From 5e6ffcea31b7d7ddef8ef1f3f81ff5ecd06dc266 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 4 Dec 2021 04:21:23 +0900
Subject: [PATCH 001/369] KeyOf Type Reference Support (#133)

---
 changelog.md            |  12 +-
 example/index.ts        |  11 +-
 package.json            |   2 +-
 readme.md               | 461 ++++++++++++++++++----------------------
 spec/schema/keyof.ts    |  13 +-
 spec/types/typebox.d.ts |  36 ++--
 src/typebox.ts          |  59 ++---
 typebox.png             | Bin 0 -> 342043 bytes
 8 files changed, 284 insertions(+), 310 deletions(-)
 create mode 100644 typebox.png

diff --git a/changelog.md b/changelog.md
index 1c65a1ae7..fcd52a1ef 100644
--- a/changelog.md
+++ b/changelog.md
@@ -1,10 +1,16 @@
+## [0.23.1](https://www.npmjs.com/package/@sinclair/typebox/v/0.23.1)
+
+Updates:
+
+- The `Type.KeyOf(...)` type can now accept references of `Type.Ref(TObject)`
+
 ## [0.23.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.23.0)
 
 Updates:
 
-- The types `Type.Namespace()` and `Type.Ref()` are promoted to `Standard`.
-- TypeBox adds a new type named `TRef<TSchema>` that is returned on calls to `Type.Ref(...)`. The `TRef` includes a `RefKind` symbol for introspection of the reference type.
-- TypeBox now maintains an internal dictionary of all schemas passed that contain an `$id` property. This dictionary is checked whenever a user attempts to reference a type and will throw if attempting to reference a target schema with no $id.
+- The types `Type.Namespace(...)` and `Type.Ref(...)` are promoted to `Standard`.
+- TypeBox now includes an additional type named `TRef<...>` that is returned on calls to `Type.Ref(...)`. The `TRef<...>` includes a new `RefKind` symbol for introspection of the reference type.
+- TypeBox now maintains an internal dictionary of all schemas passed that contain an `$id` property. This dictionary is checked whenever a user attempts to reference a type and will throw if attempting to reference a target schema with no `$id`.
 - The types `Type.Partial(...)`, `Type.Required(...)`, `Type.Omit()` and `Type.Pick(...)` now support reference types. Note that when using these functions with references, TypeBox will replicate the source schema and apply the nessasary modifiers to the replication.
 
 ## [0.22.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.22.0)
diff --git a/example/index.ts b/example/index.ts
index 922c43620..7f3a03024 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -1,15 +1,16 @@
 import { Type, Static } from '@sinclair/typebox'
 
 const T = Type.Object({
-    name:  Type.Optional(Type.String()),
-    order: Type.Number()
+    x: Type.String(),
+    y: Type.Number(),
+    z: Type.String()
 }, { $id: 'T' })
 
 const R = Type.Ref(T)
 
-const P = Type.Omit(T, ['name'])
+const K = Type.KeyOf(R)
 
-console.log(P)
+type T = Static<typeof K>
 
-type T = Static<typeof P>
+console.log(K)
 
diff --git a/package.json b/package.json
index 81f0bf75e..1b774bf59 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.23.0",
+  "version": "0.23.1",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "json-schema",
diff --git a/readme.md b/readme.md
index 92b344759..241d936c7 100644
--- a/readme.md
+++ b/readme.md
@@ -2,8 +2,12 @@
 
 <h1>TypeBox</h1>
 
+<img src="typebox.png" />
+
 <p>JSON Schema Type Builder with Static Type Resolution for TypeScript</p>
 
+
+
 [![npm version](https://badge.fury.io/js/%40sinclair%2Ftypebox.svg)](https://badge.fury.io/js/%40sinclair%2Ftypebox) [![GitHub CI](https://github.com/sinclairzx81/typebox/workflows/GitHub%20CI/badge.svg)](https://github.com/sinclairzx81/typebox/actions)
 
 </div>
@@ -24,7 +28,7 @@ $ npm install @sinclair/typebox --save
 import { Static, Type } from 'https://deno.land/x/typebox/src/typebox.ts'
 ```
 
-## Usage
+## Example
 
 ```typescript
 import { Static, Type } from '@sinclair/typebox'
@@ -38,7 +42,7 @@ type T = Static<typeof T>   // type T = string
 
 ## Overview
 
-TypeBox is a library that builds in-memory JSON Schema objects that can be statically resolved to TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox allows one to create a unified type that can be statically checked by the TypeScript compiler and runtime asserted using standard JSON Schema validation.
+TypeBox is a library that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox allows one to create a unified type that can be both statically asserted by the TypeScript compiler and runtime asserted using industry standard JSON Schema validation.
 
 TypeBox can be used as a simple tool to build up complex schemas or integrated into RPC or REST services to help validate JSON data received over the wire. TypeBox does not provide any JSON schema validation. Please use libraries such as AJV to validate schemas built with this library.
 
@@ -49,7 +53,7 @@ License MIT
 ## Contents
 - [Install](#Install)
 - [Overview](#Overview)
-- [Example](#Example)
+- [Usage](#Usage)
 - [Types](#Types)
 - [Modifiers](#Modifiers)
 - [Options](#Options)
@@ -63,7 +67,7 @@ License MIT
 
 <a name="Example"></a>
 
-## Example
+## Usage
 
 The following demonstrates TypeBox's general usage.
 
@@ -89,25 +93,25 @@ type T = {
 //
 //--------------------------------------------------------------------------------------------
 
-const T = Type.Object({             // const T = {
-    id: Type.String(),              //   type: 'object',
-    name: Type.String(),            //   properties: { 
-    timestamp: Type.Integer()       //      id: { 
-})                                  //         type: 'string' 
-                                    //      },
-                                    //      name: { 
-                                    //         type: 'string' 
-                                    //      },
-                                    //      timestamp: { 
-                                    //         type: 'integer' 
-                                    //      }
-                                    //   }, 
-                                    //   required: [
-                                    //      "id",
-                                    //      "name",
-                                    //      "timestamp"
-                                    //   ]
-                                    // } 
+const T = Type.Object({               // const T = {
+    id: Type.String(),                //   type: 'object',
+    name: Type.String(),              //   properties: { 
+    timestamp: Type.Integer()         //      id: { 
+})                                    //         type: 'string' 
+                                      //      },
+                                      //      name: { 
+                                      //         type: 'string' 
+                                      //      },
+                                      //      timestamp: { 
+                                      //         type: 'integer' 
+                                      //      }
+                                      //   }, 
+                                      //   required: [
+                                      //      "id",
+                                      //      "name",
+                                      //      "timestamp"
+                                      //   ]
+                                      // } 
 
 //--------------------------------------------------------------------------------------------
 //
@@ -115,11 +119,11 @@ const T = Type.Object({             // const T = {
 //
 //--------------------------------------------------------------------------------------------
 
-type T = Static<typeof T>           // type T = {
-                                    //    id: string,
-                                    //    name: string,
-                                    //    timestamp: number
-                                    // }
+type T = Static<typeof T>             // type T = {
+                                      //    id: string,
+                                      //    name: string,
+                                      //    timestamp: number
+                                      // }
 
 //--------------------------------------------------------------------------------------------
 //
@@ -127,9 +131,9 @@ type T = Static<typeof T>           // type T = {
 //
 //--------------------------------------------------------------------------------------------
 
-function receive(value: T) {      // ... as a Type
+function receive(value: T) {         // ... as a Type
 
-    if(JSON.validate(T, value)) { // ... as a Schema
+    if(JSON.validate(T, value)) {    // ... as a Schema
 
         // ok...
     }
@@ -145,50 +149,50 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
 │ TypeBox                        │ TypeScript                  │ JSON Schema                    │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Any()           │ type T = any                │ const T = { }                  │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Unknown()       │ type T = unknown            │ const T = { }                  │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.String()        │ type T = string             │ const T = {                    │
 │                                │                             │    type: 'string'              │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Number()        │ type T = number             │ const T = {                    │
 │                                │                             │    type: 'number'              │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Integer()       │ type T = number             │ const T = {                    │
 │                                │                             │    type: 'integer'             │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Boolean()       │ type T = boolean            │ const T = {                    │
 │                                │                             │    type: 'boolean'             │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Null()          │ type T = null               │ const T = {                    │
 │                                │                             │    type: 'null'                │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.RegEx(/foo/)	 │ type T = string             │ const T = {                    │
+│ const T = Type.RegEx(/foo/)    │ type T = string             │ const T = {                    │
 │                                │                             │    type: 'string',             │
 │                                │                             │    pattern: 'foo'              │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Literal(42)     │ type T = 42                 │ const T = {                    │
 │                                │                             │    const: 42                   │
 │                                │                             │    type: 'number'              │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Array(          │ type T = number[]           │ const T = {                    │
 │    Type.Number()               │                             │    type: 'array',              │
@@ -196,36 +200,36 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │                                │                             │      type: 'number'            │
 │                                │                             │    }                           │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Object({        │ type T = {                  │ const T = {                    │
 │   x: Type.Number(),            │    x: number,               │   type: 'object',              │
 │   y: Type.Number()             │    y: number                │   properties: {                │
 │ })                             │ }                           │      x: {                      │
 │                                │                             │        type: 'number'          │
-│   	                         │                             │      },                        │
-│   	                         │                             │      y: {                      │
-│   	                         │                             │        type: 'number'          │
+│                                │                             │      },                        │
+│                                │                             │      y: {                      │
+│                                │                             │        type: 'number'          │
 │                                │                             │      }                         │
-│   	                         │                             │   },                           │
-│   	                         │                             │   required: ['x', 'y']         │
+│                                │                             │   },                           │
+│                                │                             │   required: ['x', 'y']         │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Tuple([         │ type T = [number, number]   │ const T = {                    │
 │   Type.Number(),               │                             │    type: 'array',              │
 │   Type.Number()                │                             │    items: [                    │
 │ ])                             │                             │       {                        │
-│   	                         │                             │         type: 'number'         │
-│   	                         │                             │       }, {                     │
-│   	                         │                             │         type: 'number'         │
-│   	                         │                             │       }                        │
-│   	                         │                             │    ],                          │
-│   	                         │                             │    additionalItems: false,     │
-│   	                         │                             │    minItems: 2,                │
-│   	                         │                             │    maxItems: 2,                │
-│   	                         │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │         type: 'number'         │
+│                                │                             │       }, {                     │
+│                                │                             │         type: 'number'         │
+│                                │                             │       }                        │
+│                                │                             │    ],                          │
+│                                │                             │    additionalItems: false,     │
+│                                │                             │    minItems: 2,                │
+│                                │                             │    maxItems: 2,                │
+│                                │                             │ }                              │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ enum Foo {                     │ enum Foo {                  │ const T = {                    │
 │   A,                           │   A,                        │   anyOf: [{                    │
@@ -244,7 +248,7 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │     y: Type.Number()           │ }                           │ }                              │
 │   })                           │                             │                                │
 │ )                              │                             │                                │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Union([         │ type T = string | number    │ const T = {                    │
 │   Type.String(),               │                             │    anyOf: [{                   │
@@ -253,14 +257,14 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │                                │                             │       type: 'number'           │
 │                                │                             │    }]                          │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Intersect([     │ type T = {                  │ const T = {                    │
 │    Type.Object({               │    x: number                │    allOf: [{                   │
 │       x: Type.Number()         │ } & {                       │       type: 'object',          │
 │    }),                         │    y: number                │       properties: {            │
 │    Type.Object({               │ }                           │          a: {                  │
-│       y: Type.Number()         │                             │            type: 'number'      │    
+│       y: Type.Number()         │                             │            type: 'number'      │
 │   })                           │                             │          }                     │
 │ })                             │                             │       },                       │
 │                                │                             │       required: ['a']          │
@@ -268,23 +272,23 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │                                │                             │       type: 'object',          │
 │                                │                             │       properties: {            │
 │                                │                             │          b: {                  │
-│   	                         │                             │            type: 'number'      │
-│   	                         │                             │          }                     │
-│   	                         │                             │       },                       │
-│   	                         │                             │       required: ['b']          │
-│   	                         │                             │    }]                          │
-│   	                         │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │            type: 'number'      │
+│                                │                             │          }                     │
+│                                │                             │       },                       │
+│                                │                             │       required: ['b']          │
+│                                │                             │    }]                          │
+│                                │                             │ }                              │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Record(         │ type T = {                  │ const T = {                    │
 │    Type.String(),              │    [key: string]: number    │    type: 'object',             │
 │    Type.Number()               │ }                           │    patternProperties: {        │
-│ ) 	                         │                             │      '^.*$': {                 │
-│   	                         │                             │         type: 'number'         │
-│   	                         │                             │      }                         │
-│   	                         │                             │    }                           │
-│   	                         │                             │ }                              │
-│   	                         │                             │                                │
+│ )                              │                             │      '^.*$': {                 │
+│                                │                             │         type: 'number'         │
+│                                │                             │      }                         │
+│                                │                             │    }                           │
+│                                │                             │ }                              │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Partial(        │ type T = Partial<{          │ const T = {                    │
 │    Type.Object({               │    x: number,               │   type: 'object',              │
@@ -297,7 +301,7 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │                                │                             │     }                          │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Required(       │ type T = Required<{         │ const T = {                    │
 │    Type.Object({               │    x?: number,              │   type: 'object',              │
@@ -311,7 +315,7 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │ )                              │                             │   },                           │
 │                                │                             │   required: ['x', 'y']         │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Pick(           │ type T = Pick<{             │ const T = {                    │
 │    Type.Object({               │    x: number,               │   type: 'object',              │
@@ -345,38 +349,38 @@ TypeBox provides modifiers that can be applied to an objects properties. This al
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
 │ TypeBox                        │ TypeScript                  │ JSON Schema                    │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Object({        │ type T = {                  │ const T = {                    │
 │   name: Type.Optional(         │    name?: string,           │   type: 'object',              │
 │      Type.String(),            │ }                           │   properties: {                │
-│   )	                         │                             │      name: {                   │
+│   )                            │                             │      name: {                   │
 │ })  	                         │                             │        type: 'string'          │
-│   	                         │                             │      }                         │
-│   	                         │                             │   }                            │
-│   	                         │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │      }                         │
+│                                │                             │   }                            │
+│                                │                             │ }                              │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Object({        │ type T = {                  │ const T = {                    │
 │   name: Type.Readonly(         │    readonly name: string,   │   type: 'object',              │
 │      Type.String(),            │ }                           │   properties: {                │
-│   )	                         │                             │      name: {                   │
+│   )                            │                             │      name: {                   │
 │ })  	                         │                             │        type: 'string'          │
-│   	                         │                             │      }                         │
-│   	                         │                             │   },                           │
+│                                │                             │      }                         │
+│                                │                             │   },                           │
 │                                │                             │   required: ['name']           │
-│   	                         │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │ }                              │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Object({        │ type T = {                  │ const T = {                    │
 │   name: Type.ReadonlyOptional( │    readonly name?: string,  │   type: 'object',              │
 │      Type.String(),            │ }                           │   properties: {                │
-│   )	                         │                             │      name: {                   │
+│   )                            │                             │      name: {                   │
 │ })  	                         │                             │        type: 'string'          │
-│   	                         │                             │      }                         │
-│   	                         │                             │   }                            │
+│                                │                             │      }                         │
+│                                │                             │   }                            │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
@@ -409,25 +413,25 @@ import { Type, Static, TSchema } from '@sinclair/typebox'
 
 const Nullable = <T extends TSchema>(type: T) => Type.Union([type, Type.Null()])
 
-const T = Nullable(Type.String())            // const T = {
-                                             //   "anyOf": [{
-                                             //      type: 'string'
-                                             //   }, {
-                                             //      type: 'null'
-                                             //   }]
-                                             // }
-
-type T = Static<typeof T>                    // type T = string | null
-
-const U = Nullable(Type.Number())            // const U = {
-                                             //   "anyOf": [{
-                                             //      type: 'number'
-                                             //   }, {
-                                             //      type: 'null'
-                                             //   }]
-                                             // }
-
-type U = Static<typeof U>                    // type U = number | null
+const T = Nullable(Type.String())              // const T = {
+                                               //   "anyOf": [{
+                                               //      type: 'string'
+                                               //   }, {
+                                               //      type: 'null'
+                                               //   }]
+                                               // }
+
+type T = Static<typeof T>                      // type T = string | null
+
+const U = Nullable(Type.Number())              // const U = {
+                                               //   "anyOf": [{
+                                               //      type: 'number'
+                                               //   }, {
+                                               //      type: 'null'
+                                               //   }]
+                                               // }
+
+type U = Static<typeof U>                      // type U = number | null
 ```
 
 <a name="Reference-Types"></a>
@@ -437,61 +441,61 @@ type U = Static<typeof U>                    // type U = number | null
 Types can be referenced with `Type.Ref(...)`. To reference a type, the target type must specify an `$id`.
 
 ```typescript
-const T = Type.String({ $id: 'T' })          // const T = {
-                                             //    $id: 'T',
-                                             //    type: 'string'
-                                             // }
+const T = Type.String({ $id: 'T' })            // const T = {
+                                               //    $id: 'T',
+                                               //    type: 'string'
+                                               // }
                                              
-const R = Type.Ref(T)                        // const R = {
-                                             //    $ref: 'T'
-                                             // }
+const R = Type.Ref(T)                          // const R = {
+                                               //    $ref: 'T'
+                                               // }
 ```
 
-It can be helpful to organize shared referenced types under a common namespace. The `Type.Namespace(...)` function can be used to create a shared definition container for related types. The following creates a `Math3D` container and a `Vertex` structure that references types in the container.
+It can sometimes be helpful to organize shared referenced types under a common namespace. The `Type.Namespace(...)` function can be used to create a shared definition container for related types. The following creates a `Math3D` container and a `Vertex` structure that references types in the container.
 
 ```typescript
-const Math3D = Type.Namespace({               //  const Math3D = {
-  Vector4: Type.Object({                      //    $id: 'Math3D',
-    x: Type.Number(),                         //    $defs: {
-    y: Type.Number(),                         //      Vector4: {
-    z: Type.Number(),                         //        type: 'object',
-    w: Type.Number()                          //        properties: {
-  }),                                         //          x: { type: 'number' },
-  Vector3: Type.Object({                      //          y: { type: 'number' },
-    x: Type.Number(),                         //          z: { type: 'number' },
-    y: Type.Number(),                         //          w: { type: 'number' }
-    z: Type.Number()                          //        },
-  }),                                         //        required: ['x', 'y', 'z', 'w']
-  Vector2: Type.Object({                      //      },
-    x: Type.Number(),                         //      Vector3: {
-    y: Type.Number()                          //        type: 'object',
-  })                                          //        properties: {
-}, { $id: 'Math3D' })                         //          x: { 'type': 'number' },
-                                              //          y: { 'type': 'number' },
-                                              //          z: { 'type': 'number' }
-                                              //        },
-                                              //        required: ['x', 'y', 'z']
-                                              //      },
-                                              //      Vector2: {
-                                              //        type: 'object',
-                                              //        properties: {
-                                              //          x: { 'type': 'number' },
-                                              //          y: { 'type': 'number' },
-                                              //        },
-                                              //        required: ['x', 'y']
-                                              //      }
-                                              //    }
-                                              //  }
+const Math3D = Type.Namespace({                 //  const Math3D = {
+  Vector4: Type.Object({                        //    $id: 'Math3D',
+    x: Type.Number(),                           //    $defs: {
+    y: Type.Number(),                           //      Vector4: {
+    z: Type.Number(),                           //        type: 'object',
+    w: Type.Number()                            //        properties: {
+  }),                                           //          x: { type: 'number' },
+  Vector3: Type.Object({                        //          y: { type: 'number' },
+    x: Type.Number(),                           //          z: { type: 'number' },
+    y: Type.Number(),                           //          w: { type: 'number' }
+    z: Type.Number()                            //        },
+  }),                                           //        required: ['x', 'y', 'z', 'w']
+  Vector2: Type.Object({                        //      },
+    x: Type.Number(),                           //      Vector3: {
+    y: Type.Number()                            //        type: 'object',
+  })                                            //        properties: {
+}, { $id: 'Math3D' })                           //          x: { 'type': 'number' },
+                                                //          y: { 'type': 'number' },
+                                                //          z: { 'type': 'number' }
+                                                //        },
+                                                //        required: ['x', 'y', 'z']
+                                                //      },
+                                                //      Vector2: {
+                                                //        type: 'object',
+                                                //        properties: {
+                                                //          x: { 'type': 'number' },
+                                                //          y: { 'type': 'number' },
+                                                //        },
+                                                //        required: ['x', 'y']
+                                                //      }
+                                                //    }
+                                                //  }
 													 
-const Vertex = Type.Object({                  //  const Vertex = {
-    position: Type.Ref(Math3D, 'Vector4'),    //    type: 'object',
-    normal:   Type.Ref(Math3D, 'Vector3'),    //    properties: {
-    uv:       Type.Ref(Math3D, 'Vector2')     //      position: { $ref: 'Math3D#/$defs/Vector4' },
-})                                            //      normal: { $ref: 'Math3D#/$defs/Vector3' },
-                                              //      uv: { $ref: 'Math3D#/$defs/Vector2' }
-                                              //    },
-                                              //    required: ['position', 'normal', 'uv']
-                                              //  }
+const Vertex = Type.Object({                    //  const Vertex = {
+    position: Type.Ref(Math3D, 'Vector4'),      //    type: 'object',
+    normal:   Type.Ref(Math3D, 'Vector3'),      //    properties: {
+    uv:       Type.Ref(Math3D, 'Vector2')       //      position: { $ref: 'Math3D#/$defs/Vector4' },
+})                                              //      normal: { $ref: 'Math3D#/$defs/Vector3' },
+                                                //      uv: { $ref: 'Math3D#/$defs/Vector2' }
+                                                //    },
+                                                //    required: ['position', 'normal', 'uv']
+                                                //  }
 ```
 
 <a name="Recursive-Types"></a>
@@ -501,30 +505,30 @@ const Vertex = Type.Object({                  //  const Vertex = {
 Recursive types can be created with the `Type.Rec(...)` function. The following creates a `Node` type that contains an array of inner Nodes. Note that due to current restrictions on TypeScript inference, it is not possible for TypeBox to statically infer for recursive types. TypeBox will infer the inner recursive type as `any`.
 
 ```typescript
-const Node = Type.Rec(Self => Type.Object({   // const Node = {
-  id:    Type.String(),                       //   $id: 'Node',
-  nodes: Type.Array(Self),                    //   $ref: 'Node#/$defs/self',
-}), { $id: 'Node' })                          //   $defs: {
-                                              //     self: {
-                                              //       type: 'object',
-                                              //       properties: {
-                                              //         id: {
-                                              //           type: 'string'
-                                              //         },
-                                              //         nodes: {
-                                              //            type: 'array',
-                                              //            items: {
-                                              //              $ref: 'Node#/$defs/self'
-                                              //            }
-                                              //         }
-                                              //      }
-                                              //    }
-                                              // }
-
-type Node = Static<typeof Node>               // type Node = {
-                                              //   id: string
-                                              //   nodes: any[]
-                                              //
+const Node = Type.Rec(Self => Type.Object({    // const Node = {
+  id:    Type.String(),                        //   $id: 'Node',
+  nodes: Type.Array(Self),                     //   $ref: 'Node#/$defs/self',
+}), { $id: 'Node' })                           //   $defs: {
+                                               //     self: {
+                                               //       type: 'object',
+                                               //       properties: {
+                                               //         id: {
+                                               //           type: 'string'
+                                               //         },
+                                               //         nodes: {
+                                               //            type: 'array',
+                                               //            items: {
+                                               //              $ref: 'Node#/$defs/self'
+                                               //            }
+                                               //         }
+                                               //      }
+                                               //    }
+                                               // }
+
+type Node = Static<typeof Node>                // type Node = {
+                                               //   id: string
+                                               //   nodes: any[]
+                                               // }
 
 function visit(node: Node) {
     for(const inner of node.nodes) {
@@ -542,7 +546,7 @@ In addition to JSON schema types, TypeBox provides several extended types that a
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
 │ TypeBox                        │ TypeScript                  │ Extended Schema                │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Constructor([   │ type T = new (              │ const T = {                    │
 │    Type.String(),              │  arg0: string,              │   type: 'constructor'          │
@@ -555,7 +559,7 @@ In addition to JSON schema types, TypeBox provides several extended types that a
 │                                │                             │      type: 'boolean'           │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Function([      │ type T = (                  │ const T = {                    │
 |    Type.String(),              │  arg0: string,              │   type : 'function',           │
@@ -568,7 +572,7 @@ In addition to JSON schema types, TypeBox provides several extended types that a
 │                                │                             │      type: 'boolean'           │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Promise(        │ type T = Promise<string>    │ const T = {                    │
 │    Type.String()               │                             │   type: 'promise',             │
@@ -576,17 +580,17 @@ In addition to JSON schema types, TypeBox provides several extended types that a
 │                                │                             │      type: 'string'            │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Undefined()     │ type T = undefined          │ const T = {                    │
 │                                │                             │   type: 'undefined'            │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Void()          │ type T = void               │ const T = {                    │
 │                                │                             │   type: 'void'                 │
 │                                │                             │ }                              │
-│   	                         │                             │                                │
+│                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
@@ -594,7 +598,7 @@ In addition to JSON schema types, TypeBox provides several extended types that a
 
 ### Strict
 
-TypeBox includes the properties `kind` and `modifier` on each underlying schema. These properties are used to help TypeBox statically resolve the schemas to the appropriate TypeScript type as well as apply the appropriate modifiers to an objects properties (such as optional). These properties are not strictly valid JSON schema so in some cases it may be desirable to omit them. TypeBox provides a `Type.Strict()` function that will omit these properties if nessasary.
+TypeBox schemas contain the properties `kind` and `modifier`. These properties are provided to enable runtime type reflection on schemas, as well as helping TypeBox apply the appropriate static type inference rules. These properties are not strictly valid JSON schema so in some cases it may be desirable to omit them. TypeBox provides a `Type.Strict()` function that will omit these properties if nessasary.
 
 ```typescript
 const T = Type.Object({                       // const T = {
@@ -623,7 +627,7 @@ const U = Type.Strict(T)                      // const U = {
 
 ### Validation
 
-TypeBox does not provide JSON schema validation functionality, so users will need to select an appropriate JSON Schema validator for their language or framework. TypeBox targets JSON Schema draft `2019-09` so any validator capable of draft `2019-09` should be fine. A good library to use for validation in JavaScript environments is [AJV](https://www.npmjs.com/package/ajv). The following example shows setting up AJV 7 to work with TypeBox.
+TypeBox does not provide JSON schema validation so users will need to select an appropriate JSON Schema validator for their needs. TypeBox schemas target JSON Schema draft `2019-09` so any validator capable of draft `2019-09` should be fine. A good library to use for validation in JavaScript environments is [AJV](https://www.npmjs.com/package/ajv). The following example shows setting up AJV 7 to work with TypeBox.
 
 ```bash
 $ npm install ajv ajv-formats --save
@@ -689,64 +693,11 @@ const ok = ajv.validate(User, {
 }) // -> ok
 ```
 
-#### Reference Types
-
-Referenced types can be added to AJV with the `ajv.addSchema(...)` function. The following moves the `userId` and `email` property types into a `Type.Namespace(...)` and registers the box with AJV.
-
-```typescript
-//--------------------------------------------------------------------------------------------
-//
-// Shared Types
-//
-//--------------------------------------------------------------------------------------------
-
-const Shared = Type.Namespace({
-  UserId: Type.String({ format: 'uuid' }),
-  Email:  Type.String({ format: 'email' })
-}, { $id: 'Shared' })
-
-//--------------------------------------------------------------------------------------------
-//
-// Setup Validator and Register Shared Types
-//
-//--------------------------------------------------------------------------------------------
-
-const ajv = addFormats(new Ajv({}), [...])
-  .addKeyword('kind')
-  .addKeyword('modifier')
-  .addSchema(Shared) // <-- Register Shared Types
-
-//--------------------------------------------------------------------------------------------
-//
-// Create a TypeBox type
-//
-//--------------------------------------------------------------------------------------------
-
-const User = Type.Object({
-  userId: Type.Ref(Shared, 'UserId'),
-  email:  Type.Ref(Shared, 'Email'),
-  online: Type.Boolean()
-}, { additionalProperties: false })
-
-//--------------------------------------------------------------------------------------------
-//
-// Validate Data
-//
-//--------------------------------------------------------------------------------------------
-
-const ok = ajv.validate(User, { 
-    userId: '68b4b1d8-0db6-468d-b551-02069a692044', 
-    email:  'dave@domain.com',
-    online: true
-}) // -> ok
-
-```
-
-Please refer to the official AJV [documentation](https://ajv.js.org/guide/getting-started.html) for additional information.
+Please refer to the official AJV [documentation](https://ajv.js.org/guide/getting-started.html) for additional information on using AJV.
 
 ### OpenAPI
 
-TypeBox can be used to create schemas for OpenAPI, however users should be aware of the various differences between the JSON Schema and OpenAPI specifications. Two common instances where OpenAPI diverges from the JSON Schema specification is OpenAPI's handling of `string enum` and `nullable`. The following shows how you can use TypeBox to construct these types.
+TypeBox can be used to create schemas for OpenAPI, however users should be aware of the various disparities between the JSON Schema and OpenAPI schema specifications. Two common instances where OpenAPI diverges from the JSON Schema specification is OpenAPI's handling of string enums and nullable schemas. The following shows how you can use TypeBox to construct these types.
 
 ```typescript
 import { Type, Static, TNull, TLiteral, TUnion, TSchema } from '@sinclair/typebox'
@@ -761,12 +712,12 @@ function Nullable<T extends TSchema>(schema: T): TUnion<[T, TNull]> {
     return { ...schema, nullable: true } as any
 }
 
-const T = Nullable(Type.String())        // const T = {
-                                         //   type: 'string',
-                                         //   nullable: true
-                                         // }
+const T = Nullable(Type.String())              // const T = {
+                                               //   type: 'string',
+                                               //   nullable: true
+                                               // }
 
-type T = Static<typeof T>                // type T = string | null
+type T = Static<typeof T>                      // type T = string | null
 
 //--------------------------------------------------------------------------------------------
 //
@@ -780,9 +731,9 @@ function StringUnion<T extends string[]>(values: [...T]): TUnion<IntoStringUnion
     return { enum: values } as any
 }
 
-const T = StringUnion(['A', 'B', 'C'])   // const T = {
-                                         //    enum: ['A', 'B', 'C']
-                                         // }
+const T = StringUnion(['A', 'B', 'C'])          // const T = {
+                                                //    enum: ['A', 'B', 'C']
+                                                // }
 
-type T = Static<typeof T>                // type T = 'A' | 'B' | 'C'
+type T = Static<typeof T>                       // type T = 'A' | 'B' | 'C'
 ```
diff --git a/spec/schema/keyof.ts b/spec/schema/keyof.ts
index baa1ec940..7ef2b0810 100644
--- a/spec/schema/keyof.ts
+++ b/spec/schema/keyof.ts
@@ -1,5 +1,6 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Type }        from '@sinclair/typebox'
+import { ok, fail }    from './validate'
+import { strictEqual } from 'assert'
 
 describe("KeyOf", () => {
     it('Should validate with all object keys as a kind of union', () => {
@@ -36,4 +37,12 @@ describe("KeyOf", () => {
         fail(T, 'y')
         ok(T, 'z')
     })
+
+    it('Should construct new object when targetting reference', () => {
+        const T = Type.Object({ a: Type.String(), b: Type.String() }, { $id: 'T' })
+        const R = Type.Ref(T)
+        const P = Type.KeyOf(R, [])
+        strictEqual(P.enum[0], 'a')
+        strictEqual(P.enum[1], 'b')
+     })
 })
diff --git a/spec/types/typebox.d.ts b/spec/types/typebox.d.ts
index df723db3a..2c2f46d9b 100644
--- a/spec/types/typebox.d.ts
+++ b/spec/types/typebox.d.ts
@@ -142,6 +142,11 @@ export interface TEnum<T extends TEnumKey[]> extends TSchema, CustomOptions {
     kind: typeof EnumKind;
     anyOf: T;
 }
+export interface TRef<T extends TSchema> extends TSchema, CustomOptions {
+    $static: Static<T>;
+    kind: typeof RefKind;
+    $ref: string;
+}
 export interface TString extends TSchema, StringOptions<string> {
     $static: string;
     kind: typeof StringKind;
@@ -175,11 +180,6 @@ export interface TAny extends TSchema, CustomOptions {
     $static: any;
     kind: typeof AnyKind;
 }
-export interface TRef<T extends TSchema> extends TSchema, CustomOptions {
-    $static: Static<T>;
-    kind: typeof RefKind;
-    $ref: string;
-}
 export declare const ConstructorKind: unique symbol;
 export declare const FunctionKind: unique symbol;
 export declare const PromiseKind: unique symbol;
@@ -215,9 +215,9 @@ export interface TVoid extends TSchema, CustomOptions {
     kind: typeof VoidKind;
     type: 'void';
 }
-export declare type Pickable = TObject<TProperties> | TRef<TObject<TProperties>>;
-export declare type PickablePropertyKeys<T extends Pickable> = T extends TObject<infer U> ? keyof U : T extends TRef<TObject<infer U>> ? keyof U : never;
-export declare type PickableProperties<T extends Pickable> = T extends TObject<infer U> ? U : T extends TRef<TObject<infer U>> ? U : never;
+export declare type Selectable = TObject<TProperties> | TRef<TObject<TProperties>>;
+export declare type SelectablePropertyKeys<T extends Selectable> = T extends TObject<infer U> ? keyof U : T extends TRef<TObject<infer U>> ? keyof U : never;
+export declare type SelectableProperties<T extends Selectable> = T extends TObject<infer U> ? U : T extends TRef<TObject<infer U>> ? U : never;
 export declare type UnionToIntersect<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 export declare type StaticReadonlyOptionalPropertyKeys<T extends TProperties> = {
     [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never;
@@ -271,7 +271,7 @@ export declare type StaticFunction<T extends readonly TSchema[], U extends TSche
 export declare type StaticPromise<T extends TSchema> = Promise<Static<T>>;
 export declare type Static<T extends TSchema> = T['$static'];
 export declare class TypeBuilder {
-    private readonly schemas;
+    protected readonly schemas: Map<string, TSchema>;
     /** `Standard` Modifies an object property to be both readonly and optional */
     ReadonlyOptional<T extends TSchema>(item: T): TReadonlyOptional<T>;
     /** `Standard` Modifies an object property to be readonly */
@@ -308,18 +308,18 @@ export declare class TypeBuilder {
     Unknown(options?: CustomOptions): TUnknown;
     /** `Standard` Creates an any type */
     Any(options?: CustomOptions): TAny;
-    /** `Standard` Creates a keyof type from the given object */
-    KeyOf<T extends TObject<TProperties>>(object: T, options?: CustomOptions): TKeyOf<(keyof T['properties'])[]>;
     /** `Standard` Creates a record type */
     Record<K extends TRecordKey, T extends TSchema>(key: K, value: T, options?: ObjectOptions): TRecord<K, T>;
+    /** `Standard` Creates a keyof type from the given object */
+    KeyOf<T extends TObject<TProperties> | TRef<TObject<TProperties>>>(object: T, options?: CustomOptions): TKeyOf<SelectablePropertyKeys<T>[]>;
     /** `Standard` Makes all properties in the given object type required */
     Required<T extends TObject<TProperties> | TRef<TObject<TProperties>>>(object: T, options?: ObjectOptions): TObject<StaticRequired<T['properties']>>;
     /** `Standard` Makes all properties in the given object type optional */
     Partial<T extends TObject<TProperties> | TRef<TObject<TProperties>>>(object: T, options?: ObjectOptions): TObject<StaticPartial<T['properties']>>;
     /** `Standard` Picks property keys from the given object type */
-    Pick<T extends TObject<TProperties> | TRef<TObject<TProperties>>, K extends PickablePropertyKeys<T>[]>(object: T, keys: [...K], options?: ObjectOptions): TObject<Pick<PickableProperties<T>, K[number]>>;
+    Pick<T extends TObject<TProperties> | TRef<TObject<TProperties>>, K extends SelectablePropertyKeys<T>[]>(object: T, keys: [...K], options?: ObjectOptions): TObject<Pick<SelectableProperties<T>, K[number]>>;
     /** `Standard` Omits property keys from the given object type */
-    Omit<T extends TObject<TProperties> | TRef<TObject<TProperties>>, K extends PickablePropertyKeys<T>[]>(object: T, keys: [...K], options?: ObjectOptions): TObject<Omit<PickableProperties<T>, K[number]>>;
+    Omit<T extends TObject<TProperties> | TRef<TObject<TProperties>>, K extends SelectablePropertyKeys<T>[]>(object: T, keys: [...K], options?: ObjectOptions): TObject<Omit<SelectableProperties<T>, K[number]>>;
     /** `Standard` Omits the `kind` and `modifier` properties from the underlying schema */
     Strict<T extends TSchema>(schema: T, options?: CustomOptions): T;
     /** `Extended` Creates a constructor type */
@@ -335,14 +335,14 @@ export declare class TypeBuilder {
     /** `Standard` Creates a namespace for a set of related types */
     Namespace<T extends TDefinitions>($defs: T, options?: CustomOptions): TNamespace<T>;
     /** `Standard` References a type within a namespace. The referenced namespace must specify an `$id` */
-    Ref<T extends TNamespace<TDefinitions>, K extends keyof T['$defs']>(box: T, key: K): TRef<T['$defs'][K]>;
+    Ref<T extends TNamespace<TDefinitions>, K extends keyof T['$defs']>(namespace: T, key: K): TRef<T['$defs'][K]>;
     /** `Standard` References type. The referenced type must specify an `$id` */
     Ref<T extends TSchema>(schema: T): TRef<T>;
     /** `Experimental` Creates a recursive type */
     Rec<T extends TSchema>(callback: (self: TAny) => T, options?: CustomOptions): T;
-    /** Stores this schema if it contains an $id. This function is used for later referencing. */
-    private Store;
-    /** Resolves a schema by $id. May resolve recursively if the target is a TRef. */
-    private Resolve;
+    /** Conditionally stores and schema if it contains an $id and returns.  */
+    protected Store(schema: any): any;
+    /** Conditionally dereferences a schema if RefKind. Otherwise return argument. */
+    protected Deref(schema: any): any;
 }
 export declare const Type: TypeBuilder;
diff --git a/src/typebox.ts b/src/typebox.ts
index db18c4cc4..3c47cc9e3 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -62,6 +62,10 @@ export const UnknownKind   = Symbol('UnknownKind')
 export const AnyKind       = Symbol('AnyKind')
 export const RefKind       = Symbol('RefKind')
 
+// --------------------------------------------------------------------------
+// Options
+// --------------------------------------------------------------------------
+
 export interface CustomOptions {
     $id?: string
     title?: string
@@ -109,7 +113,7 @@ export type ObjectOptions = {
 } & CustomOptions
 
 // --------------------------------------------------------------------------
-// Namespacing
+// Namespace
 // --------------------------------------------------------------------------
 
 export type TDefinitions                       = { [key: string]: TSchema }
@@ -141,6 +145,7 @@ export interface TKeyOf     <T extends TKey[]>                        extends TS
 export interface TArray     <T extends TSchema>                       extends TSchema, ArrayOptions          { $static: StaticArray<T>,     kind: typeof ArrayKind,     type: 'array', items: T } 
 export interface TLiteral   <T extends TValue>                        extends TSchema, CustomOptions         { $static: StaticLiteral<T>,   kind: typeof LiteralKind,   const: T }
 export interface TEnum      <T extends TEnumKey[]>                    extends TSchema, CustomOptions         { $static: StaticEnum<T>,      kind: typeof EnumKind,      anyOf: T }
+export interface TRef       <T extends TSchema>                       extends TSchema, CustomOptions         { $static: Static<T>,          kind: typeof RefKind,       $ref: string  }
 export interface TString                                              extends TSchema, StringOptions<string> { $static: string,             kind: typeof StringKind,    type: 'string' }
 export interface TNumber                                              extends TSchema, NumberOptions         { $static: number,             kind: typeof NumberKind,    type: 'number' }
 export interface TInteger                                             extends TSchema, NumberOptions         { $static: number,             kind: typeof IntegerKind,   type: 'integer' } 
@@ -148,7 +153,7 @@ export interface TBoolean                                             extends TS
 export interface TNull                                                extends TSchema, CustomOptions         { $static: null,               kind: typeof NullKind,      type: 'null' }
 export interface TUnknown                                             extends TSchema, CustomOptions         { $static: unknown,            kind: typeof UnknownKind }
 export interface TAny                                                 extends TSchema, CustomOptions         { $static: any,                kind: typeof AnyKind }
-export interface TRef<T extends TSchema>                              extends TSchema, CustomOptions         { $static: Static<T>,          kind: typeof RefKind,       $ref: string  }
+
 
 // --------------------------------------------------------------------------
 // Extended Schema Types
@@ -168,10 +173,10 @@ export interface TVoid                                                 extends T
 // --------------------------------------------------------------------------
 // Utility Types
 // --------------------------------------------------------------------------
-export type Pickable = TObject<TProperties> | TRef<TObject<TProperties>>
-export type PickablePropertyKeys<T extends Pickable> = T extends TObject<infer U> ? keyof U : T extends TRef<TObject<infer U>> ? keyof U : never
-export type PickableProperties  <T extends Pickable> = T extends TObject<infer U> ? U : T extends TRef<TObject<infer U>> ? U : never
 
+export type Selectable = TObject<TProperties> | TRef<TObject<TProperties>>
+export type SelectablePropertyKeys             <T extends Selectable>          = T extends TObject<infer U> ? keyof U : T extends TRef<TObject<infer U>> ? keyof U : never
+export type SelectableProperties               <T extends Selectable>          = T extends TObject<infer U> ? U : T extends TRef<TObject<infer U>> ? U : never
 export type UnionToIntersect<U>                                                = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never
 export type StaticReadonlyOptionalPropertyKeys <T extends TProperties>         = { [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never }[keyof T]
 export type StaticReadonlyPropertyKeys         <T extends TProperties>         = { [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never }[keyof T]
@@ -246,7 +251,8 @@ function clone(object: any): any {
 // --------------------------------------------------------------------------
 
 export class TypeBuilder {
-    private readonly schemas = new Map<string, TSchema>()
+
+    protected readonly schemas = new Map<string, TSchema>()
 
     /** `Standard` Modifies an object property to be both readonly and optional */
     public ReadonlyOptional<T extends TSchema>(item: T): TReadonlyOptional<T> {
@@ -356,12 +362,6 @@ export class TypeBuilder {
     public Any(options: CustomOptions = {}): TAny {
         return this.Store({ ...options, kind: AnyKind })
     }
-
-    /** `Standard` Creates a keyof type from the given object */
-    public KeyOf<T extends TObject<TProperties>>(object: T, options: CustomOptions = {}): TKeyOf<(keyof T['properties'])[]> {
-        const keys = Object.keys(object.properties)
-        return this.Store({...options, kind: KeyOfKind, type: 'string', enum: keys })
-    }
     
     /** `Standard` Creates a record type */
     public Record<K extends TRecordKey, T extends TSchema>(key: K, value: T, options: ObjectOptions = {}): TRecord<K, T> {
@@ -376,10 +376,17 @@ export class TypeBuilder {
         })()
         return this.Store({ ...options, kind: RecordKind, type: 'object', patternProperties: { [pattern]: value } })
     }
-    
+
+    /** `Standard` Creates a keyof type from the given object */
+    public KeyOf<T extends TObject<TProperties> | TRef<TObject<TProperties>>>(object: T, options: CustomOptions = {}): TKeyOf<SelectablePropertyKeys<T>[]> {
+        const source = this.Deref(object)
+        const keys = Object.keys(source.properties)
+        return this.Store({...options, kind: KeyOfKind, type: 'string', enum: keys })
+    }
+
     /** `Standard` Makes all properties in the given object type required */
     public Required<T extends TObject<TProperties> | TRef<TObject<TProperties>>>(object: T, options: ObjectOptions = {}): TObject<StaticRequired<T['properties']>> {
-        const source = this.Resolve(object)
+        const source = this.Deref(object)
         const schema = { ...clone(source), ...options }
         schema.required = Object.keys(schema.properties)
         for(const key of Object.keys(schema.properties)) {
@@ -396,7 +403,7 @@ export class TypeBuilder {
     
     /** `Standard` Makes all properties in the given object type optional */
     public Partial<T extends TObject<TProperties> | TRef<TObject<TProperties>>>(object: T, options: ObjectOptions = {}): TObject<StaticPartial<T['properties']>> {
-        const source = this.Resolve(object)
+        const source = this.Deref(object)
         const schema = { ...clone(source), ...options }
         delete schema.required
         for(const key of Object.keys(schema.properties)) {
@@ -412,8 +419,8 @@ export class TypeBuilder {
     }
     
     /** `Standard` Picks property keys from the given object type */
-    public Pick<T extends TObject<TProperties> | TRef<TObject<TProperties>>, K extends PickablePropertyKeys<T>[]>(object: T, keys: [...K], options: ObjectOptions = {}): TObject<Pick<PickableProperties<T>, K[number]>> {
-        const source = this.Resolve(object)
+    public Pick<T extends TObject<TProperties> | TRef<TObject<TProperties>>, K extends SelectablePropertyKeys<T>[]>(object: T, keys: [...K], options: ObjectOptions = {}): TObject<Pick<SelectableProperties<T>, K[number]>> {
+        const source = this.Deref(object)
         const schema = { ...clone(source), ...options }
         schema.required = schema.required ? schema.required.filter((key: K) => keys.includes(key as any)) : undefined
         for(const key of Object.keys(schema.properties)) {
@@ -423,8 +430,8 @@ export class TypeBuilder {
     }
     
     /** `Standard` Omits property keys from the given object type */
-    public Omit<T extends TObject<TProperties> | TRef<TObject<TProperties>>, K extends PickablePropertyKeys<T>[]>(object: T, keys: [...K], options: ObjectOptions = {}):TObject<Omit<PickableProperties<T>, K[number]>> {
-        const source = this.Resolve(object)
+    public Omit<T extends TObject<TProperties> | TRef<TObject<TProperties>>, K extends SelectablePropertyKeys<T>[]>(object: T, keys: [...K], options: ObjectOptions = {}):TObject<Omit<SelectableProperties<T>, K[number]>> {
+        const source = this.Deref(object)
         const schema = { ...clone(source), ...options }
         schema.required = schema.required ? schema.required.filter((key: string) => !keys.includes(key as any)) : undefined
         for(const key of Object.keys(schema.properties)) {
@@ -469,7 +476,7 @@ export class TypeBuilder {
     }
     
     /** `Standard` References a type within a namespace. The referenced namespace must specify an `$id` */
-    public Ref<T extends TNamespace<TDefinitions>, K extends keyof T['$defs']>(box: T, key: K): TRef<T['$defs'][K]>
+    public Ref<T extends TNamespace<TDefinitions>, K extends keyof T['$defs']>(namespace: T, key: K): TRef<T['$defs'][K]>
     
     /** `Standard` References type. The referenced type must specify an `$id` */
     public Ref<T extends TSchema>(schema: T): TRef<T>
@@ -498,18 +505,18 @@ export class TypeBuilder {
         return this.Store({ ...options, $ref: `${$id}#/$defs/self`, $defs: { self } })
     }
 
-    /** Stores this schema if it contains an $id. This function is used for later referencing. */
-    private Store(schema: any): any {
+    /** Conditionally stores and schema if it contains an $id and returns.  */
+    protected Store(schema: any): any {
         if(!schema.$id) return schema
-        this.schemas.set(schema.$id, schema)
+        this.schemas.set(schema.$id, schema as any)
         return schema
     }
 
-    /** Resolves a schema by $id. May resolve recursively if the target is a TRef. */
-    private Resolve(schema: any): any {
+    /** Conditionally dereferences a schema if RefKind. Otherwise return argument. */
+    protected Deref(schema: any): any {
         if(schema.kind !== RefKind) return schema
         if(!this.schemas.has(schema.$ref)) throw Error(`Unable to locate schema with $id '${schema.$ref}'`)
-        return this.Resolve(this.schemas.get(schema.$ref)!)
+        return this.Deref(this.schemas.get(schema.$ref)!)
     }
 }
 
diff --git a/typebox.png b/typebox.png
new file mode 100644
index 0000000000000000000000000000000000000000..d55615fcea711801022a6d577bf0d3988e63bd7b
GIT binary patch
literal 342043
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

literal 0
HcmV?d00001


From c400efaafaf988785c6af34d2c3a3df2deabd37d Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 4 Dec 2021 04:23:11 +0900
Subject: [PATCH 002/369] Documentation

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 241d936c7..aa474d8d3 100644
--- a/readme.md
+++ b/readme.md
@@ -2,7 +2,7 @@
 
 <h1>TypeBox</h1>
 
-<img src="typebox.png" />
+<img src="https://github.com/sinclairzx81/typebox/blob/master/typebox.png?raw=true" />
 
 <p>JSON Schema Type Builder with Static Type Resolution for TypeScript</p>
 

From ecb7d85c68e60d8511d13f7c5d30ffafbbdba69b Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 4 Dec 2021 04:39:19 +0900
Subject: [PATCH 003/369] Documentation

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index aa474d8d3..66589972d 100644
--- a/readme.md
+++ b/readme.md
@@ -42,7 +42,7 @@ type T = Static<typeof T>   // type T = string
 
 ## Overview
 
-TypeBox is a library that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox allows one to create a unified type that can be both statically asserted by the TypeScript compiler and runtime asserted using industry standard JSON Schema validation.
+TypeBox is a library that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox allows one to create a unified type that can be both statically asserted by the TypeScript compiler and runtime asserted using standard JSON Schema validation.
 
 TypeBox can be used as a simple tool to build up complex schemas or integrated into RPC or REST services to help validate JSON data received over the wire. TypeBox does not provide any JSON schema validation. Please use libraries such as AJV to validate schemas built with this library.
 

From 00de70a118c40934d49d941e683a5c65168f4705 Mon Sep 17 00:00:00 2001
From: Doni Rubiagatra <rubiagatra@gmail.com>
Date: Sun, 19 Dec 2021 14:28:52 +0800
Subject: [PATCH 004/369] Documentation

---
 readme.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/readme.md b/readme.md
index 66589972d..a2e4aed56 100644
--- a/readme.md
+++ b/readme.md
@@ -263,19 +263,19 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │    Type.Object({               │    x: number                │    allOf: [{                   │
 │       x: Type.Number()         │ } & {                       │       type: 'object',          │
 │    }),                         │    y: number                │       properties: {            │
-│    Type.Object({               │ }                           │          a: {                  │
+│    Type.Object({               │ }                           │          x: {                  │
 │       y: Type.Number()         │                             │            type: 'number'      │
 │   })                           │                             │          }                     │
 │ })                             │                             │       },                       │
-│                                │                             │       required: ['a']          │
+│                                │                             │       required: ['x']          │
 │                                │                             │    }, {                        │
 │                                │                             │       type: 'object',          │
 │                                │                             │       properties: {            │
-│                                │                             │          b: {                  │
+│                                │                             │          y: {                  │
 │                                │                             │            type: 'number'      │
 │                                │                             │          }                     │
 │                                │                             │       },                       │
-│                                │                             │       required: ['b']          │
+│                                │                             │       required: ['y']          │
 │                                │                             │    }]                          │
 │                                │                             │ }                              │
 │                                │                             │                                │

From 62c85bac0fde54314e4b48ad6b870880f8aeeb82 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 22 Dec 2021 23:51:37 +0900
Subject: [PATCH 005/369] Strict Typing on Store and Deref

---
 package.json            |  2 +-
 spec/types/typebox.d.ts |  4 ++--
 src/typebox.ts          | 18 ++++++++++--------
 3 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/package.json b/package.json
index 1b774bf59..cef6d5b2f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.23.1",
+  "version": "0.23.2",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "json-schema",
diff --git a/spec/types/typebox.d.ts b/spec/types/typebox.d.ts
index 2c2f46d9b..de83d985b 100644
--- a/spec/types/typebox.d.ts
+++ b/spec/types/typebox.d.ts
@@ -341,8 +341,8 @@ export declare class TypeBuilder {
     /** `Experimental` Creates a recursive type */
     Rec<T extends TSchema>(callback: (self: TAny) => T, options?: CustomOptions): T;
     /** Conditionally stores and schema if it contains an $id and returns.  */
-    protected Store(schema: any): any;
+    protected Store<T extends TSchema | TNamespace<TDefinitions>, S = Omit<T, '$static'>>(schema: S): T;
     /** Conditionally dereferences a schema if RefKind. Otherwise return argument. */
-    protected Deref(schema: any): any;
+    protected Deref<T extends TSchema>(schema: T): any;
 }
 export declare const Type: TypeBuilder;
diff --git a/src/typebox.ts b/src/typebox.ts
index 3c47cc9e3..aeeb30849 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -506,17 +506,19 @@ export class TypeBuilder {
     }
 
     /** Conditionally stores and schema if it contains an $id and returns.  */
-    protected Store(schema: any): any {
-        if(!schema.$id) return schema
-        this.schemas.set(schema.$id, schema as any)
-        return schema
+    protected Store<T extends TSchema | TNamespace<TDefinitions>, S = Omit<T, '$static'>>(schema: S): T {
+        const $schema: any = schema
+        if(!$schema['$id']) return $schema
+        this.schemas.set($schema['$id'], $schema)
+        return $schema
     }
 
     /** Conditionally dereferences a schema if RefKind. Otherwise return argument. */
-    protected Deref(schema: any): any {
-        if(schema.kind !== RefKind) return schema
-        if(!this.schemas.has(schema.$ref)) throw Error(`Unable to locate schema with $id '${schema.$ref}'`)
-        return this.Deref(this.schemas.get(schema.$ref)!)
+    protected Deref<T extends TSchema>(schema: T): any {
+        const $schema: any = schema
+        if($schema['kind'] !== RefKind) return schema
+        if(!this.schemas.has($schema['$ref'])) throw Error(`Unable to locate schema with $id '${$schema['$ref']}'`)
+        return this.Deref(this.schemas.get($schema['$ref'])!)
     }
 }
 

From 4e44e691a2d53aaf8221af69fd70846fc2b1c165 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 22 Dec 2021 23:54:01 +0900
Subject: [PATCH 006/369] Strict Typing on Store and Deref

---
 src/typebox.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/typebox.ts b/src/typebox.ts
index aeeb30849..4dd4864a1 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -505,7 +505,7 @@ export class TypeBuilder {
         return this.Store({ ...options, $ref: `${$id}#/$defs/self`, $defs: { self } })
     }
 
-    /** Conditionally stores and schema if it contains an $id and returns.  */
+    /** Conditionally stores and schema if it contains an $id and returns  */
     protected Store<T extends TSchema | TNamespace<TDefinitions>, S = Omit<T, '$static'>>(schema: S): T {
         const $schema: any = schema
         if(!$schema['$id']) return $schema
@@ -513,7 +513,7 @@ export class TypeBuilder {
         return $schema
     }
 
-    /** Conditionally dereferences a schema if RefKind. Otherwise return argument. */
+    /** Conditionally dereferences a schema if RefKind. Otherwise return argument */
     protected Deref<T extends TSchema>(schema: T): any {
         const $schema: any = schema
         if($schema['kind'] !== RefKind) return schema

From 5c690d681d1e55bf95415f48db3844c13bbd79d5 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 22 Dec 2021 23:55:51 +0900
Subject: [PATCH 007/369] Strict Typing on Store and Deref

---
 spec/types/typebox.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/spec/types/typebox.d.ts b/spec/types/typebox.d.ts
index de83d985b..3eb849c20 100644
--- a/spec/types/typebox.d.ts
+++ b/spec/types/typebox.d.ts
@@ -340,9 +340,9 @@ export declare class TypeBuilder {
     Ref<T extends TSchema>(schema: T): TRef<T>;
     /** `Experimental` Creates a recursive type */
     Rec<T extends TSchema>(callback: (self: TAny) => T, options?: CustomOptions): T;
-    /** Conditionally stores and schema if it contains an $id and returns.  */
+    /** Conditionally stores and schema if it contains an $id and returns  */
     protected Store<T extends TSchema | TNamespace<TDefinitions>, S = Omit<T, '$static'>>(schema: S): T;
-    /** Conditionally dereferences a schema if RefKind. Otherwise return argument. */
+    /** Conditionally dereferences a schema if RefKind. Otherwise return argument */
     protected Deref<T extends TSchema>(schema: T): any;
 }
 export declare const Type: TypeBuilder;

From 2149b290d2a6870d1d6360fbe942ae271d987a5d Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 17 Jan 2022 23:40:34 +0900
Subject: [PATCH 008/369] Updates

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index a2e4aed56..1f31ffca7 100644
--- a/readme.md
+++ b/readme.md
@@ -697,7 +697,7 @@ Please refer to the official AJV [documentation](https://ajv.js.org/guide/gettin
 
 ### OpenAPI
 
-TypeBox can be used to create schemas for OpenAPI, however users should be aware of the various disparities between the JSON Schema and OpenAPI schema specifications. Two common instances where OpenAPI diverges from the JSON Schema specification is OpenAPI's handling of string enums and nullable schemas. The following shows how you can use TypeBox to construct these types.
+TypeBox can be used to create schemas for OpenAPI, however users should be mindful of some disparities between the JSON Schema and OpenAPI for versions prior to OpenAPI 3.1. Two common instances where OpenAPI diverges is the handling nullable and string enum schemas types. The following shows how you can use TypeBox to construct these types.
 
 ```typescript
 import { Type, Static, TNull, TLiteral, TUnion, TSchema } from '@sinclair/typebox'

From b7a9c23bb9a1db9b5d61965ddf4f03d582d371cf Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 18 Jan 2022 01:53:53 +0900
Subject: [PATCH 009/369] Additional Union Test

---
 spec/schema/union.ts | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/spec/schema/union.ts b/spec/schema/union.ts
index c1e3c859a..3d66dd9a0 100644
--- a/spec/schema/union.ts
+++ b/spec/schema/union.ts
@@ -21,6 +21,14 @@ describe('Union', () => {
         ok(T, { b: 'world' })
     })
 
+    it('Should fail to validate for descriminated union types', () => {
+        const A = Type.Object({ kind: Type.Literal('A'), value: Type.String() })
+        const B = Type.Object({ kind: Type.Literal('B'), value: Type.Number() })
+        const T = Type.Union([A, B])
+        fail(T, { kind: 'A', value:  42 })     // expect { kind: 'A', value: string } 
+        fail(T, { kind: 'B', value: 'hello' }) // expect { kind: 'B', value: number } 
+    })
+
     it('Should validate union of objects where properties overlap', () => {
         const A = Type.Object({ a: Type.String() }, { additionalProperties: false })
         const B = Type.Object({ a: Type.String(), b: Type.String() }, { additionalProperties: false })

From 62dc5f825aee482833c5a0a44ac34b17ed5b3f3c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9s=20Correa=20Casablanca?=
 <castarco@coderspirit.xyz>
Date: Sat, 22 Jan 2022 10:46:28 +0100
Subject: [PATCH 010/369] Documentation (#144)

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 1f31ffca7..083da1b54 100644
--- a/readme.md
+++ b/readme.md
@@ -598,7 +598,7 @@ In addition to JSON schema types, TypeBox provides several extended types that a
 
 ### Strict
 
-TypeBox schemas contain the properties `kind` and `modifier`. These properties are provided to enable runtime type reflection on schemas, as well as helping TypeBox apply the appropriate static type inference rules. These properties are not strictly valid JSON schema so in some cases it may be desirable to omit them. TypeBox provides a `Type.Strict()` function that will omit these properties if nessasary.
+TypeBox schemas contain the properties `kind` and `modifier`. These properties are provided to enable runtime type reflection on schemas, as well as helping TypeBox apply the appropriate static type inference rules. These properties are not strictly valid JSON schema so in some cases it may be desirable to omit them. TypeBox provides a `Type.Strict()` function that will omit these properties if necessary.
 
 ```typescript
 const T = Type.Object({                       // const T = {

From 4acd67064c2218a2674a63d81b3e82598563063b Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 23 Jan 2022 09:07:34 +0900
Subject: [PATCH 011/369] Next

---
 .github/.keep                                 |    0
 .github/workflows/ci.yml                      |   23 +-
 .gitignore                                    |    3 -
 .vscode/settings.json                         |    7 +-
 benchmark/compression/index.ts                |   25 +
 .../compression/module/typebox-compiler.ts    |    4 +
 .../compression/module/typebox-conditional.ts |    4 +
 .../compression/module/typebox-format.ts      |    4 +
 benchmark/compression/module/typebox-guard.ts |    4 +
 benchmark/compression/module/typebox-value.ts |    4 +
 benchmark/compression/module/typebox.ts       |    3 +
 benchmark/index.ts                            |    2 +
 benchmark/measurement/index.ts                |    5 +
 benchmark/measurement/module/benchmark.ts     |    7 +
 benchmark/measurement/module/cases.ts         |  114 +
 benchmark/measurement/module/check.ts         |   42 +
 benchmark/measurement/module/compile.ts       |   36 +
 benchmark/measurement/module/index.ts         |   36 +
 benchmark/measurement/module/result.ts        |   15 +
 changelog.md                                  |   98 +-
 codegen/codegen.ts                            |   43 +
 codegen/index.ts                              |   29 +
 codegen/tsconfig.json                         |    4 +
 codegen/typebox.ts                            |  364 +++
 codegen/typescript.ts                         |  225 ++
 example/index.ts                              |   24 +-
 hammer.mjs                                    |   65 +-
 license                                       |    2 +-
 package-lock.json                             | 2752 +++++------------
 package.json                                  |   36 +-
 readme.md                                     | 1191 ++++---
 spec/schema/any.ts                            |   33 -
 spec/schema/array.ts                          |   77 -
 spec/schema/boolean.ts                        |   41 -
 spec/schema/box.ts                            |   74 -
 spec/schema/enum.ts                           |   57 -
 spec/schema/intersect.ts                      |   97 -
 spec/schema/keyof.ts                          |   48 -
 spec/schema/literal.ts                        |   44 -
 spec/schema/modifier.ts                       |   22 -
 spec/schema/null.ts                           |   39 -
 spec/schema/number.ts                         |   33 -
 spec/schema/object.ts                         |   94 -
 spec/schema/omit.ts                           |   44 -
 spec/schema/optional.ts                       |   21 -
 spec/schema/partial.ts                        |   52 -
 spec/schema/pick.ts                           |   43 -
 spec/schema/readonly-optional.ts              |   21 -
 spec/schema/readonly.ts                       |   23 -
 spec/schema/rec.ts                            |  101 -
 spec/schema/record.ts                         |  100 -
 spec/schema/ref.ts                            |   87 -
 spec/schema/regex.ts                          |   31 -
 spec/schema/required.ts                       |   52 -
 spec/schema/strict.ts                         |   33 -
 spec/schema/string.ts                         |   49 -
 spec/schema/tuple.ts                          |   70 -
 spec/schema/union.ts                          |   65 -
 spec/schema/unknown.ts                        |   33 -
 spec/schema/validate.ts                       |   70 -
 spec/types/any.ts                             |    4 -
 spec/types/array.ts                           |   22 -
 spec/types/boolean.ts                         |    4 -
 spec/types/enum.ts                            |    8 -
 spec/types/intersect.ts                       |   38 -
 spec/types/keyof.ts                           |   49 -
 spec/types/literal.ts                         |    8 -
 spec/types/modifier.ts                        |   18 -
 spec/types/namespace.ts                       |   16 -
 spec/types/null.ts                            |    4 -
 spec/types/number.ts                          |    5 -
 spec/types/object.ts                          |   54 -
 spec/types/omit.ts                            |   17 -
 spec/types/optional.ts                        |   11 -
 spec/types/partial.ts                         |   18 -
 spec/types/pick.ts                            |   17 -
 spec/types/readonly-optional.ts               |   11 -
 spec/types/readonly.ts                        |   12 -
 spec/types/rec.ts                             |   14 -
 spec/types/record.ts                          |   85 -
 spec/types/ref.ts                             |   26 -
 spec/types/regex.ts                           |    4 -
 spec/types/required.ts                        |   18 -
 spec/types/spec.ts                            |    8 -
 spec/types/strict.ts                          |   16 -
 spec/types/string.ts                          |    4 -
 spec/types/tuple.ts                           |   12 -
 spec/types/typebox.d.ts                       |  348 ---
 spec/types/union.ts                           |   28 -
 spec/types/unknown.ts                         |    4 -
 src/compiler/compiler.ts                      |  416 +++
 src/compiler/index.ts                         |   30 +
 src/conditional/conditional.ts                |  114 +
 src/conditional/index.ts                      |   30 +
 src/conditional/structural.ts                 |  558 ++++
 src/errors/errors.ts                          |  411 +++
 src/errors/index.ts                           |   29 +
 src/format/format.ts                          |   54 +
 src/format/index.ts                           |   29 +
 src/guard/guard.ts                            |  362 +++
 src/guard/index.ts                            |   29 +
 src/tsconfig.json                             |   16 +-
 src/typebox.ts                                | 1316 +++++---
 src/value/cast.ts                             |  370 +++
 src/value/check.ts                            |  331 ++
 src/value/clone.ts                            |   62 +
 src/value/create.ts                           |  342 ++
 src/value/delta.ts                            |  182 ++
 src/value/equal.ts                            |   67 +
 src/value/index.ts                            |   31 +
 src/value/is.ts                               |   50 +
 src/value/pointer.ts                          |  122 +
 src/value/value.ts                            |   97 +
 test/runtime/assert/assert.ts                 |   59 +
 test/runtime/assert/index.ts                  |    1 +
 test/runtime/compiler/any.ts                  |   33 +
 test/runtime/compiler/array.ts                |   97 +
 test/runtime/compiler/boolean.ts              |   40 +
 test/runtime/compiler/enum.ts                 |   56 +
 .../schema => test/runtime/compiler}/index.ts |    9 +-
 test/runtime/compiler/intersect.ts            |   83 +
 test/runtime/compiler/keyof.ts                |   52 +
 test/runtime/compiler/literal.ts              |   43 +
 test/runtime/compiler/modifier.ts             |    3 +
 test/runtime/compiler/never.ts                |   36 +
 test/runtime/compiler/null.ts                 |   39 +
 test/runtime/compiler/number.ts               |   33 +
 test/runtime/compiler/object.ts               |  142 +
 test/runtime/compiler/omit.ts                 |   60 +
 test/runtime/compiler/optional.ts             |   27 +
 test/runtime/compiler/partial.ts              |   52 +
 test/runtime/compiler/pick.ts                 |   60 +
 test/runtime/compiler/readonly-optional.ts    |   27 +
 test/runtime/compiler/readonly.ts             |   28 +
 test/runtime/compiler/record.ts               |  101 +
 test/runtime/compiler/recursive.ts            |   83 +
 test/runtime/compiler/ref.ts                  |   70 +
 test/runtime/compiler/regex.ts                |   35 +
 test/runtime/compiler/required.ts             |   57 +
 test/runtime/compiler/string.ts               |   65 +
 test/runtime/compiler/tuple.ts                |   62 +
 test/runtime/compiler/uint8array.ts           |   56 +
 test/runtime/compiler/union.ts                |   62 +
 test/runtime/compiler/unknown.ts              |   33 +
 test/runtime/compiler/validate.ts             |  107 +
 test/runtime/compiler/void.ts                 |   39 +
 test/runtime/conditional/any.ts               |   92 +
 test/runtime/conditional/array.ts             |  310 ++
 test/runtime/conditional/boolean.ts           |  107 +
 test/runtime/conditional/constructor.ts       |  243 ++
 test/runtime/conditional/function.ts          |  245 ++
 test/runtime/conditional/index.ts             |   19 +
 test/runtime/conditional/integer.ts           |  112 +
 test/runtime/conditional/literal.ts           |  324 ++
 test/runtime/conditional/null.ts              |  113 +
 test/runtime/conditional/number.ts            |  111 +
 test/runtime/conditional/object.ts            |  155 +
 test/runtime/conditional/promise.ts           |  245 ++
 test/runtime/conditional/record.ts            |  182 ++
 test/runtime/conditional/string.ts            |  143 +
 test/runtime/conditional/tuple.ts             |  196 ++
 test/runtime/conditional/uint8array.ts        |  112 +
 test/runtime/conditional/undefined.ts         |  100 +
 test/runtime/conditional/union.ts             |  142 +
 test/runtime/conditional/unknown.ts           |  119 +
 test/runtime/conditional/void.ts              |  119 +
 test/runtime/format/format.ts                 |   25 +
 test/runtime/format/index.ts                  |    1 +
 test/runtime/guard/any.ts                     |   19 +
 test/runtime/guard/array.ts                   |   63 +
 test/runtime/guard/boolean.ts                 |   19 +
 test/runtime/guard/constructor.ts             |   35 +
 test/runtime/guard/function.ts                |   35 +
 test/runtime/guard/index.ts                   |   21 +
 test/runtime/guard/integer.ts                 |   44 +
 test/runtime/guard/literal.ts                 |   32 +
 test/runtime/guard/null.ts                    |   19 +
 test/runtime/guard/number.ts                  |   44 +
 test/runtime/guard/object.ts                  |   99 +
 test/runtime/guard/promise.ts                 |   45 +
 test/runtime/guard/record.ts                  |   53 +
 test/runtime/guard/ref.ts                     |   25 +
 test/runtime/guard/self.ts                    |   22 +
 test/runtime/guard/string.ts                  |   39 +
 test/runtime/guard/tuple.ts                   |   23 +
 test/runtime/guard/uint8array.ts              |   33 +
 test/runtime/guard/undefined.ts               |   19 +
 test/runtime/guard/union.ts                   |   66 +
 test/runtime/guard/unknown.ts                 |   19 +
 test/runtime/guard/void.ts                    |   19 +
 test/runtime/index.ts                         |    6 +
 test/runtime/schema/any.ts                    |   33 +
 test/runtime/schema/array.ts                  |   96 +
 test/runtime/schema/boolean.ts                |   40 +
 test/runtime/schema/enum.ts                   |   56 +
 .../runtime/schema/index.ts                   |   10 +-
 test/runtime/schema/intersect.ts              |   94 +
 test/runtime/schema/keyof.ts                  |   52 +
 test/runtime/schema/literal.ts                |   43 +
 test/runtime/schema/modifier.ts               |    3 +
 test/runtime/schema/never.ts                  |   33 +
 test/runtime/schema/null.ts                   |   39 +
 test/runtime/schema/number.ts                 |   33 +
 test/runtime/schema/object.ts                 |  142 +
 test/runtime/schema/omit.ts                   |   73 +
 test/runtime/schema/optional.ts               |   27 +
 test/runtime/schema/partial.ts                |   52 +
 test/runtime/schema/pick.ts                   |   73 +
 test/runtime/schema/readonly-optional.ts      |   27 +
 test/runtime/schema/readonly.ts               |   28 +
 test/runtime/schema/record.ts                 |  101 +
 test/runtime/schema/recursive.ts              |   83 +
 test/runtime/schema/ref.ts                    |   69 +
 test/runtime/schema/regex.ts                  |   35 +
 test/runtime/schema/required.ts               |   57 +
 test/runtime/schema/string.ts                 |   65 +
 test/runtime/schema/tuple.ts                  |   62 +
 test/runtime/schema/union.ts                  |   62 +
 test/runtime/schema/unknown.ts                |   33 +
 test/runtime/schema/unsafe.ts                 |   18 +
 test/runtime/schema/validate.ts               |   64 +
 test/runtime/schema/void.ts                   |   39 +
 test/runtime/value/cast/any.ts                |   47 +
 test/runtime/value/cast/array.ts              |  137 +
 test/runtime/value/cast/boolean.ts            |   53 +
 test/runtime/value/cast/convert.ts            |  281 ++
 test/runtime/value/cast/enum.ts               |   62 +
 test/runtime/value/cast/index.ts              |   24 +
 test/runtime/value/cast/integer.ts            |   47 +
 test/runtime/value/cast/intersect.ts          |   90 +
 test/runtime/value/cast/keyof.ts              |   62 +
 test/runtime/value/cast/literal.ts            |   53 +
 test/runtime/value/cast/namespace.ts          |    0
 test/runtime/value/cast/never.ts              |   35 +
 test/runtime/value/cast/null.ts               |   53 +
 test/runtime/value/cast/number.ts             |   53 +
 test/runtime/value/cast/object.ts             |  112 +
 test/runtime/value/cast/rec.ts                |  104 +
 test/runtime/value/cast/record.ts             |   81 +
 test/runtime/value/cast/regex.ts              |   53 +
 test/runtime/value/cast/string.ts             |   55 +
 test/runtime/value/cast/tuple.ts              |   80 +
 test/runtime/value/cast/uint8array.ts         |   53 +
 test/runtime/value/cast/undefined.ts          |   53 +
 test/runtime/value/cast/union.ts              |  125 +
 test/runtime/value/cast/unknown.ts            |   50 +
 test/runtime/value/cast/void.ts               |   53 +
 test/runtime/value/check/any.ts               |   42 +
 test/runtime/value/check/array.ts             |   33 +
 test/runtime/value/check/boolean.ts           |   42 +
 test/runtime/value/check/enum.ts              |   29 +
 test/runtime/value/check/index.ts             |   22 +
 test/runtime/value/check/integer.ts           |   19 +
 test/runtime/value/check/intersect.ts         |   82 +
 test/runtime/value/check/keyof.ts             |   37 +
 test/runtime/value/check/literal.ts           |   27 +
 test/runtime/value/check/never.ts             |   42 +
 test/runtime/value/check/null.ts              |   42 +
 test/runtime/value/check/number.ts            |   42 +
 test/runtime/value/check/object.ts            |  101 +
 test/runtime/value/check/rec.ts               |   69 +
 test/runtime/value/check/record.ts            |   83 +
 test/runtime/value/check/regex.ts             |   19 +
 test/runtime/value/check/string.ts            |   42 +
 test/runtime/value/check/tuple.ts             |   40 +
 test/runtime/value/check/uint8array.ts        |   33 +
 test/runtime/value/check/undefined.ts         |   42 +
 test/runtime/value/check/union.ts             |   77 +
 test/runtime/value/check/unknown.ts           |   42 +
 test/runtime/value/check/void.ts              |   42 +
 test/runtime/value/clone/clone.ts             |  177 ++
 test/runtime/value/clone/index.ts             |    1 +
 test/runtime/value/create/any.ts              |   14 +
 test/runtime/value/create/array.ts            |   18 +
 test/runtime/value/create/boolean.ts          |   14 +
 test/runtime/value/create/constructor.ts      |   38 +
 test/runtime/value/create/enum.ts             |   22 +
 test/runtime/value/create/function.ts         |   19 +
 test/runtime/value/create/index.ts            |   24 +
 test/runtime/value/create/integer.ts          |   14 +
 test/runtime/value/create/intersect.ts        |   66 +
 test/runtime/value/create/keyof.ts            |   25 +
 test/runtime/value/create/literal.ts          |   18 +
 test/runtime/value/create/never.ts            |   10 +
 test/runtime/value/create/null.ts             |   10 +
 test/runtime/value/create/number.ts           |   14 +
 test/runtime/value/create/object.ts           |   75 +
 test/runtime/value/create/rec.ts              |   30 +
 test/runtime/value/create/record.ts           |   18 +
 test/runtime/value/create/regex.ts            |   16 +
 test/runtime/value/create/string.ts           |   14 +
 test/runtime/value/create/tuple.ts            |   22 +
 test/runtime/value/create/uint8array.ts       |   28 +
 test/runtime/value/create/undefined.ts        |   10 +
 test/runtime/value/create/union.ts            |   51 +
 test/runtime/value/create/unknown.ts          |   14 +
 test/runtime/value/create/void.ts             |   10 +
 test/runtime/value/delta/diff.ts              |  424 +++
 test/runtime/value/delta/index.ts             |    2 +
 test/runtime/value/delta/patch.ts             |  447 +++
 test/runtime/value/equal/equal.ts             |  111 +
 test/runtime/value/equal/index.ts             |    1 +
 test/runtime/value/index.ts                   |    7 +
 test/runtime/value/pointer/index.ts           |    1 +
 test/runtime/value/pointer/pointer.ts         |  397 +++
 test/static/any.ts                            |    4 +
 test/static/array.ts                          |   24 +
 test/static/assert.ts                         |    8 +
 test/static/boolean.ts                        |    4 +
 test/static/enum.ts                           |   12 +
 test/static/index.ts                          |   35 +
 test/static/intersect.ts                      |   51 +
 test/static/keyof.ts                          |   57 +
 test/static/literal.ts                        |    8 +
 test/static/modifier.ts                       |   18 +
 test/static/never.ts                          |    7 +
 test/static/null.ts                           |    4 +
 test/static/number.ts                         |    4 +
 test/static/object.ts                         |   52 +
 test/static/omit.ts                           |   37 +
 test/static/optional.ts                       |   14 +
 test/static/partial.ts                        |   19 +
 test/static/pick.ts                           |   40 +
 test/static/readonly-optional.ts              |   11 +
 test/static/readonly.ts                       |   14 +
 test/static/record.ts                         |   61 +
 test/static/recursive.ts                      |   15 +
 test/static/ref.ts                            |   13 +
 test/static/regex.ts                          |    4 +
 test/static/required.ts                       |   22 +
 test/static/return-type.ts                    |   18 +
 test/static/strict.ts                         |   20 +
 test/static/string.ts                         |    4 +
 test/static/tsconfig.json                     |    4 +
 test/static/tuple.ts                          |   10 +
 test/static/union.ts                          |   73 +
 test/static/unknown.ts                        |    4 +
 tsconfig.json                                 |   26 +-
 typebox.png                                   |  Bin 342043 -> 706199 bytes
 339 files changed, 20443 insertions(+), 5343 deletions(-)
 create mode 100644 .github/.keep
 create mode 100644 benchmark/compression/index.ts
 create mode 100644 benchmark/compression/module/typebox-compiler.ts
 create mode 100644 benchmark/compression/module/typebox-conditional.ts
 create mode 100644 benchmark/compression/module/typebox-format.ts
 create mode 100644 benchmark/compression/module/typebox-guard.ts
 create mode 100644 benchmark/compression/module/typebox-value.ts
 create mode 100644 benchmark/compression/module/typebox.ts
 create mode 100644 benchmark/index.ts
 create mode 100644 benchmark/measurement/index.ts
 create mode 100644 benchmark/measurement/module/benchmark.ts
 create mode 100644 benchmark/measurement/module/cases.ts
 create mode 100644 benchmark/measurement/module/check.ts
 create mode 100644 benchmark/measurement/module/compile.ts
 create mode 100644 benchmark/measurement/module/index.ts
 create mode 100644 benchmark/measurement/module/result.ts
 create mode 100644 codegen/codegen.ts
 create mode 100644 codegen/index.ts
 create mode 100644 codegen/tsconfig.json
 create mode 100644 codegen/typebox.ts
 create mode 100644 codegen/typescript.ts
 delete mode 100644 spec/schema/any.ts
 delete mode 100644 spec/schema/array.ts
 delete mode 100644 spec/schema/boolean.ts
 delete mode 100644 spec/schema/box.ts
 delete mode 100644 spec/schema/enum.ts
 delete mode 100644 spec/schema/intersect.ts
 delete mode 100644 spec/schema/keyof.ts
 delete mode 100644 spec/schema/literal.ts
 delete mode 100644 spec/schema/modifier.ts
 delete mode 100644 spec/schema/null.ts
 delete mode 100644 spec/schema/number.ts
 delete mode 100644 spec/schema/object.ts
 delete mode 100644 spec/schema/omit.ts
 delete mode 100644 spec/schema/optional.ts
 delete mode 100644 spec/schema/partial.ts
 delete mode 100644 spec/schema/pick.ts
 delete mode 100644 spec/schema/readonly-optional.ts
 delete mode 100644 spec/schema/readonly.ts
 delete mode 100644 spec/schema/rec.ts
 delete mode 100644 spec/schema/record.ts
 delete mode 100644 spec/schema/ref.ts
 delete mode 100644 spec/schema/regex.ts
 delete mode 100644 spec/schema/required.ts
 delete mode 100644 spec/schema/strict.ts
 delete mode 100644 spec/schema/string.ts
 delete mode 100644 spec/schema/tuple.ts
 delete mode 100644 spec/schema/union.ts
 delete mode 100644 spec/schema/unknown.ts
 delete mode 100644 spec/schema/validate.ts
 delete mode 100644 spec/types/any.ts
 delete mode 100644 spec/types/array.ts
 delete mode 100644 spec/types/boolean.ts
 delete mode 100644 spec/types/enum.ts
 delete mode 100644 spec/types/intersect.ts
 delete mode 100644 spec/types/keyof.ts
 delete mode 100644 spec/types/literal.ts
 delete mode 100644 spec/types/modifier.ts
 delete mode 100644 spec/types/namespace.ts
 delete mode 100644 spec/types/null.ts
 delete mode 100644 spec/types/number.ts
 delete mode 100644 spec/types/object.ts
 delete mode 100644 spec/types/omit.ts
 delete mode 100644 spec/types/optional.ts
 delete mode 100644 spec/types/partial.ts
 delete mode 100644 spec/types/pick.ts
 delete mode 100644 spec/types/readonly-optional.ts
 delete mode 100644 spec/types/readonly.ts
 delete mode 100644 spec/types/rec.ts
 delete mode 100644 spec/types/record.ts
 delete mode 100644 spec/types/ref.ts
 delete mode 100644 spec/types/regex.ts
 delete mode 100644 spec/types/required.ts
 delete mode 100644 spec/types/spec.ts
 delete mode 100644 spec/types/strict.ts
 delete mode 100644 spec/types/string.ts
 delete mode 100644 spec/types/tuple.ts
 delete mode 100644 spec/types/typebox.d.ts
 delete mode 100644 spec/types/union.ts
 delete mode 100644 spec/types/unknown.ts
 create mode 100644 src/compiler/compiler.ts
 create mode 100644 src/compiler/index.ts
 create mode 100644 src/conditional/conditional.ts
 create mode 100644 src/conditional/index.ts
 create mode 100644 src/conditional/structural.ts
 create mode 100644 src/errors/errors.ts
 create mode 100644 src/errors/index.ts
 create mode 100644 src/format/format.ts
 create mode 100644 src/format/index.ts
 create mode 100644 src/guard/guard.ts
 create mode 100644 src/guard/index.ts
 create mode 100644 src/value/cast.ts
 create mode 100644 src/value/check.ts
 create mode 100644 src/value/clone.ts
 create mode 100644 src/value/create.ts
 create mode 100644 src/value/delta.ts
 create mode 100644 src/value/equal.ts
 create mode 100644 src/value/index.ts
 create mode 100644 src/value/is.ts
 create mode 100644 src/value/pointer.ts
 create mode 100644 src/value/value.ts
 create mode 100644 test/runtime/assert/assert.ts
 create mode 100644 test/runtime/assert/index.ts
 create mode 100644 test/runtime/compiler/any.ts
 create mode 100644 test/runtime/compiler/array.ts
 create mode 100644 test/runtime/compiler/boolean.ts
 create mode 100644 test/runtime/compiler/enum.ts
 rename {spec/schema => test/runtime/compiler}/index.ts (82%)
 create mode 100644 test/runtime/compiler/intersect.ts
 create mode 100644 test/runtime/compiler/keyof.ts
 create mode 100644 test/runtime/compiler/literal.ts
 create mode 100644 test/runtime/compiler/modifier.ts
 create mode 100644 test/runtime/compiler/never.ts
 create mode 100644 test/runtime/compiler/null.ts
 create mode 100644 test/runtime/compiler/number.ts
 create mode 100644 test/runtime/compiler/object.ts
 create mode 100644 test/runtime/compiler/omit.ts
 create mode 100644 test/runtime/compiler/optional.ts
 create mode 100644 test/runtime/compiler/partial.ts
 create mode 100644 test/runtime/compiler/pick.ts
 create mode 100644 test/runtime/compiler/readonly-optional.ts
 create mode 100644 test/runtime/compiler/readonly.ts
 create mode 100644 test/runtime/compiler/record.ts
 create mode 100644 test/runtime/compiler/recursive.ts
 create mode 100644 test/runtime/compiler/ref.ts
 create mode 100644 test/runtime/compiler/regex.ts
 create mode 100644 test/runtime/compiler/required.ts
 create mode 100644 test/runtime/compiler/string.ts
 create mode 100644 test/runtime/compiler/tuple.ts
 create mode 100644 test/runtime/compiler/uint8array.ts
 create mode 100644 test/runtime/compiler/union.ts
 create mode 100644 test/runtime/compiler/unknown.ts
 create mode 100644 test/runtime/compiler/validate.ts
 create mode 100644 test/runtime/compiler/void.ts
 create mode 100644 test/runtime/conditional/any.ts
 create mode 100644 test/runtime/conditional/array.ts
 create mode 100644 test/runtime/conditional/boolean.ts
 create mode 100644 test/runtime/conditional/constructor.ts
 create mode 100644 test/runtime/conditional/function.ts
 create mode 100644 test/runtime/conditional/index.ts
 create mode 100644 test/runtime/conditional/integer.ts
 create mode 100644 test/runtime/conditional/literal.ts
 create mode 100644 test/runtime/conditional/null.ts
 create mode 100644 test/runtime/conditional/number.ts
 create mode 100644 test/runtime/conditional/object.ts
 create mode 100644 test/runtime/conditional/promise.ts
 create mode 100644 test/runtime/conditional/record.ts
 create mode 100644 test/runtime/conditional/string.ts
 create mode 100644 test/runtime/conditional/tuple.ts
 create mode 100644 test/runtime/conditional/uint8array.ts
 create mode 100644 test/runtime/conditional/undefined.ts
 create mode 100644 test/runtime/conditional/union.ts
 create mode 100644 test/runtime/conditional/unknown.ts
 create mode 100644 test/runtime/conditional/void.ts
 create mode 100644 test/runtime/format/format.ts
 create mode 100644 test/runtime/format/index.ts
 create mode 100644 test/runtime/guard/any.ts
 create mode 100644 test/runtime/guard/array.ts
 create mode 100644 test/runtime/guard/boolean.ts
 create mode 100644 test/runtime/guard/constructor.ts
 create mode 100644 test/runtime/guard/function.ts
 create mode 100644 test/runtime/guard/index.ts
 create mode 100644 test/runtime/guard/integer.ts
 create mode 100644 test/runtime/guard/literal.ts
 create mode 100644 test/runtime/guard/null.ts
 create mode 100644 test/runtime/guard/number.ts
 create mode 100644 test/runtime/guard/object.ts
 create mode 100644 test/runtime/guard/promise.ts
 create mode 100644 test/runtime/guard/record.ts
 create mode 100644 test/runtime/guard/ref.ts
 create mode 100644 test/runtime/guard/self.ts
 create mode 100644 test/runtime/guard/string.ts
 create mode 100644 test/runtime/guard/tuple.ts
 create mode 100644 test/runtime/guard/uint8array.ts
 create mode 100644 test/runtime/guard/undefined.ts
 create mode 100644 test/runtime/guard/union.ts
 create mode 100644 test/runtime/guard/unknown.ts
 create mode 100644 test/runtime/guard/void.ts
 create mode 100644 test/runtime/index.ts
 create mode 100644 test/runtime/schema/any.ts
 create mode 100644 test/runtime/schema/array.ts
 create mode 100644 test/runtime/schema/boolean.ts
 create mode 100644 test/runtime/schema/enum.ts
 rename spec/types/typebox.test-d.ts => test/runtime/schema/index.ts (83%)
 create mode 100644 test/runtime/schema/intersect.ts
 create mode 100644 test/runtime/schema/keyof.ts
 create mode 100644 test/runtime/schema/literal.ts
 create mode 100644 test/runtime/schema/modifier.ts
 create mode 100644 test/runtime/schema/never.ts
 create mode 100644 test/runtime/schema/null.ts
 create mode 100644 test/runtime/schema/number.ts
 create mode 100644 test/runtime/schema/object.ts
 create mode 100644 test/runtime/schema/omit.ts
 create mode 100644 test/runtime/schema/optional.ts
 create mode 100644 test/runtime/schema/partial.ts
 create mode 100644 test/runtime/schema/pick.ts
 create mode 100644 test/runtime/schema/readonly-optional.ts
 create mode 100644 test/runtime/schema/readonly.ts
 create mode 100644 test/runtime/schema/record.ts
 create mode 100644 test/runtime/schema/recursive.ts
 create mode 100644 test/runtime/schema/ref.ts
 create mode 100644 test/runtime/schema/regex.ts
 create mode 100644 test/runtime/schema/required.ts
 create mode 100644 test/runtime/schema/string.ts
 create mode 100644 test/runtime/schema/tuple.ts
 create mode 100644 test/runtime/schema/union.ts
 create mode 100644 test/runtime/schema/unknown.ts
 create mode 100644 test/runtime/schema/unsafe.ts
 create mode 100644 test/runtime/schema/validate.ts
 create mode 100644 test/runtime/schema/void.ts
 create mode 100644 test/runtime/value/cast/any.ts
 create mode 100644 test/runtime/value/cast/array.ts
 create mode 100644 test/runtime/value/cast/boolean.ts
 create mode 100644 test/runtime/value/cast/convert.ts
 create mode 100644 test/runtime/value/cast/enum.ts
 create mode 100644 test/runtime/value/cast/index.ts
 create mode 100644 test/runtime/value/cast/integer.ts
 create mode 100644 test/runtime/value/cast/intersect.ts
 create mode 100644 test/runtime/value/cast/keyof.ts
 create mode 100644 test/runtime/value/cast/literal.ts
 create mode 100644 test/runtime/value/cast/namespace.ts
 create mode 100644 test/runtime/value/cast/never.ts
 create mode 100644 test/runtime/value/cast/null.ts
 create mode 100644 test/runtime/value/cast/number.ts
 create mode 100644 test/runtime/value/cast/object.ts
 create mode 100644 test/runtime/value/cast/rec.ts
 create mode 100644 test/runtime/value/cast/record.ts
 create mode 100644 test/runtime/value/cast/regex.ts
 create mode 100644 test/runtime/value/cast/string.ts
 create mode 100644 test/runtime/value/cast/tuple.ts
 create mode 100644 test/runtime/value/cast/uint8array.ts
 create mode 100644 test/runtime/value/cast/undefined.ts
 create mode 100644 test/runtime/value/cast/union.ts
 create mode 100644 test/runtime/value/cast/unknown.ts
 create mode 100644 test/runtime/value/cast/void.ts
 create mode 100644 test/runtime/value/check/any.ts
 create mode 100644 test/runtime/value/check/array.ts
 create mode 100644 test/runtime/value/check/boolean.ts
 create mode 100644 test/runtime/value/check/enum.ts
 create mode 100644 test/runtime/value/check/index.ts
 create mode 100644 test/runtime/value/check/integer.ts
 create mode 100644 test/runtime/value/check/intersect.ts
 create mode 100644 test/runtime/value/check/keyof.ts
 create mode 100644 test/runtime/value/check/literal.ts
 create mode 100644 test/runtime/value/check/never.ts
 create mode 100644 test/runtime/value/check/null.ts
 create mode 100644 test/runtime/value/check/number.ts
 create mode 100644 test/runtime/value/check/object.ts
 create mode 100644 test/runtime/value/check/rec.ts
 create mode 100644 test/runtime/value/check/record.ts
 create mode 100644 test/runtime/value/check/regex.ts
 create mode 100644 test/runtime/value/check/string.ts
 create mode 100644 test/runtime/value/check/tuple.ts
 create mode 100644 test/runtime/value/check/uint8array.ts
 create mode 100644 test/runtime/value/check/undefined.ts
 create mode 100644 test/runtime/value/check/union.ts
 create mode 100644 test/runtime/value/check/unknown.ts
 create mode 100644 test/runtime/value/check/void.ts
 create mode 100644 test/runtime/value/clone/clone.ts
 create mode 100644 test/runtime/value/clone/index.ts
 create mode 100644 test/runtime/value/create/any.ts
 create mode 100644 test/runtime/value/create/array.ts
 create mode 100644 test/runtime/value/create/boolean.ts
 create mode 100644 test/runtime/value/create/constructor.ts
 create mode 100644 test/runtime/value/create/enum.ts
 create mode 100644 test/runtime/value/create/function.ts
 create mode 100644 test/runtime/value/create/index.ts
 create mode 100644 test/runtime/value/create/integer.ts
 create mode 100644 test/runtime/value/create/intersect.ts
 create mode 100644 test/runtime/value/create/keyof.ts
 create mode 100644 test/runtime/value/create/literal.ts
 create mode 100644 test/runtime/value/create/never.ts
 create mode 100644 test/runtime/value/create/null.ts
 create mode 100644 test/runtime/value/create/number.ts
 create mode 100644 test/runtime/value/create/object.ts
 create mode 100644 test/runtime/value/create/rec.ts
 create mode 100644 test/runtime/value/create/record.ts
 create mode 100644 test/runtime/value/create/regex.ts
 create mode 100644 test/runtime/value/create/string.ts
 create mode 100644 test/runtime/value/create/tuple.ts
 create mode 100644 test/runtime/value/create/uint8array.ts
 create mode 100644 test/runtime/value/create/undefined.ts
 create mode 100644 test/runtime/value/create/union.ts
 create mode 100644 test/runtime/value/create/unknown.ts
 create mode 100644 test/runtime/value/create/void.ts
 create mode 100644 test/runtime/value/delta/diff.ts
 create mode 100644 test/runtime/value/delta/index.ts
 create mode 100644 test/runtime/value/delta/patch.ts
 create mode 100644 test/runtime/value/equal/equal.ts
 create mode 100644 test/runtime/value/equal/index.ts
 create mode 100644 test/runtime/value/index.ts
 create mode 100644 test/runtime/value/pointer/index.ts
 create mode 100644 test/runtime/value/pointer/pointer.ts
 create mode 100644 test/static/any.ts
 create mode 100644 test/static/array.ts
 create mode 100644 test/static/assert.ts
 create mode 100644 test/static/boolean.ts
 create mode 100644 test/static/enum.ts
 create mode 100644 test/static/index.ts
 create mode 100644 test/static/intersect.ts
 create mode 100644 test/static/keyof.ts
 create mode 100644 test/static/literal.ts
 create mode 100644 test/static/modifier.ts
 create mode 100644 test/static/never.ts
 create mode 100644 test/static/null.ts
 create mode 100644 test/static/number.ts
 create mode 100644 test/static/object.ts
 create mode 100644 test/static/omit.ts
 create mode 100644 test/static/optional.ts
 create mode 100644 test/static/partial.ts
 create mode 100644 test/static/pick.ts
 create mode 100644 test/static/readonly-optional.ts
 create mode 100644 test/static/readonly.ts
 create mode 100644 test/static/record.ts
 create mode 100644 test/static/recursive.ts
 create mode 100644 test/static/ref.ts
 create mode 100644 test/static/regex.ts
 create mode 100644 test/static/required.ts
 create mode 100644 test/static/return-type.ts
 create mode 100644 test/static/strict.ts
 create mode 100644 test/static/string.ts
 create mode 100644 test/static/tsconfig.json
 create mode 100644 test/static/tuple.ts
 create mode 100644 test/static/union.ts
 create mode 100644 test/static/unknown.ts

diff --git a/.github/.keep b/.github/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 4604aa7a8..d64a14027 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -3,24 +3,21 @@ name: GitHub CI
 on: [push, pull_request]
 
 jobs:
-  npm:
+  TypeBox:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        node-version: [14.x]
+        node: [14.x, 16.x, 18.x]
         os: [ubuntu-latest, windows-latest, macOS-latest]
     steps:
       - uses: actions/checkout@v2
-      - name: Use Node.js
+      - name: Install Node
         uses: actions/setup-node@v1
         with:
-          node-version: ${{ matrix.node-version }}
-      - name: Install with npm
-        run: |
-          npm install
-      - name: Build
-        run: |
-          npm run build
-      - name: Run tests
-        run: |
-          npm run test
+          node-version: ${{ matrix.node }}
+      - name: Install Packages
+        run: npm install
+      - name: Build Library
+        run: npm run build
+      - name: Test Library
+        run: npm run test
diff --git a/.gitignore b/.gitignore
index 46029743a..2c085d1d2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,2 @@
 node_modules
 target
-index.js
-spec.js
-
diff --git a/.vscode/settings.json b/.vscode/settings.json
index e4c4348f5..a9232115d 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,7 +1,8 @@
 {
     "files.exclude": {
         "node_modules": true,
-        "package-lock.json": true,
-        "target": false
-    }
+        "package-lock.json": true
+    },
+    "typescript.tsdk": "node_modules\\typescript\\lib",
+    "editor.suggest.showStatusBar": false
 }
\ No newline at end of file
diff --git a/benchmark/compression/index.ts b/benchmark/compression/index.ts
new file mode 100644
index 000000000..9454d15ce
--- /dev/null
+++ b/benchmark/compression/index.ts
@@ -0,0 +1,25 @@
+import { shell } from '@sinclair/hammer'
+import { statSync, readdirSync } from 'fs'
+import { basename, extname } from 'path'
+
+export async function measure(test: string) {
+  await shell(`hammer build benchmark/compression/module/${test}.ts --dist target/benchmark/compression`)
+  const compiled = statSync(`target/benchmark/compression/${test}.js`)
+  await shell(`hammer build benchmark/compression/module/${test}.ts --dist target/benchmark/compression --minify`)
+  const minified = statSync(`target/benchmark/compression/${test}.js`)
+  return {
+    test: test.padEnd(20),
+    compiled: `${Math.floor(compiled.size / 1000)} kb`.padStart(8),
+    minified: `${Math.floor(minified.size / 1000)} kb`.padStart(8),
+    ratio: compiled.size / minified.size,
+  }
+}
+
+export async function compression() {
+  const tests = readdirSync('benchmark/compression/module').map((name) => basename(name, extname(name)))
+  const results = await Promise.all(tests.map((test) => measure(test)))
+  const present = results.reduce((acc, c) => {
+    return { ...acc, [c.test.replace('-', '/')]: { Compiled: c.compiled, Minified: c.minified, Compression: `${c.ratio.toFixed(2)} x` } }
+  }, {})
+  console.table(present)
+}
diff --git a/benchmark/compression/module/typebox-compiler.ts b/benchmark/compression/module/typebox-compiler.ts
new file mode 100644
index 000000000..97a54ba07
--- /dev/null
+++ b/benchmark/compression/module/typebox-compiler.ts
@@ -0,0 +1,4 @@
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { Type } from '@sinclair/typebox'
+
+const T = TypeCompiler.Compile(Type.String())
diff --git a/benchmark/compression/module/typebox-conditional.ts b/benchmark/compression/module/typebox-conditional.ts
new file mode 100644
index 000000000..3a12edfa2
--- /dev/null
+++ b/benchmark/compression/module/typebox-conditional.ts
@@ -0,0 +1,4 @@
+import { Conditional } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+
+const T = Conditional.Extends(Type.String(), Type.String(), Type.String(), Type.String())
diff --git a/benchmark/compression/module/typebox-format.ts b/benchmark/compression/module/typebox-format.ts
new file mode 100644
index 000000000..360a2ce85
--- /dev/null
+++ b/benchmark/compression/module/typebox-format.ts
@@ -0,0 +1,4 @@
+import { Format } from 'src/format'
+import { Type } from '@sinclair/typebox'
+
+Format.Set('custom', (value) => true)
diff --git a/benchmark/compression/module/typebox-guard.ts b/benchmark/compression/module/typebox-guard.ts
new file mode 100644
index 000000000..9c453c2d5
--- /dev/null
+++ b/benchmark/compression/module/typebox-guard.ts
@@ -0,0 +1,4 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+
+const T = TypeGuard.TSchema(Type.String())
diff --git a/benchmark/compression/module/typebox-value.ts b/benchmark/compression/module/typebox-value.ts
new file mode 100644
index 000000000..f616f8256
--- /dev/null
+++ b/benchmark/compression/module/typebox-value.ts
@@ -0,0 +1,4 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+const T = Value.Create(Type.String())
diff --git a/benchmark/compression/module/typebox.ts b/benchmark/compression/module/typebox.ts
new file mode 100644
index 000000000..0b01566e5
--- /dev/null
+++ b/benchmark/compression/module/typebox.ts
@@ -0,0 +1,3 @@
+import { Type } from '@sinclair/typebox'
+
+const T = Type.String()
diff --git a/benchmark/index.ts b/benchmark/index.ts
new file mode 100644
index 000000000..db1450ec6
--- /dev/null
+++ b/benchmark/index.ts
@@ -0,0 +1,2 @@
+export * from './compression/index'
+export * from './measurement/index'
diff --git a/benchmark/measurement/index.ts b/benchmark/measurement/index.ts
new file mode 100644
index 000000000..6175663af
--- /dev/null
+++ b/benchmark/measurement/index.ts
@@ -0,0 +1,5 @@
+import { shell } from '@sinclair/hammer'
+
+export async function measurement() {
+  await shell(`hammer run benchmark/measurement/module/index.ts --dist target/benchmark/measurement`)
+}
diff --git a/benchmark/measurement/module/benchmark.ts b/benchmark/measurement/module/benchmark.ts
new file mode 100644
index 000000000..c4b4de381
--- /dev/null
+++ b/benchmark/measurement/module/benchmark.ts
@@ -0,0 +1,7 @@
+export namespace Benchmark {
+  export function Measure(execute: Function, iterations: number = 16_000_000) {
+    const start = Date.now()
+    for (let i = 0; i < iterations; i++) execute()
+    return { iterations, completed: Date.now() - start }
+  }
+}
diff --git a/benchmark/measurement/module/cases.ts b/benchmark/measurement/module/cases.ts
new file mode 100644
index 000000000..fb88ceb36
--- /dev/null
+++ b/benchmark/measurement/module/cases.ts
@@ -0,0 +1,114 @@
+import { Type } from '@sinclair/typebox'
+
+export namespace Cases {
+  export const Number = Type.Number()
+
+  export const String = Type.String()
+
+  export const Boolean = Type.Boolean()
+
+  export const Null = Type.Null()
+
+  export const RegEx = Type.RegEx(/foo/, { default: 'foo' })
+
+  export const ObjectA = Type.Object({
+    p0: Type.String(),
+    p1: Type.Number(),
+    p2: Type.Number(),
+    p3: Type.Array(Type.Number(), { minItems: 4 }),
+    p4: Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    }),
+    p5: Type.Object({
+      a: Type.String(),
+      b: Type.String(),
+      c: Type.String(),
+    }),
+  })
+
+  export const ObjectB = Type.Object(ObjectA.properties, {
+    additionalProperties: false,
+  })
+
+  export const Tuple = Type.Tuple([Type.String(), Type.Number(), Type.Boolean()])
+
+  export const Union = Type.Union([Type.Object({ x: Type.Number(), y: Type.Number() }), Type.Object({ a: Type.String(), b: Type.String() })], { default: { a: 'a', b: 'b' } })
+
+  export const Recursive = Type.Recursive(
+    (Recursive) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(Recursive),
+      }),
+    {
+      default: {
+        id: '',
+        nodes: [
+          {
+            id: '',
+            nodes: [
+              { id: '', nodes: [] },
+              { id: '', nodes: [] },
+              { id: '', nodes: [] },
+            ],
+          },
+          {
+            id: '',
+            nodes: [
+              { id: '', nodes: [] },
+              { id: '', nodes: [] },
+              { id: '', nodes: [] },
+            ],
+          },
+          {
+            id: '',
+            nodes: [
+              { id: '', nodes: [] },
+              { id: '', nodes: [] },
+              { id: '', nodes: [] },
+            ],
+          },
+        ],
+      },
+    },
+  )
+
+  export const Vector4 = Type.Tuple([Type.Number(), Type.Number(), Type.Number(), Type.Number()])
+
+  export const Matrix4 = Type.Array(Type.Array(Type.Number()), {
+    default: [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, 0],
+      [0, 0, 0, 1],
+    ],
+  })
+
+  export const Literal_String = Type.Literal('foo')
+
+  export const Literal_Number = Type.Literal(1)
+
+  export const Literal_Boolean = Type.Literal(true)
+
+  export const Array_Number = Type.Array(Type.Number(), { minItems: 16 })
+
+  export const Array_String = Type.Array(Type.String(), { minItems: 16 })
+
+  export const Array_Boolean = Type.Array(Type.Boolean(), { minItems: 16 })
+
+  export const Array_ObjectA = Type.Array(ObjectA, { minItems: 16 })
+
+  export const Array_ObjectB = Type.Array(ObjectB, { minItems: 16 })
+
+  export const Array_Tuple = Type.Array(Tuple, { minItems: 16 })
+
+  export const Array_Union = Type.Array(Union, { minItems: 16 })
+
+  export const Array_Recursive = Type.Array(Recursive, { minItems: 16 })
+
+  export const Array_Vector4 = Type.Array(Vector4, { minItems: 16 })
+
+  export const Array_Matrix4 = Type.Array(Matrix4, { minItems: 16 })
+}
diff --git a/benchmark/measurement/module/check.ts b/benchmark/measurement/module/check.ts
new file mode 100644
index 000000000..3b8f975a4
--- /dev/null
+++ b/benchmark/measurement/module/check.ts
@@ -0,0 +1,42 @@
+import { Cases } from './cases'
+import { Benchmark } from './benchmark'
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { TSchema } from '@sinclair/typebox'
+import { Value } from '@sinclair/typebox/value'
+
+import Ajv from 'ajv'
+
+const ajv = new Ajv() // ensure single instance
+
+export namespace CheckBenchmark {
+  function Measure<T extends TSchema>(type: string, schema: T) {
+    console.log('CheckBenchmark.Measure(', type, ')')
+
+    const iterations = 1_000_000
+    const V = Value.Create(schema)
+
+    const AC = ajv.compile(schema)
+    const A = Benchmark.Measure(() => {
+      if (!AC(V)) throw Error()
+    }, iterations)
+
+    const CC = TypeCompiler.Compile(schema)
+    const T = Benchmark.Measure(() => {
+      if (!CC.Check(V)) throw Error()
+    }, iterations)
+
+    const VC = Benchmark.Measure(() => {
+      if (!Value.Check(schema, V)) throw Error()
+    }, iterations)
+
+    return { type, ajv: A, compiler: T, value: VC }
+  }
+
+  export function* Execute() {
+    for (const [type, schema] of Object.entries(Cases)) {
+      if (!TypeGuard.TSchema(schema)) throw Error('Invalid TypeBox schema')
+      yield Measure(type, schema)
+    }
+  }
+}
diff --git a/benchmark/measurement/module/compile.ts b/benchmark/measurement/module/compile.ts
new file mode 100644
index 000000000..1dd039601
--- /dev/null
+++ b/benchmark/measurement/module/compile.ts
@@ -0,0 +1,36 @@
+import { Cases } from './cases'
+import { Benchmark } from './benchmark'
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { TSchema } from '@sinclair/typebox'
+import Ajv from 'ajv'
+
+const ajv = new Ajv() // ensure single instance
+
+export namespace CompileBenchmark {
+  function Measure<T extends TSchema>(type: string, schema: T) {
+    const iterations = 2000
+    console.log('CompileBenchmark.Measure(', type, ')')
+    // -------------------------------------------------------------------------------
+    // Note: Ajv caches schemas by reference. To ensure we measure actual
+    // compilation times, we must pass a new reference via { ...schema }
+    // -------------------------------------------------------------------------------
+    const AC = Benchmark.Measure(() => ajv.compile({ ...schema }), iterations)
+    const CC = Benchmark.Measure(() => TypeCompiler.Compile({ ...schema }), iterations)
+    return { type, ajv: AC, compiler: CC }
+  }
+
+  export function* Execute() {
+    for (const [type, schema] of Object.entries(Cases)) {
+      if (!TypeGuard.TSchema(schema)) throw Error('Invalid TypeBox schema')
+      // -------------------------------------------------------------------------------
+      // Note: it is not possible to benchmark recursive schemas as ajv will cache and
+      // track duplicate $id (resulting in compile error). It is not possible to ammend
+      // recursive $id's without potentially biasing results, so we omit on this case.
+      // -------------------------------------------------------------------------------
+      if (type === 'Recursive' || type === 'Array_Recursive') continue
+
+      yield Measure(type, schema)
+    }
+  }
+}
diff --git a/benchmark/measurement/module/index.ts b/benchmark/measurement/module/index.ts
new file mode 100644
index 000000000..5b6d43480
--- /dev/null
+++ b/benchmark/measurement/module/index.ts
@@ -0,0 +1,36 @@
+import { CompileBenchmark } from './compile'
+import { CheckBenchmark } from './check'
+import { Result } from './result'
+
+export function present(results: Result[]) {
+  console.table(
+    results.reduce((acc, result) => {
+      const ratio = result.ajv.completed / result.compiler.completed
+      if (result.value) {
+        return {
+          ...acc,
+          [result.type.padStart(16, ' ')]: {
+            Iterations: result.compiler.iterations,
+            ValueCheck: `${result.value.completed} ms`.padStart(10),
+            Ajv: `${result.ajv.completed} ms`.padStart(10),
+            TypeCompiler: `${result.compiler.completed} ms`.padStart(10),
+            Performance: `${ratio.toFixed(2)} x`.padStart(10, ' '),
+          },
+        }
+      } else {
+        return {
+          ...acc,
+          [result.type.padStart(16, ' ')]: {
+            Iterations: result.compiler.iterations,
+            Ajv: `${result.ajv.completed} ms`.padStart(10),
+            TypeCompiler: `${result.compiler.completed} ms`.padStart(10),
+            Performance: `${ratio.toFixed(2)} x`.padStart(10, ' '),
+          },
+        }
+      }
+    }, {}),
+  )
+}
+
+present([...CompileBenchmark.Execute()])
+present([...CheckBenchmark.Execute()])
diff --git a/benchmark/measurement/module/result.ts b/benchmark/measurement/module/result.ts
new file mode 100644
index 000000000..c74a1aa5d
--- /dev/null
+++ b/benchmark/measurement/module/result.ts
@@ -0,0 +1,15 @@
+export type Result = {
+  type: string
+  ajv: {
+    iterations: number
+    completed: number
+  }
+  compiler: {
+    iterations: number
+    completed: number
+  }
+  value?: {
+    iterations: number
+    completed: number
+  }
+}
diff --git a/changelog.md b/changelog.md
index fcd52a1ef..7c8020b0c 100644
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,99 @@
+## [0.24.44](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.44)
+
+Updates:
+- [189](https://github.com/sinclairzx81/typebox/pull/189) Both `Value.Error(T, value)` and `TypeCheck.Error(value)` now return an iterator for validation errors.
+- [191](https://github.com/sinclairzx81/typebox/pull/191) TypeBox now provides a `TypeGuard` API that can be used to check the structural validity of TypeBox type. The TypeGuard can be used in reflection / code generation scenarios to resolve the appropriate inner `TSchema` type while traversing a outer type.
+- [197](https://github.com/sinclairzx81/typebox/pull/197) TypeBox now implements conditional runtime type mapping. This functionality is offered as seperate import for the `0.24.0` release but may be provided as standard type in later releases. This API enables `type T = Foo extends Bar ? true : false` conditional checks to be implemented at runtime. This API also provides the `Exclude` and `Extract` utility types which are implemented through conditional types in TypeScript.
+- [199](https://github.com/sinclairzx81/typebox/pull/199) TypeBox now provides better support for varidiac function and constructor signatures. Currently Variadics are mapped through `Tuple` types.
+- [200](https://github.com/sinclairzx81/typebox/pull/200) The types `TPick` and `TOmit` now support types of `TUnion<TLiteral<string>[]>` to be used to select properties. Additionally, `KeyOf` now returns `TUnion<TLiteral<string>[]>`, allowing `KeyOf` schemas to be passed to `TPick` and `TOmit`.
+- [214](https://github.com/sinclairzx81/typebox/pull/214) TypeBox now provides better support for i18n. To achieve this, TypeBox includes fixed mappable error codes on the `ValueError` type. These codes can be used by external implementors to create localized error messages. TypeBox may include localized error codes as an optional import in future releases.
+- [288](https://github.com/sinclairzx81/typebox/pull/228) TypeBox now allows users to implement custom string validator formats. These formats are internally shared between the `Value` and `TypeCompiler` API's. TypeBox does not currently provide any built in formats, however the standard expected set (email, uuid, uri, etc) may be provided via optional import (inline with ajv-formats usage)
+- [229](https://github.com/sinclairzx81/typebox/pull/229) The `Value.Cast()` function now implements automatic coersion of string, number and boolean types.
+- [231](https://github.com/sinclairzx81/typebox/pull/231) TypeBox provides a new `Value.Diff<T>()` and `Value.Patch<T>()` utility API for JavaScript values. This API is intended to provide a basis for the efficient transmission of state updates across a network. This API can diff any JavaScript value (typed or untyped) but is recommended to be used in conjunction with a formal static type.
+- [236](https://github.com/sinclairzx81/typebox/pull/236) TypeBox now implements the `TNever` type. This type is analogous to TypeScript's `never` type and is used in instances a composition results in a non-reconcilable type. Currently this type is implemented for empty `TUnion<[]>` types only. Future releases may utilize this type for planned updates to `TIntersect` (for example `string & number` resolves to `never`)
+- [241](https://github.com/sinclairzx81/typebox/pull/241) [247](https://github.com/sinclairzx81/typebox/pull/247) TypeBox now exposes a ValuePointer API that can be used to mutate a value via an RFC6901 JSON Pointer. Previously this functionality was internally used by `Value.Diff()` and `Value.Patch()` functions but is now offered as an optional import for implementations that need to update values manually through pointer references.
+
+Additional:
+
+- This project now includes two reference code generation utilities that can be used in custom build tooling. The first is `TypeScriptCodeGen` which will remap TypeScript `interface` and `type` definitions to TypeBox types. The second is `TypeBoxCodeGen` which will map existing TypeBox types into TypeScript type definitions. These implementations are not expected to be part of the TypeBox package, but users are free to clone and enhance them in their existing tool chains. Reference implementations can be found https://github.com/sinclairzx81/typebox/tree/master/codegen
+
+
+
+## [0.24.15](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.15)
+
+Added:
+- `Conditional.Extends(...)` This enables TypeBox to conditionally map types inline with TypeScripts structural equivelence checks. Tested against TypeScript 4.7.4.
+- `Conditional.Extract(...)` Which analogs TypeScripts `Extract<...>` utility type. Additional information [here](https://www.typescriptlang.org/docs/handbook/utility-types.html#extracttype-union) 
+- `Conditional.Exclude(...)` Which analogs TypeScripts `Exclude<...>` utility type. Additional information [here](https://www.typescriptlang.org/docs/handbook/utility-types.html#excludeuniontype-excludedmembers)
+- `Type.Parameters(...)` Returns the parameters of a `TFunction` as a `TTuple`
+- `Type.ReturnType(...)` Returns the return type schema of a `TFunction`
+- `Type.ConstructorParameters(...)` Returns the parameters of a `TConstructor` as a `TTuple`
+- `Type.InstanceType(...)` Returns the instance type schema of a `TConstructor`
+ 
+## [0.24.8](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.8)
+
+Added:
+- `Value.Cast(T, value)` structurally casts a value into another form while retaining information within the original value.
+- `Value.Check(T, value)` provides slow dynamic type checking for values. For performance, one should consider the `TypeCompiler` or `Ajv` validator.
+- `Value.Errors(T, value)` returns an iterable iterator errors found in a given value.
+
+## [0.24.6](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.6)
+
+Added:
+
+- TypeBox now offers a `TypeGuard` module for structurally checking TypeBox schematics. This module can be used in runtime type reflection scenarios where it's helpful to test a schema is of a particular form. This module can be imported under the `@sinclair/typebox/guard` import path.
+
+Example:
+
+```typescript
+import { TypeGuard } from '@sinclair/typebox/guard'
+
+const T: any = {}                                    // T is any
+
+const { type } = T                                   // unsafe: type is any
+
+if(TypeGuard.TString(T)) {
+    
+  const { type } = T                                 // safe: type is 'string'
+}
+
+```
+
+## [0.24.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.0)
+
+Changes:
+
+- The `kind` and `modifier` keywords are now expressed as symbol keys. This change allows AJV to leverage TypeBox schemas directly without explicit configuration of `kind` and `modifier` in strict mode.
+- `Type.Intersect([...])` now returns a composite `TObject` instead of a `allOf` schema representation. This change allows intersected types to be leveraged in calls to `Omit`, `Pick`, `Partial`, `Required`.
+- `Type.Void(...)` now generates a `{ type: null }` schema representation. This is principally used for RPC implementations where a RPC target function needs to respond with a serializable value for `void` return.
+- `Type.Rec(...)` renamed to `Type.Recursive(...)` and now supports non-mutual recursive type inference.
+
+Added:
+
+- `Type.Unsafe<T>(...)`. This type enables custom schema representations whose static type is informed by generic type T.
+- `Type.Uint8Array(...)`. This is a non-standard schema that can be configured on AJV to enable binary buffer range validation.
+- Added optional extended `design` property on all schema options. This property can be used to specify design time metadata when rendering forms.
+
+Compiler:
+
+- TypeBox now provides an optional experimental type compiler that can be used to validate types without AJV. This compiler is not a standard JSON schema compiler and will only compile TypeBox's known schema representations. For full JSON schema validation, AJV should still be the preference. This compiler is a work in progress.
+
+Value:
+
+- TypeBox now provides a value generator that can generate default values from TypeBox types.
+
+Breaking Changes:
+
+- `Type.Intersect(...)` is constrained to accept types of `TObject` only.
+- `Type.Namespace(...)` has been removed.
+- The types `TUnion`, `TEnum`, `KeyOf` and `TLiteral<TString>[]` are all now expressed via `allOf`. For Open API users, Please consider `Type.Unsafe()` to express `enum` string union representations. Documentation on using `Type.Unsafe()` can be found [here](https://github.com/sinclairzx81/typebox#Unsafe-Types)
+
+## [0.23.3](https://www.npmjs.com/package/@sinclair/typebox/v/0.23.3)
+
+Updates:
+
+- Fix: Rename BoxKind to NamespaceKind
+
 ## [0.23.1](https://www.npmjs.com/package/@sinclair/typebox/v/0.23.1)
 
 Updates:
@@ -240,4 +336,4 @@ const T = Type.Object({
     b: Type.Number()
 }, { 
     additionalProperties: false 
-})
\ No newline at end of file
+})
diff --git a/codegen/codegen.ts b/codegen/codegen.ts
new file mode 100644
index 000000000..ebbdab70d
--- /dev/null
+++ b/codegen/codegen.ts
@@ -0,0 +1,43 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/codegen
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TSchema } from '@sinclair/typebox'
+import { TypeBoxCodegen } from './typebox'
+import { TypeScriptCodeGen } from './typescript'
+
+export namespace CodeGen {
+  /** Generates TypeScript type definitions from TypeBox types */
+  export function TypeScript(schema: TSchema, references: TSchema[] = []): string {
+    return TypeScriptCodeGen.Generate(schema, references)
+  }
+
+  /** Generates TypeBox type definitions from TypeScript code */
+  export function TypeBox(code: string): string {
+    return TypeBoxCodegen.Generate(code)
+  }
+}
diff --git a/codegen/index.ts b/codegen/index.ts
new file mode 100644
index 000000000..d72a0bbe4
--- /dev/null
+++ b/codegen/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/codegen
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './codegen'
diff --git a/codegen/tsconfig.json b/codegen/tsconfig.json
new file mode 100644
index 000000000..9f4a7e200
--- /dev/null
+++ b/codegen/tsconfig.json
@@ -0,0 +1,4 @@
+{
+  "extends": "../tsconfig.json",
+  "files": ["index.ts"]
+}
diff --git a/codegen/typebox.ts b/codegen/typebox.ts
new file mode 100644
index 000000000..d18637bd2
--- /dev/null
+++ b/codegen/typebox.ts
@@ -0,0 +1,364 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/codegen
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as ts from 'typescript'
+
+/** Generates TypeBox types from TypeScript interface and type definitions */
+export namespace TypeBoxCodegen {
+  function isReadonlyProperty(node: ts.PropertySignature): boolean {
+    return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'readonly') !== undefined
+  }
+
+  function isOptionalProperty(node: ts.PropertySignature) {
+    return node.questionToken !== undefined
+  }
+
+  function isExport(node: ts.InterfaceDeclaration | ts.TypeAliasDeclaration | ts.EnumDeclaration): boolean {
+    return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'export') !== undefined
+  }
+
+  function* SourceFile(node: ts.SourceFile): IterableIterator<string> {
+    for (const next of node.getChildren()) {
+      yield* Visit(next)
+    }
+  }
+
+  function* PropertySignature(node: ts.PropertySignature): IterableIterator<string> {
+    const [readonly, optional] = [isReadonlyProperty(node), isOptionalProperty(node)]
+    const type = Collect(node.type)
+    if (readonly && optional) {
+      return yield `${node.name.getText()}: Type.ReadonlyOptional(${type})`
+    } else if (readonly) {
+      return yield `${node.name.getText()}: Type.Readonly(${type})`
+    } else if (optional) {
+      return yield `${node.name.getText()}: Type.Optional(${type})`
+    } else {
+      return yield `${node.name.getText()}: ${type}`
+    }
+  }
+
+  function* ArrayTypeNode(node: ts.ArrayTypeNode): IterableIterator<string> {
+    const type = Collect(node.elementType)
+    yield `Type.Array(${type})`
+  }
+
+  function* TupleTypeNode(node: ts.TupleTypeNode): IterableIterator<string> {
+    const types = node.elements.map((type) => Collect(type)).join(',\n')
+    yield `Type.Tuple([\n${types}\n])`
+  }
+
+  function* UnionTypeNode(node: ts.UnionTypeNode): IterableIterator<string> {
+    const types = node.types.map((type) => Collect(type)).join(',\n')
+    yield `Type.Union([\n${types}\n])`
+  }
+
+  function* IntersectionTypeNode(node: ts.IntersectionTypeNode): IterableIterator<string> {
+    const types = node.types.map((type) => Collect(type)).join(',\n')
+    yield `Type.Intersect([\n${types}\n])`
+  }
+
+  function* TypeOperatorNode(node: ts.TypeOperatorNode): IterableIterator<string> {
+    if (node.operator === ts.SyntaxKind.KeyOfKeyword) {
+      const type = Collect(node.type)
+      yield `Type.KeyOf(${type})`
+    }
+  }
+
+  function* Parameter(node: ts.ParameterDeclaration): IterableIterator<string> {
+    yield Collect(node.type)
+  }
+
+  function* FunctionTypeNode(node: ts.FunctionTypeNode): IterableIterator<string> {
+    const parameters = node.parameters.map((param) => Collect(param)).join(', ')
+    const returns = Collect(node.type)
+    yield `Type.Function([${parameters}], ${returns})`
+  }
+
+  function* ConstructorTypeNode(node: ts.ConstructorTypeNode): IterableIterator<string> {
+    const parameters = node.parameters.map((param) => Collect(param)).join(', ')
+    const returns = Collect(node.type)
+    yield `Type.Constructor([${parameters}], ${returns})`
+  }
+
+  function* EnumDeclaration(node: ts.EnumDeclaration): IterableIterator<string> {
+    const exports = isExport(node) ? 'export ' : ''
+    const name = node.name.getText()
+    const members = node.members.map((member) => member.getText()).join(', ')
+    const enumType = `${exports}enum ${name}Enum { ${members} }`
+    const type = `${exports}const ${name} = Type.Enum(${name}Enum)`
+    yield [enumType, '', type].join('\n')
+  }
+
+  function* InterfaceDeclaration(node: ts.InterfaceDeclaration): IterableIterator<string> {
+    useImports = true
+    if (node.typeParameters) {
+      useGenerics = true
+      const exports = isExport(node) ? 'export ' : ''
+      const constraints = node.typeParameters.map((param) => `${Collect(param)} extends TSchema`).join(', ')
+      const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(', ')
+      const names = node.typeParameters.map((param) => `${Collect(param)}`).join(', ')
+      const members = node.members.map((member) => Collect(member)).join(',\n')
+      const staticDeclaration = `${exports}type ${node.name.getText()}<${constraints}> = Static<ReturnType<typeof ${node.name.getText()}<${names}>>>`
+      const typeDeclaration = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => Type.Object({\n${members}\n})`
+      yield `${staticDeclaration}\n${typeDeclaration}`
+    } else {
+      const exports = isExport(node) ? 'export ' : ''
+      const members = node.members.map((member) => Collect(member)).join(',\n')
+      const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`
+      const typeDeclaration = `${exports}const ${node.name.getText()} = Type.Object({\n${members}\n})`
+      yield `${staticDeclaration}\n${typeDeclaration}`
+    }
+  }
+
+  function* TypeAliasDeclaration(node: ts.TypeAliasDeclaration): IterableIterator<string> {
+    useImports = true
+    if (node.typeParameters) {
+      useGenerics = true
+      const exports = isExport(node) ? 'export ' : ''
+      const constraints = node.typeParameters.map((param) => `${Collect(param)} extends TSchema`).join(', ')
+      const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(', ')
+      const names = node.typeParameters.map((param) => Collect(param)).join(', ')
+      const type = Collect(node.type)
+      const staticDeclaration = `${exports}type ${node.name.getText()}<${constraints}> = Static<ReturnType<typeof ${node.name.getText()}<${names}>>>`
+      const typeDeclaration = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${type}`
+      yield `${staticDeclaration}\n${typeDeclaration}`
+    } else {
+      const exports = isExport(node) ? 'export ' : ''
+      const type = Collect(node.type)
+      const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`
+      const typeDeclaration = `${exports}const ${node.name.getText()} = ${type}`
+      yield `${staticDeclaration}\n${typeDeclaration}`
+    }
+  }
+
+  function* TypeParameterDeclaration(node: ts.TypeParameterDeclaration): IterableIterator<string> {
+    yield node.name.getText()
+  }
+
+  function* ParenthesizedTypeNode(node: ts.ParenthesizedTypeNode): IterableIterator<string> {
+    yield Collect(node.type)
+  }
+
+  function* RestTypeNode(node: ts.RestTypeNode): IterableIterator<string> {
+    yield `Type.Rest()`
+  }
+
+  function* ConditionalTypeNode(node: ts.ConditionalTypeNode): IterableIterator<string> {
+    useConditional = true
+    const checkType = Collect(node.checkType)
+    const extendsType = Collect(node.extendsType)
+    const trueType = Collect(node.trueType)
+    const falseType = Collect(node.falseType)
+    yield `Conditional.Extends(${checkType}, ${extendsType}, ${trueType}, ${falseType})`
+  }
+
+  function* TypeReferenceNode(node: ts.TypeReferenceNode): IterableIterator<string> {
+    const name = node.typeName.getText()
+    const args = node.typeArguments ? `(${node.typeArguments.map((type) => Collect(type)).join(', ')})` : ''
+    if (name === 'Array') {
+      return yield `Type.Array${args}`
+    } else if (name === 'Record') {
+      return yield `Type.Record${args}`
+    } else if (name === 'Partial') {
+      return yield `Type.Partial${args}`
+    } else if (name === 'Uint8Array') {
+      return yield `Type.Uint8Array()`
+    } else if (name === 'Required') {
+      return yield `Type.Required${args}`
+    } else if (name === 'Omit') {
+      return yield `Type.Omit${args}`
+    } else if (name === 'Pick') {
+      return yield `Type.Pick${args}`
+    } else if (name === 'Promise') {
+      return yield `Type.Promise${args}`
+    } else if (name === 'ReturnType') {
+      return yield `Type.ReturnType${args}`
+    } else if (name === 'InstanceType') {
+      return yield `Type.InstanceType${args}`
+    } else if (name === 'Parameters') {
+      return yield `Type.Parameters${args}`
+    } else if (name === 'ConstructorParameters') {
+      return yield `Type.ConstructorParameters${args}`
+    } else if (name === 'Exclude') {
+      return yield `Conditional.Exclude${args}`
+    } else if (name === 'Extract') {
+      return yield `Conditional.Extract${args}`
+    } else {
+      return yield `${name}${args}`
+    }
+  }
+
+  function* TypeLiteralNode(node: ts.TypeLiteralNode): IterableIterator<string> {
+    const members = node.members.map((member) => Collect(member)).join(',\n')
+    yield `Type.Object({\n${members}\n})`
+  }
+
+  function* LiteralTypeNode(node: ts.LiteralTypeNode): IterableIterator<string> {
+    const text = node.getText()
+    if (text === 'null') return yield `Type.Null()`
+    yield `Type.Literal(${node.getText()})`
+  }
+
+  function* FunctionDeclaration(node: ts.FunctionDeclaration): IterableIterator<string> {
+    yield node.getText()
+  }
+
+  function* ClassDeclaration(node: ts.ClassDeclaration): IterableIterator<string> {
+    yield node.getText()
+  }
+
+  function Collect(node: ts.Node | undefined): string {
+    return `${[...Visit(node)].join('')}`
+  }
+
+  function CollectNewLine(node: ts.Node | undefined): string {
+    return [...Visit(node)].join('\n\n')
+  }
+
+  function* Visit(node: ts.Node | undefined): IterableIterator<string> {
+    if (node === undefined) return
+    if (ts.isSourceFile(node)) {
+      return yield* SourceFile(node)
+    } else if (ts.isInterfaceDeclaration(node)) {
+      return yield* InterfaceDeclaration(node)
+    } else if (ts.isTypeAliasDeclaration(node)) {
+      return yield* TypeAliasDeclaration(node)
+    } else if (ts.isParameter(node)) {
+      return yield* Parameter(node)
+    } else if (ts.isFunctionTypeNode(node)) {
+      return yield* FunctionTypeNode(node)
+    } else if (ts.isConstructorTypeNode(node)) {
+      return yield* ConstructorTypeNode(node)
+    } else if (ts.isEnumDeclaration(node)) {
+      return yield* EnumDeclaration(node)
+    } else if (ts.isPropertySignature(node)) {
+      return yield* PropertySignature(node)
+    } else if (ts.isTypeReferenceNode(node)) {
+      return yield* TypeReferenceNode(node)
+    } else if (ts.isTypeLiteralNode(node)) {
+      return yield* TypeLiteralNode(node)
+    } else if (ts.isLiteralTypeNode(node)) {
+      return yield* LiteralTypeNode(node)
+    } else if (ts.isArrayTypeNode(node)) {
+      return yield* ArrayTypeNode(node)
+    } else if (ts.isTupleTypeNode(node)) {
+      return yield* TupleTypeNode(node)
+    } else if (ts.isIntersectionTypeNode(node)) {
+      return yield* IntersectionTypeNode(node)
+    } else if (ts.isUnionTypeNode(node)) {
+      return yield* UnionTypeNode(node)
+    } else if (ts.isTypeOperatorNode(node)) {
+      return yield* TypeOperatorNode(node)
+    } else if (ts.isTypeParameterDeclaration(node)) {
+      return yield* TypeParameterDeclaration(node)
+    } else if (ts.isParenthesizedTypeNode(node)) {
+      return yield* ParenthesizedTypeNode(node)
+    } else if (ts.isRestTypeNode(node)) {
+      return yield* RestTypeNode(node)
+    } else if (ts.isFunctionDeclaration(node)) {
+      return yield* FunctionDeclaration(node)
+    } else if (ts.isClassDeclaration(node)) {
+      return yield* ClassDeclaration(node)
+    } else if (ts.isConditionalTypeNode(node)) {
+      return yield* ConditionalTypeNode(node)
+    } else if (node.kind === ts.SyntaxKind.KeyOfKeyword) {
+      return yield `Type.KeyOf()`
+    } else if (node.kind === ts.SyntaxKind.NumberKeyword) {
+      return yield `Type.Number()`
+    } else if (node.kind === ts.SyntaxKind.StringKeyword) {
+      return yield `Type.String()`
+    } else if (node.kind === ts.SyntaxKind.BooleanKeyword) {
+      return yield `Type.Boolean()`
+    } else if (node.kind === ts.SyntaxKind.UndefinedKeyword) {
+      return yield `Type.Undefined()`
+    } else if (node.kind === ts.SyntaxKind.UnknownKeyword) {
+      return yield `Type.Unknown()`
+    } else if (node.kind === ts.SyntaxKind.AnyKeyword) {
+      return yield `Type.Any()`
+    } else if (node.kind === ts.SyntaxKind.NeverKeyword) {
+      return yield `Type.Never()`
+    } else if (node.kind === ts.SyntaxKind.NullKeyword) {
+      return yield `Type.Null()`
+    } else if (node.kind === ts.SyntaxKind.VoidKeyword) {
+      return yield `Type.Void()`
+    } else if (node.kind === ts.SyntaxKind.EndOfFileToken) {
+      return
+    } else if (node.kind === ts.SyntaxKind.SyntaxList) {
+      for (const child of node.getChildren()) {
+        yield* Visit(child)
+      }
+      return
+    } else {
+      console.log('Unhandled:', ts.SyntaxKind[node.kind])
+      return yield node.getText()
+    }
+  }
+
+  function Format(input: string): string {
+    function count(line: string, opens: string[]) {
+      const codes = opens.map((open) => open.charCodeAt(0))
+      return line
+        .split('')
+        .map((char) => char.charCodeAt(0))
+        .reduce((acc, current) => {
+          return codes.includes(current) ? acc + 1 : acc
+        }, 0)
+    }
+    let indent = 0
+    const output: string[] = []
+    for (const line of input.split('\n').map((n) => n.trim())) {
+      indent -= count(line, ['}', ']'])
+      output.push(`${''.padStart(indent * 2, ' ')}${line}`)
+      indent += count(line, ['{', '['])
+    }
+    return output.join('\n')
+  }
+
+  let useImports = false
+  let useConditional = false
+  let useGenerics = false
+
+  /** Generates TypeBox types from TypeScript interface and type definitions */
+  export function Generate(typescriptCode: string) {
+    useImports = false
+    useConditional = false
+    useGenerics = false
+
+    const source = ts.createSourceFile('code.ts', typescriptCode, ts.ScriptTarget.ESNext, true)
+    const typeDeclarations = CollectNewLine(source)
+    const importStatments: string[] = []
+    if (useImports) {
+      if (useConditional) importStatments.push(`import { Conditional } from '@sinclair/typebox/conditional'`)
+      if (useGenerics) importStatments.push(`import { Type, Static, TSchema } from '@sinclair/typebox'`)
+      if (!useGenerics) importStatments.push(`import { Type, Static } from '@sinclair/typebox'`)
+    }
+    const imports = importStatments.join('\n')
+    const types = Format(typeDeclarations)
+    return [imports, '', types].join('\n')
+  }
+}
diff --git a/codegen/typescript.ts b/codegen/typescript.ts
new file mode 100644
index 000000000..6087ece23
--- /dev/null
+++ b/codegen/typescript.ts
@@ -0,0 +1,225 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/codegen
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TypeGuard } from '@sinclair/typebox/guard'
+import * as Types from '@sinclair/typebox'
+
+export namespace TypeScriptCodeGen {
+  function Any(schema: Types.TAny) {
+    return 'any'
+  }
+
+  function Array(schema: Types.TArray) {
+    const items = Visit(schema.items)
+    return `Array<${items}>`
+  }
+
+  function Boolean(schema: Types.TBoolean) {
+    return 'boolean'
+  }
+
+  function Constructor(schema: Types.TConstructor) {
+    const params = schema.parameters.map((param) => Visit(param)).join(', ')
+    const returns = Visit(schema.returns)
+    return `new (${params}) => ${returns}`
+  }
+
+  function Function(schema: Types.TFunction) {
+    const params = schema.parameters.map((param) => Visit(param)).join(', ')
+    const returns = Visit(schema.returns)
+    return `(${params}) => ${returns}`
+  }
+
+  function Integer(schema: Types.TInteger) {
+    return 'number'
+  }
+
+  function Literal(schema: Types.TLiteral) {
+    if (typeof schema.const === 'string') {
+      return `'${schema.const}'`
+    } else {
+      return `${schema.const}`
+    }
+  }
+
+  function Never(schema: Types.TNever) {
+    return 'never'
+  }
+
+  function Null(schema: Types.TNull) {
+    return 'null'
+  }
+
+  function String(schema: Types.TString) {
+    return 'string'
+  }
+
+  function Number(schema: Types.TNumber) {
+    return 'number'
+  }
+
+  function Object(schema: Types.TObject) {
+    const properties: string = globalThis.Object.entries(schema.properties)
+      .map(([key, value]) => {
+        return `${key}: ${Visit(value)}`
+      })
+      .join(',\n')
+    return `{\n${properties}\n}`
+  }
+
+  function Promise(schema: Types.TPromise) {
+    const item = Visit(schema.item)
+    return `Promise<${item}>`
+  }
+
+  function Record(schema: Types.TRecord) {
+    for (const [key, value] of globalThis.Object.entries(schema.patternProperties)) {
+      const type = Visit(value)
+      if (key === '^(0|[1-9][0-9]*)$') {
+        return `Record<number, ${type}>`
+      } else {
+        return `Record<string, ${type}>`
+      }
+    }
+    throw Error('TypeScriptCodeGen: Unreachable')
+  }
+
+  function Ref(schema: Types.TRef) {
+    return schema.$ref
+  }
+
+  function Self(schema: Types.TSelf) {
+    return schema.$ref
+  }
+
+  function Tuple(schema: Types.TTuple) {
+    if (schema.items === undefined) return `[]`
+    const items = schema.items.map((schema) => Visit(schema)).join(', ')
+    return `[${items}]`
+  }
+
+  function UInt8Array(schema: Types.TUint8Array) {
+    return `Uint8Array`
+  }
+
+  function Undefined(schema: Types.TUndefined) {
+    return `undefined`
+  }
+
+  function Union(schema: Types.TUnion) {
+    return schema.anyOf.map((schema) => Visit(schema)).join(' | ')
+  }
+
+  function Unknown(schema: Types.TUnknown) {
+    return `unknown`
+  }
+
+  function Void(schema: Types.TVoid) {
+    return `void`
+  }
+
+  function Visit(schema: Types.TSchema): string {
+    if (TypeGuard.TAny(schema)) {
+      return Any(schema)
+    } else if (TypeGuard.TArray(schema)) {
+      return Array(schema)
+    } else if (TypeGuard.TBoolean(schema)) {
+      return Boolean(schema)
+    } else if (TypeGuard.TConstructor(schema)) {
+      return Constructor(schema)
+    } else if (TypeGuard.TFunction(schema)) {
+      return Function(schema)
+    } else if (TypeGuard.TInteger(schema)) {
+      return Integer(schema)
+    } else if (TypeGuard.TLiteral(schema)) {
+      return Literal(schema)
+    } else if (TypeGuard.TNever(schema)) {
+      return Never(schema)
+    } else if (TypeGuard.TNull(schema)) {
+      return Null(schema)
+    } else if (TypeGuard.TNumber(schema)) {
+      return Number(schema)
+    } else if (TypeGuard.TObject(schema)) {
+      return Object(schema)
+    } else if (TypeGuard.TPromise(schema)) {
+      return Promise(schema)
+    } else if (TypeGuard.TRecord(schema)) {
+      return Record(schema)
+    } else if (TypeGuard.TRef(schema)) {
+      return Ref(schema)
+    } else if (TypeGuard.TSelf(schema)) {
+      return Self(schema)
+    } else if (TypeGuard.TString(schema)) {
+      return String(schema)
+    } else if (TypeGuard.TTuple(schema)) {
+      return Tuple(schema)
+    } else if (TypeGuard.TUint8Array(schema)) {
+      return UInt8Array(schema)
+    } else if (TypeGuard.TUndefined(schema)) {
+      return Undefined(schema)
+    } else if (TypeGuard.TUnion(schema)) {
+      return Union(schema)
+    } else if (TypeGuard.TUnknown(schema)) {
+      return Unknown(schema)
+    } else if (TypeGuard.TVoid(schema)) {
+      return Void(schema)
+    } else {
+      throw Error('TypeScriptCodeGen: Unknown type')
+    }
+  }
+
+  function Format(input: string): string {
+    function count(line: string, opens: string[]) {
+      const codes = opens.map((open) => open.charCodeAt(0))
+      return line
+        .split('')
+        .map((char) => char.charCodeAt(0))
+        .reduce((acc, current) => {
+          return codes.includes(current) ? acc + 1 : acc
+        }, 0)
+    }
+    let indent = 0
+    const output: string[] = []
+    for (const line of input.split('\n').map((n) => n.trim())) {
+      indent -= count(line, ['}'])
+      output.push(`${''.padStart(indent * 2, ' ')}${line}`)
+      indent += count(line, ['{'])
+    }
+    return output.join('\n')
+  }
+
+  /** Generates TypeScript code from TypeBox types */
+  export function Generate(schema: Types.TSchema, references: Types.TSchema[] = []) {
+    const result: string[] = []
+    for (const reference of references) {
+      result.push(`type ${reference.$id} = ${Format([...Visit(reference)].join(''))}`)
+    }
+    result.push(`type ${schema.$id || 'T'} = ${Format([...Visit(schema)].join(''))}`)
+    return result.join('\n\n')
+  }
+}
diff --git a/example/index.ts b/example/index.ts
index 7f3a03024..1d6e207c4 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -1,16 +1,18 @@
+import { CodeGen } from '@sinclair/typebox/codegen'
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { Conditional } from '@sinclair/typebox/conditional'
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Format } from '@sinclair/typebox/format'
+import { Value, ValuePointer } from '@sinclair/typebox/value'
 import { Type, Static } from '@sinclair/typebox'
 
-const T = Type.Object({
-    x: Type.String(),
-    y: Type.Number(),
-    z: Type.String()
-}, { $id: 'T' })
-
-const R = Type.Ref(T)
 
-const K = Type.KeyOf(R)
-
-type T = Static<typeof K>
+const T = Type.Object({
+  x: Type.Number(),
+  y: Type.Number(),
+  z: Type.Number()
+})
 
-console.log(K)
+type T = Static<typeof T>
 
+console.log(T)
\ No newline at end of file
diff --git a/hammer.mjs b/hammer.mjs
index f46ddc1b6..34b412fca 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -1,3 +1,7 @@
+import { compression, measurement } from './benchmark'
+import { readFileSync } from 'fs'
+
+
 // -------------------------------------------------------------------------------
 // Clean
 // -------------------------------------------------------------------------------
@@ -7,29 +11,46 @@ export async function clean() {
 }
 
 // -------------------------------------------------------------------------------
-// Specs
+// Format
 // -------------------------------------------------------------------------------
 
-export async function spec_types() {
-    await shell(`tsc -p ./src/tsconfig.json --outDir spec/types --emitDeclarationOnly`)
-    await shell(`tsd spec/types`)
+export async function format() {
+    await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test benchmark codegen')
 }
 
-export async function spec_schemas() {
-    await shell(`hammer build ./spec/schema/index.ts --dist target/spec/schema --platform node`)
-    await shell(`mocha target/spec/schema/index.js`)
+// -------------------------------------------------------------------------------
+// Start
+// -------------------------------------------------------------------------------
+
+export async function start(example = 'index') {
+    await shell(`hammer run example/${example}.ts --dist target/example/${example}`)
 }
 
-export async function spec() {
-    await spec_types()
-    await spec_schemas()
+// -------------------------------------------------------------------------------
+// Benchmark
+// -------------------------------------------------------------------------------
+
+export async function benchmark() {
+    await compression()
+    await measurement()
 }
 
 // -------------------------------------------------------------------------------
-// Example
+// Test
 // -------------------------------------------------------------------------------
-export async function example(target = 'target/example') {
-    await shell(`hammer run example/index.ts --dist ${target}`)
+
+export async function test_static() {
+    await shell(`tsc -p test/static/tsconfig.json --noEmit --strict`)
+}
+
+export async function test_runtime(filter) {
+    await shell(`hammer build ./test/runtime/index.ts --dist target/test/runtime --platform node`)
+    await shell(`mocha target/test/runtime/index.js -g "${filter}"`)
+}
+
+export async function test(filter = '') {
+    await test_static()
+    await test_runtime(filter)
 }
 
 // -------------------------------------------------------------------------------
@@ -37,15 +58,23 @@ export async function example(target = 'target/example') {
 // -------------------------------------------------------------------------------
 
 export async function build(target = 'target/build') {
-    await spec()
+    await test()
     await folder(target).delete()
     await shell(`tsc -p ./src/tsconfig.json --outDir ${target}`)
     await folder(target).add('package.json')
     await folder(target).add('readme.md')
     await folder(target).add('license')
     await shell(`cd ${target} && npm pack`)
-
-    // $ npm publish sinclair-typebox-0.x.x.tgz --access=public
-    // $ git tag <version>
-    // $ git push origin <version>
 }
+
+
+// -------------------------------------------------------------
+// Publish
+// -------------------------------------------------------------
+
+export async function publish(otp, target = 'target/build') {
+    const { version } = JSON.parse(readFileSync('package.json', 'utf8'))
+    await shell(`cd ${target} && npm publish sinclair-typebox-${version}.tgz --access=public --otp ${otp}`)
+    await shell(`git tag ${version}`)
+    await shell(`git push origin ${version}`)
+}
\ No newline at end of file
diff --git a/license b/license
index 2e5d87302..cd929d327 100644
--- a/license
+++ b/license
@@ -2,7 +2,7 @@ TypeBox: JSON Schema Type Builder with Static Type Resolution for TypeScript
 
 The MIT License (MIT)
 
-Copyright (c) 2021 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/package-lock.json b/package-lock.json
index 2a7201ff4..0754cb51b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,239 +1,71 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.22.0",
+  "version": "0.24.39",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.22.0",
+      "version": "0.24.39",
       "license": "MIT",
       "devDependencies": {
-        "@sinclair/hammer": "^0.15.8",
-        "@types/chai": "^4.2.22",
-        "@types/mocha": "^9.0.0",
-        "@types/node": "^16.11.9",
-        "ajv": "^8.8.2",
+        "@sinclair/hammer": "^0.17.1",
+        "@types/chai": "^4.3.3",
+        "@types/mocha": "^9.1.1",
+        "@types/node": "^18.7.13",
+        "ajv": "^8.11.0",
         "ajv-formats": "^2.1.1",
-        "chai": "^4.3.4",
-        "mocha": "^9.1.3",
-        "tsd": "^0.19.0",
-        "typescript": "^4.5.2"
-      }
-    },
-    "node_modules/@babel/code-frame": {
-      "version": "7.16.0",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.16.0.tgz",
-      "integrity": "sha512-IF4EOMEV+bfYwOmNxGzSnjR2EmQod7f1UXOpZM3l4i4o4QNwzjtJAu/HxdjHq0aYBvdqMuQEY1eg0nqW9ZPORA==",
-      "dev": true,
-      "dependencies": {
-        "@babel/highlight": "^7.16.0"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.15.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.15.7.tgz",
-      "integrity": "sha512-K4JvCtQqad9OY2+yTU8w+E82ywk/fe+ELNlt1G8z3bVGlZfn/hOcQQsUhGhW/N+tb3fxK800wLtKOE/aM0m72w==",
-      "dev": true,
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/highlight": {
-      "version": "7.16.0",
-      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.16.0.tgz",
-      "integrity": "sha512-t8MH41kUQylBtu2+4IQA3atqevA2lRgqA2wyVB/YiWmsDSuylZZuXOUy9ric30hfzauEFfdsuk/eXTRrGrfd0g==",
-      "dev": true,
-      "dependencies": {
-        "@babel/helper-validator-identifier": "^7.15.7",
-        "chalk": "^2.0.0",
-        "js-tokens": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/ansi-styles": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
-      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
-      "dev": true,
-      "dependencies": {
-        "color-convert": "^1.9.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/chalk": {
-      "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
-      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
-      "dev": true,
-      "dependencies": {
-        "ansi-styles": "^3.2.1",
-        "escape-string-regexp": "^1.0.5",
-        "supports-color": "^5.3.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/color-convert": {
-      "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
-      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
-      "dev": true,
-      "dependencies": {
-        "color-name": "1.1.3"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/color-name": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-      "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=",
-      "dev": true
-    },
-    "node_modules/@babel/highlight/node_modules/escape-string-regexp": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-      "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=",
-      "dev": true,
-      "engines": {
-        "node": ">=0.8.0"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/has-flag": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-      "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
-      "dev": true,
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/supports-color": {
-      "version": "5.5.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
-      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
-      "dev": true,
-      "dependencies": {
-        "has-flag": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/@nodelib/fs.scandir": {
-      "version": "2.1.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
-      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
-      "dev": true,
-      "dependencies": {
-        "@nodelib/fs.stat": "2.0.5",
-        "run-parallel": "^1.1.9"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@nodelib/fs.stat": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
-      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
-      "dev": true,
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@nodelib/fs.walk": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
-      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+        "chai": "^4.3.6",
+        "mocha": "^9.2.2",
+        "prettier": "^2.7.1",
+        "typescript": "^4.8.2"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.14.53.tgz",
+      "integrity": "sha512-W2dAL6Bnyn4xa/QRSU3ilIK4EzD5wgYXKXJiS1HDF5vU3675qc2bvFyLwbUcdmssDveyndy7FbitrCoiV/eMLg==",
+      "cpu": [
+        "loong64"
+      ],
       "dev": true,
-      "dependencies": {
-        "@nodelib/fs.scandir": "2.1.5",
-        "fastq": "^1.6.0"
-      },
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">= 8"
+        "node": ">=12"
       }
     },
     "node_modules/@sinclair/hammer": {
-      "version": "0.15.8",
-      "resolved": "https://registry.npmjs.org/@sinclair/hammer/-/hammer-0.15.8.tgz",
-      "integrity": "sha512-XM6SOQkF8HusX6nCZrlwpU1O+QtjNyhvrF0B6loZReJAuAZJJuTd4/fFDErCrp8uGauG8alYNXcpEOmQRvLARw==",
+      "version": "0.17.1",
+      "resolved": "https://registry.npmjs.org/@sinclair/hammer/-/hammer-0.17.1.tgz",
+      "integrity": "sha512-/M7KXwCaXdDmBJXQHpn1NWSTUg7Rmx6vzseVOax7IXhsBYj3vEGU5yt/Xh3XdRLVOEcyl4vGWgJ0pL9cmyrTJA==",
       "dev": true,
       "dependencies": {
-        "esbuild": "^0.12.24"
+        "@sinclair/hammer": "^0.17.0",
+        "esbuild": "^0.14.53"
       },
       "bin": {
         "hammer": "hammer"
       }
     },
-    "node_modules/@tsd/typescript": {
-      "version": "4.5.2",
-      "resolved": "https://registry.npmjs.org/@tsd/typescript/-/typescript-4.5.2.tgz",
-      "integrity": "sha512-K778wcPuAsJ9Ch0/FlhQcaIMFEi+TfxNi5NSUbgZd3RucaktYUpR++1Ox2mW2G25oyxWb8gfgg+JUhulRbI6eQ==",
-      "dev": true,
-      "bin": {
-        "tsc": "typescript/bin/tsc",
-        "tsserver": "typescript/bin/tsserver"
-      }
-    },
     "node_modules/@types/chai": {
-      "version": "4.2.22",
-      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.2.22.tgz",
-      "integrity": "sha512-tFfcE+DSTzWAgifkjik9AySNqIyNoYwmR+uecPwwD/XRNfvOjmC/FjCxpiUGDkDVDphPfCUecSQVFw+lN3M3kQ==",
-      "dev": true
-    },
-    "node_modules/@types/eslint": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-7.29.0.tgz",
-      "integrity": "sha512-VNcvioYDH8/FxaeTKkM4/TiTwt6pBV9E3OfGmvaw8tPl0rrHCJ4Ll15HRT+pMiFAf/MLQvAzC+6RzUMEL9Ceng==",
-      "dev": true,
-      "dependencies": {
-        "@types/estree": "*",
-        "@types/json-schema": "*"
-      }
-    },
-    "node_modules/@types/estree": {
-      "version": "0.0.50",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.50.tgz",
-      "integrity": "sha512-C6N5s2ZFtuZRj54k2/zyRhNDjJwwcViAM3Nbm8zjBpbqAdZ00mr0CFxvSKeO8Y/e03WVFLpQMdHYVfUd6SB+Hw==",
-      "dev": true
-    },
-    "node_modules/@types/json-schema": {
-      "version": "7.0.9",
-      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.9.tgz",
-      "integrity": "sha512-qcUXuemtEu+E5wZSJHNxUXeCZhAfXKQ41D+duX+VYPde7xyEVZci+/oXKJL13tnRs9lR2pr4fod59GT6/X1/yQ==",
-      "dev": true
-    },
-    "node_modules/@types/minimist": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/@types/minimist/-/minimist-1.2.2.tgz",
-      "integrity": "sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==",
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.3.3.tgz",
+      "integrity": "sha512-hC7OMnszpxhZPduX+m+nrx+uFoLkWOMiR4oa/AZF3MuSETYTZmFfJAHqZEM8MVlvfG7BEUcgvtwoCTxBp6hm3g==",
       "dev": true
     },
     "node_modules/@types/mocha": {
-      "version": "9.0.0",
-      "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-9.0.0.tgz",
-      "integrity": "sha512-scN0hAWyLVAvLR9AyW7HoFF5sJZglyBsbPuHO4fv7JRvfmPBMfp1ozWqOf/e4wwPNxezBZXRfWzMb6iFLgEVRA==",
+      "version": "9.1.1",
+      "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-9.1.1.tgz",
+      "integrity": "sha512-Z61JK7DKDtdKTWwLeElSEBcWGRLY8g95ic5FoQqI9CMx0ns/Ghep3B4DfcEimiKMvtamNVULVNKEsiwV3aQmXw==",
       "dev": true
     },
     "node_modules/@types/node": {
-      "version": "16.11.9",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-16.11.9.tgz",
-      "integrity": "sha512-MKmdASMf3LtPzwLyRrFjtFFZ48cMf8jmX5VRYrDQiJa8Ybu5VAmkqBWqKU8fdCwD8ysw4mQ9nrEHvzg6gunR7A==",
-      "dev": true
-    },
-    "node_modules/@types/normalize-package-data": {
-      "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/@types/normalize-package-data/-/normalize-package-data-2.4.1.tgz",
-      "integrity": "sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw==",
+      "version": "18.7.13",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.13.tgz",
+      "integrity": "sha512-46yIhxSe5xEaJZXWdIBP7GU4HDTG8/eo0qd9atdiL+lFpA03y8KS+lkTN834TWJj5767GbWv4n/P6efyTFt1Dw==",
       "dev": true
     },
     "node_modules/@ungap/promise-all-settled": {
@@ -243,9 +75,9 @@
       "dev": true
     },
     "node_modules/ajv": {
-      "version": "8.8.2",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.8.2.tgz",
-      "integrity": "sha512-x9VuX+R/jcFj1DHo/fCp99esgGDWiHENrKxaCENuCxpoMCmAt/COCGVDwA7kleEpEzJjDnvh3yGoOuLu0Dtllw==",
+      "version": "8.11.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.0.tgz",
+      "integrity": "sha512-wGgprdCvMalC0BztXvitD2hC04YffAvtsUn93JbGXYLAtCUO4xd17mCCZQxUOItiBwZvJScWo8NIvQMQ71rdpg==",
       "dev": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
@@ -284,21 +116,6 @@
         "node": ">=6"
       }
     },
-    "node_modules/ansi-escapes": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz",
-      "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==",
-      "dev": true,
-      "dependencies": {
-        "type-fest": "^0.21.3"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/ansi-regex": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
@@ -342,24 +159,6 @@
       "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
       "dev": true
     },
-    "node_modules/array-union": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz",
-      "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==",
-      "dev": true,
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/arrify": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz",
-      "integrity": "sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=",
-      "dev": true,
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
     "node_modules/assertion-error": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz",
@@ -413,9 +212,9 @@
       "dev": true
     },
     "node_modules/camelcase": {
-      "version": "6.2.0",
-      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.2.0.tgz",
-      "integrity": "sha512-c7wVvbw3f37nuobQNtgsgG9POC9qMbNuMQmTCqZv23b6MIz0fcYpBiOlv9gEN/hdLdnZTDQhg6e9Dq5M1vKvfg==",
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz",
+      "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==",
       "dev": true,
       "engines": {
         "node": ">=10"
@@ -424,42 +223,17 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/camelcase-keys": {
-      "version": "6.2.2",
-      "resolved": "https://registry.npmjs.org/camelcase-keys/-/camelcase-keys-6.2.2.tgz",
-      "integrity": "sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg==",
-      "dev": true,
-      "dependencies": {
-        "camelcase": "^5.3.1",
-        "map-obj": "^4.0.0",
-        "quick-lru": "^4.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/camelcase-keys/node_modules/camelcase": {
-      "version": "5.3.1",
-      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
-      "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
-      "dev": true,
-      "engines": {
-        "node": ">=6"
-      }
-    },
     "node_modules/chai": {
-      "version": "4.3.4",
-      "resolved": "https://registry.npmjs.org/chai/-/chai-4.3.4.tgz",
-      "integrity": "sha512-yS5H68VYOCtN1cjfwumDSuzn/9c+yza4f3reKXlE5rUg7SFcCEy90gJvydNgOYtblyf4Zi6jIWRnXOgErta0KA==",
+      "version": "4.3.6",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-4.3.6.tgz",
+      "integrity": "sha512-bbcp3YfHCUzMOvKqsztczerVgBKSsEijCySNlHHbX3VG1nskvqjz5Rfso1gGwD6w6oOV3eI60pKuMOV5MV7p3Q==",
       "dev": true,
       "dependencies": {
         "assertion-error": "^1.1.0",
         "check-error": "^1.0.2",
         "deep-eql": "^3.0.1",
         "get-func-name": "^2.0.0",
+        "loupe": "^2.3.1",
         "pathval": "^1.1.1",
         "type-detect": "^4.0.5"
       },
@@ -498,17 +272,23 @@
     "node_modules/check-error": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.2.tgz",
-      "integrity": "sha1-V00xLt2Iu13YkS6Sht1sCu1KrII=",
+      "integrity": "sha512-BrgHpW9NURQgzoNyjfq0Wu6VFO6D7IZEmJNdtgNqpzGG8RuNFHt2jQxWlAs4HMe119chBnv+34syEZtc6IhLtA==",
       "dev": true,
       "engines": {
         "node": "*"
       }
     },
     "node_modules/chokidar": {
-      "version": "3.5.2",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.2.tgz",
-      "integrity": "sha512-ekGhOnNVPgT77r4K/U3GDhu+FQ2S8TnK/s2KbIGXi0SZWuwkZ2QNyfWdZW+TVfn84DpEP7rLeCt2UI6bJ8GwbQ==",
+      "version": "3.5.3",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
+      "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==",
       "dev": true,
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://paulmillr.com/funding/"
+        }
+      ],
       "dependencies": {
         "anymatch": "~3.1.2",
         "braces": "~3.0.2",
@@ -557,13 +337,13 @@
     "node_modules/concat-map": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
       "dev": true
     },
     "node_modules/debug": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.2.tgz",
-      "integrity": "sha512-mOp8wKcvj7XxC78zLgw/ZA+6TSgkoE2C/ienthhRD298T7UNwAg9diBpLRxC0mOezLl4B0xV7M0cCO6P/O0Xhw==",
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.3.tgz",
+      "integrity": "sha512-/zxw5+vh1Tfv+4Qn7a5nsbcJKPaSvCDhojn6FEl9vupwK2VCSDtEiEtqr8DFtzYFOdz63LBkxec7DYuc2jon6Q==",
       "dev": true,
       "dependencies": {
         "ms": "2.1.2"
@@ -595,37 +375,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/decamelize-keys": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/decamelize-keys/-/decamelize-keys-1.1.0.tgz",
-      "integrity": "sha1-0XGoeTMlKAfrPLYdwcFEXQeN8tk=",
-      "dev": true,
-      "dependencies": {
-        "decamelize": "^1.1.0",
-        "map-obj": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/decamelize-keys/node_modules/decamelize": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
-      "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=",
-      "dev": true,
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/decamelize-keys/node_modules/map-obj": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/map-obj/-/map-obj-1.0.1.tgz",
-      "integrity": "sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0=",
-      "dev": true,
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
     "node_modules/deep-eql": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-3.0.1.tgz",
@@ -647,138 +396,410 @@
         "node": ">=0.3.1"
       }
     },
-    "node_modules/dir-glob": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz",
-      "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==",
-      "dev": true,
-      "dependencies": {
-        "path-type": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/emoji-regex": {
       "version": "8.0.0",
       "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
       "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
       "dev": true
     },
-    "node_modules/error-ex": {
-      "version": "1.3.2",
-      "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz",
-      "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==",
-      "dev": true,
-      "dependencies": {
-        "is-arrayish": "^0.2.1"
-      }
-    },
     "node_modules/esbuild": {
-      "version": "0.12.29",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.12.29.tgz",
-      "integrity": "sha512-w/XuoBCSwepyiZtIRsKsetiLDUVGPVw1E/R3VTFSecIy8UR7Cq3SOtwKHJMFoVqqVG36aGkzh4e8BvpO1Fdc7g==",
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.14.53.tgz",
+      "integrity": "sha512-ohO33pUBQ64q6mmheX1mZ8mIXj8ivQY/L4oVuAshr+aJI+zLl+amrp3EodrUNDNYVrKJXGPfIHFGhO8slGRjuw==",
       "dev": true,
       "hasInstallScript": true,
       "bin": {
         "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/linux-loong64": "0.14.53",
+        "esbuild-android-64": "0.14.53",
+        "esbuild-android-arm64": "0.14.53",
+        "esbuild-darwin-64": "0.14.53",
+        "esbuild-darwin-arm64": "0.14.53",
+        "esbuild-freebsd-64": "0.14.53",
+        "esbuild-freebsd-arm64": "0.14.53",
+        "esbuild-linux-32": "0.14.53",
+        "esbuild-linux-64": "0.14.53",
+        "esbuild-linux-arm": "0.14.53",
+        "esbuild-linux-arm64": "0.14.53",
+        "esbuild-linux-mips64le": "0.14.53",
+        "esbuild-linux-ppc64le": "0.14.53",
+        "esbuild-linux-riscv64": "0.14.53",
+        "esbuild-linux-s390x": "0.14.53",
+        "esbuild-netbsd-64": "0.14.53",
+        "esbuild-openbsd-64": "0.14.53",
+        "esbuild-sunos-64": "0.14.53",
+        "esbuild-windows-32": "0.14.53",
+        "esbuild-windows-64": "0.14.53",
+        "esbuild-windows-arm64": "0.14.53"
+      }
+    },
+    "node_modules/esbuild-android-64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-android-64/-/esbuild-android-64-0.14.53.tgz",
+      "integrity": "sha512-fIL93sOTnEU+NrTAVMIKiAw0YH22HWCAgg4N4Z6zov2t0kY9RAJ50zY9ZMCQ+RT6bnOfDt8gCTnt/RaSNA2yRA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/escalade": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
-      "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==",
+    "node_modules/esbuild-android-arm64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-android-arm64/-/esbuild-android-arm64-0.14.53.tgz",
+      "integrity": "sha512-PC7KaF1v0h/nWpvlU1UMN7dzB54cBH8qSsm7S9mkwFA1BXpaEOufCg8hdoEI1jep0KeO/rjZVWrsH8+q28T77A==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
       "engines": {
-        "node": ">=6"
+        "node": ">=12"
       }
     },
-    "node_modules/escape-string-regexp": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
-      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+    "node_modules/esbuild-darwin-64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-darwin-64/-/esbuild-darwin-64-0.14.53.tgz",
+      "integrity": "sha512-gE7P5wlnkX4d4PKvLBUgmhZXvL7lzGRLri17/+CmmCzfncIgq8lOBvxGMiQ4xazplhxq+72TEohyFMZLFxuWvg==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
       "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">=12"
       }
     },
-    "node_modules/eslint-formatter-pretty": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/eslint-formatter-pretty/-/eslint-formatter-pretty-4.1.0.tgz",
-      "integrity": "sha512-IsUTtGxF1hrH6lMWiSl1WbGaiP01eT6kzywdY1U+zLc0MP+nwEnUiS9UI8IaOTUhTeQJLlCEWIbXINBH4YJbBQ==",
+    "node_modules/esbuild-darwin-arm64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-darwin-arm64/-/esbuild-darwin-arm64-0.14.53.tgz",
+      "integrity": "sha512-otJwDU3hnI15Q98PX4MJbknSZ/WSR1I45il7gcxcECXzfN4Mrpft5hBDHXNRnCh+5858uPXBXA1Vaz2jVWLaIA==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
-      "dependencies": {
-        "@types/eslint": "^7.2.13",
-        "ansi-escapes": "^4.2.1",
-        "chalk": "^4.1.0",
-        "eslint-rule-docs": "^1.1.5",
-        "log-symbols": "^4.0.0",
-        "plur": "^4.0.0",
-        "string-width": "^4.2.0",
-        "supports-hyperlinks": "^2.0.0"
-      },
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
       "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">=12"
       }
     },
-    "node_modules/eslint-rule-docs": {
-      "version": "1.1.231",
-      "resolved": "https://registry.npmjs.org/eslint-rule-docs/-/eslint-rule-docs-1.1.231.tgz",
-      "integrity": "sha512-egHz9A1WG7b8CS0x1P6P/Rj5FqZOjray/VjpJa14tMZalfRKvpE2ONJ3plCM7+PcinmU4tcmbPLv0VtwzSdLVA==",
-      "dev": true
-    },
-    "node_modules/fast-deep-equal": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
-      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
-      "dev": true
-    },
-    "node_modules/fast-glob": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.7.tgz",
-      "integrity": "sha512-rYGMRwip6lUMvYD3BTScMwT1HtAs2d71SMv66Vrxs0IekGZEjhM0pcMfjQPnknBt2zeCwQMEupiN02ZP4DiT1Q==",
+    "node_modules/esbuild-freebsd-64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-freebsd-64/-/esbuild-freebsd-64-0.14.53.tgz",
+      "integrity": "sha512-WkdJa8iyrGHyKiPF4lk0MiOF87Q2SkE+i+8D4Cazq3/iqmGPJ6u49je300MFi5I2eUsQCkaOWhpCVQMTKGww2w==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
-      "dependencies": {
-        "@nodelib/fs.stat": "^2.0.2",
-        "@nodelib/fs.walk": "^1.2.3",
-        "glob-parent": "^5.1.2",
-        "merge2": "^1.3.0",
-        "micromatch": "^4.0.4"
-      },
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
       }
     },
-    "node_modules/fastq": {
-      "version": "1.13.0",
-      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.13.0.tgz",
-      "integrity": "sha512-YpkpUnK8od0o1hmeSc7UUs/eB/vIPWJYjKck2QKIzAf71Vm1AAQ3EbuZB3g2JIy+pg+ERD0vqI79KyZiB2e2Nw==",
+    "node_modules/esbuild-freebsd-arm64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-freebsd-arm64/-/esbuild-freebsd-arm64-0.14.53.tgz",
+      "integrity": "sha512-9T7WwCuV30NAx0SyQpw8edbKvbKELnnm1FHg7gbSYaatH+c8WJW10g/OdM7JYnv7qkimw2ZTtSA+NokOLd2ydQ==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
-      "dependencies": {
-        "reusify": "^1.0.4"
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/fill-range": {
-      "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
-      "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+    "node_modules/esbuild-linux-32": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-32/-/esbuild-linux-32-0.14.53.tgz",
+      "integrity": "sha512-VGanLBg5en2LfGDgLEUxQko2lqsOS7MTEWUi8x91YmsHNyzJVT/WApbFFx3MQGhkf+XdimVhpyo5/G0PBY91zg==",
+      "cpu": [
+        "ia32"
+      ],
       "dev": true,
-      "dependencies": {
-        "to-regex-range": "^5.0.1"
-      },
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
       }
     },
-    "node_modules/find-up": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+    "node_modules/esbuild-linux-64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-64/-/esbuild-linux-64-0.14.53.tgz",
+      "integrity": "sha512-pP/FA55j/fzAV7N9DF31meAyjOH6Bjuo3aSKPh26+RW85ZEtbJv9nhoxmGTd9FOqjx59Tc1ZbrJabuiXlMwuZQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/esbuild-linux-arm": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-arm/-/esbuild-linux-arm-0.14.53.tgz",
+      "integrity": "sha512-/u81NGAVZMopbmzd21Nu/wvnKQK3pT4CrvQ8BTje1STXcQAGnfyKgQlj3m0j2BzYbvQxSy+TMck4TNV2onvoPA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/esbuild-linux-arm64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-arm64/-/esbuild-linux-arm64-0.14.53.tgz",
+      "integrity": "sha512-GDmWITT+PMsjCA6/lByYk7NyFssW4Q6in32iPkpjZ/ytSyH+xeEx8q7HG3AhWH6heemEYEWpTll/eui3jwlSnw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/esbuild-linux-mips64le": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-mips64le/-/esbuild-linux-mips64le-0.14.53.tgz",
+      "integrity": "sha512-d6/XHIQW714gSSp6tOOX2UscedVobELvQlPMkInhx1NPz4ThZI9uNLQ4qQJHGBGKGfu+rtJsxM4NVHLhnNRdWQ==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/esbuild-linux-ppc64le": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-ppc64le/-/esbuild-linux-ppc64le-0.14.53.tgz",
+      "integrity": "sha512-ndnJmniKPCB52m+r6BtHHLAOXw+xBCWIxNnedbIpuREOcbSU/AlyM/2dA3BmUQhsHdb4w3amD5U2s91TJ3MzzA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/esbuild-linux-riscv64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-riscv64/-/esbuild-linux-riscv64-0.14.53.tgz",
+      "integrity": "sha512-yG2sVH+QSix6ct4lIzJj329iJF3MhloLE6/vKMQAAd26UVPVkhMFqFopY+9kCgYsdeWvXdPgmyOuKa48Y7+/EQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/esbuild-linux-s390x": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-s390x/-/esbuild-linux-s390x-0.14.53.tgz",
+      "integrity": "sha512-OCJlgdkB+XPYndHmw6uZT7jcYgzmx9K+28PVdOa/eLjdoYkeAFvH5hTwX4AXGLZLH09tpl4bVsEtvuyUldaNCg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/esbuild-netbsd-64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-netbsd-64/-/esbuild-netbsd-64-0.14.53.tgz",
+      "integrity": "sha512-gp2SB+Efc7MhMdWV2+pmIs/Ja/Mi5rjw+wlDmmbIn68VGXBleNgiEZG+eV2SRS0kJEUyHNedDtwRIMzaohWedQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/esbuild-openbsd-64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-openbsd-64/-/esbuild-openbsd-64-0.14.53.tgz",
+      "integrity": "sha512-eKQ30ZWe+WTZmteDYg8S+YjHV5s4iTxeSGhJKJajFfQx9TLZJvsJX0/paqwP51GicOUruFpSUAs2NCc0a4ivQQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/esbuild-sunos-64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-sunos-64/-/esbuild-sunos-64-0.14.53.tgz",
+      "integrity": "sha512-OWLpS7a2FrIRukQqcgQqR1XKn0jSJoOdT+RlhAxUoEQM/IpytS3FXzCJM6xjUYtpO5GMY0EdZJp+ur2pYdm39g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/esbuild-windows-32": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-32/-/esbuild-windows-32-0.14.53.tgz",
+      "integrity": "sha512-m14XyWQP5rwGW0tbEfp95U6A0wY0DYPInWBB7D69FAXUpBpBObRoGTKRv36lf2RWOdE4YO3TNvj37zhXjVL5xg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/esbuild-windows-64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-64/-/esbuild-windows-64-0.14.53.tgz",
+      "integrity": "sha512-s9skQFF0I7zqnQ2K8S1xdLSfZFsPLuOGmSx57h2btSEswv0N0YodYvqLcJMrNMXh6EynOmWD7rz+0rWWbFpIHQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/esbuild-windows-arm64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-arm64/-/esbuild-windows-arm64-0.14.53.tgz",
+      "integrity": "sha512-E+5Gvb+ZWts+00T9II6wp2L3KG2r3iGxByqd/a1RmLmYWVsSVUjkvIxZuJ3hYTIbhLkH5PRwpldGTKYqVz0nzQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
+      "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==",
+      "dev": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "dev": true
+    },
+    "node_modules/fill-range": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
+      "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+      "dev": true,
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
       "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
       "dev": true,
       "dependencies": {
@@ -804,7 +825,7 @@
     "node_modules/fs.realpath": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
       "dev": true
     },
     "node_modules/fsevents": {
@@ -821,12 +842,6 @@
         "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
       }
     },
-    "node_modules/function-bind": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
-      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
-      "dev": true
-    },
     "node_modules/get-caller-file": {
       "version": "2.0.5",
       "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
@@ -839,16 +854,16 @@
     "node_modules/get-func-name": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.0.tgz",
-      "integrity": "sha1-6td0q+5y4gQJQzoGY2YCPdaIekE=",
+      "integrity": "sha512-Hm0ixYtaSZ/V7C8FJrtZIuBBI+iSgL+1Aq82zSu8VQNB4S3Gk8e7Qs3VwBDJAhmRZcFqkl3tQu36g/Foh5I5ig==",
       "dev": true,
       "engines": {
         "node": "*"
       }
     },
     "node_modules/glob": {
-      "version": "7.1.7",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz",
-      "integrity": "sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==",
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz",
+      "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==",
       "dev": true,
       "dependencies": {
         "fs.realpath": "^1.0.0",
@@ -877,24 +892,16 @@
         "node": ">= 6"
       }
     },
-    "node_modules/globby": {
-      "version": "11.0.4",
-      "resolved": "https://registry.npmjs.org/globby/-/globby-11.0.4.tgz",
-      "integrity": "sha512-9O4MVG9ioZJ08ffbcyVYyLOJLk5JQ688pJ4eMGLpdWLHq/Wr1D9BlriLQyL0E+jbkuePVZXYFj47QM/v093wHg==",
+    "node_modules/glob/node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
       "dev": true,
       "dependencies": {
-        "array-union": "^2.1.0",
-        "dir-glob": "^3.0.1",
-        "fast-glob": "^3.1.1",
-        "ignore": "^5.1.4",
-        "merge2": "^1.3.0",
-        "slash": "^3.0.0"
+        "brace-expansion": "^1.1.7"
       },
       "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": "*"
       }
     },
     "node_modules/growl": {
@@ -906,27 +913,6 @@
         "node": ">=4.x"
       }
     },
-    "node_modules/hard-rejection": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/hard-rejection/-/hard-rejection-2.1.0.tgz",
-      "integrity": "sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==",
-      "dev": true,
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/has": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
-      "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
-      "dev": true,
-      "dependencies": {
-        "function-bind": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4.0"
-      }
-    },
     "node_modules/has-flag": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
@@ -945,40 +931,10 @@
         "he": "bin/he"
       }
     },
-    "node_modules/hosted-git-info": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.0.2.tgz",
-      "integrity": "sha512-c9OGXbZ3guC/xOlCg1Ci/VgWlwsqDv1yMQL1CWqXDL0hDjXuNcq0zuR4xqPSuasI3kqFDhqSyTjREz5gzq0fXg==",
-      "dev": true,
-      "dependencies": {
-        "lru-cache": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/ignore": {
-      "version": "5.1.9",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.1.9.tgz",
-      "integrity": "sha512-2zeMQpbKz5dhZ9IwL0gbxSW5w0NK/MSAMtNuhgIHEPmaU3vPdKPL0UdvUCXs5SS4JAwsBxysK5sFMW8ocFiVjQ==",
-      "dev": true,
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/indent-string": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz",
-      "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==",
-      "dev": true,
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/inflight": {
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
-      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
       "dev": true,
       "dependencies": {
         "once": "^1.3.0",
@@ -991,21 +947,6 @@
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
       "dev": true
     },
-    "node_modules/irregular-plurals": {
-      "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/irregular-plurals/-/irregular-plurals-3.3.0.tgz",
-      "integrity": "sha512-MVBLKUTangM3EfRPFROhmWQQKRDsrgI83J8GS3jXy+OwYqiR2/aoWndYQ5416jLE3uaGgLH7ncme3X9y09gZ3g==",
-      "dev": true,
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/is-arrayish": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
-      "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=",
-      "dev": true
-    },
     "node_modules/is-binary-path": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
@@ -1018,22 +959,10 @@
         "node": ">=8"
       }
     },
-    "node_modules/is-core-module": {
-      "version": "2.8.0",
-      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.8.0.tgz",
-      "integrity": "sha512-vd15qHsaqrRL7dtH6QNuy0ndJmRDrS9HAM1CAiSifNUFv4x1a0CCVsj18hJ1mShxIG6T2i1sO78MkP56r0nYRw==",
-      "dev": true,
-      "dependencies": {
-        "has": "^1.0.3"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/is-extglob": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-      "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
       "dev": true,
       "engines": {
         "node": ">=0.10.0"
@@ -1049,9 +978,9 @@
       }
     },
     "node_modules/is-glob": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.1.tgz",
-      "integrity": "sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==",
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
       "dev": true,
       "dependencies": {
         "is-extglob": "^2.1.1"
@@ -1093,13 +1022,7 @@
     "node_modules/isexe": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=",
-      "dev": true
-    },
-    "node_modules/js-tokens": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
-      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
       "dev": true
     },
     "node_modules/js-yaml": {
@@ -1114,33 +1037,12 @@
         "js-yaml": "bin/js-yaml.js"
       }
     },
-    "node_modules/json-parse-even-better-errors": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
-      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
-      "dev": true
-    },
     "node_modules/json-schema-traverse": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
       "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
       "dev": true
     },
-    "node_modules/kind-of": {
-      "version": "6.0.3",
-      "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz",
-      "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==",
-      "dev": true,
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/lines-and-columns": {
-      "version": "1.1.6",
-      "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.1.6.tgz",
-      "integrity": "sha1-HADHQ7QzzQpOgHWPe2SldEDZ/wA=",
-      "dev": true
-    },
     "node_modules/locate-path": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
@@ -1172,170 +1074,54 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/lru-cache": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
-      "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
+    "node_modules/loupe": {
+      "version": "2.3.4",
+      "resolved": "https://registry.npmjs.org/loupe/-/loupe-2.3.4.tgz",
+      "integrity": "sha512-OvKfgCC2Ndby6aSTREl5aCCPTNIzlDfQZvZxNUrBrihDhL3xcrYegTblhmEiCrg2kKQz4XsFIaemE5BF4ybSaQ==",
       "dev": true,
       "dependencies": {
-        "yallist": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/map-obj": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/map-obj/-/map-obj-4.3.0.tgz",
-      "integrity": "sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==",
-      "dev": true,
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/meow": {
-      "version": "9.0.0",
-      "resolved": "https://registry.npmjs.org/meow/-/meow-9.0.0.tgz",
-      "integrity": "sha512-+obSblOQmRhcyBt62furQqRAQpNyWXo8BuQ5bN7dG8wmwQ+vwHKp/rCFD4CrTP8CsDQD1sjoZ94K417XEUk8IQ==",
-      "dev": true,
-      "dependencies": {
-        "@types/minimist": "^1.2.0",
-        "camelcase-keys": "^6.2.2",
-        "decamelize": "^1.2.0",
-        "decamelize-keys": "^1.1.0",
-        "hard-rejection": "^2.1.0",
-        "minimist-options": "4.1.0",
-        "normalize-package-data": "^3.0.0",
-        "read-pkg-up": "^7.0.1",
-        "redent": "^3.0.0",
-        "trim-newlines": "^3.0.0",
-        "type-fest": "^0.18.0",
-        "yargs-parser": "^20.2.3"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/meow/node_modules/decamelize": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
-      "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=",
-      "dev": true,
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/meow/node_modules/type-fest": {
-      "version": "0.18.1",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.18.1.tgz",
-      "integrity": "sha512-OIAYXk8+ISY+qTOwkHtKqzAuxchoMiD9Udx+FSGQDuiRR+PJKJHc2NJAXlbhkGwTt/4/nKZxELY1w3ReWOL8mw==",
-      "dev": true,
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/merge2": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
-      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
-      "dev": true,
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/micromatch": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.4.tgz",
-      "integrity": "sha512-pRmzw/XUcwXGpD9aI9q/0XOwLNygjETJ8y0ao0wdqprrzDa4YnxLcz7fQRZr8voh8V10kGhABbNcHVk5wHgWwg==",
-      "dev": true,
-      "dependencies": {
-        "braces": "^3.0.1",
-        "picomatch": "^2.2.3"
-      },
-      "engines": {
-        "node": ">=8.6"
-      }
-    },
-    "node_modules/min-indent": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz",
-      "integrity": "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==",
-      "dev": true,
-      "engines": {
-        "node": ">=4"
+        "get-func-name": "^2.0.0"
       }
     },
     "node_modules/minimatch": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
-      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-4.2.1.tgz",
+      "integrity": "sha512-9Uq1ChtSZO+Mxa/CL1eGizn2vRn3MlLgzhT0Iz8zaY8NdvxvB0d5QdPFmCKf7JKA9Lerx5vRrnwO03jsSfGG9g==",
       "dev": true,
       "dependencies": {
         "brace-expansion": "^1.1.7"
       },
       "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/minimist-options": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/minimist-options/-/minimist-options-4.1.0.tgz",
-      "integrity": "sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==",
-      "dev": true,
-      "dependencies": {
-        "arrify": "^1.0.1",
-        "is-plain-obj": "^1.1.0",
-        "kind-of": "^6.0.3"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/minimist-options/node_modules/is-plain-obj": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz",
-      "integrity": "sha1-caUMhCnfync8kqOQpKA7OfzVHT4=",
-      "dev": true,
-      "engines": {
-        "node": ">=0.10.0"
+        "node": ">=10"
       }
     },
     "node_modules/mocha": {
-      "version": "9.1.3",
-      "resolved": "https://registry.npmjs.org/mocha/-/mocha-9.1.3.tgz",
-      "integrity": "sha512-Xcpl9FqXOAYqI3j79pEtHBBnQgVXIhpULjGQa7DVb0Po+VzmSIK9kanAiWLHoRR/dbZ2qpdPshuXr8l1VaHCzw==",
+      "version": "9.2.2",
+      "resolved": "https://registry.npmjs.org/mocha/-/mocha-9.2.2.tgz",
+      "integrity": "sha512-L6XC3EdwT6YrIk0yXpavvLkn8h+EU+Y5UcCHKECyMbdUIxyMuZj4bX4U9e1nvnvUUvQVsV2VHQr5zLdcUkhW/g==",
       "dev": true,
       "dependencies": {
         "@ungap/promise-all-settled": "1.1.2",
         "ansi-colors": "4.1.1",
         "browser-stdout": "1.3.1",
-        "chokidar": "3.5.2",
-        "debug": "4.3.2",
+        "chokidar": "3.5.3",
+        "debug": "4.3.3",
         "diff": "5.0.0",
         "escape-string-regexp": "4.0.0",
         "find-up": "5.0.0",
-        "glob": "7.1.7",
+        "glob": "7.2.0",
         "growl": "1.10.5",
         "he": "1.2.0",
         "js-yaml": "4.1.0",
         "log-symbols": "4.1.0",
-        "minimatch": "3.0.4",
+        "minimatch": "4.2.1",
         "ms": "2.1.3",
-        "nanoid": "3.1.25",
+        "nanoid": "3.3.1",
         "serialize-javascript": "6.0.0",
         "strip-json-comments": "3.1.1",
         "supports-color": "8.1.1",
         "which": "2.0.2",
-        "workerpool": "6.1.5",
+        "workerpool": "6.2.0",
         "yargs": "16.2.0",
         "yargs-parser": "20.2.4",
         "yargs-unparser": "2.0.0"
@@ -1359,9 +1145,9 @@
       "dev": true
     },
     "node_modules/nanoid": {
-      "version": "3.1.25",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.1.25.tgz",
-      "integrity": "sha512-rdwtIXaXCLFAQbnfqDRnI6jaRHp9fTcYBjtFKE8eezcZ7LuLjhUaQGNeMXf1HmRoCH32CLz6XwX0TtxEOS/A3Q==",
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.1.tgz",
+      "integrity": "sha512-n6Vs/3KGyxPQd6uO0eH4Bv0ojGSUvuLlIHtC3Y0kEO23YRge8H9x1GCzLn28YX0H66pMkxuaeESFq4tKISKwdw==",
       "dev": true,
       "bin": {
         "nanoid": "bin/nanoid.cjs"
@@ -1370,21 +1156,6 @@
         "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
       }
     },
-    "node_modules/normalize-package-data": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-3.0.3.tgz",
-      "integrity": "sha512-p2W1sgqij3zMMyRC067Dg16bfzVH+w7hyegmpIvZ4JNjqtGOVAIvLmjBx3yP7YTe9vKJgkoNOPjwQGogDoMXFA==",
-      "dev": true,
-      "dependencies": {
-        "hosted-git-info": "^4.0.1",
-        "is-core-module": "^2.5.0",
-        "semver": "^7.3.4",
-        "validate-npm-package-license": "^3.0.1"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/normalize-path": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
@@ -1397,7 +1168,7 @@
     "node_modules/once": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
       "dev": true,
       "dependencies": {
         "wrappy": "1"
@@ -1433,33 +1204,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/p-try": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz",
-      "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
-      "dev": true,
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/parse-json": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
-      "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
-      "dev": true,
-      "dependencies": {
-        "@babel/code-frame": "^7.0.0",
-        "error-ex": "^1.3.1",
-        "json-parse-even-better-errors": "^2.3.0",
-        "lines-and-columns": "^1.1.6"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/path-exists": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
@@ -1472,27 +1216,12 @@
     "node_modules/path-is-absolute": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
-      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
+      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
       "dev": true,
       "engines": {
         "node": ">=0.10.0"
       }
     },
-    "node_modules/path-parse": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
-      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
-      "dev": true
-    },
-    "node_modules/path-type": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
-      "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==",
-      "dev": true,
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/pathval": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/pathval/-/pathval-1.1.1.tgz",
@@ -1503,9 +1232,9 @@
       }
     },
     "node_modules/picomatch": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.0.tgz",
-      "integrity": "sha512-lY1Q/PiJGC2zOv/z391WOTD+Z02bCgsFfvxoXXf6h7kv9o+WmsmzYqrAwY63sNgOxE4xEdq0WyUnXfKeBrSvYw==",
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
       "dev": true,
       "engines": {
         "node": ">=8.6"
@@ -1514,19 +1243,19 @@
         "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
-    "node_modules/plur": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/plur/-/plur-4.0.0.tgz",
-      "integrity": "sha512-4UGewrYgqDFw9vV6zNV+ADmPAUAfJPKtGvb/VdpQAx25X5f3xXdGdyOEVFwkl8Hl/tl7+xbeHqSEM+D5/TirUg==",
+    "node_modules/prettier": {
+      "version": "2.7.1",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.7.1.tgz",
+      "integrity": "sha512-ujppO+MkdPqoVINuDFDRLClm7D78qbDt0/NR+wp5FqEZOoTNAjPHWj17QRhu7geIHJfcNhRk1XVQmF8Bp3ye+g==",
       "dev": true,
-      "dependencies": {
-        "irregular-plurals": "^3.2.0"
+      "bin": {
+        "prettier": "bin-prettier.js"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">=10.13.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://github.com/prettier/prettier?sponsor=1"
       }
     },
     "node_modules/punycode": {
@@ -1538,35 +1267,6 @@
         "node": ">=6"
       }
     },
-    "node_modules/queue-microtask": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
-      "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ]
-    },
-    "node_modules/quick-lru": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-4.0.1.tgz",
-      "integrity": "sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==",
-      "dev": true,
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/randombytes": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz",
@@ -1576,135 +1276,6 @@
         "safe-buffer": "^5.1.0"
       }
     },
-    "node_modules/read-pkg": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-5.2.0.tgz",
-      "integrity": "sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==",
-      "dev": true,
-      "dependencies": {
-        "@types/normalize-package-data": "^2.4.0",
-        "normalize-package-data": "^2.5.0",
-        "parse-json": "^5.0.0",
-        "type-fest": "^0.6.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/read-pkg-up": {
-      "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-7.0.1.tgz",
-      "integrity": "sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==",
-      "dev": true,
-      "dependencies": {
-        "find-up": "^4.1.0",
-        "read-pkg": "^5.2.0",
-        "type-fest": "^0.8.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/read-pkg-up/node_modules/find-up": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz",
-      "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==",
-      "dev": true,
-      "dependencies": {
-        "locate-path": "^5.0.0",
-        "path-exists": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/read-pkg-up/node_modules/locate-path": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz",
-      "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==",
-      "dev": true,
-      "dependencies": {
-        "p-locate": "^4.1.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/read-pkg-up/node_modules/p-limit": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
-      "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
-      "dev": true,
-      "dependencies": {
-        "p-try": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/read-pkg-up/node_modules/p-locate": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz",
-      "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==",
-      "dev": true,
-      "dependencies": {
-        "p-limit": "^2.2.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/read-pkg-up/node_modules/type-fest": {
-      "version": "0.8.1",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz",
-      "integrity": "sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==",
-      "dev": true,
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/read-pkg/node_modules/hosted-git-info": {
-      "version": "2.8.9",
-      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.9.tgz",
-      "integrity": "sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==",
-      "dev": true
-    },
-    "node_modules/read-pkg/node_modules/normalize-package-data": {
-      "version": "2.5.0",
-      "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz",
-      "integrity": "sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==",
-      "dev": true,
-      "dependencies": {
-        "hosted-git-info": "^2.1.4",
-        "resolve": "^1.10.0",
-        "semver": "2 || 3 || 4 || 5",
-        "validate-npm-package-license": "^3.0.1"
-      }
-    },
-    "node_modules/read-pkg/node_modules/semver": {
-      "version": "5.7.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
-      "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
-      "dev": true,
-      "bin": {
-        "semver": "bin/semver"
-      }
-    },
-    "node_modules/read-pkg/node_modules/type-fest": {
-      "version": "0.6.0",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.6.0.tgz",
-      "integrity": "sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==",
-      "dev": true,
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/readdirp": {
       "version": "3.6.0",
       "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
@@ -1717,81 +1288,22 @@
         "node": ">=8.10.0"
       }
     },
-    "node_modules/redent": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz",
-      "integrity": "sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==",
-      "dev": true,
-      "dependencies": {
-        "indent-string": "^4.0.0",
-        "strip-indent": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/require-directory": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
-      "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=",
-      "dev": true,
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/require-from-string": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
-      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
-      "dev": true,
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/resolve": {
-      "version": "1.20.0",
-      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.20.0.tgz",
-      "integrity": "sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A==",
-      "dev": true,
-      "dependencies": {
-        "is-core-module": "^2.2.0",
-        "path-parse": "^1.0.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/reusify": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz",
-      "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==",
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
       "dev": true,
       "engines": {
-        "iojs": ">=1.0.0",
         "node": ">=0.10.0"
       }
     },
-    "node_modules/run-parallel": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
-      "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
+    "node_modules/require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
       "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "dependencies": {
-        "queue-microtask": "^1.2.2"
+      "engines": {
+        "node": ">=0.10.0"
       }
     },
     "node_modules/safe-buffer": {
@@ -1814,21 +1326,6 @@
         }
       ]
     },
-    "node_modules/semver": {
-      "version": "7.3.5",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.5.tgz",
-      "integrity": "sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==",
-      "dev": true,
-      "dependencies": {
-        "lru-cache": "^6.0.0"
-      },
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/serialize-javascript": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz",
@@ -1838,47 +1335,6 @@
         "randombytes": "^2.1.0"
       }
     },
-    "node_modules/slash": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
-      "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
-      "dev": true,
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/spdx-correct": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.1.tgz",
-      "integrity": "sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w==",
-      "dev": true,
-      "dependencies": {
-        "spdx-expression-parse": "^3.0.0",
-        "spdx-license-ids": "^3.0.0"
-      }
-    },
-    "node_modules/spdx-exceptions": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz",
-      "integrity": "sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A==",
-      "dev": true
-    },
-    "node_modules/spdx-expression-parse": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz",
-      "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==",
-      "dev": true,
-      "dependencies": {
-        "spdx-exceptions": "^2.1.0",
-        "spdx-license-ids": "^3.0.0"
-      }
-    },
-    "node_modules/spdx-license-ids": {
-      "version": "3.0.11",
-      "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.11.tgz",
-      "integrity": "sha512-Ctl2BrFiM0X3MANYgj3CkygxhRmr9mi6xhejbdO960nF6EDJApTYpn0BQnDKlnNBULKiCN1n3w9EBkHK8ZWg+g==",
-      "dev": true
-    },
     "node_modules/string-width": {
       "version": "4.2.3",
       "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
@@ -1905,18 +1361,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/strip-indent": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz",
-      "integrity": "sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==",
-      "dev": true,
-      "dependencies": {
-        "min-indent": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/strip-json-comments": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
@@ -1944,31 +1388,6 @@
         "url": "https://github.com/chalk/supports-color?sponsor=1"
       }
     },
-    "node_modules/supports-hyperlinks": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/supports-hyperlinks/-/supports-hyperlinks-2.2.0.tgz",
-      "integrity": "sha512-6sXEzV5+I5j8Bmq9/vUphGRM/RJNT9SCURJLjwfOg51heRtguGWDzcaBlgAzKhQa0EVNpPEKzQuBwZ8S8WaCeQ==",
-      "dev": true,
-      "dependencies": {
-        "has-flag": "^4.0.0",
-        "supports-color": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/supports-hyperlinks/node_modules/supports-color": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-      "dev": true,
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/to-regex-range": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
@@ -1981,35 +1400,6 @@
         "node": ">=8.0"
       }
     },
-    "node_modules/trim-newlines": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/trim-newlines/-/trim-newlines-3.0.1.tgz",
-      "integrity": "sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw==",
-      "dev": true,
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/tsd": {
-      "version": "0.19.0",
-      "resolved": "https://registry.npmjs.org/tsd/-/tsd-0.19.0.tgz",
-      "integrity": "sha512-DlYCjjRVspfSAC+9X1NUDqPj0PtsVjUSyC4/OJpCGnY2Mtg0ddc+opckmnLV3RhUBpVuAAOrz661v+QSJwINkQ==",
-      "dev": true,
-      "dependencies": {
-        "@tsd/typescript": "~4.5.2",
-        "eslint-formatter-pretty": "^4.1.0",
-        "globby": "^11.0.1",
-        "meow": "^9.0.0",
-        "path-exists": "^4.0.0",
-        "read-pkg-up": "^7.0.0"
-      },
-      "bin": {
-        "tsd": "dist/cli.js"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
     "node_modules/type-detect": {
       "version": "4.0.8",
       "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz",
@@ -2019,22 +1409,10 @@
         "node": ">=4"
       }
     },
-    "node_modules/type-fest": {
-      "version": "0.21.3",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz",
-      "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==",
-      "dev": true,
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/typescript": {
-      "version": "4.5.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.5.2.tgz",
-      "integrity": "sha512-5BlMof9H1yGt0P8/WF+wPNw6GfctgGjXp5hkblpyT+8rkASSmkUKMXrxR0Xg8ThVCi/JnHQiKXeBaEwCeQwMFw==",
+      "version": "4.8.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.8.2.tgz",
+      "integrity": "sha512-C0I1UsrrDHo2fYI5oaCGbSejwX4ch+9Y5jTQELvovfmFkK3HHSZJB8MSJcWLmCUBzQBchCrZ9rMRV6GuNrvGtw==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -2053,16 +1431,6 @@
         "punycode": "^2.1.0"
       }
     },
-    "node_modules/validate-npm-package-license": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz",
-      "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==",
-      "dev": true,
-      "dependencies": {
-        "spdx-correct": "^3.0.0",
-        "spdx-expression-parse": "^3.0.0"
-      }
-    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -2079,9 +1447,9 @@
       }
     },
     "node_modules/workerpool": {
-      "version": "6.1.5",
-      "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.1.5.tgz",
-      "integrity": "sha512-XdKkCK0Zqc6w3iTxLckiuJ81tiD/o5rBE/m+nXpRCB+/Sq4DqkfXZ/x0jW02DG1tGsfUGXbTJyZDP+eu67haSw==",
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.2.0.tgz",
+      "integrity": "sha512-Rsk5qQHJ9eowMH28Jwhe8HEbmdYDX4lwoMWshiCXugjtHqMD9ZbiqSDLxcsfdqsETPzVUtX5s1Z5kStiIM6l4A==",
       "dev": true
     },
     "node_modules/wrap-ansi": {
@@ -2104,7 +1472,7 @@
     "node_modules/wrappy": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
       "dev": true
     },
     "node_modules/y18n": {
@@ -2116,12 +1484,6 @@
         "node": ">=10"
       }
     },
-    "node_modules/yallist": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
-      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
-      "dev": true
-    },
     "node_modules/yargs": {
       "version": "16.2.0",
       "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz",
@@ -2178,181 +1540,39 @@
     }
   },
   "dependencies": {
-    "@babel/code-frame": {
-      "version": "7.16.0",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.16.0.tgz",
-      "integrity": "sha512-IF4EOMEV+bfYwOmNxGzSnjR2EmQod7f1UXOpZM3l4i4o4QNwzjtJAu/HxdjHq0aYBvdqMuQEY1eg0nqW9ZPORA==",
-      "dev": true,
-      "requires": {
-        "@babel/highlight": "^7.16.0"
-      }
-    },
-    "@babel/helper-validator-identifier": {
-      "version": "7.15.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.15.7.tgz",
-      "integrity": "sha512-K4JvCtQqad9OY2+yTU8w+E82ywk/fe+ELNlt1G8z3bVGlZfn/hOcQQsUhGhW/N+tb3fxK800wLtKOE/aM0m72w==",
-      "dev": true
-    },
-    "@babel/highlight": {
-      "version": "7.16.0",
-      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.16.0.tgz",
-      "integrity": "sha512-t8MH41kUQylBtu2+4IQA3atqevA2lRgqA2wyVB/YiWmsDSuylZZuXOUy9ric30hfzauEFfdsuk/eXTRrGrfd0g==",
-      "dev": true,
-      "requires": {
-        "@babel/helper-validator-identifier": "^7.15.7",
-        "chalk": "^2.0.0",
-        "js-tokens": "^4.0.0"
-      },
-      "dependencies": {
-        "ansi-styles": {
-          "version": "3.2.1",
-          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
-          "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
-          "dev": true,
-          "requires": {
-            "color-convert": "^1.9.0"
-          }
-        },
-        "chalk": {
-          "version": "2.4.2",
-          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
-          "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
-          "dev": true,
-          "requires": {
-            "ansi-styles": "^3.2.1",
-            "escape-string-regexp": "^1.0.5",
-            "supports-color": "^5.3.0"
-          }
-        },
-        "color-convert": {
-          "version": "1.9.3",
-          "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
-          "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
-          "dev": true,
-          "requires": {
-            "color-name": "1.1.3"
-          }
-        },
-        "color-name": {
-          "version": "1.1.3",
-          "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-          "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=",
-          "dev": true
-        },
-        "escape-string-regexp": {
-          "version": "1.0.5",
-          "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-          "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=",
-          "dev": true
-        },
-        "has-flag": {
-          "version": "3.0.0",
-          "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-          "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
-          "dev": true
-        },
-        "supports-color": {
-          "version": "5.5.0",
-          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
-          "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
-          "dev": true,
-          "requires": {
-            "has-flag": "^3.0.0"
-          }
-        }
-      }
-    },
-    "@nodelib/fs.scandir": {
-      "version": "2.1.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
-      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
-      "dev": true,
-      "requires": {
-        "@nodelib/fs.stat": "2.0.5",
-        "run-parallel": "^1.1.9"
-      }
-    },
-    "@nodelib/fs.stat": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
-      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
-      "dev": true
-    },
-    "@nodelib/fs.walk": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
-      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+    "@esbuild/linux-loong64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.14.53.tgz",
+      "integrity": "sha512-W2dAL6Bnyn4xa/QRSU3ilIK4EzD5wgYXKXJiS1HDF5vU3675qc2bvFyLwbUcdmssDveyndy7FbitrCoiV/eMLg==",
       "dev": true,
-      "requires": {
-        "@nodelib/fs.scandir": "2.1.5",
-        "fastq": "^1.6.0"
-      }
+      "optional": true
     },
     "@sinclair/hammer": {
-      "version": "0.15.8",
-      "resolved": "https://registry.npmjs.org/@sinclair/hammer/-/hammer-0.15.8.tgz",
-      "integrity": "sha512-XM6SOQkF8HusX6nCZrlwpU1O+QtjNyhvrF0B6loZReJAuAZJJuTd4/fFDErCrp8uGauG8alYNXcpEOmQRvLARw==",
+      "version": "0.17.1",
+      "resolved": "https://registry.npmjs.org/@sinclair/hammer/-/hammer-0.17.1.tgz",
+      "integrity": "sha512-/M7KXwCaXdDmBJXQHpn1NWSTUg7Rmx6vzseVOax7IXhsBYj3vEGU5yt/Xh3XdRLVOEcyl4vGWgJ0pL9cmyrTJA==",
       "dev": true,
       "requires": {
-        "esbuild": "^0.12.24"
+        "@sinclair/hammer": "^0.17.0",
+        "esbuild": "^0.14.53"
       }
     },
-    "@tsd/typescript": {
-      "version": "4.5.2",
-      "resolved": "https://registry.npmjs.org/@tsd/typescript/-/typescript-4.5.2.tgz",
-      "integrity": "sha512-K778wcPuAsJ9Ch0/FlhQcaIMFEi+TfxNi5NSUbgZd3RucaktYUpR++1Ox2mW2G25oyxWb8gfgg+JUhulRbI6eQ==",
-      "dev": true
-    },
     "@types/chai": {
-      "version": "4.2.22",
-      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.2.22.tgz",
-      "integrity": "sha512-tFfcE+DSTzWAgifkjik9AySNqIyNoYwmR+uecPwwD/XRNfvOjmC/FjCxpiUGDkDVDphPfCUecSQVFw+lN3M3kQ==",
-      "dev": true
-    },
-    "@types/eslint": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-7.29.0.tgz",
-      "integrity": "sha512-VNcvioYDH8/FxaeTKkM4/TiTwt6pBV9E3OfGmvaw8tPl0rrHCJ4Ll15HRT+pMiFAf/MLQvAzC+6RzUMEL9Ceng==",
-      "dev": true,
-      "requires": {
-        "@types/estree": "*",
-        "@types/json-schema": "*"
-      }
-    },
-    "@types/estree": {
-      "version": "0.0.50",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.50.tgz",
-      "integrity": "sha512-C6N5s2ZFtuZRj54k2/zyRhNDjJwwcViAM3Nbm8zjBpbqAdZ00mr0CFxvSKeO8Y/e03WVFLpQMdHYVfUd6SB+Hw==",
-      "dev": true
-    },
-    "@types/json-schema": {
-      "version": "7.0.9",
-      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.9.tgz",
-      "integrity": "sha512-qcUXuemtEu+E5wZSJHNxUXeCZhAfXKQ41D+duX+VYPde7xyEVZci+/oXKJL13tnRs9lR2pr4fod59GT6/X1/yQ==",
-      "dev": true
-    },
-    "@types/minimist": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/@types/minimist/-/minimist-1.2.2.tgz",
-      "integrity": "sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==",
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.3.3.tgz",
+      "integrity": "sha512-hC7OMnszpxhZPduX+m+nrx+uFoLkWOMiR4oa/AZF3MuSETYTZmFfJAHqZEM8MVlvfG7BEUcgvtwoCTxBp6hm3g==",
       "dev": true
     },
     "@types/mocha": {
-      "version": "9.0.0",
-      "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-9.0.0.tgz",
-      "integrity": "sha512-scN0hAWyLVAvLR9AyW7HoFF5sJZglyBsbPuHO4fv7JRvfmPBMfp1ozWqOf/e4wwPNxezBZXRfWzMb6iFLgEVRA==",
+      "version": "9.1.1",
+      "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-9.1.1.tgz",
+      "integrity": "sha512-Z61JK7DKDtdKTWwLeElSEBcWGRLY8g95ic5FoQqI9CMx0ns/Ghep3B4DfcEimiKMvtamNVULVNKEsiwV3aQmXw==",
       "dev": true
     },
     "@types/node": {
-      "version": "16.11.9",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-16.11.9.tgz",
-      "integrity": "sha512-MKmdASMf3LtPzwLyRrFjtFFZ48cMf8jmX5VRYrDQiJa8Ybu5VAmkqBWqKU8fdCwD8ysw4mQ9nrEHvzg6gunR7A==",
-      "dev": true
-    },
-    "@types/normalize-package-data": {
-      "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/@types/normalize-package-data/-/normalize-package-data-2.4.1.tgz",
-      "integrity": "sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw==",
+      "version": "18.7.13",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.13.tgz",
+      "integrity": "sha512-46yIhxSe5xEaJZXWdIBP7GU4HDTG8/eo0qd9atdiL+lFpA03y8KS+lkTN834TWJj5767GbWv4n/P6efyTFt1Dw==",
       "dev": true
     },
     "@ungap/promise-all-settled": {
@@ -2362,9 +1582,9 @@
       "dev": true
     },
     "ajv": {
-      "version": "8.8.2",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.8.2.tgz",
-      "integrity": "sha512-x9VuX+R/jcFj1DHo/fCp99esgGDWiHENrKxaCENuCxpoMCmAt/COCGVDwA7kleEpEzJjDnvh3yGoOuLu0Dtllw==",
+      "version": "8.11.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.0.tgz",
+      "integrity": "sha512-wGgprdCvMalC0BztXvitD2hC04YffAvtsUn93JbGXYLAtCUO4xd17mCCZQxUOItiBwZvJScWo8NIvQMQ71rdpg==",
       "dev": true,
       "requires": {
         "fast-deep-equal": "^3.1.1",
@@ -2388,15 +1608,6 @@
       "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==",
       "dev": true
     },
-    "ansi-escapes": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz",
-      "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==",
-      "dev": true,
-      "requires": {
-        "type-fest": "^0.21.3"
-      }
-    },
     "ansi-regex": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
@@ -2428,18 +1639,6 @@
       "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
       "dev": true
     },
-    "array-union": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz",
-      "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==",
-      "dev": true
-    },
-    "arrify": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz",
-      "integrity": "sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=",
-      "dev": true
-    },
     "assertion-error": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz",
@@ -2484,40 +1683,22 @@
       "dev": true
     },
     "camelcase": {
-      "version": "6.2.0",
-      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.2.0.tgz",
-      "integrity": "sha512-c7wVvbw3f37nuobQNtgsgG9POC9qMbNuMQmTCqZv23b6MIz0fcYpBiOlv9gEN/hdLdnZTDQhg6e9Dq5M1vKvfg==",
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz",
+      "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==",
       "dev": true
     },
-    "camelcase-keys": {
-      "version": "6.2.2",
-      "resolved": "https://registry.npmjs.org/camelcase-keys/-/camelcase-keys-6.2.2.tgz",
-      "integrity": "sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg==",
-      "dev": true,
-      "requires": {
-        "camelcase": "^5.3.1",
-        "map-obj": "^4.0.0",
-        "quick-lru": "^4.0.1"
-      },
-      "dependencies": {
-        "camelcase": {
-          "version": "5.3.1",
-          "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
-          "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
-          "dev": true
-        }
-      }
-    },
     "chai": {
-      "version": "4.3.4",
-      "resolved": "https://registry.npmjs.org/chai/-/chai-4.3.4.tgz",
-      "integrity": "sha512-yS5H68VYOCtN1cjfwumDSuzn/9c+yza4f3reKXlE5rUg7SFcCEy90gJvydNgOYtblyf4Zi6jIWRnXOgErta0KA==",
+      "version": "4.3.6",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-4.3.6.tgz",
+      "integrity": "sha512-bbcp3YfHCUzMOvKqsztczerVgBKSsEijCySNlHHbX3VG1nskvqjz5Rfso1gGwD6w6oOV3eI60pKuMOV5MV7p3Q==",
       "dev": true,
       "requires": {
         "assertion-error": "^1.1.0",
         "check-error": "^1.0.2",
         "deep-eql": "^3.0.1",
         "get-func-name": "^2.0.0",
+        "loupe": "^2.3.1",
         "pathval": "^1.1.1",
         "type-detect": "^4.0.5"
       }
@@ -2546,13 +1727,13 @@
     "check-error": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.2.tgz",
-      "integrity": "sha1-V00xLt2Iu13YkS6Sht1sCu1KrII=",
+      "integrity": "sha512-BrgHpW9NURQgzoNyjfq0Wu6VFO6D7IZEmJNdtgNqpzGG8RuNFHt2jQxWlAs4HMe119chBnv+34syEZtc6IhLtA==",
       "dev": true
     },
     "chokidar": {
-      "version": "3.5.2",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.2.tgz",
-      "integrity": "sha512-ekGhOnNVPgT77r4K/U3GDhu+FQ2S8TnK/s2KbIGXi0SZWuwkZ2QNyfWdZW+TVfn84DpEP7rLeCt2UI6bJ8GwbQ==",
+      "version": "3.5.3",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
+      "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==",
       "dev": true,
       "requires": {
         "anymatch": "~3.1.2",
@@ -2594,13 +1775,13 @@
     "concat-map": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
       "dev": true
     },
     "debug": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.2.tgz",
-      "integrity": "sha512-mOp8wKcvj7XxC78zLgw/ZA+6TSgkoE2C/ienthhRD298T7UNwAg9diBpLRxC0mOezLl4B0xV7M0cCO6P/O0Xhw==",
+      "version": "4.3.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.3.tgz",
+      "integrity": "sha512-/zxw5+vh1Tfv+4Qn7a5nsbcJKPaSvCDhojn6FEl9vupwK2VCSDtEiEtqr8DFtzYFOdz63LBkxec7DYuc2jon6Q==",
       "dev": true,
       "requires": {
         "ms": "2.1.2"
@@ -2620,30 +1801,6 @@
       "integrity": "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==",
       "dev": true
     },
-    "decamelize-keys": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/decamelize-keys/-/decamelize-keys-1.1.0.tgz",
-      "integrity": "sha1-0XGoeTMlKAfrPLYdwcFEXQeN8tk=",
-      "dev": true,
-      "requires": {
-        "decamelize": "^1.1.0",
-        "map-obj": "^1.0.0"
-      },
-      "dependencies": {
-        "decamelize": {
-          "version": "1.2.0",
-          "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
-          "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=",
-          "dev": true
-        },
-        "map-obj": {
-          "version": "1.0.1",
-          "resolved": "https://registry.npmjs.org/map-obj/-/map-obj-1.0.1.tgz",
-          "integrity": "sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0=",
-          "dev": true
-        }
-      }
-    },
     "deep-eql": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-3.0.1.tgz",
@@ -2659,35 +1816,180 @@
       "integrity": "sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==",
       "dev": true
     },
-    "dir-glob": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz",
-      "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==",
+    "emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true
+    },
+    "esbuild": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.14.53.tgz",
+      "integrity": "sha512-ohO33pUBQ64q6mmheX1mZ8mIXj8ivQY/L4oVuAshr+aJI+zLl+amrp3EodrUNDNYVrKJXGPfIHFGhO8slGRjuw==",
+      "dev": true,
+      "requires": {
+        "@esbuild/linux-loong64": "0.14.53",
+        "esbuild-android-64": "0.14.53",
+        "esbuild-android-arm64": "0.14.53",
+        "esbuild-darwin-64": "0.14.53",
+        "esbuild-darwin-arm64": "0.14.53",
+        "esbuild-freebsd-64": "0.14.53",
+        "esbuild-freebsd-arm64": "0.14.53",
+        "esbuild-linux-32": "0.14.53",
+        "esbuild-linux-64": "0.14.53",
+        "esbuild-linux-arm": "0.14.53",
+        "esbuild-linux-arm64": "0.14.53",
+        "esbuild-linux-mips64le": "0.14.53",
+        "esbuild-linux-ppc64le": "0.14.53",
+        "esbuild-linux-riscv64": "0.14.53",
+        "esbuild-linux-s390x": "0.14.53",
+        "esbuild-netbsd-64": "0.14.53",
+        "esbuild-openbsd-64": "0.14.53",
+        "esbuild-sunos-64": "0.14.53",
+        "esbuild-windows-32": "0.14.53",
+        "esbuild-windows-64": "0.14.53",
+        "esbuild-windows-arm64": "0.14.53"
+      }
+    },
+    "esbuild-android-64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-android-64/-/esbuild-android-64-0.14.53.tgz",
+      "integrity": "sha512-fIL93sOTnEU+NrTAVMIKiAw0YH22HWCAgg4N4Z6zov2t0kY9RAJ50zY9ZMCQ+RT6bnOfDt8gCTnt/RaSNA2yRA==",
+      "dev": true,
+      "optional": true
+    },
+    "esbuild-android-arm64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-android-arm64/-/esbuild-android-arm64-0.14.53.tgz",
+      "integrity": "sha512-PC7KaF1v0h/nWpvlU1UMN7dzB54cBH8qSsm7S9mkwFA1BXpaEOufCg8hdoEI1jep0KeO/rjZVWrsH8+q28T77A==",
+      "dev": true,
+      "optional": true
+    },
+    "esbuild-darwin-64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-darwin-64/-/esbuild-darwin-64-0.14.53.tgz",
+      "integrity": "sha512-gE7P5wlnkX4d4PKvLBUgmhZXvL7lzGRLri17/+CmmCzfncIgq8lOBvxGMiQ4xazplhxq+72TEohyFMZLFxuWvg==",
+      "dev": true,
+      "optional": true
+    },
+    "esbuild-darwin-arm64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-darwin-arm64/-/esbuild-darwin-arm64-0.14.53.tgz",
+      "integrity": "sha512-otJwDU3hnI15Q98PX4MJbknSZ/WSR1I45il7gcxcECXzfN4Mrpft5hBDHXNRnCh+5858uPXBXA1Vaz2jVWLaIA==",
+      "dev": true,
+      "optional": true
+    },
+    "esbuild-freebsd-64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-freebsd-64/-/esbuild-freebsd-64-0.14.53.tgz",
+      "integrity": "sha512-WkdJa8iyrGHyKiPF4lk0MiOF87Q2SkE+i+8D4Cazq3/iqmGPJ6u49je300MFi5I2eUsQCkaOWhpCVQMTKGww2w==",
+      "dev": true,
+      "optional": true
+    },
+    "esbuild-freebsd-arm64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-freebsd-arm64/-/esbuild-freebsd-arm64-0.14.53.tgz",
+      "integrity": "sha512-9T7WwCuV30NAx0SyQpw8edbKvbKELnnm1FHg7gbSYaatH+c8WJW10g/OdM7JYnv7qkimw2ZTtSA+NokOLd2ydQ==",
+      "dev": true,
+      "optional": true
+    },
+    "esbuild-linux-32": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-32/-/esbuild-linux-32-0.14.53.tgz",
+      "integrity": "sha512-VGanLBg5en2LfGDgLEUxQko2lqsOS7MTEWUi8x91YmsHNyzJVT/WApbFFx3MQGhkf+XdimVhpyo5/G0PBY91zg==",
+      "dev": true,
+      "optional": true
+    },
+    "esbuild-linux-64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-64/-/esbuild-linux-64-0.14.53.tgz",
+      "integrity": "sha512-pP/FA55j/fzAV7N9DF31meAyjOH6Bjuo3aSKPh26+RW85ZEtbJv9nhoxmGTd9FOqjx59Tc1ZbrJabuiXlMwuZQ==",
+      "dev": true,
+      "optional": true
+    },
+    "esbuild-linux-arm": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-arm/-/esbuild-linux-arm-0.14.53.tgz",
+      "integrity": "sha512-/u81NGAVZMopbmzd21Nu/wvnKQK3pT4CrvQ8BTje1STXcQAGnfyKgQlj3m0j2BzYbvQxSy+TMck4TNV2onvoPA==",
+      "dev": true,
+      "optional": true
+    },
+    "esbuild-linux-arm64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-arm64/-/esbuild-linux-arm64-0.14.53.tgz",
+      "integrity": "sha512-GDmWITT+PMsjCA6/lByYk7NyFssW4Q6in32iPkpjZ/ytSyH+xeEx8q7HG3AhWH6heemEYEWpTll/eui3jwlSnw==",
+      "dev": true,
+      "optional": true
+    },
+    "esbuild-linux-mips64le": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-mips64le/-/esbuild-linux-mips64le-0.14.53.tgz",
+      "integrity": "sha512-d6/XHIQW714gSSp6tOOX2UscedVobELvQlPMkInhx1NPz4ThZI9uNLQ4qQJHGBGKGfu+rtJsxM4NVHLhnNRdWQ==",
+      "dev": true,
+      "optional": true
+    },
+    "esbuild-linux-ppc64le": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-ppc64le/-/esbuild-linux-ppc64le-0.14.53.tgz",
+      "integrity": "sha512-ndnJmniKPCB52m+r6BtHHLAOXw+xBCWIxNnedbIpuREOcbSU/AlyM/2dA3BmUQhsHdb4w3amD5U2s91TJ3MzzA==",
+      "dev": true,
+      "optional": true
+    },
+    "esbuild-linux-riscv64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-riscv64/-/esbuild-linux-riscv64-0.14.53.tgz",
+      "integrity": "sha512-yG2sVH+QSix6ct4lIzJj329iJF3MhloLE6/vKMQAAd26UVPVkhMFqFopY+9kCgYsdeWvXdPgmyOuKa48Y7+/EQ==",
+      "dev": true,
+      "optional": true
+    },
+    "esbuild-linux-s390x": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-s390x/-/esbuild-linux-s390x-0.14.53.tgz",
+      "integrity": "sha512-OCJlgdkB+XPYndHmw6uZT7jcYgzmx9K+28PVdOa/eLjdoYkeAFvH5hTwX4AXGLZLH09tpl4bVsEtvuyUldaNCg==",
+      "dev": true,
+      "optional": true
+    },
+    "esbuild-netbsd-64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-netbsd-64/-/esbuild-netbsd-64-0.14.53.tgz",
+      "integrity": "sha512-gp2SB+Efc7MhMdWV2+pmIs/Ja/Mi5rjw+wlDmmbIn68VGXBleNgiEZG+eV2SRS0kJEUyHNedDtwRIMzaohWedQ==",
+      "dev": true,
+      "optional": true
+    },
+    "esbuild-openbsd-64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-openbsd-64/-/esbuild-openbsd-64-0.14.53.tgz",
+      "integrity": "sha512-eKQ30ZWe+WTZmteDYg8S+YjHV5s4iTxeSGhJKJajFfQx9TLZJvsJX0/paqwP51GicOUruFpSUAs2NCc0a4ivQQ==",
+      "dev": true,
+      "optional": true
+    },
+    "esbuild-sunos-64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-sunos-64/-/esbuild-sunos-64-0.14.53.tgz",
+      "integrity": "sha512-OWLpS7a2FrIRukQqcgQqR1XKn0jSJoOdT+RlhAxUoEQM/IpytS3FXzCJM6xjUYtpO5GMY0EdZJp+ur2pYdm39g==",
       "dev": true,
-      "requires": {
-        "path-type": "^4.0.0"
-      }
+      "optional": true
     },
-    "emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "dev": true
+    "esbuild-windows-32": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-32/-/esbuild-windows-32-0.14.53.tgz",
+      "integrity": "sha512-m14XyWQP5rwGW0tbEfp95U6A0wY0DYPInWBB7D69FAXUpBpBObRoGTKRv36lf2RWOdE4YO3TNvj37zhXjVL5xg==",
+      "dev": true,
+      "optional": true
     },
-    "error-ex": {
-      "version": "1.3.2",
-      "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz",
-      "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==",
+    "esbuild-windows-64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-64/-/esbuild-windows-64-0.14.53.tgz",
+      "integrity": "sha512-s9skQFF0I7zqnQ2K8S1xdLSfZFsPLuOGmSx57h2btSEswv0N0YodYvqLcJMrNMXh6EynOmWD7rz+0rWWbFpIHQ==",
       "dev": true,
-      "requires": {
-        "is-arrayish": "^0.2.1"
-      }
+      "optional": true
     },
-    "esbuild": {
-      "version": "0.12.29",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.12.29.tgz",
-      "integrity": "sha512-w/XuoBCSwepyiZtIRsKsetiLDUVGPVw1E/R3VTFSecIy8UR7Cq3SOtwKHJMFoVqqVG36aGkzh4e8BvpO1Fdc7g==",
-      "dev": true
+    "esbuild-windows-arm64": {
+      "version": "0.14.53",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-arm64/-/esbuild-windows-arm64-0.14.53.tgz",
+      "integrity": "sha512-E+5Gvb+ZWts+00T9II6wp2L3KG2r3iGxByqd/a1RmLmYWVsSVUjkvIxZuJ3hYTIbhLkH5PRwpldGTKYqVz0nzQ==",
+      "dev": true,
+      "optional": true
     },
     "escalade": {
       "version": "3.1.1",
@@ -2701,56 +2003,12 @@
       "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
       "dev": true
     },
-    "eslint-formatter-pretty": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/eslint-formatter-pretty/-/eslint-formatter-pretty-4.1.0.tgz",
-      "integrity": "sha512-IsUTtGxF1hrH6lMWiSl1WbGaiP01eT6kzywdY1U+zLc0MP+nwEnUiS9UI8IaOTUhTeQJLlCEWIbXINBH4YJbBQ==",
-      "dev": true,
-      "requires": {
-        "@types/eslint": "^7.2.13",
-        "ansi-escapes": "^4.2.1",
-        "chalk": "^4.1.0",
-        "eslint-rule-docs": "^1.1.5",
-        "log-symbols": "^4.0.0",
-        "plur": "^4.0.0",
-        "string-width": "^4.2.0",
-        "supports-hyperlinks": "^2.0.0"
-      }
-    },
-    "eslint-rule-docs": {
-      "version": "1.1.231",
-      "resolved": "https://registry.npmjs.org/eslint-rule-docs/-/eslint-rule-docs-1.1.231.tgz",
-      "integrity": "sha512-egHz9A1WG7b8CS0x1P6P/Rj5FqZOjray/VjpJa14tMZalfRKvpE2ONJ3plCM7+PcinmU4tcmbPLv0VtwzSdLVA==",
-      "dev": true
-    },
     "fast-deep-equal": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
       "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
       "dev": true
     },
-    "fast-glob": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.7.tgz",
-      "integrity": "sha512-rYGMRwip6lUMvYD3BTScMwT1HtAs2d71SMv66Vrxs0IekGZEjhM0pcMfjQPnknBt2zeCwQMEupiN02ZP4DiT1Q==",
-      "dev": true,
-      "requires": {
-        "@nodelib/fs.stat": "^2.0.2",
-        "@nodelib/fs.walk": "^1.2.3",
-        "glob-parent": "^5.1.2",
-        "merge2": "^1.3.0",
-        "micromatch": "^4.0.4"
-      }
-    },
-    "fastq": {
-      "version": "1.13.0",
-      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.13.0.tgz",
-      "integrity": "sha512-YpkpUnK8od0o1hmeSc7UUs/eB/vIPWJYjKck2QKIzAf71Vm1AAQ3EbuZB3g2JIy+pg+ERD0vqI79KyZiB2e2Nw==",
-      "dev": true,
-      "requires": {
-        "reusify": "^1.0.4"
-      }
-    },
     "fill-range": {
       "version": "7.0.1",
       "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
@@ -2779,7 +2037,7 @@
     "fs.realpath": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
       "dev": true
     },
     "fsevents": {
@@ -2789,12 +2047,6 @@
       "dev": true,
       "optional": true
     },
-    "function-bind": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
-      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
-      "dev": true
-    },
     "get-caller-file": {
       "version": "2.0.5",
       "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
@@ -2804,13 +2056,13 @@
     "get-func-name": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.0.tgz",
-      "integrity": "sha1-6td0q+5y4gQJQzoGY2YCPdaIekE=",
+      "integrity": "sha512-Hm0ixYtaSZ/V7C8FJrtZIuBBI+iSgL+1Aq82zSu8VQNB4S3Gk8e7Qs3VwBDJAhmRZcFqkl3tQu36g/Foh5I5ig==",
       "dev": true
     },
     "glob": {
-      "version": "7.1.7",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz",
-      "integrity": "sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==",
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz",
+      "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==",
       "dev": true,
       "requires": {
         "fs.realpath": "^1.0.0",
@@ -2819,6 +2071,17 @@
         "minimatch": "^3.0.4",
         "once": "^1.3.0",
         "path-is-absolute": "^1.0.0"
+      },
+      "dependencies": {
+        "minimatch": {
+          "version": "3.1.2",
+          "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+          "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+          "dev": true,
+          "requires": {
+            "brace-expansion": "^1.1.7"
+          }
+        }
       }
     },
     "glob-parent": {
@@ -2830,41 +2093,12 @@
         "is-glob": "^4.0.1"
       }
     },
-    "globby": {
-      "version": "11.0.4",
-      "resolved": "https://registry.npmjs.org/globby/-/globby-11.0.4.tgz",
-      "integrity": "sha512-9O4MVG9ioZJ08ffbcyVYyLOJLk5JQ688pJ4eMGLpdWLHq/Wr1D9BlriLQyL0E+jbkuePVZXYFj47QM/v093wHg==",
-      "dev": true,
-      "requires": {
-        "array-union": "^2.1.0",
-        "dir-glob": "^3.0.1",
-        "fast-glob": "^3.1.1",
-        "ignore": "^5.1.4",
-        "merge2": "^1.3.0",
-        "slash": "^3.0.0"
-      }
-    },
     "growl": {
       "version": "1.10.5",
       "resolved": "https://registry.npmjs.org/growl/-/growl-1.10.5.tgz",
       "integrity": "sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==",
       "dev": true
     },
-    "hard-rejection": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/hard-rejection/-/hard-rejection-2.1.0.tgz",
-      "integrity": "sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==",
-      "dev": true
-    },
-    "has": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
-      "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
-      "dev": true,
-      "requires": {
-        "function-bind": "^1.1.1"
-      }
-    },
     "has-flag": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
@@ -2877,31 +2111,10 @@
       "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==",
       "dev": true
     },
-    "hosted-git-info": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.0.2.tgz",
-      "integrity": "sha512-c9OGXbZ3guC/xOlCg1Ci/VgWlwsqDv1yMQL1CWqXDL0hDjXuNcq0zuR4xqPSuasI3kqFDhqSyTjREz5gzq0fXg==",
-      "dev": true,
-      "requires": {
-        "lru-cache": "^6.0.0"
-      }
-    },
-    "ignore": {
-      "version": "5.1.9",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.1.9.tgz",
-      "integrity": "sha512-2zeMQpbKz5dhZ9IwL0gbxSW5w0NK/MSAMtNuhgIHEPmaU3vPdKPL0UdvUCXs5SS4JAwsBxysK5sFMW8ocFiVjQ==",
-      "dev": true
-    },
-    "indent-string": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz",
-      "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==",
-      "dev": true
-    },
     "inflight": {
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
-      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
       "dev": true,
       "requires": {
         "once": "^1.3.0",
@@ -2914,18 +2127,6 @@
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
       "dev": true
     },
-    "irregular-plurals": {
-      "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/irregular-plurals/-/irregular-plurals-3.3.0.tgz",
-      "integrity": "sha512-MVBLKUTangM3EfRPFROhmWQQKRDsrgI83J8GS3jXy+OwYqiR2/aoWndYQ5416jLE3uaGgLH7ncme3X9y09gZ3g==",
-      "dev": true
-    },
-    "is-arrayish": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
-      "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=",
-      "dev": true
-    },
     "is-binary-path": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
@@ -2935,19 +2136,10 @@
         "binary-extensions": "^2.0.0"
       }
     },
-    "is-core-module": {
-      "version": "2.8.0",
-      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.8.0.tgz",
-      "integrity": "sha512-vd15qHsaqrRL7dtH6QNuy0ndJmRDrS9HAM1CAiSifNUFv4x1a0CCVsj18hJ1mShxIG6T2i1sO78MkP56r0nYRw==",
-      "dev": true,
-      "requires": {
-        "has": "^1.0.3"
-      }
-    },
     "is-extglob": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-      "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
       "dev": true
     },
     "is-fullwidth-code-point": {
@@ -2957,9 +2149,9 @@
       "dev": true
     },
     "is-glob": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.1.tgz",
-      "integrity": "sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==",
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
       "dev": true,
       "requires": {
         "is-extglob": "^2.1.1"
@@ -2986,13 +2178,7 @@
     "isexe": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=",
-      "dev": true
-    },
-    "js-tokens": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
-      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
       "dev": true
     },
     "js-yaml": {
@@ -3004,30 +2190,12 @@
         "argparse": "^2.0.1"
       }
     },
-    "json-parse-even-better-errors": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
-      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
-      "dev": true
-    },
     "json-schema-traverse": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
       "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
       "dev": true
     },
-    "kind-of": {
-      "version": "6.0.3",
-      "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz",
-      "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==",
-      "dev": true
-    },
-    "lines-and-columns": {
-      "version": "1.1.6",
-      "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.1.6.tgz",
-      "integrity": "sha1-HADHQ7QzzQpOgHWPe2SldEDZ/wA=",
-      "dev": true
-    },
     "locate-path": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
@@ -3047,132 +2215,51 @@
         "is-unicode-supported": "^0.1.0"
       }
     },
-    "lru-cache": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
-      "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
-      "dev": true,
-      "requires": {
-        "yallist": "^4.0.0"
-      }
-    },
-    "map-obj": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/map-obj/-/map-obj-4.3.0.tgz",
-      "integrity": "sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==",
-      "dev": true
-    },
-    "meow": {
-      "version": "9.0.0",
-      "resolved": "https://registry.npmjs.org/meow/-/meow-9.0.0.tgz",
-      "integrity": "sha512-+obSblOQmRhcyBt62furQqRAQpNyWXo8BuQ5bN7dG8wmwQ+vwHKp/rCFD4CrTP8CsDQD1sjoZ94K417XEUk8IQ==",
-      "dev": true,
-      "requires": {
-        "@types/minimist": "^1.2.0",
-        "camelcase-keys": "^6.2.2",
-        "decamelize": "^1.2.0",
-        "decamelize-keys": "^1.1.0",
-        "hard-rejection": "^2.1.0",
-        "minimist-options": "4.1.0",
-        "normalize-package-data": "^3.0.0",
-        "read-pkg-up": "^7.0.1",
-        "redent": "^3.0.0",
-        "trim-newlines": "^3.0.0",
-        "type-fest": "^0.18.0",
-        "yargs-parser": "^20.2.3"
-      },
-      "dependencies": {
-        "decamelize": {
-          "version": "1.2.0",
-          "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
-          "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=",
-          "dev": true
-        },
-        "type-fest": {
-          "version": "0.18.1",
-          "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.18.1.tgz",
-          "integrity": "sha512-OIAYXk8+ISY+qTOwkHtKqzAuxchoMiD9Udx+FSGQDuiRR+PJKJHc2NJAXlbhkGwTt/4/nKZxELY1w3ReWOL8mw==",
-          "dev": true
-        }
-      }
-    },
-    "merge2": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
-      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
-      "dev": true
-    },
-    "micromatch": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.4.tgz",
-      "integrity": "sha512-pRmzw/XUcwXGpD9aI9q/0XOwLNygjETJ8y0ao0wdqprrzDa4YnxLcz7fQRZr8voh8V10kGhABbNcHVk5wHgWwg==",
+    "loupe": {
+      "version": "2.3.4",
+      "resolved": "https://registry.npmjs.org/loupe/-/loupe-2.3.4.tgz",
+      "integrity": "sha512-OvKfgCC2Ndby6aSTREl5aCCPTNIzlDfQZvZxNUrBrihDhL3xcrYegTblhmEiCrg2kKQz4XsFIaemE5BF4ybSaQ==",
       "dev": true,
       "requires": {
-        "braces": "^3.0.1",
-        "picomatch": "^2.2.3"
+        "get-func-name": "^2.0.0"
       }
     },
-    "min-indent": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz",
-      "integrity": "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==",
-      "dev": true
-    },
     "minimatch": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
-      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-4.2.1.tgz",
+      "integrity": "sha512-9Uq1ChtSZO+Mxa/CL1eGizn2vRn3MlLgzhT0Iz8zaY8NdvxvB0d5QdPFmCKf7JKA9Lerx5vRrnwO03jsSfGG9g==",
       "dev": true,
       "requires": {
         "brace-expansion": "^1.1.7"
       }
     },
-    "minimist-options": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/minimist-options/-/minimist-options-4.1.0.tgz",
-      "integrity": "sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==",
-      "dev": true,
-      "requires": {
-        "arrify": "^1.0.1",
-        "is-plain-obj": "^1.1.0",
-        "kind-of": "^6.0.3"
-      },
-      "dependencies": {
-        "is-plain-obj": {
-          "version": "1.1.0",
-          "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz",
-          "integrity": "sha1-caUMhCnfync8kqOQpKA7OfzVHT4=",
-          "dev": true
-        }
-      }
-    },
     "mocha": {
-      "version": "9.1.3",
-      "resolved": "https://registry.npmjs.org/mocha/-/mocha-9.1.3.tgz",
-      "integrity": "sha512-Xcpl9FqXOAYqI3j79pEtHBBnQgVXIhpULjGQa7DVb0Po+VzmSIK9kanAiWLHoRR/dbZ2qpdPshuXr8l1VaHCzw==",
+      "version": "9.2.2",
+      "resolved": "https://registry.npmjs.org/mocha/-/mocha-9.2.2.tgz",
+      "integrity": "sha512-L6XC3EdwT6YrIk0yXpavvLkn8h+EU+Y5UcCHKECyMbdUIxyMuZj4bX4U9e1nvnvUUvQVsV2VHQr5zLdcUkhW/g==",
       "dev": true,
       "requires": {
         "@ungap/promise-all-settled": "1.1.2",
         "ansi-colors": "4.1.1",
         "browser-stdout": "1.3.1",
-        "chokidar": "3.5.2",
-        "debug": "4.3.2",
+        "chokidar": "3.5.3",
+        "debug": "4.3.3",
         "diff": "5.0.0",
         "escape-string-regexp": "4.0.0",
         "find-up": "5.0.0",
-        "glob": "7.1.7",
+        "glob": "7.2.0",
         "growl": "1.10.5",
         "he": "1.2.0",
         "js-yaml": "4.1.0",
         "log-symbols": "4.1.0",
-        "minimatch": "3.0.4",
+        "minimatch": "4.2.1",
         "ms": "2.1.3",
-        "nanoid": "3.1.25",
+        "nanoid": "3.3.1",
         "serialize-javascript": "6.0.0",
         "strip-json-comments": "3.1.1",
         "supports-color": "8.1.1",
         "which": "2.0.2",
-        "workerpool": "6.1.5",
+        "workerpool": "6.2.0",
         "yargs": "16.2.0",
         "yargs-parser": "20.2.4",
         "yargs-unparser": "2.0.0"
@@ -3185,23 +2272,11 @@
       "dev": true
     },
     "nanoid": {
-      "version": "3.1.25",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.1.25.tgz",
-      "integrity": "sha512-rdwtIXaXCLFAQbnfqDRnI6jaRHp9fTcYBjtFKE8eezcZ7LuLjhUaQGNeMXf1HmRoCH32CLz6XwX0TtxEOS/A3Q==",
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.1.tgz",
+      "integrity": "sha512-n6Vs/3KGyxPQd6uO0eH4Bv0ojGSUvuLlIHtC3Y0kEO23YRge8H9x1GCzLn28YX0H66pMkxuaeESFq4tKISKwdw==",
       "dev": true
     },
-    "normalize-package-data": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-3.0.3.tgz",
-      "integrity": "sha512-p2W1sgqij3zMMyRC067Dg16bfzVH+w7hyegmpIvZ4JNjqtGOVAIvLmjBx3yP7YTe9vKJgkoNOPjwQGogDoMXFA==",
-      "dev": true,
-      "requires": {
-        "hosted-git-info": "^4.0.1",
-        "is-core-module": "^2.5.0",
-        "semver": "^7.3.4",
-        "validate-npm-package-license": "^3.0.1"
-      }
-    },
     "normalize-path": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
@@ -3211,7 +2286,7 @@
     "once": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
       "dev": true,
       "requires": {
         "wrappy": "1"
@@ -3235,24 +2310,6 @@
         "p-limit": "^3.0.2"
       }
     },
-    "p-try": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz",
-      "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
-      "dev": true
-    },
-    "parse-json": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
-      "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
-      "dev": true,
-      "requires": {
-        "@babel/code-frame": "^7.0.0",
-        "error-ex": "^1.3.1",
-        "json-parse-even-better-errors": "^2.3.0",
-        "lines-and-columns": "^1.1.6"
-      }
-    },
     "path-exists": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
@@ -3262,19 +2319,7 @@
     "path-is-absolute": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
-      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
-      "dev": true
-    },
-    "path-parse": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
-      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
-      "dev": true
-    },
-    "path-type": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
-      "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==",
+      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
       "dev": true
     },
     "pathval": {
@@ -3284,19 +2329,16 @@
       "dev": true
     },
     "picomatch": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.0.tgz",
-      "integrity": "sha512-lY1Q/PiJGC2zOv/z391WOTD+Z02bCgsFfvxoXXf6h7kv9o+WmsmzYqrAwY63sNgOxE4xEdq0WyUnXfKeBrSvYw==",
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
       "dev": true
     },
-    "plur": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/plur/-/plur-4.0.0.tgz",
-      "integrity": "sha512-4UGewrYgqDFw9vV6zNV+ADmPAUAfJPKtGvb/VdpQAx25X5f3xXdGdyOEVFwkl8Hl/tl7+xbeHqSEM+D5/TirUg==",
-      "dev": true,
-      "requires": {
-        "irregular-plurals": "^3.2.0"
-      }
+    "prettier": {
+      "version": "2.7.1",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.7.1.tgz",
+      "integrity": "sha512-ujppO+MkdPqoVINuDFDRLClm7D78qbDt0/NR+wp5FqEZOoTNAjPHWj17QRhu7geIHJfcNhRk1XVQmF8Bp3ye+g==",
+      "dev": true
     },
     "punycode": {
       "version": "2.1.1",
@@ -3304,18 +2346,6 @@
       "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==",
       "dev": true
     },
-    "queue-microtask": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
-      "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
-      "dev": true
-    },
-    "quick-lru": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-4.0.1.tgz",
-      "integrity": "sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==",
-      "dev": true
-    },
     "randombytes": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz",
@@ -3325,106 +2355,6 @@
         "safe-buffer": "^5.1.0"
       }
     },
-    "read-pkg": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-5.2.0.tgz",
-      "integrity": "sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==",
-      "dev": true,
-      "requires": {
-        "@types/normalize-package-data": "^2.4.0",
-        "normalize-package-data": "^2.5.0",
-        "parse-json": "^5.0.0",
-        "type-fest": "^0.6.0"
-      },
-      "dependencies": {
-        "hosted-git-info": {
-          "version": "2.8.9",
-          "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.9.tgz",
-          "integrity": "sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==",
-          "dev": true
-        },
-        "normalize-package-data": {
-          "version": "2.5.0",
-          "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz",
-          "integrity": "sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==",
-          "dev": true,
-          "requires": {
-            "hosted-git-info": "^2.1.4",
-            "resolve": "^1.10.0",
-            "semver": "2 || 3 || 4 || 5",
-            "validate-npm-package-license": "^3.0.1"
-          }
-        },
-        "semver": {
-          "version": "5.7.1",
-          "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
-          "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
-          "dev": true
-        },
-        "type-fest": {
-          "version": "0.6.0",
-          "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.6.0.tgz",
-          "integrity": "sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==",
-          "dev": true
-        }
-      }
-    },
-    "read-pkg-up": {
-      "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-7.0.1.tgz",
-      "integrity": "sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==",
-      "dev": true,
-      "requires": {
-        "find-up": "^4.1.0",
-        "read-pkg": "^5.2.0",
-        "type-fest": "^0.8.1"
-      },
-      "dependencies": {
-        "find-up": {
-          "version": "4.1.0",
-          "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz",
-          "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==",
-          "dev": true,
-          "requires": {
-            "locate-path": "^5.0.0",
-            "path-exists": "^4.0.0"
-          }
-        },
-        "locate-path": {
-          "version": "5.0.0",
-          "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz",
-          "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==",
-          "dev": true,
-          "requires": {
-            "p-locate": "^4.1.0"
-          }
-        },
-        "p-limit": {
-          "version": "2.3.0",
-          "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
-          "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
-          "dev": true,
-          "requires": {
-            "p-try": "^2.0.0"
-          }
-        },
-        "p-locate": {
-          "version": "4.1.0",
-          "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz",
-          "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==",
-          "dev": true,
-          "requires": {
-            "p-limit": "^2.2.0"
-          }
-        },
-        "type-fest": {
-          "version": "0.8.1",
-          "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz",
-          "integrity": "sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==",
-          "dev": true
-        }
-      }
-    },
     "readdirp": {
       "version": "3.6.0",
       "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
@@ -3434,20 +2364,10 @@
         "picomatch": "^2.2.1"
       }
     },
-    "redent": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz",
-      "integrity": "sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==",
-      "dev": true,
-      "requires": {
-        "indent-string": "^4.0.0",
-        "strip-indent": "^3.0.0"
-      }
-    },
     "require-directory": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
-      "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
       "dev": true
     },
     "require-from-string": {
@@ -3456,46 +2376,12 @@
       "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
       "dev": true
     },
-    "resolve": {
-      "version": "1.20.0",
-      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.20.0.tgz",
-      "integrity": "sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A==",
-      "dev": true,
-      "requires": {
-        "is-core-module": "^2.2.0",
-        "path-parse": "^1.0.6"
-      }
-    },
-    "reusify": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz",
-      "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==",
-      "dev": true
-    },
-    "run-parallel": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
-      "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
-      "dev": true,
-      "requires": {
-        "queue-microtask": "^1.2.2"
-      }
-    },
     "safe-buffer": {
       "version": "5.2.1",
       "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
       "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
       "dev": true
     },
-    "semver": {
-      "version": "7.3.5",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.5.tgz",
-      "integrity": "sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==",
-      "dev": true,
-      "requires": {
-        "lru-cache": "^6.0.0"
-      }
-    },
     "serialize-javascript": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz",
@@ -3505,44 +2391,6 @@
         "randombytes": "^2.1.0"
       }
     },
-    "slash": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
-      "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
-      "dev": true
-    },
-    "spdx-correct": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.1.tgz",
-      "integrity": "sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w==",
-      "dev": true,
-      "requires": {
-        "spdx-expression-parse": "^3.0.0",
-        "spdx-license-ids": "^3.0.0"
-      }
-    },
-    "spdx-exceptions": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz",
-      "integrity": "sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A==",
-      "dev": true
-    },
-    "spdx-expression-parse": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz",
-      "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==",
-      "dev": true,
-      "requires": {
-        "spdx-exceptions": "^2.1.0",
-        "spdx-license-ids": "^3.0.0"
-      }
-    },
-    "spdx-license-ids": {
-      "version": "3.0.11",
-      "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.11.tgz",
-      "integrity": "sha512-Ctl2BrFiM0X3MANYgj3CkygxhRmr9mi6xhejbdO960nF6EDJApTYpn0BQnDKlnNBULKiCN1n3w9EBkHK8ZWg+g==",
-      "dev": true
-    },
     "string-width": {
       "version": "4.2.3",
       "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
@@ -3563,15 +2411,6 @@
         "ansi-regex": "^5.0.1"
       }
     },
-    "strip-indent": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz",
-      "integrity": "sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==",
-      "dev": true,
-      "requires": {
-        "min-indent": "^1.0.0"
-      }
-    },
     "strip-json-comments": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
@@ -3587,27 +2426,6 @@
         "has-flag": "^4.0.0"
       }
     },
-    "supports-hyperlinks": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/supports-hyperlinks/-/supports-hyperlinks-2.2.0.tgz",
-      "integrity": "sha512-6sXEzV5+I5j8Bmq9/vUphGRM/RJNT9SCURJLjwfOg51heRtguGWDzcaBlgAzKhQa0EVNpPEKzQuBwZ8S8WaCeQ==",
-      "dev": true,
-      "requires": {
-        "has-flag": "^4.0.0",
-        "supports-color": "^7.0.0"
-      },
-      "dependencies": {
-        "supports-color": {
-          "version": "7.2.0",
-          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-          "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-          "dev": true,
-          "requires": {
-            "has-flag": "^4.0.0"
-          }
-        }
-      }
-    },
     "to-regex-range": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
@@ -3617,42 +2435,16 @@
         "is-number": "^7.0.0"
       }
     },
-    "trim-newlines": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/trim-newlines/-/trim-newlines-3.0.1.tgz",
-      "integrity": "sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw==",
-      "dev": true
-    },
-    "tsd": {
-      "version": "0.19.0",
-      "resolved": "https://registry.npmjs.org/tsd/-/tsd-0.19.0.tgz",
-      "integrity": "sha512-DlYCjjRVspfSAC+9X1NUDqPj0PtsVjUSyC4/OJpCGnY2Mtg0ddc+opckmnLV3RhUBpVuAAOrz661v+QSJwINkQ==",
-      "dev": true,
-      "requires": {
-        "@tsd/typescript": "~4.5.2",
-        "eslint-formatter-pretty": "^4.1.0",
-        "globby": "^11.0.1",
-        "meow": "^9.0.0",
-        "path-exists": "^4.0.0",
-        "read-pkg-up": "^7.0.0"
-      }
-    },
     "type-detect": {
       "version": "4.0.8",
       "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz",
       "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==",
       "dev": true
     },
-    "type-fest": {
-      "version": "0.21.3",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz",
-      "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==",
-      "dev": true
-    },
     "typescript": {
-      "version": "4.5.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.5.2.tgz",
-      "integrity": "sha512-5BlMof9H1yGt0P8/WF+wPNw6GfctgGjXp5hkblpyT+8rkASSmkUKMXrxR0Xg8ThVCi/JnHQiKXeBaEwCeQwMFw==",
+      "version": "4.8.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.8.2.tgz",
+      "integrity": "sha512-C0I1UsrrDHo2fYI5oaCGbSejwX4ch+9Y5jTQELvovfmFkK3HHSZJB8MSJcWLmCUBzQBchCrZ9rMRV6GuNrvGtw==",
       "dev": true
     },
     "uri-js": {
@@ -3664,16 +2456,6 @@
         "punycode": "^2.1.0"
       }
     },
-    "validate-npm-package-license": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz",
-      "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==",
-      "dev": true,
-      "requires": {
-        "spdx-correct": "^3.0.0",
-        "spdx-expression-parse": "^3.0.0"
-      }
-    },
     "which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -3684,9 +2466,9 @@
       }
     },
     "workerpool": {
-      "version": "6.1.5",
-      "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.1.5.tgz",
-      "integrity": "sha512-XdKkCK0Zqc6w3iTxLckiuJ81tiD/o5rBE/m+nXpRCB+/Sq4DqkfXZ/x0jW02DG1tGsfUGXbTJyZDP+eu67haSw==",
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.2.0.tgz",
+      "integrity": "sha512-Rsk5qQHJ9eowMH28Jwhe8HEbmdYDX4lwoMWshiCXugjtHqMD9ZbiqSDLxcsfdqsETPzVUtX5s1Z5kStiIM6l4A==",
       "dev": true
     },
     "wrap-ansi": {
@@ -3703,7 +2485,7 @@
     "wrappy": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
       "dev": true
     },
     "y18n": {
@@ -3712,12 +2494,6 @@
       "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
       "dev": true
     },
-    "yallist": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
-      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
-      "dev": true
-    },
     "yargs": {
       "version": "16.2.0",
       "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz",
diff --git a/package.json b/package.json
index cef6d5b2f..44cc0bab1 100644
--- a/package.json
+++ b/package.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.23.2",
+  "version": "0.24.44",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
-    "json-schema",
     "typescript",
-    "static-types",
-    "runtime-typechecking"
+    "json-schema",
+    "validate",
+    "typecheck"
   ],
   "author": "sinclairzx81",
   "license": "MIT",
@@ -18,23 +18,23 @@
   },
   "scripts": {
     "clean": "hammer task clean",
+    "format": "hammer task format",
+    "start": "hammer task start",
+    "test": "hammer task test",
+    "benchmark": "hammer task benchmark",
     "build": "hammer task build",
-    "example": "hammer task example",
-    "spec": "hammer task spec",
-    "spec:types": "hammer task spec_types",
-    "spec:schemas": "hammer task spec_schemas",
-    "test": "npm run spec"
+    "publish": "hammer task publish"
   },
   "devDependencies": {
-    "@sinclair/hammer": "^0.15.8",
-    "@types/chai": "^4.2.22",
-    "@types/mocha": "^9.0.0",
-    "@types/node": "^16.11.9",
-    "ajv": "^8.8.2",
+    "@sinclair/hammer": "^0.17.1",
+    "@types/chai": "^4.3.3",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^18.7.13",
+    "ajv": "^8.11.0",
     "ajv-formats": "^2.1.1",
-    "chai": "^4.3.4",
-    "mocha": "^9.1.3",
-    "tsd": "^0.19.0",
-    "typescript": "^4.5.2"
+    "chai": "^4.3.6",
+    "mocha": "^9.2.2",
+    "prettier": "^2.7.1",
+    "typescript": "^4.8.2"
   }
 }
diff --git a/readme.md b/readme.md
index 083da1b54..6d77e6a33 100644
--- a/readme.md
+++ b/readme.md
@@ -2,13 +2,16 @@
 
 <h1>TypeBox</h1>
 
-<img src="https://github.com/sinclairzx81/typebox/blob/master/typebox.png?raw=true" />
-
 <p>JSON Schema Type Builder with Static Type Resolution for TypeScript</p>
+	
+<img src="https://github.com/sinclairzx81/typebox/blob/master/typebox.png?raw=true" />
 
+<br />
+<br />
 
-
-[![npm version](https://badge.fury.io/js/%40sinclair%2Ftypebox.svg)](https://badge.fury.io/js/%40sinclair%2Ftypebox) [![GitHub CI](https://github.com/sinclairzx81/typebox/workflows/GitHub%20CI/badge.svg)](https://github.com/sinclairzx81/typebox/actions)
+[![npm version](https://badge.fury.io/js/%40sinclair%2Ftypebox.svg)](https://badge.fury.io/js/%40sinclair%2Ftypebox)
+[![Downloads](https://img.shields.io/npm/dm/%40sinclair%2Ftypebox.svg)](https://www.npmjs.com/package/%40sinclair%2Ftypebox)
+[![GitHub CI](https://github.com/sinclairzx81/typebox/workflows/GitHub%20CI/badge.svg)](https://github.com/sinclairzx81/typebox/actions)
 
 </div>
 
@@ -16,16 +19,16 @@
 
 ## Install
 
-#### Node
+Node
 
 ```bash
 $ npm install @sinclair/typebox --save
 ```
 
-#### Deno
+Deno and ESM
 
 ```typescript
-import { Static, Type } from 'https://deno.land/x/typebox/src/typebox.ts'
+import { Static, Type } from 'https://esm.sh/@sinclair/typebox'
 ```
 
 ## Example
@@ -33,7 +36,7 @@ import { Static, Type } from 'https://deno.land/x/typebox/src/typebox.ts'
 ```typescript
 import { Static, Type } from '@sinclair/typebox'
 
-const T = Type.String()     // const T = { "type": "string" }
+const T = Type.String()     // const T = { type: 'string' }
 
 type T = Static<typeof T>   // type T = string
 ```
@@ -42,28 +45,47 @@ type T = Static<typeof T>   // type T = string
 
 ## Overview
 
-TypeBox is a library that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox allows one to create a unified type that can be both statically asserted by the TypeScript compiler and runtime asserted using standard JSON Schema validation.
-
-TypeBox can be used as a simple tool to build up complex schemas or integrated into RPC or REST services to help validate JSON data received over the wire. TypeBox does not provide any JSON schema validation. Please use libraries such as AJV to validate schemas built with this library.
+TypeBox is a type builder library that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
 
-Requires TypeScript 4.3.5 and above.
+TypeBox is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used either as a simple tool to build up complex schemas or integrated into REST and RPC services to help validate data received over the wire. 
 
 License MIT
 
 ## Contents
-- [Install](#Install)
-- [Overview](#Overview)
-- [Usage](#Usage)
-- [Types](#Types)
-- [Modifiers](#Modifiers)
-- [Options](#Options)
-- [Generic Types](#Generic-Types)
-- [Reference Types](#Reference-Types)
-- [Recursive Types](#Recursive-Types)
-- [Extended Types](#Extended-Types)
-- [Strict](#Strict)
-- [Validation](#Validation)
-- [OpenAPI](#OpenAPI)
+- [Install](#install)
+- [Overview](#overview)
+- [Usage](#usage)
+- [Types](#types)
+  - [Standard](#types-standard)
+  - [Modifiers](#types-modifiers)
+  - [Options](#types-options)
+  - [Extended](#types-extended)
+  - [Reference](#types-reference)
+  - [Recursive](#types-recursive)
+  - [Generic](#types-generic)
+  - [Conditional](#types-conditional)
+  - [Unsafe](#types-unsafe)
+  - [Guards](#types-guards)
+  - [Strict](#types-strict)
+- [Values](#values)
+  - [Create](#values-create)
+  - [Clone](#values-clone)
+  - [Check](#values-check)
+  - [Cast](#values-cast)
+  - [Equal](#values-equal)
+  - [Diff](#values-diff)
+  - [Patch](#values-patch)
+  - [Errors](#values-errors)
+  - [Pointer](#values-pointer)
+- [TypeCheck](#typecheck)
+  - [Ajv](#typecheck-ajv)
+  - [Compiler](#typecheck-compiler)
+  - [Formats](#typecheck-formats)
+- [Benchmark](#benchmark)
+  - [Compile](#benchmark-compile)
+  - [Validate](#benchmark-validate)
+  - [Compression](#benchmark-compression)
+- [Contribute](#contribute)
 
 <a name="Example"></a>
 
@@ -82,9 +104,9 @@ import { Static, Type } from '@sinclair/typebox'
 //--------------------------------------------------------------------------------------------
 
 type T = {
-    id: string,
-    name: string,
-    timestamp: number
+  id: string,
+  name: string,
+  timestamp: number
 }
 
 //--------------------------------------------------------------------------------------------
@@ -93,25 +115,25 @@ type T = {
 //
 //--------------------------------------------------------------------------------------------
 
-const T = Type.Object({               // const T = {
-    id: Type.String(),                //   type: 'object',
-    name: Type.String(),              //   properties: { 
-    timestamp: Type.Integer()         //      id: { 
-})                                    //         type: 'string' 
-                                      //      },
-                                      //      name: { 
-                                      //         type: 'string' 
-                                      //      },
-                                      //      timestamp: { 
-                                      //         type: 'integer' 
-                                      //      }
-                                      //   }, 
-                                      //   required: [
-                                      //      "id",
-                                      //      "name",
-                                      //      "timestamp"
-                                      //   ]
-                                      // } 
+const T = Type.Object({                              // const T = {
+  id: Type.String(),                                 //   type: 'object',
+  name: Type.String(),                               //   properties: { 
+  timestamp: Type.Integer()                          //     id: { 
+})                                                   //       type: 'string' 
+                                                     //     },
+                                                     //     name: { 
+                                                     //       type: 'string' 
+                                                     //     },
+                                                     //     timestamp: { 
+                                                     //       type: 'integer' 
+                                                     //     }
+                                                     //   }, 
+                                                     //   required: [
+                                                     //     'id',
+                                                     //     'name',
+                                                     //     'timestamp'
+                                                     //   ]
+                                                     // } 
 
 //--------------------------------------------------------------------------------------------
 //
@@ -119,11 +141,11 @@ const T = Type.Object({               // const T = {
 //
 //--------------------------------------------------------------------------------------------
 
-type T = Static<typeof T>             // type T = {
-                                      //    id: string,
-                                      //    name: string,
-                                      //    timestamp: number
-                                      // }
+type T = Static<typeof T>                            // type T = {
+                                                     //   id: string,
+                                                     //   name: string,
+                                                     //   timestamp: number
+                                                     // }
 
 //--------------------------------------------------------------------------------------------
 //
@@ -131,20 +153,26 @@ type T = Static<typeof T>             // type T = {
 //
 //--------------------------------------------------------------------------------------------
 
-function receive(value: T) {         // ... as a Type
+function receive(value: T) {                         // ... as a Type
 
-    if(JSON.validate(T, value)) {    // ... as a Schema
-
-        // ok...
-    }
+  if(JSON.validate(T, value)) {                      // ... as a Schema
+  
+    // ok...
+  }
 }
 ```
 
-<a name="Types"></a>
+<a name='types'></a>
 
 ## Types
 
-The following table outlines the TypeBox mappings between TypeScript and JSON schema.
+TypeBox provides a set of functions that allow you to compose JSON Schema similar to how you would compose static types with TypeScript. Each function creates a JSON schema fragment which can compose into more complex types. The schemas produced by TypeBox can be passed directly to any JSON Schema compliant validator, or used to reflect runtime metadata for a type.
+
+<a name='types-standard'></a>
+
+### Standard
+
+The following table lists the standard TypeBox types.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
@@ -158,22 +186,22 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.String()        │ type T = string             │ const T = {                    │
-│                                │                             │    type: 'string'              │
+│                                │                             │   type: 'string'               │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Number()        │ type T = number             │ const T = {                    │
-│                                │                             │    type: 'number'              │
+│                                │                             │   type: 'number'               │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Integer()       │ type T = number             │ const T = {                    │
-│                                │                             │    type: 'integer'             │
+│                                │                             │   type: 'integer'              │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Boolean()       │ type T = boolean            │ const T = {                    │
-│                                │                             │    type: 'boolean'             │
+│                                │                             │   type: 'boolean'              │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -189,22 +217,22 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Literal(42)     │ type T = 42                 │ const T = {                    │
-│                                │                             │    const: 42                   │
+│                                │                             │    const: 42,                  │
 │                                │                             │    type: 'number'              │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Array(          │ type T = number[]           │ const T = {                    │
-│    Type.Number()               │                             │    type: 'array',              │
-│ )                              │                             │    items: {                    │
-│                                │                             │      type: 'number'            │
-│                                │                             │    }                           │
+│   Type.Number()                │                             │   type: 'array',               │
+│ )                              │                             │   items: {                     │
+│                                │                             │     type: 'number'             │
+│                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Object({        │ type T = {                  │ const T = {                    │
-│   x: Type.Number(),            │    x: number,               │   type: 'object',              │
-│   y: Type.Number()             │    y: number                │   properties: {                │
+│   x: Type.Number(),            │   x: number,                │   type: 'object',              │
+│   y: Type.Number()             │   y: number                 │   properties: {                │
 │ })                             │ }                           │      x: {                      │
 │                                │                             │        type: 'number'          │
 │                                │                             │      },                        │
@@ -217,19 +245,18 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Tuple([         │ type T = [number, number]   │ const T = {                    │
-│   Type.Number(),               │                             │    type: 'array',              │
-│   Type.Number()                │                             │    items: [                    │
-│ ])                             │                             │       {                        │
-│                                │                             │         type: 'number'         │
-│                                │                             │       }, {                     │
-│                                │                             │         type: 'number'         │
-│                                │                             │       }                        │
-│                                │                             │    ],                          │
+│   Type.Number(),               │                             │   type: 'array',               │
+│   Type.Number()                │                             │   items: [{                    │
+│ ])                             │                             │      type: 'number'            │
+│                                │                             │    }, {                        │
+│                                │                             │      type: 'number'            │
+│                                │                             │    }],                         │
 │                                │                             │    additionalItems: false,     │
 │                                │                             │    minItems: 2,                │
-│                                │                             │    maxItems: 2,                │
+│                                │                             │    maxItems: 2                 │
 │                                │                             │ }                              │
 │                                │                             │                                │
+│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ enum Foo {                     │ enum Foo {                  │ const T = {                    │
 │   A,                           │   A,                        │   anyOf: [{                    │
@@ -243,85 +270,92 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.KeyOf(          │ type T = keyof {            │ const T = {                    │
-│   Type.Object({                │   x: number,                │    enum: ['x', 'y'],           │
-│     x: Type.Number(),          │   y: number                 │    type: 'string'              │
-│     y: Type.Number()           │ }                           │ }                              │
-│   })                           │                             │                                │
-│ )                              │                             │                                │
+│   Type.Object({                │   x: number,                │   anyOf: [{                    │
+│     x: Type.Number(),          │   y: number                 │     type: 'string',            │
+│     y: Type.Number()           │ }                           │     const: 'x'                 │
+│   })                           │                             │   }, {                         │
+│ )                              │                             │     type: 'string',            │
+│                                │                             │     const: 'y'                 │
+│                                │                             │   }]                           │
+│                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Union([         │ type T = string | number    │ const T = {                    │
-│   Type.String(),               │                             │    anyOf: [{                   │
-│   Type.Number()                │                             │       type: 'string'           │
-│ ])                             │                             │    }, {                        │
-│                                │                             │       type: 'number'           │
-│                                │                             │    }]                          │
+│   Type.String(),               │                             │   anyOf: [{                    │
+│   Type.Number()                │                             │      type: 'string'            │
+│ ])                             │                             │   }, {                         │
+│                                │                             │      type: 'number'            │
+│                                │                             │   }]                           │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Intersect([     │ type T = {                  │ const T = {                    │
-│    Type.Object({               │    x: number                │    allOf: [{                   │
-│       x: Type.Number()         │ } & {                       │       type: 'object',          │
-│    }),                         │    y: number                │       properties: {            │
-│    Type.Object({               │ }                           │          x: {                  │
-│       y: Type.Number()         │                             │            type: 'number'      │
-│   })                           │                             │          }                     │
-│ })                             │                             │       },                       │
-│                                │                             │       required: ['x']          │
-│                                │                             │    }, {                        │
-│                                │                             │       type: 'object',          │
-│                                │                             │       properties: {            │
-│                                │                             │          y: {                  │
-│                                │                             │            type: 'number'      │
-│                                │                             │          }                     │
-│                                │                             │       },                       │
-│                                │                             │       required: ['y']          │
-│                                │                             │    }]                          │
+│   Type.Object({                │   x: number                 │   type: 'object',              │
+│     x: Type.Number()           │ } & {                       │   properties: {                │
+│   }),                          │   y: number                 │     x: {                       │
+│   Type.Object({                │ }                           │       type: 'number'           │
+│     y: Type.Number()           │                             │     },                         │
+│   })                           │                             │     y: {                       │
+│ ])                             │                             │       type: 'number'           │
+│                                │                             │     }                          │
+│                                │                             │   },                           │
+│                                │                             │   required: ['x', 'y']         │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Record(         │ type T = {                  │ const T = {                    │
-│    Type.String(),              │    [key: string]: number    │    type: 'object',             │
-│    Type.Number()               │ }                           │    patternProperties: {        │
-│ )                              │                             │      '^.*$': {                 │
-│                                │                             │         type: 'number'         │
-│                                │                             │      }                         │
-│                                │                             │    }                           │
+│ const T = Type.Never()         │ type T = never              │ const T = {                    │
+│                                │                             │   allOf: [{                    │
+│                                │                             │     type: 'boolean',           │
+│                                │                             │     const: false               │
+│                                │                             │   }, {                         │
+│                                │                             │     type: 'boolean',           │
+│                                │                             │     const: true                │
+│                                │                             │   }]                           │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Record(         │ type T = Record<            │ const T = {                    │
+│   Type.String(),               │   string,                   │   type: 'object',              │
+│   Type.Number()                │   number,                   │   patternProperties: {         │
+│ )                              │ >                           │     '^.*$': {                  │
+│                                │                             │       type: 'number'           │
+│                                │                             │     }                          │
+│                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Partial(        │ type T = Partial<{          │ const T = {                    │
-│    Type.Object({               │    x: number,               │   type: 'object',              │
-│         x: Type.Number(),      │    y: number                │   properties: {                │
-│         y: Type.Number()       | }>                          │     x: {                       │
-│    })                          │                             │        type: 'number'          │
+│   Type.Object({                │   x: number,                │   type: 'object',              │
+│     x: Type.Number(),          │   y: number                 │   properties: {                │
+│     y: Type.Number()           | }>                          │     x: {                       │
+│   })                           │                             │       type: 'number'           │
 │ )                              │                             │     },                         │
 │                                │                             │     y: {                       │
-│                                │                             │        type: 'number'          │
+│                                │                             │       type: 'number'           │
 │                                │                             │     }                          │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Required(       │ type T = Required<{         │ const T = {                    │
-│    Type.Object({               │    x?: number,              │   type: 'object',              │
-│       x: Type.Optional(        │    y?: number               │   properties: {                │
-│          Type.Number()         | }>                          │     x: {                       │
-│       ),                       │                             │        type: 'number'          │
-│       y: Type.Optional(        │                             │     },                         │
-│          Type.Number()         │                             │     y: {                       │
-│       )                        │                             │        type: 'number'          │
-│    })                          │                             │     }                          │
+│   Type.Object({                │   x?: number,               │   type: 'object',              │
+│     x: Type.Optional(          │   y?: number                │   properties: {                │
+│       Type.Number()            | }>                          │     x: {                       │
+│     ),                         │                             │       type: 'number'           │
+│     y: Type.Optional(          │                             │     },                         │
+│       Type.Number()            │                             │     y: {                       │
+│     )                          │                             │       type: 'number'           │
+│   })                           │                             │     }                          │
 │ )                              │                             │   },                           │
 │                                │                             │   required: ['x', 'y']         │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Pick(           │ type T = Pick<{             │ const T = {                    │
-│    Type.Object({               │    x: number,               │   type: 'object',              │
-│       x: Type.Number(),        │    y: number                │   properties: {                │
-│       y: Type.Number(),        | }, 'x'>                     │     x: {                       │
-│     }), ['x']                  │                             │        type: 'number'          │
+│   Type.Object({                │   x: number,                │   type: 'object',              │
+│     x: Type.Number(),          │   y: number                 │   properties: {                │
+│     y: Type.Number()           | }, 'x'>                     │     x: {                       │
+│   }), ['x']                    │                             │       type: 'number'           │
 │ )                              │                             │     }                          │
 │                                │                             │   },                           │
 │                                │                             │   required: ['x']              │
@@ -329,10 +363,10 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Omit(           │ type T = Omit<{             │ const T = {                    │
-│    Type.Object({               │    x: number,               │   type: 'object',              │
-│       x: Type.Number(),        │    y: number                │   properties: {                │
-│       y: Type.Number(),        | }, 'x'>                     │     y: {                       │
-│     }), ['x']                  │                             │        type: 'number'          │
+│   Type.Object({                │   x: number,                │   type: 'object',              │
+│     x: Type.Number(),          │   y: number                 │   properties: {                │
+│     y: Type.Number()           | }, 'x'>                     │     y: {                       │
+│   }), ['x']                    │                             │       type: 'number'           │
 │ )                              │                             │     }                          │
 │                                │                             │   },                           │
 │                                │                             │   required: ['y']              │
@@ -340,7 +374,8 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
-<a name="Modifiers"></a>
+
+<a name='types-modifiers'></a>
 
 ### Modifiers
 
@@ -352,8 +387,8 @@ TypeBox provides modifiers that can be applied to an objects properties. This al
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Object({        │ type T = {                  │ const T = {                    │
-│   name: Type.Optional(         │    name?: string,           │   type: 'object',              │
-│      Type.String(),            │ }                           │   properties: {                │
+│   name: Type.Optional(         │   name?: string             │   type: 'object',              │
+│     Type.String()              │ }                           │   properties: {                │
 │   )                            │                             │      name: {                   │
 │ })  	                         │                             │        type: 'string'          │
 │                                │                             │      }                         │
@@ -362,29 +397,29 @@ TypeBox provides modifiers that can be applied to an objects properties. This al
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Object({        │ type T = {                  │ const T = {                    │
-│   name: Type.Readonly(         │    readonly name: string,   │   type: 'object',              │
-│      Type.String(),            │ }                           │   properties: {                │
-│   )                            │                             │      name: {                   │
-│ })  	                         │                             │        type: 'string'          │
-│                                │                             │      }                         │
+│   name: Type.Readonly(         │   readonly name: string     │   type: 'object',              │
+│     Type.String()              │ }                           │   properties: {                │
+│   )                            │                             │     name: {                    │
+│ })  	                         │                             │       type: 'string'           │
+│                                │                             │     }                          │
 │                                │                             │   },                           │
 │                                │                             │   required: ['name']           │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Object({        │ type T = {                  │ const T = {                    │
-│   name: Type.ReadonlyOptional( │    readonly name?: string,  │   type: 'object',              │
-│      Type.String(),            │ }                           │   properties: {                │
-│   )                            │                             │      name: {                   │
-│ })  	                         │                             │        type: 'string'          │
-│                                │                             │      }                         │
+│   name: Type.ReadonlyOptional( │   readonly name?: string    │   type: 'object',              │
+│     Type.String()              │ }                           │   properties: {                │
+│   )                            │                             │     name: {                    │
+│ })  	                         │                             │       type: 'string'           │
+│                                │                             │     }                          │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name="Options"></a>
+<a name='types-options'></a>
 
 ### Options
 
@@ -400,148 +435,12 @@ const T = Type.Number({ multipleOf: 2 })
 // array must have at least 5 integer values
 const T = Type.Array(Type.Integer(), { minItems: 5 })
 ```
-<a name="Generic-Types"></a>
-
-### Generic Types
-
-Generic types can be created using functions. The following creates a generic `Nullable<T>` type. 
-
-```typescript
-import { Type, Static, TSchema } from '@sinclair/typebox'
-
-// type Nullable<T> = T | null
-
-const Nullable = <T extends TSchema>(type: T) => Type.Union([type, Type.Null()])
-
-const T = Nullable(Type.String())              // const T = {
-                                               //   "anyOf": [{
-                                               //      type: 'string'
-                                               //   }, {
-                                               //      type: 'null'
-                                               //   }]
-                                               // }
-
-type T = Static<typeof T>                      // type T = string | null
-
-const U = Nullable(Type.Number())              // const U = {
-                                               //   "anyOf": [{
-                                               //      type: 'number'
-                                               //   }, {
-                                               //      type: 'null'
-                                               //   }]
-                                               // }
-
-type U = Static<typeof U>                      // type U = number | null
-```
-
-<a name="Reference-Types"></a>
-
-### Reference Types
-
-Types can be referenced with `Type.Ref(...)`. To reference a type, the target type must specify an `$id`.
-
-```typescript
-const T = Type.String({ $id: 'T' })            // const T = {
-                                               //    $id: 'T',
-                                               //    type: 'string'
-                                               // }
-                                             
-const R = Type.Ref(T)                          // const R = {
-                                               //    $ref: 'T'
-                                               // }
-```
-
-It can sometimes be helpful to organize shared referenced types under a common namespace. The `Type.Namespace(...)` function can be used to create a shared definition container for related types. The following creates a `Math3D` container and a `Vertex` structure that references types in the container.
-
-```typescript
-const Math3D = Type.Namespace({                 //  const Math3D = {
-  Vector4: Type.Object({                        //    $id: 'Math3D',
-    x: Type.Number(),                           //    $defs: {
-    y: Type.Number(),                           //      Vector4: {
-    z: Type.Number(),                           //        type: 'object',
-    w: Type.Number()                            //        properties: {
-  }),                                           //          x: { type: 'number' },
-  Vector3: Type.Object({                        //          y: { type: 'number' },
-    x: Type.Number(),                           //          z: { type: 'number' },
-    y: Type.Number(),                           //          w: { type: 'number' }
-    z: Type.Number()                            //        },
-  }),                                           //        required: ['x', 'y', 'z', 'w']
-  Vector2: Type.Object({                        //      },
-    x: Type.Number(),                           //      Vector3: {
-    y: Type.Number()                            //        type: 'object',
-  })                                            //        properties: {
-}, { $id: 'Math3D' })                           //          x: { 'type': 'number' },
-                                                //          y: { 'type': 'number' },
-                                                //          z: { 'type': 'number' }
-                                                //        },
-                                                //        required: ['x', 'y', 'z']
-                                                //      },
-                                                //      Vector2: {
-                                                //        type: 'object',
-                                                //        properties: {
-                                                //          x: { 'type': 'number' },
-                                                //          y: { 'type': 'number' },
-                                                //        },
-                                                //        required: ['x', 'y']
-                                                //      }
-                                                //    }
-                                                //  }
-													 
-const Vertex = Type.Object({                    //  const Vertex = {
-    position: Type.Ref(Math3D, 'Vector4'),      //    type: 'object',
-    normal:   Type.Ref(Math3D, 'Vector3'),      //    properties: {
-    uv:       Type.Ref(Math3D, 'Vector2')       //      position: { $ref: 'Math3D#/$defs/Vector4' },
-})                                              //      normal: { $ref: 'Math3D#/$defs/Vector3' },
-                                                //      uv: { $ref: 'Math3D#/$defs/Vector2' }
-                                                //    },
-                                                //    required: ['position', 'normal', 'uv']
-                                                //  }
-```
-
-<a name="Recursive-Types"></a>
-
-### Recursive Types
-
-Recursive types can be created with the `Type.Rec(...)` function. The following creates a `Node` type that contains an array of inner Nodes. Note that due to current restrictions on TypeScript inference, it is not possible for TypeBox to statically infer for recursive types. TypeBox will infer the inner recursive type as `any`.
-
-```typescript
-const Node = Type.Rec(Self => Type.Object({    // const Node = {
-  id:    Type.String(),                        //   $id: 'Node',
-  nodes: Type.Array(Self),                     //   $ref: 'Node#/$defs/self',
-}), { $id: 'Node' })                           //   $defs: {
-                                               //     self: {
-                                               //       type: 'object',
-                                               //       properties: {
-                                               //         id: {
-                                               //           type: 'string'
-                                               //         },
-                                               //         nodes: {
-                                               //            type: 'array',
-                                               //            items: {
-                                               //              $ref: 'Node#/$defs/self'
-                                               //            }
-                                               //         }
-                                               //      }
-                                               //    }
-                                               // }
-
-type Node = Static<typeof Node>                // type Node = {
-                                               //   id: string
-                                               //   nodes: any[]
-                                               // }
-
-function visit(node: Node) {
-    for(const inner of node.nodes) {
-        visit(inner as Node)                   // Assert inner as Node
-    }
-}
-```
 
-<a name="Extended-Types"></a>
+<a name='types-extended'></a>
 
-### Extended Types
+### Extended
 
-In addition to JSON schema types, TypeBox provides several extended types that allow for `function` and `constructor` types to be composed. These additional types are not valid JSON Schema and will not validate using typical JSON Schema validation. However, these types can be used to frame JSON schema and describe callable interfaces that may receive JSON validated data. These types are as follows.
+In addition to JSON schema types, TypeBox provides several extended types that allow for the composition of `function` and `constructor` types. These additional types are not valid JSON Schema and will not validate using typical JSON Schema validation. However, these types can be used to frame JSON schema and describe callable interfaces that may receive JSON validated data. These types are as follows.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
@@ -549,124 +448,487 @@ In addition to JSON schema types, TypeBox provides several extended types that a
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Constructor([   │ type T = new (              │ const T = {                    │
-│    Type.String(),              │  arg0: string,              │   type: 'constructor'          │
-│    Type.Number(),              │  arg1: number               │   arguments: [{                │
-│ ], Type.Boolean())             │ ) => boolean                │      type: 'string'            │
+│   Type.String(),               │  arg0: string,              │   type: 'constructor'          │
+│   Type.Number()                │  arg1: number               │   parameters: [{               │
+│ ], Type.Boolean())             │ ) => boolean                │     type: 'string'             │
 │                                │                             │   }, {                         │
-│                                │                             │      type: 'number'            │
+│                                │                             │     type: 'number'             │
 │                                │                             │   }],                          │
-│                                │                             │   returns: {                   │
-│                                │                             │      type: 'boolean'           │
+│                                │                             │   return: {                    │
+│                                │                             │     type: 'boolean'            │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Function([      │ type T = (                  │ const T = {                    │
-|    Type.String(),              │  arg0: string,              │   type : 'function',           │
-│    Type.Number(),              │  arg1: number               │   arguments: [{                │
-│ ], Type.Boolean())             │ ) => boolean                │      type: 'string'            │
+|   Type.String(),               │  arg0: string,              │   type : 'function',           │
+│   Type.Number()                │  arg1: number               │   parameters: [{               │
+│ ], Type.Boolean())             │ ) => boolean                │     type: 'string'             │
 │                                │                             │   }, {                         │
-│                                │                             │      type: 'number'            │
+│                                │                             │     type: 'number'             │
 │                                │                             │   }],                          │
-│                                │                             │   returns: {                   │
-│                                │                             │      type: 'boolean'           │
+│                                │                             │   return: {                    │
+│                                │                             │     type: 'boolean'            │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Uint8Array()    │ type T = Uint8Array         │ const T = {                    │
+│                                │                             │   type: 'object',              │
+│                                │                             │   specialized: 'Uint8Array'    │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Promise(        │ type T = Promise<string>    │ const T = {                    │
-│    Type.String()               │                             │   type: 'promise',             │
+│   Type.String()                │                             │   type: 'promise',             │
 │ )                              │                             │   item: {                      │
-│                                │                             │      type: 'string'            │
+│                                │                             │     type: 'string'             │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Undefined()     │ type T = undefined          │ const T = {                    │
-│                                │                             │   type: 'undefined'            │
+│                                │                             │   type: 'object',              │
+│                                │                             │   specialized: 'Undefined'     │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Void()          │ type T = void               │ const T = {                    │
-│                                │                             │   type: 'void'                 │
+│                                │                             │   type: 'null'                 │
 │                                │                             │ }                              │
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name="Strict"></a>
+<a name='types-reference'></a>
 
-### Strict
+### Reference
+
+Use `Type.Ref(...)` to create referenced types. The target type must specify an `$id`.
 
-TypeBox schemas contain the properties `kind` and `modifier`. These properties are provided to enable runtime type reflection on schemas, as well as helping TypeBox apply the appropriate static type inference rules. These properties are not strictly valid JSON schema so in some cases it may be desirable to omit them. TypeBox provides a `Type.Strict()` function that will omit these properties if necessary.
+```typescript
+const T = Type.String({ $id: 'T' })                  // const T = {
+                                                     //    $id: 'T',
+                                                     //    type: 'string'
+                                                     // }
+                                             
+const R = Type.Ref(T)                                // const R = {
+                                                     //    $ref: 'T'
+                                                     // }
+```
+
+<a name='types-recursive'></a>
+
+### Recursive
+
+Use `Type.Recursive(...)` to create recursive types.
 
 ```typescript
-const T = Type.Object({                       // const T = {
-    name: Type.Optional(Type.String())        //   kind: Symbol(ObjectKind),
-})                                            //   type: 'object',
-                                              //   properties: {
-                                              //     name: {
-                                              //       kind: Symbol(StringKind),
-                                              //       type: 'string',
-                                              //       modifier: Symbol(OptionalModifier)
-                                              //     }
-                                              //   }
-                                              // }
+const Node = Type.Recursive(Node => Type.Object({    // const Node = {
+  id: Type.String(),                                 //   $id: 'Node',
+  nodes: Type.Array(Node)                            //   type: 'object',
+}), { $id: 'Node' })                                 //   properties: {
+                                                     //     id: {
+                                                     //       type: 'string'
+                                                     //     },
+                                                     //     nodes: {
+                                                     //       type: 'array',
+                                                     //       items: {
+                                                     //         $ref: 'Node'
+                                                     //       }
+                                                     //     }
+                                                     //   },
+                                                     //   required: [
+                                                     //     'id',
+                                                     //     'nodes'
+                                                     //   ]
+                                                     // }
+
+type Node = Static<typeof Node>                      // type Node = {
+                                                     //   id: string
+                                                     //   nodes: Node[]
+                                                     // }
+
+function test(node: Node) {
+  const id = node.nodes[0].nodes[0]                  // id is string
+                 .nodes[0].nodes[0]
+                 .id
+}
+```
+
+<a name='types-generic'></a>
+
+### Generic
 
-const U = Type.Strict(T)                      // const U = {
-                                              //     type: 'object', 
-                                              //     properties: { 
-                                              //         name: { 
-                                              //             type: 'string' 
-                                              //         } 
-                                              //     } 
-                                              // }
+Use functions to create generic types. The following creates a generic `Nullable<T>` type. 
+
+```typescript
+import { Type, Static, TSchema } from '@sinclair/typebox'
+
+const Nullable = <T extends TSchema>(type: T) => Type.Union([type, Type.Null()])
+
+const T = Nullable(Type.String())                    // const T = {
+                                                     //   anyOf: [{
+                                                     //     type: 'string'
+                                                     //   }, {
+                                                     //     type: 'null'
+                                                     //   }]
+                                                     // }
+
+type T = Static<typeof T>                            // type T = string | null
+
+const U = Nullable(Type.Number())                    // const U = {
+                                                     //   anyOf: [{
+                                                     //     type: 'number'
+                                                     //   }, {
+                                                     //     type: 'null'
+                                                     //   }]
+                                                     // }
+
+type U = Static<typeof U>                            // type U = number | null
 ```
 
-<a name="Validation"></a>
+<a name='types-conditional'></a>
 
-### Validation
+### Conditional
 
-TypeBox does not provide JSON schema validation so users will need to select an appropriate JSON Schema validator for their needs. TypeBox schemas target JSON Schema draft `2019-09` so any validator capable of draft `2019-09` should be fine. A good library to use for validation in JavaScript environments is [AJV](https://www.npmjs.com/package/ajv). The following example shows setting up AJV 7 to work with TypeBox.
+Use the conditional module to create [Conditional Types](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html). This module implements TypeScript's structural equivalence checks to enable TypeBox types to be conditionally inferred at runtime. This module also provides the [Extract](https://www.typescriptlang.org/docs/handbook/utility-types.html#extracttype-union) and [Exclude](https://www.typescriptlang.org/docs/handbook/utility-types.html#excludeuniontype-excludedmembers) utility types which are expressed as conditional types in TypeScript. 
 
-```bash
-$ npm install ajv ajv-formats --save
+The conditional module is provided as an optional import.
+
+```typescript
+import { Conditional } from '@sinclair/typebox/conditional'
 ```
+The following table shows the TypeBox mappings between TypeScript and JSON schema.
 
 ```typescript
+┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
+│ TypeBox                        │ TypeScript                  │ JSON Schema                    │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Conditional.Extends( │ type T =                    │ const T = {                    │
+│   Type.String(),               │  string extends number      │   const: false,                │
+│   Type.Number(),               │  true : false               │   type: 'boolean'              │
+│   Type.Literal(true),          │                             │ }                              │
+│   Type.Literal(false)          │                             │                                │
+│ )                              │                             │                                │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Conditional.Extract( │ type T = Extract<           │ const T = {                    │
+│   Type.Union([                 │   'a' | 'b' | 'c',          │   anyOf: [{                    │
+│     Type.Literal('a'),         │   'a' | 'f'                 │     const: 'a'                 │
+│     Type.Literal('b'),         │ >                           │     type: 'string'             │
+│     Type.Literal('c')          │                             │   }]                           │
+│   ]),                          │                             │ }                              │
+│   Type.Union([                 │                             │                                │
+│     Type.Literal('a'),         │                             │                                │
+│     Type.Literal('f')          │                             │                                │
+│   ])                           │                             │                                │
+│ )                              │                             │                                │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Conditional.Exclude( │ type T = Exclude<           │ const T = {                    │
+│   Type.Union([                 │   'a' | 'b' | 'c',          │   anyOf: [{                    │
+│     Type.Literal('a'),         │   'a'                       │     const: 'b',                │
+│     Type.Literal('b'),         │ >                           │     type: 'string'             │
+│     Type.Literal('c')          │                             │   }, {                         │
+│   ]),                          │                             │     const: 'c',                │
+│   Type.Union([                 │                             │     type: 'string'             │
+│     Type.Literal('a')          │                             │   }]                           │
+│   ])                           │                             │ }                              │
+│ )                              │                             │                                │
+│                                │                             │                                │
+└────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
+```
+
+<a name='types-unsafe'></a>
+
+### Unsafe
+
+Use `Type.Unsafe(...)` to create custom schemas with user defined inference rules.
+
+```typescript
+const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
+                                                     //   type: 'number'
+                                                     // }
+
+type T = Static<typeof T>                            // type T = string
+```
+
+This function can be used to create custom schemas for validators that require specific schema representations. An example of this might be OpenAPI's `nullable` and `enum` schemas which are not provided by TypeBox. The following demonstrates using `Type.Unsafe(...)` to create these types.
+
+```typescript
+import { Type, Static, TSchema } from '@sinclair/typebox'
+
+//--------------------------------------------------------------------------------------------
+//
+// Nullable<T>
+//
+//--------------------------------------------------------------------------------------------
+
+function Nullable<T extends TSchema>(schema: T) {
+  return Type.Unsafe<Static<T> | null>({ ...schema, nullable: true })
+}
+
+const T = Nullable(Type.String())                    // const T = {
+                                                     //   type: 'string',
+                                                     //   nullable: true
+                                                     // }
+
+type T = Static<typeof T>                            // type T = string | null
+
+
 //--------------------------------------------------------------------------------------------
 //
-// Import the 2019 compliant validator from AJV
+// StringEnum<string[]>
 //
 //--------------------------------------------------------------------------------------------
 
+function StringEnum<T extends string[]>(values: [...T]) {
+  return Type.Unsafe<T[number]>({ type: 'string', enum: values })
+}
+
+const T = StringEnum(['A', 'B', 'C'])                // const T = {
+                                                     //   enum: ['A', 'B', 'C']
+                                                     // }
+
+type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
+```
+
+<a name='types-guards'></a>
+
+### Guards
+
+Use the guard module to test if values are TypeBox types.
+
+```typescript
+import { TypeGuard } from '@sinclair/typebox/guard'
+
+const T = Type.String()
+
+if(TypeGuard.TString(T)) {
+    
+  // T is TString
+}
+```
+
+<a name='types-strict'></a>
+
+### Strict
+
+TypeBox schemas contain the `Kind` and `Modifier` symbol properties. These properties are provided to enable runtime type reflection on schemas, as well as helping TypeBox internally compose types. These properties are not strictly valid JSON schema; so in some cases it may be desirable to omit them. TypeBox provides a `Type.Strict()` function that will omit these properties if necessary.
+
+```typescript
+const T = Type.Object({                              // const T = {
+  name: Type.Optional(Type.String())                 //   [Kind]: 'Object',
+})                                                   //   type: 'object',
+                                                     //   properties: {
+                                                     //     name: {
+                                                     //       [Kind]: 'String',
+                                                     //       type: 'string',
+                                                     //       [Modifier]: 'Optional'
+                                                     //     }
+                                                     //   }
+                                                     // }
+
+const U = Type.Strict(T)                             // const U = {
+                                                     //   type: 'object', 
+                                                     //   properties: { 
+                                                     //     name: { 
+                                                     //       type: 'string' 
+                                                     //     } 
+                                                     //   } 
+                                                     // }
+```
+
+<a name='values'></a>
+
+## Values
+
+TypeBox includes an optional values module that can be used to perform common operations on JavaScript values. This module enables one to create, check and cast values from types. It also provides functionality to check equality, clone and diff and patch JavaScript values. The value module is provided as an optional import.
+
+```typescript
+import { Value } from '@sinclair/typebox/value'
+```
+
+<a name='values-create'></a>
+
+### Create
+
+Use the Create function to create a value from a TypeBox type. TypeBox will use default values if specified.
+
+```typescript
+const T = Type.Object({ x: Type.Number(), y: Type.Number({ default: 42 }) })
+
+const A = Value.Create(T)                            // const A = { x: 0, y: 42 }
+```
+
+<a name='values-clone'></a>
+
+### Clone
+
+Use the Clone function to deeply clone a value
+
+```typescript
+const A = Value.Clone({ x: 1, y: 2, z: 3 })          // const A = { x: 1, y: 2, z: 3 }
+```
+
+<a name='values-check'></a>
+
+### Check
+
+Use the Check function to type check a value
+
+```typescript
+const T = Type.Object({ x: Type.Number() })
+
+const R = Value.Check(T, { x: 1 })                   // const R = true
+```
+
+<a name='values-cast'></a>
+
+### Cast
+
+Use the Cast function to cast a value into a type. The cast function will retain as much information as possible from the original value.
+
+```typescript
+const T = Type.Object({ x: Type.Number(), y: Type.Number() }, { additionalProperties: false })
+
+const X = Value.Cast(T, null)                        // const X = { x: 0, y: 0 }
+
+const Y = Value.Cast(T, { x: 1 })                    // const Y = { x: 1, y: 0 }
+
+const Z = Value.Cast(T, { x: 1, y: 2, z: 3 })        // const Z = { x: 1, y: 2 }
+```
+
+<a name='values-equal'></a>
+
+### Equal
+
+Use the Equal function to deeply check for value equality.
+
+```typescript
+const R = Value.Equal(                               // const R = true
+  { x: 1, y: 2, z: 3 },
+  { x: 1, y: 2, z: 3 }
+)
+```
+
+<a name='values-diff'></a>
+
+### Diff
+
+Use the Diff function to produce a sequence of edits to transform one value into another.
+
+```typescript
+const E = Value.Diff<any>(                          // const E = [
+  { x: 1, y: 2, z: 3 },                             //   { type: 'update', path: '/y', value: 4 },
+  { y: 4, z: 5, w: 6 }                              //   { type: 'update', path: '/z', value: 5 },
+)                                                   //   { type: 'insert', path: '/w', value: 6 },
+                                                    //   { type: 'delete', path: '/x' }
+                                                    // ]
+```
+
+<a name='values-patch'></a>
+
+### Patch
+
+Use the Patch function to apply edits
+
+```typescript
+const A = { x: 1, y: 2 }
+
+const B = { x: 3 }
+
+const E = Value.Diff<any>(A, B)                      // const E = [
+                                                     //   { type: 'update', path: '/x', value: 3 },
+                                                     //   { type: 'delete', path: '/y' }
+                                                     // ]
+
+const C = Value.Patch<any>(A, E)                     // const C = { x: 3 }
+```
+
+
+<a name='values-errors'></a>
+
+### Errors
+
+Use the Errors function enumerate validation errors.
+
+```typescript
+const T = Type.Object({ x: Type.Number(), y: Type.Number() })
+
+const R = [...Value.Errors(T, { x: '42' })]          // const R = [{
+                                                     //   schema: { type: 'number' },
+                                                     //   path: '/x',
+                                                     //   value: '42',
+                                                     //   message: 'Expected number'
+                                                     // }, {
+                                                     //   schema: { type: 'number' },
+                                                     //   path: '/y',
+                                                     //   value: undefined,
+                                                     //   message: 'Expected number'
+                                                     // }]
+```
+
+<a name='values-pointer'></a>
+
+### Pointer
+
+Use ValuePointer to perform mutable updates on existing values using [RFC6901](https://www.rfc-editor.org/rfc/rfc6901) Json Pointers.
+
+```typescript
+import { ValuePointer } from '@sinclair/typebox/value'
+
+const A = { x: 0, y: 0, z: 0 }
+
+ValuePointer.Set(A, '/x', 1)                         // const A = { x: 1, y: 0, z: 0 }
+ValuePointer.Set(A, '/y', 1)                         // const A = { x: 1, y: 1, z: 0 }
+ValuePointer.Set(A, '/z', 1)                         // const A = { x: 1, y: 1, z: 1 }
+```
+<a name='typecheck'></a>
+
+## TypeCheck
+
+TypeBox is written to target JSON Schema Draft 6 and can be used with any Draft 6 compliant validator. TypeBox is developed and tested against Ajv and can be used in any application already making use of this validator. Additionally, TypeBox also provides an optional type compiler that can be used to attain improved compilation and validation performance for certain application types.
+
+<a name='typecheck-ajv'></a>
+
+### Ajv
+
+The following example shows setting up Ajv to work with TypeBox. 
+
+```bash
+$ npm install ajv ajv-formats --save
+```
+
+```typescript
 import { Type }   from '@sinclair/typebox'
 import addFormats from 'ajv-formats'
-import Ajv        from 'ajv/dist/2019'
+import Ajv        from 'ajv'
 
 //--------------------------------------------------------------------------------------------
 //
-// Setup AJV validator with the following options and formats
+// Setup Ajv validator with the following options and formats
 //
 //--------------------------------------------------------------------------------------------
 
 const ajv = addFormats(new Ajv({}), [
-    'date-time', 
-    'time', 
-    'date', 
-    'email',  
-    'hostname', 
-    'ipv4', 
-    'ipv6', 
-    'uri', 
-    'uri-reference', 
-    'uuid',
-    'uri-template', 
-    'json-pointer', 
-    'relative-json-pointer', 
-    'regex'
-]).addKeyword('kind')
-  .addKeyword('modifier')
+  'date-time', 
+  'time', 
+  'date', 
+  'email',  
+  'hostname', 
+  'ipv4', 
+  'ipv6', 
+  'uri', 
+  'uri-reference', 
+  'uuid',
+  'uri-template', 
+  'json-pointer', 
+  'relative-json-pointer', 
+  'regex'
+])
 
 //--------------------------------------------------------------------------------------------
 //
@@ -674,11 +936,11 @@ const ajv = addFormats(new Ajv({}), [
 //
 //--------------------------------------------------------------------------------------------
 
-const User = Type.Object({
-    userId: Type.String({ format: 'uuid' }),
-    email:  Type.String({ format: 'email' }),
-    online: Type.Boolean(),
-}, { additionalProperties: false })
+const T = Type.Object({
+  x: Type.Number(),
+  y: Type.Number(),
+  z: Type.Number()
+})
 
 //--------------------------------------------------------------------------------------------
 //
@@ -686,54 +948,205 @@ const User = Type.Object({
 //
 //--------------------------------------------------------------------------------------------
 
-const ok = ajv.validate(User, { 
-    userId: '68b4b1d8-0db6-468d-b551-02069a692044', 
-    email:  'dave@domain.com',
-    online:  true
-}) // -> ok
+const R = ajv.validate(T, { x: 1, y: 2, z: 3 })      // const R = true
 ```
 
-Please refer to the official AJV [documentation](https://ajv.js.org/guide/getting-started.html) for additional information on using AJV.
+<a name='typecheck-compiler'></a>
+
+### Compiler
 
-### OpenAPI
+TypeBox provides an optional high performance just-in-time (JIT) compiler and type checker that can be used in applications that require extremely fast validation. Note that this compiler is optimized for TypeBox types only where the schematics are known in advance. If defining custom types with `Type.Unsafe<T>` please consider Ajv.
 
-TypeBox can be used to create schemas for OpenAPI, however users should be mindful of some disparities between the JSON Schema and OpenAPI for versions prior to OpenAPI 3.1. Two common instances where OpenAPI diverges is the handling nullable and string enum schemas types. The following shows how you can use TypeBox to construct these types.
+The compiler module is provided as an optional import.
 
 ```typescript
-import { Type, Static, TNull, TLiteral, TUnion, TSchema } from '@sinclair/typebox'
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+```
 
-//--------------------------------------------------------------------------------------------
-//
-// Nullable<T>
-//
-//--------------------------------------------------------------------------------------------
+Use the `Compile(...)` function to compile a type.
 
-function Nullable<T extends TSchema>(schema: T): TUnion<[T, TNull]> {
-    return { ...schema, nullable: true } as any
-}
+```typescript
+const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
+  x: Type.Number(),                                  //     x: TNumber;
+  y: Type.Number(),                                  //     y: TNumber;
+  z: Type.Number()                                   //     z: TNumber;
+}))                                                  // }>>
 
-const T = Nullable(Type.String())              // const T = {
-                                               //   type: 'string',
-                                               //   nullable: true
-                                               // }
+const R = C.Check({ x: 1, y: 2, z: 3 })              // const R = true
+```
 
-type T = Static<typeof T>                      // type T = string | null
+Validation errors can be read with the `Errors(...)` function.
 
-//--------------------------------------------------------------------------------------------
-//
-// StringUnion<[...]>
-//
-//--------------------------------------------------------------------------------------------
+```typescript
+const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
+  x: Type.Number(),                                  //     x: TNumber;
+  y: Type.Number(),                                  //     y: TNumber;
+  z: Type.Number()                                   //     z: TNumber;
+}))                                                  // }>>
+
+const value = { }
+
+const errors = [...C.Errors(value)]                  // const errors = [{
+                                                     //   schema: { type: 'number' },
+                                                     //   path: '/x',
+                                                     //   value: undefined,
+                                                     //   message: 'Expected number'
+                                                     // }, {
+                                                     //   schema: { type: 'number' },
+                                                     //   path: '/y',
+                                                     //   value: undefined,
+                                                     //   message: 'Expected number'
+                                                     // }, {
+                                                     //   schema: { type: 'number' },
+                                                     //   path: '/z',
+                                                     //   value: undefined,
+                                                     //   message: 'Expected number'
+                                                     // }]
+```
 
-type IntoStringUnion<T> = {[K in keyof T]: T[K] extends string ? TLiteral<T[K]>: never }
+Compiled routines can be inspected with the `.Code()` function.
 
-function StringUnion<T extends string[]>(values: [...T]): TUnion<IntoStringUnion<T>> {
-    return { enum: values } as any
-}
+```typescript
+const C = TypeCompiler.Compile(Type.String())        // const C: TypeCheck<TString>
+
+console.log(C.Code())                                // return function check(value) {
+                                                     //   return (
+                                                     //     (typeof value === 'string')
+                                                     //   )
+                                                     // }
+```
+
+<a name='typecheck-formats'></a>
+
+### Formats
+
+Use the format module to create user defined string formats. The format module is used by the Value and TypeCompiler modules only. If using Ajv, please refer to the official Ajv format documentation located [here](https://ajv.js.org/guide/formats.html).
 
-const T = StringUnion(['A', 'B', 'C'])          // const T = {
-                                                //    enum: ['A', 'B', 'C']
-                                                // }
+The format module is an optional import.
 
-type T = Static<typeof T>                       // type T = 'A' | 'B' | 'C'
+```typescript
+import { Format } from '@sinclair/typebox/format'
+```
+
+The following creates a `palindrome` string format.
+
+```typescript
+Format.Set('palindrome', value => value === value.split('').reverse().join(''))
+```
+
+Once set, this format can then be used by the TypeCompiler and Value modules.
+
+```typescript
+const T = Type.String({ format: 'palindrome' })
+
+const A = TypeCompiler.Compile(T).Check('engine')    // const A = false
+
+const B = Value.Check(T, 'kayak')                    // const B = true
+```
+
+<a name='benchmark'></a>
+
+## Benchmark
+
+This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.11.0. 
+
+For additional comparative benchmarks, please refer to [typescript-runtime-type-benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/).
+
+<a name='benchmark-compile'></a>
+
+### Compile
+
+This benchmark measures compilation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/measurement/module/compile.ts).
+
+```typescript
+┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
+│     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
+├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
+│           Number │    2000    │ '    384 ms' │ '      9 ms' │ '   42.67 x' │
+│           String │    2000    │ '    322 ms' │ '      8 ms' │ '   40.25 x' │
+│          Boolean │    2000    │ '    310 ms' │ '      6 ms' │ '   51.67 x' │
+│             Null │    2000    │ '    271 ms' │ '      6 ms' │ '   45.17 x' │
+│            RegEx │    2000    │ '    491 ms' │ '     12 ms' │ '   40.92 x' │
+│          ObjectA │    2000    │ '   2935 ms' │ '     44 ms' │ '   66.70 x' │
+│          ObjectB │    2000    │ '   3076 ms' │ '     30 ms' │ '  102.53 x' │
+│            Tuple │    2000    │ '   1274 ms' │ '     22 ms' │ '   57.91 x' │
+│            Union │    2000    │ '   1281 ms' │ '     22 ms' │ '   58.23 x' │
+│          Vector4 │    2000    │ '   1602 ms' │ '     17 ms' │ '   94.24 x' │
+│          Matrix4 │    2000    │ '    959 ms' │ '     10 ms' │ '   95.90 x' │
+│   Literal_String │    2000    │ '    337 ms' │ '      6 ms' │ '   56.17 x' │
+│   Literal_Number │    2000    │ '    376 ms' │ '      5 ms' │ '   75.20 x' │
+│  Literal_Boolean │    2000    │ '    370 ms' │ '      5 ms' │ '   74.00 x' │
+│     Array_Number │    2000    │ '    733 ms' │ '      9 ms' │ '   81.44 x' │
+│     Array_String │    2000    │ '    764 ms' │ '     10 ms' │ '   76.40 x' │
+│    Array_Boolean │    2000    │ '    818 ms' │ '      6 ms' │ '  136.33 x' │
+│    Array_ObjectA │    2000    │ '   3744 ms' │ '     35 ms' │ '  106.97 x' │
+│    Array_ObjectB │    2000    │ '   3893 ms' │ '     34 ms' │ '  114.50 x' │
+│      Array_Tuple │    2000    │ '   2229 ms' │ '     16 ms' │ '  139.31 x' │
+│      Array_Union │    2000    │ '   1705 ms' │ '     18 ms' │ '   94.72 x' │
+│    Array_Vector4 │    2000    │ '   2261 ms' │ '     17 ms' │ '  133.00 x' │
+│    Array_Matrix4 │    2000    │ '   1574 ms' │ '     14 ms' │ '  112.43 x' │
+└──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
+```
+
+<a name='benchmark-validate'></a>
+
+### Validate
+
+This benchmark measures validation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/measurement/module/check.ts).
+
+```typescript
+┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
+│     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
+├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
+│           Number │  1000000   │ '     37 ms' │ '      5 ms' │ '      5 ms' │ '    1.00 x' │
+│           String │  1000000   │ '     31 ms' │ '     24 ms' │ '     13 ms' │ '    1.85 x' │
+│          Boolean │  1000000   │ '     25 ms' │ '     25 ms' │ '     11 ms' │ '    2.27 x' │
+│             Null │  1000000   │ '     32 ms' │ '     26 ms' │ '     10 ms' │ '    2.60 x' │
+│            RegEx │  1000000   │ '    170 ms' │ '     48 ms' │ '     35 ms' │ '    1.37 x' │
+│          ObjectA │  1000000   │ '    564 ms' │ '     36 ms' │ '     23 ms' │ '    1.57 x' │
+│          ObjectB │  1000000   │ '   1000 ms' │ '     56 ms' │ '     40 ms' │ '    1.40 x' │
+│            Tuple │  1000000   │ '    125 ms' │ '     27 ms' │ '     13 ms' │ '    2.08 x' │
+│            Union │  1000000   │ '    316 ms' │ '     27 ms' │ '     14 ms' │ '    1.93 x' │
+│        Recursive │  1000000   │ '   3308 ms' │ '    415 ms' │ '    183 ms' │ '    2.27 x' │
+│          Vector4 │  1000000   │ '    135 ms' │ '     27 ms' │ '     12 ms' │ '    2.25 x' │
+│          Matrix4 │  1000000   │ '    658 ms' │ '     44 ms' │ '     30 ms' │ '    1.47 x' │
+│   Literal_String │  1000000   │ '     48 ms' │ '     26 ms' │ '     10 ms' │ '    2.60 x' │
+│   Literal_Number │  1000000   │ '     49 ms' │ '     31 ms' │ '      9 ms' │ '    3.44 x' │
+│  Literal_Boolean │  1000000   │ '     47 ms' │ '     28 ms' │ '     10 ms' │ '    2.80 x' │
+│     Array_Number │  1000000   │ '    418 ms' │ '     38 ms' │ '     17 ms' │ '    2.24 x' │
+│     Array_String │  1000000   │ '    466 ms' │ '     35 ms' │ '     22 ms' │ '    1.59 x' │
+│    Array_Boolean │  1000000   │ '    403 ms' │ '     41 ms' │ '     24 ms' │ '    1.71 x' │
+│    Array_ObjectA │  1000000   │ '  13596 ms' │ '   2861 ms' │ '   1759 ms' │ '    1.63 x' │
+│    Array_ObjectB │  1000000   │ '  15767 ms' │ '   2798 ms' │ '   1991 ms' │ '    1.41 x' │
+│      Array_Tuple │  1000000   │ '   1666 ms' │ '    103 ms' │ '     73 ms' │ '    1.41 x' │
+│      Array_Union │  1000000   │ '   4738 ms' │ '    229 ms' │ '     87 ms' │ '    2.63 x' │
+│  Array_Recursive │  1000000   │ '  56371 ms' │ '   7315 ms' │ '   2813 ms' │ '    2.60 x' │
+│    Array_Vector4 │  1000000   │ '   2180 ms' │ '    106 ms' │ '     53 ms' │ '    2.00 x' │
+│    Array_Matrix4 │  1000000   │ '  11795 ms' │ '    384 ms' │ '    313 ms' │ '    1.23 x' │
+└──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
+
+<a name='benchmark-compression'></a>
+
+### Compression
+
+The following table lists esbuild compiled and minified sizes for each TypeBox module.
+
+```typescript
+┌──────────────────────┬────────────┬────────────┬─────────────┐
+│       (index)        │  Compiled  │  Minified  │ Compression │
+├──────────────────────┼────────────┼────────────┼─────────────┤
+│ typebox/compiler     │ '   49 kb' │ '   24 kb' │  '2.00 x'   │
+│ typebox/conditional  │ '   42 kb' │ '   17 kb' │  '2.46 x'   │
+│ typebox/format       │ '    0 kb' │ '    0 kb' │  '2.66 x'   │
+│ typebox/guard        │ '   21 kb' │ '   10 kb' │  '2.07 x'   │
+│ typebox/value        │ '   72 kb' │ '   33 kb' │  '2.16 x'   │
+│ typebox              │ '   11 kb' │ '    6 kb' │  '1.91 x'   │
+└──────────────────────┴────────────┴────────────┴─────────────┘
+```
+
+<a name='contribute'></a>
+
+## Contribute
+
+TypeBox is open to community contribution. Please ensure you submit an open issue before submitting your pull request. The TypeBox project preferences open community discussion prior to accepting new features.
diff --git a/spec/schema/any.ts b/spec/schema/any.ts
deleted file mode 100644
index decdc2667..000000000
--- a/spec/schema/any.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe("Any", () => {
-    it('Should validate number', () => {
-        const T = Type.Any()
-        ok(T, 1)
-    })
-    it('Should validate string', () => {
-        const T = Type.Any()
-        ok(T, 'hello')
-    })
-    it('Should validate boolean', () => {
-        const T = Type.Any()
-        ok(T, true)
-    })
-    it('Should validate array', () => {
-        const T = Type.Any()
-        ok(T, [1, 2, 3])
-    })
-    it('Should validate object', () => {
-        const T = Type.Any()
-        ok(T, { a: 1, b: 2 })
-    })
-    it('Should validate null', () => {
-        const T = Type.Any()
-        ok(T, null)
-    })
-    it('Should validate undefined', () => {
-        const T = Type.Any()
-        ok(T, undefined)
-    })
-})
diff --git a/spec/schema/array.ts b/spec/schema/array.ts
deleted file mode 100644
index 6c4fcbded..000000000
--- a/spec/schema/array.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe("Array", () => {
-    it('Should validate an array of any', () => {
-        const T = Type.Array(Type.Any())
-        ok(T, [0, true, 'hello', {}])
-    })
-
-    it('Should not validate varying array when item is number', () => {
-        const T = Type.Array(Type.Number())
-        fail(T, [1, 2, 3, 'hello'])
-    })
-
-    it('Should validate for an array of unions', () => {
-        const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
-        ok(T, [1, 'hello', 3, 'world'])
-    })
-
-    it('Should not validate for an array of unions where item is not in union.', () => {
-        const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
-        fail(T, [1, 'hello', 3, 'world', true])
-    })
-
-    it('Should validate for an empty array', () => {
-        const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
-        ok(T, [])
-    })
-
-    it('Should validate for an array of intersection types', () => {
-        const A = Type.Object({ a: Type.String() })
-        const B = Type.Object({ b: Type.String() })
-        const C = Type.Intersect([A, B], { unevaluatedProperties: false })
-        const T = Type.Array(C)
-        ok(T, [
-            { a: 'hello', b: 'hello' },
-            { a: 'hello', b: 'hello' },
-            { a: 'hello', b: 'hello' },
-        ])
-    })
-
-    it('Should not validate for an array of intersection types when passing unevaluated property', () => {
-        const A = Type.Object({ a: Type.String() })
-        const B = Type.Object({ b: Type.String() })
-        const C = Type.Intersect([A, B], { unevaluatedProperties: false })
-        const T = Type.Array(C)
-        fail(T, [
-            { a: 'hello', b: 'hello' },
-            { a: 'hello', b: 'hello' },
-            { a: 'hello', b: 'hello', c: 'additional' },
-        ])
-    })
-
-    it('Should validate an array of tuples', () => {
-        const A = Type.String()
-        const B = Type.Number()
-        const C = Type.Tuple([A, B])
-        const T = Type.Array(C)
-        ok(T, [
-            ['hello', 1],
-            ['hello', 1],
-            ['hello', 1],
-        ])
-    })
-
-    it('Should not validate an array of tuples when tuple values are incorrect', () => {
-        const A = Type.String()
-        const B = Type.Number()
-        const C = Type.Tuple([A, B])
-        const T = Type.Array(C)
-        fail(T, [
-            [1, 'hello'],
-            [1, 'hello'],
-            [1, 'hello'],
-        ])
-    })
-})
diff --git a/spec/schema/boolean.ts b/spec/schema/boolean.ts
deleted file mode 100644
index 6ce216837..000000000
--- a/spec/schema/boolean.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe("Boolean", () => {
-
-    it('Should validate a boolean', () => {
-        const T = Type.Boolean()
-        ok(T, true)
-        ok(T, false)
-    })
-
-    it('Should not validate a number', () => {
-        const T = Type.Boolean()
-        fail(T, 1)
-    })
-
-    it('Should not validate a string', () => {
-        const T = Type.Boolean()
-        fail(T, 'true')
-    })
-
-    it('Should not validate an array', () => {
-        const T = Type.Boolean()
-        fail(T, [true])
-    })
-
-    it('Should not validate an object', () => {
-        const T = Type.Boolean()
-        fail(T, {})
-    })
-
-    it('Should not validate an null', () => {
-        const T = Type.Boolean()
-        fail(T, null)
-    })
-
-    it('Should not validate an undefined', () => {
-        const T = Type.Boolean()
-        fail(T, undefined)
-    })
-})
diff --git a/spec/schema/box.ts b/spec/schema/box.ts
deleted file mode 100644
index a605d00ba..000000000
--- a/spec/schema/box.ts
+++ /dev/null
@@ -1,74 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe("Box", () => {
-
-    it('Should should validate Vertex structure', () => {
-        const Vector2 = Type.Object({ x: Type.Number(), y: Type.Number() })
-        const Vector3 = Type.Object({ x: Type.Number(), y: Type.Number(), z: Type.Number() })
-        const Vector4 = Type.Object({ x: Type.Number(), y: Type.Number(), z: Type.Number(), w: Type.Number() })
-        const Math3D = Type.Namespace({ Vector2, Vector3, Vector4 }, { $id: 'Math3D' })
-        const Vertex = Type.Object({
-            position: Type.Ref(Math3D, 'Vector4'),
-            normal: Type.Ref(Math3D, 'Vector3'),
-            uv: Type.Ref(Math3D, 'Vector2'),
-        })
-
-        ok(Vertex, {
-            position: { x: 1, y: 1, z: 1, w: 1 },
-            normal:   { x: 1, y: 1, z: 1 },
-            uv:       { x: 1, y: 1 },
-        }, [Math3D])
-    })
-
-    it('Should not validate when Vertex structure is missing properties', () => {
-        const Vector2 = Type.Object({ x: Type.Number(), y: Type.Number() })
-        const Vector3 = Type.Object({ x: Type.Number(), y: Type.Number(), z: Type.Number() })
-        const Vector4 = Type.Object({ x: Type.Number(), y: Type.Number(), z: Type.Number(), w: Type.Number() })
-        const Math3D = Type.Namespace({ Vector2, Vector3, Vector4 }, { $id: 'Math3D' })
-        const Vertex = Type.Object({
-            position: Type.Ref(Math3D, 'Vector4'),
-            normal: Type.Ref(Math3D, 'Vector3'),
-            uv: Type.Ref(Math3D, 'Vector2'),
-        })
-
-        fail(Vertex, {
-            position: { x: 1, y: 1, z: 1, w: 1 },
-            normal:   { x: 1, y: 1, z: 1 },
-        }, [Math3D])
-    })
-
-    it('Should not validate when Vertex structure contains invalid property values.', () => {
-        const Vector2 = Type.Object({ x: Type.Number(), y: Type.Number() })
-        const Vector3 = Type.Object({ x: Type.Number(), y: Type.Number(), z: Type.Number() })
-        const Vector4 = Type.Object({ x: Type.Number(), y: Type.Number(), z: Type.Number(), w: Type.Number() })
-        const Math3D = Type.Namespace({ Vector2, Vector3, Vector4 }, { $id: 'Math3D' })
-        const Vertex = Type.Object({
-            position: Type.Ref(Math3D, 'Vector4'),
-            normal:  Type.Ref(Math3D, 'Vector3'),
-            uv:      Type.Ref(Math3D, 'Vector2'),
-        })
-        fail(Vertex, {
-            position: { x: 1, y: 1, z: 1, w: 1 },
-            normal:   { x: 1, y: 1, z: 1 },
-            uv:       { x: 1, y: 'not a number'},
-        }, [Math3D])
-    })
-
-    it('Should not validate when Box has not been registered with validator (AJV)', () => {
-        const Vector2 = Type.Object({ x: Type.Number(), y: Type.Number() })
-        const Vector3 = Type.Object({ x: Type.Number(), y: Type.Number(), z: Type.Number() })
-        const Vector4 = Type.Object({ x: Type.Number(), y: Type.Number(), z: Type.Number(), w: Type.Number() })
-        const Math3D = Type.Namespace({ Vector2, Vector3, Vector4 }, { $id: 'Math3D' })
-        const Vertex = Type.Object({
-            position: Type.Ref(Math3D, 'Vector4'),
-            normal:   Type.Ref(Math3D, 'Vector3'),
-            uv:       Type.Ref(Math3D, 'Vector2'),
-        })
-        fail(Vertex, {
-            position: { x: 1, y: 1, z: 1, w: 1 },
-            normal:   { x: 1, y: 1, z: 1 },
-            uv:       { x: 1, y: 1},
-        }, [])
-    })
-})
diff --git a/spec/schema/enum.ts b/spec/schema/enum.ts
deleted file mode 100644
index 2a6356c3c..000000000
--- a/spec/schema/enum.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe('Enum', () => {
-
-    it('Should validate when emum uses default numeric values', () => {
-        enum Kind {
-            Foo, // = 0
-            Bar  // = 1
-        }
-        const T = Type.Enum(Kind)
-        ok(T, 0)
-        ok(T, 1)
-    })
-    it('Should not validate when given enum values are not numeric', () => {
-        enum Kind {
-            Foo, // = 0
-            Bar  // = 1
-        }
-        const T = Type.Enum(Kind)
-        fail(T, 'Foo')
-        fail(T, 'Bar')
-    })
-
-    it('Should validate when emum has defined string values', () => {
-        enum Kind {
-            Foo = 'foo',
-            Bar = 'bar'
-        }
-        const T = Type.Enum(Kind)
-        ok(T, 'foo')
-        ok(T, 'bar')
-    })
-
-    it('Should not validate when emum has defined string values and user passes numeric', () => {
-        enum Kind {
-            Foo = 'foo',
-            Bar = 'bar'
-        }
-        const T = Type.Enum(Kind)
-        fail(T, 0)
-        fail(T, 1)
-    })
-
-    it('Should validate when enum has one or more string values', () => {
-        enum Kind {
-            Foo,
-            Bar = 'bar'
-        }
-        const T = Type.Enum(Kind)
-        ok(T, 0)
-        ok(T, 'bar')
-        fail(T, 'baz')
-        fail(T, 'Foo')
-        fail(T, 1)
-    })
-})
diff --git a/spec/schema/intersect.ts b/spec/schema/intersect.ts
deleted file mode 100644
index 4a7f9cd5d..000000000
--- a/spec/schema/intersect.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe('Intersect', () => {
-
-    it('Should intersect two objects', () => {
-        const A = Type.Object({ a: Type.String() })
-        const B = Type.Object({ b: Type.Number() })
-        const T = Type.Intersect([A, B])
-        ok(T, { a: 'hello', b: 42 })
-    })
-
-    it('Should allow additional properties if not using unevaluatedProperties', () => {
-        const A = Type.Object({ a: Type.String() })
-        const B = Type.Object({ b: Type.Number() })
-        const T = Type.Intersect([A, B])
-        ok(T, { a: 'hello', b: 42, c: true })
-    })
-
-    it('Should not allow additional properties if using unevaluatedProperties', () => {
-        const A = Type.Object({ a: Type.String() })
-        const B = Type.Object({ b: Type.Number() })
-        const T = Type.Intersect([A, B], { unevaluatedProperties: false })
-        fail(T, { a: 'hello', b: 42, c: true })
-    })
-
-    describe('Should not allow unevaluatedProperties with record intersection', () => {
-        const A = Type.Object({
-            a: Type.String(),
-            b: Type.String(),
-            c: Type.String()
-        })
-        const B = Type.Record(Type.Number(), Type.Number())
-        const T = Type.Intersect([A, B])
-        ok(T, {
-            a: 'a', b: 'b', c: 'c',
-            0: 1, 1: 2, 2: 3
-        })
-    })
-
-    describe('Should intersect object with number record', () => {
-        const A = Type.Object({
-            a: Type.String(),
-            b: Type.String(),
-            c: Type.String()
-        })
-        const B = Type.Record(Type.Number(), Type.Number())
-        const T = Type.Intersect([A, B])
-        ok(T, {
-            a: 'a', b: 'b', c: 'c',
-            0: 1, 1: 2, 2: 3
-        })
-    })
-
-    describe('Should not intersect object with string record', () => {
-        const A = Type.Object({
-            a: Type.String(),
-            b: Type.String(),
-            c: Type.String()
-        })
-        const B = Type.Record(Type.String(), Type.Number())
-        const T = Type.Intersect([A, B])
-        fail(T, {
-            a: 'a', b: 'b', c: 'c',
-            x: 1, y: 2, z: 3
-        })
-    })
-
-    describe('Should intersect object with union literal record', () => {
-        const A = Type.Object({
-            a: Type.String(),
-            b: Type.String(),
-            c: Type.String()
-        })
-        const K = Type.Union([
-            Type.Literal('x'),
-            Type.Literal('y'),
-            Type.Literal('z')
-        ])
-        const B = Type.Record(K, Type.Number())
-        const T = Type.Intersect([A, B])
-        ok(T, {
-            a: 'a', b: 'b', c: 'c',
-            x: 1, y: 2, z: 3
-        })
-    })
-
-    describe('Should intersect with partial', () => {
-        const A = Type.Object({ a: Type.Number() })
-        const B = Type.Object({ b: Type.Number() })
-        const P = Type.Intersect([Type.Partial(A), Type.Partial(B)], { unevaluatedProperties: false })
-        ok(P, { a: 1, b: 2 })
-        ok(P, { a: 1 })
-        ok(P, { b: 1 })
-        fail(P, { c: 1 })
-    })
-})
diff --git a/spec/schema/keyof.ts b/spec/schema/keyof.ts
deleted file mode 100644
index 7ef2b0810..000000000
--- a/spec/schema/keyof.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { Type }        from '@sinclair/typebox'
-import { ok, fail }    from './validate'
-import { strictEqual } from 'assert'
-
-describe("KeyOf", () => {
-    it('Should validate with all object keys as a kind of union', () => {
-        const T = Type.KeyOf(Type.Object({
-            x: Type.Number(),
-            y: Type.Number(),
-            z: Type.Number()
-        }))
-        ok(T, 'x')
-        ok(T, 'y')
-        ok(T, 'z')
-        fail(T, 'w')
-    })
-
-    it('Should validate when using pick', () => {
-        const T = Type.KeyOf(Type.Pick(Type.Object({
-            x: Type.Number(),
-            y: Type.Number(),
-            z: Type.Number()
-        }), ['x', 'y']))
-        ok(T, 'x')
-        ok(T, 'y')
-        fail(T, 'z')
-    })
-
-    it('Should validate when using omit', () => {
-        const T = Type.KeyOf(Type.Omit(Type.Object({
-            x: Type.Number(),
-            y: Type.Number(),
-            z: Type.Number()
-        }), ['x', 'y']))
-
-        fail(T, 'x')
-        fail(T, 'y')
-        ok(T, 'z')
-    })
-
-    it('Should construct new object when targetting reference', () => {
-        const T = Type.Object({ a: Type.String(), b: Type.String() }, { $id: 'T' })
-        const R = Type.Ref(T)
-        const P = Type.KeyOf(R, [])
-        strictEqual(P.enum[0], 'a')
-        strictEqual(P.enum[1], 'b')
-     })
-})
diff --git a/spec/schema/literal.ts b/spec/schema/literal.ts
deleted file mode 100644
index 72d190c1b..000000000
--- a/spec/schema/literal.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-import * as assert from 'assert'
-
-describe("Literal", () => {
-    it('Should validate literal number', () => {
-        const T = Type.Literal(42)
-        ok(T, 42)
-    })
-    it('Should validate literal string', () => {
-        const T = Type.Literal('hello')
-        ok(T, 'hello')
-    })
-
-    it('Should validate literal boolean', () => {
-        const T = Type.Literal(true)
-        ok(T, true)
-    })
-
-    it('Should not validate invalid literal number', () => {
-        const T = Type.Literal(42)
-        fail(T, 43)
-    })
-    it('Should not validate invalid literal string', () => {
-        const T = Type.Literal('hello')
-        fail(T, 'world')
-    })
-    it('Should not validate invalid literal boolean', () => {
-        const T = Type.Literal(false)
-        fail(T, true)
-    })
-
-    it('Should validate literal union', () => {
-        const T = Type.Union([Type.Literal(42), Type.Literal('hello')])
-        ok(T, 42)
-        ok(T, 'hello')
-    })
-
-    it('Should not validate invalid literal union', () => {
-        const T = Type.Union([Type.Literal(42), Type.Literal('hello')])
-        fail(T, 43)
-        fail(T, 'world')
-    })
-})
diff --git a/spec/schema/modifier.ts b/spec/schema/modifier.ts
deleted file mode 100644
index 456b72513..000000000
--- a/spec/schema/modifier.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { Type, ReadonlyModifier, OptionalModifier } from '@sinclair/typebox'
-import * as assert from 'assert'
-
-describe('Modifier', () => {
-    it('Omit modifier', () => {
-        const T = Type.Object({
-            a: Type.Readonly(Type.String()),
-            b: Type.Optional(Type.String()),
-        })
-
-        const S = JSON.stringify(T)
-        const P = JSON.parse(S) as any
-
-        // check assignment on Type
-        assert.equal(T.properties.a['modifier'], ReadonlyModifier)
-        assert.equal(T.properties.b['modifier'], OptionalModifier)
-
-        // check deserialized
-        assert.equal(P.properties.a['modifier'], undefined)
-        assert.equal(P.properties.b['modifier'], undefined)
-    })
-})
diff --git a/spec/schema/null.ts b/spec/schema/null.ts
deleted file mode 100644
index 3ea7e8867..000000000
--- a/spec/schema/null.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe("Null", () => {
-    it('Should not validate number', () => {
-        const T = Type.Null()
-        fail(T, 1)
-    })
-
-    it('Should not validate string', () => {
-        const T = Type.Null()
-        fail(T, 'hello')
-    })
-
-    it('Should not validate boolean', () => {
-        const T = Type.Null()
-        fail(T, true)
-    })
-
-    it('Should not validate array', () => {
-        const T = Type.Null()
-        fail(T, [1, 2, 3])
-    })
-
-    it('Should not validate object', () => {
-        const T = Type.Null()
-        fail(T, { a: 1, b: 2 })
-    })
-
-    it('Should not validate null', () => {
-        const T = Type.Null()
-        ok(T, null)
-    })
-
-    it('Should not validate undefined', () => {
-        const T = Type.Null()
-        fail(T, undefined)
-    })
-})
diff --git a/spec/schema/number.ts b/spec/schema/number.ts
deleted file mode 100644
index a37af99a1..000000000
--- a/spec/schema/number.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe("Number", () => {
-    it('Should validate number', () => {
-        const T = Type.Number()
-        ok(T, 1)
-    })
-    it('Should not validate string', () => {
-        const T = Type.Number()
-        fail(T, 'hello')
-    })
-    it('Should not validate boolean', () => {
-        const T = Type.Number()
-        fail(T, true)
-    })
-    it('Should not validate array', () => {
-        const T = Type.Number()
-        fail(T, [1, 2, 3])
-    })
-    it('Should not validate object', () => {
-        const T = Type.Number()
-        fail(T, { a: 1, b: 2 })
-    })
-    it('Should not validate null', () => {
-        const T = Type.Number()
-        fail(T, null)
-    })
-    it('Should not validate undefined', () => {
-        const T = Type.Number()
-        fail(T, undefined)
-    })
-})
diff --git a/spec/schema/object.ts b/spec/schema/object.ts
deleted file mode 100644
index e1e0285a7..000000000
--- a/spec/schema/object.ts
+++ /dev/null
@@ -1,94 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe('Object', () => {
-
-    it('Should not validate a number', () => {
-        const T = Type.Object({})
-        fail(T, 42)
-    })
-
-    it('Should not validate a string', () => {
-        const T = Type.Object({})
-        fail(T, 'hello')
-    })
-
-    it('Should not validate a boolean', () => {
-        const T = Type.Object({})
-        fail(T, true)
-    })
-    
-    it('Should not validate a null', () => {
-        const T = Type.Object({})
-        fail(T, null)
-    })
-
-    it('Should not validate an array', () => {
-        const T = Type.Object({})
-        fail(T, [1, 2])
-    })
-
-    it('Should validate with correct property values', () => {
-        const T = Type.Object({
-            a: Type.Number(),
-            b: Type.String(),
-            c: Type.Boolean(),
-            d: Type.Array(Type.Number()),
-            e: Type.Object({ x: Type.Number(), y: Type.Number() })
-        })
-        ok(T, {
-            a: 10,
-            b: 'hello',
-            c: true,
-            d: [1, 2, 3],
-            e: { x: 10, y: 20 }
-        })
-    })
-
-    it('Should not validate with incorrect property values', () => {
-        const T = Type.Object({
-            a: Type.Number(),
-            b: Type.String(),
-            c: Type.Boolean(),
-            d: Type.Array(Type.Number()),
-            e: Type.Object({ x: Type.Number(), y: Type.Number() })
-        })
-        fail(T, {
-            a: 'not a number', // error
-            b: 'hello',
-            c: true,
-            d: [1, 2, 3],
-            e: { x: 10, y: 20 }
-        })
-    })
-
-    it('Should allow additionalProperties by default', () => {
-        const T = Type.Object({
-            a: Type.Number(),
-            b: Type.String()
-        })
-        ok(T, {
-            a: 1,
-            b: 'hello',
-            c: true
-        })
-    })
-
-    it('Should not allow additionalProperties if additionalProperties is false', () => {
-        const T = Type.Object({
-            a: Type.Number(),
-            b: Type.String()
-        }, { additionalProperties: false })
-        fail(T, {
-            a: 1,
-            b: 'hello',
-            c: true
-        })
-    })
-
-    it('Should not allow properties for an empty object when additionalProperties is false', () => {
-        const T = Type.Object({}, { additionalProperties: false })
-        ok(T, {})
-        fail(T, { a: 10 })
-    })
-})
diff --git a/spec/schema/omit.ts b/spec/schema/omit.ts
deleted file mode 100644
index e4cb69d26..000000000
--- a/spec/schema/omit.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-import { strictEqual } from 'assert'
-
-describe('Omit', () => {
-    it('Should omit properties on the source schema', () => {
-        const A = Type.Object({
-            x: Type.Number(),
-            y: Type.Number(),
-            z: Type.Number()
-        }, { additionalProperties: false })
-        const T = Type.Omit(A, ['z'])
-        ok(T, { x: 1, y: 1 })
-    })
-
-    it('Should remove required properties on the target schema', () => {
-        const A = Type.Object({
-            x: Type.Number(),
-            y: Type.Number(),
-            z: Type.Number()
-        }, { additionalProperties: false })
-        const T = Type.Omit(A, ['z'])
-        strictEqual(T.required!.includes('z'), false)
-    })
-
-    it('Should inherit options from the source object', () => {
-        const A = Type.Object({
-            x: Type.Number(),
-            y: Type.Number(),
-            z: Type.Number()
-        }, { additionalProperties: false })
-        const T = Type.Omit(A, ['z'])
-        strictEqual(A.additionalProperties, false)
-        strictEqual(T.additionalProperties, false)
-    })
-    
-    it('Should construct new object when targetting reference', () => {
-        const T = Type.Object({ a: Type.String(), b: Type.String() }, { $id: 'T' })
-        const R = Type.Ref(T)
-        const P = Type.Omit(R, [])
-        strictEqual(P.properties.a.type, 'string')
-        strictEqual(P.properties.b.type, 'string')
-     })
-})
diff --git a/spec/schema/optional.ts b/spec/schema/optional.ts
deleted file mode 100644
index 07168d943..000000000
--- a/spec/schema/optional.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import { deepStrictEqual, strictEqual } from 'assert'
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe('Optional', () => {
-    it('Should validate object with optional', () => {
-        const T = Type.Object({
-            a: Type.Optional(Type.String()),
-            b: Type.String()
-        }, { additionalProperties: false })
-        ok(T, { a: 'hello', b: 'world' })
-        ok(T, { b: 'world' })
-    })
-    it('Should remove required value from schema', () => {
-        const T = Type.Object({
-            a: Type.Optional(Type.String()),
-            b: Type.String()
-        }, { additionalProperties: false })
-        strictEqual(T.required!.includes('a'), false)
-    })
-})
diff --git a/spec/schema/partial.ts b/spec/schema/partial.ts
deleted file mode 100644
index 0e3af59f1..000000000
--- a/spec/schema/partial.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import { OptionalModifier, ReadonlyOptionalModifier, Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-import { strictEqual } from 'assert'
-
-describe('Partial', () => {
-
-    it('Should convert a required object into a partial.', () => {
-        const A = Type.Object({
-            x: Type.Number(),
-            y: Type.Number(),
-            z: Type.Number()
-        }, { additionalProperties: false })
-        const T = Type.Partial(A)
-        ok(T, { x: 1, y: 1, z: 1 })
-        ok(T, { x: 1, y: 1 })
-        ok(T, { x: 1 })
-        ok(T, {})
-    })
-
-    it('Should update modifier types correctly when converting to partial', () => {
-        const A = Type.Object({
-            x: Type.ReadonlyOptional(Type.Number()),
-            y: Type.Readonly(Type.Number()),
-            z: Type.Optional(Type.Number()),
-            w: Type.Number()
-        }, { additionalProperties: false })
-        const T = Type.Partial(A)
-        strictEqual(T.properties.x.modifier, ReadonlyOptionalModifier)
-        strictEqual(T.properties.y.modifier, ReadonlyOptionalModifier)
-        strictEqual(T.properties.z.modifier, OptionalModifier)
-        strictEqual(T.properties.w.modifier, OptionalModifier)
-    })
-
-    it('Should inherit options from the source object', () => {
-        const A = Type.Object({
-            x: Type.Number(),
-            y: Type.Number(),
-            z: Type.Number()
-        }, { additionalProperties: false })
-        const T = Type.Partial(A)
-        strictEqual(A.additionalProperties, false)
-        strictEqual(T.additionalProperties, false)
-    })
-
-    it('Should construct new object when targetting reference', () => {
-        const T = Type.Object({ a: Type.String(), b: Type.String() }, { $id: 'T' })
-        const R = Type.Ref(T)
-        const P = Type.Partial(R)
-        strictEqual(P.properties.a.type, 'string')
-        strictEqual(P.properties.b.type, 'string')
-     })
-})
diff --git a/spec/schema/pick.ts b/spec/schema/pick.ts
deleted file mode 100644
index 5318c3555..000000000
--- a/spec/schema/pick.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-import { strictEqual } from 'assert'
-
-describe('Pick', () => {
-    it('Should pick properties from the source schema', () => {
-        const Vector3 = Type.Object({
-            x: Type.Number(),
-            y: Type.Number(),
-            z: Type.Number()
-        }, { additionalProperties: false })
-        const T = Type.Pick(Vector3, ['x', 'y'])
-        ok(T, { x: 1, y: 1 })
-    })
-
-    it('Should remove required properties on the target schema', () => {
-        const A = Type.Object({
-            x: Type.Number(),
-            y: Type.Number(),
-            z: Type.Number()
-        }, { additionalProperties: false })
-        const T = Type.Pick(A, ['x', 'y'])
-        strictEqual(T.required!.includes('z'), false)
-    })
-
-    it('Should inherit options from the source object', () => {
-        const A = Type.Object({
-            x: Type.Number(),
-            y: Type.Number(),
-            z: Type.Number()
-        }, { additionalProperties: false })
-        const T = Type.Pick(A, ['x', 'y'])
-        strictEqual(A.additionalProperties, false)
-        strictEqual(T.additionalProperties, false)
-    })
-    it('Should construct new object when targetting reference', () => {
-        const T = Type.Object({ a: Type.String(), b: Type.String() }, { $id: 'T' })
-        const R = Type.Ref(T)
-        const P = Type.Pick(R, ['a', 'b'])
-        strictEqual(P.properties.a.type, 'string')
-        strictEqual(P.properties.b.type, 'string')
-     })
-})
diff --git a/spec/schema/readonly-optional.ts b/spec/schema/readonly-optional.ts
deleted file mode 100644
index 4edb7c9e2..000000000
--- a/spec/schema/readonly-optional.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-import { strictEqual } from 'assert'
-
-describe('ReadonlyOptional', () => {
-    it('Should validate object with optional', () => {
-        const T = Type.Object({
-            a: Type.ReadonlyOptional(Type.String()),
-            b: Type.String()
-        }, { additionalProperties: false })
-        ok(T, { a: 'hello', b: 'world' })
-        ok(T, { b: 'world' })
-    })
-    it('Should remove required value from schema', () => {
-        const T = Type.Object({
-            a: Type.ReadonlyOptional(Type.String()),
-            b: Type.String()
-        }, { additionalProperties: false })
-        strictEqual(T.required!.includes('a'), false)
-    })
-})
diff --git a/spec/schema/readonly.ts b/spec/schema/readonly.ts
deleted file mode 100644
index 8cdc0f855..000000000
--- a/spec/schema/readonly.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { deepStrictEqual, strictEqual } from 'assert'
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe('Readonly', () => {
-
-    it('Should validate object with readonly', () => {
-        const T = Type.Object({
-            a: Type.Readonly(Type.String()),
-            b: Type.Readonly(Type.String())
-        }, { additionalProperties: false })
-        ok(T, { a: 'hello', b: 'world' })
-    })
-
-    it('Should retain required array on object', () => {
-        const T = Type.Object({
-            a: Type.Readonly(Type.String()),
-            b: Type.Readonly(Type.String()),
-        }, { additionalProperties: false })
-        strictEqual(T.required!.includes('a'), true)
-        strictEqual(T.required!.includes('b'), true)
-    })
-})
\ No newline at end of file
diff --git a/spec/schema/rec.ts b/spec/schema/rec.ts
deleted file mode 100644
index 51a4801e9..000000000
--- a/spec/schema/rec.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe("Rec", () => {
-
-    it('Should validate recursive Node type', () => {
-        const Node = Type.Rec(Self => Type.Object({
-            nodeId: Type.String(),
-            nodes: Type.Array(Self)
-        }, { additionalProperties: false }))
-        ok(Node, { nodeId: '1', nodes: [] })
-        ok(Node, {
-            nodeId: '1',
-            nodes: [
-                { nodeId: '2', nodes: [] },
-                { nodeId: '3', nodes: [] },
-                { nodeId: '4', nodes: [] },
-                { nodeId: '5', nodes: [] }
-            ]
-        })
-    })
-    it('Should validate recursive Node type with an $id', () => {
-        const Node = Type.Rec(Self => Type.Object({
-            nodeId: Type.String(),
-            nodes: Type.Array(Self)
-        }, { additionalProperties: false }), 
-        { $id: 'Node' })
-        ok(Node, { nodeId: '1', nodes: [] })
-        ok(Node, {
-            nodeId: '1',
-            nodes: [
-                { nodeId: '2', nodes: [] },
-                { nodeId: '3', nodes: [] },
-                { nodeId: '4', nodes: [] },
-                { nodeId: '5', nodes: [] }
-            ]
-        })
-    })
-    it('Should not validate recursive Node type with missing properties', () => {
-        const Node = Type.Rec(Self => Type.Object({
-            nodeId: Type.String(),
-            nodes: Type.Array(Self)
-        }, { additionalProperties: false }))
-        fail(Node, {
-            nodes: [
-                { nodeId: '2', nodes: [] },
-                { nodeId: '3', nodes: [] },
-                { nodeId: '4', nodes: [] },
-                { nodeId: '5', nodes: [] }
-            ]
-        })
-    })
-
-    it('Should not validate recursive Node type with additionalProperties', () => {
-        const Node = Type.Rec(Self => Type.Object({
-            nodeId: Type.String(),
-            nodes: Type.Array(Self)
-        }, { additionalProperties: false }))
-        fail(Node, {
-            nodeId: '1',
-            nodes: [
-                { nodeId: '2', nodes: [] },
-                { nodeId: '3', nodes: [] },
-                { nodeId: '4', nodes: [] },
-                { nodeId: '5', nodes: [] }
-            ],
-            additional: 1
-        })
-    })
-
-
-    // it('Should validate with JSON pointer references to sub schema', () => {
-    //     const Element = Type.Rec('Element', Self => Type.Object({
-    //         elementId: Type.String(),
-    //         elements: Type.Array(Self)
-    //     }, { additionalProperties: false }))
-
-    //     const Node = Type.Rec('Node', Self => Type.Object({
-    //         nodeId: Type.String(),
-    //         nodes: Type.Array(Self),
-    //         element: Element
-    //     }, { additionalProperties: false }))
-
-    //     ok(Node, {
-    //         nodeId: '1',
-    //         nodes: [
-    //             { nodeId: '2', nodes: [] },
-    //             { nodeId: '3', nodes: [] },
-    //             { nodeId: '4', nodes: [] },
-    //             { nodeId: '5', nodes: [] }
-    //         ],
-    //         element: {
-    //             elementId: '1',
-    //             elements: [{
-    //                 elementId: '1',
-    //                 elements: []
-    //             }]
-    //         }
-    //     })
-    // })
-})
diff --git a/spec/schema/record.ts b/spec/schema/record.ts
deleted file mode 100644
index 187f2bcd6..000000000
--- a/spec/schema/record.ts
+++ /dev/null
@@ -1,100 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe('Record', () => {
-
-    it('Should validate when all property values are numbers', () => {
-        const T = Type.Record(Type.String(), Type.Number())
-        ok(T, { 'a': 1, 'b': 2, 'c': 3 })
-    })
-
-    it('Should validate when all property keys are strings', () => {
-        const T = Type.Record(Type.String(), Type.Number())
-        ok(T, { 'a': 1, 'b': 2, 'c': 3, '0': 4 })
-    })
-
-    it('Should validate when all property keys are numbers', () => {
-        const T = Type.Record(Type.Number(), Type.Number())
-        ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
-    })
-
-    it('Should validate when all property keys are numbers, but one property is a string with varying type', () => {
-        const T = Type.Record(Type.Number(), Type.Number())
-        ok(T, { '0': 1, '1': 2, '2': 3, '3': 4, 'a': 'hello' })
-    })
-
-    it('Should not validate if passing a leading zeros for numeric keys', () => {
-        const T = Type.Record(Type.Number(), Type.Number(), { additionalProperties: false })
-        fail(T, {
-            '00': 1,
-            '01': 2,
-            '02': 3,
-            '03': 4
-        })
-    })
-
-    it('Should not validate if passing a signed numeric keys', () => {
-        const T = Type.Record(Type.Number(), Type.Number(), { additionalProperties: false })
-        fail(T, {
-            '-0': 1,
-            '-1': 2,
-            '-2': 3,
-            '-3': 4
-        })
-    })
-
-    it('Should not validate when all property keys are numbers, but one property is a string with varying type with additionalProperties false', () => {
-        const T = Type.Record(Type.Number(), Type.Number(), { additionalProperties: false })
-        fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, 'a': 'hello' })
-    })
-
-    it('Should validate when specifying union literals for the known keys', () => {
-        const K = Type.Union([
-            Type.Literal('a'),
-            Type.Literal('b'),
-            Type.Literal('c'),
-        ])
-        const T = Type.Record(K, Type.Number())
-        ok(T, { a: 1, b: 2, c: 3, d: 'hello' })
-    })
-
-    it('Should not validate when specifying union literals for the known keys and with additionalProperties: false', () => {
-        const K = Type.Union([
-            Type.Literal('a'),
-            Type.Literal('b'),
-            Type.Literal('c'),
-        ])
-        const T = Type.Record(K, Type.Number(), { additionalProperties: false })
-        fail(T, { a: 1, b: 2, c: 3, d: 'hello' })
-    })
-
-    it('Should validate for keyof records', () => {
-        const T = Type.Object({
-            a: Type.String(),
-            b: Type.Number(),
-            c: Type.String()
-        })
-        const R = Type.Record(Type.KeyOf(T), Type.Number())
-        ok(R, { a: 1, b: 2, c: 3 })
-    })
-
-    it('Should should validate when specifying regular expressions', () => {
-        const K = Type.RegEx(/^op_.*$/)
-        const T = Type.Record(K, Type.Number(), { additionalProperties: false })
-        ok(T, {
-            'op_a': 1,
-            'op_b': 2,
-            'op_c': 3,
-        })
-    })
-
-    it('Should should not validate when specifying regular expressions and passing invalid property', () => {
-        const K = Type.RegEx(/^op_.*$/)
-        const T = Type.Record(K, Type.Number(), { additionalProperties: false })
-        fail(T, {
-            'op_a': 1,
-            'op_b': 2,
-            'aop_c': 3,
-        })
-    })
-})
diff --git a/spec/schema/ref.ts b/spec/schema/ref.ts
deleted file mode 100644
index 0eeee897b..000000000
--- a/spec/schema/ref.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe('Ref', () => {
-
-    it('Should should validate when referencing a type', () => {
-        const T = Type.Object({
-            x: Type.Number(),
-            y: Type.Number(),
-            z: Type.Number()
-        }, { $id: 'T' })
-        const R = Type.Ref(T)
-        ok(R, { 
-            x: 1, 
-            y: 2, 
-            z: 3 
-        }, [T])
-    })
-
-    it('Should not validate when passing invalid data', () => {
-        const T = Type.Object({
-            x: Type.Number(),
-            y: Type.Number(),
-            z: Type.Number()
-        }, { $id: 'T' })
-        const R = Type.Ref(T)
-        fail(R, { 
-            x: 1, 
-            y: 2
-        }, [T])
-    })
-
-    it('Should throw when not specifying an $id on target schema', () => {
-        try {
-            const T = Type.Object({
-                x: Type.Number(),
-                y: Type.Number(),
-                z: Type.Number()
-            }, { })
-            const R = Type.Ref(T)
-        } catch {
-            return
-        }
-        throw Error('Expected throw')
-    })
-
-    it('Should not validate when not adding additional schema', () => {
-        const T = Type.Object({
-            x: Type.Number(),
-            y: Type.Number(),
-            z: Type.Number()
-        }, { $id: 'T' })
-        const R = Type.Ref(T)
-        fail(R, { 
-            x: 1, 
-            y: 2, 
-            z: 3 
-        }, [])
-    })
-
-    it('Should validate as a Box, and as a Ref', () => {
-        const Vertex = Type.Object({
-            x: Type.Number(),
-            y: Type.Number(),
-            z: Type.Number()
-        }, { $id: 'Vertex' })
-        
-        const Box = Type.Namespace({ 
-            Vertex 
-        }, { $id: 'Box' })
-        
-        const R1 = Type.Ref(Vertex)
-        
-        const R2 = Type.Ref(Box, 'Vertex')
-
-        ok(R1, { 
-            x: 1, 
-            y: 2, 
-            z: 3 
-        }, [Box])
-        ok(R2, { 
-            x: 1, 
-            y: 2, 
-            z: 3 
-        }, [Box])
-    })
-})
\ No newline at end of file
diff --git a/spec/schema/regex.ts b/spec/schema/regex.ts
deleted file mode 100644
index af2d52311..000000000
--- a/spec/schema/regex.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe('RegEx', () => {
-
-    it('Should validate numeric value', () => {
-        const T = Type.RegEx(/[012345]/)
-        ok(T, '0')
-        ok(T, '1')
-        ok(T, '2')
-        ok(T, '3')
-        ok(T, '4')
-        ok(T, '5')
-    })
-
-    it('Should validate true or false string value', () => {
-        const T = Type.RegEx(/true|false/)
-        ok(T, 'true')
-        ok(T, 'true')
-        ok(T, 'true')
-        ok(T, 'false')
-        ok(T, 'false')
-        ok(T, 'false')
-        fail(T, '6')
-    })
-
-    it('Should not validate failed regex test', () => {
-        const T = Type.RegEx(/true|false/)
-        fail(T, 'unknown')
-    })
-})
diff --git a/spec/schema/required.ts b/spec/schema/required.ts
deleted file mode 100644
index 2b9eb8cd8..000000000
--- a/spec/schema/required.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import { Type, ReadonlyModifier, ReadonlyOptionalModifier, OptionalModifier } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-import { strictEqual } from 'assert'
-
-describe('Required', () => {
-
-    it('Should convert a partial object into a required object', () => {
-        const A = Type.Object({
-            x: Type.Optional(Type.Number()),
-            y: Type.Optional(Type.Number()),
-            z: Type.Optional(Type.Number())
-        }, { additionalProperties: false })
-        const T = Type.Required(A)
-        ok(T, { x: 1, y: 1, z: 1 })
-        fail(T, { x: 1, y: 1 })
-        fail(T, { x: 1 })
-        fail(T, {})
-    })
-
-    it('Should update modifier types correctly when converting to required', () => {
-        const A = Type.Object({
-            x: Type.ReadonlyOptional(Type.Number()),
-            y: Type.Readonly(Type.Number()),
-            z: Type.Optional(Type.Number()),
-            w: Type.Number()
-        })
-        const T = Type.Required(A)
-        strictEqual(T.properties.x.modifier, ReadonlyModifier)
-        strictEqual(T.properties.y.modifier, ReadonlyModifier)
-        strictEqual(T.properties.z.modifier, undefined)
-        strictEqual(T.properties.w.modifier, undefined)
-    })
-
-    it('Should inherit options from the source object', () => {
-        const A = Type.Object({
-            x: Type.Optional(Type.Number()),
-            y: Type.Optional(Type.Number()),
-            z: Type.Optional(Type.Number())
-        }, { additionalPropeties: false })
-        const T = Type.Required(A)
-        strictEqual(A.additionalPropeties, false)
-        strictEqual(T.additionalPropeties, false)
-    })
-
-    it('Should construct new object when targetting reference', () => {
-        const T = Type.Object({ a: Type.String(), b: Type.String() }, { $id: 'T' })
-        const R = Type.Ref(T)
-        const P = Type.Required(R)
-        strictEqual(P.properties.a.type, 'string')
-        strictEqual(P.properties.b.type, 'string')
-     })
-})
diff --git a/spec/schema/strict.ts b/spec/schema/strict.ts
deleted file mode 100644
index 4329cd079..000000000
--- a/spec/schema/strict.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe('Required', () => {
-
-    it('Should validate after applying strict', () => {
-        const A = Type.Object({
-            x: Type.Optional(Type.Number()),
-            y: Type.Optional(Type.Number()),
-            z: Type.Optional(Type.Number())
-        }, { additionalProperties: false })
-        const T = Type.Strict(Type.Required(A))
-        ok(T, { x: 1, y: 1, z: 1 })
-        fail(T, { x: 1, y: 1 })
-        fail(T, { x: 1 })
-        fail(T, {})
-    })
-
-    it('Should validate if applying $schema.', () => {
-        const A = Type.Object({
-            x: Type.Optional(Type.Number()),
-            y: Type.Optional(Type.Number()),
-            z: Type.Optional(Type.Number())
-        }, { additionalProperties: false })
-        const $schema = 'https://json-schema.org/draft/2019-09/schema'
-        const T = Type.Strict(Type.Required(A), { $schema })
-        ok(T, { x: 1, y: 1, z: 1 })
-        fail(T, { x: 1, y: 1 })
-        fail(T, { x: 1 })
-        fail(T, {})
-    })
-    
-})
diff --git a/spec/schema/string.ts b/spec/schema/string.ts
deleted file mode 100644
index c51bb1c2c..000000000
--- a/spec/schema/string.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe("String", () => {
-    it('Should not validate number', () => {
-        const T = Type.String()
-        fail(T, 1)
-    })
-    it('Should validate string', () => {
-        const T = Type.String()
-        ok(T, 'hello')
-    })
-    it('Should not validate boolean', () => {
-        const T = Type.String()
-        fail(T, true)
-    })
-    it('Should not validate array', () => {
-        const T = Type.String()
-        fail(T, [1, 2, 3])
-    })
-    it('Should not validate object', () => {
-        const T = Type.String()
-        fail(T, { a: 1, b: 2 })
-    })
-    it('Should not validate null', () => {
-        const T = Type.String()
-        fail(T, null)
-    })
-    it('Should not validate undefined', () => {
-        const T = Type.String()
-        fail(T, undefined)
-    })
-
-    it('Should validate string format as email', () => {
-        const T = Type.String({ format: 'email' })
-        ok(T, 'name@domain.com')
-    })
-
-    it('Should validate string format as uuid', () => {
-        const T = Type.String({ format: 'uuid' })
-        ok(T, '4a7a17c9-2492-4a53-8e13-06ea2d3f3bbf')
-    })
-
-    it('Should validate string format as iso8601 date', () => {
-        const T = Type.String({ format: 'date-time' })
-        ok(T, '2021-06-11T20:30:00-04:00')
-    })
-})
-
diff --git a/spec/schema/tuple.ts b/spec/schema/tuple.ts
deleted file mode 100644
index 659de6565..000000000
--- a/spec/schema/tuple.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { isRegExp } from 'util'
-import { ok, fail } from './validate'
-
-describe('Tuple', () => {
-
-    it('Should validate tuple of [string, number]', () => {
-        const A = Type.String()
-        const B = Type.Number()
-        const T = Type.Tuple([A, B])
-        ok(T, ['hello', 42])
-    })
-
-    it('Should not validate tuple of [string, number] when reversed', () => {
-        const A = Type.String()
-        const B = Type.Number()
-        const T = Type.Tuple([A, B])
-        fail(T, [42, 'hello'])
-    })
-
-    it('Should validate empty tuple []', () => {
-        const T = Type.Tuple([])
-        ok(T, [])
-    })
-    
-    it('Should not validate empty tuple [] with one or more elements', () => {
-        const T = Type.Tuple([])
-        fail(T, [1])
-    })
-
-    it('Should validate tuple of objects', () => {
-        const A = Type.Object({ a: Type.String() })
-        const B = Type.Object({ b: Type.Number() })
-        const T = Type.Tuple([A, B])
-        ok(T, [
-            { a: 'hello' },
-            { b: 42 },
-        ])
-    })
-
-    it('Should not validate tuple of objects when reversed', () => {
-        const A = Type.Object({ a: Type.String() })
-        const B = Type.Object({ b: Type.Number() })
-        const T = Type.Tuple([A, B])
-        fail(T, [
-            { b: 42 },
-            { a: 'hello' },
-        ])
-    })
-
-    it('Should not validate tuple when array is less than tuple length', () => {
-        const A = Type.Object({ a: Type.String() })
-        const B = Type.Object({ b: Type.Number() })
-        const T = Type.Tuple([A, B])
-        fail(T, [
-            { a: 'hello' },
-        ])
-    })
-
-    it('Should not validate tuple when array is greater than tuple length', () => {
-        const A = Type.Object({ a: Type.String() })
-        const B = Type.Object({ b: Type.Number() })
-        const T = Type.Tuple([A, B])
-        fail(T, [
-            { a: 'hello' },
-            { b: 42 },
-            { b: 42 },
-        ])
-    })
-})
diff --git a/spec/schema/union.ts b/spec/schema/union.ts
deleted file mode 100644
index 3d66dd9a0..000000000
--- a/spec/schema/union.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe('Union', () => {
-
-    it('Should validate union of string, number and boolean', () => {
-        const A = Type.String()
-        const B = Type.Number()
-        const C = Type.Boolean()
-        const T = Type.Union([A, B, C])
-        ok(T, 'hello')
-        ok(T, true)
-        ok(T, 42)
-    })
-
-    it('Should validate union of objects', () => {
-        const A = Type.Object({ a: Type.String() }, { additionalProperties: false })
-        const B = Type.Object({ b: Type.String() }, { additionalProperties: false })
-        const T = Type.Union([A, B])
-        ok(T, { a: 'hello' })
-        ok(T, { b: 'world' })
-    })
-
-    it('Should fail to validate for descriminated union types', () => {
-        const A = Type.Object({ kind: Type.Literal('A'), value: Type.String() })
-        const B = Type.Object({ kind: Type.Literal('B'), value: Type.Number() })
-        const T = Type.Union([A, B])
-        fail(T, { kind: 'A', value:  42 })     // expect { kind: 'A', value: string } 
-        fail(T, { kind: 'B', value: 'hello' }) // expect { kind: 'B', value: number } 
-    })
-
-    it('Should validate union of objects where properties overlap', () => {
-        const A = Type.Object({ a: Type.String() }, { additionalProperties: false })
-        const B = Type.Object({ a: Type.String(), b: Type.String() }, { additionalProperties: false })
-        const T = Type.Union([A, B])
-        ok(T, { a: 'hello' })             // A
-        ok(T, { a: 'hello', b: 'world' }) // B
-    })
-   
-
-    it('Should validate union of overlapping property of varying type', () => {
-        const A = Type.Object({ a: Type.String(), b: Type.Number() }, { additionalProperties: false })
-        const B = Type.Object({ a: Type.String(), b: Type.String() }, { additionalProperties: false })
-        const T = Type.Union([A, B])
-        ok(T, { a: 'hello', b: 42 })      // A
-        ok(T, { a: 'hello', b: 'world' }) // B
-    })
-
-    it('Should validate union of literal strings', () => {
-        const A = Type.Literal('hello')
-        const B = Type.Literal('world')
-        const T = Type.Union([A, B])
-        ok(T, 'hello') // A
-        ok(T, 'world') // B
-    })
-
-    it('Should not validate union of literal strings for unknown string', () => {
-        const A = Type.Literal('hello')
-        const B = Type.Literal('world')
-        const T = Type.Union([A, B])
-        fail(T, 'foo') // A
-        fail(T, 'bar') // B
-    })
-})
-
diff --git a/spec/schema/unknown.ts b/spec/schema/unknown.ts
deleted file mode 100644
index aea8b4035..000000000
--- a/spec/schema/unknown.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
-
-describe("Unknown", () => {
-    it('Should validate number', () => {
-        const T = Type.Any()
-        ok(T, 1)
-    })
-    it('Should validate string', () => {
-        const T = Type.Any()
-        ok(T, 'hello')
-    })
-    it('Should validate boolean', () => {
-        const T = Type.Any()
-        ok(T, true)
-    })
-    it('Should validate array', () => {
-        const T = Type.Any()
-        ok(T, [1, 2, 3])
-    })
-    it('Should validate object', () => {
-        const T = Type.Any()
-        ok(T, { a: 1, b: 2 })
-    })
-    it('Should validate null', () => {
-        const T = Type.Any()
-        ok(T, null)
-    })
-    it('Should validate undefined', () => {
-        const T = Type.Any()
-        ok(T, undefined)
-    })
-})
diff --git a/spec/schema/validate.ts b/spec/schema/validate.ts
deleted file mode 100644
index 50dd77f37..000000000
--- a/spec/schema/validate.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-import { TSchema } from '@sinclair/typebox'
-import addFormats from 'ajv-formats'
-import Ajv, {AnySchema} from 'ajv/dist/2019'
-
-export function validator(additional: AnySchema[]) {
-    return addFormats(new Ajv({}), [
-        'date-time',
-        'time',
-        'date',
-        'email',
-        'hostname',
-        'ipv4',
-        'ipv6',
-        'uri',
-        'uri-reference',
-        'uuid',
-        'uri-template',
-        'json-pointer',
-        'relative-json-pointer',
-        'regex'
-    ])
-        .addKeyword('kind')
-        .addKeyword('modifier')
-        .addSchema(additional)
-}
-
-
-export function ok<T extends TSchema>(type: T, data: unknown, additional: AnySchema[] = []) {
-    const ajv = validator(additional)
-    function execute() { // required as ajv will throw if referenced schema is not found
-        try { return ajv.validate(type, data) as boolean } catch { return false }
-    }
-    if (execute() === false) {
-        console.log('---------------------------')
-        console.log('type')
-        console.log('---------------------------')
-        console.log(JSON.stringify(type, null, 2))
-        console.log('---------------------------')
-        console.log('data')
-        console.log('---------------------------')
-        console.log(JSON.stringify(data, null, 2))
-        console.log('---------------------------')
-        console.log('errors')
-        console.log('---------------------------')
-        console.log(ajv.errorsText(ajv.errors))
-        throw Error('expected ok')
-    }
-}
-
-export function fail<T extends TSchema>(type: T, data: unknown, additional: AnySchema[] = []) {
-    const ajv = validator(additional)
-    function execute() { // required as ajv will throw if referenced schema is not found
-        try { return ajv.validate(type, data) as boolean } catch { return false }
-    }
-    if (execute() === true) {
-        console.log('---------------------------')
-        console.log('type')
-        console.log('---------------------------')
-        console.log(JSON.stringify(type, null, 2))
-        console.log('---------------------------')
-        console.log('data')
-        console.log('---------------------------')
-        console.log(JSON.stringify(data, null, 2))
-        console.log('---------------------------')
-        console.log('errors')
-        console.log('---------------------------')
-        console.log(ajv.errorsText(ajv.errors))
-        throw Error('expected ok')
-    }
-}
\ No newline at end of file
diff --git a/spec/types/any.ts b/spec/types/any.ts
deleted file mode 100644
index 00dcbbca0..000000000
--- a/spec/types/any.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-Spec.expectType<any>(Spec.infer(Type.Any()))
diff --git a/spec/types/array.ts b/spec/types/array.ts
deleted file mode 100644
index 20e21336b..000000000
--- a/spec/types/array.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-const T0 = Type.Array(Type.String())
-
-Spec.expectType<string[]>(Spec.infer(T0))
-
-const T1 = Type.Array(Type.Object({
-    x: Type.Number(),
-    y: Type.Boolean(),
-    z: Type.String()
-}))
-
-Spec.expectType<{x: number, y: boolean, z: string}[]>(Spec.infer(T1))
-
-const T2 = Type.Array(Type.Array(Type.String()))
-
-Spec.expectType<string[][]>(Spec.infer(T2))
-
-const T3 = Type.Array(Type.Tuple([Type.String(), Type.Number()]))
-
-Spec.expectType<[string, number][]>(Spec.infer(T3))
diff --git a/spec/types/boolean.ts b/spec/types/boolean.ts
deleted file mode 100644
index 5f468bae3..000000000
--- a/spec/types/boolean.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-Spec.expectType<boolean>(Spec.infer(Type.Boolean()))
diff --git a/spec/types/enum.ts b/spec/types/enum.ts
deleted file mode 100644
index cfeef50de..000000000
--- a/spec/types/enum.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-enum E { A, B = 'hello', C = 42 }
-
-const T = Type.Enum(E)
-
-Spec.expectType<E>(Spec.infer(T))
\ No newline at end of file
diff --git a/spec/types/intersect.ts b/spec/types/intersect.ts
deleted file mode 100644
index f3fc6f9fd..000000000
--- a/spec/types/intersect.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import * as Spec from './spec'
-import { Type, Static } from './typebox'
-
-{
-    const A = Type.String()
-    const B = Type.Number()
-    const T = Type.Intersect([A, B])
-    Spec.expectType<never>(Spec.infer(T))
-}
-{
-    const A = Type.Object({
-        A: Type.String(),
-        B: Type.String()
-    })
-    const B = Type.Object({
-        X: Type.Number(),
-        Y: Type.Number()
-    })
-    const T = Type.Intersect([A, B])
-    Spec.expectType<{
-        A: string, 
-        B: string
-    } & { 
-        X: number, 
-        Y: number
-    }>(Spec.infer(T))
-}
-{ // https://github.com/sinclairzx81/typebox/issues/113
-    const A = Type.Object({ A: Type.String() })
-    const B = Type.Object({ B: Type.String() })
-    const C = Type.Object({ C: Type.String() })
-    const T = Type.Intersect([A, Type.Union([B, C])])
-    type T = Static<typeof T> 
-    const _0: T = { A: '', B: '' }
-    const _1: T = { A: '', C: '' }
-    const _3: T = { A: '', B: '', C: '' }
-    Spec.expectType<{ A: string } & ({ B: string, } | { C: string })>(Spec.infer(T))
-}
diff --git a/spec/types/keyof.ts b/spec/types/keyof.ts
deleted file mode 100644
index b9a830ff3..000000000
--- a/spec/types/keyof.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-{
-    const K = Type.KeyOf(
-        Type.Object({
-            A: Type.Null(),
-            B: Type.Null(),
-            C: Type.Null(),
-        })
-    )
-
-    Spec.expectType<'A' | 'B' | 'C'>(Spec.infer(K))
-}
-
-{
-    const Q = Type.Pick(
-        Type.Object({
-            A: Type.Null(),
-            B: Type.Null(),
-            C: Type.Null(),
-        }), ['A', 'B']
-    )
-
-    const K = Type.KeyOf(
-        Type.Pick(
-            Type.Object({
-                A: Type.Null(),
-                B: Type.Null(),
-                C: Type.Null(),
-            }), ['A', 'B']
-        )
-    )
-    
-    Spec.expectType<'A' | 'B'>(Spec.infer(K))
-}
-
-{
-    const K = Type.KeyOf(
-        Type.Omit(
-            Type.Object({
-                A: Type.Null(),
-                B: Type.Null(),
-                C: Type.Null(),
-            }), ['A', 'B']
-        )
-    )
-    Spec.expectType<'C'>(Spec.infer(K))
-}
\ No newline at end of file
diff --git a/spec/types/literal.ts b/spec/types/literal.ts
deleted file mode 100644
index 982584675..000000000
--- a/spec/types/literal.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-Spec.expectType<'hello'>(Spec.infer(Type.Literal('hello')))
-
-Spec.expectType<true>(Spec.infer(Type.Literal(true)))
-
-Spec.expectType<42>(Spec.infer(Type.Literal(42)))
\ No newline at end of file
diff --git a/spec/types/modifier.ts b/spec/types/modifier.ts
deleted file mode 100644
index 4b1ae11fc..000000000
--- a/spec/types/modifier.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-// Asserts combinatory modifiers
-{
-    const T = Type.Object({
-        A: Type.ReadonlyOptional(Type.String()),
-        B: Type.Readonly(Type.String()),
-        C: Type.Optional(Type.String()),
-        D: Type.String()
-    })
-    Spec.expectType<{
-        readonly A?: string,
-        readonly B:  string,
-        C?:          string,
-        D:           string
-    }>(Spec.infer(T))
-}
\ No newline at end of file
diff --git a/spec/types/namespace.ts b/spec/types/namespace.ts
deleted file mode 100644
index 5e580ed82..000000000
--- a/spec/types/namespace.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-{
-    const T = Type.Namespace({
-        Vector2: Type.Object({
-            X: Type.Number(),
-            Y: Type.Number(),
-        })
-    }, { $id: 'Math' })
-
-    Spec.expectType<{
-        X: number,
-        Y: number
-    }>(Spec.infer(T['definitions']['Vector2']))
-}
\ No newline at end of file
diff --git a/spec/types/null.ts b/spec/types/null.ts
deleted file mode 100644
index e3a49fa0e..000000000
--- a/spec/types/null.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-Spec.expectType<null>(Spec.infer(Type.Null()))
diff --git a/spec/types/number.ts b/spec/types/number.ts
deleted file mode 100644
index 9c3a761b5..000000000
--- a/spec/types/number.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-Spec.expectType<number>(Spec.infer(Type.Number()))
-
diff --git a/spec/types/object.ts b/spec/types/object.ts
deleted file mode 100644
index 3b112a608..000000000
--- a/spec/types/object.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-{
-    const T = Type.Object({
-        A: Type.String(),
-        B: Type.String(),
-        C: Type.String()
-    })
-
-    Spec.expectType<{
-        A: string,
-        B: string,
-        C: string
-    }>(Spec.infer(T))
-}
-{
-    const T = Type.Object({
-        A: Type.Object({
-            A: Type.String(),
-            B: Type.String(),
-            C: Type.String()
-        }),
-        B: Type.Object({
-            A: Type.String(),
-            B: Type.String(),
-            C: Type.String()
-        }),
-        C: Type.Object({
-            A: Type.String(),
-            B: Type.String(),
-            C: Type.String()
-        })
-    })
-    Spec.expectType<{
-        A: {
-            A: string,
-            B: string,
-            C: string
-        },
-        B: {
-            A: string,
-            B: string,
-            C: string
-        },
-        C: {
-            A: string,
-            B: string,
-            C: string
-        }
-    }>(Spec.infer(T))
-}
-
-
diff --git a/spec/types/omit.ts b/spec/types/omit.ts
deleted file mode 100644
index 5614036b2..000000000
--- a/spec/types/omit.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-{
-    const T = Type.Omit(
-        Type.Object({
-            A: Type.String(),
-            B: Type.String(),
-            C: Type.String()
-        }),
-        ['C'])
-
-    Spec.expectType<{
-        A: string,
-        B: string
-    }>(Spec.infer(T))
-}
\ No newline at end of file
diff --git a/spec/types/optional.ts b/spec/types/optional.ts
deleted file mode 100644
index 1de0fd3c4..000000000
--- a/spec/types/optional.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-{
-    const T = Type.Object({
-        A: Type.Optional(Type.String())
-    })
-    Spec.expectType<{
-        A?: string
-    }>(Spec.infer(T))
-}
\ No newline at end of file
diff --git a/spec/types/partial.ts b/spec/types/partial.ts
deleted file mode 100644
index 63ee73fbc..000000000
--- a/spec/types/partial.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-{
-    const T = Type.Partial(
-        Type.Object({
-            A: Type.String(),
-            B: Type.String(),
-            C: Type.String()
-        }),
-    )
-
-    Spec.expectType<{
-        A?: string,
-        B?: string,
-        C?: string
-    }>(Spec.infer(T))
-}
\ No newline at end of file
diff --git a/spec/types/pick.ts b/spec/types/pick.ts
deleted file mode 100644
index 73c4ac527..000000000
--- a/spec/types/pick.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-{
-    const T = Type.Pick(
-        Type.Object({
-            A: Type.String(),
-            B: Type.String(),
-            C: Type.String()
-        }),
-        ['A', 'B'])
-
-    Spec.expectType<{
-        A: string,
-        B: string
-    }>(Spec.infer(T))
-}
\ No newline at end of file
diff --git a/spec/types/readonly-optional.ts b/spec/types/readonly-optional.ts
deleted file mode 100644
index 59b460adf..000000000
--- a/spec/types/readonly-optional.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-{
-    const T = Type.Object({
-        A: Type.ReadonlyOptional(Type.String())
-    })
-    Spec.expectType<{
-        readonly A?: string
-    }>(Spec.infer(T))
-}
\ No newline at end of file
diff --git a/spec/types/readonly.ts b/spec/types/readonly.ts
deleted file mode 100644
index 9b1ff7f24..000000000
--- a/spec/types/readonly.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-{
-    const T = Type.Object({
-        A: Type.Readonly(Type.String())
-    })
-
-    Spec.expectType<{
-        readonly A: string
-    }>(Spec.infer(T))
-}
\ No newline at end of file
diff --git a/spec/types/rec.ts b/spec/types/rec.ts
deleted file mode 100644
index 131c68049..000000000
--- a/spec/types/rec.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-{
-    const T = Type.Rec(Self => Type.Object({
-        id:    Type.String(),
-        nodes: Type.Array(Self)
-    }))
-
-    Spec.expectType<{
-        id: string,
-        nodes: { id: string, nodes: [] }[]
-    }>(Spec.infer(T))
-}
\ No newline at end of file
diff --git a/spec/types/record.ts b/spec/types/record.ts
deleted file mode 100644
index 0d02cd207..000000000
--- a/spec/types/record.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-{
-    // type K = string
-    const K = Type.String()
-
-    Spec.expectType<
-        Record<string, number>
-    >(Spec.infer(
-        Type.Record(K, Type.Number()))
-    )
-}
-{
-    // type K = string
-    const K = Type.RegEx(/foo|bar/)
-
-    Spec.expectType<
-        Record<string, number>
-    >(Spec.infer(
-        Type.Record(K, Type.Number()))
-    )
-}
-{
-    // type K = number
-    const K = Type.Number()
-
-    Spec.expectType<
-        Record<string, number>
-    >(Spec.infer(
-        Type.Record(K, Type.Number()))
-    )
-
-    Spec.expectType<
-        Record<number, number>
-    >(Spec.infer(
-        Type.Record(K, Type.Number()))
-    )
-}
-{
-    // type K = 'A' | 'B' | 'C'
-    const K = Type.Union([
-        Type.Literal('A'),
-        Type.Literal('B'),
-        Type.Literal('C')
-    ])
-
-    Spec.expectType<
-        Record<'A' | 'B' | 'C', number>
-    >(Spec.infer(
-        Type.Record(K, Type.Number()))
-    )
-}
-{
-    // type K = keyof { A: number, B: number, C: number }
-    const K = Type.KeyOf(
-        Type.Object({
-            A: Type.Number(),
-            B: Type.Number(),
-            C: Type.Number()
-        })
-    )
-    Spec.expectType<
-        Record<'A' | 'B' | 'C', number>
-    >(Spec.infer(
-        Type.Record(K, Type.Number()))
-    )
-}
-{
-    // type K = keyof Omit<{ A: number, B: number, C: number }, 'C'>
-    const K = Type.KeyOf(
-        Type.Omit(
-            Type.Object({
-                A: Type.Number(),
-                B: Type.Number(),
-                C: Type.Number()
-            }),
-            ['C']
-        )
-    )
-    Spec.expectType<
-        Record<'A' | 'B', number>
-    >(Spec.infer(
-        Type.Record(K, Type.Number()))
-    )
-}
\ No newline at end of file
diff --git a/spec/types/ref.ts b/spec/types/ref.ts
deleted file mode 100644
index 2089da146..000000000
--- a/spec/types/ref.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-{
-    const T = Type.String({ $id: 'T' })
-
-    const R = Type.Ref(T)
-
-    Spec.expectType<string>(Spec.infer(R))
-
-}
-{
-    const T = Type.Namespace({
-        Vector2: Type.Object({
-            X: Type.Number(),
-            Y: Type.Number(),
-        })
-    }, { $id: 'Math' })
-
-    const R = Type.Ref(T, 'Vector2')
-
-    Spec.expectType<{
-        X: number,
-        Y: number
-    }>(Spec.infer(R))
-}
\ No newline at end of file
diff --git a/spec/types/regex.ts b/spec/types/regex.ts
deleted file mode 100644
index 4bfabc9af..000000000
--- a/spec/types/regex.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-Spec.expectType<string>(Spec.infer(Type.RegEx(/foo/)))
diff --git a/spec/types/required.ts b/spec/types/required.ts
deleted file mode 100644
index f4f0dc5fe..000000000
--- a/spec/types/required.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import * as Spec from './spec'
-import { Type, Static } from './typebox'
-
-{
-    const T = Type.Required(
-        Type.Object({
-            A: Type.Optional(Type.String()),
-            B: Type.Optional(Type.String()),
-            C: Type.Optional(Type.String())
-        }),
-    )
-
-    Spec.expectType<{
-        A: string,
-        B: string,
-        C: string
-    }>(Spec.infer(T))
-}
\ No newline at end of file
diff --git a/spec/types/spec.ts b/spec/types/spec.ts
deleted file mode 100644
index 2f7f31bea..000000000
--- a/spec/types/spec.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { TSchema, Static } from './typebox'
-
-export const infer = <T extends TSchema>(_: T): Static<T> => null as any as Static<T>
-
-export * from 'tsd'
-
-
-
diff --git a/spec/types/strict.ts b/spec/types/strict.ts
deleted file mode 100644
index 24dba3044..000000000
--- a/spec/types/strict.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-{
-    const T = Type.Strict(Type.Object({
-        A: Type.String(),
-        B: Type.String(),
-        C: Type.String()
-    }))
-    
-    Spec.expectType<{
-        A: string,
-        B: string,
-        C: string
-    }>(Spec.infer(T))
-}
\ No newline at end of file
diff --git a/spec/types/string.ts b/spec/types/string.ts
deleted file mode 100644
index f4e8578bb..000000000
--- a/spec/types/string.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-Spec.expectType<string>(Spec.infer(Type.String()))
diff --git a/spec/types/tuple.ts b/spec/types/tuple.ts
deleted file mode 100644
index db323731d..000000000
--- a/spec/types/tuple.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-{
-    const T = Type.Tuple([
-        Type.Number(),
-        Type.String(),
-        Type.Boolean()
-    ])
-
-    Spec.expectType<[number, string, boolean]>(Spec.infer(T))
-}
diff --git a/spec/types/typebox.d.ts b/spec/types/typebox.d.ts
deleted file mode 100644
index 3eb849c20..000000000
--- a/spec/types/typebox.d.ts
+++ /dev/null
@@ -1,348 +0,0 @@
-export declare const ReadonlyOptionalModifier: unique symbol;
-export declare const OptionalModifier: unique symbol;
-export declare const ReadonlyModifier: unique symbol;
-export declare type TModifier = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>;
-export declare type TReadonlyOptional<T extends TSchema> = T & {
-    modifier: typeof ReadonlyOptionalModifier;
-};
-export declare type TOptional<T extends TSchema> = T & {
-    modifier: typeof OptionalModifier;
-};
-export declare type TReadonly<T extends TSchema> = T & {
-    modifier: typeof ReadonlyModifier;
-};
-export declare const BoxKind: unique symbol;
-export declare const KeyOfKind: unique symbol;
-export declare const IntersectKind: unique symbol;
-export declare const UnionKind: unique symbol;
-export declare const TupleKind: unique symbol;
-export declare const ObjectKind: unique symbol;
-export declare const RecordKind: unique symbol;
-export declare const ArrayKind: unique symbol;
-export declare const EnumKind: unique symbol;
-export declare const LiteralKind: unique symbol;
-export declare const StringKind: unique symbol;
-export declare const NumberKind: unique symbol;
-export declare const IntegerKind: unique symbol;
-export declare const BooleanKind: unique symbol;
-export declare const NullKind: unique symbol;
-export declare const UnknownKind: unique symbol;
-export declare const AnyKind: unique symbol;
-export declare const RefKind: unique symbol;
-export interface CustomOptions {
-    $id?: string;
-    title?: string;
-    description?: string;
-    default?: any;
-    examples?: any;
-    [prop: string]: any;
-}
-export declare type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex';
-export declare type StringOptions<TFormat extends string> = {
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    format?: TFormat;
-    contentEncoding?: '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64';
-    contentMediaType?: string;
-} & CustomOptions;
-export declare type ArrayOptions = {
-    uniqueItems?: boolean;
-    minItems?: number;
-    maxItems?: number;
-} & CustomOptions;
-export declare type NumberOptions = {
-    exclusiveMaximum?: number;
-    exclusiveMinimum?: number;
-    maximum?: number;
-    minimum?: number;
-    multipleOf?: number;
-} & CustomOptions;
-export declare type IntersectOptions = {
-    unevaluatedProperties?: boolean;
-} & CustomOptions;
-export declare type ObjectOptions = {
-    additionalProperties?: boolean;
-} & CustomOptions;
-export declare type TDefinitions = {
-    [key: string]: TSchema;
-};
-export declare type TNamespace<T extends TDefinitions> = {
-    kind: typeof BoxKind;
-    $defs: T;
-} & CustomOptions;
-export interface TSchema {
-    $static: unknown;
-}
-export declare type TEnumType = Record<string, string | number>;
-export declare type TKey = string | number | symbol;
-export declare type TValue = string | number | boolean;
-export declare type TRecordKey = TString | TNumber | TKeyOf<any> | TUnion<any>;
-export declare type TEnumKey<T = TKey> = {
-    type: 'number' | 'string';
-    const: T;
-};
-export interface TProperties {
-    [key: string]: TSchema;
-}
-export interface TRecord<K extends TRecordKey, T extends TSchema> extends TSchema, ObjectOptions {
-    $static: StaticRecord<K, T>;
-    kind: typeof RecordKind;
-    type: 'object';
-    patternProperties: {
-        [pattern: string]: T;
-    };
-}
-export interface TTuple<T extends TSchema[]> extends TSchema, CustomOptions {
-    $static: StaticTuple<T>;
-    kind: typeof TupleKind;
-    type: 'array';
-    items?: T;
-    additionalItems?: false;
-    minItems: number;
-    maxItems: number;
-}
-export interface TObject<T extends TProperties> extends TSchema, ObjectOptions {
-    $static: StaticObject<T>;
-    kind: typeof ObjectKind;
-    type: 'object';
-    properties: T;
-    required?: string[];
-}
-export interface TUnion<T extends TSchema[]> extends TSchema, CustomOptions {
-    $static: StaticUnion<T>;
-    kind: typeof UnionKind;
-    anyOf: T;
-}
-export interface TIntersect<T extends TSchema[]> extends TSchema, IntersectOptions {
-    $static: StaticIntersect<T>;
-    kind: typeof IntersectKind;
-    type: 'object';
-    allOf: T;
-}
-export interface TKeyOf<T extends TKey[]> extends TSchema, CustomOptions {
-    $static: StaticKeyOf<T>;
-    kind: typeof KeyOfKind;
-    type: 'string';
-    enum: T;
-}
-export interface TArray<T extends TSchema> extends TSchema, ArrayOptions {
-    $static: StaticArray<T>;
-    kind: typeof ArrayKind;
-    type: 'array';
-    items: T;
-}
-export interface TLiteral<T extends TValue> extends TSchema, CustomOptions {
-    $static: StaticLiteral<T>;
-    kind: typeof LiteralKind;
-    const: T;
-}
-export interface TEnum<T extends TEnumKey[]> extends TSchema, CustomOptions {
-    $static: StaticEnum<T>;
-    kind: typeof EnumKind;
-    anyOf: T;
-}
-export interface TRef<T extends TSchema> extends TSchema, CustomOptions {
-    $static: Static<T>;
-    kind: typeof RefKind;
-    $ref: string;
-}
-export interface TString extends TSchema, StringOptions<string> {
-    $static: string;
-    kind: typeof StringKind;
-    type: 'string';
-}
-export interface TNumber extends TSchema, NumberOptions {
-    $static: number;
-    kind: typeof NumberKind;
-    type: 'number';
-}
-export interface TInteger extends TSchema, NumberOptions {
-    $static: number;
-    kind: typeof IntegerKind;
-    type: 'integer';
-}
-export interface TBoolean extends TSchema, CustomOptions {
-    $static: boolean;
-    kind: typeof BooleanKind;
-    type: 'boolean';
-}
-export interface TNull extends TSchema, CustomOptions {
-    $static: null;
-    kind: typeof NullKind;
-    type: 'null';
-}
-export interface TUnknown extends TSchema, CustomOptions {
-    $static: unknown;
-    kind: typeof UnknownKind;
-}
-export interface TAny extends TSchema, CustomOptions {
-    $static: any;
-    kind: typeof AnyKind;
-}
-export declare const ConstructorKind: unique symbol;
-export declare const FunctionKind: unique symbol;
-export declare const PromiseKind: unique symbol;
-export declare const UndefinedKind: unique symbol;
-export declare const VoidKind: unique symbol;
-export interface TConstructor<T extends TSchema[], U extends TSchema> extends TSchema, CustomOptions {
-    $static: StaticConstructor<T, U>;
-    kind: typeof ConstructorKind;
-    type: 'constructor';
-    arguments: TSchema[];
-    returns: TSchema;
-}
-export interface TFunction<T extends TSchema[], U extends TSchema> extends TSchema, CustomOptions {
-    $static: StaticFunction<T, U>;
-    kind: typeof FunctionKind;
-    type: 'function';
-    arguments: TSchema[];
-    returns: TSchema;
-}
-export interface TPromise<T extends TSchema> extends TSchema, CustomOptions {
-    $static: StaticPromise<T>;
-    kind: typeof PromiseKind;
-    type: 'promise';
-    item: TSchema;
-}
-export interface TUndefined extends TSchema, CustomOptions {
-    $static: undefined;
-    kind: typeof UndefinedKind;
-    type: 'undefined';
-}
-export interface TVoid extends TSchema, CustomOptions {
-    $static: void;
-    kind: typeof VoidKind;
-    type: 'void';
-}
-export declare type Selectable = TObject<TProperties> | TRef<TObject<TProperties>>;
-export declare type SelectablePropertyKeys<T extends Selectable> = T extends TObject<infer U> ? keyof U : T extends TRef<TObject<infer U>> ? keyof U : never;
-export declare type SelectableProperties<T extends Selectable> = T extends TObject<infer U> ? U : T extends TRef<TObject<infer U>> ? U : never;
-export declare type UnionToIntersect<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-export declare type StaticReadonlyOptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never;
-}[keyof T];
-export declare type StaticReadonlyPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never;
-}[keyof T];
-export declare type StaticOptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TOptional<TSchema> ? K : never;
-}[keyof T];
-export declare type StaticRequiredPropertyKeys<T extends TProperties> = keyof Omit<T, StaticReadonlyOptionalPropertyKeys<T> | StaticReadonlyPropertyKeys<T> | StaticOptionalPropertyKeys<T>>;
-export declare type StaticIntersectEvaluate<T extends readonly TSchema[]> = {
-    [K in keyof T]: T[K] extends TSchema ? Static<T[K]> : never;
-};
-export declare type StaticIntersectReduce<I extends unknown, T extends readonly any[]> = T extends [infer A, ...infer B] ? StaticIntersectReduce<I & A, B> : I;
-export declare type StaticRequired<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonly<U> : T[K] extends TReadonly<infer U> ? TReadonly<U> : T[K] extends TOptional<infer U> ? U : T[K];
-};
-export declare type StaticPartial<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : T[K] extends TReadonly<infer U> ? TReadonlyOptional<U> : T[K] extends TOptional<infer U> ? TOptional<U> : TOptional<T[K]>;
-};
-export declare type StaticProperties<T extends TProperties> = {
-    readonly [K in StaticReadonlyOptionalPropertyKeys<T>]?: Static<T[K]>;
-} & {
-    readonly [K in StaticReadonlyPropertyKeys<T>]: Static<T[K]>;
-} & {
-    [K in StaticOptionalPropertyKeys<T>]?: Static<T[K]>;
-} & {
-    [K in StaticRequiredPropertyKeys<T>]: Static<T[K]>;
-};
-export declare type StaticRecord<K extends TRecordKey, T extends TSchema> = K extends TString ? Record<string, Static<T>> : K extends TNumber ? Record<number, Static<T>> : K extends TKeyOf<TKey[]> ? Record<K['$static'], Static<T>> : K extends TUnion<TSchema[]> ? Record<K['$static'], Static<T>> : never;
-export declare type StaticEnum<T> = T extends TEnumKey<infer U>[] ? U : never;
-export declare type StaticKeyOf<T extends TKey[]> = T extends Array<infer K> ? K : never;
-export declare type StaticIntersect<T extends readonly TSchema[]> = StaticIntersectReduce<unknown, StaticIntersectEvaluate<T>>;
-export declare type StaticUnion<T extends readonly TSchema[]> = {
-    [K in keyof T]: T[K] extends TSchema ? Static<T[K]> : never;
-}[number];
-export declare type StaticTuple<T extends readonly TSchema[]> = {
-    [K in keyof T]: T[K] extends TSchema ? Static<T[K]> : never;
-};
-export declare type StaticObject<T extends TProperties> = StaticProperties<T> extends infer I ? {
-    [K in keyof I]: I[K];
-} : never;
-export declare type StaticArray<T extends TSchema> = Array<Static<T>>;
-export declare type StaticLiteral<T extends TValue> = T;
-export declare type StaticParameters<T extends readonly TSchema[]> = {
-    [K in keyof T]: T[K] extends TSchema ? Static<T[K]> : never;
-};
-export declare type StaticConstructor<T extends readonly TSchema[], U extends TSchema> = new (...args: [...StaticParameters<T>]) => Static<U>;
-export declare type StaticFunction<T extends readonly TSchema[], U extends TSchema> = (...args: [...StaticParameters<T>]) => Static<U>;
-export declare type StaticPromise<T extends TSchema> = Promise<Static<T>>;
-export declare type Static<T extends TSchema> = T['$static'];
-export declare class TypeBuilder {
-    protected readonly schemas: Map<string, TSchema>;
-    /** `Standard` Modifies an object property to be both readonly and optional */
-    ReadonlyOptional<T extends TSchema>(item: T): TReadonlyOptional<T>;
-    /** `Standard` Modifies an object property to be readonly */
-    Readonly<T extends TSchema>(item: T): TReadonly<T>;
-    /** `Standard` Modifies an object property to be optional */
-    Optional<T extends TSchema>(item: T): TOptional<T>;
-    /** `Standard` Creates a type type */
-    Tuple<T extends TSchema[]>(items: [...T], options?: CustomOptions): TTuple<T>;
-    /** `Standard` Creates an object type with the given properties */
-    Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
-    /** `Standard` Creates an intersect type. */
-    Intersect<T extends TSchema[]>(items: [...T], options?: IntersectOptions): TIntersect<T>;
-    /** `Standard` Creates a union type */
-    Union<T extends TSchema[]>(items: [...T], options?: CustomOptions): TUnion<T>;
-    /** `Standard` Creates an array type */
-    Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T>;
-    /** `Standard` Creates an enum type from a TypeScript enum */
-    Enum<T extends TEnumType>(item: T, options?: CustomOptions): TEnum<TEnumKey<T[keyof T]>[]>;
-    /** `Standard` Creates a literal type. Supports string, number and boolean values only */
-    Literal<T extends TValue>(value: T, options?: CustomOptions): TLiteral<T>;
-    /** `Standard` Creates a string type */
-    String<TCustomFormatOption extends string>(options?: StringOptions<StringFormatOption | TCustomFormatOption>): TString;
-    /** `Standard` Creates a string type from a regular expression */
-    RegEx(regex: RegExp, options?: CustomOptions): TString;
-    /** `Standard` Creates a number type */
-    Number(options?: NumberOptions): TNumber;
-    /** `Standard` Creates an integer type */
-    Integer(options?: NumberOptions): TInteger;
-    /** `Standard` Creates a boolean type */
-    Boolean(options?: CustomOptions): TBoolean;
-    /** `Standard` Creates a null type */
-    Null(options?: CustomOptions): TNull;
-    /** `Standard` Creates an unknown type */
-    Unknown(options?: CustomOptions): TUnknown;
-    /** `Standard` Creates an any type */
-    Any(options?: CustomOptions): TAny;
-    /** `Standard` Creates a record type */
-    Record<K extends TRecordKey, T extends TSchema>(key: K, value: T, options?: ObjectOptions): TRecord<K, T>;
-    /** `Standard` Creates a keyof type from the given object */
-    KeyOf<T extends TObject<TProperties> | TRef<TObject<TProperties>>>(object: T, options?: CustomOptions): TKeyOf<SelectablePropertyKeys<T>[]>;
-    /** `Standard` Makes all properties in the given object type required */
-    Required<T extends TObject<TProperties> | TRef<TObject<TProperties>>>(object: T, options?: ObjectOptions): TObject<StaticRequired<T['properties']>>;
-    /** `Standard` Makes all properties in the given object type optional */
-    Partial<T extends TObject<TProperties> | TRef<TObject<TProperties>>>(object: T, options?: ObjectOptions): TObject<StaticPartial<T['properties']>>;
-    /** `Standard` Picks property keys from the given object type */
-    Pick<T extends TObject<TProperties> | TRef<TObject<TProperties>>, K extends SelectablePropertyKeys<T>[]>(object: T, keys: [...K], options?: ObjectOptions): TObject<Pick<SelectableProperties<T>, K[number]>>;
-    /** `Standard` Omits property keys from the given object type */
-    Omit<T extends TObject<TProperties> | TRef<TObject<TProperties>>, K extends SelectablePropertyKeys<T>[]>(object: T, keys: [...K], options?: ObjectOptions): TObject<Omit<SelectableProperties<T>, K[number]>>;
-    /** `Standard` Omits the `kind` and `modifier` properties from the underlying schema */
-    Strict<T extends TSchema>(schema: T, options?: CustomOptions): T;
-    /** `Extended` Creates a constructor type */
-    Constructor<T extends TSchema[], U extends TSchema>(args: [...T], returns: U, options?: CustomOptions): TConstructor<T, U>;
-    /** `Extended` Creates a function type */
-    Function<T extends TSchema[], U extends TSchema>(args: [...T], returns: U, options?: CustomOptions): TFunction<T, U>;
-    /** `Extended` Creates a promise type */
-    Promise<T extends TSchema>(item: T, options?: CustomOptions): TPromise<T>;
-    /** `Extended` Creates a undefined type */
-    Undefined(options?: CustomOptions): TUndefined;
-    /** `Extended` Creates a void type */
-    Void(options?: CustomOptions): TVoid;
-    /** `Standard` Creates a namespace for a set of related types */
-    Namespace<T extends TDefinitions>($defs: T, options?: CustomOptions): TNamespace<T>;
-    /** `Standard` References a type within a namespace. The referenced namespace must specify an `$id` */
-    Ref<T extends TNamespace<TDefinitions>, K extends keyof T['$defs']>(namespace: T, key: K): TRef<T['$defs'][K]>;
-    /** `Standard` References type. The referenced type must specify an `$id` */
-    Ref<T extends TSchema>(schema: T): TRef<T>;
-    /** `Experimental` Creates a recursive type */
-    Rec<T extends TSchema>(callback: (self: TAny) => T, options?: CustomOptions): T;
-    /** Conditionally stores and schema if it contains an $id and returns  */
-    protected Store<T extends TSchema | TNamespace<TDefinitions>, S = Omit<T, '$static'>>(schema: S): T;
-    /** Conditionally dereferences a schema if RefKind. Otherwise return argument */
-    protected Deref<T extends TSchema>(schema: T): any;
-}
-export declare const Type: TypeBuilder;
diff --git a/spec/types/union.ts b/spec/types/union.ts
deleted file mode 100644
index 892a25e74..000000000
--- a/spec/types/union.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-{
-    const A = Type.String()
-    const B = Type.Number()
-    const T = Type.Union([A, B])
-    Spec.expectType<string | number>(Spec.infer(T))
-}
-{
-    const A = Type.Object({
-        A: Type.String(),
-        B: Type.String()
-    })
-    const B = Type.Object({
-        X: Type.Number(),
-        Y: Type.Number()
-    })
-    const T = Type.Union([A, B])
-    Spec.expectType<{
-        A: string, 
-        B: string
-    } | { 
-        X: number, 
-        Y: number
-    }>(Spec.infer(T))
-}
-
diff --git a/spec/types/unknown.ts b/spec/types/unknown.ts
deleted file mode 100644
index 45a99a05e..000000000
--- a/spec/types/unknown.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import * as Spec from './spec'
-import { Type } from './typebox'
-
-Spec.expectType<unknown>(Spec.infer(Type.Unknown()))
\ No newline at end of file
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
new file mode 100644
index 000000000..716b0974b
--- /dev/null
+++ b/src/compiler/compiler.ts
@@ -0,0 +1,416 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/compiler
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { ValueErrors, ValueError } from '../errors/index'
+import { TypeGuard } from '../guard/index'
+import { Format } from '../format/index'
+import * as Types from '../typebox'
+
+// -------------------------------------------------------------------
+// CheckFunction
+// -------------------------------------------------------------------
+
+export type CheckFunction = (value: unknown) => boolean
+
+// -------------------------------------------------------------------
+// TypeCheck
+// -------------------------------------------------------------------
+
+export class TypeCheck<T extends Types.TSchema> {
+  constructor(private readonly schema: T, private readonly references: Types.TSchema[], private readonly checkFunc: CheckFunction, private readonly code: string) {}
+
+  /** Returns the generated validation code used to validate this type. */
+  public Code(): string {
+    return this.code
+  }
+
+  /** Returns an iterator for each error in this value. */
+  public Errors(value: unknown): IterableIterator<ValueError> {
+    return ValueErrors.Errors(this.schema, this.references, value)
+  }
+
+  /** Returns true if the value matches the given type. */
+  public Check(value: unknown): value is Types.Static<T> {
+    return this.checkFunc(value)
+  }
+}
+
+// -------------------------------------------------------------------
+// Property
+// -------------------------------------------------------------------
+
+export namespace Property {
+  function DollarSign(code: number) {
+    return code === 36
+  }
+  function Underscore(code: number) {
+    return code === 95
+  }
+  function Numeric(code: number) {
+    return code >= 48 && code <= 57
+  }
+  function Alpha(code: number) {
+    return (code >= 65 && code <= 90) || (code >= 97 && code <= 122)
+  }
+
+  export function Check(propertyName: string) {
+    if (propertyName.length === 0) return false
+    {
+      const code = propertyName.charCodeAt(0)
+      if (!(DollarSign(code) || Underscore(code) || Alpha(code))) {
+        return false
+      }
+    }
+    for (let i = 1; i < propertyName.length; i++) {
+      const code = propertyName.charCodeAt(i)
+      if (!(DollarSign(code) || Underscore(code) || Alpha(code) || Numeric(code))) {
+        return false
+      }
+    }
+    return true
+  }
+}
+
+// -------------------------------------------------------------------
+// TypeCompiler
+// -------------------------------------------------------------------
+
+export class TypeCompilerUnknownTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('TypeCompiler: Unknown type')
+  }
+}
+
+/** Compiles Types for Runtime Type Checking */
+export namespace TypeCompiler {
+  // -------------------------------------------------------------------
+  // Types
+  // -------------------------------------------------------------------
+
+  function* Any(schema: Types.TAny, value: string): IterableIterator<string> {
+    yield '(true)'
+  }
+
+  function* Array(schema: Types.TArray, value: string): IterableIterator<string> {
+    const expression = CreateExpression(schema.items, 'value')
+    if (schema.minItems !== undefined) yield `(${value}.length >= ${schema.minItems})`
+    if (schema.maxItems !== undefined) yield `(${value}.length <= ${schema.maxItems})`
+    if (schema.uniqueItems !== undefined) yield `(new Set(${value}).size === ${value}.length)`
+    yield `(Array.isArray(${value}) && ${value}.every(value => ${expression}))`
+  }
+
+  function* Boolean(schema: Types.TBoolean, value: string): IterableIterator<string> {
+    yield `(typeof ${value} === 'boolean')`
+  }
+
+  function* Constructor(schema: Types.TConstructor, value: string): IterableIterator<string> {
+    yield* Visit(schema.returns, `${value}.prototype`)
+  }
+
+  function* Function(schema: Types.TFunction, value: string): IterableIterator<string> {
+    yield `(typeof ${value} === 'function')`
+  }
+
+  function* Integer(schema: Types.TNumeric, value: string): IterableIterator<string> {
+    yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`
+    if (schema.multipleOf !== undefined) yield `(${value} % ${schema.multipleOf} === 0)`
+    if (schema.exclusiveMinimum !== undefined) yield `(${value} > ${schema.exclusiveMinimum})`
+    if (schema.exclusiveMaximum !== undefined) yield `(${value} < ${schema.exclusiveMaximum})`
+    if (schema.minimum !== undefined) yield `(${value} >= ${schema.minimum})`
+    if (schema.maximum !== undefined) yield `(${value} <= ${schema.maximum})`
+  }
+
+  function* Literal(schema: Types.TLiteral, value: string): IterableIterator<string> {
+    if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
+      yield `(${value} === ${schema.const})`
+    } else {
+      yield `(${value} === '${schema.const}')`
+    }
+  }
+
+  function* Never(schema: Types.TNull, value: string): IterableIterator<string> {
+    yield `(false)`
+  }
+
+  function* Null(schema: Types.TNull, value: string): IterableIterator<string> {
+    yield `(${value} === null)`
+  }
+
+  function* Number(schema: Types.TNumeric, value: string): IterableIterator<string> {
+    yield `(typeof ${value} === 'number')`
+    if (schema.multipleOf !== undefined) yield `(${value} % ${schema.multipleOf} === 0)`
+    if (schema.exclusiveMinimum !== undefined) yield `(${value} > ${schema.exclusiveMinimum})`
+    if (schema.exclusiveMaximum !== undefined) yield `(${value} < ${schema.exclusiveMaximum})`
+    if (schema.minimum !== undefined) yield `(${value} >= ${schema.minimum})`
+    if (schema.maximum !== undefined) yield `(${value} <= ${schema.maximum})`
+  }
+
+  function* Object(schema: Types.TObject, value: string): IterableIterator<string> {
+    yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`
+    if (schema.minProperties !== undefined) yield `(Object.keys(${value}).length >= ${schema.minProperties})`
+    if (schema.maxProperties !== undefined) yield `(Object.keys(${value}).length <= ${schema.maxProperties})`
+    const propertyKeys = globalThis.Object.keys(schema.properties)
+    if (schema.additionalProperties === false) {
+      // Optimization: If the property key length matches the required keys length
+      // then we only need check that the values property key length matches that
+      // of the property key length. This is because exhaustive testing for values
+      // will occur in subsequent property tests.
+      if (schema.required && schema.required.length === propertyKeys.length) {
+        yield `(Object.keys(${value}).length === ${propertyKeys.length})`
+      } else {
+        const keys = `[${propertyKeys.map((key) => `'${key}'`).join(', ')}]`
+        yield `(Object.keys(${value}).every(key => ${keys}.includes(key)))`
+      }
+    }
+    for (const propertyKey of propertyKeys) {
+      const memberExpression = Property.Check(propertyKey) ? `${value}.${propertyKey}` : `${value}['${propertyKey}']`
+      const propertySchema = schema.properties[propertyKey]
+      if (schema.required && schema.required.includes(propertyKey)) {
+        yield* Visit(propertySchema, memberExpression)
+      } else {
+        const expression = CreateExpression(propertySchema, memberExpression)
+        yield `(${memberExpression} === undefined ? true : (${expression}))`
+      }
+    }
+  }
+
+  function* Promise(schema: Types.TPromise<any>, value: string): IterableIterator<string> {
+    yield `(typeof value === 'object' && typeof ${value}.then === 'function')`
+  }
+
+  function* Record(schema: Types.TRecord<any, any>, value: string): IterableIterator<string> {
+    yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`
+    const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
+    const local = PushLocal(`new RegExp(/${keyPattern}/)`)
+    yield `(Object.keys(${value}).every(key => ${local}.test(key)))`
+    const expression = CreateExpression(valueSchema, 'value')
+    yield `(Object.values(${value}).every(value => ${expression}))`
+  }
+
+  function* Ref(schema: Types.TRef<any>, value: string): IterableIterator<string> {
+    // Reference: If we have seen this reference before we can just yield and return
+    // the function call. If this isn't the case we defer to visit to generate and
+    // set the function for subsequent passes. Consider for refactor.
+    if (names.has(schema.$ref)) return yield `(${CreateFunctionName(schema.$ref)}(${value}))`
+    if (!referenceMap.has(schema.$ref)) throw Error(`TypeCompiler.Ref: Cannot de-reference schema with $id '${schema.$ref}'`)
+    const reference = referenceMap.get(schema.$ref)!
+    yield* Visit(reference, value)
+  }
+
+  function* Self(schema: Types.TSelf, value: string): IterableIterator<string> {
+    const func = CreateFunctionName(schema.$ref)
+    yield `(${func}(${value}))`
+  }
+
+  function* String(schema: Types.TString, value: string): IterableIterator<string> {
+    yield `(typeof ${value} === 'string')`
+    if (schema.minLength !== undefined) {
+      yield `(${value}.length >= ${schema.minLength})`
+    }
+    if (schema.maxLength !== undefined) {
+      yield `(${value}.length <= ${schema.maxLength})`
+    }
+    if (schema.pattern !== undefined) {
+      const local = PushLocal(`new RegExp(/${schema.pattern}/);`)
+      yield `(${local}.test(${value}))`
+    }
+    if (schema.format !== undefined) {
+      yield `(format('${schema.format}', ${value}))`
+    }
+  }
+
+  function* Tuple(schema: Types.TTuple<any[]>, value: string): IterableIterator<string> {
+    yield `(Array.isArray(${value}))`
+    if (schema.items === undefined) return yield `(${value}.length === 0)`
+    yield `(${value}.length === ${schema.maxItems})`
+    for (let i = 0; i < schema.items.length; i++) {
+      const expression = CreateExpression(schema.items[i], `${value}[${i}]`)
+      yield `(${expression})`
+    }
+  }
+
+  function* Undefined(schema: Types.TUndefined, value: string): IterableIterator<string> {
+    yield `(${value} === undefined)`
+  }
+
+  function* Union(schema: Types.TUnion<any[]>, value: string): IterableIterator<string> {
+    const expressions = schema.anyOf.map((schema: Types.TSchema) => CreateExpression(schema, value))
+    yield `(${expressions.join(' || ')})`
+  }
+
+  function* Uint8Array(schema: Types.TUint8Array, value: string): IterableIterator<string> {
+    yield `(${value} instanceof Uint8Array)`
+    if (schema.maxByteLength) yield `(${value}.length <= ${schema.maxByteLength})`
+    if (schema.minByteLength) yield `(${value}.length >= ${schema.minByteLength})`
+  }
+
+  function* Unknown(schema: Types.TUnknown, value: string): IterableIterator<string> {
+    yield '(true)'
+  }
+
+  function* Void(schema: Types.TVoid, value: string): IterableIterator<string> {
+    yield `(${value} === null)`
+  }
+
+  function* Visit<T extends Types.TSchema>(schema: T, value: string): IterableIterator<string> {
+    // Reference: Referenced schemas can originate from either additional schemas
+    // or inline in the schema itself. Ideally the recursive path should align to
+    // reference path. Consider for refactor.
+    if (schema.$id && !names.has(schema.$id)) {
+      names.add(schema.$id)
+      const name = CreateFunctionName(schema.$id)
+      const body = CreateFunction(name, schema, 'value')
+      PushFunction(body)
+      yield `(${name}(${value}))`
+      return
+    }
+    const anySchema = schema as any
+    switch (anySchema[Types.Kind]) {
+      case 'Any':
+        return yield* Any(anySchema, value)
+      case 'Array':
+        return yield* Array(anySchema, value)
+      case 'Boolean':
+        return yield* Boolean(anySchema, value)
+      case 'Constructor':
+        return yield* Constructor(anySchema, value)
+      case 'Function':
+        return yield* Function(anySchema, value)
+      case 'Integer':
+        return yield* Integer(anySchema, value)
+      case 'Literal':
+        return yield* Literal(anySchema, value)
+      case 'Never':
+        return yield* Never(anySchema, value)
+      case 'Null':
+        return yield* Null(anySchema, value)
+      case 'Number':
+        return yield* Number(anySchema, value)
+      case 'Object':
+        return yield* Object(anySchema, value)
+      case 'Promise':
+        return yield* Promise(anySchema, value)
+      case 'Record':
+        return yield* Record(anySchema, value)
+      case 'Ref':
+        return yield* Ref(anySchema, value)
+      case 'Self':
+        return yield* Self(anySchema, value)
+      case 'String':
+        return yield* String(anySchema, value)
+      case 'Tuple':
+        return yield* Tuple(anySchema, value)
+      case 'Undefined':
+        return yield* Undefined(anySchema, value)
+      case 'Union':
+        return yield* Union(anySchema, value)
+      case 'Uint8Array':
+        return yield* Uint8Array(anySchema, value)
+      case 'Unknown':
+        return yield* Unknown(anySchema, value)
+      case 'Void':
+        return yield* Void(anySchema, value)
+      default:
+        throw new TypeCompilerUnknownTypeError(schema)
+    }
+  }
+
+  // -------------------------------------------------------------------
+  // Compile State
+  // -------------------------------------------------------------------
+
+  const referenceMap = new Map<string, Types.TSchema>()
+  const locals = new Set<string>() // local variables and functions
+  const names = new Set<string>() // cache of local functions
+
+  function ResetCompiler() {
+    referenceMap.clear()
+    locals.clear()
+    names.clear()
+  }
+
+  function AddReferences(schemas: Types.TSchema[] = []) {
+    for (const schema of schemas) {
+      if (!schema.$id) throw new Error(`TypeCompiler: Referenced schemas must specify an $id.`)
+      if (referenceMap.has(schema.$id)) throw new Error(`TypeCompiler: Duplicate schema $id found for '${schema.$id}'`)
+      referenceMap.set(schema.$id, schema)
+    }
+  }
+
+  function CreateExpression(schema: Types.TSchema, value: string): string {
+    return [...Visit(schema, value)].join(' && ')
+  }
+
+  function CreateFunctionName($id: string) {
+    return `check_${$id.replace(/-/g, '_')}`
+  }
+
+  function CreateFunction(name: string, schema: Types.TSchema, value: string): string {
+    const expression = [...Visit(schema, value)].map((condition) => `    ${condition}`).join(' &&\n')
+    return `function ${name}(value) {\n  return (\n${expression}\n )\n}`
+  }
+
+  function PushFunction(functionBody: string) {
+    locals.add(functionBody)
+  }
+
+  function PushLocal(expression: string) {
+    const local = `local_${locals.size}`
+    locals.add(`const ${local} = ${expression}`)
+    return local
+  }
+
+  function GetLocals() {
+    return [...locals.values()]
+  }
+
+  // -------------------------------------------------------------------
+  // Compile
+  // -------------------------------------------------------------------
+
+  function Build<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []): string {
+    ResetCompiler()
+    AddReferences(references)
+    const check = CreateFunction('check', schema, 'value')
+    const locals = GetLocals()
+    return `${locals.join('\n')}\nreturn ${check}`
+  }
+
+  /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
+  export function Compile<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []): TypeCheck<T> {
+    TypeGuard.Assert(schema, references)
+    const code = Build(schema, references)
+    const func1 = globalThis.Function('format', code)
+    const func2 = func1((format: string, value: string) => {
+      if (!Format.Has(format)) return false
+      const func = Format.Get(format)!
+      return func(value)
+    })
+    return new TypeCheck(schema, references, func2, code)
+  }
+}
diff --git a/src/compiler/index.ts b/src/compiler/index.ts
new file mode 100644
index 000000000..2785e30e6
--- /dev/null
+++ b/src/compiler/index.ts
@@ -0,0 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/compiler
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export { ValueError, ValueErrorType } from '../errors/index'
+export * from './compiler'
diff --git a/src/conditional/conditional.ts b/src/conditional/conditional.ts
new file mode 100644
index 000000000..dd3e71180
--- /dev/null
+++ b/src/conditional/conditional.ts
@@ -0,0 +1,114 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/conditional
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '../typebox'
+import { Structural, StructuralResult } from './structural'
+import { TypeGuard } from '../guard/index'
+
+// ------------------------------------------------------------------------
+// Extends
+// ------------------------------------------------------------------------
+
+export type TExtends<L extends Types.TSchema, R extends Types.TSchema, T extends Types.TSchema, U extends Types.TSchema> = Types.Static<L> extends Types.Static<R> ? T : U
+
+// ------------------------------------------------------------------------
+// Exclude
+// ------------------------------------------------------------------------
+
+export interface TExclude<T extends Types.TUnion, U extends Types.TUnion> extends Types.TUnion<any[]> {
+  static: Exclude<Types.Static<T, this['params']>, Types.Static<U, this['params']>>
+}
+
+// ------------------------------------------------------------------------
+// Extract
+// ------------------------------------------------------------------------
+
+export interface TExtract<T extends Types.TSchema, U extends Types.TUnion> extends Types.TUnion<any[]> {
+  static: Extract<Types.Static<T, this['params']>, Types.Static<U, this['params']>>
+}
+
+/** Conditional Types */
+export namespace Conditional {
+  /** (Experimental) Creates a conditional expression type */
+  export function Extends<L extends Types.TSchema, R extends Types.TSchema, T extends Types.TSchema, U extends Types.TSchema>(left: L, right: R, ok: T, fail: U): TExtends<L, R, T, U> {
+    switch (Structural.Check(left, right)) {
+      case StructuralResult.Union:
+        return Types.Type.Union([Clone(ok), Clone(fail)]) as any as TExtends<L, R, T, U>
+      case StructuralResult.True:
+        return Clone(ok)
+      case StructuralResult.False:
+        return Clone(fail)
+    }
+  }
+
+  /** (Experimental) Constructs a type by excluding from UnionType all union members that are assignable to ExcludedMembers. */
+  export function Exclude<T extends Types.TUnion, U extends Types.TUnion>(unionType: T, excludedMembers: U, options: Types.SchemaOptions = {}): TExclude<T, U> {
+    const anyOf = unionType.anyOf
+      .filter((schema) => {
+        const check = Structural.Check(schema, excludedMembers)
+        return !(check === StructuralResult.True || check === StructuralResult.Union)
+      })
+      .map((schema) => Clone(schema))
+    return { ...options, [Types.Kind]: 'Union', anyOf } as any
+  }
+
+  /** (Experimental) Constructs a type by extracting from Type all union members that are assignable to Union. */
+  export function Extract<T extends Types.TSchema, U extends Types.TUnion>(type: T, union: U, options: Types.SchemaOptions = {}): TExtract<T, U> {
+    if (TypeGuard.TUnion(type)) {
+      const anyOf = type.anyOf.filter((schema: Types.TSchema) => Structural.Check(schema, union) === StructuralResult.True).map((schema: Types.TSchema) => Clone(schema))
+      return { ...options, [Types.Kind]: 'Union', anyOf } as any
+    } else {
+      const anyOf = union.anyOf.filter((schema) => Structural.Check(type, schema) === StructuralResult.True).map((schema) => Clone(schema))
+      return { ...options, [Types.Kind]: 'Union', anyOf } as any
+    }
+  }
+
+  function Clone(value: any): any {
+    const isObject = (object: any): object is Record<string | symbol, any> => typeof object === 'object' && object !== null && !Array.isArray(object)
+    const isArray = (object: any): object is any[] => typeof object === 'object' && object !== null && Array.isArray(object)
+    if (isObject(value)) {
+      return Object.keys(value).reduce(
+        (acc, key) => ({
+          ...acc,
+          [key]: Clone(value[key]),
+        }),
+        Object.getOwnPropertySymbols(value).reduce(
+          (acc, key) => ({
+            ...acc,
+            [key]: Clone(value[key]),
+          }),
+          {},
+        ),
+      )
+    } else if (isArray(value)) {
+      return value.map((item: any) => Clone(item))
+    } else {
+      return value
+    }
+  }
+}
diff --git a/src/conditional/index.ts b/src/conditional/index.ts
new file mode 100644
index 000000000..93afa1daa
--- /dev/null
+++ b/src/conditional/index.ts
@@ -0,0 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/conditional
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './conditional'
+export * from './structural'
diff --git a/src/conditional/structural.ts b/src/conditional/structural.ts
new file mode 100644
index 000000000..18790d858
--- /dev/null
+++ b/src/conditional/structural.ts
@@ -0,0 +1,558 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/conditional
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '../typebox'
+import { TypeGuard } from '../guard'
+
+// --------------------------------------------------------------------------
+// StructuralResult
+// --------------------------------------------------------------------------
+
+export enum StructuralResult {
+  Union,
+  True,
+  False,
+}
+
+// --------------------------------------------------------------------------
+// Structural
+// --------------------------------------------------------------------------
+
+/** Performs structural equivalence checks against TypeBox types. */
+export namespace Structural {
+  const referenceMap = new Map<string, Types.TAnySchema>()
+
+  // ------------------------------------------------------------------------
+  // Rules
+  // ------------------------------------------------------------------------
+
+  function AnyOrUnknownRule(right: Types.TSchema) {
+    // https://github.com/microsoft/TypeScript/issues/40049
+    if (right[Types.Kind] === 'Union' && right.anyOf.some((schema: Types.TSchema) => schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown')) return true
+    if (right[Types.Kind] === 'Unknown') return true
+    if (right[Types.Kind] === 'Any') return true
+    return false
+  }
+
+  function ObjectRightRule(left: Types.TAnySchema, right: Types.TObject) {
+    // type A = boolean extends {}     ? 1 : 2 // additionalProperties: false
+    // type B = boolean extends object ? 1 : 2 // additionalProperties: true
+    const additionalProperties = right.additionalProperties
+    const propertyLength = globalThis.Object.keys(right.properties).length
+    return additionalProperties === false && propertyLength === 0
+  }
+
+  function UnionRightRule(left: Types.TAnySchema, right: Types.TUnion): StructuralResult {
+    const result = right.anyOf.some((right: Types.TSchema) => Visit(left, right) !== StructuralResult.False)
+    return result ? StructuralResult.True : StructuralResult.False
+  }
+
+  // ------------------------------------------------------------------------
+  // Records
+  // ------------------------------------------------------------------------
+
+  function RecordPattern(schema: Types.TRecord) {
+    return globalThis.Object.keys(schema.patternProperties)[0] as string
+  }
+
+  function RecordNumberOrStringKey(schema: Types.TRecord) {
+    const pattern = RecordPattern(schema)
+    return pattern === '^.*$' || pattern === '^(0|[1-9][0-9]*)$'
+  }
+
+  function RecordValue(schema: Types.TRecord) {
+    const pattern = RecordPattern(schema)
+    return schema.patternProperties[pattern]
+  }
+
+  function RecordKey(schema: Types.TRecord) {
+    const pattern = RecordPattern(schema)
+    if (pattern === '^.*$') {
+      return Types.Type.String()
+    } else if (pattern === '^(0|[1-9][0-9]*)$') {
+      return Types.Type.Number()
+    } else {
+      const keys = pattern.slice(1, pattern.length - 1).split('|')
+      const schemas = keys.map((key) => (isNaN(+key) ? Types.Type.Literal(key) : Types.Type.Literal(parseFloat(key))))
+      return Types.Type.Union(schemas)
+    }
+  }
+
+  function PropertyMap(schema: Types.TObject | Types.TRecord) {
+    const comparable = new Map<string, Types.TSchema>()
+    if (TypeGuard.TRecord(schema)) {
+      const propertyPattern = RecordPattern(schema as Types.TRecord)
+      if (propertyPattern === '^.*$' || propertyPattern === '^(0|[1-9][0-9]*)$') throw Error('Cannot extract record properties without property constraints')
+      const propertySchema = schema.patternProperties[propertyPattern] as Types.TSchema
+      const propertyKeys = propertyPattern.slice(1, propertyPattern.length - 1).split('|')
+      propertyKeys.forEach((propertyKey) => {
+        comparable.set(propertyKey, propertySchema)
+      })
+    } else {
+      globalThis.Object.entries(schema.properties).forEach(([propertyKey, propertySchema]) => {
+        comparable.set(propertyKey, propertySchema as Types.TSchema)
+      })
+    }
+    return comparable
+  }
+
+  // ------------------------------------------------------------------------
+  // Indexable
+  // ------------------------------------------------------------------------
+
+  function Indexable<Left extends Types.TAnySchema, Right extends Types.TAnySchema>(left: Left, right: Types.TSchema): StructuralResult {
+    if (TypeGuard.TUnion(right)) {
+      return StructuralResult.False
+    } else {
+      return Visit(left, right)
+    }
+  }
+
+  // ------------------------------------------------------------------------
+  // Checks
+  // ------------------------------------------------------------------------
+
+  function Any(left: Types.TAny, right: Types.TSchema): StructuralResult {
+    return AnyOrUnknownRule(right) ? StructuralResult.True : StructuralResult.Union
+  }
+
+  function Array(left: Types.TArray, right: Types.TSchema): StructuralResult {
+    if (AnyOrUnknownRule(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TObject(right)) {
+      if (right.properties['length'] !== undefined && right.properties['length'][Types.Kind] === 'Number') return StructuralResult.True
+      if (globalThis.Object.keys(right.properties).length === 0) return StructuralResult.True
+      return StructuralResult.False
+    } else if (!TypeGuard.TArray(right)) {
+      return StructuralResult.False
+    } else if (left.items === undefined && right.items !== undefined) {
+      return StructuralResult.False
+    } else if (left.items !== undefined && right.items === undefined) {
+      return StructuralResult.False
+    } else if (left.items === undefined && right.items === undefined) {
+      return StructuralResult.False
+    } else {
+      const result = Visit(left.items, right.items) !== StructuralResult.False
+      return result ? StructuralResult.True : StructuralResult.False
+    }
+  }
+
+  function Boolean(left: Types.TBoolean, right: Types.TSchema): StructuralResult {
+    if (AnyOrUnknownRule(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TBoolean(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TUnion(right)) {
+      return UnionRightRule(left, right)
+    } else {
+      return StructuralResult.False
+    }
+  }
+
+  function Constructor(left: Types.TConstructor, right: Types.TSchema): StructuralResult {
+    if (AnyOrUnknownRule(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TObject(right) && globalThis.Object.keys(right.properties).length === 0) {
+      return StructuralResult.True
+    } else if (!TypeGuard.TConstructor(right)) {
+      return StructuralResult.False
+    } else if (right.parameters.length < left.parameters.length) {
+      return StructuralResult.False
+    } else {
+      if (Visit(left.returns, right.returns) === StructuralResult.False) {
+        return StructuralResult.False
+      }
+      for (let i = 0; i < left.parameters.length; i++) {
+        const result = Visit(right.parameters[i], left.parameters[i])
+        if (result === StructuralResult.False) return StructuralResult.False
+      }
+      return StructuralResult.True
+    }
+  }
+
+  function Function(left: Types.TFunction, right: Types.TSchema): StructuralResult {
+    if (AnyOrUnknownRule(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TObject(right)) {
+      if (right.properties['length'] !== undefined && right.properties['length'][Types.Kind] === 'Number') return StructuralResult.True
+      if (globalThis.Object.keys(right.properties).length === 0) return StructuralResult.True
+      return StructuralResult.False
+    } else if (!TypeGuard.TFunction(right)) {
+      return StructuralResult.False
+    } else if (right.parameters.length < left.parameters.length) {
+      return StructuralResult.False
+    } else if (Visit(left.returns, right.returns) === StructuralResult.False) {
+      return StructuralResult.False
+    } else {
+      for (let i = 0; i < left.parameters.length; i++) {
+        const result = Visit(right.parameters[i], left.parameters[i])
+        if (result === StructuralResult.False) return StructuralResult.False
+      }
+      return StructuralResult.True
+    }
+  }
+
+  function Integer(left: Types.TInteger, right: Types.TSchema): StructuralResult {
+    if (AnyOrUnknownRule(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TInteger(right) || TypeGuard.TNumber(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TUnion(right)) {
+      return UnionRightRule(left, right)
+    } else {
+      return StructuralResult.False
+    }
+  }
+
+  function Literal(left: Types.TLiteral, right: Types.TSchema): StructuralResult {
+    if (AnyOrUnknownRule(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TRecord(right)) {
+      if (typeof left.const === 'string') {
+        return Indexable(left, RecordValue(right as Types.TRecord))
+      } else {
+        return StructuralResult.False
+      }
+    } else if (TypeGuard.TLiteral(right) && left.const === right.const) {
+      return StructuralResult.True
+    } else if (TypeGuard.TString(right) && typeof left.const === 'string') {
+      return StructuralResult.True
+    } else if (TypeGuard.TNumber(right) && typeof left.const === 'number') {
+      return StructuralResult.True
+    } else if (TypeGuard.TInteger(right) && typeof left.const === 'number') {
+      return StructuralResult.True
+    } else if (TypeGuard.TBoolean(right) && typeof left.const === 'boolean') {
+      return StructuralResult.True
+    } else if (TypeGuard.TUnion(right)) {
+      return UnionRightRule(left, right)
+    } else {
+      return StructuralResult.False
+    }
+  }
+
+  function Number(left: Types.TNumber, right: Types.TSchema): StructuralResult {
+    if (AnyOrUnknownRule(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TNumber(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TInteger(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TUnion(right)) {
+      return UnionRightRule(left, right)
+    } else {
+      return StructuralResult.False
+    }
+  }
+
+  function Null(left: Types.TNull, right: Types.TSchema): StructuralResult {
+    if (AnyOrUnknownRule(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TNull(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TUnion(right)) {
+      return UnionRightRule(left, right)
+    } else {
+      return StructuralResult.False
+    }
+  }
+
+  function Properties(left: Map<string, Types.TSchema>, right: Map<string, Types.TSchema>) {
+    if (right.size > left.size) return StructuralResult.False
+    if (![...right.keys()].every((rightKey) => left.has(rightKey))) return StructuralResult.False
+    for (const rightKey of right.keys()) {
+      const leftProp = left.get(rightKey)!
+      const rightProp = right.get(rightKey)!
+      if (Visit(leftProp, rightProp) === StructuralResult.False) {
+        return StructuralResult.False
+      }
+    }
+    return StructuralResult.True
+  }
+
+  function Object(left: Types.TObject, right: Types.TAnySchema): StructuralResult {
+    if (AnyOrUnknownRule(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TObject(right)) {
+      return Properties(PropertyMap(left), PropertyMap(right))
+    } else if (TypeGuard.TRecord(right)) {
+      if (!RecordNumberOrStringKey(right as Types.TRecord)) {
+        return Properties(PropertyMap(left), PropertyMap(right))
+      } else {
+        return StructuralResult.True
+      }
+    } else {
+      return StructuralResult.False
+    }
+  }
+
+  function Promise(left: Types.TPromise, right: Types.TSchema): StructuralResult {
+    if (AnyOrUnknownRule(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TObject(right)) {
+      if (ObjectRightRule(left, right) || globalThis.Object.keys(right.properties).length === 0) {
+        return StructuralResult.True
+      } else {
+        return StructuralResult.False
+      }
+    } else if (!TypeGuard.TPromise(right)) {
+      return StructuralResult.False
+    } else {
+      const result = Visit(left.item, right.item) !== StructuralResult.False
+      return result ? StructuralResult.True : StructuralResult.False
+    }
+  }
+
+  function Record(left: Types.TRecord, right: Types.TSchema): StructuralResult {
+    if (AnyOrUnknownRule(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TObject(right)) {
+      if (RecordPattern(left) === '^.*$' && right[Types.Hint] === 'Record') {
+        return StructuralResult.True
+      } else if (RecordPattern(left) === '^.*$') {
+        return StructuralResult.False
+      } else {
+        return globalThis.Object.keys(right.properties).length === 0 ? StructuralResult.True : StructuralResult.False
+      }
+    } else if (TypeGuard.TRecord(right)) {
+      if (!RecordNumberOrStringKey(left as Types.TRecord) && !RecordNumberOrStringKey(right as Types.TRecord)) {
+        return Properties(PropertyMap(left), PropertyMap(right))
+      } else if (RecordNumberOrStringKey(left as Types.TRecord) && !RecordNumberOrStringKey(right as Types.TRecord)) {
+        const leftKey = RecordKey(left as Types.TRecord)
+        const rightKey = RecordKey(right as Types.TRecord)
+        if (Visit(rightKey, leftKey) === StructuralResult.False) {
+          return StructuralResult.False
+        } else {
+          return StructuralResult.True
+        }
+      } else {
+        return StructuralResult.True
+      }
+    } else {
+      return StructuralResult.False
+    }
+  }
+
+  function Ref(left: Types.TRef, right: Types.TSchema): StructuralResult {
+    if (!referenceMap.has(left.$ref)) throw Error(`Cannot locate referenced $id '${left.$ref}'`)
+    const resolved = referenceMap.get(left.$ref)!
+    return Visit(resolved, right)
+  }
+
+  function Self(left: Types.TSelf, right: Types.TSchema): StructuralResult {
+    if (!referenceMap.has(left.$ref)) throw Error(`Cannot locate referenced self $id '${left.$ref}'`)
+    const resolved = referenceMap.get(left.$ref)!
+    return Visit(resolved, right)
+  }
+
+  function String(left: Types.TString, right: Types.TSchema): StructuralResult {
+    if (AnyOrUnknownRule(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TRecord(right)) {
+      return Indexable(left, RecordValue(right))
+    } else if (TypeGuard.TString(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TUnion(right)) {
+      return UnionRightRule(left, right)
+    } else {
+      return StructuralResult.False
+    }
+  }
+
+  function Tuple(left: Types.TTuple, right: Types.TSchema): StructuralResult {
+    if (AnyOrUnknownRule(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TObject(right)) {
+      const result = ObjectRightRule(left, right) || globalThis.Object.keys(right.properties).length === 0
+      return result ? StructuralResult.True : StructuralResult.False
+    } else if (TypeGuard.TRecord(right)) {
+      return Indexable(left, RecordValue(right))
+    } else if (TypeGuard.TArray(right)) {
+      if (right.items === undefined) {
+        return StructuralResult.False
+      } else if (TypeGuard.TUnion(right.items) && left.items) {
+        const result = left.items.every((left: Types.TSchema) => UnionRightRule(left, right.items as Types.TUnion) !== StructuralResult.False)
+        return result ? StructuralResult.True : StructuralResult.False
+      } else if (TypeGuard.TAny(right.items)) {
+        return StructuralResult.True
+      } else {
+        return StructuralResult.False
+      }
+    }
+    if (!TypeGuard.TTuple(right)) return StructuralResult.False
+    if (left.items === undefined && right.items === undefined) return StructuralResult.True
+    if (left.items === undefined && right.items !== undefined) return StructuralResult.False
+    if (left.items !== undefined && right.items === undefined) return StructuralResult.False
+    if (left.items === undefined && right.items === undefined) return StructuralResult.True
+    if (left.minItems !== right.minItems || left.maxItems !== right.maxItems) return StructuralResult.False
+    for (let i = 0; i < left.items!.length; i++) {
+      if (Visit(left.items![i], right.items![i]) === StructuralResult.False) return StructuralResult.False
+    }
+    return StructuralResult.True
+  }
+
+  function Uint8Array(left: Types.TUint8Array, right: Types.TSchema): StructuralResult {
+    if (AnyOrUnknownRule(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TRecord(right)) {
+      return Indexable(left, RecordValue(right as Types.TRecord))
+    } else if (TypeGuard.TUint8Array(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TUnion(right)) {
+      return UnionRightRule(left, right)
+    } else {
+      return StructuralResult.False
+    }
+  }
+
+  function Undefined(left: Types.TUndefined, right: Types.TSchema): StructuralResult {
+    if (AnyOrUnknownRule(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TUndefined(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TVoid(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TUnion(right)) {
+      return UnionRightRule(left, right)
+    } else {
+      return StructuralResult.False
+    }
+  }
+
+  function Union(left: Types.TUnion, right: Types.TSchema): StructuralResult {
+    if (left.anyOf.some((left: Types.TSchema) => TypeGuard.TAny(left))) {
+      return StructuralResult.Union
+    } else if (TypeGuard.TUnion(right)) {
+      const result = left.anyOf.every((left: Types.TSchema) => right.anyOf.some((right: Types.TSchema) => Visit(left, right) !== StructuralResult.False))
+      return result ? StructuralResult.True : StructuralResult.False
+    } else {
+      const result = left.anyOf.every((left: Types.TSchema) => Visit(left, right) !== StructuralResult.False)
+      return result ? StructuralResult.True : StructuralResult.False
+    }
+  }
+
+  function Unknown(left: Types.TUnknown, right: Types.TSchema): StructuralResult {
+    if (TypeGuard.TUnion(right)) {
+      const result = right.anyOf.some((right: Types.TSchema) => TypeGuard.TAny(right) || TypeGuard.TUnknown(right))
+      return result ? StructuralResult.True : StructuralResult.False
+    } else if (TypeGuard.TAny(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TUnknown(right)) {
+      return StructuralResult.True
+    } else {
+      return StructuralResult.False
+    }
+  }
+
+  function Void(left: Types.TVoid, right: Types.TSchema): StructuralResult {
+    if (TypeGuard.TUnion(right)) {
+      const result = right.anyOf.some((right: Types.TSchema) => TypeGuard.TAny(right) || TypeGuard.TUnknown(right))
+      return result ? StructuralResult.True : StructuralResult.False
+    } else if (TypeGuard.TAny(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TUnknown(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TVoid(right)) {
+      return StructuralResult.True
+    } else {
+      return StructuralResult.False
+    }
+  }
+
+  let recursionDepth = 0
+  function Visit<Left extends Types.TAnySchema, Right extends Types.TAnySchema>(left: Left, right: Types.TSchema): StructuralResult {
+    recursionDepth += 1
+    if (recursionDepth >= 1000) return StructuralResult.True
+    if (left.$id !== undefined) referenceMap.set(left.$id!, left)
+    if (right.$id !== undefined) referenceMap.set(right.$id!, right)
+    const resolvedRight = right[Types.Kind] === 'Self' ? referenceMap.get(right.$ref)! : right
+    if (TypeGuard.TAny(left)) {
+      return Any(left, resolvedRight)
+    } else if (TypeGuard.TArray(left)) {
+      return Array(left, resolvedRight)
+    } else if (TypeGuard.TBoolean(left)) {
+      return Boolean(left, resolvedRight)
+    } else if (TypeGuard.TConstructor(left)) {
+      return Constructor(left, resolvedRight)
+    } else if (TypeGuard.TFunction(left)) {
+      return Function(left, resolvedRight)
+    } else if (TypeGuard.TInteger(left)) {
+      return Integer(left, resolvedRight)
+    } else if (TypeGuard.TLiteral(left)) {
+      return Literal(left, resolvedRight)
+    } else if (TypeGuard.TNull(left)) {
+      return Null(left, resolvedRight)
+    } else if (TypeGuard.TNumber(left)) {
+      return Number(left, resolvedRight)
+    } else if (TypeGuard.TObject(left)) {
+      return Object(left, resolvedRight)
+    } else if (TypeGuard.TPromise(left)) {
+      return Promise(left, resolvedRight)
+    } else if (TypeGuard.TRecord(left)) {
+      return Record(left, resolvedRight)
+    } else if (TypeGuard.TRef(left)) {
+      return Ref(left, resolvedRight)
+    } else if (TypeGuard.TSelf(left)) {
+      return Self(left, resolvedRight)
+    } else if (TypeGuard.TString(left)) {
+      return String(left, resolvedRight)
+    } else if (TypeGuard.TTuple(left)) {
+      return Tuple(left, resolvedRight)
+    } else if (TypeGuard.TUndefined(left)) {
+      return Undefined(left, resolvedRight)
+    } else if (TypeGuard.TUint8Array(left)) {
+      return Uint8Array(left, resolvedRight)
+    } else if (TypeGuard.TUnion(left)) {
+      return Union(left, resolvedRight)
+    } else if (TypeGuard.TUnknown(left)) {
+      return Unknown(left, resolvedRight)
+    } else if (TypeGuard.TVoid(left)) {
+      return Void(left, resolvedRight)
+    } else {
+      throw Error(`Structural: Unknown left operand '${left[Types.Kind]}'`)
+    }
+  }
+
+  /** Structurally tests if the left schema extends the right. */
+  export function Check(left: Types.TSchema, right: Types.TSchema): StructuralResult {
+    referenceMap.clear()
+    recursionDepth = 0
+    return Visit(left, right)
+  }
+}
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
new file mode 100644
index 000000000..e4dea5907
--- /dev/null
+++ b/src/errors/errors.ts
@@ -0,0 +1,411 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/errors
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '../typebox'
+import { Format } from '../format/index'
+
+// -------------------------------------------------------------------
+// ValueErrorType
+// -------------------------------------------------------------------
+
+export enum ValueErrorType {
+  Array,
+  ArrayMinItems,
+  ArrayMaxItems,
+  ArrayUniqueItems,
+  Boolean,
+  Function,
+  Integer,
+  IntegerMultipleOf,
+  IntegerExclusiveMinimum,
+  IntegerExclusiveMaximum,
+  IntegerMinimum,
+  IntegerMaximum,
+  Literal,
+  Never,
+  Null,
+  Number,
+  NumberMultipleOf,
+  NumberExclusiveMinimum,
+  NumberExclusiveMaximum,
+  NumberMinumum,
+  NumberMaximum,
+  Object,
+  ObjectMinProperties,
+  ObjectMaxProperties,
+  ObjectAdditionalProperties,
+  Promise,
+  RecordKeyNumeric,
+  RecordKeyString,
+  String,
+  StringMinLength,
+  StringMaxLength,
+  StringPattern,
+  StringFormatUnknown,
+  StringFormat,
+  TupleZeroLength,
+  TupleLength,
+  Undefined,
+  Union,
+  Uint8Array,
+  Uint8ArrayMinByteLength,
+  Uint8ArrayMaxByteLength,
+  Void,
+}
+
+// -------------------------------------------------------------------
+// ValueError
+// -------------------------------------------------------------------
+
+export interface ValueError {
+  type: ValueErrorType
+  schema: Types.TSchema
+  path: string
+  value: unknown
+  message: string
+}
+
+// -------------------------------------------------------------------
+// ValueErrors
+// -------------------------------------------------------------------
+
+export class ValueErrorsUnknownTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('ValueErrors: Unknown type')
+  }
+}
+
+export namespace ValueErrors {
+  function* Any(schema: Types.TAny, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {}
+
+  function* Array(schema: Types.TArray, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!globalThis.Array.isArray(value)) {
+      return yield { type: ValueErrorType.Array, schema, path, value, message: `Expected array` }
+    }
+    if (schema.minItems !== undefined && !(value.length >= schema.minItems)) {
+      yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be greater or equal to ${schema.minItems}` }
+    }
+    if (schema.maxItems !== undefined && !(value.length <= schema.maxItems)) {
+      yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` }
+    }
+    if (schema.uniqueItems === true && !(new Set(value).size === value.length)) {
+      yield { type: ValueErrorType.ArrayUniqueItems, schema, path, value, message: `Expected array elements to be unique` }
+    }
+    for (let i = 0; i < value.length; i++) {
+      yield* Visit(schema.items, references, `${path}/${i}`, value[i])
+    }
+  }
+
+  function* Boolean(schema: Types.TBoolean, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!(typeof value === 'boolean')) {
+      return yield { type: ValueErrorType.Boolean, schema, path, value, message: `Expected boolean` }
+    }
+  }
+
+  function* Constructor(schema: Types.TConstructor, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    yield* Visit(schema.returns, references, path, value.prototype)
+  }
+
+  function* Function(schema: Types.TFunction, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!(typeof value === 'function')) {
+      return yield { type: ValueErrorType.Function, schema, path, value, message: `Expected function` }
+    }
+  }
+
+  function* Integer(schema: Types.TNumeric, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!(typeof value === 'number')) {
+      return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` }
+    }
+    if (!globalThis.Number.isInteger(value)) {
+      yield { type: ValueErrorType.Integer, schema, path, value, message: `Expected integer` }
+    }
+    if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
+      yield { type: ValueErrorType.IntegerMultipleOf, schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` }
+    }
+    if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
+      yield { type: ValueErrorType.IntegerExclusiveMinimum, schema, path, value, message: `Expected integer to be greater than ${schema.exclusiveMinimum}` }
+    }
+    if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
+      yield { type: ValueErrorType.IntegerExclusiveMaximum, schema, path, value, message: `Expected integer to be less than ${schema.exclusiveMaximum}` }
+    }
+    if (schema.minimum && !(value >= schema.minimum)) {
+      yield { type: ValueErrorType.IntegerMinimum, schema, path, value, message: `Expected integer to be greater or equal to ${schema.minimum}` }
+    }
+    if (schema.maximum && !(value <= schema.maximum)) {
+      yield { type: ValueErrorType.IntegerMaximum, schema, path, value, message: `Expected integer to be less or equal to ${schema.maximum}` }
+    }
+  }
+
+  function* Literal(schema: Types.TLiteral, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!(value === schema.const)) {
+      const error = typeof schema.const === 'string' ? `'${schema.const}'` : schema.const
+      return yield { type: ValueErrorType.Literal, schema, path, value, message: `Expected ${error}` }
+    }
+  }
+
+  function* Never(schema: Types.TNever, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    yield { type: ValueErrorType.Never, schema, path, value, message: `Value cannot be validated` }
+  }
+
+  function* Null(schema: Types.TNull, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!(value === null)) {
+      return yield { type: ValueErrorType.Null, schema, path, value, message: `Expected null` }
+    }
+  }
+
+  function* Number(schema: Types.TNumeric, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!(typeof value === 'number')) {
+      return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` }
+    }
+    if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
+      yield { type: ValueErrorType.NumberMultipleOf, schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` }
+    }
+    if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
+      yield { type: ValueErrorType.NumberExclusiveMinimum, schema, path, value, message: `Expected number to be greater than ${schema.exclusiveMinimum}` }
+    }
+    if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
+      yield { type: ValueErrorType.NumberExclusiveMaximum, schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` }
+    }
+    if (schema.minimum && !(value >= schema.minimum)) {
+      yield { type: ValueErrorType.NumberMaximum, schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` }
+    }
+    if (schema.maximum && !(value <= schema.maximum)) {
+      yield { type: ValueErrorType.NumberMinumum, schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` }
+    }
+  }
+
+  function* Object(schema: Types.TObject, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+      return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
+    }
+    if (schema.minProperties !== undefined && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
+      yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` }
+    }
+    if (schema.maxProperties !== undefined && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
+      yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` }
+    }
+    const propertyKeys = globalThis.Object.keys(schema.properties)
+    if (schema.additionalProperties === false) {
+      for (const propKey of globalThis.Object.keys(value)) {
+        if (!propertyKeys.includes(propKey)) {
+          yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${propKey}`, value: value[propKey], message: 'Unexpected property' }
+        }
+      }
+    }
+    for (const propertyKey of propertyKeys) {
+      const propertySchema = schema.properties[propertyKey]
+      if (schema.required && schema.required.includes(propertyKey)) {
+        yield* Visit(propertySchema, references, `${path}/${propertyKey}`, value[propertyKey])
+      } else {
+        if (value[propertyKey] !== undefined) {
+          yield* Visit(propertySchema, references, `${path}/${propertyKey}`, value[propertyKey])
+        }
+      }
+    }
+  }
+
+  function* Promise(schema: Types.TPromise, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!(typeof value === 'object' && typeof value.then === 'function')) {
+      yield { type: ValueErrorType.Promise, schema, path, value, message: `Expected Promise` }
+    }
+  }
+
+  function* Record(schema: Types.TRecord, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+      return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
+    }
+    const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
+    const regex = new RegExp(keyPattern)
+    if (!globalThis.Object.keys(value).every((key) => regex.test(key))) {
+      const numeric = keyPattern === '^(0|[1-9][0-9]*)$'
+      const type = numeric ? ValueErrorType.RecordKeyNumeric : ValueErrorType.RecordKeyString
+      const message = numeric ? 'Expected all object property keys to be numeric' : 'Expected all object property keys to be strings'
+      return yield { type, schema, path, value, message }
+    }
+    for (const [propKey, propValue] of globalThis.Object.entries(value)) {
+      yield* Visit(valueSchema, references, `${path}/${propKey}`, propValue)
+    }
+  }
+
+  function* Ref(schema: Types.TRef<any>, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    const reference = references.find((reference) => reference.$id === schema.$ref)
+    if (reference === undefined) throw new Error(`ValueErrors.Ref: Cannot find schema with $id '${schema.$ref}'.`)
+    yield* Visit(reference, references, path, value)
+  }
+
+  function* Self(schema: Types.TSelf, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    const reference = references.find((reference) => reference.$id === schema.$ref)
+    if (reference === undefined) throw new Error(`ValueErrors.Self: Cannot find schema with $id '${schema.$ref}'.`)
+    yield* Visit(reference, references, path, value)
+  }
+
+  function* String(schema: Types.TString, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!(typeof value === 'string')) {
+      return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' }
+    }
+    if (schema.minLength !== undefined && !(value.length >= schema.minLength)) {
+      yield { type: ValueErrorType.StringMinLength, schema, path, value, message: `Expected string length greater or equal to ${schema.minLength}` }
+    }
+    if (schema.maxLength !== undefined && !(value.length <= schema.maxLength)) {
+      yield { type: ValueErrorType.StringMaxLength, schema, path, value, message: `Expected string length less or equal to ${schema.maxLength}` }
+    }
+    if (schema.pattern !== undefined) {
+      const regex = new RegExp(schema.pattern)
+      if (!regex.test(value)) {
+        yield { type: ValueErrorType.StringPattern, schema, path, value, message: `Expected string to match pattern ${schema.pattern}` }
+      }
+    }
+    if (schema.format !== undefined) {
+      if (!Format.Has(schema.format)) {
+        yield { type: ValueErrorType.StringFormatUnknown, schema, path, value, message: `Unknown string format '${schema.format}'` }
+      } else {
+        const format = Format.Get(schema.format)!
+        if (!format(value)) {
+          yield { type: ValueErrorType.StringFormat, schema, path, value, message: `Expected string to match format '${schema.format}'` }
+        }
+      }
+    }
+  }
+
+  function* Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!globalThis.Array.isArray(value)) {
+      return yield { type: ValueErrorType.Array, schema, path, value, message: 'Expected Array' }
+    }
+    if (schema.items === undefined && !(value.length === 0)) {
+      return yield { type: ValueErrorType.TupleZeroLength, schema, path, value, message: 'Expected tuple to have 0 elements' }
+    }
+    if (!(value.length === schema.maxItems)) {
+      yield { type: ValueErrorType.TupleLength, schema, path, value, message: `Expected tuple to have ${schema.maxItems} elements` }
+    }
+    if (!schema.items) {
+      return
+    }
+    for (let i = 0; i < schema.items.length; i++) {
+      yield* Visit(schema.items[i], references, `${path}/${i}`, value[i])
+    }
+  }
+
+  function* Undefined(schema: Types.TUndefined, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!(value === undefined)) {
+      yield { type: ValueErrorType.Undefined, schema, path, value, message: `Expected undefined` }
+    }
+  }
+
+  function* Union(schema: Types.TUnion, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    const errors: ValueError[] = []
+    for (const inner of schema.anyOf) {
+      const variantErrors = [...Visit(inner, references, path, value)]
+      if (variantErrors.length === 0) return
+      errors.push(...variantErrors)
+    }
+    for (const error of errors) {
+      yield error
+    }
+    if (errors.length > 0) {
+      yield { type: ValueErrorType.Union, schema, path, value, message: 'Expected value of union' }
+    }
+  }
+
+  function* Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!(value instanceof globalThis.Uint8Array)) {
+      return yield { type: ValueErrorType.Uint8Array, schema, path, value, message: `Expected Uint8Array` }
+    }
+
+    if (schema.maxByteLength && !(value.length <= schema.maxByteLength)) {
+      yield { type: ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length less or equal to ${schema.maxByteLength}` }
+    }
+    if (schema.minByteLength && !(value.length >= schema.minByteLength)) {
+      yield { type: ValueErrorType.Uint8ArrayMinByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length greater or equal to ${schema.maxByteLength}` }
+    }
+  }
+
+  function* Unknown(schema: Types.TUnknown, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {}
+
+  function* Void(schema: Types.TVoid, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!(value === null)) {
+      return yield { type: ValueErrorType.Void, schema, path, value, message: `Expected null` }
+    }
+  }
+
+  function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    const anyReferences = schema.$id === undefined ? references : [schema, ...references]
+    const anySchema = schema as any
+    switch (anySchema[Types.Kind]) {
+      case 'Any':
+        return yield* Any(anySchema, anyReferences, path, value)
+      case 'Array':
+        return yield* Array(anySchema, anyReferences, path, value)
+      case 'Boolean':
+        return yield* Boolean(anySchema, anyReferences, path, value)
+      case 'Constructor':
+        return yield* Constructor(anySchema, anyReferences, path, value)
+      case 'Function':
+        return yield* Function(anySchema, anyReferences, path, value)
+      case 'Integer':
+        return yield* Integer(anySchema, anyReferences, path, value)
+      case 'Literal':
+        return yield* Literal(anySchema, anyReferences, path, value)
+      case 'Never':
+        return yield* Never(anySchema, anyReferences, path, value)
+      case 'Null':
+        return yield* Null(anySchema, anyReferences, path, value)
+      case 'Number':
+        return yield* Number(anySchema, anyReferences, path, value)
+      case 'Object':
+        return yield* Object(anySchema, anyReferences, path, value)
+      case 'Promise':
+        return yield* Promise(anySchema, anyReferences, path, value)
+      case 'Record':
+        return yield* Record(anySchema, anyReferences, path, value)
+      case 'Ref':
+        return yield* Ref(anySchema, anyReferences, path, value)
+      case 'Self':
+        return yield* Self(anySchema, anyReferences, path, value)
+      case 'String':
+        return yield* String(anySchema, anyReferences, path, value)
+      case 'Tuple':
+        return yield* Tuple(anySchema, anyReferences, path, value)
+      case 'Undefined':
+        return yield* Undefined(anySchema, anyReferences, path, value)
+      case 'Union':
+        return yield* Union(anySchema, anyReferences, path, value)
+      case 'Uint8Array':
+        return yield* Uint8Array(anySchema, anyReferences, path, value)
+      case 'Unknown':
+        return yield* Unknown(anySchema, anyReferences, path, value)
+      case 'Void':
+        return yield* Void(anySchema, anyReferences, path, value)
+      default:
+        throw new ValueErrorsUnknownTypeError(schema)
+    }
+  }
+
+  export function* Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): IterableIterator<ValueError> {
+    yield* Visit(schema, references, '', value)
+  }
+}
diff --git a/src/errors/index.ts b/src/errors/index.ts
new file mode 100644
index 000000000..eae491eeb
--- /dev/null
+++ b/src/errors/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/errors
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './errors'
diff --git a/src/format/format.ts b/src/format/format.ts
new file mode 100644
index 000000000..3dc6de9f4
--- /dev/null
+++ b/src/format/format.ts
@@ -0,0 +1,54 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/format
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export type FormatValidationFunction = (value: string) => boolean
+
+/** Shared string formats used by the TypeCompiler and Value modules */
+export namespace Format {
+  const formats = new Map<string, FormatValidationFunction>()
+
+  /** Clears all formats */
+  export function Clear() {
+    return formats.clear()
+  }
+
+  /** Returns true if the string format exists */
+  export function Has(format: string) {
+    return formats.has(format)
+  }
+
+  /** Sets a string format validation function */
+  export function Set(format: string, func: FormatValidationFunction) {
+    formats.set(format, func)
+  }
+
+  /** Gets a string format validation function */
+  export function Get(format: string) {
+    return formats.get(format)
+  }
+}
diff --git a/src/format/index.ts b/src/format/index.ts
new file mode 100644
index 000000000..f3153aa36
--- /dev/null
+++ b/src/format/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/format
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './format'
diff --git a/src/guard/guard.ts b/src/guard/guard.ts
new file mode 100644
index 000000000..01b653566
--- /dev/null
+++ b/src/guard/guard.ts
@@ -0,0 +1,362 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/guard
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, dTribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '../typebox'
+
+export class TypeGuardInvalidTypeError extends Error {
+  constructor(public readonly schema: unknown) {
+    super('TypeGuard: Invalid type')
+  }
+}
+
+/** TypeGuard tests that values conform to a known TypeBox type specification */
+export namespace TypeGuard {
+  function IsObject(value: unknown): value is Record<string | symbol, any> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+  }
+
+  function IsArray(value: unknown): value is any[] {
+    return typeof value === 'object' && value !== null && Array.isArray(value)
+  }
+
+  function IsPattern(value: unknown): value is string {
+    try {
+      new RegExp(value as string)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  function IsControlCharacterFree(value: unknown): value is string {
+    if (typeof value !== 'string') return false
+    for (let i = 0; i < value.length; i++) {
+      const code = value.charCodeAt(i)
+      if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
+        return false
+      }
+    }
+    return true
+  }
+
+  function IsString(value: unknown): value is string {
+    return typeof value === 'string'
+  }
+
+  function IsNumber(value: unknown): value is number {
+    return typeof value === 'number'
+  }
+
+  function IsBoolean(value: unknown): value is boolean {
+    return typeof value === 'boolean'
+  }
+
+  function IsOptionalNumber(value: unknown): value is number | undefined {
+    return value === undefined || (value !== undefined && IsNumber(value))
+  }
+
+  function IsOptionalBoolean(value: unknown): value is boolean | undefined {
+    return value === undefined || (value !== undefined && IsBoolean(value))
+  }
+
+  function IsOptionalString(value: unknown): value is string | undefined {
+    return value === undefined || (value !== undefined && IsString(value))
+  }
+
+  function IsOptionalPattern(value: unknown): value is string | undefined {
+    return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value) && IsPattern(value))
+  }
+  function IsOptionalFormat(value: unknown): value is string | undefined {
+    return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value))
+  }
+  /** Returns true if the given schema is TAny */
+  export function TAny(schema: unknown): schema is Types.TAny {
+    return IsObject(schema) && schema[Types.Kind] === 'Any' && IsOptionalString(schema.$id)
+  }
+
+  /** Returns true if the given schema is TArray */
+  export function TArray(schema: unknown): schema is Types.TArray {
+    return (
+      IsObject(schema) &&
+      schema[Types.Kind] === 'Array' &&
+      schema.type === 'array' &&
+      IsOptionalString(schema.$id) &&
+      TSchema(schema.items) &&
+      IsOptionalNumber(schema.minItems) &&
+      IsOptionalNumber(schema.maxItems) &&
+      IsOptionalBoolean(schema.uniqueItems)
+    )
+  }
+
+  /** Returns true if the given schema is TBoolean */
+  export function TBoolean(schema: unknown): schema is Types.TBoolean {
+    return IsObject(schema) && schema[Types.Kind] === 'Boolean' && schema.type === 'boolean' && IsOptionalString(schema.$id)
+  }
+
+  /** Returns true if the given schema is TConstructor */
+  export function TConstructor(schema: unknown): schema is Types.TConstructor {
+    if (!(IsObject(schema) && schema[Types.Kind] === 'Constructor' && schema.type === 'constructor' && IsOptionalString(schema.$id) && IsArray(schema.parameters) && TSchema(schema.returns))) {
+      return false
+    }
+    for (const parameter of schema.parameters) {
+      if (!TSchema(parameter)) return false
+    }
+    return true
+  }
+
+  /** Returns true if the given schema is TFunction */
+  export function TFunction(schema: unknown): schema is Types.TFunction {
+    if (!(IsObject(schema) && schema[Types.Kind] === 'Function' && schema.type === 'function' && IsOptionalString(schema.$id) && IsArray(schema.parameters) && TSchema(schema.returns))) {
+      return false
+    }
+    for (const parameter of schema.parameters) {
+      if (!TSchema(parameter)) return false
+    }
+    return true
+  }
+
+  /** Returns true if the given schema is TInteger */
+  export function TInteger(schema: unknown): schema is Types.TInteger {
+    return (
+      IsObject(schema) &&
+      schema[Types.Kind] === 'Integer' &&
+      schema.type === 'integer' &&
+      IsOptionalString(schema.$id) &&
+      IsOptionalNumber(schema.multipleOf) &&
+      IsOptionalNumber(schema.minimum) &&
+      IsOptionalNumber(schema.maximum) &&
+      IsOptionalNumber(schema.exclusiveMinimum) &&
+      IsOptionalNumber(schema.exclusiveMaximum)
+    )
+  }
+
+  /** Returns true if the given schema is TLiteral */
+  export function TLiteral(schema: unknown): schema is Types.TLiteral {
+    return IsObject(schema) && schema[Types.Kind] === 'Literal' && IsOptionalString(schema.$id) && (IsString(schema.const) || IsNumber(schema.const) || IsBoolean(schema.const))
+  }
+
+  /** Returns true if the given schema is TNever */
+  export function TNever(schema: unknown): schema is Types.TNever {
+    return (
+      IsObject(schema) &&
+      schema[Types.Kind] === 'Never' &&
+      IsArray(schema.allOf) &&
+      schema.allOf.length === 2 &&
+      IsObject(schema.allOf[0]) &&
+      IsString(schema.allOf[0].type) &&
+      schema.allOf[0].type === 'boolean' &&
+      schema.allOf[0].const === false &&
+      IsObject(schema.allOf[1]) &&
+      IsString(schema.allOf[1].type) &&
+      schema.allOf[1].type === 'boolean' &&
+      schema.allOf[1].const === true
+    )
+  }
+
+  /** Returns true if the given schema is TNull */
+  export function TNull(schema: unknown): schema is Types.TNull {
+    return IsObject(schema) && schema[Types.Kind] === 'Null' && schema.type === 'null' && IsOptionalString(schema.$id)
+  }
+
+  /** Returns true if the given schema is TNumber */
+  export function TNumber(schema: unknown): schema is Types.TNumber {
+    return (
+      IsObject(schema) &&
+      schema[Types.Kind] === 'Number' &&
+      schema.type === 'number' &&
+      IsOptionalString(schema.$id) &&
+      IsOptionalNumber(schema.multipleOf) &&
+      IsOptionalNumber(schema.minimum) &&
+      IsOptionalNumber(schema.maximum) &&
+      IsOptionalNumber(schema.exclusiveMinimum) &&
+      IsOptionalNumber(schema.exclusiveMaximum)
+    )
+  }
+
+  /** Returns true if the given schema is TObject */
+  export function TObject(schema: unknown): schema is Types.TObject {
+    if (
+      !(
+        IsObject(schema) &&
+        schema[Types.Kind] === 'Object' &&
+        schema.type === 'object' &&
+        IsOptionalString(schema.$id) &&
+        IsObject(schema.properties) &&
+        IsOptionalBoolean(schema.additionalProperties) &&
+        IsOptionalNumber(schema.minProperties) &&
+        IsOptionalNumber(schema.maxProperties)
+      )
+    ) {
+      return false
+    }
+    for (const [key, value] of Object.entries(schema.properties)) {
+      if (!IsControlCharacterFree(key)) return false
+      if (!TSchema(value)) return false
+    }
+    return true
+  }
+
+  /** Returns true if the given schema is TPromise */
+  export function TPromise(schema: unknown): schema is Types.TPromise {
+    return IsObject(schema) && schema[Types.Kind] === 'Promise' && schema.type === 'promise' && IsOptionalString(schema.$id) && TSchema(schema.item)
+  }
+
+  /** Returns true if the given schema is TRecord */
+  export function TRecord(schema: unknown): schema is Types.TRecord {
+    if (!(IsObject(schema) && schema[Types.Kind] === 'Record' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.additionalProperties === false && IsObject(schema.patternProperties))) {
+      return false
+    }
+    const keys = Object.keys(schema.patternProperties)
+    if (keys.length !== 1) {
+      return false
+    }
+    if (!IsPattern(keys[0])) {
+      return false
+    }
+    if (!TSchema(schema.patternProperties[keys[0]])) {
+      return false
+    }
+    return true
+  }
+
+  /** Returns true if the given schema is TSelf */
+  export function TSelf(schema: unknown): schema is Types.TSelf {
+    return IsObject(schema) && schema[Types.Kind] === 'Self' && IsOptionalString(schema.$id) && IsString(schema.$ref)
+  }
+
+  /** Returns true if the given schema is TRef */
+  export function TRef(schema: unknown): schema is Types.TRef {
+    return IsObject(schema) && schema[Types.Kind] === 'Ref' && IsOptionalString(schema.$id) && IsString(schema.$ref)
+  }
+
+  /** Returns true if the given schema is TString */
+  export function TString(schema: unknown): schema is Types.TString {
+    return (
+      IsObject(schema) &&
+      schema[Types.Kind] === 'String' &&
+      schema.type === 'string' &&
+      IsOptionalString(schema.$id) &&
+      IsOptionalNumber(schema.minLength) &&
+      IsOptionalNumber(schema.maxLength) &&
+      IsOptionalPattern(schema.pattern) &&
+      IsOptionalFormat(schema.format)
+    )
+  }
+
+  /** Returns true if the given schema is TTuple */
+  export function TTuple(schema: unknown): schema is Types.TTuple {
+    if (!(IsObject(schema) && schema[Types.Kind] === 'Tuple' && schema.type === 'array' && IsOptionalString(schema.$id) && IsNumber(schema.minItems) && IsNumber(schema.maxItems) && schema.minItems === schema.maxItems)) {
+      return false
+    }
+    if (schema.items === undefined && schema.additionalItems === undefined && schema.minItems === 0) {
+      return true
+    }
+    if (!IsArray(schema.items)) {
+      return false
+    }
+    for (const inner of schema.items) {
+      if (!TSchema(inner)) return false
+    }
+    return true
+  }
+
+  /** Returns true if the given schema is TUndefined */
+  export function TUndefined(schema: unknown): schema is Types.TUndefined {
+    return IsObject(schema) && schema[Types.Kind] === 'Undefined' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.specialized === 'Undefined'
+  }
+
+  /** Returns true if the given schema is TUnion */
+  export function TUnion(schema: unknown): schema is Types.TUnion {
+    if (!(IsObject(schema) && schema[Types.Kind] === 'Union' && IsArray(schema.anyOf) && IsOptionalString(schema.$id))) {
+      return false
+    }
+    for (const inner of schema.anyOf) {
+      if (!TSchema(inner)) return false
+    }
+    return true
+  }
+
+  /** Returns true if the given schema is TUint8Array */
+  export function TUint8Array(schema: unknown): schema is Types.TUint8Array {
+    return (
+      IsObject(schema) &&
+      schema[Types.Kind] === 'Uint8Array' &&
+      schema.type === 'object' &&
+      IsOptionalString(schema.$id) &&
+      schema.specialized === 'Uint8Array' &&
+      IsOptionalNumber(schema.minByteLength) &&
+      IsOptionalNumber(schema.maxByteLength)
+    )
+  }
+
+  /** Returns true if the given schema is TUnknown */
+  export function TUnknown(schema: unknown): schema is Types.TUnknown {
+    return IsObject(schema) && schema[Types.Kind] === 'Unknown' && IsOptionalString(schema.$id)
+  }
+
+  /** Returns true if the given schema is TVoid */
+  export function TVoid(schema: unknown): schema is Types.TVoid {
+    return IsObject(schema) && schema[Types.Kind] === 'Void' && schema.type === 'null' && IsOptionalString(schema.$id)
+  }
+
+  /** Returns true if the given schema is TSchema */
+  export function TSchema(schema: unknown): schema is Types.TSchema {
+    return (
+      TAny(schema) ||
+      TArray(schema) ||
+      TBoolean(schema) ||
+      TConstructor(schema) ||
+      TFunction(schema) ||
+      TInteger(schema) ||
+      TLiteral(schema) ||
+      TNever(schema) ||
+      TNull(schema) ||
+      TNumber(schema) ||
+      TObject(schema) ||
+      TPromise(schema) ||
+      TRecord(schema) ||
+      TSelf(schema) ||
+      TRef(schema) ||
+      TString(schema) ||
+      TTuple(schema) ||
+      TUndefined(schema) ||
+      TUnion(schema) ||
+      TUint8Array(schema) ||
+      TUnknown(schema) ||
+      TVoid(schema)
+    )
+  }
+
+  /** Asserts if this schema and associated references are valid. */
+  export function Assert<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []) {
+    if (!TSchema(schema)) throw new TypeGuardInvalidTypeError(schema)
+    for (const schema of references) {
+      if (!TSchema(schema)) throw new TypeGuardInvalidTypeError(schema)
+    }
+  }
+}
diff --git a/src/guard/index.ts b/src/guard/index.ts
new file mode 100644
index 000000000..d39efe4ec
--- /dev/null
+++ b/src/guard/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/guards
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './guard'
diff --git a/src/tsconfig.json b/src/tsconfig.json
index 8440ad2e5..3bca8a311 100644
--- a/src/tsconfig.json
+++ b/src/tsconfig.json
@@ -1,14 +1,4 @@
 {
-  "compilerOptions": {
-    "strict": true,
-    "module": "CommonJS",
-    "target": "ESNext",
-    "moduleResolution": "node",
-    "lib": ["ESNext"],
-    "declaration": true,
-    "outDir": "../dist/",
-  },
-  "files": [
-    "typebox.ts"
-  ]
-}
\ No newline at end of file
+  "extends": "../tsconfig.json",
+  "files": ["compiler/index.ts", "conditional/index.ts", "format/index.ts", "guard/index.ts", "value/index.ts", "typebox.ts"]
+}
diff --git a/src/typebox.ts b/src/typebox.ts
index 4dd4864a1..0f6211749 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -1,10 +1,10 @@
 /*--------------------------------------------------------------------------
 
-TypeBox: JSON Schema Type Builder with Static Type Resolution for TypeScript
+@sinclair/typebox
 
 The MIT License (MIT)
 
-Copyright (c) 2021 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -26,501 +26,947 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+// --------------------------------------------------------------------------
+// Symbols
+// --------------------------------------------------------------------------
+
+export const Kind = Symbol.for('TypeBox.Kind')
+export const Hint = Symbol.for('TypeBox.Hint')
+export const Modifier = Symbol.for('TypeBox.Modifier')
+
 // --------------------------------------------------------------------------
 // Modifiers
 // --------------------------------------------------------------------------
 
-export const ReadonlyOptionalModifier            = Symbol('ReadonlyOptionalModifier')
-export const OptionalModifier                    = Symbol('OptionalModifier')
-export const ReadonlyModifier                    = Symbol('ReadonlyModifier')
+export type TModifier = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>
+export type TReadonly<T extends TSchema> = T & { [Modifier]: 'Readonly' }
+export type TOptional<T extends TSchema> = T & { [Modifier]: 'Optional' }
+export type TReadonlyOptional<T extends TSchema> = T & { [Modifier]: 'ReadonlyOptional' }
 
-export type TModifier                            = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>
-export type TReadonlyOptional<T extends TSchema> = T & { modifier: typeof ReadonlyOptionalModifier }
-export type TOptional<T extends TSchema>         = T & { modifier: typeof OptionalModifier }
-export type TReadonly<T extends TSchema>         = T & { modifier: typeof ReadonlyModifier }
+// --------------------------------------------------------------------------
+// Schema
+// --------------------------------------------------------------------------
+
+export interface SchemaOptions {
+  $schema?: string
+  /** Id for this schema */
+  $id?: string
+  /** Title of this schema */
+  title?: string
+  /** Description of this schema */
+  description?: string
+  /** Default value for this schema */
+  default?: any
+  /** Example values matching this schema. */
+  examples?: any
+  [prop: string]: any
+}
+
+export interface TSchema extends SchemaOptions {
+  [Kind]: string
+  [Hint]?: string
+  [Modifier]?: string
+  params: unknown[]
+  static: unknown
+}
 
 // --------------------------------------------------------------------------
-// Schema Standard
+// TAnySchema
 // --------------------------------------------------------------------------
 
-export const BoxKind       = Symbol('BoxKind')
-export const KeyOfKind     = Symbol('KeyOfKind')
-export const IntersectKind = Symbol('IntersectKind')
-export const UnionKind     = Symbol('UnionKind')
-export const TupleKind     = Symbol('TupleKind')
-export const ObjectKind    = Symbol('ObjectKind')
-export const RecordKind    = Symbol('RecordKind')
-export const ArrayKind     = Symbol('ArrayKind')
-export const EnumKind      = Symbol('EnumKind')
-export const LiteralKind   = Symbol('LiteralKind')
-export const StringKind    = Symbol('StringKind')
-export const NumberKind    = Symbol('NumberKind')
-export const IntegerKind   = Symbol('IntegerKind')
-export const BooleanKind   = Symbol('BooleanKind')
-export const NullKind      = Symbol('NullKind')
-export const UnknownKind   = Symbol('UnknownKind')
-export const AnyKind       = Symbol('AnyKind')
-export const RefKind       = Symbol('RefKind')
+export type TAnySchema =
+  | TSchema
+  | TAny
+  | TArray
+  | TBoolean
+  | TConstructor
+  | TEnum
+  | TFunction
+  | TInteger
+  | TLiteral
+  | TNull
+  | TNumber
+  | TObject
+  | TPromise
+  | TRecord
+  | TSelf
+  | TRef
+  | TString
+  | TTuple
+  | TUndefined
+  | TUnion
+  | TUint8Array
+  | TUnknown
+  | TVoid
 
 // --------------------------------------------------------------------------
-// Options
+// TNumeric
 // --------------------------------------------------------------------------
 
-export interface CustomOptions {
-    $id?: string
-    title?: string
-    description?: string
-    default?: any
-    examples?: any
-    [prop: string]: any
+export interface NumericOptions extends SchemaOptions {
+  exclusiveMaximum?: number
+  exclusiveMinimum?: number
+  maximum?: number
+  minimum?: number
+  multipleOf?: number
 }
 
-export type StringFormatOption =
-    | 'date-time'    | 'time'          | 'date'         | 'email'        | 'idn-email'     | 'hostname'
-    | 'idn-hostname' | 'ipv4'          | 'ipv6'         | 'uri'          | 'uri-reference' | 'iri'
-    | 'uuid'         | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer'
-    | 'regex'
+export type TNumeric = TInteger | TNumber
 
-export declare type StringOptions<TFormat extends string> = {
-    minLength?: number
-    maxLength?: number
-    pattern?: string
-    format?: TFormat
-    contentEncoding?: '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64'
-    contentMediaType?: string
-} & CustomOptions
-
-export type ArrayOptions = {
-    uniqueItems?: boolean
-    minItems?: number
-    maxItems?: number
-} & CustomOptions
-
-export type NumberOptions = {
-    exclusiveMaximum?: number
-    exclusiveMinimum?: number
-    maximum?: number
-    minimum?: number
-    multipleOf?: number
-} & CustomOptions
-
-export type IntersectOptions = {
-    unevaluatedProperties?: boolean
-} & CustomOptions
-
-export type ObjectOptions = {
-    additionalProperties?: boolean
-} & CustomOptions
-
-// --------------------------------------------------------------------------
-// Namespace
-// --------------------------------------------------------------------------
-
-export type TDefinitions                       = { [key: string]: TSchema }
-export type TNamespace<T extends TDefinitions> = { kind: typeof BoxKind, $defs: T } & CustomOptions
-
-// --------------------------------------------------------------------------
-// TSchema
-// --------------------------------------------------------------------------
-
-export interface TSchema { $static: unknown }
-
-// --------------------------------------------------------------------------
-// Standard Schema Types
-// --------------------------------------------------------------------------
-
-export type TEnumType          = Record<string, string | number>
-export type TKey               = string | number | symbol
-export type TValue             = string | number | boolean
-export type TRecordKey         = TString | TNumber | TKeyOf<any> | TUnion<any>
-export type TEnumKey<T = TKey> = { type: 'number' | 'string', const: T }
-
-export interface TProperties { [key: string]: TSchema }
-export interface TRecord    <K extends TRecordKey, T extends TSchema> extends TSchema, ObjectOptions         { $static: StaticRecord<K, T>, kind: typeof RecordKind,    type: 'object', patternProperties: { [pattern: string]: T } }
-export interface TTuple     <T extends TSchema[]>                     extends TSchema, CustomOptions         { $static: StaticTuple<T>,     kind: typeof TupleKind,     type: 'array', items?: T, additionalItems?: false, minItems: number, maxItems: number }
-export interface TObject    <T extends TProperties>                   extends TSchema, ObjectOptions         { $static: StaticObject<T>,    kind: typeof ObjectKind,    type: 'object', properties: T, required?: string[] } 
-export interface TUnion     <T extends TSchema[]>                     extends TSchema, CustomOptions         { $static: StaticUnion<T>,     kind: typeof UnionKind,     anyOf: T }
-export interface TIntersect <T extends TSchema[]>                     extends TSchema, IntersectOptions      { $static: StaticIntersect<T>, kind: typeof IntersectKind, type: 'object', allOf: T }
-export interface TKeyOf     <T extends TKey[]>                        extends TSchema, CustomOptions         { $static: StaticKeyOf<T>,     kind: typeof KeyOfKind,     type: 'string', enum: T }
-export interface TArray     <T extends TSchema>                       extends TSchema, ArrayOptions          { $static: StaticArray<T>,     kind: typeof ArrayKind,     type: 'array', items: T } 
-export interface TLiteral   <T extends TValue>                        extends TSchema, CustomOptions         { $static: StaticLiteral<T>,   kind: typeof LiteralKind,   const: T }
-export interface TEnum      <T extends TEnumKey[]>                    extends TSchema, CustomOptions         { $static: StaticEnum<T>,      kind: typeof EnumKind,      anyOf: T }
-export interface TRef       <T extends TSchema>                       extends TSchema, CustomOptions         { $static: Static<T>,          kind: typeof RefKind,       $ref: string  }
-export interface TString                                              extends TSchema, StringOptions<string> { $static: string,             kind: typeof StringKind,    type: 'string' }
-export interface TNumber                                              extends TSchema, NumberOptions         { $static: number,             kind: typeof NumberKind,    type: 'number' }
-export interface TInteger                                             extends TSchema, NumberOptions         { $static: number,             kind: typeof IntegerKind,   type: 'integer' } 
-export interface TBoolean                                             extends TSchema, CustomOptions         { $static: boolean,            kind: typeof BooleanKind,   type: 'boolean' } 
-export interface TNull                                                extends TSchema, CustomOptions         { $static: null,               kind: typeof NullKind,      type: 'null' }
-export interface TUnknown                                             extends TSchema, CustomOptions         { $static: unknown,            kind: typeof UnknownKind }
-export interface TAny                                                 extends TSchema, CustomOptions         { $static: any,                kind: typeof AnyKind }
+// --------------------------------------------------------------------------
+// Any
+// --------------------------------------------------------------------------
 
+export interface TAny extends TSchema {
+  [Kind]: 'Any'
+  static: any
+}
 
 // --------------------------------------------------------------------------
-// Extended Schema Types
+// Array
 // --------------------------------------------------------------------------
 
-export const ConstructorKind = Symbol('ConstructorKind')
-export const FunctionKind    = Symbol('FunctionKind')
-export const PromiseKind     = Symbol('PromiseKind')
-export const UndefinedKind   = Symbol('UndefinedKind')
-export const VoidKind        = Symbol('VoidKind')
-export interface TConstructor <T extends TSchema[], U extends TSchema> extends TSchema, CustomOptions { $static: StaticConstructor<T, U>, kind: typeof ConstructorKind, type: 'constructor', arguments: TSchema[], returns: TSchema }
-export interface TFunction    <T extends TSchema[], U extends TSchema> extends TSchema, CustomOptions { $static: StaticFunction<T, U>, kind: typeof FunctionKind, type: 'function', arguments: TSchema[], returns: TSchema }
-export interface TPromise     <T extends TSchema>                      extends TSchema, CustomOptions { $static: StaticPromise<T>, kind: typeof PromiseKind, type: 'promise', item: TSchema }
-export interface TUndefined                                            extends TSchema, CustomOptions { $static: undefined, kind: typeof UndefinedKind, type: 'undefined' }
-export interface TVoid                                                 extends TSchema, CustomOptions { $static: void, kind: typeof VoidKind, type: 'void' }
+export interface ArrayOptions extends SchemaOptions {
+  uniqueItems?: boolean
+  minItems?: number
+  maxItems?: number
+}
+
+export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
+  [Kind]: 'Array'
+  static: Array<Static<T, this['params']>>
+  type: 'array'
+  items: T
+}
 
 // --------------------------------------------------------------------------
-// Utility Types
+// Boolean
 // --------------------------------------------------------------------------
 
-export type Selectable = TObject<TProperties> | TRef<TObject<TProperties>>
-export type SelectablePropertyKeys             <T extends Selectable>          = T extends TObject<infer U> ? keyof U : T extends TRef<TObject<infer U>> ? keyof U : never
-export type SelectableProperties               <T extends Selectable>          = T extends TObject<infer U> ? U : T extends TRef<TObject<infer U>> ? U : never
-export type UnionToIntersect<U>                                                = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never
-export type StaticReadonlyOptionalPropertyKeys <T extends TProperties>         = { [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never }[keyof T]
-export type StaticReadonlyPropertyKeys         <T extends TProperties>         = { [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never }[keyof T]
-export type StaticOptionalPropertyKeys         <T extends TProperties>         = { [K in keyof T]: T[K] extends TOptional<TSchema> ? K : never }[keyof T]
-export type StaticRequiredPropertyKeys         <T extends TProperties>         = keyof Omit<T, StaticReadonlyOptionalPropertyKeys<T> | StaticReadonlyPropertyKeys<T> | StaticOptionalPropertyKeys<T>>
-export type StaticIntersectEvaluate            <T extends readonly TSchema[]>  = {[K in keyof T]: T[K] extends TSchema ? Static<T[K]> : never }
-export type StaticIntersectReduce<I extends unknown, T extends readonly any[]> = T extends [infer A, ...infer B] ? StaticIntersectReduce<I & A, B> : I
-export type StaticRequired<T extends TProperties> = {
-    [K in keyof T]: 
-        T[K] extends TReadonlyOptional<infer U> ? TReadonly<U> :  
-        T[K] extends TReadonly<infer U>         ? TReadonly<U> :
-        T[K] extends TOptional<infer U>         ? U :  
-        T[K]
+export interface TBoolean extends TSchema {
+  [Kind]: 'Boolean'
+  static: boolean
+  type: 'boolean'
 }
-export type StaticPartial<T extends TProperties> = {
-    [K in keyof T]:
-        T[K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> :  
-        T[K] extends TReadonly<infer U>         ? TReadonlyOptional<U> :
-        T[K] extends TOptional<infer U>         ? TOptional<U> :
-        TOptional<T[K]>
+
+// --------------------------------------------------------------------------
+// Constructor
+// --------------------------------------------------------------------------
+
+export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>
+
+export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns']
+
+export type StaticContructorParameters<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never }]
+
+export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'Constructor'
+  static: new (...param: StaticContructorParameters<T, this['params']>) => Static<U, this['params']>
+  type: 'constructor'
+  parameters: T
+  returns: U
 }
 
-// ------------------------------------------------------------------------
-// Static Schema
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+// Enum
+// --------------------------------------------------------------------------
 
-export type StaticProperties <T extends TProperties> =
-    { readonly [K in StaticReadonlyOptionalPropertyKeys<T>]?: Static<T[K]> } &
-    { readonly [K in StaticReadonlyPropertyKeys<T>]:          Static<T[K]> } &
-    {          [K in StaticOptionalPropertyKeys<T>]?:         Static<T[K]> } &
-    {          [K in StaticRequiredPropertyKeys<T>]:          Static<T[K]> }
-export type StaticRecord <K extends TRecordKey, T extends TSchema> = 
-    K extends TString           ? Record<string, Static<T>> : 
-    K extends TNumber           ? Record<number, Static<T>> : 
-    K extends TKeyOf<TKey[]>    ? Record<K['$static'], Static<T>> : 
-    K extends TUnion<TSchema[]> ? Record<K['$static'], Static<T>> :
-    never
-export type StaticEnum        <T>                                               = T extends TEnumKey<infer U>[] ? U : never
-export type StaticKeyOf       <T extends TKey[]>                                = T extends Array<infer K> ? K : never
-export type StaticIntersect   <T extends readonly TSchema[]>                    = StaticIntersectReduce<unknown, StaticIntersectEvaluate<T>>
-export type StaticUnion       <T extends readonly TSchema[]>                    = { [K in keyof T]: T[K] extends TSchema ? Static<T[K]> : never }[number]
-export type StaticTuple       <T extends readonly TSchema[]>                    = { [K in keyof T]: T[K] extends TSchema ? Static<T[K]> : never }
-export type StaticObject      <T extends TProperties>                           = StaticProperties<T> extends infer I ? {[K in keyof I]: I[K]}: never
-export type StaticArray       <T extends TSchema>                               = Array<Static<T>>
-export type StaticLiteral     <T extends TValue>                                = T
-export type StaticParameters  <T extends readonly TSchema[]>                    = {[K in keyof T]: T[K] extends TSchema ? Static<T[K]>: never }
-export type StaticConstructor <T extends readonly TSchema[], U extends TSchema> = new (...args: [...StaticParameters<T>]) => Static<U>
-export type StaticFunction    <T extends readonly TSchema[], U extends TSchema> = (...args: [...StaticParameters<T>]) => Static<U>
-export type StaticPromise     <T extends TSchema>                               = Promise<Static<T>>
-export type Static            <T extends TSchema>                               = T['$static']
-
-// --------------------------------------------------------------------------
-// Utility
-// --------------------------------------------------------------------------
-
-function isObject(object: any) {
-    return typeof object === 'object' && object !== null && !Array.isArray(object)
-}
-
-function isArray(object: any) {
-    return typeof object === 'object' && object !== null && Array.isArray(object)
-}
-
-function clone(object: any): any {
-    if(isObject(object)) return Object.keys(object).reduce<any>((acc, key) => ({...acc, [key]: clone(object[key]) }), {})
-    if(isArray(object)) return object.map((item: any) => clone(item))
-    return object
+export interface TEnumOption<T> {
+  type: 'number' | 'string'
+  const: T
+}
+
+export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
+  [Kind]: 'Union'
+  static: T[keyof T]
+  anyOf: TLiteral<string | number>[]
 }
 
 // --------------------------------------------------------------------------
-// TypeBuilder
+// Function
 // --------------------------------------------------------------------------
 
-export class TypeBuilder {
+export type TParameters<T extends TFunction> = TTuple<T['parameters']>
 
-    protected readonly schemas = new Map<string, TSchema>()
+export type TReturnType<T extends TFunction> = T['returns']
 
-    /** `Standard` Modifies an object property to be both readonly and optional */
-    public ReadonlyOptional<T extends TSchema>(item: T): TReadonlyOptional<T> {
-        return { ...item, modifier: ReadonlyOptionalModifier }
-    }
+export type StaticFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never }]
 
-    /** `Standard` Modifies an object property to be readonly */
-    public Readonly<T extends TSchema>(item: T): TReadonly<T> {
-        return { ...item, modifier: ReadonlyModifier }
-    }
+export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'Function'
+  static: (...param: StaticFunctionParameters<T, this['params']>) => Static<U, this['params']>
+  type: 'function'
+  parameters: T
+  returns: U
+}
 
-     /** `Standard` Modifies an object property to be optional */
-    public Optional<T extends TSchema>(item: T): TOptional<T> {
-        return { ...item, modifier: OptionalModifier }
-    }
+// --------------------------------------------------------------------------
+// Integer
+// --------------------------------------------------------------------------
 
-    /** `Standard` Creates a type type */
-    public Tuple<T extends TSchema[]>(items: [...T], options: CustomOptions = {}): TTuple<T> {
-        const additionalItems = false
-        const minItems = items.length
-        const maxItems = items.length
-        const schema = ((items.length > 0)
-            ? { ...options, kind: TupleKind, type: 'array', items, additionalItems, minItems, maxItems }
-            : { ...options, kind: TupleKind, type: 'array', minItems, maxItems }) as any
-        return this.Store(schema)
-    }
+export interface TInteger extends TSchema, NumericOptions {
+  [Kind]: 'Integer'
+  static: number
+  type: 'integer'
+}
 
-    /** `Standard` Creates an object type with the given properties */
-    public Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
-        const property_names = Object.keys(properties)
-        const optional = property_names.filter(name => {
-            const candidate = properties[name] as TModifier
-            return (candidate.modifier &&
-                (candidate.modifier === OptionalModifier ||
-                    candidate.modifier === ReadonlyOptionalModifier))
-        })
-        const required_names = property_names.filter(name => !optional.includes(name))
-        const required = (required_names.length > 0) ? required_names : undefined
-        return this.Store(((required) 
-            ? { ...options, kind: ObjectKind, type: 'object', properties, required } 
-            : { ...options, kind: ObjectKind, type: 'object', properties }))
-    }
+// --------------------------------------------------------------------------
+// Intersect
+// --------------------------------------------------------------------------
 
-    /** `Standard` Creates an intersect type. */
-    public Intersect<T extends TSchema[]>(items: [...T], options: IntersectOptions = {}): TIntersect<T> {
-        return this.Store({ ...options, kind: IntersectKind, type: 'object', allOf: items })
-    }
-    
-    /** `Standard` Creates a union type */
-    public Union<T extends TSchema[]>(items: [...T], options: CustomOptions = {}): TUnion<T> {
-        return this.Store({ ...options, kind: UnionKind, anyOf: items })
-    }
+export type IntersectReduce<I extends unknown, T extends readonly any[]> = T extends [infer A, ...infer B] ? IntersectReduce<I & A, B> : I extends object ? I : {}
 
-    /** `Standard` Creates an array type */
-    public Array<T extends TSchema>(items: T, options: ArrayOptions = {}): TArray<T> {
-        return this.Store({ ...options, kind: ArrayKind, type: 'array', items })
-    }
-    
-    /** `Standard` Creates an enum type from a TypeScript enum */
-    public Enum<T extends TEnumType>(item: T, options: CustomOptions = {}): TEnum<TEnumKey<T[keyof T]>[]> {
-        const values = Object.keys(item).filter(key => isNaN(key as any)).map(key => item[key]) as T[keyof T][]
-        const anyOf  = values.map(value => typeof value === 'string' ? { type: 'string' as const, const: value } : { type: 'number' as const, const: value })
-        return this.Store({ ...options, kind: EnumKind, anyOf })
-    }
+// note: rename to IntersectStatic<T, P> in next minor release
+export type IntersectEvaluate<T extends readonly TSchema[], P extends unknown[]> = { [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never }
 
-    /** `Standard` Creates a literal type. Supports string, number and boolean values only */
-    public Literal<T extends TValue>(value: T, options: CustomOptions = {}): TLiteral<T> {
-        return this.Store({ ...options, kind: LiteralKind, const: value, type: typeof value as 'string' | 'number' | 'boolean' })
-    }
+export type IntersectProperties<T extends readonly TObject[]> = {
+  [K in keyof T]: T[K] extends TObject<infer P> ? P : {}
+}
 
-    /** `Standard` Creates a string type */
-    public String<TCustomFormatOption extends string>(options: StringOptions<StringFormatOption | TCustomFormatOption> = {}): TString {
-        return this.Store({ ...options, kind: StringKind, type: 'string' })
-    }
+export interface TIntersect<T extends TObject[] = TObject[]> extends TObject {
+  static: IntersectReduce<unknown, IntersectEvaluate<T, this['params']>>
+  properties: IntersectReduce<unknown, IntersectProperties<T>>
+}
 
-    /** `Standard` Creates a string type from a regular expression */
-    public RegEx(regex: RegExp, options: CustomOptions = {}): TString {
-        return this.String({ ...options, pattern: regex.source })
-    }
+// --------------------------------------------------------------------------
+// KeyOf: Implemented by way of Union<TLiteral<string>>
+// --------------------------------------------------------------------------
 
-    /** `Standard` Creates a number type */
-    public Number(options: NumberOptions = {}): TNumber {
-        return this.Store({ ...options, kind: NumberKind, type: 'number' })
-    }
+export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never
 
-    /** `Standard` Creates an integer type */
-    public Integer(options: NumberOptions = {}): TInteger {
-        return this.Store({ ...options, kind: IntegerKind, type: 'integer' })
-    }
+export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never
 
-    /** `Standard` Creates a boolean type */
-    public Boolean(options: CustomOptions = {}): TBoolean {
-        return this.Store({ ...options, kind: BooleanKind, type: 'boolean' })
-    }
+export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L]
 
-    /** `Standard` Creates a null type */
-    public Null(options: CustomOptions = {}): TNull {
-        return this.Store({ ...options, kind: NullKind, type: 'null' })
-    }
+export type UnionStringLiteralToTuple<T> = T extends TUnion<infer L> ? { [I in keyof L]: L[I] extends TLiteral<infer C> ? C : never } : never
 
-    /** `Standard` Creates an unknown type */
-    public Unknown(options: CustomOptions = {}): TUnknown {
-        return this.Store({ ...options, kind: UnknownKind })
-    }
+export type UnionLiteralsFromObject<T extends TObject> = { [K in ObjectPropertyKeys<T>]: TLiteral<K> } extends infer R ? UnionToTuple<R[keyof R]> : never
 
-    /** `Standard` Creates an any type */
-    public Any(options: CustomOptions = {}): TAny {
-        return this.Store({ ...options, kind: AnyKind })
-    }
-    
-    /** `Standard` Creates a record type */
-    public Record<K extends TRecordKey, T extends TSchema>(key: K, value: T, options: ObjectOptions = {}): TRecord<K, T> {
-        const pattern = (() => {
-            switch(key.kind) {
-                case UnionKind:  return `^${key.anyOf.map((literal: any) => literal.const as TValue).join('|')}$`
-                case KeyOfKind:  return `^${key.enum.join('|')}$`
-                case NumberKind: return '^(0|[1-9][0-9]*)$'
-                case StringKind: return key.pattern ? key.pattern : '^.*$'
-                default: throw Error('Invalid Record Key')
-            }
-        })()
-        return this.Store({ ...options, kind: RecordKind, type: 'object', patternProperties: { [pattern]: value } })
-    }
+// export type TKeyOf<T extends TObject> = { [K in ObjectPropertyKeys<T>]: TLiteral<K> } extends infer R ? UnionToTuple<R[keyof R]> : never
 
-    /** `Standard` Creates a keyof type from the given object */
-    public KeyOf<T extends TObject<TProperties> | TRef<TObject<TProperties>>>(object: T, options: CustomOptions = {}): TKeyOf<SelectablePropertyKeys<T>[]> {
-        const source = this.Deref(object)
-        const keys = Object.keys(source.properties)
-        return this.Store({...options, kind: KeyOfKind, type: 'string', enum: keys })
-    }
+export interface TKeyOf<T extends TObject> extends TUnion<UnionLiteralsFromObject<T>> {}
 
-    /** `Standard` Makes all properties in the given object type required */
-    public Required<T extends TObject<TProperties> | TRef<TObject<TProperties>>>(object: T, options: ObjectOptions = {}): TObject<StaticRequired<T['properties']>> {
-        const source = this.Deref(object)
-        const schema = { ...clone(source), ...options }
-        schema.required = Object.keys(schema.properties)
-        for(const key of Object.keys(schema.properties)) {
-            const property = schema.properties[key]
-            switch(property.modifier) {
-                case ReadonlyOptionalModifier: property.modifier = ReadonlyModifier; break;
-                case ReadonlyModifier: property.modifier = ReadonlyModifier; break;
-                case OptionalModifier: delete property.modifier; break;
-                default: delete property.modifier; break;
-            }
-        }
-        return this.Store(schema)
-    }
-    
-    /** `Standard` Makes all properties in the given object type optional */
-    public Partial<T extends TObject<TProperties> | TRef<TObject<TProperties>>>(object: T, options: ObjectOptions = {}): TObject<StaticPartial<T['properties']>> {
-        const source = this.Deref(object)
-        const schema = { ...clone(source), ...options }
-        delete schema.required
-        for(const key of Object.keys(schema.properties)) {
-            const property = schema.properties[key]
-            switch(property.modifier) {
-                case ReadonlyOptionalModifier: property.modifier = ReadonlyOptionalModifier; break;
-                case ReadonlyModifier: property.modifier = ReadonlyOptionalModifier; break;
-                case OptionalModifier: property.modifier = OptionalModifier; break;
-                default: property.modifier = OptionalModifier; break;
-            }
-        }
-        return this.Store(schema)
-    }
-    
-    /** `Standard` Picks property keys from the given object type */
-    public Pick<T extends TObject<TProperties> | TRef<TObject<TProperties>>, K extends SelectablePropertyKeys<T>[]>(object: T, keys: [...K], options: ObjectOptions = {}): TObject<Pick<SelectableProperties<T>, K[number]>> {
-        const source = this.Deref(object)
-        const schema = { ...clone(source), ...options }
-        schema.required = schema.required ? schema.required.filter((key: K) => keys.includes(key as any)) : undefined
-        for(const key of Object.keys(schema.properties)) {
-            if(!keys.includes(key as any)) delete schema.properties[key]
-        }
-        return this.Store(schema)
-    }
-    
-    /** `Standard` Omits property keys from the given object type */
-    public Omit<T extends TObject<TProperties> | TRef<TObject<TProperties>>, K extends SelectablePropertyKeys<T>[]>(object: T, keys: [...K], options: ObjectOptions = {}):TObject<Omit<SelectableProperties<T>, K[number]>> {
-        const source = this.Deref(object)
-        const schema = { ...clone(source), ...options }
-        schema.required = schema.required ? schema.required.filter((key: string) => !keys.includes(key as any)) : undefined
-        for(const key of Object.keys(schema.properties)) {
-            if(keys.includes(key as any)) delete schema.properties[key]
-        }
-        return this.Store(schema)
-    }
+// --------------------------------------------------------------------------
+// Literal
+// --------------------------------------------------------------------------
 
-    /** `Standard` Omits the `kind` and `modifier` properties from the underlying schema */
-    public Strict<T extends TSchema>(schema: T, options: CustomOptions = {}): T {
-        return JSON.parse(JSON.stringify({ ...options, ...schema })) as T
-    }
-    
-    /** `Extended` Creates a constructor type */
-    public Constructor<T extends TSchema[], U extends TSchema>(args: [...T], returns: U, options: CustomOptions = {}): TConstructor<T, U> {
-        return this.Store({ ...options, kind: ConstructorKind, type: 'constructor', arguments: args, returns })
-    }
+export type TLiteralValue = string | number | boolean
 
-    /** `Extended` Creates a function type */
-    public Function<T extends TSchema[], U extends TSchema>(args: [...T], returns: U, options: CustomOptions = {}): TFunction<T, U> {
-        return this.Store({ ...options, kind: FunctionKind, type: 'function', arguments: args, returns })
-    }
+export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
+  [Kind]: 'Literal'
+  static: T
+  const: T
+}
 
-    /** `Extended` Creates a promise type */
-    public Promise<T extends TSchema>(item: T, options: CustomOptions = {}): TPromise<T> {
-        return this.Store({ ...options, type: 'promise', kind: PromiseKind, item })
-    }
+// --------------------------------------------------------------------------
+// Never
+// --------------------------------------------------------------------------
 
-    /** `Extended` Creates a undefined type */
-    public Undefined(options: CustomOptions = {}): TUndefined {
-        return this.Store({ ...options, type: 'undefined', kind: UndefinedKind })
-    }
+export interface TNever extends TSchema {
+  [Kind]: 'Never'
+  static: never
+  allOf: [{ type: 'boolean'; const: false }, { type: 'boolean'; const: true }]
+}
 
-    /** `Extended` Creates a void type */
-    public Void(options: CustomOptions = {}): TVoid {
-        return this.Store({ ...options, type: 'void', kind: VoidKind })
-    }
-    
-    /** `Standard` Creates a namespace for a set of related types */
-    public Namespace<T extends TDefinitions>($defs: T, options: CustomOptions = {}): TNamespace<T> {
-        return this.Store({ ...options, kind: BoxKind, $defs })
-    }
-    
-    /** `Standard` References a type within a namespace. The referenced namespace must specify an `$id` */
-    public Ref<T extends TNamespace<TDefinitions>, K extends keyof T['$defs']>(namespace: T, key: K): TRef<T['$defs'][K]>
-    
-    /** `Standard` References type. The referenced type must specify an `$id` */
-    public Ref<T extends TSchema>(schema: T): TRef<T>
-    
-    public Ref(...args: any[]): any {
-        if(args.length === 2) {
-            const namespace = args[0] as TNamespace<TDefinitions>
-            const targetKey = args[1] as string
-            if(namespace.$id === undefined) throw new Error(`Referenced namespace has no $id`)
-            if(!this.schemas.has(namespace.$id)) throw new Error(`Unable to locate namespace with $id '${namespace.$id}'`)
-            return this.Store({ kind: RefKind, $ref: `${namespace.$id}#/$defs/${targetKey}` })
-        } else if(args.length === 1) {
-            const target = args[0] as any
-            if(target.$id === undefined) throw new Error(`Referenced schema has no $id`)
-            if(!this.schemas.has(target.$id)) throw new Error(`Unable to locate schema with $id '${target.$id}'`)
-            return this.Store({ kind: RefKind, $ref: target.$id })
-        } else {
-            throw new Error('Type.Ref: Invalid arguments')
-        }
-    }
+// --------------------------------------------------------------------------
+// Null
+// --------------------------------------------------------------------------
 
-    /** `Experimental` Creates a recursive type */
-    public Rec<T extends TSchema>(callback: (self: TAny) => T, options: CustomOptions = {}): T {
-        const $id = options.$id || ''
-        const self = callback({ $ref: `${$id}#/$defs/self` } as any)
-        return this.Store({ ...options, $ref: `${$id}#/$defs/self`, $defs: { self } })
-    }
+export interface TNull extends TSchema {
+  [Kind]: 'Null'
+  static: null
+  type: 'null'
+}
 
-    /** Conditionally stores and schema if it contains an $id and returns  */
-    protected Store<T extends TSchema | TNamespace<TDefinitions>, S = Omit<T, '$static'>>(schema: S): T {
-        const $schema: any = schema
-        if(!$schema['$id']) return $schema
-        this.schemas.set($schema['$id'], $schema)
-        return $schema
-    }
+// --------------------------------------------------------------------------
+// Number
+// --------------------------------------------------------------------------
 
-    /** Conditionally dereferences a schema if RefKind. Otherwise return argument */
-    protected Deref<T extends TSchema>(schema: T): any {
-        const $schema: any = schema
-        if($schema['kind'] !== RefKind) return schema
-        if(!this.schemas.has($schema['$ref'])) throw Error(`Unable to locate schema with $id '${$schema['$ref']}'`)
-        return this.Deref(this.schemas.get($schema['$ref'])!)
-    }
+export interface TNumber extends TSchema, NumericOptions {
+  [Kind]: 'Number'
+  static: number
+  type: 'number'
+}
+
+// --------------------------------------------------------------------------
+// Object
+// --------------------------------------------------------------------------
+
+export type ReadonlyOptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never }[keyof T]
+
+export type ReadonlyPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never }[keyof T]
+
+export type OptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TOptional<TSchema> ? K : never }[keyof T]
+
+export type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>
+
+export type PropertiesReduce<T extends TProperties, P extends unknown[]> = { readonly [K in ReadonlyOptionalPropertyKeys<T>]?: Static<T[K], P> } & {
+  readonly [K in ReadonlyPropertyKeys<T>]: Static<T[K], P>
+} & {
+  [K in OptionalPropertyKeys<T>]?: Static<T[K], P>
+} & { [K in RequiredPropertyKeys<T>]: Static<T[K], P> } extends infer R
+  ? { [K in keyof R]: R[K] }
+  : never
+
+export type TRecordProperties<K extends TUnion<TLiteral[]>, T extends TSchema> = Static<K> extends string ? { [X in Static<K>]: T } : never
+
+export interface TProperties {
+  [key: string]: TSchema
+}
+
+export type ObjectProperties<T> = T extends TObject<infer U> ? U : never
+
+export type ObjectPropertyKeys<T> = T extends TObject<infer U> ? keyof U : never
+
+export interface ObjectOptions extends SchemaOptions {
+  additionalProperties?: boolean
+  minProperties?: number
+  maxProperties?: number
+}
+
+export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
+  [Kind]: 'Object'
+  static: PropertiesReduce<T, this['params']>
+  type: 'object'
+  properties: T
+  required?: string[]
+}
+
+// --------------------------------------------------------------------------
+// Omit
+// --------------------------------------------------------------------------
+
+export interface TOmit<T extends TObject, Properties extends ObjectPropertyKeys<T>[]> extends TObject, ObjectOptions {
+  static: Omit<Static<T, this['params']>, Properties[number]>
+  properties: T extends TObject ? Omit<T['properties'], Properties[number]> : never
+}
+
+// --------------------------------------------------------------------------
+// Partial
+// --------------------------------------------------------------------------
+
+export interface TPartial<T extends TObject> extends TObject {
+  static: Partial<Static<T, this['params']>>
+}
+
+// --------------------------------------------------------------------------
+// Pick
+// --------------------------------------------------------------------------
+
+// export interface TPick<T extends TObject, Properties extends ObjectPropertyKeys<T>[]> extends TObject, ObjectOptions {
+//   static: Pick<Static<T, this['params']>, Properties[number]>
+//   properties: ObjectProperties<T>
+// }
+
+export type TPick<T extends TObject, Properties extends ObjectPropertyKeys<T>[]> = TObject<{
+  [K in Properties[number]]: T['properties'][K]
+}>
+
+// --------------------------------------------------------------------------
+// Promise
+// --------------------------------------------------------------------------
+
+export interface TPromise<T extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'Promise'
+  static: Promise<Static<T, this['params']>>
+  type: 'promise'
+  item: TSchema
+}
+
+// --------------------------------------------------------------------------
+// Record
+// --------------------------------------------------------------------------
+
+export type TRecordKey = TString | TNumber | TUnion<TLiteral<any>[]>
+
+export interface TRecord<K extends TRecordKey = TRecordKey, T extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'Record'
+  static: Record<Static<K>, Static<T, this['params']>>
+  type: 'object'
+  patternProperties: { [pattern: string]: T }
+  additionalProperties: false
+}
+
+// --------------------------------------------------------------------------
+// Rec
+// --------------------------------------------------------------------------
+
+export interface TSelf extends TSchema {
+  [Kind]: 'Self'
+  static: this['params'][0]
+  $ref: string
+}
+
+export type TRecursiveReduce<T extends TSchema> = Static<T, [TRecursiveReduce<T>]>
+
+export interface TRecursive<T extends TSchema> extends TSchema {
+  static: TRecursiveReduce<T>
+}
+
+// --------------------------------------------------------------------------
+// Ref
+// --------------------------------------------------------------------------
+
+export interface TRef<T extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'Ref'
+  static: Static<T, this['params']>
+  $ref: string
+}
+
+// --------------------------------------------------------------------------
+// Required
+// --------------------------------------------------------------------------
+
+export interface TRequired<T extends TObject | TRef<TObject>> extends TObject {
+  static: Required<Static<T, this['params']>>
+}
+
+// --------------------------------------------------------------------------
+// String
+// --------------------------------------------------------------------------
+
+export type StringFormatOption =
+  | 'date-time'
+  | 'time'
+  | 'date'
+  | 'email'
+  | 'idn-email'
+  | 'hostname'
+  | 'idn-hostname'
+  | 'ipv4'
+  | 'ipv6'
+  | 'uri'
+  | 'uri-reference'
+  | 'iri'
+  | 'uuid'
+  | 'iri-reference'
+  | 'uri-template'
+  | 'json-pointer'
+  | 'relative-json-pointer'
+  | 'regex'
+
+export interface StringOptions<Format extends string> extends SchemaOptions {
+  minLength?: number
+  maxLength?: number
+  pattern?: string
+  format?: Format
+  contentEncoding?: '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64'
+  contentMediaType?: string
 }
 
+export interface TString<Format extends string = string> extends TSchema, StringOptions<Format> {
+  [Kind]: 'String'
+  static: string
+  type: 'string'
+}
+
+// --------------------------------------------------------------------------
+// Tuple
+// --------------------------------------------------------------------------
+
+export type TupleToArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? R : never
+
+export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
+  [Kind]: 'Tuple'
+  static: { [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : T[K] }
+  type: 'array'
+  items?: T
+  additionalItems?: false
+  minItems: number
+  maxItems: number
+}
+
+// --------------------------------------------------------------------------
+// Undefined
+// --------------------------------------------------------------------------
+
+export interface TUndefined extends TSchema {
+  [Kind]: 'Undefined'
+  specialized: 'Undefined'
+  static: undefined
+  type: 'object'
+}
+
+// --------------------------------------------------------------------------
+// Union
+// --------------------------------------------------------------------------
+
+export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
+  [Kind]: 'Union'
+  static: { [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : never }[number]
+  anyOf: T
+}
+
+// -------------------------------------------------------------------------
+// Uint8Array
+// -------------------------------------------------------------------------
+
+export interface Uint8ArrayOptions extends SchemaOptions {
+  maxByteLength?: number
+  minByteLength?: number
+}
+
+export interface TUint8Array extends TSchema, Uint8ArrayOptions {
+  [Kind]: 'Uint8Array'
+  static: Uint8Array
+  specialized: 'Uint8Array'
+  type: 'object'
+}
+
+// --------------------------------------------------------------------------
+// Unknown
+// --------------------------------------------------------------------------
+
+export interface TUnknown extends TSchema {
+  [Kind]: 'Unknown'
+  static: unknown
+}
+
+// --------------------------------------------------------------------------
+// Unsafe
+// --------------------------------------------------------------------------
+
+export interface UnsafeOptions extends SchemaOptions {
+  [Kind]?: string
+}
+
+export interface TUnsafe<T> extends TSchema {
+  [Kind]: string
+  static: T
+}
+
+// --------------------------------------------------------------------------
+// Void
+// --------------------------------------------------------------------------
+
+export interface TVoid extends TSchema {
+  [Kind]: 'Void'
+  static: void
+  type: 'null'
+}
+
+// --------------------------------------------------------------------------
+// Static<T>
+// --------------------------------------------------------------------------
+
+/** Creates a static type from a TypeBox type */
+export type Static<T extends TSchema, P extends unknown[] = []> = (T & { params: P })['static']
+
+// --------------------------------------------------------------------------
+// TypeBuilder
+// --------------------------------------------------------------------------
+
+let TypeOrdinal = 0
+
+export class TypeBuilder {
+  // ----------------------------------------------------------------------
+  // Modifiers
+  // ----------------------------------------------------------------------
+
+  /** Creates a readonly optional property */
+  public ReadonlyOptional<T extends TSchema>(item: T): TReadonlyOptional<T> {
+    return { [Modifier]: 'ReadonlyOptional', ...item }
+  }
+
+  /** Creates a readonly property */
+  public Readonly<T extends TSchema>(item: T): TReadonly<T> {
+    return { [Modifier]: 'Readonly', ...item }
+  }
+
+  /** Creates a optional property */
+  public Optional<T extends TSchema>(item: T): TOptional<T> {
+    return { [Modifier]: 'Optional', ...item }
+  }
+
+  // ----------------------------------------------------------------------
+  // Types
+  // ----------------------------------------------------------------------
+
+  /** Creates a any type */
+  public Any(options: SchemaOptions = {}): TAny {
+    return this.Create({ ...options, [Kind]: 'Any' })
+  }
+
+  /** Creates a array type */
+  public Array<T extends TSchema>(items: T, options: ArrayOptions = {}): TArray<T> {
+    return this.Create({ ...options, [Kind]: 'Array', type: 'array', items })
+  }
+
+  /** Creates a boolean type */
+  public Boolean(options: SchemaOptions = {}): TBoolean {
+    return this.Create({ ...options, [Kind]: 'Boolean', type: 'boolean' })
+  }
+
+  /** Creates a tuple type from this constructors parameters */
+  public ConstructorParameters<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TConstructorParameters<T> {
+    return this.Tuple([...schema.parameters], { ...options })
+  }
+
+  /** Creates a constructor type */
+  public Constructor<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TConstructor<TupleToArray<T>, U>
+
+  /** Creates a constructor type */
+  public Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>
+
+  /** Creates a constructor type */
+  public Constructor(parameters: any, returns: any, options: SchemaOptions = {}) {
+    if (parameters[Kind] === 'Tuple') {
+      const inner = parameters.items === undefined ? [] : parameters.items
+      return this.Create({ ...options, [Kind]: 'Constructor', type: 'constructor', parameters: inner, returns })
+    } else if (globalThis.Array.isArray(parameters)) {
+      return this.Create({ ...options, [Kind]: 'Constructor', type: 'constructor', parameters, returns })
+    } else {
+      throw new Error('TypeBuilder.Constructor: Invalid parameters')
+    }
+  }
+
+  /** Creates a enum type */
+  public Enum<T extends Record<string, string | number>>(item: T, options: SchemaOptions = {}): TEnum<T> {
+    const values = Object.keys(item)
+      .filter((key) => isNaN(key as any))
+      .map((key) => item[key]) as T[keyof T][]
+    const anyOf = values.map((value) => (typeof value === 'string' ? { [Kind]: 'Literal', type: 'string' as const, const: value } : { [Kind]: 'Literal', type: 'number' as const, const: value }))
+    return this.Create({ ...options, [Kind]: 'Union', [Hint]: 'Enum', anyOf })
+  }
+
+  /** Creates a function type */
+  public Function<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TFunction<TupleToArray<T>, U>
+
+  /** Creates a function type */
+  public Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>
+
+  /** Creates a function type */
+  public Function(parameters: any, returns: any, options: SchemaOptions = {}) {
+    if (parameters[Kind] === 'Tuple') {
+      const inner = parameters.items === undefined ? [] : parameters.items
+      return this.Create({ ...options, [Kind]: 'Function', type: 'function', parameters: inner, returns })
+    } else if (globalThis.Array.isArray(parameters)) {
+      return this.Create({ ...options, [Kind]: 'Function', type: 'function', parameters, returns })
+    } else {
+      throw new Error('TypeBuilder.Function: Invalid parameters')
+    }
+  }
+
+  /** Creates a type from this constructors instance type */
+  public InstanceType<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TInstanceType<T> {
+    return { ...options, ...this.Clone(schema.returns) }
+  }
+
+  /** Creates a integer type */
+  public Integer(options: NumericOptions = {}): TInteger {
+    return this.Create({ ...options, [Kind]: 'Integer', type: 'integer' })
+  }
+
+  /** Creates a intersect type. */
+  public Intersect<T extends TObject[]>(objects: [...T], options: ObjectOptions = {}): TIntersect<T> {
+    const isOptional = (schema: TSchema) => (schema[Modifier] && schema[Modifier] === 'Optional') || schema[Modifier] === 'ReadonlyOptional'
+    const [required, optional] = [new Set<string>(), new Set<string>()]
+    for (const object of objects) {
+      for (const [key, schema] of Object.entries(object.properties)) {
+        if (isOptional(schema)) optional.add(key)
+      }
+    }
+    for (const object of objects) {
+      for (const key of Object.keys(object.properties)) {
+        if (!optional.has(key)) required.add(key)
+      }
+    }
+    const properties = {} as Record<string, any>
+    for (const object of objects) {
+      for (const [key, schema] of Object.entries(object.properties)) {
+        properties[key] = properties[key] === undefined ? schema : { [Kind]: 'Union', anyOf: [properties[key], { ...schema }] }
+      }
+    }
+    if (required.size > 0) {
+      return this.Create({ ...options, [Kind]: 'Object', type: 'object', properties, required: [...required] })
+    } else {
+      return this.Create({ ...options, [Kind]: 'Object', type: 'object', properties })
+    }
+  }
+
+  /** Creates a keyof type */
+  public KeyOf<T extends TObject>(object: T, options: SchemaOptions = {}): TKeyOf<T> {
+    const items = Object.keys(object.properties).map((key) => this.Create({ ...options, [Kind]: 'Literal', type: 'string', const: key }))
+    return this.Create({ ...options, [Kind]: 'Union', [Hint]: 'KeyOf', anyOf: items })
+  }
+
+  /** Creates a literal type. */
+  public Literal<T extends TLiteralValue>(value: T, options: SchemaOptions = {}): TLiteral<T> {
+    return this.Create({ ...options, [Kind]: 'Literal', const: value, type: typeof value as 'string' | 'number' | 'boolean' })
+  }
+
+  /** Creates a never type */
+  public Never(options: SchemaOptions = {}): TNever {
+    return this.Create({
+      ...options,
+      [Kind]: 'Never',
+      allOf: [
+        { type: 'boolean', const: false },
+        { type: 'boolean', const: true },
+      ],
+    })
+  }
+
+  /** Creates a null type */
+  public Null(options: SchemaOptions = {}): TNull {
+    return this.Create({ ...options, [Kind]: 'Null', type: 'null' })
+  }
+
+  /** Creates a number type */
+  public Number(options: NumericOptions = {}): TNumber {
+    return this.Create({ ...options, [Kind]: 'Number', type: 'number' })
+  }
+
+  /** Creates an object type with the given properties */
+  public Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
+    const property_names = Object.keys(properties)
+    const optional = property_names.filter((name) => {
+      const property = properties[name] as TModifier
+      const modifier = property[Modifier]
+      return modifier && (modifier === 'Optional' || modifier === 'ReadonlyOptional')
+    })
+    const required = property_names.filter((name) => !optional.includes(name))
+    if (required.length > 0) {
+      return this.Create({ ...options, [Kind]: 'Object', type: 'object', properties, required })
+    } else {
+      return this.Create({ ...options, [Kind]: 'Object', type: 'object', properties })
+    }
+  }
+
+  /** Creates a new object whose properties are omitted from the given object */
+  public Omit<T extends TObject, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: ObjectOptions): TOmit<T, UnionStringLiteralToTuple<K>>
+
+  /** Creates a new object whose properties are omitted from the given object */
+  public Omit<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: T, keys: [...K], options?: ObjectOptions): TOmit<T, K>
+
+  /** Creates a new object whose properties are omitted from the given object */
+  public Omit(schema: any, keys: any, options: ObjectOptions = {}) {
+    const select: string[] = keys[Kind] === 'Union' ? keys.anyOf.map((schema: TLiteral) => schema.const) : keys
+    const next = { ...this.Clone(schema), ...options, [Hint]: 'Omit' }
+    if (next.required) {
+      next.required = next.required.filter((key: string) => !select.includes(key as any))
+      if (next.required.length === 0) delete next.required
+    }
+    for (const key of Object.keys(next.properties)) {
+      if (select.includes(key as any)) delete next.properties[key]
+    }
+    return this.Create(next)
+  }
+
+  /** Creates a tuple type from this functions parameters */
+  public Parameters<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TParameters<T> {
+    return Type.Tuple(schema.parameters, { ...options })
+  }
+
+  /** Creates an object type whose properties are all optional */
+  public Partial<T extends TObject>(schema: T, options: ObjectOptions = {}): TPartial<T> {
+    const next = { ...this.Clone(schema), ...options, [Hint]: 'Partial' }
+    delete next.required
+    for (const key of Object.keys(next.properties)) {
+      const property = next.properties[key]
+      const modifer = property[Modifier]
+      switch (modifer) {
+        case 'ReadonlyOptional':
+          property[Modifier] = 'ReadonlyOptional'
+          break
+        case 'Readonly':
+          property[Modifier] = 'ReadonlyOptional'
+          break
+        case 'Optional':
+          property[Modifier] = 'Optional'
+          break
+        default:
+          property[Modifier] = 'Optional'
+          break
+      }
+    }
+    return this.Create(next)
+  }
+
+  /** Creates a object whose properties are picked from the given object */
+  public Pick<T extends TObject, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: ObjectOptions): TPick<T, UnionStringLiteralToTuple<K>>
+
+  /** Creates a object whose properties are picked from the given object */
+  public Pick<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: T, keys: [...K], options?: ObjectOptions): TPick<T, K>
+
+  /** Creates a object whose properties are picked from the given object */
+  public Pick<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: any, keys: any, options: ObjectOptions = {}) {
+    const select: string[] = keys[Kind] === 'Union' ? keys.anyOf.map((schema: TLiteral) => schema.const) : keys
+    const next = { ...this.Clone(schema), ...options, [Hint]: 'Pick' }
+    if (next.required) {
+      next.required = next.required.filter((key: any) => select.includes(key))
+      if (next.required.length === 0) delete next.required
+    }
+    for (const key of Object.keys(next.properties)) {
+      if (!select.includes(key as any)) delete next.properties[key]
+    }
+    return this.Create(next)
+  }
+
+  /** Creates a promise type. This type cannot be represented in schema. */
+  public Promise<T extends TSchema>(item: T, options: SchemaOptions = {}): TPromise<T> {
+    return this.Create({ ...options, [Kind]: 'Promise', type: 'promise', item })
+  }
+
+  /** Creates an object whose properties are derived from the given string literal union. */
+  public Record<K extends TUnion<TLiteral[]>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TObject<TRecordProperties<K, T>>
+
+  /** Creates a record type */
+  public Record<K extends TString | TNumber, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecord<K, T>
+
+  /** Creates a record type */
+  public Record(key: any, value: any, options: ObjectOptions = {}) {
+    // If string literal union return TObject with properties extracted from union.
+    if (key[Kind] === 'Union') {
+      return this.Object(
+        key.anyOf.reduce((acc: any, literal: any) => {
+          return { ...acc, [literal.const]: value }
+        }, {}),
+        { ...options, [Hint]: 'Record' },
+      )
+    }
+    // otherwise return TRecord with patternProperties
+    const pattern = key[Kind] === 'Number' ? '^(0|[1-9][0-9]*)$' : key[Kind] === 'String' && key.pattern ? key.pattern : '^.*$'
+    return this.Create({
+      ...options,
+      [Kind]: 'Record',
+      type: 'object',
+      patternProperties: { [pattern]: value },
+      additionalProperties: false,
+    })
+  }
+
+  /** Creates a recursive object type */
+  public Recursive<T extends TSchema>(callback: (self: TSelf) => T, options: SchemaOptions = {}): TRecursive<T> {
+    if (options.$id === undefined) options.$id = `T${TypeOrdinal++}`
+    const self = callback({ [Kind]: 'Self', $ref: `${options.$id}` } as any)
+    self.$id = options.$id
+    return this.Create({ ...options, ...self } as any)
+  }
+
+  /** Creates a reference schema */
+  public Ref<T extends TSchema>(schema: T, options: SchemaOptions = {}): TRef<T> {
+    if (schema.$id === undefined) throw Error('TypeBuilder.Ref: Referenced schema must specify an $id')
+    return this.Create({ ...options, [Kind]: 'Ref', $ref: schema.$id! })
+  }
+
+  /** Creates a string type from a regular expression */
+  public RegEx(regex: RegExp, options: SchemaOptions = {}): TString {
+    return this.Create({ ...options, [Kind]: 'String', type: 'string', pattern: regex.source })
+  }
+
+  /** Creates an object type whose properties are all required */
+  public Required<T extends TObject>(schema: T, options: SchemaOptions = {}): TRequired<T> {
+    const next = { ...this.Clone(schema), ...options, [Hint]: 'Required' }
+    next.required = Object.keys(next.properties)
+    for (const key of Object.keys(next.properties)) {
+      const property = next.properties[key]
+      const modifier = property[Modifier]
+      switch (modifier) {
+        case 'ReadonlyOptional':
+          property[Modifier] = 'Readonly'
+          break
+        case 'Readonly':
+          property[Modifier] = 'Readonly'
+          break
+        case 'Optional':
+          delete property[Modifier]
+          break
+        default:
+          delete property[Modifier]
+          break
+      }
+    }
+    return this.Create(next)
+  }
+
+  /** Creates a type from this functions return type */
+  public ReturnType<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TReturnType<T> {
+    return { ...options, ...this.Clone(schema.returns) }
+  }
+
+  /** Removes Kind and Modifier symbol property keys from this schema */
+  public Strict<T extends TSchema>(schema: T): T {
+    return JSON.parse(JSON.stringify(schema))
+  }
+
+  /** Creates a string type */
+  public String<Format extends string>(options: StringOptions<StringFormatOption | Format> = {}): TString<Format> {
+    return this.Create({ ...options, [Kind]: 'String', type: 'string' })
+  }
+
+  /** Creates a tuple type */
+  public Tuple<T extends TSchema[]>(items: [...T], options: SchemaOptions = {}): TTuple<T> {
+    const additionalItems = false
+    const minItems = items.length
+    const maxItems = items.length
+    const schema = (items.length > 0 ? { ...options, [Kind]: 'Tuple', type: 'array', items, additionalItems, minItems, maxItems } : { ...options, [Kind]: 'Tuple', type: 'array', minItems, maxItems }) as any
+    return this.Create(schema)
+  }
+
+  /** Creates a undefined type */
+  public Undefined(options: SchemaOptions = {}): TUndefined {
+    return this.Create({ ...options, [Kind]: 'Undefined', type: 'object', specialized: 'Undefined' })
+  }
+
+  /** Creates a union type */
+
+  public Union(items: [], options?: SchemaOptions): TNever
+  public Union<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TUnion<T>
+  public Union<T extends TSchema[]>(items: [...T], options: SchemaOptions = {}) {
+    return items.length === 0 ? Type.Never({ ...options }) : this.Create({ ...options, [Kind]: 'Union', anyOf: items })
+  }
+
+  /** Creates a Uint8Array type */
+  public Uint8Array(options: Uint8ArrayOptions = {}): TUint8Array {
+    return this.Create({ ...options, [Kind]: 'Uint8Array', type: 'object', specialized: 'Uint8Array' })
+  }
+
+  /** Creates an unknown type */
+  public Unknown(options: SchemaOptions = {}): TUnknown {
+    return this.Create({ ...options, [Kind]: 'Unknown' })
+  }
+
+  /** Creates a user defined schema that infers as type T  */
+  public Unsafe<T>(options: UnsafeOptions = {}): TUnsafe<T> {
+    return this.Create({ ...options, [Kind]: options[Kind] || 'Unsafe' })
+  }
+
+  /** Creates a void type */
+  public Void(options: SchemaOptions = {}): TVoid {
+    return this.Create({ ...options, [Kind]: 'Void', type: 'null' })
+  }
+
+  /** Use this function to return TSchema with static and params omitted */
+  protected Create<T>(schema: Omit<T, 'static' | 'params'>): T {
+    return schema as any
+  }
+
+  /** Clones the given value */
+  protected Clone(value: any): any {
+    const isObject = (object: any): object is Record<string | symbol, any> => typeof object === 'object' && object !== null && !Array.isArray(object)
+    const isArray = (object: any): object is any[] => typeof object === 'object' && object !== null && Array.isArray(object)
+    if (isObject(value)) {
+      return Object.keys(value).reduce(
+        (acc, key) => ({
+          ...acc,
+          [key]: this.Clone(value[key]),
+        }),
+        Object.getOwnPropertySymbols(value).reduce(
+          (acc, key) => ({
+            ...acc,
+            [key]: this.Clone(value[key]),
+          }),
+          {},
+        ),
+      )
+    } else if (isArray(value)) {
+      return value.map((item: any) => this.Clone(item))
+    } else {
+      return value
+    }
+  }
+}
 
+/** JSON Schema Type Builder with Static Type Resolution for TypeScript */
 export const Type = new TypeBuilder()
diff --git a/src/value/cast.ts b/src/value/cast.ts
new file mode 100644
index 000000000..4478b5ff5
--- /dev/null
+++ b/src/value/cast.ts
@@ -0,0 +1,370 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '../typebox'
+import { ValueCreate } from './create'
+import { ValueCheck } from './check'
+import { ValueClone } from './clone'
+
+namespace UnionValueCast {
+  // ----------------------------------------------------------------------------------------------
+  // The following will score a schema against a value. For objects, the score is the tally of
+  // points awarded for each property of the value. Property points are (1.0 / propertyCount)
+  // to prevent large property counts biasing results. Properties that match literal values are
+  // maximally awarded as literals are typically used as union discriminator fields.
+  // ----------------------------------------------------------------------------------------------
+  function Score(schema: Types.TSchema, references: Types.TSchema[], value: any): number {
+    if (schema[Types.Kind] === 'Object' && typeof value === 'object' && value !== null) {
+      const object = schema as Types.TObject
+      const keys = Object.keys(value)
+      const entries = globalThis.Object.entries(object.properties)
+      const [point, max] = [1 / entries.length, entries.length]
+      return entries.reduce((acc, [key, schema]) => {
+        const literal = schema[Types.Kind] === 'Literal' && schema.const === value[key] ? max : 0
+        const checks = ValueCheck.Check(schema, references, value[key]) ? point : 0
+        const exists = keys.includes(key) ? point : 0
+        return acc + (literal + checks + exists)
+      }, 0)
+    } else {
+      return ValueCheck.Check(schema, references, value) ? 1 : 0
+    }
+  }
+  function Select(union: Types.TUnion, references: Types.TSchema[], value: any): Types.TSchema {
+    let [select, best] = [union.anyOf[0], 0]
+    for (const schema of union.anyOf) {
+      const score = Score(schema, references, value)
+      if (score > best) {
+        select = schema
+        best = score
+      }
+    }
+    return select
+  }
+
+  export function Create(union: Types.TUnion, references: Types.TSchema[], value: any) {
+    return ValueCheck.Check(union, references, value) ? ValueClone.Clone(value) : ValueCast.Cast(Select(union, references, value), references, value)
+  }
+}
+
+// -----------------------------------------------------------
+// Errors
+// -----------------------------------------------------------
+
+export class ValueCastReferenceTypeError extends Error {
+  constructor(public readonly schema: Types.TRef | Types.TSelf) {
+    super(`ValueCast: Cannot locate referenced schema with $id '${schema.$ref}'`)
+  }
+}
+
+export class ValueCastArrayUniqueItemsTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema, public readonly value: unknown) {
+    super('ValueCast: Array cast produced invalid data due to uniqueItems constraint')
+  }
+}
+
+export class ValueCastNeverTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('ValueCast: Never types cannot be cast')
+  }
+}
+
+export class ValueCastRecursiveTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('ValueCast.Recursive: Cannot cast recursive schemas')
+  }
+}
+export class ValueCastUnknownTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('ValueCast: Unknown type')
+  }
+}
+
+export namespace ValueCast {
+  // -----------------------------------------------------------
+  // Guards
+  // -----------------------------------------------------------
+
+  function IsArray(value: unknown): value is unknown[] {
+    return typeof value === 'object' && globalThis.Array.isArray(value)
+  }
+
+  function IsString(value: unknown): value is string {
+    return typeof value === 'string'
+  }
+
+  function IsBoolean(value: unknown): value is boolean {
+    return typeof value === 'boolean'
+  }
+
+  function IsBigInt(value: unknown): value is bigint {
+    return typeof value === 'bigint'
+  }
+
+  function IsNumber(value: unknown): value is number {
+    return typeof value === 'number'
+  }
+
+  function IsStringNumeric(value: unknown): value is string {
+    return IsString(value) && !isNaN(value as any) && !isNaN(parseFloat(value))
+  }
+
+  function IsValueToString(value: unknown): value is { toString: () => string } {
+    return IsBigInt(value) || IsBoolean(value) || IsNumber(value)
+  }
+
+  function IsValueTrue(value: unknown): value is true {
+    return value === true || (IsNumber(value) && value === 1) || (IsBigInt(value) && value === 1n) || (IsString(value) && (value.toLowerCase() === 'true' || value === '1'))
+  }
+
+  function IsValueFalse(value: unknown): value is true {
+    return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === 0n) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'))
+  }
+
+  // -----------------------------------------------------------
+  // Convert
+  // -----------------------------------------------------------
+
+  function TryConvertString(value: unknown) {
+    return IsValueToString(value) ? value.toString() : value
+  }
+
+  function TryConvertNumber(value: unknown) {
+    return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : value
+  }
+
+  function TryConvertInteger(value: unknown) {
+    return IsStringNumeric(value) ? parseInt(value) : IsValueTrue(value) ? 1 : value
+  }
+
+  function TryConvertBoolean(value: unknown) {
+    return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value
+  }
+
+  // -----------------------------------------------------------
+  // Cast
+  // -----------------------------------------------------------
+
+  function Any(schema: Types.TAny, references: Types.TSchema[], value: any): any {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+  }
+
+  function Array(schema: Types.TArray, references: Types.TSchema[], value: any): any {
+    if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
+    const created = IsArray(value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+    const minimum = IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...globalThis.Array.from({ length: schema.minItems - created.length }, () => null)] : created
+    const maximum = IsNumber(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum
+    const casted = maximum.map((value: unknown) => Visit(schema.items, references, value))
+    if (schema.uniqueItems !== true) return casted
+    const unique = [...new Set(casted)]
+    if (!ValueCheck.Check(schema, references, unique)) throw new ValueCastArrayUniqueItemsTypeError(schema, unique)
+    return unique
+  }
+
+  function Boolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): any {
+    const conversion = TryConvertBoolean(value)
+    return ValueCheck.Check(schema, references, conversion) ? conversion : ValueCreate.Create(schema, references)
+  }
+
+  function Constructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): any {
+    if (ValueCheck.Check(schema, references, value)) return ValueCreate.Create(schema, references)
+    const required = new Set(schema.returns.required || [])
+    const result = function () {}
+    for (const [key, property] of globalThis.Object.entries(schema.returns.properties)) {
+      if (!required.has(key) && value.prototype[key] === undefined) continue
+      result.prototype[key] = Visit(property as Types.TSchema, references, value.prototype[key])
+    }
+    return result
+  }
+
+  function Enum(schema: Types.TEnum<any>, references: Types.TSchema[], value: any): any {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+  }
+
+  function Function(schema: Types.TFunction, references: Types.TSchema[], value: any): any {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+  }
+
+  function Integer(schema: Types.TInteger, references: Types.TSchema[], value: any): any {
+    const conversion = TryConvertInteger(value)
+    return ValueCheck.Check(schema, references, conversion) ? conversion : ValueCreate.Create(schema, references)
+  }
+
+  function Literal(schema: Types.TLiteral, references: Types.TSchema[], value: any): any {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+  }
+
+  function Never(schema: Types.TNever, references: Types.TSchema[], value: any): any {
+    throw new ValueCastNeverTypeError(schema)
+  }
+
+  function Null(schema: Types.TNull, references: Types.TSchema[], value: any): any {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+  }
+
+  function Number(schema: Types.TNumber, references: Types.TSchema[], value: any): any {
+    const conversion = TryConvertNumber(value)
+    return ValueCheck.Check(schema, references, conversion) ? conversion : ValueCreate.Create(schema, references)
+  }
+
+  function Object(schema: Types.TObject, references: Types.TSchema[], value: any): any {
+    if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
+    if (value === null || typeof value !== 'object') return ValueCreate.Create(schema, references)
+    const required = new Set(schema.required || [])
+    const result = {} as Record<string, any>
+    for (const [key, property] of globalThis.Object.entries(schema.properties)) {
+      if (!required.has(key) && value[key] === undefined) continue
+      result[key] = Visit(property, references, value[key])
+    }
+    return result
+  }
+
+  function Promise(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+  }
+
+  function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): any {
+    if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
+    if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value)) return ValueCreate.Create(schema, references)
+    const subschemaKey = globalThis.Object.keys(schema.patternProperties)[0]
+    const subschema = schema.patternProperties[subschemaKey]
+    const result = {} as Record<string, any>
+    for (const [propKey, propValue] of globalThis.Object.entries(value)) {
+      result[propKey] = Visit(subschema, references, propValue)
+    }
+    return result
+  }
+
+  function Recursive(schema: Types.TRecursive<any>, references: Types.TSchema[], value: any): any {
+    throw new ValueCastRecursiveTypeError(schema)
+  }
+
+  function Ref(schema: Types.TRef<any>, references: Types.TSchema[], value: any): any {
+    const reference = references.find((reference) => reference.$id === schema.$ref)
+    if (reference === undefined) throw new ValueCastReferenceTypeError(schema)
+    return Visit(reference, references, value)
+  }
+
+  function Self(schema: Types.TSelf, references: Types.TSchema[], value: any): any {
+    const reference = references.find((reference) => reference.$id === schema.$ref)
+    if (reference === undefined) throw new ValueCastReferenceTypeError(schema)
+    return Visit(reference, references, value)
+  }
+
+  function String(schema: Types.TString, references: Types.TSchema[], value: any): any {
+    const conversion = TryConvertString(value)
+    return ValueCheck.Check(schema, references, conversion) ? conversion : ValueCreate.Create(schema, references)
+  }
+
+  function Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): any {
+    if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
+    if (!globalThis.Array.isArray(value)) return ValueCreate.Create(schema, references)
+    if (schema.items === undefined) return []
+    return schema.items.map((schema, index) => Visit(schema, references, value[index]))
+  }
+
+  function Undefined(schema: Types.TUndefined, references: Types.TSchema[], value: any): any {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+  }
+
+  function Union(schema: Types.TUnion, references: Types.TSchema[], value: any): any {
+    return UnionValueCast.Create(schema, references, value)
+  }
+
+  function Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): any {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+  }
+
+  function Unknown(schema: Types.TUnknown, references: Types.TSchema[], value: any): any {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+  }
+
+  function Void(schema: Types.TVoid, references: Types.TSchema[], value: any): any {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+  }
+
+  export function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
+    const anyReferences = schema.$id === undefined ? references : [schema, ...references]
+    const anySchema = schema as any
+    switch (schema[Types.Kind]) {
+      case 'Any':
+        return Any(anySchema, anyReferences, value)
+      case 'Array':
+        return Array(anySchema, anyReferences, value)
+      case 'Boolean':
+        return Boolean(anySchema, anyReferences, value)
+      case 'Constructor':
+        return Constructor(anySchema, anyReferences, value)
+      case 'Enum':
+        return Enum(anySchema, anyReferences, value)
+      case 'Function':
+        return Function(anySchema, anyReferences, value)
+      case 'Integer':
+        return Integer(anySchema, anyReferences, value)
+      case 'Literal':
+        return Literal(anySchema, anyReferences, value)
+      case 'Never':
+        return Never(anySchema, anyReferences, value)
+      case 'Null':
+        return Null(anySchema, anyReferences, value)
+      case 'Number':
+        return Number(anySchema, anyReferences, value)
+      case 'Object':
+        return Object(anySchema, anyReferences, value)
+      case 'Promise':
+        return Promise(anySchema, anyReferences, value)
+      case 'Record':
+        return Record(anySchema, anyReferences, value)
+      case 'Rec':
+        return Recursive(anySchema, anyReferences, value)
+      case 'Ref':
+        return Ref(anySchema, anyReferences, value)
+      case 'Self':
+        return Self(anySchema, anyReferences, value)
+      case 'String':
+        return String(anySchema, anyReferences, value)
+      case 'Tuple':
+        return Tuple(anySchema, anyReferences, value)
+      case 'Undefined':
+        return Undefined(anySchema, anyReferences, value)
+      case 'Union':
+        return Union(anySchema, anyReferences, value)
+      case 'Uint8Array':
+        return Uint8Array(anySchema, anyReferences, value)
+      case 'Unknown':
+        return Unknown(anySchema, anyReferences, value)
+      case 'Void':
+        return Void(anySchema, anyReferences, value)
+      default:
+        throw new ValueCastUnknownTypeError(anySchema)
+    }
+  }
+
+  export function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: any): Types.Static<T> {
+    return schema.$id === undefined ? Visit(schema, references, value) : Visit(schema, [schema, ...references], value)
+  }
+}
diff --git a/src/value/check.ts b/src/value/check.ts
new file mode 100644
index 000000000..b4f7bafcf
--- /dev/null
+++ b/src/value/check.ts
@@ -0,0 +1,331 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '../typebox'
+import { Format } from '../format'
+
+export class ValueCheckUnknownTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('ValueCheck: Unknown type')
+  }
+}
+
+export namespace ValueCheck {
+  function Any(schema: Types.TAny, references: Types.TSchema[], value: any): boolean {
+    return true
+  }
+  function Array(schema: Types.TArray, references: Types.TSchema[], value: any): boolean {
+    if (!globalThis.Array.isArray(value)) {
+      return false
+    }
+    if (schema.minItems !== undefined && !(value.length >= schema.minItems)) {
+      return false
+    }
+    if (schema.maxItems !== undefined && !(value.length <= schema.maxItems)) {
+      return false
+    }
+    if (schema.uniqueItems === true && !(new Set(value).size === value.length)) {
+      return false
+    }
+    return value.every((val) => Visit(schema.items, references, val))
+  }
+
+  function Boolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): boolean {
+    return typeof value === 'boolean'
+  }
+
+  function Constructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): boolean {
+    return Visit(schema.returns, references, value.prototype)
+  }
+
+  function Function(schema: Types.TFunction, references: Types.TSchema[], value: any): boolean {
+    return typeof value === 'function'
+  }
+
+  function Integer(schema: Types.TNumeric, references: Types.TSchema[], value: any): boolean {
+    if (!(typeof value === 'number')) {
+      return false
+    }
+    if (!globalThis.Number.isInteger(value)) {
+      return false
+    }
+    if (schema.multipleOf !== undefined && !(value % schema.multipleOf === 0)) {
+      return false
+    }
+    if (schema.exclusiveMinimum !== undefined && !(value > schema.exclusiveMinimum)) {
+      return false
+    }
+    if (schema.exclusiveMaximum !== undefined && !(value < schema.exclusiveMaximum)) {
+      return false
+    }
+    if (schema.minimum !== undefined && !(value >= schema.minimum)) {
+      return false
+    }
+    if (schema.maximum !== undefined && !(value <= schema.maximum)) {
+      return false
+    }
+    return true
+  }
+
+  function Literal(schema: Types.TLiteral, references: Types.TSchema[], value: any): boolean {
+    return value === schema.const
+  }
+
+  function Never(schema: Types.TNever, references: Types.TSchema[], value: any): boolean {
+    return false
+  }
+
+  function Null(schema: Types.TNull, references: Types.TSchema[], value: any): boolean {
+    return value === null
+  }
+
+  function Number(schema: Types.TNumeric, references: Types.TSchema[], value: any): boolean {
+    if (!(typeof value === 'number')) {
+      return false
+    }
+    if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
+      return false
+    }
+    if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
+      return false
+    }
+    if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
+      return false
+    }
+    if (schema.minimum && !(value >= schema.minimum)) {
+      return false
+    }
+    if (schema.maximum && !(value <= schema.maximum)) {
+      return false
+    }
+    return true
+  }
+
+  function Object(schema: Types.TObject, references: Types.TSchema[], value: any): boolean {
+    if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+      return false
+    }
+    if (schema.minProperties !== undefined && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
+      return false
+    }
+    if (schema.maxProperties !== undefined && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
+      return false
+    }
+    const propertyKeys = globalThis.Object.keys(schema.properties)
+    if (schema.additionalProperties === false) {
+      // optimization: If the property key length matches the required keys length
+      // then we only need check that the values property key length matches that
+      // of the property key length. This is because exhaustive testing for values
+      // will occur in subsequent property tests.
+      if (schema.required && schema.required.length === propertyKeys.length && !(globalThis.Object.keys(value).length === propertyKeys.length)) {
+        return false
+      } else {
+        if (!globalThis.Object.keys(value).every((key) => propertyKeys.includes(key))) {
+          return false
+        }
+      }
+    }
+    for (const propertyKey of propertyKeys) {
+      const propertySchema = schema.properties[propertyKey]
+      if (schema.required && schema.required.includes(propertyKey)) {
+        if (!Visit(propertySchema, references, value[propertyKey])) {
+          return false
+        }
+      } else {
+        if (value[propertyKey] !== undefined) {
+          if (!Visit(propertySchema, references, value[propertyKey])) {
+            return false
+          }
+        }
+      }
+    }
+    return true
+  }
+
+  function Promise(schema: Types.TPromise<any>, references: Types.TSchema[], value: any): boolean {
+    return typeof value === 'object' && typeof value.then === 'function'
+  }
+
+  function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): boolean {
+    if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+      return false
+    }
+    const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
+    const regex = new RegExp(keyPattern)
+    if (!globalThis.Object.keys(value).every((key) => regex.test(key))) {
+      return false
+    }
+    for (const propValue of globalThis.Object.values(value)) {
+      if (!Visit(valueSchema, references, propValue)) return false
+    }
+    return true
+  }
+
+  function Ref(schema: Types.TRef<any>, references: Types.TSchema[], value: any): boolean {
+    const reference = references.find((reference) => reference.$id === schema.$ref)
+    if (reference === undefined) throw new Error(`ValueCheck.Ref: Cannot find schema with $id '${schema.$ref}'.`)
+    return Visit(reference, references, value)
+  }
+
+  function Self(schema: Types.TSelf, references: Types.TSchema[], value: any): boolean {
+    const reference = references.find((reference) => reference.$id === schema.$ref)
+    if (reference === undefined) throw new Error(`ValueCheck.Self: Cannot find schema with $id '${schema.$ref}'.`)
+    return Visit(reference, references, value)
+  }
+
+  function String(schema: Types.TString, references: Types.TSchema[], value: any): boolean {
+    if (!(typeof value === 'string')) {
+      return false
+    }
+    if (schema.minLength !== undefined) {
+      if (!(value.length >= schema.minLength)) return false
+    }
+    if (schema.maxLength !== undefined) {
+      if (!(value.length <= schema.maxLength)) return false
+    }
+    if (schema.pattern !== undefined) {
+      const regex = new RegExp(schema.pattern)
+      if (!regex.test(value)) return false
+    }
+    if (schema.format !== undefined) {
+      if (!Format.Has(schema.format)) return false
+      const func = Format.Get(schema.format)!
+      return func(value)
+    }
+    return true
+  }
+
+  function Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): boolean {
+    if (!globalThis.Array.isArray(value)) {
+      return false
+    }
+    if (schema.items === undefined && !(value.length === 0)) {
+      return false
+    }
+    if (!(value.length === schema.maxItems)) {
+      return false
+    }
+    if (!schema.items) {
+      return true
+    }
+    for (let i = 0; i < schema.items.length; i++) {
+      if (!Visit(schema.items[i], references, value[i])) return false
+    }
+    return true
+  }
+
+  function Undefined(schema: Types.TUndefined, references: Types.TSchema[], value: any): boolean {
+    return value === undefined
+  }
+
+  function Union(schema: Types.TUnion<any[]>, references: Types.TSchema[], value: any): boolean {
+    return schema.anyOf.some((inner) => Visit(inner, references, value))
+  }
+
+  function Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): boolean {
+    if (!(value instanceof globalThis.Uint8Array)) {
+      return false
+    }
+    if (schema.maxByteLength && !(value.length <= schema.maxByteLength)) {
+      return false
+    }
+    if (schema.minByteLength && !(value.length >= schema.minByteLength)) {
+      return false
+    }
+    return true
+  }
+
+  function Unknown(schema: Types.TUnknown, references: Types.TSchema[], value: any): boolean {
+    return true
+  }
+
+  function Void(schema: Types.TVoid, references: Types.TSchema[], value: any): boolean {
+    return value === null
+  }
+
+  function Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): boolean {
+    const anyReferences = schema.$id === undefined ? references : [schema, ...references]
+    const anySchema = schema as any
+    switch (anySchema[Types.Kind]) {
+      case 'Any':
+        return Any(anySchema, anyReferences, value)
+      case 'Array':
+        return Array(anySchema, anyReferences, value)
+      case 'Boolean':
+        return Boolean(anySchema, anyReferences, value)
+      case 'Constructor':
+        return Constructor(anySchema, anyReferences, value)
+      case 'Function':
+        return Function(anySchema, anyReferences, value)
+      case 'Integer':
+        return Integer(anySchema, anyReferences, value)
+      case 'Literal':
+        return Literal(anySchema, anyReferences, value)
+      case 'Never':
+        return Never(anySchema, anyReferences, value)
+      case 'Null':
+        return Null(anySchema, anyReferences, value)
+      case 'Number':
+        return Number(anySchema, anyReferences, value)
+      case 'Object':
+        return Object(anySchema, anyReferences, value)
+      case 'Promise':
+        return Promise(anySchema, anyReferences, value)
+      case 'Record':
+        return Record(anySchema, anyReferences, value)
+      case 'Ref':
+        return Ref(anySchema, anyReferences, value)
+      case 'Self':
+        return Self(anySchema, anyReferences, value)
+      case 'String':
+        return String(anySchema, anyReferences, value)
+      case 'Tuple':
+        return Tuple(anySchema, anyReferences, value)
+      case 'Undefined':
+        return Undefined(anySchema, anyReferences, value)
+      case 'Union':
+        return Union(anySchema, anyReferences, value)
+      case 'Uint8Array':
+        return Uint8Array(anySchema, anyReferences, value)
+      case 'Unknown':
+        return Unknown(anySchema, anyReferences, value)
+      case 'Void':
+        return Void(anySchema, anyReferences, value)
+      default:
+        throw new ValueCheckUnknownTypeError(anySchema)
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Check
+  // -------------------------------------------------------------------------
+
+  export function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: any): boolean {
+    return schema.$id === undefined ? Visit(schema, references, value) : Visit(schema, [schema, ...references], value)
+  }
+}
diff --git a/src/value/clone.ts b/src/value/clone.ts
new file mode 100644
index 000000000..03b06c913
--- /dev/null
+++ b/src/value/clone.ts
@@ -0,0 +1,62 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Is, ObjectType, ArrayType, TypedArrayType, ValueType } from './is'
+
+export namespace ValueClone {
+  function Object(value: ObjectType): any {
+    const keys = [...globalThis.Object.keys(value), ...globalThis.Object.getOwnPropertySymbols(value)]
+    return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {})
+  }
+
+  function Array(value: ArrayType): any {
+    return value.map((element: any) => Clone(element))
+  }
+
+  function TypedArray(value: TypedArrayType): any {
+    return value.slice()
+  }
+
+  function Value(value: ValueType): any {
+    return value
+  }
+
+  export function Clone<T extends unknown>(value: T): T {
+    if (Is.Object(value)) {
+      return Object(value)
+    } else if (Is.Array(value)) {
+      return Array(value)
+    } else if (Is.TypedArray(value)) {
+      return TypedArray(value)
+    } else if (Is.Value(value)) {
+      return Value(value)
+    } else {
+      throw new Error('ValueClone: Unable to clone value')
+    }
+  }
+}
diff --git a/src/value/create.ts b/src/value/create.ts
new file mode 100644
index 000000000..5cd549096
--- /dev/null
+++ b/src/value/create.ts
@@ -0,0 +1,342 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '../typebox'
+
+export class ValueCreateUnknownTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('ValueCreate: Unknown type')
+  }
+}
+
+export class ValueCreateNeverTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('ValueCreate: Never types cannot be created')
+  }
+}
+
+export namespace ValueCreate {
+  function Any(schema: Types.TAny, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else {
+      return {}
+    }
+  }
+
+  function Array(schema: Types.TArray, references: Types.TSchema[]): any {
+    if (schema.uniqueItems === true && schema.default === undefined) {
+      throw new Error('ValueCreate.Array: Arrays with uniqueItems require a default value')
+    } else if (schema.default !== undefined) {
+      return schema.default
+    } else if (schema.minItems !== undefined) {
+      return globalThis.Array.from({ length: schema.minItems }).map((item) => {
+        return ValueCreate.Create(schema.items, references)
+      })
+    } else {
+      return []
+    }
+  }
+
+  function Boolean(schema: Types.TBoolean, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else {
+      return false
+    }
+  }
+
+  function Constructor(schema: Types.TConstructor, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else {
+      const value = ValueCreate.Create(schema.returns, references) as any
+      if (typeof value === 'object' && !globalThis.Array.isArray(value)) {
+        return class {
+          constructor() {
+            for (const [key, val] of globalThis.Object.entries(value)) {
+              const self = this as any
+              self[key] = val
+            }
+          }
+        }
+      } else {
+        return class {}
+      }
+    }
+  }
+
+  function Enum(schema: Types.TEnum<any>, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else if (schema.anyOf.length === 0) {
+      throw new Error('ValueCreate.Enum: Cannot create default enum value as this enum has no items')
+    } else {
+      return schema.anyOf[0].const
+    }
+  }
+
+  function Function(schema: Types.TFunction, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else {
+      return () => ValueCreate.Create(schema.returns, references)
+    }
+  }
+
+  function Integer(schema: Types.TInteger, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else if (schema.minimum !== undefined) {
+      return schema.minimum
+    } else {
+      return 0
+    }
+  }
+
+  function Literal(schema: Types.TLiteral, references: Types.TSchema[]): any {
+    return schema.const
+  }
+
+  function Never(schema: Types.TNever, references: Types.TSchema[]): any {
+    throw new ValueCreateNeverTypeError(schema)
+  }
+
+  function Null(schema: Types.TNull, references: Types.TSchema[]): any {
+    return null
+  }
+
+  function Number(schema: Types.TNumber, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else if (schema.minimum !== undefined) {
+      return schema.minimum
+    } else {
+      return 0
+    }
+  }
+
+  function Object(schema: Types.TObject, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else {
+      const required = new Set(schema.required)
+      return (
+        schema.default ||
+        globalThis.Object.entries(schema.properties).reduce((acc, [key, schema]) => {
+          return required.has(key) ? { ...acc, [key]: ValueCreate.Create(schema, references) } : { ...acc }
+        }, {})
+      )
+    }
+  }
+
+  function Promise(schema: Types.TPromise<any>, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else {
+      return globalThis.Promise.resolve(ValueCreate.Create(schema.item, references))
+    }
+  }
+
+  function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[]): any {
+    const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
+    if (schema.default !== undefined) {
+      return schema.default
+    } else if (!(keyPattern === '^.*$' || keyPattern === '^(0|[1-9][0-9]*)$')) {
+      const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|')
+      return propertyKeys.reduce((acc, key) => {
+        return { ...acc, [key]: Create(valueSchema, references) }
+      }, {})
+    } else {
+      return {}
+    }
+  }
+
+  function Recursive(schema: Types.TRecursive<any>, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else {
+      throw new Error('ValueCreate.Recursive: Recursive types require a default value')
+    }
+  }
+
+  function Ref(schema: Types.TRef<any>, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else {
+      const reference = references.find((reference) => reference.$id === schema.$ref)
+      if (reference === undefined) throw new Error(`ValueCreate.Ref: Cannot find schema with $id '${schema.$ref}'.`)
+      return Visit(reference, references)
+    }
+  }
+
+  function Self(schema: Types.TSelf, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else {
+      const reference = references.find((reference) => reference.$id === schema.$ref)
+      if (reference === undefined) throw new Error(`ValueCreate.Self: Cannot locate schema with $id '${schema.$ref}'`)
+      return Visit(reference, references)
+    }
+  }
+
+  function String(schema: Types.TString, references: Types.TSchema[]): any {
+    if (schema.pattern !== undefined) {
+      if (schema.default === undefined) {
+        throw new Error('ValueCreate.String: String types with patterns must specify a default value')
+      } else {
+        return schema.default
+      }
+    } else if (schema.format !== undefined) {
+      if (schema.default === undefined) {
+        throw new Error('ValueCreate.String: String types with formats must specify a default value')
+      } else {
+        return schema.default
+      }
+    } else {
+      if (schema.default !== undefined) {
+        return schema.default
+      } else if (schema.minLength !== undefined) {
+        return globalThis.Array.from({ length: schema.minLength })
+          .map(() => '.')
+          .join('')
+      } else {
+        return ''
+      }
+    }
+  }
+
+  function Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    }
+    if (schema.items === undefined) {
+      return []
+    } else {
+      return globalThis.Array.from({ length: schema.minItems }).map((_, index) => ValueCreate.Create((schema.items as any[])[index], references))
+    }
+  }
+
+  function Undefined(schema: Types.TUndefined, references: Types.TSchema[]): any {
+    return undefined
+  }
+
+  function Union(schema: Types.TUnion<any[]>, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else if (schema.anyOf.length === 0) {
+      throw new Error('ValueCreate.Union: Cannot create Union with zero variants')
+    } else {
+      return ValueCreate.Create(schema.anyOf[0], references)
+    }
+  }
+  function Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else if (schema.minByteLength !== undefined) {
+      return new globalThis.Uint8Array(schema.minByteLength)
+    } else {
+      return new globalThis.Uint8Array(0)
+    }
+  }
+
+  function Unknown(schema: Types.TUnknown, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else {
+      return {}
+    }
+  }
+
+  function Void(schema: Types.TVoid, references: Types.TSchema[]): any {
+    return null
+  }
+
+  /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
+  export function Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T> {
+    const anyReferences = schema.$id === undefined ? references : [schema, ...references]
+    const anySchema = schema as any
+
+    switch (anySchema[Types.Kind]) {
+      case 'Any':
+        return Any(anySchema, anyReferences)
+      case 'Array':
+        return Array(anySchema, anyReferences)
+      case 'Boolean':
+        return Boolean(anySchema, anyReferences)
+      case 'Constructor':
+        return Constructor(anySchema, anyReferences)
+      case 'Enum':
+        return Enum(anySchema, anyReferences)
+      case 'Function':
+        return Function(anySchema, anyReferences)
+      case 'Integer':
+        return Integer(anySchema, anyReferences)
+      case 'Literal':
+        return Literal(anySchema, anyReferences)
+      case 'Never':
+        return Never(anySchema, anyReferences)
+      case 'Null':
+        return Null(anySchema, anyReferences)
+      case 'Number':
+        return Number(anySchema, anyReferences)
+      case 'Object':
+        return Object(anySchema, anyReferences)
+      case 'Promise':
+        return Promise(anySchema, anyReferences)
+      case 'Record':
+        return Record(anySchema, anyReferences)
+      case 'Rec':
+        return Recursive(anySchema, anyReferences)
+      case 'Ref':
+        return Ref(anySchema, anyReferences)
+      case 'Self':
+        return Self(anySchema, anyReferences)
+      case 'String':
+        return String(anySchema, anyReferences)
+      case 'Tuple':
+        return Tuple(anySchema, anyReferences)
+      case 'Undefined':
+        return Undefined(anySchema, anyReferences)
+      case 'Union':
+        return Union(anySchema, anyReferences)
+      case 'Uint8Array':
+        return Uint8Array(anySchema, anyReferences)
+      case 'Unknown':
+        return Unknown(anySchema, anyReferences)
+      case 'Void':
+        return Void(anySchema, anyReferences)
+      default:
+        throw new ValueCreateUnknownTypeError(anySchema)
+    }
+  }
+
+  export function Create<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R]): Types.Static<T> {
+    return Visit(schema, references)
+  }
+}
diff --git a/src/value/delta.ts b/src/value/delta.ts
new file mode 100644
index 000000000..371a11f2c
--- /dev/null
+++ b/src/value/delta.ts
@@ -0,0 +1,182 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Is, ObjectType, ArrayType, TypedArrayType, ValueType } from './is'
+import { ValueClone } from './clone'
+import { ValuePointer } from './pointer'
+
+export type Edit<T = unknown> = Insert<T> | Update<T> | Delete<T>
+
+export interface Insert<T> {
+  brand: T
+  type: 'insert'
+  path: string
+  value: any
+}
+
+export interface Update<T> {
+  brand: T
+  type: 'update'
+  path: string
+  value: any
+}
+
+export interface Delete<T> {
+  brand: T
+  type: 'delete'
+  path: string
+}
+
+export namespace ValueDelta {
+  // ---------------------------------------------------------------------
+  // Edits
+  // ---------------------------------------------------------------------
+
+  function Update(path: string, value: unknown): Edit<any> {
+    return { type: 'update', path, value } as any
+  }
+
+  function Insert(path: string, value: unknown): Edit<any> {
+    return { type: 'insert', path, value } as any
+  }
+
+  function Delete(path: string): Edit<any> {
+    return { type: 'delete', path } as any
+  }
+
+  // ---------------------------------------------------------------------
+  // Diff
+  // ---------------------------------------------------------------------
+
+  function* Object(path: string, current: ObjectType, next: unknown): IterableIterator<Edit<any>> {
+    if (!Is.Object(next)) return yield Update(path, next)
+    const currentKeys = [...globalThis.Object.keys(current), ...globalThis.Object.getOwnPropertySymbols(current)]
+    const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)]
+    for (const key of currentKeys) {
+      if (typeof key === 'symbol') throw Error('ValueDelta: Cannot produce diff symbol keys')
+      if (next[key] === undefined && nextKeys.includes(key)) yield Update(`${path}/${String(key)}`, undefined)
+    }
+    for (const key of nextKeys) {
+      if (current[key] === undefined || next[key] === undefined) continue
+      if (typeof key === 'symbol') throw Error('ValueDelta: Cannot produce diff symbol keys')
+      yield* Visit(`${path}/${String(key)}`, current[key], next[key])
+    }
+    for (const key of nextKeys) {
+      if (typeof key === 'symbol') throw Error('ValueDelta: Cannot produce diff symbol keys')
+      if (current[key] === undefined) yield Insert(`${path}/${String(key)}`, next[key])
+    }
+    for (const key of currentKeys.reverse()) {
+      if (typeof key === 'symbol') throw Error('ValueDelta: Cannot produce diff symbol keys')
+      if (next[key] === undefined && !nextKeys.includes(key)) yield Delete(`${path}/${String(key)}`)
+    }
+  }
+
+  function* Array(path: string, current: ArrayType, next: unknown): IterableIterator<Edit<any>> {
+    if (!Is.Array(next)) return yield Update(path, next)
+    for (let i = 0; i < Math.min(current.length, next.length); i++) {
+      yield* Visit(`${path}/${i}`, current[i], next[i])
+    }
+    for (let i = 0; i < next.length; i++) {
+      if (i < current.length) continue
+      yield Insert(`${path}/${i}`, next[i])
+    }
+    for (let i = current.length - 1; i >= 0; i--) {
+      if (i < next.length) continue
+      yield Delete(`${path}/${i}`)
+    }
+  }
+
+  function* TypedArray(path: string, current: TypedArrayType, next: unknown): IterableIterator<Edit<any>> {
+    if (!Is.TypedArray(next) || current.length !== next.length || globalThis.Object.getPrototypeOf(current).constructor.name !== globalThis.Object.getPrototypeOf(next).constructor.name) return yield Update(path, next)
+    for (let i = 0; i < Math.min(current.length, next.length); i++) {
+      yield* Visit(`${path}/${i}`, current[i], next[i])
+    }
+  }
+
+  function* Value(path: string, current: ValueType, next: unknown): IterableIterator<Edit<any>> {
+    if (current === next) return
+    yield Update(path, next)
+  }
+
+  function* Visit(path: string, current: unknown, next: unknown): IterableIterator<Edit<any>> {
+    if (Is.Object(current)) {
+      return yield* Object(path, current, next)
+    } else if (Is.Array(current)) {
+      return yield* Array(path, current, next)
+    } else if (Is.TypedArray(current)) {
+      return yield* TypedArray(path, current, next)
+    } else if (Is.Value(current)) {
+      return yield* Value(path, current, next)
+    } else {
+      throw new Error('ValueDelta: Cannot produce edits for value')
+    }
+  }
+
+  export function Diff<T>(current: T, next: T): Edit<T>[] {
+    return [...Visit('', current, next)]
+  }
+
+  // ---------------------------------------------------------------------
+  // Patch
+  // ---------------------------------------------------------------------
+
+  function IsRootUpdate<T>(edits: Edit<T>[]): edits is [Update<T>] {
+    return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update'
+  }
+
+  function IsIdentity<T>(edits: Edit<T>[]) {
+    return edits.length === 0
+  }
+
+  export function Patch<T>(current: T, edits: Edit<T>[]): T {
+    if (IsRootUpdate(edits)) {
+      return ValueClone.Clone(edits[0].value)
+    }
+    if (IsIdentity(edits)) {
+      return ValueClone.Clone(current)
+    }
+    const clone = ValueClone.Clone(current)
+    for (const edit of edits) {
+      switch (edit.type) {
+        case 'insert': {
+          ValuePointer.Set(clone, edit.path, edit.value)
+          break
+        }
+        case 'update': {
+          ValuePointer.Set(clone, edit.path, edit.value)
+          break
+        }
+        case 'delete': {
+          ValuePointer.Delete(clone, edit.path)
+          break
+        }
+      }
+    }
+    return clone
+  }
+}
diff --git a/src/value/equal.ts b/src/value/equal.ts
new file mode 100644
index 000000000..773f2d3c1
--- /dev/null
+++ b/src/value/equal.ts
@@ -0,0 +1,67 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Is, ObjectType, ArrayType, TypedArrayType, ValueType } from './is'
+
+export namespace ValueEqual {
+  function Object(left: ObjectType, right: unknown): boolean {
+    if (!Is.Object(right)) return false
+    const leftKeys = [...globalThis.Object.keys(left), ...globalThis.Object.getOwnPropertySymbols(left)]
+    const rightKeys = [...globalThis.Object.keys(right), ...globalThis.Object.getOwnPropertySymbols(right)]
+    if (leftKeys.length !== rightKeys.length) return false
+    return leftKeys.every((key) => Equal(left[key], right[key]))
+  }
+
+  function Array(left: ArrayType, right: unknown): any {
+    if (!Is.Array(right) || left.length !== right.length) return false
+    return left.every((value, index) => Equal(value, right[index]))
+  }
+
+  function TypedArray(left: TypedArrayType, right: unknown): any {
+    if (!Is.TypedArray(right) || left.length !== right.length || globalThis.Object.getPrototypeOf(left).constructor.name !== globalThis.Object.getPrototypeOf(right).constructor.name) return false
+    return left.every((value, index) => Equal(value, right[index]))
+  }
+
+  function Value(left: ValueType, right: unknown): any {
+    return left === right
+  }
+
+  export function Equal<T>(left: T, right: unknown): right is T {
+    if (Is.Object(left)) {
+      return Object(left, right)
+    } else if (Is.TypedArray(left)) {
+      return TypedArray(left, right)
+    } else if (Is.Array(left)) {
+      return Array(left, right)
+    } else if (Is.Value(left)) {
+      return Value(left, right)
+    } else {
+      throw new Error('ValueEquals: Unable to compare value')
+    }
+  }
+}
diff --git a/src/value/index.ts b/src/value/index.ts
new file mode 100644
index 000000000..f96cee562
--- /dev/null
+++ b/src/value/index.ts
@@ -0,0 +1,31 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export { ValueError, ValueErrorType } from '../errors/index'
+export * from './pointer'
+export * from './value'
diff --git a/src/value/is.ts b/src/value/is.ts
new file mode 100644
index 000000000..729197d59
--- /dev/null
+++ b/src/value/is.ts
@@ -0,0 +1,50 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export type ValueType = null | undefined | Function | symbol | bigint | number | boolean | string
+export type ObjectType = Record<string | number | symbol, unknown>
+export type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array
+export type ArrayType = unknown[]
+
+export namespace Is {
+  export function Object(value: unknown): value is ObjectType {
+    return value !== null && typeof value === 'object' && !globalThis.Array.isArray(value) && !ArrayBuffer.isView(value)
+  }
+
+  export function Array(value: unknown): value is ArrayType {
+    return globalThis.Array.isArray(value) && !ArrayBuffer.isView(value)
+  }
+
+  export function Value(value: unknown): value is ValueType {
+    return value === null || value === undefined || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'bigint' || typeof value === 'number' || typeof value === 'boolean' || typeof value === 'string'
+  }
+
+  export function TypedArray(value: unknown): value is TypedArrayType {
+    return ArrayBuffer.isView(value)
+  }
+}
diff --git a/src/value/pointer.ts b/src/value/pointer.ts
new file mode 100644
index 000000000..4b7c5bf9c
--- /dev/null
+++ b/src/value/pointer.ts
@@ -0,0 +1,122 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export class ValuePointerRootSetError extends Error {
+  constructor(public readonly value: unknown, public readonly path: string, public readonly update: unknown) {
+    super('ValuePointer: Cannot set root value')
+  }
+}
+
+export class ValuePointerRootDeleteError extends Error {
+  constructor(public readonly value: unknown, public readonly path: string) {
+    super('ValuePointer: Cannot delete root value')
+  }
+}
+
+/** ValuePointer performs mutable operations on values using RFC6901 Json Pointers */
+export namespace ValuePointer {
+  function Escape(component: string) {
+    return component.indexOf('~') === -1 ? component : component.replace(/~1/g, '/').replace(/~0/g, '~')
+  }
+
+  /** Formats the given pointer into navigable key components */
+  export function* Format(pointer: string): IterableIterator<string> {
+    if (pointer === '') return
+    let [start, end] = [0, 0]
+    for (let i = 0; i < pointer.length; i++) {
+      const char = pointer.charAt(i)
+      if (char === '/') {
+        if (i === 0) {
+          start = i + 1
+        } else {
+          end = i
+          yield Escape(pointer.slice(start, end))
+          start = i + 1
+        }
+      } else {
+        end = i
+      }
+    }
+    yield Escape(pointer.slice(start))
+  }
+
+  /** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
+  export function Set(value: any, pointer: string, update: unknown): void {
+    if (pointer === '') throw new ValuePointerRootSetError(value, pointer, update)
+    let [owner, next, key] = [null as any, value, '']
+    for (const component of Format(pointer)) {
+      if (next[component] === undefined) next[component] = {}
+      owner = next
+      next = next[component]
+      key = component
+    }
+    owner[key] = update
+  }
+
+  /** Deletes a value at the given pointer */
+  export function Delete(value: any, pointer: string): void {
+    if (pointer === '') throw new ValuePointerRootDeleteError(value, pointer)
+    let [owner, next, key] = [null as any, value as any, '']
+    for (const component of Format(pointer)) {
+      if (next[component] === undefined || next[component] === null) return
+      owner = next
+      next = next[component]
+      key = component
+    }
+    if (globalThis.Array.isArray(owner)) {
+      const index = parseInt(key)
+      owner.splice(index, 1)
+    } else {
+      delete owner[key]
+    }
+  }
+
+  /** Returns true if a value exists at the given pointer */
+  export function Has(value: any, pointer: string): boolean {
+    if (pointer === '') return true
+    let [owner, next, key] = [null as any, value as any, '']
+    for (const component of Format(pointer)) {
+      if (next[component] === undefined) return false
+      owner = next
+      next = next[component]
+      key = component
+    }
+    return globalThis.Object.getOwnPropertyNames(owner).includes(key)
+  }
+
+  /** Gets the value at the given pointer */
+  export function Get(value: any, pointer: string): any {
+    if (pointer === '') return value
+    let current = value
+    for (const component of Format(pointer)) {
+      if (current[component] === undefined) return undefined
+      current = current[component]
+    }
+    return current
+  }
+}
diff --git a/src/value/value.ts b/src/value/value.ts
new file mode 100644
index 000000000..ff0f27872
--- /dev/null
+++ b/src/value/value.ts
@@ -0,0 +1,97 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '../typebox'
+import { ValueErrors, ValueError } from '../errors/index'
+import { ValueEqual } from './equal'
+import { ValueCast } from './cast'
+import { ValueClone } from './clone'
+import { ValueCreate } from './create'
+import { ValueCheck } from './check'
+import { ValueDelta, Edit } from './delta'
+
+export type { Edit } from './delta'
+
+/** Value performs immutable operations on values */
+export namespace Value {
+  /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number and boolean values if a reasonable conversion is possible. */
+  export function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): Types.Static<T>
+  /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number and boolean values if a reasonable conversion is possible. */
+  export function Cast<T extends Types.TSchema>(schema: T, value: unknown): Types.Static<T>
+  export function Cast(...args: any[]) {
+    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
+    return ValueCast.Cast(schema, references, value)
+  }
+
+  /** Creates a value from the given type */
+  export function Create<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R]): Types.Static<T>
+  /** Creates a value from the given type */
+  export function Create<T extends Types.TSchema>(schema: T): Types.Static<T>
+  export function Create(...args: any[]) {
+    const [schema, references] = args.length === 2 ? [args[0], args[1]] : [args[0], []]
+    return ValueCreate.Create(schema, references)
+  }
+
+  /** Returns true if the value matches the given type. */
+  export function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): value is Types.Static<T>
+  /** Returns true if the value matches the given type. */
+  export function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>
+  export function Check(...args: any[]) {
+    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
+    return ValueCheck.Check(schema, references, value)
+  }
+
+  /** Returns an iterator for each error in this value. */
+  export function Errors<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): IterableIterator<ValueError>
+  /** Returns an iterator for each error in this value. */
+  export function Errors<T extends Types.TSchema>(schema: T, value: unknown): IterableIterator<ValueError>
+  export function* Errors(...args: any[]) {
+    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
+    yield* ValueErrors.Errors(schema, references, value)
+  }
+
+  /** Returns true if left and right values are structurally equal */
+  export function Equal<T>(left: T, right: unknown): right is T {
+    return ValueEqual.Equal(left, right)
+  }
+
+  /** Returns a structural clone of the given value */
+  export function Clone<T>(value: T): T {
+    return ValueClone.Clone(value)
+  }
+
+  /** Returns edits to transform the current value into the next value */
+  export function Diff<T>(current: T, next: T): Edit<T>[] {
+    return ValueDelta.Diff(current, next)
+  }
+
+  /** Returns a new value with edits applied to the given value */
+  export function Patch<T>(current: T, edits: Edit<T>[]): T {
+    return ValueDelta.Patch(current, edits) as T
+  }
+}
diff --git a/test/runtime/assert/assert.ts b/test/runtime/assert/assert.ts
new file mode 100644
index 000000000..19543636d
--- /dev/null
+++ b/test/runtime/assert/assert.ts
@@ -0,0 +1,59 @@
+import * as assert from 'assert'
+
+export namespace Assert {
+  let port = 9000
+  /** Generates a new port used for host binding */
+  export function nextPort() {
+    const next = port++
+    return next
+  }
+
+  export function equal(actual: unknown, expect: unknown) {
+    return assert.equal(actual, expect)
+  }
+
+  export function notEqual(actual: unknown, expect: unknown) {
+    return assert.notEqual(actual, expect)
+  }
+
+  export function deepEqual(actual: unknown, expect: unknown) {
+    if (actual instanceof Uint8Array && expect instanceof Uint8Array) {
+      assert.equal(actual.length, expect.length)
+      for (let i = 0; i < actual.length; i++) assert.equal(actual[i], expect[i])
+    }
+    return assert.deepEqual(actual, expect)
+  }
+
+  let nextIdOrdinal = 0
+  export function nextId() {
+    return `nextID${nextIdOrdinal++}`
+  }
+
+  export function throws(callback: Function) {
+    try {
+      callback()
+    } catch {
+      return
+    }
+    throw Error('Expected throw')
+  }
+
+  export async function throwsAsync(callback: Function) {
+    try {
+      await callback()
+    } catch {
+      return
+    }
+    throw Error('Expected throw')
+  }
+
+  export function isTypeOf(value: any, type: any) {
+    if (typeof value === type) return
+    throw Error(`Value is not typeof ${type}`)
+  }
+
+  export function isInstanceOf(value: any, constructor: any) {
+    if (value instanceof constructor) return
+    throw Error(`Value is not instance of ${constructor}`)
+  }
+}
diff --git a/test/runtime/assert/index.ts b/test/runtime/assert/index.ts
new file mode 100644
index 000000000..c3bd55138
--- /dev/null
+++ b/test/runtime/assert/index.ts
@@ -0,0 +1 @@
+export * from './assert'
diff --git a/test/runtime/compiler/any.ts b/test/runtime/compiler/any.ts
new file mode 100644
index 000000000..fdccc5f61
--- /dev/null
+++ b/test/runtime/compiler/any.ts
@@ -0,0 +1,33 @@
+import { Type } from '@sinclair/typebox'
+import { ok } from './validate'
+
+describe('type/compiler/Any', () => {
+  it('Should validate number', () => {
+    const T = Type.Any()
+    ok(T, 1)
+  })
+  it('Should validate string', () => {
+    const T = Type.Any()
+    ok(T, 'hello')
+  })
+  it('Should validate boolean', () => {
+    const T = Type.Any()
+    ok(T, true)
+  })
+  it('Should validate array', () => {
+    const T = Type.Any()
+    ok(T, [1, 2, 3])
+  })
+  it('Should validate object', () => {
+    const T = Type.Any()
+    ok(T, { a: 1, b: 2 })
+  })
+  it('Should validate null', () => {
+    const T = Type.Any()
+    ok(T, null)
+  })
+  it('Should validate undefined', () => {
+    const T = Type.Any()
+    ok(T, undefined)
+  })
+})
diff --git a/test/runtime/compiler/array.ts b/test/runtime/compiler/array.ts
new file mode 100644
index 000000000..f74b7b4d6
--- /dev/null
+++ b/test/runtime/compiler/array.ts
@@ -0,0 +1,97 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Array', () => {
+  it('Should validate an array of any', () => {
+    const T = Type.Array(Type.Any())
+    ok(T, [0, true, 'hello', {}])
+  })
+
+  it('Should not validate varying array when item is number', () => {
+    const T = Type.Array(Type.Number())
+    fail(T, [1, 2, 3, 'hello'])
+  })
+
+  it('Should validate for an array of unions', () => {
+    const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
+    ok(T, [1, 'hello', 3, 'world'])
+  })
+
+  it('Should not validate for an array of unions where item is not in union.', () => {
+    const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
+    fail(T, [1, 'hello', 3, 'world', true])
+  })
+
+  it('Should validate for an empty array', () => {
+    const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
+    ok(T, [])
+  })
+
+  it('Should validate for an array of intersection types', () => {
+    const A = Type.Object({ a: Type.String() })
+    const B = Type.Object({ b: Type.String() })
+    const C = Type.Intersect([A, B])
+    const T = Type.Array(C)
+    ok(T, [
+      { a: 'hello', b: 'hello' },
+      { a: 'hello', b: 'hello' },
+      { a: 'hello', b: 'hello' },
+    ])
+  })
+
+  it('Should not validate for an array of intersection types when passing additionalProperties false', () => {
+    const A = Type.Object({ a: Type.String() })
+    const B = Type.Object({ b: Type.String() })
+    const C = Type.Intersect([A, B], { additionalProperties: false })
+    const T = Type.Array(C)
+    fail(T, [
+      { a: 'hello', b: 'hello' },
+      { a: 'hello', b: 'hello' },
+      { a: 'hello', b: 'hello', c: 'additional' },
+    ])
+  })
+
+  it('Should validate an array of tuples', () => {
+    const A = Type.String()
+    const B = Type.Number()
+    const C = Type.Tuple([A, B])
+    const T = Type.Array(C)
+    ok(T, [
+      ['hello', 1],
+      ['hello', 1],
+      ['hello', 1],
+    ])
+  })
+
+  it('Should not validate an array of tuples when tuple values are incorrect', () => {
+    const A = Type.String()
+    const B = Type.Number()
+    const C = Type.Tuple([A, B])
+    const T = Type.Array(C)
+    fail(T, [
+      [1, 'hello'],
+      [1, 'hello'],
+      [1, 'hello'],
+    ])
+  })
+
+  it('Should not validate array with failed minItems', () => {
+    const T = Type.Array(Type.Number(), { minItems: 3 })
+    fail(T, [0, 1])
+  })
+  it('Should not validate array with failed maxItems', () => {
+    const T = Type.Array(Type.Number(), { maxItems: 3 })
+    fail(T, [0, 1, 2, 3])
+  })
+  it('Should validate array with uniqueItems when items are references', () => {
+    const T = Type.Array(Type.Object({ x: Type.Number(), y: Type.Number() }), { uniqueItems: true })
+    ok(T, [
+      { x: 0, y: 1 },
+      { x: 1, y: 0 },
+    ]) // references distinct
+  })
+  it('Should not validate array with non uniqueItems', () => {
+    const T = Type.Array(Type.Number(), { uniqueItems: true })
+    fail(T, [0, 0])
+  })
+})
diff --git a/test/runtime/compiler/boolean.ts b/test/runtime/compiler/boolean.ts
new file mode 100644
index 000000000..07293041f
--- /dev/null
+++ b/test/runtime/compiler/boolean.ts
@@ -0,0 +1,40 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Boolean', () => {
+  it('Should validate a boolean', () => {
+    const T = Type.Boolean()
+    ok(T, true)
+    ok(T, false)
+  })
+
+  it('Should not validate a number', () => {
+    const T = Type.Boolean()
+    fail(T, 1)
+  })
+
+  it('Should not validate a string', () => {
+    const T = Type.Boolean()
+    fail(T, 'true')
+  })
+
+  it('Should not validate an array', () => {
+    const T = Type.Boolean()
+    fail(T, [true])
+  })
+
+  it('Should not validate an object', () => {
+    const T = Type.Boolean()
+    fail(T, {})
+  })
+
+  it('Should not validate an null', () => {
+    const T = Type.Boolean()
+    fail(T, null)
+  })
+
+  it('Should not validate an undefined', () => {
+    const T = Type.Boolean()
+    fail(T, undefined)
+  })
+})
diff --git a/test/runtime/compiler/enum.ts b/test/runtime/compiler/enum.ts
new file mode 100644
index 000000000..736cee47b
--- /dev/null
+++ b/test/runtime/compiler/enum.ts
@@ -0,0 +1,56 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Enum', () => {
+  it('Should validate when emum uses default numeric values', () => {
+    enum Kind {
+      Foo, // = 0
+      Bar, // = 1
+    }
+    const T = Type.Enum(Kind)
+    ok(T, 0)
+    ok(T, 1)
+  })
+  it('Should not validate when given enum values are not numeric', () => {
+    enum Kind {
+      Foo, // = 0
+      Bar, // = 1
+    }
+    const T = Type.Enum(Kind)
+    fail(T, 'Foo')
+    fail(T, 'Bar')
+  })
+
+  it('Should validate when emum has defined string values', () => {
+    enum Kind {
+      Foo = 'foo',
+      Bar = 'bar',
+    }
+    const T = Type.Enum(Kind)
+    ok(T, 'foo')
+    ok(T, 'bar')
+  })
+
+  it('Should not validate when emum has defined string values and user passes numeric', () => {
+    enum Kind {
+      Foo = 'foo',
+      Bar = 'bar',
+    }
+    const T = Type.Enum(Kind)
+    fail(T, 0)
+    fail(T, 1)
+  })
+
+  it('Should validate when enum has one or more string values', () => {
+    enum Kind {
+      Foo,
+      Bar = 'bar',
+    }
+    const T = Type.Enum(Kind)
+    ok(T, 0)
+    ok(T, 'bar')
+    fail(T, 'baz')
+    fail(T, 'Foo')
+    fail(T, 1)
+  })
+})
diff --git a/spec/schema/index.ts b/test/runtime/compiler/index.ts
similarity index 82%
rename from spec/schema/index.ts
rename to test/runtime/compiler/index.ts
index a4a273c52..a77b5456e 100644
--- a/spec/schema/index.ts
+++ b/test/runtime/compiler/index.ts
@@ -1,12 +1,12 @@
 import './any'
 import './array'
 import './boolean'
-import './box'
 import './enum'
 import './intersect'
 import './keyof'
 import './literal'
 import './modifier'
+import './never'
 import './null'
 import './number'
 import './object'
@@ -16,13 +16,14 @@ import './partial'
 import './pick'
 import './readonly-optional'
 import './readonly'
-import './rec'
+import './recursive'
 import './record'
 import './ref'
 import './regex'
 import './required'
-import './strict'
 import './string'
 import './tuple'
+import './uint8array'
 import './union'
-import './unknown'
\ No newline at end of file
+import './unknown'
+import './void'
diff --git a/test/runtime/compiler/intersect.ts b/test/runtime/compiler/intersect.ts
new file mode 100644
index 000000000..f59d9adae
--- /dev/null
+++ b/test/runtime/compiler/intersect.ts
@@ -0,0 +1,83 @@
+import { Type, Static } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Intersect', () => {
+  it('Should intersect two objects', () => {
+    const A = Type.Object({ a: Type.String() })
+    const B = Type.Object({ b: Type.Number() })
+    const T = Type.Intersect([A, B], { additionalProperties: false })
+    ok(T, { a: 'hello', b: 42 })
+  })
+
+  it('Should intersect with partial', () => {
+    const A = Type.Partial(Type.Object({ a: Type.Number() }))
+    const B = Type.Partial(Type.Object({ b: Type.Number() }))
+    const P = Type.Intersect([A, B], { additionalProperties: false })
+    ok(P, { a: 1, b: 2 })
+    // ok(P, { a: 1 })
+    // ok(P, { b: 1 })
+    // ok(P, {})
+    // fail(P, { c: 1 })
+  })
+
+  it('Should intersect with overlapping same type', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ a: Type.Number() })
+    const P = Type.Intersect([A, B])
+    ok(P, { a: 1 })
+    fail(P, { a: 'hello' })
+    fail(P, {})
+  })
+
+  it('Should intersect with overlapping varying type', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ a: Type.String() })
+    const T = Type.Intersect([A, B])
+    ok(T, { a: 1 })
+    ok(T, { a: 'hello' })
+    fail(T, {})
+  })
+
+  it('Should intersect with deeply nest overlapping varying type', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ a: Type.String() })
+    const C = Type.Object({ a: Type.Boolean() })
+    const D = Type.Object({ a: Type.Null() })
+    const T = Type.Intersect([A, B, C, D])
+    ok(T, { a: 1 })
+    ok(T, { a: 'hello' })
+    ok(T, { a: false })
+    ok(T, { a: null })
+    fail(T, { a: [] })
+    fail(T, {})
+  })
+
+  it('Should pick from intersected type', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const C = Type.Object({ z: Type.Number() })
+    const T = Type.Intersect([A, B, C])
+    const P = Type.Pick(T, ['x', 'y'], { additionalProperties: false })
+    ok(P, { x: 1, y: 1 })
+    fail(P, { x: 1, y: 1, z: 1 })
+  })
+
+  it('Should omit from intersected type', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const C = Type.Object({ z: Type.Number() })
+    const T = Type.Intersect([A, B, C])
+    const P = Type.Omit(T, ['z'], { additionalProperties: false })
+    ok(P, { x: 1, y: 1 })
+    fail(P, { x: 1, y: 1, z: 1 })
+  })
+
+  it('Should intersect nested object properties', () => {
+    const A = Type.Object({ x: Type.Object({ x: Type.Number() }) })
+    const B = Type.Object({ x: Type.Object({ x: Type.String() }) })
+    const T = Type.Intersect([A, B])
+    ok(T, { x: { x: 1 } })
+    ok(T, { x: { x: 'hello' } })
+    fail(T, { x: { x: false } })
+  })
+})
diff --git a/test/runtime/compiler/keyof.ts b/test/runtime/compiler/keyof.ts
new file mode 100644
index 000000000..3920b1485
--- /dev/null
+++ b/test/runtime/compiler/keyof.ts
@@ -0,0 +1,52 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+import { strictEqual } from 'assert'
+
+describe('type/compiler/KeyOf', () => {
+  it('Should validate with all object keys as a kind of union', () => {
+    const T = Type.KeyOf(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+    )
+    ok(T, 'x')
+    ok(T, 'y')
+    ok(T, 'z')
+    fail(T, 'w')
+  })
+
+  it('Should validate when using pick', () => {
+    const T = Type.KeyOf(
+      Type.Pick(
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+          z: Type.Number(),
+        }),
+        ['x', 'y'],
+      ),
+    )
+    ok(T, 'x')
+    ok(T, 'y')
+    fail(T, 'z')
+  })
+
+  it('Should validate when using omit', () => {
+    const T = Type.KeyOf(
+      Type.Omit(
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+          z: Type.Number(),
+        }),
+        ['x', 'y'],
+      ),
+    )
+
+    fail(T, 'x')
+    fail(T, 'y')
+    ok(T, 'z')
+  })
+})
diff --git a/test/runtime/compiler/literal.ts b/test/runtime/compiler/literal.ts
new file mode 100644
index 000000000..1aa46921f
--- /dev/null
+++ b/test/runtime/compiler/literal.ts
@@ -0,0 +1,43 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Literal', () => {
+  it('Should validate literal number', () => {
+    const T = Type.Literal(42)
+    ok(T, 42)
+  })
+  it('Should validate literal string', () => {
+    const T = Type.Literal('hello')
+    ok(T, 'hello')
+  })
+
+  it('Should validate literal boolean', () => {
+    const T = Type.Literal(true)
+    ok(T, true)
+  })
+
+  it('Should not validate invalid literal number', () => {
+    const T = Type.Literal(42)
+    fail(T, 43)
+  })
+  it('Should not validate invalid literal string', () => {
+    const T = Type.Literal('hello')
+    fail(T, 'world')
+  })
+  it('Should not validate invalid literal boolean', () => {
+    const T = Type.Literal(false)
+    fail(T, true)
+  })
+
+  it('Should validate literal union', () => {
+    const T = Type.Union([Type.Literal(42), Type.Literal('hello')])
+    ok(T, 42)
+    ok(T, 'hello')
+  })
+
+  it('Should not validate invalid literal union', () => {
+    const T = Type.Union([Type.Literal(42), Type.Literal('hello')])
+    fail(T, 43)
+    fail(T, 'world')
+  })
+})
diff --git a/test/runtime/compiler/modifier.ts b/test/runtime/compiler/modifier.ts
new file mode 100644
index 000000000..39f16c447
--- /dev/null
+++ b/test/runtime/compiler/modifier.ts
@@ -0,0 +1,3 @@
+import { Type } from '@sinclair/typebox'
+
+describe('type/compiler/Modifier', () => {})
diff --git a/test/runtime/compiler/never.ts b/test/runtime/compiler/never.ts
new file mode 100644
index 000000000..8be660cdf
--- /dev/null
+++ b/test/runtime/compiler/never.ts
@@ -0,0 +1,36 @@
+import { Type } from '@sinclair/typebox'
+import { fail } from './validate'
+
+describe('type/compiler/Never', () => {
+  it('Should not validate number', () => {
+    const T = Type.Never()
+    fail(T, 1)
+  })
+
+  it('Should not validate string', () => {
+    const T = Type.Never()
+    fail(T, 'hello')
+  })
+
+  it('Should not validate boolean', () => {
+    const T = Type.Never()
+    fail(T, true)
+  })
+
+  it('Should not validate array', () => {
+    const T = Type.Never()
+    fail(T, [1, 2, 3])
+  })
+  it('Should not validate object', () => {
+    const T = Type.Never()
+    fail(T, { a: 1, b: 2 })
+  })
+  it('Should not validate null', () => {
+    const T = Type.Never()
+    fail(T, null)
+  })
+  it('Should not validate undefined', () => {
+    const T = Type.Never()
+    fail(T, undefined)
+  })
+})
diff --git a/test/runtime/compiler/null.ts b/test/runtime/compiler/null.ts
new file mode 100644
index 000000000..a3e6009c4
--- /dev/null
+++ b/test/runtime/compiler/null.ts
@@ -0,0 +1,39 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Null', () => {
+  it('Should not validate number', () => {
+    const T = Type.Null()
+    fail(T, 1)
+  })
+
+  it('Should not validate string', () => {
+    const T = Type.Null()
+    fail(T, 'hello')
+  })
+
+  it('Should not validate boolean', () => {
+    const T = Type.Null()
+    fail(T, true)
+  })
+
+  it('Should not validate array', () => {
+    const T = Type.Null()
+    fail(T, [1, 2, 3])
+  })
+
+  it('Should not validate object', () => {
+    const T = Type.Null()
+    fail(T, { a: 1, b: 2 })
+  })
+
+  it('Should not validate null', () => {
+    const T = Type.Null()
+    ok(T, null)
+  })
+
+  it('Should not validate undefined', () => {
+    const T = Type.Null()
+    fail(T, undefined)
+  })
+})
diff --git a/test/runtime/compiler/number.ts b/test/runtime/compiler/number.ts
new file mode 100644
index 000000000..0a9e05b08
--- /dev/null
+++ b/test/runtime/compiler/number.ts
@@ -0,0 +1,33 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Number', () => {
+  it('Should validate number', () => {
+    const T = Type.Number()
+    ok(T, 1)
+  })
+  it('Should not validate string', () => {
+    const T = Type.Number()
+    fail(T, 'hello')
+  })
+  it('Should not validate boolean', () => {
+    const T = Type.Number()
+    fail(T, true)
+  })
+  it('Should not validate array', () => {
+    const T = Type.Number()
+    fail(T, [1, 2, 3])
+  })
+  it('Should not validate object', () => {
+    const T = Type.Number()
+    fail(T, { a: 1, b: 2 })
+  })
+  it('Should not validate null', () => {
+    const T = Type.Number()
+    fail(T, null)
+  })
+  it('Should not validate undefined', () => {
+    const T = Type.Number()
+    fail(T, undefined)
+  })
+})
diff --git a/test/runtime/compiler/object.ts b/test/runtime/compiler/object.ts
new file mode 100644
index 000000000..845855cd7
--- /dev/null
+++ b/test/runtime/compiler/object.ts
@@ -0,0 +1,142 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Object', () => {
+  it('Should not validate a number', () => {
+    const T = Type.Object({})
+    fail(T, 42)
+  })
+
+  it('Should not validate a string', () => {
+    const T = Type.Object({})
+    fail(T, 'hello')
+  })
+
+  it('Should not validate a boolean', () => {
+    const T = Type.Object({})
+    fail(T, true)
+  })
+
+  it('Should not validate a null', () => {
+    const T = Type.Object({})
+    fail(T, null)
+  })
+
+  it('Should not validate an array', () => {
+    const T = Type.Object({})
+    fail(T, [1, 2])
+  })
+
+  it('Should validate with correct property values', () => {
+    const T = Type.Object({
+      a: Type.Number(),
+      b: Type.String(),
+      c: Type.Boolean(),
+      d: Type.Array(Type.Number()),
+      e: Type.Object({ x: Type.Number(), y: Type.Number() }),
+    })
+    ok(T, {
+      a: 10,
+      b: 'hello',
+      c: true,
+      d: [1, 2, 3],
+      e: { x: 10, y: 20 },
+    })
+  })
+
+  it('Should not validate with incorrect property values', () => {
+    const T = Type.Object({
+      a: Type.Number(),
+      b: Type.String(),
+      c: Type.Boolean(),
+      d: Type.Array(Type.Number()),
+      e: Type.Object({ x: Type.Number(), y: Type.Number() }),
+    })
+    fail(T, {
+      a: 'not a number', // error
+      b: 'hello',
+      c: true,
+      d: [1, 2, 3],
+      e: { x: 10, y: 20 },
+    })
+  })
+
+  it('Should allow additionalProperties by default', () => {
+    const T = Type.Object({
+      a: Type.Number(),
+      b: Type.String(),
+    })
+    ok(T, {
+      a: 1,
+      b: 'hello',
+      c: true,
+    })
+  })
+
+  it('Should not allow an empty object if minProperties is set to 1', () => {
+    const T = Type.Object(
+      {
+        a: Type.Optional(Type.Number()),
+        b: Type.Optional(Type.String()),
+      },
+      { additionalProperties: false, minProperties: 1 },
+    )
+    ok(T, { a: 1 })
+    ok(T, { b: 'hello' })
+    fail(T, {})
+  })
+
+  it('Should not allow 3 properties if maxProperties is set to 2', () => {
+    const T = Type.Object(
+      {
+        a: Type.Optional(Type.Number()),
+        b: Type.Optional(Type.String()),
+        c: Type.Optional(Type.Boolean()),
+      },
+      { additionalProperties: false, maxProperties: 2 },
+    )
+    ok(T, { a: 1 })
+    ok(T, { a: 1, b: 'hello' })
+    fail(T, {
+      a: 1,
+      b: 'hello',
+      c: true,
+    })
+  })
+
+  it('Should not allow additionalProperties if additionalProperties is false', () => {
+    const T = Type.Object(
+      {
+        a: Type.Number(),
+        b: Type.String(),
+      },
+      { additionalProperties: false },
+    )
+    fail(T, {
+      a: 1,
+      b: 'hello',
+      c: true,
+    })
+  })
+
+  it('Should not allow properties for an empty object when additionalProperties is false', () => {
+    const T = Type.Object({}, { additionalProperties: false })
+    ok(T, {})
+    fail(T, { a: 10 })
+  })
+
+  it('Should validate with non-syntax property keys', () => {
+    const T = Type.Object({
+      'with-hyphen': Type.Literal(1),
+      '0-leading': Type.Literal(2),
+      '$-leading': Type.Literal(3),
+      '!@#$%^&*(': Type.Literal(4),
+    })
+    ok(T, {
+      'with-hyphen': 1,
+      '0-leading': 2,
+      '$-leading': 3,
+      '!@#$%^&*(': 4,
+    })
+  })
+})
diff --git a/test/runtime/compiler/omit.ts b/test/runtime/compiler/omit.ts
new file mode 100644
index 000000000..29b65bab7
--- /dev/null
+++ b/test/runtime/compiler/omit.ts
@@ -0,0 +1,60 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+import { strictEqual } from 'assert'
+
+describe('type/compiler/Omit', () => {
+  it('Should omit properties on the source schema', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Omit(A, ['z'])
+    ok(T, { x: 1, y: 1 })
+  })
+
+  it('Should remove required properties on the target schema', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Omit(A, ['z'])
+    strictEqual(T.required!.includes('z'), false)
+  })
+
+  it('Should inherit options from the source object', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Omit(A, ['z'])
+    strictEqual(A.additionalProperties, false)
+    strictEqual(T.additionalProperties, false)
+  })
+
+  it('Should omit with keyof object', () => {
+    const A = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    const B = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    })
+    const T = Type.Omit(A, Type.KeyOf(B), { additionalProperties: false })
+    ok(T, { z: 0 })
+    fail(T, { x: 0, y: 0, z: 0 })
+  })
+})
diff --git a/test/runtime/compiler/optional.ts b/test/runtime/compiler/optional.ts
new file mode 100644
index 000000000..abbcb86c3
--- /dev/null
+++ b/test/runtime/compiler/optional.ts
@@ -0,0 +1,27 @@
+import { strictEqual } from 'assert'
+import { Type } from '@sinclair/typebox'
+import { ok } from './validate'
+
+describe('type/compiler/Optional', () => {
+  it('Should validate object with optional', () => {
+    const T = Type.Object(
+      {
+        a: Type.Optional(Type.String()),
+        b: Type.String(),
+      },
+      { additionalProperties: false },
+    )
+    ok(T, { a: 'hello', b: 'world' })
+    ok(T, { b: 'world' })
+  })
+  it('Should remove required value from schema', () => {
+    const T = Type.Object(
+      {
+        a: Type.Optional(Type.String()),
+        b: Type.String(),
+      },
+      { additionalProperties: false },
+    )
+    strictEqual(T.required!.includes('a'), false)
+  })
+})
diff --git a/test/runtime/compiler/partial.ts b/test/runtime/compiler/partial.ts
new file mode 100644
index 000000000..c060a0e20
--- /dev/null
+++ b/test/runtime/compiler/partial.ts
@@ -0,0 +1,52 @@
+import { Type, Modifier } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+import { strictEqual } from 'assert'
+
+describe('type/compiler/Partial', () => {
+  it('Should convert a required object into a partial.', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Partial(A)
+    ok(T, { x: 1, y: 1, z: 1 })
+    ok(T, { x: 1, y: 1 })
+    ok(T, { x: 1 })
+    ok(T, {})
+  })
+
+  it('Should update modifier types correctly when converting to partial', () => {
+    const A = Type.Object(
+      {
+        x: Type.ReadonlyOptional(Type.Number()),
+        y: Type.Readonly(Type.Number()),
+        z: Type.Optional(Type.Number()),
+        w: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Partial(A)
+    strictEqual(T.properties.x[Modifier], 'ReadonlyOptional')
+    strictEqual(T.properties.y[Modifier], 'ReadonlyOptional')
+    strictEqual(T.properties.z[Modifier], 'Optional')
+    strictEqual(T.properties.w[Modifier], 'Optional')
+  })
+
+  it('Should inherit options from the source object', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Partial(A)
+    strictEqual(A.additionalProperties, false)
+    strictEqual(T.additionalProperties, false)
+  })
+})
diff --git a/test/runtime/compiler/pick.ts b/test/runtime/compiler/pick.ts
new file mode 100644
index 000000000..c66cbb912
--- /dev/null
+++ b/test/runtime/compiler/pick.ts
@@ -0,0 +1,60 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+import { strictEqual } from 'assert'
+
+describe('type/compiler/Pick', () => {
+  it('Should pick properties from the source schema', () => {
+    const Vector3 = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Pick(Vector3, ['x', 'y'])
+    ok(T, { x: 1, y: 1 })
+  })
+
+  it('Should remove required properties on the target schema', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Pick(A, ['x', 'y'])
+    strictEqual(T.required!.includes('z'), false)
+  })
+
+  it('Should inherit options from the source object', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Pick(A, ['x', 'y'])
+    strictEqual(A.additionalProperties, false)
+    strictEqual(T.additionalProperties, false)
+  })
+
+  it('Should pick with keyof object', () => {
+    const A = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    const B = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    })
+    const T = Type.Pick(A, Type.KeyOf(B), { additionalProperties: false })
+    ok(T, { x: 0, y: 0 })
+    fail(T, { x: 0, y: 0, z: 0 })
+  })
+})
diff --git a/test/runtime/compiler/readonly-optional.ts b/test/runtime/compiler/readonly-optional.ts
new file mode 100644
index 000000000..33b78d762
--- /dev/null
+++ b/test/runtime/compiler/readonly-optional.ts
@@ -0,0 +1,27 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+import { strictEqual } from 'assert'
+
+describe('type/compiler/ReadonlyOptional', () => {
+  it('Should validate object with optional', () => {
+    const T = Type.Object(
+      {
+        a: Type.ReadonlyOptional(Type.String()),
+        b: Type.String(),
+      },
+      { additionalProperties: false },
+    )
+    ok(T, { a: 'hello', b: 'world' })
+    ok(T, { b: 'world' })
+  })
+  it('Should remove required value from schema', () => {
+    const T = Type.Object(
+      {
+        a: Type.ReadonlyOptional(Type.String()),
+        b: Type.String(),
+      },
+      { additionalProperties: false },
+    )
+    strictEqual(T.required!.includes('a'), false)
+  })
+})
diff --git a/test/runtime/compiler/readonly.ts b/test/runtime/compiler/readonly.ts
new file mode 100644
index 000000000..1ad7ff703
--- /dev/null
+++ b/test/runtime/compiler/readonly.ts
@@ -0,0 +1,28 @@
+import { deepStrictEqual, strictEqual } from 'assert'
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Readonly', () => {
+  it('Should validate object with readonly', () => {
+    const T = Type.Object(
+      {
+        a: Type.Readonly(Type.String()),
+        b: Type.Readonly(Type.String()),
+      },
+      { additionalProperties: false },
+    )
+    ok(T, { a: 'hello', b: 'world' })
+  })
+
+  it('Should retain required array on object', () => {
+    const T = Type.Object(
+      {
+        a: Type.Readonly(Type.String()),
+        b: Type.Readonly(Type.String()),
+      },
+      { additionalProperties: false },
+    )
+    strictEqual(T.required!.includes('a'), true)
+    strictEqual(T.required!.includes('b'), true)
+  })
+})
diff --git a/test/runtime/compiler/record.ts b/test/runtime/compiler/record.ts
new file mode 100644
index 000000000..aa3384805
--- /dev/null
+++ b/test/runtime/compiler/record.ts
@@ -0,0 +1,101 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Record', () => {
+  it('Should validate when all property values are numbers', () => {
+    const T = Type.Record(Type.String(), Type.Number())
+    ok(T, { a: 1, b: 2, c: 3 })
+  })
+
+  it('Should validate when all property keys are strings', () => {
+    const T = Type.Record(Type.String(), Type.Number())
+    ok(T, { a: 1, b: 2, c: 3, '0': 4 })
+  })
+
+  it('Should validate when all property keys are numbers', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
+  })
+
+  it('Should validate when all property keys are numbers, but one property is a string with varying type', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
+  })
+
+  it('Should not validate if passing a leading zeros for numeric keys', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    fail(T, {
+      '00': 1,
+      '01': 2,
+      '02': 3,
+      '03': 4,
+    })
+  })
+
+  it('Should not validate if passing a signed numeric keys', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    fail(T, {
+      '-0': 1,
+      '-1': 2,
+      '-2': 3,
+      '-3': 4,
+    })
+  })
+
+  it('Should not validate when all property keys are numbers, but one property is a string with varying type', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
+  })
+
+  it('Should validate when specifying string union literals when additionalProperties is true', () => {
+    const K = Type.Union([Type.Literal('a'), Type.Literal('b'), Type.Literal('c')])
+    const T = Type.Record(K, Type.Number())
+    ok(T, { a: 1, b: 2, c: 3, d: 'hello' })
+  })
+
+  it('Should not validate when specifying string union literals when additionalProperties is false', () => {
+    const K = Type.Union([Type.Literal('a'), Type.Literal('b'), Type.Literal('c')])
+    const T = Type.Record(K, Type.Number(), { additionalProperties: false })
+    fail(T, { a: 1, b: 2, c: 3, d: 'hello' })
+  })
+
+  it('Should validate for keyof records', () => {
+    const T = Type.Object({
+      a: Type.String(),
+      b: Type.Number(),
+      c: Type.String(),
+    })
+    const R = Type.Record(Type.KeyOf(T), Type.Number())
+    ok(R, { a: 1, b: 2, c: 3 })
+  })
+
+  it('Should not validate for unknown key via keyof', () => {
+    const T = Type.Object({
+      a: Type.String(),
+      b: Type.Number(),
+      c: Type.String(),
+    })
+    const R = Type.Record(Type.KeyOf(T), Type.Number(), { additionalProperties: false })
+    fail(R, { a: 1, b: 2, c: 3, d: 4 })
+  })
+
+  it('Should should validate when specifying regular expressions', () => {
+    const K = Type.RegEx(/^op_.*$/)
+    const T = Type.Record(K, Type.Number())
+    ok(T, {
+      op_a: 1,
+      op_b: 2,
+      op_c: 3,
+    })
+  })
+
+  it('Should should not validate when specifying regular expressions and passing invalid property', () => {
+    const K = Type.RegEx(/^op_.*$/)
+    const T = Type.Record(K, Type.Number())
+    fail(T, {
+      op_a: 1,
+      op_b: 2,
+      aop_c: 3,
+    })
+  })
+})
diff --git a/test/runtime/compiler/recursive.ts b/test/runtime/compiler/recursive.ts
new file mode 100644
index 000000000..0bd48baf0
--- /dev/null
+++ b/test/runtime/compiler/recursive.ts
@@ -0,0 +1,83 @@
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Recursive', () => {
+  it('Should generate default ordinal $id if not specified', () => {
+    const Node = Type.Recursive((Node) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(Node),
+      }),
+    )
+    Assert.equal(Node.$id === undefined, false)
+  })
+
+  it('Should override default ordinal $id if specified', () => {
+    const Node = Type.Recursive(
+      (Node) =>
+        Type.Object({
+          id: Type.String(),
+          nodes: Type.Array(Node),
+        }),
+      { $id: 'Node' },
+    )
+    Assert.equal(Node.$id === 'Node', true)
+  })
+
+  it('Should validate recursive node type', () => {
+    const Node = Type.Recursive((Self) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(Self),
+      }),
+    )
+    ok(Node, {
+      id: 'A',
+      nodes: [
+        { id: 'B', nodes: [] },
+        { id: 'C', nodes: [] },
+      ],
+    })
+  })
+
+  it('Should validate wrapped recursive node type', () => {
+    const Node = Type.Tuple([
+      Type.Recursive((Self) =>
+        Type.Object({
+          id: Type.String(),
+          nodes: Type.Array(Self),
+        }),
+      ),
+    ])
+    ok(Node, [
+      {
+        id: 'A',
+        nodes: [
+          { id: 'B', nodes: [] },
+          { id: 'C', nodes: [] },
+        ],
+      },
+    ])
+  })
+
+  it('Should not validate wrapped recursive node type with invalid id', () => {
+    const Node = Type.Tuple([
+      Type.Recursive((Self) =>
+        Type.Object({
+          id: Type.String(),
+          nodes: Type.Array(Self),
+        }),
+      ),
+    ])
+    fail(Node, [
+      {
+        id: 'A',
+        nodes: [
+          { id: 1, nodes: [] },
+          { id: 'C', nodes: [] },
+        ],
+      },
+    ])
+  })
+})
diff --git a/test/runtime/compiler/ref.ts b/test/runtime/compiler/ref.ts
new file mode 100644
index 000000000..b816f895c
--- /dev/null
+++ b/test/runtime/compiler/ref.ts
@@ -0,0 +1,70 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+import { Assert } from '../assert/index'
+
+describe('type/compiler/Ref', () => {
+  it('Should should validate when referencing a type', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { $id: Assert.nextId() },
+    )
+    const R = Type.Ref(T)
+    ok(
+      R,
+      {
+        x: 1,
+        y: 2,
+        z: 3,
+      },
+      [T],
+    )
+  })
+
+  it('Should not validate when passing invalid data', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { $id: Assert.nextId() },
+    )
+    const R = Type.Ref(T)
+    fail(
+      R,
+      {
+        x: 1,
+        y: 2,
+      },
+      [T],
+    )
+  })
+
+  it('Should de-reference object property schema', () => {
+    const R = Type.Object(
+      {
+        name: Type.String(),
+      },
+      { $id: 'R' },
+    )
+
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+        r: Type.Optional(Type.Ref(R)),
+      },
+      { $id: 'T' },
+    )
+
+    ok(T, { x: 1, y: 2, z: 3 }, [R])
+    ok(T, { x: 1, y: 2, z: 3, r: { name: 'hello' } }, [R])
+    fail(T, { x: 1, y: 2, z: 3, r: { name: 1 } }, [R])
+    fail(T, { x: 1, y: 2, z: 3, r: {} }, [R])
+  })
+})
diff --git a/test/runtime/compiler/regex.ts b/test/runtime/compiler/regex.ts
new file mode 100644
index 000000000..0213a8216
--- /dev/null
+++ b/test/runtime/compiler/regex.ts
@@ -0,0 +1,35 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/RegEx', () => {
+  it('Should validate numeric value', () => {
+    const T = Type.RegEx(/[012345]/)
+    ok(T, '0')
+    ok(T, '1')
+    ok(T, '2')
+    ok(T, '3')
+    ok(T, '4')
+    ok(T, '5')
+  })
+
+  it('Should validate true or false string value', () => {
+    const T = Type.RegEx(/true|false/)
+    ok(T, 'true')
+    ok(T, 'true')
+    ok(T, 'true')
+    ok(T, 'false')
+    ok(T, 'false')
+    ok(T, 'false')
+    fail(T, '6')
+  })
+
+  it('Should not validate failed regex test', () => {
+    const T = Type.RegEx(/true|false/)
+    fail(T, 'unknown')
+  })
+
+  it('Should pass numeric 5 digit test', () => {
+    const T = Type.RegEx(/[\d]{5}/)
+    ok(T, '12345')
+  })
+})
diff --git a/test/runtime/compiler/required.ts b/test/runtime/compiler/required.ts
new file mode 100644
index 000000000..56d27bc5a
--- /dev/null
+++ b/test/runtime/compiler/required.ts
@@ -0,0 +1,57 @@
+import { Type, Modifier } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+import { strictEqual } from 'assert'
+
+describe('type/compiler/compiler/Required', () => {
+  it('Should convert a partial object into a required object', () => {
+    const A = Type.Object(
+      {
+        x: Type.Optional(Type.Number()),
+        y: Type.Optional(Type.Number()),
+        z: Type.Optional(Type.Number()),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Required(A)
+    ok(T, { x: 1, y: 1, z: 1 })
+    fail(T, { x: 1, y: 1 })
+    fail(T, { x: 1 })
+    fail(T, {})
+  })
+
+  it('Should update modifier types correctly when converting to required', () => {
+    const A = Type.Object({
+      x: Type.ReadonlyOptional(Type.Number()),
+      y: Type.Readonly(Type.Number()),
+      z: Type.Optional(Type.Number()),
+      w: Type.Number(),
+    })
+    const T = Type.Required(A)
+    strictEqual(T.properties.x[Modifier], 'Readonly')
+    strictEqual(T.properties.y[Modifier], 'Readonly')
+    strictEqual(T.properties.z[Modifier], undefined)
+    strictEqual(T.properties.w[Modifier], undefined)
+  })
+
+  it('Should inherit options from the source object', () => {
+    const A = Type.Object(
+      {
+        x: Type.Optional(Type.Number()),
+        y: Type.Optional(Type.Number()),
+        z: Type.Optional(Type.Number()),
+      },
+      { additionalPropeties: false },
+    )
+    const T = Type.Required(A)
+    strictEqual(A.additionalPropeties, false)
+    strictEqual(T.additionalPropeties, false)
+  })
+
+  // it('Should construct new object when targetting reference', () => {
+  //   const T = Type.Object({ a: Type.String(), b: Type.String() }, { $id: 'T' })
+  //   const R = Type.Ref(T)
+  //   const P = Type.Required(R)
+  //   strictEqual(P.properties.a.type, 'string')
+  //   strictEqual(P.properties.b.type, 'string')
+  // })
+})
diff --git a/test/runtime/compiler/string.ts b/test/runtime/compiler/string.ts
new file mode 100644
index 000000000..f90398e7b
--- /dev/null
+++ b/test/runtime/compiler/string.ts
@@ -0,0 +1,65 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/String', () => {
+  it('Should not validate number', () => {
+    const T = Type.String()
+    fail(T, 1)
+  })
+  it('Should validate string', () => {
+    const T = Type.String()
+    ok(T, 'hello')
+  })
+  it('Should not validate boolean', () => {
+    const T = Type.String()
+    fail(T, true)
+  })
+  it('Should not validate array', () => {
+    const T = Type.String()
+    fail(T, [1, 2, 3])
+  })
+  it('Should not validate object', () => {
+    const T = Type.String()
+    fail(T, { a: 1, b: 2 })
+  })
+  it('Should not validate null', () => {
+    const T = Type.String()
+    fail(T, null)
+  })
+  it('Should not validate undefined', () => {
+    const T = Type.String()
+    fail(T, undefined)
+  })
+
+  it('Should validate string format as email', () => {
+    const T = Type.String({ format: 'email' })
+    ok(T, 'name@domain.com')
+  })
+
+  it('Should validate string format as uuid', () => {
+    const T = Type.String({ format: 'uuid' })
+    ok(T, '4a7a17c9-2492-4a53-8e13-06ea2d3f3bbf')
+  })
+
+  it('Should validate string format as iso8601 date', () => {
+    const T = Type.String({ format: 'date-time' })
+    ok(T, '2021-06-11T20:30:00-04:00')
+  })
+
+  it('Should validate minLength', () => {
+    const T = Type.String({ minLength: 4 })
+    ok(T, '....')
+    fail(T, '...')
+  })
+
+  it('Should validate maxLength', () => {
+    const T = Type.String({ maxLength: 4 })
+    ok(T, '....')
+    fail(T, '.....')
+  })
+
+  it('Should pass numeric 5 digit test', () => {
+    const T = Type.String({ pattern: '[\\d]{5}' })
+    ok(T, '12345')
+  })
+})
diff --git a/test/runtime/compiler/tuple.ts b/test/runtime/compiler/tuple.ts
new file mode 100644
index 000000000..574410d8b
--- /dev/null
+++ b/test/runtime/compiler/tuple.ts
@@ -0,0 +1,62 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+import { Assert } from '../assert'
+
+describe('type/compiler/Tuple', () => {
+  it('Should validate tuple of [string, number]', () => {
+    const A = Type.String()
+    const B = Type.Number()
+    const T = Type.Tuple([A, B])
+    ok(T, ['hello', 42])
+  })
+
+  it('Should not validate tuple of [string, number] when reversed', () => {
+    const A = Type.String()
+    const B = Type.Number()
+    const T = Type.Tuple([A, B])
+    fail(T, [42, 'hello'])
+  })
+
+  it('Should validate with empty tuple', () => {
+    const T = Type.Tuple([])
+    ok(T, [])
+  })
+
+  it('Should not validate with empty tuple with more items', () => {
+    const T = Type.Tuple([])
+    fail(T, [1])
+  })
+
+  it('Should not validate with empty tuple with less items', () => {
+    const T = Type.Tuple([Type.Number(), Type.Number()])
+    fail(T, [1])
+  })
+
+  it('Should validate tuple of objects', () => {
+    const A = Type.Object({ a: Type.String() })
+    const B = Type.Object({ b: Type.Number() })
+    const T = Type.Tuple([A, B])
+    ok(T, [{ a: 'hello' }, { b: 42 }])
+  })
+
+  it('Should not validate tuple of objects when reversed', () => {
+    const A = Type.Object({ a: Type.String() })
+    const B = Type.Object({ b: Type.Number() })
+    const T = Type.Tuple([A, B])
+    fail(T, [{ b: 42 }, { a: 'hello' }])
+  })
+
+  it('Should not validate tuple when array is less than tuple length', () => {
+    const A = Type.Object({ a: Type.String() })
+    const B = Type.Object({ b: Type.Number() })
+    const T = Type.Tuple([A, B])
+    fail(T, [{ a: 'hello' }])
+  })
+
+  it('Should not validate tuple when array is greater than tuple length', () => {
+    const A = Type.Object({ a: Type.String() })
+    const B = Type.Object({ b: Type.Number() })
+    const T = Type.Tuple([A, B])
+    fail(T, [{ a: 'hello' }, { b: 42 }, { b: 42 }])
+  })
+})
diff --git a/test/runtime/compiler/uint8array.ts b/test/runtime/compiler/uint8array.ts
new file mode 100644
index 000000000..9a552e53d
--- /dev/null
+++ b/test/runtime/compiler/uint8array.ts
@@ -0,0 +1,56 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Uint8Array', () => {
+  it('Should not validate number', () => {
+    const T = Type.Uint8Array()
+    fail(T, 1)
+  })
+
+  it('Should not validate string', () => {
+    const T = Type.Uint8Array()
+    fail(T, 'hello')
+  })
+
+  it('Should not validate boolean', () => {
+    const T = Type.Uint8Array()
+    fail(T, true)
+  })
+
+  it('Should not validate array', () => {
+    const T = Type.Uint8Array()
+    fail(T, [1, 2, 3])
+  })
+
+  it('Should not validate object', () => {
+    const T = Type.Uint8Array()
+    fail(T, { a: 1, b: 2 })
+  })
+
+  it('Should not validate null', () => {
+    const T = Type.Uint8Array()
+    fail(T, null)
+  })
+
+  it('Should not validate undefined', () => {
+    const T = Type.Uint8Array()
+    fail(T, undefined)
+  })
+
+  it('Should validate Uint8Array', () => {
+    const T = Type.Uint8Array()
+    ok(T, new Uint8Array(100))
+  })
+
+  it('Should validate minByteLength', () => {
+    const T = Type.Uint8Array({ minByteLength: 4 })
+    ok(T, new Uint8Array(4))
+    fail(T, new Uint8Array(3))
+  })
+
+  it('Should validate maxByteLength', () => {
+    const T = Type.Uint8Array({ maxByteLength: 4 })
+    ok(T, new Uint8Array(4))
+    fail(T, new Uint8Array(5))
+  })
+})
diff --git a/test/runtime/compiler/union.ts b/test/runtime/compiler/union.ts
new file mode 100644
index 000000000..fcf751910
--- /dev/null
+++ b/test/runtime/compiler/union.ts
@@ -0,0 +1,62 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Union', () => {
+  it('Should validate union of string, number and boolean', () => {
+    const A = Type.String()
+    const B = Type.Number()
+    const C = Type.Boolean()
+    const T = Type.Union([A, B, C])
+    ok(T, 'hello')
+    ok(T, true)
+    ok(T, 42)
+  })
+
+  it('Should validate union of objects', () => {
+    const A = Type.Object({ a: Type.String() }, { additionalProperties: false })
+    const B = Type.Object({ b: Type.String() }, { additionalProperties: false })
+    const T = Type.Union([A, B])
+    ok(T, { a: 'hello' })
+    ok(T, { b: 'world' })
+  })
+
+  it('Should fail to validate for descriminated union types', () => {
+    const A = Type.Object({ kind: Type.Literal('A'), value: Type.String() })
+    const B = Type.Object({ kind: Type.Literal('B'), value: Type.Number() })
+    const T = Type.Union([A, B])
+    fail(T, { kind: 'A', value: 42 }) // expect { kind: 'A', value: string }
+    fail(T, { kind: 'B', value: 'hello' }) // expect { kind: 'B', value: number }
+  })
+
+  it('Should validate union of objects where properties overlap', () => {
+    const A = Type.Object({ a: Type.String() }, { additionalProperties: false })
+    const B = Type.Object({ a: Type.String(), b: Type.String() }, { additionalProperties: false })
+    const T = Type.Union([A, B])
+    ok(T, { a: 'hello' }) // A
+    ok(T, { a: 'hello', b: 'world' }) // B
+  })
+
+  it('Should validate union of overlapping property of varying type', () => {
+    const A = Type.Object({ a: Type.String(), b: Type.Number() }, { additionalProperties: false })
+    const B = Type.Object({ a: Type.String(), b: Type.String() }, { additionalProperties: false })
+    const T = Type.Union([A, B])
+    ok(T, { a: 'hello', b: 42 }) // A
+    ok(T, { a: 'hello', b: 'world' }) // B
+  })
+
+  it('Should validate union of literal strings', () => {
+    const A = Type.Literal('hello')
+    const B = Type.Literal('world')
+    const T = Type.Union([A, B])
+    ok(T, 'hello') // A
+    ok(T, 'world') // B
+  })
+
+  it('Should not validate union of literal strings for unknown string', () => {
+    const A = Type.Literal('hello')
+    const B = Type.Literal('world')
+    const T = Type.Union([A, B])
+    fail(T, 'foo') // A
+    fail(T, 'bar') // B
+  })
+})
diff --git a/test/runtime/compiler/unknown.ts b/test/runtime/compiler/unknown.ts
new file mode 100644
index 000000000..7f3cb116d
--- /dev/null
+++ b/test/runtime/compiler/unknown.ts
@@ -0,0 +1,33 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Unknown', () => {
+  it('Should validate number', () => {
+    const T = Type.Any()
+    ok(T, 1)
+  })
+  it('Should validate string', () => {
+    const T = Type.Any()
+    ok(T, 'hello')
+  })
+  it('Should validate boolean', () => {
+    const T = Type.Any()
+    ok(T, true)
+  })
+  it('Should validate array', () => {
+    const T = Type.Any()
+    ok(T, [1, 2, 3])
+  })
+  it('Should validate object', () => {
+    const T = Type.Any()
+    ok(T, { a: 1, b: 2 })
+  })
+  it('Should validate null', () => {
+    const T = Type.Any()
+    ok(T, null)
+  })
+  it('Should validate undefined', () => {
+    const T = Type.Any()
+    ok(T, undefined)
+  })
+})
diff --git a/test/runtime/compiler/validate.ts b/test/runtime/compiler/validate.ts
new file mode 100644
index 000000000..985184e4c
--- /dev/null
+++ b/test/runtime/compiler/validate.ts
@@ -0,0 +1,107 @@
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { Value } from '@sinclair/typebox/value'
+import { TSchema } from '@sinclair/typebox'
+import { Format } from 'src/format'
+
+// -------------------------------------------------------------------------
+// Test Formats: https://github.com/ajv-validator/ajv-formats/blob/master/src/formats.ts
+//
+//   - date-time
+//   - email
+//   - uuid
+//
+// -------------------------------------------------------------------------
+
+const EMAIL = /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i
+const UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i
+const DATE_TIME_SEPARATOR = /t|\s/i
+const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i
+const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/
+const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+
+function isLeapYear(year: number): boolean {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)
+}
+
+function isDate(str: string): boolean {
+  const matches: string[] | null = DATE.exec(str)
+  if (!matches) return false
+  const year: number = +matches[1]
+  const month: number = +matches[2]
+  const day: number = +matches[3]
+  return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month])
+}
+
+function isTime(str: string, strictTimeZone?: boolean): boolean {
+  const matches: string[] | null = TIME.exec(str)
+  if (!matches) return false
+  const hr: number = +matches[1]
+  const min: number = +matches[2]
+  const sec: number = +matches[3]
+  const tz: string | undefined = matches[4]
+  const tzSign: number = matches[5] === '-' ? -1 : 1
+  const tzH: number = +(matches[6] || 0)
+  const tzM: number = +(matches[7] || 0)
+  if (tzH > 23 || tzM > 59 || (strictTimeZone && !tz)) return false
+  if (hr <= 23 && min <= 59 && sec < 60) return true
+  // leap second
+  const utcMin = min - tzM * tzSign
+  const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0)
+  return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61
+}
+
+function isDateTime(str: string, strictTimeZone?: boolean): boolean {
+  const dateTime: string[] = str.split(DATE_TIME_SEPARATOR)
+  return dateTime.length === 2 && isDate(dateTime[0]) && isTime(dateTime[1], strictTimeZone)
+}
+
+// -------------------------------------------------------------------------
+// Use Formats
+// -------------------------------------------------------------------------
+
+Format.Set('email', (value) => EMAIL.test(value))
+Format.Set('uuid', (value) => UUID.test(value))
+Format.Set('date-time', (value) => isDateTime(value, true))
+
+export function ok<T extends TSchema>(schema: T, data: unknown, references: any[] = []) {
+  const C = TypeCompiler.Compile(schema, references)
+  const result = C.Check(data)
+  if (result !== Value.Check(schema, references, data)) {
+    throw Error('Compiler and Value Check disparity')
+  }
+  if (!result) {
+    console.log('---------------------------')
+    console.log('type')
+    console.log('---------------------------')
+    console.log(JSON.stringify(schema, null, 2))
+    console.log('---------------------------')
+    console.log('data')
+    console.log('---------------------------')
+    console.log(JSON.stringify(data, null, 2))
+    console.log('---------------------------')
+    console.log('errors')
+    console.log('---------------------------')
+    console.log(result)
+    throw Error('expected ok')
+  }
+}
+
+export function fail<T extends TSchema>(schema: T, data: unknown, additional: any[] = []) {
+  const C = TypeCompiler.Compile(schema, additional)
+  const result = C.Check(data)
+  if (result) {
+    console.log('---------------------------')
+    console.log('type')
+    console.log('---------------------------')
+    console.log(JSON.stringify(schema, null, 2))
+    console.log('---------------------------')
+    console.log('data')
+    console.log('---------------------------')
+    console.log(JSON.stringify(data, null, 2))
+    console.log('---------------------------')
+    console.log('errors')
+    console.log('---------------------------')
+    console.log('none')
+    throw Error('expected ok')
+  }
+}
diff --git a/test/runtime/compiler/void.ts b/test/runtime/compiler/void.ts
new file mode 100644
index 000000000..3beefc21d
--- /dev/null
+++ b/test/runtime/compiler/void.ts
@@ -0,0 +1,39 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Void', () => {
+  it('Should not validate number', () => {
+    const T = Type.Void()
+    fail(T, 1)
+  })
+
+  it('Should not validate string', () => {
+    const T = Type.Void()
+    fail(T, 'hello')
+  })
+
+  it('Should not validate boolean', () => {
+    const T = Type.Void()
+    fail(T, true)
+  })
+
+  it('Should not validate array', () => {
+    const T = Type.Void()
+    fail(T, [1, 2, 3])
+  })
+
+  it('Should not validate object', () => {
+    const T = Type.Void()
+    fail(T, { a: 1, b: 2 })
+  })
+
+  it('Should validate null', () => {
+    const T = Type.Null()
+    ok(T, null)
+  })
+
+  it('Should not validate undefined', () => {
+    const T = Type.Void()
+    fail(T, undefined)
+  })
+})
diff --git a/test/runtime/conditional/any.ts b/test/runtime/conditional/any.ts
new file mode 100644
index 000000000..a8a11d46a
--- /dev/null
+++ b/test/runtime/conditional/any.ts
@@ -0,0 +1,92 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Any', () => {
+  it('Should extend Any', () => {
+    type T = any extends any ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+  it('Should extend Unknown', () => {
+    type T = any extends unknown ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = any extends string ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.String())
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+  it('Should extend Boolean', () => {
+    type T = any extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+  it('Should extend Number', () => {
+    type T = any extends number ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Number())
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+  it('Should extend Integer', () => {
+    type T = any extends number ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+  it('Should extend Array 1', () => {
+    type T = any extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+  it('Should extend Array 2', () => {
+    type T = any extends Array<string> ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Array(Type.String()))
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+  it('Should extend Tuple', () => {
+    type T = any extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+  it('Should extend Object 1', () => {
+    type T = any extends object ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+  it('Should extend Object 2', () => {
+    type T = any extends {} ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+  it('Should extend Object 3', () => {
+    type T = any extends { a: number } ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Object({ a: Type.Number() }))
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+  it('Should extend Union 1', () => {
+    type T = any extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+  it('Should extend Union 2', () => {
+    type T = any extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Union([Type.Any(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+  it('Should extend Null', () => {
+    type T = any extends null ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Null())
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+  it('Should extend Undefined', () => {
+    type T = any extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+  it('Should extend Void', () => {
+    type T = any extends void ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Void())
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+})
diff --git a/test/runtime/conditional/array.ts b/test/runtime/conditional/array.ts
new file mode 100644
index 000000000..2f28914d0
--- /dev/null
+++ b/test/runtime/conditional/array.ts
@@ -0,0 +1,310 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Array', () => {
+  // ----------------------------------------------
+  // Generic Varying
+  // ----------------------------------------------
+
+  it('Should extend Array Varying 1', () => {
+    type T = Array<any> extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Array Varying 2', () => {
+    type T = Array<string> extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Array Varying 3', () => {
+    type T = Array<any> extends Array<string> ? 1 : 2 // 1
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Array(Type.String()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Array Varying 4', () => {
+    type T = Array<number> extends Array<string> ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Number()), Type.Array(Type.String()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  // ----------------------------------------------
+  // Any
+  // ----------------------------------------------
+  it('Should extend Any', () => {
+    type T = Array<any> extends any ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = Array<any> extends unknown ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = Array<any> extends string ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = Array<any> extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = Array<any> extends number ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = Array<any> extends number ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array 1', () => {
+    type T = Array<any> extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Array 2', () => {
+    type T = Array<string> extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Array 3', () => {
+    type T = Array<any> extends Array<string> ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = Array<any> extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = Array<any> extends object ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = Array<any> extends {} ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = Array<any> extends { a: number } ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Object({ a: Type.Number() }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 4', () => {
+    type T = Array<any> extends { length: '1' } ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Object({ length: Type.Literal('1') }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 5', () => {
+    type T = Array<any> extends { length: number } ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Object({ length: Type.Number() }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = Array<any> extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = Array<any> extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = Array<any> extends any | Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 4', () => {
+    type T = Array<string> extends any | Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 5', () => {
+    type T = Array<any> extends any | Array<string> ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Array(Type.String())]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = Array<any> extends null ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = Array<any> extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.Any()), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  // ----------------------------------------------
+  // Constrained
+  // ----------------------------------------------
+
+  it('Should extend constrained Any', () => {
+    type T = Array<string> extends any ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained Unknown', () => {
+    type T = Array<string> extends unknown ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained String', () => {
+    type T = Array<string> extends string ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Boolean', () => {
+    type T = Array<string> extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Number', () => {
+    type T = Array<string> extends number ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Integer', () => {
+    type T = Array<string> extends number ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Array 1', () => {
+    type T = Array<string> extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained Array 2', () => {
+    type T = Array<string> extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained Array 3', () => {
+    type T = Array<string> extends Array<string> ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained Tuple', () => {
+    type T = Array<string> extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Object 1', () => {
+    type T = Array<string> extends object ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained Object 2', () => {
+    type T = Array<string> extends {} ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained Object 3', () => {
+    type T = Array<string> extends { a: number } ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Object({ a: Type.Number() }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Object 4', () => {
+    type T = Array<string> extends { length: '1' } ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Object({ length: Type.Literal('1') }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Object 5', () => {
+    type T = Array<string> extends { length: number } ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Object({ length: Type.Number() }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained Union 1', () => {
+    type T = Array<string> extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Union([Type.Null(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Union 2', () => {
+    type T = Array<string> extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Union([Type.Any(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained Union 3', () => {
+    type T = Array<string> extends any | Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained Union 4', () => {
+    type T = Array<string> extends any | Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained Union 5', () => {
+    type T = Array<string> extends any | Array<string> ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.String())]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained Null', () => {
+    type T = Array<string> extends null ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Undefined', () => {
+    type T = Array<string> extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Void', () => {
+    type T = Array<string> extends void ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+})
diff --git a/test/runtime/conditional/boolean.ts b/test/runtime/conditional/boolean.ts
new file mode 100644
index 000000000..df089789c
--- /dev/null
+++ b/test/runtime/conditional/boolean.ts
@@ -0,0 +1,107 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Boolean', () => {
+  it('Should extend Any', () => {
+    type T = boolean extends any ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = boolean extends string ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = boolean extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Number', () => {
+    type T = boolean extends number ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = boolean extends number ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array', () => {
+    type T = boolean extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = boolean extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = boolean extends Record<number, any> ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = boolean extends {} ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = boolean extends { a: 10 } ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = boolean extends object ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = boolean extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = boolean extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = boolean extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = boolean extends null ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = boolean extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = boolean extends void ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+})
diff --git a/test/runtime/conditional/constructor.ts b/test/runtime/conditional/constructor.ts
new file mode 100644
index 000000000..de607b660
--- /dev/null
+++ b/test/runtime/conditional/constructor.ts
@@ -0,0 +1,243 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Constructor', () => {
+  it('Should extend Function', () => {
+    type T = (new () => number) extends () => number ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Function([], Type.Number()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Constructor 1', () => {
+    type T = (new () => number) extends new () => number ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Number()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Constructor 2', () => {
+    type T = (new () => any) extends new () => number ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Constructor 3', () => {
+    type T = (new () => number) extends new () => any ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Constructor 4', () => {
+    type T = (new (a: number) => number) extends new () => any ? 1 : 2
+    const R = Structural.Check(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([], Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Constructor 5', () => {
+    type T = (new (a: number | string) => number) extends new (a: number) => number ? 1 : 2
+    const R = Structural.Check(Type.Constructor([Type.Union([Type.Number(), Type.String()])], Type.Number()), Type.Constructor([Type.Number()], Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Constructor 6', () => {
+    type T = (new (a: number) => number) extends new (a: number | string) => any ? 1 : 2
+    const R = Structural.Check(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([Type.Union([Type.Number(), Type.String()])], Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Constructor 7', () => {
+    type T = (new (a: number, b: number) => number) extends new (a: number) => number ? 1 : 2
+    const R = Structural.Check(Type.Constructor([Type.Number(), Type.Number()], Type.Number()), Type.Constructor([Type.Number()], Type.Number()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Constructor 8', () => {
+    type T = (new (a: number) => number) extends new (a: number, b: number) => number ? 1 : 2
+    const R = Structural.Check(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([Type.Number(), Type.Number()], Type.Number()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Constructor 9', () => {
+    type T = (new () => number) extends new () => any ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Constructor 9', () => {
+    type T = (new () => any) extends new () => number ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Constructor 10', () => {
+    type T = (new () => Array<any>) extends new () => object ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Array(Type.Any())), Type.Constructor([], Type.Object({})))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+  it('Should extend Constructor 11', () => {
+    type T = (new () => Array<string>) extends new () => object ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Array(Type.String())), Type.Constructor([], Type.Object({})))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Constructor 12', () => {
+    type T = (new () => object) extends new () => Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Object({})), Type.Constructor([], Type.Array(Type.Any())))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Constructor 13', () => {
+    type T = (new (a: unknown) => number) extends new (a: any) => number ? 1 : 2
+    const R = Structural.Check(Type.Constructor([Type.Unknown()], Type.Number({})), Type.Constructor([Type.Any()], Type.Number({})))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Constructor 14', () => {
+    type T = (new (a: any) => number) extends new (a: unknown) => number ? 1 : 2
+    const R = Structural.Check(Type.Constructor([Type.Any()], Type.Number({})), Type.Constructor([Type.Unknown()], Type.Number({})))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Constructor 15', () => {
+    type T = (new () => any) extends new () => unknown ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Any({})), Type.Constructor([], Type.Unknown({})))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Constructor 16', () => {
+    type T = (new () => unknown) extends new () => any ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Unknown({})), Type.Constructor([], Type.Any({})))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Any', () => {
+    type T = (new () => number) extends any ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = (new () => number) extends string ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = (new () => number) extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = (new () => number) extends number ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = (new () => number) extends number ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array 1', () => {
+    type T = (new () => number) extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array 2', () => {
+    type T = (new () => number) extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array 3', () => {
+    type T = (new () => number) extends Array<string> ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = (new () => number) extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = (() => number) extends Record<number, any> ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = (new () => number) extends object ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = (new () => number) extends {} ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = (new () => number) extends { a: number } ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Object({ a: Type.Number() }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 4', () => {
+    type T = (new () => number) extends { length: '1' } ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Object({ length: Type.Literal('1') }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = (new () => number) extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Union([Type.Null(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = (new () => number) extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = (new () => number) extends any | Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 4', () => {
+    type T = (new () => number) extends any | Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 5', () => {
+    type T = (new () => number) extends any | Array<string> ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.String())]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = (new () => number) extends null ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = (new () => number) extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = (new () => number) extends void ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+})
diff --git a/test/runtime/conditional/function.ts b/test/runtime/conditional/function.ts
new file mode 100644
index 000000000..2729aa40b
--- /dev/null
+++ b/test/runtime/conditional/function.ts
@@ -0,0 +1,245 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Function', () => {
+  it('Should extend Constructor 1', () => {
+    type T = (() => number) extends new () => number ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Constructor([], Type.Number()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Function 1', () => {
+    type T = (() => number) extends () => number ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Function([], Type.Number()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Function 2', () => {
+    type T = (() => any) extends () => number ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Function 3', () => {
+    type T = (() => number) extends () => any ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Function 4', () => {
+    type T = ((a: number) => number) extends () => any ? 1 : 2
+    const R = Structural.Check(Type.Function([Type.Number()], Type.Number()), Type.Function([], Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Function 5', () => {
+    type T = ((a: number | string) => number) extends (a: number) => number ? 1 : 2
+    const R = Structural.Check(Type.Function([Type.Union([Type.Number(), Type.String()])], Type.Number()), Type.Function([Type.Number()], Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Function 6', () => {
+    type T = ((a: number) => number) extends (a: number | string) => any ? 1 : 2
+    const R = Structural.Check(Type.Function([Type.Number()], Type.Number()), Type.Function([Type.Union([Type.Number(), Type.String()])], Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Function 7', () => {
+    type T = ((a: number, b: number) => number) extends (a: number) => number ? 1 : 2
+    const R = Structural.Check(Type.Function([Type.Number(), Type.Number()], Type.Number()), Type.Function([Type.Number()], Type.Number()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Function 8', () => {
+    type T = ((a: number) => number) extends (a: number, b: number) => number ? 1 : 2
+    const R = Structural.Check(Type.Function([Type.Number()], Type.Number()), Type.Function([Type.Number(), Type.Number()], Type.Number()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Function 9', () => {
+    type T = (() => number) extends () => any ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Function([], Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Function 9', () => {
+    type T = (() => any) extends () => number ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Function 10', () => {
+    type T = (() => Array<any>) extends () => object ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Array(Type.Any())), Type.Function([], Type.Object({})))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Function 11', () => {
+    type T = (() => Array<string>) extends () => object ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Array(Type.String())), Type.Function([], Type.Object({})))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Function 12', () => {
+    type T = (() => object) extends () => Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Object({})), Type.Function([], Type.Array(Type.Any())))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Function 13', () => {
+    type T = ((a: unknown) => number) extends (a: any) => number ? 1 : 2
+    const R = Structural.Check(Type.Function([Type.Unknown()], Type.Number({})), Type.Function([Type.Any()], Type.Number({})))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Function 14', () => {
+    type T = ((a: any) => number) extends (a: unknown) => number ? 1 : 2
+    const R = Structural.Check(Type.Function([Type.Any()], Type.Number({})), Type.Function([Type.Unknown()], Type.Number({})))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Function 15', () => {
+    type T = (() => any) extends () => unknown ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Any({})), Type.Function([], Type.Unknown({})))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Function 16', () => {
+    type T = (() => unknown) extends () => any ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Unknown({})), Type.Function([], Type.Any({})))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Any', () => {
+    type T = (() => number) extends any ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = (() => number) extends string ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = (() => number) extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = (() => number) extends number ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = (() => number) extends number ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array 1', () => {
+    type T = (() => number) extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array 2', () => {
+    type T = (() => number) extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array 3', () => {
+    type T = (() => number) extends Array<string> ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = (() => number) extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = (() => number) extends Record<number, any> ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = (() => number) extends object ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = (() => number) extends {} ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = (() => number) extends { a: number } ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Object({ a: Type.Number() }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 4', () => {
+    type T = (() => number) extends { length: '1' } ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Object({ length: Type.Literal('1') }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 5', () => {
+    type T = (() => number) extends { length: number } ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Object({ length: Type.Number() }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = (() => number) extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Union([Type.Null(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = (() => number) extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = (() => number) extends any | Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 4', () => {
+    type T = (() => number) extends any | Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 5', () => {
+    type T = (() => number) extends any | Array<string> ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.String())]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = (() => number) extends null ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = (() => number) extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Function([], Type.Number()), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+})
diff --git a/test/runtime/conditional/index.ts b/test/runtime/conditional/index.ts
new file mode 100644
index 000000000..0686b6d9d
--- /dev/null
+++ b/test/runtime/conditional/index.ts
@@ -0,0 +1,19 @@
+import './any'
+import './array'
+import './boolean'
+import './constructor'
+import './function'
+import './integer'
+import './literal'
+import './null'
+import './number'
+import './object'
+import './promise'
+import './record'
+import './string'
+import './tuple'
+import './uint8array'
+import './undefined'
+import './union'
+import './unknown'
+import './void'
diff --git a/test/runtime/conditional/integer.ts b/test/runtime/conditional/integer.ts
new file mode 100644
index 000000000..3c384c776
--- /dev/null
+++ b/test/runtime/conditional/integer.ts
@@ -0,0 +1,112 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Integer', () => {
+  it('Should extend Any', () => {
+    type T = number extends any ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = number extends unknown ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = number extends string ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = number extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = number extends number ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Number())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Integer', () => {
+    type T = number extends number ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Array', () => {
+    type T = number extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = number extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = number extends Record<number, any> ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = number extends {} ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = number extends { a: 10 } ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = number extends object ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = number extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = number extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = number extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = number extends null ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = number extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Void', () => {
+    type T = number extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Integer(), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+})
diff --git a/test/runtime/conditional/literal.ts b/test/runtime/conditional/literal.ts
new file mode 100644
index 000000000..994597c2f
--- /dev/null
+++ b/test/runtime/conditional/literal.ts
@@ -0,0 +1,324 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Literal', () => {
+  // -------------------------------------------------------------------
+  // String Literal
+  // -------------------------------------------------------------------
+  it('Should extend Any (String)', () => {
+    type T = 'hello' extends any ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Unknown (String)', () => {
+    type T = 'hello' extends unknown ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String (String)', () => {
+    type T = 'hello' extends string ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.String())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Boolean (String)', () => {
+    type T = 'hello' extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number (String)', () => {
+    type T = 'hello' extends number ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer (String)', () => {
+    type T = 'hello' extends number ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array (String)', () => {
+    type T = 'hello' extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Tuple (String)', () => {
+    type T = 'hello' extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Object 1 (String)', () => {
+    type T = 'hello' extends {} ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 2 (String)', () => {
+    type T = 'hello' extends { a: 10 } ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3 (String)', () => {
+    type T = 'hello' extends object ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 1 (String)', () => {
+    type T = 'hello' extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 2 (String)', () => {
+    type T = 'hello' extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 3 (String)', () => {
+    type T = 'hello' extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Null (String)', () => {
+    type T = 'hello' extends null ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined (String)', () => {
+    type T = 'hello' extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  // -------------------------------------------------------------------
+  // Number Literal
+  // -------------------------------------------------------------------
+
+  it('Should extend Any (Number)', () => {
+    type T = 10 extends any ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Unknown (Number)', () => {
+    type T = 10 extends unknown ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String (Number)', () => {
+    type T = 10 extends string ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean (Number)', () => {
+    type T = 10 extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number (Number)', () => {
+    type T = 10 extends number ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.Number())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Integer (Number)', () => {
+    type T = 10 extends number ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Array (Number)', () => {
+    type T = 10 extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Tuple (Number)', () => {
+    type T = 10 extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Object 1 (Number)', () => {
+    type T = 10 extends {} ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 2 (Number)', () => {
+    type T = 10 extends { a: 10 } ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3 (Number)', () => {
+    type T = 10 extends object ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 1 (Number)', () => {
+    type T = 10 extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 2 (Number)', () => {
+    type T = 10 extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 3 (Number)', () => {
+    type T = 10 extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Null (Number)', () => {
+    type T = 10 extends null ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined (Number)', () => {
+    type T = 10 extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  // -------------------------------------------------------------------
+  // Boolean Literal
+  // -------------------------------------------------------------------
+
+  it('Should extend Any (Boolean)', () => {
+    type T = true extends any ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Unknown (Boolean)', () => {
+    type T = true extends unknown ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String (Boolean)', () => {
+    type T = true extends string ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean (Boolean)', () => {
+    type T = true extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Number (Boolean)', () => {
+    type T = true extends number ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer (Boolean)', () => {
+    type T = true extends number ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array (Boolean)', () => {
+    type T = true extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Tuple (Boolean)', () => {
+    type T = true extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record 1', () => {
+    type T = 'hello' extends Record<number, any> ? 1 : 2
+    const R = Structural.Check(Type.Literal('hello'), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 2', () => {
+    type T = 10 extends Record<number, any> ? 1 : 2
+    const R = Structural.Check(Type.Literal(10), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record 3', () => {
+    type T = true extends Record<number, any> ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 1 (Boolean)', () => {
+    type T = true extends {} ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 2 (Boolean)', () => {
+    type T = true extends { a: 10 } ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3 (Boolean)', () => {
+    type T = true extends object ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 1 (Boolean)', () => {
+    type T = true extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 2 (Boolean)', () => {
+    type T = true extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 3 (Boolean)', () => {
+    type T = true extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Null (Boolean)', () => {
+    type T = true extends null ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined (Boolean)', () => {
+    type T = true extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = true extends void ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+})
diff --git a/test/runtime/conditional/null.ts b/test/runtime/conditional/null.ts
new file mode 100644
index 000000000..d8b91e504
--- /dev/null
+++ b/test/runtime/conditional/null.ts
@@ -0,0 +1,113 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Null', () => {
+  it('Should extend Any', () => {
+    type T = null extends any ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = null extends unknown ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = null extends string ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = null extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = null extends number ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = null extends number ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array', () => {
+    type T = null extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = null extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = null extends Record<number, any> ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = null extends {} ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = null extends { a: 10 } ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = null extends object ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = null extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = null extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = null extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Null', () => {
+    type T = null extends null ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Null())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = null extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = null extends void ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+})
diff --git a/test/runtime/conditional/number.ts b/test/runtime/conditional/number.ts
new file mode 100644
index 000000000..35e6f7c68
--- /dev/null
+++ b/test/runtime/conditional/number.ts
@@ -0,0 +1,111 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Number', () => {
+  it('Should extend Any', () => {
+    type T = number extends any ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+  it('Should extend Unknown', () => {
+    type T = number extends unknown ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+  it('Should extend String', () => {
+    type T = number extends string ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = number extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = number extends number ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Number())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Integer', () => {
+    type T = number extends number ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Array', () => {
+    type T = number extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = number extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = number extends Record<number, any> ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = number extends {} ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = number extends { a: 10 } ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = number extends object ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = number extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = number extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = number extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = number extends null ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = number extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = number extends void ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+})
diff --git a/test/runtime/conditional/object.ts b/test/runtime/conditional/object.ts
new file mode 100644
index 000000000..3452661ef
--- /dev/null
+++ b/test/runtime/conditional/object.ts
@@ -0,0 +1,155 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Object', () => {
+  // ----------------------------------------------------------
+  // Record
+  // ----------------------------------------------------------
+
+  it('Should extend Record 1', () => {
+    type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
+    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
+    const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 2', () => {
+    type T = { a: number; b: number } extends Record<string, number> ? 1 : 2
+    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
+    const B = Type.Record(Type.String(), Type.Number())
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 3', () => {
+    type T = { a: number; b: number } extends Record<number, number> ? 1 : 2
+    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
+    const B = Type.Record(Type.Number(), Type.Number())
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 4', () => {
+    type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
+    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
+    const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 5', () => {
+    type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
+    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
+    const B = Type.Record(Type.String(), Type.Number())
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 6', () => {
+    type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
+    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
+    const B = Type.Record(Type.Number(), Type.Number())
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  // ----------------------------------------------------------
+  // Standard
+  // ----------------------------------------------------------
+
+  it('Should extend Any', () => {
+    type T = { a: number } extends any ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = { a: number } extends string ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = { a: number } extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = { a: number } extends number ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = { a: number } extends number ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array', () => {
+    type T = { a: number } extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Tuple', () => {
+    type T = { a: number } extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Object 1', () => {
+    type T = { a: number } extends {} ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = { a: number } extends { a: 10 } ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Object({ a: Type.Literal(10) }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = { a: number } extends object ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = { a: number } extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Union([Type.Null(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = { a: number } extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = { a: number } extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Null', () => {
+    type T = { a: number } extends null ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = { a: number } extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = { a: number } extends void ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+})
diff --git a/test/runtime/conditional/promise.ts b/test/runtime/conditional/promise.ts
new file mode 100644
index 000000000..77de0358d
--- /dev/null
+++ b/test/runtime/conditional/promise.ts
@@ -0,0 +1,245 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Promise', () => {
+  // ----------------------------------------------
+  // Generic Varying
+  // ----------------------------------------------
+
+  it('Should extend Promise Varying 1', () => {
+    type T = Promise<any> extends Promise<any> ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Promise(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Promise Varying 2', () => {
+    type T = Promise<string> extends Promise<any> ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.String()), Type.Promise(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Promise Varying 3', () => {
+    type T = Promise<any> extends Promise<string> ? 1 : 2 // 1
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Promise(Type.String()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Promise Varying 4', () => {
+    type T = Promise<number> extends Promise<string> ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Promise(Type.String()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  // ----------------------------------------------
+  // Any
+  // ----------------------------------------------
+
+  it('Should extend Any', () => {
+    type T = Promise<any> extends any ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = Promise<any> extends unknown ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = Promise<any> extends string ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = Promise<any> extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = Promise<any> extends number ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = Promise<any> extends number ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array', () => {
+    type T = Promise<any> extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = Promise<any> extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = Promise<any> extends Record<number, any> ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = Promise<any> extends {} ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = Promise<any> extends { a: 10 } ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = Promise<any> extends object ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = Promise<any> extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = Promise<any> extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = Promise<any> extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Null', () => {
+    type T = Promise<any> extends null ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = Promise<any> extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  // ----------------------------------------------
+  // Constrained
+  // ----------------------------------------------
+
+  it('Should extend constrained Any', () => {
+    type T = Promise<number> extends any ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained Unknown', () => {
+    type T = Promise<number> extends unknown ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained String', () => {
+    type T = Promise<number> extends string ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Boolean', () => {
+    type T = Promise<number> extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Number', () => {
+    type T = Promise<number> extends number ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Any()), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Integer', () => {
+    type T = Promise<number> extends number ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Array', () => {
+    type T = Promise<number> extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Tuple', () => {
+    type T = Promise<number> extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Object 1', () => {
+    type T = Promise<number> extends {} ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained Object 2', () => {
+    type T = Promise<number> extends { a: 10 } ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Object 3', () => {
+    type T = Promise<number> extends object ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained Union 1', () => {
+    type T = Promise<number> extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Union 2', () => {
+    type T = Promise<number> extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend constrained Union 2', () => {
+    type T = Promise<number> extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Null', () => {
+    type T = Promise<number> extends null ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend constrained Undefined', () => {
+    type T = Promise<number> extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = Promise<number> extends void ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+})
diff --git a/test/runtime/conditional/record.ts b/test/runtime/conditional/record.ts
new file mode 100644
index 000000000..4e4e0cb7c
--- /dev/null
+++ b/test/runtime/conditional/record.ts
@@ -0,0 +1,182 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Record', () => {
+  it('Should extend Record 1', () => {
+    type T = Record<'a' | 'b', number> extends { a: number; b: number } ? 1 : 2
+    const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
+    const B = Type.Object({ a: Type.Number(), b: Type.Number() })
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 2', () => {
+    type T = Record<string, number> extends { a: number; b: number } ? 1 : 2
+    const A = Type.Record(Type.String(), Type.Number())
+    const B = Type.Object({ a: Type.Number(), b: Type.Number() })
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record 3', () => {
+    type T = Record<number, number> extends { a: number; b: number } ? 1 : 2
+    const A = Type.Record(Type.Number(), Type.Number())
+    const B = Type.Object({ a: Type.Number(), b: Type.Number() })
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record 4', () => {
+    type T = Record<'a' | 'b', number> extends { a: number; b: number } ? 1 : 2
+    const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
+    const B = Type.Object({ a: Type.Number(), b: Type.Number() })
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 5', () => {
+    type T = Record<'a' | 'b', number> extends { a: number; b: number } ? 1 : 2
+    const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
+    const B = Type.Object({ a: Type.Number(), b: Type.Number() })
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 6', () => {
+    type T = Record<string, number> extends Record<'a' | 'b', number> ? true : false
+    const A = Type.Record(Type.String(), Type.Number())
+    const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 7', () => {
+    type T = Record<string, number> extends Record<string, number> ? 1 : 2
+    const A = Type.Record(Type.String(), Type.Number())
+    const B = Type.Record(Type.String(), Type.Number())
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+  it('Should extend Record 8', () => {
+    type T = Record<string, number> extends Record<number, number> ? 1 : 2
+    const A = Type.Record(Type.String(), Type.Number())
+    const B = Type.Record(Type.Number(), Type.Number())
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+  it('Should extend Record 9', () => {
+    type T = Record<number, number> extends Record<'a' | 'b', number> ? 1 : 2
+    const A = Type.Record(Type.Number(), Type.Number())
+    const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Record 10', () => {
+    type T = Record<number, number> extends Record<string, number> ? 1 : 2
+    const A = Type.Record(Type.Number(), Type.Number())
+    const B = Type.Record(Type.String(), Type.Number())
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+  it('Should extend Record 11', () => {
+    type T = Record<number, number> extends Record<number, number> ? 1 : 2
+    const A = Type.Record(Type.Number(), Type.Number())
+    const B = Type.Record(Type.Number(), Type.Number())
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  // -------------------------------------------------------------------
+  // Standard
+  // -------------------------------------------------------------------
+
+  it('Should extend Any', () => {
+    type T = Record<number, number> extends any ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = Record<number, number> extends unknown ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = Record<number, number> extends string ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Boolean', () => {
+    type T = Record<number, number> extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Number', () => {
+    type T = Record<number, number> extends number ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Integer', () => {
+    type T = Record<number, number> extends number ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Array 1', () => {
+    type T = Record<number, number> extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Array 2', () => {
+    type T = Record<number, number> extends Array<string> ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.String()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Tuple', () => {
+    type T = Record<number, number> extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Object 1', () => {
+    type T = Record<number, number> extends object ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+  it('Should extend Object 2', () => {
+    type T = Record<number, number> extends {} ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+  it('Should extend Object 3', () => {
+    type T = Record<number, number> extends { a: number } ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Object({ a: Type.Number() }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Union 1', () => {
+    type T = Record<number, number> extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Union 2', () => {
+    type T = Record<number, number> extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Any(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+  it('Should extend Null', () => {
+    type T = Record<number, number> extends null ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Undefined', () => {
+    type T = Record<number, number> extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = Record<number, number> extends void ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+})
diff --git a/test/runtime/conditional/string.ts b/test/runtime/conditional/string.ts
new file mode 100644
index 000000000..42c02aa1e
--- /dev/null
+++ b/test/runtime/conditional/string.ts
@@ -0,0 +1,143 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/String', () => {
+  it('Should extend Any', () => {
+    type T = string extends any ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = string extends unknown ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = string extends string ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.String())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = string extends boolean ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = string extends number ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = string extends number ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array', () => {
+    type T = string extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = string extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record 1', () => {
+    type T = string extends Record<number, any> ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 2', () => {
+    type T = string extends Record<number, unknown> ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.Unknown()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 3', () => {
+    type T = string extends Record<number, string> ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.String()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 4', () => {
+    type T = string extends Record<number, number> ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.Number()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record 5', () => {
+    type T = string extends Record<any, number | string> ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.Union([Type.Number(), Type.String()])))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record 6', () => {
+    type T = string extends Record<any, {}> ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = string extends {} ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = string extends { a: 10 } ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = string extends object ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = number extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = number extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = number extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = number extends null ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = number extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = number extends void ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+})
diff --git a/test/runtime/conditional/tuple.ts b/test/runtime/conditional/tuple.ts
new file mode 100644
index 000000000..6c2d025e2
--- /dev/null
+++ b/test/runtime/conditional/tuple.ts
@@ -0,0 +1,196 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Tuple', () => {
+  it('Should extend Any', () => {
+    type T = [string, number] extends any ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = [string, number] extends string ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = [string, number] extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = [string, number] extends number ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = [string, number] extends number ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array 1', () => {
+    type T = [string, number] extends Array<any> ? 1 : 2 // 1
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Array 2', () => {
+    type T = [string, number] extends Array<string> ? 1 : 2 // 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.String()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array 3', () => {
+    type T = [string, number] extends Array<string | number> ? 1 : 2 // 1
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Union([Type.String(), Type.Number()])))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+  it('Should extend Array 4', () => {
+    type T = [string, number] extends Array<string | number | boolean> ? 1 : 2 // 1
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Union([Type.String(), Type.Number(), Type.Boolean()])))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Tuple 1', () => {
+    type T = [string, number] extends [string, number] ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Tuple 2', () => {
+    type T = [string, number] extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Tuple 3', () => {
+    type T = [string, any] extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Any()]), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Tuple 4', () => {
+    type T = [string, number] extends [string, any] ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Any()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Tuple 5', () => {
+    type T = [string, unknown] extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Unknown()]), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Tuple 6', () => {
+    type T = [string, number] extends [string, unknown] ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Unknown()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Tuple 7', () => {
+    type T = [] extends [string, number] ? 1 : 2
+    const R = Structural.Check(Type.Tuple([]), Type.Tuple([Type.String(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Tuple 8', () => {
+    type T = [string, number] extends [] ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record 1', () => {
+    type T = [string, number] extends Record<number, any> ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 2', () => {
+    type T = [string, number] extends Record<number, unknown> ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.Unknown()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 3', () => {
+    type T = [string, number] extends Record<number, string> ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.String()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 4', () => {
+    type T = [string, number] extends Record<number, number> ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.Number()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record 5', () => {
+    type T = [string, number] extends Record<any, number | string> ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.Union([Type.Number(), Type.String()])))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record 6', () => {
+    type T = [string, number] extends Record<any, {}> ? 1 : 2
+    const R = Structural.Check(Type.String(), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = [string, number] extends {} ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = [string, number] extends { a: 10 } ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = [string, number] extends object ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = [string, number] extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = [string, number] extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = [string, number] extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Null', () => {
+    type T = [string, number] extends null ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = [string, number] extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = [string, number] extends void ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+})
diff --git a/test/runtime/conditional/uint8array.ts b/test/runtime/conditional/uint8array.ts
new file mode 100644
index 000000000..ddfef9031
--- /dev/null
+++ b/test/runtime/conditional/uint8array.ts
@@ -0,0 +1,112 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Uint8Array', () => {
+  it('Should extend Any', () => {
+    type T = Uint8Array extends any ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = Uint8Array extends unknown ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = Uint8Array extends string ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = Uint8Array extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = Uint8Array extends number ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = Uint8Array extends number ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array', () => {
+    type T = Uint8Array extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Tuple', () => {
+    type T = Uint8Array extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = Uint8Array extends Record<number, any> ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = Uint8Array extends {} ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = Uint8Array extends { a: 10 } ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = Uint8Array extends object ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = Uint8Array extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = Uint8Array extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = Uint8Array extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Null', () => {
+    type T = Uint8Array extends null ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = Uint8Array extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = Uint8Array extends void ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+})
diff --git a/test/runtime/conditional/undefined.ts b/test/runtime/conditional/undefined.ts
new file mode 100644
index 000000000..3bacbf798
--- /dev/null
+++ b/test/runtime/conditional/undefined.ts
@@ -0,0 +1,100 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Undefined', () => {
+  it('Should extend Any', () => {
+    type T = undefined extends any ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = undefined extends string ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = undefined extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = undefined extends number ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = undefined extends number ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array', () => {
+    type T = undefined extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = undefined extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = undefined extends {} ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = undefined extends { a: 10 } ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = undefined extends object ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = undefined extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = undefined extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = undefined extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Null', () => {
+    type T = undefined extends null ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = undefined extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+  it('Should extend Void', () => {
+    type T = undefined extends void ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.Void())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+})
diff --git a/test/runtime/conditional/union.ts b/test/runtime/conditional/union.ts
new file mode 100644
index 000000000..26e06a812
--- /dev/null
+++ b/test/runtime/conditional/union.ts
@@ -0,0 +1,142 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Union', () => {
+  it('Should extend Any', () => {
+    type T = number | string extends any ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = number | string extends string ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = number | string extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = number | string extends number ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = number | string extends number ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array', () => {
+    type T = number | string extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Tuple', () => {
+    type T = number | string extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = number | string extends {} ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = number | string extends { a: 10 } ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = number | string extends object ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = number | string extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = number | string extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = number | string extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 4', () => {
+    type T = any | boolean extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+
+  it('Should extend Union 5', () => {
+    type T = any | string extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+
+  it('Should extend Union 6', () => {
+    type T = any | {} extends {} ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+
+  it('Should extend Union 7', () => {
+    type T = any extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
+
+  it('Should extend Union 8', () => {
+    type T = unknown | string extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Unknown(), Type.String()]), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 9', () => {
+    type T = unknown extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Null', () => {
+    type T = number | string extends null ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = number | string extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = number | string extends void ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void 2', () => {
+    type T = number | string | void extends void ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+})
diff --git a/test/runtime/conditional/unknown.ts b/test/runtime/conditional/unknown.ts
new file mode 100644
index 000000000..8025a6b77
--- /dev/null
+++ b/test/runtime/conditional/unknown.ts
@@ -0,0 +1,119 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Unknown', () => {
+  it('Should extend Any', () => {
+    type T = unknown extends any ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = unknown extends unknown ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = unknown extends string ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = unknown extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = unknown extends number ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = unknown extends number ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array 1', () => {
+    type T = unknown extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array 2', () => {
+    type T = unknown extends Array<string> ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Array(Type.String()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = unknown extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = unknown extends object ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = unknown extends {} ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = unknown extends { a: number } ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Object({ a: Type.Number() }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = unknown extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = unknown extends any | number ? 1 : 2 // 1
+    const R = Structural.Check(Type.Unknown(), Type.Union([Type.Any(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = unknown extends unknown | number ? 1 : 2 // 1
+    const R = Structural.Check(Type.Unknown(), Type.Union([Type.Unknown(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 4', () => {
+    type T = unknown extends unknown | any ? 1 : 2 // 1
+    const R = Structural.Check(Type.Unknown(), Type.Union([Type.Unknown(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = unknown extends null ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = unknown extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = unknown extends void ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+})
diff --git a/test/runtime/conditional/void.ts b/test/runtime/conditional/void.ts
new file mode 100644
index 000000000..289f3dfdc
--- /dev/null
+++ b/test/runtime/conditional/void.ts
@@ -0,0 +1,119 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Void', () => {
+  it('Should extend Any', () => {
+    type T = void extends any ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = void extends unknown ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = void extends string ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = void extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = void extends number ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = void extends number ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array 1', () => {
+    type T = void extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array 2', () => {
+    type T = void extends Array<string> ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.Array(Type.String()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = void extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = void extends object ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = void extends {} ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = void extends { a: number } ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.Object({ a: Type.Number() }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = void extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = void extends any | number ? 1 : 2 // 1
+    const R = Structural.Check(Type.Void(), Type.Union([Type.Any(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = void extends unknown | number ? 1 : 2 // 1
+    const R = Structural.Check(Type.Void(), Type.Union([Type.Unknown(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 4', () => {
+    type T = void extends unknown | any ? 1 : 2 // 1
+    const R = Structural.Check(Type.Void(), Type.Union([Type.Unknown(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = void extends null ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = void extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = void extends void ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.Void())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+})
diff --git a/test/runtime/format/format.ts b/test/runtime/format/format.ts
new file mode 100644
index 000000000..e867d5a41
--- /dev/null
+++ b/test/runtime/format/format.ts
@@ -0,0 +1,25 @@
+import { Format } from '@sinclair/typebox/format'
+import { Assert } from '../assert/index'
+
+describe('format/Format', () => {
+  it('Should set format', () => {
+    Format.Set('test#format1', () => true)
+  })
+
+  it('Should get format', () => {
+    Format.Set('test#format2', () => true)
+    const format = Format.Get('test#format2')
+    Assert.equal(typeof format, 'function')
+  })
+
+  it('Should return true if exists', () => {
+    Format.Set('test#format3', () => true)
+    Assert.equal(Format.Has('test#format3'), true)
+  })
+
+  it('Should clear formats', () => {
+    Format.Set('test#format4', () => true)
+    Format.Clear()
+    Assert.equal(Format.Has('test#format4'), false)
+  })
+})
diff --git a/test/runtime/format/index.ts b/test/runtime/format/index.ts
new file mode 100644
index 000000000..78c71b23b
--- /dev/null
+++ b/test/runtime/format/index.ts
@@ -0,0 +1 @@
+import './format'
diff --git a/test/runtime/guard/any.ts b/test/runtime/guard/any.ts
new file mode 100644
index 000000000..e2b5a7b74
--- /dev/null
+++ b/test/runtime/guard/any.ts
@@ -0,0 +1,19 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TAny', () => {
+  it('should guard for TAny', () => {
+    const R = TypeGuard.TAny(Type.Any())
+    Assert.equal(R, true)
+  })
+  it('should not guard for TAny', () => {
+    const R = TypeGuard.TAny(null)
+    Assert.equal(R, false)
+  })
+  it('should not guard for TAny with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TAny(Type.Any({ $id: 1 }))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/array.ts b/test/runtime/guard/array.ts
new file mode 100644
index 000000000..088f39653
--- /dev/null
+++ b/test/runtime/guard/array.ts
@@ -0,0 +1,63 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TArray', () => {
+  it('should guard for TArray', () => {
+    const R = TypeGuard.TArray(Type.Array(Type.Number()))
+    Assert.equal(R, true)
+  })
+
+  it('should not guard for TArray', () => {
+    const R = TypeGuard.TArray(null)
+    Assert.equal(R, false)
+  })
+
+  it('should guard for nested object TArray', () => {
+    const R = TypeGuard.TArray(
+      Type.Array(
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ),
+    )
+    Assert.equal(R, true)
+  })
+
+  it('should not guard for nested object TArray', () => {
+    const R = TypeGuard.TArray(
+      Type.Array(
+        Type.Object({
+          x: Type.Number(),
+          y: {} as any,
+        }),
+      ),
+    )
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TArray with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TArray(Type.Array(Type.Number(), { $id: 1 }))
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TArray with invalid minItems', () => {
+    // @ts-ignore
+    const R = TypeGuard.TArray(Type.Array(Type.String(), { minItems: '1' }))
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TArray with invalid maxItems', () => {
+    // @ts-ignore
+    const R = TypeGuard.TArray(Type.Array(Type.String(), { maxItems: '1' }))
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TArray with invalid uniqueItems', () => {
+    // @ts-ignore
+    const R = TypeGuard.TArray(Type.Array(Type.String(), { uniqueItems: '1' }))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/boolean.ts b/test/runtime/guard/boolean.ts
new file mode 100644
index 000000000..52c94c877
--- /dev/null
+++ b/test/runtime/guard/boolean.ts
@@ -0,0 +1,19 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TBoolean', () => {
+  it('should guard for TBoolean', () => {
+    const R = TypeGuard.TBoolean(Type.Boolean())
+    Assert.equal(R, true)
+  })
+  it('should not guard for TBoolean', () => {
+    const R = TypeGuard.TBoolean(null)
+    Assert.equal(R, false)
+  })
+  it('should not guard for TBoolean with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TBoolean(Type.Boolean({ $id: 1 }))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/constructor.ts b/test/runtime/guard/constructor.ts
new file mode 100644
index 000000000..e584c0609
--- /dev/null
+++ b/test/runtime/guard/constructor.ts
@@ -0,0 +1,35 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TConstructor', () => {
+  it('should guard for TConstructor', () => {
+    const R = TypeGuard.TConstructor(Type.Constructor([], Type.Number()))
+    Assert.equal(R, true)
+  })
+  it('should not guard for TConstructor', () => {
+    const R = TypeGuard.TConstructor(null)
+    Assert.equal(R, false)
+  })
+  it('should not guard for TConstructor with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TConstructor(Type.Constructor([], Type.Number(), { $id: 1 }))
+    Assert.equal(R, false)
+  })
+  it('should not guard for TConstructor with invalid Params', () => {
+    const R = TypeGuard.TConstructor(Type.Constructor([{} as any, {} as any], Type.Number()))
+    Assert.equal(R, false)
+  })
+  it('should not guard for TConstructor with invalid Return', () => {
+    const R = TypeGuard.TConstructor(Type.Constructor([], {} as any))
+    Assert.equal(R, false)
+  })
+  it('should guard for TConstructor with empty TTuple', () => {
+    const R = TypeGuard.TConstructor(Type.Constructor(Type.Tuple([]), Type.Number()))
+    Assert.equal(R, true)
+  })
+  it('should guard for TConstructor with array TTuple', () => {
+    const R = TypeGuard.TConstructor(Type.Constructor(Type.Tuple([Type.Number(), Type.String()]), Type.Number()))
+    Assert.equal(R, true)
+  })
+})
diff --git a/test/runtime/guard/function.ts b/test/runtime/guard/function.ts
new file mode 100644
index 000000000..3cff158a8
--- /dev/null
+++ b/test/runtime/guard/function.ts
@@ -0,0 +1,35 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TFunction', () => {
+  it('should guard for TFunction', () => {
+    const R = TypeGuard.TFunction(Type.Function([], Type.Number()))
+    Assert.equal(R, true)
+  })
+  it('should not guard for TFunction', () => {
+    const R = TypeGuard.TFunction(null)
+    Assert.equal(R, false)
+  })
+  it('should not guard for TFunction with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TFunction(Type.Function([], Type.Number(), { $id: 1 }))
+    Assert.equal(R, false)
+  })
+  it('should not guard for TFunction with invalid Params', () => {
+    const R = TypeGuard.TFunction(Type.Function([{} as any, {} as any], Type.Number()))
+    Assert.equal(R, false)
+  })
+  it('should not guard for TFunction with invalid Return', () => {
+    const R = TypeGuard.TFunction(Type.Function([], {} as any))
+    Assert.equal(R, false)
+  })
+  it('should guard for TFunction with empty TTuple', () => {
+    const R = TypeGuard.TFunction(Type.Function(Type.Tuple([]), Type.Number()))
+    Assert.equal(R, true)
+  })
+  it('should guard for TFunction with array TTuple', () => {
+    const R = TypeGuard.TFunction(Type.Function(Type.Tuple([Type.Number(), Type.String()]), Type.Number()))
+    Assert.equal(R, true)
+  })
+})
diff --git a/test/runtime/guard/index.ts b/test/runtime/guard/index.ts
new file mode 100644
index 000000000..804c4865c
--- /dev/null
+++ b/test/runtime/guard/index.ts
@@ -0,0 +1,21 @@
+import './any'
+import './array'
+import './boolean'
+import './constructor'
+import './function'
+import './integer'
+import './literal'
+import './null'
+import './number'
+import './object'
+import './promise'
+import './record'
+import './ref'
+import './self'
+import './string'
+import './tuple'
+import './uint8array'
+import './undefined'
+import './union'
+import './unknown'
+import './void'
diff --git a/test/runtime/guard/integer.ts b/test/runtime/guard/integer.ts
new file mode 100644
index 000000000..d53536b6e
--- /dev/null
+++ b/test/runtime/guard/integer.ts
@@ -0,0 +1,44 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TInteger', () => {
+  it('should guard for TInteger', () => {
+    const R = TypeGuard.TInteger(Type.Integer())
+    Assert.equal(R, true)
+  })
+  it('should not guard for TInteger', () => {
+    const R = TypeGuard.TInteger(null)
+    Assert.equal(R, false)
+  })
+  it('should not guard for TInteger with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TInteger(Type.Integer({ $id: 1 }))
+    Assert.equal(R, false)
+  })
+  it('should not guard for TInteger with invalid multipleOf', () => {
+    // @ts-ignore
+    const R = TypeGuard.TInteger(Type.Integer({ multipleOf: '1' }))
+    Assert.equal(R, false)
+  })
+  it('should not guard for TInteger with invalid minimum', () => {
+    // @ts-ignore
+    const R = TypeGuard.TInteger(Type.Integer({ minimum: '1' }))
+    Assert.equal(R, false)
+  })
+  it('should not guard for TInteger with invalid maximum', () => {
+    // @ts-ignore
+    const R = TypeGuard.TInteger(Type.Integer({ maximum: '1' }))
+    Assert.equal(R, false)
+  })
+  it('should not guard for TInteger with invalid exclusiveMinimum', () => {
+    // @ts-ignore
+    const R = TypeGuard.TInteger(Type.Integer({ exclusiveMinimum: '1' }))
+    Assert.equal(R, false)
+  })
+  it('should not guard for TInteger with invalid exclusiveMaximum', () => {
+    // @ts-ignore
+    const R = TypeGuard.TInteger(Type.Integer({ exclusiveMaximum: '1' }))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/literal.ts b/test/runtime/guard/literal.ts
new file mode 100644
index 000000000..efe372437
--- /dev/null
+++ b/test/runtime/guard/literal.ts
@@ -0,0 +1,32 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TLiteral', () => {
+  it('should guard for TLiteral of String', () => {
+    const R = TypeGuard.TLiteral(Type.Literal('hello'))
+    Assert.equal(R, true)
+  })
+  it('should guard for TLiteral of Number', () => {
+    const R = TypeGuard.TLiteral(Type.Literal(42))
+    Assert.equal(R, true)
+  })
+  it('should guard for TLiteral of Boolean', () => {
+    const R = TypeGuard.TLiteral(Type.Literal(true))
+    Assert.equal(R, true)
+  })
+  it('should not guard for TLiteral of Null', () => {
+    // @ts-ignore
+    const R = TypeGuard.TLiteral(Type.Literal(null))
+    Assert.equal(R, false)
+  })
+  it('should not guard for TLiteral', () => {
+    const R = TypeGuard.TLiteral(null)
+    Assert.equal(R, false)
+  })
+  it('should not guard for TLiteral with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TLiteral(Type.Literal(42, { $id: 1 }))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/null.ts b/test/runtime/guard/null.ts
new file mode 100644
index 000000000..36f8df40b
--- /dev/null
+++ b/test/runtime/guard/null.ts
@@ -0,0 +1,19 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TNull', () => {
+  it('should guard for TNull', () => {
+    const R = TypeGuard.TNull(Type.Null())
+    Assert.equal(R, true)
+  })
+  it('should not guard for TNull', () => {
+    const R = TypeGuard.TNull(null)
+    Assert.equal(R, false)
+  })
+  it('should not guard for TNull with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TNull(Type.Null({ $id: 1 }))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/number.ts b/test/runtime/guard/number.ts
new file mode 100644
index 000000000..9ea80b538
--- /dev/null
+++ b/test/runtime/guard/number.ts
@@ -0,0 +1,44 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TNumber', () => {
+  it('should guard for TNumber', () => {
+    const R = TypeGuard.TNumber(Type.Number())
+    Assert.equal(R, true)
+  })
+  it('should not guard for TNumber', () => {
+    const R = TypeGuard.TNumber(null)
+    Assert.equal(R, false)
+  })
+  it('should not guard for TNumber with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TNumber(Type.Number({ $id: 1 }))
+    Assert.equal(R, false)
+  })
+  it('should not guard for TNumber with invalid multipleOf', () => {
+    // @ts-ignore
+    const R = TypeGuard.TNumber(Type.Number({ multipleOf: '1' }))
+    Assert.equal(R, false)
+  })
+  it('should not guard for TNumber with invalid minimum', () => {
+    // @ts-ignore
+    const R = TypeGuard.TNumber(Type.Number({ minimum: '1' }))
+    Assert.equal(R, false)
+  })
+  it('should not guard for TNumber with invalid maximum', () => {
+    // @ts-ignore
+    const R = TypeGuard.TNumber(Type.Number({ maximum: '1' }))
+    Assert.equal(R, false)
+  })
+  it('should not guard for TNumber with invalid exclusiveMinimum', () => {
+    // @ts-ignore
+    const R = TypeGuard.TNumber(Type.Number({ exclusiveMinimum: '1' }))
+    Assert.equal(R, false)
+  })
+  it('should not guard for TNumber with invalid exclusiveMaximum', () => {
+    // @ts-ignore
+    const R = TypeGuard.TNumber(Type.Number({ exclusiveMaximum: '1' }))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/object.ts b/test/runtime/guard/object.ts
new file mode 100644
index 000000000..a4503e2c5
--- /dev/null
+++ b/test/runtime/guard/object.ts
@@ -0,0 +1,99 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TObject', () => {
+  it('should guard for TObject', () => {
+    const R = TypeGuard.TObject(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+    )
+    Assert.equal(R, true)
+  })
+
+  it('should not guard for TObject', () => {
+    const R = TypeGuard.TObject(null)
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TObject with escape characters in property key', () => {
+    const R = TypeGuard.TObject(
+      Type.Object({
+        'hello\nworld': Type.Number(),
+      }),
+    )
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TObject with invalid property values', () => {
+    const R = TypeGuard.TObject(
+      Type.Object({
+        x: Type.Number(),
+        y: {} as any,
+      }),
+    )
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TObject with invalid additionalProperties', () => {
+    const R = TypeGuard.TObject(
+      Type.Object(
+        {
+          x: Type.Number(),
+        },
+        {
+          // @ts-ignore
+          additionalProperties: 'true',
+        },
+      ),
+    )
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TObject with invalid $id', () => {
+    const R = TypeGuard.TObject(
+      Type.Object(
+        {
+          x: Type.Number(),
+        },
+        {
+          // @ts-ignore
+          $id: 1,
+        },
+      ),
+    )
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TObject with invalid minProperties', () => {
+    const R = TypeGuard.TObject(
+      Type.Object(
+        {
+          x: Type.Number(),
+        },
+        {
+          // @ts-ignore
+          minProperties: '1',
+        },
+      ),
+    )
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TObject with invalid maxProperties', () => {
+    const R = TypeGuard.TObject(
+      Type.Object(
+        {
+          x: Type.Number(),
+        },
+        {
+          // @ts-ignore
+          maxProperties: '1',
+        },
+      ),
+    )
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/promise.ts b/test/runtime/guard/promise.ts
new file mode 100644
index 000000000..0610bc319
--- /dev/null
+++ b/test/runtime/guard/promise.ts
@@ -0,0 +1,45 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TPromise', () => {
+  it('should guard for TPromise', () => {
+    const R = TypeGuard.TPromise(Type.Promise(Type.Number()))
+    Assert.equal(R, true)
+  })
+
+  it('should not guard for TPromise', () => {
+    const R = TypeGuard.TPromise(null)
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TPromise with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TPromise(Type.Promise(Type.Number(), { $id: 1 }))
+    Assert.equal(R, false)
+  })
+
+  it('should guard for TPromise with nested TObject', () => {
+    const R = TypeGuard.TPromise(
+      Type.Promise(
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ),
+    )
+    Assert.equal(R, true)
+  })
+
+  it('should not guard for TPromise with nested TObject', () => {
+    const R = TypeGuard.TPromise(
+      Type.Promise(
+        Type.Object({
+          x: Type.Number(),
+          y: {} as any,
+        }),
+      ),
+    )
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/record.ts b/test/runtime/guard/record.ts
new file mode 100644
index 000000000..718f56e65
--- /dev/null
+++ b/test/runtime/guard/record.ts
@@ -0,0 +1,53 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TRecord', () => {
+  it('should guard for TRecord', () => {
+    const R = TypeGuard.TRecord(Type.Record(Type.String(), Type.Number()))
+    Assert.equal(R, true)
+  })
+
+  it('should guard for TRecord with TObject value', () => {
+    const R = TypeGuard.TRecord(
+      Type.Record(
+        Type.String(),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ),
+    )
+    Assert.equal(R, true)
+  })
+
+  it('should not guard for TRecord', () => {
+    const R = TypeGuard.TRecord(null)
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TRecord with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TRecord(Type.Record(Type.String(), Type.Number(), { $id: 1 }))
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TRecord with TObject value with invalid Property', () => {
+    const R = TypeGuard.TRecord(
+      Type.Record(
+        Type.String(),
+        Type.Object({
+          x: Type.Number(),
+          y: {} as any,
+        }),
+      ),
+    )
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TRecord with invalid literal key', () => {
+    const K = Type.Union([Type.Literal('hello\nworld')])
+    const R = TypeGuard.TRecord(Type.Record(K, Type.Number()))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/ref.ts b/test/runtime/guard/ref.ts
new file mode 100644
index 000000000..ecc260cb6
--- /dev/null
+++ b/test/runtime/guard/ref.ts
@@ -0,0 +1,25 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TRef', () => {
+  it('should guard for TRef', () => {
+    const T = Type.Number({ $id: 'T' })
+    const R = TypeGuard.TRef(Type.Ref(T))
+    Assert.equal(R, true)
+  })
+
+  it('should not guard for TRef', () => {
+    const R = TypeGuard.TRef(null)
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TRef with invalid $ref', () => {
+    const T = Type.Number({ $id: 'T' })
+    const S = Type.Ref(T)
+    // @ts-ignore
+    S.$ref = 1
+    const R = TypeGuard.TRef(S)
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/self.ts b/test/runtime/guard/self.ts
new file mode 100644
index 000000000..8777789de
--- /dev/null
+++ b/test/runtime/guard/self.ts
@@ -0,0 +1,22 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TSelf', () => {
+  it('should guard for TSelf', () => {
+    Type.Recursive((Node) => {
+      const R = TypeGuard.TSelf(Node)
+      Assert.equal(R, true)
+      return Type.Object({ nodes: Type.Array(Node) })
+    })
+  })
+  it('should guard for TSelf with invalid $ref', () => {
+    Type.Recursive((Node) => {
+      // @ts-ignore
+      Node.$ref = 1
+      const R = TypeGuard.TSelf(Node)
+      Assert.equal(R, false)
+      return Type.Object({ nodes: Type.Array(Node) })
+    })
+  })
+})
diff --git a/test/runtime/guard/string.ts b/test/runtime/guard/string.ts
new file mode 100644
index 000000000..598b9bf15
--- /dev/null
+++ b/test/runtime/guard/string.ts
@@ -0,0 +1,39 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TString', () => {
+  it('should guard for TString', () => {
+    const R = TypeGuard.TString(Type.String())
+    Assert.equal(R, true)
+  })
+
+  it('should not guard for TString', () => {
+    const R = TypeGuard.TString(null)
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TString with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TString(Type.String({ $id: 1 }))
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TString with invalid minLength', () => {
+    // @ts-ignore
+    const R = TypeGuard.TString(Type.String({ minLength: '1' }))
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TString with invalid maxLength', () => {
+    // @ts-ignore
+    const R = TypeGuard.TString(Type.String({ maxLength: '1' }))
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TString with invalid pattern', () => {
+    // @ts-ignore
+    const R = TypeGuard.TString(Type.String({ pattern: 1 }))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/tuple.ts b/test/runtime/guard/tuple.ts
new file mode 100644
index 000000000..765714caf
--- /dev/null
+++ b/test/runtime/guard/tuple.ts
@@ -0,0 +1,23 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TTuple', () => {
+  it('should guard for TTuple', () => {
+    const R = TypeGuard.TTuple(Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.equal(R, true)
+  })
+  it('should not guard for TTuple', () => {
+    const R = TypeGuard.TTuple(null)
+    Assert.equal(R, false)
+  })
+  it('should not guard for TTuple with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TTuple(Type.Tuple([Type.Number(), Type.Number()], { $id: 1 }))
+    Assert.equal(R, false)
+  })
+  it('should not guard for TTuple with invalid Items', () => {
+    const R = TypeGuard.TTuple(Type.Tuple([Type.Number(), {} as any]))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/uint8array.ts b/test/runtime/guard/uint8array.ts
new file mode 100644
index 000000000..963d7ad4d
--- /dev/null
+++ b/test/runtime/guard/uint8array.ts
@@ -0,0 +1,33 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TUint8Array', () => {
+  it('should guard for TUint8Array', () => {
+    const R = TypeGuard.TUint8Array(Type.Uint8Array())
+    Assert.equal(R, true)
+  })
+
+  it('should not guard for TUint8Array', () => {
+    const R = TypeGuard.TUint8Array(null)
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TUint8Array with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TUint8Array(Type.Uint8Array({ $id: 1 }))
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TUint8Array with invalid minByteLength', () => {
+    // @ts-ignore
+    const R = TypeGuard.TUint8Array(Type.Uint8Array({ minByteLength: '1' }))
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TUint8Array with invalid maxByteLength', () => {
+    // @ts-ignore
+    const R = TypeGuard.TUint8Array(Type.Uint8Array({ maxByteLength: '1' }))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/undefined.ts b/test/runtime/guard/undefined.ts
new file mode 100644
index 000000000..90c854759
--- /dev/null
+++ b/test/runtime/guard/undefined.ts
@@ -0,0 +1,19 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TUndefined', () => {
+  it('should guard for TUndefined', () => {
+    const R = TypeGuard.TUndefined(Type.Undefined())
+    Assert.equal(R, true)
+  })
+  it('should not guard for TUndefined', () => {
+    const R = TypeGuard.TUndefined(null)
+    Assert.equal(R, false)
+  })
+  it('should not guard for TUndefined with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TUndefined(Type.Undefined({ $id: 1 }))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/union.ts b/test/runtime/guard/union.ts
new file mode 100644
index 000000000..614a16654
--- /dev/null
+++ b/test/runtime/guard/union.ts
@@ -0,0 +1,66 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TUnion', () => {
+  it('should guard for TUnion', () => {
+    const R = TypeGuard.TUnion(
+      Type.Union([
+        Type.Object({
+          x: Type.Number(),
+        }),
+        Type.Object({
+          y: Type.Number(),
+        }),
+      ]),
+    )
+    Assert.equal(R, true)
+  })
+  it('should not guard for TUnion', () => {
+    const R = TypeGuard.TUnion(null)
+    Assert.equal(R, false)
+  })
+  it('should guard for TUnion with invalid $id', () => {
+    const R = TypeGuard.TUnion(
+      Type.Union(
+        [
+          Type.Object({
+            x: Type.Number(),
+          }),
+          Type.Object({
+            y: Type.Number(),
+          }),
+        ],
+        {
+          // @ts-ignore
+          $id: 1,
+        },
+      ),
+    )
+    Assert.equal(R, false)
+  })
+  it('should not guard for TUnion with invalid variant', () => {
+    const R = TypeGuard.TUnion(
+      Type.Union([
+        Type.Object({
+          x: Type.Number(),
+        }),
+        {} as any,
+      ]),
+    )
+    Assert.equal(R, false)
+  })
+  it('should not guard for TUnion with invalid object variant', () => {
+    const R = TypeGuard.TUnion(
+      Type.Union([
+        Type.Object({
+          x: Type.Number(),
+        }),
+        Type.Object({
+          y: {} as any,
+        }),
+      ]),
+    )
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/unknown.ts b/test/runtime/guard/unknown.ts
new file mode 100644
index 000000000..443698bd3
--- /dev/null
+++ b/test/runtime/guard/unknown.ts
@@ -0,0 +1,19 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TUnknown', () => {
+  it('should guard for TUnknown', () => {
+    const R = TypeGuard.TUnknown(Type.Unknown())
+    Assert.equal(R, true)
+  })
+  it('should not guard for TUnknown', () => {
+    const R = TypeGuard.TUnknown(null)
+    Assert.equal(R, false)
+  })
+  it('should not guard for TUnknown with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TUnknown(Type.Unknown({ $id: 1 }))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/void.ts b/test/runtime/guard/void.ts
new file mode 100644
index 000000000..b0565e69a
--- /dev/null
+++ b/test/runtime/guard/void.ts
@@ -0,0 +1,19 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TVoid', () => {
+  it('should guard for TVoid', () => {
+    const R = TypeGuard.TVoid(Type.Void())
+    Assert.equal(R, true)
+  })
+  it('should not guard for TVoid', () => {
+    const R = TypeGuard.TVoid(null)
+    Assert.equal(R, false)
+  })
+  it('should not guard for TVoid with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TVoid(Type.Void({ $id: 1 }))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/index.ts b/test/runtime/index.ts
new file mode 100644
index 000000000..77bb736d2
--- /dev/null
+++ b/test/runtime/index.ts
@@ -0,0 +1,6 @@
+import './compiler/index'
+import './conditional/index'
+import './format/index'
+import './guard/index'
+import './schema/index'
+import './value/index'
diff --git a/test/runtime/schema/any.ts b/test/runtime/schema/any.ts
new file mode 100644
index 000000000..6ffcb54c5
--- /dev/null
+++ b/test/runtime/schema/any.ts
@@ -0,0 +1,33 @@
+import { Type } from '@sinclair/typebox'
+import { ok } from './validate'
+
+describe('type/schema/Any', () => {
+  it('Should validate number', () => {
+    const T = Type.Any()
+    ok(T, 1)
+  })
+  it('Should validate string', () => {
+    const T = Type.Any()
+    ok(T, 'hello')
+  })
+  it('Should validate boolean', () => {
+    const T = Type.Any()
+    ok(T, true)
+  })
+  it('Should validate array', () => {
+    const T = Type.Any()
+    ok(T, [1, 2, 3])
+  })
+  it('Should validate object', () => {
+    const T = Type.Any()
+    ok(T, { a: 1, b: 2 })
+  })
+  it('Should validate null', () => {
+    const T = Type.Any()
+    ok(T, null)
+  })
+  it('Should validate undefined', () => {
+    const T = Type.Any()
+    ok(T, undefined)
+  })
+})
diff --git a/test/runtime/schema/array.ts b/test/runtime/schema/array.ts
new file mode 100644
index 000000000..bc3d1b1cf
--- /dev/null
+++ b/test/runtime/schema/array.ts
@@ -0,0 +1,96 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/Array', () => {
+  it('Should validate an array of any', () => {
+    const T = Type.Array(Type.Any())
+    ok(T, [0, true, 'hello', {}])
+  })
+
+  it('Should not validate varying array when item is number', () => {
+    const T = Type.Array(Type.Number())
+    fail(T, [1, 2, 3, 'hello'])
+  })
+
+  it('Should validate for an array of unions', () => {
+    const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
+    ok(T, [1, 'hello', 3, 'world'])
+  })
+
+  it('Should not validate for an array of unions where item is not in union.', () => {
+    const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
+    fail(T, [1, 'hello', 3, 'world', true])
+  })
+
+  it('Should validate for an empty array', () => {
+    const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
+    ok(T, [])
+  })
+
+  it('Should validate for an array of intersection types', () => {
+    const A = Type.Object({ a: Type.String() })
+    const B = Type.Object({ b: Type.String() })
+    const C = Type.Intersect([A, B])
+    const T = Type.Array(C)
+    ok(T, [
+      { a: 'hello', b: 'hello' },
+      { a: 'hello', b: 'hello' },
+      { a: 'hello', b: 'hello' },
+    ])
+  })
+
+  it('Should not validate for an array of intersection types when passing additionalProperties false', () => {
+    const A = Type.Object({ a: Type.String() })
+    const B = Type.Object({ b: Type.String() })
+    const C = Type.Intersect([A, B], { additionalProperties: false })
+    const T = Type.Array(C)
+    fail(T, [
+      { a: 'hello', b: 'hello' },
+      { a: 'hello', b: 'hello' },
+      { a: 'hello', b: 'hello', c: 'additional' },
+    ])
+  })
+
+  it('Should validate an array of tuples', () => {
+    const A = Type.String()
+    const B = Type.Number()
+    const C = Type.Tuple([A, B])
+    const T = Type.Array(C)
+    ok(T, [
+      ['hello', 1],
+      ['hello', 1],
+      ['hello', 1],
+    ])
+  })
+
+  it('Should not validate an array of tuples when tuple values are incorrect', () => {
+    const A = Type.String()
+    const B = Type.Number()
+    const C = Type.Tuple([A, B])
+    const T = Type.Array(C)
+    fail(T, [
+      [1, 'hello'],
+      [1, 'hello'],
+      [1, 'hello'],
+    ])
+  })
+  it('Should not validate array with failed minItems', () => {
+    const T = Type.Array(Type.Number(), { minItems: 3 })
+    fail(T, [0, 1])
+  })
+  it('Should not validate array with failed maxItems', () => {
+    const T = Type.Array(Type.Number(), { maxItems: 3 })
+    fail(T, [0, 1, 2, 3])
+  })
+  it('Should validate array with uniqueItems when items are references', () => {
+    const T = Type.Array(Type.Object({ x: Type.Number(), y: Type.Number() }), { uniqueItems: true })
+    ok(T, [
+      { x: 0, y: 1 },
+      { x: 1, y: 0 },
+    ]) // references distinct
+  })
+  it('Should not validate array with non uniqueItems', () => {
+    const T = Type.Array(Type.Number(), { uniqueItems: true })
+    fail(T, [0, 0])
+  })
+})
diff --git a/test/runtime/schema/boolean.ts b/test/runtime/schema/boolean.ts
new file mode 100644
index 000000000..4402a1b60
--- /dev/null
+++ b/test/runtime/schema/boolean.ts
@@ -0,0 +1,40 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/Boolean', () => {
+  it('Should validate a boolean', () => {
+    const T = Type.Boolean()
+    ok(T, true)
+    ok(T, false)
+  })
+
+  it('Should not validate a number', () => {
+    const T = Type.Boolean()
+    fail(T, 1)
+  })
+
+  it('Should not validate a string', () => {
+    const T = Type.Boolean()
+    fail(T, 'true')
+  })
+
+  it('Should not validate an array', () => {
+    const T = Type.Boolean()
+    fail(T, [true])
+  })
+
+  it('Should not validate an object', () => {
+    const T = Type.Boolean()
+    fail(T, {})
+  })
+
+  it('Should not validate an null', () => {
+    const T = Type.Boolean()
+    fail(T, null)
+  })
+
+  it('Should not validate an undefined', () => {
+    const T = Type.Boolean()
+    fail(T, undefined)
+  })
+})
diff --git a/test/runtime/schema/enum.ts b/test/runtime/schema/enum.ts
new file mode 100644
index 000000000..dbdbacf4c
--- /dev/null
+++ b/test/runtime/schema/enum.ts
@@ -0,0 +1,56 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/Enum', () => {
+  it('Should validate when emum uses default numeric values', () => {
+    enum Kind {
+      Foo, // = 0
+      Bar, // = 1
+    }
+    const T = Type.Enum(Kind)
+    ok(T, 0)
+    ok(T, 1)
+  })
+  it('Should not validate when given enum values are not numeric', () => {
+    enum Kind {
+      Foo, // = 0
+      Bar, // = 1
+    }
+    const T = Type.Enum(Kind)
+    fail(T, 'Foo')
+    fail(T, 'Bar')
+  })
+
+  it('Should validate when emum has defined string values', () => {
+    enum Kind {
+      Foo = 'foo',
+      Bar = 'bar',
+    }
+    const T = Type.Enum(Kind)
+    ok(T, 'foo')
+    ok(T, 'bar')
+  })
+
+  it('Should not validate when emum has defined string values and user passes numeric', () => {
+    enum Kind {
+      Foo = 'foo',
+      Bar = 'bar',
+    }
+    const T = Type.Enum(Kind)
+    fail(T, 0)
+    fail(T, 1)
+  })
+
+  it('Should validate when enum has one or more string values', () => {
+    enum Kind {
+      Foo,
+      Bar = 'bar',
+    }
+    const T = Type.Enum(Kind)
+    ok(T, 0)
+    ok(T, 'bar')
+    fail(T, 'baz')
+    fail(T, 'Foo')
+    fail(T, 1)
+  })
+})
diff --git a/spec/types/typebox.test-d.ts b/test/runtime/schema/index.ts
similarity index 83%
rename from spec/types/typebox.test-d.ts
rename to test/runtime/schema/index.ts
index 519bba3d5..401e007a9 100644
--- a/spec/types/typebox.test-d.ts
+++ b/test/runtime/schema/index.ts
@@ -1,12 +1,12 @@
 import './any'
 import './array'
 import './boolean'
-import './emum'
+import './enum'
 import './intersect'
 import './keyof'
 import './literal'
 import './modifier'
-import './namespace'
+import './never'
 import './null'
 import './number'
 import './object'
@@ -16,14 +16,14 @@ import './partial'
 import './pick'
 import './readonly-optional'
 import './readonly'
-import './rec'
+import './recursive'
 import './record'
 import './ref'
 import './regex'
 import './required'
-import './strict'
 import './string'
 import './tuple'
 import './union'
 import './unknown'
-
+import './unsafe'
+import './void'
diff --git a/test/runtime/schema/intersect.ts b/test/runtime/schema/intersect.ts
new file mode 100644
index 000000000..24e3406ba
--- /dev/null
+++ b/test/runtime/schema/intersect.ts
@@ -0,0 +1,94 @@
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert'
+import { ok, fail } from './validate'
+
+describe('type/schema/Intersect', () => {
+  it('Should intersect two objects', () => {
+    const A = Type.Object({ a: Type.String() })
+    const B = Type.Object({ b: Type.Number() })
+    const T = Type.Intersect([A, B], { additionalProperties: false })
+    ok(T, { a: 'hello', b: 42 })
+  })
+
+  it('Should intersect with partial', () => {
+    const A = Type.Partial(Type.Object({ a: Type.Number() }))
+    const B = Type.Partial(Type.Object({ b: Type.Number() }))
+    const P = Type.Intersect([A, B], { additionalProperties: false })
+    ok(P, { a: 1, b: 2 })
+    ok(P, { a: 1 })
+    ok(P, { b: 1 })
+    ok(P, {})
+    fail(P, { c: 1 })
+  })
+
+  it('Should intersect with overlapping same type', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ a: Type.Number() })
+    const P = Type.Intersect([A, B])
+    ok(P, { a: 1 })
+    fail(P, { a: 'hello' })
+    fail(P, {})
+  })
+
+  it('Should intersect with overlapping varying type', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ a: Type.String() })
+    const T = Type.Intersect([A, B])
+    ok(T, { a: 1 })
+    ok(T, { a: 'hello' })
+    fail(T, {})
+  })
+
+  it('Should intersect with deeply nest overlapping varying type', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ a: Type.String() })
+    const C = Type.Object({ a: Type.Boolean() })
+    const D = Type.Object({ a: Type.Null() })
+    const T = Type.Intersect([A, B, C, D])
+    ok(T, { a: 1 })
+    ok(T, { a: 'hello' })
+    ok(T, { a: false })
+    ok(T, { a: null })
+    fail(T, { a: [] })
+    fail(T, {})
+  })
+
+  it('Should pick from intersected type', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const C = Type.Object({ z: Type.Number() })
+    const T = Type.Intersect([A, B, C])
+    const P = Type.Pick(T, ['x', 'y'], { additionalProperties: false })
+    ok(P, { x: 1, y: 1 })
+    fail(P, { x: 1, y: 1, z: 1 })
+  })
+
+  it('Should omit from intersected type', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const C = Type.Object({ z: Type.Number() })
+    const T = Type.Intersect([A, B, C])
+    const P = Type.Omit(T, ['z'], { additionalProperties: false })
+    ok(P, { x: 1, y: 1 })
+    fail(P, { x: 1, y: 1, z: 1 })
+  })
+
+  it('Should intersect nested object properties', () => {
+    const A = Type.Object({ x: Type.Object({ x: Type.Number() }) })
+    const B = Type.Object({ x: Type.Object({ x: Type.String() }) })
+    const T = Type.Intersect([A, B])
+    ok(T, { x: { x: 1 } })
+    ok(T, { x: { x: 'hello' } })
+    fail(T, { x: { x: false } })
+  })
+
+  // todo: move to composition / type guard spec
+  it('Should intersect and produce the same schema', () => {
+    const T = Type.Object({
+      field: Type.Optional(Type.String()),
+    })
+    const A = Type.Intersect([T])
+    const B = Type.Intersect([T])
+    Assert.deepEqual(A, B)
+  })
+})
diff --git a/test/runtime/schema/keyof.ts b/test/runtime/schema/keyof.ts
new file mode 100644
index 000000000..d929b3770
--- /dev/null
+++ b/test/runtime/schema/keyof.ts
@@ -0,0 +1,52 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+import { strictEqual } from 'assert'
+
+describe('type/schema/KeyOf', () => {
+  it('Should validate with all object keys as a kind of union', () => {
+    const T = Type.KeyOf(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+    )
+    ok(T, 'x')
+    ok(T, 'y')
+    ok(T, 'z')
+    fail(T, 'w')
+  })
+
+  it('Should validate when using pick', () => {
+    const T = Type.KeyOf(
+      Type.Pick(
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+          z: Type.Number(),
+        }),
+        ['x', 'y'],
+      ),
+    )
+    ok(T, 'x')
+    ok(T, 'y')
+    fail(T, 'z')
+  })
+
+  it('Should validate when using omit', () => {
+    const T = Type.KeyOf(
+      Type.Omit(
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+          z: Type.Number(),
+        }),
+        ['x', 'y'],
+      ),
+    )
+
+    fail(T, 'x')
+    fail(T, 'y')
+    ok(T, 'z')
+  })
+})
diff --git a/test/runtime/schema/literal.ts b/test/runtime/schema/literal.ts
new file mode 100644
index 000000000..92b065986
--- /dev/null
+++ b/test/runtime/schema/literal.ts
@@ -0,0 +1,43 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/Literal', () => {
+  it('Should validate literal number', () => {
+    const T = Type.Literal(42)
+    ok(T, 42)
+  })
+  it('Should validate literal string', () => {
+    const T = Type.Literal('hello')
+    ok(T, 'hello')
+  })
+
+  it('Should validate literal boolean', () => {
+    const T = Type.Literal(true)
+    ok(T, true)
+  })
+
+  it('Should not validate invalid literal number', () => {
+    const T = Type.Literal(42)
+    fail(T, 43)
+  })
+  it('Should not validate invalid literal string', () => {
+    const T = Type.Literal('hello')
+    fail(T, 'world')
+  })
+  it('Should not validate invalid literal boolean', () => {
+    const T = Type.Literal(false)
+    fail(T, true)
+  })
+
+  it('Should validate literal union', () => {
+    const T = Type.Union([Type.Literal(42), Type.Literal('hello')])
+    ok(T, 42)
+    ok(T, 'hello')
+  })
+
+  it('Should not validate invalid literal union', () => {
+    const T = Type.Union([Type.Literal(42), Type.Literal('hello')])
+    fail(T, 43)
+    fail(T, 'world')
+  })
+})
diff --git a/test/runtime/schema/modifier.ts b/test/runtime/schema/modifier.ts
new file mode 100644
index 000000000..43e76c2b1
--- /dev/null
+++ b/test/runtime/schema/modifier.ts
@@ -0,0 +1,3 @@
+import { Type } from '@sinclair/typebox'
+
+describe('type/schema/Modifier', () => {})
diff --git a/test/runtime/schema/never.ts b/test/runtime/schema/never.ts
new file mode 100644
index 000000000..a32e4b66b
--- /dev/null
+++ b/test/runtime/schema/never.ts
@@ -0,0 +1,33 @@
+import { Type } from '@sinclair/typebox'
+import { fail } from './validate'
+
+describe('type/schema/Never', () => {
+  it('Should not validate number', () => {
+    const T = Type.Never()
+    fail(T, 1)
+  })
+  it('Should not validate string', () => {
+    const T = Type.Never()
+    fail(T, 'hello')
+  })
+  it('Should not validate boolean', () => {
+    const T = Type.Never()
+    fail(T, true)
+  })
+  it('Should not validate array', () => {
+    const T = Type.Never()
+    fail(T, [1, 2, 3])
+  })
+  it('Should not validate object', () => {
+    const T = Type.Never()
+    fail(T, { a: 1, b: 2 })
+  })
+  it('Should not validate null', () => {
+    const T = Type.Never()
+    fail(T, null)
+  })
+  it('Should validate undefined', () => {
+    const T = Type.Never()
+    fail(T, undefined)
+  })
+})
diff --git a/test/runtime/schema/null.ts b/test/runtime/schema/null.ts
new file mode 100644
index 000000000..8d5dca921
--- /dev/null
+++ b/test/runtime/schema/null.ts
@@ -0,0 +1,39 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/Null', () => {
+  it('Should not validate number', () => {
+    const T = Type.Null()
+    fail(T, 1)
+  })
+
+  it('Should not validate string', () => {
+    const T = Type.Null()
+    fail(T, 'hello')
+  })
+
+  it('Should not validate boolean', () => {
+    const T = Type.Null()
+    fail(T, true)
+  })
+
+  it('Should not validate array', () => {
+    const T = Type.Null()
+    fail(T, [1, 2, 3])
+  })
+
+  it('Should not validate object', () => {
+    const T = Type.Null()
+    fail(T, { a: 1, b: 2 })
+  })
+
+  it('Should not validate null', () => {
+    const T = Type.Null()
+    ok(T, null)
+  })
+
+  it('Should not validate undefined', () => {
+    const T = Type.Null()
+    fail(T, undefined)
+  })
+})
diff --git a/test/runtime/schema/number.ts b/test/runtime/schema/number.ts
new file mode 100644
index 000000000..62d509c0f
--- /dev/null
+++ b/test/runtime/schema/number.ts
@@ -0,0 +1,33 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/Number', () => {
+  it('Should validate number', () => {
+    const T = Type.Number()
+    ok(T, 1)
+  })
+  it('Should not validate string', () => {
+    const T = Type.Number()
+    fail(T, 'hello')
+  })
+  it('Should not validate boolean', () => {
+    const T = Type.Number()
+    fail(T, true)
+  })
+  it('Should not validate array', () => {
+    const T = Type.Number()
+    fail(T, [1, 2, 3])
+  })
+  it('Should not validate object', () => {
+    const T = Type.Number()
+    fail(T, { a: 1, b: 2 })
+  })
+  it('Should not validate null', () => {
+    const T = Type.Number()
+    fail(T, null)
+  })
+  it('Should not validate undefined', () => {
+    const T = Type.Number()
+    fail(T, undefined)
+  })
+})
diff --git a/test/runtime/schema/object.ts b/test/runtime/schema/object.ts
new file mode 100644
index 000000000..188dc1076
--- /dev/null
+++ b/test/runtime/schema/object.ts
@@ -0,0 +1,142 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/Object', () => {
+  it('Should not validate a number', () => {
+    const T = Type.Object({})
+    fail(T, 42)
+  })
+
+  it('Should not validate a string', () => {
+    const T = Type.Object({})
+    fail(T, 'hello')
+  })
+
+  it('Should not validate a boolean', () => {
+    const T = Type.Object({})
+    fail(T, true)
+  })
+
+  it('Should not validate a null', () => {
+    const T = Type.Object({})
+    fail(T, null)
+  })
+
+  it('Should not validate an array', () => {
+    const T = Type.Object({})
+    fail(T, [1, 2])
+  })
+
+  it('Should validate with correct property values', () => {
+    const T = Type.Object({
+      a: Type.Number(),
+      b: Type.String(),
+      c: Type.Boolean(),
+      d: Type.Array(Type.Number()),
+      e: Type.Object({ x: Type.Number(), y: Type.Number() }),
+    })
+    ok(T, {
+      a: 10,
+      b: 'hello',
+      c: true,
+      d: [1, 2, 3],
+      e: { x: 10, y: 20 },
+    })
+  })
+
+  it('Should not validate with incorrect property values', () => {
+    const T = Type.Object({
+      a: Type.Number(),
+      b: Type.String(),
+      c: Type.Boolean(),
+      d: Type.Array(Type.Number()),
+      e: Type.Object({ x: Type.Number(), y: Type.Number() }),
+    })
+    fail(T, {
+      a: 'not a number', // error
+      b: 'hello',
+      c: true,
+      d: [1, 2, 3],
+      e: { x: 10, y: 20 },
+    })
+  })
+
+  it('Should allow additionalProperties by default', () => {
+    const T = Type.Object({
+      a: Type.Number(),
+      b: Type.String(),
+    })
+    ok(T, {
+      a: 1,
+      b: 'hello',
+      c: true,
+    })
+  })
+
+  it('Should not allow an empty object if minProperties is set to 1', () => {
+    const T = Type.Object(
+      {
+        a: Type.Optional(Type.Number()),
+        b: Type.Optional(Type.String()),
+      },
+      { additionalProperties: false, minProperties: 1 },
+    )
+    ok(T, { a: 1 })
+    ok(T, { b: 'hello' })
+    fail(T, {})
+  })
+
+  it('Should not allow 3 properties if maxProperties is set to 2', () => {
+    const T = Type.Object(
+      {
+        a: Type.Optional(Type.Number()),
+        b: Type.Optional(Type.String()),
+        c: Type.Optional(Type.Boolean()),
+      },
+      { additionalProperties: false, maxProperties: 2 },
+    )
+    ok(T, { a: 1 })
+    ok(T, { a: 1, b: 'hello' })
+    fail(T, {
+      a: 1,
+      b: 'hello',
+      c: true,
+    })
+  })
+
+  it('Should not allow additionalProperties if additionalProperties is false', () => {
+    const T = Type.Object(
+      {
+        a: Type.Number(),
+        b: Type.String(),
+      },
+      { additionalProperties: false },
+    )
+    fail(T, {
+      a: 1,
+      b: 'hello',
+      c: true,
+    })
+  })
+
+  it('Should not allow properties for an empty object when additionalProperties is false', () => {
+    const T = Type.Object({}, { additionalProperties: false })
+    ok(T, {})
+    fail(T, { a: 10 })
+  })
+
+  it('Should validate with non-syntax property keys', () => {
+    const T = Type.Object({
+      'with-hyphen': Type.Literal(1),
+      '0-leading': Type.Literal(2),
+      '$-leading': Type.Literal(3),
+      '!@#$%^&*(': Type.Literal(4),
+    })
+    ok(T, {
+      'with-hyphen': 1,
+      '0-leading': 2,
+      '$-leading': 3,
+      '!@#$%^&*(': 4,
+    })
+  })
+})
diff --git a/test/runtime/schema/omit.ts b/test/runtime/schema/omit.ts
new file mode 100644
index 000000000..b605646f5
--- /dev/null
+++ b/test/runtime/schema/omit.ts
@@ -0,0 +1,73 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+import { strictEqual } from 'assert'
+
+describe('type/schema/Omit', () => {
+  it('Should omit properties on the source schema', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Omit(A, ['z'])
+    ok(T, { x: 1, y: 1 })
+  })
+
+  it('Should remove required properties on the target schema', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Omit(A, ['z'])
+    strictEqual(T.required!.includes('z'), false)
+  })
+
+  it('Should delete the required property if no required properties remain', () => {
+    const A = Type.Object(
+      {
+        x: Type.Optional(Type.Number()),
+        y: Type.ReadonlyOptional(Type.Number()),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Omit(A, ['z'])
+    strictEqual(T.required, undefined)
+  })
+
+  it('Should inherit options from the source object', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Omit(A, ['z'])
+    strictEqual(A.additionalProperties, false)
+    strictEqual(T.additionalProperties, false)
+  })
+
+  it('Should omit with keyof object', () => {
+    const A = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    const B = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    })
+    const T = Type.Omit(A, Type.KeyOf(B), { additionalProperties: false })
+    ok(T, { z: 0 })
+    fail(T, { x: 0, y: 0, z: 0 })
+  })
+})
diff --git a/test/runtime/schema/optional.ts b/test/runtime/schema/optional.ts
new file mode 100644
index 000000000..ba95bd7fb
--- /dev/null
+++ b/test/runtime/schema/optional.ts
@@ -0,0 +1,27 @@
+import { strictEqual } from 'assert'
+import { Type } from '@sinclair/typebox'
+import { ok } from './validate'
+
+describe('type/schema/Optional', () => {
+  it('Should validate object with optional', () => {
+    const T = Type.Object(
+      {
+        a: Type.Optional(Type.String()),
+        b: Type.String(),
+      },
+      { additionalProperties: false },
+    )
+    ok(T, { a: 'hello', b: 'world' })
+    ok(T, { b: 'world' })
+  })
+  it('Should remove required value from schema', () => {
+    const T = Type.Object(
+      {
+        a: Type.Optional(Type.String()),
+        b: Type.String(),
+      },
+      { additionalProperties: false },
+    )
+    strictEqual(T.required!.includes('a'), false)
+  })
+})
diff --git a/test/runtime/schema/partial.ts b/test/runtime/schema/partial.ts
new file mode 100644
index 000000000..6fafdd867
--- /dev/null
+++ b/test/runtime/schema/partial.ts
@@ -0,0 +1,52 @@
+import { Type, Modifier } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+import { strictEqual } from 'assert'
+
+describe('type/schema/Partial', () => {
+  it('Should convert a required object into a partial.', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Partial(A)
+    ok(T, { x: 1, y: 1, z: 1 })
+    ok(T, { x: 1, y: 1 })
+    ok(T, { x: 1 })
+    ok(T, {})
+  })
+
+  it('Should update modifier types correctly when converting to partial', () => {
+    const A = Type.Object(
+      {
+        x: Type.ReadonlyOptional(Type.Number()),
+        y: Type.Readonly(Type.Number()),
+        z: Type.Optional(Type.Number()),
+        w: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Partial(A)
+    strictEqual(T.properties.x[Modifier], 'ReadonlyOptional')
+    strictEqual(T.properties.y[Modifier], 'ReadonlyOptional')
+    strictEqual(T.properties.z[Modifier], 'Optional')
+    strictEqual(T.properties.w[Modifier], 'Optional')
+  })
+
+  it('Should inherit options from the source object', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Partial(A)
+    strictEqual(A.additionalProperties, false)
+    strictEqual(T.additionalProperties, false)
+  })
+})
diff --git a/test/runtime/schema/pick.ts b/test/runtime/schema/pick.ts
new file mode 100644
index 000000000..f96332bfc
--- /dev/null
+++ b/test/runtime/schema/pick.ts
@@ -0,0 +1,73 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+import { strictEqual } from 'assert'
+
+describe('type/schema/Pick', () => {
+  it('Should pick properties from the source schema', () => {
+    const Vector3 = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Pick(Vector3, ['x', 'y'])
+    ok(T, { x: 1, y: 1 })
+  })
+
+  it('Should remove required properties on the target schema', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Pick(A, ['x', 'y'])
+    strictEqual(T.required!.includes('z'), false)
+  })
+
+  it('Should delete the required property if no required properties remain', () => {
+    const A = Type.Object(
+      {
+        x: Type.Optional(Type.Number()),
+        y: Type.ReadonlyOptional(Type.Number()),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Pick(A, ['x', 'y'])
+    strictEqual(T.required, undefined)
+  })
+
+  it('Should inherit options from the source object', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Pick(A, ['x', 'y'])
+    strictEqual(A.additionalProperties, false)
+    strictEqual(T.additionalProperties, false)
+  })
+
+  it('Should pick with keyof object', () => {
+    const A = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    const B = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    })
+    const T = Type.Pick(A, Type.KeyOf(B), { additionalProperties: false })
+    ok(T, { x: 0, y: 0 })
+    fail(T, { x: 0, y: 0, z: 0 })
+  })
+})
diff --git a/test/runtime/schema/readonly-optional.ts b/test/runtime/schema/readonly-optional.ts
new file mode 100644
index 000000000..8353010be
--- /dev/null
+++ b/test/runtime/schema/readonly-optional.ts
@@ -0,0 +1,27 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+import { strictEqual } from 'assert'
+
+describe('type/schema/ReadonlyOptional', () => {
+  it('Should validate object with optional', () => {
+    const T = Type.Object(
+      {
+        a: Type.ReadonlyOptional(Type.String()),
+        b: Type.String(),
+      },
+      { additionalProperties: false },
+    )
+    ok(T, { a: 'hello', b: 'world' })
+    ok(T, { b: 'world' })
+  })
+  it('Should remove required value from schema', () => {
+    const T = Type.Object(
+      {
+        a: Type.ReadonlyOptional(Type.String()),
+        b: Type.String(),
+      },
+      { additionalProperties: false },
+    )
+    strictEqual(T.required!.includes('a'), false)
+  })
+})
diff --git a/test/runtime/schema/readonly.ts b/test/runtime/schema/readonly.ts
new file mode 100644
index 000000000..c0b55dc85
--- /dev/null
+++ b/test/runtime/schema/readonly.ts
@@ -0,0 +1,28 @@
+import { deepStrictEqual, strictEqual } from 'assert'
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/Readonly', () => {
+  it('Should validate object with readonly', () => {
+    const T = Type.Object(
+      {
+        a: Type.Readonly(Type.String()),
+        b: Type.Readonly(Type.String()),
+      },
+      { additionalProperties: false },
+    )
+    ok(T, { a: 'hello', b: 'world' })
+  })
+
+  it('Should retain required array on object', () => {
+    const T = Type.Object(
+      {
+        a: Type.Readonly(Type.String()),
+        b: Type.Readonly(Type.String()),
+      },
+      { additionalProperties: false },
+    )
+    strictEqual(T.required!.includes('a'), true)
+    strictEqual(T.required!.includes('b'), true)
+  })
+})
diff --git a/test/runtime/schema/record.ts b/test/runtime/schema/record.ts
new file mode 100644
index 000000000..d88819c94
--- /dev/null
+++ b/test/runtime/schema/record.ts
@@ -0,0 +1,101 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/Record', () => {
+  it('Should validate when all property values are numbers', () => {
+    const T = Type.Record(Type.String(), Type.Number())
+    ok(T, { a: 1, b: 2, c: 3 })
+  })
+
+  it('Should validate when all property keys are strings', () => {
+    const T = Type.Record(Type.String(), Type.Number())
+    ok(T, { a: 1, b: 2, c: 3, '0': 4 })
+  })
+
+  it('Should validate when all property keys are numbers', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
+  })
+
+  it('Should validate when all property keys are numbers, but one property is a string with varying type', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
+  })
+
+  it('Should not validate if passing a leading zeros for numeric keys', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    fail(T, {
+      '00': 1,
+      '01': 2,
+      '02': 3,
+      '03': 4,
+    })
+  })
+
+  it('Should not validate if passing a signed numeric keys', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    fail(T, {
+      '-0': 1,
+      '-1': 2,
+      '-2': 3,
+      '-3': 4,
+    })
+  })
+
+  it('Should not validate when all property keys are numbers, but one property is a string with varying type', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
+  })
+
+  it('Should validate when specifying string union literals when additionalProperties is true', () => {
+    const K = Type.Union([Type.Literal('a'), Type.Literal('b'), Type.Literal('c')])
+    const T = Type.Record(K, Type.Number())
+    ok(T, { a: 1, b: 2, c: 3, d: 'hello' })
+  })
+
+  it('Should not validate when specifying string union literals when additionalProperties is false', () => {
+    const K = Type.Union([Type.Literal('a'), Type.Literal('b'), Type.Literal('c')])
+    const T = Type.Record(K, Type.Number(), { additionalProperties: false })
+    fail(T, { a: 1, b: 2, c: 3, d: 'hello' })
+  })
+
+  it('Should validate for keyof records', () => {
+    const T = Type.Object({
+      a: Type.String(),
+      b: Type.Number(),
+      c: Type.String(),
+    })
+    const R = Type.Record(Type.KeyOf(T), Type.Number())
+    ok(R, { a: 1, b: 2, c: 3 })
+  })
+
+  it('Should not validate for unknown key via keyof', () => {
+    const T = Type.Object({
+      a: Type.String(),
+      b: Type.Number(),
+      c: Type.String(),
+    })
+    const R = Type.Record(Type.KeyOf(T), Type.Number(), { additionalProperties: false })
+    fail(R, { a: 1, b: 2, c: 3, d: 4 })
+  })
+
+  it('Should should validate when specifying regular expressions', () => {
+    const K = Type.RegEx(/^op_.*$/)
+    const T = Type.Record(K, Type.Number())
+    ok(T, {
+      op_a: 1,
+      op_b: 2,
+      op_c: 3,
+    })
+  })
+
+  it('Should should not validate when specifying regular expressions and passing invalid property', () => {
+    const K = Type.RegEx(/^op_.*$/)
+    const T = Type.Record(K, Type.Number())
+    fail(T, {
+      op_a: 1,
+      op_b: 2,
+      aop_c: 3,
+    })
+  })
+})
diff --git a/test/runtime/schema/recursive.ts b/test/runtime/schema/recursive.ts
new file mode 100644
index 000000000..a0b132232
--- /dev/null
+++ b/test/runtime/schema/recursive.ts
@@ -0,0 +1,83 @@
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+import { ok, fail } from './validate'
+
+describe('type/schema/Recursive', () => {
+  it('Should generate default ordinal $id if not specified', () => {
+    const Node = Type.Recursive((Node) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(Node),
+      }),
+    )
+    Assert.equal(Node.$id === undefined, false)
+  })
+
+  it('Should override default ordinal $id if specified', () => {
+    const Node = Type.Recursive(
+      (Node) =>
+        Type.Object({
+          id: Type.String(),
+          nodes: Type.Array(Node),
+        }),
+      { $id: 'Node' },
+    )
+    Assert.equal(Node.$id === 'Node', true)
+  })
+
+  it('Should validate recursive node type', () => {
+    const Node = Type.Recursive((Self) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(Self),
+      }),
+    )
+    ok(Node, {
+      id: 'A',
+      nodes: [
+        { id: 'B', nodes: [] },
+        { id: 'C', nodes: [] },
+      ],
+    })
+  })
+
+  it('Should validate wrapped recursive node type', () => {
+    const Node = Type.Tuple([
+      Type.Recursive((Self) =>
+        Type.Object({
+          id: Type.String(),
+          nodes: Type.Array(Self),
+        }),
+      ),
+    ])
+    ok(Node, [
+      {
+        id: 'A',
+        nodes: [
+          { id: 'B', nodes: [] },
+          { id: 'C', nodes: [] },
+        ],
+      },
+    ])
+  })
+
+  it('Should not validate wrapped recursive node type with invalid id', () => {
+    const Node = Type.Tuple([
+      Type.Recursive((Self) =>
+        Type.Object({
+          id: Type.String(),
+          nodes: Type.Array(Self),
+        }),
+      ),
+    ])
+    fail(Node, [
+      {
+        id: 'A',
+        nodes: [
+          { id: 1, nodes: [] },
+          { id: 'C', nodes: [] },
+        ],
+      },
+    ])
+  })
+})
diff --git a/test/runtime/schema/ref.ts b/test/runtime/schema/ref.ts
new file mode 100644
index 000000000..ade5e054a
--- /dev/null
+++ b/test/runtime/schema/ref.ts
@@ -0,0 +1,69 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+import { Assert } from '../assert/index'
+
+describe('type/schema/Ref', () => {
+  it('Should should validate when referencing a type', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { $id: 'T' },
+    )
+    const R = Type.Ref(T)
+    ok(
+      R,
+      {
+        x: 1,
+        y: 2,
+        z: 3,
+      },
+      [T],
+    )
+  })
+
+  it('Should not validate when passing invalid data', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { $id: 'T' },
+    )
+    const R = Type.Ref(T)
+    fail(
+      R,
+      {
+        x: 1,
+        y: 2,
+      },
+      [T],
+    )
+  })
+  it('Should de-reference object property schema', () => {
+    const R = Type.Object(
+      {
+        name: Type.String(),
+      },
+      { $id: 'R' },
+    )
+
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+        r: Type.Optional(Type.Ref(R)),
+      },
+      { $id: 'T' },
+    )
+
+    ok(T, { x: 1, y: 2, z: 3 }, [R])
+    ok(T, { x: 1, y: 2, z: 3, r: { name: 'hello' } }, [R])
+    fail(T, { x: 1, y: 2, z: 3, r: { name: 1 } }, [R])
+    fail(T, { x: 1, y: 2, z: 3, r: {} }, [R])
+  })
+})
diff --git a/test/runtime/schema/regex.ts b/test/runtime/schema/regex.ts
new file mode 100644
index 000000000..0c5c56faa
--- /dev/null
+++ b/test/runtime/schema/regex.ts
@@ -0,0 +1,35 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/RegEx', () => {
+  it('Should validate numeric value', () => {
+    const T = Type.RegEx(/[012345]/)
+    ok(T, '0')
+    ok(T, '1')
+    ok(T, '2')
+    ok(T, '3')
+    ok(T, '4')
+    ok(T, '5')
+  })
+
+  it('Should validate true or false string value', () => {
+    const T = Type.RegEx(/true|false/)
+    ok(T, 'true')
+    ok(T, 'true')
+    ok(T, 'true')
+    ok(T, 'false')
+    ok(T, 'false')
+    ok(T, 'false')
+    fail(T, '6')
+  })
+
+  it('Should not validate failed regex test', () => {
+    const T = Type.RegEx(/true|false/)
+    fail(T, 'unknown')
+  })
+
+  it('Should pass numeric 5 digit test', () => {
+    const T = Type.RegEx(/[\d]{5}/)
+    ok(T, '12345')
+  })
+})
diff --git a/test/runtime/schema/required.ts b/test/runtime/schema/required.ts
new file mode 100644
index 000000000..f3090fcdd
--- /dev/null
+++ b/test/runtime/schema/required.ts
@@ -0,0 +1,57 @@
+import { Type, Modifier } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+import { strictEqual } from 'assert'
+
+describe('type/schema/Required', () => {
+  it('Should convert a partial object into a required object', () => {
+    const A = Type.Object(
+      {
+        x: Type.Optional(Type.Number()),
+        y: Type.Optional(Type.Number()),
+        z: Type.Optional(Type.Number()),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Required(A)
+    ok(T, { x: 1, y: 1, z: 1 })
+    fail(T, { x: 1, y: 1 })
+    fail(T, { x: 1 })
+    fail(T, {})
+  })
+
+  it('Should update modifier types correctly when converting to required', () => {
+    const A = Type.Object({
+      x: Type.ReadonlyOptional(Type.Number()),
+      y: Type.Readonly(Type.Number()),
+      z: Type.Optional(Type.Number()),
+      w: Type.Number(),
+    })
+    const T = Type.Required(A)
+    strictEqual(T.properties.x[Modifier], 'Readonly')
+    strictEqual(T.properties.y[Modifier], 'Readonly')
+    strictEqual(T.properties.z[Modifier], undefined)
+    strictEqual(T.properties.w[Modifier], undefined)
+  })
+
+  it('Should inherit options from the source object', () => {
+    const A = Type.Object(
+      {
+        x: Type.Optional(Type.Number()),
+        y: Type.Optional(Type.Number()),
+        z: Type.Optional(Type.Number()),
+      },
+      { additionalPropeties: false },
+    )
+    const T = Type.Required(A)
+    strictEqual(A.additionalPropeties, false)
+    strictEqual(T.additionalPropeties, false)
+  })
+
+  // it('Should construct new object when targetting reference', () => {
+  //   const T = Type.Object({ a: Type.String(), b: Type.String() }, { $id: 'T' })
+  //   const R = Type.Ref(T)
+  //   const P = Type.Required(R)
+  //   strictEqual(P.properties.a.type, 'string')
+  //   strictEqual(P.properties.b.type, 'string')
+  // })
+})
diff --git a/test/runtime/schema/string.ts b/test/runtime/schema/string.ts
new file mode 100644
index 000000000..9061de762
--- /dev/null
+++ b/test/runtime/schema/string.ts
@@ -0,0 +1,65 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/String', () => {
+  it('Should not validate number', () => {
+    const T = Type.String()
+    fail(T, 1)
+  })
+  it('Should validate string', () => {
+    const T = Type.String()
+    ok(T, 'hello')
+  })
+  it('Should not validate boolean', () => {
+    const T = Type.String()
+    fail(T, true)
+  })
+  it('Should not validate array', () => {
+    const T = Type.String()
+    fail(T, [1, 2, 3])
+  })
+  it('Should not validate object', () => {
+    const T = Type.String()
+    fail(T, { a: 1, b: 2 })
+  })
+  it('Should not validate null', () => {
+    const T = Type.String()
+    fail(T, null)
+  })
+  it('Should not validate undefined', () => {
+    const T = Type.String()
+    fail(T, undefined)
+  })
+
+  it('Should validate string format as email', () => {
+    const T = Type.String({ format: 'email' })
+    ok(T, 'name@domain.com')
+  })
+
+  it('Should validate string format as uuid', () => {
+    const T = Type.String({ format: 'uuid' })
+    ok(T, '4a7a17c9-2492-4a53-8e13-06ea2d3f3bbf')
+  })
+
+  it('Should validate string format as iso8601 date', () => {
+    const T = Type.String({ format: 'date-time' })
+    ok(T, '2021-06-11T20:30:00-04:00')
+  })
+
+  it('Should validate minLength', () => {
+    const T = Type.String({ minLength: 4 })
+    ok(T, '....')
+    fail(T, '...')
+  })
+
+  it('Should validate maxLength', () => {
+    const T = Type.String({ maxLength: 4 })
+    ok(T, '....')
+    fail(T, '.....')
+  })
+
+  it('Should pass numeric 5 digit test', () => {
+    const T = Type.String({ pattern: '[\\d]{5}' })
+    ok(T, '12345')
+  })
+})
diff --git a/test/runtime/schema/tuple.ts b/test/runtime/schema/tuple.ts
new file mode 100644
index 000000000..60ba0be00
--- /dev/null
+++ b/test/runtime/schema/tuple.ts
@@ -0,0 +1,62 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+import { Assert } from '../assert'
+
+describe('type/schema/Tuple', () => {
+  it('Should validate tuple of [string, number]', () => {
+    const A = Type.String()
+    const B = Type.Number()
+    const T = Type.Tuple([A, B])
+    ok(T, ['hello', 42])
+  })
+
+  it('Should not validate tuple of [string, number] when reversed', () => {
+    const A = Type.String()
+    const B = Type.Number()
+    const T = Type.Tuple([A, B])
+    fail(T, [42, 'hello'])
+  })
+
+  it('Should validate with empty tuple', () => {
+    const T = Type.Tuple([])
+    ok(T, [])
+  })
+
+  it('Should not validate with empty tuple with more items', () => {
+    const T = Type.Tuple([])
+    fail(T, [1])
+  })
+
+  it('Should not validate with empty tuple with less items', () => {
+    const T = Type.Tuple([Type.Number(), Type.Number()])
+    fail(T, [1])
+  })
+
+  it('Should validate tuple of objects', () => {
+    const A = Type.Object({ a: Type.String() })
+    const B = Type.Object({ b: Type.Number() })
+    const T = Type.Tuple([A, B])
+    ok(T, [{ a: 'hello' }, { b: 42 }])
+  })
+
+  it('Should not validate tuple of objects when reversed', () => {
+    const A = Type.Object({ a: Type.String() })
+    const B = Type.Object({ b: Type.Number() })
+    const T = Type.Tuple([A, B])
+    fail(T, [{ b: 42 }, { a: 'hello' }])
+  })
+
+  it('Should not validate tuple when array is less than tuple length', () => {
+    const A = Type.Object({ a: Type.String() })
+    const B = Type.Object({ b: Type.Number() })
+    const T = Type.Tuple([A, B])
+    fail(T, [{ a: 'hello' }])
+  })
+
+  it('Should not validate tuple when array is greater than tuple length', () => {
+    const A = Type.Object({ a: Type.String() })
+    const B = Type.Object({ b: Type.Number() })
+    const T = Type.Tuple([A, B])
+    fail(T, [{ a: 'hello' }, { b: 42 }, { b: 42 }])
+  })
+})
diff --git a/test/runtime/schema/union.ts b/test/runtime/schema/union.ts
new file mode 100644
index 000000000..45d371abe
--- /dev/null
+++ b/test/runtime/schema/union.ts
@@ -0,0 +1,62 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/Union', () => {
+  it('Should validate union of string, number and boolean', () => {
+    const A = Type.String()
+    const B = Type.Number()
+    const C = Type.Boolean()
+    const T = Type.Union([A, B, C])
+    ok(T, 'hello')
+    ok(T, true)
+    ok(T, 42)
+  })
+
+  it('Should validate union of objects', () => {
+    const A = Type.Object({ a: Type.String() }, { additionalProperties: false })
+    const B = Type.Object({ b: Type.String() }, { additionalProperties: false })
+    const T = Type.Union([A, B])
+    ok(T, { a: 'hello' })
+    ok(T, { b: 'world' })
+  })
+
+  it('Should fail to validate for descriminated union types', () => {
+    const A = Type.Object({ kind: Type.Literal('A'), value: Type.String() })
+    const B = Type.Object({ kind: Type.Literal('B'), value: Type.Number() })
+    const T = Type.Union([A, B])
+    fail(T, { kind: 'A', value: 42 }) // expect { kind: 'A', value: string }
+    fail(T, { kind: 'B', value: 'hello' }) // expect { kind: 'B', value: number }
+  })
+
+  it('Should validate union of objects where properties overlap', () => {
+    const A = Type.Object({ a: Type.String() }, { additionalProperties: false })
+    const B = Type.Object({ a: Type.String(), b: Type.String() }, { additionalProperties: false })
+    const T = Type.Union([A, B])
+    ok(T, { a: 'hello' }) // A
+    ok(T, { a: 'hello', b: 'world' }) // B
+  })
+
+  it('Should validate union of overlapping property of varying type', () => {
+    const A = Type.Object({ a: Type.String(), b: Type.Number() }, { additionalProperties: false })
+    const B = Type.Object({ a: Type.String(), b: Type.String() }, { additionalProperties: false })
+    const T = Type.Union([A, B])
+    ok(T, { a: 'hello', b: 42 }) // A
+    ok(T, { a: 'hello', b: 'world' }) // B
+  })
+
+  it('Should validate union of literal strings', () => {
+    const A = Type.Literal('hello')
+    const B = Type.Literal('world')
+    const T = Type.Union([A, B])
+    ok(T, 'hello') // A
+    ok(T, 'world') // B
+  })
+
+  it('Should not validate union of literal strings for unknown string', () => {
+    const A = Type.Literal('hello')
+    const B = Type.Literal('world')
+    const T = Type.Union([A, B])
+    fail(T, 'foo') // A
+    fail(T, 'bar') // B
+  })
+})
diff --git a/test/runtime/schema/unknown.ts b/test/runtime/schema/unknown.ts
new file mode 100644
index 000000000..c9b94f339
--- /dev/null
+++ b/test/runtime/schema/unknown.ts
@@ -0,0 +1,33 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/Unknown', () => {
+  it('Should validate number', () => {
+    const T = Type.Any()
+    ok(T, 1)
+  })
+  it('Should validate string', () => {
+    const T = Type.Any()
+    ok(T, 'hello')
+  })
+  it('Should validate boolean', () => {
+    const T = Type.Any()
+    ok(T, true)
+  })
+  it('Should validate array', () => {
+    const T = Type.Any()
+    ok(T, [1, 2, 3])
+  })
+  it('Should validate object', () => {
+    const T = Type.Any()
+    ok(T, { a: 1, b: 2 })
+  })
+  it('Should validate null', () => {
+    const T = Type.Any()
+    ok(T, null)
+  })
+  it('Should validate undefined', () => {
+    const T = Type.Any()
+    ok(T, undefined)
+  })
+})
diff --git a/test/runtime/schema/unsafe.ts b/test/runtime/schema/unsafe.ts
new file mode 100644
index 000000000..d21fe3411
--- /dev/null
+++ b/test/runtime/schema/unsafe.ts
@@ -0,0 +1,18 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/Unsafe', () => {
+  it('Should validate an unsafe type', () => {
+    const T = Type.Unsafe({
+      type: 'object',
+      properties: {
+        x: { type: 'number' },
+        y: { type: 'number' },
+        z: { type: 'number' },
+      },
+      additionalProperties: false,
+    })
+    ok(T, { x: 1, y: 2, z: 3 })
+    fail(T, { x: 1, y: 2, z: 3, w: 4 })
+  })
+})
diff --git a/test/runtime/schema/validate.ts b/test/runtime/schema/validate.ts
new file mode 100644
index 000000000..f12181907
--- /dev/null
+++ b/test/runtime/schema/validate.ts
@@ -0,0 +1,64 @@
+import { TSchema } from '@sinclair/typebox'
+import addFormats from 'ajv-formats'
+import Ajv, { AnySchema } from 'ajv/dist/2019'
+
+export function validator(additional: AnySchema[]) {
+  return addFormats(new Ajv({}), ['date-time', 'time', 'date', 'email', 'hostname', 'ipv4', 'ipv6', 'uri', 'uri-reference', 'uuid', 'uri-template', 'json-pointer', 'relative-json-pointer', 'regex'])
+    .addKeyword('kind')
+    .addKeyword('modifier')
+    .addSchema(additional)
+}
+
+export function ok<T extends TSchema>(type: T, data: unknown, additional: AnySchema[] = []) {
+  const ajv = validator(additional)
+  function execute() {
+    // required as ajv will throw if referenced schema is not found
+    try {
+      return ajv.validate(type, data) as boolean
+    } catch {
+      return false
+    }
+  }
+  if (execute() === false) {
+    console.log('---------------------------')
+    console.log('type')
+    console.log('---------------------------')
+    console.log(JSON.stringify(type, null, 2))
+    console.log('---------------------------')
+    console.log('data')
+    console.log('---------------------------')
+    console.log(JSON.stringify(data, null, 2))
+    console.log('---------------------------')
+    console.log('errors')
+    console.log('---------------------------')
+    console.log(ajv.errorsText(ajv.errors))
+    throw Error('expected ok')
+  }
+}
+
+export function fail<T extends TSchema>(type: T, data: unknown, additional: AnySchema[] = []) {
+  const ajv = validator(additional)
+  function execute() {
+    // required as ajv will throw if referenced schema is not found
+    try {
+      return ajv.validate(type, data) as boolean
+    } catch {
+      return false
+    }
+  }
+  if (execute() === true) {
+    console.log('---------------------------')
+    console.log('type')
+    console.log('---------------------------')
+    console.log(JSON.stringify(type, null, 2))
+    console.log('---------------------------')
+    console.log('data')
+    console.log('---------------------------')
+    console.log(JSON.stringify(data, null, 2))
+    console.log('---------------------------')
+    console.log('errors')
+    console.log('---------------------------')
+    console.log(ajv.errorsText(ajv.errors))
+    throw Error('expected ok')
+  }
+}
diff --git a/test/runtime/schema/void.ts b/test/runtime/schema/void.ts
new file mode 100644
index 000000000..8d5c13e21
--- /dev/null
+++ b/test/runtime/schema/void.ts
@@ -0,0 +1,39 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/Void', () => {
+  it('Should not validate number', () => {
+    const T = Type.Void()
+    fail(T, 1)
+  })
+
+  it('Should not validate string', () => {
+    const T = Type.Void()
+    fail(T, 'hello')
+  })
+
+  it('Should not validate boolean', () => {
+    const T = Type.Void()
+    fail(T, true)
+  })
+
+  it('Should not validate array', () => {
+    const T = Type.Void()
+    fail(T, [1, 2, 3])
+  })
+
+  it('Should not validate object', () => {
+    const T = Type.Void()
+    fail(T, { a: 1, b: 2 })
+  })
+
+  it('Should validate null', () => {
+    const T = Type.Null()
+    ok(T, null)
+  })
+
+  it('Should not validate undefined', () => {
+    const T = Type.Void()
+    fail(T, undefined)
+  })
+})
diff --git a/test/runtime/value/cast/any.ts b/test/runtime/value/cast/any.ts
new file mode 100644
index 000000000..5fcace73f
--- /dev/null
+++ b/test/runtime/value/cast/any.ts
@@ -0,0 +1,47 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Any', () => {
+  const T = Type.Any()
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+  it('Should upcast from boolean', () => {
+    const value = false
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+  it('Should preserve', () => {
+    const value = { a: 1, b: 2 }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, { a: 1, b: 2 })
+  })
+})
diff --git a/test/runtime/value/cast/array.ts b/test/runtime/value/cast/array.ts
new file mode 100644
index 000000000..d23c59218
--- /dev/null
+++ b/test/runtime/value/cast/array.ts
@@ -0,0 +1,137 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Array', () => {
+  const T = Type.Array(Type.Number(), { default: [1, 2, 3] })
+  const E = [1, 2, 3]
+
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, [1])
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preserve', () => {
+    const value = [6, 7, 8]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, [6, 7, 8])
+  })
+
+  it('Should preserve with invalid element set to default', () => {
+    const value = [6, 7, 8, 'hello', 9]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, [6, 7, 8, 0, 9])
+  })
+
+  // -----------------------------------------------------------------
+  // Constraints: Ranges
+  // -----------------------------------------------------------------
+
+  it('Should cast array and truncate to maxItems from value', () => {
+    const result = Value.Cast(Type.Array(Type.Number(), { maxItems: 3 }), [0, 1, 2, 4, 5, 6])
+    Assert.deepEqual(result, [0, 1, 2])
+  })
+
+  it('Should cast arrays and append array to minItems from value', () => {
+    const result = Value.Cast(Type.Array(Type.Number(), { minItems: 6 }), [0, 1, 2])
+    Assert.deepEqual(result, [0, 1, 2, 0, 0, 0])
+  })
+
+  it('Should cast array and truncate to maxItems from default value', () => {
+    const result = Value.Cast(Type.Array(Type.Number(), { maxItems: 3, default: [0, 1, 2, 4, 5, 6] }), null)
+    Assert.deepEqual(result, [0, 1, 2])
+  })
+
+  it('Should cast arrays and append array to minItems from default value', () => {
+    const result = Value.Cast(Type.Array(Type.Number({ default: 1 }), { minItems: 6, default: [0, 1, 2] }), null)
+    Assert.deepEqual(result, [0, 1, 2, 1, 1, 1])
+  })
+
+  // -----------------------------------------------------------------
+  // Constraints: Unique
+  // -----------------------------------------------------------------
+
+  it('Should cast arrays with uniqueItems with unique default value', () => {
+    const result = Value.Cast(Type.Array(Type.Number(), { uniqueItems: true, default: [0, 1, 2] }), null)
+    Assert.deepEqual(result, [0, 1, 2])
+  })
+
+  it('Should cast arrays with uniqueItems with unique value', () => {
+    const result = Value.Cast(Type.Array(Type.Number(), { uniqueItems: true }), [0, 1, 2])
+    Assert.deepEqual(result, [0, 1, 2])
+  })
+
+  it('Should throw when casting arrays with uniqueItems and no value or default value', () => {
+    Assert.throws(() => Value.Cast(Type.Array(Type.Number(), { uniqueItems: true }), null))
+  })
+
+  it('Should throw when casting arrays with uniqueItems and not enough values to populate set', () => {
+    Assert.throws(() => Value.Cast(Type.Array(Type.Number(), { minItems: 3, uniqueItems: true }), [0, 1]))
+  })
+
+  it('Should throw when casting arrays with uniqueItems and not enough default values to populate set', () => {
+    Assert.throws(() => Value.Cast(Type.Array(Type.Number(), { minItems: 3, uniqueItems: true, default: [0, 1] }), null))
+  })
+
+  // -----------------------------------------------------------------
+  // Suggestion: https://github.com/sinclairzx81/typebox/issues/239
+  // -----------------------------------------------------------------
+
+  it('Should remove duplicates if uniqueItems is true', () => {
+    const T = Type.Array(Type.Number(), { uniqueItems: true })
+    const value = [1, 1, 2, 2]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, [1, 2])
+  })
+
+  it('Should should fill up with defaults to minItems', () => {
+    const T = Type.Array(Type.Number(), { minItems: 3 })
+    const value = [1, 2]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, [1, 2, 0])
+  })
+
+  it('Should should truncate to maxItems', () => {
+    const T = Type.Array(Type.Number(), { maxItems: 3 })
+    const value = [1, 2, 3, 4]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, [1, 2, 3])
+  })
+})
diff --git a/test/runtime/value/cast/boolean.ts b/test/runtime/value/cast/boolean.ts
new file mode 100644
index 000000000..e7a3c8023
--- /dev/null
+++ b/test/runtime/value/cast/boolean.ts
@@ -0,0 +1,53 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Boolean', () => {
+  const T = Type.Boolean()
+  const E = false
+
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from number', () => {
+    const value = 0
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, true)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preserve', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, true)
+  })
+})
diff --git a/test/runtime/value/cast/convert.ts b/test/runtime/value/cast/convert.ts
new file mode 100644
index 000000000..ba63f16a8
--- /dev/null
+++ b/test/runtime/value/cast/convert.ts
@@ -0,0 +1,281 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/String', () => {
+  it('Should convert string', () => {
+    const value = 'hello'
+    const result = Value.Cast(Type.String(), value)
+    Assert.deepEqual(result, 'hello')
+  })
+
+  it('Should convert number #1', () => {
+    const value = 42
+    const result = Value.Cast(Type.String(), value)
+    Assert.deepEqual(result, '42')
+  })
+
+  it('Should convert number #2', () => {
+    const value = 42n
+    const result = Value.Cast(Type.String(), value)
+    Assert.deepEqual(result, '42')
+  })
+
+  it('Should convert true', () => {
+    const value = true
+    const result = Value.Cast(Type.String(), value)
+    Assert.deepEqual(result, 'true')
+  })
+
+  it('Should convert false', () => {
+    const value = false
+    const result = Value.Cast(Type.String(), value)
+    Assert.deepEqual(result, 'false')
+  })
+
+  it('Should convert object', () => {
+    const value = {}
+    const result = Value.Cast(Type.String(), value)
+    Assert.deepEqual(result, '')
+  })
+
+  it('Should convert array', () => {
+    const value = [] as any[]
+    const result = Value.Cast(Type.String(), value)
+    Assert.deepEqual(result, '')
+  })
+})
+
+describe('value/convert/Number', () => {
+  it('Should convert string #1', () => {
+    const value = 'hello'
+    const result = Value.Cast(Type.Number(), value)
+    Assert.deepEqual(result, 0)
+  })
+
+  it('Should convert string #2', () => {
+    const value = '3.14'
+    const result = Value.Cast(Type.Number(), value)
+    Assert.deepEqual(result, 3.14)
+  })
+
+  it('Should convert string #3', () => {
+    const value = '-0'
+    const result = Value.Cast(Type.Number(), value)
+    Assert.deepEqual(result, 0)
+  })
+
+  it('Should convert string #4', () => {
+    const value = '-100'
+    const result = Value.Cast(Type.Number(), value)
+    Assert.deepEqual(result, -100)
+  })
+
+  it('Should convert number', () => {
+    const value = 42
+    const result = Value.Cast(Type.Number(), value)
+    Assert.deepEqual(result, 42)
+  })
+
+  it('Should convert true', () => {
+    const value = true
+    const result = Value.Cast(Type.Number(), value)
+    Assert.deepEqual(result, 1)
+  })
+
+  it('Should convert false', () => {
+    const value = false
+    const result = Value.Cast(Type.Number(), value)
+    Assert.deepEqual(result, 0)
+  })
+
+  it('Should convert object', () => {
+    const value = {}
+    const result = Value.Cast(Type.String(), value)
+    Assert.deepEqual(result, 0)
+  })
+
+  it('Should convert array', () => {
+    const value = [] as any[]
+    const result = Value.Cast(Type.String(), value)
+    Assert.deepEqual(result, 0)
+  })
+})
+
+describe('value/convert/Integer', () => {
+  it('Should convert string #1', () => {
+    const value = 'hello'
+    const result = Value.Cast(Type.Integer(), value)
+    Assert.deepEqual(result, 0)
+  })
+
+  it('Should convert string #2', () => {
+    const value = '3.14'
+    const result = Value.Cast(Type.Integer(), value)
+    Assert.deepEqual(result, 3)
+  })
+
+  it('Should convert string #3', () => {
+    const value = '-0'
+    const result = Value.Cast(Type.Integer(), value)
+    Assert.deepEqual(result, 0)
+  })
+
+  it('Should convert string #4', () => {
+    const value = '-100'
+    const result = Value.Cast(Type.Integer(), value)
+    Assert.deepEqual(result, -100)
+  })
+
+  it('Should convert number', () => {
+    const value = 42
+    const result = Value.Cast(Type.Integer(), value)
+    Assert.deepEqual(result, 42)
+  })
+
+  it('Should convert true', () => {
+    const value = true
+    const result = Value.Cast(Type.Integer(), value)
+    Assert.deepEqual(result, 1)
+  })
+
+  it('Should convert false', () => {
+    const value = false
+    const result = Value.Cast(Type.Integer(), value)
+    Assert.deepEqual(result, 0)
+  })
+
+  it('Should convert object', () => {
+    const value = {}
+    const result = Value.Cast(Type.Integer(), value)
+    Assert.deepEqual(result, 0)
+  })
+
+  it('Should convert array', () => {
+    const value = [] as any[]
+    const result = Value.Cast(Type.Integer(), value)
+    Assert.deepEqual(result, 0)
+  })
+})
+
+describe('value/convert/Boolean', () => {
+  it('Should convert string #1', () => {
+    const value = 'hello'
+    const result = Value.Cast(Type.Boolean(), value)
+    Assert.deepEqual(result, false)
+  })
+
+  it('Should convert string #2', () => {
+    const value = 'true'
+    const result = Value.Cast(Type.Boolean(), value)
+    Assert.deepEqual(result, true)
+  })
+
+  it('Should convert string #3', () => {
+    const value = 'TRUE'
+    const result = Value.Cast(Type.Boolean(), value)
+    Assert.deepEqual(result, true)
+  })
+
+  it('Should convert string #4', () => {
+    const value = 'false'
+    const result = Value.Cast(Type.Boolean(), value)
+    Assert.deepEqual(result, false)
+  })
+
+  it('Should convert string #5', () => {
+    const value = '0'
+    const result = Value.Cast(Type.Boolean(), value)
+    Assert.deepEqual(result, false)
+  })
+
+  it('Should convert string #6', () => {
+    const value = '1'
+    const result = Value.Cast(Type.Boolean(), value)
+    Assert.deepEqual(result, true)
+  })
+
+  it('Should convert string #7', () => {
+    const value = '0'
+    const result = Value.Cast(Type.Boolean({ default: true }), value)
+    Assert.deepEqual(result, false)
+  })
+
+  it('Should convert string #8', () => {
+    const value = '1'
+    const result = Value.Cast(Type.Boolean({ default: false }), value)
+    Assert.deepEqual(result, true)
+  })
+
+  it('Should convert string #8', () => {
+    const value = '2'
+    const result = Value.Cast(Type.Boolean({ default: true }), value)
+    Assert.deepEqual(result, true)
+  })
+
+  it('Should convert number #1', () => {
+    const value = 0
+    const result = Value.Cast(Type.Boolean(), value)
+    Assert.deepEqual(result, false)
+  })
+
+  it('Should convert number #2', () => {
+    const value = 1n
+    const result = Value.Cast(Type.Boolean(), value)
+    Assert.deepEqual(result, true)
+  })
+
+  it('Should convert number #3', () => {
+    const value = 1
+    const result = Value.Cast(Type.Boolean(), value)
+    Assert.deepEqual(result, true)
+  })
+
+  it('Should convert number #4', () => {
+    const value = 2
+    const result = Value.Cast(Type.Boolean(), value)
+    Assert.deepEqual(result, false)
+  })
+
+  it('Should convert number #5', () => {
+    const value = 0
+    const result = Value.Cast(Type.Boolean({ default: true }), value)
+    Assert.deepEqual(result, false)
+  })
+
+  it('Should convert number #6', () => {
+    const value = 1
+    const result = Value.Cast(Type.Boolean({ default: false }), value)
+    Assert.deepEqual(result, true)
+  })
+
+  it('Should convert number #7', () => {
+    const value = 2
+    const result = Value.Cast(Type.Boolean({ default: true }), value)
+    Assert.deepEqual(result, true)
+  })
+
+  it('Should convert true', () => {
+    const value = true
+    const result = Value.Cast(Type.Boolean(), value)
+    Assert.deepEqual(result, true)
+  })
+
+  it('Should convert false', () => {
+    const value = false
+    const result = Value.Cast(Type.Boolean(), value)
+    Assert.deepEqual(result, false)
+  })
+
+  it('Should convert object', () => {
+    const value = {}
+    const result = Value.Cast(Type.Boolean(), value)
+    Assert.deepEqual(result, false)
+  })
+
+  it('Should convert array', () => {
+    const value = [] as any[]
+    const result = Value.Cast(Type.Boolean(), value)
+    Assert.deepEqual(result, false)
+  })
+})
diff --git a/test/runtime/value/cast/enum.ts b/test/runtime/value/cast/enum.ts
new file mode 100644
index 000000000..232505ac7
--- /dev/null
+++ b/test/runtime/value/cast/enum.ts
@@ -0,0 +1,62 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Boolean', () => {
+  enum Foo {
+    A,
+    B,
+  }
+  const T = Type.Enum(Foo)
+  const E = Foo.A
+
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from number', () => {
+    const value = 123
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from enum A', () => {
+    const value = Foo.A
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, Foo.A)
+  })
+
+  it('Should upcast from enum B', () => {
+    const value = Foo.B
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, Foo.B)
+  })
+})
diff --git a/test/runtime/value/cast/index.ts b/test/runtime/value/cast/index.ts
new file mode 100644
index 000000000..14b81b055
--- /dev/null
+++ b/test/runtime/value/cast/index.ts
@@ -0,0 +1,24 @@
+import './any'
+import './array'
+import './boolean'
+import './convert'
+import './enum'
+import './integer'
+import './intersect'
+import './keyof'
+import './literal'
+import './namespace'
+import './never'
+import './null'
+import './number'
+import './object'
+import './rec'
+import './record'
+import './regex'
+import './string'
+import './tuple'
+import './uint8array'
+import './undefined'
+import './union'
+import './unknown'
+import './void'
diff --git a/test/runtime/value/cast/integer.ts b/test/runtime/value/cast/integer.ts
new file mode 100644
index 000000000..1f026ac8e
--- /dev/null
+++ b/test/runtime/value/cast/integer.ts
@@ -0,0 +1,47 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Integer', () => {
+  const T = Type.Integer()
+  const E = 0
+
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, 1)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, 1) // conversion
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+})
diff --git a/test/runtime/value/cast/intersect.ts b/test/runtime/value/cast/intersect.ts
new file mode 100644
index 000000000..78e2c0bb5
--- /dev/null
+++ b/test/runtime/value/cast/intersect.ts
@@ -0,0 +1,90 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Intersect', () => {
+  const A = Type.Object({
+    x: Type.Number({ default: 0 }),
+    y: Type.Number({ default: 1 }),
+    z: Type.Number({ default: 2 }),
+  })
+  const B = Type.Object({
+    a: Type.Number({ default: 'a' }),
+    b: Type.Number({ default: 'b' }),
+    c: Type.Number({ default: 'c' }),
+  })
+  const T = Type.Intersect([A, B])
+  const E = {
+    x: 0,
+    y: 1,
+    z: 2,
+    a: 'a',
+    b: 'b',
+    c: 'c',
+  }
+
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from number', () => {
+    const value = E
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast and preserve object', () => {
+    const value = { x: 7, y: 8, z: 9 }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, {
+      x: 7,
+      y: 8,
+      z: 9,
+      a: 'a',
+      b: 'b',
+      c: 'c',
+    })
+  })
+
+  it('Should upcast and preserve from incorrect properties', () => {
+    const value = { x: {}, y: 8, z: 9 }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, {
+      x: 0,
+      y: 8,
+      z: 9,
+      a: 'a',
+      b: 'b',
+      c: 'c',
+    })
+  })
+})
diff --git a/test/runtime/value/cast/keyof.ts b/test/runtime/value/cast/keyof.ts
new file mode 100644
index 000000000..c9c2b9c9c
--- /dev/null
+++ b/test/runtime/value/cast/keyof.ts
@@ -0,0 +1,62 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/KeyOf', () => {
+  const T = Type.KeyOf(
+    Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    }),
+  )
+  const E = 'x'
+
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preserve', () => {
+    const value = 'y'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, 'y')
+  })
+})
diff --git a/test/runtime/value/cast/literal.ts b/test/runtime/value/cast/literal.ts
new file mode 100644
index 000000000..bf0174a77
--- /dev/null
+++ b/test/runtime/value/cast/literal.ts
@@ -0,0 +1,53 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Literal', () => {
+  const T = Type.Literal('hello')
+  const E = 'hello'
+
+  it('Should upcast from string', () => {
+    const value = 'world'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preseve', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, 'hello')
+  })
+})
diff --git a/test/runtime/value/cast/namespace.ts b/test/runtime/value/cast/namespace.ts
new file mode 100644
index 000000000..e69de29bb
diff --git a/test/runtime/value/cast/never.ts b/test/runtime/value/cast/never.ts
new file mode 100644
index 000000000..d8ec459fe
--- /dev/null
+++ b/test/runtime/value/cast/never.ts
@@ -0,0 +1,35 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Never', () => {
+  const T = Type.Never()
+  it('Should throw from string', () => {
+    const value = 'hello'
+    Assert.throws(() => Value.Cast(T, value))
+  })
+  it('Should throw from number', () => {
+    const value = 1
+    Assert.throws(() => Value.Cast(T, value))
+  })
+  it('Should throw from boolean', () => {
+    const value = false
+    Assert.throws(() => Value.Cast(T, value))
+  })
+  it('Should throw from object', () => {
+    const value = {}
+    Assert.throws(() => Value.Cast(T, value))
+  })
+  it('Should throw from array', () => {
+    const value = [1]
+    Assert.throws(() => Value.Cast(T, value))
+  })
+  it('Should throw from undefined', () => {
+    const value = undefined
+    Assert.throws(() => Value.Cast(T, value))
+  })
+  it('Should throw from null', () => {
+    const value = null
+    Assert.throws(() => Value.Cast(T, value))
+  })
+})
diff --git a/test/runtime/value/cast/null.ts b/test/runtime/value/cast/null.ts
new file mode 100644
index 000000000..5857121e2
--- /dev/null
+++ b/test/runtime/value/cast/null.ts
@@ -0,0 +1,53 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Null', () => {
+  const T = Type.Null()
+  const E = null
+
+  it('Should upcast from string', () => {
+    const value = 'world'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preseve', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, null)
+  })
+})
diff --git a/test/runtime/value/cast/number.ts b/test/runtime/value/cast/number.ts
new file mode 100644
index 000000000..273f1f4ab
--- /dev/null
+++ b/test/runtime/value/cast/number.ts
@@ -0,0 +1,53 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Number', () => {
+  const T = Type.Number()
+  const E = 0
+
+  it('Should upcast from string', () => {
+    const value = 'world'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, 1)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true // convert
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, 1)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preseve', () => {
+    const value = 123
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, 123)
+  })
+})
diff --git a/test/runtime/value/cast/object.ts b/test/runtime/value/cast/object.ts
new file mode 100644
index 000000000..bf821147b
--- /dev/null
+++ b/test/runtime/value/cast/object.ts
@@ -0,0 +1,112 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Object', () => {
+  const T = Type.Object({
+    a: Type.Number({ default: 'a' }),
+    b: Type.Number({ default: 'b' }),
+    c: Type.Number({ default: 'c' }),
+    x: Type.Number({ default: 0 }),
+    y: Type.Number({ default: 1 }),
+    z: Type.Number({ default: 2 }),
+  })
+  const E = {
+    x: 0,
+    y: 1,
+    z: 2,
+    a: 'a',
+    b: 'b',
+    c: 'c',
+  }
+
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from number', () => {
+    const value = E
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should preserve', () => {
+    const value = { x: 7, y: 8, z: 9, a: 10, b: 11, c: 12 }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, {
+      x: 7,
+      y: 8,
+      z: 9,
+      a: 10,
+      b: 11,
+      c: 12,
+    })
+  })
+  it('Should upcast and preserve partial object', () => {
+    const value = { x: 7, y: 8, z: 9 }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, {
+      x: 7,
+      y: 8,
+      z: 9,
+      a: 'a',
+      b: 'b',
+      c: 'c',
+    })
+  })
+
+  it('Should upcast and preserve partial object with incorrect properties', () => {
+    const value = { x: {}, y: 8, z: 9 }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, {
+      x: 0,
+      y: 8,
+      z: 9,
+      a: 'a',
+      b: 'b',
+      c: 'c',
+    })
+  })
+
+  it('Should upcast and preserve partial object and omit unknown properties', () => {
+    const value = { x: 7, y: 8, z: 9, unknown: 'foo' }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, {
+      x: 7,
+      y: 8,
+      z: 9,
+      a: 'a',
+      b: 'b',
+      c: 'c',
+    })
+  })
+})
diff --git a/test/runtime/value/cast/rec.ts b/test/runtime/value/cast/rec.ts
new file mode 100644
index 000000000..478a5fc87
--- /dev/null
+++ b/test/runtime/value/cast/rec.ts
@@ -0,0 +1,104 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Recursive', () => {
+  const T = Type.Recursive((Self) =>
+    Type.Object({
+      id: Type.String(),
+      nodes: Type.Array(Self),
+    }),
+  )
+
+  const E = { id: '', nodes: [] }
+
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from number', () => {
+    const value = E
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preserve', () => {
+    const value = {
+      id: 'A',
+      nodes: [
+        { id: 'B', nodes: [] },
+        { id: 'C', nodes: [] },
+        { id: 'D', nodes: [] },
+      ],
+    }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+
+  it('Should upcast from varying types', () => {
+    const TypeA = Type.Recursive((Self) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(Self),
+      }),
+    )
+
+    const TypeB = Type.Recursive((Self) =>
+      Type.Object({
+        id: Type.String(),
+        name: Type.String({ default: 'test' }),
+        nodes: Type.Array(Self),
+      }),
+    )
+
+    const ValueA = {
+      id: 'A',
+      nodes: [
+        { id: 'B', nodes: [] },
+        { id: 'C', nodes: [] },
+        { id: 'D', nodes: [] },
+      ],
+    }
+    const ValueB = Value.Cast(TypeB, ValueA)
+
+    Assert.deepEqual(ValueB, {
+      id: 'A',
+      name: 'test',
+      nodes: [
+        { id: 'B', name: 'test', nodes: [] },
+        { id: 'C', name: 'test', nodes: [] },
+        { id: 'D', name: 'test', nodes: [] },
+      ],
+    })
+  })
+})
diff --git a/test/runtime/value/cast/record.ts b/test/runtime/value/cast/record.ts
new file mode 100644
index 000000000..c8e9dd350
--- /dev/null
+++ b/test/runtime/value/cast/record.ts
@@ -0,0 +1,81 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Record', () => {
+  const T = Type.Record(
+    Type.String(),
+    Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    }),
+  )
+  const E = {}
+
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from number', () => {
+    const value = E
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preserve', () => {
+    const value = {
+      a: { x: 1, y: 2, z: 3 },
+      b: { x: 4, y: 5, z: 6 },
+    }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+  it('Should preserve and patch invalid records', () => {
+    const value = {
+      a: { x: 1, y: 2, z: 3 },
+      b: { x: 4, y: 5, z: {} },
+      c: [1, 2, 3],
+      d: 1,
+      e: { x: 1, y: 2, w: 9000 },
+    }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, {
+      a: { x: 1, y: 2, z: 3 },
+      b: { x: 4, y: 5, z: 0 },
+      c: { x: 0, y: 0, z: 0 },
+      d: { x: 0, y: 0, z: 0 },
+      e: { x: 1, y: 2, z: 0 },
+    })
+  })
+})
diff --git a/test/runtime/value/cast/regex.ts b/test/runtime/value/cast/regex.ts
new file mode 100644
index 000000000..c973dba37
--- /dev/null
+++ b/test/runtime/value/cast/regex.ts
@@ -0,0 +1,53 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/RegEx', () => {
+  const T = Type.RegEx(/foo/, { default: 'foo' })
+  const E = 'foo'
+
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, 'foo')
+  })
+
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preserve', () => {
+    const value = 'foo'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+})
diff --git a/test/runtime/value/cast/string.ts b/test/runtime/value/cast/string.ts
new file mode 100644
index 000000000..9b5fa1ef7
--- /dev/null
+++ b/test/runtime/value/cast/string.ts
@@ -0,0 +1,55 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/String', () => {
+  const T = Type.String()
+  const E = ''
+
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, 'hello')
+  })
+
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, '1') // conversion
+  })
+
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, 'true') // conversion
+  })
+
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preserve', () => {
+    const value = 'foo'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+})
diff --git a/test/runtime/value/cast/tuple.ts b/test/runtime/value/cast/tuple.ts
new file mode 100644
index 000000000..4ecb10d96
--- /dev/null
+++ b/test/runtime/value/cast/tuple.ts
@@ -0,0 +1,80 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Tuple', () => {
+  const T = Type.Tuple([Type.Number(), Type.String()])
+  const E = [0, '']
+
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, [1, ''])
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preserve', () => {
+    const value = [42, 'world']
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+
+  it('Should upcast with empty', () => {
+    const value = [] as any[]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should append with less than tuple length', () => {
+    const value = [42]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, [42, ''])
+  })
+
+  it('Should truncate with greater than tuple length', () => {
+    const value = [42, '', true]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, [42, ''])
+  })
+
+  it('Should preserve and patch invalid element', () => {
+    const value = [{}, 'hello']
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, [0, 'hello'])
+  })
+})
diff --git a/test/runtime/value/cast/uint8array.ts b/test/runtime/value/cast/uint8array.ts
new file mode 100644
index 000000000..edcdef5de
--- /dev/null
+++ b/test/runtime/value/cast/uint8array.ts
@@ -0,0 +1,53 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Uint8Array', () => {
+  const T = Type.Uint8Array({ default: new Uint8Array([0, 1, 2, 3]) })
+  const E = new Uint8Array([0, 1, 2, 3])
+
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preserve', () => {
+    const value = new Uint8Array([6, 7, 8, 9, 10])
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+})
diff --git a/test/runtime/value/cast/undefined.ts b/test/runtime/value/cast/undefined.ts
new file mode 100644
index 000000000..62de89959
--- /dev/null
+++ b/test/runtime/value/cast/undefined.ts
@@ -0,0 +1,53 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Undefined', () => {
+  const T = Type.Undefined()
+  const E = undefined
+
+  it('Should upcast from string', () => {
+    const value = 'world'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preseve', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, undefined)
+  })
+})
diff --git a/test/runtime/value/cast/union.ts b/test/runtime/value/cast/union.ts
new file mode 100644
index 000000000..5998527da
--- /dev/null
+++ b/test/runtime/value/cast/union.ts
@@ -0,0 +1,125 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Union', () => {
+  const A = Type.Object(
+    {
+      type: Type.Literal('A'),
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    },
+    { additionalProperties: false },
+  )
+  const B = Type.Object(
+    {
+      type: Type.Literal('B'),
+      a: Type.String(),
+      b: Type.String(),
+      c: Type.String(),
+    },
+    { additionalProperties: false },
+  )
+  const T = Type.Union([A, B])
+
+  const E = {
+    type: 'A',
+    x: 0,
+    y: 0,
+    z: 0,
+  }
+
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preserve A', () => {
+    const value = { type: 'A', x: 1, y: 2, z: 3 }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+
+  it('Should preserve B', () => {
+    const value = { type: 'B', a: 'a', b: 'b', c: 'c' }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+
+  it('Should infer through heuristics #1', () => {
+    const value = { type: 'A', a: 'a', b: 'b', c: 'c' }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, { type: 'A', x: 0, y: 0, z: 0 })
+  })
+
+  it('Should infer through heuristics #2', () => {
+    const value = { type: 'B', x: 1, y: 2, z: 3 }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, { type: 'B', a: '', b: '', c: '' })
+  })
+
+  it('Should infer through heuristics #3', () => {
+    const value = { type: 'A', a: 'a', b: 'b', c: null }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, { type: 'A', x: 0, y: 0, z: 0 })
+  })
+
+  it('Should infer through heuristics #4', () => {
+    const value = { type: 'B', x: 1, y: 2, z: {} }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, { type: 'B', a: '', b: '', c: '' })
+  })
+
+  it('Should infer through heuristics #5', () => {
+    const value = { type: 'B', x: 1, y: 2, z: null }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, { type: 'B', a: '', b: '', c: '' })
+  })
+
+  it('Should infer through heuristics #6', () => {
+    const value = { x: 1 }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, { type: 'A', x: 1, y: 0, z: 0 })
+  })
+
+  it('Should infer through heuristics #7', () => {
+    const value = { a: null } // property existing should contribute
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, { type: 'B', a: '', b: '', c: '' })
+  })
+})
diff --git a/test/runtime/value/cast/unknown.ts b/test/runtime/value/cast/unknown.ts
new file mode 100644
index 000000000..5a98faa9c
--- /dev/null
+++ b/test/runtime/value/cast/unknown.ts
@@ -0,0 +1,50 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Unknown', () => {
+  const T = Type.Unknown()
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+  it('Should upcast from boolean', () => {
+    const value = false
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, value)
+  })
+
+  it('Should preserve', () => {
+    const value = { a: 1, b: 2 }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, { a: 1, b: 2 })
+  })
+})
diff --git a/test/runtime/value/cast/void.ts b/test/runtime/value/cast/void.ts
new file mode 100644
index 000000000..33e53e02d
--- /dev/null
+++ b/test/runtime/value/cast/void.ts
@@ -0,0 +1,53 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Void', () => {
+  const T = Type.Void()
+  const E = null
+
+  it('Should upcast from string', () => {
+    const value = 'world'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preserve', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, null)
+  })
+})
diff --git a/test/runtime/value/check/any.ts b/test/runtime/value/check/any.ts
new file mode 100644
index 000000000..15f31b510
--- /dev/null
+++ b/test/runtime/value/check/any.ts
@@ -0,0 +1,42 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Any', () => {
+  const T = Type.Any()
+  it('Should pass string', () => {
+    const value = 'hello'
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should pass number', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should pass boolean', () => {
+    const value = true
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should pass null', () => {
+    const value = null
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should pass undefined', () => {
+    const value = undefined
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should pass object', () => {
+    const value = { a: 1 }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should pass array', () => {
+    const value = [1, 2]
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+})
diff --git a/test/runtime/value/check/array.ts b/test/runtime/value/check/array.ts
new file mode 100644
index 000000000..5b7b327e1
--- /dev/null
+++ b/test/runtime/value/check/array.ts
@@ -0,0 +1,33 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Array', () => {
+  it('Should pass number array', () => {
+    const T = Type.Array(Type.Number())
+    const value = [1, 2, 3]
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail number array', () => {
+    const T = Type.Array(Type.Number())
+    const value = ['a', 'b', 'c']
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should pass object array', () => {
+    const T = Type.Array(Type.Object({ x: Type.Number() }))
+    const value = [{ x: 1 }, { x: 1 }, { x: 1 }]
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail object array', () => {
+    const T = Type.Array(Type.Object({ x: Type.Number() }))
+    const value = [{ x: 1 }, { x: 1 }, 1]
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/boolean.ts b/test/runtime/value/check/boolean.ts
new file mode 100644
index 000000000..003bc296a
--- /dev/null
+++ b/test/runtime/value/check/boolean.ts
@@ -0,0 +1,42 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Boolean', () => {
+  const T = Type.Boolean()
+  it('Should fail string', () => {
+    const value = 'hello'
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail number', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should pass boolean', () => {
+    const value = true
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should fail null', () => {
+    const value = null
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail undefined', () => {
+    const value = undefined
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail object', () => {
+    const value = { a: 1 }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail array', () => {
+    const value = [1, 2]
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/enum.ts b/test/runtime/value/check/enum.ts
new file mode 100644
index 000000000..505625ca9
--- /dev/null
+++ b/test/runtime/value/check/enum.ts
@@ -0,0 +1,29 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Enum', () => {
+  enum Foo {
+    A = 1,
+    B = 2,
+  }
+  const T = Type.Enum(Foo)
+
+  it('Should pass enum option A', () => {
+    const value = Foo.A
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should pass enum option B', () => {
+    const value = Foo.A
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail unknown value', () => {
+    const value = 'unknown'
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/index.ts b/test/runtime/value/check/index.ts
new file mode 100644
index 000000000..e617cfa64
--- /dev/null
+++ b/test/runtime/value/check/index.ts
@@ -0,0 +1,22 @@
+import './any'
+import './array'
+import './boolean'
+import './enum'
+import './integer'
+import './intersect'
+import './keyof'
+import './literal'
+import './never'
+import './null'
+import './number'
+import './object'
+import './rec'
+import './record'
+import './regex'
+import './string'
+import './tuple'
+import './uint8array'
+import './undefined'
+import './union'
+import './unknown'
+import './void'
diff --git a/test/runtime/value/check/integer.ts b/test/runtime/value/check/integer.ts
new file mode 100644
index 000000000..27ab4d396
--- /dev/null
+++ b/test/runtime/value/check/integer.ts
@@ -0,0 +1,19 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Integer', () => {
+  const T = Type.Integer()
+
+  it('Should pass integer', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail integer', () => {
+    const value = 3.14
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/intersect.ts b/test/runtime/value/check/intersect.ts
new file mode 100644
index 000000000..c5f747b35
--- /dev/null
+++ b/test/runtime/value/check/intersect.ts
@@ -0,0 +1,82 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Intersect', () => {
+  const A = Type.Object({
+    x: Type.Number(),
+    y: Type.Number(),
+    z: Type.Number(),
+  })
+  const B = Type.Object({
+    a: Type.String(),
+    b: Type.String(),
+    c: Type.String(),
+  })
+  const T = Type.Intersect([A, B])
+
+  it('Should pass intersect', () => {
+    const value = {
+      x: 1,
+      y: 1,
+      z: 1,
+      a: '1',
+      b: '1',
+      c: '1',
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail intersect with invalid property', () => {
+    const value = {
+      x: true,
+      y: 1,
+      z: 1,
+      a: '1',
+      b: '1',
+      c: '1',
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail intersect with missing property', () => {
+    const value = {
+      y: 1,
+      z: 1,
+      a: '1',
+      b: '1',
+      c: '1',
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail intersect with primitive value', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should pass intersect with optional properties', () => {
+    const A = Type.Object({
+      x: Type.Optional(Type.Number()),
+      y: Type.Optional(Type.Number()),
+      z: Type.Optional(Type.Number()),
+    })
+    const B = Type.Object({
+      a: Type.String(),
+      b: Type.String(),
+      c: Type.String(),
+    })
+    const T = Type.Intersect([A, B])
+    const value = {
+      a: '1',
+      b: '1',
+      c: '1',
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+})
diff --git a/test/runtime/value/check/keyof.ts b/test/runtime/value/check/keyof.ts
new file mode 100644
index 000000000..132446d60
--- /dev/null
+++ b/test/runtime/value/check/keyof.ts
@@ -0,0 +1,37 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/KeyOf', () => {
+  const T = Type.KeyOf(
+    Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    }),
+  )
+
+  it('Should pass keyof', () => {
+    const value = 'x'
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail keyof', () => {
+    const value = 'w'
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail keyof with undefined', () => {
+    const value = undefined
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail keyof with null', () => {
+    const value = null
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/literal.ts b/test/runtime/value/check/literal.ts
new file mode 100644
index 000000000..84667b1e0
--- /dev/null
+++ b/test/runtime/value/check/literal.ts
@@ -0,0 +1,27 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Literal', () => {
+  const T = Type.Literal('hello')
+  it('Should pass literal', () => {
+    const value = 'hello'
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should fail literal', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail literal with undefined', () => {
+    const value = undefined
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail literal with null', () => {
+    const value = null
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/never.ts b/test/runtime/value/check/never.ts
new file mode 100644
index 000000000..4f4948d6a
--- /dev/null
+++ b/test/runtime/value/check/never.ts
@@ -0,0 +1,42 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Never', () => {
+  const T = Type.Never()
+  it('Should fail string', () => {
+    const value = 'hello'
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail number', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail boolean', () => {
+    const value = true
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail null', () => {
+    const value = null
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail undefined', () => {
+    const value = undefined
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail object', () => {
+    const value = { a: 1 }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail array', () => {
+    const value = [1, 2]
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/null.ts b/test/runtime/value/check/null.ts
new file mode 100644
index 000000000..f2cbc93ff
--- /dev/null
+++ b/test/runtime/value/check/null.ts
@@ -0,0 +1,42 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Null', () => {
+  const T = Type.Null()
+  it('Should fail string', () => {
+    const value = 'hello'
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail number', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail boolean', () => {
+    const value = true
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should pass null', () => {
+    const value = null
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should fail undefined', () => {
+    const value = undefined
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail object', () => {
+    const value = { a: 1 }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail array', () => {
+    const value = [1, 2]
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/number.ts b/test/runtime/value/check/number.ts
new file mode 100644
index 000000000..f6b34bebf
--- /dev/null
+++ b/test/runtime/value/check/number.ts
@@ -0,0 +1,42 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Number', () => {
+  const T = Type.Number()
+  it('Should fail string', () => {
+    const value = 'hello'
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should pass number', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should fail boolean', () => {
+    const value = true
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail null', () => {
+    const value = null
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail undefined', () => {
+    const value = undefined
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail object', () => {
+    const value = { a: 1 }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail array', () => {
+    const value = [1, 2]
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/object.ts b/test/runtime/value/check/object.ts
new file mode 100644
index 000000000..25ac7265f
--- /dev/null
+++ b/test/runtime/value/check/object.ts
@@ -0,0 +1,101 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Object', () => {
+  const T = Type.Object({
+    x: Type.Number(),
+    y: Type.Number(),
+    z: Type.Number(),
+    a: Type.String(),
+    b: Type.String(),
+    c: Type.String(),
+  })
+
+  it('Should pass object', () => {
+    const value = {
+      x: 1,
+      y: 1,
+      z: 1,
+      a: '1',
+      b: '1',
+      c: '1',
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail object with additional properties', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const value = {
+      x: 1,
+      y: 1,
+      z: 1,
+      a: 1,
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail object with invalid property', () => {
+    const value = {
+      x: true,
+      y: 1,
+      z: 1,
+      a: '1',
+      b: '1',
+      c: '1',
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail object with missing property', () => {
+    const value = {
+      y: 1,
+      z: 1,
+      a: '1',
+      b: '1',
+      c: '1',
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should pass object with optional properties', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.Number()),
+      y: Type.Optional(Type.Number()),
+      z: Type.Optional(Type.Number()),
+      a: Type.String(),
+      b: Type.String(),
+      c: Type.String(),
+    })
+    const value = {
+      a: '1',
+      b: '1',
+      c: '1',
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail object with null', () => {
+    const value = null
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail object with undefined', () => {
+    const value = undefined
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/rec.ts b/test/runtime/value/check/rec.ts
new file mode 100644
index 000000000..4659b7f8c
--- /dev/null
+++ b/test/runtime/value/check/rec.ts
@@ -0,0 +1,69 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Recursive', () => {
+  const T = Type.Recursive((Self) =>
+    Type.Object({
+      id: Type.String(),
+      nodes: Type.Array(Self),
+    }),
+  )
+
+  it('Should pass recursive', () => {
+    const value = {
+      id: 'A',
+      nodes: [
+        { id: 'B', nodes: [] },
+        { id: 'C', nodes: [] },
+        { id: 'D', nodes: [] },
+      ],
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail recursive with invalid id', () => {
+    const value = {
+      id: 'A',
+      nodes: [
+        { id: 1, nodes: [] },
+        { id: 'C', nodes: [] },
+        { id: 'D', nodes: [] },
+      ],
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail rec with invalid nodes', () => {
+    const value = {
+      id: 'A',
+      nodes: [
+        { id: 'B', nodes: 1 },
+        { id: 'C', nodes: [] },
+        { id: 'D', nodes: [] },
+      ],
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail recursive with missing id', () => {
+    const value = {
+      id: 'A',
+      nodes: [{ nodes: [] }, { id: 'C', nodes: [] }, { id: 'D', nodes: [] }],
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail rec with missing nodes', () => {
+    const value = {
+      id: 'A',
+      nodes: [{ id: 'B' }, { id: 'C', nodes: [] }, { id: 'D', nodes: [] }],
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/record.ts b/test/runtime/value/check/record.ts
new file mode 100644
index 000000000..fe58df049
--- /dev/null
+++ b/test/runtime/value/check/record.ts
@@ -0,0 +1,83 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Record', () => {
+  it('Should pass record', () => {
+    const T = Type.Record(
+      Type.String(),
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+    )
+    const value = {
+      position: {
+        x: 1,
+        y: 2,
+        z: 3,
+      },
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail record with missing property', () => {
+    const T = Type.Record(
+      Type.String(),
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+    )
+    const value = {
+      position: {
+        x: 1,
+        y: 2,
+      },
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail record with invalid property', () => {
+    const T = Type.Record(
+      Type.String(),
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+    )
+    const value = {
+      position: {
+        x: 1,
+        y: 2,
+        z: '3',
+      },
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should pass record with optional property', () => {
+    const T = Type.Record(
+      Type.String(),
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Optional(Type.Number()),
+      }),
+    )
+    const value = {
+      position: {
+        x: 1,
+        y: 2,
+      },
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+})
diff --git a/test/runtime/value/check/regex.ts b/test/runtime/value/check/regex.ts
new file mode 100644
index 000000000..343e10980
--- /dev/null
+++ b/test/runtime/value/check/regex.ts
@@ -0,0 +1,19 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/RegEx', () => {
+  it('Should pass regex', () => {
+    const T = Type.RegEx(/foo/)
+    const value = 'foo'
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail regex', () => {
+    const T = Type.RegEx(/foo/)
+    const value = 'bar'
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/string.ts b/test/runtime/value/check/string.ts
new file mode 100644
index 000000000..85737681a
--- /dev/null
+++ b/test/runtime/value/check/string.ts
@@ -0,0 +1,42 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/String', () => {
+  const T = Type.String()
+  it('Should pass string', () => {
+    const value = 'hello'
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should fail number', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail boolean', () => {
+    const value = true
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail null', () => {
+    const value = null
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail undefined', () => {
+    const value = undefined
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail object', () => {
+    const value = { a: 1 }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail array', () => {
+    const value = [1, 2]
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/tuple.ts b/test/runtime/value/check/tuple.ts
new file mode 100644
index 000000000..2d010d9aa
--- /dev/null
+++ b/test/runtime/value/check/tuple.ts
@@ -0,0 +1,40 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Tuple', () => {
+  it('Should pass tuple', () => {
+    const T = Type.Tuple([Type.Number(), Type.Number()])
+    const value = [1, 2]
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail when tuple is less than length', () => {
+    const T = Type.Tuple([Type.Number(), Type.Number()])
+    const value = [1]
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail when tuple is greater than length', () => {
+    const T = Type.Tuple([Type.Number(), Type.Number()])
+    const value = [1, 1, 2]
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should pass empty tuple', () => {
+    const T = Type.Tuple([])
+    const value = [] as any[]
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail empty tuple', () => {
+    const T = Type.Tuple([])
+    const value = [1]
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/uint8array.ts b/test/runtime/value/check/uint8array.ts
new file mode 100644
index 000000000..f792d8147
--- /dev/null
+++ b/test/runtime/value/check/uint8array.ts
@@ -0,0 +1,33 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Uint8Array', () => {
+  it('Should pass uint8array', () => {
+    const T = Type.Uint8Array()
+    const value = new Uint8Array(4)
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail uint8array', () => {
+    const T = Type.Uint8Array()
+    const value = [0, 1, 2, 3]
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail uint8array with undefined', () => {
+    const T = Type.Uint8Array()
+    const value = undefined
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail uint8array with null', () => {
+    const T = Type.Uint8Array()
+    const value = null
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/undefined.ts b/test/runtime/value/check/undefined.ts
new file mode 100644
index 000000000..162022385
--- /dev/null
+++ b/test/runtime/value/check/undefined.ts
@@ -0,0 +1,42 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Undefined', () => {
+  const T = Type.Undefined()
+  it('Should fail string', () => {
+    const value = 'hello'
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail number', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail boolean', () => {
+    const value = true
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail null', () => {
+    const value = null
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should pass undefined', () => {
+    const value = undefined
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should fail object', () => {
+    const value = { a: 1 }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail array', () => {
+    const value = [1, 2]
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/union.ts b/test/runtime/value/check/union.ts
new file mode 100644
index 000000000..ff822c895
--- /dev/null
+++ b/test/runtime/value/check/union.ts
@@ -0,0 +1,77 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Union', () => {
+  const A = Type.Object({
+    type: Type.Literal('A'),
+    x: Type.Number(),
+    y: Type.Number(),
+  })
+
+  const B = Type.Object({
+    type: Type.Literal('B'),
+    x: Type.Boolean(),
+    y: Type.Boolean(),
+  })
+
+  const T = Type.Union([A, B])
+
+  it('Should pass union A', () => {
+    const value = { type: 'A', x: 1, y: 1 }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should pass union B', () => {
+    const value = { type: 'B', x: true, y: false }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail union A', () => {
+    const value = { type: 'A', x: true, y: false }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail union B', () => {
+    const value = { type: 'B', x: 1, y: 1 }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should pass union A with optional properties', () => {
+    const A = Type.Object({
+      type: Type.Literal('A'),
+      x: Type.Optional(Type.Number()),
+      y: Type.Optional(Type.Number()),
+    })
+    const B = Type.Object({
+      type: Type.Literal('B'),
+      x: Type.Boolean(),
+      y: Type.Boolean(),
+    })
+    const T = Type.Union([A, B])
+    const value = { type: 'A' }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail union A with invalid optional properties', () => {
+    const A = Type.Object({
+      type: Type.Literal('A'),
+      x: Type.Optional(Type.Number()),
+      y: Type.Optional(Type.Number()),
+    })
+    const B = Type.Object({
+      type: Type.Literal('B'),
+      x: Type.Boolean(),
+      y: Type.Boolean(),
+    })
+    const T = Type.Union([A, B])
+    const value = { type: 'A', x: true, y: false }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/check/unknown.ts b/test/runtime/value/check/unknown.ts
new file mode 100644
index 000000000..1bb814596
--- /dev/null
+++ b/test/runtime/value/check/unknown.ts
@@ -0,0 +1,42 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Unknown', () => {
+  const T = Type.Any()
+  it('Should pass string', () => {
+    const value = 'hello'
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should pass number', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should pass boolean', () => {
+    const value = true
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should pass null', () => {
+    const value = null
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should pass undefined', () => {
+    const value = undefined
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should pass object', () => {
+    const value = { a: 1 }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should pass array', () => {
+    const value = [1, 2]
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+})
diff --git a/test/runtime/value/check/void.ts b/test/runtime/value/check/void.ts
new file mode 100644
index 000000000..b9d01c1f3
--- /dev/null
+++ b/test/runtime/value/check/void.ts
@@ -0,0 +1,42 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Void', () => {
+  const T = Type.Void()
+  it('Should fail string', () => {
+    const value = 'hello'
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail number', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail boolean', () => {
+    const value = true
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should pass null', () => {
+    const value = null
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+  it('Should fail undefined', () => {
+    const value = undefined
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail object', () => {
+    const value = { a: 1 }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail array', () => {
+    const value = [1, 2]
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+})
diff --git a/test/runtime/value/clone/clone.ts b/test/runtime/value/clone/clone.ts
new file mode 100644
index 000000000..4fdcf9e04
--- /dev/null
+++ b/test/runtime/value/clone/clone.ts
@@ -0,0 +1,177 @@
+import { Value } from '@sinclair/typebox/value'
+import { Assert } from '../../assert/index'
+
+describe('value/clone/Clone', () => {
+  // --------------------------------------------
+  // ValueType
+  // --------------------------------------------
+  it('Should clone null', () => {
+    const R = Value.Clone(null)
+    Assert.deepEqual(R, null)
+  })
+
+  it('Should clone undefined', () => {
+    const R = Value.Clone(undefined)
+    Assert.deepEqual(R, undefined)
+  })
+
+  it('Should clone number', () => {
+    const R = Value.Clone(1)
+    Assert.deepEqual(R, 1)
+  })
+
+  it('Should clone bigint', () => {
+    const R = Value.Clone(1n)
+    Assert.deepEqual(R, 1n)
+  })
+
+  it('Should clone boolean', () => {
+    const R = Value.Clone(true)
+    Assert.deepEqual(R, true)
+  })
+
+  it('Should clone string', () => {
+    const R = Value.Clone('hello')
+    Assert.deepEqual(R, 'hello')
+  })
+
+  it('Should clone symbol', () => {
+    const S = Symbol('hello')
+    const R = Value.Clone(S)
+    Assert.deepEqual(R, S)
+  })
+
+  // --------------------------------------------
+  // ObjectType
+  // --------------------------------------------
+
+  it('Should clone object #1', () => {
+    const V = {
+      x: 1,
+      y: 2,
+      z: 3,
+    }
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+
+  it('Should clone object #2', () => {
+    const V = {
+      x: 1,
+      y: 2,
+      z: 3,
+      w: {
+        a: 1,
+        b: 2,
+        c: 3,
+      },
+    }
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+
+  it('Should clone object #3', () => {
+    const V = {
+      x: 1,
+      y: 2,
+      z: 3,
+      w: [0, 1, 2, 3, 4],
+    }
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+  // --------------------------------------------
+  // ArrayType
+  // --------------------------------------------
+  it('Should clone array #1', () => {
+    const V = [1, 2, 3, 4]
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+  it('Should clone array #2', () => {
+    const V = [
+      [1, 2, 3],
+      [1, 2, 3],
+      [1, 2, 3],
+      [1, 2, 3],
+    ]
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+  it('Should clone array #3', () => {
+    const V = [
+      { x: 1, y: 2, z: 3 },
+      { x: 1, y: 2, z: 3 },
+      { x: 1, y: 2, z: 3 },
+      { x: 1, y: 2, z: 3 },
+    ]
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+
+  it('Should clone Int8Array', () => {
+    const V = new Int8Array([1, 2, 3, 4])
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+
+  it('Should clone Uint8Array', () => {
+    const V = new Uint8Array([1, 2, 3, 4])
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+
+  it('Should clone Uint8ClampedArray', () => {
+    const V = new Uint8ClampedArray([1, 2, 3, 4])
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+
+  it('Should clone Int16Array', () => {
+    const V = new Int16Array([1, 2, 3, 4])
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+
+  it('Should clone Uint16Array', () => {
+    const V = new Uint16Array([1, 2, 3, 4])
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+
+  it('Should clone Int32Array', () => {
+    const V = new Int32Array([1, 2, 3, 4])
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+
+  it('Should clone Uint32Array', () => {
+    const V = new Int32Array([1, 2, 3, 4])
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+
+  it('Should clone Float32Array', () => {
+    const V = new Float32Array([1, 2, 3, 4])
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+
+  it('Should clone Float64Array', () => {
+    const V = new Float64Array([1, 2, 3, 4])
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+
+  it('Should clone BigInt64Array', () => {
+    const V = new BigInt64Array([1n, 2n, 3n, 4n])
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+
+  it('Should clone BigUint64Array', () => {
+    const V = new BigUint64Array([1n, 2n, 3n, 4n])
+    const R = Value.Clone(V)
+    Assert.deepEqual(R, V)
+  })
+})
diff --git a/test/runtime/value/clone/index.ts b/test/runtime/value/clone/index.ts
new file mode 100644
index 000000000..cd798158e
--- /dev/null
+++ b/test/runtime/value/clone/index.ts
@@ -0,0 +1 @@
+import './clone'
diff --git a/test/runtime/value/create/any.ts b/test/runtime/value/create/any.ts
new file mode 100644
index 000000000..bbd59d47d
--- /dev/null
+++ b/test/runtime/value/create/any.ts
@@ -0,0 +1,14 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Any', () => {
+  it('Should create value', () => {
+    const T = Type.Any()
+    Assert.deepEqual(Value.Create(T), {})
+  })
+  it('Should create default', () => {
+    const T = Type.Any({ default: 1 })
+    Assert.deepEqual(Value.Create(T), 1)
+  })
+})
diff --git a/test/runtime/value/create/array.ts b/test/runtime/value/create/array.ts
new file mode 100644
index 000000000..1d97755a1
--- /dev/null
+++ b/test/runtime/value/create/array.ts
@@ -0,0 +1,18 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Any', () => {
+  it('Should create value', () => {
+    const T = Type.Array(Type.String())
+    Assert.deepEqual(Value.Create(T), [])
+  })
+  it('Should create default', () => {
+    const T = Type.Array(Type.String(), { default: ['1'] })
+    Assert.deepEqual(Value.Create(T), ['1'])
+  })
+  it('Should create with minItems', () => {
+    const T = Type.Array(Type.String(), { minItems: 4 })
+    Assert.deepEqual(Value.Create(T), ['', '', '', ''])
+  })
+})
diff --git a/test/runtime/value/create/boolean.ts b/test/runtime/value/create/boolean.ts
new file mode 100644
index 000000000..824641724
--- /dev/null
+++ b/test/runtime/value/create/boolean.ts
@@ -0,0 +1,14 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Boolean', () => {
+  it('Should create value', () => {
+    const T = Type.Boolean()
+    Assert.deepEqual(Value.Create(T), false)
+  })
+  it('Should create default', () => {
+    const T = Type.Any({ default: true })
+    Assert.deepEqual(Value.Create(T), true)
+  })
+})
diff --git a/test/runtime/value/create/constructor.ts b/test/runtime/value/create/constructor.ts
new file mode 100644
index 000000000..b4c9b7701
--- /dev/null
+++ b/test/runtime/value/create/constructor.ts
@@ -0,0 +1,38 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Constructor', () => {
+  it('Should create value', () => {
+    const T = Type.Constructor(
+      [],
+      Type.Object({
+        test: Type.Function([], Type.Number({ default: 123 })),
+      }),
+    )
+    const C = Value.Create(T)
+    const I = new C()
+    const R = I.test()
+    Assert.deepEqual(R, 123)
+  })
+
+  it('Should create default', () => {
+    const T = Type.Constructor(
+      [],
+      Type.Object({
+        test: Type.Function([], Type.Number({ default: 123 })),
+      }),
+      {
+        default: class {
+          test() {
+            return 321
+          }
+        },
+      },
+    )
+    const C = Value.Create(T)
+    const I = new C()
+    const R = I.test()
+    Assert.deepEqual(R, 321)
+  })
+})
diff --git a/test/runtime/value/create/enum.ts b/test/runtime/value/create/enum.ts
new file mode 100644
index 000000000..b6dcb55ca
--- /dev/null
+++ b/test/runtime/value/create/enum.ts
@@ -0,0 +1,22 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Boolean', () => {
+  it('Should create value', () => {
+    enum Foo {
+      A,
+      B,
+    }
+    const T = Type.Enum(Foo)
+    Assert.deepEqual(Value.Create(T), Foo.A)
+  })
+  it('Should create default', () => {
+    enum Foo {
+      A,
+      B,
+    }
+    const T = Type.Enum(Foo, { default: Foo.B })
+    Assert.deepEqual(Value.Create(T), Foo.B)
+  })
+})
diff --git a/test/runtime/value/create/function.ts b/test/runtime/value/create/function.ts
new file mode 100644
index 000000000..6315bd203
--- /dev/null
+++ b/test/runtime/value/create/function.ts
@@ -0,0 +1,19 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Function', () => {
+  it('Should create value', () => {
+    const T = Type.Function([], Type.Number({ default: 123 }))
+    const F = Value.Create(T)
+    const R = F()
+    Assert.deepEqual(R, 123)
+  })
+
+  it('Should create default', () => {
+    const T = Type.Function([], Type.Number({ default: 123 }), { default: () => 321 })
+    const F = Value.Create(T)
+    const R = F()
+    Assert.deepEqual(R, 321)
+  })
+})
diff --git a/test/runtime/value/create/index.ts b/test/runtime/value/create/index.ts
new file mode 100644
index 000000000..db38f47ad
--- /dev/null
+++ b/test/runtime/value/create/index.ts
@@ -0,0 +1,24 @@
+import './any'
+import './array'
+import './boolean'
+import './constructor'
+import './enum'
+import './function'
+import './integer'
+import './intersect'
+import './keyof'
+import './literal'
+import './never'
+import './null'
+import './number'
+import './object'
+import './rec'
+import './record'
+import './regex'
+import './string'
+import './tuple'
+import './uint8array'
+import './undefined'
+import './union'
+import './unknown'
+import './void'
diff --git a/test/runtime/value/create/integer.ts b/test/runtime/value/create/integer.ts
new file mode 100644
index 000000000..3643a1f54
--- /dev/null
+++ b/test/runtime/value/create/integer.ts
@@ -0,0 +1,14 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Integer', () => {
+  it('Should create value', () => {
+    const T = Type.Integer()
+    Assert.deepEqual(Value.Create(T), 0)
+  })
+  it('Should create default', () => {
+    const T = Type.Integer({ default: 7 })
+    Assert.deepEqual(Value.Create(T), 7)
+  })
+})
diff --git a/test/runtime/value/create/intersect.ts b/test/runtime/value/create/intersect.ts
new file mode 100644
index 000000000..efa66c5b1
--- /dev/null
+++ b/test/runtime/value/create/intersect.ts
@@ -0,0 +1,66 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Intersect', () => {
+  it('Should create value', () => {
+    const A = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    const B = Type.Object({
+      a: Type.Number(),
+      b: Type.Number(),
+      c: Type.Number(),
+    })
+    const T = Type.Intersect([A, B])
+    Assert.deepEqual(Value.Create(T), {
+      x: 0,
+      y: 0,
+      z: 0,
+      a: 0,
+      b: 0,
+      c: 0,
+    })
+  })
+  it('Should create default', () => {
+    const A = Type.Object({
+      x: Type.Number({ default: 1 }),
+      y: Type.Number({ default: 2 }),
+      z: Type.Number({ default: 3 }),
+    })
+    const B = Type.Object({
+      a: Type.Number({ default: 4 }),
+      b: Type.Number({ default: 5 }),
+      c: Type.Number({ default: 6 }),
+    })
+    const T = Type.Intersect([A, B])
+    Assert.deepEqual(Value.Create(T), {
+      x: 1,
+      y: 2,
+      z: 3,
+      a: 4,
+      b: 5,
+      c: 6,
+    })
+  })
+  it('Should create default and omit optionals', () => {
+    const A = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    const B = Type.Object({
+      a: Type.Optional(Type.Number()),
+      b: Type.Optional(Type.Number()),
+      c: Type.Optional(Type.Number()),
+    })
+    const T = Type.Intersect([A, B])
+    Assert.deepEqual(Value.Create(T), {
+      x: 0,
+      y: 0,
+      z: 0,
+    })
+  })
+})
diff --git a/test/runtime/value/create/keyof.ts b/test/runtime/value/create/keyof.ts
new file mode 100644
index 000000000..6b498bb15
--- /dev/null
+++ b/test/runtime/value/create/keyof.ts
@@ -0,0 +1,25 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/KeyOf', () => {
+  it('Should create value', () => {
+    const T = Type.KeyOf(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+    )
+    Assert.deepEqual(Value.Create(T), 'x')
+  })
+  it('Should create default', () => {
+    const T = Type.KeyOf(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      { default: 'y' },
+    )
+    Assert.deepEqual(Value.Create(T), 'y')
+  })
+})
diff --git a/test/runtime/value/create/literal.ts b/test/runtime/value/create/literal.ts
new file mode 100644
index 000000000..591799b39
--- /dev/null
+++ b/test/runtime/value/create/literal.ts
@@ -0,0 +1,18 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/KeyOf', () => {
+  it('Should create literal string', () => {
+    const T = Type.Literal('hello')
+    Assert.deepEqual(Value.Create(T), 'hello')
+  })
+  it('Should create literal number', () => {
+    const T = Type.Literal(1)
+    Assert.deepEqual(Value.Create(T), 1)
+  })
+  it('Should create literal boolean', () => {
+    const T = Type.Literal(true)
+    Assert.deepEqual(Value.Create(T), true)
+  })
+})
diff --git a/test/runtime/value/create/never.ts b/test/runtime/value/create/never.ts
new file mode 100644
index 000000000..437ff3ef3
--- /dev/null
+++ b/test/runtime/value/create/never.ts
@@ -0,0 +1,10 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Never', () => {
+  it('Should create value', () => {
+    const T = Type.Never()
+    Assert.throws(() => Value.Create(T))
+  })
+})
diff --git a/test/runtime/value/create/null.ts b/test/runtime/value/create/null.ts
new file mode 100644
index 000000000..4b11e6d1a
--- /dev/null
+++ b/test/runtime/value/create/null.ts
@@ -0,0 +1,10 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Null', () => {
+  it('Should create value', () => {
+    const T = Type.Null()
+    Assert.deepEqual(Value.Create(T), null)
+  })
+})
diff --git a/test/runtime/value/create/number.ts b/test/runtime/value/create/number.ts
new file mode 100644
index 000000000..7be03f37d
--- /dev/null
+++ b/test/runtime/value/create/number.ts
@@ -0,0 +1,14 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Number', () => {
+  it('Should create value', () => {
+    const T = Type.Number()
+    Assert.deepEqual(Value.Create(T), 0)
+  })
+  it('Should create default', () => {
+    const T = Type.Number({ default: 7 })
+    Assert.deepEqual(Value.Create(T), 7)
+  })
+})
diff --git a/test/runtime/value/create/object.ts b/test/runtime/value/create/object.ts
new file mode 100644
index 000000000..50b41ee3b
--- /dev/null
+++ b/test/runtime/value/create/object.ts
@@ -0,0 +1,75 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Object', () => {
+  it('Should create value', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    Assert.deepEqual(Value.Create(T), {
+      x: 0,
+      y: 0,
+      z: 0,
+    })
+  })
+
+  it('Should create value with optional properties', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.Number()),
+      y: Type.Optional(Type.Number()),
+      z: Type.Optional(Type.Number()),
+    })
+    Assert.deepEqual(Value.Create(T), {})
+  })
+
+  it('Should create default with default properties', () => {
+    const T = Type.Object({
+      x: Type.Number({ default: 1 }),
+      y: Type.Number({ default: 2 }),
+      z: Type.Number({ default: 3 }),
+    })
+    Assert.deepEqual(Value.Create(T), {
+      x: 1,
+      y: 2,
+      z: 3,
+    })
+  })
+
+  it('Should create nested object', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+      w: Type.Object({
+        x: Type.Number({ default: 7 }),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+    })
+    Assert.deepEqual(Value.Create(T), {
+      x: 0,
+      y: 0,
+      z: 0,
+      w: { x: 7, y: 0, z: 0 },
+    })
+  })
+
+  it('Should create with default', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { default: { x: 1, y: 2, z: 3 } },
+    )
+    Assert.deepEqual(Value.Create(T), {
+      x: 1,
+      y: 2,
+      z: 3,
+    })
+  })
+})
diff --git a/test/runtime/value/create/rec.ts b/test/runtime/value/create/rec.ts
new file mode 100644
index 000000000..070169062
--- /dev/null
+++ b/test/runtime/value/create/rec.ts
@@ -0,0 +1,30 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Recursive', () => {
+  it('Should create value', () => {
+    const T = Type.Recursive((Self) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(Self),
+      }),
+    )
+    Assert.deepEqual(Value.Create(T), {
+      id: '',
+      nodes: [],
+    })
+  })
+
+  it('Should create default', () => {
+    const T = Type.Recursive(
+      (Self) =>
+        Type.Object({
+          id: Type.String(),
+          nodes: Type.Array(Self),
+        }),
+      { default: 7 },
+    )
+    Assert.deepEqual(Value.Create(T), 7)
+  })
+})
diff --git a/test/runtime/value/create/record.ts b/test/runtime/value/create/record.ts
new file mode 100644
index 000000000..c19d8555f
--- /dev/null
+++ b/test/runtime/value/create/record.ts
@@ -0,0 +1,18 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Record', () => {
+  it('Should create value', () => {
+    const T = Type.Record(Type.String(), Type.Object({}))
+    Assert.deepEqual(Value.Create(T), {})
+  })
+  it('Should create default', () => {
+    const T = Type.Record(Type.String(), Type.Object({}), {
+      default: {
+        x: {},
+      },
+    })
+    Assert.deepEqual(Value.Create(T), { x: {} })
+  })
+})
diff --git a/test/runtime/value/create/regex.ts b/test/runtime/value/create/regex.ts
new file mode 100644
index 000000000..78d535a2d
--- /dev/null
+++ b/test/runtime/value/create/regex.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/RegEx', () => {
+  it('Should throw without a default value', () => {
+    Assert.throws(() => {
+      const T = Type.RegEx(/foo/)
+      Value.Create(T)
+    })
+  })
+  it('Should create default', () => {
+    const T = Type.RegEx(/foo/, { default: 'foo' })
+    Assert.deepEqual(Value.Create(T), 'foo')
+  })
+})
diff --git a/test/runtime/value/create/string.ts b/test/runtime/value/create/string.ts
new file mode 100644
index 000000000..d5a7bcd77
--- /dev/null
+++ b/test/runtime/value/create/string.ts
@@ -0,0 +1,14 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/String', () => {
+  it('Should create value', () => {
+    const T = Type.String()
+    Assert.deepEqual(Value.Create(T), 0)
+  })
+  it('Should create default', () => {
+    const T = Type.String({ default: 'hello' })
+    Assert.deepEqual(Value.Create(T), 'hello')
+  })
+})
diff --git a/test/runtime/value/create/tuple.ts b/test/runtime/value/create/tuple.ts
new file mode 100644
index 000000000..f2c91ccdb
--- /dev/null
+++ b/test/runtime/value/create/tuple.ts
@@ -0,0 +1,22 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Tuple', () => {
+  it('Should create value', () => {
+    const T = Type.Tuple([Type.Number(), Type.String()])
+    Assert.deepEqual(Value.Create(T), [0, ''])
+  })
+  it('Should create default', () => {
+    const T = Type.Tuple([Type.Number(), Type.String()], { default: [7, 'hello'] })
+    Assert.deepEqual(Value.Create(T), [7, 'hello'])
+  })
+  it('Should create default elements', () => {
+    const T = Type.Tuple([Type.Number({ default: 7 }), Type.String({ default: 'hello' })])
+    Assert.deepEqual(Value.Create(T), [7, 'hello'])
+  })
+  it('Should create default by overriding elements', () => {
+    const T = Type.Tuple([Type.Number({ default: 7 }), Type.String({ default: 'hello' })], { default: [32, 'world'] })
+    Assert.deepEqual(Value.Create(T), [32, 'world'])
+  })
+})
diff --git a/test/runtime/value/create/uint8array.ts b/test/runtime/value/create/uint8array.ts
new file mode 100644
index 000000000..6effa6d4c
--- /dev/null
+++ b/test/runtime/value/create/uint8array.ts
@@ -0,0 +1,28 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Uint8Array', () => {
+  it('Should create value', () => {
+    const T = Type.Uint8Array()
+    const value = Value.Create(T)
+    Assert.isInstanceOf(value, Uint8Array)
+    Assert.equal(value.length, 0)
+  })
+
+  it('Should create default', () => {
+    const T = Type.Uint8Array({ default: new Uint8Array([0, 1, 2, 3]) })
+    const value = Value.Create(T)
+    Assert.isInstanceOf(value, Uint8Array)
+    Assert.equal(value.length, 4)
+    Assert.deepEqual([value[0], value[1], value[2], value[3]], [0, 1, 2, 3])
+  })
+
+  it('Should create with minByteLength', () => {
+    const T = Type.Uint8Array({ minByteLength: 4 })
+    const value = Value.Create(T)
+    Assert.isInstanceOf(value, Uint8Array)
+    Assert.equal(value.length, 4)
+    Assert.deepEqual([value[0], value[1], value[2], value[3]], [0, 0, 0, 0])
+  })
+})
diff --git a/test/runtime/value/create/undefined.ts b/test/runtime/value/create/undefined.ts
new file mode 100644
index 000000000..45e369ad4
--- /dev/null
+++ b/test/runtime/value/create/undefined.ts
@@ -0,0 +1,10 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Undefined', () => {
+  it('Should create value', () => {
+    const T = Type.Undefined()
+    Assert.deepEqual(Value.Create(T), undefined)
+  })
+})
diff --git a/test/runtime/value/create/union.ts b/test/runtime/value/create/union.ts
new file mode 100644
index 000000000..63e14202f
--- /dev/null
+++ b/test/runtime/value/create/union.ts
@@ -0,0 +1,51 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Union', () => {
+  it('Should create union Object', () => {
+    const A = Type.Object({
+      type: Type.Literal('A'),
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    const B = Type.Object({
+      type: Type.Literal('B'),
+      x: Type.String(),
+      y: Type.String(),
+      z: Type.String(),
+    })
+    const T = Type.Union([A, B])
+    Assert.deepEqual(Value.Create(T), {
+      type: 'A',
+      x: 0,
+      y: 0,
+      z: 0,
+    })
+  })
+
+  it('Should create union Null', () => {
+    const A = Type.Null()
+    const B = Type.Object({
+      type: Type.Literal('B'),
+      x: Type.String(),
+      y: Type.String(),
+      z: Type.String(),
+    })
+    const T = Type.Union([A, B])
+    Assert.deepEqual(Value.Create(T), null)
+  })
+
+  it('Should create union Array', () => {
+    const A = Type.Array(Type.String())
+    const B = Type.Object({
+      type: Type.Literal('B'),
+      x: Type.String(),
+      y: Type.String(),
+      z: Type.String(),
+    })
+    const T = Type.Union([A, B])
+    Assert.deepEqual(Value.Create(T), [])
+  })
+})
diff --git a/test/runtime/value/create/unknown.ts b/test/runtime/value/create/unknown.ts
new file mode 100644
index 000000000..d86946c6c
--- /dev/null
+++ b/test/runtime/value/create/unknown.ts
@@ -0,0 +1,14 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Unknown', () => {
+  it('Should create value', () => {
+    const T = Type.Unknown()
+    Assert.deepEqual(Value.Create(T), {})
+  })
+  it('Should create default', () => {
+    const T = Type.Unknown({ default: 1 })
+    Assert.deepEqual(Value.Create(T), 1)
+  })
+})
diff --git a/test/runtime/value/create/void.ts b/test/runtime/value/create/void.ts
new file mode 100644
index 000000000..eff8379a7
--- /dev/null
+++ b/test/runtime/value/create/void.ts
@@ -0,0 +1,10 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Void', () => {
+  it('Should create value', () => {
+    const T = Type.Void()
+    Assert.deepEqual(Value.Create(T), null)
+  })
+})
diff --git a/test/runtime/value/delta/diff.ts b/test/runtime/value/delta/diff.ts
new file mode 100644
index 000000000..5a86fccb4
--- /dev/null
+++ b/test/runtime/value/delta/diff.ts
@@ -0,0 +1,424 @@
+import { Value, Edit } from '@sinclair/typebox/value'
+import { Assert } from '../../assert/index'
+
+// -----------------------------------------------------------------
+// Diff Factory
+// -----------------------------------------------------------------
+
+function Update(path: string, value: unknown): Edit<unknown> {
+  return { type: 'update', path, value } as any
+}
+
+function Insert(path: string, value: unknown): Edit<unknown> {
+  return { type: 'insert', path, value } as any
+}
+
+function Delete(path: string): Edit<unknown> {
+  return { type: 'delete', path } as any
+}
+
+describe('value/delta/Diff', () => {
+  // ----------------------------------------------------
+  // Null
+  // ----------------------------------------------------
+  it('Should diff NULL null to null', () => {
+    const A = null
+    const B = null
+    const D = Value.Diff(A, B)
+    const E = [] as Edit[]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff NULL undefined to undefined', () => {
+    const A = undefined
+    const B = undefined
+    const D = Value.Diff(A, B)
+    const E = [] as Edit[]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff NULL string to string', () => {
+    const A = 'hello'
+    const B = 'hello'
+    const D = Value.Diff(A, B)
+    const E = [] as Edit[]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff NULL number to number', () => {
+    const A = 1
+    const B = 1
+    const D = Value.Diff(A, B)
+    const E = [] as Edit[]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff NULL boolean to boolean', () => {
+    const A = true
+    const B = true
+    const D = Value.Diff(A, B)
+    const E = [] as Edit[]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff NULL symbol to symbol', () => {
+    const S = Symbol('A')
+    const A = S
+    const B = S
+    const D = Value.Diff(A, B)
+    const E = [] as Edit[]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff NULL object to object', () => {
+    const A = { x: 1, y: 2, z: 3 }
+    const B = { x: 1, y: 2, z: 3 }
+    const D = Value.Diff(A, B)
+    const E = [] as Edit[]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff NULL array to array', () => {
+    const A = [1, 2, 3]
+    const B = [1, 2, 3]
+    const D = Value.Diff(A, B)
+    const E = [] as Edit[]
+    Assert.deepEqual(D, E)
+  })
+
+  // ----------------------------------------------------
+  // Type Change Root
+  // ----------------------------------------------------
+
+  it('Should diff TYPE change number to null', () => {
+    const A = 1
+    const B = null
+    const D = Value.Diff(A, B)
+    const E = [Update('', B)]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff TYPE change null to undefined', () => {
+    const A = null
+    const B = undefined
+    const D = Value.Diff(A, B)
+    const E = [Update('', B)]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff TYPE change null to number', () => {
+    const A = null
+    const B = 1
+    const D = Value.Diff(A, B)
+    const E = [Update('', B)]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff TYPE change null to boolean', () => {
+    const A = null
+    const B = true
+    const D = Value.Diff(A, B)
+    const E = [Update('', B)]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff TYPE change null to string', () => {
+    const A = null
+    const B = 'hello'
+    const D = Value.Diff(A, B)
+    const E = [Update('', B)]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff TYPE change null to symbol', () => {
+    const A = null
+    const B = Symbol('A')
+    const D = Value.Diff(A, B)
+    const E = [Update('', B)]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff TYPE change null to object', () => {
+    const A = null
+    const B = { x: 1, y: 1, z: 1 }
+    const D = Value.Diff(A, B)
+    const E = [Update('', B)]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff TYPE change null to array', () => {
+    const A = null
+    const B = [1, 2, 3]
+    const D = Value.Diff(A, B)
+    const E = [Update('', B)]
+    Assert.deepEqual(D, E)
+  })
+  // ----------------------------------------------------
+  // Value Change Root
+  // ----------------------------------------------------
+
+  it('Should diff VALUE change number', () => {
+    const A = 1
+    const B = 2
+    const D = Value.Diff(A, B)
+    const E = [Update('', B)]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff VALUE change boolean', () => {
+    const A = false
+    const B = true
+    const D = Value.Diff(A, B)
+    const E = [Update('', B)]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff VALUE change string', () => {
+    const A = 'hello'
+    const B = 'world'
+    const D = Value.Diff(A, B)
+    const E = [Update('', B)]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff VALUE change symbol', () => {
+    const A = Symbol('A')
+    const B = Symbol('B')
+    const D = Value.Diff<any>(A, B)
+    const E = [Update('', B)]
+    Assert.deepEqual(D, E)
+  })
+
+  // ----------------------------------------------------
+  // Array
+  // ----------------------------------------------------
+
+  it('Should diff ELEMENT update', () => {
+    const A = [1, 2, 3, 4]
+    const B = [1, 2, 3, 9]
+    const D = Value.Diff(A, B)
+    const E = [Update('/3', 9)]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff ELEMENT push', () => {
+    const A = [1, 2, 3, 4]
+    const B = [1, 2, 3, 4, 5]
+    const D = Value.Diff(A, B)
+    const E = [Insert('/4', 5)]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff ELEMENT push twice', () => {
+    const A = [1, 2, 3, 4]
+    const B = [1, 2, 3, 4, 5, 6]
+    const D = Value.Diff(A, B)
+    const E = [Insert('/4', 5), Insert('/5', 6)]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff ELEMENT pop', () => {
+    const A = [1, 2, 3, 4]
+    const B = [1, 2, 3]
+    const D = Value.Diff(A, B)
+    const E = [Delete('/3')]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff ELEMENT pop twice', () => {
+    const A = [1, 2, 3, 4]
+    const B = [1, 2]
+    const D = Value.Diff(A, B)
+    const E = [Delete('/3'), Delete('/2')]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff ELEMENT unshift', () => {
+    const A = [1, 2, 3, 4]
+    const B = [2, 3, 4]
+    const D = Value.Diff(A, B)
+    const E = [Update('/0', 2), Update('/1', 3), Update('/2', 4), Delete('/3')]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff ELEMENT unshift twice', () => {
+    const A = [1, 2, 3, 4]
+    const B = [3, 4]
+    const D = Value.Diff(A, B)
+    const E = [Update('/0', 3), Update('/1', 4), Delete('/3'), Delete('/2')]
+    Assert.deepEqual(D, E)
+  })
+
+  // ----------------------------------------------------
+  // Object
+  // ----------------------------------------------------
+
+  it('Should diff PROPERTY insert', () => {
+    const A = { x: 1, y: 1 }
+    const B = { x: 1, y: 1, z: 1 }
+    const D = Value.Diff(A, B)
+    const E = [Insert('/z', 1)]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff PROPERTY delete', () => {
+    const A = { x: 1, y: 1, z: 1 }
+    const B = { x: 1, y: 1 }
+    const D = Value.Diff(A, B)
+    const E = [Delete('/z')]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff PROPERTY update', () => {
+    const A = { x: 1, y: 1, z: 1 }
+    const B = { x: 1, y: 1, z: 2 }
+    const D = Value.Diff(A, B)
+    const E = [Update('/z', 2)]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff PROPERTY all values', () => {
+    const A = { x: 1, y: 1, z: 1 }
+    const B = { x: 2, y: 2, z: 2 }
+    const D = Value.Diff(A, B)
+    const E = [Update('/x', 2), Update('/y', 2), Update('/z', 2)]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff PROPERTY all delete, all insert', () => {
+    const A = { x: 1, y: 1, z: 1 }
+    const B = { a: 2, b: 2, c: 2 }
+    const D = Value.Diff<any>(A, B)
+    const E = [Insert('/a', 2), Insert('/b', 2), Insert('/c', 2), Delete('/z'), Delete('/y'), Delete('/x')]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff PROPERTY update, insert and delete order preserved', () => {
+    const A = { x: 1, y: 1, z: 1, w: 1 }
+    const B = { a: 2, b: 2, c: 2, w: 2 }
+    const D = Value.Diff<any>(A, B)
+    const E = [Update('/w', 2), Insert('/a', 2), Insert('/b', 2), Insert('/c', 2), Delete('/z'), Delete('/y'), Delete('/x')]
+    Assert.deepEqual(D, E)
+  })
+
+  // ----------------------------------------------------
+  // Object Nested
+  // ----------------------------------------------------
+
+  it('Should diff NESTED OBJECT diff type change update', () => {
+    const A = { v: 1 }
+    const B = { v: { x: 1, y: 1, z: 1 } }
+    const D = Value.Diff<any>(A, B)
+    const E = [Update('/v', B.v)]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff NESTED OBJECT diff value change update', () => {
+    const A = { v: 1 }
+    const B = { v: 2 }
+    const D = Value.Diff(A, B)
+    const E = [Update('/v', B.v)]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff NESTED OBJECT diff partial property update', () => {
+    const A = { v: { x: 1, y: 1, z: 1 } }
+    const B = { v: { x: 2, y: 2, z: 2 } }
+    const D = Value.Diff(A, B)
+    const E = [Update('/v/x', B.v.x), Update('/v/y', B.v.y), Update('/v/z', B.v.z)]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff NESTED OBJECT diff partial property insert', () => {
+    const A = { v: { x: 1, y: 1, z: 1 } }
+    const B = { v: { x: 1, y: 1, z: 1, w: 1 } }
+    const D = Value.Diff(A, B)
+    const E = [Insert('/v/w', B.v.w)]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff NESTED OBJECT diff partial property delete', () => {
+    const A = { v: { x: 1, y: 1, z: 1 } }
+    const B = { v: { x: 1, y: 1 } }
+    const D = Value.Diff(A, B)
+    const E = [Delete('/v/z')]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff NESTED OBJECT ordered diff - update, insert and delete', () => {
+    const A = { v: { x: 1, y: 1 } }
+    const B = { v: { x: 2, w: 2 } }
+    const D = Value.Diff<any>(A, B)
+    const E = [Update('/v/x', B.v.x), Insert('/v/w', B.v.w), Delete('/v/y')]
+    Assert.deepEqual(D, E)
+  })
+
+  // ----------------------------------------------------
+  // Array Nested
+  // ----------------------------------------------------
+
+  it('Should diff NESTED ARRAY object diff type change update', () => {
+    const A = [{ v: 1 }]
+    const B = [{ v: { x: 1, y: 1, z: 1 } }]
+    const D = Value.Diff<any>(A, B)
+    const E = [Update('/0/v', B[0].v)]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff NESTED ARRAY object diff value change update', () => {
+    const A = [{ v: 1 }]
+    const B = [{ v: 2 }]
+    const D = Value.Diff(A, B)
+    const E = [Update('/0/v', B[0].v)]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff NESTED ARRAY object diff partial property update', () => {
+    const A = [{ v: { x: 1, y: 1, z: 1 } }]
+    const B = [{ v: { x: 2, y: 2, z: 2 } }]
+    const D = Value.Diff(A, B)
+    const E = [Update('/0/v/x', B[0].v.x), Update('/0/v/y', B[0].v.y), Update('/0/v/z', B[0].v.z)]
+    Assert.deepEqual(D, E)
+  })
+  it('Should diff NESTED ARRAY object diff partial property insert', () => {
+    const A = [{ v: { x: 1, y: 1, z: 1 } }]
+    const B = [{ v: { x: 1, y: 1, z: 1, w: 1 } }]
+    const D = Value.Diff(A, B)
+    const E = [Insert('/0/v/w', B[0].v.w)]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff NESTED ARRAY object diff partial property delete', () => {
+    const A = [{ v: { x: 1, y: 1, z: 1 } }]
+    const B = [{ v: { x: 1, y: 1 } }]
+    const D = Value.Diff(A, B)
+    const E = [Delete('/0/v/z')]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff NESTED ARRAY update, insert and delete order preserved', () => {
+    const A = [{ v: { x: 1, y: 1 } }]
+    const B = [{ v: { x: 2, w: 2 } }]
+    const D = Value.Diff<any>(A, B)
+    const E = [Update('/0/v/x', B[0].v.x), Insert('/0/v/w', B[0].v.w), Delete('/0/v/y')]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should throw if attempting to diff a current value with symbol key', () => {
+    const A = [{ [Symbol('A')]: 1, v: { x: 1, y: 1 } }]
+    const B = [{ v: { x: 2, w: 2 } }]
+    Assert.throws(() => Value.Diff<any>(A, B))
+  })
+
+  it('Should throw if attempting to diff a next value with symbol key', () => {
+    const A = [{ v: { x: 1, y: 1 } }]
+    const B = [{ [Symbol('A')]: 1, v: { x: 2, w: 2 } }]
+    Assert.throws(() => Value.Diff<any>(A, B))
+  })
+
+  it('Should diff a Uint8Array (same size)', () => {
+    const A = new Uint8Array([0, 1, 2, 3])
+    const B = new Uint8Array([0, 9, 2, 9])
+    const D = Value.Diff(A, B)
+    const E = [Update('/1', 9), Update('/3', 9)]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff a Uint8Array (less than requires full update)', () => {
+    const A = new Uint8Array([0, 1, 2, 3])
+    const B = new Uint8Array([0, 9, 2])
+    const D = Value.Diff(A, B)
+    const E = [Update('', new Uint8Array([0, 9, 2]))]
+    Assert.deepEqual(D, E)
+  })
+
+  it('Should diff a Uint8Array (greater than requires full update)', () => {
+    const A = new Uint8Array([0, 1, 2, 3])
+    const B = new Uint8Array([0, 9, 2, 3, 4])
+    const D = Value.Diff(A, B)
+    const E = [Update('', new Uint8Array([0, 9, 2, 3, 4]))]
+    Assert.deepEqual(D, E)
+  })
+})
diff --git a/test/runtime/value/delta/index.ts b/test/runtime/value/delta/index.ts
new file mode 100644
index 000000000..10b4755d9
--- /dev/null
+++ b/test/runtime/value/delta/index.ts
@@ -0,0 +1,2 @@
+import './diff'
+import './patch'
diff --git a/test/runtime/value/delta/patch.ts b/test/runtime/value/delta/patch.ts
new file mode 100644
index 000000000..62a0c50e1
--- /dev/null
+++ b/test/runtime/value/delta/patch.ts
@@ -0,0 +1,447 @@
+import { Value } from '@sinclair/typebox/value'
+import { Assert } from '../../assert/index'
+
+describe('value/delta/Patch', () => {
+  // ----------------------------------------------------
+  // Null
+  // ----------------------------------------------------
+  it('Should patch NULL null to null', () => {
+    const A = null
+    const B = null
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch NULL undefined to undefined', () => {
+    const A = undefined
+    const B = undefined
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch NULL string to string', () => {
+    const A = 'hello'
+    const B = 'hello'
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch NULL number to number', () => {
+    const A = 1
+    const B = 1
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch NULL boolean to boolean', () => {
+    const A = true
+    const B = true
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch NULL symbol to symbol', () => {
+    const S = Symbol('A')
+    const A = S
+    const B = S
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch NULL object to object', () => {
+    const A = { x: 1, y: 2, z: 3 }
+    const B = { x: 1, y: 2, z: 3 }
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch NULL array to array', () => {
+    const A = [1, 2, 3]
+    const B = [1, 2, 3]
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  // ----------------------------------------------------
+  // Type Change Root
+  // ----------------------------------------------------
+
+  it('Should patch TYPE change number to null', () => {
+    const A = 1
+    const B = null
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch TYPE change null to undefined', () => {
+    const A = null
+    const B = undefined
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch TYPE change null to number', () => {
+    const A = null
+    const B = 1
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch TYPE change null to boolean', () => {
+    const A = null
+    const B = true
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch TYPE change null to string', () => {
+    const A = null
+    const B = 'hello'
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch TYPE change null to symbol', () => {
+    const A = null
+    const B = Symbol('A')
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch TYPE change null to object', () => {
+    const A = null
+    const B = { x: 1, y: 1, z: 1 }
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch TYPE change null to array', () => {
+    const A = null
+    const B = [1, 2, 3]
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch TYPE change object to array', () => {
+    const A = { x: 1, y: 2 }
+    const B = [1, 2, 3]
+    const D = Value.Diff<any>(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch TYPE change array to object', () => {
+    const A = [1, 2, 3]
+    const B = { x: 1, y: 2 }
+    const D = Value.Diff<any>(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  // ----------------------------------------------------
+  // Value Change Root
+  // ----------------------------------------------------
+
+  it('Should patch VALUE change number', () => {
+    const A = 1
+    const B = 2
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch VALUE change boolean', () => {
+    const A = false
+    const B = true
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch VALUE change string', () => {
+    const A = 'hello'
+    const B = 'world'
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch VALUE change symbol', () => {
+    const A = Symbol('A')
+    const B = Symbol('B')
+    const D = Value.Diff<any>(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  // ----------------------------------------------------
+  // Array
+  // ----------------------------------------------------
+
+  it('Should patch ELEMENT update', () => {
+    const A = [1, 2, 3, 4]
+    const B = [1, 2, 3, 9]
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch ELEMENT push', () => {
+    const A = [1, 2, 3, 4]
+    const B = [1, 2, 3, 4, 5]
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch ELEMENT push twice', () => {
+    const A = [1, 2, 3, 4]
+    const B = [1, 2, 3, 4, 5, 6]
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch ELEMENT pop', () => {
+    const A = [1, 2, 3, 4]
+    const B = [1, 2, 3]
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch ELEMENT pop twice', () => {
+    const A = [1, 2, 3, 4]
+    const B = [1, 2]
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch ELEMENT unshift', () => {
+    const A = [1, 2, 3, 4]
+    const B = [2, 3, 4]
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch ELEMENT unshift twice', () => {
+    const A = [1, 2, 3, 4]
+    const B = [3, 4]
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  // ----------------------------------------------------
+  // Object
+  // ----------------------------------------------------
+
+  it('Should patch PROPERTY insert', () => {
+    const A = { x: 1, y: 1 }
+    const B = { x: 1, y: 1, z: 1 }
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch PROPERTY delete', () => {
+    const A = { x: 1, y: 1, z: 1 }
+    const B = { x: 1, y: 1 }
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch PROPERTY update', () => {
+    const A = { x: 1, y: 1, z: 1 }
+    const B = { x: 1, y: 1, z: 2 }
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch PROPERTY all values', () => {
+    const A = { x: 1, y: 1, z: 1 }
+    const B = { x: 2, y: 2, z: 2 }
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch PROPERTY all delete, all insert', () => {
+    const A = { x: 1, y: 1, z: 1 }
+    const B = { a: 2, b: 2, c: 2 }
+    const D = Value.Diff<any>(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch PROPERTY update, insert and delete order preserved', () => {
+    const A = { x: 1, y: 1, z: 1, w: 1 }
+    const B = { a: 2, b: 2, c: 2, w: 2 }
+    const D = Value.Diff<any>(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  // ----------------------------------------------------
+  // Object Nested
+  // ----------------------------------------------------
+
+  it('Should patch NESTED OBJECT diff type change update', () => {
+    const A = { v: 1 }
+    const B = { v: { x: 1, y: 1, z: 1 } }
+    const D = Value.Diff<any>(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch NESTED OBJECT diff value change update', () => {
+    const A = { v: 1 }
+    const B = { v: 2 }
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch NESTED OBJECT diff partial property update', () => {
+    const A = { v: { x: 1, y: 1, z: 1 } }
+    const B = { v: { x: 2, y: 2, z: 2 } }
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch NESTED OBJECT update, insert and delete order preserved', () => {
+    const A = { v: { x: 1, y: 1 } }
+    const B = { v: { x: 2, w: 2 } }
+    const D = Value.Diff<any>(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  // ----------------------------------------------------
+  // Array Nested
+  // ----------------------------------------------------
+
+  it('Should patch NESTED ARRAY object diff type change update', () => {
+    const A = [{ v: 1 }]
+    const B = [{ v: { x: 1, y: 1, z: 1 } }]
+    const D = Value.Diff<any>(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch NESTED ARRAY object diff value change update', () => {
+    const A = [{ v: 1 }]
+    const B = [{ v: 2 }]
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch NESTED ARRAY object diff partial property update', () => {
+    const A = [{ v: { x: 1, y: 1, z: 1 } }]
+    const B = [{ v: { x: 2, y: 2, z: 2 } }]
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  it('Should patch NESTED ARRAY object diff partial property insert', () => {
+    const A = [{ v: { x: 1, y: 1, z: 1 } }]
+    const B = [{ v: { x: 1, y: 1, z: 1, w: 1 } }]
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch NESTED ARRAY object diff partial property delete', () => {
+    const A = [{ v: { x: 1, y: 1, z: 1 } }]
+    const B = [{ v: { x: 1, y: 1 } }]
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch NESTED ARRAY object ordered diff - update, insert and delete', () => {
+    const A = [{ v: { x: 1, y: 1 } }]
+    const B = [{ v: { x: 2, w: 2 } }]
+    const D = Value.Diff<any>(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch Uint8Array (same size)', () => {
+    const A = [{ v: new Uint8Array([0, 1, 3]) }]
+    const B = [{ v: new Uint8Array([0, 1, 2]) }]
+    const D = Value.Diff<any>(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch Uint8Array (less than size)', () => {
+    const A = [{ v: new Uint8Array([0, 1, 3]) }]
+    const B = [{ v: new Uint8Array([0, 1]) }]
+    const D = Value.Diff<any>(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+
+  it('Should patch Uint8Array (greater than size)', () => {
+    const A = [{ v: new Uint8Array([0, 1, 3]) }]
+    const B = [{ v: new Uint8Array([0, 1, 2, 4]) }]
+    const D = Value.Diff<any>(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+  // ----------------------------------------------------
+  // Mega Values
+  // ----------------------------------------------------
+
+  it('Should patch MEGA value', () => {
+    const A = [
+      { a: { x: 1, y: 1 } },
+      { b: { x: 1, y: 1, z: ['hello', 1, 2] } },
+      { c: { x: 1, y: 1 } },
+      {
+        d: [
+          { a: 1 },
+          { a: 1 },
+          { a: 1 },
+          [
+            { a: { x: 1, y: 1 } },
+            { b: { x: 1, y: 1, z: ['hello', true, true, 2] } },
+            { c: { x: 1, y: 1 } },
+            {
+              d: [{ a: 1 }, { a: 1 }, { a: 1 }],
+            },
+          ],
+        ],
+      },
+    ]
+    const B = [
+      1,
+      2,
+      { a: { x: 1, y: 'a' } },
+      { b: { x: true, y: 1, z: ['hello', true, true] } },
+      { c: { x: 1, y: 1 } },
+      {
+        d: [
+          { a: 'hello' },
+          1,
+          2,
+          { a: 1 },
+          { a: 1 },
+          [
+            { a: { x: 1, y: 1 }, x: [1, 2, 3, 4] },
+            { c: { x: 1, y: 1 } },
+            {
+              d: [{ a: 1 }, { a: 2 }, 'hello'],
+            },
+          ],
+        ],
+      },
+    ]
+    const D = Value.Diff<any>(A, B)
+    const P = Value.Patch(A, D)
+    Assert.deepEqual(B, P)
+  })
+})
diff --git a/test/runtime/value/equal/equal.ts b/test/runtime/value/equal/equal.ts
new file mode 100644
index 000000000..b02583e6e
--- /dev/null
+++ b/test/runtime/value/equal/equal.ts
@@ -0,0 +1,111 @@
+import { Value } from '@sinclair/typebox/value'
+import { Assert } from '../../assert/index'
+
+describe('value/equal/Equal', () => {
+  it('Should equal null value', () => {
+    const R = Value.Equal(null, null)
+    Assert.deepEqual(R, true)
+  })
+
+  it('Should not equal null value', () => {
+    const R = Value.Equal(null, 'null')
+    Assert.deepEqual(R, false)
+  })
+
+  it('Should equal undefined value', () => {
+    const R = Value.Equal(undefined, undefined)
+    Assert.deepEqual(R, true)
+  })
+
+  it('Should not equal undefined value', () => {
+    const R = Value.Equal(undefined, 'undefined')
+    Assert.deepEqual(R, false)
+  })
+
+  it('Should equal symbol value', () => {
+    const S1 = Symbol.for('test')
+    const S2 = Symbol.for('test')
+    const R = Value.Equal(S1, S2)
+    Assert.deepEqual(R, true)
+  })
+
+  it('Should not equal symbol value', () => {
+    const S1 = Symbol('test')
+    const S2 = Symbol('test')
+    const R = Value.Equal(S1, S2)
+    Assert.deepEqual(R, false)
+  })
+
+  it('Should equal string value', () => {
+    const R = Value.Equal('hello', 'hello')
+    Assert.deepEqual(R, true)
+  })
+  it('Should not equal string value', () => {
+    const R = Value.Equal('hello', 'world')
+    Assert.deepEqual(R, false)
+  })
+
+  it('Should equal number value', () => {
+    const R = Value.Equal(1, 1)
+    Assert.deepEqual(R, true)
+  })
+
+  it('Should not equal number value', () => {
+    const R = Value.Equal(1, 2)
+    Assert.deepEqual(R, false)
+  })
+
+  it('Should equal boolean value', () => {
+    const R = Value.Equal(true, true)
+    Assert.deepEqual(R, true)
+  })
+
+  it('Should not equal boolean value', () => {
+    const R = Value.Equal(true, false)
+    Assert.deepEqual(R, false)
+  })
+
+  it('Should equal array value', () => {
+    const R = Value.Equal([0, 1, 2], [0, 1, 2])
+    Assert.deepEqual(R, true)
+  })
+
+  it('Should not equal array value', () => {
+    const R = Value.Equal([0, 1, 2], [0, 1, 3])
+    Assert.deepEqual(R, false)
+  })
+
+  it('Should not equal array value with additional elements', () => {
+    const R = Value.Equal([0, 1, 2], [0, 1, 2, 3])
+    Assert.deepEqual(R, false)
+  })
+
+  it('Should equal object value', () => {
+    const R = Value.Equal({ x: 1, y: 2, z: 3 }, { x: 1, y: 2, z: 3 })
+    Assert.deepEqual(R, true)
+  })
+
+  it('Should not equal object value', () => {
+    const R = Value.Equal({ x: 1, y: 2, z: 3 }, { x: 1, y: 2, z: 4 })
+    Assert.deepEqual(R, false)
+  })
+
+  it('Should not equal object value with additional properties', () => {
+    const R = Value.Equal({ x: 1, y: 2, z: 3 }, { x: 1, y: 2, z: 3, w: 1 })
+    Assert.deepEqual(R, false)
+  })
+
+  it('Should equal typed array value', () => {
+    const R = Value.Equal(new Uint8Array([0, 1, 2]), new Uint8Array([0, 1, 2]))
+    Assert.deepEqual(R, true)
+  })
+
+  it('Should not equal typed array value', () => {
+    const R = Value.Equal(new Uint8Array([0, 1, 2]), new Uint8Array([0, 1, 3]))
+    Assert.deepEqual(R, false)
+  })
+  it('Should not equal typed array value with varying type', () => {
+    const R = Value.Equal(new Uint8Array([0, 1, 2]), new Int8Array([0, 1, 2]))
+    Assert.deepEqual(R, false)
+  })
+})
diff --git a/test/runtime/value/equal/index.ts b/test/runtime/value/equal/index.ts
new file mode 100644
index 000000000..8175d94d7
--- /dev/null
+++ b/test/runtime/value/equal/index.ts
@@ -0,0 +1 @@
+import './equal'
diff --git a/test/runtime/value/index.ts b/test/runtime/value/index.ts
new file mode 100644
index 000000000..2ca9e7172
--- /dev/null
+++ b/test/runtime/value/index.ts
@@ -0,0 +1,7 @@
+import './cast'
+import './check'
+import './clone'
+import './create'
+import './delta'
+import './equal'
+import './pointer'
diff --git a/test/runtime/value/pointer/index.ts b/test/runtime/value/pointer/index.ts
new file mode 100644
index 000000000..a4004f3be
--- /dev/null
+++ b/test/runtime/value/pointer/index.ts
@@ -0,0 +1 @@
+import './pointer'
diff --git a/test/runtime/value/pointer/pointer.ts b/test/runtime/value/pointer/pointer.ts
new file mode 100644
index 000000000..a3854baa6
--- /dev/null
+++ b/test/runtime/value/pointer/pointer.ts
@@ -0,0 +1,397 @@
+import { ValuePointer } from '@sinclair/typebox/value'
+import { Assert } from '../../assert/index'
+
+describe('value/pointer/Pointer', () => {
+  //-----------------------------------------------
+  // Format
+  //-----------------------------------------------
+
+  it('Should produce correct format #1', () => {
+    const R = [...ValuePointer.Format('')]
+    Assert.deepEqual(R, [])
+  })
+
+  it('Should produce correct format #2', () => {
+    const R = [...ValuePointer.Format('a')]
+    Assert.deepEqual(R, ['a'])
+  })
+
+  it('Should produce correct format #3', () => {
+    const R = [...ValuePointer.Format('/')]
+    Assert.deepEqual(R, [''])
+  })
+
+  it('Should produce correct format #4', () => {
+    const R = [...ValuePointer.Format('/x')]
+    Assert.deepEqual(R, ['x'])
+  })
+
+  it('Should produce correct format #5', () => {
+    const R = [...ValuePointer.Format('/x/')]
+    Assert.deepEqual(R, ['x', ''])
+  })
+
+  it('Should produce correct format #6', () => {
+    const R = [...ValuePointer.Format('/x//')]
+    Assert.deepEqual(R, ['x', '', ''])
+  })
+
+  it('Should produce correct format #7', () => {
+    const R = [...ValuePointer.Format('/x//y')]
+    Assert.deepEqual(R, ['x', '', 'y'])
+  })
+
+  it('Should produce correct format #8', () => {
+    const R = [...ValuePointer.Format('/x//y/')]
+    Assert.deepEqual(R, ['x', '', 'y', ''])
+  })
+
+  it('Should produce correct format #9', () => {
+    const R = [...ValuePointer.Format('/x/~0')]
+    Assert.deepEqual(R, ['x', '~'])
+  })
+
+  it('Should produce correct format #10', () => {
+    const R = [...ValuePointer.Format('/x/~1')]
+    Assert.deepEqual(R, ['x', '/'])
+  })
+
+  it('Should produce correct format #11', () => {
+    const R = [...ValuePointer.Format('/x/~0/')]
+    Assert.deepEqual(R, ['x', '~', ''])
+  })
+
+  it('Should produce correct format #12', () => {
+    const R = [...ValuePointer.Format('/x/~1/')]
+    Assert.deepEqual(R, ['x', '/', ''])
+  })
+
+  it('Should produce correct format #13', () => {
+    const R = [...ValuePointer.Format('/x/a~0b')]
+    Assert.deepEqual(R, ['x', 'a~b'])
+  })
+
+  it('Should produce correct format #14', () => {
+    const R = [...ValuePointer.Format('/x/a~1b')]
+    Assert.deepEqual(R, ['x', 'a/b'])
+  })
+
+  it('Should produce correct format #15', () => {
+    const R = [...ValuePointer.Format('/x/a~0b/')]
+    Assert.deepEqual(R, ['x', 'a~b', ''])
+  })
+
+  it('Should produce correct format #16', () => {
+    const R = [...ValuePointer.Format('/x/a~1b/')]
+    Assert.deepEqual(R, ['x', 'a/b', ''])
+  })
+
+  it('Should produce correct format #17', () => {
+    const R = [...ValuePointer.Format('/x/a~0b///y')]
+    Assert.deepEqual(R, ['x', 'a~b', '', '', 'y'])
+  })
+
+  it('Should produce correct format #18', () => {
+    const R = [...ValuePointer.Format('/x/a~1b///y')]
+    Assert.deepEqual(R, ['x', 'a/b', '', '', 'y'])
+  })
+
+  it('Should produce correct format #19', () => {
+    const R = [...ValuePointer.Format('/x/a~0b///')]
+    Assert.deepEqual(R, ['x', 'a~b', '', '', ''])
+  })
+
+  it('Should produce correct format #20', () => {
+    const R = [...ValuePointer.Format('/x/a~1b///')]
+    Assert.deepEqual(R, ['x', 'a/b', '', '', ''])
+  })
+
+  //-----------------------------------------------
+  // Get
+  //-----------------------------------------------
+
+  it('Should get array #1', () => {
+    const V = [0, 1, 2, 3]
+    Assert.deepEqual(ValuePointer.Get(V, ''), [0, 1, 2, 3])
+    Assert.deepEqual(ValuePointer.Get(V, '/'), undefined)
+    Assert.deepEqual(ValuePointer.Get(V, '/0'), 0)
+    Assert.deepEqual(ValuePointer.Get(V, '/1'), 1)
+    Assert.deepEqual(ValuePointer.Get(V, '/2'), 2)
+    Assert.deepEqual(ValuePointer.Get(V, '/3'), 3)
+  })
+
+  it('Should get array #2', () => {
+    const V = [{ x: 0 }, { x: 1 }, { x: 2 }, { x: 3 }]
+    Assert.deepEqual(ValuePointer.Get(V, ''), [{ x: 0 }, { x: 1 }, { x: 2 }, { x: 3 }])
+    Assert.deepEqual(ValuePointer.Get(V, '/'), undefined)
+    Assert.deepEqual(ValuePointer.Get(V, '/0'), { x: 0 })
+    Assert.deepEqual(ValuePointer.Get(V, '/1'), { x: 1 })
+    Assert.deepEqual(ValuePointer.Get(V, '/2'), { x: 2 })
+    Assert.deepEqual(ValuePointer.Get(V, '/3'), { x: 3 })
+    Assert.deepEqual(ValuePointer.Get(V, '/0/x'), 0)
+    Assert.deepEqual(ValuePointer.Get(V, '/1/x'), 1)
+    Assert.deepEqual(ValuePointer.Get(V, '/2/x'), 2)
+    Assert.deepEqual(ValuePointer.Get(V, '/3/x'), 3)
+  })
+
+  it('Should get object #1', () => {
+    const V = { x: 0, y: 1, z: 2 }
+    Assert.deepEqual(ValuePointer.Get(V, ''), { x: 0, y: 1, z: 2 })
+    Assert.deepEqual(ValuePointer.Get(V, '/'), undefined)
+    Assert.deepEqual(ValuePointer.Get(V, '/x'), 0)
+    Assert.deepEqual(ValuePointer.Get(V, '/y'), 1)
+    Assert.deepEqual(ValuePointer.Get(V, '/z'), 2)
+  })
+
+  it('Should get object #2', () => {
+    const V = { x: { x: 0 }, y: { x: 1 }, z: { x: 2 } }
+    Assert.deepEqual(ValuePointer.Get(V, ''), { x: { x: 0 }, y: { x: 1 }, z: { x: 2 } })
+    Assert.deepEqual(ValuePointer.Get(V, '/'), undefined)
+    Assert.deepEqual(ValuePointer.Get(V, '/x'), { x: 0 })
+    Assert.deepEqual(ValuePointer.Get(V, '/y'), { x: 1 })
+    Assert.deepEqual(ValuePointer.Get(V, '/z'), { x: 2 })
+  })
+
+  it('Should get object #3', () => {
+    const V = { '': { x: -1 }, x: { '': { x: 1 } }, y: { '': { x: 2 } }, z: { '': { x: 3 } } }
+    Assert.deepEqual(ValuePointer.Get(V, ''), { '': { x: -1 }, x: { '': { x: 1 } }, y: { '': { x: 2 } }, z: { '': { x: 3 } } })
+    Assert.deepEqual(ValuePointer.Get(V, '/'), { x: -1 })
+    Assert.deepEqual(ValuePointer.Get(V, '/x'), { '': { x: 1 } })
+    Assert.deepEqual(ValuePointer.Get(V, '/y'), { '': { x: 2 } })
+    Assert.deepEqual(ValuePointer.Get(V, '/z'), { '': { x: 3 } })
+    Assert.deepEqual(ValuePointer.Get(V, '/x/'), { x: 1 })
+    Assert.deepEqual(ValuePointer.Get(V, '/y/'), { x: 2 })
+    Assert.deepEqual(ValuePointer.Get(V, '/z/'), { x: 3 })
+    Assert.deepEqual(ValuePointer.Get(V, '/x//x'), 1)
+    Assert.deepEqual(ValuePointer.Get(V, '/y//x'), 2)
+    Assert.deepEqual(ValuePointer.Get(V, '/z//x'), 3)
+  })
+
+  //-----------------------------------------------
+  // Has
+  //-----------------------------------------------
+
+  it('Should return has true for undefined', () => {
+    const V = undefined
+    Assert.deepEqual(ValuePointer.Has(V, ''), true)
+  })
+
+  it('Should return has true for null', () => {
+    const V = null
+    Assert.deepEqual(ValuePointer.Has(V, ''), true)
+  })
+
+  it('Should return has true for object', () => {
+    const V = {}
+    Assert.deepEqual(ValuePointer.Has(V, ''), true)
+  })
+
+  it('Should return has true for array', () => {
+    const V: any[] = []
+    Assert.deepEqual(ValuePointer.Has(V, ''), true)
+  })
+
+  it('Should return has true for string', () => {
+    const V = 'hello'
+    Assert.deepEqual(ValuePointer.Has(V, ''), true)
+  })
+
+  it('Should return has true for number', () => {
+    const V = 42
+    Assert.deepEqual(ValuePointer.Has(V, ''), true)
+  })
+
+  it('Should return has true for boolean', () => {
+    const V = false
+    Assert.deepEqual(ValuePointer.Has(V, ''), true)
+  })
+
+  it('Should return has true for deeply nested', () => {
+    const V = {
+      '': { x: { y: { z: 1 } } },
+      x: 1,
+      y: { x: 1 },
+      z: [{ x: 1 }, { y: 1 }],
+      w: undefined,
+      n: null,
+    }
+    // exists
+    Assert.deepEqual(ValuePointer.Has(V, ''), true)
+    Assert.deepEqual(ValuePointer.Has(V, '/'), true)
+    Assert.deepEqual(ValuePointer.Has(V, '//x'), true)
+    Assert.deepEqual(ValuePointer.Has(V, '//x/y'), true)
+    Assert.deepEqual(ValuePointer.Has(V, '//x/y/z'), true)
+    Assert.deepEqual(ValuePointer.Has(V, '/x'), true)
+    Assert.deepEqual(ValuePointer.Has(V, '/y/x'), true)
+    Assert.deepEqual(ValuePointer.Has(V, '/z'), true)
+    Assert.deepEqual(ValuePointer.Has(V, '/z/0'), true)
+    Assert.deepEqual(ValuePointer.Has(V, '/z/0/x'), true)
+    Assert.deepEqual(ValuePointer.Has(V, '/z/1'), true)
+    Assert.deepEqual(ValuePointer.Has(V, '/z/1/y'), true)
+    Assert.deepEqual(ValuePointer.Has(V, '/x'), true)
+    Assert.deepEqual(ValuePointer.Has(V, '/n'), true)
+  })
+
+  //-----------------------------------------------
+  // Set
+  //-----------------------------------------------
+
+  it('Should throw when setting root', () => {
+    const V = {}
+    Assert.throws(() => ValuePointer.Set(V, '', { x: 1 }))
+  })
+
+  it('Should set array values', () => {
+    const V = [0, 1, 2]
+    ValuePointer.Set(V, '/0', 3)
+    ValuePointer.Set(V, '/1', 4)
+    ValuePointer.Set(V, '/2', 5)
+    Assert.deepEqual(V, [3, 4, 5])
+  })
+
+  it('Should set object values', () => {
+    const V = { x: 0, y: 1, z: 2 }
+    ValuePointer.Set(V, '/x', 3)
+    ValuePointer.Set(V, '/y', 4)
+    ValuePointer.Set(V, '/z', 5)
+    Assert.deepEqual(V, { x: 3, y: 4, z: 5 })
+  })
+
+  it('Should set object values recursively #1', () => {
+    const V = {}
+    ValuePointer.Set(V, '/x/y/z', 1)
+    Assert.deepEqual(V, { x: { y: { z: 1 } } })
+  })
+
+  it('Should set object values recursively #2', () => {
+    const V = {}
+    ValuePointer.Set(V, '/x/0/y/z/', 1)
+    ValuePointer.Set(V, '/x/1/y/z/', 2)
+    Assert.deepEqual(V, {
+      x: {
+        0: {
+          y: {
+            z: {
+              '': 1,
+            },
+          },
+        },
+        1: {
+          y: {
+            z: {
+              '': 2,
+            },
+          },
+        },
+      },
+    })
+  })
+
+  //-----------------------------------------------
+  // Delete
+  //-----------------------------------------------
+
+  it('Should throw when deleting root', () => {
+    const V = {}
+    Assert.throws(() => ValuePointer.Delete(V, ''))
+  })
+
+  it('Should delete object properties', () => {
+    const V = {
+      x: { x: 1, y: 2, z: 3 },
+      y: { x: 3, y: 4, z: 5 },
+    }
+    ValuePointer.Delete(V, '/x/y')
+    ValuePointer.Delete(V, '/y')
+    Assert.deepEqual(V, { x: { x: 1, z: 3 } })
+  })
+
+  it('Should be a noop if property does not exist', () => {
+    const V = {
+      x: { x: 1, y: 2, z: 3 },
+      y: { x: 3, y: 4, z: 5 },
+    }
+    ValuePointer.Delete(V, '/x/w')
+    ValuePointer.Delete(V, '/w')
+    Assert.deepEqual(V, {
+      x: { x: 1, y: 2, z: 3 },
+      y: { x: 3, y: 4, z: 5 },
+    })
+  })
+
+  it('Should not delete owner', () => {
+    const V = { x: { y: { z: 1 } } }
+    ValuePointer.Delete(V, '/x/y/z')
+    Assert.deepEqual(V, { x: { y: {} } })
+  })
+
+  it('Should delete owner', () => {
+    const V = { x: { y: { z: 1 } } }
+    ValuePointer.Delete(V, '/x/y')
+    Assert.deepEqual(V, { x: {} })
+  })
+
+  it('Should not throw if deleting null property', () => {
+    const V = { x: { y: null } }
+    ValuePointer.Delete(V, '/x/y/z')
+    Assert.deepEqual(V, { x: { y: null } })
+  })
+
+  //-----------------------------------------------
+  // Escapes
+  //-----------------------------------------------
+
+  it('Should support get ~0 pointer escape', () => {
+    const V = {
+      x: { '~': { x: 1 } },
+    }
+    Assert.deepEqual(ValuePointer.Get(V, '/x/~0'), { x: 1 })
+  })
+
+  it('Should support get ~1 pointer escape', () => {
+    const V = {
+      x: { '/': { x: 1 } },
+    }
+    Assert.deepEqual(ValuePointer.Get(V, '/x/~1'), { x: 1 })
+  })
+
+  it('Should support set ~0 pointer escape', () => {
+    const V = {
+      x: { '~': { x: 1 } },
+    }
+    ValuePointer.Set(V, '/x/~0', { x: 2 })
+    Assert.deepEqual(V, {
+      x: { '~': { x: 2 } },
+    })
+  })
+
+  it('Should support set ~1 pointer escape', () => {
+    const V = {
+      x: { '/': { x: 1 } },
+    }
+    ValuePointer.Set(V, '/x/~1', { x: 2 })
+    Assert.deepEqual(V, {
+      x: { '/': { x: 2 } },
+    })
+  })
+
+  it('Should support delete ~0 pointer escape', () => {
+    const V = {
+      x: { '~': { x: 1 } },
+    }
+    ValuePointer.Delete(V, '/x/~0')
+    Assert.deepEqual(V, {
+      x: {},
+    })
+  })
+
+  it('Should support delete ~1 pointer escape', () => {
+    const V = {
+      x: { '/': { x: 1 } },
+    }
+    ValuePointer.Delete(V, '/x/~1')
+    Assert.deepEqual(V, {
+      x: {},
+    })
+  })
+})
diff --git a/test/static/any.ts b/test/static/any.ts
new file mode 100644
index 000000000..abe16019e
--- /dev/null
+++ b/test/static/any.ts
@@ -0,0 +1,4 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.Any()).ToInfer<any>()
diff --git a/test/static/array.ts b/test/static/array.ts
new file mode 100644
index 000000000..1b52abc7c
--- /dev/null
+++ b/test/static/array.ts
@@ -0,0 +1,24 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.Array(Type.String())).ToInfer<string[]>()
+
+Expect(
+  Type.Array(
+    Type.Object({
+      x: Type.Number(),
+      y: Type.Boolean(),
+      z: Type.String(),
+    }),
+  ),
+).ToInfer<
+  {
+    x: number
+    y: boolean
+    z: string
+  }[]
+>()
+
+Expect(Type.Array(Type.Array(Type.String()))).ToInfer<string[][]>()
+
+Expect(Type.Array(Type.Tuple([Type.String(), Type.Number()]))).ToInfer<[string, number][]>()
diff --git a/test/static/assert.ts b/test/static/assert.ts
new file mode 100644
index 000000000..b4ffbd33f
--- /dev/null
+++ b/test/static/assert.ts
@@ -0,0 +1,8 @@
+import { Static, TSchema } from '@sinclair/typebox'
+
+export function Expect<T extends TSchema>(schema: T) {
+  return {
+    ToInfer: <U extends Static<T>>() => {},
+    ToBe: <U extends T>() => {},
+  }
+}
diff --git a/test/static/boolean.ts b/test/static/boolean.ts
new file mode 100644
index 000000000..d1b9f4c79
--- /dev/null
+++ b/test/static/boolean.ts
@@ -0,0 +1,4 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.Boolean()).ToInfer<boolean>()
diff --git a/test/static/enum.ts b/test/static/enum.ts
new file mode 100644
index 000000000..aee807c9f
--- /dev/null
+++ b/test/static/enum.ts
@@ -0,0 +1,12 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+
+enum E {
+  A,
+  B = 'hello',
+  C = 42,
+}
+
+const T = Type.Enum(E)
+
+Expect(T).ToBe<Static<typeof T>>() // ?
diff --git a/test/static/index.ts b/test/static/index.ts
new file mode 100644
index 000000000..909c65591
--- /dev/null
+++ b/test/static/index.ts
@@ -0,0 +1,35 @@
+import './any'
+import './array'
+import './boolean'
+import './constructor-parameters'
+import './constructor'
+import './emum'
+import './function'
+import './instance-type'
+import './intersect'
+import './keyof'
+import './literal'
+import './modifier'
+import './namespace'
+import './never'
+import './null'
+import './number'
+import './object'
+import './omit'
+import './optional'
+import './parameters'
+import './partial'
+import './pick'
+import './readonly-optional'
+import './readonly'
+import './recursive'
+import './record'
+import './ref'
+import './regex'
+import './required'
+import './return-type'
+import './strict'
+import './string'
+import './tuple'
+import './union'
+import './unknown'
diff --git a/test/static/intersect.ts b/test/static/intersect.ts
new file mode 100644
index 000000000..fcbb1000b
--- /dev/null
+++ b/test/static/intersect.ts
@@ -0,0 +1,51 @@
+import { Expect } from './assert'
+import { Type, TOptional, TString } from '@sinclair/typebox'
+
+{
+  const A = Type.Object({
+    A: Type.String(),
+    B: Type.String(),
+  })
+  const B = Type.Object({
+    X: Type.Number(),
+    Y: Type.Number(),
+  })
+  const T = Type.Intersect([A, B])
+
+  Expect(T).ToInfer<
+    {
+      A: string
+      B: string
+    } & {
+      X: number
+      Y: number
+    }
+  >()
+}
+
+{
+  const A = Type.Object({
+    A: Type.Optional(Type.String()),
+  })
+  const B = Type.Object({
+    B: Type.String(),
+  })
+  const T = Type.Intersect([A, B])
+
+  Expect(T.properties.A).ToBe<TOptional<TString>>()
+  Expect(T.properties.B).ToBe<TString>()
+}
+
+// https://github.com/sinclairzx81/typebox/issues/113
+// https://github.com/sinclairzx81/typebox/issues/187
+// {
+//     const A = Type.Object({ A: Type.String() })
+//     const B = Type.Object({ B: Type.String() })
+//     const C = Type.Object({ C: Type.String() })
+//     const T = Type.Intersect([A, Type.Union([B, C])])
+//     type T = Static<typeof T>
+//     const _0: T = { A: '', B: '' }
+//     const _1: T = { A: '', C: '' }
+//     const _3: T = { A: '', B: '', C: '' }
+//     Expect(T).ToBe<{ A: string } & ({ B: string, } | { C: string })>()
+// }
diff --git a/test/static/keyof.ts b/test/static/keyof.ts
new file mode 100644
index 000000000..62d626057
--- /dev/null
+++ b/test/static/keyof.ts
@@ -0,0 +1,57 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+{
+  const K = Type.KeyOf(
+    Type.Object({
+      A: Type.Null(),
+      B: Type.Null(),
+      C: Type.Null(),
+    }),
+  )
+  Expect(K).ToInfer<'A' | 'B' | 'C'>()
+}
+
+{
+  const T = Type.Pick(
+    Type.Object({
+      A: Type.Null(),
+      B: Type.Null(),
+      C: Type.Null(),
+    }),
+    ['A', 'B'],
+  )
+
+  const K = Type.KeyOf(T)
+
+  Expect(K).ToInfer<'A' | 'B'>()
+}
+
+{
+  const T = Type.Omit(
+    Type.Object({
+      A: Type.Null(),
+      B: Type.Null(),
+      C: Type.Null(),
+    }),
+    ['A', 'B'],
+  )
+
+  const K = Type.KeyOf(T)
+
+  Expect(K).ToInfer<'C'>()
+}
+
+{
+  const T = Type.KeyOf(
+    Type.Omit(
+      Type.Object({
+        A: Type.Null(),
+        B: Type.Null(),
+        C: Type.Null(),
+      }),
+      ['A', 'B'],
+    ),
+  )
+  Expect(T).ToInfer<'C'>()
+}
diff --git a/test/static/literal.ts b/test/static/literal.ts
new file mode 100644
index 000000000..461f43475
--- /dev/null
+++ b/test/static/literal.ts
@@ -0,0 +1,8 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.Literal('hello')).ToInfer<'hello'>()
+
+Expect(Type.Literal(true)).ToInfer<true>()
+
+Expect(Type.Literal(42)).ToInfer<42>()
diff --git a/test/static/modifier.ts b/test/static/modifier.ts
new file mode 100644
index 000000000..c0950bdf2
--- /dev/null
+++ b/test/static/modifier.ts
@@ -0,0 +1,18 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+// Asserts combinatory modifiers
+{
+  const T = Type.Object({
+    A: Type.ReadonlyOptional(Type.String()),
+    B: Type.Readonly(Type.String()),
+    C: Type.Optional(Type.String()),
+    D: Type.String(),
+  })
+  Expect(T).ToInfer<{
+    readonly A?: string
+    readonly B: string
+    C?: string
+    D: string
+  }>()
+}
diff --git a/test/static/never.ts b/test/static/never.ts
new file mode 100644
index 000000000..5eae99bec
--- /dev/null
+++ b/test/static/never.ts
@@ -0,0 +1,7 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+{
+  const T = Type.Never()
+  Expect(T).ToInfer<never>()
+}
diff --git a/test/static/null.ts b/test/static/null.ts
new file mode 100644
index 000000000..36993ffe3
--- /dev/null
+++ b/test/static/null.ts
@@ -0,0 +1,4 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.Null()).ToInfer<null>()
diff --git a/test/static/number.ts b/test/static/number.ts
new file mode 100644
index 000000000..2b1717110
--- /dev/null
+++ b/test/static/number.ts
@@ -0,0 +1,4 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.Number()).ToInfer<number>()
diff --git a/test/static/object.ts b/test/static/object.ts
new file mode 100644
index 000000000..9ed03b64a
--- /dev/null
+++ b/test/static/object.ts
@@ -0,0 +1,52 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+{
+  const T = Type.Object({
+    A: Type.String(),
+    B: Type.String(),
+    C: Type.String(),
+  })
+
+  Expect(T).ToInfer<{
+    A: string
+    B: string
+    C: string
+  }>()
+}
+{
+  const T = Type.Object({
+    A: Type.Object({
+      A: Type.String(),
+      B: Type.String(),
+      C: Type.String(),
+    }),
+    B: Type.Object({
+      A: Type.String(),
+      B: Type.String(),
+      C: Type.String(),
+    }),
+    C: Type.Object({
+      A: Type.String(),
+      B: Type.String(),
+      C: Type.String(),
+    }),
+  })
+  Expect(T).ToInfer<{
+    A: {
+      A: string
+      B: string
+      C: string
+    }
+    B: {
+      A: string
+      B: string
+      C: string
+    }
+    C: {
+      A: string
+      B: string
+      C: string
+    }
+  }>()
+}
diff --git a/test/static/omit.ts b/test/static/omit.ts
new file mode 100644
index 000000000..669fbab6c
--- /dev/null
+++ b/test/static/omit.ts
@@ -0,0 +1,37 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+
+{
+  const A = Type.Object({
+    A: Type.String(),
+    B: Type.String(),
+    C: Type.String(),
+  })
+
+  const T = Type.Omit(A, ['A', 'B'])
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<{
+    C: string
+  }>()
+}
+{
+  const A = Type.Object({
+    A: Type.String(),
+    B: Type.String(),
+    C: Type.String(),
+  })
+  const B = Type.Object({
+    A: Type.String(),
+    B: Type.String(),
+  })
+
+  const T = Type.Omit(A, Type.KeyOf(B))
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<{
+    C: string
+  }>()
+}
diff --git a/test/static/optional.ts b/test/static/optional.ts
new file mode 100644
index 000000000..aba6c4e8c
--- /dev/null
+++ b/test/static/optional.ts
@@ -0,0 +1,14 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+
+{
+  const T = Type.Object({
+    A: Type.Optional(Type.String()),
+  })
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<{
+    A?: string
+  }>()
+}
diff --git a/test/static/partial.ts b/test/static/partial.ts
new file mode 100644
index 000000000..348c64613
--- /dev/null
+++ b/test/static/partial.ts
@@ -0,0 +1,19 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+
+{
+  const T = Type.Partial(
+    Type.Object({
+      A: Type.String(),
+      B: Type.String(),
+      C: Type.String(),
+    }),
+  )
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<{
+    A?: string
+    B?: string
+    C?: string
+  }>()
+}
diff --git a/test/static/pick.ts b/test/static/pick.ts
new file mode 100644
index 000000000..bf1772bfd
--- /dev/null
+++ b/test/static/pick.ts
@@ -0,0 +1,40 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+
+{
+  const A = Type.Object({
+    A: Type.String(),
+    B: Type.String(),
+    C: Type.String(),
+  })
+
+  const T = Type.Pick(A, ['A', 'B'])
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<{
+    A: string
+    B: string
+  }>()
+}
+
+{
+  const A = Type.Object({
+    A: Type.String(),
+    B: Type.String(),
+    C: Type.String(),
+  })
+  const B = Type.Object({
+    A: Type.String(),
+    B: Type.String(),
+  })
+
+  const T = Type.Pick(A, Type.KeyOf(B))
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<{
+    A: string
+    B: string
+  }>()
+}
diff --git a/test/static/readonly-optional.ts b/test/static/readonly-optional.ts
new file mode 100644
index 000000000..622e809e2
--- /dev/null
+++ b/test/static/readonly-optional.ts
@@ -0,0 +1,11 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+
+{
+  const T = Type.Object({
+    A: Type.ReadonlyOptional(Type.String()),
+  })
+  Expect(T).ToInfer<{
+    readonly A?: string
+  }>()
+}
diff --git a/test/static/readonly.ts b/test/static/readonly.ts
new file mode 100644
index 000000000..6cce5ebb3
--- /dev/null
+++ b/test/static/readonly.ts
@@ -0,0 +1,14 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+
+{
+  const T = Type.Object({
+    A: Type.Readonly(Type.String()),
+  })
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<{
+    readonly A: string
+  }>()
+}
diff --git a/test/static/record.ts b/test/static/record.ts
new file mode 100644
index 000000000..928c052fa
--- /dev/null
+++ b/test/static/record.ts
@@ -0,0 +1,61 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+{
+  // type K = string
+  const K = Type.String()
+  const T = Type.Record(K, Type.Number())
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<Record<string, number>>()
+}
+{
+  // type K = string
+  const K = Type.RegEx(/foo|bar/)
+  const T = Type.Record(K, Type.Number())
+  type T = Static<typeof T>
+  Expect(T).ToInfer<Record<string, number>>()
+}
+{
+  // type K = number
+  const K = Type.Number()
+  const T = Type.Record(K, Type.Number())
+  type T = Static<typeof T>
+  Expect(T).ToInfer<Record<string, number>>()
+  Expect(T).ToInfer<Record<number, number>>()
+}
+{
+  // type K = 'A' | 'B' | 'C'
+  const K = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+  const T = Type.Record(K, Type.Number())
+  type T = Static<typeof T>
+  Expect(T).ToInfer<Record<'A' | 'B' | 'C', number>>()
+}
+{
+  // type K = keyof { A: number, B: number, C: number }
+  const K = Type.KeyOf(
+    Type.Object({
+      A: Type.Number(),
+      B: Type.Number(),
+      C: Type.Number(),
+    }),
+  )
+  const T = Type.Record(K, Type.Number())
+  type T = Static<typeof T>
+  Expect(T).ToInfer<Record<'A' | 'B' | 'C', number>>()
+}
+{
+  // type K = keyof Omit<{ A: number, B: number, C: number }, 'C'>
+  const K = Type.KeyOf(
+    Type.Omit(
+      Type.Object({
+        A: Type.Number(),
+        B: Type.Number(),
+        C: Type.Number(),
+      }),
+      ['C'],
+    ),
+  )
+  const T = Type.Record(K, Type.Number())
+  type T = Static<typeof T>
+  Expect(T).ToInfer<Record<'A' | 'B', number>>()
+}
diff --git a/test/static/recursive.ts b/test/static/recursive.ts
new file mode 100644
index 000000000..777195109
--- /dev/null
+++ b/test/static/recursive.ts
@@ -0,0 +1,15 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+
+{
+  const T = Type.Recursive((Node) =>
+    Type.Object({
+      id: Type.String(),
+      nodes: Type.Array(Node),
+    }),
+  )
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<T>() // ? how to test....
+}
diff --git a/test/static/ref.ts b/test/static/ref.ts
new file mode 100644
index 000000000..c4abe3675
--- /dev/null
+++ b/test/static/ref.ts
@@ -0,0 +1,13 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+
+{
+  const T = Type.String({ $id: 'T' })
+  const R = Type.Ref(T)
+
+  type T = Static<typeof T>
+  type R = Static<typeof R>
+
+  Expect(T).ToInfer<string>()
+  Expect(R).ToInfer<string>()
+}
diff --git a/test/static/regex.ts b/test/static/regex.ts
new file mode 100644
index 000000000..ea2769da7
--- /dev/null
+++ b/test/static/regex.ts
@@ -0,0 +1,4 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.RegEx(/foo/)).ToInfer<string>()
diff --git a/test/static/required.ts b/test/static/required.ts
new file mode 100644
index 000000000..c3b0ca726
--- /dev/null
+++ b/test/static/required.ts
@@ -0,0 +1,22 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+
+Expect(Type.RegEx(/foo/)).ToInfer<string>()
+
+{
+  const T = Type.Required(
+    Type.Object({
+      A: Type.Optional(Type.String()),
+      B: Type.Optional(Type.String()),
+      C: Type.Optional(Type.String()),
+    }),
+  )
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<{
+    A: string
+    B: string
+    C: string
+  }>()
+}
diff --git a/test/static/return-type.ts b/test/static/return-type.ts
new file mode 100644
index 000000000..d394484ee
--- /dev/null
+++ b/test/static/return-type.ts
@@ -0,0 +1,18 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+
+{
+  const T = Type.ReturnType(Type.Function([], Type.String()))
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<string>()
+}
+
+{
+  const T = Type.ReturnType(Type.Function([Type.Number()], Type.Number()))
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<number>()
+}
diff --git a/test/static/strict.ts b/test/static/strict.ts
new file mode 100644
index 000000000..a389c8963
--- /dev/null
+++ b/test/static/strict.ts
@@ -0,0 +1,20 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+
+{
+  const T = Type.Strict(
+    Type.Object({
+      A: Type.String(),
+      B: Type.String(),
+      C: Type.String(),
+    }),
+  )
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<{
+    A: string
+    B: string
+    C: string
+  }>()
+}
diff --git a/test/static/string.ts b/test/static/string.ts
new file mode 100644
index 000000000..5f21e625b
--- /dev/null
+++ b/test/static/string.ts
@@ -0,0 +1,4 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.String()).ToInfer<string>()
diff --git a/test/static/tsconfig.json b/test/static/tsconfig.json
new file mode 100644
index 000000000..6710ecd93
--- /dev/null
+++ b/test/static/tsconfig.json
@@ -0,0 +1,4 @@
+{
+  "extends": "../../tsconfig.json",
+  "files": ["index.ts"]
+}
diff --git a/test/static/tuple.ts b/test/static/tuple.ts
new file mode 100644
index 000000000..2ced852bc
--- /dev/null
+++ b/test/static/tuple.ts
@@ -0,0 +1,10 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+
+{
+  const T = Type.Tuple([Type.Number(), Type.String(), Type.Boolean()])
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<[number, string, boolean]>()
+}
diff --git a/test/static/union.ts b/test/static/union.ts
new file mode 100644
index 000000000..114d685fc
--- /dev/null
+++ b/test/static/union.ts
@@ -0,0 +1,73 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+
+{
+  const A = Type.String()
+  const B = Type.Number()
+  const T = Type.Union([A, B])
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<string | number>()
+}
+{
+  const A = Type.Object({
+    A: Type.String(),
+    B: Type.String(),
+  })
+  const B = Type.Object({
+    X: Type.Number(),
+    Y: Type.Number(),
+  })
+  const T = Type.Union([A, B])
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<
+    | {
+        A: string
+        B: string
+      }
+    | {
+        X: number
+        Y: number
+      }
+  >()
+}
+
+{
+  const A = Type.Object({
+    A: Type.String(),
+    B: Type.String(),
+  })
+  const B = Type.Object({
+    X: Type.Number(),
+    Y: Type.Number(),
+  })
+  const T = Type.Union([A, B, Type.Intersect([A, B])])
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<
+    | {
+        A: string
+        B: string
+      }
+    | {
+        X: number
+        Y: number
+      }
+    | ({
+        A: string
+        B: string
+      } & {
+        X: number
+        Y: number
+      })
+  >()
+}
+
+{
+  const T = Type.Union([])
+  Expect(T).ToInfer<never>()
+}
diff --git a/test/static/unknown.ts b/test/static/unknown.ts
new file mode 100644
index 000000000..28168a2a4
--- /dev/null
+++ b/test/static/unknown.ts
@@ -0,0 +1,4 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.Unknown()).ToInfer<unknown>()
diff --git a/tsconfig.json b/tsconfig.json
index 893bd6203..df793c134 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,15 +1,33 @@
 {
   "compilerOptions": {
     "strict": true,
-    "target": "ESNext",
+    "target": "ES2020",
+    "module": "CommonJS",
     "moduleResolution": "node",
-    "removeComments": true,
-    "lib": ["ESNext"],
+    "declaration": true,
     "baseUrl": ".",
     "paths": {
+      "@sinclair/typebox/codegen": [
+        "codegen/index.ts"
+      ],
+      "@sinclair/typebox/compiler": [
+        "src/compiler/index.ts"
+      ],
+      "@sinclair/typebox/conditional": [
+        "src/conditional/index.ts"
+      ],
+      "@sinclair/typebox/format": [
+        "src/format/index.ts"
+      ],
+      "@sinclair/typebox/guard": [
+        "src/guard/index.ts"
+      ],
+      "@sinclair/typebox/value": [
+        "src/value/index.ts"
+      ],
       "@sinclair/typebox": [
         "src/typebox.ts"
-      ]
+      ],
     }
   }
 }
\ No newline at end of file
diff --git a/typebox.png b/typebox.png
index d55615fcea711801022a6d577bf0d3988e63bd7b..0df53e5c5f5f2e423565e564ab3a01aa6a845c3e 100644
GIT binary patch
literal 706199
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%0A?DVB*DsVJi&ocpa!u>6&!4&M
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

literal 342043
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


From eeb53e45f421e94dec7c01b787ccdc1aa1699d03 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 12 Oct 2022 16:51:31 +0900
Subject: [PATCH 012/369] Next

---
 example/index.ts | 1 -
 package.json     | 2 +-
 src/typebox.ts   | 2 ++
 3 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/example/index.ts b/example/index.ts
index 1d6e207c4..fe4d20dc7 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -6,7 +6,6 @@ import { Format } from '@sinclair/typebox/format'
 import { Value, ValuePointer } from '@sinclair/typebox/value'
 import { Type, Static } from '@sinclair/typebox'
 
-
 const T = Type.Object({
   x: Type.Number(),
   y: Type.Number(),
diff --git a/package.json b/package.json
index 44cc0bab1..d88fbc251 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.44",
+  "version": "0.24.45",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 0f6211749..657fc5ba0 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -347,6 +347,7 @@ export interface TOmit<T extends TObject, Properties extends ObjectPropertyKeys<
 
 export interface TPartial<T extends TObject> extends TObject {
   static: Partial<Static<T, this['params']>>
+  properties: T['properties']
 }
 
 // --------------------------------------------------------------------------
@@ -419,6 +420,7 @@ export interface TRef<T extends TSchema = TSchema> extends TSchema {
 
 export interface TRequired<T extends TObject | TRef<TObject>> extends TObject {
   static: Required<Static<T, this['params']>>
+  properties: T['properties']
 }
 
 // --------------------------------------------------------------------------

From 694f01aa874c067c1fcf1107664f6e8012577a59 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 12 Oct 2022 17:57:33 +0900
Subject: [PATCH 013/369] Remap TSchema modifier types on Partial and Required

---
 package.json   |  2 +-
 src/typebox.ts | 42 ++++++++++++++++++++++++------------------
 2 files changed, 25 insertions(+), 19 deletions(-)

diff --git a/package.json b/package.json
index d88fbc251..9adb40302 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.45",
+  "version": "0.24.46",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 657fc5ba0..b7ad22d14 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -229,17 +229,13 @@ export interface TIntersect<T extends TObject[] = TObject[]> extends TObject {
 }
 
 // --------------------------------------------------------------------------
-// KeyOf: Implemented by way of Union<TLiteral<string>>
+// KeyOf
 // --------------------------------------------------------------------------
 
 export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never
-
 export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never
-
 export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L]
-
 export type UnionStringLiteralToTuple<T> = T extends TUnion<infer L> ? { [I in keyof L]: L[I] extends TLiteral<infer C> ? C : never } : never
-
 export type UnionLiteralsFromObject<T extends TObject> = { [K in ObjectPropertyKeys<T>]: TLiteral<K> } extends infer R ? UnionToTuple<R[keyof R]> : never
 
 // export type TKeyOf<T extends TObject> = { [K in ObjectPropertyKeys<T>]: TLiteral<K> } extends infer R ? UnionToTuple<R[keyof R]> : never
@@ -293,20 +289,16 @@ export interface TNumber extends TSchema, NumericOptions {
 // --------------------------------------------------------------------------
 
 export type ReadonlyOptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never }[keyof T]
-
 export type ReadonlyPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never }[keyof T]
-
 export type OptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TOptional<TSchema> ? K : never }[keyof T]
-
 export type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>
 
-export type PropertiesReduce<T extends TProperties, P extends unknown[]> = { readonly [K in ReadonlyOptionalPropertyKeys<T>]?: Static<T[K], P> } & {
-  readonly [K in ReadonlyPropertyKeys<T>]: Static<T[K], P>
-} & {
-  [K in OptionalPropertyKeys<T>]?: Static<T[K], P>
-} & { [K in RequiredPropertyKeys<T>]: Static<T[K], P> } extends infer R
-  ? { [K in keyof R]: R[K] }
-  : never
+// prettier-ignore
+export type PropertiesReduce<T extends TProperties, P extends unknown[]> = 
+  { readonly [K in ReadonlyOptionalPropertyKeys<T>]?: Static<T[K], P> } & 
+  { readonly [K in ReadonlyPropertyKeys<T>]:          Static<T[K], P> } & 
+  {          [K in OptionalPropertyKeys<T>]?:         Static<T[K], P> } & 
+  {          [K in RequiredPropertyKeys<T>]:          Static<T[K], P> } extends infer R ? { [K in keyof R]: R[K] } : never
 
 export type TRecordProperties<K extends TUnion<TLiteral[]>, T extends TSchema> = Static<K> extends string ? { [X in Static<K>]: T } : never
 
@@ -347,7 +339,14 @@ export interface TOmit<T extends TObject, Properties extends ObjectPropertyKeys<
 
 export interface TPartial<T extends TObject> extends TObject {
   static: Partial<Static<T, this['params']>>
-  properties: T['properties']
+  properties: {
+    // prettier-ignore
+    [K in keyof T['properties']]: 
+      T['properties'][K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : 
+      T['properties'][K] extends TReadonly<infer U>         ? TReadonlyOptional<U> : 
+      T['properties'][K] extends TOptional<infer U>         ? TOptional<U> : 
+      TOptional<T['properties'][K]>
+  }
 }
 
 // --------------------------------------------------------------------------
@@ -420,7 +419,14 @@ export interface TRef<T extends TSchema = TSchema> extends TSchema {
 
 export interface TRequired<T extends TObject | TRef<TObject>> extends TObject {
   static: Required<Static<T, this['params']>>
-  properties: T['properties']
+  properties: {
+    // prettier-ignore
+    [K in keyof T['properties']]: 
+      T['properties'][K] extends TReadonlyOptional<infer U> ? TReadonly<U> :  
+      T['properties'][K] extends TReadonly<infer U>         ? TReadonly<U> :
+      T['properties'][K] extends TOptional<infer U>         ? U :  
+      T['properties'][K]
+  }
 }
 
 // --------------------------------------------------------------------------
@@ -955,7 +961,7 @@ export class TypeBuilder {
           [key]: this.Clone(value[key]),
         }),
         Object.getOwnPropertySymbols(value).reduce(
-          (acc, key) => ({
+          (acc, key: any) => ({
             ...acc,
             [key]: this.Clone(value[key]),
           }),

From 707b8caf7b83a241b57d94205d069d4d8f9c59bf Mon Sep 17 00:00:00 2001
From: Noam Okman <noamokman@gmail.com>
Date: Tue, 18 Oct 2022 17:42:31 +0300
Subject: [PATCH 014/369] Support readonly argument for Pick and Omit (#261)

* support pick from const array

* support omit from const array
---
 src/typebox.ts      |  8 ++++----
 test/static/omit.ts | 19 +++++++++++++++++++
 test/static/pick.ts | 19 +++++++++++++++++++
 3 files changed, 42 insertions(+), 4 deletions(-)

diff --git a/src/typebox.ts b/src/typebox.ts
index b7ad22d14..ec08f871a 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -745,11 +745,11 @@ export class TypeBuilder {
   public Omit<T extends TObject, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: ObjectOptions): TOmit<T, UnionStringLiteralToTuple<K>>
 
   /** Creates a new object whose properties are omitted from the given object */
-  public Omit<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: T, keys: [...K], options?: ObjectOptions): TOmit<T, K>
+  public Omit<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: T, keys: readonly [...K], options?: ObjectOptions): TOmit<T, K>
 
   /** Creates a new object whose properties are omitted from the given object */
   public Omit(schema: any, keys: any, options: ObjectOptions = {}) {
-    const select: string[] = keys[Kind] === 'Union' ? keys.anyOf.map((schema: TLiteral) => schema.const) : keys
+    const select: readonly string[] = keys[Kind] === 'Union' ? keys.anyOf.map((schema: TLiteral) => schema.const) : keys
     const next = { ...this.Clone(schema), ...options, [Hint]: 'Omit' }
     if (next.required) {
       next.required = next.required.filter((key: string) => !select.includes(key as any))
@@ -795,11 +795,11 @@ export class TypeBuilder {
   public Pick<T extends TObject, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: ObjectOptions): TPick<T, UnionStringLiteralToTuple<K>>
 
   /** Creates a object whose properties are picked from the given object */
-  public Pick<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: T, keys: [...K], options?: ObjectOptions): TPick<T, K>
+  public Pick<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: T, keys: readonly [...K], options?: ObjectOptions): TPick<T, K>
 
   /** Creates a object whose properties are picked from the given object */
   public Pick<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: any, keys: any, options: ObjectOptions = {}) {
-    const select: string[] = keys[Kind] === 'Union' ? keys.anyOf.map((schema: TLiteral) => schema.const) : keys
+    const select: readonly string[] = keys[Kind] === 'Union' ? keys.anyOf.map((schema: TLiteral) => schema.const) : keys
     const next = { ...this.Clone(schema), ...options, [Hint]: 'Pick' }
     if (next.required) {
       next.required = next.required.filter((key: any) => select.includes(key))
diff --git a/test/static/omit.ts b/test/static/omit.ts
index 669fbab6c..4ef02bdf5 100644
--- a/test/static/omit.ts
+++ b/test/static/omit.ts
@@ -16,6 +16,25 @@ import { Type, Static } from '@sinclair/typebox'
     C: string
   }>()
 }
+
+{
+  const A = Type.Object({
+    A: Type.String(),
+    B: Type.String(),
+    C: Type.String(),
+  })
+
+  const keys = ['A', 'B'] as const;
+
+  const T = Type.Omit(A, keys)
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<{
+    C: string
+  }>()
+}
+
 {
   const A = Type.Object({
     A: Type.String(),
diff --git a/test/static/pick.ts b/test/static/pick.ts
index bf1772bfd..0ae10cd93 100644
--- a/test/static/pick.ts
+++ b/test/static/pick.ts
@@ -18,6 +18,25 @@ import { Type, Static } from '@sinclair/typebox'
   }>()
 }
 
+{
+  const A = Type.Object({
+    A: Type.String(),
+    B: Type.String(),
+    C: Type.String(),
+  })
+
+  const keys = ['A', 'B'] as const
+
+  const T = Type.Pick(A, keys)
+
+  type T = Static<typeof T>
+
+  Expect(T).ToInfer<{
+    A: string
+    B: string
+  }>()
+}
+
 {
   const A = Type.Object({
     A: Type.String(),

From 302914491d07f2ec0b99552cca3b7b55ca7d73a1 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 18 Oct 2022 23:47:20 +0900
Subject: [PATCH 015/369] Formatting

---
 test/static/omit.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/static/omit.ts b/test/static/omit.ts
index 4ef02bdf5..c3f726889 100644
--- a/test/static/omit.ts
+++ b/test/static/omit.ts
@@ -24,7 +24,7 @@ import { Type, Static } from '@sinclair/typebox'
     C: Type.String(),
   })
 
-  const keys = ['A', 'B'] as const;
+  const keys = ['A', 'B'] as const
 
   const T = Type.Omit(A, keys)
 

From 31a137aca7bea6f80d564ad270e0704dac3d7aa2 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 19 Oct 2022 17:08:44 +0900
Subject: [PATCH 016/369] Next

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 9adb40302..1af6ec989 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.46",
+  "version": "0.24.47",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

From 44d74706e69efde3540d221f18694a71ab17d750 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sat, 22 Oct 2022 08:52:03 +0900
Subject: [PATCH 017/369] Required properties error reporting type

---
 package.json                      |  2 +-
 src/errors/errors.ts              | 16 +++++++++++++---
 test/runtime/compiler/validate.ts | 12 ++++++++++--
 3 files changed, 24 insertions(+), 6 deletions(-)

diff --git a/package.json b/package.json
index 1af6ec989..c16727829 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.47",
+  "version": "0.24.48",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index e4dea5907..b681aa313 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -59,6 +59,7 @@ export enum ValueErrorType {
   ObjectMinProperties,
   ObjectMaxProperties,
   ObjectAdditionalProperties,
+  ObjectRequiredProperties,
   Promise,
   RecordKeyNumeric,
   RecordKeyString,
@@ -211,12 +212,21 @@ export namespace ValueErrors {
     }
     const propertyKeys = globalThis.Object.keys(schema.properties)
     if (schema.additionalProperties === false) {
-      for (const propKey of globalThis.Object.keys(value)) {
-        if (!propertyKeys.includes(propKey)) {
-          yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${propKey}`, value: value[propKey], message: 'Unexpected property' }
+      for (const objectKey of globalThis.Object.keys(value)) {
+        if (!propertyKeys.includes(objectKey)) {
+          yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${objectKey}`, value: value[objectKey], message: `Unexpected property` }
         }
       }
     }
+
+    if (schema.required && schema.required.length > 0) {
+      const objectKeys = globalThis.Object.keys(value)
+      for (const requiredKey of schema.required) {
+        if (objectKeys.includes(requiredKey)) continue
+        yield { type: ValueErrorType.ObjectRequiredProperties, schema: schema.properties[requiredKey], path: `${path}/${requiredKey}`, value: undefined, message: `Expected required property` }
+      }
+    }
+
     for (const propertyKey of propertyKeys) {
       const propertySchema = schema.properties[propertyKey]
       if (schema.required && schema.required.includes(propertyKey)) {
diff --git a/test/runtime/compiler/validate.ts b/test/runtime/compiler/validate.ts
index 985184e4c..4d2ba2f69 100644
--- a/test/runtime/compiler/validate.ts
+++ b/test/runtime/compiler/validate.ts
@@ -69,6 +69,10 @@ export function ok<T extends TSchema>(schema: T, data: unknown, references: any[
   if (result !== Value.Check(schema, references, data)) {
     throw Error('Compiler and Value Check disparity')
   }
+  if (result === false) {
+    const errors = [...Value.Errors(schema, references, data)]
+    if (errors.length === 0) throw Error('expected at least 1 error')
+  }
   if (!result) {
     console.log('---------------------------')
     console.log('type')
@@ -86,9 +90,13 @@ export function ok<T extends TSchema>(schema: T, data: unknown, references: any[
   }
 }
 
-export function fail<T extends TSchema>(schema: T, data: unknown, additional: any[] = []) {
-  const C = TypeCompiler.Compile(schema, additional)
+export function fail<T extends TSchema>(schema: T, data: unknown, references: any[] = []) {
+  const C = TypeCompiler.Compile(schema, references)
   const result = C.Check(data)
+  if (result === false) {
+    const errors = [...Value.Errors(schema, references, data)]
+    if (errors.length === 0) throw Error('expected at least 1 error')
+  }
   if (result) {
     console.log('---------------------------')
     console.log('type')

From 27fd7409ba2c33a680dc0d3c13cc6716468588cf Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sat, 22 Oct 2022 12:39:01 +0900
Subject: [PATCH 018/369] Reference TypeScript to JsonSchema Code Generation

---
 codegen/codegen.ts    |   6 +
 codegen/jsonschema.ts | 428 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 434 insertions(+)
 create mode 100644 codegen/jsonschema.ts

diff --git a/codegen/codegen.ts b/codegen/codegen.ts
index ebbdab70d..63728ce18 100644
--- a/codegen/codegen.ts
+++ b/codegen/codegen.ts
@@ -29,6 +29,7 @@ THE SOFTWARE.
 import { TSchema } from '@sinclair/typebox'
 import { TypeBoxCodegen } from './typebox'
 import { TypeScriptCodeGen } from './typescript'
+import { JsonSchemaCodeGen } from './jsonschema'
 
 export namespace CodeGen {
   /** Generates TypeScript type definitions from TypeBox types */
@@ -40,4 +41,9 @@ export namespace CodeGen {
   export function TypeBox(code: string): string {
     return TypeBoxCodegen.Generate(code)
   }
+
+  /** Generates JsonSchema definitions from TypeScript code */
+  export function JsonSchema(code: string): string {
+    return JsonSchemaCodeGen.Generate(code)
+  }
 }
diff --git a/codegen/jsonschema.ts b/codegen/jsonschema.ts
new file mode 100644
index 000000000..8dbfaa0c5
--- /dev/null
+++ b/codegen/jsonschema.ts
@@ -0,0 +1,428 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/codegen
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as ts from 'typescript'
+
+export class NonExpressable extends Error {
+  constructor(type: string) {
+    super(`JsonSchemaCodeGen: Cannot express syntax type '${type}'`)
+  }
+}
+
+/** Generates JsonSchema from TypeScript interface and type definitions */
+export namespace JsonSchemaCodeGen {
+  function isReadonlyProperty(node: ts.PropertySignature): boolean {
+    return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'readonly') !== undefined
+  }
+
+  function isOptionalProperty(node: ts.PropertySignature) {
+    return node.questionToken !== undefined
+  }
+
+  function isExport(node: ts.InterfaceDeclaration | ts.TypeAliasDeclaration | ts.EnumDeclaration): boolean {
+    return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'export') !== undefined
+  }
+
+  function* SourceFile(node: ts.SourceFile): IterableIterator<string> {
+    for (const next of node.getChildren()) {
+      yield* Visit(next)
+    }
+  }
+
+  function* PropertySignature(node: ts.PropertySignature): IterableIterator<string> {
+    const [readonly, optional] = [isReadonlyProperty(node), isOptionalProperty(node)]
+    const type = Collect(node.type)
+    if (readonly && optional) {
+      return yield `${node.name.getText()}: ${type}`
+    } else if (readonly) {
+      return yield `${node.name.getText()}: ${type}`
+    } else if (optional) {
+      return yield `${node.name.getText()}: ${type}`
+    } else {
+      return yield `${node.name.getText()}: ${type}`
+    }
+  }
+
+  function* ArrayTypeNode(node: ts.ArrayTypeNode): IterableIterator<string> {
+    const type = Collect(node.elementType)
+    yield `{
+      type: 'array',
+      items: ${type}
+    }`
+  }
+
+  function* TupleTypeNode(node: ts.TupleTypeNode): IterableIterator<string> {
+    const types = node.elements.map((type) => Collect(type)).join(',\n')
+    yield `{
+      type: 'array',
+      items: [${types}],
+      minItems: ${node.elements.length},
+      maxItems: ${node.elements.length}
+    }`
+  }
+
+  function* UnionTypeNode(node: ts.UnionTypeNode): IterableIterator<string> {
+    const types = node.types.map((type) => Collect(type)).join(',\n')
+    yield `{
+      anyOf: [
+        ${types}
+      ]
+    }`
+  }
+
+  function* IntersectionTypeNode(node: ts.IntersectionTypeNode): IterableIterator<string> {
+    throw new NonExpressable('IntersectionTypeNode')
+  }
+
+  function* TypeOperatorNode(node: ts.TypeOperatorNode): IterableIterator<string> {
+    throw new NonExpressable('TypeOperatorNode')
+  }
+
+  function* Parameter(node: ts.ParameterDeclaration): IterableIterator<string> {
+    yield Collect(node.type)
+  }
+
+  function* FunctionTypeNode(node: ts.FunctionTypeNode): IterableIterator<string> {
+    throw new NonExpressable('FunctionTypeNode')
+  }
+
+  function* ConstructorTypeNode(node: ts.ConstructorTypeNode): IterableIterator<string> {
+    throw new NonExpressable('ConstructorTypeNode')
+  }
+
+  function* EnumMember(node: ts.EnumMember): IterableIterator<string> {
+    if (node.initializer) {
+      return yield `{
+        const: ${node.initializer.getText()}
+      }`
+    }
+    return yield `{
+      const: '${node.name.getText()}'
+    }`
+  }
+
+  function* EnumDeclaration(node: ts.EnumDeclaration): IterableIterator<string> {
+    const exports = isExport(node) ? 'export ' : ''
+    const name = node.name.getText()
+    const members = node.members.map((member) => Collect(member)).join(',\n')
+    yield `${exports}const ${name} = {
+      anyOf: [
+        ${members}
+      ]
+    }`
+  }
+
+  function* InterfaceDeclaration(node: ts.InterfaceDeclaration): IterableIterator<string> {
+    if (node.typeParameters) {
+      const exports = isExport(node) ? 'export ' : ''
+      const members = node.members.map((member) => Collect(member)).join(',\n')
+      const required = node.members
+        .filter((member) => member.questionToken === undefined)
+        .map((member) => `'${member.name?.getText()}'`)
+        .join(',\n')
+      const parameters = node.typeParameters.map((param) => `${Collect(param)}`).join(', ')
+      const definition = `${exports}const ${node.name.getText()} = (${parameters}) => {
+        type: 'object,
+        properties: {
+          ${members}
+        },
+        required: [
+          ${required}
+        ],
+      }`
+      yield `${definition}`
+    } else {
+      const exports = isExport(node) ? 'export ' : ''
+      const members = node.members.map((member) => Collect(member)).join(',\n')
+      const required = node.members
+        .filter((member) => member.questionToken === undefined)
+        .map((member) => `'${member.name?.getText()}'`)
+        .join(',\n')
+      const definition = `${exports}const ${node.name.getText()} = {
+        type: 'object',
+        properties: {
+          ${members}
+        },
+        required: [
+          ${required}
+        ]
+      }`
+      yield `${definition}`
+    }
+  }
+
+  function* TypeAliasDeclaration(node: ts.TypeAliasDeclaration): IterableIterator<string> {
+    if (node.typeParameters) {
+      const exports = isExport(node) ? 'export ' : ''
+      const parameters = node.typeParameters.map((param) => `${Collect(param)}`).join(', ')
+      const type = Collect(node.type)
+      const definition = `${exports}const ${node.name.getText()} = (${parameters}) => ${type}`
+      yield `${definition}`
+    } else {
+      const exports = isExport(node) ? 'export ' : ''
+      const type = Collect(node.type)
+      const definition = `${exports}const ${node.name.getText()} = ${type}`
+      yield `${definition}`
+    }
+  }
+
+  function* TypeParameterDeclaration(node: ts.TypeParameterDeclaration): IterableIterator<string> {
+    yield node.name.getText()
+  }
+
+  function* ParenthesizedTypeNode(node: ts.ParenthesizedTypeNode): IterableIterator<string> {
+    yield Collect(node.type)
+  }
+
+  function* RestTypeNode(node: ts.RestTypeNode): IterableIterator<string> {
+    throw new NonExpressable('RestTypeNode')
+  }
+
+  function* ConditionalTypeNode(node: ts.ConditionalTypeNode): IterableIterator<string> {
+    const checkType = Collect(node.checkType)
+    const extendsType = Collect(node.extendsType)
+    const trueType = Collect(node.trueType)
+    const falseType = Collect(node.falseType)
+    yield `${checkType} ${extendsType}, ${trueType}, ${falseType})`
+  }
+
+  function* TypeReferenceNode(node: ts.TypeReferenceNode): IterableIterator<string> {
+    const name = node.typeName.getText()
+    const args = node.typeArguments ? `(${node.typeArguments.map((type) => Collect(type)).join(', ')})` : ''
+    if (name === 'Array') {
+      return yield `{
+        type: 'array',
+        items: ${args}
+      }`
+    } else if (name === 'Record') {
+      throw new NonExpressable('TypeReferenceNode:Record')
+    } else if (name === 'Partial') {
+      throw new NonExpressable('TypeReferenceNode:Partial')
+    } else if (name === 'Uint8Array') {
+      throw new NonExpressable('TypeReferenceNode:Uint8Array')
+    } else if (name === 'Required') {
+      throw new NonExpressable('TypeReferenceNode:Required')
+    } else if (name === 'Omit') {
+      throw new NonExpressable('TypeReferenceNode:Omit')
+    } else if (name === 'Pick') {
+      throw new NonExpressable('TypeReferenceNode:Pick')
+    } else if (name === 'Promise') {
+      throw new NonExpressable('TypeReferenceNode:Promise')
+    } else if (name === 'ReturnType') {
+      throw new NonExpressable('TypeReferenceNode:ReturnType')
+    } else if (name === 'InstanceType') {
+      throw new NonExpressable('TypeReferenceNode:InstanceType')
+    } else if (name === 'Parameters') {
+      throw new NonExpressable('TypeReferenceNode:Parameters')
+    } else if (name === 'ConstructorParameters') {
+      throw new NonExpressable('TypeReferenceNode:ConstructorParameters')
+    } else if (name === 'Exclude') {
+      throw new NonExpressable('TypeReferenceNode:Exclude')
+    } else if (name === 'Extract') {
+      throw new NonExpressable('TypeReferenceNode:Extract')
+    } else {
+      return yield `${name}${args}`
+    }
+  }
+
+  function* TypeLiteralNode(node: ts.TypeLiteralNode): IterableIterator<string> {
+    const members = node.members.map((member) => Collect(member)).join(',\n')
+    const required = node.members
+      .filter((member) => member.questionToken === undefined)
+      .map((member) => `'${member.name?.getText()}'`)
+      .join(',\n')
+    yield `{
+      type: 'object',
+      properties: {
+        ${members}
+      },
+      required: [
+        ${required}
+      ]
+    }`
+  }
+
+  function* LiteralTypeNode(node: ts.LiteralTypeNode): IterableIterator<string> {
+    const text = node.getText()
+    if (text === 'null')
+      return yield `{ 
+      type: 'null' 
+    }`
+    yield `{ 
+      const: ${node.getText()} 
+    }`
+  }
+
+  function* FunctionDeclaration(node: ts.FunctionDeclaration): IterableIterator<string> {
+    yield node.getText()
+  }
+
+  function* ClassDeclaration(node: ts.ClassDeclaration): IterableIterator<string> {
+    yield node.getText()
+  }
+
+  function Collect(node: ts.Node | undefined): string {
+    return `${[...Visit(node)].join('')}`
+  }
+
+  function CollectNewLine(node: ts.Node | undefined): string {
+    return [...Visit(node)].join('\n\n')
+  }
+
+  function* Visit(node: ts.Node | undefined): IterableIterator<string> {
+    if (node === undefined) return
+    if (ts.isSourceFile(node)) {
+      return yield* SourceFile(node)
+    } else if (ts.isInterfaceDeclaration(node)) {
+      return yield* InterfaceDeclaration(node)
+    } else if (ts.isTypeAliasDeclaration(node)) {
+      return yield* TypeAliasDeclaration(node)
+    } else if (ts.isParameter(node)) {
+      return yield* Parameter(node)
+    } else if (ts.isFunctionTypeNode(node)) {
+      return yield* FunctionTypeNode(node)
+    } else if (ts.isConstructorTypeNode(node)) {
+      return yield* ConstructorTypeNode(node)
+    } else if (ts.isEnumMember(node)) {
+      return yield* EnumMember(node)
+    } else if (ts.isEnumDeclaration(node)) {
+      return yield* EnumDeclaration(node)
+    } else if (ts.isPropertySignature(node)) {
+      return yield* PropertySignature(node)
+    } else if (ts.isTypeReferenceNode(node)) {
+      return yield* TypeReferenceNode(node)
+    } else if (ts.isTypeLiteralNode(node)) {
+      return yield* TypeLiteralNode(node)
+    } else if (ts.isLiteralTypeNode(node)) {
+      return yield* LiteralTypeNode(node)
+    } else if (ts.isArrayTypeNode(node)) {
+      return yield* ArrayTypeNode(node)
+    } else if (ts.isTupleTypeNode(node)) {
+      return yield* TupleTypeNode(node)
+    } else if (ts.isIntersectionTypeNode(node)) {
+      return yield* IntersectionTypeNode(node)
+    } else if (ts.isUnionTypeNode(node)) {
+      return yield* UnionTypeNode(node)
+    } else if (ts.isTypeOperatorNode(node)) {
+      return yield* TypeOperatorNode(node)
+    } else if (ts.isTypeParameterDeclaration(node)) {
+      return yield* TypeParameterDeclaration(node)
+    } else if (ts.isParenthesizedTypeNode(node)) {
+      return yield* ParenthesizedTypeNode(node)
+    } else if (ts.isRestTypeNode(node)) {
+      return yield* RestTypeNode(node)
+    } else if (ts.isFunctionDeclaration(node)) {
+      return yield* FunctionDeclaration(node)
+    } else if (ts.isClassDeclaration(node)) {
+      return yield* ClassDeclaration(node)
+    } else if (ts.isConditionalTypeNode(node)) {
+      return yield* ConditionalTypeNode(node)
+    } else if (node.kind === ts.SyntaxKind.KeyOfKeyword) {
+      throw Error('JsonSchemaCodeGen: keyof cannot be expressed as json schema')
+    } else if (node.kind === ts.SyntaxKind.NumberKeyword) {
+      return yield `{ 
+        type: 'number' 
+      }`
+    } else if (node.kind === ts.SyntaxKind.StringKeyword) {
+      return yield `{ 
+        type: 'string' 
+      }`
+    } else if (node.kind === ts.SyntaxKind.BooleanKeyword) {
+      return yield `{ 
+        type: 'boolean' 
+      }`
+    } else if (node.kind === ts.SyntaxKind.UndefinedKeyword) {
+      throw Error('JsonSchemaCodeGen: undefined cannot be expressed as json schema')
+    } else if (node.kind === ts.SyntaxKind.UnknownKeyword) {
+      return yield `{
+
+      }`
+    } else if (node.kind === ts.SyntaxKind.AnyKeyword) {
+      return yield `{ 
+
+      }`
+    } else if (node.kind === ts.SyntaxKind.NeverKeyword) {
+      return yield `{
+        anyOf: [
+          { 
+            type: 'boolean', 
+            const: true 
+          }, 
+          { 
+            type: 'boolean', 
+            const: false 
+          }
+        ]
+      }`
+    } else if (node.kind === ts.SyntaxKind.NullKeyword) {
+      return yield `{ 
+        type: 'null' 
+      }`
+    } else if (node.kind === ts.SyntaxKind.VoidKeyword) {
+      throw Error('JsonSchemaCodeGen: void cannot be expressed as json schema')
+    } else if (node.kind === ts.SyntaxKind.EndOfFileToken) {
+      return
+    } else if (node.kind === ts.SyntaxKind.SyntaxList) {
+      for (const child of node.getChildren()) {
+        yield* Visit(child)
+      }
+      return
+    } else {
+      console.log('Unhandled:', ts.SyntaxKind[node.kind])
+      return yield node.getText()
+    }
+  }
+
+  function Format(input: string): string {
+    function count(line: string, opens: string[]) {
+      const codes = opens.map((open) => open.charCodeAt(0))
+      return line
+        .split('')
+        .map((char) => char.charCodeAt(0))
+        .reduce((acc, current) => {
+          return codes.includes(current) ? acc + 1 : acc
+        }, 0)
+    }
+    let indent = 0
+    const output: string[] = []
+    for (const line of input.split('\n').map((n) => n.trim())) {
+      indent -= count(line, ['}', ']'])
+      output.push(`${''.padStart(indent * 2, ' ')}${line}`)
+      indent += count(line, ['{', '['])
+    }
+    return output.join('\n')
+  }
+
+  /** Generates TypeBox types from TypeScript interface and type definitions */
+  export function Generate(typescriptCode: string) {
+    const source = ts.createSourceFile('code.ts', typescriptCode, ts.ScriptTarget.ESNext, true)
+    const declarations = CollectNewLine(source)
+    const types = Format(declarations)
+    return [types].join('\n')
+  }
+}

From ea3139967688de59b26a95aba30b066a4d2648c6 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sat, 22 Oct 2022 13:03:37 +0900
Subject: [PATCH 019/369] Reference TypeScript to JsonSchema Code Generation

---
 codegen/jsonschema.ts | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/codegen/jsonschema.ts b/codegen/jsonschema.ts
index 8dbfaa0c5..171a55764 100644
--- a/codegen/jsonschema.ts
+++ b/codegen/jsonschema.ts
@@ -96,7 +96,12 @@ export namespace JsonSchemaCodeGen {
   }
 
   function* IntersectionTypeNode(node: ts.IntersectionTypeNode): IterableIterator<string> {
-    throw new NonExpressable('IntersectionTypeNode')
+    const types = node.types.map((type) => Collect(type)).join(',\n')
+    yield `{
+      allOf: [
+        ${types}
+      ]
+    }`
   }
 
   function* TypeOperatorNode(node: ts.TypeOperatorNode): IterableIterator<string> {

From 4bcacd4f9911dd17755b44662d2a4631633ae400 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 23 Oct 2022 17:26:44 +0900
Subject: [PATCH 020/369] Non-Boolean Additional Properties (#264)

---
 changelog.md                       |   9 +++
 codegen/jsonschema.ts              |  12 ++--
 package.json                       |   2 +-
 readme.md                          | 102 ++++++++++++++---------------
 src/compiler/compiler.ts           |   5 ++
 src/errors/errors.ts               |   7 +-
 src/guard/guard.ts                 |   7 +-
 src/typebox.ts                     |  13 ++--
 src/value/cast.ts                  |   8 +++
 src/value/check.ts                 |   8 +++
 test/runtime/compiler/object.ts    |  66 +++++++++++++++++++
 test/runtime/guard/object.ts       |  31 +++++++++
 test/runtime/schema/object.ts      |  68 +++++++++++++++++++
 test/runtime/value/cast/object.ts  |  54 +++++++++++++++
 test/runtime/value/check/object.ts |  92 ++++++++++++++++++++++++++
 test/static/object.ts              |  22 ++++++-
 16 files changed, 436 insertions(+), 70 deletions(-)

diff --git a/changelog.md b/changelog.md
index 7c8020b0c..220a9cfac 100644
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,12 @@
+## [0.24.49](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.49)
+
+Updates:
+- [264](https://github.com/sinclairzx81/typebox/pull/264) TypeBox now provides preliminary support for non-boolean `additionalProperties`. This allows existing `TObject` schemas to be augmented with additional properties of a known type.
+
+Additional:
+
+- TypeBox provides an additional reference `codegen` module for generating raw JSON Schema from TypeScript types via the TS compiler API. This generator may be used in future tooling.
+
 ## [0.24.44](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.44)
 
 Updates:
diff --git a/codegen/jsonschema.ts b/codegen/jsonschema.ts
index 171a55764..23f4db8a1 100644
--- a/codegen/jsonschema.ts
+++ b/codegen/jsonschema.ts
@@ -209,11 +209,7 @@ export namespace JsonSchemaCodeGen {
   }
 
   function* ConditionalTypeNode(node: ts.ConditionalTypeNode): IterableIterator<string> {
-    const checkType = Collect(node.checkType)
-    const extendsType = Collect(node.extendsType)
-    const trueType = Collect(node.trueType)
-    const falseType = Collect(node.falseType)
-    yield `${checkType} ${extendsType}, ${trueType}, ${falseType})`
+    throw new NonExpressable('ConditionalTypeNode')
   }
 
   function* TypeReferenceNode(node: ts.TypeReferenceNode): IterableIterator<string> {
@@ -348,7 +344,7 @@ export namespace JsonSchemaCodeGen {
     } else if (ts.isConditionalTypeNode(node)) {
       return yield* ConditionalTypeNode(node)
     } else if (node.kind === ts.SyntaxKind.KeyOfKeyword) {
-      throw Error('JsonSchemaCodeGen: keyof cannot be expressed as json schema')
+      throw new NonExpressable('KeyOfKeyword')
     } else if (node.kind === ts.SyntaxKind.NumberKeyword) {
       return yield `{ 
         type: 'number' 
@@ -362,7 +358,7 @@ export namespace JsonSchemaCodeGen {
         type: 'boolean' 
       }`
     } else if (node.kind === ts.SyntaxKind.UndefinedKeyword) {
-      throw Error('JsonSchemaCodeGen: undefined cannot be expressed as json schema')
+      throw new NonExpressable('UndefinedKeyword')
     } else if (node.kind === ts.SyntaxKind.UnknownKeyword) {
       return yield `{
 
@@ -389,7 +385,7 @@ export namespace JsonSchemaCodeGen {
         type: 'null' 
       }`
     } else if (node.kind === ts.SyntaxKind.VoidKeyword) {
-      throw Error('JsonSchemaCodeGen: void cannot be expressed as json schema')
+      throw new NonExpressable('KeyOfKeyword')
     } else if (node.kind === ts.SyntaxKind.EndOfFileToken) {
       return
     } else if (node.kind === ts.SyntaxKind.SyntaxList) {
diff --git a/package.json b/package.json
index c16727829..3e54b2706 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.48",
+  "version": "0.24.49",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 6d77e6a33..a5bc4caa5 100644
--- a/readme.md
+++ b/readme.md
@@ -1062,29 +1062,29 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    384 ms' │ '      9 ms' │ '   42.67 x' │
-│           String │    2000    │ '    322 ms' │ '      8 ms' │ '   40.25 x' │
-│          Boolean │    2000    │ '    310 ms' │ '      6 ms' │ '   51.67 x' │
-│             Null │    2000    │ '    271 ms' │ '      6 ms' │ '   45.17 x' │
-│            RegEx │    2000    │ '    491 ms' │ '     12 ms' │ '   40.92 x' │
-│          ObjectA │    2000    │ '   2935 ms' │ '     44 ms' │ '   66.70 x' │
-│          ObjectB │    2000    │ '   3076 ms' │ '     30 ms' │ '  102.53 x' │
-│            Tuple │    2000    │ '   1274 ms' │ '     22 ms' │ '   57.91 x' │
-│            Union │    2000    │ '   1281 ms' │ '     22 ms' │ '   58.23 x' │
-│          Vector4 │    2000    │ '   1602 ms' │ '     17 ms' │ '   94.24 x' │
-│          Matrix4 │    2000    │ '    959 ms' │ '     10 ms' │ '   95.90 x' │
-│   Literal_String │    2000    │ '    337 ms' │ '      6 ms' │ '   56.17 x' │
-│   Literal_Number │    2000    │ '    376 ms' │ '      5 ms' │ '   75.20 x' │
-│  Literal_Boolean │    2000    │ '    370 ms' │ '      5 ms' │ '   74.00 x' │
-│     Array_Number │    2000    │ '    733 ms' │ '      9 ms' │ '   81.44 x' │
-│     Array_String │    2000    │ '    764 ms' │ '     10 ms' │ '   76.40 x' │
-│    Array_Boolean │    2000    │ '    818 ms' │ '      6 ms' │ '  136.33 x' │
-│    Array_ObjectA │    2000    │ '   3744 ms' │ '     35 ms' │ '  106.97 x' │
-│    Array_ObjectB │    2000    │ '   3893 ms' │ '     34 ms' │ '  114.50 x' │
-│      Array_Tuple │    2000    │ '   2229 ms' │ '     16 ms' │ '  139.31 x' │
-│      Array_Union │    2000    │ '   1705 ms' │ '     18 ms' │ '   94.72 x' │
-│    Array_Vector4 │    2000    │ '   2261 ms' │ '     17 ms' │ '  133.00 x' │
-│    Array_Matrix4 │    2000    │ '   1574 ms' │ '     14 ms' │ '  112.43 x' │
+│           Number │    2000    │ '    428 ms' │ '     12 ms' │ '   35.67 x' │
+│           String │    2000    │ '    337 ms' │ '     12 ms' │ '   28.08 x' │
+│          Boolean │    2000    │ '    317 ms' │ '     11 ms' │ '   28.82 x' │
+│             Null │    2000    │ '    274 ms' │ '     10 ms' │ '   27.40 x' │
+│            RegEx │    2000    │ '    500 ms' │ '     18 ms' │ '   27.78 x' │
+│          ObjectA │    2000    │ '   2717 ms' │ '     49 ms' │ '   55.45 x' │
+│          ObjectB │    2000    │ '   2854 ms' │ '     37 ms' │ '   77.14 x' │
+│            Tuple │    2000    │ '   1224 ms' │ '     21 ms' │ '   58.29 x' │
+│            Union │    2000    │ '   1266 ms' │ '     23 ms' │ '   55.04 x' │
+│          Vector4 │    2000    │ '   1513 ms' │ '     19 ms' │ '   79.63 x' │
+│          Matrix4 │    2000    │ '    841 ms' │ '     12 ms' │ '   70.08 x' │
+│   Literal_String │    2000    │ '    327 ms' │ '      8 ms' │ '   40.88 x' │
+│   Literal_Number │    2000    │ '    358 ms' │ '      6 ms' │ '   59.67 x' │
+│  Literal_Boolean │    2000    │ '    355 ms' │ '      5 ms' │ '   71.00 x' │
+│     Array_Number │    2000    │ '    685 ms' │ '      7 ms' │ '   97.86 x' │
+│     Array_String │    2000    │ '    716 ms' │ '     11 ms' │ '   65.09 x' │
+│    Array_Boolean │    2000    │ '    732 ms' │ '      6 ms' │ '  122.00 x' │
+│    Array_ObjectA │    2000    │ '   3503 ms' │ '     34 ms' │ '  103.03 x' │
+│    Array_ObjectB │    2000    │ '   3626 ms' │ '     38 ms' │ '   95.42 x' │
+│      Array_Tuple │    2000    │ '   2095 ms' │ '     21 ms' │ '   99.76 x' │
+│      Array_Union │    2000    │ '   1577 ms' │ '     22 ms' │ '   71.68 x' │
+│    Array_Vector4 │    2000    │ '   2172 ms' │ '     17 ms' │ '  127.76 x' │
+│    Array_Matrix4 │    2000    │ '   1468 ms' │ '     19 ms' │ '   77.26 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1098,31 +1098,31 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  1000000   │ '     37 ms' │ '      5 ms' │ '      5 ms' │ '    1.00 x' │
-│           String │  1000000   │ '     31 ms' │ '     24 ms' │ '     13 ms' │ '    1.85 x' │
-│          Boolean │  1000000   │ '     25 ms' │ '     25 ms' │ '     11 ms' │ '    2.27 x' │
-│             Null │  1000000   │ '     32 ms' │ '     26 ms' │ '     10 ms' │ '    2.60 x' │
-│            RegEx │  1000000   │ '    170 ms' │ '     48 ms' │ '     35 ms' │ '    1.37 x' │
-│          ObjectA │  1000000   │ '    564 ms' │ '     36 ms' │ '     23 ms' │ '    1.57 x' │
-│          ObjectB │  1000000   │ '   1000 ms' │ '     56 ms' │ '     40 ms' │ '    1.40 x' │
-│            Tuple │  1000000   │ '    125 ms' │ '     27 ms' │ '     13 ms' │ '    2.08 x' │
-│            Union │  1000000   │ '    316 ms' │ '     27 ms' │ '     14 ms' │ '    1.93 x' │
-│        Recursive │  1000000   │ '   3308 ms' │ '    415 ms' │ '    183 ms' │ '    2.27 x' │
-│          Vector4 │  1000000   │ '    135 ms' │ '     27 ms' │ '     12 ms' │ '    2.25 x' │
-│          Matrix4 │  1000000   │ '    658 ms' │ '     44 ms' │ '     30 ms' │ '    1.47 x' │
-│   Literal_String │  1000000   │ '     48 ms' │ '     26 ms' │ '     10 ms' │ '    2.60 x' │
-│   Literal_Number │  1000000   │ '     49 ms' │ '     31 ms' │ '      9 ms' │ '    3.44 x' │
-│  Literal_Boolean │  1000000   │ '     47 ms' │ '     28 ms' │ '     10 ms' │ '    2.80 x' │
-│     Array_Number │  1000000   │ '    418 ms' │ '     38 ms' │ '     17 ms' │ '    2.24 x' │
-│     Array_String │  1000000   │ '    466 ms' │ '     35 ms' │ '     22 ms' │ '    1.59 x' │
-│    Array_Boolean │  1000000   │ '    403 ms' │ '     41 ms' │ '     24 ms' │ '    1.71 x' │
-│    Array_ObjectA │  1000000   │ '  13596 ms' │ '   2861 ms' │ '   1759 ms' │ '    1.63 x' │
-│    Array_ObjectB │  1000000   │ '  15767 ms' │ '   2798 ms' │ '   1991 ms' │ '    1.41 x' │
-│      Array_Tuple │  1000000   │ '   1666 ms' │ '    103 ms' │ '     73 ms' │ '    1.41 x' │
-│      Array_Union │  1000000   │ '   4738 ms' │ '    229 ms' │ '     87 ms' │ '    2.63 x' │
-│  Array_Recursive │  1000000   │ '  56371 ms' │ '   7315 ms' │ '   2813 ms' │ '    2.60 x' │
-│    Array_Vector4 │  1000000   │ '   2180 ms' │ '    106 ms' │ '     53 ms' │ '    2.00 x' │
-│    Array_Matrix4 │  1000000   │ '  11795 ms' │ '    384 ms' │ '    313 ms' │ '    1.23 x' │
+│           Number │  1000000   │ '     24 ms' │ '      9 ms' │ '      6 ms' │ '    1.50 x' │
+│           String │  1000000   │ '     23 ms' │ '     19 ms' │ '     12 ms' │ '    1.58 x' │
+│          Boolean │  1000000   │ '     24 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│             Null │  1000000   │ '     23 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
+│            RegEx │  1000000   │ '    164 ms' │ '     46 ms' │ '     38 ms' │ '    1.21 x' │
+│          ObjectA │  1000000   │ '    548 ms' │ '     36 ms' │ '     22 ms' │ '    1.64 x' │
+│          ObjectB │  1000000   │ '   1118 ms' │ '     51 ms' │ '     38 ms' │ '    1.34 x' │
+│            Tuple │  1000000   │ '    136 ms' │ '     25 ms' │ '     14 ms' │ '    1.79 x' │
+│            Union │  1000000   │ '    338 ms' │ '     27 ms' │ '     16 ms' │ '    1.69 x' │
+│        Recursive │  1000000   │ '   3251 ms' │ '    416 ms' │ '     98 ms' │ '    4.24 x' │
+│          Vector4 │  1000000   │ '    146 ms' │ '     23 ms' │ '     12 ms' │ '    1.92 x' │
+│          Matrix4 │  1000000   │ '    584 ms' │ '     40 ms' │ '     25 ms' │ '    1.60 x' │
+│   Literal_String │  1000000   │ '     46 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│   Literal_Number │  1000000   │ '     46 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
+│  Literal_Boolean │  1000000   │ '     47 ms' │ '     21 ms' │ '     10 ms' │ '    2.10 x' │
+│     Array_Number │  1000000   │ '    456 ms' │ '     31 ms' │ '     19 ms' │ '    1.63 x' │
+│     Array_String │  1000000   │ '    489 ms' │ '     40 ms' │ '     25 ms' │ '    1.60 x' │
+│    Array_Boolean │  1000000   │ '    458 ms' │ '     35 ms' │ '     27 ms' │ '    1.30 x' │
+│    Array_ObjectA │  1000000   │ '  13559 ms' │ '   2568 ms' │ '   1564 ms' │ '    1.64 x' │
+│    Array_ObjectB │  1000000   │ '  15863 ms' │ '   2744 ms' │ '   2060 ms' │ '    1.33 x' │
+│      Array_Tuple │  1000000   │ '   1694 ms' │ '     96 ms' │ '     63 ms' │ '    1.52 x' │
+│      Array_Union │  1000000   │ '   4736 ms' │ '    229 ms' │ '     86 ms' │ '    2.66 x' │
+│  Array_Recursive │  1000000   │ '  53804 ms' │ '   6744 ms' │ '   1167 ms' │ '    5.78 x' │
+│    Array_Vector4 │  1000000   │ '   2244 ms' │ '     99 ms' │ '     46 ms' │ '    2.15 x' │
+│    Array_Matrix4 │  1000000   │ '  11966 ms' │ '    378 ms' │ '    229 ms' │ '    1.65 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1136,11 +1136,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '   49 kb' │ '   24 kb' │  '2.00 x'   │
+│ typebox/compiler     │ '   51 kb' │ '   25 kb' │  '2.00 x'   │
 │ typebox/conditional  │ '   42 kb' │ '   17 kb' │  '2.46 x'   │
 │ typebox/format       │ '    0 kb' │ '    0 kb' │  '2.66 x'   │
-│ typebox/guard        │ '   21 kb' │ '   10 kb' │  '2.07 x'   │
-│ typebox/value        │ '   72 kb' │ '   33 kb' │  '2.16 x'   │
+│ typebox/guard        │ '   21 kb' │ '   10 kb' │  '2.08 x'   │
+│ typebox/value        │ '   74 kb' │ '   34 kb' │  '2.16 x'   │
 │ typebox              │ '   11 kb' │ '    6 kb' │  '1.91 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 716b0974b..7ebae8990 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -187,6 +187,11 @@ export namespace TypeCompiler {
         yield `(Object.keys(${value}).every(key => ${keys}.includes(key)))`
       }
     }
+    if (TypeGuard.TSchema(schema.additionalProperties)) {
+      const expression = CreateExpression(schema.additionalProperties, 'value[key]')
+      const keys = `[${propertyKeys.map((key) => `'${key}'`).join(', ')}]`
+      yield `(Object.keys(${value}).every(key => ${keys}.includes(key) || ${expression}))`
+    }
     for (const propertyKey of propertyKeys) {
       const memberExpression = Property.Check(propertyKey) ? `${value}.${propertyKey}` : `${value}['${propertyKey}']`
       const propertySchema = schema.properties[propertyKey]
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index b681aa313..913a60226 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -226,7 +226,12 @@ export namespace ValueErrors {
         yield { type: ValueErrorType.ObjectRequiredProperties, schema: schema.properties[requiredKey], path: `${path}/${requiredKey}`, value: undefined, message: `Expected required property` }
       }
     }
-
+    if (typeof schema.additionalProperties === 'object') {
+      for (const objectKey of globalThis.Object.keys(value)) {
+        if (propertyKeys.includes(objectKey)) continue
+        yield* Visit(schema.additionalProperties as Types.TSchema, references, `${path}/${objectKey}`, value[objectKey])
+      }
+    }
     for (const propertyKey of propertyKeys) {
       const propertySchema = schema.properties[propertyKey]
       if (schema.required && schema.required.includes(propertyKey)) {
diff --git a/src/guard/guard.ts b/src/guard/guard.ts
index 01b653566..ac9d54430 100644
--- a/src/guard/guard.ts
+++ b/src/guard/guard.ts
@@ -83,17 +83,18 @@ export namespace TypeGuard {
   function IsOptionalBoolean(value: unknown): value is boolean | undefined {
     return value === undefined || (value !== undefined && IsBoolean(value))
   }
-
   function IsOptionalString(value: unknown): value is string | undefined {
     return value === undefined || (value !== undefined && IsString(value))
   }
-
   function IsOptionalPattern(value: unknown): value is string | undefined {
     return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value) && IsPattern(value))
   }
   function IsOptionalFormat(value: unknown): value is string | undefined {
     return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value))
   }
+  function IsOptionalSchema(value: unknown): value is boolean | undefined {
+    return value === undefined || TSchema(value)
+  }
   /** Returns true if the given schema is TAny */
   export function TAny(schema: unknown): schema is Types.TAny {
     return IsObject(schema) && schema[Types.Kind] === 'Any' && IsOptionalString(schema.$id)
@@ -207,7 +208,7 @@ export namespace TypeGuard {
         schema.type === 'object' &&
         IsOptionalString(schema.$id) &&
         IsObject(schema.properties) &&
-        IsOptionalBoolean(schema.additionalProperties) &&
+        (IsOptionalBoolean(schema.additionalProperties) || IsOptionalSchema(schema.additionalProperties)) &&
         IsOptionalNumber(schema.minProperties) &&
         IsOptionalNumber(schema.maxProperties)
       )
diff --git a/src/typebox.ts b/src/typebox.ts
index ec08f871a..b15fcc030 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -310,15 +310,18 @@ export type ObjectProperties<T> = T extends TObject<infer U> ? U : never
 
 export type ObjectPropertyKeys<T> = T extends TObject<infer U> ? keyof U : never
 
-export interface ObjectOptions extends SchemaOptions {
-  additionalProperties?: boolean
+export type TAdditionalProperties = undefined | TSchema | boolean
+
+export interface ObjectOptions<A extends TAdditionalProperties = undefined> extends SchemaOptions {
+  additionalProperties?: A
   minProperties?: number
   maxProperties?: number
 }
 
-export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
+export interface TObject<T extends TProperties = TProperties, A extends TAdditionalProperties = undefined> extends TSchema, ObjectOptions<A> {
   [Kind]: 'Object'
-  static: PropertiesReduce<T, this['params']>
+  static: A extends TSchema ? PropertiesReduce<T, this['params']> & Record<string, Static<A, ['params']>> : PropertiesReduce<T, this['params']>
+  additionalProperties?: A
   type: 'object'
   properties: T
   required?: string[]
@@ -726,7 +729,7 @@ export class TypeBuilder {
   }
 
   /** Creates an object type with the given properties */
-  public Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
+  public Object<T extends TProperties, A extends TAdditionalProperties = undefined>(properties: T, options: ObjectOptions<A> = {}): TObject<T, A> {
     const property_names = Object.keys(properties)
     const optional = property_names.filter((name) => {
       const property = properties[name] as TModifier
diff --git a/src/value/cast.ts b/src/value/cast.ts
index 4478b5ff5..848fed23b 100644
--- a/src/value/cast.ts
+++ b/src/value/cast.ts
@@ -240,6 +240,14 @@ export namespace ValueCast {
       if (!required.has(key) && value[key] === undefined) continue
       result[key] = Visit(property, references, value[key])
     }
+    // additional schema properties
+    if (typeof schema.additionalProperties === 'object') {
+      const propertyKeys = globalThis.Object.keys(schema.properties)
+      for (const objectKey of globalThis.Object.keys(value)) {
+        if (propertyKeys.includes(objectKey)) continue
+        result[objectKey] = Visit(schema.additionalProperties, references, value[objectKey])
+      }
+    }
     return result
   }
 
diff --git a/src/value/check.ts b/src/value/check.ts
index b4f7bafcf..302f5609d 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -150,6 +150,14 @@ export namespace ValueCheck {
         }
       }
     }
+    if (typeof schema.additionalProperties === 'object') {
+      for (const objectKey of globalThis.Object.keys(value)) {
+        if (propertyKeys.includes(objectKey)) continue
+        if (!Visit(schema.additionalProperties as Types.TSchema, references, value[objectKey])) {
+          return false
+        }
+      }
+    }
     for (const propertyKey of propertyKeys) {
       const propertySchema = schema.properties[propertyKey]
       if (schema.required && schema.required.includes(propertyKey)) {
diff --git a/test/runtime/compiler/object.ts b/test/runtime/compiler/object.ts
index 845855cd7..c6b4aa809 100644
--- a/test/runtime/compiler/object.ts
+++ b/test/runtime/compiler/object.ts
@@ -139,4 +139,70 @@ describe('type/compiler/Object', () => {
       '!@#$%^&*(': 4,
     })
   })
+
+  it('Should validate schema additional properties of string', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.String(),
+      },
+    )
+    ok(T, {
+      x: 1,
+      y: 2,
+      z: 'hello',
+    })
+    fail(T, {
+      x: 1,
+      y: 2,
+      z: 3,
+    })
+  })
+  it('Should validate schema additional properties of array', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.Array(Type.Number()),
+      },
+    )
+    ok(T, {
+      x: 1,
+      y: 2,
+      z: [0, 1, 2],
+    })
+    fail(T, {
+      x: 1,
+      y: 2,
+      z: 3,
+    })
+  })
+  it('Should validate schema additional properties of object', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.Object({
+          z: Type.Number(),
+        }),
+      },
+    )
+    ok(T, {
+      x: 1,
+      y: 2,
+      z: { z: 1 },
+    })
+    fail(T, {
+      x: 1,
+      y: 2,
+      z: 3,
+    })
+  })
 })
diff --git a/test/runtime/guard/object.ts b/test/runtime/guard/object.ts
index a4503e2c5..c34d32639 100644
--- a/test/runtime/guard/object.ts
+++ b/test/runtime/guard/object.ts
@@ -96,4 +96,35 @@ describe('type/guard/TObject', () => {
     )
     Assert.equal(R, false)
   })
+
+  it('should guard for TObject with invalid additional properties', () => {
+    const R = TypeGuard.TObject(
+      Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        {
+          // @ts-ignore
+          additionalProperties: 1,
+        },
+      ),
+    )
+    Assert.equal(R, false)
+  })
+
+  it('should not guard for TObject with valid additional properties schema', () => {
+    const R = TypeGuard.TObject(
+      Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        {
+          additionalProperties: Type.String(),
+        },
+      ),
+    )
+    Assert.equal(R, true)
+  })
 })
diff --git a/test/runtime/schema/object.ts b/test/runtime/schema/object.ts
index 188dc1076..658daea41 100644
--- a/test/runtime/schema/object.ts
+++ b/test/runtime/schema/object.ts
@@ -139,4 +139,72 @@ describe('type/schema/Object', () => {
       '!@#$%^&*(': 4,
     })
   })
+
+  it('Should validate schema additional properties of string', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.String(),
+      },
+    )
+    ok(T, {
+      x: 1,
+      y: 2,
+      z: 'hello',
+    })
+    fail(T, {
+      x: 1,
+      y: 2,
+      z: 3,
+    })
+  })
+
+  it('Should validate schema additional properties of array', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.Array(Type.Number()),
+      },
+    )
+    ok(T, {
+      x: 1,
+      y: 2,
+      z: [0, 1, 2],
+    })
+    fail(T, {
+      x: 1,
+      y: 2,
+      z: 3,
+    })
+  })
+
+  it('Should validate schema additional properties of object', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.Object({
+          z: Type.Number(),
+        }),
+      },
+    )
+    ok(T, {
+      x: 1,
+      y: 2,
+      z: { z: 1 },
+    })
+    fail(T, {
+      x: 1,
+      y: 2,
+      z: 3,
+    })
+  })
 })
diff --git a/test/runtime/value/cast/object.ts b/test/runtime/value/cast/object.ts
index bf821147b..71bd0bf01 100644
--- a/test/runtime/value/cast/object.ts
+++ b/test/runtime/value/cast/object.ts
@@ -109,4 +109,58 @@ describe('value/cast/Object', () => {
       c: 'c',
     })
   })
+
+  it('Should upcast and create invalid additional properties', () => {
+    const result = Value.Cast(
+      Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        {
+          additionalProperties: Type.Object({
+            a: Type.Number(),
+            b: Type.Number(),
+          }),
+        },
+      ),
+      {
+        x: 1,
+        y: 2,
+        z: true,
+      },
+    )
+    Assert.deepEqual(result, {
+      x: 1,
+      y: 2,
+      z: { a: 0, b: 0 },
+    })
+  })
+
+  it('Should upcast and preserve additional properties', () => {
+    const result = Value.Cast(
+      Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        {
+          additionalProperties: Type.Object({
+            a: Type.Number(),
+            b: Type.Number(),
+          }),
+        },
+      ),
+      {
+        x: 1,
+        y: 2,
+        z: { b: 1 },
+      },
+    )
+    Assert.deepEqual(result, {
+      x: 1,
+      y: 2,
+      z: { a: 0, b: 1 },
+    })
+  })
 })
diff --git a/test/runtime/value/check/object.ts b/test/runtime/value/check/object.ts
index 25ac7265f..ccd0ef10c 100644
--- a/test/runtime/value/check/object.ts
+++ b/test/runtime/value/check/object.ts
@@ -98,4 +98,96 @@ describe('value/check/Object', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
+
+  it('Should validate schema additional properties of string', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.String(),
+      },
+    )
+
+    Assert.equal(
+      Value.Check(T, {
+        x: 1,
+        y: 2,
+        z: 'hello',
+      }),
+      true,
+    )
+
+    Assert.equal(
+      Value.Check(T, {
+        x: 1,
+        y: 2,
+        z: 3,
+      }),
+      false,
+    )
+  })
+
+  it('Should validate schema additional properties of array', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.Array(Type.Number()),
+      },
+    )
+
+    Assert.equal(
+      Value.Check(T, {
+        x: 1,
+        y: 2,
+        z: [0, 1, 2],
+      }),
+      true,
+    )
+
+    Assert.equal(
+      Value.Check(T, {
+        x: 1,
+        y: 2,
+        z: 3,
+      }),
+      false,
+    )
+  })
+
+  it('Should validate schema additional properties of object', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.Object({
+          z: Type.Number(),
+        }),
+      },
+    )
+
+    Assert.equal(
+      Value.Check(T, {
+        x: 1,
+        y: 2,
+        z: { z: 1 },
+      }),
+      true,
+    )
+
+    Assert.equal(
+      Value.Check(T, {
+        x: 1,
+        y: 2,
+        z: 3,
+      }),
+      false,
+    )
+  })
 })
diff --git a/test/static/object.ts b/test/static/object.ts
index 9ed03b64a..57e58299b 100644
--- a/test/static/object.ts
+++ b/test/static/object.ts
@@ -1,5 +1,5 @@
 import { Expect } from './assert'
-import { Type } from '@sinclair/typebox'
+import { Type, Static } from '@sinclair/typebox'
 
 {
   const T = Type.Object({
@@ -50,3 +50,23 @@ import { Type } from '@sinclair/typebox'
     }
   }>()
 }
+{
+  const T = Type.Object(
+    {
+      A: Type.Number(),
+      B: Type.Number(),
+      C: Type.Number(),
+    },
+    {
+      additionalProperties: Type.Boolean(),
+    },
+  )
+  // note: the inferenced additionalProperty type does break usual structural
+  // equivelence and assignment checks, but does allow for the following usage.
+  function test(value: Static<typeof T>) {
+    value.A = 10
+    value.B = 20
+    value.C = 30
+    value.D = true // ok
+  }
+}

From 262dbfffad34b93d0fbf55f5b8220953eefe4194 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sun, 23 Oct 2022 17:59:05 +0900
Subject: [PATCH 021/369] Revert Generic AdditionalProperties Argument on
 TObject

---
 package.json          |  2 +-
 src/typebox.ts        | 12 ++++++------
 test/static/object.ts | 16 +++++++---------
 3 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/package.json b/package.json
index 3e54b2706..7080127d8 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.49",
+  "version": "0.24.50",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index b15fcc030..c38070433 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -312,16 +312,16 @@ export type ObjectPropertyKeys<T> = T extends TObject<infer U> ? keyof U : never
 
 export type TAdditionalProperties = undefined | TSchema | boolean
 
-export interface ObjectOptions<A extends TAdditionalProperties = undefined> extends SchemaOptions {
-  additionalProperties?: A
+export interface ObjectOptions extends SchemaOptions {
+  additionalProperties?: TAdditionalProperties
   minProperties?: number
   maxProperties?: number
 }
 
-export interface TObject<T extends TProperties = TProperties, A extends TAdditionalProperties = undefined> extends TSchema, ObjectOptions<A> {
+export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
   [Kind]: 'Object'
-  static: A extends TSchema ? PropertiesReduce<T, this['params']> & Record<string, Static<A, ['params']>> : PropertiesReduce<T, this['params']>
-  additionalProperties?: A
+  static: PropertiesReduce<T, this['params']>
+  additionalProperties?: TAdditionalProperties
   type: 'object'
   properties: T
   required?: string[]
@@ -729,7 +729,7 @@ export class TypeBuilder {
   }
 
   /** Creates an object type with the given properties */
-  public Object<T extends TProperties, A extends TAdditionalProperties = undefined>(properties: T, options: ObjectOptions<A> = {}): TObject<T, A> {
+  public Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
     const property_names = Object.keys(properties)
     const optional = property_names.filter((name) => {
       const property = properties[name] as TModifier
diff --git a/test/static/object.ts b/test/static/object.ts
index 57e58299b..d91856915 100644
--- a/test/static/object.ts
+++ b/test/static/object.ts
@@ -1,5 +1,5 @@
 import { Expect } from './assert'
-import { Type, Static } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
 
 {
   const T = Type.Object({
@@ -61,12 +61,10 @@ import { Type, Static } from '@sinclair/typebox'
       additionalProperties: Type.Boolean(),
     },
   )
-  // note: the inferenced additionalProperty type does break usual structural
-  // equivelence and assignment checks, but does allow for the following usage.
-  function test(value: Static<typeof T>) {
-    value.A = 10
-    value.B = 20
-    value.C = 30
-    value.D = true // ok
-  }
+  // note: Pending TypeScript support for negated types. 
+  Expect(T).ToInfer<{
+    A: number
+    B: number
+    C: number
+  }>()
 }

From 573791b382b1b725c7e486ec3f99a5068b974a70 Mon Sep 17 00:00:00 2001
From: Shane da Silva <shane@dasilva.io>
Date: Tue, 25 Oct 2022 21:53:44 -0700
Subject: [PATCH 022/369] Allow Integer keys in Record types (#266)

---
 src/typebox.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/typebox.ts b/src/typebox.ts
index c38070433..c58665205 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -380,7 +380,7 @@ export interface TPromise<T extends TSchema = TSchema> extends TSchema {
 // Record
 // --------------------------------------------------------------------------
 
-export type TRecordKey = TString | TNumber | TUnion<TLiteral<any>[]>
+export type TRecordKey = TString | TInteger | TNumber | TUnion<TLiteral<any>[]>
 
 export interface TRecord<K extends TRecordKey = TRecordKey, T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Record'
@@ -823,7 +823,7 @@ export class TypeBuilder {
   public Record<K extends TUnion<TLiteral[]>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TObject<TRecordProperties<K, T>>
 
   /** Creates a record type */
-  public Record<K extends TString | TNumber, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecord<K, T>
+  public Record<K extends TString | TInteger | TNumber, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecord<K, T>
 
   /** Creates a record type */
   public Record(key: any, value: any, options: ObjectOptions = {}) {
@@ -837,7 +837,7 @@ export class TypeBuilder {
       )
     }
     // otherwise return TRecord with patternProperties
-    const pattern = key[Kind] === 'Number' ? '^(0|[1-9][0-9]*)$' : key[Kind] === 'String' && key.pattern ? key.pattern : '^.*$'
+    const pattern = ['Integer', 'Number'].includes(key[Kind]) ? '^(0|[1-9][0-9]*)$' : key[Kind] === 'String' && key.pattern ? key.pattern : '^.*$'
     return this.Create({
       ...options,
       [Kind]: 'Record',

From d0faeabe3b3066dbb94665738411f863f7af8e64 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 26 Oct 2022 14:16:54 +0900
Subject: [PATCH 023/369] Integer Record Keys Tests

---
 package.json                       |   2 +-
 src/typebox.ts                     |   4 +-
 test/runtime/compiler/record.ts    | 108 +++++++++++++++++++----------
 test/runtime/conditional/record.ts |  32 +++++++++
 test/runtime/schema/record.ts      | 108 +++++++++++++++++++----------
 test/runtime/value/check/record.ts |  71 +++++++++++++++++++
 test/static/object.ts              |   2 +-
 test/static/record.ts              |  11 +++
 8 files changed, 264 insertions(+), 74 deletions(-)

diff --git a/package.json b/package.json
index 7080127d8..a4b4814db 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.50",
+  "version": "0.24.51",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index c58665205..4f0c98e30 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -380,7 +380,7 @@ export interface TPromise<T extends TSchema = TSchema> extends TSchema {
 // Record
 // --------------------------------------------------------------------------
 
-export type TRecordKey = TString | TInteger | TNumber | TUnion<TLiteral<any>[]>
+export type TRecordKey = TString | TNumeric | TUnion<TLiteral<any>[]>
 
 export interface TRecord<K extends TRecordKey = TRecordKey, T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Record'
@@ -823,7 +823,7 @@ export class TypeBuilder {
   public Record<K extends TUnion<TLiteral[]>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TObject<TRecordProperties<K, T>>
 
   /** Creates a record type */
-  public Record<K extends TString | TInteger | TNumber, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecord<K, T>
+  public Record<K extends TString | TNumeric, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecord<K, T>
 
   /** Creates a record type */
   public Record(key: any, value: any, options: ObjectOptions = {}) {
diff --git a/test/runtime/compiler/record.ts b/test/runtime/compiler/record.ts
index aa3384805..608919a69 100644
--- a/test/runtime/compiler/record.ts
+++ b/test/runtime/compiler/record.ts
@@ -12,41 +12,6 @@ describe('type/compiler/Record', () => {
     ok(T, { a: 1, b: 2, c: 3, '0': 4 })
   })
 
-  it('Should validate when all property keys are numbers', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
-    ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
-  })
-
-  it('Should validate when all property keys are numbers, but one property is a string with varying type', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
-    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
-  })
-
-  it('Should not validate if passing a leading zeros for numeric keys', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
-    fail(T, {
-      '00': 1,
-      '01': 2,
-      '02': 3,
-      '03': 4,
-    })
-  })
-
-  it('Should not validate if passing a signed numeric keys', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
-    fail(T, {
-      '-0': 1,
-      '-1': 2,
-      '-2': 3,
-      '-3': 4,
-    })
-  })
-
-  it('Should not validate when all property keys are numbers, but one property is a string with varying type', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
-    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
-  })
-
   it('Should validate when specifying string union literals when additionalProperties is true', () => {
     const K = Type.Union([Type.Literal('a'), Type.Literal('b'), Type.Literal('c')])
     const T = Type.Record(K, Type.Number())
@@ -98,4 +63,77 @@ describe('type/compiler/Record', () => {
       aop_c: 3,
     })
   })
+
+  // ------------------------------------------------------------
+  // Integer Keys
+  // ------------------------------------------------------------
+
+  it('Should validate when all property keys are integers', () => {
+    const T = Type.Record(Type.Integer(), Type.Number())
+    ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
+  })
+
+  it('Should validate when all property keys are integers, but one property is a string with varying type', () => {
+    const T = Type.Record(Type.Integer(), Type.Number())
+    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
+  })
+
+  it('Should not validate if passing a leading zeros for integers keys', () => {
+    const T = Type.Record(Type.Integer(), Type.Number())
+    fail(T, {
+      '00': 1,
+      '01': 2,
+      '02': 3,
+      '03': 4,
+    })
+  })
+
+  it('Should not validate if passing a signed integers keys', () => {
+    const T = Type.Record(Type.Integer(), Type.Number())
+    fail(T, {
+      '-0': 1,
+      '-1': 2,
+      '-2': 3,
+      '-3': 4,
+    })
+  })
+
+  // ------------------------------------------------------------
+  // Number Keys
+  // ------------------------------------------------------------
+
+  it('Should validate when all property keys are numbers', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
+  })
+
+  it('Should validate when all property keys are numbers, but one property is a string with varying type', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
+  })
+
+  it('Should not validate if passing a leading zeros for numeric keys', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    fail(T, {
+      '00': 1,
+      '01': 2,
+      '02': 3,
+      '03': 4,
+    })
+  })
+
+  it('Should not validate if passing a signed numeric keys', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    fail(T, {
+      '-0': 1,
+      '-1': 2,
+      '-2': 3,
+      '-3': 4,
+    })
+  })
+
+  it('Should not validate when all property keys are numbers, but one property is a string with varying type', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
+  })
 })
diff --git a/test/runtime/conditional/record.ts b/test/runtime/conditional/record.ts
index 4e4e0cb7c..48b41ec24 100644
--- a/test/runtime/conditional/record.ts
+++ b/test/runtime/conditional/record.ts
@@ -87,6 +87,38 @@ describe('conditional/structural/Record', () => {
     Assert.deepEqual(R, StructuralResult.True)
   })
 
+  // -----
+
+  it('Should extend Record 12', () => {
+    type T = Record<string, number> extends Record<number, number> ? 1 : 2
+    const A = Type.Record(Type.String(), Type.Number())
+    const B = Type.Record(Type.Integer(), Type.Number())
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+  it('Should extend Record 13', () => {
+    type T = Record<number, number> extends Record<'a' | 'b', number> ? 1 : 2
+    const A = Type.Record(Type.Integer(), Type.Number())
+    const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Record 14', () => {
+    type T = Record<number, number> extends Record<string, number> ? 1 : 2
+    const A = Type.Record(Type.Integer(), Type.Number())
+    const B = Type.Record(Type.String(), Type.Number())
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Record 15', () => {
+    type T = Record<number, number> extends Record<number, number> ? 1 : 2
+    const A = Type.Record(Type.Integer(), Type.Number())
+    const B = Type.Record(Type.Integer(), Type.Number())
+    const R = Structural.Check(A, B)
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
   // -------------------------------------------------------------------
   // Standard
   // -------------------------------------------------------------------
diff --git a/test/runtime/schema/record.ts b/test/runtime/schema/record.ts
index d88819c94..4f93b89c6 100644
--- a/test/runtime/schema/record.ts
+++ b/test/runtime/schema/record.ts
@@ -12,41 +12,6 @@ describe('type/schema/Record', () => {
     ok(T, { a: 1, b: 2, c: 3, '0': 4 })
   })
 
-  it('Should validate when all property keys are numbers', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
-    ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
-  })
-
-  it('Should validate when all property keys are numbers, but one property is a string with varying type', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
-    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
-  })
-
-  it('Should not validate if passing a leading zeros for numeric keys', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
-    fail(T, {
-      '00': 1,
-      '01': 2,
-      '02': 3,
-      '03': 4,
-    })
-  })
-
-  it('Should not validate if passing a signed numeric keys', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
-    fail(T, {
-      '-0': 1,
-      '-1': 2,
-      '-2': 3,
-      '-3': 4,
-    })
-  })
-
-  it('Should not validate when all property keys are numbers, but one property is a string with varying type', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
-    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
-  })
-
   it('Should validate when specifying string union literals when additionalProperties is true', () => {
     const K = Type.Union([Type.Literal('a'), Type.Literal('b'), Type.Literal('c')])
     const T = Type.Record(K, Type.Number())
@@ -98,4 +63,77 @@ describe('type/schema/Record', () => {
       aop_c: 3,
     })
   })
+
+  // ------------------------------------------------------------
+  // Integer Keys
+  // ------------------------------------------------------------
+
+  it('Should validate when all property keys are integers', () => {
+    const T = Type.Record(Type.Integer(), Type.Number())
+    ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
+  })
+
+  it('Should validate when all property keys are integers, but one property is a string with varying type', () => {
+    const T = Type.Record(Type.Integer(), Type.Number())
+    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
+  })
+
+  it('Should not validate if passing a leading zeros for integers keys', () => {
+    const T = Type.Record(Type.Integer(), Type.Number())
+    fail(T, {
+      '00': 1,
+      '01': 2,
+      '02': 3,
+      '03': 4,
+    })
+  })
+
+  it('Should not validate if passing a signed integers keys', () => {
+    const T = Type.Record(Type.Integer(), Type.Number())
+    fail(T, {
+      '-0': 1,
+      '-1': 2,
+      '-2': 3,
+      '-3': 4,
+    })
+  })
+
+  // ------------------------------------------------------------
+  // Number Keys
+  // ------------------------------------------------------------
+
+  it('Should validate when all property keys are numbers', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
+  })
+
+  it('Should validate when all property keys are numbers, but one property is a string with varying type', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
+  })
+
+  it('Should not validate if passing a leading zeros for numeric keys', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    fail(T, {
+      '00': 1,
+      '01': 2,
+      '02': 3,
+      '03': 4,
+    })
+  })
+
+  it('Should not validate if passing a signed numeric keys', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    fail(T, {
+      '-0': 1,
+      '-1': 2,
+      '-2': 3,
+      '-3': 4,
+    })
+  })
+
+  it('Should not validate when all property keys are numbers, but one property is a string with varying type', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
+  })
 })
diff --git a/test/runtime/value/check/record.ts b/test/runtime/value/check/record.ts
index fe58df049..86d3d38e6 100644
--- a/test/runtime/value/check/record.ts
+++ b/test/runtime/value/check/record.ts
@@ -80,4 +80,75 @@ describe('value/check/Record', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, true)
   })
+
+  it('Should pass record with optional property', () => {
+    const T = Type.Record(
+      Type.String(),
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Optional(Type.Number()),
+      }),
+    )
+    const value = {
+      position: {
+        x: 1,
+        y: 2,
+      },
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  // -------------------------------------------------
+  // Number Key
+  // -------------------------------------------------
+
+  it('Should pass record with number key', () => {
+    const T = Type.Record(Type.Number(), Type.String())
+    const value = {
+      0: 'a',
+      1: 'a',
+      2: 'a',
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should not pass record with invalid number key', () => {
+    const T = Type.Record(Type.Number(), Type.String())
+    const value = {
+      a: 'a',
+      1: 'a',
+      2: 'a',
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  // -------------------------------------------------
+  // Integer Key
+  // -------------------------------------------------
+
+  it('Should pass record with integer key', () => {
+    const T = Type.Record(Type.Integer(), Type.String())
+    const value = {
+      0: 'a',
+      1: 'a',
+      2: 'a',
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should not pass record with invalid integer key', () => {
+    const T = Type.Record(Type.Integer(), Type.String())
+    const value = {
+      a: 'a',
+      1: 'a',
+      2: 'a',
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
 })
diff --git a/test/static/object.ts b/test/static/object.ts
index d91856915..c9d57419c 100644
--- a/test/static/object.ts
+++ b/test/static/object.ts
@@ -61,7 +61,7 @@ import { Type } from '@sinclair/typebox'
       additionalProperties: Type.Boolean(),
     },
   )
-  // note: Pending TypeScript support for negated types. 
+  // note: Pending TypeScript support for negated types.
   Expect(T).ToInfer<{
     A: number
     B: number
diff --git a/test/static/record.ts b/test/static/record.ts
index 928c052fa..207e30d3f 100644
--- a/test/static/record.ts
+++ b/test/static/record.ts
@@ -59,3 +59,14 @@ import { Type, Static } from '@sinclair/typebox'
   type T = Static<typeof T>
   Expect(T).ToInfer<Record<'A' | 'B', number>>()
 }
+
+{
+  const T = Type.Record(Type.Number(), Type.String())
+
+  Expect(T).ToInfer<Record<number, string>>()
+}
+{
+  const T = Type.Record(Type.Integer(), Type.String())
+
+  Expect(T).ToInfer<Record<number, string>>()
+}

From 16f65512f3eca8916c9b91805b79ccf712108763 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 29 Oct 2022 04:54:57 +0900
Subject: [PATCH 024/369] TypeBox 0.25.0 (#271)

---
 changelog.md                                  |   9 +
 example/index.ts                              |   2 +-
 package.json                                  |   2 +-
 readme.md                                     | 406 +++++++++++-------
 src/compiler/compiler.ts                      |  18 +-
 src/conditional/structural.ts                 |  18 +
 src/errors/errors.ts                          |  25 ++
 src/guard/guard.ts                            | 145 ++++++-
 src/typebox.ts                                | 151 ++++---
 src/value/cast.ts                             |   8 +-
 src/value/check.ts                            |  27 +-
 src/value/clone.ts                            |  16 +-
 src/value/create.ts                           |  12 +
 src/value/delta.ts                            |   7 +
 src/value/equal.ts                            |   6 +
 src/value/is.ts                               |   6 +-
 test/runtime/compiler/date.ts                 |  61 +++
 test/runtime/compiler/index.ts                |   2 +
 test/runtime/compiler/integer.ts              |  67 +++
 test/runtime/compiler/number.ts               |  30 ++
 test/runtime/conditional/any.ts               |   6 +
 test/runtime/conditional/array.ts             |   6 +
 test/runtime/conditional/boolean.ts           |   6 +
 test/runtime/conditional/constructor.ts       |   7 +
 test/runtime/conditional/date.ts              | 118 +++++
 test/runtime/conditional/function.ts          |   6 +
 test/runtime/conditional/index.ts             |   1 +
 test/runtime/conditional/integer.ts           |   7 +
 test/runtime/conditional/literal.ts           |   6 +
 test/runtime/conditional/null.ts              |   6 +
 test/runtime/conditional/number.ts            |   8 +
 test/runtime/conditional/object.ts            |   6 +
 test/runtime/conditional/promise.ts           |   6 +
 test/runtime/conditional/record.ts            |  25 ++
 test/runtime/conditional/string.ts            |   6 +
 test/runtime/conditional/tuple.ts             |   7 +
 test/runtime/conditional/uint8array.ts        |   7 +
 test/runtime/conditional/undefined.ts         |   7 +
 test/runtime/conditional/union.ts             |  12 +
 test/runtime/conditional/unknown.ts           |   6 +
 test/runtime/conditional/void.ts              |   6 +
 test/runtime/guard/any.ts                     |   6 +-
 test/runtime/guard/array.ts                   |  16 +-
 test/runtime/guard/boolean.ts                 |   6 +-
 test/runtime/guard/constructor.ts             |  14 +-
 test/runtime/guard/date.ts                    |  45 ++
 test/runtime/guard/function.ts                |  14 +-
 test/runtime/guard/index.ts                   |   1 +
 test/runtime/guard/integer.ts                 |  16 +-
 test/runtime/guard/literal.ts                 |  12 +-
 test/runtime/guard/null.ts                    |   6 +-
 test/runtime/guard/number.ts                  |  16 +-
 test/runtime/guard/object.ts                  |  20 +-
 test/runtime/guard/promise.ts                 |  10 +-
 test/runtime/guard/record.ts                  |  12 +-
 test/runtime/guard/ref.ts                     |   6 +-
 test/runtime/guard/self.ts                    |   4 +-
 test/runtime/guard/string.ts                  |  12 +-
 test/runtime/guard/tuple.ts                   |   8 +-
 test/runtime/guard/uint8array.ts              |  10 +-
 test/runtime/guard/undefined.ts               |   6 +-
 test/runtime/guard/union.ts                   |  10 +-
 test/runtime/guard/unknown.ts                 |   6 +-
 test/runtime/guard/void.ts                    |   6 +-
 test/runtime/schema/date.ts                   |  62 +++
 test/runtime/schema/index.ts                  |   3 +
 test/runtime/schema/integer.ts                |  67 +++
 test/runtime/schema/number.ts                 |  30 ++
 test/runtime/schema/uint8array.ts             |  56 +++
 test/runtime/schema/validate.ts               |  42 +-
 test/runtime/value/cast/any.ts                |   8 +
 test/runtime/value/cast/array.ts              |   6 +
 test/runtime/value/cast/boolean.ts            |   6 +
 test/runtime/value/cast/date.ts               |  56 +++
 test/runtime/value/cast/enum.ts               |  10 +
 test/runtime/value/cast/index.ts              |   4 +-
 test/runtime/value/cast/integer.ts            |   9 +
 test/runtime/value/cast/intersect.ts          |   9 +
 test/runtime/value/cast/keyof.ts              |   6 +
 test/runtime/value/cast/literal.ts            |   9 +
 test/runtime/value/cast/namespace.ts          |   0
 test/runtime/value/cast/never.ts              |   4 +
 test/runtime/value/cast/null.ts               |   9 +
 test/runtime/value/cast/number.ts             |   9 +
 test/runtime/value/cast/object.ts             |   7 +
 test/runtime/value/cast/record.ts             |   7 +
 .../value/cast/{rec.ts => recursive.ts}       |   8 +
 test/runtime/value/cast/regex.ts              |   9 +
 test/runtime/value/cast/string.ts             |   7 +
 test/runtime/value/cast/tuple.ts              |   6 +
 test/runtime/value/cast/uint8array.ts         |   9 +
 test/runtime/value/cast/undefined.ts          |   9 +
 test/runtime/value/cast/union.ts              |   9 +
 test/runtime/value/cast/unknown.ts            |  11 +
 test/runtime/value/cast/void.ts               |   9 +
 test/runtime/value/check/any.ts               |   5 +
 test/runtime/value/check/array.ts             |   5 +
 test/runtime/value/check/boolean.ts           |   5 +
 test/runtime/value/check/date.ts              |  47 ++
 test/runtime/value/check/enum.ts              |   5 +
 test/runtime/value/check/index.ts             |   3 +-
 test/runtime/value/check/integer.ts           |   5 +
 test/runtime/value/check/null.ts              |   5 +
 test/runtime/value/check/number.ts            |   5 +
 .../value/check/{rec.ts => recursive.ts}      |   0
 test/runtime/value/check/string.ts            |   5 +
 test/runtime/value/check/uint8array.ts        |   8 +-
 test/runtime/value/check/undefined.ts         |   5 +
 test/runtime/value/check/unknown.ts           |   5 +
 test/runtime/value/check/void.ts              |   5 +
 test/static/constructor-parameters.ts         |  13 +
 test/static/constructor.ts                    |  11 +
 test/static/date.ts                           |   4 +
 test/static/function.ts                       |  11 +
 test/static/index.ts                          |   1 +
 test/static/parameters.ts                     |  13 +
 116 files changed, 1834 insertions(+), 373 deletions(-)
 create mode 100644 test/runtime/compiler/date.ts
 create mode 100644 test/runtime/compiler/integer.ts
 create mode 100644 test/runtime/conditional/date.ts
 create mode 100644 test/runtime/guard/date.ts
 create mode 100644 test/runtime/schema/date.ts
 create mode 100644 test/runtime/schema/integer.ts
 create mode 100644 test/runtime/schema/uint8array.ts
 create mode 100644 test/runtime/value/cast/date.ts
 delete mode 100644 test/runtime/value/cast/namespace.ts
 rename test/runtime/value/cast/{rec.ts => recursive.ts} (94%)
 create mode 100644 test/runtime/value/check/date.ts
 rename test/runtime/value/check/{rec.ts => recursive.ts} (100%)
 create mode 100644 test/static/constructor-parameters.ts
 create mode 100644 test/static/constructor.ts
 create mode 100644 test/static/date.ts
 create mode 100644 test/static/function.ts
 create mode 100644 test/static/parameters.ts

diff --git a/changelog.md b/changelog.md
index 220a9cfac..660e2863f 100644
--- a/changelog.md
+++ b/changelog.md
@@ -1,6 +1,15 @@
+## [0.25.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.0)
+
+Updates:
+
+- [271](https://github.com/sinclairzx81/typebox/pull/271) Adds a new non-standard `Type.Date()` type. This type joins the existing `Type.UInt8Array()` as a promoted extended type used to represent core JavaScript primitives. It's inclusion was prompted by end user requirements to validate Date objects prior to writing them to Date supported API's and where serialization of the Date object is handled internally by the API. 
+
+- [271](https://github.com/sinclairzx81/typebox/pull/271) Redesign of Extended Type representations. Extended types been updated to provide external validators (such as Ajv) additional standard proporties to use when defining the custom schema. These properties are `instanceOf` (used for validating a class `object` instances), and `typeOf` (when validating `value` types). Information on configuring Ajv for these properties can be found in the Ajv section of the TypeBox readme.
+
 ## [0.24.49](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.49)
 
 Updates:
+
 - [264](https://github.com/sinclairzx81/typebox/pull/264) TypeBox now provides preliminary support for non-boolean `additionalProperties`. This allows existing `TObject` schemas to be augmented with additional properties of a known type.
 
 Additional:
diff --git a/example/index.ts b/example/index.ts
index fe4d20dc7..987d926be 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -4,7 +4,7 @@ import { Conditional } from '@sinclair/typebox/conditional'
 import { TypeGuard } from '@sinclair/typebox/guard'
 import { Format } from '@sinclair/typebox/format'
 import { Value, ValuePointer } from '@sinclair/typebox/value'
-import { Type, Static } from '@sinclair/typebox'
+import { Type, Static, TSchema } from '@sinclair/typebox'
 
 const T = Type.Object({
   x: Type.Number(),
diff --git a/package.json b/package.json
index a4b4814db..fbc4bf63f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.51",
+  "version": "0.25.0",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index a5bc4caa5..60ec68e6c 100644
--- a/readme.md
+++ b/readme.md
@@ -56,10 +56,10 @@ License MIT
 - [Overview](#overview)
 - [Usage](#usage)
 - [Types](#types)
-  - [Standard](#types-standard)
+  - [Standard Types](#types-standard)
+  - [Extended Types](#types-extended)
   - [Modifiers](#types-modifiers)
   - [Options](#types-options)
-  - [Extended](#types-extended)
   - [Reference](#types-reference)
   - [Recursive](#types-recursive)
   - [Generic](#types-generic)
@@ -79,7 +79,7 @@ License MIT
   - [Pointer](#values-pointer)
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
-  - [Compiler](#typecheck-compiler)
+  - [TypeCompiler](#typecheck-typecompiler)
   - [Formats](#typecheck-formats)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
@@ -170,9 +170,9 @@ TypeBox provides a set of functions that allow you to compose JSON Schema simila
 
 <a name='types-standard'></a>
 
-### Standard
+### Standard Types
 
-The following table lists the standard TypeBox types.
+The following table lists the Standard TypeBox types.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
@@ -375,6 +375,81 @@ The following table lists the standard TypeBox types.
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
+<a name='types-extended'></a>
+
+### Extended Types
+
+TypeBox provides a set of extended types that can be used to express schematics for core JavaScript constructs and primitives. Extended types are not valid JSON Schema and will not validate using typical validation. These types however can be used to frame JSON schema and describe callable RPC interfaces that may receive JSON validated data.
+
+```typescript
+┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
+│ TypeBox                        │ TypeScript                  │ Extended Schema                │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Constructor([   │ type T = new (              │ const T = {                    │
+│   Type.String(),               │  arg0: string,              │   type: 'object',              │
+│   Type.Number()                │  arg1: number               │   instanceOf: 'Constructor',   │
+│ ], Type.Boolean())             │ ) => boolean                │   parameters: [{               │
+│                                │                             │     type: 'string'             │
+│                                │                             │   }, {                         │
+│                                │                             │     type: 'number'             │
+│                                │                             │   }],                          │
+│                                │                             │   return: {                    │
+│                                │                             │     type: 'boolean'            │
+│                                │                             │   }                            │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Function([      │ type T = (                  │ const T = {                    │
+|   Type.String(),               │  arg0: string,              │   type : 'object',             │
+│   Type.Number()                │  arg1: number               │   instanceOf: 'Function',      │
+│ ], Type.Boolean())             │ ) => boolean                │   parameters: [{               │
+│                                │                             │     type: 'string'             │
+│                                │                             │   }, {                         │
+│                                │                             │     type: 'number'             │
+│                                │                             │   }],                          │
+│                                │                             │   return: {                    │
+│                                │                             │     type: 'boolean'            │
+│                                │                             │   }                            │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Promise(        │ type T = Promise<string>    │ const T = {                    │
+│   Type.String()                │                             │   type: 'object',              │
+│ )                              │                             │   instanceOf: 'Promise',       │
+│                                │                             │   item: {                      │
+│                                │                             │     type: 'string'             │
+│                                │                             │   }                            │
+│                                │                             │ }                              │
+│                                │                             │                                │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Uint8Array()    │ type T = Uint8Array         │ const T = {                    │
+│                                │                             │   type: 'object',              │
+│                                │                             │   instanceOf: 'Uint8Array'     │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Date()          │ type T = Date               │ const T = {                    │
+│                                │                             │   type: 'object',              │
+│                                │                             │   instanceOf: 'Date'           │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Undefined()     │ type T = undefined          │ const T = {                    │
+│                                │                             │   type: 'null',                │
+│                                │                             │   typeOf: 'Undefined'          │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Void()          │ type T = void               │ const T = {                    │
+│                                │                             │   type: 'null'                 │
+│                                │                             │   typeOf: 'Void'               │
+│                                │                             │ }                              │
+│                                │                             │                                │
+└────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
+```
+
 <a name='types-modifiers'></a>
 
 ### Modifiers
@@ -436,70 +511,6 @@ const T = Type.Number({ multipleOf: 2 })
 const T = Type.Array(Type.Integer(), { minItems: 5 })
 ```
 
-<a name='types-extended'></a>
-
-### Extended
-
-In addition to JSON schema types, TypeBox provides several extended types that allow for the composition of `function` and `constructor` types. These additional types are not valid JSON Schema and will not validate using typical JSON Schema validation. However, these types can be used to frame JSON schema and describe callable interfaces that may receive JSON validated data. These types are as follows.
-
-```typescript
-┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
-│ TypeBox                        │ TypeScript                  │ Extended Schema                │
-│                                │                             │                                │
-├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Constructor([   │ type T = new (              │ const T = {                    │
-│   Type.String(),               │  arg0: string,              │   type: 'constructor'          │
-│   Type.Number()                │  arg1: number               │   parameters: [{               │
-│ ], Type.Boolean())             │ ) => boolean                │     type: 'string'             │
-│                                │                             │   }, {                         │
-│                                │                             │     type: 'number'             │
-│                                │                             │   }],                          │
-│                                │                             │   return: {                    │
-│                                │                             │     type: 'boolean'            │
-│                                │                             │   }                            │
-│                                │                             │ }                              │
-│                                │                             │                                │
-├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Function([      │ type T = (                  │ const T = {                    │
-|   Type.String(),               │  arg0: string,              │   type : 'function',           │
-│   Type.Number()                │  arg1: number               │   parameters: [{               │
-│ ], Type.Boolean())             │ ) => boolean                │     type: 'string'             │
-│                                │                             │   }, {                         │
-│                                │                             │     type: 'number'             │
-│                                │                             │   }],                          │
-│                                │                             │   return: {                    │
-│                                │                             │     type: 'boolean'            │
-│                                │                             │   }                            │
-│                                │                             │ }                              │
-│                                │                             │                                │
-├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Uint8Array()    │ type T = Uint8Array         │ const T = {                    │
-│                                │                             │   type: 'object',              │
-│                                │                             │   specialized: 'Uint8Array'    │
-│                                │                             │ }                              │
-│                                │                             │                                │
-├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Promise(        │ type T = Promise<string>    │ const T = {                    │
-│   Type.String()                │                             │   type: 'promise',             │
-│ )                              │                             │   item: {                      │
-│                                │                             │     type: 'string'             │
-│                                │                             │   }                            │
-│                                │                             │ }                              │
-│                                │                             │                                │
-├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Undefined()     │ type T = undefined          │ const T = {                    │
-│                                │                             │   type: 'object',              │
-│                                │                             │   specialized: 'Undefined'     │
-│                                │                             │ }                              │
-│                                │                             │                                │
-├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Void()          │ type T = void               │ const T = {                    │
-│                                │                             │   type: 'null'                 │
-│                                │                             │ }                              │
-│                                │                             │                                │
-└────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
-```
-
 <a name='types-reference'></a>
 
 ### Reference
@@ -890,70 +901,143 @@ ValuePointer.Set(A, '/z', 1)                         // const A = { x: 1, y: 1,
 
 ## TypeCheck
 
-TypeBox is written to target JSON Schema Draft 6 and can be used with any Draft 6 compliant validator. TypeBox is developed and tested against Ajv and can be used in any application already making use of this validator. Additionally, TypeBox also provides an optional type compiler that can be used to attain improved compilation and validation performance for certain application types.
+TypeBox targets JSON Schema Draft 6 and is built and tested against the Ajv JSON Schema validator for standards compliance. TypeBox also includes an optional built-in TypeCompiler that can provide improved compilation and validation performance specifically for TypeBox types only.
+
+The following sections detail using these validators.
 
 <a name='typecheck-ajv'></a>
 
 ### Ajv
 
-The following example shows setting up Ajv to work with TypeBox. 
+The following are the recommended configurations to support both the [Standard](#standard) and [Extended](#extended) type sets provided by TypeBox. For schema portability and publishing to remote systems, it is recommended to use the Standard type set only.
 
 ```bash
 $ npm install ajv ajv-formats --save
 ```
 
+<details>
+
+<summary>
+<strong>Standard Ajv Configuration</strong>
+<p>Expand for Standard Type Set Configuration</p>
+</summary>
+
 ```typescript
 import { Type }   from '@sinclair/typebox'
 import addFormats from 'ajv-formats'
 import Ajv        from 'ajv'
 
-//--------------------------------------------------------------------------------------------
-//
-// Setup Ajv validator with the following options and formats
-//
-//--------------------------------------------------------------------------------------------
-
-const ajv = addFormats(new Ajv({}), [
-  'date-time', 
-  'time', 
-  'date', 
-  'email',  
-  'hostname', 
-  'ipv4', 
-  'ipv6', 
-  'uri', 
-  'uri-reference', 
-  'uuid',
-  'uri-template', 
-  'json-pointer', 
-  'relative-json-pointer', 
-  'regex'
-])
+export function createAjv() {
+  return addFormats(new Ajv({}), [
+    'date-time', 
+    'time', 
+    'date', 
+    'email',  
+    'hostname', 
+    'ipv4', 
+    'ipv6', 
+    'uri', 
+    'uri-reference', 
+    'uuid',
+    'uri-template', 
+    'json-pointer', 
+    'relative-json-pointer', 
+    'regex'
+  ])
+}
 
-//--------------------------------------------------------------------------------------------
-//
-// Create a TypeBox type
-//
-//--------------------------------------------------------------------------------------------
+const ajv = createAjv()
 
-const T = Type.Object({
+const R = ajv.validate(Type.Object({                 // const R = true
   x: Type.Number(),
   y: Type.Number(),
   z: Type.Number()
-})
+}), { x: 1, y: 2, z: 3 })     
+```
 
-//--------------------------------------------------------------------------------------------
-//
-// Validate Data
-//
-//--------------------------------------------------------------------------------------------
+</details>
+
+<details>
 
-const R = ajv.validate(T, { x: 1, y: 2, z: 3 })      // const R = true
+<summary>
+<strong>Extended Ajv Configuration</strong>
+<p>Expand for Extended Type Set Configuration</p>
+</summary>
+
+```typescript
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Value }     from '@sinclair/typebox/value'
+import { Type }      from '@sinclair/typebox'
+import addFormats    from 'ajv-formats'
+import Ajv           from 'ajv'
+
+function schemaOf(schemaOf: string, value: unknown, schema: unknown) {
+  switch (schemaOf) {
+    case 'Constructor':
+      return TypeGuard.TConstructor(schema) && Value.Check(schema, value) // not supported
+    case 'Function':
+      return TypeGuard.TFunction(schema) && Value.Check(schema, value) // not supported
+    case 'Date':
+      return TypeGuard.TDate(schema) && Value.Check(schema, value)
+    case 'Promise':
+      return TypeGuard.TPromise(schema) && Value.Check(schema, value) // not supported
+    case 'Uint8Array':
+      return TypeGuard.TUint8Array(schema) && Value.Check(schema, value)
+    case 'Undefined':
+      return TypeGuard.TUndefined(schema) && Value.Check(schema, value) // not supported
+    case 'Void':
+      return TypeGuard.TVoid(schema) && Value.Check(schema, value)
+    default:
+      return false
+  }
+}
+
+export function createAjv() {
+  return addFormats(new Ajv({}), [
+    'date-time', 
+    'time', 
+    'date', 
+    'email',  
+    'hostname', 
+    'ipv4', 
+    'ipv6', 
+    'uri', 
+    'uri-reference', 
+    'uuid',
+    'uri-template', 
+    'json-pointer', 
+    'relative-json-pointer', 
+    'regex'
+  ])
+  .addKeyword({ type: 'object', keyword: 'instanceOf', validate: schemaOf })
+  .addKeyword({ type: 'null', keyword: 'typeOf', validate: schemaOf })
+  .addKeyword('exclusiveMinimumTimestamp')
+  .addKeyword('exclusiveMaximumTimestamp')
+  .addKeyword('minimumTimestamp')
+  .addKeyword('maximumTimestamp')
+  .addKeyword('minByteLength')
+  .addKeyword('maxByteLength')
+}
+
+const ajv = createAjv()
+
+const R = ajv.validate(Type.Object({                 // const R = true
+  buffer: Type.Uint8Array(),
+  date: Type.Date(),
+  void: Type.Void()
+}), {
+  buffer: new Uint8Array(),
+  date: new Date(),
+  void: null
+})
 ```
 
-<a name='typecheck-compiler'></a>
+</details>
+
+
+<a name='typecheck-typecompiler'></a>
 
-### Compiler
+### TypeCompiler
 
 TypeBox provides an optional high performance just-in-time (JIT) compiler and type checker that can be used in applications that require extremely fast validation. Note that this compiler is optimized for TypeBox types only where the schematics are known in advance. If defining custom types with `Type.Unsafe<T>` please consider Ajv.
 
@@ -1062,29 +1146,29 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    428 ms' │ '     12 ms' │ '   35.67 x' │
-│           String │    2000    │ '    337 ms' │ '     12 ms' │ '   28.08 x' │
-│          Boolean │    2000    │ '    317 ms' │ '     11 ms' │ '   28.82 x' │
-│             Null │    2000    │ '    274 ms' │ '     10 ms' │ '   27.40 x' │
-│            RegEx │    2000    │ '    500 ms' │ '     18 ms' │ '   27.78 x' │
-│          ObjectA │    2000    │ '   2717 ms' │ '     49 ms' │ '   55.45 x' │
-│          ObjectB │    2000    │ '   2854 ms' │ '     37 ms' │ '   77.14 x' │
-│            Tuple │    2000    │ '   1224 ms' │ '     21 ms' │ '   58.29 x' │
-│            Union │    2000    │ '   1266 ms' │ '     23 ms' │ '   55.04 x' │
-│          Vector4 │    2000    │ '   1513 ms' │ '     19 ms' │ '   79.63 x' │
-│          Matrix4 │    2000    │ '    841 ms' │ '     12 ms' │ '   70.08 x' │
-│   Literal_String │    2000    │ '    327 ms' │ '      8 ms' │ '   40.88 x' │
-│   Literal_Number │    2000    │ '    358 ms' │ '      6 ms' │ '   59.67 x' │
-│  Literal_Boolean │    2000    │ '    355 ms' │ '      5 ms' │ '   71.00 x' │
-│     Array_Number │    2000    │ '    685 ms' │ '      7 ms' │ '   97.86 x' │
-│     Array_String │    2000    │ '    716 ms' │ '     11 ms' │ '   65.09 x' │
-│    Array_Boolean │    2000    │ '    732 ms' │ '      6 ms' │ '  122.00 x' │
-│    Array_ObjectA │    2000    │ '   3503 ms' │ '     34 ms' │ '  103.03 x' │
-│    Array_ObjectB │    2000    │ '   3626 ms' │ '     38 ms' │ '   95.42 x' │
-│      Array_Tuple │    2000    │ '   2095 ms' │ '     21 ms' │ '   99.76 x' │
-│      Array_Union │    2000    │ '   1577 ms' │ '     22 ms' │ '   71.68 x' │
-│    Array_Vector4 │    2000    │ '   2172 ms' │ '     17 ms' │ '  127.76 x' │
-│    Array_Matrix4 │    2000    │ '   1468 ms' │ '     19 ms' │ '   77.26 x' │
+│           Number │    2000    │ '    421 ms' │ '     11 ms' │ '   38.27 x' │
+│           String │    2000    │ '    332 ms' │ '     11 ms' │ '   30.18 x' │
+│          Boolean │    2000    │ '    291 ms' │ '     12 ms' │ '   24.25 x' │
+│             Null │    2000    │ '    266 ms' │ '      9 ms' │ '   29.56 x' │
+│            RegEx │    2000    │ '    486 ms' │ '     17 ms' │ '   28.59 x' │
+│          ObjectA │    2000    │ '   2791 ms' │ '     50 ms' │ '   55.82 x' │
+│          ObjectB │    2000    │ '   2896 ms' │ '     37 ms' │ '   78.27 x' │
+│            Tuple │    2000    │ '   1244 ms' │ '     21 ms' │ '   59.24 x' │
+│            Union │    2000    │ '   1258 ms' │ '     25 ms' │ '   50.32 x' │
+│          Vector4 │    2000    │ '   1513 ms' │ '     21 ms' │ '   72.05 x' │
+│          Matrix4 │    2000    │ '    850 ms' │ '     11 ms' │ '   77.27 x' │
+│   Literal_String │    2000    │ '    335 ms' │ '      7 ms' │ '   47.86 x' │
+│   Literal_Number │    2000    │ '    358 ms' │ '      7 ms' │ '   51.14 x' │
+│  Literal_Boolean │    2000    │ '    356 ms' │ '      7 ms' │ '   50.86 x' │
+│     Array_Number │    2000    │ '    689 ms' │ '      9 ms' │ '   76.56 x' │
+│     Array_String │    2000    │ '    728 ms' │ '     12 ms' │ '   60.67 x' │
+│    Array_Boolean │    2000    │ '    726 ms' │ '      7 ms' │ '  103.71 x' │
+│    Array_ObjectA │    2000    │ '   3631 ms' │ '     35 ms' │ '  103.74 x' │
+│    Array_ObjectB │    2000    │ '   3636 ms' │ '     40 ms' │ '   90.90 x' │
+│      Array_Tuple │    2000    │ '   2119 ms' │ '     31 ms' │ '   68.35 x' │
+│      Array_Union │    2000    │ '   1550 ms' │ '     23 ms' │ '   67.39 x' │
+│    Array_Vector4 │    2000    │ '   2200 ms' │ '     18 ms' │ '  122.22 x' │
+│    Array_Matrix4 │    2000    │ '   1494 ms' │ '     14 ms' │ '  106.71 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1098,31 +1182,31 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  1000000   │ '     24 ms' │ '      9 ms' │ '      6 ms' │ '    1.50 x' │
-│           String │  1000000   │ '     23 ms' │ '     19 ms' │ '     12 ms' │ '    1.58 x' │
-│          Boolean │  1000000   │ '     24 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│             Null │  1000000   │ '     23 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
-│            RegEx │  1000000   │ '    164 ms' │ '     46 ms' │ '     38 ms' │ '    1.21 x' │
-│          ObjectA │  1000000   │ '    548 ms' │ '     36 ms' │ '     22 ms' │ '    1.64 x' │
-│          ObjectB │  1000000   │ '   1118 ms' │ '     51 ms' │ '     38 ms' │ '    1.34 x' │
-│            Tuple │  1000000   │ '    136 ms' │ '     25 ms' │ '     14 ms' │ '    1.79 x' │
-│            Union │  1000000   │ '    338 ms' │ '     27 ms' │ '     16 ms' │ '    1.69 x' │
-│        Recursive │  1000000   │ '   3251 ms' │ '    416 ms' │ '     98 ms' │ '    4.24 x' │
-│          Vector4 │  1000000   │ '    146 ms' │ '     23 ms' │ '     12 ms' │ '    1.92 x' │
-│          Matrix4 │  1000000   │ '    584 ms' │ '     40 ms' │ '     25 ms' │ '    1.60 x' │
-│   Literal_String │  1000000   │ '     46 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│   Literal_Number │  1000000   │ '     46 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
-│  Literal_Boolean │  1000000   │ '     47 ms' │ '     21 ms' │ '     10 ms' │ '    2.10 x' │
-│     Array_Number │  1000000   │ '    456 ms' │ '     31 ms' │ '     19 ms' │ '    1.63 x' │
-│     Array_String │  1000000   │ '    489 ms' │ '     40 ms' │ '     25 ms' │ '    1.60 x' │
-│    Array_Boolean │  1000000   │ '    458 ms' │ '     35 ms' │ '     27 ms' │ '    1.30 x' │
-│    Array_ObjectA │  1000000   │ '  13559 ms' │ '   2568 ms' │ '   1564 ms' │ '    1.64 x' │
-│    Array_ObjectB │  1000000   │ '  15863 ms' │ '   2744 ms' │ '   2060 ms' │ '    1.33 x' │
-│      Array_Tuple │  1000000   │ '   1694 ms' │ '     96 ms' │ '     63 ms' │ '    1.52 x' │
-│      Array_Union │  1000000   │ '   4736 ms' │ '    229 ms' │ '     86 ms' │ '    2.66 x' │
-│  Array_Recursive │  1000000   │ '  53804 ms' │ '   6744 ms' │ '   1167 ms' │ '    5.78 x' │
-│    Array_Vector4 │  1000000   │ '   2244 ms' │ '     99 ms' │ '     46 ms' │ '    2.15 x' │
-│    Array_Matrix4 │  1000000   │ '  11966 ms' │ '    378 ms' │ '    229 ms' │ '    1.65 x' │
+│           Number │  1000000   │ '     28 ms' │ '      6 ms' │ '      6 ms' │ '    1.00 x' │
+│           String │  1000000   │ '     25 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
+│          Boolean │  1000000   │ '     34 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
+│             Null │  1000000   │ '     37 ms' │ '     28 ms' │ '     10 ms' │ '    2.80 x' │
+│            RegEx │  1000000   │ '    162 ms' │ '     50 ms' │ '     37 ms' │ '    1.35 x' │
+│          ObjectA │  1000000   │ '    550 ms' │ '     38 ms' │ '     22 ms' │ '    1.73 x' │
+│          ObjectB │  1000000   │ '   1033 ms' │ '     58 ms' │ '     38 ms' │ '    1.53 x' │
+│            Tuple │  1000000   │ '    126 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
+│            Union │  1000000   │ '    326 ms' │ '     25 ms' │ '     16 ms' │ '    1.56 x' │
+│        Recursive │  1000000   │ '   3089 ms' │ '    436 ms' │ '    101 ms' │ '    4.32 x' │
+│          Vector4 │  1000000   │ '    155 ms' │ '     24 ms' │ '     12 ms' │ '    2.00 x' │
+│          Matrix4 │  1000000   │ '    579 ms' │ '     41 ms' │ '     28 ms' │ '    1.46 x' │
+│   Literal_String │  1000000   │ '     50 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
+│   Literal_Number │  1000000   │ '     46 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
+│  Literal_Boolean │  1000000   │ '     48 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
+│     Array_Number │  1000000   │ '    424 ms' │ '     32 ms' │ '     19 ms' │ '    1.68 x' │
+│     Array_String │  1000000   │ '    483 ms' │ '     34 ms' │ '     28 ms' │ '    1.21 x' │
+│    Array_Boolean │  1000000   │ '    432 ms' │ '     35 ms' │ '     26 ms' │ '    1.35 x' │
+│    Array_ObjectA │  1000000   │ '  13895 ms' │ '   2440 ms' │ '   1495 ms' │ '    1.63 x' │
+│    Array_ObjectB │  1000000   │ '  16261 ms' │ '   2633 ms' │ '   2011 ms' │ '    1.31 x' │
+│      Array_Tuple │  1000000   │ '   1741 ms' │ '     98 ms' │ '     66 ms' │ '    1.48 x' │
+│      Array_Union │  1000000   │ '   4825 ms' │ '    232 ms' │ '     87 ms' │ '    2.67 x' │
+│  Array_Recursive │  1000000   │ '  54158 ms' │ '   6966 ms' │ '   1173 ms' │ '    5.94 x' │
+│    Array_Vector4 │  1000000   │ '   2577 ms' │ '     99 ms' │ '     48 ms' │ '    2.06 x' │
+│    Array_Matrix4 │  1000000   │ '  12648 ms' │ '    397 ms' │ '    249 ms' │ '    1.59 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1136,12 +1220,12 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '   51 kb' │ '   25 kb' │  '2.00 x'   │
-│ typebox/conditional  │ '   42 kb' │ '   17 kb' │  '2.46 x'   │
+│ typebox/compiler     │ '   54 kb' │ '   27 kb' │  '1.97 x'   │
+│ typebox/conditional  │ '   44 kb' │ '   17 kb' │  '2.45 x'   │
 │ typebox/format       │ '    0 kb' │ '    0 kb' │  '2.66 x'   │
-│ typebox/guard        │ '   21 kb' │ '   10 kb' │  '2.08 x'   │
-│ typebox/value        │ '   74 kb' │ '   34 kb' │  '2.16 x'   │
-│ typebox              │ '   11 kb' │ '    6 kb' │  '1.91 x'   │
+│ typebox/guard        │ '   22 kb' │ '   11 kb' │  '2.05 x'   │
+│ typebox/value        │ '   78 kb' │ '   36 kb' │  '2.13 x'   │
+│ typebox              │ '   12 kb' │ '    6 kb' │  '1.89 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 7ebae8990..a7f41db03 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -54,7 +54,7 @@ export class TypeCheck<T extends Types.TSchema> {
     return ValueErrors.Errors(this.schema, this.references, value)
   }
 
-  /** Returns true if the value matches the given type. */
+  /** Returns true if the value matches the compiled type. */
   public Check(value: unknown): value is Types.Static<T> {
     return this.checkFunc(value)
   }
@@ -132,11 +132,19 @@ export namespace TypeCompiler {
     yield* Visit(schema.returns, `${value}.prototype`)
   }
 
+  function* Date(schema: Types.TDate, value: string): IterableIterator<string> {
+    yield `(${value} instanceof Date)`
+    if (schema.exclusiveMinimumTimestamp !== undefined) yield `(${value}.getTime() > ${schema.exclusiveMinimumTimestamp})`
+    if (schema.exclusiveMaximumTimestamp !== undefined) yield `(${value}.getTime() < ${schema.exclusiveMaximumTimestamp})`
+    if (schema.minimumTimestamp !== undefined) yield `(${value}.getTime() >= ${schema.minimumTimestamp})`
+    if (schema.maximumTimestamp !== undefined) yield `(${value}.getTime() <= ${schema.maximumTimestamp})`
+  }
+
   function* Function(schema: Types.TFunction, value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'function')`
   }
 
-  function* Integer(schema: Types.TNumeric, value: string): IterableIterator<string> {
+  function* Integer(schema: Types.TInteger, value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`
     if (schema.multipleOf !== undefined) yield `(${value} % ${schema.multipleOf} === 0)`
     if (schema.exclusiveMinimum !== undefined) yield `(${value} > ${schema.exclusiveMinimum})`
@@ -161,7 +169,7 @@ export namespace TypeCompiler {
     yield `(${value} === null)`
   }
 
-  function* Number(schema: Types.TNumeric, value: string): IterableIterator<string> {
+  function* Number(schema: Types.TNumber, value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'number')`
     if (schema.multipleOf !== undefined) yield `(${value} % ${schema.multipleOf} === 0)`
     if (schema.exclusiveMinimum !== undefined) yield `(${value} > ${schema.exclusiveMinimum})`
@@ -209,7 +217,7 @@ export namespace TypeCompiler {
   }
 
   function* Record(schema: Types.TRecord<any, any>, value: string): IterableIterator<string> {
-    yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`
+    yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date))`
     const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
     const local = PushLocal(`new RegExp(/${keyPattern}/)`)
     yield `(Object.keys(${value}).every(key => ${local}.test(key)))`
@@ -304,6 +312,8 @@ export namespace TypeCompiler {
         return yield* Boolean(anySchema, value)
       case 'Constructor':
         return yield* Constructor(anySchema, value)
+      case 'Date':
+        return yield* Date(anySchema, value)
       case 'Function':
         return yield* Function(anySchema, value)
       case 'Integer':
diff --git a/src/conditional/structural.ts b/src/conditional/structural.ts
index 18790d858..62c04ac33 100644
--- a/src/conditional/structural.ts
+++ b/src/conditional/structural.ts
@@ -197,6 +197,22 @@ export namespace Structural {
     }
   }
 
+  function Date(left: Types.TDate, right: Types.TSchema): StructuralResult {
+    if (AnyOrUnknownRule(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TRecord(right)) {
+      return StructuralResult.False
+    } else if (TypeGuard.TDate(right)) {
+      return StructuralResult.True
+    } else if (TypeGuard.TUnion(right)) {
+      return UnionRightRule(left, right)
+    } else {
+      return StructuralResult.False
+    }
+  }
+
   function Function(left: Types.TFunction, right: Types.TSchema): StructuralResult {
     if (AnyOrUnknownRule(right)) {
       return StructuralResult.True
@@ -510,6 +526,8 @@ export namespace Structural {
       return Boolean(left, resolvedRight)
     } else if (TypeGuard.TConstructor(left)) {
       return Constructor(left, resolvedRight)
+    } else if (TypeGuard.TDate(left)) {
+      return Date(left, resolvedRight)
     } else if (TypeGuard.TFunction(left)) {
       return Function(left, resolvedRight)
     } else if (TypeGuard.TInteger(left)) {
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 913a60226..98fd0bf6c 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -39,6 +39,11 @@ export enum ValueErrorType {
   ArrayMaxItems,
   ArrayUniqueItems,
   Boolean,
+  Date,
+  DateExclusiveMinimum,
+  DateExclusiveMaximum,
+  DateMinimum,
+  DateMaximum,
   Function,
   Integer,
   IntegerMultipleOf,
@@ -132,6 +137,24 @@ export namespace ValueErrors {
     yield* Visit(schema.returns, references, path, value.prototype)
   }
 
+  function* Date(schema: Types.TNumeric, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!(value instanceof globalThis.Date)) {
+      return yield { type: ValueErrorType.Date, schema, path, value, message: `Expected Date object` }
+    }
+    if (schema.exclusiveMinimumTimestamp && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
+      yield { type: ValueErrorType.DateExclusiveMinimum, schema, path, value, message: `Expected Date timestamp to be greater than ${schema.exclusiveMinimum}` }
+    }
+    if (schema.exclusiveMaximumTimestamp && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+      yield { type: ValueErrorType.DateExclusiveMaximum, schema, path, value, message: `Expected Date timestamp to be less than ${schema.exclusiveMaximum}` }
+    }
+    if (schema.minimumTimestamp && !(value.getTime() >= schema.minimumTimestamp)) {
+      yield { type: ValueErrorType.DateMinimum, schema, path, value, message: `Expected Date timestamp to be greater or equal to ${schema.minimum}` }
+    }
+    if (schema.maximumTimestamp && !(value.getTime() <= schema.maximumTimestamp)) {
+      yield { type: ValueErrorType.DateMaximum, schema, path, value, message: `Expected Date timestamp to be less or equal to ${schema.maximum}` }
+    }
+  }
+
   function* Function(schema: Types.TFunction, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!(typeof value === 'function')) {
       return yield { type: ValueErrorType.Function, schema, path, value, message: `Expected function` }
@@ -379,6 +402,8 @@ export namespace ValueErrors {
         return yield* Boolean(anySchema, anyReferences, path, value)
       case 'Constructor':
         return yield* Constructor(anySchema, anyReferences, path, value)
+      case 'Date':
+        return yield* Date(anySchema, anyReferences, path, value)
       case 'Function':
         return yield* Function(anySchema, anyReferences, path, value)
       case 'Integer':
diff --git a/src/guard/guard.ts b/src/guard/guard.ts
index ac9d54430..24f23c2eb 100644
--- a/src/guard/guard.ts
+++ b/src/guard/guard.ts
@@ -83,18 +83,23 @@ export namespace TypeGuard {
   function IsOptionalBoolean(value: unknown): value is boolean | undefined {
     return value === undefined || (value !== undefined && IsBoolean(value))
   }
+
   function IsOptionalString(value: unknown): value is string | undefined {
     return value === undefined || (value !== undefined && IsString(value))
   }
+
   function IsOptionalPattern(value: unknown): value is string | undefined {
     return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value) && IsPattern(value))
   }
+
   function IsOptionalFormat(value: unknown): value is string | undefined {
     return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value))
   }
+
   function IsOptionalSchema(value: unknown): value is boolean | undefined {
     return value === undefined || TSchema(value)
   }
+
   /** Returns true if the given schema is TAny */
   export function TAny(schema: unknown): schema is Types.TAny {
     return IsObject(schema) && schema[Types.Kind] === 'Any' && IsOptionalString(schema.$id)
@@ -116,12 +121,27 @@ export namespace TypeGuard {
 
   /** Returns true if the given schema is TBoolean */
   export function TBoolean(schema: unknown): schema is Types.TBoolean {
-    return IsObject(schema) && schema[Types.Kind] === 'Boolean' && schema.type === 'boolean' && IsOptionalString(schema.$id)
+    // prettier-ignore
+    return (
+      IsObject(schema) && 
+      schema[Types.Kind] === 'Boolean' && 
+      schema.type === 'boolean' && 
+      IsOptionalString(schema.$id)
+    )
   }
 
   /** Returns true if the given schema is TConstructor */
   export function TConstructor(schema: unknown): schema is Types.TConstructor {
-    if (!(IsObject(schema) && schema[Types.Kind] === 'Constructor' && schema.type === 'constructor' && IsOptionalString(schema.$id) && IsArray(schema.parameters) && TSchema(schema.returns))) {
+    // prettier-ignore
+    if (!(
+      IsObject(schema) && 
+      schema[Types.Kind] === 'Constructor' && 
+      schema.type === 'object' && 
+      schema.instanceOf === 'Constructor' && 
+      IsOptionalString(schema.$id) && 
+      IsArray(schema.parameters) && 
+      TSchema(schema.returns))
+    ) {
       return false
     }
     for (const parameter of schema.parameters) {
@@ -130,9 +150,33 @@ export namespace TypeGuard {
     return true
   }
 
+  /** Returns true if the given schema is TDate */
+  export function TDate(schema: unknown): schema is Types.TDate {
+    return (
+      IsObject(schema) &&
+      schema[Types.Kind] === 'Date' &&
+      schema.type === 'object' &&
+      schema.instanceOf === 'Date' &&
+      IsOptionalString(schema.$id) &&
+      IsOptionalNumber(schema.minimumTimestamp) &&
+      IsOptionalNumber(schema.maximumTimestamp) &&
+      IsOptionalNumber(schema.exclusiveMinimumTimestamp) &&
+      IsOptionalNumber(schema.exclusiveMaximumTimestamp)
+    )
+  }
+
   /** Returns true if the given schema is TFunction */
   export function TFunction(schema: unknown): schema is Types.TFunction {
-    if (!(IsObject(schema) && schema[Types.Kind] === 'Function' && schema.type === 'function' && IsOptionalString(schema.$id) && IsArray(schema.parameters) && TSchema(schema.returns))) {
+    // prettier-ignore
+    if (!(
+      IsObject(schema) && 
+      schema[Types.Kind] === 'Function' && 
+      schema.type === 'object' &&
+      schema.instanceOf === 'Function' &&
+      IsOptionalString(schema.$id) && 
+      IsArray(schema.parameters) && 
+      TSchema(schema.returns))
+    ) {
       return false
     }
     for (const parameter of schema.parameters) {
@@ -158,7 +202,17 @@ export namespace TypeGuard {
 
   /** Returns true if the given schema is TLiteral */
   export function TLiteral(schema: unknown): schema is Types.TLiteral {
-    return IsObject(schema) && schema[Types.Kind] === 'Literal' && IsOptionalString(schema.$id) && (IsString(schema.const) || IsNumber(schema.const) || IsBoolean(schema.const))
+    // prettier-ignore
+    return (
+      IsObject(schema) && 
+      schema[Types.Kind] === 'Literal' && 
+      IsOptionalString(schema.$id) && 
+      (
+        IsString(schema.const) || 
+        IsNumber(schema.const) || 
+        IsBoolean(schema.const)
+      )
+    )
   }
 
   /** Returns true if the given schema is TNever */
@@ -224,12 +278,28 @@ export namespace TypeGuard {
 
   /** Returns true if the given schema is TPromise */
   export function TPromise(schema: unknown): schema is Types.TPromise {
-    return IsObject(schema) && schema[Types.Kind] === 'Promise' && schema.type === 'promise' && IsOptionalString(schema.$id) && TSchema(schema.item)
+    // prettier-ignore
+    return (
+      IsObject(schema) && 
+      schema[Types.Kind] === 'Promise' && 
+      schema.type === 'object' && 
+      schema.instanceOf === 'Promise' &&
+      IsOptionalString(schema.$id) && 
+      TSchema(schema.item)
+    )
   }
 
   /** Returns true if the given schema is TRecord */
   export function TRecord(schema: unknown): schema is Types.TRecord {
-    if (!(IsObject(schema) && schema[Types.Kind] === 'Record' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.additionalProperties === false && IsObject(schema.patternProperties))) {
+    // prettier-ignore
+    if (!(
+      IsObject(schema) && 
+      schema[Types.Kind] === 'Record' && 
+      schema.type === 'object' && 
+      IsOptionalString(schema.$id) && 
+      schema.additionalProperties === false && 
+      IsObject(schema.patternProperties))
+    ) {
       return false
     }
     const keys = Object.keys(schema.patternProperties)
@@ -247,12 +317,24 @@ export namespace TypeGuard {
 
   /** Returns true if the given schema is TSelf */
   export function TSelf(schema: unknown): schema is Types.TSelf {
-    return IsObject(schema) && schema[Types.Kind] === 'Self' && IsOptionalString(schema.$id) && IsString(schema.$ref)
+    // prettier-ignore
+    return (
+      IsObject(schema) && 
+      schema[Types.Kind] === 'Self' && 
+      IsOptionalString(schema.$id) && 
+      IsString(schema.$ref)
+    )
   }
 
   /** Returns true if the given schema is TRef */
   export function TRef(schema: unknown): schema is Types.TRef {
-    return IsObject(schema) && schema[Types.Kind] === 'Ref' && IsOptionalString(schema.$id) && IsString(schema.$ref)
+    // prettier-ignore
+    return (
+      IsObject(schema) && 
+      schema[Types.Kind] === 'Ref' && 
+      IsOptionalString(schema.$id) && 
+      IsString(schema.$ref)
+    )
   }
 
   /** Returns true if the given schema is TString */
@@ -271,7 +353,16 @@ export namespace TypeGuard {
 
   /** Returns true if the given schema is TTuple */
   export function TTuple(schema: unknown): schema is Types.TTuple {
-    if (!(IsObject(schema) && schema[Types.Kind] === 'Tuple' && schema.type === 'array' && IsOptionalString(schema.$id) && IsNumber(schema.minItems) && IsNumber(schema.maxItems) && schema.minItems === schema.maxItems)) {
+    // prettier-ignore
+    if (!(
+      IsObject(schema) && 
+      schema[Types.Kind] === 'Tuple' && 
+      schema.type === 'array' && 
+      IsOptionalString(schema.$id) && 
+      IsNumber(schema.minItems) && 
+      IsNumber(schema.maxItems) && 
+      schema.minItems === schema.maxItems)
+    ) {
       return false
     }
     if (schema.items === undefined && schema.additionalItems === undefined && schema.minItems === 0) {
@@ -288,12 +379,25 @@ export namespace TypeGuard {
 
   /** Returns true if the given schema is TUndefined */
   export function TUndefined(schema: unknown): schema is Types.TUndefined {
-    return IsObject(schema) && schema[Types.Kind] === 'Undefined' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.specialized === 'Undefined'
+    // prettier-ignore
+    return (
+      IsObject(schema) && 
+      schema[Types.Kind] === 'Undefined' && 
+      schema.type === 'null' && 
+      schema.typeOf === 'Undefined' && 
+      IsOptionalString(schema.$id)
+    )
   }
 
   /** Returns true if the given schema is TUnion */
   export function TUnion(schema: unknown): schema is Types.TUnion {
-    if (!(IsObject(schema) && schema[Types.Kind] === 'Union' && IsArray(schema.anyOf) && IsOptionalString(schema.$id))) {
+    // prettier-ignore
+    if (!(
+      IsObject(schema) && 
+      schema[Types.Kind] === 'Union' && 
+      IsArray(schema.anyOf) && 
+      IsOptionalString(schema.$id))
+    ) {
       return false
     }
     for (const inner of schema.anyOf) {
@@ -309,7 +413,7 @@ export namespace TypeGuard {
       schema[Types.Kind] === 'Uint8Array' &&
       schema.type === 'object' &&
       IsOptionalString(schema.$id) &&
-      schema.specialized === 'Uint8Array' &&
+      schema.instanceOf === 'Uint8Array' &&
       IsOptionalNumber(schema.minByteLength) &&
       IsOptionalNumber(schema.maxByteLength)
     )
@@ -317,12 +421,24 @@ export namespace TypeGuard {
 
   /** Returns true if the given schema is TUnknown */
   export function TUnknown(schema: unknown): schema is Types.TUnknown {
-    return IsObject(schema) && schema[Types.Kind] === 'Unknown' && IsOptionalString(schema.$id)
+    // prettier-ignore
+    return (
+      IsObject(schema) && 
+      schema[Types.Kind] === 'Unknown' && 
+      IsOptionalString(schema.$id)
+    )
   }
 
   /** Returns true if the given schema is TVoid */
   export function TVoid(schema: unknown): schema is Types.TVoid {
-    return IsObject(schema) && schema[Types.Kind] === 'Void' && schema.type === 'null' && IsOptionalString(schema.$id)
+    // prettier-ignore
+    return (
+      IsObject(schema) && 
+      schema[Types.Kind] === 'Void' && 
+      schema.type === 'null' && 
+      schema.typeOf === 'Void' && 
+      IsOptionalString(schema.$id)
+    )
   }
 
   /** Returns true if the given schema is TSchema */
@@ -332,6 +448,7 @@ export namespace TypeGuard {
       TArray(schema) ||
       TBoolean(schema) ||
       TConstructor(schema) ||
+      TDate(schema) ||
       TFunction(schema) ||
       TInteger(schema) ||
       TLiteral(schema) ||
diff --git a/src/typebox.ts b/src/typebox.ts
index 4f0c98e30..5c8daf5cb 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -80,6 +80,7 @@ export type TAnySchema =
   | TArray
   | TBoolean
   | TConstructor
+  | TDate
   | TEnum
   | TFunction
   | TInteger
@@ -162,11 +163,30 @@ export type StaticContructorParameters<T extends readonly TSchema[], P extends u
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Constructor'
   static: new (...param: StaticContructorParameters<T, this['params']>) => Static<U, this['params']>
-  type: 'constructor'
+  type: 'object'
+  instanceOf: 'Constructor'
   parameters: T
   returns: U
 }
 
+// --------------------------------------------------------------------------
+// Date
+// --------------------------------------------------------------------------
+
+export interface DateOptions extends SchemaOptions {
+  exclusiveMaximumTimestamp?: number
+  exclusiveMinimumTimestamp?: number
+  maximumTimestamp?: number
+  minimumTimestamp?: number
+}
+
+export interface TDate extends TSchema, DateOptions {
+  [Kind]: 'Date'
+  static: Date
+  type: 'object'
+  instanceOf: 'Date'
+}
+
 // --------------------------------------------------------------------------
 // Enum
 // --------------------------------------------------------------------------
@@ -195,7 +215,8 @@ export type StaticFunctionParameters<T extends readonly TSchema[], P extends unk
 export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Function'
   static: (...param: StaticFunctionParameters<T, this['params']>) => Static<U, this['params']>
-  type: 'function'
+  type: 'object'
+  instanceOf: 'Function'
   parameters: T
   returns: U
 }
@@ -372,7 +393,8 @@ export type TPick<T extends TObject, Properties extends ObjectPropertyKeys<T>[]>
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Promise'
   static: Promise<Static<T, this['params']>>
-  type: 'promise'
+  type: 'object'
+  instanceOf: 'Promise'
   item: TSchema
 }
 
@@ -493,9 +515,9 @@ export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
 
 export interface TUndefined extends TSchema {
   [Kind]: 'Undefined'
-  specialized: 'Undefined'
   static: undefined
-  type: 'object'
+  type: 'null'
+  typeOf: 'Undefined'
 }
 
 // --------------------------------------------------------------------------
@@ -520,7 +542,7 @@ export interface Uint8ArrayOptions extends SchemaOptions {
 export interface TUint8Array extends TSchema, Uint8ArrayOptions {
   [Kind]: 'Uint8Array'
   static: Uint8Array
-  specialized: 'Uint8Array'
+  instanceOf: 'Uint8Array'
   type: 'object'
 }
 
@@ -554,6 +576,7 @@ export interface TVoid extends TSchema {
   [Kind]: 'Void'
   static: void
   type: 'null'
+  typeOf: 'Void'
 }
 
 // --------------------------------------------------------------------------
@@ -593,45 +616,50 @@ export class TypeBuilder {
   // Types
   // ----------------------------------------------------------------------
 
-  /** Creates a any type */
+  /** `Standard` Creates a any type */
   public Any(options: SchemaOptions = {}): TAny {
     return this.Create({ ...options, [Kind]: 'Any' })
   }
 
-  /** Creates a array type */
+  /** `Standard` Creates a array type */
   public Array<T extends TSchema>(items: T, options: ArrayOptions = {}): TArray<T> {
     return this.Create({ ...options, [Kind]: 'Array', type: 'array', items })
   }
 
-  /** Creates a boolean type */
+  /** `Standard` Creates a boolean type */
   public Boolean(options: SchemaOptions = {}): TBoolean {
     return this.Create({ ...options, [Kind]: 'Boolean', type: 'boolean' })
   }
 
-  /** Creates a tuple type from this constructors parameters */
+  /** `Extended` Creates a tuple type from this constructors parameters */
   public ConstructorParameters<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TConstructorParameters<T> {
     return this.Tuple([...schema.parameters], { ...options })
   }
 
-  /** Creates a constructor type */
+  /** `Extended` Creates a constructor type */
   public Constructor<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TConstructor<TupleToArray<T>, U>
 
-  /** Creates a constructor type */
+  /** `Extended` Creates a constructor type */
   public Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>
 
-  /** Creates a constructor type */
+  /** `Extended` Creates a constructor type */
   public Constructor(parameters: any, returns: any, options: SchemaOptions = {}) {
     if (parameters[Kind] === 'Tuple') {
       const inner = parameters.items === undefined ? [] : parameters.items
-      return this.Create({ ...options, [Kind]: 'Constructor', type: 'constructor', parameters: inner, returns })
+      return this.Create({ ...options, [Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: inner, returns })
     } else if (globalThis.Array.isArray(parameters)) {
-      return this.Create({ ...options, [Kind]: 'Constructor', type: 'constructor', parameters, returns })
+      return this.Create({ ...options, [Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters, returns })
     } else {
       throw new Error('TypeBuilder.Constructor: Invalid parameters')
     }
   }
 
-  /** Creates a enum type */
+  /** `Extended` Creates a Date type */
+  public Date(options: DateOptions = {}): TDate {
+    return this.Create({ ...options, [Kind]: 'Date', type: 'object', instanceOf: 'Date' })
+  }
+
+  /** `Standard` Creates a enum type */
   public Enum<T extends Record<string, string | number>>(item: T, options: SchemaOptions = {}): TEnum<T> {
     const values = Object.keys(item)
       .filter((key) => isNaN(key as any))
@@ -640,35 +668,35 @@ export class TypeBuilder {
     return this.Create({ ...options, [Kind]: 'Union', [Hint]: 'Enum', anyOf })
   }
 
-  /** Creates a function type */
+  /** `Extended` Creates a function type */
   public Function<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TFunction<TupleToArray<T>, U>
 
-  /** Creates a function type */
+  /** `Extended` Creates a function type */
   public Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>
 
-  /** Creates a function type */
+  /** `Extended` Creates a function type */
   public Function(parameters: any, returns: any, options: SchemaOptions = {}) {
     if (parameters[Kind] === 'Tuple') {
       const inner = parameters.items === undefined ? [] : parameters.items
-      return this.Create({ ...options, [Kind]: 'Function', type: 'function', parameters: inner, returns })
+      return this.Create({ ...options, [Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: inner, returns })
     } else if (globalThis.Array.isArray(parameters)) {
-      return this.Create({ ...options, [Kind]: 'Function', type: 'function', parameters, returns })
+      return this.Create({ ...options, [Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters, returns })
     } else {
       throw new Error('TypeBuilder.Function: Invalid parameters')
     }
   }
 
-  /** Creates a type from this constructors instance type */
+  /** `Extended` Creates a type from this constructors instance type */
   public InstanceType<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TInstanceType<T> {
     return { ...options, ...this.Clone(schema.returns) }
   }
 
-  /** Creates a integer type */
+  /** `Standard` Creates a integer type */
   public Integer(options: NumericOptions = {}): TInteger {
     return this.Create({ ...options, [Kind]: 'Integer', type: 'integer' })
   }
 
-  /** Creates a intersect type. */
+  /** `Standard` Creates a intersect type. */
   public Intersect<T extends TObject[]>(objects: [...T], options: ObjectOptions = {}): TIntersect<T> {
     const isOptional = (schema: TSchema) => (schema[Modifier] && schema[Modifier] === 'Optional') || schema[Modifier] === 'ReadonlyOptional'
     const [required, optional] = [new Set<string>(), new Set<string>()]
@@ -695,18 +723,18 @@ export class TypeBuilder {
     }
   }
 
-  /** Creates a keyof type */
+  /** `Standard` Creates a keyof type */
   public KeyOf<T extends TObject>(object: T, options: SchemaOptions = {}): TKeyOf<T> {
     const items = Object.keys(object.properties).map((key) => this.Create({ ...options, [Kind]: 'Literal', type: 'string', const: key }))
     return this.Create({ ...options, [Kind]: 'Union', [Hint]: 'KeyOf', anyOf: items })
   }
 
-  /** Creates a literal type. */
+  /** `Standard` Creates a literal type. */
   public Literal<T extends TLiteralValue>(value: T, options: SchemaOptions = {}): TLiteral<T> {
     return this.Create({ ...options, [Kind]: 'Literal', const: value, type: typeof value as 'string' | 'number' | 'boolean' })
   }
 
-  /** Creates a never type */
+  /** `Standard` Creates a never type */
   public Never(options: SchemaOptions = {}): TNever {
     return this.Create({
       ...options,
@@ -718,17 +746,17 @@ export class TypeBuilder {
     })
   }
 
-  /** Creates a null type */
+  /** `Standard` Creates a null type */
   public Null(options: SchemaOptions = {}): TNull {
     return this.Create({ ...options, [Kind]: 'Null', type: 'null' })
   }
 
-  /** Creates a number type */
+  /** `Standard` Creates a number type */
   public Number(options: NumericOptions = {}): TNumber {
     return this.Create({ ...options, [Kind]: 'Number', type: 'number' })
   }
 
-  /** Creates an object type with the given properties */
+  /** `Standard` Creates an object type */
   public Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
     const property_names = Object.keys(properties)
     const optional = property_names.filter((name) => {
@@ -744,13 +772,13 @@ export class TypeBuilder {
     }
   }
 
-  /** Creates a new object whose properties are omitted from the given object */
+  /** `Standard` Creates a new object type whose keys are omitted from the given source type */
   public Omit<T extends TObject, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: ObjectOptions): TOmit<T, UnionStringLiteralToTuple<K>>
 
-  /** Creates a new object whose properties are omitted from the given object */
+  /** `Standard` Creates a new object type whose keys are omitted from the given source type */
   public Omit<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: T, keys: readonly [...K], options?: ObjectOptions): TOmit<T, K>
 
-  /** Creates a new object whose properties are omitted from the given object */
+  /** `Standard` Creates a new object type whose keys are omitted from the given source type */
   public Omit(schema: any, keys: any, options: ObjectOptions = {}) {
     const select: readonly string[] = keys[Kind] === 'Union' ? keys.anyOf.map((schema: TLiteral) => schema.const) : keys
     const next = { ...this.Clone(schema), ...options, [Hint]: 'Omit' }
@@ -764,12 +792,12 @@ export class TypeBuilder {
     return this.Create(next)
   }
 
-  /** Creates a tuple type from this functions parameters */
+  /** `Extended` Creates a tuple type from this functions parameters */
   public Parameters<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TParameters<T> {
     return Type.Tuple(schema.parameters, { ...options })
   }
 
-  /** Creates an object type whose properties are all optional */
+  /** `Standard` Creates an object type whose properties are all optional */
   public Partial<T extends TObject>(schema: T, options: ObjectOptions = {}): TPartial<T> {
     const next = { ...this.Clone(schema), ...options, [Hint]: 'Partial' }
     delete next.required
@@ -794,13 +822,13 @@ export class TypeBuilder {
     return this.Create(next)
   }
 
-  /** Creates a object whose properties are picked from the given object */
+  /** `Standard` Creates a new object type whose keys are picked from the given source type */
   public Pick<T extends TObject, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: ObjectOptions): TPick<T, UnionStringLiteralToTuple<K>>
 
-  /** Creates a object whose properties are picked from the given object */
+  /** `Standard` Creates a new object type whose keys are picked from the given source type */
   public Pick<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: T, keys: readonly [...K], options?: ObjectOptions): TPick<T, K>
 
-  /** Creates a object whose properties are picked from the given object */
+  /** `Standard` Creates a new object type whose keys are picked from the given source type */
   public Pick<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: any, keys: any, options: ObjectOptions = {}) {
     const select: readonly string[] = keys[Kind] === 'Union' ? keys.anyOf.map((schema: TLiteral) => schema.const) : keys
     const next = { ...this.Clone(schema), ...options, [Hint]: 'Pick' }
@@ -814,18 +842,18 @@ export class TypeBuilder {
     return this.Create(next)
   }
 
-  /** Creates a promise type. This type cannot be represented in schema. */
+  /** `Extended` Creates a Promise type */
   public Promise<T extends TSchema>(item: T, options: SchemaOptions = {}): TPromise<T> {
-    return this.Create({ ...options, [Kind]: 'Promise', type: 'promise', item })
+    return this.Create({ ...options, [Kind]: 'Promise', type: 'object', instanceOf: 'Promise', item })
   }
 
-  /** Creates an object whose properties are derived from the given string literal union. */
+  /** `Standard` Creates an object whose properties are derived from the given string literal union. */
   public Record<K extends TUnion<TLiteral[]>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TObject<TRecordProperties<K, T>>
 
-  /** Creates a record type */
+  /** `Standard` Creates a record type */
   public Record<K extends TString | TNumeric, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecord<K, T>
 
-  /** Creates a record type */
+  /** `Standard` Creates a record type */
   public Record(key: any, value: any, options: ObjectOptions = {}) {
     // If string literal union return TObject with properties extracted from union.
     if (key[Kind] === 'Union') {
@@ -847,7 +875,7 @@ export class TypeBuilder {
     })
   }
 
-  /** Creates a recursive object type */
+  /** `Standard` Creates recursive type */
   public Recursive<T extends TSchema>(callback: (self: TSelf) => T, options: SchemaOptions = {}): TRecursive<T> {
     if (options.$id === undefined) options.$id = `T${TypeOrdinal++}`
     const self = callback({ [Kind]: 'Self', $ref: `${options.$id}` } as any)
@@ -855,18 +883,18 @@ export class TypeBuilder {
     return this.Create({ ...options, ...self } as any)
   }
 
-  /** Creates a reference schema */
+  /** `Standard` Creates a reference type. The referenced type must contain a $id. */
   public Ref<T extends TSchema>(schema: T, options: SchemaOptions = {}): TRef<T> {
     if (schema.$id === undefined) throw Error('TypeBuilder.Ref: Referenced schema must specify an $id')
     return this.Create({ ...options, [Kind]: 'Ref', $ref: schema.$id! })
   }
 
-  /** Creates a string type from a regular expression */
+  /** `Standard` Creates a string type from a regular expression */
   public RegEx(regex: RegExp, options: SchemaOptions = {}): TString {
     return this.Create({ ...options, [Kind]: 'String', type: 'string', pattern: regex.source })
   }
 
-  /** Creates an object type whose properties are all required */
+  /** `Standard` Creates an object type whose properties are all required */
   public Required<T extends TObject>(schema: T, options: SchemaOptions = {}): TRequired<T> {
     const next = { ...this.Clone(schema), ...options, [Hint]: 'Required' }
     next.required = Object.keys(next.properties)
@@ -891,7 +919,7 @@ export class TypeBuilder {
     return this.Create(next)
   }
 
-  /** Creates a type from this functions return type */
+  /** `Extended` Creates a type from this functions return type */
   public ReturnType<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TReturnType<T> {
     return { ...options, ...this.Clone(schema.returns) }
   }
@@ -901,12 +929,12 @@ export class TypeBuilder {
     return JSON.parse(JSON.stringify(schema))
   }
 
-  /** Creates a string type */
+  /** `Standard` Creates a string type */
   public String<Format extends string>(options: StringOptions<StringFormatOption | Format> = {}): TString<Format> {
     return this.Create({ ...options, [Kind]: 'String', type: 'string' })
   }
 
-  /** Creates a tuple type */
+  /** `Standard` Creates a tuple type */
   public Tuple<T extends TSchema[]>(items: [...T], options: SchemaOptions = {}): TTuple<T> {
     const additionalItems = false
     const minItems = items.length
@@ -915,37 +943,40 @@ export class TypeBuilder {
     return this.Create(schema)
   }
 
-  /** Creates a undefined type */
+  /** `Extended` Creates a undefined type */
   public Undefined(options: SchemaOptions = {}): TUndefined {
-    return this.Create({ ...options, [Kind]: 'Undefined', type: 'object', specialized: 'Undefined' })
+    return this.Create({ ...options, [Kind]: 'Undefined', type: 'null', typeOf: 'Undefined' })
   }
 
-  /** Creates a union type */
-
+  /** `Standard` Creates a union type */
   public Union(items: [], options?: SchemaOptions): TNever
+
+  /** `Standard` Creates a union type */
   public Union<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TUnion<T>
+
+  /** `Standard` Creates a union type */
   public Union<T extends TSchema[]>(items: [...T], options: SchemaOptions = {}) {
     return items.length === 0 ? Type.Never({ ...options }) : this.Create({ ...options, [Kind]: 'Union', anyOf: items })
   }
 
-  /** Creates a Uint8Array type */
+  /** `Extended` Creates a Uint8Array type */
   public Uint8Array(options: Uint8ArrayOptions = {}): TUint8Array {
-    return this.Create({ ...options, [Kind]: 'Uint8Array', type: 'object', specialized: 'Uint8Array' })
+    return this.Create({ ...options, [Kind]: 'Uint8Array', type: 'object', instanceOf: 'Uint8Array' })
   }
 
-  /** Creates an unknown type */
+  /** `Standard` Creates an unknown type */
   public Unknown(options: SchemaOptions = {}): TUnknown {
     return this.Create({ ...options, [Kind]: 'Unknown' })
   }
 
-  /** Creates a user defined schema that infers as type T  */
+  /** `Standard` Creates a user defined schema that infers as type T  */
   public Unsafe<T>(options: UnsafeOptions = {}): TUnsafe<T> {
     return this.Create({ ...options, [Kind]: options[Kind] || 'Unsafe' })
   }
 
-  /** Creates a void type */
+  /** `Extended` Creates a void type */
   public Void(options: SchemaOptions = {}): TVoid {
-    return this.Create({ ...options, [Kind]: 'Void', type: 'null' })
+    return this.Create({ ...options, [Kind]: 'Void', type: 'null', typeOf: 'Void' })
   }
 
   /** Use this function to return TSchema with static and params omitted */
diff --git a/src/value/cast.ts b/src/value/cast.ts
index 848fed23b..fda08eb81 100644
--- a/src/value/cast.ts
+++ b/src/value/cast.ts
@@ -201,6 +201,10 @@ export namespace ValueCast {
     return result
   }
 
+  function Date(schema: Types.TDate, references: Types.TSchema[], value: any): any {
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+  }
+
   function Enum(schema: Types.TEnum<any>, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
   }
@@ -257,7 +261,7 @@ export namespace ValueCast {
 
   function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): any {
     if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
-    if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value)) return ValueCreate.Create(schema, references)
+    if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value) || value instanceof globalThis.Date) return ValueCreate.Create(schema, references)
     const subschemaKey = globalThis.Object.keys(schema.patternProperties)[0]
     const subschema = schema.patternProperties[subschemaKey]
     const result = {} as Record<string, any>
@@ -327,6 +331,8 @@ export namespace ValueCast {
         return Boolean(anySchema, anyReferences, value)
       case 'Constructor':
         return Constructor(anySchema, anyReferences, value)
+      case 'Date':
+        return Date(anySchema, anyReferences, value)
       case 'Enum':
         return Enum(anySchema, anyReferences, value)
       case 'Function':
diff --git a/src/value/check.ts b/src/value/check.ts
index 302f5609d..54e0418c3 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -62,12 +62,29 @@ export namespace ValueCheck {
   function Constructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): boolean {
     return Visit(schema.returns, references, value.prototype)
   }
-
+  function Date(schema: Types.TDate, references: Types.TSchema[], value: any): boolean {
+    if (!(value instanceof globalThis.Date)) {
+      return false
+    }
+    if (schema.exclusiveMinimumTimestamp && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
+      return false
+    }
+    if (schema.exclusiveMaximumTimestamp && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+      return false
+    }
+    if (schema.minimumTimestamp && !(value.getTime() >= schema.minimumTimestamp)) {
+      return false
+    }
+    if (schema.maximumTimestamp && !(value.getTime() <= schema.maximumTimestamp)) {
+      return false
+    }
+    return true
+  }
   function Function(schema: Types.TFunction, references: Types.TSchema[], value: any): boolean {
     return typeof value === 'function'
   }
 
-  function Integer(schema: Types.TNumeric, references: Types.TSchema[], value: any): boolean {
+  function Integer(schema: Types.TInteger, references: Types.TSchema[], value: any): boolean {
     if (!(typeof value === 'number')) {
       return false
     }
@@ -104,7 +121,7 @@ export namespace ValueCheck {
     return value === null
   }
 
-  function Number(schema: Types.TNumeric, references: Types.TSchema[], value: any): boolean {
+  function Number(schema: Types.TNumber, references: Types.TSchema[], value: any): boolean {
     if (!(typeof value === 'number')) {
       return false
     }
@@ -180,7 +197,7 @@ export namespace ValueCheck {
   }
 
   function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): boolean {
-    if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+    if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value) && !(value instanceof globalThis.Date))) {
       return false
     }
     const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
@@ -288,6 +305,8 @@ export namespace ValueCheck {
         return Boolean(anySchema, anyReferences, value)
       case 'Constructor':
         return Constructor(anySchema, anyReferences, value)
+      case 'Date':
+        return Date(anySchema, anyReferences, value)
       case 'Function':
         return Function(anySchema, anyReferences, value)
       case 'Integer':
diff --git a/src/value/clone.ts b/src/value/clone.ts
index 03b06c913..d2bb93cdb 100644
--- a/src/value/clone.ts
+++ b/src/value/clone.ts
@@ -29,15 +29,19 @@ THE SOFTWARE.
 import { Is, ObjectType, ArrayType, TypedArrayType, ValueType } from './is'
 
 export namespace ValueClone {
+  function Array(value: ArrayType): any {
+    return value.map((element: any) => Clone(element))
+  }
+
+  function Date(value: Date): any {
+    return new globalThis.Date(value.toISOString())
+  }
+
   function Object(value: ObjectType): any {
     const keys = [...globalThis.Object.keys(value), ...globalThis.Object.getOwnPropertySymbols(value)]
     return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {})
   }
 
-  function Array(value: ArrayType): any {
-    return value.map((element: any) => Clone(element))
-  }
-
   function TypedArray(value: TypedArrayType): any {
     return value.slice()
   }
@@ -47,7 +51,9 @@ export namespace ValueClone {
   }
 
   export function Clone<T extends unknown>(value: T): T {
-    if (Is.Object(value)) {
+    if (Is.Date(value)) {
+      return Date(value)
+    } else if (Is.Object(value)) {
       return Object(value)
     } else if (Is.Array(value)) {
       return Array(value)
diff --git a/src/value/create.ts b/src/value/create.ts
index 5cd549096..3f9f7b52a 100644
--- a/src/value/create.ts
+++ b/src/value/create.ts
@@ -91,6 +91,16 @@ export namespace ValueCreate {
     }
   }
 
+  function Date(schema: Types.TDate, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else if (schema.minimumTimestamp !== undefined) {
+      return new globalThis.Date(schema.minimumTimestamp)
+    } else {
+      return new globalThis.Date(0)
+    }
+  }
+
   function Enum(schema: Types.TEnum<any>, references: Types.TSchema[]): any {
     if (schema.default !== undefined) {
       return schema.default
@@ -291,6 +301,8 @@ export namespace ValueCreate {
         return Boolean(anySchema, anyReferences)
       case 'Constructor':
         return Constructor(anySchema, anyReferences)
+      case 'Date':
+        return Date(anySchema, anyReferences)
       case 'Enum':
         return Enum(anySchema, anyReferences)
       case 'Function':
diff --git a/src/value/delta.ts b/src/value/delta.ts
index 371a11f2c..73c30b069 100644
--- a/src/value/delta.ts
+++ b/src/value/delta.ts
@@ -96,6 +96,11 @@ export namespace ValueDelta {
     }
   }
 
+  function* Date(path: string, current: Date, next: unknown): IterableIterator<Edit<any>> {
+    if (Is.Date(next) && current.getTime() === next.getTime()) return
+    yield Update(path, next)
+  }
+
   function* Array(path: string, current: ArrayType, next: unknown): IterableIterator<Edit<any>> {
     if (!Is.Array(next)) return yield Update(path, next)
     for (let i = 0; i < Math.min(current.length, next.length); i++) {
@@ -126,6 +131,8 @@ export namespace ValueDelta {
   function* Visit(path: string, current: unknown, next: unknown): IterableIterator<Edit<any>> {
     if (Is.Object(current)) {
       return yield* Object(path, current, next)
+    } else if (Is.Date(current)) {
+      return yield* Date(path, current, next)
     } else if (Is.Array(current)) {
       return yield* Array(path, current, next)
     } else if (Is.TypedArray(current)) {
diff --git a/src/value/equal.ts b/src/value/equal.ts
index 773f2d3c1..2e85871ab 100644
--- a/src/value/equal.ts
+++ b/src/value/equal.ts
@@ -37,6 +37,10 @@ export namespace ValueEqual {
     return leftKeys.every((key) => Equal(left[key], right[key]))
   }
 
+  function Date(left: Date, right: unknown): any {
+    return Is.Date(right) && left.getTime() === right.getTime()
+  }
+
   function Array(left: ArrayType, right: unknown): any {
     if (!Is.Array(right) || left.length !== right.length) return false
     return left.every((value, index) => Equal(value, right[index]))
@@ -54,6 +58,8 @@ export namespace ValueEqual {
   export function Equal<T>(left: T, right: unknown): right is T {
     if (Is.Object(left)) {
       return Object(left, right)
+    } else if (Is.Date(left)) {
+      return Date(left, right)
     } else if (Is.TypedArray(left)) {
       return TypedArray(left, right)
     } else if (Is.Array(left)) {
diff --git a/src/value/is.ts b/src/value/is.ts
index 729197d59..3d29fc898 100644
--- a/src/value/is.ts
+++ b/src/value/is.ts
@@ -33,7 +33,11 @@ export type ArrayType = unknown[]
 
 export namespace Is {
   export function Object(value: unknown): value is ObjectType {
-    return value !== null && typeof value === 'object' && !globalThis.Array.isArray(value) && !ArrayBuffer.isView(value)
+    return value !== null && typeof value === 'object' && !globalThis.Array.isArray(value) && !ArrayBuffer.isView(value) && !(value instanceof globalThis.Date)
+  }
+
+  export function Date(value: unknown): value is Date {
+    return value instanceof globalThis.Date
   }
 
   export function Array(value: unknown): value is ArrayType {
diff --git a/test/runtime/compiler/date.ts b/test/runtime/compiler/date.ts
new file mode 100644
index 000000000..d6c099e6c
--- /dev/null
+++ b/test/runtime/compiler/date.ts
@@ -0,0 +1,61 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Date', () => {
+  it('Should not validate number', () => {
+    const T = Type.Date()
+    fail(T, 1)
+  })
+  it('Should not validate string', () => {
+    const T = Type.Date()
+    fail(T, 'hello')
+  })
+  it('Should not validate boolean', () => {
+    const T = Type.Date()
+    fail(T, true)
+  })
+  it('Should not validate array', () => {
+    const T = Type.Date()
+    fail(T, [1, 2, 3])
+  })
+  it('Should not validate object', () => {
+    const T = Type.Date()
+    fail(T, { a: 1, b: 2 })
+  })
+  it('Should not validate null', () => {
+    const T = Type.Date()
+    fail(T, null)
+  })
+  it('Should not validate undefined', () => {
+    const T = Type.Date()
+    fail(T, undefined)
+  })
+  it('Should validate Date', () => {
+    const T = Type.Date()
+    ok(T, new Date())
+  })
+
+  it('Should validate Date minimumTimestamp', () => {
+    const T = Type.Date({ minimumTimestamp: 10 })
+    fail(T, new Date(9))
+    ok(T, new Date(10))
+  })
+
+  it('Should validate Date maximumTimestamp', () => {
+    const T = Type.Date({ maximumTimestamp: 10 })
+    ok(T, new Date(10))
+    fail(T, new Date(11))
+  })
+
+  it('Should validate Date exclusiveMinimumTimestamp', () => {
+    const T = Type.Date({ exclusiveMinimumTimestamp: 10 })
+    fail(T, new Date(10))
+    ok(T, new Date(11))
+  })
+
+  it('Should validate Date exclusiveMaximumTimestamp', () => {
+    const T = Type.Date({ exclusiveMaximumTimestamp: 10 })
+    ok(T, new Date(9))
+    fail(T, new Date(10))
+  })
+})
diff --git a/test/runtime/compiler/index.ts b/test/runtime/compiler/index.ts
index a77b5456e..01159a601 100644
--- a/test/runtime/compiler/index.ts
+++ b/test/runtime/compiler/index.ts
@@ -1,7 +1,9 @@
 import './any'
 import './array'
 import './boolean'
+import './date'
 import './enum'
+import './integer'
 import './intersect'
 import './keyof'
 import './literal'
diff --git a/test/runtime/compiler/integer.ts b/test/runtime/compiler/integer.ts
new file mode 100644
index 000000000..af3ac6bfa
--- /dev/null
+++ b/test/runtime/compiler/integer.ts
@@ -0,0 +1,67 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Integer', () => {
+  it('Should not validate number', () => {
+    const T = Type.Integer()
+    fail(T, 3.14)
+  })
+
+  it('Should validate integer', () => {
+    const T = Type.Integer()
+    ok(T, 1)
+  })
+
+  it('Should not validate string', () => {
+    const T = Type.Integer()
+    fail(T, 'hello')
+  })
+
+  it('Should not validate boolean', () => {
+    const T = Type.Integer()
+    fail(T, true)
+  })
+
+  it('Should not validate array', () => {
+    const T = Type.Integer()
+    fail(T, [1, 2, 3])
+  })
+
+  it('Should not validate object', () => {
+    const T = Type.Integer()
+    fail(T, { a: 1, b: 2 })
+  })
+
+  it('Should not validate null', () => {
+    const T = Type.Integer()
+    fail(T, null)
+  })
+  it('Should not validate undefined', () => {
+    const T = Type.Integer()
+    fail(T, undefined)
+  })
+
+  it('Should validate minimum', () => {
+    const T = Type.Integer({ minimum: 10 })
+    fail(T, 9)
+    ok(T, 10)
+  })
+
+  it('Should validate maximum', () => {
+    const T = Type.Integer({ maximum: 10 })
+    ok(T, 10)
+    fail(T, 11)
+  })
+
+  it('Should validate Date exclusiveMinimum', () => {
+    const T = Type.Integer({ exclusiveMinimum: 10 })
+    fail(T, 10)
+    ok(T, 11)
+  })
+
+  it('Should validate Date exclusiveMaximum', () => {
+    const T = Type.Integer({ exclusiveMaximum: 10 })
+    ok(T, 9)
+    fail(T, 10)
+  })
+})
diff --git a/test/runtime/compiler/number.ts b/test/runtime/compiler/number.ts
index 0a9e05b08..7628bfd12 100644
--- a/test/runtime/compiler/number.ts
+++ b/test/runtime/compiler/number.ts
@@ -3,9 +3,15 @@ import { ok, fail } from './validate'
 
 describe('type/compiler/Number', () => {
   it('Should validate number', () => {
+    const T = Type.Number()
+    ok(T, 3.14)
+  })
+
+  it('Should validate integer', () => {
     const T = Type.Number()
     ok(T, 1)
   })
+
   it('Should not validate string', () => {
     const T = Type.Number()
     fail(T, 'hello')
@@ -30,4 +36,28 @@ describe('type/compiler/Number', () => {
     const T = Type.Number()
     fail(T, undefined)
   })
+
+  it('Should validate minimum', () => {
+    const T = Type.Number({ minimum: 10 })
+    fail(T, 9)
+    ok(T, 10)
+  })
+
+  it('Should validate maximum', () => {
+    const T = Type.Number({ maximum: 10 })
+    ok(T, 10)
+    fail(T, 11)
+  })
+
+  it('Should validate Date exclusiveMinimum', () => {
+    const T = Type.Number({ exclusiveMinimum: 10 })
+    fail(T, 10)
+    ok(T, 11)
+  })
+
+  it('Should validate Date exclusiveMaximum', () => {
+    const T = Type.Number({ exclusiveMaximum: 10 })
+    ok(T, 9)
+    fail(T, 10)
+  })
 })
diff --git a/test/runtime/conditional/any.ts b/test/runtime/conditional/any.ts
index a8a11d46a..b450886d9 100644
--- a/test/runtime/conditional/any.ts
+++ b/test/runtime/conditional/any.ts
@@ -89,4 +89,10 @@ describe('conditional/structural/Any', () => {
     const R = Structural.Check(Type.Any(), Type.Void())
     Assert.deepEqual(R, StructuralResult.Union)
   })
+
+  it('Should extend Date', () => {
+    type T = any extends Date ? 1 : 2
+    const R = Structural.Check(Type.Any(), Type.Date())
+    Assert.deepEqual(R, StructuralResult.Union)
+  })
 })
diff --git a/test/runtime/conditional/array.ts b/test/runtime/conditional/array.ts
index 2f28914d0..f9ca50ab3 100644
--- a/test/runtime/conditional/array.ts
+++ b/test/runtime/conditional/array.ts
@@ -307,4 +307,10 @@ describe('conditional/structural/Array', () => {
     const R = Structural.Check(Type.Array(Type.String()), Type.Void())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
+  it('Should extend Date', () => {
+    type T = Array<string> extends Date ? 1 : 2
+    const R = Structural.Check(Type.Array(Type.String()), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/boolean.ts b/test/runtime/conditional/boolean.ts
index df089789c..4699a972b 100644
--- a/test/runtime/conditional/boolean.ts
+++ b/test/runtime/conditional/boolean.ts
@@ -104,4 +104,10 @@ describe('conditional/structural/Boolean', () => {
     const R = Structural.Check(Type.Boolean(), Type.Void())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
+  it('Should extend Date', () => {
+    type T = boolean extends Date ? 1 : 2
+    const R = Structural.Check(Type.Boolean(), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/constructor.ts b/test/runtime/conditional/constructor.ts
index de607b660..38cd73be6 100644
--- a/test/runtime/conditional/constructor.ts
+++ b/test/runtime/conditional/constructor.ts
@@ -8,6 +8,7 @@ describe('conditional/structural/Constructor', () => {
     const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Function([], Type.Number()))
     Assert.deepEqual(R, StructuralResult.False)
   })
+
   it('Should extend Constructor 1', () => {
     type T = (new () => number) extends new () => number ? 1 : 2
     const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Number()))
@@ -240,4 +241,10 @@ describe('conditional/structural/Constructor', () => {
     const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Void())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
+  it('Should extend Date', () => {
+    type T = (new () => number) extends Date ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/date.ts b/test/runtime/conditional/date.ts
new file mode 100644
index 000000000..29920d23a
--- /dev/null
+++ b/test/runtime/conditional/date.ts
@@ -0,0 +1,118 @@
+import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('conditional/structural/Date', () => {
+  it('Should extend Any', () => {
+    type T = Date extends any ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Any())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = Date extends unknown ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Unknown())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = Date extends string ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.String())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = Date extends boolean ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Boolean())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = Date extends number ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Number())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = Date extends number ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Integer())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Array', () => {
+    type T = Date extends Array<any> ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+  it('Should extend Tuple', () => {
+    type T = Date extends [number, number] ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = Date extends Record<number, any> ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = Date extends {} ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = Date extends { a: 10 } ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = Date extends object ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Object({}))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = Date extends number | string ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = Date extends any | number ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = Date extends boolean | number ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Null', () => {
+    type T = Date extends null ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Null())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = Date extends undefined ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Undefined())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = Date extends void ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Void())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Date', () => {
+    type T = Date extends Date ? 1 : 2
+    const R = Structural.Check(Type.Date(), Type.Date())
+    Assert.deepEqual(R, StructuralResult.True)
+  })
+})
diff --git a/test/runtime/conditional/function.ts b/test/runtime/conditional/function.ts
index 2729aa40b..64eb9f080 100644
--- a/test/runtime/conditional/function.ts
+++ b/test/runtime/conditional/function.ts
@@ -242,4 +242,10 @@ describe('conditional/structural/Function', () => {
     const R = Structural.Check(Type.Function([], Type.Number()), Type.Void())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
+  it('Should extend Date', () => {
+    type T = (() => number) extends Date ? 1 : 2
+    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/index.ts b/test/runtime/conditional/index.ts
index 0686b6d9d..1f7a88c56 100644
--- a/test/runtime/conditional/index.ts
+++ b/test/runtime/conditional/index.ts
@@ -2,6 +2,7 @@ import './any'
 import './array'
 import './boolean'
 import './constructor'
+import './date'
 import './function'
 import './integer'
 import './literal'
diff --git a/test/runtime/conditional/integer.ts b/test/runtime/conditional/integer.ts
index 3c384c776..78b1bca8e 100644
--- a/test/runtime/conditional/integer.ts
+++ b/test/runtime/conditional/integer.ts
@@ -104,9 +104,16 @@ describe('conditional/structural/Integer', () => {
     const R = Structural.Check(Type.Integer(), Type.Undefined())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
   it('Should extend Void', () => {
     type T = number extends undefined ? 1 : 2
     const R = Structural.Check(Type.Integer(), Type.Void())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
+  it('Should extend Date', () => {
+    type T = number extends Date ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/literal.ts b/test/runtime/conditional/literal.ts
index 994597c2f..a699ebf42 100644
--- a/test/runtime/conditional/literal.ts
+++ b/test/runtime/conditional/literal.ts
@@ -321,4 +321,10 @@ describe('conditional/structural/Literal', () => {
     const R = Structural.Check(Type.Literal(true), Type.Void())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
+  it('Should extend Date', () => {
+    type T = true extends Date ? 1 : 2
+    const R = Structural.Check(Type.Literal(true), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/null.ts b/test/runtime/conditional/null.ts
index d8b91e504..1b1fc9661 100644
--- a/test/runtime/conditional/null.ts
+++ b/test/runtime/conditional/null.ts
@@ -110,4 +110,10 @@ describe('conditional/structural/Null', () => {
     const R = Structural.Check(Type.Null(), Type.Void())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
+  it('Should extend Date', () => {
+    type T = null extends Date ? 1 : 2
+    const R = Structural.Check(Type.Null(), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/number.ts b/test/runtime/conditional/number.ts
index 35e6f7c68..7cb136f35 100644
--- a/test/runtime/conditional/number.ts
+++ b/test/runtime/conditional/number.ts
@@ -8,11 +8,13 @@ describe('conditional/structural/Number', () => {
     const R = Structural.Check(Type.Number(), Type.Any())
     Assert.deepEqual(R, StructuralResult.True)
   })
+
   it('Should extend Unknown', () => {
     type T = number extends unknown ? 1 : 2
     const R = Structural.Check(Type.Number(), Type.Unknown())
     Assert.deepEqual(R, StructuralResult.True)
   })
+
   it('Should extend String', () => {
     type T = number extends string ? 1 : 2
     const R = Structural.Check(Type.Number(), Type.String())
@@ -108,4 +110,10 @@ describe('conditional/structural/Number', () => {
     const R = Structural.Check(Type.Number(), Type.Void())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
+  it('Should extend Date', () => {
+    type T = number extends Date ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/object.ts b/test/runtime/conditional/object.ts
index 3452661ef..fb327cc40 100644
--- a/test/runtime/conditional/object.ts
+++ b/test/runtime/conditional/object.ts
@@ -152,4 +152,10 @@ describe('conditional/structural/Object', () => {
     const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Void())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
+  it('Should extend Date', () => {
+    type T = { a: number } extends Date ? 1 : 2
+    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/promise.ts b/test/runtime/conditional/promise.ts
index 77de0358d..68ad4b99d 100644
--- a/test/runtime/conditional/promise.ts
+++ b/test/runtime/conditional/promise.ts
@@ -242,4 +242,10 @@ describe('conditional/structural/Promise', () => {
     const R = Structural.Check(Type.Promise(Type.Number()), Type.Void())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
+  it('Should extend Date', () => {
+    type T = Promise<number> extends Date ? 1 : 2
+    const R = Structural.Check(Type.Promise(Type.Number()), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/record.ts b/test/runtime/conditional/record.ts
index 48b41ec24..396878420 100644
--- a/test/runtime/conditional/record.ts
+++ b/test/runtime/conditional/record.ts
@@ -58,6 +58,7 @@ describe('conditional/structural/Record', () => {
     const R = Structural.Check(A, B)
     Assert.deepEqual(R, StructuralResult.True)
   })
+
   it('Should extend Record 8', () => {
     type T = Record<string, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
@@ -65,6 +66,7 @@ describe('conditional/structural/Record', () => {
     const R = Structural.Check(A, B)
     Assert.deepEqual(R, StructuralResult.True)
   })
+
   it('Should extend Record 9', () => {
     type T = Record<number, number> extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
@@ -72,6 +74,7 @@ describe('conditional/structural/Record', () => {
     const R = Structural.Check(A, B)
     Assert.deepEqual(R, StructuralResult.False)
   })
+
   it('Should extend Record 10', () => {
     type T = Record<number, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
@@ -79,6 +82,7 @@ describe('conditional/structural/Record', () => {
     const R = Structural.Check(A, B)
     Assert.deepEqual(R, StructuralResult.True)
   })
+
   it('Should extend Record 11', () => {
     type T = Record<number, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
@@ -96,6 +100,7 @@ describe('conditional/structural/Record', () => {
     const R = Structural.Check(A, B)
     Assert.deepEqual(R, StructuralResult.True)
   })
+
   it('Should extend Record 13', () => {
     type T = Record<number, number> extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
@@ -103,6 +108,7 @@ describe('conditional/structural/Record', () => {
     const R = Structural.Check(A, B)
     Assert.deepEqual(R, StructuralResult.False)
   })
+
   it('Should extend Record 14', () => {
     type T = Record<number, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
@@ -140,66 +146,79 @@ describe('conditional/structural/Record', () => {
     const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.String())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
   it('Should extend Boolean', () => {
     type T = Record<number, number> extends boolean ? 1 : 2
     const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Boolean())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
   it('Should extend Number', () => {
     type T = Record<number, number> extends number ? 1 : 2
     const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Number())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
   it('Should extend Integer', () => {
     type T = Record<number, number> extends number ? 1 : 2
     const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Integer())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
   it('Should extend Array 1', () => {
     type T = Record<number, number> extends Array<any> ? 1 : 2
     const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.Any()))
     Assert.deepEqual(R, StructuralResult.False)
   })
+
   it('Should extend Array 2', () => {
     type T = Record<number, number> extends Array<string> ? 1 : 2
     const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.String()))
     Assert.deepEqual(R, StructuralResult.False)
   })
+
   it('Should extend Tuple', () => {
     type T = Record<number, number> extends [number, number] ? 1 : 2
     const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, StructuralResult.False)
   })
+
   it('Should extend Object 1', () => {
     type T = Record<number, number> extends object ? 1 : 2
     const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Object({}))
     Assert.deepEqual(R, StructuralResult.True)
   })
+
   it('Should extend Object 2', () => {
     type T = Record<number, number> extends {} ? 1 : 2
     const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Object({}))
     Assert.deepEqual(R, StructuralResult.True)
   })
+
   it('Should extend Object 3', () => {
     type T = Record<number, number> extends { a: number } ? 1 : 2
     const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Object({ a: Type.Number() }))
     Assert.deepEqual(R, StructuralResult.False)
   })
+
   it('Should extend Union 1', () => {
     type T = Record<number, number> extends number | string ? 1 : 2
     const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, StructuralResult.False)
   })
+
   it('Should extend Union 2', () => {
     type T = Record<number, number> extends any | number ? 1 : 2
     const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Any(), Type.String()]))
     Assert.deepEqual(R, StructuralResult.True)
   })
+
   it('Should extend Null', () => {
     type T = Record<number, number> extends null ? 1 : 2
     const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Null())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
   it('Should extend Undefined', () => {
     type T = Record<number, number> extends undefined ? 1 : 2
     const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Undefined())
@@ -211,4 +230,10 @@ describe('conditional/structural/Record', () => {
     const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Void())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
+  it('Should extend Date', () => {
+    type T = Record<number, number> extends Date ? 1 : 2
+    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/string.ts b/test/runtime/conditional/string.ts
index 42c02aa1e..783a25e91 100644
--- a/test/runtime/conditional/string.ts
+++ b/test/runtime/conditional/string.ts
@@ -140,4 +140,10 @@ describe('conditional/structural/String', () => {
     const R = Structural.Check(Type.Number(), Type.Void())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
+  it('Should extend Date', () => {
+    type T = number extends Date ? 1 : 2
+    const R = Structural.Check(Type.Number(), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/tuple.ts b/test/runtime/conditional/tuple.ts
index 6c2d025e2..dcd96163d 100644
--- a/test/runtime/conditional/tuple.ts
+++ b/test/runtime/conditional/tuple.ts
@@ -50,6 +50,7 @@ describe('conditional/structural/Tuple', () => {
     const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Union([Type.String(), Type.Number()])))
     Assert.deepEqual(R, StructuralResult.True)
   })
+
   it('Should extend Array 4', () => {
     type T = [string, number] extends Array<string | number | boolean> ? 1 : 2 // 1
     const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Union([Type.String(), Type.Number(), Type.Boolean()])))
@@ -193,4 +194,10 @@ describe('conditional/structural/Tuple', () => {
     const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Void())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
+  it('Should extend Date', () => {
+    type T = [string, number] extends Date ? 1 : 2
+    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/uint8array.ts b/test/runtime/conditional/uint8array.ts
index ddfef9031..984082d01 100644
--- a/test/runtime/conditional/uint8array.ts
+++ b/test/runtime/conditional/uint8array.ts
@@ -44,6 +44,7 @@ describe('conditional/structural/Uint8Array', () => {
     const R = Structural.Check(Type.Uint8Array(), Type.Array(Type.Any()))
     Assert.deepEqual(R, StructuralResult.False)
   })
+
   it('Should extend Tuple', () => {
     type T = Uint8Array extends [number, number] ? 1 : 2
     const R = Structural.Check(Type.Uint8Array(), Type.Tuple([Type.Number(), Type.Number()]))
@@ -109,4 +110,10 @@ describe('conditional/structural/Uint8Array', () => {
     const R = Structural.Check(Type.Uint8Array(), Type.Void())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
+  it('Should extend Date', () => {
+    type T = Uint8Array extends Date ? 1 : 2
+    const R = Structural.Check(Type.Uint8Array(), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/undefined.ts b/test/runtime/conditional/undefined.ts
index 3bacbf798..2a03f11ba 100644
--- a/test/runtime/conditional/undefined.ts
+++ b/test/runtime/conditional/undefined.ts
@@ -92,9 +92,16 @@ describe('conditional/structural/Undefined', () => {
     const R = Structural.Check(Type.Undefined(), Type.Undefined())
     Assert.deepEqual(R, StructuralResult.True)
   })
+
   it('Should extend Void', () => {
     type T = undefined extends void ? 1 : 2
     const R = Structural.Check(Type.Undefined(), Type.Void())
     Assert.deepEqual(R, StructuralResult.True)
   })
+
+  it('Should extend Date', () => {
+    type T = undefined extends Date ? 1 : 2
+    const R = Structural.Check(Type.Undefined(), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/union.ts b/test/runtime/conditional/union.ts
index 26e06a812..bcd0da241 100644
--- a/test/runtime/conditional/union.ts
+++ b/test/runtime/conditional/union.ts
@@ -139,4 +139,16 @@ describe('conditional/structural/Union', () => {
     const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Void())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
+  it('Should extend Date', () => {
+    type T = number | string | void extends Date ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
+
+  it('Should extend Date 2', () => {
+    type T = Date | number | string | void extends Date ? 1 : 2
+    const R = Structural.Check(Type.Union([Type.Date(), Type.Number(), Type.String()]), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/unknown.ts b/test/runtime/conditional/unknown.ts
index 8025a6b77..51b0e2908 100644
--- a/test/runtime/conditional/unknown.ts
+++ b/test/runtime/conditional/unknown.ts
@@ -116,4 +116,10 @@ describe('conditional/structural/Unknown', () => {
     const R = Structural.Check(Type.Unknown(), Type.Void())
     Assert.deepEqual(R, StructuralResult.False)
   })
+
+  it('Should extend Date', () => {
+    type T = unknown extends Date ? 1 : 2
+    const R = Structural.Check(Type.Unknown(), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/conditional/void.ts b/test/runtime/conditional/void.ts
index 289f3dfdc..6e1ece4ca 100644
--- a/test/runtime/conditional/void.ts
+++ b/test/runtime/conditional/void.ts
@@ -116,4 +116,10 @@ describe('conditional/structural/Void', () => {
     const R = Structural.Check(Type.Void(), Type.Void())
     Assert.deepEqual(R, StructuralResult.True)
   })
+
+  it('Should extend Date', () => {
+    type T = void extends Date ? 1 : 2
+    const R = Structural.Check(Type.Void(), Type.Date())
+    Assert.deepEqual(R, StructuralResult.False)
+  })
 })
diff --git a/test/runtime/guard/any.ts b/test/runtime/guard/any.ts
index e2b5a7b74..039fa56ef 100644
--- a/test/runtime/guard/any.ts
+++ b/test/runtime/guard/any.ts
@@ -3,15 +3,15 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TAny', () => {
-  it('should guard for TAny', () => {
+  it('Should guard for TAny', () => {
     const R = TypeGuard.TAny(Type.Any())
     Assert.equal(R, true)
   })
-  it('should not guard for TAny', () => {
+  it('Should not guard for TAny', () => {
     const R = TypeGuard.TAny(null)
     Assert.equal(R, false)
   })
-  it('should not guard for TAny with invalid $id', () => {
+  it('Should not guard for TAny with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TAny(Type.Any({ $id: 1 }))
     Assert.equal(R, false)
diff --git a/test/runtime/guard/array.ts b/test/runtime/guard/array.ts
index 088f39653..402614610 100644
--- a/test/runtime/guard/array.ts
+++ b/test/runtime/guard/array.ts
@@ -3,17 +3,17 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TArray', () => {
-  it('should guard for TArray', () => {
+  it('Should guard for TArray', () => {
     const R = TypeGuard.TArray(Type.Array(Type.Number()))
     Assert.equal(R, true)
   })
 
-  it('should not guard for TArray', () => {
+  it('Should not guard for TArray', () => {
     const R = TypeGuard.TArray(null)
     Assert.equal(R, false)
   })
 
-  it('should guard for nested object TArray', () => {
+  it('Should guard for nested object TArray', () => {
     const R = TypeGuard.TArray(
       Type.Array(
         Type.Object({
@@ -25,7 +25,7 @@ describe('type/guard/TArray', () => {
     Assert.equal(R, true)
   })
 
-  it('should not guard for nested object TArray', () => {
+  it('Should not guard for nested object TArray', () => {
     const R = TypeGuard.TArray(
       Type.Array(
         Type.Object({
@@ -37,25 +37,25 @@ describe('type/guard/TArray', () => {
     Assert.equal(R, false)
   })
 
-  it('should not guard for TArray with invalid $id', () => {
+  it('Should not guard for TArray with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TArray(Type.Array(Type.Number(), { $id: 1 }))
     Assert.equal(R, false)
   })
 
-  it('should not guard for TArray with invalid minItems', () => {
+  it('Should not guard for TArray with invalid minItems', () => {
     // @ts-ignore
     const R = TypeGuard.TArray(Type.Array(Type.String(), { minItems: '1' }))
     Assert.equal(R, false)
   })
 
-  it('should not guard for TArray with invalid maxItems', () => {
+  it('Should not guard for TArray with invalid maxItems', () => {
     // @ts-ignore
     const R = TypeGuard.TArray(Type.Array(Type.String(), { maxItems: '1' }))
     Assert.equal(R, false)
   })
 
-  it('should not guard for TArray with invalid uniqueItems', () => {
+  it('Should not guard for TArray with invalid uniqueItems', () => {
     // @ts-ignore
     const R = TypeGuard.TArray(Type.Array(Type.String(), { uniqueItems: '1' }))
     Assert.equal(R, false)
diff --git a/test/runtime/guard/boolean.ts b/test/runtime/guard/boolean.ts
index 52c94c877..71680414f 100644
--- a/test/runtime/guard/boolean.ts
+++ b/test/runtime/guard/boolean.ts
@@ -3,15 +3,15 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TBoolean', () => {
-  it('should guard for TBoolean', () => {
+  it('Should guard for TBoolean', () => {
     const R = TypeGuard.TBoolean(Type.Boolean())
     Assert.equal(R, true)
   })
-  it('should not guard for TBoolean', () => {
+  it('Should not guard for TBoolean', () => {
     const R = TypeGuard.TBoolean(null)
     Assert.equal(R, false)
   })
-  it('should not guard for TBoolean with invalid $id', () => {
+  it('Should not guard for TBoolean with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TBoolean(Type.Boolean({ $id: 1 }))
     Assert.equal(R, false)
diff --git a/test/runtime/guard/constructor.ts b/test/runtime/guard/constructor.ts
index e584c0609..9bb2d4b37 100644
--- a/test/runtime/guard/constructor.ts
+++ b/test/runtime/guard/constructor.ts
@@ -3,32 +3,32 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TConstructor', () => {
-  it('should guard for TConstructor', () => {
+  it('Should guard for TConstructor', () => {
     const R = TypeGuard.TConstructor(Type.Constructor([], Type.Number()))
     Assert.equal(R, true)
   })
-  it('should not guard for TConstructor', () => {
+  it('Should not guard for TConstructor', () => {
     const R = TypeGuard.TConstructor(null)
     Assert.equal(R, false)
   })
-  it('should not guard for TConstructor with invalid $id', () => {
+  it('Should not guard for TConstructor with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TConstructor(Type.Constructor([], Type.Number(), { $id: 1 }))
     Assert.equal(R, false)
   })
-  it('should not guard for TConstructor with invalid Params', () => {
+  it('Should not guard for TConstructor with invalid Params', () => {
     const R = TypeGuard.TConstructor(Type.Constructor([{} as any, {} as any], Type.Number()))
     Assert.equal(R, false)
   })
-  it('should not guard for TConstructor with invalid Return', () => {
+  it('Should not guard for TConstructor with invalid Return', () => {
     const R = TypeGuard.TConstructor(Type.Constructor([], {} as any))
     Assert.equal(R, false)
   })
-  it('should guard for TConstructor with empty TTuple', () => {
+  it('Should guard for TConstructor with empty TTuple', () => {
     const R = TypeGuard.TConstructor(Type.Constructor(Type.Tuple([]), Type.Number()))
     Assert.equal(R, true)
   })
-  it('should guard for TConstructor with array TTuple', () => {
+  it('Should guard for TConstructor with array TTuple', () => {
     const R = TypeGuard.TConstructor(Type.Constructor(Type.Tuple([Type.Number(), Type.String()]), Type.Number()))
     Assert.equal(R, true)
   })
diff --git a/test/runtime/guard/date.ts b/test/runtime/guard/date.ts
new file mode 100644
index 000000000..14132a7bd
--- /dev/null
+++ b/test/runtime/guard/date.ts
@@ -0,0 +1,45 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('type/guard/TDate', () => {
+  it('Should guard for TDate', () => {
+    const R = TypeGuard.TDate(Type.Date())
+    Assert.equal(R, true)
+  })
+
+  it('Should not guard for TDate', () => {
+    const R = TypeGuard.TDate(null)
+    Assert.equal(R, false)
+  })
+
+  it('Should not guard for TDate with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TDate(Type.Number({ $id: 1 }))
+    Assert.equal(R, false)
+  })
+
+  it('Should not guard for TDate with invalid minimum', () => {
+    // @ts-ignore
+    const R = TypeGuard.TDate(Type.Number({ minimum: '1' }))
+    Assert.equal(R, false)
+  })
+
+  it('Should not guard for TDate with invalid maximum', () => {
+    // @ts-ignore
+    const R = TypeGuard.TDate(Type.Number({ maximum: '1' }))
+    Assert.equal(R, false)
+  })
+
+  it('Should not guard for TDate with invalid exclusiveMinimum', () => {
+    // @ts-ignore
+    const R = TypeGuard.TDate(Type.Number({ exclusiveMinimum: '1' }))
+    Assert.equal(R, false)
+  })
+
+  it('Should not guard for TDate with invalid exclusiveMaximum', () => {
+    // @ts-ignore
+    const R = TypeGuard.TDate(Type.Number({ exclusiveMaximum: '1' }))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/function.ts b/test/runtime/guard/function.ts
index 3cff158a8..102ac4f14 100644
--- a/test/runtime/guard/function.ts
+++ b/test/runtime/guard/function.ts
@@ -3,32 +3,32 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TFunction', () => {
-  it('should guard for TFunction', () => {
+  it('Should guard for TFunction', () => {
     const R = TypeGuard.TFunction(Type.Function([], Type.Number()))
     Assert.equal(R, true)
   })
-  it('should not guard for TFunction', () => {
+  it('Should not guard for TFunction', () => {
     const R = TypeGuard.TFunction(null)
     Assert.equal(R, false)
   })
-  it('should not guard for TFunction with invalid $id', () => {
+  it('Should not guard for TFunction with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TFunction(Type.Function([], Type.Number(), { $id: 1 }))
     Assert.equal(R, false)
   })
-  it('should not guard for TFunction with invalid Params', () => {
+  it('Should not guard for TFunction with invalid Params', () => {
     const R = TypeGuard.TFunction(Type.Function([{} as any, {} as any], Type.Number()))
     Assert.equal(R, false)
   })
-  it('should not guard for TFunction with invalid Return', () => {
+  it('Should not guard for TFunction with invalid Return', () => {
     const R = TypeGuard.TFunction(Type.Function([], {} as any))
     Assert.equal(R, false)
   })
-  it('should guard for TFunction with empty TTuple', () => {
+  it('Should guard for TFunction with empty TTuple', () => {
     const R = TypeGuard.TFunction(Type.Function(Type.Tuple([]), Type.Number()))
     Assert.equal(R, true)
   })
-  it('should guard for TFunction with array TTuple', () => {
+  it('Should guard for TFunction with array TTuple', () => {
     const R = TypeGuard.TFunction(Type.Function(Type.Tuple([Type.Number(), Type.String()]), Type.Number()))
     Assert.equal(R, true)
   })
diff --git a/test/runtime/guard/index.ts b/test/runtime/guard/index.ts
index 804c4865c..037d13781 100644
--- a/test/runtime/guard/index.ts
+++ b/test/runtime/guard/index.ts
@@ -2,6 +2,7 @@ import './any'
 import './array'
 import './boolean'
 import './constructor'
+import './date'
 import './function'
 import './integer'
 import './literal'
diff --git a/test/runtime/guard/integer.ts b/test/runtime/guard/integer.ts
index d53536b6e..72558e07e 100644
--- a/test/runtime/guard/integer.ts
+++ b/test/runtime/guard/integer.ts
@@ -3,40 +3,40 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TInteger', () => {
-  it('should guard for TInteger', () => {
+  it('Should guard for TInteger', () => {
     const R = TypeGuard.TInteger(Type.Integer())
     Assert.equal(R, true)
   })
-  it('should not guard for TInteger', () => {
+  it('Should not guard for TInteger', () => {
     const R = TypeGuard.TInteger(null)
     Assert.equal(R, false)
   })
-  it('should not guard for TInteger with invalid $id', () => {
+  it('Should not guard for TInteger with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ $id: 1 }))
     Assert.equal(R, false)
   })
-  it('should not guard for TInteger with invalid multipleOf', () => {
+  it('Should not guard for TInteger with invalid multipleOf', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ multipleOf: '1' }))
     Assert.equal(R, false)
   })
-  it('should not guard for TInteger with invalid minimum', () => {
+  it('Should not guard for TInteger with invalid minimum', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ minimum: '1' }))
     Assert.equal(R, false)
   })
-  it('should not guard for TInteger with invalid maximum', () => {
+  it('Should not guard for TInteger with invalid maximum', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ maximum: '1' }))
     Assert.equal(R, false)
   })
-  it('should not guard for TInteger with invalid exclusiveMinimum', () => {
+  it('Should not guard for TInteger with invalid exclusiveMinimum', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ exclusiveMinimum: '1' }))
     Assert.equal(R, false)
   })
-  it('should not guard for TInteger with invalid exclusiveMaximum', () => {
+  it('Should not guard for TInteger with invalid exclusiveMaximum', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ exclusiveMaximum: '1' }))
     Assert.equal(R, false)
diff --git a/test/runtime/guard/literal.ts b/test/runtime/guard/literal.ts
index efe372437..df4d39e24 100644
--- a/test/runtime/guard/literal.ts
+++ b/test/runtime/guard/literal.ts
@@ -3,28 +3,28 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TLiteral', () => {
-  it('should guard for TLiteral of String', () => {
+  it('Should guard for TLiteral of String', () => {
     const R = TypeGuard.TLiteral(Type.Literal('hello'))
     Assert.equal(R, true)
   })
-  it('should guard for TLiteral of Number', () => {
+  it('Should guard for TLiteral of Number', () => {
     const R = TypeGuard.TLiteral(Type.Literal(42))
     Assert.equal(R, true)
   })
-  it('should guard for TLiteral of Boolean', () => {
+  it('Should guard for TLiteral of Boolean', () => {
     const R = TypeGuard.TLiteral(Type.Literal(true))
     Assert.equal(R, true)
   })
-  it('should not guard for TLiteral of Null', () => {
+  it('Should not guard for TLiteral of Null', () => {
     // @ts-ignore
     const R = TypeGuard.TLiteral(Type.Literal(null))
     Assert.equal(R, false)
   })
-  it('should not guard for TLiteral', () => {
+  it('Should not guard for TLiteral', () => {
     const R = TypeGuard.TLiteral(null)
     Assert.equal(R, false)
   })
-  it('should not guard for TLiteral with invalid $id', () => {
+  it('Should not guard for TLiteral with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TLiteral(Type.Literal(42, { $id: 1 }))
     Assert.equal(R, false)
diff --git a/test/runtime/guard/null.ts b/test/runtime/guard/null.ts
index 36f8df40b..d853e112f 100644
--- a/test/runtime/guard/null.ts
+++ b/test/runtime/guard/null.ts
@@ -3,15 +3,15 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TNull', () => {
-  it('should guard for TNull', () => {
+  it('Should guard for TNull', () => {
     const R = TypeGuard.TNull(Type.Null())
     Assert.equal(R, true)
   })
-  it('should not guard for TNull', () => {
+  it('Should not guard for TNull', () => {
     const R = TypeGuard.TNull(null)
     Assert.equal(R, false)
   })
-  it('should not guard for TNull with invalid $id', () => {
+  it('Should not guard for TNull with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TNull(Type.Null({ $id: 1 }))
     Assert.equal(R, false)
diff --git a/test/runtime/guard/number.ts b/test/runtime/guard/number.ts
index 9ea80b538..eb6141606 100644
--- a/test/runtime/guard/number.ts
+++ b/test/runtime/guard/number.ts
@@ -3,40 +3,40 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TNumber', () => {
-  it('should guard for TNumber', () => {
+  it('Should guard for TNumber', () => {
     const R = TypeGuard.TNumber(Type.Number())
     Assert.equal(R, true)
   })
-  it('should not guard for TNumber', () => {
+  it('Should not guard for TNumber', () => {
     const R = TypeGuard.TNumber(null)
     Assert.equal(R, false)
   })
-  it('should not guard for TNumber with invalid $id', () => {
+  it('Should not guard for TNumber with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ $id: 1 }))
     Assert.equal(R, false)
   })
-  it('should not guard for TNumber with invalid multipleOf', () => {
+  it('Should not guard for TNumber with invalid multipleOf', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ multipleOf: '1' }))
     Assert.equal(R, false)
   })
-  it('should not guard for TNumber with invalid minimum', () => {
+  it('Should not guard for TNumber with invalid minimum', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ minimum: '1' }))
     Assert.equal(R, false)
   })
-  it('should not guard for TNumber with invalid maximum', () => {
+  it('Should not guard for TNumber with invalid maximum', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ maximum: '1' }))
     Assert.equal(R, false)
   })
-  it('should not guard for TNumber with invalid exclusiveMinimum', () => {
+  it('Should not guard for TNumber with invalid exclusiveMinimum', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ exclusiveMinimum: '1' }))
     Assert.equal(R, false)
   })
-  it('should not guard for TNumber with invalid exclusiveMaximum', () => {
+  it('Should not guard for TNumber with invalid exclusiveMaximum', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ exclusiveMaximum: '1' }))
     Assert.equal(R, false)
diff --git a/test/runtime/guard/object.ts b/test/runtime/guard/object.ts
index c34d32639..867774afc 100644
--- a/test/runtime/guard/object.ts
+++ b/test/runtime/guard/object.ts
@@ -3,7 +3,7 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TObject', () => {
-  it('should guard for TObject', () => {
+  it('Should guard for TObject', () => {
     const R = TypeGuard.TObject(
       Type.Object({
         x: Type.Number(),
@@ -13,12 +13,12 @@ describe('type/guard/TObject', () => {
     Assert.equal(R, true)
   })
 
-  it('should not guard for TObject', () => {
+  it('Should not guard for TObject', () => {
     const R = TypeGuard.TObject(null)
     Assert.equal(R, false)
   })
 
-  it('should not guard for TObject with escape characters in property key', () => {
+  it('Should not guard for TObject with escape characters in property key', () => {
     const R = TypeGuard.TObject(
       Type.Object({
         'hello\nworld': Type.Number(),
@@ -27,7 +27,7 @@ describe('type/guard/TObject', () => {
     Assert.equal(R, false)
   })
 
-  it('should not guard for TObject with invalid property values', () => {
+  it('Should not guard for TObject with invalid property values', () => {
     const R = TypeGuard.TObject(
       Type.Object({
         x: Type.Number(),
@@ -37,7 +37,7 @@ describe('type/guard/TObject', () => {
     Assert.equal(R, false)
   })
 
-  it('should not guard for TObject with invalid additionalProperties', () => {
+  it('Should not guard for TObject with invalid additionalProperties', () => {
     const R = TypeGuard.TObject(
       Type.Object(
         {
@@ -52,7 +52,7 @@ describe('type/guard/TObject', () => {
     Assert.equal(R, false)
   })
 
-  it('should not guard for TObject with invalid $id', () => {
+  it('Should not guard for TObject with invalid $id', () => {
     const R = TypeGuard.TObject(
       Type.Object(
         {
@@ -67,7 +67,7 @@ describe('type/guard/TObject', () => {
     Assert.equal(R, false)
   })
 
-  it('should not guard for TObject with invalid minProperties', () => {
+  it('Should not guard for TObject with invalid minProperties', () => {
     const R = TypeGuard.TObject(
       Type.Object(
         {
@@ -82,7 +82,7 @@ describe('type/guard/TObject', () => {
     Assert.equal(R, false)
   })
 
-  it('should not guard for TObject with invalid maxProperties', () => {
+  it('Should not guard for TObject with invalid maxProperties', () => {
     const R = TypeGuard.TObject(
       Type.Object(
         {
@@ -97,7 +97,7 @@ describe('type/guard/TObject', () => {
     Assert.equal(R, false)
   })
 
-  it('should guard for TObject with invalid additional properties', () => {
+  it('Should guard for TObject with invalid additional properties', () => {
     const R = TypeGuard.TObject(
       Type.Object(
         {
@@ -113,7 +113,7 @@ describe('type/guard/TObject', () => {
     Assert.equal(R, false)
   })
 
-  it('should not guard for TObject with valid additional properties schema', () => {
+  it('Should not guard for TObject with valid additional properties schema', () => {
     const R = TypeGuard.TObject(
       Type.Object(
         {
diff --git a/test/runtime/guard/promise.ts b/test/runtime/guard/promise.ts
index 0610bc319..fdfbfb184 100644
--- a/test/runtime/guard/promise.ts
+++ b/test/runtime/guard/promise.ts
@@ -3,23 +3,23 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TPromise', () => {
-  it('should guard for TPromise', () => {
+  it('Should guard for TPromise', () => {
     const R = TypeGuard.TPromise(Type.Promise(Type.Number()))
     Assert.equal(R, true)
   })
 
-  it('should not guard for TPromise', () => {
+  it('Should not guard for TPromise', () => {
     const R = TypeGuard.TPromise(null)
     Assert.equal(R, false)
   })
 
-  it('should not guard for TPromise with invalid $id', () => {
+  it('Should not guard for TPromise with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TPromise(Type.Promise(Type.Number(), { $id: 1 }))
     Assert.equal(R, false)
   })
 
-  it('should guard for TPromise with nested TObject', () => {
+  it('Should guard for TPromise with nested TObject', () => {
     const R = TypeGuard.TPromise(
       Type.Promise(
         Type.Object({
@@ -31,7 +31,7 @@ describe('type/guard/TPromise', () => {
     Assert.equal(R, true)
   })
 
-  it('should not guard for TPromise with nested TObject', () => {
+  it('Should not guard for TPromise with nested TObject', () => {
     const R = TypeGuard.TPromise(
       Type.Promise(
         Type.Object({
diff --git a/test/runtime/guard/record.ts b/test/runtime/guard/record.ts
index 718f56e65..92ab62c00 100644
--- a/test/runtime/guard/record.ts
+++ b/test/runtime/guard/record.ts
@@ -3,12 +3,12 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TRecord', () => {
-  it('should guard for TRecord', () => {
+  it('Should guard for TRecord', () => {
     const R = TypeGuard.TRecord(Type.Record(Type.String(), Type.Number()))
     Assert.equal(R, true)
   })
 
-  it('should guard for TRecord with TObject value', () => {
+  it('Should guard for TRecord with TObject value', () => {
     const R = TypeGuard.TRecord(
       Type.Record(
         Type.String(),
@@ -21,18 +21,18 @@ describe('type/guard/TRecord', () => {
     Assert.equal(R, true)
   })
 
-  it('should not guard for TRecord', () => {
+  it('Should not guard for TRecord', () => {
     const R = TypeGuard.TRecord(null)
     Assert.equal(R, false)
   })
 
-  it('should not guard for TRecord with invalid $id', () => {
+  it('Should not guard for TRecord with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TRecord(Type.Record(Type.String(), Type.Number(), { $id: 1 }))
     Assert.equal(R, false)
   })
 
-  it('should not guard for TRecord with TObject value with invalid Property', () => {
+  it('Should not guard for TRecord with TObject value with invalid Property', () => {
     const R = TypeGuard.TRecord(
       Type.Record(
         Type.String(),
@@ -45,7 +45,7 @@ describe('type/guard/TRecord', () => {
     Assert.equal(R, false)
   })
 
-  it('should not guard for TRecord with invalid literal key', () => {
+  it('Should not guard for TRecord with invalid literal key', () => {
     const K = Type.Union([Type.Literal('hello\nworld')])
     const R = TypeGuard.TRecord(Type.Record(K, Type.Number()))
     Assert.equal(R, false)
diff --git a/test/runtime/guard/ref.ts b/test/runtime/guard/ref.ts
index ecc260cb6..6a4a8e883 100644
--- a/test/runtime/guard/ref.ts
+++ b/test/runtime/guard/ref.ts
@@ -3,18 +3,18 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TRef', () => {
-  it('should guard for TRef', () => {
+  it('Should guard for TRef', () => {
     const T = Type.Number({ $id: 'T' })
     const R = TypeGuard.TRef(Type.Ref(T))
     Assert.equal(R, true)
   })
 
-  it('should not guard for TRef', () => {
+  it('Should not guard for TRef', () => {
     const R = TypeGuard.TRef(null)
     Assert.equal(R, false)
   })
 
-  it('should not guard for TRef with invalid $ref', () => {
+  it('Should not guard for TRef with invalid $ref', () => {
     const T = Type.Number({ $id: 'T' })
     const S = Type.Ref(T)
     // @ts-ignore
diff --git a/test/runtime/guard/self.ts b/test/runtime/guard/self.ts
index 8777789de..824d77ee8 100644
--- a/test/runtime/guard/self.ts
+++ b/test/runtime/guard/self.ts
@@ -3,14 +3,14 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TSelf', () => {
-  it('should guard for TSelf', () => {
+  it('Should guard for TSelf', () => {
     Type.Recursive((Node) => {
       const R = TypeGuard.TSelf(Node)
       Assert.equal(R, true)
       return Type.Object({ nodes: Type.Array(Node) })
     })
   })
-  it('should guard for TSelf with invalid $ref', () => {
+  it('Should guard for TSelf with invalid $ref', () => {
     Type.Recursive((Node) => {
       // @ts-ignore
       Node.$ref = 1
diff --git a/test/runtime/guard/string.ts b/test/runtime/guard/string.ts
index 598b9bf15..a3cc7c224 100644
--- a/test/runtime/guard/string.ts
+++ b/test/runtime/guard/string.ts
@@ -3,35 +3,35 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TString', () => {
-  it('should guard for TString', () => {
+  it('Should guard for TString', () => {
     const R = TypeGuard.TString(Type.String())
     Assert.equal(R, true)
   })
 
-  it('should not guard for TString', () => {
+  it('Should not guard for TString', () => {
     const R = TypeGuard.TString(null)
     Assert.equal(R, false)
   })
 
-  it('should not guard for TString with invalid $id', () => {
+  it('Should not guard for TString with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TString(Type.String({ $id: 1 }))
     Assert.equal(R, false)
   })
 
-  it('should not guard for TString with invalid minLength', () => {
+  it('Should not guard for TString with invalid minLength', () => {
     // @ts-ignore
     const R = TypeGuard.TString(Type.String({ minLength: '1' }))
     Assert.equal(R, false)
   })
 
-  it('should not guard for TString with invalid maxLength', () => {
+  it('Should not guard for TString with invalid maxLength', () => {
     // @ts-ignore
     const R = TypeGuard.TString(Type.String({ maxLength: '1' }))
     Assert.equal(R, false)
   })
 
-  it('should not guard for TString with invalid pattern', () => {
+  it('Should not guard for TString with invalid pattern', () => {
     // @ts-ignore
     const R = TypeGuard.TString(Type.String({ pattern: 1 }))
     Assert.equal(R, false)
diff --git a/test/runtime/guard/tuple.ts b/test/runtime/guard/tuple.ts
index 765714caf..935426e24 100644
--- a/test/runtime/guard/tuple.ts
+++ b/test/runtime/guard/tuple.ts
@@ -3,20 +3,20 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TTuple', () => {
-  it('should guard for TTuple', () => {
+  it('Should guard for TTuple', () => {
     const R = TypeGuard.TTuple(Type.Tuple([Type.Number(), Type.Number()]))
     Assert.equal(R, true)
   })
-  it('should not guard for TTuple', () => {
+  it('Should not guard for TTuple', () => {
     const R = TypeGuard.TTuple(null)
     Assert.equal(R, false)
   })
-  it('should not guard for TTuple with invalid $id', () => {
+  it('Should not guard for TTuple with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TTuple(Type.Tuple([Type.Number(), Type.Number()], { $id: 1 }))
     Assert.equal(R, false)
   })
-  it('should not guard for TTuple with invalid Items', () => {
+  it('Should not guard for TTuple with invalid Items', () => {
     const R = TypeGuard.TTuple(Type.Tuple([Type.Number(), {} as any]))
     Assert.equal(R, false)
   })
diff --git a/test/runtime/guard/uint8array.ts b/test/runtime/guard/uint8array.ts
index 963d7ad4d..0143c3f47 100644
--- a/test/runtime/guard/uint8array.ts
+++ b/test/runtime/guard/uint8array.ts
@@ -3,29 +3,29 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TUint8Array', () => {
-  it('should guard for TUint8Array', () => {
+  it('Should guard for TUint8Array', () => {
     const R = TypeGuard.TUint8Array(Type.Uint8Array())
     Assert.equal(R, true)
   })
 
-  it('should not guard for TUint8Array', () => {
+  it('Should not guard for TUint8Array', () => {
     const R = TypeGuard.TUint8Array(null)
     Assert.equal(R, false)
   })
 
-  it('should not guard for TUint8Array with invalid $id', () => {
+  it('Should not guard for TUint8Array with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TUint8Array(Type.Uint8Array({ $id: 1 }))
     Assert.equal(R, false)
   })
 
-  it('should not guard for TUint8Array with invalid minByteLength', () => {
+  it('Should not guard for TUint8Array with invalid minByteLength', () => {
     // @ts-ignore
     const R = TypeGuard.TUint8Array(Type.Uint8Array({ minByteLength: '1' }))
     Assert.equal(R, false)
   })
 
-  it('should not guard for TUint8Array with invalid maxByteLength', () => {
+  it('Should not guard for TUint8Array with invalid maxByteLength', () => {
     // @ts-ignore
     const R = TypeGuard.TUint8Array(Type.Uint8Array({ maxByteLength: '1' }))
     Assert.equal(R, false)
diff --git a/test/runtime/guard/undefined.ts b/test/runtime/guard/undefined.ts
index 90c854759..0b7f471c8 100644
--- a/test/runtime/guard/undefined.ts
+++ b/test/runtime/guard/undefined.ts
@@ -3,15 +3,15 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TUndefined', () => {
-  it('should guard for TUndefined', () => {
+  it('Should guard for TUndefined', () => {
     const R = TypeGuard.TUndefined(Type.Undefined())
     Assert.equal(R, true)
   })
-  it('should not guard for TUndefined', () => {
+  it('Should not guard for TUndefined', () => {
     const R = TypeGuard.TUndefined(null)
     Assert.equal(R, false)
   })
-  it('should not guard for TUndefined with invalid $id', () => {
+  it('Should not guard for TUndefined with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TUndefined(Type.Undefined({ $id: 1 }))
     Assert.equal(R, false)
diff --git a/test/runtime/guard/union.ts b/test/runtime/guard/union.ts
index 614a16654..b26465a2e 100644
--- a/test/runtime/guard/union.ts
+++ b/test/runtime/guard/union.ts
@@ -3,7 +3,7 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TUnion', () => {
-  it('should guard for TUnion', () => {
+  it('Should guard for TUnion', () => {
     const R = TypeGuard.TUnion(
       Type.Union([
         Type.Object({
@@ -16,11 +16,11 @@ describe('type/guard/TUnion', () => {
     )
     Assert.equal(R, true)
   })
-  it('should not guard for TUnion', () => {
+  it('Should not guard for TUnion', () => {
     const R = TypeGuard.TUnion(null)
     Assert.equal(R, false)
   })
-  it('should guard for TUnion with invalid $id', () => {
+  it('Should guard for TUnion with invalid $id', () => {
     const R = TypeGuard.TUnion(
       Type.Union(
         [
@@ -39,7 +39,7 @@ describe('type/guard/TUnion', () => {
     )
     Assert.equal(R, false)
   })
-  it('should not guard for TUnion with invalid variant', () => {
+  it('Should not guard for TUnion with invalid variant', () => {
     const R = TypeGuard.TUnion(
       Type.Union([
         Type.Object({
@@ -50,7 +50,7 @@ describe('type/guard/TUnion', () => {
     )
     Assert.equal(R, false)
   })
-  it('should not guard for TUnion with invalid object variant', () => {
+  it('Should not guard for TUnion with invalid object variant', () => {
     const R = TypeGuard.TUnion(
       Type.Union([
         Type.Object({
diff --git a/test/runtime/guard/unknown.ts b/test/runtime/guard/unknown.ts
index 443698bd3..d23f2c267 100644
--- a/test/runtime/guard/unknown.ts
+++ b/test/runtime/guard/unknown.ts
@@ -3,15 +3,15 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TUnknown', () => {
-  it('should guard for TUnknown', () => {
+  it('Should guard for TUnknown', () => {
     const R = TypeGuard.TUnknown(Type.Unknown())
     Assert.equal(R, true)
   })
-  it('should not guard for TUnknown', () => {
+  it('Should not guard for TUnknown', () => {
     const R = TypeGuard.TUnknown(null)
     Assert.equal(R, false)
   })
-  it('should not guard for TUnknown with invalid $id', () => {
+  it('Should not guard for TUnknown with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TUnknown(Type.Unknown({ $id: 1 }))
     Assert.equal(R, false)
diff --git a/test/runtime/guard/void.ts b/test/runtime/guard/void.ts
index b0565e69a..d513f5f2a 100644
--- a/test/runtime/guard/void.ts
+++ b/test/runtime/guard/void.ts
@@ -3,15 +3,15 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 
 describe('type/guard/TVoid', () => {
-  it('should guard for TVoid', () => {
+  it('Should guard for TVoid', () => {
     const R = TypeGuard.TVoid(Type.Void())
     Assert.equal(R, true)
   })
-  it('should not guard for TVoid', () => {
+  it('Should not guard for TVoid', () => {
     const R = TypeGuard.TVoid(null)
     Assert.equal(R, false)
   })
-  it('should not guard for TVoid with invalid $id', () => {
+  it('Should not guard for TVoid with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TVoid(Type.Void({ $id: 1 }))
     Assert.equal(R, false)
diff --git a/test/runtime/schema/date.ts b/test/runtime/schema/date.ts
new file mode 100644
index 000000000..8e468665c
--- /dev/null
+++ b/test/runtime/schema/date.ts
@@ -0,0 +1,62 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+// ----------------------------------------------------
+// These tests are implemented by way of .addKeyword()
+// which are configured to use Value.Check()
+// ----------------------------------------------------
+
+describe('type/schema/Date', () => {
+  it('Should not validate number', () => {
+    const T = Type.Date()
+    fail(T, 1)
+  })
+  it('Should not validate string', () => {
+    const T = Type.Date()
+    fail(T, 'hello')
+  })
+  it('Should not validate boolean', () => {
+    const T = Type.Date()
+    fail(T, true)
+  })
+  it('Should not validate array', () => {
+    const T = Type.Date()
+    fail(T, [1, 2, 3])
+  })
+  it('Should not validate object', () => {
+    const T = Type.Date()
+    fail(T, { a: 1, b: 2 })
+  })
+  it('Should not validate null', () => {
+    const T = Type.Date()
+    fail(T, null)
+  })
+  it('Should not validate undefined', () => {
+    const T = Type.Date()
+    fail(T, undefined)
+  })
+  it('Should validate Date', () => {
+    const T = Type.Date()
+    ok(T, new Date())
+  })
+  it('Should validate Date minimumTimestamp', () => {
+    const T = Type.Date({ minimumTimestamp: 10 })
+    fail(T, new Date(9))
+    ok(T, new Date(10))
+  })
+  it('Should validate Date maximumTimestamp', () => {
+    const T = Type.Date({ maximumTimestamp: 10 })
+    ok(T, new Date(10))
+    fail(T, new Date(11))
+  })
+  it('Should validate Date exclusiveMinimumTimestamp', () => {
+    const T = Type.Date({ exclusiveMinimumTimestamp: 10 })
+    fail(T, new Date(10))
+    ok(T, new Date(11))
+  })
+  it('Should validate Date exclusiveMaximumTimestamp', () => {
+    const T = Type.Date({ exclusiveMaximumTimestamp: 10 })
+    ok(T, new Date(9))
+    fail(T, new Date(10))
+  })
+})
diff --git a/test/runtime/schema/index.ts b/test/runtime/schema/index.ts
index 401e007a9..d0053aa86 100644
--- a/test/runtime/schema/index.ts
+++ b/test/runtime/schema/index.ts
@@ -1,7 +1,9 @@
 import './any'
 import './array'
 import './boolean'
+import './date'
 import './enum'
+import './integer'
 import './intersect'
 import './keyof'
 import './literal'
@@ -23,6 +25,7 @@ import './regex'
 import './required'
 import './string'
 import './tuple'
+import './uint8array'
 import './union'
 import './unknown'
 import './unsafe'
diff --git a/test/runtime/schema/integer.ts b/test/runtime/schema/integer.ts
new file mode 100644
index 000000000..da32a8766
--- /dev/null
+++ b/test/runtime/schema/integer.ts
@@ -0,0 +1,67 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/Integer', () => {
+  it('Should not validate number', () => {
+    const T = Type.Integer()
+    fail(T, 3.14)
+  })
+
+  it('Should validate integer', () => {
+    const T = Type.Integer()
+    ok(T, 1)
+  })
+
+  it('Should not validate string', () => {
+    const T = Type.Integer()
+    fail(T, 'hello')
+  })
+
+  it('Should not validate boolean', () => {
+    const T = Type.Integer()
+    fail(T, true)
+  })
+
+  it('Should not validate array', () => {
+    const T = Type.Integer()
+    fail(T, [1, 2, 3])
+  })
+
+  it('Should not validate object', () => {
+    const T = Type.Integer()
+    fail(T, { a: 1, b: 2 })
+  })
+
+  it('Should not validate null', () => {
+    const T = Type.Integer()
+    fail(T, null)
+  })
+  it('Should not validate undefined', () => {
+    const T = Type.Integer()
+    fail(T, undefined)
+  })
+
+  it('Should validate minimum', () => {
+    const T = Type.Integer({ minimum: 10 })
+    fail(T, 9)
+    ok(T, 10)
+  })
+
+  it('Should validate maximum', () => {
+    const T = Type.Integer({ maximum: 10 })
+    ok(T, 10)
+    fail(T, 11)
+  })
+
+  it('Should validate Date exclusiveMinimum', () => {
+    const T = Type.Integer({ exclusiveMinimum: 10 })
+    fail(T, 10)
+    ok(T, 11)
+  })
+
+  it('Should validate Date exclusiveMaximum', () => {
+    const T = Type.Integer({ exclusiveMaximum: 10 })
+    ok(T, 9)
+    fail(T, 10)
+  })
+})
diff --git a/test/runtime/schema/number.ts b/test/runtime/schema/number.ts
index 62d509c0f..b1a19ea72 100644
--- a/test/runtime/schema/number.ts
+++ b/test/runtime/schema/number.ts
@@ -3,9 +3,15 @@ import { ok, fail } from './validate'
 
 describe('type/schema/Number', () => {
   it('Should validate number', () => {
+    const T = Type.Number()
+    ok(T, 3.14)
+  })
+
+  it('Should validate integer', () => {
     const T = Type.Number()
     ok(T, 1)
   })
+
   it('Should not validate string', () => {
     const T = Type.Number()
     fail(T, 'hello')
@@ -30,4 +36,28 @@ describe('type/schema/Number', () => {
     const T = Type.Number()
     fail(T, undefined)
   })
+
+  it('Should validate minimum', () => {
+    const T = Type.Number({ minimum: 10 })
+    fail(T, 9)
+    ok(T, 10)
+  })
+
+  it('Should validate maximum', () => {
+    const T = Type.Number({ maximum: 10 })
+    ok(T, 10)
+    fail(T, 11)
+  })
+
+  it('Should validate Date exclusiveMinimum', () => {
+    const T = Type.Number({ exclusiveMinimum: 10 })
+    fail(T, 10)
+    ok(T, 11)
+  })
+
+  it('Should validate Date exclusiveMaximum', () => {
+    const T = Type.Number({ exclusiveMaximum: 10 })
+    ok(T, 9)
+    fail(T, 10)
+  })
 })
diff --git a/test/runtime/schema/uint8array.ts b/test/runtime/schema/uint8array.ts
new file mode 100644
index 000000000..e1f7e0f68
--- /dev/null
+++ b/test/runtime/schema/uint8array.ts
@@ -0,0 +1,56 @@
+import { Type } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/schema/Uint8Array', () => {
+  it('Should not validate number', () => {
+    const T = Type.Uint8Array()
+    fail(T, 1)
+  })
+
+  it('Should not validate string', () => {
+    const T = Type.Uint8Array()
+    fail(T, 'hello')
+  })
+
+  it('Should not validate boolean', () => {
+    const T = Type.Uint8Array()
+    fail(T, true)
+  })
+
+  it('Should not validate array', () => {
+    const T = Type.Uint8Array()
+    fail(T, [1, 2, 3])
+  })
+
+  it('Should not validate object', () => {
+    const T = Type.Uint8Array()
+    fail(T, { a: 1, b: 2 })
+  })
+
+  it('Should not validate null', () => {
+    const T = Type.Uint8Array()
+    fail(T, null)
+  })
+
+  it('Should not validate undefined', () => {
+    const T = Type.Uint8Array()
+    fail(T, undefined)
+  })
+
+  it('Should validate Uint8Array', () => {
+    const T = Type.Uint8Array()
+    ok(T, new Uint8Array(100))
+  })
+
+  it('Should validate minByteLength', () => {
+    const T = Type.Uint8Array({ minByteLength: 4 })
+    ok(T, new Uint8Array(4))
+    fail(T, new Uint8Array(3))
+  })
+
+  it('Should validate maxByteLength', () => {
+    const T = Type.Uint8Array({ maxByteLength: 4 })
+    ok(T, new Uint8Array(4))
+    fail(T, new Uint8Array(5))
+  })
+})
diff --git a/test/runtime/schema/validate.ts b/test/runtime/schema/validate.ts
index f12181907..bd1f822f7 100644
--- a/test/runtime/schema/validate.ts
+++ b/test/runtime/schema/validate.ts
@@ -1,16 +1,46 @@
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Value } from '@sinclair/typebox/value'
+
 import { TSchema } from '@sinclair/typebox'
 import addFormats from 'ajv-formats'
 import Ajv, { AnySchema } from 'ajv/dist/2019'
 
-export function validator(additional: AnySchema[]) {
+function schemaOf(schemaOf: string, value: unknown, schema: unknown) {
+  switch (schemaOf) {
+    case 'Constructor':
+      return TypeGuard.TConstructor(schema) && Value.Check(schema, value)
+    case 'Function':
+      return TypeGuard.TFunction(schema) && Value.Check(schema, value)
+    case 'Date':
+      return TypeGuard.TDate(schema) && Value.Check(schema, value)
+    case 'Promise':
+      return TypeGuard.TPromise(schema) && Value.Check(schema, value)
+    case 'Uint8Array':
+      return TypeGuard.TUint8Array(schema) && Value.Check(schema, value)
+    case 'Undefined':
+      return TypeGuard.TUndefined(schema) && Value.Check(schema, value)
+    case 'Void':
+      return TypeGuard.TVoid(schema) && Value.Check(schema, value)
+    default:
+      return false
+  }
+}
+
+export function createAjv(references: AnySchema[]) {
   return addFormats(new Ajv({}), ['date-time', 'time', 'date', 'email', 'hostname', 'ipv4', 'ipv6', 'uri', 'uri-reference', 'uuid', 'uri-template', 'json-pointer', 'relative-json-pointer', 'regex'])
-    .addKeyword('kind')
-    .addKeyword('modifier')
-    .addSchema(additional)
+    .addKeyword({ type: 'object', keyword: 'instanceOf', validate: schemaOf })
+    .addKeyword({ type: 'null', keyword: 'typeOf', validate: schemaOf })
+    .addKeyword('exclusiveMinimumTimestamp')
+    .addKeyword('exclusiveMaximumTimestamp')
+    .addKeyword('minimumTimestamp')
+    .addKeyword('maximumTimestamp')
+    .addKeyword('minByteLength')
+    .addKeyword('maxByteLength')
+    .addSchema(references)
 }
 
 export function ok<T extends TSchema>(type: T, data: unknown, additional: AnySchema[] = []) {
-  const ajv = validator(additional)
+  const ajv = createAjv(additional)
   function execute() {
     // required as ajv will throw if referenced schema is not found
     try {
@@ -37,7 +67,7 @@ export function ok<T extends TSchema>(type: T, data: unknown, additional: AnySch
 }
 
 export function fail<T extends TSchema>(type: T, data: unknown, additional: AnySchema[] = []) {
-  const ajv = validator(additional)
+  const ajv = createAjv(additional)
   function execute() {
     // required as ajv will throw if referenced schema is not found
     try {
diff --git a/test/runtime/value/cast/any.ts b/test/runtime/value/cast/any.ts
index 5fcace73f..155b2fcaa 100644
--- a/test/runtime/value/cast/any.ts
+++ b/test/runtime/value/cast/any.ts
@@ -34,11 +34,19 @@ describe('value/cast/Any', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
+
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
+
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result.getTime(100), 100)
+  })
+
   it('Should preserve', () => {
     const value = { a: 1, b: 2 }
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/array.ts b/test/runtime/value/cast/array.ts
index d23c59218..fca7b4719 100644
--- a/test/runtime/value/cast/array.ts
+++ b/test/runtime/value/cast/array.ts
@@ -48,6 +48,12 @@ describe('value/cast/Array', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should preserve', () => {
     const value = [6, 7, 8]
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/boolean.ts b/test/runtime/value/cast/boolean.ts
index e7a3c8023..d0267b52e 100644
--- a/test/runtime/value/cast/boolean.ts
+++ b/test/runtime/value/cast/boolean.ts
@@ -45,6 +45,12 @@ describe('value/cast/Boolean', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should preserve', () => {
     const value = true
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/date.ts b/test/runtime/value/cast/date.ts
new file mode 100644
index 000000000..69c26dc40
--- /dev/null
+++ b/test/runtime/value/cast/date.ts
@@ -0,0 +1,56 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Date', () => {
+  const T = Type.Date()
+  const E = new Date(0)
+
+  it('Should upcast from string', () => {
+    const value = 'world'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preseve', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result.getTime(), 100)
+  })
+})
diff --git a/test/runtime/value/cast/enum.ts b/test/runtime/value/cast/enum.ts
index 232505ac7..e75d5bdd8 100644
--- a/test/runtime/value/cast/enum.ts
+++ b/test/runtime/value/cast/enum.ts
@@ -15,21 +15,25 @@ describe('value/cast/Boolean', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from number', () => {
     const value = 123
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
@@ -48,6 +52,12 @@ describe('value/cast/Boolean', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should upcast from enum A', () => {
     const value = Foo.A
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/index.ts b/test/runtime/value/cast/index.ts
index 14b81b055..74b79cd8a 100644
--- a/test/runtime/value/cast/index.ts
+++ b/test/runtime/value/cast/index.ts
@@ -2,17 +2,17 @@ import './any'
 import './array'
 import './boolean'
 import './convert'
+import './date'
 import './enum'
 import './integer'
 import './intersect'
 import './keyof'
 import './literal'
-import './namespace'
 import './never'
 import './null'
 import './number'
 import './object'
-import './rec'
+import './recursive'
 import './record'
 import './regex'
 import './string'
diff --git a/test/runtime/value/cast/integer.ts b/test/runtime/value/cast/integer.ts
index 1f026ac8e..194fd7b18 100644
--- a/test/runtime/value/cast/integer.ts
+++ b/test/runtime/value/cast/integer.ts
@@ -11,16 +11,19 @@ describe('value/cast/Integer', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, 1)
   })
+
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, 1) // conversion
   })
+
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
@@ -44,4 +47,10 @@ describe('value/cast/Integer', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
 })
diff --git a/test/runtime/value/cast/intersect.ts b/test/runtime/value/cast/intersect.ts
index 78e2c0bb5..ed3ade161 100644
--- a/test/runtime/value/cast/intersect.ts
+++ b/test/runtime/value/cast/intersect.ts
@@ -28,16 +28,19 @@ describe('value/cast/Intersect', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from number', () => {
     const value = E
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
@@ -62,6 +65,12 @@ describe('value/cast/Intersect', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should upcast and preserve object', () => {
     const value = { x: 7, y: 8, z: 9 }
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/keyof.ts b/test/runtime/value/cast/keyof.ts
index c9c2b9c9c..b18d1f56f 100644
--- a/test/runtime/value/cast/keyof.ts
+++ b/test/runtime/value/cast/keyof.ts
@@ -54,6 +54,12 @@ describe('value/cast/KeyOf', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should preserve', () => {
     const value = 'y'
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/literal.ts b/test/runtime/value/cast/literal.ts
index bf0174a77..ae2e27083 100644
--- a/test/runtime/value/cast/literal.ts
+++ b/test/runtime/value/cast/literal.ts
@@ -11,16 +11,19 @@ describe('value/cast/Literal', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
@@ -45,6 +48,12 @@ describe('value/cast/Literal', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should preseve', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/namespace.ts b/test/runtime/value/cast/namespace.ts
deleted file mode 100644
index e69de29bb..000000000
diff --git a/test/runtime/value/cast/never.ts b/test/runtime/value/cast/never.ts
index d8ec459fe..c493f32f2 100644
--- a/test/runtime/value/cast/never.ts
+++ b/test/runtime/value/cast/never.ts
@@ -32,4 +32,8 @@ describe('value/cast/Never', () => {
     const value = null
     Assert.throws(() => Value.Cast(T, value))
   })
+  it('Should upcast from date', () => {
+    const value = null
+    Assert.throws(() => Value.Cast(T, value))
+  })
 })
diff --git a/test/runtime/value/cast/null.ts b/test/runtime/value/cast/null.ts
index 5857121e2..06eb0f344 100644
--- a/test/runtime/value/cast/null.ts
+++ b/test/runtime/value/cast/null.ts
@@ -11,16 +11,19 @@ describe('value/cast/Null', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
@@ -45,6 +48,12 @@ describe('value/cast/Null', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should preseve', () => {
     const value = null
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/number.ts b/test/runtime/value/cast/number.ts
index 273f1f4ab..1fbd51807 100644
--- a/test/runtime/value/cast/number.ts
+++ b/test/runtime/value/cast/number.ts
@@ -11,16 +11,19 @@ describe('value/cast/Number', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, 1)
   })
+
   it('Should upcast from boolean', () => {
     const value = true // convert
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, 1)
   })
+
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
@@ -45,6 +48,12 @@ describe('value/cast/Number', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should preseve', () => {
     const value = 123
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/object.ts b/test/runtime/value/cast/object.ts
index 71bd0bf01..544ab46d8 100644
--- a/test/runtime/value/cast/object.ts
+++ b/test/runtime/value/cast/object.ts
@@ -59,6 +59,13 @@ describe('value/cast/Object', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should preserve', () => {
     const value = { x: 7, y: 8, z: 9, a: 10, b: 11, c: 12 }
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/record.ts b/test/runtime/value/cast/record.ts
index c8e9dd350..32b5c53c4 100644
--- a/test/runtime/value/cast/record.ts
+++ b/test/runtime/value/cast/record.ts
@@ -53,6 +53,12 @@ describe('value/cast/Record', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should preserve', () => {
     const value = {
       a: { x: 1, y: 2, z: 3 },
@@ -61,6 +67,7 @@ describe('value/cast/Record', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
+
   it('Should preserve and patch invalid records', () => {
     const value = {
       a: { x: 1, y: 2, z: 3 },
diff --git a/test/runtime/value/cast/rec.ts b/test/runtime/value/cast/recursive.ts
similarity index 94%
rename from test/runtime/value/cast/rec.ts
rename to test/runtime/value/cast/recursive.ts
index 478a5fc87..0db482577 100644
--- a/test/runtime/value/cast/rec.ts
+++ b/test/runtime/value/cast/recursive.ts
@@ -17,11 +17,13 @@ describe('value/cast/Recursive', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from number', () => {
     const value = E
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
@@ -52,6 +54,12 @@ describe('value/cast/Recursive', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should preserve', () => {
     const value = {
       id: 'A',
diff --git a/test/runtime/value/cast/regex.ts b/test/runtime/value/cast/regex.ts
index c973dba37..3adb18c98 100644
--- a/test/runtime/value/cast/regex.ts
+++ b/test/runtime/value/cast/regex.ts
@@ -17,16 +17,19 @@ describe('value/cast/RegEx', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
@@ -45,6 +48,12 @@ describe('value/cast/RegEx', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should preserve', () => {
     const value = 'foo'
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/string.ts b/test/runtime/value/cast/string.ts
index 9b5fa1ef7..28b7f2066 100644
--- a/test/runtime/value/cast/string.ts
+++ b/test/runtime/value/cast/string.ts
@@ -29,6 +29,7 @@ describe('value/cast/String', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
@@ -47,6 +48,12 @@ describe('value/cast/String', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should preserve', () => {
     const value = 'foo'
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/tuple.ts b/test/runtime/value/cast/tuple.ts
index 4ecb10d96..c26831b24 100644
--- a/test/runtime/value/cast/tuple.ts
+++ b/test/runtime/value/cast/tuple.ts
@@ -48,6 +48,12 @@ describe('value/cast/Tuple', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should preserve', () => {
     const value = [42, 'world']
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/uint8array.ts b/test/runtime/value/cast/uint8array.ts
index edcdef5de..bd861b452 100644
--- a/test/runtime/value/cast/uint8array.ts
+++ b/test/runtime/value/cast/uint8array.ts
@@ -17,16 +17,19 @@ describe('value/cast/Uint8Array', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
@@ -45,6 +48,12 @@ describe('value/cast/Uint8Array', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should preserve', () => {
     const value = new Uint8Array([6, 7, 8, 9, 10])
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/undefined.ts b/test/runtime/value/cast/undefined.ts
index 62de89959..36a67693f 100644
--- a/test/runtime/value/cast/undefined.ts
+++ b/test/runtime/value/cast/undefined.ts
@@ -11,16 +11,19 @@ describe('value/cast/Undefined', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
@@ -45,6 +48,12 @@ describe('value/cast/Undefined', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should preseve', () => {
     const value = undefined
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/union.ts b/test/runtime/value/cast/union.ts
index 5998527da..f8db7ca4c 100644
--- a/test/runtime/value/cast/union.ts
+++ b/test/runtime/value/cast/union.ts
@@ -41,16 +41,19 @@ describe('value/cast/Union', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
@@ -69,6 +72,12 @@ describe('value/cast/Union', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should preserve A', () => {
     const value = { type: 'A', x: 1, y: 2, z: 3 }
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/unknown.ts b/test/runtime/value/cast/unknown.ts
index 5a98faa9c..66f333d7e 100644
--- a/test/runtime/value/cast/unknown.ts
+++ b/test/runtime/value/cast/unknown.ts
@@ -4,26 +4,31 @@ import { Assert } from '../../assert/index'
 
 describe('value/cast/Unknown', () => {
   const T = Type.Unknown()
+
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
+
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
+
   it('Should upcast from boolean', () => {
     const value = false
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
+
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
+
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
@@ -42,6 +47,12 @@ describe('value/cast/Unknown', () => {
     Assert.deepEqual(result, value)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result: any = Value.Cast(T, value)
+    Assert.deepEqual(result.getTime(), 100)
+  })
+
   it('Should preserve', () => {
     const value = { a: 1, b: 2 }
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/void.ts b/test/runtime/value/cast/void.ts
index 33e53e02d..93d491d82 100644
--- a/test/runtime/value/cast/void.ts
+++ b/test/runtime/value/cast/void.ts
@@ -11,16 +11,19 @@ describe('value/cast/Void', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
+
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
@@ -45,6 +48,12 @@ describe('value/cast/Void', () => {
     Assert.deepEqual(result, E)
   })
 
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
   it('Should preserve', () => {
     const value = null
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/check/any.ts b/test/runtime/value/check/any.ts
index 15f31b510..a9fab67d4 100644
--- a/test/runtime/value/check/any.ts
+++ b/test/runtime/value/check/any.ts
@@ -39,4 +39,9 @@ describe('value/check/Any', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, true)
   })
+  it('Should pass Date', () => {
+    const value = new Date()
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
 })
diff --git a/test/runtime/value/check/array.ts b/test/runtime/value/check/array.ts
index 5b7b327e1..909b093c6 100644
--- a/test/runtime/value/check/array.ts
+++ b/test/runtime/value/check/array.ts
@@ -30,4 +30,9 @@ describe('value/check/Array', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
+  it('Should fail Date', () => {
+    const value = new Date()
+    const result = Value.Check(Type.Array(Type.Any()), value)
+    Assert.equal(result, false)
+  })
 })
diff --git a/test/runtime/value/check/boolean.ts b/test/runtime/value/check/boolean.ts
index 003bc296a..887f3f020 100644
--- a/test/runtime/value/check/boolean.ts
+++ b/test/runtime/value/check/boolean.ts
@@ -39,4 +39,9 @@ describe('value/check/Boolean', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
+  it('Should fail Date', () => {
+    const value = new Date()
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
 })
diff --git a/test/runtime/value/check/date.ts b/test/runtime/value/check/date.ts
new file mode 100644
index 000000000..583e1b620
--- /dev/null
+++ b/test/runtime/value/check/date.ts
@@ -0,0 +1,47 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Date', () => {
+  const T = Type.Date()
+  it('Should fail string', () => {
+    const value = 'hello'
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail number', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail boolean', () => {
+    const value = true
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail null', () => {
+    const value = null
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail undefined', () => {
+    const value = undefined
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail object', () => {
+    const value = { a: 1 }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail array', () => {
+    const value = [1, 2]
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should pass Date', () => {
+    const value = new Date()
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+})
diff --git a/test/runtime/value/check/enum.ts b/test/runtime/value/check/enum.ts
index 505625ca9..5eb8c08e6 100644
--- a/test/runtime/value/check/enum.ts
+++ b/test/runtime/value/check/enum.ts
@@ -26,4 +26,9 @@ describe('value/check/Enum', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
+  it('Should fail Date', () => {
+    const value = new Date()
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
 })
diff --git a/test/runtime/value/check/index.ts b/test/runtime/value/check/index.ts
index e617cfa64..26759b50d 100644
--- a/test/runtime/value/check/index.ts
+++ b/test/runtime/value/check/index.ts
@@ -1,6 +1,7 @@
 import './any'
 import './array'
 import './boolean'
+import './date'
 import './enum'
 import './integer'
 import './intersect'
@@ -10,7 +11,7 @@ import './never'
 import './null'
 import './number'
 import './object'
-import './rec'
+import './recursive'
 import './record'
 import './regex'
 import './string'
diff --git a/test/runtime/value/check/integer.ts b/test/runtime/value/check/integer.ts
index 27ab4d396..59a74024c 100644
--- a/test/runtime/value/check/integer.ts
+++ b/test/runtime/value/check/integer.ts
@@ -16,4 +16,9 @@ describe('value/check/Integer', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
+  it('Should fail Date', () => {
+    const value = new Date()
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
 })
diff --git a/test/runtime/value/check/null.ts b/test/runtime/value/check/null.ts
index f2cbc93ff..15b9f786b 100644
--- a/test/runtime/value/check/null.ts
+++ b/test/runtime/value/check/null.ts
@@ -39,4 +39,9 @@ describe('value/check/Null', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
+  it('Should fail Date', () => {
+    const value = new Date()
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
 })
diff --git a/test/runtime/value/check/number.ts b/test/runtime/value/check/number.ts
index f6b34bebf..4d9b14d6c 100644
--- a/test/runtime/value/check/number.ts
+++ b/test/runtime/value/check/number.ts
@@ -39,4 +39,9 @@ describe('value/check/Number', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
+  it('Should fail Date', () => {
+    const value = new Date()
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
 })
diff --git a/test/runtime/value/check/rec.ts b/test/runtime/value/check/recursive.ts
similarity index 100%
rename from test/runtime/value/check/rec.ts
rename to test/runtime/value/check/recursive.ts
diff --git a/test/runtime/value/check/string.ts b/test/runtime/value/check/string.ts
index 85737681a..7db4daca3 100644
--- a/test/runtime/value/check/string.ts
+++ b/test/runtime/value/check/string.ts
@@ -39,4 +39,9 @@ describe('value/check/String', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
+  it('Should fail Date', () => {
+    const value = new Date()
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
 })
diff --git a/test/runtime/value/check/uint8array.ts b/test/runtime/value/check/uint8array.ts
index f792d8147..9940e7c4a 100644
--- a/test/runtime/value/check/uint8array.ts
+++ b/test/runtime/value/check/uint8array.ts
@@ -3,28 +3,28 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/check/Uint8Array', () => {
-  it('Should pass uint8array', () => {
+  it('Should pass Uint8Array', () => {
     const T = Type.Uint8Array()
     const value = new Uint8Array(4)
     const result = Value.Check(T, value)
     Assert.equal(result, true)
   })
 
-  it('Should fail uint8array', () => {
+  it('Should fail Uint8Array', () => {
     const T = Type.Uint8Array()
     const value = [0, 1, 2, 3]
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
 
-  it('Should fail uint8array with undefined', () => {
+  it('Should fail Uint8Array with undefined', () => {
     const T = Type.Uint8Array()
     const value = undefined
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
 
-  it('Should fail uint8array with null', () => {
+  it('Should fail Uint8Array with null', () => {
     const T = Type.Uint8Array()
     const value = null
     const result = Value.Check(T, value)
diff --git a/test/runtime/value/check/undefined.ts b/test/runtime/value/check/undefined.ts
index 162022385..83b6f3383 100644
--- a/test/runtime/value/check/undefined.ts
+++ b/test/runtime/value/check/undefined.ts
@@ -39,4 +39,9 @@ describe('value/check/Undefined', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
+  it('Should fail Date', () => {
+    const value = new Date()
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
 })
diff --git a/test/runtime/value/check/unknown.ts b/test/runtime/value/check/unknown.ts
index 1bb814596..19e305188 100644
--- a/test/runtime/value/check/unknown.ts
+++ b/test/runtime/value/check/unknown.ts
@@ -39,4 +39,9 @@ describe('value/check/Unknown', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, true)
   })
+  it('Should pass Date', () => {
+    const value = new Date()
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
 })
diff --git a/test/runtime/value/check/void.ts b/test/runtime/value/check/void.ts
index b9d01c1f3..c6079c354 100644
--- a/test/runtime/value/check/void.ts
+++ b/test/runtime/value/check/void.ts
@@ -39,4 +39,9 @@ describe('value/check/Void', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
+  it('Should fail Date', () => {
+    const value = new Date()
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
 })
diff --git a/test/static/constructor-parameters.ts b/test/static/constructor-parameters.ts
new file mode 100644
index 000000000..68081e37f
--- /dev/null
+++ b/test/static/constructor-parameters.ts
@@ -0,0 +1,13 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+const C = Type.Constructor(
+  [Type.Number(), Type.String()],
+  Type.Object({
+    method: Type.Function([Type.Number(), Type.String()], Type.Boolean()),
+  }),
+)
+
+const P = Type.ConstructorParameters(C)
+
+Expect(P).ToInfer<[number, string]>()
diff --git a/test/static/constructor.ts b/test/static/constructor.ts
new file mode 100644
index 000000000..8e05d8c40
--- /dev/null
+++ b/test/static/constructor.ts
@@ -0,0 +1,11 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+const C = Type.Constructor(
+  [Type.Number(), Type.String()],
+  Type.Object({
+    method: Type.Function([Type.Number(), Type.String()], Type.Boolean()),
+  }),
+)
+
+Expect(C).ToInfer<new (param_0: number, param_1: string) => { method: (param_0: number, param_1: string) => boolean }>()
diff --git a/test/static/date.ts b/test/static/date.ts
new file mode 100644
index 000000000..5907ac9eb
--- /dev/null
+++ b/test/static/date.ts
@@ -0,0 +1,4 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.Date()).ToInfer<Date>()
diff --git a/test/static/function.ts b/test/static/function.ts
new file mode 100644
index 000000000..824075f7c
--- /dev/null
+++ b/test/static/function.ts
@@ -0,0 +1,11 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+const C = Type.Function(
+  [Type.Number(), Type.String()],
+  Type.Object({
+    method: Type.Function([Type.Number(), Type.String()], Type.Boolean()),
+  }),
+)
+
+Expect(C).ToInfer<(param_0: number, param_1: string) => { method: (param_0: number, param_1: string) => boolean }>()
diff --git a/test/static/index.ts b/test/static/index.ts
index 909c65591..cc84ce321 100644
--- a/test/static/index.ts
+++ b/test/static/index.ts
@@ -1,6 +1,7 @@
 import './any'
 import './array'
 import './boolean'
+import './date'
 import './constructor-parameters'
 import './constructor'
 import './emum'
diff --git a/test/static/parameters.ts b/test/static/parameters.ts
new file mode 100644
index 000000000..02ad9c989
--- /dev/null
+++ b/test/static/parameters.ts
@@ -0,0 +1,13 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+const C = Type.Function(
+  [Type.Number(), Type.String()],
+  Type.Object({
+    method: Type.Function([Type.Number(), Type.String()], Type.Boolean()),
+  }),
+)
+
+const P = Type.Parameters(C)
+
+Expect(P).ToInfer<[number, string]>()

From fcf926e60c8136b779fe5fd338aa5f1508cbc802 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sat, 29 Oct 2022 06:03:03 +0900
Subject: [PATCH 025/369] Rename error reporting enums to date constraints

---
 package.json         |  2 +-
 src/errors/errors.ts | 16 ++++++++--------
 src/typebox.ts       |  2 +-
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/package.json b/package.json
index fbc4bf63f..5bfde7d27 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.0",
+  "version": "0.25.1",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 98fd0bf6c..db4830256 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -40,10 +40,10 @@ export enum ValueErrorType {
   ArrayUniqueItems,
   Boolean,
   Date,
-  DateExclusiveMinimum,
-  DateExclusiveMaximum,
-  DateMinimum,
-  DateMaximum,
+  DateExclusiveMinimumTimestamp,
+  DateExclusiveMaximumTimestamp,
+  DateMinimumTimestamp,
+  DateMaximumTimestamp,
   Function,
   Integer,
   IntegerMultipleOf,
@@ -142,16 +142,16 @@ export namespace ValueErrors {
       return yield { type: ValueErrorType.Date, schema, path, value, message: `Expected Date object` }
     }
     if (schema.exclusiveMinimumTimestamp && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
-      yield { type: ValueErrorType.DateExclusiveMinimum, schema, path, value, message: `Expected Date timestamp to be greater than ${schema.exclusiveMinimum}` }
+      yield { type: ValueErrorType.DateExclusiveMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater than ${schema.exclusiveMinimum}` }
     }
     if (schema.exclusiveMaximumTimestamp && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
-      yield { type: ValueErrorType.DateExclusiveMaximum, schema, path, value, message: `Expected Date timestamp to be less than ${schema.exclusiveMaximum}` }
+      yield { type: ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less than ${schema.exclusiveMaximum}` }
     }
     if (schema.minimumTimestamp && !(value.getTime() >= schema.minimumTimestamp)) {
-      yield { type: ValueErrorType.DateMinimum, schema, path, value, message: `Expected Date timestamp to be greater or equal to ${schema.minimum}` }
+      yield { type: ValueErrorType.DateMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater or equal to ${schema.minimum}` }
     }
     if (schema.maximumTimestamp && !(value.getTime() <= schema.maximumTimestamp)) {
-      yield { type: ValueErrorType.DateMaximum, schema, path, value, message: `Expected Date timestamp to be less or equal to ${schema.maximum}` }
+      yield { type: ValueErrorType.DateMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less or equal to ${schema.maximum}` }
     }
   }
 
diff --git a/src/typebox.ts b/src/typebox.ts
index 5c8daf5cb..ebacf611f 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -413,7 +413,7 @@ export interface TRecord<K extends TRecordKey = TRecordKey, T extends TSchema =
 }
 
 // --------------------------------------------------------------------------
-// Rec
+// Recursive
 // --------------------------------------------------------------------------
 
 export interface TSelf extends TSchema {

From a0793a890c28a5d55132deef19dbdceb535f13f0 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Mon, 31 Oct 2022 16:30:14 +0900
Subject: [PATCH 026/369] Compiler Argument TNull to TNever

---
 package-lock.json        | 4 ++--
 src/compiler/compiler.ts | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 0754cb51b..9128aeaa5 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.39",
+  "version": "0.25.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.24.39",
+      "version": "0.25.1",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index a7f41db03..3c797dbfc 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -161,7 +161,7 @@ export namespace TypeCompiler {
     }
   }
 
-  function* Never(schema: Types.TNull, value: string): IterableIterator<string> {
+  function* Never(schema: Types.TNever, value: string): IterableIterator<string> {
     yield `(false)`
   }
 

From 09186986f5e06db597d87e5dd34783b9ef73608f Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Mon, 31 Oct 2022 21:29:19 +0900
Subject: [PATCH 027/369] Enclose Expression to Ensure Evaluation is Scoped

---
 package.json             | 2 +-
 src/compiler/compiler.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/package.json b/package.json
index 5bfde7d27..d194415ad 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.1",
+  "version": "0.25.2",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 3c797dbfc..9ef44a813 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -378,7 +378,7 @@ export namespace TypeCompiler {
   }
 
   function CreateExpression(schema: Types.TSchema, value: string): string {
-    return [...Visit(schema, value)].join(' && ')
+    return `(${[...Visit(schema, value)].join(' && ')})`
   }
 
   function CreateFunctionName($id: string) {

From cea45f1c67e2838e2029e842707a5ef477d8f273 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 8 Nov 2022 16:20:26 +0900
Subject: [PATCH 028/369] Union Cast Uses Default Value

---
 package.json                     |   2 +-
 src/value/cast.ts                | 123 ++++++++++++++++---------------
 src/value/create.ts              |  12 ---
 test/runtime/value/cast/union.ts |  34 +++++++++
 4 files changed, 97 insertions(+), 74 deletions(-)

diff --git a/package.json b/package.json
index d194415ad..e056ba896 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.2",
+  "version": "0.25.3",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/cast.ts b/src/value/cast.ts
index fda08eb81..19c7b9133 100644
--- a/src/value/cast.ts
+++ b/src/value/cast.ts
@@ -31,13 +31,47 @@ import { ValueCreate } from './create'
 import { ValueCheck } from './check'
 import { ValueClone } from './clone'
 
-namespace UnionValueCast {
-  // ----------------------------------------------------------------------------------------------
-  // The following will score a schema against a value. For objects, the score is the tally of
-  // points awarded for each property of the value. Property points are (1.0 / propertyCount)
-  // to prevent large property counts biasing results. Properties that match literal values are
-  // maximally awarded as literals are typically used as union discriminator fields.
-  // ----------------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------------
+// Errors
+// ----------------------------------------------------------------------------------------------
+
+export class ValueCastReferenceTypeError extends Error {
+  constructor(public readonly schema: Types.TRef | Types.TSelf) {
+    super(`ValueCast: Cannot locate referenced schema with $id '${schema.$ref}'`)
+  }
+}
+
+export class ValueCastArrayUniqueItemsTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema, public readonly value: unknown) {
+    super('ValueCast: Array cast produced invalid data due to uniqueItems constraint')
+  }
+}
+
+export class ValueCastNeverTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('ValueCast: Never types cannot be cast')
+  }
+}
+
+export class ValueCastRecursiveTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('ValueCast.Recursive: Cannot cast recursive schemas')
+  }
+}
+export class ValueCastUnknownTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('ValueCast: Unknown type')
+  }
+}
+
+// ----------------------------------------------------------------------------------------------
+// The following will score a schema against a value. For objects, the score is the tally of
+// points awarded for each property of the value. Property points are (1.0 / propertyCount)
+// to prevent large property counts biasing results. Properties that match literal values are
+// maximally awarded as literals are typically used as union discriminator fields.
+// ----------------------------------------------------------------------------------------------
+
+namespace UnionCastCreate {
   function Score(schema: Types.TSchema, references: Types.TSchema[], value: any): number {
     if (schema[Types.Kind] === 'Object' && typeof value === 'object' && value !== null) {
       const object = schema as Types.TObject
@@ -54,6 +88,7 @@ namespace UnionValueCast {
       return ValueCheck.Check(schema, references, value) ? 1 : 0
     }
   }
+
   function Select(union: Types.TUnion, references: Types.TSchema[], value: any): Types.TSchema {
     let [select, best] = [union.anyOf[0], 0]
     for (const schema of union.anyOf) {
@@ -67,47 +102,19 @@ namespace UnionValueCast {
   }
 
   export function Create(union: Types.TUnion, references: Types.TSchema[], value: any) {
-    return ValueCheck.Check(union, references, value) ? ValueClone.Clone(value) : ValueCast.Cast(Select(union, references, value), references, value)
-  }
-}
-
-// -----------------------------------------------------------
-// Errors
-// -----------------------------------------------------------
-
-export class ValueCastReferenceTypeError extends Error {
-  constructor(public readonly schema: Types.TRef | Types.TSelf) {
-    super(`ValueCast: Cannot locate referenced schema with $id '${schema.$ref}'`)
-  }
-}
-
-export class ValueCastArrayUniqueItemsTypeError extends Error {
-  constructor(public readonly schema: Types.TSchema, public readonly value: unknown) {
-    super('ValueCast: Array cast produced invalid data due to uniqueItems constraint')
-  }
-}
-
-export class ValueCastNeverTypeError extends Error {
-  constructor(public readonly schema: Types.TSchema) {
-    super('ValueCast: Never types cannot be cast')
-  }
-}
-
-export class ValueCastRecursiveTypeError extends Error {
-  constructor(public readonly schema: Types.TSchema) {
-    super('ValueCast.Recursive: Cannot cast recursive schemas')
-  }
-}
-export class ValueCastUnknownTypeError extends Error {
-  constructor(public readonly schema: Types.TSchema) {
-    super('ValueCast: Unknown type')
+    if (union.default !== undefined) {
+      return union.default
+    } else {
+      const schema = Select(union, references, value)
+      return ValueCast.Cast(schema, references, value)
+    }
   }
 }
 
 export namespace ValueCast {
-  // -----------------------------------------------------------
+  // ----------------------------------------------------------------------------------------------
   // Guards
-  // -----------------------------------------------------------
+  // ----------------------------------------------------------------------------------------------
 
   function IsArray(value: unknown): value is unknown[] {
     return typeof value === 'object' && globalThis.Array.isArray(value)
@@ -145,9 +152,9 @@ export namespace ValueCast {
     return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === 0n) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'))
   }
 
-  // -----------------------------------------------------------
+  // ----------------------------------------------------------------------------------------------
   // Convert
-  // -----------------------------------------------------------
+  // ----------------------------------------------------------------------------------------------
 
   function TryConvertString(value: unknown) {
     return IsValueToString(value) ? value.toString() : value
@@ -165,12 +172,12 @@ export namespace ValueCast {
     return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value
   }
 
-  // -----------------------------------------------------------
+  // ----------------------------------------------------------------------------------------------
   // Cast
-  // -----------------------------------------------------------
+  // ----------------------------------------------------------------------------------------------
 
   function Any(schema: Types.TAny, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
 
   function Array(schema: Types.TArray, references: Types.TSchema[], value: any): any {
@@ -205,10 +212,6 @@ export namespace ValueCast {
     return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
 
-  function Enum(schema: Types.TEnum<any>, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-  }
-
   function Function(schema: Types.TFunction, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
   }
@@ -219,7 +222,7 @@ export namespace ValueCast {
   }
 
   function Literal(schema: Types.TLiteral, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
 
   function Never(schema: Types.TNever, references: Types.TSchema[], value: any): any {
@@ -227,7 +230,7 @@ export namespace ValueCast {
   }
 
   function Null(schema: Types.TNull, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
 
   function Number(schema: Types.TNumber, references: Types.TSchema[], value: any): any {
@@ -300,23 +303,23 @@ export namespace ValueCast {
   }
 
   function Undefined(schema: Types.TUndefined, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
 
   function Union(schema: Types.TUnion, references: Types.TSchema[], value: any): any {
-    return UnionValueCast.Create(schema, references, value)
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : UnionCastCreate.Create(schema, references, value)
   }
 
   function Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
 
   function Unknown(schema: Types.TUnknown, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
 
   function Void(schema: Types.TVoid, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
 
   export function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
@@ -333,8 +336,6 @@ export namespace ValueCast {
         return Constructor(anySchema, anyReferences, value)
       case 'Date':
         return Date(anySchema, anyReferences, value)
-      case 'Enum':
-        return Enum(anySchema, anyReferences, value)
       case 'Function':
         return Function(anySchema, anyReferences, value)
       case 'Integer':
diff --git a/src/value/create.ts b/src/value/create.ts
index 3f9f7b52a..bb742c407 100644
--- a/src/value/create.ts
+++ b/src/value/create.ts
@@ -101,16 +101,6 @@ export namespace ValueCreate {
     }
   }
 
-  function Enum(schema: Types.TEnum<any>, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
-      return schema.default
-    } else if (schema.anyOf.length === 0) {
-      throw new Error('ValueCreate.Enum: Cannot create default enum value as this enum has no items')
-    } else {
-      return schema.anyOf[0].const
-    }
-  }
-
   function Function(schema: Types.TFunction, references: Types.TSchema[]): any {
     if (schema.default !== undefined) {
       return schema.default
@@ -303,8 +293,6 @@ export namespace ValueCreate {
         return Constructor(anySchema, anyReferences)
       case 'Date':
         return Date(anySchema, anyReferences)
-      case 'Enum':
-        return Enum(anySchema, anyReferences)
       case 'Function':
         return Function(anySchema, anyReferences)
       case 'Integer':
diff --git a/test/runtime/value/cast/union.ts b/test/runtime/value/cast/union.ts
index f8db7ca4c..b438b5dba 100644
--- a/test/runtime/value/cast/union.ts
+++ b/test/runtime/value/cast/union.ts
@@ -131,4 +131,38 @@ describe('value/cast/Union', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, { type: 'B', a: '', b: '', c: '' })
   })
+
+  it('Should cast with default value (create)', () => {
+    const result = Value.Cast(
+      Type.Object({
+        id: Type.Number(),
+        value: Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')], { default: 'C' }),
+      }),
+      {
+        id: 42,
+        value: 'D',
+      },
+    )
+    Assert.deepEqual(result, {
+      id: 42,
+      value: 'C',
+    })
+  })
+
+  it('Should cast with default value (preserve)', () => {
+    const result = Value.Cast(
+      Type.Object({
+        id: Type.Number(),
+        value: Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')], { default: 'C' }),
+      }),
+      {
+        id: 42,
+        value: 'B',
+      },
+    )
+    Assert.deepEqual(result, {
+      id: 42,
+      value: 'B',
+    })
+  })
 })

From 6cba0d55e08d5e2cd3f9e62fbc8ab0a5be9f923c Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 9 Nov 2022 17:33:12 +0900
Subject: [PATCH 029/369] ValueDelta: Edit Types Defined as TypeBox Types

---
 package.json       |   2 +-
 readme.md          |   6 +--
 src/value/delta.ts | 108 ++++++++++++++++++++++++++-------------------
 src/value/value.ts |   4 +-
 4 files changed, 69 insertions(+), 51 deletions(-)

diff --git a/package.json b/package.json
index e056ba896..02b60fe2b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.3",
+  "version": "0.25.4",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 60ec68e6c..2d1ddcdb1 100644
--- a/readme.md
+++ b/readme.md
@@ -832,7 +832,7 @@ const R = Value.Equal(                               // const R = true
 Use the Diff function to produce a sequence of edits to transform one value into another.
 
 ```typescript
-const E = Value.Diff<any>(                          // const E = [
+const E = Value.Diff(                               // const E = [
   { x: 1, y: 2, z: 3 },                             //   { type: 'update', path: '/y', value: 4 },
   { y: 4, z: 5, w: 6 }                              //   { type: 'update', path: '/z', value: 5 },
 )                                                   //   { type: 'insert', path: '/w', value: 6 },
@@ -851,12 +851,12 @@ const A = { x: 1, y: 2 }
 
 const B = { x: 3 }
 
-const E = Value.Diff<any>(A, B)                      // const E = [
+const E = Value.Diff(A, B)                           // const E = [
                                                      //   { type: 'update', path: '/x', value: 3 },
                                                      //   { type: 'delete', path: '/y' }
                                                      // ]
 
-const C = Value.Patch<any>(A, E)                     // const C = { x: 3 }
+const C = Value.Patch<typeof B>(A, E)                // const C = { x: 3 }
 ```
 
 
diff --git a/src/value/delta.ts b/src/value/delta.ts
index 73c30b069..00cd71902 100644
--- a/src/value/delta.ts
+++ b/src/value/delta.ts
@@ -26,46 +26,71 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { Type, Static } from '../typebox'
 import { Is, ObjectType, ArrayType, TypedArrayType, ValueType } from './is'
 import { ValueClone } from './clone'
 import { ValuePointer } from './pointer'
 
-export type Edit<T = unknown> = Insert<T> | Update<T> | Delete<T>
-
-export interface Insert<T> {
-  brand: T
-  type: 'insert'
-  path: string
-  value: any
+// ---------------------------------------------------------------------
+// Operations
+// ---------------------------------------------------------------------
+
+export type Insert = Static<typeof Insert>
+export const Insert = Type.Object({
+  type: Type.Literal('insert'),
+  path: Type.String(),
+  value: Type.Unknown(),
+})
+
+export type Update = Static<typeof Update>
+export const Update = Type.Object({
+  type: Type.Literal('update'),
+  path: Type.String(),
+  value: Type.Unknown(),
+})
+
+export type Delete = Static<typeof Delete>
+export const Delete = Type.Object({
+  type: Type.Literal('delete'),
+  path: Type.String(),
+})
+
+export type Edit = Static<typeof Edit>
+export const Edit = Type.Union([Insert, Update, Delete])
+
+// ---------------------------------------------------------------------
+// Errors
+// ---------------------------------------------------------------------
+
+export class ValueDeltaObjectWithSymbolKeyError extends Error {
+  constructor(public readonly key: unknown) {
+    super('ValueDelta: Cannot diff objects with symbol keys')
+  }
 }
-
-export interface Update<T> {
-  brand: T
-  type: 'update'
-  path: string
-  value: any
+export class ValueDeltaUnableToDiffUnknownValue extends Error {
+  constructor(public readonly value: unknown) {
+    super('ValueDelta: Unable to create diff edits for unknown value')
+  }
 }
 
-export interface Delete<T> {
-  brand: T
-  type: 'delete'
-  path: string
-}
+// ---------------------------------------------------------------------
+// ValueDelta
+// ---------------------------------------------------------------------
 
 export namespace ValueDelta {
   // ---------------------------------------------------------------------
   // Edits
   // ---------------------------------------------------------------------
 
-  function Update(path: string, value: unknown): Edit<any> {
+  function Update(path: string, value: unknown): Edit {
     return { type: 'update', path, value } as any
   }
 
-  function Insert(path: string, value: unknown): Edit<any> {
+  function Insert(path: string, value: unknown): Edit {
     return { type: 'insert', path, value } as any
   }
 
-  function Delete(path: string): Edit<any> {
+  function Delete(path: string): Edit {
     return { type: 'delete', path } as any
   }
 
@@ -73,35 +98,30 @@ export namespace ValueDelta {
   // Diff
   // ---------------------------------------------------------------------
 
-  function* Object(path: string, current: ObjectType, next: unknown): IterableIterator<Edit<any>> {
+  function* Object(path: string, current: ObjectType, next: unknown): IterableIterator<Edit> {
     if (!Is.Object(next)) return yield Update(path, next)
     const currentKeys = [...globalThis.Object.keys(current), ...globalThis.Object.getOwnPropertySymbols(current)]
     const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)]
     for (const key of currentKeys) {
-      if (typeof key === 'symbol') throw Error('ValueDelta: Cannot produce diff symbol keys')
+      if (typeof key === 'symbol') throw new ValueDeltaObjectWithSymbolKeyError(key)
       if (next[key] === undefined && nextKeys.includes(key)) yield Update(`${path}/${String(key)}`, undefined)
     }
     for (const key of nextKeys) {
       if (current[key] === undefined || next[key] === undefined) continue
-      if (typeof key === 'symbol') throw Error('ValueDelta: Cannot produce diff symbol keys')
+      if (typeof key === 'symbol') throw new ValueDeltaObjectWithSymbolKeyError(key)
       yield* Visit(`${path}/${String(key)}`, current[key], next[key])
     }
     for (const key of nextKeys) {
-      if (typeof key === 'symbol') throw Error('ValueDelta: Cannot produce diff symbol keys')
+      if (typeof key === 'symbol') throw new ValueDeltaObjectWithSymbolKeyError(key)
       if (current[key] === undefined) yield Insert(`${path}/${String(key)}`, next[key])
     }
     for (const key of currentKeys.reverse()) {
-      if (typeof key === 'symbol') throw Error('ValueDelta: Cannot produce diff symbol keys')
+      if (typeof key === 'symbol') throw new ValueDeltaObjectWithSymbolKeyError(key)
       if (next[key] === undefined && !nextKeys.includes(key)) yield Delete(`${path}/${String(key)}`)
     }
   }
 
-  function* Date(path: string, current: Date, next: unknown): IterableIterator<Edit<any>> {
-    if (Is.Date(next) && current.getTime() === next.getTime()) return
-    yield Update(path, next)
-  }
-
-  function* Array(path: string, current: ArrayType, next: unknown): IterableIterator<Edit<any>> {
+  function* Array(path: string, current: ArrayType, next: unknown): IterableIterator<Edit> {
     if (!Is.Array(next)) return yield Update(path, next)
     for (let i = 0; i < Math.min(current.length, next.length); i++) {
       yield* Visit(`${path}/${i}`, current[i], next[i])
@@ -116,23 +136,21 @@ export namespace ValueDelta {
     }
   }
 
-  function* TypedArray(path: string, current: TypedArrayType, next: unknown): IterableIterator<Edit<any>> {
+  function* TypedArray(path: string, current: TypedArrayType, next: unknown): IterableIterator<Edit> {
     if (!Is.TypedArray(next) || current.length !== next.length || globalThis.Object.getPrototypeOf(current).constructor.name !== globalThis.Object.getPrototypeOf(next).constructor.name) return yield Update(path, next)
     for (let i = 0; i < Math.min(current.length, next.length); i++) {
       yield* Visit(`${path}/${i}`, current[i], next[i])
     }
   }
 
-  function* Value(path: string, current: ValueType, next: unknown): IterableIterator<Edit<any>> {
+  function* Value(path: string, current: ValueType, next: unknown): IterableIterator<Edit> {
     if (current === next) return
     yield Update(path, next)
   }
 
-  function* Visit(path: string, current: unknown, next: unknown): IterableIterator<Edit<any>> {
+  function* Visit(path: string, current: unknown, next: unknown): IterableIterator<Edit> {
     if (Is.Object(current)) {
       return yield* Object(path, current, next)
-    } else if (Is.Date(current)) {
-      return yield* Date(path, current, next)
     } else if (Is.Array(current)) {
       return yield* Array(path, current, next)
     } else if (Is.TypedArray(current)) {
@@ -140,11 +158,11 @@ export namespace ValueDelta {
     } else if (Is.Value(current)) {
       return yield* Value(path, current, next)
     } else {
-      throw new Error('ValueDelta: Cannot produce edits for value')
+      throw new ValueDeltaUnableToDiffUnknownValue(current)
     }
   }
 
-  export function Diff<T>(current: T, next: T): Edit<T>[] {
+  export function Diff(current: unknown, next: unknown): Edit[] {
     return [...Visit('', current, next)]
   }
 
@@ -152,20 +170,20 @@ export namespace ValueDelta {
   // Patch
   // ---------------------------------------------------------------------
 
-  function IsRootUpdate<T>(edits: Edit<T>[]): edits is [Update<T>] {
+  function IsRootUpdate(edits: Edit[]): edits is [Update] {
     return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update'
   }
 
-  function IsIdentity<T>(edits: Edit<T>[]) {
+  function IsIdentity(edits: Edit[]) {
     return edits.length === 0
   }
 
-  export function Patch<T>(current: T, edits: Edit<T>[]): T {
+  export function Patch<T = any>(current: unknown, edits: Edit[]): T {
     if (IsRootUpdate(edits)) {
-      return ValueClone.Clone(edits[0].value)
+      return ValueClone.Clone(edits[0].value) as T
     }
     if (IsIdentity(edits)) {
-      return ValueClone.Clone(current)
+      return ValueClone.Clone(current) as T
     }
     const clone = ValueClone.Clone(current)
     for (const edit of edits) {
@@ -184,6 +202,6 @@ export namespace ValueDelta {
         }
       }
     }
-    return clone
+    return clone as T
   }
 }
diff --git a/src/value/value.ts b/src/value/value.ts
index ff0f27872..a8eea545e 100644
--- a/src/value/value.ts
+++ b/src/value/value.ts
@@ -86,12 +86,12 @@ export namespace Value {
   }
 
   /** Returns edits to transform the current value into the next value */
-  export function Diff<T>(current: T, next: T): Edit<T>[] {
+  export function Diff(current: unknown, next: unknown): Edit[] {
     return ValueDelta.Diff(current, next)
   }
 
   /** Returns a new value with edits applied to the given value */
-  export function Patch<T>(current: T, edits: Edit<T>[]): T {
+  export function Patch<T = any>(current: unknown, edits: Edit[]): T {
     return ValueDelta.Patch(current, edits) as T
   }
 }

From 1cb016b429e85516e978c2afedd7c5e5803dfe3b Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 9 Nov 2022 18:26:11 +0900
Subject: [PATCH 030/369] ValueDelta: Edit Types Defined as TypeBox Types

---
 package.json                   | 2 +-
 src/conditional/conditional.ts | 2 +-
 src/errors/errors.ts           | 1 +
 src/format/format.ts           | 2 +-
 src/guard/guard.ts             | 2 +-
 src/value/pointer.ts           | 2 +-
 src/value/value.ts             | 4 ++--
 7 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/package.json b/package.json
index 02b60fe2b..e16bda5fb 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.4",
+  "version": "0.25.5",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/conditional/conditional.ts b/src/conditional/conditional.ts
index dd3e71180..ecd2a756d 100644
--- a/src/conditional/conditional.ts
+++ b/src/conditional/conditional.ts
@@ -52,7 +52,7 @@ export interface TExtract<T extends Types.TSchema, U extends Types.TUnion> exten
   static: Extract<Types.Static<T, this['params']>, Types.Static<U, this['params']>>
 }
 
-/** Conditional Types */
+/** Conditional type mapping for TypeBox types */
 export namespace Conditional {
   /** (Experimental) Creates a conditional expression type */
   export function Extends<L extends Types.TSchema, R extends Types.TSchema, T extends Types.TSchema, U extends Types.TSchema>(left: L, right: R, ok: T, fail: U): TExtends<L, R, T, U> {
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index db4830256..4324f2bb1 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -106,6 +106,7 @@ export class ValueErrorsUnknownTypeError extends Error {
   }
 }
 
+/** Provides functionality to generate a sequence of errors against a TypeBox type.  */
 export namespace ValueErrors {
   function* Any(schema: Types.TAny, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {}
 
diff --git a/src/format/format.ts b/src/format/format.ts
index 3dc6de9f4..544009a7f 100644
--- a/src/format/format.ts
+++ b/src/format/format.ts
@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 export type FormatValidationFunction = (value: string) => boolean
 
-/** Shared string formats used by the TypeCompiler and Value modules */
+/** Provides functions to create custom string formats */
 export namespace Format {
   const formats = new Map<string, FormatValidationFunction>()
 
diff --git a/src/guard/guard.ts b/src/guard/guard.ts
index 24f23c2eb..ca61df37d 100644
--- a/src/guard/guard.ts
+++ b/src/guard/guard.ts
@@ -34,7 +34,7 @@ export class TypeGuardInvalidTypeError extends Error {
   }
 }
 
-/** TypeGuard tests that values conform to a known TypeBox type specification */
+/** Provides functionality to test if values are TypeBox types */
 export namespace TypeGuard {
   function IsObject(value: unknown): value is Record<string | symbol, any> {
     return typeof value === 'object' && value !== null && !Array.isArray(value)
diff --git a/src/value/pointer.ts b/src/value/pointer.ts
index 4b7c5bf9c..fa828480c 100644
--- a/src/value/pointer.ts
+++ b/src/value/pointer.ts
@@ -38,7 +38,7 @@ export class ValuePointerRootDeleteError extends Error {
   }
 }
 
-/** ValuePointer performs mutable operations on values using RFC6901 Json Pointers */
+/** Provides functionality to update values through RFC6901 string pointers */
 export namespace ValuePointer {
   function Escape(component: string) {
     return component.indexOf('~') === -1 ? component : component.replace(/~1/g, '/').replace(/~0/g, '~')
diff --git a/src/value/value.ts b/src/value/value.ts
index a8eea545e..48aab1500 100644
--- a/src/value/value.ts
+++ b/src/value/value.ts
@@ -35,9 +35,9 @@ import { ValueCreate } from './create'
 import { ValueCheck } from './check'
 import { ValueDelta, Edit } from './delta'
 
-export type { Edit } from './delta'
+export { Edit, Insert, Update, Delete } from './delta'
 
-/** Value performs immutable operations on values */
+/** Provides functions to perform structural updates to JavaScript values */
 export namespace Value {
   /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number and boolean values if a reasonable conversion is possible. */
   export function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): Types.Static<T>

From eaec121cc0e0f151e37a536ccc3ba8c2ac10b539 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Thu, 10 Nov 2022 20:16:24 +0900
Subject: [PATCH 031/369] Value Guard Numeric Constraints on Error Reporting

---
 package.json         |  2 +-
 src/errors/errors.ts | 48 ++++++++++++++++++++++++--------------------
 2 files changed, 27 insertions(+), 23 deletions(-)

diff --git a/package.json b/package.json
index e16bda5fb..be32d047a 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.5",
+  "version": "0.25.6",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 4324f2bb1..df1da6817 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -108,16 +108,20 @@ export class ValueErrorsUnknownTypeError extends Error {
 
 /** Provides functionality to generate a sequence of errors against a TypeBox type.  */
 export namespace ValueErrors {
+  function IsNumber(value: number | undefined): value is number {
+    return typeof value === 'number'
+  }
+
   function* Any(schema: Types.TAny, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {}
 
   function* Array(schema: Types.TArray, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!globalThis.Array.isArray(value)) {
       return yield { type: ValueErrorType.Array, schema, path, value, message: `Expected array` }
     }
-    if (schema.minItems !== undefined && !(value.length >= schema.minItems)) {
+    if (IsNumber(schema.minItems) && !(value.length >= schema.minItems)) {
       yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be greater or equal to ${schema.minItems}` }
     }
-    if (schema.maxItems !== undefined && !(value.length <= schema.maxItems)) {
+    if (IsNumber(schema.maxItems) && !(value.length <= schema.maxItems)) {
       yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` }
     }
     if (schema.uniqueItems === true && !(new Set(value).size === value.length)) {
@@ -142,16 +146,16 @@ export namespace ValueErrors {
     if (!(value instanceof globalThis.Date)) {
       return yield { type: ValueErrorType.Date, schema, path, value, message: `Expected Date object` }
     }
-    if (schema.exclusiveMinimumTimestamp && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
+    if (IsNumber(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
       yield { type: ValueErrorType.DateExclusiveMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater than ${schema.exclusiveMinimum}` }
     }
-    if (schema.exclusiveMaximumTimestamp && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+    if (IsNumber(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
       yield { type: ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less than ${schema.exclusiveMaximum}` }
     }
-    if (schema.minimumTimestamp && !(value.getTime() >= schema.minimumTimestamp)) {
+    if (IsNumber(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
       yield { type: ValueErrorType.DateMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater or equal to ${schema.minimum}` }
     }
-    if (schema.maximumTimestamp && !(value.getTime() <= schema.maximumTimestamp)) {
+    if (IsNumber(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
       yield { type: ValueErrorType.DateMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less or equal to ${schema.maximum}` }
     }
   }
@@ -169,19 +173,19 @@ export namespace ValueErrors {
     if (!globalThis.Number.isInteger(value)) {
       yield { type: ValueErrorType.Integer, schema, path, value, message: `Expected integer` }
     }
-    if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
+    if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
       yield { type: ValueErrorType.IntegerMultipleOf, schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` }
     }
-    if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
+    if (IsNumber(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
       yield { type: ValueErrorType.IntegerExclusiveMinimum, schema, path, value, message: `Expected integer to be greater than ${schema.exclusiveMinimum}` }
     }
-    if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
+    if (IsNumber(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
       yield { type: ValueErrorType.IntegerExclusiveMaximum, schema, path, value, message: `Expected integer to be less than ${schema.exclusiveMaximum}` }
     }
-    if (schema.minimum && !(value >= schema.minimum)) {
+    if (IsNumber(schema.minimum) && !(value >= schema.minimum)) {
       yield { type: ValueErrorType.IntegerMinimum, schema, path, value, message: `Expected integer to be greater or equal to ${schema.minimum}` }
     }
-    if (schema.maximum && !(value <= schema.maximum)) {
+    if (IsNumber(schema.maximum) && !(value <= schema.maximum)) {
       yield { type: ValueErrorType.IntegerMaximum, schema, path, value, message: `Expected integer to be less or equal to ${schema.maximum}` }
     }
   }
@@ -207,19 +211,19 @@ export namespace ValueErrors {
     if (!(typeof value === 'number')) {
       return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` }
     }
-    if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
+    if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
       yield { type: ValueErrorType.NumberMultipleOf, schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` }
     }
-    if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
+    if (IsNumber(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
       yield { type: ValueErrorType.NumberExclusiveMinimum, schema, path, value, message: `Expected number to be greater than ${schema.exclusiveMinimum}` }
     }
-    if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
+    if (IsNumber(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
       yield { type: ValueErrorType.NumberExclusiveMaximum, schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` }
     }
-    if (schema.minimum && !(value >= schema.minimum)) {
+    if (IsNumber(schema.minimum) && !(value >= schema.minimum)) {
       yield { type: ValueErrorType.NumberMaximum, schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` }
     }
-    if (schema.maximum && !(value <= schema.maximum)) {
+    if (IsNumber(schema.maximum) && !(value <= schema.maximum)) {
       yield { type: ValueErrorType.NumberMinumum, schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` }
     }
   }
@@ -228,10 +232,10 @@ export namespace ValueErrors {
     if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
       return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
     }
-    if (schema.minProperties !== undefined && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
+    if (IsNumber(schema.minProperties) && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
       yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` }
     }
-    if (schema.maxProperties !== undefined && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
+    if (IsNumber(schema.maxProperties) && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
       yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` }
     }
     const propertyKeys = globalThis.Object.keys(schema.properties)
@@ -307,10 +311,10 @@ export namespace ValueErrors {
     if (!(typeof value === 'string')) {
       return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' }
     }
-    if (schema.minLength !== undefined && !(value.length >= schema.minLength)) {
+    if (IsNumber(schema.minLength) && !(value.length >= schema.minLength)) {
       yield { type: ValueErrorType.StringMinLength, schema, path, value, message: `Expected string length greater or equal to ${schema.minLength}` }
     }
-    if (schema.maxLength !== undefined && !(value.length <= schema.maxLength)) {
+    if (IsNumber(schema.maxLength) && !(value.length <= schema.maxLength)) {
       yield { type: ValueErrorType.StringMaxLength, schema, path, value, message: `Expected string length less or equal to ${schema.maxLength}` }
     }
     if (schema.pattern !== undefined) {
@@ -375,10 +379,10 @@ export namespace ValueErrors {
       return yield { type: ValueErrorType.Uint8Array, schema, path, value, message: `Expected Uint8Array` }
     }
 
-    if (schema.maxByteLength && !(value.length <= schema.maxByteLength)) {
+    if (IsNumber(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
       yield { type: ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length less or equal to ${schema.maxByteLength}` }
     }
-    if (schema.minByteLength && !(value.length >= schema.minByteLength)) {
+    if (IsNumber(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
       yield { type: ValueErrorType.Uint8ArrayMinByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length greater or equal to ${schema.maxByteLength}` }
     }
   }

From 1a6e3fbe45a440b624f161c515a1737dc34d7828 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Thu, 10 Nov 2022 20:37:55 +0900
Subject: [PATCH 032/369] Value Guard Numeric Constraints

---
 package.json             |  2 +-
 src/compiler/compiler.ts | 53 ++++++++++++++++++++--------------------
 src/errors/errors.ts     |  2 +-
 src/value/check.ts       | 48 +++++++++++++++++++-----------------
 4 files changed, 54 insertions(+), 51 deletions(-)

diff --git a/package.json b/package.json
index be32d047a..a4078398d 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.6",
+  "version": "0.25.7",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 9ef44a813..922e504d8 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -108,6 +108,9 @@ export class TypeCompilerUnknownTypeError extends Error {
 
 /** Compiles Types for Runtime Type Checking */
 export namespace TypeCompiler {
+  function IsNumber(value: unknown): value is number {
+    return typeof value === 'number'
+  }
   // -------------------------------------------------------------------
   // Types
   // -------------------------------------------------------------------
@@ -118,9 +121,9 @@ export namespace TypeCompiler {
 
   function* Array(schema: Types.TArray, value: string): IterableIterator<string> {
     const expression = CreateExpression(schema.items, 'value')
-    if (schema.minItems !== undefined) yield `(${value}.length >= ${schema.minItems})`
-    if (schema.maxItems !== undefined) yield `(${value}.length <= ${schema.maxItems})`
-    if (schema.uniqueItems !== undefined) yield `(new Set(${value}).size === ${value}.length)`
+    if (IsNumber(schema.minItems)) yield `(${value}.length >= ${schema.minItems})`
+    if (IsNumber(schema.maxItems)) yield `(${value}.length <= ${schema.maxItems})`
+    if (schema.uniqueItems === true) yield `(new Set(${value}).size === ${value}.length)`
     yield `(Array.isArray(${value}) && ${value}.every(value => ${expression}))`
   }
 
@@ -134,10 +137,10 @@ export namespace TypeCompiler {
 
   function* Date(schema: Types.TDate, value: string): IterableIterator<string> {
     yield `(${value} instanceof Date)`
-    if (schema.exclusiveMinimumTimestamp !== undefined) yield `(${value}.getTime() > ${schema.exclusiveMinimumTimestamp})`
-    if (schema.exclusiveMaximumTimestamp !== undefined) yield `(${value}.getTime() < ${schema.exclusiveMaximumTimestamp})`
-    if (schema.minimumTimestamp !== undefined) yield `(${value}.getTime() >= ${schema.minimumTimestamp})`
-    if (schema.maximumTimestamp !== undefined) yield `(${value}.getTime() <= ${schema.maximumTimestamp})`
+    if (IsNumber(schema.exclusiveMinimumTimestamp)) yield `(${value}.getTime() > ${schema.exclusiveMinimumTimestamp})`
+    if (IsNumber(schema.exclusiveMaximumTimestamp)) yield `(${value}.getTime() < ${schema.exclusiveMaximumTimestamp})`
+    if (IsNumber(schema.minimumTimestamp)) yield `(${value}.getTime() >= ${schema.minimumTimestamp})`
+    if (IsNumber(schema.maximumTimestamp)) yield `(${value}.getTime() <= ${schema.maximumTimestamp})`
   }
 
   function* Function(schema: Types.TFunction, value: string): IterableIterator<string> {
@@ -146,11 +149,11 @@ export namespace TypeCompiler {
 
   function* Integer(schema: Types.TInteger, value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`
-    if (schema.multipleOf !== undefined) yield `(${value} % ${schema.multipleOf} === 0)`
-    if (schema.exclusiveMinimum !== undefined) yield `(${value} > ${schema.exclusiveMinimum})`
-    if (schema.exclusiveMaximum !== undefined) yield `(${value} < ${schema.exclusiveMaximum})`
-    if (schema.minimum !== undefined) yield `(${value} >= ${schema.minimum})`
-    if (schema.maximum !== undefined) yield `(${value} <= ${schema.maximum})`
+    if (IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf} === 0)`
+    if (IsNumber(schema.exclusiveMinimum)) yield `(${value} > ${schema.exclusiveMinimum})`
+    if (IsNumber(schema.exclusiveMaximum)) yield `(${value} < ${schema.exclusiveMaximum})`
+    if (IsNumber(schema.minimum)) yield `(${value} >= ${schema.minimum})`
+    if (IsNumber(schema.maximum)) yield `(${value} <= ${schema.maximum})`
   }
 
   function* Literal(schema: Types.TLiteral, value: string): IterableIterator<string> {
@@ -171,17 +174,17 @@ export namespace TypeCompiler {
 
   function* Number(schema: Types.TNumber, value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'number')`
-    if (schema.multipleOf !== undefined) yield `(${value} % ${schema.multipleOf} === 0)`
-    if (schema.exclusiveMinimum !== undefined) yield `(${value} > ${schema.exclusiveMinimum})`
-    if (schema.exclusiveMaximum !== undefined) yield `(${value} < ${schema.exclusiveMaximum})`
-    if (schema.minimum !== undefined) yield `(${value} >= ${schema.minimum})`
-    if (schema.maximum !== undefined) yield `(${value} <= ${schema.maximum})`
+    if (IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf} === 0)`
+    if (IsNumber(schema.exclusiveMinimum)) yield `(${value} > ${schema.exclusiveMinimum})`
+    if (IsNumber(schema.exclusiveMaximum)) yield `(${value} < ${schema.exclusiveMaximum})`
+    if (IsNumber(schema.minimum)) yield `(${value} >= ${schema.minimum})`
+    if (IsNumber(schema.maximum)) yield `(${value} <= ${schema.maximum})`
   }
 
   function* Object(schema: Types.TObject, value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`
-    if (schema.minProperties !== undefined) yield `(Object.keys(${value}).length >= ${schema.minProperties})`
-    if (schema.maxProperties !== undefined) yield `(Object.keys(${value}).length <= ${schema.maxProperties})`
+    if (IsNumber(schema.minProperties)) yield `(Object.keys(${value}).length >= ${schema.minProperties})`
+    if (IsNumber(schema.maxProperties)) yield `(Object.keys(${value}).length <= ${schema.maxProperties})`
     const propertyKeys = globalThis.Object.keys(schema.properties)
     if (schema.additionalProperties === false) {
       // Optimization: If the property key length matches the required keys length
@@ -242,12 +245,8 @@ export namespace TypeCompiler {
 
   function* String(schema: Types.TString, value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'string')`
-    if (schema.minLength !== undefined) {
-      yield `(${value}.length >= ${schema.minLength})`
-    }
-    if (schema.maxLength !== undefined) {
-      yield `(${value}.length <= ${schema.maxLength})`
-    }
+    if (IsNumber(schema.minLength)) yield `(${value}.length >= ${schema.minLength})`
+    if (IsNumber(schema.maxLength)) yield `(${value}.length <= ${schema.maxLength})`
     if (schema.pattern !== undefined) {
       const local = PushLocal(`new RegExp(/${schema.pattern}/);`)
       yield `(${local}.test(${value}))`
@@ -278,8 +277,8 @@ export namespace TypeCompiler {
 
   function* Uint8Array(schema: Types.TUint8Array, value: string): IterableIterator<string> {
     yield `(${value} instanceof Uint8Array)`
-    if (schema.maxByteLength) yield `(${value}.length <= ${schema.maxByteLength})`
-    if (schema.minByteLength) yield `(${value}.length >= ${schema.minByteLength})`
+    if (IsNumber(schema.maxByteLength)) yield `(${value}.length <= ${schema.maxByteLength})`
+    if (IsNumber(schema.minByteLength)) yield `(${value}.length >= ${schema.minByteLength})`
   }
 
   function* Unknown(schema: Types.TUnknown, value: string): IterableIterator<string> {
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index df1da6817..c7f43e791 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -108,7 +108,7 @@ export class ValueErrorsUnknownTypeError extends Error {
 
 /** Provides functionality to generate a sequence of errors against a TypeBox type.  */
 export namespace ValueErrors {
-  function IsNumber(value: number | undefined): value is number {
+  function IsNumber(value: unknown): value is number {
     return typeof value === 'number'
   }
 
diff --git a/src/value/check.ts b/src/value/check.ts
index 54e0418c3..e17d90cf3 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -36,6 +36,10 @@ export class ValueCheckUnknownTypeError extends Error {
 }
 
 export namespace ValueCheck {
+  function IsNumber(value: unknown): value is number {
+    return typeof value === 'number'
+  }
+
   function Any(schema: Types.TAny, references: Types.TSchema[], value: any): boolean {
     return true
   }
@@ -43,10 +47,10 @@ export namespace ValueCheck {
     if (!globalThis.Array.isArray(value)) {
       return false
     }
-    if (schema.minItems !== undefined && !(value.length >= schema.minItems)) {
+    if (IsNumber(schema.minItems) && !(value.length >= schema.minItems)) {
       return false
     }
-    if (schema.maxItems !== undefined && !(value.length <= schema.maxItems)) {
+    if (IsNumber(schema.maxItems) && !(value.length <= schema.maxItems)) {
       return false
     }
     if (schema.uniqueItems === true && !(new Set(value).size === value.length)) {
@@ -66,16 +70,16 @@ export namespace ValueCheck {
     if (!(value instanceof globalThis.Date)) {
       return false
     }
-    if (schema.exclusiveMinimumTimestamp && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
+    if (IsNumber(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
       return false
     }
-    if (schema.exclusiveMaximumTimestamp && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+    if (IsNumber(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
       return false
     }
-    if (schema.minimumTimestamp && !(value.getTime() >= schema.minimumTimestamp)) {
+    if (IsNumber(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
       return false
     }
-    if (schema.maximumTimestamp && !(value.getTime() <= schema.maximumTimestamp)) {
+    if (IsNumber(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
       return false
     }
     return true
@@ -91,19 +95,19 @@ export namespace ValueCheck {
     if (!globalThis.Number.isInteger(value)) {
       return false
     }
-    if (schema.multipleOf !== undefined && !(value % schema.multipleOf === 0)) {
+    if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
       return false
     }
-    if (schema.exclusiveMinimum !== undefined && !(value > schema.exclusiveMinimum)) {
+    if (IsNumber(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
       return false
     }
-    if (schema.exclusiveMaximum !== undefined && !(value < schema.exclusiveMaximum)) {
+    if (IsNumber(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
       return false
     }
-    if (schema.minimum !== undefined && !(value >= schema.minimum)) {
+    if (IsNumber(schema.minimum) && !(value >= schema.minimum)) {
       return false
     }
-    if (schema.maximum !== undefined && !(value <= schema.maximum)) {
+    if (IsNumber(schema.maximum) && !(value <= schema.maximum)) {
       return false
     }
     return true
@@ -125,19 +129,19 @@ export namespace ValueCheck {
     if (!(typeof value === 'number')) {
       return false
     }
-    if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
+    if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
       return false
     }
-    if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
+    if (IsNumber(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
       return false
     }
-    if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
+    if (IsNumber(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
       return false
     }
-    if (schema.minimum && !(value >= schema.minimum)) {
+    if (IsNumber(schema.minimum) && !(value >= schema.minimum)) {
       return false
     }
-    if (schema.maximum && !(value <= schema.maximum)) {
+    if (IsNumber(schema.maximum) && !(value <= schema.maximum)) {
       return false
     }
     return true
@@ -147,10 +151,10 @@ export namespace ValueCheck {
     if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
       return false
     }
-    if (schema.minProperties !== undefined && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
+    if (IsNumber(schema.minProperties) && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
       return false
     }
-    if (schema.maxProperties !== undefined && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
+    if (IsNumber(schema.maxProperties) && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
       return false
     }
     const propertyKeys = globalThis.Object.keys(schema.properties)
@@ -227,10 +231,10 @@ export namespace ValueCheck {
     if (!(typeof value === 'string')) {
       return false
     }
-    if (schema.minLength !== undefined) {
+    if (IsNumber(schema.minLength)) {
       if (!(value.length >= schema.minLength)) return false
     }
-    if (schema.maxLength !== undefined) {
+    if (IsNumber(schema.maxLength)) {
       if (!(value.length <= schema.maxLength)) return false
     }
     if (schema.pattern !== undefined) {
@@ -276,10 +280,10 @@ export namespace ValueCheck {
     if (!(value instanceof globalThis.Uint8Array)) {
       return false
     }
-    if (schema.maxByteLength && !(value.length <= schema.maxByteLength)) {
+    if (IsNumber(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
       return false
     }
-    if (schema.minByteLength && !(value.length >= schema.minByteLength)) {
+    if (IsNumber(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
       return false
     }
     return true

From 0a34eca379edf2750979c30fda4caaf4470dacdb Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Fri, 11 Nov 2022 13:11:57 +0900
Subject: [PATCH 033/369] Specify Submodule Exports

---
 package.json | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/package.json b/package.json
index a4078398d..8d606c612 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.7",
+  "version": "0.25.8",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -12,6 +12,15 @@
   "license": "MIT",
   "main": "./typebox.js",
   "types": "./typebox.d.ts",
+  "exports": {
+    "./compiler": "./compiler/index.js",
+    "./conditional": "./conditional/index.js",
+    "./errors": "./errors/index.js",
+    "./format": "./format/index.js",
+    "./guard": "./guard/index.js",
+    "./value": "./value/index.js",
+    ".": "./typebox.js"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/sinclairzx81/typebox"

From 3fb1d37c3393a116d39601c61599913d4a18a3d2 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 16 Nov 2022 13:40:07 +0900
Subject: [PATCH 034/369] Deno Npm Imports

---
 readme.md | 33 +++++++++++++++++++++++++--------
 1 file changed, 25 insertions(+), 8 deletions(-)

diff --git a/readme.md b/readme.md
index 2d1ddcdb1..94ef87319 100644
--- a/readme.md
+++ b/readme.md
@@ -19,28 +19,45 @@
 
 ## Install
 
-Node
-
+### npm
 ```bash
 $ npm install @sinclair/typebox --save
 ```
 
-Deno and ESM
+### deno
+```typescript
+import { Static, Type } from 'npm:@sinclair/typebox'
+```
+
+### esm
 
 ```typescript
 import { Static, Type } from 'https://esm.sh/@sinclair/typebox'
 ```
 
-## Example
+## Usage
 
 ```typescript
 import { Static, Type } from '@sinclair/typebox'
 
-const T = Type.String()     // const T = { type: 'string' }
+const T = Type.Object({                              // const T = {
+  x: Type.Number(),                                  //   type: 'object',
+  y: Type.Number(),                                  //   required: ['x', 'y', 'z'],
+  z: Type.Number()                                   //   properties: {
+})                                                   //     x: { type: 'number' },
+                                                     //     y: { type: 'number' },
+                                                     //     z: { type: 'number' }
+                                                     //   }
+                                                     // }
 
-type T = Static<typeof T>   // type T = string
+type T = Static<typeof T>                            // type T = {
+                                                     //   x: number,
+                                                     //   y: number,
+                                                     //   z: number
+                                                     // }
 ```
 
+
 <a name="Overview"></a>
 
 ## Overview
@@ -54,7 +71,7 @@ License MIT
 ## Contents
 - [Install](#install)
 - [Overview](#overview)
-- [Usage](#usage)
+- [Example](#Example)
 - [Types](#types)
   - [Standard Types](#types-standard)
   - [Extended Types](#types-extended)
@@ -89,7 +106,7 @@ License MIT
 
 <a name="Example"></a>
 
-## Usage
+## Example
 
 The following demonstrates TypeBox's general usage.
 

From f33423fcf35ce5cfbd6909c45fe8972d88b029da Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 22 Nov 2022 21:53:36 +0900
Subject: [PATCH 035/369] Custom Types (#282)

---
 .../compression/module/typebox-custom.ts      |   4 +
 changelog.md                                  |   6 +
 example/index.ts                              |   1 +
 package.json                                  |   3 +-
 readme.md                                     | 128 +++++++++++-------
 src/compiler/compiler.ts                      |  29 ++--
 src/conditional/structural.ts                 |  45 +++---
 src/custom/custom.ts                          |  54 ++++++++
 src/custom/index.ts                           |  29 ++++
 src/errors/errors.ts                          |  13 +-
 src/guard/guard.ts                            |  17 ++-
 src/tsconfig.json                             |   2 +-
 src/value/cast.ts                             |   8 +-
 src/value/check.ts                            |  12 +-
 src/value/create.ts                           |  12 +-
 test/runtime/compiler/custom.ts               |  28 ++++
 test/runtime/compiler/index.ts                |   1 +
 test/runtime/errors/index.ts                  |   1 +
 test/runtime/index.ts                         |   1 +
 test/runtime/value/cast/custom.ts             |  64 +++++++++
 test/runtime/value/cast/index.ts              |   1 +
 test/runtime/value/check/custom.ts            |  28 ++++
 test/runtime/value/check/index.ts             |   1 +
 test/runtime/value/create/custom.ts           |  18 +++
 test/runtime/value/create/index.ts            |   1 +
 tsconfig.json                                 |   3 +
 26 files changed, 417 insertions(+), 93 deletions(-)
 create mode 100644 benchmark/compression/module/typebox-custom.ts
 create mode 100644 src/custom/custom.ts
 create mode 100644 src/custom/index.ts
 create mode 100644 test/runtime/compiler/custom.ts
 create mode 100644 test/runtime/errors/index.ts
 create mode 100644 test/runtime/value/cast/custom.ts
 create mode 100644 test/runtime/value/check/custom.ts
 create mode 100644 test/runtime/value/create/custom.ts

diff --git a/benchmark/compression/module/typebox-custom.ts b/benchmark/compression/module/typebox-custom.ts
new file mode 100644
index 000000000..8620c02f1
--- /dev/null
+++ b/benchmark/compression/module/typebox-custom.ts
@@ -0,0 +1,4 @@
+import { Custom } from 'src/custom/index'
+import { Type } from '@sinclair/typebox'
+
+Custom.Set('custom', (value) => true)
diff --git a/changelog.md b/changelog.md
index 660e2863f..d4535926a 100644
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,9 @@
+## [0.25.9](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.9)
+
+Updates:
+
+- TypeBox now supports custom types. These types require the user to specify a custom `[Kind]` string on the type. Custom types can be registered via `Custom.Set('<Kind>', (value) => { ... })`.
+
 ## [0.25.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.0)
 
 Updates:
diff --git a/example/index.ts b/example/index.ts
index 987d926be..97c0303f9 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -3,6 +3,7 @@ import { TypeCompiler } from '@sinclair/typebox/compiler'
 import { Conditional } from '@sinclair/typebox/conditional'
 import { TypeGuard } from '@sinclair/typebox/guard'
 import { Format } from '@sinclair/typebox/format'
+import { Custom } from '@sinclair/typebox/custom'
 import { Value, ValuePointer } from '@sinclair/typebox/value'
 import { Type, Static, TSchema } from '@sinclair/typebox'
 
diff --git a/package.json b/package.json
index 8d606c612..ab27031c1 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.8",
+  "version": "0.25.9",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -15,6 +15,7 @@
   "exports": {
     "./compiler": "./compiler/index.js",
     "./conditional": "./conditional/index.js",
+    "./custom": "./custom/index.js",
     "./errors": "./errors/index.js",
     "./format": "./format/index.js",
     "./guard": "./guard/index.js",
diff --git a/readme.md b/readme.md
index 94ef87319..f1a6a94c5 100644
--- a/readme.md
+++ b/readme.md
@@ -97,6 +97,7 @@ License MIT
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
   - [TypeCompiler](#typecheck-typecompiler)
+  - [Custom](#typecheck-custom)
   - [Formats](#typecheck-formats)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
@@ -1117,6 +1118,30 @@ console.log(C.Code())                                // return function check(va
                                                      // }
 ```
 
+<a name='typecheck-custom'></a>
+
+### Custom
+
+Use custom module to create a custom types. When creating a custom type you must specify a `Kind` symbol property on the types schema. The `Kind` symbol property should match the name used to register the type. Custom types are used by the Value and TypeCompiler modules only.
+
+The custom module is an optional import.
+
+```typescript
+import { Custom } from '@sinclair/typebox/custom'
+```
+
+The following registers a BigInt custom type.
+
+```typescript
+import { Type, Kind } from '@sinclair/typebox'
+
+Custom.Set('BigInt', value => typeof value === 'bigint')
+
+const T = Type.Unsafe<bigint>({ [Kind]: 'BigInt' })  // const T = { [Kind]: 'BigInt' }
+
+const R = Value.Check(T, 65536n)                     // const R = true
+```
+
 <a name='typecheck-formats'></a>
 
 ### Formats
@@ -1163,29 +1188,29 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    421 ms' │ '     11 ms' │ '   38.27 x' │
-│           String │    2000    │ '    332 ms' │ '     11 ms' │ '   30.18 x' │
-│          Boolean │    2000    │ '    291 ms' │ '     12 ms' │ '   24.25 x' │
-│             Null │    2000    │ '    266 ms' │ '      9 ms' │ '   29.56 x' │
-│            RegEx │    2000    │ '    486 ms' │ '     17 ms' │ '   28.59 x' │
-│          ObjectA │    2000    │ '   2791 ms' │ '     50 ms' │ '   55.82 x' │
-│          ObjectB │    2000    │ '   2896 ms' │ '     37 ms' │ '   78.27 x' │
-│            Tuple │    2000    │ '   1244 ms' │ '     21 ms' │ '   59.24 x' │
-│            Union │    2000    │ '   1258 ms' │ '     25 ms' │ '   50.32 x' │
-│          Vector4 │    2000    │ '   1513 ms' │ '     21 ms' │ '   72.05 x' │
-│          Matrix4 │    2000    │ '    850 ms' │ '     11 ms' │ '   77.27 x' │
-│   Literal_String │    2000    │ '    335 ms' │ '      7 ms' │ '   47.86 x' │
-│   Literal_Number │    2000    │ '    358 ms' │ '      7 ms' │ '   51.14 x' │
-│  Literal_Boolean │    2000    │ '    356 ms' │ '      7 ms' │ '   50.86 x' │
-│     Array_Number │    2000    │ '    689 ms' │ '      9 ms' │ '   76.56 x' │
-│     Array_String │    2000    │ '    728 ms' │ '     12 ms' │ '   60.67 x' │
-│    Array_Boolean │    2000    │ '    726 ms' │ '      7 ms' │ '  103.71 x' │
-│    Array_ObjectA │    2000    │ '   3631 ms' │ '     35 ms' │ '  103.74 x' │
-│    Array_ObjectB │    2000    │ '   3636 ms' │ '     40 ms' │ '   90.90 x' │
-│      Array_Tuple │    2000    │ '   2119 ms' │ '     31 ms' │ '   68.35 x' │
-│      Array_Union │    2000    │ '   1550 ms' │ '     23 ms' │ '   67.39 x' │
-│    Array_Vector4 │    2000    │ '   2200 ms' │ '     18 ms' │ '  122.22 x' │
-│    Array_Matrix4 │    2000    │ '   1494 ms' │ '     14 ms' │ '  106.71 x' │
+│           Number │    2000    │ '    427 ms' │ '     13 ms' │ '   32.85 x' │
+│           String │    2000    │ '    367 ms' │ '     12 ms' │ '   30.58 x' │
+│          Boolean │    2000    │ '    297 ms' │ '     13 ms' │ '   22.85 x' │
+│             Null │    2000    │ '    255 ms' │ '      9 ms' │ '   28.33 x' │
+│            RegEx │    2000    │ '    487 ms' │ '     17 ms' │ '   28.65 x' │
+│          ObjectA │    2000    │ '   2718 ms' │ '     53 ms' │ '   51.28 x' │
+│          ObjectB │    2000    │ '   2874 ms' │ '     36 ms' │ '   79.83 x' │
+│            Tuple │    2000    │ '   1221 ms' │ '     22 ms' │ '   55.50 x' │
+│            Union │    2000    │ '   1223 ms' │ '     24 ms' │ '   50.96 x' │
+│          Vector4 │    2000    │ '   1517 ms' │ '     21 ms' │ '   72.24 x' │
+│          Matrix4 │    2000    │ '    830 ms' │ '     10 ms' │ '   83.00 x' │
+│   Literal_String │    2000    │ '    334 ms' │ '      8 ms' │ '   41.75 x' │
+│   Literal_Number │    2000    │ '    357 ms' │ '      6 ms' │ '   59.50 x' │
+│  Literal_Boolean │    2000    │ '    353 ms' │ '      7 ms' │ '   50.43 x' │
+│     Array_Number │    2000    │ '    679 ms' │ '     11 ms' │ '   61.73 x' │
+│     Array_String │    2000    │ '    713 ms' │ '     10 ms' │ '   71.30 x' │
+│    Array_Boolean │    2000    │ '    710 ms' │ '      7 ms' │ '  101.43 x' │
+│    Array_ObjectA │    2000    │ '   3571 ms' │ '     35 ms' │ '  102.03 x' │
+│    Array_ObjectB │    2000    │ '   3567 ms' │ '     41 ms' │ '   87.00 x' │
+│      Array_Tuple │    2000    │ '   2083 ms' │ '     19 ms' │ '  109.63 x' │
+│      Array_Union │    2000    │ '   1559 ms' │ '     23 ms' │ '   67.78 x' │
+│    Array_Vector4 │    2000    │ '   2156 ms' │ '     19 ms' │ '  113.47 x' │
+│    Array_Matrix4 │    2000    │ '   1483 ms' │ '     13 ms' │ '  114.08 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1199,31 +1224,31 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  1000000   │ '     28 ms' │ '      6 ms' │ '      6 ms' │ '    1.00 x' │
-│           String │  1000000   │ '     25 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
-│          Boolean │  1000000   │ '     34 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
-│             Null │  1000000   │ '     37 ms' │ '     28 ms' │ '     10 ms' │ '    2.80 x' │
-│            RegEx │  1000000   │ '    162 ms' │ '     50 ms' │ '     37 ms' │ '    1.35 x' │
-│          ObjectA │  1000000   │ '    550 ms' │ '     38 ms' │ '     22 ms' │ '    1.73 x' │
-│          ObjectB │  1000000   │ '   1033 ms' │ '     58 ms' │ '     38 ms' │ '    1.53 x' │
-│            Tuple │  1000000   │ '    126 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
-│            Union │  1000000   │ '    326 ms' │ '     25 ms' │ '     16 ms' │ '    1.56 x' │
-│        Recursive │  1000000   │ '   3089 ms' │ '    436 ms' │ '    101 ms' │ '    4.32 x' │
-│          Vector4 │  1000000   │ '    155 ms' │ '     24 ms' │ '     12 ms' │ '    2.00 x' │
-│          Matrix4 │  1000000   │ '    579 ms' │ '     41 ms' │ '     28 ms' │ '    1.46 x' │
-│   Literal_String │  1000000   │ '     50 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
-│   Literal_Number │  1000000   │ '     46 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
+│           Number │  1000000   │ '     25 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
+│           String │  1000000   │ '     22 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
+│          Boolean │  1000000   │ '     21 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
+│             Null │  1000000   │ '     24 ms' │ '     21 ms' │ '      9 ms' │ '    2.33 x' │
+│            RegEx │  1000000   │ '    158 ms' │ '     46 ms' │ '     37 ms' │ '    1.24 x' │
+│          ObjectA │  1000000   │ '    566 ms' │ '     36 ms' │ '     24 ms' │ '    1.50 x' │
+│          ObjectB │  1000000   │ '   1026 ms' │ '     52 ms' │ '     40 ms' │ '    1.30 x' │
+│            Tuple │  1000000   │ '    121 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
+│            Union │  1000000   │ '    299 ms' │ '     26 ms' │ '     16 ms' │ '    1.63 x' │
+│        Recursive │  1000000   │ '   3168 ms' │ '    414 ms' │ '     97 ms' │ '    4.27 x' │
+│          Vector4 │  1000000   │ '    147 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
+│          Matrix4 │  1000000   │ '    573 ms' │ '     40 ms' │ '     29 ms' │ '    1.38 x' │
+│   Literal_String │  1000000   │ '     48 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│   Literal_Number │  1000000   │ '     46 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
 │  Literal_Boolean │  1000000   │ '     48 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
-│     Array_Number │  1000000   │ '    424 ms' │ '     32 ms' │ '     19 ms' │ '    1.68 x' │
-│     Array_String │  1000000   │ '    483 ms' │ '     34 ms' │ '     28 ms' │ '    1.21 x' │
-│    Array_Boolean │  1000000   │ '    432 ms' │ '     35 ms' │ '     26 ms' │ '    1.35 x' │
-│    Array_ObjectA │  1000000   │ '  13895 ms' │ '   2440 ms' │ '   1495 ms' │ '    1.63 x' │
-│    Array_ObjectB │  1000000   │ '  16261 ms' │ '   2633 ms' │ '   2011 ms' │ '    1.31 x' │
-│      Array_Tuple │  1000000   │ '   1741 ms' │ '     98 ms' │ '     66 ms' │ '    1.48 x' │
-│      Array_Union │  1000000   │ '   4825 ms' │ '    232 ms' │ '     87 ms' │ '    2.67 x' │
-│  Array_Recursive │  1000000   │ '  54158 ms' │ '   6966 ms' │ '   1173 ms' │ '    5.94 x' │
-│    Array_Vector4 │  1000000   │ '   2577 ms' │ '     99 ms' │ '     48 ms' │ '    2.06 x' │
-│    Array_Matrix4 │  1000000   │ '  12648 ms' │ '    397 ms' │ '    249 ms' │ '    1.59 x' │
+│     Array_Number │  1000000   │ '    454 ms' │ '     32 ms' │ '     18 ms' │ '    1.78 x' │
+│     Array_String │  1000000   │ '    481 ms' │ '     32 ms' │ '     22 ms' │ '    1.45 x' │
+│    Array_Boolean │  1000000   │ '    448 ms' │ '     34 ms' │ '     27 ms' │ '    1.26 x' │
+│    Array_ObjectA │  1000000   │ '  13709 ms' │ '   2360 ms' │ '   1548 ms' │ '    1.52 x' │
+│    Array_ObjectB │  1000000   │ '  16602 ms' │ '   2585 ms' │ '   1904 ms' │ '    1.36 x' │
+│      Array_Tuple │  1000000   │ '   1831 ms' │ '     96 ms' │ '     63 ms' │ '    1.52 x' │
+│      Array_Union │  1000000   │ '   4958 ms' │ '    234 ms' │ '     86 ms' │ '    2.72 x' │
+│  Array_Recursive │  1000000   │ '  55876 ms' │ '   7160 ms' │ '   1138 ms' │ '    6.29 x' │
+│    Array_Vector4 │  1000000   │ '   2381 ms' │ '     99 ms' │ '     47 ms' │ '    2.11 x' │
+│    Array_Matrix4 │  1000000   │ '  11670 ms' │ '    383 ms' │ '    228 ms' │ '    1.68 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1237,11 +1262,12 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '   54 kb' │ '   27 kb' │  '1.97 x'   │
-│ typebox/conditional  │ '   44 kb' │ '   17 kb' │  '2.45 x'   │
+│ typebox/compiler     │ '   55 kb' │ '   27 kb' │  '2.00 x'   │
+│ typebox/conditional  │ '   45 kb' │ '   18 kb' │  '2.44 x'   │
+│ typebox/custom       │ '    0 kb' │ '    0 kb' │  '2.61 x'   │
 │ typebox/format       │ '    0 kb' │ '    0 kb' │  '2.66 x'   │
-│ typebox/guard        │ '   22 kb' │ '   11 kb' │  '2.05 x'   │
-│ typebox/value        │ '   78 kb' │ '   36 kb' │  '2.13 x'   │
+│ typebox/guard        │ '   23 kb' │ '   11 kb' │  '2.07 x'   │
+│ typebox/value        │ '   80 kb' │ '   37 kb' │  '2.15 x'   │
 │ typebox              │ '   12 kb' │ '    6 kb' │  '1.89 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 922e504d8..04d0d2bce 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -29,6 +29,7 @@ THE SOFTWARE.
 import { ValueErrors, ValueError } from '../errors/index'
 import { TypeGuard } from '../guard/index'
 import { Format } from '../format/index'
+import { Custom } from '../custom/index'
 import * as Types from '../typebox'
 
 // -------------------------------------------------------------------
@@ -289,6 +290,10 @@ export namespace TypeCompiler {
     yield `(${value} === null)`
   }
 
+  function* Kind(schema: Types.TSchema, value: string): IterableIterator<string> {
+    yield `(custom('${schema[Types.Kind]}', ${value}))`
+  }
+
   function* Visit<T extends Types.TSchema>(schema: T, value: string): IterableIterator<string> {
     // Reference: Referenced schemas can originate from either additional schemas
     // or inline in the schema itself. Ideally the recursive path should align to
@@ -350,7 +355,8 @@ export namespace TypeCompiler {
       case 'Void':
         return yield* Void(anySchema, value)
       default:
-        throw new TypeCompilerUnknownTypeError(schema)
+        if (!Custom.Has(anySchema[Types.Kind])) throw new TypeCompilerUnknownTypeError(schema)
+        return yield* Kind(anySchema, value)
     }
   }
 
@@ -419,12 +425,19 @@ export namespace TypeCompiler {
   export function Compile<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []): TypeCheck<T> {
     TypeGuard.Assert(schema, references)
     const code = Build(schema, references)
-    const func1 = globalThis.Function('format', code)
-    const func2 = func1((format: string, value: string) => {
-      if (!Format.Has(format)) return false
-      const func = Format.Get(format)!
-      return func(value)
-    })
-    return new TypeCheck(schema, references, func2, code)
+    const compiledFunction = globalThis.Function('custom', 'format', code)
+    const checkFunction = compiledFunction(
+      (kind: string, value: unknown) => {
+        if (!Custom.Has(kind)) return false
+        const func = Custom.Get(kind)!
+        return func(value)
+      },
+      (format: string, value: string) => {
+        if (!Format.Has(format)) return false
+        const func = Format.Get(format)!
+        return func(value)
+      },
+    )
+    return new TypeCheck(schema, references, checkFunction, code)
   }
 }
diff --git a/src/conditional/structural.ts b/src/conditional/structural.ts
index 62c04ac33..2f0465091 100644
--- a/src/conditional/structural.ts
+++ b/src/conditional/structural.ts
@@ -51,11 +51,12 @@ export namespace Structural {
   // Rules
   // ------------------------------------------------------------------------
 
-  function AnyOrUnknownRule(right: Types.TSchema) {
+  function AnyUnknownOrCustomRule(right: Types.TSchema) {
     // https://github.com/microsoft/TypeScript/issues/40049
-    if (right[Types.Kind] === 'Union' && right.anyOf.some((schema: Types.TSchema) => schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown')) return true
-    if (right[Types.Kind] === 'Unknown') return true
-    if (right[Types.Kind] === 'Any') return true
+    if (TypeGuard.TUnion(right) && right.anyOf.some((schema: Types.TSchema) => schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown')) return true
+    if (TypeGuard.TUnknown(right)) return true
+    if (TypeGuard.TAny(right)) return true
+    if (TypeGuard.TCustom(right)) throw Error(`Structural: Cannot structurally compare custom type '${right[Types.Kind]}'`)
     return false
   }
 
@@ -138,11 +139,11 @@ export namespace Structural {
   // ------------------------------------------------------------------------
 
   function Any(left: Types.TAny, right: Types.TSchema): StructuralResult {
-    return AnyOrUnknownRule(right) ? StructuralResult.True : StructuralResult.Union
+    return AnyUnknownOrCustomRule(right) ? StructuralResult.True : StructuralResult.Union
   }
 
   function Array(left: Types.TArray, right: Types.TSchema): StructuralResult {
-    if (AnyOrUnknownRule(right)) {
+    if (AnyUnknownOrCustomRule(right)) {
       return StructuralResult.True
     } else if (TypeGuard.TObject(right)) {
       if (right.properties['length'] !== undefined && right.properties['length'][Types.Kind] === 'Number') return StructuralResult.True
@@ -163,7 +164,7 @@ export namespace Structural {
   }
 
   function Boolean(left: Types.TBoolean, right: Types.TSchema): StructuralResult {
-    if (AnyOrUnknownRule(right)) {
+    if (AnyUnknownOrCustomRule(right)) {
       return StructuralResult.True
     } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
       return StructuralResult.True
@@ -177,7 +178,7 @@ export namespace Structural {
   }
 
   function Constructor(left: Types.TConstructor, right: Types.TSchema): StructuralResult {
-    if (AnyOrUnknownRule(right)) {
+    if (AnyUnknownOrCustomRule(right)) {
       return StructuralResult.True
     } else if (TypeGuard.TObject(right) && globalThis.Object.keys(right.properties).length === 0) {
       return StructuralResult.True
@@ -198,7 +199,7 @@ export namespace Structural {
   }
 
   function Date(left: Types.TDate, right: Types.TSchema): StructuralResult {
-    if (AnyOrUnknownRule(right)) {
+    if (AnyUnknownOrCustomRule(right)) {
       return StructuralResult.True
     } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
       return StructuralResult.True
@@ -214,7 +215,7 @@ export namespace Structural {
   }
 
   function Function(left: Types.TFunction, right: Types.TSchema): StructuralResult {
-    if (AnyOrUnknownRule(right)) {
+    if (AnyUnknownOrCustomRule(right)) {
       return StructuralResult.True
     } else if (TypeGuard.TObject(right)) {
       if (right.properties['length'] !== undefined && right.properties['length'][Types.Kind] === 'Number') return StructuralResult.True
@@ -236,7 +237,7 @@ export namespace Structural {
   }
 
   function Integer(left: Types.TInteger, right: Types.TSchema): StructuralResult {
-    if (AnyOrUnknownRule(right)) {
+    if (AnyUnknownOrCustomRule(right)) {
       return StructuralResult.True
     } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
       return StructuralResult.True
@@ -250,7 +251,7 @@ export namespace Structural {
   }
 
   function Literal(left: Types.TLiteral, right: Types.TSchema): StructuralResult {
-    if (AnyOrUnknownRule(right)) {
+    if (AnyUnknownOrCustomRule(right)) {
       return StructuralResult.True
     } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
       return StructuralResult.True
@@ -278,7 +279,7 @@ export namespace Structural {
   }
 
   function Number(left: Types.TNumber, right: Types.TSchema): StructuralResult {
-    if (AnyOrUnknownRule(right)) {
+    if (AnyUnknownOrCustomRule(right)) {
       return StructuralResult.True
     } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
       return StructuralResult.True
@@ -294,7 +295,7 @@ export namespace Structural {
   }
 
   function Null(left: Types.TNull, right: Types.TSchema): StructuralResult {
-    if (AnyOrUnknownRule(right)) {
+    if (AnyUnknownOrCustomRule(right)) {
       return StructuralResult.True
     } else if (TypeGuard.TNull(right)) {
       return StructuralResult.True
@@ -319,7 +320,7 @@ export namespace Structural {
   }
 
   function Object(left: Types.TObject, right: Types.TAnySchema): StructuralResult {
-    if (AnyOrUnknownRule(right)) {
+    if (AnyUnknownOrCustomRule(right)) {
       return StructuralResult.True
     } else if (TypeGuard.TObject(right)) {
       return Properties(PropertyMap(left), PropertyMap(right))
@@ -335,7 +336,7 @@ export namespace Structural {
   }
 
   function Promise(left: Types.TPromise, right: Types.TSchema): StructuralResult {
-    if (AnyOrUnknownRule(right)) {
+    if (AnyUnknownOrCustomRule(right)) {
       return StructuralResult.True
     } else if (TypeGuard.TObject(right)) {
       if (ObjectRightRule(left, right) || globalThis.Object.keys(right.properties).length === 0) {
@@ -352,7 +353,7 @@ export namespace Structural {
   }
 
   function Record(left: Types.TRecord, right: Types.TSchema): StructuralResult {
-    if (AnyOrUnknownRule(right)) {
+    if (AnyUnknownOrCustomRule(right)) {
       return StructuralResult.True
     } else if (TypeGuard.TObject(right)) {
       if (RecordPattern(left) === '^.*$' && right[Types.Hint] === 'Record') {
@@ -394,7 +395,7 @@ export namespace Structural {
   }
 
   function String(left: Types.TString, right: Types.TSchema): StructuralResult {
-    if (AnyOrUnknownRule(right)) {
+    if (AnyUnknownOrCustomRule(right)) {
       return StructuralResult.True
     } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
       return StructuralResult.True
@@ -410,7 +411,7 @@ export namespace Structural {
   }
 
   function Tuple(left: Types.TTuple, right: Types.TSchema): StructuralResult {
-    if (AnyOrUnknownRule(right)) {
+    if (AnyUnknownOrCustomRule(right)) {
       return StructuralResult.True
     } else if (TypeGuard.TObject(right)) {
       const result = ObjectRightRule(left, right) || globalThis.Object.keys(right.properties).length === 0
@@ -442,7 +443,7 @@ export namespace Structural {
   }
 
   function Uint8Array(left: Types.TUint8Array, right: Types.TSchema): StructuralResult {
-    if (AnyOrUnknownRule(right)) {
+    if (AnyUnknownOrCustomRule(right)) {
       return StructuralResult.True
     } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
       return StructuralResult.True
@@ -458,7 +459,7 @@ export namespace Structural {
   }
 
   function Undefined(left: Types.TUndefined, right: Types.TSchema): StructuralResult {
-    if (AnyOrUnknownRule(right)) {
+    if (AnyUnknownOrCustomRule(right)) {
       return StructuralResult.True
     } else if (TypeGuard.TUndefined(right)) {
       return StructuralResult.True
@@ -562,6 +563,8 @@ export namespace Structural {
       return Unknown(left, resolvedRight)
     } else if (TypeGuard.TVoid(left)) {
       return Void(left, resolvedRight)
+    } else if (TypeGuard.TCustom(left)) {
+      throw Error(`Structural: Cannot structurally compare custom type '${left[Types.Kind]}'`)
     } else {
       throw Error(`Structural: Unknown left operand '${left[Types.Kind]}'`)
     }
diff --git a/src/custom/custom.ts b/src/custom/custom.ts
new file mode 100644
index 000000000..0f9128581
--- /dev/null
+++ b/src/custom/custom.ts
@@ -0,0 +1,54 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/custom
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export type CustomValidationFunction = (value: unknown) => boolean
+
+/** Provides functions to create custom types */
+export namespace Custom {
+  const customs = new Map<string, CustomValidationFunction>()
+
+  /** Clears all custom types */
+  export function Clear() {
+    return customs.clear()
+  }
+
+  /** Returns true if this kind exists */
+  export function Has(kind: string) {
+    return customs.has(kind)
+  }
+
+  /** Sets a validation function for a custom kind */
+  export function Set(kind: string, func: CustomValidationFunction) {
+    customs.set(kind, func)
+  }
+
+  /** Gets a custom validation function */
+  export function Get(kind: string) {
+    return customs.get(kind)
+  }
+}
diff --git a/src/custom/index.ts b/src/custom/index.ts
new file mode 100644
index 000000000..5c5b0bf66
--- /dev/null
+++ b/src/custom/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/custom
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './custom'
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index c7f43e791..f2cd2d00e 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -28,6 +28,7 @@ THE SOFTWARE.
 
 import * as Types from '../typebox'
 import { Format } from '../format/index'
+import { Custom } from '../custom/index'
 
 // -------------------------------------------------------------------
 // ValueErrorType
@@ -82,6 +83,7 @@ export enum ValueErrorType {
   Uint8ArrayMinByteLength,
   Uint8ArrayMaxByteLength,
   Void,
+  Custom,
 }
 
 // -------------------------------------------------------------------
@@ -378,7 +380,6 @@ export namespace ValueErrors {
     if (!(value instanceof globalThis.Uint8Array)) {
       return yield { type: ValueErrorType.Uint8Array, schema, path, value, message: `Expected Uint8Array` }
     }
-
     if (IsNumber(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
       yield { type: ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length less or equal to ${schema.maxByteLength}` }
     }
@@ -395,6 +396,13 @@ export namespace ValueErrors {
     }
   }
 
+  function* CustomType(schema: Types.TSchema, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    const func = Custom.Get(schema[Types.Kind])!
+    if (!func(value)) {
+      return yield { type: ValueErrorType.Custom, schema, path, value, message: `Expected kind ${schema[Types.Kind]}` }
+    }
+  }
+
   function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     const anyReferences = schema.$id === undefined ? references : [schema, ...references]
     const anySchema = schema as any
@@ -446,7 +454,8 @@ export namespace ValueErrors {
       case 'Void':
         return yield* Void(anySchema, anyReferences, path, value)
       default:
-        throw new ValueErrorsUnknownTypeError(schema)
+        if (!Custom.Has(anySchema[Types.Kind])) throw new ValueErrorsUnknownTypeError(schema)
+        return yield* CustomType(anySchema, anyReferences, path, value)
     }
   }
 
diff --git a/src/guard/guard.ts b/src/guard/guard.ts
index ca61df37d..429e908cb 100644
--- a/src/guard/guard.ts
+++ b/src/guard/guard.ts
@@ -26,11 +26,12 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { Custom } from '../custom/index'
 import * as Types from '../typebox'
 
-export class TypeGuardInvalidTypeError extends Error {
+export class TypeGuardUnknownTypeError extends Error {
   constructor(public readonly schema: unknown) {
-    super('TypeGuard: Invalid type')
+    super('TypeGuard: Unknown type')
   }
 }
 
@@ -441,6 +442,11 @@ export namespace TypeGuard {
     )
   }
 
+  /** Returns true if the given schema is a registered custom type */
+  export function TCustom(schema: unknown): schema is Types.TSchema {
+    return IsObject(schema) && IsString(schema[Types.Kind]) && Custom.Has(schema[Types.Kind])
+  }
+
   /** Returns true if the given schema is TSchema */
   export function TSchema(schema: unknown): schema is Types.TSchema {
     return (
@@ -466,15 +472,16 @@ export namespace TypeGuard {
       TUnion(schema) ||
       TUint8Array(schema) ||
       TUnknown(schema) ||
-      TVoid(schema)
+      TVoid(schema) ||
+      TCustom(schema)
     )
   }
 
   /** Asserts if this schema and associated references are valid. */
   export function Assert<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []) {
-    if (!TSchema(schema)) throw new TypeGuardInvalidTypeError(schema)
+    if (!TSchema(schema)) throw new TypeGuardUnknownTypeError(schema)
     for (const schema of references) {
-      if (!TSchema(schema)) throw new TypeGuardInvalidTypeError(schema)
+      if (!TSchema(schema)) throw new TypeGuardUnknownTypeError(schema)
     }
   }
 }
diff --git a/src/tsconfig.json b/src/tsconfig.json
index 3bca8a311..c8ce66e6d 100644
--- a/src/tsconfig.json
+++ b/src/tsconfig.json
@@ -1,4 +1,4 @@
 {
   "extends": "../tsconfig.json",
-  "files": ["compiler/index.ts", "conditional/index.ts", "format/index.ts", "guard/index.ts", "value/index.ts", "typebox.ts"]
+  "files": ["compiler/index.ts", "conditional/index.ts", "custom/index.ts", "format/index.ts", "guard/index.ts", "value/index.ts", "typebox.ts"]
 }
diff --git a/src/value/cast.ts b/src/value/cast.ts
index 19c7b9133..094cbfd5c 100644
--- a/src/value/cast.ts
+++ b/src/value/cast.ts
@@ -30,6 +30,7 @@ import * as Types from '../typebox'
 import { ValueCreate } from './create'
 import { ValueCheck } from './check'
 import { ValueClone } from './clone'
+import { Custom } from '../custom/index'
 
 // ----------------------------------------------------------------------------------------------
 // Errors
@@ -322,6 +323,10 @@ export namespace ValueCast {
     return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
 
+  function Kind(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+  }
+
   export function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
     const anyReferences = schema.$id === undefined ? references : [schema, ...references]
     const anySchema = schema as any
@@ -375,7 +380,8 @@ export namespace ValueCast {
       case 'Void':
         return Void(anySchema, anyReferences, value)
       default:
-        throw new ValueCastUnknownTypeError(anySchema)
+        if (!Custom.Has(anySchema[Types.Kind])) throw new ValueCastUnknownTypeError(anySchema)
+        return Kind(anySchema, anyReferences, value)
     }
   }
 
diff --git a/src/value/check.ts b/src/value/check.ts
index e17d90cf3..7c7c8bef9 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -27,7 +27,8 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import * as Types from '../typebox'
-import { Format } from '../format'
+import { Format } from '../format/index'
+import { Custom } from '../custom/index'
 
 export class ValueCheckUnknownTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
@@ -297,6 +298,12 @@ export namespace ValueCheck {
     return value === null
   }
 
+  function Kind(schema: Types.TSchema, references: Types.TSchema[], value: unknown): boolean {
+    if (!Custom.Has(schema[Types.Kind])) return false
+    const func = Custom.Get(schema[Types.Kind])!
+    return func(value)
+  }
+
   function Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): boolean {
     const anyReferences = schema.$id === undefined ? references : [schema, ...references]
     const anySchema = schema as any
@@ -348,7 +355,8 @@ export namespace ValueCheck {
       case 'Void':
         return Void(anySchema, anyReferences, value)
       default:
-        throw new ValueCheckUnknownTypeError(anySchema)
+        if (!Custom.Has(anySchema[Types.Kind])) throw new ValueCheckUnknownTypeError(anySchema)
+        return Kind(anySchema, anyReferences, value)
     }
   }
 
diff --git a/src/value/create.ts b/src/value/create.ts
index bb742c407..ad67b771d 100644
--- a/src/value/create.ts
+++ b/src/value/create.ts
@@ -27,6 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import * as Types from '../typebox'
+import { Custom } from '../custom/index'
 
 export class ValueCreateUnknownTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
@@ -277,6 +278,14 @@ export namespace ValueCreate {
     return null
   }
 
+  function Kind(schema: Types.TSchema, references: Types.TSchema[]): any {
+    if (schema.default !== undefined) {
+      return schema.default
+    } else {
+      throw new Error('ValueCreate.Kind: Custom types must specify a default value')
+    }
+  }
+
   /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
   export function Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T> {
     const anyReferences = schema.$id === undefined ? references : [schema, ...references]
@@ -332,7 +341,8 @@ export namespace ValueCreate {
       case 'Void':
         return Void(anySchema, anyReferences)
       default:
-        throw new ValueCreateUnknownTypeError(anySchema)
+        if (!Custom.Has(anySchema[Types.Kind])) throw new ValueCreateUnknownTypeError(anySchema)
+        return Kind(anySchema, anyReferences)
     }
   }
 
diff --git a/test/runtime/compiler/custom.ts b/test/runtime/compiler/custom.ts
new file mode 100644
index 000000000..14ef55e66
--- /dev/null
+++ b/test/runtime/compiler/custom.ts
@@ -0,0 +1,28 @@
+import { Custom } from '@sinclair/typebox/custom'
+import { Type, Kind } from '@sinclair/typebox'
+import { ok, fail } from './validate'
+
+describe('type/compiler/Custom', () => {
+  Custom.Set('BigInt', (value) => typeof value === 'bigint')
+
+  it('Should validate bigint', () => {
+    const T = Type.Unsafe({ [Kind]: 'BigInt' })
+    ok(T, 1n)
+  })
+  it('Should not validate bigint', () => {
+    const T = Type.Unsafe({ [Kind]: 'BigInt' })
+    fail(T, 1)
+  })
+  it('Should validate bigint nested', () => {
+    const T = Type.Object({
+      x: Type.Unsafe({ [Kind]: 'BigInt' }),
+    })
+    ok(T, { x: 1n })
+  })
+  it('Should not validate bigint nested', () => {
+    const T = Type.Object({
+      x: Type.Unsafe({ [Kind]: 'BigInt' }),
+    })
+    fail(T, { x: 1 })
+  })
+})
diff --git a/test/runtime/compiler/index.ts b/test/runtime/compiler/index.ts
index 01159a601..d06324993 100644
--- a/test/runtime/compiler/index.ts
+++ b/test/runtime/compiler/index.ts
@@ -1,6 +1,7 @@
 import './any'
 import './array'
 import './boolean'
+import './custom'
 import './date'
 import './enum'
 import './integer'
diff --git a/test/runtime/errors/index.ts b/test/runtime/errors/index.ts
new file mode 100644
index 000000000..3443ef957
--- /dev/null
+++ b/test/runtime/errors/index.ts
@@ -0,0 +1 @@
+// todo: implement once errors are standardized
diff --git a/test/runtime/index.ts b/test/runtime/index.ts
index 77bb736d2..ea1496280 100644
--- a/test/runtime/index.ts
+++ b/test/runtime/index.ts
@@ -1,5 +1,6 @@
 import './compiler/index'
 import './conditional/index'
+import './errors/index'
 import './format/index'
 import './guard/index'
 import './schema/index'
diff --git a/test/runtime/value/cast/custom.ts b/test/runtime/value/cast/custom.ts
new file mode 100644
index 000000000..ceb931198
--- /dev/null
+++ b/test/runtime/value/cast/custom.ts
@@ -0,0 +1,64 @@
+import { Value } from '@sinclair/typebox/value'
+import { Custom } from '@sinclair/typebox/custom'
+import { Type, Kind } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Custom', () => {
+  Custom.Set('CustomCast', (value) => value === 'hello' || value === 'world')
+  const T = Type.Unsafe({ [Kind]: 'CustomCast', default: 'hello' })
+  const E = 'hello'
+
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from boolean', () => {
+    const value = false
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+
+  it('Should preserve', () => {
+    const value = { a: 'hello', b: 'world' }
+    const result = Value.Cast(
+      Type.Object({
+        a: T,
+        b: T,
+      }),
+      value,
+    )
+    Assert.deepEqual(result, { a: 'hello', b: 'world' })
+  })
+})
diff --git a/test/runtime/value/cast/index.ts b/test/runtime/value/cast/index.ts
index 74b79cd8a..58b1e8252 100644
--- a/test/runtime/value/cast/index.ts
+++ b/test/runtime/value/cast/index.ts
@@ -2,6 +2,7 @@ import './any'
 import './array'
 import './boolean'
 import './convert'
+import './custom'
 import './date'
 import './enum'
 import './integer'
diff --git a/test/runtime/value/check/custom.ts b/test/runtime/value/check/custom.ts
new file mode 100644
index 000000000..026b64e60
--- /dev/null
+++ b/test/runtime/value/check/custom.ts
@@ -0,0 +1,28 @@
+import { Value } from '@sinclair/typebox/value'
+import { Custom } from '@sinclair/typebox/custom'
+import { Type, Kind } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/check/Custom', () => {
+  Custom.Set('BigInt', (value) => typeof value === 'bigint')
+  it('Should validate bigint', () => {
+    const T = Type.Unsafe({ [Kind]: 'BigInt' })
+    Assert.deepEqual(Value.Check(T, 1n), true)
+  })
+  it('Should not validate bigint', () => {
+    const T = Type.Unsafe({ [Kind]: 'BigInt' })
+    Assert.deepEqual(Value.Check(T, 1), false)
+  })
+  it('Should validate bigint nested', () => {
+    const T = Type.Object({
+      x: Type.Unsafe({ [Kind]: 'BigInt' }),
+    })
+    Assert.deepEqual(Value.Check(T, { x: 1n }), true)
+  })
+  it('Should not validate bigint nested', () => {
+    const T = Type.Object({
+      x: Type.Unsafe({ [Kind]: 'BigInt' }),
+    })
+    Assert.deepEqual(Value.Check(T, { x: 1 }), false)
+  })
+})
diff --git a/test/runtime/value/check/index.ts b/test/runtime/value/check/index.ts
index 26759b50d..eb99c6eba 100644
--- a/test/runtime/value/check/index.ts
+++ b/test/runtime/value/check/index.ts
@@ -1,6 +1,7 @@
 import './any'
 import './array'
 import './boolean'
+import './custom'
 import './date'
 import './enum'
 import './integer'
diff --git a/test/runtime/value/create/custom.ts b/test/runtime/value/create/custom.ts
new file mode 100644
index 000000000..2703379fc
--- /dev/null
+++ b/test/runtime/value/create/custom.ts
@@ -0,0 +1,18 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type, Kind } from '@sinclair/typebox'
+import { Custom } from '@sinclair/typebox/custom'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Custom', () => {
+  it('Should create custom value with default', () => {
+    Custom.Set('CustomCreate1', (value) => true)
+    const T = Type.Unsafe({ [Kind]: 'CustomCreate1', default: 'hello' })
+    Assert.deepEqual(Value.Create(T), 'hello')
+  })
+
+  it('Should throw when no default value is specified', () => {
+    Custom.Set('CustomCreate2', (value) => true)
+    const T = Type.Unsafe({ [Kind]: 'CustomCreate2' })
+    Assert.throws(() => Value.Create(T))
+  })
+})
diff --git a/test/runtime/value/create/index.ts b/test/runtime/value/create/index.ts
index db38f47ad..2e06b6f0f 100644
--- a/test/runtime/value/create/index.ts
+++ b/test/runtime/value/create/index.ts
@@ -1,6 +1,7 @@
 import './any'
 import './array'
 import './boolean'
+import './custom'
 import './constructor'
 import './enum'
 import './function'
diff --git a/tsconfig.json b/tsconfig.json
index df793c134..41c97c61c 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -16,6 +16,9 @@
       "@sinclair/typebox/conditional": [
         "src/conditional/index.ts"
       ],
+      "@sinclair/typebox/custom": [
+        "src/custom/index.ts"
+      ],
       "@sinclair/typebox/format": [
         "src/format/index.ts"
       ],

From 0c1741a179af328c0627c420fe32ed8a70ed7c3d Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 22 Nov 2022 22:09:21 +0900
Subject: [PATCH 036/369] changelog

---
 changelog.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/changelog.md b/changelog.md
index d4535926a..bd439349b 100644
--- a/changelog.md
+++ b/changelog.md
@@ -2,7 +2,7 @@
 
 Updates:
 
-- TypeBox now supports custom types. These types require the user to specify a custom `[Kind]` string on the type. Custom types can be registered via `Custom.Set('<Kind>', (value) => { ... })`.
+- [282](https://github.com/sinclairzx81/typebox/pull/282) TypeBox now supports custom types. These types require the user to specify a custom `[Kind]` string on the type. Custom types can be registered via `Custom.Set('<Kind>', (value) => { ... })`.
 
 ## [0.25.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.0)
 

From 18f892b2ae6e34e9836a88f12578e8b041c021de Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 22 Nov 2022 22:10:35 +0900
Subject: [PATCH 037/369] Changelog

---
 changelog.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/changelog.md b/changelog.md
index bd439349b..d8ffa70a0 100644
--- a/changelog.md
+++ b/changelog.md
@@ -2,7 +2,7 @@
 
 Updates:
 
-- [282](https://github.com/sinclairzx81/typebox/pull/282) TypeBox now supports custom types. These types require the user to specify a custom `[Kind]` string on the type. Custom types can be registered via `Custom.Set('<Kind>', (value) => { ... })`.
+- [282](https://github.com/sinclairzx81/typebox/pull/282) TypeBox now supports custom types. These types require the user to specify a custom `[Kind]` string on the type. Custom types can be registered via `Custom.Set('<Kind>', (value) => { ... })` which allow the TypeCompiler and Value API's to make use of user defined validation logic.
 
 ## [0.25.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.0)
 

From 18017549c8e26748117daab38c74cad962b9e3a2 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 25 Nov 2022 14:39:52 +0900
Subject: [PATCH 038/369] Custom Constraints (#283)

---
 example/index.ts                    |   4 +-
 package-lock.json                   |  46 +++++-----
 package.json                        |   8 +-
 readme.md                           | 130 ++++++++++++++--------------
 src/compiler/compiler.ts            |  54 +++++++-----
 src/conditional/structural.ts       |   4 +-
 src/custom/custom.ts                |  16 ++--
 src/errors/errors.ts                |   6 +-
 src/format/format.ts                |  10 +--
 src/guard/guard.ts                  |   6 +-
 src/value/cast.ts                   |   4 +-
 src/value/check.ts                  |   8 +-
 src/value/create.ts                 |   6 +-
 test/runtime/compiler/custom.ts     |   2 +-
 test/runtime/value/cast/custom.ts   |   2 +-
 test/runtime/value/check/custom.ts  |   6 +-
 test/runtime/value/create/custom.ts |   4 +-
 17 files changed, 165 insertions(+), 151 deletions(-)

diff --git a/example/index.ts b/example/index.ts
index 97c0303f9..dfde052cf 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -5,7 +5,7 @@ import { TypeGuard } from '@sinclair/typebox/guard'
 import { Format } from '@sinclair/typebox/format'
 import { Custom } from '@sinclair/typebox/custom'
 import { Value, ValuePointer } from '@sinclair/typebox/value'
-import { Type, Static, TSchema } from '@sinclair/typebox'
+import { Type, Kind, Static, TSchema } from '@sinclair/typebox'
 
 const T = Type.Object({
   x: Type.Number(),
@@ -15,4 +15,4 @@ const T = Type.Object({
 
 type T = Static<typeof T>
 
-console.log(T)
\ No newline at end of file
+console.log(T)
diff --git a/package-lock.json b/package-lock.json
index 9128aeaa5..81dc5039e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,24 +1,24 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.1",
+  "version": "0.25.10",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.25.1",
+      "version": "0.25.10",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
         "@types/chai": "^4.3.3",
         "@types/mocha": "^9.1.1",
-        "@types/node": "^18.7.13",
-        "ajv": "^8.11.0",
+        "@types/node": "^18.11.9",
+        "ajv": "^8.11.2",
         "ajv-formats": "^2.1.1",
         "chai": "^4.3.6",
         "mocha": "^9.2.2",
         "prettier": "^2.7.1",
-        "typescript": "^4.8.2"
+        "typescript": "^4.9.3"
       }
     },
     "node_modules/@esbuild/linux-loong64": {
@@ -63,9 +63,9 @@
       "dev": true
     },
     "node_modules/@types/node": {
-      "version": "18.7.13",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.13.tgz",
-      "integrity": "sha512-46yIhxSe5xEaJZXWdIBP7GU4HDTG8/eo0qd9atdiL+lFpA03y8KS+lkTN834TWJj5767GbWv4n/P6efyTFt1Dw==",
+      "version": "18.11.9",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.11.9.tgz",
+      "integrity": "sha512-CRpX21/kGdzjOpFsZSkcrXMGIBWMGNIHXXBVFSH+ggkftxg+XYP20TESbh+zFvFj3EQOl5byk0HTRn1IL6hbqg==",
       "dev": true
     },
     "node_modules/@ungap/promise-all-settled": {
@@ -75,9 +75,9 @@
       "dev": true
     },
     "node_modules/ajv": {
-      "version": "8.11.0",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.0.tgz",
-      "integrity": "sha512-wGgprdCvMalC0BztXvitD2hC04YffAvtsUn93JbGXYLAtCUO4xd17mCCZQxUOItiBwZvJScWo8NIvQMQ71rdpg==",
+      "version": "8.11.2",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.2.tgz",
+      "integrity": "sha512-E4bfmKAhGiSTvMfL1Myyycaub+cUEU2/IvpylXkUu7CHBkBj1f/ikdzbD7YQ6FKUbixDxeYvB/xY4fvyroDlQg==",
       "dev": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
@@ -1410,9 +1410,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "4.8.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.8.2.tgz",
-      "integrity": "sha512-C0I1UsrrDHo2fYI5oaCGbSejwX4ch+9Y5jTQELvovfmFkK3HHSZJB8MSJcWLmCUBzQBchCrZ9rMRV6GuNrvGtw==",
+      "version": "4.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.3.tgz",
+      "integrity": "sha512-CIfGzTelbKNEnLpLdGFgdyKhG23CKdKgQPOBc+OUNrkJ2vr+KSzsSV5kq5iWhEQbok+quxgGzrAtGWCyU7tHnA==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -1570,9 +1570,9 @@
       "dev": true
     },
     "@types/node": {
-      "version": "18.7.13",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.13.tgz",
-      "integrity": "sha512-46yIhxSe5xEaJZXWdIBP7GU4HDTG8/eo0qd9atdiL+lFpA03y8KS+lkTN834TWJj5767GbWv4n/P6efyTFt1Dw==",
+      "version": "18.11.9",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.11.9.tgz",
+      "integrity": "sha512-CRpX21/kGdzjOpFsZSkcrXMGIBWMGNIHXXBVFSH+ggkftxg+XYP20TESbh+zFvFj3EQOl5byk0HTRn1IL6hbqg==",
       "dev": true
     },
     "@ungap/promise-all-settled": {
@@ -1582,9 +1582,9 @@
       "dev": true
     },
     "ajv": {
-      "version": "8.11.0",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.0.tgz",
-      "integrity": "sha512-wGgprdCvMalC0BztXvitD2hC04YffAvtsUn93JbGXYLAtCUO4xd17mCCZQxUOItiBwZvJScWo8NIvQMQ71rdpg==",
+      "version": "8.11.2",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.2.tgz",
+      "integrity": "sha512-E4bfmKAhGiSTvMfL1Myyycaub+cUEU2/IvpylXkUu7CHBkBj1f/ikdzbD7YQ6FKUbixDxeYvB/xY4fvyroDlQg==",
       "dev": true,
       "requires": {
         "fast-deep-equal": "^3.1.1",
@@ -2442,9 +2442,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "4.8.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.8.2.tgz",
-      "integrity": "sha512-C0I1UsrrDHo2fYI5oaCGbSejwX4ch+9Y5jTQELvovfmFkK3HHSZJB8MSJcWLmCUBzQBchCrZ9rMRV6GuNrvGtw==",
+      "version": "4.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.3.tgz",
+      "integrity": "sha512-CIfGzTelbKNEnLpLdGFgdyKhG23CKdKgQPOBc+OUNrkJ2vr+KSzsSV5kq5iWhEQbok+quxgGzrAtGWCyU7tHnA==",
       "dev": true
     },
     "uri-js": {
diff --git a/package.json b/package.json
index ab27031c1..6954d63f2 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.9",
+  "version": "0.25.10",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -39,12 +39,12 @@
     "@sinclair/hammer": "^0.17.1",
     "@types/chai": "^4.3.3",
     "@types/mocha": "^9.1.1",
-    "@types/node": "^18.7.13",
-    "ajv": "^8.11.0",
+    "@types/node": "^18.11.9",
+    "ajv": "^8.11.2",
     "ajv-formats": "^2.1.1",
     "chai": "^4.3.6",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^4.8.2"
+    "typescript": "^4.9.3"
   }
 }
diff --git a/readme.md b/readme.md
index f1a6a94c5..dbbb0b9af 100644
--- a/readme.md
+++ b/readme.md
@@ -97,8 +97,8 @@ License MIT
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
   - [TypeCompiler](#typecheck-typecompiler)
-  - [Custom](#typecheck-custom)
-  - [Formats](#typecheck-formats)
+  - [Custom Types](#typecheck-custom-types)
+  - [Custom Formats](#typecheck-custom-formats)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
   - [Validate](#benchmark-validate)
@@ -1118,11 +1118,11 @@ console.log(C.Code())                                // return function check(va
                                                      // }
 ```
 
-<a name='typecheck-custom'></a>
+<a name='typecheck-custom-types'></a>
 
-### Custom
+### Custom Types
 
-Use custom module to create a custom types. When creating a custom type you must specify a `Kind` symbol property on the types schema. The `Kind` symbol property should match the name used to register the type. Custom types are used by the Value and TypeCompiler modules only.
+Use the custom module to create user defined types. User defined types require a `[Kind]` symbol property which is used to match the schema against a registered type. Custom types are specific to TypeBox and can only be used with the TypeCompiler and Value modules.
 
 The custom module is an optional import.
 
@@ -1130,23 +1130,27 @@ The custom module is an optional import.
 import { Custom } from '@sinclair/typebox/custom'
 ```
 
-The following registers a BigInt custom type.
+The following creates a `BigInt` type.
 
 ```typescript
 import { Type, Kind } from '@sinclair/typebox'
 
-Custom.Set('BigInt', value => typeof value === 'bigint')
-
+Custom.Set('BigInt', (schema, value) => typeof value === 'bigint')
+//            │
+//            └───────────────────┐                  The [Kind] is used to match registered type
+//                                │
 const T = Type.Unsafe<bigint>({ [Kind]: 'BigInt' })  // const T = { [Kind]: 'BigInt' }
 
-const R = Value.Check(T, 65536n)                     // const R = true
+const A = TypeCompiler.Compile(T).Check(65536)       // const A = false
+
+const B = Value.Check(T, 65536n)                     // const B = true
 ```
 
-<a name='typecheck-formats'></a>
+<a name='typecheck-custom-formats'></a>
 
-### Formats
+### Custom Formats
 
-Use the format module to create user defined string formats. The format module is used by the Value and TypeCompiler modules only. If using Ajv, please refer to the official Ajv format documentation located [here](https://ajv.js.org/guide/formats.html).
+Use the format module to create user defined string formats. If using Ajv, please refer to the official Ajv format documentation located [here](https://ajv.js.org/guide/formats.html). The format module is specific to TypeBox can only be used with the TypeCompiler and Value modules.
 
 The format module is an optional import.
 
@@ -1154,7 +1158,7 @@ The format module is an optional import.
 import { Format } from '@sinclair/typebox/format'
 ```
 
-The following creates a `palindrome` string format.
+The following creates a palindrome string format.
 
 ```typescript
 Format.Set('palindrome', value => value === value.split('').reverse().join(''))
@@ -1174,7 +1178,7 @@ const B = Value.Check(T, 'kayak')                    // const B = true
 
 ## Benchmark
 
-This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.11.0. 
+This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.11.2. 
 
 For additional comparative benchmarks, please refer to [typescript-runtime-type-benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/).
 
@@ -1188,29 +1192,29 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    427 ms' │ '     13 ms' │ '   32.85 x' │
-│           String │    2000    │ '    367 ms' │ '     12 ms' │ '   30.58 x' │
-│          Boolean │    2000    │ '    297 ms' │ '     13 ms' │ '   22.85 x' │
-│             Null │    2000    │ '    255 ms' │ '      9 ms' │ '   28.33 x' │
-│            RegEx │    2000    │ '    487 ms' │ '     17 ms' │ '   28.65 x' │
-│          ObjectA │    2000    │ '   2718 ms' │ '     53 ms' │ '   51.28 x' │
-│          ObjectB │    2000    │ '   2874 ms' │ '     36 ms' │ '   79.83 x' │
-│            Tuple │    2000    │ '   1221 ms' │ '     22 ms' │ '   55.50 x' │
-│            Union │    2000    │ '   1223 ms' │ '     24 ms' │ '   50.96 x' │
-│          Vector4 │    2000    │ '   1517 ms' │ '     21 ms' │ '   72.24 x' │
+│           Number │    2000    │ '    414 ms' │ '     14 ms' │ '   29.57 x' │
+│           String │    2000    │ '    326 ms' │ '     12 ms' │ '   27.17 x' │
+│          Boolean │    2000    │ '    301 ms' │ '     11 ms' │ '   27.36 x' │
+│             Null │    2000    │ '    253 ms' │ '      8 ms' │ '   31.63 x' │
+│            RegEx │    2000    │ '    480 ms' │ '     18 ms' │ '   26.67 x' │
+│          ObjectA │    2000    │ '   2704 ms' │ '     53 ms' │ '   51.02 x' │
+│          ObjectB │    2000    │ '   2846 ms' │ '     35 ms' │ '   81.31 x' │
+│            Tuple │    2000    │ '   1244 ms' │ '     23 ms' │ '   54.09 x' │
+│            Union │    2000    │ '   1222 ms' │ '     26 ms' │ '   47.00 x' │
+│          Vector4 │    2000    │ '   1522 ms' │ '     22 ms' │ '   69.18 x' │
 │          Matrix4 │    2000    │ '    830 ms' │ '     10 ms' │ '   83.00 x' │
-│   Literal_String │    2000    │ '    334 ms' │ '      8 ms' │ '   41.75 x' │
-│   Literal_Number │    2000    │ '    357 ms' │ '      6 ms' │ '   59.50 x' │
-│  Literal_Boolean │    2000    │ '    353 ms' │ '      7 ms' │ '   50.43 x' │
-│     Array_Number │    2000    │ '    679 ms' │ '     11 ms' │ '   61.73 x' │
-│     Array_String │    2000    │ '    713 ms' │ '     10 ms' │ '   71.30 x' │
-│    Array_Boolean │    2000    │ '    710 ms' │ '      7 ms' │ '  101.43 x' │
-│    Array_ObjectA │    2000    │ '   3571 ms' │ '     35 ms' │ '  102.03 x' │
-│    Array_ObjectB │    2000    │ '   3567 ms' │ '     41 ms' │ '   87.00 x' │
-│      Array_Tuple │    2000    │ '   2083 ms' │ '     19 ms' │ '  109.63 x' │
-│      Array_Union │    2000    │ '   1559 ms' │ '     23 ms' │ '   67.78 x' │
-│    Array_Vector4 │    2000    │ '   2156 ms' │ '     19 ms' │ '  113.47 x' │
-│    Array_Matrix4 │    2000    │ '   1483 ms' │ '     13 ms' │ '  114.08 x' │
+│   Literal_String │    2000    │ '    348 ms' │ '      9 ms' │ '   38.67 x' │
+│   Literal_Number │    2000    │ '    356 ms' │ '      9 ms' │ '   39.56 x' │
+│  Literal_Boolean │    2000    │ '    353 ms' │ '      6 ms' │ '   58.83 x' │
+│     Array_Number │    2000    │ '    686 ms' │ '     11 ms' │ '   62.36 x' │
+│     Array_String │    2000    │ '    722 ms' │ '     11 ms' │ '   65.64 x' │
+│    Array_Boolean │    2000    │ '    724 ms' │ '      9 ms' │ '   80.44 x' │
+│    Array_ObjectA │    2000    │ '   3706 ms' │ '     36 ms' │ '  102.94 x' │
+│    Array_ObjectB │    2000    │ '   3678 ms' │ '     38 ms' │ '   96.79 x' │
+│      Array_Tuple │    2000    │ '   2217 ms' │ '     23 ms' │ '   96.39 x' │
+│      Array_Union │    2000    │ '   1654 ms' │ '     24 ms' │ '   68.92 x' │
+│    Array_Vector4 │    2000    │ '   2283 ms' │ '     20 ms' │ '  114.15 x' │
+│    Array_Matrix4 │    2000    │ '   1567 ms' │ '     19 ms' │ '   82.47 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1224,31 +1228,31 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  1000000   │ '     25 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
-│           String │  1000000   │ '     22 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
-│          Boolean │  1000000   │ '     21 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
-│             Null │  1000000   │ '     24 ms' │ '     21 ms' │ '      9 ms' │ '    2.33 x' │
-│            RegEx │  1000000   │ '    158 ms' │ '     46 ms' │ '     37 ms' │ '    1.24 x' │
-│          ObjectA │  1000000   │ '    566 ms' │ '     36 ms' │ '     24 ms' │ '    1.50 x' │
-│          ObjectB │  1000000   │ '   1026 ms' │ '     52 ms' │ '     40 ms' │ '    1.30 x' │
-│            Tuple │  1000000   │ '    121 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
-│            Union │  1000000   │ '    299 ms' │ '     26 ms' │ '     16 ms' │ '    1.63 x' │
-│        Recursive │  1000000   │ '   3168 ms' │ '    414 ms' │ '     97 ms' │ '    4.27 x' │
-│          Vector4 │  1000000   │ '    147 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
-│          Matrix4 │  1000000   │ '    573 ms' │ '     40 ms' │ '     29 ms' │ '    1.38 x' │
-│   Literal_String │  1000000   │ '     48 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│   Literal_Number │  1000000   │ '     46 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
-│  Literal_Boolean │  1000000   │ '     48 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
-│     Array_Number │  1000000   │ '    454 ms' │ '     32 ms' │ '     18 ms' │ '    1.78 x' │
-│     Array_String │  1000000   │ '    481 ms' │ '     32 ms' │ '     22 ms' │ '    1.45 x' │
-│    Array_Boolean │  1000000   │ '    448 ms' │ '     34 ms' │ '     27 ms' │ '    1.26 x' │
-│    Array_ObjectA │  1000000   │ '  13709 ms' │ '   2360 ms' │ '   1548 ms' │ '    1.52 x' │
-│    Array_ObjectB │  1000000   │ '  16602 ms' │ '   2585 ms' │ '   1904 ms' │ '    1.36 x' │
-│      Array_Tuple │  1000000   │ '   1831 ms' │ '     96 ms' │ '     63 ms' │ '    1.52 x' │
-│      Array_Union │  1000000   │ '   4958 ms' │ '    234 ms' │ '     86 ms' │ '    2.72 x' │
-│  Array_Recursive │  1000000   │ '  55876 ms' │ '   7160 ms' │ '   1138 ms' │ '    6.29 x' │
-│    Array_Vector4 │  1000000   │ '   2381 ms' │ '     99 ms' │ '     47 ms' │ '    2.11 x' │
-│    Array_Matrix4 │  1000000   │ '  11670 ms' │ '    383 ms' │ '    228 ms' │ '    1.68 x' │
+│           Number │  1000000   │ '     33 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
+│           String │  1000000   │ '     26 ms' │ '     24 ms' │ '     12 ms' │ '    2.00 x' │
+│          Boolean │  1000000   │ '     24 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
+│             Null │  1000000   │ '     28 ms' │ '     24 ms' │ '     11 ms' │ '    2.18 x' │
+│            RegEx │  1000000   │ '    171 ms' │ '     56 ms' │ '     41 ms' │ '    1.37 x' │
+│          ObjectA │  1000000   │ '    614 ms' │ '     42 ms' │ '     24 ms' │ '    1.75 x' │
+│          ObjectB │  1000000   │ '   1109 ms' │ '     59 ms' │ '     45 ms' │ '    1.31 x' │
+│            Tuple │  1000000   │ '    122 ms' │ '     25 ms' │ '     13 ms' │ '    1.92 x' │
+│            Union │  1000000   │ '    316 ms' │ '     26 ms' │ '     16 ms' │ '    1.63 x' │
+│        Recursive │  1000000   │ '   3219 ms' │ '    453 ms' │ '    128 ms' │ '    3.54 x' │
+│          Vector4 │  1000000   │ '    145 ms' │ '     26 ms' │ '     13 ms' │ '    2.00 x' │
+│          Matrix4 │  1000000   │ '    537 ms' │ '     42 ms' │ '     28 ms' │ '    1.50 x' │
+│   Literal_String │  1000000   │ '     51 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
+│   Literal_Number │  1000000   │ '     48 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
+│  Literal_Boolean │  1000000   │ '     49 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
+│     Array_Number │  1000000   │ '    438 ms' │ '     35 ms' │ '     19 ms' │ '    1.84 x' │
+│     Array_String │  1000000   │ '    468 ms' │ '     33 ms' │ '     23 ms' │ '    1.43 x' │
+│    Array_Boolean │  1000000   │ '    448 ms' │ '     36 ms' │ '     29 ms' │ '    1.24 x' │
+│    Array_ObjectA │  1000000   │ '  13904 ms' │ '   2536 ms' │ '   1530 ms' │ '    1.66 x' │
+│    Array_ObjectB │  1000000   │ '  16188 ms' │ '   2724 ms' │ '   1834 ms' │ '    1.49 x' │
+│      Array_Tuple │  1000000   │ '   1725 ms' │ '     98 ms' │ '     64 ms' │ '    1.53 x' │
+│      Array_Union │  1000000   │ '   4762 ms' │ '    237 ms' │ '     87 ms' │ '    2.72 x' │
+│  Array_Recursive │  1000000   │ '  54754 ms' │ '   7707 ms' │ '   1152 ms' │ '    6.69 x' │
+│    Array_Vector4 │  1000000   │ '   2485 ms' │ '    100 ms' │ '     48 ms' │ '    2.08 x' │
+│    Array_Matrix4 │  1000000   │ '  13116 ms' │ '    387 ms' │ '    232 ms' │ '    1.67 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1262,12 +1266,12 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '   55 kb' │ '   27 kb' │  '2.00 x'   │
+│ typebox/compiler     │ '   56 kb' │ '   28 kb' │  '2.01 x'   │
 │ typebox/conditional  │ '   45 kb' │ '   18 kb' │  '2.44 x'   │
 │ typebox/custom       │ '    0 kb' │ '    0 kb' │  '2.61 x'   │
 │ typebox/format       │ '    0 kb' │ '    0 kb' │  '2.66 x'   │
 │ typebox/guard        │ '   23 kb' │ '   11 kb' │  '2.07 x'   │
-│ typebox/value        │ '   80 kb' │ '   37 kb' │  '2.15 x'   │
+│ typebox/value        │ '   80 kb' │ '   37 kb' │  '2.16 x'   │
 │ typebox              │ '   12 kb' │ '    6 kb' │  '1.89 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 04d0d2bce..0164c7c3a 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -233,9 +233,9 @@ export namespace TypeCompiler {
     // Reference: If we have seen this reference before we can just yield and return
     // the function call. If this isn't the case we defer to visit to generate and
     // set the function for subsequent passes. Consider for refactor.
-    if (names.has(schema.$ref)) return yield `(${CreateFunctionName(schema.$ref)}(${value}))`
-    if (!referenceMap.has(schema.$ref)) throw Error(`TypeCompiler.Ref: Cannot de-reference schema with $id '${schema.$ref}'`)
-    const reference = referenceMap.get(schema.$ref)!
+    if (state_local_function_names.has(schema.$ref)) return yield `(${CreateFunctionName(schema.$ref)}(${value}))`
+    if (!state_reference_map.has(schema.$ref)) throw Error(`TypeCompiler.Ref: Cannot de-reference schema with $id '${schema.$ref}'`)
+    const reference = state_reference_map.get(schema.$ref)!
     yield* Visit(reference, value)
   }
 
@@ -290,16 +290,18 @@ export namespace TypeCompiler {
     yield `(${value} === null)`
   }
 
-  function* Kind(schema: Types.TSchema, value: string): IterableIterator<string> {
-    yield `(custom('${schema[Types.Kind]}', ${value}))`
+  function* UserDefined(schema: Types.TSchema, value: string): IterableIterator<string> {
+    const schema_key = `schema_key_${state_remote_custom_types.size}`
+    state_remote_custom_types.set(schema_key, schema)
+    yield `(custom('${schema[Types.Kind]}', '${schema_key}', ${value}))`
   }
 
   function* Visit<T extends Types.TSchema>(schema: T, value: string): IterableIterator<string> {
     // Reference: Referenced schemas can originate from either additional schemas
     // or inline in the schema itself. Ideally the recursive path should align to
     // reference path. Consider for refactor.
-    if (schema.$id && !names.has(schema.$id)) {
-      names.add(schema.$id)
+    if (schema.$id && !state_local_function_names.has(schema.$id)) {
+      state_local_function_names.add(schema.$id)
       const name = CreateFunctionName(schema.$id)
       const body = CreateFunction(name, schema, 'value')
       PushFunction(body)
@@ -356,29 +358,31 @@ export namespace TypeCompiler {
         return yield* Void(anySchema, value)
       default:
         if (!Custom.Has(anySchema[Types.Kind])) throw new TypeCompilerUnknownTypeError(schema)
-        return yield* Kind(anySchema, value)
+        return yield* UserDefined(anySchema, value)
     }
   }
 
   // -------------------------------------------------------------------
-  // Compile State
+  // Compiler State
   // -------------------------------------------------------------------
 
-  const referenceMap = new Map<string, Types.TSchema>()
-  const locals = new Set<string>() // local variables and functions
-  const names = new Set<string>() // cache of local functions
+  const state_reference_map = new Map<string, Types.TSchema>() // tracks schemas with identifiers
+  const state_local_variables = new Set<string>() // local variables and functions
+  const state_local_function_names = new Set<string>() // local function names used call ref validators
+  const state_remote_custom_types = new Map<string, unknown>() // remote custom types used during compilation
 
   function ResetCompiler() {
-    referenceMap.clear()
-    locals.clear()
-    names.clear()
+    state_reference_map.clear()
+    state_local_variables.clear()
+    state_local_function_names.clear()
+    state_remote_custom_types.clear()
   }
 
   function AddReferences(schemas: Types.TSchema[] = []) {
     for (const schema of schemas) {
       if (!schema.$id) throw new Error(`TypeCompiler: Referenced schemas must specify an $id.`)
-      if (referenceMap.has(schema.$id)) throw new Error(`TypeCompiler: Duplicate schema $id found for '${schema.$id}'`)
-      referenceMap.set(schema.$id, schema)
+      if (state_reference_map.has(schema.$id)) throw new Error(`TypeCompiler: Duplicate schema $id found for '${schema.$id}'`)
+      state_reference_map.set(schema.$id, schema)
     }
   }
 
@@ -396,17 +400,17 @@ export namespace TypeCompiler {
   }
 
   function PushFunction(functionBody: string) {
-    locals.add(functionBody)
+    state_local_variables.add(functionBody)
   }
 
   function PushLocal(expression: string) {
-    const local = `local_${locals.size}`
-    locals.add(`const ${local} = ${expression}`)
+    const local = `local_${state_local_variables.size}`
+    state_local_variables.add(`const ${local} = ${expression}`)
     return local
   }
 
   function GetLocals() {
-    return [...locals.values()]
+    return [...state_local_variables.values()]
   }
 
   // -------------------------------------------------------------------
@@ -425,12 +429,14 @@ export namespace TypeCompiler {
   export function Compile<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []): TypeCheck<T> {
     TypeGuard.Assert(schema, references)
     const code = Build(schema, references)
+    const custom_schemas = new Map(state_remote_custom_types)
     const compiledFunction = globalThis.Function('custom', 'format', code)
     const checkFunction = compiledFunction(
-      (kind: string, value: unknown) => {
-        if (!Custom.Has(kind)) return false
+      (kind: string, schema_key: string, value: unknown) => {
+        if (!Custom.Has(kind) || !custom_schemas.has(schema_key)) return false
+        const schema = custom_schemas.get(schema_key)!
         const func = Custom.Get(kind)!
-        return func(value)
+        return func(schema, value)
       },
       (format: string, value: string) => {
         if (!Format.Has(format)) return false
diff --git a/src/conditional/structural.ts b/src/conditional/structural.ts
index 2f0465091..323c761ab 100644
--- a/src/conditional/structural.ts
+++ b/src/conditional/structural.ts
@@ -56,7 +56,7 @@ export namespace Structural {
     if (TypeGuard.TUnion(right) && right.anyOf.some((schema: Types.TSchema) => schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown')) return true
     if (TypeGuard.TUnknown(right)) return true
     if (TypeGuard.TAny(right)) return true
-    if (TypeGuard.TCustom(right)) throw Error(`Structural: Cannot structurally compare custom type '${right[Types.Kind]}'`)
+    if (TypeGuard.TUserDefined(right)) throw Error(`Structural: Cannot structurally compare custom type '${right[Types.Kind]}'`)
     return false
   }
 
@@ -563,7 +563,7 @@ export namespace Structural {
       return Unknown(left, resolvedRight)
     } else if (TypeGuard.TVoid(left)) {
       return Void(left, resolvedRight)
-    } else if (TypeGuard.TCustom(left)) {
+    } else if (TypeGuard.TUserDefined(left)) {
       throw Error(`Structural: Cannot structurally compare custom type '${left[Types.Kind]}'`)
     } else {
       throw Error(`Structural: Unknown left operand '${left[Types.Kind]}'`)
diff --git a/src/custom/custom.ts b/src/custom/custom.ts
index 0f9128581..3dfc8ae8f 100644
--- a/src/custom/custom.ts
+++ b/src/custom/custom.ts
@@ -26,28 +26,28 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export type CustomValidationFunction = (value: unknown) => boolean
+export type CustomValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean
 
-/** Provides functions to create custom types */
+/** Provides functions to create user defined types */
 export namespace Custom {
-  const customs = new Map<string, CustomValidationFunction>()
+  const customs = new Map<string, CustomValidationFunction<any>>()
 
-  /** Clears all custom types */
+  /** Clears all user defined types */
   export function Clear() {
     return customs.clear()
   }
 
-  /** Returns true if this kind exists */
+  /** Returns true if this user defined type exists */
   export function Has(kind: string) {
     return customs.has(kind)
   }
 
-  /** Sets a validation function for a custom kind */
-  export function Set(kind: string, func: CustomValidationFunction) {
+  /** Sets a validation function for a user defined type */
+  export function Set<TSchema = unknown>(kind: string, func: CustomValidationFunction<TSchema>) {
     customs.set(kind, func)
   }
 
-  /** Gets a custom validation function */
+  /** Gets a custom validation function for a user defined type */
   export function Get(kind: string) {
     return customs.get(kind)
   }
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index f2cd2d00e..f6f7cb159 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -396,9 +396,9 @@ export namespace ValueErrors {
     }
   }
 
-  function* CustomType(schema: Types.TSchema, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  function* UserDefined(schema: Types.TSchema, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     const func = Custom.Get(schema[Types.Kind])!
-    if (!func(value)) {
+    if (!func(schema, value)) {
       return yield { type: ValueErrorType.Custom, schema, path, value, message: `Expected kind ${schema[Types.Kind]}` }
     }
   }
@@ -455,7 +455,7 @@ export namespace ValueErrors {
         return yield* Void(anySchema, anyReferences, path, value)
       default:
         if (!Custom.Has(anySchema[Types.Kind])) throw new ValueErrorsUnknownTypeError(schema)
-        return yield* CustomType(anySchema, anyReferences, path, value)
+        return yield* UserDefined(anySchema, anyReferences, path, value)
     }
   }
 
diff --git a/src/format/format.ts b/src/format/format.ts
index 544009a7f..c185ab00b 100644
--- a/src/format/format.ts
+++ b/src/format/format.ts
@@ -28,26 +28,26 @@ THE SOFTWARE.
 
 export type FormatValidationFunction = (value: string) => boolean
 
-/** Provides functions to create custom string formats */
+/** Provides functions to create user defined string formats */
 export namespace Format {
   const formats = new Map<string, FormatValidationFunction>()
 
-  /** Clears all formats */
+  /** Clears all user defined string formats */
   export function Clear() {
     return formats.clear()
   }
 
-  /** Returns true if the string format exists */
+  /** Returns true if the user defined string format exists */
   export function Has(format: string) {
     return formats.has(format)
   }
 
-  /** Sets a string format validation function */
+  /** Sets a validation function for a user defined string format */
   export function Set(format: string, func: FormatValidationFunction) {
     formats.set(format, func)
   }
 
-  /** Gets a string format validation function */
+  /** Gets a validation function for a user defined string format */
   export function Get(format: string) {
     return formats.get(format)
   }
diff --git a/src/guard/guard.ts b/src/guard/guard.ts
index 429e908cb..c6904f0b6 100644
--- a/src/guard/guard.ts
+++ b/src/guard/guard.ts
@@ -442,8 +442,8 @@ export namespace TypeGuard {
     )
   }
 
-  /** Returns true if the given schema is a registered custom type */
-  export function TCustom(schema: unknown): schema is Types.TSchema {
+  /** Returns true if the given schema is a registered user defined type */
+  export function TUserDefined(schema: unknown): schema is Types.TSchema {
     return IsObject(schema) && IsString(schema[Types.Kind]) && Custom.Has(schema[Types.Kind])
   }
 
@@ -473,7 +473,7 @@ export namespace TypeGuard {
       TUint8Array(schema) ||
       TUnknown(schema) ||
       TVoid(schema) ||
-      TCustom(schema)
+      TUserDefined(schema)
     )
   }
 
diff --git a/src/value/cast.ts b/src/value/cast.ts
index 094cbfd5c..17d72e375 100644
--- a/src/value/cast.ts
+++ b/src/value/cast.ts
@@ -323,7 +323,7 @@ export namespace ValueCast {
     return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
 
-  function Kind(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
+  function UserDefined(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
 
@@ -381,7 +381,7 @@ export namespace ValueCast {
         return Void(anySchema, anyReferences, value)
       default:
         if (!Custom.Has(anySchema[Types.Kind])) throw new ValueCastUnknownTypeError(anySchema)
-        return Kind(anySchema, anyReferences, value)
+        return UserDefined(anySchema, anyReferences, value)
     }
   }
 
diff --git a/src/value/check.ts b/src/value/check.ts
index 7c7c8bef9..16fe2ad8e 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -32,7 +32,7 @@ import { Custom } from '../custom/index'
 
 export class ValueCheckUnknownTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
-    super('ValueCheck: Unknown type')
+    super(`ValueCheck: ${schema[Types.Kind] ? `Unknown type '${schema[Types.Kind]}'` : 'Unknown type'}`)
   }
 }
 
@@ -298,10 +298,10 @@ export namespace ValueCheck {
     return value === null
   }
 
-  function Kind(schema: Types.TSchema, references: Types.TSchema[], value: unknown): boolean {
+  function UserDefined(schema: Types.TSchema, references: Types.TSchema[], value: unknown): boolean {
     if (!Custom.Has(schema[Types.Kind])) return false
     const func = Custom.Get(schema[Types.Kind])!
-    return func(value)
+    return func(schema, value)
   }
 
   function Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): boolean {
@@ -356,7 +356,7 @@ export namespace ValueCheck {
         return Void(anySchema, anyReferences, value)
       default:
         if (!Custom.Has(anySchema[Types.Kind])) throw new ValueCheckUnknownTypeError(anySchema)
-        return Kind(anySchema, anyReferences, value)
+        return UserDefined(anySchema, anyReferences, value)
     }
   }
 
diff --git a/src/value/create.ts b/src/value/create.ts
index ad67b771d..ab4d33ad0 100644
--- a/src/value/create.ts
+++ b/src/value/create.ts
@@ -278,11 +278,11 @@ export namespace ValueCreate {
     return null
   }
 
-  function Kind(schema: Types.TSchema, references: Types.TSchema[]): any {
+  function UserDefined(schema: Types.TSchema, references: Types.TSchema[]): any {
     if (schema.default !== undefined) {
       return schema.default
     } else {
-      throw new Error('ValueCreate.Kind: Custom types must specify a default value')
+      throw new Error('ValueCreate.UserDefined: User defined types must specify a default value')
     }
   }
 
@@ -342,7 +342,7 @@ export namespace ValueCreate {
         return Void(anySchema, anyReferences)
       default:
         if (!Custom.Has(anySchema[Types.Kind])) throw new ValueCreateUnknownTypeError(anySchema)
-        return Kind(anySchema, anyReferences)
+        return UserDefined(anySchema, anyReferences)
     }
   }
 
diff --git a/test/runtime/compiler/custom.ts b/test/runtime/compiler/custom.ts
index 14ef55e66..1a42cdd8c 100644
--- a/test/runtime/compiler/custom.ts
+++ b/test/runtime/compiler/custom.ts
@@ -3,7 +3,7 @@ import { Type, Kind } from '@sinclair/typebox'
 import { ok, fail } from './validate'
 
 describe('type/compiler/Custom', () => {
-  Custom.Set('BigInt', (value) => typeof value === 'bigint')
+  Custom.Set('BigInt', (schema, value) => typeof value === 'bigint')
 
   it('Should validate bigint', () => {
     const T = Type.Unsafe({ [Kind]: 'BigInt' })
diff --git a/test/runtime/value/cast/custom.ts b/test/runtime/value/cast/custom.ts
index ceb931198..cbdd0085e 100644
--- a/test/runtime/value/cast/custom.ts
+++ b/test/runtime/value/cast/custom.ts
@@ -4,7 +4,7 @@ import { Type, Kind } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/cast/Custom', () => {
-  Custom.Set('CustomCast', (value) => value === 'hello' || value === 'world')
+  Custom.Set('CustomCast', (schema, value) => value === 'hello' || value === 'world')
   const T = Type.Unsafe({ [Kind]: 'CustomCast', default: 'hello' })
   const E = 'hello'
 
diff --git a/test/runtime/value/check/custom.ts b/test/runtime/value/check/custom.ts
index 026b64e60..8518802fd 100644
--- a/test/runtime/value/check/custom.ts
+++ b/test/runtime/value/check/custom.ts
@@ -4,21 +4,25 @@ import { Type, Kind } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/check/Custom', () => {
-  Custom.Set('BigInt', (value) => typeof value === 'bigint')
+  Custom.Set('BigInt', (schema, value) => typeof value === 'bigint')
+
   it('Should validate bigint', () => {
     const T = Type.Unsafe({ [Kind]: 'BigInt' })
     Assert.deepEqual(Value.Check(T, 1n), true)
   })
+
   it('Should not validate bigint', () => {
     const T = Type.Unsafe({ [Kind]: 'BigInt' })
     Assert.deepEqual(Value.Check(T, 1), false)
   })
+
   it('Should validate bigint nested', () => {
     const T = Type.Object({
       x: Type.Unsafe({ [Kind]: 'BigInt' }),
     })
     Assert.deepEqual(Value.Check(T, { x: 1n }), true)
   })
+
   it('Should not validate bigint nested', () => {
     const T = Type.Object({
       x: Type.Unsafe({ [Kind]: 'BigInt' }),
diff --git a/test/runtime/value/create/custom.ts b/test/runtime/value/create/custom.ts
index 2703379fc..90ca03152 100644
--- a/test/runtime/value/create/custom.ts
+++ b/test/runtime/value/create/custom.ts
@@ -5,13 +5,13 @@ import { Assert } from '../../assert/index'
 
 describe('value/create/Custom', () => {
   it('Should create custom value with default', () => {
-    Custom.Set('CustomCreate1', (value) => true)
+    Custom.Set('CustomCreate1', () => true)
     const T = Type.Unsafe({ [Kind]: 'CustomCreate1', default: 'hello' })
     Assert.deepEqual(Value.Create(T), 'hello')
   })
 
   it('Should throw when no default value is specified', () => {
-    Custom.Set('CustomCreate2', (value) => true)
+    Custom.Set('CustomCreate2', () => true)
     const T = Type.Unsafe({ [Kind]: 'CustomCreate2' })
     Assert.throws(() => Value.Create(T))
   })

From a7f2d536f5397ecd502b837b1eb16ca262162d77 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Fri, 25 Nov 2022 14:43:42 +0900
Subject: [PATCH 039/369] Documentation

---
 readme.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/readme.md b/readme.md
index dbbb0b9af..0d4b885df 100644
--- a/readme.md
+++ b/readme.md
@@ -1137,8 +1137,8 @@ import { Type, Kind } from '@sinclair/typebox'
 
 Custom.Set('BigInt', (schema, value) => typeof value === 'bigint')
 //            │
-//            └───────────────────┐                  The [Kind] is used to match registered type
-//                                │
+//            └────────────────────────────┐         The [Kind] is used to match registered type
+//                                         │
 const T = Type.Unsafe<bigint>({ [Kind]: 'BigInt' })  // const T = { [Kind]: 'BigInt' }
 
 const A = TypeCompiler.Compile(T).Check(65536)       // const A = false

From 6407167c24d18555872715fb4fc12f53b3085bdb Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Fri, 25 Nov 2022 14:48:31 +0900
Subject: [PATCH 040/369] Changelog

---
 changelog.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/changelog.md b/changelog.md
index d8ffa70a0..e07572ea2 100644
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,9 @@
+## [0.25.10](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.10)
+
+Updates:
+
+- [283](https://github.com/sinclairzx81/typebox/pull/283) Updates the custom type validator callback signature to accept a schema instance which may include additional constraints (such as options) that may be used in the validation process. `Custom.Set('<Kind>', (schema, value) => { ... })`.
+
 ## [0.25.9](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.9)
 
 Updates:

From a77d13616718d1e8fd9f30ccd8ece9be5b1aac35 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Fri, 25 Nov 2022 14:48:34 +0900
Subject: [PATCH 041/369] Changelog

---
 changelog.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/changelog.md b/changelog.md
index e07572ea2..bd34becd7 100644
--- a/changelog.md
+++ b/changelog.md
@@ -2,7 +2,7 @@
 
 Updates:
 
-- [283](https://github.com/sinclairzx81/typebox/pull/283) Updates the custom type validator callback signature to accept a schema instance which may include additional constraints (such as options) that may be used in the validation process. `Custom.Set('<Kind>', (schema, value) => { ... })`.
+- [283](https://github.com/sinclairzx81/typebox/pull/283) Updates the custom type validator callback signature to accept a schema instance. The schema instance may include additional constraints (such as options) that may be used during the validation process. `Custom.Set('<Kind>', (schema, value) => { ... })`.
 
 ## [0.25.9](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.9)
 

From c465464ea03d49d25a3cbbe02708e20548304f3d Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 7 Dec 2022 02:54:58 +0900
Subject: [PATCH 042/369] Value Hash (#286)

---
 benchmark/compression/module/typebox-hash.ts |   3 +
 changelog.md                                 |   6 +
 example/index.ts                             |   2 +-
 package.json                                 |   3 +-
 readme.md                                    | 114 ++++++-----
 src/compiler/compiler.ts                     |  10 +-
 src/errors/errors.ts                         |   4 +-
 src/hash/hash.ts                             | 193 +++++++++++++++++++
 src/hash/index.ts                            |  29 +++
 src/tsconfig.json                            |   2 +-
 src/value/check.ts                           |   5 +-
 src/value/index.ts                           |   1 +
 src/value/value.ts                           |  18 +-
 test/runtime/compiler/array.ts               |  11 +-
 test/runtime/hash/hash.ts                    |  94 +++++++++
 test/runtime/hash/index.ts                   |   1 +
 test/runtime/index.ts                        |   1 +
 test/runtime/schema/array.ts                 |  11 +-
 test/runtime/value/check/array.ts            |  33 ++++
 tsconfig.json                                |   3 +
 20 files changed, 475 insertions(+), 69 deletions(-)
 create mode 100644 benchmark/compression/module/typebox-hash.ts
 create mode 100644 src/hash/hash.ts
 create mode 100644 src/hash/index.ts
 create mode 100644 test/runtime/hash/hash.ts
 create mode 100644 test/runtime/hash/index.ts

diff --git a/benchmark/compression/module/typebox-hash.ts b/benchmark/compression/module/typebox-hash.ts
new file mode 100644
index 000000000..94c5787e1
--- /dev/null
+++ b/benchmark/compression/module/typebox-hash.ts
@@ -0,0 +1,3 @@
+import { ValueHash } from '@sinclair/typebox/hash'
+
+const H = ValueHash.Create(1)
diff --git a/changelog.md b/changelog.md
index bd34becd7..8ab7ca510 100644
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,9 @@
+## [0.25.11](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.11)
+
+Updates:
+
+- [286](https://github.com/sinclairzx81/typebox/pull/286) implements a FNV1A-64 non cryptographic hashing function in TypeBox. This function should not be used in place of cryptographic hashing functions, rather it's purpose is to provide relatively fast, hashing mechanism to assist with checks for arrays with uniqueItems constraints, specifically for cases where the array may contains reference values (such as objects, arrays, Dates and Uint8Array). This function is provided via `Value.Hash()` for convenience as the hash may be useful to generate a numeric identifier for values (with some considerations to React array rendering in absence of key or identifier)
+
 ## [0.25.10](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.10)
 
 Updates:
diff --git a/example/index.ts b/example/index.ts
index dfde052cf..dee703c07 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -15,4 +15,4 @@ const T = Type.Object({
 
 type T = Static<typeof T>
 
-console.log(T)
+console.log(T)
\ No newline at end of file
diff --git a/package.json b/package.json
index 6954d63f2..31deefffa 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.10",
+  "version": "0.25.11",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -19,6 +19,7 @@
     "./errors": "./errors/index.js",
     "./format": "./format/index.js",
     "./guard": "./guard/index.js",
+    "./hash": "./hash/index.js",
     "./value": "./value/index.js",
     ".": "./typebox.js"
   },
diff --git a/readme.md b/readme.md
index 0d4b885df..660ae6100 100644
--- a/readme.md
+++ b/readme.md
@@ -90,6 +90,7 @@ License MIT
   - [Check](#values-check)
   - [Cast](#values-cast)
   - [Equal](#values-equal)
+  - [Hash](#values-hash)
   - [Diff](#values-diff)
   - [Patch](#values-patch)
   - [Errors](#values-errors)
@@ -843,6 +844,18 @@ const R = Value.Equal(                               // const R = true
 )
 ```
 
+<a name='values-hash'></a>
+
+### Hash
+
+Use the Hash function to create a [FNV1A-64](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function) non cryptographic hash of a value.
+
+```typescript
+const A = Value.Hash({ x: 1, y: 2, z: 3 })          // const A = 2910466848807138541n
+
+const B = Value.Hash({ x: 1, y: 4, z: 3 })          // const B = 1418369778807423581n
+```
+
 <a name='values-diff'></a>
 
 ### Diff
@@ -1192,29 +1205,29 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    414 ms' │ '     14 ms' │ '   29.57 x' │
-│           String │    2000    │ '    326 ms' │ '     12 ms' │ '   27.17 x' │
-│          Boolean │    2000    │ '    301 ms' │ '     11 ms' │ '   27.36 x' │
-│             Null │    2000    │ '    253 ms' │ '      8 ms' │ '   31.63 x' │
-│            RegEx │    2000    │ '    480 ms' │ '     18 ms' │ '   26.67 x' │
-│          ObjectA │    2000    │ '   2704 ms' │ '     53 ms' │ '   51.02 x' │
-│          ObjectB │    2000    │ '   2846 ms' │ '     35 ms' │ '   81.31 x' │
-│            Tuple │    2000    │ '   1244 ms' │ '     23 ms' │ '   54.09 x' │
-│            Union │    2000    │ '   1222 ms' │ '     26 ms' │ '   47.00 x' │
-│          Vector4 │    2000    │ '   1522 ms' │ '     22 ms' │ '   69.18 x' │
-│          Matrix4 │    2000    │ '    830 ms' │ '     10 ms' │ '   83.00 x' │
-│   Literal_String │    2000    │ '    348 ms' │ '      9 ms' │ '   38.67 x' │
-│   Literal_Number │    2000    │ '    356 ms' │ '      9 ms' │ '   39.56 x' │
-│  Literal_Boolean │    2000    │ '    353 ms' │ '      6 ms' │ '   58.83 x' │
-│     Array_Number │    2000    │ '    686 ms' │ '     11 ms' │ '   62.36 x' │
-│     Array_String │    2000    │ '    722 ms' │ '     11 ms' │ '   65.64 x' │
-│    Array_Boolean │    2000    │ '    724 ms' │ '      9 ms' │ '   80.44 x' │
-│    Array_ObjectA │    2000    │ '   3706 ms' │ '     36 ms' │ '  102.94 x' │
-│    Array_ObjectB │    2000    │ '   3678 ms' │ '     38 ms' │ '   96.79 x' │
-│      Array_Tuple │    2000    │ '   2217 ms' │ '     23 ms' │ '   96.39 x' │
-│      Array_Union │    2000    │ '   1654 ms' │ '     24 ms' │ '   68.92 x' │
-│    Array_Vector4 │    2000    │ '   2283 ms' │ '     20 ms' │ '  114.15 x' │
-│    Array_Matrix4 │    2000    │ '   1567 ms' │ '     19 ms' │ '   82.47 x' │
+│           Number │    2000    │ '    415 ms' │ '     14 ms' │ '   29.64 x' │
+│           String │    2000    │ '    335 ms' │ '     12 ms' │ '   27.92 x' │
+│          Boolean │    2000    │ '    295 ms' │ '     13 ms' │ '   22.69 x' │
+│             Null │    2000    │ '    255 ms' │ '      8 ms' │ '   31.88 x' │
+│            RegEx │    2000    │ '    482 ms' │ '     17 ms' │ '   28.35 x' │
+│          ObjectA │    2000    │ '   2700 ms' │ '     55 ms' │ '   49.09 x' │
+│          ObjectB │    2000    │ '   2871 ms' │ '     36 ms' │ '   79.75 x' │
+│            Tuple │    2000    │ '   1229 ms' │ '     22 ms' │ '   55.86 x' │
+│            Union │    2000    │ '   1216 ms' │ '     26 ms' │ '   46.77 x' │
+│          Vector4 │    2000    │ '   1575 ms' │ '     25 ms' │ '   63.00 x' │
+│          Matrix4 │    2000    │ '    908 ms' │ '     13 ms' │ '   69.85 x' │
+│   Literal_String │    2000    │ '    353 ms' │ '      9 ms' │ '   39.22 x' │
+│   Literal_Number │    2000    │ '    371 ms' │ '      7 ms' │ '   53.00 x' │
+│  Literal_Boolean │    2000    │ '    361 ms' │ '      8 ms' │ '   45.13 x' │
+│     Array_Number │    2000    │ '    694 ms' │ '      7 ms' │ '   99.14 x' │
+│     Array_String │    2000    │ '    778 ms' │ '      8 ms' │ '   97.25 x' │
+│    Array_Boolean │    2000    │ '    735 ms' │ '      7 ms' │ '  105.00 x' │
+│    Array_ObjectA │    2000    │ '   3732 ms' │ '     44 ms' │ '   84.82 x' │
+│    Array_ObjectB │    2000    │ '   3624 ms' │ '     40 ms' │ '   90.60 x' │
+│      Array_Tuple │    2000    │ '   2101 ms' │ '     15 ms' │ '  140.07 x' │
+│      Array_Union │    2000    │ '   1480 ms' │ '     25 ms' │ '   59.20 x' │
+│    Array_Vector4 │    2000    │ '   2175 ms' │ '     18 ms' │ '  120.83 x' │
+│    Array_Matrix4 │    2000    │ '   1516 ms' │ '     13 ms' │ '  116.62 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1228,31 +1241,31 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  1000000   │ '     33 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
-│           String │  1000000   │ '     26 ms' │ '     24 ms' │ '     12 ms' │ '    2.00 x' │
-│          Boolean │  1000000   │ '     24 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
-│             Null │  1000000   │ '     28 ms' │ '     24 ms' │ '     11 ms' │ '    2.18 x' │
-│            RegEx │  1000000   │ '    171 ms' │ '     56 ms' │ '     41 ms' │ '    1.37 x' │
-│          ObjectA │  1000000   │ '    614 ms' │ '     42 ms' │ '     24 ms' │ '    1.75 x' │
-│          ObjectB │  1000000   │ '   1109 ms' │ '     59 ms' │ '     45 ms' │ '    1.31 x' │
-│            Tuple │  1000000   │ '    122 ms' │ '     25 ms' │ '     13 ms' │ '    1.92 x' │
-│            Union │  1000000   │ '    316 ms' │ '     26 ms' │ '     16 ms' │ '    1.63 x' │
-│        Recursive │  1000000   │ '   3219 ms' │ '    453 ms' │ '    128 ms' │ '    3.54 x' │
-│          Vector4 │  1000000   │ '    145 ms' │ '     26 ms' │ '     13 ms' │ '    2.00 x' │
-│          Matrix4 │  1000000   │ '    537 ms' │ '     42 ms' │ '     28 ms' │ '    1.50 x' │
-│   Literal_String │  1000000   │ '     51 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
-│   Literal_Number │  1000000   │ '     48 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
-│  Literal_Boolean │  1000000   │ '     49 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
-│     Array_Number │  1000000   │ '    438 ms' │ '     35 ms' │ '     19 ms' │ '    1.84 x' │
-│     Array_String │  1000000   │ '    468 ms' │ '     33 ms' │ '     23 ms' │ '    1.43 x' │
-│    Array_Boolean │  1000000   │ '    448 ms' │ '     36 ms' │ '     29 ms' │ '    1.24 x' │
-│    Array_ObjectA │  1000000   │ '  13904 ms' │ '   2536 ms' │ '   1530 ms' │ '    1.66 x' │
-│    Array_ObjectB │  1000000   │ '  16188 ms' │ '   2724 ms' │ '   1834 ms' │ '    1.49 x' │
-│      Array_Tuple │  1000000   │ '   1725 ms' │ '     98 ms' │ '     64 ms' │ '    1.53 x' │
-│      Array_Union │  1000000   │ '   4762 ms' │ '    237 ms' │ '     87 ms' │ '    2.72 x' │
-│  Array_Recursive │  1000000   │ '  54754 ms' │ '   7707 ms' │ '   1152 ms' │ '    6.69 x' │
-│    Array_Vector4 │  1000000   │ '   2485 ms' │ '    100 ms' │ '     48 ms' │ '    2.08 x' │
-│    Array_Matrix4 │  1000000   │ '  13116 ms' │ '    387 ms' │ '    232 ms' │ '    1.67 x' │
+│           Number │  1000000   │ '     28 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
+│           String │  1000000   │ '     22 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
+│          Boolean │  1000000   │ '     22 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
+│             Null │  1000000   │ '     25 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
+│            RegEx │  1000000   │ '    167 ms' │ '     48 ms' │ '     38 ms' │ '    1.26 x' │
+│          ObjectA │  1000000   │ '    591 ms' │ '     36 ms' │ '     22 ms' │ '    1.64 x' │
+│          ObjectB │  1000000   │ '   1168 ms' │ '     61 ms' │ '     37 ms' │ '    1.65 x' │
+│            Tuple │  1000000   │ '    127 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
+│            Union │  1000000   │ '    340 ms' │ '     26 ms' │ '     16 ms' │ '    1.63 x' │
+│        Recursive │  1000000   │ '   3174 ms' │ '    432 ms' │ '    100 ms' │ '    4.32 x' │
+│          Vector4 │  1000000   │ '    142 ms' │ '     24 ms' │ '     12 ms' │ '    2.00 x' │
+│          Matrix4 │  1000000   │ '    577 ms' │ '     40 ms' │ '     28 ms' │ '    1.43 x' │
+│   Literal_String │  1000000   │ '     47 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│   Literal_Number │  1000000   │ '     47 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
+│  Literal_Boolean │  1000000   │ '     45 ms' │ '     19 ms' │ '     11 ms' │ '    1.73 x' │
+│     Array_Number │  1000000   │ '    432 ms' │ '     33 ms' │ '     19 ms' │ '    1.74 x' │
+│     Array_String │  1000000   │ '    462 ms' │ '     32 ms' │ '     22 ms' │ '    1.45 x' │
+│    Array_Boolean │  1000000   │ '    455 ms' │ '     32 ms' │ '     26 ms' │ '    1.23 x' │
+│    Array_ObjectA │  1000000   │ '  14595 ms' │ '   2306 ms' │ '   1496 ms' │ '    1.54 x' │
+│    Array_ObjectB │  1000000   │ '  17310 ms' │ '   2625 ms' │ '   2105 ms' │ '    1.25 x' │
+│      Array_Tuple │  1000000   │ '   1794 ms' │ '     97 ms' │ '     66 ms' │ '    1.47 x' │
+│      Array_Union │  1000000   │ '   5085 ms' │ '    246 ms' │ '     91 ms' │ '    2.70 x' │
+│  Array_Recursive │  1000000   │ '  59747 ms' │ '   7866 ms' │ '   1136 ms' │ '    6.92 x' │
+│    Array_Vector4 │  1000000   │ '   2375 ms' │ '     99 ms' │ '     48 ms' │ '    2.06 x' │
+│    Array_Matrix4 │  1000000   │ '  13115 ms' │ '    385 ms' │ '    246 ms' │ '    1.57 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1266,12 +1279,13 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '   56 kb' │ '   28 kb' │  '2.01 x'   │
+│ typebox/compiler     │ '   61 kb' │ '   30 kb' │  '2.03 x'   │
 │ typebox/conditional  │ '   45 kb' │ '   18 kb' │  '2.44 x'   │
 │ typebox/custom       │ '    0 kb' │ '    0 kb' │  '2.61 x'   │
 │ typebox/format       │ '    0 kb' │ '    0 kb' │  '2.66 x'   │
 │ typebox/guard        │ '   23 kb' │ '   11 kb' │  '2.07 x'   │
-│ typebox/value        │ '   80 kb' │ '   37 kb' │  '2.16 x'   │
+│ typebox/hash         │ '    4 kb' │ '    1 kb' │  '2.27 x'   │
+│ typebox/value        │ '   85 kb' │ '   39 kb' │  '2.16 x'   │
 │ typebox              │ '   12 kb' │ '    6 kb' │  '1.89 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 0164c7c3a..011e12d45 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -30,6 +30,7 @@ import { ValueErrors, ValueError } from '../errors/index'
 import { TypeGuard } from '../guard/index'
 import { Format } from '../format/index'
 import { Custom } from '../custom/index'
+import { ValueHash } from '../hash/index'
 import * as Types from '../typebox'
 
 // -------------------------------------------------------------------
@@ -122,10 +123,10 @@ export namespace TypeCompiler {
 
   function* Array(schema: Types.TArray, value: string): IterableIterator<string> {
     const expression = CreateExpression(schema.items, 'value')
+    yield `(Array.isArray(${value}) && ${value}.every(value => ${expression}))`
     if (IsNumber(schema.minItems)) yield `(${value}.length >= ${schema.minItems})`
     if (IsNumber(schema.maxItems)) yield `(${value}.length <= ${schema.maxItems})`
-    if (schema.uniqueItems === true) yield `(new Set(${value}).size === ${value}.length)`
-    yield `(Array.isArray(${value}) && ${value}.every(value => ${expression}))`
+    if (schema.uniqueItems === true) yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`
   }
 
   function* Boolean(schema: Types.TBoolean, value: string): IterableIterator<string> {
@@ -430,7 +431,7 @@ export namespace TypeCompiler {
     TypeGuard.Assert(schema, references)
     const code = Build(schema, references)
     const custom_schemas = new Map(state_remote_custom_types)
-    const compiledFunction = globalThis.Function('custom', 'format', code)
+    const compiledFunction = globalThis.Function('custom', 'format', 'hash', code)
     const checkFunction = compiledFunction(
       (kind: string, schema_key: string, value: unknown) => {
         if (!Custom.Has(kind) || !custom_schemas.has(schema_key)) return false
@@ -443,6 +444,9 @@ export namespace TypeCompiler {
         const func = Format.Get(format)!
         return func(value)
       },
+      (value: unknown) => {
+        return ValueHash.Create(value)
+      },
     )
     return new TypeCheck(schema, references, checkFunction, code)
   }
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index f6f7cb159..d3407418e 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -29,6 +29,7 @@ THE SOFTWARE.
 import * as Types from '../typebox'
 import { Format } from '../format/index'
 import { Custom } from '../custom/index'
+import { ValueHash } from '../hash/index'
 
 // -------------------------------------------------------------------
 // ValueErrorType
@@ -126,7 +127,8 @@ export namespace ValueErrors {
     if (IsNumber(schema.maxItems) && !(value.length <= schema.maxItems)) {
       yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` }
     }
-    if (schema.uniqueItems === true && !(new Set(value).size === value.length)) {
+    // prettier-ignore
+    if (schema.uniqueItems === true && !((function() { const set = new Set(); for(const element of value) { const hashed = ValueHash.Create(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())) {
       yield { type: ValueErrorType.ArrayUniqueItems, schema, path, value, message: `Expected array elements to be unique` }
     }
     for (let i = 0; i < value.length; i++) {
diff --git a/src/hash/hash.ts b/src/hash/hash.ts
new file mode 100644
index 000000000..f1955cd54
--- /dev/null
+++ b/src/hash/hash.ts
@@ -0,0 +1,193 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/hash
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export class ValueHashError extends Error {
+  constructor(public readonly value: unknown) {
+    super(`Hash: Unable to hash value`)
+  }
+}
+
+export namespace ValueHash {
+  enum ByteMarker {
+    Undefined,
+    Null,
+    Boolean,
+    Number,
+    String,
+    Object,
+    Array,
+    Date,
+    Uint8Array,
+  }
+
+  // ----------------------------------------------------
+  // State
+  // ----------------------------------------------------
+
+  let Hash = 14695981039346656037n
+  const [Prime, Size] = [1099511628211n, 2n ** 64n]
+  const Bytes = globalThis.Array.from({ length: 256 }).map((_, i) => globalThis.BigInt(i))
+  const F64 = new globalThis.Float64Array(1)
+  const F64In = new globalThis.DataView(F64.buffer)
+  const F64Out = new globalThis.Uint8Array(F64.buffer)
+
+  // ----------------------------------------------------
+  // Guards
+  // ----------------------------------------------------
+
+  function IsDate(value: unknown): value is Date {
+    return value instanceof globalThis.Date
+  }
+
+  function IsUint8Array(value: unknown): value is Uint8Array {
+    return value instanceof globalThis.Uint8Array
+  }
+
+  function IsArray(value: unknown): value is Array<unknown> {
+    return globalThis.Array.isArray(value)
+  }
+
+  function IsBoolean(value: unknown): value is boolean {
+    return typeof value === 'boolean'
+  }
+
+  function IsNull(value: unknown): value is null {
+    return value === null
+  }
+
+  function IsNumber(value: unknown): value is number {
+    return typeof value === 'number'
+  }
+
+  function IsObject(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !IsArray(value) && !IsDate(value) && !IsUint8Array(value)
+  }
+
+  function IsString(value: unknown): value is string {
+    return typeof value === 'string'
+  }
+
+  function IsUndefined(value: unknown): value is undefined {
+    return value === undefined
+  }
+
+  // ----------------------------------------------------
+  // Encoding
+  // ----------------------------------------------------
+
+  function Array(value: Array<unknown>) {
+    Fnv1A64(ByteMarker.Array)
+    for (const item of value) {
+      Visit(item)
+    }
+  }
+
+  function Boolean(value: boolean) {
+    Fnv1A64(ByteMarker.Boolean)
+    Fnv1A64(value ? 1 : 0)
+  }
+
+  function Date(value: Date) {
+    Fnv1A64(ByteMarker.Date)
+    Visit(value.getTime())
+  }
+
+  function Null(value: null) {
+    Fnv1A64(ByteMarker.Null)
+  }
+
+  function Number(value: number) {
+    Fnv1A64(ByteMarker.Number)
+    F64In.setFloat64(0, value)
+    for (const byte of F64Out) {
+      Fnv1A64(byte)
+    }
+  }
+
+  function Object(value: Record<string, unknown>) {
+    Fnv1A64(ByteMarker.Object)
+    for (const key of globalThis.Object.keys(value).sort()) {
+      Visit(key)
+      Visit(value[key])
+    }
+  }
+
+  function String(value: string) {
+    Fnv1A64(ByteMarker.String)
+    for (let i = 0; i < value.length; i++) {
+      Fnv1A64(value.charCodeAt(i))
+    }
+  }
+
+  function Uint8Array(value: Uint8Array) {
+    Fnv1A64(ByteMarker.Uint8Array)
+    for (let i = 0; i < value.length; i++) {
+      Fnv1A64(value[i])
+    }
+  }
+
+  function Undefined(value: undefined) {
+    return Fnv1A64(ByteMarker.Undefined)
+  }
+
+  function Visit(value: any) {
+    if (IsArray(value)) {
+      Array(value)
+    } else if (IsBoolean(value)) {
+      Boolean(value)
+    } else if (IsDate(value)) {
+      Date(value)
+    } else if (IsNull(value)) {
+      Null(value)
+    } else if (IsNumber(value)) {
+      Number(value)
+    } else if (IsObject(value)) {
+      Object(value)
+    } else if (IsString(value)) {
+      String(value)
+    } else if (IsUint8Array(value)) {
+      Uint8Array(value)
+    } else if (IsUndefined(value)) {
+      Undefined(value)
+    } else {
+      throw new ValueHashError(value)
+    }
+  }
+
+  function Fnv1A64(byte: number) {
+    Hash = Hash ^ Bytes[byte]
+    Hash = (Hash * Prime) % Size
+  }
+
+  /** Creates a FNV1A-64 non cryptographic hash of the given value */
+  export function Create(value: unknown) {
+    Hash = 14695981039346656037n
+    Visit(value)
+    return Hash
+  }
+}
diff --git a/src/hash/index.ts b/src/hash/index.ts
new file mode 100644
index 000000000..d6597c698
--- /dev/null
+++ b/src/hash/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/hash
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './hash'
diff --git a/src/tsconfig.json b/src/tsconfig.json
index c8ce66e6d..52cb52269 100644
--- a/src/tsconfig.json
+++ b/src/tsconfig.json
@@ -1,4 +1,4 @@
 {
   "extends": "../tsconfig.json",
-  "files": ["compiler/index.ts", "conditional/index.ts", "custom/index.ts", "format/index.ts", "guard/index.ts", "value/index.ts", "typebox.ts"]
+  "files": ["compiler/index.ts", "conditional/index.ts", "custom/index.ts", "format/index.ts", "guard/index.ts", "hash/index.ts", "value/index.ts", "typebox.ts"]
 }
diff --git a/src/value/check.ts b/src/value/check.ts
index 16fe2ad8e..8ceca89e5 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -29,6 +29,7 @@ THE SOFTWARE.
 import * as Types from '../typebox'
 import { Format } from '../format/index'
 import { Custom } from '../custom/index'
+import { ValueHash } from '../hash/index'
 
 export class ValueCheckUnknownTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
@@ -44,6 +45,7 @@ export namespace ValueCheck {
   function Any(schema: Types.TAny, references: Types.TSchema[], value: any): boolean {
     return true
   }
+
   function Array(schema: Types.TArray, references: Types.TSchema[], value: any): boolean {
     if (!globalThis.Array.isArray(value)) {
       return false
@@ -54,7 +56,8 @@ export namespace ValueCheck {
     if (IsNumber(schema.maxItems) && !(value.length <= schema.maxItems)) {
       return false
     }
-    if (schema.uniqueItems === true && !(new Set(value).size === value.length)) {
+    // prettier-ignore
+    if (schema.uniqueItems === true && !((function() { const set = new Set(); for(const element of value) { const hashed = ValueHash.Create(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())) {
       return false
     }
     return value.every((val) => Visit(schema.items, references, val))
diff --git a/src/value/index.ts b/src/value/index.ts
index f96cee562..b962dac8c 100644
--- a/src/value/index.ts
+++ b/src/value/index.ts
@@ -27,5 +27,6 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 export { ValueError, ValueErrorType } from '../errors/index'
+export { Edit, Insert, Update, Delete } from './delta'
 export * from './pointer'
 export * from './value'
diff --git a/src/value/value.ts b/src/value/value.ts
index 48aab1500..1e36736d0 100644
--- a/src/value/value.ts
+++ b/src/value/value.ts
@@ -28,6 +28,7 @@ THE SOFTWARE.
 
 import * as Types from '../typebox'
 import { ValueErrors, ValueError } from '../errors/index'
+import { ValueHash } from '../hash/index'
 import { ValueEqual } from './equal'
 import { ValueCast } from './cast'
 import { ValueClone } from './clone'
@@ -35,8 +36,6 @@ import { ValueCreate } from './create'
 import { ValueCheck } from './check'
 import { ValueDelta, Edit } from './delta'
 
-export { Edit, Insert, Update, Delete } from './delta'
-
 /** Provides functions to perform structural updates to JavaScript values */
 export namespace Value {
   /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number and boolean values if a reasonable conversion is possible. */
@@ -66,6 +65,11 @@ export namespace Value {
     return ValueCheck.Check(schema, references, value)
   }
 
+  /** Returns a structural clone of the given value */
+  export function Clone<T>(value: T): T {
+    return ValueClone.Clone(value)
+  }
+
   /** Returns an iterator for each error in this value. */
   export function Errors<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): IterableIterator<ValueError>
   /** Returns an iterator for each error in this value. */
@@ -80,16 +84,16 @@ export namespace Value {
     return ValueEqual.Equal(left, right)
   }
 
-  /** Returns a structural clone of the given value */
-  export function Clone<T>(value: T): T {
-    return ValueClone.Clone(value)
-  }
-
   /** Returns edits to transform the current value into the next value */
   export function Diff(current: unknown, next: unknown): Edit[] {
     return ValueDelta.Diff(current, next)
   }
 
+  /** Returns a FNV1A-64 non cryptographic hash of the given value */
+  export function Hash(value: unknown): bigint {
+    return ValueHash.Create(value)
+  }
+
   /** Returns a new value with edits applied to the given value */
   export function Patch<T = any>(current: unknown, edits: Edit[]): T {
     return ValueDelta.Patch(current, edits) as T
diff --git a/test/runtime/compiler/array.ts b/test/runtime/compiler/array.ts
index f74b7b4d6..61fc8171c 100644
--- a/test/runtime/compiler/array.ts
+++ b/test/runtime/compiler/array.ts
@@ -83,12 +83,19 @@ describe('type/compiler/Array', () => {
     const T = Type.Array(Type.Number(), { maxItems: 3 })
     fail(T, [0, 1, 2, 3])
   })
-  it('Should validate array with uniqueItems when items are references', () => {
+  it('Should validate array with uniqueItems when items are distinct objects', () => {
     const T = Type.Array(Type.Object({ x: Type.Number(), y: Type.Number() }), { uniqueItems: true })
     ok(T, [
       { x: 0, y: 1 },
       { x: 1, y: 0 },
-    ]) // references distinct
+    ])
+  })
+  it('Should not validate array with uniqueItems when items are not distinct objects', () => {
+    const T = Type.Array(Type.Object({ x: Type.Number(), y: Type.Number() }), { uniqueItems: true })
+    fail(T, [
+      { x: 1, y: 0 },
+      { x: 1, y: 0 },
+    ])
   })
   it('Should not validate array with non uniqueItems', () => {
     const T = Type.Array(Type.Number(), { uniqueItems: true })
diff --git a/test/runtime/hash/hash.ts b/test/runtime/hash/hash.ts
new file mode 100644
index 000000000..dd508fce4
--- /dev/null
+++ b/test/runtime/hash/hash.ts
@@ -0,0 +1,94 @@
+import { ValueHash } from '@sinclair/typebox/hash'
+import { Assert } from '../assert/index'
+
+describe('Hash', () => {
+  it('Should hash number', () => {
+    Assert.equal('bigint', typeof ValueHash.Create(1))
+    const A = ValueHash.Create(1)
+    const B = ValueHash.Create(2)
+    Assert.notEqual(A, B)
+  })
+
+  it('Should hash string', () => {
+    Assert.equal('bigint', typeof ValueHash.Create('hello'))
+    const A = ValueHash.Create('hello')
+    const B = ValueHash.Create('world')
+    Assert.notEqual(A, B)
+  })
+
+  it('Should hash boolean', () => {
+    Assert.equal('bigint', typeof ValueHash.Create(true))
+    Assert.equal('bigint', typeof ValueHash.Create(false))
+    const A = ValueHash.Create(true)
+    const B = ValueHash.Create(false)
+    Assert.notEqual(A, B)
+  })
+
+  it('Should not hash bigint', () => {
+    Assert.throws(() => ValueHash.Create(1n))
+  })
+
+  it('Should hash null', () => {
+    Assert.equal('bigint', typeof ValueHash.Create(null))
+    const A = ValueHash.Create(null)
+    const B = ValueHash.Create(undefined)
+    Assert.notEqual(A, B)
+  })
+
+  it('Should hash array', () => {
+    Assert.equal('bigint', typeof ValueHash.Create([0, 1, 2, 3]))
+    const A = ValueHash.Create([0, 1, 2, 3])
+    const B = ValueHash.Create([0, 2, 2, 3])
+    Assert.notEqual(A, B)
+  })
+
+  it('Should hash object 1', () => {
+    // prettier-ignore
+    Assert.equal('bigint', typeof ValueHash.Create({ x: 1, y: 2 }))
+    const A = ValueHash.Create({ x: 1, y: 2 })
+    const B = ValueHash.Create({ x: 2, y: 2 })
+    Assert.notEqual(A, B)
+  })
+  it('Should hash object 2', () => {
+    const A = ValueHash.Create({ x: 1, y: [1, 2] })
+    const B = ValueHash.Create({ x: 1, y: [1, 3] })
+    Assert.notEqual(A, B)
+  })
+  it('Should hash object 3', () => {
+    const A = ValueHash.Create({ x: 1, y: undefined })
+    const B = ValueHash.Create({ x: 1 })
+    Assert.notEqual(A, B)
+  })
+  it('Should hash object 4', () => {
+    const A = ValueHash.Create({ x: 1, y: new Uint8Array([0, 1, 2]) })
+    const B = ValueHash.Create({ x: 1, y: [0, 1, 2] })
+    Assert.notEqual(A, B)
+  })
+
+  it('Should hash object 5', () => {
+    const A = ValueHash.Create({ x: 1, y: undefined })
+    const B = ValueHash.Create({ x: 2, y: undefined })
+    Assert.notEqual(A, B)
+  })
+
+  it('Should hash Date', () => {
+    Assert.equal('bigint', typeof ValueHash.Create(new Date()))
+    const A = ValueHash.Create(new Date(1))
+    const B = ValueHash.Create(new Date(2))
+    Assert.notEqual(A, B)
+  })
+
+  it('Should hash Uint8Array', () => {
+    Assert.equal('bigint', typeof ValueHash.Create(new Uint8Array([0, 1, 2, 3])))
+    const A = ValueHash.Create(new Uint8Array([0, 1, 2, 3]))
+    const B = ValueHash.Create(new Uint8Array([0, 2, 2, 3]))
+    Assert.notEqual(A, B)
+  })
+
+  it('Should hash undefined', () => {
+    Assert.equal('bigint', typeof ValueHash.Create(undefined))
+    const A = ValueHash.Create(undefined)
+    const B = ValueHash.Create(null)
+    Assert.notEqual(A, B)
+  })
+})
diff --git a/test/runtime/hash/index.ts b/test/runtime/hash/index.ts
new file mode 100644
index 000000000..50fbad4e5
--- /dev/null
+++ b/test/runtime/hash/index.ts
@@ -0,0 +1 @@
+import './hash'
diff --git a/test/runtime/index.ts b/test/runtime/index.ts
index ea1496280..f5ed2d8cd 100644
--- a/test/runtime/index.ts
+++ b/test/runtime/index.ts
@@ -3,5 +3,6 @@ import './conditional/index'
 import './errors/index'
 import './format/index'
 import './guard/index'
+import './hash/index'
 import './schema/index'
 import './value/index'
diff --git a/test/runtime/schema/array.ts b/test/runtime/schema/array.ts
index bc3d1b1cf..57df3662a 100644
--- a/test/runtime/schema/array.ts
+++ b/test/runtime/schema/array.ts
@@ -82,12 +82,19 @@ describe('type/schema/Array', () => {
     const T = Type.Array(Type.Number(), { maxItems: 3 })
     fail(T, [0, 1, 2, 3])
   })
-  it('Should validate array with uniqueItems when items are references', () => {
+  it('Should validate array with uniqueItems when items are distinct objects', () => {
     const T = Type.Array(Type.Object({ x: Type.Number(), y: Type.Number() }), { uniqueItems: true })
     ok(T, [
       { x: 0, y: 1 },
       { x: 1, y: 0 },
-    ]) // references distinct
+    ])
+  })
+  it('Should not validate array with uniqueItems when items are not distinct objects', () => {
+    const T = Type.Array(Type.Object({ x: Type.Number(), y: Type.Number() }), { uniqueItems: true })
+    fail(T, [
+      { x: 1, y: 0 },
+      { x: 1, y: 0 },
+    ])
   })
   it('Should not validate array with non uniqueItems', () => {
     const T = Type.Array(Type.Number(), { uniqueItems: true })
diff --git a/test/runtime/value/check/array.ts b/test/runtime/value/check/array.ts
index 909b093c6..64f3f3806 100644
--- a/test/runtime/value/check/array.ts
+++ b/test/runtime/value/check/array.ts
@@ -30,9 +30,42 @@ describe('value/check/Array', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
+
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(Type.Array(Type.Any()), value)
     Assert.equal(result, false)
   })
+
+  it('Should validate array with unique primitive items', () => {
+    const T = Type.Array(Type.Number(), { uniqueItems: true })
+    const result = Value.Check(T, [0, 1, 2])
+    Assert.equal(result, true)
+  })
+
+  it('Should not validate array with non-unique primitive items', () => {
+    const T = Type.Array(Type.Number(), { uniqueItems: true })
+    const result = Value.Check(T, [0, 0, 2])
+    Assert.equal(result, false)
+  })
+
+  it('Should validate array with unique object items', () => {
+    const T = Type.Array(Type.Object({ x: Type.Number(), y: Type.Number() }), { uniqueItems: true })
+    const result = Value.Check(T, [
+      { x: 1, y: 1 },
+      { x: 2, y: 2 },
+      { x: 3, y: 3 },
+    ])
+    Assert.equal(result, true)
+  })
+
+  it('Should not validate array with non-unique object items', () => {
+    const T = Type.Array(Type.Object({ x: Type.Number(), y: Type.Number() }), { uniqueItems: true })
+    const result = Value.Check(T, [
+      { x: 1, y: 1 },
+      { x: 1, y: 1 },
+      { x: 3, y: 3 },
+    ])
+    Assert.equal(result, false)
+  })
 })
diff --git a/tsconfig.json b/tsconfig.json
index 41c97c61c..c1619dc92 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -25,6 +25,9 @@
       "@sinclair/typebox/guard": [
         "src/guard/index.ts"
       ],
+      "@sinclair/typebox/hash": [
+        "src/hash/index.ts"
+      ],
       "@sinclair/typebox/value": [
         "src/value/index.ts"
       ],

From 7dcdea9e7d59c103a39fe4e732767c2177912a54 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Fri, 9 Dec 2022 19:41:10 +0900
Subject: [PATCH 043/369] Examples IntersectAllOf and UnionOneOf

---
 example/custom/index.ts          |  2 ++
 example/custom/intersectAllOf.ts | 21 +++++++++++++++++++++
 example/custom/unionOneOf.ts     | 17 +++++++++++++++++
 3 files changed, 40 insertions(+)
 create mode 100644 example/custom/index.ts
 create mode 100644 example/custom/intersectAllOf.ts
 create mode 100644 example/custom/unionOneOf.ts

diff --git a/example/custom/index.ts b/example/custom/index.ts
new file mode 100644
index 000000000..7f9f50c3c
--- /dev/null
+++ b/example/custom/index.ts
@@ -0,0 +1,2 @@
+export * from './intersectAllOf'
+export * from './unionOneOf'
\ No newline at end of file
diff --git a/example/custom/intersectAllOf.ts b/example/custom/intersectAllOf.ts
new file mode 100644
index 000000000..4b8e24efe
--- /dev/null
+++ b/example/custom/intersectAllOf.ts
@@ -0,0 +1,21 @@
+import { Kind, TSchema, SchemaOptions, IntersectReduce, IntersectEvaluate } from '@sinclair/typebox'
+import { Custom } from '@sinclair/typebox/custom'
+import { Value } from '@sinclair/typebox/value'
+
+export interface IntersectAllOfOptions extends SchemaOptions {
+  unevaluatedProperties?: boolean
+}
+
+export interface IntersectAllOf<T extends TSchema[]> extends TSchema, IntersectAllOfOptions {
+  [Kind]: 'IntersectAllOf',
+  static: IntersectReduce<unknown, IntersectEvaluate<T, []>>
+  allOf: T
+}
+
+/** Creates a Intersect type with a allOf  schema representation */
+export function IntersectAllOf<T extends TSchema[]>(allOf: [...T], options: IntersectAllOfOptions = {}) {
+  if(!Custom.Has('IntersectAllOf')) Custom.Set('IntersectAllOf', (schema: { allOf: TSchema[] }, value) => {
+    return schema.allOf.every(schema => Value.Check(schema, value))
+  })
+  return { ...options, [Kind]: 'IntersectAllOf', allOf } as IntersectAllOf<T>
+}
\ No newline at end of file
diff --git a/example/custom/unionOneOf.ts b/example/custom/unionOneOf.ts
new file mode 100644
index 000000000..0db14c59d
--- /dev/null
+++ b/example/custom/unionOneOf.ts
@@ -0,0 +1,17 @@
+import { Kind, TSchema, SchemaOptions, Static } from '@sinclair/typebox'
+import { Custom } from '@sinclair/typebox/custom'
+import { Value } from '@sinclair/typebox/value'
+
+export interface UnionOneOf<T extends TSchema[]> extends TSchema {
+    [Kind]: 'UnionOneOf',
+    static: { [K in keyof T]: Static<T[K]> }[number]
+    oneOf: T
+}
+
+/** Creates a Union type with a oneOf schema representation */
+export function UnionOneOf<T extends TSchema[]>(oneOf: [...T], options: SchemaOptions = {}) {
+    if (!Custom.Has('UnionOneOf')) Custom.Set('UnionOneOf', (schema: { oneOf: TSchema[] }, value) => {
+        return 1 === schema.oneOf.reduce((acc: number, schema: any) => (Value.Check(schema, value) ? acc + 1 : acc), 0)
+    })
+    return { [Kind]: 'UnionOneOf', oneOf } as UnionOneOf<T>
+}

From 581ec5de076f5ce921dee08e456118441eb3ac66 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 9 Dec 2022 21:04:48 +0900
Subject: [PATCH 044/369] Use BigInt Constructor (#287)

---
 example/index.ts  | 2 +-
 package.json      | 2 +-
 src/hash/hash.ts  | 6 +++---
 src/value/cast.ts | 4 ++--
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/example/index.ts b/example/index.ts
index dee703c07..dfde052cf 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -15,4 +15,4 @@ const T = Type.Object({
 
 type T = Static<typeof T>
 
-console.log(T)
\ No newline at end of file
+console.log(T)
diff --git a/package.json b/package.json
index 31deefffa..834e2b71a 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.11",
+  "version": "0.25.12",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/hash/hash.ts b/src/hash/hash.ts
index f1955cd54..3d0ac21b6 100644
--- a/src/hash/hash.ts
+++ b/src/hash/hash.ts
@@ -49,8 +49,8 @@ export namespace ValueHash {
   // State
   // ----------------------------------------------------
 
-  let Hash = 14695981039346656037n
-  const [Prime, Size] = [1099511628211n, 2n ** 64n]
+  let Hash = globalThis.BigInt('14695981039346656037')
+  const [Prime, Size] = [globalThis.BigInt('1099511628211'), globalThis.BigInt('2') ** globalThis.BigInt('64')]
   const Bytes = globalThis.Array.from({ length: 256 }).map((_, i) => globalThis.BigInt(i))
   const F64 = new globalThis.Float64Array(1)
   const F64In = new globalThis.DataView(F64.buffer)
@@ -186,7 +186,7 @@ export namespace ValueHash {
 
   /** Creates a FNV1A-64 non cryptographic hash of the given value */
   export function Create(value: unknown) {
-    Hash = 14695981039346656037n
+    Hash = globalThis.BigInt('14695981039346656037')
     Visit(value)
     return Hash
   }
diff --git a/src/value/cast.ts b/src/value/cast.ts
index 17d72e375..5abe5f60c 100644
--- a/src/value/cast.ts
+++ b/src/value/cast.ts
@@ -146,11 +146,11 @@ export namespace ValueCast {
   }
 
   function IsValueTrue(value: unknown): value is true {
-    return value === true || (IsNumber(value) && value === 1) || (IsBigInt(value) && value === 1n) || (IsString(value) && (value.toLowerCase() === 'true' || value === '1'))
+    return value === true || (IsNumber(value) && value === 1) || (IsBigInt(value) && value === globalThis.BigInt('1')) || (IsString(value) && (value.toLowerCase() === 'true' || value === '1'))
   }
 
   function IsValueFalse(value: unknown): value is true {
-    return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === 0n) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'))
+    return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === globalThis.BigInt('0')) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'))
   }
 
   // ----------------------------------------------------------------------------------------------

From 31d927baf39b510351128dd8951fcd32dc2395ef Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sat, 10 Dec 2022 17:05:09 +0900
Subject: [PATCH 045/369] Documentation

---
 readme.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/readme.md b/readme.md
index 660ae6100..acb9d9283 100644
--- a/readme.md
+++ b/readme.md
@@ -73,8 +73,8 @@ License MIT
 - [Overview](#overview)
 - [Example](#Example)
 - [Types](#types)
-  - [Standard Types](#types-standard)
-  - [Extended Types](#types-extended)
+  - [Standard](#types-standard)
+  - [Extended](#types-extended)
   - [Modifiers](#types-modifiers)
   - [Options](#types-options)
   - [Reference](#types-reference)
@@ -189,7 +189,7 @@ TypeBox provides a set of functions that allow you to compose JSON Schema simila
 
 <a name='types-standard'></a>
 
-### Standard Types
+### Standard
 
 The following table lists the Standard TypeBox types.
 
@@ -396,7 +396,7 @@ The following table lists the Standard TypeBox types.
 
 <a name='types-extended'></a>
 
-### Extended Types
+### Extended
 
 TypeBox provides a set of extended types that can be used to express schematics for core JavaScript constructs and primitives. Extended types are not valid JSON Schema and will not validate using typical validation. These types however can be used to frame JSON schema and describe callable RPC interfaces that may receive JSON validated data.
 

From 9989fc784ed31bf880ab6d12cae8dee108dc6ad5 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 11 Dec 2022 17:12:13 +0900
Subject: [PATCH 046/369] Assert Numeric for NaN (#288)

---
 example/index.ts                    |  2 +-
 package.json                        |  2 +-
 readme.md                           | 96 ++++++++++++++---------------
 src/compiler/compiler.ts            |  5 +-
 src/errors/errors.ts                |  6 +-
 src/guard/guard.ts                  |  2 +-
 src/value/cast.ts                   |  2 +-
 src/value/check.ts                  |  7 ++-
 test/runtime/compiler/integer.ts    |  4 ++
 test/runtime/compiler/number.ts     |  4 ++
 test/runtime/schema/integer.ts      |  4 ++
 test/runtime/schema/number.ts       |  4 ++
 test/runtime/value/check/integer.ts |  6 ++
 test/runtime/value/check/number.ts  |  5 ++
 14 files changed, 89 insertions(+), 60 deletions(-)

diff --git a/example/index.ts b/example/index.ts
index dfde052cf..dee703c07 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -15,4 +15,4 @@ const T = Type.Object({
 
 type T = Static<typeof T>
 
-console.log(T)
+console.log(T)
\ No newline at end of file
diff --git a/package.json b/package.json
index 834e2b71a..bc74862d6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.12",
+  "version": "0.25.13",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index acb9d9283..94bc7374b 100644
--- a/readme.md
+++ b/readme.md
@@ -1205,29 +1205,29 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    415 ms' │ '     14 ms' │ '   29.64 x' │
-│           String │    2000    │ '    335 ms' │ '     12 ms' │ '   27.92 x' │
-│          Boolean │    2000    │ '    295 ms' │ '     13 ms' │ '   22.69 x' │
-│             Null │    2000    │ '    255 ms' │ '      8 ms' │ '   31.88 x' │
-│            RegEx │    2000    │ '    482 ms' │ '     17 ms' │ '   28.35 x' │
-│          ObjectA │    2000    │ '   2700 ms' │ '     55 ms' │ '   49.09 x' │
-│          ObjectB │    2000    │ '   2871 ms' │ '     36 ms' │ '   79.75 x' │
-│            Tuple │    2000    │ '   1229 ms' │ '     22 ms' │ '   55.86 x' │
-│            Union │    2000    │ '   1216 ms' │ '     26 ms' │ '   46.77 x' │
-│          Vector4 │    2000    │ '   1575 ms' │ '     25 ms' │ '   63.00 x' │
-│          Matrix4 │    2000    │ '    908 ms' │ '     13 ms' │ '   69.85 x' │
-│   Literal_String │    2000    │ '    353 ms' │ '      9 ms' │ '   39.22 x' │
-│   Literal_Number │    2000    │ '    371 ms' │ '      7 ms' │ '   53.00 x' │
-│  Literal_Boolean │    2000    │ '    361 ms' │ '      8 ms' │ '   45.13 x' │
-│     Array_Number │    2000    │ '    694 ms' │ '      7 ms' │ '   99.14 x' │
-│     Array_String │    2000    │ '    778 ms' │ '      8 ms' │ '   97.25 x' │
-│    Array_Boolean │    2000    │ '    735 ms' │ '      7 ms' │ '  105.00 x' │
-│    Array_ObjectA │    2000    │ '   3732 ms' │ '     44 ms' │ '   84.82 x' │
-│    Array_ObjectB │    2000    │ '   3624 ms' │ '     40 ms' │ '   90.60 x' │
-│      Array_Tuple │    2000    │ '   2101 ms' │ '     15 ms' │ '  140.07 x' │
-│      Array_Union │    2000    │ '   1480 ms' │ '     25 ms' │ '   59.20 x' │
-│    Array_Vector4 │    2000    │ '   2175 ms' │ '     18 ms' │ '  120.83 x' │
-│    Array_Matrix4 │    2000    │ '   1516 ms' │ '     13 ms' │ '  116.62 x' │
+│           Number │    2000    │ '    437 ms' │ '     15 ms' │ '   29.13 x' │
+│           String │    2000    │ '    332 ms' │ '     13 ms' │ '   25.54 x' │
+│          Boolean │    2000    │ '    293 ms' │ '     12 ms' │ '   24.42 x' │
+│             Null │    2000    │ '    259 ms' │ '      9 ms' │ '   28.78 x' │
+│            RegEx │    2000    │ '    505 ms' │ '     21 ms' │ '   24.05 x' │
+│          ObjectA │    2000    │ '   2726 ms' │ '     53 ms' │ '   51.43 x' │
+│          ObjectB │    2000    │ '   2835 ms' │ '     37 ms' │ '   76.62 x' │
+│            Tuple │    2000    │ '   1239 ms' │ '     24 ms' │ '   51.63 x' │
+│            Union │    2000    │ '   1244 ms' │ '     34 ms' │ '   36.59 x' │
+│          Vector4 │    2000    │ '   1521 ms' │ '     21 ms' │ '   72.43 x' │
+│          Matrix4 │    2000    │ '    836 ms' │ '     10 ms' │ '   83.60 x' │
+│   Literal_String │    2000    │ '    333 ms' │ '      9 ms' │ '   37.00 x' │
+│   Literal_Number │    2000    │ '    357 ms' │ '      9 ms' │ '   39.67 x' │
+│  Literal_Boolean │    2000    │ '    352 ms' │ '      6 ms' │ '   58.67 x' │
+│     Array_Number │    2000    │ '    685 ms' │ '     12 ms' │ '   57.08 x' │
+│     Array_String │    2000    │ '    720 ms' │ '     12 ms' │ '   60.00 x' │
+│    Array_Boolean │    2000    │ '    709 ms' │ '      8 ms' │ '   88.63 x' │
+│    Array_ObjectA │    2000    │ '   3590 ms' │ '     40 ms' │ '   89.75 x' │
+│    Array_ObjectB │    2000    │ '   3610 ms' │ '     51 ms' │ '   70.78 x' │
+│      Array_Tuple │    2000    │ '   2124 ms' │ '     19 ms' │ '  111.79 x' │
+│      Array_Union │    2000    │ '   1533 ms' │ '     21 ms' │ '   73.00 x' │
+│    Array_Vector4 │    2000    │ '   2278 ms' │ '     19 ms' │ '  119.89 x' │
+│    Array_Matrix4 │    2000    │ '   1504 ms' │ '     20 ms' │ '   75.20 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1241,31 +1241,31 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  1000000   │ '     28 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
-│           String │  1000000   │ '     22 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
-│          Boolean │  1000000   │ '     22 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
-│             Null │  1000000   │ '     25 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
-│            RegEx │  1000000   │ '    167 ms' │ '     48 ms' │ '     38 ms' │ '    1.26 x' │
-│          ObjectA │  1000000   │ '    591 ms' │ '     36 ms' │ '     22 ms' │ '    1.64 x' │
-│          ObjectB │  1000000   │ '   1168 ms' │ '     61 ms' │ '     37 ms' │ '    1.65 x' │
-│            Tuple │  1000000   │ '    127 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
-│            Union │  1000000   │ '    340 ms' │ '     26 ms' │ '     16 ms' │ '    1.63 x' │
-│        Recursive │  1000000   │ '   3174 ms' │ '    432 ms' │ '    100 ms' │ '    4.32 x' │
-│          Vector4 │  1000000   │ '    142 ms' │ '     24 ms' │ '     12 ms' │ '    2.00 x' │
-│          Matrix4 │  1000000   │ '    577 ms' │ '     40 ms' │ '     28 ms' │ '    1.43 x' │
-│   Literal_String │  1000000   │ '     47 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│   Literal_Number │  1000000   │ '     47 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
-│  Literal_Boolean │  1000000   │ '     45 ms' │ '     19 ms' │ '     11 ms' │ '    1.73 x' │
-│     Array_Number │  1000000   │ '    432 ms' │ '     33 ms' │ '     19 ms' │ '    1.74 x' │
-│     Array_String │  1000000   │ '    462 ms' │ '     32 ms' │ '     22 ms' │ '    1.45 x' │
-│    Array_Boolean │  1000000   │ '    455 ms' │ '     32 ms' │ '     26 ms' │ '    1.23 x' │
-│    Array_ObjectA │  1000000   │ '  14595 ms' │ '   2306 ms' │ '   1496 ms' │ '    1.54 x' │
-│    Array_ObjectB │  1000000   │ '  17310 ms' │ '   2625 ms' │ '   2105 ms' │ '    1.25 x' │
-│      Array_Tuple │  1000000   │ '   1794 ms' │ '     97 ms' │ '     66 ms' │ '    1.47 x' │
-│      Array_Union │  1000000   │ '   5085 ms' │ '    246 ms' │ '     91 ms' │ '    2.70 x' │
-│  Array_Recursive │  1000000   │ '  59747 ms' │ '   7866 ms' │ '   1136 ms' │ '    6.92 x' │
-│    Array_Vector4 │  1000000   │ '   2375 ms' │ '     99 ms' │ '     48 ms' │ '    2.06 x' │
-│    Array_Matrix4 │  1000000   │ '  13115 ms' │ '    385 ms' │ '    246 ms' │ '    1.57 x' │
+│           Number │  1000000   │ '     29 ms' │ '      6 ms' │ '      6 ms' │ '    1.00 x' │
+│           String │  1000000   │ '     24 ms' │ '     19 ms' │ '     11 ms' │ '    1.73 x' │
+│          Boolean │  1000000   │ '     22 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
+│             Null │  1000000   │ '     27 ms' │ '     23 ms' │ '     11 ms' │ '    2.09 x' │
+│            RegEx │  1000000   │ '    160 ms' │ '     52 ms' │ '     40 ms' │ '    1.30 x' │
+│          ObjectA │  1000000   │ '    577 ms' │ '     37 ms' │ '     26 ms' │ '    1.42 x' │
+│          ObjectB │  1000000   │ '    990 ms' │ '     50 ms' │ '     37 ms' │ '    1.35 x' │
+│            Tuple │  1000000   │ '    124 ms' │ '     22 ms' │ '     17 ms' │ '    1.29 x' │
+│            Union │  1000000   │ '    318 ms' │ '     24 ms' │ '     16 ms' │ '    1.50 x' │
+│        Recursive │  1000000   │ '   3102 ms' │ '    408 ms' │ '    102 ms' │ '    4.00 x' │
+│          Vector4 │  1000000   │ '    150 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
+│          Matrix4 │  1000000   │ '    579 ms' │ '     43 ms' │ '     27 ms' │ '    1.59 x' │
+│   Literal_String │  1000000   │ '     50 ms' │ '     22 ms' │ '     10 ms' │ '    2.20 x' │
+│   Literal_Number │  1000000   │ '     47 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
+│  Literal_Boolean │  1000000   │ '     48 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
+│     Array_Number │  1000000   │ '    429 ms' │ '     32 ms' │ '     20 ms' │ '    1.60 x' │
+│     Array_String │  1000000   │ '    474 ms' │ '     33 ms' │ '     25 ms' │ '    1.32 x' │
+│    Array_Boolean │  1000000   │ '    447 ms' │ '     35 ms' │ '     31 ms' │ '    1.13 x' │
+│    Array_ObjectA │  1000000   │ '  14098 ms' │ '   2352 ms' │ '   2015 ms' │ '    1.17 x' │
+│    Array_ObjectB │  1000000   │ '  16216 ms' │ '   2628 ms' │ '   2511 ms' │ '    1.05 x' │
+│      Array_Tuple │  1000000   │ '   1749 ms' │ '     95 ms' │ '     75 ms' │ '    1.27 x' │
+│      Array_Union │  1000000   │ '   4712 ms' │ '    233 ms' │ '     84 ms' │ '    2.77 x' │
+│  Array_Recursive │  1000000   │ '  56118 ms' │ '   7192 ms' │ '   1180 ms' │ '    6.09 x' │
+│    Array_Vector4 │  1000000   │ '   2284 ms' │ '     99 ms' │ '     50 ms' │ '    1.98 x' │
+│    Array_Matrix4 │  1000000   │ '  12640 ms' │ '    412 ms' │ '    272 ms' │ '    1.51 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 011e12d45..df9dd4821 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -111,8 +111,9 @@ export class TypeCompilerUnknownTypeError extends Error {
 /** Compiles Types for Runtime Type Checking */
 export namespace TypeCompiler {
   function IsNumber(value: unknown): value is number {
-    return typeof value === 'number'
+    return typeof value === 'number' && !globalThis.isNaN(value)
   }
+
   // -------------------------------------------------------------------
   // Types
   // -------------------------------------------------------------------
@@ -175,7 +176,7 @@ export namespace TypeCompiler {
   }
 
   function* Number(schema: Types.TNumber, value: string): IterableIterator<string> {
-    yield `(typeof ${value} === 'number')`
+    yield `(typeof ${value} === 'number' && !isNaN(${value}))`
     if (IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf} === 0)`
     if (IsNumber(schema.exclusiveMinimum)) yield `(${value} > ${schema.exclusiveMinimum})`
     if (IsNumber(schema.exclusiveMaximum)) yield `(${value} < ${schema.exclusiveMaximum})`
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index d3407418e..ed39446a8 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -112,7 +112,7 @@ export class ValueErrorsUnknownTypeError extends Error {
 /** Provides functionality to generate a sequence of errors against a TypeBox type.  */
 export namespace ValueErrors {
   function IsNumber(value: unknown): value is number {
-    return typeof value === 'number'
+    return typeof value === 'number' && !isNaN(value)
   }
 
   function* Any(schema: Types.TAny, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {}
@@ -171,7 +171,7 @@ export namespace ValueErrors {
   }
 
   function* Integer(schema: Types.TNumeric, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(typeof value === 'number')) {
+    if (!(typeof value === 'number' && globalThis.Number.isInteger(value))) {
       return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` }
     }
     if (!globalThis.Number.isInteger(value)) {
@@ -212,7 +212,7 @@ export namespace ValueErrors {
   }
 
   function* Number(schema: Types.TNumeric, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(typeof value === 'number')) {
+    if (!(typeof value === 'number' && !isNaN(value))) {
       return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` }
     }
     if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
diff --git a/src/guard/guard.ts b/src/guard/guard.ts
index c6904f0b6..437dc4acd 100644
--- a/src/guard/guard.ts
+++ b/src/guard/guard.ts
@@ -70,7 +70,7 @@ export namespace TypeGuard {
   }
 
   function IsNumber(value: unknown): value is number {
-    return typeof value === 'number'
+    return typeof value === 'number' && !isNaN(value)
   }
 
   function IsBoolean(value: unknown): value is boolean {
diff --git a/src/value/cast.ts b/src/value/cast.ts
index 5abe5f60c..3f085611b 100644
--- a/src/value/cast.ts
+++ b/src/value/cast.ts
@@ -134,7 +134,7 @@ export namespace ValueCast {
   }
 
   function IsNumber(value: unknown): value is number {
-    return typeof value === 'number'
+    return typeof value === 'number' && !isNaN(value)
   }
 
   function IsStringNumeric(value: unknown): value is string {
diff --git a/src/value/check.ts b/src/value/check.ts
index 8ceca89e5..f4f8d0f24 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -39,7 +39,7 @@ export class ValueCheckUnknownTypeError extends Error {
 
 export namespace ValueCheck {
   function IsNumber(value: unknown): value is number {
-    return typeof value === 'number'
+    return typeof value === 'number' && !isNaN(value)
   }
 
   function Any(schema: Types.TAny, references: Types.TSchema[], value: any): boolean {
@@ -88,12 +88,13 @@ export namespace ValueCheck {
     }
     return true
   }
+
   function Function(schema: Types.TFunction, references: Types.TSchema[], value: any): boolean {
     return typeof value === 'function'
   }
 
   function Integer(schema: Types.TInteger, references: Types.TSchema[], value: any): boolean {
-    if (!(typeof value === 'number')) {
+    if (!(typeof value === 'number' && globalThis.Number.isInteger(value))) {
       return false
     }
     if (!globalThis.Number.isInteger(value)) {
@@ -130,7 +131,7 @@ export namespace ValueCheck {
   }
 
   function Number(schema: Types.TNumber, references: Types.TSchema[], value: any): boolean {
-    if (!(typeof value === 'number')) {
+    if (!(typeof value === 'number' && !isNaN(value))) {
       return false
     }
     if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
diff --git a/test/runtime/compiler/integer.ts b/test/runtime/compiler/integer.ts
index af3ac6bfa..ba1110be9 100644
--- a/test/runtime/compiler/integer.ts
+++ b/test/runtime/compiler/integer.ts
@@ -64,4 +64,8 @@ describe('type/compiler/Integer', () => {
     ok(T, 9)
     fail(T, 10)
   })
+
+  it('Should not validate NaN', () => {
+    fail(Type.Integer(), NaN)
+  })
 })
diff --git a/test/runtime/compiler/number.ts b/test/runtime/compiler/number.ts
index 7628bfd12..b92e944b8 100644
--- a/test/runtime/compiler/number.ts
+++ b/test/runtime/compiler/number.ts
@@ -60,4 +60,8 @@ describe('type/compiler/Number', () => {
     ok(T, 9)
     fail(T, 10)
   })
+
+  it('Should not validate NaN', () => {
+    fail(Type.Number(), NaN)
+  })
 })
diff --git a/test/runtime/schema/integer.ts b/test/runtime/schema/integer.ts
index da32a8766..d176053ab 100644
--- a/test/runtime/schema/integer.ts
+++ b/test/runtime/schema/integer.ts
@@ -64,4 +64,8 @@ describe('type/schema/Integer', () => {
     ok(T, 9)
     fail(T, 10)
   })
+
+  it('Should not validate NaN', () => {
+    fail(Type.Integer(), NaN)
+  })
 })
diff --git a/test/runtime/schema/number.ts b/test/runtime/schema/number.ts
index b1a19ea72..3b3d6fc36 100644
--- a/test/runtime/schema/number.ts
+++ b/test/runtime/schema/number.ts
@@ -60,4 +60,8 @@ describe('type/schema/Number', () => {
     ok(T, 9)
     fail(T, 10)
   })
+
+  it('Should not validate NaN', () => {
+    fail(Type.Number(), NaN)
+  })
 })
diff --git a/test/runtime/value/check/integer.ts b/test/runtime/value/check/integer.ts
index 59a74024c..e02a6f55c 100644
--- a/test/runtime/value/check/integer.ts
+++ b/test/runtime/value/check/integer.ts
@@ -16,9 +16,15 @@ describe('value/check/Integer', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
+
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
+
+  it('Should fail NaN', () => {
+    const result = Value.Check(Type.Integer(), NaN)
+    Assert.equal(result, false)
+  })
 })
diff --git a/test/runtime/value/check/number.ts b/test/runtime/value/check/number.ts
index 4d9b14d6c..86dd673f1 100644
--- a/test/runtime/value/check/number.ts
+++ b/test/runtime/value/check/number.ts
@@ -44,4 +44,9 @@ describe('value/check/Number', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
+
+  it('Should fail NaN', () => {
+    const result = Value.Check(Type.Number(), NaN)
+    Assert.equal(result, false)
+  })
 })

From b66949f32ba2b25f8c314994ba874c7317dfbf53 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sun, 11 Dec 2022 20:28:29 +0900
Subject: [PATCH 047/369] Documentation

---
 readme.md | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/readme.md b/readme.md
index 94bc7374b..257316fc8 100644
--- a/readme.md
+++ b/readme.md
@@ -1148,22 +1148,23 @@ The following creates a `BigInt` type.
 ```typescript
 import { Type, Kind } from '@sinclair/typebox'
 
-Custom.Set('BigInt', (schema, value) => typeof value === 'bigint')
+Custom.Set('bigint', (schema, value) => typeof value === 'bigint')
+//            ▲
 //            │
-//            └────────────────────────────┐         The [Kind] is used to match registered type
+//            └────────────────────────────┐
 //                                         │
-const T = Type.Unsafe<bigint>({ [Kind]: 'BigInt' })  // const T = { [Kind]: 'BigInt' }
+const T = Type.Unsafe<bigint>({ [Kind]: 'bigint' })  // const T = { [Kind]: 'BigInt' }
 
-const A = TypeCompiler.Compile(T).Check(65536)       // const A = false
+const A = TypeCompiler.Compile(T).Check(1n)          // const A = true
 
-const B = Value.Check(T, 65536n)                     // const B = true
+const B = Value.Check(T, 1)                          // const B = false
 ```
 
 <a name='typecheck-custom-formats'></a>
 
 ### Custom Formats
 
-Use the format module to create user defined string formats. If using Ajv, please refer to the official Ajv format documentation located [here](https://ajv.js.org/guide/formats.html). The format module is specific to TypeBox can only be used with the TypeCompiler and Value modules.
+Use the format module to create user defined string formats. The format module is specific to TypeBox can only be used with the TypeCompiler and Value modules. If using Ajv, please refer to the official Ajv format documentation located [here](https://ajv.js.org/guide/formats.html).
 
 The format module is an optional import.
 
@@ -1171,20 +1172,19 @@ The format module is an optional import.
 import { Format } from '@sinclair/typebox/format'
 ```
 
-The following creates a palindrome string format.
+The following creates a custom string format that checks for lowercase.
 
 ```typescript
-Format.Set('palindrome', value => value === value.split('').reverse().join(''))
-```
-
-Once set, this format can then be used by the TypeCompiler and Value modules.
-
-```typescript
-const T = Type.String({ format: 'palindrome' })
+Format.Set('lowercase', value => value === value.toLowerCase())
+//            ▲
+//            │
+//            └────────────────────┐         
+//                                 │
+const T = Type.String({ format: 'lowercase' })
 
-const A = TypeCompiler.Compile(T).Check('engine')    // const A = false
+const A = TypeCompiler.Compile(T).Check('action')    // const A = true
 
-const B = Value.Check(T, 'kayak')                    // const B = true
+const B = Value.Check(T, 'Action')                   // const B = false
 ```
 
 <a name='benchmark'></a>

From 6c410b2006dc207872237ad3142934e26a4ae0ee Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sun, 11 Dec 2022 20:29:13 +0900
Subject: [PATCH 048/369] Documentation

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 257316fc8..ac6ea8174 100644
--- a/readme.md
+++ b/readme.md
@@ -1143,7 +1143,7 @@ The custom module is an optional import.
 import { Custom } from '@sinclair/typebox/custom'
 ```
 
-The following creates a `BigInt` type.
+The following creates a `bigint` type.
 
 ```typescript
 import { Type, Kind } from '@sinclair/typebox'

From 29f73eae36e5f685e886ae7f1508c3f75683db8e Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 15 Dec 2022 19:48:59 +0900
Subject: [PATCH 049/369] Extensions and Collections (#290)

---
 example/collections/array.ts          | 381 ++++++++++++++++++++++++++
 example/collections/index.ts          |  31 +++
 example/collections/map.ts            | 182 ++++++++++++
 example/collections/set.ts            | 123 +++++++++
 example/custom/index.ts               |   2 -
 example/custom/intersectAllOf.ts      |  21 --
 example/custom/unionOneOf.ts          |  17 --
 example/extensions/index.ts           |  31 +++
 example/extensions/intersect-allof.ts |  60 ++++
 example/extensions/union-enum.ts      |  46 ++++
 example/extensions/union-oneof.ts     |  47 ++++
 example/index.ts                      |   2 +-
 hammer.mjs                            |   2 +-
 13 files changed, 903 insertions(+), 42 deletions(-)
 create mode 100644 example/collections/array.ts
 create mode 100644 example/collections/index.ts
 create mode 100644 example/collections/map.ts
 create mode 100644 example/collections/set.ts
 delete mode 100644 example/custom/index.ts
 delete mode 100644 example/custom/intersectAllOf.ts
 delete mode 100644 example/custom/unionOneOf.ts
 create mode 100644 example/extensions/index.ts
 create mode 100644 example/extensions/intersect-allof.ts
 create mode 100644 example/extensions/union-enum.ts
 create mode 100644 example/extensions/union-oneof.ts

diff --git a/example/collections/array.ts b/example/collections/array.ts
new file mode 100644
index 000000000..66a255a5c
--- /dev/null
+++ b/example/collections/array.ts
@@ -0,0 +1,381 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/collections
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TypeCheck, TypeCompiler, ValueError } from '@sinclair/typebox/compiler'
+import { TSchema, Static } from '@sinclair/typebox'
+import { Value } from '@sinclair/typebox/value'
+
+// ----------------------------------------------------------------
+// TypeArrayError
+// ----------------------------------------------------------------
+
+export class TypeArrayError extends Error {
+  constructor(message: string) {
+    super(`${message}`)
+  }
+}
+export class TypeArrayLengthError extends Error {
+  constructor() {
+    super('arrayLength not a number')
+  }
+}
+
+// ----------------------------------------------------------------
+// TypeArray<T>
+// ----------------------------------------------------------------
+
+export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
+  readonly #typeCheck: TypeCheck<T>
+  readonly #values: Static<T>[]
+
+  constructor(schema: T, arrayLength: number = 0) {
+    if (typeof arrayLength !== 'number') throw new TypeArrayLengthError()
+    this.#typeCheck = TypeCompiler.Compile(schema)
+    this.#values = new Array(arrayLength)
+    for (let i = 0; i < arrayLength; i++) {
+      this.#values[i] = Value.Create(schema)
+    }
+  }
+
+  // ---------------------------------------------------
+  // Indexer
+  // ---------------------------------------------------
+
+  /** Sets the value at the given index */
+  public set(index: number, item: Static<T>): void {
+    this.#assertIndexInBounds(index)
+    this.#assertItem(index, item)
+    this.#values[index] = item
+  }
+
+  // ---------------------------------------------------
+  // Array<T>
+  // ---------------------------------------------------
+
+  /** Iterator for values in this array */
+  public [Symbol.iterator](): IterableIterator<Static<T>> {
+    return this.#values[Symbol.iterator]() as IterableIterator<T>
+  }
+
+  /** Gets the value at the given index */
+  public at(index: number): Static<T> {
+    this.#assertIndexInBounds(index)
+    return this.#values[index] as T
+  }
+
+  /**
+   * Gets the length of the array. This is a number one higher than the highest index in the array.
+   */
+  public get length(): number {
+    return this.#values.length
+  }
+  /**
+   * Returns a string representation of an array.
+   */
+  public toString(): string {
+    return this.#values.toString()
+  }
+  /**
+   * Returns a string representation of an array. The elements are converted to string using their toLocaleString methods.
+   */
+  public toLocaleString(): string {
+    return this.#values.toLocaleString()
+  }
+
+  /**
+   * Removes the last element from an array and returns it.
+   * If the array is empty, undefined is returned and the array is not modified.
+   */
+  public pop(): Static<T> | undefined {
+    return this.#values.pop()
+  }
+  /**
+   * Appends new elements to the end of an array, and returns the new length of the array.
+   * @param items New elements to add to the array.
+   */
+  public push(...items: Static<T>[]): number {
+    this.#assertItems(items)
+    return this.#values.push(...items)
+  }
+  /**
+   * Combines two or more arrays.
+   * This method returns a new array without modifying any existing arrays.
+   * @param items Additional arrays and/or items to add to the end of the array.
+   */
+  public concat(...items: ConcatArray<Static<T>>[]): Static<T>[]
+
+  /**
+   * Combines two or more arrays.
+   * This method returns a new array without modifying any existing arrays.
+   * @param items Additional arrays and/or items to add to the end of the array.
+   */
+  public concat(...items: (T | ConcatArray<Static<T>>)[]): Static<T>[] {
+    this.#assertItems(items)
+    return this.#values.concat(...items) as Static<T>[]
+  }
+
+  /**
+   * Adds all the elements of an array into a string, separated by the specified separator string.
+   * @param separator A string used to separate one element of the array from the next in the resulting string. If omitted, the array elements are separated with a comma.
+   */
+  public join(separator?: string): string {
+    return this.#values.join(separator)
+  }
+  /**
+   * Reverses the elements in an array in place.
+   * This method mutates the array and returns a reference to the same array.
+   */
+  public reverse(): Static<T>[] {
+    return this.#values.reverse() as Static<T>[]
+  }
+  /**
+   * Removes the first element from an array and returns it.
+   * If the array is empty, undefined is returned and the array is not modified.
+   */
+  public shift(): Static<T> | undefined {
+    return this.#values.shift() as Static<T> | undefined
+  }
+
+  /**
+   * Returns a copy of a section of an array.
+   * For both start and end, a negative index can be used to indicate an offset from the end of the array.
+   * For example, -2 refers to the second to last element of the array.
+   * @param start The beginning index of the specified portion of the array.
+   * If start is undefined, then the slice begins at index 0.
+   * @param end The end index of the specified portion of the array. This is exclusive of the element at the index 'end'.
+   * If end is undefined, then the slice extends to the end of the array.
+   */
+  public slice(start?: number, end?: number): Static<T>[] {
+    return this.#values.slice(start, end) as Static<T>[]
+  }
+
+  /**
+   * Sorts an array in place.
+   * This method mutates the array and returns a reference to the same array.
+   * @param compareFn Function used to determine the order of the elements. It is expected to return
+   * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
+   * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+   * ```ts
+   * [11,2,22,1].sort((a, b) => a - b)
+   * ```
+   */
+  public sort(compareFn?: (a: Static<T>, b: Static<T>) => number): this {
+    this.#values.sort(compareFn as any)
+    return this
+  }
+
+  /**
+   * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
+   * @param start The zero-based location in the array from which to start removing elements.
+   * @param deleteCount The number of elements to remove.
+   * @returns An array containing the elements that were deleted.
+   */
+  public splice(start: number, deleteCount?: number): Static<T>[]
+
+  /**
+   * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
+   * @param start The zero-based location in the array from which to start removing elements.
+   * @param deleteCount The number of elements to remove.
+   * @param items Elements to insert into the array in place of the deleted elements.
+   * @returns An array containing the elements that were deleted.
+   */
+  public splice(start: number, deleteCount: number, ...items: Static<T>[]): Static<T>[] {
+    this.#assertItems(items)
+    return this.#values.splice(start, deleteCount, items) as Static<T>[]
+  }
+
+  /**
+   * Inserts new elements at the start of an array, and returns the new length of the array.
+   * @param items Elements to insert at the start of the array.
+   */
+  public unshift(...items: Static<T>[]): number {
+    this.#assertItems(items)
+    return this.#values.unshift(items)
+  }
+
+  /**
+   * Returns the index of the first occurrence of a value in an array, or -1 if it is not present.
+   * @param searchElement The value to locate in the array.
+   * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
+   */
+  public indexOf(searchElement: Static<T>, fromIndex?: number): number {
+    return this.#values.indexOf(searchElement, fromIndex)
+  }
+
+  /**
+   * Returns the index of the last occurrence of a specified value in an array, or -1 if it is not present.
+   * @param searchElement The value to locate in the array.
+   * @param fromIndex The array index at which to begin searching backward. If fromIndex is omitted, the search starts at the last index in the array.
+   */
+  public lastIndexOf(searchElement: Static<T>, fromIndex?: number): number {
+    return this.#values.lastIndexOf(searchElement, fromIndex)
+  }
+
+  /**
+   * Determines whether all the members of an array satisfy the specified test.
+   * @param predicate A function that accepts up to three arguments. The every method calls
+   * the predicate function for each element in the array until the predicate returns a value
+   * which is coercible to the Boolean value false, or until the end of the array.
+   * @param thisArg An object to which the this keyword can refer in the predicate function.
+   * If thisArg is omitted, undefined is used as the this value.
+   */
+  public every<S extends T>(predicate: (value: Static<T>, index: number, array: Static<T>[]) => value is Static<S>, thisArg?: any): this is Static<S>[]
+
+  /**
+   * Determines whether all the members of an array satisfy the specified test.
+   * @param predicate A function that accepts up to three arguments. The every method calls
+   * the predicate function for each element in the array until the predicate returns a value
+   * which is coercible to the Boolean value false, or until the end of the array.
+   * @param thisArg An object to which the this keyword can refer in the predicate function.
+   * If thisArg is omitted, undefined is used as the this value.
+   */
+  public every(predicate: (value: Static<T>, index: number, array: Static<T>[]) => unknown, thisArg?: any): boolean {
+    return this.#values.every(predicate as any, thisArg)
+  }
+
+  /**
+   * Determines whether the specified callback function returns true for any element of an array.
+   * @param predicate A function that accepts up to three arguments. The some method calls
+   * the predicate function for each element in the array until the predicate returns a value
+   * which is coercible to the Boolean value true, or until the end of the array.
+   * @param thisArg An object to which the this keyword can refer in the predicate function.
+   * If thisArg is omitted, undefined is used as the this value.
+   */
+  public some(predicate: (value: Static<T>, index: number, array: T[]) => unknown, thisArg?: any): boolean {
+    return this.#values.some(predicate as any, thisArg)
+  }
+
+  /**
+   * Performs the specified action for each element in an array.
+   * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
+   * @param thisArg  An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+   */
+  public forEach(callbackfn: (value: Static<T>, index: number, array: Static<T>[]) => void, thisArg?: any): void {
+    return this.#values.forEach(callbackfn as any, thisArg)
+  }
+  /**
+   * Calls a defined callback function on each element of an array, and returns an array that contains the results.
+   * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
+   * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+   */
+  public map<U>(callbackfn: (value: Static<T>, index: number, array: Static<T>[]) => U, thisArg?: any): U[] {
+    return this.#values.map(callbackfn as any, thisArg)
+  }
+
+  /**
+   * Returns the elements of an array that meet the condition specified in a callback function.
+   * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.
+   * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
+   */
+  public filter<S extends T>(predicate: (value: Static<T>, index: number, array: Static<T>[]) => value is Static<S>, thisArg?: any): Static<S>[]
+  /**
+   * Returns the elements of an array that meet the condition specified in a callback function.
+   * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.
+   * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
+   */
+  public filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]
+  public filter(predicate: any, thisArg: any): any {
+    return this.#values.filter(predicate as any, thisArg)
+  }
+
+  /**
+   * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
+   * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
+   * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
+   */
+  public reduce(callbackfn: (previousValue: Static<T>, currentValue: Static<T>, currentIndex: number, array: T[]) => Static<T>): Static<T>
+  public reduce(callbackfn: (previousValue: Static<T>, currentValue: Static<T>, currentIndex: number, array: T[]) => Static<T>, initialValue: Static<T>): Static<T>
+  /**
+   * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
+   * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
+   * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
+   */
+  public reduce<U>(callbackfn: (previousValue: U, currentValue: Static<T>, currentIndex: number, array: Static<T>[]) => U, initialValue: U): U
+  public reduce(callbackfn: any, initialValue?: any): any {
+    return this.#values.reduce(callbackfn, initialValue)
+  }
+  /**
+   * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
+   * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
+   * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
+   */
+  public reduceRight(callbackfn: (previousValue: Static<T>, currentValue: Static<T>, currentIndex: number, array: Static<T>[]) => Static<T>): Static<T>
+  public reduceRight(callbackfn: (previousValue: Static<T>, currentValue: Static<T>, currentIndex: number, array: Static<T>[]) => Static<T>, initialValue: T): Static<T>
+  /**
+   * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
+   * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
+   * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
+   */
+  public reduceRight<U>(callbackfn: (previousValue: U, currentValue: Static<T>, currentIndex: number, array: Static<T>[]) => U, initialValue: U): U
+  public reduceRight(callbackfn: any, initialValue?: any): any {
+    return this.#values.reduceRight(callbackfn, initialValue)
+  }
+
+  // ---------------------------------------------------
+  // Assertions
+  // ---------------------------------------------------
+
+  #formatError(errors: ValueError[]) {
+    return errors.map((error) => `${error.message} ${error.path}`).join('. ')
+  }
+  /** Asserts the given values */
+  #assertIndexInBounds(index: number) {
+    if (index >= 0 && index < this.#values.length) return
+    throw new TypeArrayError(`Index ${index} is outside the bounds of this Array.`)
+  }
+
+  /** Asserts the given values */
+  #assertItem(index: number, item: unknown): asserts item is Static<T> {
+    if (this.#typeCheck.Check(item)) return
+    const message = this.#formatError([...this.#typeCheck.Errors(item)])
+    throw new TypeArrayError(`Item at Index ${index} is invalid. ${message}`)
+  }
+
+  /** Asserts the given values */
+  #assertItems(items: unknown[]): asserts items is Static<T>[] {
+    for (let i = 0; i < items.length; i++) {
+      this.#assertItem(i, items[i])
+    }
+  }
+
+  /** Creates a typed array from an existing array */
+  public static from<T extends TSchema>(schema: T, iterable: IterableIterator<Static<T>> | Array<Static<T>>): TypeArray<T> {
+    if (globalThis.Array.isArray(iterable)) {
+      const array = new TypeArray(schema, iterable.length)
+      for (let i = 0; i < iterable.length; i++) {
+        array.set(i, iterable[i])
+      }
+      return array
+    }
+    const array = new TypeArray(schema)
+    for (const value of iterable) {
+      array.push(value)
+    }
+    return array
+  }
+}
diff --git a/example/collections/index.ts b/example/collections/index.ts
new file mode 100644
index 000000000..004ddbfb5
--- /dev/null
+++ b/example/collections/index.ts
@@ -0,0 +1,31 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/collections
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './array'
+export * from './map'
+export * from './set'
diff --git a/example/collections/map.ts b/example/collections/map.ts
new file mode 100644
index 000000000..040bd5fa7
--- /dev/null
+++ b/example/collections/map.ts
@@ -0,0 +1,182 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/collections
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TypeCheck, TypeCompiler, ValueError } from '@sinclair/typebox/compiler'
+import { TSchema, Static } from '@sinclair/typebox'
+import { Value } from '@sinclair/typebox/value'
+
+// ----------------------------------------------------------------
+// TypeMapKeyError
+// ----------------------------------------------------------------
+
+export class TypeMapKeyError extends Error {
+  constructor(message: string) {
+    super(`${message} for key`)
+  }
+}
+
+// ----------------------------------------------------------------
+// TypeMapKeyError
+// ----------------------------------------------------------------
+
+export class TypeMapValueError extends Error {
+  constructor(key: unknown, message: string) {
+    super(`${message} for key ${JSON.stringify(key)}`)
+  }
+}
+
+// ----------------------------------------------------------------
+// TypeMap<K, V>
+// ----------------------------------------------------------------
+
+// prettier-ignore
+type TypeMapEntries<K extends TSchema, V extends TSchema> =
+  | Iterable<[Static<K>, Static<V>]> 
+  | Array<[Static<K>, Static<V>]>
+
+/** Runtime type checked Map collection */
+export class TypeMap<K extends TSchema, V extends TSchema> {
+  readonly #keycheck: TypeCheck<K>
+  readonly #valuecheck: TypeCheck<V>
+  readonly #keys: Map<bigint, Static<K>>
+  readonly #values: Map<bigint, Static<V>>
+
+  /** Constructs a new HashMap of the given key and value types. */
+  constructor(key: K, value: V, entries: TypeMapEntries<K, V> = []) {
+    this.#keycheck = TypeCompiler.Compile(key)
+    this.#valuecheck = TypeCompiler.Compile(value)
+    this.#keys = new Map<bigint, Static<K>>()
+    this.#values = new Map<bigint, Static<V>>()
+    for (const [key, value] of entries) {
+      this.set(key, value)
+    }
+  }
+
+  /** Iterator for this TypeMap */
+  public *[Symbol.iterator](): IterableIterator<[Static<K>, Static<V>]> {
+    for (const [key, value] of this.#values) {
+      yield [this.#keys.get(key)!, value]
+    }
+  }
+
+  /** Iterator for the keys in this TypeMap */
+  public *keys(): IterableIterator<Static<K>> {
+    yield* this.#keys.values()
+  }
+
+  /** Iterator for the values in this TypeMap */
+  public *values(): IterableIterator<Static<V>> {
+    yield* this.#values.values()
+  }
+
+  /** Clears all entries in this map */
+  public clear(): void {
+    this.#values.clear()
+    this.#keys.clear()
+  }
+
+  /** Executes a provided function once per each key/value pair in the Map, in insertion order. */
+  public forEach(callbackfn: (value: Static<V>, key: Static<K>, map: TypeMap<K, V>) => void, thisArg?: any): void {
+    this.#values.forEach((value, key) => callbackfn(value, this.#keys.get(key)!, this))
+  }
+
+  /** @returns the number of elements in the TypeMap. */
+  public get size(): number {
+    return this.#values.size
+  }
+
+  /**
+   * @returns boolean indicating whether an element with the specified key exists or not.
+   */
+  public has(key: Static<K>): boolean {
+    this.#assertKey(key)
+    return this.#values.has(this.#encodeKey(key))
+  }
+
+  /**
+   * Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.
+   * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
+   */
+  public get(key: Static<K>): Static<V> | undefined {
+    this.#assertKey(key)
+    return this.#values.get(this.#encodeKey(key))!
+  }
+
+  /**
+   * Adds a new element with a specified key and value to the Map. If an element with the same key already exists, the element will be updated.
+   */
+  public set(key: Static<K>, value: Static<V>) {
+    this.#assertKey(key)
+    this.#assertValue(key, value)
+    const encodedKey = this.#encodeKey(key)
+    this.#keys.set(encodedKey, key)
+    this.#values.set(encodedKey, value)
+  }
+
+  /**
+   * @returns true if an element in the Map existed and has been removed, or false if the element does not exist.
+   */
+  public delete(key: Static<K>): boolean {
+    this.#assertKey(key)
+    const encodedKey = this.#encodeKey(key)
+    this.#keys.delete(encodedKey)
+    return this.#values.delete(encodedKey)
+  }
+
+  // ---------------------------------------------------
+  // Encoder
+  // ---------------------------------------------------
+
+  /** Encodes the key as a 64bit numeric */
+  #encodeKey(key: Static<K>) {
+    return Value.Hash(key)
+  }
+
+  // ---------------------------------------------------
+  // Assertions
+  // ---------------------------------------------------
+
+  #formatError(errors: ValueError[]) {
+    return errors
+      .map((error) => `${error.message} ${error.path}`)
+      .join('. ')
+      .trim()
+  }
+
+  /** Asserts the key matches the key schema  */
+  #assertKey(key: unknown): asserts key is Static<K> {
+    if (this.#keycheck.Check(key)) return
+    throw new TypeMapKeyError(this.#formatError([...this.#keycheck.Errors(key)]))
+  }
+
+  /** Asserts the key matches the value schema  */
+  #assertValue(key: Static<K>, value: unknown): asserts value is Static<V> {
+    if (this.#valuecheck.Check(value)) return
+    throw new TypeMapValueError(key, this.#formatError([...this.#valuecheck.Errors(value)]))
+  }
+}
diff --git a/example/collections/set.ts b/example/collections/set.ts
new file mode 100644
index 000000000..aa83c5d26
--- /dev/null
+++ b/example/collections/set.ts
@@ -0,0 +1,123 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/collections
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TypeCheck, TypeCompiler, ValueError } from '@sinclair/typebox/compiler'
+import { TSchema, Static } from '@sinclair/typebox'
+import { Value } from '@sinclair/typebox/value'
+
+// ----------------------------------------------------------------
+// TypeSetError
+// ----------------------------------------------------------------
+
+export class TypeSetError extends Error {
+  constructor(message: string) {
+    super(`${message}`)
+  }
+}
+
+// ----------------------------------------------------------------
+// TypeSet
+// ----------------------------------------------------------------
+
+/** Runtime type checked Set collection */
+export class TypeSet<T extends TSchema> {
+  readonly #valuecheck: TypeCheck<T>
+  readonly values: Map<bigint, Static<T>>
+  constructor(schema: T, iterable: Array<T> | Iterable<T> = []) {
+    this.#valuecheck = TypeCompiler.Compile(schema)
+    this.values = new Map<bigint, Static<T>>()
+    for (const value of iterable) {
+      this.add(value)
+    }
+  }
+
+  /** Adds a value to this set */
+  public add(value: Static<T>): this {
+    this.#assertValue(value)
+    this.values.set(this.#encodeKey(value), value)
+    return this
+  }
+
+  /** Clears the values in this set */
+  public clear(): void {
+    this.values.clear()
+  }
+
+  /**
+   * Removes a specified value from the Set.
+   * @returns Returns true if an element in the Set existed and has been removed, or false if the element does not exist.
+   */
+  public delete(value: Static<T>): boolean {
+    return this.values.delete(this.#encodeKey(value))
+  }
+
+  /** Executes a provided function once per each value in the Set object, in insertion order. */
+  public forEach(callbackfn: (value: Static<T>, value2: Static<T>, set: TypeSet<T>) => void, thisArg?: any): void {
+    this.values.forEach((value, value2) => callbackfn(value, value2, this), thisArg)
+  }
+
+  /**
+   * @returns a boolean indicating whether an element with the specified value exists in the Set or not.
+   */
+  public has(value: Static<T>): boolean {
+    return this.values.has(this.#encodeKey(value))
+  }
+
+  /**
+   * @returns the number of (unique) elements in Set.
+   */
+  public get size(): number {
+    return this.values.size
+  }
+
+  // ---------------------------------------------------
+  // Encoder
+  // ---------------------------------------------------
+
+  #encodeKey(value: Static<T>) {
+    return Value.Hash(value)
+  }
+
+  // ---------------------------------------------------
+  // Assertions
+  // ---------------------------------------------------
+
+  /** Formats errors */
+  #formatError(errors: ValueError[]) {
+    return errors
+      .map((error) => `${error.message} ${error.path}`)
+      .join('. ')
+      .trim()
+  }
+
+  /** Asserts the key matches the value schema  */
+  #assertValue(value: unknown): asserts value is Static<T> {
+    if (this.#valuecheck.Check(value)) return
+    throw new TypeSetError(this.#formatError([...this.#valuecheck.Errors(value)]))
+  }
+}
diff --git a/example/custom/index.ts b/example/custom/index.ts
deleted file mode 100644
index 7f9f50c3c..000000000
--- a/example/custom/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export * from './intersectAllOf'
-export * from './unionOneOf'
\ No newline at end of file
diff --git a/example/custom/intersectAllOf.ts b/example/custom/intersectAllOf.ts
deleted file mode 100644
index 4b8e24efe..000000000
--- a/example/custom/intersectAllOf.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import { Kind, TSchema, SchemaOptions, IntersectReduce, IntersectEvaluate } from '@sinclair/typebox'
-import { Custom } from '@sinclair/typebox/custom'
-import { Value } from '@sinclair/typebox/value'
-
-export interface IntersectAllOfOptions extends SchemaOptions {
-  unevaluatedProperties?: boolean
-}
-
-export interface IntersectAllOf<T extends TSchema[]> extends TSchema, IntersectAllOfOptions {
-  [Kind]: 'IntersectAllOf',
-  static: IntersectReduce<unknown, IntersectEvaluate<T, []>>
-  allOf: T
-}
-
-/** Creates a Intersect type with a allOf  schema representation */
-export function IntersectAllOf<T extends TSchema[]>(allOf: [...T], options: IntersectAllOfOptions = {}) {
-  if(!Custom.Has('IntersectAllOf')) Custom.Set('IntersectAllOf', (schema: { allOf: TSchema[] }, value) => {
-    return schema.allOf.every(schema => Value.Check(schema, value))
-  })
-  return { ...options, [Kind]: 'IntersectAllOf', allOf } as IntersectAllOf<T>
-}
\ No newline at end of file
diff --git a/example/custom/unionOneOf.ts b/example/custom/unionOneOf.ts
deleted file mode 100644
index 0db14c59d..000000000
--- a/example/custom/unionOneOf.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { Kind, TSchema, SchemaOptions, Static } from '@sinclair/typebox'
-import { Custom } from '@sinclair/typebox/custom'
-import { Value } from '@sinclair/typebox/value'
-
-export interface UnionOneOf<T extends TSchema[]> extends TSchema {
-    [Kind]: 'UnionOneOf',
-    static: { [K in keyof T]: Static<T[K]> }[number]
-    oneOf: T
-}
-
-/** Creates a Union type with a oneOf schema representation */
-export function UnionOneOf<T extends TSchema[]>(oneOf: [...T], options: SchemaOptions = {}) {
-    if (!Custom.Has('UnionOneOf')) Custom.Set('UnionOneOf', (schema: { oneOf: TSchema[] }, value) => {
-        return 1 === schema.oneOf.reduce((acc: number, schema: any) => (Value.Check(schema, value) ? acc + 1 : acc), 0)
-    })
-    return { [Kind]: 'UnionOneOf', oneOf } as UnionOneOf<T>
-}
diff --git a/example/extensions/index.ts b/example/extensions/index.ts
new file mode 100644
index 000000000..a8ff621e5
--- /dev/null
+++ b/example/extensions/index.ts
@@ -0,0 +1,31 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/extensions
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './intersect-allof'
+export * from './union-oneof'
+export * from './union-enum'
diff --git a/example/extensions/intersect-allof.ts b/example/extensions/intersect-allof.ts
new file mode 100644
index 000000000..7cf413e73
--- /dev/null
+++ b/example/extensions/intersect-allof.ts
@@ -0,0 +1,60 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/extensions
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Kind, TSchema, SchemaOptions, IntersectReduce, IntersectEvaluate } from '@sinclair/typebox'
+import { TypeGuard } from '@sinclair/typebox/guard'
+import { Custom } from '@sinclair/typebox/custom'
+import { Value } from '@sinclair/typebox/value'
+
+function IntersectAllOfCheck(schema: IntersectAllOf<TSchema[]>, value: unknown) {
+  if (!schema.allOf.every((schema) => Value.Check(schema, value))) return false
+  if (schema.unevaluatedProperties === undefined || schema.unevaluatedProperties === true) return true
+  const valueKeys = typeof value === 'object' && value !== null ? globalThis.Object.keys(value) : []
+  const knownKeys = schema.allOf.reduce((set, schema) => {
+    if (!TypeGuard.TObject(schema)) return set
+    Object.keys(schema.properties).forEach((key) => set.add(key))
+    return set
+  }, new Set<string>())
+  return valueKeys.every((key) => knownKeys.has(key))
+}
+
+export interface IntersectAllOfOptions extends SchemaOptions {
+  unevaluatedProperties?: boolean
+}
+
+export interface IntersectAllOf<T extends TSchema[]> extends TSchema, IntersectAllOfOptions {
+  [Kind]: 'IntersectAllOf'
+  static: IntersectReduce<unknown, IntersectEvaluate<T, []>>
+  allOf: T
+}
+
+/** Creates a Intersect type with a `allOf` schema representation */
+export function IntersectAllOf<T extends TSchema[]>(allOf: [...T], options: IntersectAllOfOptions = {}) {
+  if (!Custom.Has('IntersectAllOf')) Custom.Set('IntersectAllOf', IntersectAllOfCheck)
+  return { ...options, [Kind]: 'IntersectAllOf', allOf } as IntersectAllOf<T>
+}
diff --git a/example/extensions/union-enum.ts b/example/extensions/union-enum.ts
new file mode 100644
index 000000000..ac895338e
--- /dev/null
+++ b/example/extensions/union-enum.ts
@@ -0,0 +1,46 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/extensions
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Kind, TSchema, SchemaOptions } from '@sinclair/typebox'
+import { Custom } from '@sinclair/typebox/custom'
+
+function UnionEnumCheck(schema: TUnionEnum<(string | number)[]>, value: unknown) {
+  return (typeof value === 'string' || typeof value === 'number') && schema.enum.includes(value)
+}
+
+export interface TUnionEnum<T extends (string | number)[]> extends TSchema {
+  [Kind]: 'UnionEnum'
+  static: T[number]
+  enum: T
+}
+
+/** Creates a Union type with a `enum` schema representation  */
+export function UnionEnum<T extends (string | number)[]>(values: [...T], options: SchemaOptions = {}) {
+  if (!Custom.Has('UnionEnum')) Custom.Set('UnionEnum', UnionEnumCheck)
+  return { ...options, [Kind]: 'UnionEnum', enum: values } as TUnionEnum<T>
+}
diff --git a/example/extensions/union-oneof.ts b/example/extensions/union-oneof.ts
new file mode 100644
index 000000000..c40a9f9b5
--- /dev/null
+++ b/example/extensions/union-oneof.ts
@@ -0,0 +1,47 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/extensions
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Kind, TSchema, SchemaOptions, Static } from '@sinclair/typebox'
+import { Custom } from '@sinclair/typebox/custom'
+import { Value } from '@sinclair/typebox/value'
+
+function UnionOneOfCheck(schema: UnionOneOf<TSchema[]>, value: unknown) {
+  return 1 === schema.oneOf.reduce((acc: number, schema: any) => (Value.Check(schema, value) ? acc + 1 : acc), 0)
+}
+
+export interface UnionOneOf<T extends TSchema[]> extends TSchema {
+  [Kind]: 'UnionOneOf'
+  static: { [K in keyof T]: Static<T[K]> }[number]
+  oneOf: T
+}
+
+/** Creates a Union type with a `oneOf` schema representation */
+export function UnionOneOf<T extends TSchema[]>(oneOf: [...T], options: SchemaOptions = {}) {
+  if (!Custom.Has('UnionOneOf')) Custom.Set('UnionOneOf', UnionOneOfCheck)
+  return { ...options, [Kind]: 'UnionOneOf', oneOf } as UnionOneOf<T>
+}
diff --git a/example/index.ts b/example/index.ts
index dee703c07..dfde052cf 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -15,4 +15,4 @@ const T = Type.Object({
 
 type T = Static<typeof T>
 
-console.log(T)
\ No newline at end of file
+console.log(T)
diff --git a/hammer.mjs b/hammer.mjs
index 34b412fca..19e88cee3 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -15,7 +15,7 @@ export async function clean() {
 // -------------------------------------------------------------------------------
 
 export async function format() {
-    await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test benchmark codegen')
+    await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test example benchmark codegen')
 }
 
 // -------------------------------------------------------------------------------

From 1cb07ad032d1afcd44efbc55139f0e88e87ecc4f Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Mon, 19 Dec 2022 15:30:14 +0900
Subject: [PATCH 050/369] Example String Formats

---
 example/formats/additional.ts | 94 +++++++++++++++++++++++++++++++++++
 example/formats/index.ts      |  1 +
 2 files changed, 95 insertions(+)
 create mode 100644 example/formats/additional.ts
 create mode 100644 example/formats/index.ts

diff --git a/example/formats/additional.ts b/example/formats/additional.ts
new file mode 100644
index 000000000..60396d3cf
--- /dev/null
+++ b/example/formats/additional.ts
@@ -0,0 +1,94 @@
+import { Format } from '@sinclair/typebox/format'
+
+/** Configures TypeBox for additional string formats */
+export namespace AdditionalFormats {
+  // -------------------------------------------------------------------------------------------
+  // These formats are ported from the ajv-formats library. All credit goes to the original
+  // authors with the original code located at the following location.
+  //
+  // https://github.com/ajv-validator/ajv-formats/blob/master/src/formats.ts
+  // -------------------------------------------------------------------------------------------
+
+  const UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i
+  const DATE_TIME_SEPARATOR = /t|\s/i
+  const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i
+  const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/
+  const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+  const IPV4 = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/
+  const IPV6 =
+    /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i
+  const URL =
+    /^(?:https?|wss?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu
+  const EMAIL = /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i
+
+  function IsLeapYear(year: number): boolean {
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)
+  }
+
+  function IsDate(str: string): boolean {
+    const matches: string[] | null = DATE.exec(str)
+    if (!matches) return false
+    const year: number = +matches[1]
+    const month: number = +matches[2]
+    const day: number = +matches[3]
+    return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && IsLeapYear(year) ? 29 : DAYS[month])
+  }
+
+  function IsTime(str: string, strictTimeZone?: boolean): boolean {
+    const matches: string[] | null = TIME.exec(str)
+    if (!matches) return false
+    const hr: number = +matches[1]
+    const min: number = +matches[2]
+    const sec: number = +matches[3]
+    const tz: string | undefined = matches[4]
+    const tzSign: number = matches[5] === '-' ? -1 : 1
+    const tzH: number = +(matches[6] || 0)
+    const tzM: number = +(matches[7] || 0)
+    if (tzH > 23 || tzM > 59 || (strictTimeZone && !tz)) return false
+    if (hr <= 23 && min <= 59 && sec < 60) return true
+    // leap second
+    const utcMin = min - tzM * tzSign
+    const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0)
+    return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61
+  }
+
+  function IsDateTime(value: string, strictTimeZone?: boolean): boolean {
+    const dateTime: string[] = value.split(DATE_TIME_SEPARATOR)
+    return dateTime.length === 2 && IsDate(dateTime[0]) && IsTime(dateTime[1], strictTimeZone)
+  }
+
+  function IsEmail(value: string) {
+    return EMAIL.test(value)
+  }
+
+  function IsUuid(value: string) {
+    return UUID.test(value)
+  }
+
+  function IsUrl(value: string) {
+    return URL.test(value)
+  }
+
+  function IsIPv6(value: string) {
+    return IPV6.test(value)
+  }
+
+  function IsIPv4(value: string) {
+    return IPV4.test(value)
+  }
+
+  /** Configures additional string formats */
+  export function Configure(): void {
+    Format.Set('date-time', (value) => IsDateTime(value, true))
+    Format.Set('date', (value) => IsDate(value))
+    Format.Set('time', (value) => IsTime(value))
+    Format.Set('email', (value) => IsEmail(value))
+    Format.Set('uuid', (value) => IsUuid(value))
+    Format.Set('url', (value) => IsUrl(value))
+    Format.Set('ipv6', (value) => IsIPv6(value))
+    Format.Set('ipv4', (value) => IsIPv4(value))
+    //
+    // optional: add additional formats
+    //
+  }
+}
diff --git a/example/formats/index.ts b/example/formats/index.ts
new file mode 100644
index 000000000..2923362e3
--- /dev/null
+++ b/example/formats/index.ts
@@ -0,0 +1 @@
+export * from './additional'

From 0ce824bfb391d36e5c18008938af2da2b101adfa Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 19 Dec 2022 22:50:32 +0900
Subject: [PATCH 051/369] Additional Defaults (#294)

---
 example/index.ts                       |  2 +-
 package.json                           |  2 +-
 src/value/create.ts                    | 24 ++++++++++++++++++++----
 test/runtime/value/create/literal.ts   |  6 +++++-
 test/runtime/value/create/null.ts      |  4 ++++
 test/runtime/value/create/undefined.ts |  4 ++++
 test/runtime/value/create/void.ts      |  5 +++++
 7 files changed, 40 insertions(+), 7 deletions(-)

diff --git a/example/index.ts b/example/index.ts
index dfde052cf..ec83c1476 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -10,7 +10,7 @@ import { Type, Kind, Static, TSchema } from '@sinclair/typebox'
 const T = Type.Object({
   x: Type.Number(),
   y: Type.Number(),
-  z: Type.Number()
+  z: Type.Number(),
 })
 
 type T = Static<typeof T>
diff --git a/package.json b/package.json
index bc74862d6..184b312a4 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.13",
+  "version": "0.25.14",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/create.ts b/src/value/create.ts
index ab4d33ad0..19469ced5 100644
--- a/src/value/create.ts
+++ b/src/value/create.ts
@@ -121,7 +121,11 @@ export namespace ValueCreate {
   }
 
   function Literal(schema: Types.TLiteral, references: Types.TSchema[]): any {
-    return schema.const
+    if (schema.default !== undefined) {
+      return schema.default
+    } else {
+      return schema.const
+    }
   }
 
   function Never(schema: Types.TNever, references: Types.TSchema[]): any {
@@ -129,7 +133,11 @@ export namespace ValueCreate {
   }
 
   function Null(schema: Types.TNull, references: Types.TSchema[]): any {
-    return null
+    if (schema.default !== undefined) {
+      return schema.default
+    } else {
+      return null
+    }
   }
 
   function Number(schema: Types.TNumber, references: Types.TSchema[]): any {
@@ -244,7 +252,11 @@ export namespace ValueCreate {
   }
 
   function Undefined(schema: Types.TUndefined, references: Types.TSchema[]): any {
-    return undefined
+    if (schema.default !== undefined) {
+      return schema.default
+    } else {
+      return undefined
+    }
   }
 
   function Union(schema: Types.TUnion<any[]>, references: Types.TSchema[]): any {
@@ -275,7 +287,11 @@ export namespace ValueCreate {
   }
 
   function Void(schema: Types.TVoid, references: Types.TSchema[]): any {
-    return null
+    if (schema.default !== undefined) {
+      return schema.default
+    } else {
+      return null
+    }
   }
 
   function UserDefined(schema: Types.TSchema, references: Types.TSchema[]): any {
diff --git a/test/runtime/value/create/literal.ts b/test/runtime/value/create/literal.ts
index 591799b39..d2913ab7f 100644
--- a/test/runtime/value/create/literal.ts
+++ b/test/runtime/value/create/literal.ts
@@ -2,7 +2,7 @@ import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('value/create/KeyOf', () => {
+describe('value/create/Literal', () => {
   it('Should create literal string', () => {
     const T = Type.Literal('hello')
     Assert.deepEqual(Value.Create(T), 'hello')
@@ -15,4 +15,8 @@ describe('value/create/KeyOf', () => {
     const T = Type.Literal(true)
     Assert.deepEqual(Value.Create(T), true)
   })
+  it('Should create literal from default value', () => {
+    const T = Type.Literal(true, { default: 'hello' })
+    Assert.deepEqual(Value.Create(T), 'hello')
+  })
 })
diff --git a/test/runtime/value/create/null.ts b/test/runtime/value/create/null.ts
index 4b11e6d1a..45c42fc86 100644
--- a/test/runtime/value/create/null.ts
+++ b/test/runtime/value/create/null.ts
@@ -7,4 +7,8 @@ describe('value/create/Null', () => {
     const T = Type.Null()
     Assert.deepEqual(Value.Create(T), null)
   })
+  it('Should create null from default value', () => {
+    const T = Type.Null({ default: 'hello' })
+    Assert.deepEqual(Value.Create(T), 'hello')
+  })
 })
diff --git a/test/runtime/value/create/undefined.ts b/test/runtime/value/create/undefined.ts
index 45e369ad4..b684204c6 100644
--- a/test/runtime/value/create/undefined.ts
+++ b/test/runtime/value/create/undefined.ts
@@ -7,4 +7,8 @@ describe('value/create/Undefined', () => {
     const T = Type.Undefined()
     Assert.deepEqual(Value.Create(T), undefined)
   })
+  it('Should create value from default value', () => {
+    const T = Type.Undefined({ default: 'hello' })
+    Assert.deepEqual(Value.Create(T), 'hello')
+  })
 })
diff --git a/test/runtime/value/create/void.ts b/test/runtime/value/create/void.ts
index eff8379a7..b74886656 100644
--- a/test/runtime/value/create/void.ts
+++ b/test/runtime/value/create/void.ts
@@ -7,4 +7,9 @@ describe('value/create/Void', () => {
     const T = Type.Void()
     Assert.deepEqual(Value.Create(T), null)
   })
+
+  it('Should create value from default value', () => {
+    const T = Type.Void({ default: 'hello' })
+    Assert.deepEqual(Value.Create(T), 'hello')
+  })
 })

From 34d6fb2ed1b823fb2117af7733d7f9f755e2c3b6 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 20 Dec 2022 11:45:17 +0900
Subject: [PATCH 052/369] Structural Value Checks (#295)

---
 example/index.ts                           | 19 +++----
 package.json                               |  3 +-
 src/compiler/compiler.ts                   | 27 ++++++----
 src/errors/errors.ts                       | 50 ++++++++++-------
 src/system/index.ts                        | 29 ++++++++++
 src/system/system.ts                       | 59 ++++++++++++++++++++
 src/value/cast.ts                          | 12 ++---
 src/value/check.ts                         | 36 +++++++++----
 test/runtime/compiler/any.ts               | 16 +++---
 test/runtime/compiler/array.ts             | 30 +++++------
 test/runtime/compiler/boolean.ts           | 18 +++----
 test/runtime/compiler/custom.ts            | 10 ++--
 test/runtime/compiler/date.ts              | 34 ++++++------
 test/runtime/compiler/enum.ts              | 28 +++++-----
 test/runtime/compiler/integer.ts           | 36 ++++++-------
 test/runtime/compiler/intersect.ts         | 44 +++++++--------
 test/runtime/compiler/keyof.ts             | 22 ++++----
 test/runtime/compiler/literal.ts           | 22 ++++----
 test/runtime/compiler/never.ts             | 16 +++---
 test/runtime/compiler/null.ts              | 16 +++---
 test/runtime/compiler/number.ts            | 36 ++++++-------
 test/runtime/compiler/object.ts            | 50 ++++++++---------
 test/runtime/compiler/omit.ts              |  8 +--
 test/runtime/compiler/optional.ts          |  6 +--
 test/runtime/compiler/partial.ts           | 10 ++--
 test/runtime/compiler/pick.ts              |  8 +--
 test/runtime/compiler/readonly-optional.ts |  6 +--
 test/runtime/compiler/readonly.ts          |  4 +-
 test/runtime/compiler/record.ts            | 36 ++++++-------
 test/runtime/compiler/recursive.ts         |  8 +--
 test/runtime/compiler/ref.ts               | 14 ++---
 test/runtime/compiler/regex.ts             | 32 +++++------
 test/runtime/compiler/required.ts          | 10 ++--
 test/runtime/compiler/string.ts            | 32 +++++------
 test/runtime/compiler/tuple.ts             | 20 +++----
 test/runtime/compiler/uint8array.ts        | 26 ++++-----
 test/runtime/compiler/union.ts             | 32 +++++------
 test/runtime/compiler/unknown.ts           | 16 +++---
 test/runtime/compiler/validate.ts          | 12 ++++-
 test/runtime/compiler/void.ts              | 16 +++---
 test/runtime/index.ts                      |  1 +
 test/runtime/schema/any.ts                 | 16 +++---
 test/runtime/schema/array.ts               | 30 +++++------
 test/runtime/schema/boolean.ts             | 18 +++----
 test/runtime/schema/date.ts                | 34 ++++++------
 test/runtime/schema/enum.ts                | 28 +++++-----
 test/runtime/schema/integer.ts             | 36 ++++++-------
 test/runtime/schema/intersect.ts           | 52 +++++++++---------
 test/runtime/schema/keyof.ts               | 22 ++++----
 test/runtime/schema/literal.ts             | 22 ++++----
 test/runtime/schema/never.ts               | 16 +++---
 test/runtime/schema/null.ts                | 16 +++---
 test/runtime/schema/number.ts              | 36 ++++++-------
 test/runtime/schema/object.ts              | 50 ++++++++---------
 test/runtime/schema/omit.ts                |  8 +--
 test/runtime/schema/optional.ts            |  6 +--
 test/runtime/schema/partial.ts             | 10 ++--
 test/runtime/schema/pick.ts                |  8 +--
 test/runtime/schema/readonly-optional.ts   |  6 +--
 test/runtime/schema/readonly.ts            |  4 +-
 test/runtime/schema/record.ts              | 36 ++++++-------
 test/runtime/schema/recursive.ts           |  8 +--
 test/runtime/schema/ref.ts                 | 14 ++---
 test/runtime/schema/regex.ts               | 32 +++++------
 test/runtime/schema/required.ts            | 10 ++--
 test/runtime/schema/string.ts              | 32 +++++------
 test/runtime/schema/tuple.ts               | 20 +++----
 test/runtime/schema/uint8array.ts          | 26 ++++-----
 test/runtime/schema/union.ts               | 32 +++++------
 test/runtime/schema/unknown.ts             | 16 +++---
 test/runtime/schema/unsafe.ts              |  6 +--
 test/runtime/schema/validate.ts            |  4 +-
 test/runtime/schema/void.ts                | 16 +++---
 test/runtime/settings/index.ts             |  1 +
 test/runtime/settings/structural.ts        | 62 ++++++++++++++++++++++
 tsconfig.json                              |  3 ++
 76 files changed, 923 insertions(+), 723 deletions(-)
 create mode 100644 src/system/index.ts
 create mode 100644 src/system/system.ts
 create mode 100644 test/runtime/settings/index.ts
 create mode 100644 test/runtime/settings/structural.ts

diff --git a/example/index.ts b/example/index.ts
index ec83c1476..c367f5f78 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -1,18 +1,19 @@
 import { CodeGen } from '@sinclair/typebox/codegen'
+import { TypeSystem } from '@sinclair/typebox/system'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
-import { Conditional } from '@sinclair/typebox/conditional'
 import { TypeGuard } from '@sinclair/typebox/guard'
+import { Conditional } from '@sinclair/typebox/conditional'
 import { Format } from '@sinclair/typebox/format'
 import { Custom } from '@sinclair/typebox/custom'
 import { Value, ValuePointer } from '@sinclair/typebox/value'
 import { Type, Kind, Static, TSchema } from '@sinclair/typebox'
 
 const T = Type.Object({
-  x: Type.Number(),
-  y: Type.Number(),
-  z: Type.Number(),
-})
-
-type T = Static<typeof T>
-
-console.log(T)
+    x: Type.Number(),
+    y: Type.Number(),
+    z: Type.Number(),
+  })
+  
+  type T = Static<typeof T>
+  
+  console.log(T)
\ No newline at end of file
diff --git a/package.json b/package.json
index 184b312a4..0b6dce662 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.14",
+  "version": "0.25.15",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -20,6 +20,7 @@
     "./format": "./format/index.js",
     "./guard": "./guard/index.js",
     "./hash": "./hash/index.js",
+    "./system": "./system/index.js",
     "./value": "./value/index.js",
     ".": "./typebox.js"
   },
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index df9dd4821..73c4814ca 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -27,6 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { ValueErrors, ValueError } from '../errors/index'
+import { TypeSystem } from '../system/index'
 import { TypeGuard } from '../guard/index'
 import { Format } from '../format/index'
 import { Custom } from '../custom/index'
@@ -185,26 +186,30 @@ export namespace TypeCompiler {
   }
 
   function* Object(schema: Types.TObject, value: string): IterableIterator<string> {
-    yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`
-    if (IsNumber(schema.minProperties)) yield `(Object.keys(${value}).length >= ${schema.minProperties})`
-    if (IsNumber(schema.maxProperties)) yield `(Object.keys(${value}).length <= ${schema.maxProperties})`
-    const propertyKeys = globalThis.Object.keys(schema.properties)
+    if (TypeSystem.Kind === 'json-schema') {
+      yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`
+    } else if (TypeSystem.Kind === 'structural') {
+      yield `(typeof ${value} === 'object' && ${value} !== null)`
+    }
+    if (IsNumber(schema.minProperties)) yield `(Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties})`
+    if (IsNumber(schema.maxProperties)) yield `(Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties})`
+    const propertyKeys = globalThis.Object.getOwnPropertyNames(schema.properties)
     if (schema.additionalProperties === false) {
       // Optimization: If the property key length matches the required keys length
       // then we only need check that the values property key length matches that
       // of the property key length. This is because exhaustive testing for values
       // will occur in subsequent property tests.
       if (schema.required && schema.required.length === propertyKeys.length) {
-        yield `(Object.keys(${value}).length === ${propertyKeys.length})`
+        yield `(Object.getOwnPropertyNames(${value}).length === ${propertyKeys.length})`
       } else {
         const keys = `[${propertyKeys.map((key) => `'${key}'`).join(', ')}]`
-        yield `(Object.keys(${value}).every(key => ${keys}.includes(key)))`
+        yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key)))`
       }
     }
     if (TypeGuard.TSchema(schema.additionalProperties)) {
       const expression = CreateExpression(schema.additionalProperties, 'value[key]')
       const keys = `[${propertyKeys.map((key) => `'${key}'`).join(', ')}]`
-      yield `(Object.keys(${value}).every(key => ${keys}.includes(key) || ${expression}))`
+      yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`
     }
     for (const propertyKey of propertyKeys) {
       const memberExpression = Property.Check(propertyKey) ? `${value}.${propertyKey}` : `${value}['${propertyKey}']`
@@ -223,10 +228,14 @@ export namespace TypeCompiler {
   }
 
   function* Record(schema: Types.TRecord<any, any>, value: string): IterableIterator<string> {
-    yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date))`
+    if (TypeSystem.Kind === 'json-schema') {
+      yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date))`
+    } else if (TypeSystem.Kind === 'structural') {
+      yield `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date))`
+    }
     const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
     const local = PushLocal(`new RegExp(/${keyPattern}/)`)
-    yield `(Object.keys(${value}).every(key => ${local}.test(key)))`
+    yield `(Object.getOwnPropertyNames(${value}).every(key => ${local}.test(key)))`
     const expression = CreateExpression(valueSchema, 'value')
     yield `(Object.values(${value}).every(value => ${expression}))`
   }
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index ed39446a8..36f774ab2 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -27,6 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import * as Types from '../typebox'
+import { TypeSystem } from '../system/index'
 import { Format } from '../format/index'
 import { Custom } from '../custom/index'
 import { ValueHash } from '../hash/index'
@@ -128,7 +129,7 @@ export namespace ValueErrors {
       yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` }
     }
     // prettier-ignore
-    if (schema.uniqueItems === true && !((function() { const set = new Set(); for(const element of value) { const hashed = ValueHash.Create(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())) {
+    if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) { const hashed = ValueHash.Create(element); if (set.has(hashed)) { return false } else { set.add(hashed) } } return true })())) {
       yield { type: ValueErrorType.ArrayUniqueItems, schema, path, value, message: `Expected array elements to be unique` }
     }
     for (let i = 0; i < value.length; i++) {
@@ -233,38 +234,43 @@ export namespace ValueErrors {
   }
 
   function* Object(schema: Types.TObject, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-      return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
+    if (TypeSystem.Kind === 'json-schema') {
+      if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+        return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
+      }
+    } else if (TypeSystem.Kind === 'structural') {
+      if (!(typeof value === 'object' && value !== null)) {
+        return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
+      }
     }
-    if (IsNumber(schema.minProperties) && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
+    if (IsNumber(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
       yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` }
     }
-    if (IsNumber(schema.maxProperties) && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
+    if (IsNumber(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
       yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` }
     }
-    const propertyKeys = globalThis.Object.keys(schema.properties)
+    const propertyNames = globalThis.Object.getOwnPropertyNames(schema.properties)
     if (schema.additionalProperties === false) {
-      for (const objectKey of globalThis.Object.keys(value)) {
-        if (!propertyKeys.includes(objectKey)) {
-          yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${objectKey}`, value: value[objectKey], message: `Unexpected property` }
+      for (const propertyName of globalThis.Object.getOwnPropertyNames(value)) {
+        if (!propertyNames.includes(propertyName)) {
+          yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${propertyName}`, value: value[propertyName], message: `Unexpected property` }
         }
       }
     }
-
     if (schema.required && schema.required.length > 0) {
-      const objectKeys = globalThis.Object.keys(value)
+      const propertyNames = globalThis.Object.getOwnPropertyNames(value)
       for (const requiredKey of schema.required) {
-        if (objectKeys.includes(requiredKey)) continue
+        if (propertyNames.includes(requiredKey)) continue
         yield { type: ValueErrorType.ObjectRequiredProperties, schema: schema.properties[requiredKey], path: `${path}/${requiredKey}`, value: undefined, message: `Expected required property` }
       }
     }
     if (typeof schema.additionalProperties === 'object') {
-      for (const objectKey of globalThis.Object.keys(value)) {
-        if (propertyKeys.includes(objectKey)) continue
-        yield* Visit(schema.additionalProperties as Types.TSchema, references, `${path}/${objectKey}`, value[objectKey])
+      for (const propertyName of globalThis.Object.getOwnPropertyNames(value)) {
+        if (propertyNames.includes(propertyName)) continue
+        yield* Visit(schema.additionalProperties as Types.TSchema, references, `${path}/${propertyName}`, value[propertyName])
       }
     }
-    for (const propertyKey of propertyKeys) {
+    for (const propertyKey of propertyNames) {
       const propertySchema = schema.properties[propertyKey]
       if (schema.required && schema.required.includes(propertyKey)) {
         yield* Visit(propertySchema, references, `${path}/${propertyKey}`, value[propertyKey])
@@ -283,12 +289,18 @@ export namespace ValueErrors {
   }
 
   function* Record(schema: Types.TRecord, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-      return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
+    if (TypeSystem.Kind === 'json-schema') {
+      if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value) && !(value instanceof globalThis.Date))) {
+        return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
+      }
+    } else if (TypeSystem.Kind === 'structural') {
+      if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date))) {
+        return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
+      }
     }
     const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
     const regex = new RegExp(keyPattern)
-    if (!globalThis.Object.keys(value).every((key) => regex.test(key))) {
+    if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {
       const numeric = keyPattern === '^(0|[1-9][0-9]*)$'
       const type = numeric ? ValueErrorType.RecordKeyNumeric : ValueErrorType.RecordKeyString
       const message = numeric ? 'Expected all object property keys to be numeric' : 'Expected all object property keys to be strings'
diff --git a/src/system/index.ts b/src/system/index.ts
new file mode 100644
index 000000000..9f65a6522
--- /dev/null
+++ b/src/system/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/system
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './system'
diff --git a/src/system/system.ts b/src/system/system.ts
new file mode 100644
index 000000000..b2985a72b
--- /dev/null
+++ b/src/system/system.ts
@@ -0,0 +1,59 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/system
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export class InvalidTypeSystemError extends Error {
+  constructor(typeSystem: string) {
+    super(`TypeSystemSettings: Unknown TypeSystem '${typeSystem}'`)
+  }
+}
+
+export type TypeSystemKind = 'json-schema' | 'structural'
+
+class TypeSystemSettings {
+  private kind: TypeSystemKind
+  constructor() {
+    this.kind = 'json-schema'
+  }
+  /**
+   * `Experimental` Sets the type system kind used by TypeBox. By default TypeBox uses `json-schema` assertion
+   * rules to verify JavaScript values. If setting the type system to `structural`, TypeBox will use TypeScript
+   * structural checking rules enabling Arrays to be validated as Objects.
+   */
+  public get Kind(): TypeSystemKind {
+    return this.kind
+  }
+  public set Kind(value: TypeSystemKind) {
+    if (!(value === 'json-schema' || value === 'structural')) {
+      throw new InvalidTypeSystemError(value)
+    }
+    this.kind = value
+  }
+}
+
+/** TypeBox TypeSystem Settings */
+export const TypeSystem = new TypeSystemSettings()
diff --git a/src/value/cast.ts b/src/value/cast.ts
index 3f085611b..5fccc466d 100644
--- a/src/value/cast.ts
+++ b/src/value/cast.ts
@@ -250,10 +250,10 @@ export namespace ValueCast {
     }
     // additional schema properties
     if (typeof schema.additionalProperties === 'object') {
-      const propertyKeys = globalThis.Object.keys(schema.properties)
-      for (const objectKey of globalThis.Object.keys(value)) {
-        if (propertyKeys.includes(objectKey)) continue
-        result[objectKey] = Visit(schema.additionalProperties, references, value[objectKey])
+      const propertyNames = globalThis.Object.getOwnPropertyNames(schema.properties)
+      for (const propertyName of globalThis.Object.getOwnPropertyNames(value)) {
+        if (propertyNames.includes(propertyName)) continue
+        result[propertyName] = Visit(schema.additionalProperties, references, value[propertyName])
       }
     }
     return result
@@ -266,8 +266,8 @@ export namespace ValueCast {
   function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): any {
     if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
     if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value) || value instanceof globalThis.Date) return ValueCreate.Create(schema, references)
-    const subschemaKey = globalThis.Object.keys(schema.patternProperties)[0]
-    const subschema = schema.patternProperties[subschemaKey]
+    const subschemaPropertyName = globalThis.Object.getOwnPropertyNames(schema.patternProperties)[0]
+    const subschema = schema.patternProperties[subschemaPropertyName]
     const result = {} as Record<string, any>
     for (const [propKey, propValue] of globalThis.Object.entries(value)) {
       result[propKey] = Visit(subschema, references, propValue)
diff --git a/src/value/check.ts b/src/value/check.ts
index f4f8d0f24..e1415462d 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -27,6 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import * as Types from '../typebox'
+import { TypeSystem } from '../system/index'
 import { Format } from '../format/index'
 import { Custom } from '../custom/index'
 import { ValueHash } from '../hash/index'
@@ -70,6 +71,7 @@ export namespace ValueCheck {
   function Constructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): boolean {
     return Visit(schema.returns, references, value.prototype)
   }
+
   function Date(schema: Types.TDate, references: Types.TSchema[], value: any): boolean {
     if (!(value instanceof globalThis.Date)) {
       return false
@@ -153,31 +155,37 @@ export namespace ValueCheck {
   }
 
   function Object(schema: Types.TObject, references: Types.TSchema[], value: any): boolean {
-    if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-      return false
+    if (TypeSystem.Kind === 'json-schema') {
+      if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+        return false
+      }
+    } else if (TypeSystem.Kind === 'structural') {
+      if (!(typeof value === 'object' && value !== null)) {
+        return false
+      }
     }
-    if (IsNumber(schema.minProperties) && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
+    if (IsNumber(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
       return false
     }
-    if (IsNumber(schema.maxProperties) && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
+    if (IsNumber(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
       return false
     }
-    const propertyKeys = globalThis.Object.keys(schema.properties)
+    const propertyKeys = globalThis.Object.getOwnPropertyNames(schema.properties)
     if (schema.additionalProperties === false) {
       // optimization: If the property key length matches the required keys length
       // then we only need check that the values property key length matches that
       // of the property key length. This is because exhaustive testing for values
       // will occur in subsequent property tests.
-      if (schema.required && schema.required.length === propertyKeys.length && !(globalThis.Object.keys(value).length === propertyKeys.length)) {
+      if (schema.required && schema.required.length === propertyKeys.length && !(globalThis.Object.getOwnPropertyNames(value).length === propertyKeys.length)) {
         return false
       } else {
-        if (!globalThis.Object.keys(value).every((key) => propertyKeys.includes(key))) {
+        if (!globalThis.Object.getOwnPropertyNames(value).every((key) => propertyKeys.includes(key))) {
           return false
         }
       }
     }
     if (typeof schema.additionalProperties === 'object') {
-      for (const objectKey of globalThis.Object.keys(value)) {
+      for (const objectKey of globalThis.Object.getOwnPropertyNames(value)) {
         if (propertyKeys.includes(objectKey)) continue
         if (!Visit(schema.additionalProperties as Types.TSchema, references, value[objectKey])) {
           return false
@@ -206,12 +214,18 @@ export namespace ValueCheck {
   }
 
   function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): boolean {
-    if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value) && !(value instanceof globalThis.Date))) {
-      return false
+    if (TypeSystem.Kind === 'json-schema') {
+      if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value) && !(value instanceof globalThis.Date))) {
+        return false
+      }
+    } else if (TypeSystem.Kind === 'structural') {
+      if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date))) {
+        return false
+      }
     }
     const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
     const regex = new RegExp(keyPattern)
-    if (!globalThis.Object.keys(value).every((key) => regex.test(key))) {
+    if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {
       return false
     }
     for (const propValue of globalThis.Object.values(value)) {
diff --git a/test/runtime/compiler/any.ts b/test/runtime/compiler/any.ts
index fdccc5f61..7519db00f 100644
--- a/test/runtime/compiler/any.ts
+++ b/test/runtime/compiler/any.ts
@@ -1,33 +1,33 @@
 import { Type } from '@sinclair/typebox'
-import { ok } from './validate'
+import { Ok } from './validate'
 
 describe('type/compiler/Any', () => {
   it('Should validate number', () => {
     const T = Type.Any()
-    ok(T, 1)
+    Ok(T, 1)
   })
   it('Should validate string', () => {
     const T = Type.Any()
-    ok(T, 'hello')
+    Ok(T, 'hello')
   })
   it('Should validate boolean', () => {
     const T = Type.Any()
-    ok(T, true)
+    Ok(T, true)
   })
   it('Should validate array', () => {
     const T = Type.Any()
-    ok(T, [1, 2, 3])
+    Ok(T, [1, 2, 3])
   })
   it('Should validate object', () => {
     const T = Type.Any()
-    ok(T, { a: 1, b: 2 })
+    Ok(T, { a: 1, b: 2 })
   })
   it('Should validate null', () => {
     const T = Type.Any()
-    ok(T, null)
+    Ok(T, null)
   })
   it('Should validate undefined', () => {
     const T = Type.Any()
-    ok(T, undefined)
+    Ok(T, undefined)
   })
 })
diff --git a/test/runtime/compiler/array.ts b/test/runtime/compiler/array.ts
index 61fc8171c..adff196f9 100644
--- a/test/runtime/compiler/array.ts
+++ b/test/runtime/compiler/array.ts
@@ -1,30 +1,30 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Array', () => {
   it('Should validate an array of any', () => {
     const T = Type.Array(Type.Any())
-    ok(T, [0, true, 'hello', {}])
+    Ok(T, [0, true, 'hello', {}])
   })
 
   it('Should not validate varying array when item is number', () => {
     const T = Type.Array(Type.Number())
-    fail(T, [1, 2, 3, 'hello'])
+    Fail(T, [1, 2, 3, 'hello'])
   })
 
   it('Should validate for an array of unions', () => {
     const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
-    ok(T, [1, 'hello', 3, 'world'])
+    Ok(T, [1, 'hello', 3, 'world'])
   })
 
   it('Should not validate for an array of unions where item is not in union.', () => {
     const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
-    fail(T, [1, 'hello', 3, 'world', true])
+    Fail(T, [1, 'hello', 3, 'world', true])
   })
 
   it('Should validate for an empty array', () => {
     const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
-    ok(T, [])
+    Ok(T, [])
   })
 
   it('Should validate for an array of intersection types', () => {
@@ -32,7 +32,7 @@ describe('type/compiler/Array', () => {
     const B = Type.Object({ b: Type.String() })
     const C = Type.Intersect([A, B])
     const T = Type.Array(C)
-    ok(T, [
+    Ok(T, [
       { a: 'hello', b: 'hello' },
       { a: 'hello', b: 'hello' },
       { a: 'hello', b: 'hello' },
@@ -44,7 +44,7 @@ describe('type/compiler/Array', () => {
     const B = Type.Object({ b: Type.String() })
     const C = Type.Intersect([A, B], { additionalProperties: false })
     const T = Type.Array(C)
-    fail(T, [
+    Fail(T, [
       { a: 'hello', b: 'hello' },
       { a: 'hello', b: 'hello' },
       { a: 'hello', b: 'hello', c: 'additional' },
@@ -56,7 +56,7 @@ describe('type/compiler/Array', () => {
     const B = Type.Number()
     const C = Type.Tuple([A, B])
     const T = Type.Array(C)
-    ok(T, [
+    Ok(T, [
       ['hello', 1],
       ['hello', 1],
       ['hello', 1],
@@ -68,7 +68,7 @@ describe('type/compiler/Array', () => {
     const B = Type.Number()
     const C = Type.Tuple([A, B])
     const T = Type.Array(C)
-    fail(T, [
+    Fail(T, [
       [1, 'hello'],
       [1, 'hello'],
       [1, 'hello'],
@@ -77,28 +77,28 @@ describe('type/compiler/Array', () => {
 
   it('Should not validate array with failed minItems', () => {
     const T = Type.Array(Type.Number(), { minItems: 3 })
-    fail(T, [0, 1])
+    Fail(T, [0, 1])
   })
   it('Should not validate array with failed maxItems', () => {
     const T = Type.Array(Type.Number(), { maxItems: 3 })
-    fail(T, [0, 1, 2, 3])
+    Fail(T, [0, 1, 2, 3])
   })
   it('Should validate array with uniqueItems when items are distinct objects', () => {
     const T = Type.Array(Type.Object({ x: Type.Number(), y: Type.Number() }), { uniqueItems: true })
-    ok(T, [
+    Ok(T, [
       { x: 0, y: 1 },
       { x: 1, y: 0 },
     ])
   })
   it('Should not validate array with uniqueItems when items are not distinct objects', () => {
     const T = Type.Array(Type.Object({ x: Type.Number(), y: Type.Number() }), { uniqueItems: true })
-    fail(T, [
+    Fail(T, [
       { x: 1, y: 0 },
       { x: 1, y: 0 },
     ])
   })
   it('Should not validate array with non uniqueItems', () => {
     const T = Type.Array(Type.Number(), { uniqueItems: true })
-    fail(T, [0, 0])
+    Fail(T, [0, 0])
   })
 })
diff --git a/test/runtime/compiler/boolean.ts b/test/runtime/compiler/boolean.ts
index 07293041f..c0d7997fb 100644
--- a/test/runtime/compiler/boolean.ts
+++ b/test/runtime/compiler/boolean.ts
@@ -1,40 +1,40 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Boolean', () => {
   it('Should validate a boolean', () => {
     const T = Type.Boolean()
-    ok(T, true)
-    ok(T, false)
+    Ok(T, true)
+    Ok(T, false)
   })
 
   it('Should not validate a number', () => {
     const T = Type.Boolean()
-    fail(T, 1)
+    Fail(T, 1)
   })
 
   it('Should not validate a string', () => {
     const T = Type.Boolean()
-    fail(T, 'true')
+    Fail(T, 'true')
   })
 
   it('Should not validate an array', () => {
     const T = Type.Boolean()
-    fail(T, [true])
+    Fail(T, [true])
   })
 
   it('Should not validate an object', () => {
     const T = Type.Boolean()
-    fail(T, {})
+    Fail(T, {})
   })
 
   it('Should not validate an null', () => {
     const T = Type.Boolean()
-    fail(T, null)
+    Fail(T, null)
   })
 
   it('Should not validate an undefined', () => {
     const T = Type.Boolean()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
 })
diff --git a/test/runtime/compiler/custom.ts b/test/runtime/compiler/custom.ts
index 1a42cdd8c..4cba073d9 100644
--- a/test/runtime/compiler/custom.ts
+++ b/test/runtime/compiler/custom.ts
@@ -1,28 +1,28 @@
 import { Custom } from '@sinclair/typebox/custom'
 import { Type, Kind } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Custom', () => {
   Custom.Set('BigInt', (schema, value) => typeof value === 'bigint')
 
   it('Should validate bigint', () => {
     const T = Type.Unsafe({ [Kind]: 'BigInt' })
-    ok(T, 1n)
+    Ok(T, 1n)
   })
   it('Should not validate bigint', () => {
     const T = Type.Unsafe({ [Kind]: 'BigInt' })
-    fail(T, 1)
+    Fail(T, 1)
   })
   it('Should validate bigint nested', () => {
     const T = Type.Object({
       x: Type.Unsafe({ [Kind]: 'BigInt' }),
     })
-    ok(T, { x: 1n })
+    Ok(T, { x: 1n })
   })
   it('Should not validate bigint nested', () => {
     const T = Type.Object({
       x: Type.Unsafe({ [Kind]: 'BigInt' }),
     })
-    fail(T, { x: 1 })
+    Fail(T, { x: 1 })
   })
 })
diff --git a/test/runtime/compiler/date.ts b/test/runtime/compiler/date.ts
index d6c099e6c..ae8855bd8 100644
--- a/test/runtime/compiler/date.ts
+++ b/test/runtime/compiler/date.ts
@@ -1,61 +1,61 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Date', () => {
   it('Should not validate number', () => {
     const T = Type.Date()
-    fail(T, 1)
+    Fail(T, 1)
   })
   it('Should not validate string', () => {
     const T = Type.Date()
-    fail(T, 'hello')
+    Fail(T, 'hello')
   })
   it('Should not validate boolean', () => {
     const T = Type.Date()
-    fail(T, true)
+    Fail(T, true)
   })
   it('Should not validate array', () => {
     const T = Type.Date()
-    fail(T, [1, 2, 3])
+    Fail(T, [1, 2, 3])
   })
   it('Should not validate object', () => {
     const T = Type.Date()
-    fail(T, { a: 1, b: 2 })
+    Fail(T, { a: 1, b: 2 })
   })
   it('Should not validate null', () => {
     const T = Type.Date()
-    fail(T, null)
+    Fail(T, null)
   })
   it('Should not validate undefined', () => {
     const T = Type.Date()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
   it('Should validate Date', () => {
     const T = Type.Date()
-    ok(T, new Date())
+    Ok(T, new Date())
   })
 
   it('Should validate Date minimumTimestamp', () => {
     const T = Type.Date({ minimumTimestamp: 10 })
-    fail(T, new Date(9))
-    ok(T, new Date(10))
+    Fail(T, new Date(9))
+    Ok(T, new Date(10))
   })
 
   it('Should validate Date maximumTimestamp', () => {
     const T = Type.Date({ maximumTimestamp: 10 })
-    ok(T, new Date(10))
-    fail(T, new Date(11))
+    Ok(T, new Date(10))
+    Fail(T, new Date(11))
   })
 
   it('Should validate Date exclusiveMinimumTimestamp', () => {
     const T = Type.Date({ exclusiveMinimumTimestamp: 10 })
-    fail(T, new Date(10))
-    ok(T, new Date(11))
+    Fail(T, new Date(10))
+    Ok(T, new Date(11))
   })
 
   it('Should validate Date exclusiveMaximumTimestamp', () => {
     const T = Type.Date({ exclusiveMaximumTimestamp: 10 })
-    ok(T, new Date(9))
-    fail(T, new Date(10))
+    Ok(T, new Date(9))
+    Fail(T, new Date(10))
   })
 })
diff --git a/test/runtime/compiler/enum.ts b/test/runtime/compiler/enum.ts
index 736cee47b..08460de6f 100644
--- a/test/runtime/compiler/enum.ts
+++ b/test/runtime/compiler/enum.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Enum', () => {
   it('Should validate when emum uses default numeric values', () => {
@@ -8,8 +8,8 @@ describe('type/compiler/Enum', () => {
       Bar, // = 1
     }
     const T = Type.Enum(Kind)
-    ok(T, 0)
-    ok(T, 1)
+    Ok(T, 0)
+    Ok(T, 1)
   })
   it('Should not validate when given enum values are not numeric', () => {
     enum Kind {
@@ -17,8 +17,8 @@ describe('type/compiler/Enum', () => {
       Bar, // = 1
     }
     const T = Type.Enum(Kind)
-    fail(T, 'Foo')
-    fail(T, 'Bar')
+    Fail(T, 'Foo')
+    Fail(T, 'Bar')
   })
 
   it('Should validate when emum has defined string values', () => {
@@ -27,8 +27,8 @@ describe('type/compiler/Enum', () => {
       Bar = 'bar',
     }
     const T = Type.Enum(Kind)
-    ok(T, 'foo')
-    ok(T, 'bar')
+    Ok(T, 'foo')
+    Ok(T, 'bar')
   })
 
   it('Should not validate when emum has defined string values and user passes numeric', () => {
@@ -37,8 +37,8 @@ describe('type/compiler/Enum', () => {
       Bar = 'bar',
     }
     const T = Type.Enum(Kind)
-    fail(T, 0)
-    fail(T, 1)
+    Fail(T, 0)
+    Fail(T, 1)
   })
 
   it('Should validate when enum has one or more string values', () => {
@@ -47,10 +47,10 @@ describe('type/compiler/Enum', () => {
       Bar = 'bar',
     }
     const T = Type.Enum(Kind)
-    ok(T, 0)
-    ok(T, 'bar')
-    fail(T, 'baz')
-    fail(T, 'Foo')
-    fail(T, 1)
+    Ok(T, 0)
+    Ok(T, 'bar')
+    Fail(T, 'baz')
+    Fail(T, 'Foo')
+    Fail(T, 1)
   })
 })
diff --git a/test/runtime/compiler/integer.ts b/test/runtime/compiler/integer.ts
index ba1110be9..1d3b85dbb 100644
--- a/test/runtime/compiler/integer.ts
+++ b/test/runtime/compiler/integer.ts
@@ -1,71 +1,71 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Integer', () => {
   it('Should not validate number', () => {
     const T = Type.Integer()
-    fail(T, 3.14)
+    Fail(T, 3.14)
   })
 
   it('Should validate integer', () => {
     const T = Type.Integer()
-    ok(T, 1)
+    Ok(T, 1)
   })
 
   it('Should not validate string', () => {
     const T = Type.Integer()
-    fail(T, 'hello')
+    Fail(T, 'hello')
   })
 
   it('Should not validate boolean', () => {
     const T = Type.Integer()
-    fail(T, true)
+    Fail(T, true)
   })
 
   it('Should not validate array', () => {
     const T = Type.Integer()
-    fail(T, [1, 2, 3])
+    Fail(T, [1, 2, 3])
   })
 
   it('Should not validate object', () => {
     const T = Type.Integer()
-    fail(T, { a: 1, b: 2 })
+    Fail(T, { a: 1, b: 2 })
   })
 
   it('Should not validate null', () => {
     const T = Type.Integer()
-    fail(T, null)
+    Fail(T, null)
   })
   it('Should not validate undefined', () => {
     const T = Type.Integer()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
 
   it('Should validate minimum', () => {
     const T = Type.Integer({ minimum: 10 })
-    fail(T, 9)
-    ok(T, 10)
+    Fail(T, 9)
+    Ok(T, 10)
   })
 
   it('Should validate maximum', () => {
     const T = Type.Integer({ maximum: 10 })
-    ok(T, 10)
-    fail(T, 11)
+    Ok(T, 10)
+    Fail(T, 11)
   })
 
   it('Should validate Date exclusiveMinimum', () => {
     const T = Type.Integer({ exclusiveMinimum: 10 })
-    fail(T, 10)
-    ok(T, 11)
+    Fail(T, 10)
+    Ok(T, 11)
   })
 
   it('Should validate Date exclusiveMaximum', () => {
     const T = Type.Integer({ exclusiveMaximum: 10 })
-    ok(T, 9)
-    fail(T, 10)
+    Ok(T, 9)
+    Fail(T, 10)
   })
 
   it('Should not validate NaN', () => {
-    fail(Type.Integer(), NaN)
+    Fail(Type.Integer(), NaN)
   })
 })
diff --git a/test/runtime/compiler/intersect.ts b/test/runtime/compiler/intersect.ts
index f59d9adae..5cb524514 100644
--- a/test/runtime/compiler/intersect.ts
+++ b/test/runtime/compiler/intersect.ts
@@ -1,19 +1,19 @@
 import { Type, Static } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Intersect', () => {
   it('Should intersect two objects', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
     const T = Type.Intersect([A, B], { additionalProperties: false })
-    ok(T, { a: 'hello', b: 42 })
+    Ok(T, { a: 'hello', b: 42 })
   })
 
   it('Should intersect with partial', () => {
     const A = Type.Partial(Type.Object({ a: Type.Number() }))
     const B = Type.Partial(Type.Object({ b: Type.Number() }))
     const P = Type.Intersect([A, B], { additionalProperties: false })
-    ok(P, { a: 1, b: 2 })
+    Ok(P, { a: 1, b: 2 })
     // ok(P, { a: 1 })
     // ok(P, { b: 1 })
     // ok(P, {})
@@ -24,18 +24,18 @@ describe('type/compiler/Intersect', () => {
     const A = Type.Object({ a: Type.Number() })
     const B = Type.Object({ a: Type.Number() })
     const P = Type.Intersect([A, B])
-    ok(P, { a: 1 })
-    fail(P, { a: 'hello' })
-    fail(P, {})
+    Ok(P, { a: 1 })
+    Fail(P, { a: 'hello' })
+    Fail(P, {})
   })
 
   it('Should intersect with overlapping varying type', () => {
     const A = Type.Object({ a: Type.Number() })
     const B = Type.Object({ a: Type.String() })
     const T = Type.Intersect([A, B])
-    ok(T, { a: 1 })
-    ok(T, { a: 'hello' })
-    fail(T, {})
+    Ok(T, { a: 1 })
+    Ok(T, { a: 'hello' })
+    Fail(T, {})
   })
 
   it('Should intersect with deeply nest overlapping varying type', () => {
@@ -44,12 +44,12 @@ describe('type/compiler/Intersect', () => {
     const C = Type.Object({ a: Type.Boolean() })
     const D = Type.Object({ a: Type.Null() })
     const T = Type.Intersect([A, B, C, D])
-    ok(T, { a: 1 })
-    ok(T, { a: 'hello' })
-    ok(T, { a: false })
-    ok(T, { a: null })
-    fail(T, { a: [] })
-    fail(T, {})
+    Ok(T, { a: 1 })
+    Ok(T, { a: 'hello' })
+    Ok(T, { a: false })
+    Ok(T, { a: null })
+    Fail(T, { a: [] })
+    Fail(T, {})
   })
 
   it('Should pick from intersected type', () => {
@@ -58,8 +58,8 @@ describe('type/compiler/Intersect', () => {
     const C = Type.Object({ z: Type.Number() })
     const T = Type.Intersect([A, B, C])
     const P = Type.Pick(T, ['x', 'y'], { additionalProperties: false })
-    ok(P, { x: 1, y: 1 })
-    fail(P, { x: 1, y: 1, z: 1 })
+    Ok(P, { x: 1, y: 1 })
+    Fail(P, { x: 1, y: 1, z: 1 })
   })
 
   it('Should omit from intersected type', () => {
@@ -68,16 +68,16 @@ describe('type/compiler/Intersect', () => {
     const C = Type.Object({ z: Type.Number() })
     const T = Type.Intersect([A, B, C])
     const P = Type.Omit(T, ['z'], { additionalProperties: false })
-    ok(P, { x: 1, y: 1 })
-    fail(P, { x: 1, y: 1, z: 1 })
+    Ok(P, { x: 1, y: 1 })
+    Fail(P, { x: 1, y: 1, z: 1 })
   })
 
   it('Should intersect nested object properties', () => {
     const A = Type.Object({ x: Type.Object({ x: Type.Number() }) })
     const B = Type.Object({ x: Type.Object({ x: Type.String() }) })
     const T = Type.Intersect([A, B])
-    ok(T, { x: { x: 1 } })
-    ok(T, { x: { x: 'hello' } })
-    fail(T, { x: { x: false } })
+    Ok(T, { x: { x: 1 } })
+    Ok(T, { x: { x: 'hello' } })
+    Fail(T, { x: { x: false } })
   })
 })
diff --git a/test/runtime/compiler/keyof.ts b/test/runtime/compiler/keyof.ts
index 3920b1485..e96ad8762 100644
--- a/test/runtime/compiler/keyof.ts
+++ b/test/runtime/compiler/keyof.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
 describe('type/compiler/KeyOf', () => {
@@ -11,10 +11,10 @@ describe('type/compiler/KeyOf', () => {
         z: Type.Number(),
       }),
     )
-    ok(T, 'x')
-    ok(T, 'y')
-    ok(T, 'z')
-    fail(T, 'w')
+    Ok(T, 'x')
+    Ok(T, 'y')
+    Ok(T, 'z')
+    Fail(T, 'w')
   })
 
   it('Should validate when using pick', () => {
@@ -28,9 +28,9 @@ describe('type/compiler/KeyOf', () => {
         ['x', 'y'],
       ),
     )
-    ok(T, 'x')
-    ok(T, 'y')
-    fail(T, 'z')
+    Ok(T, 'x')
+    Ok(T, 'y')
+    Fail(T, 'z')
   })
 
   it('Should validate when using omit', () => {
@@ -45,8 +45,8 @@ describe('type/compiler/KeyOf', () => {
       ),
     )
 
-    fail(T, 'x')
-    fail(T, 'y')
-    ok(T, 'z')
+    Fail(T, 'x')
+    Fail(T, 'y')
+    Ok(T, 'z')
   })
 })
diff --git a/test/runtime/compiler/literal.ts b/test/runtime/compiler/literal.ts
index 1aa46921f..a7251b789 100644
--- a/test/runtime/compiler/literal.ts
+++ b/test/runtime/compiler/literal.ts
@@ -1,43 +1,43 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Literal', () => {
   it('Should validate literal number', () => {
     const T = Type.Literal(42)
-    ok(T, 42)
+    Ok(T, 42)
   })
   it('Should validate literal string', () => {
     const T = Type.Literal('hello')
-    ok(T, 'hello')
+    Ok(T, 'hello')
   })
 
   it('Should validate literal boolean', () => {
     const T = Type.Literal(true)
-    ok(T, true)
+    Ok(T, true)
   })
 
   it('Should not validate invalid literal number', () => {
     const T = Type.Literal(42)
-    fail(T, 43)
+    Fail(T, 43)
   })
   it('Should not validate invalid literal string', () => {
     const T = Type.Literal('hello')
-    fail(T, 'world')
+    Fail(T, 'world')
   })
   it('Should not validate invalid literal boolean', () => {
     const T = Type.Literal(false)
-    fail(T, true)
+    Fail(T, true)
   })
 
   it('Should validate literal union', () => {
     const T = Type.Union([Type.Literal(42), Type.Literal('hello')])
-    ok(T, 42)
-    ok(T, 'hello')
+    Ok(T, 42)
+    Ok(T, 'hello')
   })
 
   it('Should not validate invalid literal union', () => {
     const T = Type.Union([Type.Literal(42), Type.Literal('hello')])
-    fail(T, 43)
-    fail(T, 'world')
+    Fail(T, 43)
+    Fail(T, 'world')
   })
 })
diff --git a/test/runtime/compiler/never.ts b/test/runtime/compiler/never.ts
index 8be660cdf..a19036774 100644
--- a/test/runtime/compiler/never.ts
+++ b/test/runtime/compiler/never.ts
@@ -1,36 +1,36 @@
 import { Type } from '@sinclair/typebox'
-import { fail } from './validate'
+import { Fail } from './validate'
 
 describe('type/compiler/Never', () => {
   it('Should not validate number', () => {
     const T = Type.Never()
-    fail(T, 1)
+    Fail(T, 1)
   })
 
   it('Should not validate string', () => {
     const T = Type.Never()
-    fail(T, 'hello')
+    Fail(T, 'hello')
   })
 
   it('Should not validate boolean', () => {
     const T = Type.Never()
-    fail(T, true)
+    Fail(T, true)
   })
 
   it('Should not validate array', () => {
     const T = Type.Never()
-    fail(T, [1, 2, 3])
+    Fail(T, [1, 2, 3])
   })
   it('Should not validate object', () => {
     const T = Type.Never()
-    fail(T, { a: 1, b: 2 })
+    Fail(T, { a: 1, b: 2 })
   })
   it('Should not validate null', () => {
     const T = Type.Never()
-    fail(T, null)
+    Fail(T, null)
   })
   it('Should not validate undefined', () => {
     const T = Type.Never()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
 })
diff --git a/test/runtime/compiler/null.ts b/test/runtime/compiler/null.ts
index a3e6009c4..1253ea64a 100644
--- a/test/runtime/compiler/null.ts
+++ b/test/runtime/compiler/null.ts
@@ -1,39 +1,39 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Null', () => {
   it('Should not validate number', () => {
     const T = Type.Null()
-    fail(T, 1)
+    Fail(T, 1)
   })
 
   it('Should not validate string', () => {
     const T = Type.Null()
-    fail(T, 'hello')
+    Fail(T, 'hello')
   })
 
   it('Should not validate boolean', () => {
     const T = Type.Null()
-    fail(T, true)
+    Fail(T, true)
   })
 
   it('Should not validate array', () => {
     const T = Type.Null()
-    fail(T, [1, 2, 3])
+    Fail(T, [1, 2, 3])
   })
 
   it('Should not validate object', () => {
     const T = Type.Null()
-    fail(T, { a: 1, b: 2 })
+    Fail(T, { a: 1, b: 2 })
   })
 
   it('Should not validate null', () => {
     const T = Type.Null()
-    ok(T, null)
+    Ok(T, null)
   })
 
   it('Should not validate undefined', () => {
     const T = Type.Null()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
 })
diff --git a/test/runtime/compiler/number.ts b/test/runtime/compiler/number.ts
index b92e944b8..90a229f64 100644
--- a/test/runtime/compiler/number.ts
+++ b/test/runtime/compiler/number.ts
@@ -1,67 +1,67 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Number', () => {
   it('Should validate number', () => {
     const T = Type.Number()
-    ok(T, 3.14)
+    Ok(T, 3.14)
   })
 
   it('Should validate integer', () => {
     const T = Type.Number()
-    ok(T, 1)
+    Ok(T, 1)
   })
 
   it('Should not validate string', () => {
     const T = Type.Number()
-    fail(T, 'hello')
+    Fail(T, 'hello')
   })
   it('Should not validate boolean', () => {
     const T = Type.Number()
-    fail(T, true)
+    Fail(T, true)
   })
   it('Should not validate array', () => {
     const T = Type.Number()
-    fail(T, [1, 2, 3])
+    Fail(T, [1, 2, 3])
   })
   it('Should not validate object', () => {
     const T = Type.Number()
-    fail(T, { a: 1, b: 2 })
+    Fail(T, { a: 1, b: 2 })
   })
   it('Should not validate null', () => {
     const T = Type.Number()
-    fail(T, null)
+    Fail(T, null)
   })
   it('Should not validate undefined', () => {
     const T = Type.Number()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
 
   it('Should validate minimum', () => {
     const T = Type.Number({ minimum: 10 })
-    fail(T, 9)
-    ok(T, 10)
+    Fail(T, 9)
+    Ok(T, 10)
   })
 
   it('Should validate maximum', () => {
     const T = Type.Number({ maximum: 10 })
-    ok(T, 10)
-    fail(T, 11)
+    Ok(T, 10)
+    Fail(T, 11)
   })
 
   it('Should validate Date exclusiveMinimum', () => {
     const T = Type.Number({ exclusiveMinimum: 10 })
-    fail(T, 10)
-    ok(T, 11)
+    Fail(T, 10)
+    Ok(T, 11)
   })
 
   it('Should validate Date exclusiveMaximum', () => {
     const T = Type.Number({ exclusiveMaximum: 10 })
-    ok(T, 9)
-    fail(T, 10)
+    Ok(T, 9)
+    Fail(T, 10)
   })
 
   it('Should not validate NaN', () => {
-    fail(Type.Number(), NaN)
+    Fail(Type.Number(), NaN)
   })
 })
diff --git a/test/runtime/compiler/object.ts b/test/runtime/compiler/object.ts
index c6b4aa809..924b75c86 100644
--- a/test/runtime/compiler/object.ts
+++ b/test/runtime/compiler/object.ts
@@ -1,30 +1,30 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Object', () => {
   it('Should not validate a number', () => {
     const T = Type.Object({})
-    fail(T, 42)
+    Fail(T, 42)
   })
 
   it('Should not validate a string', () => {
     const T = Type.Object({})
-    fail(T, 'hello')
+    Fail(T, 'hello')
   })
 
   it('Should not validate a boolean', () => {
     const T = Type.Object({})
-    fail(T, true)
+    Fail(T, true)
   })
 
   it('Should not validate a null', () => {
     const T = Type.Object({})
-    fail(T, null)
+    Fail(T, null)
   })
 
   it('Should not validate an array', () => {
     const T = Type.Object({})
-    fail(T, [1, 2])
+    Fail(T, [1, 2])
   })
 
   it('Should validate with correct property values', () => {
@@ -35,7 +35,7 @@ describe('type/compiler/Object', () => {
       d: Type.Array(Type.Number()),
       e: Type.Object({ x: Type.Number(), y: Type.Number() }),
     })
-    ok(T, {
+    Ok(T, {
       a: 10,
       b: 'hello',
       c: true,
@@ -52,7 +52,7 @@ describe('type/compiler/Object', () => {
       d: Type.Array(Type.Number()),
       e: Type.Object({ x: Type.Number(), y: Type.Number() }),
     })
-    fail(T, {
+    Fail(T, {
       a: 'not a number', // error
       b: 'hello',
       c: true,
@@ -66,7 +66,7 @@ describe('type/compiler/Object', () => {
       a: Type.Number(),
       b: Type.String(),
     })
-    ok(T, {
+    Ok(T, {
       a: 1,
       b: 'hello',
       c: true,
@@ -81,9 +81,9 @@ describe('type/compiler/Object', () => {
       },
       { additionalProperties: false, minProperties: 1 },
     )
-    ok(T, { a: 1 })
-    ok(T, { b: 'hello' })
-    fail(T, {})
+    Ok(T, { a: 1 })
+    Ok(T, { b: 'hello' })
+    Fail(T, {})
   })
 
   it('Should not allow 3 properties if maxProperties is set to 2', () => {
@@ -95,9 +95,9 @@ describe('type/compiler/Object', () => {
       },
       { additionalProperties: false, maxProperties: 2 },
     )
-    ok(T, { a: 1 })
-    ok(T, { a: 1, b: 'hello' })
-    fail(T, {
+    Ok(T, { a: 1 })
+    Ok(T, { a: 1, b: 'hello' })
+    Fail(T, {
       a: 1,
       b: 'hello',
       c: true,
@@ -112,7 +112,7 @@ describe('type/compiler/Object', () => {
       },
       { additionalProperties: false },
     )
-    fail(T, {
+    Fail(T, {
       a: 1,
       b: 'hello',
       c: true,
@@ -121,8 +121,8 @@ describe('type/compiler/Object', () => {
 
   it('Should not allow properties for an empty object when additionalProperties is false', () => {
     const T = Type.Object({}, { additionalProperties: false })
-    ok(T, {})
-    fail(T, { a: 10 })
+    Ok(T, {})
+    Fail(T, { a: 10 })
   })
 
   it('Should validate with non-syntax property keys', () => {
@@ -132,7 +132,7 @@ describe('type/compiler/Object', () => {
       '$-leading': Type.Literal(3),
       '!@#$%^&*(': Type.Literal(4),
     })
-    ok(T, {
+    Ok(T, {
       'with-hyphen': 1,
       '0-leading': 2,
       '$-leading': 3,
@@ -150,12 +150,12 @@ describe('type/compiler/Object', () => {
         additionalProperties: Type.String(),
       },
     )
-    ok(T, {
+    Ok(T, {
       x: 1,
       y: 2,
       z: 'hello',
     })
-    fail(T, {
+    Fail(T, {
       x: 1,
       y: 2,
       z: 3,
@@ -171,12 +171,12 @@ describe('type/compiler/Object', () => {
         additionalProperties: Type.Array(Type.Number()),
       },
     )
-    ok(T, {
+    Ok(T, {
       x: 1,
       y: 2,
       z: [0, 1, 2],
     })
-    fail(T, {
+    Fail(T, {
       x: 1,
       y: 2,
       z: 3,
@@ -194,12 +194,12 @@ describe('type/compiler/Object', () => {
         }),
       },
     )
-    ok(T, {
+    Ok(T, {
       x: 1,
       y: 2,
       z: { z: 1 },
     })
-    fail(T, {
+    Fail(T, {
       x: 1,
       y: 2,
       z: 3,
diff --git a/test/runtime/compiler/omit.ts b/test/runtime/compiler/omit.ts
index 29b65bab7..42634995f 100644
--- a/test/runtime/compiler/omit.ts
+++ b/test/runtime/compiler/omit.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
 describe('type/compiler/Omit', () => {
@@ -13,7 +13,7 @@ describe('type/compiler/Omit', () => {
       { additionalProperties: false },
     )
     const T = Type.Omit(A, ['z'])
-    ok(T, { x: 1, y: 1 })
+    Ok(T, { x: 1, y: 1 })
   })
 
   it('Should remove required properties on the target schema', () => {
@@ -54,7 +54,7 @@ describe('type/compiler/Omit', () => {
       y: Type.Number(),
     })
     const T = Type.Omit(A, Type.KeyOf(B), { additionalProperties: false })
-    ok(T, { z: 0 })
-    fail(T, { x: 0, y: 0, z: 0 })
+    Ok(T, { z: 0 })
+    Fail(T, { x: 0, y: 0, z: 0 })
   })
 })
diff --git a/test/runtime/compiler/optional.ts b/test/runtime/compiler/optional.ts
index abbcb86c3..a78384e67 100644
--- a/test/runtime/compiler/optional.ts
+++ b/test/runtime/compiler/optional.ts
@@ -1,6 +1,6 @@
 import { strictEqual } from 'assert'
 import { Type } from '@sinclair/typebox'
-import { ok } from './validate'
+import { Ok } from './validate'
 
 describe('type/compiler/Optional', () => {
   it('Should validate object with optional', () => {
@@ -11,8 +11,8 @@ describe('type/compiler/Optional', () => {
       },
       { additionalProperties: false },
     )
-    ok(T, { a: 'hello', b: 'world' })
-    ok(T, { b: 'world' })
+    Ok(T, { a: 'hello', b: 'world' })
+    Ok(T, { b: 'world' })
   })
   it('Should remove required value from schema', () => {
     const T = Type.Object(
diff --git a/test/runtime/compiler/partial.ts b/test/runtime/compiler/partial.ts
index c060a0e20..6f11fb90b 100644
--- a/test/runtime/compiler/partial.ts
+++ b/test/runtime/compiler/partial.ts
@@ -1,5 +1,5 @@
 import { Type, Modifier } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
 describe('type/compiler/Partial', () => {
@@ -13,10 +13,10 @@ describe('type/compiler/Partial', () => {
       { additionalProperties: false },
     )
     const T = Type.Partial(A)
-    ok(T, { x: 1, y: 1, z: 1 })
-    ok(T, { x: 1, y: 1 })
-    ok(T, { x: 1 })
-    ok(T, {})
+    Ok(T, { x: 1, y: 1, z: 1 })
+    Ok(T, { x: 1, y: 1 })
+    Ok(T, { x: 1 })
+    Ok(T, {})
   })
 
   it('Should update modifier types correctly when converting to partial', () => {
diff --git a/test/runtime/compiler/pick.ts b/test/runtime/compiler/pick.ts
index c66cbb912..e6c9eb805 100644
--- a/test/runtime/compiler/pick.ts
+++ b/test/runtime/compiler/pick.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
 describe('type/compiler/Pick', () => {
@@ -13,7 +13,7 @@ describe('type/compiler/Pick', () => {
       { additionalProperties: false },
     )
     const T = Type.Pick(Vector3, ['x', 'y'])
-    ok(T, { x: 1, y: 1 })
+    Ok(T, { x: 1, y: 1 })
   })
 
   it('Should remove required properties on the target schema', () => {
@@ -54,7 +54,7 @@ describe('type/compiler/Pick', () => {
       y: Type.Number(),
     })
     const T = Type.Pick(A, Type.KeyOf(B), { additionalProperties: false })
-    ok(T, { x: 0, y: 0 })
-    fail(T, { x: 0, y: 0, z: 0 })
+    Ok(T, { x: 0, y: 0 })
+    Fail(T, { x: 0, y: 0, z: 0 })
   })
 })
diff --git a/test/runtime/compiler/readonly-optional.ts b/test/runtime/compiler/readonly-optional.ts
index 33b78d762..90ec45097 100644
--- a/test/runtime/compiler/readonly-optional.ts
+++ b/test/runtime/compiler/readonly-optional.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
 describe('type/compiler/ReadonlyOptional', () => {
@@ -11,8 +11,8 @@ describe('type/compiler/ReadonlyOptional', () => {
       },
       { additionalProperties: false },
     )
-    ok(T, { a: 'hello', b: 'world' })
-    ok(T, { b: 'world' })
+    Ok(T, { a: 'hello', b: 'world' })
+    Ok(T, { b: 'world' })
   })
   it('Should remove required value from schema', () => {
     const T = Type.Object(
diff --git a/test/runtime/compiler/readonly.ts b/test/runtime/compiler/readonly.ts
index 1ad7ff703..3edbab2a3 100644
--- a/test/runtime/compiler/readonly.ts
+++ b/test/runtime/compiler/readonly.ts
@@ -1,6 +1,6 @@
 import { deepStrictEqual, strictEqual } from 'assert'
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Readonly', () => {
   it('Should validate object with readonly', () => {
@@ -11,7 +11,7 @@ describe('type/compiler/Readonly', () => {
       },
       { additionalProperties: false },
     )
-    ok(T, { a: 'hello', b: 'world' })
+    Ok(T, { a: 'hello', b: 'world' })
   })
 
   it('Should retain required array on object', () => {
diff --git a/test/runtime/compiler/record.ts b/test/runtime/compiler/record.ts
index 608919a69..d73a14848 100644
--- a/test/runtime/compiler/record.ts
+++ b/test/runtime/compiler/record.ts
@@ -1,27 +1,27 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Record', () => {
   it('Should validate when all property values are numbers', () => {
     const T = Type.Record(Type.String(), Type.Number())
-    ok(T, { a: 1, b: 2, c: 3 })
+    Ok(T, { a: 1, b: 2, c: 3 })
   })
 
   it('Should validate when all property keys are strings', () => {
     const T = Type.Record(Type.String(), Type.Number())
-    ok(T, { a: 1, b: 2, c: 3, '0': 4 })
+    Ok(T, { a: 1, b: 2, c: 3, '0': 4 })
   })
 
   it('Should validate when specifying string union literals when additionalProperties is true', () => {
     const K = Type.Union([Type.Literal('a'), Type.Literal('b'), Type.Literal('c')])
     const T = Type.Record(K, Type.Number())
-    ok(T, { a: 1, b: 2, c: 3, d: 'hello' })
+    Ok(T, { a: 1, b: 2, c: 3, d: 'hello' })
   })
 
   it('Should not validate when specifying string union literals when additionalProperties is false', () => {
     const K = Type.Union([Type.Literal('a'), Type.Literal('b'), Type.Literal('c')])
     const T = Type.Record(K, Type.Number(), { additionalProperties: false })
-    fail(T, { a: 1, b: 2, c: 3, d: 'hello' })
+    Fail(T, { a: 1, b: 2, c: 3, d: 'hello' })
   })
 
   it('Should validate for keyof records', () => {
@@ -31,7 +31,7 @@ describe('type/compiler/Record', () => {
       c: Type.String(),
     })
     const R = Type.Record(Type.KeyOf(T), Type.Number())
-    ok(R, { a: 1, b: 2, c: 3 })
+    Ok(R, { a: 1, b: 2, c: 3 })
   })
 
   it('Should not validate for unknown key via keyof', () => {
@@ -41,13 +41,13 @@ describe('type/compiler/Record', () => {
       c: Type.String(),
     })
     const R = Type.Record(Type.KeyOf(T), Type.Number(), { additionalProperties: false })
-    fail(R, { a: 1, b: 2, c: 3, d: 4 })
+    Fail(R, { a: 1, b: 2, c: 3, d: 4 })
   })
 
   it('Should should validate when specifying regular expressions', () => {
     const K = Type.RegEx(/^op_.*$/)
     const T = Type.Record(K, Type.Number())
-    ok(T, {
+    Ok(T, {
       op_a: 1,
       op_b: 2,
       op_c: 3,
@@ -57,7 +57,7 @@ describe('type/compiler/Record', () => {
   it('Should should not validate when specifying regular expressions and passing invalid property', () => {
     const K = Type.RegEx(/^op_.*$/)
     const T = Type.Record(K, Type.Number())
-    fail(T, {
+    Fail(T, {
       op_a: 1,
       op_b: 2,
       aop_c: 3,
@@ -70,17 +70,17 @@ describe('type/compiler/Record', () => {
 
   it('Should validate when all property keys are integers', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
-    ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
+    Ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
   })
 
   it('Should validate when all property keys are integers, but one property is a string with varying type', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
-    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
+    Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
 
   it('Should not validate if passing a leading zeros for integers keys', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
-    fail(T, {
+    Fail(T, {
       '00': 1,
       '01': 2,
       '02': 3,
@@ -90,7 +90,7 @@ describe('type/compiler/Record', () => {
 
   it('Should not validate if passing a signed integers keys', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
-    fail(T, {
+    Fail(T, {
       '-0': 1,
       '-1': 2,
       '-2': 3,
@@ -104,17 +104,17 @@ describe('type/compiler/Record', () => {
 
   it('Should validate when all property keys are numbers', () => {
     const T = Type.Record(Type.Number(), Type.Number())
-    ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
+    Ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
   })
 
   it('Should validate when all property keys are numbers, but one property is a string with varying type', () => {
     const T = Type.Record(Type.Number(), Type.Number())
-    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
+    Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
 
   it('Should not validate if passing a leading zeros for numeric keys', () => {
     const T = Type.Record(Type.Number(), Type.Number())
-    fail(T, {
+    Fail(T, {
       '00': 1,
       '01': 2,
       '02': 3,
@@ -124,7 +124,7 @@ describe('type/compiler/Record', () => {
 
   it('Should not validate if passing a signed numeric keys', () => {
     const T = Type.Record(Type.Number(), Type.Number())
-    fail(T, {
+    Fail(T, {
       '-0': 1,
       '-1': 2,
       '-2': 3,
@@ -134,6 +134,6 @@ describe('type/compiler/Record', () => {
 
   it('Should not validate when all property keys are numbers, but one property is a string with varying type', () => {
     const T = Type.Record(Type.Number(), Type.Number())
-    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
+    Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
 })
diff --git a/test/runtime/compiler/recursive.ts b/test/runtime/compiler/recursive.ts
index 0bd48baf0..3cc78be1a 100644
--- a/test/runtime/compiler/recursive.ts
+++ b/test/runtime/compiler/recursive.ts
@@ -1,6 +1,6 @@
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Recursive', () => {
   it('Should generate default ordinal $id if not specified', () => {
@@ -32,7 +32,7 @@ describe('type/compiler/Recursive', () => {
         nodes: Type.Array(Self),
       }),
     )
-    ok(Node, {
+    Ok(Node, {
       id: 'A',
       nodes: [
         { id: 'B', nodes: [] },
@@ -50,7 +50,7 @@ describe('type/compiler/Recursive', () => {
         }),
       ),
     ])
-    ok(Node, [
+    Ok(Node, [
       {
         id: 'A',
         nodes: [
@@ -70,7 +70,7 @@ describe('type/compiler/Recursive', () => {
         }),
       ),
     ])
-    fail(Node, [
+    Fail(Node, [
       {
         id: 'A',
         nodes: [
diff --git a/test/runtime/compiler/ref.ts b/test/runtime/compiler/ref.ts
index b816f895c..632ac0fe7 100644
--- a/test/runtime/compiler/ref.ts
+++ b/test/runtime/compiler/ref.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 import { Assert } from '../assert/index'
 
 describe('type/compiler/Ref', () => {
@@ -13,7 +13,7 @@ describe('type/compiler/Ref', () => {
       { $id: Assert.nextId() },
     )
     const R = Type.Ref(T)
-    ok(
+    Ok(
       R,
       {
         x: 1,
@@ -34,7 +34,7 @@ describe('type/compiler/Ref', () => {
       { $id: Assert.nextId() },
     )
     const R = Type.Ref(T)
-    fail(
+    Fail(
       R,
       {
         x: 1,
@@ -62,9 +62,9 @@ describe('type/compiler/Ref', () => {
       { $id: 'T' },
     )
 
-    ok(T, { x: 1, y: 2, z: 3 }, [R])
-    ok(T, { x: 1, y: 2, z: 3, r: { name: 'hello' } }, [R])
-    fail(T, { x: 1, y: 2, z: 3, r: { name: 1 } }, [R])
-    fail(T, { x: 1, y: 2, z: 3, r: {} }, [R])
+    Ok(T, { x: 1, y: 2, z: 3 }, [R])
+    Ok(T, { x: 1, y: 2, z: 3, r: { name: 'hello' } }, [R])
+    Fail(T, { x: 1, y: 2, z: 3, r: { name: 1 } }, [R])
+    Fail(T, { x: 1, y: 2, z: 3, r: {} }, [R])
   })
 })
diff --git a/test/runtime/compiler/regex.ts b/test/runtime/compiler/regex.ts
index 0213a8216..5f3418047 100644
--- a/test/runtime/compiler/regex.ts
+++ b/test/runtime/compiler/regex.ts
@@ -1,35 +1,35 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/RegEx', () => {
   it('Should validate numeric value', () => {
     const T = Type.RegEx(/[012345]/)
-    ok(T, '0')
-    ok(T, '1')
-    ok(T, '2')
-    ok(T, '3')
-    ok(T, '4')
-    ok(T, '5')
+    Ok(T, '0')
+    Ok(T, '1')
+    Ok(T, '2')
+    Ok(T, '3')
+    Ok(T, '4')
+    Ok(T, '5')
   })
 
   it('Should validate true or false string value', () => {
     const T = Type.RegEx(/true|false/)
-    ok(T, 'true')
-    ok(T, 'true')
-    ok(T, 'true')
-    ok(T, 'false')
-    ok(T, 'false')
-    ok(T, 'false')
-    fail(T, '6')
+    Ok(T, 'true')
+    Ok(T, 'true')
+    Ok(T, 'true')
+    Ok(T, 'false')
+    Ok(T, 'false')
+    Ok(T, 'false')
+    Fail(T, '6')
   })
 
   it('Should not validate failed regex test', () => {
     const T = Type.RegEx(/true|false/)
-    fail(T, 'unknown')
+    Fail(T, 'unknown')
   })
 
   it('Should pass numeric 5 digit test', () => {
     const T = Type.RegEx(/[\d]{5}/)
-    ok(T, '12345')
+    Ok(T, '12345')
   })
 })
diff --git a/test/runtime/compiler/required.ts b/test/runtime/compiler/required.ts
index 56d27bc5a..fc6f32f83 100644
--- a/test/runtime/compiler/required.ts
+++ b/test/runtime/compiler/required.ts
@@ -1,5 +1,5 @@
 import { Type, Modifier } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
 describe('type/compiler/compiler/Required', () => {
@@ -13,10 +13,10 @@ describe('type/compiler/compiler/Required', () => {
       { additionalProperties: false },
     )
     const T = Type.Required(A)
-    ok(T, { x: 1, y: 1, z: 1 })
-    fail(T, { x: 1, y: 1 })
-    fail(T, { x: 1 })
-    fail(T, {})
+    Ok(T, { x: 1, y: 1, z: 1 })
+    Fail(T, { x: 1, y: 1 })
+    Fail(T, { x: 1 })
+    Fail(T, {})
   })
 
   it('Should update modifier types correctly when converting to required', () => {
diff --git a/test/runtime/compiler/string.ts b/test/runtime/compiler/string.ts
index f90398e7b..2f0005afb 100644
--- a/test/runtime/compiler/string.ts
+++ b/test/runtime/compiler/string.ts
@@ -1,65 +1,65 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/String', () => {
   it('Should not validate number', () => {
     const T = Type.String()
-    fail(T, 1)
+    Fail(T, 1)
   })
   it('Should validate string', () => {
     const T = Type.String()
-    ok(T, 'hello')
+    Ok(T, 'hello')
   })
   it('Should not validate boolean', () => {
     const T = Type.String()
-    fail(T, true)
+    Fail(T, true)
   })
   it('Should not validate array', () => {
     const T = Type.String()
-    fail(T, [1, 2, 3])
+    Fail(T, [1, 2, 3])
   })
   it('Should not validate object', () => {
     const T = Type.String()
-    fail(T, { a: 1, b: 2 })
+    Fail(T, { a: 1, b: 2 })
   })
   it('Should not validate null', () => {
     const T = Type.String()
-    fail(T, null)
+    Fail(T, null)
   })
   it('Should not validate undefined', () => {
     const T = Type.String()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
 
   it('Should validate string format as email', () => {
     const T = Type.String({ format: 'email' })
-    ok(T, 'name@domain.com')
+    Ok(T, 'name@domain.com')
   })
 
   it('Should validate string format as uuid', () => {
     const T = Type.String({ format: 'uuid' })
-    ok(T, '4a7a17c9-2492-4a53-8e13-06ea2d3f3bbf')
+    Ok(T, '4a7a17c9-2492-4a53-8e13-06ea2d3f3bbf')
   })
 
   it('Should validate string format as iso8601 date', () => {
     const T = Type.String({ format: 'date-time' })
-    ok(T, '2021-06-11T20:30:00-04:00')
+    Ok(T, '2021-06-11T20:30:00-04:00')
   })
 
   it('Should validate minLength', () => {
     const T = Type.String({ minLength: 4 })
-    ok(T, '....')
-    fail(T, '...')
+    Ok(T, '....')
+    Fail(T, '...')
   })
 
   it('Should validate maxLength', () => {
     const T = Type.String({ maxLength: 4 })
-    ok(T, '....')
-    fail(T, '.....')
+    Ok(T, '....')
+    Fail(T, '.....')
   })
 
   it('Should pass numeric 5 digit test', () => {
     const T = Type.String({ pattern: '[\\d]{5}' })
-    ok(T, '12345')
+    Ok(T, '12345')
   })
 })
diff --git a/test/runtime/compiler/tuple.ts b/test/runtime/compiler/tuple.ts
index 574410d8b..63a436182 100644
--- a/test/runtime/compiler/tuple.ts
+++ b/test/runtime/compiler/tuple.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 import { Assert } from '../assert'
 
 describe('type/compiler/Tuple', () => {
@@ -7,56 +7,56 @@ describe('type/compiler/Tuple', () => {
     const A = Type.String()
     const B = Type.Number()
     const T = Type.Tuple([A, B])
-    ok(T, ['hello', 42])
+    Ok(T, ['hello', 42])
   })
 
   it('Should not validate tuple of [string, number] when reversed', () => {
     const A = Type.String()
     const B = Type.Number()
     const T = Type.Tuple([A, B])
-    fail(T, [42, 'hello'])
+    Fail(T, [42, 'hello'])
   })
 
   it('Should validate with empty tuple', () => {
     const T = Type.Tuple([])
-    ok(T, [])
+    Ok(T, [])
   })
 
   it('Should not validate with empty tuple with more items', () => {
     const T = Type.Tuple([])
-    fail(T, [1])
+    Fail(T, [1])
   })
 
   it('Should not validate with empty tuple with less items', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
-    fail(T, [1])
+    Fail(T, [1])
   })
 
   it('Should validate tuple of objects', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
     const T = Type.Tuple([A, B])
-    ok(T, [{ a: 'hello' }, { b: 42 }])
+    Ok(T, [{ a: 'hello' }, { b: 42 }])
   })
 
   it('Should not validate tuple of objects when reversed', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
     const T = Type.Tuple([A, B])
-    fail(T, [{ b: 42 }, { a: 'hello' }])
+    Fail(T, [{ b: 42 }, { a: 'hello' }])
   })
 
   it('Should not validate tuple when array is less than tuple length', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
     const T = Type.Tuple([A, B])
-    fail(T, [{ a: 'hello' }])
+    Fail(T, [{ a: 'hello' }])
   })
 
   it('Should not validate tuple when array is greater than tuple length', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
     const T = Type.Tuple([A, B])
-    fail(T, [{ a: 'hello' }, { b: 42 }, { b: 42 }])
+    Fail(T, [{ a: 'hello' }, { b: 42 }, { b: 42 }])
   })
 })
diff --git a/test/runtime/compiler/uint8array.ts b/test/runtime/compiler/uint8array.ts
index 9a552e53d..ae94d7872 100644
--- a/test/runtime/compiler/uint8array.ts
+++ b/test/runtime/compiler/uint8array.ts
@@ -1,56 +1,56 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Uint8Array', () => {
   it('Should not validate number', () => {
     const T = Type.Uint8Array()
-    fail(T, 1)
+    Fail(T, 1)
   })
 
   it('Should not validate string', () => {
     const T = Type.Uint8Array()
-    fail(T, 'hello')
+    Fail(T, 'hello')
   })
 
   it('Should not validate boolean', () => {
     const T = Type.Uint8Array()
-    fail(T, true)
+    Fail(T, true)
   })
 
   it('Should not validate array', () => {
     const T = Type.Uint8Array()
-    fail(T, [1, 2, 3])
+    Fail(T, [1, 2, 3])
   })
 
   it('Should not validate object', () => {
     const T = Type.Uint8Array()
-    fail(T, { a: 1, b: 2 })
+    Fail(T, { a: 1, b: 2 })
   })
 
   it('Should not validate null', () => {
     const T = Type.Uint8Array()
-    fail(T, null)
+    Fail(T, null)
   })
 
   it('Should not validate undefined', () => {
     const T = Type.Uint8Array()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
 
   it('Should validate Uint8Array', () => {
     const T = Type.Uint8Array()
-    ok(T, new Uint8Array(100))
+    Ok(T, new Uint8Array(100))
   })
 
   it('Should validate minByteLength', () => {
     const T = Type.Uint8Array({ minByteLength: 4 })
-    ok(T, new Uint8Array(4))
-    fail(T, new Uint8Array(3))
+    Ok(T, new Uint8Array(4))
+    Fail(T, new Uint8Array(3))
   })
 
   it('Should validate maxByteLength', () => {
     const T = Type.Uint8Array({ maxByteLength: 4 })
-    ok(T, new Uint8Array(4))
-    fail(T, new Uint8Array(5))
+    Ok(T, new Uint8Array(4))
+    Fail(T, new Uint8Array(5))
   })
 })
diff --git a/test/runtime/compiler/union.ts b/test/runtime/compiler/union.ts
index fcf751910..8ad6e4f64 100644
--- a/test/runtime/compiler/union.ts
+++ b/test/runtime/compiler/union.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Union', () => {
   it('Should validate union of string, number and boolean', () => {
@@ -7,56 +7,56 @@ describe('type/compiler/Union', () => {
     const B = Type.Number()
     const C = Type.Boolean()
     const T = Type.Union([A, B, C])
-    ok(T, 'hello')
-    ok(T, true)
-    ok(T, 42)
+    Ok(T, 'hello')
+    Ok(T, true)
+    Ok(T, 42)
   })
 
   it('Should validate union of objects', () => {
     const A = Type.Object({ a: Type.String() }, { additionalProperties: false })
     const B = Type.Object({ b: Type.String() }, { additionalProperties: false })
     const T = Type.Union([A, B])
-    ok(T, { a: 'hello' })
-    ok(T, { b: 'world' })
+    Ok(T, { a: 'hello' })
+    Ok(T, { b: 'world' })
   })
 
   it('Should fail to validate for descriminated union types', () => {
     const A = Type.Object({ kind: Type.Literal('A'), value: Type.String() })
     const B = Type.Object({ kind: Type.Literal('B'), value: Type.Number() })
     const T = Type.Union([A, B])
-    fail(T, { kind: 'A', value: 42 }) // expect { kind: 'A', value: string }
-    fail(T, { kind: 'B', value: 'hello' }) // expect { kind: 'B', value: number }
+    Fail(T, { kind: 'A', value: 42 }) // expect { kind: 'A', value: string }
+    Fail(T, { kind: 'B', value: 'hello' }) // expect { kind: 'B', value: number }
   })
 
   it('Should validate union of objects where properties overlap', () => {
     const A = Type.Object({ a: Type.String() }, { additionalProperties: false })
     const B = Type.Object({ a: Type.String(), b: Type.String() }, { additionalProperties: false })
     const T = Type.Union([A, B])
-    ok(T, { a: 'hello' }) // A
-    ok(T, { a: 'hello', b: 'world' }) // B
+    Ok(T, { a: 'hello' }) // A
+    Ok(T, { a: 'hello', b: 'world' }) // B
   })
 
   it('Should validate union of overlapping property of varying type', () => {
     const A = Type.Object({ a: Type.String(), b: Type.Number() }, { additionalProperties: false })
     const B = Type.Object({ a: Type.String(), b: Type.String() }, { additionalProperties: false })
     const T = Type.Union([A, B])
-    ok(T, { a: 'hello', b: 42 }) // A
-    ok(T, { a: 'hello', b: 'world' }) // B
+    Ok(T, { a: 'hello', b: 42 }) // A
+    Ok(T, { a: 'hello', b: 'world' }) // B
   })
 
   it('Should validate union of literal strings', () => {
     const A = Type.Literal('hello')
     const B = Type.Literal('world')
     const T = Type.Union([A, B])
-    ok(T, 'hello') // A
-    ok(T, 'world') // B
+    Ok(T, 'hello') // A
+    Ok(T, 'world') // B
   })
 
   it('Should not validate union of literal strings for unknown string', () => {
     const A = Type.Literal('hello')
     const B = Type.Literal('world')
     const T = Type.Union([A, B])
-    fail(T, 'foo') // A
-    fail(T, 'bar') // B
+    Fail(T, 'foo') // A
+    Fail(T, 'bar') // B
   })
 })
diff --git a/test/runtime/compiler/unknown.ts b/test/runtime/compiler/unknown.ts
index 7f3cb116d..30376d8e3 100644
--- a/test/runtime/compiler/unknown.ts
+++ b/test/runtime/compiler/unknown.ts
@@ -1,33 +1,33 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Unknown', () => {
   it('Should validate number', () => {
     const T = Type.Any()
-    ok(T, 1)
+    Ok(T, 1)
   })
   it('Should validate string', () => {
     const T = Type.Any()
-    ok(T, 'hello')
+    Ok(T, 'hello')
   })
   it('Should validate boolean', () => {
     const T = Type.Any()
-    ok(T, true)
+    Ok(T, true)
   })
   it('Should validate array', () => {
     const T = Type.Any()
-    ok(T, [1, 2, 3])
+    Ok(T, [1, 2, 3])
   })
   it('Should validate object', () => {
     const T = Type.Any()
-    ok(T, { a: 1, b: 2 })
+    Ok(T, { a: 1, b: 2 })
   })
   it('Should validate null', () => {
     const T = Type.Any()
-    ok(T, null)
+    Ok(T, null)
   })
   it('Should validate undefined', () => {
     const T = Type.Any()
-    ok(T, undefined)
+    Ok(T, undefined)
   })
 })
diff --git a/test/runtime/compiler/validate.ts b/test/runtime/compiler/validate.ts
index 4d2ba2f69..c242768a3 100644
--- a/test/runtime/compiler/validate.ts
+++ b/test/runtime/compiler/validate.ts
@@ -63,7 +63,7 @@ Format.Set('email', (value) => EMAIL.test(value))
 Format.Set('uuid', (value) => UUID.test(value))
 Format.Set('date-time', (value) => isDateTime(value, true))
 
-export function ok<T extends TSchema>(schema: T, data: unknown, references: any[] = []) {
+export function Ok<T extends TSchema>(schema: T, data: unknown, references: any[] = []) {
   const C = TypeCompiler.Compile(schema, references)
   const result = C.Check(data)
   if (result !== Value.Check(schema, references, data)) {
@@ -73,6 +73,10 @@ export function ok<T extends TSchema>(schema: T, data: unknown, references: any[
     const errors = [...Value.Errors(schema, references, data)]
     if (errors.length === 0) throw Error('expected at least 1 error')
   }
+  if (result === true) {
+    const errors = [...Value.Errors(schema, references, data)]
+    if (errors.length > 0) throw Error('expected no errors')
+  }
   if (!result) {
     console.log('---------------------------')
     console.log('type')
@@ -90,13 +94,17 @@ export function ok<T extends TSchema>(schema: T, data: unknown, references: any[
   }
 }
 
-export function fail<T extends TSchema>(schema: T, data: unknown, references: any[] = []) {
+export function Fail<T extends TSchema>(schema: T, data: unknown, references: any[] = []) {
   const C = TypeCompiler.Compile(schema, references)
   const result = C.Check(data)
   if (result === false) {
     const errors = [...Value.Errors(schema, references, data)]
     if (errors.length === 0) throw Error('expected at least 1 error')
   }
+  if (result === true) {
+    const errors = [...Value.Errors(schema, references, data)]
+    if (errors.length > 0) throw Error('expected no errors')
+  }
   if (result) {
     console.log('---------------------------')
     console.log('type')
diff --git a/test/runtime/compiler/void.ts b/test/runtime/compiler/void.ts
index 3beefc21d..a5e80992e 100644
--- a/test/runtime/compiler/void.ts
+++ b/test/runtime/compiler/void.ts
@@ -1,39 +1,39 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/compiler/Void', () => {
   it('Should not validate number', () => {
     const T = Type.Void()
-    fail(T, 1)
+    Fail(T, 1)
   })
 
   it('Should not validate string', () => {
     const T = Type.Void()
-    fail(T, 'hello')
+    Fail(T, 'hello')
   })
 
   it('Should not validate boolean', () => {
     const T = Type.Void()
-    fail(T, true)
+    Fail(T, true)
   })
 
   it('Should not validate array', () => {
     const T = Type.Void()
-    fail(T, [1, 2, 3])
+    Fail(T, [1, 2, 3])
   })
 
   it('Should not validate object', () => {
     const T = Type.Void()
-    fail(T, { a: 1, b: 2 })
+    Fail(T, { a: 1, b: 2 })
   })
 
   it('Should validate null', () => {
     const T = Type.Null()
-    ok(T, null)
+    Ok(T, null)
   })
 
   it('Should not validate undefined', () => {
     const T = Type.Void()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
 })
diff --git a/test/runtime/index.ts b/test/runtime/index.ts
index f5ed2d8cd..095140dab 100644
--- a/test/runtime/index.ts
+++ b/test/runtime/index.ts
@@ -5,4 +5,5 @@ import './format/index'
 import './guard/index'
 import './hash/index'
 import './schema/index'
+import './settings/index'
 import './value/index'
diff --git a/test/runtime/schema/any.ts b/test/runtime/schema/any.ts
index 6ffcb54c5..3e857c831 100644
--- a/test/runtime/schema/any.ts
+++ b/test/runtime/schema/any.ts
@@ -1,33 +1,33 @@
 import { Type } from '@sinclair/typebox'
-import { ok } from './validate'
+import { Ok } from './validate'
 
 describe('type/schema/Any', () => {
   it('Should validate number', () => {
     const T = Type.Any()
-    ok(T, 1)
+    Ok(T, 1)
   })
   it('Should validate string', () => {
     const T = Type.Any()
-    ok(T, 'hello')
+    Ok(T, 'hello')
   })
   it('Should validate boolean', () => {
     const T = Type.Any()
-    ok(T, true)
+    Ok(T, true)
   })
   it('Should validate array', () => {
     const T = Type.Any()
-    ok(T, [1, 2, 3])
+    Ok(T, [1, 2, 3])
   })
   it('Should validate object', () => {
     const T = Type.Any()
-    ok(T, { a: 1, b: 2 })
+    Ok(T, { a: 1, b: 2 })
   })
   it('Should validate null', () => {
     const T = Type.Any()
-    ok(T, null)
+    Ok(T, null)
   })
   it('Should validate undefined', () => {
     const T = Type.Any()
-    ok(T, undefined)
+    Ok(T, undefined)
   })
 })
diff --git a/test/runtime/schema/array.ts b/test/runtime/schema/array.ts
index 57df3662a..3b9b972b6 100644
--- a/test/runtime/schema/array.ts
+++ b/test/runtime/schema/array.ts
@@ -1,30 +1,30 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Array', () => {
   it('Should validate an array of any', () => {
     const T = Type.Array(Type.Any())
-    ok(T, [0, true, 'hello', {}])
+    Ok(T, [0, true, 'hello', {}])
   })
 
   it('Should not validate varying array when item is number', () => {
     const T = Type.Array(Type.Number())
-    fail(T, [1, 2, 3, 'hello'])
+    Fail(T, [1, 2, 3, 'hello'])
   })
 
   it('Should validate for an array of unions', () => {
     const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
-    ok(T, [1, 'hello', 3, 'world'])
+    Ok(T, [1, 'hello', 3, 'world'])
   })
 
   it('Should not validate for an array of unions where item is not in union.', () => {
     const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
-    fail(T, [1, 'hello', 3, 'world', true])
+    Fail(T, [1, 'hello', 3, 'world', true])
   })
 
   it('Should validate for an empty array', () => {
     const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
-    ok(T, [])
+    Ok(T, [])
   })
 
   it('Should validate for an array of intersection types', () => {
@@ -32,7 +32,7 @@ describe('type/schema/Array', () => {
     const B = Type.Object({ b: Type.String() })
     const C = Type.Intersect([A, B])
     const T = Type.Array(C)
-    ok(T, [
+    Ok(T, [
       { a: 'hello', b: 'hello' },
       { a: 'hello', b: 'hello' },
       { a: 'hello', b: 'hello' },
@@ -44,7 +44,7 @@ describe('type/schema/Array', () => {
     const B = Type.Object({ b: Type.String() })
     const C = Type.Intersect([A, B], { additionalProperties: false })
     const T = Type.Array(C)
-    fail(T, [
+    Fail(T, [
       { a: 'hello', b: 'hello' },
       { a: 'hello', b: 'hello' },
       { a: 'hello', b: 'hello', c: 'additional' },
@@ -56,7 +56,7 @@ describe('type/schema/Array', () => {
     const B = Type.Number()
     const C = Type.Tuple([A, B])
     const T = Type.Array(C)
-    ok(T, [
+    Ok(T, [
       ['hello', 1],
       ['hello', 1],
       ['hello', 1],
@@ -68,7 +68,7 @@ describe('type/schema/Array', () => {
     const B = Type.Number()
     const C = Type.Tuple([A, B])
     const T = Type.Array(C)
-    fail(T, [
+    Fail(T, [
       [1, 'hello'],
       [1, 'hello'],
       [1, 'hello'],
@@ -76,28 +76,28 @@ describe('type/schema/Array', () => {
   })
   it('Should not validate array with failed minItems', () => {
     const T = Type.Array(Type.Number(), { minItems: 3 })
-    fail(T, [0, 1])
+    Fail(T, [0, 1])
   })
   it('Should not validate array with failed maxItems', () => {
     const T = Type.Array(Type.Number(), { maxItems: 3 })
-    fail(T, [0, 1, 2, 3])
+    Fail(T, [0, 1, 2, 3])
   })
   it('Should validate array with uniqueItems when items are distinct objects', () => {
     const T = Type.Array(Type.Object({ x: Type.Number(), y: Type.Number() }), { uniqueItems: true })
-    ok(T, [
+    Ok(T, [
       { x: 0, y: 1 },
       { x: 1, y: 0 },
     ])
   })
   it('Should not validate array with uniqueItems when items are not distinct objects', () => {
     const T = Type.Array(Type.Object({ x: Type.Number(), y: Type.Number() }), { uniqueItems: true })
-    fail(T, [
+    Fail(T, [
       { x: 1, y: 0 },
       { x: 1, y: 0 },
     ])
   })
   it('Should not validate array with non uniqueItems', () => {
     const T = Type.Array(Type.Number(), { uniqueItems: true })
-    fail(T, [0, 0])
+    Fail(T, [0, 0])
   })
 })
diff --git a/test/runtime/schema/boolean.ts b/test/runtime/schema/boolean.ts
index 4402a1b60..a784cf6b9 100644
--- a/test/runtime/schema/boolean.ts
+++ b/test/runtime/schema/boolean.ts
@@ -1,40 +1,40 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Boolean', () => {
   it('Should validate a boolean', () => {
     const T = Type.Boolean()
-    ok(T, true)
-    ok(T, false)
+    Ok(T, true)
+    Ok(T, false)
   })
 
   it('Should not validate a number', () => {
     const T = Type.Boolean()
-    fail(T, 1)
+    Fail(T, 1)
   })
 
   it('Should not validate a string', () => {
     const T = Type.Boolean()
-    fail(T, 'true')
+    Fail(T, 'true')
   })
 
   it('Should not validate an array', () => {
     const T = Type.Boolean()
-    fail(T, [true])
+    Fail(T, [true])
   })
 
   it('Should not validate an object', () => {
     const T = Type.Boolean()
-    fail(T, {})
+    Fail(T, {})
   })
 
   it('Should not validate an null', () => {
     const T = Type.Boolean()
-    fail(T, null)
+    Fail(T, null)
   })
 
   it('Should not validate an undefined', () => {
     const T = Type.Boolean()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
 })
diff --git a/test/runtime/schema/date.ts b/test/runtime/schema/date.ts
index 8e468665c..2e0672e95 100644
--- a/test/runtime/schema/date.ts
+++ b/test/runtime/schema/date.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 // ----------------------------------------------------
 // These tests are implemented by way of .addKeyword()
@@ -9,54 +9,54 @@ import { ok, fail } from './validate'
 describe('type/schema/Date', () => {
   it('Should not validate number', () => {
     const T = Type.Date()
-    fail(T, 1)
+    Fail(T, 1)
   })
   it('Should not validate string', () => {
     const T = Type.Date()
-    fail(T, 'hello')
+    Fail(T, 'hello')
   })
   it('Should not validate boolean', () => {
     const T = Type.Date()
-    fail(T, true)
+    Fail(T, true)
   })
   it('Should not validate array', () => {
     const T = Type.Date()
-    fail(T, [1, 2, 3])
+    Fail(T, [1, 2, 3])
   })
   it('Should not validate object', () => {
     const T = Type.Date()
-    fail(T, { a: 1, b: 2 })
+    Fail(T, { a: 1, b: 2 })
   })
   it('Should not validate null', () => {
     const T = Type.Date()
-    fail(T, null)
+    Fail(T, null)
   })
   it('Should not validate undefined', () => {
     const T = Type.Date()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
   it('Should validate Date', () => {
     const T = Type.Date()
-    ok(T, new Date())
+    Ok(T, new Date())
   })
   it('Should validate Date minimumTimestamp', () => {
     const T = Type.Date({ minimumTimestamp: 10 })
-    fail(T, new Date(9))
-    ok(T, new Date(10))
+    Fail(T, new Date(9))
+    Ok(T, new Date(10))
   })
   it('Should validate Date maximumTimestamp', () => {
     const T = Type.Date({ maximumTimestamp: 10 })
-    ok(T, new Date(10))
-    fail(T, new Date(11))
+    Ok(T, new Date(10))
+    Fail(T, new Date(11))
   })
   it('Should validate Date exclusiveMinimumTimestamp', () => {
     const T = Type.Date({ exclusiveMinimumTimestamp: 10 })
-    fail(T, new Date(10))
-    ok(T, new Date(11))
+    Fail(T, new Date(10))
+    Ok(T, new Date(11))
   })
   it('Should validate Date exclusiveMaximumTimestamp', () => {
     const T = Type.Date({ exclusiveMaximumTimestamp: 10 })
-    ok(T, new Date(9))
-    fail(T, new Date(10))
+    Ok(T, new Date(9))
+    Fail(T, new Date(10))
   })
 })
diff --git a/test/runtime/schema/enum.ts b/test/runtime/schema/enum.ts
index dbdbacf4c..4e52e0ead 100644
--- a/test/runtime/schema/enum.ts
+++ b/test/runtime/schema/enum.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Enum', () => {
   it('Should validate when emum uses default numeric values', () => {
@@ -8,8 +8,8 @@ describe('type/schema/Enum', () => {
       Bar, // = 1
     }
     const T = Type.Enum(Kind)
-    ok(T, 0)
-    ok(T, 1)
+    Ok(T, 0)
+    Ok(T, 1)
   })
   it('Should not validate when given enum values are not numeric', () => {
     enum Kind {
@@ -17,8 +17,8 @@ describe('type/schema/Enum', () => {
       Bar, // = 1
     }
     const T = Type.Enum(Kind)
-    fail(T, 'Foo')
-    fail(T, 'Bar')
+    Fail(T, 'Foo')
+    Fail(T, 'Bar')
   })
 
   it('Should validate when emum has defined string values', () => {
@@ -27,8 +27,8 @@ describe('type/schema/Enum', () => {
       Bar = 'bar',
     }
     const T = Type.Enum(Kind)
-    ok(T, 'foo')
-    ok(T, 'bar')
+    Ok(T, 'foo')
+    Ok(T, 'bar')
   })
 
   it('Should not validate when emum has defined string values and user passes numeric', () => {
@@ -37,8 +37,8 @@ describe('type/schema/Enum', () => {
       Bar = 'bar',
     }
     const T = Type.Enum(Kind)
-    fail(T, 0)
-    fail(T, 1)
+    Fail(T, 0)
+    Fail(T, 1)
   })
 
   it('Should validate when enum has one or more string values', () => {
@@ -47,10 +47,10 @@ describe('type/schema/Enum', () => {
       Bar = 'bar',
     }
     const T = Type.Enum(Kind)
-    ok(T, 0)
-    ok(T, 'bar')
-    fail(T, 'baz')
-    fail(T, 'Foo')
-    fail(T, 1)
+    Ok(T, 0)
+    Ok(T, 'bar')
+    Fail(T, 'baz')
+    Fail(T, 'Foo')
+    Fail(T, 1)
   })
 })
diff --git a/test/runtime/schema/integer.ts b/test/runtime/schema/integer.ts
index d176053ab..281774ac3 100644
--- a/test/runtime/schema/integer.ts
+++ b/test/runtime/schema/integer.ts
@@ -1,71 +1,71 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Integer', () => {
   it('Should not validate number', () => {
     const T = Type.Integer()
-    fail(T, 3.14)
+    Fail(T, 3.14)
   })
 
   it('Should validate integer', () => {
     const T = Type.Integer()
-    ok(T, 1)
+    Ok(T, 1)
   })
 
   it('Should not validate string', () => {
     const T = Type.Integer()
-    fail(T, 'hello')
+    Fail(T, 'hello')
   })
 
   it('Should not validate boolean', () => {
     const T = Type.Integer()
-    fail(T, true)
+    Fail(T, true)
   })
 
   it('Should not validate array', () => {
     const T = Type.Integer()
-    fail(T, [1, 2, 3])
+    Fail(T, [1, 2, 3])
   })
 
   it('Should not validate object', () => {
     const T = Type.Integer()
-    fail(T, { a: 1, b: 2 })
+    Fail(T, { a: 1, b: 2 })
   })
 
   it('Should not validate null', () => {
     const T = Type.Integer()
-    fail(T, null)
+    Fail(T, null)
   })
   it('Should not validate undefined', () => {
     const T = Type.Integer()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
 
   it('Should validate minimum', () => {
     const T = Type.Integer({ minimum: 10 })
-    fail(T, 9)
-    ok(T, 10)
+    Fail(T, 9)
+    Ok(T, 10)
   })
 
   it('Should validate maximum', () => {
     const T = Type.Integer({ maximum: 10 })
-    ok(T, 10)
-    fail(T, 11)
+    Ok(T, 10)
+    Fail(T, 11)
   })
 
   it('Should validate Date exclusiveMinimum', () => {
     const T = Type.Integer({ exclusiveMinimum: 10 })
-    fail(T, 10)
-    ok(T, 11)
+    Fail(T, 10)
+    Ok(T, 11)
   })
 
   it('Should validate Date exclusiveMaximum', () => {
     const T = Type.Integer({ exclusiveMaximum: 10 })
-    ok(T, 9)
-    fail(T, 10)
+    Ok(T, 9)
+    Fail(T, 10)
   })
 
   it('Should not validate NaN', () => {
-    fail(Type.Integer(), NaN)
+    Fail(Type.Integer(), NaN)
   })
 })
diff --git a/test/runtime/schema/intersect.ts b/test/runtime/schema/intersect.ts
index 24e3406ba..e1671dbc3 100644
--- a/test/runtime/schema/intersect.ts
+++ b/test/runtime/schema/intersect.ts
@@ -1,42 +1,42 @@
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Intersect', () => {
   it('Should intersect two objects', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
     const T = Type.Intersect([A, B], { additionalProperties: false })
-    ok(T, { a: 'hello', b: 42 })
+    Ok(T, { a: 'hello', b: 42 })
   })
 
   it('Should intersect with partial', () => {
     const A = Type.Partial(Type.Object({ a: Type.Number() }))
     const B = Type.Partial(Type.Object({ b: Type.Number() }))
     const P = Type.Intersect([A, B], { additionalProperties: false })
-    ok(P, { a: 1, b: 2 })
-    ok(P, { a: 1 })
-    ok(P, { b: 1 })
-    ok(P, {})
-    fail(P, { c: 1 })
+    Ok(P, { a: 1, b: 2 })
+    Ok(P, { a: 1 })
+    Ok(P, { b: 1 })
+    Ok(P, {})
+    Fail(P, { c: 1 })
   })
 
   it('Should intersect with overlapping same type', () => {
     const A = Type.Object({ a: Type.Number() })
     const B = Type.Object({ a: Type.Number() })
     const P = Type.Intersect([A, B])
-    ok(P, { a: 1 })
-    fail(P, { a: 'hello' })
-    fail(P, {})
+    Ok(P, { a: 1 })
+    Fail(P, { a: 'hello' })
+    Fail(P, {})
   })
 
   it('Should intersect with overlapping varying type', () => {
     const A = Type.Object({ a: Type.Number() })
     const B = Type.Object({ a: Type.String() })
     const T = Type.Intersect([A, B])
-    ok(T, { a: 1 })
-    ok(T, { a: 'hello' })
-    fail(T, {})
+    Ok(T, { a: 1 })
+    Ok(T, { a: 'hello' })
+    Fail(T, {})
   })
 
   it('Should intersect with deeply nest overlapping varying type', () => {
@@ -45,12 +45,12 @@ describe('type/schema/Intersect', () => {
     const C = Type.Object({ a: Type.Boolean() })
     const D = Type.Object({ a: Type.Null() })
     const T = Type.Intersect([A, B, C, D])
-    ok(T, { a: 1 })
-    ok(T, { a: 'hello' })
-    ok(T, { a: false })
-    ok(T, { a: null })
-    fail(T, { a: [] })
-    fail(T, {})
+    Ok(T, { a: 1 })
+    Ok(T, { a: 'hello' })
+    Ok(T, { a: false })
+    Ok(T, { a: null })
+    Fail(T, { a: [] })
+    Fail(T, {})
   })
 
   it('Should pick from intersected type', () => {
@@ -59,8 +59,8 @@ describe('type/schema/Intersect', () => {
     const C = Type.Object({ z: Type.Number() })
     const T = Type.Intersect([A, B, C])
     const P = Type.Pick(T, ['x', 'y'], { additionalProperties: false })
-    ok(P, { x: 1, y: 1 })
-    fail(P, { x: 1, y: 1, z: 1 })
+    Ok(P, { x: 1, y: 1 })
+    Fail(P, { x: 1, y: 1, z: 1 })
   })
 
   it('Should omit from intersected type', () => {
@@ -69,17 +69,17 @@ describe('type/schema/Intersect', () => {
     const C = Type.Object({ z: Type.Number() })
     const T = Type.Intersect([A, B, C])
     const P = Type.Omit(T, ['z'], { additionalProperties: false })
-    ok(P, { x: 1, y: 1 })
-    fail(P, { x: 1, y: 1, z: 1 })
+    Ok(P, { x: 1, y: 1 })
+    Fail(P, { x: 1, y: 1, z: 1 })
   })
 
   it('Should intersect nested object properties', () => {
     const A = Type.Object({ x: Type.Object({ x: Type.Number() }) })
     const B = Type.Object({ x: Type.Object({ x: Type.String() }) })
     const T = Type.Intersect([A, B])
-    ok(T, { x: { x: 1 } })
-    ok(T, { x: { x: 'hello' } })
-    fail(T, { x: { x: false } })
+    Ok(T, { x: { x: 1 } })
+    Ok(T, { x: { x: 'hello' } })
+    Fail(T, { x: { x: false } })
   })
 
   // todo: move to composition / type guard spec
diff --git a/test/runtime/schema/keyof.ts b/test/runtime/schema/keyof.ts
index d929b3770..f637ee5f0 100644
--- a/test/runtime/schema/keyof.ts
+++ b/test/runtime/schema/keyof.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
 describe('type/schema/KeyOf', () => {
@@ -11,10 +11,10 @@ describe('type/schema/KeyOf', () => {
         z: Type.Number(),
       }),
     )
-    ok(T, 'x')
-    ok(T, 'y')
-    ok(T, 'z')
-    fail(T, 'w')
+    Ok(T, 'x')
+    Ok(T, 'y')
+    Ok(T, 'z')
+    Fail(T, 'w')
   })
 
   it('Should validate when using pick', () => {
@@ -28,9 +28,9 @@ describe('type/schema/KeyOf', () => {
         ['x', 'y'],
       ),
     )
-    ok(T, 'x')
-    ok(T, 'y')
-    fail(T, 'z')
+    Ok(T, 'x')
+    Ok(T, 'y')
+    Fail(T, 'z')
   })
 
   it('Should validate when using omit', () => {
@@ -45,8 +45,8 @@ describe('type/schema/KeyOf', () => {
       ),
     )
 
-    fail(T, 'x')
-    fail(T, 'y')
-    ok(T, 'z')
+    Fail(T, 'x')
+    Fail(T, 'y')
+    Ok(T, 'z')
   })
 })
diff --git a/test/runtime/schema/literal.ts b/test/runtime/schema/literal.ts
index 92b065986..fe5e0f578 100644
--- a/test/runtime/schema/literal.ts
+++ b/test/runtime/schema/literal.ts
@@ -1,43 +1,43 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Literal', () => {
   it('Should validate literal number', () => {
     const T = Type.Literal(42)
-    ok(T, 42)
+    Ok(T, 42)
   })
   it('Should validate literal string', () => {
     const T = Type.Literal('hello')
-    ok(T, 'hello')
+    Ok(T, 'hello')
   })
 
   it('Should validate literal boolean', () => {
     const T = Type.Literal(true)
-    ok(T, true)
+    Ok(T, true)
   })
 
   it('Should not validate invalid literal number', () => {
     const T = Type.Literal(42)
-    fail(T, 43)
+    Fail(T, 43)
   })
   it('Should not validate invalid literal string', () => {
     const T = Type.Literal('hello')
-    fail(T, 'world')
+    Fail(T, 'world')
   })
   it('Should not validate invalid literal boolean', () => {
     const T = Type.Literal(false)
-    fail(T, true)
+    Fail(T, true)
   })
 
   it('Should validate literal union', () => {
     const T = Type.Union([Type.Literal(42), Type.Literal('hello')])
-    ok(T, 42)
-    ok(T, 'hello')
+    Ok(T, 42)
+    Ok(T, 'hello')
   })
 
   it('Should not validate invalid literal union', () => {
     const T = Type.Union([Type.Literal(42), Type.Literal('hello')])
-    fail(T, 43)
-    fail(T, 'world')
+    Fail(T, 43)
+    Fail(T, 'world')
   })
 })
diff --git a/test/runtime/schema/never.ts b/test/runtime/schema/never.ts
index a32e4b66b..8a3f6e386 100644
--- a/test/runtime/schema/never.ts
+++ b/test/runtime/schema/never.ts
@@ -1,33 +1,33 @@
 import { Type } from '@sinclair/typebox'
-import { fail } from './validate'
+import { Fail } from './validate'
 
 describe('type/schema/Never', () => {
   it('Should not validate number', () => {
     const T = Type.Never()
-    fail(T, 1)
+    Fail(T, 1)
   })
   it('Should not validate string', () => {
     const T = Type.Never()
-    fail(T, 'hello')
+    Fail(T, 'hello')
   })
   it('Should not validate boolean', () => {
     const T = Type.Never()
-    fail(T, true)
+    Fail(T, true)
   })
   it('Should not validate array', () => {
     const T = Type.Never()
-    fail(T, [1, 2, 3])
+    Fail(T, [1, 2, 3])
   })
   it('Should not validate object', () => {
     const T = Type.Never()
-    fail(T, { a: 1, b: 2 })
+    Fail(T, { a: 1, b: 2 })
   })
   it('Should not validate null', () => {
     const T = Type.Never()
-    fail(T, null)
+    Fail(T, null)
   })
   it('Should validate undefined', () => {
     const T = Type.Never()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
 })
diff --git a/test/runtime/schema/null.ts b/test/runtime/schema/null.ts
index 8d5dca921..bd9c709bb 100644
--- a/test/runtime/schema/null.ts
+++ b/test/runtime/schema/null.ts
@@ -1,39 +1,39 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Null', () => {
   it('Should not validate number', () => {
     const T = Type.Null()
-    fail(T, 1)
+    Fail(T, 1)
   })
 
   it('Should not validate string', () => {
     const T = Type.Null()
-    fail(T, 'hello')
+    Fail(T, 'hello')
   })
 
   it('Should not validate boolean', () => {
     const T = Type.Null()
-    fail(T, true)
+    Fail(T, true)
   })
 
   it('Should not validate array', () => {
     const T = Type.Null()
-    fail(T, [1, 2, 3])
+    Fail(T, [1, 2, 3])
   })
 
   it('Should not validate object', () => {
     const T = Type.Null()
-    fail(T, { a: 1, b: 2 })
+    Fail(T, { a: 1, b: 2 })
   })
 
   it('Should not validate null', () => {
     const T = Type.Null()
-    ok(T, null)
+    Ok(T, null)
   })
 
   it('Should not validate undefined', () => {
     const T = Type.Null()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
 })
diff --git a/test/runtime/schema/number.ts b/test/runtime/schema/number.ts
index 3b3d6fc36..99140d591 100644
--- a/test/runtime/schema/number.ts
+++ b/test/runtime/schema/number.ts
@@ -1,67 +1,67 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Number', () => {
   it('Should validate number', () => {
     const T = Type.Number()
-    ok(T, 3.14)
+    Ok(T, 3.14)
   })
 
   it('Should validate integer', () => {
     const T = Type.Number()
-    ok(T, 1)
+    Ok(T, 1)
   })
 
   it('Should not validate string', () => {
     const T = Type.Number()
-    fail(T, 'hello')
+    Fail(T, 'hello')
   })
   it('Should not validate boolean', () => {
     const T = Type.Number()
-    fail(T, true)
+    Fail(T, true)
   })
   it('Should not validate array', () => {
     const T = Type.Number()
-    fail(T, [1, 2, 3])
+    Fail(T, [1, 2, 3])
   })
   it('Should not validate object', () => {
     const T = Type.Number()
-    fail(T, { a: 1, b: 2 })
+    Fail(T, { a: 1, b: 2 })
   })
   it('Should not validate null', () => {
     const T = Type.Number()
-    fail(T, null)
+    Fail(T, null)
   })
   it('Should not validate undefined', () => {
     const T = Type.Number()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
 
   it('Should validate minimum', () => {
     const T = Type.Number({ minimum: 10 })
-    fail(T, 9)
-    ok(T, 10)
+    Fail(T, 9)
+    Ok(T, 10)
   })
 
   it('Should validate maximum', () => {
     const T = Type.Number({ maximum: 10 })
-    ok(T, 10)
-    fail(T, 11)
+    Ok(T, 10)
+    Fail(T, 11)
   })
 
   it('Should validate Date exclusiveMinimum', () => {
     const T = Type.Number({ exclusiveMinimum: 10 })
-    fail(T, 10)
-    ok(T, 11)
+    Fail(T, 10)
+    Ok(T, 11)
   })
 
   it('Should validate Date exclusiveMaximum', () => {
     const T = Type.Number({ exclusiveMaximum: 10 })
-    ok(T, 9)
-    fail(T, 10)
+    Ok(T, 9)
+    Fail(T, 10)
   })
 
   it('Should not validate NaN', () => {
-    fail(Type.Number(), NaN)
+    Fail(Type.Number(), NaN)
   })
 })
diff --git a/test/runtime/schema/object.ts b/test/runtime/schema/object.ts
index 658daea41..98b9a2761 100644
--- a/test/runtime/schema/object.ts
+++ b/test/runtime/schema/object.ts
@@ -1,30 +1,30 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Object', () => {
   it('Should not validate a number', () => {
     const T = Type.Object({})
-    fail(T, 42)
+    Fail(T, 42)
   })
 
   it('Should not validate a string', () => {
     const T = Type.Object({})
-    fail(T, 'hello')
+    Fail(T, 'hello')
   })
 
   it('Should not validate a boolean', () => {
     const T = Type.Object({})
-    fail(T, true)
+    Fail(T, true)
   })
 
   it('Should not validate a null', () => {
     const T = Type.Object({})
-    fail(T, null)
+    Fail(T, null)
   })
 
   it('Should not validate an array', () => {
     const T = Type.Object({})
-    fail(T, [1, 2])
+    Fail(T, [1, 2])
   })
 
   it('Should validate with correct property values', () => {
@@ -35,7 +35,7 @@ describe('type/schema/Object', () => {
       d: Type.Array(Type.Number()),
       e: Type.Object({ x: Type.Number(), y: Type.Number() }),
     })
-    ok(T, {
+    Ok(T, {
       a: 10,
       b: 'hello',
       c: true,
@@ -52,7 +52,7 @@ describe('type/schema/Object', () => {
       d: Type.Array(Type.Number()),
       e: Type.Object({ x: Type.Number(), y: Type.Number() }),
     })
-    fail(T, {
+    Fail(T, {
       a: 'not a number', // error
       b: 'hello',
       c: true,
@@ -66,7 +66,7 @@ describe('type/schema/Object', () => {
       a: Type.Number(),
       b: Type.String(),
     })
-    ok(T, {
+    Ok(T, {
       a: 1,
       b: 'hello',
       c: true,
@@ -81,9 +81,9 @@ describe('type/schema/Object', () => {
       },
       { additionalProperties: false, minProperties: 1 },
     )
-    ok(T, { a: 1 })
-    ok(T, { b: 'hello' })
-    fail(T, {})
+    Ok(T, { a: 1 })
+    Ok(T, { b: 'hello' })
+    Fail(T, {})
   })
 
   it('Should not allow 3 properties if maxProperties is set to 2', () => {
@@ -95,9 +95,9 @@ describe('type/schema/Object', () => {
       },
       { additionalProperties: false, maxProperties: 2 },
     )
-    ok(T, { a: 1 })
-    ok(T, { a: 1, b: 'hello' })
-    fail(T, {
+    Ok(T, { a: 1 })
+    Ok(T, { a: 1, b: 'hello' })
+    Fail(T, {
       a: 1,
       b: 'hello',
       c: true,
@@ -112,7 +112,7 @@ describe('type/schema/Object', () => {
       },
       { additionalProperties: false },
     )
-    fail(T, {
+    Fail(T, {
       a: 1,
       b: 'hello',
       c: true,
@@ -121,8 +121,8 @@ describe('type/schema/Object', () => {
 
   it('Should not allow properties for an empty object when additionalProperties is false', () => {
     const T = Type.Object({}, { additionalProperties: false })
-    ok(T, {})
-    fail(T, { a: 10 })
+    Ok(T, {})
+    Fail(T, { a: 10 })
   })
 
   it('Should validate with non-syntax property keys', () => {
@@ -132,7 +132,7 @@ describe('type/schema/Object', () => {
       '$-leading': Type.Literal(3),
       '!@#$%^&*(': Type.Literal(4),
     })
-    ok(T, {
+    Ok(T, {
       'with-hyphen': 1,
       '0-leading': 2,
       '$-leading': 3,
@@ -150,12 +150,12 @@ describe('type/schema/Object', () => {
         additionalProperties: Type.String(),
       },
     )
-    ok(T, {
+    Ok(T, {
       x: 1,
       y: 2,
       z: 'hello',
     })
-    fail(T, {
+    Fail(T, {
       x: 1,
       y: 2,
       z: 3,
@@ -172,12 +172,12 @@ describe('type/schema/Object', () => {
         additionalProperties: Type.Array(Type.Number()),
       },
     )
-    ok(T, {
+    Ok(T, {
       x: 1,
       y: 2,
       z: [0, 1, 2],
     })
-    fail(T, {
+    Fail(T, {
       x: 1,
       y: 2,
       z: 3,
@@ -196,12 +196,12 @@ describe('type/schema/Object', () => {
         }),
       },
     )
-    ok(T, {
+    Ok(T, {
       x: 1,
       y: 2,
       z: { z: 1 },
     })
-    fail(T, {
+    Fail(T, {
       x: 1,
       y: 2,
       z: 3,
diff --git a/test/runtime/schema/omit.ts b/test/runtime/schema/omit.ts
index b605646f5..3ba6a3aa3 100644
--- a/test/runtime/schema/omit.ts
+++ b/test/runtime/schema/omit.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
 describe('type/schema/Omit', () => {
@@ -13,7 +13,7 @@ describe('type/schema/Omit', () => {
       { additionalProperties: false },
     )
     const T = Type.Omit(A, ['z'])
-    ok(T, { x: 1, y: 1 })
+    Ok(T, { x: 1, y: 1 })
   })
 
   it('Should remove required properties on the target schema', () => {
@@ -67,7 +67,7 @@ describe('type/schema/Omit', () => {
       y: Type.Number(),
     })
     const T = Type.Omit(A, Type.KeyOf(B), { additionalProperties: false })
-    ok(T, { z: 0 })
-    fail(T, { x: 0, y: 0, z: 0 })
+    Ok(T, { z: 0 })
+    Fail(T, { x: 0, y: 0, z: 0 })
   })
 })
diff --git a/test/runtime/schema/optional.ts b/test/runtime/schema/optional.ts
index ba95bd7fb..298550f73 100644
--- a/test/runtime/schema/optional.ts
+++ b/test/runtime/schema/optional.ts
@@ -1,6 +1,6 @@
 import { strictEqual } from 'assert'
 import { Type } from '@sinclair/typebox'
-import { ok } from './validate'
+import { Ok } from './validate'
 
 describe('type/schema/Optional', () => {
   it('Should validate object with optional', () => {
@@ -11,8 +11,8 @@ describe('type/schema/Optional', () => {
       },
       { additionalProperties: false },
     )
-    ok(T, { a: 'hello', b: 'world' })
-    ok(T, { b: 'world' })
+    Ok(T, { a: 'hello', b: 'world' })
+    Ok(T, { b: 'world' })
   })
   it('Should remove required value from schema', () => {
     const T = Type.Object(
diff --git a/test/runtime/schema/partial.ts b/test/runtime/schema/partial.ts
index 6fafdd867..9b9490288 100644
--- a/test/runtime/schema/partial.ts
+++ b/test/runtime/schema/partial.ts
@@ -1,5 +1,5 @@
 import { Type, Modifier } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
 describe('type/schema/Partial', () => {
@@ -13,10 +13,10 @@ describe('type/schema/Partial', () => {
       { additionalProperties: false },
     )
     const T = Type.Partial(A)
-    ok(T, { x: 1, y: 1, z: 1 })
-    ok(T, { x: 1, y: 1 })
-    ok(T, { x: 1 })
-    ok(T, {})
+    Ok(T, { x: 1, y: 1, z: 1 })
+    Ok(T, { x: 1, y: 1 })
+    Ok(T, { x: 1 })
+    Ok(T, {})
   })
 
   it('Should update modifier types correctly when converting to partial', () => {
diff --git a/test/runtime/schema/pick.ts b/test/runtime/schema/pick.ts
index f96332bfc..99f49f700 100644
--- a/test/runtime/schema/pick.ts
+++ b/test/runtime/schema/pick.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
 describe('type/schema/Pick', () => {
@@ -13,7 +13,7 @@ describe('type/schema/Pick', () => {
       { additionalProperties: false },
     )
     const T = Type.Pick(Vector3, ['x', 'y'])
-    ok(T, { x: 1, y: 1 })
+    Ok(T, { x: 1, y: 1 })
   })
 
   it('Should remove required properties on the target schema', () => {
@@ -67,7 +67,7 @@ describe('type/schema/Pick', () => {
       y: Type.Number(),
     })
     const T = Type.Pick(A, Type.KeyOf(B), { additionalProperties: false })
-    ok(T, { x: 0, y: 0 })
-    fail(T, { x: 0, y: 0, z: 0 })
+    Ok(T, { x: 0, y: 0 })
+    Fail(T, { x: 0, y: 0, z: 0 })
   })
 })
diff --git a/test/runtime/schema/readonly-optional.ts b/test/runtime/schema/readonly-optional.ts
index 8353010be..59f2f4baf 100644
--- a/test/runtime/schema/readonly-optional.ts
+++ b/test/runtime/schema/readonly-optional.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
 describe('type/schema/ReadonlyOptional', () => {
@@ -11,8 +11,8 @@ describe('type/schema/ReadonlyOptional', () => {
       },
       { additionalProperties: false },
     )
-    ok(T, { a: 'hello', b: 'world' })
-    ok(T, { b: 'world' })
+    Ok(T, { a: 'hello', b: 'world' })
+    Ok(T, { b: 'world' })
   })
   it('Should remove required value from schema', () => {
     const T = Type.Object(
diff --git a/test/runtime/schema/readonly.ts b/test/runtime/schema/readonly.ts
index c0b55dc85..50f75eb99 100644
--- a/test/runtime/schema/readonly.ts
+++ b/test/runtime/schema/readonly.ts
@@ -1,6 +1,6 @@
 import { deepStrictEqual, strictEqual } from 'assert'
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Readonly', () => {
   it('Should validate object with readonly', () => {
@@ -11,7 +11,7 @@ describe('type/schema/Readonly', () => {
       },
       { additionalProperties: false },
     )
-    ok(T, { a: 'hello', b: 'world' })
+    Ok(T, { a: 'hello', b: 'world' })
   })
 
   it('Should retain required array on object', () => {
diff --git a/test/runtime/schema/record.ts b/test/runtime/schema/record.ts
index 4f93b89c6..e9f2de88b 100644
--- a/test/runtime/schema/record.ts
+++ b/test/runtime/schema/record.ts
@@ -1,27 +1,27 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Record', () => {
   it('Should validate when all property values are numbers', () => {
     const T = Type.Record(Type.String(), Type.Number())
-    ok(T, { a: 1, b: 2, c: 3 })
+    Ok(T, { a: 1, b: 2, c: 3 })
   })
 
   it('Should validate when all property keys are strings', () => {
     const T = Type.Record(Type.String(), Type.Number())
-    ok(T, { a: 1, b: 2, c: 3, '0': 4 })
+    Ok(T, { a: 1, b: 2, c: 3, '0': 4 })
   })
 
   it('Should validate when specifying string union literals when additionalProperties is true', () => {
     const K = Type.Union([Type.Literal('a'), Type.Literal('b'), Type.Literal('c')])
     const T = Type.Record(K, Type.Number())
-    ok(T, { a: 1, b: 2, c: 3, d: 'hello' })
+    Ok(T, { a: 1, b: 2, c: 3, d: 'hello' })
   })
 
   it('Should not validate when specifying string union literals when additionalProperties is false', () => {
     const K = Type.Union([Type.Literal('a'), Type.Literal('b'), Type.Literal('c')])
     const T = Type.Record(K, Type.Number(), { additionalProperties: false })
-    fail(T, { a: 1, b: 2, c: 3, d: 'hello' })
+    Fail(T, { a: 1, b: 2, c: 3, d: 'hello' })
   })
 
   it('Should validate for keyof records', () => {
@@ -31,7 +31,7 @@ describe('type/schema/Record', () => {
       c: Type.String(),
     })
     const R = Type.Record(Type.KeyOf(T), Type.Number())
-    ok(R, { a: 1, b: 2, c: 3 })
+    Ok(R, { a: 1, b: 2, c: 3 })
   })
 
   it('Should not validate for unknown key via keyof', () => {
@@ -41,13 +41,13 @@ describe('type/schema/Record', () => {
       c: Type.String(),
     })
     const R = Type.Record(Type.KeyOf(T), Type.Number(), { additionalProperties: false })
-    fail(R, { a: 1, b: 2, c: 3, d: 4 })
+    Fail(R, { a: 1, b: 2, c: 3, d: 4 })
   })
 
   it('Should should validate when specifying regular expressions', () => {
     const K = Type.RegEx(/^op_.*$/)
     const T = Type.Record(K, Type.Number())
-    ok(T, {
+    Ok(T, {
       op_a: 1,
       op_b: 2,
       op_c: 3,
@@ -57,7 +57,7 @@ describe('type/schema/Record', () => {
   it('Should should not validate when specifying regular expressions and passing invalid property', () => {
     const K = Type.RegEx(/^op_.*$/)
     const T = Type.Record(K, Type.Number())
-    fail(T, {
+    Fail(T, {
       op_a: 1,
       op_b: 2,
       aop_c: 3,
@@ -70,17 +70,17 @@ describe('type/schema/Record', () => {
 
   it('Should validate when all property keys are integers', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
-    ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
+    Ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
   })
 
   it('Should validate when all property keys are integers, but one property is a string with varying type', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
-    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
+    Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
 
   it('Should not validate if passing a leading zeros for integers keys', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
-    fail(T, {
+    Fail(T, {
       '00': 1,
       '01': 2,
       '02': 3,
@@ -90,7 +90,7 @@ describe('type/schema/Record', () => {
 
   it('Should not validate if passing a signed integers keys', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
-    fail(T, {
+    Fail(T, {
       '-0': 1,
       '-1': 2,
       '-2': 3,
@@ -104,17 +104,17 @@ describe('type/schema/Record', () => {
 
   it('Should validate when all property keys are numbers', () => {
     const T = Type.Record(Type.Number(), Type.Number())
-    ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
+    Ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
   })
 
   it('Should validate when all property keys are numbers, but one property is a string with varying type', () => {
     const T = Type.Record(Type.Number(), Type.Number())
-    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
+    Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
 
   it('Should not validate if passing a leading zeros for numeric keys', () => {
     const T = Type.Record(Type.Number(), Type.Number())
-    fail(T, {
+    Fail(T, {
       '00': 1,
       '01': 2,
       '02': 3,
@@ -124,7 +124,7 @@ describe('type/schema/Record', () => {
 
   it('Should not validate if passing a signed numeric keys', () => {
     const T = Type.Record(Type.Number(), Type.Number())
-    fail(T, {
+    Fail(T, {
       '-0': 1,
       '-1': 2,
       '-2': 3,
@@ -134,6 +134,6 @@ describe('type/schema/Record', () => {
 
   it('Should not validate when all property keys are numbers, but one property is a string with varying type', () => {
     const T = Type.Record(Type.Number(), Type.Number())
-    fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
+    Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
 })
diff --git a/test/runtime/schema/recursive.ts b/test/runtime/schema/recursive.ts
index a0b132232..f5e9a352f 100644
--- a/test/runtime/schema/recursive.ts
+++ b/test/runtime/schema/recursive.ts
@@ -1,6 +1,6 @@
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Recursive', () => {
   it('Should generate default ordinal $id if not specified', () => {
@@ -32,7 +32,7 @@ describe('type/schema/Recursive', () => {
         nodes: Type.Array(Self),
       }),
     )
-    ok(Node, {
+    Ok(Node, {
       id: 'A',
       nodes: [
         { id: 'B', nodes: [] },
@@ -50,7 +50,7 @@ describe('type/schema/Recursive', () => {
         }),
       ),
     ])
-    ok(Node, [
+    Ok(Node, [
       {
         id: 'A',
         nodes: [
@@ -70,7 +70,7 @@ describe('type/schema/Recursive', () => {
         }),
       ),
     ])
-    fail(Node, [
+    Fail(Node, [
       {
         id: 'A',
         nodes: [
diff --git a/test/runtime/schema/ref.ts b/test/runtime/schema/ref.ts
index ade5e054a..cfab94010 100644
--- a/test/runtime/schema/ref.ts
+++ b/test/runtime/schema/ref.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 import { Assert } from '../assert/index'
 
 describe('type/schema/Ref', () => {
@@ -13,7 +13,7 @@ describe('type/schema/Ref', () => {
       { $id: 'T' },
     )
     const R = Type.Ref(T)
-    ok(
+    Ok(
       R,
       {
         x: 1,
@@ -34,7 +34,7 @@ describe('type/schema/Ref', () => {
       { $id: 'T' },
     )
     const R = Type.Ref(T)
-    fail(
+    Fail(
       R,
       {
         x: 1,
@@ -61,9 +61,9 @@ describe('type/schema/Ref', () => {
       { $id: 'T' },
     )
 
-    ok(T, { x: 1, y: 2, z: 3 }, [R])
-    ok(T, { x: 1, y: 2, z: 3, r: { name: 'hello' } }, [R])
-    fail(T, { x: 1, y: 2, z: 3, r: { name: 1 } }, [R])
-    fail(T, { x: 1, y: 2, z: 3, r: {} }, [R])
+    Ok(T, { x: 1, y: 2, z: 3 }, [R])
+    Ok(T, { x: 1, y: 2, z: 3, r: { name: 'hello' } }, [R])
+    Fail(T, { x: 1, y: 2, z: 3, r: { name: 1 } }, [R])
+    Fail(T, { x: 1, y: 2, z: 3, r: {} }, [R])
   })
 })
diff --git a/test/runtime/schema/regex.ts b/test/runtime/schema/regex.ts
index 0c5c56faa..3c3b49a39 100644
--- a/test/runtime/schema/regex.ts
+++ b/test/runtime/schema/regex.ts
@@ -1,35 +1,35 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/RegEx', () => {
   it('Should validate numeric value', () => {
     const T = Type.RegEx(/[012345]/)
-    ok(T, '0')
-    ok(T, '1')
-    ok(T, '2')
-    ok(T, '3')
-    ok(T, '4')
-    ok(T, '5')
+    Ok(T, '0')
+    Ok(T, '1')
+    Ok(T, '2')
+    Ok(T, '3')
+    Ok(T, '4')
+    Ok(T, '5')
   })
 
   it('Should validate true or false string value', () => {
     const T = Type.RegEx(/true|false/)
-    ok(T, 'true')
-    ok(T, 'true')
-    ok(T, 'true')
-    ok(T, 'false')
-    ok(T, 'false')
-    ok(T, 'false')
-    fail(T, '6')
+    Ok(T, 'true')
+    Ok(T, 'true')
+    Ok(T, 'true')
+    Ok(T, 'false')
+    Ok(T, 'false')
+    Ok(T, 'false')
+    Fail(T, '6')
   })
 
   it('Should not validate failed regex test', () => {
     const T = Type.RegEx(/true|false/)
-    fail(T, 'unknown')
+    Fail(T, 'unknown')
   })
 
   it('Should pass numeric 5 digit test', () => {
     const T = Type.RegEx(/[\d]{5}/)
-    ok(T, '12345')
+    Ok(T, '12345')
   })
 })
diff --git a/test/runtime/schema/required.ts b/test/runtime/schema/required.ts
index f3090fcdd..fc8b6149e 100644
--- a/test/runtime/schema/required.ts
+++ b/test/runtime/schema/required.ts
@@ -1,5 +1,5 @@
 import { Type, Modifier } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
 describe('type/schema/Required', () => {
@@ -13,10 +13,10 @@ describe('type/schema/Required', () => {
       { additionalProperties: false },
     )
     const T = Type.Required(A)
-    ok(T, { x: 1, y: 1, z: 1 })
-    fail(T, { x: 1, y: 1 })
-    fail(T, { x: 1 })
-    fail(T, {})
+    Ok(T, { x: 1, y: 1, z: 1 })
+    Fail(T, { x: 1, y: 1 })
+    Fail(T, { x: 1 })
+    Fail(T, {})
   })
 
   it('Should update modifier types correctly when converting to required', () => {
diff --git a/test/runtime/schema/string.ts b/test/runtime/schema/string.ts
index 9061de762..3a536bddd 100644
--- a/test/runtime/schema/string.ts
+++ b/test/runtime/schema/string.ts
@@ -1,65 +1,65 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/String', () => {
   it('Should not validate number', () => {
     const T = Type.String()
-    fail(T, 1)
+    Fail(T, 1)
   })
   it('Should validate string', () => {
     const T = Type.String()
-    ok(T, 'hello')
+    Ok(T, 'hello')
   })
   it('Should not validate boolean', () => {
     const T = Type.String()
-    fail(T, true)
+    Fail(T, true)
   })
   it('Should not validate array', () => {
     const T = Type.String()
-    fail(T, [1, 2, 3])
+    Fail(T, [1, 2, 3])
   })
   it('Should not validate object', () => {
     const T = Type.String()
-    fail(T, { a: 1, b: 2 })
+    Fail(T, { a: 1, b: 2 })
   })
   it('Should not validate null', () => {
     const T = Type.String()
-    fail(T, null)
+    Fail(T, null)
   })
   it('Should not validate undefined', () => {
     const T = Type.String()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
 
   it('Should validate string format as email', () => {
     const T = Type.String({ format: 'email' })
-    ok(T, 'name@domain.com')
+    Ok(T, 'name@domain.com')
   })
 
   it('Should validate string format as uuid', () => {
     const T = Type.String({ format: 'uuid' })
-    ok(T, '4a7a17c9-2492-4a53-8e13-06ea2d3f3bbf')
+    Ok(T, '4a7a17c9-2492-4a53-8e13-06ea2d3f3bbf')
   })
 
   it('Should validate string format as iso8601 date', () => {
     const T = Type.String({ format: 'date-time' })
-    ok(T, '2021-06-11T20:30:00-04:00')
+    Ok(T, '2021-06-11T20:30:00-04:00')
   })
 
   it('Should validate minLength', () => {
     const T = Type.String({ minLength: 4 })
-    ok(T, '....')
-    fail(T, '...')
+    Ok(T, '....')
+    Fail(T, '...')
   })
 
   it('Should validate maxLength', () => {
     const T = Type.String({ maxLength: 4 })
-    ok(T, '....')
-    fail(T, '.....')
+    Ok(T, '....')
+    Fail(T, '.....')
   })
 
   it('Should pass numeric 5 digit test', () => {
     const T = Type.String({ pattern: '[\\d]{5}' })
-    ok(T, '12345')
+    Ok(T, '12345')
   })
 })
diff --git a/test/runtime/schema/tuple.ts b/test/runtime/schema/tuple.ts
index 60ba0be00..773586e04 100644
--- a/test/runtime/schema/tuple.ts
+++ b/test/runtime/schema/tuple.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 import { Assert } from '../assert'
 
 describe('type/schema/Tuple', () => {
@@ -7,56 +7,56 @@ describe('type/schema/Tuple', () => {
     const A = Type.String()
     const B = Type.Number()
     const T = Type.Tuple([A, B])
-    ok(T, ['hello', 42])
+    Ok(T, ['hello', 42])
   })
 
   it('Should not validate tuple of [string, number] when reversed', () => {
     const A = Type.String()
     const B = Type.Number()
     const T = Type.Tuple([A, B])
-    fail(T, [42, 'hello'])
+    Fail(T, [42, 'hello'])
   })
 
   it('Should validate with empty tuple', () => {
     const T = Type.Tuple([])
-    ok(T, [])
+    Ok(T, [])
   })
 
   it('Should not validate with empty tuple with more items', () => {
     const T = Type.Tuple([])
-    fail(T, [1])
+    Fail(T, [1])
   })
 
   it('Should not validate with empty tuple with less items', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
-    fail(T, [1])
+    Fail(T, [1])
   })
 
   it('Should validate tuple of objects', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
     const T = Type.Tuple([A, B])
-    ok(T, [{ a: 'hello' }, { b: 42 }])
+    Ok(T, [{ a: 'hello' }, { b: 42 }])
   })
 
   it('Should not validate tuple of objects when reversed', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
     const T = Type.Tuple([A, B])
-    fail(T, [{ b: 42 }, { a: 'hello' }])
+    Fail(T, [{ b: 42 }, { a: 'hello' }])
   })
 
   it('Should not validate tuple when array is less than tuple length', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
     const T = Type.Tuple([A, B])
-    fail(T, [{ a: 'hello' }])
+    Fail(T, [{ a: 'hello' }])
   })
 
   it('Should not validate tuple when array is greater than tuple length', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
     const T = Type.Tuple([A, B])
-    fail(T, [{ a: 'hello' }, { b: 42 }, { b: 42 }])
+    Fail(T, [{ a: 'hello' }, { b: 42 }, { b: 42 }])
   })
 })
diff --git a/test/runtime/schema/uint8array.ts b/test/runtime/schema/uint8array.ts
index e1f7e0f68..04cb8f732 100644
--- a/test/runtime/schema/uint8array.ts
+++ b/test/runtime/schema/uint8array.ts
@@ -1,56 +1,56 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Uint8Array', () => {
   it('Should not validate number', () => {
     const T = Type.Uint8Array()
-    fail(T, 1)
+    Fail(T, 1)
   })
 
   it('Should not validate string', () => {
     const T = Type.Uint8Array()
-    fail(T, 'hello')
+    Fail(T, 'hello')
   })
 
   it('Should not validate boolean', () => {
     const T = Type.Uint8Array()
-    fail(T, true)
+    Fail(T, true)
   })
 
   it('Should not validate array', () => {
     const T = Type.Uint8Array()
-    fail(T, [1, 2, 3])
+    Fail(T, [1, 2, 3])
   })
 
   it('Should not validate object', () => {
     const T = Type.Uint8Array()
-    fail(T, { a: 1, b: 2 })
+    Fail(T, { a: 1, b: 2 })
   })
 
   it('Should not validate null', () => {
     const T = Type.Uint8Array()
-    fail(T, null)
+    Fail(T, null)
   })
 
   it('Should not validate undefined', () => {
     const T = Type.Uint8Array()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
 
   it('Should validate Uint8Array', () => {
     const T = Type.Uint8Array()
-    ok(T, new Uint8Array(100))
+    Ok(T, new Uint8Array(100))
   })
 
   it('Should validate minByteLength', () => {
     const T = Type.Uint8Array({ minByteLength: 4 })
-    ok(T, new Uint8Array(4))
-    fail(T, new Uint8Array(3))
+    Ok(T, new Uint8Array(4))
+    Fail(T, new Uint8Array(3))
   })
 
   it('Should validate maxByteLength', () => {
     const T = Type.Uint8Array({ maxByteLength: 4 })
-    ok(T, new Uint8Array(4))
-    fail(T, new Uint8Array(5))
+    Ok(T, new Uint8Array(4))
+    Fail(T, new Uint8Array(5))
   })
 })
diff --git a/test/runtime/schema/union.ts b/test/runtime/schema/union.ts
index 45d371abe..10d3e5081 100644
--- a/test/runtime/schema/union.ts
+++ b/test/runtime/schema/union.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Union', () => {
   it('Should validate union of string, number and boolean', () => {
@@ -7,56 +7,56 @@ describe('type/schema/Union', () => {
     const B = Type.Number()
     const C = Type.Boolean()
     const T = Type.Union([A, B, C])
-    ok(T, 'hello')
-    ok(T, true)
-    ok(T, 42)
+    Ok(T, 'hello')
+    Ok(T, true)
+    Ok(T, 42)
   })
 
   it('Should validate union of objects', () => {
     const A = Type.Object({ a: Type.String() }, { additionalProperties: false })
     const B = Type.Object({ b: Type.String() }, { additionalProperties: false })
     const T = Type.Union([A, B])
-    ok(T, { a: 'hello' })
-    ok(T, { b: 'world' })
+    Ok(T, { a: 'hello' })
+    Ok(T, { b: 'world' })
   })
 
   it('Should fail to validate for descriminated union types', () => {
     const A = Type.Object({ kind: Type.Literal('A'), value: Type.String() })
     const B = Type.Object({ kind: Type.Literal('B'), value: Type.Number() })
     const T = Type.Union([A, B])
-    fail(T, { kind: 'A', value: 42 }) // expect { kind: 'A', value: string }
-    fail(T, { kind: 'B', value: 'hello' }) // expect { kind: 'B', value: number }
+    Fail(T, { kind: 'A', value: 42 }) // expect { kind: 'A', value: string }
+    Fail(T, { kind: 'B', value: 'hello' }) // expect { kind: 'B', value: number }
   })
 
   it('Should validate union of objects where properties overlap', () => {
     const A = Type.Object({ a: Type.String() }, { additionalProperties: false })
     const B = Type.Object({ a: Type.String(), b: Type.String() }, { additionalProperties: false })
     const T = Type.Union([A, B])
-    ok(T, { a: 'hello' }) // A
-    ok(T, { a: 'hello', b: 'world' }) // B
+    Ok(T, { a: 'hello' }) // A
+    Ok(T, { a: 'hello', b: 'world' }) // B
   })
 
   it('Should validate union of overlapping property of varying type', () => {
     const A = Type.Object({ a: Type.String(), b: Type.Number() }, { additionalProperties: false })
     const B = Type.Object({ a: Type.String(), b: Type.String() }, { additionalProperties: false })
     const T = Type.Union([A, B])
-    ok(T, { a: 'hello', b: 42 }) // A
-    ok(T, { a: 'hello', b: 'world' }) // B
+    Ok(T, { a: 'hello', b: 42 }) // A
+    Ok(T, { a: 'hello', b: 'world' }) // B
   })
 
   it('Should validate union of literal strings', () => {
     const A = Type.Literal('hello')
     const B = Type.Literal('world')
     const T = Type.Union([A, B])
-    ok(T, 'hello') // A
-    ok(T, 'world') // B
+    Ok(T, 'hello') // A
+    Ok(T, 'world') // B
   })
 
   it('Should not validate union of literal strings for unknown string', () => {
     const A = Type.Literal('hello')
     const B = Type.Literal('world')
     const T = Type.Union([A, B])
-    fail(T, 'foo') // A
-    fail(T, 'bar') // B
+    Fail(T, 'foo') // A
+    Fail(T, 'bar') // B
   })
 })
diff --git a/test/runtime/schema/unknown.ts b/test/runtime/schema/unknown.ts
index c9b94f339..2bc681767 100644
--- a/test/runtime/schema/unknown.ts
+++ b/test/runtime/schema/unknown.ts
@@ -1,33 +1,33 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Unknown', () => {
   it('Should validate number', () => {
     const T = Type.Any()
-    ok(T, 1)
+    Ok(T, 1)
   })
   it('Should validate string', () => {
     const T = Type.Any()
-    ok(T, 'hello')
+    Ok(T, 'hello')
   })
   it('Should validate boolean', () => {
     const T = Type.Any()
-    ok(T, true)
+    Ok(T, true)
   })
   it('Should validate array', () => {
     const T = Type.Any()
-    ok(T, [1, 2, 3])
+    Ok(T, [1, 2, 3])
   })
   it('Should validate object', () => {
     const T = Type.Any()
-    ok(T, { a: 1, b: 2 })
+    Ok(T, { a: 1, b: 2 })
   })
   it('Should validate null', () => {
     const T = Type.Any()
-    ok(T, null)
+    Ok(T, null)
   })
   it('Should validate undefined', () => {
     const T = Type.Any()
-    ok(T, undefined)
+    Ok(T, undefined)
   })
 })
diff --git a/test/runtime/schema/unsafe.ts b/test/runtime/schema/unsafe.ts
index d21fe3411..509d2d4fb 100644
--- a/test/runtime/schema/unsafe.ts
+++ b/test/runtime/schema/unsafe.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Unsafe', () => {
   it('Should validate an unsafe type', () => {
@@ -12,7 +12,7 @@ describe('type/schema/Unsafe', () => {
       },
       additionalProperties: false,
     })
-    ok(T, { x: 1, y: 2, z: 3 })
-    fail(T, { x: 1, y: 2, z: 3, w: 4 })
+    Ok(T, { x: 1, y: 2, z: 3 })
+    Fail(T, { x: 1, y: 2, z: 3, w: 4 })
   })
 })
diff --git a/test/runtime/schema/validate.ts b/test/runtime/schema/validate.ts
index bd1f822f7..7390db7bb 100644
--- a/test/runtime/schema/validate.ts
+++ b/test/runtime/schema/validate.ts
@@ -39,7 +39,7 @@ export function createAjv(references: AnySchema[]) {
     .addSchema(references)
 }
 
-export function ok<T extends TSchema>(type: T, data: unknown, additional: AnySchema[] = []) {
+export function Ok<T extends TSchema>(type: T, data: unknown, additional: AnySchema[] = []) {
   const ajv = createAjv(additional)
   function execute() {
     // required as ajv will throw if referenced schema is not found
@@ -66,7 +66,7 @@ export function ok<T extends TSchema>(type: T, data: unknown, additional: AnySch
   }
 }
 
-export function fail<T extends TSchema>(type: T, data: unknown, additional: AnySchema[] = []) {
+export function Fail<T extends TSchema>(type: T, data: unknown, additional: AnySchema[] = []) {
   const ajv = createAjv(additional)
   function execute() {
     // required as ajv will throw if referenced schema is not found
diff --git a/test/runtime/schema/void.ts b/test/runtime/schema/void.ts
index 8d5c13e21..99d984c3e 100644
--- a/test/runtime/schema/void.ts
+++ b/test/runtime/schema/void.ts
@@ -1,39 +1,39 @@
 import { Type } from '@sinclair/typebox'
-import { ok, fail } from './validate'
+import { Ok, Fail } from './validate'
 
 describe('type/schema/Void', () => {
   it('Should not validate number', () => {
     const T = Type.Void()
-    fail(T, 1)
+    Fail(T, 1)
   })
 
   it('Should not validate string', () => {
     const T = Type.Void()
-    fail(T, 'hello')
+    Fail(T, 'hello')
   })
 
   it('Should not validate boolean', () => {
     const T = Type.Void()
-    fail(T, true)
+    Fail(T, true)
   })
 
   it('Should not validate array', () => {
     const T = Type.Void()
-    fail(T, [1, 2, 3])
+    Fail(T, [1, 2, 3])
   })
 
   it('Should not validate object', () => {
     const T = Type.Void()
-    fail(T, { a: 1, b: 2 })
+    Fail(T, { a: 1, b: 2 })
   })
 
   it('Should validate null', () => {
     const T = Type.Null()
-    ok(T, null)
+    Ok(T, null)
   })
 
   it('Should not validate undefined', () => {
     const T = Type.Void()
-    fail(T, undefined)
+    Fail(T, undefined)
   })
 })
diff --git a/test/runtime/settings/index.ts b/test/runtime/settings/index.ts
new file mode 100644
index 000000000..e63c403f9
--- /dev/null
+++ b/test/runtime/settings/index.ts
@@ -0,0 +1 @@
+import './structural'
diff --git a/test/runtime/settings/structural.ts b/test/runtime/settings/structural.ts
new file mode 100644
index 000000000..e857ff265
--- /dev/null
+++ b/test/runtime/settings/structural.ts
@@ -0,0 +1,62 @@
+import { Ok, Fail } from '../compiler/validate'
+import { TypeSystem } from '@sinclair/typebox/system'
+import { Type } from '@sinclair/typebox'
+
+describe('Settings/Structural', () => {
+  before(() => {
+    TypeSystem.Kind = 'structural'
+  })
+  after(() => {
+    TypeSystem.Kind = 'json-schema'
+  })
+
+  // ---------------------------------------------------------------
+  // Object
+  // ---------------------------------------------------------------
+  it('Should validate arrays with empty objects', () => {
+    const T = Type.Object({})
+    Ok(T, [0, 1, 2])
+  })
+  it('Should validate arrays with objects with length property', () => {
+    const T = Type.Object({ length: Type.Number() })
+    Ok(T, [0, 1, 2])
+  })
+  it('Should validate arrays with objects with additionalProperties false when array has no elements', () => {
+    const T = Type.Object({ length: Type.Number() }, { additionalProperties: false })
+    Ok(T, [])
+  })
+  it('Should not validate arrays with objects with additionalProperties false when array has elements', () => {
+    const T = Type.Object({ length: Type.Number() }, { additionalProperties: false })
+    Fail(T, [0, 1, 2])
+  })
+  it('Should not validate arrays with objects when length property is string', () => {
+    const T = Type.Object({ length: Type.String() })
+    Fail(T, [0, 1, 2])
+  })
+  // ---------------------------------------------------------------
+  // Record
+  // ---------------------------------------------------------------
+  it('Should validate arrays as Records with String Keys', () => {
+    const T = Type.Record(Type.String(), Type.Number())
+    Ok(T, [0, 1, 2])
+  })
+  it('Should not validate arrays as Records with Number Keys', () => {
+    const T = Type.Record(Type.Integer(), Type.Number())
+    Fail(T, [0, 1, 2])
+  })
+  it('Should not validate arrays as Records with Object Values', () => {
+    const T = Type.Record(
+      Type.String(),
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+    )
+    Ok(T, [
+      { x: 1, y: 1, z: 1 },
+      { x: 1, y: 1, z: 1 },
+      { x: 1, y: 1, z: 1 },
+    ])
+  })
+})
diff --git a/tsconfig.json b/tsconfig.json
index c1619dc92..d660b0d6d 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -28,6 +28,9 @@
       "@sinclair/typebox/hash": [
         "src/hash/index.ts"
       ],
+      "@sinclair/typebox/system": [
+        "src/system/index.ts"
+      ],
       "@sinclair/typebox/value": [
         "src/value/index.ts"
       ],

From 999d5bc35bbf50bac64a6f953d4fb3e59975005d Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 20 Dec 2022 11:46:05 +0900
Subject: [PATCH 053/369] Format

---
 example/index.ts | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/example/index.ts b/example/index.ts
index c367f5f78..6307054b6 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -9,11 +9,11 @@ import { Value, ValuePointer } from '@sinclair/typebox/value'
 import { Type, Kind, Static, TSchema } from '@sinclair/typebox'
 
 const T = Type.Object({
-    x: Type.Number(),
-    y: Type.Number(),
-    z: Type.Number(),
-  })
-  
-  type T = Static<typeof T>
-  
-  console.log(T)
\ No newline at end of file
+  x: Type.Number(),
+  y: Type.Number(),
+  z: Type.Number(),
+})
+
+type T = Static<typeof T>
+
+console.log(T)

From ce18d623165bf608e50a5cbd72bdb01fbfa8dcf3 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 22 Dec 2022 03:33:31 +0900
Subject: [PATCH 054/369] Structural Configuration (#297)

---
 package.json                                  |  2 +-
 src/compiler/compiler.ts                      | 18 ++++++----
 src/errors/errors.ts                          | 31 ++++++++--------
 src/system/system.ts                          | 35 ++++---------------
 src/value/check.ts                            | 29 ++++++++-------
 test/runtime/index.ts                         |  2 +-
 test/runtime/settings/index.ts                |  1 -
 .../AllowArrayObjects.ts}                     |  7 ++--
 test/runtime/system/AllowNaN.ts               | 30 ++++++++++++++++
 test/runtime/system/index.ts                  |  2 ++
 10 files changed, 88 insertions(+), 69 deletions(-)
 delete mode 100644 test/runtime/settings/index.ts
 rename test/runtime/{settings/structural.ts => system/AllowArrayObjects.ts} (93%)
 create mode 100644 test/runtime/system/AllowNaN.ts
 create mode 100644 test/runtime/system/index.ts

diff --git a/package.json b/package.json
index 0b6dce662..b94472262 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.15",
+  "version": "0.25.16",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 73c4814ca..1e7e964bc 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -177,7 +177,11 @@ export namespace TypeCompiler {
   }
 
   function* Number(schema: Types.TNumber, value: string): IterableIterator<string> {
-    yield `(typeof ${value} === 'number' && !isNaN(${value}))`
+    if (TypeSystem.AllowNaN) {
+      yield `(typeof ${value} === 'number')`
+    } else {
+      yield `(typeof ${value} === 'number' && !isNaN(${value}))`
+    }
     if (IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf} === 0)`
     if (IsNumber(schema.exclusiveMinimum)) yield `(${value} > ${schema.exclusiveMinimum})`
     if (IsNumber(schema.exclusiveMaximum)) yield `(${value} < ${schema.exclusiveMaximum})`
@@ -186,10 +190,10 @@ export namespace TypeCompiler {
   }
 
   function* Object(schema: Types.TObject, value: string): IterableIterator<string> {
-    if (TypeSystem.Kind === 'json-schema') {
-      yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`
-    } else if (TypeSystem.Kind === 'structural') {
+    if (TypeSystem.AllowArrayObjects) {
       yield `(typeof ${value} === 'object' && ${value} !== null)`
+    } else {
+      yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`
     }
     if (IsNumber(schema.minProperties)) yield `(Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties})`
     if (IsNumber(schema.maxProperties)) yield `(Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties})`
@@ -228,10 +232,10 @@ export namespace TypeCompiler {
   }
 
   function* Record(schema: Types.TRecord<any, any>, value: string): IterableIterator<string> {
-    if (TypeSystem.Kind === 'json-schema') {
-      yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date))`
-    } else if (TypeSystem.Kind === 'structural') {
+    if (TypeSystem.AllowArrayObjects) {
       yield `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date))`
+    } else {
+      yield `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !Array.isArray(${value}))`
     }
     const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
     const local = PushLocal(`new RegExp(/${keyPattern}/)`)
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 36f774ab2..ad346e3a5 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -173,10 +173,7 @@ export namespace ValueErrors {
 
   function* Integer(schema: Types.TNumeric, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!(typeof value === 'number' && globalThis.Number.isInteger(value))) {
-      return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` }
-    }
-    if (!globalThis.Number.isInteger(value)) {
-      yield { type: ValueErrorType.Integer, schema, path, value, message: `Expected integer` }
+      return yield { type: ValueErrorType.Integer, schema, path, value, message: `Expected integer` }
     }
     if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
       yield { type: ValueErrorType.IntegerMultipleOf, schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` }
@@ -213,8 +210,14 @@ export namespace ValueErrors {
   }
 
   function* Number(schema: Types.TNumeric, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(typeof value === 'number' && !isNaN(value))) {
-      return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` }
+    if (TypeSystem.AllowNaN) {
+      if (!(typeof value === 'number')) {
+        return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` }
+      }
+    } else {
+      if (!(typeof value === 'number' && !isNaN(value))) {
+        return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` }
+      }
     }
     if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
       yield { type: ValueErrorType.NumberMultipleOf, schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` }
@@ -234,12 +237,12 @@ export namespace ValueErrors {
   }
 
   function* Object(schema: Types.TObject, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (TypeSystem.Kind === 'json-schema') {
-      if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+    if (TypeSystem.AllowArrayObjects) {
+      if (!(typeof value === 'object' && value !== null)) {
         return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
       }
-    } else if (TypeSystem.Kind === 'structural') {
-      if (!(typeof value === 'object' && value !== null)) {
+    } else {
+      if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
         return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
       }
     }
@@ -289,12 +292,12 @@ export namespace ValueErrors {
   }
 
   function* Record(schema: Types.TRecord, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (TypeSystem.Kind === 'json-schema') {
-      if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value) && !(value instanceof globalThis.Date))) {
+    if (TypeSystem.AllowArrayObjects) {
+      if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date))) {
         return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
       }
-    } else if (TypeSystem.Kind === 'structural') {
-      if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date))) {
+    } else {
+      if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date) && !globalThis.Array.isArray(value))) {
         return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
       }
     }
diff --git a/src/system/system.ts b/src/system/system.ts
index b2985a72b..0ddd2a1f0 100644
--- a/src/system/system.ts
+++ b/src/system/system.ts
@@ -26,34 +26,13 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export class InvalidTypeSystemError extends Error {
-  constructor(typeSystem: string) {
-    super(`TypeSystemSettings: Unknown TypeSystem '${typeSystem}'`)
-  }
-}
-
-export type TypeSystemKind = 'json-schema' | 'structural'
-
-class TypeSystemSettings {
-  private kind: TypeSystemKind
-  constructor() {
-    this.kind = 'json-schema'
-  }
+export namespace TypeSystem {
   /**
-   * `Experimental` Sets the type system kind used by TypeBox. By default TypeBox uses `json-schema` assertion
-   * rules to verify JavaScript values. If setting the type system to `structural`, TypeBox will use TypeScript
-   * structural checking rules enabling Arrays to be validated as Objects.
+   * Sets whether arrays should be treated as kinds of objects. The default is `false`
    */
-  public get Kind(): TypeSystemKind {
-    return this.kind
-  }
-  public set Kind(value: TypeSystemKind) {
-    if (!(value === 'json-schema' || value === 'structural')) {
-      throw new InvalidTypeSystemError(value)
-    }
-    this.kind = value
-  }
+  export let AllowArrayObjects: boolean = false
+  /**
+   * Sets whether numeric checks should consider NaN a valid number type. The default is `false`
+   */
+  export let AllowNaN: boolean = false
 }
-
-/** TypeBox TypeSystem Settings */
-export const TypeSystem = new TypeSystemSettings()
diff --git a/src/value/check.ts b/src/value/check.ts
index e1415462d..4bd8389ce 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -99,9 +99,6 @@ export namespace ValueCheck {
     if (!(typeof value === 'number' && globalThis.Number.isInteger(value))) {
       return false
     }
-    if (!globalThis.Number.isInteger(value)) {
-      return false
-    }
     if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
       return false
     }
@@ -133,8 +130,14 @@ export namespace ValueCheck {
   }
 
   function Number(schema: Types.TNumber, references: Types.TSchema[], value: any): boolean {
-    if (!(typeof value === 'number' && !isNaN(value))) {
-      return false
+    if (TypeSystem.AllowNaN) {
+      if (!(typeof value === 'number')) {
+        return false
+      }
+    } else {
+      if (!(typeof value === 'number' && !isNaN(value))) {
+        return false
+      }
     }
     if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
       return false
@@ -155,12 +158,12 @@ export namespace ValueCheck {
   }
 
   function Object(schema: Types.TObject, references: Types.TSchema[], value: any): boolean {
-    if (TypeSystem.Kind === 'json-schema') {
-      if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+    if (TypeSystem.AllowArrayObjects) {
+      if (!(typeof value === 'object' && value !== null)) {
         return false
       }
-    } else if (TypeSystem.Kind === 'structural') {
-      if (!(typeof value === 'object' && value !== null)) {
+    } else {
+      if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
         return false
       }
     }
@@ -214,12 +217,12 @@ export namespace ValueCheck {
   }
 
   function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): boolean {
-    if (TypeSystem.Kind === 'json-schema') {
-      if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value) && !(value instanceof globalThis.Date))) {
+    if (TypeSystem.AllowArrayObjects) {
+      if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date))) {
         return false
       }
-    } else if (TypeSystem.Kind === 'structural') {
-      if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date))) {
+    } else {
+      if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date) && !globalThis.Array.isArray(value))) {
         return false
       }
     }
diff --git a/test/runtime/index.ts b/test/runtime/index.ts
index 095140dab..6bd775e76 100644
--- a/test/runtime/index.ts
+++ b/test/runtime/index.ts
@@ -5,5 +5,5 @@ import './format/index'
 import './guard/index'
 import './hash/index'
 import './schema/index'
-import './settings/index'
+import './system/index'
 import './value/index'
diff --git a/test/runtime/settings/index.ts b/test/runtime/settings/index.ts
deleted file mode 100644
index e63c403f9..000000000
--- a/test/runtime/settings/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-import './structural'
diff --git a/test/runtime/settings/structural.ts b/test/runtime/system/AllowArrayObjects.ts
similarity index 93%
rename from test/runtime/settings/structural.ts
rename to test/runtime/system/AllowArrayObjects.ts
index e857ff265..9ee0c46e3 100644
--- a/test/runtime/settings/structural.ts
+++ b/test/runtime/system/AllowArrayObjects.ts
@@ -2,14 +2,13 @@ import { Ok, Fail } from '../compiler/validate'
 import { TypeSystem } from '@sinclair/typebox/system'
 import { Type } from '@sinclair/typebox'
 
-describe('Settings/Structural', () => {
+describe('TypeSystem/AllowArrayObjects', () => {
   before(() => {
-    TypeSystem.Kind = 'structural'
+    TypeSystem.AllowArrayObjects = true
   })
   after(() => {
-    TypeSystem.Kind = 'json-schema'
+    TypeSystem.AllowArrayObjects = false
   })
-
   // ---------------------------------------------------------------
   // Object
   // ---------------------------------------------------------------
diff --git a/test/runtime/system/AllowNaN.ts b/test/runtime/system/AllowNaN.ts
new file mode 100644
index 000000000..bcf0d9ee5
--- /dev/null
+++ b/test/runtime/system/AllowNaN.ts
@@ -0,0 +1,30 @@
+import { Ok, Fail } from '../compiler/validate'
+import { TypeSystem } from '@sinclair/typebox/system'
+import { Type } from '@sinclair/typebox'
+
+describe('TypeSystem/AllowNaN', () => {
+  before(() => {
+    TypeSystem.AllowNaN = true
+  })
+  after(() => {
+    TypeSystem.AllowNaN = false
+  })
+  // ---------------------------------------------------------------
+  // Number
+  // ---------------------------------------------------------------
+  it('Should validate number with NaN', () => {
+    const T = Type.Number()
+    Ok(T, NaN)
+  })
+
+  // ---------------------------------------------------------------
+  // Integer
+  //
+  // Note: The Number.isInteger() test will fail for NaN. Because
+  // of this we cannot reasonably override NaN handling for integers.
+  // ---------------------------------------------------------------
+  it('Should not validate integer with NaN', () => {
+    const T = Type.Integer()
+    Fail(T, NaN)
+  })
+})
diff --git a/test/runtime/system/index.ts b/test/runtime/system/index.ts
new file mode 100644
index 000000000..fde988aa0
--- /dev/null
+++ b/test/runtime/system/index.ts
@@ -0,0 +1,2 @@
+import './AllowArrayObjects'
+import './AllowNaN'

From eed7cab39447ad5752aeecc03944db35511ab34f Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Fri, 23 Dec 2022 05:41:41 +0900
Subject: [PATCH 055/369] Additional Codegen

---
 codegen/codegen.ts    |  16 ++-
 codegen/formatter.ts  |  46 ++++++++
 codegen/jsonschema.ts |  25 +---
 codegen/typebox.ts    |  23 +---
 codegen/typescript.ts |  29 +----
 codegen/zod.ts        | 257 ++++++++++++++++++++++++++++++++++++++++++
 6 files changed, 323 insertions(+), 73 deletions(-)
 create mode 100644 codegen/formatter.ts
 create mode 100644 codegen/zod.ts

diff --git a/codegen/codegen.ts b/codegen/codegen.ts
index 63728ce18..8e0237439 100644
--- a/codegen/codegen.ts
+++ b/codegen/codegen.ts
@@ -28,15 +28,19 @@ THE SOFTWARE.
 
 import { TSchema } from '@sinclair/typebox'
 import { TypeBoxCodegen } from './typebox'
-import { TypeScriptCodeGen } from './typescript'
-import { JsonSchemaCodeGen } from './jsonschema'
+import { TypeScriptCodegen } from './typescript'
+import { JsonSchemaCodegen } from './jsonschema'
+import { ZodCodegen, ZodCodegenOptions } from './zod'
 
-export namespace CodeGen {
+export namespace Codegen {
   /** Generates TypeScript type definitions from TypeBox types */
   export function TypeScript(schema: TSchema, references: TSchema[] = []): string {
-    return TypeScriptCodeGen.Generate(schema, references)
+    return TypeScriptCodegen.Generate(schema, references)
+  }
+  /** Generates Zod type definitions from TypeBox types */
+  export function Zod(schema: TSchema, references: TSchema[] = [], options: ZodCodegenOptions = { imports: true, exports: false }): string {
+    return ZodCodegen.Generate(schema, references, options)
   }
-
   /** Generates TypeBox type definitions from TypeScript code */
   export function TypeBox(code: string): string {
     return TypeBoxCodegen.Generate(code)
@@ -44,6 +48,6 @@ export namespace CodeGen {
 
   /** Generates JsonSchema definitions from TypeScript code */
   export function JsonSchema(code: string): string {
-    return JsonSchemaCodeGen.Generate(code)
+    return JsonSchemaCodegen.Generate(code)
   }
 }
diff --git a/codegen/formatter.ts b/codegen/formatter.ts
new file mode 100644
index 000000000..6e3b4a7b8
--- /dev/null
+++ b/codegen/formatter.ts
@@ -0,0 +1,46 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/codegen
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export namespace Formatter {
+  // Code formatter
+  export function Format(input: string): string {
+    function count(line: string, opens: string[]) {
+      const codes = opens.map((open) => open.charCodeAt(0))
+      // prettier-ignore
+      return line.split('').map((char) => char.charCodeAt(0)).reduce((acc, current) => codes.includes(current) ? acc + 1 : acc, 0)
+    }
+    let indent = 0
+    const output: string[] = []
+    for (const line of input.split('\n').map((n) => n.trim())) {
+      indent -= count(line, ['}'])
+      output.push(`${''.padStart(indent * 2, ' ')}${line}`)
+      indent += count(line, ['{'])
+    }
+    return output.join('\n')
+  }
+}
diff --git a/codegen/jsonschema.ts b/codegen/jsonschema.ts
index 23f4db8a1..31c85b854 100644
--- a/codegen/jsonschema.ts
+++ b/codegen/jsonschema.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { Formatter } from './formatter'
 import * as ts from 'typescript'
 
 export class NonExpressable extends Error {
@@ -35,7 +36,7 @@ export class NonExpressable extends Error {
 }
 
 /** Generates JsonSchema from TypeScript interface and type definitions */
-export namespace JsonSchemaCodeGen {
+export namespace JsonSchemaCodegen {
   function isReadonlyProperty(node: ts.PropertySignature): boolean {
     return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'readonly') !== undefined
   }
@@ -399,31 +400,11 @@ export namespace JsonSchemaCodeGen {
     }
   }
 
-  function Format(input: string): string {
-    function count(line: string, opens: string[]) {
-      const codes = opens.map((open) => open.charCodeAt(0))
-      return line
-        .split('')
-        .map((char) => char.charCodeAt(0))
-        .reduce((acc, current) => {
-          return codes.includes(current) ? acc + 1 : acc
-        }, 0)
-    }
-    let indent = 0
-    const output: string[] = []
-    for (const line of input.split('\n').map((n) => n.trim())) {
-      indent -= count(line, ['}', ']'])
-      output.push(`${''.padStart(indent * 2, ' ')}${line}`)
-      indent += count(line, ['{', '['])
-    }
-    return output.join('\n')
-  }
-
   /** Generates TypeBox types from TypeScript interface and type definitions */
   export function Generate(typescriptCode: string) {
     const source = ts.createSourceFile('code.ts', typescriptCode, ts.ScriptTarget.ESNext, true)
     const declarations = CollectNewLine(source)
-    const types = Format(declarations)
+    const types = Formatter.Format(declarations)
     return [types].join('\n')
   }
 }
diff --git a/codegen/typebox.ts b/codegen/typebox.ts
index d18637bd2..4d18be49c 100644
--- a/codegen/typebox.ts
+++ b/codegen/typebox.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { Formatter } from './formatter'
 import * as ts from 'typescript'
 
 /** Generates TypeBox types from TypeScript interface and type definitions */
@@ -319,26 +320,6 @@ export namespace TypeBoxCodegen {
     }
   }
 
-  function Format(input: string): string {
-    function count(line: string, opens: string[]) {
-      const codes = opens.map((open) => open.charCodeAt(0))
-      return line
-        .split('')
-        .map((char) => char.charCodeAt(0))
-        .reduce((acc, current) => {
-          return codes.includes(current) ? acc + 1 : acc
-        }, 0)
-    }
-    let indent = 0
-    const output: string[] = []
-    for (const line of input.split('\n').map((n) => n.trim())) {
-      indent -= count(line, ['}', ']'])
-      output.push(`${''.padStart(indent * 2, ' ')}${line}`)
-      indent += count(line, ['{', '['])
-    }
-    return output.join('\n')
-  }
-
   let useImports = false
   let useConditional = false
   let useGenerics = false
@@ -358,7 +339,7 @@ export namespace TypeBoxCodegen {
       if (!useGenerics) importStatments.push(`import { Type, Static } from '@sinclair/typebox'`)
     }
     const imports = importStatments.join('\n')
-    const types = Format(typeDeclarations)
+    const types = Formatter.Format(typeDeclarations)
     return [imports, '', types].join('\n')
   }
 }
diff --git a/codegen/typescript.ts b/codegen/typescript.ts
index 6087ece23..a0885fdd9 100644
--- a/codegen/typescript.ts
+++ b/codegen/typescript.ts
@@ -26,10 +26,11 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { Formatter } from './formatter'
 import { TypeGuard } from '@sinclair/typebox/guard'
 import * as Types from '@sinclair/typebox'
 
-export namespace TypeScriptCodeGen {
+export namespace TypeScriptCodegen {
   function Any(schema: Types.TAny) {
     return 'any'
   }
@@ -193,33 +194,13 @@ export namespace TypeScriptCodeGen {
     }
   }
 
-  function Format(input: string): string {
-    function count(line: string, opens: string[]) {
-      const codes = opens.map((open) => open.charCodeAt(0))
-      return line
-        .split('')
-        .map((char) => char.charCodeAt(0))
-        .reduce((acc, current) => {
-          return codes.includes(current) ? acc + 1 : acc
-        }, 0)
-    }
-    let indent = 0
-    const output: string[] = []
-    for (const line of input.split('\n').map((n) => n.trim())) {
-      indent -= count(line, ['}'])
-      output.push(`${''.padStart(indent * 2, ' ')}${line}`)
-      indent += count(line, ['{'])
-    }
-    return output.join('\n')
-  }
-
   /** Generates TypeScript code from TypeBox types */
   export function Generate(schema: Types.TSchema, references: Types.TSchema[] = []) {
     const result: string[] = []
     for (const reference of references) {
-      result.push(`type ${reference.$id} = ${Format([...Visit(reference)].join(''))}`)
+      result.push(`type ${reference.$id} = ${[...Visit(reference)].join('')}`)
     }
-    result.push(`type ${schema.$id || 'T'} = ${Format([...Visit(schema)].join(''))}`)
-    return result.join('\n\n')
+    result.push(`type ${schema.$id || 'T'} = ${[...Visit(schema)].join('')}`)
+    return Formatter.Format(result.join('\n\n'))
   }
 }
diff --git a/codegen/zod.ts b/codegen/zod.ts
new file mode 100644
index 000000000..4f900d64d
--- /dev/null
+++ b/codegen/zod.ts
@@ -0,0 +1,257 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/codegen
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Formatter } from './formatter'
+import { TypeGuard } from '@sinclair/typebox/guard'
+import * as Types from '@sinclair/typebox'
+
+export class ZodNonReferentialType extends Error {
+  constructor(message: string) {
+    super(`ZodNonReferentialType: ${message}`)
+  }
+}
+export class ZodUnsupportedType extends Error {
+  constructor(message: string) {
+    super(`ZodUnsupportedType: ${message}`)
+  }
+}
+export interface ZodCodegenOptions {
+  imports: boolean
+  exports: boolean
+}
+export namespace ZodCodegen {
+  function Any(schema: Types.TAny) {
+    return `z.any()`
+  }
+  function Array(schema: Types.TArray) {
+    const items = Visit(schema.items)
+    return `z.array(${items})`
+  }
+  function Boolean(schema: Types.TBoolean) {
+    return `z.boolean()`
+  }
+  function Constructor(schema: Types.TConstructor): string {
+    throw new ZodUnsupportedType(`TConstructor`)
+  }
+  function Function(schema: Types.TFunction) {
+    const params = schema.parameters.map((param) => Visit(param)).join(`, `)
+    const returns = Visit(schema.returns)
+    return `z.function().args(${params}).returns(${returns})`
+  }
+  function Integer(schema: Types.TInteger) {
+    const buffer: string[] = []
+    buffer.push(`z.number().int()`)
+    if (schema.minimum !== undefined) buffer.push(`.min(${schema.minimum})`)
+    if (schema.maximum !== undefined) buffer.push(`.max(${schema.maximum})`)
+    if (schema.exclusiveMaximum !== undefined) buffer.push(`.max(${schema.exclusiveMaximum - 1})`)
+    if (schema.exclusiveMinimum !== undefined) buffer.push(`.max(${schema.exclusiveMinimum + 1})`)
+    if (schema.multipleOf !== undefined) buffer.push(`.multipleOf(${schema.multipleOf})`)
+    return buffer.join(``)
+  }
+  function Literal(schema: Types.TLiteral) {
+    if (typeof schema.const === `string`) {
+      return `z.literal('${schema.const}')`
+    } else {
+      return `z.literal(${schema.const})`
+    }
+  }
+  function Never(schema: Types.TNever) {
+    return `z.never()`
+  }
+  function Null(schema: Types.TNull) {
+    return `z.null()`
+  }
+  function String(schema: Types.TString) {
+    const buffer: string[] = []
+    buffer.push(`z.string()`)
+    if (schema.maxLength !== undefined) buffer.push(`.max(${schema.maxLength})`)
+    if (schema.minLength !== undefined) buffer.push(`.min(${schema.minLength})`)
+    return buffer.join(``)
+  }
+  function Number(schema: Types.TNumber) {
+    const buffer: string[] = []
+    buffer.push(`z.number()`)
+    if (schema.minimum !== undefined) buffer.push(`.min(${schema.minimum})`)
+    if (schema.maximum !== undefined) buffer.push(`.max(${schema.maximum})`)
+    if (schema.exclusiveMaximum !== undefined) buffer.push(`.max(${schema.exclusiveMaximum - 1})`)
+    if (schema.exclusiveMinimum !== undefined) buffer.push(`.max(${schema.exclusiveMinimum + 1})`)
+    if (schema.multipleOf !== undefined) buffer.push(`.multipleOf(${schema.multipleOf})`)
+    return buffer.join(``)
+  }
+  function Object(schema: Types.TObject) {
+    const properties: string = globalThis.Object.entries(schema.properties)
+      .map(([key, value]) => {
+        const quoted = key.includes('-') || '1234567890'.includes(key.charAt(0))
+        const property = quoted ? `'${key}'` : key
+        return [`Optional`, `ReadonlyOptional`].includes(value[Types.Modifier] as string) ? `${property}: ${Visit(value)}.optional()` : `${property}: ${Visit(value)}`
+      })
+      .join(`,\n`)
+    const buffer: string[] = []
+    buffer.push(`z.object({\n${properties}\n})`)
+    if (schema.additionalProperties === false) buffer.push(`.strict()`)
+    return buffer.join(``)
+  }
+  function Promise(schema: Types.TPromise) {
+    const item = Visit(schema.item)
+    return `${item}.promise()`
+  }
+  function Record(schema: Types.TRecord) {
+    for (const [key, value] of globalThis.Object.entries(schema.patternProperties)) {
+      const type = Visit(value)
+      if (key === `^(0|[1-9][0-9]*)$`) {
+        throw new ZodUnsupportedType(`TRecord<TNumber, TUnknown>`)
+      } else {
+        return `z.record(${type})`
+      }
+    }
+    throw Error(`TypeScriptCodeGen: Unreachable`)
+  }
+  function Ref(schema: Types.TRef) {
+    if (!reference_map.has(schema.$ref!)) throw new ZodNonReferentialType(schema.$ref!)
+    return schema.$ref
+  }
+  function Self(schema: Types.TSelf) {
+    if (!reference_map.has(schema.$ref!)) throw new ZodNonReferentialType(schema.$ref!)
+    recursive_set.add(schema.$ref)
+    return schema.$ref
+  }
+  function Tuple(schema: Types.TTuple) {
+    if (schema.items === undefined) return `[]`
+    const items = schema.items.map((schema) => Visit(schema)).join(`, `)
+    return `z.tuple([${items}])`
+  }
+  function UInt8Array(schema: Types.TUint8Array): string {
+    throw new ZodUnsupportedType(`TUint8Array`)
+  }
+  function Undefined(schema: Types.TUndefined) {
+    return `z.undefined()`
+  }
+  function Union(schema: Types.TUnion) {
+    return `z.union([${schema.anyOf.map((schema) => Visit(schema)).join(`, `)}])`
+  }
+  function Unknown(schema: Types.TUnknown) {
+    return `z.unknown()`
+  }
+  function Void(schema: Types.TVoid) {
+    return `z.void()`
+  }
+  function Visit(schema: Types.TSchema): string {
+    if (schema.$id !== undefined) reference_map.set(schema.$id, schema)
+    if (TypeGuard.TAny(schema)) {
+      return Any(schema)
+    } else if (TypeGuard.TArray(schema)) {
+      return Array(schema)
+    } else if (TypeGuard.TBoolean(schema)) {
+      return Boolean(schema)
+    } else if (TypeGuard.TConstructor(schema)) {
+      return Constructor(schema)
+    } else if (TypeGuard.TFunction(schema)) {
+      return Function(schema)
+    } else if (TypeGuard.TInteger(schema)) {
+      return Integer(schema)
+    } else if (TypeGuard.TLiteral(schema)) {
+      return Literal(schema)
+    } else if (TypeGuard.TNever(schema)) {
+      return Never(schema)
+    } else if (TypeGuard.TNull(schema)) {
+      return Null(schema)
+    } else if (TypeGuard.TNumber(schema)) {
+      return Number(schema)
+    } else if (TypeGuard.TObject(schema)) {
+      return Object(schema)
+    } else if (TypeGuard.TPromise(schema)) {
+      return Promise(schema)
+    } else if (TypeGuard.TRecord(schema)) {
+      return Record(schema)
+    } else if (TypeGuard.TRef(schema)) {
+      return Ref(schema)
+    } else if (TypeGuard.TSelf(schema)) {
+      return Self(schema)
+    } else if (TypeGuard.TString(schema)) {
+      return String(schema)
+    } else if (TypeGuard.TTuple(schema)) {
+      return Tuple(schema)
+    } else if (TypeGuard.TUint8Array(schema)) {
+      return UInt8Array(schema)
+    } else if (TypeGuard.TUndefined(schema)) {
+      return Undefined(schema)
+    } else if (TypeGuard.TUnion(schema)) {
+      return Union(schema)
+    } else if (TypeGuard.TUnknown(schema)) {
+      return Unknown(schema)
+    } else if (TypeGuard.TVoid(schema)) {
+      return Void(schema)
+    } else {
+      throw Error(`TypeScriptCodeGen: Unknown type`)
+    }
+  }
+  const reference_map = new Map<string, Types.TSchema>()
+  const recursive_set = new Set<string>()
+  /** Renders a Zod definition of a TypeBox type */
+  export function Generate(schema: Types.TSchema, references: Types.TSchema[], options: ZodCodegenOptions = { imports: true, exports: false }) {
+    const emitted = new Set<string>()
+    const exports = options.exports ? 'export' : ''
+    const imports_code: string[] = []
+    const reference_code: string[] = []
+    const type_code: string[] = []
+    // initialize root schematic and reference map
+    if (schema.$id === undefined) schema.$id = `T_Generated`
+    for (const reference of references) {
+      if (reference.$id === undefined) throw new ZodNonReferentialType(JSON.stringify(reference))
+      reference_map.set(reference.$id, reference)
+    }
+    // render-code: Imports required for the generated code
+    if (options.imports) {
+      imports_code.push(`import z from 'zod'`)
+    }
+    // render-type: If we detect the root schematic has been referenced, we interpret this as a recursive
+    // root. It`s noted that zod performs 4x slower when wrapped in a lazy(() => ...), so this is considered
+    // an optimization.
+    const typedef = [...Visit(schema)].join(``)
+    if (recursive_set.has(schema.$id!)) {
+      type_code.push(`${exports} const ${schema.$id || `T`} = z.lazy(() => ${Formatter.Format(typedef)})`)
+    } else {
+      type_code.push(`${exports} const ${schema.$id || `T`} = ${Formatter.Format(typedef)}`)
+    }
+    emitted.add(schema.$id!)
+    // render-reference: References may either be recursive or not. We track a recursive_set when visiting
+    // schemas of type TSelf. If we`ve never observed the reference through recursion, when it should be safe
+    // to omit the lazy(() => ...) wrap.
+    for (const reference of reference_map.values()) {
+      if (emitted.has(reference.$id!)) continue
+      const typedef = [...Visit(schema)].join(``)
+      if (recursive_set.has(reference.$id!)) {
+        reference_code.push(`${exports} const ${reference.$id} = z.lazy(() => ${typedef})`)
+      } else {
+        reference_code.push(`${exports} const ${reference.$id} = ${typedef}`)
+      }
+      emitted.add(reference.$id!)
+    }
+    return Formatter.Format([...imports_code, ...reference_code, ...type_code].join(`\n\n`))
+  }
+}

From c843318058b10729a769220bebc75cbc5306f2e5 Mon Sep 17 00:00:00 2001
From: Yeongjet Tang <jettangs@gmail.com>
Date: Sat, 7 Jan 2023 20:59:24 +0800
Subject: [PATCH 056/369] Escape Regex String Patterns in Compiler (#302)

Co-authored-by: yeongjet <yeongjet@gmail.com>
---
 src/compiler/compiler.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 1e7e964bc..92fb69739 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -264,7 +264,7 @@ export namespace TypeCompiler {
     if (IsNumber(schema.minLength)) yield `(${value}.length >= ${schema.minLength})`
     if (IsNumber(schema.maxLength)) yield `(${value}.length <= ${schema.maxLength})`
     if (schema.pattern !== undefined) {
-      const local = PushLocal(`new RegExp(/${schema.pattern}/);`)
+      const local = PushLocal(`${new RegExp(schema.pattern)};`)
       yield `(${local}.test(${value}))`
     }
     if (schema.format !== undefined) {

From d8849641694101d66795d0263ced392965fab59d Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sat, 7 Jan 2023 22:03:42 +0900
Subject: [PATCH 057/369] Version

---
 package.json                    | 2 +-
 test/runtime/compiler/string.ts | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/package.json b/package.json
index b94472262..056480855 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.16",
+  "version": "0.25.17",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/test/runtime/compiler/string.ts b/test/runtime/compiler/string.ts
index 2f0005afb..baff1e18e 100644
--- a/test/runtime/compiler/string.ts
+++ b/test/runtime/compiler/string.ts
@@ -62,4 +62,9 @@ describe('type/compiler/String', () => {
     const T = Type.String({ pattern: '[\\d]{5}' })
     Ok(T, '12345')
   })
+
+  it('Should should escape characters in the pattern', () => {
+    const T = Type.String({ pattern: '/a/' })
+    Ok(T, '/a/')
+  })
 })

From df1dda9fd15f770bb6e82f1fb08732fcb62589ad Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 9 Jan 2023 20:53:24 +0900
Subject: [PATCH 058/369] Support Date Conversion For Cast (#307)

---
 changelog.md                       |  6 ++
 example/index.ts                   |  2 +-
 package.json                       |  2 +-
 src/compiler/compiler.ts           |  2 +-
 src/errors/errors.ts               |  3 +
 src/value/cast.ts                  | 93 ++++++++++++++--------------
 src/value/check.ts                 |  3 +
 src/value/value.ts                 |  4 +-
 test/runtime/compiler/date.ts      |  8 +--
 test/runtime/schema/date.ts        |  4 ++
 test/runtime/value/cast/convert.ts | 98 ++++++++++++++++--------------
 test/runtime/value/cast/date.ts    |  4 +-
 test/runtime/value/check/date.ts   |  5 ++
 13 files changed, 131 insertions(+), 103 deletions(-)

diff --git a/changelog.md b/changelog.md
index 8ab7ca510..57c8a06bf 100644
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,9 @@
+## [0.25.18](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.18)
+
+Updates:
+
+- [307](https://github.com/sinclairzx81/typebox/pull/307) implements date conversion when casting values with `Value.Cast(Type.Date(), ...)`. Castable values include numbers (interpretted as timestamps) and iso8601 string values. Uncastable values will result in dates with values of `1970-01-01T00:00:00.000Z`. This version also includes more robust checks for Dates initialized with invalid values.
+
 ## [0.25.11](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.11)
 
 Updates:
diff --git a/example/index.ts b/example/index.ts
index 6307054b6..588558a9d 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -1,4 +1,4 @@
-import { CodeGen } from '@sinclair/typebox/codegen'
+import { Codegen } from '@sinclair/typebox/codegen'
 import { TypeSystem } from '@sinclair/typebox/system'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 import { TypeGuard } from '@sinclair/typebox/guard'
diff --git a/package.json b/package.json
index 056480855..295a2dedf 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.17",
+  "version": "0.25.18",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 92fb69739..016279112 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -140,7 +140,7 @@ export namespace TypeCompiler {
   }
 
   function* Date(schema: Types.TDate, value: string): IterableIterator<string> {
-    yield `(${value} instanceof Date)`
+    yield `(${value} instanceof Date) && !isNaN(${value}.getTime())`
     if (IsNumber(schema.exclusiveMinimumTimestamp)) yield `(${value}.getTime() > ${schema.exclusiveMinimumTimestamp})`
     if (IsNumber(schema.exclusiveMaximumTimestamp)) yield `(${value}.getTime() < ${schema.exclusiveMaximumTimestamp})`
     if (IsNumber(schema.minimumTimestamp)) yield `(${value}.getTime() >= ${schema.minimumTimestamp})`
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index ad346e3a5..464d477d0 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -151,6 +151,9 @@ export namespace ValueErrors {
     if (!(value instanceof globalThis.Date)) {
       return yield { type: ValueErrorType.Date, schema, path, value, message: `Expected Date object` }
     }
+    if (isNaN(value.getTime())) {
+      return yield { type: ValueErrorType.Date, schema, path, value, message: `Invalid Date` }
+    }
     if (IsNumber(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
       yield { type: ValueErrorType.DateExclusiveMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater than ${schema.exclusiveMinimum}` }
     }
diff --git a/src/value/cast.ts b/src/value/cast.ts
index 5fccc466d..2535addff 100644
--- a/src/value/cast.ts
+++ b/src/value/cast.ts
@@ -35,25 +35,21 @@ import { Custom } from '../custom/index'
 // ----------------------------------------------------------------------------------------------
 // Errors
 // ----------------------------------------------------------------------------------------------
-
 export class ValueCastReferenceTypeError extends Error {
   constructor(public readonly schema: Types.TRef | Types.TSelf) {
     super(`ValueCast: Cannot locate referenced schema with $id '${schema.$ref}'`)
   }
 }
-
 export class ValueCastArrayUniqueItemsTypeError extends Error {
   constructor(public readonly schema: Types.TSchema, public readonly value: unknown) {
     super('ValueCast: Array cast produced invalid data due to uniqueItems constraint')
   }
 }
-
 export class ValueCastNeverTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
     super('ValueCast: Never types cannot be cast')
   }
 }
-
 export class ValueCastRecursiveTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
     super('ValueCast.Recursive: Cannot cast recursive schemas')
@@ -71,7 +67,6 @@ export class ValueCastUnknownTypeError extends Error {
 // to prevent large property counts biasing results. Properties that match literal values are
 // maximally awarded as literals are typically used as union discriminator fields.
 // ----------------------------------------------------------------------------------------------
-
 namespace UnionCastCreate {
   function Score(schema: Types.TSchema, references: Types.TSchema[], value: any): number {
     if (schema[Types.Kind] === 'Object' && typeof value === 'object' && value !== null) {
@@ -89,7 +84,6 @@ namespace UnionCastCreate {
       return ValueCheck.Check(schema, references, value) ? 1 : 0
     }
   }
-
   function Select(union: Types.TUnion, references: Types.TSchema[], value: any): Types.TSchema {
     let [select, best] = [union.anyOf[0], 0]
     for (const schema of union.anyOf) {
@@ -101,7 +95,6 @@ namespace UnionCastCreate {
     }
     return select
   }
-
   export function Create(union: Types.TUnion, references: Types.TSchema[], value: any) {
     if (union.default !== undefined) {
       return union.default
@@ -116,71 +109,99 @@ export namespace ValueCast {
   // ----------------------------------------------------------------------------------------------
   // Guards
   // ----------------------------------------------------------------------------------------------
-
   function IsArray(value: unknown): value is unknown[] {
     return typeof value === 'object' && globalThis.Array.isArray(value)
   }
-
+  function IsDate(value: unknown): value is Date {
+    return typeof value === 'object' && value instanceof globalThis.Date
+  }
   function IsString(value: unknown): value is string {
     return typeof value === 'string'
   }
-
   function IsBoolean(value: unknown): value is boolean {
     return typeof value === 'boolean'
   }
-
   function IsBigInt(value: unknown): value is bigint {
     return typeof value === 'bigint'
   }
-
   function IsNumber(value: unknown): value is number {
     return typeof value === 'number' && !isNaN(value)
   }
-
   function IsStringNumeric(value: unknown): value is string {
     return IsString(value) && !isNaN(value as any) && !isNaN(parseFloat(value))
   }
-
   function IsValueToString(value: unknown): value is { toString: () => string } {
     return IsBigInt(value) || IsBoolean(value) || IsNumber(value)
   }
-
   function IsValueTrue(value: unknown): value is true {
     return value === true || (IsNumber(value) && value === 1) || (IsBigInt(value) && value === globalThis.BigInt('1')) || (IsString(value) && (value.toLowerCase() === 'true' || value === '1'))
   }
-
   function IsValueFalse(value: unknown): value is true {
     return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === globalThis.BigInt('0')) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'))
   }
+  function IsTimeStringWithTimeZone(value: unknown): value is string {
+    return IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value)
+  }
+  function IsTimeStringWithoutTimeZone(value: unknown): value is string {
+    return IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value)
+  }
+  function IsDateTimeStringWithTimeZone(value: unknown): value is string {
+    return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value)
+  }
+  function IsDateTimeStringWithoutTimeZone(value: unknown): value is string {
+    return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value)
+  }
+  function IsDateString(value: unknown): value is string {
+    return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value)
+  }
 
   // ----------------------------------------------------------------------------------------------
   // Convert
   // ----------------------------------------------------------------------------------------------
-
   function TryConvertString(value: unknown) {
     return IsValueToString(value) ? value.toString() : value
   }
-
   function TryConvertNumber(value: unknown) {
     return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : value
   }
-
   function TryConvertInteger(value: unknown) {
     return IsStringNumeric(value) ? parseInt(value) : IsValueTrue(value) ? 1 : value
   }
-
   function TryConvertBoolean(value: unknown) {
     return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value
   }
+  function TryConvertDate(value: unknown) {
+    // note: this function may return an invalid dates for the regex tests
+    // above. Invalid dates will however be checked during the casting
+    // function and will return a epoch date if invalid. Consider better
+    // string parsing for the iso dates in future revisions.
+    return IsDate(value)
+      ? value
+      : IsNumber(value)
+      ? new globalThis.Date(value)
+      : IsValueTrue(value)
+      ? new globalThis.Date(1)
+      : IsStringNumeric(value)
+      ? new globalThis.Date(parseInt(value))
+      : IsTimeStringWithoutTimeZone(value)
+      ? new globalThis.Date(`1970-01-01T${value}.000Z`)
+      : IsTimeStringWithTimeZone(value)
+      ? new globalThis.Date(`1970-01-01T${value}`)
+      : IsDateTimeStringWithoutTimeZone(value)
+      ? new globalThis.Date(`${value}.000Z`)
+      : IsDateTimeStringWithTimeZone(value)
+      ? new globalThis.Date(value)
+      : IsDateString(value)
+      ? new globalThis.Date(`${value}T00:00:00.000Z`)
+      : value
+  }
 
   // ----------------------------------------------------------------------------------------------
   // Cast
   // ----------------------------------------------------------------------------------------------
-
   function Any(schema: Types.TAny, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
-
   function Array(schema: Types.TArray, references: Types.TSchema[], value: any): any {
     if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
     const created = IsArray(value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
@@ -192,12 +213,10 @@ export namespace ValueCast {
     if (!ValueCheck.Check(schema, references, unique)) throw new ValueCastArrayUniqueItemsTypeError(schema, unique)
     return unique
   }
-
   function Boolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): any {
     const conversion = TryConvertBoolean(value)
     return ValueCheck.Check(schema, references, conversion) ? conversion : ValueCreate.Create(schema, references)
   }
-
   function Constructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): any {
     if (ValueCheck.Check(schema, references, value)) return ValueCreate.Create(schema, references)
     const required = new Set(schema.returns.required || [])
@@ -208,37 +227,30 @@ export namespace ValueCast {
     }
     return result
   }
-
   function Date(schema: Types.TDate, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+    const conversion = TryConvertDate(value)
+    return ValueCheck.Check(schema, references, conversion) ? ValueClone.Clone(conversion) : ValueCreate.Create(schema, references)
   }
-
   function Function(schema: Types.TFunction, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
   }
-
   function Integer(schema: Types.TInteger, references: Types.TSchema[], value: any): any {
     const conversion = TryConvertInteger(value)
     return ValueCheck.Check(schema, references, conversion) ? conversion : ValueCreate.Create(schema, references)
   }
-
   function Literal(schema: Types.TLiteral, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
-
   function Never(schema: Types.TNever, references: Types.TSchema[], value: any): any {
     throw new ValueCastNeverTypeError(schema)
   }
-
   function Null(schema: Types.TNull, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
-
   function Number(schema: Types.TNumber, references: Types.TSchema[], value: any): any {
     const conversion = TryConvertNumber(value)
     return ValueCheck.Check(schema, references, conversion) ? conversion : ValueCreate.Create(schema, references)
   }
-
   function Object(schema: Types.TObject, references: Types.TSchema[], value: any): any {
     if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
     if (value === null || typeof value !== 'object') return ValueCreate.Create(schema, references)
@@ -258,11 +270,9 @@ export namespace ValueCast {
     }
     return result
   }
-
   function Promise(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
   }
-
   function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): any {
     if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
     if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value) || value instanceof globalThis.Date) return ValueCreate.Create(schema, references)
@@ -274,59 +284,47 @@ export namespace ValueCast {
     }
     return result
   }
-
   function Recursive(schema: Types.TRecursive<any>, references: Types.TSchema[], value: any): any {
     throw new ValueCastRecursiveTypeError(schema)
   }
-
   function Ref(schema: Types.TRef<any>, references: Types.TSchema[], value: any): any {
     const reference = references.find((reference) => reference.$id === schema.$ref)
     if (reference === undefined) throw new ValueCastReferenceTypeError(schema)
     return Visit(reference, references, value)
   }
-
   function Self(schema: Types.TSelf, references: Types.TSchema[], value: any): any {
     const reference = references.find((reference) => reference.$id === schema.$ref)
     if (reference === undefined) throw new ValueCastReferenceTypeError(schema)
     return Visit(reference, references, value)
   }
-
   function String(schema: Types.TString, references: Types.TSchema[], value: any): any {
     const conversion = TryConvertString(value)
     return ValueCheck.Check(schema, references, conversion) ? conversion : ValueCreate.Create(schema, references)
   }
-
   function Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): any {
     if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
     if (!globalThis.Array.isArray(value)) return ValueCreate.Create(schema, references)
     if (schema.items === undefined) return []
     return schema.items.map((schema, index) => Visit(schema, references, value[index]))
   }
-
   function Undefined(schema: Types.TUndefined, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
-
   function Union(schema: Types.TUnion, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : UnionCastCreate.Create(schema, references, value)
   }
-
   function Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
-
   function Unknown(schema: Types.TUnknown, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
-
   function Void(schema: Types.TVoid, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
-
   function UserDefined(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
-
   export function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
     const anyReferences = schema.$id === undefined ? references : [schema, ...references]
     const anySchema = schema as any
@@ -384,7 +382,6 @@ export namespace ValueCast {
         return UserDefined(anySchema, anyReferences, value)
     }
   }
-
   export function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: any): Types.Static<T> {
     return schema.$id === undefined ? Visit(schema, references, value) : Visit(schema, [schema, ...references], value)
   }
diff --git a/src/value/check.ts b/src/value/check.ts
index 4bd8389ce..4d4a50558 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -76,6 +76,9 @@ export namespace ValueCheck {
     if (!(value instanceof globalThis.Date)) {
       return false
     }
+    if (isNaN(value.getTime())) {
+      return false
+    }
     if (IsNumber(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
       return false
     }
diff --git a/src/value/value.ts b/src/value/value.ts
index 1e36736d0..aba57e044 100644
--- a/src/value/value.ts
+++ b/src/value/value.ts
@@ -38,9 +38,9 @@ import { ValueDelta, Edit } from './delta'
 
 /** Provides functions to perform structural updates to JavaScript values */
 export namespace Value {
-  /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number and boolean values if a reasonable conversion is possible. */
+  /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number, boolean and date values if a reasonable conversion is possible. */
   export function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): Types.Static<T>
-  /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number and boolean values if a reasonable conversion is possible. */
+  /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number, boolean and date values if a reasonable conversion is possible. */
   export function Cast<T extends Types.TSchema>(schema: T, value: unknown): Types.Static<T>
   export function Cast(...args: any[]) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
diff --git a/test/runtime/compiler/date.ts b/test/runtime/compiler/date.ts
index ae8855bd8..943bfa0e2 100644
--- a/test/runtime/compiler/date.ts
+++ b/test/runtime/compiler/date.ts
@@ -34,25 +34,25 @@ describe('type/compiler/Date', () => {
     const T = Type.Date()
     Ok(T, new Date())
   })
-
+  it('Should not validate Date if is invalid', () => {
+    const T = Type.Date()
+    Fail(T, new Date('not-a-valid-date'))
+  })
   it('Should validate Date minimumTimestamp', () => {
     const T = Type.Date({ minimumTimestamp: 10 })
     Fail(T, new Date(9))
     Ok(T, new Date(10))
   })
-
   it('Should validate Date maximumTimestamp', () => {
     const T = Type.Date({ maximumTimestamp: 10 })
     Ok(T, new Date(10))
     Fail(T, new Date(11))
   })
-
   it('Should validate Date exclusiveMinimumTimestamp', () => {
     const T = Type.Date({ exclusiveMinimumTimestamp: 10 })
     Fail(T, new Date(10))
     Ok(T, new Date(11))
   })
-
   it('Should validate Date exclusiveMaximumTimestamp', () => {
     const T = Type.Date({ exclusiveMaximumTimestamp: 10 })
     Ok(T, new Date(9))
diff --git a/test/runtime/schema/date.ts b/test/runtime/schema/date.ts
index 2e0672e95..7843e4af1 100644
--- a/test/runtime/schema/date.ts
+++ b/test/runtime/schema/date.ts
@@ -39,6 +39,10 @@ describe('type/schema/Date', () => {
     const T = Type.Date()
     Ok(T, new Date())
   })
+  it('Should not validate Date if is invalid', () => {
+    const T = Type.Date()
+    Fail(T, new Date('not-a-valid-date'))
+  })
   it('Should validate Date minimumTimestamp', () => {
     const T = Type.Date({ minimumTimestamp: 10 })
     Fail(T, new Date(9))
diff --git a/test/runtime/value/cast/convert.ts b/test/runtime/value/cast/convert.ts
index ba63f16a8..825dddc73 100644
--- a/test/runtime/value/cast/convert.ts
+++ b/test/runtime/value/cast/convert.ts
@@ -2,280 +2,290 @@ import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
+//---------------------------------------------------------------
+// String Convert
+//---------------------------------------------------------------
 describe('value/convert/String', () => {
   it('Should convert string', () => {
     const value = 'hello'
     const result = Value.Cast(Type.String(), value)
     Assert.deepEqual(result, 'hello')
   })
-
   it('Should convert number #1', () => {
     const value = 42
     const result = Value.Cast(Type.String(), value)
     Assert.deepEqual(result, '42')
   })
-
   it('Should convert number #2', () => {
     const value = 42n
     const result = Value.Cast(Type.String(), value)
     Assert.deepEqual(result, '42')
   })
-
   it('Should convert true', () => {
     const value = true
     const result = Value.Cast(Type.String(), value)
     Assert.deepEqual(result, 'true')
   })
-
   it('Should convert false', () => {
     const value = false
     const result = Value.Cast(Type.String(), value)
     Assert.deepEqual(result, 'false')
   })
-
   it('Should convert object', () => {
     const value = {}
     const result = Value.Cast(Type.String(), value)
     Assert.deepEqual(result, '')
   })
-
   it('Should convert array', () => {
     const value = [] as any[]
     const result = Value.Cast(Type.String(), value)
     Assert.deepEqual(result, '')
   })
 })
-
+//---------------------------------------------------------------
+// Number Convert
+//---------------------------------------------------------------
 describe('value/convert/Number', () => {
   it('Should convert string #1', () => {
     const value = 'hello'
     const result = Value.Cast(Type.Number(), value)
     Assert.deepEqual(result, 0)
   })
-
   it('Should convert string #2', () => {
     const value = '3.14'
     const result = Value.Cast(Type.Number(), value)
     Assert.deepEqual(result, 3.14)
   })
-
   it('Should convert string #3', () => {
     const value = '-0'
     const result = Value.Cast(Type.Number(), value)
     Assert.deepEqual(result, 0)
   })
-
   it('Should convert string #4', () => {
     const value = '-100'
     const result = Value.Cast(Type.Number(), value)
     Assert.deepEqual(result, -100)
   })
-
   it('Should convert number', () => {
     const value = 42
     const result = Value.Cast(Type.Number(), value)
     Assert.deepEqual(result, 42)
   })
-
   it('Should convert true', () => {
     const value = true
     const result = Value.Cast(Type.Number(), value)
     Assert.deepEqual(result, 1)
   })
-
   it('Should convert false', () => {
     const value = false
     const result = Value.Cast(Type.Number(), value)
     Assert.deepEqual(result, 0)
   })
-
   it('Should convert object', () => {
     const value = {}
     const result = Value.Cast(Type.String(), value)
     Assert.deepEqual(result, 0)
   })
-
   it('Should convert array', () => {
     const value = [] as any[]
     const result = Value.Cast(Type.String(), value)
     Assert.deepEqual(result, 0)
   })
 })
-
+//---------------------------------------------------------------
+// Integer Convert
+//---------------------------------------------------------------
 describe('value/convert/Integer', () => {
   it('Should convert string #1', () => {
     const value = 'hello'
     const result = Value.Cast(Type.Integer(), value)
     Assert.deepEqual(result, 0)
   })
-
   it('Should convert string #2', () => {
     const value = '3.14'
     const result = Value.Cast(Type.Integer(), value)
     Assert.deepEqual(result, 3)
   })
-
   it('Should convert string #3', () => {
     const value = '-0'
     const result = Value.Cast(Type.Integer(), value)
     Assert.deepEqual(result, 0)
   })
-
   it('Should convert string #4', () => {
     const value = '-100'
     const result = Value.Cast(Type.Integer(), value)
     Assert.deepEqual(result, -100)
   })
-
   it('Should convert number', () => {
     const value = 42
     const result = Value.Cast(Type.Integer(), value)
     Assert.deepEqual(result, 42)
   })
-
   it('Should convert true', () => {
     const value = true
     const result = Value.Cast(Type.Integer(), value)
     Assert.deepEqual(result, 1)
   })
-
   it('Should convert false', () => {
     const value = false
     const result = Value.Cast(Type.Integer(), value)
     Assert.deepEqual(result, 0)
   })
-
   it('Should convert object', () => {
     const value = {}
     const result = Value.Cast(Type.Integer(), value)
     Assert.deepEqual(result, 0)
   })
-
   it('Should convert array', () => {
     const value = [] as any[]
     const result = Value.Cast(Type.Integer(), value)
     Assert.deepEqual(result, 0)
   })
 })
-
+//---------------------------------------------------------------
+// Boolean Convert
+//---------------------------------------------------------------
 describe('value/convert/Boolean', () => {
   it('Should convert string #1', () => {
     const value = 'hello'
     const result = Value.Cast(Type.Boolean(), value)
     Assert.deepEqual(result, false)
   })
-
   it('Should convert string #2', () => {
     const value = 'true'
     const result = Value.Cast(Type.Boolean(), value)
     Assert.deepEqual(result, true)
   })
-
   it('Should convert string #3', () => {
     const value = 'TRUE'
     const result = Value.Cast(Type.Boolean(), value)
     Assert.deepEqual(result, true)
   })
-
   it('Should convert string #4', () => {
     const value = 'false'
     const result = Value.Cast(Type.Boolean(), value)
     Assert.deepEqual(result, false)
   })
-
   it('Should convert string #5', () => {
     const value = '0'
     const result = Value.Cast(Type.Boolean(), value)
     Assert.deepEqual(result, false)
   })
-
   it('Should convert string #6', () => {
     const value = '1'
     const result = Value.Cast(Type.Boolean(), value)
     Assert.deepEqual(result, true)
   })
-
   it('Should convert string #7', () => {
     const value = '0'
     const result = Value.Cast(Type.Boolean({ default: true }), value)
     Assert.deepEqual(result, false)
   })
-
   it('Should convert string #8', () => {
     const value = '1'
     const result = Value.Cast(Type.Boolean({ default: false }), value)
     Assert.deepEqual(result, true)
   })
-
   it('Should convert string #8', () => {
     const value = '2'
     const result = Value.Cast(Type.Boolean({ default: true }), value)
     Assert.deepEqual(result, true)
   })
-
   it('Should convert number #1', () => {
     const value = 0
     const result = Value.Cast(Type.Boolean(), value)
     Assert.deepEqual(result, false)
   })
-
   it('Should convert number #2', () => {
     const value = 1n
     const result = Value.Cast(Type.Boolean(), value)
     Assert.deepEqual(result, true)
   })
-
   it('Should convert number #3', () => {
     const value = 1
     const result = Value.Cast(Type.Boolean(), value)
     Assert.deepEqual(result, true)
   })
-
   it('Should convert number #4', () => {
     const value = 2
     const result = Value.Cast(Type.Boolean(), value)
     Assert.deepEqual(result, false)
   })
-
   it('Should convert number #5', () => {
     const value = 0
     const result = Value.Cast(Type.Boolean({ default: true }), value)
     Assert.deepEqual(result, false)
   })
-
   it('Should convert number #6', () => {
     const value = 1
     const result = Value.Cast(Type.Boolean({ default: false }), value)
     Assert.deepEqual(result, true)
   })
-
   it('Should convert number #7', () => {
     const value = 2
     const result = Value.Cast(Type.Boolean({ default: true }), value)
     Assert.deepEqual(result, true)
   })
-
   it('Should convert true', () => {
     const value = true
     const result = Value.Cast(Type.Boolean(), value)
     Assert.deepEqual(result, true)
   })
-
   it('Should convert false', () => {
     const value = false
     const result = Value.Cast(Type.Boolean(), value)
     Assert.deepEqual(result, false)
   })
-
   it('Should convert object', () => {
     const value = {}
     const result = Value.Cast(Type.Boolean(), value)
     Assert.deepEqual(result, false)
   })
-
   it('Should convert array', () => {
     const value = [] as any[]
     const result = Value.Cast(Type.Boolean(), value)
     Assert.deepEqual(result, false)
   })
 })
+
+//---------------------------------------------------------------
+// Date Convert
+//---------------------------------------------------------------
+describe('value/convert/Date', () => {
+  it('Should convert from number', () => {
+    const result = Value.Cast(Type.Date(), 123)
+    Assert.deepEqual(result.getTime(), 123)
+  })
+  it('Should convert from numeric string', () => {
+    const result = Value.Cast(Type.Date(), '123')
+    Assert.deepEqual(result.getTime(), 123)
+  })
+  it('Should convert from boolean true (interpretted as numeric 1)', () => {
+    const result = Value.Cast(Type.Date(), true)
+    Assert.deepEqual(result.getTime(), 1)
+  })
+  it('Should convert from datetime string', () => {
+    const result = Value.Cast(Type.Date(), '1980-02-03T01:02:03.000Z')
+    Assert.deepEqual(result.toISOString(), '1980-02-03T01:02:03.000Z')
+  })
+  it('Should convert from datetime string without timezone', () => {
+    const result = Value.Cast(Type.Date(), '1980-02-03T01:02:03')
+    Assert.deepEqual(result.toISOString(), '1980-02-03T01:02:03.000Z')
+  })
+  it('Should convert from time with timezone', () => {
+    const result = Value.Cast(Type.Date(), '01:02:03.000Z')
+    Assert.deepEqual(result.toISOString(), '1970-01-01T01:02:03.000Z')
+  })
+  it('Should convert from time without timezone', () => {
+    const result = Value.Cast(Type.Date(), '01:02:03')
+    Assert.deepEqual(result.toISOString(), '1970-01-01T01:02:03.000Z')
+  })
+  it('Should convert from date string', () => {
+    const result = Value.Cast(Type.Date(), '1980-02-03')
+    Assert.deepEqual(result.toISOString(), '1980-02-03T00:00:00.000Z')
+  })
+  it('Should convert invalid strings to unix epoch 0', () => {
+    const result = Value.Cast(Type.Date(), 'invalid-date')
+    Assert.deepEqual(result.toISOString(), '1970-01-01T00:00:00.000Z')
+  })
+})
diff --git a/test/runtime/value/cast/date.ts b/test/runtime/value/cast/date.ts
index 69c26dc40..a991af828 100644
--- a/test/runtime/value/cast/date.ts
+++ b/test/runtime/value/cast/date.ts
@@ -15,13 +15,13 @@ describe('value/cast/Date', () => {
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.deepEqual(result.getTime(), 1) // convert
   })
 
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.deepEqual(result.getTime(), 1) // convert
   })
 
   it('Should upcast from object', () => {
diff --git a/test/runtime/value/check/date.ts b/test/runtime/value/check/date.ts
index 583e1b620..39d40e00d 100644
--- a/test/runtime/value/check/date.ts
+++ b/test/runtime/value/check/date.ts
@@ -44,4 +44,9 @@ describe('value/check/Date', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, true)
   })
+  it('Should not validate Date if is invalid', () => {
+    const value = new Date('not-a-valid-date')
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
 })

From 4d7ef420d19af8d133ad651285845e73e17198ab Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 9 Jan 2023 23:26:24 +0900
Subject: [PATCH 059/369] Revised User Defined Type and Format API (#308)

---
 package.json                             |   2 +-
 readme.md                                | 216 +++++++++++++----------
 src/system/system.ts                     |  39 +++-
 test/runtime/system/AllowArrayObjects.ts |   2 +-
 test/runtime/system/AllowNaN.ts          |   2 +-
 test/runtime/system/CreateFormat.ts      |  17 ++
 test/runtime/system/CreateType.ts        |  23 +++
 test/runtime/system/index.ts             |   2 +
 8 files changed, 200 insertions(+), 103 deletions(-)
 create mode 100644 test/runtime/system/CreateFormat.ts
 create mode 100644 test/runtime/system/CreateType.ts

diff --git a/package.json b/package.json
index 295a2dedf..fd8c28e3e 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.18",
+  "version": "0.25.19",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index ac6ea8174..3a576e9f7 100644
--- a/readme.md
+++ b/readme.md
@@ -96,10 +96,11 @@ License MIT
   - [Errors](#values-errors)
   - [Pointer](#values-pointer)
 - [TypeCheck](#typecheck)
-  - [Ajv](#typecheck-ajv)
   - [TypeCompiler](#typecheck-typecompiler)
-  - [Custom Types](#typecheck-custom-types)
-  - [Custom Formats](#typecheck-custom-formats)
+  - [Ajv](#typecheck-ajv)
+- [TypeSystem](#typecheck)
+  - [Types](#typesystem-types)
+  - [Formats](#typesystem-formats)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
   - [Validate](#benchmark-validate)
@@ -936,6 +937,71 @@ TypeBox targets JSON Schema Draft 6 and is built and tested against the Ajv JSON
 
 The following sections detail using these validators.
 
+<a name='typecheck-typecompiler'></a>
+
+### TypeCompiler
+
+TypeBox includes an high performance just-in-time (JIT) compiler and type checker that can be used in applications that require extremely fast validation. Note that this compiler is optimized for TypeBox types only where the schematics are known in advance.
+
+The compiler module is provided as an optional import.
+
+```typescript
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+```
+
+Use the `Compile(...)` function to compile a type.
+
+```typescript
+const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
+  x: Type.Number(),                                  //     x: TNumber;
+  y: Type.Number(),                                  //     y: TNumber;
+  z: Type.Number()                                   //     z: TNumber;
+}))                                                  // }>>
+
+const R = C.Check({ x: 1, y: 2, z: 3 })              // const R = true
+```
+
+Validation errors can be read with the `Errors(...)` function.
+
+```typescript
+const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
+  x: Type.Number(),                                  //     x: TNumber;
+  y: Type.Number(),                                  //     y: TNumber;
+  z: Type.Number()                                   //     z: TNumber;
+}))                                                  // }>>
+
+const value = { }
+
+const errors = [...C.Errors(value)]                  // const errors = [{
+                                                     //   schema: { type: 'number' },
+                                                     //   path: '/x',
+                                                     //   value: undefined,
+                                                     //   message: 'Expected number'
+                                                     // }, {
+                                                     //   schema: { type: 'number' },
+                                                     //   path: '/y',
+                                                     //   value: undefined,
+                                                     //   message: 'Expected number'
+                                                     // }, {
+                                                     //   schema: { type: 'number' },
+                                                     //   path: '/z',
+                                                     //   value: undefined,
+                                                     //   message: 'Expected number'
+                                                     // }]
+```
+
+Compiled routines can be inspected with the `.Code()` function.
+
+```typescript
+const C = TypeCompiler.Compile(Type.String())        // const C: TypeCheck<TString>
+
+console.log(C.Code())                                // return function check(value) {
+                                                     //   return (
+                                                     //     (typeof value === 'string')
+                                                     //   )
+                                                     // }
+```
+
 <a name='typecheck-ajv'></a>
 
 ### Ajv
@@ -1066,125 +1132,87 @@ const R = ajv.validate(Type.Object({                 // const R = true
 </details>
 
 
-<a name='typecheck-typecompiler'></a>
+<a name='typesystem'></a>
 
-### TypeCompiler
+## TypeSystem
 
-TypeBox provides an optional high performance just-in-time (JIT) compiler and type checker that can be used in applications that require extremely fast validation. Note that this compiler is optimized for TypeBox types only where the schematics are known in advance. If defining custom types with `Type.Unsafe<T>` please consider Ajv.
+TypeBox provides an extensible TypeSystem module that enables developers to register additional types above and beyond the standard or extended type set. This module also allows developers to define custom string formats as well as override certain type checking behaviours.
 
-The compiler module is provided as an optional import.
+The TypeSystem module is provided as an optional import.
 
 ```typescript
-import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { TypeSystem } from '@sinclair/typebox/system'
 ```
 
-Use the `Compile(...)` function to compile a type.
-
-```typescript
-const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
-  x: Type.Number(),                                  //     x: TNumber;
-  y: Type.Number(),                                  //     y: TNumber;
-  z: Type.Number()                                   //     z: TNumber;
-}))                                                  // }>>
+<a name='typesystem-types'></a>
 
-const R = C.Check({ x: 1, y: 2, z: 3 })              // const R = true
-```
+### Types
 
-Validation errors can be read with the `Errors(...)` function.
+Use the `CreateType(...)` function to specify and return a custom type. This function will return a type factory function that can be used to construct the type. The following creates and registers a BigNumber type which will statically infer as `bigint`.
 
 ```typescript
-const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
-  x: Type.Number(),                                  //     x: TNumber;
-  y: Type.Number(),                                  //     y: TNumber;
-  z: Type.Number()                                   //     z: TNumber;
-}))                                                  // }>>
+//--------------------------------------------------------------------------------------------
+//
+// Use TypeSystem.CreateType(...) to define and return a type factory function
+//
+//--------------------------------------------------------------------------------------------
 
-const value = { }
+type BigNumberOptions = { minimum?: bigint; maximum?: bigint }
 
-const errors = [...C.Errors(value)]                  // const errors = [{
-                                                     //   schema: { type: 'number' },
-                                                     //   path: '/x',
-                                                     //   value: undefined,
-                                                     //   message: 'Expected number'
-                                                     // }, {
-                                                     //   schema: { type: 'number' },
-                                                     //   path: '/y',
-                                                     //   value: undefined,
-                                                     //   message: 'Expected number'
-                                                     // }, {
-                                                     //   schema: { type: 'number' },
-                                                     //   path: '/z',
-                                                     //   value: undefined,
-                                                     //   message: 'Expected number'
-                                                     // }]
-```
+const BigNumber = TypeSystem.CreateType<bigint, BigNumberOptions>(
+  'BigNumber', 
+  (options, value) => {
+    if (typeof value !== 'bigint') return false
+    if (options.maximum !== undefined && value > options.maximum) return false
+    if (options.minimum !== undefined && value < options.minimum) return false
+    return true
+  }
+)
 
-Compiled routines can be inspected with the `.Code()` function.
+//--------------------------------------------------------------------------------------------
+//
+// Use the custom type like any other type
+//
+//--------------------------------------------------------------------------------------------
 
-```typescript
-const C = TypeCompiler.Compile(Type.String())        // const C: TypeCheck<TString>
+const T = BigNumber({ minimum: 10n, maximum: 20n })  // const T = { 
+                                                     //    minimum: 10n, 
+                                                     //    maximum: 20n, 
+                                                     //    [Symbol(TypeBox.Kind)]: 'BigNumber' 
+                                                     //  }
 
-console.log(C.Code())                                // return function check(value) {
-                                                     //   return (
-                                                     //     (typeof value === 'string')
-                                                     //   )
-                                                     // }
+const C = TypeCompiler.Compile(T)
+const X = C.Check(15n)                               // const X = true
+const Y = C.Check(5n)                                // const Y = false
+const Z = C.Check(25n)                               // const Z = false
 ```
 
-<a name='typecheck-custom-types'></a>
+<a name='typesystem-formats'></a>
 
-### Custom Types
+### Formats
 
-Use the custom module to create user defined types. User defined types require a `[Kind]` symbol property which is used to match the schema against a registered type. Custom types are specific to TypeBox and can only be used with the TypeCompiler and Value modules.
-
-The custom module is an optional import.
+Use the `CreateFormat(...)` function to specify user defined string formats. The following creates a custom string format that checks for lowercase.
 
 ```typescript
-import { Custom } from '@sinclair/typebox/custom'
-```
-
-The following creates a `bigint` type.
-
-```typescript
-import { Type, Kind } from '@sinclair/typebox'
-
-Custom.Set('bigint', (schema, value) => typeof value === 'bigint')
-//            ▲
-//            │
-//            └────────────────────────────┐
-//                                         │
-const T = Type.Unsafe<bigint>({ [Kind]: 'bigint' })  // const T = { [Kind]: 'BigInt' }
-
-const A = TypeCompiler.Compile(T).Check(1n)          // const A = true
-
-const B = Value.Check(T, 1)                          // const B = false
-```
-
-<a name='typecheck-custom-formats'></a>
-
-### Custom Formats
-
-Use the format module to create user defined string formats. The format module is specific to TypeBox can only be used with the TypeCompiler and Value modules. If using Ajv, please refer to the official Ajv format documentation located [here](https://ajv.js.org/guide/formats.html).
-
-The format module is an optional import.
+//--------------------------------------------------------------------------------------------
+//
+// Use TypeSystem.CreateFormat(...) to define a custom string format
+//
+//--------------------------------------------------------------------------------------------
 
-```typescript
-import { Format } from '@sinclair/typebox/format'
-```
+TypeSystem.CreateFormat('lowercase', value => value === value.toLowerCase())
 
-The following creates a custom string format that checks for lowercase.
+//--------------------------------------------------------------------------------------------
+//
+// Use the format by creating string types with the 'format' option
+//
+//--------------------------------------------------------------------------------------------
 
-```typescript
-Format.Set('lowercase', value => value === value.toLowerCase())
-//            ▲
-//            │
-//            └────────────────────┐         
-//                                 │
 const T = Type.String({ format: 'lowercase' })
 
-const A = TypeCompiler.Compile(T).Check('action')    // const A = true
+const A = Value.Check(T, 'action')                   // const A = true
 
-const B = Value.Check(T, 'Action')                   // const B = false
+const B = Value.Check(T, 'ACTION')                   // const B = false
 ```
 
 <a name='benchmark'></a>
diff --git a/src/system/system.ts b/src/system/system.ts
index 0ddd2a1f0..61486609b 100644
--- a/src/system/system.ts
+++ b/src/system/system.ts
@@ -26,13 +26,40 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { Kind, Type } from '@sinclair/typebox'
+import { Custom } from '../custom/index'
+import { Format } from '../format/index'
+
+export class TypeSystemDuplicateTypeKind extends Error {
+  constructor(kind: string) {
+    super(`Duplicate kind '${kind}' detected`)
+  }
+}
+export class TypeSystemDuplicateFormat extends Error {
+  constructor(kind: string) {
+    super(`Duplicate format '${kind}' detected`)
+  }
+}
+
+/** Creates user defined types and formats and provides overrides for value checking behaviours */
 export namespace TypeSystem {
-  /**
-   * Sets whether arrays should be treated as kinds of objects. The default is `false`
-   */
+  /** Sets whether arrays should be treated as kinds of objects. The default is `false` */
   export let AllowArrayObjects: boolean = false
-  /**
-   * Sets whether numeric checks should consider NaN a valid number type. The default is `false`
-   */
+
+  /** Sets whether numeric checks should consider NaN a valid number type. The default is `false` */
   export let AllowNaN: boolean = false
+
+  /** Creates a custom type */
+  export function CreateType<Type, Options = object>(kind: string, callback: (options: Options, value: unknown) => boolean) {
+    if (Custom.Has(kind)) throw new TypeSystemDuplicateTypeKind(kind)
+    Custom.Set(kind, callback)
+    return (options: Partial<Options> = {}) => Type.Unsafe<Type>({ ...options, [Kind]: kind })
+  }
+
+  /** Creates a custom string format */
+  export function CreateFormat(format: string, callback: (value: string) => boolean) {
+    if (Format.Has(format)) throw new TypeSystemDuplicateFormat(format)
+    Format.Set(format, callback)
+    return callback
+  }
 }
diff --git a/test/runtime/system/AllowArrayObjects.ts b/test/runtime/system/AllowArrayObjects.ts
index 9ee0c46e3..064139813 100644
--- a/test/runtime/system/AllowArrayObjects.ts
+++ b/test/runtime/system/AllowArrayObjects.ts
@@ -2,7 +2,7 @@ import { Ok, Fail } from '../compiler/validate'
 import { TypeSystem } from '@sinclair/typebox/system'
 import { Type } from '@sinclair/typebox'
 
-describe('TypeSystem/AllowArrayObjects', () => {
+describe('system/TypeSystem/AllowArrayObjects', () => {
   before(() => {
     TypeSystem.AllowArrayObjects = true
   })
diff --git a/test/runtime/system/AllowNaN.ts b/test/runtime/system/AllowNaN.ts
index bcf0d9ee5..4795e7936 100644
--- a/test/runtime/system/AllowNaN.ts
+++ b/test/runtime/system/AllowNaN.ts
@@ -2,7 +2,7 @@ import { Ok, Fail } from '../compiler/validate'
 import { TypeSystem } from '@sinclair/typebox/system'
 import { Type } from '@sinclair/typebox'
 
-describe('TypeSystem/AllowNaN', () => {
+describe('system/TypeSystem/AllowNaN', () => {
   before(() => {
     TypeSystem.AllowNaN = true
   })
diff --git a/test/runtime/system/CreateFormat.ts b/test/runtime/system/CreateFormat.ts
new file mode 100644
index 000000000..751eb34e8
--- /dev/null
+++ b/test/runtime/system/CreateFormat.ts
@@ -0,0 +1,17 @@
+import { Ok, Fail } from '../compiler/validate'
+import { Assert } from '../assert/index'
+import { TypeSystem } from '@sinclair/typebox/system'
+import { Type } from '@sinclair/typebox'
+
+describe('system/TypeSystem/CreateFormat', () => {
+  it('Should create and validate a format', () => {
+    TypeSystem.CreateFormat('CreateFormat0', (value) => value === value.toLowerCase())
+    const T = Type.String({ format: 'CreateFormat0' })
+    Ok(T, 'action')
+    Fail(T, 'ACTION')
+  })
+  it('Should throw if registering the same format twice', () => {
+    TypeSystem.CreateFormat('CreateFormat1', (value) => true)
+    Assert.throws(() => TypeSystem.CreateFormat('CreateFormat1', (value) => true))
+  })
+})
diff --git a/test/runtime/system/CreateType.ts b/test/runtime/system/CreateType.ts
new file mode 100644
index 000000000..60626b7d2
--- /dev/null
+++ b/test/runtime/system/CreateType.ts
@@ -0,0 +1,23 @@
+import { Ok, Fail } from '../compiler/validate'
+import { Assert } from '../assert/index'
+import { TypeSystem } from '@sinclair/typebox/system'
+
+describe('system/TypeSystem/CreateType', () => {
+  it('Should create and validate a type', () => {
+    type BigNumberOptions = { minimum?: bigint; maximum?: bigint }
+    const BigNumber = TypeSystem.CreateType<bigint, BigNumberOptions>('CreateType0', (options, value) => {
+      if (typeof value !== 'bigint') return false
+      if (options.maximum !== undefined && value > options.maximum) return false
+      if (options.minimum !== undefined && value < options.minimum) return false
+      return true
+    })
+    const T = BigNumber({ minimum: 10n, maximum: 20n })
+    Ok(T, 15n)
+    Fail(T, 5n)
+    Fail(T, 25n)
+  })
+  it('Should throw if registering the same type twice', () => {
+    TypeSystem.CreateType('CreateType1', () => true)
+    Assert.throws(() => TypeSystem.CreateType('CreateType1', () => true))
+  })
+})
diff --git a/test/runtime/system/index.ts b/test/runtime/system/index.ts
index fde988aa0..72bdb9c85 100644
--- a/test/runtime/system/index.ts
+++ b/test/runtime/system/index.ts
@@ -1,2 +1,4 @@
 import './AllowArrayObjects'
 import './AllowNaN'
+import './CreateFormat'
+import './CreateType'

From a57f858d79976b0b02fbfde4bd94659817e54a7e Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Mon, 9 Jan 2023 23:33:37 +0900
Subject: [PATCH 060/369] Use Relative Import

---
 package.json         | 2 +-
 src/system/system.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/package.json b/package.json
index fd8c28e3e..22362682c 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.19",
+  "version": "0.25.20",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/system/system.ts b/src/system/system.ts
index 61486609b..97c86e2ec 100644
--- a/src/system/system.ts
+++ b/src/system/system.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { Kind, Type } from '@sinclair/typebox'
+import { Kind, Type } from '../typebox'
 import { Custom } from '../custom/index'
 import { Format } from '../format/index'
 

From c4061c162eb99be3d07b08c9cb393804c3977060 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 19 Jan 2023 15:23:30 +0900
Subject: [PATCH 061/369] Annual License Update (#312)

---
 codegen/codegen.ts                    | 2 +-
 codegen/formatter.ts                  | 2 +-
 codegen/index.ts                      | 2 +-
 codegen/jsonschema.ts                 | 2 +-
 codegen/typebox.ts                    | 2 +-
 codegen/typescript.ts                 | 2 +-
 codegen/zod.ts                        | 2 +-
 example/collections/array.ts          | 2 +-
 example/collections/index.ts          | 2 +-
 example/collections/map.ts            | 2 +-
 example/collections/set.ts            | 2 +-
 example/extensions/index.ts           | 2 +-
 example/extensions/intersect-allof.ts | 2 +-
 example/extensions/union-enum.ts      | 2 +-
 example/extensions/union-oneof.ts     | 2 +-
 license                               | 2 +-
 package-lock.json                     | 4 ++--
 package.json                          | 2 +-
 src/compiler/compiler.ts              | 2 +-
 src/compiler/index.ts                 | 2 +-
 src/conditional/conditional.ts        | 2 +-
 src/conditional/index.ts              | 2 +-
 src/conditional/structural.ts         | 2 +-
 src/custom/custom.ts                  | 2 +-
 src/custom/index.ts                   | 2 +-
 src/errors/errors.ts                  | 2 +-
 src/errors/index.ts                   | 2 +-
 src/format/format.ts                  | 2 +-
 src/format/index.ts                   | 2 +-
 src/guard/guard.ts                    | 2 +-
 src/guard/index.ts                    | 2 +-
 src/hash/hash.ts                      | 2 +-
 src/hash/index.ts                     | 2 +-
 src/system/index.ts                   | 2 +-
 src/system/system.ts                  | 2 +-
 src/typebox.ts                        | 2 +-
 src/value/cast.ts                     | 2 +-
 src/value/check.ts                    | 2 +-
 src/value/clone.ts                    | 2 +-
 src/value/create.ts                   | 2 +-
 src/value/delta.ts                    | 2 +-
 src/value/equal.ts                    | 2 +-
 src/value/index.ts                    | 2 +-
 src/value/is.ts                       | 2 +-
 src/value/pointer.ts                  | 2 +-
 src/value/value.ts                    | 2 +-
 46 files changed, 47 insertions(+), 47 deletions(-)

diff --git a/codegen/codegen.ts b/codegen/codegen.ts
index 8e0237439..81d3797d3 100644
--- a/codegen/codegen.ts
+++ b/codegen/codegen.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/codegen/formatter.ts b/codegen/formatter.ts
index 6e3b4a7b8..68d8cd440 100644
--- a/codegen/formatter.ts
+++ b/codegen/formatter.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/codegen/index.ts b/codegen/index.ts
index d72a0bbe4..01fc5f56e 100644
--- a/codegen/index.ts
+++ b/codegen/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/codegen/jsonschema.ts b/codegen/jsonschema.ts
index 31c85b854..c429a1125 100644
--- a/codegen/jsonschema.ts
+++ b/codegen/jsonschema.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/codegen/typebox.ts b/codegen/typebox.ts
index 4d18be49c..598921ba0 100644
--- a/codegen/typebox.ts
+++ b/codegen/typebox.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/codegen/typescript.ts b/codegen/typescript.ts
index a0885fdd9..bb1d7a6c8 100644
--- a/codegen/typescript.ts
+++ b/codegen/typescript.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/codegen/zod.ts b/codegen/zod.ts
index 4f900d64d..bfa9eaecf 100644
--- a/codegen/zod.ts
+++ b/codegen/zod.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/collections/array.ts b/example/collections/array.ts
index 66a255a5c..8bc93a37b 100644
--- a/example/collections/array.ts
+++ b/example/collections/array.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/collections/index.ts b/example/collections/index.ts
index 004ddbfb5..49183354a 100644
--- a/example/collections/index.ts
+++ b/example/collections/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/collections/map.ts b/example/collections/map.ts
index 040bd5fa7..debda1af6 100644
--- a/example/collections/map.ts
+++ b/example/collections/map.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/collections/set.ts b/example/collections/set.ts
index aa83c5d26..6ca6e055a 100644
--- a/example/collections/set.ts
+++ b/example/collections/set.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/extensions/index.ts b/example/extensions/index.ts
index a8ff621e5..31d34239e 100644
--- a/example/extensions/index.ts
+++ b/example/extensions/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/extensions/intersect-allof.ts b/example/extensions/intersect-allof.ts
index 7cf413e73..4a3a6016d 100644
--- a/example/extensions/intersect-allof.ts
+++ b/example/extensions/intersect-allof.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/extensions/union-enum.ts b/example/extensions/union-enum.ts
index ac895338e..6f61163f2 100644
--- a/example/extensions/union-enum.ts
+++ b/example/extensions/union-enum.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/extensions/union-oneof.ts b/example/extensions/union-oneof.ts
index c40a9f9b5..ef749b778 100644
--- a/example/extensions/union-oneof.ts
+++ b/example/extensions/union-oneof.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/license b/license
index cd929d327..08641fd64 100644
--- a/license
+++ b/license
@@ -2,7 +2,7 @@ TypeBox: JSON Schema Type Builder with Static Type Resolution for TypeScript
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/package-lock.json b/package-lock.json
index 81dc5039e..63868b5b2 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.10",
+  "version": "0.25.21",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.25.10",
+      "version": "0.25.21",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 22362682c..20872e73a 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.20",
+  "version": "0.25.21",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 016279112..f3150170c 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/compiler/index.ts b/src/compiler/index.ts
index 2785e30e6..e747dd76a 100644
--- a/src/compiler/index.ts
+++ b/src/compiler/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/conditional/conditional.ts b/src/conditional/conditional.ts
index ecd2a756d..a71a8d4d2 100644
--- a/src/conditional/conditional.ts
+++ b/src/conditional/conditional.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/conditional/index.ts b/src/conditional/index.ts
index 93afa1daa..c6f97147d 100644
--- a/src/conditional/index.ts
+++ b/src/conditional/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/conditional/structural.ts b/src/conditional/structural.ts
index 323c761ab..ec444955a 100644
--- a/src/conditional/structural.ts
+++ b/src/conditional/structural.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/custom/custom.ts b/src/custom/custom.ts
index 3dfc8ae8f..f1d2cfcfb 100644
--- a/src/custom/custom.ts
+++ b/src/custom/custom.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/custom/index.ts b/src/custom/index.ts
index 5c5b0bf66..b96208819 100644
--- a/src/custom/index.ts
+++ b/src/custom/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 464d477d0..e90ddfbf3 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/errors/index.ts b/src/errors/index.ts
index eae491eeb..71cdce9af 100644
--- a/src/errors/index.ts
+++ b/src/errors/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/format/format.ts b/src/format/format.ts
index c185ab00b..9bf384637 100644
--- a/src/format/format.ts
+++ b/src/format/format.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/format/index.ts b/src/format/index.ts
index f3153aa36..58e298c28 100644
--- a/src/format/index.ts
+++ b/src/format/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/guard/guard.ts b/src/guard/guard.ts
index 437dc4acd..87d4bc1a8 100644
--- a/src/guard/guard.ts
+++ b/src/guard/guard.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/guard/index.ts b/src/guard/index.ts
index d39efe4ec..980961dae 100644
--- a/src/guard/index.ts
+++ b/src/guard/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/hash/hash.ts b/src/hash/hash.ts
index 3d0ac21b6..dbe5123a2 100644
--- a/src/hash/hash.ts
+++ b/src/hash/hash.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/hash/index.ts b/src/hash/index.ts
index d6597c698..c1f89ba06 100644
--- a/src/hash/index.ts
+++ b/src/hash/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/system/index.ts b/src/system/index.ts
index 9f65a6522..457186e0b 100644
--- a/src/system/index.ts
+++ b/src/system/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/system/system.ts b/src/system/system.ts
index 97c86e2ec..1a637f8aa 100644
--- a/src/system/system.ts
+++ b/src/system/system.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/typebox.ts b/src/typebox.ts
index ebacf611f..0949f9b31 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/cast.ts b/src/value/cast.ts
index 2535addff..5c205b538 100644
--- a/src/value/cast.ts
+++ b/src/value/cast.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/check.ts b/src/value/check.ts
index 4d4a50558..538db1ccb 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/clone.ts b/src/value/clone.ts
index d2bb93cdb..82bf94b04 100644
--- a/src/value/clone.ts
+++ b/src/value/clone.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/create.ts b/src/value/create.ts
index 19469ced5..7766960b6 100644
--- a/src/value/create.ts
+++ b/src/value/create.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/delta.ts b/src/value/delta.ts
index 00cd71902..427a1d675 100644
--- a/src/value/delta.ts
+++ b/src/value/delta.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/equal.ts b/src/value/equal.ts
index 2e85871ab..841cba47a 100644
--- a/src/value/equal.ts
+++ b/src/value/equal.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/index.ts b/src/value/index.ts
index b962dac8c..5e48c738f 100644
--- a/src/value/index.ts
+++ b/src/value/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/is.ts b/src/value/is.ts
index 3d29fc898..c808f9db6 100644
--- a/src/value/is.ts
+++ b/src/value/is.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/pointer.ts b/src/value/pointer.ts
index fa828480c..1e7718e89 100644
--- a/src/value/pointer.ts
+++ b/src/value/pointer.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/value.ts b/src/value/value.ts
index aba57e044..373005b7a 100644
--- a/src/value/value.ts
+++ b/src/value/value.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

From 14b4d4a50bccddeca560f5dd73e32e84c5f6e3d9 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 15 Feb 2023 15:56:00 +0900
Subject: [PATCH 062/369] Support UTF-16 Identifiers (#323)

---
 changelog.md                     |   6 ++
 package.json                     |   2 +-
 readme.md                        | 102 +++++++++++++++----------------
 src/compiler/compiler.ts         |  54 +++++++++++-----
 test/runtime/compiler/index.ts   |   1 +
 test/runtime/compiler/unicode.ts |  84 +++++++++++++++++++++++++
 6 files changed, 183 insertions(+), 66 deletions(-)
 create mode 100644 test/runtime/compiler/unicode.ts

diff --git a/changelog.md b/changelog.md
index 57c8a06bf..5034c30f7 100644
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,9 @@
+## [0.25.22](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.22)
+
+Updates:
+
+- [323](https://github.com/sinclairzx81/typebox/pull/323) adds compiler support for UTF-16 (unicode) characters for schema identifiers.  
+
 ## [0.25.18](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.18)
 
 Updates:
diff --git a/package.json b/package.json
index 20872e73a..9f54111ca 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.21",
+  "version": "0.25.22",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 3a576e9f7..4276f179c 100644
--- a/readme.md
+++ b/readme.md
@@ -1233,29 +1233,29 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    437 ms' │ '     15 ms' │ '   29.13 x' │
-│           String │    2000    │ '    332 ms' │ '     13 ms' │ '   25.54 x' │
-│          Boolean │    2000    │ '    293 ms' │ '     12 ms' │ '   24.42 x' │
-│             Null │    2000    │ '    259 ms' │ '      9 ms' │ '   28.78 x' │
-│            RegEx │    2000    │ '    505 ms' │ '     21 ms' │ '   24.05 x' │
-│          ObjectA │    2000    │ '   2726 ms' │ '     53 ms' │ '   51.43 x' │
-│          ObjectB │    2000    │ '   2835 ms' │ '     37 ms' │ '   76.62 x' │
-│            Tuple │    2000    │ '   1239 ms' │ '     24 ms' │ '   51.63 x' │
-│            Union │    2000    │ '   1244 ms' │ '     34 ms' │ '   36.59 x' │
-│          Vector4 │    2000    │ '   1521 ms' │ '     21 ms' │ '   72.43 x' │
-│          Matrix4 │    2000    │ '    836 ms' │ '     10 ms' │ '   83.60 x' │
-│   Literal_String │    2000    │ '    333 ms' │ '      9 ms' │ '   37.00 x' │
-│   Literal_Number │    2000    │ '    357 ms' │ '      9 ms' │ '   39.67 x' │
-│  Literal_Boolean │    2000    │ '    352 ms' │ '      6 ms' │ '   58.67 x' │
-│     Array_Number │    2000    │ '    685 ms' │ '     12 ms' │ '   57.08 x' │
-│     Array_String │    2000    │ '    720 ms' │ '     12 ms' │ '   60.00 x' │
-│    Array_Boolean │    2000    │ '    709 ms' │ '      8 ms' │ '   88.63 x' │
-│    Array_ObjectA │    2000    │ '   3590 ms' │ '     40 ms' │ '   89.75 x' │
-│    Array_ObjectB │    2000    │ '   3610 ms' │ '     51 ms' │ '   70.78 x' │
-│      Array_Tuple │    2000    │ '   2124 ms' │ '     19 ms' │ '  111.79 x' │
-│      Array_Union │    2000    │ '   1533 ms' │ '     21 ms' │ '   73.00 x' │
-│    Array_Vector4 │    2000    │ '   2278 ms' │ '     19 ms' │ '  119.89 x' │
-│    Array_Matrix4 │    2000    │ '   1504 ms' │ '     20 ms' │ '   75.20 x' │
+│           Number │    2000    │ '    418 ms' │ '     14 ms' │ '   29.86 x' │
+│           String │    2000    │ '    331 ms' │ '     12 ms' │ '   27.58 x' │
+│          Boolean │    2000    │ '    290 ms' │ '     13 ms' │ '   22.31 x' │
+│             Null │    2000    │ '    253 ms' │ '      8 ms' │ '   31.63 x' │
+│            RegEx │    2000    │ '    481 ms' │ '     18 ms' │ '   26.72 x' │
+│          ObjectA │    2000    │ '   2675 ms' │ '     54 ms' │ '   49.54 x' │
+│          ObjectB │    2000    │ '   2849 ms' │ '     39 ms' │ '   73.05 x' │
+│            Tuple │    2000    │ '   1224 ms' │ '     22 ms' │ '   55.64 x' │
+│            Union │    2000    │ '   1225 ms' │ '     26 ms' │ '   47.12 x' │
+│          Vector4 │    2000    │ '   1777 ms' │ '     24 ms' │ '   74.04 x' │
+│          Matrix4 │    2000    │ '    825 ms' │ '     12 ms' │ '   68.75 x' │
+│   Literal_String │    2000    │ '    345 ms' │ '      9 ms' │ '   38.33 x' │
+│   Literal_Number │    2000    │ '    363 ms' │ '      7 ms' │ '   51.86 x' │
+│  Literal_Boolean │    2000    │ '    358 ms' │ '      6 ms' │ '   59.67 x' │
+│     Array_Number │    2000    │ '    687 ms' │ '      8 ms' │ '   85.88 x' │
+│     Array_String │    2000    │ '    726 ms' │ '      8 ms' │ '   90.75 x' │
+│    Array_Boolean │    2000    │ '    703 ms' │ '      8 ms' │ '   87.88 x' │
+│    Array_ObjectA │    2000    │ '   3686 ms' │ '     40 ms' │ '   92.15 x' │
+│    Array_ObjectB │    2000    │ '   3821 ms' │ '     40 ms' │ '   95.53 x' │
+│      Array_Tuple │    2000    │ '   2070 ms' │ '     17 ms' │ '  121.76 x' │
+│      Array_Union │    2000    │ '   1503 ms' │ '     21 ms' │ '   71.57 x' │
+│    Array_Vector4 │    2000    │ '   2185 ms' │ '     21 ms' │ '  104.05 x' │
+│    Array_Matrix4 │    2000    │ '   1502 ms' │ '     16 ms' │ '   93.88 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1269,31 +1269,31 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  1000000   │ '     29 ms' │ '      6 ms' │ '      6 ms' │ '    1.00 x' │
-│           String │  1000000   │ '     24 ms' │ '     19 ms' │ '     11 ms' │ '    1.73 x' │
-│          Boolean │  1000000   │ '     22 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
-│             Null │  1000000   │ '     27 ms' │ '     23 ms' │ '     11 ms' │ '    2.09 x' │
-│            RegEx │  1000000   │ '    160 ms' │ '     52 ms' │ '     40 ms' │ '    1.30 x' │
-│          ObjectA │  1000000   │ '    577 ms' │ '     37 ms' │ '     26 ms' │ '    1.42 x' │
-│          ObjectB │  1000000   │ '    990 ms' │ '     50 ms' │ '     37 ms' │ '    1.35 x' │
-│            Tuple │  1000000   │ '    124 ms' │ '     22 ms' │ '     17 ms' │ '    1.29 x' │
-│            Union │  1000000   │ '    318 ms' │ '     24 ms' │ '     16 ms' │ '    1.50 x' │
-│        Recursive │  1000000   │ '   3102 ms' │ '    408 ms' │ '    102 ms' │ '    4.00 x' │
-│          Vector4 │  1000000   │ '    150 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
-│          Matrix4 │  1000000   │ '    579 ms' │ '     43 ms' │ '     27 ms' │ '    1.59 x' │
-│   Literal_String │  1000000   │ '     50 ms' │ '     22 ms' │ '     10 ms' │ '    2.20 x' │
-│   Literal_Number │  1000000   │ '     47 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
-│  Literal_Boolean │  1000000   │ '     48 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
-│     Array_Number │  1000000   │ '    429 ms' │ '     32 ms' │ '     20 ms' │ '    1.60 x' │
-│     Array_String │  1000000   │ '    474 ms' │ '     33 ms' │ '     25 ms' │ '    1.32 x' │
-│    Array_Boolean │  1000000   │ '    447 ms' │ '     35 ms' │ '     31 ms' │ '    1.13 x' │
-│    Array_ObjectA │  1000000   │ '  14098 ms' │ '   2352 ms' │ '   2015 ms' │ '    1.17 x' │
-│    Array_ObjectB │  1000000   │ '  16216 ms' │ '   2628 ms' │ '   2511 ms' │ '    1.05 x' │
-│      Array_Tuple │  1000000   │ '   1749 ms' │ '     95 ms' │ '     75 ms' │ '    1.27 x' │
-│      Array_Union │  1000000   │ '   4712 ms' │ '    233 ms' │ '     84 ms' │ '    2.77 x' │
-│  Array_Recursive │  1000000   │ '  56118 ms' │ '   7192 ms' │ '   1180 ms' │ '    6.09 x' │
-│    Array_Vector4 │  1000000   │ '   2284 ms' │ '     99 ms' │ '     50 ms' │ '    1.98 x' │
-│    Array_Matrix4 │  1000000   │ '  12640 ms' │ '    412 ms' │ '    272 ms' │ '    1.51 x' │
+│           Number │  1000000   │ '     28 ms' │ '      6 ms' │ '      6 ms' │ '    1.00 x' │
+│           String │  1000000   │ '     25 ms' │ '     23 ms' │ '     11 ms' │ '    2.09 x' │
+│          Boolean │  1000000   │ '     24 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
+│             Null │  1000000   │ '     25 ms' │ '     22 ms' │ '     10 ms' │ '    2.20 x' │
+│            RegEx │  1000000   │ '    164 ms' │ '     53 ms' │ '     37 ms' │ '    1.43 x' │
+│          ObjectA │  1000000   │ '    593 ms' │ '     47 ms' │ '     25 ms' │ '    1.88 x' │
+│          ObjectB │  1000000   │ '   1053 ms' │ '     54 ms' │ '     40 ms' │ '    1.35 x' │
+│            Tuple │  1000000   │ '    129 ms' │ '     25 ms' │ '     16 ms' │ '    1.56 x' │
+│            Union │  1000000   │ '    334 ms' │ '     25 ms' │ '     16 ms' │ '    1.56 x' │
+│        Recursive │  1000000   │ '   3127 ms' │ '    424 ms' │ '     98 ms' │ '    4.33 x' │
+│          Vector4 │  1000000   │ '    152 ms' │ '     24 ms' │ '     12 ms' │ '    2.00 x' │
+│          Matrix4 │  1000000   │ '    593 ms' │ '     41 ms' │ '     27 ms' │ '    1.52 x' │
+│   Literal_String │  1000000   │ '     48 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
+│   Literal_Number │  1000000   │ '     47 ms' │ '     22 ms' │ '     10 ms' │ '    2.20 x' │
+│  Literal_Boolean │  1000000   │ '     48 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
+│     Array_Number │  1000000   │ '    495 ms' │ '     32 ms' │ '     21 ms' │ '    1.52 x' │
+│     Array_String │  1000000   │ '    481 ms' │ '     31 ms' │ '     21 ms' │ '    1.48 x' │
+│    Array_Boolean │  1000000   │ '    446 ms' │ '     32 ms' │ '     27 ms' │ '    1.19 x' │
+│    Array_ObjectA │  1000000   │ '  14314 ms' │ '   2341 ms' │ '   1969 ms' │ '    1.19 x' │
+│    Array_ObjectB │  1000000   │ '  16883 ms' │ '   2661 ms' │ '   2606 ms' │ '    1.02 x' │
+│      Array_Tuple │  1000000   │ '   1834 ms' │ '     98 ms' │ '     77 ms' │ '    1.27 x' │
+│      Array_Union │  1000000   │ '   4960 ms' │ '    240 ms' │ '     87 ms' │ '    2.76 x' │
+│  Array_Recursive │  1000000   │ '  56273 ms' │ '   7118 ms' │ '   1122 ms' │ '    6.34 x' │
+│    Array_Vector4 │  1000000   │ '   2498 ms' │ '     99 ms' │ '     48 ms' │ '    2.06 x' │
+│    Array_Matrix4 │  1000000   │ '  12487 ms' │ '    383 ms' │ '    246 ms' │ '    1.56 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1307,13 +1307,13 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '   61 kb' │ '   30 kb' │  '2.03 x'   │
+│ typebox/compiler     │ '   64 kb' │ '   31 kb' │  '2.02 x'   │
 │ typebox/conditional  │ '   45 kb' │ '   18 kb' │  '2.44 x'   │
 │ typebox/custom       │ '    0 kb' │ '    0 kb' │  '2.61 x'   │
 │ typebox/format       │ '    0 kb' │ '    0 kb' │  '2.66 x'   │
 │ typebox/guard        │ '   23 kb' │ '   11 kb' │  '2.07 x'   │
-│ typebox/hash         │ '    4 kb' │ '    1 kb' │  '2.27 x'   │
-│ typebox/value        │ '   85 kb' │ '   39 kb' │  '2.16 x'   │
+│ typebox/hash         │ '    4 kb' │ '    1 kb' │  '2.30 x'   │
+│ typebox/value        │ '   89 kb' │ '   41 kb' │  '2.15 x'   │
 │ typebox              │ '   12 kb' │ '    6 kb' │  '1.89 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index f3150170c..032e7a0bb 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -62,41 +62,65 @@ export class TypeCheck<T extends Types.TSchema> {
     return this.checkFunc(value)
   }
 }
-
 // -------------------------------------------------------------------
-// Property
+// Character
 // -------------------------------------------------------------------
-
-export namespace Property {
-  function DollarSign(code: number) {
+namespace Character {
+  export function DollarSign(code: number) {
     return code === 36
   }
-  function Underscore(code: number) {
+  export function Underscore(code: number) {
     return code === 95
   }
-  function Numeric(code: number) {
+  export function Numeric(code: number) {
     return code >= 48 && code <= 57
   }
-  function Alpha(code: number) {
+  export function Alpha(code: number) {
     return (code >= 65 && code <= 90) || (code >= 97 && code <= 122)
   }
+}
 
-  export function Check(propertyName: string) {
+// -------------------------------------------------------------------
+// Identifier
+// -------------------------------------------------------------------
+namespace Identifier {
+  export function Encode($id: string) {
+    const buffer: string[] = []
+    for (let i = 0; i < $id.length; i++) {
+      const code = $id.charCodeAt(i)
+      if (Character.Numeric(code) || Character.Alpha(code)) {
+        buffer.push($id.charAt(i))
+      } else {
+        buffer.push(`_${code}_`)
+      }
+    }
+    return buffer.join('').replace(/__/g, '_')
+  }
+}
+
+// -------------------------------------------------------------------
+// MemberExpression
+// -------------------------------------------------------------------
+export namespace MemberExpression {
+  function Check(propertyName: string) {
     if (propertyName.length === 0) return false
     {
       const code = propertyName.charCodeAt(0)
-      if (!(DollarSign(code) || Underscore(code) || Alpha(code))) {
+      if (!(Character.DollarSign(code) || Character.Underscore(code) || Character.Alpha(code))) {
         return false
       }
     }
     for (let i = 1; i < propertyName.length; i++) {
       const code = propertyName.charCodeAt(i)
-      if (!(DollarSign(code) || Underscore(code) || Alpha(code) || Numeric(code))) {
+      if (!(Character.DollarSign(code) || Character.Underscore(code) || Character.Alpha(code) || Character.Numeric(code))) {
         return false
       }
     }
     return true
   }
+  export function Encode(object: string, key: string) {
+    return !Check(key) ? `${object}['${key}']` : `${object}.${key}`
+  }
 }
 
 // -------------------------------------------------------------------
@@ -111,6 +135,9 @@ export class TypeCompilerUnknownTypeError extends Error {
 
 /** Compiles Types for Runtime Type Checking */
 export namespace TypeCompiler {
+  // -------------------------------------------------------------------
+  // Guards
+  // -------------------------------------------------------------------
   function IsNumber(value: unknown): value is number {
     return typeof value === 'number' && !globalThis.isNaN(value)
   }
@@ -118,7 +145,6 @@ export namespace TypeCompiler {
   // -------------------------------------------------------------------
   // Types
   // -------------------------------------------------------------------
-
   function* Any(schema: Types.TAny, value: string): IterableIterator<string> {
     yield '(true)'
   }
@@ -216,7 +242,7 @@ export namespace TypeCompiler {
       yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`
     }
     for (const propertyKey of propertyKeys) {
-      const memberExpression = Property.Check(propertyKey) ? `${value}.${propertyKey}` : `${value}['${propertyKey}']`
+      const memberExpression = MemberExpression.Encode(value, propertyKey)
       const propertySchema = schema.properties[propertyKey]
       if (schema.required && schema.required.includes(propertyKey)) {
         yield* Visit(propertySchema, memberExpression)
@@ -406,7 +432,7 @@ export namespace TypeCompiler {
   }
 
   function CreateFunctionName($id: string) {
-    return `check_${$id.replace(/-/g, '_')}`
+    return `check_${Identifier.Encode($id)}`
   }
 
   function CreateFunction(name: string, schema: Types.TSchema, value: string): string {
diff --git a/test/runtime/compiler/index.ts b/test/runtime/compiler/index.ts
index d06324993..a842d535a 100644
--- a/test/runtime/compiler/index.ts
+++ b/test/runtime/compiler/index.ts
@@ -3,6 +3,7 @@ import './array'
 import './boolean'
 import './custom'
 import './date'
+import './unicode'
 import './enum'
 import './integer'
 import './intersect'
diff --git a/test/runtime/compiler/unicode.ts b/test/runtime/compiler/unicode.ts
new file mode 100644
index 000000000..2e65bd6cf
--- /dev/null
+++ b/test/runtime/compiler/unicode.ts
@@ -0,0 +1,84 @@
+import { Type } from '@sinclair/typebox'
+import { Ok } from './validate'
+
+describe('type/compiler/Unicode', () => {
+  // ---------------------------------------------------------
+  // Identifiers
+  // ---------------------------------------------------------
+  it('Should support unicode identifiers', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        $id: '식별자',
+      },
+    )
+    Ok(T, {
+      x: 1,
+      y: 2,
+    })
+  })
+  it('Should support unicode identifier references', () => {
+    const R = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        $id: '식별자',
+      },
+    )
+    const T = Type.Object({
+      vector: Type.Ref(R),
+    })
+    Ok(
+      T,
+      {
+        vector: {
+          x: 1,
+          y: 2,
+        },
+      },
+      [R],
+    )
+  })
+  it('Should support unicode identifier recursion', () => {
+    const Node = Type.Recursive(
+      (Node) =>
+        Type.Object({
+          id: Type.String(),
+          nodes: Type.Array(Node),
+        }),
+      {
+        $id: '식별자',
+      },
+    )
+    Ok(Node, {
+      id: 'A',
+      nodes: [
+        {
+          id: 'B',
+          nodes: [
+            {
+              id: 'C',
+              nodes: [],
+            },
+          ],
+        },
+      ],
+    })
+  })
+  // ---------------------------------------------------------
+  // Properties
+  // ---------------------------------------------------------
+  it('Should support unicode properties', () => {
+    const T = Type.Object({
+      이름: Type.String(),
+    })
+    Ok(T, {
+      이름: 'dave',
+    })
+  })
+})

From 13682f66c348531bba9e98ddb312ac952676b659 Mon Sep 17 00:00:00 2001
From: Steve Zhu <4130171+stevezhu@users.noreply.github.com>
Date: Thu, 16 Feb 2023 05:15:35 -0500
Subject: [PATCH 063/369] Support JSDoc IntelliSense on Object Properties
 (#324)

---
 src/typebox.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/typebox.ts b/src/typebox.ts
index 0949f9b31..a425d3696 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -316,10 +316,10 @@ export type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, Readonly
 
 // prettier-ignore
 export type PropertiesReduce<T extends TProperties, P extends unknown[]> = 
-  { readonly [K in ReadonlyOptionalPropertyKeys<T>]?: Static<T[K], P> } & 
-  { readonly [K in ReadonlyPropertyKeys<T>]:          Static<T[K], P> } & 
-  {          [K in OptionalPropertyKeys<T>]?:         Static<T[K], P> } & 
-  {          [K in RequiredPropertyKeys<T>]:          Static<T[K], P> } extends infer R ? { [K in keyof R]: R[K] } : never
+  Readonly<Partial<Pick<{ [K in keyof T]: Static<T[K], P> }, ReadonlyOptionalPropertyKeys<T>>>> &
+  Readonly<Pick<{ [K in keyof T]: Static<T[K], P> }, ReadonlyPropertyKeys<T>>> &
+  Partial<Pick<{ [K in keyof T]: Static<T[K], P> }, OptionalPropertyKeys<T>>> &
+  Required<Pick<{ [K in keyof T]: Static<T[K], P> }, RequiredPropertyKeys<T>>> extends infer R ? { [K in keyof R]: R[K] } : never
 
 export type TRecordProperties<K extends TUnion<TLiteral[]>, T extends TSchema> = Static<K> extends string ? { [X in Static<K>]: T } : never
 

From 5515fb681f279322f8f628b411634f2566c5fac5 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 16 Feb 2023 19:42:14 +0900
Subject: [PATCH 064/369] Property Inference Optimization (#325)

---
 changelog.md     | 12 ++++++++++++
 example/index.ts |  1 +
 package.json     |  2 +-
 src/typebox.ts   | 16 +++++++++++-----
 4 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/changelog.md b/changelog.md
index 5034c30f7..6a6e9ac45 100644
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,15 @@
+## [0.25.23](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.23)
+
+Updates:
+
+- [324](https://github.com/sinclairzx81/typebox/pull/324) TypeScript Language Service now presents JSDoc comments when inferring static object properties. (IntelliSense)
+- [325](https://github.com/sinclairzx81/typebox/pull/325) Additional property inference optimizations.
+
+Additional:
+
+- Huge thank you to Github user [stevezhu](https://github.com/stevezhu) for these excellent contributions.
+
+
 ## [0.25.22](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.22)
 
 Updates:
diff --git a/example/index.ts b/example/index.ts
index 588558a9d..75d4d616a 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -9,6 +9,7 @@ import { Value, ValuePointer } from '@sinclair/typebox/value'
 import { Type, Kind, Static, TSchema } from '@sinclair/typebox'
 
 const T = Type.Object({
+  /** It's a X */
   x: Type.Number(),
   y: Type.Number(),
   z: Type.Number(),
diff --git a/package.json b/package.json
index 9f54111ca..b9a59fe67 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.22",
+  "version": "0.25.23",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index a425d3696..e5fb7ff5d 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -315,11 +315,17 @@ export type OptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K]
 export type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>
 
 // prettier-ignore
-export type PropertiesReduce<T extends TProperties, P extends unknown[]> = 
-  Readonly<Partial<Pick<{ [K in keyof T]: Static<T[K], P> }, ReadonlyOptionalPropertyKeys<T>>>> &
-  Readonly<Pick<{ [K in keyof T]: Static<T[K], P> }, ReadonlyPropertyKeys<T>>> &
-  Partial<Pick<{ [K in keyof T]: Static<T[K], P> }, OptionalPropertyKeys<T>>> &
-  Required<Pick<{ [K in keyof T]: Static<T[K], P> }, RequiredPropertyKeys<T>>> extends infer R ? { [K in keyof R]: R[K] } : never
+export type PropertiesReducer<T extends TProperties, R extends Record<keyof any, unknown>> = (
+  Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> &
+  Readonly<Pick<R, ReadonlyPropertyKeys<T>>> &
+  Partial<Pick<R, OptionalPropertyKeys<T>>> &
+  Required<Pick<R, RequiredPropertyKeys<T>>>
+) extends infer O ? { [K in keyof O]: O[K] } : never
+
+// prettier-ignore
+export type PropertiesReduce<T extends TProperties, P extends unknown[]> = PropertiesReducer<T, { 
+  [K in keyof T]: Static<T[K], P> 
+}>
 
 export type TRecordProperties<K extends TUnion<TLiteral[]>, T extends TSchema> = Static<K> extends string ? { [X in Static<K>]: T } : never
 

From ac0a3e296315c25952aded837d4241f316e62eb8 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Thu, 16 Feb 2023 19:52:28 +0900
Subject: [PATCH 065/369] Update Example

---
 example/index.ts | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/example/index.ts b/example/index.ts
index 75d4d616a..ed8d1cdc2 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -8,8 +8,11 @@ import { Custom } from '@sinclair/typebox/custom'
 import { Value, ValuePointer } from '@sinclair/typebox/value'
 import { Type, Kind, Static, TSchema } from '@sinclair/typebox'
 
+// -----------------------------------------------------------
+// Create: Type
+// -----------------------------------------------------------
+
 const T = Type.Object({
-  /** It's a X */
   x: Type.Number(),
   y: Type.Number(),
   z: Type.Number(),
@@ -18,3 +21,25 @@ const T = Type.Object({
 type T = Static<typeof T>
 
 console.log(T)
+
+// -----------------------------------------------------------
+// Create: Value
+// -----------------------------------------------------------
+
+const V = Value.Create(T)
+
+console.log(V)
+
+// -----------------------------------------------------------
+// Compile: Type
+// -----------------------------------------------------------
+
+const C = TypeCompiler.Compile(T)
+
+console.log(C.Code())
+
+// -----------------------------------------------------------
+// Check: Value
+// -----------------------------------------------------------
+
+console.log(C.Check(V))

From fb5fabfa95a9f40e06ff47be1b98f4ee0a333769 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Fri, 17 Feb 2023 00:10:11 +0900
Subject: [PATCH 066/369] ReadonlyObject Extension

---
 example/extensions/index.ts           |  1 +
 example/extensions/readonly-object.ts | 56 +++++++++++++++++++++++++++
 2 files changed, 57 insertions(+)
 create mode 100644 example/extensions/readonly-object.ts

diff --git a/example/extensions/index.ts b/example/extensions/index.ts
index 31d34239e..c8ec2834b 100644
--- a/example/extensions/index.ts
+++ b/example/extensions/index.ts
@@ -27,5 +27,6 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 export * from './intersect-allof'
+export * from './readonly-object'
 export * from './union-oneof'
 export * from './union-enum'
diff --git a/example/extensions/readonly-object.ts b/example/extensions/readonly-object.ts
new file mode 100644
index 000000000..cf92fd2cc
--- /dev/null
+++ b/example/extensions/readonly-object.ts
@@ -0,0 +1,56 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/extensions
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Type, TSchema, TObject, TProperties, Modifier, TReadonly, TReadonlyOptional, TOptional } from '@sinclair/typebox'
+
+// prettier-ignore
+export type TReadonlyObject<T extends TObject> = TObject<{
+  [K in keyof T['properties']]: 
+    T['properties'][K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : 
+    T['properties'][K] extends TReadonly<infer U>         ? TReadonly<U> : 
+    T['properties'][K] extends TOptional<infer U>         ? TReadonlyOptional<U> : 
+    TReadonly<T['properties'][K]>
+}>
+
+/** Remaps all properties of an object to be readonly */
+export function ReadonlyObject<T extends TObject>(schema: T): TReadonlyObject<T> {
+  return Type.Object(
+    Object.keys(schema.properties).reduce((acc, key) => {
+      const property = schema.properties[key] as TSchema
+      const modifier = property[Modifier]
+      // prettier-ignore
+      const mapped = (
+        (modifier === 'ReadonlyOptional') ? { ...property, [Modifier]: 'ReadonlyOptional' } :
+        (modifier === 'Readonly')         ? { ...property, [Modifier]: 'Readonly' } :
+        (modifier === 'Optional')         ? { ...property, [Modifier]: 'ReadonlyOptional' } :
+        ({...property, [Modifier]: 'Readonly' })
+      )
+      return { ...acc, [key]: mapped }
+    }, {} as TProperties),
+  ) as TReadonlyObject<T>
+}

From 1159041ec068d7e7d4cf5543c528f28ec00f689e Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 18 Feb 2023 01:54:57 +0900
Subject: [PATCH 067/369] TRPC Documentation (#326)

---
 example/trpc/readme.md | 97 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 97 insertions(+)
 create mode 100644 example/trpc/readme.md

diff --git a/example/trpc/readme.md b/example/trpc/readme.md
new file mode 100644
index 000000000..c63f4f0b9
--- /dev/null
+++ b/example/trpc/readme.md
@@ -0,0 +1,97 @@
+# TypeBox TRPC Integration
+
+To use TypeBox with TRPC, you will need to wrap types passed to procedures within a TRPC compatible assert function. Once wrapped, TypeBox can offer typical auto type inference for procedures, enhanced runtime checking performance and enable publishable procedure schematics based on the JSON Schema specification.
+
+## Contents
+
+- [Example](#Example)
+- [TypeCompiler](#TypeComplier)
+- [Value](#Value)
+- [Ajv](#Ajv)
+
+## Example
+
+The following example shows a minimal TypeBox TRPC setup with the `IoType` wrapper function described in the sections below.
+
+```typescript
+import { Type } from '@sinclair/typebox'
+import { initTRPC } from '@trpc/server'
+import { IoType } from './io-type'
+
+const addInput = IoType(Type.Object({
+  a: Type.Number(),
+  b: Type.Number()
+}))
+
+const addOutput = IoType(Type.Number())
+
+const t = initTRPC.create()
+
+export const appRouter = t.router({
+  add: t.procedure
+    .input(addInput)
+    .output(addOutput)
+    .query(({ input }) => input.a + input.b) // type-safe
+})
+```
+
+<a name="TypeCompiler"></a>
+
+## With [TypeCompiler](https://www.typescriptlang.org/dev/bug-workbench/?target=99&lib=true&ts=4.7.4#code/PTAEAEDMEsBsFMB2BDAtvAXKaB7AtAC4CeADvAHQEDOAUNKiTgE4GgDeoAKgMoDGAFvFTJQAX1CQmOVKADk4KtES9YyaE2DEyAIxwAPWXQbNWHTqXgBhaSTjwmYiVJnzFy1es0Xde4Lxt2TIb0jCzsXABKAAqWAKJMUg7iktJy4ARMJLzAVPYAbvaGNPB6oaz+iFSsAJI45mSgALygADycoCUESAAmVFx8gsIAfAAUVAJCyFicADSgTPCQ9ki88FTTA5MA2gC6TaC7AJRNQ+w0oKAVVZeCvADW+-VWAQhM5NYMdmMTwnMLSwtlGtDud5vACABXJiIUAjPLIWAQzCgCGIO6IHAAd0Qx0apwm93etzucIRSOOAH5QPDEfBQFgRiNcac2KCLldTKASMgCPw5ugqFRkABzOniZpbchSgl3cjxRJUUm0w47LYABh2bNAvKkmNAiHges40TiCWYIw4AqFoqwAAMACRsK0i+DJZigR3c3miW1zfzdZGyABCAEEACIAfQisQAigBVWLcTiyMQgi6iQ5MmiiGg0EAQGAIFDoLBSCFdN7UIxlcJKaAEY0xRwpFzpTLZXJMApBasmcJPZvONJuFRqDRaeA+YLGMIcWoD5JD2TkYC4QgWIoc0DIbrdaqIEjl-bziwjJ7kADy2gAVvBeAQLaCplwLOQAHIQ1DaexMmag7TTK+H5fj+IIZiCNBbju3QXuWh6sM0J5kGeQGft+TBMhBW4IdgiD1o2ljkLwCw8vAWbFKUfZQSQJARDg5b2PsBDkGWFaPhc0FYMxJBSKs3RQvAWrkEo8EjNB+7wWmFygOQ9EEKJ0GwfJ5ZSRc5AAI5IkwRCMhwIlHhmJy4fB5AiAA1MZ5bkNoxz5hOeBCks2aHEAA)
+
+The following uses the TypeCompiler to perform JIT optimized type checking for TRPC.
+
+```typescript
+import { TSchema } from '@sinclair/typebox'
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { TRPCError } from '@trpc/server'
+
+export const IoType = <T extends TSchema>(schema: T, references: TSchema[] = []) => {
+  const check = TypeCompiler.Compile(schema, references)
+  return (value: unknown) => check.Check(value) ? value : (() => {
+    const { path, message } = [...check.Errors(value)][0]
+    throw new TRPCError({ message: `${message} for ${path}`, code: 'BAD_REQUEST' })
+  })()
+}
+```
+
+<a name="Value"></a>
+
+## With [Value](https://www.typescriptlang.org/dev/bug-workbench/?target=99&lib=true&ts=4.7.4#code/PTAEAEDMEsBsFMB2BDAtvAXKaB7AtAC4CeADvAHQEDOAUNKiTgE4GgDeoAasrAK7ygAvqEhMcqUAHJwVaIgDGsZNCbBiZAEY4AHsABuPfpLoNmrDgBUAyvIAW8VMiEixE6bIVKVa0vC3bjekYWdlALACUABQBhAFEmMSZnUXEpcAImEnlgKngmPTzjGnhtYNZ5HEQqVgBJHAtfUABeUAAeC1ASgiQAEyowm3tHAD4ACio7B2QsCwAaUCZ4SDykeXgqGcGpgG0AXWbQPYBKZuHQGlBQUYM+TFBeRABrRBwAd0QTprPuW-Jo+3kj3Gk0c8xu-BOAH5QOCBFhRqNPmc2BdLqAKlVzKASMgCLZ5ugqFRkABzATCFrbcjUn78cjxRJUYFDZDzRbLRYKdZgwzwI67bYABl2qMueLEr1AiHgkoiMQZzFGHEJxLJWAABgASNgq0nwYSQZigbU4vGCdXzCo9O6SABCAEEACIAfXCsQAigBVWJWCySIRHVGCI6Img0EAQGAIFDoLBiXjdJiUWhBMyhOTQAhy6LJVxpDJZHJ5ApMQKmEKWRoGvPuOSKZSqdR+HRlsqhOoNMi51KScjAXCEXxFDHVUDIHo9GqIEgJg4d3yjTsUADyGgAVvB5AQlajpmFfOQAHK8VAaPKI2aojQzA-H0-nwPBwM0Eescc9ZcJmesFrzsiL28TzPJhEWfV9QB-bBEEzbNyHkRZcXgUNilKNNwOQEgSHCHAEzyA4CHIeNEx3S53ywAiSDENYel4RZRVAcg5G-UZ3ynb9AzRBicIIZj30-HiEw4tFyAAR34JgiARDgmNnYNTig79yCcABqBSE3IDQTgjJs8GJZYaGDIA)
+
+The following performs dynamic type checking without code evaluation.
+
+```typescript
+import { Value } from '@sinclair/typebox/value'
+import { TSchema } from '@sinclair/typebox'
+import { TRPCError } from '@trpc/server'
+
+export const IoType = <T extends TSchema>(schema: T, references: TSchema[] = []) => 
+  (value: unknown) => Value.Check(schema, value) ? value : (() => {
+    const { path, message } = [...Value.Errors(schema, references, value)][0]
+    throw new TRPCError({ message: `${message} for ${path}`, code: 'BAD_REQUEST' })
+  })()
+```
+
+<a name="Ajv"></a>
+
+## With [Ajv](https://www.typescriptlang.org/dev/bug-workbench/?target=99&lib=true&ts=4.7.4#code/PTAEAEDMEsBsFMB2BDAtvAXKaB7AtAC4CeADvAHQEDOAUNKiTgE4GgDeoAKgMoDGAFvFTIANKG4FkBaL1ABfUJCY5UoAOTgq0RL1jJoTYMTIAjHAA81dBs1YdOAJQAKAYQCiTZU3mLlqjQRMJLzAVPBMAG7hVvSMLKAAggBWEb4q6sgpwAAm0FQEwABMAAwlVjTw5nGsvDiI+aAAkjicpPCgALygADycoJUESNlUXHyCwgB8ABRUAkLIWJxiTPCQ4Ui88FSLY-MA2gC6naCHAJSdE+w0oKC19ayZqV2I8ADuiSlTp9egK2srOi25EgzDcyAEUz+60BF1Aj3IyGy2V2wkhq2hm1O3xudwac14AGtjvDagw4PAZnNhNjfvACABXJiIUBTCLIWD0zCgemIAmIHCvRCnLASKQyXqXDqXfEE1nsznnAD8oDZHPaWCmX1hbB+OLqDQ46CoVGQAHN4GJtPlkICnFJ+D4ujLyOEvFQAIR7YoHXWgAj8ZTvF7vRyuDxeKaGrYm81YUAAAwAJGwjTH4AoQd5k1bJLb7XJ42JatkuWoAEIJAAiAH0HG4AIoAVTc3E4ankNLkpy+NDkNBoIAgMAQKHQWGU9MGTEotFitnY2EQ0AIoZcPiU6QCQRCYUi0Ws1QXrTI6786k02l0+kMxngZksB-nHGax-aGbPanIwFwhDa5VxDxIo0iAkJOxwvm0UyvuQADyJhJPAvAEJGPwLFwbTkAAcvSqAmOEXwiD8JiLBh2G4fh3xdt8NAAXCSIwZOoGsF0EFkFBpE4XhTBfNRtHMYuy6ruQvArFIFLUZUh60cgJAkA4OCTuExwEOQE5TihNyItkWAqSQyibNkjLwL65DaExUxacBTE0jc5AKQQ5laQxDmTjZoDkAAjpyTBEJqHBmWBXawgFKnIKAADUi5MeQJjnIOt54Caay9qcQA)
+
+
+The following uses Ajv to perform more generalized JSON Schema checks across the complete JSON Schema specification.
+
+```typescript
+import { TSchema, Static } from '@sinclair/typebox'
+import { TRPCError } from '@trpc/server'
+import Ajv from 'ajv/dist/2020'
+
+export const IoType = <T extends TSchema>(schema: T, references: TSchema[] = []) => {
+  const ajv = new Ajv()
+  references.forEach(reference => ajv.addSchema(reference))
+  const check = ajv.compile(schema)
+  return (value: unknown): Static<T> => check(value) ? value : (() => {
+    const { message, instancePath } = check.errors![0]
+    throw new TRPCError({ message:  `${message} for ${instancePath}`, code: 'BAD_REQUEST' })
+  })()
+}
+```
\ No newline at end of file

From 5a520a19427cd6a5e734076e1330a7a405bca1a7 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 19 Feb 2023 04:22:34 +0900
Subject: [PATCH 068/369] Documentation

---
 example/trpc/readme.md | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/example/trpc/readme.md b/example/trpc/readme.md
index c63f4f0b9..fe753c01c 100644
--- a/example/trpc/readme.md
+++ b/example/trpc/readme.md
@@ -1,14 +1,16 @@
-# TypeBox TRPC Integration
+# Using TypeBox with TRPC
 
 To use TypeBox with TRPC, you will need to wrap types passed to procedures within a TRPC compatible assert function. Once wrapped, TypeBox can offer typical auto type inference for procedures, enhanced runtime checking performance and enable publishable procedure schematics based on the JSON Schema specification.
 
 ## Contents
 
 - [Example](#Example)
-- [TypeCompiler](#TypeComplier)
+- [TypeCompiler](#TypeCompiler)
 - [Value](#Value)
 - [Ajv](#Ajv)
 
+<a name="Example"></a>
+
 ## Example
 
 The following example shows a minimal TypeBox TRPC setup with the `IoType` wrapper function described in the sections below.
@@ -94,4 +96,4 @@ export const IoType = <T extends TSchema>(schema: T, references: TSchema[] = [])
     throw new TRPCError({ message:  `${message} for ${instancePath}`, code: 'BAD_REQUEST' })
   })()
 }
-```
\ No newline at end of file
+```

From 078cfacd44336aa01528c3241658516d7f2ec46e Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 23 Feb 2023 20:34:10 +0900
Subject: [PATCH 069/369] Support Required Undefined Property Check (#331)

---
 benchmark/compression/index.ts                |   4 +-
 .../compression/module/typebox-system.ts      |   3 +
 changelog.md                                  |  11 +
 example/trpc/readme.md                        |  66 ++--
 example/typedef/index.ts                      |  29 ++
 example/typedef/readme.md                     | 100 ++++++
 example/typedef/typedef.ts                    |  88 +++++
 package.json                                  |   2 +-
 readme.md                                     | 306 +++++++-----------
 src/compiler/compiler.ts                      |   5 +-
 src/errors/errors.ts                          |   4 +
 src/guard/extends.ts                          |  46 +++
 src/guard/index.ts                            |   1 +
 src/value/cast.ts                             |   5 -
 src/value/check.ts                            |  12 +
 src/value/create.ts                           |  10 -
 test/runtime/compiler/object.ts               |  22 ++
 test/runtime/value/check/object.ts            |  22 ++
 18 files changed, 493 insertions(+), 243 deletions(-)
 create mode 100644 benchmark/compression/module/typebox-system.ts
 create mode 100644 example/typedef/index.ts
 create mode 100644 example/typedef/readme.md
 create mode 100644 example/typedef/typedef.ts
 create mode 100644 src/guard/extends.ts

diff --git a/benchmark/compression/index.ts b/benchmark/compression/index.ts
index 9454d15ce..fc49651ab 100644
--- a/benchmark/compression/index.ts
+++ b/benchmark/compression/index.ts
@@ -9,8 +9,8 @@ export async function measure(test: string) {
   const minified = statSync(`target/benchmark/compression/${test}.js`)
   return {
     test: test.padEnd(20),
-    compiled: `${Math.floor(compiled.size / 1000)} kb`.padStart(8),
-    minified: `${Math.floor(minified.size / 1000)} kb`.padStart(8),
+    compiled: `${(compiled.size / 1000).toFixed(1)} kb`.padStart(8),
+    minified: `${(minified.size / 1000).toFixed(1)} kb`.padStart(8),
     ratio: compiled.size / minified.size,
   }
 }
diff --git a/benchmark/compression/module/typebox-system.ts b/benchmark/compression/module/typebox-system.ts
new file mode 100644
index 000000000..929092b50
--- /dev/null
+++ b/benchmark/compression/module/typebox-system.ts
@@ -0,0 +1,3 @@
+import { TypeSystem } from '@sinclair/typebox/system'
+
+TypeSystem.AllowNaN = true
diff --git a/changelog.md b/changelog.md
index 6a6e9ac45..fa1f19caf 100644
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,14 @@
+## [0.25.24](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.23)
+
+Updates:
+
+- [331](https://github.com/sinclairzx81/typebox/pull/331) Implements an additional check specific to property types of `required & undefined`. This to ensure the property key exists when the property value extends `undefined`.
+- [331](https://github.com/sinclairzx81/typebox/pull/331) Documentation updates for Ajv and TypeCompiler
+
+Additional:
+
+- [331](https://github.com/sinclairzx81/typebox/pull/331) Remove unusued recursive code paths for create and cast.
+
 ## [0.25.23](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.23)
 
 Updates:
diff --git a/example/trpc/readme.md b/example/trpc/readme.md
index fe753c01c..f3b26ccbc 100644
--- a/example/trpc/readme.md
+++ b/example/trpc/readme.md
@@ -1,31 +1,34 @@
 # Using TypeBox with TRPC
 
-To use TypeBox with TRPC, you will need to wrap types passed to procedures within a TRPC compatible assert function. Once wrapped, TypeBox can offer typical auto type inference for procedures, enhanced runtime checking performance and enable publishable procedure schematics based on the JSON Schema specification.
+To use TypeBox with TRPC, you will need to wrap types passed to procedures within a TRPC compatible assertion function. Once wrapped, TypeBox can provide TRPC auto type inference for procedures, enhanced runtime checking performance and well as providing options for enabling publishable procedure schematics based on the JSON Schema specification.
 
 ## Contents
 
 - [Example](#Example)
-- [TypeCompiler](#TypeCompiler)
-- [Value](#Value)
-- [Ajv](#Ajv)
+- [RpcType](#RpcType)
+  - [TypeCompiler](#TypeCompiler)
+  - [Value](#Value)
+  - [Ajv](#Ajv)
 
 <a name="Example"></a>
 
 ## Example
 
-The following example shows a minimal TypeBox TRPC setup with the `IoType` wrapper function described in the sections below.
+The following shows a minimal TypeBox + TRPC setup with the `RpcType` wrapper function described in the sections below.
 
 ```typescript
 import { Type } from '@sinclair/typebox'
 import { initTRPC } from '@trpc/server'
-import { IoType } from './io-type'
+import { RpcType } from './rpctype'
 
-const addInput = IoType(Type.Object({
-  a: Type.Number(),
-  b: Type.Number()
-}))
+const addInput = RpcType(
+  Type.Object({
+    a: Type.Number(),
+    b: Type.Number(),
+  }),
+)
 
-const addOutput = IoType(Type.Number())
+const addOutput = RpcType(Type.Number())
 
 const t = initTRPC.create()
 
@@ -33,13 +36,19 @@ export const appRouter = t.router({
   add: t.procedure
     .input(addInput)
     .output(addOutput)
-    .query(({ input }) => input.a + input.b) // type-safe
+    .query(({ input }) => input.a + input.b), // type-safe
 })
 ```
 
+<a name="RpcType"></a>
+
+## RpcType
+
+Unlike Zod, Yup, Superstruct, TypeBox types are pure JSON Schema and do not implement built a in `parse` or `validate` function. Because of this, you will need to wrap the Type in a TRPC compatible function which implements `parse` or `validate` on behalf of TRPC. As JSON Schema is a formal specification, there are a number of ways you can choose to implement this function, the following shows recommended implementations.
+
 <a name="TypeCompiler"></a>
 
-## With [TypeCompiler](https://www.typescriptlang.org/dev/bug-workbench/?target=99&lib=true&ts=4.7.4#code/PTAEAEDMEsBsFMB2BDAtvAXKaB7AtAC4CeADvAHQEDOAUNKiTgE4GgDeoAKgMoDGAFvFTJQAX1CQmOVKADk4KtES9YyaE2DEyAIxwAPWXQbNWHTqXgBhaSTjwmYiVJnzFy1es0Xde4Lxt2TIb0jCzsXABKAAqWAKJMUg7iktJy4ARMJLzAVPYAbvaGNPB6oaz+iFSsAJI45mSgALygADycoCUESAAmVFx8gsIAfAAUVAJCyFicADSgTPCQ9ki88FTTA5MA2gC6TaC7AJRNQ+w0oKAVVZeCvADW+-VWAQhM5NYMdmMTwnMLSwtlGtDud5vACABXJiIUAjPLIWAQzCgCGIO6IHAAd0Qx0apwm93etzucIRSOOAH5QPDEfBQFgRiNcac2KCLldTKASMgCPw5ugqFRkABzOniZpbchSgl3cjxRJUUm0w47LYABh2bNAvKkmNAiHges40TiCWYIw4AqFoqwAAMACRsK0i+DJZigR3c3miW1zfzdZGyABCAEEACIAfQisQAigBVWLcTiyMQgi6iQ5MmiiGg0EAQGAIFDoLBSCFdN7UIxlcJKaAEY0xRwpFzpTLZXJMApBasmcJPZvONJuFRqDRaeA+YLGMIcWoD5JD2TkYC4QgWIoc0DIbrdaqIEjl-bziwjJ7kADy2gAVvBeAQLaCplwLOQAHIQ1DaexMmag7TTK+H5fj+IIZiCNBbju3QXuWh6sM0J5kGeQGft+TBMhBW4IdgiD1o2ljkLwCw8vAWbFKUfZQSQJARDg5b2PsBDkGWFaPhc0FYMxJBSKs3RQvAWrkEo8EjNB+7wWmFygOQ9EEKJ0GwfJ5ZSRc5AAI5IkwRCMhwIlHhmJy4fB5AiAA1MZ5bkNoxz5hOeBCks2aHEAA)
+### With [TypeCompiler](https://www.typescriptlang.org/dev/bug-workbench/?target=99&lib=true&ts=4.7.4#code/PTAEAEDMEsBsFMB2BDAtvAXKATgBwMYAuAnrvAHSEDOAUNKrgPbaGgDeoAKgMr4AW8VMlABfUJGyNUoAOTgq0RPljJo2YCTIAjRgA8ZdBs1YdOpeAGEpuOPGyjxk6XIVKVajeZ27g+a7ewDeiYWdi4AJQAFCwBRbEl7MQkpWXBCPHxgKjsANzsDGnhdENZIAFclQmhGRFBwgjMyAB5OUCLCJAATKi5eASEAPgAKKn5BZCxOABoceEg7JHx4Kkm+8YBtAF1QAF5QLYBKdhpQUD9EKlYx-ABrXa5zKwYA8iebBBGxoRnsOYWlZYHE6zQhlbC1IY5ZCwMqYUAVG6IRgAd0QRx2A2Op1O0EgQ2uN1eAlukOhsIOR1+oPBoChMPgwNO50uYVwyEIfBm6CoVGQAHN4A49utyKKCeQ4gkqKT6QdNusAAybRmgDmSZGgRDwDWcKKxeLMIYcbm8gVYAAGABI2Cb+fAksxQNa2RyROaZn5OnCZAAhACCABEAPrhGIARQAqjFuJwZKIgacRDQkzQQBAYAgUOgsJIyh1sJRaMFjGFFNBCLrog5ks40hksrl8oYSmFGoKkk5Uq5lKp1Jp4N4gkZQhx6vg29XOzJyMAMv2CszWMhOp0AJKIXB5+5jttDNvkADyWgAVvAiEbgRMHmRyAA5MqoLR2IYHKbArSTcx3h9P7Av5MUjQNCLqAy6dAeeabqwew7uYe5fvej7PoBwE1Cy0GgGWFZ6uQ+C-Oy8D-oUxQliByC4Lg4SMHmdj3IQ5C5vmF6nGBWD0bgkhLJ0YIMtioDkIoUFDGB65QQm2LkNRhBCWBEHSXm4mnOQACOsLYMQQxGphG5biI6KYoJebkMIADU2lQeQWhHGm-YALS8vMAFAA)
 
 The following uses the TypeCompiler to perform JIT optimized type checking for TRPC.
 
@@ -48,18 +57,19 @@ import { TSchema } from '@sinclair/typebox'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 import { TRPCError } from '@trpc/server'
 
-export const IoType = <T extends TSchema>(schema: T, references: TSchema[] = []) => {
+export function RpcType<T extends TSchema>(schema: T, references: TSchema[] = []) {
   const check = TypeCompiler.Compile(schema, references)
-  return (value: unknown) => check.Check(value) ? value : (() => {
+  return (value: unknown) => {
+    if (check.Check(value)) return value
     const { path, message } = [...check.Errors(value)][0]
     throw new TRPCError({ message: `${message} for ${path}`, code: 'BAD_REQUEST' })
-  })()
+  }
 }
 ```
 
 <a name="Value"></a>
 
-## With [Value](https://www.typescriptlang.org/dev/bug-workbench/?target=99&lib=true&ts=4.7.4#code/PTAEAEDMEsBsFMB2BDAtvAXKaB7AtAC4CeADvAHQEDOAUNKiTgE4GgDeoAasrAK7ygAvqEhMcqUAHJwVaIgDGsZNCbBiZAEY4AHsABuPfpLoNmrDgBUAyvIAW8VMiEixE6bIVKVa0vC3bjekYWdlALACUABQBhAFEmMSZnUXEpcAImEnlgKngmPTzjGnhtYNZ5HEQqVgBJHAtfUABeUAAeC1ASgiQAEyowm3tHAD4ACio7B2QsCwAaUCZ4SDykeXgqGcGpgG0AXWbQPYBKZuHQGlBQUYM+TFBeRABrRBwAd0QTprPuW-Jo+3kj3Gk0c8xu-BOAH5QOCBFhRqNPmc2BdLqAKlVzKASMgCLZ5ugqFRkABzATCFrbcjUn78cjxRJUYFDZDzRbLRYKdZgwzwI67bYABl2qMueLEr1AiHgkoiMQZzFGHEJxLJWAABgASNgq0nwYSQZigbU4vGCdXzCo9O6SABCAEEACIAfXCsQAigBVWJWCySIRHVGCI6Img0EAQGAIFDoLBiXjdJiUWhBMyhOTQAhy6LJVxpDJZHJ5ApMQKmEKWRoGvPuOSKZSqdR+HRlsqhOoNMi51KScjAXCEXxFDHVUDIHo9GqIEgJg4d3yjTsUADyGgAVvB5AQlajpmFfOQAHK8VAaPKI2aojQzA-H0-nwPBwM0Eescc9ZcJmesFrzsiL28TzPJhEWfV9QB-bBEEzbNyHkRZcXgUNilKNNwOQEgSHCHAEzyA4CHIeNEx3S53ywAiSDENYel4RZRVAcg5G-UZ3ynb9AzRBicIIZj30-HiEw4tFyAAR34JgiARDgmNnYNTig79yCcABqBSE3IDQTgjJs8GJZYaGDIA)
+### With [Value](https://www.typescriptlang.org/dev/bug-workbench/?target=99&lib=true&ts=4.7.4#code/PTAEAEDMEsBsFMB2BDAtvAXKATgBwMYAuAnrvAHSEDOAUNKrgPbaGgDeoAasrAK7ygAvqEjZGqUAHJwVaInyxk0bMBJkARowAewAG49+kug2asOAFQDK+ABbxUyISLETps+YuWrS8TVqP0TCzsoOYASgAKAMIAothi2E6i4lLghHj4wFTw2Lo5RjTwWkGskLzyhNCMiKBhBOY+ADzmoEWESAAmVKHWdg4AfAAUVLb2yFjmADQ48JA5SPjwVBO9YwDaALqgALygmwCU7DSgM4S82DWD+nyYoOUA1oiMAO6Ih9v9Rycn0JCD3DdyFE7Ph7sNRg5ptd+PtDth4GcLqBofBjt98NUqGZQLhkIQbNN0FQqMgAOYCYS7NbkGkA-jkOIJKjgvrIabwubw+RLKEGeD7DZrAAMGzRJ3xYmeoEQ8Cl4WijOYgw4RJJ5KwAAMACRsVVk+DCSDMUA63H4wQa6YYjq3SQAIQAggARAD6YRiAEUAKoxSzmSRCfZowQ0EM0EAQGAIFDoLBiXjtbCUWiBUwhOTQQjyqJJFypdIELI5PLYAImYIWHy5lJuOQKJQqNS+bRlkohOr4BpkauucjADJNgoYxBY0DIDodACSiFwCZ2tXqPkGXYoAHl1AAreBEZVo8ahHzkAByvFQ6hyg32kzR6gmh5PZ4vQcEsJoNGHo-HHVXCdnrF2HYrsu96nue2CXkG76Yqw-6gBmWaRFE5D4PCeLwJeb5FG2H6sMguC4GEjAJjk86EOQ8aJruJxflgZG4GIiwdOcqLfKA5ByH+gxftOf5Bqx5BEYQnFfj+QkJnx3zkAAjvw2DEIMypwTOc4vjsnwcQm5COAA1Epf7kOohwRk2AC0JJzKG+xAA)
 
 The following performs dynamic type checking without code evaluation.
 
@@ -68,17 +78,18 @@ import { Value } from '@sinclair/typebox/value'
 import { TSchema } from '@sinclair/typebox'
 import { TRPCError } from '@trpc/server'
 
-export const IoType = <T extends TSchema>(schema: T, references: TSchema[] = []) => 
-  (value: unknown) => Value.Check(schema, value) ? value : (() => {
+export function RpcType<T extends TSchema>(schema: T, references: TSchema[] = []) {
+  return (value: unknown) => {
+    if (Value.Check(schema, value)) return value
     const { path, message } = [...Value.Errors(schema, references, value)][0]
     throw new TRPCError({ message: `${message} for ${path}`, code: 'BAD_REQUEST' })
-  })()
+  }
+}
 ```
 
 <a name="Ajv"></a>
 
-## With [Ajv](https://www.typescriptlang.org/dev/bug-workbench/?target=99&lib=true&ts=4.7.4#code/PTAEAEDMEsBsFMB2BDAtvAXKaB7AtAC4CeADvAHQEDOAUNKiTgE4GgDeoAKgMoDGAFvFTIANKG4FkBaL1ABfUJCY5UoAOTgq0RL1jJoTYMTIAjHAA81dBs1YdOAJQAKAYQCiTZU3mLlqjQRMJLzAVPBMAG7hVvSMLKAAggBWEb4q6sgpwAAm0FQEwABMAAwlVjTw5nGsvDiI+aAAkjicpPCgALygADycoJUESNlUXHyCwgB8ABRUAkLIWJxiTPCQ4Ui88FSLY-MA2gC6naCHAJSdE+w0oKC19ayZqV2I8ADuiSlTp9egK2srOi25EgzDcyAEUz+60BF1Aj3IyGy2V2wkhq2hm1O3xudwac14AGtjvDagw4PAZnNhNjfvACABXJiIUBTCLIWD0zCgemIAmIHCvRCnLASKQyXqXDqXfEE1nsznnAD8oDZHPaWCmX1hbB+OLqDQ46CoVGQAHN4GJtPlkICnFJ+D4ujLyOEvFQAIR7YoHXWgAj8ZTvF7vRyuDxeKaGrYm81YUAAAwAJGwjTH4AoQd5k1bJLb7XJ42JatkuWoAEIJAAiAH0HG4AIoAVTc3E4ankNLkpy+NDkNBoIAgMAQKHQWGU9MGTEotFitnY2EQ0AIoZcPiU6QCQRCYUi0Ws1QXrTI6786k02l0+kMxngZksB-nHGax-aGbPanIwFwhDa5VxDxIo0iAkJOxwvm0UyvuQADyJhJPAvAEJGPwLFwbTkAAcvSqAmOEXwiD8JiLBh2G4fh3xdt8NAAXCSIwZOoGsF0EFkFBpE4XhTBfNRtHMYuy6ruQvArFIFLUZUh60cgJAkA4OCTuExwEOQE5TihNyItkWAqSQyibNkjLwL65DaExUxacBTE0jc5AKQQ5laQxDmTjZoDkAAjpyTBEJqHBmWBXawgFKnIKAADUi5MeQJjnIOt54Caay9qcQA)
-
+### With [Ajv](https://www.typescriptlang.org/dev/bug-workbench/?target=99&lib=true&ts=4.7.4#code/PTAEAEDMEsBsFMB2BDAtvAXKATgBwMYAuAnrvAHSEDOAUNKrgPbaGgDeoAKgMr4AW8VMgA0oboWSFo+UAF9QkbI1SgA5OCrRE+WMmjZgJMgCNGAD1V0GzVh04AlAAoBhAKLYl2OQqUr1hPHxgKnhsADdQy3omFlAAQQArMJ9lNWQk4AATaCpCYAAmAAYiyxp4MxjWSABXbSlGRFB7Ak5SeAAeTlBywiRMqi5eASEAPgAKKn5BZCxOUWx4SFCkfHgqWaHpgG0AXVAAXlBdgEp2GlBQfAbc0HTkw8R4AHd4pLHj85xF5e018khmK5kPwxmMFksFr9TvsRrckuRkJlMpshGDvpDVscPhcrogblN8ABrA5wsLkK4MODwCZTITYr6EarYRpjMLIWDVTCgWqExCMJ6IY5YcSSaSdWEws4XC7QSBjAmE1nszlYhlMxpsjnwT44662UDoKhUZAAc3goi0uWQv0ckj43kOCvIoU8VAAhFtCjsdaBCHwlC9Hi8HC53J4xhxDcazVgAAYAEjYUdN8HkAK8ictEhtdtksdEV0yXNUACE4gARAD69lcAEUAKqubicVRyemyGgdmggCAwBAodBYJTVXrYSi0aI2digLTQQgh5zeRSpfyBYKhCLYKLWWJ2NpL3xqDRaHR6AxGeCmCxWSrT5r4VpkA8r8jAQIX0q4m6IzIASUQuAjiS96PtSoHkAA8sYCTwEQEafDMXBtOQABy1SoMYoTvMInzGLMyFoRhWEfLIWI0DQX6sD+EEjoBrCHCBbRjOBhGYdg7wfBReq+iSs7zk4zjkgskjUpx5S3pRty4Lg9iMCOoQkoQ5DDqO8EXD+WBKbgSirJkTLatKoDkFodFjD+-50fSFzkHJhCmdRtEjlZRkAI6ctgxCghwJlAaRBywj5SnIKAADUM4ASO5DGKcPYXgAtMaSydscQA)
 
 The following uses Ajv to perform more generalized JSON Schema checks across the complete JSON Schema specification.
 
@@ -87,13 +98,14 @@ import { TSchema, Static } from '@sinclair/typebox'
 import { TRPCError } from '@trpc/server'
 import Ajv from 'ajv/dist/2020'
 
-export const IoType = <T extends TSchema>(schema: T, references: TSchema[] = []) => {
+export function RpcType<T extends TSchema>(schema: T, references: TSchema[] = []) {
   const ajv = new Ajv()
-  references.forEach(reference => ajv.addSchema(reference))
+  references.forEach((reference) => ajv.addSchema(reference))
   const check = ajv.compile(schema)
-  return (value: unknown): Static<T> => check(value) ? value : (() => {
+  return (value: unknown): Static<T> => {
+    if (check(value)) return value
     const { message, instancePath } = check.errors![0]
-    throw new TRPCError({ message:  `${message} for ${instancePath}`, code: 'BAD_REQUEST' })
-  })()
+    throw new TRPCError({ message: `${message} for ${instancePath}`, code: 'BAD_REQUEST' })
+  }
 }
 ```
diff --git a/example/typedef/index.ts b/example/typedef/index.ts
new file mode 100644
index 000000000..7b932b243
--- /dev/null
+++ b/example/typedef/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/extensions
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './typedef'
diff --git a/example/typedef/readme.md b/example/typedef/readme.md
new file mode 100644
index 000000000..0f0106a67
--- /dev/null
+++ b/example/typedef/readme.md
@@ -0,0 +1,100 @@
+# JSON Type Definition
+
+JSON Type Definition (JTD) specification is an alternative schema specification to JSON Schema that provides better support for nominal type systems. TypeBox doesn't provide JTD support by default, but can be expressed through unsafe types and validated with Ajv.
+
+This example provides a reference implementation for JSON Type Definition.
+
+## TypeDef
+
+Refer to the `typedef.ts` file in this directory for a reference implementation of the JSON Type Definition type builder.
+
+```typescript
+import { Static } from '@sinclair/typebox'
+import { TypeDef } from './typedef'
+```
+
+## Properties
+
+```typescript
+// ------------------------------------------------------------------------
+// PropertiesType
+//
+// https://jsontypedef.com/docs/jtd-in-5-minutes/#properties-schemas
+//
+// ------------------------------------------------------------------------
+
+export type PropertiesType = Static<typeof PropertiesType>
+export const PropertiesType = TypeDef.Properties({
+  x: TypeDef.Float32(),
+  y: TypeDef.Float32(),
+  z: TypeDef.Float32(),
+})
+```
+
+## Values
+
+```typescript
+// ------------------------------------------------------------------------
+// ValuesType
+//
+// https://jsontypedef.com/docs/jtd-in-5-minutes/#values-schemas
+//
+// ------------------------------------------------------------------------
+
+export type ValuesType = Static<typeof ValuesType>
+export const ValuesType = TypeDef.Values(TypeDef.Float64())
+```
+
+## Enum
+
+```typescript
+// ------------------------------------------------------------------------
+// EnumType
+//
+// https://jsontypedef.com/docs/jtd-in-5-minutes/#enum-schemas
+//
+// ------------------------------------------------------------------------
+
+export type EnumType = Static<typeof EnumType>
+export const EnumType = TypeDef.Enum(['FOO', 'BAR', 'BAZ'])
+```
+
+## Elements
+
+```typescript
+// ------------------------------------------------------------------------
+// ElementsType
+//
+// https://jsontypedef.com/docs/jtd-in-5-minutes/#elements-schemas
+//
+// ------------------------------------------------------------------------
+
+export type ElementsType = Static<typeof ElementsType>
+export const ElementsType = TypeDef.Elements(PropertiesType)
+```
+
+## Union
+
+```typescript
+// ------------------------------------------------------------------------
+// UnionType
+//
+// https://jsontypedef.com/docs/jtd-in-5-minutes/#discriminator-schemas
+//
+// ------------------------------------------------------------------------
+
+export type UnionType = Static<typeof UnionType>
+export const UnionType = TypeDef.Union('eventType', {
+  USER_CREATED: TypeDef.Properties({
+    id: TypeDef.String(),
+  }),
+  USER_PAYMENT_PLAN_CHANGED: TypeDef.Properties({
+    id: TypeDef.String(),
+    plan: TypeDef.Enum(['FREE', 'PAID']),
+  }),
+  USER_DELETED: TypeDef.Properties({
+    id: TypeDef.String(),
+    softDelete: TypeDef.Boolean(),
+  }),
+})
+```
diff --git a/example/typedef/typedef.ts b/example/typedef/typedef.ts
new file mode 100644
index 000000000..06a60c1bc
--- /dev/null
+++ b/example/typedef/typedef.ts
@@ -0,0 +1,88 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/typedef
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Type, Static, TUnsafe } from '@sinclair/typebox'
+
+// ------------------------------------------------------------------------
+// TypeDef Namespace
+//
+// https://jsontypedef.com/docs/jtd-in-5-minutes/
+// ------------------------------------------------------------------------
+
+export type StaticTypeDefUnion<D extends string, M extends Record<string, TUnsafe<any>>> = { [K in keyof M]: { [P in D]: K } & Static<M[K]> }[keyof M]
+
+export namespace TypeDef {
+  export function Boolean() {
+    return Type.Unsafe<boolean>({ type: 'boolean' })
+  }
+  export function String() {
+    return Type.Unsafe<string>({ type: 'string' })
+  }
+  export function TimeStamp() {
+    return Type.Unsafe<string>({ type: 'timestamp' })
+  }
+  export function Float32() {
+    return Type.Unsafe<number>({ type: 'float32' })
+  }
+  export function Float64() {
+    return Type.Unsafe<number>({ type: 'float64' })
+  }
+  export function Int8() {
+    return Type.Unsafe<number>({ type: 'int8' })
+  }
+  export function Uint8() {
+    return Type.Unsafe<number>({ type: 'uint8' })
+  }
+  export function Int16() {
+    return Type.Unsafe<number>({ type: 'int16' })
+  }
+  export function Uint16() {
+    return Type.Unsafe<number>({ type: 'uint16' })
+  }
+  export function Int32() {
+    return Type.Unsafe<number>({ type: 'int32' })
+  }
+  export function Uint32() {
+    return Type.Unsafe<number>({ type: 'uint32' })
+  }
+  export function Enum<T extends string[]>(values: [...T]) {
+    return Type.Unsafe<T[number]>({ enum: values })
+  }
+  export function Elements<T extends TUnsafe<any>>(element: T) {
+    return Type.Unsafe<Array<Static<T>>>({ elements: element })
+  }
+  export function Properties<T extends Record<string, TUnsafe<any>>>(properties: T) {
+    return Type.Unsafe<{ [K in keyof T]: Static<T[K]> }>({ properties })
+  }
+  export function Values<V extends TUnsafe<any>>(values: V) {
+    return Type.Unsafe<Record<string, Static<V>>>({ values })
+  }
+  export function Union<D extends string, M extends Record<string, TUnsafe<any>>>(discriminator: D, mapping: M) {
+    return Type.Unsafe<StaticTypeDefUnion<D, M>>({ discriminator, mapping })
+  }
+}
diff --git a/package.json b/package.json
index b9a59fe67..50ce0021c 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.23",
+  "version": "0.25.24",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 4276f179c..34acd8bbd 100644
--- a/readme.md
+++ b/readme.md
@@ -19,17 +19,17 @@
 
 ## Install
 
-### npm
+#### Npm
 ```bash
 $ npm install @sinclair/typebox --save
 ```
 
-### deno
+#### Deno
 ```typescript
 import { Static, Type } from 'npm:@sinclair/typebox'
 ```
 
-### esm
+#### Esm
 
 ```typescript
 import { Static, Type } from 'https://esm.sh/@sinclair/typebox'
@@ -64,7 +64,7 @@ type T = Static<typeof T>                            // type T = {
 
 TypeBox is a type builder library that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
 
-TypeBox is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used either as a simple tool to build up complex schemas or integrated into REST and RPC services to help validate data received over the wire. 
+This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used either as a simple tool to build up complex schemas or integrated into REST and RPC services to help validate data received over the wire. 
 
 License MIT
 
@@ -96,8 +96,8 @@ License MIT
   - [Errors](#values-errors)
   - [Pointer](#values-pointer)
 - [TypeCheck](#typecheck)
-  - [TypeCompiler](#typecheck-typecompiler)
   - [Ajv](#typecheck-ajv)
+  - [TypeCompiler](#typecheck-typecompiler)
 - [TypeSystem](#typecheck)
   - [Types](#typesystem-types)
   - [Formats](#typesystem-formats)
@@ -933,17 +933,58 @@ ValuePointer.Set(A, '/z', 1)                         // const A = { x: 1, y: 1,
 
 ## TypeCheck
 
-TypeBox targets JSON Schema Draft 6 and is built and tested against the Ajv JSON Schema validator for standards compliance. TypeBox also includes an optional built-in TypeCompiler that can provide improved compilation and validation performance specifically for TypeBox types only.
+TypeBox constructs JSON Schema draft 6 compliant schematics and can be used with any validator that supports this specification. In JavaScript, an ideal validator to use is Ajv which supports draft 6 as well as more recent revisions to the specification. In addition to Ajv, TypeBox provides an optional built in type compiler which can offer faster runtime type compilation, as well as providing high performance data validation for TypeBox types only.
 
 The following sections detail using these validators.
 
+<a name='typecheck-ajv'></a>
+
+## Ajv
+
+The following shows the recommended setup for Ajv. 
+
+```bash
+$ npm install ajv ajv-formats --save
+```
+
+```typescript
+import { Type }   from '@sinclair/typebox'
+import addFormats from 'ajv-formats'
+import Ajv        from 'ajv'
+
+const ajv = addFormats(new Ajv({}), [
+  'date-time', 
+  'time', 
+  'date', 
+  'email',  
+  'hostname', 
+  'ipv4', 
+  'ipv6', 
+  'uri', 
+  'uri-reference', 
+  'uuid',
+  'uri-template', 
+  'json-pointer', 
+  'relative-json-pointer', 
+  'regex'
+])
+
+const C = ajv.compile(Type.Object({                
+  x: Type.Number(),
+  y: Type.Number(),
+  z: Type.Number()
+}))
+
+const R = C({ x: 1, y: 2, z: 3 })                    // const R = true 
+```
+
 <a name='typecheck-typecompiler'></a>
 
 ### TypeCompiler
 
-TypeBox includes an high performance just-in-time (JIT) compiler and type checker that can be used in applications that require extremely fast validation. Note that this compiler is optimized for TypeBox types only where the schematics are known in advance.
+The TypeCompiler is a Just-In-Time (JIT) runtime compiler that can be used to convert TypeBox types into fast validation routines. This compiler is specifically tuned for fast compilation and validation for TypeBox types only. 
 
-The compiler module is provided as an optional import.
+The TypeCompiler is provided as an optional import.
 
 ```typescript
 import { TypeCompiler } from '@sinclair/typebox/compiler'
@@ -961,7 +1002,7 @@ const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObje
 const R = C.Check({ x: 1, y: 2, z: 3 })              // const R = true
 ```
 
-Validation errors can be read with the `Errors(...)` function.
+Use `Errors(...)` to generate diagnostics for a value. The `Errors(...)` function will run an exhaustive check across the value and yield any error found. For performance, this function should only be called after failed `Check(...)`.
 
 ```typescript
 const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
@@ -1002,141 +1043,11 @@ console.log(C.Code())                                // return function check(va
                                                      // }
 ```
 
-<a name='typecheck-ajv'></a>
-
-### Ajv
-
-The following are the recommended configurations to support both the [Standard](#standard) and [Extended](#extended) type sets provided by TypeBox. For schema portability and publishing to remote systems, it is recommended to use the Standard type set only.
-
-```bash
-$ npm install ajv ajv-formats --save
-```
-
-<details>
-
-<summary>
-<strong>Standard Ajv Configuration</strong>
-<p>Expand for Standard Type Set Configuration</p>
-</summary>
-
-```typescript
-import { Type }   from '@sinclair/typebox'
-import addFormats from 'ajv-formats'
-import Ajv        from 'ajv'
-
-export function createAjv() {
-  return addFormats(new Ajv({}), [
-    'date-time', 
-    'time', 
-    'date', 
-    'email',  
-    'hostname', 
-    'ipv4', 
-    'ipv6', 
-    'uri', 
-    'uri-reference', 
-    'uuid',
-    'uri-template', 
-    'json-pointer', 
-    'relative-json-pointer', 
-    'regex'
-  ])
-}
-
-const ajv = createAjv()
-
-const R = ajv.validate(Type.Object({                 // const R = true
-  x: Type.Number(),
-  y: Type.Number(),
-  z: Type.Number()
-}), { x: 1, y: 2, z: 3 })     
-```
-
-</details>
-
-<details>
-
-<summary>
-<strong>Extended Ajv Configuration</strong>
-<p>Expand for Extended Type Set Configuration</p>
-</summary>
-
-```typescript
-import { TypeGuard } from '@sinclair/typebox/guard'
-import { Value }     from '@sinclair/typebox/value'
-import { Type }      from '@sinclair/typebox'
-import addFormats    from 'ajv-formats'
-import Ajv           from 'ajv'
-
-function schemaOf(schemaOf: string, value: unknown, schema: unknown) {
-  switch (schemaOf) {
-    case 'Constructor':
-      return TypeGuard.TConstructor(schema) && Value.Check(schema, value) // not supported
-    case 'Function':
-      return TypeGuard.TFunction(schema) && Value.Check(schema, value) // not supported
-    case 'Date':
-      return TypeGuard.TDate(schema) && Value.Check(schema, value)
-    case 'Promise':
-      return TypeGuard.TPromise(schema) && Value.Check(schema, value) // not supported
-    case 'Uint8Array':
-      return TypeGuard.TUint8Array(schema) && Value.Check(schema, value)
-    case 'Undefined':
-      return TypeGuard.TUndefined(schema) && Value.Check(schema, value) // not supported
-    case 'Void':
-      return TypeGuard.TVoid(schema) && Value.Check(schema, value)
-    default:
-      return false
-  }
-}
-
-export function createAjv() {
-  return addFormats(new Ajv({}), [
-    'date-time', 
-    'time', 
-    'date', 
-    'email',  
-    'hostname', 
-    'ipv4', 
-    'ipv6', 
-    'uri', 
-    'uri-reference', 
-    'uuid',
-    'uri-template', 
-    'json-pointer', 
-    'relative-json-pointer', 
-    'regex'
-  ])
-  .addKeyword({ type: 'object', keyword: 'instanceOf', validate: schemaOf })
-  .addKeyword({ type: 'null', keyword: 'typeOf', validate: schemaOf })
-  .addKeyword('exclusiveMinimumTimestamp')
-  .addKeyword('exclusiveMaximumTimestamp')
-  .addKeyword('minimumTimestamp')
-  .addKeyword('maximumTimestamp')
-  .addKeyword('minByteLength')
-  .addKeyword('maxByteLength')
-}
-
-const ajv = createAjv()
-
-const R = ajv.validate(Type.Object({                 // const R = true
-  buffer: Type.Uint8Array(),
-  date: Type.Date(),
-  void: Type.Void()
-}), {
-  buffer: new Uint8Array(),
-  date: new Date(),
-  void: null
-})
-```
-
-</details>
-
-
 <a name='typesystem'></a>
 
 ## TypeSystem
 
-TypeBox provides an extensible TypeSystem module that enables developers to register additional types above and beyond the standard or extended type set. This module also allows developers to define custom string formats as well as override certain type checking behaviours.
+TypeBox provides an extensible TypeSystem module that enables developers to define additional types above and beyond the built in type set. This module also allows developers to define custom string formats as well as override certain type checking behaviours.
 
 The TypeSystem module is provided as an optional import.
 
@@ -1148,7 +1059,7 @@ import { TypeSystem } from '@sinclair/typebox/system'
 
 ### Types
 
-Use the `CreateType(...)` function to specify and return a custom type. This function will return a type factory function that can be used to construct the type. The following creates and registers a BigNumber type which will statically infer as `bigint`.
+Use the `CreateType(...)` function to specify custom type. This function will return a type factory function that can be used to construct the type. The following creates and registers a BigNumber type which will statically infer as `bigint`. 
 
 ```typescript
 //--------------------------------------------------------------------------------------------
@@ -1233,29 +1144,29 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    418 ms' │ '     14 ms' │ '   29.86 x' │
-│           String │    2000    │ '    331 ms' │ '     12 ms' │ '   27.58 x' │
-│          Boolean │    2000    │ '    290 ms' │ '     13 ms' │ '   22.31 x' │
-│             Null │    2000    │ '    253 ms' │ '      8 ms' │ '   31.63 x' │
-│            RegEx │    2000    │ '    481 ms' │ '     18 ms' │ '   26.72 x' │
-│          ObjectA │    2000    │ '   2675 ms' │ '     54 ms' │ '   49.54 x' │
-│          ObjectB │    2000    │ '   2849 ms' │ '     39 ms' │ '   73.05 x' │
-│            Tuple │    2000    │ '   1224 ms' │ '     22 ms' │ '   55.64 x' │
-│            Union │    2000    │ '   1225 ms' │ '     26 ms' │ '   47.12 x' │
-│          Vector4 │    2000    │ '   1777 ms' │ '     24 ms' │ '   74.04 x' │
-│          Matrix4 │    2000    │ '    825 ms' │ '     12 ms' │ '   68.75 x' │
-│   Literal_String │    2000    │ '    345 ms' │ '      9 ms' │ '   38.33 x' │
-│   Literal_Number │    2000    │ '    363 ms' │ '      7 ms' │ '   51.86 x' │
-│  Literal_Boolean │    2000    │ '    358 ms' │ '      6 ms' │ '   59.67 x' │
-│     Array_Number │    2000    │ '    687 ms' │ '      8 ms' │ '   85.88 x' │
-│     Array_String │    2000    │ '    726 ms' │ '      8 ms' │ '   90.75 x' │
-│    Array_Boolean │    2000    │ '    703 ms' │ '      8 ms' │ '   87.88 x' │
-│    Array_ObjectA │    2000    │ '   3686 ms' │ '     40 ms' │ '   92.15 x' │
-│    Array_ObjectB │    2000    │ '   3821 ms' │ '     40 ms' │ '   95.53 x' │
-│      Array_Tuple │    2000    │ '   2070 ms' │ '     17 ms' │ '  121.76 x' │
-│      Array_Union │    2000    │ '   1503 ms' │ '     21 ms' │ '   71.57 x' │
-│    Array_Vector4 │    2000    │ '   2185 ms' │ '     21 ms' │ '  104.05 x' │
-│    Array_Matrix4 │    2000    │ '   1502 ms' │ '     16 ms' │ '   93.88 x' │
+│           Number │    2000    │ '    451 ms' │ '     16 ms' │ '   28.19 x' │
+│           String │    2000    │ '    338 ms' │ '     14 ms' │ '   24.14 x' │
+│          Boolean │    2000    │ '    297 ms' │ '     13 ms' │ '   22.85 x' │
+│             Null │    2000    │ '    265 ms' │ '      8 ms' │ '   33.13 x' │
+│            RegEx │    2000    │ '    492 ms' │ '     18 ms' │ '   27.33 x' │
+│          ObjectA │    2000    │ '   2744 ms' │ '     55 ms' │ '   49.89 x' │
+│          ObjectB │    2000    │ '   3005 ms' │ '     44 ms' │ '   68.30 x' │
+│            Tuple │    2000    │ '   1283 ms' │ '     26 ms' │ '   49.35 x' │
+│            Union │    2000    │ '   1263 ms' │ '     27 ms' │ '   46.78 x' │
+│          Vector4 │    2000    │ '   1622 ms' │ '     23 ms' │ '   70.52 x' │
+│          Matrix4 │    2000    │ '    888 ms' │ '     12 ms' │ '   74.00 x' │
+│   Literal_String │    2000    │ '    344 ms' │ '     14 ms' │ '   24.57 x' │
+│   Literal_Number │    2000    │ '    389 ms' │ '      8 ms' │ '   48.63 x' │
+│  Literal_Boolean │    2000    │ '    374 ms' │ '      9 ms' │ '   41.56 x' │
+│     Array_Number │    2000    │ '    710 ms' │ '     12 ms' │ '   59.17 x' │
+│     Array_String │    2000    │ '    739 ms' │ '      9 ms' │ '   82.11 x' │
+│    Array_Boolean │    2000    │ '    732 ms' │ '      7 ms' │ '  104.57 x' │
+│    Array_ObjectA │    2000    │ '   3733 ms' │ '     42 ms' │ '   88.88 x' │
+│    Array_ObjectB │    2000    │ '   3602 ms' │ '     42 ms' │ '   85.76 x' │
+│      Array_Tuple │    2000    │ '   2204 ms' │ '     20 ms' │ '  110.20 x' │
+│      Array_Union │    2000    │ '   1533 ms' │ '     24 ms' │ '   63.88 x' │
+│    Array_Vector4 │    2000    │ '   2263 ms' │ '     21 ms' │ '  107.76 x' │
+│    Array_Matrix4 │    2000    │ '   1576 ms' │ '     14 ms' │ '  112.57 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1269,31 +1180,31 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  1000000   │ '     28 ms' │ '      6 ms' │ '      6 ms' │ '    1.00 x' │
-│           String │  1000000   │ '     25 ms' │ '     23 ms' │ '     11 ms' │ '    2.09 x' │
-│          Boolean │  1000000   │ '     24 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
-│             Null │  1000000   │ '     25 ms' │ '     22 ms' │ '     10 ms' │ '    2.20 x' │
-│            RegEx │  1000000   │ '    164 ms' │ '     53 ms' │ '     37 ms' │ '    1.43 x' │
-│          ObjectA │  1000000   │ '    593 ms' │ '     47 ms' │ '     25 ms' │ '    1.88 x' │
-│          ObjectB │  1000000   │ '   1053 ms' │ '     54 ms' │ '     40 ms' │ '    1.35 x' │
-│            Tuple │  1000000   │ '    129 ms' │ '     25 ms' │ '     16 ms' │ '    1.56 x' │
-│            Union │  1000000   │ '    334 ms' │ '     25 ms' │ '     16 ms' │ '    1.56 x' │
-│        Recursive │  1000000   │ '   3127 ms' │ '    424 ms' │ '     98 ms' │ '    4.33 x' │
-│          Vector4 │  1000000   │ '    152 ms' │ '     24 ms' │ '     12 ms' │ '    2.00 x' │
-│          Matrix4 │  1000000   │ '    593 ms' │ '     41 ms' │ '     27 ms' │ '    1.52 x' │
-│   Literal_String │  1000000   │ '     48 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
-│   Literal_Number │  1000000   │ '     47 ms' │ '     22 ms' │ '     10 ms' │ '    2.20 x' │
-│  Literal_Boolean │  1000000   │ '     48 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
-│     Array_Number │  1000000   │ '    495 ms' │ '     32 ms' │ '     21 ms' │ '    1.52 x' │
-│     Array_String │  1000000   │ '    481 ms' │ '     31 ms' │ '     21 ms' │ '    1.48 x' │
-│    Array_Boolean │  1000000   │ '    446 ms' │ '     32 ms' │ '     27 ms' │ '    1.19 x' │
-│    Array_ObjectA │  1000000   │ '  14314 ms' │ '   2341 ms' │ '   1969 ms' │ '    1.19 x' │
-│    Array_ObjectB │  1000000   │ '  16883 ms' │ '   2661 ms' │ '   2606 ms' │ '    1.02 x' │
-│      Array_Tuple │  1000000   │ '   1834 ms' │ '     98 ms' │ '     77 ms' │ '    1.27 x' │
-│      Array_Union │  1000000   │ '   4960 ms' │ '    240 ms' │ '     87 ms' │ '    2.76 x' │
-│  Array_Recursive │  1000000   │ '  56273 ms' │ '   7118 ms' │ '   1122 ms' │ '    6.34 x' │
-│    Array_Vector4 │  1000000   │ '   2498 ms' │ '     99 ms' │ '     48 ms' │ '    2.06 x' │
-│    Array_Matrix4 │  1000000   │ '  12487 ms' │ '    383 ms' │ '    246 ms' │ '    1.56 x' │
+│           Number │  1000000   │ '     30 ms' │ '      7 ms' │ '      6 ms' │ '    1.17 x' │
+│           String │  1000000   │ '     23 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
+│          Boolean │  1000000   │ '     22 ms' │ '     21 ms' │ '     10 ms' │ '    2.10 x' │
+│             Null │  1000000   │ '     27 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
+│            RegEx │  1000000   │ '    163 ms' │ '     47 ms' │ '     38 ms' │ '    1.24 x' │
+│          ObjectA │  1000000   │ '    654 ms' │ '     41 ms' │ '     24 ms' │ '    1.71 x' │
+│          ObjectB │  1000000   │ '   1173 ms' │ '     59 ms' │ '     41 ms' │ '    1.44 x' │
+│            Tuple │  1000000   │ '    124 ms' │ '     24 ms' │ '     17 ms' │ '    1.41 x' │
+│            Union │  1000000   │ '    332 ms' │ '     26 ms' │ '     16 ms' │ '    1.63 x' │
+│        Recursive │  1000000   │ '   3129 ms' │ '    412 ms' │ '    102 ms' │ '    4.04 x' │
+│          Vector4 │  1000000   │ '    147 ms' │ '     26 ms' │ '     13 ms' │ '    2.00 x' │
+│          Matrix4 │  1000000   │ '    576 ms' │ '     41 ms' │ '     28 ms' │ '    1.46 x' │
+│   Literal_String │  1000000   │ '     51 ms' │ '     21 ms' │ '     10 ms' │ '    2.10 x' │
+│   Literal_Number │  1000000   │ '     47 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
+│  Literal_Boolean │  1000000   │ '     47 ms' │ '     21 ms' │ '     10 ms' │ '    2.10 x' │
+│     Array_Number │  1000000   │ '    490 ms' │ '     33 ms' │ '     18 ms' │ '    1.83 x' │
+│     Array_String │  1000000   │ '    502 ms' │ '     31 ms' │ '     25 ms' │ '    1.24 x' │
+│    Array_Boolean │  1000000   │ '    465 ms' │ '     33 ms' │ '     27 ms' │ '    1.22 x' │
+│    Array_ObjectA │  1000000   │ '  15463 ms' │ '   2470 ms' │ '   2052 ms' │ '    1.20 x' │
+│    Array_ObjectB │  1000000   │ '  18047 ms' │ '   2497 ms' │ '   2348 ms' │ '    1.06 x' │
+│      Array_Tuple │  1000000   │ '   1958 ms' │ '     99 ms' │ '     77 ms' │ '    1.29 x' │
+│      Array_Union │  1000000   │ '   5348 ms' │ '    254 ms' │ '     89 ms' │ '    2.85 x' │
+│  Array_Recursive │  1000000   │ '  54643 ms' │ '   8870 ms' │ '   1158 ms' │ '    7.66 x' │
+│    Array_Vector4 │  1000000   │ '   2724 ms' │ '    105 ms' │ '     48 ms' │ '    2.19 x' │
+│    Array_Matrix4 │  1000000   │ '  13821 ms' │ '    437 ms' │ '    266 ms' │ '    1.64 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1307,14 +1218,15 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '   64 kb' │ '   31 kb' │  '2.02 x'   │
-│ typebox/conditional  │ '   45 kb' │ '   18 kb' │  '2.44 x'   │
-│ typebox/custom       │ '    0 kb' │ '    0 kb' │  '2.61 x'   │
-│ typebox/format       │ '    0 kb' │ '    0 kb' │  '2.66 x'   │
-│ typebox/guard        │ '   23 kb' │ '   11 kb' │  '2.07 x'   │
-│ typebox/hash         │ '    4 kb' │ '    1 kb' │  '2.30 x'   │
-│ typebox/value        │ '   89 kb' │ '   41 kb' │  '2.15 x'   │
-│ typebox              │ '   12 kb' │ '    6 kb' │  '1.89 x'   │
+│ typebox/compiler     │ ' 65.4 kb' │ ' 32.2 kb' │  '2.03 x'   │
+│ typebox/conditional  │ ' 45.5 kb' │ ' 18.6 kb' │  '2.45 x'   │
+│ typebox/custom       │ '  0.6 kb' │ '  0.2 kb' │  '2.61 x'   │
+│ typebox/format       │ '  0.6 kb' │ '  0.2 kb' │  '2.66 x'   │
+│ typebox/guard        │ ' 23.8 kb' │ ' 11.4 kb' │  '2.08 x'   │
+│ typebox/hash         │ '  4.2 kb' │ '  1.8 kb' │  '2.30 x'   │
+│ typebox/system       │ ' 14.0 kb' │ '  7.1 kb' │  '1.96 x'   │
+│ typebox/value        │ ' 90.0 kb' │ ' 41.8 kb' │  '2.15 x'   │
+│ typebox              │ ' 12.0 kb' │ '  6.4 kb' │  '1.89 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 032e7a0bb..de1b76664 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 import { ValueErrors, ValueError } from '../errors/index'
 import { TypeSystem } from '../system/index'
-import { TypeGuard } from '../guard/index'
+import { TypeExtends, TypeGuard } from '../guard/index'
 import { Format } from '../format/index'
 import { Custom } from '../custom/index'
 import { ValueHash } from '../hash/index'
@@ -246,6 +246,9 @@ export namespace TypeCompiler {
       const propertySchema = schema.properties[propertyKey]
       if (schema.required && schema.required.includes(propertyKey)) {
         yield* Visit(propertySchema, memberExpression)
+        if (TypeExtends.Undefined(propertySchema)) {
+          yield `('${propertyKey}' in ${value})`
+        }
       } else {
         const expression = CreateExpression(propertySchema, memberExpression)
         yield `(${memberExpression} === undefined ? true : (${expression}))`
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index e90ddfbf3..0cbf89419 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -28,6 +28,7 @@ THE SOFTWARE.
 
 import * as Types from '../typebox'
 import { TypeSystem } from '../system/index'
+import { TypeExtends } from '../guard/extends'
 import { Format } from '../format/index'
 import { Custom } from '../custom/index'
 import { ValueHash } from '../hash/index'
@@ -280,6 +281,9 @@ export namespace ValueErrors {
       const propertySchema = schema.properties[propertyKey]
       if (schema.required && schema.required.includes(propertyKey)) {
         yield* Visit(propertySchema, references, `${path}/${propertyKey}`, value[propertyKey])
+        if (TypeExtends.Undefined(schema) && !(propertyKey in value)) {
+          yield { type: ValueErrorType.ObjectRequiredProperties, schema: propertySchema, path: `${path}/${propertyKey}`, value: undefined, message: `Expected required property` }
+        }
       } else {
         if (value[propertyKey] !== undefined) {
           yield* Visit(propertySchema, references, `${path}/${propertyKey}`, value[propertyKey])
diff --git a/src/guard/extends.ts b/src/guard/extends.ts
new file mode 100644
index 000000000..441a87dca
--- /dev/null
+++ b/src/guard/extends.ts
@@ -0,0 +1,46 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/guard
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, dTribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '../typebox'
+
+export namespace TypeExtends {
+  /**
+   * This function returns true if the given schema is undefined, either directly or
+   * through union composition. This check is required on object property types of
+   * undefined, where an additional `'x' in value` check is required to determine
+   * the keys existence.
+   */
+  export function Undefined(schema: Types.TSchema): boolean {
+    if (schema[Types.Kind] === 'Undefined') return true
+    if (schema[Types.Kind] === 'Union') {
+      const union = schema as Types.TUnion
+      return union.anyOf.some((schema) => Undefined(schema))
+    }
+    return false
+  }
+}
diff --git a/src/guard/index.ts b/src/guard/index.ts
index 980961dae..036419519 100644
--- a/src/guard/index.ts
+++ b/src/guard/index.ts
@@ -27,3 +27,4 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 export * from './guard'
+export * from './extends'
diff --git a/src/value/cast.ts b/src/value/cast.ts
index 5c205b538..1a12d1333 100644
--- a/src/value/cast.ts
+++ b/src/value/cast.ts
@@ -284,9 +284,6 @@ export namespace ValueCast {
     }
     return result
   }
-  function Recursive(schema: Types.TRecursive<any>, references: Types.TSchema[], value: any): any {
-    throw new ValueCastRecursiveTypeError(schema)
-  }
   function Ref(schema: Types.TRef<any>, references: Types.TSchema[], value: any): any {
     const reference = references.find((reference) => reference.$id === schema.$ref)
     if (reference === undefined) throw new ValueCastReferenceTypeError(schema)
@@ -357,8 +354,6 @@ export namespace ValueCast {
         return Promise(anySchema, anyReferences, value)
       case 'Record':
         return Record(anySchema, anyReferences, value)
-      case 'Rec':
-        return Recursive(anySchema, anyReferences, value)
       case 'Ref':
         return Ref(anySchema, anyReferences, value)
       case 'Self':
diff --git a/src/value/check.ts b/src/value/check.ts
index 538db1ccb..6149cb7f6 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -28,6 +28,7 @@ THE SOFTWARE.
 
 import * as Types from '../typebox'
 import { TypeSystem } from '../system/index'
+import { TypeExtends } from '../guard/extends'
 import { Format } from '../format/index'
 import { Custom } from '../custom/index'
 import { ValueHash } from '../hash/index'
@@ -39,10 +40,18 @@ export class ValueCheckUnknownTypeError extends Error {
 }
 
 export namespace ValueCheck {
+  // --------------------------------------------------------
+  // Guards
+  // --------------------------------------------------------
+
   function IsNumber(value: unknown): value is number {
     return typeof value === 'number' && !isNaN(value)
   }
 
+  // --------------------------------------------------------
+  // Guards
+  // --------------------------------------------------------
+
   function Any(schema: Types.TAny, references: Types.TSchema[], value: any): boolean {
     return true
   }
@@ -204,6 +213,9 @@ export namespace ValueCheck {
         if (!Visit(propertySchema, references, value[propertyKey])) {
           return false
         }
+        if (TypeExtends.Undefined(propertySchema)) {
+          return propertyKey in value
+        }
       } else {
         if (value[propertyKey] !== undefined) {
           if (!Visit(propertySchema, references, value[propertyKey])) {
diff --git a/src/value/create.ts b/src/value/create.ts
index 7766960b6..980d180d8 100644
--- a/src/value/create.ts
+++ b/src/value/create.ts
@@ -186,14 +186,6 @@ export namespace ValueCreate {
     }
   }
 
-  function Recursive(schema: Types.TRecursive<any>, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
-      return schema.default
-    } else {
-      throw new Error('ValueCreate.Recursive: Recursive types require a default value')
-    }
-  }
-
   function Ref(schema: Types.TRef<any>, references: Types.TSchema[]): any {
     if (schema.default !== undefined) {
       return schema.default
@@ -336,8 +328,6 @@ export namespace ValueCreate {
         return Promise(anySchema, anyReferences)
       case 'Record':
         return Record(anySchema, anyReferences)
-      case 'Rec':
-        return Recursive(anySchema, anyReferences)
       case 'Ref':
         return Ref(anySchema, anyReferences)
       case 'Self':
diff --git a/test/runtime/compiler/object.ts b/test/runtime/compiler/object.ts
index 924b75c86..5a4bbe1e7 100644
--- a/test/runtime/compiler/object.ts
+++ b/test/runtime/compiler/object.ts
@@ -205,4 +205,26 @@ describe('type/compiler/Object', () => {
       z: 3,
     })
   })
+  it('Should check for property key if property type is undefined', () => {
+    const T = Type.Object({ x: Type.Undefined() })
+    Ok(T, { x: undefined })
+    Fail(T, {})
+  })
+  it('Should check for property key if property type extends undefined', () => {
+    const T = Type.Object({ x: Type.Union([Type.Number(), Type.Undefined()]) })
+    Ok(T, { x: 1 })
+    Ok(T, { x: undefined })
+    Fail(T, {})
+  })
+  it('Should not check for property key if property type is undefined and optional', () => {
+    const T = Type.Object({ x: Type.Optional(Type.Undefined()) })
+    Ok(T, { x: undefined })
+    Ok(T, {})
+  })
+  it('Should not check for property key if property type extends undefined and optional', () => {
+    const T = Type.Object({ x: Type.Optional(Type.Union([Type.Number(), Type.Undefined()])) })
+    Ok(T, { x: 1 })
+    Ok(T, { x: undefined })
+    Ok(T, {})
+  })
 })
diff --git a/test/runtime/value/check/object.ts b/test/runtime/value/check/object.ts
index ccd0ef10c..ed6a76d93 100644
--- a/test/runtime/value/check/object.ts
+++ b/test/runtime/value/check/object.ts
@@ -190,4 +190,26 @@ describe('value/check/Object', () => {
       false,
     )
   })
+  it('Should check for property key if property type is undefined', () => {
+    const T = Type.Object({ x: Type.Undefined() })
+    Assert.equal(Value.Check(T, { x: undefined }), true)
+    Assert.equal(Value.Check(T, {}), false)
+  })
+  it('Should check for property key if property type extends undefined', () => {
+    const T = Type.Object({ x: Type.Union([Type.Number(), Type.Undefined()]) })
+    Assert.equal(Value.Check(T, { x: 1 }), true)
+    Assert.equal(Value.Check(T, { x: undefined }), true)
+    Assert.equal(Value.Check(T, {}), false)
+  })
+  it('Should not check for property key if property type is undefined and optional', () => {
+    const T = Type.Object({ x: Type.Optional(Type.Undefined()) })
+    Assert.equal(Value.Check(T, { x: undefined }), true)
+    Assert.equal(Value.Check(T, {}), true)
+  })
+  it('Should not check for property key if property type extends undefined and optional', () => {
+    const T = Type.Object({ x: Type.Optional(Type.Union([Type.Number(), Type.Undefined()])) })
+    Assert.equal(Value.Check(T, { x: 1 }), true)
+    Assert.equal(Value.Check(T, { x: undefined }), true)
+    Assert.equal(Value.Check(T, {}), true)
+  })
 })

From 4ec4daad440f94034f2c9b3600fc28630eebe62e Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 22 Mar 2023 01:01:38 +0900
Subject: [PATCH 070/369] Revision 0.26.0 (#346)

---
 .github/workflows/ci.yml                      |    2 +-
 .gitignore                                    |    1 +
 .vscode/settings.json                         |    4 +-
 .../compression/module/typebox-conditional.ts |    4 -
 .../compression/module/typebox-custom.ts      |    4 -
 .../compression/module/typebox-errors.ts      |    3 +
 .../compression/module/typebox-format.ts      |    4 -
 benchmark/compression/module/typebox-guard.ts |    4 -
 benchmark/compression/module/typebox-hash.ts  |    3 -
 benchmark/measurement/module/cases.ts         |  105 +-
 benchmark/measurement/module/check.ts         |    3 +-
 benchmark/measurement/module/compile.ts       |    7 +-
 benchmark/measurement/module/index.ts         |    4 +-
 changelog.md                                  |  410 ---
 changelog/0.17.1.md                           |   15 +
 changelog/0.17.4.md                           |   38 +
 changelog/0.17.6.md                           |   56 +
 changelog/0.18.0.md                           |   22 +
 changelog/0.18.1.md                           |    5 +
 changelog/0.19.0.md                           |   20 +
 changelog/0.20.0.md                           |   17 +
 changelog/0.20.1.md                           |    5 +
 changelog/0.21.0.md                           |    7 +
 changelog/0.21.2.md                           |   26 +
 changelog/0.22.0.md                           |    8 +
 changelog/0.23.0.md                           |    8 +
 changelog/0.23.1.md                           |    5 +
 changelog/0.23.3.md                           |    5 +
 changelog/0.24.0.md                           |   28 +
 changelog/0.24.15.md                          |   10 +
 changelog/0.24.44.md                          |   18 +
 changelog/0.24.49.md                          |    9 +
 changelog/0.24.6.md                           |   20 +
 changelog/0.24.8.md                           |    6 +
 changelog/0.25.0.md                           |    7 +
 changelog/0.25.10.md                          |    5 +
 changelog/0.25.11.md                          |    5 +
 changelog/0.25.18.md                          |    5 +
 changelog/0.25.22.md                          |    5 +
 changelog/0.25.23.md                          |   10 +
 changelog/0.25.24.md                          |   10 +
 changelog/0.25.9.md                           |    5 +
 changelog/0.26.0.md                           |  394 +++
 codegen/codegen.ts                            |   53 -
 codegen/index.ts                              |    5 +-
 ...typescript.ts => typebox-to-typescript.ts} |   81 +-
 codegen/{zod.ts => typebox-to-zod.ts}         |   90 +-
 ...schema.ts => typescript-to-json-schema.ts} |   71 +-
 .../{typebox.ts => typescript-to-typebox.ts}  |   71 +-
 example/experimental/experimental.ts          |  109 +
 {src/hash => example/experimental}/index.ts   |    4 +-
 example/experimental/readme.md                |   30 +
 example/extensions/index.ts                   |   32 -
 example/extensions/intersect-allof.ts         |   60 -
 example/extensions/readonly-object.ts         |   56 -
 example/extensions/union-enum.ts              |   46 -
 example/extensions/union-oneof.ts             |   47 -
 example/formats/additional.ts                 |   94 -
 example/formats/index.ts                      |    2 +-
 example/formats/readme.md                     |   43 +
 example/formats/standard.ts                   |   74 +
 example/index.ts                              |    7 +-
 example/trpc/readme.md                        |   12 +-
 example/typedef/index.ts                      |    2 +-
 example/typedef/readme.md                     |  159 +-
 example/typedef/typedef.ts                    |  399 ++-
 hammer.mjs                                    |   16 +-
 package-lock.json                             |   20 +-
 package.json                                  |    9 +-
 readme.md                                     |  654 +++--
 src/compiler/compiler.ts                      |  458 ++--
 src/conditional/conditional.ts                |  114 -
 src/conditional/index.ts                      |   30 -
 src/conditional/structural.ts                 |  579 ----
 src/custom/custom.ts                          |   54 -
 src/custom/index.ts                           |   29 -
 src/errors/errors.ts                          |  389 +--
 src/format/format.ts                          |   54 -
 src/format/index.ts                           |   29 -
 src/guard/extends.ts                          |   46 -
 src/guard/guard.ts                            |  487 ----
 src/guard/index.ts                            |   30 -
 src/system/system.ts                          |   49 +-
 src/tsconfig.json                             |    2 +-
 src/typebox.ts                                | 2335 +++++++++++++----
 src/value/cast.ts                             |  207 +-
 src/value/check.ts                            |  350 +--
 src/value/clone.ts                            |    5 -
 src/value/convert.ts                          |  342 +++
 src/value/create.ts                           |  220 +-
 src/value/equal.ts                            |    5 -
 src/{hash => value}/hash.ts                   |   76 +-
 src/value/index.ts                            |    3 +-
 src/value/value.ts                            |   29 +-
 test/runtime/compiler/any.ts                  |    8 +
 test/runtime/compiler/array.ts                |    4 +-
 test/runtime/compiler/bigint.ts               |   84 +
 test/runtime/compiler/boolean.ts              |    8 +
 test/runtime/compiler/composite.ts            |   73 +
 test/runtime/compiler/custom.ts               |    6 +-
 test/runtime/compiler/date.ts                 |    8 +
 test/runtime/compiler/index.ts                |    4 +
 test/runtime/compiler/integer.ts              |   26 +-
 test/runtime/compiler/intersect.ts            |  130 +-
 test/runtime/compiler/literal.ts              |    4 -
 test/runtime/compiler/never.ts                |   11 +-
 test/runtime/compiler/not.ts                  |   38 +
 test/runtime/compiler/null.ts                 |   14 +-
 test/runtime/compiler/number.ts               |   30 +-
 test/runtime/compiler/object.ts               |   36 +-
 test/runtime/compiler/omit.ts                 |   26 +
 test/runtime/compiler/pick.ts                 |   26 +
 test/runtime/compiler/record.ts               |    8 +
 test/runtime/compiler/ref.ts                  |   26 +-
 test/runtime/compiler/string.ts               |    9 +-
 test/runtime/compiler/symbol.ts               |   42 +
 test/runtime/compiler/validate.ts             |    9 +-
 test/runtime/compiler/void.ts                 |   18 +-
 test/runtime/conditional/any.ts               |   98 -
 test/runtime/conditional/array.ts             |  316 ---
 test/runtime/conditional/boolean.ts           |  113 -
 test/runtime/conditional/constructor.ts       |  250 --
 test/runtime/conditional/date.ts              |  118 -
 test/runtime/conditional/function.ts          |  251 --
 test/runtime/conditional/integer.ts           |  119 -
 test/runtime/conditional/literal.ts           |  330 ---
 test/runtime/conditional/null.ts              |  119 -
 test/runtime/conditional/number.ts            |  119 -
 test/runtime/conditional/object.ts            |  161 --
 test/runtime/conditional/promise.ts           |  251 --
 test/runtime/conditional/string.ts            |  149 --
 test/runtime/conditional/tuple.ts             |  203 --
 test/runtime/conditional/uint8array.ts        |  119 -
 test/runtime/conditional/undefined.ts         |  107 -
 test/runtime/conditional/union.ts             |  154 --
 test/runtime/conditional/unknown.ts           |  125 -
 test/runtime/conditional/void.ts              |  125 -
 test/runtime/errors/index.ts                  |    2 +-
 test/runtime/errors/iterator.ts               |   32 +
 test/runtime/format/format.ts                 |   25 -
 test/runtime/index.ts                         |    5 +-
 test/runtime/schema/composite.ts              |   94 +
 test/runtime/schema/index.ts                  |    2 +
 test/runtime/schema/intersect.ts              |  141 +-
 test/runtime/schema/not.ts                    |   38 +
 test/runtime/schema/validate.ts               |    2 +-
 test/runtime/system/AllowArrayObjects.ts      |   61 -
 test/runtime/system/AllowNaN.ts               |   30 -
 test/runtime/system/CreateFormat.ts           |   17 -
 test/runtime/system/CreateType.ts             |   23 -
 test/runtime/system/index.ts                  |    5 +-
 test/runtime/system/system.ts                 |  169 ++
 test/runtime/type/clone/clone.ts              |  147 ++
 test/runtime/type/clone/index.ts              |    1 +
 test/runtime/type/extends/any.ts              |   98 +
 test/runtime/type/extends/array.ts            |  316 +++
 test/runtime/type/extends/bigint.ts           |  101 +
 test/runtime/type/extends/boolean.ts          |  107 +
 test/runtime/type/extends/constructor.ts      |  250 ++
 test/runtime/type/extends/date.ts             |  112 +
 test/runtime/type/extends/function.ts         |  251 ++
 .../{conditional => type/extends}/index.ts    |    2 +
 test/runtime/type/extends/integer.ts          |  113 +
 test/runtime/type/extends/literal.ts          |  312 +++
 test/runtime/type/extends/null.ts             |  119 +
 test/runtime/type/extends/number.ts           |  113 +
 test/runtime/type/extends/object.ts           |  177 ++
 test/runtime/type/extends/promise.ts          |  251 ++
 .../{conditional => type/extends}/record.ts   |  140 +-
 test/runtime/type/extends/string.ts           |  131 +
 test/runtime/type/extends/symbol.ts           |  106 +
 test/runtime/type/extends/tuple.ts            |  161 ++
 test/runtime/type/extends/uint8array.ts       |  113 +
 test/runtime/type/extends/undefined.ts        |  107 +
 test/runtime/type/extends/union.ts            |  136 +
 test/runtime/type/extends/unknown.ts          |  119 +
 test/runtime/type/extends/void.ts             |  125 +
 test/runtime/{ => type}/guard/any.ts          |    4 +-
 test/runtime/{ => type}/guard/array.ts        |    4 +-
 test/runtime/type/guard/bigint.ts             |   19 +
 test/runtime/{ => type}/guard/boolean.ts      |    4 +-
 test/runtime/{ => type}/guard/constructor.ts  |    4 +-
 test/runtime/{ => type}/guard/date.ts         |    4 +-
 test/runtime/type/guard/exclude.ts            |   24 +
 test/runtime/type/guard/extract.ts            |   24 +
 test/runtime/{ => type}/guard/function.ts     |    4 +-
 test/runtime/{ => type}/guard/index.ts        |    6 +
 test/runtime/{ => type}/guard/integer.ts      |    4 +-
 test/runtime/type/guard/intersect.ts          |   32 +
 test/runtime/{ => type}/guard/literal.ts      |    4 +-
 test/runtime/type/guard/not.ts                |   23 +
 test/runtime/{ => type}/guard/null.ts         |    4 +-
 test/runtime/{ => type}/guard/number.ts       |    4 +-
 test/runtime/{ => type}/guard/object.ts       |    4 +-
 test/runtime/{ => type}/guard/promise.ts      |    4 +-
 test/runtime/{ => type}/guard/record.ts       |   17 +-
 test/runtime/{ => type}/guard/ref.ts          |    4 +-
 test/runtime/{ => type}/guard/self.ts         |    4 +-
 test/runtime/{ => type}/guard/string.ts       |    4 +-
 test/runtime/type/guard/symbol.ts             |   19 +
 test/runtime/{ => type}/guard/tuple.ts        |    4 +-
 test/runtime/{ => type}/guard/uint8array.ts   |    4 +-
 test/runtime/{ => type}/guard/undefined.ts    |    4 +-
 test/runtime/{ => type}/guard/union.ts        |   24 +-
 test/runtime/{ => type}/guard/unknown.ts      |    4 +-
 test/runtime/{ => type}/guard/void.ts         |    4 +-
 test/runtime/type/index.ts                    |    5 +
 test/runtime/type/normal/exclude.ts           |   21 +
 test/runtime/type/normal/extract.ts           |   31 +
 test/runtime/type/normal/index.ts             |    5 +
 test/runtime/type/normal/intersect.ts         |   21 +
 test/runtime/type/normal/record.ts            |   12 +
 test/runtime/type/normal/union.ts             |   21 +
 test/runtime/type/registry/format.ts          |   25 +
 .../{format => type/registry}/index.ts        |    0
 test/runtime/value/cast/any.ts                |    3 -
 test/runtime/value/cast/array.ts              |   25 -
 test/runtime/value/cast/bigint.ts             |   53 +
 test/runtime/value/cast/boolean.ts            |    6 -
 test/runtime/value/cast/composite.ts          |   89 +
 test/runtime/value/cast/convert.ts            |  291 --
 test/runtime/value/cast/custom.ts             |   13 +-
 test/runtime/value/cast/date.ts               |   18 -
 test/runtime/value/cast/enum.ts               |   10 -
 test/runtime/value/cast/index.ts              |    5 +-
 test/runtime/value/cast/integer.ts            |   13 -
 test/runtime/value/cast/intersect.ts          |  147 +-
 test/runtime/value/cast/keyof.ts              |    9 -
 test/runtime/value/cast/literal.ts            |    9 -
 test/runtime/value/cast/not.ts                |   59 +
 test/runtime/value/cast/null.ts               |    9 -
 test/runtime/value/cast/number.ts             |   14 -
 test/runtime/value/cast/object.ts             |   11 -
 test/runtime/value/cast/record.ts             |    7 -
 test/runtime/value/cast/recursive.ts          |   32 +-
 test/runtime/value/cast/regex.ts              |    9 -
 test/runtime/value/cast/string.ts             |   19 -
 test/runtime/value/cast/symbol.ts             |   52 +
 test/runtime/value/cast/tuple.ts              |   13 -
 test/runtime/value/cast/uint8array.ts         |    9 -
 test/runtime/value/cast/undefined.ts          |    9 -
 test/runtime/value/cast/union.ts              |   19 -
 test/runtime/value/cast/unknown.ts            |    9 -
 test/runtime/value/cast/void.ts               |    9 -
 test/runtime/value/check/bigint.ts            |   44 +
 test/runtime/value/check/composite.ts         |   82 +
 test/runtime/value/check/custom.ts            |    5 +-
 test/runtime/value/check/index.ts             |    5 +
 test/runtime/value/check/integer.ts           |   21 +-
 test/runtime/value/check/intersect.ts         |  138 +-
 test/runtime/value/check/not.ts               |   39 +
 test/runtime/value/check/number.ts            |   15 +
 test/runtime/value/check/object.ts            |   12 +
 test/runtime/value/check/record.ts            |   11 +-
 test/runtime/value/check/ref.ts               |   83 +
 test/runtime/value/check/symbol.ts            |   52 +
 test/runtime/value/check/void.ts              |    6 +-
 test/runtime/value/convert/any.ts             |   42 +
 test/runtime/value/convert/array.ts           |   32 +
 test/runtime/value/convert/bigint.ts          |   46 +
 test/runtime/value/convert/boolean.ts         |  154 ++
 test/runtime/value/convert/composite.ts       |   16 +
 test/runtime/value/convert/custom.ts          |   24 +
 test/runtime/value/convert/date.ts            |   42 +
 test/runtime/value/convert/enum.ts            |    7 +
 test/runtime/value/convert/index.ts           |   26 +
 test/runtime/value/convert/integer.ts         |   79 +
 test/runtime/value/convert/keyof.ts           |    7 +
 test/runtime/value/convert/literal.ts         |   85 +
 test/runtime/value/convert/never.ts           |   21 +
 test/runtime/value/convert/null.ts            |   19 +
 test/runtime/value/convert/number.ts          |   76 +
 test/runtime/value/convert/object.ts          |   16 +
 test/runtime/value/convert/record.ts          |    7 +
 test/runtime/value/convert/recursive.ts       |    7 +
 test/runtime/value/convert/regex.ts           |    7 +
 test/runtime/value/convert/string.ts          |   69 +
 test/runtime/value/convert/symbol.ts          |   15 +
 test/runtime/value/convert/tuple.ts           |   21 +
 test/runtime/value/convert/uint8array.ts      |    9 +
 test/runtime/value/convert/undefined.ts       |   15 +
 test/runtime/value/convert/union.ts           |    7 +
 test/runtime/value/convert/unknown.ts         |   42 +
 test/runtime/value/convert/void.ts            |    7 +
 test/runtime/value/create/bigint.ts           |   14 +
 test/runtime/value/create/boolean.ts          |    2 +-
 test/runtime/value/create/composite.ts        |   66 +
 test/runtime/value/create/custom.ts           |    7 +-
 test/runtime/value/create/index.ts            |    7 +-
 test/runtime/value/create/intersect.ts        |   86 +-
 test/runtime/value/create/not.ts              |   21 +
 .../value/create/{rec.ts => recursive.ts}     |    0
 test/runtime/value/create/ref.ts              |   30 +
 test/runtime/value/create/symbol.ts           |   15 +
 test/runtime/{ => value}/hash/hash.ts         |   49 +-
 test/runtime/{ => value}/hash/index.ts        |    0
 test/runtime/value/index.ts                   |    2 +
 test/static/assert.ts                         |    6 +-
 test/static/bigint.ts                         |    4 +
 test/static/composite.ts                      |   19 +
 test/static/exclude.ts                        |   15 +
 test/static/extract.ts                        |   15 +
 test/static/index.ts                          |    6 +
 test/static/intersect.ts                      |   27 +-
 test/static/keyof.ts                          |   24 +
 test/static/not.ts                            |    7 +
 test/static/omit.ts                           |   48 +
 test/static/partial.ts                        |   53 +
 test/static/pick.ts                           |   70 +
 test/static/required.ts                       |   54 +
 test/static/symbol.ts                         |    4 +
 tsconfig.json                                 |   16 +-
 typebox.png                                   |  Bin 706199 -> 946728 bytes
 313 files changed, 12163 insertions(+), 8924 deletions(-)
 delete mode 100644 benchmark/compression/module/typebox-conditional.ts
 delete mode 100644 benchmark/compression/module/typebox-custom.ts
 create mode 100644 benchmark/compression/module/typebox-errors.ts
 delete mode 100644 benchmark/compression/module/typebox-format.ts
 delete mode 100644 benchmark/compression/module/typebox-guard.ts
 delete mode 100644 benchmark/compression/module/typebox-hash.ts
 delete mode 100644 changelog.md
 create mode 100644 changelog/0.17.1.md
 create mode 100644 changelog/0.17.4.md
 create mode 100644 changelog/0.17.6.md
 create mode 100644 changelog/0.18.0.md
 create mode 100644 changelog/0.18.1.md
 create mode 100644 changelog/0.19.0.md
 create mode 100644 changelog/0.20.0.md
 create mode 100644 changelog/0.20.1.md
 create mode 100644 changelog/0.21.0.md
 create mode 100644 changelog/0.21.2.md
 create mode 100644 changelog/0.22.0.md
 create mode 100644 changelog/0.23.0.md
 create mode 100644 changelog/0.23.1.md
 create mode 100644 changelog/0.23.3.md
 create mode 100644 changelog/0.24.0.md
 create mode 100644 changelog/0.24.15.md
 create mode 100644 changelog/0.24.44.md
 create mode 100644 changelog/0.24.49.md
 create mode 100644 changelog/0.24.6.md
 create mode 100644 changelog/0.24.8.md
 create mode 100644 changelog/0.25.0.md
 create mode 100644 changelog/0.25.10.md
 create mode 100644 changelog/0.25.11.md
 create mode 100644 changelog/0.25.18.md
 create mode 100644 changelog/0.25.22.md
 create mode 100644 changelog/0.25.23.md
 create mode 100644 changelog/0.25.24.md
 create mode 100644 changelog/0.25.9.md
 create mode 100644 changelog/0.26.0.md
 delete mode 100644 codegen/codegen.ts
 rename codegen/{typescript.ts => typebox-to-typescript.ts} (76%)
 rename codegen/{zod.ts => typebox-to-zod.ts} (74%)
 rename codegen/{jsonschema.ts => typescript-to-json-schema.ts} (85%)
 rename codegen/{typebox.ts => typescript-to-typebox.ts} (91%)
 create mode 100644 example/experimental/experimental.ts
 rename {src/hash => example/experimental}/index.ts (95%)
 create mode 100644 example/experimental/readme.md
 delete mode 100644 example/extensions/index.ts
 delete mode 100644 example/extensions/intersect-allof.ts
 delete mode 100644 example/extensions/readonly-object.ts
 delete mode 100644 example/extensions/union-enum.ts
 delete mode 100644 example/extensions/union-oneof.ts
 delete mode 100644 example/formats/additional.ts
 create mode 100644 example/formats/readme.md
 create mode 100644 example/formats/standard.ts
 delete mode 100644 src/conditional/conditional.ts
 delete mode 100644 src/conditional/index.ts
 delete mode 100644 src/conditional/structural.ts
 delete mode 100644 src/custom/custom.ts
 delete mode 100644 src/custom/index.ts
 delete mode 100644 src/format/format.ts
 delete mode 100644 src/format/index.ts
 delete mode 100644 src/guard/extends.ts
 delete mode 100644 src/guard/guard.ts
 delete mode 100644 src/guard/index.ts
 create mode 100644 src/value/convert.ts
 rename src/{hash => value}/hash.ts (83%)
 create mode 100644 test/runtime/compiler/bigint.ts
 create mode 100644 test/runtime/compiler/composite.ts
 create mode 100644 test/runtime/compiler/not.ts
 create mode 100644 test/runtime/compiler/symbol.ts
 delete mode 100644 test/runtime/conditional/any.ts
 delete mode 100644 test/runtime/conditional/array.ts
 delete mode 100644 test/runtime/conditional/boolean.ts
 delete mode 100644 test/runtime/conditional/constructor.ts
 delete mode 100644 test/runtime/conditional/date.ts
 delete mode 100644 test/runtime/conditional/function.ts
 delete mode 100644 test/runtime/conditional/integer.ts
 delete mode 100644 test/runtime/conditional/literal.ts
 delete mode 100644 test/runtime/conditional/null.ts
 delete mode 100644 test/runtime/conditional/number.ts
 delete mode 100644 test/runtime/conditional/object.ts
 delete mode 100644 test/runtime/conditional/promise.ts
 delete mode 100644 test/runtime/conditional/string.ts
 delete mode 100644 test/runtime/conditional/tuple.ts
 delete mode 100644 test/runtime/conditional/uint8array.ts
 delete mode 100644 test/runtime/conditional/undefined.ts
 delete mode 100644 test/runtime/conditional/union.ts
 delete mode 100644 test/runtime/conditional/unknown.ts
 delete mode 100644 test/runtime/conditional/void.ts
 create mode 100644 test/runtime/errors/iterator.ts
 delete mode 100644 test/runtime/format/format.ts
 create mode 100644 test/runtime/schema/composite.ts
 create mode 100644 test/runtime/schema/not.ts
 delete mode 100644 test/runtime/system/AllowArrayObjects.ts
 delete mode 100644 test/runtime/system/AllowNaN.ts
 delete mode 100644 test/runtime/system/CreateFormat.ts
 delete mode 100644 test/runtime/system/CreateType.ts
 create mode 100644 test/runtime/system/system.ts
 create mode 100644 test/runtime/type/clone/clone.ts
 create mode 100644 test/runtime/type/clone/index.ts
 create mode 100644 test/runtime/type/extends/any.ts
 create mode 100644 test/runtime/type/extends/array.ts
 create mode 100644 test/runtime/type/extends/bigint.ts
 create mode 100644 test/runtime/type/extends/boolean.ts
 create mode 100644 test/runtime/type/extends/constructor.ts
 create mode 100644 test/runtime/type/extends/date.ts
 create mode 100644 test/runtime/type/extends/function.ts
 rename test/runtime/{conditional => type/extends}/index.ts (91%)
 create mode 100644 test/runtime/type/extends/integer.ts
 create mode 100644 test/runtime/type/extends/literal.ts
 create mode 100644 test/runtime/type/extends/null.ts
 create mode 100644 test/runtime/type/extends/number.ts
 create mode 100644 test/runtime/type/extends/object.ts
 create mode 100644 test/runtime/type/extends/promise.ts
 rename test/runtime/{conditional => type/extends}/record.ts (58%)
 create mode 100644 test/runtime/type/extends/string.ts
 create mode 100644 test/runtime/type/extends/symbol.ts
 create mode 100644 test/runtime/type/extends/tuple.ts
 create mode 100644 test/runtime/type/extends/uint8array.ts
 create mode 100644 test/runtime/type/extends/undefined.ts
 create mode 100644 test/runtime/type/extends/union.ts
 create mode 100644 test/runtime/type/extends/unknown.ts
 create mode 100644 test/runtime/type/extends/void.ts
 rename test/runtime/{ => type}/guard/any.ts (83%)
 rename test/runtime/{ => type}/guard/array.ts (94%)
 create mode 100644 test/runtime/type/guard/bigint.ts
 rename test/runtime/{ => type}/guard/boolean.ts (84%)
 rename test/runtime/{ => type}/guard/constructor.ts (93%)
 rename test/runtime/{ => type}/guard/date.ts (92%)
 create mode 100644 test/runtime/type/guard/exclude.ts
 create mode 100644 test/runtime/type/guard/extract.ts
 rename test/runtime/{ => type}/guard/function.ts (93%)
 rename test/runtime/{ => type}/guard/index.ts (78%)
 rename test/runtime/{ => type}/guard/integer.ts (93%)
 create mode 100644 test/runtime/type/guard/intersect.ts
 rename test/runtime/{ => type}/guard/literal.ts (91%)
 create mode 100644 test/runtime/type/guard/not.ts
 rename test/runtime/{ => type}/guard/null.ts (83%)
 rename test/runtime/{ => type}/guard/number.ts (93%)
 rename test/runtime/{ => type}/guard/object.ts (96%)
 rename test/runtime/{ => type}/guard/promise.ts (91%)
 rename test/runtime/{ => type}/guard/record.ts (66%)
 rename test/runtime/{ => type}/guard/ref.ts (85%)
 rename test/runtime/{ => type}/guard/self.ts (85%)
 rename test/runtime/{ => type}/guard/string.ts (91%)
 create mode 100644 test/runtime/type/guard/symbol.ts
 rename test/runtime/{ => type}/guard/tuple.ts (88%)
 rename test/runtime/{ => type}/guard/uint8array.ts (90%)
 rename test/runtime/{ => type}/guard/undefined.ts (84%)
 rename test/runtime/{ => type}/guard/union.ts (63%)
 rename test/runtime/{ => type}/guard/unknown.ts (84%)
 rename test/runtime/{ => type}/guard/void.ts (83%)
 create mode 100644 test/runtime/type/index.ts
 create mode 100644 test/runtime/type/normal/exclude.ts
 create mode 100644 test/runtime/type/normal/extract.ts
 create mode 100644 test/runtime/type/normal/index.ts
 create mode 100644 test/runtime/type/normal/intersect.ts
 create mode 100644 test/runtime/type/normal/record.ts
 create mode 100644 test/runtime/type/normal/union.ts
 create mode 100644 test/runtime/type/registry/format.ts
 rename test/runtime/{format => type/registry}/index.ts (100%)
 create mode 100644 test/runtime/value/cast/bigint.ts
 create mode 100644 test/runtime/value/cast/composite.ts
 delete mode 100644 test/runtime/value/cast/convert.ts
 create mode 100644 test/runtime/value/cast/not.ts
 create mode 100644 test/runtime/value/cast/symbol.ts
 create mode 100644 test/runtime/value/check/bigint.ts
 create mode 100644 test/runtime/value/check/composite.ts
 create mode 100644 test/runtime/value/check/not.ts
 create mode 100644 test/runtime/value/check/ref.ts
 create mode 100644 test/runtime/value/check/symbol.ts
 create mode 100644 test/runtime/value/convert/any.ts
 create mode 100644 test/runtime/value/convert/array.ts
 create mode 100644 test/runtime/value/convert/bigint.ts
 create mode 100644 test/runtime/value/convert/boolean.ts
 create mode 100644 test/runtime/value/convert/composite.ts
 create mode 100644 test/runtime/value/convert/custom.ts
 create mode 100644 test/runtime/value/convert/date.ts
 create mode 100644 test/runtime/value/convert/enum.ts
 create mode 100644 test/runtime/value/convert/index.ts
 create mode 100644 test/runtime/value/convert/integer.ts
 create mode 100644 test/runtime/value/convert/keyof.ts
 create mode 100644 test/runtime/value/convert/literal.ts
 create mode 100644 test/runtime/value/convert/never.ts
 create mode 100644 test/runtime/value/convert/null.ts
 create mode 100644 test/runtime/value/convert/number.ts
 create mode 100644 test/runtime/value/convert/object.ts
 create mode 100644 test/runtime/value/convert/record.ts
 create mode 100644 test/runtime/value/convert/recursive.ts
 create mode 100644 test/runtime/value/convert/regex.ts
 create mode 100644 test/runtime/value/convert/string.ts
 create mode 100644 test/runtime/value/convert/symbol.ts
 create mode 100644 test/runtime/value/convert/tuple.ts
 create mode 100644 test/runtime/value/convert/uint8array.ts
 create mode 100644 test/runtime/value/convert/undefined.ts
 create mode 100644 test/runtime/value/convert/union.ts
 create mode 100644 test/runtime/value/convert/unknown.ts
 create mode 100644 test/runtime/value/convert/void.ts
 create mode 100644 test/runtime/value/create/bigint.ts
 create mode 100644 test/runtime/value/create/composite.ts
 create mode 100644 test/runtime/value/create/not.ts
 rename test/runtime/value/create/{rec.ts => recursive.ts} (100%)
 create mode 100644 test/runtime/value/create/ref.ts
 create mode 100644 test/runtime/value/create/symbol.ts
 rename test/runtime/{ => value}/hash/hash.ts (69%)
 rename test/runtime/{ => value}/hash/index.ts (100%)
 create mode 100644 test/static/bigint.ts
 create mode 100644 test/static/composite.ts
 create mode 100644 test/static/exclude.ts
 create mode 100644 test/static/extract.ts
 create mode 100644 test/static/not.ts
 create mode 100644 test/static/symbol.ts

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d64a14027..a07597518 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -20,4 +20,4 @@ jobs:
       - name: Build Library
         run: npm run build
       - name: Test Library
-        run: npm run test
+        run: npm run test
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 2c085d1d2..adfbc990e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 node_modules
 target
+dist
diff --git a/.vscode/settings.json b/.vscode/settings.json
index a9232115d..df318270b 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -3,6 +3,6 @@
         "node_modules": true,
         "package-lock.json": true
     },
-    "typescript.tsdk": "node_modules\\typescript\\lib",
-    "editor.suggest.showStatusBar": false
+    "editor.suggest.showStatusBar": false,
+    "typescript.tsdk": "node_modules\\typescript\\lib"
 }
\ No newline at end of file
diff --git a/benchmark/compression/module/typebox-conditional.ts b/benchmark/compression/module/typebox-conditional.ts
deleted file mode 100644
index 3a12edfa2..000000000
--- a/benchmark/compression/module/typebox-conditional.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { Conditional } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-
-const T = Conditional.Extends(Type.String(), Type.String(), Type.String(), Type.String())
diff --git a/benchmark/compression/module/typebox-custom.ts b/benchmark/compression/module/typebox-custom.ts
deleted file mode 100644
index 8620c02f1..000000000
--- a/benchmark/compression/module/typebox-custom.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { Custom } from 'src/custom/index'
-import { Type } from '@sinclair/typebox'
-
-Custom.Set('custom', (value) => true)
diff --git a/benchmark/compression/module/typebox-errors.ts b/benchmark/compression/module/typebox-errors.ts
new file mode 100644
index 000000000..883bf9614
--- /dev/null
+++ b/benchmark/compression/module/typebox-errors.ts
@@ -0,0 +1,3 @@
+import { ValueErrorType } from '@sinclair/typebox/errors'
+
+console.log(ValueErrorType)
diff --git a/benchmark/compression/module/typebox-format.ts b/benchmark/compression/module/typebox-format.ts
deleted file mode 100644
index 360a2ce85..000000000
--- a/benchmark/compression/module/typebox-format.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { Format } from 'src/format'
-import { Type } from '@sinclair/typebox'
-
-Format.Set('custom', (value) => true)
diff --git a/benchmark/compression/module/typebox-guard.ts b/benchmark/compression/module/typebox-guard.ts
deleted file mode 100644
index 9c453c2d5..000000000
--- a/benchmark/compression/module/typebox-guard.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
-import { Type } from '@sinclair/typebox'
-
-const T = TypeGuard.TSchema(Type.String())
diff --git a/benchmark/compression/module/typebox-hash.ts b/benchmark/compression/module/typebox-hash.ts
deleted file mode 100644
index 94c5787e1..000000000
--- a/benchmark/compression/module/typebox-hash.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { ValueHash } from '@sinclair/typebox/hash'
-
-const H = ValueHash.Create(1)
diff --git a/benchmark/measurement/module/cases.ts b/benchmark/measurement/module/cases.ts
index fb88ceb36..e59f281f2 100644
--- a/benchmark/measurement/module/cases.ts
+++ b/benchmark/measurement/module/cases.ts
@@ -1,42 +1,40 @@
 import { Type } from '@sinclair/typebox'
 
 export namespace Cases {
-  export const Number = Type.Number()
+  export const Literal_String = Type.Literal('hello')
 
-  export const String = Type.String()
+  export const Literal_Number = Type.Literal(1)
+
+  export const Literal_Boolean = Type.Literal(true)
 
-  export const Boolean = Type.Boolean()
+  export const Primitive_Number = Type.Number()
 
-  export const Null = Type.Null()
+  export const Primitive_String = Type.String()
 
-  export const RegEx = Type.RegEx(/foo/, { default: 'foo' })
+  export const Primitive_String_Pattern = Type.RegEx(/foo/, { default: 'foo' })
 
-  export const ObjectA = Type.Object({
-    p0: Type.String(),
-    p1: Type.Number(),
-    p2: Type.Number(),
-    p3: Type.Array(Type.Number(), { minItems: 4 }),
-    p4: Type.Object({
-      x: Type.Number(),
-      y: Type.Number(),
-      z: Type.Number(),
-    }),
-    p5: Type.Object({
-      a: Type.String(),
-      b: Type.String(),
-      c: Type.String(),
+  export const Primitive_Boolean = Type.Boolean()
+
+  export const Primitive_Null = Type.Null()
+
+  export const Object_Unconstrained = Type.Object({
+    number: Type.Number(),
+    negNumber: Type.Number(),
+    maxNumber: Type.Number(),
+    string: Type.String(),
+    longString: Type.String(),
+    boolean: Type.Boolean(),
+    deeplyNested: Type.Object({
+      foo: Type.String(),
+      num: Type.Number(),
+      bool: Type.Boolean(),
     }),
   })
 
-  export const ObjectB = Type.Object(ObjectA.properties, {
+  export const Object_Constrained = Type.Object(Object_Unconstrained.properties, {
     additionalProperties: false,
   })
-
-  export const Tuple = Type.Tuple([Type.String(), Type.Number(), Type.Boolean()])
-
-  export const Union = Type.Union([Type.Object({ x: Type.Number(), y: Type.Number() }), Type.Object({ a: Type.String(), b: Type.String() })], { default: { a: 'a', b: 'b' } })
-
-  export const Recursive = Type.Recursive(
+  export const Object_Recursive = Type.Recursive(
     (Recursive) =>
       Type.Object({
         id: Type.String(),
@@ -75,9 +73,32 @@ export namespace Cases {
     },
   )
 
-  export const Vector4 = Type.Tuple([Type.Number(), Type.Number(), Type.Number(), Type.Number()])
-
-  export const Matrix4 = Type.Array(Type.Array(Type.Number()), {
+  // prettier-ignore
+  export const Tuple_Primitive = Type.Tuple([
+    Type.String(), 
+    Type.Number(), 
+    Type.Boolean()
+  ])
+  // prettier-ignore
+  export const Tuple_Object = Type.Tuple([
+    Type.Object({ x: Type.Number(), y: Type.Number() }), 
+    Type.Object({ a: Type.String(), b: Type.String() })
+  ])
+  // prettier-ignore
+  export const Composite_Intersect = Type.Intersect([
+    Type.Object({ x: Type.Number(), y: Type.Number() }), 
+    Type.Object({ a: Type.String(), b: Type.String() })
+  ], { default: { x: 1, y: 2, a: 'a', b: 'b' } })
+
+  // prettier-ignore
+  export const Composite_Union = Type.Union([
+    Type.Object({ x: Type.Number(), y: Type.Number() }), 
+    Type.Object({ a: Type.String(), b: Type.String() })
+  ], { default: { a: 'a', b: 'b' } })
+
+  export const Math_Vector4 = Type.Tuple([Type.Number(), Type.Number(), Type.Number(), Type.Number()])
+
+  export const Math_Matrix4 = Type.Array(Type.Array(Type.Number()), {
     default: [
       [1, 0, 0, 0],
       [0, 1, 0, 0],
@@ -86,29 +107,27 @@ export namespace Cases {
     ],
   })
 
-  export const Literal_String = Type.Literal('foo')
+  export const Array_Primitive_Number = Type.Array(Type.Number(), { minItems: 4 })
 
-  export const Literal_Number = Type.Literal(1)
-
-  export const Literal_Boolean = Type.Literal(true)
+  export const Array_Primitive_String = Type.Array(Type.String(), { minItems: 4 })
 
-  export const Array_Number = Type.Array(Type.Number(), { minItems: 16 })
+  export const Array_Primitive_Boolean = Type.Array(Type.Boolean(), { minItems: 4 })
 
-  export const Array_String = Type.Array(Type.String(), { minItems: 16 })
+  export const Array_Object_Unconstrained = Type.Array(Object_Unconstrained, { minItems: 4 })
 
-  export const Array_Boolean = Type.Array(Type.Boolean(), { minItems: 16 })
+  export const Array_Object_Constrained = Type.Array(Object_Constrained, { minItems: 4 })
 
-  export const Array_ObjectA = Type.Array(ObjectA, { minItems: 16 })
+  export const Array_Object_Recursive = Type.Array(Object_Recursive, { minItems: 4 })
 
-  export const Array_ObjectB = Type.Array(ObjectB, { minItems: 16 })
+  export const Array_Tuple_Primitive = Type.Array(Tuple_Primitive, { minItems: 4 })
 
-  export const Array_Tuple = Type.Array(Tuple, { minItems: 16 })
+  export const Array_Tuple_Object = Type.Array(Tuple_Object, { minItems: 4 })
 
-  export const Array_Union = Type.Array(Union, { minItems: 16 })
+  export const Array_Composite_Intersect = Type.Array(Composite_Intersect, { minItems: 4 })
 
-  export const Array_Recursive = Type.Array(Recursive, { minItems: 16 })
+  export const Array_Composite_Union = Type.Array(Composite_Union, { minItems: 4 })
 
-  export const Array_Vector4 = Type.Array(Vector4, { minItems: 16 })
+  export const Array_Math_Vector4 = Type.Array(Math_Vector4, { minItems: 4 })
 
-  export const Array_Matrix4 = Type.Array(Matrix4, { minItems: 16 })
+  export const Array_Math_Matrix4 = Type.Array(Math_Matrix4, { minItems: 4 })
 }
diff --git a/benchmark/measurement/module/check.ts b/benchmark/measurement/module/check.ts
index 3b8f975a4..a6e2e4324 100644
--- a/benchmark/measurement/module/check.ts
+++ b/benchmark/measurement/module/check.ts
@@ -1,8 +1,7 @@
 import { Cases } from './cases'
 import { Benchmark } from './benchmark'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
-import { TypeGuard } from '@sinclair/typebox/guard'
-import { TSchema } from '@sinclair/typebox'
+import { TSchema, TypeGuard } from '@sinclair/typebox'
 import { Value } from '@sinclair/typebox/value'
 
 import Ajv from 'ajv'
diff --git a/benchmark/measurement/module/compile.ts b/benchmark/measurement/module/compile.ts
index 1dd039601..98b61c006 100644
--- a/benchmark/measurement/module/compile.ts
+++ b/benchmark/measurement/module/compile.ts
@@ -1,15 +1,14 @@
 import { Cases } from './cases'
 import { Benchmark } from './benchmark'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
-import { TypeGuard } from '@sinclair/typebox/guard'
-import { TSchema } from '@sinclair/typebox'
+import { TSchema, TypeGuard } from '@sinclair/typebox'
 import Ajv from 'ajv'
 
 const ajv = new Ajv() // ensure single instance
 
 export namespace CompileBenchmark {
   function Measure<T extends TSchema>(type: string, schema: T) {
-    const iterations = 2000
+    const iterations = 1000
     console.log('CompileBenchmark.Measure(', type, ')')
     // -------------------------------------------------------------------------------
     // Note: Ajv caches schemas by reference. To ensure we measure actual
@@ -28,7 +27,7 @@ export namespace CompileBenchmark {
       // track duplicate $id (resulting in compile error). It is not possible to ammend
       // recursive $id's without potentially biasing results, so we omit on this case.
       // -------------------------------------------------------------------------------
-      if (type === 'Recursive' || type === 'Array_Recursive') continue
+      if (type === 'Object_Recursive' || type === 'Array_Object_Recursive') continue
 
       yield Measure(type, schema)
     }
diff --git a/benchmark/measurement/module/index.ts b/benchmark/measurement/module/index.ts
index 5b6d43480..65b47f716 100644
--- a/benchmark/measurement/module/index.ts
+++ b/benchmark/measurement/module/index.ts
@@ -9,7 +9,7 @@ export function present(results: Result[]) {
       if (result.value) {
         return {
           ...acc,
-          [result.type.padStart(16, ' ')]: {
+          [result.type.padEnd(26, ' ')]: {
             Iterations: result.compiler.iterations,
             ValueCheck: `${result.value.completed} ms`.padStart(10),
             Ajv: `${result.ajv.completed} ms`.padStart(10),
@@ -20,7 +20,7 @@ export function present(results: Result[]) {
       } else {
         return {
           ...acc,
-          [result.type.padStart(16, ' ')]: {
+          [result.type.padEnd(26, ' ')]: {
             Iterations: result.compiler.iterations,
             Ajv: `${result.ajv.completed} ms`.padStart(10),
             TypeCompiler: `${result.compiler.completed} ms`.padStart(10),
diff --git a/changelog.md b/changelog.md
deleted file mode 100644
index fa1f19caf..000000000
--- a/changelog.md
+++ /dev/null
@@ -1,410 +0,0 @@
-## [0.25.24](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.23)
-
-Updates:
-
-- [331](https://github.com/sinclairzx81/typebox/pull/331) Implements an additional check specific to property types of `required & undefined`. This to ensure the property key exists when the property value extends `undefined`.
-- [331](https://github.com/sinclairzx81/typebox/pull/331) Documentation updates for Ajv and TypeCompiler
-
-Additional:
-
-- [331](https://github.com/sinclairzx81/typebox/pull/331) Remove unusued recursive code paths for create and cast.
-
-## [0.25.23](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.23)
-
-Updates:
-
-- [324](https://github.com/sinclairzx81/typebox/pull/324) TypeScript Language Service now presents JSDoc comments when inferring static object properties. (IntelliSense)
-- [325](https://github.com/sinclairzx81/typebox/pull/325) Additional property inference optimizations.
-
-Additional:
-
-- Huge thank you to Github user [stevezhu](https://github.com/stevezhu) for these excellent contributions.
-
-
-## [0.25.22](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.22)
-
-Updates:
-
-- [323](https://github.com/sinclairzx81/typebox/pull/323) adds compiler support for UTF-16 (unicode) characters for schema identifiers.  
-
-## [0.25.18](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.18)
-
-Updates:
-
-- [307](https://github.com/sinclairzx81/typebox/pull/307) implements date conversion when casting values with `Value.Cast(Type.Date(), ...)`. Castable values include numbers (interpretted as timestamps) and iso8601 string values. Uncastable values will result in dates with values of `1970-01-01T00:00:00.000Z`. This version also includes more robust checks for Dates initialized with invalid values.
-
-## [0.25.11](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.11)
-
-Updates:
-
-- [286](https://github.com/sinclairzx81/typebox/pull/286) implements a FNV1A-64 non cryptographic hashing function in TypeBox. This function should not be used in place of cryptographic hashing functions, rather it's purpose is to provide relatively fast, hashing mechanism to assist with checks for arrays with uniqueItems constraints, specifically for cases where the array may contains reference values (such as objects, arrays, Dates and Uint8Array). This function is provided via `Value.Hash()` for convenience as the hash may be useful to generate a numeric identifier for values (with some considerations to React array rendering in absence of key or identifier)
-
-## [0.25.10](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.10)
-
-Updates:
-
-- [283](https://github.com/sinclairzx81/typebox/pull/283) Updates the custom type validator callback signature to accept a schema instance. The schema instance may include additional constraints (such as options) that may be used during the validation process. `Custom.Set('<Kind>', (schema, value) => { ... })`.
-
-## [0.25.9](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.9)
-
-Updates:
-
-- [282](https://github.com/sinclairzx81/typebox/pull/282) TypeBox now supports custom types. These types require the user to specify a custom `[Kind]` string on the type. Custom types can be registered via `Custom.Set('<Kind>', (value) => { ... })` which allow the TypeCompiler and Value API's to make use of user defined validation logic.
-
-## [0.25.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.0)
-
-Updates:
-
-- [271](https://github.com/sinclairzx81/typebox/pull/271) Adds a new non-standard `Type.Date()` type. This type joins the existing `Type.UInt8Array()` as a promoted extended type used to represent core JavaScript primitives. It's inclusion was prompted by end user requirements to validate Date objects prior to writing them to Date supported API's and where serialization of the Date object is handled internally by the API. 
-
-- [271](https://github.com/sinclairzx81/typebox/pull/271) Redesign of Extended Type representations. Extended types been updated to provide external validators (such as Ajv) additional standard proporties to use when defining the custom schema. These properties are `instanceOf` (used for validating a class `object` instances), and `typeOf` (when validating `value` types). Information on configuring Ajv for these properties can be found in the Ajv section of the TypeBox readme.
-
-## [0.24.49](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.49)
-
-Updates:
-
-- [264](https://github.com/sinclairzx81/typebox/pull/264) TypeBox now provides preliminary support for non-boolean `additionalProperties`. This allows existing `TObject` schemas to be augmented with additional properties of a known type.
-
-Additional:
-
-- TypeBox provides an additional reference `codegen` module for generating raw JSON Schema from TypeScript types via the TS compiler API. This generator may be used in future tooling.
-
-## [0.24.44](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.44)
-
-Updates:
-- [189](https://github.com/sinclairzx81/typebox/pull/189) Both `Value.Error(T, value)` and `TypeCheck.Error(value)` now return an iterator for validation errors.
-- [191](https://github.com/sinclairzx81/typebox/pull/191) TypeBox now provides a `TypeGuard` API that can be used to check the structural validity of TypeBox type. The TypeGuard can be used in reflection / code generation scenarios to resolve the appropriate inner `TSchema` type while traversing a outer type.
-- [197](https://github.com/sinclairzx81/typebox/pull/197) TypeBox now implements conditional runtime type mapping. This functionality is offered as seperate import for the `0.24.0` release but may be provided as standard type in later releases. This API enables `type T = Foo extends Bar ? true : false` conditional checks to be implemented at runtime. This API also provides the `Exclude` and `Extract` utility types which are implemented through conditional types in TypeScript.
-- [199](https://github.com/sinclairzx81/typebox/pull/199) TypeBox now provides better support for varidiac function and constructor signatures. Currently Variadics are mapped through `Tuple` types.
-- [200](https://github.com/sinclairzx81/typebox/pull/200) The types `TPick` and `TOmit` now support types of `TUnion<TLiteral<string>[]>` to be used to select properties. Additionally, `KeyOf` now returns `TUnion<TLiteral<string>[]>`, allowing `KeyOf` schemas to be passed to `TPick` and `TOmit`.
-- [214](https://github.com/sinclairzx81/typebox/pull/214) TypeBox now provides better support for i18n. To achieve this, TypeBox includes fixed mappable error codes on the `ValueError` type. These codes can be used by external implementors to create localized error messages. TypeBox may include localized error codes as an optional import in future releases.
-- [288](https://github.com/sinclairzx81/typebox/pull/228) TypeBox now allows users to implement custom string validator formats. These formats are internally shared between the `Value` and `TypeCompiler` API's. TypeBox does not currently provide any built in formats, however the standard expected set (email, uuid, uri, etc) may be provided via optional import (inline with ajv-formats usage)
-- [229](https://github.com/sinclairzx81/typebox/pull/229) The `Value.Cast()` function now implements automatic coersion of string, number and boolean types.
-- [231](https://github.com/sinclairzx81/typebox/pull/231) TypeBox provides a new `Value.Diff<T>()` and `Value.Patch<T>()` utility API for JavaScript values. This API is intended to provide a basis for the efficient transmission of state updates across a network. This API can diff any JavaScript value (typed or untyped) but is recommended to be used in conjunction with a formal static type.
-- [236](https://github.com/sinclairzx81/typebox/pull/236) TypeBox now implements the `TNever` type. This type is analogous to TypeScript's `never` type and is used in instances a composition results in a non-reconcilable type. Currently this type is implemented for empty `TUnion<[]>` types only. Future releases may utilize this type for planned updates to `TIntersect` (for example `string & number` resolves to `never`)
-- [241](https://github.com/sinclairzx81/typebox/pull/241) [247](https://github.com/sinclairzx81/typebox/pull/247) TypeBox now exposes a ValuePointer API that can be used to mutate a value via an RFC6901 JSON Pointer. Previously this functionality was internally used by `Value.Diff()` and `Value.Patch()` functions but is now offered as an optional import for implementations that need to update values manually through pointer references.
-
-Additional:
-
-- This project now includes two reference code generation utilities that can be used in custom build tooling. The first is `TypeScriptCodeGen` which will remap TypeScript `interface` and `type` definitions to TypeBox types. The second is `TypeBoxCodeGen` which will map existing TypeBox types into TypeScript type definitions. These implementations are not expected to be part of the TypeBox package, but users are free to clone and enhance them in their existing tool chains. Reference implementations can be found https://github.com/sinclairzx81/typebox/tree/master/codegen
-
-
-
-## [0.24.15](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.15)
-
-Added:
-- `Conditional.Extends(...)` This enables TypeBox to conditionally map types inline with TypeScripts structural equivelence checks. Tested against TypeScript 4.7.4.
-- `Conditional.Extract(...)` Which analogs TypeScripts `Extract<...>` utility type. Additional information [here](https://www.typescriptlang.org/docs/handbook/utility-types.html#extracttype-union) 
-- `Conditional.Exclude(...)` Which analogs TypeScripts `Exclude<...>` utility type. Additional information [here](https://www.typescriptlang.org/docs/handbook/utility-types.html#excludeuniontype-excludedmembers)
-- `Type.Parameters(...)` Returns the parameters of a `TFunction` as a `TTuple`
-- `Type.ReturnType(...)` Returns the return type schema of a `TFunction`
-- `Type.ConstructorParameters(...)` Returns the parameters of a `TConstructor` as a `TTuple`
-- `Type.InstanceType(...)` Returns the instance type schema of a `TConstructor`
- 
-## [0.24.8](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.8)
-
-Added:
-- `Value.Cast(T, value)` structurally casts a value into another form while retaining information within the original value.
-- `Value.Check(T, value)` provides slow dynamic type checking for values. For performance, one should consider the `TypeCompiler` or `Ajv` validator.
-- `Value.Errors(T, value)` returns an iterable iterator errors found in a given value.
-
-## [0.24.6](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.6)
-
-Added:
-
-- TypeBox now offers a `TypeGuard` module for structurally checking TypeBox schematics. This module can be used in runtime type reflection scenarios where it's helpful to test a schema is of a particular form. This module can be imported under the `@sinclair/typebox/guard` import path.
-
-Example:
-
-```typescript
-import { TypeGuard } from '@sinclair/typebox/guard'
-
-const T: any = {}                                    // T is any
-
-const { type } = T                                   // unsafe: type is any
-
-if(TypeGuard.TString(T)) {
-    
-  const { type } = T                                 // safe: type is 'string'
-}
-
-```
-
-## [0.24.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.0)
-
-Changes:
-
-- The `kind` and `modifier` keywords are now expressed as symbol keys. This change allows AJV to leverage TypeBox schemas directly without explicit configuration of `kind` and `modifier` in strict mode.
-- `Type.Intersect([...])` now returns a composite `TObject` instead of a `allOf` schema representation. This change allows intersected types to be leveraged in calls to `Omit`, `Pick`, `Partial`, `Required`.
-- `Type.Void(...)` now generates a `{ type: null }` schema representation. This is principally used for RPC implementations where a RPC target function needs to respond with a serializable value for `void` return.
-- `Type.Rec(...)` renamed to `Type.Recursive(...)` and now supports non-mutual recursive type inference.
-
-Added:
-
-- `Type.Unsafe<T>(...)`. This type enables custom schema representations whose static type is informed by generic type T.
-- `Type.Uint8Array(...)`. This is a non-standard schema that can be configured on AJV to enable binary buffer range validation.
-- Added optional extended `design` property on all schema options. This property can be used to specify design time metadata when rendering forms.
-
-Compiler:
-
-- TypeBox now provides an optional experimental type compiler that can be used to validate types without AJV. This compiler is not a standard JSON schema compiler and will only compile TypeBox's known schema representations. For full JSON schema validation, AJV should still be the preference. This compiler is a work in progress.
-
-Value:
-
-- TypeBox now provides a value generator that can generate default values from TypeBox types.
-
-Breaking Changes:
-
-- `Type.Intersect(...)` is constrained to accept types of `TObject` only.
-- `Type.Namespace(...)` has been removed.
-- The types `TUnion`, `TEnum`, `KeyOf` and `TLiteral<TString>[]` are all now expressed via `allOf`. For Open API users, Please consider `Type.Unsafe()` to express `enum` string union representations. Documentation on using `Type.Unsafe()` can be found [here](https://github.com/sinclairzx81/typebox#Unsafe-Types)
-
-## [0.23.3](https://www.npmjs.com/package/@sinclair/typebox/v/0.23.3)
-
-Updates:
-
-- Fix: Rename BoxKind to NamespaceKind
-
-## [0.23.1](https://www.npmjs.com/package/@sinclair/typebox/v/0.23.1)
-
-Updates:
-
-- The `Type.KeyOf(...)` type can now accept references of `Type.Ref(TObject)`
-
-## [0.23.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.23.0)
-
-Updates:
-
-- The types `Type.Namespace(...)` and `Type.Ref(...)` are promoted to `Standard`.
-- TypeBox now includes an additional type named `TRef<...>` that is returned on calls to `Type.Ref(...)`. The `TRef<...>` includes a new `RefKind` symbol for introspection of the reference type.
-- TypeBox now maintains an internal dictionary of all schemas passed that contain an `$id` property. This dictionary is checked whenever a user attempts to reference a type and will throw if attempting to reference a target schema with no `$id`.
-- The types `Type.Partial(...)`, `Type.Required(...)`, `Type.Omit()` and `Type.Pick(...)` now support reference types. Note that when using these functions with references, TypeBox will replicate the source schema and apply the nessasary modifiers to the replication.
-
-## [0.22.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.22.0)
-
-Updates:
-
-- The type `TSchema` is now expressed as an HKT compatible interface. All types now extend the `TSchema` interface and are themselves also expressed as interfaces. This work was undertaken to explore recursive type aliases in future releases.
-- The phantom property `_infer` has been renamed to `$static`. Callers should not interact with this property as it will always be `undefined` and used exclusively for optimizing type inference in TypeScript 4.5 and above.
-- TypeBox re-adds the feature to deeply introspect schema properties. This feature was temporarily removed on the `0.21.0` update to resolve deep instantiation errors on TypeScript 4.5.
-- The `Type.Box(...)` and `Type.Rec(...)` functions internally rename the property `definitions` to `$defs` inline with JSON schema draft 2019-09 conventions. Reference [here](https://opis.io/json-schema/2.x/definitions.html).
-
-## [0.21.2](https://www.npmjs.com/package/@sinclair/typebox/v/0.21.2)
-
-Updates:
-
-- TypeBox now correctly infers for nested union and intersect types.
-
-Before
-
-```typescript
-const A = Type.Object({ a: Type.String() })
-const B = Type.Object({ b: Type.String() })
-const C = Type.Object({ c: Type.String() })
-const T = Type.Intersect([A, Type.Union([B, C])])
-
-// type T = { a: string } & { b: string } & { c: string } 
-```
-After
-
-```typescript
-const A = Type.Object({ a: Type.String() })
-const B = Type.Object({ b: Type.String() })
-const C = Type.Object({ c: Type.String() })
-const T = Type.Intersect([A, Type.Union([B, C])])
-
-// type T = { a: string } & ({ b: string } | { c: string })
-```
-
-## [0.21.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.21.0)
-
-Updates:
-
-- TypeBox static inference has been updated inline with additional inference constraints added in TypeScript 4.5. All types now include a phantom `_infer` property which contains the inference TS type for a given schema. The type of this property is inferred at the construction of the schema, and referenced directly via `Static<T>`.
-- `Type.Box(...)` has been renamed to `Type.Namespace(...)` to draw an analogy with XML's `xmlns` XSD types.
-
-## [0.20.1](https://www.npmjs.com/package/@sinclair/typebox/v/0.20.1)
-
-Updates:
-
-- TypeBox mandates TypeScript compiler version `4.3.5` and above.
-
-## [0.20.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.20.0)
-
-Updates:
-
-- Function `Type.Rec(...)` signature change.
-- Minor documentation updates.
-
-Notes:
-
-The `Type.Rec(...)` function signature has been changed to allow passing the `$id` as a custom option. This is to align `Type.Rec(...)` with other functions that accept `$id` as an option. `Type.Rec(...)` can work with or without an explicit `$id`, but it is recommend to specify one if the recursive type is nested in an outer schema.
-
-```typescript
-const Node = Type.Rec(Self => Type.Object({
-    id: Type.String(),
-    nodes: Type.Array(Self)
-}), { $id: 'Node' })
-```
-
-## [0.19.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.19.0)
-
-Updates:
-
-- Function `Type.Box(...)` removes `$id` parameter as first argument.
-- Function `Type.Ref(...)` is now overloaded to support referencing `Type.Box(...)` and `TSchema`.
-
-Notes:
-
-This update changes the signature of `Type.Box(...)` and removes the explicit `$id` passing on the first parameter. The `$id` must be passed as an option if the caller wants to reference that type.
-
-```typescript
-const T = Type.String({ $id: 'T' })
-
-const B = Type.Box({ T }, { $id: 'B' })
-
-const R1 = Type.Ref(T)                   // const R1 = { $ref: 'T' }
-
-const R2 = Type.Ref(B, 'T')              // const R2 = { $ref: 'B#/definitions/T' }
-```
-
-## [0.18.1](https://www.npmjs.com/package/@sinclair/typebox/v/0.18.1)
-
-- Function `Type.Enum(...)` now expressed with `anyOf`. This to remove the `allowUnionTypes` configuration required to use `enum` with in AJV strict.
-- Function `Type.Rec(...)` now takes a required `$id` as the first parameter.
-- Function `Type.Strict(...)` no longer includes a `$schema`. Callers can now optionally pass `CustomOptions` on `Type.Strict(...)`
-
-## [0.18.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.18.0)
-
-Changes:
-
-- Function `Type.Intersect(...)` is now implemented with `allOf` and constrained with `unevaluatedProperties` (draft `2019-09`)
-- Function `Type.Dict(...)` has been deprecated and replaced with `Type.Record(...)`.
-- Function `Type.Strict(...)` now includes the `$schema` property referencing the `2019-09` draft.
-
-### Type.Intersect(...)
-
-TypeBox now targets JSON schema draft `2019-09` for expressing `Type.Intersect(...)`. This is now expressed via `allOf` with additionalProperties constrained with `unevaluatedProperties`. Note that `unevaluatedProperties` is a feature of the `2019-09` specification.
-
-### Type.Record(K, V)
-
-TypeBox has deprecated `Type.Dict(...)` in favor of the more generic `Type.Record(...)`. Where as `Type.Dict(...)` was previously expressed with `additionalProperties: { ... }`, `Type.Record(...)` is expressed with `patternProperties` and supports both `string` and `number` indexer keys. Additionally, `Type.Record(...)` supports string union arguments. This is analogous to TypeScript's utility record type `Record<'a' | 'b' | 'c', T>`.
-
-## [0.17.7](https://www.npmjs.com/package/@sinclair/typebox/v/0.17.7)
-
-Changes:
-
-- Added optional `$id` argument on `Type.Rec()`.
-- Documentation updates.
-
-## [0.17.6](https://www.npmjs.com/package/@sinclair/typebox/v/0.17.6)
-
-Changes:
-
-- Added `Type.Rec(...)` function.
-
-Notes:
-
-This update introduces the `Type.Rec()` function for enabling Recursive Types. Please note that due to current inference limitations in TypeScript, TypeBox is unable to infer the type and resolves inner types to `any`. 
-
-This functionality enables for complex self referential schemas to be composed. The following creates a binary expression syntax node with the expression self referential for left and right oprands.
-
-```typescript
-const Operator = Type.Union([
-    Type.Literal('+'),
-    Type.Literal('-'),
-    Type.Literal('/'),
-    Type.Literal('*')
-])
-
-type Expression = Static<typeof Expression>
-
-// Defines a self referencing type.
-const Expression = Type.Rec(Self => Type.Object({
-    left:     Type.Union([Self, Type.Number()]), 
-    right:    Type.Union([Self, Type.Number()]),
-    operator: Operator
-}))
-
-function evaluate(expression: Expression): number {
-    const left = typeof expression.left  !== 'number' 
-        ? evaluate(expression.left as Expression)  // assert as Expression
-        : expression.left
-    const right = typeof expression.right  !== 'number' 
-        ? evaluate(expression.right as Expression) // assert as Expression
-        : expression.right
-    switch(expression.operator) {
-        case '+': return left + right
-        case '-': return left - right
-        case '*': return left * right
-        case '/': return left / right
-    }
-}
-
-const result = evaluate({
-    left: {
-        left: 10, 
-        operator: '*',
-        right: 4, 
-    },
-    operator: '+',
-    right: 2,
-}) // -> 42
-```
-
-This functionality is flagged as `EXPERIMENTAL` and awaits community feedback.
-
-## [0.17.4](https://www.npmjs.com/package/@sinclair/typebox/v/0.17.4)
-
-Changes:
-
-- Added `Type.Box()` and `Type.Ref()` functions.
-
-Notes:
-
-This update provides the `Type.Box()` function to enable common related schemas to grouped under a common namespace; typically expressed as a `URI`. This functionality is primarily geared towards allowing one to define a common set of domain objects that may be shared across application domains running over a network. The `Type.Box()` is intended to be an analog to `XML` `xmlns` namespacing.
-
-The `Type.Ref()` function is limited to referencing from boxes only. The following is an example.
-
-```typescript
-// Domain objects for the fruit service.
-const Fruit = Type.Box('https://fruit.domain.com', {
-    Apple:  Type.Object({ ... }),
-    Orange: Type.Object({ ... }),
-})
-
-// An order referencing types of the fruit service.
-const Order = Type.Object({
-    id:       Type.String(),
-    quantity: Type.Number(),
-    item:     Type.Union([
-        Type.Ref(Fruit, 'Apple'),
-        Type.Ref(Fruit, 'Orange')
-    ])
-})
-```
-> Note: As of this release, the `Type.Omit()`, `Type.Pick()`, `Type.Partial()`, `Type.Readonly()` and `Type.Intersect()` functions do not work with Reference Types. This may change in later revisions.
-
-For validation using `Ajv`, its possible to apply the `Box` directly as a schema.
-
-```typescript
-ajv.addSchema(Fruit) // makes all boxed types known to Ajv
-```
-
-This functionality is flagged as `EXPERIMENTAL` and awaits community feedback.
-
-## [0.17.1](https://www.npmjs.com/package/@sinclair/typebox/v/0.17.1)
-
-- Remove default `additionalProperties: false` constraint from all object schemas.
-
-This update removes the `additionalProperties: false` constraint on all object schemas. This constraint was introduced on `0.16.x` but has resulted in significant downstream problems composing schemas whose types `intersect`. This is due to a JSON schema design principle where constraints should only be added (never removed), and that intersection types may require removal of the `additionalProperties` constraint in some cases, this had resulted in some ambiguity with respect to how TypeBox should handle such intersections. 
-
-This update can also be seen as a precursor towards TypeBox potentially leveraging `unevaluatedProperties` for type intersection in future releases. Implementors should take note that in order to constrain the schema to known properties, one should apply the `additionalProperties: false` as the second argument to `Type.Object({...})`. 
-
-```typescript
-const T = Type.Object({
-    a: Type.String(),
-    b: Type.Number()
-}, { 
-    additionalProperties: false 
-})
diff --git a/changelog/0.17.1.md b/changelog/0.17.1.md
new file mode 100644
index 000000000..b458c0b15
--- /dev/null
+++ b/changelog/0.17.1.md
@@ -0,0 +1,15 @@
+## [0.17.1](https://www.npmjs.com/package/@sinclair/typebox/v/0.17.1)
+
+- Remove default `additionalProperties: false` constraint from all object schemas.
+
+This update removes the `additionalProperties: false` constraint on all object schemas. This constraint was introduced on `0.16.x` but has resulted in significant downstream problems composing schemas whose types `intersect`. This is due to a JSON schema design principle where constraints should only be added (never removed), and that intersection types may require removal of the `additionalProperties` constraint in some cases, this had resulted in some ambiguity with respect to how TypeBox should handle such intersections. 
+
+This update can also be seen as a precursor towards TypeBox potentially leveraging `unevaluatedProperties` for type intersection in future releases. Implementers should take note that in order to constrain the schema to known properties, one should apply the `additionalProperties: false` as the second argument to `Type.Object({...})`. 
+
+```typescript
+const T = Type.Object({
+    a: Type.String(),
+    b: Type.Number()
+}, { 
+    additionalProperties: false 
+})
\ No newline at end of file
diff --git a/changelog/0.17.4.md b/changelog/0.17.4.md
new file mode 100644
index 000000000..07a8cf5e4
--- /dev/null
+++ b/changelog/0.17.4.md
@@ -0,0 +1,38 @@
+## [0.17.4](https://www.npmjs.com/package/@sinclair/typebox/v/0.17.4)
+
+Changes:
+
+- Added `Type.Box()` and `Type.Ref()` functions.
+
+Notes:
+
+This update provides the `Type.Box()` function to enable common related schemas to grouped under a common namespace; typically expressed as a `URI`. This functionality is primarily geared towards allowing one to define a common set of domain objects that may be shared across application domains running over a network. The `Type.Box()` is intended to be an analog to `XML` `xmlns` namespaces.
+
+The `Type.Ref()` function is limited to referencing from boxes only. The following is an example.
+
+```typescript
+// Domain objects for the fruit service.
+const Fruit = Type.Box('https://fruit.domain.com', {
+    Apple:  Type.Object({ ... }),
+    Orange: Type.Object({ ... }),
+})
+
+// An order referencing types of the fruit service.
+const Order = Type.Object({
+    id:       Type.String(),
+    quantity: Type.Number(),
+    item:     Type.Union([
+        Type.Ref(Fruit, 'Apple'),
+        Type.Ref(Fruit, 'Orange')
+    ])
+})
+```
+> Note: As of this release, the `Type.Omit()`, `Type.Pick()`, `Type.Partial()`, `Type.Readonly()` and `Type.Intersect()` functions do not work with Reference Types. This may change in later revisions.
+
+For validation using `Ajv`, its possible to apply the `Box` directly as a schema.
+
+```typescript
+ajv.addSchema(Fruit) // makes all boxed types known to Ajv
+```
+
+This functionality is flagged as `EXPERIMENTAL` and awaits community feedback.
\ No newline at end of file
diff --git a/changelog/0.17.6.md b/changelog/0.17.6.md
new file mode 100644
index 000000000..291ea5f3e
--- /dev/null
+++ b/changelog/0.17.6.md
@@ -0,0 +1,56 @@
+## [0.17.6](https://www.npmjs.com/package/@sinclair/typebox/v/0.17.6)
+
+Changes:
+
+- Added `Type.Rec(...)` function.
+
+Notes:
+
+This update introduces the `Type.Rec()` function for enabling Recursive Types. Please note that due to current inference limitations in TypeScript, TypeBox is unable to infer the type and resolves inner types to `any`. 
+
+This functionality enables for complex self referential schemas to be composed. The following creates a binary expression syntax node with the expression self referential for left and right operands.
+
+```typescript
+const Operator = Type.Union([
+    Type.Literal('+'),
+    Type.Literal('-'),
+    Type.Literal('/'),
+    Type.Literal('*')
+])
+
+type Expression = Static<typeof Expression>
+
+// Defines a self referencing type.
+const Expression = Type.Rec(Self => Type.Object({
+    left:     Type.Union([Self, Type.Number()]), 
+    right:    Type.Union([Self, Type.Number()]),
+    operator: Operator
+}))
+
+function evaluate(expression: Expression): number {
+    const left = typeof expression.left  !== 'number' 
+        ? evaluate(expression.left as Expression)  // assert as Expression
+        : expression.left
+    const right = typeof expression.right  !== 'number' 
+        ? evaluate(expression.right as Expression) // assert as Expression
+        : expression.right
+    switch(expression.operator) {
+        case '+': return left + right
+        case '-': return left - right
+        case '*': return left * right
+        case '/': return left / right
+    }
+}
+
+const result = evaluate({
+    left: {
+        left: 10, 
+        operator: '*',
+        right: 4, 
+    },
+    operator: '+',
+    right: 2,
+}) // -> 42
+```
+
+This functionality is flagged as `EXPERIMENTAL` and awaits community feedback.
\ No newline at end of file
diff --git a/changelog/0.18.0.md b/changelog/0.18.0.md
new file mode 100644
index 000000000..88a7d4f2e
--- /dev/null
+++ b/changelog/0.18.0.md
@@ -0,0 +1,22 @@
+## [0.18.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.18.0)
+
+Changes:
+
+- Function `Type.Intersect(...)` is now implemented with `allOf` and constrained with `unevaluatedProperties` (draft `2019-09`)
+- Function `Type.Dict(...)` has been deprecated and replaced with `Type.Record(...)`.
+- Function `Type.Strict(...)` now includes the `$schema` property referencing the `2019-09` draft.
+
+### Type.Intersect(...)
+
+TypeBox now targets JSON schema draft `2019-09` for expressing `Type.Intersect(...)`. This is now expressed via `allOf` with additionalProperties constrained with `unevaluatedProperties`. Note that `unevaluatedProperties` is a feature of the `2019-09` specification.
+
+### Type.Record(K, V)
+
+TypeBox has deprecated `Type.Dict(...)` in favor of the more generic `Type.Record(...)`. Where as `Type.Dict(...)` was previously expressed with `additionalProperties: { ... }`, `Type.Record(...)` is expressed with `patternProperties` and supports both `string` and `number` indexer keys. Additionally, `Type.Record(...)` supports string union arguments. This is analogous to TypeScript's utility record type `Record<'a' | 'b' | 'c', T>`.
+
+## [0.17.7](https://www.npmjs.com/package/@sinclair/typebox/v/0.17.7)
+
+Changes:
+
+- Added optional `$id` argument on `Type.Rec()`.
+- Documentation updates.
\ No newline at end of file
diff --git a/changelog/0.18.1.md b/changelog/0.18.1.md
new file mode 100644
index 000000000..1a0bbe7f9
--- /dev/null
+++ b/changelog/0.18.1.md
@@ -0,0 +1,5 @@
+## [0.18.1](https://www.npmjs.com/package/@sinclair/typebox/v/0.18.1)
+
+- Function `Type.Enum(...)` now expressed with `anyOf`. This to remove the `allowUnionTypes` configuration required to use `enum` with in AJV strict.
+- Function `Type.Rec(...)` now takes a required `$id` as the first parameter.
+- Function `Type.Strict(...)` no longer includes a `$schema`. Callers can now optionally pass `CustomOptions` on `Type.Strict(...)`
\ No newline at end of file
diff --git a/changelog/0.19.0.md b/changelog/0.19.0.md
new file mode 100644
index 000000000..377ccdbff
--- /dev/null
+++ b/changelog/0.19.0.md
@@ -0,0 +1,20 @@
+## [0.19.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.19.0)
+
+Updates:
+
+- Function `Type.Box(...)` removes `$id` parameter as first argument.
+- Function `Type.Ref(...)` is now overloaded to support referencing `Type.Box(...)` and `TSchema`.
+
+Notes:
+
+This update changes the signature of `Type.Box(...)` and removes the explicit `$id` passing on the first parameter. The `$id` must be passed as an option if the caller wants to reference that type.
+
+```typescript
+const T = Type.String({ $id: 'T' })
+
+const B = Type.Box({ T }, { $id: 'B' })
+
+const R1 = Type.Ref(T)                   // const R1 = { $ref: 'T' }
+
+const R2 = Type.Ref(B, 'T')              // const R2 = { $ref: 'B#/definitions/T' }
+```
\ No newline at end of file
diff --git a/changelog/0.20.0.md b/changelog/0.20.0.md
new file mode 100644
index 000000000..80a01da97
--- /dev/null
+++ b/changelog/0.20.0.md
@@ -0,0 +1,17 @@
+## [0.20.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.20.0)
+
+Updates:
+
+- Function `Type.Rec(...)` signature change.
+- Minor documentation updates.
+
+Notes:
+
+The `Type.Rec(...)` function signature has been changed to allow passing the `$id` as a custom option. This is to align `Type.Rec(...)` with other functions that accept `$id` as an option. `Type.Rec(...)` can work with or without an explicit `$id`, but it is recommend to specify one if the recursive type is nested in an outer schema.
+
+```typescript
+const Node = Type.Rec(Self => Type.Object({
+    id: Type.String(),
+    nodes: Type.Array(Self)
+}), { $id: 'Node' })
+```
\ No newline at end of file
diff --git a/changelog/0.20.1.md b/changelog/0.20.1.md
new file mode 100644
index 000000000..2dfec120f
--- /dev/null
+++ b/changelog/0.20.1.md
@@ -0,0 +1,5 @@
+## [0.20.1](https://www.npmjs.com/package/@sinclair/typebox/v/0.20.1)
+
+Updates:
+
+- TypeBox mandates TypeScript compiler version `4.3.5` and above.
\ No newline at end of file
diff --git a/changelog/0.21.0.md b/changelog/0.21.0.md
new file mode 100644
index 000000000..31df5f78f
--- /dev/null
+++ b/changelog/0.21.0.md
@@ -0,0 +1,7 @@
+## [0.21.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.21.0)
+
+Updates:
+
+- TypeBox static inference has been updated inline with additional inference constraints added in TypeScript 4.5. All types now include a phantom `_infer` property which contains the inference TS type for a given schema. The type of this property is inferred at the construction of the schema, and referenced directly via `Static<T>`.
+- `Type.Box(...)` has been renamed to `Type.Namespace(...)` to draw an analogy with XML's `xmlns` XSD types.
+
diff --git a/changelog/0.21.2.md b/changelog/0.21.2.md
new file mode 100644
index 000000000..12d31df53
--- /dev/null
+++ b/changelog/0.21.2.md
@@ -0,0 +1,26 @@
+## [0.21.2](https://www.npmjs.com/package/@sinclair/typebox/v/0.21.2)
+
+Updates:
+
+- TypeBox now correctly infers for nested union and intersect types.
+
+Before
+
+```typescript
+const A = Type.Object({ a: Type.String() })
+const B = Type.Object({ b: Type.String() })
+const C = Type.Object({ c: Type.String() })
+const T = Type.Intersect([A, Type.Union([B, C])])
+
+// type T = { a: string } & { b: string } & { c: string } 
+```
+After
+
+```typescript
+const A = Type.Object({ a: Type.String() })
+const B = Type.Object({ b: Type.String() })
+const C = Type.Object({ c: Type.String() })
+const T = Type.Intersect([A, Type.Union([B, C])])
+
+// type T = { a: string } & ({ b: string } | { c: string })
+```
\ No newline at end of file
diff --git a/changelog/0.22.0.md b/changelog/0.22.0.md
new file mode 100644
index 000000000..f65eeeb7a
--- /dev/null
+++ b/changelog/0.22.0.md
@@ -0,0 +1,8 @@
+## [0.22.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.22.0)
+
+Updates:
+
+- The type `TSchema` is now expressed as an HKT compatible interface. All types now extend the `TSchema` interface and are themselves also expressed as interfaces. This work was undertaken to explore recursive type aliases in future releases.
+- The phantom property `_infer` has been renamed to `$static`. Callers should not interact with this property as it will always be `undefined` and used exclusively for optimizing type inference in TypeScript 4.5 and above.
+- TypeBox re-adds the feature to deeply introspect schema properties. This feature was temporarily removed on the `0.21.0` update to resolve deep instantiation errors on TypeScript 4.5.
+- The `Type.Box(...)` and `Type.Rec(...)` functions internally rename the property `definitions` to `$defs` inline with JSON schema draft 2019-09 conventions. Reference [here](https://opis.io/json-schema/2.x/definitions.html).
\ No newline at end of file
diff --git a/changelog/0.23.0.md b/changelog/0.23.0.md
new file mode 100644
index 000000000..5dce7d99f
--- /dev/null
+++ b/changelog/0.23.0.md
@@ -0,0 +1,8 @@
+## [0.23.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.23.0)
+
+Updates:
+
+- The types `Type.Namespace(...)` and `Type.Ref(...)` are promoted to `Standard`.
+- TypeBox now includes an additional type named `TRef<...>` that is returned on calls to `Type.Ref(...)`. The `TRef<...>` includes a new `RefKind` symbol for introspection of the reference type.
+- TypeBox now maintains an internal dictionary of all schemas passed that contain an `$id` property. This dictionary is checked whenever a user attempts to reference a type and will throw if attempting to reference a target schema with no `$id`.
+- The types `Type.Partial(...)`, `Type.Required(...)`, `Type.Omit()` and `Type.Pick(...)` now support reference types. Note that when using these functions with references, TypeBox will replicate the source schema and apply the necessary modifiers to the replication.
\ No newline at end of file
diff --git a/changelog/0.23.1.md b/changelog/0.23.1.md
new file mode 100644
index 000000000..565f779ba
--- /dev/null
+++ b/changelog/0.23.1.md
@@ -0,0 +1,5 @@
+## [0.23.1](https://www.npmjs.com/package/@sinclair/typebox/v/0.23.1)
+
+Updates:
+
+- The `Type.KeyOf(...)` type can now accept references of `Type.Ref(TObject)`
\ No newline at end of file
diff --git a/changelog/0.23.3.md b/changelog/0.23.3.md
new file mode 100644
index 000000000..bb89450bc
--- /dev/null
+++ b/changelog/0.23.3.md
@@ -0,0 +1,5 @@
+## [0.23.3](https://www.npmjs.com/package/@sinclair/typebox/v/0.23.3)
+
+Updates:
+
+- Fix: Rename BoxKind to NamespaceKind
\ No newline at end of file
diff --git a/changelog/0.24.0.md b/changelog/0.24.0.md
new file mode 100644
index 000000000..b433b5827
--- /dev/null
+++ b/changelog/0.24.0.md
@@ -0,0 +1,28 @@
+## [0.24.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.0)
+
+Changes:
+
+- The `kind` and `modifier` keywords are now expressed as symbol keys. This change allows AJV to leverage TypeBox schemas directly without explicit configuration of `kind` and `modifier` in strict mode.
+- `Type.Intersect([...])` now returns a composite `TObject` instead of a `allOf` schema representation. This change allows intersected types to be leveraged in calls to `Omit`, `Pick`, `Partial`, `Required`.
+- `Type.Void(...)` now generates a `{ type: null }` schema representation. This is principally used for RPC implementations where a RPC target function needs to respond with a serializable value for `void` return.
+- `Type.Rec(...)` renamed to `Type.Recursive(...)` and now supports non-mutual recursive type inference.
+
+Added:
+
+- `Type.Unsafe<T>(...)`. This type enables custom schema representations whose static type is informed by generic type T.
+- `Type.Uint8Array(...)`. This is a non-standard schema that can be configured on AJV to enable binary buffer range validation.
+- Added optional extended `design` property on all schema options. This property can be used to specify design time metadata when rendering forms.
+
+Compiler:
+
+- TypeBox now provides an optional experimental type compiler that can be used to validate types without AJV. This compiler is not a standard JSON schema compiler and will only compile TypeBox's known schema representations. For full JSON schema validation, AJV should still be the preference. This compiler is a work in progress.
+
+Value:
+
+- TypeBox now provides a value generator that can generate default values from TypeBox types.
+
+Breaking Changes:
+
+- `Type.Intersect(...)` is constrained to accept types of `TObject` only.
+- `Type.Namespace(...)` has been removed.
+- The types `TUnion`, `TEnum`, `KeyOf` and `TLiteral<TString>[]` are all now expressed via `allOf`. For Open API users, Please consider `Type.Unsafe()` to express `enum` string union representations. Documentation on using `Type.Unsafe()` can be found [here](https://github.com/sinclairzx81/typebox#Unsafe-Types)
\ No newline at end of file
diff --git a/changelog/0.24.15.md b/changelog/0.24.15.md
new file mode 100644
index 000000000..69745b875
--- /dev/null
+++ b/changelog/0.24.15.md
@@ -0,0 +1,10 @@
+## [0.24.15](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.15)
+
+Added:
+- `Conditional.Extends(...)` This enables TypeBox to conditionally map types inline with TypeScripts structural equivalence checks. Tested against TypeScript 4.7.4.
+- `Conditional.Extract(...)` Which analogs TypeScripts `Extract<...>` utility type. Additional information [here](https://www.typescriptlang.org/docs/handbook/utility-types.html#extracttype-union) 
+- `Conditional.Exclude(...)` Which analogs TypeScripts `Exclude<...>` utility type. Additional information [here](https://www.typescriptlang.org/docs/handbook/utility-types.html#excludeuniontype-excludedmembers)
+- `Type.Parameters(...)` Returns the parameters of a `TFunction` as a `TTuple`
+- `Type.ReturnType(...)` Returns the return type schema of a `TFunction`
+- `Type.ConstructorParameters(...)` Returns the parameters of a `TConstructor` as a `TTuple`
+- `Type.InstanceType(...)` Returns the instance type schema of a `TConstructor`
\ No newline at end of file
diff --git a/changelog/0.24.44.md b/changelog/0.24.44.md
new file mode 100644
index 000000000..e5aac8bde
--- /dev/null
+++ b/changelog/0.24.44.md
@@ -0,0 +1,18 @@
+## [0.24.44](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.44)
+
+Updates:
+- [189](https://github.com/sinclairzx81/typebox/pull/189) Both `Value.Error(T, value)` and `TypeCheck.Error(value)` now return an iterator for validation errors.
+- [191](https://github.com/sinclairzx81/typebox/pull/191) TypeBox now provides a `TypeGuard` API that can be used to check the structural validity of TypeBox type. The TypeGuard can be used in reflection / code generation scenarios to resolve the appropriate inner `TSchema` type while traversing a outer type.
+- [197](https://github.com/sinclairzx81/typebox/pull/197) TypeBox now implements conditional runtime type mapping. This functionality is offered as separate import for the `0.24.0` release but may be provided as standard type in later releases. This API enables `type T = Foo extends Bar ? true : false` conditional checks to be implemented at runtime. This API also provides the `Exclude` and `Extract` utility types which are implemented through conditional types in TypeScript.
+- [199](https://github.com/sinclairzx81/typebox/pull/199) TypeBox now provides better support for variadic function and constructor signatures. Currently variadic types are mapped as `Tuple` types.
+- [200](https://github.com/sinclairzx81/typebox/pull/200) The types `TPick` and `TOmit` now support types of `TUnion<TLiteral<string>[]>` to be used to select properties. Additionally, `KeyOf` now returns `TUnion<TLiteral<string>[]>`, allowing `KeyOf` schemas to be passed to `TPick` and `TOmit`.
+- [214](https://github.com/sinclairzx81/typebox/pull/214) TypeBox now provides better support for i18n. To achieve this, TypeBox includes fixed mappable error codes on the `ValueError` type. These codes can be used by external implementers to create localized error messages. TypeBox may include localized error codes as an optional import in future releases.
+- [288](https://github.com/sinclairzx81/typebox/pull/228) TypeBox now allows users to implement custom string validator formats. These formats are internally shared between the `Value` and `TypeCompiler` API's. TypeBox does not currently provide any built in formats, however the standard expected set (email, uuid, uri, etc) may be provided via optional import (inline with ajv-formats usage)
+- [229](https://github.com/sinclairzx81/typebox/pull/229) The `Value.Cast()` function now implements automatic coercion of string, number and Boolean types.
+- [231](https://github.com/sinclairzx81/typebox/pull/231) TypeBox provides a new `Value.Diff<T>()` and `Value.Patch<T>()` utility API for JavaScript values. This API is intended to provide a basis for the efficient transmission of state updates across a network. This API can diff any JavaScript value (typed or untyped) but is recommended to be used in conjunction with a formal static type.
+- [236](https://github.com/sinclairzx81/typebox/pull/236) TypeBox now implements the `TNever` type. This type is analogous to TypeScript's `never` type and is used in instances a composition results in a non-reconcilable type. Currently this type is implemented for empty `TUnion<[]>` types only. Future releases may utilize this type for planned updates to `TIntersect` (for example `string & number` resolves to `never`)
+- [241](https://github.com/sinclairzx81/typebox/pull/241) [247](https://github.com/sinclairzx81/typebox/pull/247) TypeBox now exposes a ValuePointer API that can be used to mutate a value via an RFC6901 JSON Pointer. Previously this functionality was internally used by `Value.Diff()` and `Value.Patch()` functions but is now offered as an optional import for implementations that need to update values manually through pointer references.
+
+Additional:
+
+- This project now includes two reference code generation utilities that can be used in custom build tooling. The first is `TypeScriptCodeGen` which will remap TypeScript `interface` and `type` definitions to TypeBox types. The second is `TypeBoxCodeGen` which will map existing TypeBox types into TypeScript type definitions. These implementations are not expected to be part of the TypeBox package, but users are free to clone and enhance them in their existing tool chains. Reference implementations can be found https://github.com/sinclairzx81/typebox/tree/master/codegen
\ No newline at end of file
diff --git a/changelog/0.24.49.md b/changelog/0.24.49.md
new file mode 100644
index 000000000..e0fd0a65e
--- /dev/null
+++ b/changelog/0.24.49.md
@@ -0,0 +1,9 @@
+## [0.24.49](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.49)
+
+Updates:
+
+- [264](https://github.com/sinclairzx81/typebox/pull/264) TypeBox now provides preliminary support for non Boolean `additionalProperties`. This allows existing `TObject` schemas to be augmented with additional properties of a known type.
+
+Additional:
+
+- TypeBox provides an additional reference `codegen` module for generating raw JSON Schema from TypeScript types via the TS compiler API. This generator may be used in future tooling.
\ No newline at end of file
diff --git a/changelog/0.24.6.md b/changelog/0.24.6.md
new file mode 100644
index 000000000..68477e071
--- /dev/null
+++ b/changelog/0.24.6.md
@@ -0,0 +1,20 @@
+## [0.24.6](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.6)
+
+Added:
+
+- TypeBox now offers a `TypeGuard` module for structurally checking TypeBox schematics. This module can be used in runtime type reflection scenarios where it's helpful to test a schema is of a particular form. This module can be imported under the `@sinclair/typebox/guard` import path.
+
+Example:
+
+```typescript
+import { TypeGuard } from '@sinclair/typebox/guard'
+
+const T: any = {}                                    // T is any
+
+const { type } = T                                   // unsafe: type is any
+
+if(TypeGuard.TString(T)) {
+    
+  const { type } = T                                 // safe: type is 'string'
+}
+```
\ No newline at end of file
diff --git a/changelog/0.24.8.md b/changelog/0.24.8.md
new file mode 100644
index 000000000..05f1576d0
--- /dev/null
+++ b/changelog/0.24.8.md
@@ -0,0 +1,6 @@
+## [0.24.8](https://www.npmjs.com/package/@sinclair/typebox/v/0.24.8)
+
+Added:
+- `Value.Cast(T, value)` structurally casts a value into another form while retaining information within the original value.
+- `Value.Check(T, value)` provides slow dynamic type checking for values. For performance, one should consider the `TypeCompiler` or `Ajv` validator.
+- `Value.Errors(T, value)` returns an iterator of errors found in a given value.
\ No newline at end of file
diff --git a/changelog/0.25.0.md b/changelog/0.25.0.md
new file mode 100644
index 000000000..5085679b5
--- /dev/null
+++ b/changelog/0.25.0.md
@@ -0,0 +1,7 @@
+## [0.25.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.0)
+
+Updates:
+
+- [271](https://github.com/sinclairzx81/typebox/pull/271) Adds a new non-standard `Type.Date()` type. This type joins the existing `Type.UInt8Array()` as a promoted extended type used to represent core JavaScript primitives. It's inclusion was prompted by end user requirements to validate Date objects prior to writing them to Date supported API's and where serialization of the Date object is handled internally by the API. 
+
+- [271](https://github.com/sinclairzx81/typebox/pull/271) Redesign of Extended Type representations. Extended types been updated to provide external validators (such as Ajv) additional standard proporties to use when defining the custom schema. These properties are `instanceOf` (used for validating a class `object` instances), and `typeOf` (when validating `value` types). Information on configuring AJV for these properties can be found in the AJV section of the TypeBox readme.
\ No newline at end of file
diff --git a/changelog/0.25.10.md b/changelog/0.25.10.md
new file mode 100644
index 000000000..fc1d3d567
--- /dev/null
+++ b/changelog/0.25.10.md
@@ -0,0 +1,5 @@
+## [0.25.10](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.10)
+
+Updates:
+
+- [283](https://github.com/sinclairzx81/typebox/pull/283) Updates the custom type validator callback signature to accept a schema instance. The schema instance may include additional constraints (such as options) that may be used during the validation process. `Custom.Set('<Kind>', (schema, value) => { ... })`.
\ No newline at end of file
diff --git a/changelog/0.25.11.md b/changelog/0.25.11.md
new file mode 100644
index 000000000..ad5144be0
--- /dev/null
+++ b/changelog/0.25.11.md
@@ -0,0 +1,5 @@
+## [0.25.11](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.11)
+
+Updates:
+
+- [286](https://github.com/sinclairzx81/typebox/pull/286) implements a FNV1A-64 non cryptographic hashing function in TypeBox. This function should not be used in place of cryptographic hashing functions, rather it's purpose is to provide relatively fast, hashing mechanism to assist with checks for arrays with uniqueItems constraints, specifically for cases where the array may contains reference values (such as objects, arrays, Dates and Uint8Array). This function is provided via `Value.Hash()` for convenience as the hash may be useful to generate a numeric identifier for values (with some considerations to React array rendering in absence of key or identifier)
\ No newline at end of file
diff --git a/changelog/0.25.18.md b/changelog/0.25.18.md
new file mode 100644
index 000000000..d762e176f
--- /dev/null
+++ b/changelog/0.25.18.md
@@ -0,0 +1,5 @@
+## [0.25.18](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.18)
+
+Updates:
+
+- [307](https://github.com/sinclairzx81/typebox/pull/307) implements date conversion when casting values with `Value.Cast(Type.Date(), ...)`. Castable values include numbers (interpretted as timestamps) and iso8601 string values. UNCASTABLE values will result in dates with values of `1970-01-01T00:00:00.000Z`. This version also includes more robust checks for Dates initialized with invalid values.
\ No newline at end of file
diff --git a/changelog/0.25.22.md b/changelog/0.25.22.md
new file mode 100644
index 000000000..3e9240379
--- /dev/null
+++ b/changelog/0.25.22.md
@@ -0,0 +1,5 @@
+## [0.25.22](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.22)
+
+Updates:
+
+- [323](https://github.com/sinclairzx81/typebox/pull/323) adds compiler support for UTF-16 (unicode) characters for schema identifiers.  
\ No newline at end of file
diff --git a/changelog/0.25.23.md b/changelog/0.25.23.md
new file mode 100644
index 000000000..76e93040a
--- /dev/null
+++ b/changelog/0.25.23.md
@@ -0,0 +1,10 @@
+## [0.25.23](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.23)
+
+Updates:
+
+- [324](https://github.com/sinclairzx81/typebox/pull/324) TypeScript Language Service now presents JSDoc comments when inferring static object properties. (IntelliSense)
+- [325](https://github.com/sinclairzx81/typebox/pull/325) Additional property inference optimizations.
+
+Additional:
+
+- Huge thank you to GITHUB user [stevezhu](https://github.com/stevezhu) for these excellent contributions.
\ No newline at end of file
diff --git a/changelog/0.25.24.md b/changelog/0.25.24.md
new file mode 100644
index 000000000..f45dc03c0
--- /dev/null
+++ b/changelog/0.25.24.md
@@ -0,0 +1,10 @@
+## [0.25.24](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.23)
+
+Updates:
+
+- [331](https://github.com/sinclairzx81/typebox/pull/331) Implements an additional check specific to property types of `required & undefined`. This to ensure the property key exists when the property value extends `undefined`.
+- [331](https://github.com/sinclairzx81/typebox/pull/331) Documentation updates for AJV and TypeCompiler
+
+Additional:
+
+- [331](https://github.com/sinclairzx81/typebox/pull/331) Remove unused recursive code paths for create and cast.
\ No newline at end of file
diff --git a/changelog/0.25.9.md b/changelog/0.25.9.md
new file mode 100644
index 000000000..c0155a84b
--- /dev/null
+++ b/changelog/0.25.9.md
@@ -0,0 +1,5 @@
+## [0.25.9](https://www.npmjs.com/package/@sinclair/typebox/v/0.25.9)
+
+Updates:
+
+- [282](https://github.com/sinclairzx81/typebox/pull/282) TypeBox now supports custom types. These types require the user to specify a custom `[Kind]` string on the type. Custom types can be registered via `Custom.Set('<Kind>', (value) => { ... })` which allow the TypeCompiler and Value API's to make use of user defined validation logic.
\ No newline at end of file
diff --git a/changelog/0.26.0.md b/changelog/0.26.0.md
new file mode 100644
index 000000000..34b69e876
--- /dev/null
+++ b/changelog/0.26.0.md
@@ -0,0 +1,394 @@
+## [0.26.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.26.0)
+
+## Overview
+
+TypeBox now provides "runtime conditional types" (formally the `Conditional` module) as standard on `Type.*`. Additional updates in this revision include automatic union and intersection unwrap, universal support for utility types, several ergonomic enhancements and additional options for framework integrators. This revision also carries out a number an internal refactorings to reduce the amount of submodule imports.
+
+Revision 0.26.0 is a milestone release for the TypeBox project and requires a minor semver update. 
+
+## Contents
+
+- Enhancements
+  - [Standard Type Builder](#Standard-Type-Builder)
+  - [Automatic Unwrap for Union and Intersect](#Automatic-Unwrap-for-Union-and-Intersect)
+  - [Intersect and Union now Compose](#Intersect-and-Union-now-Compose)
+  - [Runtime Conditional Types](#Runtime-Conditional-Types)
+  - [Value Convert](#Value-Convert)
+  - [Error Iterator](#Error-Iterator)
+  - [Codegen without JIT](#Codegen-without-JIT)
+  - [Standard Type (Composite)](#Standard-Type-Composite)
+  - [Standard Type (Not)](#Standard-Type-Not)
+  - [Extended Type (BigInt)](#Extended-Type-BigInt)
+  - [Extended Type (Symbol)](#Extended-Type-Symbol)
+- Breaking
+  - [Minimum TypeScript Version](#Minimum-TypeScript-Version)
+  - [Intersect Schema Representation](#Intersect-Schema-Representation)
+  - [Never Schema Representation](#Never-Schema-Representation)
+  - [Value Cast and Convert](#Value-Cast-and-Convert)
+  - [Moved TypeGuard Module](#Moved-TypeGuard-Module)
+  - [Format Renamed to FormatRegistry](#Format-Renamed-to-FormatRegistry)
+  - [Custom Renamed to TypeRegistry](#Custom-Renamed-to-TypeRegistry)
+
+<a name="Standard-Type-Builder"></a>
+
+## Standard Type Builder
+
+Revision 0.26.0 exports a new type builder called `StandardType`. This builder only allows for the construction JSON Schema compliant types by omitting all Extended types.
+ 
+```typescript
+import { StandardType as Type, Static } from '@sinclair/typebox'
+
+const T = Type.Date() // error: no such function
+```
+
+<a name="Automatic-Unwrap-for-Union-and-Intersect"></a>
+
+## Automatic Unwrap for Union and Intersect
+
+Revision 0.26.0 will automatically unwrap unions and intersections for the following cases.
+
+```typescript
+const T1 = Type.Union([Type.String(), Type.Number()]) // TUnion<[TString, TNumber]>
+
+const T2 = Type.Union([Type.String()])                // TString
+
+const T3 = Type.Union([])                             // TNever
+```
+
+<a name="Intersect-and-Union-now-Compose"></a>
+
+## Intersect and Union now Compose
+
+Revision 0.26.0 re-enables support for union and intersection type composition. These types are also made compatible with `Pick`, `Omit`, `Partial`, `Required` and `KeyOf` utility types.
+
+```typescript
+const A = Type.Object({ type: Type.Literal('A') })
+const B = Type.Object({ type: Type.Literal('B') })
+const C = Type.Object({ type: Type.Literal('C') })
+
+const Union = Type.Union([A, B, C])
+
+const Extended = Type.Object({
+  x: Type.Number(),
+  y: Type.Number(),
+  z: Type.Number()
+})
+
+const T = Type.Intersect([Union, Extended])          // type T = ({
+                                                     //   type: "A";
+                                                     //  } | {
+                                                     //   type: "B";
+                                                     // } | {
+                                                     //   type: "C";
+                                                     // }) & {
+                                                     //   x: number;
+                                                     //   y: number;
+                                                     //   z: number;
+                                                     // }
+
+const K = Type.KeyOf(T)                              // type K = "type" | "x" | "y" | "z"
+
+const P = Type.Pick(T, ['type', 'x'])                // type P = ({
+                                                     //   type: "A";
+                                                     // } | {
+                                                     //   type: "B";
+                                                     // } | {
+                                                     //   type: "C";
+                                                     // }) & {
+                                                     //   x: number;
+                                                     // }
+
+const O = Type.Partial(P)                            // type O = ({
+                                                     //   type?: "A" | undefined;
+                                                     // } | {
+                                                     //   type?: "B" | undefined;
+                                                     // } | {
+                                                     //   type?: "C" | undefined;
+                                                     // }) & {
+                                                     //   x?: number | undefined;
+                                                     // }
+```
+
+<a name="Runtime-Conditional-Types"></a>
+
+## Runtime Conditional Types
+
+Revision 0.26.0 adds the runtime conditional types `Extends`, `Extract` and `Exclude` as standard. 
+
+#### TypeScript
+
+```typescript
+type T0 = string extends number ? true : false                                                 
+//   ^ false
+type T1 = Extract<string | number, number>                                                     
+//   ^ number
+type T2 = Exclude<string | number, number>                                                     
+//   ^ string
+```
+
+#### TypeBox
+```typescript
+const T0 = Type.Extends(Type.String(), Type.Number(), Type.Literal(true), Type.Literal(false)) 
+//    ^ TLiteral<false>
+const T1 = Type.Extract(Type.Union([Type.String(), Type.Number()]), Type.Number())             
+//    ^ TNumber
+const T2 = Type.Exclude(Type.Union([Type.String(), Type.Number()]), Type.Number())             
+//    ^ TString<string>
+```
+
+<a name="Value-Convert"></a>
+
+## Value Convert
+
+Revision 0.26.0 adds a new `Convert` function to the `Value.*` module. This function will perform a type coercion for any value mismatched to its type if a reasonable conversion is possible.
+
+```typescript
+const T = Type.Number()
+
+const A = Value.Convert(T, '42')                     // const A: unknown = 42 - ... Convert(...) will return `unknown`
+
+const B = Value.Check(T, A)                          // const B = true        - ... so should be checked
+```
+
+<a name="Error-Iterator"></a>
+
+## Error Iterator
+
+Revision 0.26.0 now returns a `ValueErrorIterator` for `.Errors(...)`. This iterator provides a utility function to obtain the first error only. To obtain all errors, continue to use `for-of` enumeration or array spread syntax.
+
+```typescript
+const T = Type.Number()
+
+const First = Value.Errors(T, 'foo').First()         // const First = { path: '', message: 'Expected number', ... }
+
+const All = [...Value.Errors(T, 'foo')]              // const All = [{ path: '', message: 'Expected number', ... }]
+```
+
+
+<a name="Codegen-without-JIT"></a>
+
+## Codegen without JIT
+
+Revision 0.26.0 adds a `.Code()` function to the `TypeCompiler` to enable code generation without JIT evaluation.
+
+```typescript
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+
+const T = Type.Object({
+  x: Type.Number(),
+  y: Type.Number()
+})
+
+const C = TypeCompiler.Code(T)                       // return function check(value) {
+                                                     //   return (
+                                                     //    (typeof value === 'object' && value !== null) &&
+                                                     //    !Array.isArray(value) &&
+                                                     //    typeof value.x === 'number' &&
+                                                     //    Number.isFinite(value.x) &&
+                                                     //    typeof value.y === 'number' &&
+                                                     //    Number.isFinite(value.y)
+                                                     //   )
+                                                     // }
+```
+
+<a name="Standard-Type-Not"></a>
+
+## Standard Type (Not)
+
+Revision 0.26.0 introduces the `Not` standard type. This type allows for the inversion of assertion logic which can be useful to narrow for broader types.
+
+#### Example 1
+
+```typescript
+const T = Type.Not(Type.String({ pattern: 'A|B|C' }), Type.String())
+
+Value.Check(T, 'A')                                  // false
+Value.Check(T, 'B')                                  // false
+Value.Check(T, 'C')                                  // false
+Value.Check(T, 'D')                                  // true
+```
+
+#### Example 2
+
+```typescript
+const Even = Type.Number({ multipleOf: 2 })
+const Odd  = Type.Not(Even, Type.Number())
+
+Value.Check(Even, 0)                                  // true
+Value.Check(Even, 1)                                  // false
+Value.Check(Even, 2)                                  // true
+
+Value.Check(Odd, 0)                                   // false
+Value.Check(Odd, 1)                                   // true
+Value.Check(Odd, 2)                                   // false
+```
+
+<a name="Extended-Type-Composite"></a>
+
+## Standard Type (Composite)
+
+Revision 0.26.0 includes a new `Composite` standard type. This type will combine an array of `TObject[]` into a `TObject` by taking a union of any overlapping properties.
+
+```typescript
+const A = Type.Object({ type: Type.Literal('A') })
+
+const B = Type.Object({ type: Type.Literal('B') })
+
+const C = Type.Object({ type: Type.Literal('C'), value: Type.Number() })
+
+const T = Type.Composite([A, B, C])                  // type T = { 
+                                                     //   type: 'A' | 'B' | 'C'
+                                                     //   value: number
+                                                     // }
+```
+
+<a name="Extended-Type-Symbol"></a>
+
+## Extended Type (Symbol)
+
+Revision 0.26.0 provides provisional support for `Symbol` type validation.
+
+```typescript
+const T = Type.Symbol()
+
+Value.Check(A, Symbol('Foo'))                        // true
+```
+
+<a name="Extended-Type-BigInt"></a>
+
+## Extended Type (BigInt)
+
+Revision 0.26.0 provides provisional support for `BigInt` type validation.
+
+```typescript
+const T = Type.BigInt({ minimum: 10n })
+
+Value.Check(B, 1_000_000n)                           // true
+```
+
+<a name="Breaking"></a>
+
+## Breaking Changes
+
+The following are breaking changed in Revision 0.26.0
+
+<a name="Minimum-TypeScript-Version"></a>
+
+## Minimum TypeScript Version
+
+Revision 0.26.0 requires a minimum recommended TypeScript version of `4.2.3`. Version `4.1.5` is no longer supported.
+
+<a name="Intersect-Schema-Representation"></a>
+
+## Intersect Schema Representation
+
+Revision 0.26.0 changes the schema representation for `Intersect`. Revision 0.25.0 would construct a composite `object` type, in 0.26.0, `Intersect` is expressed as `anyOf`. If upgrading, consider using `Type.Composite(...)` to return backwards compatible representations.
+
+#### Intersect 0.25.0
+
+```typescript
+const T = Type.Intersect([                           // const U = {
+  Type.Object({                                      //   type: 'object',
+    x: Type.Number(),                                //   required: ['x', 'y'],  
+  }),                                                //   properties: {  
+  Type.Object({                                      //     x: {   
+    y: Type.Number(),                                //       type: 'number'   
+  })                                                 //     },   
+])                                                   //     y: {     
+                                                     //       type: 'number'   
+                                                     //     }  
+                                                     //   }  
+                                                     // } 
+```
+#### Intersect 0.26.0
+
+```typescript
+const T = Type.Intersect([                          // const U = {
+  Type.Object({                                     //  type: 'object', 
+    x: Type.Number(),                               //  allOf: [{
+  }),                                               //    type: 'object',
+  Type.Object({                                     //    required: [ 'x' ],
+    y: Type.Number(),                               //    properties: {
+  })                                                //      x: { type: 'number' }
+])                                                  //    }
+                                                    //  }, {
+                                                    //    type: 'object',
+                                                    //    required: ['y'],
+                                                    //    properties: {
+                                                    //      y: { type: 'number' }
+                                                    //    }
+                                                    //  }]
+                                                    // }
+```
+
+<a name="Never-Schema-Representation"></a>
+
+## Never Schema Representation
+
+Revision 0.26.0 simplifies the representation for `TNever`. Previous versions of TypeBox used an illogical intersection of Boolean constants via `allOf`. In 0.26.0, `never` is expressed as a `not` schema of type `any`.
+
+#### Intersect 0.25.0
+
+```typescript
+const T = Type.Never()                               // const T = {
+                                                     //   allOf: [
+                                                     //     { type: 'boolean', const: true }
+                                                     //     { type: 'boolean', const: false }
+                                                     //   ]
+                                                     // }
+```
+#### Intersect 0.26.0
+
+```typescript
+const T = Type.Never()                               // const T = { not: {} }
+```
+
+<a name="Value-Cast-and-Convert"></a>
+
+## Value Cast and Convert
+
+Revision 0.26.0 removes the `Cast` functions ability to coerce values. Use the new `Convert` function prior to `Cast`.
+
+```typescript
+const T = Type.Number()
+
+const V = Value.Cast(T, '42')                        // const V = 42   - 0.25.0 coerces to 42
+
+const V = Value.Cast(T, Value.Convert(T, '42'))      //  const V = 42   - 0.26.0 convert then cast
+```
+
+<a name="Movied TypeGuard Module"></a>
+
+## Moved TypeGuard Module
+
+The `TypeGuard` is now imported via the `@sinclair/typebox` module. This move is due to the TypeBox compositor internally using the guard when constructing types.
+
+```typescript
+import { TypeGuard } from '@sinclair/typebox/guard' // 0.25.0
+
+import { TypeGuard } from '@sinclair/typebox'       // 0.26.0
+```
+
+<a name="Format-Renamed-to-FormatRegistry"></a>
+
+## Format Renamed to FormatRegistry
+
+The `Format` module has been renamed to `FormatRegistry` and moved to the `typebox.ts` module.
+
+```typescript
+import { Format } from '@sinclair/typebox/format'    // 0.25.0
+
+import { FormatRegistry } from '@sinclair/typebox'   // 0.26.0
+```
+
+<a name="Custom-Renamed-to-TypeRegistry"></a>
+
+## Custom Renamed to TypeRegistry
+
+The `Format` module has been renamed to `FormatRegistry` and moved to the `typebox.ts` module.
+
+```typescript
+import { Custom } from '@sinclair/typebox/format' // 0.25.0
+
+import { TypeRegistry } from '@sinclair/typebox'  // 0.26.0
+```
\ No newline at end of file
diff --git a/codegen/codegen.ts b/codegen/codegen.ts
deleted file mode 100644
index 81d3797d3..000000000
--- a/codegen/codegen.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/codegen
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { TSchema } from '@sinclair/typebox'
-import { TypeBoxCodegen } from './typebox'
-import { TypeScriptCodegen } from './typescript'
-import { JsonSchemaCodegen } from './jsonschema'
-import { ZodCodegen, ZodCodegenOptions } from './zod'
-
-export namespace Codegen {
-  /** Generates TypeScript type definitions from TypeBox types */
-  export function TypeScript(schema: TSchema, references: TSchema[] = []): string {
-    return TypeScriptCodegen.Generate(schema, references)
-  }
-  /** Generates Zod type definitions from TypeBox types */
-  export function Zod(schema: TSchema, references: TSchema[] = [], options: ZodCodegenOptions = { imports: true, exports: false }): string {
-    return ZodCodegen.Generate(schema, references, options)
-  }
-  /** Generates TypeBox type definitions from TypeScript code */
-  export function TypeBox(code: string): string {
-    return TypeBoxCodegen.Generate(code)
-  }
-
-  /** Generates JsonSchema definitions from TypeScript code */
-  export function JsonSchema(code: string): string {
-    return JsonSchemaCodegen.Generate(code)
-  }
-}
diff --git a/codegen/index.ts b/codegen/index.ts
index 01fc5f56e..0513ff9ca 100644
--- a/codegen/index.ts
+++ b/codegen/index.ts
@@ -26,4 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export * from './codegen'
+export { TypeBoxToTypeScript } from './typebox-to-typescript'
+export { TypeBoxToZod } from './typebox-to-zod'
+export { TypeScriptToJsonSchema } from './typescript-to-json-schema'
+export { TypeScriptToTypeBox } from './typescript-to-typebox'
diff --git a/codegen/typescript.ts b/codegen/typebox-to-typescript.ts
similarity index 76%
rename from codegen/typescript.ts
rename to codegen/typebox-to-typescript.ts
index bb1d7a6c8..6629c6022 100644
--- a/codegen/typescript.ts
+++ b/codegen/typebox-to-typescript.ts
@@ -27,39 +27,35 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { Formatter } from './formatter'
-import { TypeGuard } from '@sinclair/typebox/guard'
 import * as Types from '@sinclair/typebox'
 
-export namespace TypeScriptCodegen {
+export namespace TypeBoxToTypeScript {
   function Any(schema: Types.TAny) {
     return 'any'
   }
-
   function Array(schema: Types.TArray) {
     const items = Visit(schema.items)
     return `Array<${items}>`
   }
-
   function Boolean(schema: Types.TBoolean) {
     return 'boolean'
   }
-
   function Constructor(schema: Types.TConstructor) {
     const params = schema.parameters.map((param) => Visit(param)).join(', ')
     const returns = Visit(schema.returns)
     return `new (${params}) => ${returns}`
   }
-
   function Function(schema: Types.TFunction) {
     const params = schema.parameters.map((param) => Visit(param)).join(', ')
     const returns = Visit(schema.returns)
     return `(${params}) => ${returns}`
   }
-
   function Integer(schema: Types.TInteger) {
     return 'number'
   }
-
+  function Intersect(schema: Types.TIntersect) {
+    return `(${schema.allOf.map((schema) => Visit(schema)).join(' & ')})`
+  }
   function Literal(schema: Types.TLiteral) {
     if (typeof schema.const === 'string') {
       return `'${schema.const}'`
@@ -67,23 +63,18 @@ export namespace TypeScriptCodegen {
       return `${schema.const}`
     }
   }
-
   function Never(schema: Types.TNever) {
     return 'never'
   }
-
   function Null(schema: Types.TNull) {
     return 'null'
   }
-
   function String(schema: Types.TString) {
     return 'string'
   }
-
   function Number(schema: Types.TNumber) {
     return 'number'
   }
-
   function Object(schema: Types.TObject) {
     const properties: string = globalThis.Object.entries(schema.properties)
       .map(([key, value]) => {
@@ -92,12 +83,10 @@ export namespace TypeScriptCodegen {
       .join(',\n')
     return `{\n${properties}\n}`
   }
-
   function Promise(schema: Types.TPromise) {
     const item = Visit(schema.item)
     return `Promise<${item}>`
   }
-
   function Record(schema: Types.TRecord) {
     for (const [key, value] of globalThis.Object.entries(schema.patternProperties)) {
       const type = Visit(value)
@@ -107,93 +96,85 @@ export namespace TypeScriptCodegen {
         return `Record<string, ${type}>`
       }
     }
-    throw Error('TypeScriptCodeGen: Unreachable')
+    throw Error('TypeBoxToTypeScript: Unreachable')
   }
-
   function Ref(schema: Types.TRef) {
     return schema.$ref
   }
-
   function Self(schema: Types.TSelf) {
     return schema.$ref
   }
-
   function Tuple(schema: Types.TTuple) {
     if (schema.items === undefined) return `[]`
     const items = schema.items.map((schema) => Visit(schema)).join(', ')
     return `[${items}]`
   }
-
   function UInt8Array(schema: Types.TUint8Array) {
     return `Uint8Array`
   }
-
   function Undefined(schema: Types.TUndefined) {
     return `undefined`
   }
-
   function Union(schema: Types.TUnion) {
-    return schema.anyOf.map((schema) => Visit(schema)).join(' | ')
+    return `${schema.anyOf.map((schema) => Visit(schema)).join(' | ')}`
   }
-
   function Unknown(schema: Types.TUnknown) {
     return `unknown`
   }
-
   function Void(schema: Types.TVoid) {
     return `void`
   }
-
   function Visit(schema: Types.TSchema): string {
-    if (TypeGuard.TAny(schema)) {
+    if (Types.TypeGuard.TAny(schema)) {
       return Any(schema)
-    } else if (TypeGuard.TArray(schema)) {
+    } else if (Types.TypeGuard.TArray(schema)) {
       return Array(schema)
-    } else if (TypeGuard.TBoolean(schema)) {
+    } else if (Types.TypeGuard.TBoolean(schema)) {
       return Boolean(schema)
-    } else if (TypeGuard.TConstructor(schema)) {
+    } else if (Types.TypeGuard.TConstructor(schema)) {
       return Constructor(schema)
-    } else if (TypeGuard.TFunction(schema)) {
+    } else if (Types.TypeGuard.TFunction(schema)) {
       return Function(schema)
-    } else if (TypeGuard.TInteger(schema)) {
+    } else if (Types.TypeGuard.TInteger(schema)) {
       return Integer(schema)
-    } else if (TypeGuard.TLiteral(schema)) {
+    } else if (Types.TypeGuard.TIntersect(schema)) {
+      return Intersect(schema)
+    } else if (Types.TypeGuard.TLiteral(schema)) {
       return Literal(schema)
-    } else if (TypeGuard.TNever(schema)) {
+    } else if (Types.TypeGuard.TNever(schema)) {
       return Never(schema)
-    } else if (TypeGuard.TNull(schema)) {
+    } else if (Types.TypeGuard.TNull(schema)) {
       return Null(schema)
-    } else if (TypeGuard.TNumber(schema)) {
+    } else if (Types.TypeGuard.TNumber(schema)) {
       return Number(schema)
-    } else if (TypeGuard.TObject(schema)) {
+    } else if (Types.TypeGuard.TObject(schema)) {
       return Object(schema)
-    } else if (TypeGuard.TPromise(schema)) {
+    } else if (Types.TypeGuard.TPromise(schema)) {
       return Promise(schema)
-    } else if (TypeGuard.TRecord(schema)) {
+    } else if (Types.TypeGuard.TRecord(schema)) {
       return Record(schema)
-    } else if (TypeGuard.TRef(schema)) {
+    } else if (Types.TypeGuard.TRef(schema)) {
       return Ref(schema)
-    } else if (TypeGuard.TSelf(schema)) {
+    } else if (Types.TypeGuard.TSelf(schema)) {
       return Self(schema)
-    } else if (TypeGuard.TString(schema)) {
+    } else if (Types.TypeGuard.TString(schema)) {
       return String(schema)
-    } else if (TypeGuard.TTuple(schema)) {
+    } else if (Types.TypeGuard.TTuple(schema)) {
       return Tuple(schema)
-    } else if (TypeGuard.TUint8Array(schema)) {
+    } else if (Types.TypeGuard.TUint8Array(schema)) {
       return UInt8Array(schema)
-    } else if (TypeGuard.TUndefined(schema)) {
+    } else if (Types.TypeGuard.TUndefined(schema)) {
       return Undefined(schema)
-    } else if (TypeGuard.TUnion(schema)) {
+    } else if (Types.TypeGuard.TUnion(schema)) {
       return Union(schema)
-    } else if (TypeGuard.TUnknown(schema)) {
+    } else if (Types.TypeGuard.TUnknown(schema)) {
       return Unknown(schema)
-    } else if (TypeGuard.TVoid(schema)) {
+    } else if (Types.TypeGuard.TVoid(schema)) {
       return Void(schema)
     } else {
-      throw Error('TypeScriptCodeGen: Unknown type')
+      throw Error('TypeBoxToTypeScript: Unknown type')
     }
   }
-
   /** Generates TypeScript code from TypeBox types */
   export function Generate(schema: Types.TSchema, references: Types.TSchema[] = []) {
     const result: string[] = []
diff --git a/codegen/zod.ts b/codegen/typebox-to-zod.ts
similarity index 74%
rename from codegen/zod.ts
rename to codegen/typebox-to-zod.ts
index bfa9eaecf..84d84706d 100644
--- a/codegen/zod.ts
+++ b/codegen/typebox-to-zod.ts
@@ -27,24 +27,29 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { Formatter } from './formatter'
-import { TypeGuard } from '@sinclair/typebox/guard'
 import * as Types from '@sinclair/typebox'
 
-export class ZodNonReferentialType extends Error {
+// --------------------------------------------------------------------------
+// Errors
+// --------------------------------------------------------------------------
+export class TypeBoxToZodNonReferentialType extends Error {
   constructor(message: string) {
-    super(`ZodNonReferentialType: ${message}`)
+    super(`TypeBoxToZod: ${message}`)
   }
 }
-export class ZodUnsupportedType extends Error {
+export class TypeBoxToZodUnsupportedType extends Error {
   constructor(message: string) {
-    super(`ZodUnsupportedType: ${message}`)
+    super(`TypeBoxToZod: ${message}`)
   }
 }
+// --------------------------------------------------------------------------
+// Transform
+// --------------------------------------------------------------------------
 export interface ZodCodegenOptions {
   imports: boolean
   exports: boolean
 }
-export namespace ZodCodegen {
+export namespace TypeBoxToZod {
   function Any(schema: Types.TAny) {
     return `z.any()`
   }
@@ -56,7 +61,7 @@ export namespace ZodCodegen {
     return `z.boolean()`
   }
   function Constructor(schema: Types.TConstructor): string {
-    throw new ZodUnsupportedType(`TConstructor`)
+    throw new TypeBoxToZodUnsupportedType(`TConstructor`)
   }
   function Function(schema: Types.TFunction) {
     const params = schema.parameters.map((param) => Visit(param)).join(`, `)
@@ -73,6 +78,17 @@ export namespace ZodCodegen {
     if (schema.multipleOf !== undefined) buffer.push(`.multipleOf(${schema.multipleOf})`)
     return buffer.join(``)
   }
+  function Intersect(schema: Types.TIntersect) {
+    // note: Zod only supports binary intersection. While correct, this is partially at odds with TypeScript's
+    // ability to distribute across (A & B & C). This code reduces intersection to binary ops.
+    function reduce(rest: Types.TSchema[]): string {
+      if (rest.length === 0) throw Error('Expected at least one intersect type')
+      if (rest.length === 1) return Visit(rest[0])
+      const [left, right] = [rest[0], rest.slice(1)]
+      return `z.intersection(${Visit(left)}, ${reduce(right)})`
+    }
+    return reduce(schema.allOf)
+  }
   function Literal(schema: Types.TLiteral) {
     if (typeof schema.const === `string`) {
       return `z.literal('${schema.const}')`
@@ -124,19 +140,19 @@ export namespace ZodCodegen {
     for (const [key, value] of globalThis.Object.entries(schema.patternProperties)) {
       const type = Visit(value)
       if (key === `^(0|[1-9][0-9]*)$`) {
-        throw new ZodUnsupportedType(`TRecord<TNumber, TUnknown>`)
+        throw new TypeBoxToZodUnsupportedType(`TRecord<TNumber, TUnknown>`)
       } else {
         return `z.record(${type})`
       }
     }
-    throw Error(`TypeScriptCodeGen: Unreachable`)
+    throw Error(`TypeBoxToZod: Unreachable`)
   }
   function Ref(schema: Types.TRef) {
-    if (!reference_map.has(schema.$ref!)) throw new ZodNonReferentialType(schema.$ref!)
+    if (!reference_map.has(schema.$ref!)) throw new TypeBoxToZodNonReferentialType(schema.$ref!)
     return schema.$ref
   }
   function Self(schema: Types.TSelf) {
-    if (!reference_map.has(schema.$ref!)) throw new ZodNonReferentialType(schema.$ref!)
+    if (!reference_map.has(schema.$ref!)) throw new TypeBoxToZodNonReferentialType(schema.$ref!)
     recursive_set.add(schema.$ref)
     return schema.$ref
   }
@@ -146,7 +162,7 @@ export namespace ZodCodegen {
     return `z.tuple([${items}])`
   }
   function UInt8Array(schema: Types.TUint8Array): string {
-    throw new ZodUnsupportedType(`TUint8Array`)
+    throw new TypeBoxToZodUnsupportedType(`TUint8Array`)
   }
   function Undefined(schema: Types.TUndefined) {
     return `z.undefined()`
@@ -162,52 +178,54 @@ export namespace ZodCodegen {
   }
   function Visit(schema: Types.TSchema): string {
     if (schema.$id !== undefined) reference_map.set(schema.$id, schema)
-    if (TypeGuard.TAny(schema)) {
+    if (Types.TypeGuard.TAny(schema)) {
       return Any(schema)
-    } else if (TypeGuard.TArray(schema)) {
+    } else if (Types.TypeGuard.TArray(schema)) {
       return Array(schema)
-    } else if (TypeGuard.TBoolean(schema)) {
+    } else if (Types.TypeGuard.TBoolean(schema)) {
       return Boolean(schema)
-    } else if (TypeGuard.TConstructor(schema)) {
+    } else if (Types.TypeGuard.TConstructor(schema)) {
       return Constructor(schema)
-    } else if (TypeGuard.TFunction(schema)) {
+    } else if (Types.TypeGuard.TFunction(schema)) {
       return Function(schema)
-    } else if (TypeGuard.TInteger(schema)) {
+    } else if (Types.TypeGuard.TInteger(schema)) {
       return Integer(schema)
-    } else if (TypeGuard.TLiteral(schema)) {
+    } else if (Types.TypeGuard.TIntersect(schema)) {
+      return Intersect(schema)
+    } else if (Types.TypeGuard.TLiteral(schema)) {
       return Literal(schema)
-    } else if (TypeGuard.TNever(schema)) {
+    } else if (Types.TypeGuard.TNever(schema)) {
       return Never(schema)
-    } else if (TypeGuard.TNull(schema)) {
+    } else if (Types.TypeGuard.TNull(schema)) {
       return Null(schema)
-    } else if (TypeGuard.TNumber(schema)) {
+    } else if (Types.TypeGuard.TNumber(schema)) {
       return Number(schema)
-    } else if (TypeGuard.TObject(schema)) {
+    } else if (Types.TypeGuard.TObject(schema)) {
       return Object(schema)
-    } else if (TypeGuard.TPromise(schema)) {
+    } else if (Types.TypeGuard.TPromise(schema)) {
       return Promise(schema)
-    } else if (TypeGuard.TRecord(schema)) {
+    } else if (Types.TypeGuard.TRecord(schema)) {
       return Record(schema)
-    } else if (TypeGuard.TRef(schema)) {
+    } else if (Types.TypeGuard.TRef(schema)) {
       return Ref(schema)
-    } else if (TypeGuard.TSelf(schema)) {
+    } else if (Types.TypeGuard.TSelf(schema)) {
       return Self(schema)
-    } else if (TypeGuard.TString(schema)) {
+    } else if (Types.TypeGuard.TString(schema)) {
       return String(schema)
-    } else if (TypeGuard.TTuple(schema)) {
+    } else if (Types.TypeGuard.TTuple(schema)) {
       return Tuple(schema)
-    } else if (TypeGuard.TUint8Array(schema)) {
+    } else if (Types.TypeGuard.TUint8Array(schema)) {
       return UInt8Array(schema)
-    } else if (TypeGuard.TUndefined(schema)) {
+    } else if (Types.TypeGuard.TUndefined(schema)) {
       return Undefined(schema)
-    } else if (TypeGuard.TUnion(schema)) {
+    } else if (Types.TypeGuard.TUnion(schema)) {
       return Union(schema)
-    } else if (TypeGuard.TUnknown(schema)) {
+    } else if (Types.TypeGuard.TUnknown(schema)) {
       return Unknown(schema)
-    } else if (TypeGuard.TVoid(schema)) {
+    } else if (Types.TypeGuard.TVoid(schema)) {
       return Void(schema)
     } else {
-      throw Error(`TypeScriptCodeGen: Unknown type`)
+      throw Error(`TypeBoxToZod: Unknown type`)
     }
   }
   const reference_map = new Map<string, Types.TSchema>()
@@ -222,7 +240,7 @@ export namespace ZodCodegen {
     // initialize root schematic and reference map
     if (schema.$id === undefined) schema.$id = `T_Generated`
     for (const reference of references) {
-      if (reference.$id === undefined) throw new ZodNonReferentialType(JSON.stringify(reference))
+      if (reference.$id === undefined) throw new TypeBoxToZodNonReferentialType(JSON.stringify(reference))
       reference_map.set(reference.$id, reference)
     }
     // render-code: Imports required for the generated code
diff --git a/codegen/jsonschema.ts b/codegen/typescript-to-json-schema.ts
similarity index 85%
rename from codegen/jsonschema.ts
rename to codegen/typescript-to-json-schema.ts
index c429a1125..2f198dbcb 100644
--- a/codegen/jsonschema.ts
+++ b/codegen/typescript-to-json-schema.ts
@@ -29,32 +29,32 @@ THE SOFTWARE.
 import { Formatter } from './formatter'
 import * as ts from 'typescript'
 
-export class NonExpressable extends Error {
+// --------------------------------------------------------------------------
+// Errors
+// --------------------------------------------------------------------------
+export class TypeScriptToJsonSchemaNonExpressable extends Error {
   constructor(type: string) {
-    super(`JsonSchemaCodeGen: Cannot express syntax type '${type}'`)
+    super(`TypeScriptToJsonSchema: Cannot express syntax type '${type}'`)
   }
 }
-
-/** Generates JsonSchema from TypeScript interface and type definitions */
-export namespace JsonSchemaCodegen {
+// --------------------------------------------------------------------------
+// Transform
+// --------------------------------------------------------------------------
+export namespace TypeScriptToJsonSchema {
   function isReadonlyProperty(node: ts.PropertySignature): boolean {
     return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'readonly') !== undefined
   }
-
   function isOptionalProperty(node: ts.PropertySignature) {
     return node.questionToken !== undefined
   }
-
   function isExport(node: ts.InterfaceDeclaration | ts.TypeAliasDeclaration | ts.EnumDeclaration): boolean {
     return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'export') !== undefined
   }
-
   function* SourceFile(node: ts.SourceFile): IterableIterator<string> {
     for (const next of node.getChildren()) {
       yield* Visit(next)
     }
   }
-
   function* PropertySignature(node: ts.PropertySignature): IterableIterator<string> {
     const [readonly, optional] = [isReadonlyProperty(node), isOptionalProperty(node)]
     const type = Collect(node.type)
@@ -68,7 +68,6 @@ export namespace JsonSchemaCodegen {
       return yield `${node.name.getText()}: ${type}`
     }
   }
-
   function* ArrayTypeNode(node: ts.ArrayTypeNode): IterableIterator<string> {
     const type = Collect(node.elementType)
     yield `{
@@ -76,7 +75,6 @@ export namespace JsonSchemaCodegen {
       items: ${type}
     }`
   }
-
   function* TupleTypeNode(node: ts.TupleTypeNode): IterableIterator<string> {
     const types = node.elements.map((type) => Collect(type)).join(',\n')
     yield `{
@@ -86,7 +84,6 @@ export namespace JsonSchemaCodegen {
       maxItems: ${node.elements.length}
     }`
   }
-
   function* UnionTypeNode(node: ts.UnionTypeNode): IterableIterator<string> {
     const types = node.types.map((type) => Collect(type)).join(',\n')
     yield `{
@@ -95,7 +92,6 @@ export namespace JsonSchemaCodegen {
       ]
     }`
   }
-
   function* IntersectionTypeNode(node: ts.IntersectionTypeNode): IterableIterator<string> {
     const types = node.types.map((type) => Collect(type)).join(',\n')
     yield `{
@@ -104,23 +100,18 @@ export namespace JsonSchemaCodegen {
       ]
     }`
   }
-
   function* TypeOperatorNode(node: ts.TypeOperatorNode): IterableIterator<string> {
-    throw new NonExpressable('TypeOperatorNode')
+    throw new TypeScriptToJsonSchemaNonExpressable('TypeOperatorNode')
   }
-
   function* Parameter(node: ts.ParameterDeclaration): IterableIterator<string> {
     yield Collect(node.type)
   }
-
   function* FunctionTypeNode(node: ts.FunctionTypeNode): IterableIterator<string> {
-    throw new NonExpressable('FunctionTypeNode')
+    throw new TypeScriptToJsonSchemaNonExpressable('FunctionTypeNode')
   }
-
   function* ConstructorTypeNode(node: ts.ConstructorTypeNode): IterableIterator<string> {
-    throw new NonExpressable('ConstructorTypeNode')
+    throw new TypeScriptToJsonSchemaNonExpressable('ConstructorTypeNode')
   }
-
   function* EnumMember(node: ts.EnumMember): IterableIterator<string> {
     if (node.initializer) {
       return yield `{
@@ -131,7 +122,6 @@ export namespace JsonSchemaCodegen {
       const: '${node.name.getText()}'
     }`
   }
-
   function* EnumDeclaration(node: ts.EnumDeclaration): IterableIterator<string> {
     const exports = isExport(node) ? 'export ' : ''
     const name = node.name.getText()
@@ -142,7 +132,6 @@ export namespace JsonSchemaCodegen {
       ]
     }`
   }
-
   function* InterfaceDeclaration(node: ts.InterfaceDeclaration): IterableIterator<string> {
     if (node.typeParameters) {
       const exports = isExport(node) ? 'export ' : ''
@@ -206,11 +195,11 @@ export namespace JsonSchemaCodegen {
   }
 
   function* RestTypeNode(node: ts.RestTypeNode): IterableIterator<string> {
-    throw new NonExpressable('RestTypeNode')
+    throw new TypeScriptToJsonSchemaNonExpressable('RestTypeNode')
   }
 
   function* ConditionalTypeNode(node: ts.ConditionalTypeNode): IterableIterator<string> {
-    throw new NonExpressable('ConditionalTypeNode')
+    throw new TypeScriptToJsonSchemaNonExpressable('ConditionalTypeNode')
   }
 
   function* TypeReferenceNode(node: ts.TypeReferenceNode): IterableIterator<string> {
@@ -222,31 +211,31 @@ export namespace JsonSchemaCodegen {
         items: ${args}
       }`
     } else if (name === 'Record') {
-      throw new NonExpressable('TypeReferenceNode:Record')
+      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Record')
     } else if (name === 'Partial') {
-      throw new NonExpressable('TypeReferenceNode:Partial')
+      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Partial')
     } else if (name === 'Uint8Array') {
-      throw new NonExpressable('TypeReferenceNode:Uint8Array')
+      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Uint8Array')
     } else if (name === 'Required') {
-      throw new NonExpressable('TypeReferenceNode:Required')
+      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Required')
     } else if (name === 'Omit') {
-      throw new NonExpressable('TypeReferenceNode:Omit')
+      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Omit')
     } else if (name === 'Pick') {
-      throw new NonExpressable('TypeReferenceNode:Pick')
+      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Pick')
     } else if (name === 'Promise') {
-      throw new NonExpressable('TypeReferenceNode:Promise')
+      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Promise')
     } else if (name === 'ReturnType') {
-      throw new NonExpressable('TypeReferenceNode:ReturnType')
+      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:ReturnType')
     } else if (name === 'InstanceType') {
-      throw new NonExpressable('TypeReferenceNode:InstanceType')
+      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:InstanceType')
     } else if (name === 'Parameters') {
-      throw new NonExpressable('TypeReferenceNode:Parameters')
+      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Parameters')
     } else if (name === 'ConstructorParameters') {
-      throw new NonExpressable('TypeReferenceNode:ConstructorParameters')
+      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:ConstructorParameters')
     } else if (name === 'Exclude') {
-      throw new NonExpressable('TypeReferenceNode:Exclude')
+      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Exclude')
     } else if (name === 'Extract') {
-      throw new NonExpressable('TypeReferenceNode:Extract')
+      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Extract')
     } else {
       return yield `${name}${args}`
     }
@@ -345,7 +334,7 @@ export namespace JsonSchemaCodegen {
     } else if (ts.isConditionalTypeNode(node)) {
       return yield* ConditionalTypeNode(node)
     } else if (node.kind === ts.SyntaxKind.KeyOfKeyword) {
-      throw new NonExpressable('KeyOfKeyword')
+      throw new TypeScriptToJsonSchemaNonExpressable('KeyOfKeyword')
     } else if (node.kind === ts.SyntaxKind.NumberKeyword) {
       return yield `{ 
         type: 'number' 
@@ -359,7 +348,7 @@ export namespace JsonSchemaCodegen {
         type: 'boolean' 
       }`
     } else if (node.kind === ts.SyntaxKind.UndefinedKeyword) {
-      throw new NonExpressable('UndefinedKeyword')
+      throw new TypeScriptToJsonSchemaNonExpressable('UndefinedKeyword')
     } else if (node.kind === ts.SyntaxKind.UnknownKeyword) {
       return yield `{
 
@@ -386,7 +375,7 @@ export namespace JsonSchemaCodegen {
         type: 'null' 
       }`
     } else if (node.kind === ts.SyntaxKind.VoidKeyword) {
-      throw new NonExpressable('KeyOfKeyword')
+      throw new TypeScriptToJsonSchemaNonExpressable('KeyOfKeyword')
     } else if (node.kind === ts.SyntaxKind.EndOfFileToken) {
       return
     } else if (node.kind === ts.SyntaxKind.SyntaxList) {
diff --git a/codegen/typebox.ts b/codegen/typescript-to-typebox.ts
similarity index 91%
rename from codegen/typebox.ts
rename to codegen/typescript-to-typebox.ts
index 598921ba0..a42f11750 100644
--- a/codegen/typebox.ts
+++ b/codegen/typescript-to-typebox.ts
@@ -29,26 +29,29 @@ THE SOFTWARE.
 import { Formatter } from './formatter'
 import * as ts from 'typescript'
 
-/** Generates TypeBox types from TypeScript interface and type definitions */
-export namespace TypeBoxCodegen {
+// --------------------------------------------------------------------------
+// Transform
+// --------------------------------------------------------------------------
+
+/** Generates TypeBox types from TypeScript code */
+export namespace TypeScriptToTypeBox {
   function isReadonlyProperty(node: ts.PropertySignature): boolean {
     return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'readonly') !== undefined
   }
-
   function isOptionalProperty(node: ts.PropertySignature) {
     return node.questionToken !== undefined
   }
-
-  function isExport(node: ts.InterfaceDeclaration | ts.TypeAliasDeclaration | ts.EnumDeclaration): boolean {
+  function isExport(node: ts.InterfaceDeclaration | ts.TypeAliasDeclaration | ts.EnumDeclaration | ts.ModuleDeclaration): boolean {
     return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'export') !== undefined
   }
-
+  function isNamespace(node: ts.ModuleDeclaration) {
+    return node.flags === ts.NodeFlags.Namespace
+  }
   function* SourceFile(node: ts.SourceFile): IterableIterator<string> {
     for (const next of node.getChildren()) {
       yield* Visit(next)
     }
   }
-
   function* PropertySignature(node: ts.PropertySignature): IterableIterator<string> {
     const [readonly, optional] = [isReadonlyProperty(node), isOptionalProperty(node)]
     const type = Collect(node.type)
@@ -62,50 +65,41 @@ export namespace TypeBoxCodegen {
       return yield `${node.name.getText()}: ${type}`
     }
   }
-
   function* ArrayTypeNode(node: ts.ArrayTypeNode): IterableIterator<string> {
     const type = Collect(node.elementType)
     yield `Type.Array(${type})`
   }
-
   function* TupleTypeNode(node: ts.TupleTypeNode): IterableIterator<string> {
     const types = node.elements.map((type) => Collect(type)).join(',\n')
     yield `Type.Tuple([\n${types}\n])`
   }
-
   function* UnionTypeNode(node: ts.UnionTypeNode): IterableIterator<string> {
     const types = node.types.map((type) => Collect(type)).join(',\n')
     yield `Type.Union([\n${types}\n])`
   }
-
   function* IntersectionTypeNode(node: ts.IntersectionTypeNode): IterableIterator<string> {
     const types = node.types.map((type) => Collect(type)).join(',\n')
     yield `Type.Intersect([\n${types}\n])`
   }
-
   function* TypeOperatorNode(node: ts.TypeOperatorNode): IterableIterator<string> {
     if (node.operator === ts.SyntaxKind.KeyOfKeyword) {
       const type = Collect(node.type)
       yield `Type.KeyOf(${type})`
     }
   }
-
   function* Parameter(node: ts.ParameterDeclaration): IterableIterator<string> {
     yield Collect(node.type)
   }
-
   function* FunctionTypeNode(node: ts.FunctionTypeNode): IterableIterator<string> {
     const parameters = node.parameters.map((param) => Collect(param)).join(', ')
     const returns = Collect(node.type)
     yield `Type.Function([${parameters}], ${returns})`
   }
-
   function* ConstructorTypeNode(node: ts.ConstructorTypeNode): IterableIterator<string> {
     const parameters = node.parameters.map((param) => Collect(param)).join(', ')
     const returns = Collect(node.type)
     yield `Type.Constructor([${parameters}], ${returns})`
   }
-
   function* EnumDeclaration(node: ts.EnumDeclaration): IterableIterator<string> {
     const exports = isExport(node) ? 'export ' : ''
     const name = node.name.getText()
@@ -114,7 +108,6 @@ export namespace TypeBoxCodegen {
     const type = `${exports}const ${name} = Type.Enum(${name}Enum)`
     yield [enumType, '', type].join('\n')
   }
-
   function* InterfaceDeclaration(node: ts.InterfaceDeclaration): IterableIterator<string> {
     useImports = true
     if (node.typeParameters) {
@@ -135,7 +128,6 @@ export namespace TypeBoxCodegen {
       yield `${staticDeclaration}\n${typeDeclaration}`
     }
   }
-
   function* TypeAliasDeclaration(node: ts.TypeAliasDeclaration): IterableIterator<string> {
     useImports = true
     if (node.typeParameters) {
@@ -156,28 +148,22 @@ export namespace TypeBoxCodegen {
       yield `${staticDeclaration}\n${typeDeclaration}`
     }
   }
-
   function* TypeParameterDeclaration(node: ts.TypeParameterDeclaration): IterableIterator<string> {
     yield node.name.getText()
   }
-
   function* ParenthesizedTypeNode(node: ts.ParenthesizedTypeNode): IterableIterator<string> {
     yield Collect(node.type)
   }
-
   function* RestTypeNode(node: ts.RestTypeNode): IterableIterator<string> {
     yield `Type.Rest()`
   }
-
   function* ConditionalTypeNode(node: ts.ConditionalTypeNode): IterableIterator<string> {
-    useConditional = true
     const checkType = Collect(node.checkType)
     const extendsType = Collect(node.extendsType)
     const trueType = Collect(node.trueType)
     const falseType = Collect(node.falseType)
-    yield `Conditional.Extends(${checkType}, ${extendsType}, ${trueType}, ${falseType})`
+    yield `Type.Extends(${checkType}, ${extendsType}, ${trueType}, ${falseType})`
   }
-
   function* TypeReferenceNode(node: ts.TypeReferenceNode): IterableIterator<string> {
     const name = node.typeName.getText()
     const args = node.typeArguments ? `(${node.typeArguments.map((type) => Collect(type)).join(', ')})` : ''
@@ -206,41 +192,46 @@ export namespace TypeBoxCodegen {
     } else if (name === 'ConstructorParameters') {
       return yield `Type.ConstructorParameters${args}`
     } else if (name === 'Exclude') {
-      return yield `Conditional.Exclude${args}`
+      return yield `Type.Exclude${args}`
     } else if (name === 'Extract') {
-      return yield `Conditional.Extract${args}`
+      return yield `Type.Extract${args}`
     } else {
       return yield `${name}${args}`
     }
   }
-
   function* TypeLiteralNode(node: ts.TypeLiteralNode): IterableIterator<string> {
     const members = node.members.map((member) => Collect(member)).join(',\n')
     yield `Type.Object({\n${members}\n})`
   }
-
   function* LiteralTypeNode(node: ts.LiteralTypeNode): IterableIterator<string> {
     const text = node.getText()
     if (text === 'null') return yield `Type.Null()`
     yield `Type.Literal(${node.getText()})`
   }
-
+  function* ModuleDeclaration(node: ts.ModuleDeclaration): IterableIterator<string> {
+    const export_specifier = isExport(node) ? 'export ' : ''
+    const module_specifier = isNamespace(node) ? 'namespace' : 'module'
+    yield `${export_specifier}${module_specifier} ${node.name.getText()} {`
+    yield* Visit(node.body)
+    yield `}`
+  }
+  function* ModuleBlock(node: ts.ModuleBlock): IterableIterator<string> {
+    for (const statement of node.statements) {
+      yield* Visit(statement)
+    }
+  }
   function* FunctionDeclaration(node: ts.FunctionDeclaration): IterableIterator<string> {
     yield node.getText()
   }
-
   function* ClassDeclaration(node: ts.ClassDeclaration): IterableIterator<string> {
     yield node.getText()
   }
-
   function Collect(node: ts.Node | undefined): string {
     return `${[...Visit(node)].join('')}`
   }
-
   function CollectNewLine(node: ts.Node | undefined): string {
     return [...Visit(node)].join('\n\n')
   }
-
   function* Visit(node: ts.Node | undefined): IterableIterator<string> {
     if (node === undefined) return
     if (ts.isSourceFile(node)) {
@@ -265,6 +256,10 @@ export namespace TypeBoxCodegen {
       return yield* TypeLiteralNode(node)
     } else if (ts.isLiteralTypeNode(node)) {
       return yield* LiteralTypeNode(node)
+    } else if (ts.isModuleDeclaration(node)) {
+      return yield* ModuleDeclaration(node)
+    } else if (ts.isModuleBlock(node)) {
+      return yield* ModuleBlock(node)
     } else if (ts.isArrayTypeNode(node)) {
       return yield* ArrayTypeNode(node)
     } else if (ts.isTupleTypeNode(node)) {
@@ -287,6 +282,8 @@ export namespace TypeBoxCodegen {
       return yield* ClassDeclaration(node)
     } else if (ts.isConditionalTypeNode(node)) {
       return yield* ConditionalTypeNode(node)
+    } else if (node.kind === ts.SyntaxKind.ExportKeyword) {
+      return yield `export`
     } else if (node.kind === ts.SyntaxKind.KeyOfKeyword) {
       return yield `Type.KeyOf()`
     } else if (node.kind === ts.SyntaxKind.NumberKeyword) {
@@ -319,22 +316,16 @@ export namespace TypeBoxCodegen {
       return yield node.getText()
     }
   }
-
   let useImports = false
-  let useConditional = false
   let useGenerics = false
-
   /** Generates TypeBox types from TypeScript interface and type definitions */
   export function Generate(typescriptCode: string) {
     useImports = false
-    useConditional = false
     useGenerics = false
-
     const source = ts.createSourceFile('code.ts', typescriptCode, ts.ScriptTarget.ESNext, true)
     const typeDeclarations = CollectNewLine(source)
     const importStatments: string[] = []
     if (useImports) {
-      if (useConditional) importStatments.push(`import { Conditional } from '@sinclair/typebox/conditional'`)
       if (useGenerics) importStatments.push(`import { Type, Static, TSchema } from '@sinclair/typebox'`)
       if (!useGenerics) importStatments.push(`import { Type, Static } from '@sinclair/typebox'`)
     }
diff --git a/example/experimental/experimental.ts b/example/experimental/experimental.ts
new file mode 100644
index 000000000..facf22474
--- /dev/null
+++ b/example/experimental/experimental.ts
@@ -0,0 +1,109 @@
+
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/experimental
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '@sinclair/typebox'
+import { Value } from '@sinclair/typebox/value'
+
+// -------------------------------------------------------------------------------------
+// TReadonlyObject
+// -------------------------------------------------------------------------------------
+export type TReadonlyArray<T extends Types.TSchema[]> = Types.Assert<{ [K in keyof T]: TReadonlyObject<Types.Assert<T[K], Types.TSchema>> }, Types.TSchema[]>
+// prettier-ignore
+export type TReadonlyProperties<T extends Types.TProperties> = Types.Evaluate<Types.Assert<{
+  [K in keyof T]: 
+    T[K] extends Types.TReadonlyOptional<infer U> ? Types.TReadonlyOptional<U> : 
+    T[K] extends Types.TReadonly<infer U>         ? Types.TReadonly<U> : 
+    T[K] extends Types.TOptional<infer U>         ? Types.TReadonlyOptional<U> : 
+    Types.TReadonly<T[K]>
+}, Types.TProperties>>
+// prettier-ignore
+export type TReadonlyObject<T extends Types.TSchema> = 
+  T extends Types.TIntersect<infer S> ? Types.TIntersect<TReadonlyArray<S>> : 
+  T extends Types.TUnion<infer S>     ? Types.TUnion<TReadonlyArray<S>> : 
+  T extends Types.TObject<infer S>    ? Types.TObject<TReadonlyProperties<S>> : 
+  Types.TReadonly<T>
+
+// -------------------------------------------------------------------------------------
+// TUnionEnum
+// -------------------------------------------------------------------------------------
+export interface TUnionEnum<T extends (string | number)[]> extends Types.TSchema {
+  [Types.Kind]: 'UnionEnum'
+  static: T[number]
+  enum: T
+}
+// -------------------------------------------------------------------------------------
+// UnionOneOf
+// -------------------------------------------------------------------------------------
+export interface UnionOneOf<T extends Types.TSchema[]> extends Types.TSchema {
+  [Types.Kind]: 'UnionOneOf'
+  static: { [K in keyof T]: Types.Static<T[K]> }[number]
+  oneOf: T
+}
+// -------------------------------------------------------------------------------------
+// ExperimentalTypeBuilder
+// -------------------------------------------------------------------------------------
+export class ExperimentalTypeBuilder extends Types.ExtendedTypeBuilder {
+  /** `[Experimental]` Remaps a Intersect, Union or Object as readonly */
+  public ReadonlyObject<T extends Types.TSchema>(schema: T): TReadonlyObject<T> {
+    function Apply(property: Types.TSchema): any {
+      // prettier-ignore
+      switch (property[Types.Modifier]) {
+        case 'ReadonlyOptional': property[Types.Modifier] = 'ReadonlyOptional'; break
+        case 'Readonly': property[Types.Modifier] = 'Readonly'; break
+        case 'Optional': property[Types.Modifier] = 'ReadonlyOptional'; break
+        default: property[Types.Modifier] = 'Readonly'; break
+      }
+      return property
+    }
+    // prettier-ignore
+    return (Types.TypeGuard.TIntersect(schema) || Types.TypeGuard.TUnion(schema) || Types.TypeGuard.TObject(schema)) 
+      ? Types.ObjectMap.Map<TReadonlyObject<T>>(schema, (schema) => {
+        globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]))
+      return schema
+    }, {}) : Apply(schema)
+  }
+  /** `[Experimental]` Creates a Union type with a `enum` schema representation  */
+  public UnionEnum<T extends (string | number)[]>(values: [...T], options: Types.SchemaOptions = {}) {
+    function UnionEnumCheck(schema: TUnionEnum<(string | number)[]>, value: unknown) {
+      return (typeof value === 'string' || typeof value === 'number') && schema.enum.includes(value)
+    }
+    if (!Types.TypeRegistry.Has('UnionEnum')) Types.TypeRegistry.Set('UnionEnum', UnionEnumCheck)
+    return { ...options, [Types.Kind]: 'UnionEnum', enum: values } as TUnionEnum<T>
+  }
+  /** `[Experimental]` Creates a Union type with a `oneOf` schema representation */
+  public UnionOneOf<T extends Types.TSchema[]>(oneOf: [...T], options: Types.SchemaOptions = {}) {
+    function UnionOneOfCheck(schema: UnionOneOf<Types.TSchema[]>, value: unknown) {
+      return 1 === schema.oneOf.reduce((acc: number, schema: any) => (Value.Check(schema, value) ? acc + 1 : acc), 0)
+    }
+    if (!Types.TypeRegistry.Has('UnionOneOf')) Types.TypeRegistry.Set('UnionOneOf', UnionOneOfCheck)
+    return { ...options, [Types.Kind]: 'UnionOneOf', oneOf } as UnionOneOf<T>
+  }
+}
+
+export const Type = new ExperimentalTypeBuilder()
\ No newline at end of file
diff --git a/src/hash/index.ts b/example/experimental/index.ts
similarity index 95%
rename from src/hash/index.ts
rename to example/experimental/index.ts
index c1f89ba06..9dcc0367b 100644
--- a/src/hash/index.ts
+++ b/example/experimental/index.ts
@@ -1,6 +1,6 @@
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox/hash
+@sinclair/typebox/extensions
 
 The MIT License (MIT)
 
@@ -26,4 +26,4 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export * from './hash'
+export * from './experimental'
diff --git a/example/experimental/readme.md b/example/experimental/readme.md
new file mode 100644
index 000000000..16f8b3873
--- /dev/null
+++ b/example/experimental/readme.md
@@ -0,0 +1,30 @@
+# ExperimentalTypeBuilder
+
+An experimental TypeBox type builder with additional custom types.
+
+## Overview
+
+The TypeBox TypeBuilder classes are designed to be extended with user defined types. Instances where you may wish to do this are if your application is dependent on custom schematics and/or non-JSON serializable values (an example of which might be a Mongo's `ObjectId` or other such non-serializable value)
+
+## Application Type Builder
+
+The following shows creating a simple `ApplicationTypeBuilder` with additional types `Nullable` and `StringEnum`. These types are fairly common in OpenAPI implementations.
+
+```typescript
+import { StandardTypeBuilder, Static, TSchema } from '@sinclair/typebox'
+
+export class ApplicationTypeBuilder extends StandardTypeBuilder { // only JSON Schema types
+  public Nullable<T extends TSchema>(schema: T) {
+    return this.Unsafe<Static<T> | null>({ ...schema, nullable: true })
+  }
+  public StringEnum<T extends string[]>(values: [...T]) {
+    return this.Unsafe<T[number]>({ type: 'string', enum: values })
+  }
+}
+
+export const Type = new ApplicationTypeBuilder()    // re-export!
+```
+
+## Experimental Type Builder
+
+The `experimental.ts` file provided with this example shows advanced usage by creating complex types for potential inclusion in the TypeBox library in later revisions. It is offered for reference, experimentation and is open to contributor submission.
\ No newline at end of file
diff --git a/example/extensions/index.ts b/example/extensions/index.ts
deleted file mode 100644
index c8ec2834b..000000000
--- a/example/extensions/index.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/extensions
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-export * from './intersect-allof'
-export * from './readonly-object'
-export * from './union-oneof'
-export * from './union-enum'
diff --git a/example/extensions/intersect-allof.ts b/example/extensions/intersect-allof.ts
deleted file mode 100644
index 4a3a6016d..000000000
--- a/example/extensions/intersect-allof.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/extensions
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { Kind, TSchema, SchemaOptions, IntersectReduce, IntersectEvaluate } from '@sinclair/typebox'
-import { TypeGuard } from '@sinclair/typebox/guard'
-import { Custom } from '@sinclair/typebox/custom'
-import { Value } from '@sinclair/typebox/value'
-
-function IntersectAllOfCheck(schema: IntersectAllOf<TSchema[]>, value: unknown) {
-  if (!schema.allOf.every((schema) => Value.Check(schema, value))) return false
-  if (schema.unevaluatedProperties === undefined || schema.unevaluatedProperties === true) return true
-  const valueKeys = typeof value === 'object' && value !== null ? globalThis.Object.keys(value) : []
-  const knownKeys = schema.allOf.reduce((set, schema) => {
-    if (!TypeGuard.TObject(schema)) return set
-    Object.keys(schema.properties).forEach((key) => set.add(key))
-    return set
-  }, new Set<string>())
-  return valueKeys.every((key) => knownKeys.has(key))
-}
-
-export interface IntersectAllOfOptions extends SchemaOptions {
-  unevaluatedProperties?: boolean
-}
-
-export interface IntersectAllOf<T extends TSchema[]> extends TSchema, IntersectAllOfOptions {
-  [Kind]: 'IntersectAllOf'
-  static: IntersectReduce<unknown, IntersectEvaluate<T, []>>
-  allOf: T
-}
-
-/** Creates a Intersect type with a `allOf` schema representation */
-export function IntersectAllOf<T extends TSchema[]>(allOf: [...T], options: IntersectAllOfOptions = {}) {
-  if (!Custom.Has('IntersectAllOf')) Custom.Set('IntersectAllOf', IntersectAllOfCheck)
-  return { ...options, [Kind]: 'IntersectAllOf', allOf } as IntersectAllOf<T>
-}
diff --git a/example/extensions/readonly-object.ts b/example/extensions/readonly-object.ts
deleted file mode 100644
index cf92fd2cc..000000000
--- a/example/extensions/readonly-object.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/extensions
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { Type, TSchema, TObject, TProperties, Modifier, TReadonly, TReadonlyOptional, TOptional } from '@sinclair/typebox'
-
-// prettier-ignore
-export type TReadonlyObject<T extends TObject> = TObject<{
-  [K in keyof T['properties']]: 
-    T['properties'][K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : 
-    T['properties'][K] extends TReadonly<infer U>         ? TReadonly<U> : 
-    T['properties'][K] extends TOptional<infer U>         ? TReadonlyOptional<U> : 
-    TReadonly<T['properties'][K]>
-}>
-
-/** Remaps all properties of an object to be readonly */
-export function ReadonlyObject<T extends TObject>(schema: T): TReadonlyObject<T> {
-  return Type.Object(
-    Object.keys(schema.properties).reduce((acc, key) => {
-      const property = schema.properties[key] as TSchema
-      const modifier = property[Modifier]
-      // prettier-ignore
-      const mapped = (
-        (modifier === 'ReadonlyOptional') ? { ...property, [Modifier]: 'ReadonlyOptional' } :
-        (modifier === 'Readonly')         ? { ...property, [Modifier]: 'Readonly' } :
-        (modifier === 'Optional')         ? { ...property, [Modifier]: 'ReadonlyOptional' } :
-        ({...property, [Modifier]: 'Readonly' })
-      )
-      return { ...acc, [key]: mapped }
-    }, {} as TProperties),
-  ) as TReadonlyObject<T>
-}
diff --git a/example/extensions/union-enum.ts b/example/extensions/union-enum.ts
deleted file mode 100644
index 6f61163f2..000000000
--- a/example/extensions/union-enum.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/extensions
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { Kind, TSchema, SchemaOptions } from '@sinclair/typebox'
-import { Custom } from '@sinclair/typebox/custom'
-
-function UnionEnumCheck(schema: TUnionEnum<(string | number)[]>, value: unknown) {
-  return (typeof value === 'string' || typeof value === 'number') && schema.enum.includes(value)
-}
-
-export interface TUnionEnum<T extends (string | number)[]> extends TSchema {
-  [Kind]: 'UnionEnum'
-  static: T[number]
-  enum: T
-}
-
-/** Creates a Union type with a `enum` schema representation  */
-export function UnionEnum<T extends (string | number)[]>(values: [...T], options: SchemaOptions = {}) {
-  if (!Custom.Has('UnionEnum')) Custom.Set('UnionEnum', UnionEnumCheck)
-  return { ...options, [Kind]: 'UnionEnum', enum: values } as TUnionEnum<T>
-}
diff --git a/example/extensions/union-oneof.ts b/example/extensions/union-oneof.ts
deleted file mode 100644
index ef749b778..000000000
--- a/example/extensions/union-oneof.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/extensions
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { Kind, TSchema, SchemaOptions, Static } from '@sinclair/typebox'
-import { Custom } from '@sinclair/typebox/custom'
-import { Value } from '@sinclair/typebox/value'
-
-function UnionOneOfCheck(schema: UnionOneOf<TSchema[]>, value: unknown) {
-  return 1 === schema.oneOf.reduce((acc: number, schema: any) => (Value.Check(schema, value) ? acc + 1 : acc), 0)
-}
-
-export interface UnionOneOf<T extends TSchema[]> extends TSchema {
-  [Kind]: 'UnionOneOf'
-  static: { [K in keyof T]: Static<T[K]> }[number]
-  oneOf: T
-}
-
-/** Creates a Union type with a `oneOf` schema representation */
-export function UnionOneOf<T extends TSchema[]>(oneOf: [...T], options: SchemaOptions = {}) {
-  if (!Custom.Has('UnionOneOf')) Custom.Set('UnionOneOf', UnionOneOfCheck)
-  return { ...options, [Kind]: 'UnionOneOf', oneOf } as UnionOneOf<T>
-}
diff --git a/example/formats/additional.ts b/example/formats/additional.ts
deleted file mode 100644
index 60396d3cf..000000000
--- a/example/formats/additional.ts
+++ /dev/null
@@ -1,94 +0,0 @@
-import { Format } from '@sinclair/typebox/format'
-
-/** Configures TypeBox for additional string formats */
-export namespace AdditionalFormats {
-  // -------------------------------------------------------------------------------------------
-  // These formats are ported from the ajv-formats library. All credit goes to the original
-  // authors with the original code located at the following location.
-  //
-  // https://github.com/ajv-validator/ajv-formats/blob/master/src/formats.ts
-  // -------------------------------------------------------------------------------------------
-
-  const UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i
-  const DATE_TIME_SEPARATOR = /t|\s/i
-  const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i
-  const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/
-  const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-  const IPV4 = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/
-  const IPV6 =
-    /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i
-  const URL =
-    /^(?:https?|wss?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu
-  const EMAIL = /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i
-
-  function IsLeapYear(year: number): boolean {
-    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)
-  }
-
-  function IsDate(str: string): boolean {
-    const matches: string[] | null = DATE.exec(str)
-    if (!matches) return false
-    const year: number = +matches[1]
-    const month: number = +matches[2]
-    const day: number = +matches[3]
-    return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && IsLeapYear(year) ? 29 : DAYS[month])
-  }
-
-  function IsTime(str: string, strictTimeZone?: boolean): boolean {
-    const matches: string[] | null = TIME.exec(str)
-    if (!matches) return false
-    const hr: number = +matches[1]
-    const min: number = +matches[2]
-    const sec: number = +matches[3]
-    const tz: string | undefined = matches[4]
-    const tzSign: number = matches[5] === '-' ? -1 : 1
-    const tzH: number = +(matches[6] || 0)
-    const tzM: number = +(matches[7] || 0)
-    if (tzH > 23 || tzM > 59 || (strictTimeZone && !tz)) return false
-    if (hr <= 23 && min <= 59 && sec < 60) return true
-    // leap second
-    const utcMin = min - tzM * tzSign
-    const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0)
-    return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61
-  }
-
-  function IsDateTime(value: string, strictTimeZone?: boolean): boolean {
-    const dateTime: string[] = value.split(DATE_TIME_SEPARATOR)
-    return dateTime.length === 2 && IsDate(dateTime[0]) && IsTime(dateTime[1], strictTimeZone)
-  }
-
-  function IsEmail(value: string) {
-    return EMAIL.test(value)
-  }
-
-  function IsUuid(value: string) {
-    return UUID.test(value)
-  }
-
-  function IsUrl(value: string) {
-    return URL.test(value)
-  }
-
-  function IsIPv6(value: string) {
-    return IPV6.test(value)
-  }
-
-  function IsIPv4(value: string) {
-    return IPV4.test(value)
-  }
-
-  /** Configures additional string formats */
-  export function Configure(): void {
-    Format.Set('date-time', (value) => IsDateTime(value, true))
-    Format.Set('date', (value) => IsDate(value))
-    Format.Set('time', (value) => IsTime(value))
-    Format.Set('email', (value) => IsEmail(value))
-    Format.Set('uuid', (value) => IsUuid(value))
-    Format.Set('url', (value) => IsUrl(value))
-    Format.Set('ipv6', (value) => IsIPv6(value))
-    Format.Set('ipv4', (value) => IsIPv4(value))
-    //
-    // optional: add additional formats
-    //
-  }
-}
diff --git a/example/formats/index.ts b/example/formats/index.ts
index 2923362e3..4251323c5 100644
--- a/example/formats/index.ts
+++ b/example/formats/index.ts
@@ -1 +1 @@
-export * from './additional'
+export * from './standard'
diff --git a/example/formats/readme.md b/example/formats/readme.md
new file mode 100644
index 000000000..03eb80d35
--- /dev/null
+++ b/example/formats/readme.md
@@ -0,0 +1,43 @@
+# String Formats
+
+TypeBox does not implement any string formats by default. However it is possible to register user defined formats using the `FormatRegistry`. Once registered, the format becomes available to both `Value` and `TypeCompiler` modules.
+
+## FormatRegistry
+
+The following shows basic usage of the format registry
+
+```typescript
+import { Type, FormatRegistry } from '@sinclair/typebox'
+import { Value } from '@sinclair/typebox/value'
+
+// Register the 'foo-only' format. The format checks for 'foo' only.
+FormatRegistry.Set('foo-only', value => value === 'foo')
+
+const T = Type.String({ format: 'foo-only' })
+
+// Validate
+Value.Check(T, 'foo') // true
+Value.Check(T, 'bar') // false
+```
+
+## Standard Formats
+
+The `standard.ts` file provided with this example implements several standard string formats. 
+
+```typescript
+import './standard'
+```
+
+The following formats are implemented by `standard.ts`
+
+| Format      | Description |
+| ---         | --- |
+| `email`     | Internet email address, see [RFC 5321, section 4.1.2.](http://tools.ietf.org/html/rfc5321#section-4.1.2) |
+| `date-time` | ISO8601 DateTime. example, `2018-11-13T20:20:39+00:00` |
+| `date`      | ISO8601 Date component, for example, `2018-11-13`                                  |
+| `time`      | ISO8601 Time component, for example, `20:20:39+00:00`                              |
+| `uuid`      | A Universally Unique Identifier as defined by [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122). |
+| `url`       | A uniform resource locator as defined in [RFC 1738](https://www.rfc-editor.org/rfc/rfc1738)
+| `ipv4`      | IPv4 address, according to dotted-quad ABNF syntax as defined in [RFC 2673, section 3.2](http://tools.ietf.org/html/rfc2673#section-3.2). |
+| `ipv6`      | IPv6 address, as defined in [RFC 2373, section 2.2](http://tools.ietf.org/html/rfc2373#section-2.2). |
+
diff --git a/example/formats/standard.ts b/example/formats/standard.ts
new file mode 100644
index 000000000..7a0d9b06e
--- /dev/null
+++ b/example/formats/standard.ts
@@ -0,0 +1,74 @@
+import { FormatRegistry } from '@sinclair/typebox'
+
+// -------------------------------------------------------------------------------------------
+// Format Registration
+// -------------------------------------------------------------------------------------------
+FormatRegistry.Set('date-time', (value) => IsDateTime(value, true))
+FormatRegistry.Set('date', (value) => IsDate(value))
+FormatRegistry.Set('time', (value) => IsTime(value))
+FormatRegistry.Set('email', (value) => IsEmail(value))
+FormatRegistry.Set('uuid', (value) => IsUuid(value))
+FormatRegistry.Set('url', (value) => IsUrl(value))
+FormatRegistry.Set('ipv6', (value) => IsIPv6(value))
+FormatRegistry.Set('ipv4', (value) => IsIPv4(value))
+
+// -------------------------------------------------------------------------------------------
+// https://github.com/ajv-validator/ajv-formats/blob/master/src/formats.ts
+// -------------------------------------------------------------------------------------------
+
+const UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i
+const DATE_TIME_SEPARATOR = /t|\s/i
+const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i
+const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/
+const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+const IPV4 = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/
+const IPV6 = /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i
+const URL = /^(?:https?|wss?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu
+const EMAIL = /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i
+function IsLeapYear(year: number): boolean {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)
+}
+function IsDate(str: string): boolean {
+  const matches: string[] | null = DATE.exec(str)
+  if (!matches) return false
+  const year: number = +matches[1]
+  const month: number = +matches[2]
+  const day: number = +matches[3]
+  return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && IsLeapYear(year) ? 29 : DAYS[month])
+}
+function IsTime(str: string, strictTimeZone?: boolean): boolean {
+  const matches: string[] | null = TIME.exec(str)
+  if (!matches) return false
+  const hr: number = +matches[1]
+  const min: number = +matches[2]
+  const sec: number = +matches[3]
+  const tz: string | undefined = matches[4]
+  const tzSign: number = matches[5] === '-' ? -1 : 1
+  const tzH: number = +(matches[6] || 0)
+  const tzM: number = +(matches[7] || 0)
+  if (tzH > 23 || tzM > 59 || (strictTimeZone && !tz)) return false
+  if (hr <= 23 && min <= 59 && sec < 60) return true
+  const utcMin = min - tzM * tzSign
+  const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0)
+  return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61
+}
+function IsDateTime(value: string, strictTimeZone?: boolean): boolean {
+  const dateTime: string[] = value.split(DATE_TIME_SEPARATOR)
+  return dateTime.length === 2 && IsDate(dateTime[0]) && IsTime(dateTime[1], strictTimeZone)
+}
+function IsEmail(value: string) {
+  return EMAIL.test(value)
+}
+function IsUuid(value: string) {
+  return UUID.test(value)
+}
+function IsUrl(value: string) {
+  return URL.test(value)
+}
+function IsIPv6(value: string) {
+  return IPV6.test(value)
+}
+function IsIPv4(value: string) {
+  return IPV4.test(value)
+}
+
diff --git a/example/index.ts b/example/index.ts
index ed8d1cdc2..ed52156bd 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -1,12 +1,7 @@
-import { Codegen } from '@sinclair/typebox/codegen'
 import { TypeSystem } from '@sinclair/typebox/system'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
-import { TypeGuard } from '@sinclair/typebox/guard'
-import { Conditional } from '@sinclair/typebox/conditional'
-import { Format } from '@sinclair/typebox/format'
-import { Custom } from '@sinclair/typebox/custom'
 import { Value, ValuePointer } from '@sinclair/typebox/value'
-import { Type, Kind, Static, TSchema } from '@sinclair/typebox'
+import { Type, TypeGuard, Kind, Static, TSchema } from '@sinclair/typebox'
 
 // -----------------------------------------------------------
 // Create: Type
diff --git a/example/trpc/readme.md b/example/trpc/readme.md
index f3b26ccbc..e321ae253 100644
--- a/example/trpc/readme.md
+++ b/example/trpc/readme.md
@@ -1,6 +1,6 @@
 # Using TypeBox with TRPC
 
-To use TypeBox with TRPC, you will need to wrap types passed to procedures within a TRPC compatible assertion function. Once wrapped, TypeBox can provide TRPC auto type inference for procedures, enhanced runtime checking performance and well as providing options for enabling publishable procedure schematics based on the JSON Schema specification.
+To use TypeBox with TRPC, you will need to wrap types passed to procedures within a TRPC compatible assertion function. Once wrapped, TypeBox can provide TRPC auto type inference for procedures, enhanced runtime checking performance as well as provide options to enabling publishable procedure schematics based on the JSON Schema specification.
 
 ## Contents
 
@@ -57,11 +57,11 @@ import { TSchema } from '@sinclair/typebox'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 import { TRPCError } from '@trpc/server'
 
-export function RpcType<T extends TSchema>(schema: T, references: TSchema[] = []) {
-  const check = TypeCompiler.Compile(schema, references)
+export function RpcType<T extends TSchema>(schema: T) {
+  const check = TypeCompiler.Compile(schema)
   return (value: unknown) => {
     if (check.Check(value)) return value
-    const { path, message } = [...check.Errors(value)][0]
+    const { path, message } = check.Errors(value).First()!
     throw new TRPCError({ message: `${message} for ${path}`, code: 'BAD_REQUEST' })
   }
 }
@@ -78,10 +78,10 @@ import { Value } from '@sinclair/typebox/value'
 import { TSchema } from '@sinclair/typebox'
 import { TRPCError } from '@trpc/server'
 
-export function RpcType<T extends TSchema>(schema: T, references: TSchema[] = []) {
+export function RpcType<T extends TSchema>(schema: T) {
   return (value: unknown) => {
     if (Value.Check(schema, value)) return value
-    const { path, message } = [...Value.Errors(schema, references, value)][0]
+    const { path, message } = check.Errors(value).First()!
     throw new TRPCError({ message: `${message} for ${path}`, code: 'BAD_REQUEST' })
   }
 }
diff --git a/example/typedef/index.ts b/example/typedef/index.ts
index 7b932b243..b5db4f7aa 100644
--- a/example/typedef/index.ts
+++ b/example/typedef/index.ts
@@ -1,6 +1,6 @@
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox/extensions
+@sinclair/typebox/typedef
 
 The MIT License (MIT)
 
diff --git a/example/typedef/readme.md b/example/typedef/readme.md
index 0f0106a67..07837ad72 100644
--- a/example/typedef/readme.md
+++ b/example/typedef/readme.md
@@ -1,100 +1,81 @@
-# JSON Type Definition
+# TypeDef
 
-JSON Type Definition (JTD) specification is an alternative schema specification to JSON Schema that provides better support for nominal type systems. TypeBox doesn't provide JTD support by default, but can be expressed through unsafe types and validated with Ajv.
+TypeBox may offer support for [RPC8927](https://www.rfc-editor.org/rfc/rfc8927) JSON Type Definition in future revisions of the library. This specification is much simpler than JSON Schema but can be useful when describing schematics that need to be shared with nominal type languages.
 
-This example provides a reference implementation for JSON Type Definition.
+## Usage
 
-## TypeDef
-
-Refer to the `typedef.ts` file in this directory for a reference implementation of the JSON Type Definition type builder.
+The file `typedef.ts` provided with this example contains the provisional implementation for RPC8927.
 
 ```typescript
-import { Static } from '@sinclair/typebox'
-import { TypeDef } from './typedef'
+import { Value } from '@sinclair/typebox/value'
+import { Type, Static } from './typedef'
+
+const T = Type.Struct('T', {                         // const T = {
+  x: Type.Float32(),                                 //   properties: {
+  y: Type.Float32(),                                 //     x: { type: "float32" },
+  z: Type.Float32()                                  //     y: { type: 'float32' },
+})                                                   //     z: { type: 'float32' }
+                                                     //   }
+                                                     // }
+
+type T = Static<typeof T>                            // type T = {
+                                                     //   x: number,
+                                                     //   z: number,
+                                                     //   y: number
+                                                     // }
+
+const R = Value.Check(T, { x: 1, y: 2, z: 3 })       // const R = true
 ```
 
-## Properties
-
-```typescript
-// ------------------------------------------------------------------------
-// PropertiesType
-//
-// https://jsontypedef.com/docs/jtd-in-5-minutes/#properties-schemas
-//
-// ------------------------------------------------------------------------
-
-export type PropertiesType = Static<typeof PropertiesType>
-export const PropertiesType = TypeDef.Properties({
-  x: TypeDef.Float32(),
-  y: TypeDef.Float32(),
-  z: TypeDef.Float32(),
-})
-```
+### Unions
 
-## Values
+The JSON Type Definition has a different representation for unions and is primarily orientated towards discriminated unions. To use unions, you will need to name each struct on the first argument. TypeBox will take care of producing the union representation and static type.
 
 ```typescript
-// ------------------------------------------------------------------------
-// ValuesType
-//
-// https://jsontypedef.com/docs/jtd-in-5-minutes/#values-schemas
-//
-// ------------------------------------------------------------------------
-
-export type ValuesType = Static<typeof ValuesType>
-export const ValuesType = TypeDef.Values(TypeDef.Float64())
-```
-
-## Enum
-
-```typescript
-// ------------------------------------------------------------------------
-// EnumType
-//
-// https://jsontypedef.com/docs/jtd-in-5-minutes/#enum-schemas
-//
-// ------------------------------------------------------------------------
-
-export type EnumType = Static<typeof EnumType>
-export const EnumType = TypeDef.Enum(['FOO', 'BAR', 'BAZ'])
-```
-
-## Elements
-
-```typescript
-// ------------------------------------------------------------------------
-// ElementsType
-//
-// https://jsontypedef.com/docs/jtd-in-5-minutes/#elements-schemas
-//
-// ------------------------------------------------------------------------
-
-export type ElementsType = Static<typeof ElementsType>
-export const ElementsType = TypeDef.Elements(PropertiesType)
-```
-
-## Union
-
-```typescript
-// ------------------------------------------------------------------------
-// UnionType
-//
-// https://jsontypedef.com/docs/jtd-in-5-minutes/#discriminator-schemas
-//
-// ------------------------------------------------------------------------
-
-export type UnionType = Static<typeof UnionType>
-export const UnionType = TypeDef.Union('eventType', {
-  USER_CREATED: TypeDef.Properties({
-    id: TypeDef.String(),
-  }),
-  USER_PAYMENT_PLAN_CHANGED: TypeDef.Properties({
-    id: TypeDef.String(),
-    plan: TypeDef.Enum(['FREE', 'PAID']),
-  }),
-  USER_DELETED: TypeDef.Properties({
-    id: TypeDef.String(),
-    softDelete: TypeDef.Boolean(),
-  }),
-})
+import { Type, Static } from './typedef'
+
+const Vector2 = Type.Struct('Vector2', {             // const Vector2 = {
+  x: Type.Float32(),                                 //   properties: {
+  y: Type.Float32(),                                 //     x: { type: 'float32' },
+})                                                   //     y: { type: 'float32' }
+                                                     //   }
+                                                     // }
+
+const Vector3 = Type.Struct('Vector3', {             // const Vector3 = {
+  x: Type.Float32(),                                 //   properties: {
+  y: Type.Float32(),                                 //     x: { type: 'float32' },
+  z: Type.Float32()                                  //     y: { type: 'float32' },
+})                                                   //     z: { type: 'float32' }
+                                                     //   }
+                                                     // }
+
+const Union = Type.Union('type', [                   //  const Union = {
+  Vector2,                                           //    discriminator: 'type',
+  Vector3                                            //    mapping: {
+])                                                   //      Vector2: {
+                                                     //        properties: {
+                                                     //         x: { type: 'float32' },
+                                                     //         y: { type: 'float32' },
+                                                     //       }
+                                                     //     },
+                                                     //     Vector3: {
+                                                     //       properties: {
+                                                     //         x: { type: 'float32' },
+                                                     //         y: { type: 'float32' },
+                                                     //         z: { type: 'float32' }
+                                                     //       }
+                                                     //     }
+                                                     //   }
+                                                     // }
+
+type Union = Static<typeof Union>                    // type Union = {
+                                                     //   type: 'Vector2'
+                                                     //   x: number
+                                                     //   y: number
+                                                     // } | {
+                                                     //   type: 'Vector3'
+                                                     //   x: number
+                                                     //   y: number
+                                                     //   z: number
+                                                     // }    
 ```
diff --git a/example/typedef/typedef.ts b/example/typedef/typedef.ts
index 06a60c1bc..544d1b893 100644
--- a/example/typedef/typedef.ts
+++ b/example/typedef/typedef.ts
@@ -26,63 +26,378 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { Type, Static, TUnsafe } from '@sinclair/typebox'
+export { type Static, TSchema, PropertiesReduce, TReadonly, TReadonlyOptional, TOptional } from '@sinclair/typebox'
+import * as Types from '@sinclair/typebox'
 
-// ------------------------------------------------------------------------
-// TypeDef Namespace
-//
-// https://jsontypedef.com/docs/jtd-in-5-minutes/
-// ------------------------------------------------------------------------
-
-export type StaticTypeDefUnion<D extends string, M extends Record<string, TUnsafe<any>>> = { [K in keyof M]: { [P in D]: K } & Static<M[K]> }[keyof M]
-
-export namespace TypeDef {
-  export function Boolean() {
-    return Type.Unsafe<boolean>({ type: 'boolean' })
+// --------------------------------------------------------------------------
+// Symbols
+// --------------------------------------------------------------------------
+export const Name = Symbol.for('TypeBox:Name')
+// --------------------------------------------------------------------------
+// TArray
+// --------------------------------------------------------------------------
+export interface TArray<T extends Types.TSchema = Types.TSchema> extends Types.TSchema {
+  [Types.Kind]: 'TypeDef:Array'
+  static: Types.Static<T, this['params']>[]
+  elements: T
+}
+// --------------------------------------------------------------------------
+// TBoolean
+// --------------------------------------------------------------------------
+export interface TBoolean extends Types.TSchema {
+  [Types.Kind]: 'TypeDef:Boolean'
+  static: 'boolean'
+  type: 'boolean'
+}
+// --------------------------------------------------------------------------
+// TEnum
+// --------------------------------------------------------------------------
+export interface TEnum<T extends string[] = string[]> extends Types.TSchema {
+  [Types.Kind]: 'TypeDef:Enum'
+  static: T[number]
+  enum: [...T]
+}
+// --------------------------------------------------------------------------
+// TFloat32
+// --------------------------------------------------------------------------
+export interface TFloat32 extends Types.TSchema  {
+  [Types.Kind]: 'TypeDef:Float32'
+  type: 'float32'
+  static: number
+}
+// --------------------------------------------------------------------------
+// TFloat64
+// --------------------------------------------------------------------------
+export interface TFloat64 extends Types.TSchema  {
+  [Types.Kind]: 'TypeDef:Float64'
+  type: 'float64'
+  static: number
+}
+// --------------------------------------------------------------------------
+// TInt8
+// --------------------------------------------------------------------------
+export interface TInt8 extends Types.TSchema  {
+  [Types.Kind]: 'TypeDef:Int8'
+  type: 'int8'
+  static: number
+}
+// --------------------------------------------------------------------------
+// TInt16
+// --------------------------------------------------------------------------
+export interface TInt16 extends Types.TSchema  {
+  [Types.Kind]: 'TypeDef:Int16'
+  type: 'int16'
+  static: number
+}
+// --------------------------------------------------------------------------
+// TInt32
+// --------------------------------------------------------------------------
+export interface TInt32 extends Types.TSchema  {
+  [Types.Kind]: 'TypeDef:Int32'
+  type: 'int32'
+  static: number
+}
+// --------------------------------------------------------------------------
+// TUint8
+// --------------------------------------------------------------------------
+export interface TUint8 extends Types.TSchema  {
+  [Types.Kind]: 'TypeDef:Uint8'
+  type: 'uint8'
+  static: number
+}
+// --------------------------------------------------------------------------
+// TUint16
+// --------------------------------------------------------------------------
+export interface TUint16 extends Types.TSchema  {
+  [Types.Kind]: 'TypeDef:Uint16'
+  type: 'uint16'
+  static: number
+}
+// --------------------------------------------------------------------------
+// TUint32
+// --------------------------------------------------------------------------
+export interface TUint32 extends Types.TSchema {
+  [Types.Kind]: 'TypeDef:Uint32'
+  type: 'uint32'
+  static: number
+}
+// --------------------------------------------------------------------------
+// TProperties
+// --------------------------------------------------------------------------
+export type TFields = Record<string, Types.TSchema>
+// --------------------------------------------------------------------------
+// TRecord
+// --------------------------------------------------------------------------
+export interface TRecord<T extends Types.TSchema = Types.TSchema> extends Types.TSchema {
+  [Types.Kind]: 'TypeDef:Record'
+  static: Record<string, Types.Static<T, this['params']>>
+  values: T
+}
+// --------------------------------------------------------------------------
+// TString
+// --------------------------------------------------------------------------
+export interface TString extends Types.TSchema {
+  [Types.Kind]: 'TypeDef:String'
+  static: string
+}
+// --------------------------------------------------------------------------
+// TStruct
+// --------------------------------------------------------------------------
+type OptionalKeys<T extends TFields> = { [K in keyof T]: T[K] extends (Types.TReadonlyOptional<T[K]> | Types.TOptional<T[K]>) ? T[K] : never }
+type RequiredKeys<T extends TFields> = { [K in keyof T]: T[K] extends (Types.TReadonlyOptional<T[K]> | Types.TOptional<T[K]>) ? never : T[K] }
+export interface StructOptions {
+  additionalProperties?: boolean
+}
+export interface TStruct<D extends string = string, T extends TFields = TFields> extends Types.TSchema, StructOptions {
+  [Name]: D
+  [Types.Kind]: 'TypeDef:Struct'
+  static: Types.PropertiesReduce<T, this['params']>
+  optionalProperties: {[K in Types.Assert<OptionalKeys<T>, keyof T>]: T[K] }
+  properties: {[K in Types.Assert<RequiredKeys<T>, keyof T>]: T[K] }
+}
+// --------------------------------------------------------------------------
+// TTimestamp
+// --------------------------------------------------------------------------
+export interface TTimestamp extends Types.TSchema {
+  [Types.Kind]: 'TypeDef:Timestamp'
+  static: number
+}
+// --------------------------------------------------------------------------
+// TUnion
+// --------------------------------------------------------------------------
+export interface TUnion<D extends string = string, T extends TStruct[] = TStruct[]> extends Types.TSchema {
+  [Types.Kind]: 'TypeDef:Union'
+  static: Types.Evaluate<{ [K in keyof T]: { [key in D]: T[K][typeof Name] } & Types.Static<T[K]> }[number]>
+  discriminator: D, 
+  mapping: T
+}
+// --------------------------------------------------------------------------
+// TypeRegistry
+// --------------------------------------------------------------------------
+Types.TypeRegistry.Set<TArray>('TypeDef:Array', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TArray>('TypeDef:Boolean', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TArray>('TypeDef:Int8', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TArray>('TypeDef:Int16', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TArray>('TypeDef:Int32', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TArray>('TypeDef:Uint8', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TArray>('TypeDef:Uint16', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TArray>('TypeDef:Uint32', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TArray>('TypeDef:Record', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TArray>('TypeDef:String', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TArray>('TypeDef:Struct', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TArray>('TypeDef:Timestamp', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TArray>('TypeDef:Union', (schema, value) => TypeDefCheck.Check(schema, value))
+// --------------------------------------------------------------------------
+// TypeDefCheck
+// --------------------------------------------------------------------------
+export class TypeDefCheckUnionTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('TypeDefCheck: Unknown type')
+  }
+}
+export namespace TypeDefCheck {
+  // ------------------------------------------------------------------------
+  // Guards
+  // ------------------------------------------------------------------------
+  function IsObject(value: unknown): value is Record<keyof any, unknown> {
+    return typeof value === 'object' && value !== null && !globalThis.Array.isArray(value)
+  }
+  function IsArray(value: unknown): value is unknown[] {
+    return globalThis.Array.isArray(value)
+  }
+  function IsString(value: unknown): value is string {
+    return typeof value === 'string'
+  }
+  function IsInt(value: unknown, min: number, max: number): value is number {
+    return typeof value === 'number' && globalThis.Number.isInteger(value) && value >= min && value < max
+  }
+  // ------------------------------------------------------------------------
+  // Types
+  // ------------------------------------------------------------------------
+  function Array(schema: TArray, value: unknown): boolean {
+    return IsArray(value) && value.every(value => Visit(schema.elements, value))
   }
-  export function String() {
-    return Type.Unsafe<string>({ type: 'string' })
+  function Boolean(schema: TBoolean, value: unknown): boolean {
+    return typeof value === 'boolean'
   }
-  export function TimeStamp() {
-    return Type.Unsafe<string>({ type: 'timestamp' })
+  function Enum(schema: TEnum, value: unknown): boolean {
+    return typeof value === 'string' && schema.enum.includes(value)
   }
-  export function Float32() {
-    return Type.Unsafe<number>({ type: 'float32' })
+  function Float32(schema: TFloat32, value: unknown): boolean {
+    return typeof value === 'number'
   }
-  export function Float64() {
-    return Type.Unsafe<number>({ type: 'float64' })
+  function Float64(schema: TFloat64, value: unknown): boolean {
+    return typeof value === 'number'
   }
-  export function Int8() {
-    return Type.Unsafe<number>({ type: 'int8' })
+  function Int8(schema: TInt8, value: unknown): boolean {
+    return IsInt(value, -128, 127)
   }
-  export function Uint8() {
-    return Type.Unsafe<number>({ type: 'uint8' })
+  function Int16(schema: TInt16, value: unknown): boolean {
+    return IsInt(value, -32_768, 32_767)
   }
-  export function Int16() {
-    return Type.Unsafe<number>({ type: 'int16' })
+  function Int32(schema: TInt32, value: unknown): boolean {
+    return IsInt(value, -2_147_483_648, 2_147_483_647)
   }
-  export function Uint16() {
-    return Type.Unsafe<number>({ type: 'uint16' })
+  function Uint8(schema: TUint8, value: unknown): boolean {
+    return IsInt(value, 0, 255)
   }
-  export function Int32() {
-    return Type.Unsafe<number>({ type: 'int32' })
+  function Uint16(schema: TUint16, value: unknown): boolean {
+    return IsInt(value, 0, 65535)
   }
-  export function Uint32() {
-    return Type.Unsafe<number>({ type: 'uint32' })
+  function Uint32(schema: TUint32, value: unknown): boolean {
+    return IsInt(value, 0, 4_294_967_295)
   }
-  export function Enum<T extends string[]>(values: [...T]) {
-    return Type.Unsafe<T[number]>({ enum: values })
+  function Record(schema: TRecord, value: unknown): boolean {
+    return IsObject(value) && globalThis.Object.getOwnPropertyNames(value).every(key => Visit(schema.values, value[key]))
   }
-  export function Elements<T extends TUnsafe<any>>(element: T) {
-    return Type.Unsafe<Array<Static<T>>>({ elements: element })
+  function String(schema: TString, value: unknown): boolean {
+    return typeof value === 'string'
   }
-  export function Properties<T extends Record<string, TUnsafe<any>>>(properties: T) {
-    return Type.Unsafe<{ [K in keyof T]: Static<T[K]> }>({ properties })
+  function Struct(schema: TStruct, value: unknown): boolean {
+    const optionalKeys = schema.optionalProperties === undefined ? [] : globalThis.Object.getOwnPropertyNames(schema.optionalProperties)
+    const requiredKeys = schema.properties === undefined ? [] : globalThis.Object.getOwnPropertyNames(schema.properties)
+    if(!(IsObject(value) && 
+      optionalKeys.every(key => key in value ? Visit((schema.optionalProperties as any)[key], value[key]) : true) &&
+      requiredKeys.every(key => key in value && Visit(((schema as any).properties[key] as any), value[key])))) return false
+    if(schema.additionalProperties === true) return true
+    const unknownKeys = globalThis.Object.getOwnPropertyNames(value)
+    return unknownKeys.every(key => optionalKeys.includes(key) || requiredKeys.includes(key))
   }
-  export function Values<V extends TUnsafe<any>>(values: V) {
-    return Type.Unsafe<Record<string, Static<V>>>({ values })
+  function Timestamp(schema: TString, value: unknown): boolean {
+    return IsInt(value, 0, Number.MAX_SAFE_INTEGER)
   }
-  export function Union<D extends string, M extends Record<string, TUnsafe<any>>>(discriminator: D, mapping: M) {
-    return Type.Unsafe<StaticTypeDefUnion<D, M>>({ discriminator, mapping })
+  function Union(schema: TUnion, value: unknown): boolean {
+    return IsObject(value) && 
+      schema.discriminator in value &&
+      IsString(value[schema.discriminator]) &&
+      value[schema.discriminator] as any in schema.mapping &&
+      Visit(schema.mapping[value[schema.discriminator] as any], value)
+  }
+  function Visit(schema: Types.TSchema, value: unknown): boolean {
+    const anySchema = schema as any
+    switch(anySchema[Types.Kind]) {
+      case 'TypeDef:Array': return Array(anySchema, value)
+      case 'TypeDef:Boolean': return Boolean(anySchema, value)
+      case 'TypeDef:Enum': return Enum(anySchema, value)
+      case 'TypeDef:Float32': return Float32(anySchema, value)
+      case 'TypeDef:Float64': return Float64(anySchema, value)
+      case 'TypeDef:Int8': return Int8(anySchema, value)
+      case 'TypeDef:Int16': return Int16(anySchema, value)
+      case 'TypeDef:Int32': return Int32(anySchema, value)
+      case 'TypeDef:Uint8': return Uint8(anySchema, value)
+      case 'TypeDef:Uint16': return Uint16(anySchema, value)
+      case 'TypeDef:Uint32': return Uint32(anySchema, value)
+      case 'TypeDef:Record': return Record(anySchema, value)
+      case 'TypeDef:String': return String(anySchema, value)
+      case 'TypeDef:Struct': return Struct(anySchema, value)
+      case 'TypeDef:Timestamp': return Timestamp(anySchema, value)
+      case 'TypeDef:Union': return Union(anySchema, value)
+      default: throw new TypeDefCheckUnionTypeError(anySchema)
+    }
+  }
+  export function Check(schema: Types.TSchema, value: unknown): boolean {
+    return Visit(schema, value)
+  }
+}
+// --------------------------------------------------------------------------
+// TypeDefTypeBuilder
+// --------------------------------------------------------------------------
+export class TypeDefTypeBuilder extends Types.TypeBuilder {
+  // ------------------------------------------------------------------------
+  // Modifiers
+  // ------------------------------------------------------------------------
+  /** `[Modifier]` Creates a Optional property */
+  public Optional<T extends Types.TSchema>(schema: T): Types.TOptional<T> {
+    return { [Types.Modifier]: 'Optional', ...Types.TypeClone.Clone(schema, {}) }
+  }
+  /** `[Modifier]` Creates a ReadonlyOptional property */
+  public ReadonlyOptional<T extends Types.TSchema>(schema: T): Types.TReadonlyOptional<T> {
+    return { [Types.Modifier]: 'ReadonlyOptional', ...Types.TypeClone.Clone(schema, {}) }
+  }
+  /** `[Modifier]` Creates a Readonly object or property */
+  public Readonly<T extends Types.TSchema>(schema: T): Types.TReadonly<T> {
+    return { [Types.Modifier]: 'Readonly', ...schema }
+  }
+  // ------------------------------------------------------------------------
+  // Modifiers
+  // ------------------------------------------------------------------------
+  /** `[Standard]` Creates a TypeDef Array type */
+  public Array<T extends Types.TSchema>(elements: T): TArray<T> {
+    return this.Create({ [Types.Kind]: 'TypeDef:Array', elements })
+  }
+  /** `[Standard]` Creates a TypeDef Boolean type */
+  public Boolean(): TBoolean {
+    return this.Create({ [Types.Kind]: 'TypeDef:Boolean', type: 'boolean' })
+  }
+  /** `[Standard]` Creates a TypeDef Enum type */
+  public Enum<T extends string[]>(values: [...T]): TEnum<T> {
+    return this.Create({ [Types.Kind]: 'TypeDef:Enum', enum: values })
+  }
+  /** `[Standard]` Creates a TypeDef Float32 type */
+  public Float32(): TFloat32 {
+    return this.Create({ [Types.Kind]: 'TypeDef:Float32', type: 'float32' })
+  }
+  /** `[Standard]` Creates a TypeDef Float64 type */
+  public Float64(): TFloat64 {
+    return this.Create({ [Types.Kind]: 'TypeDef:Float64', type: 'float64' })
+  }
+  /** `[Standard]` Creates a TypeDef Int8 type */
+  public Int8(): TInt8 {
+    return this.Create({ [Types.Kind]: 'TypeDef:Int8', type: 'int8' })
+  }
+  /** `[Standard]` Creates a TypeDef Int16 type */
+  public Int16(): TInt16 {
+    return this.Create({ [Types.Kind]: 'TypeDef:Int16', type: 'int16' })
+  }
+  /** `[Standard]` Creates a TypeDef Int32 type */
+  public Int32(): TInt32 {
+    return this.Create({ [Types.Kind]: 'TypeDef:Int32', type: 'int32' })
+  }
+  /** `[Standard]` Creates a TypeDef Uint8 type */
+  public Uint8(): TUint8 {
+    return this.Create({ [Types.Kind]: 'TypeDef:Uint8', type: 'uint8' })
+  }
+  /** `[Standard]` Creates a TypeDef Uint16 type */
+  public Uint16(): TUint16 {
+    return this.Create({ [Types.Kind]: 'TypeDef:Uint16', type: 'uint16' })
+  }
+  /** `[Standard]` Creates a TypeDef Uint32 type */
+  public Uint32(): TUint32 {
+    return this.Create({ [Types.Kind]: 'TypeDef:Uint32', type: 'uint32' })
+  }
+  /** `[Standard]` Creates a TypeDef Record type */
+  public Record<T extends Types.TSchema>(values: T): TRecord<T> {
+    return this.Create({ [Types.Kind]: 'TypeDef:Record',values })
+  }
+  /** `[Standard]` Creates a TypeDef String type */
+  public String(): TString {
+    return this.Create({ [Types.Kind]: 'TypeDef:String',type: 'string' })
+  }  
+  /** `[Standard]` Creates a TypeDef Struct type */
+  public Struct<N extends string, T extends TFields>(name: N, fields: T, options?: StructOptions): TStruct<N, T> {
+    const optionalProperties = globalThis.Object.getOwnPropertyNames(fields).reduce((acc, key) => (Types.TypeGuard.TOptional(fields[key]) || Types.TypeGuard.TReadonlyOptional(fields[key]) ? { ...acc, [key]: fields[key] } : { ...acc }), {} as TFields)
+    const properties = globalThis.Object.getOwnPropertyNames(fields).reduce((acc, key) => (Types.TypeGuard.TOptional(fields[key]) || Types.TypeGuard.TReadonlyOptional(fields[key]) ? {... acc } : { ...acc, [key]: fields[key] }), {} as TFields)
+    const optionalPropertiesObject = globalThis.Object.getOwnPropertyNames(optionalProperties).length > 0 ? { optionalProperties: optionalProperties } : {}
+    const propertiesObject = globalThis.Object.getOwnPropertyNames(properties).length === 0 ? {} : { properties: properties }
+    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Struct', [Name]: name, ...propertiesObject, ...optionalPropertiesObject })
+  }
+  /** `[Standard]` Creates a TypeDef Timestamp type */
+  public Timestamp(): TTimestamp {
+    return this.Create({ [Types.Kind]: 'TypeDef:Timestamp', type: 'timestamp' })
+  }
+
+  /** `[Standard]` Creates a TypeDef Discriminated Union type */
+  public Union<D extends string, T extends TStruct<string, TFields>[]>(discriminator: D, objects: [...T]): TUnion<D, T> {
+    if(objects.length === 0) throw new Error('TypeDefTypeBuilder: Union types must have at least one object') 
+    const exists = objects.every(object => typeof object[Name] === 'string')
+    if(!exists) throw new Error('TypeDefTypeBuilder: All union objects MUST have a descriminator')
+    const unique = objects.reduce((set, current) => set.add(current[Name]), new Set<string>())
+    if(unique.size !== objects.length) throw new Error('TypeDefTypeBuilder: All union objects MUST unique descriminator strings')
+    const mapping = objects.reduce((acc, current) => ({ ...acc, [current[Name]]: current  }), {})
+    return this.Create({ [Types.Kind]: 'TypeDef:Union', discriminator, mapping })
   }
 }
+
+/** JSON Type Definition Type Builder */
+export const Type = new TypeDefTypeBuilder()
+
diff --git a/hammer.mjs b/hammer.mjs
index 19e88cee3..0957385eb 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -1,11 +1,9 @@
 import { compression, measurement } from './benchmark'
 import { readFileSync } from 'fs'
 
-
 // -------------------------------------------------------------------------------
 // Clean
 // -------------------------------------------------------------------------------
-
 export async function clean() {
     await folder('target').delete()
 }
@@ -13,15 +11,13 @@ export async function clean() {
 // -------------------------------------------------------------------------------
 // Format
 // -------------------------------------------------------------------------------
-
 export async function format() {
-    await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test example benchmark codegen')
+    await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test example/index.ts benchmark codegen')
 }
 
 // -------------------------------------------------------------------------------
 // Start
 // -------------------------------------------------------------------------------
-
 export async function start(example = 'index') {
     await shell(`hammer run example/${example}.ts --dist target/example/${example}`)
 }
@@ -29,34 +25,27 @@ export async function start(example = 'index') {
 // -------------------------------------------------------------------------------
 // Benchmark
 // -------------------------------------------------------------------------------
-
 export async function benchmark() {
     await compression()
     await measurement()
 }
-
 // -------------------------------------------------------------------------------
 // Test
 // -------------------------------------------------------------------------------
-
 export async function test_static() {
     await shell(`tsc -p test/static/tsconfig.json --noEmit --strict`)
 }
-
 export async function test_runtime(filter) {
     await shell(`hammer build ./test/runtime/index.ts --dist target/test/runtime --platform node`)
     await shell(`mocha target/test/runtime/index.js -g "${filter}"`)
 }
-
 export async function test(filter = '') {
     await test_static()
     await test_runtime(filter)
 }
-
 // -------------------------------------------------------------------------------
 // Build
 // -------------------------------------------------------------------------------
-
 export async function build(target = 'target/build') {
     await test()
     await folder(target).delete()
@@ -66,12 +55,9 @@ export async function build(target = 'target/build') {
     await folder(target).add('license')
     await shell(`cd ${target} && npm pack`)
 }
-
-
 // -------------------------------------------------------------
 // Publish
 // -------------------------------------------------------------
-
 export async function publish(otp, target = 'target/build') {
     const { version } = JSON.parse(readFileSync('package.json', 'utf8'))
     await shell(`cd ${target} && npm publish sinclair-typebox-${version}.tgz --access=public --otp ${otp}`)
diff --git a/package-lock.json b/package-lock.json
index 63868b5b2..e013c6885 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.21",
+  "version": "0.26.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.25.21",
+      "version": "0.26.0",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
@@ -18,7 +18,7 @@
         "chai": "^4.3.6",
         "mocha": "^9.2.2",
         "prettier": "^2.7.1",
-        "typescript": "^4.9.3"
+        "typescript": "^5.0.2"
       }
     },
     "node_modules/@esbuild/linux-loong64": {
@@ -1410,16 +1410,16 @@
       }
     },
     "node_modules/typescript": {
-      "version": "4.9.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.3.tgz",
-      "integrity": "sha512-CIfGzTelbKNEnLpLdGFgdyKhG23CKdKgQPOBc+OUNrkJ2vr+KSzsSV5kq5iWhEQbok+quxgGzrAtGWCyU7tHnA==",
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.2.tgz",
+      "integrity": "sha512-wVORMBGO/FAs/++blGNeAVdbNKtIh1rbBL2EyQ1+J9lClJ93KiiKe8PmFIVdXhHcyv44SL9oglmfeSsndo0jRw==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
       },
       "engines": {
-        "node": ">=4.2.0"
+        "node": ">=12.20"
       }
     },
     "node_modules/uri-js": {
@@ -2442,9 +2442,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "4.9.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.3.tgz",
-      "integrity": "sha512-CIfGzTelbKNEnLpLdGFgdyKhG23CKdKgQPOBc+OUNrkJ2vr+KSzsSV5kq5iWhEQbok+quxgGzrAtGWCyU7tHnA==",
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.2.tgz",
+      "integrity": "sha512-wVORMBGO/FAs/++blGNeAVdbNKtIh1rbBL2EyQ1+J9lClJ93KiiKe8PmFIVdXhHcyv44SL9oglmfeSsndo0jRw==",
       "dev": true
     },
     "uri-js": {
diff --git a/package.json b/package.json
index 50ce0021c..8043b31b7 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.24",
+  "version": "0.26.0",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -14,12 +14,7 @@
   "types": "./typebox.d.ts",
   "exports": {
     "./compiler": "./compiler/index.js",
-    "./conditional": "./conditional/index.js",
-    "./custom": "./custom/index.js",
     "./errors": "./errors/index.js",
-    "./format": "./format/index.js",
-    "./guard": "./guard/index.js",
-    "./hash": "./hash/index.js",
     "./system": "./system/index.js",
     "./value": "./value/index.js",
     ".": "./typebox.js"
@@ -47,6 +42,6 @@
     "chai": "^4.3.6",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^4.9.3"
+    "typescript": "^5.0.2"
   }
 }
diff --git a/readme.md b/readme.md
index 34acd8bbd..2d199c156 100644
--- a/readme.md
+++ b/readme.md
@@ -35,7 +35,7 @@ import { Static, Type } from 'npm:@sinclair/typebox'
 import { Static, Type } from 'https://esm.sh/@sinclair/typebox'
 ```
 
-## Usage
+## Example
 
 ```typescript
 import { Static, Type } from '@sinclair/typebox'
@@ -62,32 +62,33 @@ type T = Static<typeof T>                            // type T = {
 
 ## Overview
 
-TypeBox is a type builder library that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
+TypeBox is a runtime type builder that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type assertion rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
 
-This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used either as a simple tool to build up complex schemas or integrated into REST and RPC services to help validate data received over the wire. 
+This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire. 
 
 License MIT
 
 ## Contents
 - [Install](#install)
 - [Overview](#overview)
-- [Example](#Example)
+- [Usage](#usage)
 - [Types](#types)
   - [Standard](#types-standard)
   - [Extended](#types-extended)
   - [Modifiers](#types-modifiers)
   - [Options](#types-options)
-  - [Reference](#types-reference)
+  - [Generics](#types-generics)
+  - [References](#types-references)
   - [Recursive](#types-recursive)
-  - [Generic](#types-generic)
   - [Conditional](#types-conditional)
-  - [Unsafe](#types-unsafe)
   - [Guards](#types-guards)
+  - [Unsafe](#types-unsafe)
   - [Strict](#types-strict)
 - [Values](#values)
   - [Create](#values-create)
   - [Clone](#values-clone)
   - [Check](#values-check)
+  - [Convert](#values-convert)
   - [Cast](#values-cast)
   - [Equal](#values-equal)
   - [Hash](#values-hash)
@@ -101,20 +102,20 @@ License MIT
 - [TypeSystem](#typecheck)
   - [Types](#typesystem-types)
   - [Formats](#typesystem-formats)
+  - [Policies](#typesystem-policies)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
   - [Validate](#benchmark-validate)
   - [Compression](#benchmark-compression)
 - [Contribute](#contribute)
 
-<a name="Example"></a>
+<a name="usage"></a>
 
-## Example
+## Usage
 
-The following demonstrates TypeBox's general usage.
+The following shows general usage.
 
 ```typescript
-
 import { Static, Type } from '@sinclair/typebox'
 
 //--------------------------------------------------------------------------------------------
@@ -173,9 +174,11 @@ type T = Static<typeof T>                            // type T = {
 //
 //--------------------------------------------------------------------------------------------
 
-function receive(value: T) {                         // ... as a Type
+import { Value } from '@sinclair/typebox/value'
+
+function receive(value: T) {                         // ... as a Static Type
 
-  if(JSON.validate(T, value)) {                      // ... as a Schema
+  if(Value.Check(T, value)) {                        // ... as a JSON Schema
   
     // ok...
   }
@@ -186,13 +189,13 @@ function receive(value: T) {                         // ... as a Type
 
 ## Types
 
-TypeBox provides a set of functions that allow you to compose JSON Schema similar to how you would compose static types with TypeScript. Each function creates a JSON schema fragment which can compose into more complex types. The schemas produced by TypeBox can be passed directly to any JSON Schema compliant validator, or used to reflect runtime metadata for a type.
+TypeBox types are JSON schema fragments that can be composed into more complex types. Each fragment is structured such that a JSON schema compliant validator can runtime assert a value the same way TypeScript will statically assert a type. TypeBox provides a set of Standard types which are used create JSON schema compliant schematics as well as an Extended type set used to create schematics for constructs native to JavaScript. 
 
 <a name='types-standard'></a>
 
-### Standard
+### Standard Types
 
-The following table lists the Standard TypeBox types.
+The following table lists the Standard TypeBox types. These types are fully compatible with the JSON Schema Draft 6 specification.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
@@ -230,12 +233,6 @@ The following table lists the Standard TypeBox types.
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.RegEx(/foo/)    │ type T = string             │ const T = {                    │
-│                                │                             │    type: 'string',             │
-│                                │                             │    pattern: 'foo'              │
-│                                │                             │ }                              │
-│                                │                             │                                │
-├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Literal(42)     │ type T = 42                 │ const T = {                    │
 │                                │                             │    const: 42,                  │
 │                                │                             │    type: 'number'              │
@@ -252,15 +249,14 @@ The following table lists the Standard TypeBox types.
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Object({        │ type T = {                  │ const T = {                    │
 │   x: Type.Number(),            │   x: number,                │   type: 'object',              │
-│   y: Type.Number()             │   y: number                 │   properties: {                │
-│ })                             │ }                           │      x: {                      │
-│                                │                             │        type: 'number'          │
-│                                │                             │      },                        │
-│                                │                             │      y: {                      │
-│                                │                             │        type: 'number'          │
-│                                │                             │      }                         │
-│                                │                             │   },                           │
-│                                │                             │   required: ['x', 'y']         │
+│   y: Type.Number()             │   y: number                 │   required: ['x', 'y'],        │
+│ })                             │ }                           │   properties: {                │
+│                                │                             │     x: {                       │
+│                                │                             │       type: 'number'           │
+│                                │                             │     }, {                       │
+│                                │                             │       type: 'number'           │
+│                                │                             │     }                          │
+│                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -310,13 +306,36 @@ The following table lists the Standard TypeBox types.
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Intersect([     │ type T = {                  │ const T = {                    │
-│   Type.Object({                │   x: number                 │   type: 'object',              │
-│     x: Type.Number()           │ } & {                       │   properties: {                │
-│   }),                          │   y: number                 │     x: {                       │
-│   Type.Object({                │ }                           │       type: 'number'           │
-│     y: Type.Number()           │                             │     },                         │
-│   })                           │                             │     y: {                       │
-│ ])                             │                             │       type: 'number'           │
+│   Type.Object({                │   x: number                 │   allOf: [{                    │
+│     x: Type.Number()           │ } & {                       │     type: 'object',            │
+│   }),                          │   y: number                 │     required: ['x'],           │
+│   Type.Object({                │ }                           │     properties: {              │
+│     y: Type.Number()           │                             │       x: {                     │
+│   ])                           │                             │         type: 'number'         │
+│ ])                             │                             │       }                        │
+│                                │                             │     }                          │
+│                                │                             │   }, {                         │
+│                                │                             │     type: 'object',            |
+│                                │                             │     required: ['y'],           │
+│                                │                             │     properties: {              │
+│                                │                             │       y: {                     │
+│                                │                             │         type: 'number'         │
+│                                │                             │       }                        │
+│                                │                             │   }]                           │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Composite([     │ type T = {                  │ const T = {                    │
+│   Type.Object({                │   x: number | string        │   type: 'object',              │
+│     x: Type.Number()           │   y: number                 │   properties: {                │
+│   }),                          │ }                           │     x: {                       │
+│   Type.Object({                │                             │       anyOf: [                 │
+│     x: Type.String()           │                             │         { type: 'number' },    │
+│     y: Type.Number()           │                             │         { type: 'string' }     │
+│   })                           │                             │       ]                        │
+│ ])                             │                             │     },                         │
+│                                │                             │     y: {                       │
+│                                │                             │       type: 'number'           │
 │                                │                             │     }                          │
 │                                │                             │   },                           │
 │                                │                             │   required: ['x', 'y']         │
@@ -324,16 +343,51 @@ The following table lists the Standard TypeBox types.
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Never()         │ type T = never              │ const T = {                    │
-│                                │                             │   allOf: [{                    │
-│                                │                             │     type: 'boolean',           │
-│                                │                             │     const: false               │
+│                                │                             │   not: {}                      │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Not(            | type T = string             │ const T = {                    │
+|   Type.Union([                 │                             │   allOf: [{                    │
+│     Type.Literal('x'),         │                             │     not: {                     │
+│     Type.Literal('y'),         │                             │       anyOf: [                 │
+│     Type.Literal('z')          │                             │         { const: 'x' },        │
+│   ]),                          │                             │         { const: 'y' },        │
+│   Type.String()                │                             │         { const: 'z' }         │
+│ )                              │                             │       ]                        │
+│                                │                             │     }                          │
 │                                │                             │   }, {                         │
-│                                │                             │     type: 'boolean',           │
-│                                │                             │     const: true                │
+│                                │                             │     type: 'string'             │
 │                                │                             │   }]                           │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Extends(        │ type T =                    │ const T = {                    │
+│   Type.String(),               │  string extends number      │   const: false,                │
+│   Type.Number(),               │  true : false               │   type: 'boolean'              │
+│   Type.Literal(true),          │                             │ }                              │
+│   Type.Literal(false)          │                             │                                │
+│ )                              │                             │                                │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Extract(        │ type T = Extract<           │ const T = {                    │
+│   Type.Union([                 │   string | number,          │   type: 'string'               │
+│     Type.String(),             │   string                    │ }                              │
+│     Type.Number(),             │ >                           │                                │
+│   ]),                          │                             │                                │
+│   Type.String()                │                             │                                │
+│ )                              │                             │                                │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Exclude(        │ type T = Exclude<           │ const T = {                    │
+│   Type.Union([                 │   string | number,          │   type: 'number'               │
+│     Type.String(),             │   string                    │ }                              │
+│     Type.Number(),             │ >                           │                                │
+│   ]),                          │                             │                                │
+│   Type.String()                │                             │                                │
+│ )                              │                             │                                │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Record(         │ type T = Record<            │ const T = {                    │
 │   Type.String(),               │   string,                   │   type: 'object',              │
 │   Type.Number()                │   number,                   │   patternProperties: {         │
@@ -359,15 +413,15 @@ The following table lists the Standard TypeBox types.
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Required(       │ type T = Required<{         │ const T = {                    │
 │   Type.Object({                │   x?: number,               │   type: 'object',              │
-│     x: Type.Optional(          │   y?: number                │   properties: {                │
-│       Type.Number()            | }>                          │     x: {                       │
-│     ),                         │                             │       type: 'number'           │
-│     y: Type.Optional(          │                             │     },                         │
-│       Type.Number()            │                             │     y: {                       │
-│     )                          │                             │       type: 'number'           │
-│   })                           │                             │     }                          │
-│ )                              │                             │   },                           │
-│                                │                             │   required: ['x', 'y']         │
+│     x: Type.Optional(          │   y?: number                │   required: ['x', 'y'],        │
+│       Type.Number()            | }>                          │   properties: {                │
+│     ),                         │                             │     x: {                       │
+│     y: Type.Optional(          │                             │       type: 'number'           │
+│       Type.Number()            │                             │     },                         │
+│     )                          │                             │     y: {                       │
+│   })                           │                             │       type: 'number'           │
+│ )                              │                             │     }                          │
+│                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -392,14 +446,25 @@ The following table lists the Standard TypeBox types.
 │                                │                             │   required: ['y']              │
 │                                │                             │ }                              │
 │                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const A = Type.Object({        │ type A = {                  │ const T = {                    │
+│    x: Type.Number(),           │   x: number,                │   $ref: 'A'                    │
+│    y: Type.Number()            │   y: number                 │ }                              │
+│ }, { $id: 'T' })               | }                           │                                │
+│                                │                             │                                │
+│ const T = Type.Ref(A)          │ type T = A                  │                                │
+│                                │                             │                                │
+│                                │                             │                                │
+│                                │                             │                                │
+│                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
 <a name='types-extended'></a>
 
-### Extended
+### Extended Types
 
-TypeBox provides a set of extended types that can be used to express schematics for core JavaScript constructs and primitives. Extended types are not valid JSON Schema and will not validate using typical validation. These types however can be used to frame JSON schema and describe callable RPC interfaces that may receive JSON validated data.
+TypeBox provides several extended types that can be used to produce schematics for common JavaScript constructs. These types can not be used with standard JSON schema validators; but are useful to help frame schematics for RPC interfaces that may receive JSON validated data. Extended types are prefixed with the `[Extended]` doc comment for convenience. The following table lists the supported types.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
@@ -462,6 +527,24 @@ TypeBox provides a set of extended types that can be used to express schematics
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.RegEx(/foo/)    │ type T = string             │ const T = {                    │
+│                                │                             │    type: 'string',             │
+│                                │                             │    pattern: 'foo'              │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Symbol()        │ type T = symbol             │ const T = {                    │
+│                                │                             │   type: 'null',                │
+│                                │                             │   typeOf: 'Symbol'             │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.BigInt()        │ type T = bigint             │ const T = {                    │
+│                                │                             │   type: 'null',                │
+│                                │                             │   typeOf: 'BigInt'             │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Void()          │ type T = void               │ const T = {                    │
 │                                │                             │   type: 'null'                 │
 │                                │                             │   typeOf: 'Void'               │
@@ -474,7 +557,7 @@ TypeBox provides a set of extended types that can be used to express schematics
 
 ### Modifiers
 
-TypeBox provides modifiers that can be applied to an objects properties. This allows for `optional` and `readonly` to be applied to that property. The following table illustates how they map between TypeScript and JSON Schema.
+TypeBox provides modifiers that allow schema properties to be statically inferred as `readonly` or `optional`. The following table shows the supported modifiers and how they map between TypeScript and JSON Schema.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
@@ -484,9 +567,9 @@ TypeBox provides modifiers that can be applied to an objects properties. This al
 │ const T = Type.Object({        │ type T = {                  │ const T = {                    │
 │   name: Type.Optional(         │   name?: string             │   type: 'object',              │
 │     Type.String()              │ }                           │   properties: {                │
-│   )                            │                             │      name: {                   │
-│ })  	                         │                             │        type: 'string'          │
-│                                │                             │      }                         │
+│   )                            │                             │     name: {                    │
+│ })  	                         │                             │       type: 'string'           │
+│                                │                             │     }                          │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
@@ -518,24 +601,96 @@ TypeBox provides modifiers that can be applied to an objects properties. This al
 
 ### Options
 
-You can pass additional JSON schema options on the last argument of any given type. The following are some examples.
+You can pass JSON Schema options on the last argument of any type. Option hints specific to each type are provided for convenience.
 
 ```typescript
-// string must be an email
-const T = Type.String({ format: 'email' })
+// String must be an email
+const T = Type.String({                              // const T = { 
+  format: 'email'                                    //   type: 'string',
+})                                                   //   format: 'email' 
+                                                     // }
 
-// number must be a multiple of 2
-const T = Type.Number({ multipleOf: 2 })
+// Mumber must be a multiple of 2
+const T = Type.Number({                              // const T = { 
+  multipleOf: 2                                      //  type: 'number', 
+})                                                   //  multipleOf: 2 
+                                                     // }
+
+// Array must have at least 5 integer values
+const T = Type.Array(Type.Integer(), {               // const T = { 
+  minItems: 5                                        //   type: 'array',
+})                                                   //   minItems: 5,        
+                                                     //   items: { 
+                                                     //     type: 'integer'
+                                                     //   }
+                                                     // }
 
-// array must have at least 5 integer values
-const T = Type.Array(Type.Integer(), { minItems: 5 })
 ```
 
-<a name='types-reference'></a>
+<a name='types-generics'></a>
 
-### Reference
+### Generic Types
 
-Use `Type.Ref(...)` to create referenced types. The target type must specify an `$id`.
+Generic types can be created with generic functions constrained to type `TSchema`. The following creates a generic `Vector<T>` type.
+
+```typescript
+import { Type, Static, TSchema } from '@sinclair/typebox'
+
+const Vector = <T extends TSchema>(t: T) => Type.Object({ x: t, y: t, z: t })
+
+const NumberVector = Vector(Type.Number())           // const NumberVector = {
+                                                     //   type: 'object',
+                                                     //   required: ['x', 'y', 'z'],
+                                                     //   properties: {
+                                                     //     x: { type: 'number' },
+                                                     //     y: { type: 'number' },
+                                                     //     z: { type: 'number' }
+                                                     //   }
+                                                     // }
+
+type NumberVector = Static<typeof NumberVector>      // type NumberVector = {
+                                                     //   x: number,
+                                                     //   y: number,
+                                                     //   z: number
+                                                     // }
+
+const BooleanVector = Vector(Type.Boolean())         // const BooleanVector = {
+                                                     //   type: 'object',
+                                                     //   required: ['x', 'y', 'z'],
+                                                     //   properties: {
+                                                     //     x: { type: 'boolean' },
+                                                     //     y: { type: 'boolean' },
+                                                     //     z: { type: 'boolean' }
+                                                     //   }
+                                                     // }
+
+type BooleanVector = Static<typeof BooleanVector>    // type BooleanVector = {
+                                                     //   x: boolean,
+                                                     //   y: boolean,
+                                                     //   z: boolean
+                                                     // }
+```
+
+The following creates a generic `Nullable<T>` type.
+
+```typescript
+const Nullable = <T extends TSchema>(schema: T) => Type.Union([schema, Type.Null()])
+
+const T = Nullable(Type.String())                   // const T = {
+                                                    //   anyOf: [
+                                                    //     { type: 'string' },
+                                                    //     { type: 'null' }
+                                                    //   ]
+                                                    // }
+
+type T = Static<typeof T>                           // type T = string | null
+```
+
+<a name='types-references'></a>
+
+### Reference Types
+
+Reference types are supported with `Type.Ref(...)`. The target type must specify a valid `$id`.
 
 ```typescript
 const T = Type.String({ $id: 'T' })                  // const T = {
@@ -550,9 +705,9 @@ const R = Type.Ref(T)                                // const R = {
 
 <a name='types-recursive'></a>
 
-### Recursive
+### Recursive Types
 
-Use `Type.Recursive(...)` to create recursive types.
+Recursive types are supported with `Type.Recursive(...)`.
 
 ```typescript
 const Node = Type.Recursive(Node => Type.Object({    // const Node = {
@@ -581,102 +736,41 @@ type Node = Static<typeof Node>                      // type Node = {
                                                      // }
 
 function test(node: Node) {
-  const id = node.nodes[0].nodes[0]                  // id is string
-                 .nodes[0].nodes[0]
-                 .id
+  const id = node.nodes[0].nodes[0].id               // id is string
 }
 ```
 
-<a name='types-generic'></a>
-
-### Generic
-
-Use functions to create generic types. The following creates a generic `Nullable<T>` type. 
-
-```typescript
-import { Type, Static, TSchema } from '@sinclair/typebox'
-
-const Nullable = <T extends TSchema>(type: T) => Type.Union([type, Type.Null()])
-
-const T = Nullable(Type.String())                    // const T = {
-                                                     //   anyOf: [{
-                                                     //     type: 'string'
-                                                     //   }, {
-                                                     //     type: 'null'
-                                                     //   }]
-                                                     // }
-
-type T = Static<typeof T>                            // type T = string | null
-
-const U = Nullable(Type.Number())                    // const U = {
-                                                     //   anyOf: [{
-                                                     //     type: 'number'
-                                                     //   }, {
-                                                     //     type: 'null'
-                                                     //   }]
-                                                     // }
-
-type U = Static<typeof U>                            // type U = number | null
-```
-
 <a name='types-conditional'></a>
 
-### Conditional
+### Conditional Types
 
-Use the conditional module to create [Conditional Types](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html). This module implements TypeScript's structural equivalence checks to enable TypeBox types to be conditionally inferred at runtime. This module also provides the [Extract](https://www.typescriptlang.org/docs/handbook/utility-types.html#extracttype-union) and [Exclude](https://www.typescriptlang.org/docs/handbook/utility-types.html#excludeuniontype-excludedmembers) utility types which are expressed as conditional types in TypeScript. 
+Conditional types are supported with `Extends`, `Exclude` and `Extract`.
 
-The conditional module is provided as an optional import.
+**TypeScript**
 
 ```typescript
-import { Conditional } from '@sinclair/typebox/conditional'
+type T0 = string extends number ? true : false                                                 
+//   ^ false
+type T1 = Extract<string | number, number>                                                     
+//   ^ number
+type T2 = Exclude<string | number, number>                                                     
+//   ^ string
 ```
-The following table shows the TypeBox mappings between TypeScript and JSON schema.
-
+**TypeBox**
 ```typescript
-┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
-│ TypeBox                        │ TypeScript                  │ JSON Schema                    │
-│                                │                             │                                │
-├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Conditional.Extends( │ type T =                    │ const T = {                    │
-│   Type.String(),               │  string extends number      │   const: false,                │
-│   Type.Number(),               │  true : false               │   type: 'boolean'              │
-│   Type.Literal(true),          │                             │ }                              │
-│   Type.Literal(false)          │                             │                                │
-│ )                              │                             │                                │
-│                                │                             │                                │
-├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Conditional.Extract( │ type T = Extract<           │ const T = {                    │
-│   Type.Union([                 │   'a' | 'b' | 'c',          │   anyOf: [{                    │
-│     Type.Literal('a'),         │   'a' | 'f'                 │     const: 'a'                 │
-│     Type.Literal('b'),         │ >                           │     type: 'string'             │
-│     Type.Literal('c')          │                             │   }]                           │
-│   ]),                          │                             │ }                              │
-│   Type.Union([                 │                             │                                │
-│     Type.Literal('a'),         │                             │                                │
-│     Type.Literal('f')          │                             │                                │
-│   ])                           │                             │                                │
-│ )                              │                             │                                │
-│                                │                             │                                │
-├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Conditional.Exclude( │ type T = Exclude<           │ const T = {                    │
-│   Type.Union([                 │   'a' | 'b' | 'c',          │   anyOf: [{                    │
-│     Type.Literal('a'),         │   'a'                       │     const: 'b',                │
-│     Type.Literal('b'),         │ >                           │     type: 'string'             │
-│     Type.Literal('c')          │                             │   }, {                         │
-│   ]),                          │                             │     const: 'c',                │
-│   Type.Union([                 │                             │     type: 'string'             │
-│     Type.Literal('a')          │                             │   }]                           │
-│   ])                           │                             │ }                              │
-│ )                              │                             │                                │
-│                                │                             │                                │
-└────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
+const T0 = Type.Extends(Type.String(), Type.Number(), Type.Literal(true), Type.Literal(false)) 
+//    ^ TLiteral<false>
+const T1 = Type.Extract(Type.Union([Type.String(), Type.Number()]), Type.Number())             
+//    ^ TNumber
+const T2 = Type.Exclude(Type.Union([Type.String(), Type.Number()]), Type.Number())             
+//    ^ TString<string>
 ```
 
 <a name='types-unsafe'></a>
 
 ### Unsafe
 
-Use `Type.Unsafe(...)` to create custom schemas with user defined inference rules.
+Use `Type.Unsafe(...)` to create custom schematics with user defined inference rules.
 
 ```typescript
 const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
@@ -686,16 +780,12 @@ const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
 type T = Static<typeof T>                            // type T = string
 ```
 
-This function can be used to create custom schemas for validators that require specific schema representations. An example of this might be OpenAPI's `nullable` and `enum` schemas which are not provided by TypeBox. The following demonstrates using `Type.Unsafe(...)` to create these types.
+The `Type.Unsafe(...)` type can be useful to express specific OpenAPI schema representations.
 
 ```typescript
 import { Type, Static, TSchema } from '@sinclair/typebox'
 
-//--------------------------------------------------------------------------------------------
-//
 // Nullable<T>
-//
-//--------------------------------------------------------------------------------------------
 
 function Nullable<T extends TSchema>(schema: T) {
   return Type.Unsafe<Static<T> | null>({ ...schema, nullable: true })
@@ -708,12 +798,7 @@ const T = Nullable(Type.String())                    // const T = {
 
 type T = Static<typeof T>                            // type T = string | null
 
-
-//--------------------------------------------------------------------------------------------
-//
 // StringEnum<string[]>
-//
-//--------------------------------------------------------------------------------------------
 
 function StringEnum<T extends string[]>(values: [...T]) {
   return Type.Unsafe<T[number]>({ type: 'string', enum: values })
@@ -730,10 +815,10 @@ type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
 
 ### Guards
 
-Use the guard module to test if values are TypeBox types.
+TypeBox provides a `TypeGuard` module that can be used for reflection and asserting values as types.
 
 ```typescript
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { Type, TypeGuard } from '@sinclair/typebox'
 
 const T = Type.String()
 
@@ -747,7 +832,7 @@ if(TypeGuard.TString(T)) {
 
 ### Strict
 
-TypeBox schemas contain the `Kind` and `Modifier` symbol properties. These properties are provided to enable runtime type reflection on schemas, as well as helping TypeBox internally compose types. These properties are not strictly valid JSON schema; so in some cases it may be desirable to omit them. TypeBox provides a `Type.Strict()` function that will omit these properties if necessary.
+TypeBox schemas contain the `Kind` and `Modifier` symbol properties. These properties are used for type composition and reflection. These properties are not strictly valid JSON schema; so in some cases it may be desirable to omit them. TypeBox provides a `Type.Strict()` function that will omit these properties if necessary.
 
 ```typescript
 const T = Type.Object({                              // const T = {
@@ -776,7 +861,7 @@ const U = Type.Strict(T)                             // const U = {
 
 ## Values
 
-TypeBox includes an optional values module that can be used to perform common operations on JavaScript values. This module enables one to create, check and cast values from types. It also provides functionality to check equality, clone and diff and patch JavaScript values. The value module is provided as an optional import.
+TypeBox provides an optional utility module that can be used to perform common operations on JavaScript values. This module includes functionality to create, check and cast values from types as well as check equality, clone, diff and patch JavaScript values. This module is provided via optional import.
 
 ```typescript
 import { Value } from '@sinclair/typebox/value'
@@ -786,7 +871,7 @@ import { Value } from '@sinclair/typebox/value'
 
 ### Create
 
-Use the Create function to create a value from a TypeBox type. TypeBox will use default values if specified.
+Use the Create function to create a value from a type. TypeBox will use default values if specified.
 
 ```typescript
 const T = Type.Object({ x: Type.Number(), y: Type.Number({ default: 42 }) })
@@ -816,6 +901,20 @@ const T = Type.Object({ x: Type.Number() })
 const R = Value.Check(T, { x: 1 })                   // const R = true
 ```
 
+<a name='values-convert'></a>
+
+### Convert
+
+Use the Convert function to convert a value into its target type if a reasonable conversion is possible.
+
+```typescript
+const T = Type.Object({ x: Type.Number(), y: Type.Number() })
+
+const R1 = Value.Convert(T, { x: '3.14' })          // const R1 = { x: 3.14 }
+
+const R2 = Value.Convert(T, { x: 'not a number' })  // const R2 = { x: 'not a number' }
+```
+
 <a name='values-cast'></a>
 
 ### Cast
@@ -918,7 +1017,7 @@ const R = [...Value.Errors(T, { x: '42' })]          // const R = [{
 
 ### Pointer
 
-Use ValuePointer to perform mutable updates on existing values using [RFC6901](https://www.rfc-editor.org/rfc/rfc6901) Json Pointers.
+Use ValuePointer to perform mutable updates on existing values using [RFC6901](https://www.rfc-editor.org/rfc/rfc6901) JSON Pointers.
 
 ```typescript
 import { ValuePointer } from '@sinclair/typebox/value'
@@ -933,15 +1032,15 @@ ValuePointer.Set(A, '/z', 1)                         // const A = { x: 1, y: 1,
 
 ## TypeCheck
 
-TypeBox constructs JSON Schema draft 6 compliant schematics and can be used with any validator that supports this specification. In JavaScript, an ideal validator to use is Ajv which supports draft 6 as well as more recent revisions to the specification. In addition to Ajv, TypeBox provides an optional built in type compiler which can offer faster runtime type compilation, as well as providing high performance data validation for TypeBox types only.
+TypeBox types target JSON Schema draft 6 so are compatible with any validator that supports this specification. TypeBox also provides a built in type checking compiler designed specifically for high performance compilation and value assertion.
 
-The following sections detail using these validators.
+The following sections detail using Ajv and TypeBox's compiler infrastructure.
 
 <a name='typecheck-ajv'></a>
 
 ## Ajv
 
-The following shows the recommended setup for Ajv. 
+The following shows the recommended setup for Ajv.
 
 ```bash
 $ npm install ajv ajv-formats --save
@@ -982,7 +1081,7 @@ const R = C({ x: 1, y: 2, z: 3 })                    // const R = true
 
 ### TypeCompiler
 
-The TypeCompiler is a Just-In-Time (JIT) runtime compiler that can be used to convert TypeBox types into fast validation routines. This compiler is specifically tuned for fast compilation and validation for TypeBox types only. 
+The TypeBox TypeCompiler is a high performance JIT compiler that transforms TypeBox types into optimized JavaScript validation routines. The compiler is tuned for fast compilation as well as fast value assertion. It is designed to serve as a validation backend that can be integrated into larger applications; but can also be used as a general purpose validator.
 
 The TypeCompiler is provided as an optional import.
 
@@ -1002,7 +1101,7 @@ const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObje
 const R = C.Check({ x: 1, y: 2, z: 3 })              // const R = true
 ```
 
-Use `Errors(...)` to generate diagnostics for a value. The `Errors(...)` function will run an exhaustive check across the value and yield any error found. For performance, this function should only be called after failed `Check(...)`.
+Use the `Errors(...)` function to produce diagnostic errors for a value. The `Errors(...)` function will return an iterator that if enumerated; will perform an exhaustive check across the entire value and yield any error found. For performance, this function should only be called after failed `Check(...)`. Applications may also choose to yield only the first value to avoid exhaustive error generation.
 
 ```typescript
 const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
@@ -1047,7 +1146,7 @@ console.log(C.Code())                                // return function check(va
 
 ## TypeSystem
 
-TypeBox provides an extensible TypeSystem module that enables developers to define additional types above and beyond the built in type set. This module also allows developers to define custom string formats as well as override certain type checking behaviours.
+The TypeBox TypeSystem module provides functionality to define types above and beyond the Standard and Extended type sets as well as control various assertion polices. Configurations made to the TypeSystem module are observed by both `TypeCompiler` and `Value` modules.
 
 The TypeSystem module is provided as an optional import.
 
@@ -1059,71 +1158,62 @@ import { TypeSystem } from '@sinclair/typebox/system'
 
 ### Types
 
-Use the `CreateType(...)` function to specify custom type. This function will return a type factory function that can be used to construct the type. The following creates and registers a BigNumber type which will statically infer as `bigint`. 
+Use the `Type(...)` function to create a custom type. This function will return a type factory function that can be used to construct the type. The following creates a Point type.
 
 ```typescript
-//--------------------------------------------------------------------------------------------
-//
-// Use TypeSystem.CreateType(...) to define and return a type factory function
-//
-//--------------------------------------------------------------------------------------------
+type PointOptions = { }                              // The Type Options
 
-type BigNumberOptions = { minimum?: bigint; maximum?: bigint }
+type PointType = { x: number, y: number }            // The Static<T> Type
 
-const BigNumber = TypeSystem.CreateType<bigint, BigNumberOptions>(
-  'BigNumber', 
-  (options, value) => {
-    if (typeof value !== 'bigint') return false
-    if (options.maximum !== undefined && value > options.maximum) return false
-    if (options.minimum !== undefined && value < options.minimum) return false
-    return true
-  }
-)
+const Point = TypeSystem.Type<PointType, PointOptions>('Point', (options, value) => {
+  return (
+    typeof value === 'object' && value !== null &&
+    typeof value.x === 'number' && 
+    typeof value.y === 'number'
+  )
+})
 
-//--------------------------------------------------------------------------------------------
-//
-// Use the custom type like any other type
-//
-//--------------------------------------------------------------------------------------------
+const T = Point()
 
-const T = BigNumber({ minimum: 10n, maximum: 20n })  // const T = { 
-                                                     //    minimum: 10n, 
-                                                     //    maximum: 20n, 
-                                                     //    [Symbol(TypeBox.Kind)]: 'BigNumber' 
-                                                     //  }
+type T = Static<typeof T>                             // type T = { x: number, y: number }
 
-const C = TypeCompiler.Compile(T)
-const X = C.Check(15n)                               // const X = true
-const Y = C.Check(5n)                                // const Y = false
-const Z = C.Check(25n)                               // const Z = false
+const R = Value.Check(T, { x: 1, y: 2 })              // const R = true
 ```
 
 <a name='typesystem-formats'></a>
 
 ### Formats
 
-Use the `CreateFormat(...)` function to specify user defined string formats. The following creates a custom string format that checks for lowercase.
+Use the `Format(...)` function to create a custom string format. The following creates a custom string format that checks for lowercase strings.
 
 ```typescript
-//--------------------------------------------------------------------------------------------
-//
-// Use TypeSystem.CreateFormat(...) to define a custom string format
-//
-//--------------------------------------------------------------------------------------------
+TypeSystem.Format('lowercase', value => value === value.toLowerCase()) // format should be lowercase
 
-TypeSystem.CreateFormat('lowercase', value => value === value.toLowerCase())
+const T = Type.String({ format: 'lowercase' })       
 
-//--------------------------------------------------------------------------------------------
-//
-// Use the format by creating string types with the 'format' option
+const A = Value.Check(T, 'action')                   // const A = true
+
+const B = Value.Check(T, 'ACTION')                   // const B = false
+```
+
+<a name='typesystem-policies'></a>
+
+### Policies
+
+TypeBox validates using JSON Schema assertion policies by default. It is possible to override these policies and have TypeBox assert using TypeScript policies. The following overrides are available.
+
+```typescript
+// Allow arrays to validate as object types (default is false)
 //
-//--------------------------------------------------------------------------------------------
+// const A: {} = [] - allowed in TS
 
-const T = Type.String({ format: 'lowercase' })
+TypeSystem.AllowArrayObjects = true                  
 
-const A = Value.Check(T, 'action')                   // const A = true
+// Allow numeric values to be NaN or + or - Infinity (default is false)
+//
+// const A: number = NaN - allowed in TS
 
-const B = Value.Check(T, 'ACTION')                   // const B = false
+TypeSystem.AllowNaN = true                      
 ```
 
 <a name='benchmark'></a>
@@ -1141,33 +1231,37 @@ For additional comparative benchmarks, please refer to [typescript-runtime-type-
 This benchmark measures compilation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/measurement/module/compile.ts).
 
 ```typescript
-┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
-│     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
-├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    451 ms' │ '     16 ms' │ '   28.19 x' │
-│           String │    2000    │ '    338 ms' │ '     14 ms' │ '   24.14 x' │
-│          Boolean │    2000    │ '    297 ms' │ '     13 ms' │ '   22.85 x' │
-│             Null │    2000    │ '    265 ms' │ '      8 ms' │ '   33.13 x' │
-│            RegEx │    2000    │ '    492 ms' │ '     18 ms' │ '   27.33 x' │
-│          ObjectA │    2000    │ '   2744 ms' │ '     55 ms' │ '   49.89 x' │
-│          ObjectB │    2000    │ '   3005 ms' │ '     44 ms' │ '   68.30 x' │
-│            Tuple │    2000    │ '   1283 ms' │ '     26 ms' │ '   49.35 x' │
-│            Union │    2000    │ '   1263 ms' │ '     27 ms' │ '   46.78 x' │
-│          Vector4 │    2000    │ '   1622 ms' │ '     23 ms' │ '   70.52 x' │
-│          Matrix4 │    2000    │ '    888 ms' │ '     12 ms' │ '   74.00 x' │
-│   Literal_String │    2000    │ '    344 ms' │ '     14 ms' │ '   24.57 x' │
-│   Literal_Number │    2000    │ '    389 ms' │ '      8 ms' │ '   48.63 x' │
-│  Literal_Boolean │    2000    │ '    374 ms' │ '      9 ms' │ '   41.56 x' │
-│     Array_Number │    2000    │ '    710 ms' │ '     12 ms' │ '   59.17 x' │
-│     Array_String │    2000    │ '    739 ms' │ '      9 ms' │ '   82.11 x' │
-│    Array_Boolean │    2000    │ '    732 ms' │ '      7 ms' │ '  104.57 x' │
-│    Array_ObjectA │    2000    │ '   3733 ms' │ '     42 ms' │ '   88.88 x' │
-│    Array_ObjectB │    2000    │ '   3602 ms' │ '     42 ms' │ '   85.76 x' │
-│      Array_Tuple │    2000    │ '   2204 ms' │ '     20 ms' │ '  110.20 x' │
-│      Array_Union │    2000    │ '   1533 ms' │ '     24 ms' │ '   63.88 x' │
-│    Array_Vector4 │    2000    │ '   2263 ms' │ '     21 ms' │ '  107.76 x' │
-│    Array_Matrix4 │    2000    │ '   1576 ms' │ '     14 ms' │ '  112.57 x' │
-└──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
+┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
+│          (index)           │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
+├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
+│ Literal_String             │    1000    │ '    260 ms' │ '      8 ms' │ '   32.50 x' │
+│ Literal_Number             │    1000    │ '    198 ms' │ '      4 ms' │ '   49.50 x' │
+│ Literal_Boolean            │    1000    │ '    185 ms' │ '      5 ms' │ '   37.00 x' │
+│ Primitive_Number           │    1000    │ '    176 ms' │ '      9 ms' │ '   19.56 x' │
+│ Primitive_String           │    1000    │ '    161 ms' │ '      9 ms' │ '   17.89 x' │
+│ Primitive_String_Pattern   │    1000    │ '    215 ms' │ '     12 ms' │ '   17.92 x' │
+│ Primitive_Boolean          │    1000    │ '    133 ms' │ '      5 ms' │ '   26.60 x' │
+│ Primitive_Null             │    1000    │ '    143 ms' │ '      8 ms' │ '   17.88 x' │
+│ Object_Unconstrained       │    1000    │ '   1181 ms' │ '     38 ms' │ '   31.08 x' │
+│ Object_Constrained         │    1000    │ '   1168 ms' │ '     32 ms' │ '   36.50 x' │
+│ Tuple_Primitive            │    1000    │ '    557 ms' │ '     16 ms' │ '   34.81 x' │
+│ Tuple_Object               │    1000    │ '   1119 ms' │ '     17 ms' │ '   65.82 x' │
+│ Composite_Intersect        │    1000    │ '    569 ms' │ '     22 ms' │ '   25.86 x' │
+│ Composite_Union            │    1000    │ '    513 ms' │ '     23 ms' │ '   22.30 x' │
+│ Math_Vector4               │    1000    │ '    802 ms' │ '     10 ms' │ '   80.20 x' │
+│ Math_Matrix4               │    1000    │ '    395 ms' │ '     12 ms' │ '   32.92 x' │
+│ Array_Primitive_Number     │    1000    │ '    282 ms' │ '      8 ms' │ '   35.25 x' │
+│ Array_Primitive_String     │    1000    │ '    321 ms' │ '      5 ms' │ '   64.20 x' │
+│ Array_Primitive_Boolean    │    1000    │ '    364 ms' │ '      5 ms' │ '   72.80 x' │
+│ Array_Object_Unconstrained │    1000    │ '   1573 ms' │ '     18 ms' │ '   87.39 x' │
+│ Array_Object_Constrained   │    1000    │ '   1270 ms' │ '     20 ms' │ '   63.50 x' │
+│ Array_Tuple_Primitive      │    1000    │ '    973 ms' │ '     18 ms' │ '   54.06 x' │
+│ Array_Tuple_Object         │    1000    │ '   1253 ms' │ '     16 ms' │ '   78.31 x' │
+│ Array_Composite_Intersect  │    1000    │ '    927 ms' │ '     20 ms' │ '   46.35 x' │
+│ Array_Composite_Union      │    1000    │ '   1123 ms' │ '     16 ms' │ '   70.19 x' │
+│ Array_Math_Vector4         │    1000    │ '   1068 ms' │ '     10 ms' │ '  106.80 x' │
+│ Array_Math_Matrix4         │    1000    │ '    488 ms' │ '      7 ms' │ '   69.71 x' │
+└────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
 <a name='benchmark-validate'></a>
@@ -1177,35 +1271,39 @@ This benchmark measures compilation performance for varying types. You can revie
 This benchmark measures validation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/measurement/module/check.ts).
 
 ```typescript
-┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
-│     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
-├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  1000000   │ '     30 ms' │ '      7 ms' │ '      6 ms' │ '    1.17 x' │
-│           String │  1000000   │ '     23 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
-│          Boolean │  1000000   │ '     22 ms' │ '     21 ms' │ '     10 ms' │ '    2.10 x' │
-│             Null │  1000000   │ '     27 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
-│            RegEx │  1000000   │ '    163 ms' │ '     47 ms' │ '     38 ms' │ '    1.24 x' │
-│          ObjectA │  1000000   │ '    654 ms' │ '     41 ms' │ '     24 ms' │ '    1.71 x' │
-│          ObjectB │  1000000   │ '   1173 ms' │ '     59 ms' │ '     41 ms' │ '    1.44 x' │
-│            Tuple │  1000000   │ '    124 ms' │ '     24 ms' │ '     17 ms' │ '    1.41 x' │
-│            Union │  1000000   │ '    332 ms' │ '     26 ms' │ '     16 ms' │ '    1.63 x' │
-│        Recursive │  1000000   │ '   3129 ms' │ '    412 ms' │ '    102 ms' │ '    4.04 x' │
-│          Vector4 │  1000000   │ '    147 ms' │ '     26 ms' │ '     13 ms' │ '    2.00 x' │
-│          Matrix4 │  1000000   │ '    576 ms' │ '     41 ms' │ '     28 ms' │ '    1.46 x' │
-│   Literal_String │  1000000   │ '     51 ms' │ '     21 ms' │ '     10 ms' │ '    2.10 x' │
-│   Literal_Number │  1000000   │ '     47 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
-│  Literal_Boolean │  1000000   │ '     47 ms' │ '     21 ms' │ '     10 ms' │ '    2.10 x' │
-│     Array_Number │  1000000   │ '    490 ms' │ '     33 ms' │ '     18 ms' │ '    1.83 x' │
-│     Array_String │  1000000   │ '    502 ms' │ '     31 ms' │ '     25 ms' │ '    1.24 x' │
-│    Array_Boolean │  1000000   │ '    465 ms' │ '     33 ms' │ '     27 ms' │ '    1.22 x' │
-│    Array_ObjectA │  1000000   │ '  15463 ms' │ '   2470 ms' │ '   2052 ms' │ '    1.20 x' │
-│    Array_ObjectB │  1000000   │ '  18047 ms' │ '   2497 ms' │ '   2348 ms' │ '    1.06 x' │
-│      Array_Tuple │  1000000   │ '   1958 ms' │ '     99 ms' │ '     77 ms' │ '    1.29 x' │
-│      Array_Union │  1000000   │ '   5348 ms' │ '    254 ms' │ '     89 ms' │ '    2.85 x' │
-│  Array_Recursive │  1000000   │ '  54643 ms' │ '   8870 ms' │ '   1158 ms' │ '    7.66 x' │
-│    Array_Vector4 │  1000000   │ '   2724 ms' │ '    105 ms' │ '     48 ms' │ '    2.19 x' │
-│    Array_Matrix4 │  1000000   │ '  13821 ms' │ '    437 ms' │ '    266 ms' │ '    1.64 x' │
-└──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
+┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
+│          (index)           │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
+├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
+│ Literal_String             │  1000000   │ '     26 ms' │ '      6 ms' │ '      6 ms' │ '    1.00 x' │
+│ Literal_Number             │  1000000   │ '     21 ms' │ '     19 ms' │ '     11 ms' │ '    1.73 x' │
+│ Literal_Boolean            │  1000000   │ '     19 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
+│ Primitive_Number           │  1000000   │ '     24 ms' │ '     19 ms' │ '     11 ms' │ '    1.73 x' │
+│ Primitive_String           │  1000000   │ '     26 ms' │ '     17 ms' │ '     10 ms' │ '    1.70 x' │
+│ Primitive_String_Pattern   │  1000000   │ '    159 ms' │ '     45 ms' │ '     37 ms' │ '    1.22 x' │
+│ Primitive_Boolean          │  1000000   │ '     23 ms' │ '     17 ms' │ '     10 ms' │ '    1.70 x' │
+│ Primitive_Null             │  1000000   │ '     23 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
+│ Object_Unconstrained       │  1000000   │ '    809 ms' │ '     35 ms' │ '     30 ms' │ '    1.17 x' │
+│ Object_Constrained         │  1000000   │ '   1060 ms' │ '     56 ms' │ '     45 ms' │ '    1.24 x' │
+│ Object_Recursive           │  1000000   │ '   4965 ms' │ '    397 ms' │ '    100 ms' │ '    3.97 x' │
+│ Tuple_Primitive            │  1000000   │ '    159 ms' │ '     22 ms' │ '     16 ms' │ '    1.38 x' │
+│ Tuple_Object               │  1000000   │ '    658 ms' │ '     31 ms' │ '     27 ms' │ '    1.15 x' │
+│ Composite_Intersect        │  1000000   │ '    695 ms' │ '     26 ms' │ '     22 ms' │ '    1.18 x' │
+│ Composite_Union            │  1000000   │ '    503 ms' │ '     24 ms' │ '     19 ms' │ '    1.26 x' │
+│ Math_Vector4               │  1000000   │ '    259 ms' │ '     22 ms' │ '     14 ms' │ '    1.57 x' │
+│ Math_Matrix4               │  1000000   │ '   1007 ms' │ '     40 ms' │ '     29 ms' │ '    1.38 x' │
+│ Array_Primitive_Number     │  1000000   │ '    262 ms' │ '     23 ms' │ '     17 ms' │ '    1.35 x' │
+│ Array_Primitive_String     │  1000000   │ '    241 ms' │ '     27 ms' │ '     24 ms' │ '    1.13 x' │
+│ Array_Primitive_Boolean    │  1000000   │ '    141 ms' │ '     23 ms' │ '     20 ms' │ '    1.15 x' │
+│ Array_Object_Unconstrained │  1000000   │ '   4976 ms' │ '     70 ms' │ '     67 ms' │ '    1.04 x' │
+│ Array_Object_Constrained   │  1000000   │ '   5234 ms' │ '    143 ms' │ '    120 ms' │ '    1.19 x' │
+│ Array_Object_Recursive     │  1000000   │ '  19605 ms' │ '   1909 ms' │ '    350 ms' │ '    5.45 x' │
+│ Array_Tuple_Primitive      │  1000000   │ '    706 ms' │ '     39 ms' │ '     32 ms' │ '    1.22 x' │
+│ Array_Tuple_Object         │  1000000   │ '   2951 ms' │ '     67 ms' │ '     63 ms' │ '    1.06 x' │
+│ Array_Composite_Intersect  │  1000000   │ '   2969 ms' │ '     49 ms' │ '     44 ms' │ '    1.11 x' │
+│ Array_Composite_Union      │  1000000   │ '   2191 ms' │ '     77 ms' │ '     41 ms' │ '    1.88 x' │
+│ Array_Math_Vector4         │  1000000   │ '   1164 ms' │ '     41 ms' │ '     25 ms' │ '    1.64 x' │
+│ Array_Math_Matrix4         │  1000000   │ '   4903 ms' │ '    115 ms' │ '     99 ms' │ '    1.16 x' │
+└────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
 <a name='benchmark-compression'></a>
@@ -1218,15 +1316,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ ' 65.4 kb' │ ' 32.2 kb' │  '2.03 x'   │
-│ typebox/conditional  │ ' 45.5 kb' │ ' 18.6 kb' │  '2.45 x'   │
-│ typebox/custom       │ '  0.6 kb' │ '  0.2 kb' │  '2.61 x'   │
-│ typebox/format       │ '  0.6 kb' │ '  0.2 kb' │  '2.66 x'   │
-│ typebox/guard        │ ' 23.8 kb' │ ' 11.4 kb' │  '2.08 x'   │
-│ typebox/hash         │ '  4.2 kb' │ '  1.8 kb' │  '2.30 x'   │
-│ typebox/system       │ ' 14.0 kb' │ '  7.1 kb' │  '1.96 x'   │
-│ typebox/value        │ ' 90.0 kb' │ ' 41.8 kb' │  '2.15 x'   │
-│ typebox              │ ' 12.0 kb' │ '  6.4 kb' │  '1.89 x'   │
+│ typebox/compiler     │ '108.8 kb' │ ' 48.9 kb' │  '2.23 x'   │
+│ typebox/errors       │ ' 93.2 kb' │ ' 41.5 kb' │  '2.24 x'   │
+│ typebox/system       │ ' 60.0 kb' │ ' 24.6 kb' │  '2.43 x'   │
+│ typebox/value        │ '153.5 kb' │ ' 66.7 kb' │  '2.30 x'   │
+│ typebox              │ ' 58.7 kb' │ ' 24.1 kb' │  '2.43 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index de1b76664..f773b012c 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -26,37 +26,28 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { ValueErrors, ValueError } from '../errors/index'
-import { TypeSystem } from '../system/index'
-import { TypeExtends, TypeGuard } from '../guard/index'
-import { Format } from '../format/index'
-import { Custom } from '../custom/index'
-import { ValueHash } from '../hash/index'
 import * as Types from '../typebox'
+import { ValueErrors, ValueErrorIterator } from '../errors/index'
+import { TypeSystem } from '../system/index'
+import { ValueHash } from '../value/hash'
 
 // -------------------------------------------------------------------
 // CheckFunction
 // -------------------------------------------------------------------
-
 export type CheckFunction = (value: unknown) => boolean
-
 // -------------------------------------------------------------------
 // TypeCheck
 // -------------------------------------------------------------------
-
 export class TypeCheck<T extends Types.TSchema> {
   constructor(private readonly schema: T, private readonly references: Types.TSchema[], private readonly checkFunc: CheckFunction, private readonly code: string) {}
-
-  /** Returns the generated validation code used to validate this type. */
+  /** Returns the generated assertion code used to validate this type. */
   public Code(): string {
     return this.code
   }
-
   /** Returns an iterator for each error in this value. */
-  public Errors(value: unknown): IterableIterator<ValueError> {
+  public Errors(value: unknown): ValueErrorIterator {
     return ValueErrors.Errors(this.schema, this.references, value)
   }
-
   /** Returns true if the value matches the compiled type. */
   public Check(value: unknown): value is Types.Static<T> {
     return this.checkFunc(value)
@@ -79,7 +70,6 @@ namespace Character {
     return (code >= 65 && code <= 90) || (code >= 97 && code <= 122)
   }
 }
-
 // -------------------------------------------------------------------
 // Identifier
 // -------------------------------------------------------------------
@@ -97,7 +87,6 @@ namespace Identifier {
     return buffer.join('').replace(/__/g, '_')
   }
 }
-
 // -------------------------------------------------------------------
 // MemberExpression
 // -------------------------------------------------------------------
@@ -122,369 +111,386 @@ export namespace MemberExpression {
     return !Check(key) ? `${object}['${key}']` : `${object}.${key}`
   }
 }
-
 // -------------------------------------------------------------------
 // TypeCompiler
 // -------------------------------------------------------------------
-
 export class TypeCompilerUnknownTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
     super('TypeCompiler: Unknown type')
   }
 }
-
+export class TypeCompilerDereferenceError extends Error {
+  constructor(public readonly schema: Types.TRef) {
+    super(`TypeCompiler: Unable to dereference schema with $id '${schema.$ref}'`)
+  }
+}
+export class TypeCompilerTypeGuardError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('TypeCompiler: Preflight validation check failed to guard for the given schema')
+  }
+}
 /** Compiles Types for Runtime Type Checking */
 export namespace TypeCompiler {
   // -------------------------------------------------------------------
   // Guards
   // -------------------------------------------------------------------
+  function IsBigInt(value: unknown): value is bigint {
+    return typeof value === 'bigint'
+  }
   function IsNumber(value: unknown): value is number {
-    return typeof value === 'number' && !globalThis.isNaN(value)
+    return typeof value === 'number' && globalThis.Number.isFinite(value)
+  }
+  function IsString(value: unknown): value is string {
+    return typeof value === 'string'
   }
-
   // -------------------------------------------------------------------
-  // Types
+  // Overrides
   // -------------------------------------------------------------------
-  function* Any(schema: Types.TAny, value: string): IterableIterator<string> {
-    yield '(true)'
+  function IsNumberCheck(value: string): string {
+    return !TypeSystem.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`
   }
-
-  function* Array(schema: Types.TArray, value: string): IterableIterator<string> {
-    const expression = CreateExpression(schema.items, 'value')
-    yield `(Array.isArray(${value}) && ${value}.every(value => ${expression}))`
-    if (IsNumber(schema.minItems)) yield `(${value}.length >= ${schema.minItems})`
-    if (IsNumber(schema.maxItems)) yield `(${value}.length <= ${schema.maxItems})`
-    if (schema.uniqueItems === true) yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`
+  function IsObjectCheck(value: string): string {
+    return !TypeSystem.AllowArrayObjects ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`
   }
-
-  function* Boolean(schema: Types.TBoolean, value: string): IterableIterator<string> {
-    yield `(typeof ${value} === 'boolean')`
+  function IsRecordCheck(value: string): string {
+    return !TypeSystem.AllowArrayObjects
+      ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
+      : `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
   }
-
-  function* Constructor(schema: Types.TConstructor, value: string): IterableIterator<string> {
-    yield* Visit(schema.returns, `${value}.prototype`)
+  function IsVoidCheck(value: string): string {
+    return TypeSystem.AllowVoidNull ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`
   }
-
-  function* Date(schema: Types.TDate, value: string): IterableIterator<string> {
-    yield `(${value} instanceof Date) && !isNaN(${value}.getTime())`
-    if (IsNumber(schema.exclusiveMinimumTimestamp)) yield `(${value}.getTime() > ${schema.exclusiveMinimumTimestamp})`
-    if (IsNumber(schema.exclusiveMaximumTimestamp)) yield `(${value}.getTime() < ${schema.exclusiveMaximumTimestamp})`
-    if (IsNumber(schema.minimumTimestamp)) yield `(${value}.getTime() >= ${schema.minimumTimestamp})`
-    if (IsNumber(schema.maximumTimestamp)) yield `(${value}.getTime() <= ${schema.maximumTimestamp})`
+  // -------------------------------------------------------------------
+  // Types
+  // -------------------------------------------------------------------
+  function* Any(schema: Types.TAny, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield 'true'
+  }
+  function* Array(schema: Types.TArray, references: Types.TSchema[], value: string): IterableIterator<string> {
+    const expression = CreateExpression(schema.items, references, 'value')
+    yield `Array.isArray(${value}) && ${value}.every(value => ${expression})`
+    if (IsNumber(schema.minItems)) yield `${value}.length >= ${schema.minItems}`
+    if (IsNumber(schema.maxItems)) yield `${value}.length <= ${schema.maxItems}`
+    if (schema.uniqueItems === true) yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`
   }
-
-  function* Function(schema: Types.TFunction, value: string): IterableIterator<string> {
-    yield `(typeof ${value} === 'function')`
+  function* BigInt(schema: Types.TBigInt, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield `(typeof ${value} === 'bigint')`
+    if (IsBigInt(schema.multipleOf)) yield `(${value} % BigInt(${schema.multipleOf})) === 0`
+    if (IsBigInt(schema.exclusiveMinimum)) yield `${value} > BigInt(${schema.exclusiveMinimum})`
+    if (IsBigInt(schema.exclusiveMaximum)) yield `${value} < BigInt(${schema.exclusiveMaximum})`
+    if (IsBigInt(schema.minimum)) yield `${value} >= BigInt(${schema.minimum})`
+    if (IsBigInt(schema.maximum)) yield `${value} <= BigInt(${schema.maximum})`
   }
-
-  function* Integer(schema: Types.TInteger, value: string): IterableIterator<string> {
-    yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`
-    if (IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf} === 0)`
-    if (IsNumber(schema.exclusiveMinimum)) yield `(${value} > ${schema.exclusiveMinimum})`
-    if (IsNumber(schema.exclusiveMaximum)) yield `(${value} < ${schema.exclusiveMaximum})`
-    if (IsNumber(schema.minimum)) yield `(${value} >= ${schema.minimum})`
-    if (IsNumber(schema.maximum)) yield `(${value} <= ${schema.maximum})`
+  function* Boolean(schema: Types.TBoolean, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield `typeof ${value} === 'boolean'`
   }
-
-  function* Literal(schema: Types.TLiteral, value: string): IterableIterator<string> {
-    if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
-      yield `(${value} === ${schema.const})`
-    } else {
-      yield `(${value} === '${schema.const}')`
-    }
+  function* Constructor(schema: Types.TConstructor, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield* Visit(schema.returns, references, `${value}.prototype`)
   }
-
-  function* Never(schema: Types.TNever, value: string): IterableIterator<string> {
-    yield `(false)`
+  function* Date(schema: Types.TDate, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`
+    if (IsNumber(schema.exclusiveMinimumTimestamp)) yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`
+    if (IsNumber(schema.exclusiveMaximumTimestamp)) yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`
+    if (IsNumber(schema.minimumTimestamp)) yield `${value}.getTime() >= ${schema.minimumTimestamp}`
+    if (IsNumber(schema.maximumTimestamp)) yield `${value}.getTime() <= ${schema.maximumTimestamp}`
   }
-
-  function* Null(schema: Types.TNull, value: string): IterableIterator<string> {
-    yield `(${value} === null)`
+  function* Function(schema: Types.TFunction, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield `typeof ${value} === 'function'`
   }
-
-  function* Number(schema: Types.TNumber, value: string): IterableIterator<string> {
-    if (TypeSystem.AllowNaN) {
-      yield `(typeof ${value} === 'number')`
-    } else {
-      yield `(typeof ${value} === 'number' && !isNaN(${value}))`
+  function* Integer(schema: Types.TInteger, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`
+    if (IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf}) === 0`
+    if (IsNumber(schema.exclusiveMinimum)) yield `${value} > ${schema.exclusiveMinimum}`
+    if (IsNumber(schema.exclusiveMaximum)) yield `${value} < ${schema.exclusiveMaximum}`
+    if (IsNumber(schema.minimum)) yield `${value} >= ${schema.minimum}`
+    if (IsNumber(schema.maximum)) yield `${value} <= ${schema.maximum}`
+  }
+  function* Intersect(schema: Types.TIntersect, references: Types.TSchema[], value: string): IterableIterator<string> {
+    if (schema.unevaluatedProperties === undefined) {
+      const expressions = schema.allOf.map((schema: Types.TSchema) => CreateExpression(schema, references, value))
+      yield `${expressions.join(' && ')}`
+    } else if (schema.unevaluatedProperties === false) {
+      // prettier-ignore
+      const schemaKeys = Types.KeyResolver.Resolve(schema).map((key) => `'${key}'`).join(', ')
+      const expressions = schema.allOf.map((schema: Types.TSchema) => CreateExpression(schema, references, value))
+      const expression1 = `Object.getOwnPropertyNames(${value}).every(key => [${schemaKeys}].includes(key))`
+      yield `${expressions.join(' && ')} && ${expression1}`
+    } else if (typeof schema.unevaluatedProperties === 'object') {
+      // prettier-ignore
+      const schemaKeys = Types.KeyResolver.Resolve(schema).map((key) => `'${key}'`).join(', ')
+      const expressions = schema.allOf.map((schema: Types.TSchema) => CreateExpression(schema, references, value))
+      const expression1 = CreateExpression(schema.unevaluatedProperties, references, 'value[key]')
+      const expression2 = `Object.getOwnPropertyNames(${value}).every(key => [${schemaKeys}].includes(key) || ${expression1})`
+      yield `${expressions.join(' && ')} && ${expression2}`
     }
-    if (IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf} === 0)`
-    if (IsNumber(schema.exclusiveMinimum)) yield `(${value} > ${schema.exclusiveMinimum})`
-    if (IsNumber(schema.exclusiveMaximum)) yield `(${value} < ${schema.exclusiveMaximum})`
-    if (IsNumber(schema.minimum)) yield `(${value} >= ${schema.minimum})`
-    if (IsNumber(schema.maximum)) yield `(${value} <= ${schema.maximum})`
   }
-
-  function* Object(schema: Types.TObject, value: string): IterableIterator<string> {
-    if (TypeSystem.AllowArrayObjects) {
-      yield `(typeof ${value} === 'object' && ${value} !== null)`
+  function* Literal(schema: Types.TLiteral, references: Types.TSchema[], value: string): IterableIterator<string> {
+    if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
+      yield `${value} === ${schema.const}`
     } else {
-      yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`
+      yield `${value} === '${schema.const}'`
     }
-    if (IsNumber(schema.minProperties)) yield `(Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties})`
-    if (IsNumber(schema.maxProperties)) yield `(Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties})`
-    const propertyKeys = globalThis.Object.getOwnPropertyNames(schema.properties)
-    if (schema.additionalProperties === false) {
-      // Optimization: If the property key length matches the required keys length
-      // then we only need check that the values property key length matches that
-      // of the property key length. This is because exhaustive testing for values
-      // will occur in subsequent property tests.
-      if (schema.required && schema.required.length === propertyKeys.length) {
-        yield `(Object.getOwnPropertyNames(${value}).length === ${propertyKeys.length})`
+  }
+  function* Never(schema: Types.TNever, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield `false`
+  }
+  function* Not(schema: Types.TNot, references: Types.TSchema[], value: string): IterableIterator<string> {
+    const left = CreateExpression(schema.allOf[0].not, references, value)
+    const right = CreateExpression(schema.allOf[1], references, value)
+    yield `!${left} && ${right}`
+  }
+  function* Null(schema: Types.TNull, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield `${value} === null`
+  }
+  function* Number(schema: Types.TNumber, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield IsNumberCheck(value)
+    if (IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf}) === 0`
+    if (IsNumber(schema.exclusiveMinimum)) yield `${value} > ${schema.exclusiveMinimum}`
+    if (IsNumber(schema.exclusiveMaximum)) yield `${value} < ${schema.exclusiveMaximum}`
+    if (IsNumber(schema.minimum)) yield `${value} >= ${schema.minimum}`
+    if (IsNumber(schema.maximum)) yield `${value} <= ${schema.maximum}`
+  }
+
+  function* Object(schema: Types.TObject, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield IsObjectCheck(value)
+    if (!TypeSystem.AllowArrayObjects) yield `!Array.isArray(${value})`
+    if (IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
+    if (IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
+    const schemaKeys = globalThis.Object.getOwnPropertyNames(schema.properties)
+    for (const schemaKey of schemaKeys) {
+      const memberExpression = MemberExpression.Encode(value, schemaKey)
+      const property = schema.properties[schemaKey]
+      if (schema.required && schema.required.includes(schemaKey)) {
+        yield* Visit(property, references, memberExpression)
+        if (Types.ExtendsUndefined.Check(property)) yield `('${schemaKey}' in ${value})`
       } else {
-        const keys = `[${propertyKeys.map((key) => `'${key}'`).join(', ')}]`
-        yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key)))`
+        const expression = CreateExpression(property, references, memberExpression)
+        yield `('${schemaKey}' in ${value} ? ${expression} : true)`
       }
     }
-    if (TypeGuard.TSchema(schema.additionalProperties)) {
-      const expression = CreateExpression(schema.additionalProperties, 'value[key]')
-      const keys = `[${propertyKeys.map((key) => `'${key}'`).join(', ')}]`
-      yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`
-    }
-    for (const propertyKey of propertyKeys) {
-      const memberExpression = MemberExpression.Encode(value, propertyKey)
-      const propertySchema = schema.properties[propertyKey]
-      if (schema.required && schema.required.includes(propertyKey)) {
-        yield* Visit(propertySchema, memberExpression)
-        if (TypeExtends.Undefined(propertySchema)) {
-          yield `('${propertyKey}' in ${value})`
-        }
+    if (schema.additionalProperties === false) {
+      if (schema.required && schema.required.length === schemaKeys.length) {
+        yield `Object.getOwnPropertyNames(${value}).length === ${schemaKeys.length}`
       } else {
-        const expression = CreateExpression(propertySchema, memberExpression)
-        yield `(${memberExpression} === undefined ? true : (${expression}))`
+        const keys = `[${schemaKeys.map((key) => `'${key}'`).join(', ')}]`
+        yield `Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key))`
       }
     }
+    if (typeof schema.additionalProperties === 'object') {
+      const expression = CreateExpression(schema.additionalProperties, references, 'value[key]')
+      const keys = `[${schemaKeys.map((key) => `'${key}'`).join(', ')}]`
+      yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`
+    }
   }
-
-  function* Promise(schema: Types.TPromise<any>, value: string): IterableIterator<string> {
+  function* Promise(schema: Types.TPromise<any>, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof value === 'object' && typeof ${value}.then === 'function')`
   }
 
-  function* Record(schema: Types.TRecord<any, any>, value: string): IterableIterator<string> {
-    if (TypeSystem.AllowArrayObjects) {
-      yield `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date))`
-    } else {
-      yield `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !Array.isArray(${value}))`
-    }
+  function* Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield IsRecordCheck(value)
     const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
     const local = PushLocal(`new RegExp(/${keyPattern}/)`)
     yield `(Object.getOwnPropertyNames(${value}).every(key => ${local}.test(key)))`
-    const expression = CreateExpression(valueSchema, 'value')
-    yield `(Object.values(${value}).every(value => ${expression}))`
+    const expression = CreateExpression(valueSchema, references, 'value')
+    yield `Object.values(${value}).every(value => ${expression})`
   }
-
-  function* Ref(schema: Types.TRef<any>, value: string): IterableIterator<string> {
+  function* Ref(schema: Types.TRef<any>, references: Types.TSchema[], value: string): IterableIterator<string> {
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+    if (index === -1) throw new TypeCompilerDereferenceError(schema)
+    const target = references[index]
     // Reference: If we have seen this reference before we can just yield and return
     // the function call. If this isn't the case we defer to visit to generate and
     // set the function for subsequent passes. Consider for refactor.
-    if (state_local_function_names.has(schema.$ref)) return yield `(${CreateFunctionName(schema.$ref)}(${value}))`
-    if (!state_reference_map.has(schema.$ref)) throw Error(`TypeCompiler.Ref: Cannot de-reference schema with $id '${schema.$ref}'`)
-    const reference = state_reference_map.get(schema.$ref)!
-    yield* Visit(reference, value)
+    if (state_local_function_names.has(schema.$ref)) return yield `${CreateFunctionName(schema.$ref)}(${value})`
+    yield* Visit(target, references, value)
   }
-
-  function* Self(schema: Types.TSelf, value: string): IterableIterator<string> {
+  function* Self(schema: Types.TSelf, references: Types.TSchema[], value: string): IterableIterator<string> {
     const func = CreateFunctionName(schema.$ref)
-    yield `(${func}(${value}))`
+    yield `${func}(${value})`
   }
-
-  function* String(schema: Types.TString, value: string): IterableIterator<string> {
+  function* String(schema: Types.TString, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'string')`
-    if (IsNumber(schema.minLength)) yield `(${value}.length >= ${schema.minLength})`
-    if (IsNumber(schema.maxLength)) yield `(${value}.length <= ${schema.maxLength})`
+    if (IsNumber(schema.minLength)) yield `${value}.length >= ${schema.minLength}`
+    if (IsNumber(schema.maxLength)) yield `${value}.length <= ${schema.maxLength}`
     if (schema.pattern !== undefined) {
       const local = PushLocal(`${new RegExp(schema.pattern)};`)
-      yield `(${local}.test(${value}))`
+      yield `${local}.test(${value})`
     }
     if (schema.format !== undefined) {
-      yield `(format('${schema.format}', ${value}))`
+      yield `format('${schema.format}', ${value})`
     }
   }
-
-  function* Tuple(schema: Types.TTuple<any[]>, value: string): IterableIterator<string> {
+  function* Symbol(schema: Types.TSymbol, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield `(typeof ${value} === 'symbol')`
+  }
+  function* Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(Array.isArray(${value}))`
-    if (schema.items === undefined) return yield `(${value}.length === 0)`
+    if (schema.items === undefined) return yield `${value}.length === 0`
     yield `(${value}.length === ${schema.maxItems})`
     for (let i = 0; i < schema.items.length; i++) {
-      const expression = CreateExpression(schema.items[i], `${value}[${i}]`)
-      yield `(${expression})`
+      const expression = CreateExpression(schema.items[i], references, `${value}[${i}]`)
+      yield `${expression}`
     }
   }
-
-  function* Undefined(schema: Types.TUndefined, value: string): IterableIterator<string> {
-    yield `(${value} === undefined)`
+  function* Undefined(schema: Types.TUndefined, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield `${value} === undefined`
   }
-
-  function* Union(schema: Types.TUnion<any[]>, value: string): IterableIterator<string> {
-    const expressions = schema.anyOf.map((schema: Types.TSchema) => CreateExpression(schema, value))
+  function* Union(schema: Types.TUnion<any[]>, references: Types.TSchema[], value: string): IterableIterator<string> {
+    const expressions = schema.anyOf.map((schema: Types.TSchema) => CreateExpression(schema, references, value))
     yield `(${expressions.join(' || ')})`
   }
-
-  function* Uint8Array(schema: Types.TUint8Array, value: string): IterableIterator<string> {
-    yield `(${value} instanceof Uint8Array)`
+  function* Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield `${value} instanceof Uint8Array`
     if (IsNumber(schema.maxByteLength)) yield `(${value}.length <= ${schema.maxByteLength})`
     if (IsNumber(schema.minByteLength)) yield `(${value}.length >= ${schema.minByteLength})`
   }
-
-  function* Unknown(schema: Types.TUnknown, value: string): IterableIterator<string> {
-    yield '(true)'
+  function* Unknown(schema: Types.TUnknown, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield 'true'
   }
-
-  function* Void(schema: Types.TVoid, value: string): IterableIterator<string> {
-    yield `(${value} === null)`
+  function* Void(schema: Types.TVoid, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield IsVoidCheck(value)
   }
-
-  function* UserDefined(schema: Types.TSchema, value: string): IterableIterator<string> {
+  function* UserDefined(schema: Types.TSchema, references: Types.TSchema[], value: string): IterableIterator<string> {
     const schema_key = `schema_key_${state_remote_custom_types.size}`
     state_remote_custom_types.set(schema_key, schema)
-    yield `(custom('${schema[Types.Kind]}', '${schema_key}', ${value}))`
+    yield `custom('${schema[Types.Kind]}', '${schema_key}', ${value})`
   }
-
-  function* Visit<T extends Types.TSchema>(schema: T, value: string): IterableIterator<string> {
+  function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: string): IterableIterator<string> {
+    const references_ = IsString(schema.$id) ? [...references, schema] : references
+    const schema_ = schema as any
     // Reference: Referenced schemas can originate from either additional schemas
     // or inline in the schema itself. Ideally the recursive path should align to
     // reference path. Consider for refactor.
-    if (schema.$id && !state_local_function_names.has(schema.$id)) {
+    if (IsString(schema.$id) && !state_local_function_names.has(schema.$id)) {
       state_local_function_names.add(schema.$id)
       const name = CreateFunctionName(schema.$id)
-      const body = CreateFunction(name, schema, 'value')
+      const body = CreateFunction(name, schema, references, 'value')
       PushFunction(body)
-      yield `(${name}(${value}))`
+      yield `${name}(${value})`
       return
     }
-    const anySchema = schema as any
-    switch (anySchema[Types.Kind]) {
+    switch (schema_[Types.Kind]) {
       case 'Any':
-        return yield* Any(anySchema, value)
+        return yield* Any(schema_, references_, value)
       case 'Array':
-        return yield* Array(anySchema, value)
+        return yield* Array(schema_, references_, value)
+      case 'BigInt':
+        return yield* BigInt(schema_, references_, value)
       case 'Boolean':
-        return yield* Boolean(anySchema, value)
+        return yield* Boolean(schema_, references_, value)
       case 'Constructor':
-        return yield* Constructor(anySchema, value)
+        return yield* Constructor(schema_, references_, value)
       case 'Date':
-        return yield* Date(anySchema, value)
+        return yield* Date(schema_, references_, value)
       case 'Function':
-        return yield* Function(anySchema, value)
+        return yield* Function(schema_, references_, value)
       case 'Integer':
-        return yield* Integer(anySchema, value)
+        return yield* Integer(schema_, references_, value)
+      case 'Intersect':
+        return yield* Intersect(schema_, references_, value)
       case 'Literal':
-        return yield* Literal(anySchema, value)
+        return yield* Literal(schema_, references_, value)
       case 'Never':
-        return yield* Never(anySchema, value)
+        return yield* Never(schema_, references_, value)
+      case 'Not':
+        return yield* Not(schema_, references_, value)
       case 'Null':
-        return yield* Null(anySchema, value)
+        return yield* Null(schema_, references_, value)
       case 'Number':
-        return yield* Number(anySchema, value)
+        return yield* Number(schema_, references_, value)
       case 'Object':
-        return yield* Object(anySchema, value)
+        return yield* Object(schema_, references_, value)
       case 'Promise':
-        return yield* Promise(anySchema, value)
+        return yield* Promise(schema_, references_, value)
       case 'Record':
-        return yield* Record(anySchema, value)
+        return yield* Record(schema_, references_, value)
       case 'Ref':
-        return yield* Ref(anySchema, value)
+        return yield* Ref(schema_, references_, value)
       case 'Self':
-        return yield* Self(anySchema, value)
+        return yield* Self(schema_, references_, value)
       case 'String':
-        return yield* String(anySchema, value)
+        return yield* String(schema_, references_, value)
+      case 'Symbol':
+        return yield* Symbol(schema_, references_, value)
       case 'Tuple':
-        return yield* Tuple(anySchema, value)
+        return yield* Tuple(schema_, references_, value)
       case 'Undefined':
-        return yield* Undefined(anySchema, value)
+        return yield* Undefined(schema_, references_, value)
       case 'Union':
-        return yield* Union(anySchema, value)
+        return yield* Union(schema_, references_, value)
       case 'Uint8Array':
-        return yield* Uint8Array(anySchema, value)
+        return yield* Uint8Array(schema_, references_, value)
       case 'Unknown':
-        return yield* Unknown(anySchema, value)
+        return yield* Unknown(schema_, references_, value)
       case 'Void':
-        return yield* Void(anySchema, value)
+        return yield* Void(schema_, references_, value)
       default:
-        if (!Custom.Has(anySchema[Types.Kind])) throw new TypeCompilerUnknownTypeError(schema)
-        return yield* UserDefined(anySchema, value)
+        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new TypeCompilerUnknownTypeError(schema)
+        return yield* UserDefined(schema_, references_, value)
     }
   }
-
   // -------------------------------------------------------------------
   // Compiler State
   // -------------------------------------------------------------------
-
-  const state_reference_map = new Map<string, Types.TSchema>() // tracks schemas with identifiers
   const state_local_variables = new Set<string>() // local variables and functions
   const state_local_function_names = new Set<string>() // local function names used call ref validators
   const state_remote_custom_types = new Map<string, unknown>() // remote custom types used during compilation
-
   function ResetCompiler() {
-    state_reference_map.clear()
     state_local_variables.clear()
     state_local_function_names.clear()
     state_remote_custom_types.clear()
   }
-
-  function AddReferences(schemas: Types.TSchema[] = []) {
-    for (const schema of schemas) {
-      if (!schema.$id) throw new Error(`TypeCompiler: Referenced schemas must specify an $id.`)
-      if (state_reference_map.has(schema.$id)) throw new Error(`TypeCompiler: Duplicate schema $id found for '${schema.$id}'`)
-      state_reference_map.set(schema.$id, schema)
-    }
-  }
-
-  function CreateExpression(schema: Types.TSchema, value: string): string {
-    return `(${[...Visit(schema, value)].join(' && ')})`
+  function CreateExpression(schema: Types.TSchema, references: Types.TSchema[], value: string): string {
+    return `(${[...Visit(schema, references, value)].join(' && ')})`
   }
-
   function CreateFunctionName($id: string) {
     return `check_${Identifier.Encode($id)}`
   }
-
-  function CreateFunction(name: string, schema: Types.TSchema, value: string): string {
-    const expression = [...Visit(schema, value)].map((condition) => `    ${condition}`).join(' &&\n')
+  function CreateFunction(name: string, schema: Types.TSchema, references: Types.TSchema[], value: string): string {
+    const expression = [...Visit(schema, references, value)].map((condition) => `    ${condition}`).join(' &&\n')
     return `function ${name}(value) {\n  return (\n${expression}\n )\n}`
   }
-
   function PushFunction(functionBody: string) {
     state_local_variables.add(functionBody)
   }
-
   function PushLocal(expression: string) {
     const local = `local_${state_local_variables.size}`
     state_local_variables.add(`const ${local} = ${expression}`)
     return local
   }
-
   function GetLocals() {
     return [...state_local_variables.values()]
   }
-
   // -------------------------------------------------------------------
   // Compile
   // -------------------------------------------------------------------
-
-  function Build<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []): string {
+  function Build<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): string {
     ResetCompiler()
-    AddReferences(references)
-    const check = CreateFunction('check', schema, 'value')
+    const check = CreateFunction('check', schema, references, 'value')
     const locals = GetLocals()
     return `${locals.join('\n')}\nreturn ${check}`
   }
-
+  /** Returns the generated assertion code used to validate this type. */
+  export function Code<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []) {
+    if (!Types.TypeGuard.TSchema(schema)) throw new TypeCompilerTypeGuardError(schema)
+    for (const schema of references) if (!Types.TypeGuard.TSchema(schema)) throw new TypeCompilerTypeGuardError(schema)
+    return Build(schema, references)
+  }
   /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
   export function Compile<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []): TypeCheck<T> {
-    TypeGuard.Assert(schema, references)
-    const code = Build(schema, references)
+    const code = Code(schema, references)
     const custom_schemas = new Map(state_remote_custom_types)
     const compiledFunction = globalThis.Function('custom', 'format', 'hash', code)
     const checkFunction = compiledFunction(
       (kind: string, schema_key: string, value: unknown) => {
-        if (!Custom.Has(kind) || !custom_schemas.has(schema_key)) return false
+        if (!Types.TypeRegistry.Has(kind) || !custom_schemas.has(schema_key)) return false
         const schema = custom_schemas.get(schema_key)!
-        const func = Custom.Get(kind)!
+        const func = Types.TypeRegistry.Get(kind)!
         return func(schema, value)
       },
       (format: string, value: string) => {
-        if (!Format.Has(format)) return false
-        const func = Format.Get(format)!
+        if (!Types.FormatRegistry.Has(format)) return false
+        const func = Types.FormatRegistry.Get(format)!
         return func(value)
       },
       (value: unknown) => {
diff --git a/src/conditional/conditional.ts b/src/conditional/conditional.ts
deleted file mode 100644
index a71a8d4d2..000000000
--- a/src/conditional/conditional.ts
+++ /dev/null
@@ -1,114 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/conditional
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import * as Types from '../typebox'
-import { Structural, StructuralResult } from './structural'
-import { TypeGuard } from '../guard/index'
-
-// ------------------------------------------------------------------------
-// Extends
-// ------------------------------------------------------------------------
-
-export type TExtends<L extends Types.TSchema, R extends Types.TSchema, T extends Types.TSchema, U extends Types.TSchema> = Types.Static<L> extends Types.Static<R> ? T : U
-
-// ------------------------------------------------------------------------
-// Exclude
-// ------------------------------------------------------------------------
-
-export interface TExclude<T extends Types.TUnion, U extends Types.TUnion> extends Types.TUnion<any[]> {
-  static: Exclude<Types.Static<T, this['params']>, Types.Static<U, this['params']>>
-}
-
-// ------------------------------------------------------------------------
-// Extract
-// ------------------------------------------------------------------------
-
-export interface TExtract<T extends Types.TSchema, U extends Types.TUnion> extends Types.TUnion<any[]> {
-  static: Extract<Types.Static<T, this['params']>, Types.Static<U, this['params']>>
-}
-
-/** Conditional type mapping for TypeBox types */
-export namespace Conditional {
-  /** (Experimental) Creates a conditional expression type */
-  export function Extends<L extends Types.TSchema, R extends Types.TSchema, T extends Types.TSchema, U extends Types.TSchema>(left: L, right: R, ok: T, fail: U): TExtends<L, R, T, U> {
-    switch (Structural.Check(left, right)) {
-      case StructuralResult.Union:
-        return Types.Type.Union([Clone(ok), Clone(fail)]) as any as TExtends<L, R, T, U>
-      case StructuralResult.True:
-        return Clone(ok)
-      case StructuralResult.False:
-        return Clone(fail)
-    }
-  }
-
-  /** (Experimental) Constructs a type by excluding from UnionType all union members that are assignable to ExcludedMembers. */
-  export function Exclude<T extends Types.TUnion, U extends Types.TUnion>(unionType: T, excludedMembers: U, options: Types.SchemaOptions = {}): TExclude<T, U> {
-    const anyOf = unionType.anyOf
-      .filter((schema) => {
-        const check = Structural.Check(schema, excludedMembers)
-        return !(check === StructuralResult.True || check === StructuralResult.Union)
-      })
-      .map((schema) => Clone(schema))
-    return { ...options, [Types.Kind]: 'Union', anyOf } as any
-  }
-
-  /** (Experimental) Constructs a type by extracting from Type all union members that are assignable to Union. */
-  export function Extract<T extends Types.TSchema, U extends Types.TUnion>(type: T, union: U, options: Types.SchemaOptions = {}): TExtract<T, U> {
-    if (TypeGuard.TUnion(type)) {
-      const anyOf = type.anyOf.filter((schema: Types.TSchema) => Structural.Check(schema, union) === StructuralResult.True).map((schema: Types.TSchema) => Clone(schema))
-      return { ...options, [Types.Kind]: 'Union', anyOf } as any
-    } else {
-      const anyOf = union.anyOf.filter((schema) => Structural.Check(type, schema) === StructuralResult.True).map((schema) => Clone(schema))
-      return { ...options, [Types.Kind]: 'Union', anyOf } as any
-    }
-  }
-
-  function Clone(value: any): any {
-    const isObject = (object: any): object is Record<string | symbol, any> => typeof object === 'object' && object !== null && !Array.isArray(object)
-    const isArray = (object: any): object is any[] => typeof object === 'object' && object !== null && Array.isArray(object)
-    if (isObject(value)) {
-      return Object.keys(value).reduce(
-        (acc, key) => ({
-          ...acc,
-          [key]: Clone(value[key]),
-        }),
-        Object.getOwnPropertySymbols(value).reduce(
-          (acc, key) => ({
-            ...acc,
-            [key]: Clone(value[key]),
-          }),
-          {},
-        ),
-      )
-    } else if (isArray(value)) {
-      return value.map((item: any) => Clone(item))
-    } else {
-      return value
-    }
-  }
-}
diff --git a/src/conditional/index.ts b/src/conditional/index.ts
deleted file mode 100644
index c6f97147d..000000000
--- a/src/conditional/index.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/conditional
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-export * from './conditional'
-export * from './structural'
diff --git a/src/conditional/structural.ts b/src/conditional/structural.ts
deleted file mode 100644
index ec444955a..000000000
--- a/src/conditional/structural.ts
+++ /dev/null
@@ -1,579 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/conditional
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import * as Types from '../typebox'
-import { TypeGuard } from '../guard'
-
-// --------------------------------------------------------------------------
-// StructuralResult
-// --------------------------------------------------------------------------
-
-export enum StructuralResult {
-  Union,
-  True,
-  False,
-}
-
-// --------------------------------------------------------------------------
-// Structural
-// --------------------------------------------------------------------------
-
-/** Performs structural equivalence checks against TypeBox types. */
-export namespace Structural {
-  const referenceMap = new Map<string, Types.TAnySchema>()
-
-  // ------------------------------------------------------------------------
-  // Rules
-  // ------------------------------------------------------------------------
-
-  function AnyUnknownOrCustomRule(right: Types.TSchema) {
-    // https://github.com/microsoft/TypeScript/issues/40049
-    if (TypeGuard.TUnion(right) && right.anyOf.some((schema: Types.TSchema) => schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown')) return true
-    if (TypeGuard.TUnknown(right)) return true
-    if (TypeGuard.TAny(right)) return true
-    if (TypeGuard.TUserDefined(right)) throw Error(`Structural: Cannot structurally compare custom type '${right[Types.Kind]}'`)
-    return false
-  }
-
-  function ObjectRightRule(left: Types.TAnySchema, right: Types.TObject) {
-    // type A = boolean extends {}     ? 1 : 2 // additionalProperties: false
-    // type B = boolean extends object ? 1 : 2 // additionalProperties: true
-    const additionalProperties = right.additionalProperties
-    const propertyLength = globalThis.Object.keys(right.properties).length
-    return additionalProperties === false && propertyLength === 0
-  }
-
-  function UnionRightRule(left: Types.TAnySchema, right: Types.TUnion): StructuralResult {
-    const result = right.anyOf.some((right: Types.TSchema) => Visit(left, right) !== StructuralResult.False)
-    return result ? StructuralResult.True : StructuralResult.False
-  }
-
-  // ------------------------------------------------------------------------
-  // Records
-  // ------------------------------------------------------------------------
-
-  function RecordPattern(schema: Types.TRecord) {
-    return globalThis.Object.keys(schema.patternProperties)[0] as string
-  }
-
-  function RecordNumberOrStringKey(schema: Types.TRecord) {
-    const pattern = RecordPattern(schema)
-    return pattern === '^.*$' || pattern === '^(0|[1-9][0-9]*)$'
-  }
-
-  function RecordValue(schema: Types.TRecord) {
-    const pattern = RecordPattern(schema)
-    return schema.patternProperties[pattern]
-  }
-
-  function RecordKey(schema: Types.TRecord) {
-    const pattern = RecordPattern(schema)
-    if (pattern === '^.*$') {
-      return Types.Type.String()
-    } else if (pattern === '^(0|[1-9][0-9]*)$') {
-      return Types.Type.Number()
-    } else {
-      const keys = pattern.slice(1, pattern.length - 1).split('|')
-      const schemas = keys.map((key) => (isNaN(+key) ? Types.Type.Literal(key) : Types.Type.Literal(parseFloat(key))))
-      return Types.Type.Union(schemas)
-    }
-  }
-
-  function PropertyMap(schema: Types.TObject | Types.TRecord) {
-    const comparable = new Map<string, Types.TSchema>()
-    if (TypeGuard.TRecord(schema)) {
-      const propertyPattern = RecordPattern(schema as Types.TRecord)
-      if (propertyPattern === '^.*$' || propertyPattern === '^(0|[1-9][0-9]*)$') throw Error('Cannot extract record properties without property constraints')
-      const propertySchema = schema.patternProperties[propertyPattern] as Types.TSchema
-      const propertyKeys = propertyPattern.slice(1, propertyPattern.length - 1).split('|')
-      propertyKeys.forEach((propertyKey) => {
-        comparable.set(propertyKey, propertySchema)
-      })
-    } else {
-      globalThis.Object.entries(schema.properties).forEach(([propertyKey, propertySchema]) => {
-        comparable.set(propertyKey, propertySchema as Types.TSchema)
-      })
-    }
-    return comparable
-  }
-
-  // ------------------------------------------------------------------------
-  // Indexable
-  // ------------------------------------------------------------------------
-
-  function Indexable<Left extends Types.TAnySchema, Right extends Types.TAnySchema>(left: Left, right: Types.TSchema): StructuralResult {
-    if (TypeGuard.TUnion(right)) {
-      return StructuralResult.False
-    } else {
-      return Visit(left, right)
-    }
-  }
-
-  // ------------------------------------------------------------------------
-  // Checks
-  // ------------------------------------------------------------------------
-
-  function Any(left: Types.TAny, right: Types.TSchema): StructuralResult {
-    return AnyUnknownOrCustomRule(right) ? StructuralResult.True : StructuralResult.Union
-  }
-
-  function Array(left: Types.TArray, right: Types.TSchema): StructuralResult {
-    if (AnyUnknownOrCustomRule(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TObject(right)) {
-      if (right.properties['length'] !== undefined && right.properties['length'][Types.Kind] === 'Number') return StructuralResult.True
-      if (globalThis.Object.keys(right.properties).length === 0) return StructuralResult.True
-      return StructuralResult.False
-    } else if (!TypeGuard.TArray(right)) {
-      return StructuralResult.False
-    } else if (left.items === undefined && right.items !== undefined) {
-      return StructuralResult.False
-    } else if (left.items !== undefined && right.items === undefined) {
-      return StructuralResult.False
-    } else if (left.items === undefined && right.items === undefined) {
-      return StructuralResult.False
-    } else {
-      const result = Visit(left.items, right.items) !== StructuralResult.False
-      return result ? StructuralResult.True : StructuralResult.False
-    }
-  }
-
-  function Boolean(left: Types.TBoolean, right: Types.TSchema): StructuralResult {
-    if (AnyUnknownOrCustomRule(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TBoolean(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TUnion(right)) {
-      return UnionRightRule(left, right)
-    } else {
-      return StructuralResult.False
-    }
-  }
-
-  function Constructor(left: Types.TConstructor, right: Types.TSchema): StructuralResult {
-    if (AnyUnknownOrCustomRule(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TObject(right) && globalThis.Object.keys(right.properties).length === 0) {
-      return StructuralResult.True
-    } else if (!TypeGuard.TConstructor(right)) {
-      return StructuralResult.False
-    } else if (right.parameters.length < left.parameters.length) {
-      return StructuralResult.False
-    } else {
-      if (Visit(left.returns, right.returns) === StructuralResult.False) {
-        return StructuralResult.False
-      }
-      for (let i = 0; i < left.parameters.length; i++) {
-        const result = Visit(right.parameters[i], left.parameters[i])
-        if (result === StructuralResult.False) return StructuralResult.False
-      }
-      return StructuralResult.True
-    }
-  }
-
-  function Date(left: Types.TDate, right: Types.TSchema): StructuralResult {
-    if (AnyUnknownOrCustomRule(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TRecord(right)) {
-      return StructuralResult.False
-    } else if (TypeGuard.TDate(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TUnion(right)) {
-      return UnionRightRule(left, right)
-    } else {
-      return StructuralResult.False
-    }
-  }
-
-  function Function(left: Types.TFunction, right: Types.TSchema): StructuralResult {
-    if (AnyUnknownOrCustomRule(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TObject(right)) {
-      if (right.properties['length'] !== undefined && right.properties['length'][Types.Kind] === 'Number') return StructuralResult.True
-      if (globalThis.Object.keys(right.properties).length === 0) return StructuralResult.True
-      return StructuralResult.False
-    } else if (!TypeGuard.TFunction(right)) {
-      return StructuralResult.False
-    } else if (right.parameters.length < left.parameters.length) {
-      return StructuralResult.False
-    } else if (Visit(left.returns, right.returns) === StructuralResult.False) {
-      return StructuralResult.False
-    } else {
-      for (let i = 0; i < left.parameters.length; i++) {
-        const result = Visit(right.parameters[i], left.parameters[i])
-        if (result === StructuralResult.False) return StructuralResult.False
-      }
-      return StructuralResult.True
-    }
-  }
-
-  function Integer(left: Types.TInteger, right: Types.TSchema): StructuralResult {
-    if (AnyUnknownOrCustomRule(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TInteger(right) || TypeGuard.TNumber(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TUnion(right)) {
-      return UnionRightRule(left, right)
-    } else {
-      return StructuralResult.False
-    }
-  }
-
-  function Literal(left: Types.TLiteral, right: Types.TSchema): StructuralResult {
-    if (AnyUnknownOrCustomRule(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TRecord(right)) {
-      if (typeof left.const === 'string') {
-        return Indexable(left, RecordValue(right as Types.TRecord))
-      } else {
-        return StructuralResult.False
-      }
-    } else if (TypeGuard.TLiteral(right) && left.const === right.const) {
-      return StructuralResult.True
-    } else if (TypeGuard.TString(right) && typeof left.const === 'string') {
-      return StructuralResult.True
-    } else if (TypeGuard.TNumber(right) && typeof left.const === 'number') {
-      return StructuralResult.True
-    } else if (TypeGuard.TInteger(right) && typeof left.const === 'number') {
-      return StructuralResult.True
-    } else if (TypeGuard.TBoolean(right) && typeof left.const === 'boolean') {
-      return StructuralResult.True
-    } else if (TypeGuard.TUnion(right)) {
-      return UnionRightRule(left, right)
-    } else {
-      return StructuralResult.False
-    }
-  }
-
-  function Number(left: Types.TNumber, right: Types.TSchema): StructuralResult {
-    if (AnyUnknownOrCustomRule(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TNumber(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TInteger(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TUnion(right)) {
-      return UnionRightRule(left, right)
-    } else {
-      return StructuralResult.False
-    }
-  }
-
-  function Null(left: Types.TNull, right: Types.TSchema): StructuralResult {
-    if (AnyUnknownOrCustomRule(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TNull(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TUnion(right)) {
-      return UnionRightRule(left, right)
-    } else {
-      return StructuralResult.False
-    }
-  }
-
-  function Properties(left: Map<string, Types.TSchema>, right: Map<string, Types.TSchema>) {
-    if (right.size > left.size) return StructuralResult.False
-    if (![...right.keys()].every((rightKey) => left.has(rightKey))) return StructuralResult.False
-    for (const rightKey of right.keys()) {
-      const leftProp = left.get(rightKey)!
-      const rightProp = right.get(rightKey)!
-      if (Visit(leftProp, rightProp) === StructuralResult.False) {
-        return StructuralResult.False
-      }
-    }
-    return StructuralResult.True
-  }
-
-  function Object(left: Types.TObject, right: Types.TAnySchema): StructuralResult {
-    if (AnyUnknownOrCustomRule(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TObject(right)) {
-      return Properties(PropertyMap(left), PropertyMap(right))
-    } else if (TypeGuard.TRecord(right)) {
-      if (!RecordNumberOrStringKey(right as Types.TRecord)) {
-        return Properties(PropertyMap(left), PropertyMap(right))
-      } else {
-        return StructuralResult.True
-      }
-    } else {
-      return StructuralResult.False
-    }
-  }
-
-  function Promise(left: Types.TPromise, right: Types.TSchema): StructuralResult {
-    if (AnyUnknownOrCustomRule(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TObject(right)) {
-      if (ObjectRightRule(left, right) || globalThis.Object.keys(right.properties).length === 0) {
-        return StructuralResult.True
-      } else {
-        return StructuralResult.False
-      }
-    } else if (!TypeGuard.TPromise(right)) {
-      return StructuralResult.False
-    } else {
-      const result = Visit(left.item, right.item) !== StructuralResult.False
-      return result ? StructuralResult.True : StructuralResult.False
-    }
-  }
-
-  function Record(left: Types.TRecord, right: Types.TSchema): StructuralResult {
-    if (AnyUnknownOrCustomRule(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TObject(right)) {
-      if (RecordPattern(left) === '^.*$' && right[Types.Hint] === 'Record') {
-        return StructuralResult.True
-      } else if (RecordPattern(left) === '^.*$') {
-        return StructuralResult.False
-      } else {
-        return globalThis.Object.keys(right.properties).length === 0 ? StructuralResult.True : StructuralResult.False
-      }
-    } else if (TypeGuard.TRecord(right)) {
-      if (!RecordNumberOrStringKey(left as Types.TRecord) && !RecordNumberOrStringKey(right as Types.TRecord)) {
-        return Properties(PropertyMap(left), PropertyMap(right))
-      } else if (RecordNumberOrStringKey(left as Types.TRecord) && !RecordNumberOrStringKey(right as Types.TRecord)) {
-        const leftKey = RecordKey(left as Types.TRecord)
-        const rightKey = RecordKey(right as Types.TRecord)
-        if (Visit(rightKey, leftKey) === StructuralResult.False) {
-          return StructuralResult.False
-        } else {
-          return StructuralResult.True
-        }
-      } else {
-        return StructuralResult.True
-      }
-    } else {
-      return StructuralResult.False
-    }
-  }
-
-  function Ref(left: Types.TRef, right: Types.TSchema): StructuralResult {
-    if (!referenceMap.has(left.$ref)) throw Error(`Cannot locate referenced $id '${left.$ref}'`)
-    const resolved = referenceMap.get(left.$ref)!
-    return Visit(resolved, right)
-  }
-
-  function Self(left: Types.TSelf, right: Types.TSchema): StructuralResult {
-    if (!referenceMap.has(left.$ref)) throw Error(`Cannot locate referenced self $id '${left.$ref}'`)
-    const resolved = referenceMap.get(left.$ref)!
-    return Visit(resolved, right)
-  }
-
-  function String(left: Types.TString, right: Types.TSchema): StructuralResult {
-    if (AnyUnknownOrCustomRule(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TRecord(right)) {
-      return Indexable(left, RecordValue(right))
-    } else if (TypeGuard.TString(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TUnion(right)) {
-      return UnionRightRule(left, right)
-    } else {
-      return StructuralResult.False
-    }
-  }
-
-  function Tuple(left: Types.TTuple, right: Types.TSchema): StructuralResult {
-    if (AnyUnknownOrCustomRule(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TObject(right)) {
-      const result = ObjectRightRule(left, right) || globalThis.Object.keys(right.properties).length === 0
-      return result ? StructuralResult.True : StructuralResult.False
-    } else if (TypeGuard.TRecord(right)) {
-      return Indexable(left, RecordValue(right))
-    } else if (TypeGuard.TArray(right)) {
-      if (right.items === undefined) {
-        return StructuralResult.False
-      } else if (TypeGuard.TUnion(right.items) && left.items) {
-        const result = left.items.every((left: Types.TSchema) => UnionRightRule(left, right.items as Types.TUnion) !== StructuralResult.False)
-        return result ? StructuralResult.True : StructuralResult.False
-      } else if (TypeGuard.TAny(right.items)) {
-        return StructuralResult.True
-      } else {
-        return StructuralResult.False
-      }
-    }
-    if (!TypeGuard.TTuple(right)) return StructuralResult.False
-    if (left.items === undefined && right.items === undefined) return StructuralResult.True
-    if (left.items === undefined && right.items !== undefined) return StructuralResult.False
-    if (left.items !== undefined && right.items === undefined) return StructuralResult.False
-    if (left.items === undefined && right.items === undefined) return StructuralResult.True
-    if (left.minItems !== right.minItems || left.maxItems !== right.maxItems) return StructuralResult.False
-    for (let i = 0; i < left.items!.length; i++) {
-      if (Visit(left.items![i], right.items![i]) === StructuralResult.False) return StructuralResult.False
-    }
-    return StructuralResult.True
-  }
-
-  function Uint8Array(left: Types.TUint8Array, right: Types.TSchema): StructuralResult {
-    if (AnyUnknownOrCustomRule(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TRecord(right)) {
-      return Indexable(left, RecordValue(right as Types.TRecord))
-    } else if (TypeGuard.TUint8Array(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TUnion(right)) {
-      return UnionRightRule(left, right)
-    } else {
-      return StructuralResult.False
-    }
-  }
-
-  function Undefined(left: Types.TUndefined, right: Types.TSchema): StructuralResult {
-    if (AnyUnknownOrCustomRule(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TUndefined(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TVoid(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TUnion(right)) {
-      return UnionRightRule(left, right)
-    } else {
-      return StructuralResult.False
-    }
-  }
-
-  function Union(left: Types.TUnion, right: Types.TSchema): StructuralResult {
-    if (left.anyOf.some((left: Types.TSchema) => TypeGuard.TAny(left))) {
-      return StructuralResult.Union
-    } else if (TypeGuard.TUnion(right)) {
-      const result = left.anyOf.every((left: Types.TSchema) => right.anyOf.some((right: Types.TSchema) => Visit(left, right) !== StructuralResult.False))
-      return result ? StructuralResult.True : StructuralResult.False
-    } else {
-      const result = left.anyOf.every((left: Types.TSchema) => Visit(left, right) !== StructuralResult.False)
-      return result ? StructuralResult.True : StructuralResult.False
-    }
-  }
-
-  function Unknown(left: Types.TUnknown, right: Types.TSchema): StructuralResult {
-    if (TypeGuard.TUnion(right)) {
-      const result = right.anyOf.some((right: Types.TSchema) => TypeGuard.TAny(right) || TypeGuard.TUnknown(right))
-      return result ? StructuralResult.True : StructuralResult.False
-    } else if (TypeGuard.TAny(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TUnknown(right)) {
-      return StructuralResult.True
-    } else {
-      return StructuralResult.False
-    }
-  }
-
-  function Void(left: Types.TVoid, right: Types.TSchema): StructuralResult {
-    if (TypeGuard.TUnion(right)) {
-      const result = right.anyOf.some((right: Types.TSchema) => TypeGuard.TAny(right) || TypeGuard.TUnknown(right))
-      return result ? StructuralResult.True : StructuralResult.False
-    } else if (TypeGuard.TAny(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TUnknown(right)) {
-      return StructuralResult.True
-    } else if (TypeGuard.TVoid(right)) {
-      return StructuralResult.True
-    } else {
-      return StructuralResult.False
-    }
-  }
-
-  let recursionDepth = 0
-  function Visit<Left extends Types.TAnySchema, Right extends Types.TAnySchema>(left: Left, right: Types.TSchema): StructuralResult {
-    recursionDepth += 1
-    if (recursionDepth >= 1000) return StructuralResult.True
-    if (left.$id !== undefined) referenceMap.set(left.$id!, left)
-    if (right.$id !== undefined) referenceMap.set(right.$id!, right)
-    const resolvedRight = right[Types.Kind] === 'Self' ? referenceMap.get(right.$ref)! : right
-    if (TypeGuard.TAny(left)) {
-      return Any(left, resolvedRight)
-    } else if (TypeGuard.TArray(left)) {
-      return Array(left, resolvedRight)
-    } else if (TypeGuard.TBoolean(left)) {
-      return Boolean(left, resolvedRight)
-    } else if (TypeGuard.TConstructor(left)) {
-      return Constructor(left, resolvedRight)
-    } else if (TypeGuard.TDate(left)) {
-      return Date(left, resolvedRight)
-    } else if (TypeGuard.TFunction(left)) {
-      return Function(left, resolvedRight)
-    } else if (TypeGuard.TInteger(left)) {
-      return Integer(left, resolvedRight)
-    } else if (TypeGuard.TLiteral(left)) {
-      return Literal(left, resolvedRight)
-    } else if (TypeGuard.TNull(left)) {
-      return Null(left, resolvedRight)
-    } else if (TypeGuard.TNumber(left)) {
-      return Number(left, resolvedRight)
-    } else if (TypeGuard.TObject(left)) {
-      return Object(left, resolvedRight)
-    } else if (TypeGuard.TPromise(left)) {
-      return Promise(left, resolvedRight)
-    } else if (TypeGuard.TRecord(left)) {
-      return Record(left, resolvedRight)
-    } else if (TypeGuard.TRef(left)) {
-      return Ref(left, resolvedRight)
-    } else if (TypeGuard.TSelf(left)) {
-      return Self(left, resolvedRight)
-    } else if (TypeGuard.TString(left)) {
-      return String(left, resolvedRight)
-    } else if (TypeGuard.TTuple(left)) {
-      return Tuple(left, resolvedRight)
-    } else if (TypeGuard.TUndefined(left)) {
-      return Undefined(left, resolvedRight)
-    } else if (TypeGuard.TUint8Array(left)) {
-      return Uint8Array(left, resolvedRight)
-    } else if (TypeGuard.TUnion(left)) {
-      return Union(left, resolvedRight)
-    } else if (TypeGuard.TUnknown(left)) {
-      return Unknown(left, resolvedRight)
-    } else if (TypeGuard.TVoid(left)) {
-      return Void(left, resolvedRight)
-    } else if (TypeGuard.TUserDefined(left)) {
-      throw Error(`Structural: Cannot structurally compare custom type '${left[Types.Kind]}'`)
-    } else {
-      throw Error(`Structural: Unknown left operand '${left[Types.Kind]}'`)
-    }
-  }
-
-  /** Structurally tests if the left schema extends the right. */
-  export function Check(left: Types.TSchema, right: Types.TSchema): StructuralResult {
-    referenceMap.clear()
-    recursionDepth = 0
-    return Visit(left, right)
-  }
-}
diff --git a/src/custom/custom.ts b/src/custom/custom.ts
deleted file mode 100644
index f1d2cfcfb..000000000
--- a/src/custom/custom.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/custom
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-export type CustomValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean
-
-/** Provides functions to create user defined types */
-export namespace Custom {
-  const customs = new Map<string, CustomValidationFunction<any>>()
-
-  /** Clears all user defined types */
-  export function Clear() {
-    return customs.clear()
-  }
-
-  /** Returns true if this user defined type exists */
-  export function Has(kind: string) {
-    return customs.has(kind)
-  }
-
-  /** Sets a validation function for a user defined type */
-  export function Set<TSchema = unknown>(kind: string, func: CustomValidationFunction<TSchema>) {
-    customs.set(kind, func)
-  }
-
-  /** Gets a custom validation function for a user defined type */
-  export function Get(kind: string) {
-    return customs.get(kind)
-  }
-}
diff --git a/src/custom/index.ts b/src/custom/index.ts
deleted file mode 100644
index b96208819..000000000
--- a/src/custom/index.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/custom
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-export * from './custom'
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 0cbf89419..780b6d7f7 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -25,23 +25,24 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
-
 import * as Types from '../typebox'
 import { TypeSystem } from '../system/index'
-import { TypeExtends } from '../guard/extends'
-import { Format } from '../format/index'
-import { Custom } from '../custom/index'
-import { ValueHash } from '../hash/index'
+import { ValueHash } from '../value/hash'
 
 // -------------------------------------------------------------------
 // ValueErrorType
 // -------------------------------------------------------------------
-
 export enum ValueErrorType {
   Array,
   ArrayMinItems,
   ArrayMaxItems,
   ArrayUniqueItems,
+  BigInt,
+  BigIntMultipleOf,
+  BigIntExclusiveMinimum,
+  BigIntExclusiveMaximum,
+  BigIntMinimum,
+  BigIntMaximum,
   Boolean,
   Date,
   DateExclusiveMinimumTimestamp,
@@ -55,8 +56,11 @@ export enum ValueErrorType {
   IntegerExclusiveMaximum,
   IntegerMinimum,
   IntegerMaximum,
+  Intersect,
+  IntersectUnevaluatedProperties,
   Literal,
   Never,
+  Not,
   Null,
   Number,
   NumberMultipleOf,
@@ -78,6 +82,7 @@ export enum ValueErrorType {
   StringPattern,
   StringFormatUnknown,
   StringFormat,
+  Symbol,
   TupleZeroLength,
   TupleLength,
   Undefined,
@@ -88,11 +93,9 @@ export enum ValueErrorType {
   Void,
   Custom,
 }
-
 // -------------------------------------------------------------------
 // ValueError
 // -------------------------------------------------------------------
-
 export interface ValueError {
   type: ValueErrorType
   schema: Types.TSchema
@@ -100,33 +103,77 @@ export interface ValueError {
   value: unknown
   message: string
 }
-
+// -------------------------------------------------------------------
+// ValueErrorIterator
+// -------------------------------------------------------------------
+export class ValueErrorIterator {
+  constructor(private readonly iterator: IterableIterator<ValueError>) {}
+  public [Symbol.iterator]() {
+    return this.iterator
+  }
+  /** Returns the first value error or undefined if no errors */
+  public First(): ValueError | undefined {
+    const next = this.iterator.next()
+    return next.done ? undefined : next.value
+  }
+}
 // -------------------------------------------------------------------
 // ValueErrors
 // -------------------------------------------------------------------
-
 export class ValueErrorsUnknownTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
     super('ValueErrors: Unknown type')
   }
 }
-
+export class ValueErrorsDereferenceError extends Error {
+  constructor(public readonly schema: Types.TRef | Types.TSelf) {
+    super(`ValueErrors: Unable to dereference schema with $id '${schema.$ref}'`)
+  }
+}
 /** Provides functionality to generate a sequence of errors against a TypeBox type.  */
 export namespace ValueErrors {
+  // ----------------------------------------------------------------------
+  // Guards
+  // ----------------------------------------------------------------------
+  function IsObject(value: unknown): value is Record<keyof any, unknown> {
+    const result = typeof value === 'object' && value !== null
+    return TypeSystem.AllowArrayObjects ? result : result && !globalThis.Array.isArray(value)
+  }
+  function IsRecordObject(value: unknown): value is Record<keyof any, unknown> {
+    return IsObject(value) && !(value instanceof globalThis.Date) && !(value instanceof globalThis.Uint8Array)
+  }
+  function IsBigInt(value: unknown): value is bigint {
+    return typeof value === 'bigint'
+  }
   function IsNumber(value: unknown): value is number {
-    return typeof value === 'number' && !isNaN(value)
+    const result = typeof value === 'number'
+    return TypeSystem.AllowNaN ? result : result && globalThis.Number.isFinite(value)
   }
-
+  function IsInteger(value: unknown): value is number {
+    return globalThis.Number.isInteger(value)
+  }
+  function IsString(value: unknown): value is string {
+    return typeof value === 'string'
+  }
+  function IsVoid(value: unknown): value is void {
+    const result = value === undefined
+    return TypeSystem.AllowVoidNull ? result || value === null : result
+  }
+  function IsDefined<T>(value: unknown): value is T {
+    return value !== undefined
+  }
+  // ----------------------------------------------------------------------
+  // Types
+  // ----------------------------------------------------------------------
   function* Any(schema: Types.TAny, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {}
-
   function* Array(schema: Types.TArray, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!globalThis.Array.isArray(value)) {
       return yield { type: ValueErrorType.Array, schema, path, value, message: `Expected array` }
     }
-    if (IsNumber(schema.minItems) && !(value.length >= schema.minItems)) {
+    if (IsDefined<number>(schema.minItems) && !(value.length >= schema.minItems)) {
       yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be greater or equal to ${schema.minItems}` }
     }
-    if (IsNumber(schema.maxItems) && !(value.length <= schema.maxItems)) {
+    if (IsDefined<number>(schema.maxItems) && !(value.length <= schema.maxItems)) {
       yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` }
     }
     // prettier-ignore
@@ -137,176 +184,204 @@ export namespace ValueErrors {
       yield* Visit(schema.items, references, `${path}/${i}`, value[i])
     }
   }
-
+  function* BigInt(schema: Types.TBigInt, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!IsBigInt(value)) {
+      return yield { type: ValueErrorType.BigInt, schema, path, value, message: `Expected bigint` }
+    }
+    if (IsDefined<bigint>(schema.multipleOf) && !(value % schema.multipleOf === globalThis.BigInt(0))) {
+      yield { type: ValueErrorType.BigIntMultipleOf, schema, path, value, message: `Expected bigint to be a multiple of ${schema.multipleOf}` }
+    }
+    if (IsDefined<bigint>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+      yield { type: ValueErrorType.BigIntExclusiveMinimum, schema, path, value, message: `Expected bigint to be greater than ${schema.exclusiveMinimum}` }
+    }
+    if (IsDefined<bigint>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+      yield { type: ValueErrorType.BigIntExclusiveMaximum, schema, path, value, message: `Expected bigint to be less than ${schema.exclusiveMaximum}` }
+    }
+    if (IsDefined<bigint>(schema.minimum) && !(value >= schema.minimum)) {
+      yield { type: ValueErrorType.BigIntMinimum, schema, path, value, message: `Expected bigint to be greater or equal to ${schema.minimum}` }
+    }
+    if (IsDefined<bigint>(schema.maximum) && !(value <= schema.maximum)) {
+      yield { type: ValueErrorType.BigIntMaximum, schema, path, value, message: `Expected bigint to be less or equal to ${schema.maximum}` }
+    }
+  }
   function* Boolean(schema: Types.TBoolean, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!(typeof value === 'boolean')) {
       return yield { type: ValueErrorType.Boolean, schema, path, value, message: `Expected boolean` }
     }
   }
-
   function* Constructor(schema: Types.TConstructor, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     yield* Visit(schema.returns, references, path, value.prototype)
   }
-
   function* Date(schema: Types.TNumeric, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!(value instanceof globalThis.Date)) {
       return yield { type: ValueErrorType.Date, schema, path, value, message: `Expected Date object` }
     }
-    if (isNaN(value.getTime())) {
+    if (!globalThis.isFinite(value.getTime())) {
       return yield { type: ValueErrorType.Date, schema, path, value, message: `Invalid Date` }
     }
-    if (IsNumber(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
+    if (IsDefined<number>(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
       yield { type: ValueErrorType.DateExclusiveMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater than ${schema.exclusiveMinimum}` }
     }
-    if (IsNumber(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+    if (IsDefined<number>(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
       yield { type: ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less than ${schema.exclusiveMaximum}` }
     }
-    if (IsNumber(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
+    if (IsDefined<number>(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
       yield { type: ValueErrorType.DateMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater or equal to ${schema.minimum}` }
     }
-    if (IsNumber(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
+    if (IsDefined<number>(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
       yield { type: ValueErrorType.DateMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less or equal to ${schema.maximum}` }
     }
   }
-
   function* Function(schema: Types.TFunction, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!(typeof value === 'function')) {
       return yield { type: ValueErrorType.Function, schema, path, value, message: `Expected function` }
     }
   }
-
   function* Integer(schema: Types.TNumeric, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(typeof value === 'number' && globalThis.Number.isInteger(value))) {
+    if (!IsInteger(value)) {
       return yield { type: ValueErrorType.Integer, schema, path, value, message: `Expected integer` }
     }
-    if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
       yield { type: ValueErrorType.IntegerMultipleOf, schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` }
     }
-    if (IsNumber(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+    if (IsDefined<number>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
       yield { type: ValueErrorType.IntegerExclusiveMinimum, schema, path, value, message: `Expected integer to be greater than ${schema.exclusiveMinimum}` }
     }
-    if (IsNumber(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
       yield { type: ValueErrorType.IntegerExclusiveMaximum, schema, path, value, message: `Expected integer to be less than ${schema.exclusiveMaximum}` }
     }
-    if (IsNumber(schema.minimum) && !(value >= schema.minimum)) {
+    if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
       yield { type: ValueErrorType.IntegerMinimum, schema, path, value, message: `Expected integer to be greater or equal to ${schema.minimum}` }
     }
-    if (IsNumber(schema.maximum) && !(value <= schema.maximum)) {
+    if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
       yield { type: ValueErrorType.IntegerMaximum, schema, path, value, message: `Expected integer to be less or equal to ${schema.maximum}` }
     }
   }
-
+  function* Intersect(schema: Types.TIntersect, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    for (const subschema of schema.allOf) {
+      const next = Visit(subschema, references, path, value).next()
+      if (!next.done) {
+        yield next.value
+        yield { type: ValueErrorType.Intersect, schema, path, value, message: `Expected all sub schemas to be valid` }
+        return
+      }
+    }
+    if (schema.unevaluatedProperties === false) {
+      const schemaKeys = Types.KeyResolver.Resolve(schema)
+      const valueKeys = globalThis.Object.getOwnPropertyNames(value)
+      for (const valueKey of valueKeys) {
+        if (!schemaKeys.includes(valueKey)) {
+          yield { type: ValueErrorType.IntersectUnevaluatedProperties, schema, path: `${path}/${valueKey}`, value, message: `Unexpected property` }
+        }
+      }
+    }
+    if (typeof schema.unevaluatedProperties === 'object') {
+      const schemaKeys = Types.KeyResolver.Resolve(schema)
+      const valueKeys = globalThis.Object.getOwnPropertyNames(value)
+      for (const valueKey of valueKeys) {
+        if (!schemaKeys.includes(valueKey)) {
+          const next = Visit(schema.unevaluatedProperties, references, `${path}/${valueKey}`, value[valueKey]).next()
+          if (!next.done) {
+            yield next.value
+            yield { type: ValueErrorType.IntersectUnevaluatedProperties, schema, path: `${path}/${valueKey}`, value, message: `Invalid additional property` }
+            return
+          }
+        }
+      }
+    }
+  }
   function* Literal(schema: Types.TLiteral, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!(value === schema.const)) {
       const error = typeof schema.const === 'string' ? `'${schema.const}'` : schema.const
       return yield { type: ValueErrorType.Literal, schema, path, value, message: `Expected ${error}` }
     }
   }
-
   function* Never(schema: Types.TNever, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     yield { type: ValueErrorType.Never, schema, path, value, message: `Value cannot be validated` }
   }
-
+  function* Not(schema: Types.TNot, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (Visit(schema.allOf[0].not, references, path, value).next().done === true) {
+      yield { type: ValueErrorType.Not, schema, path, value, message: `Value should not validate` }
+    }
+    yield* Visit(schema.allOf[1], references, path, value)
+  }
   function* Null(schema: Types.TNull, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!(value === null)) {
       return yield { type: ValueErrorType.Null, schema, path, value, message: `Expected null` }
     }
   }
-
   function* Number(schema: Types.TNumeric, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (TypeSystem.AllowNaN) {
-      if (!(typeof value === 'number')) {
-        return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` }
-      }
-    } else {
-      if (!(typeof value === 'number' && !isNaN(value))) {
-        return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` }
-      }
+    if (!IsNumber(value)) {
+      return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` }
     }
-    if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
       yield { type: ValueErrorType.NumberMultipleOf, schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` }
     }
-    if (IsNumber(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+    if (IsDefined<number>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
       yield { type: ValueErrorType.NumberExclusiveMinimum, schema, path, value, message: `Expected number to be greater than ${schema.exclusiveMinimum}` }
     }
-    if (IsNumber(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
       yield { type: ValueErrorType.NumberExclusiveMaximum, schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` }
     }
-    if (IsNumber(schema.minimum) && !(value >= schema.minimum)) {
+    if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
       yield { type: ValueErrorType.NumberMaximum, schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` }
     }
-    if (IsNumber(schema.maximum) && !(value <= schema.maximum)) {
+    if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
       yield { type: ValueErrorType.NumberMinumum, schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` }
     }
   }
-
   function* Object(schema: Types.TObject, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (TypeSystem.AllowArrayObjects) {
-      if (!(typeof value === 'object' && value !== null)) {
-        return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
-      }
-    } else {
-      if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-        return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
-      }
+    if (!IsObject(value)) {
+      return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
     }
-    if (IsNumber(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+    if (IsDefined<number>(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
       yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` }
     }
-    if (IsNumber(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+    if (IsDefined<number>(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
       yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` }
     }
-    const propertyNames = globalThis.Object.getOwnPropertyNames(schema.properties)
-    if (schema.additionalProperties === false) {
-      for (const propertyName of globalThis.Object.getOwnPropertyNames(value)) {
-        if (!propertyNames.includes(propertyName)) {
-          yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${propertyName}`, value: value[propertyName], message: `Unexpected property` }
+    const requiredKeys = globalThis.Array.isArray(schema.required) ? schema.required : ([] as string[])
+    const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties)
+    const unknownKeys = globalThis.Object.getOwnPropertyNames(value)
+    for (const knownKey of knownKeys) {
+      const property = schema.properties[knownKey]
+      if (schema.required && schema.required.includes(knownKey)) {
+        yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey])
+        if (Types.ExtendsUndefined.Check(schema) && !(knownKey in value)) {
+          yield { type: ValueErrorType.ObjectRequiredProperties, schema: property, path: `${path}/${knownKey}`, value: undefined, message: `Expected required property` }
+        }
+      } else {
+        if (knownKey in value) {
+          yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey])
         }
       }
     }
-    if (schema.required && schema.required.length > 0) {
-      const propertyNames = globalThis.Object.getOwnPropertyNames(value)
-      for (const requiredKey of schema.required) {
-        if (propertyNames.includes(requiredKey)) continue
-        yield { type: ValueErrorType.ObjectRequiredProperties, schema: schema.properties[requiredKey], path: `${path}/${requiredKey}`, value: undefined, message: `Expected required property` }
-      }
+    for (const requiredKey of requiredKeys) {
+      if (unknownKeys.includes(requiredKey)) continue
+      yield { type: ValueErrorType.ObjectRequiredProperties, schema: schema.properties[requiredKey], path: `${path}/${requiredKey}`, value: undefined, message: `Expected required property` }
     }
-    if (typeof schema.additionalProperties === 'object') {
-      for (const propertyName of globalThis.Object.getOwnPropertyNames(value)) {
-        if (propertyNames.includes(propertyName)) continue
-        yield* Visit(schema.additionalProperties as Types.TSchema, references, `${path}/${propertyName}`, value[propertyName])
+    if (schema.additionalProperties === false) {
+      for (const valueKey of unknownKeys) {
+        if (!knownKeys.includes(valueKey)) {
+          yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${valueKey}`, value: value[valueKey], message: `Unexpected property` }
+        }
       }
     }
-    for (const propertyKey of propertyNames) {
-      const propertySchema = schema.properties[propertyKey]
-      if (schema.required && schema.required.includes(propertyKey)) {
-        yield* Visit(propertySchema, references, `${path}/${propertyKey}`, value[propertyKey])
-        if (TypeExtends.Undefined(schema) && !(propertyKey in value)) {
-          yield { type: ValueErrorType.ObjectRequiredProperties, schema: propertySchema, path: `${path}/${propertyKey}`, value: undefined, message: `Expected required property` }
-        }
-      } else {
-        if (value[propertyKey] !== undefined) {
-          yield* Visit(propertySchema, references, `${path}/${propertyKey}`, value[propertyKey])
-        }
+    if (typeof schema.additionalProperties === 'object') {
+      for (const valueKey of unknownKeys) {
+        if (knownKeys.includes(valueKey)) continue
+        yield* Visit(schema.additionalProperties as Types.TSchema, references, `${path}/${valueKey}`, value[valueKey])
       }
     }
   }
-
   function* Promise(schema: Types.TPromise, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!(typeof value === 'object' && typeof value.then === 'function')) {
       yield { type: ValueErrorType.Promise, schema, path, value, message: `Expected Promise` }
     }
   }
-
   function* Record(schema: Types.TRecord, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (TypeSystem.AllowArrayObjects) {
-      if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date))) {
-        return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
-      }
-    } else {
-      if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date) && !globalThis.Array.isArray(value))) {
-        return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
-      }
+    if (!IsRecordObject(value)) {
+      return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected record object` }
     }
     const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
     const regex = new RegExp(keyPattern)
@@ -320,27 +395,26 @@ export namespace ValueErrors {
       yield* Visit(valueSchema, references, `${path}/${propKey}`, propValue)
     }
   }
-
   function* Ref(schema: Types.TRef<any>, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    const reference = references.find((reference) => reference.$id === schema.$ref)
-    if (reference === undefined) throw new Error(`ValueErrors.Ref: Cannot find schema with $id '${schema.$ref}'.`)
-    yield* Visit(reference, references, path, value)
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+    if (index === -1) throw new ValueErrorsDereferenceError(schema)
+    const target = references[index]
+    yield* Visit(target, references, path, value)
   }
-
   function* Self(schema: Types.TSelf, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    const reference = references.find((reference) => reference.$id === schema.$ref)
-    if (reference === undefined) throw new Error(`ValueErrors.Self: Cannot find schema with $id '${schema.$ref}'.`)
-    yield* Visit(reference, references, path, value)
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+    if (index === -1) throw new ValueErrorsDereferenceError(schema)
+    const target = references[index]
+    yield* Visit(target, references, path, value)
   }
-
   function* String(schema: Types.TString, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(typeof value === 'string')) {
+    if (!IsString(value)) {
       return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' }
     }
-    if (IsNumber(schema.minLength) && !(value.length >= schema.minLength)) {
+    if (IsDefined<number>(schema.minLength) && !(value.length >= schema.minLength)) {
       yield { type: ValueErrorType.StringMinLength, schema, path, value, message: `Expected string length greater or equal to ${schema.minLength}` }
     }
-    if (IsNumber(schema.maxLength) && !(value.length <= schema.maxLength)) {
+    if (IsDefined<number>(schema.maxLength) && !(value.length <= schema.maxLength)) {
       yield { type: ValueErrorType.StringMaxLength, schema, path, value, message: `Expected string length less or equal to ${schema.maxLength}` }
     }
     if (schema.pattern !== undefined) {
@@ -350,17 +424,21 @@ export namespace ValueErrors {
       }
     }
     if (schema.format !== undefined) {
-      if (!Format.Has(schema.format)) {
+      if (!Types.FormatRegistry.Has(schema.format)) {
         yield { type: ValueErrorType.StringFormatUnknown, schema, path, value, message: `Unknown string format '${schema.format}'` }
       } else {
-        const format = Format.Get(schema.format)!
+        const format = Types.FormatRegistry.Get(schema.format)!
         if (!format(value)) {
           yield { type: ValueErrorType.StringFormat, schema, path, value, message: `Expected string to match format '${schema.format}'` }
         }
       }
     }
   }
-
+  function* Symbol(schema: Types.TSymbol, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!(typeof value === 'symbol')) {
+      return yield { type: ValueErrorType.Symbol, schema, path, value, message: 'Expected symbol' }
+    }
+  }
   function* Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!globalThis.Array.isArray(value)) {
       return yield { type: ValueErrorType.Array, schema, path, value, message: 'Expected Array' }
@@ -378,13 +456,11 @@ export namespace ValueErrors {
       yield* Visit(schema.items[i], references, `${path}/${i}`, value[i])
     }
   }
-
   function* Undefined(schema: Types.TUndefined, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!(value === undefined)) {
       yield { type: ValueErrorType.Undefined, schema, path, value, message: `Expected undefined` }
     }
   }
-
   function* Union(schema: Types.TUnion, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     const errors: ValueError[] = []
     for (const inner of schema.anyOf) {
@@ -399,91 +475,94 @@ export namespace ValueErrors {
       yield { type: ValueErrorType.Union, schema, path, value, message: 'Expected value of union' }
     }
   }
-
   function* Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!(value instanceof globalThis.Uint8Array)) {
       return yield { type: ValueErrorType.Uint8Array, schema, path, value, message: `Expected Uint8Array` }
     }
-    if (IsNumber(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
+    if (IsDefined<number>(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
       yield { type: ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length less or equal to ${schema.maxByteLength}` }
     }
-    if (IsNumber(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
+    if (IsDefined<number>(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
       yield { type: ValueErrorType.Uint8ArrayMinByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length greater or equal to ${schema.maxByteLength}` }
     }
   }
-
   function* Unknown(schema: Types.TUnknown, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {}
-
   function* Void(schema: Types.TVoid, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(value === null)) {
-      return yield { type: ValueErrorType.Void, schema, path, value, message: `Expected null` }
+    if (!IsVoid(value)) {
+      return yield { type: ValueErrorType.Void, schema, path, value, message: `Expected void` }
     }
   }
-
   function* UserDefined(schema: Types.TSchema, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    const func = Custom.Get(schema[Types.Kind])!
-    if (!func(schema, value)) {
+    const check = Types.TypeRegistry.Get(schema[Types.Kind])!
+    if (!check(schema, value)) {
       return yield { type: ValueErrorType.Custom, schema, path, value, message: `Expected kind ${schema[Types.Kind]}` }
     }
   }
-
   function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    const anyReferences = schema.$id === undefined ? references : [schema, ...references]
-    const anySchema = schema as any
-    switch (anySchema[Types.Kind]) {
+    const references_ = IsDefined<string>(schema.$id) ? [...references, schema] : references
+    const schema_ = schema as any
+    switch (schema_[Types.Kind]) {
       case 'Any':
-        return yield* Any(anySchema, anyReferences, path, value)
+        return yield* Any(schema_, references_, path, value)
       case 'Array':
-        return yield* Array(anySchema, anyReferences, path, value)
+        return yield* Array(schema_, references_, path, value)
+      case 'BigInt':
+        return yield* BigInt(schema_, references_, path, value)
       case 'Boolean':
-        return yield* Boolean(anySchema, anyReferences, path, value)
+        return yield* Boolean(schema_, references_, path, value)
       case 'Constructor':
-        return yield* Constructor(anySchema, anyReferences, path, value)
+        return yield* Constructor(schema_, references_, path, value)
       case 'Date':
-        return yield* Date(anySchema, anyReferences, path, value)
+        return yield* Date(schema_, references_, path, value)
       case 'Function':
-        return yield* Function(anySchema, anyReferences, path, value)
+        return yield* Function(schema_, references_, path, value)
       case 'Integer':
-        return yield* Integer(anySchema, anyReferences, path, value)
+        return yield* Integer(schema_, references_, path, value)
+      case 'Intersect':
+        return yield* Intersect(schema_, references_, path, value)
       case 'Literal':
-        return yield* Literal(anySchema, anyReferences, path, value)
+        return yield* Literal(schema_, references_, path, value)
       case 'Never':
-        return yield* Never(anySchema, anyReferences, path, value)
+        return yield* Never(schema_, references_, path, value)
+      case 'Not':
+        return yield* Not(schema_, references_, path, value)
       case 'Null':
-        return yield* Null(anySchema, anyReferences, path, value)
+        return yield* Null(schema_, references_, path, value)
       case 'Number':
-        return yield* Number(anySchema, anyReferences, path, value)
+        return yield* Number(schema_, references_, path, value)
       case 'Object':
-        return yield* Object(anySchema, anyReferences, path, value)
+        return yield* Object(schema_, references_, path, value)
       case 'Promise':
-        return yield* Promise(anySchema, anyReferences, path, value)
+        return yield* Promise(schema_, references_, path, value)
       case 'Record':
-        return yield* Record(anySchema, anyReferences, path, value)
+        return yield* Record(schema_, references_, path, value)
       case 'Ref':
-        return yield* Ref(anySchema, anyReferences, path, value)
+        return yield* Ref(schema_, references_, path, value)
       case 'Self':
-        return yield* Self(anySchema, anyReferences, path, value)
+        return yield* Self(schema_, references_, path, value)
       case 'String':
-        return yield* String(anySchema, anyReferences, path, value)
+        return yield* String(schema_, references_, path, value)
+      case 'Symbol':
+        return yield* Symbol(schema_, references_, path, value)
       case 'Tuple':
-        return yield* Tuple(anySchema, anyReferences, path, value)
+        return yield* Tuple(schema_, references_, path, value)
       case 'Undefined':
-        return yield* Undefined(anySchema, anyReferences, path, value)
+        return yield* Undefined(schema_, references_, path, value)
       case 'Union':
-        return yield* Union(anySchema, anyReferences, path, value)
+        return yield* Union(schema_, references_, path, value)
       case 'Uint8Array':
-        return yield* Uint8Array(anySchema, anyReferences, path, value)
+        return yield* Uint8Array(schema_, references_, path, value)
       case 'Unknown':
-        return yield* Unknown(anySchema, anyReferences, path, value)
+        return yield* Unknown(schema_, references_, path, value)
       case 'Void':
-        return yield* Void(anySchema, anyReferences, path, value)
+        return yield* Void(schema_, references_, path, value)
       default:
-        if (!Custom.Has(anySchema[Types.Kind])) throw new ValueErrorsUnknownTypeError(schema)
-        return yield* UserDefined(anySchema, anyReferences, path, value)
+        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueErrorsUnknownTypeError(schema)
+        return yield* UserDefined(schema_, references_, path, value)
     }
   }
-
-  export function* Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): IterableIterator<ValueError> {
-    yield* Visit(schema, references, '', value)
+  export function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): ValueErrorIterator {
+    const iterator = Visit(schema, references, '', value)
+    return new ValueErrorIterator(iterator)
   }
 }
diff --git a/src/format/format.ts b/src/format/format.ts
deleted file mode 100644
index 9bf384637..000000000
--- a/src/format/format.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/format
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-export type FormatValidationFunction = (value: string) => boolean
-
-/** Provides functions to create user defined string formats */
-export namespace Format {
-  const formats = new Map<string, FormatValidationFunction>()
-
-  /** Clears all user defined string formats */
-  export function Clear() {
-    return formats.clear()
-  }
-
-  /** Returns true if the user defined string format exists */
-  export function Has(format: string) {
-    return formats.has(format)
-  }
-
-  /** Sets a validation function for a user defined string format */
-  export function Set(format: string, func: FormatValidationFunction) {
-    formats.set(format, func)
-  }
-
-  /** Gets a validation function for a user defined string format */
-  export function Get(format: string) {
-    return formats.get(format)
-  }
-}
diff --git a/src/format/index.ts b/src/format/index.ts
deleted file mode 100644
index 58e298c28..000000000
--- a/src/format/index.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/format
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-export * from './format'
diff --git a/src/guard/extends.ts b/src/guard/extends.ts
deleted file mode 100644
index 441a87dca..000000000
--- a/src/guard/extends.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/guard
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, dTribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import * as Types from '../typebox'
-
-export namespace TypeExtends {
-  /**
-   * This function returns true if the given schema is undefined, either directly or
-   * through union composition. This check is required on object property types of
-   * undefined, where an additional `'x' in value` check is required to determine
-   * the keys existence.
-   */
-  export function Undefined(schema: Types.TSchema): boolean {
-    if (schema[Types.Kind] === 'Undefined') return true
-    if (schema[Types.Kind] === 'Union') {
-      const union = schema as Types.TUnion
-      return union.anyOf.some((schema) => Undefined(schema))
-    }
-    return false
-  }
-}
diff --git a/src/guard/guard.ts b/src/guard/guard.ts
deleted file mode 100644
index 87d4bc1a8..000000000
--- a/src/guard/guard.ts
+++ /dev/null
@@ -1,487 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/guard
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, dTribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { Custom } from '../custom/index'
-import * as Types from '../typebox'
-
-export class TypeGuardUnknownTypeError extends Error {
-  constructor(public readonly schema: unknown) {
-    super('TypeGuard: Unknown type')
-  }
-}
-
-/** Provides functionality to test if values are TypeBox types */
-export namespace TypeGuard {
-  function IsObject(value: unknown): value is Record<string | symbol, any> {
-    return typeof value === 'object' && value !== null && !Array.isArray(value)
-  }
-
-  function IsArray(value: unknown): value is any[] {
-    return typeof value === 'object' && value !== null && Array.isArray(value)
-  }
-
-  function IsPattern(value: unknown): value is string {
-    try {
-      new RegExp(value as string)
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  function IsControlCharacterFree(value: unknown): value is string {
-    if (typeof value !== 'string') return false
-    for (let i = 0; i < value.length; i++) {
-      const code = value.charCodeAt(i)
-      if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
-        return false
-      }
-    }
-    return true
-  }
-
-  function IsString(value: unknown): value is string {
-    return typeof value === 'string'
-  }
-
-  function IsNumber(value: unknown): value is number {
-    return typeof value === 'number' && !isNaN(value)
-  }
-
-  function IsBoolean(value: unknown): value is boolean {
-    return typeof value === 'boolean'
-  }
-
-  function IsOptionalNumber(value: unknown): value is number | undefined {
-    return value === undefined || (value !== undefined && IsNumber(value))
-  }
-
-  function IsOptionalBoolean(value: unknown): value is boolean | undefined {
-    return value === undefined || (value !== undefined && IsBoolean(value))
-  }
-
-  function IsOptionalString(value: unknown): value is string | undefined {
-    return value === undefined || (value !== undefined && IsString(value))
-  }
-
-  function IsOptionalPattern(value: unknown): value is string | undefined {
-    return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value) && IsPattern(value))
-  }
-
-  function IsOptionalFormat(value: unknown): value is string | undefined {
-    return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value))
-  }
-
-  function IsOptionalSchema(value: unknown): value is boolean | undefined {
-    return value === undefined || TSchema(value)
-  }
-
-  /** Returns true if the given schema is TAny */
-  export function TAny(schema: unknown): schema is Types.TAny {
-    return IsObject(schema) && schema[Types.Kind] === 'Any' && IsOptionalString(schema.$id)
-  }
-
-  /** Returns true if the given schema is TArray */
-  export function TArray(schema: unknown): schema is Types.TArray {
-    return (
-      IsObject(schema) &&
-      schema[Types.Kind] === 'Array' &&
-      schema.type === 'array' &&
-      IsOptionalString(schema.$id) &&
-      TSchema(schema.items) &&
-      IsOptionalNumber(schema.minItems) &&
-      IsOptionalNumber(schema.maxItems) &&
-      IsOptionalBoolean(schema.uniqueItems)
-    )
-  }
-
-  /** Returns true if the given schema is TBoolean */
-  export function TBoolean(schema: unknown): schema is Types.TBoolean {
-    // prettier-ignore
-    return (
-      IsObject(schema) && 
-      schema[Types.Kind] === 'Boolean' && 
-      schema.type === 'boolean' && 
-      IsOptionalString(schema.$id)
-    )
-  }
-
-  /** Returns true if the given schema is TConstructor */
-  export function TConstructor(schema: unknown): schema is Types.TConstructor {
-    // prettier-ignore
-    if (!(
-      IsObject(schema) && 
-      schema[Types.Kind] === 'Constructor' && 
-      schema.type === 'object' && 
-      schema.instanceOf === 'Constructor' && 
-      IsOptionalString(schema.$id) && 
-      IsArray(schema.parameters) && 
-      TSchema(schema.returns))
-    ) {
-      return false
-    }
-    for (const parameter of schema.parameters) {
-      if (!TSchema(parameter)) return false
-    }
-    return true
-  }
-
-  /** Returns true if the given schema is TDate */
-  export function TDate(schema: unknown): schema is Types.TDate {
-    return (
-      IsObject(schema) &&
-      schema[Types.Kind] === 'Date' &&
-      schema.type === 'object' &&
-      schema.instanceOf === 'Date' &&
-      IsOptionalString(schema.$id) &&
-      IsOptionalNumber(schema.minimumTimestamp) &&
-      IsOptionalNumber(schema.maximumTimestamp) &&
-      IsOptionalNumber(schema.exclusiveMinimumTimestamp) &&
-      IsOptionalNumber(schema.exclusiveMaximumTimestamp)
-    )
-  }
-
-  /** Returns true if the given schema is TFunction */
-  export function TFunction(schema: unknown): schema is Types.TFunction {
-    // prettier-ignore
-    if (!(
-      IsObject(schema) && 
-      schema[Types.Kind] === 'Function' && 
-      schema.type === 'object' &&
-      schema.instanceOf === 'Function' &&
-      IsOptionalString(schema.$id) && 
-      IsArray(schema.parameters) && 
-      TSchema(schema.returns))
-    ) {
-      return false
-    }
-    for (const parameter of schema.parameters) {
-      if (!TSchema(parameter)) return false
-    }
-    return true
-  }
-
-  /** Returns true if the given schema is TInteger */
-  export function TInteger(schema: unknown): schema is Types.TInteger {
-    return (
-      IsObject(schema) &&
-      schema[Types.Kind] === 'Integer' &&
-      schema.type === 'integer' &&
-      IsOptionalString(schema.$id) &&
-      IsOptionalNumber(schema.multipleOf) &&
-      IsOptionalNumber(schema.minimum) &&
-      IsOptionalNumber(schema.maximum) &&
-      IsOptionalNumber(schema.exclusiveMinimum) &&
-      IsOptionalNumber(schema.exclusiveMaximum)
-    )
-  }
-
-  /** Returns true if the given schema is TLiteral */
-  export function TLiteral(schema: unknown): schema is Types.TLiteral {
-    // prettier-ignore
-    return (
-      IsObject(schema) && 
-      schema[Types.Kind] === 'Literal' && 
-      IsOptionalString(schema.$id) && 
-      (
-        IsString(schema.const) || 
-        IsNumber(schema.const) || 
-        IsBoolean(schema.const)
-      )
-    )
-  }
-
-  /** Returns true if the given schema is TNever */
-  export function TNever(schema: unknown): schema is Types.TNever {
-    return (
-      IsObject(schema) &&
-      schema[Types.Kind] === 'Never' &&
-      IsArray(schema.allOf) &&
-      schema.allOf.length === 2 &&
-      IsObject(schema.allOf[0]) &&
-      IsString(schema.allOf[0].type) &&
-      schema.allOf[0].type === 'boolean' &&
-      schema.allOf[0].const === false &&
-      IsObject(schema.allOf[1]) &&
-      IsString(schema.allOf[1].type) &&
-      schema.allOf[1].type === 'boolean' &&
-      schema.allOf[1].const === true
-    )
-  }
-
-  /** Returns true if the given schema is TNull */
-  export function TNull(schema: unknown): schema is Types.TNull {
-    return IsObject(schema) && schema[Types.Kind] === 'Null' && schema.type === 'null' && IsOptionalString(schema.$id)
-  }
-
-  /** Returns true if the given schema is TNumber */
-  export function TNumber(schema: unknown): schema is Types.TNumber {
-    return (
-      IsObject(schema) &&
-      schema[Types.Kind] === 'Number' &&
-      schema.type === 'number' &&
-      IsOptionalString(schema.$id) &&
-      IsOptionalNumber(schema.multipleOf) &&
-      IsOptionalNumber(schema.minimum) &&
-      IsOptionalNumber(schema.maximum) &&
-      IsOptionalNumber(schema.exclusiveMinimum) &&
-      IsOptionalNumber(schema.exclusiveMaximum)
-    )
-  }
-
-  /** Returns true if the given schema is TObject */
-  export function TObject(schema: unknown): schema is Types.TObject {
-    if (
-      !(
-        IsObject(schema) &&
-        schema[Types.Kind] === 'Object' &&
-        schema.type === 'object' &&
-        IsOptionalString(schema.$id) &&
-        IsObject(schema.properties) &&
-        (IsOptionalBoolean(schema.additionalProperties) || IsOptionalSchema(schema.additionalProperties)) &&
-        IsOptionalNumber(schema.minProperties) &&
-        IsOptionalNumber(schema.maxProperties)
-      )
-    ) {
-      return false
-    }
-    for (const [key, value] of Object.entries(schema.properties)) {
-      if (!IsControlCharacterFree(key)) return false
-      if (!TSchema(value)) return false
-    }
-    return true
-  }
-
-  /** Returns true if the given schema is TPromise */
-  export function TPromise(schema: unknown): schema is Types.TPromise {
-    // prettier-ignore
-    return (
-      IsObject(schema) && 
-      schema[Types.Kind] === 'Promise' && 
-      schema.type === 'object' && 
-      schema.instanceOf === 'Promise' &&
-      IsOptionalString(schema.$id) && 
-      TSchema(schema.item)
-    )
-  }
-
-  /** Returns true if the given schema is TRecord */
-  export function TRecord(schema: unknown): schema is Types.TRecord {
-    // prettier-ignore
-    if (!(
-      IsObject(schema) && 
-      schema[Types.Kind] === 'Record' && 
-      schema.type === 'object' && 
-      IsOptionalString(schema.$id) && 
-      schema.additionalProperties === false && 
-      IsObject(schema.patternProperties))
-    ) {
-      return false
-    }
-    const keys = Object.keys(schema.patternProperties)
-    if (keys.length !== 1) {
-      return false
-    }
-    if (!IsPattern(keys[0])) {
-      return false
-    }
-    if (!TSchema(schema.patternProperties[keys[0]])) {
-      return false
-    }
-    return true
-  }
-
-  /** Returns true if the given schema is TSelf */
-  export function TSelf(schema: unknown): schema is Types.TSelf {
-    // prettier-ignore
-    return (
-      IsObject(schema) && 
-      schema[Types.Kind] === 'Self' && 
-      IsOptionalString(schema.$id) && 
-      IsString(schema.$ref)
-    )
-  }
-
-  /** Returns true if the given schema is TRef */
-  export function TRef(schema: unknown): schema is Types.TRef {
-    // prettier-ignore
-    return (
-      IsObject(schema) && 
-      schema[Types.Kind] === 'Ref' && 
-      IsOptionalString(schema.$id) && 
-      IsString(schema.$ref)
-    )
-  }
-
-  /** Returns true if the given schema is TString */
-  export function TString(schema: unknown): schema is Types.TString {
-    return (
-      IsObject(schema) &&
-      schema[Types.Kind] === 'String' &&
-      schema.type === 'string' &&
-      IsOptionalString(schema.$id) &&
-      IsOptionalNumber(schema.minLength) &&
-      IsOptionalNumber(schema.maxLength) &&
-      IsOptionalPattern(schema.pattern) &&
-      IsOptionalFormat(schema.format)
-    )
-  }
-
-  /** Returns true if the given schema is TTuple */
-  export function TTuple(schema: unknown): schema is Types.TTuple {
-    // prettier-ignore
-    if (!(
-      IsObject(schema) && 
-      schema[Types.Kind] === 'Tuple' && 
-      schema.type === 'array' && 
-      IsOptionalString(schema.$id) && 
-      IsNumber(schema.minItems) && 
-      IsNumber(schema.maxItems) && 
-      schema.minItems === schema.maxItems)
-    ) {
-      return false
-    }
-    if (schema.items === undefined && schema.additionalItems === undefined && schema.minItems === 0) {
-      return true
-    }
-    if (!IsArray(schema.items)) {
-      return false
-    }
-    for (const inner of schema.items) {
-      if (!TSchema(inner)) return false
-    }
-    return true
-  }
-
-  /** Returns true if the given schema is TUndefined */
-  export function TUndefined(schema: unknown): schema is Types.TUndefined {
-    // prettier-ignore
-    return (
-      IsObject(schema) && 
-      schema[Types.Kind] === 'Undefined' && 
-      schema.type === 'null' && 
-      schema.typeOf === 'Undefined' && 
-      IsOptionalString(schema.$id)
-    )
-  }
-
-  /** Returns true if the given schema is TUnion */
-  export function TUnion(schema: unknown): schema is Types.TUnion {
-    // prettier-ignore
-    if (!(
-      IsObject(schema) && 
-      schema[Types.Kind] === 'Union' && 
-      IsArray(schema.anyOf) && 
-      IsOptionalString(schema.$id))
-    ) {
-      return false
-    }
-    for (const inner of schema.anyOf) {
-      if (!TSchema(inner)) return false
-    }
-    return true
-  }
-
-  /** Returns true if the given schema is TUint8Array */
-  export function TUint8Array(schema: unknown): schema is Types.TUint8Array {
-    return (
-      IsObject(schema) &&
-      schema[Types.Kind] === 'Uint8Array' &&
-      schema.type === 'object' &&
-      IsOptionalString(schema.$id) &&
-      schema.instanceOf === 'Uint8Array' &&
-      IsOptionalNumber(schema.minByteLength) &&
-      IsOptionalNumber(schema.maxByteLength)
-    )
-  }
-
-  /** Returns true if the given schema is TUnknown */
-  export function TUnknown(schema: unknown): schema is Types.TUnknown {
-    // prettier-ignore
-    return (
-      IsObject(schema) && 
-      schema[Types.Kind] === 'Unknown' && 
-      IsOptionalString(schema.$id)
-    )
-  }
-
-  /** Returns true if the given schema is TVoid */
-  export function TVoid(schema: unknown): schema is Types.TVoid {
-    // prettier-ignore
-    return (
-      IsObject(schema) && 
-      schema[Types.Kind] === 'Void' && 
-      schema.type === 'null' && 
-      schema.typeOf === 'Void' && 
-      IsOptionalString(schema.$id)
-    )
-  }
-
-  /** Returns true if the given schema is a registered user defined type */
-  export function TUserDefined(schema: unknown): schema is Types.TSchema {
-    return IsObject(schema) && IsString(schema[Types.Kind]) && Custom.Has(schema[Types.Kind])
-  }
-
-  /** Returns true if the given schema is TSchema */
-  export function TSchema(schema: unknown): schema is Types.TSchema {
-    return (
-      TAny(schema) ||
-      TArray(schema) ||
-      TBoolean(schema) ||
-      TConstructor(schema) ||
-      TDate(schema) ||
-      TFunction(schema) ||
-      TInteger(schema) ||
-      TLiteral(schema) ||
-      TNever(schema) ||
-      TNull(schema) ||
-      TNumber(schema) ||
-      TObject(schema) ||
-      TPromise(schema) ||
-      TRecord(schema) ||
-      TSelf(schema) ||
-      TRef(schema) ||
-      TString(schema) ||
-      TTuple(schema) ||
-      TUndefined(schema) ||
-      TUnion(schema) ||
-      TUint8Array(schema) ||
-      TUnknown(schema) ||
-      TVoid(schema) ||
-      TUserDefined(schema)
-    )
-  }
-
-  /** Asserts if this schema and associated references are valid. */
-  export function Assert<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []) {
-    if (!TSchema(schema)) throw new TypeGuardUnknownTypeError(schema)
-    for (const schema of references) {
-      if (!TSchema(schema)) throw new TypeGuardUnknownTypeError(schema)
-    }
-  }
-}
diff --git a/src/guard/index.ts b/src/guard/index.ts
deleted file mode 100644
index 036419519..000000000
--- a/src/guard/index.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/guards
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-export * from './guard'
-export * from './extends'
diff --git a/src/system/system.ts b/src/system/system.ts
index 1a637f8aa..598f6cc09 100644
--- a/src/system/system.ts
+++ b/src/system/system.ts
@@ -26,40 +26,47 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { Kind, Type } from '../typebox'
-import { Custom } from '../custom/index'
-import { Format } from '../format/index'
+import * as Types from '../typebox'
 
 export class TypeSystemDuplicateTypeKind extends Error {
   constructor(kind: string) {
-    super(`Duplicate kind '${kind}' detected`)
+    super(`Duplicate type kind '${kind}' detected`)
   }
 }
 export class TypeSystemDuplicateFormat extends Error {
   constructor(kind: string) {
-    super(`Duplicate format '${kind}' detected`)
+    super(`Duplicate string format '${kind}' detected`)
   }
 }
-
 /** Creates user defined types and formats and provides overrides for value checking behaviours */
 export namespace TypeSystem {
-  /** Sets whether arrays should be treated as kinds of objects. The default is `false` */
+  /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
   export let AllowArrayObjects: boolean = false
-
-  /** Sets whether numeric checks should consider NaN a valid number type. The default is `false` */
+  /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
   export let AllowNaN: boolean = false
-
-  /** Creates a custom type */
-  export function CreateType<Type, Options = object>(kind: string, callback: (options: Options, value: unknown) => boolean) {
-    if (Custom.Has(kind)) throw new TypeSystemDuplicateTypeKind(kind)
-    Custom.Set(kind, callback)
-    return (options: Partial<Options> = {}) => Type.Unsafe<Type>({ ...options, [Kind]: kind })
+  /** Sets whether `null` should validate for void types. The default is `false` */
+  export let AllowVoidNull: boolean = false
+  /** Creates a new type */
+  export function Type<Type, Options = object>(kind: string, check: (options: Options, value: unknown) => boolean) {
+    if (Types.TypeRegistry.Has(kind)) throw new TypeSystemDuplicateTypeKind(kind)
+    Types.TypeRegistry.Set(kind, check)
+    return (options: Partial<Options> = {}) => Types.Type.Unsafe<Type>({ ...options, [Types.Kind]: kind })
   }
-
-  /** Creates a custom string format */
-  export function CreateFormat(format: string, callback: (value: string) => boolean) {
-    if (Format.Has(format)) throw new TypeSystemDuplicateFormat(format)
-    Format.Set(format, callback)
-    return callback
+  /** Creates a new string format */
+  export function Format<F extends string>(format: F, check: (value: string) => boolean): F {
+    if (Types.FormatRegistry.Has(format)) throw new TypeSystemDuplicateFormat(format)
+    Types.FormatRegistry.Set(format, check)
+    return format
+  }
+  // ------------------------------------------------------------------------
+  // Deprecated
+  // ------------------------------------------------------------------------
+  /** @deprecated Use `TypeSystem.Type()` instead. */
+  export function CreateType<Type, Options = object>(kind: string, check: (options: Options, value: unknown) => boolean) {
+    return Type<Type, Options>(kind, check)
+  }
+  /** @deprecated Use `TypeSystem.Format()` instead.  */
+  export function CreateFormat<F extends string>(format: F, check: (value: string) => boolean): F {
+    return Format<F>(format, check)
   }
 }
diff --git a/src/tsconfig.json b/src/tsconfig.json
index 52cb52269..c78307cfa 100644
--- a/src/tsconfig.json
+++ b/src/tsconfig.json
@@ -1,4 +1,4 @@
 {
   "extends": "../tsconfig.json",
-  "files": ["compiler/index.ts", "conditional/index.ts", "custom/index.ts", "format/index.ts", "guard/index.ts", "hash/index.ts", "value/index.ts", "typebox.ts"]
+  "files": ["compiler/index.ts", "errors/index.ts", "system/index.ts", "value/index.ts", "typebox.ts"]
 }
diff --git a/src/typebox.ts b/src/typebox.ts
index e5fb7ff5d..6c8796938 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -27,26 +27,32 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 // --------------------------------------------------------------------------
-// Symbols
+// Compositing Symbols
 // --------------------------------------------------------------------------
-
-export const Kind = Symbol.for('TypeBox.Kind')
-export const Hint = Symbol.for('TypeBox.Hint')
 export const Modifier = Symbol.for('TypeBox.Modifier')
-
+export const Hint = Symbol.for('TypeBox.Hint')
+export const Kind = Symbol.for('TypeBox.Kind')
+// --------------------------------------------------------------------------
+// Helpers
+// --------------------------------------------------------------------------
+export type TupleToIntersect<T extends any[]> = T extends [infer I] ? I : T extends [infer I, ...infer R] ? I & TupleToIntersect<R> : never
+export type TupleToUnion<T extends any[]> = { [K in keyof T]: T[K] }[number]
+export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never
+export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never
+export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L]
+export type Assert<T, E> = T extends E ? T : never
+export type Evaluate<T> = T extends infer O ? { [K in keyof O]: O[K] } : never
+export type Ensure<T> = T extends infer U ? U : never
 // --------------------------------------------------------------------------
 // Modifiers
 // --------------------------------------------------------------------------
-
 export type TModifier = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>
 export type TReadonly<T extends TSchema> = T & { [Modifier]: 'Readonly' }
 export type TOptional<T extends TSchema> = T & { [Modifier]: 'Optional' }
 export type TReadonlyOptional<T extends TSchema> = T & { [Modifier]: 'ReadonlyOptional' }
-
 // --------------------------------------------------------------------------
-// Schema
+// TSchema
 // --------------------------------------------------------------------------
-
 export interface SchemaOptions {
   $schema?: string
   /** Id for this schema */
@@ -57,294 +63,309 @@ export interface SchemaOptions {
   description?: string
   /** Default value for this schema */
   default?: any
-  /** Example values matching this schema. */
+  /** Example values matching this schema */
   examples?: any
   [prop: string]: any
 }
-
-export interface TSchema extends SchemaOptions {
+export interface TKind {
   [Kind]: string
-  [Hint]?: string
+}
+export interface TSchema extends SchemaOptions, TKind {
   [Modifier]?: string
+  [Hint]?: string
   params: unknown[]
   static: unknown
 }
-
 // --------------------------------------------------------------------------
 // TAnySchema
 // --------------------------------------------------------------------------
-
 export type TAnySchema =
   | TSchema
   | TAny
   | TArray
+  | TBigInt
   | TBoolean
   | TConstructor
   | TDate
   | TEnum
   | TFunction
   | TInteger
+  | TIntersect
   | TLiteral
+  | TNot
   | TNull
   | TNumber
   | TObject
   | TPromise
   | TRecord
-  | TSelf
   | TRef
+  | TSelf
   | TString
+  | TSymbol
   | TTuple
   | TUndefined
   | TUnion
   | TUint8Array
   | TUnknown
   | TVoid
-
 // --------------------------------------------------------------------------
 // TNumeric
 // --------------------------------------------------------------------------
-
-export interface NumericOptions extends SchemaOptions {
-  exclusiveMaximum?: number
-  exclusiveMinimum?: number
-  maximum?: number
-  minimum?: number
-  multipleOf?: number
-}
-
 export type TNumeric = TInteger | TNumber
-
+export interface NumericOptions<N extends number | bigint> extends SchemaOptions {
+  exclusiveMaximum?: N
+  exclusiveMinimum?: N
+  maximum?: N
+  minimum?: N
+  multipleOf?: N
+}
 // --------------------------------------------------------------------------
-// Any
+// TAny
 // --------------------------------------------------------------------------
-
 export interface TAny extends TSchema {
   [Kind]: 'Any'
   static: any
 }
-
 // --------------------------------------------------------------------------
-// Array
+// TArray
 // --------------------------------------------------------------------------
-
 export interface ArrayOptions extends SchemaOptions {
   uniqueItems?: boolean
   minItems?: number
   maxItems?: number
 }
-
 export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
   [Kind]: 'Array'
-  static: Array<Static<T, this['params']>>
+  static: Static<T, this['params']>[]
   type: 'array'
   items: T
 }
-
 // --------------------------------------------------------------------------
-// Boolean
+// TBigInt
+// --------------------------------------------------------------------------
+export interface TBigInt extends TSchema, NumericOptions<bigint> {
+  [Kind]: 'BigInt'
+  static: bigint
+  type: 'null'
+  typeOf: 'BigInt'
+}
+// --------------------------------------------------------------------------
+// TBoolean
 // --------------------------------------------------------------------------
-
 export interface TBoolean extends TSchema {
   [Kind]: 'Boolean'
   static: boolean
   type: 'boolean'
 }
-
 // --------------------------------------------------------------------------
-// Constructor
+// TConstructorParameters
 // --------------------------------------------------------------------------
-
 export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>
-
+// --------------------------------------------------------------------------
+// TInstanceType
+// --------------------------------------------------------------------------
 export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns']
-
-export type StaticContructorParameters<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never }]
-
+// --------------------------------------------------------------------------
+// TComposite
+// --------------------------------------------------------------------------
+export type TCompositeUnion<Left extends TSchema, Right extends TSchema> = Ensure<TUnion<[Left, Right]>>
+// note: we need to take the left and right as the accumulator is assigned for multiple composite property sets with missing properties.
+export type TCompositeUnionLeft<T extends TObject, Acc extends TProperties> = {
+  [K in keyof T['properties']]: K extends keyof Acc ? TCompositeUnion<T['properties'][K], Acc[K]> : T['properties'][K]
+}
+export type TCompositeUnionRight<T extends TObject, Acc extends TProperties> = {
+  [K in keyof Acc]: K extends keyof T['properties'] ? TCompositeUnion<T['properties'][K], Acc[K]> : Acc[K]
+}
+export type TCompositeUnionObject<T extends TObject, Acc extends TProperties> = Evaluate<TCompositeUnionLeft<T, Acc> & TCompositeUnionRight<T, Acc>>
+// prettier-ignore
+export type TCompositeProperties<T extends TObject[], Acc extends TProperties> = 
+  T extends [...infer L, infer R] ? TCompositeProperties<Assert<L, TObject[]>, TCompositeUnionObject<Assert<R, TObject>, Acc>> :
+  T extends [] ? Acc :
+  never
+export type TComposite<T extends TObject[] = TObject[]> = Ensure<TObject<TCompositeProperties<T, {}>>>
+// --------------------------------------------------------------------------
+// TConstructor
+// --------------------------------------------------------------------------
+export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: Static<Assert<T[K], TSchema>, P> }]
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Constructor'
-  static: new (...param: StaticContructorParameters<T, this['params']>) => Static<U, this['params']>
+  static: new (...param: TConstructorParameterArray<T, this['params']>) => Static<U, this['params']>
   type: 'object'
   instanceOf: 'Constructor'
   parameters: T
   returns: U
 }
-
 // --------------------------------------------------------------------------
-// Date
+// TDate
 // --------------------------------------------------------------------------
-
 export interface DateOptions extends SchemaOptions {
   exclusiveMaximumTimestamp?: number
   exclusiveMinimumTimestamp?: number
   maximumTimestamp?: number
   minimumTimestamp?: number
 }
-
 export interface TDate extends TSchema, DateOptions {
   [Kind]: 'Date'
   static: Date
   type: 'object'
   instanceOf: 'Date'
 }
-
 // --------------------------------------------------------------------------
-// Enum
+// TEnum
 // --------------------------------------------------------------------------
-
 export interface TEnumOption<T> {
   type: 'number' | 'string'
   const: T
 }
-
+export type TEnumStatic<T extends Record<string, string | number>> = T[keyof T]
 export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
   [Kind]: 'Union'
-  static: T[keyof T]
+  static: TEnumStatic<T>
   anyOf: TLiteral<string | number>[]
 }
-
 // --------------------------------------------------------------------------
-// Function
+// TExtends
 // --------------------------------------------------------------------------
-
-export type TParameters<T extends TFunction> = TTuple<T['parameters']>
-
-export type TReturnType<T extends TFunction> = T['returns']
-
-export type StaticFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never }]
-
+// prettier-ignore
+export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = 
+  (Static<L> extends Static<R> ? T : U) extends infer O ? 
+    UnionToTuple<O> extends [infer X, infer Y] ? TUnion<[Assert<X, TSchema>, Assert<Y, TSchema>]> : Assert<O, TSchema>
+  : never
+// --------------------------------------------------------------------------
+// TExclude
+// --------------------------------------------------------------------------
+// prettier-ignore
+export type TExcludeArray<T extends TSchema[], U extends TSchema> = Assert<UnionToTuple<{
+  [K in keyof T]: Static<Assert<T[K], TSchema>> extends Static<U> ? never : T[K]
+}[number]>, TSchema[]> extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never
+export type TExclude<T extends TSchema, U extends TSchema> = T extends TUnion<infer S> ? TExcludeArray<S, U> : T extends U ? TNever : T
+// --------------------------------------------------------------------------
+// TExtract
+// --------------------------------------------------------------------------
+// prettier-ignore
+export type TExtractArray<T extends TSchema[], U extends TSchema> = Assert<UnionToTuple<
+  {[K in keyof T]: Static<Assert<T[K], TSchema>> extends Static<U> ? T[K] : never
+}[number]>, TSchema[]> extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never
+export type TExtract<T extends TSchema, U extends TSchema> = T extends TUnion<infer S> ? TExtractArray<S, U> : T extends U ? T : TNever
+// --------------------------------------------------------------------------
+// TFunction
+// --------------------------------------------------------------------------
+export type TFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: Static<Assert<T[K], TSchema>, P> }]
 export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Function'
-  static: (...param: StaticFunctionParameters<T, this['params']>) => Static<U, this['params']>
+  static: (...param: TFunctionParameters<T, this['params']>) => Static<U, this['params']>
   type: 'object'
   instanceOf: 'Function'
   parameters: T
   returns: U
 }
-
 // --------------------------------------------------------------------------
-// Integer
+// TInteger
 // --------------------------------------------------------------------------
-
-export interface TInteger extends TSchema, NumericOptions {
+export interface TInteger extends TSchema, NumericOptions<number> {
   [Kind]: 'Integer'
   static: number
   type: 'integer'
 }
-
 // --------------------------------------------------------------------------
-// Intersect
+// TIntersect
 // --------------------------------------------------------------------------
-
-export type IntersectReduce<I extends unknown, T extends readonly any[]> = T extends [infer A, ...infer B] ? IntersectReduce<I & A, B> : I extends object ? I : {}
-
-// note: rename to IntersectStatic<T, P> in next minor release
-export type IntersectEvaluate<T extends readonly TSchema[], P extends unknown[]> = { [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never }
-
-export type IntersectProperties<T extends readonly TObject[]> = {
-  [K in keyof T]: T[K] extends TObject<infer P> ? P : {}
+export type TUnevaluatedProperties = undefined | TSchema | boolean
+export interface IntersectOptions extends SchemaOptions {
+  unevaluatedProperties?: TUnevaluatedProperties
 }
-
-export interface TIntersect<T extends TObject[] = TObject[]> extends TObject {
-  static: IntersectReduce<unknown, IntersectEvaluate<T, this['params']>>
-  properties: IntersectReduce<unknown, IntersectProperties<T>>
+export type TIntersectStatic<T extends TSchema[], P extends unknown[]> = TupleToIntersect<{ [K in keyof T]: Static<Assert<T[K], TSchema>, P> }>
+export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
+  [Kind]: 'Intersect'
+  type?: 'object'
+  static: TIntersectStatic<T, this['params']>
+  allOf: [...T]
 }
-
 // --------------------------------------------------------------------------
-// KeyOf
+// TKeyOf
 // --------------------------------------------------------------------------
-
-export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never
-export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never
-export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L]
-export type UnionStringLiteralToTuple<T> = T extends TUnion<infer L> ? { [I in keyof L]: L[I] extends TLiteral<infer C> ? C : never } : never
-export type UnionLiteralsFromObject<T extends TObject> = { [K in ObjectPropertyKeys<T>]: TLiteral<K> } extends infer R ? UnionToTuple<R[keyof R]> : never
-
-// export type TKeyOf<T extends TObject> = { [K in ObjectPropertyKeys<T>]: TLiteral<K> } extends infer R ? UnionToTuple<R[keyof R]> : never
-
-export interface TKeyOf<T extends TObject> extends TUnion<UnionLiteralsFromObject<T>> {}
-
+// prettier-ignore
+export type TKeyOfTuple<T extends TSchema> = {
+  [K in keyof Static<T>]: TLiteral<Assert<K, TLiteralValue>>
+} extends infer U 
+  ? UnionToTuple<Exclude<{ [K in keyof U]: U[K] }[keyof U], undefined>> // optional yields undefined keys
+  : never
+// prettier-ignore
+export type TKeyOf<T extends TSchema = TSchema> = (
+  T extends TIntersect ? TKeyOfTuple<T> :
+  T extends TUnion     ? TKeyOfTuple<T> :
+  T extends TObject    ? TKeyOfTuple<T> :
+  []
+) extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never
 // --------------------------------------------------------------------------
-// Literal
+// TLiteral
 // --------------------------------------------------------------------------
-
-export type TLiteralValue = string | number | boolean
-
+export type TLiteralValue = string | number | boolean // | bigint - supported but variant disable due to potential numeric type conflicts
 export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
   [Kind]: 'Literal'
   static: T
   const: T
 }
-
 // --------------------------------------------------------------------------
-// Never
+// TNever
 // --------------------------------------------------------------------------
-
 export interface TNever extends TSchema {
   [Kind]: 'Never'
   static: never
   allOf: [{ type: 'boolean'; const: false }, { type: 'boolean'; const: true }]
 }
-
 // --------------------------------------------------------------------------
-// Null
+// TNot
+// --------------------------------------------------------------------------
+export type TNotStatic<_ extends TSchema = TSchema, T extends TSchema = TSchema> = Static<T>
+export interface TNot<Not extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'Not'
+  static: TNotStatic<Not, T>
+  allOf: [{ not: Not }, T]
+}
+// --------------------------------------------------------------------------
+// TNull
 // --------------------------------------------------------------------------
-
 export interface TNull extends TSchema {
   [Kind]: 'Null'
   static: null
   type: 'null'
 }
-
 // --------------------------------------------------------------------------
-// Number
+// TNumber
 // --------------------------------------------------------------------------
-
-export interface TNumber extends TSchema, NumericOptions {
+export interface TNumber extends TSchema, NumericOptions<number> {
   [Kind]: 'Number'
   static: number
   type: 'number'
 }
-
 // --------------------------------------------------------------------------
-// Object
+// TObject
 // --------------------------------------------------------------------------
-
 export type ReadonlyOptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never }[keyof T]
 export type ReadonlyPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never }[keyof T]
 export type OptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TOptional<TSchema> ? K : never }[keyof T]
 export type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>
-
 // prettier-ignore
-export type PropertiesReducer<T extends TProperties, R extends Record<keyof any, unknown>> = (
+export type PropertiesReducer<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(
   Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> &
   Readonly<Pick<R, ReadonlyPropertyKeys<T>>> &
   Partial<Pick<R, OptionalPropertyKeys<T>>> &
   Required<Pick<R, RequiredPropertyKeys<T>>>
-) extends infer O ? { [K in keyof O]: O[K] } : never
-
+)>
 // prettier-ignore
-export type PropertiesReduce<T extends TProperties, P extends unknown[]> = PropertiesReducer<T, { 
-  [K in keyof T]: Static<T[K], P> 
+export type PropertiesReduce<T extends TProperties, P extends unknown[]> = PropertiesReducer<T, {
+  [K in keyof T]: Static<T[K], P>
 }>
-
-export type TRecordProperties<K extends TUnion<TLiteral[]>, T extends TSchema> = Static<K> extends string ? { [X in Static<K>]: T } : never
-
-export interface TProperties {
-  [key: string]: TSchema
-}
-
+export type TProperties = Record<keyof any, TSchema>
 export type ObjectProperties<T> = T extends TObject<infer U> ? U : never
-
 export type ObjectPropertyKeys<T> = T extends TObject<infer U> ? keyof U : never
-
 export type TAdditionalProperties = undefined | TSchema | boolean
-
 export interface ObjectOptions extends SchemaOptions {
   additionalProperties?: TAdditionalProperties
   minProperties?: number
   maxProperties?: number
 }
-
 export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
   [Kind]: 'Object'
   static: PropertiesReduce<T, this['params']>
@@ -353,117 +374,128 @@ export interface TObject<T extends TProperties = TProperties> extends TSchema, O
   properties: T
   required?: string[]
 }
-
 // --------------------------------------------------------------------------
-// Omit
+// TOmit
 // --------------------------------------------------------------------------
-
-export interface TOmit<T extends TObject, Properties extends ObjectPropertyKeys<T>[]> extends TObject, ObjectOptions {
-  static: Omit<Static<T, this['params']>, Properties[number]>
-  properties: T extends TObject ? Omit<T['properties'], Properties[number]> : never
-}
-
+export type TOmitArray<T extends TSchema[], K extends keyof any> = Assert<{ [K2 in keyof T]: TOmit<Assert<T[K2], TSchema>, K> }, TSchema[]>
+export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<Assert<Omit<T, K>, TProperties>>
+// prettier-ignore
+export type TOmit<T extends TSchema, K extends keyof any> = 
+  T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : 
+  T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : 
+  T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : 
+  T
 // --------------------------------------------------------------------------
-// Partial
+// TParameters
 // --------------------------------------------------------------------------
-
-export interface TPartial<T extends TObject> extends TObject {
-  static: Partial<Static<T, this['params']>>
-  properties: {
-    // prettier-ignore
-    [K in keyof T['properties']]: 
-      T['properties'][K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : 
-      T['properties'][K] extends TReadonly<infer U>         ? TReadonlyOptional<U> : 
-      T['properties'][K] extends TOptional<infer U>         ? TOptional<U> : 
-      TOptional<T['properties'][K]>
-  }
-}
-
+export type TParameters<T extends TFunction> = TTuple<T['parameters']>
 // --------------------------------------------------------------------------
-// Pick
+// TPartial
 // --------------------------------------------------------------------------
-
-// export interface TPick<T extends TObject, Properties extends ObjectPropertyKeys<T>[]> extends TObject, ObjectOptions {
-//   static: Pick<Static<T, this['params']>, Properties[number]>
-//   properties: ObjectProperties<T>
-// }
-
-export type TPick<T extends TObject, Properties extends ObjectPropertyKeys<T>[]> = TObject<{
-  [K in Properties[number]]: T['properties'][K]
-}>
-
+export type TPartialArray<T extends TSchema[]> = Assert<{ [K in keyof T]: TPartial<Assert<T[K], TSchema>> }, TSchema[]>
+// prettier-ignore
+export type TPartialProperties<T extends TProperties> = Evaluate<Assert<{
+  [K in keyof T]: 
+    T[K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : 
+    T[K] extends TReadonly<infer U>         ? TReadonlyOptional<U> : 
+    T[K] extends TOptional<infer U>         ? TOptional<U>         : 
+    TOptional<T[K]>
+}, TProperties>>
+// prettier-ignore
+export type TPartial<T extends TSchema> = 
+  T extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : 
+  T extends TUnion<infer S>     ? TUnion<TPartialArray<S>> : 
+  T extends TObject<infer S>    ? TObject<TPartialProperties<S>> : 
+  T
 // --------------------------------------------------------------------------
-// Promise
+// TPick
 // --------------------------------------------------------------------------
+export type TPickArray<T extends TSchema[], K extends keyof any> = { [K2 in keyof T]: TPick<Assert<T[K2], TSchema>, K> }
+// Note the key K will overlap for varying TProperties gathered via recursive union and intersect traversal. Because of this,
+// we need to extract only keys assignable to T on K2. This behavior is only required for Pick only.
+// prettier-ignore
+export type TPickProperties<T extends TProperties, K extends keyof any> = 
+  Pick<T, Assert<Extract<K, keyof T>, keyof T>> extends infer R ? ({
+    [K in keyof R]: Assert<R[K], TSchema> extends TSchema ? R[K] : never
+  }): never
+// prettier-ignore
+export type TPick<T extends TSchema, K extends keyof any> = 
+  T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : 
+  T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : 
+  T extends TObject<infer S> ? TObject<TPickProperties<S, K>> :
+  T
 
+// --------------------------------------------------------------------------
+// TPromise
+// --------------------------------------------------------------------------
+export type TPromiseStatic<T extends TSchema, P extends unknown[]> = Promise<Static<T, P>>
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Promise'
-  static: Promise<Static<T, this['params']>>
+  static: TPromiseStatic<T, this['params']>
   type: 'object'
   instanceOf: 'Promise'
   item: TSchema
 }
-
 // --------------------------------------------------------------------------
-// Record
+// TRecord
 // --------------------------------------------------------------------------
-
 export type TRecordKey = TString | TNumeric | TUnion<TLiteral<any>[]>
-
+export type TRecordPropertiesFromUnionLiteral<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema> = Static<K> extends string ? { [X in Static<K>]: T } : never
+export type TRecordPropertiesFromLiteral<K extends TLiteral<string | number>, T extends TSchema> = Evaluate<{ [K2 in K['const']]: T }>
+export type TRecordStatic<K extends TRecordKey, T extends TSchema, P extends unknown[]> = Record<Static<K>, Static<T, P>>
 export interface TRecord<K extends TRecordKey = TRecordKey, T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Record'
-  static: Record<Static<K>, Static<T, this['params']>>
+  static: TRecordStatic<K, T, this['params']>
   type: 'object'
   patternProperties: { [pattern: string]: T }
   additionalProperties: false
 }
-
 // --------------------------------------------------------------------------
-// Recursive
+// TRecursive
 // --------------------------------------------------------------------------
-
 export interface TSelf extends TSchema {
   [Kind]: 'Self'
   static: this['params'][0]
   $ref: string
 }
-
 export type TRecursiveReduce<T extends TSchema> = Static<T, [TRecursiveReduce<T>]>
-
 export interface TRecursive<T extends TSchema> extends TSchema {
   static: TRecursiveReduce<T>
 }
-
 // --------------------------------------------------------------------------
-// Ref
+// TRef
 // --------------------------------------------------------------------------
-
+export type TRefStatic<T extends TSchema, P extends unknown[]> = Static<T, P>
 export interface TRef<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Ref'
-  static: Static<T, this['params']>
+  static: TRefStatic<T, this['params']>
   $ref: string
 }
-
 // --------------------------------------------------------------------------
-// Required
+// TReturnType
 // --------------------------------------------------------------------------
-
-export interface TRequired<T extends TObject | TRef<TObject>> extends TObject {
-  static: Required<Static<T, this['params']>>
-  properties: {
-    // prettier-ignore
-    [K in keyof T['properties']]: 
-      T['properties'][K] extends TReadonlyOptional<infer U> ? TReadonly<U> :  
-      T['properties'][K] extends TReadonly<infer U>         ? TReadonly<U> :
-      T['properties'][K] extends TOptional<infer U>         ? U :  
-      T['properties'][K]
-  }
-}
-
+export type TReturnType<T extends TFunction> = T['returns']
 // --------------------------------------------------------------------------
-// String
+// TRequired
+// --------------------------------------------------------------------------
+export type TRequiredArray<T extends TSchema[]> = Assert<{ [K in keyof T]: TRequired<Assert<T[K], TSchema>> }, TSchema[]>
+// prettier-ignore
+export type TRequiredProperties<T extends TProperties> = Evaluate<Assert<{
+  [K in keyof T]: 
+    T[K] extends TReadonlyOptional<infer U> ? TReadonly<U> : 
+    T[K] extends TReadonly<infer U>         ? TReadonly<U> :  
+    T[K] extends TOptional<infer U>         ? U : 
+    T[K]
+}, TProperties>>
+// prettier-ignore
+export type TRequired<T extends TSchema> = 
+  T extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : 
+  T extends TUnion<infer S>     ? TUnion<TRequiredArray<S>> : 
+  T extends TObject<infer S>    ? TObject<TRequiredProperties<S>> : 
+  T
+// --------------------------------------------------------------------------
+// TString
 // --------------------------------------------------------------------------
-
 export type StringFormatOption =
   | 'date-time'
   | 'time'
@@ -483,7 +515,6 @@ export type StringFormatOption =
   | 'json-pointer'
   | 'relative-json-pointer'
   | 'regex'
-
 export interface StringOptions<Format extends string> extends SchemaOptions {
   minLength?: number
   maxLength?: number
@@ -492,529 +523,1689 @@ export interface StringOptions<Format extends string> extends SchemaOptions {
   contentEncoding?: '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64'
   contentMediaType?: string
 }
-
 export interface TString<Format extends string = string> extends TSchema, StringOptions<Format> {
   [Kind]: 'String'
   static: string
   type: 'string'
 }
-
 // --------------------------------------------------------------------------
-// Tuple
+// TSymbol
 // --------------------------------------------------------------------------
-
-export type TupleToArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? R : never
-
+export type SymbolValue = string | number | undefined
+export interface TSymbol extends TSchema, SchemaOptions {
+  [Kind]: 'Symbol'
+  static: symbol
+  type: 'null'
+  typeOf: 'Symbol'
+}
+// --------------------------------------------------------------------------
+// TTuple
+// --------------------------------------------------------------------------
+export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? Assert<R, TSchema[]> : never
+export type TTupleStatic<T extends TSchema[], P extends unknown[]> = {
+  [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : T[K]
+}
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
   [Kind]: 'Tuple'
-  static: { [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : T[K] }
+  static: TTupleStatic<T, this['params']>
   type: 'array'
   items?: T
   additionalItems?: false
   minItems: number
   maxItems: number
 }
-
 // --------------------------------------------------------------------------
-// Undefined
+// TUndefined
 // --------------------------------------------------------------------------
-
 export interface TUndefined extends TSchema {
   [Kind]: 'Undefined'
   static: undefined
   type: 'null'
   typeOf: 'Undefined'
 }
-
 // --------------------------------------------------------------------------
-// Union
+// TUnionOfLiteral
+// --------------------------------------------------------------------------
+export type TUnionOfLiteralArray<T extends TLiteral<string>[]> = { [K in keyof T]: Assert<T[K], TLiteral>['const'] }[number]
+export type TUnionOfLiteral<T extends TUnion<TLiteral<string>[]>> = TUnionOfLiteralArray<T['anyOf']>
+// --------------------------------------------------------------------------
+// TUnionResult - Used by Extract, Exclude and KeyOf for normalized union unwrap
+// --------------------------------------------------------------------------
+export type TUnionResult<T extends TSchema[]> = T extends [] ? TNever : T extends [infer S] ? S : TUnion<T>
+// --------------------------------------------------------------------------
+// TUnion
 // --------------------------------------------------------------------------
-
 export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
   [Kind]: 'Union'
   static: { [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : never }[number]
   anyOf: T
 }
-
-// -------------------------------------------------------------------------
-// Uint8Array
-// -------------------------------------------------------------------------
-
+// --------------------------------------------------------------------------
+// TUint8Array
+// --------------------------------------------------------------------------
 export interface Uint8ArrayOptions extends SchemaOptions {
   maxByteLength?: number
   minByteLength?: number
 }
-
 export interface TUint8Array extends TSchema, Uint8ArrayOptions {
   [Kind]: 'Uint8Array'
   static: Uint8Array
   instanceOf: 'Uint8Array'
   type: 'object'
 }
-
 // --------------------------------------------------------------------------
-// Unknown
+// TUnknown
 // --------------------------------------------------------------------------
-
 export interface TUnknown extends TSchema {
   [Kind]: 'Unknown'
   static: unknown
 }
-
 // --------------------------------------------------------------------------
-// Unsafe
+// TUnsafe
 // --------------------------------------------------------------------------
-
 export interface UnsafeOptions extends SchemaOptions {
   [Kind]?: string
 }
-
 export interface TUnsafe<T> extends TSchema {
   [Kind]: string
   static: T
 }
-
 // --------------------------------------------------------------------------
-// Void
+// TVoid
 // --------------------------------------------------------------------------
-
 export interface TVoid extends TSchema {
   [Kind]: 'Void'
   static: void
   type: 'null'
   typeOf: 'Void'
 }
-
 // --------------------------------------------------------------------------
 // Static<T>
 // --------------------------------------------------------------------------
-
-/** Creates a static type from a TypeBox type */
+/** Creates a TypeScript static type from a TypeBox type */
 export type Static<T extends TSchema, P extends unknown[] = []> = (T & { params: P })['static']
 
 // --------------------------------------------------------------------------
-// TypeBuilder
+// TypeRegistry
 // --------------------------------------------------------------------------
-
-let TypeOrdinal = 0
-
-export class TypeBuilder {
-  // ----------------------------------------------------------------------
-  // Modifiers
-  // ----------------------------------------------------------------------
-
-  /** Creates a readonly optional property */
-  public ReadonlyOptional<T extends TSchema>(item: T): TReadonlyOptional<T> {
-    return { [Modifier]: 'ReadonlyOptional', ...item }
+export type TypeRegistryValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean
+/** A registry for user defined types */
+export namespace TypeRegistry {
+  const map = new Map<string, TypeRegistryValidationFunction<any>>()
+  /** Returns the entries in this registry */
+  export function Entries() {
+    return new Map(map)
   }
-
-  /** Creates a readonly property */
-  public Readonly<T extends TSchema>(item: T): TReadonly<T> {
-    return { [Modifier]: 'Readonly', ...item }
+  /** Clears all user defined types */
+  export function Clear() {
+    return map.clear()
   }
-
-  /** Creates a optional property */
-  public Optional<T extends TSchema>(item: T): TOptional<T> {
-    return { [Modifier]: 'Optional', ...item }
+  /** Returns true if this registry contains this kind */
+  export function Has(kind: string) {
+    return map.has(kind)
   }
-
-  // ----------------------------------------------------------------------
-  // Types
-  // ----------------------------------------------------------------------
-
-  /** `Standard` Creates a any type */
-  public Any(options: SchemaOptions = {}): TAny {
-    return this.Create({ ...options, [Kind]: 'Any' })
+  /** Sets a validation function for a user defined type */
+  export function Set<TSchema = unknown>(kind: string, func: TypeRegistryValidationFunction<TSchema>) {
+    map.set(kind, func)
   }
-
-  /** `Standard` Creates a array type */
-  public Array<T extends TSchema>(items: T, options: ArrayOptions = {}): TArray<T> {
-    return this.Create({ ...options, [Kind]: 'Array', type: 'array', items })
+  /** Gets a custom validation function for a user defined type */
+  export function Get(kind: string) {
+    return map.get(kind)
   }
-
-  /** `Standard` Creates a boolean type */
-  public Boolean(options: SchemaOptions = {}): TBoolean {
-    return this.Create({ ...options, [Kind]: 'Boolean', type: 'boolean' })
+}
+// --------------------------------------------------------------------------
+// TypeRegistry
+// --------------------------------------------------------------------------
+export type FormatRegistryValidationFunction = (value: string) => boolean
+/** A registry for user defined string formats */
+export namespace FormatRegistry {
+  const map = new Map<string, FormatRegistryValidationFunction>()
+  /** Returns the entries in this registry */
+  export function Entries() {
+    return new Map(map)
   }
-
-  /** `Extended` Creates a tuple type from this constructors parameters */
-  public ConstructorParameters<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TConstructorParameters<T> {
-    return this.Tuple([...schema.parameters], { ...options })
+  /** Clears all user defined string formats */
+  export function Clear() {
+    return map.clear()
   }
-
-  /** `Extended` Creates a constructor type */
-  public Constructor<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TConstructor<TupleToArray<T>, U>
-
-  /** `Extended` Creates a constructor type */
-  public Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>
-
-  /** `Extended` Creates a constructor type */
-  public Constructor(parameters: any, returns: any, options: SchemaOptions = {}) {
-    if (parameters[Kind] === 'Tuple') {
-      const inner = parameters.items === undefined ? [] : parameters.items
-      return this.Create({ ...options, [Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: inner, returns })
-    } else if (globalThis.Array.isArray(parameters)) {
-      return this.Create({ ...options, [Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters, returns })
-    } else {
-      throw new Error('TypeBuilder.Constructor: Invalid parameters')
-    }
+  /** Returns true if the user defined string format exists */
+  export function Has(format: string) {
+    return map.has(format)
   }
-
-  /** `Extended` Creates a Date type */
-  public Date(options: DateOptions = {}): TDate {
-    return this.Create({ ...options, [Kind]: 'Date', type: 'object', instanceOf: 'Date' })
+  /** Sets a validation function for a user defined string format */
+  export function Set(format: string, func: FormatRegistryValidationFunction) {
+    map.set(format, func)
   }
-
-  /** `Standard` Creates a enum type */
-  public Enum<T extends Record<string, string | number>>(item: T, options: SchemaOptions = {}): TEnum<T> {
-    const values = Object.keys(item)
-      .filter((key) => isNaN(key as any))
-      .map((key) => item[key]) as T[keyof T][]
-    const anyOf = values.map((value) => (typeof value === 'string' ? { [Kind]: 'Literal', type: 'string' as const, const: value } : { [Kind]: 'Literal', type: 'number' as const, const: value }))
-    return this.Create({ ...options, [Kind]: 'Union', [Hint]: 'Enum', anyOf })
+  /** Gets a validation function for a user defined string format */
+  export function Get(format: string) {
+    return map.get(format)
   }
-
-  /** `Extended` Creates a function type */
-  public Function<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TFunction<TupleToArray<T>, U>
-
-  /** `Extended` Creates a function type */
-  public Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>
-
-  /** `Extended` Creates a function type */
-  public Function(parameters: any, returns: any, options: SchemaOptions = {}) {
-    if (parameters[Kind] === 'Tuple') {
-      const inner = parameters.items === undefined ? [] : parameters.items
-      return this.Create({ ...options, [Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: inner, returns })
-    } else if (globalThis.Array.isArray(parameters)) {
-      return this.Create({ ...options, [Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters, returns })
-    } else {
-      throw new Error('TypeBuilder.Function: Invalid parameters')
-    }
+}
+// --------------------------------------------------------------------------
+// TypeGuard
+// --------------------------------------------------------------------------
+export class TypeGuardUnknownTypeError extends Error {
+  constructor(public readonly schema: unknown) {
+    super('TypeGuard: Unknown type')
   }
-
-  /** `Extended` Creates a type from this constructors instance type */
-  public InstanceType<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TInstanceType<T> {
-    return { ...options, ...this.Clone(schema.returns) }
+}
+/** Provides functions to test if JavaScript values are TypeBox types */
+export namespace TypeGuard {
+  function IsObject(value: unknown): value is Record<string | symbol, any> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
   }
-
-  /** `Standard` Creates a integer type */
-  public Integer(options: NumericOptions = {}): TInteger {
-    return this.Create({ ...options, [Kind]: 'Integer', type: 'integer' })
+  function IsArray(value: unknown): value is any[] {
+    return typeof value === 'object' && value !== null && Array.isArray(value)
   }
-
-  /** `Standard` Creates a intersect type. */
-  public Intersect<T extends TObject[]>(objects: [...T], options: ObjectOptions = {}): TIntersect<T> {
-    const isOptional = (schema: TSchema) => (schema[Modifier] && schema[Modifier] === 'Optional') || schema[Modifier] === 'ReadonlyOptional'
-    const [required, optional] = [new Set<string>(), new Set<string>()]
-    for (const object of objects) {
-      for (const [key, schema] of Object.entries(object.properties)) {
-        if (isOptional(schema)) optional.add(key)
-      }
-    }
-    for (const object of objects) {
-      for (const key of Object.keys(object.properties)) {
-        if (!optional.has(key)) required.add(key)
-      }
+  function IsPattern(value: unknown): value is string {
+    try {
+      new RegExp(value as string)
+      return true
+    } catch {
+      return false
     }
-    const properties = {} as Record<string, any>
-    for (const object of objects) {
-      for (const [key, schema] of Object.entries(object.properties)) {
-        properties[key] = properties[key] === undefined ? schema : { [Kind]: 'Union', anyOf: [properties[key], { ...schema }] }
+  }
+  function IsControlCharacterFree(value: unknown): value is string {
+    if (typeof value !== 'string') return false
+    for (let i = 0; i < value.length; i++) {
+      const code = value.charCodeAt(i)
+      if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
+        return false
       }
     }
-    if (required.size > 0) {
-      return this.Create({ ...options, [Kind]: 'Object', type: 'object', properties, required: [...required] })
-    } else {
-      return this.Create({ ...options, [Kind]: 'Object', type: 'object', properties })
-    }
+    return true
   }
-
-  /** `Standard` Creates a keyof type */
-  public KeyOf<T extends TObject>(object: T, options: SchemaOptions = {}): TKeyOf<T> {
-    const items = Object.keys(object.properties).map((key) => this.Create({ ...options, [Kind]: 'Literal', type: 'string', const: key }))
-    return this.Create({ ...options, [Kind]: 'Union', [Hint]: 'KeyOf', anyOf: items })
+  function IsBigInt(value: unknown): value is bigint {
+    return typeof value === 'bigint'
   }
-
-  /** `Standard` Creates a literal type. */
-  public Literal<T extends TLiteralValue>(value: T, options: SchemaOptions = {}): TLiteral<T> {
-    return this.Create({ ...options, [Kind]: 'Literal', const: value, type: typeof value as 'string' | 'number' | 'boolean' })
+  function IsString(value: unknown): value is string {
+    return typeof value === 'string'
   }
-
-  /** `Standard` Creates a never type */
-  public Never(options: SchemaOptions = {}): TNever {
-    return this.Create({
-      ...options,
-      [Kind]: 'Never',
-      allOf: [
-        { type: 'boolean', const: false },
-        { type: 'boolean', const: true },
-      ],
-    })
+  function IsNumber(value: unknown): value is number {
+    return typeof value === 'number' && globalThis.Number.isFinite(value)
   }
-
-  /** `Standard` Creates a null type */
-  public Null(options: SchemaOptions = {}): TNull {
-    return this.Create({ ...options, [Kind]: 'Null', type: 'null' })
+  function IsBoolean(value: unknown): value is boolean {
+    return typeof value === 'boolean'
   }
-
-  /** `Standard` Creates a number type */
-  public Number(options: NumericOptions = {}): TNumber {
-    return this.Create({ ...options, [Kind]: 'Number', type: 'number' })
+  function IsOptionalBigInt(value: unknown): value is bigint | undefined {
+    return value === undefined || (value !== undefined && IsBigInt(value))
   }
-
-  /** `Standard` Creates an object type */
-  public Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
-    const property_names = Object.keys(properties)
-    const optional = property_names.filter((name) => {
-      const property = properties[name] as TModifier
-      const modifier = property[Modifier]
-      return modifier && (modifier === 'Optional' || modifier === 'ReadonlyOptional')
-    })
-    const required = property_names.filter((name) => !optional.includes(name))
-    if (required.length > 0) {
-      return this.Create({ ...options, [Kind]: 'Object', type: 'object', properties, required })
-    } else {
-      return this.Create({ ...options, [Kind]: 'Object', type: 'object', properties })
+  function IsOptionalNumber(value: unknown): value is number | undefined {
+    return value === undefined || (value !== undefined && IsNumber(value))
+  }
+  function IsOptionalBoolean(value: unknown): value is boolean | undefined {
+    return value === undefined || (value !== undefined && IsBoolean(value))
+  }
+  function IsOptionalString(value: unknown): value is string | undefined {
+    return value === undefined || (value !== undefined && IsString(value))
+  }
+  function IsOptionalPattern(value: unknown): value is string | undefined {
+    return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value) && IsPattern(value))
+  }
+  function IsOptionalFormat(value: unknown): value is string | undefined {
+    return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value))
+  }
+  function IsOptionalSchema(value: unknown): value is boolean | undefined {
+    return value === undefined || TSchema(value)
+  }
+  /** Returns true if the given schema is TAny */
+  export function TAny(schema: unknown): schema is TAny {
+    return TKind(schema) && schema[Kind] === 'Any' && IsOptionalString(schema.$id)
+  }
+  /** Returns true if the given schema is TArray */
+  export function TArray(schema: unknown): schema is TArray {
+    return (
+      TKind(schema) &&
+      schema[Kind] === 'Array' &&
+      schema.type === 'array' &&
+      IsOptionalString(schema.$id) &&
+      TSchema(schema.items) &&
+      IsOptionalNumber(schema.minItems) &&
+      IsOptionalNumber(schema.maxItems) &&
+      IsOptionalBoolean(schema.uniqueItems)
+    )
+  }
+  /** Returns true if the given schema is TSymbol */
+  export function TBigInt(schema: unknown): schema is TBigInt {
+    // prettier-ignore
+    return (
+      TKind(schema) && 
+      schema[Kind] === 'BigInt' && 
+      schema.type === 'null' &&
+      schema.typeOf === 'BigInt' &&
+      IsOptionalString(schema.$id) &&
+      IsOptionalBigInt(schema.multipleOf) &&
+      IsOptionalBigInt(schema.minimum) &&
+      IsOptionalBigInt(schema.maximum) &&
+      IsOptionalBigInt(schema.exclusiveMinimum) &&
+      IsOptionalBigInt(schema.exclusiveMaximum)
+    )
+  }
+  /** Returns true if the given schema is TBoolean */
+  export function TBoolean(schema: unknown): schema is TBoolean {
+    // prettier-ignore
+    return (
+      TKind(schema) &&
+      schema[Kind] === 'Boolean' && 
+      schema.type === 'boolean' && 
+      IsOptionalString(schema.$id)
+    )
+  }
+  /** Returns true if the given schema is TConstructor */
+  export function TConstructor(schema: unknown): schema is TConstructor {
+    // prettier-ignore
+    if (!(
+      TKind(schema) &&
+      schema[Kind] === 'Constructor' && 
+      schema.type === 'object' && 
+      schema.instanceOf === 'Constructor' && 
+      IsOptionalString(schema.$id) && 
+      IsArray(schema.parameters) && 
+      TSchema(schema.returns))
+    ) {
+      return false
+    }
+    for (const parameter of schema.parameters) {
+      if (!TSchema(parameter)) return false
     }
+    return true
+  }
+  /** Returns true if the given schema is TDate */
+  export function TDate(schema: unknown): schema is TDate {
+    return (
+      TKind(schema) &&
+      schema[Kind] === 'Date' &&
+      schema.type === 'object' &&
+      schema.instanceOf === 'Date' &&
+      IsOptionalString(schema.$id) &&
+      IsOptionalNumber(schema.minimumTimestamp) &&
+      IsOptionalNumber(schema.maximumTimestamp) &&
+      IsOptionalNumber(schema.exclusiveMinimumTimestamp) &&
+      IsOptionalNumber(schema.exclusiveMaximumTimestamp)
+    )
+  }
+  /** Returns true if the given schema is TFunction */
+  export function TFunction(schema: unknown): schema is TFunction {
+    // prettier-ignore
+    if (!(
+      TKind(schema) &&
+      schema[Kind] === 'Function' && 
+      schema.type === 'object' &&
+      schema.instanceOf === 'Function' &&
+      IsOptionalString(schema.$id) && 
+      IsArray(schema.parameters) && 
+      TSchema(schema.returns))
+    ) {
+      return false
+    }
+    for (const parameter of schema.parameters) {
+      if (!TSchema(parameter)) return false
+    }
+    return true
+  }
+  /** Returns true if the given schema is TInteger */
+  export function TInteger(schema: unknown): schema is TInteger {
+    return (
+      TKind(schema) &&
+      schema[Kind] === 'Integer' &&
+      schema.type === 'integer' &&
+      IsOptionalString(schema.$id) &&
+      IsOptionalNumber(schema.multipleOf) &&
+      IsOptionalNumber(schema.minimum) &&
+      IsOptionalNumber(schema.maximum) &&
+      IsOptionalNumber(schema.exclusiveMinimum) &&
+      IsOptionalNumber(schema.exclusiveMaximum)
+    )
+  }
+  /** Returns true if the given schema is TIntersect */
+  export function TIntersect(schema: unknown): schema is TIntersect {
+    // prettier-ignore
+    if (!(
+      TKind(schema) &&
+      schema[Kind] === 'Intersect' && 
+      IsArray(schema.allOf) && 
+      IsOptionalString(schema.type) &&
+      (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) &&
+      IsOptionalString(schema.$id))
+    ) {
+      return false
+    }
+    if ('type' in schema && schema.type !== 'object') {
+      return false
+    }
+    for (const inner of schema.allOf) {
+      if (!TSchema(inner)) return false
+    }
+    return true
+  }
+  /** Returns true if the given schema is TKind */
+  export function TKind(schema: unknown): schema is Record<typeof Kind | string, unknown> {
+    return IsObject(schema) && Kind in schema && typeof (schema as any)[Kind] === 'string' // TS 4.1.5: any required for symbol indexer
+  }
+  /** Returns true if the given schema is TLiteral */
+  export function TLiteral(schema: unknown): schema is TLiteral {
+    // prettier-ignore
+    return (
+      TKind(schema) &&
+      schema[Kind] === 'Literal' && 
+      IsOptionalString(schema.$id) && 
+      (
+        IsString(schema.const) || 
+        IsNumber(schema.const) || 
+        IsBoolean(schema.const) ||
+        IsBigInt(schema.const)
+      )
+    )
+  }
+  /** Returns true if the given schema is TNever */
+  export function TNever(schema: unknown): schema is TNever {
+    return TKind(schema) && schema[Kind] === 'Never' && IsObject(schema.not) && globalThis.Object.getOwnPropertyNames(schema.not).length === 0
+  }
+  /** Returns true if the given schema is TNot */
+  export function TNot(schema: unknown): schema is TNot {
+    // prettier-ignore
+    return (
+      TKind(schema) && 
+      schema[Kind] === 'Not' && 
+      IsArray(schema.allOf) && 
+      schema.allOf.length === 2 && 
+      IsObject(schema.allOf[0]) && 
+      TSchema(schema.allOf[0].not) && 
+      TSchema(schema.allOf[1]) 
+    )
+  }
+  /** Returns true if the given schema is TNull */
+  export function TNull(schema: unknown): schema is TNull {
+    // prettier-ignore
+    return (
+      TKind(schema) && 
+      schema[Kind] === 'Null' && 
+      schema.type === 'null' && 
+      IsOptionalString(schema.$id)
+    )
+  }
+  /** Returns true if the given schema is TNumber */
+  export function TNumber(schema: unknown): schema is TNumber {
+    return (
+      TKind(schema) &&
+      schema[Kind] === 'Number' &&
+      schema.type === 'number' &&
+      IsOptionalString(schema.$id) &&
+      IsOptionalNumber(schema.multipleOf) &&
+      IsOptionalNumber(schema.minimum) &&
+      IsOptionalNumber(schema.maximum) &&
+      IsOptionalNumber(schema.exclusiveMinimum) &&
+      IsOptionalNumber(schema.exclusiveMaximum)
+    )
+  }
+  /** Returns true if the given schema is TObject */
+  export function TObject(schema: unknown): schema is TObject {
+    if (
+      !(
+        TKind(schema) &&
+        schema[Kind] === 'Object' &&
+        schema.type === 'object' &&
+        IsOptionalString(schema.$id) &&
+        IsObject(schema.properties) &&
+        (IsOptionalBoolean(schema.additionalProperties) || IsOptionalSchema(schema.additionalProperties)) &&
+        IsOptionalNumber(schema.minProperties) &&
+        IsOptionalNumber(schema.maxProperties)
+      )
+    ) {
+      return false
+    }
+    for (const [key, value] of Object.entries(schema.properties)) {
+      if (!IsControlCharacterFree(key)) return false
+      if (!TSchema(value)) return false
+    }
+    return true
+  }
+  /** Returns true if the given schema is TPromise */
+  export function TPromise(schema: unknown): schema is TPromise {
+    // prettier-ignore
+    return (
+      TKind(schema) && 
+      schema[Kind] === 'Promise' && 
+      schema.type === 'object' && 
+      schema.instanceOf === 'Promise' &&
+      IsOptionalString(schema.$id) && 
+      TSchema(schema.item)
+    )
+  }
+  /** Returns true if the given schema is TRecord */
+  export function TRecord(schema: unknown): schema is TRecord {
+    // prettier-ignore
+    if (!(
+      TKind(schema) && 
+      schema[Kind] === 'Record' && 
+      schema.type === 'object' && 
+      IsOptionalString(schema.$id) && 
+      schema.additionalProperties === false && 
+      IsObject(schema.patternProperties))
+    ) {
+      return false
+    }
+    const keys = Object.keys(schema.patternProperties)
+    if (keys.length !== 1) {
+      return false
+    }
+    if (!IsPattern(keys[0])) {
+      return false
+    }
+    if (!TSchema(schema.patternProperties[keys[0]])) {
+      return false
+    }
+    return true
+  }
+  /** Returns true if the given schema is TSelf */
+  export function TSelf(schema: unknown): schema is TSelf {
+    // prettier-ignore
+    return (
+      TKind(schema) && 
+      schema[Kind] === 'Self' && 
+      IsOptionalString(schema.$id) && 
+      IsString(schema.$ref)
+    )
+  }
+  /** Returns true if the given schema is TRef */
+  export function TRef(schema: unknown): schema is TRef {
+    // prettier-ignore
+    return (
+      TKind(schema) && 
+      schema[Kind] === 'Ref' && 
+      IsOptionalString(schema.$id) && 
+      IsString(schema.$ref)
+    )
+  }
+  /** Returns true if the given schema is TString */
+  export function TString(schema: unknown): schema is TString {
+    return (
+      TKind(schema) &&
+      schema[Kind] === 'String' &&
+      schema.type === 'string' &&
+      IsOptionalString(schema.$id) &&
+      IsOptionalNumber(schema.minLength) &&
+      IsOptionalNumber(schema.maxLength) &&
+      IsOptionalPattern(schema.pattern) &&
+      IsOptionalFormat(schema.format)
+    )
   }
 
-  /** `Standard` Creates a new object type whose keys are omitted from the given source type */
-  public Omit<T extends TObject, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: ObjectOptions): TOmit<T, UnionStringLiteralToTuple<K>>
-
-  /** `Standard` Creates a new object type whose keys are omitted from the given source type */
-  public Omit<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: T, keys: readonly [...K], options?: ObjectOptions): TOmit<T, K>
+  /** Returns true if the given schema is TSymbol */
+  export function TSymbol(schema: unknown): schema is TSymbol {
+    // prettier-ignore
+    return (
+      TKind(schema) && 
+      schema[Kind] === 'Symbol' && 
+      schema.type === 'null' &&
+      schema.typeOf === 'Symbol' &&
+      IsOptionalString(schema.$id)
+    )
+  }
 
-  /** `Standard` Creates a new object type whose keys are omitted from the given source type */
-  public Omit(schema: any, keys: any, options: ObjectOptions = {}) {
-    const select: readonly string[] = keys[Kind] === 'Union' ? keys.anyOf.map((schema: TLiteral) => schema.const) : keys
-    const next = { ...this.Clone(schema), ...options, [Hint]: 'Omit' }
-    if (next.required) {
-      next.required = next.required.filter((key: string) => !select.includes(key as any))
-      if (next.required.length === 0) delete next.required
+  /** Returns true if the given schema is TTuple */
+  export function TTuple(schema: unknown): schema is TTuple {
+    // prettier-ignore
+    if (!(
+      TKind(schema) && 
+      schema[Kind] === 'Tuple' && 
+      schema.type === 'array' && 
+      IsOptionalString(schema.$id) && 
+      IsNumber(schema.minItems) && 
+      IsNumber(schema.maxItems) && 
+      schema.minItems === schema.maxItems)
+    ) {
+      return false
+    }
+    if (schema.items === undefined && schema.additionalItems === undefined && schema.minItems === 0) {
+      return true
+    }
+    if (!IsArray(schema.items)) {
+      return false
     }
-    for (const key of Object.keys(next.properties)) {
-      if (select.includes(key as any)) delete next.properties[key]
+    for (const inner of schema.items) {
+      if (!TSchema(inner)) return false
     }
-    return this.Create(next)
+    return true
   }
-
-  /** `Extended` Creates a tuple type from this functions parameters */
-  public Parameters<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TParameters<T> {
-    return Type.Tuple(schema.parameters, { ...options })
+  /** Returns true if the given schema is TUndefined */
+  export function TUndefined(schema: unknown): schema is TUndefined {
+    // prettier-ignore
+    return (
+      TKind(schema) && 
+      schema[Kind] === 'Undefined' && 
+      schema.type === 'null' && 
+      schema.typeOf === 'Undefined' && 
+      IsOptionalString(schema.$id)
+    )
+  }
+  /** Returns true if the given schema is TUnion */
+  export function TUnion(schema: unknown): schema is TUnion {
+    // prettier-ignore
+    if (!(
+      TKind(schema) && 
+      schema[Kind] === 'Union' && 
+      IsArray(schema.anyOf) && 
+      IsOptionalString(schema.$id))
+    ) {
+      return false
+    }
+    for (const inner of schema.anyOf) {
+      if (!TSchema(inner)) return false
+    }
+    return true
+  }
+  /** Returns true if the given schema is TUnion<Literal<string>[]> */
+  export function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral<string>[]> {
+    return TUnion(schema) && schema.anyOf.every((schema) => TLiteral(schema) && typeof schema.const === 'string')
   }
 
-  /** `Standard` Creates an object type whose properties are all optional */
-  public Partial<T extends TObject>(schema: T, options: ObjectOptions = {}): TPartial<T> {
-    const next = { ...this.Clone(schema), ...options, [Hint]: 'Partial' }
-    delete next.required
-    for (const key of Object.keys(next.properties)) {
-      const property = next.properties[key]
-      const modifer = property[Modifier]
-      switch (modifer) {
-        case 'ReadonlyOptional':
-          property[Modifier] = 'ReadonlyOptional'
-          break
-        case 'Readonly':
-          property[Modifier] = 'ReadonlyOptional'
-          break
-        case 'Optional':
-          property[Modifier] = 'Optional'
-          break
-        default:
-          property[Modifier] = 'Optional'
-          break
+  /** Returns true if the given schema is TUint8Array */
+  export function TUint8Array(schema: unknown): schema is TUint8Array {
+    return TKind(schema) && schema[Kind] === 'Uint8Array' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.instanceOf === 'Uint8Array' && IsOptionalNumber(schema.minByteLength) && IsOptionalNumber(schema.maxByteLength)
+  }
+  /** Returns true if the given schema is TUnknown */
+  export function TUnknown(schema: unknown): schema is TUnknown {
+    // prettier-ignore
+    return (
+      TKind(schema) && 
+      schema[Kind] === 'Unknown' && 
+      IsOptionalString(schema.$id)
+    )
+  }
+  /** Returns true if the given schema is TVoid */
+  export function TVoid(schema: unknown): schema is TVoid {
+    // prettier-ignore
+    return (
+      TKind(schema) && 
+      schema[Kind] === 'Void' && 
+      schema.type === 'null' && 
+      schema.typeOf === 'Void' && 
+      IsOptionalString(schema.$id)
+    )
+  }
+  /** Returns true if this schema has the ReadonlyOptional modifier */
+  export function TReadonlyOptional<T extends TSchema>(schema: T): schema is TReadonlyOptional<T> {
+    return IsObject(schema) && schema[Modifier] === 'ReadonlyOptional'
+  }
+  /** Returns true if this schema has the Readonly modifier */
+  export function TReadonly<T extends TSchema>(schema: T): schema is TReadonly<T> {
+    return IsObject(schema) && schema[Modifier] === 'Readonly'
+  }
+  /** Returns true if this schema has the Optional modifier */
+  export function TOptional<T extends TSchema>(schema: T): schema is TOptional<T> {
+    return IsObject(schema) && schema[Modifier] === 'Optional'
+  }
+  /** Returns true if the given schema is TSchema */
+  export function TSchema(schema: unknown): schema is TSchema {
+    return (
+      typeof schema === 'object' &&
+      (TAny(schema) ||
+        TArray(schema) ||
+        TBoolean(schema) ||
+        TBigInt(schema) ||
+        TConstructor(schema) ||
+        TDate(schema) ||
+        TFunction(schema) ||
+        TInteger(schema) ||
+        TIntersect(schema) ||
+        TLiteral(schema) ||
+        TNever(schema) ||
+        TNot(schema) ||
+        TNull(schema) ||
+        TNumber(schema) ||
+        TObject(schema) ||
+        TPromise(schema) ||
+        TRecord(schema) ||
+        TSelf(schema) ||
+        TRef(schema) ||
+        TString(schema) ||
+        TSymbol(schema) ||
+        TTuple(schema) ||
+        TUndefined(schema) ||
+        TUnion(schema) ||
+        TUint8Array(schema) ||
+        TUnknown(schema) ||
+        TVoid(schema) ||
+        (TKind(schema) && TypeRegistry.Has(schema[Kind] as any)))
+    )
+  }
+}
+// --------------------------------------------------------------------------
+// ExtendsUndefined
+// --------------------------------------------------------------------------
+/** Fast undefined check used for properties of type undefined */
+export namespace ExtendsUndefined {
+  export function Check(schema: TSchema): boolean {
+    if (schema[Kind] === 'Undefined') return true
+    if (schema[Kind] === 'Union') {
+      const union = schema as TUnion
+      return union.anyOf.some((schema) => Check(schema))
+    }
+    return false
+  }
+}
+// --------------------------------------------------------------------------
+// TypeExtends
+// --------------------------------------------------------------------------
+export enum TypeExtendsResult {
+  Union,
+  True,
+  False,
+}
+export namespace TypeExtends {
+  // --------------------------------------------------------------------------
+  // IntoBooleanResult
+  // --------------------------------------------------------------------------
+  function IntoBooleanResult(result: TypeExtendsResult) {
+    return result === TypeExtendsResult.False ? TypeExtendsResult.False : TypeExtendsResult.True
+  }
+  // --------------------------------------------------------------------------
+  // Any
+  // --------------------------------------------------------------------------
+  function AnyRight(left: TSchema, right: TAny) {
+    return TypeExtendsResult.True
+  }
+  function Any(left: TAny, right: TSchema) {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right) && right.anyOf.some((schema) => TypeGuard.TAny(schema) || TypeGuard.TUnknown(schema))) return TypeExtendsResult.True
+    if (TypeGuard.TUnion(right)) return TypeExtendsResult.Union
+    if (TypeGuard.TUnknown(right)) return TypeExtendsResult.True
+    if (TypeGuard.TAny(right)) return TypeExtendsResult.True
+    return TypeExtendsResult.Union
+  }
+  // --------------------------------------------------------------------------
+  // Array
+  // --------------------------------------------------------------------------
+  function ArrayRight(left: TSchema, right: TArray) {
+    if (TypeGuard.TUnknown(left)) return TypeExtendsResult.False
+    if (TypeGuard.TAny(left)) return TypeExtendsResult.Union
+    if (TypeGuard.TNever(left)) return TypeExtendsResult.True
+    return TypeExtendsResult.False
+  }
+  function Array(left: TArray, right: TSchema) {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right) && IsObjectArrayLike(right)) return TypeExtendsResult.True
+    if (!TypeGuard.TArray(right)) return TypeExtendsResult.False
+    return IntoBooleanResult(Visit(left.items, right.items))
+  }
+  // --------------------------------------------------------------------------
+  // BigInt
+  // --------------------------------------------------------------------------
+  function BigInt(left: TBigInt, right: TSchema): TypeExtendsResult {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TNever(right)) return NeverRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+    return TypeGuard.TBigInt(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  // --------------------------------------------------------------------------
+  // Boolean
+  // --------------------------------------------------------------------------
+  function BooleanRight(left: TSchema, right: TBoolean) {
+    if (TypeGuard.TLiteral(left) && typeof left.const === 'boolean') return TypeExtendsResult.True
+    return TypeGuard.TBoolean(left) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  function Boolean(left: TBoolean, right: TSchema): TypeExtendsResult {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TNever(right)) return NeverRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+    return TypeGuard.TBoolean(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  // --------------------------------------------------------------------------
+  // Constructor
+  // --------------------------------------------------------------------------
+  function Constructor(left: TConstructor, right: TSchema) {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    if (!TypeGuard.TConstructor(right)) return TypeExtendsResult.False
+    if (left.parameters.length > right.parameters.length) return TypeExtendsResult.False
+    if (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) {
+      return TypeExtendsResult.False
+    }
+    return IntoBooleanResult(Visit(left.returns, right.returns))
+  }
+  // --------------------------------------------------------------------------
+  // Date
+  // --------------------------------------------------------------------------
+  function Date(left: TDate, right: TSchema) {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+    return TypeGuard.TDate(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  // --------------------------------------------------------------------------
+  // Function
+  // --------------------------------------------------------------------------
+  function Function(left: TFunction, right: TSchema) {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    if (!TypeGuard.TFunction(right)) return TypeExtendsResult.False
+    if (left.parameters.length > right.parameters.length) return TypeExtendsResult.False
+    if (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) {
+      return TypeExtendsResult.False
+    }
+    return IntoBooleanResult(Visit(left.returns, right.returns))
+  }
+  // --------------------------------------------------------------------------
+  // Integer
+  // --------------------------------------------------------------------------
+  function IntegerRight(left: TSchema, right: TInteger) {
+    if (TypeGuard.TLiteral(left) && typeof left.const === 'number') return TypeExtendsResult.True
+    return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  function Integer(left: TInteger, right: TSchema): TypeExtendsResult {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TNever(right)) return NeverRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+    return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  // --------------------------------------------------------------------------
+  // Intersect
+  // --------------------------------------------------------------------------
+  function IntersectRight(left: TSchema, right: TIntersect): TypeExtendsResult {
+    return right.allOf.every((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  function Intersect(left: TIntersect, right: TSchema) {
+    return left.allOf.some((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  // --------------------------------------------------------------------------
+  // Literal
+  // --------------------------------------------------------------------------
+  function IsLiteralString(schema: TLiteral) {
+    return typeof schema.const === 'string'
+  }
+  function IsLiteralNumber(schema: TLiteral) {
+    return typeof schema.const === 'number'
+  }
+  function IsLiteralBoolean(schema: TLiteral) {
+    return typeof schema.const === 'boolean'
+  }
+  function Literal(left: TLiteral, right: TSchema): TypeExtendsResult {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TNever(right)) return NeverRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+    if (TypeGuard.TString(right)) return StringRight(left, right)
+    if (TypeGuard.TNumber(right)) return NumberRight(left, right)
+    if (TypeGuard.TInteger(right)) return IntegerRight(left, right)
+    if (TypeGuard.TBoolean(right)) return BooleanRight(left, right)
+    return TypeGuard.TLiteral(right) && right.const === left.const ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  // --------------------------------------------------------------------------
+  // Never
+  // --------------------------------------------------------------------------
+  function NeverRight(left: TSchema, right: TNever) {
+    return TypeExtendsResult.False
+  }
+  function Never(left: TNever, right: TSchema) {
+    return TypeExtendsResult.True
+  }
+  // --------------------------------------------------------------------------
+  // Null
+  // --------------------------------------------------------------------------
+  function Null(left: TNull, right: TSchema) {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TNever(right)) return NeverRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+    return TypeGuard.TNull(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  // --------------------------------------------------------------------------
+  // Number
+  // --------------------------------------------------------------------------
+  function NumberRight(left: TSchema, right: TNumber) {
+    if (TypeGuard.TLiteral(left) && IsLiteralNumber(left)) return TypeExtendsResult.True
+    return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  function Number(left: TNumber, right: TSchema): TypeExtendsResult {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TNever(right)) return NeverRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+    return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  // --------------------------------------------------------------------------
+  // Object
+  // --------------------------------------------------------------------------
+  function IsObjectPropertyCount(schema: TObject, count: number) {
+    return globalThis.Object.keys(schema.properties).length === count
+  }
+  function IsObjectStringLike(schema: TObject) {
+    return IsObjectArrayLike(schema)
+  }
+  function IsObjectSymbolLike(schema: TObject) {
+    // prettier-ignore
+    return IsObjectPropertyCount(schema, 0) || (
+      IsObjectPropertyCount(schema, 1) && 'description' in schema.properties && TypeGuard.TUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && ((
+        TypeGuard.TString(schema.properties.description.anyOf[0]) &&
+        TypeGuard.TUndefined(schema.properties.description.anyOf[1])
+      ) || (
+        TypeGuard.TString(schema.properties.description.anyOf[1]) &&
+        TypeGuard.TUndefined(schema.properties.description.anyOf[0])
+      ))
+    )
+  }
+  function IsObjectNumberLike(schema: TObject) {
+    return IsObjectPropertyCount(schema, 0)
+  }
+  function IsObjectBooleanLike(schema: TObject) {
+    return IsObjectPropertyCount(schema, 0)
+  }
+  function IsObjectBigIntLike(schema: TObject) {
+    return IsObjectPropertyCount(schema, 0)
+  }
+  function IsObjectDateLike(schema: TObject) {
+    return IsObjectPropertyCount(schema, 0)
+  }
+  function IsObjectUint8ArrayLike(schema: TObject) {
+    return IsObjectArrayLike(schema)
+  }
+  function IsObjectFunctionLike(schema: TObject) {
+    const length = Type.Number()
+    return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'length' in schema.properties && IntoBooleanResult(Visit(schema.properties['length'], length)) === TypeExtendsResult.True)
+  }
+  function IsObjectConstructorLike(schema: TObject) {
+    return IsObjectPropertyCount(schema, 0)
+  }
+  function IsObjectArrayLike(schema: TObject) {
+    const length = Type.Number()
+    return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'length' in schema.properties && IntoBooleanResult(Visit(schema.properties['length'], length)) === TypeExtendsResult.True)
+  }
+  function IsObjectPromiseLike(schema: TObject) {
+    const then = Type.Function([Type.Any()], Type.Any())
+    return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'then' in schema.properties && IntoBooleanResult(Visit(schema.properties['then'], then)) === TypeExtendsResult.True)
+  }
+  // --------------------------------------------------------------------------
+  // Property
+  // --------------------------------------------------------------------------
+  function Property(left: TSchema, right: TSchema) {
+    if (Visit(left, right) === TypeExtendsResult.False) return TypeExtendsResult.False
+    if (TypeGuard.TOptional(left) && !TypeGuard.TOptional(right)) return TypeExtendsResult.False
+    return TypeExtendsResult.True
+  }
+  function ObjectRight(left: TSchema, right: TObject) {
+    if (TypeGuard.TUnknown(left)) return TypeExtendsResult.False
+    if (TypeGuard.TAny(left)) return TypeExtendsResult.Union
+    if (TypeGuard.TNever(left)) return TypeExtendsResult.True
+    if (TypeGuard.TLiteral(left) && IsLiteralString(left) && IsObjectStringLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TLiteral(left) && IsLiteralNumber(left) && IsObjectNumberLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TLiteral(left) && IsLiteralBoolean(left) && IsObjectBooleanLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TBigInt(left) && IsObjectBigIntLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TString(left) && IsObjectStringLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TNumber(left) && IsObjectNumberLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TInteger(left) && IsObjectNumberLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TBoolean(left) && IsObjectBooleanLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TUint8Array(left) && IsObjectUint8ArrayLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TDate(left) && IsObjectDateLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TConstructor(left) && IsObjectConstructorLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TFunction(left) && IsObjectFunctionLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TRecord(left) && TypeGuard.TString(RecordKey(left))) {
+      // When expressing a Record with literal key values, the Record is converted into a Object with
+      // the Hint assigned as `Record`. This is used to invert the extends logic.
+      return right[Hint] === 'Record' ? TypeExtendsResult.True : TypeExtendsResult.False
+    }
+    if (TypeGuard.TRecord(left) && TypeGuard.TNumber(RecordKey(left))) {
+      return IsObjectPropertyCount(right, 0) ? TypeExtendsResult.True : TypeExtendsResult.False
+    }
+    return TypeExtendsResult.False
+  }
+  function Object(left: TObject, right: TSchema) {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+    if (!TypeGuard.TObject(right)) return TypeExtendsResult.False
+    for (const key of globalThis.Object.keys(right.properties)) {
+      if (!(key in left.properties)) return TypeExtendsResult.False
+      if (Property(left.properties[key], right.properties[key]) === TypeExtendsResult.False) {
+        return TypeExtendsResult.False
       }
     }
-    return this.Create(next)
+    return TypeExtendsResult.True
   }
-
-  /** `Standard` Creates a new object type whose keys are picked from the given source type */
-  public Pick<T extends TObject, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: ObjectOptions): TPick<T, UnionStringLiteralToTuple<K>>
-
-  /** `Standard` Creates a new object type whose keys are picked from the given source type */
-  public Pick<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: T, keys: readonly [...K], options?: ObjectOptions): TPick<T, K>
-
-  /** `Standard` Creates a new object type whose keys are picked from the given source type */
-  public Pick<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: any, keys: any, options: ObjectOptions = {}) {
-    const select: readonly string[] = keys[Kind] === 'Union' ? keys.anyOf.map((schema: TLiteral) => schema.const) : keys
-    const next = { ...this.Clone(schema), ...options, [Hint]: 'Pick' }
-    if (next.required) {
-      next.required = next.required.filter((key: any) => select.includes(key))
-      if (next.required.length === 0) delete next.required
+  // --------------------------------------------------------------------------
+  // Promise
+  // --------------------------------------------------------------------------
+  function Promise(left: TPromise, right: TSchema) {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right) && IsObjectPromiseLike(right)) return TypeExtendsResult.True
+    if (!TypeGuard.TPromise(right)) return TypeExtendsResult.False
+    return IntoBooleanResult(Visit(left.item, right.item))
+  }
+  // --------------------------------------------------------------------------
+  // Record
+  // --------------------------------------------------------------------------
+  function RecordKey(schema: TRecord) {
+    if ('^(0|[1-9][0-9]*)$' in schema.patternProperties) return Type.Number()
+    if ('^.*$' in schema.patternProperties) return Type.String()
+    throw Error('TypeExtends: Cannot get record key')
+  }
+  function RecordValue(schema: TRecord) {
+    if ('^(0|[1-9][0-9]*)$' in schema.patternProperties) return schema.patternProperties['^(0|[1-9][0-9]*)$']
+    if ('^.*$' in schema.patternProperties) return schema.patternProperties['^.*$']
+    throw Error('TypeExtends: Cannot get record value')
+  }
+  function RecordRight(left: TSchema, right: TRecord) {
+    const Key = RecordKey(right)
+    const Value = RecordValue(right)
+    if (TypeGuard.TLiteral(left) && IsLiteralString(left) && TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === TypeExtendsResult.True) return TypeExtendsResult.True
+    if (TypeGuard.TUint8Array(left) && TypeGuard.TNumber(Key)) return Visit(left, Value)
+    if (TypeGuard.TString(left) && TypeGuard.TNumber(Key)) return Visit(left, Value)
+    if (TypeGuard.TArray(left) && TypeGuard.TNumber(Key)) return Visit(left, Value)
+    if (TypeGuard.TObject(left)) {
+      for (const key of globalThis.Object.keys(left.properties)) {
+        if (Property(Value, left.properties[key]) === TypeExtendsResult.False) {
+          return TypeExtendsResult.False
+        }
+      }
+      return TypeExtendsResult.True
     }
-    for (const key of Object.keys(next.properties)) {
-      if (!select.includes(key as any)) delete next.properties[key]
+    return TypeExtendsResult.False
+  }
+  function Record(left: TRecord, right: TSchema) {
+    const Value = RecordValue(left)
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    if (!TypeGuard.TRecord(right)) return TypeExtendsResult.False
+    return Visit(Value, RecordValue(right))
+  }
+  // --------------------------------------------------------------------------
+  // String
+  // --------------------------------------------------------------------------
+  function StringRight(left: TSchema, right: TString) {
+    if (TypeGuard.TLiteral(left) && typeof left.const === 'string') return TypeExtendsResult.True
+    return TypeGuard.TString(left) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  function String(left: TString, right: TSchema): TypeExtendsResult {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TNever(right)) return NeverRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+    return TypeGuard.TString(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  // --------------------------------------------------------------------------
+  // Symbol
+  // --------------------------------------------------------------------------
+  function Symbol(left: TSymbol, right: TSchema): TypeExtendsResult {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TNever(right)) return NeverRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+    return TypeGuard.TSymbol(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  // --------------------------------------------------------------------------
+  // Tuple
+  // --------------------------------------------------------------------------
+  function TupleRight(left: TSchema, right: TTuple) {
+    if (TypeGuard.TUnknown(left)) return TypeExtendsResult.False
+    if (TypeGuard.TAny(left)) return TypeExtendsResult.Union
+    if (TypeGuard.TNever(left)) return TypeExtendsResult.True
+    return TypeExtendsResult.False
+  }
+  function IsArrayOfTuple(left: TTuple, right: TSchema) {
+    return TypeGuard.TArray(right) && left.items !== undefined && left.items.every((schema) => Visit(schema, right.items) === TypeExtendsResult.True)
+  }
+  function Tuple(left: TTuple, right: TSchema): TypeExtendsResult {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right) && IsObjectArrayLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TArray(right) && IsArrayOfTuple(left, right)) return TypeExtendsResult.True
+    if (!TypeGuard.TTuple(right)) return TypeExtendsResult.False
+    if ((left.items === undefined && right.items !== undefined) || (left.items !== undefined && right.items === undefined)) return TypeExtendsResult.False
+    if (left.items === undefined && right.items === undefined) return TypeExtendsResult.True
+    return left.items!.every((schema, index) => Visit(schema, right.items![index]) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  // --------------------------------------------------------------------------
+  // Uint8Array
+  // --------------------------------------------------------------------------
+  function Uint8Array(left: TUint8Array, right: TSchema) {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+    return TypeGuard.TUint8Array(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  // --------------------------------------------------------------------------
+  // Undefined
+  // --------------------------------------------------------------------------
+  function Undefined(left: TUndefined, right: TSchema) {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TNever(right)) return NeverRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+    if (TypeGuard.TVoid(right)) return VoidRight(left, right)
+    return TypeGuard.TUndefined(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  // --------------------------------------------------------------------------
+  // Union
+  // --------------------------------------------------------------------------
+  function UnionRight(left: TSchema, right: TUnion): TypeExtendsResult {
+    return right.anyOf.some((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  function Union(left: TUnion, right: TSchema) {
+    return left.anyOf.every((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  // --------------------------------------------------------------------------
+  // Unknown
+  // --------------------------------------------------------------------------
+  function UnknownRight(left: TSchema, right: TUnknown) {
+    return TypeExtendsResult.True
+  }
+  function Unknown(left: TUnknown, right: TSchema) {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TString(right)) return StringRight(left, right)
+    if (TypeGuard.TNumber(right)) return NumberRight(left, right)
+    if (TypeGuard.TInteger(right)) return IntegerRight(left, right)
+    if (TypeGuard.TBoolean(right)) return BooleanRight(left, right)
+    if (TypeGuard.TArray(right)) return ArrayRight(left, right)
+    if (TypeGuard.TTuple(right)) return TupleRight(left, right)
+    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    return TypeGuard.TUnknown(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  // --------------------------------------------------------------------------
+  // Void
+  // --------------------------------------------------------------------------
+  function VoidRight(left: TSchema, right: TVoid) {
+    if (TypeGuard.TUndefined(left)) return TypeExtendsResult.True
+    return TypeGuard.TUndefined(left) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  function Void(left: TVoid, right: TSchema) {
+    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
+    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+  }
+  function Visit(left: TSchema, right: TSchema): TypeExtendsResult {
+    if (TypeGuard.TAny(left)) return Any(left, right)
+    if (TypeGuard.TArray(left)) return Array(left, right)
+    if (TypeGuard.TBigInt(left)) return BigInt(left, right)
+    if (TypeGuard.TBoolean(left)) return Boolean(left, right)
+    if (TypeGuard.TConstructor(left)) return Constructor(left, right)
+    if (TypeGuard.TDate(left)) return Date(left, right)
+    if (TypeGuard.TFunction(left)) return Function(left, right)
+    if (TypeGuard.TInteger(left)) return Integer(left, right)
+    if (TypeGuard.TIntersect(left)) return Intersect(left, right)
+    if (TypeGuard.TLiteral(left)) return Literal(left, right)
+    if (TypeGuard.TNever(left)) return Never(left, right)
+    if (TypeGuard.TNull(left)) return Null(left, right)
+    if (TypeGuard.TNumber(left)) return Number(left, right)
+    if (TypeGuard.TRecord(left)) return Record(left, right)
+    if (TypeGuard.TString(left)) return String(left, right)
+    if (TypeGuard.TSymbol(left)) return Symbol(left, right)
+    if (TypeGuard.TObject(left)) return Object(left, right)
+    if (TypeGuard.TTuple(left)) return Tuple(left, right)
+    if (TypeGuard.TPromise(left)) return Promise(left, right)
+    if (TypeGuard.TUint8Array(left)) return Uint8Array(left, right)
+    if (TypeGuard.TUndefined(left)) return Undefined(left, right)
+    if (TypeGuard.TUnion(left)) return Union(left, right)
+    if (TypeGuard.TUnknown(left)) return Unknown(left, right)
+    if (TypeGuard.TVoid(left)) return Void(left, right)
+    throw Error(`TypeExtends: Unknown left type operand '${left[Kind]}'`)
+  }
+  export function Extends(left: TSchema, right: TSchema): TypeExtendsResult {
+    return Visit(left, right)
+  }
+}
+// --------------------------------------------------------------------------
+// TypeClone
+// --------------------------------------------------------------------------
+/** Specialized Clone for Types */
+export namespace TypeClone {
+  function IsObject(value: unknown): value is Record<string | symbol, any> {
+    return typeof value === 'object' && value !== null
+  }
+  function IsArray(value: unknown): value is unknown[] {
+    return globalThis.Array.isArray(value)
+  }
+  function Array(value: unknown[]) {
+    return (value as any).map((value: unknown) => Visit(value as any))
+  }
+  function Object(value: Record<keyof any, unknown>) {
+    const clonedProperties = globalThis.Object.getOwnPropertyNames(value).reduce((acc, key) => {
+      return { ...acc, [key]: Visit(value[key]) }
+    }, {})
+    const clonedSymbols = globalThis.Object.getOwnPropertySymbols(value).reduce((acc, key) => {
+      return { ...acc, [key]: Visit(value[key as any]) }
+    }, {})
+    return { ...clonedProperties, ...clonedSymbols }
+  }
+  function Visit(value: unknown): any {
+    if (IsArray(value)) return Array(value)
+    if (IsObject(value)) return Object(value)
+    return value
+  }
+  /** Clones a type. This function will omit non-self referential identifiers on the cloned type. */
+  export function Clone<T extends TSchema>(schema: T, options: SchemaOptions): T {
+    return { ...Visit(schema), ...options }
+  }
+}
+// --------------------------------------------------------------------------
+// ObjectMap
+// --------------------------------------------------------------------------
+export namespace ObjectMap {
+  function Intersect(schema: TIntersect, callback: (object: TObject) => TObject) {
+    return Type.Intersect(
+      schema.allOf.map((inner) => Visit(inner, callback)),
+      { ...schema },
+    )
+  }
+  function Union(schema: TUnion, callback: (object: TObject) => TObject) {
+    return Type.Union(
+      schema.anyOf.map((inner) => Visit(inner, callback)),
+      { ...schema },
+    )
+  }
+  function Object(schema: TObject, callback: (object: TObject) => TObject) {
+    return callback(schema)
+  }
+  function Visit(schema: TSchema, callback: (object: TObject) => TObject): TSchema {
+    if (TypeGuard.TIntersect(schema)) return Intersect(schema, callback)
+    if (TypeGuard.TUnion(schema)) return Union(schema, callback)
+    if (TypeGuard.TObject(schema)) return Object(schema, callback)
+    return schema
+  }
+  export function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T {
+    return { ...Visit(TypeClone.Clone(schema, {}), callback), ...options } as unknown as T
+  }
+}
+// --------------------------------------------------------------------------
+// KeyResolver
+// --------------------------------------------------------------------------
+export namespace KeyResolver {
+  function IsKeyable(schema: TSchema) {
+    return TypeGuard.TIntersect(schema) || TypeGuard.TUnion(schema) || (TypeGuard.TObject(schema) && globalThis.Object.getOwnPropertyNames(schema.properties).length > 0)
+  }
+  function Intersect(schema: TIntersect) {
+    return [...schema.allOf.filter((schema) => IsKeyable(schema)).reduce((set, schema) => Visit(schema).map((key) => set.add(key))[0], new Set<string>())]
+  }
+  function Union(schema: TUnion) {
+    const sets = schema.anyOf.filter((schema) => IsKeyable(schema)).map((inner) => Visit(inner))
+    return [...sets.reduce((set, outer) => outer.map((key) => (sets.every((inner) => inner.includes(key)) ? set.add(key) : set))[0], new Set<string>())]
+  }
+  function Object(schema: TObject) {
+    return globalThis.Object.keys(schema.properties)
+  }
+  function Visit(schema: TSchema): string[] {
+    if (TypeGuard.TIntersect(schema)) return Intersect(schema)
+    if (TypeGuard.TUnion(schema)) return Union(schema)
+    if (TypeGuard.TObject(schema)) return Object(schema)
+    return []
+  }
+  export function Resolve<T extends TSchema>(schema: T) {
+    return Visit(schema)
+  }
+}
+// --------------------------------------------------------------------------
+// TypeOrdinal: Used for auto $id generation
+// --------------------------------------------------------------------------
+let TypeOrdinal = 0
+// --------------------------------------------------------------------------
+// TypeBuilder
+// --------------------------------------------------------------------------
+export class TypeBuilder {
+  /** `[Utility]` Creates a schema without `static` and `params` types */
+  protected Create<T>(schema: Omit<T, 'static' | 'params'>): T {
+    return schema as any
+  }
+  /** `[Standard]` Omits compositing symbols from this schema */
+  public Strict<T extends TSchema>(schema: T): T {
+    return JSON.parse(JSON.stringify(schema))
+  }
+}
+// --------------------------------------------------------------------------
+// StandardTypeBuilder
+// --------------------------------------------------------------------------
+export class StandardTypeBuilder extends TypeBuilder {
+  // ------------------------------------------------------------------------
+  // Modifiers
+  // ------------------------------------------------------------------------
+  /** `[Modifier]` Creates a Optional property */
+  public Optional<T extends TSchema>(schema: T): TOptional<T> {
+    return { [Modifier]: 'Optional', ...TypeClone.Clone(schema, {}) }
+  }
+  /** `[Modifier]` Creates a ReadonlyOptional property */
+  public ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T> {
+    return { [Modifier]: 'ReadonlyOptional', ...TypeClone.Clone(schema, {}) }
+  }
+  /** `[Modifier]` Creates a Readonly object or property */
+  public Readonly<T extends TSchema>(schema: T): TReadonly<T> {
+    return { [Modifier]: 'Readonly', ...schema }
+  }
+  // ------------------------------------------------------------------------
+  // Types
+  // ------------------------------------------------------------------------
+  /** `[Standard]` Creates an Any type */
+  public Any(options: SchemaOptions = {}): TAny {
+    return this.Create({ ...options, [Kind]: 'Any' })
+  }
+  /** `[Standard]` Creates an Array type */
+  public Array<T extends TSchema>(items: T, options: ArrayOptions = {}): TArray<T> {
+    return this.Create({ ...options, [Kind]: 'Array', type: 'array', items: TypeClone.Clone(items, {}) })
+  }
+  /** `[Standard]` Creates a Boolean type */
+  public Boolean(options: SchemaOptions = {}): TBoolean {
+    return this.Create({ ...options, [Kind]: 'Boolean', type: 'boolean' })
+  }
+  /** `[Standard]` Creates a Composite object type that will union any overlapping properties of the given object array */
+  public Composite<T extends TObject[]>(schemas: [...T], options?: ObjectOptions): TComposite<T> {
+    const properties = {} as TProperties
+    for (const object of schemas) {
+      for (const [key, property] of globalThis.Object.entries(object.properties)) {
+        properties[key] = key in properties ? this.Union([properties[key], property]) : TypeClone.Clone(property, {})
+      }
     }
-    return this.Create(next)
+    return this.Object(properties, options) as TComposite<T>
   }
-
-  /** `Extended` Creates a Promise type */
-  public Promise<T extends TSchema>(item: T, options: SchemaOptions = {}): TPromise<T> {
-    return this.Create({ ...options, [Kind]: 'Promise', type: 'object', instanceOf: 'Promise', item })
+  /** `[Standard]` Creates a Enum type */
+  public Enum<T extends Record<string, string | number>>(item: T, options: SchemaOptions = {}): TEnum<T> {
+    // prettier-ignore
+    const values = globalThis.Object.keys(item).filter((key) => isNaN(key as any)).map((key) => item[key]) as T[keyof T][]
+    const anyOf = values.map((value) => (typeof value === 'string' ? { [Kind]: 'Literal', type: 'string' as const, const: value } : { [Kind]: 'Literal', type: 'number' as const, const: value }))
+    return this.Create({ ...options, [Kind]: 'Union', anyOf })
+  }
+  /** `[Standard]` A conditional type expression that will return the true type if the left type extends the right */
+  public Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options: SchemaOptions = {}): TExtends<L, R, T, U> {
+    switch (TypeExtends.Extends(left, right)) {
+      case TypeExtendsResult.Union:
+        return this.Union([TypeClone.Clone(trueType, options), TypeClone.Clone(falseType, options)]) as any as TExtends<L, R, T, U>
+      case TypeExtendsResult.True:
+        return TypeClone.Clone(trueType, options) as TExtends<L, R, T, U>
+      case TypeExtendsResult.False:
+        return TypeClone.Clone(falseType, options) as TExtends<L, R, T, U>
+    }
+  }
+  /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
+  public Exclude<L extends TSchema, R extends TSchema>(left: L, right: R, options: SchemaOptions = {}): TExclude<L, R> {
+    if (TypeGuard.TUnion(left)) {
+      const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) === TypeExtendsResult.False)
+      return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options)) as TExclude<L, R>
+    } else {
+      return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Clone(left, options)) as any
+    }
+  }
+  /** `[Standard]` Extracts from left left any type that is assignable to the right */
+  public Extract<L extends TSchema, R extends TSchema>(left: L, right: R, options: SchemaOptions = {}): TExtract<L, R> {
+    if (TypeGuard.TUnion(left)) {
+      const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) !== TypeExtendsResult.False)
+      return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options)) as TExtract<L, R>
+    } else {
+      return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? TypeClone.Clone(left, options) : this.Never(options)) as any
+    }
+  }
+  /** `[Standard]` Creates an Integer type */
+  public Integer(options: NumericOptions<number> = {}): TInteger {
+    return this.Create({ ...options, [Kind]: 'Integer', type: 'integer' })
+  }
+  /** `[Standard]` Creates a Intersect type */
+  public Intersect(allOf: [], options?: SchemaOptions): TNever
+  /** `[Standard]` Creates a Intersect type */
+  public Intersect<T extends [TSchema]>(allOf: [...T], options?: SchemaOptions): T[0]
+  // /** `[Standard]` Creates a Intersect type */
+  public Intersect<T extends TSchema[]>(allOf: [...T], options?: IntersectOptions): TIntersect<T>
+  public Intersect(allOf: TSchema[], options: IntersectOptions = {}) {
+    if (allOf.length === 0) return Type.Never()
+    if (allOf.length === 1) return TypeClone.Clone(allOf[0], options)
+    const objects = allOf.every((schema) => TypeGuard.TObject(schema))
+    const cloned = allOf.map((schema) => TypeClone.Clone(schema, {}))
+    const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties) ? { unevaluatedProperties: TypeClone.Clone(options.unevaluatedProperties, {}) } : {}
+    if (options.unevaluatedProperties === false || TypeGuard.TSchema(options.unevaluatedProperties) || objects) {
+      return this.Create({ ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: cloned })
+    } else {
+      return this.Create({ ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: cloned })
+    }
+  }
+  /** `[Standard]` Creates a KeyOf type */
+  public KeyOf<T extends TSchema>(schema: T, options: SchemaOptions = {}): TKeyOf<T> {
+    const keys = KeyResolver.Resolve(schema)
+    // prettier-ignore
+    const keyof = keys.length === 0 ? this.Never(options) : this.Union(keys.map((key) => this.Literal(key)), options)
+    return keyof as TKeyOf<T>
+  }
+  /** `[Standard]` Creates a Literal type */
+  public Literal<T extends TLiteralValue>(value: T, options: SchemaOptions = {}): TLiteral<T> {
+    return this.Create({ ...options, [Kind]: 'Literal', const: value, type: typeof value as 'string' | 'number' | 'boolean' })
+  }
+  /** `[Standard]` Creates a Never type */
+  public Never(options: SchemaOptions = {}): TNever {
+    return this.Create({ ...options, [Kind]: 'Never', not: {} })
+  }
+  /** `[Standard]` Creates a Not type. The first argument is the disallowed type, the second is the allowed. */
+  public Not<N extends TSchema, T extends TSchema>(not: N, schema: T, options?: SchemaOptions): TNot<N, T> {
+    return this.Create({ ...options, [Kind]: 'Not', allOf: [{ not: TypeClone.Clone(not, {}) }, TypeClone.Clone(schema, {})] })
+  }
+  /** `[Standard]` Creates a Null type */
+  public Null(options: SchemaOptions = {}): TNull {
+    return this.Create({ ...options, [Kind]: 'Null', type: 'null' })
+  }
+  /** `[Standard]` Creates a Number type */
+  public Number(options: NumericOptions<number> = {}): TNumber {
+    return this.Create({ ...options, [Kind]: 'Number', type: 'number' })
+  }
+  /** `[Standard]` Creates an Object type */
+  public Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
+    const propertyKeys = globalThis.Object.getOwnPropertyNames(properties)
+    const optionalKeys = propertyKeys.filter((key) => TypeGuard.TOptional(properties[key]) || TypeGuard.TReadonlyOptional(properties[key]))
+    const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name))
+    const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Clone(options.additionalProperties, {}) } : {}
+    const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(properties[key], {}) }), {} as TProperties)
+    if (requiredKeys.length > 0) {
+      return this.Create({ ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys })
+    } else {
+      return this.Create({ ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties })
+    }
+  }
+  /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+  public Omit<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TOmit<T, K[number]>
+  /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+  public Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionOfLiteral<K>>
+  /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+  public Omit<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TOmit<T, K['const']>
+  /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+  public Omit<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TOmit<T, never>
+  public Omit(schema: TSchema, unresolved: unknown, options: SchemaOptions = {}): any {
+    // prettier-ignore
+    const keys = 
+      TypeGuard.TUnionLiteral(unresolved) ? unresolved.anyOf.map((schema) => schema.const) : 
+      TypeGuard.TLiteral(unresolved) ? [unresolved.const] : 
+      TypeGuard.TNever(unresolved) ? [] :
+      (unresolved as string[])
+    // prettier-ignore
+    return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
+      if (schema.required) {
+        schema.required = schema.required.filter((key: string) => !keys.includes(key as any))
+        if (schema.required.length === 0) delete schema.required
+      }
+      for (const key of globalThis.Object.keys(schema.properties)) {
+        if (keys.includes(key as any)) delete schema.properties[key]
+      }
+      return this.Create(schema)
+    }, options)
   }
 
-  /** `Standard` Creates an object whose properties are derived from the given string literal union. */
-  public Record<K extends TUnion<TLiteral[]>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TObject<TRecordProperties<K, T>>
-
-  /** `Standard` Creates a record type */
+  /** `[Standard]` Creates a mapped type where all properties are Optional */
+  public Partial<T extends TSchema>(schema: T, options: ObjectOptions = {}): TPartial<T> {
+    function Apply(schema: TSchema) {
+      // prettier-ignore
+      switch (schema[Modifier]) {
+        case 'ReadonlyOptional': schema[Modifier] = 'ReadonlyOptional'; break;
+        case 'Readonly': schema[Modifier] = 'ReadonlyOptional'; break;
+        case 'Optional': schema[Modifier] = 'Optional'; break;
+        default: schema[Modifier] = 'Optional'; break;
+      }
+    }
+    // prettier-ignore
+    return ObjectMap.Map<TPartial<T>>(TypeClone.Clone(schema, {}), (schema) => {
+      delete schema.required
+      globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]))
+      return schema
+    }, options)
+  }
+  /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+  public Pick<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TPick<T, K[number]>
+  /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+  public Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionOfLiteral<K>>
+  /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+  public Pick<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TPick<T, K['const']>
+  /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+  public Pick<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TPick<T, never>
+  public Pick(schema: TSchema, unresolved: unknown, options: SchemaOptions = {}): any {
+    // prettier-ignore
+    const keys = 
+      TypeGuard.TUnionLiteral(unresolved) ? unresolved.anyOf.map((schema) => schema.const) : 
+      TypeGuard.TLiteral(unresolved) ? [unresolved.const] : 
+      TypeGuard.TNever(unresolved) ? [] :
+      (unresolved as string[])
+    // prettier-ignore
+    return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
+      if (schema.required) {
+        schema.required = schema.required.filter((key: any) => keys.includes(key))
+        if (schema.required.length === 0) delete schema.required
+      }
+      for (const key of globalThis.Object.keys(schema.properties)) {
+        if (!keys.includes(key as any)) delete schema.properties[key]
+      }
+      return this.Create(schema)
+    }, options)
+  }
+  /** `[Standard]` Creates an Object type from the given Literal Union */
+  public Record<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TObject<TRecordPropertiesFromUnionLiteral<K, T>>
+  /** `[Standard]` Creates an Object type from the given Literal Union */
+  public Record<K extends TLiteral<string | number>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TObject<TRecordPropertiesFromLiteral<K, T>>
+  /** `[Standard]` Creates a Record type */
   public Record<K extends TString | TNumeric, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecord<K, T>
-
-  /** `Standard` Creates a record type */
-  public Record(key: any, value: any, options: ObjectOptions = {}) {
-    // If string literal union return TObject with properties extracted from union.
-    if (key[Kind] === 'Union') {
-      return this.Object(
-        key.anyOf.reduce((acc: any, literal: any) => {
-          return { ...acc, [literal.const]: value }
-        }, {}),
-        { ...options, [Hint]: 'Record' },
-      )
+  public Record(key: any, schema: TSchema, options: ObjectOptions = {}) {
+    if (TypeGuard.TLiteral(key)) {
+      if (typeof key.const === 'string' || typeof key.const === 'number') {
+        return this.Object({ [key.const]: TypeClone.Clone(schema, {}) }, options)
+      } else throw Error('TypeBuilder: Record key can only be derived from literals of number or string')
+    }
+    if (TypeGuard.TUnion(key)) {
+      if (key.anyOf.every((schema) => TypeGuard.TLiteral(schema) && (typeof schema.const === 'string' || typeof schema.const === 'number'))) {
+        const properties = key.anyOf.reduce((acc: any, literal: any) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {} as TProperties)
+        return this.Object(properties, { ...options, [Hint]: 'Record' })
+      } else throw Error('TypeBuilder: Record key can only be derived from union literal of number or string')
     }
-    // otherwise return TRecord with patternProperties
     const pattern = ['Integer', 'Number'].includes(key[Kind]) ? '^(0|[1-9][0-9]*)$' : key[Kind] === 'String' && key.pattern ? key.pattern : '^.*$'
     return this.Create({
       ...options,
       [Kind]: 'Record',
       type: 'object',
-      patternProperties: { [pattern]: value },
+      patternProperties: { [pattern]: TypeClone.Clone(schema, {}) },
       additionalProperties: false,
     })
   }
-
-  /** `Standard` Creates recursive type */
+  /** `[Standard]` Creates a Recursive type */
   public Recursive<T extends TSchema>(callback: (self: TSelf) => T, options: SchemaOptions = {}): TRecursive<T> {
-    if (options.$id === undefined) options.$id = `T${TypeOrdinal++}`
+    if (options.$id === undefined) (options as any).$id = `T${TypeOrdinal++}`
     const self = callback({ [Kind]: 'Self', $ref: `${options.$id}` } as any)
     self.$id = options.$id
     return this.Create({ ...options, ...self } as any)
   }
-
-  /** `Standard` Creates a reference type. The referenced type must contain a $id. */
+  /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
   public Ref<T extends TSchema>(schema: T, options: SchemaOptions = {}): TRef<T> {
-    if (schema.$id === undefined) throw Error('TypeBuilder.Ref: Referenced schema must specify an $id')
+    if (schema.$id === undefined) throw Error('StandardTypeBuilder.Ref: Target type must specify an $id')
     return this.Create({ ...options, [Kind]: 'Ref', $ref: schema.$id! })
   }
-
-  /** `Standard` Creates a string type from a regular expression */
-  public RegEx(regex: RegExp, options: SchemaOptions = {}): TString {
-    return this.Create({ ...options, [Kind]: 'String', type: 'string', pattern: regex.source })
-  }
-
-  /** `Standard` Creates an object type whose properties are all required */
-  public Required<T extends TObject>(schema: T, options: SchemaOptions = {}): TRequired<T> {
-    const next = { ...this.Clone(schema), ...options, [Hint]: 'Required' }
-    next.required = Object.keys(next.properties)
-    for (const key of Object.keys(next.properties)) {
-      const property = next.properties[key]
-      const modifier = property[Modifier]
-      switch (modifier) {
-        case 'ReadonlyOptional':
-          property[Modifier] = 'Readonly'
-          break
-        case 'Readonly':
-          property[Modifier] = 'Readonly'
-          break
-        case 'Optional':
-          delete property[Modifier]
-          break
-        default:
-          delete property[Modifier]
-          break
+  /** `[Standard]` Creates a mapped type where all properties are Required */
+  public Required<T extends TSchema>(schema: T, options: SchemaOptions = {}): TRequired<T> {
+    function Apply(schema: TSchema) {
+      // prettier-ignore
+      switch (schema[Modifier]) {
+        case 'ReadonlyOptional': schema[Modifier] = 'Readonly'; break
+        case 'Readonly': schema[Modifier] = 'Readonly'; break
+        case 'Optional': delete schema[Modifier]; break
+        default: delete schema[Modifier]; break
       }
     }
-    return this.Create(next)
-  }
-
-  /** `Extended` Creates a type from this functions return type */
-  public ReturnType<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TReturnType<T> {
-    return { ...options, ...this.Clone(schema.returns) }
-  }
-
-  /** Removes Kind and Modifier symbol property keys from this schema */
-  public Strict<T extends TSchema>(schema: T): T {
-    return JSON.parse(JSON.stringify(schema))
+    // prettier-ignore
+    return ObjectMap.Map<TRequired<T>>(TypeClone.Clone(schema, {}), (schema) => {
+      schema.required = globalThis.Object.keys(schema.properties)
+      globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]))
+      return schema
+    }, options)
   }
-
-  /** `Standard` Creates a string type */
+  /** `[Standard]` Creates a String type */
   public String<Format extends string>(options: StringOptions<StringFormatOption | Format> = {}): TString<Format> {
     return this.Create({ ...options, [Kind]: 'String', type: 'string' })
   }
-
-  /** `Standard` Creates a tuple type */
+  /** `[Standard]` Creates a Tuple type */
   public Tuple<T extends TSchema[]>(items: [...T], options: SchemaOptions = {}): TTuple<T> {
-    const additionalItems = false
-    const minItems = items.length
-    const maxItems = items.length
-    const schema = (items.length > 0 ? { ...options, [Kind]: 'Tuple', type: 'array', items, additionalItems, minItems, maxItems } : { ...options, [Kind]: 'Tuple', type: 'array', minItems, maxItems }) as any
+    const [additionalItems, minItems, maxItems] = [false, items.length, items.length]
+    const clonedItems = items.map((item) => TypeClone.Clone(item, {}))
+    // prettier-ignore
+    const schema = (items.length > 0 ? 
+      { ...options, [Kind]: 'Tuple', type: 'array', items: clonedItems, additionalItems, minItems, maxItems } : 
+      { ...options, [Kind]: 'Tuple', type: 'array', minItems, maxItems }) as any
     return this.Create(schema)
   }
-
-  /** `Extended` Creates a undefined type */
-  public Undefined(options: SchemaOptions = {}): TUndefined {
-    return this.Create({ ...options, [Kind]: 'Undefined', type: 'null', typeOf: 'Undefined' })
-  }
-
-  /** `Standard` Creates a union type */
-  public Union(items: [], options?: SchemaOptions): TNever
-
-  /** `Standard` Creates a union type */
-  public Union<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TUnion<T>
-
-  /** `Standard` Creates a union type */
-  public Union<T extends TSchema[]>(items: [...T], options: SchemaOptions = {}) {
-    return items.length === 0 ? Type.Never({ ...options }) : this.Create({ ...options, [Kind]: 'Union', anyOf: items })
-  }
-
-  /** `Extended` Creates a Uint8Array type */
-  public Uint8Array(options: Uint8ArrayOptions = {}): TUint8Array {
-    return this.Create({ ...options, [Kind]: 'Uint8Array', type: 'object', instanceOf: 'Uint8Array' })
+  /** `[Standard]` Creates a Union type */
+  public Union(anyOf: [], options?: SchemaOptions): TNever
+  /** `[Standard]` Creates a Union type */
+  public Union<T extends [TSchema]>(anyOf: [...T], options?: SchemaOptions): T[0]
+  /** `[Standard]` Creates a Union type */
+  public Union<T extends TSchema[]>(anyOf: [...T], options?: SchemaOptions): TUnion<T>
+  public Union(anyOf: TSchema[], options: SchemaOptions = {}) {
+    if (anyOf.length === 0) return this.Never(options)
+    if (anyOf.length === 1) return this.Create(TypeClone.Clone(anyOf[0], options))
+    const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema, {}))
+    return this.Create({ ...options, [Kind]: 'Union', anyOf: clonedAnyOf })
   }
-
-  /** `Standard` Creates an unknown type */
+  /** `[Standard]` Creates an Unknown type */
   public Unknown(options: SchemaOptions = {}): TUnknown {
     return this.Create({ ...options, [Kind]: 'Unknown' })
   }
-
-  /** `Standard` Creates a user defined schema that infers as type T  */
+  /** `[Standard]` Creates a Unsafe type that infers for the generic argument */
   public Unsafe<T>(options: UnsafeOptions = {}): TUnsafe<T> {
     return this.Create({ ...options, [Kind]: options[Kind] || 'Unsafe' })
   }
-
-  /** `Extended` Creates a void type */
-  public Void(options: SchemaOptions = {}): TVoid {
-    return this.Create({ ...options, [Kind]: 'Void', type: 'null', typeOf: 'Void' })
+}
+// --------------------------------------------------------------------------
+// TypeBuilder
+// --------------------------------------------------------------------------
+export class ExtendedTypeBuilder extends StandardTypeBuilder {
+  /** `[Extended]` Creates a BigInt type */
+  public BigInt(options: NumericOptions<bigint> = {}): TBigInt {
+    return this.Create({ ...options, [Kind]: 'BigInt', type: 'null', typeOf: 'BigInt' })
   }
-
-  /** Use this function to return TSchema with static and params omitted */
-  protected Create<T>(schema: Omit<T, 'static' | 'params'>): T {
-    return schema as any
+  /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
+  public ConstructorParameters<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TConstructorParameters<T> {
+    return this.Tuple([...schema.parameters], { ...options })
   }
-
-  /** Clones the given value */
-  protected Clone(value: any): any {
-    const isObject = (object: any): object is Record<string | symbol, any> => typeof object === 'object' && object !== null && !Array.isArray(object)
-    const isArray = (object: any): object is any[] => typeof object === 'object' && object !== null && Array.isArray(object)
-    if (isObject(value)) {
-      return Object.keys(value).reduce(
-        (acc, key) => ({
-          ...acc,
-          [key]: this.Clone(value[key]),
-        }),
-        Object.getOwnPropertySymbols(value).reduce(
-          (acc, key: any) => ({
-            ...acc,
-            [key]: this.Clone(value[key]),
-          }),
-          {},
-        ),
-      )
-    } else if (isArray(value)) {
-      return value.map((item: any) => this.Clone(item))
+  /** `[Extended]` Creates a Constructor type */
+  public Constructor<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TConstructor<TTupleIntoArray<T>, U>
+  /** `[Extended]` Creates a Constructor type */
+  public Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>
+  public Constructor(parameters: any, returns: any, options: SchemaOptions = {}) {
+    const clonedReturns = TypeClone.Clone(returns, {})
+    if (TypeGuard.TTuple(parameters)) {
+      const clonedParameters = parameters.items === undefined ? [] : parameters.items.map((parameter) => TypeClone.Clone(parameter, {}))
+      return this.Create({ ...options, [Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: clonedParameters, returns: clonedReturns })
+    } else if (globalThis.Array.isArray(parameters)) {
+      const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}))
+      return this.Create({ ...options, [Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: clonedParameters, returns: clonedReturns })
+    } else {
+      throw new Error('ExtendedTypeBuilder.Constructor: Invalid parameters')
+    }
+  }
+  /** `[Extended]` Creates a Date type */
+  public Date(options: DateOptions = {}): TDate {
+    return this.Create({ ...options, [Kind]: 'Date', type: 'object', instanceOf: 'Date' })
+  }
+  /** `[Extended]` Creates a Function type */
+  public Function<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TFunction<TTupleIntoArray<T>, U>
+  /** `[Extended]` Creates a Function type */
+  public Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>
+  public Function(parameters: any, returns: any, options: SchemaOptions = {}) {
+    const clonedReturns = TypeClone.Clone(returns, {})
+    if (TypeGuard.TTuple(parameters)) {
+      const clonedParameters = parameters.items === undefined ? [] : parameters.items.map((parameter) => TypeClone.Clone(parameter, {}))
+      return this.Create({ ...options, [Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: clonedParameters, returns: clonedReturns })
+    } else if (globalThis.Array.isArray(parameters)) {
+      const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}))
+      return this.Create({ ...options, [Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: clonedParameters, returns: clonedReturns })
     } else {
-      return value
+      throw new Error('ExtendedTypeBuilder.Function: Invalid parameters')
     }
   }
+  /** `[Extended]` Extracts the InstanceType from the given Constructor */
+  public InstanceType<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TInstanceType<T> {
+    return TypeClone.Clone(schema.returns, options)
+  }
+  /** `[Extended]` Extracts the Parameters from the given Function type */
+  public Parameters<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TParameters<T> {
+    return this.Tuple(schema.parameters, { ...options })
+  }
+  /** `[Extended]` Creates a Promise type */
+  public Promise<T extends TSchema>(item: T, options: SchemaOptions = {}): TPromise<T> {
+    return this.Create({ ...options, [Kind]: 'Promise', type: 'object', instanceOf: 'Promise', item: TypeClone.Clone(item, {}) })
+  }
+  /** `[Extended]` Creates a regular expression type */
+  public RegEx(regex: RegExp, options: SchemaOptions = {}): TString {
+    return this.Create({ ...options, [Kind]: 'String', type: 'string', pattern: regex.source })
+  }
+  /** `[Extended]` Extracts the ReturnType from the given Function */
+  public ReturnType<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TReturnType<T> {
+    return TypeClone.Clone(schema.returns, options)
+  }
+  /** `[Extended]` Creates a Symbol type */
+  public Symbol(options?: SchemaOptions): TSymbol {
+    return this.Create({ ...options, [Kind]: 'Symbol', type: 'null', typeOf: 'Symbol' })
+  }
+  /** `[Extended]` Creates a Undefined type */
+  public Undefined(options: SchemaOptions = {}): TUndefined {
+    return this.Create({ ...options, [Kind]: 'Undefined', type: 'null', typeOf: 'Undefined' })
+  }
+  /** `[Extended]` Creates a Uint8Array type */
+  public Uint8Array(options: Uint8ArrayOptions = {}): TUint8Array {
+    return this.Create({ ...options, [Kind]: 'Uint8Array', type: 'object', instanceOf: 'Uint8Array' })
+  }
+  /** `[Extended]` Creates a Void type */
+  public Void(options: SchemaOptions = {}): TVoid {
+    return this.Create({ ...options, [Kind]: 'Void', type: 'null', typeOf: 'Void' })
+  }
 }
 
-/** JSON Schema Type Builder with Static Type Resolution for TypeScript */
-export const Type = new TypeBuilder()
+/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
+export const StandardType = new StandardTypeBuilder()
+
+/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
+export const Type = new ExtendedTypeBuilder()
diff --git a/src/value/cast.ts b/src/value/cast.ts
index 1a12d1333..67e936a29 100644
--- a/src/value/cast.ts
+++ b/src/value/cast.ts
@@ -30,7 +30,6 @@ import * as Types from '../typebox'
 import { ValueCreate } from './create'
 import { ValueCheck } from './check'
 import { ValueClone } from './clone'
-import { Custom } from '../custom/index'
 
 // ----------------------------------------------------------------------------------------------
 // Errors
@@ -60,7 +59,11 @@ export class ValueCastUnknownTypeError extends Error {
     super('ValueCast: Unknown type')
   }
 }
-
+export class ValueCastDereferenceError extends Error {
+  constructor(public readonly schema: Types.TRef | Types.TSelf) {
+    super(`ValueCast: Unable to dereference schema with $id '${schema.$ref}'`)
+  }
+}
 // ----------------------------------------------------------------------------------------------
 // The following will score a schema against a value. For objects, the score is the tally of
 // points awarded for each property of the value. Property points are (1.0 / propertyCount)
@@ -109,93 +112,18 @@ export namespace ValueCast {
   // ----------------------------------------------------------------------------------------------
   // Guards
   // ----------------------------------------------------------------------------------------------
+  function IsObject(value: unknown): value is Record<keyof any, unknown> {
+    return typeof value === 'object' && value !== null && !globalThis.Array.isArray(value)
+  }
   function IsArray(value: unknown): value is unknown[] {
     return typeof value === 'object' && globalThis.Array.isArray(value)
   }
-  function IsDate(value: unknown): value is Date {
-    return typeof value === 'object' && value instanceof globalThis.Date
-  }
-  function IsString(value: unknown): value is string {
-    return typeof value === 'string'
-  }
-  function IsBoolean(value: unknown): value is boolean {
-    return typeof value === 'boolean'
-  }
-  function IsBigInt(value: unknown): value is bigint {
-    return typeof value === 'bigint'
-  }
   function IsNumber(value: unknown): value is number {
     return typeof value === 'number' && !isNaN(value)
   }
-  function IsStringNumeric(value: unknown): value is string {
-    return IsString(value) && !isNaN(value as any) && !isNaN(parseFloat(value))
-  }
-  function IsValueToString(value: unknown): value is { toString: () => string } {
-    return IsBigInt(value) || IsBoolean(value) || IsNumber(value)
-  }
-  function IsValueTrue(value: unknown): value is true {
-    return value === true || (IsNumber(value) && value === 1) || (IsBigInt(value) && value === globalThis.BigInt('1')) || (IsString(value) && (value.toLowerCase() === 'true' || value === '1'))
-  }
-  function IsValueFalse(value: unknown): value is true {
-    return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === globalThis.BigInt('0')) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'))
-  }
-  function IsTimeStringWithTimeZone(value: unknown): value is string {
-    return IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value)
-  }
-  function IsTimeStringWithoutTimeZone(value: unknown): value is string {
-    return IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value)
-  }
-  function IsDateTimeStringWithTimeZone(value: unknown): value is string {
-    return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value)
-  }
-  function IsDateTimeStringWithoutTimeZone(value: unknown): value is string {
-    return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value)
-  }
-  function IsDateString(value: unknown): value is string {
-    return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value)
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Convert
-  // ----------------------------------------------------------------------------------------------
-  function TryConvertString(value: unknown) {
-    return IsValueToString(value) ? value.toString() : value
-  }
-  function TryConvertNumber(value: unknown) {
-    return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : value
-  }
-  function TryConvertInteger(value: unknown) {
-    return IsStringNumeric(value) ? parseInt(value) : IsValueTrue(value) ? 1 : value
-  }
-  function TryConvertBoolean(value: unknown) {
-    return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value
-  }
-  function TryConvertDate(value: unknown) {
-    // note: this function may return an invalid dates for the regex tests
-    // above. Invalid dates will however be checked during the casting
-    // function and will return a epoch date if invalid. Consider better
-    // string parsing for the iso dates in future revisions.
-    return IsDate(value)
-      ? value
-      : IsNumber(value)
-      ? new globalThis.Date(value)
-      : IsValueTrue(value)
-      ? new globalThis.Date(1)
-      : IsStringNumeric(value)
-      ? new globalThis.Date(parseInt(value))
-      : IsTimeStringWithoutTimeZone(value)
-      ? new globalThis.Date(`1970-01-01T${value}.000Z`)
-      : IsTimeStringWithTimeZone(value)
-      ? new globalThis.Date(`1970-01-01T${value}`)
-      : IsDateTimeStringWithoutTimeZone(value)
-      ? new globalThis.Date(`${value}.000Z`)
-      : IsDateTimeStringWithTimeZone(value)
-      ? new globalThis.Date(value)
-      : IsDateString(value)
-      ? new globalThis.Date(`${value}T00:00:00.000Z`)
-      : value
+  function IsString(value: unknown): value is string {
+    return typeof value === 'string'
   }
-
   // ----------------------------------------------------------------------------------------------
   // Cast
   // ----------------------------------------------------------------------------------------------
@@ -213,9 +141,11 @@ export namespace ValueCast {
     if (!ValueCheck.Check(schema, references, unique)) throw new ValueCastArrayUniqueItemsTypeError(schema, unique)
     return unique
   }
+  function BigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any): any {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+  }
   function Boolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): any {
-    const conversion = TryConvertBoolean(value)
-    return ValueCheck.Check(schema, references, conversion) ? conversion : ValueCreate.Create(schema, references)
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
   }
   function Constructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): any {
     if (ValueCheck.Check(schema, references, value)) return ValueCreate.Create(schema, references)
@@ -228,31 +158,36 @@ export namespace ValueCast {
     return result
   }
   function Date(schema: Types.TDate, references: Types.TSchema[], value: any): any {
-    const conversion = TryConvertDate(value)
-    return ValueCheck.Check(schema, references, conversion) ? ValueClone.Clone(conversion) : ValueCreate.Create(schema, references)
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
   function Function(schema: Types.TFunction, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
   }
   function Integer(schema: Types.TInteger, references: Types.TSchema[], value: any): any {
-    const conversion = TryConvertInteger(value)
-    return ValueCheck.Check(schema, references, conversion) ? conversion : ValueCreate.Create(schema, references)
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+  }
+  function Intersect(schema: Types.TIntersect, references: Types.TSchema[], value: any): any {
+    const created = ValueCreate.Create(schema, references)
+    const mapped = IsObject(created) && IsObject(value) ? { ...(created as any), ...value } : value
+    return ValueCheck.Check(schema, references, mapped) ? mapped : ValueCreate.Create(schema, references)
   }
   function Literal(schema: Types.TLiteral, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
   }
   function Never(schema: Types.TNever, references: Types.TSchema[], value: any): any {
     throw new ValueCastNeverTypeError(schema)
   }
+  function Not(schema: Types.TNot, references: Types.TSchema[], value: any): any {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema.allOf[1], references)
+  }
   function Null(schema: Types.TNull, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
   }
   function Number(schema: Types.TNumber, references: Types.TSchema[], value: any): any {
-    const conversion = TryConvertNumber(value)
-    return ValueCheck.Check(schema, references, conversion) ? conversion : ValueCreate.Create(schema, references)
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
   }
   function Object(schema: Types.TObject, references: Types.TSchema[], value: any): any {
-    if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
+    if (ValueCheck.Check(schema, references, value)) return value
     if (value === null || typeof value !== 'object') return ValueCreate.Create(schema, references)
     const required = new Set(schema.required || [])
     const result = {} as Record<string, any>
@@ -285,18 +220,22 @@ export namespace ValueCast {
     return result
   }
   function Ref(schema: Types.TRef<any>, references: Types.TSchema[], value: any): any {
-    const reference = references.find((reference) => reference.$id === schema.$ref)
-    if (reference === undefined) throw new ValueCastReferenceTypeError(schema)
-    return Visit(reference, references, value)
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+    if (index === -1) throw new ValueCastDereferenceError(schema)
+    const target = references[index]
+    return Visit(target, references, value)
   }
   function Self(schema: Types.TSelf, references: Types.TSchema[], value: any): any {
-    const reference = references.find((reference) => reference.$id === schema.$ref)
-    if (reference === undefined) throw new ValueCastReferenceTypeError(schema)
-    return Visit(reference, references, value)
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+    if (index === -1) throw new ValueCastDereferenceError(schema)
+    const target = references[index]
+    return Visit(target, references, value)
   }
   function String(schema: Types.TString, references: Types.TSchema[], value: any): any {
-    const conversion = TryConvertString(value)
-    return ValueCheck.Check(schema, references, conversion) ? conversion : ValueCreate.Create(schema, references)
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+  }
+  function Symbol(schema: Types.TSymbol, references: Types.TSchema[], value: any): any {
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
   function Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): any {
     if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
@@ -323,61 +262,69 @@ export namespace ValueCast {
     return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
   export function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
-    const anyReferences = schema.$id === undefined ? references : [schema, ...references]
-    const anySchema = schema as any
+    const references_ = IsString(schema.$id) ? [...references, schema] : references
+    const schema_ = schema as any
     switch (schema[Types.Kind]) {
       case 'Any':
-        return Any(anySchema, anyReferences, value)
+        return Any(schema_, references_, value)
       case 'Array':
-        return Array(anySchema, anyReferences, value)
+        return Array(schema_, references_, value)
+      case 'BigInt':
+        return BigInt(schema_, references_, value)
       case 'Boolean':
-        return Boolean(anySchema, anyReferences, value)
+        return Boolean(schema_, references_, value)
       case 'Constructor':
-        return Constructor(anySchema, anyReferences, value)
+        return Constructor(schema_, references_, value)
       case 'Date':
-        return Date(anySchema, anyReferences, value)
+        return Date(schema_, references_, value)
       case 'Function':
-        return Function(anySchema, anyReferences, value)
+        return Function(schema_, references_, value)
       case 'Integer':
-        return Integer(anySchema, anyReferences, value)
+        return Integer(schema_, references_, value)
+      case 'Intersect':
+        return Intersect(schema_, references_, value)
       case 'Literal':
-        return Literal(anySchema, anyReferences, value)
+        return Literal(schema_, references_, value)
       case 'Never':
-        return Never(anySchema, anyReferences, value)
+        return Never(schema_, references_, value)
+      case 'Not':
+        return Not(schema_, references_, value)
       case 'Null':
-        return Null(anySchema, anyReferences, value)
+        return Null(schema_, references_, value)
       case 'Number':
-        return Number(anySchema, anyReferences, value)
+        return Number(schema_, references_, value)
       case 'Object':
-        return Object(anySchema, anyReferences, value)
+        return Object(schema_, references_, value)
       case 'Promise':
-        return Promise(anySchema, anyReferences, value)
+        return Promise(schema_, references_, value)
       case 'Record':
-        return Record(anySchema, anyReferences, value)
+        return Record(schema_, references_, value)
       case 'Ref':
-        return Ref(anySchema, anyReferences, value)
+        return Ref(schema_, references_, value)
       case 'Self':
-        return Self(anySchema, anyReferences, value)
+        return Self(schema_, references_, value)
       case 'String':
-        return String(anySchema, anyReferences, value)
+        return String(schema_, references_, value)
+      case 'Symbol':
+        return Symbol(schema_, references_, value)
       case 'Tuple':
-        return Tuple(anySchema, anyReferences, value)
+        return Tuple(schema_, references_, value)
       case 'Undefined':
-        return Undefined(anySchema, anyReferences, value)
+        return Undefined(schema_, references_, value)
       case 'Union':
-        return Union(anySchema, anyReferences, value)
+        return Union(schema_, references_, value)
       case 'Uint8Array':
-        return Uint8Array(anySchema, anyReferences, value)
+        return Uint8Array(schema_, references_, value)
       case 'Unknown':
-        return Unknown(anySchema, anyReferences, value)
+        return Unknown(schema_, references_, value)
       case 'Void':
-        return Void(anySchema, anyReferences, value)
+        return Void(schema_, references_, value)
       default:
-        if (!Custom.Has(anySchema[Types.Kind])) throw new ValueCastUnknownTypeError(anySchema)
-        return UserDefined(anySchema, anyReferences, value)
+        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueCastUnknownTypeError(schema_)
+        return UserDefined(schema_, references_, value)
     }
   }
-  export function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: any): Types.Static<T> {
-    return schema.$id === undefined ? Visit(schema, references, value) : Visit(schema, [schema, ...references], value)
+  export function Cast<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): Types.Static<T> {
+    return Visit(schema, references, ValueClone.Clone(value))
   }
 }
diff --git a/src/value/check.ts b/src/value/check.ts
index 6149cb7f6..15c06bbe8 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -28,156 +28,197 @@ THE SOFTWARE.
 
 import * as Types from '../typebox'
 import { TypeSystem } from '../system/index'
-import { TypeExtends } from '../guard/extends'
-import { Format } from '../format/index'
-import { Custom } from '../custom/index'
-import { ValueHash } from '../hash/index'
+import { ValueHash } from './hash'
 
+// -------------------------------------------------------------------------
+// Errors
+// -------------------------------------------------------------------------
 export class ValueCheckUnknownTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
     super(`ValueCheck: ${schema[Types.Kind] ? `Unknown type '${schema[Types.Kind]}'` : 'Unknown type'}`)
   }
 }
-
+export class ValueCheckDereferenceError extends Error {
+  constructor(public readonly schema: Types.TRef | Types.TSelf) {
+    super(`ValueCheck: Unable to dereference schema with $id '${schema.$ref}'`)
+  }
+}
 export namespace ValueCheck {
-  // --------------------------------------------------------
+  // ----------------------------------------------------------------------
   // Guards
-  // --------------------------------------------------------
-
+  // ----------------------------------------------------------------------
+  function IsObject(value: unknown): value is Record<keyof any, unknown> {
+    const result = typeof value === 'object' && value !== null
+    return TypeSystem.AllowArrayObjects ? result : result && !globalThis.Array.isArray(value)
+  }
+  function IsRecordObject(value: unknown): value is Record<keyof any, unknown> {
+    return IsObject(value) && !(value instanceof globalThis.Date) && !(value instanceof globalThis.Uint8Array)
+  }
+  function IsBigInt(value: unknown): value is bigint {
+    return typeof value === 'bigint'
+  }
   function IsNumber(value: unknown): value is number {
-    return typeof value === 'number' && !isNaN(value)
+    const result = typeof value === 'number'
+    return TypeSystem.AllowNaN ? result : result && globalThis.Number.isFinite(value)
   }
-
-  // --------------------------------------------------------
-  // Guards
-  // --------------------------------------------------------
-
+  function IsInteger(value: unknown): value is number {
+    return globalThis.Number.isInteger(value)
+  }
+  function IsString(value: unknown): value is string {
+    return typeof value === 'string'
+  }
+  function IsVoid(value: unknown): value is void {
+    const result = value === undefined
+    return TypeSystem.AllowVoidNull ? result || value === null : result
+  }
+  function IsDefined<T>(value: unknown): value is T {
+    return value !== undefined
+  }
+  // ----------------------------------------------------------------------
+  // Types
+  // ----------------------------------------------------------------------
   function Any(schema: Types.TAny, references: Types.TSchema[], value: any): boolean {
     return true
   }
-
   function Array(schema: Types.TArray, references: Types.TSchema[], value: any): boolean {
     if (!globalThis.Array.isArray(value)) {
       return false
     }
-    if (IsNumber(schema.minItems) && !(value.length >= schema.minItems)) {
+    if (IsDefined<number>(schema.minItems) && !(value.length >= schema.minItems)) {
       return false
     }
-    if (IsNumber(schema.maxItems) && !(value.length <= schema.maxItems)) {
+    if (IsDefined<number>(schema.maxItems) && !(value.length <= schema.maxItems)) {
       return false
     }
     // prettier-ignore
     if (schema.uniqueItems === true && !((function() { const set = new Set(); for(const element of value) { const hashed = ValueHash.Create(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())) {
       return false
     }
-    return value.every((val) => Visit(schema.items, references, val))
+    return value.every((value) => Visit(schema.items, references, value))
+  }
+  function BigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any): boolean {
+    if (!IsBigInt(value)) {
+      return false
+    }
+    if (IsDefined<bigint>(schema.multipleOf) && !(value % schema.multipleOf === globalThis.BigInt(0))) {
+      return false
+    }
+    if (IsDefined<bigint>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+      return false
+    }
+    if (IsDefined<bigint>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+      return false
+    }
+    if (IsDefined<bigint>(schema.minimum) && !(value >= schema.minimum)) {
+      return false
+    }
+    if (IsDefined<bigint>(schema.maximum) && !(value <= schema.maximum)) {
+      return false
+    }
+    return true
   }
-
   function Boolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): boolean {
     return typeof value === 'boolean'
   }
-
   function Constructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): boolean {
     return Visit(schema.returns, references, value.prototype)
   }
-
   function Date(schema: Types.TDate, references: Types.TSchema[], value: any): boolean {
     if (!(value instanceof globalThis.Date)) {
       return false
     }
-    if (isNaN(value.getTime())) {
+    if (!IsNumber(value.getTime())) {
       return false
     }
-    if (IsNumber(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
+    if (IsDefined<number>(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
       return false
     }
-    if (IsNumber(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+    if (IsDefined<number>(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
       return false
     }
-    if (IsNumber(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
+    if (IsDefined<number>(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
       return false
     }
-    if (IsNumber(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
+    if (IsDefined<number>(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
       return false
     }
     return true
   }
-
   function Function(schema: Types.TFunction, references: Types.TSchema[], value: any): boolean {
     return typeof value === 'function'
   }
-
   function Integer(schema: Types.TInteger, references: Types.TSchema[], value: any): boolean {
-    if (!(typeof value === 'number' && globalThis.Number.isInteger(value))) {
+    if (!IsInteger(value)) {
       return false
     }
-    if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
       return false
     }
-    if (IsNumber(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+    if (IsDefined<number>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
       return false
     }
-    if (IsNumber(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
       return false
     }
-    if (IsNumber(schema.minimum) && !(value >= schema.minimum)) {
+    if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
       return false
     }
-    if (IsNumber(schema.maximum) && !(value <= schema.maximum)) {
+    if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
       return false
     }
     return true
   }
-
+  function Intersect(schema: Types.TIntersect, references: Types.TSchema[], value: any): boolean {
+    if (!schema.allOf.every((schema) => Visit(schema, references, value))) {
+      return false
+    } else if (schema.unevaluatedProperties === false) {
+      const schemaKeys = Types.KeyResolver.Resolve(schema)
+      const valueKeys = globalThis.Object.getOwnPropertyNames(value)
+      return valueKeys.every((key) => schemaKeys.includes(key))
+    } else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
+      const schemaKeys = Types.KeyResolver.Resolve(schema)
+      const valueKeys = globalThis.Object.getOwnPropertyNames(value)
+      return valueKeys.every((key) => schemaKeys.includes(key) || Visit(schema.unevaluatedProperties as Types.TSchema, references, value[key]))
+    } else {
+      return true
+    }
+  }
   function Literal(schema: Types.TLiteral, references: Types.TSchema[], value: any): boolean {
     return value === schema.const
   }
-
   function Never(schema: Types.TNever, references: Types.TSchema[], value: any): boolean {
     return false
   }
-
+  function Not(schema: Types.TNot, references: Types.TSchema[], value: any): boolean {
+    return !Visit(schema.allOf[0].not, references, value) && Visit(schema.allOf[1], references, value)
+  }
   function Null(schema: Types.TNull, references: Types.TSchema[], value: any): boolean {
     return value === null
   }
-
   function Number(schema: Types.TNumber, references: Types.TSchema[], value: any): boolean {
-    if (TypeSystem.AllowNaN) {
-      if (!(typeof value === 'number')) {
-        return false
-      }
-    } else {
-      if (!(typeof value === 'number' && !isNaN(value))) {
-        return false
-      }
+    if (!IsNumber(value)) {
+      return false
     }
-    if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
       return false
     }
-    if (IsNumber(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+    if (IsDefined<number>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
       return false
     }
-    if (IsNumber(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
       return false
     }
-    if (IsNumber(schema.minimum) && !(value >= schema.minimum)) {
+    if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
       return false
     }
-    if (IsNumber(schema.maximum) && !(value <= schema.maximum)) {
+    if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
       return false
     }
     return true
   }
-
   function Object(schema: Types.TObject, references: Types.TSchema[], value: any): boolean {
-    if (TypeSystem.AllowArrayObjects) {
-      if (!(typeof value === 'object' && value !== null)) {
-        return false
-      }
-    } else {
-      if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-        return false
-      }
+    if (!IsObject(value)) {
+      return false
     }
     if (IsNumber(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
       return false
@@ -185,61 +226,43 @@ export namespace ValueCheck {
     if (IsNumber(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
       return false
     }
-    const propertyKeys = globalThis.Object.getOwnPropertyNames(schema.properties)
-    if (schema.additionalProperties === false) {
-      // optimization: If the property key length matches the required keys length
-      // then we only need check that the values property key length matches that
-      // of the property key length. This is because exhaustive testing for values
-      // will occur in subsequent property tests.
-      if (schema.required && schema.required.length === propertyKeys.length && !(globalThis.Object.getOwnPropertyNames(value).length === propertyKeys.length)) {
-        return false
-      } else {
-        if (!globalThis.Object.getOwnPropertyNames(value).every((key) => propertyKeys.includes(key))) {
+    const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties)
+    for (const knownKey of knownKeys) {
+      const property = schema.properties[knownKey]
+      if (schema.required && schema.required.includes(knownKey)) {
+        if (!Visit(property, references, value[knownKey])) {
           return false
         }
-      }
-    }
-    if (typeof schema.additionalProperties === 'object') {
-      for (const objectKey of globalThis.Object.getOwnPropertyNames(value)) {
-        if (propertyKeys.includes(objectKey)) continue
-        if (!Visit(schema.additionalProperties as Types.TSchema, references, value[objectKey])) {
+        if (Types.ExtendsUndefined.Check(property)) {
+          return knownKey in value
+        }
+      } else {
+        if (knownKey in value && !Visit(property, references, value[knownKey])) {
           return false
         }
       }
     }
-    for (const propertyKey of propertyKeys) {
-      const propertySchema = schema.properties[propertyKey]
-      if (schema.required && schema.required.includes(propertyKey)) {
-        if (!Visit(propertySchema, references, value[propertyKey])) {
-          return false
-        }
-        if (TypeExtends.Undefined(propertySchema)) {
-          return propertyKey in value
-        }
+    if (schema.additionalProperties === false) {
+      const valueKeys = globalThis.Object.getOwnPropertyNames(value)
+      // optimization: value is valid if schemaKey length matches the valueKey length
+      if (schema.required && schema.required.length === knownKeys.length && valueKeys.length === knownKeys.length) {
+        return true
       } else {
-        if (value[propertyKey] !== undefined) {
-          if (!Visit(propertySchema, references, value[propertyKey])) {
-            return false
-          }
-        }
+        return valueKeys.every((valueKey) => knownKeys.includes(valueKey))
       }
+    } else if (typeof schema.additionalProperties === 'object') {
+      const valueKeys = globalThis.Object.getOwnPropertyNames(value)
+      return valueKeys.every((key) => knownKeys.includes(key) || Visit(schema.additionalProperties as Types.TSchema, references, value[key]))
+    } else {
+      return true
     }
-    return true
   }
-
   function Promise(schema: Types.TPromise<any>, references: Types.TSchema[], value: any): boolean {
     return typeof value === 'object' && typeof value.then === 'function'
   }
-
   function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): boolean {
-    if (TypeSystem.AllowArrayObjects) {
-      if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date))) {
-        return false
-      }
-    } else {
-      if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date) && !globalThis.Array.isArray(value))) {
-        return false
-      }
+    if (!IsRecordObject(value)) {
+      return false
     }
     const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
     const regex = new RegExp(keyPattern)
@@ -251,41 +274,45 @@ export namespace ValueCheck {
     }
     return true
   }
-
   function Ref(schema: Types.TRef<any>, references: Types.TSchema[], value: any): boolean {
-    const reference = references.find((reference) => reference.$id === schema.$ref)
-    if (reference === undefined) throw new Error(`ValueCheck.Ref: Cannot find schema with $id '${schema.$ref}'.`)
-    return Visit(reference, references, value)
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+    if (index === -1) throw new ValueCheckDereferenceError(schema)
+    const target = references[index]
+    return Visit(target, references, value)
   }
-
   function Self(schema: Types.TSelf, references: Types.TSchema[], value: any): boolean {
-    const reference = references.find((reference) => reference.$id === schema.$ref)
-    if (reference === undefined) throw new Error(`ValueCheck.Self: Cannot find schema with $id '${schema.$ref}'.`)
-    return Visit(reference, references, value)
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+    if (index === -1) throw new ValueCheckDereferenceError(schema)
+    const target = references[index]
+    return Visit(target, references, value)
   }
-
   function String(schema: Types.TString, references: Types.TSchema[], value: any): boolean {
-    if (!(typeof value === 'string')) {
+    if (!IsString(value)) {
       return false
     }
-    if (IsNumber(schema.minLength)) {
+    if (IsDefined<number>(schema.minLength)) {
       if (!(value.length >= schema.minLength)) return false
     }
-    if (IsNumber(schema.maxLength)) {
+    if (IsDefined<number>(schema.maxLength)) {
       if (!(value.length <= schema.maxLength)) return false
     }
-    if (schema.pattern !== undefined) {
+    if (IsDefined<string>(schema.pattern)) {
       const regex = new RegExp(schema.pattern)
       if (!regex.test(value)) return false
     }
-    if (schema.format !== undefined) {
-      if (!Format.Has(schema.format)) return false
-      const func = Format.Get(schema.format)!
+    if (IsDefined<string>(schema.format)) {
+      if (!Types.FormatRegistry.Has(schema.format)) return false
+      const func = Types.FormatRegistry.Get(schema.format)!
       return func(value)
     }
     return true
   }
-
+  function Symbol(schema: Types.TSymbol, references: Types.TSchema[], value: any): boolean {
+    if (!(typeof value === 'symbol')) {
+      return false
+    }
+    return true
+  }
   function Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): boolean {
     if (!globalThis.Array.isArray(value)) {
       return false
@@ -304,103 +331,102 @@ export namespace ValueCheck {
     }
     return true
   }
-
   function Undefined(schema: Types.TUndefined, references: Types.TSchema[], value: any): boolean {
     return value === undefined
   }
-
   function Union(schema: Types.TUnion<any[]>, references: Types.TSchema[], value: any): boolean {
     return schema.anyOf.some((inner) => Visit(inner, references, value))
   }
-
   function Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): boolean {
     if (!(value instanceof globalThis.Uint8Array)) {
       return false
     }
-    if (IsNumber(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
+    if (IsDefined<number>(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
       return false
     }
-    if (IsNumber(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
+    if (IsDefined<number>(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
       return false
     }
     return true
   }
-
   function Unknown(schema: Types.TUnknown, references: Types.TSchema[], value: any): boolean {
     return true
   }
-
   function Void(schema: Types.TVoid, references: Types.TSchema[], value: any): boolean {
-    return value === null
+    return IsVoid(value)
   }
-
   function UserDefined(schema: Types.TSchema, references: Types.TSchema[], value: unknown): boolean {
-    if (!Custom.Has(schema[Types.Kind])) return false
-    const func = Custom.Get(schema[Types.Kind])!
+    if (!Types.TypeRegistry.Has(schema[Types.Kind])) return false
+    const func = Types.TypeRegistry.Get(schema[Types.Kind])!
     return func(schema, value)
   }
-
   function Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): boolean {
-    const anyReferences = schema.$id === undefined ? references : [schema, ...references]
-    const anySchema = schema as any
-    switch (anySchema[Types.Kind]) {
+    const references_ = IsDefined<string>(schema.$id) ? [...references, schema] : references
+    const schema_ = schema as any
+    switch (schema_[Types.Kind]) {
       case 'Any':
-        return Any(anySchema, anyReferences, value)
+        return Any(schema_, references_, value)
       case 'Array':
-        return Array(anySchema, anyReferences, value)
+        return Array(schema_, references_, value)
+      case 'BigInt':
+        return BigInt(schema_, references_, value)
       case 'Boolean':
-        return Boolean(anySchema, anyReferences, value)
+        return Boolean(schema_, references_, value)
       case 'Constructor':
-        return Constructor(anySchema, anyReferences, value)
+        return Constructor(schema_, references_, value)
       case 'Date':
-        return Date(anySchema, anyReferences, value)
+        return Date(schema_, references_, value)
       case 'Function':
-        return Function(anySchema, anyReferences, value)
+        return Function(schema_, references_, value)
       case 'Integer':
-        return Integer(anySchema, anyReferences, value)
+        return Integer(schema_, references_, value)
+      case 'Intersect':
+        return Intersect(schema_, references_, value)
       case 'Literal':
-        return Literal(anySchema, anyReferences, value)
+        return Literal(schema_, references_, value)
       case 'Never':
-        return Never(anySchema, anyReferences, value)
+        return Never(schema_, references_, value)
+      case 'Not':
+        return Not(schema_, references_, value)
       case 'Null':
-        return Null(anySchema, anyReferences, value)
+        return Null(schema_, references_, value)
       case 'Number':
-        return Number(anySchema, anyReferences, value)
+        return Number(schema_, references_, value)
       case 'Object':
-        return Object(anySchema, anyReferences, value)
+        return Object(schema_, references_, value)
       case 'Promise':
-        return Promise(anySchema, anyReferences, value)
+        return Promise(schema_, references_, value)
       case 'Record':
-        return Record(anySchema, anyReferences, value)
+        return Record(schema_, references_, value)
       case 'Ref':
-        return Ref(anySchema, anyReferences, value)
+        return Ref(schema_, references_, value)
       case 'Self':
-        return Self(anySchema, anyReferences, value)
+        return Self(schema_, references_, value)
       case 'String':
-        return String(anySchema, anyReferences, value)
+        return String(schema_, references_, value)
+      case 'Symbol':
+        return Symbol(schema_, references_, value)
       case 'Tuple':
-        return Tuple(anySchema, anyReferences, value)
+        return Tuple(schema_, references_, value)
       case 'Undefined':
-        return Undefined(anySchema, anyReferences, value)
+        return Undefined(schema_, references_, value)
       case 'Union':
-        return Union(anySchema, anyReferences, value)
+        return Union(schema_, references_, value)
       case 'Uint8Array':
-        return Uint8Array(anySchema, anyReferences, value)
+        return Uint8Array(schema_, references_, value)
       case 'Unknown':
-        return Unknown(anySchema, anyReferences, value)
+        return Unknown(schema_, references_, value)
       case 'Void':
-        return Void(anySchema, anyReferences, value)
+        return Void(schema_, references_, value)
       default:
-        if (!Custom.Has(anySchema[Types.Kind])) throw new ValueCheckUnknownTypeError(anySchema)
-        return UserDefined(anySchema, anyReferences, value)
+        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueCheckUnknownTypeError(schema_)
+        return UserDefined(schema_, references_, value)
     }
   }
-
   // -------------------------------------------------------------------------
   // Check
   // -------------------------------------------------------------------------
-
-  export function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: any): boolean {
-    return schema.$id === undefined ? Visit(schema, references, value) : Visit(schema, [schema, ...references], value)
+  export function Check<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): boolean {
+    return Visit(schema, references, value)
   }
 }
diff --git a/src/value/clone.ts b/src/value/clone.ts
index 82bf94b04..e8d3d2185 100644
--- a/src/value/clone.ts
+++ b/src/value/clone.ts
@@ -32,24 +32,19 @@ export namespace ValueClone {
   function Array(value: ArrayType): any {
     return value.map((element: any) => Clone(element))
   }
-
   function Date(value: Date): any {
     return new globalThis.Date(value.toISOString())
   }
-
   function Object(value: ObjectType): any {
     const keys = [...globalThis.Object.keys(value), ...globalThis.Object.getOwnPropertySymbols(value)]
     return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {})
   }
-
   function TypedArray(value: TypedArrayType): any {
     return value.slice()
   }
-
   function Value(value: ValueType): any {
     return value
   }
-
   export function Clone<T extends unknown>(value: T): T {
     if (Is.Date(value)) {
       return Date(value)
diff --git a/src/value/convert.ts b/src/value/convert.ts
new file mode 100644
index 000000000..987ef038e
--- /dev/null
+++ b/src/value/convert.ts
@@ -0,0 +1,342 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '../typebox'
+import { ValueClone } from './clone'
+
+// ----------------------------------------------------------------------------------------------
+// Errors
+// ----------------------------------------------------------------------------------------------
+export class ValueConvertUnknownTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('ValueConvert: Unknown type')
+  }
+}
+export class ValueConvertDereferenceError extends Error {
+  constructor(public readonly schema: Types.TRef | Types.TSelf) {
+    super(`ValueConvert: Unable to dereference schema with $id '${schema.$ref}'`)
+  }
+}
+export namespace ValueConvert {
+  // ----------------------------------------------------------------------------------------------
+  // Guards
+  // ----------------------------------------------------------------------------------------------
+  function IsObject(value: unknown): value is Record<keyof any, unknown> {
+    return typeof value === 'object' && value !== null && !globalThis.Array.isArray(value)
+  }
+  function IsArray(value: unknown): value is unknown[] {
+    return typeof value === 'object' && globalThis.Array.isArray(value)
+  }
+  function IsDate(value: unknown): value is Date {
+    return typeof value === 'object' && value instanceof globalThis.Date
+  }
+  function IsSymbol(value: unknown): value is symbol {
+    return typeof value === 'symbol'
+  }
+  function IsString(value: unknown): value is string {
+    return typeof value === 'string'
+  }
+  function IsBoolean(value: unknown): value is boolean {
+    return typeof value === 'boolean'
+  }
+  function IsBigInt(value: unknown): value is bigint {
+    return typeof value === 'bigint'
+  }
+  function IsNumber(value: unknown): value is number {
+    return typeof value === 'number' && !isNaN(value)
+  }
+  function IsStringNumeric(value: unknown): value is string {
+    return IsString(value) && !isNaN(value as any) && !isNaN(parseFloat(value))
+  }
+  function IsValueToString(value: unknown): value is { toString: () => string } {
+    return IsBigInt(value) || IsBoolean(value) || IsNumber(value)
+  }
+  function IsValueTrue(value: unknown): value is true {
+    return value === true || (IsNumber(value) && value === 1) || (IsBigInt(value) && value === globalThis.BigInt('1')) || (IsString(value) && (value.toLowerCase() === 'true' || value === '1'))
+  }
+  function IsValueFalse(value: unknown): value is true {
+    return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === globalThis.BigInt('0')) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'))
+  }
+  function IsTimeStringWithTimeZone(value: unknown): value is string {
+    return IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value)
+  }
+  function IsTimeStringWithoutTimeZone(value: unknown): value is string {
+    return IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value)
+  }
+  function IsDateTimeStringWithTimeZone(value: unknown): value is string {
+    return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value)
+  }
+  function IsDateTimeStringWithoutTimeZone(value: unknown): value is string {
+    return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value)
+  }
+  function IsDateString(value: unknown): value is string {
+    return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value)
+  }
+  // ----------------------------------------------------------------------------------------------
+  // Convert
+  // ----------------------------------------------------------------------------------------------
+  function TryConvertLiteralString(value: unknown, target: string) {
+    const conversion = TryConvertString(value)
+    return conversion === target ? conversion : value
+  }
+  function TryConvertLiteralNumber(value: unknown, target: number) {
+    const conversion = TryConvertNumber(value)
+    return conversion === target ? conversion : value
+  }
+  function TryConvertLiteralBoolean(value: unknown, target: boolean) {
+    const conversion = TryConvertBoolean(value)
+    return conversion === target ? conversion : value
+  }
+  function TryConvertLiteral(schema: Types.TLiteral, value: unknown) {
+    if (typeof schema.const === 'string') {
+      return TryConvertLiteralString(value, schema.const)
+    } else if (typeof schema.const === 'number') {
+      return TryConvertLiteralNumber(value, schema.const)
+    } else if (typeof schema.const === 'boolean') {
+      return TryConvertLiteralBoolean(value, schema.const)
+    } else {
+      return ValueClone.Clone(value)
+    }
+  }
+  function TryConvertBoolean(value: unknown) {
+    return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value
+  }
+  function TryConvertBigInt(value: unknown) {
+    return IsStringNumeric(value) ? globalThis.BigInt(parseInt(value)) : IsNumber(value) ? globalThis.BigInt(value | 0) : IsValueFalse(value) ? 0 : IsValueTrue(value) ? 1 : value
+  }
+
+  function TryConvertString(value: unknown) {
+    return IsValueToString(value) ? value.toString() : IsSymbol(value) && value.description !== undefined ? value.description.toString() : value
+  }
+  function TryConvertNumber(value: unknown) {
+    return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value
+  }
+  function TryConvertInteger(value: unknown) {
+    return IsStringNumeric(value) ? parseInt(value) : IsNumber(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value
+  }
+  function TryConvertNull(value: unknown) {
+    return IsString(value) && value.toLowerCase() === 'null' ? null : value
+  }
+  function TryConvertUndefined(value: unknown) {
+    return IsString(value) && value === 'undefined' ? undefined : value
+  }
+  function TryConvertDate(value: unknown) {
+    // note: this function may return an invalid dates for the regex tests
+    // above. Invalid dates will however be checked during the casting
+    // function and will return a epoch date if invalid. Consider better
+    // string parsing for the iso dates in future revisions.
+    return IsDate(value)
+      ? value
+      : IsNumber(value)
+      ? new globalThis.Date(value)
+      : IsValueTrue(value)
+      ? new globalThis.Date(1)
+      : IsValueFalse(value)
+      ? new globalThis.Date(0)
+      : IsStringNumeric(value)
+      ? new globalThis.Date(parseInt(value))
+      : IsTimeStringWithoutTimeZone(value)
+      ? new globalThis.Date(`1970-01-01T${value}.000Z`)
+      : IsTimeStringWithTimeZone(value)
+      ? new globalThis.Date(`1970-01-01T${value}`)
+      : IsDateTimeStringWithoutTimeZone(value)
+      ? new globalThis.Date(`${value}.000Z`)
+      : IsDateTimeStringWithTimeZone(value)
+      ? new globalThis.Date(value)
+      : IsDateString(value)
+      ? new globalThis.Date(`${value}T00:00:00.000Z`)
+      : value
+  }
+
+  // ----------------------------------------------------------------------------------------------
+  // Cast
+  // ----------------------------------------------------------------------------------------------
+  function Any(schema: Types.TAny, references: Types.TSchema[], value: any): any {
+    return value
+  }
+  function Array(schema: Types.TArray, references: Types.TSchema[], value: any): any {
+    if (IsArray(value)) {
+      return value.map((value) => Visit(schema.items, references, value))
+    }
+    return value
+  }
+  function BigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any): unknown {
+    return TryConvertBigInt(value)
+  }
+  function Boolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): unknown {
+    return TryConvertBoolean(value)
+  }
+  function Constructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): unknown {
+    return ValueClone.Clone(value)
+  }
+  function Date(schema: Types.TDate, references: Types.TSchema[], value: any): unknown {
+    return TryConvertDate(value)
+  }
+  function Function(schema: Types.TFunction, references: Types.TSchema[], value: any): unknown {
+    return value
+  }
+  function Integer(schema: Types.TInteger, references: Types.TSchema[], value: any): unknown {
+    return TryConvertInteger(value)
+  }
+  function Intersect(schema: Types.TIntersect, references: Types.TSchema[], value: any): unknown {
+    return value
+  }
+  function Literal(schema: Types.TLiteral, references: Types.TSchema[], value: any): unknown {
+    return TryConvertLiteral(schema, value)
+  }
+  function Never(schema: Types.TNever, references: Types.TSchema[], value: any): unknown {
+    return value
+  }
+  function Null(schema: Types.TNull, references: Types.TSchema[], value: any): unknown {
+    return TryConvertNull(value)
+  }
+  function Number(schema: Types.TNumber, references: Types.TSchema[], value: any): unknown {
+    return TryConvertNumber(value)
+  }
+  function Object(schema: Types.TObject, references: Types.TSchema[], value: any): unknown {
+    if (IsObject(value))
+      return globalThis.Object.keys(schema.properties).reduce((acc, key) => {
+        return value[key] !== undefined ? { ...acc, [key]: Visit(schema.properties[key], references, value[key]) } : { ...acc }
+      }, value)
+    return value
+  }
+  function Promise(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown {
+    return value
+  }
+  function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): unknown {
+    return value
+  }
+  function Ref(schema: Types.TRef<any>, references: Types.TSchema[], value: any): unknown {
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+    if (index === -1) throw new ValueConvertDereferenceError(schema)
+    const target = references[index]
+    return Visit(target, references, value)
+  }
+  function Self(schema: Types.TSelf, references: Types.TSchema[], value: any): unknown {
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+    if (index === -1) throw new ValueConvertDereferenceError(schema)
+    const target = references[index]
+    return Visit(target, references, value)
+  }
+  function String(schema: Types.TString, references: Types.TSchema[], value: any): unknown {
+    return TryConvertString(value)
+  }
+  function Symbol(schema: Types.TSymbol, references: Types.TSchema[], value: any): unknown {
+    return value
+  }
+  function Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): unknown {
+    if (IsArray(value) && schema.items !== undefined) {
+      return value.map((value, index) => {
+        return index < schema.items!.length ? Visit(schema.items![index], references, value) : value
+      })
+    }
+    return value
+  }
+  function Undefined(schema: Types.TUndefined, references: Types.TSchema[], value: any): unknown {
+    return TryConvertUndefined(value)
+  }
+  function Union(schema: Types.TUnion, references: Types.TSchema[], value: any): unknown {
+    return value
+  }
+  function Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): unknown {
+    return value
+  }
+  function Unknown(schema: Types.TUnknown, references: Types.TSchema[], value: any): unknown {
+    return value
+  }
+  function Void(schema: Types.TVoid, references: Types.TSchema[], value: any): unknown {
+    return value
+  }
+  function UserDefined(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown {
+    return value
+  }
+  export function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown {
+    const references_ = IsString(schema.$id) ? [...references, schema] : references
+    const schema_ = schema as any
+    switch (schema[Types.Kind]) {
+      case 'Any':
+        return Any(schema_, references_, value)
+      case 'Array':
+        return Array(schema_, references_, value)
+      case 'BigInt':
+        return BigInt(schema_, references_, value)
+      case 'Boolean':
+        return Boolean(schema_, references_, value)
+      case 'Constructor':
+        return Constructor(schema_, references_, value)
+      case 'Date':
+        return Date(schema_, references_, value)
+      case 'Function':
+        return Function(schema_, references_, value)
+      case 'Integer':
+        return Integer(schema_, references_, value)
+      case 'Intersect':
+        return Intersect(schema_, references_, value)
+      case 'Literal':
+        return Literal(schema_, references_, value)
+      case 'Never':
+        return Never(schema_, references_, value)
+      case 'Null':
+        return Null(schema_, references_, value)
+      case 'Number':
+        return Number(schema_, references_, value)
+      case 'Object':
+        return Object(schema_, references_, value)
+      case 'Promise':
+        return Promise(schema_, references_, value)
+      case 'Record':
+        return Record(schema_, references_, value)
+      case 'Ref':
+        return Ref(schema_, references_, value)
+      case 'Self':
+        return Self(schema_, references_, value)
+      case 'String':
+        return String(schema_, references_, value)
+      case 'Symbol':
+        return Symbol(schema_, references_, value)
+      case 'Tuple':
+        return Tuple(schema_, references_, value)
+      case 'Undefined':
+        return Undefined(schema_, references_, value)
+      case 'Union':
+        return Union(schema_, references_, value)
+      case 'Uint8Array':
+        return Uint8Array(schema_, references_, value)
+      case 'Unknown':
+        return Unknown(schema_, references_, value)
+      case 'Void':
+        return Void(schema_, references_, value)
+      default:
+        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueConvertUnknownTypeError(schema_)
+        return UserDefined(schema_, references_, value)
+    }
+  }
+  export function Convert<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): unknown {
+    return Visit(schema, references, ValueClone.Clone(value))
+  }
+}
diff --git a/src/value/create.ts b/src/value/create.ts
index 980d180d8..a2a0e1392 100644
--- a/src/value/create.ts
+++ b/src/value/create.ts
@@ -27,33 +27,55 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import * as Types from '../typebox'
-import { Custom } from '../custom/index'
+import { ValueCheck } from './check'
 
+// --------------------------------------------------------------------------
+// Errors
+// --------------------------------------------------------------------------
 export class ValueCreateUnknownTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
     super('ValueCreate: Unknown type')
   }
 }
-
 export class ValueCreateNeverTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
     super('ValueCreate: Never types cannot be created')
   }
 }
-
+export class ValueCreateIntersectTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('ValueCreate: Can only create values for intersected objects and non-varying primitive types. Consider using a default value.')
+  }
+}
+export class ValueCreateDereferenceError extends Error {
+  constructor(public readonly schema: Types.TRef | Types.TSelf) {
+    super(`ValueCreate: Unable to dereference schema with $id '${schema.$ref}'`)
+  }
+}
+// --------------------------------------------------------------------------
+// ValueCreate
+// --------------------------------------------------------------------------
 export namespace ValueCreate {
+  // --------------------------------------------------------
+  // Guards
+  // --------------------------------------------------------
+  function IsString(value: unknown): value is string {
+    return typeof value === 'string'
+  }
+  // --------------------------------------------------------
+  // Types
+  // --------------------------------------------------------
   function Any(schema: Types.TAny, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else {
       return {}
     }
   }
-
   function Array(schema: Types.TArray, references: Types.TSchema[]): any {
     if (schema.uniqueItems === true && schema.default === undefined) {
       throw new Error('ValueCreate.Array: Arrays with uniqueItems require a default value')
-    } else if (schema.default !== undefined) {
+    } else if ('default' in schema) {
       return schema.default
     } else if (schema.minItems !== undefined) {
       return globalThis.Array.from({ length: schema.minItems }).map((item) => {
@@ -63,17 +85,22 @@ export namespace ValueCreate {
       return []
     }
   }
-
+  function BigInt(schema: Types.TBigInt, references: Types.TSchema[]): any {
+    if ('default' in schema) {
+      return schema.default
+    } else {
+      return globalThis.BigInt(0)
+    }
+  }
   function Boolean(schema: Types.TBoolean, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else {
       return false
     }
   }
-
   function Constructor(schema: Types.TConstructor, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else {
       const value = ValueCreate.Create(schema.returns, references) as any
@@ -91,9 +118,8 @@ export namespace ValueCreate {
       }
     }
   }
-
   function Date(schema: Types.TDate, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else if (schema.minimumTimestamp !== undefined) {
       return new globalThis.Date(schema.minimumTimestamp)
@@ -101,17 +127,15 @@ export namespace ValueCreate {
       return new globalThis.Date(0)
     }
   }
-
   function Function(schema: Types.TFunction, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else {
       return () => ValueCreate.Create(schema.returns, references)
     }
   }
-
   function Integer(schema: Types.TInteger, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else if (schema.minimum !== undefined) {
       return schema.minimum
@@ -119,29 +143,41 @@ export namespace ValueCreate {
       return 0
     }
   }
-
+  function Intersect(schema: Types.TIntersect, references: Types.TSchema[]): any {
+    if ('default' in schema) {
+      return schema.default
+    } else {
+      const value = schema.type === 'object' ? schema.allOf.reduce((acc, schema) => ({ ...acc, ...(Visit(schema, references) as any) }), {}) : schema.allOf.reduce((_, schema) => Visit(schema, references), undefined as any)
+      if (!ValueCheck.Check(schema, references, value)) throw new ValueCreateIntersectTypeError(schema)
+      return value
+    }
+  }
   function Literal(schema: Types.TLiteral, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else {
       return schema.const
     }
   }
-
   function Never(schema: Types.TNever, references: Types.TSchema[]): any {
     throw new ValueCreateNeverTypeError(schema)
   }
-
+  function Not(schema: Types.TNot, references: Types.TSchema[]): any {
+    if ('default' in schema) {
+      return schema.default
+    } else {
+      return Visit(schema.allOf[1], references)
+    }
+  }
   function Null(schema: Types.TNull, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else {
       return null
     }
   }
-
   function Number(schema: Types.TNumber, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else if (schema.minimum !== undefined) {
       return schema.minimum
@@ -149,9 +185,8 @@ export namespace ValueCreate {
       return 0
     }
   }
-
   function Object(schema: Types.TObject, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else {
       const required = new Set(schema.required)
@@ -163,18 +198,16 @@ export namespace ValueCreate {
       )
     }
   }
-
   function Promise(schema: Types.TPromise<any>, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else {
       return globalThis.Promise.resolve(ValueCreate.Create(schema.item, references))
     }
   }
-
   function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[]): any {
     const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else if (!(keyPattern === '^.*$' || keyPattern === '^(0|[1-9][0-9]*)$')) {
       const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|')
@@ -185,42 +218,41 @@ export namespace ValueCreate {
       return {}
     }
   }
-
   function Ref(schema: Types.TRef<any>, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else {
-      const reference = references.find((reference) => reference.$id === schema.$ref)
-      if (reference === undefined) throw new Error(`ValueCreate.Ref: Cannot find schema with $id '${schema.$ref}'.`)
-      return Visit(reference, references)
+      const index = references.findIndex((foreign) => foreign.$id === schema.$id)
+      if (index === -1) throw new ValueCreateDereferenceError(schema)
+      const target = references[index]
+      return Visit(target, references)
     }
   }
-
   function Self(schema: Types.TSelf, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else {
-      const reference = references.find((reference) => reference.$id === schema.$ref)
-      if (reference === undefined) throw new Error(`ValueCreate.Self: Cannot locate schema with $id '${schema.$ref}'`)
-      return Visit(reference, references)
+      const index = references.findIndex((foreign) => foreign.$id === schema.$id)
+      if (index === -1) throw new ValueCreateDereferenceError(schema)
+      const target = references[index]
+      return Visit(target, references)
     }
   }
-
   function String(schema: Types.TString, references: Types.TSchema[]): any {
     if (schema.pattern !== undefined) {
-      if (schema.default === undefined) {
+      if (!('default' in schema)) {
         throw new Error('ValueCreate.String: String types with patterns must specify a default value')
       } else {
         return schema.default
       }
     } else if (schema.format !== undefined) {
-      if (schema.default === undefined) {
+      if (!('default' in schema)) {
         throw new Error('ValueCreate.String: String types with formats must specify a default value')
       } else {
         return schema.default
       }
     } else {
-      if (schema.default !== undefined) {
+      if ('default' in schema) {
         return schema.default
       } else if (schema.minLength !== undefined) {
         return globalThis.Array.from({ length: schema.minLength })
@@ -231,9 +263,17 @@ export namespace ValueCreate {
       }
     }
   }
-
+  function Symbol(schema: Types.TString, references: Types.TSchema[]): any {
+    if ('default' in schema) {
+      return schema.default
+    } else if ('value' in schema) {
+      return globalThis.Symbol.for(schema.value)
+    } else {
+      return globalThis.Symbol()
+    }
+  }
   function Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     }
     if (schema.items === undefined) {
@@ -242,17 +282,15 @@ export namespace ValueCreate {
       return globalThis.Array.from({ length: schema.minItems }).map((_, index) => ValueCreate.Create((schema.items as any[])[index], references))
     }
   }
-
   function Undefined(schema: Types.TUndefined, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else {
       return undefined
     }
   }
-
   function Union(schema: Types.TUnion<any[]>, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else if (schema.anyOf.length === 0) {
       throw new Error('ValueCreate.Union: Cannot create Union with zero variants')
@@ -261,7 +299,7 @@ export namespace ValueCreate {
     }
   }
   function Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else if (schema.minByteLength !== undefined) {
       return new globalThis.Uint8Array(schema.minByteLength)
@@ -269,90 +307,92 @@ export namespace ValueCreate {
       return new globalThis.Uint8Array(0)
     }
   }
-
   function Unknown(schema: Types.TUnknown, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else {
       return {}
     }
   }
-
   function Void(schema: Types.TVoid, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else {
-      return null
+      return void 0
     }
   }
-
   function UserDefined(schema: Types.TSchema, references: Types.TSchema[]): any {
-    if (schema.default !== undefined) {
+    if ('default' in schema) {
       return schema.default
     } else {
       throw new Error('ValueCreate.UserDefined: User defined types must specify a default value')
     }
   }
-
   /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
-  export function Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T> {
-    const anyReferences = schema.$id === undefined ? references : [schema, ...references]
-    const anySchema = schema as any
-
-    switch (anySchema[Types.Kind]) {
+  export function Visit(schema: Types.TSchema, references: Types.TSchema[]): unknown {
+    const references_ = IsString(schema.$id) ? [...references, schema] : references
+    const schema_ = schema as any
+    switch (schema_[Types.Kind]) {
       case 'Any':
-        return Any(anySchema, anyReferences)
+        return Any(schema_, references_)
       case 'Array':
-        return Array(anySchema, anyReferences)
+        return Array(schema_, references_)
+      case 'BigInt':
+        return BigInt(schema_, references_)
       case 'Boolean':
-        return Boolean(anySchema, anyReferences)
+        return Boolean(schema_, references_)
       case 'Constructor':
-        return Constructor(anySchema, anyReferences)
+        return Constructor(schema_, references_)
       case 'Date':
-        return Date(anySchema, anyReferences)
+        return Date(schema_, references_)
       case 'Function':
-        return Function(anySchema, anyReferences)
+        return Function(schema_, references_)
       case 'Integer':
-        return Integer(anySchema, anyReferences)
+        return Integer(schema_, references_)
+      case 'Intersect':
+        return Intersect(schema_, references_)
       case 'Literal':
-        return Literal(anySchema, anyReferences)
+        return Literal(schema_, references_)
       case 'Never':
-        return Never(anySchema, anyReferences)
+        return Never(schema_, references_)
+      case 'Not':
+        return Not(schema_, references_)
       case 'Null':
-        return Null(anySchema, anyReferences)
+        return Null(schema_, references_)
       case 'Number':
-        return Number(anySchema, anyReferences)
+        return Number(schema_, references_)
       case 'Object':
-        return Object(anySchema, anyReferences)
+        return Object(schema_, references_)
       case 'Promise':
-        return Promise(anySchema, anyReferences)
+        return Promise(schema_, references_)
       case 'Record':
-        return Record(anySchema, anyReferences)
+        return Record(schema_, references_)
       case 'Ref':
-        return Ref(anySchema, anyReferences)
+        return Ref(schema_, references_)
       case 'Self':
-        return Self(anySchema, anyReferences)
+        return Self(schema_, references_)
       case 'String':
-        return String(anySchema, anyReferences)
+        return String(schema_, references_)
+      case 'Symbol':
+        return Symbol(schema_, references_)
       case 'Tuple':
-        return Tuple(anySchema, anyReferences)
+        return Tuple(schema_, references_)
       case 'Undefined':
-        return Undefined(anySchema, anyReferences)
+        return Undefined(schema_, references_)
       case 'Union':
-        return Union(anySchema, anyReferences)
+        return Union(schema_, references_)
       case 'Uint8Array':
-        return Uint8Array(anySchema, anyReferences)
+        return Uint8Array(schema_, references_)
       case 'Unknown':
-        return Unknown(anySchema, anyReferences)
+        return Unknown(schema_, references_)
       case 'Void':
-        return Void(anySchema, anyReferences)
+        return Void(schema_, references_)
       default:
-        if (!Custom.Has(anySchema[Types.Kind])) throw new ValueCreateUnknownTypeError(anySchema)
-        return UserDefined(anySchema, anyReferences)
+        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueCreateUnknownTypeError(schema_)
+        return UserDefined(schema_, references_)
     }
   }
-
-  export function Create<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R]): Types.Static<T> {
+  export function Create<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T> {
     return Visit(schema, references)
   }
 }
diff --git a/src/value/equal.ts b/src/value/equal.ts
index 841cba47a..ba3e2424c 100644
--- a/src/value/equal.ts
+++ b/src/value/equal.ts
@@ -36,25 +36,20 @@ export namespace ValueEqual {
     if (leftKeys.length !== rightKeys.length) return false
     return leftKeys.every((key) => Equal(left[key], right[key]))
   }
-
   function Date(left: Date, right: unknown): any {
     return Is.Date(right) && left.getTime() === right.getTime()
   }
-
   function Array(left: ArrayType, right: unknown): any {
     if (!Is.Array(right) || left.length !== right.length) return false
     return left.every((value, index) => Equal(value, right[index]))
   }
-
   function TypedArray(left: TypedArrayType, right: unknown): any {
     if (!Is.TypedArray(right) || left.length !== right.length || globalThis.Object.getPrototypeOf(left).constructor.name !== globalThis.Object.getPrototypeOf(right).constructor.name) return false
     return left.every((value, index) => Equal(value, right[index]))
   }
-
   function Value(left: ValueType, right: unknown): any {
     return left === right
   }
-
   export function Equal<T>(left: T, right: unknown): right is T {
     if (Is.Object(left)) {
       return Object(left, right)
diff --git a/src/hash/hash.ts b/src/value/hash.ts
similarity index 83%
rename from src/hash/hash.ts
rename to src/value/hash.ts
index dbe5123a2..5231ecce3 100644
--- a/src/hash/hash.ts
+++ b/src/value/hash.ts
@@ -31,7 +31,6 @@ export class ValueHashError extends Error {
     super(`Hash: Unable to hash value`)
   }
 }
-
 export namespace ValueHash {
   enum ByteMarker {
     Undefined,
@@ -43,123 +42,122 @@ export namespace ValueHash {
     Array,
     Date,
     Uint8Array,
+    Symbol,
+    BigInt,
   }
 
   // ----------------------------------------------------
   // State
   // ----------------------------------------------------
-
   let Hash = globalThis.BigInt('14695981039346656037')
   const [Prime, Size] = [globalThis.BigInt('1099511628211'), globalThis.BigInt('2') ** globalThis.BigInt('64')]
   const Bytes = globalThis.Array.from({ length: 256 }).map((_, i) => globalThis.BigInt(i))
   const F64 = new globalThis.Float64Array(1)
   const F64In = new globalThis.DataView(F64.buffer)
   const F64Out = new globalThis.Uint8Array(F64.buffer)
-
   // ----------------------------------------------------
   // Guards
   // ----------------------------------------------------
-
   function IsDate(value: unknown): value is Date {
     return value instanceof globalThis.Date
   }
-
   function IsUint8Array(value: unknown): value is Uint8Array {
     return value instanceof globalThis.Uint8Array
   }
-
   function IsArray(value: unknown): value is Array<unknown> {
     return globalThis.Array.isArray(value)
   }
-
   function IsBoolean(value: unknown): value is boolean {
     return typeof value === 'boolean'
   }
-
   function IsNull(value: unknown): value is null {
     return value === null
   }
-
   function IsNumber(value: unknown): value is number {
     return typeof value === 'number'
   }
-
+  function IsSymbol(value: unknown): value is symbol {
+    return typeof value === 'symbol'
+  }
+  function IsBigInt(value: unknown): value is bigint {
+    return typeof value === 'bigint'
+  }
   function IsObject(value: unknown): value is Record<string, unknown> {
     return typeof value === 'object' && value !== null && !IsArray(value) && !IsDate(value) && !IsUint8Array(value)
   }
-
   function IsString(value: unknown): value is string {
     return typeof value === 'string'
   }
-
   function IsUndefined(value: unknown): value is undefined {
     return value === undefined
   }
-
   // ----------------------------------------------------
   // Encoding
   // ----------------------------------------------------
-
   function Array(value: Array<unknown>) {
-    Fnv1A64(ByteMarker.Array)
+    FNV1A64(ByteMarker.Array)
     for (const item of value) {
       Visit(item)
     }
   }
-
   function Boolean(value: boolean) {
-    Fnv1A64(ByteMarker.Boolean)
-    Fnv1A64(value ? 1 : 0)
+    FNV1A64(ByteMarker.Boolean)
+    FNV1A64(value ? 1 : 0)
+  }
+  function BigInt(value: bigint) {
+    FNV1A64(ByteMarker.BigInt)
+    F64In.setBigInt64(0, value)
+    for (const byte of F64Out) {
+      FNV1A64(byte)
+    }
   }
-
   function Date(value: Date) {
-    Fnv1A64(ByteMarker.Date)
+    FNV1A64(ByteMarker.Date)
     Visit(value.getTime())
   }
-
   function Null(value: null) {
-    Fnv1A64(ByteMarker.Null)
+    FNV1A64(ByteMarker.Null)
   }
-
   function Number(value: number) {
-    Fnv1A64(ByteMarker.Number)
+    FNV1A64(ByteMarker.Number)
     F64In.setFloat64(0, value)
     for (const byte of F64Out) {
-      Fnv1A64(byte)
+      FNV1A64(byte)
     }
   }
-
   function Object(value: Record<string, unknown>) {
-    Fnv1A64(ByteMarker.Object)
+    FNV1A64(ByteMarker.Object)
     for (const key of globalThis.Object.keys(value).sort()) {
       Visit(key)
       Visit(value[key])
     }
   }
-
   function String(value: string) {
-    Fnv1A64(ByteMarker.String)
+    FNV1A64(ByteMarker.String)
     for (let i = 0; i < value.length; i++) {
-      Fnv1A64(value.charCodeAt(i))
+      FNV1A64(value.charCodeAt(i))
     }
   }
-
+  function Symbol(value: symbol) {
+    FNV1A64(ByteMarker.Symbol)
+    Visit(value.description)
+  }
   function Uint8Array(value: Uint8Array) {
-    Fnv1A64(ByteMarker.Uint8Array)
+    FNV1A64(ByteMarker.Uint8Array)
     for (let i = 0; i < value.length; i++) {
-      Fnv1A64(value[i])
+      FNV1A64(value[i])
     }
   }
-
   function Undefined(value: undefined) {
-    return Fnv1A64(ByteMarker.Undefined)
+    return FNV1A64(ByteMarker.Undefined)
   }
-
   function Visit(value: any) {
     if (IsArray(value)) {
       Array(value)
     } else if (IsBoolean(value)) {
       Boolean(value)
+    } else if (IsBigInt(value)) {
+      BigInt(value)
     } else if (IsDate(value)) {
       Date(value)
     } else if (IsNull(value)) {
@@ -170,6 +168,8 @@ export namespace ValueHash {
       Object(value)
     } else if (IsString(value)) {
       String(value)
+    } else if (IsSymbol(value)) {
+      Symbol(value)
     } else if (IsUint8Array(value)) {
       Uint8Array(value)
     } else if (IsUndefined(value)) {
@@ -178,12 +178,10 @@ export namespace ValueHash {
       throw new ValueHashError(value)
     }
   }
-
-  function Fnv1A64(byte: number) {
+  function FNV1A64(byte: number) {
     Hash = Hash ^ Bytes[byte]
     Hash = (Hash * Prime) % Size
   }
-
   /** Creates a FNV1A-64 non cryptographic hash of the given value */
   export function Create(value: unknown) {
     Hash = globalThis.BigInt('14695981039346656037')
diff --git a/src/value/index.ts b/src/value/index.ts
index 5e48c738f..5598e30ab 100644
--- a/src/value/index.ts
+++ b/src/value/index.ts
@@ -26,7 +26,8 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export { ValueError, ValueErrorType } from '../errors/index'
+export { ValueError, ValueErrorIterator, ValueErrorType } from '../errors/index'
+export { ValueHash } from './hash'
 export { Edit, Insert, Update, Delete } from './delta'
 export * from './pointer'
 export * from './value'
diff --git a/src/value/value.ts b/src/value/value.ts
index 373005b7a..b76700865 100644
--- a/src/value/value.ts
+++ b/src/value/value.ts
@@ -27,11 +27,12 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import * as Types from '../typebox'
-import { ValueErrors, ValueError } from '../errors/index'
-import { ValueHash } from '../hash/index'
+import { ValueErrors, ValueErrorIterator, ValueError } from '../errors/index'
+import { ValueHash } from './hash'
 import { ValueEqual } from './equal'
 import { ValueCast } from './cast'
 import { ValueClone } from './clone'
+import { ValueConvert } from './convert'
 import { ValueCreate } from './create'
 import { ValueCheck } from './check'
 import { ValueDelta, Edit } from './delta'
@@ -46,7 +47,6 @@ export namespace Value {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
     return ValueCast.Cast(schema, references, value)
   }
-
   /** Creates a value from the given type */
   export function Create<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R]): Types.Static<T>
   /** Creates a value from the given type */
@@ -55,7 +55,6 @@ export namespace Value {
     const [schema, references] = args.length === 2 ? [args[0], args[1]] : [args[0], []]
     return ValueCreate.Create(schema, references)
   }
-
   /** Returns true if the value matches the given type. */
   export function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): value is Types.Static<T>
   /** Returns true if the value matches the given type. */
@@ -64,36 +63,38 @@ export namespace Value {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
     return ValueCheck.Check(schema, references, value)
   }
-
+  /** Converts any type mismatched values to their target type if a conversion is possible. */
+  export function Convert<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): unknown
+  /** Converts any type mismatched values to their target type if a conversion is possible. */
+  export function Convert<T extends Types.TSchema>(schema: T, value: unknown): unknown
+  export function Convert(...args: any[]) {
+    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
+    return ValueConvert.Convert(schema, references, value)
+  }
   /** Returns a structural clone of the given value */
   export function Clone<T>(value: T): T {
     return ValueClone.Clone(value)
   }
-
   /** Returns an iterator for each error in this value. */
-  export function Errors<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): IterableIterator<ValueError>
+  export function Errors<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): ValueErrorIterator
   /** Returns an iterator for each error in this value. */
-  export function Errors<T extends Types.TSchema>(schema: T, value: unknown): IterableIterator<ValueError>
-  export function* Errors(...args: any[]) {
+  export function Errors<T extends Types.TSchema>(schema: T, value: unknown): ValueErrorIterator
+  export function Errors(...args: any[]) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
-    yield* ValueErrors.Errors(schema, references, value)
+    return ValueErrors.Errors(schema, references, value) as ValueErrorIterator
   }
-
   /** Returns true if left and right values are structurally equal */
   export function Equal<T>(left: T, right: unknown): right is T {
     return ValueEqual.Equal(left, right)
   }
-
   /** Returns edits to transform the current value into the next value */
   export function Diff(current: unknown, next: unknown): Edit[] {
     return ValueDelta.Diff(current, next)
   }
-
   /** Returns a FNV1A-64 non cryptographic hash of the given value */
   export function Hash(value: unknown): bigint {
     return ValueHash.Create(value)
   }
-
   /** Returns a new value with edits applied to the given value */
   export function Patch<T = any>(current: unknown, edits: Edit[]): T {
     return ValueDelta.Patch(current, edits) as T
diff --git a/test/runtime/compiler/any.ts b/test/runtime/compiler/any.ts
index 7519db00f..949147d7f 100644
--- a/test/runtime/compiler/any.ts
+++ b/test/runtime/compiler/any.ts
@@ -30,4 +30,12 @@ describe('type/compiler/Any', () => {
     const T = Type.Any()
     Ok(T, undefined)
   })
+  it('Should validate bigint', () => {
+    const T = Type.Any()
+    Ok(T, BigInt(1))
+  })
+  it('Should validate symbol', () => {
+    const T = Type.Any()
+    Ok(T, Symbol(1))
+  })
 })
diff --git a/test/runtime/compiler/array.ts b/test/runtime/compiler/array.ts
index adff196f9..a2ccad658 100644
--- a/test/runtime/compiler/array.ts
+++ b/test/runtime/compiler/array.ts
@@ -39,10 +39,10 @@ describe('type/compiler/Array', () => {
     ])
   })
 
-  it('Should not validate for an array of intersection types when passing additionalProperties false', () => {
+  it('Should not validate for an array of composite types when passing additionalProperties false', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.String() })
-    const C = Type.Intersect([A, B], { additionalProperties: false })
+    const C = Type.Composite([A, B], { additionalProperties: false })
     const T = Type.Array(C)
     Fail(T, [
       { a: 'hello', b: 'hello' },
diff --git a/test/runtime/compiler/bigint.ts b/test/runtime/compiler/bigint.ts
new file mode 100644
index 000000000..484573395
--- /dev/null
+++ b/test/runtime/compiler/bigint.ts
@@ -0,0 +1,84 @@
+import { Type } from '@sinclair/typebox'
+import { Ok, Fail } from './validate'
+
+describe('type/compiler/BigInt', () => {
+  it('Should not validate number', () => {
+    const T = Type.BigInt()
+    Fail(T, 3.14)
+  })
+  it('Should not validate NaN', () => {
+    const T = Type.BigInt()
+    Fail(T, NaN)
+  })
+  it('Should not validate +Infinity', () => {
+    const T = Type.BigInt()
+    Fail(T, Infinity)
+  })
+  it('Should not validate -Infinity', () => {
+    const T = Type.BigInt()
+    Fail(T, -Infinity)
+  })
+  it('Should not validate integer', () => {
+    const T = Type.BigInt()
+    Fail(T, 1)
+  })
+  it('Should not validate string', () => {
+    const T = Type.BigInt()
+    Fail(T, 'hello')
+  })
+  it('Should not validate boolean', () => {
+    const T = Type.BigInt()
+    Fail(T, true)
+  })
+  it('Should not validate array', () => {
+    const T = Type.BigInt()
+    Fail(T, [1, 2, 3])
+  })
+  it('Should not validate object', () => {
+    const T = Type.BigInt()
+    Fail(T, { a: 1, b: 2 })
+  })
+  it('Should not validate null', () => {
+    const T = Type.BigInt()
+    Fail(T, null)
+  })
+  it('Should not validate undefined', () => {
+    const T = Type.BigInt()
+    Fail(T, undefined)
+  })
+  it('Should not validate symbol', () => {
+    const T = Type.BigInt()
+    Fail(T, Symbol())
+  })
+  it('Should validate bigint', () => {
+    const T = Type.BigInt()
+    Ok(T, BigInt(1))
+  })
+  it('Should validate minimum', () => {
+    const T = Type.BigInt({ minimum: BigInt(10) })
+    Fail(T, BigInt(9))
+    Ok(T, BigInt(10))
+  })
+
+  it('Should validate maximum', () => {
+    const T = Type.BigInt({ maximum: BigInt(10) })
+    Ok(T, BigInt(10))
+    Fail(T, BigInt(11))
+  })
+
+  it('Should validate Date exclusiveMinimum', () => {
+    const T = Type.BigInt({ exclusiveMinimum: BigInt(10) })
+    Fail(T, BigInt(10))
+    Ok(T, BigInt(11))
+  })
+
+  it('Should validate Date exclusiveMaximum', () => {
+    const T = Type.BigInt({ exclusiveMaximum: BigInt(10) })
+    Ok(T, BigInt(9))
+    Fail(T, BigInt(10))
+  })
+
+  it('Should not validate NaN', () => {
+    Fail(Type.Number(), NaN)
+  })
+})
diff --git a/test/runtime/compiler/boolean.ts b/test/runtime/compiler/boolean.ts
index c0d7997fb..03f01d890 100644
--- a/test/runtime/compiler/boolean.ts
+++ b/test/runtime/compiler/boolean.ts
@@ -37,4 +37,12 @@ describe('type/compiler/Boolean', () => {
     const T = Type.Boolean()
     Fail(T, undefined)
   })
+  it('Should not validate bigint', () => {
+    const T = Type.Boolean()
+    Fail(T, BigInt(1))
+  })
+  it('Should not validate symbol', () => {
+    const T = Type.Boolean()
+    Fail(T, Symbol(1))
+  })
 })
diff --git a/test/runtime/compiler/composite.ts b/test/runtime/compiler/composite.ts
new file mode 100644
index 000000000..5635e45fa
--- /dev/null
+++ b/test/runtime/compiler/composite.ts
@@ -0,0 +1,73 @@
+import { Type, Static } from '@sinclair/typebox'
+import { Ok, Fail } from './validate'
+
+describe('type/compiler/Composite', () => {
+  it('Should compose two objects', () => {
+    const A = Type.Object({ a: Type.String() })
+    const B = Type.Object({ b: Type.Number() })
+    const T = Type.Composite([A, B], { additionalProperties: false })
+    Ok(T, { a: 'hello', b: 42 })
+  })
+  it('Should compose with partial', () => {
+    const A = Type.Partial(Type.Object({ a: Type.Number() }))
+    const B = Type.Partial(Type.Object({ b: Type.Number() }))
+    const P = Type.Composite([A, B], { additionalProperties: false })
+    Ok(P, { a: 1, b: 2 })
+  })
+  it('Should compose with overlapping same type', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ a: Type.Number() })
+    const P = Type.Composite([A, B])
+    Ok(P, { a: 1 })
+    Fail(P, { a: 'hello' })
+    Fail(P, {})
+  })
+  it('Should compose with overlapping varying type', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ a: Type.String() })
+    const T = Type.Composite([A, B])
+    Ok(T, { a: 1 })
+    Ok(T, { a: 'hello' })
+    Fail(T, {})
+  })
+  it('Should compose with deeply nest overlapping varying type', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ a: Type.String() })
+    const C = Type.Object({ a: Type.Boolean() })
+    const D = Type.Object({ a: Type.Null() })
+    const T = Type.Composite([A, B, C, D])
+    Ok(T, { a: 1 })
+    Ok(T, { a: 'hello' })
+    Ok(T, { a: false })
+    Ok(T, { a: null })
+    Fail(T, { a: [] })
+    Fail(T, {})
+  })
+  it('Should pick from composited type', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const C = Type.Object({ z: Type.Number() })
+    const T = Type.Composite([A, B, C])
+    const P = Type.Pick(T, ['x', 'y'], { additionalProperties: false })
+    Ok(P, { x: 1, y: 1 })
+    Fail(P, { x: 1, y: 1, z: 1 })
+  })
+  it('Should omit from composited type', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const C = Type.Object({ z: Type.Number() })
+    const T = Type.Composite([A, B, C])
+    const P = Type.Omit(T, ['z'], { additionalProperties: false })
+    Ok(P, { x: 1, y: 1 })
+    Fail(P, { x: 1, y: 1, z: 1 })
+  })
+
+  it('Should compose nested object properties', () => {
+    const A = Type.Object({ x: Type.Object({ x: Type.Number() }) })
+    const B = Type.Object({ x: Type.Object({ x: Type.String() }) })
+    const T = Type.Composite([A, B])
+    Ok(T, { x: { x: 1 } })
+    Ok(T, { x: { x: 'hello' } })
+    Fail(T, { x: { x: false } })
+  })
+})
diff --git a/test/runtime/compiler/custom.ts b/test/runtime/compiler/custom.ts
index 4cba073d9..4380a9e82 100644
--- a/test/runtime/compiler/custom.ts
+++ b/test/runtime/compiler/custom.ts
@@ -1,10 +1,8 @@
-import { Custom } from '@sinclair/typebox/custom'
-import { Type, Kind } from '@sinclair/typebox'
+import { Type, Kind, TypeRegistry } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
 describe('type/compiler/Custom', () => {
-  Custom.Set('BigInt', (schema, value) => typeof value === 'bigint')
-
+  TypeRegistry.Set('BigInt', (schema, value) => typeof value === 'bigint')
   it('Should validate bigint', () => {
     const T = Type.Unsafe({ [Kind]: 'BigInt' })
     Ok(T, 1n)
diff --git a/test/runtime/compiler/date.ts b/test/runtime/compiler/date.ts
index 943bfa0e2..dfda22522 100644
--- a/test/runtime/compiler/date.ts
+++ b/test/runtime/compiler/date.ts
@@ -34,6 +34,14 @@ describe('type/compiler/Date', () => {
     const T = Type.Date()
     Ok(T, new Date())
   })
+  it('Should not validate bigint', () => {
+    const T = Type.Date()
+    Fail(T, BigInt(1))
+  })
+  it('Should not validate symbol', () => {
+    const T = Type.Date()
+    Fail(T, Symbol(1))
+  })
   it('Should not validate Date if is invalid', () => {
     const T = Type.Date()
     Fail(T, new Date('not-a-valid-date'))
diff --git a/test/runtime/compiler/index.ts b/test/runtime/compiler/index.ts
index a842d535a..d04e227f4 100644
--- a/test/runtime/compiler/index.ts
+++ b/test/runtime/compiler/index.ts
@@ -1,6 +1,8 @@
 import './any'
 import './array'
+import './bigint'
 import './boolean'
+import './composite'
 import './custom'
 import './date'
 import './unicode'
@@ -11,6 +13,7 @@ import './keyof'
 import './literal'
 import './modifier'
 import './never'
+import './not'
 import './null'
 import './number'
 import './object'
@@ -26,6 +29,7 @@ import './ref'
 import './regex'
 import './required'
 import './string'
+import './symbol'
 import './tuple'
 import './uint8array'
 import './union'
diff --git a/test/runtime/compiler/integer.ts b/test/runtime/compiler/integer.ts
index 1d3b85dbb..598aa04b4 100644
--- a/test/runtime/compiler/integer.ts
+++ b/test/runtime/compiler/integer.ts
@@ -6,7 +6,18 @@ describe('type/compiler/Integer', () => {
     const T = Type.Integer()
     Fail(T, 3.14)
   })
-
+  it('Should not validate NaN', () => {
+    const T = Type.Integer()
+    Fail(T, NaN)
+  })
+  it('Should not validate +Infinity', () => {
+    const T = Type.Integer()
+    Fail(T, Infinity)
+  })
+  it('Should not validate -Infinity', () => {
+    const T = Type.Integer()
+    Fail(T, -Infinity)
+  })
   it('Should validate integer', () => {
     const T = Type.Integer()
     Ok(T, 1)
@@ -40,7 +51,14 @@ describe('type/compiler/Integer', () => {
     const T = Type.Integer()
     Fail(T, undefined)
   })
-
+  it('Should not validate bigint', () => {
+    const T = Type.Integer()
+    Fail(T, BigInt(1))
+  })
+  it('Should not validate symbol', () => {
+    const T = Type.Integer()
+    Fail(T, Symbol(1))
+  })
   it('Should validate minimum', () => {
     const T = Type.Integer({ minimum: 10 })
     Fail(T, 9)
@@ -64,8 +82,4 @@ describe('type/compiler/Integer', () => {
     Ok(T, 9)
     Fail(T, 10)
   })
-
-  it('Should not validate NaN', () => {
-    Fail(Type.Integer(), NaN)
-  })
 })
diff --git a/test/runtime/compiler/intersect.ts b/test/runtime/compiler/intersect.ts
index 5cb524514..610dd7f30 100644
--- a/test/runtime/compiler/intersect.ts
+++ b/test/runtime/compiler/intersect.ts
@@ -2,82 +2,82 @@ import { Type, Static } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
 describe('type/compiler/Intersect', () => {
-  it('Should intersect two objects', () => {
-    const A = Type.Object({ a: Type.String() })
-    const B = Type.Object({ b: Type.Number() })
-    const T = Type.Intersect([A, B], { additionalProperties: false })
-    Ok(T, { a: 'hello', b: 42 })
+  it('Should intersect number and number', () => {
+    const A = Type.Number()
+    const B = Type.Number()
+    const T = Type.Intersect([A, B], {})
+    Ok(T, 1)
   })
-
-  it('Should intersect with partial', () => {
-    const A = Type.Partial(Type.Object({ a: Type.Number() }))
-    const B = Type.Partial(Type.Object({ b: Type.Number() }))
-    const P = Type.Intersect([A, B], { additionalProperties: false })
-    Ok(P, { a: 1, b: 2 })
-    // ok(P, { a: 1 })
-    // ok(P, { b: 1 })
-    // ok(P, {})
-    // fail(P, { c: 1 })
+  it('Should not intersect string and number', () => {
+    const A = Type.String()
+    const B = Type.Number()
+    const T = Type.Intersect([A, B], {})
+    Fail(T, 1)
+    Fail(T, '1')
   })
-
-  it('Should intersect with overlapping same type', () => {
-    const A = Type.Object({ a: Type.Number() })
-    const B = Type.Object({ a: Type.Number() })
-    const P = Type.Intersect([A, B])
-    Ok(P, { a: 1 })
-    Fail(P, { a: 'hello' })
-    Fail(P, {})
+  it('Should intersect two objects', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const T = Type.Intersect([A, B], {})
+    Ok(T, { x: 1, y: 1 })
   })
-
-  it('Should intersect with overlapping varying type', () => {
-    const A = Type.Object({ a: Type.Number() })
-    const B = Type.Object({ a: Type.String() })
-    const T = Type.Intersect([A, B])
-    Ok(T, { a: 1 })
-    Ok(T, { a: 'hello' })
-    Fail(T, {})
+  it('Should not intersect two objects with internal additionalProperties false', () => {
+    const A = Type.Object({ x: Type.Number() }, { additionalProperties: false })
+    const B = Type.Object({ y: Type.Number() }, { additionalProperties: false })
+    const T = Type.Intersect([A, B], {})
+    Fail(T, { x: 1, y: 1 })
   })
-
-  it('Should intersect with deeply nest overlapping varying type', () => {
-    const A = Type.Object({ a: Type.Number() })
-    const B = Type.Object({ a: Type.String() })
-    const C = Type.Object({ a: Type.Boolean() })
-    const D = Type.Object({ a: Type.Null() })
-    const T = Type.Intersect([A, B, C, D])
-    Ok(T, { a: 1 })
-    Ok(T, { a: 'hello' })
-    Ok(T, { a: false })
-    Ok(T, { a: null })
-    Fail(T, { a: [] })
-    Fail(T, {})
+  it('Should intersect two objects and mandate required properties', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const T = Type.Intersect([A, B], {})
+    Ok(T, { x: 1, y: 1 })
+    Fail(T, { x: 1 })
+    Fail(T, { y: 1 })
   })
-
-  it('Should pick from intersected type', () => {
+  it('Should intersect two objects with unevaluated properties', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ y: Type.Number() })
-    const C = Type.Object({ z: Type.Number() })
-    const T = Type.Intersect([A, B, C])
-    const P = Type.Pick(T, ['x', 'y'], { additionalProperties: false })
-    Ok(P, { x: 1, y: 1 })
-    Fail(P, { x: 1, y: 1, z: 1 })
+    const T = Type.Intersect([A, B], {})
+    Ok(T, { x: 1, y: 2, z: 1 })
   })
-
-  it('Should omit from intersected type', () => {
+  it('Should intersect two objects and restrict unevaluated properties', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ y: Type.Number() })
-    const C = Type.Object({ z: Type.Number() })
-    const T = Type.Intersect([A, B, C])
-    const P = Type.Omit(T, ['z'], { additionalProperties: false })
-    Ok(P, { x: 1, y: 1 })
-    Fail(P, { x: 1, y: 1, z: 1 })
+    const T = Type.Intersect([A, B], { unevaluatedProperties: false })
+    Fail(T, { x: 1, y: 2, z: 1 })
   })
-
-  it('Should intersect nested object properties', () => {
-    const A = Type.Object({ x: Type.Object({ x: Type.Number() }) })
-    const B = Type.Object({ x: Type.Object({ x: Type.String() }) })
+  it('Should intersect two objects and allow unevaluated properties of number', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const T = Type.Intersect([A, B], { unevaluatedProperties: Type.Number() })
+    Ok(T, { x: 1, y: 2, z: 3 })
+    Fail(T, { x: 1, y: 2, z: '1' })
+  })
+  it('Should intersect two union objects with overlapping properties of the same type', () => {
+    const A = Type.Union([Type.Object({ x: Type.Number() })])
+    const B = Type.Union([Type.Object({ x: Type.Number() })])
+    const T = Type.Intersect([A, B])
+    Ok(T, { x: 1 })
+    Fail(T, { x: '1' })
+  })
+  it('Should not intersect two union objects with overlapping properties of varying types', () => {
+    const A = Type.Union([Type.Object({ x: Type.Number() })])
+    const B = Type.Union([Type.Object({ x: Type.String() })])
+    const T = Type.Intersect([A, B])
+    Fail(T, { x: 1 })
+    Fail(T, { x: '1' })
+  })
+  it('Should intersect two union objects with non-overlapping properties', () => {
+    const A = Type.Union([Type.Object({ x: Type.Number() })])
+    const B = Type.Union([Type.Object({ y: Type.Number() })])
+    const T = Type.Intersect([A, B])
+    Ok(T, { x: 1, y: 1 })
+  })
+  it('Should not intersect two union objects with non-overlapping properties for additionalProperties false', () => {
+    const A = Type.Union([Type.Object({ x: Type.Number() }, { additionalProperties: false })])
+    const B = Type.Union([Type.Object({ y: Type.Number() }, { additionalProperties: false })])
     const T = Type.Intersect([A, B])
-    Ok(T, { x: { x: 1 } })
-    Ok(T, { x: { x: 'hello' } })
-    Fail(T, { x: { x: false } })
+    Fail(T, { x: 1, y: 1 })
   })
 })
diff --git a/test/runtime/compiler/literal.ts b/test/runtime/compiler/literal.ts
index a7251b789..ce81439d8 100644
--- a/test/runtime/compiler/literal.ts
+++ b/test/runtime/compiler/literal.ts
@@ -10,12 +10,10 @@ describe('type/compiler/Literal', () => {
     const T = Type.Literal('hello')
     Ok(T, 'hello')
   })
-
   it('Should validate literal boolean', () => {
     const T = Type.Literal(true)
     Ok(T, true)
   })
-
   it('Should not validate invalid literal number', () => {
     const T = Type.Literal(42)
     Fail(T, 43)
@@ -28,13 +26,11 @@ describe('type/compiler/Literal', () => {
     const T = Type.Literal(false)
     Fail(T, true)
   })
-
   it('Should validate literal union', () => {
     const T = Type.Union([Type.Literal(42), Type.Literal('hello')])
     Ok(T, 42)
     Ok(T, 'hello')
   })
-
   it('Should not validate invalid literal union', () => {
     const T = Type.Union([Type.Literal(42), Type.Literal('hello')])
     Fail(T, 43)
diff --git a/test/runtime/compiler/never.ts b/test/runtime/compiler/never.ts
index a19036774..6cc53bb93 100644
--- a/test/runtime/compiler/never.ts
+++ b/test/runtime/compiler/never.ts
@@ -6,17 +6,14 @@ describe('type/compiler/Never', () => {
     const T = Type.Never()
     Fail(T, 1)
   })
-
   it('Should not validate string', () => {
     const T = Type.Never()
     Fail(T, 'hello')
   })
-
   it('Should not validate boolean', () => {
     const T = Type.Never()
     Fail(T, true)
   })
-
   it('Should not validate array', () => {
     const T = Type.Never()
     Fail(T, [1, 2, 3])
@@ -33,4 +30,12 @@ describe('type/compiler/Never', () => {
     const T = Type.Never()
     Fail(T, undefined)
   })
+  it('Should not validate bigint', () => {
+    const T = Type.Never()
+    Fail(T, BigInt(1))
+  })
+  it('Should not validate symbol', () => {
+    const T = Type.Never()
+    Fail(T, Symbol(1))
+  })
 })
diff --git a/test/runtime/compiler/not.ts b/test/runtime/compiler/not.ts
new file mode 100644
index 000000000..27a07c5ba
--- /dev/null
+++ b/test/runtime/compiler/not.ts
@@ -0,0 +1,38 @@
+import { Type } from '@sinclair/typebox'
+import { Ok, Fail } from './validate'
+
+describe('type/compiler/Not', () => {
+  it('Should validate with not number', () => {
+    const T = Type.Not(Type.Number(), Type.String())
+    Fail(T, 1)
+    Ok(T, 'A')
+  })
+  it('Should validate with union left', () => {
+    // prettier-ignore
+    const T = Type.Not(Type.Union([
+      Type.Literal('A'), 
+      Type.Literal('B'), 
+      Type.Literal('C')
+    ]), Type.String())
+    Fail(T, 'A')
+    Fail(T, 'B')
+    Fail(T, 'C')
+    Ok(T, 'D')
+  })
+  it('Should validate with union right', () => {
+    // prettier-ignore
+    const T = Type.Not(Type.Number(), Type.Union([
+      Type.String(),
+      Type.Boolean()
+    ]))
+    Fail(T, 1)
+    Ok(T, 'A')
+    Ok(T, true)
+  })
+  it('Should not validate with symmetric left right', () => {
+    // prettier-ignore
+    const T = Type.Not(Type.Number(), Type.Number())
+    Fail(T, 1)
+    Fail(T, true) // not a number, but not a number either?
+  })
+})
diff --git a/test/runtime/compiler/null.ts b/test/runtime/compiler/null.ts
index 1253ea64a..fcc8257fa 100644
--- a/test/runtime/compiler/null.ts
+++ b/test/runtime/compiler/null.ts
@@ -6,34 +6,36 @@ describe('type/compiler/Null', () => {
     const T = Type.Null()
     Fail(T, 1)
   })
-
   it('Should not validate string', () => {
     const T = Type.Null()
     Fail(T, 'hello')
   })
-
   it('Should not validate boolean', () => {
     const T = Type.Null()
     Fail(T, true)
   })
-
   it('Should not validate array', () => {
     const T = Type.Null()
     Fail(T, [1, 2, 3])
   })
-
   it('Should not validate object', () => {
     const T = Type.Null()
     Fail(T, { a: 1, b: 2 })
   })
-
   it('Should not validate null', () => {
     const T = Type.Null()
     Ok(T, null)
   })
-
   it('Should not validate undefined', () => {
     const T = Type.Null()
     Fail(T, undefined)
   })
+  it('Should not validate bigint', () => {
+    const T = Type.Null()
+    Fail(T, BigInt(1))
+  })
+  it('Should not validate symbol', () => {
+    const T = Type.Null()
+    Fail(T, Symbol(1))
+  })
 })
diff --git a/test/runtime/compiler/number.ts b/test/runtime/compiler/number.ts
index 90a229f64..59081b8e3 100644
--- a/test/runtime/compiler/number.ts
+++ b/test/runtime/compiler/number.ts
@@ -6,12 +6,22 @@ describe('type/compiler/Number', () => {
     const T = Type.Number()
     Ok(T, 3.14)
   })
-
+  it('Should not validate NaN', () => {
+    const T = Type.Number()
+    Fail(T, NaN)
+  })
+  it('Should not validate +Infinity', () => {
+    const T = Type.Number()
+    Fail(T, Infinity)
+  })
+  it('Should not validate -Infinity', () => {
+    const T = Type.Number()
+    Fail(T, -Infinity)
+  })
   it('Should validate integer', () => {
     const T = Type.Number()
     Ok(T, 1)
   })
-
   it('Should not validate string', () => {
     const T = Type.Number()
     Fail(T, 'hello')
@@ -36,32 +46,32 @@ describe('type/compiler/Number', () => {
     const T = Type.Number()
     Fail(T, undefined)
   })
-
+  it('Should not validate bigint', () => {
+    const T = Type.Number()
+    Fail(T, BigInt(1))
+  })
+  it('Should not validate symbol', () => {
+    const T = Type.Number()
+    Fail(T, Symbol(1))
+  })
   it('Should validate minimum', () => {
     const T = Type.Number({ minimum: 10 })
     Fail(T, 9)
     Ok(T, 10)
   })
-
   it('Should validate maximum', () => {
     const T = Type.Number({ maximum: 10 })
     Ok(T, 10)
     Fail(T, 11)
   })
-
   it('Should validate Date exclusiveMinimum', () => {
     const T = Type.Number({ exclusiveMinimum: 10 })
     Fail(T, 10)
     Ok(T, 11)
   })
-
   it('Should validate Date exclusiveMaximum', () => {
     const T = Type.Number({ exclusiveMaximum: 10 })
     Ok(T, 9)
     Fail(T, 10)
   })
-
-  it('Should not validate NaN', () => {
-    Fail(Type.Number(), NaN)
-  })
 })
diff --git a/test/runtime/compiler/object.ts b/test/runtime/compiler/object.ts
index 5a4bbe1e7..699b533b0 100644
--- a/test/runtime/compiler/object.ts
+++ b/test/runtime/compiler/object.ts
@@ -6,27 +6,34 @@ describe('type/compiler/Object', () => {
     const T = Type.Object({})
     Fail(T, 42)
   })
-
   it('Should not validate a string', () => {
     const T = Type.Object({})
     Fail(T, 'hello')
   })
-
   it('Should not validate a boolean', () => {
     const T = Type.Object({})
     Fail(T, true)
   })
-
   it('Should not validate a null', () => {
     const T = Type.Object({})
     Fail(T, null)
   })
-
+  it('Should not validate undefined', () => {
+    const T = Type.Object({})
+    Fail(T, undefined)
+  })
+  it('Should not validate bigint', () => {
+    const T = Type.Object({})
+    Fail(T, BigInt(1))
+  })
+  it('Should not validate symbol', () => {
+    const T = Type.Object({})
+    Fail(T, Symbol(1))
+  })
   it('Should not validate an array', () => {
     const T = Type.Object({})
     Fail(T, [1, 2])
   })
-
   it('Should validate with correct property values', () => {
     const T = Type.Object({
       a: Type.Number(),
@@ -43,7 +50,6 @@ describe('type/compiler/Object', () => {
       e: { x: 10, y: 20 },
     })
   })
-
   it('Should not validate with incorrect property values', () => {
     const T = Type.Object({
       a: Type.Number(),
@@ -60,7 +66,6 @@ describe('type/compiler/Object', () => {
       e: { x: 10, y: 20 },
     })
   })
-
   it('Should allow additionalProperties by default', () => {
     const T = Type.Object({
       a: Type.Number(),
@@ -72,7 +77,6 @@ describe('type/compiler/Object', () => {
       c: true,
     })
   })
-
   it('Should not allow an empty object if minProperties is set to 1', () => {
     const T = Type.Object(
       {
@@ -85,7 +89,6 @@ describe('type/compiler/Object', () => {
     Ok(T, { b: 'hello' })
     Fail(T, {})
   })
-
   it('Should not allow 3 properties if maxProperties is set to 2', () => {
     const T = Type.Object(
       {
@@ -103,7 +106,6 @@ describe('type/compiler/Object', () => {
       c: true,
     })
   })
-
   it('Should not allow additionalProperties if additionalProperties is false', () => {
     const T = Type.Object(
       {
@@ -118,7 +120,6 @@ describe('type/compiler/Object', () => {
       c: true,
     })
   })
-
   it('Should not allow properties for an empty object when additionalProperties is false', () => {
     const T = Type.Object({}, { additionalProperties: false })
     Ok(T, {})
@@ -139,7 +140,6 @@ describe('type/compiler/Object', () => {
       '!@#$%^&*(': 4,
     })
   })
-
   it('Should validate schema additional properties of string', () => {
     const T = Type.Object(
       {
@@ -227,4 +227,16 @@ describe('type/compiler/Object', () => {
     Ok(T, { x: undefined })
     Ok(T, {})
   })
+  it('Should not check undefined for optional property of number', () => {
+    const T = Type.Object({ x: Type.Optional(Type.Number()) })
+    Ok(T, { x: 1 })
+    Ok(T, {})
+    Fail(T, { x: undefined })
+  })
+  it('Should check undefined for optional property of undefined', () => {
+    const T = Type.Object({ x: Type.Optional(Type.Undefined()) })
+    Fail(T, { x: 1 })
+    Ok(T, {})
+    Ok(T, { x: undefined })
+  })
 })
diff --git a/test/runtime/compiler/omit.ts b/test/runtime/compiler/omit.ts
index 42634995f..9d4ed2723 100644
--- a/test/runtime/compiler/omit.ts
+++ b/test/runtime/compiler/omit.ts
@@ -57,4 +57,30 @@ describe('type/compiler/Omit', () => {
     Ok(T, { z: 0 })
     Fail(T, { x: 0, y: 0, z: 0 })
   })
+  it('Should support Omit of Literal', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Omit(A, Type.Literal('x'))
+    Ok(T, { y: 1, z: 1 })
+    Fail(T, { x: 1, y: 1, z: 1 })
+  })
+  it('Should support Omit of Never', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Omit(A, Type.Never())
+    Fail(T, { y: 1, z: 1 })
+    Ok(T, { x: 1, y: 1, z: 1 })
+  })
 })
diff --git a/test/runtime/compiler/pick.ts b/test/runtime/compiler/pick.ts
index e6c9eb805..dd8f234b6 100644
--- a/test/runtime/compiler/pick.ts
+++ b/test/runtime/compiler/pick.ts
@@ -57,4 +57,30 @@ describe('type/compiler/Pick', () => {
     Ok(T, { x: 0, y: 0 })
     Fail(T, { x: 0, y: 0, z: 0 })
   })
+  it('Should support Pick of Literal', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Pick(A, Type.Literal('x'))
+    Ok(T, { x: 1 })
+    Fail(T, { x: 1, y: 1, z: 1 })
+  })
+  it('Should support Pick of Never', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { additionalProperties: false },
+    )
+    const T = Type.Pick(A, Type.Never())
+    Fail(T, { x: 1, y: 1, z: 1 })
+    Ok(T, {})
+  })
 })
diff --git a/test/runtime/compiler/record.ts b/test/runtime/compiler/record.ts
index d73a14848..d12e65daa 100644
--- a/test/runtime/compiler/record.ts
+++ b/test/runtime/compiler/record.ts
@@ -136,4 +136,12 @@ describe('type/compiler/Record', () => {
     const T = Type.Record(Type.Number(), Type.Number())
     Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
+  it('Should fail record with Date', () => {
+    const T = Type.Record(Type.String(), Type.String())
+    Fail(T, new Date())
+  })
+  it('Should fail record with Uint8Array', () => {
+    const T = Type.Record(Type.String(), Type.String())
+    Fail(T, new Uint8Array())
+  })
 })
diff --git a/test/runtime/compiler/ref.ts b/test/runtime/compiler/ref.ts
index 632ac0fe7..ef23a872e 100644
--- a/test/runtime/compiler/ref.ts
+++ b/test/runtime/compiler/ref.ts
@@ -45,26 +45,38 @@ describe('type/compiler/Ref', () => {
   })
 
   it('Should de-reference object property schema', () => {
-    const R = Type.Object(
+    const T = Type.Object(
       {
         name: Type.String(),
       },
       { $id: 'R' },
     )
 
-    const T = Type.Object(
+    const R = Type.Object(
       {
         x: Type.Number(),
         y: Type.Number(),
         z: Type.Number(),
-        r: Type.Optional(Type.Ref(R)),
+        r: Type.Optional(Type.Ref(T)),
       },
       { $id: 'T' },
     )
 
-    Ok(T, { x: 1, y: 2, z: 3 }, [R])
-    Ok(T, { x: 1, y: 2, z: 3, r: { name: 'hello' } }, [R])
-    Fail(T, { x: 1, y: 2, z: 3, r: { name: 1 } }, [R])
-    Fail(T, { x: 1, y: 2, z: 3, r: {} }, [R])
+    Ok(R, { x: 1, y: 2, z: 3 }, [T])
+    Ok(R, { x: 1, y: 2, z: 3, r: { name: 'hello' } }, [T])
+    Fail(R, { x: 1, y: 2, z: 3, r: { name: 1 } }, [T])
+    Fail(R, { x: 1, y: 2, z: 3, r: {} }, [T])
+  })
+
+  it('Should reference recursive schema', () => {
+    const T = Type.Recursive((Node) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(Node),
+      }),
+    )
+    const R = Type.Ref(T)
+    Ok(R, { id: '', nodes: [{ id: '', nodes: [] }] }, [T])
+    Fail(R, { id: '', nodes: [{ id: 1, nodes: [] }] }, [T])
   })
 })
diff --git a/test/runtime/compiler/string.ts b/test/runtime/compiler/string.ts
index baff1e18e..0f43dc025 100644
--- a/test/runtime/compiler/string.ts
+++ b/test/runtime/compiler/string.ts
@@ -30,7 +30,14 @@ describe('type/compiler/String', () => {
     const T = Type.String()
     Fail(T, undefined)
   })
-
+  it('Should not validate bigint', () => {
+    const T = Type.String()
+    Fail(T, BigInt(1))
+  })
+  it('Should not validate symbol', () => {
+    const T = Type.String()
+    Fail(T, Symbol(1))
+  })
   it('Should validate string format as email', () => {
     const T = Type.String({ format: 'email' })
     Ok(T, 'name@domain.com')
diff --git a/test/runtime/compiler/symbol.ts b/test/runtime/compiler/symbol.ts
new file mode 100644
index 000000000..fcca5a548
--- /dev/null
+++ b/test/runtime/compiler/symbol.ts
@@ -0,0 +1,42 @@
+import { Type } from '@sinclair/typebox'
+import { Ok, Fail } from './validate'
+
+describe('type/compiler/Symbol', () => {
+  it('Should not validate a boolean', () => {
+    const T = Type.Symbol()
+    Fail(T, true)
+    Fail(T, false)
+  })
+  it('Should not validate a number', () => {
+    const T = Type.Symbol()
+    Fail(T, 1)
+  })
+  it('Should not validate a string', () => {
+    const T = Type.Symbol()
+    Fail(T, 'true')
+  })
+  it('Should not validate an array', () => {
+    const T = Type.Symbol()
+    Fail(T, [true])
+  })
+  it('Should not validate an object', () => {
+    const T = Type.Symbol()
+    Fail(T, {})
+  })
+  it('Should not validate an null', () => {
+    const T = Type.Symbol()
+    Fail(T, null)
+  })
+  it('Should not validate an undefined', () => {
+    const T = Type.Symbol()
+    Fail(T, undefined)
+  })
+  it('Should not validate bigint', () => {
+    const T = Type.Symbol()
+    Fail(T, BigInt(1))
+  })
+  it('Should not validate symbol', () => {
+    const T = Type.Symbol()
+    Ok(T, Symbol(1))
+  })
+})
diff --git a/test/runtime/compiler/validate.ts b/test/runtime/compiler/validate.ts
index c242768a3..070d6092b 100644
--- a/test/runtime/compiler/validate.ts
+++ b/test/runtime/compiler/validate.ts
@@ -1,7 +1,6 @@
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 import { Value } from '@sinclair/typebox/value'
-import { TSchema } from '@sinclair/typebox'
-import { Format } from 'src/format'
+import { TSchema, FormatRegistry } from '@sinclair/typebox'
 
 // -------------------------------------------------------------------------
 // Test Formats: https://github.com/ajv-validator/ajv-formats/blob/master/src/formats.ts
@@ -59,9 +58,9 @@ function isDateTime(str: string, strictTimeZone?: boolean): boolean {
 // Use Formats
 // -------------------------------------------------------------------------
 
-Format.Set('email', (value) => EMAIL.test(value))
-Format.Set('uuid', (value) => UUID.test(value))
-Format.Set('date-time', (value) => isDateTime(value, true))
+FormatRegistry.Set('email', (value) => EMAIL.test(value))
+FormatRegistry.Set('uuid', (value) => UUID.test(value))
+FormatRegistry.Set('date-time', (value) => isDateTime(value, true))
 
 export function Ok<T extends TSchema>(schema: T, data: unknown, references: any[] = []) {
   const C = TypeCompiler.Compile(schema, references)
diff --git a/test/runtime/compiler/void.ts b/test/runtime/compiler/void.ts
index a5e80992e..4963c0e4e 100644
--- a/test/runtime/compiler/void.ts
+++ b/test/runtime/compiler/void.ts
@@ -6,34 +6,32 @@ describe('type/compiler/Void', () => {
     const T = Type.Void()
     Fail(T, 1)
   })
-
   it('Should not validate string', () => {
     const T = Type.Void()
     Fail(T, 'hello')
   })
-
   it('Should not validate boolean', () => {
     const T = Type.Void()
     Fail(T, true)
   })
-
   it('Should not validate array', () => {
     const T = Type.Void()
     Fail(T, [1, 2, 3])
   })
-
   it('Should not validate object', () => {
     const T = Type.Void()
     Fail(T, { a: 1, b: 2 })
   })
-
   it('Should validate null', () => {
-    const T = Type.Null()
-    Ok(T, null)
+    const T = Type.Void()
+    Fail(T, null)
   })
-
-  it('Should not validate undefined', () => {
+  it('Should validate undefined', () => {
+    const T = Type.Void()
+    Ok(T, undefined)
+  })
+  it('Should validate void 0', () => {
     const T = Type.Void()
-    Fail(T, undefined)
+    Ok(T, void 0)
   })
 })
diff --git a/test/runtime/conditional/any.ts b/test/runtime/conditional/any.ts
deleted file mode 100644
index b450886d9..000000000
--- a/test/runtime/conditional/any.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Any', () => {
-  it('Should extend Any', () => {
-    type T = any extends any ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-  it('Should extend Unknown', () => {
-    type T = any extends unknown ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = any extends string ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.String())
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-  it('Should extend Boolean', () => {
-    type T = any extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-  it('Should extend Number', () => {
-    type T = any extends number ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Number())
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-  it('Should extend Integer', () => {
-    type T = any extends number ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-  it('Should extend Array 1', () => {
-    type T = any extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-  it('Should extend Array 2', () => {
-    type T = any extends Array<string> ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Array(Type.String()))
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-  it('Should extend Tuple', () => {
-    type T = any extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-  it('Should extend Object 1', () => {
-    type T = any extends object ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-  it('Should extend Object 2', () => {
-    type T = any extends {} ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-  it('Should extend Object 3', () => {
-    type T = any extends { a: number } ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Object({ a: Type.Number() }))
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-  it('Should extend Union 1', () => {
-    type T = any extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-  it('Should extend Union 2', () => {
-    type T = any extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Union([Type.Any(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-  it('Should extend Null', () => {
-    type T = any extends null ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Null())
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-  it('Should extend Undefined', () => {
-    type T = any extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-  it('Should extend Void', () => {
-    type T = any extends void ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Void())
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-
-  it('Should extend Date', () => {
-    type T = any extends Date ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Date())
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-})
diff --git a/test/runtime/conditional/array.ts b/test/runtime/conditional/array.ts
deleted file mode 100644
index f9ca50ab3..000000000
--- a/test/runtime/conditional/array.ts
+++ /dev/null
@@ -1,316 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Array', () => {
-  // ----------------------------------------------
-  // Generic Varying
-  // ----------------------------------------------
-
-  it('Should extend Array Varying 1', () => {
-    type T = Array<any> extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Array Varying 2', () => {
-    type T = Array<string> extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Array Varying 3', () => {
-    type T = Array<any> extends Array<string> ? 1 : 2 // 1
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Array(Type.String()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Array Varying 4', () => {
-    type T = Array<number> extends Array<string> ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Number()), Type.Array(Type.String()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  // ----------------------------------------------
-  // Any
-  // ----------------------------------------------
-  it('Should extend Any', () => {
-    type T = Array<any> extends any ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Unknown', () => {
-    type T = Array<any> extends unknown ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = Array<any> extends string ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = Array<any> extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number', () => {
-    type T = Array<any> extends number ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer', () => {
-    type T = Array<any> extends number ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array 1', () => {
-    type T = Array<any> extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Array 2', () => {
-    type T = Array<string> extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Array 3', () => {
-    type T = Array<any> extends Array<string> ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Tuple', () => {
-    type T = Array<any> extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = Array<any> extends object ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = Array<any> extends {} ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = Array<any> extends { a: number } ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Object({ a: Type.Number() }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 4', () => {
-    type T = Array<any> extends { length: '1' } ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Object({ length: Type.Literal('1') }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 5', () => {
-    type T = Array<any> extends { length: number } ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Object({ length: Type.Number() }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = Array<any> extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = Array<any> extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 3', () => {
-    type T = Array<any> extends any | Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 4', () => {
-    type T = Array<string> extends any | Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 5', () => {
-    type T = Array<any> extends any | Array<string> ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Array(Type.String())]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Null', () => {
-    type T = Array<any> extends null ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined', () => {
-    type T = Array<any> extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.Any()), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  // ----------------------------------------------
-  // Constrained
-  // ----------------------------------------------
-
-  it('Should extend constrained Any', () => {
-    type T = Array<string> extends any ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained Unknown', () => {
-    type T = Array<string> extends unknown ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained String', () => {
-    type T = Array<string> extends string ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Boolean', () => {
-    type T = Array<string> extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Number', () => {
-    type T = Array<string> extends number ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Integer', () => {
-    type T = Array<string> extends number ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Array 1', () => {
-    type T = Array<string> extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained Array 2', () => {
-    type T = Array<string> extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained Array 3', () => {
-    type T = Array<string> extends Array<string> ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained Tuple', () => {
-    type T = Array<string> extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Object 1', () => {
-    type T = Array<string> extends object ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained Object 2', () => {
-    type T = Array<string> extends {} ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained Object 3', () => {
-    type T = Array<string> extends { a: number } ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Object({ a: Type.Number() }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Object 4', () => {
-    type T = Array<string> extends { length: '1' } ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Object({ length: Type.Literal('1') }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Object 5', () => {
-    type T = Array<string> extends { length: number } ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Object({ length: Type.Number() }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained Union 1', () => {
-    type T = Array<string> extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Union([Type.Null(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Union 2', () => {
-    type T = Array<string> extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Union([Type.Any(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained Union 3', () => {
-    type T = Array<string> extends any | Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained Union 4', () => {
-    type T = Array<string> extends any | Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained Union 5', () => {
-    type T = Array<string> extends any | Array<string> ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.String())]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained Null', () => {
-    type T = Array<string> extends null ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Undefined', () => {
-    type T = Array<string> extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Void', () => {
-    type T = Array<string> extends void ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date', () => {
-    type T = Array<string> extends Date ? 1 : 2
-    const R = Structural.Check(Type.Array(Type.String()), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/conditional/boolean.ts b/test/runtime/conditional/boolean.ts
deleted file mode 100644
index 4699a972b..000000000
--- a/test/runtime/conditional/boolean.ts
+++ /dev/null
@@ -1,113 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Boolean', () => {
-  it('Should extend Any', () => {
-    type T = boolean extends any ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = boolean extends string ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = boolean extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Number', () => {
-    type T = boolean extends number ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer', () => {
-    type T = boolean extends number ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array', () => {
-    type T = boolean extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple', () => {
-    type T = boolean extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record', () => {
-    type T = boolean extends Record<number, any> ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = boolean extends {} ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = boolean extends { a: 10 } ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = boolean extends object ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = boolean extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = boolean extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = boolean extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Null', () => {
-    type T = boolean extends null ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined', () => {
-    type T = boolean extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void', () => {
-    type T = boolean extends void ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date', () => {
-    type T = boolean extends Date ? 1 : 2
-    const R = Structural.Check(Type.Boolean(), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/conditional/constructor.ts b/test/runtime/conditional/constructor.ts
deleted file mode 100644
index 38cd73be6..000000000
--- a/test/runtime/conditional/constructor.ts
+++ /dev/null
@@ -1,250 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Constructor', () => {
-  it('Should extend Function', () => {
-    type T = (new () => number) extends () => number ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Function([], Type.Number()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Constructor 1', () => {
-    type T = (new () => number) extends new () => number ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Number()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Constructor 2', () => {
-    type T = (new () => any) extends new () => number ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Constructor 3', () => {
-    type T = (new () => number) extends new () => any ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Constructor 4', () => {
-    type T = (new (a: number) => number) extends new () => any ? 1 : 2
-    const R = Structural.Check(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([], Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Constructor 5', () => {
-    type T = (new (a: number | string) => number) extends new (a: number) => number ? 1 : 2
-    const R = Structural.Check(Type.Constructor([Type.Union([Type.Number(), Type.String()])], Type.Number()), Type.Constructor([Type.Number()], Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Constructor 6', () => {
-    type T = (new (a: number) => number) extends new (a: number | string) => any ? 1 : 2
-    const R = Structural.Check(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([Type.Union([Type.Number(), Type.String()])], Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Constructor 7', () => {
-    type T = (new (a: number, b: number) => number) extends new (a: number) => number ? 1 : 2
-    const R = Structural.Check(Type.Constructor([Type.Number(), Type.Number()], Type.Number()), Type.Constructor([Type.Number()], Type.Number()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Constructor 8', () => {
-    type T = (new (a: number) => number) extends new (a: number, b: number) => number ? 1 : 2
-    const R = Structural.Check(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([Type.Number(), Type.Number()], Type.Number()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Constructor 9', () => {
-    type T = (new () => number) extends new () => any ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Constructor 9', () => {
-    type T = (new () => any) extends new () => number ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Constructor 10', () => {
-    type T = (new () => Array<any>) extends new () => object ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Array(Type.Any())), Type.Constructor([], Type.Object({})))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-  it('Should extend Constructor 11', () => {
-    type T = (new () => Array<string>) extends new () => object ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Array(Type.String())), Type.Constructor([], Type.Object({})))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Constructor 12', () => {
-    type T = (new () => object) extends new () => Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Object({})), Type.Constructor([], Type.Array(Type.Any())))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Constructor 13', () => {
-    type T = (new (a: unknown) => number) extends new (a: any) => number ? 1 : 2
-    const R = Structural.Check(Type.Constructor([Type.Unknown()], Type.Number({})), Type.Constructor([Type.Any()], Type.Number({})))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Constructor 14', () => {
-    type T = (new (a: any) => number) extends new (a: unknown) => number ? 1 : 2
-    const R = Structural.Check(Type.Constructor([Type.Any()], Type.Number({})), Type.Constructor([Type.Unknown()], Type.Number({})))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Constructor 15', () => {
-    type T = (new () => any) extends new () => unknown ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Any({})), Type.Constructor([], Type.Unknown({})))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Constructor 16', () => {
-    type T = (new () => unknown) extends new () => any ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Unknown({})), Type.Constructor([], Type.Any({})))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Any', () => {
-    type T = (new () => number) extends any ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = (new () => number) extends string ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = (new () => number) extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number', () => {
-    type T = (new () => number) extends number ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer', () => {
-    type T = (new () => number) extends number ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array 1', () => {
-    type T = (new () => number) extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array 2', () => {
-    type T = (new () => number) extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array 3', () => {
-    type T = (new () => number) extends Array<string> ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple', () => {
-    type T = (new () => number) extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record', () => {
-    type T = (() => number) extends Record<number, any> ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = (new () => number) extends object ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = (new () => number) extends {} ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = (new () => number) extends { a: number } ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Object({ a: Type.Number() }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 4', () => {
-    type T = (new () => number) extends { length: '1' } ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Object({ length: Type.Literal('1') }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = (new () => number) extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Union([Type.Null(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = (new () => number) extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 3', () => {
-    type T = (new () => number) extends any | Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 4', () => {
-    type T = (new () => number) extends any | Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 5', () => {
-    type T = (new () => number) extends any | Array<string> ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.String())]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Null', () => {
-    type T = (new () => number) extends null ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined', () => {
-    type T = (new () => number) extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void', () => {
-    type T = (new () => number) extends void ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date', () => {
-    type T = (new () => number) extends Date ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/conditional/date.ts b/test/runtime/conditional/date.ts
deleted file mode 100644
index 29920d23a..000000000
--- a/test/runtime/conditional/date.ts
+++ /dev/null
@@ -1,118 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Date', () => {
-  it('Should extend Any', () => {
-    type T = Date extends any ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Unknown', () => {
-    type T = Date extends unknown ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = Date extends string ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = Date extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number', () => {
-    type T = Date extends number ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer', () => {
-    type T = Date extends number ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array', () => {
-    type T = Date extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-  it('Should extend Tuple', () => {
-    type T = Date extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record', () => {
-    type T = Date extends Record<number, any> ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = Date extends {} ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = Date extends { a: 10 } ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = Date extends object ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = Date extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = Date extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 3', () => {
-    type T = Date extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Null', () => {
-    type T = Date extends null ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined', () => {
-    type T = Date extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void', () => {
-    type T = Date extends void ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date', () => {
-    type T = Date extends Date ? 1 : 2
-    const R = Structural.Check(Type.Date(), Type.Date())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-})
diff --git a/test/runtime/conditional/function.ts b/test/runtime/conditional/function.ts
deleted file mode 100644
index 64eb9f080..000000000
--- a/test/runtime/conditional/function.ts
+++ /dev/null
@@ -1,251 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Function', () => {
-  it('Should extend Constructor 1', () => {
-    type T = (() => number) extends new () => number ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Constructor([], Type.Number()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Function 1', () => {
-    type T = (() => number) extends () => number ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Function([], Type.Number()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Function 2', () => {
-    type T = (() => any) extends () => number ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Function 3', () => {
-    type T = (() => number) extends () => any ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Function 4', () => {
-    type T = ((a: number) => number) extends () => any ? 1 : 2
-    const R = Structural.Check(Type.Function([Type.Number()], Type.Number()), Type.Function([], Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Function 5', () => {
-    type T = ((a: number | string) => number) extends (a: number) => number ? 1 : 2
-    const R = Structural.Check(Type.Function([Type.Union([Type.Number(), Type.String()])], Type.Number()), Type.Function([Type.Number()], Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Function 6', () => {
-    type T = ((a: number) => number) extends (a: number | string) => any ? 1 : 2
-    const R = Structural.Check(Type.Function([Type.Number()], Type.Number()), Type.Function([Type.Union([Type.Number(), Type.String()])], Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Function 7', () => {
-    type T = ((a: number, b: number) => number) extends (a: number) => number ? 1 : 2
-    const R = Structural.Check(Type.Function([Type.Number(), Type.Number()], Type.Number()), Type.Function([Type.Number()], Type.Number()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Function 8', () => {
-    type T = ((a: number) => number) extends (a: number, b: number) => number ? 1 : 2
-    const R = Structural.Check(Type.Function([Type.Number()], Type.Number()), Type.Function([Type.Number(), Type.Number()], Type.Number()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Function 9', () => {
-    type T = (() => number) extends () => any ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Function([], Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Function 9', () => {
-    type T = (() => any) extends () => number ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Function 10', () => {
-    type T = (() => Array<any>) extends () => object ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Array(Type.Any())), Type.Function([], Type.Object({})))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Function 11', () => {
-    type T = (() => Array<string>) extends () => object ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Array(Type.String())), Type.Function([], Type.Object({})))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Function 12', () => {
-    type T = (() => object) extends () => Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Object({})), Type.Function([], Type.Array(Type.Any())))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Function 13', () => {
-    type T = ((a: unknown) => number) extends (a: any) => number ? 1 : 2
-    const R = Structural.Check(Type.Function([Type.Unknown()], Type.Number({})), Type.Function([Type.Any()], Type.Number({})))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Function 14', () => {
-    type T = ((a: any) => number) extends (a: unknown) => number ? 1 : 2
-    const R = Structural.Check(Type.Function([Type.Any()], Type.Number({})), Type.Function([Type.Unknown()], Type.Number({})))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Function 15', () => {
-    type T = (() => any) extends () => unknown ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Any({})), Type.Function([], Type.Unknown({})))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Function 16', () => {
-    type T = (() => unknown) extends () => any ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Unknown({})), Type.Function([], Type.Any({})))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Any', () => {
-    type T = (() => number) extends any ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = (() => number) extends string ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = (() => number) extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number', () => {
-    type T = (() => number) extends number ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer', () => {
-    type T = (() => number) extends number ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array 1', () => {
-    type T = (() => number) extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array 2', () => {
-    type T = (() => number) extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array 3', () => {
-    type T = (() => number) extends Array<string> ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple', () => {
-    type T = (() => number) extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record', () => {
-    type T = (() => number) extends Record<number, any> ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = (() => number) extends object ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = (() => number) extends {} ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = (() => number) extends { a: number } ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Object({ a: Type.Number() }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 4', () => {
-    type T = (() => number) extends { length: '1' } ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Object({ length: Type.Literal('1') }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 5', () => {
-    type T = (() => number) extends { length: number } ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Object({ length: Type.Number() }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = (() => number) extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Union([Type.Null(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = (() => number) extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 3', () => {
-    type T = (() => number) extends any | Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 4', () => {
-    type T = (() => number) extends any | Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 5', () => {
-    type T = (() => number) extends any | Array<string> ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.String())]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Null', () => {
-    type T = (() => number) extends null ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void', () => {
-    type T = (() => number) extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Function([], Type.Number()), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date', () => {
-    type T = (() => number) extends Date ? 1 : 2
-    const R = Structural.Check(Type.Constructor([], Type.Number()), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/conditional/integer.ts b/test/runtime/conditional/integer.ts
deleted file mode 100644
index 78b1bca8e..000000000
--- a/test/runtime/conditional/integer.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Integer', () => {
-  it('Should extend Any', () => {
-    type T = number extends any ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Unknown', () => {
-    type T = number extends unknown ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = number extends string ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = number extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number', () => {
-    type T = number extends number ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Number())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Integer', () => {
-    type T = number extends number ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Array', () => {
-    type T = number extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple', () => {
-    type T = number extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record', () => {
-    type T = number extends Record<number, any> ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = number extends {} ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = number extends { a: 10 } ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = number extends object ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = number extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = number extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = number extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Null', () => {
-    type T = number extends null ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined', () => {
-    type T = number extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void', () => {
-    type T = number extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Integer(), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date', () => {
-    type T = number extends Date ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/conditional/literal.ts b/test/runtime/conditional/literal.ts
deleted file mode 100644
index a699ebf42..000000000
--- a/test/runtime/conditional/literal.ts
+++ /dev/null
@@ -1,330 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Literal', () => {
-  // -------------------------------------------------------------------
-  // String Literal
-  // -------------------------------------------------------------------
-  it('Should extend Any (String)', () => {
-    type T = 'hello' extends any ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Unknown (String)', () => {
-    type T = 'hello' extends unknown ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String (String)', () => {
-    type T = 'hello' extends string ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.String())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Boolean (String)', () => {
-    type T = 'hello' extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number (String)', () => {
-    type T = 'hello' extends number ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer (String)', () => {
-    type T = 'hello' extends number ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array (String)', () => {
-    type T = 'hello' extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-  it('Should extend Tuple (String)', () => {
-    type T = 'hello' extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-  it('Should extend Object 1 (String)', () => {
-    type T = 'hello' extends {} ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 2 (String)', () => {
-    type T = 'hello' extends { a: 10 } ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3 (String)', () => {
-    type T = 'hello' extends object ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 1 (String)', () => {
-    type T = 'hello' extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 2 (String)', () => {
-    type T = 'hello' extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 3 (String)', () => {
-    type T = 'hello' extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Null (String)', () => {
-    type T = 'hello' extends null ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined (String)', () => {
-    type T = 'hello' extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  // -------------------------------------------------------------------
-  // Number Literal
-  // -------------------------------------------------------------------
-
-  it('Should extend Any (Number)', () => {
-    type T = 10 extends any ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Unknown (Number)', () => {
-    type T = 10 extends unknown ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String (Number)', () => {
-    type T = 10 extends string ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean (Number)', () => {
-    type T = 10 extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number (Number)', () => {
-    type T = 10 extends number ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.Number())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Integer (Number)', () => {
-    type T = 10 extends number ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Array (Number)', () => {
-    type T = 10 extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-  it('Should extend Tuple (Number)', () => {
-    type T = 10 extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-  it('Should extend Object 1 (Number)', () => {
-    type T = 10 extends {} ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 2 (Number)', () => {
-    type T = 10 extends { a: 10 } ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3 (Number)', () => {
-    type T = 10 extends object ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 1 (Number)', () => {
-    type T = 10 extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 2 (Number)', () => {
-    type T = 10 extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 3 (Number)', () => {
-    type T = 10 extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Null (Number)', () => {
-    type T = 10 extends null ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined (Number)', () => {
-    type T = 10 extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  // -------------------------------------------------------------------
-  // Boolean Literal
-  // -------------------------------------------------------------------
-
-  it('Should extend Any (Boolean)', () => {
-    type T = true extends any ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Unknown (Boolean)', () => {
-    type T = true extends unknown ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String (Boolean)', () => {
-    type T = true extends string ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean (Boolean)', () => {
-    type T = true extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Number (Boolean)', () => {
-    type T = true extends number ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer (Boolean)', () => {
-    type T = true extends number ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array (Boolean)', () => {
-    type T = true extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple (Boolean)', () => {
-    type T = true extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record 1', () => {
-    type T = 'hello' extends Record<number, any> ? 1 : 2
-    const R = Structural.Check(Type.Literal('hello'), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Record 2', () => {
-    type T = 10 extends Record<number, any> ? 1 : 2
-    const R = Structural.Check(Type.Literal(10), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record 3', () => {
-    type T = true extends Record<number, any> ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1 (Boolean)', () => {
-    type T = true extends {} ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 2 (Boolean)', () => {
-    type T = true extends { a: 10 } ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3 (Boolean)', () => {
-    type T = true extends object ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 1 (Boolean)', () => {
-    type T = true extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 2 (Boolean)', () => {
-    type T = true extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 3 (Boolean)', () => {
-    type T = true extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Null (Boolean)', () => {
-    type T = true extends null ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined (Boolean)', () => {
-    type T = true extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void', () => {
-    type T = true extends void ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date', () => {
-    type T = true extends Date ? 1 : 2
-    const R = Structural.Check(Type.Literal(true), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/conditional/null.ts b/test/runtime/conditional/null.ts
deleted file mode 100644
index 1b1fc9661..000000000
--- a/test/runtime/conditional/null.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Null', () => {
-  it('Should extend Any', () => {
-    type T = null extends any ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Unknown', () => {
-    type T = null extends unknown ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = null extends string ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = null extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number', () => {
-    type T = null extends number ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer', () => {
-    type T = null extends number ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array', () => {
-    type T = null extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple', () => {
-    type T = null extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record', () => {
-    type T = null extends Record<number, any> ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = null extends {} ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = null extends { a: 10 } ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = null extends object ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = null extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = null extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = null extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Null', () => {
-    type T = null extends null ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Null())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Undefined', () => {
-    type T = null extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void', () => {
-    type T = null extends void ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date', () => {
-    type T = null extends Date ? 1 : 2
-    const R = Structural.Check(Type.Null(), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/conditional/number.ts b/test/runtime/conditional/number.ts
deleted file mode 100644
index 7cb136f35..000000000
--- a/test/runtime/conditional/number.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Number', () => {
-  it('Should extend Any', () => {
-    type T = number extends any ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Unknown', () => {
-    type T = number extends unknown ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = number extends string ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = number extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number', () => {
-    type T = number extends number ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Number())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Integer', () => {
-    type T = number extends number ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Array', () => {
-    type T = number extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple', () => {
-    type T = number extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record', () => {
-    type T = number extends Record<number, any> ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = number extends {} ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = number extends { a: 10 } ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = number extends object ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = number extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = number extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = number extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Null', () => {
-    type T = number extends null ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined', () => {
-    type T = number extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void', () => {
-    type T = number extends void ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date', () => {
-    type T = number extends Date ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/conditional/object.ts b/test/runtime/conditional/object.ts
deleted file mode 100644
index fb327cc40..000000000
--- a/test/runtime/conditional/object.ts
+++ /dev/null
@@ -1,161 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Object', () => {
-  // ----------------------------------------------------------
-  // Record
-  // ----------------------------------------------------------
-
-  it('Should extend Record 1', () => {
-    type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
-    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
-    const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Record 2', () => {
-    type T = { a: number; b: number } extends Record<string, number> ? 1 : 2
-    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
-    const B = Type.Record(Type.String(), Type.Number())
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Record 3', () => {
-    type T = { a: number; b: number } extends Record<number, number> ? 1 : 2
-    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
-    const B = Type.Record(Type.Number(), Type.Number())
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Record 4', () => {
-    type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
-    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
-    const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Record 5', () => {
-    type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
-    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
-    const B = Type.Record(Type.String(), Type.Number())
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Record 6', () => {
-    type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
-    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
-    const B = Type.Record(Type.Number(), Type.Number())
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  // ----------------------------------------------------------
-  // Standard
-  // ----------------------------------------------------------
-
-  it('Should extend Any', () => {
-    type T = { a: number } extends any ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = { a: number } extends string ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = { a: number } extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number', () => {
-    type T = { a: number } extends number ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer', () => {
-    type T = { a: number } extends number ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array', () => {
-    type T = { a: number } extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-  it('Should extend Tuple', () => {
-    type T = { a: number } extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-  it('Should extend Object 1', () => {
-    type T = { a: number } extends {} ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = { a: number } extends { a: 10 } ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Object({ a: Type.Literal(10) }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = { a: number } extends object ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = { a: number } extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Union([Type.Null(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = { a: number } extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = { a: number } extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Null', () => {
-    type T = { a: number } extends null ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined', () => {
-    type T = { a: number } extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void', () => {
-    type T = { a: number } extends void ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date', () => {
-    type T = { a: number } extends Date ? 1 : 2
-    const R = Structural.Check(Type.Object({ a: Type.Number() }), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/conditional/promise.ts b/test/runtime/conditional/promise.ts
deleted file mode 100644
index 68ad4b99d..000000000
--- a/test/runtime/conditional/promise.ts
+++ /dev/null
@@ -1,251 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Promise', () => {
-  // ----------------------------------------------
-  // Generic Varying
-  // ----------------------------------------------
-
-  it('Should extend Promise Varying 1', () => {
-    type T = Promise<any> extends Promise<any> ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Promise(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Promise Varying 2', () => {
-    type T = Promise<string> extends Promise<any> ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.String()), Type.Promise(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Promise Varying 3', () => {
-    type T = Promise<any> extends Promise<string> ? 1 : 2 // 1
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Promise(Type.String()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Promise Varying 4', () => {
-    type T = Promise<number> extends Promise<string> ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Promise(Type.String()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  // ----------------------------------------------
-  // Any
-  // ----------------------------------------------
-
-  it('Should extend Any', () => {
-    type T = Promise<any> extends any ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Unknown', () => {
-    type T = Promise<any> extends unknown ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = Promise<any> extends string ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = Promise<any> extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number', () => {
-    type T = Promise<any> extends number ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer', () => {
-    type T = Promise<any> extends number ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array', () => {
-    type T = Promise<any> extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple', () => {
-    type T = Promise<any> extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record', () => {
-    type T = Promise<any> extends Record<number, any> ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = Promise<any> extends {} ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = Promise<any> extends { a: 10 } ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = Promise<any> extends object ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = Promise<any> extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = Promise<any> extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = Promise<any> extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Null', () => {
-    type T = Promise<any> extends null ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined', () => {
-    type T = Promise<any> extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  // ----------------------------------------------
-  // Constrained
-  // ----------------------------------------------
-
-  it('Should extend constrained Any', () => {
-    type T = Promise<number> extends any ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained Unknown', () => {
-    type T = Promise<number> extends unknown ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained String', () => {
-    type T = Promise<number> extends string ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Boolean', () => {
-    type T = Promise<number> extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Number', () => {
-    type T = Promise<number> extends number ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Any()), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Integer', () => {
-    type T = Promise<number> extends number ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Array', () => {
-    type T = Promise<number> extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Tuple', () => {
-    type T = Promise<number> extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Object 1', () => {
-    type T = Promise<number> extends {} ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained Object 2', () => {
-    type T = Promise<number> extends { a: 10 } ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Object 3', () => {
-    type T = Promise<number> extends object ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained Union 1', () => {
-    type T = Promise<number> extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Union 2', () => {
-    type T = Promise<number> extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend constrained Union 2', () => {
-    type T = Promise<number> extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Null', () => {
-    type T = Promise<number> extends null ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend constrained Undefined', () => {
-    type T = Promise<number> extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void', () => {
-    type T = Promise<number> extends void ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date', () => {
-    type T = Promise<number> extends Date ? 1 : 2
-    const R = Structural.Check(Type.Promise(Type.Number()), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/conditional/string.ts b/test/runtime/conditional/string.ts
deleted file mode 100644
index 783a25e91..000000000
--- a/test/runtime/conditional/string.ts
+++ /dev/null
@@ -1,149 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/String', () => {
-  it('Should extend Any', () => {
-    type T = string extends any ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Unknown', () => {
-    type T = string extends unknown ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = string extends string ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.String())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = string extends boolean ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number', () => {
-    type T = string extends number ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer', () => {
-    type T = string extends number ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array', () => {
-    type T = string extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple', () => {
-    type T = string extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record 1', () => {
-    type T = string extends Record<number, any> ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Record 2', () => {
-    type T = string extends Record<number, unknown> ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.Unknown()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Record 3', () => {
-    type T = string extends Record<number, string> ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.String()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Record 4', () => {
-    type T = string extends Record<number, number> ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.Number()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record 5', () => {
-    type T = string extends Record<any, number | string> ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.Union([Type.Number(), Type.String()])))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record 6', () => {
-    type T = string extends Record<any, {}> ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = string extends {} ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = string extends { a: 10 } ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = string extends object ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = number extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = number extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 3', () => {
-    type T = number extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Null', () => {
-    type T = number extends null ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined', () => {
-    type T = number extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void', () => {
-    type T = number extends void ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date', () => {
-    type T = number extends Date ? 1 : 2
-    const R = Structural.Check(Type.Number(), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/conditional/tuple.ts b/test/runtime/conditional/tuple.ts
deleted file mode 100644
index dcd96163d..000000000
--- a/test/runtime/conditional/tuple.ts
+++ /dev/null
@@ -1,203 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Tuple', () => {
-  it('Should extend Any', () => {
-    type T = [string, number] extends any ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = [string, number] extends string ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = [string, number] extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number', () => {
-    type T = [string, number] extends number ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer', () => {
-    type T = [string, number] extends number ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array 1', () => {
-    type T = [string, number] extends Array<any> ? 1 : 2 // 1
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Array 2', () => {
-    type T = [string, number] extends Array<string> ? 1 : 2 // 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.String()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array 3', () => {
-    type T = [string, number] extends Array<string | number> ? 1 : 2 // 1
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Union([Type.String(), Type.Number()])))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Array 4', () => {
-    type T = [string, number] extends Array<string | number | boolean> ? 1 : 2 // 1
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Union([Type.String(), Type.Number(), Type.Boolean()])))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Tuple 1', () => {
-    type T = [string, number] extends [string, number] ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Tuple 2', () => {
-    type T = [string, number] extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple 3', () => {
-    type T = [string, any] extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Any()]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple 4', () => {
-    type T = [string, number] extends [string, any] ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Any()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Tuple 5', () => {
-    type T = [string, unknown] extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Unknown()]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple 6', () => {
-    type T = [string, number] extends [string, unknown] ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Unknown()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Tuple 7', () => {
-    type T = [] extends [string, number] ? 1 : 2
-    const R = Structural.Check(Type.Tuple([]), Type.Tuple([Type.String(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple 8', () => {
-    type T = [string, number] extends [] ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record 1', () => {
-    type T = [string, number] extends Record<number, any> ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Record 2', () => {
-    type T = [string, number] extends Record<number, unknown> ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.Unknown()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Record 3', () => {
-    type T = [string, number] extends Record<number, string> ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.String()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Record 4', () => {
-    type T = [string, number] extends Record<number, number> ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.Number()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record 5', () => {
-    type T = [string, number] extends Record<any, number | string> ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Record(Type.Number(), Type.Union([Type.Number(), Type.String()])))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record 6', () => {
-    type T = [string, number] extends Record<any, {}> ? 1 : 2
-    const R = Structural.Check(Type.String(), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = [string, number] extends {} ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = [string, number] extends { a: 10 } ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = [string, number] extends object ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = [string, number] extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = [string, number] extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = [string, number] extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Null', () => {
-    type T = [string, number] extends null ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined', () => {
-    type T = [string, number] extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void', () => {
-    type T = [string, number] extends void ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date', () => {
-    type T = [string, number] extends Date ? 1 : 2
-    const R = Structural.Check(Type.Tuple([Type.String(), Type.Number()]), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/conditional/uint8array.ts b/test/runtime/conditional/uint8array.ts
deleted file mode 100644
index 984082d01..000000000
--- a/test/runtime/conditional/uint8array.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Uint8Array', () => {
-  it('Should extend Any', () => {
-    type T = Uint8Array extends any ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Unknown', () => {
-    type T = Uint8Array extends unknown ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = Uint8Array extends string ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = Uint8Array extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number', () => {
-    type T = Uint8Array extends number ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer', () => {
-    type T = Uint8Array extends number ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array', () => {
-    type T = Uint8Array extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple', () => {
-    type T = Uint8Array extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Record', () => {
-    type T = Uint8Array extends Record<number, any> ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = Uint8Array extends {} ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = Uint8Array extends { a: 10 } ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = Uint8Array extends object ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = Uint8Array extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = Uint8Array extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 3', () => {
-    type T = Uint8Array extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Null', () => {
-    type T = Uint8Array extends null ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined', () => {
-    type T = Uint8Array extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void', () => {
-    type T = Uint8Array extends void ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date', () => {
-    type T = Uint8Array extends Date ? 1 : 2
-    const R = Structural.Check(Type.Uint8Array(), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/conditional/undefined.ts b/test/runtime/conditional/undefined.ts
deleted file mode 100644
index 2a03f11ba..000000000
--- a/test/runtime/conditional/undefined.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Undefined', () => {
-  it('Should extend Any', () => {
-    type T = undefined extends any ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = undefined extends string ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = undefined extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number', () => {
-    type T = undefined extends number ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer', () => {
-    type T = undefined extends number ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array', () => {
-    type T = undefined extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple', () => {
-    type T = undefined extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = undefined extends {} ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = undefined extends { a: 10 } ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = undefined extends object ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = undefined extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = undefined extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = undefined extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Null', () => {
-    type T = undefined extends null ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined', () => {
-    type T = undefined extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Void', () => {
-    type T = undefined extends void ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.Void())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Date', () => {
-    type T = undefined extends Date ? 1 : 2
-    const R = Structural.Check(Type.Undefined(), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/conditional/union.ts b/test/runtime/conditional/union.ts
deleted file mode 100644
index bcd0da241..000000000
--- a/test/runtime/conditional/union.ts
+++ /dev/null
@@ -1,154 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Union', () => {
-  it('Should extend Any', () => {
-    type T = number | string extends any ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = number | string extends string ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = number | string extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number', () => {
-    type T = number | string extends number ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer', () => {
-    type T = number | string extends number ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array', () => {
-    type T = number | string extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-  it('Should extend Tuple', () => {
-    type T = number | string extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = number | string extends {} ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = number | string extends { a: 10 } ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = number | string extends object ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = number | string extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = number | string extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 3', () => {
-    type T = number | string extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 4', () => {
-    type T = any | boolean extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-
-  it('Should extend Union 5', () => {
-    type T = any | string extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-
-  it('Should extend Union 6', () => {
-    type T = any | {} extends {} ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-
-  it('Should extend Union 7', () => {
-    type T = any extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.Union)
-  })
-
-  it('Should extend Union 8', () => {
-    type T = unknown | string extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Unknown(), Type.String()]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 9', () => {
-    type T = unknown extends boolean | number ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Null', () => {
-    type T = number | string extends null ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined', () => {
-    type T = number | string extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void', () => {
-    type T = number | string extends void ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void 2', () => {
-    type T = number | string | void extends void ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date', () => {
-    type T = number | string | void extends Date ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Number(), Type.String()]), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date 2', () => {
-    type T = Date | number | string | void extends Date ? 1 : 2
-    const R = Structural.Check(Type.Union([Type.Date(), Type.Number(), Type.String()]), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/conditional/unknown.ts b/test/runtime/conditional/unknown.ts
deleted file mode 100644
index 51b0e2908..000000000
--- a/test/runtime/conditional/unknown.ts
+++ /dev/null
@@ -1,125 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Unknown', () => {
-  it('Should extend Any', () => {
-    type T = unknown extends any ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Unknown', () => {
-    type T = unknown extends unknown ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = unknown extends string ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = unknown extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number', () => {
-    type T = unknown extends number ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer', () => {
-    type T = unknown extends number ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array 1', () => {
-    type T = unknown extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array 2', () => {
-    type T = unknown extends Array<string> ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Array(Type.String()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple', () => {
-    type T = unknown extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = unknown extends object ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = unknown extends {} ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = unknown extends { a: number } ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Object({ a: Type.Number() }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = unknown extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = unknown extends any | number ? 1 : 2 // 1
-    const R = Structural.Check(Type.Unknown(), Type.Union([Type.Any(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 3', () => {
-    type T = unknown extends unknown | number ? 1 : 2 // 1
-    const R = Structural.Check(Type.Unknown(), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 4', () => {
-    type T = unknown extends unknown | any ? 1 : 2 // 1
-    const R = Structural.Check(Type.Unknown(), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Null', () => {
-    type T = unknown extends null ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined', () => {
-    type T = unknown extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void', () => {
-    type T = unknown extends void ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Date', () => {
-    type T = unknown extends Date ? 1 : 2
-    const R = Structural.Check(Type.Unknown(), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/conditional/void.ts b/test/runtime/conditional/void.ts
deleted file mode 100644
index 6e1ece4ca..000000000
--- a/test/runtime/conditional/void.ts
+++ /dev/null
@@ -1,125 +0,0 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
-
-describe('conditional/structural/Void', () => {
-  it('Should extend Any', () => {
-    type T = void extends any ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Unknown', () => {
-    type T = void extends unknown ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend String', () => {
-    type T = void extends string ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Boolean', () => {
-    type T = void extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Number', () => {
-    type T = void extends number ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Integer', () => {
-    type T = void extends number ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array 1', () => {
-    type T = void extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Array 2', () => {
-    type T = void extends Array<string> ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.Array(Type.String()))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Tuple', () => {
-    type T = void extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = void extends object ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 2', () => {
-    type T = void extends {} ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 3', () => {
-    type T = void extends { a: number } ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.Object({ a: Type.Number() }))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 1', () => {
-    type T = void extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Union 2', () => {
-    type T = void extends any | number ? 1 : 2 // 1
-    const R = Structural.Check(Type.Void(), Type.Union([Type.Any(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 3', () => {
-    type T = void extends unknown | number ? 1 : 2 // 1
-    const R = Structural.Check(Type.Void(), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Union 4', () => {
-    type T = void extends unknown | any ? 1 : 2 // 1
-    const R = Structural.Check(Type.Void(), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Null', () => {
-    type T = void extends null ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Undefined', () => {
-    type T = void extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Void', () => {
-    type T = void extends void ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.Void())
-    Assert.deepEqual(R, StructuralResult.True)
-  })
-
-  it('Should extend Date', () => {
-    type T = void extends Date ? 1 : 2
-    const R = Structural.Check(Type.Void(), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-})
diff --git a/test/runtime/errors/index.ts b/test/runtime/errors/index.ts
index 3443ef957..41d3ac147 100644
--- a/test/runtime/errors/index.ts
+++ b/test/runtime/errors/index.ts
@@ -1 +1 @@
-// todo: implement once errors are standardized
+import './iterator'
diff --git a/test/runtime/errors/iterator.ts b/test/runtime/errors/iterator.ts
new file mode 100644
index 000000000..3a61c3ad9
--- /dev/null
+++ b/test/runtime/errors/iterator.ts
@@ -0,0 +1,32 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrors } from '@sinclair/typebox/errors'
+import { Assert } from '../assert'
+
+describe('errors/ValueErrorIterator', () => {
+  it('Should return undefined for non error', () => {
+    const R = ValueErrors.Errors(Type.Number(), [], 1).First()
+    Assert.equal(R, undefined)
+  })
+  it('Should return a value error when error', () => {
+    const { type, path, message } = ValueErrors.Errors(Type.Number(), [], '').First()!
+    Assert.isTypeOf(type, 'number')
+    Assert.isTypeOf(path, 'string')
+    Assert.isTypeOf(message, 'string')
+  })
+  it('Should yield empty array for non error', () => {
+    const R = [...ValueErrors.Errors(Type.Number(), [], 1)]
+    Assert.equal(R.length, 0)
+  })
+  it('Should yield array with 1 error when error', () => {
+    const R = [...ValueErrors.Errors(Type.Number(), [], 'foo')]
+    Assert.equal(R.length, 1)
+  })
+  it('Should yield array with N errors when error', () => {
+    // prettier-ignore
+    const R = [...ValueErrors.Errors(Type.Object({
+      x: Type.Number(),
+      y: Type.Number()
+    }), [], {})] // require object to invoke internal check
+    Assert.equal(R.length > 1, true)
+  })
+})
diff --git a/test/runtime/format/format.ts b/test/runtime/format/format.ts
deleted file mode 100644
index e867d5a41..000000000
--- a/test/runtime/format/format.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import { Format } from '@sinclair/typebox/format'
-import { Assert } from '../assert/index'
-
-describe('format/Format', () => {
-  it('Should set format', () => {
-    Format.Set('test#format1', () => true)
-  })
-
-  it('Should get format', () => {
-    Format.Set('test#format2', () => true)
-    const format = Format.Get('test#format2')
-    Assert.equal(typeof format, 'function')
-  })
-
-  it('Should return true if exists', () => {
-    Format.Set('test#format3', () => true)
-    Assert.equal(Format.Has('test#format3'), true)
-  })
-
-  it('Should clear formats', () => {
-    Format.Set('test#format4', () => true)
-    Format.Clear()
-    Assert.equal(Format.Has('test#format4'), false)
-  })
-})
diff --git a/test/runtime/index.ts b/test/runtime/index.ts
index 6bd775e76..5a8bca7ab 100644
--- a/test/runtime/index.ts
+++ b/test/runtime/index.ts
@@ -1,9 +1,6 @@
 import './compiler/index'
-import './conditional/index'
 import './errors/index'
-import './format/index'
-import './guard/index'
-import './hash/index'
 import './schema/index'
 import './system/index'
+import './type/index'
 import './value/index'
diff --git a/test/runtime/schema/composite.ts b/test/runtime/schema/composite.ts
new file mode 100644
index 000000000..cca8cac71
--- /dev/null
+++ b/test/runtime/schema/composite.ts
@@ -0,0 +1,94 @@
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../assert'
+import { Ok, Fail } from './validate'
+
+describe('type/schema/Composite', () => {
+  it('Should compose two objects', () => {
+    const A = Type.Object({ a: Type.String() })
+    const B = Type.Object({ b: Type.Number() })
+    const T = Type.Composite([A, B], { additionalProperties: false })
+    Ok(T, { a: 'hello', b: 42 })
+  })
+
+  it('Should compose with partial', () => {
+    const A = Type.Partial(Type.Object({ a: Type.Number() }))
+    const B = Type.Partial(Type.Object({ b: Type.Number() }))
+    const P = Type.Composite([A, B], { additionalProperties: false })
+    Ok(P, { a: 1, b: 2 })
+    Ok(P, { a: 1 })
+    Ok(P, { b: 1 })
+    Ok(P, {})
+    Fail(P, { c: 1 })
+  })
+
+  it('Should compose with overlapping same type', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ a: Type.Number() })
+    const P = Type.Composite([A, B])
+    Ok(P, { a: 1 })
+    Fail(P, { a: 'hello' })
+    Fail(P, {})
+  })
+
+  it('Should compose with overlapping varying type', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ a: Type.String() })
+    const T = Type.Composite([A, B])
+    Ok(T, { a: 1 })
+    Ok(T, { a: 'hello' })
+    Fail(T, {})
+  })
+
+  it('Should compose with deeply nest overlapping varying type', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ a: Type.String() })
+    const C = Type.Object({ a: Type.Boolean() })
+    const D = Type.Object({ a: Type.Null() })
+    const T = Type.Composite([A, B, C, D])
+    Ok(T, { a: 1 })
+    Ok(T, { a: 'hello' })
+    Ok(T, { a: false })
+    Ok(T, { a: null })
+    Fail(T, { a: [] })
+    Fail(T, {})
+  })
+
+  it('Should pick from composited type', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const C = Type.Object({ z: Type.Number() })
+    const T = Type.Composite([A, B, C])
+    const P = Type.Pick(T, ['x', 'y'], { additionalProperties: false })
+    Ok(P, { x: 1, y: 1 })
+    Fail(P, { x: 1, y: 1, z: 1 })
+  })
+
+  it('Should omit from composited type', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const C = Type.Object({ z: Type.Number() })
+    const T = Type.Composite([A, B, C])
+    const P = Type.Omit(T, ['z'], { additionalProperties: false })
+    Ok(P, { x: 1, y: 1 })
+    Fail(P, { x: 1, y: 1, z: 1 })
+  })
+
+  it('Should compose nested object properties', () => {
+    const A = Type.Object({ x: Type.Object({ x: Type.Number() }) })
+    const B = Type.Object({ x: Type.Object({ x: Type.String() }) })
+    const T = Type.Composite([A, B])
+    Ok(T, { x: { x: 1 } })
+    Ok(T, { x: { x: 'hello' } })
+    Fail(T, { x: { x: false } })
+  })
+
+  // todo: move to composition / type guard spec
+  it('Should compose and produce the same schema', () => {
+    const T = Type.Object({
+      field: Type.Optional(Type.String()),
+    })
+    const A = Type.Composite([T])
+    const B = Type.Composite([T])
+    Assert.deepEqual(A, B)
+  })
+})
diff --git a/test/runtime/schema/index.ts b/test/runtime/schema/index.ts
index d0053aa86..705b1d169 100644
--- a/test/runtime/schema/index.ts
+++ b/test/runtime/schema/index.ts
@@ -1,6 +1,7 @@
 import './any'
 import './array'
 import './boolean'
+import './composite'
 import './date'
 import './enum'
 import './integer'
@@ -9,6 +10,7 @@ import './keyof'
 import './literal'
 import './modifier'
 import './never'
+import './not'
 import './null'
 import './number'
 import './object'
diff --git a/test/runtime/schema/intersect.ts b/test/runtime/schema/intersect.ts
index e1671dbc3..d3de6c365 100644
--- a/test/runtime/schema/intersect.ts
+++ b/test/runtime/schema/intersect.ts
@@ -1,94 +1,83 @@
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert'
+import { Type, Static } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
 describe('type/schema/Intersect', () => {
-  it('Should intersect two objects', () => {
-    const A = Type.Object({ a: Type.String() })
-    const B = Type.Object({ b: Type.Number() })
-    const T = Type.Intersect([A, B], { additionalProperties: false })
-    Ok(T, { a: 'hello', b: 42 })
+  it('Should intersect number and number', () => {
+    const A = Type.Number()
+    const B = Type.Number()
+    const T = Type.Intersect([A, B], {})
+    Ok(T, 1)
   })
-
-  it('Should intersect with partial', () => {
-    const A = Type.Partial(Type.Object({ a: Type.Number() }))
-    const B = Type.Partial(Type.Object({ b: Type.Number() }))
-    const P = Type.Intersect([A, B], { additionalProperties: false })
-    Ok(P, { a: 1, b: 2 })
-    Ok(P, { a: 1 })
-    Ok(P, { b: 1 })
-    Ok(P, {})
-    Fail(P, { c: 1 })
+  it('Should not intersect string and number', () => {
+    const A = Type.String()
+    const B = Type.Number()
+    const T = Type.Intersect([A, B], {})
+    Fail(T, 1)
+    Fail(T, '1')
   })
-
-  it('Should intersect with overlapping same type', () => {
-    const A = Type.Object({ a: Type.Number() })
-    const B = Type.Object({ a: Type.Number() })
-    const P = Type.Intersect([A, B])
-    Ok(P, { a: 1 })
-    Fail(P, { a: 'hello' })
-    Fail(P, {})
+  it('Should intersect two objects', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const T = Type.Intersect([A, B], {})
+    Ok(T, { x: 1, y: 1 })
   })
-
-  it('Should intersect with overlapping varying type', () => {
-    const A = Type.Object({ a: Type.Number() })
-    const B = Type.Object({ a: Type.String() })
-    const T = Type.Intersect([A, B])
-    Ok(T, { a: 1 })
-    Ok(T, { a: 'hello' })
-    Fail(T, {})
+  it('Should not intersect two objects with internal additionalProperties false', () => {
+    const A = Type.Object({ x: Type.Number() }, { additionalProperties: false })
+    const B = Type.Object({ y: Type.Number() }, { additionalProperties: false })
+    const T = Type.Intersect([A, B], {})
+    Fail(T, { x: 1, y: 1 })
   })
-
-  it('Should intersect with deeply nest overlapping varying type', () => {
-    const A = Type.Object({ a: Type.Number() })
-    const B = Type.Object({ a: Type.String() })
-    const C = Type.Object({ a: Type.Boolean() })
-    const D = Type.Object({ a: Type.Null() })
-    const T = Type.Intersect([A, B, C, D])
-    Ok(T, { a: 1 })
-    Ok(T, { a: 'hello' })
-    Ok(T, { a: false })
-    Ok(T, { a: null })
-    Fail(T, { a: [] })
-    Fail(T, {})
+  it('Should intersect two objects and mandate required properties', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const T = Type.Intersect([A, B], {})
+    Ok(T, { x: 1, y: 1 })
+    Fail(T, { x: 1 })
+    Fail(T, { y: 1 })
   })
-
-  it('Should pick from intersected type', () => {
+  it('Should intersect two objects with unevaluated properties', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ y: Type.Number() })
-    const C = Type.Object({ z: Type.Number() })
-    const T = Type.Intersect([A, B, C])
-    const P = Type.Pick(T, ['x', 'y'], { additionalProperties: false })
-    Ok(P, { x: 1, y: 1 })
-    Fail(P, { x: 1, y: 1, z: 1 })
+    const T = Type.Intersect([A, B], {})
+    Ok(T, { x: 1, y: 2, z: 1 })
   })
-
-  it('Should omit from intersected type', () => {
+  it('Should intersect two objects and restrict unevaluated properties', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ y: Type.Number() })
-    const C = Type.Object({ z: Type.Number() })
-    const T = Type.Intersect([A, B, C])
-    const P = Type.Omit(T, ['z'], { additionalProperties: false })
-    Ok(P, { x: 1, y: 1 })
-    Fail(P, { x: 1, y: 1, z: 1 })
+    const T = Type.Intersect([A, B], { unevaluatedProperties: false })
+    Fail(T, { x: 1, y: 2, z: 1 })
   })
-
-  it('Should intersect nested object properties', () => {
-    const A = Type.Object({ x: Type.Object({ x: Type.Number() }) })
-    const B = Type.Object({ x: Type.Object({ x: Type.String() }) })
+  it('Should intersect two objects and allow unevaluated properties of number', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const T = Type.Intersect([A, B], { unevaluatedProperties: Type.Number() })
+    Ok(T, { x: 1, y: 2, z: 3 })
+    Fail(T, { x: 1, y: 2, z: '1' })
+  })
+  it('Should intersect two union objects with overlapping properties of the same type', () => {
+    const A = Type.Union([Type.Object({ x: Type.Number() })])
+    const B = Type.Union([Type.Object({ x: Type.Number() })])
     const T = Type.Intersect([A, B])
-    Ok(T, { x: { x: 1 } })
-    Ok(T, { x: { x: 'hello' } })
-    Fail(T, { x: { x: false } })
+    Ok(T, { x: 1 })
+    Fail(T, { x: '1' })
   })
-
-  // todo: move to composition / type guard spec
-  it('Should intersect and produce the same schema', () => {
-    const T = Type.Object({
-      field: Type.Optional(Type.String()),
-    })
-    const A = Type.Intersect([T])
-    const B = Type.Intersect([T])
-    Assert.deepEqual(A, B)
+  it('Should not intersect two union objects with overlapping properties of varying types', () => {
+    const A = Type.Union([Type.Object({ x: Type.Number() })])
+    const B = Type.Union([Type.Object({ x: Type.String() })])
+    const T = Type.Intersect([A, B])
+    Fail(T, { x: 1 })
+    Fail(T, { x: '1' })
+  })
+  it('Should intersect two union objects with non-overlapping properties', () => {
+    const A = Type.Union([Type.Object({ x: Type.Number() })])
+    const B = Type.Union([Type.Object({ y: Type.Number() })])
+    const T = Type.Intersect([A, B])
+    Ok(T, { x: 1, y: 1 })
+  })
+  it('Should not intersect two union objects with non-overlapping properties for additionalProperties false', () => {
+    const A = Type.Union([Type.Object({ x: Type.Number() }, { additionalProperties: false })])
+    const B = Type.Union([Type.Object({ y: Type.Number() }, { additionalProperties: false })])
+    const T = Type.Intersect([A, B])
+    Fail(T, { x: 1, y: 1 })
   })
 })
diff --git a/test/runtime/schema/not.ts b/test/runtime/schema/not.ts
new file mode 100644
index 000000000..c8ec36faf
--- /dev/null
+++ b/test/runtime/schema/not.ts
@@ -0,0 +1,38 @@
+import { Type } from '@sinclair/typebox'
+import { Ok, Fail } from './validate'
+
+describe('type/schema/Not', () => {
+  it('Should validate with not number', () => {
+    const T = Type.Not(Type.Number(), Type.String())
+    Fail(T, 1)
+    Ok(T, 'A')
+  })
+  it('Should validate with union left', () => {
+    // prettier-ignore
+    const T = Type.Not(Type.Union([
+      Type.Literal('A'), 
+      Type.Literal('B'), 
+      Type.Literal('C')
+    ]), Type.String())
+    Fail(T, 'A')
+    Fail(T, 'B')
+    Fail(T, 'C')
+    Ok(T, 'D')
+  })
+  it('Should validate with union right', () => {
+    // prettier-ignore
+    const T = Type.Not(Type.Number(), Type.Union([
+      Type.String(),
+      Type.Boolean()
+    ]))
+    Fail(T, 1)
+    Ok(T, 'A')
+    Ok(T, true)
+  })
+  it('Should not validate with symmetric left right', () => {
+    // prettier-ignore
+    const T = Type.Not(Type.Number(), Type.Number())
+    Fail(T, 1)
+    Fail(T, true) // not a number, but not a number either?
+  })
+})
diff --git a/test/runtime/schema/validate.ts b/test/runtime/schema/validate.ts
index 7390db7bb..6e9cf4eac 100644
--- a/test/runtime/schema/validate.ts
+++ b/test/runtime/schema/validate.ts
@@ -1,4 +1,4 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Value } from '@sinclair/typebox/value'
 
 import { TSchema } from '@sinclair/typebox'
diff --git a/test/runtime/system/AllowArrayObjects.ts b/test/runtime/system/AllowArrayObjects.ts
deleted file mode 100644
index 064139813..000000000
--- a/test/runtime/system/AllowArrayObjects.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import { Ok, Fail } from '../compiler/validate'
-import { TypeSystem } from '@sinclair/typebox/system'
-import { Type } from '@sinclair/typebox'
-
-describe('system/TypeSystem/AllowArrayObjects', () => {
-  before(() => {
-    TypeSystem.AllowArrayObjects = true
-  })
-  after(() => {
-    TypeSystem.AllowArrayObjects = false
-  })
-  // ---------------------------------------------------------------
-  // Object
-  // ---------------------------------------------------------------
-  it('Should validate arrays with empty objects', () => {
-    const T = Type.Object({})
-    Ok(T, [0, 1, 2])
-  })
-  it('Should validate arrays with objects with length property', () => {
-    const T = Type.Object({ length: Type.Number() })
-    Ok(T, [0, 1, 2])
-  })
-  it('Should validate arrays with objects with additionalProperties false when array has no elements', () => {
-    const T = Type.Object({ length: Type.Number() }, { additionalProperties: false })
-    Ok(T, [])
-  })
-  it('Should not validate arrays with objects with additionalProperties false when array has elements', () => {
-    const T = Type.Object({ length: Type.Number() }, { additionalProperties: false })
-    Fail(T, [0, 1, 2])
-  })
-  it('Should not validate arrays with objects when length property is string', () => {
-    const T = Type.Object({ length: Type.String() })
-    Fail(T, [0, 1, 2])
-  })
-  // ---------------------------------------------------------------
-  // Record
-  // ---------------------------------------------------------------
-  it('Should validate arrays as Records with String Keys', () => {
-    const T = Type.Record(Type.String(), Type.Number())
-    Ok(T, [0, 1, 2])
-  })
-  it('Should not validate arrays as Records with Number Keys', () => {
-    const T = Type.Record(Type.Integer(), Type.Number())
-    Fail(T, [0, 1, 2])
-  })
-  it('Should not validate arrays as Records with Object Values', () => {
-    const T = Type.Record(
-      Type.String(),
-      Type.Object({
-        x: Type.Number(),
-        y: Type.Number(),
-        z: Type.Number(),
-      }),
-    )
-    Ok(T, [
-      { x: 1, y: 1, z: 1 },
-      { x: 1, y: 1, z: 1 },
-      { x: 1, y: 1, z: 1 },
-    ])
-  })
-})
diff --git a/test/runtime/system/AllowNaN.ts b/test/runtime/system/AllowNaN.ts
deleted file mode 100644
index 4795e7936..000000000
--- a/test/runtime/system/AllowNaN.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-import { Ok, Fail } from '../compiler/validate'
-import { TypeSystem } from '@sinclair/typebox/system'
-import { Type } from '@sinclair/typebox'
-
-describe('system/TypeSystem/AllowNaN', () => {
-  before(() => {
-    TypeSystem.AllowNaN = true
-  })
-  after(() => {
-    TypeSystem.AllowNaN = false
-  })
-  // ---------------------------------------------------------------
-  // Number
-  // ---------------------------------------------------------------
-  it('Should validate number with NaN', () => {
-    const T = Type.Number()
-    Ok(T, NaN)
-  })
-
-  // ---------------------------------------------------------------
-  // Integer
-  //
-  // Note: The Number.isInteger() test will fail for NaN. Because
-  // of this we cannot reasonably override NaN handling for integers.
-  // ---------------------------------------------------------------
-  it('Should not validate integer with NaN', () => {
-    const T = Type.Integer()
-    Fail(T, NaN)
-  })
-})
diff --git a/test/runtime/system/CreateFormat.ts b/test/runtime/system/CreateFormat.ts
deleted file mode 100644
index 751eb34e8..000000000
--- a/test/runtime/system/CreateFormat.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { Ok, Fail } from '../compiler/validate'
-import { Assert } from '../assert/index'
-import { TypeSystem } from '@sinclair/typebox/system'
-import { Type } from '@sinclair/typebox'
-
-describe('system/TypeSystem/CreateFormat', () => {
-  it('Should create and validate a format', () => {
-    TypeSystem.CreateFormat('CreateFormat0', (value) => value === value.toLowerCase())
-    const T = Type.String({ format: 'CreateFormat0' })
-    Ok(T, 'action')
-    Fail(T, 'ACTION')
-  })
-  it('Should throw if registering the same format twice', () => {
-    TypeSystem.CreateFormat('CreateFormat1', (value) => true)
-    Assert.throws(() => TypeSystem.CreateFormat('CreateFormat1', (value) => true))
-  })
-})
diff --git a/test/runtime/system/CreateType.ts b/test/runtime/system/CreateType.ts
deleted file mode 100644
index 60626b7d2..000000000
--- a/test/runtime/system/CreateType.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { Ok, Fail } from '../compiler/validate'
-import { Assert } from '../assert/index'
-import { TypeSystem } from '@sinclair/typebox/system'
-
-describe('system/TypeSystem/CreateType', () => {
-  it('Should create and validate a type', () => {
-    type BigNumberOptions = { minimum?: bigint; maximum?: bigint }
-    const BigNumber = TypeSystem.CreateType<bigint, BigNumberOptions>('CreateType0', (options, value) => {
-      if (typeof value !== 'bigint') return false
-      if (options.maximum !== undefined && value > options.maximum) return false
-      if (options.minimum !== undefined && value < options.minimum) return false
-      return true
-    })
-    const T = BigNumber({ minimum: 10n, maximum: 20n })
-    Ok(T, 15n)
-    Fail(T, 5n)
-    Fail(T, 25n)
-  })
-  it('Should throw if registering the same type twice', () => {
-    TypeSystem.CreateType('CreateType1', () => true)
-    Assert.throws(() => TypeSystem.CreateType('CreateType1', () => true))
-  })
-})
diff --git a/test/runtime/system/index.ts b/test/runtime/system/index.ts
index 72bdb9c85..a3fc40210 100644
--- a/test/runtime/system/index.ts
+++ b/test/runtime/system/index.ts
@@ -1,4 +1 @@
-import './AllowArrayObjects'
-import './AllowNaN'
-import './CreateFormat'
-import './CreateType'
+import './system'
diff --git a/test/runtime/system/system.ts b/test/runtime/system/system.ts
new file mode 100644
index 000000000..5c41eda2c
--- /dev/null
+++ b/test/runtime/system/system.ts
@@ -0,0 +1,169 @@
+import { Ok, Fail } from '../compiler/validate'
+import { Assert } from '../assert/index'
+import { TypeSystem } from '@sinclair/typebox/system'
+import { Type } from '@sinclair/typebox'
+
+describe('system/TypeSystem/AllowNaN', () => {
+  before(() => {
+    TypeSystem.AllowNaN = true
+  })
+  after(() => {
+    TypeSystem.AllowNaN = false
+  })
+  // ---------------------------------------------------------------
+  // Number
+  // ---------------------------------------------------------------
+  it('Should validate number with NaN', () => {
+    const T = Type.Number()
+    Ok(T, NaN)
+  })
+  it('Should validate number with +Infinity', () => {
+    const T = Type.Number()
+    Ok(T, Infinity)
+  })
+  it('Should validate number with -Infinity', () => {
+    const T = Type.Number()
+    Ok(T, -Infinity)
+  })
+  // ---------------------------------------------------------------
+  // Integer
+  //
+  // Note: The Number.isInteger() test will fail for NaN. Because
+  // of this we cannot reasonably override NaN handling for integers.
+  // ---------------------------------------------------------------
+  it('Should not validate integer with NaN', () => {
+    const T = Type.Integer()
+    Fail(T, NaN)
+  })
+  it('Should not validate integer with +Infinity', () => {
+    const T = Type.Integer()
+    Fail(T, Infinity)
+  })
+  it('Should not validate integer with -Infinity', () => {
+    const T = Type.Integer()
+    Fail(T, -Infinity)
+  })
+  // ---------------------------------------------------------------
+  // BigInt
+  //
+  // Note: We expect failures here as bigint isn't IEEE754
+  // ---------------------------------------------------------------
+  it('Should not validate bigint with NaN', () => {
+    const T = Type.BigInt()
+    Fail(T, NaN)
+  })
+  it('Should not validate bigint with +Infinity', () => {
+    const T = Type.BigInt()
+    Fail(T, Infinity)
+  })
+  it('Should not validate bigint with -Infinity', () => {
+    const T = Type.BigInt()
+    Fail(T, -Infinity)
+  })
+})
+
+describe('system/TypeSystem/AllowArrayObjects', () => {
+  before(() => {
+    TypeSystem.AllowArrayObjects = true
+  })
+  after(() => {
+    TypeSystem.AllowArrayObjects = false
+  })
+  // ---------------------------------------------------------------
+  // Object
+  // ---------------------------------------------------------------
+  it('Should validate arrays with empty objects', () => {
+    const T = Type.Object({})
+    Ok(T, [0, 1, 2])
+  })
+  it('Should validate arrays with objects with length property', () => {
+    const T = Type.Object({ length: Type.Number() })
+    Ok(T, [0, 1, 2])
+  })
+  it('Should validate arrays with objects with additionalProperties false when array has no elements', () => {
+    const T = Type.Object({ length: Type.Number() }, { additionalProperties: false })
+    Ok(T, [])
+  })
+  it('Should not validate arrays with objects with additionalProperties false when array has elements', () => {
+    const T = Type.Object({ length: Type.Number() }, { additionalProperties: false })
+    Fail(T, [0, 1, 2])
+  })
+  it('Should not validate arrays with objects when length property is string', () => {
+    const T = Type.Object({ length: Type.String() })
+    Fail(T, [0, 1, 2])
+  })
+  // ---------------------------------------------------------------
+  // Record
+  // ---------------------------------------------------------------
+  it('Should validate arrays as Records with String Keys', () => {
+    const T = Type.Record(Type.String(), Type.Number())
+    Ok(T, [0, 1, 2])
+  })
+  it('Should not validate arrays as Records with Number Keys', () => {
+    const T = Type.Record(Type.Integer(), Type.Number())
+    Fail(T, [0, 1, 2])
+  })
+  it('Should not validate arrays as Records with Object Values', () => {
+    const T = Type.Record(
+      Type.String(),
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+    )
+    Ok(T, [
+      { x: 1, y: 1, z: 1 },
+      { x: 1, y: 1, z: 1 },
+      { x: 1, y: 1, z: 1 },
+    ])
+  })
+})
+describe('system/TypeSystem/AllowVoidNull', () => {
+  before(() => {
+    TypeSystem.AllowVoidNull = true
+  })
+  after(() => {
+    TypeSystem.AllowVoidNull = false
+  })
+  // ---------------------------------------------------------------
+  // Object
+  // ---------------------------------------------------------------
+  it('Should validate with null', () => {
+    const T = Type.Void()
+    Ok(T, null)
+  })
+})
+
+describe('system/TypeSystem/Format', () => {
+  it('Should create and validate a format', () => {
+    TypeSystem.Format('CreateFormat0', (value) => value === value.toLowerCase())
+    const T = Type.String({ format: 'CreateFormat0' })
+    Ok(T, 'action')
+    Fail(T, 'ACTION')
+  })
+  it('Should throw if registering the same format twice', () => {
+    TypeSystem.Format('CreateFormat1', (value) => true)
+    Assert.throws(() => TypeSystem.Format('CreateFormat1', (value) => true))
+  })
+})
+
+describe('system/TypeSystem/Type', () => {
+  it('Should create and validate a type', () => {
+    type BigNumberOptions = { minimum?: bigint; maximum?: bigint }
+    const BigNumber = TypeSystem.Type<bigint, BigNumberOptions>('CreateType0', (options, value) => {
+      if (typeof value !== 'bigint') return false
+      if (options.maximum !== undefined && value > options.maximum) return false
+      if (options.minimum !== undefined && value < options.minimum) return false
+      return true
+    })
+    const T = BigNumber({ minimum: 10n, maximum: 20n })
+    Ok(T, 15n)
+    Fail(T, 5n)
+    Fail(T, 25n)
+  })
+  it('Should throw if registering the same type twice', () => {
+    TypeSystem.Type('CreateType1', () => true)
+    Assert.throws(() => TypeSystem.Type('CreateType1', () => true))
+  })
+})
diff --git a/test/runtime/type/clone/clone.ts b/test/runtime/type/clone/clone.ts
new file mode 100644
index 000000000..36568003b
--- /dev/null
+++ b/test/runtime/type/clone/clone.ts
@@ -0,0 +1,147 @@
+// --------------------------------------------------------------------
+// $id deletion was omitted from 0.26.0 to reduce complexity overhead.
+// --------------------------------------------------------------------
+
+// import { Type } from '@sinclair/typebox'
+// import { Assert } from '../../assert'
+
+// describe('type/Clone', () => {
+//   it('Should retain source type $id for cloned objects', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Object({ x: S, y: S })
+//     Assert.equal(T.properties.x.$id, undefined)
+//     Assert.equal(T.properties.y.$id, undefined)
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should retain source type $id when composing objects with cloned arrays', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Function([S], S)
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should remove cloned $id for Array', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Array(S)
+//     Assert.equal(T.items.$id, undefined)
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should remove cloned $id for Composite', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Composite([Type.Object({ a: S }), Type.Object({ b: S })])
+//     Assert.equal(T.properties.a.$id, undefined)
+//     Assert.equal(T.properties.b.$id, undefined)
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should remove cloned $id for Constructor', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Constructor([S], S)
+//     Assert.equal(T.parameters[0].$id, undefined)
+//     Assert.equal(T.returns.$id, undefined)
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should remove cloned $id for Function', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Function([S], S)
+//     Assert.equal(T.parameters[0].$id, undefined)
+//     Assert.equal(T.returns.$id, undefined)
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should remove cloned $id for Intersect', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Intersect([S, S])
+//     Assert.equal(T.allOf[0].$id, undefined)
+//     Assert.equal(T.allOf[1].$id, undefined)
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should remove cloned $id for Intersect with unevaluatedProperties', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Intersect([S, S], { unevaluatedProperties: S })
+//     // @ts-ignore
+//     Assert.equal(T.unevaluatedProperties.$id, undefined)
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should remove cloned $id for Not', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Not(S, S)
+//     Assert.equal(T.allOf[0].not.$id, undefined)
+//     Assert.equal(T.allOf[1].$id, undefined)
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should remove cloned $id for Object', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Object({ x: S, y: S })
+//     Assert.equal(T.properties.x.$id, undefined)
+//     Assert.equal(T.properties.y.$id, undefined)
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should remove cloned $id for nested Object', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const N = Type.Object({ s: S }, { $id: 'N' })
+//     const T = Type.Object({ x: S, y: S, z: N })
+//     Assert.equal(T.properties.x.$id, undefined)
+//     Assert.equal(T.properties.y.$id, undefined)
+//     Assert.equal(T.properties.z.$id, undefined)
+//     Assert.equal(T.properties.z.properties.s.$id, undefined)
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should remove cloned $id for Object additionalProperties', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Object({}, { additionalProperties: S })
+//     // @ts-ignore
+//     Assert.equal(T.additionalProperties!.$id, undefined)
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should remove cloned $id for Promise', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Promise(S)
+//     Assert.equal(T.item.$id, undefined)
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should remove cloned $id for Record', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Record(Type.String(), S)
+//     Assert.equal(T.patternProperties['^.*$'].$id, undefined)
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should remove cloned $id for Tuple', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Tuple([S, S])
+//     Assert.equal(T.items![0]!.$id, undefined)
+//     Assert.equal(T.items![1]!.$id, undefined)
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should remove cloned $id for Union', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Union([S, S])
+//     Assert.equal(T.anyOf[0]!.$id, undefined)
+//     Assert.equal(T.anyOf[1]!.$id, undefined)
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should retain cloned $id for wrapped Recursive 1', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Object({
+//       x: Type.Recursive(
+//         (Self) =>
+//           Type.Object({
+//             self: Type.Optional(Self),
+//           }),
+//         { $id: 'RecursiveClone' },
+//       ),
+//     })
+//     Assert.equal(T.properties.x.$id, 'RecursiveClone')
+//     Assert.equal(S.$id, 'S')
+//   })
+//   it('Should retain cloned $id for wrapped Recursive 2', () => {
+//     const S = Type.String({ $id: 'S' })
+//     const T = Type.Tuple([
+//       Type.Recursive(
+//         (Self) =>
+//           Type.Object({
+//             self: Type.Optional(Self),
+//           }),
+//         { $id: 'RecursiveClone' },
+//       ),
+//     ])
+//     Assert.equal(T.items![0].$id, 'RecursiveClone')
+//     Assert.equal(S.$id, 'S')
+//   })
+// })
diff --git a/test/runtime/type/clone/index.ts b/test/runtime/type/clone/index.ts
new file mode 100644
index 000000000..cd798158e
--- /dev/null
+++ b/test/runtime/type/clone/index.ts
@@ -0,0 +1 @@
+import './clone'
diff --git a/test/runtime/type/extends/any.ts b/test/runtime/type/extends/any.ts
new file mode 100644
index 000000000..f67300b2e
--- /dev/null
+++ b/test/runtime/type/extends/any.ts
@@ -0,0 +1,98 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Any', () => {
+  it('Should extend Any', () => {
+    type T = any extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Unknown', () => {
+    type T = any extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = any extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Boolean', () => {
+    type T = any extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Number', () => {
+    type T = any extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Integer', () => {
+    type T = any extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Array 1', () => {
+    type T = any extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Array 2', () => {
+    type T = any extends Array<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Array(Type.String()))
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Tuple', () => {
+    type T = any extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Object 1', () => {
+    type T = any extends object ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Object 2', () => {
+    type T = any extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Object 3', () => {
+    type T = any extends { a: number } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Object({ a: Type.Number() }))
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Union 1', () => {
+    type T = any extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Union 2', () => {
+    type T = any extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Any(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Null', () => {
+    type T = any extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Undefined', () => {
+    type T = any extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Void', () => {
+    type T = any extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+
+  it('Should extend Date', () => {
+    type T = any extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+})
diff --git a/test/runtime/type/extends/array.ts b/test/runtime/type/extends/array.ts
new file mode 100644
index 000000000..973c7457f
--- /dev/null
+++ b/test/runtime/type/extends/array.ts
@@ -0,0 +1,316 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Array', () => {
+  // ----------------------------------------------
+  // Generic Varying
+  // ----------------------------------------------
+
+  it('Should extend Array Varying 1', () => {
+    type T = Array<any> extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Array Varying 2', () => {
+    type T = Array<string> extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Array Varying 3', () => {
+    type T = Array<any> extends Array<string> ? 1 : 2 // 1
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.String()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Array Varying 4', () => {
+    type T = Array<number> extends Array<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Number()), Type.Array(Type.String()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  // ----------------------------------------------
+  // Any
+  // ----------------------------------------------
+  it('Should extend Any', () => {
+    type T = Array<any> extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = Array<any> extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = Array<any> extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = Array<any> extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = Array<any> extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = Array<any> extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array 1', () => {
+    type T = Array<any> extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Array 2', () => {
+    type T = Array<string> extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Array 3', () => {
+    type T = Array<any> extends Array<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = Array<any> extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = Array<any> extends object ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = Array<any> extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = Array<any> extends { a: number } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({ a: Type.Number() }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 4', () => {
+    type T = Array<any> extends { length: '1' } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({ length: Type.Literal('1') }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 5', () => {
+    type T = Array<any> extends { length: number } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({ length: Type.Number() }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = Array<any> extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = Array<any> extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = Array<any> extends any | Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 4', () => {
+    type T = Array<string> extends any | Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 5', () => {
+    type T = Array<any> extends any | Array<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Array(Type.String())]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = Array<any> extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = Array<any> extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  // ----------------------------------------------
+  // Constrained
+  // ----------------------------------------------
+
+  it('Should extend constrained Any', () => {
+    type T = Array<string> extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained Unknown', () => {
+    type T = Array<string> extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained String', () => {
+    type T = Array<string> extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Boolean', () => {
+    type T = Array<string> extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Number', () => {
+    type T = Array<string> extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Integer', () => {
+    type T = Array<string> extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Array 1', () => {
+    type T = Array<string> extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained Array 2', () => {
+    type T = Array<string> extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained Array 3', () => {
+    type T = Array<string> extends Array<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained Tuple', () => {
+    type T = Array<string> extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Object 1', () => {
+    type T = Array<string> extends object ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained Object 2', () => {
+    type T = Array<string> extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained Object 3', () => {
+    type T = Array<string> extends { a: number } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({ a: Type.Number() }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Object 4', () => {
+    type T = Array<string> extends { length: '1' } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({ length: Type.Literal('1') }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Object 5', () => {
+    type T = Array<string> extends { length: number } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({ length: Type.Number() }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained Union 1', () => {
+    type T = Array<string> extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Null(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Union 2', () => {
+    type T = Array<string> extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained Union 3', () => {
+    type T = Array<string> extends any | Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained Union 4', () => {
+    type T = Array<string> extends any | Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained Union 5', () => {
+    type T = Array<string> extends any | Array<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.String())]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained Null', () => {
+    type T = Array<string> extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Undefined', () => {
+    type T = Array<string> extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Void', () => {
+    type T = Array<string> extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Date', () => {
+    type T = Array<string> extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/bigint.ts b/test/runtime/type/extends/bigint.ts
new file mode 100644
index 000000000..779cb8424
--- /dev/null
+++ b/test/runtime/type/extends/bigint.ts
@@ -0,0 +1,101 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/BigInt', () => {
+  it('Should extend Any', () => {
+    type T = bigint extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Unknown', () => {
+    type T = bigint extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend String', () => {
+    type T = bigint extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Boolean', () => {
+    type T = bigint extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Number', () => {
+    type T = bigint extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Integer', () => {
+    type T = bigint extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Array', () => {
+    type T = bigint extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Tuple', () => {
+    type T = bigint extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Record', () => {
+    type T = bigint extends Record<number, any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Object 1', () => {
+    type T = bigint extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Object 2', () => {
+    type T = bigint extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Object({ a: Type.Literal(10) }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Union 1', () => {
+    type T = bigint extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Union 2', () => {
+    type T = bigint extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Union 3', () => {
+    type T = bigint extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Union 4', () => {
+    type T = bigint extends boolean | bigint ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Union([Type.Boolean(), Type.BigInt()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Null', () => {
+    type T = bigint extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Undefined', () => {
+    type T = bigint extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Void', () => {
+    type T = bigint extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Date', () => {
+    type T = bigint extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.BigInt(), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/boolean.ts b/test/runtime/type/extends/boolean.ts
new file mode 100644
index 000000000..290eee289
--- /dev/null
+++ b/test/runtime/type/extends/boolean.ts
@@ -0,0 +1,107 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Boolean', () => {
+  it('Should extend Any', () => {
+    type T = boolean extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Boolean(), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = boolean extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Boolean(), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = boolean extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Boolean(), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Number', () => {
+    type T = boolean extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Boolean(), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = boolean extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Boolean(), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array', () => {
+    type T = boolean extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Boolean(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = boolean extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Boolean(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = boolean extends Record<number, any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = boolean extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Boolean(), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = boolean extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Boolean(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = boolean extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Boolean(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = boolean extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Boolean(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = boolean extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Boolean(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = boolean extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Boolean(), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = boolean extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Boolean(), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = boolean extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Boolean(), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Date', () => {
+    type T = boolean extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Boolean(), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/constructor.ts b/test/runtime/type/extends/constructor.ts
new file mode 100644
index 000000000..5746dbab4
--- /dev/null
+++ b/test/runtime/type/extends/constructor.ts
@@ -0,0 +1,250 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Constructor', () => {
+  it('Should extend Function', () => {
+    type T = (new () => number) extends () => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Function([], Type.Number()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Constructor 1', () => {
+    type T = (new () => number) extends new () => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Number()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Constructor 2', () => {
+    type T = (new () => any) extends new () => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Constructor 3', () => {
+    type T = (new () => number) extends new () => any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Constructor 4', () => {
+    type T = (new (a: number) => number) extends new () => any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([], Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Constructor 5', () => {
+    type T = (new (a: number | string) => number) extends new (a: number) => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([Type.Union([Type.Number(), Type.String()])], Type.Number()), Type.Constructor([Type.Number()], Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Constructor 6', () => {
+    type T = (new (a: number) => number) extends new (a: number | string) => any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([Type.Union([Type.Number(), Type.String()])], Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Constructor 7', () => {
+    type T = (new (a: number, b: number) => number) extends new (a: number) => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([Type.Number(), Type.Number()], Type.Number()), Type.Constructor([Type.Number()], Type.Number()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Constructor 8', () => {
+    type T = (new (a: number) => number) extends new (a: number, b: number) => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([Type.Number(), Type.Number()], Type.Number()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Constructor 9', () => {
+    type T = (new () => number) extends new () => any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Constructor 9', () => {
+    type T = (new () => any) extends new () => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Constructor 10', () => {
+    type T = (new () => Array<any>) extends new () => object ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Array(Type.Any())), Type.Constructor([], Type.Object({})))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Constructor 11', () => {
+    type T = (new () => Array<string>) extends new () => object ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Array(Type.String())), Type.Constructor([], Type.Object({})))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Constructor 12', () => {
+    type T = (new () => object) extends new () => Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Object({})), Type.Constructor([], Type.Array(Type.Any())))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Constructor 13', () => {
+    type T = (new (a: unknown) => number) extends new (a: any) => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([Type.Unknown()], Type.Number({})), Type.Constructor([Type.Any()], Type.Number({})))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Constructor 14', () => {
+    type T = (new (a: any) => number) extends new (a: unknown) => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([Type.Any()], Type.Number({})), Type.Constructor([Type.Unknown()], Type.Number({})))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Constructor 15', () => {
+    type T = (new () => any) extends new () => unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Any({})), Type.Constructor([], Type.Unknown({})))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Constructor 16', () => {
+    type T = (new () => unknown) extends new () => any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Unknown({})), Type.Constructor([], Type.Any({})))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Any', () => {
+    type T = (new () => number) extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = (new () => number) extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = (new () => number) extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = (new () => number) extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = (new () => number) extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array 1', () => {
+    type T = (new () => number) extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array 2', () => {
+    type T = (new () => number) extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array 3', () => {
+    type T = (new () => number) extends Array<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = (new () => number) extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = (() => number) extends Record<number, any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = (new () => number) extends object ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = (new () => number) extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = (new () => number) extends { a: number } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({ a: Type.Number() }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 4', () => {
+    type T = (new () => number) extends { length: '1' } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({ length: Type.Literal('1') }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = (new () => number) extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Null(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = (new () => number) extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = (new () => number) extends any | Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 4', () => {
+    type T = (new () => number) extends any | Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 5', () => {
+    type T = (new () => number) extends any | Array<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.String())]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = (new () => number) extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = (new () => number) extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = (new () => number) extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Date', () => {
+    type T = (new () => number) extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/date.ts b/test/runtime/type/extends/date.ts
new file mode 100644
index 000000000..53e7bfc55
--- /dev/null
+++ b/test/runtime/type/extends/date.ts
@@ -0,0 +1,112 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Date', () => {
+  it('Should extend Any', () => {
+    type T = Date extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = Date extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = Date extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = Date extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = Date extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = Date extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array', () => {
+    type T = Date extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Tuple', () => {
+    type T = Date extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = Date extends Record<number, any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = Date extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = Date extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = Date extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = Date extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = Date extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Null', () => {
+    type T = Date extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = Date extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = Date extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Date', () => {
+    type T = Date extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Date(), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+})
diff --git a/test/runtime/type/extends/function.ts b/test/runtime/type/extends/function.ts
new file mode 100644
index 000000000..93abeb0d4
--- /dev/null
+++ b/test/runtime/type/extends/function.ts
@@ -0,0 +1,251 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Function', () => {
+  it('Should extend Constructor 1', () => {
+    type T = (() => number) extends new () => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Constructor([], Type.Number()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Function 1', () => {
+    type T = (() => number) extends () => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Function([], Type.Number()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Function 2', () => {
+    type T = (() => any) extends () => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Function 3', () => {
+    type T = (() => number) extends () => any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Function 4', () => {
+    type T = ((a: number) => number) extends () => any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([Type.Number()], Type.Number()), Type.Function([], Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Function 5', () => {
+    type T = ((a: number | string) => number) extends (a: number) => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([Type.Union([Type.Number(), Type.String()])], Type.Number()), Type.Function([Type.Number()], Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Function 6', () => {
+    type T = ((a: number) => number) extends (a: number | string) => any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([Type.Number()], Type.Number()), Type.Function([Type.Union([Type.Number(), Type.String()])], Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Function 7', () => {
+    type T = ((a: number, b: number) => number) extends (a: number) => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([Type.Number(), Type.Number()], Type.Number()), Type.Function([Type.Number()], Type.Number()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Function 8', () => {
+    type T = ((a: number) => number) extends (a: number, b: number) => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([Type.Number()], Type.Number()), Type.Function([Type.Number(), Type.Number()], Type.Number()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Function 9', () => {
+    type T = (() => number) extends () => any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Function([], Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Function 9', () => {
+    type T = (() => any) extends () => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Function 10', () => {
+    type T = (() => Array<any>) extends () => object ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Array(Type.Any())), Type.Function([], Type.Object({})))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Function 11', () => {
+    type T = (() => Array<string>) extends () => object ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Array(Type.String())), Type.Function([], Type.Object({})))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Function 12', () => {
+    type T = (() => object) extends () => Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Object({})), Type.Function([], Type.Array(Type.Any())))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Function 13', () => {
+    type T = ((a: unknown) => number) extends (a: any) => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([Type.Unknown()], Type.Number({})), Type.Function([Type.Any()], Type.Number({})))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Function 14', () => {
+    type T = ((a: any) => number) extends (a: unknown) => number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([Type.Any()], Type.Number({})), Type.Function([Type.Unknown()], Type.Number({})))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Function 15', () => {
+    type T = (() => any) extends () => unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Any({})), Type.Function([], Type.Unknown({})))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Function 16', () => {
+    type T = (() => unknown) extends () => any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Unknown({})), Type.Function([], Type.Any({})))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Any', () => {
+    type T = (() => number) extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = (() => number) extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = (() => number) extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = (() => number) extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = (() => number) extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array 1', () => {
+    type T = (() => number) extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array 2', () => {
+    type T = (() => number) extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array 3', () => {
+    type T = (() => number) extends Array<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = (() => number) extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = (() => number) extends Record<number, any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = (() => number) extends object ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = (() => number) extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = (() => number) extends { a: number } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({ a: Type.Number() }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 4', () => {
+    type T = (() => number) extends { length: '1' } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({ length: Type.Literal('1') }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 5', () => {
+    type T = (() => number) extends { length: number } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({ length: Type.Number() }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = (() => number) extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Null(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = (() => number) extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = (() => number) extends any | Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 4', () => {
+    type T = (() => number) extends any | Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 5', () => {
+    type T = (() => number) extends any | Array<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.String())]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = (() => number) extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = (() => number) extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Date', () => {
+    type T = (() => number) extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/conditional/index.ts b/test/runtime/type/extends/index.ts
similarity index 91%
rename from test/runtime/conditional/index.ts
rename to test/runtime/type/extends/index.ts
index 1f7a88c56..ae680a5a0 100644
--- a/test/runtime/conditional/index.ts
+++ b/test/runtime/type/extends/index.ts
@@ -1,5 +1,6 @@
 import './any'
 import './array'
+import './bigint'
 import './boolean'
 import './constructor'
 import './date'
@@ -12,6 +13,7 @@ import './object'
 import './promise'
 import './record'
 import './string'
+import './symbol'
 import './tuple'
 import './uint8array'
 import './undefined'
diff --git a/test/runtime/type/extends/integer.ts b/test/runtime/type/extends/integer.ts
new file mode 100644
index 000000000..844e1ffdb
--- /dev/null
+++ b/test/runtime/type/extends/integer.ts
@@ -0,0 +1,113 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Integer', () => {
+  it('Should extend Any', () => {
+    type T = number extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = number extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = number extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = number extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = number extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Integer', () => {
+    type T = number extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Array', () => {
+    type T = number extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = number extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = number extends Record<number, any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = number extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = number extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.Object({ a: Type.Literal(10) }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = number extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = number extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = number extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = number extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = number extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = number extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Integer(), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Date', () => {
+    type T = number extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/literal.ts b/test/runtime/type/extends/literal.ts
new file mode 100644
index 000000000..71377e5e8
--- /dev/null
+++ b/test/runtime/type/extends/literal.ts
@@ -0,0 +1,312 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Literal', () => {
+  // -------------------------------------------------------------------
+  // String Literal
+  // -------------------------------------------------------------------
+  it('Should extend Any (String)', () => {
+    type T = 'hello' extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Unknown (String)', () => {
+    type T = 'hello' extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String (String)', () => {
+    type T = 'hello' extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal('hello'), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Boolean (String)', () => {
+    type T = 'hello' extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Number (String)', () => {
+    type T = 'hello' extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Integer (String)', () => {
+    type T = 'hello' extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array (String)', () => {
+    type T = 'hello' extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Tuple (String)', () => {
+    type T = 'hello' extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Object 1 (String)', () => {
+    type T = 'hello' extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 2 (String)', () => {
+    type T = 'hello' extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 1 (String)', () => {
+    type T = 'hello' extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 2 (String)', () => {
+    type T = 'hello' extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 3 (String)', () => {
+    type T = 'hello' extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Null (String)', () => {
+    type T = 'hello' extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Undefined (String)', () => {
+    type T = 'hello' extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  // -------------------------------------------------------------------
+  // Number Literal
+  // -------------------------------------------------------------------
+
+  it('Should extend Any (Number)', () => {
+    type T = 10 extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(10), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Unknown (Number)', () => {
+    type T = 10 extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(10), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String (Number)', () => {
+    type T = 10 extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(10), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Boolean (Number)', () => {
+    type T = 10 extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(10), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Number (Number)', () => {
+    type T = 10 extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(10), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Integer (Number)', () => {
+    type T = 10 extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(10), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Array (Number)', () => {
+    type T = 10 extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(10), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Tuple (Number)', () => {
+    type T = 10 extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(10), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Object 1 (Number)', () => {
+    type T = 10 extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(10), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 2 (Number)', () => {
+    type T = 10 extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(10), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 1 (Number)', () => {
+    type T = 10 extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(10), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 2 (Number)', () => {
+    type T = 10 extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(10), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 3 (Number)', () => {
+    type T = 10 extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(10), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Null (Number)', () => {
+    type T = 10 extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(10), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Undefined (Number)', () => {
+    type T = 10 extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(10), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  // -------------------------------------------------------------------
+  // Boolean Literal
+  // -------------------------------------------------------------------
+
+  it('Should extend Any (Boolean)', () => {
+    type T = true extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Unknown (Boolean)', () => {
+    type T = true extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String (Boolean)', () => {
+    type T = true extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Boolean (Boolean)', () => {
+    type T = true extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Number (Boolean)', () => {
+    type T = true extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Integer (Boolean)', () => {
+    type T = true extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array (Boolean)', () => {
+    type T = true extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Tuple (Boolean)', () => {
+    type T = true extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Record 1', () => {
+    type T = 'hello' extends Record<number, any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Record 2', () => {
+    type T = 10 extends Record<number, any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(10), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Record 3', () => {
+    type T = true extends Record<number, any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 1 (Boolean)', () => {
+    type T = true extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 2 (Boolean)', () => {
+    type T = true extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 1 (Boolean)', () => {
+    type T = true extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 2 (Boolean)', () => {
+    type T = true extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 3 (Boolean)', () => {
+    type T = true extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Null (Boolean)', () => {
+    type T = true extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Undefined (Boolean)', () => {
+    type T = true extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = true extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Date', () => {
+    type T = true extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Literal(true), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/null.ts b/test/runtime/type/extends/null.ts
new file mode 100644
index 000000000..82931c96d
--- /dev/null
+++ b/test/runtime/type/extends/null.ts
@@ -0,0 +1,119 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Null', () => {
+  it('Should extend Any', () => {
+    type T = null extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = null extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = null extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = null extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = null extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = null extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array', () => {
+    type T = null extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = null extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = null extends Record<number, any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = null extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = null extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = null extends object ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = null extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = null extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = null extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Null', () => {
+    type T = null extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = null extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = null extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Date', () => {
+    type T = null extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Null(), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/number.ts b/test/runtime/type/extends/number.ts
new file mode 100644
index 000000000..06e893f9d
--- /dev/null
+++ b/test/runtime/type/extends/number.ts
@@ -0,0 +1,113 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Number', () => {
+  it('Should extend Any', () => {
+    type T = number extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = number extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = number extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = number extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = number extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Integer', () => {
+    type T = number extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Array', () => {
+    type T = number extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = number extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = number extends Record<number, any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = number extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = number extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = number extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = number extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = number extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = number extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = number extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = number extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Date', () => {
+    type T = number extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/object.ts b/test/runtime/type/extends/object.ts
new file mode 100644
index 000000000..b5a2973ed
--- /dev/null
+++ b/test/runtime/type/extends/object.ts
@@ -0,0 +1,177 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Object', () => {
+  // ----------------------------------------------------------
+  // Object
+  // ----------------------------------------------------------
+  it('Should extend Object 1', () => {
+    type T = { x: number; y: number } extends { x: number } ? 1 : 2
+    const A = Type.Object({ x: Type.Number(), y: Type.Number() })
+    const B = Type.Object({ x: Type.Number() })
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Object 2', () => {
+    type T = { x: number } extends { x: number; y: number } ? 1 : 2
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ x: Type.Number(), y: Type.Number() })
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Object 3', () => {
+    type T = { x: number; y: string } extends { x: number } ? 1 : 2
+    const A = Type.Object({ x: Type.Number(), y: Type.String() })
+    const B = Type.Object({ x: Type.Number() })
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Object 4', () => {
+    type T = { x: number } extends { x: number; y: string } ? 1 : 2
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ x: Type.Number(), y: Type.String() })
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Object 5', () => {
+    type T = { x: number | string } extends { x: number } ? 1 : 2
+    const A = Type.Object({ x: Type.Union([Type.Number(), Type.String()]) })
+    const B = Type.Object({ x: Type.Number() })
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Object 6', () => {
+    type T = { x: number } extends { x: number | string } ? 1 : 2
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ x: Type.Union([Type.Number(), Type.String()]) })
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  // ----------------------------------------------------------
+  // Record
+  // ----------------------------------------------------------
+  it('Should extend Record 2', () => {
+    type T = { a: number; b: number } extends Record<string, number> ? 1 : 2
+    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
+    const B = Type.Record(Type.String(), Type.Number())
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Record 3', () => {
+    type T = { a: number; b: number } extends Record<number, number> ? 1 : 2
+    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
+    const B = Type.Record(Type.Number(), Type.Number())
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Record 4', () => {
+    type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
+    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
+    const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Record 5', () => {
+    type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
+    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
+    const B = Type.Record(Type.String(), Type.Number())
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Record 6', () => {
+    type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
+    const A = Type.Object({ a: Type.Number(), b: Type.Number() })
+    const B = Type.Record(Type.Number(), Type.Number())
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  // ----------------------------------------------------------
+  // Standard
+  // ----------------------------------------------------------
+  it('Should extend Any', () => {
+    type T = { a: number } extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend String', () => {
+    type T = { a: number } extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Boolean', () => {
+    type T = { a: number } extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Number', () => {
+    type T = { a: number } extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Integer', () => {
+    type T = { a: number } extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Array', () => {
+    type T = { a: number } extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Tuple', () => {
+    type T = { a: number } extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Object 1', () => {
+    type T = { a: number } extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Object 2', () => {
+    type T = { a: number } extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Object({ a: Type.Literal(10) }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Object 3', () => {
+    type T = { a: number } extends object ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Union 1', () => {
+    type T = { a: number } extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Union([Type.Null(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Union 2', () => {
+    type T = { a: number } extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Union 2', () => {
+    type T = { a: number } extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Null', () => {
+    type T = { a: number } extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Undefined', () => {
+    type T = { a: number } extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Void', () => {
+    type T = { a: number } extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Date', () => {
+    type T = { a: number } extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/promise.ts b/test/runtime/type/extends/promise.ts
new file mode 100644
index 000000000..b8c6a24db
--- /dev/null
+++ b/test/runtime/type/extends/promise.ts
@@ -0,0 +1,251 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Promise', () => {
+  // ----------------------------------------------
+  // Generic Varying
+  // ----------------------------------------------
+
+  it('Should extend Promise Varying 1', () => {
+    type T = Promise<any> extends Promise<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Promise(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Promise Varying 2', () => {
+    type T = Promise<string> extends Promise<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.String()), Type.Promise(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Promise Varying 3', () => {
+    type T = Promise<any> extends Promise<string> ? 1 : 2 // 1
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Promise(Type.String()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Promise Varying 4', () => {
+    type T = Promise<number> extends Promise<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Promise(Type.String()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  // ----------------------------------------------
+  // Any
+  // ----------------------------------------------
+
+  it('Should extend Any', () => {
+    type T = Promise<any> extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = Promise<any> extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = Promise<any> extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = Promise<any> extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = Promise<any> extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = Promise<any> extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array', () => {
+    type T = Promise<any> extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = Promise<any> extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = Promise<any> extends Record<number, any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = Promise<any> extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = Promise<any> extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = Promise<any> extends object ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = Promise<any> extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = Promise<any> extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = Promise<any> extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Null', () => {
+    type T = Promise<any> extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = Promise<any> extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  // ----------------------------------------------
+  // Constrained
+  // ----------------------------------------------
+
+  it('Should extend constrained Any', () => {
+    type T = Promise<number> extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained Unknown', () => {
+    type T = Promise<number> extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained String', () => {
+    type T = Promise<number> extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Boolean', () => {
+    type T = Promise<number> extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Number', () => {
+    type T = Promise<number> extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Integer', () => {
+    type T = Promise<number> extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Array', () => {
+    type T = Promise<number> extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Tuple', () => {
+    type T = Promise<number> extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Object 1', () => {
+    type T = Promise<number> extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained Object 2', () => {
+    type T = Promise<number> extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Object 3', () => {
+    type T = Promise<number> extends object ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained Union 1', () => {
+    type T = Promise<number> extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Union 2', () => {
+    type T = Promise<number> extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend constrained Union 2', () => {
+    type T = Promise<number> extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Null', () => {
+    type T = Promise<number> extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend constrained Undefined', () => {
+    type T = Promise<number> extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = Promise<number> extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Date', () => {
+    type T = Promise<number> extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/conditional/record.ts b/test/runtime/type/extends/record.ts
similarity index 58%
rename from test/runtime/conditional/record.ts
rename to test/runtime/type/extends/record.ts
index 396878420..74a7920a8 100644
--- a/test/runtime/conditional/record.ts
+++ b/test/runtime/type/extends/record.ts
@@ -1,94 +1,94 @@
-import { Structural, StructuralResult } from '@sinclair/typebox/conditional'
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
-describe('conditional/structural/Record', () => {
+describe('type/extends/Record', () => {
   it('Should extend Record 1', () => {
     type T = Record<'a' | 'b', number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
   })
 
   it('Should extend Record 2', () => {
     type T = Record<string, number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.False)
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 
   it('Should extend Record 3', () => {
     type T = Record<number, number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.False)
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 
   it('Should extend Record 4', () => {
     type T = Record<'a' | 'b', number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
   })
 
   it('Should extend Record 5', () => {
     type T = Record<'a' | 'b', number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
   })
 
   it('Should extend Record 6', () => {
     type T = Record<string, number> extends Record<'a' | 'b', number> ? true : false
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
   })
 
   it('Should extend Record 7', () => {
     type T = Record<string, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Record(Type.String(), Type.Number())
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
   })
 
   it('Should extend Record 8', () => {
     type T = Record<string, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Record(Type.Number(), Type.Number())
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
   })
 
   it('Should extend Record 9', () => {
     type T = Record<number, number> extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
     const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.False)
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 
   it('Should extend Record 10', () => {
     type T = Record<number, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
     const B = Type.Record(Type.String(), Type.Number())
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
   })
 
   it('Should extend Record 11', () => {
     type T = Record<number, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
     const B = Type.Record(Type.Number(), Type.Number())
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
   })
 
   // -----
@@ -97,32 +97,32 @@ describe('conditional/structural/Record', () => {
     type T = Record<string, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Record(Type.Integer(), Type.Number())
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
   })
 
   it('Should extend Record 13', () => {
     type T = Record<number, number> extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
     const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.False)
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 
   it('Should extend Record 14', () => {
     type T = Record<number, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
     const B = Type.Record(Type.String(), Type.Number())
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
   })
 
   it('Should extend Record 15', () => {
     type T = Record<number, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
     const B = Type.Record(Type.Integer(), Type.Number())
-    const R = Structural.Check(A, B)
-    Assert.deepEqual(R, StructuralResult.True)
+    const R = TypeExtends.Extends(A, B)
+    Assert.deepEqual(R, TypeExtendsResult.True)
   })
 
   // -------------------------------------------------------------------
@@ -131,109 +131,103 @@ describe('conditional/structural/Record', () => {
 
   it('Should extend Any', () => {
     type T = Record<number, number> extends any ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Any())
-    Assert.deepEqual(R, StructuralResult.True)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
   })
 
   it('Should extend Unknown', () => {
     type T = Record<number, number> extends unknown ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Unknown())
-    Assert.deepEqual(R, StructuralResult.True)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
   })
 
   it('Should extend String', () => {
     type T = Record<number, number> extends string ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.String())
-    Assert.deepEqual(R, StructuralResult.False)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 
   it('Should extend Boolean', () => {
     type T = Record<number, number> extends boolean ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Boolean())
-    Assert.deepEqual(R, StructuralResult.False)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 
   it('Should extend Number', () => {
     type T = Record<number, number> extends number ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Number())
-    Assert.deepEqual(R, StructuralResult.False)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 
   it('Should extend Integer', () => {
     type T = Record<number, number> extends number ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Integer())
-    Assert.deepEqual(R, StructuralResult.False)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 
   it('Should extend Array 1', () => {
     type T = Record<number, number> extends Array<any> ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, StructuralResult.False)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 
   it('Should extend Array 2', () => {
     type T = Record<number, number> extends Array<string> ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.String()))
-    Assert.deepEqual(R, StructuralResult.False)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.String()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 
   it('Should extend Tuple', () => {
     type T = Record<number, number> extends [number, number] ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, StructuralResult.False)
-  })
-
-  it('Should extend Object 1', () => {
-    type T = Record<number, number> extends object ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.True)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 
   it('Should extend Object 2', () => {
     type T = Record<number, number> extends {} ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Object({}))
-    Assert.deepEqual(R, StructuralResult.True)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
   })
 
   it('Should extend Object 3', () => {
     type T = Record<number, number> extends { a: number } ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Object({ a: Type.Number() }))
-    Assert.deepEqual(R, StructuralResult.False)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Object({ a: Type.Number() }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 
   it('Should extend Union 1', () => {
     type T = Record<number, number> extends number | string ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.False)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 
   it('Should extend Union 2', () => {
     type T = Record<number, number> extends any | number ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Any(), Type.String()]))
-    Assert.deepEqual(R, StructuralResult.True)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Any(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
   })
 
   it('Should extend Null', () => {
     type T = Record<number, number> extends null ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Null())
-    Assert.deepEqual(R, StructuralResult.False)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 
   it('Should extend Undefined', () => {
     type T = Record<number, number> extends undefined ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Undefined())
-    Assert.deepEqual(R, StructuralResult.False)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 
   it('Should extend Void', () => {
     type T = Record<number, number> extends void ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Void())
-    Assert.deepEqual(R, StructuralResult.False)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 
   it('Should extend Date', () => {
     type T = Record<number, number> extends Date ? 1 : 2
-    const R = Structural.Check(Type.Record(Type.Number(), Type.Number()), Type.Date())
-    Assert.deepEqual(R, StructuralResult.False)
+    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/string.ts b/test/runtime/type/extends/string.ts
new file mode 100644
index 000000000..1ba4aa486
--- /dev/null
+++ b/test/runtime/type/extends/string.ts
@@ -0,0 +1,131 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/String', () => {
+  it('Should extend Any', () => {
+    type T = string extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = string extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = string extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = string extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = string extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = string extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array', () => {
+    type T = string extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = string extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Record 1', () => {
+    type T = string extends Record<number, any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Record 2', () => {
+    type T = string extends Record<number, unknown> ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Unknown()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Record 3', () => {
+    type T = string extends Record<number, string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.String()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Record 4', () => {
+    type T = string extends Record<number, number> ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Number()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = string extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = string extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = number extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = number extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = number extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = number extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = number extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = number extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Date', () => {
+    type T = number extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Number(), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/symbol.ts b/test/runtime/type/extends/symbol.ts
new file mode 100644
index 000000000..402de3d61
--- /dev/null
+++ b/test/runtime/type/extends/symbol.ts
@@ -0,0 +1,106 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Symbol', () => {
+  it('Should extend Any', () => {
+    type T = symbol extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Unknown', () => {
+    type T = symbol extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend String', () => {
+    type T = symbol extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Boolean', () => {
+    type T = symbol extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Number', () => {
+    type T = symbol extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Integer', () => {
+    type T = symbol extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Array', () => {
+    type T = symbol extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Tuple', () => {
+    type T = symbol extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Record', () => {
+    type T = symbol extends Record<number, any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Object 1', () => {
+    type T = symbol extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Object 2', () => {
+    type T = symbol extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Object({ a: Type.Literal(10) }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Union 1', () => {
+    type T = symbol extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Union 2', () => {
+    type T = symbol extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Union 3', () => {
+    type T = symbol extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Union 4', () => {
+    type T = symbol extends boolean | symbol ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Union([Type.Boolean(), Type.Symbol()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Null', () => {
+    type T = symbol extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Undefined', () => {
+    type T = symbol extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Void', () => {
+    type T = symbol extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Date', () => {
+    type T = symbol extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Symbol', () => {
+    type T = symbol extends symbol ? 1 : 2
+    const R = TypeExtends.Extends(Type.Symbol(), Type.Symbol())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+})
diff --git a/test/runtime/type/extends/tuple.ts b/test/runtime/type/extends/tuple.ts
new file mode 100644
index 000000000..15486a6a6
--- /dev/null
+++ b/test/runtime/type/extends/tuple.ts
@@ -0,0 +1,161 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Tuple', () => {
+  it('Should extend Any', () => {
+    type T = [string, number] extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend String', () => {
+    type T = [string, number] extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Boolean', () => {
+    type T = [string, number] extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Number', () => {
+    type T = [string, number] extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Integer', () => {
+    type T = [string, number] extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Array 1', () => {
+    type T = [string, number] extends Array<any> ? 1 : 2 // 1
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Array 2', () => {
+    type T = [string, number] extends Array<string> ? 1 : 2 // 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.String()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Array 3', () => {
+    type T = [string, number] extends Array<string | number> ? 1 : 2 // 1
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Union([Type.String(), Type.Number()])))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Array 4', () => {
+    type T = [string, number] extends Array<string | number | boolean> ? 1 : 2 // 1
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Union([Type.String(), Type.Number(), Type.Boolean()])))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Tuple 1', () => {
+    type T = [string, number] extends [string, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Tuple 2', () => {
+    type T = [string, number] extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Tuple 3', () => {
+    type T = [string, any] extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Any()]), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Tuple 4', () => {
+    type T = [string, number] extends [string, any] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Any()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Tuple 5', () => {
+    type T = [string, unknown] extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Unknown()]), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Tuple 6', () => {
+    type T = [string, number] extends [string, unknown] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Unknown()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Tuple 7', () => {
+    type T = [] extends [string, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([]), Type.Tuple([Type.String(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Tuple 8', () => {
+    type T = [string, number] extends [] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Record 1', () => {
+    type T = [string, number] extends Record<number, any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Record 2', () => {
+    type T = [string, number] extends Record<number, unknown> ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Unknown()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Record 3', () => {
+    type T = [string, number] extends Record<number, string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.String()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Record 4', () => {
+    type T = [string, number] extends Record<number, number> ? 1 : 2
+    const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Number()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Object 1', () => {
+    type T = [string, number] extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Object 2', () => {
+    type T = [string, number] extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Object 3', () => {
+    type T = [string, number] extends object ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Union 1', () => {
+    type T = [string, number] extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Union 2', () => {
+    type T = [string, number] extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Union 2', () => {
+    type T = [string, number] extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Null', () => {
+    type T = [string, number] extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Undefined', () => {
+    type T = [string, number] extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Void', () => {
+    type T = [string, number] extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Date', () => {
+    type T = [string, number] extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/uint8array.ts b/test/runtime/type/extends/uint8array.ts
new file mode 100644
index 000000000..756a93d53
--- /dev/null
+++ b/test/runtime/type/extends/uint8array.ts
@@ -0,0 +1,113 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Uint8Array', () => {
+  it('Should extend Any', () => {
+    type T = Uint8Array extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = Uint8Array extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = Uint8Array extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = Uint8Array extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = Uint8Array extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = Uint8Array extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array', () => {
+    type T = Uint8Array extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = Uint8Array extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Record', () => {
+    type T = Uint8Array extends Record<number, any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Record(Type.Number(), Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = Uint8Array extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = Uint8Array extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = Uint8Array extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = Uint8Array extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = Uint8Array extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Null', () => {
+    type T = Uint8Array extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = Uint8Array extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = Uint8Array extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Date', () => {
+    type T = Uint8Array extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/undefined.ts b/test/runtime/type/extends/undefined.ts
new file mode 100644
index 000000000..46a4061a5
--- /dev/null
+++ b/test/runtime/type/extends/undefined.ts
@@ -0,0 +1,107 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Undefined', () => {
+  it('Should extend Any', () => {
+    type T = undefined extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = undefined extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = undefined extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = undefined extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = undefined extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array', () => {
+    type T = undefined extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = undefined extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = undefined extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = undefined extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = undefined extends object ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = undefined extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = undefined extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = undefined extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Null', () => {
+    type T = undefined extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = undefined extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Void', () => {
+    type T = undefined extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Date', () => {
+    type T = undefined extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Undefined(), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/union.ts b/test/runtime/type/extends/union.ts
new file mode 100644
index 000000000..ab749f76b
--- /dev/null
+++ b/test/runtime/type/extends/union.ts
@@ -0,0 +1,136 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Union', () => {
+  it('Should extend Any', () => {
+    type T = number | string extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend String', () => {
+    type T = number | string extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Boolean', () => {
+    type T = number | string extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Number', () => {
+    type T = number | string extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Integer', () => {
+    type T = number | string extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Array', () => {
+    type T = number | string extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Tuple', () => {
+    type T = number | string extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Object 1', () => {
+    type T = number | string extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Object 2', () => {
+    type T = number | string extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Union 1', () => {
+    type T = number | string extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Union 2', () => {
+    type T = number | string extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Union 3', () => {
+    type T = number | string extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Union 4', () => {
+    type T = any | boolean extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Union 5', () => {
+    type T = any | string extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Union 6', () => {
+    type T = any | {} extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Union 7', () => {
+    type T = any extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extend Union 8', () => {
+    type T = unknown | string extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Unknown(), Type.String()]), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Union 9', () => {
+    type T = unknown extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Null', () => {
+    type T = number | string extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Undefined', () => {
+    type T = number | string extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Void', () => {
+    type T = number | string extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Void 2', () => {
+    type T = number | string | void extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Date', () => {
+    type T = number | string | void extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Date 2', () => {
+    type T = Date | number | string | void extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Date(), Type.Number(), Type.String()]), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend BigInt', () => {
+    type T = bigint | number | string | void extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.BigInt(), Type.Number(), Type.String()]), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Symbol', () => {
+    type T = symbol | number | string | void extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Union([Type.Symbol(), Type.Number(), Type.String()]), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/unknown.ts b/test/runtime/type/extends/unknown.ts
new file mode 100644
index 000000000..c37f4c65f
--- /dev/null
+++ b/test/runtime/type/extends/unknown.ts
@@ -0,0 +1,119 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Unknown', () => {
+  it('Should extend Any', () => {
+    type T = unknown extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = unknown extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = unknown extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = unknown extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = unknown extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = unknown extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array 1', () => {
+    type T = unknown extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array 2', () => {
+    type T = unknown extends Array<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Array(Type.String()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = unknown extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = unknown extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = unknown extends { a: number } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Object({ a: Type.Number() }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = unknown extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = unknown extends any | number ? 1 : 2 // 1
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Any(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = unknown extends unknown | number ? 1 : 2 // 1
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Unknown(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 4', () => {
+    type T = unknown extends unknown | any ? 1 : 2 // 1
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Unknown(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = unknown extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = unknown extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = unknown extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Date', () => {
+    type T = unknown extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/void.ts b/test/runtime/type/extends/void.ts
new file mode 100644
index 000000000..d800fb08d
--- /dev/null
+++ b/test/runtime/type/extends/void.ts
@@ -0,0 +1,125 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Void', () => {
+  it('Should extend Any', () => {
+    type T = void extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Unknown', () => {
+    type T = void extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend String', () => {
+    type T = void extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Boolean', () => {
+    type T = void extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Number', () => {
+    type T = void extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Integer', () => {
+    type T = void extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array 1', () => {
+    type T = void extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Array 2', () => {
+    type T = void extends Array<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.Array(Type.String()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Tuple', () => {
+    type T = void extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 1', () => {
+    type T = void extends object ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 2', () => {
+    type T = void extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.Object({}))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Object 3', () => {
+    type T = void extends { a: number } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.Object({ a: Type.Number() }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 1', () => {
+    type T = void extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Union 2', () => {
+    type T = void extends any | number ? 1 : 2 // 1
+    const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Any(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 3', () => {
+    type T = void extends unknown | number ? 1 : 2 // 1
+    const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Unknown(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Union 4', () => {
+    type T = void extends unknown | any ? 1 : 2 // 1
+    const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Unknown(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Null', () => {
+    type T = void extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Undefined', () => {
+    type T = void extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+
+  it('Should extend Void', () => {
+    type T = void extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.Void())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+
+  it('Should extend Date', () => {
+    type T = void extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Void(), Type.Date())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/guard/any.ts b/test/runtime/type/guard/any.ts
similarity index 83%
rename from test/runtime/guard/any.ts
rename to test/runtime/type/guard/any.ts
index 039fa56ef..8f8e4d86c 100644
--- a/test/runtime/guard/any.ts
+++ b/test/runtime/type/guard/any.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TAny', () => {
   it('Should guard for TAny', () => {
diff --git a/test/runtime/guard/array.ts b/test/runtime/type/guard/array.ts
similarity index 94%
rename from test/runtime/guard/array.ts
rename to test/runtime/type/guard/array.ts
index 402614610..a6bec8803 100644
--- a/test/runtime/guard/array.ts
+++ b/test/runtime/type/guard/array.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TArray', () => {
   it('Should guard for TArray', () => {
diff --git a/test/runtime/type/guard/bigint.ts b/test/runtime/type/guard/bigint.ts
new file mode 100644
index 000000000..12be1911b
--- /dev/null
+++ b/test/runtime/type/guard/bigint.ts
@@ -0,0 +1,19 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TBigInt', () => {
+  it('Should guard for TBigInt', () => {
+    const R = TypeGuard.TBigInt(Type.BigInt())
+    Assert.equal(R, true)
+  })
+  it('Should not guard for TBigInt', () => {
+    const R = TypeGuard.TBigInt(null)
+    Assert.equal(R, false)
+  })
+  it('Should not guard for BigInt with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TBigInt(Type.BigInt({ $id: 1 }))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/boolean.ts b/test/runtime/type/guard/boolean.ts
similarity index 84%
rename from test/runtime/guard/boolean.ts
rename to test/runtime/type/guard/boolean.ts
index 71680414f..5368dedb2 100644
--- a/test/runtime/guard/boolean.ts
+++ b/test/runtime/type/guard/boolean.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TBoolean', () => {
   it('Should guard for TBoolean', () => {
diff --git a/test/runtime/guard/constructor.ts b/test/runtime/type/guard/constructor.ts
similarity index 93%
rename from test/runtime/guard/constructor.ts
rename to test/runtime/type/guard/constructor.ts
index 9bb2d4b37..813594c0c 100644
--- a/test/runtime/guard/constructor.ts
+++ b/test/runtime/type/guard/constructor.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TConstructor', () => {
   it('Should guard for TConstructor', () => {
diff --git a/test/runtime/guard/date.ts b/test/runtime/type/guard/date.ts
similarity index 92%
rename from test/runtime/guard/date.ts
rename to test/runtime/type/guard/date.ts
index 14132a7bd..b14cd4600 100644
--- a/test/runtime/guard/date.ts
+++ b/test/runtime/type/guard/date.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TDate', () => {
   it('Should guard for TDate', () => {
diff --git a/test/runtime/type/guard/exclude.ts b/test/runtime/type/guard/exclude.ts
new file mode 100644
index 000000000..be3e62261
--- /dev/null
+++ b/test/runtime/type/guard/exclude.ts
@@ -0,0 +1,24 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TExclude', () => {
+  it('Should extract string from number', () => {
+    const T = Type.Exclude(Type.String(), Type.Number())
+    Assert.deepEqual(TypeGuard.TString(T), true)
+  })
+  it('Should extract string from string', () => {
+    const T = Type.Exclude(Type.String(), Type.String())
+    Assert.deepEqual(TypeGuard.TNever(T), true)
+  })
+  it('Should extract string | number | boolean from string', () => {
+    const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
+    Assert.deepEqual(TypeGuard.TUnion(T), true)
+    Assert.deepEqual(TypeGuard.TNumber(T.anyOf[0]), true)
+    Assert.deepEqual(TypeGuard.TBoolean(T.anyOf[1]), true)
+  })
+  it('Should extract string | number | boolean from string | boolean', () => {
+    const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Boolean()]))
+    Assert.deepEqual(TypeGuard.TNumber(T), true)
+  })
+})
diff --git a/test/runtime/type/guard/extract.ts b/test/runtime/type/guard/extract.ts
new file mode 100644
index 000000000..f1caa3737
--- /dev/null
+++ b/test/runtime/type/guard/extract.ts
@@ -0,0 +1,24 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TExtract', () => {
+  it('Should extract string from number', () => {
+    const T = Type.Extract(Type.String(), Type.Number())
+    Assert.deepEqual(TypeGuard.TNever(T), true)
+  })
+  it('Should extract string from string', () => {
+    const T = Type.Extract(Type.String(), Type.String())
+    Assert.deepEqual(TypeGuard.TString(T), true)
+  })
+  it('Should extract string | number | boolean from string', () => {
+    const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
+    Assert.deepEqual(TypeGuard.TString(T), true)
+  })
+  it('Should extract string | number | boolean from string | boolean', () => {
+    const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Boolean()]))
+    Assert.deepEqual(TypeGuard.TUnion(T), true)
+    Assert.deepEqual(TypeGuard.TString(T.anyOf[0]), true)
+    Assert.deepEqual(TypeGuard.TBoolean(T.anyOf[1]), true)
+  })
+})
diff --git a/test/runtime/guard/function.ts b/test/runtime/type/guard/function.ts
similarity index 93%
rename from test/runtime/guard/function.ts
rename to test/runtime/type/guard/function.ts
index 102ac4f14..e70b67d57 100644
--- a/test/runtime/guard/function.ts
+++ b/test/runtime/type/guard/function.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TFunction', () => {
   it('Should guard for TFunction', () => {
diff --git a/test/runtime/guard/index.ts b/test/runtime/type/guard/index.ts
similarity index 78%
rename from test/runtime/guard/index.ts
rename to test/runtime/type/guard/index.ts
index 037d13781..d66cdf0f5 100644
--- a/test/runtime/guard/index.ts
+++ b/test/runtime/type/guard/index.ts
@@ -1,11 +1,16 @@
 import './any'
 import './array'
+import './bigint'
 import './boolean'
 import './constructor'
 import './date'
+import './exclude'
+import './extract'
 import './function'
 import './integer'
 import './literal'
+import './intersect'
+import './not'
 import './null'
 import './number'
 import './object'
@@ -14,6 +19,7 @@ import './record'
 import './ref'
 import './self'
 import './string'
+import './symbol'
 import './tuple'
 import './uint8array'
 import './undefined'
diff --git a/test/runtime/guard/integer.ts b/test/runtime/type/guard/integer.ts
similarity index 93%
rename from test/runtime/guard/integer.ts
rename to test/runtime/type/guard/integer.ts
index 72558e07e..28976d20e 100644
--- a/test/runtime/guard/integer.ts
+++ b/test/runtime/type/guard/integer.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TInteger', () => {
   it('Should guard for TInteger', () => {
diff --git a/test/runtime/type/guard/intersect.ts b/test/runtime/type/guard/intersect.ts
new file mode 100644
index 000000000..907b4a72d
--- /dev/null
+++ b/test/runtime/type/guard/intersect.ts
@@ -0,0 +1,32 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TUnion', () => {
+  it('Should guard for TIntersect', () => {
+    const R = TypeGuard.TIntersect(
+      Type.Intersect([
+        Type.Object({
+          x: Type.Number(),
+        }),
+        Type.Object({
+          y: Type.Number(),
+        }),
+      ]),
+    )
+    Assert.equal(R, true)
+  })
+  it('Should not guard for TIntersect', () => {
+    const R = TypeGuard.TIntersect(
+      Type.Union([
+        Type.Object({
+          x: Type.Number(),
+        }),
+        Type.Object({
+          y: Type.Number(),
+        }),
+      ]),
+    )
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/literal.ts b/test/runtime/type/guard/literal.ts
similarity index 91%
rename from test/runtime/guard/literal.ts
rename to test/runtime/type/guard/literal.ts
index df4d39e24..674c9dd40 100644
--- a/test/runtime/guard/literal.ts
+++ b/test/runtime/type/guard/literal.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TLiteral', () => {
   it('Should guard for TLiteral of String', () => {
diff --git a/test/runtime/type/guard/not.ts b/test/runtime/type/guard/not.ts
new file mode 100644
index 000000000..0bbc9d5ec
--- /dev/null
+++ b/test/runtime/type/guard/not.ts
@@ -0,0 +1,23 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TNot', () => {
+  it('Should guard for TNot', () => {
+    const R = TypeGuard.TNot(Type.Not(Type.String(), Type.String()))
+    Assert.equal(R, true)
+  })
+  it('Should not guard for TNot 1', () => {
+    const R = TypeGuard.TNot(Type.Not(null as any, Type.String()))
+    Assert.equal(R, false)
+  })
+  it('Should not guard for TNot 2', () => {
+    const R = TypeGuard.TNot(Type.Not(Type.String(), null as any))
+    Assert.equal(R, false)
+  })
+  it('Should not guard for TNot with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TNot(Type.Not(Type.String(), Type.String()), { $id: 1 })
+    Assert.equal(R, true)
+  })
+})
diff --git a/test/runtime/guard/null.ts b/test/runtime/type/guard/null.ts
similarity index 83%
rename from test/runtime/guard/null.ts
rename to test/runtime/type/guard/null.ts
index d853e112f..11656ab0c 100644
--- a/test/runtime/guard/null.ts
+++ b/test/runtime/type/guard/null.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TNull', () => {
   it('Should guard for TNull', () => {
diff --git a/test/runtime/guard/number.ts b/test/runtime/type/guard/number.ts
similarity index 93%
rename from test/runtime/guard/number.ts
rename to test/runtime/type/guard/number.ts
index eb6141606..c325b27b4 100644
--- a/test/runtime/guard/number.ts
+++ b/test/runtime/type/guard/number.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TNumber', () => {
   it('Should guard for TNumber', () => {
diff --git a/test/runtime/guard/object.ts b/test/runtime/type/guard/object.ts
similarity index 96%
rename from test/runtime/guard/object.ts
rename to test/runtime/type/guard/object.ts
index 867774afc..2cdb5044c 100644
--- a/test/runtime/guard/object.ts
+++ b/test/runtime/type/guard/object.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TObject', () => {
   it('Should guard for TObject', () => {
diff --git a/test/runtime/guard/promise.ts b/test/runtime/type/guard/promise.ts
similarity index 91%
rename from test/runtime/guard/promise.ts
rename to test/runtime/type/guard/promise.ts
index fdfbfb184..eeedaf2f0 100644
--- a/test/runtime/guard/promise.ts
+++ b/test/runtime/type/guard/promise.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TPromise', () => {
   it('Should guard for TPromise', () => {
diff --git a/test/runtime/guard/record.ts b/test/runtime/type/guard/record.ts
similarity index 66%
rename from test/runtime/guard/record.ts
rename to test/runtime/type/guard/record.ts
index 92ab62c00..2418c0e3d 100644
--- a/test/runtime/guard/record.ts
+++ b/test/runtime/type/guard/record.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TRecord', () => {
   it('Should guard for TRecord', () => {
@@ -45,9 +45,14 @@ describe('type/guard/TRecord', () => {
     Assert.equal(R, false)
   })
 
-  it('Should not guard for TRecord with invalid literal key', () => {
-    const K = Type.Union([Type.Literal('hello\nworld')])
-    const R = TypeGuard.TRecord(Type.Record(K, Type.Number()))
-    Assert.equal(R, false)
+  it('Transform: Should should transform to TObject for single literal union value', () => {
+    const K = Type.Union([Type.Literal('ok')])
+    const R = TypeGuard.TObject(Type.Record(K, Type.Number()))
+    Assert.equal(R, true)
+  })
+  it('Transform: Should should transform to TObject for multi literal union value', () => {
+    const K = Type.Union([Type.Literal('A'), Type.Literal('B')])
+    const R = TypeGuard.TObject(Type.Record(K, Type.Number()))
+    Assert.equal(R, true)
   })
 })
diff --git a/test/runtime/guard/ref.ts b/test/runtime/type/guard/ref.ts
similarity index 85%
rename from test/runtime/guard/ref.ts
rename to test/runtime/type/guard/ref.ts
index 6a4a8e883..e76680cf7 100644
--- a/test/runtime/guard/ref.ts
+++ b/test/runtime/type/guard/ref.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TRef', () => {
   it('Should guard for TRef', () => {
diff --git a/test/runtime/guard/self.ts b/test/runtime/type/guard/self.ts
similarity index 85%
rename from test/runtime/guard/self.ts
rename to test/runtime/type/guard/self.ts
index 824d77ee8..d9059c1ba 100644
--- a/test/runtime/guard/self.ts
+++ b/test/runtime/type/guard/self.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TSelf', () => {
   it('Should guard for TSelf', () => {
diff --git a/test/runtime/guard/string.ts b/test/runtime/type/guard/string.ts
similarity index 91%
rename from test/runtime/guard/string.ts
rename to test/runtime/type/guard/string.ts
index a3cc7c224..24b33dd1e 100644
--- a/test/runtime/guard/string.ts
+++ b/test/runtime/type/guard/string.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TString', () => {
   it('Should guard for TString', () => {
diff --git a/test/runtime/type/guard/symbol.ts b/test/runtime/type/guard/symbol.ts
new file mode 100644
index 000000000..7683f099e
--- /dev/null
+++ b/test/runtime/type/guard/symbol.ts
@@ -0,0 +1,19 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TSymbol', () => {
+  it('Should guard for TSymbol', () => {
+    const R = TypeGuard.TSymbol(Type.Symbol())
+    Assert.equal(R, true)
+  })
+  it('Should not guard for TSymbol', () => {
+    const R = TypeGuard.TSymbol(null)
+    Assert.equal(R, false)
+  })
+  it('Should not guard for TSymbol with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.TSymbol(Type.Symbol({ $id: 1 }))
+    Assert.equal(R, false)
+  })
+})
diff --git a/test/runtime/guard/tuple.ts b/test/runtime/type/guard/tuple.ts
similarity index 88%
rename from test/runtime/guard/tuple.ts
rename to test/runtime/type/guard/tuple.ts
index 935426e24..8e549aa57 100644
--- a/test/runtime/guard/tuple.ts
+++ b/test/runtime/type/guard/tuple.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TTuple', () => {
   it('Should guard for TTuple', () => {
diff --git a/test/runtime/guard/uint8array.ts b/test/runtime/type/guard/uint8array.ts
similarity index 90%
rename from test/runtime/guard/uint8array.ts
rename to test/runtime/type/guard/uint8array.ts
index 0143c3f47..cd4c741e7 100644
--- a/test/runtime/guard/uint8array.ts
+++ b/test/runtime/type/guard/uint8array.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TUint8Array', () => {
   it('Should guard for TUint8Array', () => {
diff --git a/test/runtime/guard/undefined.ts b/test/runtime/type/guard/undefined.ts
similarity index 84%
rename from test/runtime/guard/undefined.ts
rename to test/runtime/type/guard/undefined.ts
index 0b7f471c8..cc8bbeea3 100644
--- a/test/runtime/guard/undefined.ts
+++ b/test/runtime/type/guard/undefined.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TUndefined', () => {
   it('Should guard for TUndefined', () => {
diff --git a/test/runtime/guard/union.ts b/test/runtime/type/guard/union.ts
similarity index 63%
rename from test/runtime/guard/union.ts
rename to test/runtime/type/guard/union.ts
index b26465a2e..16fc75d41 100644
--- a/test/runtime/guard/union.ts
+++ b/test/runtime/type/guard/union.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TUnion', () => {
   it('Should guard for TUnion', () => {
@@ -22,6 +22,7 @@ describe('type/guard/TUnion', () => {
   })
   it('Should guard for TUnion with invalid $id', () => {
     const R = TypeGuard.TUnion(
+      // @ts-ignore
       Type.Union(
         [
           Type.Object({
@@ -63,4 +64,23 @@ describe('type/guard/TUnion', () => {
     )
     Assert.equal(R, false)
   })
+  it('Transform: Should transform to never for zero length union', () => {
+    const T = Type.Union([])
+    const R = TypeGuard.TNever(T)
+    Assert.equal(R, true)
+  })
+  it('Transform: Should unwrap union type for array of length === 1', () => {
+    const T = Type.Union([Type.String()])
+    const R = TypeGuard.TString(T)
+    Assert.equal(R, true)
+  })
+  it('Transform: Should retain union if array length > 1', () => {
+    const T = Type.Union([Type.String(), Type.Number()])
+    const R1 = TypeGuard.TUnion(T)
+    const R2 = TypeGuard.TString(T.anyOf[0])
+    const R3 = TypeGuard.TNumber(T.anyOf[1])
+    Assert.equal(R1, true)
+    Assert.equal(R2, true)
+    Assert.equal(R3, true)
+  })
 })
diff --git a/test/runtime/guard/unknown.ts b/test/runtime/type/guard/unknown.ts
similarity index 84%
rename from test/runtime/guard/unknown.ts
rename to test/runtime/type/guard/unknown.ts
index d23f2c267..4d3e5980c 100644
--- a/test/runtime/guard/unknown.ts
+++ b/test/runtime/type/guard/unknown.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TUnknown', () => {
   it('Should guard for TUnknown', () => {
diff --git a/test/runtime/guard/void.ts b/test/runtime/type/guard/void.ts
similarity index 83%
rename from test/runtime/guard/void.ts
rename to test/runtime/type/guard/void.ts
index d513f5f2a..839719a2f 100644
--- a/test/runtime/guard/void.ts
+++ b/test/runtime/type/guard/void.ts
@@ -1,6 +1,6 @@
-import { TypeGuard } from '@sinclair/typebox/guard'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
+import { Assert } from '../../assert/index'
 
 describe('type/guard/TVoid', () => {
   it('Should guard for TVoid', () => {
diff --git a/test/runtime/type/index.ts b/test/runtime/type/index.ts
new file mode 100644
index 000000000..2ec254a35
--- /dev/null
+++ b/test/runtime/type/index.ts
@@ -0,0 +1,5 @@
+import './clone/index'
+import './extends/index'
+import './guard/index'
+import './registry/index'
+import './normal/index'
diff --git a/test/runtime/type/normal/exclude.ts b/test/runtime/type/normal/exclude.ts
new file mode 100644
index 000000000..fd0234242
--- /dev/null
+++ b/test/runtime/type/normal/exclude.ts
@@ -0,0 +1,21 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/normal/Exclude', () => {
+  it('Normalize 1', () => {
+    const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
+    const R = TypeGuard.TUnion(T)
+    Assert.deepEqual(R, true)
+  })
+  it('Normalize 2', () => {
+    const T = Type.Exclude(Type.Union([Type.String(), Type.Number()]), Type.String())
+    const R = TypeGuard.TNumber(T)
+    Assert.deepEqual(R, true)
+  })
+  it('Normalize 3', () => {
+    const T = Type.Exclude(Type.Union([Type.String()]), Type.String())
+    const R = TypeGuard.TNever(T)
+    Assert.deepEqual(R, true)
+  })
+})
diff --git a/test/runtime/type/normal/extract.ts b/test/runtime/type/normal/extract.ts
new file mode 100644
index 000000000..bb3a3d09d
--- /dev/null
+++ b/test/runtime/type/normal/extract.ts
@@ -0,0 +1,31 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/normal/Extract', () => {
+  it('Normalize 1', () => {
+    const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Number()]))
+    const R = TypeGuard.TUnion(T)
+    Assert.deepEqual(R, true)
+  })
+  it('Normalize 2', () => {
+    const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
+    const R = TypeGuard.TString(T)
+    Assert.deepEqual(R, true)
+  })
+  it('Normalize 3', () => {
+    const T = Type.Extract(Type.Union([Type.String(), Type.Number()]), Type.String())
+    const R = TypeGuard.TString(T)
+    Assert.deepEqual(R, true)
+  })
+  it('Normalize 4', () => {
+    const T = Type.Extract(Type.Union([Type.String()]), Type.String())
+    const R = TypeGuard.TString(T)
+    Assert.deepEqual(R, true)
+  })
+  it('Normalize 5', () => {
+    const T = Type.Extract(Type.Union([]), Type.String())
+    const R = TypeGuard.TNever(T)
+    Assert.deepEqual(R, true)
+  })
+})
diff --git a/test/runtime/type/normal/index.ts b/test/runtime/type/normal/index.ts
new file mode 100644
index 000000000..d0d7e13fd
--- /dev/null
+++ b/test/runtime/type/normal/index.ts
@@ -0,0 +1,5 @@
+import './exclude'
+import './extract'
+import './intersect'
+import './record'
+import './union'
diff --git a/test/runtime/type/normal/intersect.ts b/test/runtime/type/normal/intersect.ts
new file mode 100644
index 000000000..95accfd2d
--- /dev/null
+++ b/test/runtime/type/normal/intersect.ts
@@ -0,0 +1,21 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/normal/Intersect', () => {
+  it('Normalize 1', () => {
+    const T = Type.Intersect([Type.Number(), Type.String()])
+    const R = TypeGuard.TIntersect(T)
+    Assert.deepEqual(R, true)
+  })
+  it('Normalize 2', () => {
+    const T = Type.Intersect([Type.Number()])
+    const R = TypeGuard.TNumber(T)
+    Assert.deepEqual(R, true)
+  })
+  it('Normalize 3', () => {
+    const T = Type.Intersect([])
+    const R = TypeGuard.TNever(T)
+    Assert.deepEqual(R, true)
+  })
+})
diff --git a/test/runtime/type/normal/record.ts b/test/runtime/type/normal/record.ts
new file mode 100644
index 000000000..53337902f
--- /dev/null
+++ b/test/runtime/type/normal/record.ts
@@ -0,0 +1,12 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/normal/Record', () => {
+  it('Normalize 1', () => {
+    const K = Type.Union([Type.Literal('A'), Type.Literal('B')])
+    const T = Type.Record(K, Type.String())
+    const R = TypeGuard.TObject(T)
+    Assert.deepEqual(R, true)
+  })
+})
diff --git a/test/runtime/type/normal/union.ts b/test/runtime/type/normal/union.ts
new file mode 100644
index 000000000..44e5a7ece
--- /dev/null
+++ b/test/runtime/type/normal/union.ts
@@ -0,0 +1,21 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/normal/Union', () => {
+  it('Normalize 1', () => {
+    const T = Type.Union([Type.Number(), Type.String()])
+    const R = TypeGuard.TUnion(T)
+    Assert.deepEqual(R, true)
+  })
+  it('Normalize 2', () => {
+    const T = Type.Union([Type.Number()])
+    const R = TypeGuard.TNumber(T)
+    Assert.deepEqual(R, true)
+  })
+  it('Normalize 3', () => {
+    const T = Type.Union([])
+    const R = TypeGuard.TNever(T)
+    Assert.deepEqual(R, true)
+  })
+})
diff --git a/test/runtime/type/registry/format.ts b/test/runtime/type/registry/format.ts
new file mode 100644
index 000000000..7f04d15d3
--- /dev/null
+++ b/test/runtime/type/registry/format.ts
@@ -0,0 +1,25 @@
+import { FormatRegistry } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('format/Format', () => {
+  it('Should set format', () => {
+    FormatRegistry.Set('test#format1', () => true)
+  })
+
+  it('Should get format', () => {
+    FormatRegistry.Set('test#format2', () => true)
+    const format = FormatRegistry.Get('test#format2')
+    Assert.equal(typeof format, 'function')
+  })
+
+  it('Should return true if exists', () => {
+    FormatRegistry.Set('test#format3', () => true)
+    Assert.equal(FormatRegistry.Has('test#format3'), true)
+  })
+
+  it('Should clear formats', () => {
+    FormatRegistry.Set('test#format4', () => true)
+    FormatRegistry.Clear()
+    Assert.equal(FormatRegistry.Has('test#format4'), false)
+  })
+})
diff --git a/test/runtime/format/index.ts b/test/runtime/type/registry/index.ts
similarity index 100%
rename from test/runtime/format/index.ts
rename to test/runtime/type/registry/index.ts
diff --git a/test/runtime/value/cast/any.ts b/test/runtime/value/cast/any.ts
index 155b2fcaa..a294da43f 100644
--- a/test/runtime/value/cast/any.ts
+++ b/test/runtime/value/cast/any.ts
@@ -34,19 +34,16 @@ describe('value/cast/Any', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result.getTime(100), 100)
   })
-
   it('Should preserve', () => {
     const value = { a: 1, b: 2 }
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/array.ts b/test/runtime/value/cast/array.ts
index fca7b4719..820c3f699 100644
--- a/test/runtime/value/cast/array.ts
+++ b/test/runtime/value/cast/array.ts
@@ -5,135 +5,110 @@ import { Assert } from '../../assert/index'
 describe('value/cast/Array', () => {
   const T = Type.Array(Type.Number(), { default: [1, 2, 3] })
   const E = [1, 2, 3]
-
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, [1])
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preserve', () => {
     const value = [6, 7, 8]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, [6, 7, 8])
   })
-
   it('Should preserve with invalid element set to default', () => {
     const value = [6, 7, 8, 'hello', 9]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, [6, 7, 8, 0, 9])
   })
-
   // -----------------------------------------------------------------
   // Constraints: Ranges
   // -----------------------------------------------------------------
-
   it('Should cast array and truncate to maxItems from value', () => {
     const result = Value.Cast(Type.Array(Type.Number(), { maxItems: 3 }), [0, 1, 2, 4, 5, 6])
     Assert.deepEqual(result, [0, 1, 2])
   })
-
   it('Should cast arrays and append array to minItems from value', () => {
     const result = Value.Cast(Type.Array(Type.Number(), { minItems: 6 }), [0, 1, 2])
     Assert.deepEqual(result, [0, 1, 2, 0, 0, 0])
   })
-
   it('Should cast array and truncate to maxItems from default value', () => {
     const result = Value.Cast(Type.Array(Type.Number(), { maxItems: 3, default: [0, 1, 2, 4, 5, 6] }), null)
     Assert.deepEqual(result, [0, 1, 2])
   })
-
   it('Should cast arrays and append array to minItems from default value', () => {
     const result = Value.Cast(Type.Array(Type.Number({ default: 1 }), { minItems: 6, default: [0, 1, 2] }), null)
     Assert.deepEqual(result, [0, 1, 2, 1, 1, 1])
   })
-
   // -----------------------------------------------------------------
   // Constraints: Unique
   // -----------------------------------------------------------------
-
   it('Should cast arrays with uniqueItems with unique default value', () => {
     const result = Value.Cast(Type.Array(Type.Number(), { uniqueItems: true, default: [0, 1, 2] }), null)
     Assert.deepEqual(result, [0, 1, 2])
   })
-
   it('Should cast arrays with uniqueItems with unique value', () => {
     const result = Value.Cast(Type.Array(Type.Number(), { uniqueItems: true }), [0, 1, 2])
     Assert.deepEqual(result, [0, 1, 2])
   })
-
   it('Should throw when casting arrays with uniqueItems and no value or default value', () => {
     Assert.throws(() => Value.Cast(Type.Array(Type.Number(), { uniqueItems: true }), null))
   })
-
   it('Should throw when casting arrays with uniqueItems and not enough values to populate set', () => {
     Assert.throws(() => Value.Cast(Type.Array(Type.Number(), { minItems: 3, uniqueItems: true }), [0, 1]))
   })
-
   it('Should throw when casting arrays with uniqueItems and not enough default values to populate set', () => {
     Assert.throws(() => Value.Cast(Type.Array(Type.Number(), { minItems: 3, uniqueItems: true, default: [0, 1] }), null))
   })
-
   // -----------------------------------------------------------------
   // Suggestion: https://github.com/sinclairzx81/typebox/issues/239
   // -----------------------------------------------------------------
-
   it('Should remove duplicates if uniqueItems is true', () => {
     const T = Type.Array(Type.Number(), { uniqueItems: true })
     const value = [1, 1, 2, 2]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, [1, 2])
   })
-
   it('Should should fill up with defaults to minItems', () => {
     const T = Type.Array(Type.Number(), { minItems: 3 })
     const value = [1, 2]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, [1, 2, 0])
   })
-
   it('Should should truncate to maxItems', () => {
     const T = Type.Array(Type.Number(), { maxItems: 3 })
     const value = [1, 2, 3, 4]
diff --git a/test/runtime/value/cast/bigint.ts b/test/runtime/value/cast/bigint.ts
new file mode 100644
index 000000000..8e69e3756
--- /dev/null
+++ b/test/runtime/value/cast/bigint.ts
@@ -0,0 +1,53 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/BigInt', () => {
+  const T = Type.BigInt()
+  const E = BigInt(0)
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from number', () => {
+    const value = 0
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should preserve', () => {
+    const value = BigInt(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, BigInt(100))
+  })
+})
diff --git a/test/runtime/value/cast/boolean.ts b/test/runtime/value/cast/boolean.ts
index d0267b52e..a790df65b 100644
--- a/test/runtime/value/cast/boolean.ts
+++ b/test/runtime/value/cast/boolean.ts
@@ -5,13 +5,11 @@ import { Assert } from '../../assert/index'
 describe('value/cast/Boolean', () => {
   const T = Type.Boolean()
   const E = false
-
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from number', () => {
     const value = 0
     const result = Value.Cast(T, value)
@@ -32,25 +30,21 @@ describe('value/cast/Boolean', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preserve', () => {
     const value = true
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/composite.ts b/test/runtime/value/cast/composite.ts
new file mode 100644
index 000000000..781cf2448
--- /dev/null
+++ b/test/runtime/value/cast/composite.ts
@@ -0,0 +1,89 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Composite', () => {
+  const A = Type.Object({
+    x: Type.Number({ default: 0 }),
+    y: Type.Number({ default: 1 }),
+    z: Type.Number({ default: 2 }),
+  })
+  const B = Type.Object({
+    a: Type.Number({ default: 'a' }),
+    b: Type.Number({ default: 'b' }),
+    c: Type.Number({ default: 'c' }),
+  })
+  const T = Type.Composite([A, B])
+  const E = {
+    x: 0,
+    y: 1,
+    z: 2,
+    a: 'a',
+    b: 'b',
+    c: 'c',
+  }
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from number', () => {
+    const value = E
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast and preserve object', () => {
+    const value = { x: 7, y: 8, z: 9 }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, {
+      x: 7,
+      y: 8,
+      z: 9,
+      a: 'a',
+      b: 'b',
+      c: 'c',
+    })
+  })
+  it('Should upcast and preserve from incorrect properties', () => {
+    const value = { x: {}, y: 8, z: 9 }
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, {
+      x: 0,
+      y: 8,
+      z: 9,
+      a: 'a',
+      b: 'b',
+      c: 'c',
+    })
+  })
+})
diff --git a/test/runtime/value/cast/convert.ts b/test/runtime/value/cast/convert.ts
deleted file mode 100644
index 825dddc73..000000000
--- a/test/runtime/value/cast/convert.ts
+++ /dev/null
@@ -1,291 +0,0 @@
-import { Value } from '@sinclair/typebox/value'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
-
-//---------------------------------------------------------------
-// String Convert
-//---------------------------------------------------------------
-describe('value/convert/String', () => {
-  it('Should convert string', () => {
-    const value = 'hello'
-    const result = Value.Cast(Type.String(), value)
-    Assert.deepEqual(result, 'hello')
-  })
-  it('Should convert number #1', () => {
-    const value = 42
-    const result = Value.Cast(Type.String(), value)
-    Assert.deepEqual(result, '42')
-  })
-  it('Should convert number #2', () => {
-    const value = 42n
-    const result = Value.Cast(Type.String(), value)
-    Assert.deepEqual(result, '42')
-  })
-  it('Should convert true', () => {
-    const value = true
-    const result = Value.Cast(Type.String(), value)
-    Assert.deepEqual(result, 'true')
-  })
-  it('Should convert false', () => {
-    const value = false
-    const result = Value.Cast(Type.String(), value)
-    Assert.deepEqual(result, 'false')
-  })
-  it('Should convert object', () => {
-    const value = {}
-    const result = Value.Cast(Type.String(), value)
-    Assert.deepEqual(result, '')
-  })
-  it('Should convert array', () => {
-    const value = [] as any[]
-    const result = Value.Cast(Type.String(), value)
-    Assert.deepEqual(result, '')
-  })
-})
-//---------------------------------------------------------------
-// Number Convert
-//---------------------------------------------------------------
-describe('value/convert/Number', () => {
-  it('Should convert string #1', () => {
-    const value = 'hello'
-    const result = Value.Cast(Type.Number(), value)
-    Assert.deepEqual(result, 0)
-  })
-  it('Should convert string #2', () => {
-    const value = '3.14'
-    const result = Value.Cast(Type.Number(), value)
-    Assert.deepEqual(result, 3.14)
-  })
-  it('Should convert string #3', () => {
-    const value = '-0'
-    const result = Value.Cast(Type.Number(), value)
-    Assert.deepEqual(result, 0)
-  })
-  it('Should convert string #4', () => {
-    const value = '-100'
-    const result = Value.Cast(Type.Number(), value)
-    Assert.deepEqual(result, -100)
-  })
-  it('Should convert number', () => {
-    const value = 42
-    const result = Value.Cast(Type.Number(), value)
-    Assert.deepEqual(result, 42)
-  })
-  it('Should convert true', () => {
-    const value = true
-    const result = Value.Cast(Type.Number(), value)
-    Assert.deepEqual(result, 1)
-  })
-  it('Should convert false', () => {
-    const value = false
-    const result = Value.Cast(Type.Number(), value)
-    Assert.deepEqual(result, 0)
-  })
-  it('Should convert object', () => {
-    const value = {}
-    const result = Value.Cast(Type.String(), value)
-    Assert.deepEqual(result, 0)
-  })
-  it('Should convert array', () => {
-    const value = [] as any[]
-    const result = Value.Cast(Type.String(), value)
-    Assert.deepEqual(result, 0)
-  })
-})
-//---------------------------------------------------------------
-// Integer Convert
-//---------------------------------------------------------------
-describe('value/convert/Integer', () => {
-  it('Should convert string #1', () => {
-    const value = 'hello'
-    const result = Value.Cast(Type.Integer(), value)
-    Assert.deepEqual(result, 0)
-  })
-  it('Should convert string #2', () => {
-    const value = '3.14'
-    const result = Value.Cast(Type.Integer(), value)
-    Assert.deepEqual(result, 3)
-  })
-  it('Should convert string #3', () => {
-    const value = '-0'
-    const result = Value.Cast(Type.Integer(), value)
-    Assert.deepEqual(result, 0)
-  })
-  it('Should convert string #4', () => {
-    const value = '-100'
-    const result = Value.Cast(Type.Integer(), value)
-    Assert.deepEqual(result, -100)
-  })
-  it('Should convert number', () => {
-    const value = 42
-    const result = Value.Cast(Type.Integer(), value)
-    Assert.deepEqual(result, 42)
-  })
-  it('Should convert true', () => {
-    const value = true
-    const result = Value.Cast(Type.Integer(), value)
-    Assert.deepEqual(result, 1)
-  })
-  it('Should convert false', () => {
-    const value = false
-    const result = Value.Cast(Type.Integer(), value)
-    Assert.deepEqual(result, 0)
-  })
-  it('Should convert object', () => {
-    const value = {}
-    const result = Value.Cast(Type.Integer(), value)
-    Assert.deepEqual(result, 0)
-  })
-  it('Should convert array', () => {
-    const value = [] as any[]
-    const result = Value.Cast(Type.Integer(), value)
-    Assert.deepEqual(result, 0)
-  })
-})
-//---------------------------------------------------------------
-// Boolean Convert
-//---------------------------------------------------------------
-describe('value/convert/Boolean', () => {
-  it('Should convert string #1', () => {
-    const value = 'hello'
-    const result = Value.Cast(Type.Boolean(), value)
-    Assert.deepEqual(result, false)
-  })
-  it('Should convert string #2', () => {
-    const value = 'true'
-    const result = Value.Cast(Type.Boolean(), value)
-    Assert.deepEqual(result, true)
-  })
-  it('Should convert string #3', () => {
-    const value = 'TRUE'
-    const result = Value.Cast(Type.Boolean(), value)
-    Assert.deepEqual(result, true)
-  })
-  it('Should convert string #4', () => {
-    const value = 'false'
-    const result = Value.Cast(Type.Boolean(), value)
-    Assert.deepEqual(result, false)
-  })
-  it('Should convert string #5', () => {
-    const value = '0'
-    const result = Value.Cast(Type.Boolean(), value)
-    Assert.deepEqual(result, false)
-  })
-  it('Should convert string #6', () => {
-    const value = '1'
-    const result = Value.Cast(Type.Boolean(), value)
-    Assert.deepEqual(result, true)
-  })
-  it('Should convert string #7', () => {
-    const value = '0'
-    const result = Value.Cast(Type.Boolean({ default: true }), value)
-    Assert.deepEqual(result, false)
-  })
-  it('Should convert string #8', () => {
-    const value = '1'
-    const result = Value.Cast(Type.Boolean({ default: false }), value)
-    Assert.deepEqual(result, true)
-  })
-  it('Should convert string #8', () => {
-    const value = '2'
-    const result = Value.Cast(Type.Boolean({ default: true }), value)
-    Assert.deepEqual(result, true)
-  })
-  it('Should convert number #1', () => {
-    const value = 0
-    const result = Value.Cast(Type.Boolean(), value)
-    Assert.deepEqual(result, false)
-  })
-  it('Should convert number #2', () => {
-    const value = 1n
-    const result = Value.Cast(Type.Boolean(), value)
-    Assert.deepEqual(result, true)
-  })
-  it('Should convert number #3', () => {
-    const value = 1
-    const result = Value.Cast(Type.Boolean(), value)
-    Assert.deepEqual(result, true)
-  })
-  it('Should convert number #4', () => {
-    const value = 2
-    const result = Value.Cast(Type.Boolean(), value)
-    Assert.deepEqual(result, false)
-  })
-  it('Should convert number #5', () => {
-    const value = 0
-    const result = Value.Cast(Type.Boolean({ default: true }), value)
-    Assert.deepEqual(result, false)
-  })
-  it('Should convert number #6', () => {
-    const value = 1
-    const result = Value.Cast(Type.Boolean({ default: false }), value)
-    Assert.deepEqual(result, true)
-  })
-  it('Should convert number #7', () => {
-    const value = 2
-    const result = Value.Cast(Type.Boolean({ default: true }), value)
-    Assert.deepEqual(result, true)
-  })
-  it('Should convert true', () => {
-    const value = true
-    const result = Value.Cast(Type.Boolean(), value)
-    Assert.deepEqual(result, true)
-  })
-  it('Should convert false', () => {
-    const value = false
-    const result = Value.Cast(Type.Boolean(), value)
-    Assert.deepEqual(result, false)
-  })
-  it('Should convert object', () => {
-    const value = {}
-    const result = Value.Cast(Type.Boolean(), value)
-    Assert.deepEqual(result, false)
-  })
-  it('Should convert array', () => {
-    const value = [] as any[]
-    const result = Value.Cast(Type.Boolean(), value)
-    Assert.deepEqual(result, false)
-  })
-})
-
-//---------------------------------------------------------------
-// Date Convert
-//---------------------------------------------------------------
-describe('value/convert/Date', () => {
-  it('Should convert from number', () => {
-    const result = Value.Cast(Type.Date(), 123)
-    Assert.deepEqual(result.getTime(), 123)
-  })
-  it('Should convert from numeric string', () => {
-    const result = Value.Cast(Type.Date(), '123')
-    Assert.deepEqual(result.getTime(), 123)
-  })
-  it('Should convert from boolean true (interpretted as numeric 1)', () => {
-    const result = Value.Cast(Type.Date(), true)
-    Assert.deepEqual(result.getTime(), 1)
-  })
-  it('Should convert from datetime string', () => {
-    const result = Value.Cast(Type.Date(), '1980-02-03T01:02:03.000Z')
-    Assert.deepEqual(result.toISOString(), '1980-02-03T01:02:03.000Z')
-  })
-  it('Should convert from datetime string without timezone', () => {
-    const result = Value.Cast(Type.Date(), '1980-02-03T01:02:03')
-    Assert.deepEqual(result.toISOString(), '1980-02-03T01:02:03.000Z')
-  })
-  it('Should convert from time with timezone', () => {
-    const result = Value.Cast(Type.Date(), '01:02:03.000Z')
-    Assert.deepEqual(result.toISOString(), '1970-01-01T01:02:03.000Z')
-  })
-  it('Should convert from time without timezone', () => {
-    const result = Value.Cast(Type.Date(), '01:02:03')
-    Assert.deepEqual(result.toISOString(), '1970-01-01T01:02:03.000Z')
-  })
-  it('Should convert from date string', () => {
-    const result = Value.Cast(Type.Date(), '1980-02-03')
-    Assert.deepEqual(result.toISOString(), '1980-02-03T00:00:00.000Z')
-  })
-  it('Should convert invalid strings to unix epoch 0', () => {
-    const result = Value.Cast(Type.Date(), 'invalid-date')
-    Assert.deepEqual(result.toISOString(), '1970-01-01T00:00:00.000Z')
-  })
-})
diff --git a/test/runtime/value/cast/custom.ts b/test/runtime/value/cast/custom.ts
index cbdd0085e..815a8e208 100644
--- a/test/runtime/value/cast/custom.ts
+++ b/test/runtime/value/cast/custom.ts
@@ -1,55 +1,46 @@
 import { Value } from '@sinclair/typebox/value'
-import { Custom } from '@sinclair/typebox/custom'
-import { Type, Kind } from '@sinclair/typebox'
+import { Type, Kind, TypeRegistry } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/cast/Custom', () => {
-  Custom.Set('CustomCast', (schema, value) => value === 'hello' || value === 'world')
+  TypeRegistry.Set('CustomCast', (schema, value) => value === 'hello' || value === 'world')
   const T = Type.Unsafe({ [Kind]: 'CustomCast', default: 'hello' })
   const E = 'hello'
-
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from boolean', () => {
     const value = false
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preserve', () => {
     const value = { a: 'hello', b: 'world' }
     const result = Value.Cast(
diff --git a/test/runtime/value/cast/date.ts b/test/runtime/value/cast/date.ts
index a991af828..b094c8c79 100644
--- a/test/runtime/value/cast/date.ts
+++ b/test/runtime/value/cast/date.ts
@@ -5,49 +5,31 @@ import { Assert } from '../../assert/index'
 describe('value/cast/Date', () => {
   const T = Type.Date()
   const E = new Date(0)
-
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
-  it('Should upcast from number', () => {
-    const value = 1
-    const result = Value.Cast(T, value)
-    Assert.deepEqual(result.getTime(), 1) // convert
-  })
-
-  it('Should upcast from boolean', () => {
-    const value = true
-    const result = Value.Cast(T, value)
-    Assert.deepEqual(result.getTime(), 1) // convert
-  })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preseve', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/enum.ts b/test/runtime/value/cast/enum.ts
index e75d5bdd8..86e6d2119 100644
--- a/test/runtime/value/cast/enum.ts
+++ b/test/runtime/value/cast/enum.ts
@@ -9,61 +9,51 @@ describe('value/cast/Boolean', () => {
   }
   const T = Type.Enum(Foo)
   const E = Foo.A
-
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from number', () => {
     const value = 123
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from enum A', () => {
     const value = Foo.A
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, Foo.A)
   })
-
   it('Should upcast from enum B', () => {
     const value = Foo.B
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/index.ts b/test/runtime/value/cast/index.ts
index 58b1e8252..238aa9688 100644
--- a/test/runtime/value/cast/index.ts
+++ b/test/runtime/value/cast/index.ts
@@ -1,7 +1,8 @@
 import './any'
 import './array'
+import './bigint'
 import './boolean'
-import './convert'
+import './composite'
 import './custom'
 import './date'
 import './enum'
@@ -10,6 +11,7 @@ import './intersect'
 import './keyof'
 import './literal'
 import './never'
+import './not'
 import './null'
 import './number'
 import './object'
@@ -17,6 +19,7 @@ import './recursive'
 import './record'
 import './regex'
 import './string'
+import './symbol'
 import './tuple'
 import './uint8array'
 import './undefined'
diff --git a/test/runtime/value/cast/integer.ts b/test/runtime/value/cast/integer.ts
index 194fd7b18..1bf6228c9 100644
--- a/test/runtime/value/cast/integer.ts
+++ b/test/runtime/value/cast/integer.ts
@@ -5,49 +5,36 @@ import { Assert } from '../../assert/index'
 describe('value/cast/Integer', () => {
   const T = Type.Integer()
   const E = 0
-
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, 1)
   })
-
-  it('Should upcast from boolean', () => {
-    const value = true
-    const result = Value.Cast(T, value)
-    Assert.deepEqual(result, 1) // conversion
-  })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/intersect.ts b/test/runtime/value/cast/intersect.ts
index ed3ade161..8a681fddb 100644
--- a/test/runtime/value/cast/intersect.ts
+++ b/test/runtime/value/cast/intersect.ts
@@ -3,97 +3,74 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/cast/Intersect', () => {
-  const A = Type.Object({
-    x: Type.Number({ default: 0 }),
-    y: Type.Number({ default: 1 }),
-    z: Type.Number({ default: 2 }),
+  it('Should cast from an invalid object', () => {
+    // prettier-ignore
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }), 
+      Type.Object({ y: Type.Number() })
+    ])
+    const V = Value.Cast(T, 1)
+    Assert.deepEqual(V, { x: 0, y: 0 })
   })
-  const B = Type.Object({
-    a: Type.Number({ default: 'a' }),
-    b: Type.Number({ default: 'b' }),
-    c: Type.Number({ default: 'c' }),
+  it('Should cast from an partial object and preserve', () => {
+    // prettier-ignore
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }), 
+      Type.Object({ y: Type.Number() })
+    ])
+    const V = Value.Cast(T, { x: 1 })
+    Assert.deepEqual(V, { x: 1, y: 0 })
   })
-  const T = Type.Intersect([A, B])
-  const E = {
-    x: 0,
-    y: 1,
-    z: 2,
-    a: 'a',
-    b: 'b',
-    c: 'c',
-  }
-
-  it('Should upcast from string', () => {
-    const value = 'hello'
-    const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
-  })
-
-  it('Should upcast from number', () => {
-    const value = E
-    const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
-  })
-
-  it('Should upcast from boolean', () => {
-    const value = true
-    const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
-  })
-
-  it('Should upcast from object', () => {
-    const value = {}
-    const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+  it('Should cast and use default values', () => {
+    // prettier-ignore
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }), 
+      Type.Object({ y: Type.Number({ default: 42 }) })
+    ])
+    const V = Value.Cast(T, { x: 1 })
+    Assert.deepEqual(V, { x: 1, y: 42 })
   })
-
-  it('Should upcast from array', () => {
-    const value = [1]
-    const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+  it('Should throw with an illogical intersect', () => {
+    // prettier-ignore
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }), 
+      Type.Object({ x: Type.String() })
+    ])
+    Assert.throws(() => Value.Cast(T, { x: 1 }))
   })
-
-  it('Should upcast from undefined', () => {
-    const value = undefined
-    const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+  it('Should throw with an illogical intersect (primative)', () => {
+    // prettier-ignore
+    const T = Type.Intersect([
+      Type.Number(), 
+      Type.String()
+    ])
+    Assert.throws(() => Value.Cast(T, { x: 1 }))
   })
-
-  it('Should upcast from null', () => {
-    const value = null
-    const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+  it('Should use last intersected default for equivalent sub schemas', () => {
+    // prettier-ignore
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }), 
+      Type.Object({ x: Type.Number({ default: 1000 }) })
+    ])
+    const V = Value.Cast(T, null)
+    Assert.deepEqual(V, { x: 1000 })
   })
-
-  it('Should upcast from date', () => {
-    const value = new Date(100)
-    const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+  it('Should use last intersected default for equivalent sub schemas (primitives)', () => {
+    // prettier-ignore
+    const T = Type.Intersect([
+      Type.Number(), 
+      Type.Number({ default: 1000 })
+    ])
+    const V = Value.Cast(T, null)
+    Assert.deepEqual(V, 1000)
   })
-
-  it('Should upcast and preserve object', () => {
-    const value = { x: 7, y: 8, z: 9 }
-    const result = Value.Cast(T, value)
-    Assert.deepEqual(result, {
-      x: 7,
-      y: 8,
-      z: 9,
-      a: 'a',
-      b: 'b',
-      c: 'c',
-    })
-  })
-
-  it('Should upcast and preserve from incorrect properties', () => {
-    const value = { x: {}, y: 8, z: 9 }
-    const result = Value.Cast(T, value)
-    Assert.deepEqual(result, {
-      x: 0,
-      y: 8,
-      z: 9,
-      a: 'a',
-      b: 'b',
-      c: 'c',
-    })
+  it('Should preserve if default is specified', () => {
+    // prettier-ignore
+    const T = Type.Intersect([
+      Type.Number(), 
+      Type.Number({ default: 1000 })
+    ])
+    const V = Value.Cast(T, 2000)
+    Assert.deepEqual(V, 2000)
   })
 })
diff --git a/test/runtime/value/cast/keyof.ts b/test/runtime/value/cast/keyof.ts
index b18d1f56f..7ee9795fe 100644
--- a/test/runtime/value/cast/keyof.ts
+++ b/test/runtime/value/cast/keyof.ts
@@ -11,55 +11,46 @@ describe('value/cast/KeyOf', () => {
     }),
   )
   const E = 'x'
-
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preserve', () => {
     const value = 'y'
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/literal.ts b/test/runtime/value/cast/literal.ts
index ae2e27083..557abdf81 100644
--- a/test/runtime/value/cast/literal.ts
+++ b/test/runtime/value/cast/literal.ts
@@ -5,55 +5,46 @@ import { Assert } from '../../assert/index'
 describe('value/cast/Literal', () => {
   const T = Type.Literal('hello')
   const E = 'hello'
-
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preseve', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/not.ts b/test/runtime/value/cast/not.ts
new file mode 100644
index 000000000..ac783efcf
--- /dev/null
+++ b/test/runtime/value/cast/not.ts
@@ -0,0 +1,59 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Not', () => {
+  const T = Type.Not(Type.String(), Type.Number())
+  const E = 0
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from number', () => {
+    const value = 0
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should preserve', () => {
+    const value = 100
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, 100)
+  })
+  it('Should not preserve when schema is illogical', () => {
+    const T = Type.Not(Type.Number(), Type.Number())
+    const value = 100
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, 0)
+  })
+})
diff --git a/test/runtime/value/cast/null.ts b/test/runtime/value/cast/null.ts
index 06eb0f344..467068b5c 100644
--- a/test/runtime/value/cast/null.ts
+++ b/test/runtime/value/cast/null.ts
@@ -5,55 +5,46 @@ import { Assert } from '../../assert/index'
 describe('value/cast/Null', () => {
   const T = Type.Null()
   const E = null
-
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preseve', () => {
     const value = null
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/number.ts b/test/runtime/value/cast/number.ts
index 1fbd51807..e3e43b537 100644
--- a/test/runtime/value/cast/number.ts
+++ b/test/runtime/value/cast/number.ts
@@ -5,55 +5,41 @@ import { Assert } from '../../assert/index'
 describe('value/cast/Number', () => {
   const T = Type.Number()
   const E = 0
-
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, 1)
   })
-
-  it('Should upcast from boolean', () => {
-    const value = true // convert
-    const result = Value.Cast(T, value)
-    Assert.deepEqual(result, 1)
-  })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preseve', () => {
     const value = 123
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/object.ts b/test/runtime/value/cast/object.ts
index 544ab46d8..0c631b556 100644
--- a/test/runtime/value/cast/object.ts
+++ b/test/runtime/value/cast/object.ts
@@ -19,7 +19,6 @@ describe('value/cast/Object', () => {
     b: 'b',
     c: 'c',
   }
-
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
@@ -35,37 +34,31 @@ describe('value/cast/Object', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preserve', () => {
     const value = { x: 7, y: 8, z: 9, a: 10, b: 11, c: 12 }
     const result = Value.Cast(T, value)
@@ -90,7 +83,6 @@ describe('value/cast/Object', () => {
       c: 'c',
     })
   })
-
   it('Should upcast and preserve partial object with incorrect properties', () => {
     const value = { x: {}, y: 8, z: 9 }
     const result = Value.Cast(T, value)
@@ -103,7 +95,6 @@ describe('value/cast/Object', () => {
       c: 'c',
     })
   })
-
   it('Should upcast and preserve partial object and omit unknown properties', () => {
     const value = { x: 7, y: 8, z: 9, unknown: 'foo' }
     const result = Value.Cast(T, value)
@@ -116,7 +107,6 @@ describe('value/cast/Object', () => {
       c: 'c',
     })
   })
-
   it('Should upcast and create invalid additional properties', () => {
     const result = Value.Cast(
       Type.Object(
@@ -143,7 +133,6 @@ describe('value/cast/Object', () => {
       z: { a: 0, b: 0 },
     })
   })
-
   it('Should upcast and preserve additional properties', () => {
     const result = Value.Cast(
       Type.Object(
diff --git a/test/runtime/value/cast/record.ts b/test/runtime/value/cast/record.ts
index 32b5c53c4..e62515ae2 100644
--- a/test/runtime/value/cast/record.ts
+++ b/test/runtime/value/cast/record.ts
@@ -28,37 +28,31 @@ describe('value/cast/Record', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preserve', () => {
     const value = {
       a: { x: 1, y: 2, z: 3 },
@@ -67,7 +61,6 @@ describe('value/cast/Record', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
-
   it('Should preserve and patch invalid records', () => {
     const value = {
       a: { x: 1, y: 2, z: 3 },
diff --git a/test/runtime/value/cast/recursive.ts b/test/runtime/value/cast/recursive.ts
index 0db482577..39a0a9f68 100644
--- a/test/runtime/value/cast/recursive.ts
+++ b/test/runtime/value/cast/recursive.ts
@@ -9,57 +9,47 @@ describe('value/cast/Recursive', () => {
       nodes: Type.Array(Self),
     }),
   )
-
   const E = { id: '', nodes: [] }
-
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from number', () => {
     const value = E
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preserve', () => {
     const value = {
       id: 'A',
@@ -72,7 +62,6 @@ describe('value/cast/Recursive', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
-
   it('Should upcast from varying types', () => {
     const TypeA = Type.Recursive((Self) =>
       Type.Object({
@@ -80,7 +69,6 @@ describe('value/cast/Recursive', () => {
         nodes: Type.Array(Self),
       }),
     )
-
     const TypeB = Type.Recursive((Self) =>
       Type.Object({
         id: Type.String(),
@@ -88,7 +76,6 @@ describe('value/cast/Recursive', () => {
         nodes: Type.Array(Self),
       }),
     )
-
     const ValueA = {
       id: 'A',
       nodes: [
@@ -98,15 +85,14 @@ describe('value/cast/Recursive', () => {
       ],
     }
     const ValueB = Value.Cast(TypeB, ValueA)
-
-    Assert.deepEqual(ValueB, {
-      id: 'A',
-      name: 'test',
-      nodes: [
-        { id: 'B', name: 'test', nodes: [] },
-        { id: 'C', name: 'test', nodes: [] },
-        { id: 'D', name: 'test', nodes: [] },
-      ],
-    })
+    // Assert.deepEqual(ValueB, {
+    //   id: 'A',
+    //   name: 'test',
+    //   nodes: [
+    //     { id: 'B', name: 'test', nodes: [] },
+    //     { id: 'C', name: 'test', nodes: [] },
+    //     { id: 'D', name: 'test', nodes: [] },
+    //   ],
+    // })
   })
 })
diff --git a/test/runtime/value/cast/regex.ts b/test/runtime/value/cast/regex.ts
index 3adb18c98..ab34f4264 100644
--- a/test/runtime/value/cast/regex.ts
+++ b/test/runtime/value/cast/regex.ts
@@ -5,55 +5,46 @@ import { Assert } from '../../assert/index'
 describe('value/cast/RegEx', () => {
   const T = Type.RegEx(/foo/, { default: 'foo' })
   const E = 'foo'
-
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, 'foo')
   })
-
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preserve', () => {
     const value = 'foo'
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/string.ts b/test/runtime/value/cast/string.ts
index 28b7f2066..0ed878b4d 100644
--- a/test/runtime/value/cast/string.ts
+++ b/test/runtime/value/cast/string.ts
@@ -5,55 +5,36 @@ import { Assert } from '../../assert/index'
 describe('value/cast/String', () => {
   const T = Type.String()
   const E = ''
-
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, 'hello')
   })
-
-  it('Should upcast from number', () => {
-    const value = 1
-    const result = Value.Cast(T, value)
-    Assert.deepEqual(result, '1') // conversion
-  })
-
-  it('Should upcast from boolean', () => {
-    const value = true
-    const result = Value.Cast(T, value)
-    Assert.deepEqual(result, 'true') // conversion
-  })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preserve', () => {
     const value = 'foo'
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/symbol.ts b/test/runtime/value/cast/symbol.ts
new file mode 100644
index 000000000..15af14c42
--- /dev/null
+++ b/test/runtime/value/cast/symbol.ts
@@ -0,0 +1,52 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Symbol', () => {
+  const T = Type.Symbol()
+  it('Should upcast from string', () => {
+    const value = 'hello'
+    const result = Value.Cast(T, value)
+    Assert.isTypeOf(result, 'symbol')
+  })
+  it('Should upcast from number', () => {
+    const value = 0
+    const result = Value.Cast(T, value)
+    Assert.isTypeOf(result, 'symbol')
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.isTypeOf(result, 'symbol')
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.isTypeOf(result, 'symbol')
+  })
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.isTypeOf(result, 'symbol')
+  })
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.isTypeOf(result, 'symbol')
+  })
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.isTypeOf(result, 'symbol')
+  })
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.isTypeOf(result, 'symbol')
+  })
+  it('Should preserve', () => {
+    const value = Symbol('hello')
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result.description, value.description)
+  })
+})
diff --git a/test/runtime/value/cast/tuple.ts b/test/runtime/value/cast/tuple.ts
index c26831b24..8ba7835c5 100644
--- a/test/runtime/value/cast/tuple.ts
+++ b/test/runtime/value/cast/tuple.ts
@@ -5,79 +5,66 @@ import { Assert } from '../../assert/index'
 describe('value/cast/Tuple', () => {
   const T = Type.Tuple([Type.Number(), Type.String()])
   const E = [0, '']
-
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, [1, ''])
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preserve', () => {
     const value = [42, 'world']
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
-
   it('Should upcast with empty', () => {
     const value = [] as any[]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should append with less than tuple length', () => {
     const value = [42]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, [42, ''])
   })
-
   it('Should truncate with greater than tuple length', () => {
     const value = [42, '', true]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, [42, ''])
   })
-
   it('Should preserve and patch invalid element', () => {
     const value = [{}, 'hello']
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/uint8array.ts b/test/runtime/value/cast/uint8array.ts
index bd861b452..638eb9c57 100644
--- a/test/runtime/value/cast/uint8array.ts
+++ b/test/runtime/value/cast/uint8array.ts
@@ -5,55 +5,46 @@ import { Assert } from '../../assert/index'
 describe('value/cast/Uint8Array', () => {
   const T = Type.Uint8Array({ default: new Uint8Array([0, 1, 2, 3]) })
   const E = new Uint8Array([0, 1, 2, 3])
-
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preserve', () => {
     const value = new Uint8Array([6, 7, 8, 9, 10])
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/undefined.ts b/test/runtime/value/cast/undefined.ts
index 36a67693f..d8a089ce6 100644
--- a/test/runtime/value/cast/undefined.ts
+++ b/test/runtime/value/cast/undefined.ts
@@ -5,55 +5,46 @@ import { Assert } from '../../assert/index'
 describe('value/cast/Undefined', () => {
   const T = Type.Undefined()
   const E = undefined
-
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preseve', () => {
     const value = undefined
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/union.ts b/test/runtime/value/cast/union.ts
index b438b5dba..5850866b8 100644
--- a/test/runtime/value/cast/union.ts
+++ b/test/runtime/value/cast/union.ts
@@ -22,7 +22,6 @@ describe('value/cast/Union', () => {
     { additionalProperties: false },
   )
   const T = Type.Union([A, B])
-
   const E = {
     type: 'A',
     x: 0,
@@ -35,103 +34,86 @@ describe('value/cast/Union', () => {
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preserve A', () => {
     const value = { type: 'A', x: 1, y: 2, z: 3 }
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
-
   it('Should preserve B', () => {
     const value = { type: 'B', a: 'a', b: 'b', c: 'c' }
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
-
   it('Should infer through heuristics #1', () => {
     const value = { type: 'A', a: 'a', b: 'b', c: 'c' }
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, { type: 'A', x: 0, y: 0, z: 0 })
   })
-
   it('Should infer through heuristics #2', () => {
     const value = { type: 'B', x: 1, y: 2, z: 3 }
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, { type: 'B', a: '', b: '', c: '' })
   })
-
   it('Should infer through heuristics #3', () => {
     const value = { type: 'A', a: 'a', b: 'b', c: null }
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, { type: 'A', x: 0, y: 0, z: 0 })
   })
-
   it('Should infer through heuristics #4', () => {
     const value = { type: 'B', x: 1, y: 2, z: {} }
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, { type: 'B', a: '', b: '', c: '' })
   })
-
   it('Should infer through heuristics #5', () => {
     const value = { type: 'B', x: 1, y: 2, z: null }
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, { type: 'B', a: '', b: '', c: '' })
   })
-
   it('Should infer through heuristics #6', () => {
     const value = { x: 1 }
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, { type: 'A', x: 1, y: 0, z: 0 })
   })
-
   it('Should infer through heuristics #7', () => {
     const value = { a: null } // property existing should contribute
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, { type: 'B', a: '', b: '', c: '' })
   })
-
   it('Should cast with default value (create)', () => {
     const result = Value.Cast(
       Type.Object({
@@ -148,7 +130,6 @@ describe('value/cast/Union', () => {
       value: 'C',
     })
   })
-
   it('Should cast with default value (preserve)', () => {
     const result = Value.Cast(
       Type.Object({
diff --git a/test/runtime/value/cast/unknown.ts b/test/runtime/value/cast/unknown.ts
index 66f333d7e..806b37257 100644
--- a/test/runtime/value/cast/unknown.ts
+++ b/test/runtime/value/cast/unknown.ts
@@ -4,55 +4,46 @@ import { Assert } from '../../assert/index'
 
 describe('value/cast/Unknown', () => {
   const T = Type.Unknown()
-
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
-
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
-
   it('Should upcast from boolean', () => {
     const value = false
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, value)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result: any = Value.Cast(T, value)
     Assert.deepEqual(result.getTime(), 100)
   })
-
   it('Should preserve', () => {
     const value = { a: 1, b: 2 }
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/cast/void.ts b/test/runtime/value/cast/void.ts
index 93d491d82..787c0bb85 100644
--- a/test/runtime/value/cast/void.ts
+++ b/test/runtime/value/cast/void.ts
@@ -5,55 +5,46 @@ import { Assert } from '../../assert/index'
 describe('value/cast/Void', () => {
   const T = Type.Void()
   const E = null
-
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
     Assert.deepEqual(result, E)
   })
-
   it('Should preserve', () => {
     const value = null
     const result = Value.Cast(T, value)
diff --git a/test/runtime/value/check/bigint.ts b/test/runtime/value/check/bigint.ts
new file mode 100644
index 000000000..74bf4c90d
--- /dev/null
+++ b/test/runtime/value/check/bigint.ts
@@ -0,0 +1,44 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/BigInt', () => {
+  const T = Type.BigInt()
+  it('Should not validate NaN', () => {
+    const T = Type.BigInt()
+    const result = Value.Check(T, NaN)
+    Assert.equal(result, false)
+  })
+  it('Should not validate +Infinity', () => {
+    const T = Type.BigInt()
+    const result = Value.Check(T, Infinity)
+    Assert.equal(result, false)
+  })
+  it('Should not validate -Infinity', () => {
+    const T = Type.BigInt()
+    const result = Value.Check(T, -Infinity)
+    Assert.equal(result, false)
+  })
+  it('Should fail integer', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail integer', () => {
+    const value = 3.14
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail Date', () => {
+    const value = new Date()
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should pass bigint', () => {
+    const result = Value.Check(T, BigInt(0))
+    Assert.equal(result, true)
+  })
+})
diff --git a/test/runtime/value/check/composite.ts b/test/runtime/value/check/composite.ts
new file mode 100644
index 000000000..c9b4db2b6
--- /dev/null
+++ b/test/runtime/value/check/composite.ts
@@ -0,0 +1,82 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Composite', () => {
+  const A = Type.Object({
+    x: Type.Number(),
+    y: Type.Number(),
+    z: Type.Number(),
+  })
+  const B = Type.Object({
+    a: Type.String(),
+    b: Type.String(),
+    c: Type.String(),
+  })
+  const T = Type.Composite([A, B])
+
+  it('Should pass composite', () => {
+    const value = {
+      x: 1,
+      y: 1,
+      z: 1,
+      a: '1',
+      b: '1',
+      c: '1',
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+
+  it('Should fail intersect with invalid property', () => {
+    const value = {
+      x: true,
+      y: 1,
+      z: 1,
+      a: '1',
+      b: '1',
+      c: '1',
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail intersect with missing property', () => {
+    const value = {
+      y: 1,
+      z: 1,
+      a: '1',
+      b: '1',
+      c: '1',
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should fail intersect with primitive value', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+
+  it('Should pass intersect with optional properties', () => {
+    const A = Type.Object({
+      x: Type.Optional(Type.Number()),
+      y: Type.Optional(Type.Number()),
+      z: Type.Optional(Type.Number()),
+    })
+    const B = Type.Object({
+      a: Type.String(),
+      b: Type.String(),
+      c: Type.String(),
+    })
+    const T = Type.Composite([A, B])
+    const value = {
+      a: '1',
+      b: '1',
+      c: '1',
+    }
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+})
diff --git a/test/runtime/value/check/custom.ts b/test/runtime/value/check/custom.ts
index 8518802fd..796bc6f23 100644
--- a/test/runtime/value/check/custom.ts
+++ b/test/runtime/value/check/custom.ts
@@ -1,10 +1,9 @@
 import { Value } from '@sinclair/typebox/value'
-import { Custom } from '@sinclair/typebox/custom'
-import { Type, Kind } from '@sinclair/typebox'
+import { Type, Kind, TypeRegistry } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/check/Custom', () => {
-  Custom.Set('BigInt', (schema, value) => typeof value === 'bigint')
+  TypeRegistry.Set('BigInt', (schema, value) => typeof value === 'bigint')
 
   it('Should validate bigint', () => {
     const T = Type.Unsafe({ [Kind]: 'BigInt' })
diff --git a/test/runtime/value/check/index.ts b/test/runtime/value/check/index.ts
index eb99c6eba..1fc8801be 100644
--- a/test/runtime/value/check/index.ts
+++ b/test/runtime/value/check/index.ts
@@ -1,6 +1,8 @@
 import './any'
 import './array'
+import './bigint'
 import './boolean'
+import './composite'
 import './custom'
 import './date'
 import './enum'
@@ -9,13 +11,16 @@ import './intersect'
 import './keyof'
 import './literal'
 import './never'
+import './not'
 import './null'
 import './number'
 import './object'
 import './recursive'
+import './ref'
 import './record'
 import './regex'
 import './string'
+import './symbol'
 import './tuple'
 import './uint8array'
 import './undefined'
diff --git a/test/runtime/value/check/integer.ts b/test/runtime/value/check/integer.ts
index e02a6f55c..ae46303f7 100644
--- a/test/runtime/value/check/integer.ts
+++ b/test/runtime/value/check/integer.ts
@@ -5,6 +5,22 @@ import { Assert } from '../../assert/index'
 describe('value/check/Integer', () => {
   const T = Type.Integer()
 
+  it('Should not validate NaN', () => {
+    const T = Type.Integer()
+    const result = Value.Check(T, NaN)
+    Assert.equal(result, false)
+  })
+  it('Should not validate +Infinity', () => {
+    const T = Type.Integer()
+    const result = Value.Check(T, Infinity)
+    Assert.equal(result, false)
+  })
+  it('Should not validate -Infinity', () => {
+    const T = Type.Integer()
+    const result = Value.Check(T, -Infinity)
+    Assert.equal(result, false)
+  })
+
   it('Should pass integer', () => {
     const value = 1
     const result = Value.Check(T, value)
@@ -22,9 +38,4 @@ describe('value/check/Integer', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
-
-  it('Should fail NaN', () => {
-    const result = Value.Check(Type.Integer(), NaN)
-    Assert.equal(result, false)
-  })
 })
diff --git a/test/runtime/value/check/intersect.ts b/test/runtime/value/check/intersect.ts
index c5f747b35..5c9941220 100644
--- a/test/runtime/value/check/intersect.ts
+++ b/test/runtime/value/check/intersect.ts
@@ -3,80 +3,82 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/check/Intersect', () => {
-  const A = Type.Object({
-    x: Type.Number(),
-    y: Type.Number(),
-    z: Type.Number(),
+  it('Should intersect number and number', () => {
+    const A = Type.Number()
+    const B = Type.Number()
+    const T = Type.Intersect([A, B], {})
+    Assert.equal(Value.Check(T, 1), true)
   })
-  const B = Type.Object({
-    a: Type.String(),
-    b: Type.String(),
-    c: Type.String(),
+  it('Should not intersect string and number', () => {
+    const A = Type.String()
+    const B = Type.Number()
+    const T = Type.Intersect([A, B], {})
+    Assert.equal(Value.Check(T, 1), false)
+    Assert.equal(Value.Check(T, '1'), false)
   })
-  const T = Type.Intersect([A, B])
-
-  it('Should pass intersect', () => {
-    const value = {
-      x: 1,
-      y: 1,
-      z: 1,
-      a: '1',
-      b: '1',
-      c: '1',
-    }
-    const result = Value.Check(T, value)
-    Assert.equal(result, true)
+  it('Should intersect two objects', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const T = Type.Intersect([A, B], {})
+    Assert.equal(Value.Check(T, { x: 1, y: 1 }), true)
   })
-
-  it('Should fail intersect with invalid property', () => {
-    const value = {
-      x: true,
-      y: 1,
-      z: 1,
-      a: '1',
-      b: '1',
-      c: '1',
-    }
-    const result = Value.Check(T, value)
-    Assert.equal(result, false)
+  it('Should not intersect two objects with internal additionalProperties false', () => {
+    const A = Type.Object({ x: Type.Number() }, { additionalProperties: false })
+    const B = Type.Object({ y: Type.Number() }, { additionalProperties: false })
+    const T = Type.Intersect([A, B], {})
+    Assert.equal(Value.Check(T, { x: 1, y: 1 }), false)
   })
-
-  it('Should fail intersect with missing property', () => {
-    const value = {
-      y: 1,
-      z: 1,
-      a: '1',
-      b: '1',
-      c: '1',
-    }
-    const result = Value.Check(T, value)
-    Assert.equal(result, false)
+  it('Should intersect two objects and mandate required properties', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const T = Type.Intersect([A, B], {})
+    Assert.equal(Value.Check(T, { x: 1, y: 1 }), true)
+    Assert.equal(Value.Check(T, { x: 1 }), false)
+    Assert.equal(Value.Check(T, { x: 1 }), false)
   })
-
-  it('Should fail intersect with primitive value', () => {
-    const value = 1
-    const result = Value.Check(T, value)
-    Assert.equal(result, false)
+  it('Should intersect two objects with unevaluated properties', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const T = Type.Intersect([A, B], {})
+    Assert.equal(Value.Check(T, { x: 1, y: 1, z: 1 }), true)
   })
-
-  it('Should pass intersect with optional properties', () => {
-    const A = Type.Object({
-      x: Type.Optional(Type.Number()),
-      y: Type.Optional(Type.Number()),
-      z: Type.Optional(Type.Number()),
-    })
-    const B = Type.Object({
-      a: Type.String(),
-      b: Type.String(),
-      c: Type.String(),
-    })
+  it('Should intersect two objects and restrict unevaluated properties', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const T = Type.Intersect([A, B], { unevaluatedProperties: false })
+    Assert.equal(Value.Check(T, { x: 1, y: 1, z: 1 }), false)
+  })
+  it('Should intersect two objects and allow unevaluated properties of number', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const T = Type.Intersect([A, B], { unevaluatedProperties: Type.Number() })
+    Assert.equal(Value.Check(T, { x: 1, y: 2, z: 3 }), true)
+    Assert.equal(Value.Check(T, { x: 1, y: 2, z: '1' }), false)
+  })
+  it('Should intersect two union objects with overlapping properties of the same type', () => {
+    const A = Type.Union([Type.Object({ x: Type.Number() })])
+    const B = Type.Union([Type.Object({ x: Type.Number() })])
+    const T = Type.Intersect([A, B])
+    Assert.equal(Value.Check(T, { x: 1 }), true)
+    Assert.equal(Value.Check(T, { x: '1' }), false)
+  })
+  it('Should not intersect two union objects with overlapping properties of varying types', () => {
+    const A = Type.Union([Type.Object({ x: Type.Number() })])
+    const B = Type.Union([Type.Object({ x: Type.String() })])
+    const T = Type.Intersect([A, B])
+    Assert.equal(Value.Check(T, { x: 1 }), false)
+    Assert.equal(Value.Check(T, { x: '1' }), false)
+  })
+  it('Should intersect two union objects with non-overlapping properties', () => {
+    const A = Type.Union([Type.Object({ x: Type.Number() })])
+    const B = Type.Union([Type.Object({ y: Type.Number() })])
+    const T = Type.Intersect([A, B])
+    Assert.equal(Value.Check(T, { x: 1, y: 1 }), true)
+  })
+  it('Should not intersect two union objects with non-overlapping properties for additionalProperties false', () => {
+    const A = Type.Union([Type.Object({ x: Type.Number() }, { additionalProperties: false })])
+    const B = Type.Union([Type.Object({ y: Type.Number() }, { additionalProperties: false })])
     const T = Type.Intersect([A, B])
-    const value = {
-      a: '1',
-      b: '1',
-      c: '1',
-    }
-    const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.equal(Value.Check(T, { x: 1, y: 1 }), false)
   })
 })
diff --git a/test/runtime/value/check/not.ts b/test/runtime/value/check/not.ts
new file mode 100644
index 000000000..b6a0b08f6
--- /dev/null
+++ b/test/runtime/value/check/not.ts
@@ -0,0 +1,39 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Not', () => {
+  it('Should validate with not number', () => {
+    const T = Type.Not(Type.Number(), Type.String())
+    Assert.equal(Value.Check(T, 1), false)
+    Assert.equal(Value.Check(T, 'A'), true)
+  })
+  it('Should validate with union left', () => {
+    // prettier-ignore
+    const T = Type.Not(Type.Union([
+            Type.Literal('A'),
+            Type.Literal('B'),
+            Type.Literal('C')
+        ]), Type.String())
+    Assert.equal(Value.Check(T, 'A'), false)
+    Assert.equal(Value.Check(T, 'B'), false)
+    Assert.equal(Value.Check(T, 'C'), false)
+    Assert.equal(Value.Check(T, 'D'), true)
+  })
+  it('Should validate with union right', () => {
+    // prettier-ignore
+    const T = Type.Not(Type.Number(), Type.Union([
+            Type.String(),
+            Type.Boolean()
+        ]))
+    Assert.equal(Value.Check(T, 1), false)
+    Assert.equal(Value.Check(T, 'A'), true)
+    Assert.equal(Value.Check(T, true), true)
+  })
+  it('Should not validate with symmetric left right', () => {
+    // prettier-ignore
+    const T = Type.Not(Type.Number(), Type.Number())
+    Assert.equal(Value.Check(T, 1), false)
+    Assert.equal(Value.Check(T, true), false)
+  })
+})
diff --git a/test/runtime/value/check/number.ts b/test/runtime/value/check/number.ts
index 86dd673f1..e2d0c63b8 100644
--- a/test/runtime/value/check/number.ts
+++ b/test/runtime/value/check/number.ts
@@ -4,6 +4,21 @@ import { Assert } from '../../assert/index'
 
 describe('value/check/Number', () => {
   const T = Type.Number()
+  it('Should not validate NaN', () => {
+    const T = Type.Number()
+    const result = Value.Check(T, NaN)
+    Assert.equal(result, false)
+  })
+  it('Should not validate +Infinity', () => {
+    const T = Type.Number()
+    const result = Value.Check(T, Infinity)
+    Assert.equal(result, false)
+  })
+  it('Should not validate -Infinity', () => {
+    const T = Type.Number()
+    const result = Value.Check(T, -Infinity)
+    Assert.equal(result, false)
+  })
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
diff --git a/test/runtime/value/check/object.ts b/test/runtime/value/check/object.ts
index ed6a76d93..6b672b938 100644
--- a/test/runtime/value/check/object.ts
+++ b/test/runtime/value/check/object.ts
@@ -212,4 +212,16 @@ describe('value/check/Object', () => {
     Assert.equal(Value.Check(T, { x: undefined }), true)
     Assert.equal(Value.Check(T, {}), true)
   })
+  it('Should not check undefined for optional property of number', () => {
+    const T = Type.Object({ x: Type.Optional(Type.Number()) })
+    Assert.equal(Value.Check(T, { x: 1 }), true)
+    Assert.equal(Value.Check(T, {}), true)
+    Assert.equal(Value.Check(T, { x: undefined }), false)
+  })
+  it('Should check undefined for optional property of undefined', () => {
+    const T = Type.Object({ x: Type.Optional(Type.Undefined()) })
+    Assert.equal(Value.Check(T, { x: 1 }), false)
+    Assert.equal(Value.Check(T, {}), true)
+    Assert.equal(Value.Check(T, { x: undefined }), true)
+  })
 })
diff --git a/test/runtime/value/check/record.ts b/test/runtime/value/check/record.ts
index 86d3d38e6..3bea978c0 100644
--- a/test/runtime/value/check/record.ts
+++ b/test/runtime/value/check/record.ts
@@ -22,7 +22,16 @@ describe('value/check/Record', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, true)
   })
-
+  it('Should fail record with Date', () => {
+    const T = Type.Record(Type.String(), Type.String())
+    const result = Value.Check(T, new Date())
+    Assert.equal(result, false)
+  })
+  it('Should fail record with Uint8Array', () => {
+    const T = Type.Record(Type.String(), Type.String())
+    const result = Value.Check(T, new Uint8Array())
+    Assert.equal(result, false)
+  })
   it('Should fail record with missing property', () => {
     const T = Type.Record(
       Type.String(),
diff --git a/test/runtime/value/check/ref.ts b/test/runtime/value/check/ref.ts
new file mode 100644
index 000000000..be4c2980b
--- /dev/null
+++ b/test/runtime/value/check/ref.ts
@@ -0,0 +1,83 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Ref', () => {
+  it('Should should validate when referencing a type', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { $id: Assert.nextId() },
+    )
+    const R = Type.Ref(T)
+    Assert.deepEqual(
+      Value.Check(R, [T], {
+        x: 1,
+        y: 2,
+        z: 3,
+      }),
+      true,
+    )
+  })
+
+  it('Should not validate when passing invalid data', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { $id: Assert.nextId() },
+    )
+    const R = Type.Ref(T)
+    Assert.deepEqual(
+      Value.Check(R, [T], {
+        x: 1,
+        y: 2,
+      }),
+      false,
+    )
+  })
+
+  it('Should de-reference object property schema', () => {
+    const T = Type.Object(
+      {
+        name: Type.String(),
+      },
+      { $id: 'R' },
+    )
+
+    const R = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+        r: Type.Optional(Type.Ref(T)),
+      },
+      { $id: 'T' },
+    )
+    Assert.deepEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3 }), true)
+    Assert.deepEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3, r: { name: 'hello' } }), true)
+    Assert.deepEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3, r: { name: 1 } }), false)
+    Assert.deepEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3, r: {} }), false)
+    // Ok(R, { x: 1, y: 2, z: 3 }, [T])
+    // Ok(R, , [T])
+    // Fail(R, , [T])
+    // Fail(R, , [T])
+  })
+
+  it('Should reference recursive schema', () => {
+    const T = Type.Recursive((Node) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(Node),
+      }),
+    )
+    const R = Type.Ref(T)
+    Assert.deepEqual(Value.Check(R, [T], { id: '', nodes: [{ id: '', nodes: [] }] }), true)
+    Assert.deepEqual(Value.Check(R, [T], { id: '', nodes: [{ id: 1, nodes: [] }] }), false)
+  })
+})
diff --git a/test/runtime/value/check/symbol.ts b/test/runtime/value/check/symbol.ts
new file mode 100644
index 000000000..f2df521eb
--- /dev/null
+++ b/test/runtime/value/check/symbol.ts
@@ -0,0 +1,52 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Symbol', () => {
+  const T = Type.Symbol()
+  it('Should fail string', () => {
+    const value = 'hello'
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail number', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail boolean', () => {
+    const value = true
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail null', () => {
+    const value = null
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail undefined', () => {
+    const value = undefined
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail object', () => {
+    const value = { a: 1 }
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail array', () => {
+    const value = [1, 2]
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should fail Date', () => {
+    const value = new Date()
+    const result = Value.Check(T, value)
+    Assert.equal(result, false)
+  })
+  it('Should pass symbol', () => {
+    const value = Symbol(1)
+    const result = Value.Check(T, value)
+    Assert.equal(result, true)
+  })
+})
diff --git a/test/runtime/value/check/void.ts b/test/runtime/value/check/void.ts
index c6079c354..5930cb44f 100644
--- a/test/runtime/value/check/void.ts
+++ b/test/runtime/value/check/void.ts
@@ -22,12 +22,12 @@ describe('value/check/Void', () => {
   it('Should pass null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.equal(result, false)
   })
-  it('Should fail undefined', () => {
+  it('Should pass undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.equal(result, true)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
diff --git a/test/runtime/value/convert/any.ts b/test/runtime/value/convert/any.ts
new file mode 100644
index 000000000..cb776c87c
--- /dev/null
+++ b/test/runtime/value/convert/any.ts
@@ -0,0 +1,42 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Any', () => {
+  const T = Type.Any()
+  it('Should convert null', () => {
+    const V = null
+    const R = Value.Convert(T, V)
+    Assert.deepEqual(R, V)
+  })
+  it('Should convert undefined', () => {
+    const V = undefined
+    const R = Value.Convert(T, V)
+    Assert.deepEqual(R, V)
+  })
+  it('Should convert string', () => {
+    const V = 'hello'
+    const R = Value.Convert(T, V)
+    Assert.deepEqual(R, V)
+  })
+  it('Should convert number', () => {
+    const V = 42
+    const R = Value.Convert(T, V)
+    Assert.deepEqual(R, V)
+  })
+  it('Should convert boolean', () => {
+    const V = true
+    const R = Value.Convert(T, V)
+    Assert.deepEqual(R, V)
+  })
+  it('Should convert object', () => {
+    const V = { x: 1 }
+    const R = Value.Convert(T, V)
+    Assert.deepEqual(R, V)
+  })
+  it('Should convert array', () => {
+    const V = [1, 2, 3]
+    const R = Value.Convert(T, V)
+    Assert.deepEqual(R, V)
+  })
+})
diff --git a/test/runtime/value/convert/array.ts b/test/runtime/value/convert/array.ts
new file mode 100644
index 000000000..18e41d496
--- /dev/null
+++ b/test/runtime/value/convert/array.ts
@@ -0,0 +1,32 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Array', () => {
+  it('Should convert array of number', () => {
+    const T = Type.Array(Type.Number())
+    const R = Value.Convert(T, [1, 3.14, '1', '3.14', true, false, 'true', 'false', 'hello'])
+    Assert.deepEqual(R, [1, 3.14, 1, 3.14, 1, 0, 1, 0, 'hello'])
+  })
+  it('Should convert array of boolean', () => {
+    const T = Type.Array(Type.Boolean())
+    const R = Value.Convert(T, [1, 3.14, '1', '3.14', true, false, 'true', 'false', 'hello'])
+    Assert.deepEqual(R, [true, 3.14, true, '3.14', true, false, true, false, 'hello'])
+  })
+  it('Should convert array of string', () => {
+    const T = Type.Array(Type.String())
+    const R = Value.Convert(T, [1, 3.14, '1', '3.14', true, false, 'true', 'false', 'hello'])
+    Assert.deepEqual(R, ['1', '3.14', '1', '3.14', 'true', 'false', 'true', 'false', 'hello'])
+  })
+  it('Should convert array of date', () => {
+    const T = Type.Array(Type.Date())
+    const R = Value.Convert(T, [1, '1', true, false, 'true', 'false', 'hello']) as any[]
+    Assert.deepEqual(R[0].getTime(), 1)
+    Assert.deepEqual(R[1].getTime(), 1)
+    Assert.deepEqual(R[2].getTime(), 1)
+    Assert.deepEqual(R[3].getTime(), 0)
+    Assert.deepEqual(R[4].getTime(), 1)
+    Assert.deepEqual(R[5].getTime(), 0)
+    Assert.deepEqual(R[6], 'hello')
+  })
+})
diff --git a/test/runtime/value/convert/bigint.ts b/test/runtime/value/convert/bigint.ts
new file mode 100644
index 000000000..69a23791e
--- /dev/null
+++ b/test/runtime/value/convert/bigint.ts
@@ -0,0 +1,46 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/BigInt', () => {
+  it('Should convert bitint from string 1', () => {
+    const T = Type.BigInt()
+    const R = Value.Convert(T, '1')
+    Assert.deepEqual(R, BigInt(1))
+  })
+  it('Should convert bigint from string 2', () => {
+    const T = Type.BigInt()
+    const R = Value.Convert(T, '3.14')
+    Assert.deepEqual(R, BigInt(3))
+  })
+  it('Should convert bitint from string 3', () => {
+    const T = Type.BigInt()
+    const R = Value.Convert(T, 'true')
+    Assert.deepEqual(R, BigInt(1))
+  })
+  it('Should convert bigint from string 4', () => {
+    const T = Type.BigInt()
+    const R = Value.Convert(T, 'false')
+    Assert.deepEqual(R, BigInt(0))
+  })
+  it('Should convert bitint from number 1', () => {
+    const T = Type.BigInt()
+    const R = Value.Convert(T, 1)
+    Assert.deepEqual(R, BigInt(1))
+  })
+  it('Should convert bigint from number 2', () => {
+    const T = Type.BigInt()
+    const R = Value.Convert(T, 3.14)
+    Assert.deepEqual(R, BigInt(3))
+  })
+  it('Should convert bitint from boolean 1', () => {
+    const T = Type.BigInt()
+    const R = Value.Convert(T, true)
+    Assert.deepEqual(R, BigInt(1))
+  })
+  it('Should convert bigint from boolean 2', () => {
+    const T = Type.BigInt()
+    const R = Value.Convert(T, false)
+    Assert.deepEqual(R, BigInt(0))
+  })
+})
diff --git a/test/runtime/value/convert/boolean.ts b/test/runtime/value/convert/boolean.ts
new file mode 100644
index 000000000..02f3422af
--- /dev/null
+++ b/test/runtime/value/convert/boolean.ts
@@ -0,0 +1,154 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Boolean', () => {
+  it('Should convert from string 1', () => {
+    const T = Type.Boolean()
+    const R = Value.Convert(T, '1')
+    Assert.deepEqual(R, true)
+  })
+  it('Should convert from string 2', () => {
+    const T = Type.Boolean()
+    const R = Value.Convert(T, '3.14')
+    Assert.deepEqual(R, '3.14')
+  })
+  it('Should convert from string 3', () => {
+    const T = Type.Boolean()
+    const R = Value.Convert(T, 'true')
+    Assert.deepEqual(R, true)
+  })
+  it('Should convert from string 4', () => {
+    const T = Type.Boolean()
+    const R = Value.Convert(T, 'false')
+    Assert.deepEqual(R, false)
+  })
+  it('Should convert from number 1', () => {
+    const T = Type.Boolean()
+    const R = Value.Convert(T, 1)
+    Assert.deepEqual(R, true)
+  })
+  it('Should convert from number 2', () => {
+    const T = Type.Boolean()
+    const R = Value.Convert(T, 3.14)
+    Assert.deepEqual(R, 3.14)
+  })
+  it('Should convert from number 3', () => {
+    const T = Type.Boolean()
+    const R = Value.Convert(T, 1.1)
+    Assert.deepEqual(R, 1.1)
+  })
+  it('Should convert from boolean 1', () => {
+    const T = Type.Boolean()
+    const R = Value.Convert(T, true)
+    Assert.deepEqual(R, true)
+  })
+  it('Should convert from boolean 2', () => {
+    const T = Type.Boolean()
+    const R = Value.Convert(T, false)
+    Assert.deepEqual(R, false)
+  })
+  // ----------------------------------------------------------
+  // Casts
+  // ----------------------------------------------------------
+  it('Should convert string #1', () => {
+    const value = 'hello'
+    const result = Value.Convert(Type.Boolean(), value)
+    Assert.deepEqual(result, 'hello')
+  })
+  it('Should convert string #2', () => {
+    const value = 'true'
+    const result = Value.Convert(Type.Boolean(), value)
+    Assert.deepEqual(result, true)
+  })
+  it('Should convert string #3', () => {
+    const value = 'TRUE'
+    const result = Value.Convert(Type.Boolean(), value)
+    Assert.deepEqual(result, true)
+  })
+  it('Should convert string #4', () => {
+    const value = 'false'
+    const result = Value.Convert(Type.Boolean(), value)
+    Assert.deepEqual(result, false)
+  })
+  it('Should convert string #5', () => {
+    const value = '0'
+    const result = Value.Convert(Type.Boolean(), value)
+    Assert.deepEqual(result, false)
+  })
+  it('Should convert string #6', () => {
+    const value = '1'
+    const result = Value.Convert(Type.Boolean(), value)
+    Assert.deepEqual(result, true)
+  })
+  it('Should convert string #7', () => {
+    const value = '0'
+    const result = Value.Convert(Type.Boolean({ default: true }), value)
+    Assert.deepEqual(result, false)
+  })
+  it('Should convert string #8', () => {
+    const value = '1'
+    const result = Value.Convert(Type.Boolean({ default: false }), value)
+    Assert.deepEqual(result, true)
+  })
+  it('Should convert string #8', () => {
+    const value = '2'
+    const result = Value.Convert(Type.Boolean({ default: true }), value)
+    Assert.deepEqual(result, '2')
+  })
+  it('Should convert number #1', () => {
+    const value = 0
+    const result = Value.Convert(Type.Boolean(), value)
+    Assert.deepEqual(result, false)
+  })
+  it('Should convert number #2', () => {
+    const value = 1n
+    const result = Value.Convert(Type.Boolean(), value)
+    Assert.deepEqual(result, true)
+  })
+  it('Should convert number #3', () => {
+    const value = 1
+    const result = Value.Convert(Type.Boolean(), value)
+    Assert.deepEqual(result, true)
+  })
+  it('Should convert number #4', () => {
+    const value = 2
+    const result = Value.Convert(Type.Boolean(), value)
+    Assert.deepEqual(result, 2)
+  })
+  it('Should convert number #5', () => {
+    const value = 0
+    const result = Value.Convert(Type.Boolean({ default: true }), value)
+    Assert.deepEqual(result, false)
+  })
+  it('Should convert number #6', () => {
+    const value = 1
+    const result = Value.Convert(Type.Boolean({ default: false }), value)
+    Assert.deepEqual(result, true)
+  })
+  it('Should convert number #7', () => {
+    const value = 2
+    const result = Value.Convert(Type.Boolean({ default: true }), value)
+    Assert.deepEqual(result, 2)
+  })
+  it('Should convert true', () => {
+    const value = true
+    const result = Value.Convert(Type.Boolean(), value)
+    Assert.deepEqual(result, true)
+  })
+  it('Should convert false', () => {
+    const value = false
+    const result = Value.Convert(Type.Boolean(), value)
+    Assert.deepEqual(result, false)
+  })
+  it('Should convert object', () => {
+    const value = {}
+    const result = Value.Convert(Type.Boolean(), value)
+    Assert.deepEqual(result, {})
+  })
+  it('Should convert array', () => {
+    const value = [] as any[]
+    const result = Value.Convert(Type.Boolean(), value)
+    Assert.deepEqual(result, [])
+  })
+})
diff --git a/test/runtime/value/convert/composite.ts b/test/runtime/value/convert/composite.ts
new file mode 100644
index 000000000..a8944d449
--- /dev/null
+++ b/test/runtime/value/convert/composite.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Composite', () => {
+  it('Should convert properties', () => {
+    // prettier-ignore
+    const T = Type.Composite([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Boolean() }),
+      Type.Object({ z: Type.Boolean() })
+    ])
+    const R = Value.Convert(T, { x: '42', y: 'true', z: 'hello' })
+    Assert.deepEqual(R, { x: 42, y: true, z: 'hello' })
+  })
+})
diff --git a/test/runtime/value/convert/custom.ts b/test/runtime/value/convert/custom.ts
new file mode 100644
index 000000000..82887cefd
--- /dev/null
+++ b/test/runtime/value/convert/custom.ts
@@ -0,0 +1,24 @@
+import { Value } from '@sinclair/typebox/value'
+import { TypeSystem } from '@sinclair/typebox/system'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Custom', () => {
+  it('Should not convert 1', () => {
+    const Custom = TypeSystem.Type('type/convert/Custom/1', () => true)
+    const T = Custom()
+    const R = Value.Convert(T, true)
+    Assert.deepEqual(R, true)
+  })
+  it('Should not convert 2', () => {
+    const Custom = TypeSystem.Type('type/convert/Custom/2', () => true)
+    const T = Custom()
+    const R = Value.Convert(T, 42)
+    Assert.deepEqual(R, 42)
+  })
+  it('Should not convert 3', () => {
+    const Custom = TypeSystem.Type('type/convert/Custom/3', () => true)
+    const T = Custom()
+    const R = Value.Convert(T, 'hello')
+    Assert.deepEqual(R, 'hello')
+  })
+})
diff --git a/test/runtime/value/convert/date.ts b/test/runtime/value/convert/date.ts
new file mode 100644
index 000000000..27ea49c24
--- /dev/null
+++ b/test/runtime/value/convert/date.ts
@@ -0,0 +1,42 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Date', () => {
+  it('Should convert from number', () => {
+    const result = Value.Convert(Type.Date(), 123) as Date
+    Assert.deepEqual(result.getTime(), 123)
+  })
+  it('Should convert from numeric string', () => {
+    const result = Value.Convert(Type.Date(), '123') as Date
+    Assert.deepEqual(result.getTime(), 123)
+  })
+  it('Should convert from boolean true (interpretted as numeric 1)', () => {
+    const result = Value.Convert(Type.Date(), true) as Date
+    Assert.deepEqual(result.getTime(), 1)
+  })
+  it('Should convert from datetime string', () => {
+    const result = Value.Convert(Type.Date(), '1980-02-03T01:02:03.000Z') as Date
+    Assert.deepEqual(result.toISOString(), '1980-02-03T01:02:03.000Z')
+  })
+  it('Should convert from datetime string without timezone', () => {
+    const result = Value.Convert(Type.Date(), '1980-02-03T01:02:03') as Date
+    Assert.deepEqual(result.toISOString(), '1980-02-03T01:02:03.000Z')
+  })
+  it('Should convert from time with timezone', () => {
+    const result = Value.Convert(Type.Date(), '01:02:03.000Z') as Date
+    Assert.deepEqual(result.toISOString(), '1970-01-01T01:02:03.000Z')
+  })
+  it('Should convert from time without timezone', () => {
+    const result = Value.Convert(Type.Date(), '01:02:03') as Date
+    Assert.deepEqual(result.toISOString(), '1970-01-01T01:02:03.000Z')
+  })
+  it('Should convert from date string', () => {
+    const result = Value.Convert(Type.Date(), '1980-02-03') as Date
+    Assert.deepEqual(result.toISOString(), '1980-02-03T00:00:00.000Z')
+  })
+  it('Should convert invalid strings to unix epoch 0', () => {
+    const result = Value.Convert(Type.Date(), 'invalid-date') as Date
+    Assert.deepEqual(result, 'invalid-date')
+  })
+})
diff --git a/test/runtime/value/convert/enum.ts b/test/runtime/value/convert/enum.ts
new file mode 100644
index 000000000..a42c758e9
--- /dev/null
+++ b/test/runtime/value/convert/enum.ts
@@ -0,0 +1,7 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Enum', () => {
+  it('Should convert', () => {})
+})
diff --git a/test/runtime/value/convert/index.ts b/test/runtime/value/convert/index.ts
new file mode 100644
index 000000000..a14997a97
--- /dev/null
+++ b/test/runtime/value/convert/index.ts
@@ -0,0 +1,26 @@
+import './any'
+import './array'
+import './bigint'
+import './boolean'
+import './composite'
+import './custom'
+import './date'
+import './enum'
+import './integer'
+import './keyof'
+import './literal'
+import './never'
+import './null'
+import './number'
+import './object'
+import './recursive'
+import './record'
+import './regex'
+import './string'
+import './symbol'
+import './tuple'
+import './uint8array'
+import './undefined'
+import './union'
+import './unknown'
+import './void'
diff --git a/test/runtime/value/convert/integer.ts b/test/runtime/value/convert/integer.ts
new file mode 100644
index 000000000..e2f03c32a
--- /dev/null
+++ b/test/runtime/value/convert/integer.ts
@@ -0,0 +1,79 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Integer', () => {
+  it('Should convert from string 1', () => {
+    const T = Type.Integer()
+    const R = Value.Convert(T, '3.14')
+    Assert.deepEqual(R, 3)
+  })
+  it('Should convert from string 2', () => {
+    const T = Type.Integer()
+    const R = Value.Convert(T, '42')
+    Assert.deepEqual(R, 42)
+  })
+  it('Should convert from boolean 1', () => {
+    const T = Type.Integer()
+    const R = Value.Convert(T, true)
+    Assert.deepEqual(R, 1)
+  })
+  it('Should convert from boolean 2', () => {
+    const T = Type.Integer()
+    const R = Value.Convert(T, false)
+    Assert.deepEqual(R, 0)
+  })
+  it('Should convert from number 1', () => {
+    const T = Type.Integer()
+    const R = Value.Convert(T, 3.14)
+    Assert.deepEqual(R, 3)
+  })
+  // ----------------------------------------------------------
+  // Casts
+  // ----------------------------------------------------------
+  it('Should convert string #1', () => {
+    const value = 'hello'
+    const result = Value.Convert(Type.Integer(), value)
+    Assert.deepEqual(result, 'hello')
+  })
+  it('Should convert string #2', () => {
+    const value = '3.14'
+    const result = Value.Convert(Type.Integer(), value)
+    Assert.deepEqual(result, 3)
+  })
+  it('Should convert string #3', () => {
+    const value = '-0'
+    const result = Value.Convert(Type.Integer(), value)
+    Assert.deepEqual(result, 0)
+  })
+  it('Should convert string #4', () => {
+    const value = '-100'
+    const result = Value.Convert(Type.Integer(), value)
+    Assert.deepEqual(result, -100)
+  })
+  it('Should convert number', () => {
+    const value = 42
+    const result = Value.Convert(Type.Integer(), value)
+    Assert.deepEqual(result, 42)
+  })
+  it('Should convert true', () => {
+    const value = true
+    const result = Value.Convert(Type.Integer(), value)
+    Assert.deepEqual(result, 1)
+  })
+  it('Should convert false', () => {
+    const value = false
+    const result = Value.Convert(Type.Integer(), value)
+    Assert.deepEqual(result, 0)
+  })
+  it('Should convert object', () => {
+    const value = {}
+    const result = Value.Convert(Type.Integer(), value)
+    Assert.deepEqual(result, {})
+  })
+  it('Should convert array', () => {
+    const value = [] as any[]
+    const result = Value.Convert(Type.Integer(), value)
+    Assert.deepEqual(result, [])
+  })
+})
diff --git a/test/runtime/value/convert/keyof.ts b/test/runtime/value/convert/keyof.ts
new file mode 100644
index 000000000..5f4141fe1
--- /dev/null
+++ b/test/runtime/value/convert/keyof.ts
@@ -0,0 +1,7 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/KeyOf', () => {
+  it('Should convert', () => {})
+})
diff --git a/test/runtime/value/convert/literal.ts b/test/runtime/value/convert/literal.ts
new file mode 100644
index 000000000..6943c3637
--- /dev/null
+++ b/test/runtime/value/convert/literal.ts
@@ -0,0 +1,85 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Literal:String', () => {
+  it('Should convert from number 1', () => {
+    const T = Type.Literal('1')
+    const R = Value.Convert(T, 1)
+    Assert.deepEqual(R, '1')
+  })
+  it('Should convert from number 2', () => {
+    const T = Type.Literal('1')
+    const R = Value.Convert(T, 2)
+    Assert.deepEqual(R, 2)
+  })
+  it('Should convert from boolean', () => {
+    const T = Type.Literal('true')
+    const R = Value.Convert(T, true)
+    Assert.deepEqual(R, 'true')
+  })
+})
+describe('value/convert/Literal:Number', () => {
+  it('Should convert from number 1', () => {
+    const T = Type.Literal(3.14)
+    const R = Value.Convert(T, '3.14')
+    Assert.deepEqual(R, 3.14)
+  })
+  it('Should convert from number 2', () => {
+    const T = Type.Literal(3.14)
+    const R = Value.Convert(T, '3.15')
+    Assert.deepEqual(R, '3.15')
+  })
+  it('Should convert from boolean 1', () => {
+    const T = Type.Literal(1)
+    const R = Value.Convert(T, true)
+    Assert.deepEqual(R, 1)
+  })
+  it('Should convert from boolean 2', () => {
+    const T = Type.Literal(0)
+    const R = Value.Convert(T, false)
+    Assert.deepEqual(R, 0)
+  })
+  it('Should convert from boolean 3', () => {
+    const T = Type.Literal(2)
+    const R = Value.Convert(T, true)
+    Assert.deepEqual(R, true)
+  })
+})
+describe('value/convert/Literal:Boolean', () => {
+  it('Should convert from number 1', () => {
+    const T = Type.Literal(true)
+    const R = Value.Convert(T, 3.14)
+    Assert.deepEqual(R, 3.14)
+  })
+  it('Should convert from number 2', () => {
+    const T = Type.Literal(true)
+    const R = Value.Convert(T, 1)
+    Assert.deepEqual(R, true)
+  })
+  it('Should convert from string 1', () => {
+    const T = Type.Literal(true)
+    const R = Value.Convert(T, 'true')
+    Assert.deepEqual(R, true)
+  })
+  it('Should convert from string 2', () => {
+    const T = Type.Literal(false)
+    const R = Value.Convert(T, 'false')
+    Assert.deepEqual(R, false)
+  })
+  it('Should convert from string 3', () => {
+    const T = Type.Literal(true)
+    const R = Value.Convert(T, '1')
+    Assert.deepEqual(R, true)
+  })
+  it('Should convert from string 4', () => {
+    const T = Type.Literal(false)
+    const R = Value.Convert(T, '0')
+    Assert.deepEqual(R, false)
+  })
+  it('Should convert from string 5', () => {
+    const T = Type.Literal(false)
+    const R = Value.Convert(T, '2')
+    Assert.deepEqual(R, '2')
+  })
+})
diff --git a/test/runtime/value/convert/never.ts b/test/runtime/value/convert/never.ts
new file mode 100644
index 000000000..eb481d593
--- /dev/null
+++ b/test/runtime/value/convert/never.ts
@@ -0,0 +1,21 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Never', () => {
+  it('Should not convert 1', () => {
+    const T = Type.Never()
+    const R = Value.Convert(T, true)
+    Assert.deepEqual(R, true)
+  })
+  it('Should not convert 2', () => {
+    const T = Type.Never()
+    const R = Value.Convert(T, 42)
+    Assert.deepEqual(R, 42)
+  })
+  it('Should not convert 3', () => {
+    const T = Type.Never()
+    const R = Value.Convert(T, 'true')
+    Assert.deepEqual(R, 'true')
+  })
+})
diff --git a/test/runtime/value/convert/null.ts b/test/runtime/value/convert/null.ts
new file mode 100644
index 000000000..bda1930a8
--- /dev/null
+++ b/test/runtime/value/convert/null.ts
@@ -0,0 +1,19 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Null', () => {
+  const T = Type.Null()
+  it('Should convert from string 1', () => {
+    const R = Value.Convert(T, 'null')
+    Assert.deepEqual(R, null)
+  })
+  it('Should convert from string 2', () => {
+    const R = Value.Convert(T, 'NULL')
+    Assert.deepEqual(R, null)
+  })
+  it('Should convert from string 3', () => {
+    const R = Value.Convert(T, 'nil')
+    Assert.deepEqual(R, 'nil')
+  })
+})
diff --git a/test/runtime/value/convert/number.ts b/test/runtime/value/convert/number.ts
new file mode 100644
index 000000000..3b5029c8c
--- /dev/null
+++ b/test/runtime/value/convert/number.ts
@@ -0,0 +1,76 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Number', () => {
+  const T = Type.Number()
+  it('Should convert from string 1', () => {
+    const R = Value.Convert(T, '3.14')
+    Assert.deepEqual(R, 3.14)
+  })
+  it('Should convert from string 2', () => {
+    const R = Value.Convert(T, '42')
+    Assert.deepEqual(R, 42)
+  })
+  it('Should convert from boolean 1', () => {
+    const R = Value.Convert(T, true)
+    Assert.deepEqual(R, 1)
+  })
+  it('Should convert from boolean 2', () => {
+    const R = Value.Convert(T, false)
+    Assert.deepEqual(R, 0)
+  })
+  it('Should convert from number 1', () => {
+    const R = Value.Convert(T, 3.14)
+    Assert.deepEqual(R, 3.14)
+  })
+
+  // ----------------------------------------------------------
+  // Casts
+  // ----------------------------------------------------------
+  it('Should convert string #1', () => {
+    const value = 'hello'
+    const result = Value.Convert(Type.Number(), value)
+    Assert.deepEqual(result, 'hello')
+  })
+  it('Should convert string #2', () => {
+    const value = '3.14'
+    const result = Value.Convert(Type.Number(), value)
+    Assert.deepEqual(result, 3.14)
+  })
+  it('Should convert string #3', () => {
+    const value = '-0'
+    const result = Value.Convert(Type.Number(), value)
+    Assert.deepEqual(result, 0)
+  })
+  it('Should convert string #4', () => {
+    const value = '-100'
+    const result = Value.Convert(Type.Number(), value)
+    Assert.deepEqual(result, -100)
+  })
+  it('Should convert number', () => {
+    const value = 42
+    const result = Value.Convert(Type.Number(), value)
+    Assert.deepEqual(result, 42)
+  })
+  it('Should convert true', () => {
+    const value = true
+    const result = Value.Convert(Type.Number(), value)
+    Assert.deepEqual(result, 1)
+  })
+  it('Should convert false', () => {
+    const value = false
+    const result = Value.Convert(Type.Number(), value)
+    Assert.deepEqual(result, 0)
+  })
+  it('Should convert object', () => {
+    const value = {}
+    const result = Value.Convert(Type.String(), value)
+    Assert.deepEqual(result, {})
+  })
+  it('Should convert array', () => {
+    const value = [] as any[]
+    const result = Value.Convert(Type.String(), value)
+    Assert.deepEqual(result, [])
+  })
+})
diff --git a/test/runtime/value/convert/object.ts b/test/runtime/value/convert/object.ts
new file mode 100644
index 000000000..2c85d60f2
--- /dev/null
+++ b/test/runtime/value/convert/object.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Object', () => {
+  it('Should convert properties', () => {
+    // prettier-ignore
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.Boolean(),
+      z: Type.Boolean()
+    })
+    const R = Value.Convert(T, { x: '42', y: 'true', z: 'hello' })
+    Assert.deepEqual(R, { x: 42, y: true, z: 'hello' })
+  })
+})
diff --git a/test/runtime/value/convert/record.ts b/test/runtime/value/convert/record.ts
new file mode 100644
index 000000000..bfeb7129c
--- /dev/null
+++ b/test/runtime/value/convert/record.ts
@@ -0,0 +1,7 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Record', () => {
+  it('Should convert', () => {})
+})
diff --git a/test/runtime/value/convert/recursive.ts b/test/runtime/value/convert/recursive.ts
new file mode 100644
index 000000000..5cae25261
--- /dev/null
+++ b/test/runtime/value/convert/recursive.ts
@@ -0,0 +1,7 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Recursive', () => {
+  it('Should convert', () => {})
+})
diff --git a/test/runtime/value/convert/regex.ts b/test/runtime/value/convert/regex.ts
new file mode 100644
index 000000000..8f4efad92
--- /dev/null
+++ b/test/runtime/value/convert/regex.ts
@@ -0,0 +1,7 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/RegEx', () => {
+  it('Should convert', () => {})
+})
diff --git a/test/runtime/value/convert/string.ts b/test/runtime/value/convert/string.ts
new file mode 100644
index 000000000..b20c3ccf7
--- /dev/null
+++ b/test/runtime/value/convert/string.ts
@@ -0,0 +1,69 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/String', () => {
+  const T = Type.String()
+  it('Should convert from number 1', () => {
+    const R = Value.Convert(T, 3.14)
+    Assert.deepEqual(R, '3.14')
+  })
+  it('Should convert from number 2', () => {
+    const R = Value.Convert(T, 3)
+    Assert.deepEqual(R, '3')
+  })
+  it('Should convert from boolean 1', () => {
+    const R = Value.Convert(T, true)
+    Assert.deepEqual(R, 'true')
+  })
+  it('Should convert from boolean 2', () => {
+    const R = Value.Convert(T, false)
+    Assert.deepEqual(R, 'false')
+  })
+  it('Should convert from bigint', () => {
+    const R = Value.Convert(T, BigInt(12345))
+    Assert.deepEqual(R, '12345')
+  })
+  it('Should convert from symbol', () => {
+    const R = Value.Convert(T, Symbol(12345))
+    Assert.deepEqual(R, '12345')
+  })
+  // ----------------------------------------------------------
+  // Casts
+  // ----------------------------------------------------------
+  it('Should convert string', () => {
+    const value = 'hello'
+    const result = Value.Convert(Type.String(), value)
+    Assert.deepEqual(result, 'hello')
+  })
+  it('Should convert number #1', () => {
+    const value = 42
+    const result = Value.Convert(Type.String(), value)
+    Assert.deepEqual(result, '42')
+  })
+  it('Should convert number #2', () => {
+    const value = 42n
+    const result = Value.Convert(Type.String(), value)
+    Assert.deepEqual(result, '42')
+  })
+  it('Should convert true', () => {
+    const value = true
+    const result = Value.Convert(Type.String(), value)
+    Assert.deepEqual(result, 'true')
+  })
+  it('Should convert false', () => {
+    const value = false
+    const result = Value.Convert(Type.String(), value)
+    Assert.deepEqual(result, 'false')
+  })
+  it('Should convert object', () => {
+    const value = {}
+    const result = Value.Convert(Type.String(), value)
+    Assert.deepEqual(result, {})
+  })
+  it('Should convert array', () => {
+    const value = [] as any[]
+    const result = Value.Convert(Type.String(), value)
+    Assert.deepEqual(result, [])
+  })
+})
diff --git a/test/runtime/value/convert/symbol.ts b/test/runtime/value/convert/symbol.ts
new file mode 100644
index 000000000..fe2a158e3
--- /dev/null
+++ b/test/runtime/value/convert/symbol.ts
@@ -0,0 +1,15 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Symbol', () => {
+  const T = Type.Symbol()
+  it('Should convert from number 1', () => {
+    const R = Value.Convert(T, 3.14)
+    Assert.deepEqual(R, '3.14')
+  })
+  it('Should convert from number 2', () => {
+    const R = Value.Convert(T, 3)
+    Assert.deepEqual(R, '3')
+  })
+})
diff --git a/test/runtime/value/convert/tuple.ts b/test/runtime/value/convert/tuple.ts
new file mode 100644
index 000000000..eafc01c42
--- /dev/null
+++ b/test/runtime/value/convert/tuple.ts
@@ -0,0 +1,21 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Tuple', () => {
+  it('Should convert from Array 1', () => {
+    const T = Type.Tuple([Type.Number(), Type.Number()])
+    const R = Value.Convert(T, ['1', 'true'])
+    Assert.deepEqual(R, [1, true])
+  })
+  it('Should convert from Array 2', () => {
+    const T = Type.Tuple([Type.Number(), Type.Number()])
+    const R = Value.Convert(T, ['1'])
+    Assert.deepEqual(R, [1])
+  })
+  it('Should convert from Array 3', () => {
+    const T = Type.Tuple([Type.Number(), Type.Number()])
+    const R = Value.Convert(T, ['1', '2', '3'])
+    Assert.deepEqual(R, [1, 2, '3'])
+  })
+})
diff --git a/test/runtime/value/convert/uint8array.ts b/test/runtime/value/convert/uint8array.ts
new file mode 100644
index 000000000..bd6ac1fb0
--- /dev/null
+++ b/test/runtime/value/convert/uint8array.ts
@@ -0,0 +1,9 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Uint8Array', () => {
+  it('Should convert from Array', () => {
+    const T = Type.Uint8Array()
+  })
+})
diff --git a/test/runtime/value/convert/undefined.ts b/test/runtime/value/convert/undefined.ts
new file mode 100644
index 000000000..130f4177e
--- /dev/null
+++ b/test/runtime/value/convert/undefined.ts
@@ -0,0 +1,15 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Undefined', () => {
+  const T = Type.Undefined()
+  it('Should convert from string 1', () => {
+    const R = Value.Convert(T, 'undefined')
+    Assert.deepEqual(R, undefined)
+  })
+  it('Should convert from string 2', () => {
+    const R = Value.Convert(T, 'hello')
+    Assert.deepEqual(R, 'hello')
+  })
+})
diff --git a/test/runtime/value/convert/union.ts b/test/runtime/value/convert/union.ts
new file mode 100644
index 000000000..5b1f2f3a5
--- /dev/null
+++ b/test/runtime/value/convert/union.ts
@@ -0,0 +1,7 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Union', () => {
+  it('Should convert', () => {})
+})
diff --git a/test/runtime/value/convert/unknown.ts b/test/runtime/value/convert/unknown.ts
new file mode 100644
index 000000000..0b8cea1f9
--- /dev/null
+++ b/test/runtime/value/convert/unknown.ts
@@ -0,0 +1,42 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Unknown', () => {
+  const T = Type.Unknown()
+  it('Should convert null', () => {
+    const V = null
+    const R = Value.Convert(T, V)
+    Assert.deepEqual(R, V)
+  })
+  it('Should convert undefined', () => {
+    const V = undefined
+    const R = Value.Convert(T, V)
+    Assert.deepEqual(R, V)
+  })
+  it('Should convert string', () => {
+    const V = 'hello'
+    const R = Value.Convert(T, V)
+    Assert.deepEqual(R, V)
+  })
+  it('Should convert number', () => {
+    const V = 42
+    const R = Value.Convert(T, V)
+    Assert.deepEqual(R, V)
+  })
+  it('Should convert boolean', () => {
+    const V = true
+    const R = Value.Convert(T, V)
+    Assert.deepEqual(R, V)
+  })
+  it('Should convert object', () => {
+    const V = { x: 1 }
+    const R = Value.Convert(T, V)
+    Assert.deepEqual(R, V)
+  })
+  it('Should convert array', () => {
+    const V = [1, 2, 3]
+    const R = Value.Convert(T, V)
+    Assert.deepEqual(R, V)
+  })
+})
diff --git a/test/runtime/value/convert/void.ts b/test/runtime/value/convert/void.ts
new file mode 100644
index 000000000..a977b79d5
--- /dev/null
+++ b/test/runtime/value/convert/void.ts
@@ -0,0 +1,7 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Void', () => {
+  it('Should convert', () => {})
+})
diff --git a/test/runtime/value/create/bigint.ts b/test/runtime/value/create/bigint.ts
new file mode 100644
index 000000000..616058107
--- /dev/null
+++ b/test/runtime/value/create/bigint.ts
@@ -0,0 +1,14 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/BigInt', () => {
+  it('Should create value', () => {
+    const T = Type.BigInt()
+    Assert.deepEqual(Value.Create(T), BigInt(0))
+  })
+  it('Should create default', () => {
+    const T = Type.BigInt({ default: true })
+    Assert.deepEqual(Value.Create(T), true)
+  })
+})
diff --git a/test/runtime/value/create/boolean.ts b/test/runtime/value/create/boolean.ts
index 824641724..9315f20b6 100644
--- a/test/runtime/value/create/boolean.ts
+++ b/test/runtime/value/create/boolean.ts
@@ -8,7 +8,7 @@ describe('value/create/Boolean', () => {
     Assert.deepEqual(Value.Create(T), false)
   })
   it('Should create default', () => {
-    const T = Type.Any({ default: true })
+    const T = Type.Boolean({ default: true })
     Assert.deepEqual(Value.Create(T), true)
   })
 })
diff --git a/test/runtime/value/create/composite.ts b/test/runtime/value/create/composite.ts
new file mode 100644
index 000000000..96995304a
--- /dev/null
+++ b/test/runtime/value/create/composite.ts
@@ -0,0 +1,66 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Composite', () => {
+  it('Should create value', () => {
+    const A = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    const B = Type.Object({
+      a: Type.Number(),
+      b: Type.Number(),
+      c: Type.Number(),
+    })
+    const T = Type.Composite([A, B])
+    Assert.deepEqual(Value.Create(T), {
+      x: 0,
+      y: 0,
+      z: 0,
+      a: 0,
+      b: 0,
+      c: 0,
+    })
+  })
+  it('Should create default', () => {
+    const A = Type.Object({
+      x: Type.Number({ default: 1 }),
+      y: Type.Number({ default: 2 }),
+      z: Type.Number({ default: 3 }),
+    })
+    const B = Type.Object({
+      a: Type.Number({ default: 4 }),
+      b: Type.Number({ default: 5 }),
+      c: Type.Number({ default: 6 }),
+    })
+    const T = Type.Composite([A, B])
+    Assert.deepEqual(Value.Create(T), {
+      x: 1,
+      y: 2,
+      z: 3,
+      a: 4,
+      b: 5,
+      c: 6,
+    })
+  })
+  it('Should create default and omit optionals', () => {
+    const A = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    const B = Type.Object({
+      a: Type.Optional(Type.Number()),
+      b: Type.Optional(Type.Number()),
+      c: Type.Optional(Type.Number()),
+    })
+    const T = Type.Composite([A, B])
+    Assert.deepEqual(Value.Create(T), {
+      x: 0,
+      y: 0,
+      z: 0,
+    })
+  })
+})
diff --git a/test/runtime/value/create/custom.ts b/test/runtime/value/create/custom.ts
index 90ca03152..1a3ca5424 100644
--- a/test/runtime/value/create/custom.ts
+++ b/test/runtime/value/create/custom.ts
@@ -1,17 +1,16 @@
 import { Value } from '@sinclair/typebox/value'
-import { Type, Kind } from '@sinclair/typebox'
-import { Custom } from '@sinclair/typebox/custom'
+import { Type, Kind, TypeRegistry } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/create/Custom', () => {
   it('Should create custom value with default', () => {
-    Custom.Set('CustomCreate1', () => true)
+    TypeRegistry.Set('CustomCreate1', () => true)
     const T = Type.Unsafe({ [Kind]: 'CustomCreate1', default: 'hello' })
     Assert.deepEqual(Value.Create(T), 'hello')
   })
 
   it('Should throw when no default value is specified', () => {
-    Custom.Set('CustomCreate2', () => true)
+    TypeRegistry.Set('CustomCreate2', () => true)
     const T = Type.Unsafe({ [Kind]: 'CustomCreate2' })
     Assert.throws(() => Value.Create(T))
   })
diff --git a/test/runtime/value/create/index.ts b/test/runtime/value/create/index.ts
index 2e06b6f0f..fb947093e 100644
--- a/test/runtime/value/create/index.ts
+++ b/test/runtime/value/create/index.ts
@@ -1,6 +1,8 @@
 import './any'
 import './array'
+import './bigint'
 import './boolean'
+import './composite'
 import './custom'
 import './constructor'
 import './enum'
@@ -10,13 +12,16 @@ import './intersect'
 import './keyof'
 import './literal'
 import './never'
+import './not'
 import './null'
 import './number'
 import './object'
-import './rec'
+import './recursive'
+import './ref'
 import './record'
 import './regex'
 import './string'
+import './symbol'
 import './tuple'
 import './uint8array'
 import './undefined'
diff --git a/test/runtime/value/create/intersect.ts b/test/runtime/value/create/intersect.ts
index efa66c5b1..344ad5b90 100644
--- a/test/runtime/value/create/intersect.ts
+++ b/test/runtime/value/create/intersect.ts
@@ -4,63 +4,37 @@ import { Assert } from '../../assert/index'
 
 describe('value/create/Intersect', () => {
   it('Should create value', () => {
-    const A = Type.Object({
-      x: Type.Number(),
-      y: Type.Number(),
-      z: Type.Number(),
-    })
-    const B = Type.Object({
-      a: Type.Number(),
-      b: Type.Number(),
-      c: Type.Number(),
-    })
-    const T = Type.Intersect([A, B])
-    Assert.deepEqual(Value.Create(T), {
-      x: 0,
-      y: 0,
-      z: 0,
-      a: 0,
-      b: 0,
-      c: 0,
-    })
+    const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
+    const R = Value.Create(T)
+
+    Assert.deepEqual(R, { x: 0, y: 0 })
+  })
+  it('Should create value with default', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.Number({ default: 100 }) }), Type.Object({ y: Type.Number({ default: 200 }) })])
+    const R = Value.Create(T)
+    Assert.deepEqual(R, { x: 100, y: 200 })
+  })
+  it('Should create for overlapping intersection', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.Number(), y: Type.Number() })])
+    const R = Value.Create(T)
+    Assert.deepEqual(R, { x: 0, y: 0 })
+  })
+  it('Should create with last intersected overlapping default', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.Number({ default: 1 }) }), Type.Object({ x: Type.Number({ default: 2 }), y: Type.Number() })])
+    const R = Value.Create(T)
+    Assert.deepEqual(R, { x: 2, y: 0 })
+  })
+  it('Should throw for non-constructable intersection 1', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.String() })])
+    Assert.throws(() => Value.Create(T))
   })
-  it('Should create default', () => {
-    const A = Type.Object({
-      x: Type.Number({ default: 1 }),
-      y: Type.Number({ default: 2 }),
-      z: Type.Number({ default: 3 }),
-    })
-    const B = Type.Object({
-      a: Type.Number({ default: 4 }),
-      b: Type.Number({ default: 5 }),
-      c: Type.Number({ default: 6 }),
-    })
-    const T = Type.Intersect([A, B])
-    Assert.deepEqual(Value.Create(T), {
-      x: 1,
-      y: 2,
-      z: 3,
-      a: 4,
-      b: 5,
-      c: 6,
-    })
+  it('Should throw for non-constructable intersection 2', () => {
+    const T = Type.Intersect([Type.String(), Type.Number()])
+    Assert.throws(() => Value.Create(T))
   })
-  it('Should create default and omit optionals', () => {
-    const A = Type.Object({
-      x: Type.Number(),
-      y: Type.Number(),
-      z: Type.Number(),
-    })
-    const B = Type.Object({
-      a: Type.Optional(Type.Number()),
-      b: Type.Optional(Type.Number()),
-      c: Type.Optional(Type.Number()),
-    })
-    const T = Type.Intersect([A, B])
-    Assert.deepEqual(Value.Create(T), {
-      x: 0,
-      y: 0,
-      z: 0,
-    })
+  it('Should not throw for non-constructable intersection with default', () => {
+    const T = Type.Intersect([Type.String(), Type.Number()], { default: 'hello' })
+    const R = Value.Create(T)
+    Assert.deepEqual(R, 'hello')
   })
 })
diff --git a/test/runtime/value/create/not.ts b/test/runtime/value/create/not.ts
new file mode 100644
index 000000000..132d4eb9e
--- /dev/null
+++ b/test/runtime/value/create/not.ts
@@ -0,0 +1,21 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Not', () => {
+  it('Should create value', () => {
+    const T = Type.Not(Type.String(), Type.Number())
+    const R = Value.Create(T)
+    Assert.equal(R, 0)
+  })
+  it('Should create value with default inner', () => {
+    const T = Type.Not(Type.String(), Type.Number({ default: 100 }))
+    const R = Value.Create(T)
+    Assert.equal(R, 100)
+  })
+  it('Should create value with default outer', () => {
+    const T = Type.Not(Type.String(), Type.Number(), { default: 100 })
+    const R = Value.Create(T)
+    Assert.equal(R, 100)
+  })
+})
diff --git a/test/runtime/value/create/rec.ts b/test/runtime/value/create/recursive.ts
similarity index 100%
rename from test/runtime/value/create/rec.ts
rename to test/runtime/value/create/recursive.ts
diff --git a/test/runtime/value/create/ref.ts b/test/runtime/value/create/ref.ts
new file mode 100644
index 000000000..621236c98
--- /dev/null
+++ b/test/runtime/value/create/ref.ts
@@ -0,0 +1,30 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Ref', () => {
+  it('Should throw if target is undefined', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { $id: 'T', default: 'target' },
+    )
+    const R = Type.Ref(T)
+    Assert.throws(() => Value.Create(R))
+  })
+  it('Should create ref default if ref default is defined', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      },
+      { $id: 'T', default: 'target' },
+    )
+    const R = Type.Ref(T, { default: 'override' })
+    Assert.deepEqual(Value.Create(R), 'override') // terminated at R default value
+  })
+})
diff --git a/test/runtime/value/create/symbol.ts b/test/runtime/value/create/symbol.ts
new file mode 100644
index 000000000..da3ba1c3a
--- /dev/null
+++ b/test/runtime/value/create/symbol.ts
@@ -0,0 +1,15 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Symbol', () => {
+  it('Should create value', () => {
+    const T = Type.Symbol()
+    const V = Value.Create(T)
+    Assert.deepEqual(typeof V, 'symbol')
+  })
+  it('Should create default', () => {
+    const T = Type.Symbol({ default: true })
+    Assert.deepEqual(Value.Create(T), true)
+  })
+})
diff --git a/test/runtime/hash/hash.ts b/test/runtime/value/hash/hash.ts
similarity index 69%
rename from test/runtime/hash/hash.ts
rename to test/runtime/value/hash/hash.ts
index dd508fce4..45b255342 100644
--- a/test/runtime/hash/hash.ts
+++ b/test/runtime/value/hash/hash.ts
@@ -1,21 +1,19 @@
-import { ValueHash } from '@sinclair/typebox/hash'
-import { Assert } from '../assert/index'
+import { ValueHash } from '@sinclair/typebox/value'
+import { Assert } from '../../assert/index'
 
-describe('Hash', () => {
+describe('value/hash/Hash', () => {
   it('Should hash number', () => {
     Assert.equal('bigint', typeof ValueHash.Create(1))
     const A = ValueHash.Create(1)
     const B = ValueHash.Create(2)
     Assert.notEqual(A, B)
   })
-
   it('Should hash string', () => {
     Assert.equal('bigint', typeof ValueHash.Create('hello'))
     const A = ValueHash.Create('hello')
     const B = ValueHash.Create('world')
     Assert.notEqual(A, B)
   })
-
   it('Should hash boolean', () => {
     Assert.equal('bigint', typeof ValueHash.Create(true))
     Assert.equal('bigint', typeof ValueHash.Create(false))
@@ -23,25 +21,18 @@ describe('Hash', () => {
     const B = ValueHash.Create(false)
     Assert.notEqual(A, B)
   })
-
-  it('Should not hash bigint', () => {
-    Assert.throws(() => ValueHash.Create(1n))
-  })
-
   it('Should hash null', () => {
     Assert.equal('bigint', typeof ValueHash.Create(null))
     const A = ValueHash.Create(null)
     const B = ValueHash.Create(undefined)
     Assert.notEqual(A, B)
   })
-
   it('Should hash array', () => {
     Assert.equal('bigint', typeof ValueHash.Create([0, 1, 2, 3]))
     const A = ValueHash.Create([0, 1, 2, 3])
     const B = ValueHash.Create([0, 2, 2, 3])
     Assert.notEqual(A, B)
   })
-
   it('Should hash object 1', () => {
     // prettier-ignore
     Assert.equal('bigint', typeof ValueHash.Create({ x: 1, y: 2 }))
@@ -64,31 +55,57 @@ describe('Hash', () => {
     const B = ValueHash.Create({ x: 1, y: [0, 1, 2] })
     Assert.notEqual(A, B)
   })
-
   it('Should hash object 5', () => {
     const A = ValueHash.Create({ x: 1, y: undefined })
     const B = ValueHash.Create({ x: 2, y: undefined })
     Assert.notEqual(A, B)
   })
-
   it('Should hash Date', () => {
     Assert.equal('bigint', typeof ValueHash.Create(new Date()))
     const A = ValueHash.Create(new Date(1))
     const B = ValueHash.Create(new Date(2))
     Assert.notEqual(A, B)
   })
-
   it('Should hash Uint8Array', () => {
     Assert.equal('bigint', typeof ValueHash.Create(new Uint8Array([0, 1, 2, 3])))
     const A = ValueHash.Create(new Uint8Array([0, 1, 2, 3]))
     const B = ValueHash.Create(new Uint8Array([0, 2, 2, 3]))
     Assert.notEqual(A, B)
   })
-
   it('Should hash undefined', () => {
     Assert.equal('bigint', typeof ValueHash.Create(undefined))
     const A = ValueHash.Create(undefined)
     const B = ValueHash.Create(null)
     Assert.notEqual(A, B)
   })
+  it('Should hash symbol 1', () => {
+    Assert.equal('bigint', typeof ValueHash.Create(Symbol()))
+    const A = ValueHash.Create(Symbol(1))
+    const B = ValueHash.Create(Symbol())
+    Assert.notEqual(A, B)
+  })
+  it('Should hash symbol 2', () => {
+    Assert.equal('bigint', typeof ValueHash.Create(Symbol()))
+    const A = ValueHash.Create(Symbol(1))
+    const B = ValueHash.Create(Symbol(2))
+    Assert.notEqual(A, B)
+  })
+  it('Should hash symbol 2', () => {
+    Assert.equal('bigint', typeof ValueHash.Create(Symbol()))
+    const A = ValueHash.Create(Symbol(1))
+    const B = ValueHash.Create(Symbol(1))
+    Assert.equal(A, B)
+  })
+  it('Should hash bigint 1', () => {
+    Assert.equal('bigint', typeof ValueHash.Create(BigInt(1)))
+    const A = ValueHash.Create(BigInt(1))
+    const B = ValueHash.Create(BigInt(2))
+    Assert.notEqual(A, B)
+  })
+  it('Should hash bigint 2', () => {
+    Assert.equal('bigint', typeof ValueHash.Create(BigInt(1)))
+    const A = ValueHash.Create(BigInt(1))
+    const B = ValueHash.Create(BigInt(1))
+    Assert.equal(A, B)
+  })
 })
diff --git a/test/runtime/hash/index.ts b/test/runtime/value/hash/index.ts
similarity index 100%
rename from test/runtime/hash/index.ts
rename to test/runtime/value/hash/index.ts
diff --git a/test/runtime/value/index.ts b/test/runtime/value/index.ts
index 2ca9e7172..ad07f09f0 100644
--- a/test/runtime/value/index.ts
+++ b/test/runtime/value/index.ts
@@ -1,7 +1,9 @@
 import './cast'
 import './check'
 import './clone'
+import './convert'
 import './create'
 import './delta'
 import './equal'
+import './hash'
 import './pointer'
diff --git a/test/static/assert.ts b/test/static/assert.ts
index b4ffbd33f..4b8763847 100644
--- a/test/static/assert.ts
+++ b/test/static/assert.ts
@@ -1,8 +1,8 @@
 import { Static, TSchema } from '@sinclair/typebox'
 
-export function Expect<T extends TSchema>(schema: T) {
+export function Expect<T extends TSchema, S = Static<T>>(schema: T) {
   return {
-    ToInfer: <U extends Static<T>>() => {},
-    ToBe: <U extends T>() => {},
+    ToInfer: <U extends S>() => {},
+    ToBe: <U extends S>() => {},
   }
 }
diff --git a/test/static/bigint.ts b/test/static/bigint.ts
new file mode 100644
index 000000000..a18b437ba
--- /dev/null
+++ b/test/static/bigint.ts
@@ -0,0 +1,4 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.BigInt()).ToInfer<bigint>()
diff --git a/test/static/composite.ts b/test/static/composite.ts
new file mode 100644
index 000000000..be5596d2d
--- /dev/null
+++ b/test/static/composite.ts
@@ -0,0 +1,19 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+{
+  const A = Type.Object({
+    A: Type.String(),
+    B: Type.String(),
+  })
+  const B = Type.Object({
+    A: Type.Number(),
+    B: Type.Number(),
+  })
+  const T = Type.Composite([A, B])
+
+  Expect(T).ToInfer<{
+    A: string | number
+    B: string | number
+  }>()
+}
diff --git a/test/static/exclude.ts b/test/static/exclude.ts
new file mode 100644
index 000000000..b0a76354c
--- /dev/null
+++ b/test/static/exclude.ts
@@ -0,0 +1,15 @@
+import { Type } from '@sinclair/typebox'
+import { Expect } from './assert'
+
+{
+  const T = Type.Exclude(Type.String(), Type.String())
+  Expect(T).ToBe<never>()
+}
+{
+  const T = Type.Exclude(Type.String(), Type.Number())
+  Expect(T).ToBe<string>()
+}
+{
+  const T = Type.Exclude(Type.Union([Type.Number(), Type.String(), Type.Boolean()]), Type.Number())
+  Expect(T).ToBe<boolean | string>()
+}
diff --git a/test/static/extract.ts b/test/static/extract.ts
new file mode 100644
index 000000000..7cc603709
--- /dev/null
+++ b/test/static/extract.ts
@@ -0,0 +1,15 @@
+import { Type } from '@sinclair/typebox'
+import { Expect } from './assert'
+
+{
+  const T = Type.Extract(Type.String(), Type.String())
+  Expect(T).ToBe<string>()
+}
+{
+  const T = Type.Extract(Type.String(), Type.Number())
+  Expect(T).ToBe<never>()
+}
+{
+  const T = Type.Extract(Type.Union([Type.Number(), Type.String(), Type.Boolean()]), Type.Number())
+  Expect(T).ToBe<number>()
+}
diff --git a/test/static/index.ts b/test/static/index.ts
index cc84ce321..8666ca223 100644
--- a/test/static/index.ts
+++ b/test/static/index.ts
@@ -1,10 +1,14 @@
 import './any'
 import './array'
+import './bigint'
 import './boolean'
+import './composite'
 import './date'
 import './constructor-parameters'
 import './constructor'
 import './emum'
+import './extract'
+import './exclude'
 import './function'
 import './instance-type'
 import './intersect'
@@ -13,6 +17,7 @@ import './literal'
 import './modifier'
 import './namespace'
 import './never'
+import './not'
 import './null'
 import './number'
 import './object'
@@ -31,6 +36,7 @@ import './required'
 import './return-type'
 import './strict'
 import './string'
+import './symbol'
 import './tuple'
 import './union'
 import './unknown'
diff --git a/test/static/intersect.ts b/test/static/intersect.ts
index fcbb1000b..b7cf181b6 100644
--- a/test/static/intersect.ts
+++ b/test/static/intersect.ts
@@ -1,5 +1,5 @@
 import { Expect } from './assert'
-import { Type, TOptional, TString } from '@sinclair/typebox'
+import { Type, TOptional, TString, Static } from '@sinclair/typebox'
 
 {
   const A = Type.Object({
@@ -38,14 +38,17 @@ import { Type, TOptional, TString } from '@sinclair/typebox'
 
 // https://github.com/sinclairzx81/typebox/issues/113
 // https://github.com/sinclairzx81/typebox/issues/187
-// {
-//     const A = Type.Object({ A: Type.String() })
-//     const B = Type.Object({ B: Type.String() })
-//     const C = Type.Object({ C: Type.String() })
-//     const T = Type.Intersect([A, Type.Union([B, C])])
-//     type T = Static<typeof T>
-//     const _0: T = { A: '', B: '' }
-//     const _1: T = { A: '', C: '' }
-//     const _3: T = { A: '', B: '', C: '' }
-//     Expect(T).ToBe<{ A: string } & ({ B: string, } | { C: string })>()
-// }
+{
+  const A = Type.Object({ A: Type.String() })
+  const B = Type.Object({ B: Type.String() })
+  const C = Type.Object({ C: Type.String() })
+  const T = Type.Intersect([A, Type.Union([B, C])])
+  type T = Static<typeof T>
+  const _0: T = { A: '', B: '' }
+  const _1: T = { A: '', C: '' }
+  const _3: T = { A: '', B: '', C: '' }
+  // invert equivelence (expect true both cases)
+  type T1 = T extends { A: string } & ({ B: string } | { C: string }) ? true : false
+  type T2 = { A: string } & ({ B: string } | { C: string }) extends T ? true : false
+  Expect(T).ToBe<{ A: string } & ({ B: string } | { C: string })>() // solved!
+}
diff --git a/test/static/keyof.ts b/test/static/keyof.ts
index 62d626057..ff353b7fa 100644
--- a/test/static/keyof.ts
+++ b/test/static/keyof.ts
@@ -55,3 +55,27 @@ import { Type } from '@sinclair/typebox'
   )
   Expect(T).ToInfer<'C'>()
 }
+{
+  {
+    const A = Type.Object({ type: Type.Literal('A') })
+    const B = Type.Object({ type: Type.Literal('B') })
+    const C = Type.Object({ type: Type.Literal('C') })
+    const Union = Type.Union([A, B, C])
+    const Extended = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    const T = Type.Intersect([Union, Extended])
+
+    const K1 = Type.KeyOf(T)
+
+    Expect(K1).ToInfer<'type' | 'x' | 'y' | 'z'>()
+
+    const P = Type.Omit(T, ['type', 'x'])
+
+    const K2 = Type.KeyOf(P)
+
+    Expect(K2).ToInfer<'y' | 'z'>()
+  }
+}
diff --git a/test/static/not.ts b/test/static/not.ts
new file mode 100644
index 000000000..ea157157a
--- /dev/null
+++ b/test/static/not.ts
@@ -0,0 +1,7 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+{
+  const T = Type.Not(Type.Number(), Type.String())
+  Expect(T).ToInfer<string>()
+}
diff --git a/test/static/omit.ts b/test/static/omit.ts
index c3f726889..98b93ba57 100644
--- a/test/static/omit.ts
+++ b/test/static/omit.ts
@@ -54,3 +54,51 @@ import { Type, Static } from '@sinclair/typebox'
     C: string
   }>()
 }
+{
+  const A = Type.Object({ type: Type.Literal('A') })
+  const B = Type.Object({ type: Type.Literal('B') })
+  const C = Type.Object({ type: Type.Literal('C') })
+  const Union = Type.Union([A, B, C])
+  const Extended = Type.Object({
+    x: Type.Number(),
+    y: Type.Number(),
+    z: Type.Number(),
+  })
+  const T = Type.Intersect([Union, Extended])
+
+  Expect(T).ToInfer<
+    (
+      | {
+          type: 'A'
+        }
+      | {
+          type: 'B'
+        }
+      | {
+          type: 'C'
+        }
+    ) & {
+      x: number
+      y: number
+      z: number
+    }
+  >()
+
+  const P = Type.Omit(T, ['type', 'x'])
+
+  Expect(P).ToInfer<
+    ({} | {} | {}) & {
+      y: number
+      z: number
+    }
+  >()
+
+  const O = Type.Partial(P)
+
+  Expect(O).ToInfer<
+    ({} | {} | {}) & {
+      y?: number | undefined
+      z?: number | undefined
+    }
+  >()
+}
diff --git a/test/static/partial.ts b/test/static/partial.ts
index 348c64613..a9e591f94 100644
--- a/test/static/partial.ts
+++ b/test/static/partial.ts
@@ -17,3 +17,56 @@ import { Type, Static } from '@sinclair/typebox'
     C?: string
   }>()
 }
+{
+  {
+    const A = Type.Object({ type: Type.Literal('A') })
+    const B = Type.Object({ type: Type.Literal('B') })
+    const C = Type.Object({ type: Type.Literal('C') })
+    const Union = Type.Union([A, B, C])
+    const Extended = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+
+    const T = Type.Intersect([Union, Extended])
+
+    Expect(T).ToInfer<
+      (
+        | {
+            type: 'A'
+          }
+        | {
+            type: 'B'
+          }
+        | {
+            type: 'C'
+          }
+      ) & {
+        x: number
+        y: number
+        z: number
+      }
+    >()
+
+    const P = Type.Partial(T)
+
+    Expect(P).ToInfer<
+      (
+        | {
+            type?: 'A' | undefined
+          }
+        | {
+            type?: 'B' | undefined
+          }
+        | {
+            type?: 'C' | undefined
+          }
+      ) & {
+        x?: number | undefined
+        y?: number | undefined
+        z?: number | undefined
+      }
+    >()
+  }
+}
diff --git a/test/static/pick.ts b/test/static/pick.ts
index 0ae10cd93..f9d825571 100644
--- a/test/static/pick.ts
+++ b/test/static/pick.ts
@@ -57,3 +57,73 @@ import { Type, Static } from '@sinclair/typebox'
     B: string
   }>()
 }
+{
+  const A = Type.Object({ type: Type.Literal('A') })
+  const B = Type.Object({ type: Type.Literal('B') })
+  const C = Type.Object({ type: Type.Literal('C') })
+  const Union = Type.Union([A, B, C])
+  const Extended = Type.Object({
+    x: Type.Number(),
+    y: Type.Number(),
+    z: Type.Number(),
+  })
+  const T = Type.Intersect([Union, Extended])
+
+  Expect(T).ToInfer<
+    (
+      | {
+          type: 'A'
+        }
+      | {
+          type: 'B'
+        }
+      | {
+          type: 'C'
+        }
+    ) & {
+      x: number
+      y: number
+      z: number
+    }
+  >()
+
+  const K = Type.KeyOf(T)
+
+  Expect(K).ToInfer<'type' | 'x' | 'y' | 'z'>()
+
+  const P = Type.Pick(T, ['type', 'x'])
+
+  Expect(P).ToInfer<
+    (
+      | {
+          type: 'A'
+        }
+      | {
+          type: 'B'
+        }
+      | {
+          type: 'C'
+        }
+    ) & {
+      x: number
+    }
+  >()
+
+  const O = Type.Partial(P)
+
+  Expect(O).ToInfer<
+    (
+      | {
+          type?: 'A' | undefined
+        }
+      | {
+          type?: 'B' | undefined
+        }
+      | {
+          type?: 'C' | undefined
+        }
+    ) & {
+      x?: number | undefined
+    }
+  >()
+}
diff --git a/test/static/required.ts b/test/static/required.ts
index c3b0ca726..30aa9ca1d 100644
--- a/test/static/required.ts
+++ b/test/static/required.ts
@@ -20,3 +20,57 @@ Expect(Type.RegEx(/foo/)).ToInfer<string>()
     C: string
   }>()
 }
+{
+  {
+    const A = Type.Object({ type: Type.Literal('A') })
+    const B = Type.Object({ type: Type.Literal('B') })
+    const C = Type.Object({ type: Type.Literal('C') })
+    const Union = Type.Union([A, B, C])
+    const Extended = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    const T = Type.Intersect([Union, Extended])
+
+    const P = Type.Partial(T)
+
+    Expect(P).ToInfer<
+      (
+        | {
+            type?: 'A' | undefined
+          }
+        | {
+            type?: 'B' | undefined
+          }
+        | {
+            type?: 'C' | undefined
+          }
+      ) & {
+        x?: number | undefined
+        y?: number | undefined
+        z?: number | undefined
+      }
+    >()
+
+    const R = Type.Required(P)
+
+    Expect(R).ToInfer<
+      (
+        | {
+            type: 'A'
+          }
+        | {
+            type: 'B'
+          }
+        | {
+            type: 'C'
+          }
+      ) & {
+        x: number
+        y: number
+        z: number
+      }
+    >()
+  }
+}
diff --git a/test/static/symbol.ts b/test/static/symbol.ts
new file mode 100644
index 000000000..633541438
--- /dev/null
+++ b/test/static/symbol.ts
@@ -0,0 +1,4 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.Symbol()).ToInfer<symbol>()
diff --git a/tsconfig.json b/tsconfig.json
index d660b0d6d..47541b26d 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -13,20 +13,8 @@
       "@sinclair/typebox/compiler": [
         "src/compiler/index.ts"
       ],
-      "@sinclair/typebox/conditional": [
-        "src/conditional/index.ts"
-      ],
-      "@sinclair/typebox/custom": [
-        "src/custom/index.ts"
-      ],
-      "@sinclair/typebox/format": [
-        "src/format/index.ts"
-      ],
-      "@sinclair/typebox/guard": [
-        "src/guard/index.ts"
-      ],
-      "@sinclair/typebox/hash": [
-        "src/hash/index.ts"
+      "@sinclair/typebox/errors": [
+        "src/errors/index.ts"
       ],
       "@sinclair/typebox/system": [
         "src/system/index.ts"
diff --git a/typebox.png b/typebox.png
index 0df53e5c5f5f2e423565e564ab3a01aa6a845c3e..ed053e1f3df23df4eca1b25d94b0df721437a1e9 100644
GIT binary patch
literal 946728
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%0Ahz4OCA5{ySR@m#xkrQaLe
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%0D_qOlSO~8l$4<98g-Mltb*5H+5
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%0D6${Pcq+tJHh?RYA#{UyuGWFqa
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
N002ovPDHLkV1hI>{(S%d

literal 706199
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%0A?DVB*DsVJi&ocpa!u>6&!4&M
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


From 138f222ced27fbe56fcf181cd9aec4805f11f67a Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 22 Mar 2023 02:29:28 +0900
Subject: [PATCH 071/369] Revision 0.26.0

---
 src/typebox.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/typebox.ts b/src/typebox.ts
index 6c8796938..bff6d38ab 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -1882,7 +1882,7 @@ export class StandardTypeBuilder extends TypeBuilder {
       return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Clone(left, options)) as any
     }
   }
-  /** `[Standard]` Extracts from left left any type that is assignable to the right */
+  /** `[Standard]` Extracts from the left type any type that is assignable to the right */
   public Extract<L extends TSchema, R extends TSchema>(left: L, right: R, options: SchemaOptions = {}): TExtract<L, R> {
     if (TypeGuard.TUnion(left)) {
       const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) !== TypeExtendsResult.False)

From 4379e312a499832408081333804112e503d36936 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Thu, 23 Mar 2023 00:16:24 +0900
Subject: [PATCH 072/369] Revision 0.26.0

---
 src/typebox.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/typebox.ts b/src/typebox.ts
index bff6d38ab..92e57a117 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -1733,7 +1733,7 @@ export namespace TypeClone {
     if (IsObject(value)) return Object(value)
     return value
   }
-  /** Clones a type. This function will omit non-self referential identifiers on the cloned type. */
+  /** Clones a type. */
   export function Clone<T extends TSchema>(schema: T, options: SchemaOptions): T {
     return { ...Visit(schema), ...options }
   }

From 5df81a9c8a2361329612d29b3a349f9eb27f3914 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Thu, 23 Mar 2023 00:21:08 +0900
Subject: [PATCH 073/369] Revision 0.26.0

---
 example/trpc/readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/example/trpc/readme.md b/example/trpc/readme.md
index e321ae253..5a2b36158 100644
--- a/example/trpc/readme.md
+++ b/example/trpc/readme.md
@@ -81,7 +81,7 @@ import { TRPCError } from '@trpc/server'
 export function RpcType<T extends TSchema>(schema: T) {
   return (value: unknown) => {
     if (Value.Check(schema, value)) return value
-    const { path, message } = check.Errors(value).First()!
+    const { path, message } = Value.Errors(schema, value).First()!
     throw new TRPCError({ message: `${message} for ${path}`, code: 'BAD_REQUEST' })
   }
 }

From 528903882f266836bbb427fa487980a837524e6f Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 23 Mar 2023 04:05:18 +0900
Subject: [PATCH 074/369] Remove Unused Object Array Check (#348)

---
 package.json             | 2 +-
 src/compiler/compiler.ts | 1 -
 src/value/check.ts       | 4 ++--
 3 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/package.json b/package.json
index 8043b31b7..079fe206a 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index f773b012c..30a15e5f0 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -253,7 +253,6 @@ export namespace TypeCompiler {
 
   function* Object(schema: Types.TObject, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield IsObjectCheck(value)
-    if (!TypeSystem.AllowArrayObjects) yield `!Array.isArray(${value})`
     if (IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
     if (IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
     const schemaKeys = globalThis.Object.getOwnPropertyNames(schema.properties)
diff --git a/src/value/check.ts b/src/value/check.ts
index 15c06bbe8..59db8e22d 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -220,10 +220,10 @@ export namespace ValueCheck {
     if (!IsObject(value)) {
       return false
     }
-    if (IsNumber(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+    if (IsDefined<number>(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
       return false
     }
-    if (IsNumber(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+    if (IsDefined<number>(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
       return false
     }
     const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties)

From 1cbb5c60cc9fbdd601b35a3873a2c43cd8338b29 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 23 Mar 2023 17:14:45 +0900
Subject: [PATCH 075/369] Composite Evaluate (#349)

---
 changelog/0.26.2.md                  | 38 +++++++++++++++
 package.json                         |  2 +-
 readme.md                            | 25 +++++-----
 src/typebox.ts                       | 73 +++++++++++++++++++---------
 test/runtime/compiler/composite.ts   | 41 ++++++++++------
 test/runtime/schema/composite.ts     | 42 ++++++++--------
 test/runtime/type/guard/composite.ts | 27 ++++++++++
 test/runtime/type/guard/index.ts     |  1 +
 test/static/composite.ts             | 63 ++++++++++++++++++++++--
 9 files changed, 233 insertions(+), 79 deletions(-)
 create mode 100644 changelog/0.26.2.md
 create mode 100644 test/runtime/type/guard/composite.ts

diff --git a/changelog/0.26.2.md b/changelog/0.26.2.md
new file mode 100644
index 000000000..4e046809f
--- /dev/null
+++ b/changelog/0.26.2.md
@@ -0,0 +1,38 @@
+## [0.26.2](https://www.npmjs.com/package/@sinclair/typebox/v/0.26.2)
+
+Updates:
+
+- [331](https://github.com/sinclairzx81/typebox/pull/349) Revert 0.25.0 Intersect logic for Composite
+
+Notes:
+
+This PR reverts the logic on Type.Composite back to 0.25.0 Type.Intersect due to excessive type instantiation issues. On 0.26.0, Type.Composite attempted to take a union for overlapping properties, however due to the sophistication required to type map the unions for overlapping properties, this has resulted in type instantiation problems for some users upgrading to 0.26.0.
+
+As such, 0.26.2 reverts back to the 0.25.0 interpretation, but applies type mappings more inline with TS's interpretation of an overlapping varying property types. In the examples below, the type `C` is the evaluated type for Type.Composite. Note that TS will not union for overlapping properties and instead evaluate `never`. The 0.26.2 implementation falls inline with this evaluation.
+
+```typescript
+{ // evaluation case 1: non-varying
+  type T = { a: number } & { a: number }
+
+  type C = {[K in keyof T]: T[K] }  // type C = { a: number }
+}
+
+{ // evaluation case 2: varying
+  type T = { a: number } & { a: string }
+
+  type C = {[K in keyof T]: T[K] }  // type C = { a: never }
+}
+
+{ // evaluation case 3: single optional
+  type T = { a?: number } & { a: number }
+
+  type C = {[K in keyof T]: T[K] }  // type C = { a: number }
+}
+
+{ // evaluation case 4: all optional
+  type T = { a?: number } & { a?: number }
+
+  type C = {[K in keyof T]: T[K] }  // type C = { a: number | undefined }
+}
+```
+Note: the Type.Composite is intended to be a temporary type which can be replaced with a more general `Type.Mapped` in future revisions of TypeBox. As the infrastructure to support mapped types does not exist, users can use Type.Composite to partially replicate mapped type evaluation for composited object types only.
\ No newline at end of file
diff --git a/package.json b/package.json
index 079fe206a..9160c0b84 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.26.1",
+  "version": "0.26.2",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 2d199c156..b26946d92 100644
--- a/readme.md
+++ b/readme.md
@@ -229,13 +229,13 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Null()          │ type T = null               │ const T = {                    │
-│                                │                             │    type: 'null'                │
+│                                │                             │   type: 'null'                 │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Literal(42)     │ type T = 42                 │ const T = {                    │
-│                                │                             │    const: 42,                  │
-│                                │                             │    type: 'number'              │
+│                                │                             │   const: 42,                   │
+│                                │                             │   type: 'number'               │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -326,19 +326,16 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Composite([     │ type T = {                  │ const T = {                    │
-│   Type.Object({                │   x: number | string        │   type: 'object',              │
-│     x: Type.Number()           │   y: number                 │   properties: {                │
-│   }),                          │ }                           │     x: {                       │
-│   Type.Object({                │                             │       anyOf: [                 │
-│     x: Type.String()           │                             │         { type: 'number' },    │
-│     y: Type.Number()           │                             │         { type: 'string' }     │
-│   })                           │                             │       ]                        │
-│ ])                             │                             │     },                         │
-│                                │                             │     y: {                       │
+│   Type.Object({                │   x: number                 │   type: 'object',              │
+│     x: Type.Number()           │   y: number                 │   required: ['x', 'y'],        │
+│   }),                          │ }                           │   properties: {                │
+│   Type.Object({                │                             │     x: {                       │
+│     y: Type.Number()           │                             │       type: 'number'           │
+│   })                           │                             │     },                         │
+│ ])                             │                             │     y: {                       │
 │                                │                             │       type: 'number'           │
 │                                │                             │     }                          │
-│                                │                             │   },                           │
-│                                │                             │   required: ['x', 'y']         │
+│                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
diff --git a/src/typebox.ts b/src/typebox.ts
index 92e57a117..de0334021 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -168,21 +168,14 @@ export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['retur
 // --------------------------------------------------------------------------
 // TComposite
 // --------------------------------------------------------------------------
-export type TCompositeUnion<Left extends TSchema, Right extends TSchema> = Ensure<TUnion<[Left, Right]>>
-// note: we need to take the left and right as the accumulator is assigned for multiple composite property sets with missing properties.
-export type TCompositeUnionLeft<T extends TObject, Acc extends TProperties> = {
-  [K in keyof T['properties']]: K extends keyof Acc ? TCompositeUnion<T['properties'][K], Acc[K]> : T['properties'][K]
+export type TCompositeEvaluateArray<T extends readonly TSchema[], P extends unknown[]> = { [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never }
+export type TCompositeArray<T extends readonly TObject[]> = { [K in keyof T]: T[K] extends TObject<infer P> ? P : {} }
+export type TCompositeProperties<I extends unknown, T extends readonly any[]> = Evaluate<T extends [infer A, ...infer B] ? TCompositeProperties<I & A, B> : I extends object ? I : {}>
+export interface TComposite<T extends TObject[] = TObject[]> extends TObject {
+  [Hint]: 'Composite' // Hint is required to differentiate between object | intersection on pick, omit, required, partial and keyof
+  static: Evaluate<TCompositeProperties<unknown, TCompositeEvaluateArray<T, this['params']>>>
+  properties: TCompositeProperties<unknown, TCompositeArray<T>>
 }
-export type TCompositeUnionRight<T extends TObject, Acc extends TProperties> = {
-  [K in keyof Acc]: K extends keyof T['properties'] ? TCompositeUnion<T['properties'][K], Acc[K]> : Acc[K]
-}
-export type TCompositeUnionObject<T extends TObject, Acc extends TProperties> = Evaluate<TCompositeUnionLeft<T, Acc> & TCompositeUnionRight<T, Acc>>
-// prettier-ignore
-export type TCompositeProperties<T extends TObject[], Acc extends TProperties> = 
-  T extends [...infer L, infer R] ? TCompositeProperties<Assert<L, TObject[]>, TCompositeUnionObject<Assert<R, TObject>, Acc>> :
-  T extends [] ? Acc :
-  never
-export type TComposite<T extends TObject[] = TObject[]> = Ensure<TObject<TCompositeProperties<T, {}>>>
 // --------------------------------------------------------------------------
 // TConstructor
 // --------------------------------------------------------------------------
@@ -275,6 +268,7 @@ export interface IntersectOptions extends SchemaOptions {
   unevaluatedProperties?: TUnevaluatedProperties
 }
 export type TIntersectStatic<T extends TSchema[], P extends unknown[]> = TupleToIntersect<{ [K in keyof T]: Static<Assert<T[K], TSchema>, P> }>
+
 export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
   [Kind]: 'Intersect'
   type?: 'object'
@@ -292,6 +286,7 @@ export type TKeyOfTuple<T extends TSchema> = {
   : never
 // prettier-ignore
 export type TKeyOf<T extends TSchema = TSchema> = (
+  T extends TComposite ? TKeyOfTuple<T> :
   T extends TIntersect ? TKeyOfTuple<T> :
   T extends TUnion     ? TKeyOfTuple<T> :
   T extends TObject    ? TKeyOfTuple<T> :
@@ -312,7 +307,7 @@ export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSche
 export interface TNever extends TSchema {
   [Kind]: 'Never'
   static: never
-  allOf: [{ type: 'boolean'; const: false }, { type: 'boolean'; const: true }]
+  not: {}
 }
 // --------------------------------------------------------------------------
 // TNot
@@ -381,6 +376,7 @@ export type TOmitArray<T extends TSchema[], K extends keyof any> = Assert<{ [K2
 export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<Assert<Omit<T, K>, TProperties>>
 // prettier-ignore
 export type TOmit<T extends TSchema, K extends keyof any> = 
+  T extends TComposite<infer S> ? TComposite<TOmitArray<S, K>> :
   T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : 
   T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : 
   T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : 
@@ -392,6 +388,7 @@ export type TParameters<T extends TFunction> = TTuple<T['parameters']>
 // --------------------------------------------------------------------------
 // TPartial
 // --------------------------------------------------------------------------
+export type TPartialObjectArray<T extends TObject[]> = Assert<{ [K in keyof T]: TPartial<Assert<T[K], TObject>> }, TObject[]>
 export type TPartialArray<T extends TSchema[]> = Assert<{ [K in keyof T]: TPartial<Assert<T[K], TSchema>> }, TSchema[]>
 // prettier-ignore
 export type TPartialProperties<T extends TProperties> = Evaluate<Assert<{
@@ -402,7 +399,8 @@ export type TPartialProperties<T extends TProperties> = Evaluate<Assert<{
     TOptional<T[K]>
 }, TProperties>>
 // prettier-ignore
-export type TPartial<T extends TSchema> = 
+export type TPartial<T extends TSchema> =  
+  T extends TComposite<infer S> ? TComposite<TPartialArray<S>> :
   T extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : 
   T extends TUnion<infer S>     ? TUnion<TPartialArray<S>> : 
   T extends TObject<infer S>    ? TObject<TPartialProperties<S>> : 
@@ -420,11 +418,11 @@ export type TPickProperties<T extends TProperties, K extends keyof any> =
   }): never
 // prettier-ignore
 export type TPick<T extends TSchema, K extends keyof any> = 
+  T extends TComposite<infer S> ? TComposite<TPickArray<S, K>> :
   T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : 
   T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : 
   T extends TObject<infer S> ? TObject<TPickProperties<S, K>> :
   T
-
 // --------------------------------------------------------------------------
 // TPromise
 // --------------------------------------------------------------------------
@@ -489,6 +487,7 @@ export type TRequiredProperties<T extends TProperties> = Evaluate<Assert<{
 }, TProperties>>
 // prettier-ignore
 export type TRequired<T extends TSchema> = 
+  T extends TComposite<infer S> ? TComposite<TRequiredArray<S>> : 
   T extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : 
   T extends TUnion<infer S>     ? TUnion<TRequiredArray<S>> : 
   T extends TObject<infer S>    ? TObject<TRequiredProperties<S>> : 
@@ -1845,15 +1844,41 @@ export class StandardTypeBuilder extends TypeBuilder {
   public Boolean(options: SchemaOptions = {}): TBoolean {
     return this.Create({ ...options, [Kind]: 'Boolean', type: 'boolean' })
   }
-  /** `[Standard]` Creates a Composite object type that will union any overlapping properties of the given object array */
-  public Composite<T extends TObject[]>(schemas: [...T], options?: ObjectOptions): TComposite<T> {
-    const properties = {} as TProperties
-    for (const object of schemas) {
-      for (const [key, property] of globalThis.Object.entries(object.properties)) {
-        properties[key] = key in properties ? this.Union([properties[key], property]) : TypeClone.Clone(property, {})
+  /** `[Standard]` Creates a Composite object type. */
+  public Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T> {
+    const isOptionalAll = (objects: TObject[], key: string) => objects.every((object) => !(key in object.properties) || IsOptional(object.properties[key]))
+    const IsOptional = (schema: TSchema) => TypeGuard.TOptional(schema) || TypeGuard.TReadonlyOptional(schema)
+    const [required, optional] = [new Set<string>(), new Set<string>()]
+    for (const object of objects) {
+      for (const key of globalThis.Object.getOwnPropertyNames(object.properties)) {
+        if (isOptionalAll(objects, key)) optional.add(key)
+      }
+    }
+    for (const object of objects) {
+      for (const key of globalThis.Object.getOwnPropertyNames(object.properties)) {
+        if (!optional.has(key)) required.add(key)
       }
     }
-    return this.Object(properties, options) as TComposite<T>
+    const properties = {} as Record<keyof any, any>
+    for (const object of objects) {
+      for (const [key, schema] of Object.entries(object.properties)) {
+        const property = TypeClone.Clone(schema, {})
+        if (!optional.has(key)) delete property[Modifier]
+        if (key in properties) {
+          const left = TypeExtends.Extends(properties[key], property) !== TypeExtendsResult.False
+          const right = TypeExtends.Extends(property, properties[key]) !== TypeExtendsResult.False
+          if (!left && !right) properties[key] = Type.Never()
+          if (!left && right) properties[key] = property
+        } else {
+          properties[key] = property
+        }
+      }
+    }
+    if (required.size > 0) {
+      return this.Create({ ...options, [Kind]: 'Object', [Hint]: 'Composite', type: 'object', properties, required: [...required] })
+    } else {
+      return this.Create({ ...options, [Kind]: 'Object', [Hint]: 'Composite', type: 'object', properties })
+    }
   }
   /** `[Standard]` Creates a Enum type */
   public Enum<T extends Record<string, string | number>>(item: T, options: SchemaOptions = {}): TEnum<T> {
diff --git a/test/runtime/compiler/composite.ts b/test/runtime/compiler/composite.ts
index 5635e45fa..48466589d 100644
--- a/test/runtime/compiler/composite.ts
+++ b/test/runtime/compiler/composite.ts
@@ -1,4 +1,4 @@
-import { Type, Static } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
 describe('type/compiler/Composite', () => {
@@ -13,33 +13,45 @@ describe('type/compiler/Composite', () => {
     const B = Type.Partial(Type.Object({ b: Type.Number() }))
     const P = Type.Composite([A, B], { additionalProperties: false })
     Ok(P, { a: 1, b: 2 })
+    Ok(P, { a: 1 })
+    Ok(P, { b: 1 })
+    Ok(P, {})
+    Fail(P, { a: 1, b: 2, c: 3 })
+    Fail(P, { c: 1 })
   })
   it('Should compose with overlapping same type', () => {
     const A = Type.Object({ a: Type.Number() })
     const B = Type.Object({ a: Type.Number() })
     const P = Type.Composite([A, B])
     Ok(P, { a: 1 })
-    Fail(P, { a: 'hello' })
-    Fail(P, {})
+    Fail(P, { a: '1' })
   })
-  it('Should compose with overlapping varying type', () => {
+  it('Should not compose with overlapping varying type', () => {
     const A = Type.Object({ a: Type.Number() })
     const B = Type.Object({ a: Type.String() })
     const T = Type.Composite([A, B])
-    Ok(T, { a: 1 })
-    Ok(T, { a: 'hello' })
+    Fail(T, { a: 1 })
+    Fail(T, { a: 'hello' })
     Fail(T, {})
   })
   it('Should compose with deeply nest overlapping varying type', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ b: Type.String() })
+    const C = Type.Object({ c: Type.Boolean() })
+    const D = Type.Object({ d: Type.Null() })
+    const T = Type.Composite([A, B, C, D])
+    Ok(T, { a: 1, b: 'hello', c: true, d: null })
+  })
+  it('Should not compose with deeply nest overlapping varying type', () => {
     const A = Type.Object({ a: Type.Number() })
     const B = Type.Object({ a: Type.String() })
     const C = Type.Object({ a: Type.Boolean() })
     const D = Type.Object({ a: Type.Null() })
     const T = Type.Composite([A, B, C, D])
-    Ok(T, { a: 1 })
-    Ok(T, { a: 'hello' })
-    Ok(T, { a: false })
-    Ok(T, { a: null })
+    Fail(T, { a: 1 })
+    Fail(T, { a: 'hello' })
+    Fail(T, { a: false })
+    Fail(T, { a: null })
     Fail(T, { a: [] })
     Fail(T, {})
   })
@@ -61,13 +73,12 @@ describe('type/compiler/Composite', () => {
     Ok(P, { x: 1, y: 1 })
     Fail(P, { x: 1, y: 1, z: 1 })
   })
-
   it('Should compose nested object properties', () => {
     const A = Type.Object({ x: Type.Object({ x: Type.Number() }) })
-    const B = Type.Object({ x: Type.Object({ x: Type.String() }) })
+    const B = Type.Object({ y: Type.Object({ x: Type.String() }) })
     const T = Type.Composite([A, B])
-    Ok(T, { x: { x: 1 } })
-    Ok(T, { x: { x: 'hello' } })
-    Fail(T, { x: { x: false } })
+    Ok(T, { x: { x: 1 }, y: { x: '' } })
+    Fail(T, { x: { x: '1' }, y: { x: '' } })
+    Fail(T, { x: { x: 1 }, y: { x: 1 } })
   })
 })
diff --git a/test/runtime/schema/composite.ts b/test/runtime/schema/composite.ts
index cca8cac71..9e19cb26c 100644
--- a/test/runtime/schema/composite.ts
+++ b/test/runtime/schema/composite.ts
@@ -9,7 +9,6 @@ describe('type/schema/Composite', () => {
     const T = Type.Composite([A, B], { additionalProperties: false })
     Ok(T, { a: 'hello', b: 42 })
   })
-
   it('Should compose with partial', () => {
     const A = Type.Partial(Type.Object({ a: Type.Number() }))
     const B = Type.Partial(Type.Object({ b: Type.Number() }))
@@ -18,41 +17,45 @@ describe('type/schema/Composite', () => {
     Ok(P, { a: 1 })
     Ok(P, { b: 1 })
     Ok(P, {})
+    Fail(P, { a: 1, b: 2, c: 3 })
     Fail(P, { c: 1 })
   })
-
   it('Should compose with overlapping same type', () => {
     const A = Type.Object({ a: Type.Number() })
     const B = Type.Object({ a: Type.Number() })
     const P = Type.Composite([A, B])
     Ok(P, { a: 1 })
-    Fail(P, { a: 'hello' })
-    Fail(P, {})
+    Fail(P, { a: '1' })
   })
-
-  it('Should compose with overlapping varying type', () => {
+  it('Should not compose with overlapping varying type', () => {
     const A = Type.Object({ a: Type.Number() })
     const B = Type.Object({ a: Type.String() })
     const T = Type.Composite([A, B])
-    Ok(T, { a: 1 })
-    Ok(T, { a: 'hello' })
+    Fail(T, { a: 1 })
+    Fail(T, { a: 'hello' })
     Fail(T, {})
   })
-
   it('Should compose with deeply nest overlapping varying type', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ b: Type.String() })
+    const C = Type.Object({ c: Type.Boolean() })
+    const D = Type.Object({ d: Type.Null() })
+    const T = Type.Composite([A, B, C, D])
+    Ok(T, { a: 1, b: 'hello', c: true, d: null })
+  })
+  it('Should not compose with deeply nest overlapping varying type', () => {
     const A = Type.Object({ a: Type.Number() })
     const B = Type.Object({ a: Type.String() })
     const C = Type.Object({ a: Type.Boolean() })
     const D = Type.Object({ a: Type.Null() })
     const T = Type.Composite([A, B, C, D])
-    Ok(T, { a: 1 })
-    Ok(T, { a: 'hello' })
-    Ok(T, { a: false })
-    Ok(T, { a: null })
+    Fail(T, { a: 1 })
+    Fail(T, { a: 'hello' })
+    Fail(T, { a: false })
+    Fail(T, { a: null })
     Fail(T, { a: [] })
     Fail(T, {})
   })
-
   it('Should pick from composited type', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ y: Type.Number() })
@@ -62,7 +65,6 @@ describe('type/schema/Composite', () => {
     Ok(P, { x: 1, y: 1 })
     Fail(P, { x: 1, y: 1, z: 1 })
   })
-
   it('Should omit from composited type', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ y: Type.Number() })
@@ -72,16 +74,14 @@ describe('type/schema/Composite', () => {
     Ok(P, { x: 1, y: 1 })
     Fail(P, { x: 1, y: 1, z: 1 })
   })
-
   it('Should compose nested object properties', () => {
     const A = Type.Object({ x: Type.Object({ x: Type.Number() }) })
-    const B = Type.Object({ x: Type.Object({ x: Type.String() }) })
+    const B = Type.Object({ y: Type.Object({ x: Type.String() }) })
     const T = Type.Composite([A, B])
-    Ok(T, { x: { x: 1 } })
-    Ok(T, { x: { x: 'hello' } })
-    Fail(T, { x: { x: false } })
+    Ok(T, { x: { x: 1 }, y: { x: '' } })
+    Fail(T, { x: { x: '1' }, y: { x: '' } })
+    Fail(T, { x: { x: 1 }, y: { x: 1 } })
   })
-
   // todo: move to composition / type guard spec
   it('Should compose and produce the same schema', () => {
     const T = Type.Object({
diff --git a/test/runtime/type/guard/composite.ts b/test/runtime/type/guard/composite.ts
new file mode 100644
index 000000000..2ace75790
--- /dev/null
+++ b/test/runtime/type/guard/composite.ts
@@ -0,0 +1,27 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TComposite', () => {
+  it('Should guard for distinct properties', () => {
+    const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
+    Assert.equal(TypeGuard.TNumber(T.properties.x), true)
+    Assert.equal(TypeGuard.TNumber(T.properties.y), true)
+  })
+  it('Should guard for overlapping properties', () => {
+    const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.Number() })])
+    Assert.equal(TypeGuard.TNumber(T.properties.x), true)
+  })
+  it('Should guard for illogical intersection and yield never', () => {
+    const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.String() })])
+    Assert.equal(TypeGuard.TNever(T.properties.x), true)
+  })
+  it('Should not produce optional property if all properties are not optional', () => {
+    const T = Type.Composite([Type.Object({ x: Type.Optional(Type.Number()) }), Type.Object({ x: Type.Number() })])
+    Assert.equal(TypeGuard.TOptional(T.properties.x), false)
+  })
+  it('Should produce optional property if all properties are optional', () => {
+    const T = Type.Composite([Type.Object({ x: Type.Optional(Type.Number()) }), Type.Object({ x: Type.Optional(Type.Number()) })])
+    Assert.equal(TypeGuard.TOptional(T.properties.x), true)
+  })
+})
diff --git a/test/runtime/type/guard/index.ts b/test/runtime/type/guard/index.ts
index d66cdf0f5..991f457ee 100644
--- a/test/runtime/type/guard/index.ts
+++ b/test/runtime/type/guard/index.ts
@@ -2,6 +2,7 @@ import './any'
 import './array'
 import './bigint'
 import './boolean'
+import './composite'
 import './constructor'
 import './date'
 import './exclude'
diff --git a/test/static/composite.ts b/test/static/composite.ts
index be5596d2d..fcbc5c4a9 100644
--- a/test/static/composite.ts
+++ b/test/static/composite.ts
@@ -1,19 +1,74 @@
 import { Expect } from './assert'
-import { Type } from '@sinclair/typebox'
+import { Type, Static } from '@sinclair/typebox'
 
+// Overlapping - Non Varying
 {
   const A = Type.Object({
+    A: Type.Number(),
+  })
+  const B = Type.Object({
+    A: Type.Number(),
+  })
+  const T = Type.Composite([A, B])
+
+  Expect(T).ToInfer<{
+    A: number
+  }>()
+}
+// Overlapping - Varying
+{
+  const A = Type.Object({
+    A: Type.Number(),
+  })
+  const B = Type.Object({
     A: Type.String(),
-    B: Type.String(),
+  })
+  const T = Type.Composite([A, B])
+
+  Expect(T).ToInfer<{
+    A: never
+  }>()
+}
+// Overlapping Single Optional
+{
+  const A = Type.Object({
+    A: Type.Optional(Type.Number()),
+  })
+  const B = Type.Object({
+    A: Type.Number(),
+  })
+  const T = Type.Composite([A, B])
+
+  Expect(T).ToInfer<{
+    A: number
+  }>()
+}
+// Overlapping All Optional
+{
+  const A = Type.Object({
+    A: Type.Optional(Type.Number()),
   })
   const B = Type.Object({
+    A: Type.Optional(Type.Number()),
+  })
+  const T = Type.Composite([A, B])
+
+  Expect(T).ToInfer<{
+    A: number | undefined
+  }>()
+}
+// Distinct Properties
+{
+  const A = Type.Object({
     A: Type.Number(),
+  })
+  const B = Type.Object({
     B: Type.Number(),
   })
   const T = Type.Composite([A, B])
 
   Expect(T).ToInfer<{
-    A: string | number
-    B: string | number
+    A: number
+    B: number
   }>()
 }

From e16fceb02f6871709c5bdde455a57942848eb8ab Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Thu, 23 Mar 2023 18:01:24 +0900
Subject: [PATCH 076/369] Composite Evaluate

---
 readme.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/readme.md b/readme.md
index b26946d92..494f001e9 100644
--- a/readme.md
+++ b/readme.md
@@ -325,15 +325,15 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Composite([     │ type T = {                  │ const T = {                    │
+│ const T = Type.Composite([     │ type I = {                  │ const T = {                    │
 │   Type.Object({                │   x: number                 │   type: 'object',              │
-│     x: Type.Number()           │   y: number                 │   required: ['x', 'y'],        │
-│   }),                          │ }                           │   properties: {                │
-│   Type.Object({                │                             │     x: {                       │
+│     x: Type.Number()           │ } & {                       │   required: ['x', 'y'],        │
+│   }),                          │   y: number                 │   properties: {                │
+│   Type.Object({                │ }                           │     x: {                       │
 │     y: Type.Number()           │                             │       type: 'number'           │
-│   })                           │                             │     },                         │
-│ ])                             │                             │     y: {                       │
-│                                │                             │       type: 'number'           │
+│   })                           │ type T = {                  │     },                         │
+│ ])                             │   [K in keyof I]: I[K]      │     y: {                       │
+│                                │ }                           │       type: 'number'           │
 │                                │                             │     }                          │
 │                                │                             │   }                            │
 │                                │                             │ }                              │

From 4ae9125b5503ec2e804334f7bcebe0d5d8d179de Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 24 Mar 2023 07:18:57 +0900
Subject: [PATCH 077/369] Composite Evaluate

---
 changelog/0.26.2.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/changelog/0.26.2.md b/changelog/0.26.2.md
index 4e046809f..052f4bd7d 100644
--- a/changelog/0.26.2.md
+++ b/changelog/0.26.2.md
@@ -32,7 +32,7 @@ As such, 0.26.2 reverts back to the 0.25.0 interpretation, but applies type mapp
 { // evaluation case 4: all optional
   type T = { a?: number } & { a?: number }
 
-  type C = {[K in keyof T]: T[K] }  // type C = { a: number | undefined }
+  type C = {[K in keyof T]: T[K] }  // type C = { a?: number | undefined }
 }
 ```
-Note: the Type.Composite is intended to be a temporary type which can be replaced with a more general `Type.Mapped` in future revisions of TypeBox. As the infrastructure to support mapped types does not exist, users can use Type.Composite to partially replicate mapped type evaluation for composited object types only.
\ No newline at end of file
+Note: the Type.Composite is intended to be a temporary type which can be replaced with a more general `Type.Mapped` in future revisions of TypeBox. As the infrastructure to support mapped types does not exist, users can use Type.Composite to partially replicate mapped type evaluation for composited object types only.

From 39afc1fbaa318469c893c1e21fb645adccd62d3f Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 24 Mar 2023 13:55:07 +0900
Subject: [PATCH 078/369] Exact Optional Property Types (#352)

---
 package.json                       |  2 +-
 src/compiler/compiler.ts           | 31 +++++++++++++------------
 src/errors/errors.ts               | 33 ++++++++++++++++-----------
 src/system/system.ts               | 11 +++++++++
 src/value/check.ts                 | 32 +++++++++++++++-----------
 test/runtime/compiler/object.ts    |  6 ++---
 test/runtime/system/system.ts      | 36 ++++++++++++++++++++++++++++++
 test/runtime/value/check/object.ts |  4 ++--
 8 files changed, 109 insertions(+), 46 deletions(-)

diff --git a/package.json b/package.json
index 9160c0b84..dfeab5f08 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.26.2",
+  "version": "0.26.3",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 30a15e5f0..aee1fa24e 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -144,10 +144,10 @@ export namespace TypeCompiler {
     return typeof value === 'string'
   }
   // -------------------------------------------------------------------
-  // Overrides
+  // Polices
   // -------------------------------------------------------------------
-  function IsNumberCheck(value: string): string {
-    return !TypeSystem.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`
+  function IsExactOptionalProperty(value: string, key: string, expression: string) {
+    return TypeSystem.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${value}.${key} !== undefined ? ${expression} : true)`
   }
   function IsObjectCheck(value: string): string {
     return !TypeSystem.AllowArrayObjects ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`
@@ -157,6 +157,9 @@ export namespace TypeCompiler {
       ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
       : `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
   }
+  function IsNumberCheck(value: string): string {
+    return !TypeSystem.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`
+  }
   function IsVoidCheck(value: string): string {
     return TypeSystem.AllowVoidNull ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`
   }
@@ -255,29 +258,29 @@ export namespace TypeCompiler {
     yield IsObjectCheck(value)
     if (IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
     if (IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
-    const schemaKeys = globalThis.Object.getOwnPropertyNames(schema.properties)
-    for (const schemaKey of schemaKeys) {
-      const memberExpression = MemberExpression.Encode(value, schemaKey)
-      const property = schema.properties[schemaKey]
-      if (schema.required && schema.required.includes(schemaKey)) {
+    const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties)
+    for (const knownKey of knownKeys) {
+      const memberExpression = MemberExpression.Encode(value, knownKey)
+      const property = schema.properties[knownKey]
+      if (schema.required && schema.required.includes(knownKey)) {
         yield* Visit(property, references, memberExpression)
-        if (Types.ExtendsUndefined.Check(property)) yield `('${schemaKey}' in ${value})`
+        if (Types.ExtendsUndefined.Check(property)) yield `('${knownKey}' in ${value})`
       } else {
         const expression = CreateExpression(property, references, memberExpression)
-        yield `('${schemaKey}' in ${value} ? ${expression} : true)`
+        yield IsExactOptionalProperty(value, knownKey, expression)
       }
     }
     if (schema.additionalProperties === false) {
-      if (schema.required && schema.required.length === schemaKeys.length) {
-        yield `Object.getOwnPropertyNames(${value}).length === ${schemaKeys.length}`
+      if (schema.required && schema.required.length === knownKeys.length) {
+        yield `Object.getOwnPropertyNames(${value}).length === ${knownKeys.length}`
       } else {
-        const keys = `[${schemaKeys.map((key) => `'${key}'`).join(', ')}]`
+        const keys = `[${knownKeys.map((key) => `'${key}'`).join(', ')}]`
         yield `Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key))`
       }
     }
     if (typeof schema.additionalProperties === 'object') {
       const expression = CreateExpression(schema.additionalProperties, references, 'value[key]')
-      const keys = `[${schemaKeys.map((key) => `'${key}'`).join(', ')}]`
+      const keys = `[${knownKeys.map((key) => `'${key}'`).join(', ')}]`
       yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`
     }
   }
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 780b6d7f7..51476a648 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -135,6 +135,24 @@ export namespace ValueErrors {
   // ----------------------------------------------------------------------
   // Guards
   // ----------------------------------------------------------------------
+  function IsBigInt(value: unknown): value is bigint {
+    return typeof value === 'bigint'
+  }
+  function IsInteger(value: unknown): value is number {
+    return globalThis.Number.isInteger(value)
+  }
+  function IsString(value: unknown): value is string {
+    return typeof value === 'string'
+  }
+  function IsDefined<T>(value: unknown): value is T {
+    return value !== undefined
+  }
+  // ----------------------------------------------------------------------
+  // Policies
+  // ----------------------------------------------------------------------
+  function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string) {
+    return TypeSystem.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined
+  }
   function IsObject(value: unknown): value is Record<keyof any, unknown> {
     const result = typeof value === 'object' && value !== null
     return TypeSystem.AllowArrayObjects ? result : result && !globalThis.Array.isArray(value)
@@ -142,26 +160,15 @@ export namespace ValueErrors {
   function IsRecordObject(value: unknown): value is Record<keyof any, unknown> {
     return IsObject(value) && !(value instanceof globalThis.Date) && !(value instanceof globalThis.Uint8Array)
   }
-  function IsBigInt(value: unknown): value is bigint {
-    return typeof value === 'bigint'
-  }
   function IsNumber(value: unknown): value is number {
     const result = typeof value === 'number'
     return TypeSystem.AllowNaN ? result : result && globalThis.Number.isFinite(value)
   }
-  function IsInteger(value: unknown): value is number {
-    return globalThis.Number.isInteger(value)
-  }
-  function IsString(value: unknown): value is string {
-    return typeof value === 'string'
-  }
   function IsVoid(value: unknown): value is void {
     const result = value === undefined
     return TypeSystem.AllowVoidNull ? result || value === null : result
   }
-  function IsDefined<T>(value: unknown): value is T {
-    return value !== undefined
-  }
+
   // ----------------------------------------------------------------------
   // Types
   // ----------------------------------------------------------------------
@@ -351,7 +358,7 @@ export namespace ValueErrors {
           yield { type: ValueErrorType.ObjectRequiredProperties, schema: property, path: `${path}/${knownKey}`, value: undefined, message: `Expected required property` }
         }
       } else {
-        if (knownKey in value) {
+        if (IsExactOptionalProperty(value, knownKey)) {
           yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey])
         }
       }
diff --git a/src/system/system.ts b/src/system/system.ts
index 598f6cc09..a7dda5804 100644
--- a/src/system/system.ts
+++ b/src/system/system.ts
@@ -38,14 +38,24 @@ export class TypeSystemDuplicateFormat extends Error {
     super(`Duplicate string format '${kind}' detected`)
   }
 }
+
 /** Creates user defined types and formats and provides overrides for value checking behaviours */
 export namespace TypeSystem {
+  // ------------------------------------------------------------------------
+  // Assertion Policies
+  // ------------------------------------------------------------------------
+  /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
+  export let ExactOptionalPropertyTypes: boolean = false
   /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
   export let AllowArrayObjects: boolean = false
   /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
   export let AllowNaN: boolean = false
   /** Sets whether `null` should validate for void types. The default is `false` */
   export let AllowVoidNull: boolean = false
+
+  // ------------------------------------------------------------------------
+  // String Formats and Types
+  // ------------------------------------------------------------------------
   /** Creates a new type */
   export function Type<Type, Options = object>(kind: string, check: (options: Options, value: unknown) => boolean) {
     if (Types.TypeRegistry.Has(kind)) throw new TypeSystemDuplicateTypeKind(kind)
@@ -58,6 +68,7 @@ export namespace TypeSystem {
     Types.FormatRegistry.Set(format, check)
     return format
   }
+
   // ------------------------------------------------------------------------
   // Deprecated
   // ------------------------------------------------------------------------
diff --git a/src/value/check.ts b/src/value/check.ts
index 59db8e22d..c30e4064e 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -47,6 +47,24 @@ export namespace ValueCheck {
   // ----------------------------------------------------------------------
   // Guards
   // ----------------------------------------------------------------------
+  function IsBigInt(value: unknown): value is bigint {
+    return typeof value === 'bigint'
+  }
+  function IsInteger(value: unknown): value is number {
+    return globalThis.Number.isInteger(value)
+  }
+  function IsString(value: unknown): value is string {
+    return typeof value === 'string'
+  }
+  function IsDefined<T>(value: unknown): value is T {
+    return value !== undefined
+  }
+  // ----------------------------------------------------------------------
+  // Policies
+  // ----------------------------------------------------------------------
+  function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string) {
+    return TypeSystem.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined
+  }
   function IsObject(value: unknown): value is Record<keyof any, unknown> {
     const result = typeof value === 'object' && value !== null
     return TypeSystem.AllowArrayObjects ? result : result && !globalThis.Array.isArray(value)
@@ -54,26 +72,14 @@ export namespace ValueCheck {
   function IsRecordObject(value: unknown): value is Record<keyof any, unknown> {
     return IsObject(value) && !(value instanceof globalThis.Date) && !(value instanceof globalThis.Uint8Array)
   }
-  function IsBigInt(value: unknown): value is bigint {
-    return typeof value === 'bigint'
-  }
   function IsNumber(value: unknown): value is number {
     const result = typeof value === 'number'
     return TypeSystem.AllowNaN ? result : result && globalThis.Number.isFinite(value)
   }
-  function IsInteger(value: unknown): value is number {
-    return globalThis.Number.isInteger(value)
-  }
-  function IsString(value: unknown): value is string {
-    return typeof value === 'string'
-  }
   function IsVoid(value: unknown): value is void {
     const result = value === undefined
     return TypeSystem.AllowVoidNull ? result || value === null : result
   }
-  function IsDefined<T>(value: unknown): value is T {
-    return value !== undefined
-  }
   // ----------------------------------------------------------------------
   // Types
   // ----------------------------------------------------------------------
@@ -237,7 +243,7 @@ export namespace ValueCheck {
           return knownKey in value
         }
       } else {
-        if (knownKey in value && !Visit(property, references, value[knownKey])) {
+        if (IsExactOptionalProperty(value, knownKey) && !Visit(property, references, value[knownKey])) {
           return false
         }
       }
diff --git a/test/runtime/compiler/object.ts b/test/runtime/compiler/object.ts
index 699b533b0..e6faf0837 100644
--- a/test/runtime/compiler/object.ts
+++ b/test/runtime/compiler/object.ts
@@ -227,16 +227,16 @@ describe('type/compiler/Object', () => {
     Ok(T, { x: undefined })
     Ok(T, {})
   })
-  it('Should not check undefined for optional property of number', () => {
+  it('Should check undefined for optional property of number', () => {
     const T = Type.Object({ x: Type.Optional(Type.Number()) })
     Ok(T, { x: 1 })
+    Ok(T, { x: undefined }) // allowed by default
     Ok(T, {})
-    Fail(T, { x: undefined })
   })
   it('Should check undefined for optional property of undefined', () => {
     const T = Type.Object({ x: Type.Optional(Type.Undefined()) })
     Fail(T, { x: 1 })
-    Ok(T, {})
     Ok(T, { x: undefined })
+    Ok(T, {})
   })
 })
diff --git a/test/runtime/system/system.ts b/test/runtime/system/system.ts
index 5c41eda2c..dc7c51df5 100644
--- a/test/runtime/system/system.ts
+++ b/test/runtime/system/system.ts
@@ -3,6 +3,42 @@ import { Assert } from '../assert/index'
 import { TypeSystem } from '@sinclair/typebox/system'
 import { Type } from '@sinclair/typebox'
 
+describe('system/TypeSystem/ExactOptionalPropertyTypes', () => {
+  before(() => {
+    TypeSystem.ExactOptionalPropertyTypes = true
+  })
+  after(() => {
+    TypeSystem.ExactOptionalPropertyTypes = false
+  })
+  // ---------------------------------------------------------------
+  // Number
+  // ---------------------------------------------------------------
+  it('Should not validate optional number', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.Number()),
+    })
+    Ok(T, {})
+    Ok(T, { x: 1 })
+    Fail(T, { x: undefined })
+  })
+  it('Should not validate undefined', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.Undefined()),
+    })
+    Ok(T, {})
+    Fail(T, { x: 1 })
+    Ok(T, { x: undefined })
+  })
+  it('Should validate optional number | undefined', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.Union([Type.Number(), Type.Undefined()])),
+    })
+    Ok(T, {})
+    Ok(T, { x: 1 })
+    Ok(T, { x: undefined })
+  })
+})
+
 describe('system/TypeSystem/AllowNaN', () => {
   before(() => {
     TypeSystem.AllowNaN = true
diff --git a/test/runtime/value/check/object.ts b/test/runtime/value/check/object.ts
index 6b672b938..6a06962de 100644
--- a/test/runtime/value/check/object.ts
+++ b/test/runtime/value/check/object.ts
@@ -212,11 +212,11 @@ describe('value/check/Object', () => {
     Assert.equal(Value.Check(T, { x: undefined }), true)
     Assert.equal(Value.Check(T, {}), true)
   })
-  it('Should not check undefined for optional property of number', () => {
+  it('Should check undefined for optional property of number', () => {
     const T = Type.Object({ x: Type.Optional(Type.Number()) })
     Assert.equal(Value.Check(T, { x: 1 }), true)
+    Assert.equal(Value.Check(T, { x: undefined }), true) // allowed by default
     Assert.equal(Value.Check(T, {}), true)
-    Assert.equal(Value.Check(T, { x: undefined }), false)
   })
   it('Should check undefined for optional property of undefined', () => {
     const T = Type.Object({ x: Type.Optional(Type.Undefined()) })

From 89564f12c4804a8cc44657459add16afced5f022 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 26 Mar 2023 17:17:19 +0900
Subject: [PATCH 079/369] Enhanced Member Expression Check (#354)

---
 package.json                    |  2 +-
 src/compiler/compiler.ts        | 58 ++++++++++++++++-----------------
 test/runtime/compiler/object.ts |  4 +++
 3 files changed, 34 insertions(+), 30 deletions(-)

diff --git a/package.json b/package.json
index dfeab5f08..a3f37c50a 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.26.3",
+  "version": "0.26.4",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index aee1fa24e..9f546db63 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -60,14 +60,38 @@ namespace Character {
   export function DollarSign(code: number) {
     return code === 36
   }
-  export function Underscore(code: number) {
+  export function IsUnderscore(code: number) {
     return code === 95
   }
-  export function Numeric(code: number) {
+  export function IsAlpha(code: number) {
+    return (code >= 64 && code <= 90) || (code >= 97 && code <= 122)
+  }
+  export function IsNumeric(code: number) {
     return code >= 48 && code <= 57
   }
-  export function Alpha(code: number) {
-    return (code >= 65 && code <= 90) || (code >= 97 && code <= 122)
+}
+// -------------------------------------------------------------------
+// MemberExpression
+// -------------------------------------------------------------------
+namespace MemberExpression {
+  function IsFirstCharacterNumeric(value: string) {
+    if (value.length === 0) return false
+    return Character.IsNumeric(value.charCodeAt(0))
+  }
+  function IsAccessor(value: string) {
+    if (IsFirstCharacterNumeric(value)) return false
+    for (let i = 0; i < value.length; i++) {
+      const code = value.charCodeAt(i)
+      const check = Character.IsAlpha(code) || Character.IsNumeric(code) || Character.DollarSign(code) || Character.IsUnderscore(code)
+      if (!check) return false
+    }
+    return true
+  }
+  function EscapeHyphen(key: string) {
+    return key.replace(/'/g, "\\'")
+  }
+  export function Encode(object: string, key: string) {
+    return IsAccessor(key) ? `${object}.${key}` : `${object}['${EscapeHyphen(key)}']`
   }
 }
 // -------------------------------------------------------------------
@@ -78,7 +102,7 @@ namespace Identifier {
     const buffer: string[] = []
     for (let i = 0; i < $id.length; i++) {
       const code = $id.charCodeAt(i)
-      if (Character.Numeric(code) || Character.Alpha(code)) {
+      if (Character.IsNumeric(code) || Character.IsAlpha(code)) {
         buffer.push($id.charAt(i))
       } else {
         buffer.push(`_${code}_`)
@@ -88,30 +112,6 @@ namespace Identifier {
   }
 }
 // -------------------------------------------------------------------
-// MemberExpression
-// -------------------------------------------------------------------
-export namespace MemberExpression {
-  function Check(propertyName: string) {
-    if (propertyName.length === 0) return false
-    {
-      const code = propertyName.charCodeAt(0)
-      if (!(Character.DollarSign(code) || Character.Underscore(code) || Character.Alpha(code))) {
-        return false
-      }
-    }
-    for (let i = 1; i < propertyName.length; i++) {
-      const code = propertyName.charCodeAt(i)
-      if (!(Character.DollarSign(code) || Character.Underscore(code) || Character.Alpha(code) || Character.Numeric(code))) {
-        return false
-      }
-    }
-    return true
-  }
-  export function Encode(object: string, key: string) {
-    return !Check(key) ? `${object}['${key}']` : `${object}.${key}`
-  }
-}
-// -------------------------------------------------------------------
 // TypeCompiler
 // -------------------------------------------------------------------
 export class TypeCompilerUnknownTypeError extends Error {
diff --git a/test/runtime/compiler/object.ts b/test/runtime/compiler/object.ts
index e6faf0837..0d83ab294 100644
--- a/test/runtime/compiler/object.ts
+++ b/test/runtime/compiler/object.ts
@@ -132,12 +132,16 @@ describe('type/compiler/Object', () => {
       '0-leading': Type.Literal(2),
       '$-leading': Type.Literal(3),
       '!@#$%^&*(': Type.Literal(4),
+      'node-mirror:release': Type.Literal(5), // issue: 353
+      "a'a": Type.Literal(6),
     })
     Ok(T, {
       'with-hyphen': 1,
       '0-leading': 2,
       '$-leading': 3,
       '!@#$%^&*(': 4,
+      'node-mirror:release': 5,
+      "a'a": 6,
     })
   })
   it('Should validate schema additional properties of string', () => {

From ff2a63c7349facff5403d83809148f8ae3599565 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 27 Mar 2023 12:26:44 +0900
Subject: [PATCH 080/369] Enhanced Member Expression Check (#357)

---
 package.json                    |  2 +-
 src/compiler/compiler.ts        |  2 +-
 test/runtime/compiler/object.ts | 12 ++++++++----
 3 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/package.json b/package.json
index a3f37c50a..ccd4b86f1 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.26.4",
+  "version": "0.26.5",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 9f546db63..62ef4f679 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -147,7 +147,7 @@ export namespace TypeCompiler {
   // Polices
   // -------------------------------------------------------------------
   function IsExactOptionalProperty(value: string, key: string, expression: string) {
-    return TypeSystem.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${value}.${key} !== undefined ? ${expression} : true)`
+    return TypeSystem.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${MemberExpression.Encode(value, key)} !== undefined ? ${expression} : true)`
   }
   function IsObjectCheck(value: string): string {
     return !TypeSystem.AllowArrayObjects ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`
diff --git a/test/runtime/compiler/object.ts b/test/runtime/compiler/object.ts
index 0d83ab294..b45f9a8b6 100644
--- a/test/runtime/compiler/object.ts
+++ b/test/runtime/compiler/object.ts
@@ -132,16 +132,20 @@ describe('type/compiler/Object', () => {
       '0-leading': Type.Literal(2),
       '$-leading': Type.Literal(3),
       '!@#$%^&*(': Type.Literal(4),
-      'node-mirror:release': Type.Literal(5), // issue: 353
-      "a'a": Type.Literal(6),
+      'node-mirror:release:0': Type.Literal(5), // issue: 353
+      'node-mirror:release:1': Type.Optional(Type.Literal(6)), // issue: 356
+      'node-mirror:release:2': Type.Union([Type.Literal(7), Type.Undefined()]), // key known
+      "a'a": Type.Literal(8),
     })
     Ok(T, {
       'with-hyphen': 1,
       '0-leading': 2,
       '$-leading': 3,
       '!@#$%^&*(': 4,
-      'node-mirror:release': 5,
-      "a'a": 6,
+      'node-mirror:release:0': 5,
+      'node-mirror:release:1': 6,
+      'node-mirror:release:2': 7,
+      "a'a": 8,
     })
   })
   it('Should validate schema additional properties of string', () => {

From e9f63d897b824a083a66a354eda33a1bf7738eca Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 27 Mar 2023 13:48:36 +0900
Subject: [PATCH 081/369] Inverse Assert for Compiler and Value Check Alignment
 (#359)

---
 test/runtime/compiler/validate.ts | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/test/runtime/compiler/validate.ts b/test/runtime/compiler/validate.ts
index 070d6092b..b85a91c20 100644
--- a/test/runtime/compiler/validate.ts
+++ b/test/runtime/compiler/validate.ts
@@ -96,6 +96,9 @@ export function Ok<T extends TSchema>(schema: T, data: unknown, references: any[
 export function Fail<T extends TSchema>(schema: T, data: unknown, references: any[] = []) {
   const C = TypeCompiler.Compile(schema, references)
   const result = C.Check(data)
+  if (result !== Value.Check(schema, references, data)) {
+    throw Error('Compiler and Value Check disparity')
+  }
   if (result === false) {
     const errors = [...Value.Errors(schema, references, data)]
     if (errors.length === 0) throw Error('expected at least 1 error')

From e8b213c390d850e2a161b28f41586fde6882a37f Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 28 Mar 2023 23:50:49 +0900
Subject: [PATCH 082/369] Record and Union Conversion Logic (#361)

---
 package.json                         |  2 +-
 src/value/convert.ts                 | 16 ++++++++++++++--
 test/runtime/value/convert/record.ts |  6 +++++-
 test/runtime/value/convert/union.ts  | 19 ++++++++++++++++++-
 4 files changed, 38 insertions(+), 5 deletions(-)

diff --git a/package.json b/package.json
index ccd4b86f1..c9a2ab8fb 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.26.5",
+  "version": "0.26.6",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/convert.ts b/src/value/convert.ts
index 987ef038e..b40ab967b 100644
--- a/src/value/convert.ts
+++ b/src/value/convert.ts
@@ -28,6 +28,7 @@ THE SOFTWARE.
 
 import * as Types from '../typebox'
 import { ValueClone } from './clone'
+import { ValueCheck } from './check'
 
 // ----------------------------------------------------------------------------------------------
 // Errors
@@ -129,7 +130,6 @@ export namespace ValueConvert {
   function TryConvertBigInt(value: unknown) {
     return IsStringNumeric(value) ? globalThis.BigInt(parseInt(value)) : IsNumber(value) ? globalThis.BigInt(value | 0) : IsValueFalse(value) ? 0 : IsValueTrue(value) ? 1 : value
   }
-
   function TryConvertString(value: unknown) {
     return IsValueToString(value) ? value.toString() : IsSymbol(value) && value.description !== undefined ? value.description.toString() : value
   }
@@ -229,7 +229,13 @@ export namespace ValueConvert {
     return value
   }
   function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): unknown {
-    return value
+    const propertyKey = globalThis.Object.getOwnPropertyNames(schema.patternProperties)[0]
+    const property = schema.patternProperties[propertyKey]
+    const result = {} as Record<string, unknown>
+    for (const [propKey, propValue] of globalThis.Object.entries(value)) {
+      result[propKey] = Visit(property, references, propValue)
+    }
+    return result
   }
   function Ref(schema: Types.TRef<any>, references: Types.TSchema[], value: any): unknown {
     const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
@@ -261,6 +267,12 @@ export namespace ValueConvert {
     return TryConvertUndefined(value)
   }
   function Union(schema: Types.TUnion, references: Types.TSchema[], value: any): unknown {
+    for (const subschema of schema.anyOf) {
+      const converted = Visit(subschema, references, value)
+      if (ValueCheck.Check(subschema, references, converted)) {
+        return converted
+      }
+    }
     return value
   }
   function Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): unknown {
diff --git a/test/runtime/value/convert/record.ts b/test/runtime/value/convert/record.ts
index bfeb7129c..641476f17 100644
--- a/test/runtime/value/convert/record.ts
+++ b/test/runtime/value/convert/record.ts
@@ -3,5 +3,9 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/convert/Record', () => {
-  it('Should convert', () => {})
+  it('Should convert record value to numeric', () => {
+    const T = Type.Record(Type.String(), Type.Number())
+    const V = Value.Convert(T, { x: '42', y: '24', z: 'hello' })
+    Assert.deepEqual(V, { x: 42, y: '24', z: 'hello' })
+  })
 })
diff --git a/test/runtime/value/convert/union.ts b/test/runtime/value/convert/union.ts
index 5b1f2f3a5..7fd75a17a 100644
--- a/test/runtime/value/convert/union.ts
+++ b/test/runtime/value/convert/union.ts
@@ -3,5 +3,22 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/convert/Union', () => {
-  it('Should convert', () => {})
+  it('Should convert union variant', () => {
+    const T = Type.Object({
+      x: Type.Union([Type.Number(), Type.Null()]),
+    })
+    const V1 = Value.Convert(T, { x: '42' })
+    const V2 = Value.Convert(T, { x: 'null' })
+    const V3 = Value.Convert(T, { x: 'hello' })
+    Assert.deepEqual(V1, { x: 42 })
+    Assert.deepEqual(V2, { x: null })
+    Assert.deepEqual(V3, { x: 'hello' })
+  })
+  it('Should convert first variant in ambiguous conversion', () => {
+    const T = Type.Object({
+      x: Type.Union([Type.Boolean(), Type.Number()]),
+    })
+    const V1 = Value.Convert(T, { x: '1' })
+    Assert.deepEqual(V1, { x: true })
+  })
 })

From 069c95e2aa455b294550da9c67e1b780ce53b7e4 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 29 Mar 2023 13:18:30 +0900
Subject: [PATCH 083/369] Additional Record Constraints (#363)

---
 package.json                       |  2 +-
 src/compiler/compiler.ts           |  3 ++-
 src/errors/errors.ts               |  6 ++++++
 src/value/check.ts                 |  6 ++++++
 test/runtime/compiler/record.ts    | 34 ++++++++++++++----------------
 test/runtime/schema/record.ts      | 34 ++++++++++++++----------------
 test/runtime/value/check/record.ts | 24 ++++++++++++++-------
 7 files changed, 63 insertions(+), 46 deletions(-)

diff --git a/package.json b/package.json
index c9a2ab8fb..836dbee68 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.26.6",
+  "version": "0.26.7",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 62ef4f679..1d269f98a 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -287,9 +287,10 @@ export namespace TypeCompiler {
   function* Promise(schema: Types.TPromise<any>, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof value === 'object' && typeof ${value}.then === 'function')`
   }
-
   function* Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield IsRecordCheck(value)
+    if (IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
+    if (IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
     const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
     const local = PushLocal(`new RegExp(/${keyPattern}/)`)
     yield `(Object.getOwnPropertyNames(${value}).every(key => ${local}.test(key)))`
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 51476a648..521343938 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -390,6 +390,12 @@ export namespace ValueErrors {
     if (!IsRecordObject(value)) {
       return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected record object` }
     }
+    if (IsDefined<number>(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+      yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` }
+    }
+    if (IsDefined<number>(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+      yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` }
+    }
     const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
     const regex = new RegExp(keyPattern)
     if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {
diff --git a/src/value/check.ts b/src/value/check.ts
index c30e4064e..bf3f42909 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -270,6 +270,12 @@ export namespace ValueCheck {
     if (!IsRecordObject(value)) {
       return false
     }
+    if (IsDefined<number>(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+      return false
+    }
+    if (IsDefined<number>(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+      return false
+    }
     const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
     const regex = new RegExp(keyPattern)
     if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {
diff --git a/test/runtime/compiler/record.ts b/test/runtime/compiler/record.ts
index d12e65daa..428c35f92 100644
--- a/test/runtime/compiler/record.ts
+++ b/test/runtime/compiler/record.ts
@@ -6,24 +6,36 @@ describe('type/compiler/Record', () => {
     const T = Type.Record(Type.String(), Type.Number())
     Ok(T, { a: 1, b: 2, c: 3 })
   })
-
   it('Should validate when all property keys are strings', () => {
     const T = Type.Record(Type.String(), Type.Number())
     Ok(T, { a: 1, b: 2, c: 3, '0': 4 })
   })
-
+  it('Should not validate when below minProperties', () => {
+    const T = Type.Record(Type.String(), Type.Number(), { minProperties: 4 })
+    Ok(T, { a: 1, b: 2, c: 3, d: 4 })
+    Fail(T, { a: 1, b: 2, c: 3 })
+  })
+  it('Should not validate when above maxProperties', () => {
+    const T = Type.Record(Type.String(), Type.Number(), { maxProperties: 4 })
+    Ok(T, { a: 1, b: 2, c: 3, d: 4 })
+    Fail(T, { a: 1, b: 2, c: 3, d: 4, e: 5 })
+  })
+  it('Should not validate with illogical minProperties | maxProperties', () => {
+    const T = Type.Record(Type.String(), Type.Number(), { minProperties: 5, maxProperties: 4 })
+    Fail(T, { a: 1, b: 2, c: 3 })
+    Fail(T, { a: 1, b: 2, c: 3, d: 4 })
+    Fail(T, { a: 1, b: 2, c: 3, d: 4, e: 5 })
+  })
   it('Should validate when specifying string union literals when additionalProperties is true', () => {
     const K = Type.Union([Type.Literal('a'), Type.Literal('b'), Type.Literal('c')])
     const T = Type.Record(K, Type.Number())
     Ok(T, { a: 1, b: 2, c: 3, d: 'hello' })
   })
-
   it('Should not validate when specifying string union literals when additionalProperties is false', () => {
     const K = Type.Union([Type.Literal('a'), Type.Literal('b'), Type.Literal('c')])
     const T = Type.Record(K, Type.Number(), { additionalProperties: false })
     Fail(T, { a: 1, b: 2, c: 3, d: 'hello' })
   })
-
   it('Should validate for keyof records', () => {
     const T = Type.Object({
       a: Type.String(),
@@ -33,7 +45,6 @@ describe('type/compiler/Record', () => {
     const R = Type.Record(Type.KeyOf(T), Type.Number())
     Ok(R, { a: 1, b: 2, c: 3 })
   })
-
   it('Should not validate for unknown key via keyof', () => {
     const T = Type.Object({
       a: Type.String(),
@@ -43,7 +54,6 @@ describe('type/compiler/Record', () => {
     const R = Type.Record(Type.KeyOf(T), Type.Number(), { additionalProperties: false })
     Fail(R, { a: 1, b: 2, c: 3, d: 4 })
   })
-
   it('Should should validate when specifying regular expressions', () => {
     const K = Type.RegEx(/^op_.*$/)
     const T = Type.Record(K, Type.Number())
@@ -53,7 +63,6 @@ describe('type/compiler/Record', () => {
       op_c: 3,
     })
   })
-
   it('Should should not validate when specifying regular expressions and passing invalid property', () => {
     const K = Type.RegEx(/^op_.*$/)
     const T = Type.Record(K, Type.Number())
@@ -63,21 +72,17 @@ describe('type/compiler/Record', () => {
       aop_c: 3,
     })
   })
-
   // ------------------------------------------------------------
   // Integer Keys
   // ------------------------------------------------------------
-
   it('Should validate when all property keys are integers', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
     Ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
   })
-
   it('Should validate when all property keys are integers, but one property is a string with varying type', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
     Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
-
   it('Should not validate if passing a leading zeros for integers keys', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
     Fail(T, {
@@ -87,7 +92,6 @@ describe('type/compiler/Record', () => {
       '03': 4,
     })
   })
-
   it('Should not validate if passing a signed integers keys', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
     Fail(T, {
@@ -97,21 +101,17 @@ describe('type/compiler/Record', () => {
       '-3': 4,
     })
   })
-
   // ------------------------------------------------------------
   // Number Keys
   // ------------------------------------------------------------
-
   it('Should validate when all property keys are numbers', () => {
     const T = Type.Record(Type.Number(), Type.Number())
     Ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
   })
-
   it('Should validate when all property keys are numbers, but one property is a string with varying type', () => {
     const T = Type.Record(Type.Number(), Type.Number())
     Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
-
   it('Should not validate if passing a leading zeros for numeric keys', () => {
     const T = Type.Record(Type.Number(), Type.Number())
     Fail(T, {
@@ -121,7 +121,6 @@ describe('type/compiler/Record', () => {
       '03': 4,
     })
   })
-
   it('Should not validate if passing a signed numeric keys', () => {
     const T = Type.Record(Type.Number(), Type.Number())
     Fail(T, {
@@ -131,7 +130,6 @@ describe('type/compiler/Record', () => {
       '-3': 4,
     })
   })
-
   it('Should not validate when all property keys are numbers, but one property is a string with varying type', () => {
     const T = Type.Record(Type.Number(), Type.Number())
     Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
diff --git a/test/runtime/schema/record.ts b/test/runtime/schema/record.ts
index e9f2de88b..bacc80f42 100644
--- a/test/runtime/schema/record.ts
+++ b/test/runtime/schema/record.ts
@@ -6,24 +6,36 @@ describe('type/schema/Record', () => {
     const T = Type.Record(Type.String(), Type.Number())
     Ok(T, { a: 1, b: 2, c: 3 })
   })
-
   it('Should validate when all property keys are strings', () => {
     const T = Type.Record(Type.String(), Type.Number())
     Ok(T, { a: 1, b: 2, c: 3, '0': 4 })
   })
-
+  it('Should not validate when below minProperties', () => {
+    const T = Type.Record(Type.String(), Type.Number(), { minProperties: 4 })
+    Ok(T, { a: 1, b: 2, c: 3, d: 4 })
+    Fail(T, { a: 1, b: 2, c: 3 })
+  })
+  it('Should not validate when above maxProperties', () => {
+    const T = Type.Record(Type.String(), Type.Number(), { maxProperties: 4 })
+    Ok(T, { a: 1, b: 2, c: 3, d: 4 })
+    Fail(T, { a: 1, b: 2, c: 3, d: 4, e: 5 })
+  })
+  it('Should not validate with illogical minProperties | maxProperties', () => {
+    const T = Type.Record(Type.String(), Type.Number(), { minProperties: 5, maxProperties: 4 })
+    Fail(T, { a: 1, b: 2, c: 3 })
+    Fail(T, { a: 1, b: 2, c: 3, d: 4 })
+    Fail(T, { a: 1, b: 2, c: 3, d: 4, e: 5 })
+  })
   it('Should validate when specifying string union literals when additionalProperties is true', () => {
     const K = Type.Union([Type.Literal('a'), Type.Literal('b'), Type.Literal('c')])
     const T = Type.Record(K, Type.Number())
     Ok(T, { a: 1, b: 2, c: 3, d: 'hello' })
   })
-
   it('Should not validate when specifying string union literals when additionalProperties is false', () => {
     const K = Type.Union([Type.Literal('a'), Type.Literal('b'), Type.Literal('c')])
     const T = Type.Record(K, Type.Number(), { additionalProperties: false })
     Fail(T, { a: 1, b: 2, c: 3, d: 'hello' })
   })
-
   it('Should validate for keyof records', () => {
     const T = Type.Object({
       a: Type.String(),
@@ -33,7 +45,6 @@ describe('type/schema/Record', () => {
     const R = Type.Record(Type.KeyOf(T), Type.Number())
     Ok(R, { a: 1, b: 2, c: 3 })
   })
-
   it('Should not validate for unknown key via keyof', () => {
     const T = Type.Object({
       a: Type.String(),
@@ -43,7 +54,6 @@ describe('type/schema/Record', () => {
     const R = Type.Record(Type.KeyOf(T), Type.Number(), { additionalProperties: false })
     Fail(R, { a: 1, b: 2, c: 3, d: 4 })
   })
-
   it('Should should validate when specifying regular expressions', () => {
     const K = Type.RegEx(/^op_.*$/)
     const T = Type.Record(K, Type.Number())
@@ -53,7 +63,6 @@ describe('type/schema/Record', () => {
       op_c: 3,
     })
   })
-
   it('Should should not validate when specifying regular expressions and passing invalid property', () => {
     const K = Type.RegEx(/^op_.*$/)
     const T = Type.Record(K, Type.Number())
@@ -63,21 +72,17 @@ describe('type/schema/Record', () => {
       aop_c: 3,
     })
   })
-
   // ------------------------------------------------------------
   // Integer Keys
   // ------------------------------------------------------------
-
   it('Should validate when all property keys are integers', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
     Ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
   })
-
   it('Should validate when all property keys are integers, but one property is a string with varying type', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
     Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
-
   it('Should not validate if passing a leading zeros for integers keys', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
     Fail(T, {
@@ -87,7 +92,6 @@ describe('type/schema/Record', () => {
       '03': 4,
     })
   })
-
   it('Should not validate if passing a signed integers keys', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
     Fail(T, {
@@ -97,21 +101,17 @@ describe('type/schema/Record', () => {
       '-3': 4,
     })
   })
-
   // ------------------------------------------------------------
   // Number Keys
   // ------------------------------------------------------------
-
   it('Should validate when all property keys are numbers', () => {
     const T = Type.Record(Type.Number(), Type.Number())
     Ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
   })
-
   it('Should validate when all property keys are numbers, but one property is a string with varying type', () => {
     const T = Type.Record(Type.Number(), Type.Number())
     Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
-
   it('Should not validate if passing a leading zeros for numeric keys', () => {
     const T = Type.Record(Type.Number(), Type.Number())
     Fail(T, {
@@ -121,7 +121,6 @@ describe('type/schema/Record', () => {
       '03': 4,
     })
   })
-
   it('Should not validate if passing a signed numeric keys', () => {
     const T = Type.Record(Type.Number(), Type.Number())
     Fail(T, {
@@ -131,7 +130,6 @@ describe('type/schema/Record', () => {
       '-3': 4,
     })
   })
-
   it('Should not validate when all property keys are numbers, but one property is a string with varying type', () => {
     const T = Type.Record(Type.Number(), Type.Number())
     Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
diff --git a/test/runtime/value/check/record.ts b/test/runtime/value/check/record.ts
index 3bea978c0..2df12220d 100644
--- a/test/runtime/value/check/record.ts
+++ b/test/runtime/value/check/record.ts
@@ -22,6 +22,22 @@ describe('value/check/Record', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, true)
   })
+  it('Should fail when below minProperties', () => {
+    const T = Type.Record(Type.String(), Type.Number(), { minProperties: 4 })
+    Assert.equal(Value.Check(T, { a: 1, b: 2, c: 3, d: 4 }), true)
+    Assert.equal(Value.Check(T, { a: 1, b: 2, c: 3 }), false)
+  })
+  it('Should fail when above maxProperties', () => {
+    const T = Type.Record(Type.String(), Type.Number(), { maxProperties: 4 })
+    Assert.equal(Value.Check(T, { a: 1, b: 2, c: 3, d: 4 }), true)
+    Assert.equal(Value.Check(T, { a: 1, b: 2, c: 3, d: 4, e: 5 }), false)
+  })
+  it('Should fail with illogical minProperties | maxProperties', () => {
+    const T = Type.Record(Type.String(), Type.Number(), { minProperties: 5, maxProperties: 4 })
+    Assert.equal(Value.Check(T, { a: 1, b: 2, c: 3 }), false)
+    Assert.equal(Value.Check(T, { a: 1, b: 2, c: 3, d: 4 }), false)
+    Assert.equal(Value.Check(T, { a: 1, b: 2, c: 3, d: 4, e: 5 }), false)
+  })
   it('Should fail record with Date', () => {
     const T = Type.Record(Type.String(), Type.String())
     const result = Value.Check(T, new Date())
@@ -50,7 +66,6 @@ describe('value/check/Record', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
-
   it('Should fail record with invalid property', () => {
     const T = Type.Record(
       Type.String(),
@@ -70,7 +85,6 @@ describe('value/check/Record', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
-
   it('Should pass record with optional property', () => {
     const T = Type.Record(
       Type.String(),
@@ -89,7 +103,6 @@ describe('value/check/Record', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, true)
   })
-
   it('Should pass record with optional property', () => {
     const T = Type.Record(
       Type.String(),
@@ -108,11 +121,9 @@ describe('value/check/Record', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, true)
   })
-
   // -------------------------------------------------
   // Number Key
   // -------------------------------------------------
-
   it('Should pass record with number key', () => {
     const T = Type.Record(Type.Number(), Type.String())
     const value = {
@@ -134,11 +145,9 @@ describe('value/check/Record', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
-
   // -------------------------------------------------
   // Integer Key
   // -------------------------------------------------
-
   it('Should pass record with integer key', () => {
     const T = Type.Record(Type.Integer(), Type.String())
     const value = {
@@ -149,7 +158,6 @@ describe('value/check/Record', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, true)
   })
-
   it('Should not pass record with invalid integer key', () => {
     const T = Type.Record(Type.Integer(), Type.String())
     const value = {

From 8550c9d4b7692f8b989766509265634f136ff076 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 29 Mar 2023 14:21:32 +0900
Subject: [PATCH 084/369] Documentation

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 494f001e9..1aeec6580 100644
--- a/readme.md
+++ b/readme.md
@@ -447,7 +447,7 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │ const A = Type.Object({        │ type A = {                  │ const T = {                    │
 │    x: Type.Number(),           │   x: number,                │   $ref: 'A'                    │
 │    y: Type.Number()            │   y: number                 │ }                              │
-│ }, { $id: 'T' })               | }                           │                                │
+│ }, { $id: 'A' })               | }                           │                                │
 │                                │                             │                                │
 │ const T = Type.Ref(A)          │ type T = A                  │                                │
 │                                │                             │                                │

From c5d5018bbb45953444816047447f310eccb9a5e5 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 29 Mar 2023 14:23:07 +0900
Subject: [PATCH 085/369] Documentation

---
 readme.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/readme.md b/readme.md
index 1aeec6580..265d408e4 100644
--- a/readme.md
+++ b/readme.md
@@ -444,12 +444,12 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const A = Type.Object({        │ type A = {                  │ const T = {                    │
-│    x: Type.Number(),           │   x: number,                │   $ref: 'A'                    │
+│ const T = Type.Object({        │ type T = {                  │ const R = {                    │
+│    x: Type.Number(),           │   x: number,                │   $ref: 'T'                    │
 │    y: Type.Number()            │   y: number                 │ }                              │
-│ }, { $id: 'A' })               | }                           │                                │
+│ }, { $id: 'T' })               | }                           │                                │
 │                                │                             │                                │
-│ const T = Type.Ref(A)          │ type T = A                  │                                │
+│ const R = Type.Ref(T)          │ type R = T                  │                                │
 │                                │                             │                                │
 │                                │                             │                                │
 │                                │                             │                                │

From 31d0e8b1e1f3275bb15f1239cbeb849f4459c837 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 29 Mar 2023 17:01:08 +0900
Subject: [PATCH 086/369] Support Recursive Type Code Generation

---
 codegen/typescript-to-typebox.ts | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/codegen/typescript-to-typebox.ts b/codegen/typescript-to-typebox.ts
index a42f11750..f2167c538 100644
--- a/codegen/typescript-to-typebox.ts
+++ b/codegen/typescript-to-typebox.ts
@@ -35,6 +35,12 @@ import * as ts from 'typescript'
 
 /** Generates TypeBox types from TypeScript code */
 export namespace TypeScriptToTypeBox {
+  function isRecursiveType(decl: ts.InterfaceDeclaration | ts.TypeAliasDeclaration) {
+    function find(decl: ts.InterfaceDeclaration | ts.TypeAliasDeclaration, node: ts.Node): boolean {
+      return (ts.isTypeReferenceNode(node) && decl.name.getText() === node.getText()) || node.getChildren().some((node) => find(decl, node))
+    }
+    return ts.isTypeAliasDeclaration(decl) ? [decl.type].some((node) => find(decl, node)) : decl.members.some((node) => find(decl, node))
+  }
   function isReadonlyProperty(node: ts.PropertySignature): boolean {
     return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'readonly') !== undefined
   }
@@ -110,6 +116,7 @@ export namespace TypeScriptToTypeBox {
   }
   function* InterfaceDeclaration(node: ts.InterfaceDeclaration): IterableIterator<string> {
     useImports = true
+    const heritage = node.heritageClauses !== undefined ? node.heritageClauses.flatMap((node) => node.types.map((node) => node.getText())) : []
     if (node.typeParameters) {
       useGenerics = true
       const exports = isExport(node) ? 'export ' : ''
@@ -118,13 +125,17 @@ export namespace TypeScriptToTypeBox {
       const names = node.typeParameters.map((param) => `${Collect(param)}`).join(', ')
       const members = node.members.map((member) => Collect(member)).join(',\n')
       const staticDeclaration = `${exports}type ${node.name.getText()}<${constraints}> = Static<ReturnType<typeof ${node.name.getText()}<${names}>>>`
-      const typeDeclaration = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => Type.Object({\n${members}\n})`
+      const rawTypeExpression = isRecursiveType(node) ? `Type.Recursive(${node.name.getText()} => Type.Object({\n${members}\n}))` : `Type.Object({\n${members}\n})`
+      const typeExpression = heritage.length === 0 ? rawTypeExpression : `Type.Intersect([${heritage.join(', ')}, ${rawTypeExpression}])`
+      const typeDeclaration = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${typeExpression}`
       yield `${staticDeclaration}\n${typeDeclaration}`
     } else {
       const exports = isExport(node) ? 'export ' : ''
       const members = node.members.map((member) => Collect(member)).join(',\n')
       const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`
-      const typeDeclaration = `${exports}const ${node.name.getText()} = Type.Object({\n${members}\n})`
+      const rawTypeExpression = isRecursiveType(node) ? `Type.Recursive(${node.name.getText()} => Type.Object({\n${members}\n}))` : `Type.Object({\n${members}\n})`
+      const typeExpression = heritage.length === 0 ? rawTypeExpression : `Type.Intersect([${heritage.join(', ')}, ${rawTypeExpression}])`
+      const typeDeclaration = `${exports}const ${node.name.getText()} = ${typeExpression}`
       yield `${staticDeclaration}\n${typeDeclaration}`
     }
   }
@@ -138,13 +149,15 @@ export namespace TypeScriptToTypeBox {
       const names = node.typeParameters.map((param) => Collect(param)).join(', ')
       const type = Collect(node.type)
       const staticDeclaration = `${exports}type ${node.name.getText()}<${constraints}> = Static<ReturnType<typeof ${node.name.getText()}<${names}>>>`
-      const typeDeclaration = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${type}`
+      const typeDeclaration = isRecursiveType(node)
+        ? `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => Type.Recursive(${node.name.getText()} => ${type})`
+        : `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${type}`
       yield `${staticDeclaration}\n${typeDeclaration}`
     } else {
       const exports = isExport(node) ? 'export ' : ''
       const type = Collect(node.type)
       const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`
-      const typeDeclaration = `${exports}const ${node.name.getText()} = ${type}`
+      const typeDeclaration = isRecursiveType(node) ? `${exports}const ${node.name.getText()} = Type.Recursive(${node.name.getText()} => ${type})` : `${exports}const ${node.name.getText()} = ${type}`
       yield `${staticDeclaration}\n${typeDeclaration}`
     }
   }

From d79e53fd6f7f17840f88c87989ad263ba7c8ef52 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 29 Mar 2023 18:22:14 +0900
Subject: [PATCH 087/369] Support Recursive Type Code Generation

---
 codegen/typescript-to-typebox.ts | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/codegen/typescript-to-typebox.ts b/codegen/typescript-to-typebox.ts
index f2167c538..2fbba9181 100644
--- a/codegen/typescript-to-typebox.ts
+++ b/codegen/typescript-to-typebox.ts
@@ -116,7 +116,8 @@ export namespace TypeScriptToTypeBox {
   }
   function* InterfaceDeclaration(node: ts.InterfaceDeclaration): IterableIterator<string> {
     useImports = true
-    const heritage = node.heritageClauses !== undefined ? node.heritageClauses.flatMap((node) => node.types.map((node) => node.getText())) : []
+    const heritage = node.heritageClauses !== undefined ? node.heritageClauses.flatMap((node) => Collect(node)) : []
+    console.log('123', heritage)
     if (node.typeParameters) {
       useGenerics = true
       const exports = isExport(node) ? 'export ' : ''
@@ -161,6 +162,17 @@ export namespace TypeScriptToTypeBox {
       yield `${staticDeclaration}\n${typeDeclaration}`
     }
   }
+  function* HeritageClause(node: ts.HeritageClause): IterableIterator<string> {
+    const types = node.types.map((node) => Collect(node))
+    if (types.length === 1) return yield types[0]
+    yield `Type.Intersect([${types.join(', ')}])`
+  }
+  function* ExpressionWithTypeArguments(node: ts.ExpressionWithTypeArguments): IterableIterator<string> {
+    const name = Collect(node.expression)
+    const typeArguments = node.typeArguments === undefined ? [] : node.typeArguments.map((node) => Collect(node))
+    // todo: default type argument (resolve `= number` from `type Foo<T = number>`)
+    return yield typeArguments.length === 0 ? `${name}` : `${name}(${typeArguments.join(', ')})`
+  }
   function* TypeParameterDeclaration(node: ts.TypeParameterDeclaration): IterableIterator<string> {
     yield node.name.getText()
   }
@@ -283,6 +295,10 @@ export namespace TypeScriptToTypeBox {
       return yield* UnionTypeNode(node)
     } else if (ts.isTypeOperatorNode(node)) {
       return yield* TypeOperatorNode(node)
+    } else if (ts.isHeritageClause(node)) {
+      return yield* HeritageClause(node)
+    } else if (ts.isExpressionWithTypeArguments(node)) {
+      return yield* ExpressionWithTypeArguments(node)
     } else if (ts.isTypeParameterDeclaration(node)) {
       return yield* TypeParameterDeclaration(node)
     } else if (ts.isParenthesizedTypeNode(node)) {
@@ -295,6 +311,8 @@ export namespace TypeScriptToTypeBox {
       return yield* ClassDeclaration(node)
     } else if (ts.isConditionalTypeNode(node)) {
       return yield* ConditionalTypeNode(node)
+    } else if (ts.isIdentifier(node)) {
+      return yield node.getText()
     } else if (node.kind === ts.SyntaxKind.ExportKeyword) {
       return yield `export`
     } else if (node.kind === ts.SyntaxKind.KeyOfKeyword) {

From b9db76267915eafb9db9b7f46d8aee465ae70cff Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 29 Mar 2023 18:23:20 +0900
Subject: [PATCH 088/369] Support Recursive Type Code Generation

---
 codegen/typescript-to-typebox.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/codegen/typescript-to-typebox.ts b/codegen/typescript-to-typebox.ts
index 2fbba9181..5320aa418 100644
--- a/codegen/typescript-to-typebox.ts
+++ b/codegen/typescript-to-typebox.ts
@@ -117,7 +117,6 @@ export namespace TypeScriptToTypeBox {
   function* InterfaceDeclaration(node: ts.InterfaceDeclaration): IterableIterator<string> {
     useImports = true
     const heritage = node.heritageClauses !== undefined ? node.heritageClauses.flatMap((node) => Collect(node)) : []
-    console.log('123', heritage)
     if (node.typeParameters) {
       useGenerics = true
       const exports = isExport(node) ? 'export ' : ''

From e4d7378f890b65df9ebd0a7a0801424f06274be4 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 30 Mar 2023 03:10:59 +0900
Subject: [PATCH 089/369] TypeGuard for Raw TUnsafe (#365)

---
 package.json                      |  2 +-
 src/typebox.ts                    |  9 +++++++++
 test/runtime/compiler/partial.ts  | 19 +++++++++++++++++-
 test/runtime/type/guard/index.ts  |  1 +
 test/runtime/type/guard/unsafe.ts | 32 +++++++++++++++++++++++++++++++
 5 files changed, 61 insertions(+), 2 deletions(-)
 create mode 100644 test/runtime/type/guard/unsafe.ts

diff --git a/package.json b/package.json
index 836dbee68..aa248455b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.26.7",
+  "version": "0.26.8",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index de0334021..9887da23e 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -1112,6 +1112,14 @@ export namespace TypeGuard {
       IsOptionalString(schema.$id)
     )
   }
+  /** Returns true if the given schema is a raw TUnsafe */
+  export function TUnsafe(schema: unknown): schema is TUnsafe<unknown> {
+    // prettier-ignore
+    return (
+      TKind(schema) && 
+      schema[Kind] === 'Unsafe'
+    )
+  }
   /** Returns true if the given schema is TVoid */
   export function TVoid(schema: unknown): schema is TVoid {
     // prettier-ignore
@@ -1165,6 +1173,7 @@ export namespace TypeGuard {
         TUnion(schema) ||
         TUint8Array(schema) ||
         TUnknown(schema) ||
+        TUnsafe(schema) ||
         TVoid(schema) ||
         (TKind(schema) && TypeRegistry.Has(schema[Kind] as any)))
     )
diff --git a/test/runtime/compiler/partial.ts b/test/runtime/compiler/partial.ts
index 6f11fb90b..e295aa6b9 100644
--- a/test/runtime/compiler/partial.ts
+++ b/test/runtime/compiler/partial.ts
@@ -1,4 +1,5 @@
-import { Type, Modifier } from '@sinclair/typebox'
+import { TypeSystem } from '@sinclair/typebox/system'
+import { Type, Kind, Modifier } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
@@ -49,4 +50,20 @@ describe('type/compiler/Partial', () => {
     strictEqual(A.additionalProperties, false)
     strictEqual(T.additionalProperties, false)
   })
+  it('Should support partial properties of raw TUnsafe', () => {
+    // https://github.com/sinclairzx81/typebox/issues/364
+    const T = Type.Partial(Type.Object({ x: Type.Unsafe({ x: 1 }) }))
+    strictEqual(T.required, undefined)
+  })
+  it('Should not support partial properties of unknown TUnsafe', () => {
+    // https://github.com/sinclairzx81/typebox/issues/364
+    const T = Type.Partial(Type.Object({ x: Type.Unsafe({ [Kind]: 'UnknownPartialType', x: 1 }) }))
+    strictEqual(T.required![0], 'x')
+  })
+  it('Should support partial properties of custom TUnsafe', () => {
+    // https://github.com/sinclairzx81/typebox/issues/364
+    const U = TypeSystem.Type('CustomPartialType', () => true)
+    const T = Type.Partial(Type.Object({ x: U() }))
+    strictEqual(T.required, undefined)
+  })
 })
diff --git a/test/runtime/type/guard/index.ts b/test/runtime/type/guard/index.ts
index 991f457ee..28cc9f5c8 100644
--- a/test/runtime/type/guard/index.ts
+++ b/test/runtime/type/guard/index.ts
@@ -26,4 +26,5 @@ import './uint8array'
 import './undefined'
 import './union'
 import './unknown'
+import './unsafe'
 import './void'
diff --git a/test/runtime/type/guard/unsafe.ts b/test/runtime/type/guard/unsafe.ts
new file mode 100644
index 000000000..8cb296441
--- /dev/null
+++ b/test/runtime/type/guard/unsafe.ts
@@ -0,0 +1,32 @@
+import { Kind, TypeGuard, TypeRegistry } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TUnsafe', () => {
+  it('Should guard raw TUnsafe', () => {
+    const T = Type.Unsafe({ x: 1 })
+    const R = TypeGuard.TUnsafe(T)
+    Assert.equal(R, true)
+  })
+  it('Should guard raw TUnsafe as TSchema', () => {
+    const T = Type.Unsafe({ x: 1 })
+    const R = TypeGuard.TSchema(T)
+    Assert.equal(R, true)
+  })
+  it('Should guard override TUnsafe as TSchema when registered', () => {
+    TypeRegistry.Set('type/guard/TUnsafe/Type1', () => true)
+    const T = Type.Unsafe({ [Kind]: 'type/guard/TUnsafe/Type1' })
+    const R = TypeGuard.TSchema(T)
+    Assert.equal(R, true)
+  })
+  it('Should not guard TUnsafe with unregistered kind', () => {
+    const T = Type.Unsafe({ [Kind]: 'type/guard/TUnsafe/Type2' })
+    const R = TypeGuard.TUnsafe(T)
+    Assert.equal(R, false)
+  })
+  it('Should not guard for TString', () => {
+    const T = Type.String()
+    const R = TypeGuard.TUnsafe(T)
+    Assert.equal(R, false)
+  })
+})

From 53f7d55ecab20267661e6fe3621b6014baa04bcd Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Thu, 30 Mar 2023 05:22:22 +0900
Subject: [PATCH 090/369] Support Recursive Type Generation

---
 codegen/typescript-to-typebox.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/codegen/typescript-to-typebox.ts b/codegen/typescript-to-typebox.ts
index 5320aa418..ea3eead7e 100644
--- a/codegen/typescript-to-typebox.ts
+++ b/codegen/typescript-to-typebox.ts
@@ -318,6 +318,8 @@ export namespace TypeScriptToTypeBox {
       return yield `Type.KeyOf()`
     } else if (node.kind === ts.SyntaxKind.NumberKeyword) {
       return yield `Type.Number()`
+    } else if (node.kind === ts.SyntaxKind.BigIntKeyword) {
+      return yield `Type.BigInt()`
     } else if (node.kind === ts.SyntaxKind.StringKeyword) {
       return yield `Type.String()`
     } else if (node.kind === ts.SyntaxKind.BooleanKeyword) {

From a123d05487ba005fca8062d5e54d0fdf0d4aace4 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sun, 2 Apr 2023 23:55:44 +0900
Subject: [PATCH 091/369] Legacy Intersect Implementation

---
 example/legacy/index.ts     | 29 ++++++++++++++++
 example/legacy/intersect.ts | 66 +++++++++++++++++++++++++++++++++++++
 2 files changed, 95 insertions(+)
 create mode 100644 example/legacy/index.ts
 create mode 100644 example/legacy/intersect.ts

diff --git a/example/legacy/index.ts b/example/legacy/index.ts
new file mode 100644
index 000000000..79f17933b
--- /dev/null
+++ b/example/legacy/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/legacy
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './intersect'
\ No newline at end of file
diff --git a/example/legacy/intersect.ts b/example/legacy/intersect.ts
new file mode 100644
index 000000000..d2fbd9545
--- /dev/null
+++ b/example/legacy/intersect.ts
@@ -0,0 +1,66 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/legacy
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TObject, ObjectOptions, Modifier, Kind, TSchema, Static } from '@sinclair/typebox'
+
+export type IntersectLegacyReduce<I extends unknown, T extends readonly any[]> = T extends [infer A, ...infer B] ? IntersectLegacyReduce<I & A, B> : I extends object ? I : {}
+export type IntersectLegacyEvaluate<T extends readonly TObject[], P extends unknown[]> = { [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never }
+export type IntersectLegacyProperties<T extends readonly TObject[]> = {
+  [K in keyof T]: T[K] extends TObject<infer P> ? P : {}
+}
+export interface TIntersectLegacy<T extends TObject[] = TObject[]> extends TObject {
+  static: IntersectLegacyReduce<unknown, IntersectLegacyEvaluate<T, this['params']>>
+  properties: IntersectLegacyReduce<unknown, IntersectLegacyProperties<T>>
+}
+
+/** `Legacy` Creates a legacy intersect type. */
+export function IntersectLegacy<T extends TObject[]>(objects: [...T], options: ObjectOptions = {}): TIntersectLegacy<T> {
+  const isOptional = (schema: TSchema) => (schema[Modifier] && schema[Modifier] === 'Optional') || schema[Modifier] === 'ReadonlyOptional'
+  const [required, optional] = [new Set<string>(), new Set<string>()]
+  for (const object of objects) {
+    for (const [key, schema] of Object.entries(object.properties)) {
+      if (isOptional(schema)) optional.add(key)
+    }
+  }
+  for (const object of objects) {
+    for (const key of Object.keys(object.properties)) {
+      if (!optional.has(key)) required.add(key)
+    }
+  }
+  const properties = {} as Record<string, any>
+  for (const object of objects) {
+    for (const [key, schema] of Object.entries(object.properties)) {
+      properties[key] = properties[key] === undefined ? schema : { [Kind]: 'Union', anyOf: [properties[key], { ...schema }] }
+    }
+  }
+  if (required.size > 0) {
+    return { ...options, [Kind]: 'Object', type: 'object', properties, required: [...required] } as any
+  } else {
+    return { ...options, [Kind]: 'Object', type: 'object', properties } as any
+  }
+}

From efb0cd425fb2e948203a943ca5ce20971d829955 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 4 Apr 2023 06:04:33 +0900
Subject: [PATCH 092/369] Enhanced Compiler Code Generation

---
 codegen/tsconfig.json                         |   4 -
 {codegen => example/codegen}/formatter.ts     |  35 +++--
 {codegen => example/codegen}/index.ts         |   0
 example/codegen/tsconfig.json                 |   4 +
 .../codegen}/typebox-to-typescript.ts         |   0
 .../codegen}/typebox-to-zod.ts                |   0
 .../codegen}/typescript-to-json-schema.ts     | 145 +++++++-----------
 .../codegen}/typescript-to-typebox.ts         |  82 ++++++----
 hammer.mjs                                    |   2 +-
 tsconfig.json                                 |   3 -
 10 files changed, 139 insertions(+), 136 deletions(-)
 delete mode 100644 codegen/tsconfig.json
 rename {codegen => example/codegen}/formatter.ts (62%)
 rename {codegen => example/codegen}/index.ts (100%)
 create mode 100644 example/codegen/tsconfig.json
 rename {codegen => example/codegen}/typebox-to-typescript.ts (100%)
 rename {codegen => example/codegen}/typebox-to-zod.ts (100%)
 rename {codegen => example/codegen}/typescript-to-json-schema.ts (79%)
 rename {codegen => example/codegen}/typescript-to-typebox.ts (83%)

diff --git a/codegen/tsconfig.json b/codegen/tsconfig.json
deleted file mode 100644
index 9f4a7e200..000000000
--- a/codegen/tsconfig.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "files": ["index.ts"]
-}
diff --git a/codegen/formatter.ts b/example/codegen/formatter.ts
similarity index 62%
rename from codegen/formatter.ts
rename to example/codegen/formatter.ts
index 68d8cd440..ffa6b58c2 100644
--- a/codegen/formatter.ts
+++ b/example/codegen/formatter.ts
@@ -27,19 +27,36 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 export namespace Formatter {
-  // Code formatter
+  export function Includes(line: string, token: string) {
+    return line.includes(token)
+  }
+  function IntentBefore(line: string) {
+    if (Includes(line, '({') && Includes(line, '})')) return 0
+    if (Includes(line, '([') && Includes(line, '])')) return 0
+    if (Includes(line, '{') && Includes(line, '}')) return 0
+    if (Includes(line, '])')) return -1
+    if (Includes(line, '})')) return -1
+    if (Includes(line, '}')) return -1
+    if (Includes(line, ']')) return -1
+    return 0
+  }
+  function IndentAfter(line: string) {
+    if (Includes(line, '({') && Includes(line, '})')) return 0
+    if (Includes(line, '([') && Includes(line, '])')) return 0
+    if (Includes(line, '{') && Includes(line, '}')) return 0
+    if (Includes(line, '([')) return 1
+    if (Includes(line, '({')) return 1
+    if (Includes(line, '{')) return 1
+    if (Includes(line, '[')) return 1
+    return 0
+  }
   export function Format(input: string): string {
-    function count(line: string, opens: string[]) {
-      const codes = opens.map((open) => open.charCodeAt(0))
-      // prettier-ignore
-      return line.split('').map((char) => char.charCodeAt(0)).reduce((acc, current) => codes.includes(current) ? acc + 1 : acc, 0)
-    }
-    let indent = 0
     const output: string[] = []
+    let indent = 0
     for (const line of input.split('\n').map((n) => n.trim())) {
-      indent -= count(line, ['}'])
+      indent += IntentBefore(line)
       output.push(`${''.padStart(indent * 2, ' ')}${line}`)
-      indent += count(line, ['{'])
+      indent += IndentAfter(line)
     }
     return output.join('\n')
   }
diff --git a/codegen/index.ts b/example/codegen/index.ts
similarity index 100%
rename from codegen/index.ts
rename to example/codegen/index.ts
diff --git a/example/codegen/tsconfig.json b/example/codegen/tsconfig.json
new file mode 100644
index 000000000..6710ecd93
--- /dev/null
+++ b/example/codegen/tsconfig.json
@@ -0,0 +1,4 @@
+{
+  "extends": "../../tsconfig.json",
+  "files": ["index.ts"]
+}
diff --git a/codegen/typebox-to-typescript.ts b/example/codegen/typebox-to-typescript.ts
similarity index 100%
rename from codegen/typebox-to-typescript.ts
rename to example/codegen/typebox-to-typescript.ts
diff --git a/codegen/typebox-to-zod.ts b/example/codegen/typebox-to-zod.ts
similarity index 100%
rename from codegen/typebox-to-zod.ts
rename to example/codegen/typebox-to-zod.ts
diff --git a/codegen/typescript-to-json-schema.ts b/example/codegen/typescript-to-json-schema.ts
similarity index 79%
rename from codegen/typescript-to-json-schema.ts
rename to example/codegen/typescript-to-json-schema.ts
index 2f198dbcb..3318fa63d 100644
--- a/codegen/typescript-to-json-schema.ts
+++ b/example/codegen/typescript-to-json-schema.ts
@@ -29,17 +29,6 @@ THE SOFTWARE.
 import { Formatter } from './formatter'
 import * as ts from 'typescript'
 
-// --------------------------------------------------------------------------
-// Errors
-// --------------------------------------------------------------------------
-export class TypeScriptToJsonSchemaNonExpressable extends Error {
-  constructor(type: string) {
-    super(`TypeScriptToJsonSchema: Cannot express syntax type '${type}'`)
-  }
-}
-// --------------------------------------------------------------------------
-// Transform
-// --------------------------------------------------------------------------
 export namespace TypeScriptToJsonSchema {
   function isReadonlyProperty(node: ts.PropertySignature): boolean {
     return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'readonly') !== undefined
@@ -101,16 +90,16 @@ export namespace TypeScriptToJsonSchema {
     }`
   }
   function* TypeOperatorNode(node: ts.TypeOperatorNode): IterableIterator<string> {
-    throw new TypeScriptToJsonSchemaNonExpressable('TypeOperatorNode')
+    return yield UnknownType('TypeOperatorNode')
   }
   function* Parameter(node: ts.ParameterDeclaration): IterableIterator<string> {
     yield Collect(node.type)
   }
   function* FunctionTypeNode(node: ts.FunctionTypeNode): IterableIterator<string> {
-    throw new TypeScriptToJsonSchemaNonExpressable('FunctionTypeNode')
+    return yield UnknownType('FunctionTypeNode')
   }
   function* ConstructorTypeNode(node: ts.ConstructorTypeNode): IterableIterator<string> {
-    throw new TypeScriptToJsonSchemaNonExpressable('ConstructorTypeNode')
+    return yield UnknownType('ConstructorTypeNode')
   }
   function* EnumMember(node: ts.EnumMember): IterableIterator<string> {
     if (node.initializer) {
@@ -136,20 +125,19 @@ export namespace TypeScriptToJsonSchema {
     if (node.typeParameters) {
       const exports = isExport(node) ? 'export ' : ''
       const members = node.members.map((member) => Collect(member)).join(',\n')
-      const required = node.members
-        .filter((member) => member.questionToken === undefined)
-        .map((member) => `'${member.name?.getText()}'`)
-        .join(',\n')
-      const parameters = node.typeParameters.map((param) => `${Collect(param)}`).join(', ')
-      const definition = `${exports}const ${node.name.getText()} = (${parameters}) => {
-        type: 'object,
+      // prettier-ignore
+      const required = node.members.filter((member) => member.questionToken === undefined).map((member) => `'${member.name?.getText()}'`).join(',\n')
+      const constraints = node.typeParameters.map((param) => `${Collect(param)}`).join(', ')
+      const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(', ')
+      const definition = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ({
+        type: 'object',
         properties: {
           ${members}
         },
         required: [
           ${required}
         ],
-      }`
+      })`
       yield `${definition}`
     } else {
       const exports = isExport(node) ? 'export ' : ''
@@ -170,13 +158,13 @@ export namespace TypeScriptToJsonSchema {
       yield `${definition}`
     }
   }
-
   function* TypeAliasDeclaration(node: ts.TypeAliasDeclaration): IterableIterator<string> {
     if (node.typeParameters) {
       const exports = isExport(node) ? 'export ' : ''
-      const parameters = node.typeParameters.map((param) => `${Collect(param)}`).join(', ')
+      const constraints = node.typeParameters.map((param) => `${Collect(param)}`).join(', ')
+      const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(', ')
       const type = Collect(node.type)
-      const definition = `${exports}const ${node.name.getText()} = (${parameters}) => ${type}`
+      const definition = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => (${type})`
       yield `${definition}`
     } else {
       const exports = isExport(node) ? 'export ' : ''
@@ -185,62 +173,53 @@ export namespace TypeScriptToJsonSchema {
       yield `${definition}`
     }
   }
-
   function* TypeParameterDeclaration(node: ts.TypeParameterDeclaration): IterableIterator<string> {
     yield node.name.getText()
   }
-
   function* ParenthesizedTypeNode(node: ts.ParenthesizedTypeNode): IterableIterator<string> {
     yield Collect(node.type)
   }
-
   function* RestTypeNode(node: ts.RestTypeNode): IterableIterator<string> {
-    throw new TypeScriptToJsonSchemaNonExpressable('RestTypeNode')
+    return yield UnknownType('RestTypeNode')
   }
-
   function* ConditionalTypeNode(node: ts.ConditionalTypeNode): IterableIterator<string> {
-    throw new TypeScriptToJsonSchemaNonExpressable('ConditionalTypeNode')
+    return yield UnknownType('ConditionalTypeNode')
   }
-
   function* TypeReferenceNode(node: ts.TypeReferenceNode): IterableIterator<string> {
     const name = node.typeName.getText()
     const args = node.typeArguments ? `(${node.typeArguments.map((type) => Collect(type)).join(', ')})` : ''
     if (name === 'Array') {
-      return yield `{
-        type: 'array',
-        items: ${args}
-      }`
+      return yield `{ type: 'array', items: ${args} }`
     } else if (name === 'Record') {
-      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Record')
+      return yield UnknownType('Record')
     } else if (name === 'Partial') {
-      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Partial')
+      return yield UnknownType('Partial')
     } else if (name === 'Uint8Array') {
-      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Uint8Array')
+      return yield UnknownType('Uint8Array')
     } else if (name === 'Required') {
-      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Required')
+      return yield UnknownType('Required')
     } else if (name === 'Omit') {
-      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Omit')
+      return yield UnknownType('Omit')
     } else if (name === 'Pick') {
-      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Pick')
+      return yield UnknownType('Pick')
     } else if (name === 'Promise') {
-      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Promise')
+      return yield UnknownType('Promise')
     } else if (name === 'ReturnType') {
-      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:ReturnType')
+      return yield UnknownType('ReturnType')
     } else if (name === 'InstanceType') {
-      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:InstanceType')
+      return yield UnknownType('InstanceType')
     } else if (name === 'Parameters') {
-      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Parameters')
+      return yield UnknownType('Parameters')
     } else if (name === 'ConstructorParameters') {
-      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:ConstructorParameters')
+      return yield UnknownType('ConstructorParameters')
     } else if (name === 'Exclude') {
-      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Exclude')
+      return yield UnknownType('Exclude')
     } else if (name === 'Extract') {
-      throw new TypeScriptToJsonSchemaNonExpressable('TypeReferenceNode:Extract')
+      return yield UnknownType('Extract')
     } else {
       return yield `${name}${args}`
     }
   }
-
   function* TypeLiteralNode(node: ts.TypeLiteralNode): IterableIterator<string> {
     const members = node.members.map((member) => Collect(member)).join(',\n')
     const required = node.members
@@ -257,7 +236,6 @@ export namespace TypeScriptToJsonSchema {
       ]
     }`
   }
-
   function* LiteralTypeNode(node: ts.LiteralTypeNode): IterableIterator<string> {
     const text = node.getText()
     if (text === 'null')
@@ -268,23 +246,24 @@ export namespace TypeScriptToJsonSchema {
       const: ${node.getText()} 
     }`
   }
-
   function* FunctionDeclaration(node: ts.FunctionDeclaration): IterableIterator<string> {
     yield node.getText()
   }
-
   function* ClassDeclaration(node: ts.ClassDeclaration): IterableIterator<string> {
     yield node.getText()
   }
-
   function Collect(node: ts.Node | undefined): string {
     return `${[...Visit(node)].join('')}`
   }
-
   function CollectNewLine(node: ts.Node | undefined): string {
     return [...Visit(node)].join('\n\n')
   }
-
+  function UnknownType(name: string = 'Unknown'): string {
+    return `{ not: { /* unsupported type '${name}' */ } }`
+  }
+  function KnownType(type: string): string {
+    return ['{', `type: '${type}'`, '}'].join('\n')
+  }
   function* Visit(node: ts.Node | undefined): IterableIterator<string> {
     if (node === undefined) return
     if (ts.isSourceFile(node)) {
@@ -333,49 +312,32 @@ export namespace TypeScriptToJsonSchema {
       return yield* ClassDeclaration(node)
     } else if (ts.isConditionalTypeNode(node)) {
       return yield* ConditionalTypeNode(node)
+    } else if (ts.isIdentifier(node)) {
+      return yield node.getText()
+    } else if (node.kind === ts.SyntaxKind.ExportKeyword) {
+      return yield `export`
     } else if (node.kind === ts.SyntaxKind.KeyOfKeyword) {
-      throw new TypeScriptToJsonSchemaNonExpressable('KeyOfKeyword')
+      return yield UnknownType()
     } else if (node.kind === ts.SyntaxKind.NumberKeyword) {
-      return yield `{ 
-        type: 'number' 
-      }`
+      return yield KnownType('number')
+    } else if (node.kind === ts.SyntaxKind.BigIntKeyword) {
+      return yield UnknownType()
     } else if (node.kind === ts.SyntaxKind.StringKeyword) {
-      return yield `{ 
-        type: 'string' 
-      }`
+      return yield KnownType('string')
     } else if (node.kind === ts.SyntaxKind.BooleanKeyword) {
-      return yield `{ 
-        type: 'boolean' 
-      }`
+      return yield KnownType('boolean')
     } else if (node.kind === ts.SyntaxKind.UndefinedKeyword) {
-      throw new TypeScriptToJsonSchemaNonExpressable('UndefinedKeyword')
+      return yield UnknownType('undefined')
     } else if (node.kind === ts.SyntaxKind.UnknownKeyword) {
-      return yield `{
-
-      }`
+      return yield `{ }`
     } else if (node.kind === ts.SyntaxKind.AnyKeyword) {
-      return yield `{ 
-
-      }`
+      return yield `{ }`
     } else if (node.kind === ts.SyntaxKind.NeverKeyword) {
-      return yield `{
-        anyOf: [
-          { 
-            type: 'boolean', 
-            const: true 
-          }, 
-          { 
-            type: 'boolean', 
-            const: false 
-          }
-        ]
-      }`
+      return yield `{ not: { } }`
     } else if (node.kind === ts.SyntaxKind.NullKeyword) {
-      return yield `{ 
-        type: 'null' 
-      }`
+      return yield KnownType('null')
     } else if (node.kind === ts.SyntaxKind.VoidKeyword) {
-      throw new TypeScriptToJsonSchemaNonExpressable('KeyOfKeyword')
+      return yield UnknownType('void')
     } else if (node.kind === ts.SyntaxKind.EndOfFileToken) {
       return
     } else if (node.kind === ts.SyntaxKind.SyntaxList) {
@@ -388,12 +350,11 @@ export namespace TypeScriptToJsonSchema {
       return yield node.getText()
     }
   }
-
-  /** Generates TypeBox types from TypeScript interface and type definitions */
+  /** Generates JsonSchema schematics from TypeScript interface and type definitions */
   export function Generate(typescriptCode: string) {
     const source = ts.createSourceFile('code.ts', typescriptCode, ts.ScriptTarget.ESNext, true)
     const declarations = CollectNewLine(source)
     const types = Formatter.Format(declarations)
     return [types].join('\n')
   }
-}
+}
\ No newline at end of file
diff --git a/codegen/typescript-to-typebox.ts b/example/codegen/typescript-to-typebox.ts
similarity index 83%
rename from codegen/typescript-to-typebox.ts
rename to example/codegen/typescript-to-typebox.ts
index ea3eead7e..97f5b46d7 100644
--- a/codegen/typescript-to-typebox.ts
+++ b/example/codegen/typescript-to-typebox.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+
 import { Formatter } from './formatter'
 import * as ts from 'typescript'
 
@@ -35,22 +36,30 @@ import * as ts from 'typescript'
 
 /** Generates TypeBox types from TypeScript code */
 export namespace TypeScriptToTypeBox {
-  function isRecursiveType(decl: ts.InterfaceDeclaration | ts.TypeAliasDeclaration) {
-    function find(decl: ts.InterfaceDeclaration | ts.TypeAliasDeclaration, node: ts.Node): boolean {
-      return (ts.isTypeReferenceNode(node) && decl.name.getText() === node.getText()) || node.getChildren().some((node) => find(decl, node))
-    }
-    return ts.isTypeAliasDeclaration(decl) ? [decl.type].some((node) => find(decl, node)) : decl.members.some((node) => find(decl, node))
+  // tracked for recursive types and used to associate This type references
+  let recursiveDeclaration: ts.TypeAliasDeclaration | ts.InterfaceDeclaration | null = null
+  // tracked for injecting typebox import statements
+  let useImports = false
+  // tracked for injecting TSchema import statements
+  let useGenerics = false
+  // tracked for each generated type.
+  const typeNames = new Set<string>()
+  function FindRecursiveParent(decl: ts.InterfaceDeclaration | ts.TypeAliasDeclaration, node: ts.Node): boolean {
+    return (ts.isTypeReferenceNode(node) && decl.name.getText() === node.typeName.getText()) || node.getChildren().some((node) => FindRecursiveParent(decl, node))
+  }
+  function IsRecursiveType(decl: ts.InterfaceDeclaration | ts.TypeAliasDeclaration) {
+    return ts.isTypeAliasDeclaration(decl) ? [decl.type].some((node) => FindRecursiveParent(decl, node)) : decl.members.some((node) => FindRecursiveParent(decl, node))
   }
-  function isReadonlyProperty(node: ts.PropertySignature): boolean {
+  function IsReadonlyProperty(node: ts.PropertySignature): boolean {
     return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'readonly') !== undefined
   }
-  function isOptionalProperty(node: ts.PropertySignature) {
+  function IsOptionalProperty(node: ts.PropertySignature) {
     return node.questionToken !== undefined
   }
-  function isExport(node: ts.InterfaceDeclaration | ts.TypeAliasDeclaration | ts.EnumDeclaration | ts.ModuleDeclaration): boolean {
+  function IsExport(node: ts.InterfaceDeclaration | ts.TypeAliasDeclaration | ts.EnumDeclaration | ts.ModuleDeclaration): boolean {
     return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'export') !== undefined
   }
-  function isNamespace(node: ts.ModuleDeclaration) {
+  function IsNamespace(node: ts.ModuleDeclaration) {
     return node.flags === ts.NodeFlags.Namespace
   }
   function* SourceFile(node: ts.SourceFile): IterableIterator<string> {
@@ -59,7 +68,7 @@ export namespace TypeScriptToTypeBox {
     }
   }
   function* PropertySignature(node: ts.PropertySignature): IterableIterator<string> {
-    const [readonly, optional] = [isReadonlyProperty(node), isOptionalProperty(node)]
+    const [readonly, optional] = [IsReadonlyProperty(node), IsOptionalProperty(node)]
     const type = Collect(node.type)
     if (readonly && optional) {
       return yield `${node.name.getText()}: Type.ReadonlyOptional(${type})`
@@ -107,59 +116,68 @@ export namespace TypeScriptToTypeBox {
     yield `Type.Constructor([${parameters}], ${returns})`
   }
   function* EnumDeclaration(node: ts.EnumDeclaration): IterableIterator<string> {
-    const exports = isExport(node) ? 'export ' : ''
-    const name = node.name.getText()
+    useImports = true
+    const exports = IsExport(node) ? 'export ' : ''
     const members = node.members.map((member) => member.getText()).join(', ')
-    const enumType = `${exports}enum ${name}Enum { ${members} }`
-    const type = `${exports}const ${name} = Type.Enum(${name}Enum)`
+    const enumType = `${exports}enum ${node.name.getText()}Enum { ${members} }`
+    const type = `${exports}const ${node.name.getText()} = Type.Enum(${node.name.getText()}Enum)`
     yield [enumType, '', type].join('\n')
+    typeNames.add(node.name.getText())
   }
   function* InterfaceDeclaration(node: ts.InterfaceDeclaration): IterableIterator<string> {
     useImports = true
+    const isRecursiveType = IsRecursiveType(node)
+    if (isRecursiveType) recursiveDeclaration = node
     const heritage = node.heritageClauses !== undefined ? node.heritageClauses.flatMap((node) => Collect(node)) : []
     if (node.typeParameters) {
       useGenerics = true
-      const exports = isExport(node) ? 'export ' : ''
+      const exports = IsExport(node) ? 'export ' : ''
       const constraints = node.typeParameters.map((param) => `${Collect(param)} extends TSchema`).join(', ')
       const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(', ')
       const names = node.typeParameters.map((param) => `${Collect(param)}`).join(', ')
       const members = node.members.map((member) => Collect(member)).join(',\n')
       const staticDeclaration = `${exports}type ${node.name.getText()}<${constraints}> = Static<ReturnType<typeof ${node.name.getText()}<${names}>>>`
-      const rawTypeExpression = isRecursiveType(node) ? `Type.Recursive(${node.name.getText()} => Type.Object({\n${members}\n}))` : `Type.Object({\n${members}\n})`
+      const rawTypeExpression = IsRecursiveType(node) ? `Type.Recursive(This => Type.Object({\n${members}\n}))` : `Type.Object({\n${members}\n})`
       const typeExpression = heritage.length === 0 ? rawTypeExpression : `Type.Intersect([${heritage.join(', ')}, ${rawTypeExpression}])`
       const typeDeclaration = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${typeExpression}`
       yield `${staticDeclaration}\n${typeDeclaration}`
     } else {
-      const exports = isExport(node) ? 'export ' : ''
+      const exports = IsExport(node) ? 'export ' : ''
       const members = node.members.map((member) => Collect(member)).join(',\n')
       const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`
-      const rawTypeExpression = isRecursiveType(node) ? `Type.Recursive(${node.name.getText()} => Type.Object({\n${members}\n}))` : `Type.Object({\n${members}\n})`
+      const rawTypeExpression = IsRecursiveType(node) ? `Type.Recursive(This => Type.Object({\n${members}\n}))` : `Type.Object({\n${members}\n})`
       const typeExpression = heritage.length === 0 ? rawTypeExpression : `Type.Intersect([${heritage.join(', ')}, ${rawTypeExpression}])`
       const typeDeclaration = `${exports}const ${node.name.getText()} = ${typeExpression}`
       yield `${staticDeclaration}\n${typeDeclaration}`
     }
+    typeNames.add(node.name.getText())
+    recursiveDeclaration = null
   }
   function* TypeAliasDeclaration(node: ts.TypeAliasDeclaration): IterableIterator<string> {
     useImports = true
+    const isRecursiveType = IsRecursiveType(node)
+    if (isRecursiveType) recursiveDeclaration = node
     if (node.typeParameters) {
       useGenerics = true
-      const exports = isExport(node) ? 'export ' : ''
+      const exports = IsExport(node) ? 'export ' : ''
       const constraints = node.typeParameters.map((param) => `${Collect(param)} extends TSchema`).join(', ')
       const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(', ')
       const names = node.typeParameters.map((param) => Collect(param)).join(', ')
       const type = Collect(node.type)
       const staticDeclaration = `${exports}type ${node.name.getText()}<${constraints}> = Static<ReturnType<typeof ${node.name.getText()}<${names}>>>`
-      const typeDeclaration = isRecursiveType(node)
-        ? `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => Type.Recursive(${node.name.getText()} => ${type})`
+      const typeDeclaration = isRecursiveType
+        ? `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => Type.Recursive(This => ${type})`
         : `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${type}`
       yield `${staticDeclaration}\n${typeDeclaration}`
     } else {
-      const exports = isExport(node) ? 'export ' : ''
+      const exports = IsExport(node) ? 'export ' : ''
       const type = Collect(node.type)
       const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`
-      const typeDeclaration = isRecursiveType(node) ? `${exports}const ${node.name.getText()} = Type.Recursive(${node.name.getText()} => ${type})` : `${exports}const ${node.name.getText()} = ${type}`
+      const typeDeclaration = isRecursiveType ? `${exports}const ${node.name.getText()} = Type.Recursive(This => ${type})` : `${exports}const ${node.name.getText()} = ${type}`
       yield `${staticDeclaration}\n${typeDeclaration}`
     }
+    typeNames.add(node.name.getText())
+    recursiveDeclaration = null
   }
   function* HeritageClause(node: ts.HeritageClause): IterableIterator<string> {
     const types = node.types.map((node) => Collect(node))
@@ -190,6 +208,9 @@ export namespace TypeScriptToTypeBox {
   }
   function* TypeReferenceNode(node: ts.TypeReferenceNode): IterableIterator<string> {
     const name = node.typeName.getText()
+    if (name === 'T') {
+      console.log(ts.SyntaxKind[node.kind])
+    }
     const args = node.typeArguments ? `(${node.typeArguments.map((type) => Collect(type)).join(', ')})` : ''
     if (name === 'Array') {
       return yield `Type.Array${args}`
@@ -199,6 +220,8 @@ export namespace TypeScriptToTypeBox {
       return yield `Type.Partial${args}`
     } else if (name === 'Uint8Array') {
       return yield `Type.Uint8Array()`
+    } else if (name === 'Date') {
+      return yield `Type.Date()`
     } else if (name === 'Required') {
       return yield `Type.Required${args}`
     } else if (name === 'Omit') {
@@ -219,6 +242,12 @@ export namespace TypeScriptToTypeBox {
       return yield `Type.Exclude${args}`
     } else if (name === 'Extract') {
       return yield `Type.Extract${args}`
+    } else if (recursiveDeclaration !== null && FindRecursiveParent(recursiveDeclaration, node)) {
+      return yield `This`
+    } else if (typeNames.has(name)) {
+      return yield `${name}${args}`
+    } else if (name in globalThis) {
+      return yield `Type.Never(/* Unsupported Type '${name}' */)`
     } else {
       return yield `${name}${args}`
     }
@@ -233,8 +262,8 @@ export namespace TypeScriptToTypeBox {
     yield `Type.Literal(${node.getText()})`
   }
   function* ModuleDeclaration(node: ts.ModuleDeclaration): IterableIterator<string> {
-    const export_specifier = isExport(node) ? 'export ' : ''
-    const module_specifier = isNamespace(node) ? 'namespace' : 'module'
+    const export_specifier = IsExport(node) ? 'export ' : ''
+    const module_specifier = IsNamespace(node) ? 'namespace' : 'module'
     yield `${export_specifier}${module_specifier} ${node.name.getText()} {`
     yield* Visit(node.body)
     yield `}`
@@ -348,10 +377,9 @@ export namespace TypeScriptToTypeBox {
       return yield node.getText()
     }
   }
-  let useImports = false
-  let useGenerics = false
   /** Generates TypeBox types from TypeScript interface and type definitions */
   export function Generate(typescriptCode: string) {
+    typeNames.clear()
     useImports = false
     useGenerics = false
     const source = ts.createSourceFile('code.ts', typescriptCode, ts.ScriptTarget.ESNext, true)
diff --git a/hammer.mjs b/hammer.mjs
index 0957385eb..8cf594e67 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -12,7 +12,7 @@ export async function clean() {
 // Format
 // -------------------------------------------------------------------------------
 export async function format() {
-    await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test example/index.ts benchmark codegen')
+    await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test example/index.ts benchmark')
 }
 
 // -------------------------------------------------------------------------------
diff --git a/tsconfig.json b/tsconfig.json
index 47541b26d..0932a6a80 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -7,9 +7,6 @@
     "declaration": true,
     "baseUrl": ".",
     "paths": {
-      "@sinclair/typebox/codegen": [
-        "codegen/index.ts"
-      ],
       "@sinclair/typebox/compiler": [
         "src/compiler/index.ts"
       ],

From b7fa512e4823b99b0d6519296d92360c7e2f99c9 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 4 Apr 2023 08:58:20 +0900
Subject: [PATCH 093/369] String Template Literal Code Generation

---
 example/codegen/typescript-to-typebox.ts | 82 +++++++++++++++++++++++-
 1 file changed, 80 insertions(+), 2 deletions(-)

diff --git a/example/codegen/typescript-to-typebox.ts b/example/codegen/typescript-to-typebox.ts
index 97f5b46d7..c8fc4732f 100644
--- a/example/codegen/typescript-to-typebox.ts
+++ b/example/codegen/typescript-to-typebox.ts
@@ -44,6 +44,9 @@ export namespace TypeScriptToTypeBox {
   let useGenerics = false
   // tracked for each generated type.
   const typeNames = new Set<string>()
+  // ----------------------------------------------------------------------------------------------------
+  // TypeScript AST Queries
+  // ----------------------------------------------------------------------------------------------------
   function FindRecursiveParent(decl: ts.InterfaceDeclaration | ts.TypeAliasDeclaration, node: ts.Node): boolean {
     return (ts.isTypeReferenceNode(node) && decl.name.getText() === node.typeName.getText()) || node.getChildren().some((node) => FindRecursiveParent(decl, node))
   }
@@ -62,6 +65,76 @@ export namespace TypeScriptToTypeBox {
   function IsNamespace(node: ts.ModuleDeclaration) {
     return node.flags === ts.NodeFlags.Namespace
   }
+  // ----------------------------------------------------------------------------------------------------
+  // String Template Literals: Entry TemplateLiteralTypeNode
+  //
+  // String Template Literals will evaluate as Regular Expressions. These require a distinct code path 
+  // specifically  for union, string, number and literal types embedded in the template literal. These 
+  // embedded types would otherwise be expressed as TUnion, TString, TNumber and TLiteral respectively.
+  // ----------------------------------------------------------------------------------------------------
+  function* TemplatedLiteralTypeNode(node: ts.LiteralTypeNode): IterableIterator<string> {
+    function dequote(value: string) {
+      const match = value.match(/^(['"])(.*)\1$/);
+      return match ? match[2] : value;
+    }
+    function escape(value: string) {
+      return value.replace(/[.*+?^${}()|[\]\\]/g, '\\\\$&')
+    }
+    yield escape(dequote(node.literal.getText()))
+  }
+  function * TemplatedUnionTypeNode(node: ts.UnionTypeNode) {
+    const tokens = node.types.map((type) => TemplateCollect(type)).join('|')
+    yield `(${tokens})`
+  }
+  function * TemplateLiteralTypeSpan(node: ts.TemplateLiteralTypeSpan) {
+    for(const inner of node.getChildren()) {
+      yield TemplateCollect(inner)
+    }
+  }
+  function * TemplateHead(node: ts.TemplateHead) {
+    yield node.text
+  }
+  function * TemplateTail(node: ts.TemplateTail) {
+    yield node.text
+  }
+  function * TemplateVisit(node: ts.Node | undefined): IterableIterator<string> {
+    if(node === undefined) return
+    if (ts.isUnionTypeNode(node)) {
+      return yield* TemplatedUnionTypeNode(node)
+    } else if(ts.isTemplateLiteralTypeSpan(node)) {
+      return yield* TemplateLiteralTypeSpan(node)
+    } else if(ts.isTemplateHead(node)) {
+      return yield* TemplateHead(node)
+    } else if(ts.isTemplateTail(node)) {
+      return yield* TemplateTail(node)
+    } else if(ts.isLiteralTypeNode(node)) {
+      return yield* TemplatedLiteralTypeNode(node)
+    } else if (node.kind === ts.SyntaxKind.NumberKeyword) { 
+      yield `(0|[1-9][0-9]*)`
+    } else if (node.kind === ts.SyntaxKind.StringKeyword) { 
+      yield `(.*)`
+    } else if (node.kind === ts.SyntaxKind.SyntaxList) {
+      for (const child of node.getChildren()) {
+        yield* TemplateVisit(child)
+      }
+      return
+    } else {
+      console.log('Unhandled:', ts.SyntaxKind[node.kind])
+    }
+  }
+  function TemplateCollect(node: ts.Node | undefined): string {
+    return `${[...TemplateVisit(node)].join('')}`
+  }
+  function * TemplateLiteralTypeNode(node: ts.TemplateLiteralTypeNode) {
+    const buffer: string[] = []
+    for(const inner of node.getChildren()) {
+      buffer.push(TemplateCollect(inner))
+    }
+    yield `Type.String({ pattern: '^${buffer.join('')}\$' })`
+  }
+  // ----------------------------------------------------------------------------------------------------
+  // TypeScript To TypeBox Type Transformation
+  // ----------------------------------------------------------------------------------------------------
   function* SourceFile(node: ts.SourceFile): IterableIterator<string> {
     for (const next of node.getChildren()) {
       yield* Visit(next)
@@ -101,6 +174,9 @@ export namespace TypeScriptToTypeBox {
       const type = Collect(node.type)
       yield `Type.KeyOf(${type})`
     }
+    if(node.operator === ts.SyntaxKind.ReadonlyKeyword) {
+      yield Collect(node.type)
+    }
   }
   function* Parameter(node: ts.ParameterDeclaration): IterableIterator<string> {
     yield Collect(node.type)
@@ -307,8 +383,8 @@ export namespace TypeScriptToTypeBox {
       return yield* TypeReferenceNode(node)
     } else if (ts.isTypeLiteralNode(node)) {
       return yield* TypeLiteralNode(node)
-    } else if (ts.isLiteralTypeNode(node)) {
-      return yield* LiteralTypeNode(node)
+    } else if(ts.isLiteralTypeNode(node)) {
+      return yield *LiteralTypeNode(node)
     } else if (ts.isModuleDeclaration(node)) {
       return yield* ModuleDeclaration(node)
     } else if (ts.isModuleBlock(node)) {
@@ -321,6 +397,8 @@ export namespace TypeScriptToTypeBox {
       return yield* IntersectionTypeNode(node)
     } else if (ts.isUnionTypeNode(node)) {
       return yield* UnionTypeNode(node)
+    } else if (ts.isTemplateLiteralTypeNode(node)) {
+      return yield * TemplateLiteralTypeNode(node)
     } else if (ts.isTypeOperatorNode(node)) {
       return yield* TypeOperatorNode(node)
     } else if (ts.isHeritageClause(node)) {

From 749a6d04af2c57f86ae26428e8786882fee377d9 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 4 Apr 2023 11:34:14 +0900
Subject: [PATCH 094/369] Indexer, Readonly Tuple and String Literal Types

---
 example/codegen/typescript-to-typebox.ts | 230 ++++++++++++++---------
 1 file changed, 140 insertions(+), 90 deletions(-)

diff --git a/example/codegen/typescript-to-typebox.ts b/example/codegen/typescript-to-typebox.ts
index c8fc4732f..d2b9d0d6d 100644
--- a/example/codegen/typescript-to-typebox.ts
+++ b/example/codegen/typescript-to-typebox.ts
@@ -26,115 +26,145 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-
 import { Formatter } from './formatter'
 import * as ts from 'typescript'
 
-// --------------------------------------------------------------------------
-// Transform
-// --------------------------------------------------------------------------
-
-/** Generates TypeBox types from TypeScript code */
-export namespace TypeScriptToTypeBox {
-  // tracked for recursive types and used to associate This type references
-  let recursiveDeclaration: ts.TypeAliasDeclaration | ts.InterfaceDeclaration | null = null
-  // tracked for injecting typebox import statements
-  let useImports = false
-  // tracked for injecting TSchema import statements
-  let useGenerics = false
-  // tracked for each generated type.
-  const typeNames = new Set<string>()
-  // ----------------------------------------------------------------------------------------------------
-  // TypeScript AST Queries
-  // ----------------------------------------------------------------------------------------------------
-  function FindRecursiveParent(decl: ts.InterfaceDeclaration | ts.TypeAliasDeclaration, node: ts.Node): boolean {
-    return (ts.isTypeReferenceNode(node) && decl.name.getText() === node.typeName.getText()) || node.getChildren().some((node) => FindRecursiveParent(decl, node))
+// -------------------------------------------------------------------------
+// [StringTemplateLiteral]
+//
+// Specialized code path for evaluating string template literals as regular
+// expressions. This is distinct from typical code paths which would
+// otherwise yield types of TSchema inside the generated regular expression.
+// -------------------------------------------------------------------------
+namespace StringTemplateLiteral {
+  function DereferenceNode(reference: ts.TypeReferenceNode): ts.Node | undefined {
+    function find(node: ts.Node): ts.Node | undefined {
+      if (node.getText() === reference.getText()) return node.parent
+      for (const inner of node.getChildren()) {
+        const result = find(inner)
+        if (result) return result
+      }
+      return undefined
+    }
+    return find(reference.getSourceFile())
   }
-  function IsRecursiveType(decl: ts.InterfaceDeclaration | ts.TypeAliasDeclaration) {
-    return ts.isTypeAliasDeclaration(decl) ? [decl.type].some((node) => FindRecursiveParent(decl, node)) : decl.members.some((node) => FindRecursiveParent(decl, node))
+  function Dequote(value: string) {
+    const match = value.match(/^(['"`])(.*)\1$/)
+    return match ? match[2] : value
   }
-  function IsReadonlyProperty(node: ts.PropertySignature): boolean {
-    return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'readonly') !== undefined
+  function Escape(value: string) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\\\$&')
   }
-  function IsOptionalProperty(node: ts.PropertySignature) {
-    return node.questionToken !== undefined
+  function* LiteralTypeNode(node: ts.LiteralTypeNode) {
+    yield Escape(Dequote(node.literal.getText()))
   }
-  function IsExport(node: ts.InterfaceDeclaration | ts.TypeAliasDeclaration | ts.EnumDeclaration | ts.ModuleDeclaration): boolean {
-    return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'export') !== undefined
+  function* UnionTypeNode(node: ts.UnionTypeNode) {
+    const tokens = node.types.map((type) => Collect(type)).join('|')
+    yield `(${tokens})`
   }
-  function IsNamespace(node: ts.ModuleDeclaration) {
-    return node.flags === ts.NodeFlags.Namespace
+  function* StringLiteral(node: ts.StringLiteral) {
+    yield Dequote(node.getText())
   }
-  // ----------------------------------------------------------------------------------------------------
-  // String Template Literals: Entry TemplateLiteralTypeNode
-  //
-  // String Template Literals will evaluate as Regular Expressions. These require a distinct code path 
-  // specifically  for union, string, number and literal types embedded in the template literal. These 
-  // embedded types would otherwise be expressed as TUnion, TString, TNumber and TLiteral respectively.
-  // ----------------------------------------------------------------------------------------------------
-  function* TemplatedLiteralTypeNode(node: ts.LiteralTypeNode): IterableIterator<string> {
-    function dequote(value: string) {
-      const match = value.match(/^(['"])(.*)\1$/);
-      return match ? match[2] : value;
-    }
-    function escape(value: string) {
-      return value.replace(/[.*+?^${}()|[\]\\]/g, '\\\\$&')
-    }
-    yield escape(dequote(node.literal.getText()))
+  function* TypeReference(node: ts.TypeReferenceNode) {
+    const target = DereferenceNode(node)
+    if (target === undefined) return
+    yield Collect(target)
   }
-  function * TemplatedUnionTypeNode(node: ts.UnionTypeNode) {
-    const tokens = node.types.map((type) => TemplateCollect(type)).join('|')
-    yield `(${tokens})`
+  function* TypeAliasDeclaration(node: ts.TypeAliasDeclaration) {
+    yield Collect(node.type)
   }
-  function * TemplateLiteralTypeSpan(node: ts.TemplateLiteralTypeSpan) {
-    for(const inner of node.getChildren()) {
-      yield TemplateCollect(inner)
+  function* LiteralTypeSpan(node: ts.TemplateLiteralTypeSpan) {
+    for (const inner of node.getChildren()) {
+      yield Collect(inner)
     }
   }
-  function * TemplateHead(node: ts.TemplateHead) {
+  function* TemplateHead(node: ts.TemplateHead) {
+    yield node.text
+  }
+  function* TemplateMiddle(node: ts.TemplateMiddle) {
     yield node.text
   }
-  function * TemplateTail(node: ts.TemplateTail) {
+  function* TemplateTail(node: ts.TemplateTail) {
     yield node.text
   }
-  function * TemplateVisit(node: ts.Node | undefined): IterableIterator<string> {
-    if(node === undefined) return
+  function* Visit(node: ts.Node | undefined): IterableIterator<string> {
+    if (node === undefined) return
     if (ts.isUnionTypeNode(node)) {
-      return yield* TemplatedUnionTypeNode(node)
-    } else if(ts.isTemplateLiteralTypeSpan(node)) {
-      return yield* TemplateLiteralTypeSpan(node)
-    } else if(ts.isTemplateHead(node)) {
+      return yield* UnionTypeNode(node)
+    } else if (ts.isStringLiteral(node)) {
+      return yield* StringLiteral(node)
+    } else if (ts.isTemplateLiteralTypeSpan(node)) {
+      return yield* LiteralTypeSpan(node)
+    } else if (ts.isTypeReferenceNode(node)) {
+      return yield* TypeReference(node)
+    } else if (ts.isTypeAliasDeclaration(node)) {
+      return yield* TypeAliasDeclaration(node)
+    } else if (ts.isTemplateHead(node)) {
       return yield* TemplateHead(node)
-    } else if(ts.isTemplateTail(node)) {
+    } else if (ts.isTemplateMiddle(node)) {
+      return yield* TemplateMiddle(node)
+    } else if (ts.isTemplateTail(node)) {
       return yield* TemplateTail(node)
-    } else if(ts.isLiteralTypeNode(node)) {
-      return yield* TemplatedLiteralTypeNode(node)
-    } else if (node.kind === ts.SyntaxKind.NumberKeyword) { 
+    } else if (ts.isLiteralTypeNode(node)) {
+      return yield* LiteralTypeNode(node)
+    } else if (node.kind === ts.SyntaxKind.NumberKeyword) {
       yield `(0|[1-9][0-9]*)`
-    } else if (node.kind === ts.SyntaxKind.StringKeyword) { 
+    } else if (node.kind === ts.SyntaxKind.StringKeyword) {
       yield `(.*)`
     } else if (node.kind === ts.SyntaxKind.SyntaxList) {
       for (const child of node.getChildren()) {
-        yield* TemplateVisit(child)
+        yield* Visit(child)
       }
       return
     } else {
-      console.log('Unhandled:', ts.SyntaxKind[node.kind])
+      console.log('StringTemplateLiteral Unhandled:', ts.SyntaxKind[node.kind])
     }
   }
-  function TemplateCollect(node: ts.Node | undefined): string {
-    return `${[...TemplateVisit(node)].join('')}`
+  function Collect(node: ts.Node | undefined): string {
+    return `${[...Visit(node)].join('')}`
   }
-  function * TemplateLiteralTypeNode(node: ts.TemplateLiteralTypeNode) {
+  export function* TemplateLiteralTypeNode(node: ts.TemplateLiteralTypeNode) {
     const buffer: string[] = []
-    for(const inner of node.getChildren()) {
-      buffer.push(TemplateCollect(inner))
+    for (const inner of node.getChildren()) {
+      buffer.push(Collect(inner))
     }
     yield `Type.String({ pattern: '^${buffer.join('')}\$' })`
   }
-  // ----------------------------------------------------------------------------------------------------
-  // TypeScript To TypeBox Type Transformation
-  // ----------------------------------------------------------------------------------------------------
+}
+// -------------------------------------------------------------------------
+// [TypeScriptToTypeBox]
+//
+// The following are code generation paths for types of TSchema.
+// -------------------------------------------------------------------------
+/** Generates TypeBox types from TypeScript code */
+export namespace TypeScriptToTypeBox {
+  // tracked for recursive types and used to associate This type references
+  let recursiveDeclaration: ts.TypeAliasDeclaration | ts.InterfaceDeclaration | null = null
+  // tracked for injecting typebox import statements
+  let useImports = false
+  // tracked for injecting TSchema import statements
+  let useGenerics = false
+  // tracked for each generated type.
+  const typeNames = new Set<string>()
+
+  function FindRecursiveParent(decl: ts.InterfaceDeclaration | ts.TypeAliasDeclaration, node: ts.Node): boolean {
+    return (ts.isTypeReferenceNode(node) && decl.name.getText() === node.typeName.getText()) || node.getChildren().some((node) => FindRecursiveParent(decl, node))
+  }
+  function IsRecursiveType(decl: ts.InterfaceDeclaration | ts.TypeAliasDeclaration) {
+    return ts.isTypeAliasDeclaration(decl) ? [decl.type].some((node) => FindRecursiveParent(decl, node)) : decl.members.some((node) => FindRecursiveParent(decl, node))
+  }
+  function IsReadonlyProperty(node: ts.PropertySignature): boolean {
+    return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'readonly') !== undefined
+  }
+  function IsOptionalProperty(node: ts.PropertySignature) {
+    return node.questionToken !== undefined
+  }
+  function IsExport(node: ts.InterfaceDeclaration | ts.TypeAliasDeclaration | ts.EnumDeclaration | ts.ModuleDeclaration): boolean {
+    return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'export') !== undefined
+  }
+  function IsNamespace(node: ts.ModuleDeclaration) {
+    return node.flags === ts.NodeFlags.Namespace
+  }
   function* SourceFile(node: ts.SourceFile): IterableIterator<string> {
     for (const next of node.getChildren()) {
       yield* Visit(next)
@@ -174,7 +204,7 @@ export namespace TypeScriptToTypeBox {
       const type = Collect(node.type)
       yield `Type.KeyOf(${type})`
     }
-    if(node.operator === ts.SyntaxKind.ReadonlyKeyword) {
+    if (node.operator === ts.SyntaxKind.ReadonlyKeyword) {
       yield Collect(node.type)
     }
   }
@@ -200,6 +230,25 @@ export namespace TypeScriptToTypeBox {
     yield [enumType, '', type].join('\n')
     typeNames.add(node.name.getText())
   }
+  // Collects members on behalf of InterfaceDeclaration and TypeLiteralNode. This function may yield an object
+  // with additionalProperties if we find an indexer in the members set.
+  function CollectObjectMembers(members: ts.NodeArray<ts.TypeElement>): string {
+    const properties = members.filter((member) => !ts.isIndexSignatureDeclaration(member))
+    const indexers = members.filter((member) => ts.isIndexSignatureDeclaration(member))
+    const propertyCollect = properties.map((property) => Collect(property)).join(',\n')
+    const indexer = indexers.length > 0 ? Collect(indexers[indexers.length - 1]) : ''
+    if (properties.length === 0 && indexer.length > 0) {
+      return `{},\n{\nadditionalProperties: ${indexer}\n }`
+    } else if (properties.length > 0 && indexer.length > 0) {
+      return `{\n${propertyCollect}\n},\n{\nadditionalProperties: ${indexer}\n }`
+    } else {
+      return `{\n${propertyCollect}\n}`
+    }
+  }
+  function* TypeLiteralNode(node: ts.TypeLiteralNode): IterableIterator<string> {
+    const members = CollectObjectMembers(node.members)
+    yield* `Type.Object(${members})`
+  }
   function* InterfaceDeclaration(node: ts.InterfaceDeclaration): IterableIterator<string> {
     useImports = true
     const isRecursiveType = IsRecursiveType(node)
@@ -211,17 +260,17 @@ export namespace TypeScriptToTypeBox {
       const constraints = node.typeParameters.map((param) => `${Collect(param)} extends TSchema`).join(', ')
       const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(', ')
       const names = node.typeParameters.map((param) => `${Collect(param)}`).join(', ')
-      const members = node.members.map((member) => Collect(member)).join(',\n')
+      const members = CollectObjectMembers(node.members)
       const staticDeclaration = `${exports}type ${node.name.getText()}<${constraints}> = Static<ReturnType<typeof ${node.name.getText()}<${names}>>>`
-      const rawTypeExpression = IsRecursiveType(node) ? `Type.Recursive(This => Type.Object({\n${members}\n}))` : `Type.Object({\n${members}\n})`
+      const rawTypeExpression = IsRecursiveType(node) ? `Type.Recursive(This => Type.Object(${members}))` : `Type.Object(${members})`
       const typeExpression = heritage.length === 0 ? rawTypeExpression : `Type.Intersect([${heritage.join(', ')}, ${rawTypeExpression}])`
       const typeDeclaration = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${typeExpression}`
       yield `${staticDeclaration}\n${typeDeclaration}`
     } else {
       const exports = IsExport(node) ? 'export ' : ''
-      const members = node.members.map((member) => Collect(member)).join(',\n')
+      const members = CollectObjectMembers(node.members)
       const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`
-      const rawTypeExpression = IsRecursiveType(node) ? `Type.Recursive(This => Type.Object({\n${members}\n}))` : `Type.Object({\n${members}\n})`
+      const rawTypeExpression = IsRecursiveType(node) ? `Type.Recursive(This => Type.Object(${members}))` : `Type.Object(${members})`
       const typeExpression = heritage.length === 0 ? rawTypeExpression : `Type.Intersect([${heritage.join(', ')}, ${rawTypeExpression}])`
       const typeDeclaration = `${exports}const ${node.name.getText()} = ${typeExpression}`
       yield `${staticDeclaration}\n${typeDeclaration}`
@@ -282,11 +331,14 @@ export namespace TypeScriptToTypeBox {
     const falseType = Collect(node.falseType)
     yield `Type.Extends(${checkType}, ${extendsType}, ${trueType}, ${falseType})`
   }
+  function* isIndexSignatureDeclaration(node: ts.IndexSignatureDeclaration) {
+    // note: we ignore the key and just return the type. this is a mismatch between
+    // object and record types. Address in TypeBox by unifying validation paths
+    // for objects and record types.
+    yield Collect(node.type)
+  }
   function* TypeReferenceNode(node: ts.TypeReferenceNode): IterableIterator<string> {
     const name = node.typeName.getText()
-    if (name === 'T') {
-      console.log(ts.SyntaxKind[node.kind])
-    }
     const args = node.typeArguments ? `(${node.typeArguments.map((type) => Collect(type)).join(', ')})` : ''
     if (name === 'Array') {
       return yield `Type.Array${args}`
@@ -328,10 +380,6 @@ export namespace TypeScriptToTypeBox {
       return yield `${name}${args}`
     }
   }
-  function* TypeLiteralNode(node: ts.TypeLiteralNode): IterableIterator<string> {
-    const members = node.members.map((member) => Collect(member)).join(',\n')
-    yield `Type.Object({\n${members}\n})`
-  }
   function* LiteralTypeNode(node: ts.LiteralTypeNode): IterableIterator<string> {
     const text = node.getText()
     if (text === 'null') return yield `Type.Null()`
@@ -383,8 +431,8 @@ export namespace TypeScriptToTypeBox {
       return yield* TypeReferenceNode(node)
     } else if (ts.isTypeLiteralNode(node)) {
       return yield* TypeLiteralNode(node)
-    } else if(ts.isLiteralTypeNode(node)) {
-      return yield *LiteralTypeNode(node)
+    } else if (ts.isLiteralTypeNode(node)) {
+      return yield* LiteralTypeNode(node)
     } else if (ts.isModuleDeclaration(node)) {
       return yield* ModuleDeclaration(node)
     } else if (ts.isModuleBlock(node)) {
@@ -398,7 +446,7 @@ export namespace TypeScriptToTypeBox {
     } else if (ts.isUnionTypeNode(node)) {
       return yield* UnionTypeNode(node)
     } else if (ts.isTemplateLiteralTypeNode(node)) {
-      return yield * TemplateLiteralTypeNode(node)
+      return yield* StringTemplateLiteral.TemplateLiteralTypeNode(node)
     } else if (ts.isTypeOperatorNode(node)) {
       return yield* TypeOperatorNode(node)
     } else if (ts.isHeritageClause(node)) {
@@ -417,6 +465,8 @@ export namespace TypeScriptToTypeBox {
       return yield* ClassDeclaration(node)
     } else if (ts.isConditionalTypeNode(node)) {
       return yield* ConditionalTypeNode(node)
+    } else if (ts.isIndexSignatureDeclaration(node)) {
+      return yield* isIndexSignatureDeclaration(node)
     } else if (ts.isIdentifier(node)) {
       return yield node.getText()
     } else if (node.kind === ts.SyntaxKind.ExportKeyword) {

From d4858dd815ba664bfac0983e8f2c8dc413c24756 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 9 Apr 2023 01:10:29 +0900
Subject: [PATCH 095/369] Revision 0.27.0 (#371)

---
 benchmark/measurement/module/cases.ts         |  13 +
 changelog/0.27.0.md                           | 152 +++++
 example/codegen/typebox-to-typescript.ts      |   8 +-
 example/codegen/typebox-to-zod.ts             |   6 +-
 example/codegen/typescript-to-typebox.ts      | 321 +++------
 example/index.ts                              |   2 +-
 hammer.mjs                                    |   3 -
 package-lock.json                             |  18 +-
 package.json                                  |   4 +-
 readme.md                                     | 280 +++++---
 src/compiler/compiler.ts                      |  19 +-
 src/errors/errors.ts                          |  31 +-
 src/typebox.ts                                | 498 +++++++++++---
 src/value/cast.ts                             |  25 +-
 src/value/check.ts                            |  26 +-
 src/value/convert.ts                          |  23 +-
 src/value/create.ts                           |  44 +-
 test/runtime/compiler/index.ts                |   1 +
 test/runtime/compiler/recursive.ts            |  12 +-
 test/runtime/compiler/template-literal.ts     | 186 ++++++
 test/runtime/schema/index.ts                  |   1 +
 test/runtime/schema/recursive.ts              |  12 +-
 test/runtime/schema/template-literal.ts       | 186 ++++++
 test/runtime/type/extends/any.ts              |   2 -
 test/runtime/type/extends/array.ts            |  51 --
 test/runtime/type/extends/boolean.ts          |  16 -
 test/runtime/type/extends/constructor.ts      |  39 --
 test/runtime/type/extends/date.ts             |  16 -
 test/runtime/type/extends/function.ts         |  40 --
 test/runtime/type/extends/index.ts            |   1 +
 test/runtime/type/extends/integer.ts          |  17 -
 test/runtime/type/extends/literal.ts          |  47 --
 test/runtime/type/extends/null.ts             |  18 -
 test/runtime/type/extends/number.ts           |  17 -
 test/runtime/type/extends/promise.ts          |  41 --
 test/runtime/type/extends/record.ts           |  33 -
 test/runtime/type/extends/string.ts           |  20 -
 test/runtime/type/extends/template-literal.ts | 162 +++++
 test/runtime/type/extends/uint8array.ts       |  17 -
 test/runtime/type/extends/undefined.ts        |  16 -
 test/runtime/type/extends/unknown.ts          |  18 -
 test/runtime/type/extends/void.ts             |  19 -
 test/runtime/type/guard/exclude.ts            |  66 ++
 test/runtime/type/guard/extract.ts            |  72 +++
 test/runtime/type/guard/index.ts              |   3 +-
 test/runtime/type/guard/self.ts               |  22 -
 test/runtime/type/guard/template-literal.ts   |  47 ++
 test/runtime/type/guard/this.ts               |  22 +
 test/runtime/type/index.ts                    |   3 +-
 .../type/{normal => normalize}/exclude.ts     |   0
 .../type/{normal => normalize}/extract.ts     |   0
 .../type/{normal => normalize}/index.ts       |   0
 .../type/{normal => normalize}/intersect.ts   |   0
 .../type/{normal => normalize}/record.ts      |   0
 .../type/{normal => normalize}/union.ts       |   0
 test/runtime/type/registry/format.ts          |   5 +-
 test/runtime/type/registry/index.ts           |   1 +
 test/runtime/type/registry/type.ts            |  22 +
 test/runtime/type/template/finite.ts          |  61 ++
 test/runtime/type/template/generate.ts        | 199 ++++++
 test/runtime/type/template/index.ts           |   4 +
 test/runtime/type/template/parser.ts          | 607 ++++++++++++++++++
 test/runtime/type/template/pattern.ts         | 145 +++++
 test/runtime/value/cast/custom.ts             |   7 +-
 test/runtime/value/cast/index.ts              |   1 +
 test/runtime/value/cast/recursive.ts          |  12 +-
 test/runtime/value/cast/template-literal.ts   |  53 ++
 test/runtime/value/check/index.ts             |   1 +
 test/runtime/value/check/recursive.ts         |   4 +-
 test/runtime/value/check/template-literal.ts  | 187 ++++++
 test/runtime/value/create/index.ts            |   1 +
 test/runtime/value/create/recursive.ts        |   8 +-
 test/runtime/value/create/template-literal.ts |  35 +
 test/static/exclude.ts                        |  71 +-
 test/static/extract.ts                        |  72 ++-
 test/static/index.ts                          |   1 +
 test/static/template-literal.ts               |  44 ++
 77 files changed, 3251 insertions(+), 986 deletions(-)
 create mode 100644 changelog/0.27.0.md
 create mode 100644 test/runtime/compiler/template-literal.ts
 create mode 100644 test/runtime/schema/template-literal.ts
 create mode 100644 test/runtime/type/extends/template-literal.ts
 delete mode 100644 test/runtime/type/guard/self.ts
 create mode 100644 test/runtime/type/guard/template-literal.ts
 create mode 100644 test/runtime/type/guard/this.ts
 rename test/runtime/type/{normal => normalize}/exclude.ts (100%)
 rename test/runtime/type/{normal => normalize}/extract.ts (100%)
 rename test/runtime/type/{normal => normalize}/index.ts (100%)
 rename test/runtime/type/{normal => normalize}/intersect.ts (100%)
 rename test/runtime/type/{normal => normalize}/record.ts (100%)
 rename test/runtime/type/{normal => normalize}/union.ts (100%)
 create mode 100644 test/runtime/type/registry/type.ts
 create mode 100644 test/runtime/type/template/finite.ts
 create mode 100644 test/runtime/type/template/generate.ts
 create mode 100644 test/runtime/type/template/index.ts
 create mode 100644 test/runtime/type/template/parser.ts
 create mode 100644 test/runtime/type/template/pattern.ts
 create mode 100644 test/runtime/value/cast/template-literal.ts
 create mode 100644 test/runtime/value/check/template-literal.ts
 create mode 100644 test/runtime/value/create/template-literal.ts
 create mode 100644 test/static/template-literal.ts

diff --git a/benchmark/measurement/module/cases.ts b/benchmark/measurement/module/cases.ts
index e59f281f2..36ec2d7d9 100644
--- a/benchmark/measurement/module/cases.ts
+++ b/benchmark/measurement/module/cases.ts
@@ -34,6 +34,19 @@ export namespace Cases {
   export const Object_Constrained = Type.Object(Object_Unconstrained.properties, {
     additionalProperties: false,
   })
+
+  export const Object_Vector3 = Type.Object({
+    x: Type.Number(),
+    y: Type.Number(),
+    z: Type.Number(),
+  })
+
+  export const Object_Box3D = Type.Object({
+    scale: Object_Vector3,
+    position: Object_Vector3,
+    rotate: Object_Vector3,
+    pivot: Object_Vector3,
+  })
   export const Object_Recursive = Type.Recursive(
     (Recursive) =>
       Type.Object({
diff --git a/changelog/0.27.0.md b/changelog/0.27.0.md
new file mode 100644
index 000000000..be87bbf32
--- /dev/null
+++ b/changelog/0.27.0.md
@@ -0,0 +1,152 @@
+## [0.27.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.27.0)
+
+## Overview
+
+Revision 0.27.0 adds support for runtime [Template Literal Types](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html). This revision does not include any functional breaking changes but does rename some public type aliases. As such this revision requires a minor semver increment.
+
+## Contents
+
+- Enhancements
+  - [Template Literal Types](#Template-Literal-Types)
+  - [TemplateLiteralParser](#TemplateLiteralParser)
+  - [WorkBench](#WorkBench)
+- Breaking Changes
+  - [TSelf renamed to TThis](#TSelf-renamed-to-TThis)
+
+
+<a href="Template-Literal-Types"></a>
+
+## Template Literal Types
+
+Revision 0.27.0 adds support for Template Literal types. These types operate as a form of computed `TUnion<TLiteral<string>>`. TypeBox encodes template literals using a subset of [ECMA 262](https://json-schema.org/understanding-json-schema/reference/regular_expressions.html) regular erxpressions which are applied to `pattern` properties of type `string`. This encoding enables JSON Schema validators to assert using existing regular expression checks.
+
+### TypeScript
+
+TypeScript defines Template Literals using back tick quoted strings which may include embedded union groups.
+
+```typescript
+type T = `option${'A'|'B'}`                          // type T = 'optionA' | 'optionB'
+
+type R = Record<T, string>                           // type R = {
+                                                     //   optionA: string
+                                                     //   optionB: string
+                                                     // }
+```
+
+### TypeBox
+
+TypeBox defines Template Literals using the `TemplateLiteral` function. This function accepts a sequence of TLiteral, TString, TNumber, TInteger and TBigInt which describe a sequence concatenations. The embedded TUnion type defines an option group which can later be expanded into a set of `TLiteral<string>`. This expansion enables Template Literal types to also be used as Record keys.
+
+```typescript
+const T = Type.TemplateLiteral([                     // const T = {
+  Type.Literal('option'),                            //   pattern: '^option(A|B)$',
+  Type.Union([                                       //   type: 'string'
+    Type.Literal('A'),                               // }
+    Type.Literal('B')
+  ])
+])
+
+const R = Type.Record(T, Type.String())              // const R = {
+                                                     //   type: 'object',
+                                                     //   required: ['optionA', 'optionB'],
+                                                     //   properties: {
+                                                     //     optionA: {
+                                                     //       type: 'string'
+                                                     //     },
+                                                     //     optionB: {
+                                                     //       type: 'string'
+                                                     //     }
+                                                     //   }
+                                                     // }
+
+type T = Static<typeof T>                            // type T = 'optionA' | 'optionB'
+
+type R = Static<typeof R>                            // type R = {
+                                                     //   optionA: string
+                                                     //   optionB: string
+                                                     // }
+```
+
+## TemplateLiteralParser
+
+Template Literal types are encoded as `string` patterns. Because these types also need to act as composable union types, Revision 0.27.0 includes an expression parser / generator system specifically for regular expressions. This system is used during composition to allow templates to compose with other types, but can also be used in isolation to generate string sequences for the supported expression grammar. This functionality may be provided as standard on the `Value.*` sub module in subsequent revisions.
+
+The following generates a 8-bit binary sequence for the given expression.
+
+```typescript
+
+import { TemplateLiteralParser, TemplateLiteralGenerator, TemplateLiteralFinite } from '@sinclair/typebox'
+
+const Bit  = `(0|1)`                                              // bit union
+const Byte = `${Bit}${Bit}${Bit}${Bit}${Bit}${Bit}${Bit}${Bit}`   // byte sequence
+
+const E = TemplateLiteralParser.Parse(Byte)                       // parsed expression tree
+const F = TemplateLiteralFinite.Check(E)                          // is the expression finite?
+const S = [...TemplateLiteralGenerator.Generate(E)]               // generate sequence
+         
+// const S = [                                                    // computed sequence
+//     '00000000', '00000001', '00000010', '00000011', '00000100',
+//     '00000101', '00000110', '00000111', '00001000', '00001001',
+//     '00001010', '00001011', '00001100', '00001101', '00001110',
+//     '00001111', '00010000', '00010001', '00010010', '00010011',
+//     '00010100', '00010101', '00010110', '00010111', '00011000',
+//     '00011001', '00011010', '00011011', '00011100', '00011101',
+//     '00011110', '00011111', '00100000', '00100001', '00100010',
+//     '00100011', '00100100', '00100101', '00100110', '00100111',
+//     '00101000', '00101001', '00101010', '00101011', '00101100',
+//     '00101101', '00101110', '00101111', '00110000', '00110001',
+//     '00110010', '00110011', '00110100', '00110101', '00110110',
+//     '00110111', '00111000', '00111001', '00111010', '00111011',
+//     '00111100', '00111101', '00111110', '00111111', '01000000',
+//     '01000001', '01000010', '01000011', '01000100', '01000101',
+//     '01000110', '01000111', '01001000', '01001001', '01001010',
+//     '01001011', '01001100', '01001101', '01001110', '01001111',
+//     '01010000', '01010001', '01010010', '01010011', '01010100',
+//     '01010101', '01010110', '01010111', '01011000', '01011001',
+//     '01011010', '01011011', '01011100', '01011101', '01011110',
+//     '01011111', '01100000', '01100001', '01100010', '01100011',
+//     ... 156 more items
+//   ]
+```
+
+<a href="Workbench"></a>
+
+## Workbench
+
+To assist with TypeScript alignment and to prototype new features. A new web based compiler tool has been written that allows interactive cross compiling between TypeScript and TypeBox. This tool will be enhanced seperately from the TypeBox project, but can be used to quickly generate TypeBox type definitions from existing TypeScript types.
+
+[TypeBox Workbench Application](https://sinclairzx81.github.io/typebox-workbench)
+
+[TypeBox Workbench Project](https://github.com/sinclairzx81/typebox-workbench)
+
+<a href="https://sinclairzx81.github.io/typebox-workbench/"><img src="https://github.com/sinclairzx81/typebox-workbench/raw/main/typebox.png" /></a>
+
+
+## Breaking Changes
+
+The following are breaking changes in Revision 0.27.0
+
+<a href="TSelf-renamed-to-TThis"></a>
+
+## TSelf renamed to TThis
+
+This rename is to align with TypeScript interfaces. Unlike `type` aliases, TypeScript `interface` types include a implicit `this` type. This change relates specifically to TypeBox's current Recursive type which passes the `TThis` parameter via callback. The `TThis` parameter can be seen as analogous to the implicit TypeScript interface `this`. 
+
+Consider the following.
+
+```typescript
+// type T = { id: string, nodes: this[] }        // error: no implicit this
+
+interface Node {                                 // ok: this is implicit for interfaces
+  id: string, 
+  nodes: this[] 
+}  
+
+const T = Type.Recursive(This =>                 // `This` === implicit 'this' for interface
+  Type.Object({                                  //
+    id: Type.String(),                           // Should `Recursive` be renamed to `Interface`?
+    nodes: Type.Array(This)
+  })
+)
+```
+Future revisions may rename `Recurisve` to `Interface`, but for now, just the `TSelf` has been renamed.
\ No newline at end of file
diff --git a/example/codegen/typebox-to-typescript.ts b/example/codegen/typebox-to-typescript.ts
index 6629c6022..f7f76713a 100644
--- a/example/codegen/typebox-to-typescript.ts
+++ b/example/codegen/typebox-to-typescript.ts
@@ -90,7 +90,7 @@ export namespace TypeBoxToTypeScript {
   function Record(schema: Types.TRecord) {
     for (const [key, value] of globalThis.Object.entries(schema.patternProperties)) {
       const type = Visit(value)
-      if (key === '^(0|[1-9][0-9]*)$') {
+      if (key === Types.PatternNumberExact) {
         return `Record<number, ${type}>`
       } else {
         return `Record<string, ${type}>`
@@ -101,7 +101,7 @@ export namespace TypeBoxToTypeScript {
   function Ref(schema: Types.TRef) {
     return schema.$ref
   }
-  function Self(schema: Types.TSelf) {
+  function This(schema: Types.TThis) {
     return schema.$ref
   }
   function Tuple(schema: Types.TTuple) {
@@ -155,10 +155,10 @@ export namespace TypeBoxToTypeScript {
       return Record(schema)
     } else if (Types.TypeGuard.TRef(schema)) {
       return Ref(schema)
-    } else if (Types.TypeGuard.TSelf(schema)) {
-      return Self(schema)
     } else if (Types.TypeGuard.TString(schema)) {
       return String(schema)
+    } else if (Types.TypeGuard.TThis(schema)) {
+      return This(schema)
     } else if (Types.TypeGuard.TTuple(schema)) {
       return Tuple(schema)
     } else if (Types.TypeGuard.TUint8Array(schema)) {
diff --git a/example/codegen/typebox-to-zod.ts b/example/codegen/typebox-to-zod.ts
index 84d84706d..bfcdc4b0c 100644
--- a/example/codegen/typebox-to-zod.ts
+++ b/example/codegen/typebox-to-zod.ts
@@ -151,7 +151,7 @@ export namespace TypeBoxToZod {
     if (!reference_map.has(schema.$ref!)) throw new TypeBoxToZodNonReferentialType(schema.$ref!)
     return schema.$ref
   }
-  function Self(schema: Types.TSelf) {
+  function This(schema: Types.TThis) {
     if (!reference_map.has(schema.$ref!)) throw new TypeBoxToZodNonReferentialType(schema.$ref!)
     recursive_set.add(schema.$ref)
     return schema.$ref
@@ -208,10 +208,10 @@ export namespace TypeBoxToZod {
       return Record(schema)
     } else if (Types.TypeGuard.TRef(schema)) {
       return Ref(schema)
-    } else if (Types.TypeGuard.TSelf(schema)) {
-      return Self(schema)
     } else if (Types.TypeGuard.TString(schema)) {
       return String(schema)
+    } else if (Types.TypeGuard.TThis(schema)) {
+      return This(schema)
     } else if (Types.TypeGuard.TTuple(schema)) {
       return Tuple(schema)
     } else if (Types.TypeGuard.TUint8Array(schema)) {
diff --git a/example/codegen/typescript-to-typebox.ts b/example/codegen/typescript-to-typebox.ts
index d2b9d0d6d..953f8a2be 100644
--- a/example/codegen/typescript-to-typebox.ts
+++ b/example/codegen/typescript-to-typebox.ts
@@ -29,112 +29,8 @@ THE SOFTWARE.
 import { Formatter } from './formatter'
 import * as ts from 'typescript'
 
-// -------------------------------------------------------------------------
-// [StringTemplateLiteral]
-//
-// Specialized code path for evaluating string template literals as regular
-// expressions. This is distinct from typical code paths which would
-// otherwise yield types of TSchema inside the generated regular expression.
-// -------------------------------------------------------------------------
-namespace StringTemplateLiteral {
-  function DereferenceNode(reference: ts.TypeReferenceNode): ts.Node | undefined {
-    function find(node: ts.Node): ts.Node | undefined {
-      if (node.getText() === reference.getText()) return node.parent
-      for (const inner of node.getChildren()) {
-        const result = find(inner)
-        if (result) return result
-      }
-      return undefined
-    }
-    return find(reference.getSourceFile())
-  }
-  function Dequote(value: string) {
-    const match = value.match(/^(['"`])(.*)\1$/)
-    return match ? match[2] : value
-  }
-  function Escape(value: string) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\\\$&')
-  }
-  function* LiteralTypeNode(node: ts.LiteralTypeNode) {
-    yield Escape(Dequote(node.literal.getText()))
-  }
-  function* UnionTypeNode(node: ts.UnionTypeNode) {
-    const tokens = node.types.map((type) => Collect(type)).join('|')
-    yield `(${tokens})`
-  }
-  function* StringLiteral(node: ts.StringLiteral) {
-    yield Dequote(node.getText())
-  }
-  function* TypeReference(node: ts.TypeReferenceNode) {
-    const target = DereferenceNode(node)
-    if (target === undefined) return
-    yield Collect(target)
-  }
-  function* TypeAliasDeclaration(node: ts.TypeAliasDeclaration) {
-    yield Collect(node.type)
-  }
-  function* LiteralTypeSpan(node: ts.TemplateLiteralTypeSpan) {
-    for (const inner of node.getChildren()) {
-      yield Collect(inner)
-    }
-  }
-  function* TemplateHead(node: ts.TemplateHead) {
-    yield node.text
-  }
-  function* TemplateMiddle(node: ts.TemplateMiddle) {
-    yield node.text
-  }
-  function* TemplateTail(node: ts.TemplateTail) {
-    yield node.text
-  }
-  function* Visit(node: ts.Node | undefined): IterableIterator<string> {
-    if (node === undefined) return
-    if (ts.isUnionTypeNode(node)) {
-      return yield* UnionTypeNode(node)
-    } else if (ts.isStringLiteral(node)) {
-      return yield* StringLiteral(node)
-    } else if (ts.isTemplateLiteralTypeSpan(node)) {
-      return yield* LiteralTypeSpan(node)
-    } else if (ts.isTypeReferenceNode(node)) {
-      return yield* TypeReference(node)
-    } else if (ts.isTypeAliasDeclaration(node)) {
-      return yield* TypeAliasDeclaration(node)
-    } else if (ts.isTemplateHead(node)) {
-      return yield* TemplateHead(node)
-    } else if (ts.isTemplateMiddle(node)) {
-      return yield* TemplateMiddle(node)
-    } else if (ts.isTemplateTail(node)) {
-      return yield* TemplateTail(node)
-    } else if (ts.isLiteralTypeNode(node)) {
-      return yield* LiteralTypeNode(node)
-    } else if (node.kind === ts.SyntaxKind.NumberKeyword) {
-      yield `(0|[1-9][0-9]*)`
-    } else if (node.kind === ts.SyntaxKind.StringKeyword) {
-      yield `(.*)`
-    } else if (node.kind === ts.SyntaxKind.SyntaxList) {
-      for (const child of node.getChildren()) {
-        yield* Visit(child)
-      }
-      return
-    } else {
-      console.log('StringTemplateLiteral Unhandled:', ts.SyntaxKind[node.kind])
-    }
-  }
-  function Collect(node: ts.Node | undefined): string {
-    return `${[...Visit(node)].join('')}`
-  }
-  export function* TemplateLiteralTypeNode(node: ts.TemplateLiteralTypeNode) {
-    const buffer: string[] = []
-    for (const inner of node.getChildren()) {
-      buffer.push(Collect(inner))
-    }
-    yield `Type.String({ pattern: '^${buffer.join('')}\$' })`
-  }
-}
 // -------------------------------------------------------------------------
 // [TypeScriptToTypeBox]
-//
-// The following are code generation paths for types of TSchema.
 // -------------------------------------------------------------------------
 /** Generates TypeBox types from TypeScript code */
 export namespace TypeScriptToTypeBox {
@@ -195,6 +91,26 @@ export namespace TypeScriptToTypeBox {
     const types = node.types.map((type) => Collect(type)).join(',\n')
     yield `Type.Union([\n${types}\n])`
   }
+  // -------------------------------------------------------------------------
+  // TemplateLiteral
+  // -------------------------------------------------------------------------
+  function* TemplateLiteralTypeNode(node: ts.TemplateLiteralTypeNode) {
+    const collect = node.getChildren().map(node => Collect(node))
+    yield `Type.TemplateLiteral([${collect.join('')}])`
+  }
+  function* TemplateLiteralTypeSpan(node: ts.TemplateLiteralTypeSpan) {
+    const collect = node.getChildren().map(node => Collect(node))
+    yield collect.join(', ')
+  }
+  function* TemplateHead(node: ts.TemplateHead) {
+    yield `Type.Literal('${node.text}'), `
+  }
+  function* TemplateMiddle(node: ts.TemplateMiddle) {
+    yield `Type.Literal('${node.text}'), `
+  }
+  function* TemplateTail(node: ts.TemplateTail) {
+    yield `Type.Literal('${node.text}')`
+  }
   function* IntersectionTypeNode(node: ts.IntersectionTypeNode): IterableIterator<string> {
     const types = node.types.map((type) => Collect(type)).join(',\n')
     yield `Type.Intersect([\n${types}\n])`
@@ -340,45 +256,25 @@ export namespace TypeScriptToTypeBox {
   function* TypeReferenceNode(node: ts.TypeReferenceNode): IterableIterator<string> {
     const name = node.typeName.getText()
     const args = node.typeArguments ? `(${node.typeArguments.map((type) => Collect(type)).join(', ')})` : ''
-    if (name === 'Array') {
-      return yield `Type.Array${args}`
-    } else if (name === 'Record') {
-      return yield `Type.Record${args}`
-    } else if (name === 'Partial') {
-      return yield `Type.Partial${args}`
-    } else if (name === 'Uint8Array') {
-      return yield `Type.Uint8Array()`
-    } else if (name === 'Date') {
-      return yield `Type.Date()`
-    } else if (name === 'Required') {
-      return yield `Type.Required${args}`
-    } else if (name === 'Omit') {
-      return yield `Type.Omit${args}`
-    } else if (name === 'Pick') {
-      return yield `Type.Pick${args}`
-    } else if (name === 'Promise') {
-      return yield `Type.Promise${args}`
-    } else if (name === 'ReturnType') {
-      return yield `Type.ReturnType${args}`
-    } else if (name === 'InstanceType') {
-      return yield `Type.InstanceType${args}`
-    } else if (name === 'Parameters') {
-      return yield `Type.Parameters${args}`
-    } else if (name === 'ConstructorParameters') {
-      return yield `Type.ConstructorParameters${args}`
-    } else if (name === 'Exclude') {
-      return yield `Type.Exclude${args}`
-    } else if (name === 'Extract') {
-      return yield `Type.Extract${args}`
-    } else if (recursiveDeclaration !== null && FindRecursiveParent(recursiveDeclaration, node)) {
-      return yield `This`
-    } else if (typeNames.has(name)) {
-      return yield `${name}${args}`
-    } else if (name in globalThis) {
-      return yield `Type.Never(/* Unsupported Type '${name}' */)`
-    } else {
-      return yield `${name}${args}`
-    }
+    if (name === 'Array') return yield `Type.Array${args}`
+    if (name === 'Record') return yield `Type.Record${args}`
+    if (name === 'Partial') return yield `Type.Partial${args}`
+    if (name === 'Uint8Array') return yield `Type.Uint8Array()`
+    if (name === 'Date') return yield `Type.Date()`
+    if (name === 'Required') return yield `Type.Required${args}`
+    if (name === 'Omit') return yield `Type.Omit${args}`
+    if (name === 'Pick') return yield `Type.Pick${args}`
+    if (name === 'Promise') return yield `Type.Promise${args}`
+    if (name === 'ReturnType') return yield `Type.ReturnType${args}`
+    if (name === 'InstanceType') return yield `Type.InstanceType${args}`
+    if (name === 'Parameters') return yield `Type.Parameters${args}`
+    if (name === 'ConstructorParameters') return yield `Type.ConstructorParameters${args}`
+    if (name === 'Exclude') return yield `Type.Exclude${args}`
+    if (name === 'Extract') return yield `Type.Extract${args}`
+    if (recursiveDeclaration !== null && FindRecursiveParent(recursiveDeclaration, node)) return yield `This`
+    if (typeNames.has(name)) return yield `${name}${args}`
+    if (name in globalThis) return yield `Type.Never(/* Unsupported Type '${name}' */)`
+    return yield `${name}${args}`
   }
   function* LiteralTypeNode(node: ts.LiteralTypeNode): IterableIterator<string> {
     const text = node.getText()
@@ -411,99 +307,60 @@ export namespace TypeScriptToTypeBox {
   }
   function* Visit(node: ts.Node | undefined): IterableIterator<string> {
     if (node === undefined) return
-    if (ts.isSourceFile(node)) {
-      return yield* SourceFile(node)
-    } else if (ts.isInterfaceDeclaration(node)) {
-      return yield* InterfaceDeclaration(node)
-    } else if (ts.isTypeAliasDeclaration(node)) {
-      return yield* TypeAliasDeclaration(node)
-    } else if (ts.isParameter(node)) {
-      return yield* Parameter(node)
-    } else if (ts.isFunctionTypeNode(node)) {
-      return yield* FunctionTypeNode(node)
-    } else if (ts.isConstructorTypeNode(node)) {
-      return yield* ConstructorTypeNode(node)
-    } else if (ts.isEnumDeclaration(node)) {
-      return yield* EnumDeclaration(node)
-    } else if (ts.isPropertySignature(node)) {
-      return yield* PropertySignature(node)
-    } else if (ts.isTypeReferenceNode(node)) {
-      return yield* TypeReferenceNode(node)
-    } else if (ts.isTypeLiteralNode(node)) {
-      return yield* TypeLiteralNode(node)
-    } else if (ts.isLiteralTypeNode(node)) {
-      return yield* LiteralTypeNode(node)
-    } else if (ts.isModuleDeclaration(node)) {
-      return yield* ModuleDeclaration(node)
-    } else if (ts.isModuleBlock(node)) {
-      return yield* ModuleBlock(node)
-    } else if (ts.isArrayTypeNode(node)) {
-      return yield* ArrayTypeNode(node)
-    } else if (ts.isTupleTypeNode(node)) {
-      return yield* TupleTypeNode(node)
-    } else if (ts.isIntersectionTypeNode(node)) {
-      return yield* IntersectionTypeNode(node)
-    } else if (ts.isUnionTypeNode(node)) {
-      return yield* UnionTypeNode(node)
-    } else if (ts.isTemplateLiteralTypeNode(node)) {
-      return yield* StringTemplateLiteral.TemplateLiteralTypeNode(node)
-    } else if (ts.isTypeOperatorNode(node)) {
-      return yield* TypeOperatorNode(node)
-    } else if (ts.isHeritageClause(node)) {
-      return yield* HeritageClause(node)
-    } else if (ts.isExpressionWithTypeArguments(node)) {
-      return yield* ExpressionWithTypeArguments(node)
-    } else if (ts.isTypeParameterDeclaration(node)) {
-      return yield* TypeParameterDeclaration(node)
-    } else if (ts.isParenthesizedTypeNode(node)) {
-      return yield* ParenthesizedTypeNode(node)
-    } else if (ts.isRestTypeNode(node)) {
-      return yield* RestTypeNode(node)
-    } else if (ts.isFunctionDeclaration(node)) {
-      return yield* FunctionDeclaration(node)
-    } else if (ts.isClassDeclaration(node)) {
-      return yield* ClassDeclaration(node)
-    } else if (ts.isConditionalTypeNode(node)) {
-      return yield* ConditionalTypeNode(node)
-    } else if (ts.isIndexSignatureDeclaration(node)) {
-      return yield* isIndexSignatureDeclaration(node)
-    } else if (ts.isIdentifier(node)) {
-      return yield node.getText()
-    } else if (node.kind === ts.SyntaxKind.ExportKeyword) {
-      return yield `export`
-    } else if (node.kind === ts.SyntaxKind.KeyOfKeyword) {
-      return yield `Type.KeyOf()`
-    } else if (node.kind === ts.SyntaxKind.NumberKeyword) {
-      return yield `Type.Number()`
-    } else if (node.kind === ts.SyntaxKind.BigIntKeyword) {
-      return yield `Type.BigInt()`
-    } else if (node.kind === ts.SyntaxKind.StringKeyword) {
-      return yield `Type.String()`
-    } else if (node.kind === ts.SyntaxKind.BooleanKeyword) {
-      return yield `Type.Boolean()`
-    } else if (node.kind === ts.SyntaxKind.UndefinedKeyword) {
-      return yield `Type.Undefined()`
-    } else if (node.kind === ts.SyntaxKind.UnknownKeyword) {
-      return yield `Type.Unknown()`
-    } else if (node.kind === ts.SyntaxKind.AnyKeyword) {
-      return yield `Type.Any()`
-    } else if (node.kind === ts.SyntaxKind.NeverKeyword) {
-      return yield `Type.Never()`
-    } else if (node.kind === ts.SyntaxKind.NullKeyword) {
-      return yield `Type.Null()`
-    } else if (node.kind === ts.SyntaxKind.VoidKeyword) {
-      return yield `Type.Void()`
-    } else if (node.kind === ts.SyntaxKind.EndOfFileToken) {
-      return
-    } else if (node.kind === ts.SyntaxKind.SyntaxList) {
+    if (ts.isSourceFile(node)) return yield* SourceFile(node)
+    if (ts.isInterfaceDeclaration(node)) return yield* InterfaceDeclaration(node)
+    if (ts.isTypeAliasDeclaration(node)) return yield* TypeAliasDeclaration(node)
+    if (ts.isParameter(node)) return yield* Parameter(node)
+    if (ts.isFunctionTypeNode(node)) return yield* FunctionTypeNode(node)
+    if (ts.isConstructorTypeNode(node)) return yield* ConstructorTypeNode(node)
+    if (ts.isEnumDeclaration(node)) return yield* EnumDeclaration(node)
+    if (ts.isPropertySignature(node)) return yield* PropertySignature(node)
+    if (ts.isTypeReferenceNode(node)) return yield* TypeReferenceNode(node)
+    if (ts.isTypeLiteralNode(node)) return yield* TypeLiteralNode(node)
+    if (ts.isLiteralTypeNode(node)) return yield* LiteralTypeNode(node)
+    if (ts.isModuleDeclaration(node)) return yield* ModuleDeclaration(node)
+    if (ts.isModuleBlock(node)) return yield* ModuleBlock(node)
+    if (ts.isArrayTypeNode(node)) return yield* ArrayTypeNode(node)
+    if (ts.isTupleTypeNode(node)) return yield* TupleTypeNode(node)
+    if (ts.isIntersectionTypeNode(node)) return yield* IntersectionTypeNode(node)
+    if (ts.isUnionTypeNode(node)) return yield* UnionTypeNode(node)
+    if (ts.isTemplateLiteralTypeNode(node)) return yield* TemplateLiteralTypeNode(node)
+    if (ts.isTemplateLiteralTypeSpan(node)) return yield* TemplateLiteralTypeSpan(node)
+    if (ts.isTemplateHead(node)) return yield* TemplateHead(node)
+    if (ts.isTemplateMiddle(node)) return yield* TemplateMiddle(node)
+    if (ts.isTemplateTail(node)) return yield* TemplateTail(node)
+    if (ts.isTypeOperatorNode(node)) return yield* TypeOperatorNode(node)
+    if (ts.isHeritageClause(node)) return yield* HeritageClause(node)
+    if (ts.isExpressionWithTypeArguments(node)) return yield* ExpressionWithTypeArguments(node)
+    if (ts.isTypeParameterDeclaration(node)) return yield* TypeParameterDeclaration(node)
+    if (ts.isParenthesizedTypeNode(node)) return yield* ParenthesizedTypeNode(node)
+    if (ts.isRestTypeNode(node)) return yield* RestTypeNode(node)
+    if (ts.isFunctionDeclaration(node)) return yield* FunctionDeclaration(node)
+    if (ts.isClassDeclaration(node)) return yield* ClassDeclaration(node)
+    if (ts.isConditionalTypeNode(node)) return yield* ConditionalTypeNode(node)
+    if (ts.isIndexSignatureDeclaration(node)) return yield* isIndexSignatureDeclaration(node)
+    if (ts.isIdentifier(node)) return yield node.getText()
+    if (node.kind === ts.SyntaxKind.ExportKeyword) return yield `export`
+    if (node.kind === ts.SyntaxKind.KeyOfKeyword) return yield `Type.KeyOf()`
+    if (node.kind === ts.SyntaxKind.NumberKeyword) return yield `Type.Number()`
+    if (node.kind === ts.SyntaxKind.BigIntKeyword) return yield `Type.BigInt()`
+    if (node.kind === ts.SyntaxKind.StringKeyword) return yield `Type.String()`
+    if (node.kind === ts.SyntaxKind.BooleanKeyword) return yield `Type.Boolean()`
+    if (node.kind === ts.SyntaxKind.UndefinedKeyword) return yield `Type.Undefined()`
+    if (node.kind === ts.SyntaxKind.UnknownKeyword) return yield `Type.Unknown()`
+    if (node.kind === ts.SyntaxKind.AnyKeyword) return yield `Type.Any()`
+    if (node.kind === ts.SyntaxKind.NeverKeyword) return yield `Type.Never()`
+    if (node.kind === ts.SyntaxKind.NullKeyword) return yield `Type.Null()`
+    if (node.kind === ts.SyntaxKind.VoidKeyword) return yield `Type.Void()`
+    if (node.kind === ts.SyntaxKind.EndOfFileToken) return
+    if (node.kind === ts.SyntaxKind.SyntaxList) {
       for (const child of node.getChildren()) {
         yield* Visit(child)
       }
       return
-    } else {
-      console.log('Unhandled:', ts.SyntaxKind[node.kind])
-      return yield node.getText()
     }
+    console.log('Unhandled:', ts.SyntaxKind[node.kind])
+    return yield node.getText()
   }
   /** Generates TypeBox types from TypeScript interface and type definitions */
   export function Generate(typescriptCode: string) {
@@ -521,4 +378,4 @@ export namespace TypeScriptToTypeBox {
     const types = Formatter.Format(typeDeclarations)
     return [imports, '', types].join('\n')
   }
-}
+}
\ No newline at end of file
diff --git a/example/index.ts b/example/index.ts
index ed52156bd..c5ad5a144 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -37,4 +37,4 @@ console.log(C.Code())
 // Check: Value
 // -----------------------------------------------------------
 
-console.log(C.Check(V))
+console.log(C.Check(V))
\ No newline at end of file
diff --git a/hammer.mjs b/hammer.mjs
index 8cf594e67..e47b88f82 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -7,21 +7,18 @@ import { readFileSync } from 'fs'
 export async function clean() {
     await folder('target').delete()
 }
-
 // -------------------------------------------------------------------------------
 // Format
 // -------------------------------------------------------------------------------
 export async function format() {
     await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test example/index.ts benchmark')
 }
-
 // -------------------------------------------------------------------------------
 // Start
 // -------------------------------------------------------------------------------
 export async function start(example = 'index') {
     await shell(`hammer run example/${example}.ts --dist target/example/${example}`)
 }
-
 // -------------------------------------------------------------------------------
 // Benchmark
 // -------------------------------------------------------------------------------
diff --git a/package-lock.json b/package-lock.json
index e013c6885..64dbe8148 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,19 +1,19 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.26.0",
+      "version": "0.27.0",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
         "@types/chai": "^4.3.3",
         "@types/mocha": "^9.1.1",
         "@types/node": "^18.11.9",
-        "ajv": "^8.11.2",
+        "ajv": "^8.12.0",
         "ajv-formats": "^2.1.1",
         "chai": "^4.3.6",
         "mocha": "^9.2.2",
@@ -75,9 +75,9 @@
       "dev": true
     },
     "node_modules/ajv": {
-      "version": "8.11.2",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.2.tgz",
-      "integrity": "sha512-E4bfmKAhGiSTvMfL1Myyycaub+cUEU2/IvpylXkUu7CHBkBj1f/ikdzbD7YQ6FKUbixDxeYvB/xY4fvyroDlQg==",
+      "version": "8.12.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz",
+      "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==",
       "dev": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
@@ -1582,9 +1582,9 @@
       "dev": true
     },
     "ajv": {
-      "version": "8.11.2",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.2.tgz",
-      "integrity": "sha512-E4bfmKAhGiSTvMfL1Myyycaub+cUEU2/IvpylXkUu7CHBkBj1f/ikdzbD7YQ6FKUbixDxeYvB/xY4fvyroDlQg==",
+      "version": "8.12.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz",
+      "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==",
       "dev": true,
       "requires": {
         "fast-deep-equal": "^3.1.1",
diff --git a/package.json b/package.json
index aa248455b..6b792d3e1 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.26.8",
+  "version": "0.27.0",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -37,7 +37,7 @@
     "@types/chai": "^4.3.3",
     "@types/mocha": "^9.1.1",
     "@types/node": "^18.11.9",
-    "ajv": "^8.11.2",
+    "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
     "chai": "^4.3.6",
     "mocha": "^9.2.2",
diff --git a/readme.md b/readme.md
index 265d408e4..b5cb73687 100644
--- a/readme.md
+++ b/readme.md
@@ -81,6 +81,7 @@ License MIT
   - [References](#types-references)
   - [Recursive](#types-recursive)
   - [Conditional](#types-conditional)
+  - [Template Literal](#types-template-literal)
   - [Guards](#types-guards)
   - [Unsafe](#types-unsafe)
   - [Strict](#types-strict)
@@ -264,12 +265,12 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │   Type.Number(),               │                             │   type: 'array',               │
 │   Type.Number()                │                             │   items: [{                    │
 │ ])                             │                             │      type: 'number'            │
-│                                │                             │    }, {                        │
-│                                │                             │      type: 'number'            │
-│                                │                             │    }],                         │
-│                                │                             │    additionalItems: false,     │
-│                                │                             │    minItems: 2,                │
-│                                │                             │    maxItems: 2                 │
+│                                │                             │   }, {                         │
+│                                │                             │     type: 'number'             │
+│                                │                             │   }],                          │
+│                                │                             │   additionalItems: false,      │
+│                                │                             │   minItems: 2,                 │
+│                                │                             │   maxItems: 2                  │
 │                                │                             │ }                              │
 │                                │                             │                                │
 │                                │                             │                                │
@@ -321,6 +322,7 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │       y: {                     │
 │                                │                             │         type: 'number'         │
 │                                │                             │       }                        │
+│                                │                             │     }                          │
 │                                │                             │   }]                           │
 │                                │                             │ }                              │
 │                                │                             │                                │
@@ -385,6 +387,18 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │ )                              │                             │                                │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const U = Type.Union([         │ type U = 'open' | 'close'   │ const T = {                    │
+│   Type.Literal('open'),        │                             │   type: 'string',              │
+│   Type.Literal('close')        │ type T = `on${U}`           │   pattern: '^on(open|close)$'  │
+│ ])                             │                             │ }                              │
+│                                │                             │                                │
+│ const T = Type                 │                             │                                │
+│   .TemplateLiteral([           │                             │                                │
+│      Type.Literal('on'),       │                             │                                │
+│      U                         │                             │                                │
+│   ])                           │                             │                                │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Record(         │ type T = Record<            │ const T = {                    │
 │   Type.String(),               │   string,                   │   type: 'object',              │
 │   Type.Number()                │   number,                   │   patternProperties: {         │
@@ -424,23 +438,23 @@ The following table lists the Standard TypeBox types. These types are fully comp
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Pick(           │ type T = Pick<{             │ const T = {                    │
 │   Type.Object({                │   x: number,                │   type: 'object',              │
-│     x: Type.Number(),          │   y: number                 │   properties: {                │
-│     y: Type.Number()           | }, 'x'>                     │     x: {                       │
-│   }), ['x']                    │                             │       type: 'number'           │
-│ )                              │                             │     }                          │
-│                                │                             │   },                           │
-│                                │                             │   required: ['x']              │
+│     x: Type.Number(),          │   y: number                 │   required: ['x'],             │
+│     y: Type.Number()           │ }, 'x'>                     │   properties: {                │
+│   }), ['x']                    |                             │     x: {                       │
+│ )                              │                             │       type: 'number'           │
+│                                │                             │     }                          │
+│                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Omit(           │ type T = Omit<{             │ const T = {                    │
 │   Type.Object({                │   x: number,                │   type: 'object',              │
-│     x: Type.Number(),          │   y: number                 │   properties: {                │
-│     y: Type.Number()           | }, 'x'>                     │     y: {                       │
-│   }), ['x']                    │                             │       type: 'number'           │
-│ )                              │                             │     }                          │
-│                                │                             │   },                           │
-│                                │                             │   required: ['y']              │
+│     x: Type.Number(),          │   y: number                 │   required: ['y'],             │
+│     y: Type.Number()           │ }, 'x'>                     │   properties: {                │
+│   }), ['x']                    |                             │     y: {                       │
+│ )                              │                             │       type: 'number'           │
+│                                │                             │     }                          │
+│                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -687,7 +701,7 @@ type T = Static<typeof T>                           // type T = string | null
 
 ### Reference Types
 
-Reference types are supported with `Type.Ref(...)`. The target type must specify a valid `$id`.
+Reference types are supported with `Type.Ref`. The target type must specify a valid `$id`.
 
 ```typescript
 const T = Type.String({ $id: 'T' })                  // const T = {
@@ -704,7 +718,7 @@ const R = Type.Ref(T)                                // const R = {
 
 ### Recursive Types
 
-Recursive types are supported with `Type.Recursive(...)`.
+Recursive types are supported with `Type.Recursive`
 
 ```typescript
 const Node = Type.Recursive(Node => Type.Object({    // const Node = {
@@ -741,33 +755,85 @@ function test(node: Node) {
 
 ### Conditional Types
 
-Conditional types are supported with `Extends`, `Exclude` and `Extract`.
-
-**TypeScript**
+Conditional types are supported with `Type.Extends`, `Type.Exclude` and `Type.Extract`
 
 ```typescript
-type T0 = string extends number ? true : false                                                 
-//   ^ false
-type T1 = Extract<string | number, number>                                                     
-//   ^ number
-type T2 = Exclude<string | number, number>                                                     
-//   ^ string
+// TypeScript
+
+type T0 = string extends number ? true : false       // type T0 = false
+
+type T1 = Extract<string | number, number>           // type T1 = number
+
+type T2 = Exclude<string | number, number>           // type T2 = string
+
+// TypeBox
+
+const T0 = Type.Extends(Type.String(), Type.Number(), Type.Literal(true), Type.Literal(false))
+
+const T1 = Type.Extract(Type.Union([Type.String(), Type.Number()]), Type.Number())
+
+const T2 = Type.Exclude(Type.Union([Type.String(), Type.Number()]), Type.Number())
+
+
+type T0 = Static<typeof T0>                        // type T0 = false
+
+type T1 = Static<typeof T1>                        // type T1 = number
+
+type T2 = Static<typeof T2>                        // type T2 = string 
 ```
-**TypeBox**
+
+<a name='types-template-literal'></a>
+
+### Template Literal Types
+
+Template Literal types are supported with `Type.TemplateLiteral`
+
 ```typescript
-const T0 = Type.Extends(Type.String(), Type.Number(), Type.Literal(true), Type.Literal(false)) 
-//    ^ TLiteral<false>
-const T1 = Type.Extract(Type.Union([Type.String(), Type.Number()]), Type.Number())             
-//    ^ TNumber
-const T2 = Type.Exclude(Type.Union([Type.String(), Type.Number()]), Type.Number())             
-//    ^ TString<string>
+// TypeScript
+
+type T = `option${'A'|'B'}`                          // type T = 'optionA' | 'optionB'
+
+type R = Record<T, string>                           // type R = {
+                                                     //   optionA: string
+                                                     //   optionB: string
+                                                     // }
+
+// TypeBox
+
+const T = Type.TemplateLiteral([                     // const T = {
+  Type.Literal('option'),                            //   pattern: '^option(A|B)$',
+  Type.Union([                                       //   type: 'string'
+    Type.Literal('A'),                               // }
+    Type.Literal('B')
+  ])
+])
+
+const R = Type.Record(T, Type.String())              // const R = {
+                                                     //   type: 'object',
+                                                     //   required: ['optionA', 'optionB'],
+                                                     //   properties: {
+                                                     //     optionA: {
+                                                     //       type: 'string'
+                                                     //     },
+                                                     //     optionB: {
+                                                     //       type: 'string'
+                                                     //     }
+                                                     //   }
+                                                     // }
+
+type T = Static<typeof T>                            // type T = 'optionA' | 'optionB'
+
+type R = Static<typeof R>                            // type R = {
+                                                     //   optionA: string
+                                                     //   optionB: string
+                                                     // }
 ```
 
 <a name='types-unsafe'></a>
 
 ### Unsafe
 
-Use `Type.Unsafe(...)` to create custom schematics with user defined inference rules.
+Use `Type.Unsafe` to create custom schematics with user defined inference rules.
 
 ```typescript
 const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
@@ -777,7 +843,7 @@ const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
 type T = Static<typeof T>                            // type T = string
 ```
 
-The `Type.Unsafe(...)` type can be useful to express specific OpenAPI schema representations.
+The `Type.Unsafe` type can be useful to express specific OpenAPI schema representations.
 
 ```typescript
 import { Type, Static, TSchema } from '@sinclair/typebox'
@@ -829,7 +895,7 @@ if(TypeGuard.TString(T)) {
 
 ### Strict
 
-TypeBox schemas contain the `Kind` and `Modifier` symbol properties. These properties are used for type composition and reflection. These properties are not strictly valid JSON schema; so in some cases it may be desirable to omit them. TypeBox provides a `Type.Strict()` function that will omit these properties if necessary.
+TypeBox schemas contain the `Kind` and `Modifier` symbol properties. These properties are used for type composition and reflection. These properties are not strictly valid JSON schema; so in some cases it may be desirable to omit them. TypeBox provides a `Type.Strict` function that will omit these properties if necessary.
 
 ```typescript
 const T = Type.Object({                              // const T = {
@@ -905,7 +971,7 @@ const R = Value.Check(T, { x: 1 })                   // const R = true
 Use the Convert function to convert a value into its target type if a reasonable conversion is possible.
 
 ```typescript
-const T = Type.Object({ x: Type.Number(), y: Type.Number() })
+const T = Type.Object({ x: Type.Number() })
 
 const R1 = Value.Convert(T, { x: '3.14' })          // const R1 = { x: 3.14 }
 
@@ -1181,16 +1247,16 @@ const R = Value.Check(T, { x: 1, y: 2 })              // const R = true
 
 ### Formats
 
-Use the `Format(...)` function to create a custom string format. The following creates a custom string format that checks for lowercase strings.
+Use the `Format(...)` function to create a custom string format. The following creates a format that checks for lowercase strings.
 
 ```typescript
 TypeSystem.Format('lowercase', value => value === value.toLowerCase()) // format should be lowercase
 
 const T = Type.String({ format: 'lowercase' })       
 
-const A = Value.Check(T, 'action')                   // const A = true
+const A = Value.Check(T, 'Hello')                    // const A = false
 
-const B = Value.Check(T, 'ACTION')                   // const B = false
+const B = Value.Check(T, 'hello')                    // const B = true
 ```
 
 <a name='typesystem-policies'></a>
@@ -1217,7 +1283,7 @@ TypeSystem.AllowNaN = true
 
 ## Benchmark
 
-This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.11.2. 
+This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.12.0. 
 
 For additional comparative benchmarks, please refer to [typescript-runtime-type-benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/).
 
@@ -1231,33 +1297,35 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │    1000    │ '    260 ms' │ '      8 ms' │ '   32.50 x' │
-│ Literal_Number             │    1000    │ '    198 ms' │ '      4 ms' │ '   49.50 x' │
-│ Literal_Boolean            │    1000    │ '    185 ms' │ '      5 ms' │ '   37.00 x' │
-│ Primitive_Number           │    1000    │ '    176 ms' │ '      9 ms' │ '   19.56 x' │
-│ Primitive_String           │    1000    │ '    161 ms' │ '      9 ms' │ '   17.89 x' │
-│ Primitive_String_Pattern   │    1000    │ '    215 ms' │ '     12 ms' │ '   17.92 x' │
-│ Primitive_Boolean          │    1000    │ '    133 ms' │ '      5 ms' │ '   26.60 x' │
-│ Primitive_Null             │    1000    │ '    143 ms' │ '      8 ms' │ '   17.88 x' │
-│ Object_Unconstrained       │    1000    │ '   1181 ms' │ '     38 ms' │ '   31.08 x' │
-│ Object_Constrained         │    1000    │ '   1168 ms' │ '     32 ms' │ '   36.50 x' │
-│ Tuple_Primitive            │    1000    │ '    557 ms' │ '     16 ms' │ '   34.81 x' │
-│ Tuple_Object               │    1000    │ '   1119 ms' │ '     17 ms' │ '   65.82 x' │
-│ Composite_Intersect        │    1000    │ '    569 ms' │ '     22 ms' │ '   25.86 x' │
-│ Composite_Union            │    1000    │ '    513 ms' │ '     23 ms' │ '   22.30 x' │
-│ Math_Vector4               │    1000    │ '    802 ms' │ '     10 ms' │ '   80.20 x' │
-│ Math_Matrix4               │    1000    │ '    395 ms' │ '     12 ms' │ '   32.92 x' │
-│ Array_Primitive_Number     │    1000    │ '    282 ms' │ '      8 ms' │ '   35.25 x' │
-│ Array_Primitive_String     │    1000    │ '    321 ms' │ '      5 ms' │ '   64.20 x' │
-│ Array_Primitive_Boolean    │    1000    │ '    364 ms' │ '      5 ms' │ '   72.80 x' │
-│ Array_Object_Unconstrained │    1000    │ '   1573 ms' │ '     18 ms' │ '   87.39 x' │
-│ Array_Object_Constrained   │    1000    │ '   1270 ms' │ '     20 ms' │ '   63.50 x' │
-│ Array_Tuple_Primitive      │    1000    │ '    973 ms' │ '     18 ms' │ '   54.06 x' │
-│ Array_Tuple_Object         │    1000    │ '   1253 ms' │ '     16 ms' │ '   78.31 x' │
-│ Array_Composite_Intersect  │    1000    │ '    927 ms' │ '     20 ms' │ '   46.35 x' │
-│ Array_Composite_Union      │    1000    │ '   1123 ms' │ '     16 ms' │ '   70.19 x' │
-│ Array_Math_Vector4         │    1000    │ '   1068 ms' │ '     10 ms' │ '  106.80 x' │
-│ Array_Math_Matrix4         │    1000    │ '    488 ms' │ '      7 ms' │ '   69.71 x' │
+│ Literal_String             │    1000    │ '    257 ms' │ '      8 ms' │ '   32.13 x' │
+│ Literal_Number             │    1000    │ '    203 ms' │ '      4 ms' │ '   50.75 x' │
+│ Literal_Boolean            │    1000    │ '    183 ms' │ '      4 ms' │ '   45.75 x' │
+│ Primitive_Number           │    1000    │ '    174 ms' │ '      8 ms' │ '   21.75 x' │
+│ Primitive_String           │    1000    │ '    158 ms' │ '      9 ms' │ '   17.56 x' │
+│ Primitive_String_Pattern   │    1000    │ '    213 ms' │ '     13 ms' │ '   16.38 x' │
+│ Primitive_Boolean          │    1000    │ '    136 ms' │ '      6 ms' │ '   22.67 x' │
+│ Primitive_Null             │    1000    │ '    144 ms' │ '      6 ms' │ '   24.00 x' │
+│ Object_Unconstrained       │    1000    │ '   1176 ms' │ '     38 ms' │ '   30.95 x' │
+│ Object_Constrained         │    1000    │ '   1181 ms' │ '     31 ms' │ '   38.10 x' │
+│ Object_Vector3             │    1000    │ '    387 ms' │ '      8 ms' │ '   48.38 x' │
+│ Object_Box3D               │    1000    │ '   1693 ms' │ '     25 ms' │ '   67.72 x' │
+│ Tuple_Primitive            │    1000    │ '    470 ms' │ '     15 ms' │ '   31.33 x' │
+│ Tuple_Object               │    1000    │ '   1206 ms' │ '     17 ms' │ '   70.94 x' │
+│ Composite_Intersect        │    1000    │ '    567 ms' │ '     20 ms' │ '   28.35 x' │
+│ Composite_Union            │    1000    │ '    515 ms' │ '     21 ms' │ '   24.52 x' │
+│ Math_Vector4               │    1000    │ '    787 ms' │ '     10 ms' │ '   78.70 x' │
+│ Math_Matrix4               │    1000    │ '    386 ms' │ '      8 ms' │ '   48.25 x' │
+│ Array_Primitive_Number     │    1000    │ '    349 ms' │ '      7 ms' │ '   49.86 x' │
+│ Array_Primitive_String     │    1000    │ '    336 ms' │ '      4 ms' │ '   84.00 x' │
+│ Array_Primitive_Boolean    │    1000    │ '    284 ms' │ '      3 ms' │ '   94.67 x' │
+│ Array_Object_Unconstrained │    1000    │ '   1704 ms' │ '     19 ms' │ '   89.68 x' │
+│ Array_Object_Constrained   │    1000    │ '   1456 ms' │ '     18 ms' │ '   80.89 x' │
+│ Array_Tuple_Primitive      │    1000    │ '    792 ms' │ '     15 ms' │ '   52.80 x' │
+│ Array_Tuple_Object         │    1000    │ '   1552 ms' │ '     17 ms' │ '   91.29 x' │
+│ Array_Composite_Intersect  │    1000    │ '    744 ms' │ '     18 ms' │ '   41.33 x' │
+│ Array_Composite_Union      │    1000    │ '    783 ms' │ '     15 ms' │ '   52.20 x' │
+│ Array_Math_Vector4         │    1000    │ '   1093 ms' │ '     14 ms' │ '   78.07 x' │
+│ Array_Math_Matrix4         │    1000    │ '    684 ms' │ '      6 ms' │ '  114.00 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1271,35 +1339,37 @@ This benchmark measures validation performance for varying types. You can review
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │  1000000   │ '     26 ms' │ '      6 ms' │ '      6 ms' │ '    1.00 x' │
-│ Literal_Number             │  1000000   │ '     21 ms' │ '     19 ms' │ '     11 ms' │ '    1.73 x' │
-│ Literal_Boolean            │  1000000   │ '     19 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
-│ Primitive_Number           │  1000000   │ '     24 ms' │ '     19 ms' │ '     11 ms' │ '    1.73 x' │
-│ Primitive_String           │  1000000   │ '     26 ms' │ '     17 ms' │ '     10 ms' │ '    1.70 x' │
-│ Primitive_String_Pattern   │  1000000   │ '    159 ms' │ '     45 ms' │ '     37 ms' │ '    1.22 x' │
-│ Primitive_Boolean          │  1000000   │ '     23 ms' │ '     17 ms' │ '     10 ms' │ '    1.70 x' │
-│ Primitive_Null             │  1000000   │ '     23 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
-│ Object_Unconstrained       │  1000000   │ '    809 ms' │ '     35 ms' │ '     30 ms' │ '    1.17 x' │
-│ Object_Constrained         │  1000000   │ '   1060 ms' │ '     56 ms' │ '     45 ms' │ '    1.24 x' │
-│ Object_Recursive           │  1000000   │ '   4965 ms' │ '    397 ms' │ '    100 ms' │ '    3.97 x' │
-│ Tuple_Primitive            │  1000000   │ '    159 ms' │ '     22 ms' │ '     16 ms' │ '    1.38 x' │
-│ Tuple_Object               │  1000000   │ '    658 ms' │ '     31 ms' │ '     27 ms' │ '    1.15 x' │
-│ Composite_Intersect        │  1000000   │ '    695 ms' │ '     26 ms' │ '     22 ms' │ '    1.18 x' │
-│ Composite_Union            │  1000000   │ '    503 ms' │ '     24 ms' │ '     19 ms' │ '    1.26 x' │
-│ Math_Vector4               │  1000000   │ '    259 ms' │ '     22 ms' │ '     14 ms' │ '    1.57 x' │
-│ Math_Matrix4               │  1000000   │ '   1007 ms' │ '     40 ms' │ '     29 ms' │ '    1.38 x' │
-│ Array_Primitive_Number     │  1000000   │ '    262 ms' │ '     23 ms' │ '     17 ms' │ '    1.35 x' │
-│ Array_Primitive_String     │  1000000   │ '    241 ms' │ '     27 ms' │ '     24 ms' │ '    1.13 x' │
-│ Array_Primitive_Boolean    │  1000000   │ '    141 ms' │ '     23 ms' │ '     20 ms' │ '    1.15 x' │
-│ Array_Object_Unconstrained │  1000000   │ '   4976 ms' │ '     70 ms' │ '     67 ms' │ '    1.04 x' │
-│ Array_Object_Constrained   │  1000000   │ '   5234 ms' │ '    143 ms' │ '    120 ms' │ '    1.19 x' │
-│ Array_Object_Recursive     │  1000000   │ '  19605 ms' │ '   1909 ms' │ '    350 ms' │ '    5.45 x' │
-│ Array_Tuple_Primitive      │  1000000   │ '    706 ms' │ '     39 ms' │ '     32 ms' │ '    1.22 x' │
-│ Array_Tuple_Object         │  1000000   │ '   2951 ms' │ '     67 ms' │ '     63 ms' │ '    1.06 x' │
-│ Array_Composite_Intersect  │  1000000   │ '   2969 ms' │ '     49 ms' │ '     44 ms' │ '    1.11 x' │
-│ Array_Composite_Union      │  1000000   │ '   2191 ms' │ '     77 ms' │ '     41 ms' │ '    1.88 x' │
-│ Array_Math_Vector4         │  1000000   │ '   1164 ms' │ '     41 ms' │ '     25 ms' │ '    1.64 x' │
-│ Array_Math_Matrix4         │  1000000   │ '   4903 ms' │ '    115 ms' │ '     99 ms' │ '    1.16 x' │
+│ Literal_String             │  1000000   │ '     27 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
+│ Literal_Number             │  1000000   │ '     23 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
+│ Literal_Boolean            │  1000000   │ '     21 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
+│ Primitive_Number           │  1000000   │ '     26 ms' │ '     19 ms' │ '     11 ms' │ '    1.73 x' │
+│ Primitive_String           │  1000000   │ '     25 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│ Primitive_String_Pattern   │  1000000   │ '    155 ms' │ '     49 ms' │ '     43 ms' │ '    1.14 x' │
+│ Primitive_Boolean          │  1000000   │ '     23 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│ Primitive_Null             │  1000000   │ '     24 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│ Object_Unconstrained       │  1000000   │ '    804 ms' │ '     35 ms' │ '     28 ms' │ '    1.25 x' │
+│ Object_Constrained         │  1000000   │ '   1041 ms' │ '     55 ms' │ '     41 ms' │ '    1.34 x' │
+│ Object_Vector3             │  1000000   │ '    380 ms' │ '     26 ms' │ '     20 ms' │ '    1.30 x' │
+│ Object_Box3D               │  1000000   │ '   1785 ms' │ '     65 ms' │ '     52 ms' │ '    1.25 x' │
+│ Object_Recursive           │  1000000   │ '   4984 ms' │ '    396 ms' │ '    114 ms' │ '    3.47 x' │
+│ Tuple_Primitive            │  1000000   │ '    168 ms' │ '     24 ms' │ '     16 ms' │ '    1.50 x' │
+│ Tuple_Object               │  1000000   │ '    673 ms' │ '     30 ms' │ '     26 ms' │ '    1.15 x' │
+│ Composite_Intersect        │  1000000   │ '    751 ms' │ '     28 ms' │ '     20 ms' │ '    1.40 x' │
+│ Composite_Union            │  1000000   │ '    489 ms' │ '     24 ms' │ '     16 ms' │ '    1.50 x' │
+│ Math_Vector4               │  1000000   │ '    259 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
+│ Math_Matrix4               │  1000000   │ '   1002 ms' │ '     40 ms' │ '     30 ms' │ '    1.33 x' │
+│ Array_Primitive_Number     │  1000000   │ '    252 ms' │ '     22 ms' │ '     15 ms' │ '    1.47 x' │
+│ Array_Primitive_String     │  1000000   │ '    227 ms' │ '     22 ms' │ '     18 ms' │ '    1.22 x' │
+│ Array_Primitive_Boolean    │  1000000   │ '    150 ms' │ '     23 ms' │ '     22 ms' │ '    1.05 x' │
+│ Array_Object_Unconstrained │  1000000   │ '   4754 ms' │ '     71 ms' │ '     64 ms' │ '    1.11 x' │
+│ Array_Object_Constrained   │  1000000   │ '   4787 ms' │ '    142 ms' │ '    123 ms' │ '    1.15 x' │
+│ Array_Object_Recursive     │  1000000   │ '  19088 ms' │ '   1735 ms' │ '    314 ms' │ '    5.53 x' │
+│ Array_Tuple_Primitive      │  1000000   │ '    650 ms' │ '     41 ms' │ '     31 ms' │ '    1.32 x' │
+│ Array_Tuple_Object         │  1000000   │ '   2770 ms' │ '     67 ms' │ '     55 ms' │ '    1.22 x' │
+│ Array_Composite_Intersect  │  1000000   │ '   2693 ms' │ '     50 ms' │ '     39 ms' │ '    1.28 x' │
+│ Array_Composite_Union      │  1000000   │ '   1982 ms' │ '     72 ms' │ '     33 ms' │ '    2.18 x' │
+│ Array_Math_Vector4         │  1000000   │ '   1068 ms' │ '     40 ms' │ '     26 ms' │ '    1.54 x' │
+│ Array_Math_Matrix4         │  1000000   │ '   4609 ms' │ '    115 ms' │ '     88 ms' │ '    1.31 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1313,11 +1383,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '108.8 kb' │ ' 48.9 kb' │  '2.23 x'   │
-│ typebox/errors       │ ' 93.2 kb' │ ' 41.5 kb' │  '2.24 x'   │
-│ typebox/system       │ ' 60.0 kb' │ ' 24.6 kb' │  '2.43 x'   │
-│ typebox/value        │ '153.5 kb' │ ' 66.7 kb' │  '2.30 x'   │
-│ typebox              │ ' 58.7 kb' │ ' 24.1 kb' │  '2.43 x'   │
+│ typebox/compiler     │ '124.3 kb' │ ' 55.7 kb' │  '2.23 x'   │
+│ typebox/errors       │ '107.8 kb' │ ' 47.9 kb' │  '2.25 x'   │
+│ typebox/system       │ ' 73.3 kb' │ ' 30.2 kb' │  '2.43 x'   │
+│ typebox/value        │ '170.7 kb' │ ' 74.2 kb' │  '2.30 x'   │
+│ typebox              │ ' 72.0 kb' │ ' 29.7 kb' │  '2.43 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 1d269f98a..03d27ffeb 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -307,10 +307,6 @@ export namespace TypeCompiler {
     if (state_local_function_names.has(schema.$ref)) return yield `${CreateFunctionName(schema.$ref)}(${value})`
     yield* Visit(target, references, value)
   }
-  function* Self(schema: Types.TSelf, references: Types.TSchema[], value: string): IterableIterator<string> {
-    const func = CreateFunctionName(schema.$ref)
-    yield `${func}(${value})`
-  }
   function* String(schema: Types.TString, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'string')`
     if (IsNumber(schema.minLength)) yield `${value}.length >= ${schema.minLength}`
@@ -326,6 +322,15 @@ export namespace TypeCompiler {
   function* Symbol(schema: Types.TSymbol, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'symbol')`
   }
+  function* TemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield `(typeof ${value} === 'string')`
+    const local = PushLocal(`${new RegExp(schema.pattern)};`)
+    yield `${local}.test(${value})`
+  }
+  function* This(schema: Types.TThis, references: Types.TSchema[], value: string): IterableIterator<string> {
+    const func = CreateFunctionName(schema.$ref)
+    yield `${func}(${value})`
+  }
   function* Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(Array.isArray(${value}))`
     if (schema.items === undefined) return yield `${value}.length === 0`
@@ -409,12 +414,14 @@ export namespace TypeCompiler {
         return yield* Record(schema_, references_, value)
       case 'Ref':
         return yield* Ref(schema_, references_, value)
-      case 'Self':
-        return yield* Self(schema_, references_, value)
       case 'String':
         return yield* String(schema_, references_, value)
       case 'Symbol':
         return yield* Symbol(schema_, references_, value)
+      case 'TemplateLiteral':
+        return yield* TemplateLiteral(schema_, references_, value)
+      case 'This':
+        return yield* This(schema_, references_, value)
       case 'Tuple':
         return yield* Tuple(schema_, references_, value)
       case 'Undefined':
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 521343938..1d8d7615e 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -126,7 +126,7 @@ export class ValueErrorsUnknownTypeError extends Error {
   }
 }
 export class ValueErrorsDereferenceError extends Error {
-  constructor(public readonly schema: Types.TRef | Types.TSelf) {
+  constructor(public readonly schema: Types.TRef | Types.TThis) {
     super(`ValueErrors: Unable to dereference schema with $id '${schema.$ref}'`)
   }
 }
@@ -399,7 +399,7 @@ export namespace ValueErrors {
     const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
     const regex = new RegExp(keyPattern)
     if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {
-      const numeric = keyPattern === '^(0|[1-9][0-9]*)$'
+      const numeric = keyPattern === Types.PatternNumberExact
       const type = numeric ? ValueErrorType.RecordKeyNumeric : ValueErrorType.RecordKeyString
       const message = numeric ? 'Expected all object property keys to be numeric' : 'Expected all object property keys to be strings'
       return yield { type, schema, path, value, message }
@@ -414,12 +414,6 @@ export namespace ValueErrors {
     const target = references[index]
     yield* Visit(target, references, path, value)
   }
-  function* Self(schema: Types.TSelf, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-    if (index === -1) throw new ValueErrorsDereferenceError(schema)
-    const target = references[index]
-    yield* Visit(target, references, path, value)
-  }
   function* String(schema: Types.TString, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!IsString(value)) {
       return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' }
@@ -452,6 +446,21 @@ export namespace ValueErrors {
       return yield { type: ValueErrorType.Symbol, schema, path, value, message: 'Expected symbol' }
     }
   }
+  function* TemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    if (!IsString(value)) {
+      return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' }
+    }
+    const regex = new RegExp(schema.pattern)
+    if (!regex.test(value)) {
+      yield { type: ValueErrorType.StringPattern, schema, path, value, message: `Expected string to match pattern ${schema.pattern}` }
+    }
+  }
+  function* This(schema: Types.TThis, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+    if (index === -1) throw new ValueErrorsDereferenceError(schema)
+    const target = references[index]
+    yield* Visit(target, references, path, value)
+  }
   function* Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!globalThis.Array.isArray(value)) {
       return yield { type: ValueErrorType.Array, schema, path, value, message: 'Expected Array' }
@@ -551,12 +560,14 @@ export namespace ValueErrors {
         return yield* Record(schema_, references_, path, value)
       case 'Ref':
         return yield* Ref(schema_, references_, path, value)
-      case 'Self':
-        return yield* Self(schema_, references_, path, value)
       case 'String':
         return yield* String(schema_, references_, path, value)
       case 'Symbol':
         return yield* Symbol(schema_, references_, path, value)
+      case 'TemplateLiteral':
+        return yield* TemplateLiteral(schema_, references_, path, value)
+      case 'This':
+        return yield* This(schema_, references_, path, value)
       case 'Tuple':
         return yield* Tuple(schema_, references_, path, value)
       case 'Undefined':
diff --git a/src/typebox.ts b/src/typebox.ts
index 9887da23e..a25d5b0d2 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -27,12 +27,21 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 // --------------------------------------------------------------------------
-// Compositing Symbols
+// Symbols
 // --------------------------------------------------------------------------
 export const Modifier = Symbol.for('TypeBox.Modifier')
 export const Hint = Symbol.for('TypeBox.Hint')
 export const Kind = Symbol.for('TypeBox.Kind')
 // --------------------------------------------------------------------------
+// Patterns
+// --------------------------------------------------------------------------
+export const PatternBoolean = '(true|false)'
+export const PatternNumber = '(0|[1-9][0-9]*)'
+export const PatternString = '.*'
+export const PatternBooleanExact = `^${PatternBoolean}$`
+export const PatternNumberExact = `^${PatternNumber}$`
+export const PatternStringExact = `^${PatternString}$`
+// --------------------------------------------------------------------------
 // Helpers
 // --------------------------------------------------------------------------
 export type TupleToIntersect<T extends any[]> = T extends [infer I] ? I : T extends [infer I, ...infer R] ? I & TupleToIntersect<R> : never
@@ -99,9 +108,10 @@ export type TAnySchema =
   | TPromise
   | TRecord
   | TRef
-  | TSelf
   | TString
   | TSymbol
+  | TTemplateLiteral
+  | TThis
   | TTuple
   | TUndefined
   | TUnion
@@ -210,10 +220,9 @@ export interface TEnumOption<T> {
   type: 'number' | 'string'
   const: T
 }
-export type TEnumStatic<T extends Record<string, string | number>> = T[keyof T]
 export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
   [Kind]: 'Union'
-  static: TEnumStatic<T>
+  static: T[keyof T]
   anyOf: TLiteral<string | number>[]
 }
 // --------------------------------------------------------------------------
@@ -227,19 +236,31 @@ export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, U
 // --------------------------------------------------------------------------
 // TExclude
 // --------------------------------------------------------------------------
+export type TExcludeTemplateLiteralResult<T extends string> = TUnionResult<Assert<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>, TSchema[]>>
+export type TExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Exclude<Static<T>, Static<U>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never
 // prettier-ignore
 export type TExcludeArray<T extends TSchema[], U extends TSchema> = Assert<UnionToTuple<{
   [K in keyof T]: Static<Assert<T[K], TSchema>> extends Static<U> ? never : T[K]
 }[number]>, TSchema[]> extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never
-export type TExclude<T extends TSchema, U extends TSchema> = T extends TUnion<infer S> ? TExcludeArray<S, U> : T extends U ? TNever : T
+// prettier-ignore
+export type TExclude<T extends TSchema, U extends TSchema> = 
+  T extends TTemplateLiteral ? TExcludeTemplateLiteral<T, U> : 
+  T extends TUnion<infer S> ? TExcludeArray<S, U> : 
+  T extends U ? TNever : T
 // --------------------------------------------------------------------------
 // TExtract
 // --------------------------------------------------------------------------
+export type TExtractTemplateLiteralResult<T extends string> = TUnionResult<Assert<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>, TSchema[]>>
+export type TExtractTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? TExtractTemplateLiteralResult<Assert<S, string>> : never
 // prettier-ignore
 export type TExtractArray<T extends TSchema[], U extends TSchema> = Assert<UnionToTuple<
   {[K in keyof T]: Static<Assert<T[K], TSchema>> extends Static<U> ? T[K] : never
 }[number]>, TSchema[]> extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never
-export type TExtract<T extends TSchema, U extends TSchema> = T extends TUnion<infer S> ? TExtractArray<S, U> : T extends U ? T : TNever
+// prettier-ignore
+export type TExtract<T extends TSchema, U extends TSchema> = 
+  T extends TTemplateLiteral ? TExtractTemplateLiteral<T, U> : 
+  T extends TUnion<infer S> ? TExtractArray<S, U> : 
+  T extends U ? T : T
 // --------------------------------------------------------------------------
 // TFunction
 // --------------------------------------------------------------------------
@@ -267,12 +288,10 @@ export type TUnevaluatedProperties = undefined | TSchema | boolean
 export interface IntersectOptions extends SchemaOptions {
   unevaluatedProperties?: TUnevaluatedProperties
 }
-export type TIntersectStatic<T extends TSchema[], P extends unknown[]> = TupleToIntersect<{ [K in keyof T]: Static<Assert<T[K], TSchema>, P> }>
-
 export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
   [Kind]: 'Intersect'
+  static: TupleToIntersect<{ [K in keyof T]: Static<Assert<T[K], TSchema>, this['params']> }>
   type?: 'object'
-  static: TIntersectStatic<T, this['params']>
   allOf: [...T]
 }
 // --------------------------------------------------------------------------
@@ -286,10 +305,11 @@ export type TKeyOfTuple<T extends TSchema> = {
   : never
 // prettier-ignore
 export type TKeyOf<T extends TSchema = TSchema> = (
-  T extends TComposite ? TKeyOfTuple<T> :
-  T extends TIntersect ? TKeyOfTuple<T> :
-  T extends TUnion     ? TKeyOfTuple<T> :
-  T extends TObject    ? TKeyOfTuple<T> :
+  T extends TComposite       ? TKeyOfTuple<T> :
+  T extends TIntersect       ? TKeyOfTuple<T> :
+  T extends TUnion           ? TKeyOfTuple<T> :
+  T extends TObject          ? TKeyOfTuple<T> :
+  T extends TRecord<infer K> ? [K] :
   []
 ) extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never
 // --------------------------------------------------------------------------
@@ -312,10 +332,9 @@ export interface TNever extends TSchema {
 // --------------------------------------------------------------------------
 // TNot
 // --------------------------------------------------------------------------
-export type TNotStatic<_ extends TSchema = TSchema, T extends TSchema = TSchema> = Static<T>
 export interface TNot<Not extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Not'
-  static: TNotStatic<Not, T>
+  static: Static<T>
   allOf: [{ not: Not }, T]
 }
 // --------------------------------------------------------------------------
@@ -426,10 +445,9 @@ export type TPick<T extends TSchema, K extends keyof any> =
 // --------------------------------------------------------------------------
 // TPromise
 // --------------------------------------------------------------------------
-export type TPromiseStatic<T extends TSchema, P extends unknown[]> = Promise<Static<T, P>>
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Promise'
-  static: TPromiseStatic<T, this['params']>
+  static: Promise<Static<T, this['params']>>
   type: 'object'
   instanceOf: 'Promise'
   item: TSchema
@@ -437,13 +455,16 @@ export interface TPromise<T extends TSchema = TSchema> extends TSchema {
 // --------------------------------------------------------------------------
 // TRecord
 // --------------------------------------------------------------------------
-export type TRecordKey = TString | TNumeric | TUnion<TLiteral<any>[]>
-export type TRecordPropertiesFromUnionLiteral<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema> = Static<K> extends string ? { [X in Static<K>]: T } : never
-export type TRecordPropertiesFromLiteral<K extends TLiteral<string | number>, T extends TSchema> = Evaluate<{ [K2 in K['const']]: T }>
-export type TRecordStatic<K extends TRecordKey, T extends TSchema, P extends unknown[]> = Record<Static<K>, Static<T, P>>
-export interface TRecord<K extends TRecordKey = TRecordKey, T extends TSchema = TSchema> extends TSchema {
+export type RecordTemplateLiteralObjectType<K extends TTemplateLiteral, T extends TSchema> = Ensure<TObject<Evaluate<{ [_ in Static<K>]: T }>>>
+export type RecordTemplateLiteralType<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends true ? RecordTemplateLiteralObjectType<K, T> : TRecord<TString, T>
+export type RecordUnionLiteralType<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema> = Static<K> extends string ? Ensure<TObject<{ [X in Static<K>]: T }>> : never
+export type RecordLiteralType<K extends TLiteral<string | number>, T extends TSchema> = Ensure<TObject<{ [K2 in K['const']]: T }>>
+export type RecordNumberType<K extends TInteger | TNumber, T extends TSchema> = Ensure<TRecord<K, T>>
+export type RecordStringType<K extends TString, T extends TSchema> = Ensure<TRecord<K, T>>
+export type RecordKey = TUnion<TLiteral<string | number>[]> | TLiteral<string | number> | TTemplateLiteral | TInteger | TNumber | TString
+export interface TRecord<K extends RecordKey = RecordKey, T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Record'
-  static: TRecordStatic<K, T, this['params']>
+  static: Record<Static<K>, Static<T, this['params']>>
   type: 'object'
   patternProperties: { [pattern: string]: T }
   additionalProperties: false
@@ -451,8 +472,8 @@ export interface TRecord<K extends TRecordKey = TRecordKey, T extends TSchema =
 // --------------------------------------------------------------------------
 // TRecursive
 // --------------------------------------------------------------------------
-export interface TSelf extends TSchema {
-  [Kind]: 'Self'
+export interface TThis extends TSchema {
+  [Kind]: 'This'
   static: this['params'][0]
   $ref: string
 }
@@ -463,10 +484,9 @@ export interface TRecursive<T extends TSchema> extends TSchema {
 // --------------------------------------------------------------------------
 // TRef
 // --------------------------------------------------------------------------
-export type TRefStatic<T extends TSchema, P extends unknown[]> = Static<T, P>
 export interface TRef<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Ref'
-  static: TRefStatic<T, this['params']>
+  static: Static<T, this['params']>
   $ref: string
 }
 // --------------------------------------------------------------------------
@@ -538,15 +558,54 @@ export interface TSymbol extends TSchema, SchemaOptions {
   typeOf: 'Symbol'
 }
 // --------------------------------------------------------------------------
+// TTemplateLiteral
+// --------------------------------------------------------------------------
+// prettier-ignore
+export type IsTemplateLiteralFiniteCheck<T> =
+  T extends TTemplateLiteral<infer U> ? IsTemplateLiteralFiniteArray<Assert<U, TTemplateLiteralKind[]>> :    
+  T extends TUnion<infer U> ? IsTemplateLiteralFiniteArray<Assert<U, TTemplateLiteralKind[]>> :    
+  T extends TString  ? false :
+  T extends TBoolean ? false :
+  T extends TNumber  ? false :
+  T extends TInteger ? false :
+  T extends TBigInt  ? false :
+  T extends TLiteral ? true  : 
+  false
+// prettier-ignore
+export type IsTemplateLiteralFiniteArray<T extends TTemplateLiteralKind[]> = 
+  T extends [infer L, ...infer R] ? IsTemplateLiteralFiniteCheck<L> extends false ? false : IsTemplateLiteralFiniteArray<Assert<R, TTemplateLiteralKind[]>> :
+  T extends [infer L] ? IsTemplateLiteralFiniteCheck<L> extends false ? false : true : 
+  true
+export type IsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? IsTemplateLiteralFiniteArray<U> : false
+export type TTemplateLiteralKind = TUnion | TLiteral | TInteger | TTemplateLiteral | TNumber | TBigInt | TString | TBoolean | TNever
+// prettier-ignore
+export type TTemplateLiteralConst<T, Acc extends string> = 
+  T extends TUnion<infer U> ? { [K in keyof U]: TTemplateLiteralUnion<Assert<[U[K]], TTemplateLiteralKind[]>, Acc> }[number] :
+  T extends TTemplateLiteral ? `${Static<T>}` : 
+  T extends TLiteral<infer U> ? `${U}` :
+  T extends TString ? `${string}` : 
+  T extends TNumber ? `${number}` : 
+  T extends TBigInt ? `${bigint}` : 
+  T extends TBoolean ? `${boolean}` :
+  never
+// prettier-ignore
+export type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string = ''> = 
+  T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` : 
+  T extends [infer L] ? `${TTemplateLiteralConst<L, Acc>}${Acc}` : 
+  Acc
+export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
+  [Kind]: 'TemplateLiteral'
+  static: TTemplateLiteralUnion<T>
+  type: 'string'
+  pattern: string // todo: it may be possible to infer this pattern
+}
+// --------------------------------------------------------------------------
 // TTuple
 // --------------------------------------------------------------------------
 export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? Assert<R, TSchema[]> : never
-export type TTupleStatic<T extends TSchema[], P extends unknown[]> = {
-  [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : T[K]
-}
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
   [Kind]: 'Tuple'
-  static: TTupleStatic<T, this['params']>
+  static: { [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : T[K] }
   type: 'array'
   items?: T
   additionalItems?: false
@@ -574,6 +633,8 @@ export type TUnionResult<T extends TSchema[]> = T extends [] ? TNever : T extend
 // --------------------------------------------------------------------------
 // TUnion
 // --------------------------------------------------------------------------
+// prettier-ignore
+export type TUnionTemplateLiteral<T extends TTemplateLiteral, S extends string = Static<T>> = Ensure<TUnionResult<Assert<UnionToTuple<{[K in S]: TLiteral<K>}[S]>,TLiteral[]>>>
 export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
   [Kind]: 'Union'
   static: { [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : never }[number]
@@ -764,7 +825,7 @@ export namespace TypeGuard {
       IsOptionalBoolean(schema.uniqueItems)
     )
   }
-  /** Returns true if the given schema is TSymbol */
+  /** Returns true if the given schema is TBigInt */
   export function TBigInt(schema: unknown): schema is TBigInt {
     // prettier-ignore
     return (
@@ -996,16 +1057,6 @@ export namespace TypeGuard {
     }
     return true
   }
-  /** Returns true if the given schema is TSelf */
-  export function TSelf(schema: unknown): schema is TSelf {
-    // prettier-ignore
-    return (
-      TKind(schema) && 
-      schema[Kind] === 'Self' && 
-      IsOptionalString(schema.$id) && 
-      IsString(schema.$ref)
-    )
-  }
   /** Returns true if the given schema is TRef */
   export function TRef(schema: unknown): schema is TRef {
     // prettier-ignore
@@ -1029,7 +1080,6 @@ export namespace TypeGuard {
       IsOptionalFormat(schema.format)
     )
   }
-
   /** Returns true if the given schema is TSymbol */
   export function TSymbol(schema: unknown): schema is TSymbol {
     // prettier-ignore
@@ -1041,7 +1091,28 @@ export namespace TypeGuard {
       IsOptionalString(schema.$id)
     )
   }
-
+  /** Returns true if the given schema is TTemplateLiteral */
+  export function TTemplateLiteral(schema: unknown): schema is TTemplateLiteral {
+    // prettier-ignore
+    return (
+      TKind(schema) && 
+      schema[Kind] === 'TemplateLiteral' && 
+      schema.type === 'string' &&
+      IsString(schema.pattern) &&
+      schema.pattern[0] === '^' &&
+      schema.pattern[schema.pattern.length - 1] === '$'
+    )
+  }
+  /** Returns true if the given schema is TThis */
+  export function TThis(schema: unknown): schema is TThis {
+    // prettier-ignore
+    return (
+      TKind(schema) && 
+      schema[Kind] === 'This' && 
+      IsOptionalString(schema.$id) && 
+      IsString(schema.$ref)
+    )
+  }
   /** Returns true if the given schema is TTuple */
   export function TTuple(schema: unknown): schema is TTuple {
     // prettier-ignore
@@ -1098,7 +1169,6 @@ export namespace TypeGuard {
   export function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral<string>[]> {
     return TUnion(schema) && schema.anyOf.every((schema) => TLiteral(schema) && typeof schema.const === 'string')
   }
-
   /** Returns true if the given schema is TUint8Array */
   export function TUint8Array(schema: unknown): schema is TUint8Array {
     return TKind(schema) && schema[Kind] === 'Uint8Array' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.instanceOf === 'Uint8Array' && IsOptionalNumber(schema.minByteLength) && IsOptionalNumber(schema.maxByteLength)
@@ -1164,10 +1234,11 @@ export namespace TypeGuard {
         TObject(schema) ||
         TPromise(schema) ||
         TRecord(schema) ||
-        TSelf(schema) ||
         TRef(schema) ||
         TString(schema) ||
         TSymbol(schema) ||
+        TTemplateLiteral(schema) ||
+        TThis(schema) ||
         TTuple(schema) ||
         TUndefined(schema) ||
         TUnion(schema) ||
@@ -1523,13 +1594,13 @@ export namespace TypeExtends {
   // Record
   // --------------------------------------------------------------------------
   function RecordKey(schema: TRecord) {
-    if ('^(0|[1-9][0-9]*)$' in schema.patternProperties) return Type.Number()
-    if ('^.*$' in schema.patternProperties) return Type.String()
+    if (PatternNumberExact in schema.patternProperties) return Type.Number()
+    if (PatternStringExact in schema.patternProperties) return Type.String()
     throw Error('TypeExtends: Cannot get record key')
   }
   function RecordValue(schema: TRecord) {
-    if ('^(0|[1-9][0-9]*)$' in schema.patternProperties) return schema.patternProperties['^(0|[1-9][0-9]*)$']
-    if ('^.*$' in schema.patternProperties) return schema.patternProperties['^.*$']
+    if (PatternNumberExact in schema.patternProperties) return schema.patternProperties[PatternNumberExact]
+    if (PatternStringExact in schema.patternProperties) return schema.patternProperties[PatternStringExact]
     throw Error('TypeExtends: Cannot get record value')
   }
   function RecordRight(left: TSchema, right: TRecord) {
@@ -1645,7 +1716,7 @@ export namespace TypeExtends {
   function UnionRight(left: TSchema, right: TUnion): TypeExtendsResult {
     return right.anyOf.some((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
-  function Union(left: TUnion, right: TSchema) {
+  function Union(left: TUnion, right: TSchema): TypeExtendsResult {
     return left.anyOf.every((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
@@ -1683,6 +1754,10 @@ export namespace TypeExtends {
     return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   function Visit(left: TSchema, right: TSchema): TypeExtendsResult {
+    // template union remap
+    if (TypeGuard.TTemplateLiteral(left)) return Visit(TemplateLiteralResolver.Resolve(left), right)
+    if (TypeGuard.TTemplateLiteral(right)) return Visit(left, TemplateLiteralResolver.Resolve(right))
+    // standard extends
     if (TypeGuard.TAny(left)) return Any(left, right)
     if (TypeGuard.TArray(left)) return Array(left, right)
     if (TypeGuard.TBigInt(left)) return BigInt(left, right)
@@ -1696,10 +1771,10 @@ export namespace TypeExtends {
     if (TypeGuard.TNever(left)) return Never(left, right)
     if (TypeGuard.TNull(left)) return Null(left, right)
     if (TypeGuard.TNumber(left)) return Number(left, right)
+    if (TypeGuard.TObject(left)) return Object(left, right)
     if (TypeGuard.TRecord(left)) return Record(left, right)
     if (TypeGuard.TString(left)) return String(left, right)
     if (TypeGuard.TSymbol(left)) return Symbol(left, right)
-    if (TypeGuard.TObject(left)) return Object(left, right)
     if (TypeGuard.TTuple(left)) return Tuple(left, right)
     if (TypeGuard.TPromise(left)) return Promise(left, right)
     if (TypeGuard.TUint8Array(left)) return Uint8Array(left, right)
@@ -1803,6 +1878,224 @@ export namespace KeyResolver {
   }
 }
 // --------------------------------------------------------------------------
+// TemplateLiteralPattern
+// --------------------------------------------------------------------------
+export namespace TemplateLiteralPattern {
+  function Escape(value: string) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  }
+  function Visit(schema: TSchema, acc: string): string {
+    if (TypeGuard.TTemplateLiteral(schema)) {
+      const pattern = schema.pattern.slice(1, schema.pattern.length - 1)
+      return pattern
+    } else if (TypeGuard.TUnion(schema)) {
+      const tokens = schema.anyOf.map((schema) => Visit(schema, acc)).join('|')
+      return `(${tokens})`
+    } else if (TypeGuard.TNumber(schema)) {
+      return `${acc}${PatternNumber}`
+    } else if (TypeGuard.TInteger(schema)) {
+      return `${acc}${PatternNumber}`
+    } else if (TypeGuard.TBigInt(schema)) {
+      return `${acc}${PatternNumber}`
+    } else if (TypeGuard.TString(schema)) {
+      return `${acc}${PatternString}`
+    } else if (TypeGuard.TLiteral(schema)) {
+      return `${acc}${Escape(schema.const.toString())}`
+    } else if (TypeGuard.TBoolean(schema)) {
+      return `${acc}${PatternBoolean}`
+    } else if (TypeGuard.TNever(schema)) {
+      throw Error('TemplateLiteralPattern: TemplateLiteral cannot operate on types of TNever')
+    } else {
+      throw Error(`TemplateLiteralPattern: Unexpected Kind '${schema[Kind]}'`)
+    }
+  }
+  export function Create(kinds: TTemplateLiteralKind[]): string {
+    return `^${kinds.map((schema) => Visit(schema, '')).join('')}\$`
+  }
+}
+// --------------------------------------------------------------------------------------
+// TemplateLiteralResolver
+// --------------------------------------------------------------------------------------
+export namespace TemplateLiteralResolver {
+  export function Resolve(template: TTemplateLiteral): TString | TUnion | TLiteral {
+    const expression = TemplateLiteralParser.ParseExact(template.pattern)
+    if (!TemplateLiteralFinite.Check(expression)) return Type.String()
+    const literals = [...TemplateLiteralGenerator.Generate(expression)].map((value) => Type.Literal(value))
+    return Type.Union(literals)
+  }
+}
+// --------------------------------------------------------------------------------------
+// TemplateLiteralParser
+// --------------------------------------------------------------------------------------
+export class TemplateLiteralParserError extends Error {
+  constructor(message: string) {
+    super(message)
+  }
+}
+export namespace TemplateLiteralParser {
+  export type Expression = And | Or | Const
+  export type Const = { type: 'const'; const: string }
+  export type And = { type: 'and'; expr: Expression[] }
+  export type Or = { type: 'or'; expr: Expression[] }
+  function Unescape(value: string) {
+    return value.replace(/\\/g, '')
+  }
+  function IsNonEscaped(pattern: string, index: number, char: string) {
+    return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92
+  }
+  function IsOpenParen(pattern: string, index: number) {
+    return IsNonEscaped(pattern, index, '(')
+  }
+  function IsCloseParen(pattern: string, index: number) {
+    return IsNonEscaped(pattern, index, ')')
+  }
+  function IsSeparator(pattern: string, index: number) {
+    return IsNonEscaped(pattern, index, '|')
+  }
+  function IsGroup(pattern: string) {
+    if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1))) return false
+    let count = 0
+    for (let index = 0; index < pattern.length; index++) {
+      if (IsOpenParen(pattern, index)) count += 1
+      if (IsCloseParen(pattern, index)) count -= 1
+      if (count === 0 && index !== pattern.length - 1) return false
+    }
+    return true
+  }
+  function InGroup(pattern: string) {
+    return pattern.slice(1, pattern.length - 1)
+  }
+  function IsPrecedenceOr(pattern: string) {
+    let count = 0
+    for (let index = 0; index < pattern.length; index++) {
+      if (IsOpenParen(pattern, index)) count += 1
+      if (IsCloseParen(pattern, index)) count -= 1
+      if (IsSeparator(pattern, index) && count === 0) return true
+    }
+    return false
+  }
+  function IsPrecedenceAnd(pattern: string) {
+    for (let index = 0; index < pattern.length; index++) {
+      if (IsOpenParen(pattern, index)) return true
+    }
+    return false
+  }
+  function Or(pattern: string): Expression {
+    let [count, start] = [0, 0]
+    const expressions: Expression[] = []
+    for (let index = 0; index < pattern.length; index++) {
+      if (IsOpenParen(pattern, index)) count += 1
+      if (IsCloseParen(pattern, index)) count -= 1
+      if (IsSeparator(pattern, index) && count === 0) {
+        const range = pattern.slice(start, index)
+        if (range.length > 0) expressions.push(Parse(range))
+        start = index + 1
+      }
+    }
+    const range = pattern.slice(start)
+    if (range.length > 0) expressions.push(Parse(range))
+    if (expressions.length === 0) return { type: 'const', const: '' }
+    if (expressions.length === 1) return expressions[0]
+    return { type: 'or', expr: expressions }
+  }
+  function And(pattern: string): Expression {
+    function Group(value: string, index: number): [number, number] {
+      if (!IsOpenParen(value, index)) throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`)
+      let count = 0
+      for (let scan = index; scan < value.length; scan++) {
+        if (IsOpenParen(value, scan)) count += 1
+        if (IsCloseParen(value, scan)) count -= 1
+        if (count === 0) return [index, scan]
+      }
+      throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`)
+    }
+    function Range(pattern: string, index: number): [number, number] {
+      for (let scan = index; scan < pattern.length; scan++) {
+        if (IsOpenParen(pattern, scan)) return [index, scan]
+      }
+      return [index, pattern.length]
+    }
+    const expressions: Expression[] = []
+    for (let index = 0; index < pattern.length; index++) {
+      if (IsOpenParen(pattern, index)) {
+        const [start, end] = Group(pattern, index)
+        const range = pattern.slice(start, end + 1)
+        expressions.push(Parse(range))
+        index = end
+      } else {
+        const [start, end] = Range(pattern, index)
+        const range = pattern.slice(start, end)
+        if (range.length > 0) expressions.push(Parse(range))
+        index = end - 1
+      }
+    }
+    if (expressions.length === 0) return { type: 'const', const: '' }
+    if (expressions.length === 1) return expressions[0]
+    return { type: 'and', expr: expressions }
+  }
+  /** Parses a pattern and returns an expression tree */
+  export function Parse(pattern: string): Expression {
+    if (IsGroup(pattern)) return Parse(InGroup(pattern))
+    if (IsPrecedenceOr(pattern)) return Or(pattern)
+    if (IsPrecedenceAnd(pattern)) return And(pattern)
+    return { type: 'const', const: Unescape(pattern) }
+  }
+  /** Parses a pattern and strips forward and trailing ^ and $ */
+  export function ParseExact(pattern: string): Expression {
+    return Parse(pattern.slice(1, pattern.length - 1))
+  }
+}
+// --------------------------------------------------------------------------------------
+// TemplateLiteralFinite
+// --------------------------------------------------------------------------------------
+export namespace TemplateLiteralFinite {
+  function IsNumber(expression: TemplateLiteralParser.Expression): boolean {
+    return expression.type === 'or' && expression.expr.length === 2 && expression.expr[0].type === 'const' && expression.expr[0].const === '0' && expression.expr[1].type === 'const' && expression.expr[1].const === '[1-9][0-9]*'
+  }
+  function IsBoolean(expression: TemplateLiteralParser.Expression): boolean {
+    return expression.type === 'or' && expression.expr.length === 2 && expression.expr[0].type === 'const' && expression.expr[0].const === 'true' && expression.expr[1].type === 'const' && expression.expr[1].const === 'false'
+  }
+  function IsString(expression: TemplateLiteralParser.Expression) {
+    return expression.type === 'const' && expression.const === '.*'
+  }
+  export function Check(expression: TemplateLiteralParser.Expression): boolean {
+    if (IsBoolean(expression)) return true
+    if (IsNumber(expression) || IsString(expression)) return false
+    if (expression.type === 'and') return expression.expr.every((expr) => Check(expr))
+    if (expression.type === 'or') return expression.expr.every((expr) => Check(expr))
+    if (expression.type === 'const') return true
+    throw Error(`TemplateLiteralFinite: Unknown expression type`)
+  }
+}
+// --------------------------------------------------------------------------------------
+// TemplateLiteralGenerator
+// --------------------------------------------------------------------------------------
+export namespace TemplateLiteralGenerator {
+  function* Reduce(buffer: string[][]): IterableIterator<string> {
+    if (buffer.length === 1) return yield* buffer[0]
+    for (const left of buffer[0]) {
+      for (const right of Reduce(buffer.slice(1))) {
+        yield `${left}${right}`
+      }
+    }
+  }
+  function* And(expression: TemplateLiteralParser.And): IterableIterator<string> {
+    return yield* Reduce(expression.expr.map((expr) => [...Generate(expr)]))
+  }
+  function* Or(expression: TemplateLiteralParser.Or): IterableIterator<string> {
+    for (const expr of expression.expr) yield* Generate(expr)
+  }
+  function* Const(expression: TemplateLiteralParser.Const): IterableIterator<string> {
+    return yield expression.const
+  }
+  export function* Generate(expression: TemplateLiteralParser.Expression): IterableIterator<string> {
+    if (expression.type === 'and') return yield* And(expression)
+    if (expression.type === 'or') return yield* Or(expression)
+    if (expression.type === 'const') return yield* Const(expression)
+    throw Error('TemplateLiteralGenerator: Unknown expression')
+  }
+}
+// --------------------------------------------------------------------------
 // TypeOrdinal: Used for auto $id generation
 // --------------------------------------------------------------------------
 let TypeOrdinal = 0
@@ -1909,6 +2202,8 @@ export class StandardTypeBuilder extends TypeBuilder {
   }
   /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
   public Exclude<L extends TSchema, R extends TSchema>(left: L, right: R, options: SchemaOptions = {}): TExclude<L, R> {
+    if (TypeGuard.TTemplateLiteral(left)) return this.Exclude(TemplateLiteralResolver.Resolve(left), right, options) as TExclude<L, R>
+    if (TypeGuard.TTemplateLiteral(right)) return this.Exclude(left, TemplateLiteralResolver.Resolve(right), options) as any as TExclude<L, R>
     if (TypeGuard.TUnion(left)) {
       const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) === TypeExtendsResult.False)
       return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options)) as TExclude<L, R>
@@ -1918,6 +2213,8 @@ export class StandardTypeBuilder extends TypeBuilder {
   }
   /** `[Standard]` Extracts from the left type any type that is assignable to the right */
   public Extract<L extends TSchema, R extends TSchema>(left: L, right: R, options: SchemaOptions = {}): TExtract<L, R> {
+    if (TypeGuard.TTemplateLiteral(left)) return this.Extract(TemplateLiteralResolver.Resolve(left), right, options) as TExtract<L, R>
+    if (TypeGuard.TTemplateLiteral(right)) return this.Extract(left, TemplateLiteralResolver.Resolve(right), options) as any as TExtract<L, R>
     if (TypeGuard.TUnion(left)) {
       const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) !== TypeExtendsResult.False)
       return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options)) as TExtract<L, R>
@@ -1949,10 +2246,17 @@ export class StandardTypeBuilder extends TypeBuilder {
   }
   /** `[Standard]` Creates a KeyOf type */
   public KeyOf<T extends TSchema>(schema: T, options: SchemaOptions = {}): TKeyOf<T> {
-    const keys = KeyResolver.Resolve(schema)
-    // prettier-ignore
-    const keyof = keys.length === 0 ? this.Never(options) : this.Union(keys.map((key) => this.Literal(key)), options)
-    return keyof as TKeyOf<T>
+    if (TypeGuard.TRecord(schema)) {
+      const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
+      if (pattern === PatternNumberExact) return this.Number(options) as TKeyOf<T>
+      if (pattern === PatternStringExact) return this.String(options) as TKeyOf<T>
+      throw Error('StandardTypeBuilder: Unable to resolve key type from Record key pattern')
+    } else {
+      const resolved = KeyResolver.Resolve(schema)
+      if (resolved.length === 0) return this.Never(options) as TKeyOf<T>
+      const literals = resolved.map((key) => this.Literal(key))
+      return this.Union(literals, options) as TKeyOf<T>
+    }
   }
   /** `[Standard]` Creates a Literal type */
   public Literal<T extends TLiteralValue>(value: T, options: SchemaOptions = {}): TLiteral<T> {
@@ -2060,39 +2364,49 @@ export class StandardTypeBuilder extends TypeBuilder {
       return this.Create(schema)
     }, options)
   }
-  /** `[Standard]` Creates an Object type from the given Literal Union */
-  public Record<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TObject<TRecordPropertiesFromUnionLiteral<K, T>>
-  /** `[Standard]` Creates an Object type from the given Literal Union */
-  public Record<K extends TLiteral<string | number>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TObject<TRecordPropertiesFromLiteral<K, T>>
   /** `[Standard]` Creates a Record type */
-  public Record<K extends TString | TNumeric, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecord<K, T>
-  public Record(key: any, schema: TSchema, options: ObjectOptions = {}) {
-    if (TypeGuard.TLiteral(key)) {
-      if (typeof key.const === 'string' || typeof key.const === 'number') {
-        return this.Object({ [key.const]: TypeClone.Clone(schema, {}) }, options)
-      } else throw Error('TypeBuilder: Record key can only be derived from literals of number or string')
-    }
-    if (TypeGuard.TUnion(key)) {
+  public Record<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema>(key: K, schema: T): RecordUnionLiteralType<K, T>
+  /** `[Standard]` Creates a Record type */
+  public Record<K extends TLiteral<string | number>, T extends TSchema>(key: K, schema: T): RecordLiteralType<K, T>
+  /** `[Standard]` Creates a Record type */
+  public Record<K extends TTemplateLiteral, T extends TSchema>(key: K, schema: T): RecordTemplateLiteralType<K, T>
+  /** `[Standard]` Creates a Record type */
+  public Record<K extends TInteger | TNumber, T extends TSchema>(key: K, schema: T): RecordNumberType<K, T>
+  /** `[Standard]` Creates a Record type */
+  public Record<K extends TString, T extends TSchema>(key: K, schema: T): RecordStringType<K, T>
+  /** `[Standard]` Creates a Record type */
+  public Record(key: RecordKey, schema: TSchema, options: ObjectOptions = {}) {
+    if (TypeGuard.TTemplateLiteral(key)) {
+      const expression = TemplateLiteralParser.ParseExact(key.pattern)
+      // prettier-ignore
+      return TemplateLiteralFinite.Check(expression)
+        ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(schema, {}) }), {} as TProperties), options))
+        : this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false })
+    } else if (TypeGuard.TUnionLiteral(key)) {
       if (key.anyOf.every((schema) => TypeGuard.TLiteral(schema) && (typeof schema.const === 'string' || typeof schema.const === 'number'))) {
         const properties = key.anyOf.reduce((acc: any, literal: any) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {} as TProperties)
         return this.Object(properties, { ...options, [Hint]: 'Record' })
       } else throw Error('TypeBuilder: Record key can only be derived from union literal of number or string')
+    } else if (TypeGuard.TLiteral(key)) {
+      if (typeof key.const === 'string' || typeof key.const === 'number') {
+        return this.Object({ [key.const]: TypeClone.Clone(schema, {}) }, options)
+      } else throw Error('TypeBuilder: Record key can only be derived from literals of number or string')
+    } else if (TypeGuard.TInteger(key) || TypeGuard.TNumber(key)) {
+      const pattern = PatternNumberExact
+      return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false })
+    } else if (TypeGuard.TString(key)) {
+      const pattern = key.pattern === undefined ? PatternStringExact : key.pattern
+      return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false })
+    } else {
+      throw Error(`StandardTypeBuilder: Invalid Record Key`)
     }
-    const pattern = ['Integer', 'Number'].includes(key[Kind]) ? '^(0|[1-9][0-9]*)$' : key[Kind] === 'String' && key.pattern ? key.pattern : '^.*$'
-    return this.Create({
-      ...options,
-      [Kind]: 'Record',
-      type: 'object',
-      patternProperties: { [pattern]: TypeClone.Clone(schema, {}) },
-      additionalProperties: false,
-    })
   }
   /** `[Standard]` Creates a Recursive type */
-  public Recursive<T extends TSchema>(callback: (self: TSelf) => T, options: SchemaOptions = {}): TRecursive<T> {
+  public Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options: SchemaOptions = {}): TRecursive<T> {
     if (options.$id === undefined) (options as any).$id = `T${TypeOrdinal++}`
-    const self = callback({ [Kind]: 'Self', $ref: `${options.$id}` } as any)
-    self.$id = options.$id
-    return this.Create({ ...options, ...self } as any)
+    const thisType = callback({ [Kind]: 'This', $ref: `${options.$id}` } as any)
+    thisType.$id = options.$id
+    return this.Create({ ...options, ...thisType } as any)
   }
   /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
   public Ref<T extends TSchema>(schema: T, options: SchemaOptions = {}): TRef<T> {
@@ -2121,6 +2435,11 @@ export class StandardTypeBuilder extends TypeBuilder {
   public String<Format extends string>(options: StringOptions<StringFormatOption | Format> = {}): TString<Format> {
     return this.Create({ ...options, [Kind]: 'String', type: 'string' })
   }
+  /** `[Standard]` Creates a template literal type */
+  public TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options: SchemaOptions = {}): TTemplateLiteral<T> {
+    const pattern = TemplateLiteralPattern.Create(kinds)
+    return this.Create({ ...options, [Kind]: 'TemplateLiteral', type: 'string', pattern })
+  }
   /** `[Standard]` Creates a Tuple type */
   public Tuple<T extends TSchema[]>(items: [...T], options: SchemaOptions = {}): TTuple<T> {
     const [additionalItems, minItems, maxItems] = [false, items.length, items.length]
@@ -2137,11 +2456,18 @@ export class StandardTypeBuilder extends TypeBuilder {
   public Union<T extends [TSchema]>(anyOf: [...T], options?: SchemaOptions): T[0]
   /** `[Standard]` Creates a Union type */
   public Union<T extends TSchema[]>(anyOf: [...T], options?: SchemaOptions): TUnion<T>
-  public Union(anyOf: TSchema[], options: SchemaOptions = {}) {
-    if (anyOf.length === 0) return this.Never(options)
-    if (anyOf.length === 1) return this.Create(TypeClone.Clone(anyOf[0], options))
-    const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema, {}))
-    return this.Create({ ...options, [Kind]: 'Union', anyOf: clonedAnyOf })
+  /** `[Experimental]` Remaps a TemplateLiteral into a Union representation. This function is known to cause TS compiler crashes for finite templates with large generation counts. Use with caution. */
+  public Union<T extends TTemplateLiteral>(template: T): TUnionTemplateLiteral<T>
+  public Union(union: TSchema[] | TTemplateLiteral, options: SchemaOptions = {}) {
+    if (TypeGuard.TTemplateLiteral(union)) {
+      return TemplateLiteralResolver.Resolve(union)
+    } else {
+      const anyOf = union
+      if (anyOf.length === 0) return this.Never(options)
+      if (anyOf.length === 1) return this.Create(TypeClone.Clone(anyOf[0], options))
+      const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema, {}))
+      return this.Create({ ...options, [Kind]: 'Union', anyOf: clonedAnyOf })
+    }
   }
   /** `[Standard]` Creates an Unknown type */
   public Unknown(options: SchemaOptions = {}): TUnknown {
@@ -2153,7 +2479,7 @@ export class StandardTypeBuilder extends TypeBuilder {
   }
 }
 // --------------------------------------------------------------------------
-// TypeBuilder
+// ExtendedTypeBuilder
 // --------------------------------------------------------------------------
 export class ExtendedTypeBuilder extends StandardTypeBuilder {
   /** `[Extended]` Creates a BigInt type */
diff --git a/src/value/cast.ts b/src/value/cast.ts
index 67e936a29..66bb2abce 100644
--- a/src/value/cast.ts
+++ b/src/value/cast.ts
@@ -35,7 +35,7 @@ import { ValueClone } from './clone'
 // Errors
 // ----------------------------------------------------------------------------------------------
 export class ValueCastReferenceTypeError extends Error {
-  constructor(public readonly schema: Types.TRef | Types.TSelf) {
+  constructor(public readonly schema: Types.TRef | Types.TThis) {
     super(`ValueCast: Cannot locate referenced schema with $id '${schema.$ref}'`)
   }
 }
@@ -60,7 +60,7 @@ export class ValueCastUnknownTypeError extends Error {
   }
 }
 export class ValueCastDereferenceError extends Error {
-  constructor(public readonly schema: Types.TRef | Types.TSelf) {
+  constructor(public readonly schema: Types.TRef | Types.TThis) {
     super(`ValueCast: Unable to dereference schema with $id '${schema.$ref}'`)
   }
 }
@@ -225,18 +225,21 @@ export namespace ValueCast {
     const target = references[index]
     return Visit(target, references, value)
   }
-  function Self(schema: Types.TSelf, references: Types.TSchema[], value: any): any {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-    if (index === -1) throw new ValueCastDereferenceError(schema)
-    const target = references[index]
-    return Visit(target, references, value)
-  }
   function String(schema: Types.TString, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
   }
   function Symbol(schema: Types.TSymbol, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
   }
+  function TemplateLiteral(schema: Types.TSymbol, references: Types.TSchema[], value: any): any {
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+  }
+  function This(schema: Types.TThis, references: Types.TSchema[], value: any): any {
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+    if (index === -1) throw new ValueCastDereferenceError(schema)
+    const target = references[index]
+    return Visit(target, references, value)
+  }
   function Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): any {
     if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
     if (!globalThis.Array.isArray(value)) return ValueCreate.Create(schema, references)
@@ -301,12 +304,14 @@ export namespace ValueCast {
         return Record(schema_, references_, value)
       case 'Ref':
         return Ref(schema_, references_, value)
-      case 'Self':
-        return Self(schema_, references_, value)
       case 'String':
         return String(schema_, references_, value)
       case 'Symbol':
         return Symbol(schema_, references_, value)
+      case 'TemplateLiteral':
+        return TemplateLiteral(schema_, references_, value)
+      case 'This':
+        return This(schema_, references_, value)
       case 'Tuple':
         return Tuple(schema_, references_, value)
       case 'Undefined':
diff --git a/src/value/check.ts b/src/value/check.ts
index bf3f42909..d745b2979 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -39,7 +39,7 @@ export class ValueCheckUnknownTypeError extends Error {
   }
 }
 export class ValueCheckDereferenceError extends Error {
-  constructor(public readonly schema: Types.TRef | Types.TSelf) {
+  constructor(public readonly schema: Types.TRef | Types.TThis) {
     super(`ValueCheck: Unable to dereference schema with $id '${schema.$ref}'`)
   }
 }
@@ -292,12 +292,6 @@ export namespace ValueCheck {
     const target = references[index]
     return Visit(target, references, value)
   }
-  function Self(schema: Types.TSelf, references: Types.TSchema[], value: any): boolean {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-    if (index === -1) throw new ValueCheckDereferenceError(schema)
-    const target = references[index]
-    return Visit(target, references, value)
-  }
   function String(schema: Types.TString, references: Types.TSchema[], value: any): boolean {
     if (!IsString(value)) {
       return false
@@ -325,6 +319,18 @@ export namespace ValueCheck {
     }
     return true
   }
+  function TemplateLiteral(schema: Types.TTemplateLiteralKind, references: Types.TSchema[], value: any): boolean {
+    if (!IsString(value)) {
+      return false
+    }
+    return new RegExp(schema.pattern).test(value)
+  }
+  function This(schema: Types.TThis, references: Types.TSchema[], value: any): boolean {
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+    if (index === -1) throw new ValueCheckDereferenceError(schema)
+    const target = references[index]
+    return Visit(target, references, value)
+  }
   function Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): boolean {
     if (!globalThis.Array.isArray(value)) {
       return false
@@ -412,12 +418,14 @@ export namespace ValueCheck {
         return Record(schema_, references_, value)
       case 'Ref':
         return Ref(schema_, references_, value)
-      case 'Self':
-        return Self(schema_, references_, value)
       case 'String':
         return String(schema_, references_, value)
       case 'Symbol':
         return Symbol(schema_, references_, value)
+      case 'TemplateLiteral':
+        return TemplateLiteral(schema_, references_, value)
+      case 'This':
+        return This(schema_, references_, value)
       case 'Tuple':
         return Tuple(schema_, references_, value)
       case 'Undefined':
diff --git a/src/value/convert.ts b/src/value/convert.ts
index b40ab967b..00f397b9b 100644
--- a/src/value/convert.ts
+++ b/src/value/convert.ts
@@ -39,7 +39,7 @@ export class ValueConvertUnknownTypeError extends Error {
   }
 }
 export class ValueConvertDereferenceError extends Error {
-  constructor(public readonly schema: Types.TRef | Types.TSelf) {
+  constructor(public readonly schema: Types.TRef | Types.TThis) {
     super(`ValueConvert: Unable to dereference schema with $id '${schema.$ref}'`)
   }
 }
@@ -243,18 +243,21 @@ export namespace ValueConvert {
     const target = references[index]
     return Visit(target, references, value)
   }
-  function Self(schema: Types.TSelf, references: Types.TSchema[], value: any): unknown {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-    if (index === -1) throw new ValueConvertDereferenceError(schema)
-    const target = references[index]
-    return Visit(target, references, value)
-  }
   function String(schema: Types.TString, references: Types.TSchema[], value: any): unknown {
     return TryConvertString(value)
   }
   function Symbol(schema: Types.TSymbol, references: Types.TSchema[], value: any): unknown {
     return value
   }
+  function TemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[], value: any) {
+    return value
+  }
+  function This(schema: Types.TThis, references: Types.TSchema[], value: any): unknown {
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+    if (index === -1) throw new ValueConvertDereferenceError(schema)
+    const target = references[index]
+    return Visit(target, references, value)
+  }
   function Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): unknown {
     if (IsArray(value) && schema.items !== undefined) {
       return value.map((value, index) => {
@@ -325,12 +328,14 @@ export namespace ValueConvert {
         return Record(schema_, references_, value)
       case 'Ref':
         return Ref(schema_, references_, value)
-      case 'Self':
-        return Self(schema_, references_, value)
       case 'String':
         return String(schema_, references_, value)
       case 'Symbol':
         return Symbol(schema_, references_, value)
+      case 'TemplateLiteral':
+        return TemplateLiteral(schema_, references_, value)
+      case 'This':
+        return This(schema_, references_, value)
       case 'Tuple':
         return Tuple(schema_, references_, value)
       case 'Undefined':
diff --git a/src/value/create.ts b/src/value/create.ts
index a2a0e1392..f6f63b68b 100644
--- a/src/value/create.ts
+++ b/src/value/create.ts
@@ -47,8 +47,13 @@ export class ValueCreateIntersectTypeError extends Error {
     super('ValueCreate: Can only create values for intersected objects and non-varying primitive types. Consider using a default value.')
   }
 }
+export class ValueCreateTempateLiteralTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('ValueCreate: Can only create template literal values from patterns that produce finite sequences. Consider using a default value.')
+  }
+}
 export class ValueCreateDereferenceError extends Error {
-  constructor(public readonly schema: Types.TRef | Types.TSelf) {
+  constructor(public readonly schema: Types.TRef | Types.TThis) {
     super(`ValueCreate: Unable to dereference schema with $id '${schema.$ref}'`)
   }
 }
@@ -209,7 +214,7 @@ export namespace ValueCreate {
     const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
     if ('default' in schema) {
       return schema.default
-    } else if (!(keyPattern === '^.*$' || keyPattern === '^(0|[1-9][0-9]*)$')) {
+    } else if (!(keyPattern === Types.PatternStringExact || keyPattern === Types.PatternNumberExact)) {
       const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|')
       return propertyKeys.reduce((acc, key) => {
         return { ...acc, [key]: Create(valueSchema, references) }
@@ -228,16 +233,6 @@ export namespace ValueCreate {
       return Visit(target, references)
     }
   }
-  function Self(schema: Types.TSelf, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else {
-      const index = references.findIndex((foreign) => foreign.$id === schema.$id)
-      if (index === -1) throw new ValueCreateDereferenceError(schema)
-      const target = references[index]
-      return Visit(target, references)
-    }
-  }
   function String(schema: Types.TString, references: Types.TSchema[]): any {
     if (schema.pattern !== undefined) {
       if (!('default' in schema)) {
@@ -272,6 +267,25 @@ export namespace ValueCreate {
       return globalThis.Symbol()
     }
   }
+  function TemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[]) {
+    if ('default' in schema) {
+      return schema.default
+    }
+    const expression = Types.TemplateLiteralParser.ParseExact(schema.pattern)
+    if (!Types.TemplateLiteralFinite.Check(expression)) throw new ValueCreateTempateLiteralTypeError(schema)
+    const sequence = Types.TemplateLiteralGenerator.Generate(expression)
+    return sequence.next().value
+  }
+  function This(schema: Types.TThis, references: Types.TSchema[]): any {
+    if ('default' in schema) {
+      return schema.default
+    } else {
+      const index = references.findIndex((foreign) => foreign.$id === schema.$id)
+      if (index === -1) throw new ValueCreateDereferenceError(schema)
+      const target = references[index]
+      return Visit(target, references)
+    }
+  }
   function Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[]): any {
     if ('default' in schema) {
       return schema.default
@@ -369,12 +383,14 @@ export namespace ValueCreate {
         return Record(schema_, references_)
       case 'Ref':
         return Ref(schema_, references_)
-      case 'Self':
-        return Self(schema_, references_)
       case 'String':
         return String(schema_, references_)
       case 'Symbol':
         return Symbol(schema_, references_)
+      case 'TemplateLiteral':
+        return TemplateLiteral(schema_, references_)
+      case 'This':
+        return This(schema_, references_)
       case 'Tuple':
         return Tuple(schema_, references_)
       case 'Undefined':
diff --git a/test/runtime/compiler/index.ts b/test/runtime/compiler/index.ts
index d04e227f4..1e2fa7629 100644
--- a/test/runtime/compiler/index.ts
+++ b/test/runtime/compiler/index.ts
@@ -30,6 +30,7 @@ import './regex'
 import './required'
 import './string'
 import './symbol'
+import './template-literal'
 import './tuple'
 import './uint8array'
 import './union'
diff --git a/test/runtime/compiler/recursive.ts b/test/runtime/compiler/recursive.ts
index 3cc78be1a..7ffb2b2ae 100644
--- a/test/runtime/compiler/recursive.ts
+++ b/test/runtime/compiler/recursive.ts
@@ -26,10 +26,10 @@ describe('type/compiler/Recursive', () => {
   })
 
   it('Should validate recursive node type', () => {
-    const Node = Type.Recursive((Self) =>
+    const Node = Type.Recursive((This) =>
       Type.Object({
         id: Type.String(),
-        nodes: Type.Array(Self),
+        nodes: Type.Array(This),
       }),
     )
     Ok(Node, {
@@ -43,10 +43,10 @@ describe('type/compiler/Recursive', () => {
 
   it('Should validate wrapped recursive node type', () => {
     const Node = Type.Tuple([
-      Type.Recursive((Self) =>
+      Type.Recursive((This) =>
         Type.Object({
           id: Type.String(),
-          nodes: Type.Array(Self),
+          nodes: Type.Array(This),
         }),
       ),
     ])
@@ -63,10 +63,10 @@ describe('type/compiler/Recursive', () => {
 
   it('Should not validate wrapped recursive node type with invalid id', () => {
     const Node = Type.Tuple([
-      Type.Recursive((Self) =>
+      Type.Recursive((This) =>
         Type.Object({
           id: Type.String(),
-          nodes: Type.Array(Self),
+          nodes: Type.Array(This),
         }),
       ),
     ])
diff --git a/test/runtime/compiler/template-literal.ts b/test/runtime/compiler/template-literal.ts
new file mode 100644
index 000000000..fb2ebdadb
--- /dev/null
+++ b/test/runtime/compiler/template-literal.ts
@@ -0,0 +1,186 @@
+import { Type } from '@sinclair/typebox'
+import { Ok, Fail } from './validate'
+
+describe('type/compiler/TemplateLiteral', () => {
+  // --------------------------------------------------------
+  // Finite
+  // --------------------------------------------------------
+  it('Should validate finite pattern 1', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([])
+    Ok(T, '')
+    Fail(T, 'X')
+  })
+  it('Should validate finite pattern 1', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([Type.Boolean()])
+    Ok(T, 'true')
+    Ok(T, 'false')
+    Fail(T, 'X')
+  })
+  it('Should validate finite pattern 2', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A')
+    ])
+    Ok(T, 'A')
+    Fail(T, 'X')
+  })
+  it('Should validate finite pattern 3', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Literal('B')
+    ])
+    Ok(T, 'AB')
+    Fail(T, 'X')
+  })
+  it('Should validate finite pattern 4', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Union([
+        Type.Literal('B'),
+        Type.Literal('C')
+      ]),
+    ])
+    Ok(T, 'AB')
+    Ok(T, 'AC')
+    Fail(T, 'X')
+  })
+  it('Should validate finite pattern 5', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Union([
+        Type.Literal('B'),
+        Type.Literal('C')
+      ]),
+      Type.Literal('D'),
+    ])
+    Ok(T, 'ABD')
+    Ok(T, 'ACD')
+    Fail(T, 'X')
+  })
+  it('Should validate finite pattern 6', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Union([
+        Type.Literal('0'),
+        Type.Literal('1')
+      ]),
+      Type.Union([
+        Type.Literal('0'),
+        Type.Literal('1')
+      ]),
+    ])
+    Ok(T, '00')
+    Ok(T, '01')
+    Ok(T, '10')
+    Ok(T, '11')
+    Fail(T, 'X')
+  })
+  // --------------------------------------------------------
+  // Infinite
+  // --------------------------------------------------------
+  it('Should validate infinite pattern 1', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Number()
+    ])
+    Ok(T, '1')
+    Ok(T, '22')
+    Ok(T, '333')
+    Ok(T, '4444')
+    Fail(T, 'X')
+  })
+  it('Should validate infinite pattern 2', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Integer()
+    ])
+    Ok(T, '1')
+    Ok(T, '22')
+    Ok(T, '333')
+    Ok(T, '4444')
+    Fail(T, 'X')
+  })
+  it('Should validate infinite pattern 3', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.BigInt()
+    ])
+    Ok(T, '1')
+    Ok(T, '22')
+    Ok(T, '333')
+    Ok(T, '4444')
+    Fail(T, 'X')
+  })
+  it('Should validate infinite pattern 4', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.String()
+    ])
+    Ok(T, '1')
+    Ok(T, '22')
+    Ok(T, '333')
+    Ok(T, '4444')
+    Ok(T, 'a')
+    Ok(T, 'bb')
+    Ok(T, 'ccc')
+    Ok(T, 'dddd')
+  })
+
+  it('Should validate infinite pattern 5', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Number()
+    ])
+    Ok(T, 'A1')
+    Ok(T, 'A22')
+    Ok(T, 'A333')
+    Ok(T, 'A4444')
+    Fail(T, 'X')
+  })
+  it('Should validate infinite pattern 6', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Integer()
+    ])
+    Ok(T, 'A1')
+    Ok(T, 'A22')
+    Ok(T, 'A333')
+    Ok(T, 'A4444')
+    Fail(T, 'X')
+  })
+  it('Should validate infinite pattern 7', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.BigInt()
+    ])
+    Ok(T, 'A1')
+    Ok(T, 'A22')
+    Ok(T, 'A333')
+    Ok(T, 'A4444')
+    Fail(T, 'X')
+  })
+  it('Should validate infinite pattern 8', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.String()
+    ])
+    Ok(T, 'A1')
+    Ok(T, 'A22')
+    Ok(T, 'A333')
+    Ok(T, 'A4444')
+    Ok(T, 'Aa')
+    Ok(T, 'Abb')
+    Ok(T, 'Accc')
+    Ok(T, 'Adddd')
+    Fail(T, 'X')
+  })
+})
diff --git a/test/runtime/schema/index.ts b/test/runtime/schema/index.ts
index 705b1d169..6f60c4ce7 100644
--- a/test/runtime/schema/index.ts
+++ b/test/runtime/schema/index.ts
@@ -26,6 +26,7 @@ import './ref'
 import './regex'
 import './required'
 import './string'
+import './template-literal'
 import './tuple'
 import './uint8array'
 import './union'
diff --git a/test/runtime/schema/recursive.ts b/test/runtime/schema/recursive.ts
index f5e9a352f..a003f7f42 100644
--- a/test/runtime/schema/recursive.ts
+++ b/test/runtime/schema/recursive.ts
@@ -26,10 +26,10 @@ describe('type/schema/Recursive', () => {
   })
 
   it('Should validate recursive node type', () => {
-    const Node = Type.Recursive((Self) =>
+    const Node = Type.Recursive((This) =>
       Type.Object({
         id: Type.String(),
-        nodes: Type.Array(Self),
+        nodes: Type.Array(This),
       }),
     )
     Ok(Node, {
@@ -43,10 +43,10 @@ describe('type/schema/Recursive', () => {
 
   it('Should validate wrapped recursive node type', () => {
     const Node = Type.Tuple([
-      Type.Recursive((Self) =>
+      Type.Recursive((This) =>
         Type.Object({
           id: Type.String(),
-          nodes: Type.Array(Self),
+          nodes: Type.Array(This),
         }),
       ),
     ])
@@ -63,10 +63,10 @@ describe('type/schema/Recursive', () => {
 
   it('Should not validate wrapped recursive node type with invalid id', () => {
     const Node = Type.Tuple([
-      Type.Recursive((Self) =>
+      Type.Recursive((This) =>
         Type.Object({
           id: Type.String(),
-          nodes: Type.Array(Self),
+          nodes: Type.Array(This),
         }),
       ),
     ])
diff --git a/test/runtime/schema/template-literal.ts b/test/runtime/schema/template-literal.ts
new file mode 100644
index 000000000..4b3b7985f
--- /dev/null
+++ b/test/runtime/schema/template-literal.ts
@@ -0,0 +1,186 @@
+import { Type } from '@sinclair/typebox'
+import { Ok, Fail } from './validate'
+
+describe('type/schema/TemplateLiteral', () => {
+  // --------------------------------------------------------
+  // Finite
+  // --------------------------------------------------------
+  it('Should validate finite pattern 1', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([])
+    Ok(T, '')
+    Fail(T, 'X')
+  })
+  it('Should validate finite pattern 1', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([Type.Boolean()])
+    Ok(T, 'true')
+    Ok(T, 'false')
+    Fail(T, 'X')
+  })
+  it('Should validate finite pattern 2', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A')
+    ])
+    Ok(T, 'A')
+    Fail(T, 'X')
+  })
+  it('Should validate finite pattern 3', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Literal('B')
+    ])
+    Ok(T, 'AB')
+    Fail(T, 'X')
+  })
+  it('Should validate finite pattern 4', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Union([
+        Type.Literal('B'),
+        Type.Literal('C')
+      ]),
+    ])
+    Ok(T, 'AB')
+    Ok(T, 'AC')
+    Fail(T, 'X')
+  })
+  it('Should validate finite pattern 5', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Union([
+        Type.Literal('B'),
+        Type.Literal('C')
+      ]),
+      Type.Literal('D'),
+    ])
+    Ok(T, 'ABD')
+    Ok(T, 'ACD')
+    Fail(T, 'X')
+  })
+  it('Should validate finite pattern 6', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Union([
+        Type.Literal('0'),
+        Type.Literal('1')
+      ]),
+      Type.Union([
+        Type.Literal('0'),
+        Type.Literal('1')
+      ]),
+    ])
+    Ok(T, '00')
+    Ok(T, '01')
+    Ok(T, '10')
+    Ok(T, '11')
+    Fail(T, 'X')
+  })
+  // --------------------------------------------------------
+  // Infinite
+  // --------------------------------------------------------
+  it('Should validate infinite pattern 1', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Number()
+    ])
+    Ok(T, '1')
+    Ok(T, '22')
+    Ok(T, '333')
+    Ok(T, '4444')
+    Fail(T, 'X')
+  })
+  it('Should validate infinite pattern 2', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Integer()
+    ])
+    Ok(T, '1')
+    Ok(T, '22')
+    Ok(T, '333')
+    Ok(T, '4444')
+    Fail(T, 'X')
+  })
+  it('Should validate infinite pattern 3', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.BigInt()
+    ])
+    Ok(T, '1')
+    Ok(T, '22')
+    Ok(T, '333')
+    Ok(T, '4444')
+    Fail(T, 'X')
+  })
+  it('Should validate infinite pattern 4', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.String()
+    ])
+    Ok(T, '1')
+    Ok(T, '22')
+    Ok(T, '333')
+    Ok(T, '4444')
+    Ok(T, 'a')
+    Ok(T, 'bb')
+    Ok(T, 'ccc')
+    Ok(T, 'dddd')
+  })
+
+  it('Should validate infinite pattern 5', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Number()
+    ])
+    Ok(T, 'A1')
+    Ok(T, 'A22')
+    Ok(T, 'A333')
+    Ok(T, 'A4444')
+    Fail(T, 'X')
+  })
+  it('Should validate infinite pattern 6', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Integer()
+    ])
+    Ok(T, 'A1')
+    Ok(T, 'A22')
+    Ok(T, 'A333')
+    Ok(T, 'A4444')
+    Fail(T, 'X')
+  })
+  it('Should validate infinite pattern 7', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.BigInt()
+    ])
+    Ok(T, 'A1')
+    Ok(T, 'A22')
+    Ok(T, 'A333')
+    Ok(T, 'A4444')
+    Fail(T, 'X')
+  })
+  it('Should validate infinite pattern 8', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.String()
+    ])
+    Ok(T, 'A1')
+    Ok(T, 'A22')
+    Ok(T, 'A333')
+    Ok(T, 'A4444')
+    Ok(T, 'Aa')
+    Ok(T, 'Abb')
+    Ok(T, 'Accc')
+    Ok(T, 'Adddd')
+    Fail(T, 'X')
+  })
+})
diff --git a/test/runtime/type/extends/any.ts b/test/runtime/type/extends/any.ts
index f67300b2e..ad28839f3 100644
--- a/test/runtime/type/extends/any.ts
+++ b/test/runtime/type/extends/any.ts
@@ -13,7 +13,6 @@ describe('type/extends/Any', () => {
     const R = TypeExtends.Extends(Type.Any(), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String', () => {
     type T = any extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.String())
@@ -89,7 +88,6 @@ describe('type/extends/Any', () => {
     const R = TypeExtends.Extends(Type.Any(), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.Union)
   })
-
   it('Should extend Date', () => {
     type T = any extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Date())
diff --git a/test/runtime/type/extends/array.ts b/test/runtime/type/extends/array.ts
index 973c7457f..f6a349d33 100644
--- a/test/runtime/type/extends/array.ts
+++ b/test/runtime/type/extends/array.ts
@@ -6,31 +6,26 @@ describe('type/extends/Array', () => {
   // ----------------------------------------------
   // Generic Varying
   // ----------------------------------------------
-
   it('Should extend Array Varying 1', () => {
     type T = Array<any> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Array Varying 2', () => {
     type T = Array<string> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Array Varying 3', () => {
     type T = Array<any> extends Array<string> ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.String()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Array Varying 4', () => {
     type T = Array<number> extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Number()), Type.Array(Type.String()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   // ----------------------------------------------
   // Any
   // ----------------------------------------------
@@ -39,275 +34,229 @@ describe('type/extends/Array', () => {
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Unknown', () => {
     type T = Array<any> extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String', () => {
     type T = Array<any> extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Boolean', () => {
     type T = Array<any> extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Number', () => {
     type T = Array<any> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Integer', () => {
     type T = Array<any> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array 1', () => {
     type T = Array<any> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Array 2', () => {
     type T = Array<string> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Array 3', () => {
     type T = Array<any> extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Tuple', () => {
     type T = Array<any> extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 1', () => {
     type T = Array<any> extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 2', () => {
     type T = Array<any> extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 3', () => {
     type T = Array<any> extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({ a: Type.Number() }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 4', () => {
     type T = Array<any> extends { length: '1' } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({ length: Type.Literal('1') }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 5', () => {
     type T = Array<any> extends { length: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({ length: Type.Number() }))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 1', () => {
     type T = Array<any> extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 2', () => {
     type T = Array<any> extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 3', () => {
     type T = Array<any> extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 4', () => {
     type T = Array<string> extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 5', () => {
     type T = Array<any> extends any | Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Array(Type.String())]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Null', () => {
     type T = Array<any> extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Undefined', () => {
     type T = Array<any> extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   // ----------------------------------------------
   // Constrained
   // ----------------------------------------------
-
   it('Should extend constrained Any', () => {
     type T = Array<string> extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained Unknown', () => {
     type T = Array<string> extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained String', () => {
     type T = Array<string> extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Boolean', () => {
     type T = Array<string> extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Number', () => {
     type T = Array<string> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Integer', () => {
     type T = Array<string> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Array 1', () => {
     type T = Array<string> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained Array 2', () => {
     type T = Array<string> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained Array 3', () => {
     type T = Array<string> extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained Tuple', () => {
     type T = Array<string> extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Object 1', () => {
     type T = Array<string> extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained Object 2', () => {
     type T = Array<string> extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained Object 3', () => {
     type T = Array<string> extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({ a: Type.Number() }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Object 4', () => {
     type T = Array<string> extends { length: '1' } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({ length: Type.Literal('1') }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Object 5', () => {
     type T = Array<string> extends { length: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({ length: Type.Number() }))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained Union 1', () => {
     type T = Array<string> extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Null(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Union 2', () => {
     type T = Array<string> extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained Union 3', () => {
     type T = Array<string> extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained Union 4', () => {
     type T = Array<string> extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained Union 5', () => {
     type T = Array<string> extends any | Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.String())]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained Null', () => {
     type T = Array<string> extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Undefined', () => {
     type T = Array<string> extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Void', () => {
     type T = Array<string> extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Date', () => {
     type T = Array<string> extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Date())
diff --git a/test/runtime/type/extends/boolean.ts b/test/runtime/type/extends/boolean.ts
index 290eee289..c627b3a42 100644
--- a/test/runtime/type/extends/boolean.ts
+++ b/test/runtime/type/extends/boolean.ts
@@ -8,97 +8,81 @@ describe('type/extends/Boolean', () => {
     const R = TypeExtends.Extends(Type.Boolean(), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String', () => {
     type T = boolean extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Boolean', () => {
     type T = boolean extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Number', () => {
     type T = boolean extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Integer', () => {
     type T = boolean extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array', () => {
     type T = boolean extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Tuple', () => {
     type T = boolean extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Record', () => {
     type T = boolean extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Record(Type.Number(), Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 1', () => {
     type T = boolean extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Object({}, { additionalProperties: false }))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 2', () => {
     type T = boolean extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 1', () => {
     type T = boolean extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 2', () => {
     type T = boolean extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Union([Type.Any(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 2', () => {
     type T = boolean extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Union([Type.Boolean(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Null', () => {
     type T = boolean extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Undefined', () => {
     type T = boolean extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Void', () => {
     type T = boolean extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Date', () => {
     type T = boolean extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Date())
diff --git a/test/runtime/type/extends/constructor.ts b/test/runtime/type/extends/constructor.ts
index 5746dbab4..6d5b16ede 100644
--- a/test/runtime/type/extends/constructor.ts
+++ b/test/runtime/type/extends/constructor.ts
@@ -8,67 +8,56 @@ describe('type/extends/Constructor', () => {
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Function([], Type.Number()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Constructor 1', () => {
     type T = (new () => number) extends new () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Number()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Constructor 2', () => {
     type T = (new () => any) extends new () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Constructor 3', () => {
     type T = (new () => number) extends new () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Constructor 4', () => {
     type T = (new (a: number) => number) extends new () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([], Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Constructor 5', () => {
     type T = (new (a: number | string) => number) extends new (a: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Union([Type.Number(), Type.String()])], Type.Number()), Type.Constructor([Type.Number()], Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Constructor 6', () => {
     type T = (new (a: number) => number) extends new (a: number | string) => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([Type.Union([Type.Number(), Type.String()])], Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Constructor 7', () => {
     type T = (new (a: number, b: number) => number) extends new (a: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Number(), Type.Number()], Type.Number()), Type.Constructor([Type.Number()], Type.Number()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Constructor 8', () => {
     type T = (new (a: number) => number) extends new (a: number, b: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([Type.Number(), Type.Number()], Type.Number()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Constructor 9', () => {
     type T = (new () => number) extends new () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Constructor 9', () => {
     type T = (new () => any) extends new () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Constructor 10', () => {
     type T = (new () => Array<any>) extends new () => object ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Array(Type.Any())), Type.Constructor([], Type.Object({})))
@@ -79,169 +68,141 @@ describe('type/extends/Constructor', () => {
     const R = TypeExtends.Extends(Type.Constructor([], Type.Array(Type.String())), Type.Constructor([], Type.Object({})))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Constructor 12', () => {
     type T = (new () => object) extends new () => Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Object({})), Type.Constructor([], Type.Array(Type.Any())))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Constructor 13', () => {
     type T = (new (a: unknown) => number) extends new (a: any) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Unknown()], Type.Number({})), Type.Constructor([Type.Any()], Type.Number({})))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Constructor 14', () => {
     type T = (new (a: any) => number) extends new (a: unknown) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Any()], Type.Number({})), Type.Constructor([Type.Unknown()], Type.Number({})))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Constructor 15', () => {
     type T = (new () => any) extends new () => unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Any({})), Type.Constructor([], Type.Unknown({})))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Constructor 16', () => {
     type T = (new () => unknown) extends new () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Unknown({})), Type.Constructor([], Type.Any({})))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Any', () => {
     type T = (new () => number) extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String', () => {
     type T = (new () => number) extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Boolean', () => {
     type T = (new () => number) extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Number', () => {
     type T = (new () => number) extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Integer', () => {
     type T = (new () => number) extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array 1', () => {
     type T = (new () => number) extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array 2', () => {
     type T = (new () => number) extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array 3', () => {
     type T = (new () => number) extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Tuple', () => {
     type T = (new () => number) extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Record', () => {
     type T = (() => number) extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Record(Type.Number(), Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 1', () => {
     type T = (new () => number) extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 2', () => {
     type T = (new () => number) extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 3', () => {
     type T = (new () => number) extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({ a: Type.Number() }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 4', () => {
     type T = (new () => number) extends { length: '1' } ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({ length: Type.Literal('1') }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 1', () => {
     type T = (new () => number) extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Null(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 2', () => {
     type T = (new () => number) extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 3', () => {
     type T = (new () => number) extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 4', () => {
     type T = (new () => number) extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 5', () => {
     type T = (new () => number) extends any | Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.String())]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Null', () => {
     type T = (new () => number) extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Undefined', () => {
     type T = (new () => number) extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Void', () => {
     type T = (new () => number) extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Date', () => {
     type T = (new () => number) extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Date())
diff --git a/test/runtime/type/extends/date.ts b/test/runtime/type/extends/date.ts
index 53e7bfc55..21b6653ac 100644
--- a/test/runtime/type/extends/date.ts
+++ b/test/runtime/type/extends/date.ts
@@ -8,37 +8,31 @@ describe('type/extends/Date', () => {
     const R = TypeExtends.Extends(Type.Date(), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Unknown', () => {
     type T = Date extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String', () => {
     type T = Date extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Boolean', () => {
     type T = Date extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Number', () => {
     type T = Date extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Integer', () => {
     type T = Date extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array', () => {
     type T = Date extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Array(Type.Any()))
@@ -49,61 +43,51 @@ describe('type/extends/Date', () => {
     const R = TypeExtends.Extends(Type.Date(), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Record', () => {
     type T = Date extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Record(Type.Number(), Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 1', () => {
     type T = Date extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 2', () => {
     type T = Date extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 1', () => {
     type T = Date extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 2', () => {
     type T = Date extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Union([Type.Any(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 3', () => {
     type T = Date extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Union([Type.Boolean(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Null', () => {
     type T = Date extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Undefined', () => {
     type T = Date extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Void', () => {
     type T = Date extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Date', () => {
     type T = Date extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Date())
diff --git a/test/runtime/type/extends/function.ts b/test/runtime/type/extends/function.ts
index 93abeb0d4..8e36b03ed 100644
--- a/test/runtime/type/extends/function.ts
+++ b/test/runtime/type/extends/function.ts
@@ -8,241 +8,201 @@ describe('type/extends/Function', () => {
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Constructor([], Type.Number()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Function 1', () => {
     type T = (() => number) extends () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Function([], Type.Number()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Function 2', () => {
     type T = (() => any) extends () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Function 3', () => {
     type T = (() => number) extends () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Function 4', () => {
     type T = ((a: number) => number) extends () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Number()], Type.Number()), Type.Function([], Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Function 5', () => {
     type T = ((a: number | string) => number) extends (a: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Union([Type.Number(), Type.String()])], Type.Number()), Type.Function([Type.Number()], Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Function 6', () => {
     type T = ((a: number) => number) extends (a: number | string) => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Number()], Type.Number()), Type.Function([Type.Union([Type.Number(), Type.String()])], Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Function 7', () => {
     type T = ((a: number, b: number) => number) extends (a: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Number(), Type.Number()], Type.Number()), Type.Function([Type.Number()], Type.Number()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Function 8', () => {
     type T = ((a: number) => number) extends (a: number, b: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Number()], Type.Number()), Type.Function([Type.Number(), Type.Number()], Type.Number()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Function 9', () => {
     type T = (() => number) extends () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Function([], Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Function 9', () => {
     type T = (() => any) extends () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Function 10', () => {
     type T = (() => Array<any>) extends () => object ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Array(Type.Any())), Type.Function([], Type.Object({})))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Function 11', () => {
     type T = (() => Array<string>) extends () => object ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Array(Type.String())), Type.Function([], Type.Object({})))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Function 12', () => {
     type T = (() => object) extends () => Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Object({})), Type.Function([], Type.Array(Type.Any())))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Function 13', () => {
     type T = ((a: unknown) => number) extends (a: any) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Unknown()], Type.Number({})), Type.Function([Type.Any()], Type.Number({})))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Function 14', () => {
     type T = ((a: any) => number) extends (a: unknown) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Any()], Type.Number({})), Type.Function([Type.Unknown()], Type.Number({})))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Function 15', () => {
     type T = (() => any) extends () => unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Any({})), Type.Function([], Type.Unknown({})))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Function 16', () => {
     type T = (() => unknown) extends () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Unknown({})), Type.Function([], Type.Any({})))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Any', () => {
     type T = (() => number) extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String', () => {
     type T = (() => number) extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Boolean', () => {
     type T = (() => number) extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Number', () => {
     type T = (() => number) extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Integer', () => {
     type T = (() => number) extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array 1', () => {
     type T = (() => number) extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array 2', () => {
     type T = (() => number) extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array 3', () => {
     type T = (() => number) extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Tuple', () => {
     type T = (() => number) extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Record', () => {
     type T = (() => number) extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Record(Type.Number(), Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 1', () => {
     type T = (() => number) extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 2', () => {
     type T = (() => number) extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 3', () => {
     type T = (() => number) extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({ a: Type.Number() }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 4', () => {
     type T = (() => number) extends { length: '1' } ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({ length: Type.Literal('1') }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 5', () => {
     type T = (() => number) extends { length: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({ length: Type.Number() }))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 1', () => {
     type T = (() => number) extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Null(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 2', () => {
     type T = (() => number) extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 3', () => {
     type T = (() => number) extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 4', () => {
     type T = (() => number) extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 5', () => {
     type T = (() => number) extends any | Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.String())]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Null', () => {
     type T = (() => number) extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Void', () => {
     type T = (() => number) extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Date', () => {
     type T = (() => number) extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Date())
diff --git a/test/runtime/type/extends/index.ts b/test/runtime/type/extends/index.ts
index ae680a5a0..1bd1dc959 100644
--- a/test/runtime/type/extends/index.ts
+++ b/test/runtime/type/extends/index.ts
@@ -14,6 +14,7 @@ import './promise'
 import './record'
 import './string'
 import './symbol'
+import './template-literal'
 import './tuple'
 import './uint8array'
 import './undefined'
diff --git a/test/runtime/type/extends/integer.ts b/test/runtime/type/extends/integer.ts
index 844e1ffdb..d3c5e6016 100644
--- a/test/runtime/type/extends/integer.ts
+++ b/test/runtime/type/extends/integer.ts
@@ -8,103 +8,86 @@ describe('type/extends/Integer', () => {
     const R = TypeExtends.Extends(Type.Integer(), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Unknown', () => {
     type T = number extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String', () => {
     type T = number extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Boolean', () => {
     type T = number extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Number', () => {
     type T = number extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Integer', () => {
     type T = number extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Array', () => {
     type T = number extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Tuple', () => {
     type T = number extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Record', () => {
     type T = number extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Record(Type.Number(), Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 1', () => {
     type T = number extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 2', () => {
     type T = number extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Object({ a: Type.Literal(10) }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 1', () => {
     type T = number extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 2', () => {
     type T = number extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Union([Type.Any(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 2', () => {
     type T = number extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Union([Type.Boolean(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Null', () => {
     type T = number extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Undefined', () => {
     type T = number extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Void', () => {
     type T = number extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Date', () => {
     type T = number extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Date())
diff --git a/test/runtime/type/extends/literal.ts b/test/runtime/type/extends/literal.ts
index 71377e5e8..f11545ae2 100644
--- a/test/runtime/type/extends/literal.ts
+++ b/test/runtime/type/extends/literal.ts
@@ -11,37 +11,31 @@ describe('type/extends/Literal', () => {
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Unknown (String)', () => {
     type T = 'hello' extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String (String)', () => {
     type T = 'hello' extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Boolean (String)', () => {
     type T = 'hello' extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Number (String)', () => {
     type T = 'hello' extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Integer (String)', () => {
     type T = 'hello' extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array (String)', () => {
     type T = 'hello' extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Array(Type.Any()))
@@ -57,83 +51,69 @@ describe('type/extends/Literal', () => {
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Object({}, { additionalProperties: false }))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 2 (String)', () => {
     type T = 'hello' extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 1 (String)', () => {
     type T = 'hello' extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 2 (String)', () => {
     type T = 'hello' extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Union([Type.Any(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 3 (String)', () => {
     type T = 'hello' extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Union([Type.Boolean(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Null (String)', () => {
     type T = 'hello' extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Undefined (String)', () => {
     type T = 'hello' extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   // -------------------------------------------------------------------
   // Number Literal
   // -------------------------------------------------------------------
-
   it('Should extend Any (Number)', () => {
     type T = 10 extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Unknown (Number)', () => {
     type T = 10 extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String (Number)', () => {
     type T = 10 extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Boolean (Number)', () => {
     type T = 10 extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Number (Number)', () => {
     type T = 10 extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Integer (Number)', () => {
     type T = 10 extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Array (Number)', () => {
     type T = 10 extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Array(Type.Any()))
@@ -149,161 +129,134 @@ describe('type/extends/Literal', () => {
     const R = TypeExtends.Extends(Type.Literal(10), Type.Object({}, { additionalProperties: false }))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 2 (Number)', () => {
     type T = 10 extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 1 (Number)', () => {
     type T = 10 extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 2 (Number)', () => {
     type T = 10 extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Union([Type.Any(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 3 (Number)', () => {
     type T = 10 extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Union([Type.Boolean(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Null (Number)', () => {
     type T = 10 extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Undefined (Number)', () => {
     type T = 10 extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   // -------------------------------------------------------------------
   // Boolean Literal
   // -------------------------------------------------------------------
-
   it('Should extend Any (Boolean)', () => {
     type T = true extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Unknown (Boolean)', () => {
     type T = true extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String (Boolean)', () => {
     type T = true extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Boolean (Boolean)', () => {
     type T = true extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Number (Boolean)', () => {
     type T = true extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Integer (Boolean)', () => {
     type T = true extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array (Boolean)', () => {
     type T = true extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Tuple (Boolean)', () => {
     type T = true extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Record 1', () => {
     type T = 'hello' extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Record(Type.Number(), Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Record 2', () => {
     type T = 10 extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Record(Type.Number(), Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Record 3', () => {
     type T = true extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Record(Type.Number(), Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 1 (Boolean)', () => {
     type T = true extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Object({}, { additionalProperties: false }))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 2 (Boolean)', () => {
     type T = true extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 1 (Boolean)', () => {
     type T = true extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 2 (Boolean)', () => {
     type T = true extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Union([Type.Any(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 3 (Boolean)', () => {
     type T = true extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Union([Type.Boolean(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Null (Boolean)', () => {
     type T = true extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Undefined (Boolean)', () => {
     type T = true extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Void', () => {
     type T = true extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Date', () => {
     type T = true extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Date())
diff --git a/test/runtime/type/extends/null.ts b/test/runtime/type/extends/null.ts
index 82931c96d..f2d793ab9 100644
--- a/test/runtime/type/extends/null.ts
+++ b/test/runtime/type/extends/null.ts
@@ -8,109 +8,91 @@ describe('type/extends/Null', () => {
     const R = TypeExtends.Extends(Type.Null(), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Unknown', () => {
     type T = null extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String', () => {
     type T = null extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Boolean', () => {
     type T = null extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Number', () => {
     type T = null extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Integer', () => {
     type T = null extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array', () => {
     type T = null extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Tuple', () => {
     type T = null extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Record', () => {
     type T = null extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Record(Type.Number(), Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 1', () => {
     type T = null extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Object({}, { additionalProperties: false }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 2', () => {
     type T = null extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 3', () => {
     type T = null extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 1', () => {
     type T = null extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 2', () => {
     type T = null extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Union([Type.Any(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 2', () => {
     type T = null extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Union([Type.Boolean(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Null', () => {
     type T = null extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Undefined', () => {
     type T = null extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Void', () => {
     type T = null extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Date', () => {
     type T = null extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Date())
diff --git a/test/runtime/type/extends/number.ts b/test/runtime/type/extends/number.ts
index 06e893f9d..3c61fbe38 100644
--- a/test/runtime/type/extends/number.ts
+++ b/test/runtime/type/extends/number.ts
@@ -8,103 +8,86 @@ describe('type/extends/Number', () => {
     const R = TypeExtends.Extends(Type.Number(), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Unknown', () => {
     type T = number extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String', () => {
     type T = number extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Boolean', () => {
     type T = number extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Number', () => {
     type T = number extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Integer', () => {
     type T = number extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Array', () => {
     type T = number extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Tuple', () => {
     type T = number extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Record', () => {
     type T = number extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Record(Type.Number(), Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 1', () => {
     type T = number extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Object({}, { additionalProperties: false }))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 2', () => {
     type T = number extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 1', () => {
     type T = number extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 2', () => {
     type T = number extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 2', () => {
     type T = number extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Null', () => {
     type T = number extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Undefined', () => {
     type T = number extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Void', () => {
     type T = number extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Date', () => {
     type T = number extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Date())
diff --git a/test/runtime/type/extends/promise.ts b/test/runtime/type/extends/promise.ts
index b8c6a24db..44833d85b 100644
--- a/test/runtime/type/extends/promise.ts
+++ b/test/runtime/type/extends/promise.ts
@@ -6,243 +6,202 @@ describe('type/extends/Promise', () => {
   // ----------------------------------------------
   // Generic Varying
   // ----------------------------------------------
-
   it('Should extend Promise Varying 1', () => {
     type T = Promise<any> extends Promise<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Promise(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Promise Varying 2', () => {
     type T = Promise<string> extends Promise<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.String()), Type.Promise(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Promise Varying 3', () => {
     type T = Promise<any> extends Promise<string> ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Promise(Type.String()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Promise Varying 4', () => {
     type T = Promise<number> extends Promise<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Promise(Type.String()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   // ----------------------------------------------
   // Any
   // ----------------------------------------------
-
   it('Should extend Any', () => {
     type T = Promise<any> extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Unknown', () => {
     type T = Promise<any> extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String', () => {
     type T = Promise<any> extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Boolean', () => {
     type T = Promise<any> extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Number', () => {
     type T = Promise<any> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Integer', () => {
     type T = Promise<any> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array', () => {
     type T = Promise<any> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Tuple', () => {
     type T = Promise<any> extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Record', () => {
     type T = Promise<any> extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Record(Type.Number(), Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 1', () => {
     type T = Promise<any> extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Object({}, { additionalProperties: false }))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 2', () => {
     type T = Promise<any> extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 3', () => {
     type T = Promise<any> extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 1', () => {
     type T = Promise<any> extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 2', () => {
     type T = Promise<any> extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Union([Type.Any(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 2', () => {
     type T = Promise<any> extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Union([Type.Boolean(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Null', () => {
     type T = Promise<any> extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Undefined', () => {
     type T = Promise<any> extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   // ----------------------------------------------
   // Constrained
   // ----------------------------------------------
-
   it('Should extend constrained Any', () => {
     type T = Promise<number> extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained Unknown', () => {
     type T = Promise<number> extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained String', () => {
     type T = Promise<number> extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Boolean', () => {
     type T = Promise<number> extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Number', () => {
     type T = Promise<number> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Integer', () => {
     type T = Promise<number> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Array', () => {
     type T = Promise<number> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Tuple', () => {
     type T = Promise<number> extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Object 1', () => {
     type T = Promise<number> extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Object({}, { additionalProperties: false }))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained Object 2', () => {
     type T = Promise<number> extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Object 3', () => {
     type T = Promise<number> extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained Union 1', () => {
     type T = Promise<number> extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Union 2', () => {
     type T = Promise<number> extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Union([Type.Any(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend constrained Union 2', () => {
     type T = Promise<number> extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Union([Type.Boolean(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Null', () => {
     type T = Promise<number> extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend constrained Undefined', () => {
     type T = Promise<number> extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Void', () => {
     type T = Promise<number> extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Date', () => {
     type T = Promise<number> extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Date())
diff --git a/test/runtime/type/extends/record.ts b/test/runtime/type/extends/record.ts
index 74a7920a8..a3dfa77ee 100644
--- a/test/runtime/type/extends/record.ts
+++ b/test/runtime/type/extends/record.ts
@@ -10,7 +10,6 @@ describe('type/extends/Record', () => {
     const R = TypeExtends.Extends(A, B)
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Record 2', () => {
     type T = Record<string, number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
@@ -18,7 +17,6 @@ describe('type/extends/Record', () => {
     const R = TypeExtends.Extends(A, B)
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Record 3', () => {
     type T = Record<number, number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
@@ -26,7 +24,6 @@ describe('type/extends/Record', () => {
     const R = TypeExtends.Extends(A, B)
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Record 4', () => {
     type T = Record<'a' | 'b', number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
@@ -34,7 +31,6 @@ describe('type/extends/Record', () => {
     const R = TypeExtends.Extends(A, B)
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Record 5', () => {
     type T = Record<'a' | 'b', number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
@@ -42,7 +38,6 @@ describe('type/extends/Record', () => {
     const R = TypeExtends.Extends(A, B)
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Record 6', () => {
     type T = Record<string, number> extends Record<'a' | 'b', number> ? true : false
     const A = Type.Record(Type.String(), Type.Number())
@@ -50,7 +45,6 @@ describe('type/extends/Record', () => {
     const R = TypeExtends.Extends(A, B)
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Record 7', () => {
     type T = Record<string, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
@@ -58,7 +52,6 @@ describe('type/extends/Record', () => {
     const R = TypeExtends.Extends(A, B)
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Record 8', () => {
     type T = Record<string, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
@@ -66,7 +59,6 @@ describe('type/extends/Record', () => {
     const R = TypeExtends.Extends(A, B)
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Record 9', () => {
     type T = Record<number, number> extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
@@ -74,7 +66,6 @@ describe('type/extends/Record', () => {
     const R = TypeExtends.Extends(A, B)
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Record 10', () => {
     type T = Record<number, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
@@ -82,7 +73,6 @@ describe('type/extends/Record', () => {
     const R = TypeExtends.Extends(A, B)
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Record 11', () => {
     type T = Record<number, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
@@ -90,9 +80,7 @@ describe('type/extends/Record', () => {
     const R = TypeExtends.Extends(A, B)
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   // -----
-
   it('Should extend Record 12', () => {
     type T = Record<string, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
@@ -100,7 +88,6 @@ describe('type/extends/Record', () => {
     const R = TypeExtends.Extends(A, B)
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Record 13', () => {
     type T = Record<number, number> extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
@@ -108,7 +95,6 @@ describe('type/extends/Record', () => {
     const R = TypeExtends.Extends(A, B)
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Record 14', () => {
     type T = Record<number, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
@@ -116,7 +102,6 @@ describe('type/extends/Record', () => {
     const R = TypeExtends.Extends(A, B)
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Record 15', () => {
     type T = Record<number, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
@@ -124,107 +109,89 @@ describe('type/extends/Record', () => {
     const R = TypeExtends.Extends(A, B)
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   // -------------------------------------------------------------------
   // Standard
   // -------------------------------------------------------------------
-
   it('Should extend Any', () => {
     type T = Record<number, number> extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Unknown', () => {
     type T = Record<number, number> extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String', () => {
     type T = Record<number, number> extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Boolean', () => {
     type T = Record<number, number> extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Number', () => {
     type T = Record<number, number> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Integer', () => {
     type T = Record<number, number> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array 1', () => {
     type T = Record<number, number> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array 2', () => {
     type T = Record<number, number> extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.String()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Tuple', () => {
     type T = Record<number, number> extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 2', () => {
     type T = Record<number, number> extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 3', () => {
     type T = Record<number, number> extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Object({ a: Type.Number() }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 1', () => {
     type T = Record<number, number> extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 2', () => {
     type T = Record<number, number> extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Any(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Null', () => {
     type T = Record<number, number> extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Undefined', () => {
     type T = Record<number, number> extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Void', () => {
     type T = Record<number, number> extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Date', () => {
     type T = Record<number, number> extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Date())
diff --git a/test/runtime/type/extends/string.ts b/test/runtime/type/extends/string.ts
index 1ba4aa486..1746be6e6 100644
--- a/test/runtime/type/extends/string.ts
+++ b/test/runtime/type/extends/string.ts
@@ -8,121 +8,101 @@ describe('type/extends/String', () => {
     const R = TypeExtends.Extends(Type.String(), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Unknown', () => {
     type T = string extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String', () => {
     type T = string extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Boolean', () => {
     type T = string extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Number', () => {
     type T = string extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Integer', () => {
     type T = string extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array', () => {
     type T = string extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Tuple', () => {
     type T = string extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Record 1', () => {
     type T = string extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Record 2', () => {
     type T = string extends Record<number, unknown> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Unknown()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Record 3', () => {
     type T = string extends Record<number, string> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.String()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Record 4', () => {
     type T = string extends Record<number, number> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Number()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 1', () => {
     type T = string extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Object({}, { additionalProperties: false }))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 2', () => {
     type T = string extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 1', () => {
     type T = number extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 2', () => {
     type T = number extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 3', () => {
     type T = number extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Null', () => {
     type T = number extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Undefined', () => {
     type T = number extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Void', () => {
     type T = number extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Date', () => {
     type T = number extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Date())
diff --git a/test/runtime/type/extends/template-literal.ts b/test/runtime/type/extends/template-literal.ts
new file mode 100644
index 000000000..9abf5f547
--- /dev/null
+++ b/test/runtime/type/extends/template-literal.ts
@@ -0,0 +1,162 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/TemplateLiteral', () => {
+  // -------------------------------------------------------------------
+  // String Literal 'hello'
+  // -------------------------------------------------------------------
+  it('Should extend Any (hello)', () => {
+    type T = 'hello' extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Unknown (hello)', () => {
+    type T = 'hello' extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend String (hello)', () => {
+    type T = 'hello' extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Boolean (hello)', () => {
+    type T = 'hello' extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Number (hello)', () => {
+    type T = 'hello' extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Integer (hello)', () => {
+    type T = 'hello' extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Array (hello)', () => {
+    type T = 'hello' extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Tuple (hello)', () => {
+    type T = 'hello' extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Object 1 (hello)', () => {
+    type T = 'hello' extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Object 2 (hello)', () => {
+    type T = 'hello' extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Union 1 (hello)', () => {
+    type T = 'hello' extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Union 2 (hello)', () => {
+    type T = 'hello' extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Union 3 (hello)', () => {
+    type T = 'hello' extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Null (hello)', () => {
+    type T = 'hello' extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Undefined (hello)', () => {
+    type T = 'hello' extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  // -------------------------------------------------------------------
+  // String Literal 'hello' | 'world'
+  // -------------------------------------------------------------------
+  it('Should extend Any (hello | world)', () => {
+    type T = 'hello' | 'world' extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Any())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Unknown (hello | world)', () => {
+    type T = 'hello' | 'world' extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Unknown())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend String (hello | world)', () => {
+    type T = 'hello' | 'world' extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.String())
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Boolean (hello | world)', () => {
+    type T = 'hello' | 'world' extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Boolean())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Number (hello | world)', () => {
+    type T = 'hello' | 'world' extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Number())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Integer (hello | world)', () => {
+    type T = 'hello' | 'world' extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Integer())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Array (hello | world)', () => {
+    type T = 'hello' | 'world' extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Array(Type.Any()))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Tuple (hello | world)', () => {
+    type T = 'hello' | 'world' extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Object 1 (hello | world)', () => {
+    type T = 'hello' | 'world' extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Object({}, { additionalProperties: false }))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Object 2 (hello | world)', () => {
+    type T = 'hello' | 'world' extends { a: 10 } ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Union 1 (hello | world)', () => {
+    type T = 'hello' | 'world' extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Union([Type.Number(), Type.String()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Union 2 (hello | world)', () => {
+    type T = 'hello' | 'world' extends any | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Union([Type.Any(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Union 3 (hello | world)', () => {
+    type T = 'hello' | 'world' extends boolean | number ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Null (hello | world)', () => {
+    type T = 'hello' | 'world' extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Null())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Undefined (hello | world)', () => {
+    type T = 'hello' | 'world' extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Undefined())
+    Assert.deepEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/uint8array.ts b/test/runtime/type/extends/uint8array.ts
index 756a93d53..2ffea0806 100644
--- a/test/runtime/type/extends/uint8array.ts
+++ b/test/runtime/type/extends/uint8array.ts
@@ -8,103 +8,86 @@ describe('type/extends/Uint8Array', () => {
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Unknown', () => {
     type T = Uint8Array extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String', () => {
     type T = Uint8Array extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Boolean', () => {
     type T = Uint8Array extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Number', () => {
     type T = Uint8Array extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Integer', () => {
     type T = Uint8Array extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array', () => {
     type T = Uint8Array extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Tuple', () => {
     type T = Uint8Array extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Record', () => {
     type T = Uint8Array extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Record(Type.Number(), Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 1', () => {
     type T = Uint8Array extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Object({}, { additionalProperties: false }))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Object 2', () => {
     type T = Uint8Array extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 1', () => {
     type T = Uint8Array extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 2', () => {
     type T = Uint8Array extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Union([Type.Any(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 3', () => {
     type T = Uint8Array extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Union([Type.Boolean(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Null', () => {
     type T = Uint8Array extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Undefined', () => {
     type T = Uint8Array extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Void', () => {
     type T = Uint8Array extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Date', () => {
     type T = Uint8Array extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Date())
diff --git a/test/runtime/type/extends/undefined.ts b/test/runtime/type/extends/undefined.ts
index 46a4061a5..f6b39edcb 100644
--- a/test/runtime/type/extends/undefined.ts
+++ b/test/runtime/type/extends/undefined.ts
@@ -8,97 +8,81 @@ describe('type/extends/Undefined', () => {
     const R = TypeExtends.Extends(Type.Undefined(), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String', () => {
     type T = undefined extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Boolean', () => {
     type T = undefined extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Number', () => {
     type T = undefined extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Integer', () => {
     type T = undefined extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array', () => {
     type T = undefined extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Tuple', () => {
     type T = undefined extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 1', () => {
     type T = undefined extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Object({}, { additionalProperties: false }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 2', () => {
     type T = undefined extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 3', () => {
     type T = undefined extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 1', () => {
     type T = undefined extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 2', () => {
     type T = undefined extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Union([Type.Any(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 2', () => {
     type T = undefined extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Union([Type.Boolean(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Null', () => {
     type T = undefined extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Undefined', () => {
     type T = undefined extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Void', () => {
     type T = undefined extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Date', () => {
     type T = undefined extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Date())
diff --git a/test/runtime/type/extends/unknown.ts b/test/runtime/type/extends/unknown.ts
index c37f4c65f..152cd71bd 100644
--- a/test/runtime/type/extends/unknown.ts
+++ b/test/runtime/type/extends/unknown.ts
@@ -8,109 +8,91 @@ describe('type/extends/Unknown', () => {
     const R = TypeExtends.Extends(Type.Unknown(), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Unknown', () => {
     type T = unknown extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String', () => {
     type T = unknown extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Boolean', () => {
     type T = unknown extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Number', () => {
     type T = unknown extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Integer', () => {
     type T = unknown extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array 1', () => {
     type T = unknown extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array 2', () => {
     type T = unknown extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Array(Type.String()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Tuple', () => {
     type T = unknown extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 1', () => {
     type T = unknown extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 2', () => {
     type T = unknown extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Object({ a: Type.Number() }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 1', () => {
     type T = unknown extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 2', () => {
     type T = unknown extends any | number ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Any(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 3', () => {
     type T = unknown extends unknown | number ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Unknown(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 4', () => {
     type T = unknown extends unknown | any ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Unknown(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Null', () => {
     type T = unknown extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Undefined', () => {
     type T = unknown extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Void', () => {
     type T = unknown extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Date', () => {
     type T = unknown extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Date())
diff --git a/test/runtime/type/extends/void.ts b/test/runtime/type/extends/void.ts
index d800fb08d..171994949 100644
--- a/test/runtime/type/extends/void.ts
+++ b/test/runtime/type/extends/void.ts
@@ -8,115 +8,96 @@ describe('type/extends/Void', () => {
     const R = TypeExtends.Extends(Type.Void(), Type.Any())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Unknown', () => {
     type T = void extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Unknown())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend String', () => {
     type T = void extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.String())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Boolean', () => {
     type T = void extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Boolean())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Number', () => {
     type T = void extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Number())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Integer', () => {
     type T = void extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Integer())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array 1', () => {
     type T = void extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Array(Type.Any()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Array 2', () => {
     type T = void extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Array(Type.String()))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Tuple', () => {
     type T = void extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Tuple([Type.Number(), Type.Number()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 1', () => {
     type T = void extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 2', () => {
     type T = void extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Object({}))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Object 3', () => {
     type T = void extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Object({ a: Type.Number() }))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 1', () => {
     type T = void extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Number(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Union 2', () => {
     type T = void extends any | number ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Any(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 3', () => {
     type T = void extends unknown | number ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Unknown(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Union 4', () => {
     type T = void extends unknown | any ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Unknown(), Type.String()]))
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Null', () => {
     type T = void extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Null())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Undefined', () => {
     type T = void extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Undefined())
     Assert.deepEqual(R, TypeExtendsResult.False)
   })
-
   it('Should extend Void', () => {
     type T = void extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Void())
     Assert.deepEqual(R, TypeExtendsResult.True)
   })
-
   it('Should extend Date', () => {
     type T = void extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Date())
diff --git a/test/runtime/type/guard/exclude.ts b/test/runtime/type/guard/exclude.ts
index be3e62261..f85a18fad 100644
--- a/test/runtime/type/guard/exclude.ts
+++ b/test/runtime/type/guard/exclude.ts
@@ -21,4 +21,70 @@ describe('type/guard/TExclude', () => {
     const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Boolean()]))
     Assert.deepEqual(TypeGuard.TNumber(T), true)
   })
+  // ------------------------------------------------------------------------
+  // TemplateLiteral | TemplateLiteral
+  // ------------------------------------------------------------------------
+  it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const T = Type.Exclude(A, B)
+    Assert.deepEqual(TypeGuard.TNever(T), true)
+  })
+  it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+    const T = Type.Exclude(A, B)
+    Assert.deepEqual(['C'].includes(T.const), true)
+  })
+  it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
+    const T = Type.Exclude(A, B)
+    Assert.deepEqual(['C', 'B'].includes(T.anyOf[0].const), true)
+    Assert.deepEqual(['C', 'B'].includes(T.anyOf[1].const), true)
+  })
+  // ------------------------------------------------------------------------
+  // TemplateLiteral | Union 1
+  // ------------------------------------------------------------------------
+  it('Should extract TemplateLiteral | Union 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+    const T = Type.Exclude(A, B)
+    Assert.deepEqual(TypeGuard.TNever(T), true)
+  })
+  it('Should extract TemplateLiteral | Union 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.Union([Type.Literal('A'), Type.Literal('B')])
+    const T = Type.Exclude(A, B)
+    Assert.deepEqual(['C'].includes(T.const), true)
+  })
+  it('Should extract TemplateLiteral | Union 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.Union([Type.Literal('A')])
+    const T = Type.Exclude(A, B)
+    Assert.deepEqual(['C', 'B'].includes(T.anyOf[0].const), true)
+    Assert.deepEqual(['C', 'B'].includes(T.anyOf[1].const), true)
+  })
+  // ------------------------------------------------------------------------
+  // Union | TemplateLiteral 1
+  // ------------------------------------------------------------------------
+  it('Should extract Union | TemplateLiteral 1', () => {
+    const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const T = Type.Exclude(A, B)
+    Assert.deepEqual(TypeGuard.TNever(T), true)
+  })
+  it('Should extract Union | TemplateLiteral 1', () => {
+    const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+    const T = Type.Exclude(A, B)
+    Assert.deepEqual(['C'].includes(T.const), true)
+  })
+  it('Should extract Union | TemplateLiteral 1', () => {
+    const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
+    const T = Type.Exclude(A, B)
+    Assert.deepEqual(['C', 'B'].includes(T.anyOf[0].const), true)
+    Assert.deepEqual(['C', 'B'].includes(T.anyOf[1].const), true)
+  })
 })
diff --git a/test/runtime/type/guard/extract.ts b/test/runtime/type/guard/extract.ts
index f1caa3737..66914e7e7 100644
--- a/test/runtime/type/guard/extract.ts
+++ b/test/runtime/type/guard/extract.ts
@@ -21,4 +21,76 @@ describe('type/guard/TExtract', () => {
     Assert.deepEqual(TypeGuard.TString(T.anyOf[0]), true)
     Assert.deepEqual(TypeGuard.TBoolean(T.anyOf[1]), true)
   })
+  // ------------------------------------------------------------------------
+  // TemplateLiteral | TemplateLiteral
+  // ------------------------------------------------------------------------
+  it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const T = Type.Extract(A, B)
+    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[0].const), true)
+    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[1].const), true)
+    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[2].const), true)
+  })
+  it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+    const T = Type.Extract(A, B)
+    Assert.deepEqual(['A', 'B'].includes(T.anyOf[0].const), true)
+    Assert.deepEqual(['A', 'B'].includes(T.anyOf[1].const), true)
+  })
+  it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
+    const T = Type.Extract(A, B)
+    Assert.deepEqual(['A'].includes(T.const), true)
+  })
+  // ------------------------------------------------------------------------
+  // TemplateLiteral | Union 1
+  // ------------------------------------------------------------------------
+  it('Should extract TemplateLiteral | Union 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+    const T = Type.Extract(A, B)
+    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[0].const), true)
+    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[1].const), true)
+    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[2].const), true)
+  })
+  it('Should extract TemplateLiteral | Union 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.Union([Type.Literal('A'), Type.Literal('B')])
+    const T = Type.Extract(A, B)
+    Assert.deepEqual(['A', 'B'].includes(T.anyOf[0].const), true)
+    Assert.deepEqual(['A', 'B'].includes(T.anyOf[1].const), true)
+  })
+  it('Should extract TemplateLiteral | Union 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.Union([Type.Literal('A')])
+    const T = Type.Extract(A, B)
+    Assert.deepEqual(['A'].includes(T.const), true)
+  })
+  // ------------------------------------------------------------------------
+  // Union | TemplateLiteral 1
+  // ------------------------------------------------------------------------
+  it('Should extract Union | TemplateLiteral 1', () => {
+    const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const T = Type.Extract(A, B)
+    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[0].const), true)
+    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[1].const), true)
+    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[2].const), true)
+  })
+  it('Should extract Union | TemplateLiteral 1', () => {
+    const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+    const T = Type.Extract(A, B)
+    Assert.deepEqual(['A', 'B'].includes(T.anyOf[0].const), true)
+    Assert.deepEqual(['A', 'B'].includes(T.anyOf[1].const), true)
+  })
+  it('Should extract Union | TemplateLiteral 1', () => {
+    const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
+    const T = Type.Extract(A, B)
+    Assert.deepEqual(['A'].includes(T.const), true)
+  })
 })
diff --git a/test/runtime/type/guard/index.ts b/test/runtime/type/guard/index.ts
index 28cc9f5c8..d9d8086c4 100644
--- a/test/runtime/type/guard/index.ts
+++ b/test/runtime/type/guard/index.ts
@@ -18,9 +18,10 @@ import './object'
 import './promise'
 import './record'
 import './ref'
-import './self'
 import './string'
 import './symbol'
+import './template-literal'
+import './this'
 import './tuple'
 import './uint8array'
 import './undefined'
diff --git a/test/runtime/type/guard/self.ts b/test/runtime/type/guard/self.ts
deleted file mode 100644
index d9059c1ba..000000000
--- a/test/runtime/type/guard/self.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { TypeGuard } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
-
-describe('type/guard/TSelf', () => {
-  it('Should guard for TSelf', () => {
-    Type.Recursive((Node) => {
-      const R = TypeGuard.TSelf(Node)
-      Assert.equal(R, true)
-      return Type.Object({ nodes: Type.Array(Node) })
-    })
-  })
-  it('Should guard for TSelf with invalid $ref', () => {
-    Type.Recursive((Node) => {
-      // @ts-ignore
-      Node.$ref = 1
-      const R = TypeGuard.TSelf(Node)
-      Assert.equal(R, false)
-      return Type.Object({ nodes: Type.Array(Node) })
-    })
-  })
-})
diff --git a/test/runtime/type/guard/template-literal.ts b/test/runtime/type/guard/template-literal.ts
new file mode 100644
index 000000000..4d988829d
--- /dev/null
+++ b/test/runtime/type/guard/template-literal.ts
@@ -0,0 +1,47 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TTemplateLiteral', () => {
+  it('Should guard for empty TemplateLiteral', () => {
+    const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([]))
+    Assert.equal(R, true)
+  })
+  it('Should guard for TSchema', () => {
+    const R = TypeGuard.TSchema(Type.TemplateLiteral([]))
+    Assert.equal(R, true)
+  })
+  it('Should guard for TemplateLiteral (TTemplateLiteral)', () => {
+    const T = Type.TemplateLiteral([Type.Literal('hello')])
+    const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([T, Type.Literal('world')]))
+    Assert.equal(R, true)
+  })
+  it('Should guard for TemplateLiteral (TLiteral)', () => {
+    const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([Type.Literal('hello')]))
+    Assert.equal(R, true)
+  })
+  it('Should guard for TemplateLiteral (TString)', () => {
+    const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([Type.String()]))
+    Assert.equal(R, true)
+  })
+  it('Should guard for TemplateLiteral (TNumber)', () => {
+    const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([Type.Number()]))
+    Assert.equal(R, true)
+  })
+  it('Should guard for TemplateLiteral (TBoolean)', () => {
+    const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([Type.Boolean()]))
+    Assert.equal(R, true)
+  })
+  it('Should not guard for missing ^ expression prefix', () => {
+    const T = Type.TemplateLiteral([Type.Literal('hello')])
+    // @ts-ignore
+    T.pattern = T.pattern.slice(1)
+    Assert.equal(TypeGuard.TTemplateLiteral(T), false)
+  })
+  it('Should not guard for missing $ expression postfix', () => {
+    const T = Type.TemplateLiteral([Type.Literal('hello')])
+    // @ts-ignore
+    T.pattern = T.pattern.slice(0, T.pattern.length - 1)
+    Assert.equal(TypeGuard.TTemplateLiteral(T), false)
+  })
+})
diff --git a/test/runtime/type/guard/this.ts b/test/runtime/type/guard/this.ts
new file mode 100644
index 000000000..2da48ed13
--- /dev/null
+++ b/test/runtime/type/guard/this.ts
@@ -0,0 +1,22 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TThis', () => {
+  it('Should guard for TThis', () => {
+    Type.Recursive((This) => {
+      const R = TypeGuard.TThis(This)
+      Assert.equal(R, true)
+      return Type.Object({ nodes: Type.Array(This) })
+    })
+  })
+  it('Should guard for TThis with invalid $ref', () => {
+    Type.Recursive((This) => {
+      // @ts-ignore
+      This.$ref = 1
+      const R = TypeGuard.TThis(This)
+      Assert.equal(R, false)
+      return Type.Object({ nodes: Type.Array(This) })
+    })
+  })
+})
diff --git a/test/runtime/type/index.ts b/test/runtime/type/index.ts
index 2ec254a35..0d61b85fd 100644
--- a/test/runtime/type/index.ts
+++ b/test/runtime/type/index.ts
@@ -1,5 +1,6 @@
 import './clone/index'
 import './extends/index'
 import './guard/index'
+import './normalize/index'
 import './registry/index'
-import './normal/index'
+import './template/index'
diff --git a/test/runtime/type/normal/exclude.ts b/test/runtime/type/normalize/exclude.ts
similarity index 100%
rename from test/runtime/type/normal/exclude.ts
rename to test/runtime/type/normalize/exclude.ts
diff --git a/test/runtime/type/normal/extract.ts b/test/runtime/type/normalize/extract.ts
similarity index 100%
rename from test/runtime/type/normal/extract.ts
rename to test/runtime/type/normalize/extract.ts
diff --git a/test/runtime/type/normal/index.ts b/test/runtime/type/normalize/index.ts
similarity index 100%
rename from test/runtime/type/normal/index.ts
rename to test/runtime/type/normalize/index.ts
diff --git a/test/runtime/type/normal/intersect.ts b/test/runtime/type/normalize/intersect.ts
similarity index 100%
rename from test/runtime/type/normal/intersect.ts
rename to test/runtime/type/normalize/intersect.ts
diff --git a/test/runtime/type/normal/record.ts b/test/runtime/type/normalize/record.ts
similarity index 100%
rename from test/runtime/type/normal/record.ts
rename to test/runtime/type/normalize/record.ts
diff --git a/test/runtime/type/normal/union.ts b/test/runtime/type/normalize/union.ts
similarity index 100%
rename from test/runtime/type/normal/union.ts
rename to test/runtime/type/normalize/union.ts
diff --git a/test/runtime/type/registry/format.ts b/test/runtime/type/registry/format.ts
index 7f04d15d3..494160aec 100644
--- a/test/runtime/type/registry/format.ts
+++ b/test/runtime/type/registry/format.ts
@@ -1,22 +1,19 @@
 import { FormatRegistry } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('format/Format', () => {
+describe('type/FormatRegistry', () => {
   it('Should set format', () => {
     FormatRegistry.Set('test#format1', () => true)
   })
-
   it('Should get format', () => {
     FormatRegistry.Set('test#format2', () => true)
     const format = FormatRegistry.Get('test#format2')
     Assert.equal(typeof format, 'function')
   })
-
   it('Should return true if exists', () => {
     FormatRegistry.Set('test#format3', () => true)
     Assert.equal(FormatRegistry.Has('test#format3'), true)
   })
-
   it('Should clear formats', () => {
     FormatRegistry.Set('test#format4', () => true)
     FormatRegistry.Clear()
diff --git a/test/runtime/type/registry/index.ts b/test/runtime/type/registry/index.ts
index 78c71b23b..1afccae94 100644
--- a/test/runtime/type/registry/index.ts
+++ b/test/runtime/type/registry/index.ts
@@ -1 +1,2 @@
 import './format'
+import './type'
diff --git a/test/runtime/type/registry/type.ts b/test/runtime/type/registry/type.ts
new file mode 100644
index 000000000..5289d3d6d
--- /dev/null
+++ b/test/runtime/type/registry/type.ts
@@ -0,0 +1,22 @@
+import { TypeRegistry } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/TypeRegistry', () => {
+  it('Should set type', () => {
+    TypeRegistry.Set('test#type1', () => true)
+  })
+  it('Should get type', () => {
+    TypeRegistry.Set('test#type2', () => true)
+    const format = TypeRegistry.Get('test#type2')
+    Assert.equal(typeof format, 'function')
+  })
+  it('Should return true if exists', () => {
+    TypeRegistry.Set('test#type3', () => true)
+    Assert.equal(TypeRegistry.Has('test#type3'), true)
+  })
+  it('Should clear types', () => {
+    TypeRegistry.Set('test#type4', () => true)
+    TypeRegistry.Clear()
+    Assert.equal(TypeRegistry.Has('test#type4'), false)
+  })
+})
diff --git a/test/runtime/type/template/finite.ts b/test/runtime/type/template/finite.ts
new file mode 100644
index 000000000..e44c8164f
--- /dev/null
+++ b/test/runtime/type/template/finite.ts
@@ -0,0 +1,61 @@
+import { PatternString, PatternBoolean, PatternNumber, TemplateLiteralParser, TemplateLiteralFinite } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/TemplateLiteralFinite', () => {
+  // ---------------------------------------------------------------
+  // Finite
+  // ---------------------------------------------------------------
+  it('Finite 1', () => {
+    const E = TemplateLiteralParser.Parse(`A`)
+    const R = TemplateLiteralFinite.Check(E)
+    Assert.deepEqual(R, true)
+  })
+  it('Finite 2', () => {
+    const E = TemplateLiteralParser.Parse(`A|B`)
+    const R = TemplateLiteralFinite.Check(E)
+    Assert.deepEqual(R, true)
+  })
+  it('Finite 3', () => {
+    const E = TemplateLiteralParser.Parse(`A(B|C)`)
+    const R = TemplateLiteralFinite.Check(E)
+    Assert.deepEqual(R, true)
+  })
+  it('Finite 4', () => {
+    const E = TemplateLiteralParser.Parse(`${PatternBoolean}`)
+    const R = TemplateLiteralFinite.Check(E)
+    Assert.deepEqual(R, true)
+  })
+  // ---------------------------------------------------------------
+  // Infinite
+  // ---------------------------------------------------------------
+  it('Infinite 1', () => {
+    const E = TemplateLiteralParser.Parse(`${PatternString}`)
+    const R = TemplateLiteralFinite.Check(E)
+    Assert.deepEqual(R, false)
+  })
+  it('Infinite 2', () => {
+    const E = TemplateLiteralParser.Parse(`${PatternNumber}`)
+    const R = TemplateLiteralFinite.Check(E)
+    Assert.deepEqual(R, false)
+  })
+  it('Infinite 3', () => {
+    const E = TemplateLiteralParser.Parse(`A|${PatternString}`)
+    const R = TemplateLiteralFinite.Check(E)
+    Assert.deepEqual(R, false)
+  })
+  it('Infinite 4', () => {
+    const E = TemplateLiteralParser.Parse(`A|${PatternNumber}`)
+    const R = TemplateLiteralFinite.Check(E)
+    Assert.deepEqual(R, false)
+  })
+  it('Infinite 5', () => {
+    const E = TemplateLiteralParser.Parse(`A(${PatternString})`)
+    const R = TemplateLiteralFinite.Check(E)
+    Assert.deepEqual(R, false)
+  })
+  it('Infinite 6', () => {
+    const E = TemplateLiteralParser.Parse(`A(${PatternNumber})`)
+    const R = TemplateLiteralFinite.Check(E)
+    Assert.deepEqual(R, false)
+  })
+})
diff --git a/test/runtime/type/template/generate.ts b/test/runtime/type/template/generate.ts
new file mode 100644
index 000000000..587e6cb9c
--- /dev/null
+++ b/test/runtime/type/template/generate.ts
@@ -0,0 +1,199 @@
+import { TemplateLiteralParser, TemplateLiteralGenerator } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/TemplateLiteralGenerator', () => {
+  // ---------------------------------------------------------------
+  // Exact (No Default Unwrap)
+  // ---------------------------------------------------------------
+  it('Exact 1', () => {
+    const E = TemplateLiteralParser.Parse('^$')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['^$'])
+  })
+  it('Exact 2', () => {
+    const E = TemplateLiteralParser.Parse('^A$')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['^A$'])
+  })
+  // ---------------------------------------------------------------
+  // Patterns
+  // ---------------------------------------------------------------
+  it('Pattern 1', () => {
+    const E = TemplateLiteralParser.Parse('(true|false)')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['true', 'false'])
+  })
+  it('Pattern 2', () => {
+    const E = TemplateLiteralParser.Parse('(0|[1-9][0-9]*)')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['0', '[1-9][0-9]*'])
+  })
+  it('Pattern 3', () => {
+    const E = TemplateLiteralParser.Parse('.*')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['.*'])
+  })
+  // ---------------------------------------------------------------
+  // Expression
+  // ---------------------------------------------------------------
+  it('Expression 1', () => {
+    const E = TemplateLiteralParser.Parse(')')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, [')'])
+  })
+  it('Expression 2', () => {
+    const E = TemplateLiteralParser.Parse('\\)')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, [')'])
+  })
+  it('Expression 3', () => {
+    const E = TemplateLiteralParser.Parse('\\(')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['('])
+  })
+  it('Expression 4', () => {
+    const E = TemplateLiteralParser.Parse('')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, [''])
+  })
+  it('Expression 5', () => {
+    const E = TemplateLiteralParser.Parse('\\')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, [''])
+  })
+  it('Expression 6', () => {
+    const E = TemplateLiteralParser.Parse('()')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, [''])
+  })
+  it('Expression 7', () => {
+    const E = TemplateLiteralParser.Parse('(a)')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['a'])
+  })
+  it('Expression 8', () => {
+    const E = TemplateLiteralParser.Parse('()))')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['))'])
+  })
+  it('Expression 9', () => {
+    const E = TemplateLiteralParser.Parse('())')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, [')'])
+  })
+  it('Expression 10', () => {
+    const E = TemplateLiteralParser.Parse('A|B')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['A', 'B'])
+  })
+  it('Expression 11', () => {
+    const E = TemplateLiteralParser.Parse('A|(B)')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['A', 'B'])
+  })
+  it('Expression 12', () => {
+    const E = TemplateLiteralParser.Parse('A(B)')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['AB'])
+  })
+  it('Expression 13', () => {
+    const E = TemplateLiteralParser.Parse('(A)B')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['AB'])
+  })
+  it('Expression 14', () => {
+    const E = TemplateLiteralParser.Parse('(A)|B')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['A', 'B'])
+  })
+  it('Expression 15', () => {
+    const E = TemplateLiteralParser.Parse('|')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, [''])
+  })
+  it('Expression 16', () => {
+    const E = TemplateLiteralParser.Parse('||')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, [''])
+  })
+  it('Expression 17', () => {
+    const E = TemplateLiteralParser.Parse('||A')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['A'])
+  })
+  it('Expression 18', () => {
+    const E = TemplateLiteralParser.Parse('A||')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['A'])
+  })
+  it('Expression 19', () => {
+    const E = TemplateLiteralParser.Parse('A||B')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['A', 'B'])
+  })
+  it('Expression 20', () => {
+    const E = TemplateLiteralParser.Parse('A|()|B')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['A', '', 'B'])
+  })
+  it('Expression 21', () => {
+    const E = TemplateLiteralParser.Parse('A|(|)|B')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['A', '', 'B'])
+  })
+  it('Expression 22', () => {
+    const E = TemplateLiteralParser.Parse('A|(||)|B')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['A', '', 'B'])
+  })
+  it('Expression 23', () => {
+    const E = TemplateLiteralParser.Parse('|A(||)B|')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['AB'])
+  })
+  it('Expression 24', () => {
+    const E = TemplateLiteralParser.Parse('A(B)(C)')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['ABC'])
+  })
+  it('Expression 25', () => {
+    const E = TemplateLiteralParser.Parse('A(B)|(C)')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['AB', 'C'])
+  })
+  it('Expression 26', () => {
+    const E = TemplateLiteralParser.Parse('A(B|C)')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['AB', 'AC'])
+  })
+  it('Expression 27', () => {
+    const E = TemplateLiteralParser.Parse('A|(B|C)')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['A', 'B', 'C'])
+  })
+  it('Expression 28', () => {
+    const E = TemplateLiteralParser.Parse('((A)B)C')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['ABC'])
+  })
+  it('Expression 29', () => {
+    const E = TemplateLiteralParser.Parse('(0|1)(0|1)')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['00', '01', '10', '11'])
+  })
+  it('Expression 30', () => {
+    const E = TemplateLiteralParser.Parse('(0|1)|(0|1)')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['0', '1', '0', '1'])
+  })
+  it('Expression 31', () => {
+    const E = TemplateLiteralParser.Parse('(0|(1|0)|1)')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['0', '1', '0', '1'])
+  })
+  it('Expression 32', () => {
+    const E = TemplateLiteralParser.Parse('(0(1|0)1)')
+    const R = [...TemplateLiteralGenerator.Generate(E)]
+    Assert.deepEqual(R, ['011', '001'])
+  })
+})
diff --git a/test/runtime/type/template/index.ts b/test/runtime/type/template/index.ts
new file mode 100644
index 000000000..032be5db6
--- /dev/null
+++ b/test/runtime/type/template/index.ts
@@ -0,0 +1,4 @@
+import './finite'
+import './generate'
+import './parser'
+import './pattern'
diff --git a/test/runtime/type/template/parser.ts b/test/runtime/type/template/parser.ts
new file mode 100644
index 000000000..682a5b912
--- /dev/null
+++ b/test/runtime/type/template/parser.ts
@@ -0,0 +1,607 @@
+import { TemplateLiteralParser } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/TemplateLiteralParser', () => {
+  // ---------------------------------------------------------------
+  // Throws
+  // ---------------------------------------------------------------
+  it('Throw 1', () => {
+    Assert.throws(() => TemplateLiteralParser.Parse('('))
+  })
+  it('Throw 2', () => {
+    Assert.throws(() => TemplateLiteralParser.Parse('('))
+  })
+  // ---------------------------------------------------------------
+  // Exact (No Default Unwrap)
+  // ---------------------------------------------------------------
+  it('Exact 1', () => {
+    const E = TemplateLiteralParser.Parse('^$')
+    Assert.deepEqual(E, {
+      type: 'const',
+      const: '^$',
+    })
+  })
+  it('Exact 2', () => {
+    const E = TemplateLiteralParser.Parse('^A$')
+    Assert.deepEqual(E, {
+      type: 'const',
+      const: '^A$',
+    })
+  })
+  // ---------------------------------------------------------------
+  // Patterns
+  // ---------------------------------------------------------------
+  it('Pattern 1', () => {
+    const E = TemplateLiteralParser.Parse('(true|false)')
+    Assert.deepEqual(E, {
+      type: 'or',
+      expr: [
+        {
+          type: 'const',
+          const: 'true',
+        },
+        {
+          type: 'const',
+          const: 'false',
+        },
+      ],
+    })
+  })
+  it('Pattern 2', () => {
+    const E = TemplateLiteralParser.Parse('(0|[1-9][0-9]*)')
+    Assert.deepEqual(E, {
+      type: 'or',
+      expr: [
+        {
+          type: 'const',
+          const: '0',
+        },
+        {
+          type: 'const',
+          const: '[1-9][0-9]*',
+        },
+      ],
+    })
+  })
+  it('Pattern 3', () => {
+    const E = TemplateLiteralParser.Parse('.*')
+    Assert.deepEqual(E, {
+      type: 'const',
+      const: '.*',
+    })
+  })
+  // ---------------------------------------------------------------
+  // Expression
+  // ---------------------------------------------------------------
+  it('Expression 1', () => {
+    const E = TemplateLiteralParser.Parse(')')
+    Assert.deepEqual(E, {
+      type: 'const',
+      const: ')',
+    })
+  })
+  it('Expression 2', () => {
+    const E = TemplateLiteralParser.Parse('\\)')
+    Assert.deepEqual(E, {
+      type: 'const',
+      const: ')',
+    })
+  })
+  it('Expression 3', () => {
+    const E = TemplateLiteralParser.Parse('\\(')
+    Assert.deepEqual(E, {
+      type: 'const',
+      const: '(',
+    })
+  })
+  it('Expression 4', () => {
+    const E = TemplateLiteralParser.Parse('')
+    Assert.deepEqual(E, {
+      type: 'const',
+      const: '',
+    })
+  })
+  it('Expression 5', () => {
+    const E = TemplateLiteralParser.Parse('\\')
+    Assert.deepEqual(E, {
+      type: 'const',
+      const: '',
+    })
+  })
+  it('Expression 6', () => {
+    const E = TemplateLiteralParser.Parse('()')
+    Assert.deepEqual(E, {
+      type: 'const',
+      const: '',
+    })
+  })
+  it('Expression 7', () => {
+    const E = TemplateLiteralParser.Parse('(a)')
+    Assert.deepEqual(E, {
+      type: 'const',
+      const: 'a',
+    })
+  })
+  it('Expression 8', () => {
+    const E = TemplateLiteralParser.Parse('()))')
+    Assert.deepEqual(E, {
+      type: 'and',
+      expr: [
+        {
+          type: 'const',
+          const: '',
+        },
+        {
+          type: 'const',
+          const: '))',
+        },
+      ],
+    })
+  })
+  it('Expression 9', () => {
+    const E = TemplateLiteralParser.Parse('())')
+    Assert.deepEqual(E, {
+      type: 'and',
+      expr: [
+        {
+          type: 'const',
+          const: '',
+        },
+        {
+          type: 'const',
+          const: ')',
+        },
+      ],
+    })
+  })
+  it('Expression 10', () => {
+    const E = TemplateLiteralParser.Parse('A|B')
+    Assert.deepEqual(E, {
+      type: 'or',
+      expr: [
+        {
+          type: 'const',
+          const: 'A',
+        },
+        {
+          type: 'const',
+          const: 'B',
+        },
+      ],
+    })
+  })
+  it('Expression 11', () => {
+    const E = TemplateLiteralParser.Parse('A|(B)')
+    Assert.deepEqual(E, {
+      type: 'or',
+      expr: [
+        {
+          type: 'const',
+          const: 'A',
+        },
+        {
+          type: 'const',
+          const: 'B',
+        },
+      ],
+    })
+  })
+  it('Expression 12', () => {
+    const E = TemplateLiteralParser.Parse('A(B)')
+    Assert.deepEqual(E, {
+      type: 'and',
+      expr: [
+        {
+          type: 'const',
+          const: 'A',
+        },
+        {
+          type: 'const',
+          const: 'B',
+        },
+      ],
+    })
+  })
+  it('Expression 13', () => {
+    const E = TemplateLiteralParser.Parse('(A)B')
+    Assert.deepEqual(E, {
+      type: 'and',
+      expr: [
+        {
+          type: 'const',
+          const: 'A',
+        },
+        {
+          type: 'const',
+          const: 'B',
+        },
+      ],
+    })
+  })
+  it('Expression 14', () => {
+    const E = TemplateLiteralParser.Parse('(A)|B')
+    Assert.deepEqual(E, {
+      type: 'or',
+      expr: [
+        {
+          type: 'const',
+          const: 'A',
+        },
+        {
+          type: 'const',
+          const: 'B',
+        },
+      ],
+    })
+  })
+  it('Expression 15', () => {
+    const E = TemplateLiteralParser.Parse('|')
+    Assert.deepEqual(E, {
+      type: 'const',
+      const: '',
+    })
+  })
+  it('Expression 16', () => {
+    const E = TemplateLiteralParser.Parse('||')
+    Assert.deepEqual(E, {
+      type: 'const',
+      const: '',
+    })
+  })
+  it('Expression 17', () => {
+    const E = TemplateLiteralParser.Parse('||A')
+    Assert.deepEqual(E, {
+      type: 'const',
+      const: 'A',
+    })
+  })
+  it('Expression 18', () => {
+    const E = TemplateLiteralParser.Parse('A||')
+    Assert.deepEqual(E, {
+      type: 'const',
+      const: 'A',
+    })
+  })
+  it('Expression 19', () => {
+    const E = TemplateLiteralParser.Parse('A||B')
+    Assert.deepEqual(E, {
+      type: 'or',
+      expr: [
+        {
+          type: 'const',
+          const: 'A',
+        },
+        {
+          type: 'const',
+          const: 'B',
+        },
+      ],
+    })
+  })
+  it('Expression 20', () => {
+    const E = TemplateLiteralParser.Parse('A|()|B')
+    Assert.deepEqual(E, {
+      type: 'or',
+      expr: [
+        {
+          type: 'const',
+          const: 'A',
+        },
+        {
+          type: 'const',
+          const: '',
+        },
+        {
+          type: 'const',
+          const: 'B',
+        },
+      ],
+    })
+  })
+  it('Expression 21', () => {
+    const E = TemplateLiteralParser.Parse('A|(|)|B')
+    Assert.deepEqual(E, {
+      type: 'or',
+      expr: [
+        {
+          type: 'const',
+          const: 'A',
+        },
+        {
+          type: 'const',
+          const: '',
+        },
+        {
+          type: 'const',
+          const: 'B',
+        },
+      ],
+    })
+  })
+  it('Expression 22', () => {
+    const E = TemplateLiteralParser.Parse('A|(||)|B')
+    Assert.deepEqual(E, {
+      type: 'or',
+      expr: [
+        {
+          type: 'const',
+          const: 'A',
+        },
+        {
+          type: 'const',
+          const: '',
+        },
+        {
+          type: 'const',
+          const: 'B',
+        },
+      ],
+    })
+  })
+  it('Expression 23', () => {
+    const E = TemplateLiteralParser.Parse('|A(||)B|')
+    Assert.deepEqual(E, {
+      type: 'and',
+      expr: [
+        {
+          type: 'const',
+          const: 'A',
+        },
+        {
+          type: 'const',
+          const: '',
+        },
+        {
+          type: 'const',
+          const: 'B',
+        },
+      ],
+    })
+  })
+  it('Expression 24', () => {
+    const E = TemplateLiteralParser.Parse('A(B)(C)')
+    Assert.deepEqual(E, {
+      type: 'and',
+      expr: [
+        {
+          type: 'const',
+          const: 'A',
+        },
+        {
+          type: 'const',
+          const: 'B',
+        },
+        {
+          type: 'const',
+          const: 'C',
+        },
+      ],
+    })
+  })
+  it('Expression 25', () => {
+    const E = TemplateLiteralParser.Parse('A(B)|(C)')
+    Assert.deepEqual(E, {
+      type: 'or',
+      expr: [
+        {
+          type: 'and',
+          expr: [
+            {
+              type: 'const',
+              const: 'A',
+            },
+            {
+              type: 'const',
+              const: 'B',
+            },
+          ],
+        },
+        {
+          type: 'const',
+          const: 'C',
+        },
+      ],
+    })
+  })
+  it('Expression 26', () => {
+    const E = TemplateLiteralParser.Parse('A(B|C)')
+    Assert.deepEqual(E, {
+      type: 'and',
+      expr: [
+        {
+          type: 'const',
+          const: 'A',
+        },
+        {
+          type: 'or',
+          expr: [
+            {
+              type: 'const',
+              const: 'B',
+            },
+            {
+              type: 'const',
+              const: 'C',
+            },
+          ],
+        },
+      ],
+    })
+  })
+  it('Expression 27', () => {
+    const E = TemplateLiteralParser.Parse('A|(B|C)')
+    Assert.deepEqual(E, {
+      type: 'or',
+      expr: [
+        {
+          type: 'const',
+          const: 'A',
+        },
+        {
+          type: 'or',
+          expr: [
+            {
+              type: 'const',
+              const: 'B',
+            },
+            {
+              type: 'const',
+              const: 'C',
+            },
+          ],
+        },
+      ],
+    })
+  })
+  it('Expression 28', () => {
+    const E = TemplateLiteralParser.Parse('((A)B)C')
+    Assert.deepEqual(E, {
+      type: 'and',
+      expr: [
+        {
+          type: 'and',
+          expr: [
+            {
+              type: 'const',
+              const: 'A',
+            },
+            {
+              type: 'const',
+              const: 'B',
+            },
+          ],
+        },
+        {
+          type: 'const',
+          const: 'C',
+        },
+      ],
+    })
+  })
+  it('Expression 29', () => {
+    const E = TemplateLiteralParser.Parse('(0|1)(0|1)')
+    Assert.deepEqual(E, {
+      type: 'and',
+      expr: [
+        {
+          type: 'or',
+          expr: [
+            {
+              type: 'const',
+              const: '0',
+            },
+            {
+              type: 'const',
+              const: '1',
+            },
+          ],
+        },
+        {
+          type: 'or',
+          expr: [
+            {
+              type: 'const',
+              const: '0',
+            },
+            {
+              type: 'const',
+              const: '1',
+            },
+          ],
+        },
+      ],
+    })
+  })
+  it('Expression 30', () => {
+    const E = TemplateLiteralParser.Parse('(0|1)|(0|1)')
+    Assert.deepEqual(E, {
+      type: 'or',
+      expr: [
+        {
+          type: 'or',
+          expr: [
+            {
+              type: 'const',
+              const: '0',
+            },
+            {
+              type: 'const',
+              const: '1',
+            },
+          ],
+        },
+        {
+          type: 'or',
+          expr: [
+            {
+              type: 'const',
+              const: '0',
+            },
+            {
+              type: 'const',
+              const: '1',
+            },
+          ],
+        },
+      ],
+    })
+  })
+  it('Expression 31', () => {
+    const E = TemplateLiteralParser.Parse('(0|(1|0)|1)')
+    Assert.deepEqual(E, {
+      type: 'or',
+      expr: [
+        {
+          type: 'const',
+          const: '0',
+        },
+        {
+          type: 'or',
+          expr: [
+            {
+              type: 'const',
+              const: '1',
+            },
+            {
+              type: 'const',
+              const: '0',
+            },
+          ],
+        },
+        {
+          type: 'const',
+          const: '1',
+        },
+      ],
+    })
+  })
+  it('Expression 32', () => {
+    const E = TemplateLiteralParser.Parse('(0(1|0)1)')
+    Assert.deepEqual(E, {
+      type: 'and',
+      expr: [
+        {
+          type: 'const',
+          const: '0',
+        },
+        {
+          type: 'or',
+          expr: [
+            {
+              type: 'const',
+              const: '1',
+            },
+            {
+              type: 'const',
+              const: '0',
+            },
+          ],
+        },
+        {
+          type: 'const',
+          const: '1',
+        },
+      ],
+    })
+  })
+})
diff --git a/test/runtime/type/template/pattern.ts b/test/runtime/type/template/pattern.ts
new file mode 100644
index 000000000..1936c8211
--- /dev/null
+++ b/test/runtime/type/template/pattern.ts
@@ -0,0 +1,145 @@
+import { Type, TTemplateLiteral, PatternNumber, PatternString, PatternBoolean } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/TemplateLiteralPattern', () => {
+  const Equal = (template: TTemplateLiteral, expect: string) => {
+    const pattern = template.pattern.slice(1, template.pattern.length - 1)
+    Assert.equal(pattern, expect)
+  }
+  // ---------------------------------------------------------------
+  // Pattern
+  // ---------------------------------------------------------------
+  it('Pattern 1', () => {
+    const T = Type.TemplateLiteral([Type.Number()])
+    Equal(T, `${PatternNumber}`)
+  })
+  it('Pattern 2', () => {
+    const T = Type.TemplateLiteral([Type.String()])
+    Equal(T, `${PatternString}`)
+  })
+  it('Pattern 3', () => {
+    const T = Type.TemplateLiteral([Type.Boolean()])
+    Equal(T, `${PatternBoolean}`)
+  })
+  it('Pattern 4', () => {
+    const T = Type.TemplateLiteral([Type.Literal('A'), Type.Number()])
+    Equal(T, `A${PatternNumber}`)
+  })
+  it('Pattern 5', () => {
+    const T = Type.TemplateLiteral([Type.Literal('A'), Type.String()])
+    Equal(T, `A${PatternString}`)
+  })
+  it('Pattern 6', () => {
+    const T = Type.TemplateLiteral([Type.Literal('A'), Type.Boolean()])
+    Equal(T, `A${PatternBoolean}`)
+  })
+  it('Pattern 7', () => {
+    const T = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Number()])])
+    Equal(T, `(A|${PatternNumber})`)
+  })
+  it('Pattern 8', () => {
+    const T = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.String()])])
+    Equal(T, `(A|${PatternString})`)
+  })
+  it('Pattern 9', () => {
+    const T = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Boolean()])])
+    Equal(T, `(A|${PatternBoolean})`)
+  })
+  // ---------------------------------------------------------------
+  // Template
+  // ---------------------------------------------------------------
+  it('Template 1', () => {
+    const T = Type.TemplateLiteral([])
+    Equal(T, '')
+  })
+  it('Template 2', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A')
+    ])
+    Equal(T, 'A')
+  })
+  it('Template 3', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Literal('B'),
+    ])
+    Equal(T, 'AB')
+  })
+  it('Template 4', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Union([
+        Type.Literal('B'),
+      ])
+    ])
+    Equal(T, 'AB')
+  })
+  it('Template 5', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Union([
+        Type.Literal('B'),
+        Type.Literal('C'),
+      ])
+    ])
+    Equal(T, 'A(B|C)')
+  })
+  it('Template 6', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Union([
+        Type.Literal('B'),
+        Type.Literal('C'),
+      ]),
+      Type.Union([
+        Type.Literal('D'),
+        Type.Literal('E'),
+      ])
+    ])
+    Equal(T, 'A(B|C)(D|E)')
+  })
+  it('Template 7', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.TemplateLiteral([Type.Literal('A')]),
+      Type.TemplateLiteral([Type.Literal('B')])
+    ])
+    Equal(T, 'AB')
+  })
+  it('Template 8', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Union([
+        Type.TemplateLiteral([
+          Type.Literal('B'),
+          Type.Literal('C'),
+        ]),
+        Type.Literal('D')
+      ]),
+    ])
+    Equal(T, 'A(BC|D)')
+  })
+  it('Template 9', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Union([
+        Type.TemplateLiteral([
+          Type.Literal('B'),
+          Type.Literal('C'),
+        ]),
+        Type.Union([
+          Type.Literal('D'),
+          Type.Literal('E')
+        ])
+      ]),
+    ])
+    Equal(T, 'A(BC|(D|E))')
+  })
+})
diff --git a/test/runtime/value/cast/custom.ts b/test/runtime/value/cast/custom.ts
index 815a8e208..2c8d49477 100644
--- a/test/runtime/value/cast/custom.ts
+++ b/test/runtime/value/cast/custom.ts
@@ -3,7 +3,12 @@ import { Type, Kind, TypeRegistry } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/cast/Custom', () => {
-  TypeRegistry.Set('CustomCast', (schema, value) => value === 'hello' || value === 'world')
+  before(() => {
+    TypeRegistry.Set('CustomCast', (schema, value) => value === 'hello' || value === 'world')
+  })
+  after(() => {
+    TypeRegistry.Clear()
+  })
   const T = Type.Unsafe({ [Kind]: 'CustomCast', default: 'hello' })
   const E = 'hello'
   it('Should upcast from string', () => {
diff --git a/test/runtime/value/cast/index.ts b/test/runtime/value/cast/index.ts
index 238aa9688..8db2c8711 100644
--- a/test/runtime/value/cast/index.ts
+++ b/test/runtime/value/cast/index.ts
@@ -20,6 +20,7 @@ import './record'
 import './regex'
 import './string'
 import './symbol'
+import './template-literal'
 import './tuple'
 import './uint8array'
 import './undefined'
diff --git a/test/runtime/value/cast/recursive.ts b/test/runtime/value/cast/recursive.ts
index 39a0a9f68..78cc5c220 100644
--- a/test/runtime/value/cast/recursive.ts
+++ b/test/runtime/value/cast/recursive.ts
@@ -3,10 +3,10 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/cast/Recursive', () => {
-  const T = Type.Recursive((Self) =>
+  const T = Type.Recursive((This) =>
     Type.Object({
       id: Type.String(),
-      nodes: Type.Array(Self),
+      nodes: Type.Array(This),
     }),
   )
   const E = { id: '', nodes: [] }
@@ -63,17 +63,17 @@ describe('value/cast/Recursive', () => {
     Assert.deepEqual(result, value)
   })
   it('Should upcast from varying types', () => {
-    const TypeA = Type.Recursive((Self) =>
+    const TypeA = Type.Recursive((This) =>
       Type.Object({
         id: Type.String(),
-        nodes: Type.Array(Self),
+        nodes: Type.Array(This),
       }),
     )
-    const TypeB = Type.Recursive((Self) =>
+    const TypeB = Type.Recursive((This) =>
       Type.Object({
         id: Type.String(),
         name: Type.String({ default: 'test' }),
-        nodes: Type.Array(Self),
+        nodes: Type.Array(This),
       }),
     )
     const ValueA = {
diff --git a/test/runtime/value/cast/template-literal.ts b/test/runtime/value/cast/template-literal.ts
new file mode 100644
index 000000000..b2255bdfe
--- /dev/null
+++ b/test/runtime/value/cast/template-literal.ts
@@ -0,0 +1,53 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/TemplateLiteral', () => {
+  const T = Type.TemplateLiteral([Type.Literal('hello'), Type.Literal('world')])
+  const E = 'helloworld'
+  it('Should upcast from string', () => {
+    const value = 'world'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from boolean', () => {
+    const value = true
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, E)
+  })
+  it('Should preseve', () => {
+    const value = 'helloworld'
+    const result = Value.Cast(T, value)
+    Assert.deepEqual(result, 'helloworld')
+  })
+})
diff --git a/test/runtime/value/check/index.ts b/test/runtime/value/check/index.ts
index 1fc8801be..f5cc52770 100644
--- a/test/runtime/value/check/index.ts
+++ b/test/runtime/value/check/index.ts
@@ -21,6 +21,7 @@ import './record'
 import './regex'
 import './string'
 import './symbol'
+import './template-literal'
 import './tuple'
 import './uint8array'
 import './undefined'
diff --git a/test/runtime/value/check/recursive.ts b/test/runtime/value/check/recursive.ts
index 4659b7f8c..79f56d1cd 100644
--- a/test/runtime/value/check/recursive.ts
+++ b/test/runtime/value/check/recursive.ts
@@ -3,10 +3,10 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/check/Recursive', () => {
-  const T = Type.Recursive((Self) =>
+  const T = Type.Recursive((This) =>
     Type.Object({
       id: Type.String(),
-      nodes: Type.Array(Self),
+      nodes: Type.Array(This),
     }),
   )
 
diff --git a/test/runtime/value/check/template-literal.ts b/test/runtime/value/check/template-literal.ts
new file mode 100644
index 000000000..7208578c7
--- /dev/null
+++ b/test/runtime/value/check/template-literal.ts
@@ -0,0 +1,187 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/TemplateLiteral', () => {
+  // --------------------------------------------------------
+  // Finite
+  // --------------------------------------------------------
+  it('Should validate finite pattern 1', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([])
+    Assert.equal(Value.Check(T, ''), true)
+    Assert.equal(Value.Check(T, 'X'), false)
+  })
+  it('Should validate finite pattern 1', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([Type.Boolean()])
+    Assert.equal(Value.Check(T, 'true'), true)
+    Assert.equal(Value.Check(T, 'false'), true)
+    Assert.equal(Value.Check(T, 'X'), false)
+  })
+  it('Should validate finite pattern 2', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A')
+    ])
+    Assert.equal(Value.Check(T, 'A'), true)
+    Assert.equal(Value.Check(T, 'X'), false)
+  })
+  it('Should validate finite pattern 3', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Literal('B')
+    ])
+    Assert.equal(Value.Check(T, 'AB'), true)
+    Assert.equal(Value.Check(T, 'X'), false)
+  })
+  it('Should validate finite pattern 4', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Union([
+        Type.Literal('B'),
+        Type.Literal('C')
+      ]),
+    ])
+    Assert.equal(Value.Check(T, 'AB'), true)
+    Assert.equal(Value.Check(T, 'AC'), true)
+    Assert.equal(Value.Check(T, 'X'), false)
+  })
+  it('Should validate finite pattern 5', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Union([
+        Type.Literal('B'),
+        Type.Literal('C')
+      ]),
+      Type.Literal('D'),
+    ])
+    Assert.equal(Value.Check(T, 'ABD'), true)
+    Assert.equal(Value.Check(T, 'ACD'), true)
+    Assert.equal(Value.Check(T, 'X'), false)
+  })
+  it('Should validate finite pattern 6', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Union([
+        Type.Literal('0'),
+        Type.Literal('1')
+      ]),
+      Type.Union([
+        Type.Literal('0'),
+        Type.Literal('1')
+      ]),
+    ])
+    Assert.equal(Value.Check(T, '00'), true)
+    Assert.equal(Value.Check(T, '01'), true)
+    Assert.equal(Value.Check(T, '10'), true)
+    Assert.equal(Value.Check(T, '11'), true)
+    Assert.equal(Value.Check(T, 'X'), false)
+  })
+  // --------------------------------------------------------
+  // Infinite
+  // --------------------------------------------------------
+  it('Should validate infinite pattern 1', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Number()
+    ])
+    Assert.equal(Value.Check(T, '1'), true)
+    Assert.equal(Value.Check(T, '22'), true)
+    Assert.equal(Value.Check(T, '333'), true)
+    Assert.equal(Value.Check(T, '4444'), true)
+    Assert.equal(Value.Check(T, 'X'), false)
+  })
+  it('Should validate infinite pattern 2', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Integer()
+    ])
+    Assert.equal(Value.Check(T, '1'), true)
+    Assert.equal(Value.Check(T, '22'), true)
+    Assert.equal(Value.Check(T, '333'), true)
+    Assert.equal(Value.Check(T, '4444'), true)
+    Assert.equal(Value.Check(T, 'X'), false)
+  })
+  it('Should validate infinite pattern 3', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.BigInt()
+    ])
+    Assert.equal(Value.Check(T, '1'), true)
+    Assert.equal(Value.Check(T, '22'), true)
+    Assert.equal(Value.Check(T, '333'), true)
+    Assert.equal(Value.Check(T, '4444'), true)
+    Assert.equal(Value.Check(T, 'X'), false)
+  })
+  it('Should validate infinite pattern 4', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.String()
+    ])
+    Assert.equal(Value.Check(T, '1'), true)
+    Assert.equal(Value.Check(T, '22'), true)
+    Assert.equal(Value.Check(T, '333'), true)
+    Assert.equal(Value.Check(T, '4444'), true)
+    Assert.equal(Value.Check(T, 'a'), true)
+    Assert.equal(Value.Check(T, 'bb'), true)
+    Assert.equal(Value.Check(T, 'ccc'), true)
+    Assert.equal(Value.Check(T, 'dddd'), true)
+  })
+
+  it('Should validate infinite pattern 5', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Number()
+    ])
+    Assert.equal(Value.Check(T, 'A1'), true)
+    Assert.equal(Value.Check(T, 'A22'), true)
+    Assert.equal(Value.Check(T, 'A333'), true)
+    Assert.equal(Value.Check(T, 'A4444'), true)
+    Assert.equal(Value.Check(T, 'X'), false)
+  })
+  it('Should validate infinite pattern 6', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.Integer()
+    ])
+    Assert.equal(Value.Check(T, 'A1'), true)
+    Assert.equal(Value.Check(T, 'A22'), true)
+    Assert.equal(Value.Check(T, 'A333'), true)
+    Assert.equal(Value.Check(T, 'A4444'), true)
+    Assert.equal(Value.Check(T, 'X'), false)
+  })
+  it('Should validate infinite pattern 7', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.BigInt()
+    ])
+    Assert.equal(Value.Check(T, 'A1'), true)
+    Assert.equal(Value.Check(T, 'A22'), true)
+    Assert.equal(Value.Check(T, 'A333'), true)
+    Assert.equal(Value.Check(T, 'A4444'), true)
+    Assert.equal(Value.Check(T, 'X'), false)
+  })
+  it('Should validate infinite pattern 8', () => {
+    // prettier-ignore
+    const T = Type.TemplateLiteral([
+      Type.Literal('A'),
+      Type.String()
+    ])
+    Assert.equal(Value.Check(T, 'A1'), true)
+    Assert.equal(Value.Check(T, 'A22'), true)
+    Assert.equal(Value.Check(T, 'A333'), true)
+    Assert.equal(Value.Check(T, 'A4444'), true)
+    Assert.equal(Value.Check(T, 'Aa'), true)
+    Assert.equal(Value.Check(T, 'Abb'), true)
+    Assert.equal(Value.Check(T, 'Accc'), true)
+    Assert.equal(Value.Check(T, 'Adddd'), true)
+    Assert.equal(Value.Check(T, 'X'), false)
+  })
+})
diff --git a/test/runtime/value/create/index.ts b/test/runtime/value/create/index.ts
index fb947093e..26caee56d 100644
--- a/test/runtime/value/create/index.ts
+++ b/test/runtime/value/create/index.ts
@@ -22,6 +22,7 @@ import './record'
 import './regex'
 import './string'
 import './symbol'
+import './template-literal'
 import './tuple'
 import './uint8array'
 import './undefined'
diff --git a/test/runtime/value/create/recursive.ts b/test/runtime/value/create/recursive.ts
index 070169062..7f69c6b56 100644
--- a/test/runtime/value/create/recursive.ts
+++ b/test/runtime/value/create/recursive.ts
@@ -4,10 +4,10 @@ import { Assert } from '../../assert/index'
 
 describe('value/create/Recursive', () => {
   it('Should create value', () => {
-    const T = Type.Recursive((Self) =>
+    const T = Type.Recursive((This) =>
       Type.Object({
         id: Type.String(),
-        nodes: Type.Array(Self),
+        nodes: Type.Array(This),
       }),
     )
     Assert.deepEqual(Value.Create(T), {
@@ -18,10 +18,10 @@ describe('value/create/Recursive', () => {
 
   it('Should create default', () => {
     const T = Type.Recursive(
-      (Self) =>
+      (This) =>
         Type.Object({
           id: Type.String(),
-          nodes: Type.Array(Self),
+          nodes: Type.Array(This),
         }),
       { default: 7 },
     )
diff --git a/test/runtime/value/create/template-literal.ts b/test/runtime/value/create/template-literal.ts
new file mode 100644
index 000000000..4659b77f8
--- /dev/null
+++ b/test/runtime/value/create/template-literal.ts
@@ -0,0 +1,35 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/TemplateLiteral', () => {
+  it('Should create pattern 1', () => {
+    const T = Type.TemplateLiteral([Type.Literal('A')])
+    const V = Value.Create(T)
+    Assert.deepEqual(V, 'A')
+  })
+  it('Should create pattern 2', () => {
+    const T = Type.TemplateLiteral([Type.Literal('A'), Type.Literal('B')])
+    const V = Value.Create(T)
+    Assert.deepEqual(V, 'AB')
+  })
+  it('Should create pattern 3 (first only)', () => {
+    const T = Type.TemplateLiteral([Type.Literal('A'), Type.Union([Type.Literal('B'), Type.Literal('C')])])
+    const V = Value.Create(T)
+    Assert.deepEqual(V, 'AB')
+  })
+  it('Should create pattern 4 (first only)', () => {
+    const T = Type.TemplateLiteral([Type.Boolean()])
+    const V = Value.Create(T)
+    Assert.deepEqual(V, 'true')
+  })
+  it('Should throw on infinite pattern', () => {
+    const T = Type.TemplateLiteral([Type.Number()])
+    Assert.throws(() => Value.Create(T))
+  })
+  it('Should create on infinite pattern with default', () => {
+    const T = Type.TemplateLiteral([Type.Number()], { default: 42 })
+    const V = Value.Create(T)
+    Assert.deepEqual(V, 42)
+  })
+})
diff --git a/test/static/exclude.ts b/test/static/exclude.ts
index b0a76354c..526e7bc60 100644
--- a/test/static/exclude.ts
+++ b/test/static/exclude.ts
@@ -1,4 +1,4 @@
-import { Type } from '@sinclair/typebox'
+import { Type, TLiteral, TUnion } from '@sinclair/typebox'
 import { Expect } from './assert'
 
 {
@@ -13,3 +13,72 @@ import { Expect } from './assert'
   const T = Type.Exclude(Type.Union([Type.Number(), Type.String(), Type.Boolean()]), Type.Number())
   Expect(T).ToBe<boolean | string>()
 }
+// ------------------------------------------------------------------------
+// TemplateLiteral | TemplateLiteral
+// ------------------------------------------------------------------------
+{
+  const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+  const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+
+  const T = Type.Exclude(A, B)
+  Expect(T).ToBe<never>()
+}
+{
+  const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+  const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+
+  const T = Type.Exclude(A, B)
+  Expect(T).ToBe<'C'>()
+}
+{
+  const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+  const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
+  const T = Type.Exclude(A, B)
+  Expect(T).ToBe<'C' | 'B'>()
+}
+// ------------------------------------------------------------------------
+// TemplateLiteral | Union
+// ------------------------------------------------------------------------
+{
+  const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+  const B = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+
+  const T = Type.Exclude(A, B)
+  Expect(T).ToBe<never>()
+}
+{
+  const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+  const B = Type.Union([Type.Literal('A'), Type.Literal('B')])
+
+  const T = Type.Exclude(A, B)
+  Expect(T).ToBe<'C'>()
+}
+{
+  const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+  const B = Type.Union([Type.Literal('A')])
+  const T = Type.Exclude(A, B)
+  Expect(T).ToBe<'C' | 'B'>()
+}
+// ------------------------------------------------------------------------
+// Union | TemplateLiteral
+// ------------------------------------------------------------------------
+{
+  const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+  const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+
+  const T = Type.Exclude(A, B)
+  Expect(T).ToBe<never>()
+}
+{
+  const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+  const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+
+  const T = Type.Exclude(A, B)
+  Expect(T).ToBe<'C'>()
+}
+{
+  const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+  const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
+  const T = Type.Exclude(A, B)
+  Expect(T).ToBe<'C' | 'B'>()
+}
diff --git a/test/static/extract.ts b/test/static/extract.ts
index 7cc603709..9e4073836 100644
--- a/test/static/extract.ts
+++ b/test/static/extract.ts
@@ -1,4 +1,4 @@
-import { Type } from '@sinclair/typebox'
+import { Type, TLiteral, TUnion } from '@sinclair/typebox'
 import { Expect } from './assert'
 
 {
@@ -7,9 +7,77 @@ import { Expect } from './assert'
 }
 {
   const T = Type.Extract(Type.String(), Type.Number())
-  Expect(T).ToBe<never>()
+  Expect(T).ToBe<string>()
 }
 {
   const T = Type.Extract(Type.Union([Type.Number(), Type.String(), Type.Boolean()]), Type.Number())
   Expect(T).ToBe<number>()
 }
+// ------------------------------------------------------------------------
+// TemplateLiteral | TemplateLiteral
+// ------------------------------------------------------------------------
+{
+  const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+  const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+
+  const T = Type.Extract(A, B)
+  Expect(T).ToBe<'A' | 'B' | 'C'>()
+}
+{
+  const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+  const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+
+  const T = Type.Extract(A, B)
+  Expect(T).ToBe<'A' | 'B'>()
+}
+{
+  const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+  const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
+  const T = Type.Extract(A, B)
+  Expect(T).ToBe<'A'>()
+}
+// ------------------------------------------------------------------------
+// TemplateLiteral | Union
+// ------------------------------------------------------------------------
+{
+  const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+  const B = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+  const T = Type.Extract(A, B)
+  Expect(T).ToBe<'A' | 'B' | 'C'>()
+}
+{
+  const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+  const B = Type.Union([Type.Literal('A'), Type.Literal('B')])
+
+  const T = Type.Extract(A, B)
+  Expect(T).ToBe<'A' | 'B'>()
+}
+{
+  const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+  const B = Type.Union([Type.Literal('A')])
+  const T = Type.Extract(A, B)
+  Expect(T).ToBe<'A'>()
+}
+// ------------------------------------------------------------------------
+// Union | TemplateLiteral
+// ------------------------------------------------------------------------
+{
+  const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+  const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+
+  const T = Type.Extract(A, B)
+  Expect(T).ToBe<'A' | 'B' | 'C'>()
+}
+{
+  const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+  const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+
+  const T = Type.Extract(A, B)
+  Expect(T).ToBe<'A' | 'B'>()
+}
+{
+  const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+  const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
+  const T = Type.Extract(A, B)
+  Expect(T).ToBe<'A'>()
+}
diff --git a/test/static/index.ts b/test/static/index.ts
index 8666ca223..70f003457 100644
--- a/test/static/index.ts
+++ b/test/static/index.ts
@@ -37,6 +37,7 @@ import './return-type'
 import './strict'
 import './string'
 import './symbol'
+import './template-literal'
 import './tuple'
 import './union'
 import './unknown'
diff --git a/test/static/template-literal.ts b/test/static/template-literal.ts
new file mode 100644
index 000000000..c46d94af3
--- /dev/null
+++ b/test/static/template-literal.ts
@@ -0,0 +1,44 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+{
+  // Empty
+  const T = Type.TemplateLiteral([])
+  Expect(T).ToInfer<''>()
+}
+{
+  // Literal
+  const T = Type.TemplateLiteral([Type.Literal('hello')])
+  Expect(T).ToInfer<'hello'>()
+}
+{
+  // And Sequence
+  const T = Type.TemplateLiteral([Type.Literal('hello'), Type.Literal('world')])
+  Expect(T).ToInfer<'helloworld'>()
+}
+{
+  // And / Or Sequence
+  const T = Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal('1'), Type.Literal('2')])])
+  Expect(T).ToInfer<'hello1' | 'hello2'>()
+}
+{
+  // Auxiliary Template
+  const A = Type.TemplateLiteral([Type.Union([Type.Literal('1'), Type.Literal('2')])])
+  const T = Type.TemplateLiteral([Type.Literal('hello'), A])
+  Expect(T).ToInfer<'hello1' | 'hello2'>()
+}
+{
+  // String
+  const T = Type.TemplateLiteral([Type.String()])
+  Expect(T).ToInfer<`${string}`>()
+}
+{
+  // Number
+  const T = Type.TemplateLiteral([Type.Number()])
+  Expect(T).ToInfer<`${number}`>()
+}
+{
+  // Boolean
+  const T = Type.TemplateLiteral([Type.Boolean()])
+  Expect(T).ToInfer<`${boolean}`>()
+}

From cffaac6395120044d9839f093e5c6abe7faaec55 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sun, 9 Apr 2023 01:50:21 +0900
Subject: [PATCH 096/369] Workbench Compiler

---
 example/codegen/typescript-to-typebox.ts | 18 ++++++++++--------
 example/index.ts                         |  2 +-
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/example/codegen/typescript-to-typebox.ts b/example/codegen/typescript-to-typebox.ts
index 953f8a2be..7f69b2451 100644
--- a/example/codegen/typescript-to-typebox.ts
+++ b/example/codegen/typescript-to-typebox.ts
@@ -94,22 +94,24 @@ export namespace TypeScriptToTypeBox {
   // -------------------------------------------------------------------------
   // TemplateLiteral
   // -------------------------------------------------------------------------
+  // prettier-ignore
   function* TemplateLiteralTypeNode(node: ts.TemplateLiteralTypeNode) {
-    const collect = node.getChildren().map(node => Collect(node))
-    yield `Type.TemplateLiteral([${collect.join('')}])`
+    const collect = node.getChildren().map(node => Collect(node)).join('')
+    yield `Type.TemplateLiteral([${collect.slice(0, collect.length - 2)}])` // can't remove trailing here
   }
+  // prettier-ignore
   function* TemplateLiteralTypeSpan(node: ts.TemplateLiteralTypeSpan) {
-    const collect = node.getChildren().map(node => Collect(node))
-    yield collect.join(', ')
+    const collect = node.getChildren().map(node => Collect(node)).join(', ')
+    if(collect.length > 0) yield `${collect}`
   }
   function* TemplateHead(node: ts.TemplateHead) {
-    yield `Type.Literal('${node.text}'), `
+    if (node.text.length > 0) yield `Type.Literal('${node.text}'), `
   }
   function* TemplateMiddle(node: ts.TemplateMiddle) {
-    yield `Type.Literal('${node.text}'), `
+    if (node.text.length > 0) yield `Type.Literal('${node.text}'), `
   }
   function* TemplateTail(node: ts.TemplateTail) {
-    yield `Type.Literal('${node.text}')`
+    if (node.text.length > 0) yield `Type.Literal('${node.text}'), `
   }
   function* IntersectionTypeNode(node: ts.IntersectionTypeNode): IterableIterator<string> {
     const types = node.types.map((type) => Collect(type)).join(',\n')
@@ -378,4 +380,4 @@ export namespace TypeScriptToTypeBox {
     const types = Formatter.Format(typeDeclarations)
     return [imports, '', types].join('\n')
   }
-}
\ No newline at end of file
+}
diff --git a/example/index.ts b/example/index.ts
index c5ad5a144..ed52156bd 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -37,4 +37,4 @@ console.log(C.Code())
 // Check: Value
 // -----------------------------------------------------------
 
-console.log(C.Check(V))
\ No newline at end of file
+console.log(C.Check(V))

From 5454181f142483227b0046c845688951aeb2fb98 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 10 Apr 2023 20:19:30 +0900
Subject: [PATCH 097/369] Revision 0.27.1 (#372)

---
 changelog/0.27.1.md                 |   5 ++
 package-lock.json                   |   4 +-
 package.json                        |   2 +-
 readme.md                           |  34 ++++++++-
 src/value/index.ts                  |   1 +
 src/value/mutate.ts                 | 110 ++++++++++++++++++++++++++++
 src/value/value.ts                  |   5 ++
 test/runtime/assert/assert.ts       |  10 +--
 test/runtime/value/index.ts         |   1 +
 test/runtime/value/mutate/index.ts  |   1 +
 test/runtime/value/mutate/mutate.ts |  88 ++++++++++++++++++++++
 11 files changed, 245 insertions(+), 16 deletions(-)
 create mode 100644 changelog/0.27.1.md
 create mode 100644 src/value/mutate.ts
 create mode 100644 test/runtime/value/mutate/index.ts
 create mode 100644 test/runtime/value/mutate/mutate.ts

diff --git a/changelog/0.27.1.md b/changelog/0.27.1.md
new file mode 100644
index 000000000..016f05ced
--- /dev/null
+++ b/changelog/0.27.1.md
@@ -0,0 +1,5 @@
+## [0.27.1](https://www.npmjs.com/package/@sinclair/typebox/v/0.27.1)
+
+## Updates
+
+- Adds a `Value.Mutate(current, next): void` function. This function performs a deep mutable assignment on a value by internally remapping the `next(right)` values on the `current(left)`. Values omitted on the right will also be deleted on the left. This function can be useful instances where mutation of data is required without modification to existing references. An example of which might be React which tracks reference values to signal redraws. This function is implemented by way of `ValuePointer`.
diff --git a/package-lock.json b/package-lock.json
index 64dbe8148..23096db77 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.0",
+  "version": "0.27.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.27.0",
+      "version": "0.27.1",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 6b792d3e1..546a220e9 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.0",
+  "version": "0.27.1",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index b5cb73687..a5a76d424 100644
--- a/readme.md
+++ b/readme.md
@@ -96,6 +96,7 @@ License MIT
   - [Diff](#values-diff)
   - [Patch](#values-patch)
   - [Errors](#values-errors)
+  - [Mutate](#values-mutate)
   - [Pointer](#values-pointer)
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
@@ -1053,7 +1054,6 @@ const E = Value.Diff(A, B)                           // const E = [
 const C = Value.Patch<typeof B>(A, E)                // const C = { x: 3 }
 ```
 
-
 <a name='values-errors'></a>
 
 ### Errors
@@ -1076,6 +1076,29 @@ const R = [...Value.Errors(T, { x: '42' })]          // const R = [{
                                                      // }]
 ```
 
+<a name='values-mutate'></a>
+
+### Mutate
+
+Use the Mutate function to perform a deep mutable value assignment while retaining internal references.
+
+```typescript
+const Y = { z: 1 }                                   // const Y = { z: 1 } 
+
+const X = { y: Y }                                   // const X = { y: { z: 1 } }
+
+const A = { x: X }                                   // const A = { x: { y: { z: 1 } } }             
+
+
+Value.Mutate(A, { x: { y: { z: 2 } } })              // const A' = { x: { y: { z: 2 } } }   
+
+const R0 = A.x.y.z === 2                             // const R0 = 2
+
+const R1 = A.x.y === Y                               // const R1 = true
+
+const R2 = A.x === X                                 // const R2 = true
+```     
+
 <a name='values-pointer'></a>
 
 ### Pointer
@@ -1087,10 +1110,13 @@ import { ValuePointer } from '@sinclair/typebox/value'
 
 const A = { x: 0, y: 0, z: 0 }
 
-ValuePointer.Set(A, '/x', 1)                         // const A = { x: 1, y: 0, z: 0 }
-ValuePointer.Set(A, '/y', 1)                         // const A = { x: 1, y: 1, z: 0 }
-ValuePointer.Set(A, '/z', 1)                         // const A = { x: 1, y: 1, z: 1 }
+ValuePointer.Set(A, '/x', 1)                         // const A' = { x: 1, y: 0, z: 0 }
+
+ValuePointer.Set(A, '/y', 1)                         // const A' = { x: 1, y: 1, z: 0 }
+
+ValuePointer.Set(A, '/z', 1)                         // const A' = { x: 1, y: 1, z: 1 }
 ```
+
 <a name='typecheck'></a>
 
 ## TypeCheck
diff --git a/src/value/index.ts b/src/value/index.ts
index 5598e30ab..a2235b01f 100644
--- a/src/value/index.ts
+++ b/src/value/index.ts
@@ -29,5 +29,6 @@ THE SOFTWARE.
 export { ValueError, ValueErrorIterator, ValueErrorType } from '../errors/index'
 export { ValueHash } from './hash'
 export { Edit, Insert, Update, Delete } from './delta'
+export { Mutable } from './mutate'
 export * from './pointer'
 export * from './value'
diff --git a/src/value/mutate.ts b/src/value/mutate.ts
new file mode 100644
index 000000000..44d11a6e7
--- /dev/null
+++ b/src/value/mutate.ts
@@ -0,0 +1,110 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Is, TypedArrayType } from './is'
+import { ValuePointer } from './pointer'
+import { ValueClone } from './clone'
+
+export class ValueMutateTypeMismatchError extends Error {
+  constructor() {
+    super('ValueMutate: Cannot assign due type mismatch of assignable values')
+  }
+}
+export class ValueMutateInvalidRootMutationError extends Error {
+  constructor() {
+    super('ValueMutate: Only object and array types can be mutated at the root level')
+  }
+}
+export type Mutable = { [key: string]: unknown } | unknown[]
+export namespace ValueMutate {
+  function Object(root: Mutable, path: string, current: unknown, next: Record<string, unknown>) {
+    if (!Is.Object(current)) {
+      ValuePointer.Set(root, path, ValueClone.Clone(next))
+    } else {
+      const currentKeys = globalThis.Object.keys(current)
+      const nextKeys = globalThis.Object.keys(next)
+      for (const currentKey of currentKeys) {
+        if (!nextKeys.includes(currentKey)) {
+          delete current[currentKey]
+        }
+      }
+      for (const nextKey of nextKeys) {
+        if (!currentKeys.includes(nextKey)) {
+          current[nextKey] = null
+        }
+      }
+      for (const nextKey of nextKeys) {
+        Visit(root, `${path}/${nextKey}`, current[nextKey], next[nextKey])
+      }
+    }
+  }
+  function Array(root: Mutable, path: string, current: unknown, next: unknown[]) {
+    if (!Is.Array(current)) {
+      ValuePointer.Set(root, path, ValueClone.Clone(next))
+    } else {
+      for (let index = 0; index < next.length; index++) {
+        Visit(root, `${path}/${index}`, current[index], next[index])
+      }
+      current.splice(next.length)
+    }
+  }
+  function TypedArray(root: Mutable, path: string, current: unknown, next: TypedArrayType) {
+    if (Is.TypedArray(current) && current.length === next.length) {
+      for (let i = 0; i < current.length; i++) {
+        current[i] = next[i]
+      }
+    } else {
+      ValuePointer.Set(root, path, ValueClone.Clone(next))
+    }
+  }
+  function Value(root: Mutable, path: string, current: unknown, next: unknown) {
+    if (current === next) return
+    ValuePointer.Set(root, path, next)
+  }
+  function Visit(root: Mutable, path: string, current: unknown, next: unknown) {
+    if (Is.Array(next)) {
+      return Array(root, path, current, next)
+    } else if (Is.TypedArray(next)) {
+      return TypedArray(root, path, current, next)
+    } else if (Is.Object(next)) {
+      return Object(root, path, current, next)
+    } else if (Is.Value(next)) {
+      return Value(root, path, current, next)
+    }
+  }
+  /** Performs a deep mutable value assignment while retaining internal references. */
+  export function Mutate(current: Mutable, next: Mutable): void {
+    if (Is.TypedArray(current) || Is.Value(current) || Is.TypedArray(next) || Is.Value(next)) {
+      throw new ValueMutateInvalidRootMutationError()
+    }
+    if ((Is.Object(current) && Is.Array(next)) || (Is.Array(current) && Is.Object(next))) {
+      throw new ValueMutateTypeMismatchError()
+    }
+    Visit(current, '', current, next)
+  }
+}
diff --git a/src/value/value.ts b/src/value/value.ts
index b76700865..ed9335d28 100644
--- a/src/value/value.ts
+++ b/src/value/value.ts
@@ -28,6 +28,7 @@ THE SOFTWARE.
 
 import * as Types from '../typebox'
 import { ValueErrors, ValueErrorIterator, ValueError } from '../errors/index'
+import { ValueMutate, Mutable } from './mutate'
 import { ValueHash } from './hash'
 import { ValueEqual } from './equal'
 import { ValueCast } from './cast'
@@ -99,4 +100,8 @@ export namespace Value {
   export function Patch<T = any>(current: unknown, edits: Edit[]): T {
     return ValueDelta.Patch(current, edits) as T
   }
+  /** Performs a deep mutable value assignment while retaining internal references. */
+  export function Mutate(current: Mutable, next: Mutable): void {
+    ValueMutate.Mutate(current, next)
+  }
 }
diff --git a/test/runtime/assert/assert.ts b/test/runtime/assert/assert.ts
index 19543636d..d632824b4 100644
--- a/test/runtime/assert/assert.ts
+++ b/test/runtime/assert/assert.ts
@@ -7,15 +7,12 @@ export namespace Assert {
     const next = port++
     return next
   }
-
   export function equal(actual: unknown, expect: unknown) {
-    return assert.equal(actual, expect)
+    return assert.strictEqual(actual, expect)
   }
-
   export function notEqual(actual: unknown, expect: unknown) {
     return assert.notEqual(actual, expect)
   }
-
   export function deepEqual(actual: unknown, expect: unknown) {
     if (actual instanceof Uint8Array && expect instanceof Uint8Array) {
       assert.equal(actual.length, expect.length)
@@ -23,12 +20,10 @@ export namespace Assert {
     }
     return assert.deepEqual(actual, expect)
   }
-
   let nextIdOrdinal = 0
   export function nextId() {
     return `nextID${nextIdOrdinal++}`
   }
-
   export function throws(callback: Function) {
     try {
       callback()
@@ -37,7 +32,6 @@ export namespace Assert {
     }
     throw Error('Expected throw')
   }
-
   export async function throwsAsync(callback: Function) {
     try {
       await callback()
@@ -46,12 +40,10 @@ export namespace Assert {
     }
     throw Error('Expected throw')
   }
-
   export function isTypeOf(value: any, type: any) {
     if (typeof value === type) return
     throw Error(`Value is not typeof ${type}`)
   }
-
   export function isInstanceOf(value: any, constructor: any) {
     if (value instanceof constructor) return
     throw Error(`Value is not instance of ${constructor}`)
diff --git a/test/runtime/value/index.ts b/test/runtime/value/index.ts
index ad07f09f0..57403d7b8 100644
--- a/test/runtime/value/index.ts
+++ b/test/runtime/value/index.ts
@@ -6,4 +6,5 @@ import './create'
 import './delta'
 import './equal'
 import './hash'
+import './mutate'
 import './pointer'
diff --git a/test/runtime/value/mutate/index.ts b/test/runtime/value/mutate/index.ts
new file mode 100644
index 000000000..d37705ce3
--- /dev/null
+++ b/test/runtime/value/mutate/index.ts
@@ -0,0 +1 @@
+import './mutate'
\ No newline at end of file
diff --git a/test/runtime/value/mutate/mutate.ts b/test/runtime/value/mutate/mutate.ts
new file mode 100644
index 000000000..bffdf8298
--- /dev/null
+++ b/test/runtime/value/mutate/mutate.ts
@@ -0,0 +1,88 @@
+import { Value } from '@sinclair/typebox/value'
+import { Assert } from '../../assert/index'
+
+describe('value/mutate/Mutate', () => {
+  // --------------------------------------------
+  // Throw
+  // --------------------------------------------
+  it('should throw 1', () => {
+    // @ts-ignore
+    Assert.throws(() => Value.Mutate(1, 1))
+  })
+  it('should throw 2', () => {
+    // @ts-ignore
+    Assert.throws(() => Value.Mutate({}, 1))
+  })
+  it('should throw 3', () => {
+    // @ts-ignore
+    Assert.throws(() => Value.Mutate([], 1))
+  })
+  it('should throw 4', () => {
+    // @ts-ignore
+    Assert.throws(() => Value.Mutate({}, []))
+  })
+  it('should throw 5', () => {
+    // @ts-ignore
+    Assert.throws(() => Value.Mutate([], {}))
+  })
+  // --------------------------------------------
+  // Mutate
+  // --------------------------------------------
+  it('Should mutate 0', () => {
+    const Y = { z: 1 } 
+    const X = { y: Y }
+    const A = { x: X } 
+    Value.Mutate(A, {})
+    Assert.deepEqual(A, {})
+  })
+  it('Should mutate 1', () => {
+    const Y = { z: 1 } 
+    const X = { y: Y }
+    const A = { x: X } 
+    Value.Mutate(A, { x: { y: { z: 2 } } })
+    Assert.equal(A.x.y.z, 2)
+    Assert.equal(A.x.y, Y)
+    Assert.equal(A.x, X)
+  })
+  it('Should mutate 2', () => {
+    const Y = { z: 1 } 
+    const X = { y: Y }
+    const A = { x: X } 
+    Value.Mutate(A, { x: { y: { z: [1, 2, 3] } } })
+    Assert.deepEqual(A.x.y.z, [1, 2, 3])
+    Assert.equal(A.x.y, Y)
+    Assert.equal(A.x, X)
+  })
+  it('Should mutate 3', () => {
+    const Y = { z: 1 } 
+    const X = { y: Y }
+    const A = { x: X } 
+    Value.Mutate(A, { x: {} })
+    Assert.equal(A.x.y, undefined)
+    Assert.equal(A.x, X)
+  })
+  it('Should mutate 4', () => {
+    const Y = { z: 1 } 
+    const X = { y: Y }
+    const A = { x: X } 
+    Value.Mutate(A, { x: { y: 1 } })
+    Assert.equal(A.x.y, 1)
+    Assert.equal(A.x, X)
+  })
+  it('Should mutate 5', () => {
+    const Y = { z: 1 } 
+    const X = { y: Y }
+    const A = { x: X } 
+    Value.Mutate(A, { x: { y: [1, 2, 3] } })
+    Assert.deepEqual(A.x.y, [1, 2, 3])
+    Assert.equal(A.x, X)
+  })
+  it('Should mutate 6', () => {
+    const Y = { z: 1 } 
+    const X = { y: Y }
+    const A = { x: X } 
+    Value.Mutate(A, { x: [1, 2, 3] })
+    Assert.notEqual(A.x, X)
+    Assert.deepEqual(A.x, [1, 2, 3])
+  })
+})

From 691c24b845a749b46734724a44e79c8b251e37e1 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Mon, 10 Apr 2023 20:27:53 +0900
Subject: [PATCH 098/369] Revision 0.27.1

---
 changelog/0.27.1.md                 |  2 +-
 test/runtime/value/mutate/index.ts  |  2 +-
 test/runtime/value/mutate/mutate.ts | 28 ++++++++++++++--------------
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/changelog/0.27.1.md b/changelog/0.27.1.md
index 016f05ced..eba9126bd 100644
--- a/changelog/0.27.1.md
+++ b/changelog/0.27.1.md
@@ -2,4 +2,4 @@
 
 ## Updates
 
-- Adds a `Value.Mutate(current, next): void` function. This function performs a deep mutable assignment on a value by internally remapping the `next(right)` values on the `current(left)`. Values omitted on the right will also be deleted on the left. This function can be useful instances where mutation of data is required without modification to existing references. An example of which might be React which tracks reference values to signal redraws. This function is implemented by way of `ValuePointer`.
+- Adds a `Value.Mutate(left, right)` function. This function performs a deep mutable assignment on a value by internally remapping the `right` values on the `left`. Values omitted on the right will also be deleted on the left. This function can be useful scenarios where mutation of data is required without replacing existing reference values. An example of which might be React which tracks reference values to indicate redraw. This function is implemented by way of `ValuePointer`.
diff --git a/test/runtime/value/mutate/index.ts b/test/runtime/value/mutate/index.ts
index d37705ce3..28e30125c 100644
--- a/test/runtime/value/mutate/index.ts
+++ b/test/runtime/value/mutate/index.ts
@@ -1 +1 @@
-import './mutate'
\ No newline at end of file
+import './mutate'
diff --git a/test/runtime/value/mutate/mutate.ts b/test/runtime/value/mutate/mutate.ts
index bffdf8298..1c4d81ef1 100644
--- a/test/runtime/value/mutate/mutate.ts
+++ b/test/runtime/value/mutate/mutate.ts
@@ -29,58 +29,58 @@ describe('value/mutate/Mutate', () => {
   // Mutate
   // --------------------------------------------
   it('Should mutate 0', () => {
-    const Y = { z: 1 } 
+    const Y = { z: 1 }
     const X = { y: Y }
-    const A = { x: X } 
+    const A = { x: X }
     Value.Mutate(A, {})
     Assert.deepEqual(A, {})
   })
   it('Should mutate 1', () => {
-    const Y = { z: 1 } 
+    const Y = { z: 1 }
     const X = { y: Y }
-    const A = { x: X } 
+    const A = { x: X }
     Value.Mutate(A, { x: { y: { z: 2 } } })
     Assert.equal(A.x.y.z, 2)
     Assert.equal(A.x.y, Y)
     Assert.equal(A.x, X)
   })
   it('Should mutate 2', () => {
-    const Y = { z: 1 } 
+    const Y = { z: 1 }
     const X = { y: Y }
-    const A = { x: X } 
+    const A = { x: X }
     Value.Mutate(A, { x: { y: { z: [1, 2, 3] } } })
     Assert.deepEqual(A.x.y.z, [1, 2, 3])
     Assert.equal(A.x.y, Y)
     Assert.equal(A.x, X)
   })
   it('Should mutate 3', () => {
-    const Y = { z: 1 } 
+    const Y = { z: 1 }
     const X = { y: Y }
-    const A = { x: X } 
+    const A = { x: X }
     Value.Mutate(A, { x: {} })
     Assert.equal(A.x.y, undefined)
     Assert.equal(A.x, X)
   })
   it('Should mutate 4', () => {
-    const Y = { z: 1 } 
+    const Y = { z: 1 }
     const X = { y: Y }
-    const A = { x: X } 
+    const A = { x: X }
     Value.Mutate(A, { x: { y: 1 } })
     Assert.equal(A.x.y, 1)
     Assert.equal(A.x, X)
   })
   it('Should mutate 5', () => {
-    const Y = { z: 1 } 
+    const Y = { z: 1 }
     const X = { y: Y }
-    const A = { x: X } 
+    const A = { x: X }
     Value.Mutate(A, { x: { y: [1, 2, 3] } })
     Assert.deepEqual(A.x.y, [1, 2, 3])
     Assert.equal(A.x, X)
   })
   it('Should mutate 6', () => {
-    const Y = { z: 1 } 
+    const Y = { z: 1 }
     const X = { y: Y }
-    const A = { x: X } 
+    const A = { x: X }
     Value.Mutate(A, { x: [1, 2, 3] })
     Assert.notEqual(A.x, X)
     Assert.deepEqual(A.x, [1, 2, 3])

From 39fccd596ebff1e75500f91eba60e1b16942ce2a Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 11 Apr 2023 06:36:05 +0900
Subject: [PATCH 099/369] Union Error Emit Order (#375)

---
 package-lock.json    | 4 ++--
 package.json         | 2 +-
 src/errors/errors.ts | 6 +++---
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 23096db77..3729af7b3 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.1",
+  "version": "0.27.2",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.27.1",
+      "version": "0.27.2",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 546a220e9..d1183832e 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.1",
+  "version": "0.27.2",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 1d8d7615e..be83707c9 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -490,12 +490,12 @@ export namespace ValueErrors {
       if (variantErrors.length === 0) return
       errors.push(...variantErrors)
     }
-    for (const error of errors) {
-      yield error
-    }
     if (errors.length > 0) {
       yield { type: ValueErrorType.Union, schema, path, value, message: 'Expected value of union' }
     }
+    for (const error of errors) {
+      yield error
+    }
   }
   function* Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!(value instanceof globalThis.Uint8Array)) {

From e1b923cdbafe5d408bb738fec0ce7f9749c9f034 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 11 Apr 2023 14:41:51 +0900
Subject: [PATCH 100/369] Record Option Overloads (#377)

---
 package-lock.json                 |  4 +--
 package.json                      |  2 +-
 src/typebox.ts                    | 10 +++---
 test/runtime/type/guard/record.ts | 57 ++++++++++++++++++++++++++++++-
 4 files changed, 64 insertions(+), 9 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 3729af7b3..74cb8e749 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.2",
+  "version": "0.27.3",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.27.2",
+      "version": "0.27.3",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index d1183832e..3d670d213 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.2",
+  "version": "0.27.3",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index a25d5b0d2..997128ace 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -2365,15 +2365,15 @@ export class StandardTypeBuilder extends TypeBuilder {
     }, options)
   }
   /** `[Standard]` Creates a Record type */
-  public Record<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema>(key: K, schema: T): RecordUnionLiteralType<K, T>
+  public Record<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordUnionLiteralType<K, T>
   /** `[Standard]` Creates a Record type */
-  public Record<K extends TLiteral<string | number>, T extends TSchema>(key: K, schema: T): RecordLiteralType<K, T>
+  public Record<K extends TLiteral<string | number>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordLiteralType<K, T>
   /** `[Standard]` Creates a Record type */
-  public Record<K extends TTemplateLiteral, T extends TSchema>(key: K, schema: T): RecordTemplateLiteralType<K, T>
+  public Record<K extends TTemplateLiteral, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordTemplateLiteralType<K, T>
   /** `[Standard]` Creates a Record type */
-  public Record<K extends TInteger | TNumber, T extends TSchema>(key: K, schema: T): RecordNumberType<K, T>
+  public Record<K extends TInteger | TNumber, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordNumberType<K, T>
   /** `[Standard]` Creates a Record type */
-  public Record<K extends TString, T extends TSchema>(key: K, schema: T): RecordStringType<K, T>
+  public Record<K extends TString, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordStringType<K, T>
   /** `[Standard]` Creates a Record type */
   public Record(key: RecordKey, schema: TSchema, options: ObjectOptions = {}) {
     if (TypeGuard.TTemplateLiteral(key)) {
diff --git a/test/runtime/type/guard/record.ts b/test/runtime/type/guard/record.ts
index 2418c0e3d..45ebcb41e 100644
--- a/test/runtime/type/guard/record.ts
+++ b/test/runtime/type/guard/record.ts
@@ -1,8 +1,63 @@
-import { TypeGuard } from '@sinclair/typebox'
+import { TypeGuard, PatternNumberExact, PatternStringExact, PatternNumber } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/TRecord', () => {
+  // -------------------------------------------------------------
+  // Overloads
+  // -------------------------------------------------------------
+  it('Should guard overload 1', () => {
+    const T = Type.Record(Type.Union([Type.Literal('A'), Type.Literal('B')]), Type.String(), { extra: 1 })
+    Assert.equal(TypeGuard.TObject(T), true)
+    Assert.equal(TypeGuard.TString(T.properties.A), true)
+    Assert.equal(TypeGuard.TString(T.properties.B), true)
+    Assert.equal(T.extra, 1)
+  })
+  it('Should guard overload 2', () => {
+    const T = Type.Record(Type.Union([Type.Literal('A')]), Type.String(), { extra: 1 }) // unwrap as literal
+    Assert.equal(TypeGuard.TObject(T), true)
+    Assert.equal(TypeGuard.TString(T.properties.A), true)
+    Assert.equal(T.extra, 1)
+  })
+  it('Should guard overload 3', () => {
+    // @ts-ignore
+    Assert.throws(() => Type.Record(Type.Union([]), Type.String(), { extra: 1 }))
+  })
+  it('Should guard overload 4', () => {
+    const T = Type.Record(Type.Literal('A'), Type.String(), { extra: 1 })
+    Assert.equal(TypeGuard.TObject(T), true)
+    Assert.equal(TypeGuard.TString(T.properties.A), true)
+    Assert.equal(T.extra, 1)
+  })
+  it('Should guard overload 5', () => {
+    const L = Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal('A'), Type.Literal('B')])])
+    const T = Type.Record(L, Type.String(), { extra: 1 })
+    Assert.equal(TypeGuard.TObject(T), true)
+    Assert.equal(TypeGuard.TString(T.properties.helloA), true)
+    Assert.equal(TypeGuard.TString(T.properties.helloB), true)
+    Assert.equal(T.extra, 1)
+  })
+  it('Should guard overload 6', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { extra: 1 })
+    Assert.equal(TypeGuard.TRecord(T), true)
+    Assert.equal(TypeGuard.TString(T.patternProperties[PatternNumberExact]), true)
+    Assert.equal(T.extra, 1)
+  })
+  it('Should guard overload 7', () => {
+    const T = Type.Record(Type.Integer(), Type.String(), { extra: 1 })
+    Assert.equal(TypeGuard.TRecord(T), true)
+    Assert.equal(TypeGuard.TString(T.patternProperties[PatternNumberExact]), true)
+    Assert.equal(T.extra, 1)
+  })
+  it('Should guard overload 8', () => {
+    const T = Type.Record(Type.String(), Type.String(), { extra: 1 })
+    Assert.equal(TypeGuard.TRecord(T), true)
+    Assert.equal(TypeGuard.TString(T.patternProperties[PatternStringExact]), true)
+    Assert.equal(T.extra, 1)
+  })
+  // -------------------------------------------------------------
+  // Variants
+  // -------------------------------------------------------------
   it('Should guard for TRecord', () => {
     const R = TypeGuard.TRecord(Type.Record(Type.String(), Type.Number()))
     Assert.equal(R, true)

From d8effff195311fde88f972d6e1abfc71640f8e36 Mon Sep 17 00:00:00 2001
From: Mauro <35332423+m-ronchi@users.noreply.github.com>
Date: Wed, 12 Apr 2023 14:48:17 +0200
Subject: [PATCH 101/369] Compiler Character Check Fix (#378)

---
 src/compiler/compiler.ts        | 2 +-
 test/runtime/compiler/object.ts | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 03d27ffeb..5d80435ff 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -64,7 +64,7 @@ namespace Character {
     return code === 95
   }
   export function IsAlpha(code: number) {
-    return (code >= 64 && code <= 90) || (code >= 97 && code <= 122)
+    return (code >= 65 && code <= 90) || (code >= 97 && code <= 122)
   }
   export function IsNumeric(code: number) {
     return code >= 48 && code <= 57
diff --git a/test/runtime/compiler/object.ts b/test/runtime/compiler/object.ts
index b45f9a8b6..94897ec63 100644
--- a/test/runtime/compiler/object.ts
+++ b/test/runtime/compiler/object.ts
@@ -136,6 +136,7 @@ describe('type/compiler/Object', () => {
       'node-mirror:release:1': Type.Optional(Type.Literal(6)), // issue: 356
       'node-mirror:release:2': Type.Union([Type.Literal(7), Type.Undefined()]), // key known
       "a'a": Type.Literal(8),
+      "@onlyAtSymbol": Type.Literal(9)
     })
     Ok(T, {
       'with-hyphen': 1,
@@ -146,6 +147,7 @@ describe('type/compiler/Object', () => {
       'node-mirror:release:1': 6,
       'node-mirror:release:2': 7,
       "a'a": 8,
+      "@onlyAtSymbol": 9
     })
   })
   it('Should validate schema additional properties of string', () => {

From d4e6760eb301d22c236826235221a5ea49af8b54 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 12 Apr 2023 21:50:15 +0900
Subject: [PATCH 102/369] Revision 0.27.4

---
 package-lock.json               | 4 ++--
 package.json                    | 2 +-
 test/runtime/compiler/object.ts | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 74cb8e749..40c670b34 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.3",
+  "version": "0.27.4",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.27.3",
+      "version": "0.27.4",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 3d670d213..cf0937f20 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.3",
+  "version": "0.27.4",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/test/runtime/compiler/object.ts b/test/runtime/compiler/object.ts
index 94897ec63..187207b3c 100644
--- a/test/runtime/compiler/object.ts
+++ b/test/runtime/compiler/object.ts
@@ -136,7 +136,7 @@ describe('type/compiler/Object', () => {
       'node-mirror:release:1': Type.Optional(Type.Literal(6)), // issue: 356
       'node-mirror:release:2': Type.Union([Type.Literal(7), Type.Undefined()]), // key known
       "a'a": Type.Literal(8),
-      "@onlyAtSymbol": Type.Literal(9)
+      '@onlyAtSymbol': Type.Literal(9),
     })
     Ok(T, {
       'with-hyphen': 1,
@@ -147,7 +147,7 @@ describe('type/compiler/Object', () => {
       'node-mirror:release:1': 6,
       'node-mirror:release:2': 7,
       "a'a": 8,
-      "@onlyAtSymbol": 9
+      '@onlyAtSymbol': 9,
     })
   })
   it('Should validate schema additional properties of string', () => {

From 7462636ade246ab3c18e9b31ece90bb2e024e634 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Vod=C3=A1=C4=8Dek?=
 <voda@users.noreply.github.com>
Date: Thu, 13 Apr 2023 15:17:39 +0200
Subject: [PATCH 103/369] Documentation (#379)

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index a5a76d424..6c6e443cd 100644
--- a/readme.md
+++ b/readme.md
@@ -101,7 +101,7 @@ License MIT
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
   - [TypeCompiler](#typecheck-typecompiler)
-- [TypeSystem](#typecheck)
+- [TypeSystem](#typesystem)
   - [Types](#typesystem-types)
   - [Formats](#typesystem-formats)
   - [Policies](#typesystem-policies)

From ae503c5549a11ab81b9b5168cff65ac0f6d3116a Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 14 Apr 2023 10:56:47 +0900
Subject: [PATCH 104/369] Template Literal Finite Checks (#381)

---
 package-lock.json                      |  4 ++--
 package.json                           |  2 +-
 src/typebox.ts                         | 29 +++++++++++++++++++-------
 test/runtime/type/guard/record.ts      | 14 +++++++------
 test/runtime/type/template/finite.ts   | 10 +++++++++
 test/runtime/type/template/generate.ts |  6 +++---
 test/runtime/type/template/parser.ts   |  6 +++---
 test/runtime/type/template/pattern.ts  | 19 +++++++++++++++++
 8 files changed, 67 insertions(+), 23 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 40c670b34..7c2f3e507 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.4",
+  "version": "0.27.5",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.27.4",
+      "version": "0.27.5",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index cf0937f20..ca02865f9 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.4",
+  "version": "0.27.5",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 997128ace..564399508 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -37,7 +37,7 @@ export const Kind = Symbol.for('TypeBox.Kind')
 // --------------------------------------------------------------------------
 export const PatternBoolean = '(true|false)'
 export const PatternNumber = '(0|[1-9][0-9]*)'
-export const PatternString = '.*'
+export const PatternString = '(.*)'
 export const PatternBooleanExact = `^${PatternBoolean}$`
 export const PatternNumberExact = `^${PatternNumber}$`
 export const PatternStringExact = `^${PatternString}$`
@@ -456,7 +456,7 @@ export interface TPromise<T extends TSchema = TSchema> extends TSchema {
 // TRecord
 // --------------------------------------------------------------------------
 export type RecordTemplateLiteralObjectType<K extends TTemplateLiteral, T extends TSchema> = Ensure<TObject<Evaluate<{ [_ in Static<K>]: T }>>>
-export type RecordTemplateLiteralType<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends true ? RecordTemplateLiteralObjectType<K, T> : TRecord<TString, T>
+export type RecordTemplateLiteralType<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends true ? RecordTemplateLiteralObjectType<K, T> : TRecord<K, T>
 export type RecordUnionLiteralType<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema> = Static<K> extends string ? Ensure<TObject<{ [X in Static<K>]: T }>> : never
 export type RecordLiteralType<K extends TLiteral<string | number>, T extends TSchema> = Ensure<TObject<{ [K2 in K['const']]: T }>>
 export type RecordNumberType<K extends TInteger | TNumber, T extends TSchema> = Ensure<TRecord<K, T>>
@@ -1937,9 +1937,6 @@ export namespace TemplateLiteralParser {
   export type Const = { type: 'const'; const: string }
   export type And = { type: 'and'; expr: Expression[] }
   export type Or = { type: 'or'; expr: Expression[] }
-  function Unescape(value: string) {
-    return value.replace(/\\/g, '')
-  }
   function IsNonEscaped(pattern: string, index: number, char: string) {
     return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92
   }
@@ -2038,7 +2035,7 @@ export namespace TemplateLiteralParser {
     if (IsGroup(pattern)) return Parse(InGroup(pattern))
     if (IsPrecedenceOr(pattern)) return Or(pattern)
     if (IsPrecedenceAnd(pattern)) return And(pattern)
-    return { type: 'const', const: Unescape(pattern) }
+    return { type: 'const', const: pattern }
   }
   /** Parses a pattern and strips forward and trailing ^ and $ */
   export function ParseExact(pattern: string): Expression {
@@ -2050,10 +2047,26 @@ export namespace TemplateLiteralParser {
 // --------------------------------------------------------------------------------------
 export namespace TemplateLiteralFinite {
   function IsNumber(expression: TemplateLiteralParser.Expression): boolean {
-    return expression.type === 'or' && expression.expr.length === 2 && expression.expr[0].type === 'const' && expression.expr[0].const === '0' && expression.expr[1].type === 'const' && expression.expr[1].const === '[1-9][0-9]*'
+    // prettier-ignore
+    return (
+      expression.type === 'or' && 
+      expression.expr.length === 2 && 
+      expression.expr[0].type === 'const' && 
+      expression.expr[0].const === '0' && 
+      expression.expr[1].type === 'const' && 
+      expression.expr[1].const === '[1-9][0-9]*'
+    )
   }
   function IsBoolean(expression: TemplateLiteralParser.Expression): boolean {
-    return expression.type === 'or' && expression.expr.length === 2 && expression.expr[0].type === 'const' && expression.expr[0].const === 'true' && expression.expr[1].type === 'const' && expression.expr[1].const === 'false'
+    // prettier-ignore
+    return (
+      expression.type === 'or' && 
+      expression.expr.length === 2 && 
+      expression.expr[0].type === 'const' && 
+      expression.expr[0].const === 'true' && 
+      expression.expr[1].type === 'const' && 
+      expression.expr[1].const === 'false'
+    )
   }
   function IsString(expression: TemplateLiteralParser.Expression) {
     return expression.type === 'const' && expression.const === '.*'
diff --git a/test/runtime/type/guard/record.ts b/test/runtime/type/guard/record.ts
index 45ebcb41e..f43a70a1a 100644
--- a/test/runtime/type/guard/record.ts
+++ b/test/runtime/type/guard/record.ts
@@ -1,4 +1,4 @@
-import { TypeGuard, PatternNumberExact, PatternStringExact, PatternNumber } from '@sinclair/typebox'
+import { TypeGuard, PatternNumberExact, PatternStringExact, PatternString, PatternNumber } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
@@ -55,6 +55,13 @@ describe('type/guard/TRecord', () => {
     Assert.equal(TypeGuard.TString(T.patternProperties[PatternStringExact]), true)
     Assert.equal(T.extra, 1)
   })
+  it('Should guard overload 9', () => {
+    const L = Type.TemplateLiteral([Type.String(), Type.Literal('_foo')])
+    const T = Type.Record(L, Type.String(), { extra: 1 })
+    Assert.equal(TypeGuard.TRecord(T), true)
+    Assert.equal(TypeGuard.TString(T.patternProperties[`^${PatternString}_foo$`]), true)
+    Assert.equal(T.extra, 1)
+  })
   // -------------------------------------------------------------
   // Variants
   // -------------------------------------------------------------
@@ -62,7 +69,6 @@ describe('type/guard/TRecord', () => {
     const R = TypeGuard.TRecord(Type.Record(Type.String(), Type.Number()))
     Assert.equal(R, true)
   })
-
   it('Should guard for TRecord with TObject value', () => {
     const R = TypeGuard.TRecord(
       Type.Record(
@@ -75,18 +81,15 @@ describe('type/guard/TRecord', () => {
     )
     Assert.equal(R, true)
   })
-
   it('Should not guard for TRecord', () => {
     const R = TypeGuard.TRecord(null)
     Assert.equal(R, false)
   })
-
   it('Should not guard for TRecord with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TRecord(Type.Record(Type.String(), Type.Number(), { $id: 1 }))
     Assert.equal(R, false)
   })
-
   it('Should not guard for TRecord with TObject value with invalid Property', () => {
     const R = TypeGuard.TRecord(
       Type.Record(
@@ -99,7 +102,6 @@ describe('type/guard/TRecord', () => {
     )
     Assert.equal(R, false)
   })
-
   it('Transform: Should should transform to TObject for single literal union value', () => {
     const K = Type.Union([Type.Literal('ok')])
     const R = TypeGuard.TObject(Type.Record(K, Type.Number()))
diff --git a/test/runtime/type/template/finite.ts b/test/runtime/type/template/finite.ts
index e44c8164f..c843229ed 100644
--- a/test/runtime/type/template/finite.ts
+++ b/test/runtime/type/template/finite.ts
@@ -25,6 +25,11 @@ describe('type/TemplateLiteralFinite', () => {
     const R = TemplateLiteralFinite.Check(E)
     Assert.deepEqual(R, true)
   })
+  it('Finite 5', () => {
+    const E = TemplateLiteralParser.Parse(`\\.\\*`)
+    const R = TemplateLiteralFinite.Check(E)
+    Assert.deepEqual(R, true)
+  })
   // ---------------------------------------------------------------
   // Infinite
   // ---------------------------------------------------------------
@@ -58,4 +63,9 @@ describe('type/TemplateLiteralFinite', () => {
     const R = TemplateLiteralFinite.Check(E)
     Assert.deepEqual(R, false)
   })
+  it('Infinite 7', () => {
+    const E = TemplateLiteralParser.Parse(`${PatternString}_foo`)
+    const R = TemplateLiteralFinite.Check(E)
+    Assert.deepEqual(R, false)
+  })
 })
diff --git a/test/runtime/type/template/generate.ts b/test/runtime/type/template/generate.ts
index 587e6cb9c..df00189db 100644
--- a/test/runtime/type/template/generate.ts
+++ b/test/runtime/type/template/generate.ts
@@ -44,12 +44,12 @@ describe('type/TemplateLiteralGenerator', () => {
   it('Expression 2', () => {
     const E = TemplateLiteralParser.Parse('\\)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, [')'])
+    Assert.deepEqual(R, ['\\)'])
   })
   it('Expression 3', () => {
     const E = TemplateLiteralParser.Parse('\\(')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['('])
+    Assert.deepEqual(R, ['\\('])
   })
   it('Expression 4', () => {
     const E = TemplateLiteralParser.Parse('')
@@ -59,7 +59,7 @@ describe('type/TemplateLiteralGenerator', () => {
   it('Expression 5', () => {
     const E = TemplateLiteralParser.Parse('\\')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, [''])
+    Assert.deepEqual(R, ['\\'])
   })
   it('Expression 6', () => {
     const E = TemplateLiteralParser.Parse('()')
diff --git a/test/runtime/type/template/parser.ts b/test/runtime/type/template/parser.ts
index 682a5b912..9cf2607f1 100644
--- a/test/runtime/type/template/parser.ts
+++ b/test/runtime/type/template/parser.ts
@@ -84,14 +84,14 @@ describe('type/TemplateLiteralParser', () => {
     const E = TemplateLiteralParser.Parse('\\)')
     Assert.deepEqual(E, {
       type: 'const',
-      const: ')',
+      const: '\\)',
     })
   })
   it('Expression 3', () => {
     const E = TemplateLiteralParser.Parse('\\(')
     Assert.deepEqual(E, {
       type: 'const',
-      const: '(',
+      const: '\\(',
     })
   })
   it('Expression 4', () => {
@@ -105,7 +105,7 @@ describe('type/TemplateLiteralParser', () => {
     const E = TemplateLiteralParser.Parse('\\')
     Assert.deepEqual(E, {
       type: 'const',
-      const: '',
+      const: '\\',
     })
   })
   it('Expression 6', () => {
diff --git a/test/runtime/type/template/pattern.ts b/test/runtime/type/template/pattern.ts
index 1936c8211..d43148951 100644
--- a/test/runtime/type/template/pattern.ts
+++ b/test/runtime/type/template/pattern.ts
@@ -7,6 +7,25 @@ describe('type/TemplateLiteralPattern', () => {
     Assert.equal(pattern, expect)
   }
   // ---------------------------------------------------------------
+  // Escape
+  // ---------------------------------------------------------------
+  it('Escape 1', () => {
+    const T = Type.TemplateLiteral([Type.Literal('.*')])
+    Assert.equal(T.pattern, '^\\.\\*$')
+  })
+  it('Escape 2', () => {
+    const T = Type.TemplateLiteral([Type.Literal('(')])
+    Assert.equal(T.pattern, '^\\($')
+  })
+  it('Escape 3', () => {
+    const T = Type.TemplateLiteral([Type.Literal(')')])
+    Assert.equal(T.pattern, '^\\)$')
+  })
+  it('Escape 4', () => {
+    const T = Type.TemplateLiteral([Type.Literal('|')])
+    Assert.equal(T.pattern, '^\\|$')
+  })
+  // ---------------------------------------------------------------
   // Pattern
   // ---------------------------------------------------------------
   it('Pattern 1', () => {

From 5f641c13aefe4697f282d6ee8f2727738629416b Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 14 Apr 2023 13:11:35 +0900
Subject: [PATCH 105/369] Recursive KeyOf (#382)

---
 package-lock.json                      |  4 +-
 package.json                           |  2 +-
 readme.md                              |  2 +-
 src/typebox.ts                         | 15 ++++---
 src/value/create.ts                    | 10 ++++-
 test/runtime/type/guard/index.ts       |  1 +
 test/runtime/type/guard/keyof.ts       | 59 ++++++++++++++++++++++++++
 test/runtime/value/create/intersect.ts | 22 ++++++++++
 test/static/keyof.ts                   | 12 ++++++
 9 files changed, 114 insertions(+), 13 deletions(-)
 create mode 100644 test/runtime/type/guard/keyof.ts

diff --git a/package-lock.json b/package-lock.json
index 7c2f3e507..83f85c198 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.5",
+  "version": "0.27.6",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.27.5",
+      "version": "0.27.6",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index ca02865f9..04a929976 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.5",
+  "version": "0.27.6",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 6c6e443cd..c5120a9d5 100644
--- a/readme.md
+++ b/readme.md
@@ -402,7 +402,7 @@ The following table lists the Standard TypeBox types. These types are fully comp
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Record(         │ type T = Record<            │ const T = {                    │
 │   Type.String(),               │   string,                   │   type: 'object',              │
-│   Type.Number()                │   number,                   │   patternProperties: {         │
+│   Type.Number()                │   number                    │   patternProperties: {         │
 │ )                              │ >                           │     '^.*$': {                  │
 │                                │                             │       type: 'number'           │
 │                                │                             │     }                          │
diff --git a/src/typebox.ts b/src/typebox.ts
index 564399508..21ad70980 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -305,11 +305,12 @@ export type TKeyOfTuple<T extends TSchema> = {
   : never
 // prettier-ignore
 export type TKeyOf<T extends TSchema = TSchema> = (
-  T extends TComposite       ? TKeyOfTuple<T> :
-  T extends TIntersect       ? TKeyOfTuple<T> :
-  T extends TUnion           ? TKeyOfTuple<T> :
-  T extends TObject          ? TKeyOfTuple<T> :
-  T extends TRecord<infer K> ? [K] :
+  T extends TComposite          ? TKeyOfTuple<T> :
+  T extends TIntersect          ? TKeyOfTuple<T> :
+  T extends TUnion              ? TKeyOfTuple<T> :
+  T extends TObject             ? TKeyOfTuple<T> :
+  T extends TRecursive<infer S> ? TKeyOfTuple<S> :
+  T extends TRecord<infer K>    ? [K] :
   []
 ) extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never
 // --------------------------------------------------------------------------
@@ -394,7 +395,7 @@ export interface TObject<T extends TProperties = TProperties> extends TSchema, O
 export type TOmitArray<T extends TSchema[], K extends keyof any> = Assert<{ [K2 in keyof T]: TOmit<Assert<T[K2], TSchema>, K> }, TSchema[]>
 export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<Assert<Omit<T, K>, TProperties>>
 // prettier-ignore
-export type TOmit<T extends TSchema, K extends keyof any> = 
+export type TOmit<T extends TSchema = TSchema, K extends keyof any = keyof any> = 
   T extends TComposite<infer S> ? TComposite<TOmitArray<S, K>> :
   T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : 
   T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : 
@@ -436,7 +437,7 @@ export type TPickProperties<T extends TProperties, K extends keyof any> =
     [K in keyof R]: Assert<R[K], TSchema> extends TSchema ? R[K] : never
   }): never
 // prettier-ignore
-export type TPick<T extends TSchema, K extends keyof any> = 
+export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any> = 
   T extends TComposite<infer S> ? TComposite<TPickArray<S, K>> :
   T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : 
   T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : 
diff --git a/src/value/create.ts b/src/value/create.ts
index f6f63b68b..dace6a6a2 100644
--- a/src/value/create.ts
+++ b/src/value/create.ts
@@ -44,7 +44,7 @@ export class ValueCreateNeverTypeError extends Error {
 }
 export class ValueCreateIntersectTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
-    super('ValueCreate: Can only create values for intersected objects and non-varying primitive types. Consider using a default value.')
+    super('ValueCreate: Intersect produced invalid value. Consider using a default value.')
   }
 }
 export class ValueCreateTempateLiteralTypeError extends Error {
@@ -152,7 +152,13 @@ export namespace ValueCreate {
     if ('default' in schema) {
       return schema.default
     } else {
-      const value = schema.type === 'object' ? schema.allOf.reduce((acc, schema) => ({ ...acc, ...(Visit(schema, references) as any) }), {}) : schema.allOf.reduce((_, schema) => Visit(schema, references), undefined as any)
+      // Note: The best we can do here is attempt to instance each sub type and apply through object assign. For non-object
+      // sub types, we just escape the assignment and just return the value. In the latter case, this is typically going to
+      // be a consequence of an illogical intersection.
+      const value = schema.allOf.reduce((acc, schema) => {
+        const next = Visit(schema, references) as any
+        return typeof next === 'object' ? { ...acc, ...next } : next
+      }, {})
       if (!ValueCheck.Check(schema, references, value)) throw new ValueCreateIntersectTypeError(schema)
       return value
     }
diff --git a/test/runtime/type/guard/index.ts b/test/runtime/type/guard/index.ts
index d9d8086c4..d40906195 100644
--- a/test/runtime/type/guard/index.ts
+++ b/test/runtime/type/guard/index.ts
@@ -11,6 +11,7 @@ import './function'
 import './integer'
 import './literal'
 import './intersect'
+import './keyof'
 import './not'
 import './null'
 import './number'
diff --git a/test/runtime/type/guard/keyof.ts b/test/runtime/type/guard/keyof.ts
new file mode 100644
index 000000000..d1f6e9ecb
--- /dev/null
+++ b/test/runtime/type/guard/keyof.ts
@@ -0,0 +1,59 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TKeyOf', () => {
+  it('Should guard for keyof TObject', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    })
+    const K = Type.KeyOf(T)
+    Assert.deepEqual(TypeGuard.TUnion(K), true)
+    Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[0]), true)
+    Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[1]), true)
+  })
+  it('Should guard for keyof TRecursive', () => {
+    const T = Type.Recursive((Self) =>
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Array(Self),
+      }),
+    )
+    const K = Type.KeyOf(T)
+    Assert.deepEqual(TypeGuard.TUnion(K), true)
+    Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[0]), true)
+    Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[1]), true)
+  })
+  it('Should guard for keyof TIntersect', () => {
+    const T = Type.Intersect([
+      Type.Object({
+        x: Type.Number(),
+      }),
+      Type.Object({
+        y: Type.Number(),
+      }),
+    ])
+    const K = Type.KeyOf(T)
+    Assert.deepEqual(TypeGuard.TUnion(K), true)
+    Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[0]), true)
+    Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[1]), true)
+  })
+  it('Should guard for keyof TUnion', () => {
+    const T = Type.Union([
+      Type.Object({
+        x: Type.Number(),
+      }),
+      Type.Object({
+        y: Type.Number(),
+      }),
+    ])
+    const K = Type.KeyOf(T)
+    Assert.deepEqual(TypeGuard.TNever(K), true)
+  })
+  it('Should guard for keyof TNull', () => {
+    const T = Type.Null()
+    const K = Type.KeyOf(T)
+    Assert.deepEqual(TypeGuard.TNever(K), true)
+  })
+})
diff --git a/test/runtime/value/create/intersect.ts b/test/runtime/value/create/intersect.ts
index 344ad5b90..f007480ae 100644
--- a/test/runtime/value/create/intersect.ts
+++ b/test/runtime/value/create/intersect.ts
@@ -37,4 +37,26 @@ describe('value/create/Intersect', () => {
     const R = Value.Create(T)
     Assert.deepEqual(R, 'hello')
   })
+  it('Should create from nested intersection', () => {
+    const T = Type.Intersect([
+      Type.Object({
+        x: Type.Number({ default: 1 }),
+      }),
+      Type.Intersect([
+        Type.Object({
+          y: Type.Number({ default: 2 }),
+        }),
+        Type.Object({
+          z: Type.Number({ default: 3 }),
+        }),
+      ]),
+    ])
+    const R = Value.Create(T)
+    Assert.deepEqual(R, { x: 1, y: 2, z: 3 })
+  })
+  it('Should create non varying primitive', () => {
+    const T = Type.Intersect([Type.Number(), Type.Number(), Type.Number()])
+    const R = Value.Create(T)
+    Assert.deepEqual(R, 0)
+  })
 })
diff --git a/test/static/keyof.ts b/test/static/keyof.ts
index ff353b7fa..bda75e87f 100644
--- a/test/static/keyof.ts
+++ b/test/static/keyof.ts
@@ -79,3 +79,15 @@ import { Type } from '@sinclair/typebox'
     Expect(K2).ToInfer<'y' | 'z'>()
   }
 }
+{
+  const T = Type.Recursive((Self) =>
+    Type.Object({
+      a: Type.String(),
+      b: Type.String(),
+      c: Type.String(),
+      d: Type.Array(Self),
+    }),
+  )
+  const K = Type.KeyOf(T)
+  Expect(K).ToInfer<'a' | 'b' | 'c' | 'd'>()
+}

From fc616031db973c78c7a61f803a396244f896649d Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 14 Apr 2023 17:07:59 +0900
Subject: [PATCH 106/369] Recursive Utility Types (#383)

---
 package-lock.json        |  4 +--
 package.json             |  2 +-
 src/typebox.ts           | 15 +++++---
 test/static/recursive.ts | 75 +++++++++++++++++++++++++++++++++++++---
 4 files changed, 83 insertions(+), 13 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 83f85c198..841d11cd1 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.6",
+  "version": "0.27.7",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.27.6",
+      "version": "0.27.7",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 04a929976..4f0e07a85 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.6",
+  "version": "0.27.7",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 21ad70980..6bd693dd6 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -305,11 +305,11 @@ export type TKeyOfTuple<T extends TSchema> = {
   : never
 // prettier-ignore
 export type TKeyOf<T extends TSchema = TSchema> = (
+  T extends TRecursive<infer S> ? TKeyOfTuple<S> :
   T extends TComposite          ? TKeyOfTuple<T> :
   T extends TIntersect          ? TKeyOfTuple<T> :
   T extends TUnion              ? TKeyOfTuple<T> :
   T extends TObject             ? TKeyOfTuple<T> :
-  T extends TRecursive<infer S> ? TKeyOfTuple<S> :
   T extends TRecord<infer K>    ? [K] :
   []
 ) extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never
@@ -396,6 +396,7 @@ export type TOmitArray<T extends TSchema[], K extends keyof any> = Assert<{ [K2
 export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<Assert<Omit<T, K>, TProperties>>
 // prettier-ignore
 export type TOmit<T extends TSchema = TSchema, K extends keyof any = keyof any> = 
+  T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> :
   T extends TComposite<infer S> ? TComposite<TOmitArray<S, K>> :
   T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : 
   T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : 
@@ -420,6 +421,7 @@ export type TPartialProperties<T extends TProperties> = Evaluate<Assert<{
 }, TProperties>>
 // prettier-ignore
 export type TPartial<T extends TSchema> =  
+  T extends TRecursive<infer S> ? TRecursive<TPartial<S>> :   
   T extends TComposite<infer S> ? TComposite<TPartialArray<S>> :
   T extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : 
   T extends TUnion<infer S>     ? TUnion<TPartialArray<S>> : 
@@ -438,6 +440,7 @@ export type TPickProperties<T extends TProperties, K extends keyof any> =
   }): never
 // prettier-ignore
 export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any> = 
+  T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> :
   T extends TComposite<infer S> ? TComposite<TPickArray<S, K>> :
   T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : 
   T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : 
@@ -480,6 +483,7 @@ export interface TThis extends TSchema {
 }
 export type TRecursiveReduce<T extends TSchema> = Static<T, [TRecursiveReduce<T>]>
 export interface TRecursive<T extends TSchema> extends TSchema {
+  [Hint]: 'Recursive'
   static: TRecursiveReduce<T>
 }
 // --------------------------------------------------------------------------
@@ -508,6 +512,7 @@ export type TRequiredProperties<T extends TProperties> = Evaluate<Assert<{
 }, TProperties>>
 // prettier-ignore
 export type TRequired<T extends TSchema> = 
+  T extends TRecursive<infer S> ? TRecursive<TRequired<S>> :   
   T extends TComposite<infer S> ? TComposite<TRequiredArray<S>> : 
   T extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : 
   T extends TUnion<infer S>     ? TUnion<TRequiredArray<S>> : 
@@ -584,9 +589,9 @@ export type TTemplateLiteralConst<T, Acc extends string> =
   T extends TUnion<infer U> ? { [K in keyof U]: TTemplateLiteralUnion<Assert<[U[K]], TTemplateLiteralKind[]>, Acc> }[number] :
   T extends TTemplateLiteral ? `${Static<T>}` : 
   T extends TLiteral<infer U> ? `${U}` :
-  T extends TString ? `${string}` : 
-  T extends TNumber ? `${number}` : 
-  T extends TBigInt ? `${bigint}` : 
+  T extends TString  ? `${string}`  : 
+  T extends TNumber  ? `${number}`  : 
+  T extends TBigInt  ? `${bigint}`  : 
   T extends TBoolean ? `${boolean}` :
   never
 // prettier-ignore
@@ -2420,7 +2425,7 @@ export class StandardTypeBuilder extends TypeBuilder {
     if (options.$id === undefined) (options as any).$id = `T${TypeOrdinal++}`
     const thisType = callback({ [Kind]: 'This', $ref: `${options.$id}` } as any)
     thisType.$id = options.$id
-    return this.Create({ ...options, ...thisType } as any)
+    return this.Create({ ...options, [Hint]: 'Recursive', ...thisType } as any)
   }
   /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
   public Ref<T extends TSchema>(schema: T, options: SchemaOptions = {}): TRef<T> {
diff --git a/test/static/recursive.ts b/test/static/recursive.ts
index 777195109..06ca5d025 100644
--- a/test/static/recursive.ts
+++ b/test/static/recursive.ts
@@ -2,14 +2,79 @@ import { Expect } from './assert'
 import { Type, Static } from '@sinclair/typebox'
 
 {
-  const T = Type.Recursive((Node) =>
+  // identity
+  const R = Type.Recursive((Node) =>
     Type.Object({
       id: Type.String(),
       nodes: Type.Array(Node),
     }),
   )
-
-  type T = Static<typeof T>
-
-  Expect(T).ToInfer<T>() // ? how to test....
+  type T = Static<typeof R>
+  Expect(R).ToInfer<{ id: string; nodes: T[] }>()
+}
+{
+  // keyof
+  const R = Type.Recursive((Node) =>
+    Type.Object({
+      id: Type.String(),
+      nodes: Type.Array(Node),
+    }),
+  )
+  const T = Type.KeyOf(R)
+  Expect(T).ToInfer<'id' | 'nodes'>()
+}
+{
+  // partial
+  const R = Type.Recursive((Node) =>
+    Type.Object({
+      id: Type.String(),
+      nodes: Type.Array(Node),
+    }),
+  )
+  const T = Type.Partial(R)
+  Expect(T).ToInfer<{
+    id: string | undefined
+    nodes: Static<typeof T>[] | undefined
+  }>()
+}
+{
+  // required
+  const R = Type.Recursive((Node) =>
+    Type.Object({
+      id: Type.String(),
+      nodes: Type.Array(Node),
+    }),
+  )
+  const P = Type.Partial(R)
+  const T = Type.Required(P)
+  Expect(T).ToInfer<{
+    id: string
+    nodes: Static<typeof T>[]
+  }>()
+}
+{
+  // pick
+  const R = Type.Recursive((Node) =>
+    Type.Object({
+      id: Type.String(),
+      nodes: Type.Array(Node),
+    }),
+  )
+  const T = Type.Pick(R, ['id'])
+  Expect(T).ToInfer<{
+    id: string
+  }>()
+}
+{
+  // omit
+  const R = Type.Recursive((Node) =>
+    Type.Object({
+      id: Type.String(),
+      nodes: Type.Array(Node),
+    }),
+  )
+  const T = Type.Omit(R, ['id'])
+  Expect(T).ToInfer<{
+    nodes: Static<typeof T>[]
+  }>()
 }

From e348464766597309af3ecb21af57199524267a20 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Fri, 14 Apr 2023 19:53:20 +0900
Subject: [PATCH 107/369] TypeMap Example

---
 example/typemap/readme.md  |   7 +
 example/typemap/typemap.ts | 496 +++++++++++++++++++++++++++++++++++++
 2 files changed, 503 insertions(+)
 create mode 100644 example/typemap/readme.md
 create mode 100644 example/typemap/typemap.ts

diff --git a/example/typemap/readme.md b/example/typemap/readme.md
new file mode 100644
index 000000000..fdadd3ab2
--- /dev/null
+++ b/example/typemap/readme.md
@@ -0,0 +1,7 @@
+# TypeMap
+
+TypeMap is a fluent type builder abstraction built on top of TypeBox. It is modelled after the Yup and Zod and libraries, but internally uses TypeBox for type composition, inference and runtime type assertion. It supports the same advanced compositional types as TypeBox (including generics, conditional, recursive and template literal types), but offers this functionality as a set of chainable lowercase types. 
+
+Like TypeBox, TypeMap internally uses JSON schema for its type representation. It provides access to the TypeBox compiler infrastructure with the `.compile()` and `.code()` methods which are available on all types, and access to the internal schema via `.schema()`. Types also implement `.check()` and `.cast()` for convenience. 
+
+TypeMap is implemented as an example for reference purposes only.
\ No newline at end of file
diff --git a/example/typemap/typemap.ts b/example/typemap/typemap.ts
new file mode 100644
index 000000000..9352ff370
--- /dev/null
+++ b/example/typemap/typemap.ts
@@ -0,0 +1,496 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/typemap
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TypeCompiler, ValueError, TypeCheck } from '@sinclair/typebox/compiler'
+import { Value, ValueErrorIterator } from '@sinclair/typebox/value'
+import { TypeSystem } from '@sinclair/typebox/system'
+import * as T from '@sinclair/typebox'
+
+// -------------------------------------------------------------------------------------------------
+// Formats
+// -------------------------------------------------------------------------------------------------
+// prettier-ignore
+TypeSystem.Format('email', (value) => /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(value))
+// prettier-ignore
+TypeSystem.Format('uuid', (value) => /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i.test(value))
+// prettier-ignore
+TypeSystem.Format('url', (value) => /^(?:https?|wss?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu.test(value))
+// prettier-ignore
+TypeSystem.Format('ipv6', (value) => /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i.test(value))
+// prettier-ignore
+TypeSystem.Format('ipv4', (value) => /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/.test(value))
+// -------------------------------------------------------------------------------------------------
+// Type Mapping
+// -------------------------------------------------------------------------------------------------
+export type TypeToType<T extends Type> = T extends Type<infer S> ? S : never
+export type TypeToTuple<T extends Type[]> = {
+  [K in keyof T]: T[K] extends Type<infer S> ? S : never
+}
+export type TypeToProperties<T extends PropertiesType> = T.Assert<
+  {
+    [K in keyof T]: T[K] extends Type<infer S> ? S : never
+  },
+  T.TProperties
+>
+export type PropertiesType = Record<keyof any, Type>
+// prettier-ignore
+export type TemplateLiteralType = 
+  | Type<T.TUnion> 
+  | Type<T.TLiteral> 
+  | Type<T.TInteger>
+  | Type<T.TTemplateLiteral> 
+  | Type<T.TNumber> 
+  | Type<T.TBigInt> 
+  | Type<T.TString> 
+  | Type<T.TBoolean> 
+  | Type<T.TNever>;
+// -------------------------------------------------------------------------------------------------
+// Error
+// -------------------------------------------------------------------------------------------------
+export class TypeValueError extends Error {
+  constructor(public readonly errors: ValueError[]) {
+    super('TypeValueError: Invalid Value')
+  }
+}
+// -------------------------------------------------------------------------------------------------
+// Assert
+// -------------------------------------------------------------------------------------------------
+export interface TypeAssert<T extends T.TSchema> {
+  check(value: unknown): value is T.Static<T>
+  errors(value: unknown): ValueErrorIterator
+  code(): string
+}
+export class TypeAssertDynamic<T extends T.TSchema> implements TypeAssert<T> {
+  readonly #schema: T
+  constructor(schema: T) {
+    this.#schema = schema
+  }
+  public check(value: unknown): value is T.Static<T, []> {
+    return Value.Check(this.#schema, [], value)
+  }
+  public errors(value: unknown): ValueErrorIterator {
+    return Value.Errors(this.#schema, [], value)
+  }
+  public code(): string {
+    return TypeCompiler.Code(this.#schema)
+  }
+}
+export class TypeAssertCompiled<T extends T.TSchema> implements TypeAssert<T> {
+  readonly #typecheck: TypeCheck<T>
+  constructor(schema: T) {
+    this.#typecheck = TypeCompiler.Compile(schema)
+  }
+  public check(value: unknown): value is T.Static<T, []> {
+    return this.#typecheck.Check(value)
+  }
+  public errors(value: unknown): ValueErrorIterator {
+    return this.#typecheck.Errors(value)
+  }
+  public code(): string {
+    return this.#typecheck.Code()
+  }
+}
+// -----------------------------------------------------------------------------------------
+// Type
+// -----------------------------------------------------------------------------------------
+export class Type<T extends T.TSchema = T.TSchema> {
+  #assert: TypeAssert<T>
+  #schema: T
+  constructor(schema: T) {
+    this.#assert = new TypeAssertDynamic(schema)
+    this.#schema = schema
+  }
+  /** Augments this type with the given options */
+  public options(options: T.SchemaOptions) {
+    return new Type({ ...this.schema, ...options } as T)
+  }
+  /** Maps a property as readonly and optional */
+  public readonlyOptional(): Type<T.TReadonlyOptional<T>> {
+    return new Type(T.Type.ReadonlyOptional(this.#schema))
+  }
+  /** Maps a property as optional */
+  public optional(): Type<T.TOptional<T>> {
+    return new Type(T.Type.Optional(this.#schema))
+  }
+  /** Maps a property as readonly */
+  public readonly(): Type<T.TReadonly<T>> {
+    return new Type(T.Type.Readonly(this.#schema))
+  }
+  /** Composes this type as a intersect with the given type */
+  public and<U extends Type>(type: U): Type<T.TIntersect<[T, TypeToType<U>]>> {
+    return new Type(T.Type.Intersect([this.#schema, type.schema()])) as any
+  }
+  /** Composes this type as a union with the given type */
+  public or<U extends Type>(type: U): Type<T.TUnion<[T, TypeToType<U>]>> {
+    return new Type(T.Type.Union([this.#schema, type.schema()])) as any
+  }
+  /** Picks the given properties from this type */
+  public pick<K extends (keyof T.Static<T>)[]>(keys: readonly [...K]): Type<T.TPick<T, K[number]>>
+  /** Picks the given properties from this type */
+  public pick<K extends T.TUnion<T.TLiteral<string>[]>>(keys: K): Type<T.TPick<T, T.TUnionOfLiteral<K>>>
+  /** Picks the given properties from this type */
+  public pick<K extends T.TLiteral<string>>(key: K): Type<T.TPick<T, K['const']>>
+  /** Picks the given properties from this type */
+  public pick<K extends T.TNever>(key: K): Type<T.TPick<T, never>> {
+    return new Type(T.Type.Pick(this.#schema, key))
+  }
+  /** Omits the given properties from this type */
+  public omit<K extends (keyof T.Static<T>)[]>(keys: readonly [...K]): Type<T.TOmit<T, K[number]>>
+  /** Omits the given properties from this type */
+  public omit<K extends T.TUnion<T.TLiteral<string>[]>>(keys: K): Type<T.TOmit<T, T.TUnionOfLiteral<K>>>
+  /** Omits the given properties from this type */
+  public omit<K extends T.TLiteral<string>>(key: K): Type<T.TOmit<T, K['const']>>
+  /** Omits the given properties from this type */
+  public omit<K extends T.TNever>(key: K): Type<T.TOmit<T, never>> {
+    return new Type(T.Type.Omit(this.#schema, key))
+  }
+  /** Applies partial to this type */
+  public partial(): Type<T.TPartial<T>> {
+    return new Type(T.Type.Partial(this.#schema))
+  }
+  /** Applies required to this type */
+  public required(): Type<T.TRequired<T>> {
+    return new Type(T.Type.Required(this.schema()))
+  }
+  /** Returns the keys of this type */
+  public keyof(): Type<T.TKeyOf<T>> {
+    return new Type(T.Type.KeyOf(this.schema()))
+  }
+  /** Checks this value and throws if invalid */
+  public assert(value: unknown): void {
+    if (this.#assert.check(value)) return
+    throw new TypeValueError([...this.#assert.errors(value)])
+  }
+  /** Casts this value into this type */
+  public cast(value: unknown): T.Static<T> {
+    return Value.Cast(this.#schema, [], value)
+  }
+  /** Returns true if this value is valid for this type */
+  public check(value: unknown): value is T.Static<T> {
+    return this.#assert.check(value)
+  }
+  /** Returns the assertion code for this type */
+  public code(): string {
+    return this.#assert.code()
+  }
+  /** Creates a default value for this type */
+  public create(): T.Static<T> {
+    return Value.Create(this.#schema, [])
+  }
+  /** Sets a default value for this type */
+  public default(value: T.Static<T>): this {
+    return new Type({ ...this.#schema, default: value }) as this
+  }
+  /** Parses the given value and returns the valid if valid. Otherwise throw. */
+  public parse(value: unknown): T.Static<T> {
+    this.assert(value)
+    return value
+  }
+  /** Compiles this type */
+  public compile(): this {
+    const compiled = new Type(this.#schema)
+    compiled.#assert = new TypeAssertCompiled(this.#schema)
+    return compiled as this
+  }
+  /** Returns the schema associated with this type */
+  public schema(): T {
+    return Value.Clone(this.#schema)
+  }
+}
+// -----------------------------------------------------------------------------------------
+// Array
+// -----------------------------------------------------------------------------------------
+export class ArrayType<T extends T.TArray<T.TSchema>> extends Type<T> {
+  public maxItems(n: number) {
+    return this.options({ maxItems: n })
+  }
+  public minItems(n: number) {
+    return this.options({ minItems: n })
+  }
+  public length(n: number) {
+    return this.options({ minItems: n, maxItems: n })
+  }
+  public uniqueItems() {
+    return this.options({ uniqueItems: true })
+  }
+}
+// -----------------------------------------------------------------------------------------
+// Object
+// -----------------------------------------------------------------------------------------
+export class ObjectType<T extends T.TObject = T.TObject> extends Type<T> {
+  public strict() {
+    return this.options({ additionalProperties: false })
+  }
+}
+// -----------------------------------------------------------------------------------------
+// String
+// -----------------------------------------------------------------------------------------
+export class StringType extends Type<T.TString> {
+  public minLength(n: number) {
+    return this.options({ minLength: n })
+  }
+  public maxLength(n: number) {
+    return this.options({ maxLength: n })
+  }
+  public length(n: number) {
+    return this.options({ maxLength: n, minLength: n })
+  }
+  public email() {
+    return this.options({ format: 'email' })
+  }
+  public uuid() {
+    return this.options({ format: 'uuid' })
+  }
+  public url() {
+    return this.options({ format: 'url' })
+  }
+  public ipv6() {
+    return this.options({ format: 'ipv6' })
+  }
+  public ipv4() {
+    return this.options({ format: 'ipv4' })
+  }
+}
+// -----------------------------------------------------------------------------------------
+// Number
+// -----------------------------------------------------------------------------------------
+export class NumberType extends Type<T.TNumber> {
+  public exclusiveMinimum(n: number) {
+    return this.options({ exclusiveMinimum: n })
+  }
+  public minimum(n: number) {
+    return this.options({ minimum: n })
+  }
+  public exclusiveMaximum(n: number) {
+    return this.options({ exclusiveMaximum: n })
+  }
+  public maximum(n: number) {
+    return this.options({ maximum: n })
+  }
+  public multipleOf(n: number) {
+    return this.options({ multipleOf: n })
+  }
+  public positive() {
+    return this.options({ minimum: 0 })
+  }
+  public negative() {
+    return this.options({ maximum: 0 })
+  }
+}
+// -----------------------------------------------------------------------------------------
+// Integer
+// -----------------------------------------------------------------------------------------
+export class IntegerType extends Type<T.TInteger> {
+  public exclusiveMinimum(n: number) {
+    return this.options({ exclusiveMinimum: n })
+  }
+  public minimum(n: number) {
+    return this.options({ minimum: n })
+  }
+  public exclusiveMaximum(n: number) {
+    return this.options({ exclusiveMaximum: n })
+  }
+  public maximum(n: number) {
+    return this.options({ maximum: n })
+  }
+  public multipleOf(n: number) {
+    return this.options({ multipleOf: n })
+  }
+  public positive() {
+    return this.options({ minimum: 0 })
+  }
+  public negative() {
+    return this.options({ maximum: 0 })
+  }
+}
+// -----------------------------------------------------------------------------------------
+// BigInt
+// -----------------------------------------------------------------------------------------
+export class BigIntType extends Type<T.TBigInt> {
+  public exclusiveMinimum(n: bigint) {
+    return this.options({ exclusiveMinimum: n })
+  }
+  public minimum(n: bigint) {
+    return this.options({ minimum: n })
+  }
+  public exclusiveMaximum(n: bigint) {
+    return this.options({ exclusiveMaximum: n })
+  }
+  public maximum(n: bigint) {
+    return this.options({ maximum: n })
+  }
+  public multipleOf(n: bigint) {
+    return this.options({ multipleOf: n })
+  }
+  public positive() {
+    return this.options({ minimum: BigInt(0) })
+  }
+  public negative() {
+    return this.options({ maximum: BigInt(0) })
+  }
+}
+// -----------------------------------------------------------------------------------------
+// Uint8Array
+// -----------------------------------------------------------------------------------------
+export class ModelUint8Array<T extends T.TUint8Array> extends Type<T> {
+  public minByteLength(n: number) {
+    return this.options({ minByteLength: n })
+  }
+  public maxByteLength(n: number) {
+    return this.options({ maxByteLength: n })
+  }
+}
+// -----------------------------------------------------------------------------------------
+// Record
+// -----------------------------------------------------------------------------------------
+export class RecordType<T extends T.TSchema> extends Type<T.TRecord<T.TString, T>> {}
+// -----------------------------------------------------------------------------------------
+// Recursive
+// -----------------------------------------------------------------------------------------
+export class ThisType extends Type<T.TThis> {}
+export class RecursiveType<T extends T.TSchema = T.TSchema> extends Type<T> {}
+// -----------------------------------------------------------------------------------------
+// ModelBuilder
+// -----------------------------------------------------------------------------------------
+export class ModelBuilder {
+  /** Creates an any type */
+  public any() {
+    return new Type(T.Type.Any())
+  }
+  /** Creates an array type */
+  public array<T extends Type>(type: T) {
+    return new ArrayType(T.Type.Array(type.schema()))
+  }
+  /** Creates boolean type */
+  public boolean() {
+    return new Type(T.Type.Boolean())
+  }
+  /** Creates a bigint type */
+  public bigint() {
+    return new BigIntType(T.Type.BigInt())
+  }
+  /** Creates a date type */
+  public date() {
+    return new Type(T.Type.Date())
+  }
+  /** Creates a integer type */
+  public integer() {
+    return new IntegerType(T.Type.Integer())
+  }
+  /** Creates a number type */
+  public number() {
+    return new NumberType(T.Type.Number())
+  }
+  /** Creates a intersect type */
+  public intersect<T extends Type[]>(types: [...T]): Type<T.TIntersect<TypeToTuple<T>>> {
+    const internal = types.map((type) => type.schema())
+    return new Type(T.Type.Intersect(internal)) as any
+  }
+  /** Creates an keyof type */
+  public keyof<T extends Type>(type: T): Type<T.TKeyOf<TypeToType<T>>> {
+    return new Type(T.Type.KeyOf(type.schema())) as any
+  }
+  /** Creates a literal type */
+  public literal<T extends T.TLiteralValue>(value: T) {
+    return new Type(T.Type.Literal(value))
+  }
+  /** Creates a never type */
+  public never() {
+    return new Type(T.Type.Never())
+  }
+  /** Creates a null type */
+  public null() {
+    return new Type(T.Type.Null())
+  }
+  /** Creates a object type */
+  public object<T extends PropertiesType>(properties: T): Type<T.TObject<TypeToProperties<T>>> {
+    const mapped = Object.keys(properties).reduce((acc, key) => ({ ...acc, [key]: properties[key].schema() }), {} as T.TProperties)
+    return new ObjectType(T.Type.Object(mapped)) as any
+  }
+  /** Creates a partial type */
+  public partial<T extends Type>(type: T): Type<TypeToType<T>> {
+    return new Type(T.Type.Partial(type.schema())) as any
+  }
+  /** Creates a promise type */
+  public promise<T extends Type>(type: T): Type<TypeToType<T>> {
+    return new Type(T.Type.Promise(type.schema())) as any
+  }
+  /** Creates an unknown type */
+  public unknown() {
+    return new Type(T.Type.Unknown())
+  }
+  /** Creates a record type */
+  public record<T extends Type>(type: T): RecordType<TypeToType<T>> {
+    return new Type(T.Type.Record(T.Type.String(), type.schema())) as any
+  }
+  /** Creates a recursive type */
+  public recursive<T extends T.TSchema>(callback: (This: ThisType) => Type<T>) {
+    // prettier-ignore
+    return new Type(T.Type.Recursive((This) => callback(new ThisType(This)).schema()))
+  }
+  /** Creates a required type */
+  public required<T extends Type>(type: T) {
+    return new Type(T.Type.Required(type.schema()))
+  }
+  /** Creates a string type */
+  public string() {
+    return new StringType(T.Type.String())
+  }
+  /** Creates a symbol type */
+  public symbol() {
+    return new Type(T.Type.Symbol())
+  }
+  /** Creates a template literal type */
+  public templateLiteral<T extends TemplateLiteralType[]>(types: [...T]): Type<T.TTemplateLiteral<TypeToTuple<T>>> {
+    const mapped = types.map((type) => type.schema())
+    return new Type(T.Type.TemplateLiteral(mapped as any))
+  }
+  /** Creates a tuple type */
+  public tuple<T extends Type[]>(types: [...T]): Type<T.TTuple<TypeToTuple<T>>> {
+    return new Type(T.Type.Tuple(types.map((type) => type.schema()))) as any
+  }
+  /** Creates a uint8array type */
+  public uint8array() {
+    return new Type(T.Type.Uint8Array())
+  }
+  /** Creates an undefined type */
+  public undefined() {
+    return new Type(T.Type.Undefined())
+  }
+  /** Creates a union type */
+  public union<T extends Type[]>(union: [...T]): Type<T.TUnion<TypeToTuple<T>>> {
+    const mapped = union.map((type) => type.schema())
+    return new Type(T.Type.Union(mapped)) as any
+  }
+}
+
+export type Infer<T extends Type> = T extends Type<infer S> ? T.Static<S> : unknown
+
+export const TypeBuilder = new ModelBuilder()
+
+export default TypeBuilder

From 6cfcdc02cc813af2f1be57407c771fc4fadfc34a Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 15 Apr 2023 15:07:51 +0900
Subject: [PATCH 108/369] Support Unregistered Kinds in ObjectMap (#385)

---
 package-lock.json                  |  4 ++--
 package.json                       |  2 +-
 src/typebox.ts                     | 22 +++++++++++-----------
 test/runtime/compiler/omit.ts      |  4 ++--
 test/runtime/compiler/partial.ts   | 16 ----------------
 test/runtime/type/guard/index.ts   |  3 +++
 test/runtime/type/guard/omit.ts    | 17 +++++++++++++++++
 test/runtime/type/guard/partial.ts | 23 +++++++++++++++++++++++
 test/runtime/type/guard/pick.ts    | 17 +++++++++++++++++
 9 files changed, 76 insertions(+), 32 deletions(-)
 create mode 100644 test/runtime/type/guard/omit.ts
 create mode 100644 test/runtime/type/guard/partial.ts
 create mode 100644 test/runtime/type/guard/pick.ts

diff --git a/package-lock.json b/package-lock.json
index 841d11cd1..9fa990515 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.7",
+  "version": "0.27.8",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.27.7",
+      "version": "0.27.8",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 4f0e07a85..eeff01d95 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.7",
+  "version": "0.27.8",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 6bd693dd6..687c02be0 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -1832,24 +1832,24 @@ export namespace TypeClone {
 // --------------------------------------------------------------------------
 export namespace ObjectMap {
   function Intersect(schema: TIntersect, callback: (object: TObject) => TObject) {
-    return Type.Intersect(
-      schema.allOf.map((inner) => Visit(inner, callback)),
-      { ...schema },
-    )
+    // prettier-ignore
+    return Type.Intersect(schema.allOf.map((inner) => Visit(inner, callback)), { ...schema })
   }
   function Union(schema: TUnion, callback: (object: TObject) => TObject) {
-    return Type.Union(
-      schema.anyOf.map((inner) => Visit(inner, callback)),
-      { ...schema },
-    )
+    // prettier-ignore
+    return Type.Union(schema.anyOf.map((inner) => Visit(inner, callback)), { ...schema })
   }
   function Object(schema: TObject, callback: (object: TObject) => TObject) {
     return callback(schema)
   }
   function Visit(schema: TSchema, callback: (object: TObject) => TObject): TSchema {
-    if (TypeGuard.TIntersect(schema)) return Intersect(schema, callback)
-    if (TypeGuard.TUnion(schema)) return Union(schema, callback)
-    if (TypeGuard.TObject(schema)) return Object(schema, callback)
+    // There are cases where users need to map objects with unregistered kinds. Using a TypeGuard here would
+    // prevent sub schema mapping as unregistered kinds will not pass TSchema checks. This is notable in the
+    // case of TObject where unregistered property kinds cause the TObject check to fail. As mapping is only
+    // used for composition, we use explicit checks instead.
+    if (schema[Kind] === 'Intersect') return Intersect(schema as TIntersect, callback)
+    if (schema[Kind] === 'Union') return Union(schema as TUnion, callback)
+    if (schema[Kind] === 'Object') return Object(schema as TObject, callback)
     return schema
   }
   export function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T {
diff --git a/test/runtime/compiler/omit.ts b/test/runtime/compiler/omit.ts
index 9d4ed2723..9c38ff7c3 100644
--- a/test/runtime/compiler/omit.ts
+++ b/test/runtime/compiler/omit.ts
@@ -1,6 +1,6 @@
-import { Type } from '@sinclair/typebox'
+import { Type, Kind } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
-import { strictEqual } from 'assert'
+import { deepEqual, strictEqual } from 'assert'
 
 describe('type/compiler/Omit', () => {
   it('Should omit properties on the source schema', () => {
diff --git a/test/runtime/compiler/partial.ts b/test/runtime/compiler/partial.ts
index e295aa6b9..684282403 100644
--- a/test/runtime/compiler/partial.ts
+++ b/test/runtime/compiler/partial.ts
@@ -50,20 +50,4 @@ describe('type/compiler/Partial', () => {
     strictEqual(A.additionalProperties, false)
     strictEqual(T.additionalProperties, false)
   })
-  it('Should support partial properties of raw TUnsafe', () => {
-    // https://github.com/sinclairzx81/typebox/issues/364
-    const T = Type.Partial(Type.Object({ x: Type.Unsafe({ x: 1 }) }))
-    strictEqual(T.required, undefined)
-  })
-  it('Should not support partial properties of unknown TUnsafe', () => {
-    // https://github.com/sinclairzx81/typebox/issues/364
-    const T = Type.Partial(Type.Object({ x: Type.Unsafe({ [Kind]: 'UnknownPartialType', x: 1 }) }))
-    strictEqual(T.required![0], 'x')
-  })
-  it('Should support partial properties of custom TUnsafe', () => {
-    // https://github.com/sinclairzx81/typebox/issues/364
-    const U = TypeSystem.Type('CustomPartialType', () => true)
-    const T = Type.Partial(Type.Object({ x: U() }))
-    strictEqual(T.required, undefined)
-  })
 })
diff --git a/test/runtime/type/guard/index.ts b/test/runtime/type/guard/index.ts
index d40906195..d88632516 100644
--- a/test/runtime/type/guard/index.ts
+++ b/test/runtime/type/guard/index.ts
@@ -16,6 +16,9 @@ import './not'
 import './null'
 import './number'
 import './object'
+import './omit'
+import './partial'
+import './pick'
 import './promise'
 import './record'
 import './ref'
diff --git a/test/runtime/type/guard/omit.ts b/test/runtime/type/guard/omit.ts
new file mode 100644
index 000000000..7a6055a27
--- /dev/null
+++ b/test/runtime/type/guard/omit.ts
@@ -0,0 +1,17 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type, Kind } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TOmit', () => {
+  // -------------------------------------------------------------------------
+  // case: https://github.com/sinclairzx81/typebox/issues/384
+  // -------------------------------------------------------------------------
+  it('Should support TUnsafe omit properties with no Kind', () => {
+    const T = Type.Omit(Type.Object({ x: Type.Unsafe({ x: 1 }), y: Type.Number() }), ['x'])
+    Assert.deepEqual(T.required, ['y'])
+  })
+  it('Should support TUnsafe omit properties with unregistered Kind', () => {
+    const T = Type.Omit(Type.Object({ x: Type.Unsafe({ x: 1, [Kind]: 'UnknownOmitType' }), y: Type.Number() }), ['x'])
+    Assert.deepEqual(T.required, ['y'])
+  })
+})
diff --git a/test/runtime/type/guard/partial.ts b/test/runtime/type/guard/partial.ts
new file mode 100644
index 000000000..5eb292ca9
--- /dev/null
+++ b/test/runtime/type/guard/partial.ts
@@ -0,0 +1,23 @@
+import { TypeSystem } from '@sinclair/typebox/system'
+import { TypeGuard } from '@sinclair/typebox'
+import { Type, Kind } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TPartial', () => {
+  // -------------------------------------------------------------------------
+  // case: https://github.com/sinclairzx81/typebox/issues/364
+  // -------------------------------------------------------------------------
+  it('Should support TUnsafe partial properties with no Kind', () => {
+    const T = Type.Partial(Type.Object({ x: Type.Unsafe({ x: 1 }) }))
+    Assert.deepEqual(T.required, undefined)
+  })
+  it('Should support TUnsafe partial properties with unregistered Kind', () => {
+    const T = Type.Partial(Type.Object({ x: Type.Unsafe({ [Kind]: 'UnknownPartialType', x: 1 }) }))
+    Assert.deepEqual(T.required, undefined)
+  })
+  it('Should support TUnsafe partial properties with registered Kind', () => {
+    const U = TypeSystem.Type('CustomPartialType', () => true)
+    const T = Type.Partial(Type.Object({ x: U() }))
+    Assert.deepEqual(T.required, undefined)
+  })
+})
diff --git a/test/runtime/type/guard/pick.ts b/test/runtime/type/guard/pick.ts
new file mode 100644
index 000000000..65767c95d
--- /dev/null
+++ b/test/runtime/type/guard/pick.ts
@@ -0,0 +1,17 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type, Kind } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TPick', () => {
+  // -------------------------------------------------------------------------
+  // case: https://github.com/sinclairzx81/typebox/issues/384
+  // -------------------------------------------------------------------------
+  it('Should support TUnsafe omit properties with no Kind', () => {
+    const T = Type.Pick(Type.Object({ x: Type.Unsafe({ x: 1 }), y: Type.Number() }), ['x'])
+    Assert.deepEqual(T.required, ['x'])
+  })
+  it('Should support TUnsafe omit properties with unregistered Kind', () => {
+    const T = Type.Pick(Type.Object({ x: Type.Unsafe({ x: 1, [Kind]: 'UnknownPickType' }), y: Type.Number() }), ['x'])
+    Assert.deepEqual(T.required, ['x'])
+  })
+})

From 8f3755792635217dcb6bc028dfb11c279b7665aa Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 21 Apr 2023 06:42:32 +0900
Subject: [PATCH 109/369] Revision 0.28.0 (#395)

---
 .github/workflows/ci.yml              |   2 +-
 changelog/0.28.0.md                   | 199 ++++++++++++
 package-lock.json                     |   4 +-
 package.json                          |   2 +-
 readme.md                             | 161 ++++++----
 src/compiler/compiler.ts              |  38 +--
 src/errors/errors.ts                  |  49 +--
 src/system/system.ts                  |  13 -
 src/typebox.ts                        | 441 ++++++++++++++++++--------
 src/value/check.ts                    |  42 +--
 test/runtime/compiler/intersect.ts    | 136 ++++++++
 test/runtime/compiler/record.ts       |  57 +++-
 test/runtime/schema/intersect.ts      | 136 ++++++++
 test/runtime/schema/record.ts         |  39 ++-
 test/runtime/system/system.ts         |   8 +-
 test/runtime/type/guard/composite.ts  |  10 +-
 test/runtime/type/guard/index.ts      |   1 +
 test/runtime/type/guard/indexed.ts    |  98 ++++++
 test/runtime/type/guard/keyof.ts      |  27 +-
 test/runtime/type/guard/omit.ts       |  89 ++++++
 test/runtime/type/guard/pick.ts       |  93 +++++-
 test/runtime/value/check/intersect.ts | 135 ++++++++
 test/runtime/value/check/record.ts    |  32 +-
 23 files changed, 1491 insertions(+), 321 deletions(-)
 create mode 100644 changelog/0.28.0.md
 create mode 100644 test/runtime/type/guard/indexed.ts

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a07597518..b1192b393 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -7,7 +7,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        node: [14.x, 16.x, 18.x]
+        node: [16.x, 18.x, 20.x]
         os: [ubuntu-latest, windows-latest, macOS-latest]
     steps:
       - uses: actions/checkout@v2
diff --git a/changelog/0.28.0.md b/changelog/0.28.0.md
new file mode 100644
index 000000000..3ed1851fe
--- /dev/null
+++ b/changelog/0.28.0.md
@@ -0,0 +1,199 @@
+## [0.28.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.28.0)
+
+## Overview
+
+Revision 0.28.0 adds support for Indexed Access Types. This update also includes moderate breaking changes to Record and Composite types and does require a minor semver revision tick.
+
+## Contents
+
+- Enhancements
+  - [Indexed Access Types](#Indexed-Access-Types)
+  - [KeyOf Tuple and Array](#KeyOf-Tuple-and-Array)
+- Breaking Changes
+  - [Record Types Allow Additional Properties By Default](#Record-Types-Allow-Additional-Properties-By-Default)
+  - [Composite Returns Intersect for Overlapping Properties](#Composite-Returns-Intersect-for-Overlapping-Properties)
+
+<a href="Indexed-Access-Types"></a>
+
+## Indexed Access Types
+
+Revision 0.28.0 adds [Indexed Access Type](https://www.typescriptlang.org/docs/handbook/2/indexed-access-types.html) support with a new `Type.Index()` mapping type. These types allow for deep property lookups without needing to prop dive through JSON Schema properties. This type is based on the TypeScript implementation of Indexed Access Types and allows for generalized selection of properties for complex types irrespective of if that type is a Object, Union, Intersection, Array or Tuple.
+
+```typescript
+// ----------------------------------------------------------
+// The following types A and B are structurally equivalent, 
+// but have varying JSON Schema representations.
+// ----------------------------------------------------------
+const A = Type.Object({
+  x: Type.Number(),
+  y: Type.String(),
+  z: Type.Boolean(),
+})
+
+const B = Type.Intersect([           
+  Type.Object({ x: Type.Number() }),
+  Type.Object({ y: Type.String() }),
+  Type.Object({ z: Type.Boolean() })
+])
+
+// ----------------------------------------------------------
+// TypeBox 0.27.0 - Non Uniform
+// ----------------------------------------------------------
+const A_X = A.properties.x                // TNumber
+const A_Y = A.properties.y                // TString
+const A_Z = A.properties.z                // TBoolean
+
+const B_X = B.allOf[0].properties.x       // TNumber
+const B_Y = B.allOf[1].properties.y       // TString
+const B_Z = B.allOf[2].properties.z       // TBoolean
+
+// ----------------------------------------------------------
+// TypeBox 0.28.0 - Uniform via Type.Index
+// ----------------------------------------------------------
+const A_X = Type.Index(A, ['x'])          // TNumber
+const A_Y = Type.Index(A, ['y'])          // TString
+const A_Z = Type.Index(A, ['z'])          // TBoolean
+
+const B_X = Type.Index(B, ['x'])          // TNumber
+const B_Y = Type.Index(B, ['y'])          // TString
+const B_Z = Type.Index(B, ['z'])          // TBoolean
+```
+Indexed Access Types support has also been extended to Tuple and Array types.
+```typescript
+// -----------------------------------------------------------
+// Array
+// -----------------------------------------------------------
+type T = string[]
+
+type I = T[number]                        // type T = string
+
+const T = Type.Array(Type.String())
+
+const I = Type.Index(T, Type.Number())    // const I = TString
+
+// -----------------------------------------------------------
+// Tuple
+// -----------------------------------------------------------
+type T = ['A', 'B', 'C']
+
+type I = T[0 | 1]                         // type I = 'A' | 'B'
+
+const T = Type.Array(Type.String())
+
+const I = Type.Index(T, Type.Union([      // const I = TUnion<[
+  Type.Literal(0),                        //   TLiteral<'A'>,
+  Type.Literal(1),                        //   TLiteral<'B'>
+]))                                       // ]>
+```
+
+<a href="KeyOf-Tuple-and-Array"></a>
+
+## KeyOf Tuple and Array
+
+Revision 0.28.0 includes additional `Type.KeyOf` support for Array and Tuple types. Keys of Array will always return `TNumber`, whereas keys of Tuple will return a LiteralUnion for each index of that tuple.
+
+```typescript
+// -----------------------------------------------------------
+// KeyOf: Tuple
+// -----------------------------------------------------------
+const T = Type.Tuple([Type.Number(), Type.Number(), Type.Number()])
+
+const K = Type.KeyOf(T)                   // const K = TUnion<[
+                                          //   TLiteral<'0'>,
+                                          //   TLiteral<'1'>,
+                                          //   TLiteral<'2'>,
+                                          // ]>
+
+// -----------------------------------------------------------
+// KeyOf: Array
+// -----------------------------------------------------------
+const T = Type.Array(Type.String())
+
+const K = Type.KeyOf(T)                   // const K = TNumber
+```
+It is possible to combine KeyOf with Index types to extract properties from array and object constructs.
+```typescript
+// -----------------------------------------------------------
+// KeyOf + Index: Object
+// -----------------------------------------------------------
+const T = Type.Object({ x: Type.Number(),  y: Type.String(),  z: Type.Boolean() })
+
+const K = Type.Index(T, Type.KeyOf(T))    // const K = TUnion<[
+                                          //   TNumber,
+                                          //   TString,
+                                          //   TBoolean,
+                                          // ]>   
+
+// -----------------------------------------------------------
+// KeyOf + Index: Tuple
+// -----------------------------------------------------------
+const T = Type.Tuple([Type.Number(), Type.String(), Type.Boolean()])
+
+const K = Type.Index(T, Type.KeyOf(T))    // const K = TUnion<[
+                                          //   TNumber,
+                                          //   TString,
+                                          //   TBoolean,
+                                          // ]>               
+```
+## Breaking Changes
+
+The following are breaking changes in Revision 0.28.0
+
+<a href="Record-Types-Allow-Additional-Properties-By-Default"></a>
+
+## Record Types Allow Additional Properties By Default
+
+Revision 0.28.0 no longer applies an automatic `additionalProperties: false` constraint to types of `TRecord`. Previously this constraint was set to prevent records with numeric keys from allowing unevaluated additional properties with non-numeric keys. This constraint worked in revisions up to 0.26.0, but since the move to use `allOf` intersect schema representations, this meant that types of Record could no longer be composed with intersections. This is due to the JSON Schema rules around extending closed schemas. Information on these rules can be found at the link below.
+
+https://json-schema.org/understanding-json-schema/reference/object.html#extending-closed-schemas
+
+For the most part, the omission of this constraint shouldn't impact existing record types with string keys, however numeric keys may cause problems. Consider the following where the validation unexpectedly succeeds for the following numeric keyed record.
+
+```typescript
+const T = Type.Record(Type.Number(), Type.String())
+
+const R = Value.Check(T, { a: null }) // true - Because `a` is non-numeric and thus is treated as an
+                                      //        additional unevaluated property.
+```
+Moving forward, Records with numeric keys "should" be constrained explicitly with `additionalProperties: false` via options if that record does not require composition through intersection. This is largely inline with the existing constraints one might apply to types of Object.
+
+```typescript
+const T = Type.Record(Type.Number(), Type.String(), {
+  additionalProperties: false
+})
+
+const R = Value.Check(T, { a: null }) // false - Because `a` is non-numeric additional property
+```
+
+<a href="Composite-Returns-Intersect-for-Overlapping-Properties"></a>
+
+## Composite Returns Intersect for Overlapping Properties
+
+This is a minor breaking change with respect to the schema returned for Composite objects with overlapping varying property types. Previously TypeBox would evaluate `TNever` by performing an internal `extends` check against each overlapping property type. However problems emerged using this implementation for users who needed to use Composite with types of `TUnsafe`. This is due to unsafe types being incompatible with TypeBox's internal extends logic.
+
+The solution implemented in 0.28.0 is to return the full intersection of all overlapping properties. The reasoning here is that if the overlapping properties of varying types result in an illogical intersection, this is semantically the same as resolving `never` for that property. This approach avoids the need to internally check if all overlapping properties extend or narrow one another.
+
+```typescript
+const T = Type.Composite([
+  Type.Object({ x: Type.Number() }),  // overlapping property 'x' of varying type
+  Type.Object({ x: Type.String() })
+])
+
+// -----------------------------------------------------------
+// Revision 0.27.0
+// -----------------------------------------------------------
+const R = Type.Object({
+  x: Type.Never()                    // Never evaluated through extends checks.
+})
+
+// -----------------------------------------------------------
+// Revision 0.28.0
+// -----------------------------------------------------------
+const R = Type.Object({
+  x: Type.Intersect([               // Illogical intersections are semantically the same as never
+    Type.Number(), 
+    Type.String()
+  ])
+})
+```
+This implementation should make it more clear what the internal mechanics are for object compositing. Future revisions of TypeBox may however provide a utility function to test illogical intersections for Never for known types. 
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index 9fa990515..deb9afe98 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.8",
+  "version": "0.28.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.27.8",
+      "version": "0.28.0",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index eeff01d95..24257708f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.8",
+  "version": "0.28.0",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index c5120a9d5..5155d455c 100644
--- a/readme.md
+++ b/readme.md
@@ -81,7 +81,8 @@ License MIT
   - [References](#types-references)
   - [Recursive](#types-recursive)
   - [Conditional](#types-conditional)
-  - [Template Literal](#types-template-literal)
+  - [Template](#types-template-literal)
+  - [Indexed](#types-indexed)
   - [Guards](#types-guards)
   - [Unsafe](#types-unsafe)
   - [Strict](#types-strict)
@@ -276,6 +277,14 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │                                │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Index(          │ type T = {                  │ const T = {                    │
+│   Type.Object({                │   x: number,                │   type: number                 │
+│     x: Type.Number(),          │   y: string                 │ }                              │
+│     y: Type.String()           │ }['x']                      │                                │
+│   }), ['x']                    │                             │                                │
+│ )                              │                             │                                │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ enum Foo {                     │ enum Foo {                  │ const T = {                    │
 │   A,                           │   A,                        │   anyOf: [{                    │
 │   B                            │   B                         │     type: 'number',            │
@@ -830,6 +839,24 @@ type R = Static<typeof R>                            // type R = {
                                                      // }
 ```
 
+<a name='types-indexed'></a>
+
+### Indexed Access Types
+
+Indexed Access types are supported with `Type.Index`
+
+```typescript
+const T = Type.Object({                              // type T = {
+  x: Type.Number(),                                  //   x: number
+  y: Type.String(),                                  //   y: string
+  z: Type.Boolean()                                  //   z: boolean
+})                                                   // }
+
+const A = Type.Index(T, ['x'])                       // type A = T['x']
+
+const B = Type.Index(T, Type.KeyOf(T))               // type B = T[keyof T]
+```
+
 <a name='types-unsafe'></a>
 
 ### Unsafe
@@ -1309,7 +1336,7 @@ TypeSystem.AllowNaN = true
 
 ## Benchmark
 
-This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.12.0. 
+This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.12.0 running on Node 20.0.0.
 
 For additional comparative benchmarks, please refer to [typescript-runtime-type-benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/).
 
@@ -1323,35 +1350,35 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │    1000    │ '    257 ms' │ '      8 ms' │ '   32.13 x' │
-│ Literal_Number             │    1000    │ '    203 ms' │ '      4 ms' │ '   50.75 x' │
-│ Literal_Boolean            │    1000    │ '    183 ms' │ '      4 ms' │ '   45.75 x' │
-│ Primitive_Number           │    1000    │ '    174 ms' │ '      8 ms' │ '   21.75 x' │
-│ Primitive_String           │    1000    │ '    158 ms' │ '      9 ms' │ '   17.56 x' │
-│ Primitive_String_Pattern   │    1000    │ '    213 ms' │ '     13 ms' │ '   16.38 x' │
-│ Primitive_Boolean          │    1000    │ '    136 ms' │ '      6 ms' │ '   22.67 x' │
-│ Primitive_Null             │    1000    │ '    144 ms' │ '      6 ms' │ '   24.00 x' │
-│ Object_Unconstrained       │    1000    │ '   1176 ms' │ '     38 ms' │ '   30.95 x' │
-│ Object_Constrained         │    1000    │ '   1181 ms' │ '     31 ms' │ '   38.10 x' │
-│ Object_Vector3             │    1000    │ '    387 ms' │ '      8 ms' │ '   48.38 x' │
-│ Object_Box3D               │    1000    │ '   1693 ms' │ '     25 ms' │ '   67.72 x' │
-│ Tuple_Primitive            │    1000    │ '    470 ms' │ '     15 ms' │ '   31.33 x' │
-│ Tuple_Object               │    1000    │ '   1206 ms' │ '     17 ms' │ '   70.94 x' │
-│ Composite_Intersect        │    1000    │ '    567 ms' │ '     20 ms' │ '   28.35 x' │
-│ Composite_Union            │    1000    │ '    515 ms' │ '     21 ms' │ '   24.52 x' │
-│ Math_Vector4               │    1000    │ '    787 ms' │ '     10 ms' │ '   78.70 x' │
-│ Math_Matrix4               │    1000    │ '    386 ms' │ '      8 ms' │ '   48.25 x' │
-│ Array_Primitive_Number     │    1000    │ '    349 ms' │ '      7 ms' │ '   49.86 x' │
-│ Array_Primitive_String     │    1000    │ '    336 ms' │ '      4 ms' │ '   84.00 x' │
-│ Array_Primitive_Boolean    │    1000    │ '    284 ms' │ '      3 ms' │ '   94.67 x' │
-│ Array_Object_Unconstrained │    1000    │ '   1704 ms' │ '     19 ms' │ '   89.68 x' │
-│ Array_Object_Constrained   │    1000    │ '   1456 ms' │ '     18 ms' │ '   80.89 x' │
-│ Array_Tuple_Primitive      │    1000    │ '    792 ms' │ '     15 ms' │ '   52.80 x' │
-│ Array_Tuple_Object         │    1000    │ '   1552 ms' │ '     17 ms' │ '   91.29 x' │
-│ Array_Composite_Intersect  │    1000    │ '    744 ms' │ '     18 ms' │ '   41.33 x' │
-│ Array_Composite_Union      │    1000    │ '    783 ms' │ '     15 ms' │ '   52.20 x' │
-│ Array_Math_Vector4         │    1000    │ '   1093 ms' │ '     14 ms' │ '   78.07 x' │
-│ Array_Math_Matrix4         │    1000    │ '    684 ms' │ '      6 ms' │ '  114.00 x' │
+│ Literal_String             │    1000    │ '    243 ms' │ '      8 ms' │ '   30.38 x' │
+│ Literal_Number             │    1000    │ '    195 ms' │ '      5 ms' │ '   39.00 x' │
+│ Literal_Boolean            │    1000    │ '    162 ms' │ '      4 ms' │ '   40.50 x' │
+│ Primitive_Number           │    1000    │ '    168 ms' │ '      6 ms' │ '   28.00 x' │
+│ Primitive_String           │    1000    │ '    164 ms' │ '      5 ms' │ '   32.80 x' │
+│ Primitive_String_Pattern   │    1000    │ '    214 ms' │ '      9 ms' │ '   23.78 x' │
+│ Primitive_Boolean          │    1000    │ '    132 ms' │ '      4 ms' │ '   33.00 x' │
+│ Primitive_Null             │    1000    │ '    148 ms' │ '      4 ms' │ '   37.00 x' │
+│ Object_Unconstrained       │    1000    │ '   1158 ms' │ '     30 ms' │ '   38.60 x' │
+│ Object_Constrained         │    1000    │ '   1263 ms' │ '     25 ms' │ '   50.52 x' │
+│ Object_Vector3             │    1000    │ '    384 ms' │ '      7 ms' │ '   54.86 x' │
+│ Object_Box3D               │    1000    │ '   1932 ms' │ '     27 ms' │ '   71.56 x' │
+│ Tuple_Primitive            │    1000    │ '    478 ms' │ '     14 ms' │ '   34.14 x' │
+│ Tuple_Object               │    1000    │ '   1232 ms' │ '     14 ms' │ '   88.00 x' │
+│ Composite_Intersect        │    1000    │ '    671 ms' │ '     17 ms' │ '   39.47 x' │
+│ Composite_Union            │    1000    │ '    537 ms' │ '     18 ms' │ '   29.83 x' │
+│ Math_Vector4               │    1000    │ '    816 ms' │ '     14 ms' │ '   58.29 x' │
+│ Math_Matrix4               │    1000    │ '    417 ms' │ '      6 ms' │ '   69.50 x' │
+│ Array_Primitive_Number     │    1000    │ '    378 ms' │ '      5 ms' │ '   75.60 x' │
+│ Array_Primitive_String     │    1000    │ '    353 ms' │ '      6 ms' │ '   58.83 x' │
+│ Array_Primitive_Boolean    │    1000    │ '    279 ms' │ '      5 ms' │ '   55.80 x' │
+│ Array_Object_Unconstrained │    1000    │ '   1794 ms' │ '     20 ms' │ '   89.70 x' │
+│ Array_Object_Constrained   │    1000    │ '   1586 ms' │ '     19 ms' │ '   83.47 x' │
+│ Array_Tuple_Primitive      │    1000    │ '    791 ms' │ '     13 ms' │ '   60.85 x' │
+│ Array_Tuple_Object         │    1000    │ '   1638 ms' │ '     17 ms' │ '   96.35 x' │
+│ Array_Composite_Intersect  │    1000    │ '    796 ms' │ '     17 ms' │ '   46.82 x' │
+│ Array_Composite_Union      │    1000    │ '    798 ms' │ '     15 ms' │ '   53.20 x' │
+│ Array_Math_Vector4         │    1000    │ '   1127 ms' │ '     14 ms' │ '   80.50 x' │
+│ Array_Math_Matrix4         │    1000    │ '    677 ms' │ '      9 ms' │ '   75.22 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1365,37 +1392,37 @@ This benchmark measures validation performance for varying types. You can review
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │  1000000   │ '     27 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
-│ Literal_Number             │  1000000   │ '     23 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
-│ Literal_Boolean            │  1000000   │ '     21 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
-│ Primitive_Number           │  1000000   │ '     26 ms' │ '     19 ms' │ '     11 ms' │ '    1.73 x' │
-│ Primitive_String           │  1000000   │ '     25 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│ Primitive_String_Pattern   │  1000000   │ '    155 ms' │ '     49 ms' │ '     43 ms' │ '    1.14 x' │
-│ Primitive_Boolean          │  1000000   │ '     23 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│ Primitive_Null             │  1000000   │ '     24 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│ Object_Unconstrained       │  1000000   │ '    804 ms' │ '     35 ms' │ '     28 ms' │ '    1.25 x' │
-│ Object_Constrained         │  1000000   │ '   1041 ms' │ '     55 ms' │ '     41 ms' │ '    1.34 x' │
-│ Object_Vector3             │  1000000   │ '    380 ms' │ '     26 ms' │ '     20 ms' │ '    1.30 x' │
-│ Object_Box3D               │  1000000   │ '   1785 ms' │ '     65 ms' │ '     52 ms' │ '    1.25 x' │
-│ Object_Recursive           │  1000000   │ '   4984 ms' │ '    396 ms' │ '    114 ms' │ '    3.47 x' │
-│ Tuple_Primitive            │  1000000   │ '    168 ms' │ '     24 ms' │ '     16 ms' │ '    1.50 x' │
-│ Tuple_Object               │  1000000   │ '    673 ms' │ '     30 ms' │ '     26 ms' │ '    1.15 x' │
-│ Composite_Intersect        │  1000000   │ '    751 ms' │ '     28 ms' │ '     20 ms' │ '    1.40 x' │
-│ Composite_Union            │  1000000   │ '    489 ms' │ '     24 ms' │ '     16 ms' │ '    1.50 x' │
-│ Math_Vector4               │  1000000   │ '    259 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
-│ Math_Matrix4               │  1000000   │ '   1002 ms' │ '     40 ms' │ '     30 ms' │ '    1.33 x' │
-│ Array_Primitive_Number     │  1000000   │ '    252 ms' │ '     22 ms' │ '     15 ms' │ '    1.47 x' │
-│ Array_Primitive_String     │  1000000   │ '    227 ms' │ '     22 ms' │ '     18 ms' │ '    1.22 x' │
-│ Array_Primitive_Boolean    │  1000000   │ '    150 ms' │ '     23 ms' │ '     22 ms' │ '    1.05 x' │
-│ Array_Object_Unconstrained │  1000000   │ '   4754 ms' │ '     71 ms' │ '     64 ms' │ '    1.11 x' │
-│ Array_Object_Constrained   │  1000000   │ '   4787 ms' │ '    142 ms' │ '    123 ms' │ '    1.15 x' │
-│ Array_Object_Recursive     │  1000000   │ '  19088 ms' │ '   1735 ms' │ '    314 ms' │ '    5.53 x' │
-│ Array_Tuple_Primitive      │  1000000   │ '    650 ms' │ '     41 ms' │ '     31 ms' │ '    1.32 x' │
-│ Array_Tuple_Object         │  1000000   │ '   2770 ms' │ '     67 ms' │ '     55 ms' │ '    1.22 x' │
-│ Array_Composite_Intersect  │  1000000   │ '   2693 ms' │ '     50 ms' │ '     39 ms' │ '    1.28 x' │
-│ Array_Composite_Union      │  1000000   │ '   1982 ms' │ '     72 ms' │ '     33 ms' │ '    2.18 x' │
-│ Array_Math_Vector4         │  1000000   │ '   1068 ms' │ '     40 ms' │ '     26 ms' │ '    1.54 x' │
-│ Array_Math_Matrix4         │  1000000   │ '   4609 ms' │ '    115 ms' │ '     88 ms' │ '    1.31 x' │
+│ Literal_String             │  1000000   │ '     24 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
+│ Literal_Number             │  1000000   │ '     21 ms' │ '     17 ms' │ '     10 ms' │ '    1.70 x' │
+│ Literal_Boolean            │  1000000   │ '     19 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│ Primitive_Number           │  1000000   │ '     24 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
+│ Primitive_String           │  1000000   │ '     26 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Primitive_String_Pattern   │  1000000   │ '    159 ms' │ '     45 ms' │ '     36 ms' │ '    1.25 x' │
+│ Primitive_Boolean          │  1000000   │ '     22 ms' │ '     17 ms' │ '     10 ms' │ '    1.70 x' │
+│ Primitive_Null             │  1000000   │ '     23 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Object_Unconstrained       │  1000000   │ '    914 ms' │ '     34 ms' │ '     26 ms' │ '    1.31 x' │
+│ Object_Constrained         │  1000000   │ '   1095 ms' │ '     50 ms' │ '     38 ms' │ '    1.32 x' │
+│ Object_Vector3             │  1000000   │ '    414 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
+│ Object_Box3D               │  1000000   │ '   1933 ms' │ '     55 ms' │ '     53 ms' │ '    1.04 x' │
+│ Object_Recursive           │  1000000   │ '   4995 ms' │ '    378 ms' │ '    177 ms' │ '    2.14 x' │
+│ Tuple_Primitive            │  1000000   │ '    168 ms' │ '     24 ms' │ '     13 ms' │ '    1.85 x' │
+│ Tuple_Object               │  1000000   │ '    681 ms' │ '     31 ms' │ '     19 ms' │ '    1.63 x' │
+│ Composite_Intersect        │  1000000   │ '    718 ms' │ '     25 ms' │ '     15 ms' │ '    1.67 x' │
+│ Composite_Union            │  1000000   │ '    511 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
+│ Math_Vector4               │  1000000   │ '    285 ms' │ '     23 ms' │ '     12 ms' │ '    1.92 x' │
+│ Math_Matrix4               │  1000000   │ '   1197 ms' │ '     39 ms' │ '     28 ms' │ '    1.39 x' │
+│ Array_Primitive_Number     │  1000000   │ '    294 ms' │ '     22 ms' │ '     12 ms' │ '    1.83 x' │
+│ Array_Primitive_String     │  1000000   │ '    251 ms' │ '     22 ms' │ '     14 ms' │ '    1.57 x' │
+│ Array_Primitive_Boolean    │  1000000   │ '    131 ms' │ '     22 ms' │ '     14 ms' │ '    1.57 x' │
+│ Array_Object_Unconstrained │  1000000   │ '   5249 ms' │ '     69 ms' │ '     56 ms' │ '    1.23 x' │
+│ Array_Object_Constrained   │  1000000   │ '   5299 ms' │ '    127 ms' │ '    123 ms' │ '    1.03 x' │
+│ Array_Object_Recursive     │  1000000   │ '  19609 ms' │ '   1711 ms' │ '    608 ms' │ '    2.81 x' │
+│ Array_Tuple_Primitive      │  1000000   │ '    734 ms' │ '     38 ms' │ '     30 ms' │ '    1.27 x' │
+│ Array_Tuple_Object         │  1000000   │ '   2843 ms' │ '     63 ms' │ '     51 ms' │ '    1.24 x' │
+│ Array_Composite_Intersect  │  1000000   │ '   2794 ms' │ '     43 ms' │ '     36 ms' │ '    1.19 x' │
+│ Array_Composite_Union      │  1000000   │ '   1892 ms' │ '     66 ms' │ '     33 ms' │ '    2.00 x' │
+│ Array_Math_Vector4         │  1000000   │ '   1177 ms' │ '     37 ms' │ '     23 ms' │ '    1.61 x' │
+│ Array_Math_Matrix4         │  1000000   │ '   5115 ms' │ '    110 ms' │ '     85 ms' │ '    1.29 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1409,11 +1436,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '124.3 kb' │ ' 55.7 kb' │  '2.23 x'   │
-│ typebox/errors       │ '107.8 kb' │ ' 47.9 kb' │  '2.25 x'   │
-│ typebox/system       │ ' 73.3 kb' │ ' 30.2 kb' │  '2.43 x'   │
-│ typebox/value        │ '170.7 kb' │ ' 74.2 kb' │  '2.30 x'   │
-│ typebox              │ ' 72.0 kb' │ ' 29.7 kb' │  '2.43 x'   │
+│ typebox/compiler     │ '127.2 kb' │ ' 56.9 kb' │  '2.23 x'   │
+│ typebox/errors       │ '110.9 kb' │ ' 49.2 kb' │  '2.25 x'   │
+│ typebox/system       │ ' 76.4 kb' │ ' 31.5 kb' │  '2.42 x'   │
+│ typebox/value        │ '176.9 kb' │ ' 76.8 kb' │  '2.30 x'   │
+│ typebox              │ ' 75.3 kb' │ ' 31.1 kb' │  '2.42 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 5d80435ff..02591e1eb 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -209,22 +209,17 @@ export namespace TypeCompiler {
     if (IsNumber(schema.maximum)) yield `${value} <= ${schema.maximum}`
   }
   function* Intersect(schema: Types.TIntersect, references: Types.TSchema[], value: string): IterableIterator<string> {
-    if (schema.unevaluatedProperties === undefined) {
-      const expressions = schema.allOf.map((schema: Types.TSchema) => CreateExpression(schema, references, value))
-      yield `${expressions.join(' && ')}`
-    } else if (schema.unevaluatedProperties === false) {
-      // prettier-ignore
-      const schemaKeys = Types.KeyResolver.Resolve(schema).map((key) => `'${key}'`).join(', ')
-      const expressions = schema.allOf.map((schema: Types.TSchema) => CreateExpression(schema, references, value))
-      const expression1 = `Object.getOwnPropertyNames(${value}).every(key => [${schemaKeys}].includes(key))`
-      yield `${expressions.join(' && ')} && ${expression1}`
-    } else if (typeof schema.unevaluatedProperties === 'object') {
-      // prettier-ignore
-      const schemaKeys = Types.KeyResolver.Resolve(schema).map((key) => `'${key}'`).join(', ')
-      const expressions = schema.allOf.map((schema: Types.TSchema) => CreateExpression(schema, references, value))
-      const expression1 = CreateExpression(schema.unevaluatedProperties, references, 'value[key]')
-      const expression2 = `Object.getOwnPropertyNames(${value}).every(key => [${schemaKeys}].includes(key) || ${expression1})`
-      yield `${expressions.join(' && ')} && ${expression2}`
+    const check1 = schema.allOf.map((schema: Types.TSchema) => CreateExpression(schema, references, value)).join(' && ')
+    if (schema.unevaluatedProperties === false) {
+      const keyCheck = PushLocal(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`)
+      const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key))`
+      yield `${check1} && ${check2}`
+    } else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
+      const keyCheck = PushLocal(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`)
+      const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key) || ${CreateExpression(schema.unevaluatedProperties, references, 'value[key]')})`
+      yield `${check1} && ${check2}`
+    } else {
+      yield `${check1}`
     }
   }
   function* Literal(schema: Types.TLiteral, references: Types.TSchema[], value: string): IterableIterator<string> {
@@ -291,11 +286,12 @@ export namespace TypeCompiler {
     yield IsRecordCheck(value)
     if (IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
     if (IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
-    const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
-    const local = PushLocal(`new RegExp(/${keyPattern}/)`)
-    yield `(Object.getOwnPropertyNames(${value}).every(key => ${local}.test(key)))`
-    const expression = CreateExpression(valueSchema, references, 'value')
-    yield `Object.values(${value}).every(value => ${expression})`
+    const [patternKey, patternSchema] = globalThis.Object.entries(schema.patternProperties)[0]
+    const local = PushLocal(`new RegExp(/${patternKey}/)`)
+    const check1 = CreateExpression(patternSchema, references, value)
+    const check2 = Types.TypeGuard.TSchema(schema.additionalProperties) ? CreateExpression(schema.additionalProperties, references, value) : schema.additionalProperties === false ? 'false' : 'true'
+    const expression = `(${local}.test(key) ? ${check1} : ${check2})`
+    yield `(Object.entries(${value}).every(([key, value]) => ${expression}))`
   }
   function* Ref(schema: Types.TRef<any>, references: Types.TSchema[], value: string): IterableIterator<string> {
     const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index be83707c9..6b637d347 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -219,7 +219,7 @@ export namespace ValueErrors {
   function* Constructor(schema: Types.TConstructor, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     yield* Visit(schema.returns, references, path, value.prototype)
   }
-  function* Date(schema: Types.TNumeric, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  function* Date(schema: Types.TDate, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!(value instanceof globalThis.Date)) {
       return yield { type: ValueErrorType.Date, schema, path, value, message: `Expected Date object` }
     }
@@ -244,7 +244,7 @@ export namespace ValueErrors {
       return yield { type: ValueErrorType.Function, schema, path, value, message: `Expected function` }
     }
   }
-  function* Integer(schema: Types.TNumeric, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  function* Integer(schema: Types.TInteger, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!IsInteger(value)) {
       return yield { type: ValueErrorType.Integer, schema, path, value, message: `Expected integer` }
     }
@@ -265,8 +265,8 @@ export namespace ValueErrors {
     }
   }
   function* Intersect(schema: Types.TIntersect, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    for (const subschema of schema.allOf) {
-      const next = Visit(subschema, references, path, value).next()
+    for (const inner of schema.allOf) {
+      const next = Visit(inner, references, path, value).next()
       if (!next.done) {
         yield next.value
         yield { type: ValueErrorType.Intersect, schema, path, value, message: `Expected all sub schemas to be valid` }
@@ -274,19 +274,17 @@ export namespace ValueErrors {
       }
     }
     if (schema.unevaluatedProperties === false) {
-      const schemaKeys = Types.KeyResolver.Resolve(schema)
-      const valueKeys = globalThis.Object.getOwnPropertyNames(value)
-      for (const valueKey of valueKeys) {
-        if (!schemaKeys.includes(valueKey)) {
+      const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema))
+      for (const valueKey of globalThis.Object.getOwnPropertyNames(value)) {
+        if (!keyCheck.test(valueKey)) {
           yield { type: ValueErrorType.IntersectUnevaluatedProperties, schema, path: `${path}/${valueKey}`, value, message: `Unexpected property` }
         }
       }
     }
     if (typeof schema.unevaluatedProperties === 'object') {
-      const schemaKeys = Types.KeyResolver.Resolve(schema)
-      const valueKeys = globalThis.Object.getOwnPropertyNames(value)
-      for (const valueKey of valueKeys) {
-        if (!schemaKeys.includes(valueKey)) {
+      const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema))
+      for (const valueKey of globalThis.Object.getOwnPropertyNames(value)) {
+        if (!keyCheck.test(valueKey)) {
           const next = Visit(schema.unevaluatedProperties, references, `${path}/${valueKey}`, value[valueKey]).next()
           if (!next.done) {
             yield next.value
@@ -317,7 +315,7 @@ export namespace ValueErrors {
       return yield { type: ValueErrorType.Null, schema, path, value, message: `Expected null` }
     }
   }
-  function* Number(schema: Types.TNumeric, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  function* Number(schema: Types.TNumber, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!IsNumber(value)) {
       return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` }
     }
@@ -396,16 +394,21 @@ export namespace ValueErrors {
     if (IsDefined<number>(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
       yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` }
     }
-    const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
-    const regex = new RegExp(keyPattern)
-    if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {
-      const numeric = keyPattern === Types.PatternNumberExact
-      const type = numeric ? ValueErrorType.RecordKeyNumeric : ValueErrorType.RecordKeyString
-      const message = numeric ? 'Expected all object property keys to be numeric' : 'Expected all object property keys to be strings'
-      return yield { type, schema, path, value, message }
-    }
-    for (const [propKey, propValue] of globalThis.Object.entries(value)) {
-      yield* Visit(valueSchema, references, `${path}/${propKey}`, propValue)
+    const [patternKey, patternSchema] = globalThis.Object.entries(schema.patternProperties)[0]
+    const regex = new RegExp(patternKey)
+    for (const [propertyKey, propertyValue] of globalThis.Object.entries(value)) {
+      if (regex.test(propertyKey)) {
+        yield* Visit(patternSchema, references, `${path}/${propertyKey}`, propertyValue)
+        continue
+      }
+      if (typeof schema.additionalProperties === 'object') {
+        yield* Visit(schema.additionalProperties, references, `${path}/${propertyKey}`, propertyValue)
+      }
+      if (schema.additionalProperties === false) {
+        const propertyPath = `${path}/${propertyKey}`
+        const message = `Unexpected property '${propertyPath}'`
+        return yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: propertyPath, value: propertyValue, message }
+      }
     }
   }
   function* Ref(schema: Types.TRef<any>, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
diff --git a/src/system/system.ts b/src/system/system.ts
index a7dda5804..880f800e4 100644
--- a/src/system/system.ts
+++ b/src/system/system.ts
@@ -52,7 +52,6 @@ export namespace TypeSystem {
   export let AllowNaN: boolean = false
   /** Sets whether `null` should validate for void types. The default is `false` */
   export let AllowVoidNull: boolean = false
-
   // ------------------------------------------------------------------------
   // String Formats and Types
   // ------------------------------------------------------------------------
@@ -68,16 +67,4 @@ export namespace TypeSystem {
     Types.FormatRegistry.Set(format, check)
     return format
   }
-
-  // ------------------------------------------------------------------------
-  // Deprecated
-  // ------------------------------------------------------------------------
-  /** @deprecated Use `TypeSystem.Type()` instead. */
-  export function CreateType<Type, Options = object>(kind: string, check: (options: Options, value: unknown) => boolean) {
-    return Type<Type, Options>(kind, check)
-  }
-  /** @deprecated Use `TypeSystem.Format()` instead.  */
-  export function CreateFormat<F extends string>(format: F, check: (value: string) => boolean): F {
-    return Format<F>(format, check)
-  }
 }
diff --git a/src/typebox.ts b/src/typebox.ts
index 687c02be0..a76c35e3f 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -53,6 +53,22 @@ export type Assert<T, E> = T extends E ? T : never
 export type Evaluate<T> = T extends infer O ? { [K in keyof O]: O[K] } : never
 export type Ensure<T> = T extends infer U ? U : never
 // --------------------------------------------------------------------------
+// Type Assertions
+// --------------------------------------------------------------------------
+export type AssertProperties<T> = T extends TProperties ? T : TProperties
+export type AssertSchemas<T, E extends TSchema[] = TSchema[]> = T extends E ? T : []
+export type AssertSchema<T, E extends TSchema = TSchema> = T extends E ? T : TNever
+export type AssertObjects<T> = Assert<T, TObject[]>
+export type AssertObject<T> = Assert<T, TObject>
+export type AssertKeys<T> = Assert<T, Key[]>
+export type AssertKey<T> = Assert<T, Key>
+export type Key = keyof any
+// --------------------------------------------------------------------------
+// Type Normalization
+// --------------------------------------------------------------------------
+export type IntersectType<T extends TSchema[]> = T extends [] ? TNever : T extends [TSchema] ? AssertSchema<T[0]> : TIntersect<T>
+export type UnionType<T extends TSchema[]> = T extends [] ? TNever : T extends [TSchema] ? AssertSchema<T[0]> : TUnion<T>
+// --------------------------------------------------------------------------
 // Modifiers
 // --------------------------------------------------------------------------
 export type TModifier = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>
@@ -121,7 +137,6 @@ export type TAnySchema =
 // --------------------------------------------------------------------------
 // TNumeric
 // --------------------------------------------------------------------------
-export type TNumeric = TInteger | TNumber
 export interface NumericOptions<N extends number | bigint> extends SchemaOptions {
   exclusiveMaximum?: N
   exclusiveMinimum?: N
@@ -178,18 +193,38 @@ export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['retur
 // --------------------------------------------------------------------------
 // TComposite
 // --------------------------------------------------------------------------
-export type TCompositeEvaluateArray<T extends readonly TSchema[], P extends unknown[]> = { [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never }
-export type TCompositeArray<T extends readonly TObject[]> = { [K in keyof T]: T[K] extends TObject<infer P> ? P : {} }
-export type TCompositeProperties<I extends unknown, T extends readonly any[]> = Evaluate<T extends [infer A, ...infer B] ? TCompositeProperties<I & A, B> : I extends object ? I : {}>
-export interface TComposite<T extends TObject[] = TObject[]> extends TObject {
-  [Hint]: 'Composite' // Hint is required to differentiate between object | intersection on pick, omit, required, partial and keyof
-  static: Evaluate<TCompositeProperties<unknown, TCompositeEvaluateArray<T, this['params']>>>
-  properties: TCompositeProperties<unknown, TCompositeArray<T>>
-}
+export type TCompositeIsOptional<T extends TSchema> = T extends TOptional<T> | TReadonlyOptional<T> ? true : false
+// prettier-ignore
+export type TCompositeOptional<T extends TSchema[]> = T extends [infer L, ...infer R] 
+  ? TCompositeIsOptional<AssertSchema<L>> extends false ? false 
+  : TCompositeOptional<AssertSchemas<R>> : true
+export type TCompositeKeyOfUnion1<T extends TObject> = keyof T['properties']
+// prettier-ignore
+export type TCompositeKeyOfUnion2<T extends TObject[]> = T extends [infer L, ...infer R] 
+  ? TCompositeKeyOfUnion1<Assert<L, TObject>> | TCompositeKeyOfUnion2<Assert<R, TObject[]>> 
+  : never
+export type TCompositeKeyOf<T extends TObject[]> = UnionToTuple<TCompositeKeyOfUnion2<T>>
+export type TCompositePropertiesWithKey1<T extends TObject, K extends Key> = K extends keyof T['properties'] ? [T['properties'][K]] : []
+// prettier-ignore
+export type TCompositePropertiesWithKey2<T extends TObject[], K extends Key> = T extends [infer L, ...infer R] 
+  ? [...TCompositePropertiesWithKey1<AssertObject<L>, K>, ...TCompositePropertiesWithKey2<AssertObjects<R>, K>]
+  : []
+// prettier-ignore
+export type TCompositeObjectProperty<T extends TObject[], K extends Key> = TCompositePropertiesWithKey2<T, K> extends infer S ? 
+  TCompositeOptional<AssertSchemas<S>> extends true
+    ? { [_ in K]: TOptional<IntersectType<AssertSchemas<S>>> }
+    : { [_ in K]: IntersectType<AssertSchemas<S>> }
+  : {}
+// prettier-ignore
+export type TCompositeObjectsWithKeys<T extends TObject[], K extends Key[]> = K extends [infer L, ...infer R] ? L extends Key
+    ? TCompositeObjectProperty<T, L> & TCompositeObjectsWithKeys<T, AssertKeys<R>>
+    : {} 
+  : {}
+export type TComposite<T extends TObject[]> = Ensure<TObject<Evaluate<TCompositeObjectsWithKeys<T, AssertKeys<TCompositeKeyOf<T>>>>>>
 // --------------------------------------------------------------------------
 // TConstructor
 // --------------------------------------------------------------------------
-export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: Static<Assert<T[K], TSchema>, P> }]
+export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: Static<AssertSchema<T[K]>, P> }]
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Constructor'
   static: new (...param: TConstructorParameterArray<T, this['params']>) => Static<U, this['params']>
@@ -231,17 +266,17 @@ export interface TEnum<T extends Record<string, string | number> = Record<string
 // prettier-ignore
 export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = 
   (Static<L> extends Static<R> ? T : U) extends infer O ? 
-    UnionToTuple<O> extends [infer X, infer Y] ? TUnion<[Assert<X, TSchema>, Assert<Y, TSchema>]> : Assert<O, TSchema>
+    UnionToTuple<O> extends [infer X, infer Y] ? TUnion<[AssertSchema<X>, AssertSchema<Y>]> : AssertSchema<O>
   : never
 // --------------------------------------------------------------------------
 // TExclude
 // --------------------------------------------------------------------------
-export type TExcludeTemplateLiteralResult<T extends string> = TUnionResult<Assert<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>, TSchema[]>>
+export type TExcludeTemplateLiteralResult<T extends string> = UnionType<AssertSchemas<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
 export type TExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Exclude<Static<T>, Static<U>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never
 // prettier-ignore
-export type TExcludeArray<T extends TSchema[], U extends TSchema> = Assert<UnionToTuple<{
-  [K in keyof T]: Static<Assert<T[K], TSchema>> extends Static<U> ? never : T[K]
-}[number]>, TSchema[]> extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never
+export type TExcludeArray<T extends TSchema[], U extends TSchema> = AssertSchemas<UnionToTuple<{
+  [K in keyof T]: Static<AssertSchema<T[K]>> extends Static<U> ? never : T[K]
+}[number]>> extends infer R ? UnionType<AssertSchemas<R>> : never
 // prettier-ignore
 export type TExclude<T extends TSchema, U extends TSchema> = 
   T extends TTemplateLiteral ? TExcludeTemplateLiteral<T, U> : 
@@ -250,12 +285,12 @@ export type TExclude<T extends TSchema, U extends TSchema> =
 // --------------------------------------------------------------------------
 // TExtract
 // --------------------------------------------------------------------------
-export type TExtractTemplateLiteralResult<T extends string> = TUnionResult<Assert<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>, TSchema[]>>
+export type TExtractTemplateLiteralResult<T extends string> = UnionType<AssertSchemas<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
 export type TExtractTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? TExtractTemplateLiteralResult<Assert<S, string>> : never
 // prettier-ignore
-export type TExtractArray<T extends TSchema[], U extends TSchema> = Assert<UnionToTuple<
-  {[K in keyof T]: Static<Assert<T[K], TSchema>> extends Static<U> ? T[K] : never
-}[number]>, TSchema[]> extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never
+export type TExtractArray<T extends TSchema[], U extends TSchema> = AssertSchemas<UnionToTuple<
+  {[K in keyof T]: Static<AssertSchema<T[K]>> extends Static<U> ? T[K] : never
+}[number]>> extends infer R ? UnionType<AssertSchemas<R>> : never
 // prettier-ignore
 export type TExtract<T extends TSchema, U extends TSchema> = 
   T extends TTemplateLiteral ? TExtractTemplateLiteral<T, U> : 
@@ -264,7 +299,7 @@ export type TExtract<T extends TSchema, U extends TSchema> =
 // --------------------------------------------------------------------------
 // TFunction
 // --------------------------------------------------------------------------
-export type TFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: Static<Assert<T[K], TSchema>, P> }]
+export type TFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: Static<AssertSchema<T[K]>, P> }]
 export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Function'
   static: (...param: TFunctionParameters<T, this['params']>) => Static<U, this['params']>
@@ -274,6 +309,46 @@ export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends T
   returns: U
 }
 // --------------------------------------------------------------------------
+// TIndex
+// --------------------------------------------------------------------------
+export type IndexKey = keyof any
+// prettier-ignore
+export type TIndexProperty<T extends TProperties, K extends IndexKey> = 
+  K extends keyof T ? [T[K]] : 
+  []
+// prettier-ignore
+export type TIndexTuple<T extends TSchema[], K extends IndexKey> = 
+  K extends keyof T ? [T[K]] : 
+  []
+// prettier-ignore
+export type TIndexComposite<T extends TSchema[], K extends IndexKey> = 
+  T extends [infer L, ...infer R] ? [...TIndexKey<AssertSchema<L>, K>, ...TIndexComposite<AssertSchemas<R>, K>] : 
+  []
+// prettier-ignore
+export type TIndexKey<T extends TSchema, K extends IndexKey> = 
+  T extends TRecursive<infer S> ? TIndexKey<S, K> :
+  T extends TIntersect<infer S> ? TIndexComposite<S, K> :
+  T extends TUnion<infer S>     ? TIndexComposite<S, K> :
+  T extends TObject<infer S>    ? TIndexProperty<S, K> : 
+  T extends TTuple<infer S>     ? TIndexTuple<S, K> :
+  T extends TArray<infer S>     ? S :
+  []
+// prettier-ignore
+export type TIndexKeys<T extends TSchema, K extends IndexKey[]> = 
+  K extends [infer L, ...infer R] ? [...TIndexKey<T, Assert<L, IndexKey>>, ...TIndexKeys<T, Assert<R, IndexKey[]>>] : 
+  []
+// prettier-ignore
+export type TIndex<T extends TSchema, K extends IndexKey[]> = 
+  TIndexKeys<T, K> extends infer R ?
+    T extends TRecursive<infer S> ? TIndex<S, K> :
+    T extends TTuple              ? UnionType<AssertSchemas<R>> :
+    T extends TIntersect          ? UnionType<AssertSchemas<R>> :
+    T extends TUnion              ? UnionType<AssertSchemas<R>> :
+    T extends TObject             ? UnionType<AssertSchemas<R>> :
+    T extends TArray              ? UnionType<AssertSchemas<R>> :
+    TNever : 
+  TNever
+// --------------------------------------------------------------------------
 // TInteger
 // --------------------------------------------------------------------------
 export interface TInteger extends TSchema, NumericOptions<number> {
@@ -290,29 +365,37 @@ export interface IntersectOptions extends SchemaOptions {
 }
 export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
   [Kind]: 'Intersect'
-  static: TupleToIntersect<{ [K in keyof T]: Static<Assert<T[K], TSchema>, this['params']> }>
+  static: TupleToIntersect<{ [K in keyof T]: Static<AssertSchema<T[K]>, this['params']> }>
   type?: 'object'
   allOf: [...T]
 }
 // --------------------------------------------------------------------------
 // TKeyOf
 // --------------------------------------------------------------------------
+export type TKeyOfProperties<T extends TSchema> = Static<T> extends infer S
+  ? UnionToTuple<
+      {
+        [K in keyof S]: TLiteral<`${Assert<K, TLiteralValue>}`>
+      }[keyof S]
+    >
+  : []
 // prettier-ignore
-export type TKeyOfTuple<T extends TSchema> = {
-  [K in keyof Static<T>]: TLiteral<Assert<K, TLiteralValue>>
-} extends infer U 
-  ? UnionToTuple<Exclude<{ [K in keyof U]: U[K] }[keyof U], undefined>> // optional yields undefined keys
-  : never
+export type TKeyOfIndicesArray<T extends TSchema[]> = UnionToTuple<keyof T & `${number}`>
+// prettier-ignore
+export type TKeyOfIndices<T extends TSchema[]> = AssertSchemas<TKeyOfIndicesArray<T> extends infer R ? {
+  [K in keyof R] : TLiteral<Assert<R[K], TLiteralValue>>
+}: []>
 // prettier-ignore
 export type TKeyOf<T extends TSchema = TSchema> = (
-  T extends TRecursive<infer S> ? TKeyOfTuple<S> :
-  T extends TComposite          ? TKeyOfTuple<T> :
-  T extends TIntersect          ? TKeyOfTuple<T> :
-  T extends TUnion              ? TKeyOfTuple<T> :
-  T extends TObject             ? TKeyOfTuple<T> :
+  T extends TRecursive<infer S> ? TKeyOfProperties<S> :
+  T extends TIntersect          ? TKeyOfProperties<T> :
+  T extends TUnion              ? TKeyOfProperties<T> :
+  T extends TObject             ? TKeyOfProperties<T> :
+  T extends TTuple<infer K>     ? TKeyOfIndices<K> :
+  T extends TArray              ? [TNumber] :
   T extends TRecord<infer K>    ? [K] :
   []
-) extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never
+) extends infer R ? UnionType<AssertSchemas<R>> : never
 // --------------------------------------------------------------------------
 // TLiteral
 // --------------------------------------------------------------------------
@@ -392,12 +475,11 @@ export interface TObject<T extends TProperties = TProperties> extends TSchema, O
 // --------------------------------------------------------------------------
 // TOmit
 // --------------------------------------------------------------------------
-export type TOmitArray<T extends TSchema[], K extends keyof any> = Assert<{ [K2 in keyof T]: TOmit<Assert<T[K2], TSchema>, K> }, TSchema[]>
-export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<Assert<Omit<T, K>, TProperties>>
+export type TOmitArray<T extends TSchema[], K extends keyof any> = AssertSchemas<{ [K2 in keyof T]: TOmit<AssertSchema<T[K2]>, K> }>
+export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<AssertProperties<Omit<T, K>>>
 // prettier-ignore
 export type TOmit<T extends TSchema = TSchema, K extends keyof any = keyof any> = 
   T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> :
-  T extends TComposite<infer S> ? TComposite<TOmitArray<S, K>> :
   T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : 
   T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : 
   T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : 
@@ -405,24 +487,23 @@ export type TOmit<T extends TSchema = TSchema, K extends keyof any = keyof any>
 // --------------------------------------------------------------------------
 // TParameters
 // --------------------------------------------------------------------------
-export type TParameters<T extends TFunction> = TTuple<T['parameters']>
+export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>
 // --------------------------------------------------------------------------
 // TPartial
 // --------------------------------------------------------------------------
-export type TPartialObjectArray<T extends TObject[]> = Assert<{ [K in keyof T]: TPartial<Assert<T[K], TObject>> }, TObject[]>
-export type TPartialArray<T extends TSchema[]> = Assert<{ [K in keyof T]: TPartial<Assert<T[K], TSchema>> }, TSchema[]>
+export type TPartialObjectArray<T extends TObject[]> = AssertSchemas<{ [K in keyof T]: TPartial<AssertSchema<T[K], TObject>> }, TObject[]>
+export type TPartialArray<T extends TSchema[]> = AssertSchemas<{ [K in keyof T]: TPartial<AssertSchema<T[K]>> }>
 // prettier-ignore
-export type TPartialProperties<T extends TProperties> = Evaluate<Assert<{
+export type TPartialProperties<T extends TProperties> = Evaluate<AssertProperties<{
   [K in keyof T]: 
     T[K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : 
     T[K] extends TReadonly<infer U>         ? TReadonlyOptional<U> : 
     T[K] extends TOptional<infer U>         ? TOptional<U>         : 
     TOptional<T[K]>
-}, TProperties>>
+}>>
 // prettier-ignore
 export type TPartial<T extends TSchema> =  
   T extends TRecursive<infer S> ? TRecursive<TPartial<S>> :   
-  T extends TComposite<infer S> ? TComposite<TPartialArray<S>> :
   T extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : 
   T extends TUnion<infer S>     ? TUnion<TPartialArray<S>> : 
   T extends TObject<infer S>    ? TObject<TPartialProperties<S>> : 
@@ -430,18 +511,17 @@ export type TPartial<T extends TSchema> =
 // --------------------------------------------------------------------------
 // TPick
 // --------------------------------------------------------------------------
-export type TPickArray<T extends TSchema[], K extends keyof any> = { [K2 in keyof T]: TPick<Assert<T[K2], TSchema>, K> }
+export type TPickArray<T extends TSchema[], K extends keyof any> = { [K2 in keyof T]: TPick<AssertSchema<T[K2]>, K> }
 // Note the key K will overlap for varying TProperties gathered via recursive union and intersect traversal. Because of this,
 // we need to extract only keys assignable to T on K2. This behavior is only required for Pick only.
 // prettier-ignore
 export type TPickProperties<T extends TProperties, K extends keyof any> = 
   Pick<T, Assert<Extract<K, keyof T>, keyof T>> extends infer R ? ({
-    [K in keyof R]: Assert<R[K], TSchema> extends TSchema ? R[K] : never
+    [K in keyof R]: AssertSchema<R[K]> extends TSchema ? R[K] : never
   }): never
 // prettier-ignore
 export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any> = 
   T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> :
-  T extends TComposite<infer S> ? TComposite<TPickArray<S, K>> :
   T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : 
   T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : 
   T extends TObject<infer S> ? TObject<TPickProperties<S, K>> :
@@ -471,7 +551,7 @@ export interface TRecord<K extends RecordKey = RecordKey, T extends TSchema = TS
   static: Record<Static<K>, Static<T, this['params']>>
   type: 'object'
   patternProperties: { [pattern: string]: T }
-  additionalProperties: false
+  additionalProperties: TAdditionalProperties
 }
 // --------------------------------------------------------------------------
 // TRecursive
@@ -501,19 +581,18 @@ export type TReturnType<T extends TFunction> = T['returns']
 // --------------------------------------------------------------------------
 // TRequired
 // --------------------------------------------------------------------------
-export type TRequiredArray<T extends TSchema[]> = Assert<{ [K in keyof T]: TRequired<Assert<T[K], TSchema>> }, TSchema[]>
+export type TRequiredArray<T extends TSchema[]> = AssertSchemas<{ [K in keyof T]: TRequired<AssertSchema<T[K]>> }>
 // prettier-ignore
-export type TRequiredProperties<T extends TProperties> = Evaluate<Assert<{
+export type TRequiredProperties<T extends TProperties> = Evaluate<AssertProperties<{
   [K in keyof T]: 
     T[K] extends TReadonlyOptional<infer U> ? TReadonly<U> : 
     T[K] extends TReadonly<infer U>         ? TReadonly<U> :  
     T[K] extends TOptional<infer U>         ? U : 
     T[K]
-}, TProperties>>
+}>>
 // prettier-ignore
 export type TRequired<T extends TSchema> = 
   T extends TRecursive<infer S> ? TRecursive<TRequired<S>> :   
-  T extends TComposite<infer S> ? TComposite<TRequiredArray<S>> : 
   T extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : 
   T extends TUnion<infer S>     ? TUnion<TRequiredArray<S>> : 
   T extends TObject<infer S>    ? TObject<TRequiredProperties<S>> : 
@@ -540,15 +619,15 @@ export type StringFormatOption =
   | 'json-pointer'
   | 'relative-json-pointer'
   | 'regex'
-export interface StringOptions<Format extends string> extends SchemaOptions {
+export interface StringOptions extends SchemaOptions {
   minLength?: number
   maxLength?: number
   pattern?: string
-  format?: Format
+  format?: string
   contentEncoding?: '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64'
   contentMediaType?: string
 }
-export interface TString<Format extends string = string> extends TSchema, StringOptions<Format> {
+export interface TString extends TSchema, StringOptions {
   [Kind]: 'String'
   static: string
   type: 'string'
@@ -570,17 +649,16 @@ export interface TSymbol extends TSchema, SchemaOptions {
 export type IsTemplateLiteralFiniteCheck<T> =
   T extends TTemplateLiteral<infer U> ? IsTemplateLiteralFiniteArray<Assert<U, TTemplateLiteralKind[]>> :    
   T extends TUnion<infer U> ? IsTemplateLiteralFiniteArray<Assert<U, TTemplateLiteralKind[]>> :    
-  T extends TString  ? false :
+  T extends TString ? false :
   T extends TBoolean ? false :
-  T extends TNumber  ? false :
+  T extends TNumber ? false :
   T extends TInteger ? false :
-  T extends TBigInt  ? false :
+  T extends TBigInt ? false :
   T extends TLiteral ? true  : 
   false
 // prettier-ignore
 export type IsTemplateLiteralFiniteArray<T extends TTemplateLiteralKind[]> = 
   T extends [infer L, ...infer R] ? IsTemplateLiteralFiniteCheck<L> extends false ? false : IsTemplateLiteralFiniteArray<Assert<R, TTemplateLiteralKind[]>> :
-  T extends [infer L] ? IsTemplateLiteralFiniteCheck<L> extends false ? false : true : 
   true
 export type IsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? IsTemplateLiteralFiniteArray<U> : false
 export type TTemplateLiteralKind = TUnion | TLiteral | TInteger | TTemplateLiteral | TNumber | TBigInt | TString | TBoolean | TNever
@@ -589,16 +667,16 @@ export type TTemplateLiteralConst<T, Acc extends string> =
   T extends TUnion<infer U> ? { [K in keyof U]: TTemplateLiteralUnion<Assert<[U[K]], TTemplateLiteralKind[]>, Acc> }[number] :
   T extends TTemplateLiteral ? `${Static<T>}` : 
   T extends TLiteral<infer U> ? `${U}` :
-  T extends TString  ? `${string}`  : 
-  T extends TNumber  ? `${number}`  : 
-  T extends TBigInt  ? `${bigint}`  : 
+  T extends TString ? `${string}` : 
+  T extends TNumber ? `${number}` : 
+  T extends TBigInt ? `${bigint}` : 
   T extends TBoolean ? `${boolean}` :
   never
 // prettier-ignore
 export type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string = ''> = 
-  T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` : 
-  T extends [infer L] ? `${TTemplateLiteralConst<L, Acc>}${Acc}` : 
+  T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` :
   Acc
+export type TTemplateLiteralKeyArray<T extends TTemplateLiteral> = AssertKeys<UnionToTuple<Static<T>>>
 export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
   [Kind]: 'TemplateLiteral'
   static: TTemplateLiteralUnion<T>
@@ -608,7 +686,7 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
 // --------------------------------------------------------------------------
 // TTuple
 // --------------------------------------------------------------------------
-export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? Assert<R, TSchema[]> : never
+export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? AssertSchemas<R> : never
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
   [Kind]: 'Tuple'
   static: { [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : T[K] }
@@ -630,17 +708,18 @@ export interface TUndefined extends TSchema {
 // --------------------------------------------------------------------------
 // TUnionOfLiteral
 // --------------------------------------------------------------------------
-export type TUnionOfLiteralArray<T extends TLiteral<string>[]> = { [K in keyof T]: Assert<T[K], TLiteral>['const'] }[number]
-export type TUnionOfLiteral<T extends TUnion<TLiteral<string>[]>> = TUnionOfLiteralArray<T['anyOf']>
-// --------------------------------------------------------------------------
-// TUnionResult - Used by Extract, Exclude and KeyOf for normalized union unwrap
-// --------------------------------------------------------------------------
-export type TUnionResult<T extends TSchema[]> = T extends [] ? TNever : T extends [infer S] ? S : TUnion<T>
+// prettier-ignore
+export type TLiteralUnionReduce<T extends TLiteral<string | number>[]> = 
+  T extends [infer L, ...infer R] ? [Assert<L, TLiteral<string | number>>['const'], ...TLiteralUnionReduce<Assert<R, TLiteral<string>[]>>] : 
+  []
+// prettier-ignore
+export type TLiteralUnion<T extends TUnion<TLiteral<string | number>[]>> = 
+  T extends TUnion<infer S> ? TLiteralUnionReduce<Assert<S, TLiteral<string | number>[]>> : []
 // --------------------------------------------------------------------------
 // TUnion
 // --------------------------------------------------------------------------
 // prettier-ignore
-export type TUnionTemplateLiteral<T extends TTemplateLiteral, S extends string = Static<T>> = Ensure<TUnionResult<Assert<UnionToTuple<{[K in S]: TLiteral<K>}[S]>,TLiteral[]>>>
+export type TUnionTemplateLiteral<T extends TTemplateLiteral, S extends string = Static<T>> = Ensure<UnionType<Assert<UnionToTuple<{[K in S]: TLiteral<K>}[S]>,TLiteral[]>>>
 export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
   [Kind]: 'Union'
   static: { [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : never }[number]
@@ -781,6 +860,9 @@ export namespace TypeGuard {
     }
     return true
   }
+  function IsAdditionalProperties(value: unknown): value is TAdditionalProperties {
+    return IsOptionalBoolean(value) || TSchema(value)
+  }
   function IsBigInt(value: unknown): value is bigint {
     return typeof value === 'bigint'
   }
@@ -948,20 +1030,25 @@ export namespace TypeGuard {
   export function TKind(schema: unknown): schema is Record<typeof Kind | string, unknown> {
     return IsObject(schema) && Kind in schema && typeof (schema as any)[Kind] === 'string' // TS 4.1.5: any required for symbol indexer
   }
+  /** Returns true if the given schema is TLiteral<string> */
+  export function TLiteralString(schema: unknown): schema is TLiteral<string> {
+    return TKind(schema) && schema[Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'string'
+  }
+  /** Returns true if the given schema is TLiteral<number> */
+  export function TLiteralNumber(schema: unknown): schema is TLiteral<number> {
+    return TKind(schema) && schema[Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'number'
+  }
+  /** Returns true if the given schema is TLiteral<boolean> */
+  export function TLiteralBoolean(schema: unknown): schema is TLiteral<boolean> {
+    return TKind(schema) && schema[Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'boolean'
+  }
+  /** Returns true if the given schema is TUnion<Literal<string>[]> */
+  export function TLiteralUnion(schema: unknown): schema is TUnion<TLiteral<string>[]> {
+    return TUnion(schema) && schema.anyOf.every((schema) => TLiteral(schema))
+  }
   /** Returns true if the given schema is TLiteral */
   export function TLiteral(schema: unknown): schema is TLiteral {
-    // prettier-ignore
-    return (
-      TKind(schema) &&
-      schema[Kind] === 'Literal' && 
-      IsOptionalString(schema.$id) && 
-      (
-        IsString(schema.const) || 
-        IsNumber(schema.const) || 
-        IsBoolean(schema.const) ||
-        IsBigInt(schema.const)
-      )
-    )
+    return TLiteralString(schema) || TLiteralNumber(schema) || TLiteralBoolean(schema)
   }
   /** Returns true if the given schema is TNever */
   export function TNever(schema: unknown): schema is TNever {
@@ -1013,7 +1100,7 @@ export namespace TypeGuard {
         schema.type === 'object' &&
         IsOptionalString(schema.$id) &&
         IsObject(schema.properties) &&
-        (IsOptionalBoolean(schema.additionalProperties) || IsOptionalSchema(schema.additionalProperties)) &&
+        IsAdditionalProperties(schema.additionalProperties) &&
         IsOptionalNumber(schema.minProperties) &&
         IsOptionalNumber(schema.maxProperties)
       )
@@ -1046,7 +1133,7 @@ export namespace TypeGuard {
       schema[Kind] === 'Record' && 
       schema.type === 'object' && 
       IsOptionalString(schema.$id) && 
-      schema.additionalProperties === false && 
+      IsAdditionalProperties(schema.additionalProperties) &&
       IsObject(schema.patternProperties))
     ) {
       return false
@@ -1171,10 +1258,6 @@ export namespace TypeGuard {
     }
     return true
   }
-  /** Returns true if the given schema is TUnion<Literal<string>[]> */
-  export function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral<string>[]> {
-    return TUnion(schema) && schema.anyOf.every((schema) => TLiteral(schema) && typeof schema.const === 'string')
-  }
   /** Returns true if the given schema is TUint8Array */
   export function TUint8Array(schema: unknown): schema is TUint8Array {
     return TKind(schema) && schema[Kind] === 'Uint8Array' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.instanceOf === 'Uint8Array' && IsOptionalNumber(schema.minByteLength) && IsOptionalNumber(schema.maxByteLength)
@@ -1760,10 +1843,10 @@ export namespace TypeExtends {
     return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   function Visit(left: TSchema, right: TSchema): TypeExtendsResult {
-    // template union remap
+    // Template Literal Union Unwrap
     if (TypeGuard.TTemplateLiteral(left)) return Visit(TemplateLiteralResolver.Resolve(left), right)
     if (TypeGuard.TTemplateLiteral(right)) return Visit(left, TemplateLiteralResolver.Resolve(right))
-    // standard extends
+    // Standard Extends
     if (TypeGuard.TAny(left)) return Any(left, right)
     if (TypeGuard.TArray(left)) return Array(left, right)
     if (TypeGuard.TBigInt(left)) return BigInt(left, right)
@@ -1828,6 +1911,35 @@ export namespace TypeClone {
   }
 }
 // --------------------------------------------------------------------------
+// IndexedAccessor
+// --------------------------------------------------------------------------
+export namespace IndexedAccessor {
+  function Intersect(schema: TIntersect, key: string): TSchema[] {
+    return schema.allOf.reduce((acc, schema) => [...acc, ...Visit(schema, key)], [] as TSchema[])
+  }
+  function Union(schema: TUnion, key: string): TSchema[] {
+    return schema.anyOf.reduce((acc, schema) => [...acc, ...Visit(schema, key)], [] as TSchema[])
+  }
+  function Object(schema: TObject, key: string): TSchema[] {
+    const keys = globalThis.Object.getOwnPropertyNames(schema.properties).filter((k) => k === key)
+    return keys.map((key) => schema.properties[key])
+  }
+  function Tuple(schema: TTuple, key: string): TSchema[] {
+    const items = schema.items === undefined ? [] : (schema.items as TSchema[])
+    return items.filter((_, index) => index.toString() === key.toString())
+  }
+  function Visit(schema: TSchema, key: string): TSchema[] {
+    if (schema[Kind] === 'Intersect') return Intersect(schema as TIntersect, key)
+    if (schema[Kind] === 'Union') return Union(schema as TUnion, key)
+    if (schema[Kind] === 'Object') return Object(schema as TObject, key)
+    if (schema[Kind] === 'Tuple') return Tuple(schema as TTuple, key)
+    return []
+  }
+  export function Resolve(schema: TSchema, keys: string[]): TSchema[] {
+    return keys.reduce((acc, key) => [...acc, ...Visit(schema, key)], [] as TSchema[])
+  }
+}
+// --------------------------------------------------------------------------
 // ObjectMap
 // --------------------------------------------------------------------------
 export namespace ObjectMap {
@@ -1859,28 +1971,59 @@ export namespace ObjectMap {
 // --------------------------------------------------------------------------
 // KeyResolver
 // --------------------------------------------------------------------------
+export interface KeyResolverOptions {
+  includePatterns: boolean
+}
 export namespace KeyResolver {
-  function IsKeyable(schema: TSchema) {
-    return TypeGuard.TIntersect(schema) || TypeGuard.TUnion(schema) || (TypeGuard.TObject(schema) && globalThis.Object.getOwnPropertyNames(schema.properties).length > 0)
+  function UnwrapPattern(key: string) {
+    return key[0] === '^' && key[key.length - 1] === '$' ? key.slice(1, key.length - 1) : key
   }
-  function Intersect(schema: TIntersect) {
-    return [...schema.allOf.filter((schema) => IsKeyable(schema)).reduce((set, schema) => Visit(schema).map((key) => set.add(key))[0], new Set<string>())]
+  function Intersect(schema: TIntersect, options: KeyResolverOptions): string[] {
+    return schema.allOf.reduce((acc, schema) => [...acc, ...Visit(schema, options)], [] as string[])
   }
-  function Union(schema: TUnion) {
-    const sets = schema.anyOf.filter((schema) => IsKeyable(schema)).map((inner) => Visit(inner))
+  function Union(schema: TUnion, options: KeyResolverOptions): string[] {
+    const sets = schema.anyOf.map((inner) => Visit(inner, options))
     return [...sets.reduce((set, outer) => outer.map((key) => (sets.every((inner) => inner.includes(key)) ? set.add(key) : set))[0], new Set<string>())]
   }
-  function Object(schema: TObject) {
+  function Object(schema: TObject, options: KeyResolverOptions): string[] {
     return globalThis.Object.keys(schema.properties)
   }
-  function Visit(schema: TSchema): string[] {
-    if (TypeGuard.TIntersect(schema)) return Intersect(schema)
-    if (TypeGuard.TUnion(schema)) return Union(schema)
-    if (TypeGuard.TObject(schema)) return Object(schema)
+  function Record(schema: TRecord, options: KeyResolverOptions): string[] {
+    return options.includePatterns ? globalThis.Object.keys(schema.patternProperties) : []
+  }
+  function Visit(schema: TSchema, options: KeyResolverOptions): string[] {
+    if (TypeGuard.TIntersect(schema)) return Intersect(schema, options)
+    if (TypeGuard.TUnion(schema)) return Union(schema, options)
+    if (TypeGuard.TObject(schema)) return Object(schema, options)
+    if (TypeGuard.TRecord(schema)) return Record(schema, options)
     return []
   }
-  export function Resolve<T extends TSchema>(schema: T) {
-    return Visit(schema)
+  /** Resolves an array of keys in this schema */
+  export function ResolveKeys(schema: TSchema, options: KeyResolverOptions): string[] {
+    return [...new Set(Visit(schema, options))]
+  }
+  /** Resolves a regular expression pattern matching all keys in this schema */
+  export function ResolvePattern(schema: TSchema): string {
+    const keys = ResolveKeys(schema, { includePatterns: true })
+    const pattern = keys.map((key) => `(${UnwrapPattern(key)})`)
+    return `^(${pattern.join('|')})$`
+  }
+}
+// --------------------------------------------------------------------------
+// KeyArrayResolver
+// --------------------------------------------------------------------------
+export namespace KeyArrayResolver {
+  /** Resolves an array of string[] keys from the given schema or array type. */
+  export function Resolve(schema: TSchema | string[]): string[] {
+    if (globalThis.Array.isArray(schema)) return schema
+    if (TypeGuard.TLiteralUnion(schema)) return schema.anyOf.map((schema) => schema.const)
+    if (TypeGuard.TLiteral(schema)) return [schema.const as string]
+    if (TypeGuard.TTemplateLiteral(schema)) {
+      const expression = TemplateLiteralParser.ParseExact(schema.pattern)
+      if (!TemplateLiteralFinite.Check(expression)) throw Error('KeyArrayResolver: Cannot resolve keys from infinite template expression')
+      return [...TemplateLiteralGenerator.Generate(expression)]
+    }
+    return []
   }
 }
 // --------------------------------------------------------------------------
@@ -1923,6 +2066,7 @@ export namespace TemplateLiteralPattern {
 // TemplateLiteralResolver
 // --------------------------------------------------------------------------------------
 export namespace TemplateLiteralResolver {
+  /** Resolves a template literal as a TUnion */
   export function Resolve(template: TTemplateLiteral): TString | TUnion | TLiteral {
     const expression = TemplateLiteralParser.ParseExact(template.pattern)
     if (!TemplateLiteralFinite.Check(expression)) return Type.String()
@@ -2186,19 +2330,19 @@ export class StandardTypeBuilder extends TypeBuilder {
         const property = TypeClone.Clone(schema, {})
         if (!optional.has(key)) delete property[Modifier]
         if (key in properties) {
-          const left = TypeExtends.Extends(properties[key], property) !== TypeExtendsResult.False
-          const right = TypeExtends.Extends(property, properties[key]) !== TypeExtendsResult.False
-          if (!left && !right) properties[key] = Type.Never()
-          if (!left && right) properties[key] = property
+          properties[key] = TypeGuard.TIntersect(properties[key]) ? this.Intersect([...properties[key].allOf, property]) : this.Intersect([properties[key], property])
         } else {
           properties[key] = property
         }
       }
     }
+    for (const key of globalThis.Object.getOwnPropertyNames(properties)) {
+      properties[key] = optional.has(key) ? this.Optional(properties[key]) : properties[key]
+    }
     if (required.size > 0) {
-      return this.Create({ ...options, [Kind]: 'Object', [Hint]: 'Composite', type: 'object', properties, required: [...required] })
+      return this.Create({ ...options, [Kind]: 'Object', type: 'object', properties, required: [...required] })
     } else {
-      return this.Create({ ...options, [Kind]: 'Object', [Hint]: 'Composite', type: 'object', properties })
+      return this.Create({ ...options, [Kind]: 'Object', type: 'object', properties })
     }
   }
   /** `[Standard]` Creates a Enum type */
@@ -2214,9 +2358,9 @@ export class StandardTypeBuilder extends TypeBuilder {
       case TypeExtendsResult.Union:
         return this.Union([TypeClone.Clone(trueType, options), TypeClone.Clone(falseType, options)]) as any as TExtends<L, R, T, U>
       case TypeExtendsResult.True:
-        return TypeClone.Clone(trueType, options) as TExtends<L, R, T, U>
+        return TypeClone.Clone(trueType, options) as unknown as TExtends<L, R, T, U>
       case TypeExtendsResult.False:
-        return TypeClone.Clone(falseType, options) as TExtends<L, R, T, U>
+        return TypeClone.Clone(falseType, options) as unknown as TExtends<L, R, T, U>
     }
   }
   /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
@@ -2241,6 +2385,29 @@ export class StandardTypeBuilder extends TypeBuilder {
       return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? TypeClone.Clone(left, options) : this.Never(options)) as any
     }
   }
+  /** `[Standard]` Returns indexed property types for the given keys */
+  public Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, K>
+  /** `[Standard]` Returns indexed property types for the given keys */
+  public Index<T extends TSchema, K extends TUnion<TLiteral<string | number>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TLiteralUnion<K>>
+  /** `[Standard]` Returns indexed property types for the given keys */
+  public Index<T extends TSchema, K extends TLiteral<string | number>>(schema: T, key: K, options?: SchemaOptions): TIndex<T, [K['const']]>
+  /** `[Standard]` Returns indexed property types for the given keys */
+  public Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyArray<K>>
+  /** `[Standard]` Returns indexed property types for the given keys */
+  public Index<T extends TArray, K extends TNumber>(schema: T, key: K, options?: SchemaOptions): T['items']
+  /** `[Standard]` Returns indexed property types for the given keys */
+  public Index<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TIndex<T, never>
+  /** `[Standard]` Returns indexed property types for the given keys */
+  public Index(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
+    const keys = KeyArrayResolver.Resolve(unresolved)
+
+    if (TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved)) {
+      return TypeClone.Clone(schema.items, options)
+    }
+    const resolved = IndexedAccessor.Resolve(schema, keys as any)
+    const cloned = resolved.map((schema) => TypeClone.Clone(schema, {}))
+    return this.Union(cloned, options)
+  }
   /** `[Standard]` Creates an Integer type */
   public Integer(options: NumericOptions<number> = {}): TInteger {
     return this.Create({ ...options, [Kind]: 'Integer', type: 'integer' })
@@ -2267,14 +2434,20 @@ export class StandardTypeBuilder extends TypeBuilder {
   public KeyOf<T extends TSchema>(schema: T, options: SchemaOptions = {}): TKeyOf<T> {
     if (TypeGuard.TRecord(schema)) {
       const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
-      if (pattern === PatternNumberExact) return this.Number(options) as TKeyOf<T>
-      if (pattern === PatternStringExact) return this.String(options) as TKeyOf<T>
+      if (pattern === PatternNumberExact) return this.Number(options) as unknown as TKeyOf<T>
+      if (pattern === PatternStringExact) return this.String(options) as unknown as TKeyOf<T>
       throw Error('StandardTypeBuilder: Unable to resolve key type from Record key pattern')
+    } else if (TypeGuard.TTuple(schema)) {
+      const items = schema.items === undefined ? [] : schema.items
+      const literals = items.map((_, index) => Type.Literal(index))
+      return this.Union(literals, options) as unknown as TKeyOf<T>
+    } else if (TypeGuard.TArray(schema)) {
+      return this.Number(options) as unknown as TKeyOf<T>
     } else {
-      const resolved = KeyResolver.Resolve(schema)
-      if (resolved.length === 0) return this.Never(options) as TKeyOf<T>
-      const literals = resolved.map((key) => this.Literal(key))
-      return this.Union(literals, options) as TKeyOf<T>
+      const keys = KeyResolver.ResolveKeys(schema, { includePatterns: false })
+      if (keys.length === 0) return this.Never(options) as TKeyOf<T>
+      const literals = keys.map((key) => this.Literal(key))
+      return this.Union(literals, options) as unknown as TKeyOf<T>
     }
   }
   /** `[Standard]` Creates a Literal type */
@@ -2313,18 +2486,15 @@ export class StandardTypeBuilder extends TypeBuilder {
   /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TOmit<T, K[number]>
   /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
-  public Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionOfLiteral<K>>
+  public Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TLiteralUnion<K>[number]>
   /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TOmit<T, K['const']>
   /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+  public Omit<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TOmit<T, TTemplateLiteralKeyArray<K>[number]>
+  /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TOmit<T, never>
-  public Omit(schema: TSchema, unresolved: unknown, options: SchemaOptions = {}): any {
-    // prettier-ignore
-    const keys = 
-      TypeGuard.TUnionLiteral(unresolved) ? unresolved.anyOf.map((schema) => schema.const) : 
-      TypeGuard.TLiteral(unresolved) ? [unresolved.const] : 
-      TypeGuard.TNever(unresolved) ? [] :
-      (unresolved as string[])
+  public Omit(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
+    const keys = KeyArrayResolver.Resolve(unresolved)
     // prettier-ignore
     return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
       if (schema.required) {
@@ -2359,18 +2529,15 @@ export class StandardTypeBuilder extends TypeBuilder {
   /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TPick<T, K[number]>
   /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
-  public Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionOfLiteral<K>>
+  public Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TLiteralUnion<K>[number]>
   /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TPick<T, K['const']>
   /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+  public Pick<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TPick<T, TTemplateLiteralKeyArray<K>[number]>
+  /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TPick<T, never>
-  public Pick(schema: TSchema, unresolved: unknown, options: SchemaOptions = {}): any {
-    // prettier-ignore
-    const keys = 
-      TypeGuard.TUnionLiteral(unresolved) ? unresolved.anyOf.map((schema) => schema.const) : 
-      TypeGuard.TLiteral(unresolved) ? [unresolved.const] : 
-      TypeGuard.TNever(unresolved) ? [] :
-      (unresolved as string[])
+  public Pick(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
+    const keys = KeyArrayResolver.Resolve(unresolved)
     // prettier-ignore
     return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
       if (schema.required) {
@@ -2400,8 +2567,8 @@ export class StandardTypeBuilder extends TypeBuilder {
       // prettier-ignore
       return TemplateLiteralFinite.Check(expression)
         ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(schema, {}) }), {} as TProperties), options))
-        : this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false })
-    } else if (TypeGuard.TUnionLiteral(key)) {
+        : this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema, {}) }})
+    } else if (TypeGuard.TLiteralUnion(key)) {
       if (key.anyOf.every((schema) => TypeGuard.TLiteral(schema) && (typeof schema.const === 'string' || typeof schema.const === 'number'))) {
         const properties = key.anyOf.reduce((acc: any, literal: any) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {} as TProperties)
         return this.Object(properties, { ...options, [Hint]: 'Record' })
@@ -2412,10 +2579,10 @@ export class StandardTypeBuilder extends TypeBuilder {
       } else throw Error('TypeBuilder: Record key can only be derived from literals of number or string')
     } else if (TypeGuard.TInteger(key) || TypeGuard.TNumber(key)) {
       const pattern = PatternNumberExact
-      return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false })
+      return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) } })
     } else if (TypeGuard.TString(key)) {
       const pattern = key.pattern === undefined ? PatternStringExact : key.pattern
-      return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false })
+      return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) } })
     } else {
       throw Error(`StandardTypeBuilder: Invalid Record Key`)
     }
@@ -2451,7 +2618,7 @@ export class StandardTypeBuilder extends TypeBuilder {
     }, options)
   }
   /** `[Standard]` Creates a String type */
-  public String<Format extends string>(options: StringOptions<StringFormatOption | Format> = {}): TString<Format> {
+  public String(options: StringOptions = {}): TString {
     return this.Create({ ...options, [Kind]: 'String', type: 'string' })
   }
   /** `[Standard]` Creates a template literal type */
diff --git a/src/value/check.ts b/src/value/check.ts
index d745b2979..9b62e00fe 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -175,18 +175,17 @@ export namespace ValueCheck {
     return true
   }
   function Intersect(schema: Types.TIntersect, references: Types.TSchema[], value: any): boolean {
-    if (!schema.allOf.every((schema) => Visit(schema, references, value))) {
-      return false
-    } else if (schema.unevaluatedProperties === false) {
-      const schemaKeys = Types.KeyResolver.Resolve(schema)
-      const valueKeys = globalThis.Object.getOwnPropertyNames(value)
-      return valueKeys.every((key) => schemaKeys.includes(key))
+    const check1 = schema.allOf.every((schema) => Visit(schema, references, value))
+    if (schema.unevaluatedProperties === false) {
+      const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema))
+      const check2 = globalThis.Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key))
+      return check1 && check2
     } else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
-      const schemaKeys = Types.KeyResolver.Resolve(schema)
-      const valueKeys = globalThis.Object.getOwnPropertyNames(value)
-      return valueKeys.every((key) => schemaKeys.includes(key) || Visit(schema.unevaluatedProperties as Types.TSchema, references, value[key]))
+      const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema))
+      const check2 = globalThis.Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key) || Visit(schema.unevaluatedProperties as Types.TSchema, references, value[key]))
+      return check1 && check2
     } else {
-      return true
+      return check1
     }
   }
   function Literal(schema: Types.TLiteral, references: Types.TSchema[], value: any): boolean {
@@ -276,15 +275,20 @@ export namespace ValueCheck {
     if (IsDefined<number>(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
       return false
     }
-    const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
-    const regex = new RegExp(keyPattern)
-    if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {
-      return false
-    }
-    for (const propValue of globalThis.Object.values(value)) {
-      if (!Visit(valueSchema, references, propValue)) return false
-    }
-    return true
+    const [patternKey, patternSchema] = globalThis.Object.entries(schema.patternProperties)[0]
+    const regex = new RegExp(patternKey)
+    return globalThis.Object.entries(value).every(([key, value]) => {
+      if (regex.test(key)) {
+        return Visit(patternSchema, references, value)
+      }
+      if (typeof schema.additionalProperties === 'object') {
+        return Visit(schema.additionalProperties, references, value)
+      }
+      if (schema.additionalProperties === false) {
+        return false
+      }
+      return true
+    })
   }
   function Ref(schema: Types.TRef<any>, references: Types.TSchema[], value: any): boolean {
     const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
diff --git a/test/runtime/compiler/intersect.ts b/test/runtime/compiler/intersect.ts
index 610dd7f30..0f9d5272c 100644
--- a/test/runtime/compiler/intersect.ts
+++ b/test/runtime/compiler/intersect.ts
@@ -80,4 +80,140 @@ describe('type/compiler/Intersect', () => {
     const T = Type.Intersect([A, B])
     Fail(T, { x: 1, y: 1 })
   })
+
+  it('unevaluatedProperties with Record 1', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: false,
+      },
+    )
+    Ok(T, { x: 1, y: 2 })
+  })
+  it('unevaluatedProperties with Record 2', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: false,
+      },
+    )
+    Ok(T, { x: 1, y: 2, 0: 'hello' })
+  })
+  it('unevaluatedProperties with Record 3', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: false,
+      },
+    )
+    Fail(T, { x: 1, y: 2, 0: 1 })
+  })
+  it('unevaluatedProperties with Record 4', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Ok(T, { x: 1, y: 2 })
+  })
+  it('unevaluatedProperties with Record 5', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Ok(T, { x: 1, y: 2, z: true })
+  })
+  it('unevaluatedProperties with Record 6', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Fail(T, { x: 1, y: 2, z: 1 })
+  })
+  it('unevaluatedProperties with Record 7', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Ok(T, { x: 1, y: 2, 0: '' })
+  })
+  it('unevaluatedProperties with Record 8', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Ok(T, { x: 1, y: 2, 0: '', z: true })
+  })
+  it('unevaluatedProperties with Record 9', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Fail(T, { x: 1, y: 2, 0: '', z: 1 })
+  })
 })
diff --git a/test/runtime/compiler/record.ts b/test/runtime/compiler/record.ts
index 428c35f92..2f39b5684 100644
--- a/test/runtime/compiler/record.ts
+++ b/test/runtime/compiler/record.ts
@@ -2,6 +2,20 @@ import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
 describe('type/compiler/Record', () => {
+  // -------------------------------------------------------------
+  // TypeBox Only: Date and Record
+  // -------------------------------------------------------------
+  it('Should fail record with Date', () => {
+    const T = Type.Record(Type.String(), Type.String())
+    Fail(T, new Date())
+  })
+  it('Should fail record with Uint8Array', () => {
+    const T = Type.Record(Type.String(), Type.String())
+    Fail(T, new Uint8Array())
+  })
+  // -------------------------------------------------------------
+  // Standard Assertions
+  // -------------------------------------------------------------
   it('Should validate when all property values are numbers', () => {
     const T = Type.Record(Type.String(), Type.Number())
     Ok(T, { a: 1, b: 2, c: 3 })
@@ -65,7 +79,7 @@ describe('type/compiler/Record', () => {
   })
   it('Should should not validate when specifying regular expressions and passing invalid property', () => {
     const K = Type.RegEx(/^op_.*$/)
-    const T = Type.Record(K, Type.Number())
+    const T = Type.Record(K, Type.Number(), { additionalProperties: false })
     Fail(T, {
       op_a: 1,
       op_b: 2,
@@ -80,11 +94,11 @@ describe('type/compiler/Record', () => {
     Ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
   })
   it('Should validate when all property keys are integers, but one property is a string with varying type', () => {
-    const T = Type.Record(Type.Integer(), Type.Number())
+    const T = Type.Record(Type.Integer(), Type.Number(), { additionalProperties: false })
     Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
   it('Should not validate if passing a leading zeros for integers keys', () => {
-    const T = Type.Record(Type.Integer(), Type.Number())
+    const T = Type.Record(Type.Integer(), Type.Number(), { additionalProperties: false })
     Fail(T, {
       '00': 1,
       '01': 2,
@@ -93,7 +107,7 @@ describe('type/compiler/Record', () => {
     })
   })
   it('Should not validate if passing a signed integers keys', () => {
-    const T = Type.Record(Type.Integer(), Type.Number())
+    const T = Type.Record(Type.Integer(), Type.Number(), { additionalProperties: false })
     Fail(T, {
       '-0': 1,
       '-1': 2,
@@ -109,11 +123,11 @@ describe('type/compiler/Record', () => {
     Ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
   })
   it('Should validate when all property keys are numbers, but one property is a string with varying type', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
+    const T = Type.Record(Type.Number(), Type.Number(), { additionalProperties: false })
     Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
   it('Should not validate if passing a leading zeros for numeric keys', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
+    const T = Type.Record(Type.Number(), Type.Number(), { additionalProperties: false })
     Fail(T, {
       '00': 1,
       '01': 2,
@@ -122,7 +136,7 @@ describe('type/compiler/Record', () => {
     })
   })
   it('Should not validate if passing a signed numeric keys', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
+    const T = Type.Record(Type.Number(), Type.Number(), { additionalProperties: false })
     Fail(T, {
       '-0': 1,
       '-1': 2,
@@ -131,15 +145,30 @@ describe('type/compiler/Record', () => {
     })
   })
   it('Should not validate when all property keys are numbers, but one property is a string with varying type', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
+    const T = Type.Record(Type.Number(), Type.Number(), { additionalProperties: false })
     Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
-  it('Should fail record with Date', () => {
-    const T = Type.Record(Type.String(), Type.String())
-    Fail(T, new Date())
+  // ------------------------------------------------------------
+  // AdditionalProperties
+  // ------------------------------------------------------------
+  it('AdditionalProperties 1', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: true })
+    Ok(T, { 1: '', 2: '', x: 1, y: 2, z: 3 })
   })
-  it('Should fail record with Uint8Array', () => {
-    const T = Type.Record(Type.String(), Type.String())
-    Fail(T, new Uint8Array())
+  it('AdditionalProperties 2', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: false })
+    Ok(T, { 1: '', 2: '', 3: '' })
+  })
+  it('AdditionalProperties 3', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: false })
+    Fail(T, { 1: '', 2: '', x: '' })
+  })
+  it('AdditionalProperties 4', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: Type.Boolean() })
+    Fail(T, { 1: '', 2: '', x: '' })
+  })
+  it('AdditionalProperties 5', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: Type.Boolean() })
+    Ok(T, { 1: '', 2: '', x: true })
   })
 })
diff --git a/test/runtime/schema/intersect.ts b/test/runtime/schema/intersect.ts
index d3de6c365..55f4f0659 100644
--- a/test/runtime/schema/intersect.ts
+++ b/test/runtime/schema/intersect.ts
@@ -80,4 +80,140 @@ describe('type/schema/Intersect', () => {
     const T = Type.Intersect([A, B])
     Fail(T, { x: 1, y: 1 })
   })
+
+  it('unevaluatedProperties with Record 1', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: false,
+      },
+    )
+    Ok(T, { x: 1, y: 2 })
+  })
+  it('unevaluatedProperties with Record 2', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: false,
+      },
+    )
+    Ok(T, { x: 1, y: 2, 0: 'hello' })
+  })
+  it('unevaluatedProperties with Record 3', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: false,
+      },
+    )
+    Fail(T, { x: 1, y: 2, 0: 1 })
+  })
+  it('unevaluatedProperties with Record 4', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Ok(T, { x: 1, y: 2 })
+  })
+  it('unevaluatedProperties with Record 5', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Ok(T, { x: 1, y: 2, z: true })
+  })
+  it('unevaluatedProperties with Record 6', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Fail(T, { x: 1, y: 2, z: 1 })
+  })
+  it('unevaluatedProperties with Record 7', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Ok(T, { x: 1, y: 2, 0: '' })
+  })
+  it('unevaluatedProperties with Record 8', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Ok(T, { x: 1, y: 2, 0: '', z: true })
+  })
+  it('unevaluatedProperties with Record 9', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Fail(T, { x: 1, y: 2, 0: '', z: 1 })
+  })
 })
diff --git a/test/runtime/schema/record.ts b/test/runtime/schema/record.ts
index bacc80f42..d772d8817 100644
--- a/test/runtime/schema/record.ts
+++ b/test/runtime/schema/record.ts
@@ -65,7 +65,7 @@ describe('type/schema/Record', () => {
   })
   it('Should should not validate when specifying regular expressions and passing invalid property', () => {
     const K = Type.RegEx(/^op_.*$/)
-    const T = Type.Record(K, Type.Number())
+    const T = Type.Record(K, Type.Number(), { additionalProperties: false })
     Fail(T, {
       op_a: 1,
       op_b: 2,
@@ -80,11 +80,11 @@ describe('type/schema/Record', () => {
     Ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
   })
   it('Should validate when all property keys are integers, but one property is a string with varying type', () => {
-    const T = Type.Record(Type.Integer(), Type.Number())
+    const T = Type.Record(Type.Integer(), Type.Number(), { additionalProperties: false })
     Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
   it('Should not validate if passing a leading zeros for integers keys', () => {
-    const T = Type.Record(Type.Integer(), Type.Number())
+    const T = Type.Record(Type.Integer(), Type.Number(), { additionalProperties: false })
     Fail(T, {
       '00': 1,
       '01': 2,
@@ -93,7 +93,7 @@ describe('type/schema/Record', () => {
     })
   })
   it('Should not validate if passing a signed integers keys', () => {
-    const T = Type.Record(Type.Integer(), Type.Number())
+    const T = Type.Record(Type.Integer(), Type.Number(), { additionalProperties: false })
     Fail(T, {
       '-0': 1,
       '-1': 2,
@@ -109,11 +109,11 @@ describe('type/schema/Record', () => {
     Ok(T, { '0': 1, '1': 2, '2': 3, '3': 4 })
   })
   it('Should validate when all property keys are numbers, but one property is a string with varying type', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
+    const T = Type.Record(Type.Number(), Type.Number(), { additionalProperties: false })
     Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
   it('Should not validate if passing a leading zeros for numeric keys', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
+    const T = Type.Record(Type.Number(), Type.Number(), { additionalProperties: false })
     Fail(T, {
       '00': 1,
       '01': 2,
@@ -122,7 +122,7 @@ describe('type/schema/Record', () => {
     })
   })
   it('Should not validate if passing a signed numeric keys', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
+    const T = Type.Record(Type.Number(), Type.Number(), { additionalProperties: false })
     Fail(T, {
       '-0': 1,
       '-1': 2,
@@ -131,7 +131,30 @@ describe('type/schema/Record', () => {
     })
   })
   it('Should not validate when all property keys are numbers, but one property is a string with varying type', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
+    const T = Type.Record(Type.Number(), Type.Number(), { additionalProperties: false })
     Fail(T, { '0': 1, '1': 2, '2': 3, '3': 4, a: 'hello' })
   })
+  // ------------------------------------------------------------
+  // AdditionalProperties
+  // ------------------------------------------------------------
+  it('AdditionalProperties 1', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: true })
+    Ok(T, { 1: '', 2: '', x: 1, y: 2, z: 3 })
+  })
+  it('AdditionalProperties 2', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: false })
+    Ok(T, { 1: '', 2: '', 3: '' })
+  })
+  it('AdditionalProperties 3', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: false })
+    Fail(T, { 1: '', 2: '', x: '' })
+  })
+  it('AdditionalProperties 4', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: Type.Boolean() })
+    Fail(T, { 1: '', 2: '', x: '' })
+  })
+  it('AdditionalProperties 5', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: Type.Boolean() })
+    Ok(T, { 1: '', 2: '', x: true })
+  })
 })
diff --git a/test/runtime/system/system.ts b/test/runtime/system/system.ts
index dc7c51df5..33e3373db 100644
--- a/test/runtime/system/system.ts
+++ b/test/runtime/system/system.ts
@@ -135,9 +135,13 @@ describe('system/TypeSystem/AllowArrayObjects', () => {
     const T = Type.Record(Type.String(), Type.Number())
     Ok(T, [0, 1, 2])
   })
-  it('Should not validate arrays as Records with Number Keys', () => {
+  it('Should validate arrays as Records with Number Keys', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    Ok(T, [0, 1, 2])
+  })
+  it('Should validate arrays as Records with Integer Keys', () => {
     const T = Type.Record(Type.Integer(), Type.Number())
-    Fail(T, [0, 1, 2])
+    Ok(T, [0, 1, 2])
   })
   it('Should not validate arrays as Records with Object Values', () => {
     const T = Type.Record(
diff --git a/test/runtime/type/guard/composite.ts b/test/runtime/type/guard/composite.ts
index 2ace75790..c9d7d611e 100644
--- a/test/runtime/type/guard/composite.ts
+++ b/test/runtime/type/guard/composite.ts
@@ -10,11 +10,11 @@ describe('type/guard/TComposite', () => {
   })
   it('Should guard for overlapping properties', () => {
     const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.Number() })])
-    Assert.equal(TypeGuard.TNumber(T.properties.x), true)
-  })
-  it('Should guard for illogical intersection and yield never', () => {
-    const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.String() })])
-    Assert.equal(TypeGuard.TNever(T.properties.x), true)
+    Assert.equal(TypeGuard.TIntersect(T.properties.x), true)
+    // @ts-ignore
+    Assert.equal(TypeGuard.TNumber(T.properties.x.allOf[0]), true)
+    // @ts-ignore
+    Assert.equal(TypeGuard.TNumber(T.properties.x.allOf[1]), true)
   })
   it('Should not produce optional property if all properties are not optional', () => {
     const T = Type.Composite([Type.Object({ x: Type.Optional(Type.Number()) }), Type.Object({ x: Type.Number() })])
diff --git a/test/runtime/type/guard/index.ts b/test/runtime/type/guard/index.ts
index d88632516..907c82e4a 100644
--- a/test/runtime/type/guard/index.ts
+++ b/test/runtime/type/guard/index.ts
@@ -8,6 +8,7 @@ import './date'
 import './exclude'
 import './extract'
 import './function'
+import './indexed'
 import './integer'
 import './literal'
 import './intersect'
diff --git a/test/runtime/type/guard/indexed.ts b/test/runtime/type/guard/indexed.ts
new file mode 100644
index 000000000..0ddd02fe9
--- /dev/null
+++ b/test/runtime/type/guard/indexed.ts
@@ -0,0 +1,98 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TIndex', () => {
+  it('Should Index 1', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+    })
+    const I = Type.Index(T, ['x'])
+    Assert.deepEqual(TypeGuard.TNumber(I), true)
+  })
+  it('Should Index 2', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+    })
+    const I = Type.Index(T, ['x', 'y'])
+    Assert.deepEqual(TypeGuard.TUnion(I), true)
+    Assert.deepEqual(TypeGuard.TNumber(I.anyOf[0]), true)
+    Assert.deepEqual(TypeGuard.TString(I.anyOf[1]), true)
+  })
+  it('Should Index 3', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+    })
+    const I = Type.Index(T, Type.KeyOf(T))
+    Assert.deepEqual(TypeGuard.TUnion(I), true)
+    Assert.deepEqual(TypeGuard.TNumber(I.anyOf[0]), true)
+    Assert.deepEqual(TypeGuard.TString(I.anyOf[1]), true)
+  })
+  it('Should Index 4', () => {
+    const T = Type.Object({
+      ab: Type.Number(),
+      ac: Type.String(),
+    })
+    const I = Type.Index(T, Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])]))
+    Assert.deepEqual(TypeGuard.TUnion(I), true)
+    Assert.deepEqual(TypeGuard.TNumber(I.anyOf[0]), true)
+    Assert.deepEqual(TypeGuard.TString(I.anyOf[1]), true)
+  })
+  it('Should Index 5', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.String() })])
+    const I = Type.Index(T, ['x', 'y'])
+    Assert.deepEqual(TypeGuard.TUnion(I), true)
+    Assert.deepEqual(TypeGuard.TNumber(I.anyOf[0]), true)
+    Assert.deepEqual(TypeGuard.TString(I.anyOf[1]), true)
+  })
+  it('Should Index 6', () => {
+    const T = Type.Union([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.String() })])
+    const I = Type.Index(T, ['x'])
+    Assert.deepEqual(TypeGuard.TUnion(I), true)
+    Assert.deepEqual(TypeGuard.TNumber(I.anyOf[0]), true)
+    Assert.deepEqual(TypeGuard.TString(I.anyOf[1]), true)
+  })
+  it('Should Index 7', () => {
+    const T = Type.Array(Type.Null())
+    const I = Type.Index(T, Type.Number())
+    Assert.deepEqual(TypeGuard.TNull(I), true)
+  })
+  it('Should Index 6', () => {
+    const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
+    const I = Type.Index(T, [0])
+    Assert.deepEqual(TypeGuard.TLiteralString(I), true)
+    Assert.deepEqual(I.const, 'hello')
+  })
+  it('Should Index 8', () => {
+    const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
+    const I = Type.Index(T, [1])
+    Assert.deepEqual(TypeGuard.TLiteralString(I), true)
+    Assert.deepEqual(I.const, 'world')
+  })
+  it('Should Index 9', () => {
+    const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
+    const I = Type.Index(T, [0, 1])
+    Assert.deepEqual(TypeGuard.TUnion(I), true)
+    Assert.deepEqual(I.anyOf[0].const, 'hello')
+    Assert.deepEqual(I.anyOf[1].const, 'world')
+  })
+  it('Should Index 10', () => {
+    const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
+    const I = Type.Index(T, [1, 0])
+    Assert.deepEqual(TypeGuard.TUnion(I), true)
+    Assert.deepEqual(I.anyOf[0].const, 'world')
+    Assert.deepEqual(I.anyOf[1].const, 'hello')
+  })
+  it('Should Index 11', () => {
+    const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
+    const I = Type.Index(T, [0, 0, 0, 1])
+    Assert.deepEqual(TypeGuard.TUnion(I), true)
+    Assert.deepEqual(I.anyOf[0].const, 'hello')
+    Assert.deepEqual(I.anyOf[1].const, 'hello')
+    Assert.deepEqual(I.anyOf[2].const, 'hello')
+    Assert.deepEqual(I.anyOf[3].const, 'world')
+  })
+})
diff --git a/test/runtime/type/guard/keyof.ts b/test/runtime/type/guard/keyof.ts
index d1f6e9ecb..59c3067bd 100644
--- a/test/runtime/type/guard/keyof.ts
+++ b/test/runtime/type/guard/keyof.ts
@@ -3,7 +3,7 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/TKeyOf', () => {
-  it('Should guard for keyof TObject', () => {
+  it('Should KeyOf 1', () => {
     const T = Type.Object({
       x: Type.Number(),
       y: Type.Number(),
@@ -13,7 +13,7 @@ describe('type/guard/TKeyOf', () => {
     Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[0]), true)
     Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[1]), true)
   })
-  it('Should guard for keyof TRecursive', () => {
+  it('Should KeyOf 2', () => {
     const T = Type.Recursive((Self) =>
       Type.Object({
         x: Type.Number(),
@@ -25,7 +25,7 @@ describe('type/guard/TKeyOf', () => {
     Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[0]), true)
     Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[1]), true)
   })
-  it('Should guard for keyof TIntersect', () => {
+  it('Should KeyOf 3', () => {
     const T = Type.Intersect([
       Type.Object({
         x: Type.Number(),
@@ -39,7 +39,7 @@ describe('type/guard/TKeyOf', () => {
     Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[0]), true)
     Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[1]), true)
   })
-  it('Should guard for keyof TUnion', () => {
+  it('Should KeyOf 4', () => {
     const T = Type.Union([
       Type.Object({
         x: Type.Number(),
@@ -51,9 +51,26 @@ describe('type/guard/TKeyOf', () => {
     const K = Type.KeyOf(T)
     Assert.deepEqual(TypeGuard.TNever(K), true)
   })
-  it('Should guard for keyof TNull', () => {
+  it('Should KeyOf 5', () => {
     const T = Type.Null()
     const K = Type.KeyOf(T)
     Assert.deepEqual(TypeGuard.TNever(K), true)
   })
+  it('Should KeyOf 6', () => {
+    const T = Type.Array(Type.Number())
+    const K = Type.KeyOf(T)
+    Assert.deepEqual(TypeGuard.TNumber(K), true)
+  })
+  it('Should KeyOf 7', () => {
+    const T = Type.Tuple([])
+    const K = Type.KeyOf(T)
+    Assert.deepEqual(TypeGuard.TNever(K), true)
+  })
+  it('Should KeyOf 8', () => {
+    const T = Type.Tuple([Type.Number(), Type.Null()])
+    const K = Type.KeyOf(T)
+    Assert.deepEqual(TypeGuard.TUnion(K), true)
+    Assert.deepEqual(K.anyOf[0].const, '0')
+    Assert.deepEqual(K.anyOf[1].const, '1')
+  })
 })
diff --git a/test/runtime/type/guard/omit.ts b/test/runtime/type/guard/omit.ts
index 7a6055a27..debf380db 100644
--- a/test/runtime/type/guard/omit.ts
+++ b/test/runtime/type/guard/omit.ts
@@ -14,4 +14,93 @@ describe('type/guard/TOmit', () => {
     const T = Type.Omit(Type.Object({ x: Type.Unsafe({ x: 1, [Kind]: 'UnknownOmitType' }), y: Type.Number() }), ['x'])
     Assert.deepEqual(T.required, ['y'])
   })
+  // -------------------------------------------------------------------------
+  // Standard Tests
+  // -------------------------------------------------------------------------
+  it('Should Omit 1', () => {
+    const T = Type.Omit(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      ['x'],
+    )
+    Assert.deepEqual(TypeGuard.TNumber(T.properties.y), true)
+    Assert.deepEqual(T.required, ['y'])
+  })
+  it('Should Omit 2', () => {
+    const T = Type.Omit(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Optional(Type.Number()),
+      }),
+      ['x'],
+    )
+    Assert.deepEqual(TypeGuard.TNumber(T.properties.y), true)
+    Assert.deepEqual(T.required, undefined)
+  })
+  it('Should Omit 3', () => {
+    const L = Type.Literal('x')
+    const T = Type.Omit(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      L,
+    )
+    Assert.deepEqual(TypeGuard.TNumber(T.properties.y), true)
+    Assert.deepEqual(T.required, ['y'])
+  })
+  it('Should Omit 4', () => {
+    const L = Type.Literal('x')
+    const T = Type.Omit(Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })]), L)
+    Assert.deepEqual(TypeGuard.TNumber(T.allOf[1].properties.y), true)
+    // @ts-ignore
+    Assert.deepEqual(T.allOf[1].properties.x, undefined)
+  })
+  it('Should Omit 5', () => {
+    const L = Type.Union([Type.Literal('x'), Type.Literal('y')])
+    const T = Type.Omit(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      L,
+    )
+    // @ts-ignore
+    Assert.deepEqual(T.properties.x, undefined)
+    // @ts-ignore
+    Assert.deepEqual(T.properties.y, undefined)
+    // @ts-ignore
+    Assert.deepEqual(T.required, undefined)
+  })
+  it('Should Omit 6', () => {
+    const L = Type.Union([Type.Literal('x'), Type.Literal('y'), Type.Literal('z')])
+    const T = Type.Omit(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      L,
+    )
+    // @ts-ignore
+    Assert.deepEqual(T.properties.x, undefined)
+    // @ts-ignore
+    Assert.deepEqual(T.properties.y, undefined)
+    // @ts-ignore
+    Assert.deepEqual(T.required, undefined)
+  })
+  it('Should Omit 7', () => {
+    const L = Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])])
+    const T = Type.Omit(
+      Type.Object({
+        ab: Type.Number(),
+        ac: Type.Number(),
+        ad: Type.Number(),
+      }),
+      L,
+    )
+    Assert.deepEqual(TypeGuard.TNumber(T.properties.ad), true)
+    Assert.deepEqual(T.required, ['ad'])
+  })
 })
diff --git a/test/runtime/type/guard/pick.ts b/test/runtime/type/guard/pick.ts
index 65767c95d..2ca44cc15 100644
--- a/test/runtime/type/guard/pick.ts
+++ b/test/runtime/type/guard/pick.ts
@@ -7,11 +7,102 @@ describe('type/guard/TPick', () => {
   // case: https://github.com/sinclairzx81/typebox/issues/384
   // -------------------------------------------------------------------------
   it('Should support TUnsafe omit properties with no Kind', () => {
-    const T = Type.Pick(Type.Object({ x: Type.Unsafe({ x: 1 }), y: Type.Number() }), ['x'])
+    const T = Type.Pick(
+      Type.Object({
+        x: Type.Unsafe({ x: 1 }),
+        y: Type.Number(),
+      }),
+      ['x'],
+    )
     Assert.deepEqual(T.required, ['x'])
   })
   it('Should support TUnsafe omit properties with unregistered Kind', () => {
     const T = Type.Pick(Type.Object({ x: Type.Unsafe({ x: 1, [Kind]: 'UnknownPickType' }), y: Type.Number() }), ['x'])
     Assert.deepEqual(T.required, ['x'])
   })
+  // -------------------------------------------------------------------------
+  // Standard Tests
+  // -------------------------------------------------------------------------
+  it('Should Pick 1', () => {
+    const T = Type.Pick(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      ['x'],
+    )
+    Assert.deepEqual(TypeGuard.TNumber(T.properties.x), true)
+    Assert.deepEqual(T.required, ['x'])
+  })
+  it('Should Pick 2', () => {
+    const T = Type.Pick(
+      Type.Object({
+        x: Type.Optional(Type.Number()),
+        y: Type.Number(),
+      }),
+      ['x'],
+    )
+    Assert.deepEqual(TypeGuard.TNumber(T.properties.x), true)
+    Assert.deepEqual(T.required, undefined)
+  })
+  it('Should Pick 3', () => {
+    const L = Type.Literal('x')
+    const T = Type.Pick(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      L,
+    )
+    Assert.deepEqual(TypeGuard.TNumber(T.properties.x), true)
+    Assert.deepEqual(T.required, ['x'])
+  })
+  it('Should Pick 4', () => {
+    const L = Type.Literal('x')
+    const T = Type.Pick(Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })]), L)
+
+    Assert.deepEqual(TypeGuard.TNumber(T.allOf[0].properties.x), true)
+    // @ts-ignore
+    Assert.deepEqual(T.allOf[1].properties.y, undefined)
+  })
+  it('Should Pick 5', () => {
+    const L = Type.Union([Type.Literal('x'), Type.Literal('y')])
+    const T = Type.Pick(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      L,
+    )
+    Assert.deepEqual(TypeGuard.TNumber(T.properties.x), true)
+    Assert.deepEqual(TypeGuard.TNumber(T.properties.y), true)
+    Assert.deepEqual(T.required, ['x', 'y'])
+  })
+  it('Should Pick 6', () => {
+    const L = Type.Union([Type.Literal('x'), Type.Literal('y'), Type.Literal('z')])
+    const T = Type.Pick(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      L,
+    )
+    Assert.deepEqual(TypeGuard.TNumber(T.properties.x), true)
+    Assert.deepEqual(TypeGuard.TNumber(T.properties.y), true)
+    Assert.deepEqual(T.required, ['x', 'y'])
+  })
+  it('Should Pick 7', () => {
+    const L = Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])])
+    const T = Type.Pick(
+      Type.Object({
+        ab: Type.Number(),
+        ac: Type.Number(),
+        ad: Type.Number(),
+      }),
+      L,
+    )
+    Assert.deepEqual(TypeGuard.TNumber(T.properties.ab), true)
+    Assert.deepEqual(TypeGuard.TNumber(T.properties.ac), true)
+    Assert.deepEqual(T.required, ['ab', 'ac'])
+  })
 })
diff --git a/test/runtime/value/check/intersect.ts b/test/runtime/value/check/intersect.ts
index 5c9941220..a7574a19e 100644
--- a/test/runtime/value/check/intersect.ts
+++ b/test/runtime/value/check/intersect.ts
@@ -81,4 +81,139 @@ describe('value/check/Intersect', () => {
     const T = Type.Intersect([A, B])
     Assert.equal(Value.Check(T, { x: 1, y: 1 }), false)
   })
+  it('unevaluatedProperties with Record 1', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: false,
+      },
+    )
+    Assert.equal(Value.Check(T, { x: 1, y: 2 }), true)
+  })
+  it('unevaluatedProperties with Record 2', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: false,
+      },
+    )
+    Assert.equal(Value.Check(T, { x: 1, y: 2, 0: 'hello' }), true)
+  })
+  it('unevaluatedProperties with Record 3', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: false,
+      },
+    )
+    Assert.equal(Value.Check(T, { x: 1, y: 2, 0: 1 }), false)
+  })
+  it('unevaluatedProperties with Record 4', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Assert.equal(Value.Check(T, { x: 1, y: 2 }), true)
+  })
+  it('unevaluatedProperties with Record 5', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Assert.equal(Value.Check(T, { x: 1, y: 2, z: true }), true)
+  })
+  it('unevaluatedProperties with Record 6', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Assert.equal(Value.Check(T, { x: 1, y: 2, z: 1 }), false)
+  })
+  it('unevaluatedProperties with Record 7', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Assert.equal(Value.Check(T, { x: 1, y: 2, 0: '' }), true)
+  })
+  it('unevaluatedProperties with Record 8', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Assert.equal(Value.Check(T, { x: 1, y: 2, 0: '', z: true }), true)
+  })
+  it('unevaluatedProperties with Record 9', () => {
+    const T = Type.Intersect(
+      [
+        Type.Record(Type.Number(), Type.String()),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ],
+      {
+        unevaluatedProperties: Type.Boolean(),
+      },
+    )
+    Assert.equal(Value.Check(T, { x: 1, y: 2, 0: '', z: 1 }), false)
+  })
 })
diff --git a/test/runtime/value/check/record.ts b/test/runtime/value/check/record.ts
index 2df12220d..3fe8b5d08 100644
--- a/test/runtime/value/check/record.ts
+++ b/test/runtime/value/check/record.ts
@@ -136,7 +136,7 @@ describe('value/check/Record', () => {
   })
 
   it('Should not pass record with invalid number key', () => {
-    const T = Type.Record(Type.Number(), Type.String())
+    const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: false })
     const value = {
       a: 'a',
       1: 'a',
@@ -159,7 +159,7 @@ describe('value/check/Record', () => {
     Assert.equal(result, true)
   })
   it('Should not pass record with invalid integer key', () => {
-    const T = Type.Record(Type.Integer(), Type.String())
+    const T = Type.Record(Type.Integer(), Type.String(), { additionalProperties: false })
     const value = {
       a: 'a',
       1: 'a',
@@ -168,4 +168,32 @@ describe('value/check/Record', () => {
     const result = Value.Check(T, value)
     Assert.equal(result, false)
   })
+  // ------------------------------------------------------------
+  // AdditionalProperties
+  // ------------------------------------------------------------
+  it('AdditionalProperties 1', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: true })
+    const R = Value.Check(T, { 1: '', 2: '', x: 1, y: 2, z: 3 })
+    Assert.equal(R, true)
+  })
+  it('AdditionalProperties 2', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: false })
+    const R = Value.Check(T, { 1: '', 2: '', 3: '' })
+    Assert.equal(R, true)
+  })
+  it('AdditionalProperties 3', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: false })
+    const R = Value.Check(T, { 1: '', 2: '', x: '' })
+    Assert.equal(R, false)
+  })
+  it('AdditionalProperties 4', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: Type.Boolean() })
+    const R = Value.Check(T, { 1: '', 2: '', x: '' })
+    Assert.equal(R, false)
+  })
+  it('AdditionalProperties 5', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: Type.Boolean() })
+    const R = Value.Check(T, { 1: '', 2: '', x: true })
+    Assert.equal(R, true)
+  })
 })

From a8f4f180bc6f02659dbdddf057e11d4a808d4ef0 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 21 Apr 2023 08:20:07 +0900
Subject: [PATCH 110/369] Revision 0.28.1 (#397)

---
 package-lock.json      |  4 ++--
 package.json           |  2 +-
 src/typebox.ts         |  2 +-
 test/static/index.ts   |  1 +
 test/static/indexed.ts | 29 +++++++++++++++++++++++++++++
 5 files changed, 34 insertions(+), 4 deletions(-)
 create mode 100644 test/static/indexed.ts

diff --git a/package-lock.json b/package-lock.json
index deb9afe98..91b7e01ed 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.0",
+  "version": "0.28.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.0",
+      "version": "0.28.1",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 24257708f..e8ff85441 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.0",
+  "version": "0.28.1",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index a76c35e3f..098346ec3 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -710,7 +710,7 @@ export interface TUndefined extends TSchema {
 // --------------------------------------------------------------------------
 // prettier-ignore
 export type TLiteralUnionReduce<T extends TLiteral<string | number>[]> = 
-  T extends [infer L, ...infer R] ? [Assert<L, TLiteral<string | number>>['const'], ...TLiteralUnionReduce<Assert<R, TLiteral<string>[]>>] : 
+  T extends [infer L, ...infer R] ? [Assert<L, TLiteral<string | number>>['const'], ...TLiteralUnionReduce<Assert<R, TLiteral<string | number>[]>>] : 
   []
 // prettier-ignore
 export type TLiteralUnion<T extends TUnion<TLiteral<string | number>[]>> = 
diff --git a/test/static/index.ts b/test/static/index.ts
index 70f003457..2d551c739 100644
--- a/test/static/index.ts
+++ b/test/static/index.ts
@@ -10,6 +10,7 @@ import './emum'
 import './extract'
 import './exclude'
 import './function'
+import './indexed'
 import './instance-type'
 import './intersect'
 import './keyof'
diff --git a/test/static/indexed.ts b/test/static/indexed.ts
new file mode 100644
index 000000000..7e12c017c
--- /dev/null
+++ b/test/static/indexed.ts
@@ -0,0 +1,29 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+
+{
+  const T = Type.Object({
+    x: Type.Number(),
+    y: Type.String(),
+  })
+  const I = Type.Index(T, ['x', 'y'])
+  Expect(I).ToInfer<number | string>()
+}
+{
+  const T = Type.Tuple([Type.Number(), Type.String(), Type.Boolean()])
+  const I = Type.Index(T, Type.Union([Type.Literal('0'), Type.Literal('1')]))
+  Expect(I).ToInfer<number | string>()
+}
+{
+  const T = Type.Tuple([Type.Number(), Type.String(), Type.Boolean()])
+  const I = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal(1)]))
+  Expect(I).ToInfer<number | string>()
+}
+{
+  const T = Type.Object({
+    ab: Type.Number(),
+    ac: Type.String(),
+  })
+  const I = Type.Index(T, Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])]))
+  Expect(I).ToInfer<number | string>()
+}

From 9e71365ed6cde9c8e1656976c9d4fb4e27767746 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Fri, 21 Apr 2023 11:48:07 +0900
Subject: [PATCH 111/369] Template Literal DSL

---
 example/template-dsl/index.ts        |  29 ++++++++
 example/template-dsl/readme.md       |  31 ++++++++
 example/template-dsl/template-dsl.ts | 105 +++++++++++++++++++++++++++
 3 files changed, 165 insertions(+)
 create mode 100644 example/template-dsl/index.ts
 create mode 100644 example/template-dsl/readme.md
 create mode 100644 example/template-dsl/template-dsl.ts

diff --git a/example/template-dsl/index.ts b/example/template-dsl/index.ts
new file mode 100644
index 000000000..44f129157
--- /dev/null
+++ b/example/template-dsl/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/template-dsl
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './template-dsl'
\ No newline at end of file
diff --git a/example/template-dsl/readme.md b/example/template-dsl/readme.md
new file mode 100644
index 000000000..e55dba237
--- /dev/null
+++ b/example/template-dsl/readme.md
@@ -0,0 +1,31 @@
+# TemplateLiteral DSL
+
+This example implements a small string based DSL for dynamically parsing strings into `TTemplateLiteral` types at runtime. The `template-dsl.ts` script provided with this example contains the full implementation. It can be copied and pasted into projects with TypeBox 0.28.0 or higher installed. 
+
+The example is a candiate for possible inclusion in TypeBox under a `Type.TemplateLiteral(template_dsl_string)` overloaded type function.
+
+## Example
+
+The DSL supports a similar syntax to TypeScript template literal type syntax. The following shows general usage.
+
+```typescript
+import { Static } from '@sinclair/typebox'
+import { TemplateLiteral } from './template-dsl'
+
+// ----------------------------------------------------------------
+// Path
+// ----------------------------------------------------------------
+
+const Path = TemplateLiteral('/users/${number}/posts/${string}')
+
+type Path = Static<typeof Path> // type Path = '/users/${number}/posts/${string}'
+
+// ----------------------------------------------------------------
+// Bytes
+// ----------------------------------------------------------------
+
+const Byte = TemplateLiteral('${0|1}${0|1}${0|1}${0|1}${0|1}${0|1}${0|1}${0|1}')
+
+type Byte = Static<typeof Byte> // type Byte = '00000000' | '00000001' | '00000010' ... | '11111111' 
+```
+
diff --git a/example/template-dsl/template-dsl.ts b/example/template-dsl/template-dsl.ts
new file mode 100644
index 000000000..1db5777e3
--- /dev/null
+++ b/example/template-dsl/template-dsl.ts
@@ -0,0 +1,105 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/template-dsl
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Type, TTemplateLiteral, TLiteral, TTemplateLiteralKind, TNumber, TString, TBoolean, TBigInt, Assert,  Ensure, UnionType } from '@sinclair/typebox'
+
+// -------------------------------------------------------------------------
+// Helpers
+// -------------------------------------------------------------------------
+export type Trim<T> = T extends `${' '}${infer U}` ? Trim<U> : T extends `${infer U}${' '}` ? Trim<U> : T
+// -------------------------------------------------------------------------
+// TTemplateLiteralParser
+// -------------------------------------------------------------------------
+// prettier-ignore
+export type TTemplateLiteralParserUnionLiteral<T extends string> = 
+  T extends `${infer L}|${infer R}` ? [TLiteral<Trim<L>>, ...TTemplateLiteralParserUnionLiteral<R>] : 
+  T extends `${infer L}` ? [TLiteral<Trim<L>>] : 
+  []
+export type TTemplateLiteralParserUnion<T extends string> = UnionType<TTemplateLiteralParserUnionLiteral<T>>
+// prettier-ignore
+export type TTemplateLiteralParserTerminal<T extends string> = 
+  T extends 'boolean' ? TBoolean :  
+  T extends 'bigint' ? TBigInt :  
+  T extends 'number' ? TNumber :
+  T extends 'string' ? TString :
+  TTemplateLiteralParserUnion<T>
+// prettier-ignore
+export type TTemplateLiteralParserTemplate<T extends string> = 
+  T extends `{${infer L}}${infer R}` ? [TTemplateLiteralParserTerminal<L>, ...TTemplateLiteralParserTemplate<R>] :
+  T extends `${infer L}$${infer R}`  ? [TLiteral<L>, ...TTemplateLiteralParserTemplate<R>] :
+  T extends `${infer L}`             ? [TLiteral<L>] : 
+  []
+export type TTemplateLiteralParser<T extends string> = Ensure<TTemplateLiteral<Assert<TTemplateLiteralParserTemplate<T>, TTemplateLiteralKind[]>>>
+// ---------------------------------------------------------------------
+// TemplateLiteralParser
+// ---------------------------------------------------------------------
+namespace TemplateLiteralParser {
+  export function * ParseUnion(template: string): IterableIterator<TTemplateLiteralKind> {
+    const trim = template.trim()
+    if(trim === 'boolean') return yield Type.Boolean()
+    if(trim === 'number') return yield Type.Number()
+    if(trim === 'bigint') return yield Type.BigInt()
+    if(trim === 'string') return yield Type.String()
+    const literals = trim.split('|').map(literal => Type.Literal(literal.trim()))
+    return yield literals.length === 0 ? Type.Never() : literals.length === 1 ? literals[0] : Type.Union(literals)
+  }
+  export function * ParseTerminal(template: string): IterableIterator<TTemplateLiteralKind> {
+    if(template[1] !== '{') {
+      const L = Type.Literal('$')
+      const R = ParseLiteral(template.slice(1))
+      return yield * [L, ...R]
+    }
+    for(let i = 2; i < template.length; i++) {
+      if(template[i] === '}') {
+        const L = ParseUnion(template.slice(2, i))
+        const R = ParseLiteral(template.slice(i+1))
+        return yield * [...L, ...R]
+      }
+    }
+    yield Type.Literal(template)
+  }
+  export function * ParseLiteral(template: string): IterableIterator<TTemplateLiteralKind> {
+    for(let i = 0; i < template.length; i++) {
+      if(template[i] === '$') {
+        const L = Type.Literal(template.slice(0, i))
+        const R = ParseTerminal(template.slice(i))
+        return yield * [L, ...R]
+      }
+    }
+    yield Type.Literal(template)
+  }
+  export function Parse(template: string): TTemplateLiteral {
+    return Type.TemplateLiteral([...ParseLiteral(template)])
+  }
+}
+// ------------------------------------------------------------------------------------------
+// TemplateLiteral DSL
+// ------------------------------------------------------------------------------------------
+export function TemplateLiteral<T extends string>(template: T): TTemplateLiteralParser<T> {
+  return TemplateLiteralParser.Parse(template)
+}
\ No newline at end of file

From f8e50286d779c171982dae65c4a9565b777edcf7 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 21 Apr 2023 21:43:21 +0900
Subject: [PATCH 112/369] Expression Variable Fix for Compiled Records (#403)

---
 package-lock.json               |  4 ++--
 package.json                    |  2 +-
 src/compiler/compiler.ts        |  3 +--
 test/runtime/compiler/record.ts | 17 +++++++++++++++++
 4 files changed, 21 insertions(+), 5 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 91b7e01ed..3da05bcf9 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.1",
+  "version": "0.28.2",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.1",
+      "version": "0.28.2",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index e8ff85441..2ca7f90dc 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.1",
+  "version": "0.28.2",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 02591e1eb..bf0d67a91 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -248,7 +248,6 @@ export namespace TypeCompiler {
     if (IsNumber(schema.minimum)) yield `${value} >= ${schema.minimum}`
     if (IsNumber(schema.maximum)) yield `${value} <= ${schema.maximum}`
   }
-
   function* Object(schema: Types.TObject, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield IsObjectCheck(value)
     if (IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
@@ -288,7 +287,7 @@ export namespace TypeCompiler {
     if (IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
     const [patternKey, patternSchema] = globalThis.Object.entries(schema.patternProperties)[0]
     const local = PushLocal(`new RegExp(/${patternKey}/)`)
-    const check1 = CreateExpression(patternSchema, references, value)
+    const check1 = CreateExpression(patternSchema, references, 'value')
     const check2 = Types.TypeGuard.TSchema(schema.additionalProperties) ? CreateExpression(schema.additionalProperties, references, value) : schema.additionalProperties === false ? 'false' : 'true'
     const expression = `(${local}.test(key) ? ${check1} : ${check2})`
     yield `(Object.entries(${value}).every(([key, value]) => ${expression}))`
diff --git a/test/runtime/compiler/record.ts b/test/runtime/compiler/record.ts
index 2f39b5684..8bee7fa76 100644
--- a/test/runtime/compiler/record.ts
+++ b/test/runtime/compiler/record.ts
@@ -2,6 +2,23 @@ import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
 describe('type/compiler/Record', () => {
+  // -------------------------------------------------------------
+  // Issues
+  // -------------------------------------------------------------
+  it('Issue: https://github.com/sinclairzx81/typebox/issues/402', () => {
+    const T = Type.Object({
+      foo: Type.Object({
+        bar: Type.Record(Type.String(), Type.Number()),
+      }),
+    })
+    Ok(T, { foo: { bar: { x: 42 } } })
+    Ok(T, { foo: { bar: {} } })
+    Fail(T, { foo: { bar: { x: '42' } } })
+    Fail(T, { foo: { bar: [] } })
+    Fail(T, { foo: {} })
+    Fail(T, { foo: [] })
+    Fail(T, {})
+  })
   // -------------------------------------------------------------
   // TypeBox Only: Date and Record
   // -------------------------------------------------------------

From 749b4536f69d1c2cc291deaafbc051781fd77dc2 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 22 Apr 2023 06:28:50 +0900
Subject: [PATCH 113/369] Revision 0.28.3 (#406)

---
 changelog/0.28.3.md                           |  57 ++++++
 example/template-dsl/template-dsl.ts          |   2 +-
 package-lock.json                             |   4 +-
 package.json                                  |   2 +-
 readme.md                                     |  72 +++++--
 src/typebox.ts                                | 145 +++++++-------
 test/runtime/assert/assert.ts                 |  13 +-
 test/runtime/compiler/recursive.ts            |   4 +-
 test/runtime/errors/iterator.ts               |   8 +-
 test/runtime/schema/composite.ts              |   2 +-
 test/runtime/schema/recursive.ts              |   4 +-
 test/runtime/type/extends/any.ts              |  36 ++--
 test/runtime/type/extends/array.ts            | 100 +++++-----
 test/runtime/type/extends/bigint.ts           |  38 ++--
 test/runtime/type/extends/boolean.ts          |  34 ++--
 test/runtime/type/extends/constructor.ts      |  82 ++++----
 test/runtime/type/extends/date.ts             |  36 ++--
 test/runtime/type/extends/function.ts         |  82 ++++----
 test/runtime/type/extends/integer.ts          |  36 ++--
 test/runtime/type/extends/literal.ts          | 100 +++++-----
 test/runtime/type/extends/null.ts             |  38 ++--
 test/runtime/type/extends/number.ts           |  36 ++--
 test/runtime/type/extends/object.ts           |  56 +++---
 test/runtime/type/extends/promise.ts          |  78 ++++----
 test/runtime/type/extends/record.ts           |  64 +++---
 test/runtime/type/extends/string.ts           |  42 ++--
 test/runtime/type/extends/symbol.ts           |  40 ++--
 test/runtime/type/extends/template-literal.ts |  60 +++---
 test/runtime/type/extends/tuple.ts            |  62 +++---
 test/runtime/type/extends/uint8array.ts       |  36 ++--
 test/runtime/type/extends/undefined.ts        |  34 ++--
 test/runtime/type/extends/union.ts            |  52 ++---
 test/runtime/type/extends/unknown.ts          |  38 ++--
 test/runtime/type/extends/void.ts             |  40 ++--
 test/runtime/type/guard/any.ts                |   6 +-
 test/runtime/type/guard/array.ts              |  16 +-
 test/runtime/type/guard/bigint.ts             |   6 +-
 test/runtime/type/guard/boolean.ts            |   6 +-
 test/runtime/type/guard/composite.ts          |  14 +-
 test/runtime/type/guard/constructor.ts        |  22 +--
 test/runtime/type/guard/date.ts               |  14 +-
 test/runtime/type/guard/exclude.ts            |  36 ++--
 test/runtime/type/guard/extract.ts            |  48 ++---
 test/runtime/type/guard/function.ts           |  22 +--
 test/runtime/type/guard/index.ts              |   1 +
 test/runtime/type/guard/indexed.ts            |  81 +++++---
 test/runtime/type/guard/integer.ts            |  16 +-
 test/runtime/type/guard/intersect.ts          |   4 +-
 test/runtime/type/guard/keyof.ts              |  32 +--
 test/runtime/type/guard/literal.ts            |  12 +-
 test/runtime/type/guard/not.ts                |   8 +-
 test/runtime/type/guard/null.ts               |   6 +-
 test/runtime/type/guard/number.ts             |  16 +-
 test/runtime/type/guard/object.ts             |  20 +-
 test/runtime/type/guard/omit.ts               |  36 ++--
 test/runtime/type/guard/partial.ts            |   6 +-
 test/runtime/type/guard/pick.ts               |  38 ++--
 test/runtime/type/guard/promise.ts            |  10 +-
 test/runtime/type/guard/record.ts             |  66 +++----
 test/runtime/type/guard/ref.ts                |   6 +-
 test/runtime/type/guard/rest.ts               |  22 +++
 test/runtime/type/guard/string.ts             |  12 +-
 test/runtime/type/guard/symbol.ts             |   6 +-
 test/runtime/type/guard/template-literal.ts   |  18 +-
 test/runtime/type/guard/this.ts               |   4 +-
 test/runtime/type/guard/tuple.ts              |   8 +-
 test/runtime/type/guard/uint8array.ts         |  10 +-
 test/runtime/type/guard/undefined.ts          |   6 +-
 test/runtime/type/guard/union.ts              |  20 +-
 test/runtime/type/guard/unknown.ts            |   6 +-
 test/runtime/type/guard/unsafe.ts             |  10 +-
 test/runtime/type/guard/void.ts               |   6 +-
 test/runtime/type/normalize/exclude.ts        |   6 +-
 test/runtime/type/normalize/extract.ts        |  10 +-
 test/runtime/type/normalize/intersect.ts      |   6 +-
 test/runtime/type/normalize/record.ts         |   2 +-
 test/runtime/type/normalize/union.ts          |   6 +-
 test/runtime/type/registry/format.ts          |   6 +-
 test/runtime/type/registry/type.ts            |   6 +-
 test/runtime/type/template/finite.ts          |  24 +--
 test/runtime/type/template/generate.ts        |  74 +++----
 test/runtime/type/template/parser.ts          |  74 +++----
 test/runtime/type/template/pattern.ts         |  10 +-
 test/runtime/value/cast/any.ts                |  18 +-
 test/runtime/value/cast/array.ts              |  38 ++--
 test/runtime/value/cast/bigint.ts             |  18 +-
 test/runtime/value/cast/boolean.ts            |  18 +-
 test/runtime/value/cast/composite.ts          |  20 +-
 test/runtime/value/cast/custom.ts             |  16 +-
 test/runtime/value/cast/date.ts               |  12 +-
 test/runtime/value/cast/enum.ts               |  20 +-
 test/runtime/value/cast/integer.ts            |  14 +-
 test/runtime/value/cast/intersect.ts          |  12 +-
 test/runtime/value/cast/keyof.ts              |  18 +-
 test/runtime/value/cast/literal.ts            |  18 +-
 test/runtime/value/cast/not.ts                |  20 +-
 test/runtime/value/cast/null.ts               |  18 +-
 test/runtime/value/cast/number.ts             |  16 +-
 test/runtime/value/cast/object.ts             |  28 +--
 test/runtime/value/cast/record.ts             |  20 +-
 test/runtime/value/cast/recursive.ts          |  20 +-
 test/runtime/value/cast/regex.ts              |  18 +-
 test/runtime/value/cast/string.ts             |  14 +-
 test/runtime/value/cast/symbol.ts             |   2 +-
 test/runtime/value/cast/template-literal.ts   |  18 +-
 test/runtime/value/cast/tuple.ts              |  26 +--
 test/runtime/value/cast/uint8array.ts         |  18 +-
 test/runtime/value/cast/undefined.ts          |  18 +-
 test/runtime/value/cast/union.ts              |  38 ++--
 test/runtime/value/cast/unknown.ts            |  18 +-
 test/runtime/value/cast/void.ts               |  18 +-
 test/runtime/value/check/any.ts               |  16 +-
 test/runtime/value/check/array.ts             |  18 +-
 test/runtime/value/check/bigint.ts            |  14 +-
 test/runtime/value/check/boolean.ts           |  16 +-
 test/runtime/value/check/composite.ts         |  10 +-
 test/runtime/value/check/custom.ts            |   8 +-
 test/runtime/value/check/date.ts              |  18 +-
 test/runtime/value/check/enum.ts              |   8 +-
 test/runtime/value/check/integer.ts           |  12 +-
 test/runtime/value/check/intersect.ts         |  54 ++---
 test/runtime/value/check/keyof.ts             |   8 +-
 test/runtime/value/check/literal.ts           |   8 +-
 test/runtime/value/check/never.ts             |  14 +-
 test/runtime/value/check/not.ts               |  22 +--
 test/runtime/value/check/null.ts              |  16 +-
 test/runtime/value/check/number.ts            |  24 +--
 test/runtime/value/check/object.ts            |  58 +++---
 test/runtime/value/check/record.ts            |  46 ++---
 test/runtime/value/check/recursive.ts         |  10 +-
 test/runtime/value/check/ref.ts               |  16 +-
 test/runtime/value/check/regex.ts             |   4 +-
 test/runtime/value/check/string.ts            |  16 +-
 test/runtime/value/check/symbol.ts            |  18 +-
 test/runtime/value/check/template-literal.ts  | 134 ++++++-------
 test/runtime/value/check/tuple.ts             |  10 +-
 test/runtime/value/check/uint8array.ts        |   8 +-
 test/runtime/value/check/undefined.ts         |  16 +-
 test/runtime/value/check/union.ts             |  12 +-
 test/runtime/value/check/unknown.ts           |  16 +-
 test/runtime/value/check/void.ts              |  16 +-
 test/runtime/value/clone/clone.ts             |  48 ++---
 test/runtime/value/convert/any.ts             |  14 +-
 test/runtime/value/convert/array.ts           |  20 +-
 test/runtime/value/convert/bigint.ts          |  16 +-
 test/runtime/value/convert/boolean.ts         |  58 +++---
 test/runtime/value/convert/composite.ts       |   2 +-
 test/runtime/value/convert/custom.ts          |   6 +-
 test/runtime/value/convert/date.ts            |  18 +-
 test/runtime/value/convert/integer.ts         |  28 +--
 test/runtime/value/convert/literal.ts         |  30 +--
 test/runtime/value/convert/never.ts           |   6 +-
 test/runtime/value/convert/null.ts            |   6 +-
 test/runtime/value/convert/number.ts          |  28 +--
 test/runtime/value/convert/object.ts          |   2 +-
 test/runtime/value/convert/record.ts          |   2 +-
 test/runtime/value/convert/string.ts          |  26 +--
 test/runtime/value/convert/symbol.ts          |   4 +-
 test/runtime/value/convert/tuple.ts           |   6 +-
 test/runtime/value/convert/undefined.ts       |   4 +-
 test/runtime/value/convert/union.ts           |   8 +-
 test/runtime/value/convert/unknown.ts         |  14 +-
 test/runtime/value/create/any.ts              |   4 +-
 test/runtime/value/create/array.ts            |   6 +-
 test/runtime/value/create/bigint.ts           |   4 +-
 test/runtime/value/create/boolean.ts          |   4 +-
 test/runtime/value/create/composite.ts        |   6 +-
 test/runtime/value/create/constructor.ts      |   4 +-
 test/runtime/value/create/custom.ts           |   2 +-
 test/runtime/value/create/enum.ts             |   4 +-
 test/runtime/value/create/function.ts         |   4 +-
 test/runtime/value/create/integer.ts          |   4 +-
 test/runtime/value/create/intersect.ts        |  14 +-
 test/runtime/value/create/keyof.ts            |   4 +-
 test/runtime/value/create/literal.ts          |   8 +-
 test/runtime/value/create/not.ts              |   6 +-
 test/runtime/value/create/null.ts             |   4 +-
 test/runtime/value/create/number.ts           |   4 +-
 test/runtime/value/create/object.ts           |  10 +-
 test/runtime/value/create/record.ts           |   4 +-
 test/runtime/value/create/recursive.ts        |   4 +-
 test/runtime/value/create/ref.ts              |   2 +-
 test/runtime/value/create/regex.ts            |   2 +-
 test/runtime/value/create/string.ts           |   4 +-
 test/runtime/value/create/symbol.ts           |   4 +-
 test/runtime/value/create/template-literal.ts |  10 +-
 test/runtime/value/create/tuple.ts            |   8 +-
 test/runtime/value/create/uint8array.ts       |  10 +-
 test/runtime/value/create/undefined.ts        |   4 +-
 test/runtime/value/create/union.ts            |   6 +-
 test/runtime/value/create/unknown.ts          |   4 +-
 test/runtime/value/create/void.ts             |   4 +-
 test/runtime/value/delta/diff.ts              |  96 ++++-----
 test/runtime/value/delta/patch.ts             |  98 ++++-----
 test/runtime/value/equal/equal.ts             |  42 ++--
 test/runtime/value/hash/hash.ts               |  34 ++--
 test/runtime/value/mutate/mutate.ts           |  28 +--
 test/runtime/value/pointer/pointer.ts         | 186 +++++++++---------
 test/static/index.ts                          |   1 +
 test/static/indexed.ts                        |  21 ++
 test/static/rest.ts                           |  36 ++++
 201 files changed, 2426 insertions(+), 2231 deletions(-)
 create mode 100644 changelog/0.28.3.md
 create mode 100644 test/runtime/type/guard/rest.ts
 create mode 100644 test/static/rest.ts

diff --git a/changelog/0.28.3.md b/changelog/0.28.3.md
new file mode 100644
index 000000000..876b7e3fb
--- /dev/null
+++ b/changelog/0.28.3.md
@@ -0,0 +1,57 @@
+## [0.28.3](https://www.npmjs.com/package/@sinclair/typebox/v/0.28.3)
+
+## Overview
+
+Revision 0.28.3 adds a new Rest type to support variadic type composition.
+
+## Contents
+
+- Enhancements
+  - [Variadic Types](#Variadic-Types)
+
+<a href="Variadic-Types"></a>
+
+## Variadic Types
+
+Revision 0.28.3 adds a new type named `Type.Rest`. This type is used to extract a tuple array of type of `[...TSchema]`. The return value of this type is not strictly JSON Schema, however the tuple array can be used as a parameter to other types that accept tuples as their arguments.
+
+### Tuple Concatenation
+
+```typescript
+// TypeScript
+
+type A = [1, 2]
+
+type B = [3, 4]
+
+type C = [...A, ...B]
+
+// TypeBox
+
+const A = Type.Tuple([Type.Literal(1), Type.Literal(2)])
+
+const B = Type.Tuple([Type.Literal(3), Type.Literal(4)])
+
+const C = Type.Tuple([...Type.Rest(A), ...Type.Rest(B)])
+```
+
+### Tuple To Parameter
+
+```typescript
+// TypeScript
+
+type P = [number, number]
+
+type F1 = (param: [...P]) => void
+
+type F2 = (param: [...P, number]) => void
+
+// TypeBox
+
+const P = Type.Tuple([Type.Number(), Type.Number()])
+
+const F1 = Type.Function(Type.Rest(P), Type.Void())
+
+const F2 = Type.Function([...Type.Rest(P), Type.Number()], Type.Void())
+```
+
diff --git a/example/template-dsl/template-dsl.ts b/example/template-dsl/template-dsl.ts
index 1db5777e3..ad110da3a 100644
--- a/example/template-dsl/template-dsl.ts
+++ b/example/template-dsl/template-dsl.ts
@@ -60,7 +60,7 @@ export type TTemplateLiteralParser<T extends string> = Ensure<TTemplateLiteral<A
 // ---------------------------------------------------------------------
 namespace TemplateLiteralParser {
   export function * ParseUnion(template: string): IterableIterator<TTemplateLiteralKind> {
-    const trim = template.trim()
+    const trim = template.trim().replace(/"|'/g, '')
     if(trim === 'boolean') return yield Type.Boolean()
     if(trim === 'number') return yield Type.Number()
     if(trim === 'bigint') return yield Type.BigInt()
diff --git a/package-lock.json b/package-lock.json
index 3da05bcf9..7429ae097 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.2",
+  "version": "0.28.3",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.2",
+      "version": "0.28.3",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 2ca7f90dc..89382d651 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.2",
+  "version": "0.28.3",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 5155d455c..7c0fc9e57 100644
--- a/readme.md
+++ b/readme.md
@@ -83,6 +83,7 @@ License MIT
   - [Conditional](#types-conditional)
   - [Template](#types-template-literal)
   - [Indexed](#types-indexed)
+  - [Variadic](#types-variadic)
   - [Guards](#types-guards)
   - [Unsafe](#types-unsafe)
   - [Strict](#types-strict)
@@ -256,7 +257,8 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │ })                             │ }                           │   properties: {                │
 │                                │                             │     x: {                       │
 │                                │                             │       type: 'number'           │
-│                                │                             │     }, {                       │
+│                                │                             │     },                         │
+│                                │                             │     y: {                       │
 │                                │                             │       type: 'number'           │
 │                                │                             │     }                          │
 │                                │                             │   }                            │
@@ -277,14 +279,6 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │                                │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Index(          │ type T = {                  │ const T = {                    │
-│   Type.Object({                │   x: number,                │   type: number                 │
-│     x: Type.Number(),          │   y: string                 │ }                              │
-│     y: Type.String()           │ }['x']                      │                                │
-│   }), ['x']                    │                             │                                │
-│ )                              │                             │                                │
-│                                │                             │                                │
-├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ enum Foo {                     │ enum Foo {                  │ const T = {                    │
 │   A,                           │   A,                        │   anyOf: [{                    │
 │   B                            │   B                         │     type: 'number',            │
@@ -468,6 +462,28 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Index(          │ type T = {                  │ const T = {                    │
+│   Type.Object({                │   x: number,                │   type: 'number'               │
+│     x: Type.Number(),          │   y: string                 │ }                              │
+│     y: Type.String()           │ }['x']                      │                                │
+│   }), ['x']                    │                             │                                │
+│ )                              │                             │                                │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const A = Type.Tuple([         │ type A = [0, 1]             │ const T = {                    │
+│   Type.Literal(0),             │ type B = [2, 3]             │   type: 'array',               │
+│   Type.Literal(1)              │ type T = [...A, ...B]       │   items: [                     │
+│ ])                             │                             │     { const: 0 },              │
+│ const B = Type.Tuple([         │                             │     { const: 1 },              │
+|   Type.Literal(2),             │                             │     { const: 2 },              │
+|   Type.Literal(3)              │                             │     { const: 3 }               │
+│ ])                             │                             │   ],                           │
+│ const T = Type.Tuple([         │                             │   additionalItems: false,      │
+|   ...Type.Rest(A),             │                             │   minItems: 4,                 │
+|   ...Type.Test(B)              │                             │   maxItems: 4                  │
+│ ])                             │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Object({        │ type T = {                  │ const R = {                    │
 │    x: Type.Number(),           │   x: number,                │   $ref: 'T'                    │
 │    y: Type.Number()            │   y: number                 │ }                              │
@@ -856,10 +872,34 @@ const A = Type.Index(T, ['x'])                       // type A = T['x']
 
 const B = Type.Index(T, Type.KeyOf(T))               // type B = T[keyof T]
 ```
+<a name='types-variadic'></a>
+
+### Variadic Types
+
+Variadic types are supported with `Type.Rest`. This type will extract interior types from a tuple and return them as a flat array. This array can then be passed to other types that accept arrays as arguments.
+
+The following creates variadic functions using the Rest type.
+
+```typescript
+// TypeScript
 
+type P = [number, number]
+
+type F1 = (param: [...P]) => void
+
+type F2 = (param: [...P, number]) => void
+
+// TypeBox
+
+const P = Type.Tuple([Type.Number(), Type.Number()])
+
+const F1 = Type.Function(Type.Rest(P), Type.Void())
+
+const F2 = Type.Function([...Type.Rest(P), Type.Number()], Type.Void())
+```
 <a name='types-unsafe'></a>
 
-### Unsafe
+### Unsafe Types
 
 Use `Type.Unsafe` to create custom schematics with user defined inference rules.
 
@@ -904,7 +944,7 @@ type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
 
 <a name='types-guards'></a>
 
-### Guards
+### Type Gaurds
 
 TypeBox provides a `TypeGuard` module that can be used for reflection and asserting values as types.
 
@@ -1436,11 +1476,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '127.2 kb' │ ' 56.9 kb' │  '2.23 x'   │
-│ typebox/errors       │ '110.9 kb' │ ' 49.2 kb' │  '2.25 x'   │
-│ typebox/system       │ ' 76.4 kb' │ ' 31.5 kb' │  '2.42 x'   │
-│ typebox/value        │ '176.9 kb' │ ' 76.8 kb' │  '2.30 x'   │
-│ typebox              │ ' 75.3 kb' │ ' 31.1 kb' │  '2.42 x'   │
+│ typebox/compiler     │ '126.7 kb' │ ' 56.6 kb' │  '2.24 x'   │
+│ typebox/errors       │ '110.4 kb' │ ' 48.8 kb' │  '2.26 x'   │
+│ typebox/system       │ ' 75.9 kb' │ ' 31.1 kb' │  '2.44 x'   │
+│ typebox/value        │ '176.4 kb' │ ' 76.4 kb' │  '2.31 x'   │
+│ typebox              │ ' 74.8 kb' │ ' 30.7 kb' │  '2.44 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/typebox.ts b/src/typebox.ts
index 098346ec3..e95c3cdc2 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -56,18 +56,13 @@ export type Ensure<T> = T extends infer U ? U : never
 // Type Assertions
 // --------------------------------------------------------------------------
 export type AssertProperties<T> = T extends TProperties ? T : TProperties
-export type AssertSchemas<T, E extends TSchema[] = TSchema[]> = T extends E ? T : []
-export type AssertSchema<T, E extends TSchema = TSchema> = T extends E ? T : TNever
-export type AssertObjects<T> = Assert<T, TObject[]>
-export type AssertObject<T> = Assert<T, TObject>
-export type AssertKeys<T> = Assert<T, Key[]>
-export type AssertKey<T> = Assert<T, Key>
-export type Key = keyof any
+export type AssertRest<T, E extends TSchema[] = TSchema[]> = T extends E ? T : []
+export type AssertType<T, E extends TSchema = TSchema> = T extends E ? T : TNever
 // --------------------------------------------------------------------------
 // Type Normalization
 // --------------------------------------------------------------------------
-export type IntersectType<T extends TSchema[]> = T extends [] ? TNever : T extends [TSchema] ? AssertSchema<T[0]> : TIntersect<T>
-export type UnionType<T extends TSchema[]> = T extends [] ? TNever : T extends [TSchema] ? AssertSchema<T[0]> : TUnion<T>
+export type IntersectType<T extends TSchema[]> = T extends [] ? TNever : T extends [TSchema] ? AssertType<T[0]> : TIntersect<T>
+export type UnionType<T extends TSchema[]> = T extends [] ? TNever : T extends [TSchema] ? AssertType<T[0]> : TUnion<T>
 // --------------------------------------------------------------------------
 // Modifiers
 // --------------------------------------------------------------------------
@@ -76,6 +71,10 @@ export type TReadonly<T extends TSchema> = T & { [Modifier]: 'Readonly' }
 export type TOptional<T extends TSchema> = T & { [Modifier]: 'Optional' }
 export type TReadonlyOptional<T extends TSchema> = T & { [Modifier]: 'ReadonlyOptional' }
 // --------------------------------------------------------------------------
+// Key
+// --------------------------------------------------------------------------
+export type Key = keyof any
+// --------------------------------------------------------------------------
 // TSchema
 // --------------------------------------------------------------------------
 export interface SchemaOptions {
@@ -196,8 +195,8 @@ export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['retur
 export type TCompositeIsOptional<T extends TSchema> = T extends TOptional<T> | TReadonlyOptional<T> ? true : false
 // prettier-ignore
 export type TCompositeOptional<T extends TSchema[]> = T extends [infer L, ...infer R] 
-  ? TCompositeIsOptional<AssertSchema<L>> extends false ? false 
-  : TCompositeOptional<AssertSchemas<R>> : true
+  ? TCompositeIsOptional<AssertType<L>> extends false ? false 
+  : TCompositeOptional<AssertRest<R>> : true
 export type TCompositeKeyOfUnion1<T extends TObject> = keyof T['properties']
 // prettier-ignore
 export type TCompositeKeyOfUnion2<T extends TObject[]> = T extends [infer L, ...infer R] 
@@ -207,24 +206,24 @@ export type TCompositeKeyOf<T extends TObject[]> = UnionToTuple<TCompositeKeyOfU
 export type TCompositePropertiesWithKey1<T extends TObject, K extends Key> = K extends keyof T['properties'] ? [T['properties'][K]] : []
 // prettier-ignore
 export type TCompositePropertiesWithKey2<T extends TObject[], K extends Key> = T extends [infer L, ...infer R] 
-  ? [...TCompositePropertiesWithKey1<AssertObject<L>, K>, ...TCompositePropertiesWithKey2<AssertObjects<R>, K>]
+  ? [...TCompositePropertiesWithKey1<Assert<L, TObject>, K>, ...TCompositePropertiesWithKey2<Assert<R, TObject[]>, K>]
   : []
 // prettier-ignore
 export type TCompositeObjectProperty<T extends TObject[], K extends Key> = TCompositePropertiesWithKey2<T, K> extends infer S ? 
-  TCompositeOptional<AssertSchemas<S>> extends true
-    ? { [_ in K]: TOptional<IntersectType<AssertSchemas<S>>> }
-    : { [_ in K]: IntersectType<AssertSchemas<S>> }
+  TCompositeOptional<AssertRest<S>> extends true
+    ? { [_ in K]: TOptional<IntersectType<AssertRest<S>>> }
+    : { [_ in K]: IntersectType<AssertRest<S>> }
   : {}
 // prettier-ignore
 export type TCompositeObjectsWithKeys<T extends TObject[], K extends Key[]> = K extends [infer L, ...infer R] ? L extends Key
-    ? TCompositeObjectProperty<T, L> & TCompositeObjectsWithKeys<T, AssertKeys<R>>
+    ? TCompositeObjectProperty<T, L> & TCompositeObjectsWithKeys<T, Assert<R, Key[]>>
     : {} 
   : {}
-export type TComposite<T extends TObject[]> = Ensure<TObject<Evaluate<TCompositeObjectsWithKeys<T, AssertKeys<TCompositeKeyOf<T>>>>>>
+export type TComposite<T extends TObject[]> = Ensure<TObject<Evaluate<TCompositeObjectsWithKeys<T, Assert<TCompositeKeyOf<T>, Key[]>>>>>
 // --------------------------------------------------------------------------
 // TConstructor
 // --------------------------------------------------------------------------
-export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: Static<AssertSchema<T[K]>, P> }]
+export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: Static<AssertType<T[K]>, P> }]
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Constructor'
   static: new (...param: TConstructorParameterArray<T, this['params']>) => Static<U, this['params']>
@@ -266,17 +265,17 @@ export interface TEnum<T extends Record<string, string | number> = Record<string
 // prettier-ignore
 export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = 
   (Static<L> extends Static<R> ? T : U) extends infer O ? 
-    UnionToTuple<O> extends [infer X, infer Y] ? TUnion<[AssertSchema<X>, AssertSchema<Y>]> : AssertSchema<O>
+    UnionToTuple<O> extends [infer X, infer Y] ? TUnion<[AssertType<X>, AssertType<Y>]> : AssertType<O>
   : never
 // --------------------------------------------------------------------------
 // TExclude
 // --------------------------------------------------------------------------
-export type TExcludeTemplateLiteralResult<T extends string> = UnionType<AssertSchemas<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
+export type TExcludeTemplateLiteralResult<T extends string> = UnionType<AssertRest<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
 export type TExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Exclude<Static<T>, Static<U>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never
 // prettier-ignore
-export type TExcludeArray<T extends TSchema[], U extends TSchema> = AssertSchemas<UnionToTuple<{
-  [K in keyof T]: Static<AssertSchema<T[K]>> extends Static<U> ? never : T[K]
-}[number]>> extends infer R ? UnionType<AssertSchemas<R>> : never
+export type TExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
+  [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? never : T[K]
+}[number]>> extends infer R ? UnionType<AssertRest<R>> : never
 // prettier-ignore
 export type TExclude<T extends TSchema, U extends TSchema> = 
   T extends TTemplateLiteral ? TExcludeTemplateLiteral<T, U> : 
@@ -285,12 +284,12 @@ export type TExclude<T extends TSchema, U extends TSchema> =
 // --------------------------------------------------------------------------
 // TExtract
 // --------------------------------------------------------------------------
-export type TExtractTemplateLiteralResult<T extends string> = UnionType<AssertSchemas<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
+export type TExtractTemplateLiteralResult<T extends string> = UnionType<AssertRest<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
 export type TExtractTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? TExtractTemplateLiteralResult<Assert<S, string>> : never
 // prettier-ignore
-export type TExtractArray<T extends TSchema[], U extends TSchema> = AssertSchemas<UnionToTuple<
-  {[K in keyof T]: Static<AssertSchema<T[K]>> extends Static<U> ? T[K] : never
-}[number]>> extends infer R ? UnionType<AssertSchemas<R>> : never
+export type TExtractArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<
+  {[K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? T[K] : never
+}[number]>> extends infer R ? UnionType<AssertRest<R>> : never
 // prettier-ignore
 export type TExtract<T extends TSchema, U extends TSchema> = 
   T extends TTemplateLiteral ? TExtractTemplateLiteral<T, U> : 
@@ -299,7 +298,7 @@ export type TExtract<T extends TSchema, U extends TSchema> =
 // --------------------------------------------------------------------------
 // TFunction
 // --------------------------------------------------------------------------
-export type TFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: Static<AssertSchema<T[K]>, P> }]
+export type TFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: Static<AssertType<T[K]>, P> }]
 export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Function'
   static: (...param: TFunctionParameters<T, this['params']>) => Static<U, this['params']>
@@ -322,7 +321,7 @@ export type TIndexTuple<T extends TSchema[], K extends IndexKey> =
   []
 // prettier-ignore
 export type TIndexComposite<T extends TSchema[], K extends IndexKey> = 
-  T extends [infer L, ...infer R] ? [...TIndexKey<AssertSchema<L>, K>, ...TIndexComposite<AssertSchemas<R>, K>] : 
+  T extends [infer L, ...infer R] ? [...TIndexKey<AssertType<L>, K>, ...TIndexComposite<AssertRest<R>, K>] : 
   []
 // prettier-ignore
 export type TIndexKey<T extends TSchema, K extends IndexKey> = 
@@ -341,11 +340,11 @@ export type TIndexKeys<T extends TSchema, K extends IndexKey[]> =
 export type TIndex<T extends TSchema, K extends IndexKey[]> = 
   TIndexKeys<T, K> extends infer R ?
     T extends TRecursive<infer S> ? TIndex<S, K> :
-    T extends TTuple              ? UnionType<AssertSchemas<R>> :
-    T extends TIntersect          ? UnionType<AssertSchemas<R>> :
-    T extends TUnion              ? UnionType<AssertSchemas<R>> :
-    T extends TObject             ? UnionType<AssertSchemas<R>> :
-    T extends TArray              ? UnionType<AssertSchemas<R>> :
+    T extends TTuple              ? UnionType<AssertRest<R>> :
+    T extends TIntersect          ? UnionType<AssertRest<R>> :
+    T extends TUnion              ? UnionType<AssertRest<R>> :
+    T extends TObject             ? UnionType<AssertRest<R>> :
+    T extends TArray              ? UnionType<AssertRest<R>> :
     TNever : 
   TNever
 // --------------------------------------------------------------------------
@@ -365,7 +364,7 @@ export interface IntersectOptions extends SchemaOptions {
 }
 export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
   [Kind]: 'Intersect'
-  static: TupleToIntersect<{ [K in keyof T]: Static<AssertSchema<T[K]>, this['params']> }>
+  static: TupleToIntersect<{ [K in keyof T]: Static<AssertType<T[K]>, this['params']> }>
   type?: 'object'
   allOf: [...T]
 }
@@ -382,7 +381,7 @@ export type TKeyOfProperties<T extends TSchema> = Static<T> extends infer S
 // prettier-ignore
 export type TKeyOfIndicesArray<T extends TSchema[]> = UnionToTuple<keyof T & `${number}`>
 // prettier-ignore
-export type TKeyOfIndices<T extends TSchema[]> = AssertSchemas<TKeyOfIndicesArray<T> extends infer R ? {
+export type TKeyOfIndices<T extends TSchema[]> = AssertRest<TKeyOfIndicesArray<T> extends infer R ? {
   [K in keyof R] : TLiteral<Assert<R[K], TLiteralValue>>
 }: []>
 // prettier-ignore
@@ -395,7 +394,7 @@ export type TKeyOf<T extends TSchema = TSchema> = (
   T extends TArray              ? [TNumber] :
   T extends TRecord<infer K>    ? [K] :
   []
-) extends infer R ? UnionType<AssertSchemas<R>> : never
+) extends infer R ? UnionType<AssertRest<R>> : never
 // --------------------------------------------------------------------------
 // TLiteral
 // --------------------------------------------------------------------------
@@ -475,7 +474,7 @@ export interface TObject<T extends TProperties = TProperties> extends TSchema, O
 // --------------------------------------------------------------------------
 // TOmit
 // --------------------------------------------------------------------------
-export type TOmitArray<T extends TSchema[], K extends keyof any> = AssertSchemas<{ [K2 in keyof T]: TOmit<AssertSchema<T[K2]>, K> }>
+export type TOmitArray<T extends TSchema[], K extends keyof any> = AssertRest<{ [K2 in keyof T]: TOmit<AssertType<T[K2]>, K> }>
 export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<AssertProperties<Omit<T, K>>>
 // prettier-ignore
 export type TOmit<T extends TSchema = TSchema, K extends keyof any = keyof any> = 
@@ -491,8 +490,8 @@ export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>
 // --------------------------------------------------------------------------
 // TPartial
 // --------------------------------------------------------------------------
-export type TPartialObjectArray<T extends TObject[]> = AssertSchemas<{ [K in keyof T]: TPartial<AssertSchema<T[K], TObject>> }, TObject[]>
-export type TPartialArray<T extends TSchema[]> = AssertSchemas<{ [K in keyof T]: TPartial<AssertSchema<T[K]>> }>
+export type TPartialObjectArray<T extends TObject[]> = AssertRest<{ [K in keyof T]: TPartial<AssertType<T[K], TObject>> }, TObject[]>
+export type TPartialArray<T extends TSchema[]> = AssertRest<{ [K in keyof T]: TPartial<AssertType<T[K]>> }>
 // prettier-ignore
 export type TPartialProperties<T extends TProperties> = Evaluate<AssertProperties<{
   [K in keyof T]: 
@@ -511,13 +510,13 @@ export type TPartial<T extends TSchema> =
 // --------------------------------------------------------------------------
 // TPick
 // --------------------------------------------------------------------------
-export type TPickArray<T extends TSchema[], K extends keyof any> = { [K2 in keyof T]: TPick<AssertSchema<T[K2]>, K> }
+export type TPickArray<T extends TSchema[], K extends keyof any> = { [K2 in keyof T]: TPick<AssertType<T[K2]>, K> }
 // Note the key K will overlap for varying TProperties gathered via recursive union and intersect traversal. Because of this,
 // we need to extract only keys assignable to T on K2. This behavior is only required for Pick only.
 // prettier-ignore
 export type TPickProperties<T extends TProperties, K extends keyof any> = 
   Pick<T, Assert<Extract<K, keyof T>, keyof T>> extends infer R ? ({
-    [K in keyof R]: AssertSchema<R[K]> extends TSchema ? R[K] : never
+    [K in keyof R]: AssertType<R[K]> extends TSchema ? R[K] : never
   }): never
 // prettier-ignore
 export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any> = 
@@ -575,13 +574,17 @@ export interface TRef<T extends TSchema = TSchema> extends TSchema {
   $ref: string
 }
 // --------------------------------------------------------------------------
+// TRest
+// --------------------------------------------------------------------------
+export type TRest<T extends TSchema> = T extends TTuple<infer R> ? Assert<R, TSchema[]> : Assert<[T], TSchema[]>
+// --------------------------------------------------------------------------
 // TReturnType
 // --------------------------------------------------------------------------
 export type TReturnType<T extends TFunction> = T['returns']
 // --------------------------------------------------------------------------
 // TRequired
 // --------------------------------------------------------------------------
-export type TRequiredArray<T extends TSchema[]> = AssertSchemas<{ [K in keyof T]: TRequired<AssertSchema<T[K]>> }>
+export type TRequiredArray<T extends TSchema[]> = AssertRest<{ [K in keyof T]: TRequired<AssertType<T[K]>> }>
 // prettier-ignore
 export type TRequiredProperties<T extends TProperties> = Evaluate<AssertProperties<{
   [K in keyof T]: 
@@ -676,7 +679,7 @@ export type TTemplateLiteralConst<T, Acc extends string> =
 export type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string = ''> = 
   T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` :
   Acc
-export type TTemplateLiteralKeyArray<T extends TTemplateLiteral> = AssertKeys<UnionToTuple<Static<T>>>
+export type TTemplateLiteralKeyArray<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, Key[]>
 export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
   [Kind]: 'TemplateLiteral'
   static: TTemplateLiteralUnion<T>
@@ -686,7 +689,7 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
 // --------------------------------------------------------------------------
 // TTuple
 // --------------------------------------------------------------------------
-export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? AssertSchemas<R> : never
+export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? AssertRest<R> : never
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
   [Kind]: 'Tuple'
   static: { [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : T[K] }
@@ -2394,16 +2397,22 @@ export class StandardTypeBuilder extends TypeBuilder {
   /** `[Standard]` Returns indexed property types for the given keys */
   public Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyArray<K>>
   /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TArray, K extends TNumber>(schema: T, key: K, options?: SchemaOptions): T['items']
+  public Index<T extends TTuple, K extends TNumber>(schema: T, key: K, options?: SchemaOptions): UnionType<Assert<T['items'], TSchema[]>>
+  /** `[Standard]` Returns indexed property types for the given keys */
+  public Index<T extends TArray, K extends TNumber>(schema: T, key: K, options?: SchemaOptions): AssertType<T['items']>
   /** `[Standard]` Returns indexed property types for the given keys */
   public Index<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TIndex<T, never>
   /** `[Standard]` Returns indexed property types for the given keys */
   public Index(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
     const keys = KeyArrayResolver.Resolve(unresolved)
-
     if (TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved)) {
       return TypeClone.Clone(schema.items, options)
     }
+    if (TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved)) {
+      const items = schema.items === undefined ? [] : schema.items
+      const cloned = items.map((schema) => TypeClone.Clone(schema, {}))
+      return this.Union(cloned, options)
+    }
     const resolved = IndexedAccessor.Resolve(schema, keys as any)
     const cloned = resolved.map((schema) => TypeClone.Clone(schema, {}))
     return this.Union(cloned, options)
@@ -2507,7 +2516,6 @@ export class StandardTypeBuilder extends TypeBuilder {
       return this.Create(schema)
     }, options)
   }
-
   /** `[Standard]` Creates a mapped type where all properties are Optional */
   public Partial<T extends TSchema>(schema: T, options: ObjectOptions = {}): TPartial<T> {
     function Apply(schema: TSchema) {
@@ -2617,6 +2625,15 @@ export class StandardTypeBuilder extends TypeBuilder {
       return schema
     }, options)
   }
+  /** `[Standard]` Returns a schema array which allows types to compose with the JavaScript spread operator */
+  public Rest<T extends TSchema>(schema: T): TRest<T> {
+    if (TypeGuard.TTuple(schema)) {
+      if (schema.items === undefined) return [] as TSchema[] as TRest<T>
+      return schema.items.map((schema) => TypeClone.Clone(schema, {})) as TRest<T>
+    } else {
+      return [TypeClone.Clone(schema, {})] as TRest<T>
+    }
+  }
   /** `[Standard]` Creates a String type */
   public String(options: StringOptions = {}): TString {
     return this.Create({ ...options, [Kind]: 'String', type: 'string' })
@@ -2677,40 +2694,20 @@ export class ExtendedTypeBuilder extends StandardTypeBuilder {
     return this.Tuple([...schema.parameters], { ...options })
   }
   /** `[Extended]` Creates a Constructor type */
-  public Constructor<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TConstructor<TTupleIntoArray<T>, U>
-  /** `[Extended]` Creates a Constructor type */
-  public Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>
-  public Constructor(parameters: any, returns: any, options: SchemaOptions = {}) {
+  public Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U> {
     const clonedReturns = TypeClone.Clone(returns, {})
-    if (TypeGuard.TTuple(parameters)) {
-      const clonedParameters = parameters.items === undefined ? [] : parameters.items.map((parameter) => TypeClone.Clone(parameter, {}))
-      return this.Create({ ...options, [Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: clonedParameters, returns: clonedReturns })
-    } else if (globalThis.Array.isArray(parameters)) {
-      const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}))
-      return this.Create({ ...options, [Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: clonedParameters, returns: clonedReturns })
-    } else {
-      throw new Error('ExtendedTypeBuilder.Constructor: Invalid parameters')
-    }
+    const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}))
+    return this.Create({ ...options, [Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: clonedParameters, returns: clonedReturns })
   }
   /** `[Extended]` Creates a Date type */
   public Date(options: DateOptions = {}): TDate {
     return this.Create({ ...options, [Kind]: 'Date', type: 'object', instanceOf: 'Date' })
   }
   /** `[Extended]` Creates a Function type */
-  public Function<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TFunction<TTupleIntoArray<T>, U>
-  /** `[Extended]` Creates a Function type */
-  public Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>
-  public Function(parameters: any, returns: any, options: SchemaOptions = {}) {
+  public Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U> {
     const clonedReturns = TypeClone.Clone(returns, {})
-    if (TypeGuard.TTuple(parameters)) {
-      const clonedParameters = parameters.items === undefined ? [] : parameters.items.map((parameter) => TypeClone.Clone(parameter, {}))
-      return this.Create({ ...options, [Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: clonedParameters, returns: clonedReturns })
-    } else if (globalThis.Array.isArray(parameters)) {
-      const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}))
-      return this.Create({ ...options, [Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: clonedParameters, returns: clonedReturns })
-    } else {
-      throw new Error('ExtendedTypeBuilder.Function: Invalid parameters')
-    }
+    const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}))
+    return this.Create({ ...options, [Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: clonedParameters, returns: clonedReturns })
   }
   /** `[Extended]` Extracts the InstanceType from the given Constructor */
   public InstanceType<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TInstanceType<T> {
diff --git a/test/runtime/assert/assert.ts b/test/runtime/assert/assert.ts
index d632824b4..83ab9a5d5 100644
--- a/test/runtime/assert/assert.ts
+++ b/test/runtime/assert/assert.ts
@@ -7,19 +7,22 @@ export namespace Assert {
     const next = port++
     return next
   }
-  export function equal(actual: unknown, expect: unknown) {
-    return assert.strictEqual(actual, expect)
+  export function isTrue(value: boolean) {
+    return assert.strictEqual(value, true)
   }
-  export function notEqual(actual: unknown, expect: unknown) {
-    return assert.notEqual(actual, expect)
+  export function isFalse(value: boolean) {
+    return assert.strictEqual(value, false)
   }
-  export function deepEqual(actual: unknown, expect: unknown) {
+  export function isEqual(actual: unknown, expect: unknown) {
     if (actual instanceof Uint8Array && expect instanceof Uint8Array) {
       assert.equal(actual.length, expect.length)
       for (let i = 0; i < actual.length; i++) assert.equal(actual[i], expect[i])
     }
     return assert.deepEqual(actual, expect)
   }
+  export function notEqual(actual: unknown, expect: unknown) {
+    return assert.notEqual(actual, expect)
+  }
   let nextIdOrdinal = 0
   export function nextId() {
     return `nextID${nextIdOrdinal++}`
diff --git a/test/runtime/compiler/recursive.ts b/test/runtime/compiler/recursive.ts
index 7ffb2b2ae..b5b1c37ac 100644
--- a/test/runtime/compiler/recursive.ts
+++ b/test/runtime/compiler/recursive.ts
@@ -10,7 +10,7 @@ describe('type/compiler/Recursive', () => {
         nodes: Type.Array(Node),
       }),
     )
-    Assert.equal(Node.$id === undefined, false)
+    Assert.isEqual(Node.$id === undefined, false)
   })
 
   it('Should override default ordinal $id if specified', () => {
@@ -22,7 +22,7 @@ describe('type/compiler/Recursive', () => {
         }),
       { $id: 'Node' },
     )
-    Assert.equal(Node.$id === 'Node', true)
+    Assert.isEqual(Node.$id === 'Node', true)
   })
 
   it('Should validate recursive node type', () => {
diff --git a/test/runtime/errors/iterator.ts b/test/runtime/errors/iterator.ts
index 3a61c3ad9..e0baf4404 100644
--- a/test/runtime/errors/iterator.ts
+++ b/test/runtime/errors/iterator.ts
@@ -5,7 +5,7 @@ import { Assert } from '../assert'
 describe('errors/ValueErrorIterator', () => {
   it('Should return undefined for non error', () => {
     const R = ValueErrors.Errors(Type.Number(), [], 1).First()
-    Assert.equal(R, undefined)
+    Assert.isEqual(R, undefined)
   })
   it('Should return a value error when error', () => {
     const { type, path, message } = ValueErrors.Errors(Type.Number(), [], '').First()!
@@ -15,11 +15,11 @@ describe('errors/ValueErrorIterator', () => {
   })
   it('Should yield empty array for non error', () => {
     const R = [...ValueErrors.Errors(Type.Number(), [], 1)]
-    Assert.equal(R.length, 0)
+    Assert.isEqual(R.length, 0)
   })
   it('Should yield array with 1 error when error', () => {
     const R = [...ValueErrors.Errors(Type.Number(), [], 'foo')]
-    Assert.equal(R.length, 1)
+    Assert.isEqual(R.length, 1)
   })
   it('Should yield array with N errors when error', () => {
     // prettier-ignore
@@ -27,6 +27,6 @@ describe('errors/ValueErrorIterator', () => {
       x: Type.Number(),
       y: Type.Number()
     }), [], {})] // require object to invoke internal check
-    Assert.equal(R.length > 1, true)
+    Assert.isEqual(R.length > 1, true)
   })
 })
diff --git a/test/runtime/schema/composite.ts b/test/runtime/schema/composite.ts
index 9e19cb26c..93061fca4 100644
--- a/test/runtime/schema/composite.ts
+++ b/test/runtime/schema/composite.ts
@@ -89,6 +89,6 @@ describe('type/schema/Composite', () => {
     })
     const A = Type.Composite([T])
     const B = Type.Composite([T])
-    Assert.deepEqual(A, B)
+    Assert.isEqual(A, B)
   })
 })
diff --git a/test/runtime/schema/recursive.ts b/test/runtime/schema/recursive.ts
index a003f7f42..8ec132c0c 100644
--- a/test/runtime/schema/recursive.ts
+++ b/test/runtime/schema/recursive.ts
@@ -10,7 +10,7 @@ describe('type/schema/Recursive', () => {
         nodes: Type.Array(Node),
       }),
     )
-    Assert.equal(Node.$id === undefined, false)
+    Assert.isEqual(Node.$id === undefined, false)
   })
 
   it('Should override default ordinal $id if specified', () => {
@@ -22,7 +22,7 @@ describe('type/schema/Recursive', () => {
         }),
       { $id: 'Node' },
     )
-    Assert.equal(Node.$id === 'Node', true)
+    Assert.isEqual(Node.$id === 'Node', true)
   })
 
   it('Should validate recursive node type', () => {
diff --git a/test/runtime/type/extends/any.ts b/test/runtime/type/extends/any.ts
index ad28839f3..ae1ae1597 100644
--- a/test/runtime/type/extends/any.ts
+++ b/test/runtime/type/extends/any.ts
@@ -6,91 +6,91 @@ describe('type/extends/Any', () => {
   it('Should extend Any', () => {
     type T = any extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = any extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = any extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Boolean', () => {
     type T = any extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Number', () => {
     type T = any extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Integer', () => {
     type T = any extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Array 1', () => {
     type T = any extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Array 2', () => {
     type T = any extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Array(Type.String()))
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Tuple', () => {
     type T = any extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Object 1', () => {
     type T = any extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Object 2', () => {
     type T = any extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Object 3', () => {
     type T = any extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Object({ a: Type.Number() }))
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Union 1', () => {
     type T = any extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Union 2', () => {
     type T = any extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Any(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = any extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Undefined', () => {
     type T = any extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Void', () => {
     type T = any extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Date', () => {
     type T = any extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
 })
diff --git a/test/runtime/type/extends/array.ts b/test/runtime/type/extends/array.ts
index f6a349d33..ac7b04e45 100644
--- a/test/runtime/type/extends/array.ts
+++ b/test/runtime/type/extends/array.ts
@@ -9,22 +9,22 @@ describe('type/extends/Array', () => {
   it('Should extend Array Varying 1', () => {
     type T = Array<any> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array Varying 2', () => {
     type T = Array<string> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array Varying 3', () => {
     type T = Array<any> extends Array<string> ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.String()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array Varying 4', () => {
     type T = Array<number> extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Number()), Type.Array(Type.String()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   // ----------------------------------------------
   // Any
@@ -32,112 +32,112 @@ describe('type/extends/Array', () => {
   it('Should extend Any', () => {
     type T = Array<any> extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = Array<any> extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = Array<any> extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = Array<any> extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = Array<any> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = Array<any> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = Array<any> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array 2', () => {
     type T = Array<string> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array 3', () => {
     type T = Array<any> extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Tuple', () => {
     type T = Array<any> extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = Array<any> extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = Array<any> extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 3', () => {
     type T = Array<any> extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({ a: Type.Number() }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 4', () => {
     type T = Array<any> extends { length: '1' } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({ length: Type.Literal('1') }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 5', () => {
     type T = Array<any> extends { length: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({ length: Type.Number() }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 1', () => {
     type T = Array<any> extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = Array<any> extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = Array<any> extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = Array<string> extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 5', () => {
     type T = Array<any> extends any | Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Array(Type.String())]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = Array<any> extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = Array<any> extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   // ----------------------------------------------
   // Constrained
@@ -145,121 +145,121 @@ describe('type/extends/Array', () => {
   it('Should extend constrained Any', () => {
     type T = Array<string> extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Unknown', () => {
     type T = Array<string> extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained String', () => {
     type T = Array<string> extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Boolean', () => {
     type T = Array<string> extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Number', () => {
     type T = Array<string> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Integer', () => {
     type T = Array<string> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Array 1', () => {
     type T = Array<string> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Array 2', () => {
     type T = Array<string> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Array 3', () => {
     type T = Array<string> extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Tuple', () => {
     type T = Array<string> extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Object 1', () => {
     type T = Array<string> extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Object 2', () => {
     type T = Array<string> extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Object 3', () => {
     type T = Array<string> extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({ a: Type.Number() }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Object 4', () => {
     type T = Array<string> extends { length: '1' } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({ length: Type.Literal('1') }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Object 5', () => {
     type T = Array<string> extends { length: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({ length: Type.Number() }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Union 1', () => {
     type T = Array<string> extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Null(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Union 2', () => {
     type T = Array<string> extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Union 3', () => {
     type T = Array<string> extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Union 4', () => {
     type T = Array<string> extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Union 5', () => {
     type T = Array<string> extends any | Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.String())]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Null', () => {
     type T = Array<string> extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Undefined', () => {
     type T = Array<string> extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Void', () => {
     type T = Array<string> extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = Array<string> extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/bigint.ts b/test/runtime/type/extends/bigint.ts
index 779cb8424..454e22cbe 100644
--- a/test/runtime/type/extends/bigint.ts
+++ b/test/runtime/type/extends/bigint.ts
@@ -6,96 +6,96 @@ describe('type/extends/BigInt', () => {
   it('Should extend Any', () => {
     type T = bigint extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = bigint extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = bigint extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = bigint extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = bigint extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = bigint extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = bigint extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = bigint extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = bigint extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = bigint extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = bigint extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Object({ a: Type.Literal(10) }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = bigint extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = bigint extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = bigint extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 4', () => {
     type T = bigint extends boolean | bigint ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Union([Type.Boolean(), Type.BigInt()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = bigint extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = bigint extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = bigint extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = bigint extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/boolean.ts b/test/runtime/type/extends/boolean.ts
index c627b3a42..8bb9b460f 100644
--- a/test/runtime/type/extends/boolean.ts
+++ b/test/runtime/type/extends/boolean.ts
@@ -6,86 +6,86 @@ describe('type/extends/Boolean', () => {
   it('Should extend Any', () => {
     type T = boolean extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = boolean extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = boolean extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Number', () => {
     type T = boolean extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = boolean extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = boolean extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = boolean extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = boolean extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = boolean extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = boolean extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = boolean extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = boolean extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = boolean extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = boolean extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = boolean extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = boolean extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = boolean extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/constructor.ts b/test/runtime/type/extends/constructor.ts
index 6d5b16ede..82211cbe1 100644
--- a/test/runtime/type/extends/constructor.ts
+++ b/test/runtime/type/extends/constructor.ts
@@ -6,206 +6,206 @@ describe('type/extends/Constructor', () => {
   it('Should extend Function', () => {
     type T = (new () => number) extends () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Function([], Type.Number()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Constructor 1', () => {
     type T = (new () => number) extends new () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Number()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 2', () => {
     type T = (new () => any) extends new () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 3', () => {
     type T = (new () => number) extends new () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 4', () => {
     type T = (new (a: number) => number) extends new () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([], Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Constructor 5', () => {
     type T = (new (a: number | string) => number) extends new (a: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Union([Type.Number(), Type.String()])], Type.Number()), Type.Constructor([Type.Number()], Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 6', () => {
     type T = (new (a: number) => number) extends new (a: number | string) => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([Type.Union([Type.Number(), Type.String()])], Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Constructor 7', () => {
     type T = (new (a: number, b: number) => number) extends new (a: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Number(), Type.Number()], Type.Number()), Type.Constructor([Type.Number()], Type.Number()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Constructor 8', () => {
     type T = (new (a: number) => number) extends new (a: number, b: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([Type.Number(), Type.Number()], Type.Number()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 9', () => {
     type T = (new () => number) extends new () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 9', () => {
     type T = (new () => any) extends new () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 10', () => {
     type T = (new () => Array<any>) extends new () => object ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Array(Type.Any())), Type.Constructor([], Type.Object({})))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 11', () => {
     type T = (new () => Array<string>) extends new () => object ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Array(Type.String())), Type.Constructor([], Type.Object({})))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 12', () => {
     type T = (new () => object) extends new () => Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Object({})), Type.Constructor([], Type.Array(Type.Any())))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Constructor 13', () => {
     type T = (new (a: unknown) => number) extends new (a: any) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Unknown()], Type.Number({})), Type.Constructor([Type.Any()], Type.Number({})))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 14', () => {
     type T = (new (a: any) => number) extends new (a: unknown) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Any()], Type.Number({})), Type.Constructor([Type.Unknown()], Type.Number({})))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 15', () => {
     type T = (new () => any) extends new () => unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Any({})), Type.Constructor([], Type.Unknown({})))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 16', () => {
     type T = (new () => unknown) extends new () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Unknown({})), Type.Constructor([], Type.Any({})))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Any', () => {
     type T = (new () => number) extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = (new () => number) extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = (new () => number) extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = (new () => number) extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = (new () => number) extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = (new () => number) extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = (new () => number) extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 3', () => {
     type T = (new () => number) extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = (new () => number) extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = (() => number) extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = (new () => number) extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = (new () => number) extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 3', () => {
     type T = (new () => number) extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({ a: Type.Number() }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 4', () => {
     type T = (new () => number) extends { length: '1' } ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({ length: Type.Literal('1') }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = (new () => number) extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Null(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = (new () => number) extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = (new () => number) extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = (new () => number) extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 5', () => {
     type T = (new () => number) extends any | Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.String())]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = (new () => number) extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = (new () => number) extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = (new () => number) extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = (new () => number) extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/date.ts b/test/runtime/type/extends/date.ts
index 21b6653ac..7aba817c8 100644
--- a/test/runtime/type/extends/date.ts
+++ b/test/runtime/type/extends/date.ts
@@ -6,91 +6,91 @@ describe('type/extends/Date', () => {
   it('Should extend Any', () => {
     type T = Date extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = Date extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = Date extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = Date extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = Date extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = Date extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = Date extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = Date extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = Date extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = Date extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = Date extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = Date extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = Date extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = Date extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = Date extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = Date extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = Date extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = Date extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
 })
diff --git a/test/runtime/type/extends/function.ts b/test/runtime/type/extends/function.ts
index 8e36b03ed..7823aa382 100644
--- a/test/runtime/type/extends/function.ts
+++ b/test/runtime/type/extends/function.ts
@@ -6,206 +6,206 @@ describe('type/extends/Function', () => {
   it('Should extend Constructor 1', () => {
     type T = (() => number) extends new () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Constructor([], Type.Number()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Function 1', () => {
     type T = (() => number) extends () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Function([], Type.Number()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 2', () => {
     type T = (() => any) extends () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 3', () => {
     type T = (() => number) extends () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 4', () => {
     type T = ((a: number) => number) extends () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Number()], Type.Number()), Type.Function([], Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Function 5', () => {
     type T = ((a: number | string) => number) extends (a: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Union([Type.Number(), Type.String()])], Type.Number()), Type.Function([Type.Number()], Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 6', () => {
     type T = ((a: number) => number) extends (a: number | string) => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Number()], Type.Number()), Type.Function([Type.Union([Type.Number(), Type.String()])], Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Function 7', () => {
     type T = ((a: number, b: number) => number) extends (a: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Number(), Type.Number()], Type.Number()), Type.Function([Type.Number()], Type.Number()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Function 8', () => {
     type T = ((a: number) => number) extends (a: number, b: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Number()], Type.Number()), Type.Function([Type.Number(), Type.Number()], Type.Number()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 9', () => {
     type T = (() => number) extends () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Function([], Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 9', () => {
     type T = (() => any) extends () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 10', () => {
     type T = (() => Array<any>) extends () => object ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Array(Type.Any())), Type.Function([], Type.Object({})))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 11', () => {
     type T = (() => Array<string>) extends () => object ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Array(Type.String())), Type.Function([], Type.Object({})))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 12', () => {
     type T = (() => object) extends () => Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Object({})), Type.Function([], Type.Array(Type.Any())))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Function 13', () => {
     type T = ((a: unknown) => number) extends (a: any) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Unknown()], Type.Number({})), Type.Function([Type.Any()], Type.Number({})))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 14', () => {
     type T = ((a: any) => number) extends (a: unknown) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Any()], Type.Number({})), Type.Function([Type.Unknown()], Type.Number({})))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 15', () => {
     type T = (() => any) extends () => unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Any({})), Type.Function([], Type.Unknown({})))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 16', () => {
     type T = (() => unknown) extends () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Unknown({})), Type.Function([], Type.Any({})))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Any', () => {
     type T = (() => number) extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = (() => number) extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = (() => number) extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = (() => number) extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = (() => number) extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = (() => number) extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = (() => number) extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 3', () => {
     type T = (() => number) extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = (() => number) extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = (() => number) extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = (() => number) extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = (() => number) extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 3', () => {
     type T = (() => number) extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({ a: Type.Number() }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 4', () => {
     type T = (() => number) extends { length: '1' } ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({ length: Type.Literal('1') }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 5', () => {
     type T = (() => number) extends { length: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({ length: Type.Number() }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 1', () => {
     type T = (() => number) extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Null(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = (() => number) extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = (() => number) extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = (() => number) extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 5', () => {
     type T = (() => number) extends any | Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.String())]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = (() => number) extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = (() => number) extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = (() => number) extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/integer.ts b/test/runtime/type/extends/integer.ts
index d3c5e6016..d0113e0f2 100644
--- a/test/runtime/type/extends/integer.ts
+++ b/test/runtime/type/extends/integer.ts
@@ -6,91 +6,91 @@ describe('type/extends/Integer', () => {
   it('Should extend Any', () => {
     type T = number extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = number extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = number extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = number extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = number extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Integer', () => {
     type T = number extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array', () => {
     type T = number extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = number extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = number extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = number extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = number extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Object({ a: Type.Literal(10) }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = number extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = number extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = number extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = number extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = number extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/literal.ts b/test/runtime/type/extends/literal.ts
index f11545ae2..a99e26a95 100644
--- a/test/runtime/type/extends/literal.ts
+++ b/test/runtime/type/extends/literal.ts
@@ -9,77 +9,77 @@ describe('type/extends/Literal', () => {
   it('Should extend Any (String)', () => {
     type T = 'hello' extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown (String)', () => {
     type T = 'hello' extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String (String)', () => {
     type T = 'hello' extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Boolean (String)', () => {
     type T = 'hello' extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number (String)', () => {
     type T = 'hello' extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer (String)', () => {
     type T = 'hello' extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array (String)', () => {
     type T = 'hello' extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple (String)', () => {
     type T = 'hello' extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1 (String)', () => {
     type T = 'hello' extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2 (String)', () => {
     type T = 'hello' extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1 (String)', () => {
     type T = 'hello' extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2 (String)', () => {
     type T = 'hello' extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3 (String)', () => {
     type T = 'hello' extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null (String)', () => {
     type T = 'hello' extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined (String)', () => {
     type T = 'hello' extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   // -------------------------------------------------------------------
   // Number Literal
@@ -87,77 +87,77 @@ describe('type/extends/Literal', () => {
   it('Should extend Any (Number)', () => {
     type T = 10 extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown (Number)', () => {
     type T = 10 extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String (Number)', () => {
     type T = 10 extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean (Number)', () => {
     type T = 10 extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number (Number)', () => {
     type T = 10 extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Integer (Number)', () => {
     type T = 10 extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array (Number)', () => {
     type T = 10 extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple (Number)', () => {
     type T = 10 extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1 (Number)', () => {
     type T = 10 extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2 (Number)', () => {
     type T = 10 extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1 (Number)', () => {
     type T = 10 extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2 (Number)', () => {
     type T = 10 extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3 (Number)', () => {
     type T = 10 extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null (Number)', () => {
     type T = 10 extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined (Number)', () => {
     type T = 10 extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   // -------------------------------------------------------------------
   // Boolean Literal
@@ -165,101 +165,101 @@ describe('type/extends/Literal', () => {
   it('Should extend Any (Boolean)', () => {
     type T = true extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown (Boolean)', () => {
     type T = true extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String (Boolean)', () => {
     type T = true extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean (Boolean)', () => {
     type T = true extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Number (Boolean)', () => {
     type T = true extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer (Boolean)', () => {
     type T = true extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array (Boolean)', () => {
     type T = true extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple (Boolean)', () => {
     type T = true extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record 1', () => {
     type T = 'hello' extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 2', () => {
     type T = 10 extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record 3', () => {
     type T = true extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1 (Boolean)', () => {
     type T = true extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2 (Boolean)', () => {
     type T = true extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1 (Boolean)', () => {
     type T = true extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2 (Boolean)', () => {
     type T = true extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3 (Boolean)', () => {
     type T = true extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null (Boolean)', () => {
     type T = true extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined (Boolean)', () => {
     type T = true extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = true extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = true extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/null.ts b/test/runtime/type/extends/null.ts
index f2d793ab9..dc9077b94 100644
--- a/test/runtime/type/extends/null.ts
+++ b/test/runtime/type/extends/null.ts
@@ -6,96 +6,96 @@ describe('type/extends/Null', () => {
   it('Should extend Any', () => {
     type T = null extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = null extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = null extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = null extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = null extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = null extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = null extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = null extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = null extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = null extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = null extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = null extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = null extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = null extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = null extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = null extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Undefined', () => {
     type T = null extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = null extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = null extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/number.ts b/test/runtime/type/extends/number.ts
index 3c61fbe38..c34c88573 100644
--- a/test/runtime/type/extends/number.ts
+++ b/test/runtime/type/extends/number.ts
@@ -6,91 +6,91 @@ describe('type/extends/Number', () => {
   it('Should extend Any', () => {
     type T = number extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = number extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = number extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = number extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = number extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Integer', () => {
     type T = number extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array', () => {
     type T = number extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = number extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = number extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = number extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = number extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = number extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = number extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = number extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = number extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = number extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/object.ts b/test/runtime/type/extends/object.ts
index b5a2973ed..0ab311516 100644
--- a/test/runtime/type/extends/object.ts
+++ b/test/runtime/type/extends/object.ts
@@ -11,42 +11,42 @@ describe('type/extends/Object', () => {
     const A = Type.Object({ x: Type.Number(), y: Type.Number() })
     const B = Type.Object({ x: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = { x: number } extends { x: number; y: number } ? 1 : 2
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ x: Type.Number(), y: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = { x: number; y: string } extends { x: number } ? 1 : 2
     const A = Type.Object({ x: Type.Number(), y: Type.String() })
     const B = Type.Object({ x: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 4', () => {
     type T = { x: number } extends { x: number; y: string } ? 1 : 2
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ x: Type.Number(), y: Type.String() })
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 5', () => {
     type T = { x: number | string } extends { x: number } ? 1 : 2
     const A = Type.Object({ x: Type.Union([Type.Number(), Type.String()]) })
     const B = Type.Object({ x: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 6', () => {
     type T = { x: number } extends { x: number | string } ? 1 : 2
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ x: Type.Union([Type.Number(), Type.String()]) })
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   // ----------------------------------------------------------
   // Record
@@ -56,35 +56,35 @@ describe('type/extends/Object', () => {
     const A = Type.Object({ a: Type.Number(), b: Type.Number() })
     const B = Type.Record(Type.String(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 3', () => {
     type T = { a: number; b: number } extends Record<number, number> ? 1 : 2
     const A = Type.Object({ a: Type.Number(), b: Type.Number() })
     const B = Type.Record(Type.Number(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 4', () => {
     type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Object({ a: Type.Number(), b: Type.Number() })
     const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 5', () => {
     type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Object({ a: Type.Number(), b: Type.Number() })
     const B = Type.Record(Type.String(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 6', () => {
     type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Object({ a: Type.Number(), b: Type.Number() })
     const B = Type.Record(Type.Number(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   // ----------------------------------------------------------
   // Standard
@@ -92,86 +92,86 @@ describe('type/extends/Object', () => {
   it('Should extend Any', () => {
     type T = { a: number } extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = { a: number } extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = { a: number } extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = { a: number } extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = { a: number } extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = { a: number } extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = { a: number } extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = { a: number } extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = { a: number } extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Object({ a: Type.Literal(10) }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = { a: number } extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 1', () => {
     type T = { a: number } extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Union([Type.Null(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = { a: number } extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = { a: number } extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = { a: number } extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = { a: number } extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = { a: number } extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = { a: number } extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/promise.ts b/test/runtime/type/extends/promise.ts
index 44833d85b..7ebd71de5 100644
--- a/test/runtime/type/extends/promise.ts
+++ b/test/runtime/type/extends/promise.ts
@@ -9,22 +9,22 @@ describe('type/extends/Promise', () => {
   it('Should extend Promise Varying 1', () => {
     type T = Promise<any> extends Promise<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Promise(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Promise Varying 2', () => {
     type T = Promise<string> extends Promise<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.String()), Type.Promise(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Promise Varying 3', () => {
     type T = Promise<any> extends Promise<string> ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Promise(Type.String()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Promise Varying 4', () => {
     type T = Promise<number> extends Promise<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Promise(Type.String()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   // ----------------------------------------------
   // Any
@@ -32,87 +32,87 @@ describe('type/extends/Promise', () => {
   it('Should extend Any', () => {
     type T = Promise<any> extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = Promise<any> extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = Promise<any> extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = Promise<any> extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = Promise<any> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = Promise<any> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = Promise<any> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = Promise<any> extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = Promise<any> extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = Promise<any> extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = Promise<any> extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = Promise<any> extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 1', () => {
     type T = Promise<any> extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = Promise<any> extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = Promise<any> extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = Promise<any> extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = Promise<any> extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   // ----------------------------------------------
   // Constrained
@@ -120,91 +120,91 @@ describe('type/extends/Promise', () => {
   it('Should extend constrained Any', () => {
     type T = Promise<number> extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Unknown', () => {
     type T = Promise<number> extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained String', () => {
     type T = Promise<number> extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Boolean', () => {
     type T = Promise<number> extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Number', () => {
     type T = Promise<number> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Integer', () => {
     type T = Promise<number> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Array', () => {
     type T = Promise<number> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Tuple', () => {
     type T = Promise<number> extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Object 1', () => {
     type T = Promise<number> extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Object 2', () => {
     type T = Promise<number> extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Object 3', () => {
     type T = Promise<number> extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Union 1', () => {
     type T = Promise<number> extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Union 2', () => {
     type T = Promise<number> extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Union 2', () => {
     type T = Promise<number> extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Null', () => {
     type T = Promise<number> extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Undefined', () => {
     type T = Promise<number> extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = Promise<number> extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = Promise<number> extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/record.ts b/test/runtime/type/extends/record.ts
index a3dfa77ee..369e6050a 100644
--- a/test/runtime/type/extends/record.ts
+++ b/test/runtime/type/extends/record.ts
@@ -8,77 +8,77 @@ describe('type/extends/Record', () => {
     const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 2', () => {
     type T = Record<string, number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record 3', () => {
     type T = Record<number, number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record 4', () => {
     type T = Record<'a' | 'b', number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 5', () => {
     type T = Record<'a' | 'b', number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 6', () => {
     type T = Record<string, number> extends Record<'a' | 'b', number> ? true : false
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 7', () => {
     type T = Record<string, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Record(Type.String(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 8', () => {
     type T = Record<string, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Record(Type.Number(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 9', () => {
     type T = Record<number, number> extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
     const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record 10', () => {
     type T = Record<number, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
     const B = Type.Record(Type.String(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 11', () => {
     type T = Record<number, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
     const B = Type.Record(Type.Number(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   // -----
   it('Should extend Record 12', () => {
@@ -86,28 +86,28 @@ describe('type/extends/Record', () => {
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Record(Type.Integer(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 13', () => {
     type T = Record<number, number> extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
     const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record 14', () => {
     type T = Record<number, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
     const B = Type.Record(Type.String(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 15', () => {
     type T = Record<number, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
     const B = Type.Record(Type.Integer(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   // -------------------------------------------------------------------
   // Standard
@@ -115,86 +115,86 @@ describe('type/extends/Record', () => {
   it('Should extend Any', () => {
     type T = Record<number, number> extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = Record<number, number> extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = Record<number, number> extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = Record<number, number> extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = Record<number, number> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = Record<number, number> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = Record<number, number> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = Record<number, number> extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.String()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = Record<number, number> extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = Record<number, number> extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 3', () => {
     type T = Record<number, number> extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Object({ a: Type.Number() }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = Record<number, number> extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = Record<number, number> extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Any(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = Record<number, number> extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = Record<number, number> extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = Record<number, number> extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = Record<number, number> extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/string.ts b/test/runtime/type/extends/string.ts
index 1746be6e6..dc8954666 100644
--- a/test/runtime/type/extends/string.ts
+++ b/test/runtime/type/extends/string.ts
@@ -6,106 +6,106 @@ describe('type/extends/String', () => {
   it('Should extend Any', () => {
     type T = string extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = string extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = string extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Boolean', () => {
     type T = string extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = string extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = string extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = string extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = string extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record 1', () => {
     type T = string extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 2', () => {
     type T = string extends Record<number, unknown> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Unknown()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 3', () => {
     type T = string extends Record<number, string> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.String()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 4', () => {
     type T = string extends Record<number, number> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Number()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = string extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = string extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = number extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = number extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = number extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = number extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = number extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = number extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/symbol.ts b/test/runtime/type/extends/symbol.ts
index 402de3d61..e80838409 100644
--- a/test/runtime/type/extends/symbol.ts
+++ b/test/runtime/type/extends/symbol.ts
@@ -6,101 +6,101 @@ describe('type/extends/Symbol', () => {
   it('Should extend Any', () => {
     type T = symbol extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = symbol extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = symbol extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = symbol extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = symbol extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = symbol extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = symbol extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = symbol extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = symbol extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = symbol extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = symbol extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Object({ a: Type.Literal(10) }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = symbol extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = symbol extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = symbol extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 4', () => {
     type T = symbol extends boolean | symbol ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Union([Type.Boolean(), Type.Symbol()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = symbol extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = symbol extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = symbol extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = symbol extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Symbol', () => {
     type T = symbol extends symbol ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Symbol())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
 })
diff --git a/test/runtime/type/extends/template-literal.ts b/test/runtime/type/extends/template-literal.ts
index 9abf5f547..c8a98aa19 100644
--- a/test/runtime/type/extends/template-literal.ts
+++ b/test/runtime/type/extends/template-literal.ts
@@ -9,77 +9,77 @@ describe('type/extends/TemplateLiteral', () => {
   it('Should extend Any (hello)', () => {
     type T = 'hello' extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown (hello)', () => {
     type T = 'hello' extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String (hello)', () => {
     type T = 'hello' extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Boolean (hello)', () => {
     type T = 'hello' extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number (hello)', () => {
     type T = 'hello' extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer (hello)', () => {
     type T = 'hello' extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array (hello)', () => {
     type T = 'hello' extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple (hello)', () => {
     type T = 'hello' extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1 (hello)', () => {
     type T = 'hello' extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2 (hello)', () => {
     type T = 'hello' extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1 (hello)', () => {
     type T = 'hello' extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2 (hello)', () => {
     type T = 'hello' extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3 (hello)', () => {
     type T = 'hello' extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null (hello)', () => {
     type T = 'hello' extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined (hello)', () => {
     type T = 'hello' extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   // -------------------------------------------------------------------
   // String Literal 'hello' | 'world'
@@ -87,76 +87,76 @@ describe('type/extends/TemplateLiteral', () => {
   it('Should extend Any (hello | world)', () => {
     type T = 'hello' | 'world' extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown (hello | world)', () => {
     type T = 'hello' | 'world' extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String (hello | world)', () => {
     type T = 'hello' | 'world' extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Boolean (hello | world)', () => {
     type T = 'hello' | 'world' extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number (hello | world)', () => {
     type T = 'hello' | 'world' extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer (hello | world)', () => {
     type T = 'hello' | 'world' extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array (hello | world)', () => {
     type T = 'hello' | 'world' extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple (hello | world)', () => {
     type T = 'hello' | 'world' extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1 (hello | world)', () => {
     type T = 'hello' | 'world' extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2 (hello | world)', () => {
     type T = 'hello' | 'world' extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1 (hello | world)', () => {
     type T = 'hello' | 'world' extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2 (hello | world)', () => {
     type T = 'hello' | 'world' extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3 (hello | world)', () => {
     type T = 'hello' | 'world' extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null (hello | world)', () => {
     type T = 'hello' | 'world' extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined (hello | world)', () => {
     type T = 'hello' | 'world' extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/tuple.ts b/test/runtime/type/extends/tuple.ts
index 15486a6a6..f763fb884 100644
--- a/test/runtime/type/extends/tuple.ts
+++ b/test/runtime/type/extends/tuple.ts
@@ -6,156 +6,156 @@ describe('type/extends/Tuple', () => {
   it('Should extend Any', () => {
     type T = [string, number] extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = [string, number] extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = [string, number] extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = [string, number] extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = [string, number] extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = [string, number] extends Array<any> ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array 2', () => {
     type T = [string, number] extends Array<string> ? 1 : 2 // 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.String()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 3', () => {
     type T = [string, number] extends Array<string | number> ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Union([Type.String(), Type.Number()])))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array 4', () => {
     type T = [string, number] extends Array<string | number | boolean> ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Union([Type.String(), Type.Number(), Type.Boolean()])))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Tuple 1', () => {
     type T = [string, number] extends [string, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Tuple 2', () => {
     type T = [string, number] extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple 3', () => {
     type T = [string, any] extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Any()]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple 4', () => {
     type T = [string, number] extends [string, any] ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Any()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Tuple 5', () => {
     type T = [string, unknown] extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Unknown()]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple 6', () => {
     type T = [string, number] extends [string, unknown] ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Unknown()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Tuple 7', () => {
     type T = [] extends [string, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([]), Type.Tuple([Type.String(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple 8', () => {
     type T = [string, number] extends [] ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record 1', () => {
     type T = [string, number] extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 2', () => {
     type T = [string, number] extends Record<number, unknown> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Unknown()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 3', () => {
     type T = [string, number] extends Record<number, string> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.String()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 4', () => {
     type T = [string, number] extends Record<number, number> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Number()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = [string, number] extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = [string, number] extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = [string, number] extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 1', () => {
     type T = [string, number] extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = [string, number] extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = [string, number] extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = [string, number] extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = [string, number] extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = [string, number] extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = [string, number] extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/uint8array.ts b/test/runtime/type/extends/uint8array.ts
index 2ffea0806..286e00d9e 100644
--- a/test/runtime/type/extends/uint8array.ts
+++ b/test/runtime/type/extends/uint8array.ts
@@ -6,91 +6,91 @@ describe('type/extends/Uint8Array', () => {
   it('Should extend Any', () => {
     type T = Uint8Array extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = Uint8Array extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = Uint8Array extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = Uint8Array extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = Uint8Array extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = Uint8Array extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = Uint8Array extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = Uint8Array extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = Uint8Array extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Record(Type.Number(), Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 1', () => {
     type T = Uint8Array extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = Uint8Array extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = Uint8Array extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = Uint8Array extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = Uint8Array extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = Uint8Array extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = Uint8Array extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = Uint8Array extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = Uint8Array extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/undefined.ts b/test/runtime/type/extends/undefined.ts
index f6b39edcb..78b8f4a2b 100644
--- a/test/runtime/type/extends/undefined.ts
+++ b/test/runtime/type/extends/undefined.ts
@@ -6,86 +6,86 @@ describe('type/extends/Undefined', () => {
   it('Should extend Any', () => {
     type T = undefined extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = undefined extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = undefined extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = undefined extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = undefined extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = undefined extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = undefined extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = undefined extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = undefined extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = undefined extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = undefined extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = undefined extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = undefined extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = undefined extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = undefined extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Void', () => {
     type T = undefined extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Date', () => {
     type T = undefined extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/union.ts b/test/runtime/type/extends/union.ts
index ab749f76b..35b00def8 100644
--- a/test/runtime/type/extends/union.ts
+++ b/test/runtime/type/extends/union.ts
@@ -6,131 +6,131 @@ describe('type/extends/Union', () => {
   it('Should extend Any', () => {
     type T = number | string extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = number | string extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = number | string extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = number | string extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = number | string extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = number | string extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = number | string extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = number | string extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Object({}, { additionalProperties: false }))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = number | string extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = number | string extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number | string extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Any(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = number | string extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 4', () => {
     type T = any | boolean extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Union 5', () => {
     type T = any | string extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Union 6', () => {
     type T = any | {} extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Union 7', () => {
     type T = any extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.Union)
+    Assert.isEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Union 8', () => {
     type T = unknown | string extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Unknown(), Type.String()]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 9', () => {
     type T = unknown extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = number | string extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = number | string extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = number | string extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void 2', () => {
     type T = number | string | void extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = number | string | void extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date 2', () => {
     type T = Date | number | string | void extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Date(), Type.Number(), Type.String()]), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend BigInt', () => {
     type T = bigint | number | string | void extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.BigInt(), Type.Number(), Type.String()]), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Symbol', () => {
     type T = symbol | number | string | void extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Symbol(), Type.Number(), Type.String()]), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/unknown.ts b/test/runtime/type/extends/unknown.ts
index 152cd71bd..4a5adba9d 100644
--- a/test/runtime/type/extends/unknown.ts
+++ b/test/runtime/type/extends/unknown.ts
@@ -6,96 +6,96 @@ describe('type/extends/Unknown', () => {
   it('Should extend Any', () => {
     type T = unknown extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = unknown extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = unknown extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = unknown extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = unknown extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = unknown extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = unknown extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = unknown extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Array(Type.String()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = unknown extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = unknown extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = unknown extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Object({ a: Type.Number() }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = unknown extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = unknown extends any | number ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Any(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = unknown extends unknown | number ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = unknown extends unknown | any ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = unknown extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = unknown extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = unknown extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = unknown extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/void.ts b/test/runtime/type/extends/void.ts
index 171994949..8cf53aee2 100644
--- a/test/runtime/type/extends/void.ts
+++ b/test/runtime/type/extends/void.ts
@@ -6,101 +6,101 @@ describe('type/extends/Void', () => {
   it('Should extend Any', () => {
     type T = void extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Any())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = void extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Unknown())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = void extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.String())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = void extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Boolean())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = void extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Number())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = void extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Integer())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = void extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Array(Type.Any()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = void extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Array(Type.String()))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = void extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = void extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = void extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Object({}))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = void extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Object({ a: Type.Number() }))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = void extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Number(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = void extends any | number ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Any(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = void extends unknown | number ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = void extends unknown | any ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = void extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Null())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = void extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Undefined())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = void extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Void())
-    Assert.deepEqual(R, TypeExtendsResult.True)
+    Assert.isEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Date', () => {
     type T = void extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Date())
-    Assert.deepEqual(R, TypeExtendsResult.False)
+    Assert.isEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/guard/any.ts b/test/runtime/type/guard/any.ts
index 8f8e4d86c..ba3eaed09 100644
--- a/test/runtime/type/guard/any.ts
+++ b/test/runtime/type/guard/any.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TAny', () => {
   it('Should guard for TAny', () => {
     const R = TypeGuard.TAny(Type.Any())
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TAny', () => {
     const R = TypeGuard.TAny(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TAny with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TAny(Type.Any({ $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/array.ts b/test/runtime/type/guard/array.ts
index a6bec8803..80a185979 100644
--- a/test/runtime/type/guard/array.ts
+++ b/test/runtime/type/guard/array.ts
@@ -5,12 +5,12 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TArray', () => {
   it('Should guard for TArray', () => {
     const R = TypeGuard.TArray(Type.Array(Type.Number()))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not guard for TArray', () => {
     const R = TypeGuard.TArray(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should guard for nested object TArray', () => {
@@ -22,7 +22,7 @@ describe('type/guard/TArray', () => {
         }),
       ),
     )
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not guard for nested object TArray', () => {
@@ -34,30 +34,30 @@ describe('type/guard/TArray', () => {
         }),
       ),
     )
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TArray with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TArray(Type.Array(Type.Number(), { $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TArray with invalid minItems', () => {
     // @ts-ignore
     const R = TypeGuard.TArray(Type.Array(Type.String(), { minItems: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TArray with invalid maxItems', () => {
     // @ts-ignore
     const R = TypeGuard.TArray(Type.Array(Type.String(), { maxItems: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TArray with invalid uniqueItems', () => {
     // @ts-ignore
     const R = TypeGuard.TArray(Type.Array(Type.String(), { uniqueItems: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/bigint.ts b/test/runtime/type/guard/bigint.ts
index 12be1911b..200294d8b 100644
--- a/test/runtime/type/guard/bigint.ts
+++ b/test/runtime/type/guard/bigint.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TBigInt', () => {
   it('Should guard for TBigInt', () => {
     const R = TypeGuard.TBigInt(Type.BigInt())
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TBigInt', () => {
     const R = TypeGuard.TBigInt(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for BigInt with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TBigInt(Type.BigInt({ $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/boolean.ts b/test/runtime/type/guard/boolean.ts
index 5368dedb2..ec9d8b3cd 100644
--- a/test/runtime/type/guard/boolean.ts
+++ b/test/runtime/type/guard/boolean.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TBoolean', () => {
   it('Should guard for TBoolean', () => {
     const R = TypeGuard.TBoolean(Type.Boolean())
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TBoolean', () => {
     const R = TypeGuard.TBoolean(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TBoolean with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TBoolean(Type.Boolean({ $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/composite.ts b/test/runtime/type/guard/composite.ts
index c9d7d611e..23405772a 100644
--- a/test/runtime/type/guard/composite.ts
+++ b/test/runtime/type/guard/composite.ts
@@ -5,23 +5,23 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TComposite', () => {
   it('Should guard for distinct properties', () => {
     const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
-    Assert.equal(TypeGuard.TNumber(T.properties.x), true)
-    Assert.equal(TypeGuard.TNumber(T.properties.y), true)
+    Assert.isEqual(TypeGuard.TNumber(T.properties.x), true)
+    Assert.isEqual(TypeGuard.TNumber(T.properties.y), true)
   })
   it('Should guard for overlapping properties', () => {
     const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.Number() })])
-    Assert.equal(TypeGuard.TIntersect(T.properties.x), true)
+    Assert.isEqual(TypeGuard.TIntersect(T.properties.x), true)
     // @ts-ignore
-    Assert.equal(TypeGuard.TNumber(T.properties.x.allOf[0]), true)
+    Assert.isEqual(TypeGuard.TNumber(T.properties.x.allOf[0]), true)
     // @ts-ignore
-    Assert.equal(TypeGuard.TNumber(T.properties.x.allOf[1]), true)
+    Assert.isEqual(TypeGuard.TNumber(T.properties.x.allOf[1]), true)
   })
   it('Should not produce optional property if all properties are not optional', () => {
     const T = Type.Composite([Type.Object({ x: Type.Optional(Type.Number()) }), Type.Object({ x: Type.Number() })])
-    Assert.equal(TypeGuard.TOptional(T.properties.x), false)
+    Assert.isEqual(TypeGuard.TOptional(T.properties.x), false)
   })
   it('Should produce optional property if all properties are optional', () => {
     const T = Type.Composite([Type.Object({ x: Type.Optional(Type.Number()) }), Type.Object({ x: Type.Optional(Type.Number()) })])
-    Assert.equal(TypeGuard.TOptional(T.properties.x), true)
+    Assert.isEqual(TypeGuard.TOptional(T.properties.x), true)
   })
 })
diff --git a/test/runtime/type/guard/constructor.ts b/test/runtime/type/guard/constructor.ts
index 813594c0c..b60155859 100644
--- a/test/runtime/type/guard/constructor.ts
+++ b/test/runtime/type/guard/constructor.ts
@@ -5,31 +5,31 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TConstructor', () => {
   it('Should guard for TConstructor', () => {
     const R = TypeGuard.TConstructor(Type.Constructor([], Type.Number()))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TConstructor', () => {
     const R = TypeGuard.TConstructor(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TConstructor with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TConstructor(Type.Constructor([], Type.Number(), { $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TConstructor with invalid Params', () => {
     const R = TypeGuard.TConstructor(Type.Constructor([{} as any, {} as any], Type.Number()))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TConstructor with invalid Return', () => {
     const R = TypeGuard.TConstructor(Type.Constructor([], {} as any))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
-  it('Should guard for TConstructor with empty TTuple', () => {
-    const R = TypeGuard.TConstructor(Type.Constructor(Type.Tuple([]), Type.Number()))
-    Assert.equal(R, true)
+  it('Should guard for TConstructor with empty Rest Tuple', () => {
+    const R = TypeGuard.TConstructor(Type.Constructor(Type.Rest(Type.Tuple([])), Type.Number()))
+    Assert.isEqual(R, true)
   })
-  it('Should guard for TConstructor with array TTuple', () => {
-    const R = TypeGuard.TConstructor(Type.Constructor(Type.Tuple([Type.Number(), Type.String()]), Type.Number()))
-    Assert.equal(R, true)
+  it('Should guard for TConstructor with Rest Tuple', () => {
+    const R = TypeGuard.TConstructor(Type.Constructor(Type.Rest(Type.Tuple([Type.Number(), Type.String()])), Type.Number()))
+    Assert.isEqual(R, true)
   })
 })
diff --git a/test/runtime/type/guard/date.ts b/test/runtime/type/guard/date.ts
index b14cd4600..98fb8db2f 100644
--- a/test/runtime/type/guard/date.ts
+++ b/test/runtime/type/guard/date.ts
@@ -5,41 +5,41 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TDate', () => {
   it('Should guard for TDate', () => {
     const R = TypeGuard.TDate(Type.Date())
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not guard for TDate', () => {
     const R = TypeGuard.TDate(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TDate with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TDate(Type.Number({ $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TDate with invalid minimum', () => {
     // @ts-ignore
     const R = TypeGuard.TDate(Type.Number({ minimum: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TDate with invalid maximum', () => {
     // @ts-ignore
     const R = TypeGuard.TDate(Type.Number({ maximum: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TDate with invalid exclusiveMinimum', () => {
     // @ts-ignore
     const R = TypeGuard.TDate(Type.Number({ exclusiveMinimum: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TDate with invalid exclusiveMaximum', () => {
     // @ts-ignore
     const R = TypeGuard.TDate(Type.Number({ exclusiveMaximum: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/exclude.ts b/test/runtime/type/guard/exclude.ts
index f85a18fad..4f6d3a29f 100644
--- a/test/runtime/type/guard/exclude.ts
+++ b/test/runtime/type/guard/exclude.ts
@@ -5,21 +5,21 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TExclude', () => {
   it('Should extract string from number', () => {
     const T = Type.Exclude(Type.String(), Type.Number())
-    Assert.deepEqual(TypeGuard.TString(T), true)
+    Assert.isEqual(TypeGuard.TString(T), true)
   })
   it('Should extract string from string', () => {
     const T = Type.Exclude(Type.String(), Type.String())
-    Assert.deepEqual(TypeGuard.TNever(T), true)
+    Assert.isEqual(TypeGuard.TNever(T), true)
   })
   it('Should extract string | number | boolean from string', () => {
     const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
-    Assert.deepEqual(TypeGuard.TUnion(T), true)
-    Assert.deepEqual(TypeGuard.TNumber(T.anyOf[0]), true)
-    Assert.deepEqual(TypeGuard.TBoolean(T.anyOf[1]), true)
+    Assert.isEqual(TypeGuard.TUnion(T), true)
+    Assert.isEqual(TypeGuard.TNumber(T.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TBoolean(T.anyOf[1]), true)
   })
   it('Should extract string | number | boolean from string | boolean', () => {
     const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Boolean()]))
-    Assert.deepEqual(TypeGuard.TNumber(T), true)
+    Assert.isEqual(TypeGuard.TNumber(T), true)
   })
   // ------------------------------------------------------------------------
   // TemplateLiteral | TemplateLiteral
@@ -28,20 +28,20 @@ describe('type/guard/TExclude', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const T = Type.Exclude(A, B)
-    Assert.deepEqual(TypeGuard.TNever(T), true)
+    Assert.isEqual(TypeGuard.TNever(T), true)
   })
   it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
     const T = Type.Exclude(A, B)
-    Assert.deepEqual(['C'].includes(T.const), true)
+    Assert.isEqual(['C'].includes(T.const), true)
   })
   it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
     const T = Type.Exclude(A, B)
-    Assert.deepEqual(['C', 'B'].includes(T.anyOf[0].const), true)
-    Assert.deepEqual(['C', 'B'].includes(T.anyOf[1].const), true)
+    Assert.isEqual(['C', 'B'].includes(T.anyOf[0].const), true)
+    Assert.isEqual(['C', 'B'].includes(T.anyOf[1].const), true)
   })
   // ------------------------------------------------------------------------
   // TemplateLiteral | Union 1
@@ -50,20 +50,20 @@ describe('type/guard/TExclude', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const T = Type.Exclude(A, B)
-    Assert.deepEqual(TypeGuard.TNever(T), true)
+    Assert.isEqual(TypeGuard.TNever(T), true)
   })
   it('Should extract TemplateLiteral | Union 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.Union([Type.Literal('A'), Type.Literal('B')])
     const T = Type.Exclude(A, B)
-    Assert.deepEqual(['C'].includes(T.const), true)
+    Assert.isEqual(['C'].includes(T.const), true)
   })
   it('Should extract TemplateLiteral | Union 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.Union([Type.Literal('A')])
     const T = Type.Exclude(A, B)
-    Assert.deepEqual(['C', 'B'].includes(T.anyOf[0].const), true)
-    Assert.deepEqual(['C', 'B'].includes(T.anyOf[1].const), true)
+    Assert.isEqual(['C', 'B'].includes(T.anyOf[0].const), true)
+    Assert.isEqual(['C', 'B'].includes(T.anyOf[1].const), true)
   })
   // ------------------------------------------------------------------------
   // Union | TemplateLiteral 1
@@ -72,19 +72,19 @@ describe('type/guard/TExclude', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const T = Type.Exclude(A, B)
-    Assert.deepEqual(TypeGuard.TNever(T), true)
+    Assert.isEqual(TypeGuard.TNever(T), true)
   })
   it('Should extract Union | TemplateLiteral 1', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
     const T = Type.Exclude(A, B)
-    Assert.deepEqual(['C'].includes(T.const), true)
+    Assert.isEqual(['C'].includes(T.const), true)
   })
   it('Should extract Union | TemplateLiteral 1', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
     const T = Type.Exclude(A, B)
-    Assert.deepEqual(['C', 'B'].includes(T.anyOf[0].const), true)
-    Assert.deepEqual(['C', 'B'].includes(T.anyOf[1].const), true)
+    Assert.isEqual(['C', 'B'].includes(T.anyOf[0].const), true)
+    Assert.isEqual(['C', 'B'].includes(T.anyOf[1].const), true)
   })
 })
diff --git a/test/runtime/type/guard/extract.ts b/test/runtime/type/guard/extract.ts
index 66914e7e7..13d59bd0c 100644
--- a/test/runtime/type/guard/extract.ts
+++ b/test/runtime/type/guard/extract.ts
@@ -5,21 +5,21 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TExtract', () => {
   it('Should extract string from number', () => {
     const T = Type.Extract(Type.String(), Type.Number())
-    Assert.deepEqual(TypeGuard.TNever(T), true)
+    Assert.isEqual(TypeGuard.TNever(T), true)
   })
   it('Should extract string from string', () => {
     const T = Type.Extract(Type.String(), Type.String())
-    Assert.deepEqual(TypeGuard.TString(T), true)
+    Assert.isEqual(TypeGuard.TString(T), true)
   })
   it('Should extract string | number | boolean from string', () => {
     const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
-    Assert.deepEqual(TypeGuard.TString(T), true)
+    Assert.isEqual(TypeGuard.TString(T), true)
   })
   it('Should extract string | number | boolean from string | boolean', () => {
     const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Boolean()]))
-    Assert.deepEqual(TypeGuard.TUnion(T), true)
-    Assert.deepEqual(TypeGuard.TString(T.anyOf[0]), true)
-    Assert.deepEqual(TypeGuard.TBoolean(T.anyOf[1]), true)
+    Assert.isEqual(TypeGuard.TUnion(T), true)
+    Assert.isEqual(TypeGuard.TString(T.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TBoolean(T.anyOf[1]), true)
   })
   // ------------------------------------------------------------------------
   // TemplateLiteral | TemplateLiteral
@@ -28,22 +28,22 @@ describe('type/guard/TExtract', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const T = Type.Extract(A, B)
-    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[0].const), true)
-    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[1].const), true)
-    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[2].const), true)
+    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[0].const), true)
+    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[1].const), true)
+    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[2].const), true)
   })
   it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
     const T = Type.Extract(A, B)
-    Assert.deepEqual(['A', 'B'].includes(T.anyOf[0].const), true)
-    Assert.deepEqual(['A', 'B'].includes(T.anyOf[1].const), true)
+    Assert.isEqual(['A', 'B'].includes(T.anyOf[0].const), true)
+    Assert.isEqual(['A', 'B'].includes(T.anyOf[1].const), true)
   })
   it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
     const T = Type.Extract(A, B)
-    Assert.deepEqual(['A'].includes(T.const), true)
+    Assert.isEqual(['A'].includes(T.const), true)
   })
   // ------------------------------------------------------------------------
   // TemplateLiteral | Union 1
@@ -52,22 +52,22 @@ describe('type/guard/TExtract', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const T = Type.Extract(A, B)
-    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[0].const), true)
-    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[1].const), true)
-    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[2].const), true)
+    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[0].const), true)
+    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[1].const), true)
+    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[2].const), true)
   })
   it('Should extract TemplateLiteral | Union 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.Union([Type.Literal('A'), Type.Literal('B')])
     const T = Type.Extract(A, B)
-    Assert.deepEqual(['A', 'B'].includes(T.anyOf[0].const), true)
-    Assert.deepEqual(['A', 'B'].includes(T.anyOf[1].const), true)
+    Assert.isEqual(['A', 'B'].includes(T.anyOf[0].const), true)
+    Assert.isEqual(['A', 'B'].includes(T.anyOf[1].const), true)
   })
   it('Should extract TemplateLiteral | Union 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.Union([Type.Literal('A')])
     const T = Type.Extract(A, B)
-    Assert.deepEqual(['A'].includes(T.const), true)
+    Assert.isEqual(['A'].includes(T.const), true)
   })
   // ------------------------------------------------------------------------
   // Union | TemplateLiteral 1
@@ -76,21 +76,21 @@ describe('type/guard/TExtract', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const T = Type.Extract(A, B)
-    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[0].const), true)
-    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[1].const), true)
-    Assert.deepEqual(['A', 'B', 'C'].includes(T.anyOf[2].const), true)
+    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[0].const), true)
+    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[1].const), true)
+    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[2].const), true)
   })
   it('Should extract Union | TemplateLiteral 1', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
     const T = Type.Extract(A, B)
-    Assert.deepEqual(['A', 'B'].includes(T.anyOf[0].const), true)
-    Assert.deepEqual(['A', 'B'].includes(T.anyOf[1].const), true)
+    Assert.isEqual(['A', 'B'].includes(T.anyOf[0].const), true)
+    Assert.isEqual(['A', 'B'].includes(T.anyOf[1].const), true)
   })
   it('Should extract Union | TemplateLiteral 1', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
     const T = Type.Extract(A, B)
-    Assert.deepEqual(['A'].includes(T.const), true)
+    Assert.isEqual(['A'].includes(T.const), true)
   })
 })
diff --git a/test/runtime/type/guard/function.ts b/test/runtime/type/guard/function.ts
index e70b67d57..2608266fd 100644
--- a/test/runtime/type/guard/function.ts
+++ b/test/runtime/type/guard/function.ts
@@ -5,31 +5,31 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TFunction', () => {
   it('Should guard for TFunction', () => {
     const R = TypeGuard.TFunction(Type.Function([], Type.Number()))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TFunction', () => {
     const R = TypeGuard.TFunction(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TFunction with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TFunction(Type.Function([], Type.Number(), { $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TFunction with invalid Params', () => {
     const R = TypeGuard.TFunction(Type.Function([{} as any, {} as any], Type.Number()))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TFunction with invalid Return', () => {
     const R = TypeGuard.TFunction(Type.Function([], {} as any))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
-  it('Should guard for TFunction with empty TTuple', () => {
-    const R = TypeGuard.TFunction(Type.Function(Type.Tuple([]), Type.Number()))
-    Assert.equal(R, true)
+  it('Should guard for TFunction with empty Rest Tuple', () => {
+    const R = TypeGuard.TFunction(Type.Function(Type.Rest(Type.Tuple([])), Type.Number()))
+    Assert.isEqual(R, true)
   })
-  it('Should guard for TFunction with array TTuple', () => {
-    const R = TypeGuard.TFunction(Type.Function(Type.Tuple([Type.Number(), Type.String()]), Type.Number()))
-    Assert.equal(R, true)
+  it('Should guard for TFunction with Rest Tuple', () => {
+    const R = TypeGuard.TFunction(Type.Function(Type.Rest(Type.Tuple([Type.Number(), Type.String()])), Type.Number()))
+    Assert.isEqual(R, true)
   })
 })
diff --git a/test/runtime/type/guard/index.ts b/test/runtime/type/guard/index.ts
index 907c82e4a..969112f91 100644
--- a/test/runtime/type/guard/index.ts
+++ b/test/runtime/type/guard/index.ts
@@ -23,6 +23,7 @@ import './pick'
 import './promise'
 import './record'
 import './ref'
+import './rest'
 import './string'
 import './symbol'
 import './template-literal'
diff --git a/test/runtime/type/guard/indexed.ts b/test/runtime/type/guard/indexed.ts
index 0ddd02fe9..15eeaa08b 100644
--- a/test/runtime/type/guard/indexed.ts
+++ b/test/runtime/type/guard/indexed.ts
@@ -9,7 +9,7 @@ describe('type/guard/TIndex', () => {
       y: Type.String(),
     })
     const I = Type.Index(T, ['x'])
-    Assert.deepEqual(TypeGuard.TNumber(I), true)
+    Assert.isEqual(TypeGuard.TNumber(I), true)
   })
   it('Should Index 2', () => {
     const T = Type.Object({
@@ -17,9 +17,9 @@ describe('type/guard/TIndex', () => {
       y: Type.String(),
     })
     const I = Type.Index(T, ['x', 'y'])
-    Assert.deepEqual(TypeGuard.TUnion(I), true)
-    Assert.deepEqual(TypeGuard.TNumber(I.anyOf[0]), true)
-    Assert.deepEqual(TypeGuard.TString(I.anyOf[1]), true)
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(TypeGuard.TNumber(I.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
   })
   it('Should Index 3', () => {
     const T = Type.Object({
@@ -27,9 +27,9 @@ describe('type/guard/TIndex', () => {
       y: Type.String(),
     })
     const I = Type.Index(T, Type.KeyOf(T))
-    Assert.deepEqual(TypeGuard.TUnion(I), true)
-    Assert.deepEqual(TypeGuard.TNumber(I.anyOf[0]), true)
-    Assert.deepEqual(TypeGuard.TString(I.anyOf[1]), true)
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(TypeGuard.TNumber(I.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
   })
   it('Should Index 4', () => {
     const T = Type.Object({
@@ -37,62 +37,79 @@ describe('type/guard/TIndex', () => {
       ac: Type.String(),
     })
     const I = Type.Index(T, Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])]))
-    Assert.deepEqual(TypeGuard.TUnion(I), true)
-    Assert.deepEqual(TypeGuard.TNumber(I.anyOf[0]), true)
-    Assert.deepEqual(TypeGuard.TString(I.anyOf[1]), true)
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(TypeGuard.TNumber(I.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
   })
   it('Should Index 5', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.String() })])
     const I = Type.Index(T, ['x', 'y'])
-    Assert.deepEqual(TypeGuard.TUnion(I), true)
-    Assert.deepEqual(TypeGuard.TNumber(I.anyOf[0]), true)
-    Assert.deepEqual(TypeGuard.TString(I.anyOf[1]), true)
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(TypeGuard.TNumber(I.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
   })
   it('Should Index 6', () => {
     const T = Type.Union([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.String() })])
     const I = Type.Index(T, ['x'])
-    Assert.deepEqual(TypeGuard.TUnion(I), true)
-    Assert.deepEqual(TypeGuard.TNumber(I.anyOf[0]), true)
-    Assert.deepEqual(TypeGuard.TString(I.anyOf[1]), true)
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(TypeGuard.TNumber(I.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
   })
   it('Should Index 7', () => {
     const T = Type.Array(Type.Null())
     const I = Type.Index(T, Type.Number())
-    Assert.deepEqual(TypeGuard.TNull(I), true)
+    Assert.isEqual(TypeGuard.TNull(I), true)
   })
   it('Should Index 6', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [0])
-    Assert.deepEqual(TypeGuard.TLiteralString(I), true)
-    Assert.deepEqual(I.const, 'hello')
+    Assert.isEqual(TypeGuard.TLiteralString(I), true)
+    Assert.isEqual(I.const, 'hello')
   })
   it('Should Index 8', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [1])
-    Assert.deepEqual(TypeGuard.TLiteralString(I), true)
-    Assert.deepEqual(I.const, 'world')
+    Assert.isEqual(TypeGuard.TLiteralString(I), true)
+    Assert.isEqual(I.const, 'world')
   })
   it('Should Index 9', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [0, 1])
-    Assert.deepEqual(TypeGuard.TUnion(I), true)
-    Assert.deepEqual(I.anyOf[0].const, 'hello')
-    Assert.deepEqual(I.anyOf[1].const, 'world')
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(I.anyOf[0].const, 'hello')
+    Assert.isEqual(I.anyOf[1].const, 'world')
   })
   it('Should Index 10', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [1, 0])
-    Assert.deepEqual(TypeGuard.TUnion(I), true)
-    Assert.deepEqual(I.anyOf[0].const, 'world')
-    Assert.deepEqual(I.anyOf[1].const, 'hello')
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(I.anyOf[0].const, 'world')
+    Assert.isEqual(I.anyOf[1].const, 'hello')
   })
   it('Should Index 11', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [0, 0, 0, 1])
-    Assert.deepEqual(TypeGuard.TUnion(I), true)
-    Assert.deepEqual(I.anyOf[0].const, 'hello')
-    Assert.deepEqual(I.anyOf[1].const, 'hello')
-    Assert.deepEqual(I.anyOf[2].const, 'hello')
-    Assert.deepEqual(I.anyOf[3].const, 'world')
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(I.anyOf[0].const, 'hello')
+    Assert.isEqual(I.anyOf[1].const, 'hello')
+    Assert.isEqual(I.anyOf[2].const, 'hello')
+    Assert.isEqual(I.anyOf[3].const, 'world')
+  })
+  it('Should Index 12', () => {
+    const T = Type.Tuple([Type.String(), Type.Boolean()])
+    const I = Type.Index(T, Type.Number())
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TBoolean(I.anyOf[1]), true)
+  })
+  it('Should Index 13', () => {
+    const T = Type.Tuple([Type.String()])
+    const I = Type.Index(T, Type.Number())
+    Assert.isEqual(TypeGuard.TString(I), true)
+  })
+  it('Should Index 14', () => {
+    const T = Type.Tuple([])
+    const I = Type.Index(T, Type.Number())
+    Assert.isEqual(TypeGuard.TNever(I), true)
   })
 })
diff --git a/test/runtime/type/guard/integer.ts b/test/runtime/type/guard/integer.ts
index 28976d20e..1938d4d23 100644
--- a/test/runtime/type/guard/integer.ts
+++ b/test/runtime/type/guard/integer.ts
@@ -5,40 +5,40 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TInteger', () => {
   it('Should guard for TInteger', () => {
     const R = TypeGuard.TInteger(Type.Integer())
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TInteger', () => {
     const R = TypeGuard.TInteger(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TInteger with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TInteger with invalid multipleOf', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ multipleOf: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TInteger with invalid minimum', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ minimum: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TInteger with invalid maximum', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ maximum: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TInteger with invalid exclusiveMinimum', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ exclusiveMinimum: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TInteger with invalid exclusiveMaximum', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ exclusiveMaximum: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/intersect.ts b/test/runtime/type/guard/intersect.ts
index 907b4a72d..9ed33e6b2 100644
--- a/test/runtime/type/guard/intersect.ts
+++ b/test/runtime/type/guard/intersect.ts
@@ -14,7 +14,7 @@ describe('type/guard/TUnion', () => {
         }),
       ]),
     )
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TIntersect', () => {
     const R = TypeGuard.TIntersect(
@@ -27,6 +27,6 @@ describe('type/guard/TUnion', () => {
         }),
       ]),
     )
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/keyof.ts b/test/runtime/type/guard/keyof.ts
index 59c3067bd..cca0b0dae 100644
--- a/test/runtime/type/guard/keyof.ts
+++ b/test/runtime/type/guard/keyof.ts
@@ -9,9 +9,9 @@ describe('type/guard/TKeyOf', () => {
       y: Type.Number(),
     })
     const K = Type.KeyOf(T)
-    Assert.deepEqual(TypeGuard.TUnion(K), true)
-    Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[0]), true)
-    Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[1]), true)
+    Assert.isEqual(TypeGuard.TUnion(K), true)
+    Assert.isEqual(TypeGuard.TLiteral(K.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TLiteral(K.anyOf[1]), true)
   })
   it('Should KeyOf 2', () => {
     const T = Type.Recursive((Self) =>
@@ -21,9 +21,9 @@ describe('type/guard/TKeyOf', () => {
       }),
     )
     const K = Type.KeyOf(T)
-    Assert.deepEqual(TypeGuard.TUnion(K), true)
-    Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[0]), true)
-    Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[1]), true)
+    Assert.isEqual(TypeGuard.TUnion(K), true)
+    Assert.isEqual(TypeGuard.TLiteral(K.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TLiteral(K.anyOf[1]), true)
   })
   it('Should KeyOf 3', () => {
     const T = Type.Intersect([
@@ -35,9 +35,9 @@ describe('type/guard/TKeyOf', () => {
       }),
     ])
     const K = Type.KeyOf(T)
-    Assert.deepEqual(TypeGuard.TUnion(K), true)
-    Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[0]), true)
-    Assert.deepEqual(TypeGuard.TLiteral(K.anyOf[1]), true)
+    Assert.isEqual(TypeGuard.TUnion(K), true)
+    Assert.isEqual(TypeGuard.TLiteral(K.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TLiteral(K.anyOf[1]), true)
   })
   it('Should KeyOf 4', () => {
     const T = Type.Union([
@@ -49,28 +49,28 @@ describe('type/guard/TKeyOf', () => {
       }),
     ])
     const K = Type.KeyOf(T)
-    Assert.deepEqual(TypeGuard.TNever(K), true)
+    Assert.isEqual(TypeGuard.TNever(K), true)
   })
   it('Should KeyOf 5', () => {
     const T = Type.Null()
     const K = Type.KeyOf(T)
-    Assert.deepEqual(TypeGuard.TNever(K), true)
+    Assert.isEqual(TypeGuard.TNever(K), true)
   })
   it('Should KeyOf 6', () => {
     const T = Type.Array(Type.Number())
     const K = Type.KeyOf(T)
-    Assert.deepEqual(TypeGuard.TNumber(K), true)
+    Assert.isEqual(TypeGuard.TNumber(K), true)
   })
   it('Should KeyOf 7', () => {
     const T = Type.Tuple([])
     const K = Type.KeyOf(T)
-    Assert.deepEqual(TypeGuard.TNever(K), true)
+    Assert.isEqual(TypeGuard.TNever(K), true)
   })
   it('Should KeyOf 8', () => {
     const T = Type.Tuple([Type.Number(), Type.Null()])
     const K = Type.KeyOf(T)
-    Assert.deepEqual(TypeGuard.TUnion(K), true)
-    Assert.deepEqual(K.anyOf[0].const, '0')
-    Assert.deepEqual(K.anyOf[1].const, '1')
+    Assert.isEqual(TypeGuard.TUnion(K), true)
+    Assert.isEqual(K.anyOf[0].const, '0')
+    Assert.isEqual(K.anyOf[1].const, '1')
   })
 })
diff --git a/test/runtime/type/guard/literal.ts b/test/runtime/type/guard/literal.ts
index 674c9dd40..70d568f39 100644
--- a/test/runtime/type/guard/literal.ts
+++ b/test/runtime/type/guard/literal.ts
@@ -5,28 +5,28 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TLiteral', () => {
   it('Should guard for TLiteral of String', () => {
     const R = TypeGuard.TLiteral(Type.Literal('hello'))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should guard for TLiteral of Number', () => {
     const R = TypeGuard.TLiteral(Type.Literal(42))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should guard for TLiteral of Boolean', () => {
     const R = TypeGuard.TLiteral(Type.Literal(true))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TLiteral of Null', () => {
     // @ts-ignore
     const R = TypeGuard.TLiteral(Type.Literal(null))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TLiteral', () => {
     const R = TypeGuard.TLiteral(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TLiteral with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TLiteral(Type.Literal(42, { $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/not.ts b/test/runtime/type/guard/not.ts
index 0bbc9d5ec..b5a8bf07a 100644
--- a/test/runtime/type/guard/not.ts
+++ b/test/runtime/type/guard/not.ts
@@ -5,19 +5,19 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TNot', () => {
   it('Should guard for TNot', () => {
     const R = TypeGuard.TNot(Type.Not(Type.String(), Type.String()))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TNot 1', () => {
     const R = TypeGuard.TNot(Type.Not(null as any, Type.String()))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TNot 2', () => {
     const R = TypeGuard.TNot(Type.Not(Type.String(), null as any))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TNot with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TNot(Type.Not(Type.String(), Type.String()), { $id: 1 })
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
 })
diff --git a/test/runtime/type/guard/null.ts b/test/runtime/type/guard/null.ts
index 11656ab0c..7fc7f1931 100644
--- a/test/runtime/type/guard/null.ts
+++ b/test/runtime/type/guard/null.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TNull', () => {
   it('Should guard for TNull', () => {
     const R = TypeGuard.TNull(Type.Null())
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TNull', () => {
     const R = TypeGuard.TNull(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TNull with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TNull(Type.Null({ $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/number.ts b/test/runtime/type/guard/number.ts
index c325b27b4..de8782045 100644
--- a/test/runtime/type/guard/number.ts
+++ b/test/runtime/type/guard/number.ts
@@ -5,40 +5,40 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TNumber', () => {
   it('Should guard for TNumber', () => {
     const R = TypeGuard.TNumber(Type.Number())
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TNumber', () => {
     const R = TypeGuard.TNumber(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TNumber with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TNumber with invalid multipleOf', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ multipleOf: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TNumber with invalid minimum', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ minimum: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TNumber with invalid maximum', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ maximum: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TNumber with invalid exclusiveMinimum', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ exclusiveMinimum: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TNumber with invalid exclusiveMaximum', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ exclusiveMaximum: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/object.ts b/test/runtime/type/guard/object.ts
index 2cdb5044c..4811794bd 100644
--- a/test/runtime/type/guard/object.ts
+++ b/test/runtime/type/guard/object.ts
@@ -10,12 +10,12 @@ describe('type/guard/TObject', () => {
         y: Type.Number(),
       }),
     )
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not guard for TObject', () => {
     const R = TypeGuard.TObject(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TObject with escape characters in property key', () => {
@@ -24,7 +24,7 @@ describe('type/guard/TObject', () => {
         'hello\nworld': Type.Number(),
       }),
     )
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TObject with invalid property values', () => {
@@ -34,7 +34,7 @@ describe('type/guard/TObject', () => {
         y: {} as any,
       }),
     )
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TObject with invalid additionalProperties', () => {
@@ -49,7 +49,7 @@ describe('type/guard/TObject', () => {
         },
       ),
     )
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TObject with invalid $id', () => {
@@ -64,7 +64,7 @@ describe('type/guard/TObject', () => {
         },
       ),
     )
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TObject with invalid minProperties', () => {
@@ -79,7 +79,7 @@ describe('type/guard/TObject', () => {
         },
       ),
     )
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TObject with invalid maxProperties', () => {
@@ -94,7 +94,7 @@ describe('type/guard/TObject', () => {
         },
       ),
     )
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should guard for TObject with invalid additional properties', () => {
@@ -110,7 +110,7 @@ describe('type/guard/TObject', () => {
         },
       ),
     )
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TObject with valid additional properties schema', () => {
@@ -125,6 +125,6 @@ describe('type/guard/TObject', () => {
         },
       ),
     )
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
 })
diff --git a/test/runtime/type/guard/omit.ts b/test/runtime/type/guard/omit.ts
index debf380db..0c2ccaf1a 100644
--- a/test/runtime/type/guard/omit.ts
+++ b/test/runtime/type/guard/omit.ts
@@ -8,11 +8,11 @@ describe('type/guard/TOmit', () => {
   // -------------------------------------------------------------------------
   it('Should support TUnsafe omit properties with no Kind', () => {
     const T = Type.Omit(Type.Object({ x: Type.Unsafe({ x: 1 }), y: Type.Number() }), ['x'])
-    Assert.deepEqual(T.required, ['y'])
+    Assert.isEqual(T.required, ['y'])
   })
   it('Should support TUnsafe omit properties with unregistered Kind', () => {
     const T = Type.Omit(Type.Object({ x: Type.Unsafe({ x: 1, [Kind]: 'UnknownOmitType' }), y: Type.Number() }), ['x'])
-    Assert.deepEqual(T.required, ['y'])
+    Assert.isEqual(T.required, ['y'])
   })
   // -------------------------------------------------------------------------
   // Standard Tests
@@ -25,8 +25,8 @@ describe('type/guard/TOmit', () => {
       }),
       ['x'],
     )
-    Assert.deepEqual(TypeGuard.TNumber(T.properties.y), true)
-    Assert.deepEqual(T.required, ['y'])
+    Assert.isEqual(TypeGuard.TNumber(T.properties.y), true)
+    Assert.isEqual(T.required, ['y'])
   })
   it('Should Omit 2', () => {
     const T = Type.Omit(
@@ -36,8 +36,8 @@ describe('type/guard/TOmit', () => {
       }),
       ['x'],
     )
-    Assert.deepEqual(TypeGuard.TNumber(T.properties.y), true)
-    Assert.deepEqual(T.required, undefined)
+    Assert.isEqual(TypeGuard.TNumber(T.properties.y), true)
+    Assert.isEqual(T.required, undefined)
   })
   it('Should Omit 3', () => {
     const L = Type.Literal('x')
@@ -48,15 +48,15 @@ describe('type/guard/TOmit', () => {
       }),
       L,
     )
-    Assert.deepEqual(TypeGuard.TNumber(T.properties.y), true)
-    Assert.deepEqual(T.required, ['y'])
+    Assert.isEqual(TypeGuard.TNumber(T.properties.y), true)
+    Assert.isEqual(T.required, ['y'])
   })
   it('Should Omit 4', () => {
     const L = Type.Literal('x')
     const T = Type.Omit(Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })]), L)
-    Assert.deepEqual(TypeGuard.TNumber(T.allOf[1].properties.y), true)
+    Assert.isEqual(TypeGuard.TNumber(T.allOf[1].properties.y), true)
     // @ts-ignore
-    Assert.deepEqual(T.allOf[1].properties.x, undefined)
+    Assert.isEqual(T.allOf[1].properties.x, undefined)
   })
   it('Should Omit 5', () => {
     const L = Type.Union([Type.Literal('x'), Type.Literal('y')])
@@ -68,11 +68,11 @@ describe('type/guard/TOmit', () => {
       L,
     )
     // @ts-ignore
-    Assert.deepEqual(T.properties.x, undefined)
+    Assert.isEqual(T.properties.x, undefined)
     // @ts-ignore
-    Assert.deepEqual(T.properties.y, undefined)
+    Assert.isEqual(T.properties.y, undefined)
     // @ts-ignore
-    Assert.deepEqual(T.required, undefined)
+    Assert.isEqual(T.required, undefined)
   })
   it('Should Omit 6', () => {
     const L = Type.Union([Type.Literal('x'), Type.Literal('y'), Type.Literal('z')])
@@ -84,11 +84,11 @@ describe('type/guard/TOmit', () => {
       L,
     )
     // @ts-ignore
-    Assert.deepEqual(T.properties.x, undefined)
+    Assert.isEqual(T.properties.x, undefined)
     // @ts-ignore
-    Assert.deepEqual(T.properties.y, undefined)
+    Assert.isEqual(T.properties.y, undefined)
     // @ts-ignore
-    Assert.deepEqual(T.required, undefined)
+    Assert.isEqual(T.required, undefined)
   })
   it('Should Omit 7', () => {
     const L = Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])])
@@ -100,7 +100,7 @@ describe('type/guard/TOmit', () => {
       }),
       L,
     )
-    Assert.deepEqual(TypeGuard.TNumber(T.properties.ad), true)
-    Assert.deepEqual(T.required, ['ad'])
+    Assert.isEqual(TypeGuard.TNumber(T.properties.ad), true)
+    Assert.isEqual(T.required, ['ad'])
   })
 })
diff --git a/test/runtime/type/guard/partial.ts b/test/runtime/type/guard/partial.ts
index 5eb292ca9..523f2acc3 100644
--- a/test/runtime/type/guard/partial.ts
+++ b/test/runtime/type/guard/partial.ts
@@ -9,15 +9,15 @@ describe('type/guard/TPartial', () => {
   // -------------------------------------------------------------------------
   it('Should support TUnsafe partial properties with no Kind', () => {
     const T = Type.Partial(Type.Object({ x: Type.Unsafe({ x: 1 }) }))
-    Assert.deepEqual(T.required, undefined)
+    Assert.isEqual(T.required, undefined)
   })
   it('Should support TUnsafe partial properties with unregistered Kind', () => {
     const T = Type.Partial(Type.Object({ x: Type.Unsafe({ [Kind]: 'UnknownPartialType', x: 1 }) }))
-    Assert.deepEqual(T.required, undefined)
+    Assert.isEqual(T.required, undefined)
   })
   it('Should support TUnsafe partial properties with registered Kind', () => {
     const U = TypeSystem.Type('CustomPartialType', () => true)
     const T = Type.Partial(Type.Object({ x: U() }))
-    Assert.deepEqual(T.required, undefined)
+    Assert.isEqual(T.required, undefined)
   })
 })
diff --git a/test/runtime/type/guard/pick.ts b/test/runtime/type/guard/pick.ts
index 2ca44cc15..43a22ce80 100644
--- a/test/runtime/type/guard/pick.ts
+++ b/test/runtime/type/guard/pick.ts
@@ -14,11 +14,11 @@ describe('type/guard/TPick', () => {
       }),
       ['x'],
     )
-    Assert.deepEqual(T.required, ['x'])
+    Assert.isEqual(T.required, ['x'])
   })
   it('Should support TUnsafe omit properties with unregistered Kind', () => {
     const T = Type.Pick(Type.Object({ x: Type.Unsafe({ x: 1, [Kind]: 'UnknownPickType' }), y: Type.Number() }), ['x'])
-    Assert.deepEqual(T.required, ['x'])
+    Assert.isEqual(T.required, ['x'])
   })
   // -------------------------------------------------------------------------
   // Standard Tests
@@ -31,8 +31,8 @@ describe('type/guard/TPick', () => {
       }),
       ['x'],
     )
-    Assert.deepEqual(TypeGuard.TNumber(T.properties.x), true)
-    Assert.deepEqual(T.required, ['x'])
+    Assert.isEqual(TypeGuard.TNumber(T.properties.x), true)
+    Assert.isEqual(T.required, ['x'])
   })
   it('Should Pick 2', () => {
     const T = Type.Pick(
@@ -42,8 +42,8 @@ describe('type/guard/TPick', () => {
       }),
       ['x'],
     )
-    Assert.deepEqual(TypeGuard.TNumber(T.properties.x), true)
-    Assert.deepEqual(T.required, undefined)
+    Assert.isEqual(TypeGuard.TNumber(T.properties.x), true)
+    Assert.isEqual(T.required, undefined)
   })
   it('Should Pick 3', () => {
     const L = Type.Literal('x')
@@ -54,16 +54,16 @@ describe('type/guard/TPick', () => {
       }),
       L,
     )
-    Assert.deepEqual(TypeGuard.TNumber(T.properties.x), true)
-    Assert.deepEqual(T.required, ['x'])
+    Assert.isEqual(TypeGuard.TNumber(T.properties.x), true)
+    Assert.isEqual(T.required, ['x'])
   })
   it('Should Pick 4', () => {
     const L = Type.Literal('x')
     const T = Type.Pick(Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })]), L)
 
-    Assert.deepEqual(TypeGuard.TNumber(T.allOf[0].properties.x), true)
+    Assert.isEqual(TypeGuard.TNumber(T.allOf[0].properties.x), true)
     // @ts-ignore
-    Assert.deepEqual(T.allOf[1].properties.y, undefined)
+    Assert.isEqual(T.allOf[1].properties.y, undefined)
   })
   it('Should Pick 5', () => {
     const L = Type.Union([Type.Literal('x'), Type.Literal('y')])
@@ -74,9 +74,9 @@ describe('type/guard/TPick', () => {
       }),
       L,
     )
-    Assert.deepEqual(TypeGuard.TNumber(T.properties.x), true)
-    Assert.deepEqual(TypeGuard.TNumber(T.properties.y), true)
-    Assert.deepEqual(T.required, ['x', 'y'])
+    Assert.isEqual(TypeGuard.TNumber(T.properties.x), true)
+    Assert.isEqual(TypeGuard.TNumber(T.properties.y), true)
+    Assert.isEqual(T.required, ['x', 'y'])
   })
   it('Should Pick 6', () => {
     const L = Type.Union([Type.Literal('x'), Type.Literal('y'), Type.Literal('z')])
@@ -87,9 +87,9 @@ describe('type/guard/TPick', () => {
       }),
       L,
     )
-    Assert.deepEqual(TypeGuard.TNumber(T.properties.x), true)
-    Assert.deepEqual(TypeGuard.TNumber(T.properties.y), true)
-    Assert.deepEqual(T.required, ['x', 'y'])
+    Assert.isEqual(TypeGuard.TNumber(T.properties.x), true)
+    Assert.isEqual(TypeGuard.TNumber(T.properties.y), true)
+    Assert.isEqual(T.required, ['x', 'y'])
   })
   it('Should Pick 7', () => {
     const L = Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])])
@@ -101,8 +101,8 @@ describe('type/guard/TPick', () => {
       }),
       L,
     )
-    Assert.deepEqual(TypeGuard.TNumber(T.properties.ab), true)
-    Assert.deepEqual(TypeGuard.TNumber(T.properties.ac), true)
-    Assert.deepEqual(T.required, ['ab', 'ac'])
+    Assert.isEqual(TypeGuard.TNumber(T.properties.ab), true)
+    Assert.isEqual(TypeGuard.TNumber(T.properties.ac), true)
+    Assert.isEqual(T.required, ['ab', 'ac'])
   })
 })
diff --git a/test/runtime/type/guard/promise.ts b/test/runtime/type/guard/promise.ts
index eeedaf2f0..96e49b0bd 100644
--- a/test/runtime/type/guard/promise.ts
+++ b/test/runtime/type/guard/promise.ts
@@ -5,18 +5,18 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TPromise', () => {
   it('Should guard for TPromise', () => {
     const R = TypeGuard.TPromise(Type.Promise(Type.Number()))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not guard for TPromise', () => {
     const R = TypeGuard.TPromise(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TPromise with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TPromise(Type.Promise(Type.Number(), { $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should guard for TPromise with nested TObject', () => {
@@ -28,7 +28,7 @@ describe('type/guard/TPromise', () => {
         }),
       ),
     )
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not guard for TPromise with nested TObject', () => {
@@ -40,6 +40,6 @@ describe('type/guard/TPromise', () => {
         }),
       ),
     )
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/record.ts b/test/runtime/type/guard/record.ts
index f43a70a1a..350f9b3fc 100644
--- a/test/runtime/type/guard/record.ts
+++ b/test/runtime/type/guard/record.ts
@@ -8,16 +8,16 @@ describe('type/guard/TRecord', () => {
   // -------------------------------------------------------------
   it('Should guard overload 1', () => {
     const T = Type.Record(Type.Union([Type.Literal('A'), Type.Literal('B')]), Type.String(), { extra: 1 })
-    Assert.equal(TypeGuard.TObject(T), true)
-    Assert.equal(TypeGuard.TString(T.properties.A), true)
-    Assert.equal(TypeGuard.TString(T.properties.B), true)
-    Assert.equal(T.extra, 1)
+    Assert.isEqual(TypeGuard.TObject(T), true)
+    Assert.isEqual(TypeGuard.TString(T.properties.A), true)
+    Assert.isEqual(TypeGuard.TString(T.properties.B), true)
+    Assert.isEqual(T.extra, 1)
   })
   it('Should guard overload 2', () => {
     const T = Type.Record(Type.Union([Type.Literal('A')]), Type.String(), { extra: 1 }) // unwrap as literal
-    Assert.equal(TypeGuard.TObject(T), true)
-    Assert.equal(TypeGuard.TString(T.properties.A), true)
-    Assert.equal(T.extra, 1)
+    Assert.isEqual(TypeGuard.TObject(T), true)
+    Assert.isEqual(TypeGuard.TString(T.properties.A), true)
+    Assert.isEqual(T.extra, 1)
   })
   it('Should guard overload 3', () => {
     // @ts-ignore
@@ -25,49 +25,49 @@ describe('type/guard/TRecord', () => {
   })
   it('Should guard overload 4', () => {
     const T = Type.Record(Type.Literal('A'), Type.String(), { extra: 1 })
-    Assert.equal(TypeGuard.TObject(T), true)
-    Assert.equal(TypeGuard.TString(T.properties.A), true)
-    Assert.equal(T.extra, 1)
+    Assert.isEqual(TypeGuard.TObject(T), true)
+    Assert.isEqual(TypeGuard.TString(T.properties.A), true)
+    Assert.isEqual(T.extra, 1)
   })
   it('Should guard overload 5', () => {
     const L = Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal('A'), Type.Literal('B')])])
     const T = Type.Record(L, Type.String(), { extra: 1 })
-    Assert.equal(TypeGuard.TObject(T), true)
-    Assert.equal(TypeGuard.TString(T.properties.helloA), true)
-    Assert.equal(TypeGuard.TString(T.properties.helloB), true)
-    Assert.equal(T.extra, 1)
+    Assert.isEqual(TypeGuard.TObject(T), true)
+    Assert.isEqual(TypeGuard.TString(T.properties.helloA), true)
+    Assert.isEqual(TypeGuard.TString(T.properties.helloB), true)
+    Assert.isEqual(T.extra, 1)
   })
   it('Should guard overload 6', () => {
     const T = Type.Record(Type.Number(), Type.String(), { extra: 1 })
-    Assert.equal(TypeGuard.TRecord(T), true)
-    Assert.equal(TypeGuard.TString(T.patternProperties[PatternNumberExact]), true)
-    Assert.equal(T.extra, 1)
+    Assert.isEqual(TypeGuard.TRecord(T), true)
+    Assert.isEqual(TypeGuard.TString(T.patternProperties[PatternNumberExact]), true)
+    Assert.isEqual(T.extra, 1)
   })
   it('Should guard overload 7', () => {
     const T = Type.Record(Type.Integer(), Type.String(), { extra: 1 })
-    Assert.equal(TypeGuard.TRecord(T), true)
-    Assert.equal(TypeGuard.TString(T.patternProperties[PatternNumberExact]), true)
-    Assert.equal(T.extra, 1)
+    Assert.isEqual(TypeGuard.TRecord(T), true)
+    Assert.isEqual(TypeGuard.TString(T.patternProperties[PatternNumberExact]), true)
+    Assert.isEqual(T.extra, 1)
   })
   it('Should guard overload 8', () => {
     const T = Type.Record(Type.String(), Type.String(), { extra: 1 })
-    Assert.equal(TypeGuard.TRecord(T), true)
-    Assert.equal(TypeGuard.TString(T.patternProperties[PatternStringExact]), true)
-    Assert.equal(T.extra, 1)
+    Assert.isEqual(TypeGuard.TRecord(T), true)
+    Assert.isEqual(TypeGuard.TString(T.patternProperties[PatternStringExact]), true)
+    Assert.isEqual(T.extra, 1)
   })
   it('Should guard overload 9', () => {
     const L = Type.TemplateLiteral([Type.String(), Type.Literal('_foo')])
     const T = Type.Record(L, Type.String(), { extra: 1 })
-    Assert.equal(TypeGuard.TRecord(T), true)
-    Assert.equal(TypeGuard.TString(T.patternProperties[`^${PatternString}_foo$`]), true)
-    Assert.equal(T.extra, 1)
+    Assert.isEqual(TypeGuard.TRecord(T), true)
+    Assert.isEqual(TypeGuard.TString(T.patternProperties[`^${PatternString}_foo$`]), true)
+    Assert.isEqual(T.extra, 1)
   })
   // -------------------------------------------------------------
   // Variants
   // -------------------------------------------------------------
   it('Should guard for TRecord', () => {
     const R = TypeGuard.TRecord(Type.Record(Type.String(), Type.Number()))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should guard for TRecord with TObject value', () => {
     const R = TypeGuard.TRecord(
@@ -79,16 +79,16 @@ describe('type/guard/TRecord', () => {
         }),
       ),
     )
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TRecord', () => {
     const R = TypeGuard.TRecord(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TRecord with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TRecord(Type.Record(Type.String(), Type.Number(), { $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TRecord with TObject value with invalid Property', () => {
     const R = TypeGuard.TRecord(
@@ -100,16 +100,16 @@ describe('type/guard/TRecord', () => {
         }),
       ),
     )
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Transform: Should should transform to TObject for single literal union value', () => {
     const K = Type.Union([Type.Literal('ok')])
     const R = TypeGuard.TObject(Type.Record(K, Type.Number()))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Transform: Should should transform to TObject for multi literal union value', () => {
     const K = Type.Union([Type.Literal('A'), Type.Literal('B')])
     const R = TypeGuard.TObject(Type.Record(K, Type.Number()))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
 })
diff --git a/test/runtime/type/guard/ref.ts b/test/runtime/type/guard/ref.ts
index e76680cf7..53b381954 100644
--- a/test/runtime/type/guard/ref.ts
+++ b/test/runtime/type/guard/ref.ts
@@ -6,12 +6,12 @@ describe('type/guard/TRef', () => {
   it('Should guard for TRef', () => {
     const T = Type.Number({ $id: 'T' })
     const R = TypeGuard.TRef(Type.Ref(T))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not guard for TRef', () => {
     const R = TypeGuard.TRef(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TRef with invalid $ref', () => {
@@ -20,6 +20,6 @@ describe('type/guard/TRef', () => {
     // @ts-ignore
     S.$ref = 1
     const R = TypeGuard.TRef(S)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/rest.ts b/test/runtime/type/guard/rest.ts
new file mode 100644
index 000000000..1e9e831ee
--- /dev/null
+++ b/test/runtime/type/guard/rest.ts
@@ -0,0 +1,22 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TRest', () => {
+  it('Should guard Rest 1', () => {
+    const T = Type.Tuple([Type.String(), Type.Number()])
+    const R = Type.Rest(T)
+    Assert.isTrue(TypeGuard.TString(R[0]))
+    Assert.isTrue(TypeGuard.TNumber(R[1]))
+  })
+  it('Should guard Rest 2', () => {
+    const T = Type.Tuple([])
+    const R = Type.Rest(T)
+    Assert.isEqual(R.length, 0)
+  })
+  it('Should guard Rest 3', () => {
+    const T = Type.String()
+    const R = Type.Rest(T)
+    Assert.isTrue(TypeGuard.TString(R[0]))
+  })
+})
diff --git a/test/runtime/type/guard/string.ts b/test/runtime/type/guard/string.ts
index 24b33dd1e..308da7e62 100644
--- a/test/runtime/type/guard/string.ts
+++ b/test/runtime/type/guard/string.ts
@@ -5,35 +5,35 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TString', () => {
   it('Should guard for TString', () => {
     const R = TypeGuard.TString(Type.String())
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not guard for TString', () => {
     const R = TypeGuard.TString(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TString with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TString(Type.String({ $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TString with invalid minLength', () => {
     // @ts-ignore
     const R = TypeGuard.TString(Type.String({ minLength: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TString with invalid maxLength', () => {
     // @ts-ignore
     const R = TypeGuard.TString(Type.String({ maxLength: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TString with invalid pattern', () => {
     // @ts-ignore
     const R = TypeGuard.TString(Type.String({ pattern: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/symbol.ts b/test/runtime/type/guard/symbol.ts
index 7683f099e..a22a53fd7 100644
--- a/test/runtime/type/guard/symbol.ts
+++ b/test/runtime/type/guard/symbol.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TSymbol', () => {
   it('Should guard for TSymbol', () => {
     const R = TypeGuard.TSymbol(Type.Symbol())
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TSymbol', () => {
     const R = TypeGuard.TSymbol(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TSymbol with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TSymbol(Type.Symbol({ $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/template-literal.ts b/test/runtime/type/guard/template-literal.ts
index 4d988829d..79112c294 100644
--- a/test/runtime/type/guard/template-literal.ts
+++ b/test/runtime/type/guard/template-literal.ts
@@ -5,43 +5,43 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TTemplateLiteral', () => {
   it('Should guard for empty TemplateLiteral', () => {
     const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([]))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should guard for TSchema', () => {
     const R = TypeGuard.TSchema(Type.TemplateLiteral([]))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should guard for TemplateLiteral (TTemplateLiteral)', () => {
     const T = Type.TemplateLiteral([Type.Literal('hello')])
     const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([T, Type.Literal('world')]))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should guard for TemplateLiteral (TLiteral)', () => {
     const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([Type.Literal('hello')]))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should guard for TemplateLiteral (TString)', () => {
     const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([Type.String()]))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should guard for TemplateLiteral (TNumber)', () => {
     const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([Type.Number()]))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should guard for TemplateLiteral (TBoolean)', () => {
     const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([Type.Boolean()]))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for missing ^ expression prefix', () => {
     const T = Type.TemplateLiteral([Type.Literal('hello')])
     // @ts-ignore
     T.pattern = T.pattern.slice(1)
-    Assert.equal(TypeGuard.TTemplateLiteral(T), false)
+    Assert.isEqual(TypeGuard.TTemplateLiteral(T), false)
   })
   it('Should not guard for missing $ expression postfix', () => {
     const T = Type.TemplateLiteral([Type.Literal('hello')])
     // @ts-ignore
     T.pattern = T.pattern.slice(0, T.pattern.length - 1)
-    Assert.equal(TypeGuard.TTemplateLiteral(T), false)
+    Assert.isEqual(TypeGuard.TTemplateLiteral(T), false)
   })
 })
diff --git a/test/runtime/type/guard/this.ts b/test/runtime/type/guard/this.ts
index 2da48ed13..1668c93ad 100644
--- a/test/runtime/type/guard/this.ts
+++ b/test/runtime/type/guard/this.ts
@@ -6,7 +6,7 @@ describe('type/guard/TThis', () => {
   it('Should guard for TThis', () => {
     Type.Recursive((This) => {
       const R = TypeGuard.TThis(This)
-      Assert.equal(R, true)
+      Assert.isEqual(R, true)
       return Type.Object({ nodes: Type.Array(This) })
     })
   })
@@ -15,7 +15,7 @@ describe('type/guard/TThis', () => {
       // @ts-ignore
       This.$ref = 1
       const R = TypeGuard.TThis(This)
-      Assert.equal(R, false)
+      Assert.isEqual(R, false)
       return Type.Object({ nodes: Type.Array(This) })
     })
   })
diff --git a/test/runtime/type/guard/tuple.ts b/test/runtime/type/guard/tuple.ts
index 8e549aa57..d438753b6 100644
--- a/test/runtime/type/guard/tuple.ts
+++ b/test/runtime/type/guard/tuple.ts
@@ -5,19 +5,19 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TTuple', () => {
   it('Should guard for TTuple', () => {
     const R = TypeGuard.TTuple(Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TTuple', () => {
     const R = TypeGuard.TTuple(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TTuple with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TTuple(Type.Tuple([Type.Number(), Type.Number()], { $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TTuple with invalid Items', () => {
     const R = TypeGuard.TTuple(Type.Tuple([Type.Number(), {} as any]))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/uint8array.ts b/test/runtime/type/guard/uint8array.ts
index cd4c741e7..c2657f6af 100644
--- a/test/runtime/type/guard/uint8array.ts
+++ b/test/runtime/type/guard/uint8array.ts
@@ -5,29 +5,29 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TUint8Array', () => {
   it('Should guard for TUint8Array', () => {
     const R = TypeGuard.TUint8Array(Type.Uint8Array())
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not guard for TUint8Array', () => {
     const R = TypeGuard.TUint8Array(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TUint8Array with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TUint8Array(Type.Uint8Array({ $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TUint8Array with invalid minByteLength', () => {
     // @ts-ignore
     const R = TypeGuard.TUint8Array(Type.Uint8Array({ minByteLength: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not guard for TUint8Array with invalid maxByteLength', () => {
     // @ts-ignore
     const R = TypeGuard.TUint8Array(Type.Uint8Array({ maxByteLength: '1' }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/undefined.ts b/test/runtime/type/guard/undefined.ts
index cc8bbeea3..7f6d4a593 100644
--- a/test/runtime/type/guard/undefined.ts
+++ b/test/runtime/type/guard/undefined.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TUndefined', () => {
   it('Should guard for TUndefined', () => {
     const R = TypeGuard.TUndefined(Type.Undefined())
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TUndefined', () => {
     const R = TypeGuard.TUndefined(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TUndefined with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TUndefined(Type.Undefined({ $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/union.ts b/test/runtime/type/guard/union.ts
index 16fc75d41..b28b0052c 100644
--- a/test/runtime/type/guard/union.ts
+++ b/test/runtime/type/guard/union.ts
@@ -14,11 +14,11 @@ describe('type/guard/TUnion', () => {
         }),
       ]),
     )
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TUnion', () => {
     const R = TypeGuard.TUnion(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should guard for TUnion with invalid $id', () => {
     const R = TypeGuard.TUnion(
@@ -38,7 +38,7 @@ describe('type/guard/TUnion', () => {
         },
       ),
     )
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TUnion with invalid variant', () => {
     const R = TypeGuard.TUnion(
@@ -49,7 +49,7 @@ describe('type/guard/TUnion', () => {
         {} as any,
       ]),
     )
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TUnion with invalid object variant', () => {
     const R = TypeGuard.TUnion(
@@ -62,25 +62,25 @@ describe('type/guard/TUnion', () => {
         }),
       ]),
     )
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Transform: Should transform to never for zero length union', () => {
     const T = Type.Union([])
     const R = TypeGuard.TNever(T)
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Transform: Should unwrap union type for array of length === 1', () => {
     const T = Type.Union([Type.String()])
     const R = TypeGuard.TString(T)
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Transform: Should retain union if array length > 1', () => {
     const T = Type.Union([Type.String(), Type.Number()])
     const R1 = TypeGuard.TUnion(T)
     const R2 = TypeGuard.TString(T.anyOf[0])
     const R3 = TypeGuard.TNumber(T.anyOf[1])
-    Assert.equal(R1, true)
-    Assert.equal(R2, true)
-    Assert.equal(R3, true)
+    Assert.isEqual(R1, true)
+    Assert.isEqual(R2, true)
+    Assert.isEqual(R3, true)
   })
 })
diff --git a/test/runtime/type/guard/unknown.ts b/test/runtime/type/guard/unknown.ts
index 4d3e5980c..2c2dce22e 100644
--- a/test/runtime/type/guard/unknown.ts
+++ b/test/runtime/type/guard/unknown.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TUnknown', () => {
   it('Should guard for TUnknown', () => {
     const R = TypeGuard.TUnknown(Type.Unknown())
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TUnknown', () => {
     const R = TypeGuard.TUnknown(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TUnknown with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TUnknown(Type.Unknown({ $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/unsafe.ts b/test/runtime/type/guard/unsafe.ts
index 8cb296441..b54e1f16b 100644
--- a/test/runtime/type/guard/unsafe.ts
+++ b/test/runtime/type/guard/unsafe.ts
@@ -6,27 +6,27 @@ describe('type/guard/TUnsafe', () => {
   it('Should guard raw TUnsafe', () => {
     const T = Type.Unsafe({ x: 1 })
     const R = TypeGuard.TUnsafe(T)
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should guard raw TUnsafe as TSchema', () => {
     const T = Type.Unsafe({ x: 1 })
     const R = TypeGuard.TSchema(T)
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should guard override TUnsafe as TSchema when registered', () => {
     TypeRegistry.Set('type/guard/TUnsafe/Type1', () => true)
     const T = Type.Unsafe({ [Kind]: 'type/guard/TUnsafe/Type1' })
     const R = TypeGuard.TSchema(T)
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard TUnsafe with unregistered kind', () => {
     const T = Type.Unsafe({ [Kind]: 'type/guard/TUnsafe/Type2' })
     const R = TypeGuard.TUnsafe(T)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TString', () => {
     const T = Type.String()
     const R = TypeGuard.TUnsafe(T)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/guard/void.ts b/test/runtime/type/guard/void.ts
index 839719a2f..976639621 100644
--- a/test/runtime/type/guard/void.ts
+++ b/test/runtime/type/guard/void.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TVoid', () => {
   it('Should guard for TVoid', () => {
     const R = TypeGuard.TVoid(Type.Void())
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not guard for TVoid', () => {
     const R = TypeGuard.TVoid(null)
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not guard for TVoid with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TVoid(Type.Void({ $id: 1 }))
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/normalize/exclude.ts b/test/runtime/type/normalize/exclude.ts
index fd0234242..16a91ede6 100644
--- a/test/runtime/type/normalize/exclude.ts
+++ b/test/runtime/type/normalize/exclude.ts
@@ -6,16 +6,16 @@ describe('type/normal/Exclude', () => {
   it('Normalize 1', () => {
     const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
     const R = TypeGuard.TUnion(T)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Normalize 2', () => {
     const T = Type.Exclude(Type.Union([Type.String(), Type.Number()]), Type.String())
     const R = TypeGuard.TNumber(T)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Normalize 3', () => {
     const T = Type.Exclude(Type.Union([Type.String()]), Type.String())
     const R = TypeGuard.TNever(T)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
 })
diff --git a/test/runtime/type/normalize/extract.ts b/test/runtime/type/normalize/extract.ts
index bb3a3d09d..f4b87a649 100644
--- a/test/runtime/type/normalize/extract.ts
+++ b/test/runtime/type/normalize/extract.ts
@@ -6,26 +6,26 @@ describe('type/normal/Extract', () => {
   it('Normalize 1', () => {
     const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Number()]))
     const R = TypeGuard.TUnion(T)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Normalize 2', () => {
     const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
     const R = TypeGuard.TString(T)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Normalize 3', () => {
     const T = Type.Extract(Type.Union([Type.String(), Type.Number()]), Type.String())
     const R = TypeGuard.TString(T)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Normalize 4', () => {
     const T = Type.Extract(Type.Union([Type.String()]), Type.String())
     const R = TypeGuard.TString(T)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Normalize 5', () => {
     const T = Type.Extract(Type.Union([]), Type.String())
     const R = TypeGuard.TNever(T)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
 })
diff --git a/test/runtime/type/normalize/intersect.ts b/test/runtime/type/normalize/intersect.ts
index 95accfd2d..3b712b5ea 100644
--- a/test/runtime/type/normalize/intersect.ts
+++ b/test/runtime/type/normalize/intersect.ts
@@ -6,16 +6,16 @@ describe('type/normal/Intersect', () => {
   it('Normalize 1', () => {
     const T = Type.Intersect([Type.Number(), Type.String()])
     const R = TypeGuard.TIntersect(T)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Normalize 2', () => {
     const T = Type.Intersect([Type.Number()])
     const R = TypeGuard.TNumber(T)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Normalize 3', () => {
     const T = Type.Intersect([])
     const R = TypeGuard.TNever(T)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
 })
diff --git a/test/runtime/type/normalize/record.ts b/test/runtime/type/normalize/record.ts
index 53337902f..99b03383a 100644
--- a/test/runtime/type/normalize/record.ts
+++ b/test/runtime/type/normalize/record.ts
@@ -7,6 +7,6 @@ describe('type/normal/Record', () => {
     const K = Type.Union([Type.Literal('A'), Type.Literal('B')])
     const T = Type.Record(K, Type.String())
     const R = TypeGuard.TObject(T)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
 })
diff --git a/test/runtime/type/normalize/union.ts b/test/runtime/type/normalize/union.ts
index 44e5a7ece..aff9483fc 100644
--- a/test/runtime/type/normalize/union.ts
+++ b/test/runtime/type/normalize/union.ts
@@ -6,16 +6,16 @@ describe('type/normal/Union', () => {
   it('Normalize 1', () => {
     const T = Type.Union([Type.Number(), Type.String()])
     const R = TypeGuard.TUnion(T)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Normalize 2', () => {
     const T = Type.Union([Type.Number()])
     const R = TypeGuard.TNumber(T)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Normalize 3', () => {
     const T = Type.Union([])
     const R = TypeGuard.TNever(T)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
 })
diff --git a/test/runtime/type/registry/format.ts b/test/runtime/type/registry/format.ts
index 494160aec..df2568182 100644
--- a/test/runtime/type/registry/format.ts
+++ b/test/runtime/type/registry/format.ts
@@ -8,15 +8,15 @@ describe('type/FormatRegistry', () => {
   it('Should get format', () => {
     FormatRegistry.Set('test#format2', () => true)
     const format = FormatRegistry.Get('test#format2')
-    Assert.equal(typeof format, 'function')
+    Assert.isEqual(typeof format, 'function')
   })
   it('Should return true if exists', () => {
     FormatRegistry.Set('test#format3', () => true)
-    Assert.equal(FormatRegistry.Has('test#format3'), true)
+    Assert.isEqual(FormatRegistry.Has('test#format3'), true)
   })
   it('Should clear formats', () => {
     FormatRegistry.Set('test#format4', () => true)
     FormatRegistry.Clear()
-    Assert.equal(FormatRegistry.Has('test#format4'), false)
+    Assert.isEqual(FormatRegistry.Has('test#format4'), false)
   })
 })
diff --git a/test/runtime/type/registry/type.ts b/test/runtime/type/registry/type.ts
index 5289d3d6d..0ad9a6613 100644
--- a/test/runtime/type/registry/type.ts
+++ b/test/runtime/type/registry/type.ts
@@ -8,15 +8,15 @@ describe('type/TypeRegistry', () => {
   it('Should get type', () => {
     TypeRegistry.Set('test#type2', () => true)
     const format = TypeRegistry.Get('test#type2')
-    Assert.equal(typeof format, 'function')
+    Assert.isEqual(typeof format, 'function')
   })
   it('Should return true if exists', () => {
     TypeRegistry.Set('test#type3', () => true)
-    Assert.equal(TypeRegistry.Has('test#type3'), true)
+    Assert.isEqual(TypeRegistry.Has('test#type3'), true)
   })
   it('Should clear types', () => {
     TypeRegistry.Set('test#type4', () => true)
     TypeRegistry.Clear()
-    Assert.equal(TypeRegistry.Has('test#type4'), false)
+    Assert.isEqual(TypeRegistry.Has('test#type4'), false)
   })
 })
diff --git a/test/runtime/type/template/finite.ts b/test/runtime/type/template/finite.ts
index c843229ed..0941a39c2 100644
--- a/test/runtime/type/template/finite.ts
+++ b/test/runtime/type/template/finite.ts
@@ -8,27 +8,27 @@ describe('type/TemplateLiteralFinite', () => {
   it('Finite 1', () => {
     const E = TemplateLiteralParser.Parse(`A`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Finite 2', () => {
     const E = TemplateLiteralParser.Parse(`A|B`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Finite 3', () => {
     const E = TemplateLiteralParser.Parse(`A(B|C)`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Finite 4', () => {
     const E = TemplateLiteralParser.Parse(`${PatternBoolean}`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Finite 5', () => {
     const E = TemplateLiteralParser.Parse(`\\.\\*`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   // ---------------------------------------------------------------
   // Infinite
@@ -36,36 +36,36 @@ describe('type/TemplateLiteralFinite', () => {
   it('Infinite 1', () => {
     const E = TemplateLiteralParser.Parse(`${PatternString}`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
   it('Infinite 2', () => {
     const E = TemplateLiteralParser.Parse(`${PatternNumber}`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
   it('Infinite 3', () => {
     const E = TemplateLiteralParser.Parse(`A|${PatternString}`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
   it('Infinite 4', () => {
     const E = TemplateLiteralParser.Parse(`A|${PatternNumber}`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
   it('Infinite 5', () => {
     const E = TemplateLiteralParser.Parse(`A(${PatternString})`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
   it('Infinite 6', () => {
     const E = TemplateLiteralParser.Parse(`A(${PatternNumber})`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
   it('Infinite 7', () => {
     const E = TemplateLiteralParser.Parse(`${PatternString}_foo`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/type/template/generate.ts b/test/runtime/type/template/generate.ts
index df00189db..24ee76f25 100644
--- a/test/runtime/type/template/generate.ts
+++ b/test/runtime/type/template/generate.ts
@@ -8,12 +8,12 @@ describe('type/TemplateLiteralGenerator', () => {
   it('Exact 1', () => {
     const E = TemplateLiteralParser.Parse('^$')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['^$'])
+    Assert.isEqual(R, ['^$'])
   })
   it('Exact 2', () => {
     const E = TemplateLiteralParser.Parse('^A$')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['^A$'])
+    Assert.isEqual(R, ['^A$'])
   })
   // ---------------------------------------------------------------
   // Patterns
@@ -21,17 +21,17 @@ describe('type/TemplateLiteralGenerator', () => {
   it('Pattern 1', () => {
     const E = TemplateLiteralParser.Parse('(true|false)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['true', 'false'])
+    Assert.isEqual(R, ['true', 'false'])
   })
   it('Pattern 2', () => {
     const E = TemplateLiteralParser.Parse('(0|[1-9][0-9]*)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['0', '[1-9][0-9]*'])
+    Assert.isEqual(R, ['0', '[1-9][0-9]*'])
   })
   it('Pattern 3', () => {
     const E = TemplateLiteralParser.Parse('.*')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['.*'])
+    Assert.isEqual(R, ['.*'])
   })
   // ---------------------------------------------------------------
   // Expression
@@ -39,161 +39,161 @@ describe('type/TemplateLiteralGenerator', () => {
   it('Expression 1', () => {
     const E = TemplateLiteralParser.Parse(')')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, [')'])
+    Assert.isEqual(R, [')'])
   })
   it('Expression 2', () => {
     const E = TemplateLiteralParser.Parse('\\)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['\\)'])
+    Assert.isEqual(R, ['\\)'])
   })
   it('Expression 3', () => {
     const E = TemplateLiteralParser.Parse('\\(')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['\\('])
+    Assert.isEqual(R, ['\\('])
   })
   it('Expression 4', () => {
     const E = TemplateLiteralParser.Parse('')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, [''])
+    Assert.isEqual(R, [''])
   })
   it('Expression 5', () => {
     const E = TemplateLiteralParser.Parse('\\')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['\\'])
+    Assert.isEqual(R, ['\\'])
   })
   it('Expression 6', () => {
     const E = TemplateLiteralParser.Parse('()')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, [''])
+    Assert.isEqual(R, [''])
   })
   it('Expression 7', () => {
     const E = TemplateLiteralParser.Parse('(a)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['a'])
+    Assert.isEqual(R, ['a'])
   })
   it('Expression 8', () => {
     const E = TemplateLiteralParser.Parse('()))')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['))'])
+    Assert.isEqual(R, ['))'])
   })
   it('Expression 9', () => {
     const E = TemplateLiteralParser.Parse('())')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, [')'])
+    Assert.isEqual(R, [')'])
   })
   it('Expression 10', () => {
     const E = TemplateLiteralParser.Parse('A|B')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['A', 'B'])
+    Assert.isEqual(R, ['A', 'B'])
   })
   it('Expression 11', () => {
     const E = TemplateLiteralParser.Parse('A|(B)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['A', 'B'])
+    Assert.isEqual(R, ['A', 'B'])
   })
   it('Expression 12', () => {
     const E = TemplateLiteralParser.Parse('A(B)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['AB'])
+    Assert.isEqual(R, ['AB'])
   })
   it('Expression 13', () => {
     const E = TemplateLiteralParser.Parse('(A)B')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['AB'])
+    Assert.isEqual(R, ['AB'])
   })
   it('Expression 14', () => {
     const E = TemplateLiteralParser.Parse('(A)|B')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['A', 'B'])
+    Assert.isEqual(R, ['A', 'B'])
   })
   it('Expression 15', () => {
     const E = TemplateLiteralParser.Parse('|')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, [''])
+    Assert.isEqual(R, [''])
   })
   it('Expression 16', () => {
     const E = TemplateLiteralParser.Parse('||')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, [''])
+    Assert.isEqual(R, [''])
   })
   it('Expression 17', () => {
     const E = TemplateLiteralParser.Parse('||A')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['A'])
+    Assert.isEqual(R, ['A'])
   })
   it('Expression 18', () => {
     const E = TemplateLiteralParser.Parse('A||')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['A'])
+    Assert.isEqual(R, ['A'])
   })
   it('Expression 19', () => {
     const E = TemplateLiteralParser.Parse('A||B')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['A', 'B'])
+    Assert.isEqual(R, ['A', 'B'])
   })
   it('Expression 20', () => {
     const E = TemplateLiteralParser.Parse('A|()|B')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['A', '', 'B'])
+    Assert.isEqual(R, ['A', '', 'B'])
   })
   it('Expression 21', () => {
     const E = TemplateLiteralParser.Parse('A|(|)|B')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['A', '', 'B'])
+    Assert.isEqual(R, ['A', '', 'B'])
   })
   it('Expression 22', () => {
     const E = TemplateLiteralParser.Parse('A|(||)|B')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['A', '', 'B'])
+    Assert.isEqual(R, ['A', '', 'B'])
   })
   it('Expression 23', () => {
     const E = TemplateLiteralParser.Parse('|A(||)B|')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['AB'])
+    Assert.isEqual(R, ['AB'])
   })
   it('Expression 24', () => {
     const E = TemplateLiteralParser.Parse('A(B)(C)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['ABC'])
+    Assert.isEqual(R, ['ABC'])
   })
   it('Expression 25', () => {
     const E = TemplateLiteralParser.Parse('A(B)|(C)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['AB', 'C'])
+    Assert.isEqual(R, ['AB', 'C'])
   })
   it('Expression 26', () => {
     const E = TemplateLiteralParser.Parse('A(B|C)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['AB', 'AC'])
+    Assert.isEqual(R, ['AB', 'AC'])
   })
   it('Expression 27', () => {
     const E = TemplateLiteralParser.Parse('A|(B|C)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['A', 'B', 'C'])
+    Assert.isEqual(R, ['A', 'B', 'C'])
   })
   it('Expression 28', () => {
     const E = TemplateLiteralParser.Parse('((A)B)C')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['ABC'])
+    Assert.isEqual(R, ['ABC'])
   })
   it('Expression 29', () => {
     const E = TemplateLiteralParser.Parse('(0|1)(0|1)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['00', '01', '10', '11'])
+    Assert.isEqual(R, ['00', '01', '10', '11'])
   })
   it('Expression 30', () => {
     const E = TemplateLiteralParser.Parse('(0|1)|(0|1)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['0', '1', '0', '1'])
+    Assert.isEqual(R, ['0', '1', '0', '1'])
   })
   it('Expression 31', () => {
     const E = TemplateLiteralParser.Parse('(0|(1|0)|1)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['0', '1', '0', '1'])
+    Assert.isEqual(R, ['0', '1', '0', '1'])
   })
   it('Expression 32', () => {
     const E = TemplateLiteralParser.Parse('(0(1|0)1)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.deepEqual(R, ['011', '001'])
+    Assert.isEqual(R, ['011', '001'])
   })
 })
diff --git a/test/runtime/type/template/parser.ts b/test/runtime/type/template/parser.ts
index 9cf2607f1..5c9654b78 100644
--- a/test/runtime/type/template/parser.ts
+++ b/test/runtime/type/template/parser.ts
@@ -16,14 +16,14 @@ describe('type/TemplateLiteralParser', () => {
   // ---------------------------------------------------------------
   it('Exact 1', () => {
     const E = TemplateLiteralParser.Parse('^$')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'const',
       const: '^$',
     })
   })
   it('Exact 2', () => {
     const E = TemplateLiteralParser.Parse('^A$')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'const',
       const: '^A$',
     })
@@ -33,7 +33,7 @@ describe('type/TemplateLiteralParser', () => {
   // ---------------------------------------------------------------
   it('Pattern 1', () => {
     const E = TemplateLiteralParser.Parse('(true|false)')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'or',
       expr: [
         {
@@ -49,7 +49,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Pattern 2', () => {
     const E = TemplateLiteralParser.Parse('(0|[1-9][0-9]*)')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'or',
       expr: [
         {
@@ -65,7 +65,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Pattern 3', () => {
     const E = TemplateLiteralParser.Parse('.*')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'const',
       const: '.*',
     })
@@ -75,56 +75,56 @@ describe('type/TemplateLiteralParser', () => {
   // ---------------------------------------------------------------
   it('Expression 1', () => {
     const E = TemplateLiteralParser.Parse(')')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'const',
       const: ')',
     })
   })
   it('Expression 2', () => {
     const E = TemplateLiteralParser.Parse('\\)')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'const',
       const: '\\)',
     })
   })
   it('Expression 3', () => {
     const E = TemplateLiteralParser.Parse('\\(')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'const',
       const: '\\(',
     })
   })
   it('Expression 4', () => {
     const E = TemplateLiteralParser.Parse('')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'const',
       const: '',
     })
   })
   it('Expression 5', () => {
     const E = TemplateLiteralParser.Parse('\\')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'const',
       const: '\\',
     })
   })
   it('Expression 6', () => {
     const E = TemplateLiteralParser.Parse('()')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'const',
       const: '',
     })
   })
   it('Expression 7', () => {
     const E = TemplateLiteralParser.Parse('(a)')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'const',
       const: 'a',
     })
   })
   it('Expression 8', () => {
     const E = TemplateLiteralParser.Parse('()))')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'and',
       expr: [
         {
@@ -140,7 +140,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 9', () => {
     const E = TemplateLiteralParser.Parse('())')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'and',
       expr: [
         {
@@ -156,7 +156,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 10', () => {
     const E = TemplateLiteralParser.Parse('A|B')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'or',
       expr: [
         {
@@ -172,7 +172,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 11', () => {
     const E = TemplateLiteralParser.Parse('A|(B)')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'or',
       expr: [
         {
@@ -188,7 +188,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 12', () => {
     const E = TemplateLiteralParser.Parse('A(B)')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'and',
       expr: [
         {
@@ -204,7 +204,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 13', () => {
     const E = TemplateLiteralParser.Parse('(A)B')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'and',
       expr: [
         {
@@ -220,7 +220,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 14', () => {
     const E = TemplateLiteralParser.Parse('(A)|B')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'or',
       expr: [
         {
@@ -236,35 +236,35 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 15', () => {
     const E = TemplateLiteralParser.Parse('|')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'const',
       const: '',
     })
   })
   it('Expression 16', () => {
     const E = TemplateLiteralParser.Parse('||')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'const',
       const: '',
     })
   })
   it('Expression 17', () => {
     const E = TemplateLiteralParser.Parse('||A')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'const',
       const: 'A',
     })
   })
   it('Expression 18', () => {
     const E = TemplateLiteralParser.Parse('A||')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'const',
       const: 'A',
     })
   })
   it('Expression 19', () => {
     const E = TemplateLiteralParser.Parse('A||B')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'or',
       expr: [
         {
@@ -280,7 +280,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 20', () => {
     const E = TemplateLiteralParser.Parse('A|()|B')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'or',
       expr: [
         {
@@ -300,7 +300,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 21', () => {
     const E = TemplateLiteralParser.Parse('A|(|)|B')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'or',
       expr: [
         {
@@ -320,7 +320,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 22', () => {
     const E = TemplateLiteralParser.Parse('A|(||)|B')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'or',
       expr: [
         {
@@ -340,7 +340,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 23', () => {
     const E = TemplateLiteralParser.Parse('|A(||)B|')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'and',
       expr: [
         {
@@ -360,7 +360,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 24', () => {
     const E = TemplateLiteralParser.Parse('A(B)(C)')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'and',
       expr: [
         {
@@ -380,7 +380,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 25', () => {
     const E = TemplateLiteralParser.Parse('A(B)|(C)')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'or',
       expr: [
         {
@@ -405,7 +405,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 26', () => {
     const E = TemplateLiteralParser.Parse('A(B|C)')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'and',
       expr: [
         {
@@ -430,7 +430,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 27', () => {
     const E = TemplateLiteralParser.Parse('A|(B|C)')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'or',
       expr: [
         {
@@ -455,7 +455,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 28', () => {
     const E = TemplateLiteralParser.Parse('((A)B)C')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'and',
       expr: [
         {
@@ -480,7 +480,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 29', () => {
     const E = TemplateLiteralParser.Parse('(0|1)(0|1)')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'and',
       expr: [
         {
@@ -514,7 +514,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 30', () => {
     const E = TemplateLiteralParser.Parse('(0|1)|(0|1)')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'or',
       expr: [
         {
@@ -548,7 +548,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 31', () => {
     const E = TemplateLiteralParser.Parse('(0|(1|0)|1)')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'or',
       expr: [
         {
@@ -577,7 +577,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 32', () => {
     const E = TemplateLiteralParser.Parse('(0(1|0)1)')
-    Assert.deepEqual(E, {
+    Assert.isEqual(E, {
       type: 'and',
       expr: [
         {
diff --git a/test/runtime/type/template/pattern.ts b/test/runtime/type/template/pattern.ts
index d43148951..b87143069 100644
--- a/test/runtime/type/template/pattern.ts
+++ b/test/runtime/type/template/pattern.ts
@@ -4,26 +4,26 @@ import { Assert } from '../../assert/index'
 describe('type/TemplateLiteralPattern', () => {
   const Equal = (template: TTemplateLiteral, expect: string) => {
     const pattern = template.pattern.slice(1, template.pattern.length - 1)
-    Assert.equal(pattern, expect)
+    Assert.isEqual(pattern, expect)
   }
   // ---------------------------------------------------------------
   // Escape
   // ---------------------------------------------------------------
   it('Escape 1', () => {
     const T = Type.TemplateLiteral([Type.Literal('.*')])
-    Assert.equal(T.pattern, '^\\.\\*$')
+    Assert.isEqual(T.pattern, '^\\.\\*$')
   })
   it('Escape 2', () => {
     const T = Type.TemplateLiteral([Type.Literal('(')])
-    Assert.equal(T.pattern, '^\\($')
+    Assert.isEqual(T.pattern, '^\\($')
   })
   it('Escape 3', () => {
     const T = Type.TemplateLiteral([Type.Literal(')')])
-    Assert.equal(T.pattern, '^\\)$')
+    Assert.isEqual(T.pattern, '^\\)$')
   })
   it('Escape 4', () => {
     const T = Type.TemplateLiteral([Type.Literal('|')])
-    Assert.equal(T.pattern, '^\\|$')
+    Assert.isEqual(T.pattern, '^\\|$')
   })
   // ---------------------------------------------------------------
   // Pattern
diff --git a/test/runtime/value/cast/any.ts b/test/runtime/value/cast/any.ts
index a294da43f..b5beef61a 100644
--- a/test/runtime/value/cast/any.ts
+++ b/test/runtime/value/cast/any.ts
@@ -7,46 +7,46 @@ describe('value/cast/Any', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from boolean', () => {
     const value = false
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result.getTime(100), 100)
+    Assert.isEqual(result.getTime(100), 100)
   })
   it('Should preserve', () => {
     const value = { a: 1, b: 2 }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, { a: 1, b: 2 })
+    Assert.isEqual(result, { a: 1, b: 2 })
   })
 })
diff --git a/test/runtime/value/cast/array.ts b/test/runtime/value/cast/array.ts
index 820c3f699..904c51811 100644
--- a/test/runtime/value/cast/array.ts
+++ b/test/runtime/value/cast/array.ts
@@ -8,82 +8,82 @@ describe('value/cast/Array', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, [1])
+    Assert.isEqual(result, [1])
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preserve', () => {
     const value = [6, 7, 8]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, [6, 7, 8])
+    Assert.isEqual(result, [6, 7, 8])
   })
   it('Should preserve with invalid element set to default', () => {
     const value = [6, 7, 8, 'hello', 9]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, [6, 7, 8, 0, 9])
+    Assert.isEqual(result, [6, 7, 8, 0, 9])
   })
   // -----------------------------------------------------------------
   // Constraints: Ranges
   // -----------------------------------------------------------------
   it('Should cast array and truncate to maxItems from value', () => {
     const result = Value.Cast(Type.Array(Type.Number(), { maxItems: 3 }), [0, 1, 2, 4, 5, 6])
-    Assert.deepEqual(result, [0, 1, 2])
+    Assert.isEqual(result, [0, 1, 2])
   })
   it('Should cast arrays and append array to minItems from value', () => {
     const result = Value.Cast(Type.Array(Type.Number(), { minItems: 6 }), [0, 1, 2])
-    Assert.deepEqual(result, [0, 1, 2, 0, 0, 0])
+    Assert.isEqual(result, [0, 1, 2, 0, 0, 0])
   })
   it('Should cast array and truncate to maxItems from default value', () => {
     const result = Value.Cast(Type.Array(Type.Number(), { maxItems: 3, default: [0, 1, 2, 4, 5, 6] }), null)
-    Assert.deepEqual(result, [0, 1, 2])
+    Assert.isEqual(result, [0, 1, 2])
   })
   it('Should cast arrays and append array to minItems from default value', () => {
     const result = Value.Cast(Type.Array(Type.Number({ default: 1 }), { minItems: 6, default: [0, 1, 2] }), null)
-    Assert.deepEqual(result, [0, 1, 2, 1, 1, 1])
+    Assert.isEqual(result, [0, 1, 2, 1, 1, 1])
   })
   // -----------------------------------------------------------------
   // Constraints: Unique
   // -----------------------------------------------------------------
   it('Should cast arrays with uniqueItems with unique default value', () => {
     const result = Value.Cast(Type.Array(Type.Number(), { uniqueItems: true, default: [0, 1, 2] }), null)
-    Assert.deepEqual(result, [0, 1, 2])
+    Assert.isEqual(result, [0, 1, 2])
   })
   it('Should cast arrays with uniqueItems with unique value', () => {
     const result = Value.Cast(Type.Array(Type.Number(), { uniqueItems: true }), [0, 1, 2])
-    Assert.deepEqual(result, [0, 1, 2])
+    Assert.isEqual(result, [0, 1, 2])
   })
   it('Should throw when casting arrays with uniqueItems and no value or default value', () => {
     Assert.throws(() => Value.Cast(Type.Array(Type.Number(), { uniqueItems: true }), null))
@@ -101,18 +101,18 @@ describe('value/cast/Array', () => {
     const T = Type.Array(Type.Number(), { uniqueItems: true })
     const value = [1, 1, 2, 2]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, [1, 2])
+    Assert.isEqual(result, [1, 2])
   })
   it('Should should fill up with defaults to minItems', () => {
     const T = Type.Array(Type.Number(), { minItems: 3 })
     const value = [1, 2]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, [1, 2, 0])
+    Assert.isEqual(result, [1, 2, 0])
   })
   it('Should should truncate to maxItems', () => {
     const T = Type.Array(Type.Number(), { maxItems: 3 })
     const value = [1, 2, 3, 4]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, [1, 2, 3])
+    Assert.isEqual(result, [1, 2, 3])
   })
 })
diff --git a/test/runtime/value/cast/bigint.ts b/test/runtime/value/cast/bigint.ts
index 8e69e3756..57589c93e 100644
--- a/test/runtime/value/cast/bigint.ts
+++ b/test/runtime/value/cast/bigint.ts
@@ -8,46 +8,46 @@ describe('value/cast/BigInt', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 0
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preserve', () => {
     const value = BigInt(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, BigInt(100))
+    Assert.isEqual(result, BigInt(100))
   })
 })
diff --git a/test/runtime/value/cast/boolean.ts b/test/runtime/value/cast/boolean.ts
index a790df65b..6c14b5603 100644
--- a/test/runtime/value/cast/boolean.ts
+++ b/test/runtime/value/cast/boolean.ts
@@ -8,46 +8,46 @@ describe('value/cast/Boolean', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 0
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preserve', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, true)
+    Assert.isEqual(result, true)
   })
 })
diff --git a/test/runtime/value/cast/composite.ts b/test/runtime/value/cast/composite.ts
index 781cf2448..8be304b8e 100644
--- a/test/runtime/value/cast/composite.ts
+++ b/test/runtime/value/cast/composite.ts
@@ -25,47 +25,47 @@ describe('value/cast/Composite', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = E
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast and preserve object', () => {
     const value = { x: 7, y: 8, z: 9 }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, {
+    Assert.isEqual(result, {
       x: 7,
       y: 8,
       z: 9,
@@ -77,7 +77,7 @@ describe('value/cast/Composite', () => {
   it('Should upcast and preserve from incorrect properties', () => {
     const value = { x: {}, y: 8, z: 9 }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, {
+    Assert.isEqual(result, {
       x: 0,
       y: 8,
       z: 9,
diff --git a/test/runtime/value/cast/custom.ts b/test/runtime/value/cast/custom.ts
index 2c8d49477..e29b21a7d 100644
--- a/test/runtime/value/cast/custom.ts
+++ b/test/runtime/value/cast/custom.ts
@@ -14,37 +14,37 @@ describe('value/cast/Custom', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = false
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preserve', () => {
     const value = { a: 'hello', b: 'world' }
@@ -55,6 +55,6 @@ describe('value/cast/Custom', () => {
       }),
       value,
     )
-    Assert.deepEqual(result, { a: 'hello', b: 'world' })
+    Assert.isEqual(result, { a: 'hello', b: 'world' })
   })
 })
diff --git a/test/runtime/value/cast/date.ts b/test/runtime/value/cast/date.ts
index b094c8c79..ec681d908 100644
--- a/test/runtime/value/cast/date.ts
+++ b/test/runtime/value/cast/date.ts
@@ -8,31 +8,31 @@ describe('value/cast/Date', () => {
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preseve', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result.getTime(), 100)
+    Assert.isEqual(result.getTime(), 100)
   })
 })
diff --git a/test/runtime/value/cast/enum.ts b/test/runtime/value/cast/enum.ts
index 86e6d2119..1b0d1d12b 100644
--- a/test/runtime/value/cast/enum.ts
+++ b/test/runtime/value/cast/enum.ts
@@ -12,51 +12,51 @@ describe('value/cast/Boolean', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 123
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from enum A', () => {
     const value = Foo.A
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, Foo.A)
+    Assert.isEqual(result, Foo.A)
   })
   it('Should upcast from enum B', () => {
     const value = Foo.B
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, Foo.B)
+    Assert.isEqual(result, Foo.B)
   })
 })
diff --git a/test/runtime/value/cast/integer.ts b/test/runtime/value/cast/integer.ts
index 1bf6228c9..534913a83 100644
--- a/test/runtime/value/cast/integer.ts
+++ b/test/runtime/value/cast/integer.ts
@@ -8,36 +8,36 @@ describe('value/cast/Integer', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, 1)
+    Assert.isEqual(result, 1)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
 })
diff --git a/test/runtime/value/cast/intersect.ts b/test/runtime/value/cast/intersect.ts
index 8a681fddb..596ecb2da 100644
--- a/test/runtime/value/cast/intersect.ts
+++ b/test/runtime/value/cast/intersect.ts
@@ -10,7 +10,7 @@ describe('value/cast/Intersect', () => {
       Type.Object({ y: Type.Number() })
     ])
     const V = Value.Cast(T, 1)
-    Assert.deepEqual(V, { x: 0, y: 0 })
+    Assert.isEqual(V, { x: 0, y: 0 })
   })
   it('Should cast from an partial object and preserve', () => {
     // prettier-ignore
@@ -19,7 +19,7 @@ describe('value/cast/Intersect', () => {
       Type.Object({ y: Type.Number() })
     ])
     const V = Value.Cast(T, { x: 1 })
-    Assert.deepEqual(V, { x: 1, y: 0 })
+    Assert.isEqual(V, { x: 1, y: 0 })
   })
   it('Should cast and use default values', () => {
     // prettier-ignore
@@ -28,7 +28,7 @@ describe('value/cast/Intersect', () => {
       Type.Object({ y: Type.Number({ default: 42 }) })
     ])
     const V = Value.Cast(T, { x: 1 })
-    Assert.deepEqual(V, { x: 1, y: 42 })
+    Assert.isEqual(V, { x: 1, y: 42 })
   })
   it('Should throw with an illogical intersect', () => {
     // prettier-ignore
@@ -53,7 +53,7 @@ describe('value/cast/Intersect', () => {
       Type.Object({ x: Type.Number({ default: 1000 }) })
     ])
     const V = Value.Cast(T, null)
-    Assert.deepEqual(V, { x: 1000 })
+    Assert.isEqual(V, { x: 1000 })
   })
   it('Should use last intersected default for equivalent sub schemas (primitives)', () => {
     // prettier-ignore
@@ -62,7 +62,7 @@ describe('value/cast/Intersect', () => {
       Type.Number({ default: 1000 })
     ])
     const V = Value.Cast(T, null)
-    Assert.deepEqual(V, 1000)
+    Assert.isEqual(V, 1000)
   })
   it('Should preserve if default is specified', () => {
     // prettier-ignore
@@ -71,6 +71,6 @@ describe('value/cast/Intersect', () => {
       Type.Number({ default: 1000 })
     ])
     const V = Value.Cast(T, 2000)
-    Assert.deepEqual(V, 2000)
+    Assert.isEqual(V, 2000)
   })
 })
diff --git a/test/runtime/value/cast/keyof.ts b/test/runtime/value/cast/keyof.ts
index 7ee9795fe..81cd828d3 100644
--- a/test/runtime/value/cast/keyof.ts
+++ b/test/runtime/value/cast/keyof.ts
@@ -14,46 +14,46 @@ describe('value/cast/KeyOf', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preserve', () => {
     const value = 'y'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, 'y')
+    Assert.isEqual(result, 'y')
   })
 })
diff --git a/test/runtime/value/cast/literal.ts b/test/runtime/value/cast/literal.ts
index 557abdf81..71ca7dff8 100644
--- a/test/runtime/value/cast/literal.ts
+++ b/test/runtime/value/cast/literal.ts
@@ -8,46 +8,46 @@ describe('value/cast/Literal', () => {
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preseve', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, 'hello')
+    Assert.isEqual(result, 'hello')
   })
 })
diff --git a/test/runtime/value/cast/not.ts b/test/runtime/value/cast/not.ts
index ac783efcf..0fc2d1ed4 100644
--- a/test/runtime/value/cast/not.ts
+++ b/test/runtime/value/cast/not.ts
@@ -8,52 +8,52 @@ describe('value/cast/Not', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 0
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preserve', () => {
     const value = 100
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, 100)
+    Assert.isEqual(result, 100)
   })
   it('Should not preserve when schema is illogical', () => {
     const T = Type.Not(Type.Number(), Type.Number())
     const value = 100
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, 0)
+    Assert.isEqual(result, 0)
   })
 })
diff --git a/test/runtime/value/cast/null.ts b/test/runtime/value/cast/null.ts
index 467068b5c..b4d019bd4 100644
--- a/test/runtime/value/cast/null.ts
+++ b/test/runtime/value/cast/null.ts
@@ -8,46 +8,46 @@ describe('value/cast/Null', () => {
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preseve', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, null)
+    Assert.isEqual(result, null)
   })
 })
diff --git a/test/runtime/value/cast/number.ts b/test/runtime/value/cast/number.ts
index e3e43b537..66d999c91 100644
--- a/test/runtime/value/cast/number.ts
+++ b/test/runtime/value/cast/number.ts
@@ -8,41 +8,41 @@ describe('value/cast/Number', () => {
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, 1)
+    Assert.isEqual(result, 1)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preseve', () => {
     const value = 123
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, 123)
+    Assert.isEqual(result, 123)
   })
 })
diff --git a/test/runtime/value/cast/object.ts b/test/runtime/value/cast/object.ts
index 0c631b556..3fa460100 100644
--- a/test/runtime/value/cast/object.ts
+++ b/test/runtime/value/cast/object.ts
@@ -22,47 +22,47 @@ describe('value/cast/Object', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = E
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preserve', () => {
     const value = { x: 7, y: 8, z: 9, a: 10, b: 11, c: 12 }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, {
+    Assert.isEqual(result, {
       x: 7,
       y: 8,
       z: 9,
@@ -74,7 +74,7 @@ describe('value/cast/Object', () => {
   it('Should upcast and preserve partial object', () => {
     const value = { x: 7, y: 8, z: 9 }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, {
+    Assert.isEqual(result, {
       x: 7,
       y: 8,
       z: 9,
@@ -86,7 +86,7 @@ describe('value/cast/Object', () => {
   it('Should upcast and preserve partial object with incorrect properties', () => {
     const value = { x: {}, y: 8, z: 9 }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, {
+    Assert.isEqual(result, {
       x: 0,
       y: 8,
       z: 9,
@@ -98,7 +98,7 @@ describe('value/cast/Object', () => {
   it('Should upcast and preserve partial object and omit unknown properties', () => {
     const value = { x: 7, y: 8, z: 9, unknown: 'foo' }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, {
+    Assert.isEqual(result, {
       x: 7,
       y: 8,
       z: 9,
@@ -127,7 +127,7 @@ describe('value/cast/Object', () => {
         z: true,
       },
     )
-    Assert.deepEqual(result, {
+    Assert.isEqual(result, {
       x: 1,
       y: 2,
       z: { a: 0, b: 0 },
@@ -153,7 +153,7 @@ describe('value/cast/Object', () => {
         z: { b: 1 },
       },
     )
-    Assert.deepEqual(result, {
+    Assert.isEqual(result, {
       x: 1,
       y: 2,
       z: { a: 0, b: 1 },
diff --git a/test/runtime/value/cast/record.ts b/test/runtime/value/cast/record.ts
index e62515ae2..1ef6828af 100644
--- a/test/runtime/value/cast/record.ts
+++ b/test/runtime/value/cast/record.ts
@@ -16,42 +16,42 @@ describe('value/cast/Record', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = E
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preserve', () => {
     const value = {
@@ -59,7 +59,7 @@ describe('value/cast/Record', () => {
       b: { x: 4, y: 5, z: 6 },
     }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should preserve and patch invalid records', () => {
     const value = {
@@ -70,7 +70,7 @@ describe('value/cast/Record', () => {
       e: { x: 1, y: 2, w: 9000 },
     }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, {
+    Assert.isEqual(result, {
       a: { x: 1, y: 2, z: 3 },
       b: { x: 4, y: 5, z: 0 },
       c: { x: 0, y: 0, z: 0 },
diff --git a/test/runtime/value/cast/recursive.ts b/test/runtime/value/cast/recursive.ts
index 78cc5c220..cf4316ba4 100644
--- a/test/runtime/value/cast/recursive.ts
+++ b/test/runtime/value/cast/recursive.ts
@@ -13,42 +13,42 @@ describe('value/cast/Recursive', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = E
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preserve', () => {
     const value = {
@@ -60,7 +60,7 @@ describe('value/cast/Recursive', () => {
       ],
     }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from varying types', () => {
     const TypeA = Type.Recursive((This) =>
@@ -85,7 +85,7 @@ describe('value/cast/Recursive', () => {
       ],
     }
     const ValueB = Value.Cast(TypeB, ValueA)
-    // Assert.deepEqual(ValueB, {
+    // Assert.isEqual(ValueB, {
     //   id: 'A',
     //   name: 'test',
     //   nodes: [
diff --git a/test/runtime/value/cast/regex.ts b/test/runtime/value/cast/regex.ts
index ab34f4264..d23bef49c 100644
--- a/test/runtime/value/cast/regex.ts
+++ b/test/runtime/value/cast/regex.ts
@@ -8,46 +8,46 @@ describe('value/cast/RegEx', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, 'foo')
+    Assert.isEqual(result, 'foo')
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preserve', () => {
     const value = 'foo'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
 })
diff --git a/test/runtime/value/cast/string.ts b/test/runtime/value/cast/string.ts
index 0ed878b4d..ff8f5c11d 100644
--- a/test/runtime/value/cast/string.ts
+++ b/test/runtime/value/cast/string.ts
@@ -8,36 +8,36 @@ describe('value/cast/String', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, 'hello')
+    Assert.isEqual(result, 'hello')
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preserve', () => {
     const value = 'foo'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
 })
diff --git a/test/runtime/value/cast/symbol.ts b/test/runtime/value/cast/symbol.ts
index 15af14c42..05fd88049 100644
--- a/test/runtime/value/cast/symbol.ts
+++ b/test/runtime/value/cast/symbol.ts
@@ -47,6 +47,6 @@ describe('value/cast/Symbol', () => {
   it('Should preserve', () => {
     const value = Symbol('hello')
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result.description, value.description)
+    Assert.isEqual(result.description, value.description)
   })
 })
diff --git a/test/runtime/value/cast/template-literal.ts b/test/runtime/value/cast/template-literal.ts
index b2255bdfe..322928ba5 100644
--- a/test/runtime/value/cast/template-literal.ts
+++ b/test/runtime/value/cast/template-literal.ts
@@ -8,46 +8,46 @@ describe('value/cast/TemplateLiteral', () => {
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preseve', () => {
     const value = 'helloworld'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, 'helloworld')
+    Assert.isEqual(result, 'helloworld')
   })
 })
diff --git a/test/runtime/value/cast/tuple.ts b/test/runtime/value/cast/tuple.ts
index 8ba7835c5..cb805cf6e 100644
--- a/test/runtime/value/cast/tuple.ts
+++ b/test/runtime/value/cast/tuple.ts
@@ -8,66 +8,66 @@ describe('value/cast/Tuple', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, [1, ''])
+    Assert.isEqual(result, [1, ''])
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preserve', () => {
     const value = [42, 'world']
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should upcast with empty', () => {
     const value = [] as any[]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should append with less than tuple length', () => {
     const value = [42]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, [42, ''])
+    Assert.isEqual(result, [42, ''])
   })
   it('Should truncate with greater than tuple length', () => {
     const value = [42, '', true]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, [42, ''])
+    Assert.isEqual(result, [42, ''])
   })
   it('Should preserve and patch invalid element', () => {
     const value = [{}, 'hello']
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, [0, 'hello'])
+    Assert.isEqual(result, [0, 'hello'])
   })
 })
diff --git a/test/runtime/value/cast/uint8array.ts b/test/runtime/value/cast/uint8array.ts
index 638eb9c57..4adf0eb44 100644
--- a/test/runtime/value/cast/uint8array.ts
+++ b/test/runtime/value/cast/uint8array.ts
@@ -8,46 +8,46 @@ describe('value/cast/Uint8Array', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preserve', () => {
     const value = new Uint8Array([6, 7, 8, 9, 10])
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
 })
diff --git a/test/runtime/value/cast/undefined.ts b/test/runtime/value/cast/undefined.ts
index d8a089ce6..9821ee947 100644
--- a/test/runtime/value/cast/undefined.ts
+++ b/test/runtime/value/cast/undefined.ts
@@ -8,46 +8,46 @@ describe('value/cast/Undefined', () => {
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preseve', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, undefined)
+    Assert.isEqual(result, undefined)
   })
 })
diff --git a/test/runtime/value/cast/union.ts b/test/runtime/value/cast/union.ts
index 5850866b8..4ca73b41e 100644
--- a/test/runtime/value/cast/union.ts
+++ b/test/runtime/value/cast/union.ts
@@ -32,87 +32,87 @@ describe('value/cast/Union', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preserve A', () => {
     const value = { type: 'A', x: 1, y: 2, z: 3 }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should preserve B', () => {
     const value = { type: 'B', a: 'a', b: 'b', c: 'c' }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should infer through heuristics #1', () => {
     const value = { type: 'A', a: 'a', b: 'b', c: 'c' }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, { type: 'A', x: 0, y: 0, z: 0 })
+    Assert.isEqual(result, { type: 'A', x: 0, y: 0, z: 0 })
   })
   it('Should infer through heuristics #2', () => {
     const value = { type: 'B', x: 1, y: 2, z: 3 }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, { type: 'B', a: '', b: '', c: '' })
+    Assert.isEqual(result, { type: 'B', a: '', b: '', c: '' })
   })
   it('Should infer through heuristics #3', () => {
     const value = { type: 'A', a: 'a', b: 'b', c: null }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, { type: 'A', x: 0, y: 0, z: 0 })
+    Assert.isEqual(result, { type: 'A', x: 0, y: 0, z: 0 })
   })
   it('Should infer through heuristics #4', () => {
     const value = { type: 'B', x: 1, y: 2, z: {} }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, { type: 'B', a: '', b: '', c: '' })
+    Assert.isEqual(result, { type: 'B', a: '', b: '', c: '' })
   })
   it('Should infer through heuristics #5', () => {
     const value = { type: 'B', x: 1, y: 2, z: null }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, { type: 'B', a: '', b: '', c: '' })
+    Assert.isEqual(result, { type: 'B', a: '', b: '', c: '' })
   })
   it('Should infer through heuristics #6', () => {
     const value = { x: 1 }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, { type: 'A', x: 1, y: 0, z: 0 })
+    Assert.isEqual(result, { type: 'A', x: 1, y: 0, z: 0 })
   })
   it('Should infer through heuristics #7', () => {
     const value = { a: null } // property existing should contribute
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, { type: 'B', a: '', b: '', c: '' })
+    Assert.isEqual(result, { type: 'B', a: '', b: '', c: '' })
   })
   it('Should cast with default value (create)', () => {
     const result = Value.Cast(
@@ -125,7 +125,7 @@ describe('value/cast/Union', () => {
         value: 'D',
       },
     )
-    Assert.deepEqual(result, {
+    Assert.isEqual(result, {
       id: 42,
       value: 'C',
     })
@@ -141,7 +141,7 @@ describe('value/cast/Union', () => {
         value: 'B',
       },
     )
-    Assert.deepEqual(result, {
+    Assert.isEqual(result, {
       id: 42,
       value: 'B',
     })
diff --git a/test/runtime/value/cast/unknown.ts b/test/runtime/value/cast/unknown.ts
index 806b37257..f6193fb7c 100644
--- a/test/runtime/value/cast/unknown.ts
+++ b/test/runtime/value/cast/unknown.ts
@@ -7,46 +7,46 @@ describe('value/cast/Unknown', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from boolean', () => {
     const value = false
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, value)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result: any = Value.Cast(T, value)
-    Assert.deepEqual(result.getTime(), 100)
+    Assert.isEqual(result.getTime(), 100)
   })
   it('Should preserve', () => {
     const value = { a: 1, b: 2 }
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, { a: 1, b: 2 })
+    Assert.isEqual(result, { a: 1, b: 2 })
   })
 })
diff --git a/test/runtime/value/cast/void.ts b/test/runtime/value/cast/void.ts
index 787c0bb85..6996f3bf0 100644
--- a/test/runtime/value/cast/void.ts
+++ b/test/runtime/value/cast/void.ts
@@ -8,46 +8,46 @@ describe('value/cast/Void', () => {
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, E)
+    Assert.isEqual(result, E)
   })
   it('Should preserve', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.deepEqual(result, null)
+    Assert.isEqual(result, null)
   })
 })
diff --git a/test/runtime/value/check/any.ts b/test/runtime/value/check/any.ts
index a9fab67d4..1f46bb09a 100644
--- a/test/runtime/value/check/any.ts
+++ b/test/runtime/value/check/any.ts
@@ -7,41 +7,41 @@ describe('value/check/Any', () => {
   it('Should pass string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should pass number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should pass boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should pass null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should pass undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should pass object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should pass array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should pass Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 })
diff --git a/test/runtime/value/check/array.ts b/test/runtime/value/check/array.ts
index 64f3f3806..c0ef023b8 100644
--- a/test/runtime/value/check/array.ts
+++ b/test/runtime/value/check/array.ts
@@ -7,46 +7,46 @@ describe('value/check/Array', () => {
     const T = Type.Array(Type.Number())
     const value = [1, 2, 3]
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should fail number array', () => {
     const T = Type.Array(Type.Number())
     const value = ['a', 'b', 'c']
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should pass object array', () => {
     const T = Type.Array(Type.Object({ x: Type.Number() }))
     const value = [{ x: 1 }, { x: 1 }, { x: 1 }]
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should fail object array', () => {
     const T = Type.Array(Type.Object({ x: Type.Number() }))
     const value = [{ x: 1 }, { x: 1 }, 1]
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(Type.Array(Type.Any()), value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should validate array with unique primitive items', () => {
     const T = Type.Array(Type.Number(), { uniqueItems: true })
     const result = Value.Check(T, [0, 1, 2])
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should not validate array with non-unique primitive items', () => {
     const T = Type.Array(Type.Number(), { uniqueItems: true })
     const result = Value.Check(T, [0, 0, 2])
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should validate array with unique object items', () => {
@@ -56,7 +56,7 @@ describe('value/check/Array', () => {
       { x: 2, y: 2 },
       { x: 3, y: 3 },
     ])
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should not validate array with non-unique object items', () => {
@@ -66,6 +66,6 @@ describe('value/check/Array', () => {
       { x: 1, y: 1 },
       { x: 3, y: 3 },
     ])
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/bigint.ts b/test/runtime/value/check/bigint.ts
index 74bf4c90d..2f663c384 100644
--- a/test/runtime/value/check/bigint.ts
+++ b/test/runtime/value/check/bigint.ts
@@ -7,38 +7,38 @@ describe('value/check/BigInt', () => {
   it('Should not validate NaN', () => {
     const T = Type.BigInt()
     const result = Value.Check(T, NaN)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should not validate +Infinity', () => {
     const T = Type.BigInt()
     const result = Value.Check(T, Infinity)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should not validate -Infinity', () => {
     const T = Type.BigInt()
     const result = Value.Check(T, -Infinity)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail integer', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail integer', () => {
     const value = 3.14
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should pass bigint', () => {
     const result = Value.Check(T, BigInt(0))
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 })
diff --git a/test/runtime/value/check/boolean.ts b/test/runtime/value/check/boolean.ts
index 887f3f020..d15d8b7d4 100644
--- a/test/runtime/value/check/boolean.ts
+++ b/test/runtime/value/check/boolean.ts
@@ -7,41 +7,41 @@ describe('value/check/Boolean', () => {
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should pass boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should fail null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/composite.ts b/test/runtime/value/check/composite.ts
index c9b4db2b6..fe4afa39f 100644
--- a/test/runtime/value/check/composite.ts
+++ b/test/runtime/value/check/composite.ts
@@ -25,7 +25,7 @@ describe('value/check/Composite', () => {
       c: '1',
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should fail intersect with invalid property', () => {
@@ -38,7 +38,7 @@ describe('value/check/Composite', () => {
       c: '1',
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail intersect with missing property', () => {
@@ -50,13 +50,13 @@ describe('value/check/Composite', () => {
       c: '1',
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail intersect with primitive value', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should pass intersect with optional properties', () => {
@@ -77,6 +77,6 @@ describe('value/check/Composite', () => {
       c: '1',
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 })
diff --git a/test/runtime/value/check/custom.ts b/test/runtime/value/check/custom.ts
index 796bc6f23..45e3dbba1 100644
--- a/test/runtime/value/check/custom.ts
+++ b/test/runtime/value/check/custom.ts
@@ -7,25 +7,25 @@ describe('type/check/Custom', () => {
 
   it('Should validate bigint', () => {
     const T = Type.Unsafe({ [Kind]: 'BigInt' })
-    Assert.deepEqual(Value.Check(T, 1n), true)
+    Assert.isEqual(Value.Check(T, 1n), true)
   })
 
   it('Should not validate bigint', () => {
     const T = Type.Unsafe({ [Kind]: 'BigInt' })
-    Assert.deepEqual(Value.Check(T, 1), false)
+    Assert.isEqual(Value.Check(T, 1), false)
   })
 
   it('Should validate bigint nested', () => {
     const T = Type.Object({
       x: Type.Unsafe({ [Kind]: 'BigInt' }),
     })
-    Assert.deepEqual(Value.Check(T, { x: 1n }), true)
+    Assert.isEqual(Value.Check(T, { x: 1n }), true)
   })
 
   it('Should not validate bigint nested', () => {
     const T = Type.Object({
       x: Type.Unsafe({ [Kind]: 'BigInt' }),
     })
-    Assert.deepEqual(Value.Check(T, { x: 1 }), false)
+    Assert.isEqual(Value.Check(T, { x: 1 }), false)
   })
 })
diff --git a/test/runtime/value/check/date.ts b/test/runtime/value/check/date.ts
index 39d40e00d..2d4e74f8c 100644
--- a/test/runtime/value/check/date.ts
+++ b/test/runtime/value/check/date.ts
@@ -7,46 +7,46 @@ describe('value/check/Date', () => {
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should pass Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should not validate Date if is invalid', () => {
     const value = new Date('not-a-valid-date')
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/enum.ts b/test/runtime/value/check/enum.ts
index 5eb8c08e6..ec1395cdc 100644
--- a/test/runtime/value/check/enum.ts
+++ b/test/runtime/value/check/enum.ts
@@ -12,23 +12,23 @@ describe('value/check/Enum', () => {
   it('Should pass enum option A', () => {
     const value = Foo.A
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should pass enum option B', () => {
     const value = Foo.A
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should fail unknown value', () => {
     const value = 'unknown'
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/integer.ts b/test/runtime/value/check/integer.ts
index ae46303f7..2db4fe7a7 100644
--- a/test/runtime/value/check/integer.ts
+++ b/test/runtime/value/check/integer.ts
@@ -8,34 +8,34 @@ describe('value/check/Integer', () => {
   it('Should not validate NaN', () => {
     const T = Type.Integer()
     const result = Value.Check(T, NaN)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should not validate +Infinity', () => {
     const T = Type.Integer()
     const result = Value.Check(T, Infinity)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should not validate -Infinity', () => {
     const T = Type.Integer()
     const result = Value.Check(T, -Infinity)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should pass integer', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should fail integer', () => {
     const value = 3.14
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/intersect.ts b/test/runtime/value/check/intersect.ts
index a7574a19e..e41a9d0ad 100644
--- a/test/runtime/value/check/intersect.ts
+++ b/test/runtime/value/check/intersect.ts
@@ -7,79 +7,79 @@ describe('value/check/Intersect', () => {
     const A = Type.Number()
     const B = Type.Number()
     const T = Type.Intersect([A, B], {})
-    Assert.equal(Value.Check(T, 1), true)
+    Assert.isEqual(Value.Check(T, 1), true)
   })
   it('Should not intersect string and number', () => {
     const A = Type.String()
     const B = Type.Number()
     const T = Type.Intersect([A, B], {})
-    Assert.equal(Value.Check(T, 1), false)
-    Assert.equal(Value.Check(T, '1'), false)
+    Assert.isEqual(Value.Check(T, 1), false)
+    Assert.isEqual(Value.Check(T, '1'), false)
   })
   it('Should intersect two objects', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ y: Type.Number() })
     const T = Type.Intersect([A, B], {})
-    Assert.equal(Value.Check(T, { x: 1, y: 1 }), true)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 1 }), true)
   })
   it('Should not intersect two objects with internal additionalProperties false', () => {
     const A = Type.Object({ x: Type.Number() }, { additionalProperties: false })
     const B = Type.Object({ y: Type.Number() }, { additionalProperties: false })
     const T = Type.Intersect([A, B], {})
-    Assert.equal(Value.Check(T, { x: 1, y: 1 }), false)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 1 }), false)
   })
   it('Should intersect two objects and mandate required properties', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ y: Type.Number() })
     const T = Type.Intersect([A, B], {})
-    Assert.equal(Value.Check(T, { x: 1, y: 1 }), true)
-    Assert.equal(Value.Check(T, { x: 1 }), false)
-    Assert.equal(Value.Check(T, { x: 1 }), false)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 1 }), true)
+    Assert.isEqual(Value.Check(T, { x: 1 }), false)
+    Assert.isEqual(Value.Check(T, { x: 1 }), false)
   })
   it('Should intersect two objects with unevaluated properties', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ y: Type.Number() })
     const T = Type.Intersect([A, B], {})
-    Assert.equal(Value.Check(T, { x: 1, y: 1, z: 1 }), true)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 1, z: 1 }), true)
   })
   it('Should intersect two objects and restrict unevaluated properties', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ y: Type.Number() })
     const T = Type.Intersect([A, B], { unevaluatedProperties: false })
-    Assert.equal(Value.Check(T, { x: 1, y: 1, z: 1 }), false)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 1, z: 1 }), false)
   })
   it('Should intersect two objects and allow unevaluated properties of number', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ y: Type.Number() })
     const T = Type.Intersect([A, B], { unevaluatedProperties: Type.Number() })
-    Assert.equal(Value.Check(T, { x: 1, y: 2, z: 3 }), true)
-    Assert.equal(Value.Check(T, { x: 1, y: 2, z: '1' }), false)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 2, z: 3 }), true)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 2, z: '1' }), false)
   })
   it('Should intersect two union objects with overlapping properties of the same type', () => {
     const A = Type.Union([Type.Object({ x: Type.Number() })])
     const B = Type.Union([Type.Object({ x: Type.Number() })])
     const T = Type.Intersect([A, B])
-    Assert.equal(Value.Check(T, { x: 1 }), true)
-    Assert.equal(Value.Check(T, { x: '1' }), false)
+    Assert.isEqual(Value.Check(T, { x: 1 }), true)
+    Assert.isEqual(Value.Check(T, { x: '1' }), false)
   })
   it('Should not intersect two union objects with overlapping properties of varying types', () => {
     const A = Type.Union([Type.Object({ x: Type.Number() })])
     const B = Type.Union([Type.Object({ x: Type.String() })])
     const T = Type.Intersect([A, B])
-    Assert.equal(Value.Check(T, { x: 1 }), false)
-    Assert.equal(Value.Check(T, { x: '1' }), false)
+    Assert.isEqual(Value.Check(T, { x: 1 }), false)
+    Assert.isEqual(Value.Check(T, { x: '1' }), false)
   })
   it('Should intersect two union objects with non-overlapping properties', () => {
     const A = Type.Union([Type.Object({ x: Type.Number() })])
     const B = Type.Union([Type.Object({ y: Type.Number() })])
     const T = Type.Intersect([A, B])
-    Assert.equal(Value.Check(T, { x: 1, y: 1 }), true)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 1 }), true)
   })
   it('Should not intersect two union objects with non-overlapping properties for additionalProperties false', () => {
     const A = Type.Union([Type.Object({ x: Type.Number() }, { additionalProperties: false })])
     const B = Type.Union([Type.Object({ y: Type.Number() }, { additionalProperties: false })])
     const T = Type.Intersect([A, B])
-    Assert.equal(Value.Check(T, { x: 1, y: 1 }), false)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 1 }), false)
   })
   it('unevaluatedProperties with Record 1', () => {
     const T = Type.Intersect(
@@ -94,7 +94,7 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: false,
       },
     )
-    Assert.equal(Value.Check(T, { x: 1, y: 2 }), true)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 2 }), true)
   })
   it('unevaluatedProperties with Record 2', () => {
     const T = Type.Intersect(
@@ -109,7 +109,7 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: false,
       },
     )
-    Assert.equal(Value.Check(T, { x: 1, y: 2, 0: 'hello' }), true)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 2, 0: 'hello' }), true)
   })
   it('unevaluatedProperties with Record 3', () => {
     const T = Type.Intersect(
@@ -124,7 +124,7 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: false,
       },
     )
-    Assert.equal(Value.Check(T, { x: 1, y: 2, 0: 1 }), false)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 2, 0: 1 }), false)
   })
   it('unevaluatedProperties with Record 4', () => {
     const T = Type.Intersect(
@@ -139,7 +139,7 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: Type.Boolean(),
       },
     )
-    Assert.equal(Value.Check(T, { x: 1, y: 2 }), true)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 2 }), true)
   })
   it('unevaluatedProperties with Record 5', () => {
     const T = Type.Intersect(
@@ -154,7 +154,7 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: Type.Boolean(),
       },
     )
-    Assert.equal(Value.Check(T, { x: 1, y: 2, z: true }), true)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 2, z: true }), true)
   })
   it('unevaluatedProperties with Record 6', () => {
     const T = Type.Intersect(
@@ -169,7 +169,7 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: Type.Boolean(),
       },
     )
-    Assert.equal(Value.Check(T, { x: 1, y: 2, z: 1 }), false)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 2, z: 1 }), false)
   })
   it('unevaluatedProperties with Record 7', () => {
     const T = Type.Intersect(
@@ -184,7 +184,7 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: Type.Boolean(),
       },
     )
-    Assert.equal(Value.Check(T, { x: 1, y: 2, 0: '' }), true)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 2, 0: '' }), true)
   })
   it('unevaluatedProperties with Record 8', () => {
     const T = Type.Intersect(
@@ -199,7 +199,7 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: Type.Boolean(),
       },
     )
-    Assert.equal(Value.Check(T, { x: 1, y: 2, 0: '', z: true }), true)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 2, 0: '', z: true }), true)
   })
   it('unevaluatedProperties with Record 9', () => {
     const T = Type.Intersect(
@@ -214,6 +214,6 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: Type.Boolean(),
       },
     )
-    Assert.equal(Value.Check(T, { x: 1, y: 2, 0: '', z: 1 }), false)
+    Assert.isEqual(Value.Check(T, { x: 1, y: 2, 0: '', z: 1 }), false)
   })
 })
diff --git a/test/runtime/value/check/keyof.ts b/test/runtime/value/check/keyof.ts
index 132446d60..ff9234f27 100644
--- a/test/runtime/value/check/keyof.ts
+++ b/test/runtime/value/check/keyof.ts
@@ -14,24 +14,24 @@ describe('value/check/KeyOf', () => {
   it('Should pass keyof', () => {
     const value = 'x'
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should fail keyof', () => {
     const value = 'w'
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail keyof with undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail keyof with null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/literal.ts b/test/runtime/value/check/literal.ts
index 84667b1e0..ae1e28dcb 100644
--- a/test/runtime/value/check/literal.ts
+++ b/test/runtime/value/check/literal.ts
@@ -7,21 +7,21 @@ describe('value/check/Literal', () => {
   it('Should pass literal', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should fail literal', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail literal with undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail literal with null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/never.ts b/test/runtime/value/check/never.ts
index 4f4948d6a..979e74474 100644
--- a/test/runtime/value/check/never.ts
+++ b/test/runtime/value/check/never.ts
@@ -7,36 +7,36 @@ describe('value/check/Never', () => {
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/not.ts b/test/runtime/value/check/not.ts
index b6a0b08f6..abfc89597 100644
--- a/test/runtime/value/check/not.ts
+++ b/test/runtime/value/check/not.ts
@@ -5,8 +5,8 @@ import { Assert } from '../../assert/index'
 describe('value/check/Not', () => {
   it('Should validate with not number', () => {
     const T = Type.Not(Type.Number(), Type.String())
-    Assert.equal(Value.Check(T, 1), false)
-    Assert.equal(Value.Check(T, 'A'), true)
+    Assert.isEqual(Value.Check(T, 1), false)
+    Assert.isEqual(Value.Check(T, 'A'), true)
   })
   it('Should validate with union left', () => {
     // prettier-ignore
@@ -15,10 +15,10 @@ describe('value/check/Not', () => {
             Type.Literal('B'),
             Type.Literal('C')
         ]), Type.String())
-    Assert.equal(Value.Check(T, 'A'), false)
-    Assert.equal(Value.Check(T, 'B'), false)
-    Assert.equal(Value.Check(T, 'C'), false)
-    Assert.equal(Value.Check(T, 'D'), true)
+    Assert.isEqual(Value.Check(T, 'A'), false)
+    Assert.isEqual(Value.Check(T, 'B'), false)
+    Assert.isEqual(Value.Check(T, 'C'), false)
+    Assert.isEqual(Value.Check(T, 'D'), true)
   })
   it('Should validate with union right', () => {
     // prettier-ignore
@@ -26,14 +26,14 @@ describe('value/check/Not', () => {
             Type.String(),
             Type.Boolean()
         ]))
-    Assert.equal(Value.Check(T, 1), false)
-    Assert.equal(Value.Check(T, 'A'), true)
-    Assert.equal(Value.Check(T, true), true)
+    Assert.isEqual(Value.Check(T, 1), false)
+    Assert.isEqual(Value.Check(T, 'A'), true)
+    Assert.isEqual(Value.Check(T, true), true)
   })
   it('Should not validate with symmetric left right', () => {
     // prettier-ignore
     const T = Type.Not(Type.Number(), Type.Number())
-    Assert.equal(Value.Check(T, 1), false)
-    Assert.equal(Value.Check(T, true), false)
+    Assert.isEqual(Value.Check(T, 1), false)
+    Assert.isEqual(Value.Check(T, true), false)
   })
 })
diff --git a/test/runtime/value/check/null.ts b/test/runtime/value/check/null.ts
index 15b9f786b..fea54f9ec 100644
--- a/test/runtime/value/check/null.ts
+++ b/test/runtime/value/check/null.ts
@@ -7,41 +7,41 @@ describe('value/check/Null', () => {
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should pass null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should fail undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/number.ts b/test/runtime/value/check/number.ts
index e2d0c63b8..3b60578ed 100644
--- a/test/runtime/value/check/number.ts
+++ b/test/runtime/value/check/number.ts
@@ -7,61 +7,61 @@ describe('value/check/Number', () => {
   it('Should not validate NaN', () => {
     const T = Type.Number()
     const result = Value.Check(T, NaN)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should not validate +Infinity', () => {
     const T = Type.Number()
     const result = Value.Check(T, Infinity)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should not validate -Infinity', () => {
     const T = Type.Number()
     const result = Value.Check(T, -Infinity)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should pass number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail NaN', () => {
     const result = Value.Check(Type.Number(), NaN)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/object.ts b/test/runtime/value/check/object.ts
index 6a06962de..65485881b 100644
--- a/test/runtime/value/check/object.ts
+++ b/test/runtime/value/check/object.ts
@@ -22,7 +22,7 @@ describe('value/check/Object', () => {
       c: '1',
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should fail object with additional properties', () => {
@@ -41,7 +41,7 @@ describe('value/check/Object', () => {
       a: 1,
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail object with invalid property', () => {
@@ -54,7 +54,7 @@ describe('value/check/Object', () => {
       c: '1',
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail object with missing property', () => {
@@ -66,7 +66,7 @@ describe('value/check/Object', () => {
       c: '1',
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should pass object with optional properties', () => {
@@ -84,19 +84,19 @@ describe('value/check/Object', () => {
       c: '1',
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should fail object with null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail object with undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should validate schema additional properties of string', () => {
@@ -110,7 +110,7 @@ describe('value/check/Object', () => {
       },
     )
 
-    Assert.equal(
+    Assert.isEqual(
       Value.Check(T, {
         x: 1,
         y: 2,
@@ -119,7 +119,7 @@ describe('value/check/Object', () => {
       true,
     )
 
-    Assert.equal(
+    Assert.isEqual(
       Value.Check(T, {
         x: 1,
         y: 2,
@@ -140,7 +140,7 @@ describe('value/check/Object', () => {
       },
     )
 
-    Assert.equal(
+    Assert.isEqual(
       Value.Check(T, {
         x: 1,
         y: 2,
@@ -149,7 +149,7 @@ describe('value/check/Object', () => {
       true,
     )
 
-    Assert.equal(
+    Assert.isEqual(
       Value.Check(T, {
         x: 1,
         y: 2,
@@ -172,7 +172,7 @@ describe('value/check/Object', () => {
       },
     )
 
-    Assert.equal(
+    Assert.isEqual(
       Value.Check(T, {
         x: 1,
         y: 2,
@@ -181,7 +181,7 @@ describe('value/check/Object', () => {
       true,
     )
 
-    Assert.equal(
+    Assert.isEqual(
       Value.Check(T, {
         x: 1,
         y: 2,
@@ -192,36 +192,36 @@ describe('value/check/Object', () => {
   })
   it('Should check for property key if property type is undefined', () => {
     const T = Type.Object({ x: Type.Undefined() })
-    Assert.equal(Value.Check(T, { x: undefined }), true)
-    Assert.equal(Value.Check(T, {}), false)
+    Assert.isEqual(Value.Check(T, { x: undefined }), true)
+    Assert.isEqual(Value.Check(T, {}), false)
   })
   it('Should check for property key if property type extends undefined', () => {
     const T = Type.Object({ x: Type.Union([Type.Number(), Type.Undefined()]) })
-    Assert.equal(Value.Check(T, { x: 1 }), true)
-    Assert.equal(Value.Check(T, { x: undefined }), true)
-    Assert.equal(Value.Check(T, {}), false)
+    Assert.isEqual(Value.Check(T, { x: 1 }), true)
+    Assert.isEqual(Value.Check(T, { x: undefined }), true)
+    Assert.isEqual(Value.Check(T, {}), false)
   })
   it('Should not check for property key if property type is undefined and optional', () => {
     const T = Type.Object({ x: Type.Optional(Type.Undefined()) })
-    Assert.equal(Value.Check(T, { x: undefined }), true)
-    Assert.equal(Value.Check(T, {}), true)
+    Assert.isEqual(Value.Check(T, { x: undefined }), true)
+    Assert.isEqual(Value.Check(T, {}), true)
   })
   it('Should not check for property key if property type extends undefined and optional', () => {
     const T = Type.Object({ x: Type.Optional(Type.Union([Type.Number(), Type.Undefined()])) })
-    Assert.equal(Value.Check(T, { x: 1 }), true)
-    Assert.equal(Value.Check(T, { x: undefined }), true)
-    Assert.equal(Value.Check(T, {}), true)
+    Assert.isEqual(Value.Check(T, { x: 1 }), true)
+    Assert.isEqual(Value.Check(T, { x: undefined }), true)
+    Assert.isEqual(Value.Check(T, {}), true)
   })
   it('Should check undefined for optional property of number', () => {
     const T = Type.Object({ x: Type.Optional(Type.Number()) })
-    Assert.equal(Value.Check(T, { x: 1 }), true)
-    Assert.equal(Value.Check(T, { x: undefined }), true) // allowed by default
-    Assert.equal(Value.Check(T, {}), true)
+    Assert.isEqual(Value.Check(T, { x: 1 }), true)
+    Assert.isEqual(Value.Check(T, { x: undefined }), true) // allowed by default
+    Assert.isEqual(Value.Check(T, {}), true)
   })
   it('Should check undefined for optional property of undefined', () => {
     const T = Type.Object({ x: Type.Optional(Type.Undefined()) })
-    Assert.equal(Value.Check(T, { x: 1 }), false)
-    Assert.equal(Value.Check(T, {}), true)
-    Assert.equal(Value.Check(T, { x: undefined }), true)
+    Assert.isEqual(Value.Check(T, { x: 1 }), false)
+    Assert.isEqual(Value.Check(T, {}), true)
+    Assert.isEqual(Value.Check(T, { x: undefined }), true)
   })
 })
diff --git a/test/runtime/value/check/record.ts b/test/runtime/value/check/record.ts
index 3fe8b5d08..1e36e37b1 100644
--- a/test/runtime/value/check/record.ts
+++ b/test/runtime/value/check/record.ts
@@ -20,33 +20,33 @@ describe('value/check/Record', () => {
       },
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should fail when below minProperties', () => {
     const T = Type.Record(Type.String(), Type.Number(), { minProperties: 4 })
-    Assert.equal(Value.Check(T, { a: 1, b: 2, c: 3, d: 4 }), true)
-    Assert.equal(Value.Check(T, { a: 1, b: 2, c: 3 }), false)
+    Assert.isEqual(Value.Check(T, { a: 1, b: 2, c: 3, d: 4 }), true)
+    Assert.isEqual(Value.Check(T, { a: 1, b: 2, c: 3 }), false)
   })
   it('Should fail when above maxProperties', () => {
     const T = Type.Record(Type.String(), Type.Number(), { maxProperties: 4 })
-    Assert.equal(Value.Check(T, { a: 1, b: 2, c: 3, d: 4 }), true)
-    Assert.equal(Value.Check(T, { a: 1, b: 2, c: 3, d: 4, e: 5 }), false)
+    Assert.isEqual(Value.Check(T, { a: 1, b: 2, c: 3, d: 4 }), true)
+    Assert.isEqual(Value.Check(T, { a: 1, b: 2, c: 3, d: 4, e: 5 }), false)
   })
   it('Should fail with illogical minProperties | maxProperties', () => {
     const T = Type.Record(Type.String(), Type.Number(), { minProperties: 5, maxProperties: 4 })
-    Assert.equal(Value.Check(T, { a: 1, b: 2, c: 3 }), false)
-    Assert.equal(Value.Check(T, { a: 1, b: 2, c: 3, d: 4 }), false)
-    Assert.equal(Value.Check(T, { a: 1, b: 2, c: 3, d: 4, e: 5 }), false)
+    Assert.isEqual(Value.Check(T, { a: 1, b: 2, c: 3 }), false)
+    Assert.isEqual(Value.Check(T, { a: 1, b: 2, c: 3, d: 4 }), false)
+    Assert.isEqual(Value.Check(T, { a: 1, b: 2, c: 3, d: 4, e: 5 }), false)
   })
   it('Should fail record with Date', () => {
     const T = Type.Record(Type.String(), Type.String())
     const result = Value.Check(T, new Date())
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail record with Uint8Array', () => {
     const T = Type.Record(Type.String(), Type.String())
     const result = Value.Check(T, new Uint8Array())
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail record with missing property', () => {
     const T = Type.Record(
@@ -64,7 +64,7 @@ describe('value/check/Record', () => {
       },
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail record with invalid property', () => {
     const T = Type.Record(
@@ -83,7 +83,7 @@ describe('value/check/Record', () => {
       },
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should pass record with optional property', () => {
     const T = Type.Record(
@@ -101,7 +101,7 @@ describe('value/check/Record', () => {
       },
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should pass record with optional property', () => {
     const T = Type.Record(
@@ -119,7 +119,7 @@ describe('value/check/Record', () => {
       },
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   // -------------------------------------------------
   // Number Key
@@ -132,7 +132,7 @@ describe('value/check/Record', () => {
       2: 'a',
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should not pass record with invalid number key', () => {
@@ -143,7 +143,7 @@ describe('value/check/Record', () => {
       2: 'a',
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   // -------------------------------------------------
   // Integer Key
@@ -156,7 +156,7 @@ describe('value/check/Record', () => {
       2: 'a',
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should not pass record with invalid integer key', () => {
     const T = Type.Record(Type.Integer(), Type.String(), { additionalProperties: false })
@@ -166,7 +166,7 @@ describe('value/check/Record', () => {
       2: 'a',
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   // ------------------------------------------------------------
   // AdditionalProperties
@@ -174,26 +174,26 @@ describe('value/check/Record', () => {
   it('AdditionalProperties 1', () => {
     const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: true })
     const R = Value.Check(T, { 1: '', 2: '', x: 1, y: 2, z: 3 })
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('AdditionalProperties 2', () => {
     const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: false })
     const R = Value.Check(T, { 1: '', 2: '', 3: '' })
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
   it('AdditionalProperties 3', () => {
     const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: false })
     const R = Value.Check(T, { 1: '', 2: '', x: '' })
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('AdditionalProperties 4', () => {
     const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: Type.Boolean() })
     const R = Value.Check(T, { 1: '', 2: '', x: '' })
-    Assert.equal(R, false)
+    Assert.isEqual(R, false)
   })
   it('AdditionalProperties 5', () => {
     const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: Type.Boolean() })
     const R = Value.Check(T, { 1: '', 2: '', x: true })
-    Assert.equal(R, true)
+    Assert.isEqual(R, true)
   })
 })
diff --git a/test/runtime/value/check/recursive.ts b/test/runtime/value/check/recursive.ts
index 79f56d1cd..f6c7b94be 100644
--- a/test/runtime/value/check/recursive.ts
+++ b/test/runtime/value/check/recursive.ts
@@ -20,7 +20,7 @@ describe('value/check/Recursive', () => {
       ],
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should fail recursive with invalid id', () => {
@@ -33,7 +33,7 @@ describe('value/check/Recursive', () => {
       ],
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail rec with invalid nodes', () => {
@@ -46,7 +46,7 @@ describe('value/check/Recursive', () => {
       ],
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail recursive with missing id', () => {
@@ -55,7 +55,7 @@ describe('value/check/Recursive', () => {
       nodes: [{ nodes: [] }, { id: 'C', nodes: [] }, { id: 'D', nodes: [] }],
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail rec with missing nodes', () => {
@@ -64,6 +64,6 @@ describe('value/check/Recursive', () => {
       nodes: [{ id: 'B' }, { id: 'C', nodes: [] }, { id: 'D', nodes: [] }],
     }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/ref.ts b/test/runtime/value/check/ref.ts
index be4c2980b..e838a383a 100644
--- a/test/runtime/value/check/ref.ts
+++ b/test/runtime/value/check/ref.ts
@@ -13,7 +13,7 @@ describe('value/check/Ref', () => {
       { $id: Assert.nextId() },
     )
     const R = Type.Ref(T)
-    Assert.deepEqual(
+    Assert.isEqual(
       Value.Check(R, [T], {
         x: 1,
         y: 2,
@@ -33,7 +33,7 @@ describe('value/check/Ref', () => {
       { $id: Assert.nextId() },
     )
     const R = Type.Ref(T)
-    Assert.deepEqual(
+    Assert.isEqual(
       Value.Check(R, [T], {
         x: 1,
         y: 2,
@@ -59,10 +59,10 @@ describe('value/check/Ref', () => {
       },
       { $id: 'T' },
     )
-    Assert.deepEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3 }), true)
-    Assert.deepEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3, r: { name: 'hello' } }), true)
-    Assert.deepEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3, r: { name: 1 } }), false)
-    Assert.deepEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3, r: {} }), false)
+    Assert.isEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3 }), true)
+    Assert.isEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3, r: { name: 'hello' } }), true)
+    Assert.isEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3, r: { name: 1 } }), false)
+    Assert.isEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3, r: {} }), false)
     // Ok(R, { x: 1, y: 2, z: 3 }, [T])
     // Ok(R, , [T])
     // Fail(R, , [T])
@@ -77,7 +77,7 @@ describe('value/check/Ref', () => {
       }),
     )
     const R = Type.Ref(T)
-    Assert.deepEqual(Value.Check(R, [T], { id: '', nodes: [{ id: '', nodes: [] }] }), true)
-    Assert.deepEqual(Value.Check(R, [T], { id: '', nodes: [{ id: 1, nodes: [] }] }), false)
+    Assert.isEqual(Value.Check(R, [T], { id: '', nodes: [{ id: '', nodes: [] }] }), true)
+    Assert.isEqual(Value.Check(R, [T], { id: '', nodes: [{ id: 1, nodes: [] }] }), false)
   })
 })
diff --git a/test/runtime/value/check/regex.ts b/test/runtime/value/check/regex.ts
index 343e10980..b56076ded 100644
--- a/test/runtime/value/check/regex.ts
+++ b/test/runtime/value/check/regex.ts
@@ -7,13 +7,13 @@ describe('value/check/RegEx', () => {
     const T = Type.RegEx(/foo/)
     const value = 'foo'
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should fail regex', () => {
     const T = Type.RegEx(/foo/)
     const value = 'bar'
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/string.ts b/test/runtime/value/check/string.ts
index 7db4daca3..1dbc26690 100644
--- a/test/runtime/value/check/string.ts
+++ b/test/runtime/value/check/string.ts
@@ -7,41 +7,41 @@ describe('value/check/String', () => {
   it('Should pass string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/symbol.ts b/test/runtime/value/check/symbol.ts
index f2df521eb..12b343d15 100644
--- a/test/runtime/value/check/symbol.ts
+++ b/test/runtime/value/check/symbol.ts
@@ -7,46 +7,46 @@ describe('value/check/Symbol', () => {
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should pass symbol', () => {
     const value = Symbol(1)
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 })
diff --git a/test/runtime/value/check/template-literal.ts b/test/runtime/value/check/template-literal.ts
index 7208578c7..44fbbb66b 100644
--- a/test/runtime/value/check/template-literal.ts
+++ b/test/runtime/value/check/template-literal.ts
@@ -9,23 +9,23 @@ describe('value/check/TemplateLiteral', () => {
   it('Should validate finite pattern 1', () => {
     // prettier-ignore
     const T = Type.TemplateLiteral([])
-    Assert.equal(Value.Check(T, ''), true)
-    Assert.equal(Value.Check(T, 'X'), false)
+    Assert.isEqual(Value.Check(T, ''), true)
+    Assert.isEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate finite pattern 1', () => {
     // prettier-ignore
     const T = Type.TemplateLiteral([Type.Boolean()])
-    Assert.equal(Value.Check(T, 'true'), true)
-    Assert.equal(Value.Check(T, 'false'), true)
-    Assert.equal(Value.Check(T, 'X'), false)
+    Assert.isEqual(Value.Check(T, 'true'), true)
+    Assert.isEqual(Value.Check(T, 'false'), true)
+    Assert.isEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate finite pattern 2', () => {
     // prettier-ignore
     const T = Type.TemplateLiteral([
       Type.Literal('A')
     ])
-    Assert.equal(Value.Check(T, 'A'), true)
-    Assert.equal(Value.Check(T, 'X'), false)
+    Assert.isEqual(Value.Check(T, 'A'), true)
+    Assert.isEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate finite pattern 3', () => {
     // prettier-ignore
@@ -33,8 +33,8 @@ describe('value/check/TemplateLiteral', () => {
       Type.Literal('A'),
       Type.Literal('B')
     ])
-    Assert.equal(Value.Check(T, 'AB'), true)
-    Assert.equal(Value.Check(T, 'X'), false)
+    Assert.isEqual(Value.Check(T, 'AB'), true)
+    Assert.isEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate finite pattern 4', () => {
     // prettier-ignore
@@ -45,9 +45,9 @@ describe('value/check/TemplateLiteral', () => {
         Type.Literal('C')
       ]),
     ])
-    Assert.equal(Value.Check(T, 'AB'), true)
-    Assert.equal(Value.Check(T, 'AC'), true)
-    Assert.equal(Value.Check(T, 'X'), false)
+    Assert.isEqual(Value.Check(T, 'AB'), true)
+    Assert.isEqual(Value.Check(T, 'AC'), true)
+    Assert.isEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate finite pattern 5', () => {
     // prettier-ignore
@@ -59,9 +59,9 @@ describe('value/check/TemplateLiteral', () => {
       ]),
       Type.Literal('D'),
     ])
-    Assert.equal(Value.Check(T, 'ABD'), true)
-    Assert.equal(Value.Check(T, 'ACD'), true)
-    Assert.equal(Value.Check(T, 'X'), false)
+    Assert.isEqual(Value.Check(T, 'ABD'), true)
+    Assert.isEqual(Value.Check(T, 'ACD'), true)
+    Assert.isEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate finite pattern 6', () => {
     // prettier-ignore
@@ -75,11 +75,11 @@ describe('value/check/TemplateLiteral', () => {
         Type.Literal('1')
       ]),
     ])
-    Assert.equal(Value.Check(T, '00'), true)
-    Assert.equal(Value.Check(T, '01'), true)
-    Assert.equal(Value.Check(T, '10'), true)
-    Assert.equal(Value.Check(T, '11'), true)
-    Assert.equal(Value.Check(T, 'X'), false)
+    Assert.isEqual(Value.Check(T, '00'), true)
+    Assert.isEqual(Value.Check(T, '01'), true)
+    Assert.isEqual(Value.Check(T, '10'), true)
+    Assert.isEqual(Value.Check(T, '11'), true)
+    Assert.isEqual(Value.Check(T, 'X'), false)
   })
   // --------------------------------------------------------
   // Infinite
@@ -89,47 +89,47 @@ describe('value/check/TemplateLiteral', () => {
     const T = Type.TemplateLiteral([
       Type.Number()
     ])
-    Assert.equal(Value.Check(T, '1'), true)
-    Assert.equal(Value.Check(T, '22'), true)
-    Assert.equal(Value.Check(T, '333'), true)
-    Assert.equal(Value.Check(T, '4444'), true)
-    Assert.equal(Value.Check(T, 'X'), false)
+    Assert.isEqual(Value.Check(T, '1'), true)
+    Assert.isEqual(Value.Check(T, '22'), true)
+    Assert.isEqual(Value.Check(T, '333'), true)
+    Assert.isEqual(Value.Check(T, '4444'), true)
+    Assert.isEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate infinite pattern 2', () => {
     // prettier-ignore
     const T = Type.TemplateLiteral([
       Type.Integer()
     ])
-    Assert.equal(Value.Check(T, '1'), true)
-    Assert.equal(Value.Check(T, '22'), true)
-    Assert.equal(Value.Check(T, '333'), true)
-    Assert.equal(Value.Check(T, '4444'), true)
-    Assert.equal(Value.Check(T, 'X'), false)
+    Assert.isEqual(Value.Check(T, '1'), true)
+    Assert.isEqual(Value.Check(T, '22'), true)
+    Assert.isEqual(Value.Check(T, '333'), true)
+    Assert.isEqual(Value.Check(T, '4444'), true)
+    Assert.isEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate infinite pattern 3', () => {
     // prettier-ignore
     const T = Type.TemplateLiteral([
       Type.BigInt()
     ])
-    Assert.equal(Value.Check(T, '1'), true)
-    Assert.equal(Value.Check(T, '22'), true)
-    Assert.equal(Value.Check(T, '333'), true)
-    Assert.equal(Value.Check(T, '4444'), true)
-    Assert.equal(Value.Check(T, 'X'), false)
+    Assert.isEqual(Value.Check(T, '1'), true)
+    Assert.isEqual(Value.Check(T, '22'), true)
+    Assert.isEqual(Value.Check(T, '333'), true)
+    Assert.isEqual(Value.Check(T, '4444'), true)
+    Assert.isEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate infinite pattern 4', () => {
     // prettier-ignore
     const T = Type.TemplateLiteral([
       Type.String()
     ])
-    Assert.equal(Value.Check(T, '1'), true)
-    Assert.equal(Value.Check(T, '22'), true)
-    Assert.equal(Value.Check(T, '333'), true)
-    Assert.equal(Value.Check(T, '4444'), true)
-    Assert.equal(Value.Check(T, 'a'), true)
-    Assert.equal(Value.Check(T, 'bb'), true)
-    Assert.equal(Value.Check(T, 'ccc'), true)
-    Assert.equal(Value.Check(T, 'dddd'), true)
+    Assert.isEqual(Value.Check(T, '1'), true)
+    Assert.isEqual(Value.Check(T, '22'), true)
+    Assert.isEqual(Value.Check(T, '333'), true)
+    Assert.isEqual(Value.Check(T, '4444'), true)
+    Assert.isEqual(Value.Check(T, 'a'), true)
+    Assert.isEqual(Value.Check(T, 'bb'), true)
+    Assert.isEqual(Value.Check(T, 'ccc'), true)
+    Assert.isEqual(Value.Check(T, 'dddd'), true)
   })
 
   it('Should validate infinite pattern 5', () => {
@@ -138,11 +138,11 @@ describe('value/check/TemplateLiteral', () => {
       Type.Literal('A'),
       Type.Number()
     ])
-    Assert.equal(Value.Check(T, 'A1'), true)
-    Assert.equal(Value.Check(T, 'A22'), true)
-    Assert.equal(Value.Check(T, 'A333'), true)
-    Assert.equal(Value.Check(T, 'A4444'), true)
-    Assert.equal(Value.Check(T, 'X'), false)
+    Assert.isEqual(Value.Check(T, 'A1'), true)
+    Assert.isEqual(Value.Check(T, 'A22'), true)
+    Assert.isEqual(Value.Check(T, 'A333'), true)
+    Assert.isEqual(Value.Check(T, 'A4444'), true)
+    Assert.isEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate infinite pattern 6', () => {
     // prettier-ignore
@@ -150,11 +150,11 @@ describe('value/check/TemplateLiteral', () => {
       Type.Literal('A'),
       Type.Integer()
     ])
-    Assert.equal(Value.Check(T, 'A1'), true)
-    Assert.equal(Value.Check(T, 'A22'), true)
-    Assert.equal(Value.Check(T, 'A333'), true)
-    Assert.equal(Value.Check(T, 'A4444'), true)
-    Assert.equal(Value.Check(T, 'X'), false)
+    Assert.isEqual(Value.Check(T, 'A1'), true)
+    Assert.isEqual(Value.Check(T, 'A22'), true)
+    Assert.isEqual(Value.Check(T, 'A333'), true)
+    Assert.isEqual(Value.Check(T, 'A4444'), true)
+    Assert.isEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate infinite pattern 7', () => {
     // prettier-ignore
@@ -162,11 +162,11 @@ describe('value/check/TemplateLiteral', () => {
       Type.Literal('A'),
       Type.BigInt()
     ])
-    Assert.equal(Value.Check(T, 'A1'), true)
-    Assert.equal(Value.Check(T, 'A22'), true)
-    Assert.equal(Value.Check(T, 'A333'), true)
-    Assert.equal(Value.Check(T, 'A4444'), true)
-    Assert.equal(Value.Check(T, 'X'), false)
+    Assert.isEqual(Value.Check(T, 'A1'), true)
+    Assert.isEqual(Value.Check(T, 'A22'), true)
+    Assert.isEqual(Value.Check(T, 'A333'), true)
+    Assert.isEqual(Value.Check(T, 'A4444'), true)
+    Assert.isEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate infinite pattern 8', () => {
     // prettier-ignore
@@ -174,14 +174,14 @@ describe('value/check/TemplateLiteral', () => {
       Type.Literal('A'),
       Type.String()
     ])
-    Assert.equal(Value.Check(T, 'A1'), true)
-    Assert.equal(Value.Check(T, 'A22'), true)
-    Assert.equal(Value.Check(T, 'A333'), true)
-    Assert.equal(Value.Check(T, 'A4444'), true)
-    Assert.equal(Value.Check(T, 'Aa'), true)
-    Assert.equal(Value.Check(T, 'Abb'), true)
-    Assert.equal(Value.Check(T, 'Accc'), true)
-    Assert.equal(Value.Check(T, 'Adddd'), true)
-    Assert.equal(Value.Check(T, 'X'), false)
+    Assert.isEqual(Value.Check(T, 'A1'), true)
+    Assert.isEqual(Value.Check(T, 'A22'), true)
+    Assert.isEqual(Value.Check(T, 'A333'), true)
+    Assert.isEqual(Value.Check(T, 'A4444'), true)
+    Assert.isEqual(Value.Check(T, 'Aa'), true)
+    Assert.isEqual(Value.Check(T, 'Abb'), true)
+    Assert.isEqual(Value.Check(T, 'Accc'), true)
+    Assert.isEqual(Value.Check(T, 'Adddd'), true)
+    Assert.isEqual(Value.Check(T, 'X'), false)
   })
 })
diff --git a/test/runtime/value/check/tuple.ts b/test/runtime/value/check/tuple.ts
index 2d010d9aa..2fc512f98 100644
--- a/test/runtime/value/check/tuple.ts
+++ b/test/runtime/value/check/tuple.ts
@@ -7,34 +7,34 @@ describe('value/check/Tuple', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should fail when tuple is less than length', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
     const value = [1]
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail when tuple is greater than length', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
     const value = [1, 1, 2]
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should pass empty tuple', () => {
     const T = Type.Tuple([])
     const value = [] as any[]
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should fail empty tuple', () => {
     const T = Type.Tuple([])
     const value = [1]
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/uint8array.ts b/test/runtime/value/check/uint8array.ts
index 9940e7c4a..21f526a79 100644
--- a/test/runtime/value/check/uint8array.ts
+++ b/test/runtime/value/check/uint8array.ts
@@ -7,27 +7,27 @@ describe('value/check/Uint8Array', () => {
     const T = Type.Uint8Array()
     const value = new Uint8Array(4)
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should fail Uint8Array', () => {
     const T = Type.Uint8Array()
     const value = [0, 1, 2, 3]
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail Uint8Array with undefined', () => {
     const T = Type.Uint8Array()
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail Uint8Array with null', () => {
     const T = Type.Uint8Array()
     const value = null
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/undefined.ts b/test/runtime/value/check/undefined.ts
index 83b6f3383..d25ec8303 100644
--- a/test/runtime/value/check/undefined.ts
+++ b/test/runtime/value/check/undefined.ts
@@ -7,41 +7,41 @@ describe('value/check/Undefined', () => {
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should pass undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/union.ts b/test/runtime/value/check/union.ts
index ff822c895..bbd29951e 100644
--- a/test/runtime/value/check/union.ts
+++ b/test/runtime/value/check/union.ts
@@ -20,25 +20,25 @@ describe('value/check/Union', () => {
   it('Should pass union A', () => {
     const value = { type: 'A', x: 1, y: 1 }
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should pass union B', () => {
     const value = { type: 'B', x: true, y: false }
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should fail union A', () => {
     const value = { type: 'A', x: true, y: false }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should fail union B', () => {
     const value = { type: 'B', x: 1, y: 1 }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 
   it('Should pass union A with optional properties', () => {
@@ -55,7 +55,7 @@ describe('value/check/Union', () => {
     const T = Type.Union([A, B])
     const value = { type: 'A' }
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 
   it('Should fail union A with invalid optional properties', () => {
@@ -72,6 +72,6 @@ describe('value/check/Union', () => {
     const T = Type.Union([A, B])
     const value = { type: 'A', x: true, y: false }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/unknown.ts b/test/runtime/value/check/unknown.ts
index 19e305188..bb9943933 100644
--- a/test/runtime/value/check/unknown.ts
+++ b/test/runtime/value/check/unknown.ts
@@ -7,41 +7,41 @@ describe('value/check/Unknown', () => {
   it('Should pass string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should pass number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should pass boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should pass null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should pass undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should pass object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should pass array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should pass Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
 })
diff --git a/test/runtime/value/check/void.ts b/test/runtime/value/check/void.ts
index 5930cb44f..0c1b26eb9 100644
--- a/test/runtime/value/check/void.ts
+++ b/test/runtime/value/check/void.ts
@@ -7,41 +7,41 @@ describe('value/check/Void', () => {
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should pass null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should pass undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.equal(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.equal(result, false)
+    Assert.isEqual(result, false)
   })
 })
diff --git a/test/runtime/value/clone/clone.ts b/test/runtime/value/clone/clone.ts
index 4fdcf9e04..8655dd1ba 100644
--- a/test/runtime/value/clone/clone.ts
+++ b/test/runtime/value/clone/clone.ts
@@ -7,38 +7,38 @@ describe('value/clone/Clone', () => {
   // --------------------------------------------
   it('Should clone null', () => {
     const R = Value.Clone(null)
-    Assert.deepEqual(R, null)
+    Assert.isEqual(R, null)
   })
 
   it('Should clone undefined', () => {
     const R = Value.Clone(undefined)
-    Assert.deepEqual(R, undefined)
+    Assert.isEqual(R, undefined)
   })
 
   it('Should clone number', () => {
     const R = Value.Clone(1)
-    Assert.deepEqual(R, 1)
+    Assert.isEqual(R, 1)
   })
 
   it('Should clone bigint', () => {
     const R = Value.Clone(1n)
-    Assert.deepEqual(R, 1n)
+    Assert.isEqual(R, 1n)
   })
 
   it('Should clone boolean', () => {
     const R = Value.Clone(true)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should clone string', () => {
     const R = Value.Clone('hello')
-    Assert.deepEqual(R, 'hello')
+    Assert.isEqual(R, 'hello')
   })
 
   it('Should clone symbol', () => {
     const S = Symbol('hello')
     const R = Value.Clone(S)
-    Assert.deepEqual(R, S)
+    Assert.isEqual(R, S)
   })
 
   // --------------------------------------------
@@ -52,7 +52,7 @@ describe('value/clone/Clone', () => {
       z: 3,
     }
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
 
   it('Should clone object #2', () => {
@@ -67,7 +67,7 @@ describe('value/clone/Clone', () => {
       },
     }
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
 
   it('Should clone object #3', () => {
@@ -78,7 +78,7 @@ describe('value/clone/Clone', () => {
       w: [0, 1, 2, 3, 4],
     }
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
   // --------------------------------------------
   // ArrayType
@@ -86,7 +86,7 @@ describe('value/clone/Clone', () => {
   it('Should clone array #1', () => {
     const V = [1, 2, 3, 4]
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
   it('Should clone array #2', () => {
     const V = [
@@ -96,7 +96,7 @@ describe('value/clone/Clone', () => {
       [1, 2, 3],
     ]
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
   it('Should clone array #3', () => {
     const V = [
@@ -106,72 +106,72 @@ describe('value/clone/Clone', () => {
       { x: 1, y: 2, z: 3 },
     ]
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
 
   it('Should clone Int8Array', () => {
     const V = new Int8Array([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
 
   it('Should clone Uint8Array', () => {
     const V = new Uint8Array([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
 
   it('Should clone Uint8ClampedArray', () => {
     const V = new Uint8ClampedArray([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
 
   it('Should clone Int16Array', () => {
     const V = new Int16Array([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
 
   it('Should clone Uint16Array', () => {
     const V = new Uint16Array([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
 
   it('Should clone Int32Array', () => {
     const V = new Int32Array([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
 
   it('Should clone Uint32Array', () => {
     const V = new Int32Array([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
 
   it('Should clone Float32Array', () => {
     const V = new Float32Array([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
 
   it('Should clone Float64Array', () => {
     const V = new Float64Array([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
 
   it('Should clone BigInt64Array', () => {
     const V = new BigInt64Array([1n, 2n, 3n, 4n])
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
 
   it('Should clone BigUint64Array', () => {
     const V = new BigUint64Array([1n, 2n, 3n, 4n])
     const R = Value.Clone(V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
 })
diff --git a/test/runtime/value/convert/any.ts b/test/runtime/value/convert/any.ts
index cb776c87c..81f57de58 100644
--- a/test/runtime/value/convert/any.ts
+++ b/test/runtime/value/convert/any.ts
@@ -7,36 +7,36 @@ describe('value/convert/Any', () => {
   it('Should convert null', () => {
     const V = null
     const R = Value.Convert(T, V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
   it('Should convert undefined', () => {
     const V = undefined
     const R = Value.Convert(T, V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
   it('Should convert string', () => {
     const V = 'hello'
     const R = Value.Convert(T, V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
   it('Should convert number', () => {
     const V = 42
     const R = Value.Convert(T, V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
   it('Should convert boolean', () => {
     const V = true
     const R = Value.Convert(T, V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
   it('Should convert object', () => {
     const V = { x: 1 }
     const R = Value.Convert(T, V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
   it('Should convert array', () => {
     const V = [1, 2, 3]
     const R = Value.Convert(T, V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
 })
diff --git a/test/runtime/value/convert/array.ts b/test/runtime/value/convert/array.ts
index 18e41d496..be8ed6af6 100644
--- a/test/runtime/value/convert/array.ts
+++ b/test/runtime/value/convert/array.ts
@@ -6,27 +6,27 @@ describe('value/convert/Array', () => {
   it('Should convert array of number', () => {
     const T = Type.Array(Type.Number())
     const R = Value.Convert(T, [1, 3.14, '1', '3.14', true, false, 'true', 'false', 'hello'])
-    Assert.deepEqual(R, [1, 3.14, 1, 3.14, 1, 0, 1, 0, 'hello'])
+    Assert.isEqual(R, [1, 3.14, 1, 3.14, 1, 0, 1, 0, 'hello'])
   })
   it('Should convert array of boolean', () => {
     const T = Type.Array(Type.Boolean())
     const R = Value.Convert(T, [1, 3.14, '1', '3.14', true, false, 'true', 'false', 'hello'])
-    Assert.deepEqual(R, [true, 3.14, true, '3.14', true, false, true, false, 'hello'])
+    Assert.isEqual(R, [true, 3.14, true, '3.14', true, false, true, false, 'hello'])
   })
   it('Should convert array of string', () => {
     const T = Type.Array(Type.String())
     const R = Value.Convert(T, [1, 3.14, '1', '3.14', true, false, 'true', 'false', 'hello'])
-    Assert.deepEqual(R, ['1', '3.14', '1', '3.14', 'true', 'false', 'true', 'false', 'hello'])
+    Assert.isEqual(R, ['1', '3.14', '1', '3.14', 'true', 'false', 'true', 'false', 'hello'])
   })
   it('Should convert array of date', () => {
     const T = Type.Array(Type.Date())
     const R = Value.Convert(T, [1, '1', true, false, 'true', 'false', 'hello']) as any[]
-    Assert.deepEqual(R[0].getTime(), 1)
-    Assert.deepEqual(R[1].getTime(), 1)
-    Assert.deepEqual(R[2].getTime(), 1)
-    Assert.deepEqual(R[3].getTime(), 0)
-    Assert.deepEqual(R[4].getTime(), 1)
-    Assert.deepEqual(R[5].getTime(), 0)
-    Assert.deepEqual(R[6], 'hello')
+    Assert.isEqual(R[0].getTime(), 1)
+    Assert.isEqual(R[1].getTime(), 1)
+    Assert.isEqual(R[2].getTime(), 1)
+    Assert.isEqual(R[3].getTime(), 0)
+    Assert.isEqual(R[4].getTime(), 1)
+    Assert.isEqual(R[5].getTime(), 0)
+    Assert.isEqual(R[6], 'hello')
   })
 })
diff --git a/test/runtime/value/convert/bigint.ts b/test/runtime/value/convert/bigint.ts
index 69a23791e..83a069632 100644
--- a/test/runtime/value/convert/bigint.ts
+++ b/test/runtime/value/convert/bigint.ts
@@ -6,41 +6,41 @@ describe('value/convert/BigInt', () => {
   it('Should convert bitint from string 1', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, '1')
-    Assert.deepEqual(R, BigInt(1))
+    Assert.isEqual(R, BigInt(1))
   })
   it('Should convert bigint from string 2', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, '3.14')
-    Assert.deepEqual(R, BigInt(3))
+    Assert.isEqual(R, BigInt(3))
   })
   it('Should convert bitint from string 3', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, 'true')
-    Assert.deepEqual(R, BigInt(1))
+    Assert.isEqual(R, BigInt(1))
   })
   it('Should convert bigint from string 4', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, 'false')
-    Assert.deepEqual(R, BigInt(0))
+    Assert.isEqual(R, BigInt(0))
   })
   it('Should convert bitint from number 1', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, 1)
-    Assert.deepEqual(R, BigInt(1))
+    Assert.isEqual(R, BigInt(1))
   })
   it('Should convert bigint from number 2', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, 3.14)
-    Assert.deepEqual(R, BigInt(3))
+    Assert.isEqual(R, BigInt(3))
   })
   it('Should convert bitint from boolean 1', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, true)
-    Assert.deepEqual(R, BigInt(1))
+    Assert.isEqual(R, BigInt(1))
   })
   it('Should convert bigint from boolean 2', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, false)
-    Assert.deepEqual(R, BigInt(0))
+    Assert.isEqual(R, BigInt(0))
   })
 })
diff --git a/test/runtime/value/convert/boolean.ts b/test/runtime/value/convert/boolean.ts
index 02f3422af..2a72c08ee 100644
--- a/test/runtime/value/convert/boolean.ts
+++ b/test/runtime/value/convert/boolean.ts
@@ -6,47 +6,47 @@ describe('value/convert/Boolean', () => {
   it('Should convert from string 1', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, '1')
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should convert from string 2', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, '3.14')
-    Assert.deepEqual(R, '3.14')
+    Assert.isEqual(R, '3.14')
   })
   it('Should convert from string 3', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, 'true')
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should convert from string 4', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, 'false')
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should convert from number 1', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, 1)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should convert from number 2', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, 3.14)
-    Assert.deepEqual(R, 3.14)
+    Assert.isEqual(R, 3.14)
   })
   it('Should convert from number 3', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, 1.1)
-    Assert.deepEqual(R, 1.1)
+    Assert.isEqual(R, 1.1)
   })
   it('Should convert from boolean 1', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, true)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should convert from boolean 2', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, false)
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
   // ----------------------------------------------------------
   // Casts
@@ -54,101 +54,101 @@ describe('value/convert/Boolean', () => {
   it('Should convert string #1', () => {
     const value = 'hello'
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.deepEqual(result, 'hello')
+    Assert.isEqual(result, 'hello')
   })
   it('Should convert string #2', () => {
     const value = 'true'
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.deepEqual(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should convert string #3', () => {
     const value = 'TRUE'
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.deepEqual(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should convert string #4', () => {
     const value = 'false'
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.deepEqual(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should convert string #5', () => {
     const value = '0'
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.deepEqual(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should convert string #6', () => {
     const value = '1'
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.deepEqual(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should convert string #7', () => {
     const value = '0'
     const result = Value.Convert(Type.Boolean({ default: true }), value)
-    Assert.deepEqual(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should convert string #8', () => {
     const value = '1'
     const result = Value.Convert(Type.Boolean({ default: false }), value)
-    Assert.deepEqual(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should convert string #8', () => {
     const value = '2'
     const result = Value.Convert(Type.Boolean({ default: true }), value)
-    Assert.deepEqual(result, '2')
+    Assert.isEqual(result, '2')
   })
   it('Should convert number #1', () => {
     const value = 0
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.deepEqual(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should convert number #2', () => {
     const value = 1n
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.deepEqual(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should convert number #3', () => {
     const value = 1
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.deepEqual(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should convert number #4', () => {
     const value = 2
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.deepEqual(result, 2)
+    Assert.isEqual(result, 2)
   })
   it('Should convert number #5', () => {
     const value = 0
     const result = Value.Convert(Type.Boolean({ default: true }), value)
-    Assert.deepEqual(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should convert number #6', () => {
     const value = 1
     const result = Value.Convert(Type.Boolean({ default: false }), value)
-    Assert.deepEqual(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should convert number #7', () => {
     const value = 2
     const result = Value.Convert(Type.Boolean({ default: true }), value)
-    Assert.deepEqual(result, 2)
+    Assert.isEqual(result, 2)
   })
   it('Should convert true', () => {
     const value = true
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.deepEqual(result, true)
+    Assert.isEqual(result, true)
   })
   it('Should convert false', () => {
     const value = false
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.deepEqual(result, false)
+    Assert.isEqual(result, false)
   })
   it('Should convert object', () => {
     const value = {}
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.deepEqual(result, {})
+    Assert.isEqual(result, {})
   })
   it('Should convert array', () => {
     const value = [] as any[]
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.deepEqual(result, [])
+    Assert.isEqual(result, [])
   })
 })
diff --git a/test/runtime/value/convert/composite.ts b/test/runtime/value/convert/composite.ts
index a8944d449..5c7678984 100644
--- a/test/runtime/value/convert/composite.ts
+++ b/test/runtime/value/convert/composite.ts
@@ -11,6 +11,6 @@ describe('value/convert/Composite', () => {
       Type.Object({ z: Type.Boolean() })
     ])
     const R = Value.Convert(T, { x: '42', y: 'true', z: 'hello' })
-    Assert.deepEqual(R, { x: 42, y: true, z: 'hello' })
+    Assert.isEqual(R, { x: 42, y: true, z: 'hello' })
   })
 })
diff --git a/test/runtime/value/convert/custom.ts b/test/runtime/value/convert/custom.ts
index 82887cefd..5bc20d59c 100644
--- a/test/runtime/value/convert/custom.ts
+++ b/test/runtime/value/convert/custom.ts
@@ -7,18 +7,18 @@ describe('value/convert/Custom', () => {
     const Custom = TypeSystem.Type('type/convert/Custom/1', () => true)
     const T = Custom()
     const R = Value.Convert(T, true)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not convert 2', () => {
     const Custom = TypeSystem.Type('type/convert/Custom/2', () => true)
     const T = Custom()
     const R = Value.Convert(T, 42)
-    Assert.deepEqual(R, 42)
+    Assert.isEqual(R, 42)
   })
   it('Should not convert 3', () => {
     const Custom = TypeSystem.Type('type/convert/Custom/3', () => true)
     const T = Custom()
     const R = Value.Convert(T, 'hello')
-    Assert.deepEqual(R, 'hello')
+    Assert.isEqual(R, 'hello')
   })
 })
diff --git a/test/runtime/value/convert/date.ts b/test/runtime/value/convert/date.ts
index 27ea49c24..171b5fb4c 100644
--- a/test/runtime/value/convert/date.ts
+++ b/test/runtime/value/convert/date.ts
@@ -5,38 +5,38 @@ import { Assert } from '../../assert/index'
 describe('value/convert/Date', () => {
   it('Should convert from number', () => {
     const result = Value.Convert(Type.Date(), 123) as Date
-    Assert.deepEqual(result.getTime(), 123)
+    Assert.isEqual(result.getTime(), 123)
   })
   it('Should convert from numeric string', () => {
     const result = Value.Convert(Type.Date(), '123') as Date
-    Assert.deepEqual(result.getTime(), 123)
+    Assert.isEqual(result.getTime(), 123)
   })
   it('Should convert from boolean true (interpretted as numeric 1)', () => {
     const result = Value.Convert(Type.Date(), true) as Date
-    Assert.deepEqual(result.getTime(), 1)
+    Assert.isEqual(result.getTime(), 1)
   })
   it('Should convert from datetime string', () => {
     const result = Value.Convert(Type.Date(), '1980-02-03T01:02:03.000Z') as Date
-    Assert.deepEqual(result.toISOString(), '1980-02-03T01:02:03.000Z')
+    Assert.isEqual(result.toISOString(), '1980-02-03T01:02:03.000Z')
   })
   it('Should convert from datetime string without timezone', () => {
     const result = Value.Convert(Type.Date(), '1980-02-03T01:02:03') as Date
-    Assert.deepEqual(result.toISOString(), '1980-02-03T01:02:03.000Z')
+    Assert.isEqual(result.toISOString(), '1980-02-03T01:02:03.000Z')
   })
   it('Should convert from time with timezone', () => {
     const result = Value.Convert(Type.Date(), '01:02:03.000Z') as Date
-    Assert.deepEqual(result.toISOString(), '1970-01-01T01:02:03.000Z')
+    Assert.isEqual(result.toISOString(), '1970-01-01T01:02:03.000Z')
   })
   it('Should convert from time without timezone', () => {
     const result = Value.Convert(Type.Date(), '01:02:03') as Date
-    Assert.deepEqual(result.toISOString(), '1970-01-01T01:02:03.000Z')
+    Assert.isEqual(result.toISOString(), '1970-01-01T01:02:03.000Z')
   })
   it('Should convert from date string', () => {
     const result = Value.Convert(Type.Date(), '1980-02-03') as Date
-    Assert.deepEqual(result.toISOString(), '1980-02-03T00:00:00.000Z')
+    Assert.isEqual(result.toISOString(), '1980-02-03T00:00:00.000Z')
   })
   it('Should convert invalid strings to unix epoch 0', () => {
     const result = Value.Convert(Type.Date(), 'invalid-date') as Date
-    Assert.deepEqual(result, 'invalid-date')
+    Assert.isEqual(result, 'invalid-date')
   })
 })
diff --git a/test/runtime/value/convert/integer.ts b/test/runtime/value/convert/integer.ts
index e2f03c32a..727bddf0c 100644
--- a/test/runtime/value/convert/integer.ts
+++ b/test/runtime/value/convert/integer.ts
@@ -6,27 +6,27 @@ describe('value/convert/Integer', () => {
   it('Should convert from string 1', () => {
     const T = Type.Integer()
     const R = Value.Convert(T, '3.14')
-    Assert.deepEqual(R, 3)
+    Assert.isEqual(R, 3)
   })
   it('Should convert from string 2', () => {
     const T = Type.Integer()
     const R = Value.Convert(T, '42')
-    Assert.deepEqual(R, 42)
+    Assert.isEqual(R, 42)
   })
   it('Should convert from boolean 1', () => {
     const T = Type.Integer()
     const R = Value.Convert(T, true)
-    Assert.deepEqual(R, 1)
+    Assert.isEqual(R, 1)
   })
   it('Should convert from boolean 2', () => {
     const T = Type.Integer()
     const R = Value.Convert(T, false)
-    Assert.deepEqual(R, 0)
+    Assert.isEqual(R, 0)
   })
   it('Should convert from number 1', () => {
     const T = Type.Integer()
     const R = Value.Convert(T, 3.14)
-    Assert.deepEqual(R, 3)
+    Assert.isEqual(R, 3)
   })
   // ----------------------------------------------------------
   // Casts
@@ -34,46 +34,46 @@ describe('value/convert/Integer', () => {
   it('Should convert string #1', () => {
     const value = 'hello'
     const result = Value.Convert(Type.Integer(), value)
-    Assert.deepEqual(result, 'hello')
+    Assert.isEqual(result, 'hello')
   })
   it('Should convert string #2', () => {
     const value = '3.14'
     const result = Value.Convert(Type.Integer(), value)
-    Assert.deepEqual(result, 3)
+    Assert.isEqual(result, 3)
   })
   it('Should convert string #3', () => {
     const value = '-0'
     const result = Value.Convert(Type.Integer(), value)
-    Assert.deepEqual(result, 0)
+    Assert.isEqual(result, 0)
   })
   it('Should convert string #4', () => {
     const value = '-100'
     const result = Value.Convert(Type.Integer(), value)
-    Assert.deepEqual(result, -100)
+    Assert.isEqual(result, -100)
   })
   it('Should convert number', () => {
     const value = 42
     const result = Value.Convert(Type.Integer(), value)
-    Assert.deepEqual(result, 42)
+    Assert.isEqual(result, 42)
   })
   it('Should convert true', () => {
     const value = true
     const result = Value.Convert(Type.Integer(), value)
-    Assert.deepEqual(result, 1)
+    Assert.isEqual(result, 1)
   })
   it('Should convert false', () => {
     const value = false
     const result = Value.Convert(Type.Integer(), value)
-    Assert.deepEqual(result, 0)
+    Assert.isEqual(result, 0)
   })
   it('Should convert object', () => {
     const value = {}
     const result = Value.Convert(Type.Integer(), value)
-    Assert.deepEqual(result, {})
+    Assert.isEqual(result, {})
   })
   it('Should convert array', () => {
     const value = [] as any[]
     const result = Value.Convert(Type.Integer(), value)
-    Assert.deepEqual(result, [])
+    Assert.isEqual(result, [])
   })
 })
diff --git a/test/runtime/value/convert/literal.ts b/test/runtime/value/convert/literal.ts
index 6943c3637..c46ba3dc6 100644
--- a/test/runtime/value/convert/literal.ts
+++ b/test/runtime/value/convert/literal.ts
@@ -6,80 +6,80 @@ describe('value/convert/Literal:String', () => {
   it('Should convert from number 1', () => {
     const T = Type.Literal('1')
     const R = Value.Convert(T, 1)
-    Assert.deepEqual(R, '1')
+    Assert.isEqual(R, '1')
   })
   it('Should convert from number 2', () => {
     const T = Type.Literal('1')
     const R = Value.Convert(T, 2)
-    Assert.deepEqual(R, 2)
+    Assert.isEqual(R, 2)
   })
   it('Should convert from boolean', () => {
     const T = Type.Literal('true')
     const R = Value.Convert(T, true)
-    Assert.deepEqual(R, 'true')
+    Assert.isEqual(R, 'true')
   })
 })
 describe('value/convert/Literal:Number', () => {
   it('Should convert from number 1', () => {
     const T = Type.Literal(3.14)
     const R = Value.Convert(T, '3.14')
-    Assert.deepEqual(R, 3.14)
+    Assert.isEqual(R, 3.14)
   })
   it('Should convert from number 2', () => {
     const T = Type.Literal(3.14)
     const R = Value.Convert(T, '3.15')
-    Assert.deepEqual(R, '3.15')
+    Assert.isEqual(R, '3.15')
   })
   it('Should convert from boolean 1', () => {
     const T = Type.Literal(1)
     const R = Value.Convert(T, true)
-    Assert.deepEqual(R, 1)
+    Assert.isEqual(R, 1)
   })
   it('Should convert from boolean 2', () => {
     const T = Type.Literal(0)
     const R = Value.Convert(T, false)
-    Assert.deepEqual(R, 0)
+    Assert.isEqual(R, 0)
   })
   it('Should convert from boolean 3', () => {
     const T = Type.Literal(2)
     const R = Value.Convert(T, true)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
 })
 describe('value/convert/Literal:Boolean', () => {
   it('Should convert from number 1', () => {
     const T = Type.Literal(true)
     const R = Value.Convert(T, 3.14)
-    Assert.deepEqual(R, 3.14)
+    Assert.isEqual(R, 3.14)
   })
   it('Should convert from number 2', () => {
     const T = Type.Literal(true)
     const R = Value.Convert(T, 1)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should convert from string 1', () => {
     const T = Type.Literal(true)
     const R = Value.Convert(T, 'true')
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should convert from string 2', () => {
     const T = Type.Literal(false)
     const R = Value.Convert(T, 'false')
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should convert from string 3', () => {
     const T = Type.Literal(true)
     const R = Value.Convert(T, '1')
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should convert from string 4', () => {
     const T = Type.Literal(false)
     const R = Value.Convert(T, '0')
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should convert from string 5', () => {
     const T = Type.Literal(false)
     const R = Value.Convert(T, '2')
-    Assert.deepEqual(R, '2')
+    Assert.isEqual(R, '2')
   })
 })
diff --git a/test/runtime/value/convert/never.ts b/test/runtime/value/convert/never.ts
index eb481d593..5f6d0c4a6 100644
--- a/test/runtime/value/convert/never.ts
+++ b/test/runtime/value/convert/never.ts
@@ -6,16 +6,16 @@ describe('value/convert/Never', () => {
   it('Should not convert 1', () => {
     const T = Type.Never()
     const R = Value.Convert(T, true)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not convert 2', () => {
     const T = Type.Never()
     const R = Value.Convert(T, 42)
-    Assert.deepEqual(R, 42)
+    Assert.isEqual(R, 42)
   })
   it('Should not convert 3', () => {
     const T = Type.Never()
     const R = Value.Convert(T, 'true')
-    Assert.deepEqual(R, 'true')
+    Assert.isEqual(R, 'true')
   })
 })
diff --git a/test/runtime/value/convert/null.ts b/test/runtime/value/convert/null.ts
index bda1930a8..12d5ab1ee 100644
--- a/test/runtime/value/convert/null.ts
+++ b/test/runtime/value/convert/null.ts
@@ -6,14 +6,14 @@ describe('value/convert/Null', () => {
   const T = Type.Null()
   it('Should convert from string 1', () => {
     const R = Value.Convert(T, 'null')
-    Assert.deepEqual(R, null)
+    Assert.isEqual(R, null)
   })
   it('Should convert from string 2', () => {
     const R = Value.Convert(T, 'NULL')
-    Assert.deepEqual(R, null)
+    Assert.isEqual(R, null)
   })
   it('Should convert from string 3', () => {
     const R = Value.Convert(T, 'nil')
-    Assert.deepEqual(R, 'nil')
+    Assert.isEqual(R, 'nil')
   })
 })
diff --git a/test/runtime/value/convert/number.ts b/test/runtime/value/convert/number.ts
index 3b5029c8c..05636653c 100644
--- a/test/runtime/value/convert/number.ts
+++ b/test/runtime/value/convert/number.ts
@@ -6,23 +6,23 @@ describe('value/convert/Number', () => {
   const T = Type.Number()
   it('Should convert from string 1', () => {
     const R = Value.Convert(T, '3.14')
-    Assert.deepEqual(R, 3.14)
+    Assert.isEqual(R, 3.14)
   })
   it('Should convert from string 2', () => {
     const R = Value.Convert(T, '42')
-    Assert.deepEqual(R, 42)
+    Assert.isEqual(R, 42)
   })
   it('Should convert from boolean 1', () => {
     const R = Value.Convert(T, true)
-    Assert.deepEqual(R, 1)
+    Assert.isEqual(R, 1)
   })
   it('Should convert from boolean 2', () => {
     const R = Value.Convert(T, false)
-    Assert.deepEqual(R, 0)
+    Assert.isEqual(R, 0)
   })
   it('Should convert from number 1', () => {
     const R = Value.Convert(T, 3.14)
-    Assert.deepEqual(R, 3.14)
+    Assert.isEqual(R, 3.14)
   })
 
   // ----------------------------------------------------------
@@ -31,46 +31,46 @@ describe('value/convert/Number', () => {
   it('Should convert string #1', () => {
     const value = 'hello'
     const result = Value.Convert(Type.Number(), value)
-    Assert.deepEqual(result, 'hello')
+    Assert.isEqual(result, 'hello')
   })
   it('Should convert string #2', () => {
     const value = '3.14'
     const result = Value.Convert(Type.Number(), value)
-    Assert.deepEqual(result, 3.14)
+    Assert.isEqual(result, 3.14)
   })
   it('Should convert string #3', () => {
     const value = '-0'
     const result = Value.Convert(Type.Number(), value)
-    Assert.deepEqual(result, 0)
+    Assert.isEqual(result, 0)
   })
   it('Should convert string #4', () => {
     const value = '-100'
     const result = Value.Convert(Type.Number(), value)
-    Assert.deepEqual(result, -100)
+    Assert.isEqual(result, -100)
   })
   it('Should convert number', () => {
     const value = 42
     const result = Value.Convert(Type.Number(), value)
-    Assert.deepEqual(result, 42)
+    Assert.isEqual(result, 42)
   })
   it('Should convert true', () => {
     const value = true
     const result = Value.Convert(Type.Number(), value)
-    Assert.deepEqual(result, 1)
+    Assert.isEqual(result, 1)
   })
   it('Should convert false', () => {
     const value = false
     const result = Value.Convert(Type.Number(), value)
-    Assert.deepEqual(result, 0)
+    Assert.isEqual(result, 0)
   })
   it('Should convert object', () => {
     const value = {}
     const result = Value.Convert(Type.String(), value)
-    Assert.deepEqual(result, {})
+    Assert.isEqual(result, {})
   })
   it('Should convert array', () => {
     const value = [] as any[]
     const result = Value.Convert(Type.String(), value)
-    Assert.deepEqual(result, [])
+    Assert.isEqual(result, [])
   })
 })
diff --git a/test/runtime/value/convert/object.ts b/test/runtime/value/convert/object.ts
index 2c85d60f2..27dd6e824 100644
--- a/test/runtime/value/convert/object.ts
+++ b/test/runtime/value/convert/object.ts
@@ -11,6 +11,6 @@ describe('value/convert/Object', () => {
       z: Type.Boolean()
     })
     const R = Value.Convert(T, { x: '42', y: 'true', z: 'hello' })
-    Assert.deepEqual(R, { x: 42, y: true, z: 'hello' })
+    Assert.isEqual(R, { x: 42, y: true, z: 'hello' })
   })
 })
diff --git a/test/runtime/value/convert/record.ts b/test/runtime/value/convert/record.ts
index 641476f17..e773e8f25 100644
--- a/test/runtime/value/convert/record.ts
+++ b/test/runtime/value/convert/record.ts
@@ -6,6 +6,6 @@ describe('value/convert/Record', () => {
   it('Should convert record value to numeric', () => {
     const T = Type.Record(Type.String(), Type.Number())
     const V = Value.Convert(T, { x: '42', y: '24', z: 'hello' })
-    Assert.deepEqual(V, { x: 42, y: '24', z: 'hello' })
+    Assert.isEqual(V, { x: 42, y: '24', z: 'hello' })
   })
 })
diff --git a/test/runtime/value/convert/string.ts b/test/runtime/value/convert/string.ts
index b20c3ccf7..3580bbda7 100644
--- a/test/runtime/value/convert/string.ts
+++ b/test/runtime/value/convert/string.ts
@@ -6,27 +6,27 @@ describe('value/convert/String', () => {
   const T = Type.String()
   it('Should convert from number 1', () => {
     const R = Value.Convert(T, 3.14)
-    Assert.deepEqual(R, '3.14')
+    Assert.isEqual(R, '3.14')
   })
   it('Should convert from number 2', () => {
     const R = Value.Convert(T, 3)
-    Assert.deepEqual(R, '3')
+    Assert.isEqual(R, '3')
   })
   it('Should convert from boolean 1', () => {
     const R = Value.Convert(T, true)
-    Assert.deepEqual(R, 'true')
+    Assert.isEqual(R, 'true')
   })
   it('Should convert from boolean 2', () => {
     const R = Value.Convert(T, false)
-    Assert.deepEqual(R, 'false')
+    Assert.isEqual(R, 'false')
   })
   it('Should convert from bigint', () => {
     const R = Value.Convert(T, BigInt(12345))
-    Assert.deepEqual(R, '12345')
+    Assert.isEqual(R, '12345')
   })
   it('Should convert from symbol', () => {
     const R = Value.Convert(T, Symbol(12345))
-    Assert.deepEqual(R, '12345')
+    Assert.isEqual(R, '12345')
   })
   // ----------------------------------------------------------
   // Casts
@@ -34,36 +34,36 @@ describe('value/convert/String', () => {
   it('Should convert string', () => {
     const value = 'hello'
     const result = Value.Convert(Type.String(), value)
-    Assert.deepEqual(result, 'hello')
+    Assert.isEqual(result, 'hello')
   })
   it('Should convert number #1', () => {
     const value = 42
     const result = Value.Convert(Type.String(), value)
-    Assert.deepEqual(result, '42')
+    Assert.isEqual(result, '42')
   })
   it('Should convert number #2', () => {
     const value = 42n
     const result = Value.Convert(Type.String(), value)
-    Assert.deepEqual(result, '42')
+    Assert.isEqual(result, '42')
   })
   it('Should convert true', () => {
     const value = true
     const result = Value.Convert(Type.String(), value)
-    Assert.deepEqual(result, 'true')
+    Assert.isEqual(result, 'true')
   })
   it('Should convert false', () => {
     const value = false
     const result = Value.Convert(Type.String(), value)
-    Assert.deepEqual(result, 'false')
+    Assert.isEqual(result, 'false')
   })
   it('Should convert object', () => {
     const value = {}
     const result = Value.Convert(Type.String(), value)
-    Assert.deepEqual(result, {})
+    Assert.isEqual(result, {})
   })
   it('Should convert array', () => {
     const value = [] as any[]
     const result = Value.Convert(Type.String(), value)
-    Assert.deepEqual(result, [])
+    Assert.isEqual(result, [])
   })
 })
diff --git a/test/runtime/value/convert/symbol.ts b/test/runtime/value/convert/symbol.ts
index fe2a158e3..096b9c3cd 100644
--- a/test/runtime/value/convert/symbol.ts
+++ b/test/runtime/value/convert/symbol.ts
@@ -6,10 +6,10 @@ describe('value/convert/Symbol', () => {
   const T = Type.Symbol()
   it('Should convert from number 1', () => {
     const R = Value.Convert(T, 3.14)
-    Assert.deepEqual(R, '3.14')
+    Assert.isEqual(R, '3.14')
   })
   it('Should convert from number 2', () => {
     const R = Value.Convert(T, 3)
-    Assert.deepEqual(R, '3')
+    Assert.isEqual(R, '3')
   })
 })
diff --git a/test/runtime/value/convert/tuple.ts b/test/runtime/value/convert/tuple.ts
index eafc01c42..6047f3fc1 100644
--- a/test/runtime/value/convert/tuple.ts
+++ b/test/runtime/value/convert/tuple.ts
@@ -6,16 +6,16 @@ describe('value/convert/Tuple', () => {
   it('Should convert from Array 1', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
     const R = Value.Convert(T, ['1', 'true'])
-    Assert.deepEqual(R, [1, true])
+    Assert.isEqual(R, [1, true])
   })
   it('Should convert from Array 2', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
     const R = Value.Convert(T, ['1'])
-    Assert.deepEqual(R, [1])
+    Assert.isEqual(R, [1])
   })
   it('Should convert from Array 3', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
     const R = Value.Convert(T, ['1', '2', '3'])
-    Assert.deepEqual(R, [1, 2, '3'])
+    Assert.isEqual(R, [1, 2, '3'])
   })
 })
diff --git a/test/runtime/value/convert/undefined.ts b/test/runtime/value/convert/undefined.ts
index 130f4177e..90e9201a1 100644
--- a/test/runtime/value/convert/undefined.ts
+++ b/test/runtime/value/convert/undefined.ts
@@ -6,10 +6,10 @@ describe('value/convert/Undefined', () => {
   const T = Type.Undefined()
   it('Should convert from string 1', () => {
     const R = Value.Convert(T, 'undefined')
-    Assert.deepEqual(R, undefined)
+    Assert.isEqual(R, undefined)
   })
   it('Should convert from string 2', () => {
     const R = Value.Convert(T, 'hello')
-    Assert.deepEqual(R, 'hello')
+    Assert.isEqual(R, 'hello')
   })
 })
diff --git a/test/runtime/value/convert/union.ts b/test/runtime/value/convert/union.ts
index 7fd75a17a..96c79b4dd 100644
--- a/test/runtime/value/convert/union.ts
+++ b/test/runtime/value/convert/union.ts
@@ -10,15 +10,15 @@ describe('value/convert/Union', () => {
     const V1 = Value.Convert(T, { x: '42' })
     const V2 = Value.Convert(T, { x: 'null' })
     const V3 = Value.Convert(T, { x: 'hello' })
-    Assert.deepEqual(V1, { x: 42 })
-    Assert.deepEqual(V2, { x: null })
-    Assert.deepEqual(V3, { x: 'hello' })
+    Assert.isEqual(V1, { x: 42 })
+    Assert.isEqual(V2, { x: null })
+    Assert.isEqual(V3, { x: 'hello' })
   })
   it('Should convert first variant in ambiguous conversion', () => {
     const T = Type.Object({
       x: Type.Union([Type.Boolean(), Type.Number()]),
     })
     const V1 = Value.Convert(T, { x: '1' })
-    Assert.deepEqual(V1, { x: true })
+    Assert.isEqual(V1, { x: true })
   })
 })
diff --git a/test/runtime/value/convert/unknown.ts b/test/runtime/value/convert/unknown.ts
index 0b8cea1f9..7f43ce7f5 100644
--- a/test/runtime/value/convert/unknown.ts
+++ b/test/runtime/value/convert/unknown.ts
@@ -7,36 +7,36 @@ describe('value/convert/Unknown', () => {
   it('Should convert null', () => {
     const V = null
     const R = Value.Convert(T, V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
   it('Should convert undefined', () => {
     const V = undefined
     const R = Value.Convert(T, V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
   it('Should convert string', () => {
     const V = 'hello'
     const R = Value.Convert(T, V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
   it('Should convert number', () => {
     const V = 42
     const R = Value.Convert(T, V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
   it('Should convert boolean', () => {
     const V = true
     const R = Value.Convert(T, V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
   it('Should convert object', () => {
     const V = { x: 1 }
     const R = Value.Convert(T, V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
   it('Should convert array', () => {
     const V = [1, 2, 3]
     const R = Value.Convert(T, V)
-    Assert.deepEqual(R, V)
+    Assert.isEqual(R, V)
   })
 })
diff --git a/test/runtime/value/create/any.ts b/test/runtime/value/create/any.ts
index bbd59d47d..3dc08a4af 100644
--- a/test/runtime/value/create/any.ts
+++ b/test/runtime/value/create/any.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/Any', () => {
   it('Should create value', () => {
     const T = Type.Any()
-    Assert.deepEqual(Value.Create(T), {})
+    Assert.isEqual(Value.Create(T), {})
   })
   it('Should create default', () => {
     const T = Type.Any({ default: 1 })
-    Assert.deepEqual(Value.Create(T), 1)
+    Assert.isEqual(Value.Create(T), 1)
   })
 })
diff --git a/test/runtime/value/create/array.ts b/test/runtime/value/create/array.ts
index 1d97755a1..e61a1a4f3 100644
--- a/test/runtime/value/create/array.ts
+++ b/test/runtime/value/create/array.ts
@@ -5,14 +5,14 @@ import { Assert } from '../../assert/index'
 describe('value/create/Any', () => {
   it('Should create value', () => {
     const T = Type.Array(Type.String())
-    Assert.deepEqual(Value.Create(T), [])
+    Assert.isEqual(Value.Create(T), [])
   })
   it('Should create default', () => {
     const T = Type.Array(Type.String(), { default: ['1'] })
-    Assert.deepEqual(Value.Create(T), ['1'])
+    Assert.isEqual(Value.Create(T), ['1'])
   })
   it('Should create with minItems', () => {
     const T = Type.Array(Type.String(), { minItems: 4 })
-    Assert.deepEqual(Value.Create(T), ['', '', '', ''])
+    Assert.isEqual(Value.Create(T), ['', '', '', ''])
   })
 })
diff --git a/test/runtime/value/create/bigint.ts b/test/runtime/value/create/bigint.ts
index 616058107..2409d73ec 100644
--- a/test/runtime/value/create/bigint.ts
+++ b/test/runtime/value/create/bigint.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/BigInt', () => {
   it('Should create value', () => {
     const T = Type.BigInt()
-    Assert.deepEqual(Value.Create(T), BigInt(0))
+    Assert.isEqual(Value.Create(T), BigInt(0))
   })
   it('Should create default', () => {
     const T = Type.BigInt({ default: true })
-    Assert.deepEqual(Value.Create(T), true)
+    Assert.isEqual(Value.Create(T), true)
   })
 })
diff --git a/test/runtime/value/create/boolean.ts b/test/runtime/value/create/boolean.ts
index 9315f20b6..853dd9ac4 100644
--- a/test/runtime/value/create/boolean.ts
+++ b/test/runtime/value/create/boolean.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/Boolean', () => {
   it('Should create value', () => {
     const T = Type.Boolean()
-    Assert.deepEqual(Value.Create(T), false)
+    Assert.isEqual(Value.Create(T), false)
   })
   it('Should create default', () => {
     const T = Type.Boolean({ default: true })
-    Assert.deepEqual(Value.Create(T), true)
+    Assert.isEqual(Value.Create(T), true)
   })
 })
diff --git a/test/runtime/value/create/composite.ts b/test/runtime/value/create/composite.ts
index 96995304a..40421aa6e 100644
--- a/test/runtime/value/create/composite.ts
+++ b/test/runtime/value/create/composite.ts
@@ -15,7 +15,7 @@ describe('value/create/Composite', () => {
       c: Type.Number(),
     })
     const T = Type.Composite([A, B])
-    Assert.deepEqual(Value.Create(T), {
+    Assert.isEqual(Value.Create(T), {
       x: 0,
       y: 0,
       z: 0,
@@ -36,7 +36,7 @@ describe('value/create/Composite', () => {
       c: Type.Number({ default: 6 }),
     })
     const T = Type.Composite([A, B])
-    Assert.deepEqual(Value.Create(T), {
+    Assert.isEqual(Value.Create(T), {
       x: 1,
       y: 2,
       z: 3,
@@ -57,7 +57,7 @@ describe('value/create/Composite', () => {
       c: Type.Optional(Type.Number()),
     })
     const T = Type.Composite([A, B])
-    Assert.deepEqual(Value.Create(T), {
+    Assert.isEqual(Value.Create(T), {
       x: 0,
       y: 0,
       z: 0,
diff --git a/test/runtime/value/create/constructor.ts b/test/runtime/value/create/constructor.ts
index b4c9b7701..7bf4d7777 100644
--- a/test/runtime/value/create/constructor.ts
+++ b/test/runtime/value/create/constructor.ts
@@ -13,7 +13,7 @@ describe('value/create/Constructor', () => {
     const C = Value.Create(T)
     const I = new C()
     const R = I.test()
-    Assert.deepEqual(R, 123)
+    Assert.isEqual(R, 123)
   })
 
   it('Should create default', () => {
@@ -33,6 +33,6 @@ describe('value/create/Constructor', () => {
     const C = Value.Create(T)
     const I = new C()
     const R = I.test()
-    Assert.deepEqual(R, 321)
+    Assert.isEqual(R, 321)
   })
 })
diff --git a/test/runtime/value/create/custom.ts b/test/runtime/value/create/custom.ts
index 1a3ca5424..3c03cb110 100644
--- a/test/runtime/value/create/custom.ts
+++ b/test/runtime/value/create/custom.ts
@@ -6,7 +6,7 @@ describe('value/create/Custom', () => {
   it('Should create custom value with default', () => {
     TypeRegistry.Set('CustomCreate1', () => true)
     const T = Type.Unsafe({ [Kind]: 'CustomCreate1', default: 'hello' })
-    Assert.deepEqual(Value.Create(T), 'hello')
+    Assert.isEqual(Value.Create(T), 'hello')
   })
 
   it('Should throw when no default value is specified', () => {
diff --git a/test/runtime/value/create/enum.ts b/test/runtime/value/create/enum.ts
index b6dcb55ca..6a2cf1aa6 100644
--- a/test/runtime/value/create/enum.ts
+++ b/test/runtime/value/create/enum.ts
@@ -9,7 +9,7 @@ describe('value/create/Boolean', () => {
       B,
     }
     const T = Type.Enum(Foo)
-    Assert.deepEqual(Value.Create(T), Foo.A)
+    Assert.isEqual(Value.Create(T), Foo.A)
   })
   it('Should create default', () => {
     enum Foo {
@@ -17,6 +17,6 @@ describe('value/create/Boolean', () => {
       B,
     }
     const T = Type.Enum(Foo, { default: Foo.B })
-    Assert.deepEqual(Value.Create(T), Foo.B)
+    Assert.isEqual(Value.Create(T), Foo.B)
   })
 })
diff --git a/test/runtime/value/create/function.ts b/test/runtime/value/create/function.ts
index 6315bd203..e69514260 100644
--- a/test/runtime/value/create/function.ts
+++ b/test/runtime/value/create/function.ts
@@ -7,13 +7,13 @@ describe('value/create/Function', () => {
     const T = Type.Function([], Type.Number({ default: 123 }))
     const F = Value.Create(T)
     const R = F()
-    Assert.deepEqual(R, 123)
+    Assert.isEqual(R, 123)
   })
 
   it('Should create default', () => {
     const T = Type.Function([], Type.Number({ default: 123 }), { default: () => 321 })
     const F = Value.Create(T)
     const R = F()
-    Assert.deepEqual(R, 321)
+    Assert.isEqual(R, 321)
   })
 })
diff --git a/test/runtime/value/create/integer.ts b/test/runtime/value/create/integer.ts
index 3643a1f54..8354172a0 100644
--- a/test/runtime/value/create/integer.ts
+++ b/test/runtime/value/create/integer.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/Integer', () => {
   it('Should create value', () => {
     const T = Type.Integer()
-    Assert.deepEqual(Value.Create(T), 0)
+    Assert.isEqual(Value.Create(T), 0)
   })
   it('Should create default', () => {
     const T = Type.Integer({ default: 7 })
-    Assert.deepEqual(Value.Create(T), 7)
+    Assert.isEqual(Value.Create(T), 7)
   })
 })
diff --git a/test/runtime/value/create/intersect.ts b/test/runtime/value/create/intersect.ts
index f007480ae..195f2364d 100644
--- a/test/runtime/value/create/intersect.ts
+++ b/test/runtime/value/create/intersect.ts
@@ -7,22 +7,22 @@ describe('value/create/Intersect', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
     const R = Value.Create(T)
 
-    Assert.deepEqual(R, { x: 0, y: 0 })
+    Assert.isEqual(R, { x: 0, y: 0 })
   })
   it('Should create value with default', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Number({ default: 100 }) }), Type.Object({ y: Type.Number({ default: 200 }) })])
     const R = Value.Create(T)
-    Assert.deepEqual(R, { x: 100, y: 200 })
+    Assert.isEqual(R, { x: 100, y: 200 })
   })
   it('Should create for overlapping intersection', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.Number(), y: Type.Number() })])
     const R = Value.Create(T)
-    Assert.deepEqual(R, { x: 0, y: 0 })
+    Assert.isEqual(R, { x: 0, y: 0 })
   })
   it('Should create with last intersected overlapping default', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Number({ default: 1 }) }), Type.Object({ x: Type.Number({ default: 2 }), y: Type.Number() })])
     const R = Value.Create(T)
-    Assert.deepEqual(R, { x: 2, y: 0 })
+    Assert.isEqual(R, { x: 2, y: 0 })
   })
   it('Should throw for non-constructable intersection 1', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.String() })])
@@ -35,7 +35,7 @@ describe('value/create/Intersect', () => {
   it('Should not throw for non-constructable intersection with default', () => {
     const T = Type.Intersect([Type.String(), Type.Number()], { default: 'hello' })
     const R = Value.Create(T)
-    Assert.deepEqual(R, 'hello')
+    Assert.isEqual(R, 'hello')
   })
   it('Should create from nested intersection', () => {
     const T = Type.Intersect([
@@ -52,11 +52,11 @@ describe('value/create/Intersect', () => {
       ]),
     ])
     const R = Value.Create(T)
-    Assert.deepEqual(R, { x: 1, y: 2, z: 3 })
+    Assert.isEqual(R, { x: 1, y: 2, z: 3 })
   })
   it('Should create non varying primitive', () => {
     const T = Type.Intersect([Type.Number(), Type.Number(), Type.Number()])
     const R = Value.Create(T)
-    Assert.deepEqual(R, 0)
+    Assert.isEqual(R, 0)
   })
 })
diff --git a/test/runtime/value/create/keyof.ts b/test/runtime/value/create/keyof.ts
index 6b498bb15..4f8aca015 100644
--- a/test/runtime/value/create/keyof.ts
+++ b/test/runtime/value/create/keyof.ts
@@ -10,7 +10,7 @@ describe('value/create/KeyOf', () => {
         y: Type.Number(),
       }),
     )
-    Assert.deepEqual(Value.Create(T), 'x')
+    Assert.isEqual(Value.Create(T), 'x')
   })
   it('Should create default', () => {
     const T = Type.KeyOf(
@@ -20,6 +20,6 @@ describe('value/create/KeyOf', () => {
       }),
       { default: 'y' },
     )
-    Assert.deepEqual(Value.Create(T), 'y')
+    Assert.isEqual(Value.Create(T), 'y')
   })
 })
diff --git a/test/runtime/value/create/literal.ts b/test/runtime/value/create/literal.ts
index d2913ab7f..8bdb7db2c 100644
--- a/test/runtime/value/create/literal.ts
+++ b/test/runtime/value/create/literal.ts
@@ -5,18 +5,18 @@ import { Assert } from '../../assert/index'
 describe('value/create/Literal', () => {
   it('Should create literal string', () => {
     const T = Type.Literal('hello')
-    Assert.deepEqual(Value.Create(T), 'hello')
+    Assert.isEqual(Value.Create(T), 'hello')
   })
   it('Should create literal number', () => {
     const T = Type.Literal(1)
-    Assert.deepEqual(Value.Create(T), 1)
+    Assert.isEqual(Value.Create(T), 1)
   })
   it('Should create literal boolean', () => {
     const T = Type.Literal(true)
-    Assert.deepEqual(Value.Create(T), true)
+    Assert.isEqual(Value.Create(T), true)
   })
   it('Should create literal from default value', () => {
     const T = Type.Literal(true, { default: 'hello' })
-    Assert.deepEqual(Value.Create(T), 'hello')
+    Assert.isEqual(Value.Create(T), 'hello')
   })
 })
diff --git a/test/runtime/value/create/not.ts b/test/runtime/value/create/not.ts
index 132d4eb9e..433e8552f 100644
--- a/test/runtime/value/create/not.ts
+++ b/test/runtime/value/create/not.ts
@@ -6,16 +6,16 @@ describe('value/create/Not', () => {
   it('Should create value', () => {
     const T = Type.Not(Type.String(), Type.Number())
     const R = Value.Create(T)
-    Assert.equal(R, 0)
+    Assert.isEqual(R, 0)
   })
   it('Should create value with default inner', () => {
     const T = Type.Not(Type.String(), Type.Number({ default: 100 }))
     const R = Value.Create(T)
-    Assert.equal(R, 100)
+    Assert.isEqual(R, 100)
   })
   it('Should create value with default outer', () => {
     const T = Type.Not(Type.String(), Type.Number(), { default: 100 })
     const R = Value.Create(T)
-    Assert.equal(R, 100)
+    Assert.isEqual(R, 100)
   })
 })
diff --git a/test/runtime/value/create/null.ts b/test/runtime/value/create/null.ts
index 45c42fc86..3fc129a50 100644
--- a/test/runtime/value/create/null.ts
+++ b/test/runtime/value/create/null.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/Null', () => {
   it('Should create value', () => {
     const T = Type.Null()
-    Assert.deepEqual(Value.Create(T), null)
+    Assert.isEqual(Value.Create(T), null)
   })
   it('Should create null from default value', () => {
     const T = Type.Null({ default: 'hello' })
-    Assert.deepEqual(Value.Create(T), 'hello')
+    Assert.isEqual(Value.Create(T), 'hello')
   })
 })
diff --git a/test/runtime/value/create/number.ts b/test/runtime/value/create/number.ts
index 7be03f37d..db68e95a5 100644
--- a/test/runtime/value/create/number.ts
+++ b/test/runtime/value/create/number.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/Number', () => {
   it('Should create value', () => {
     const T = Type.Number()
-    Assert.deepEqual(Value.Create(T), 0)
+    Assert.isEqual(Value.Create(T), 0)
   })
   it('Should create default', () => {
     const T = Type.Number({ default: 7 })
-    Assert.deepEqual(Value.Create(T), 7)
+    Assert.isEqual(Value.Create(T), 7)
   })
 })
diff --git a/test/runtime/value/create/object.ts b/test/runtime/value/create/object.ts
index 50b41ee3b..8f0ff10b4 100644
--- a/test/runtime/value/create/object.ts
+++ b/test/runtime/value/create/object.ts
@@ -9,7 +9,7 @@ describe('value/create/Object', () => {
       y: Type.Number(),
       z: Type.Number(),
     })
-    Assert.deepEqual(Value.Create(T), {
+    Assert.isEqual(Value.Create(T), {
       x: 0,
       y: 0,
       z: 0,
@@ -22,7 +22,7 @@ describe('value/create/Object', () => {
       y: Type.Optional(Type.Number()),
       z: Type.Optional(Type.Number()),
     })
-    Assert.deepEqual(Value.Create(T), {})
+    Assert.isEqual(Value.Create(T), {})
   })
 
   it('Should create default with default properties', () => {
@@ -31,7 +31,7 @@ describe('value/create/Object', () => {
       y: Type.Number({ default: 2 }),
       z: Type.Number({ default: 3 }),
     })
-    Assert.deepEqual(Value.Create(T), {
+    Assert.isEqual(Value.Create(T), {
       x: 1,
       y: 2,
       z: 3,
@@ -49,7 +49,7 @@ describe('value/create/Object', () => {
         z: Type.Number(),
       }),
     })
-    Assert.deepEqual(Value.Create(T), {
+    Assert.isEqual(Value.Create(T), {
       x: 0,
       y: 0,
       z: 0,
@@ -66,7 +66,7 @@ describe('value/create/Object', () => {
       },
       { default: { x: 1, y: 2, z: 3 } },
     )
-    Assert.deepEqual(Value.Create(T), {
+    Assert.isEqual(Value.Create(T), {
       x: 1,
       y: 2,
       z: 3,
diff --git a/test/runtime/value/create/record.ts b/test/runtime/value/create/record.ts
index c19d8555f..05ebfd482 100644
--- a/test/runtime/value/create/record.ts
+++ b/test/runtime/value/create/record.ts
@@ -5,7 +5,7 @@ import { Assert } from '../../assert/index'
 describe('value/create/Record', () => {
   it('Should create value', () => {
     const T = Type.Record(Type.String(), Type.Object({}))
-    Assert.deepEqual(Value.Create(T), {})
+    Assert.isEqual(Value.Create(T), {})
   })
   it('Should create default', () => {
     const T = Type.Record(Type.String(), Type.Object({}), {
@@ -13,6 +13,6 @@ describe('value/create/Record', () => {
         x: {},
       },
     })
-    Assert.deepEqual(Value.Create(T), { x: {} })
+    Assert.isEqual(Value.Create(T), { x: {} })
   })
 })
diff --git a/test/runtime/value/create/recursive.ts b/test/runtime/value/create/recursive.ts
index 7f69c6b56..b12dd0b0c 100644
--- a/test/runtime/value/create/recursive.ts
+++ b/test/runtime/value/create/recursive.ts
@@ -10,7 +10,7 @@ describe('value/create/Recursive', () => {
         nodes: Type.Array(This),
       }),
     )
-    Assert.deepEqual(Value.Create(T), {
+    Assert.isEqual(Value.Create(T), {
       id: '',
       nodes: [],
     })
@@ -25,6 +25,6 @@ describe('value/create/Recursive', () => {
         }),
       { default: 7 },
     )
-    Assert.deepEqual(Value.Create(T), 7)
+    Assert.isEqual(Value.Create(T), 7)
   })
 })
diff --git a/test/runtime/value/create/ref.ts b/test/runtime/value/create/ref.ts
index 621236c98..16c7e4abd 100644
--- a/test/runtime/value/create/ref.ts
+++ b/test/runtime/value/create/ref.ts
@@ -25,6 +25,6 @@ describe('value/create/Ref', () => {
       { $id: 'T', default: 'target' },
     )
     const R = Type.Ref(T, { default: 'override' })
-    Assert.deepEqual(Value.Create(R), 'override') // terminated at R default value
+    Assert.isEqual(Value.Create(R), 'override') // terminated at R default value
   })
 })
diff --git a/test/runtime/value/create/regex.ts b/test/runtime/value/create/regex.ts
index 78d535a2d..8afa9fb8e 100644
--- a/test/runtime/value/create/regex.ts
+++ b/test/runtime/value/create/regex.ts
@@ -11,6 +11,6 @@ describe('value/create/RegEx', () => {
   })
   it('Should create default', () => {
     const T = Type.RegEx(/foo/, { default: 'foo' })
-    Assert.deepEqual(Value.Create(T), 'foo')
+    Assert.isEqual(Value.Create(T), 'foo')
   })
 })
diff --git a/test/runtime/value/create/string.ts b/test/runtime/value/create/string.ts
index d5a7bcd77..41a0035ef 100644
--- a/test/runtime/value/create/string.ts
+++ b/test/runtime/value/create/string.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/String', () => {
   it('Should create value', () => {
     const T = Type.String()
-    Assert.deepEqual(Value.Create(T), 0)
+    Assert.isEqual(Value.Create(T), 0)
   })
   it('Should create default', () => {
     const T = Type.String({ default: 'hello' })
-    Assert.deepEqual(Value.Create(T), 'hello')
+    Assert.isEqual(Value.Create(T), 'hello')
   })
 })
diff --git a/test/runtime/value/create/symbol.ts b/test/runtime/value/create/symbol.ts
index da3ba1c3a..2c78809c2 100644
--- a/test/runtime/value/create/symbol.ts
+++ b/test/runtime/value/create/symbol.ts
@@ -6,10 +6,10 @@ describe('value/create/Symbol', () => {
   it('Should create value', () => {
     const T = Type.Symbol()
     const V = Value.Create(T)
-    Assert.deepEqual(typeof V, 'symbol')
+    Assert.isEqual(typeof V, 'symbol')
   })
   it('Should create default', () => {
     const T = Type.Symbol({ default: true })
-    Assert.deepEqual(Value.Create(T), true)
+    Assert.isEqual(Value.Create(T), true)
   })
 })
diff --git a/test/runtime/value/create/template-literal.ts b/test/runtime/value/create/template-literal.ts
index 4659b77f8..7103f1272 100644
--- a/test/runtime/value/create/template-literal.ts
+++ b/test/runtime/value/create/template-literal.ts
@@ -6,22 +6,22 @@ describe('value/create/TemplateLiteral', () => {
   it('Should create pattern 1', () => {
     const T = Type.TemplateLiteral([Type.Literal('A')])
     const V = Value.Create(T)
-    Assert.deepEqual(V, 'A')
+    Assert.isEqual(V, 'A')
   })
   it('Should create pattern 2', () => {
     const T = Type.TemplateLiteral([Type.Literal('A'), Type.Literal('B')])
     const V = Value.Create(T)
-    Assert.deepEqual(V, 'AB')
+    Assert.isEqual(V, 'AB')
   })
   it('Should create pattern 3 (first only)', () => {
     const T = Type.TemplateLiteral([Type.Literal('A'), Type.Union([Type.Literal('B'), Type.Literal('C')])])
     const V = Value.Create(T)
-    Assert.deepEqual(V, 'AB')
+    Assert.isEqual(V, 'AB')
   })
   it('Should create pattern 4 (first only)', () => {
     const T = Type.TemplateLiteral([Type.Boolean()])
     const V = Value.Create(T)
-    Assert.deepEqual(V, 'true')
+    Assert.isEqual(V, 'true')
   })
   it('Should throw on infinite pattern', () => {
     const T = Type.TemplateLiteral([Type.Number()])
@@ -30,6 +30,6 @@ describe('value/create/TemplateLiteral', () => {
   it('Should create on infinite pattern with default', () => {
     const T = Type.TemplateLiteral([Type.Number()], { default: 42 })
     const V = Value.Create(T)
-    Assert.deepEqual(V, 42)
+    Assert.isEqual(V, 42)
   })
 })
diff --git a/test/runtime/value/create/tuple.ts b/test/runtime/value/create/tuple.ts
index f2c91ccdb..2edb53bd6 100644
--- a/test/runtime/value/create/tuple.ts
+++ b/test/runtime/value/create/tuple.ts
@@ -5,18 +5,18 @@ import { Assert } from '../../assert/index'
 describe('value/create/Tuple', () => {
   it('Should create value', () => {
     const T = Type.Tuple([Type.Number(), Type.String()])
-    Assert.deepEqual(Value.Create(T), [0, ''])
+    Assert.isEqual(Value.Create(T), [0, ''])
   })
   it('Should create default', () => {
     const T = Type.Tuple([Type.Number(), Type.String()], { default: [7, 'hello'] })
-    Assert.deepEqual(Value.Create(T), [7, 'hello'])
+    Assert.isEqual(Value.Create(T), [7, 'hello'])
   })
   it('Should create default elements', () => {
     const T = Type.Tuple([Type.Number({ default: 7 }), Type.String({ default: 'hello' })])
-    Assert.deepEqual(Value.Create(T), [7, 'hello'])
+    Assert.isEqual(Value.Create(T), [7, 'hello'])
   })
   it('Should create default by overriding elements', () => {
     const T = Type.Tuple([Type.Number({ default: 7 }), Type.String({ default: 'hello' })], { default: [32, 'world'] })
-    Assert.deepEqual(Value.Create(T), [32, 'world'])
+    Assert.isEqual(Value.Create(T), [32, 'world'])
   })
 })
diff --git a/test/runtime/value/create/uint8array.ts b/test/runtime/value/create/uint8array.ts
index 6effa6d4c..1284f29f7 100644
--- a/test/runtime/value/create/uint8array.ts
+++ b/test/runtime/value/create/uint8array.ts
@@ -7,22 +7,22 @@ describe('value/create/Uint8Array', () => {
     const T = Type.Uint8Array()
     const value = Value.Create(T)
     Assert.isInstanceOf(value, Uint8Array)
-    Assert.equal(value.length, 0)
+    Assert.isEqual(value.length, 0)
   })
 
   it('Should create default', () => {
     const T = Type.Uint8Array({ default: new Uint8Array([0, 1, 2, 3]) })
     const value = Value.Create(T)
     Assert.isInstanceOf(value, Uint8Array)
-    Assert.equal(value.length, 4)
-    Assert.deepEqual([value[0], value[1], value[2], value[3]], [0, 1, 2, 3])
+    Assert.isEqual(value.length, 4)
+    Assert.isEqual([value[0], value[1], value[2], value[3]], [0, 1, 2, 3])
   })
 
   it('Should create with minByteLength', () => {
     const T = Type.Uint8Array({ minByteLength: 4 })
     const value = Value.Create(T)
     Assert.isInstanceOf(value, Uint8Array)
-    Assert.equal(value.length, 4)
-    Assert.deepEqual([value[0], value[1], value[2], value[3]], [0, 0, 0, 0])
+    Assert.isEqual(value.length, 4)
+    Assert.isEqual([value[0], value[1], value[2], value[3]], [0, 0, 0, 0])
   })
 })
diff --git a/test/runtime/value/create/undefined.ts b/test/runtime/value/create/undefined.ts
index b684204c6..d9e3ed509 100644
--- a/test/runtime/value/create/undefined.ts
+++ b/test/runtime/value/create/undefined.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/Undefined', () => {
   it('Should create value', () => {
     const T = Type.Undefined()
-    Assert.deepEqual(Value.Create(T), undefined)
+    Assert.isEqual(Value.Create(T), undefined)
   })
   it('Should create value from default value', () => {
     const T = Type.Undefined({ default: 'hello' })
-    Assert.deepEqual(Value.Create(T), 'hello')
+    Assert.isEqual(Value.Create(T), 'hello')
   })
 })
diff --git a/test/runtime/value/create/union.ts b/test/runtime/value/create/union.ts
index 63e14202f..1d3c79677 100644
--- a/test/runtime/value/create/union.ts
+++ b/test/runtime/value/create/union.ts
@@ -17,7 +17,7 @@ describe('value/create/Union', () => {
       z: Type.String(),
     })
     const T = Type.Union([A, B])
-    Assert.deepEqual(Value.Create(T), {
+    Assert.isEqual(Value.Create(T), {
       type: 'A',
       x: 0,
       y: 0,
@@ -34,7 +34,7 @@ describe('value/create/Union', () => {
       z: Type.String(),
     })
     const T = Type.Union([A, B])
-    Assert.deepEqual(Value.Create(T), null)
+    Assert.isEqual(Value.Create(T), null)
   })
 
   it('Should create union Array', () => {
@@ -46,6 +46,6 @@ describe('value/create/Union', () => {
       z: Type.String(),
     })
     const T = Type.Union([A, B])
-    Assert.deepEqual(Value.Create(T), [])
+    Assert.isEqual(Value.Create(T), [])
   })
 })
diff --git a/test/runtime/value/create/unknown.ts b/test/runtime/value/create/unknown.ts
index d86946c6c..d75a062c8 100644
--- a/test/runtime/value/create/unknown.ts
+++ b/test/runtime/value/create/unknown.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/Unknown', () => {
   it('Should create value', () => {
     const T = Type.Unknown()
-    Assert.deepEqual(Value.Create(T), {})
+    Assert.isEqual(Value.Create(T), {})
   })
   it('Should create default', () => {
     const T = Type.Unknown({ default: 1 })
-    Assert.deepEqual(Value.Create(T), 1)
+    Assert.isEqual(Value.Create(T), 1)
   })
 })
diff --git a/test/runtime/value/create/void.ts b/test/runtime/value/create/void.ts
index b74886656..56c8a9a66 100644
--- a/test/runtime/value/create/void.ts
+++ b/test/runtime/value/create/void.ts
@@ -5,11 +5,11 @@ import { Assert } from '../../assert/index'
 describe('value/create/Void', () => {
   it('Should create value', () => {
     const T = Type.Void()
-    Assert.deepEqual(Value.Create(T), null)
+    Assert.isEqual(Value.Create(T), null)
   })
 
   it('Should create value from default value', () => {
     const T = Type.Void({ default: 'hello' })
-    Assert.deepEqual(Value.Create(T), 'hello')
+    Assert.isEqual(Value.Create(T), 'hello')
   })
 })
diff --git a/test/runtime/value/delta/diff.ts b/test/runtime/value/delta/diff.ts
index 5a86fccb4..bda3d0a1d 100644
--- a/test/runtime/value/delta/diff.ts
+++ b/test/runtime/value/delta/diff.ts
@@ -26,35 +26,35 @@ describe('value/delta/Diff', () => {
     const B = null
     const D = Value.Diff(A, B)
     const E = [] as Edit[]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff NULL undefined to undefined', () => {
     const A = undefined
     const B = undefined
     const D = Value.Diff(A, B)
     const E = [] as Edit[]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff NULL string to string', () => {
     const A = 'hello'
     const B = 'hello'
     const D = Value.Diff(A, B)
     const E = [] as Edit[]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff NULL number to number', () => {
     const A = 1
     const B = 1
     const D = Value.Diff(A, B)
     const E = [] as Edit[]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff NULL boolean to boolean', () => {
     const A = true
     const B = true
     const D = Value.Diff(A, B)
     const E = [] as Edit[]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff NULL symbol to symbol', () => {
     const S = Symbol('A')
@@ -62,21 +62,21 @@ describe('value/delta/Diff', () => {
     const B = S
     const D = Value.Diff(A, B)
     const E = [] as Edit[]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff NULL object to object', () => {
     const A = { x: 1, y: 2, z: 3 }
     const B = { x: 1, y: 2, z: 3 }
     const D = Value.Diff(A, B)
     const E = [] as Edit[]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff NULL array to array', () => {
     const A = [1, 2, 3]
     const B = [1, 2, 3]
     const D = Value.Diff(A, B)
     const E = [] as Edit[]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   // ----------------------------------------------------
@@ -88,7 +88,7 @@ describe('value/delta/Diff', () => {
     const B = null
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff TYPE change null to undefined', () => {
@@ -96,49 +96,49 @@ describe('value/delta/Diff', () => {
     const B = undefined
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff TYPE change null to number', () => {
     const A = null
     const B = 1
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff TYPE change null to boolean', () => {
     const A = null
     const B = true
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff TYPE change null to string', () => {
     const A = null
     const B = 'hello'
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff TYPE change null to symbol', () => {
     const A = null
     const B = Symbol('A')
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff TYPE change null to object', () => {
     const A = null
     const B = { x: 1, y: 1, z: 1 }
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff TYPE change null to array', () => {
     const A = null
     const B = [1, 2, 3]
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   // ----------------------------------------------------
   // Value Change Root
@@ -149,7 +149,7 @@ describe('value/delta/Diff', () => {
     const B = 2
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff VALUE change boolean', () => {
@@ -157,7 +157,7 @@ describe('value/delta/Diff', () => {
     const B = true
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff VALUE change string', () => {
@@ -165,7 +165,7 @@ describe('value/delta/Diff', () => {
     const B = 'world'
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff VALUE change symbol', () => {
@@ -173,7 +173,7 @@ describe('value/delta/Diff', () => {
     const B = Symbol('B')
     const D = Value.Diff<any>(A, B)
     const E = [Update('', B)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   // ----------------------------------------------------
@@ -185,7 +185,7 @@ describe('value/delta/Diff', () => {
     const B = [1, 2, 3, 9]
     const D = Value.Diff(A, B)
     const E = [Update('/3', 9)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff ELEMENT push', () => {
@@ -193,7 +193,7 @@ describe('value/delta/Diff', () => {
     const B = [1, 2, 3, 4, 5]
     const D = Value.Diff(A, B)
     const E = [Insert('/4', 5)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff ELEMENT push twice', () => {
@@ -201,7 +201,7 @@ describe('value/delta/Diff', () => {
     const B = [1, 2, 3, 4, 5, 6]
     const D = Value.Diff(A, B)
     const E = [Insert('/4', 5), Insert('/5', 6)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff ELEMENT pop', () => {
@@ -209,7 +209,7 @@ describe('value/delta/Diff', () => {
     const B = [1, 2, 3]
     const D = Value.Diff(A, B)
     const E = [Delete('/3')]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff ELEMENT pop twice', () => {
@@ -217,7 +217,7 @@ describe('value/delta/Diff', () => {
     const B = [1, 2]
     const D = Value.Diff(A, B)
     const E = [Delete('/3'), Delete('/2')]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff ELEMENT unshift', () => {
@@ -225,7 +225,7 @@ describe('value/delta/Diff', () => {
     const B = [2, 3, 4]
     const D = Value.Diff(A, B)
     const E = [Update('/0', 2), Update('/1', 3), Update('/2', 4), Delete('/3')]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff ELEMENT unshift twice', () => {
@@ -233,7 +233,7 @@ describe('value/delta/Diff', () => {
     const B = [3, 4]
     const D = Value.Diff(A, B)
     const E = [Update('/0', 3), Update('/1', 4), Delete('/3'), Delete('/2')]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   // ----------------------------------------------------
@@ -245,35 +245,35 @@ describe('value/delta/Diff', () => {
     const B = { x: 1, y: 1, z: 1 }
     const D = Value.Diff(A, B)
     const E = [Insert('/z', 1)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff PROPERTY delete', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { x: 1, y: 1 }
     const D = Value.Diff(A, B)
     const E = [Delete('/z')]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff PROPERTY update', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { x: 1, y: 1, z: 2 }
     const D = Value.Diff(A, B)
     const E = [Update('/z', 2)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff PROPERTY all values', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { x: 2, y: 2, z: 2 }
     const D = Value.Diff(A, B)
     const E = [Update('/x', 2), Update('/y', 2), Update('/z', 2)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff PROPERTY all delete, all insert', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { a: 2, b: 2, c: 2 }
     const D = Value.Diff<any>(A, B)
     const E = [Insert('/a', 2), Insert('/b', 2), Insert('/c', 2), Delete('/z'), Delete('/y'), Delete('/x')]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff PROPERTY update, insert and delete order preserved', () => {
@@ -281,7 +281,7 @@ describe('value/delta/Diff', () => {
     const B = { a: 2, b: 2, c: 2, w: 2 }
     const D = Value.Diff<any>(A, B)
     const E = [Update('/w', 2), Insert('/a', 2), Insert('/b', 2), Insert('/c', 2), Delete('/z'), Delete('/y'), Delete('/x')]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   // ----------------------------------------------------
@@ -293,7 +293,7 @@ describe('value/delta/Diff', () => {
     const B = { v: { x: 1, y: 1, z: 1 } }
     const D = Value.Diff<any>(A, B)
     const E = [Update('/v', B.v)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff NESTED OBJECT diff value change update', () => {
@@ -301,7 +301,7 @@ describe('value/delta/Diff', () => {
     const B = { v: 2 }
     const D = Value.Diff(A, B)
     const E = [Update('/v', B.v)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff NESTED OBJECT diff partial property update', () => {
@@ -309,7 +309,7 @@ describe('value/delta/Diff', () => {
     const B = { v: { x: 2, y: 2, z: 2 } }
     const D = Value.Diff(A, B)
     const E = [Update('/v/x', B.v.x), Update('/v/y', B.v.y), Update('/v/z', B.v.z)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff NESTED OBJECT diff partial property insert', () => {
@@ -317,7 +317,7 @@ describe('value/delta/Diff', () => {
     const B = { v: { x: 1, y: 1, z: 1, w: 1 } }
     const D = Value.Diff(A, B)
     const E = [Insert('/v/w', B.v.w)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff NESTED OBJECT diff partial property delete', () => {
@@ -325,7 +325,7 @@ describe('value/delta/Diff', () => {
     const B = { v: { x: 1, y: 1 } }
     const D = Value.Diff(A, B)
     const E = [Delete('/v/z')]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff NESTED OBJECT ordered diff - update, insert and delete', () => {
@@ -333,7 +333,7 @@ describe('value/delta/Diff', () => {
     const B = { v: { x: 2, w: 2 } }
     const D = Value.Diff<any>(A, B)
     const E = [Update('/v/x', B.v.x), Insert('/v/w', B.v.w), Delete('/v/y')]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   // ----------------------------------------------------
@@ -345,7 +345,7 @@ describe('value/delta/Diff', () => {
     const B = [{ v: { x: 1, y: 1, z: 1 } }]
     const D = Value.Diff<any>(A, B)
     const E = [Update('/0/v', B[0].v)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff NESTED ARRAY object diff value change update', () => {
@@ -353,21 +353,21 @@ describe('value/delta/Diff', () => {
     const B = [{ v: 2 }]
     const D = Value.Diff(A, B)
     const E = [Update('/0/v', B[0].v)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff NESTED ARRAY object diff partial property update', () => {
     const A = [{ v: { x: 1, y: 1, z: 1 } }]
     const B = [{ v: { x: 2, y: 2, z: 2 } }]
     const D = Value.Diff(A, B)
     const E = [Update('/0/v/x', B[0].v.x), Update('/0/v/y', B[0].v.y), Update('/0/v/z', B[0].v.z)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
   it('Should diff NESTED ARRAY object diff partial property insert', () => {
     const A = [{ v: { x: 1, y: 1, z: 1 } }]
     const B = [{ v: { x: 1, y: 1, z: 1, w: 1 } }]
     const D = Value.Diff(A, B)
     const E = [Insert('/0/v/w', B[0].v.w)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff NESTED ARRAY object diff partial property delete', () => {
@@ -375,7 +375,7 @@ describe('value/delta/Diff', () => {
     const B = [{ v: { x: 1, y: 1 } }]
     const D = Value.Diff(A, B)
     const E = [Delete('/0/v/z')]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff NESTED ARRAY update, insert and delete order preserved', () => {
@@ -383,7 +383,7 @@ describe('value/delta/Diff', () => {
     const B = [{ v: { x: 2, w: 2 } }]
     const D = Value.Diff<any>(A, B)
     const E = [Update('/0/v/x', B[0].v.x), Insert('/0/v/w', B[0].v.w), Delete('/0/v/y')]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should throw if attempting to diff a current value with symbol key', () => {
@@ -403,7 +403,7 @@ describe('value/delta/Diff', () => {
     const B = new Uint8Array([0, 9, 2, 9])
     const D = Value.Diff(A, B)
     const E = [Update('/1', 9), Update('/3', 9)]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff a Uint8Array (less than requires full update)', () => {
@@ -411,7 +411,7 @@ describe('value/delta/Diff', () => {
     const B = new Uint8Array([0, 9, 2])
     const D = Value.Diff(A, B)
     const E = [Update('', new Uint8Array([0, 9, 2]))]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 
   it('Should diff a Uint8Array (greater than requires full update)', () => {
@@ -419,6 +419,6 @@ describe('value/delta/Diff', () => {
     const B = new Uint8Array([0, 9, 2, 3, 4])
     const D = Value.Diff(A, B)
     const E = [Update('', new Uint8Array([0, 9, 2, 3, 4]))]
-    Assert.deepEqual(D, E)
+    Assert.isEqual(D, E)
   })
 })
diff --git a/test/runtime/value/delta/patch.ts b/test/runtime/value/delta/patch.ts
index 62a0c50e1..cb9ac37f3 100644
--- a/test/runtime/value/delta/patch.ts
+++ b/test/runtime/value/delta/patch.ts
@@ -10,35 +10,35 @@ describe('value/delta/Patch', () => {
     const B = null
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch NULL undefined to undefined', () => {
     const A = undefined
     const B = undefined
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch NULL string to string', () => {
     const A = 'hello'
     const B = 'hello'
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch NULL number to number', () => {
     const A = 1
     const B = 1
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch NULL boolean to boolean', () => {
     const A = true
     const B = true
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch NULL symbol to symbol', () => {
     const S = Symbol('A')
@@ -46,7 +46,7 @@ describe('value/delta/Patch', () => {
     const B = S
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch NULL object to object', () => {
@@ -54,7 +54,7 @@ describe('value/delta/Patch', () => {
     const B = { x: 1, y: 2, z: 3 }
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch NULL array to array', () => {
@@ -62,7 +62,7 @@ describe('value/delta/Patch', () => {
     const B = [1, 2, 3]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   // ----------------------------------------------------
@@ -74,7 +74,7 @@ describe('value/delta/Patch', () => {
     const B = null
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch TYPE change null to undefined', () => {
@@ -82,56 +82,56 @@ describe('value/delta/Patch', () => {
     const B = undefined
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch TYPE change null to number', () => {
     const A = null
     const B = 1
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch TYPE change null to boolean', () => {
     const A = null
     const B = true
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch TYPE change null to string', () => {
     const A = null
     const B = 'hello'
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch TYPE change null to symbol', () => {
     const A = null
     const B = Symbol('A')
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch TYPE change null to object', () => {
     const A = null
     const B = { x: 1, y: 1, z: 1 }
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch TYPE change null to array', () => {
     const A = null
     const B = [1, 2, 3]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch TYPE change object to array', () => {
     const A = { x: 1, y: 2 }
     const B = [1, 2, 3]
     const D = Value.Diff<any>(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch TYPE change array to object', () => {
@@ -139,7 +139,7 @@ describe('value/delta/Patch', () => {
     const B = { x: 1, y: 2 }
     const D = Value.Diff<any>(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   // ----------------------------------------------------
@@ -151,7 +151,7 @@ describe('value/delta/Patch', () => {
     const B = 2
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch VALUE change boolean', () => {
@@ -159,7 +159,7 @@ describe('value/delta/Patch', () => {
     const B = true
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch VALUE change string', () => {
@@ -167,7 +167,7 @@ describe('value/delta/Patch', () => {
     const B = 'world'
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch VALUE change symbol', () => {
@@ -175,7 +175,7 @@ describe('value/delta/Patch', () => {
     const B = Symbol('B')
     const D = Value.Diff<any>(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   // ----------------------------------------------------
@@ -187,7 +187,7 @@ describe('value/delta/Patch', () => {
     const B = [1, 2, 3, 9]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch ELEMENT push', () => {
@@ -195,7 +195,7 @@ describe('value/delta/Patch', () => {
     const B = [1, 2, 3, 4, 5]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch ELEMENT push twice', () => {
@@ -203,7 +203,7 @@ describe('value/delta/Patch', () => {
     const B = [1, 2, 3, 4, 5, 6]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch ELEMENT pop', () => {
@@ -211,7 +211,7 @@ describe('value/delta/Patch', () => {
     const B = [1, 2, 3]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch ELEMENT pop twice', () => {
@@ -219,7 +219,7 @@ describe('value/delta/Patch', () => {
     const B = [1, 2]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch ELEMENT unshift', () => {
@@ -227,7 +227,7 @@ describe('value/delta/Patch', () => {
     const B = [2, 3, 4]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch ELEMENT unshift twice', () => {
@@ -235,7 +235,7 @@ describe('value/delta/Patch', () => {
     const B = [3, 4]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   // ----------------------------------------------------
@@ -247,35 +247,35 @@ describe('value/delta/Patch', () => {
     const B = { x: 1, y: 1, z: 1 }
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch PROPERTY delete', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { x: 1, y: 1 }
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch PROPERTY update', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { x: 1, y: 1, z: 2 }
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch PROPERTY all values', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { x: 2, y: 2, z: 2 }
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch PROPERTY all delete, all insert', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { a: 2, b: 2, c: 2 }
     const D = Value.Diff<any>(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch PROPERTY update, insert and delete order preserved', () => {
@@ -283,7 +283,7 @@ describe('value/delta/Patch', () => {
     const B = { a: 2, b: 2, c: 2, w: 2 }
     const D = Value.Diff<any>(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   // ----------------------------------------------------
   // Object Nested
@@ -294,21 +294,21 @@ describe('value/delta/Patch', () => {
     const B = { v: { x: 1, y: 1, z: 1 } }
     const D = Value.Diff<any>(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch NESTED OBJECT diff value change update', () => {
     const A = { v: 1 }
     const B = { v: 2 }
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch NESTED OBJECT diff partial property update', () => {
     const A = { v: { x: 1, y: 1, z: 1 } }
     const B = { v: { x: 2, y: 2, z: 2 } }
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch NESTED OBJECT update, insert and delete order preserved', () => {
@@ -316,7 +316,7 @@ describe('value/delta/Patch', () => {
     const B = { v: { x: 2, w: 2 } }
     const D = Value.Diff<any>(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   // ----------------------------------------------------
@@ -328,7 +328,7 @@ describe('value/delta/Patch', () => {
     const B = [{ v: { x: 1, y: 1, z: 1 } }]
     const D = Value.Diff<any>(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch NESTED ARRAY object diff value change update', () => {
@@ -336,21 +336,21 @@ describe('value/delta/Patch', () => {
     const B = [{ v: 2 }]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch NESTED ARRAY object diff partial property update', () => {
     const A = [{ v: { x: 1, y: 1, z: 1 } }]
     const B = [{ v: { x: 2, y: 2, z: 2 } }]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   it('Should patch NESTED ARRAY object diff partial property insert', () => {
     const A = [{ v: { x: 1, y: 1, z: 1 } }]
     const B = [{ v: { x: 1, y: 1, z: 1, w: 1 } }]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch NESTED ARRAY object diff partial property delete', () => {
@@ -358,7 +358,7 @@ describe('value/delta/Patch', () => {
     const B = [{ v: { x: 1, y: 1 } }]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch NESTED ARRAY object ordered diff - update, insert and delete', () => {
@@ -366,7 +366,7 @@ describe('value/delta/Patch', () => {
     const B = [{ v: { x: 2, w: 2 } }]
     const D = Value.Diff<any>(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch Uint8Array (same size)', () => {
@@ -374,7 +374,7 @@ describe('value/delta/Patch', () => {
     const B = [{ v: new Uint8Array([0, 1, 2]) }]
     const D = Value.Diff<any>(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch Uint8Array (less than size)', () => {
@@ -382,7 +382,7 @@ describe('value/delta/Patch', () => {
     const B = [{ v: new Uint8Array([0, 1]) }]
     const D = Value.Diff<any>(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 
   it('Should patch Uint8Array (greater than size)', () => {
@@ -390,7 +390,7 @@ describe('value/delta/Patch', () => {
     const B = [{ v: new Uint8Array([0, 1, 2, 4]) }]
     const D = Value.Diff<any>(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
   // ----------------------------------------------------
   // Mega Values
@@ -442,6 +442,6 @@ describe('value/delta/Patch', () => {
     ]
     const D = Value.Diff<any>(A, B)
     const P = Value.Patch(A, D)
-    Assert.deepEqual(B, P)
+    Assert.isEqual(B, P)
   })
 })
diff --git a/test/runtime/value/equal/equal.ts b/test/runtime/value/equal/equal.ts
index b02583e6e..dda3c6b18 100644
--- a/test/runtime/value/equal/equal.ts
+++ b/test/runtime/value/equal/equal.ts
@@ -4,108 +4,108 @@ import { Assert } from '../../assert/index'
 describe('value/equal/Equal', () => {
   it('Should equal null value', () => {
     const R = Value.Equal(null, null)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not equal null value', () => {
     const R = Value.Equal(null, 'null')
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should equal undefined value', () => {
     const R = Value.Equal(undefined, undefined)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not equal undefined value', () => {
     const R = Value.Equal(undefined, 'undefined')
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should equal symbol value', () => {
     const S1 = Symbol.for('test')
     const S2 = Symbol.for('test')
     const R = Value.Equal(S1, S2)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not equal symbol value', () => {
     const S1 = Symbol('test')
     const S2 = Symbol('test')
     const R = Value.Equal(S1, S2)
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should equal string value', () => {
     const R = Value.Equal('hello', 'hello')
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
   it('Should not equal string value', () => {
     const R = Value.Equal('hello', 'world')
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should equal number value', () => {
     const R = Value.Equal(1, 1)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not equal number value', () => {
     const R = Value.Equal(1, 2)
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should equal boolean value', () => {
     const R = Value.Equal(true, true)
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not equal boolean value', () => {
     const R = Value.Equal(true, false)
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should equal array value', () => {
     const R = Value.Equal([0, 1, 2], [0, 1, 2])
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not equal array value', () => {
     const R = Value.Equal([0, 1, 2], [0, 1, 3])
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not equal array value with additional elements', () => {
     const R = Value.Equal([0, 1, 2], [0, 1, 2, 3])
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should equal object value', () => {
     const R = Value.Equal({ x: 1, y: 2, z: 3 }, { x: 1, y: 2, z: 3 })
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not equal object value', () => {
     const R = Value.Equal({ x: 1, y: 2, z: 3 }, { x: 1, y: 2, z: 4 })
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should not equal object value with additional properties', () => {
     const R = Value.Equal({ x: 1, y: 2, z: 3 }, { x: 1, y: 2, z: 3, w: 1 })
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
 
   it('Should equal typed array value', () => {
     const R = Value.Equal(new Uint8Array([0, 1, 2]), new Uint8Array([0, 1, 2]))
-    Assert.deepEqual(R, true)
+    Assert.isEqual(R, true)
   })
 
   it('Should not equal typed array value', () => {
     const R = Value.Equal(new Uint8Array([0, 1, 2]), new Uint8Array([0, 1, 3]))
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
   it('Should not equal typed array value with varying type', () => {
     const R = Value.Equal(new Uint8Array([0, 1, 2]), new Int8Array([0, 1, 2]))
-    Assert.deepEqual(R, false)
+    Assert.isEqual(R, false)
   })
 })
diff --git a/test/runtime/value/hash/hash.ts b/test/runtime/value/hash/hash.ts
index 45b255342..eac4765e8 100644
--- a/test/runtime/value/hash/hash.ts
+++ b/test/runtime/value/hash/hash.ts
@@ -3,39 +3,39 @@ import { Assert } from '../../assert/index'
 
 describe('value/hash/Hash', () => {
   it('Should hash number', () => {
-    Assert.equal('bigint', typeof ValueHash.Create(1))
+    Assert.isEqual('bigint', typeof ValueHash.Create(1))
     const A = ValueHash.Create(1)
     const B = ValueHash.Create(2)
     Assert.notEqual(A, B)
   })
   it('Should hash string', () => {
-    Assert.equal('bigint', typeof ValueHash.Create('hello'))
+    Assert.isEqual('bigint', typeof ValueHash.Create('hello'))
     const A = ValueHash.Create('hello')
     const B = ValueHash.Create('world')
     Assert.notEqual(A, B)
   })
   it('Should hash boolean', () => {
-    Assert.equal('bigint', typeof ValueHash.Create(true))
-    Assert.equal('bigint', typeof ValueHash.Create(false))
+    Assert.isEqual('bigint', typeof ValueHash.Create(true))
+    Assert.isEqual('bigint', typeof ValueHash.Create(false))
     const A = ValueHash.Create(true)
     const B = ValueHash.Create(false)
     Assert.notEqual(A, B)
   })
   it('Should hash null', () => {
-    Assert.equal('bigint', typeof ValueHash.Create(null))
+    Assert.isEqual('bigint', typeof ValueHash.Create(null))
     const A = ValueHash.Create(null)
     const B = ValueHash.Create(undefined)
     Assert.notEqual(A, B)
   })
   it('Should hash array', () => {
-    Assert.equal('bigint', typeof ValueHash.Create([0, 1, 2, 3]))
+    Assert.isEqual('bigint', typeof ValueHash.Create([0, 1, 2, 3]))
     const A = ValueHash.Create([0, 1, 2, 3])
     const B = ValueHash.Create([0, 2, 2, 3])
     Assert.notEqual(A, B)
   })
   it('Should hash object 1', () => {
     // prettier-ignore
-    Assert.equal('bigint', typeof ValueHash.Create({ x: 1, y: 2 }))
+    Assert.isEqual('bigint', typeof ValueHash.Create({ x: 1, y: 2 }))
     const A = ValueHash.Create({ x: 1, y: 2 })
     const B = ValueHash.Create({ x: 2, y: 2 })
     Assert.notEqual(A, B)
@@ -61,51 +61,51 @@ describe('value/hash/Hash', () => {
     Assert.notEqual(A, B)
   })
   it('Should hash Date', () => {
-    Assert.equal('bigint', typeof ValueHash.Create(new Date()))
+    Assert.isEqual('bigint', typeof ValueHash.Create(new Date()))
     const A = ValueHash.Create(new Date(1))
     const B = ValueHash.Create(new Date(2))
     Assert.notEqual(A, B)
   })
   it('Should hash Uint8Array', () => {
-    Assert.equal('bigint', typeof ValueHash.Create(new Uint8Array([0, 1, 2, 3])))
+    Assert.isEqual('bigint', typeof ValueHash.Create(new Uint8Array([0, 1, 2, 3])))
     const A = ValueHash.Create(new Uint8Array([0, 1, 2, 3]))
     const B = ValueHash.Create(new Uint8Array([0, 2, 2, 3]))
     Assert.notEqual(A, B)
   })
   it('Should hash undefined', () => {
-    Assert.equal('bigint', typeof ValueHash.Create(undefined))
+    Assert.isEqual('bigint', typeof ValueHash.Create(undefined))
     const A = ValueHash.Create(undefined)
     const B = ValueHash.Create(null)
     Assert.notEqual(A, B)
   })
   it('Should hash symbol 1', () => {
-    Assert.equal('bigint', typeof ValueHash.Create(Symbol()))
+    Assert.isEqual('bigint', typeof ValueHash.Create(Symbol()))
     const A = ValueHash.Create(Symbol(1))
     const B = ValueHash.Create(Symbol())
     Assert.notEqual(A, B)
   })
   it('Should hash symbol 2', () => {
-    Assert.equal('bigint', typeof ValueHash.Create(Symbol()))
+    Assert.isEqual('bigint', typeof ValueHash.Create(Symbol()))
     const A = ValueHash.Create(Symbol(1))
     const B = ValueHash.Create(Symbol(2))
     Assert.notEqual(A, B)
   })
   it('Should hash symbol 2', () => {
-    Assert.equal('bigint', typeof ValueHash.Create(Symbol()))
+    Assert.isEqual('bigint', typeof ValueHash.Create(Symbol()))
     const A = ValueHash.Create(Symbol(1))
     const B = ValueHash.Create(Symbol(1))
-    Assert.equal(A, B)
+    Assert.isEqual(A, B)
   })
   it('Should hash bigint 1', () => {
-    Assert.equal('bigint', typeof ValueHash.Create(BigInt(1)))
+    Assert.isEqual('bigint', typeof ValueHash.Create(BigInt(1)))
     const A = ValueHash.Create(BigInt(1))
     const B = ValueHash.Create(BigInt(2))
     Assert.notEqual(A, B)
   })
   it('Should hash bigint 2', () => {
-    Assert.equal('bigint', typeof ValueHash.Create(BigInt(1)))
+    Assert.isEqual('bigint', typeof ValueHash.Create(BigInt(1)))
     const A = ValueHash.Create(BigInt(1))
     const B = ValueHash.Create(BigInt(1))
-    Assert.equal(A, B)
+    Assert.isEqual(A, B)
   })
 })
diff --git a/test/runtime/value/mutate/mutate.ts b/test/runtime/value/mutate/mutate.ts
index 1c4d81ef1..fe5b5d053 100644
--- a/test/runtime/value/mutate/mutate.ts
+++ b/test/runtime/value/mutate/mutate.ts
@@ -33,49 +33,49 @@ describe('value/mutate/Mutate', () => {
     const X = { y: Y }
     const A = { x: X }
     Value.Mutate(A, {})
-    Assert.deepEqual(A, {})
+    Assert.isEqual(A, {})
   })
   it('Should mutate 1', () => {
     const Y = { z: 1 }
     const X = { y: Y }
     const A = { x: X }
     Value.Mutate(A, { x: { y: { z: 2 } } })
-    Assert.equal(A.x.y.z, 2)
-    Assert.equal(A.x.y, Y)
-    Assert.equal(A.x, X)
+    Assert.isEqual(A.x.y.z, 2)
+    Assert.isEqual(A.x.y, Y)
+    Assert.isEqual(A.x, X)
   })
   it('Should mutate 2', () => {
     const Y = { z: 1 }
     const X = { y: Y }
     const A = { x: X }
     Value.Mutate(A, { x: { y: { z: [1, 2, 3] } } })
-    Assert.deepEqual(A.x.y.z, [1, 2, 3])
-    Assert.equal(A.x.y, Y)
-    Assert.equal(A.x, X)
+    Assert.isEqual(A.x.y.z, [1, 2, 3])
+    Assert.isEqual(A.x.y, Y)
+    Assert.isEqual(A.x, X)
   })
   it('Should mutate 3', () => {
     const Y = { z: 1 }
     const X = { y: Y }
     const A = { x: X }
     Value.Mutate(A, { x: {} })
-    Assert.equal(A.x.y, undefined)
-    Assert.equal(A.x, X)
+    Assert.isEqual(A.x.y, undefined)
+    Assert.isEqual(A.x, X)
   })
   it('Should mutate 4', () => {
     const Y = { z: 1 }
     const X = { y: Y }
     const A = { x: X }
     Value.Mutate(A, { x: { y: 1 } })
-    Assert.equal(A.x.y, 1)
-    Assert.equal(A.x, X)
+    Assert.isEqual(A.x.y, 1)
+    Assert.isEqual(A.x, X)
   })
   it('Should mutate 5', () => {
     const Y = { z: 1 }
     const X = { y: Y }
     const A = { x: X }
     Value.Mutate(A, { x: { y: [1, 2, 3] } })
-    Assert.deepEqual(A.x.y, [1, 2, 3])
-    Assert.equal(A.x, X)
+    Assert.isEqual(A.x.y, [1, 2, 3])
+    Assert.isEqual(A.x, X)
   })
   it('Should mutate 6', () => {
     const Y = { z: 1 }
@@ -83,6 +83,6 @@ describe('value/mutate/Mutate', () => {
     const A = { x: X }
     Value.Mutate(A, { x: [1, 2, 3] })
     Assert.notEqual(A.x, X)
-    Assert.deepEqual(A.x, [1, 2, 3])
+    Assert.isEqual(A.x, [1, 2, 3])
   })
 })
diff --git a/test/runtime/value/pointer/pointer.ts b/test/runtime/value/pointer/pointer.ts
index a3854baa6..6c1ee1652 100644
--- a/test/runtime/value/pointer/pointer.ts
+++ b/test/runtime/value/pointer/pointer.ts
@@ -8,102 +8,102 @@ describe('value/pointer/Pointer', () => {
 
   it('Should produce correct format #1', () => {
     const R = [...ValuePointer.Format('')]
-    Assert.deepEqual(R, [])
+    Assert.isEqual(R, [])
   })
 
   it('Should produce correct format #2', () => {
     const R = [...ValuePointer.Format('a')]
-    Assert.deepEqual(R, ['a'])
+    Assert.isEqual(R, ['a'])
   })
 
   it('Should produce correct format #3', () => {
     const R = [...ValuePointer.Format('/')]
-    Assert.deepEqual(R, [''])
+    Assert.isEqual(R, [''])
   })
 
   it('Should produce correct format #4', () => {
     const R = [...ValuePointer.Format('/x')]
-    Assert.deepEqual(R, ['x'])
+    Assert.isEqual(R, ['x'])
   })
 
   it('Should produce correct format #5', () => {
     const R = [...ValuePointer.Format('/x/')]
-    Assert.deepEqual(R, ['x', ''])
+    Assert.isEqual(R, ['x', ''])
   })
 
   it('Should produce correct format #6', () => {
     const R = [...ValuePointer.Format('/x//')]
-    Assert.deepEqual(R, ['x', '', ''])
+    Assert.isEqual(R, ['x', '', ''])
   })
 
   it('Should produce correct format #7', () => {
     const R = [...ValuePointer.Format('/x//y')]
-    Assert.deepEqual(R, ['x', '', 'y'])
+    Assert.isEqual(R, ['x', '', 'y'])
   })
 
   it('Should produce correct format #8', () => {
     const R = [...ValuePointer.Format('/x//y/')]
-    Assert.deepEqual(R, ['x', '', 'y', ''])
+    Assert.isEqual(R, ['x', '', 'y', ''])
   })
 
   it('Should produce correct format #9', () => {
     const R = [...ValuePointer.Format('/x/~0')]
-    Assert.deepEqual(R, ['x', '~'])
+    Assert.isEqual(R, ['x', '~'])
   })
 
   it('Should produce correct format #10', () => {
     const R = [...ValuePointer.Format('/x/~1')]
-    Assert.deepEqual(R, ['x', '/'])
+    Assert.isEqual(R, ['x', '/'])
   })
 
   it('Should produce correct format #11', () => {
     const R = [...ValuePointer.Format('/x/~0/')]
-    Assert.deepEqual(R, ['x', '~', ''])
+    Assert.isEqual(R, ['x', '~', ''])
   })
 
   it('Should produce correct format #12', () => {
     const R = [...ValuePointer.Format('/x/~1/')]
-    Assert.deepEqual(R, ['x', '/', ''])
+    Assert.isEqual(R, ['x', '/', ''])
   })
 
   it('Should produce correct format #13', () => {
     const R = [...ValuePointer.Format('/x/a~0b')]
-    Assert.deepEqual(R, ['x', 'a~b'])
+    Assert.isEqual(R, ['x', 'a~b'])
   })
 
   it('Should produce correct format #14', () => {
     const R = [...ValuePointer.Format('/x/a~1b')]
-    Assert.deepEqual(R, ['x', 'a/b'])
+    Assert.isEqual(R, ['x', 'a/b'])
   })
 
   it('Should produce correct format #15', () => {
     const R = [...ValuePointer.Format('/x/a~0b/')]
-    Assert.deepEqual(R, ['x', 'a~b', ''])
+    Assert.isEqual(R, ['x', 'a~b', ''])
   })
 
   it('Should produce correct format #16', () => {
     const R = [...ValuePointer.Format('/x/a~1b/')]
-    Assert.deepEqual(R, ['x', 'a/b', ''])
+    Assert.isEqual(R, ['x', 'a/b', ''])
   })
 
   it('Should produce correct format #17', () => {
     const R = [...ValuePointer.Format('/x/a~0b///y')]
-    Assert.deepEqual(R, ['x', 'a~b', '', '', 'y'])
+    Assert.isEqual(R, ['x', 'a~b', '', '', 'y'])
   })
 
   it('Should produce correct format #18', () => {
     const R = [...ValuePointer.Format('/x/a~1b///y')]
-    Assert.deepEqual(R, ['x', 'a/b', '', '', 'y'])
+    Assert.isEqual(R, ['x', 'a/b', '', '', 'y'])
   })
 
   it('Should produce correct format #19', () => {
     const R = [...ValuePointer.Format('/x/a~0b///')]
-    Assert.deepEqual(R, ['x', 'a~b', '', '', ''])
+    Assert.isEqual(R, ['x', 'a~b', '', '', ''])
   })
 
   it('Should produce correct format #20', () => {
     const R = [...ValuePointer.Format('/x/a~1b///')]
-    Assert.deepEqual(R, ['x', 'a/b', '', '', ''])
+    Assert.isEqual(R, ['x', 'a/b', '', '', ''])
   })
 
   //-----------------------------------------------
@@ -112,59 +112,59 @@ describe('value/pointer/Pointer', () => {
 
   it('Should get array #1', () => {
     const V = [0, 1, 2, 3]
-    Assert.deepEqual(ValuePointer.Get(V, ''), [0, 1, 2, 3])
-    Assert.deepEqual(ValuePointer.Get(V, '/'), undefined)
-    Assert.deepEqual(ValuePointer.Get(V, '/0'), 0)
-    Assert.deepEqual(ValuePointer.Get(V, '/1'), 1)
-    Assert.deepEqual(ValuePointer.Get(V, '/2'), 2)
-    Assert.deepEqual(ValuePointer.Get(V, '/3'), 3)
+    Assert.isEqual(ValuePointer.Get(V, ''), [0, 1, 2, 3])
+    Assert.isEqual(ValuePointer.Get(V, '/'), undefined)
+    Assert.isEqual(ValuePointer.Get(V, '/0'), 0)
+    Assert.isEqual(ValuePointer.Get(V, '/1'), 1)
+    Assert.isEqual(ValuePointer.Get(V, '/2'), 2)
+    Assert.isEqual(ValuePointer.Get(V, '/3'), 3)
   })
 
   it('Should get array #2', () => {
     const V = [{ x: 0 }, { x: 1 }, { x: 2 }, { x: 3 }]
-    Assert.deepEqual(ValuePointer.Get(V, ''), [{ x: 0 }, { x: 1 }, { x: 2 }, { x: 3 }])
-    Assert.deepEqual(ValuePointer.Get(V, '/'), undefined)
-    Assert.deepEqual(ValuePointer.Get(V, '/0'), { x: 0 })
-    Assert.deepEqual(ValuePointer.Get(V, '/1'), { x: 1 })
-    Assert.deepEqual(ValuePointer.Get(V, '/2'), { x: 2 })
-    Assert.deepEqual(ValuePointer.Get(V, '/3'), { x: 3 })
-    Assert.deepEqual(ValuePointer.Get(V, '/0/x'), 0)
-    Assert.deepEqual(ValuePointer.Get(V, '/1/x'), 1)
-    Assert.deepEqual(ValuePointer.Get(V, '/2/x'), 2)
-    Assert.deepEqual(ValuePointer.Get(V, '/3/x'), 3)
+    Assert.isEqual(ValuePointer.Get(V, ''), [{ x: 0 }, { x: 1 }, { x: 2 }, { x: 3 }])
+    Assert.isEqual(ValuePointer.Get(V, '/'), undefined)
+    Assert.isEqual(ValuePointer.Get(V, '/0'), { x: 0 })
+    Assert.isEqual(ValuePointer.Get(V, '/1'), { x: 1 })
+    Assert.isEqual(ValuePointer.Get(V, '/2'), { x: 2 })
+    Assert.isEqual(ValuePointer.Get(V, '/3'), { x: 3 })
+    Assert.isEqual(ValuePointer.Get(V, '/0/x'), 0)
+    Assert.isEqual(ValuePointer.Get(V, '/1/x'), 1)
+    Assert.isEqual(ValuePointer.Get(V, '/2/x'), 2)
+    Assert.isEqual(ValuePointer.Get(V, '/3/x'), 3)
   })
 
   it('Should get object #1', () => {
     const V = { x: 0, y: 1, z: 2 }
-    Assert.deepEqual(ValuePointer.Get(V, ''), { x: 0, y: 1, z: 2 })
-    Assert.deepEqual(ValuePointer.Get(V, '/'), undefined)
-    Assert.deepEqual(ValuePointer.Get(V, '/x'), 0)
-    Assert.deepEqual(ValuePointer.Get(V, '/y'), 1)
-    Assert.deepEqual(ValuePointer.Get(V, '/z'), 2)
+    Assert.isEqual(ValuePointer.Get(V, ''), { x: 0, y: 1, z: 2 })
+    Assert.isEqual(ValuePointer.Get(V, '/'), undefined)
+    Assert.isEqual(ValuePointer.Get(V, '/x'), 0)
+    Assert.isEqual(ValuePointer.Get(V, '/y'), 1)
+    Assert.isEqual(ValuePointer.Get(V, '/z'), 2)
   })
 
   it('Should get object #2', () => {
     const V = { x: { x: 0 }, y: { x: 1 }, z: { x: 2 } }
-    Assert.deepEqual(ValuePointer.Get(V, ''), { x: { x: 0 }, y: { x: 1 }, z: { x: 2 } })
-    Assert.deepEqual(ValuePointer.Get(V, '/'), undefined)
-    Assert.deepEqual(ValuePointer.Get(V, '/x'), { x: 0 })
-    Assert.deepEqual(ValuePointer.Get(V, '/y'), { x: 1 })
-    Assert.deepEqual(ValuePointer.Get(V, '/z'), { x: 2 })
+    Assert.isEqual(ValuePointer.Get(V, ''), { x: { x: 0 }, y: { x: 1 }, z: { x: 2 } })
+    Assert.isEqual(ValuePointer.Get(V, '/'), undefined)
+    Assert.isEqual(ValuePointer.Get(V, '/x'), { x: 0 })
+    Assert.isEqual(ValuePointer.Get(V, '/y'), { x: 1 })
+    Assert.isEqual(ValuePointer.Get(V, '/z'), { x: 2 })
   })
 
   it('Should get object #3', () => {
     const V = { '': { x: -1 }, x: { '': { x: 1 } }, y: { '': { x: 2 } }, z: { '': { x: 3 } } }
-    Assert.deepEqual(ValuePointer.Get(V, ''), { '': { x: -1 }, x: { '': { x: 1 } }, y: { '': { x: 2 } }, z: { '': { x: 3 } } })
-    Assert.deepEqual(ValuePointer.Get(V, '/'), { x: -1 })
-    Assert.deepEqual(ValuePointer.Get(V, '/x'), { '': { x: 1 } })
-    Assert.deepEqual(ValuePointer.Get(V, '/y'), { '': { x: 2 } })
-    Assert.deepEqual(ValuePointer.Get(V, '/z'), { '': { x: 3 } })
-    Assert.deepEqual(ValuePointer.Get(V, '/x/'), { x: 1 })
-    Assert.deepEqual(ValuePointer.Get(V, '/y/'), { x: 2 })
-    Assert.deepEqual(ValuePointer.Get(V, '/z/'), { x: 3 })
-    Assert.deepEqual(ValuePointer.Get(V, '/x//x'), 1)
-    Assert.deepEqual(ValuePointer.Get(V, '/y//x'), 2)
-    Assert.deepEqual(ValuePointer.Get(V, '/z//x'), 3)
+    Assert.isEqual(ValuePointer.Get(V, ''), { '': { x: -1 }, x: { '': { x: 1 } }, y: { '': { x: 2 } }, z: { '': { x: 3 } } })
+    Assert.isEqual(ValuePointer.Get(V, '/'), { x: -1 })
+    Assert.isEqual(ValuePointer.Get(V, '/x'), { '': { x: 1 } })
+    Assert.isEqual(ValuePointer.Get(V, '/y'), { '': { x: 2 } })
+    Assert.isEqual(ValuePointer.Get(V, '/z'), { '': { x: 3 } })
+    Assert.isEqual(ValuePointer.Get(V, '/x/'), { x: 1 })
+    Assert.isEqual(ValuePointer.Get(V, '/y/'), { x: 2 })
+    Assert.isEqual(ValuePointer.Get(V, '/z/'), { x: 3 })
+    Assert.isEqual(ValuePointer.Get(V, '/x//x'), 1)
+    Assert.isEqual(ValuePointer.Get(V, '/y//x'), 2)
+    Assert.isEqual(ValuePointer.Get(V, '/z//x'), 3)
   })
 
   //-----------------------------------------------
@@ -173,37 +173,37 @@ describe('value/pointer/Pointer', () => {
 
   it('Should return has true for undefined', () => {
     const V = undefined
-    Assert.deepEqual(ValuePointer.Has(V, ''), true)
+    Assert.isEqual(ValuePointer.Has(V, ''), true)
   })
 
   it('Should return has true for null', () => {
     const V = null
-    Assert.deepEqual(ValuePointer.Has(V, ''), true)
+    Assert.isEqual(ValuePointer.Has(V, ''), true)
   })
 
   it('Should return has true for object', () => {
     const V = {}
-    Assert.deepEqual(ValuePointer.Has(V, ''), true)
+    Assert.isEqual(ValuePointer.Has(V, ''), true)
   })
 
   it('Should return has true for array', () => {
     const V: any[] = []
-    Assert.deepEqual(ValuePointer.Has(V, ''), true)
+    Assert.isEqual(ValuePointer.Has(V, ''), true)
   })
 
   it('Should return has true for string', () => {
     const V = 'hello'
-    Assert.deepEqual(ValuePointer.Has(V, ''), true)
+    Assert.isEqual(ValuePointer.Has(V, ''), true)
   })
 
   it('Should return has true for number', () => {
     const V = 42
-    Assert.deepEqual(ValuePointer.Has(V, ''), true)
+    Assert.isEqual(ValuePointer.Has(V, ''), true)
   })
 
   it('Should return has true for boolean', () => {
     const V = false
-    Assert.deepEqual(ValuePointer.Has(V, ''), true)
+    Assert.isEqual(ValuePointer.Has(V, ''), true)
   })
 
   it('Should return has true for deeply nested', () => {
@@ -216,20 +216,20 @@ describe('value/pointer/Pointer', () => {
       n: null,
     }
     // exists
-    Assert.deepEqual(ValuePointer.Has(V, ''), true)
-    Assert.deepEqual(ValuePointer.Has(V, '/'), true)
-    Assert.deepEqual(ValuePointer.Has(V, '//x'), true)
-    Assert.deepEqual(ValuePointer.Has(V, '//x/y'), true)
-    Assert.deepEqual(ValuePointer.Has(V, '//x/y/z'), true)
-    Assert.deepEqual(ValuePointer.Has(V, '/x'), true)
-    Assert.deepEqual(ValuePointer.Has(V, '/y/x'), true)
-    Assert.deepEqual(ValuePointer.Has(V, '/z'), true)
-    Assert.deepEqual(ValuePointer.Has(V, '/z/0'), true)
-    Assert.deepEqual(ValuePointer.Has(V, '/z/0/x'), true)
-    Assert.deepEqual(ValuePointer.Has(V, '/z/1'), true)
-    Assert.deepEqual(ValuePointer.Has(V, '/z/1/y'), true)
-    Assert.deepEqual(ValuePointer.Has(V, '/x'), true)
-    Assert.deepEqual(ValuePointer.Has(V, '/n'), true)
+    Assert.isEqual(ValuePointer.Has(V, ''), true)
+    Assert.isEqual(ValuePointer.Has(V, '/'), true)
+    Assert.isEqual(ValuePointer.Has(V, '//x'), true)
+    Assert.isEqual(ValuePointer.Has(V, '//x/y'), true)
+    Assert.isEqual(ValuePointer.Has(V, '//x/y/z'), true)
+    Assert.isEqual(ValuePointer.Has(V, '/x'), true)
+    Assert.isEqual(ValuePointer.Has(V, '/y/x'), true)
+    Assert.isEqual(ValuePointer.Has(V, '/z'), true)
+    Assert.isEqual(ValuePointer.Has(V, '/z/0'), true)
+    Assert.isEqual(ValuePointer.Has(V, '/z/0/x'), true)
+    Assert.isEqual(ValuePointer.Has(V, '/z/1'), true)
+    Assert.isEqual(ValuePointer.Has(V, '/z/1/y'), true)
+    Assert.isEqual(ValuePointer.Has(V, '/x'), true)
+    Assert.isEqual(ValuePointer.Has(V, '/n'), true)
   })
 
   //-----------------------------------------------
@@ -246,7 +246,7 @@ describe('value/pointer/Pointer', () => {
     ValuePointer.Set(V, '/0', 3)
     ValuePointer.Set(V, '/1', 4)
     ValuePointer.Set(V, '/2', 5)
-    Assert.deepEqual(V, [3, 4, 5])
+    Assert.isEqual(V, [3, 4, 5])
   })
 
   it('Should set object values', () => {
@@ -254,20 +254,20 @@ describe('value/pointer/Pointer', () => {
     ValuePointer.Set(V, '/x', 3)
     ValuePointer.Set(V, '/y', 4)
     ValuePointer.Set(V, '/z', 5)
-    Assert.deepEqual(V, { x: 3, y: 4, z: 5 })
+    Assert.isEqual(V, { x: 3, y: 4, z: 5 })
   })
 
   it('Should set object values recursively #1', () => {
     const V = {}
     ValuePointer.Set(V, '/x/y/z', 1)
-    Assert.deepEqual(V, { x: { y: { z: 1 } } })
+    Assert.isEqual(V, { x: { y: { z: 1 } } })
   })
 
   it('Should set object values recursively #2', () => {
     const V = {}
     ValuePointer.Set(V, '/x/0/y/z/', 1)
     ValuePointer.Set(V, '/x/1/y/z/', 2)
-    Assert.deepEqual(V, {
+    Assert.isEqual(V, {
       x: {
         0: {
           y: {
@@ -303,7 +303,7 @@ describe('value/pointer/Pointer', () => {
     }
     ValuePointer.Delete(V, '/x/y')
     ValuePointer.Delete(V, '/y')
-    Assert.deepEqual(V, { x: { x: 1, z: 3 } })
+    Assert.isEqual(V, { x: { x: 1, z: 3 } })
   })
 
   it('Should be a noop if property does not exist', () => {
@@ -313,7 +313,7 @@ describe('value/pointer/Pointer', () => {
     }
     ValuePointer.Delete(V, '/x/w')
     ValuePointer.Delete(V, '/w')
-    Assert.deepEqual(V, {
+    Assert.isEqual(V, {
       x: { x: 1, y: 2, z: 3 },
       y: { x: 3, y: 4, z: 5 },
     })
@@ -322,19 +322,19 @@ describe('value/pointer/Pointer', () => {
   it('Should not delete owner', () => {
     const V = { x: { y: { z: 1 } } }
     ValuePointer.Delete(V, '/x/y/z')
-    Assert.deepEqual(V, { x: { y: {} } })
+    Assert.isEqual(V, { x: { y: {} } })
   })
 
   it('Should delete owner', () => {
     const V = { x: { y: { z: 1 } } }
     ValuePointer.Delete(V, '/x/y')
-    Assert.deepEqual(V, { x: {} })
+    Assert.isEqual(V, { x: {} })
   })
 
   it('Should not throw if deleting null property', () => {
     const V = { x: { y: null } }
     ValuePointer.Delete(V, '/x/y/z')
-    Assert.deepEqual(V, { x: { y: null } })
+    Assert.isEqual(V, { x: { y: null } })
   })
 
   //-----------------------------------------------
@@ -345,14 +345,14 @@ describe('value/pointer/Pointer', () => {
     const V = {
       x: { '~': { x: 1 } },
     }
-    Assert.deepEqual(ValuePointer.Get(V, '/x/~0'), { x: 1 })
+    Assert.isEqual(ValuePointer.Get(V, '/x/~0'), { x: 1 })
   })
 
   it('Should support get ~1 pointer escape', () => {
     const V = {
       x: { '/': { x: 1 } },
     }
-    Assert.deepEqual(ValuePointer.Get(V, '/x/~1'), { x: 1 })
+    Assert.isEqual(ValuePointer.Get(V, '/x/~1'), { x: 1 })
   })
 
   it('Should support set ~0 pointer escape', () => {
@@ -360,7 +360,7 @@ describe('value/pointer/Pointer', () => {
       x: { '~': { x: 1 } },
     }
     ValuePointer.Set(V, '/x/~0', { x: 2 })
-    Assert.deepEqual(V, {
+    Assert.isEqual(V, {
       x: { '~': { x: 2 } },
     })
   })
@@ -370,7 +370,7 @@ describe('value/pointer/Pointer', () => {
       x: { '/': { x: 1 } },
     }
     ValuePointer.Set(V, '/x/~1', { x: 2 })
-    Assert.deepEqual(V, {
+    Assert.isEqual(V, {
       x: { '/': { x: 2 } },
     })
   })
@@ -380,7 +380,7 @@ describe('value/pointer/Pointer', () => {
       x: { '~': { x: 1 } },
     }
     ValuePointer.Delete(V, '/x/~0')
-    Assert.deepEqual(V, {
+    Assert.isEqual(V, {
       x: {},
     })
   })
@@ -390,7 +390,7 @@ describe('value/pointer/Pointer', () => {
       x: { '/': { x: 1 } },
     }
     ValuePointer.Delete(V, '/x/~1')
-    Assert.deepEqual(V, {
+    Assert.isEqual(V, {
       x: {},
     })
   })
diff --git a/test/static/index.ts b/test/static/index.ts
index 2d551c739..7cb57c759 100644
--- a/test/static/index.ts
+++ b/test/static/index.ts
@@ -34,6 +34,7 @@ import './record'
 import './ref'
 import './regex'
 import './required'
+import './rest'
 import './return-type'
 import './strict'
 import './string'
diff --git a/test/static/indexed.ts b/test/static/indexed.ts
index 7e12c017c..01ee8758e 100644
--- a/test/static/indexed.ts
+++ b/test/static/indexed.ts
@@ -27,3 +27,24 @@ import { Type, Static } from '@sinclair/typebox'
   const I = Type.Index(T, Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])]))
   Expect(I).ToInfer<number | string>()
 }
+{
+  const A = Type.Tuple([Type.String(), Type.Boolean()])
+
+  const R = Type.Index(A, Type.Number())
+
+  Expect(R).ToInfer<string | boolean>()
+}
+{
+  const A = Type.Tuple([Type.String()])
+
+  const R = Type.Index(A, Type.Number())
+
+  Expect(R).ToInfer<string>()
+}
+{
+  const A = Type.Tuple([])
+
+  const R = Type.Index(A, Type.Number())
+
+  Expect(R).ToInfer<never>()
+}
diff --git a/test/static/rest.ts b/test/static/rest.ts
new file mode 100644
index 000000000..129e22aa4
--- /dev/null
+++ b/test/static/rest.ts
@@ -0,0 +1,36 @@
+import { Expect } from './assert'
+import { Type, Static } from '@sinclair/typebox'
+
+{
+  const A = Type.Tuple([Type.Literal(1), Type.Literal(2)])
+  const B = Type.Tuple([Type.Literal(3), Type.Literal(4)])
+  const C = Type.Tuple([...Type.Rest(A), ...Type.Rest(B)])
+  Expect(C).ToInfer<[1, 2, 3, 4]>()
+}
+{
+  const A = Type.String()
+  const B = Type.Tuple([Type.Literal(3), Type.Literal(4)])
+  const C = Type.Tuple([...Type.Rest(A), ...Type.Rest(B)])
+  Expect(C).ToInfer<[string, 3, 4]>()
+}
+{
+  const A = Type.Tuple([Type.Literal(1), Type.Literal(2)])
+  const B = Type.String()
+  const C = Type.Tuple([...Type.Rest(A), ...Type.Rest(B)])
+  Expect(C).ToInfer<[1, 2, string]>()
+}
+{
+  const A = Type.Tuple([Type.Literal(1), Type.Literal(2)])
+  const B = Type.Union(Type.Rest(A))
+  Expect(B).ToInfer<1 | 2>()
+}
+{
+  const A = Type.Tuple([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
+  const B = Type.Intersect(Type.Rest(A))
+  Expect(B).ToInfer<{ x: number } & { y: number }>()
+}
+{
+  const A = Type.Tuple([Type.Literal(1), Type.Literal(2)])
+  const B = Type.Function(Type.Rest(A), Type.Null())
+  Expect(B).ToInfer<(a: 1, b: 2) => null>()
+}

From 11b09a1e0550c67ba5fa4f07483a82e0685cf884 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 22 Apr 2023 08:49:28 +0900
Subject: [PATCH 114/369] Revision 0.28.4 (#407)

---
 package-lock.json                  |  4 +-
 package.json                       |  2 +-
 readme.md                          | 10 ++--
 src/typebox.ts                     | 77 +++++++++++++++----------
 test/runtime/type/guard/indexed.ts | 93 +++++++++++++++++++++---------
 test/runtime/type/guard/record.ts  | 58 +++++++++++--------
 6 files changed, 155 insertions(+), 89 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 7429ae097..4213c74c8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.3",
+  "version": "0.28.4",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.3",
+      "version": "0.28.4",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 89382d651..ad4c5c940 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.3",
+  "version": "0.28.4",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 7c0fc9e57..9392ee2e9 100644
--- a/readme.md
+++ b/readme.md
@@ -1476,11 +1476,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '126.7 kb' │ ' 56.6 kb' │  '2.24 x'   │
-│ typebox/errors       │ '110.4 kb' │ ' 48.8 kb' │  '2.26 x'   │
-│ typebox/system       │ ' 75.9 kb' │ ' 31.1 kb' │  '2.44 x'   │
-│ typebox/value        │ '176.4 kb' │ ' 76.4 kb' │  '2.31 x'   │
-│ typebox              │ ' 74.8 kb' │ ' 30.7 kb' │  '2.44 x'   │
+│ typebox/compiler     │ '127.1 kb' │ ' 56.7 kb' │  '2.24 x'   │
+│ typebox/errors       │ '110.9 kb' │ ' 48.9 kb' │  '2.27 x'   │
+│ typebox/system       │ ' 76.3 kb' │ ' 31.2 kb' │  '2.44 x'   │
+│ typebox/value        │ '176.8 kb' │ ' 76.5 kb' │  '2.31 x'   │
+│ typebox              │ ' 75.2 kb' │ ' 30.8 kb' │  '2.44 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/typebox.ts b/src/typebox.ts
index e95c3cdc2..d96f99d71 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -73,7 +73,7 @@ export type TReadonlyOptional<T extends TSchema> = T & { [Modifier]: 'ReadonlyOp
 // --------------------------------------------------------------------------
 // Key
 // --------------------------------------------------------------------------
-export type Key = keyof any
+export type Key = string | number
 // --------------------------------------------------------------------------
 // TSchema
 // --------------------------------------------------------------------------
@@ -310,21 +310,20 @@ export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends T
 // --------------------------------------------------------------------------
 // TIndex
 // --------------------------------------------------------------------------
-export type IndexKey = keyof any
 // prettier-ignore
-export type TIndexProperty<T extends TProperties, K extends IndexKey> = 
-  K extends keyof T ? [T[K]] : 
+export type TIndexProperty<T extends TProperties, K extends Key> = 
+  T[K] extends infer R ? [R] :
   []
 // prettier-ignore
-export type TIndexTuple<T extends TSchema[], K extends IndexKey> = 
+export type TIndexTuple<T extends TSchema[], K extends Key> = 
   K extends keyof T ? [T[K]] : 
   []
 // prettier-ignore
-export type TIndexComposite<T extends TSchema[], K extends IndexKey> = 
+export type TIndexComposite<T extends TSchema[], K extends Key> = 
   T extends [infer L, ...infer R] ? [...TIndexKey<AssertType<L>, K>, ...TIndexComposite<AssertRest<R>, K>] : 
   []
 // prettier-ignore
-export type TIndexKey<T extends TSchema, K extends IndexKey> = 
+export type TIndexKey<T extends TSchema, K extends Key> = 
   T extends TRecursive<infer S> ? TIndexKey<S, K> :
   T extends TIntersect<infer S> ? TIndexComposite<S, K> :
   T extends TUnion<infer S>     ? TIndexComposite<S, K> :
@@ -333,11 +332,12 @@ export type TIndexKey<T extends TSchema, K extends IndexKey> =
   T extends TArray<infer S>     ? S :
   []
 // prettier-ignore
-export type TIndexKeys<T extends TSchema, K extends IndexKey[]> = 
-  K extends [infer L, ...infer R] ? [...TIndexKey<T, Assert<L, IndexKey>>, ...TIndexKeys<T, Assert<R, IndexKey[]>>] : 
+export type TIndexKeys<T extends TSchema, K extends Key[]> = 
+  K extends [infer L, ...infer R] ? 
+    [...TIndexKey<T, Assert<L, Key>>, ...TIndexKeys<T, Assert<R, Key[]>>] : 
   []
 // prettier-ignore
-export type TIndex<T extends TSchema, K extends IndexKey[]> = 
+export type TIndex<T extends TSchema, K extends Key[]> = 
   TIndexKeys<T, K> extends infer R ?
     T extends TRecursive<infer S> ? TIndex<S, K> :
     T extends TTuple              ? UnionType<AssertRest<R>> :
@@ -540,7 +540,7 @@ export interface TPromise<T extends TSchema = TSchema> extends TSchema {
 // --------------------------------------------------------------------------
 export type RecordTemplateLiteralObjectType<K extends TTemplateLiteral, T extends TSchema> = Ensure<TObject<Evaluate<{ [_ in Static<K>]: T }>>>
 export type RecordTemplateLiteralType<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends true ? RecordTemplateLiteralObjectType<K, T> : TRecord<K, T>
-export type RecordUnionLiteralType<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema> = Static<K> extends string ? Ensure<TObject<{ [X in Static<K>]: T }>> : never
+export type RecordUnionLiteralType<K extends TUnion, T extends TSchema> = Static<K> extends string ? Ensure<TObject<{ [X in Static<K>]: T }>> : never
 export type RecordLiteralType<K extends TLiteral<string | number>, T extends TSchema> = Ensure<TObject<{ [K2 in K['const']]: T }>>
 export type RecordNumberType<K extends TInteger | TNumber, T extends TSchema> = Ensure<TRecord<K, T>>
 export type RecordStringType<K extends TString, T extends TSchema> = Ensure<TRecord<K, T>>
@@ -1045,9 +1045,9 @@ export namespace TypeGuard {
   export function TLiteralBoolean(schema: unknown): schema is TLiteral<boolean> {
     return TKind(schema) && schema[Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'boolean'
   }
-  /** Returns true if the given schema is TUnion<Literal<string>[]> */
-  export function TLiteralUnion(schema: unknown): schema is TUnion<TLiteral<string>[]> {
-    return TUnion(schema) && schema.anyOf.every((schema) => TLiteral(schema))
+  /** Returns true if the given schema is TUnion<Literal<string | number>[]> */
+  export function TLiteralUnion(schema: unknown): schema is TUnion<TLiteral[]> {
+    return TUnion(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema))
   }
   /** Returns true if the given schema is TLiteral */
   export function TLiteral(schema: unknown): schema is TLiteral {
@@ -1924,12 +1924,12 @@ export namespace IndexedAccessor {
     return schema.anyOf.reduce((acc, schema) => [...acc, ...Visit(schema, key)], [] as TSchema[])
   }
   function Object(schema: TObject, key: string): TSchema[] {
-    const keys = globalThis.Object.getOwnPropertyNames(schema.properties).filter((k) => k === key)
+    const keys = globalThis.Object.getOwnPropertyNames(schema.properties).filter((key_) => key_ === key)
     return keys.map((key) => schema.properties[key])
   }
   function Tuple(schema: TTuple, key: string): TSchema[] {
     const items = schema.items === undefined ? [] : (schema.items as TSchema[])
-    return items.filter((_, index) => index.toString() === key.toString())
+    return items.filter((_, index) => index.toString() === key)
   }
   function Visit(schema: TSchema, key: string): TSchema[] {
     if (schema[Kind] === 'Intersect') return Intersect(schema as TIntersect, key)
@@ -1938,8 +1938,8 @@ export namespace IndexedAccessor {
     if (schema[Kind] === 'Tuple') return Tuple(schema as TTuple, key)
     return []
   }
-  export function Resolve(schema: TSchema, keys: string[]): TSchema[] {
-    return keys.reduce((acc, key) => [...acc, ...Visit(schema, key)], [] as TSchema[])
+  export function Resolve(schema: TSchema, keys: (string | number)[]): TSchema[] {
+    return keys.reduce((acc, key) => [...acc, ...Visit(schema, key.toString())], [] as TSchema[])
   }
 }
 // --------------------------------------------------------------------------
@@ -2019,7 +2019,7 @@ export namespace KeyArrayResolver {
   /** Resolves an array of string[] keys from the given schema or array type. */
   export function Resolve(schema: TSchema | string[]): string[] {
     if (globalThis.Array.isArray(schema)) return schema
-    if (TypeGuard.TLiteralUnion(schema)) return schema.anyOf.map((schema) => schema.const)
+    if (TypeGuard.TLiteralUnion(schema)) return schema.anyOf.map((schema) => schema.const.toString())
     if (TypeGuard.TLiteral(schema)) return [schema.const as string]
     if (TypeGuard.TTemplateLiteral(schema)) {
       const expression = TemplateLiteralParser.ParseExact(schema.pattern)
@@ -2030,6 +2030,24 @@ export namespace KeyArrayResolver {
   }
 }
 // --------------------------------------------------------------------------
+// UnionResolver
+// --------------------------------------------------------------------------
+export namespace UnionResolver {
+  function* Union(union: TUnion): IterableIterator<TSchema> {
+    for (const schema of union.anyOf) {
+      if (schema[Kind] === 'Union') {
+        yield* Union(schema as TUnion)
+      } else {
+        yield schema
+      }
+    }
+  }
+  /** Returns a resolved union with interior unions flattened */
+  export function Resolve(union: TUnion): TUnion {
+    return Type.Union([...Union(union)], { ...union })
+  }
+}
+// --------------------------------------------------------------------------
 // TemplateLiteralPattern
 // --------------------------------------------------------------------------
 export namespace TemplateLiteralPattern {
@@ -2389,11 +2407,11 @@ export class StandardTypeBuilder extends TypeBuilder {
     }
   }
   /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, K>
+  public Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, Key[]>>
   /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TSchema, K extends TUnion<TLiteral<string | number>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TLiteralUnion<K>>
+  public Index<T extends TSchema, K extends TUnion<TLiteral<Key>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TLiteralUnion<K>>
   /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TSchema, K extends TLiteral<string | number>>(schema: T, key: K, options?: SchemaOptions): TIndex<T, [K['const']]>
+  public Index<T extends TSchema, K extends TLiteral<Key>>(schema: T, key: K, options?: SchemaOptions): TIndex<T, [K['const']]>
   /** `[Standard]` Returns indexed property types for the given keys */
   public Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyArray<K>>
   /** `[Standard]` Returns indexed property types for the given keys */
@@ -2559,7 +2577,7 @@ export class StandardTypeBuilder extends TypeBuilder {
     }, options)
   }
   /** `[Standard]` Creates a Record type */
-  public Record<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordUnionLiteralType<K, T>
+  public Record<K extends TUnion, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordUnionLiteralType<K, T>
   /** `[Standard]` Creates a Record type */
   public Record<K extends TLiteral<string | number>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordLiteralType<K, T>
   /** `[Standard]` Creates a Record type */
@@ -2576,15 +2594,16 @@ export class StandardTypeBuilder extends TypeBuilder {
       return TemplateLiteralFinite.Check(expression)
         ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(schema, {}) }), {} as TProperties), options))
         : this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema, {}) }})
-    } else if (TypeGuard.TLiteralUnion(key)) {
-      if (key.anyOf.every((schema) => TypeGuard.TLiteral(schema) && (typeof schema.const === 'string' || typeof schema.const === 'number'))) {
-        const properties = key.anyOf.reduce((acc: any, literal: any) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {} as TProperties)
+    } else if (TypeGuard.TUnion(key)) {
+      const union = UnionResolver.Resolve(key)
+      if (TypeGuard.TLiteralUnion(union)) {
+        const properties = union.anyOf.reduce((acc: any, literal: any) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {} as TProperties)
         return this.Object(properties, { ...options, [Hint]: 'Record' })
-      } else throw Error('TypeBuilder: Record key can only be derived from union literal of number or string')
+      } else throw Error('TypeBuilder: Record key of type union contains non-literal types')
     } else if (TypeGuard.TLiteral(key)) {
       if (typeof key.const === 'string' || typeof key.const === 'number') {
         return this.Object({ [key.const]: TypeClone.Clone(schema, {}) }, options)
-      } else throw Error('TypeBuilder: Record key can only be derived from literals of number or string')
+      } else throw Error('TypeBuilder: Record key of type literal is not of type string or number')
     } else if (TypeGuard.TInteger(key) || TypeGuard.TNumber(key)) {
       const pattern = PatternNumberExact
       return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) } })
@@ -2592,7 +2611,7 @@ export class StandardTypeBuilder extends TypeBuilder {
       const pattern = key.pattern === undefined ? PatternStringExact : key.pattern
       return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) } })
     } else {
-      throw Error(`StandardTypeBuilder: Invalid Record Key`)
+      throw Error(`StandardTypeBuilder: Record key is an invalid type`)
     }
   }
   /** `[Standard]` Creates a Recursive type */
diff --git a/test/runtime/type/guard/indexed.ts b/test/runtime/type/guard/indexed.ts
index 15eeaa08b..f648ba708 100644
--- a/test/runtime/type/guard/indexed.ts
+++ b/test/runtime/type/guard/indexed.ts
@@ -9,7 +9,7 @@ describe('type/guard/TIndex', () => {
       y: Type.String(),
     })
     const I = Type.Index(T, ['x'])
-    Assert.isEqual(TypeGuard.TNumber(I), true)
+    Assert.isTrue(TypeGuard.TNumber(I))
   })
   it('Should Index 2', () => {
     const T = Type.Object({
@@ -17,9 +17,9 @@ describe('type/guard/TIndex', () => {
       y: Type.String(),
     })
     const I = Type.Index(T, ['x', 'y'])
-    Assert.isEqual(TypeGuard.TUnion(I), true)
-    Assert.isEqual(TypeGuard.TNumber(I.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
+    Assert.isTrue(TypeGuard.TUnion(I))
+    Assert.isTrue(TypeGuard.TNumber(I.anyOf[0]))
+    Assert.isTrue(TypeGuard.TString(I.anyOf[1]))
   })
   it('Should Index 3', () => {
     const T = Type.Object({
@@ -27,9 +27,9 @@ describe('type/guard/TIndex', () => {
       y: Type.String(),
     })
     const I = Type.Index(T, Type.KeyOf(T))
-    Assert.isEqual(TypeGuard.TUnion(I), true)
-    Assert.isEqual(TypeGuard.TNumber(I.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
+    Assert.isTrue(TypeGuard.TUnion(I))
+    Assert.isTrue(TypeGuard.TNumber(I.anyOf[0]))
+    Assert.isTrue(TypeGuard.TString(I.anyOf[1]))
   })
   it('Should Index 4', () => {
     const T = Type.Object({
@@ -37,59 +37,59 @@ describe('type/guard/TIndex', () => {
       ac: Type.String(),
     })
     const I = Type.Index(T, Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])]))
-    Assert.isEqual(TypeGuard.TUnion(I), true)
-    Assert.isEqual(TypeGuard.TNumber(I.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
+    Assert.isTrue(TypeGuard.TUnion(I))
+    Assert.isTrue(TypeGuard.TNumber(I.anyOf[0]))
+    Assert.isTrue(TypeGuard.TString(I.anyOf[1]))
   })
   it('Should Index 5', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.String() })])
     const I = Type.Index(T, ['x', 'y'])
-    Assert.isEqual(TypeGuard.TUnion(I), true)
-    Assert.isEqual(TypeGuard.TNumber(I.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
+    Assert.isTrue(TypeGuard.TUnion(I))
+    Assert.isTrue(TypeGuard.TNumber(I.anyOf[0]))
+    Assert.isTrue(TypeGuard.TString(I.anyOf[1]))
   })
   it('Should Index 6', () => {
     const T = Type.Union([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.String() })])
     const I = Type.Index(T, ['x'])
-    Assert.isEqual(TypeGuard.TUnion(I), true)
-    Assert.isEqual(TypeGuard.TNumber(I.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
+    Assert.isTrue(TypeGuard.TUnion(I))
+    Assert.isTrue(TypeGuard.TNumber(I.anyOf[0]))
+    Assert.isTrue(TypeGuard.TString(I.anyOf[1]))
   })
   it('Should Index 7', () => {
     const T = Type.Array(Type.Null())
     const I = Type.Index(T, Type.Number())
-    Assert.isEqual(TypeGuard.TNull(I), true)
+    Assert.isTrue(TypeGuard.TNull(I))
   })
   it('Should Index 6', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [0])
-    Assert.isEqual(TypeGuard.TLiteralString(I), true)
+    Assert.isTrue(TypeGuard.TLiteralString(I))
     Assert.isEqual(I.const, 'hello')
   })
   it('Should Index 8', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [1])
-    Assert.isEqual(TypeGuard.TLiteralString(I), true)
+    Assert.isTrue(TypeGuard.TLiteralString(I))
     Assert.isEqual(I.const, 'world')
   })
   it('Should Index 9', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [0, 1])
-    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isTrue(TypeGuard.TUnion(I))
     Assert.isEqual(I.anyOf[0].const, 'hello')
     Assert.isEqual(I.anyOf[1].const, 'world')
   })
   it('Should Index 10', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [1, 0])
-    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isTrue(TypeGuard.TUnion(I))
     Assert.isEqual(I.anyOf[0].const, 'world')
     Assert.isEqual(I.anyOf[1].const, 'hello')
   })
   it('Should Index 11', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [0, 0, 0, 1])
-    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isTrue(TypeGuard.TUnion(I))
     Assert.isEqual(I.anyOf[0].const, 'hello')
     Assert.isEqual(I.anyOf[1].const, 'hello')
     Assert.isEqual(I.anyOf[2].const, 'hello')
@@ -98,18 +98,57 @@ describe('type/guard/TIndex', () => {
   it('Should Index 12', () => {
     const T = Type.Tuple([Type.String(), Type.Boolean()])
     const I = Type.Index(T, Type.Number())
-    Assert.isEqual(TypeGuard.TUnion(I), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TBoolean(I.anyOf[1]), true)
+    Assert.isTrue(TypeGuard.TUnion(I))
+    Assert.isTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.isTrue(TypeGuard.TBoolean(I.anyOf[1]))
   })
   it('Should Index 13', () => {
     const T = Type.Tuple([Type.String()])
     const I = Type.Index(T, Type.Number())
-    Assert.isEqual(TypeGuard.TString(I), true)
+    Assert.isTrue(TypeGuard.TString(I))
   })
   it('Should Index 14', () => {
     const T = Type.Tuple([])
     const I = Type.Index(T, Type.Number())
-    Assert.isEqual(TypeGuard.TNever(I), true)
+    Assert.isTrue(TypeGuard.TNever(I))
+  })
+  it('Should Index 15', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+    })
+    const I = Type.Index(T, Type.Literal(0))
+    Assert.isTrue(TypeGuard.TNumber(I))
+  })
+  it('Should Index 16', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+    })
+    const I = Type.Index(T, Type.Literal('0'))
+    Assert.isTrue(TypeGuard.TNumber(I))
+  })
+  it('Should Index 17', () => {
+    const T = Type.Object({
+      '0': Type.Number(),
+    })
+    const I = Type.Index(T, Type.Literal(0))
+    Assert.isTrue(TypeGuard.TNumber(I))
+  })
+  it('Should Index 18', () => {
+    const T = Type.Object({
+      '0': Type.Number(),
+    })
+    const I = Type.Index(T, Type.Literal('0'))
+    Assert.isTrue(TypeGuard.TNumber(I))
+  })
+  it('Should Index 19', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+      1: Type.String(),
+      2: Type.Boolean(),
+    })
+    const I = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal(2)]))
+    Assert.isTrue(TypeGuard.TUnion(I))
+    Assert.isTrue(TypeGuard.TNumber(I.anyOf[0]))
+    Assert.isTrue(TypeGuard.TBoolean(I.anyOf[1]))
   })
 })
diff --git a/test/runtime/type/guard/record.ts b/test/runtime/type/guard/record.ts
index 350f9b3fc..94bea05ec 100644
--- a/test/runtime/type/guard/record.ts
+++ b/test/runtime/type/guard/record.ts
@@ -8,15 +8,15 @@ describe('type/guard/TRecord', () => {
   // -------------------------------------------------------------
   it('Should guard overload 1', () => {
     const T = Type.Record(Type.Union([Type.Literal('A'), Type.Literal('B')]), Type.String(), { extra: 1 })
-    Assert.isEqual(TypeGuard.TObject(T), true)
-    Assert.isEqual(TypeGuard.TString(T.properties.A), true)
-    Assert.isEqual(TypeGuard.TString(T.properties.B), true)
+    Assert.isTrue(TypeGuard.TObject(T))
+    Assert.isTrue(TypeGuard.TString(T.properties.A))
+    Assert.isTrue(TypeGuard.TString(T.properties.B))
     Assert.isEqual(T.extra, 1)
   })
   it('Should guard overload 2', () => {
     const T = Type.Record(Type.Union([Type.Literal('A')]), Type.String(), { extra: 1 }) // unwrap as literal
-    Assert.isEqual(TypeGuard.TObject(T), true)
-    Assert.isEqual(TypeGuard.TString(T.properties.A), true)
+    Assert.isTrue(TypeGuard.TObject(T))
+    Assert.isTrue(TypeGuard.TString(T.properties.A))
     Assert.isEqual(T.extra, 1)
   })
   it('Should guard overload 3', () => {
@@ -25,49 +25,57 @@ describe('type/guard/TRecord', () => {
   })
   it('Should guard overload 4', () => {
     const T = Type.Record(Type.Literal('A'), Type.String(), { extra: 1 })
-    Assert.isEqual(TypeGuard.TObject(T), true)
-    Assert.isEqual(TypeGuard.TString(T.properties.A), true)
+    Assert.isTrue(TypeGuard.TObject(T))
+    Assert.isTrue(TypeGuard.TString(T.properties.A))
     Assert.isEqual(T.extra, 1)
   })
   it('Should guard overload 5', () => {
     const L = Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal('A'), Type.Literal('B')])])
     const T = Type.Record(L, Type.String(), { extra: 1 })
-    Assert.isEqual(TypeGuard.TObject(T), true)
-    Assert.isEqual(TypeGuard.TString(T.properties.helloA), true)
-    Assert.isEqual(TypeGuard.TString(T.properties.helloB), true)
+    Assert.isTrue(TypeGuard.TObject(T))
+    Assert.isTrue(TypeGuard.TString(T.properties.helloA))
+    Assert.isTrue(TypeGuard.TString(T.properties.helloB))
     Assert.isEqual(T.extra, 1)
   })
   it('Should guard overload 6', () => {
     const T = Type.Record(Type.Number(), Type.String(), { extra: 1 })
-    Assert.isEqual(TypeGuard.TRecord(T), true)
-    Assert.isEqual(TypeGuard.TString(T.patternProperties[PatternNumberExact]), true)
+    Assert.isTrue(TypeGuard.TRecord(T))
+    Assert.isTrue(TypeGuard.TString(T.patternProperties[PatternNumberExact]))
     Assert.isEqual(T.extra, 1)
   })
   it('Should guard overload 7', () => {
     const T = Type.Record(Type.Integer(), Type.String(), { extra: 1 })
-    Assert.isEqual(TypeGuard.TRecord(T), true)
-    Assert.isEqual(TypeGuard.TString(T.patternProperties[PatternNumberExact]), true)
+    Assert.isTrue(TypeGuard.TRecord(T))
+    Assert.isTrue(TypeGuard.TString(T.patternProperties[PatternNumberExact]))
     Assert.isEqual(T.extra, 1)
   })
   it('Should guard overload 8', () => {
     const T = Type.Record(Type.String(), Type.String(), { extra: 1 })
-    Assert.isEqual(TypeGuard.TRecord(T), true)
-    Assert.isEqual(TypeGuard.TString(T.patternProperties[PatternStringExact]), true)
+    Assert.isTrue(TypeGuard.TRecord(T))
+    Assert.isTrue(TypeGuard.TString(T.patternProperties[PatternStringExact]))
     Assert.isEqual(T.extra, 1)
   })
   it('Should guard overload 9', () => {
     const L = Type.TemplateLiteral([Type.String(), Type.Literal('_foo')])
     const T = Type.Record(L, Type.String(), { extra: 1 })
-    Assert.isEqual(TypeGuard.TRecord(T), true)
-    Assert.isEqual(TypeGuard.TString(T.patternProperties[`^${PatternString}_foo$`]), true)
+    Assert.isTrue(TypeGuard.TRecord(T))
+    Assert.isTrue(TypeGuard.TString(T.patternProperties[`^${PatternString}_foo$`]))
     Assert.isEqual(T.extra, 1)
   })
+  it('Should guard overload 10', () => {
+    const L = Type.Union([Type.Literal('A'), Type.Union([Type.Literal('B'), Type.Literal('C')])])
+    const T = Type.Record(L, Type.String())
+    Assert.isTrue(TypeGuard.TObject(T))
+    Assert.isTrue(TypeGuard.TString(T.properties.A))
+    Assert.isTrue(TypeGuard.TString(T.properties.B))
+    Assert.isTrue(TypeGuard.TString(T.properties.C))
+  })
   // -------------------------------------------------------------
   // Variants
   // -------------------------------------------------------------
   it('Should guard for TRecord', () => {
     const R = TypeGuard.TRecord(Type.Record(Type.String(), Type.Number()))
-    Assert.isEqual(R, true)
+    Assert.isTrue(R)
   })
   it('Should guard for TRecord with TObject value', () => {
     const R = TypeGuard.TRecord(
@@ -79,16 +87,16 @@ describe('type/guard/TRecord', () => {
         }),
       ),
     )
-    Assert.isEqual(R, true)
+    Assert.isTrue(R)
   })
   it('Should not guard for TRecord', () => {
     const R = TypeGuard.TRecord(null)
-    Assert.isEqual(R, false)
+    Assert.isFalse(R)
   })
   it('Should not guard for TRecord with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TRecord(Type.Record(Type.String(), Type.Number(), { $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.isFalse(R)
   })
   it('Should not guard for TRecord with TObject value with invalid Property', () => {
     const R = TypeGuard.TRecord(
@@ -100,16 +108,16 @@ describe('type/guard/TRecord', () => {
         }),
       ),
     )
-    Assert.isEqual(R, false)
+    Assert.isFalse(R)
   })
   it('Transform: Should should transform to TObject for single literal union value', () => {
     const K = Type.Union([Type.Literal('ok')])
     const R = TypeGuard.TObject(Type.Record(K, Type.Number()))
-    Assert.isEqual(R, true)
+    Assert.isTrue(R)
   })
   it('Transform: Should should transform to TObject for multi literal union value', () => {
     const K = Type.Union([Type.Literal('A'), Type.Literal('B')])
     const R = TypeGuard.TObject(Type.Record(K, Type.Number()))
-    Assert.isEqual(R, true)
+    Assert.isTrue(R)
   })
 })

From 376e482737bd915460f122c95c66482b77fa9416 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sat, 22 Apr 2023 15:09:32 +0900
Subject: [PATCH 115/369] Revision 0.28.4

---
 readme.md | 41 +++++++++++++++++++++++++++--------------
 1 file changed, 27 insertions(+), 14 deletions(-)

diff --git a/readme.md b/readme.md
index 9392ee2e9..a36722e49 100644
--- a/readme.md
+++ b/readme.md
@@ -83,7 +83,7 @@ License MIT
   - [Conditional](#types-conditional)
   - [Template](#types-template-literal)
   - [Indexed](#types-indexed)
-  - [Variadic](#types-variadic)
+  - [Rest](#types-rest)
   - [Guards](#types-guards)
   - [Unsafe](#types-unsafe)
   - [Strict](#types-strict)
@@ -872,30 +872,43 @@ const A = Type.Index(T, ['x'])                       // type A = T['x']
 
 const B = Type.Index(T, Type.KeyOf(T))               // type B = T[keyof T]
 ```
-<a name='types-variadic'></a>
+<a name='types-rest'></a>
 
-### Variadic Types
+### Rest Types
 
-Variadic types are supported with `Type.Rest`. This type will extract interior types from a tuple and return them as a flat array. This array can then be passed to other types that accept arrays as arguments.
-
-The following creates variadic functions using the Rest type.
+Rest parameters are supported with `Type.Rest`. This function is used to extract interior arrays from tuples to allow them to compose with the JavaScript spread operator `...`. This type can be used for tuple concatination and variadic function composition.
 
 ```typescript
 // TypeScript
 
-type P = [number, number]
+type T = [number, number]                            // type T = [number, number]
 
-type F1 = (param: [...P]) => void
+type C = [...T, number]                              // type C = [number, number, number]
 
-type F2 = (param: [...P, number]) => void
+type F = (...param: C) => void                       // type F = (
+                                                     //   param0: number,
+                                                     //   param1: number,
+                                                     //   param2: number,
+                                                     // ) => void
 
 // TypeBox
 
-const P = Type.Tuple([Type.Number(), Type.Number()])
-
-const F1 = Type.Function(Type.Rest(P), Type.Void())
-
-const F2 = Type.Function([...Type.Rest(P), Type.Number()], Type.Void())
+const T = Type.Tuple([                               // const T: TTuple<[
+  Type.Number(),                                     //   TNumber,
+  Type.Number()                                      //   TNumber,
+])                                                   // ]>
+
+const C = Type.Tuple([                               // const C: TTuple<[
+  ...Type.Rest(T),                                   //   TNumber,
+  Type.Number()                                      //   TNumber,
+])                                                   //   TNumber
+                                                     // ]>
+
+const F = Type.Function(Type.Rest(C), Type.Void())   // const F: TFunction<[
+                                                     //   TNumber,
+                                                     //   TNumber,
+                                                     //   TNumber
+                                                     // ], TVoid>
 ```
 <a name='types-unsafe'></a>
 

From 35b1bb9ec931d71a71ff12ae32eebcdbad4812b6 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 23 Apr 2023 13:48:01 +0900
Subject: [PATCH 116/369] Revision 0.28.5 (#409)

---
 package-lock.json                  |  4 +-
 package.json                       |  2 +-
 src/typebox.ts                     | 60 +++++++++++++++---------------
 test/runtime/type/guard/indexed.ts | 18 +++++++++
 test/static/indexed.ts             | 14 +++++++
 5 files changed, 66 insertions(+), 32 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 4213c74c8..1ccf314c6 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.4",
+  "version": "0.28.5",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.4",
+      "version": "0.28.5",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index ad4c5c940..a34bb2f43 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.4",
+  "version": "0.28.5",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index d96f99d71..21df62331 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -337,9 +337,9 @@ export type TIndexKeys<T extends TSchema, K extends Key[]> =
     [...TIndexKey<T, Assert<L, Key>>, ...TIndexKeys<T, Assert<R, Key[]>>] : 
   []
 // prettier-ignore
-export type TIndex<T extends TSchema, K extends Key[]> = 
+export type TIndexFromKeyTuple<T extends TSchema, K extends Key[]> = 
   TIndexKeys<T, K> extends infer R ?
-    T extends TRecursive<infer S> ? TIndex<S, K> :
+    T extends TRecursive<infer S> ? TIndexFromKeyTuple<S, K> :
     T extends TTuple              ? UnionType<AssertRest<R>> :
     T extends TIntersect          ? UnionType<AssertRest<R>> :
     T extends TUnion              ? UnionType<AssertRest<R>> :
@@ -347,6 +347,14 @@ export type TIndex<T extends TSchema, K extends Key[]> =
     T extends TArray              ? UnionType<AssertRest<R>> :
     TNever : 
   TNever
+// prettier-ignore
+export type TIndex<T extends TSchema, K extends TSchema> =
+  [T, K] extends [TTuple, TNumber]  ? UnionType<Assert<T['items'], TSchema[]>> :  
+  [T, K] extends [TArray, TNumber]  ? AssertType<T['items']> :
+  K extends TTemplateLiteral        ? TIndexFromKeyTuple<T, TTemplateLiteralKeyTuple<K>> :
+  K extends TUnion<TLiteral<Key>[]> ? TIndexFromKeyTuple<T, TUnionLiteral<K>> :
+  K extends TLiteral<Key>           ? TIndexFromKeyTuple<T, [K['const']]> :
+  TNever
 // --------------------------------------------------------------------------
 // TInteger
 // --------------------------------------------------------------------------
@@ -679,7 +687,7 @@ export type TTemplateLiteralConst<T, Acc extends string> =
 export type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string = ''> = 
   T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` :
   Acc
-export type TTemplateLiteralKeyArray<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, Key[]>
+export type TTemplateLiteralKeyTuple<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, Key[]>
 export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
   [Kind]: 'TemplateLiteral'
   static: TTemplateLiteralUnion<T>
@@ -690,9 +698,12 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
 // TTuple
 // --------------------------------------------------------------------------
 export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? AssertRest<R> : never
+
+export type TTupleInfer<T extends TSchema[], P extends unknown[]> = T extends [infer L, ...infer R] ? [Static<AssertType<L>, P>, ...TTupleInfer<AssertRest<R>, P>] : []
+
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
   [Kind]: 'Tuple'
-  static: { [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : T[K] }
+  static: TTupleInfer<T, this['params']> // { [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : T[K] }
   type: 'array'
   items?: T
   additionalItems?: false
@@ -709,15 +720,16 @@ export interface TUndefined extends TSchema {
   typeOf: 'Undefined'
 }
 // --------------------------------------------------------------------------
-// TUnionOfLiteral
+// TUnionLiteral
 // --------------------------------------------------------------------------
 // prettier-ignore
 export type TLiteralUnionReduce<T extends TLiteral<string | number>[]> = 
   T extends [infer L, ...infer R] ? [Assert<L, TLiteral<string | number>>['const'], ...TLiteralUnionReduce<Assert<R, TLiteral<string | number>[]>>] : 
   []
 // prettier-ignore
-export type TLiteralUnion<T extends TUnion<TLiteral<string | number>[]>> = 
-  T extends TUnion<infer S> ? TLiteralUnionReduce<Assert<S, TLiteral<string | number>[]>> : []
+export type TUnionLiteral<T extends TUnion<TLiteral<string | number>[]>> = 
+  T extends TUnion<infer S> ? TLiteralUnionReduce<Assert<S, TLiteral<string | number>[]>> : 
+  []
 // --------------------------------------------------------------------------
 // TUnion
 // --------------------------------------------------------------------------
@@ -1045,10 +1057,6 @@ export namespace TypeGuard {
   export function TLiteralBoolean(schema: unknown): schema is TLiteral<boolean> {
     return TKind(schema) && schema[Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'boolean'
   }
-  /** Returns true if the given schema is TUnion<Literal<string | number>[]> */
-  export function TLiteralUnion(schema: unknown): schema is TUnion<TLiteral[]> {
-    return TUnion(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema))
-  }
   /** Returns true if the given schema is TLiteral */
   export function TLiteral(schema: unknown): schema is TLiteral {
     return TLiteralString(schema) || TLiteralNumber(schema) || TLiteralBoolean(schema)
@@ -1245,6 +1253,10 @@ export namespace TypeGuard {
       IsOptionalString(schema.$id)
     )
   }
+  /** Returns true if the given schema is TUnion<Literal<string | number>[]> */
+  export function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral[]> {
+    return TUnion(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema))
+  }
   /** Returns true if the given schema is TUnion */
   export function TUnion(schema: unknown): schema is TUnion {
     // prettier-ignore
@@ -2019,7 +2031,7 @@ export namespace KeyArrayResolver {
   /** Resolves an array of string[] keys from the given schema or array type. */
   export function Resolve(schema: TSchema | string[]): string[] {
     if (globalThis.Array.isArray(schema)) return schema
-    if (TypeGuard.TLiteralUnion(schema)) return schema.anyOf.map((schema) => schema.const.toString())
+    if (TypeGuard.TUnionLiteral(schema)) return schema.anyOf.map((schema) => schema.const.toString())
     if (TypeGuard.TLiteral(schema)) return [schema.const as string]
     if (TypeGuard.TTemplateLiteral(schema)) {
       const expression = TemplateLiteralParser.ParseExact(schema.pattern)
@@ -2407,19 +2419,9 @@ export class StandardTypeBuilder extends TypeBuilder {
     }
   }
   /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, Key[]>>
-  /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TSchema, K extends TUnion<TLiteral<Key>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TLiteralUnion<K>>
-  /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TSchema, K extends TLiteral<Key>>(schema: T, key: K, options?: SchemaOptions): TIndex<T, [K['const']]>
-  /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyArray<K>>
-  /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TTuple, K extends TNumber>(schema: T, key: K, options?: SchemaOptions): UnionType<Assert<T['items'], TSchema[]>>
-  /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TArray, K extends TNumber>(schema: T, key: K, options?: SchemaOptions): AssertType<T['items']>
+  public Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndexFromKeyTuple<T, Assert<K, Key[]>>
   /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TIndex<T, never>
+  public Index<T extends TSchema, K extends TSchema>(schema: T, key: K, options?: SchemaOptions): TIndex<T, K>
   /** `[Standard]` Returns indexed property types for the given keys */
   public Index(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
     const keys = KeyArrayResolver.Resolve(unresolved)
@@ -2513,11 +2515,11 @@ export class StandardTypeBuilder extends TypeBuilder {
   /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TOmit<T, K[number]>
   /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
-  public Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TLiteralUnion<K>[number]>
+  public Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionLiteral<K>[number]>
   /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TOmit<T, K['const']>
   /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
-  public Omit<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TOmit<T, TTemplateLiteralKeyArray<K>[number]>
+  public Omit<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TOmit<T, TTemplateLiteralKeyTuple<K>[number]>
   /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TOmit<T, never>
   public Omit(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
@@ -2555,11 +2557,11 @@ export class StandardTypeBuilder extends TypeBuilder {
   /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TPick<T, K[number]>
   /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
-  public Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TLiteralUnion<K>[number]>
+  public Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionLiteral<K>[number]>
   /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TPick<T, K['const']>
   /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
-  public Pick<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TPick<T, TTemplateLiteralKeyArray<K>[number]>
+  public Pick<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TPick<T, TTemplateLiteralKeyTuple<K>[number]>
   /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TPick<T, never>
   public Pick(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
@@ -2596,7 +2598,7 @@ export class StandardTypeBuilder extends TypeBuilder {
         : this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema, {}) }})
     } else if (TypeGuard.TUnion(key)) {
       const union = UnionResolver.Resolve(key)
-      if (TypeGuard.TLiteralUnion(union)) {
+      if (TypeGuard.TUnionLiteral(union)) {
         const properties = union.anyOf.reduce((acc: any, literal: any) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {} as TProperties)
         return this.Object(properties, { ...options, [Hint]: 'Record' })
       } else throw Error('TypeBuilder: Record key of type union contains non-literal types')
diff --git a/test/runtime/type/guard/indexed.ts b/test/runtime/type/guard/indexed.ts
index f648ba708..84683b5d8 100644
--- a/test/runtime/type/guard/indexed.ts
+++ b/test/runtime/type/guard/indexed.ts
@@ -151,4 +151,22 @@ describe('type/guard/TIndex', () => {
     Assert.isTrue(TypeGuard.TNumber(I.anyOf[0]))
     Assert.isTrue(TypeGuard.TBoolean(I.anyOf[1]))
   })
+  it('Should Index 20', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+      1: Type.String(),
+      2: Type.Boolean(),
+    })
+    const I = Type.Index(T, Type.BigInt())
+    Assert.isTrue(TypeGuard.TNever(I))
+  })
+  it('Should Index 21', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+      1: Type.String(),
+      2: Type.Boolean(),
+    })
+    const I = Type.Index(T, Type.Object({}))
+    Assert.isTrue(TypeGuard.TNever(I))
+  })
 })
diff --git a/test/static/indexed.ts b/test/static/indexed.ts
index 01ee8758e..629582bf6 100644
--- a/test/static/indexed.ts
+++ b/test/static/indexed.ts
@@ -48,3 +48,17 @@ import { Type, Static } from '@sinclair/typebox'
 
   Expect(R).ToInfer<never>()
 }
+{
+  const A = Type.Object({})
+
+  const R = Type.Index(A, Type.BigInt()) // Support Overload
+
+  Expect(R).ToInfer<never>()
+}
+{
+  const A = Type.Array(Type.Number())
+
+  const R = Type.Index(A, Type.BigInt()) // Support Overload
+
+  Expect(R).ToInfer<never>()
+}

From 1abe0bf417cd811225437ebba1e7f440c956a133 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 23 Apr 2023 14:03:25 +0900
Subject: [PATCH 117/369] License and Install Size Badges (#410)

---
 readme.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/readme.md b/readme.md
index a36722e49..dfd9c4629 100644
--- a/readme.md
+++ b/readme.md
@@ -11,6 +11,8 @@
 
 [![npm version](https://badge.fury.io/js/%40sinclair%2Ftypebox.svg)](https://badge.fury.io/js/%40sinclair%2Ftypebox)
 [![Downloads](https://img.shields.io/npm/dm/%40sinclair%2Ftypebox.svg)](https://www.npmjs.com/package/%40sinclair%2Ftypebox)
+[![Install Size](https://packagephobia.com/badge?p=@sinclair/typebox)](https://packagephobia.com/result?p=@sinclair/typebox)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![GitHub CI](https://github.com/sinclairzx81/typebox/workflows/GitHub%20CI/badge.svg)](https://github.com/sinclairzx81/typebox/actions)
 
 </div>

From 0661aca2abf18b4e94913af0555ea6528135f64b Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 25 Apr 2023 18:45:15 +0900
Subject: [PATCH 118/369] Enhanced Indexed Access Types (#413)

---
 package-lock.json                  |   4 +-
 package.json                       |   2 +-
 src/typebox.ts                     | 137 ++++++++++++------------
 test/runtime/type/guard/indexed.ts |  64 ++++++++++++
 test/static/indexed.ts             | 161 +++++++++++++++++++++++++++++
 5 files changed, 292 insertions(+), 76 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 1ccf314c6..43f8a0abe 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.5",
+  "version": "0.28.6",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.5",
+      "version": "0.28.6",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index a34bb2f43..4b0198722 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.5",
+  "version": "0.28.6",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 21df62331..65feb5990 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -49,6 +49,8 @@ export type TupleToUnion<T extends any[]> = { [K in keyof T]: T[K] }[number]
 export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never
 export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never
 export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L]
+export type Discard<T extends unknown[], D extends unknown> = T extends [infer L, ...infer R] ? (L extends D ? Discard<R, D> : [L, ...Discard<R, D>]) : []
+export type Flat<T> = T extends [] ? [] : T extends [infer L] ? [...Flat<L>] : T extends [infer L, ...infer R] ? [...Flat<L>, ...Flat<R>] : [T]
 export type Assert<T, E> = T extends E ? T : never
 export type Evaluate<T> = T extends infer O ? { [K in keyof O]: O[K] } : never
 export type Ensure<T> = T extends infer U ? U : never
@@ -310,50 +312,36 @@ export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends T
 // --------------------------------------------------------------------------
 // TIndex
 // --------------------------------------------------------------------------
+export type TIndexRest<T extends TSchema[], K extends Key> = T extends [infer L, ...infer R] ? [TIndexType<AssertType<L>, K>, ...TIndexRest<AssertRest<R>, K>] : []
+export type TIndexProperty<T extends TProperties, K extends Key> = K extends keyof T ? [T[K]] : []
+export type TIndexTuple<T extends TSchema[], K extends Key> = K extends keyof T ? [T[K]] : []
 // prettier-ignore
-export type TIndexProperty<T extends TProperties, K extends Key> = 
-  T[K] extends infer R ? [R] :
+export type TIndexType<T extends TSchema, K extends Key> =
+  T extends TRecursive<infer S> ? TIndexType<S, K> :
+  T extends TIntersect<infer S> ? IntersectType<AssertRest<Discard<Flat<TIndexRest<S, K>>, TNever>>> :
+  T extends TUnion<infer S>     ? UnionType<AssertRest<Flat<TIndexRest<S, K>>>> :
+  T extends TObject<infer S>    ? UnionType<AssertRest<Flat<TIndexProperty<S, K>>>> :
+  T extends TTuple<infer S>     ? UnionType<AssertRest<Flat<TIndexTuple<S, K>>>> :
   []
 // prettier-ignore
-export type TIndexTuple<T extends TSchema[], K extends Key> = 
-  K extends keyof T ? [T[K]] : 
-  []
-// prettier-ignore
-export type TIndexComposite<T extends TSchema[], K extends Key> = 
-  T extends [infer L, ...infer R] ? [...TIndexKey<AssertType<L>, K>, ...TIndexComposite<AssertRest<R>, K>] : 
-  []
-// prettier-ignore
-export type TIndexKey<T extends TSchema, K extends Key> = 
-  T extends TRecursive<infer S> ? TIndexKey<S, K> :
-  T extends TIntersect<infer S> ? TIndexComposite<S, K> :
-  T extends TUnion<infer S>     ? TIndexComposite<S, K> :
-  T extends TObject<infer S>    ? TIndexProperty<S, K> : 
-  T extends TTuple<infer S>     ? TIndexTuple<S, K> :
-  T extends TArray<infer S>     ? S :
-  []
+export type TIndexRestMany<T extends TSchema, K extends Key[]> = 
+ K extends [infer L, ...infer R] ? [TIndexType<T, Assert<L, Key>>, ...TIndexRestMany<T, Assert<R, Key[]>>] :
+ []
 // prettier-ignore
-export type TIndexKeys<T extends TSchema, K extends Key[]> = 
-  K extends [infer L, ...infer R] ? 
-    [...TIndexKey<T, Assert<L, Key>>, ...TIndexKeys<T, Assert<R, Key[]>>] : 
-  []
-// prettier-ignore
-export type TIndexFromKeyTuple<T extends TSchema, K extends Key[]> = 
-  TIndexKeys<T, K> extends infer R ?
-    T extends TRecursive<infer S> ? TIndexFromKeyTuple<S, K> :
-    T extends TTuple              ? UnionType<AssertRest<R>> :
-    T extends TIntersect          ? UnionType<AssertRest<R>> :
-    T extends TUnion              ? UnionType<AssertRest<R>> :
-    T extends TObject             ? UnionType<AssertRest<R>> :
-    T extends TArray              ? UnionType<AssertRest<R>> :
-    TNever : 
+export type TIndexReduce<T extends TSchema, K extends Key[]> =
+  T extends TRecursive<infer S> ? TIndexReduce<S, K> :
+  T extends TIntersect ? UnionType<Flat<TIndexRestMany<T, K>>> :
+  T extends TUnion     ? UnionType<Flat<TIndexRestMany<T, K>>> :
+  T extends TObject    ? UnionType<Flat<TIndexRestMany<T, K>>> :
+  T extends TTuple     ? UnionType<Flat<TIndexRestMany<T, K>>> :
   TNever
 // prettier-ignore
 export type TIndex<T extends TSchema, K extends TSchema> =
   [T, K] extends [TTuple, TNumber]  ? UnionType<Assert<T['items'], TSchema[]>> :  
   [T, K] extends [TArray, TNumber]  ? AssertType<T['items']> :
-  K extends TTemplateLiteral        ? TIndexFromKeyTuple<T, TTemplateLiteralKeyTuple<K>> :
-  K extends TUnion<TLiteral<Key>[]> ? TIndexFromKeyTuple<T, TUnionLiteral<K>> :
-  K extends TLiteral<Key>           ? TIndexFromKeyTuple<T, [K['const']]> :
+  K extends TTemplateLiteral        ? TIndexReduce<T, TTemplateLiteralKeyRest<K>> :
+  K extends TUnion<TLiteral<Key>[]> ? TIndexReduce<T, TUnionLiteralKeyRest<K>> :
+  K extends TLiteral<Key>           ? TIndexReduce<T, [K['const']]> :
   TNever
 // --------------------------------------------------------------------------
 // TInteger
@@ -379,12 +367,9 @@ export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, In
 // --------------------------------------------------------------------------
 // TKeyOf
 // --------------------------------------------------------------------------
+// prettier-ignore
 export type TKeyOfProperties<T extends TSchema> = Static<T> extends infer S
-  ? UnionToTuple<
-      {
-        [K in keyof S]: TLiteral<`${Assert<K, TLiteralValue>}`>
-      }[keyof S]
-    >
+  ? UnionToTuple<{[K in keyof S]: TLiteral<`${Assert<K, TLiteralValue>}`>}[keyof S]>
   : []
 // prettier-ignore
 export type TKeyOfIndicesArray<T extends TSchema[]> = UnionToTuple<keyof T & `${number}`>
@@ -687,7 +672,7 @@ export type TTemplateLiteralConst<T, Acc extends string> =
 export type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string = ''> = 
   T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` :
   Acc
-export type TTemplateLiteralKeyTuple<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, Key[]>
+export type TTemplateLiteralKeyRest<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, Key[]>
 export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
   [Kind]: 'TemplateLiteral'
   static: TTemplateLiteralUnion<T>
@@ -727,7 +712,7 @@ export type TLiteralUnionReduce<T extends TLiteral<string | number>[]> =
   T extends [infer L, ...infer R] ? [Assert<L, TLiteral<string | number>>['const'], ...TLiteralUnionReduce<Assert<R, TLiteral<string | number>[]>>] : 
   []
 // prettier-ignore
-export type TUnionLiteral<T extends TUnion<TLiteral<string | number>[]>> = 
+export type TUnionLiteralKeyRest<T extends TUnion<TLiteral<string | number>[]>> = 
   T extends TUnion<infer S> ? TLiteralUnionReduce<Assert<S, TLiteral<string | number>[]>> : 
   []
 // --------------------------------------------------------------------------
@@ -782,9 +767,8 @@ export interface TVoid extends TSchema {
 // --------------------------------------------------------------------------
 // Static<T>
 // --------------------------------------------------------------------------
-/** Creates a TypeScript static type from a TypeBox type */
+/** Infers a static type from a TypeBox type */
 export type Static<T extends TSchema, P extends unknown[] = []> = (T & { params: P })['static']
-
 // --------------------------------------------------------------------------
 // TypeRegistry
 // --------------------------------------------------------------------------
@@ -1929,29 +1913,37 @@ export namespace TypeClone {
 // IndexedAccessor
 // --------------------------------------------------------------------------
 export namespace IndexedAccessor {
-  function Intersect(schema: TIntersect, key: string): TSchema[] {
-    return schema.allOf.reduce((acc, schema) => [...acc, ...Visit(schema, key)], [] as TSchema[])
-  }
-  function Union(schema: TUnion, key: string): TSchema[] {
-    return schema.anyOf.reduce((acc, schema) => [...acc, ...Visit(schema, key)], [] as TSchema[])
-  }
-  function Object(schema: TObject, key: string): TSchema[] {
-    const keys = globalThis.Object.getOwnPropertyNames(schema.properties).filter((key_) => key_ === key)
-    return keys.map((key) => schema.properties[key])
-  }
-  function Tuple(schema: TTuple, key: string): TSchema[] {
-    const items = schema.items === undefined ? [] : (schema.items as TSchema[])
-    return items.filter((_, index) => index.toString() === key)
-  }
-  function Visit(schema: TSchema, key: string): TSchema[] {
+  function Intersect(schema: TIntersect, key: string): TSchema {
+    const schemas = schema.allOf.reduce((acc, schema) => {
+      const indexed = Visit(schema, key)
+      return indexed[Kind] === 'Never' ? acc : [...acc, indexed]
+    }, [] as TSchema[])
+    return Type.Intersect(schemas)
+  }
+  function Union(schema: TUnion, key: string): TSchema {
+    const schemas = schema.anyOf.map((schema) => Visit(schema, key))
+    return Type.Union(schemas)
+  }
+  function Object(schema: TObject, key: string): TSchema {
+    const property = schema.properties[key]
+    return property === undefined ? Type.Never() : Type.Union([property])
+  }
+  function Tuple(schema: TTuple, key: string): TSchema {
+    const items = schema.items
+    if (items === undefined) return Type.Never()
+    const element = items[key as any as number] //
+    if (element === undefined) return Type.Never()
+    return element
+  }
+  function Visit(schema: TSchema, key: string): TSchema {
     if (schema[Kind] === 'Intersect') return Intersect(schema as TIntersect, key)
     if (schema[Kind] === 'Union') return Union(schema as TUnion, key)
     if (schema[Kind] === 'Object') return Object(schema as TObject, key)
     if (schema[Kind] === 'Tuple') return Tuple(schema as TTuple, key)
-    return []
+    return Type.Never()
   }
-  export function Resolve(schema: TSchema, keys: (string | number)[]): TSchema[] {
-    return keys.reduce((acc, key) => [...acc, ...Visit(schema, key.toString())], [] as TSchema[])
+  export function Resolve(schema: TSchema, keys: Key[], options: SchemaOptions = {}): TSchema {
+    return Type.Union(keys.map((key) => Visit(schema, key.toString())))
   }
 }
 // --------------------------------------------------------------------------
@@ -2419,23 +2411,22 @@ export class StandardTypeBuilder extends TypeBuilder {
     }
   }
   /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndexFromKeyTuple<T, Assert<K, Key[]>>
+  public Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndexReduce<T, Assert<K, Key[]>>
   /** `[Standard]` Returns indexed property types for the given keys */
   public Index<T extends TSchema, K extends TSchema>(schema: T, key: K, options?: SchemaOptions): TIndex<T, K>
   /** `[Standard]` Returns indexed property types for the given keys */
   public Index(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
-    const keys = KeyArrayResolver.Resolve(unresolved)
     if (TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved)) {
       return TypeClone.Clone(schema.items, options)
-    }
-    if (TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved)) {
+    } else if (TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved)) {
       const items = schema.items === undefined ? [] : schema.items
       const cloned = items.map((schema) => TypeClone.Clone(schema, {}))
       return this.Union(cloned, options)
+    } else {
+      const keys = KeyArrayResolver.Resolve(unresolved)
+      const clone = TypeClone.Clone(schema, {})
+      return IndexedAccessor.Resolve(clone, keys, options)
     }
-    const resolved = IndexedAccessor.Resolve(schema, keys as any)
-    const cloned = resolved.map((schema) => TypeClone.Clone(schema, {}))
-    return this.Union(cloned, options)
   }
   /** `[Standard]` Creates an Integer type */
   public Integer(options: NumericOptions<number> = {}): TInteger {
@@ -2515,11 +2506,11 @@ export class StandardTypeBuilder extends TypeBuilder {
   /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TOmit<T, K[number]>
   /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
-  public Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionLiteral<K>[number]>
+  public Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionLiteralKeyRest<K>[number]>
   /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TOmit<T, K['const']>
   /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
-  public Omit<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TOmit<T, TTemplateLiteralKeyTuple<K>[number]>
+  public Omit<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TOmit<T, TTemplateLiteralKeyRest<K>[number]>
   /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TOmit<T, never>
   public Omit(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
@@ -2557,11 +2548,11 @@ export class StandardTypeBuilder extends TypeBuilder {
   /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TPick<T, K[number]>
   /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
-  public Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionLiteral<K>[number]>
+  public Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionLiteralKeyRest<K>[number]>
   /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TPick<T, K['const']>
   /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
-  public Pick<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TPick<T, TTemplateLiteralKeyTuple<K>[number]>
+  public Pick<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TPick<T, TTemplateLiteralKeyRest<K>[number]>
   /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TPick<T, never>
   public Pick(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
diff --git a/test/runtime/type/guard/indexed.ts b/test/runtime/type/guard/indexed.ts
index 84683b5d8..bc47ba647 100644
--- a/test/runtime/type/guard/indexed.ts
+++ b/test/runtime/type/guard/indexed.ts
@@ -169,4 +169,68 @@ describe('type/guard/TIndex', () => {
     const I = Type.Index(T, Type.Object({}))
     Assert.isTrue(TypeGuard.TNever(I))
   })
+  it('Should Index 22', () => {
+    const A = Type.Object({ x: Type.Literal('A') })
+    const B = Type.Object({ x: Type.Literal('B') })
+    const C = Type.Object({ x: Type.Literal('C') })
+    const D = Type.Object({ x: Type.Literal('D') })
+    const T = Type.Intersect([A, B, C, D])
+    const I = Type.Index(T, ['x'])
+    Assert.isTrue(TypeGuard.TIntersect(I))
+    Assert.isTrue(TypeGuard.TLiteral(I.allOf[0]))
+    Assert.isTrue(TypeGuard.TLiteral(I.allOf[1]))
+    Assert.isTrue(TypeGuard.TLiteral(I.allOf[2]))
+    Assert.isTrue(TypeGuard.TLiteral(I.allOf[3]))
+  })
+  it('Should Index 23', () => {
+    const A = Type.Object({ x: Type.Literal('A') })
+    const B = Type.Object({ x: Type.Literal('B') })
+    const C = Type.Object({ x: Type.Literal('C') })
+    const D = Type.Object({ x: Type.Literal('D') })
+    const T = Type.Union([A, B, C, D])
+    const I = Type.Index(T, ['x'])
+    Assert.isTrue(TypeGuard.TUnion(I))
+    Assert.isTrue(TypeGuard.TLiteral(I.anyOf[0]))
+    Assert.isTrue(TypeGuard.TLiteral(I.anyOf[1]))
+    Assert.isTrue(TypeGuard.TLiteral(I.anyOf[2]))
+    Assert.isTrue(TypeGuard.TLiteral(I.anyOf[3]))
+  })
+  it('Should Index 24', () => {
+    const A = Type.Object({ x: Type.Literal('A'), y: Type.Number() })
+    const B = Type.Object({ x: Type.Literal('B') })
+    const C = Type.Object({ x: Type.Literal('C') })
+    const D = Type.Object({ x: Type.Literal('D') })
+    const T = Type.Intersect([A, B, C, D])
+    const I = Type.Index(T, ['x', 'y'])
+    Assert.isTrue(TypeGuard.TUnion(I))
+    Assert.isTrue(TypeGuard.TIntersect(I.anyOf[0]))
+    Assert.isTrue(TypeGuard.TNumber(I.anyOf[1]))
+  })
+  it('Should Index 25', () => {
+    const A = Type.Object({ x: Type.Literal('A'), y: Type.Number() })
+    const B = Type.Object({ x: Type.Literal('B'), y: Type.String() })
+    const C = Type.Object({ x: Type.Literal('C') })
+    const D = Type.Object({ x: Type.Literal('D') })
+    const T = Type.Intersect([A, B, C, D])
+    const I = Type.Index(T, ['x', 'y'])
+    Assert.isTrue(TypeGuard.TUnion(I))
+    Assert.isTrue(TypeGuard.TIntersect(I.anyOf[0]))
+    Assert.isTrue(TypeGuard.TIntersect(I.anyOf[1]))
+    Assert.isTrue(TypeGuard.TNumber(I.anyOf[1].allOf[0]))
+    Assert.isTrue(TypeGuard.TString(I.anyOf[1].allOf[1]))
+  })
+  it('Should Index 26', () => {
+    const T = Type.Recursive((This) =>
+      Type.Object({
+        x: Type.String(),
+        y: Type.Number(),
+        z: This,
+      }),
+    )
+    const I = Type.Index(T, ['x', 'y', 'z'])
+    Assert.isTrue(TypeGuard.TUnion(I))
+    Assert.isTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.isTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.isTrue(TypeGuard.TThis(I.anyOf[2]))
+  })
 })
diff --git a/test/static/indexed.ts b/test/static/indexed.ts
index 629582bf6..aa27690d3 100644
--- a/test/static/indexed.ts
+++ b/test/static/indexed.ts
@@ -62,3 +62,164 @@ import { Type, Static } from '@sinclair/typebox'
 
   Expect(R).ToInfer<never>()
 }
+// ------------------------------------------------------------------
+// Intersections
+// ------------------------------------------------------------------
+{
+  type A = { x: string; y: 1 }
+  type B = { x: string; y: number }
+  type C = A & B
+  type R = C['y']
+
+  const A = Type.Object({ x: Type.String(), y: Type.Literal(1) })
+  const B = Type.Object({ x: Type.String(), y: Type.Number() })
+  const C = Type.Intersect([A, B])
+  const R = Type.Index(C, ['y'])
+  Expect(R).ToBe<1>()
+}
+{
+  type A = { x: string; y: 1 }
+  type B = { x: string; y: number }
+  type C = A & B
+  type R = C['x']
+
+  const A = Type.Object({ x: Type.String(), y: Type.Literal(1) })
+  const B = Type.Object({ x: Type.String(), y: Type.Number() })
+  const C = Type.Intersect([A, B])
+  const R = Type.Index(C, ['x'])
+  Expect(R).ToBe<string>()
+}
+{
+  type A = { x: string; y: 1 }
+  type B = { x: string; y: number }
+  type C = A & B
+  type R = C['x' | 'y']
+
+  const A = Type.Object({ x: Type.String(), y: Type.Literal(1) })
+  const B = Type.Object({ x: Type.String(), y: Type.Number() })
+  const C = Type.Intersect([A, B])
+  const R = Type.Index(C, ['x', 'y'])
+  Expect(R).ToBe<string | 1>()
+}
+{
+  type A = { x: string; y: number }
+  type B = { x: number; y: number }
+  type C = A & B
+  type R = C['x']
+
+  const A = Type.Object({ x: Type.String(), y: Type.Number() })
+  const B = Type.Object({ x: Type.Number(), y: Type.Number() })
+  const C = Type.Intersect([A, B])
+  const R = Type.Index(C, ['x'])
+  Expect(R).ToBe<never>()
+}
+{
+  type A = { x: string; y: number }
+  type B = { x: number; y: number }
+  type C = A & B
+  type R = C['y']
+
+  const A = Type.Object({ x: Type.String(), y: Type.Number() })
+  const B = Type.Object({ x: Type.Number(), y: Type.Number() })
+  const C = Type.Intersect([A, B])
+  const R = Type.Index(C, ['y'])
+  Expect(R).ToBe<number>()
+}
+{
+  type A = { x: string; y: number }
+  type B = { x: number; y: number }
+  type C = A & B
+  type R = C['x' | 'y']
+
+  const A = Type.Object({ x: Type.String(), y: Type.Number() })
+  const B = Type.Object({ x: Type.Number(), y: Type.Number() })
+  const C = Type.Intersect([A, B])
+  const R = Type.Index(C, ['x', 'y'])
+  Expect(R).ToBe<number>()
+}
+{
+  type A = { x: string; y: 1 }
+  type B = { x: string; y: number }
+  type C = { x: string; y: number }
+  type D = { x: string }
+  type I = (A & B) & (C & D)
+  type R = I['x' | 'y']
+
+  const A = Type.Object({ x: Type.String(), y: Type.Literal(1) })
+  const B = Type.Object({ x: Type.String(), y: Type.Number() })
+  const C = Type.Object({ x: Type.String(), y: Type.Number() })
+  const D = Type.Object({ x: Type.String() })
+  const I = Type.Intersect([Type.Intersect([A, B]), Type.Intersect([C, D])])
+  const R = Type.Index(I, ['x', 'y'])
+  type O = Static<typeof R>
+  Expect(R).ToBe<string | 1>()
+}
+{
+  type A = { x: string; y: 1 }
+  type B = { x: number; y: number }
+  type C = { x: string; y: number }
+  type D = { x: string }
+  type I = (A & B) & (C & D)
+  type R = I['x' | 'y']
+
+  const A = Type.Object({ x: Type.String(), y: Type.Literal(1) })
+  const B = Type.Object({ x: Type.Number(), y: Type.Number() })
+  const C = Type.Object({ x: Type.String(), y: Type.Number() })
+  const D = Type.Object({ x: Type.String() })
+  const I = Type.Intersect([Type.Intersect([A, B]), Type.Intersect([C, D])])
+  const R = Type.Index(I, ['x', 'y'])
+  type O = Static<typeof R>
+  Expect(R).ToBe<1>()
+}
+{
+  type A = { x: string; y: 1 }
+  type B = { x: number; y: number }
+  type C = { x: string; y: number }
+  type D = { x: string }
+  type I = (A | B) & (C & D)
+  type R = I['x' | 'y']
+
+  const A = Type.Object({ x: Type.String(), y: Type.Literal(1) })
+  const B = Type.Object({ x: Type.Number(), y: Type.Number() })
+  const C = Type.Object({ x: Type.String(), y: Type.Number() })
+  const D = Type.Object({ x: Type.String() })
+  const I = Type.Intersect([Type.Union([A, B]), Type.Intersect([C, D])])
+  const R = Type.Index(I, ['x', 'y'])
+  type O = Static<typeof R>
+  Expect(R).ToBe<number | string>()
+}
+{
+  type A = { x: 'A'; y: 1 }
+  type B = { x: 'B'; y: number }
+  type C = { x: 'C'; y: number }
+  type D = { x: 'D' }
+  type I = A | B | C | D
+  type R = I['x']
+
+  const A = Type.Object({ x: Type.Literal('A'), y: Type.Literal(1) })
+  const B = Type.Object({ x: Type.Literal('B'), y: Type.Number() })
+  const C = Type.Object({ x: Type.Literal('C'), y: Type.Number() })
+  const D = Type.Object({ x: Type.Literal('D') })
+  const I = Type.Union([A, B, C, D])
+  const R = Type.Index(I, Type.Union([Type.Literal('x')]))
+  type O = Static<typeof R>
+  Expect(R).ToBe<'A' | 'B' | 'C' | 'D'>()
+}
+{
+  type I = {
+    x: string
+    y: number
+    z: I
+  }
+  type R = I['x' | 'y' | 'z']
+  const I = Type.Recursive((This) =>
+    Type.Object({
+      x: Type.String(),
+      y: Type.Number(),
+      z: This,
+    }),
+  )
+  const R = Type.Index(I, ['x', 'y', 'z']) // z unresolvable
+  type O = Static<typeof R>
+  Expect(R).ToBe<string | number>()
+}

From 4955935c31b149e3b839be532da7395124ccd3ed Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 25 Apr 2023 19:14:50 +0900
Subject: [PATCH 119/369] Exact Optional Property Types (#414)

---
 readme.md | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index dfd9c4629..323c3efd9 100644
--- a/readme.md
+++ b/readme.md
@@ -1371,9 +1371,15 @@ const B = Value.Check(T, 'hello')                    // const B = true
 
 ### Policies
 
-TypeBox validates using JSON Schema assertion policies by default. It is possible to override these policies and have TypeBox assert using TypeScript policies. The following overrides are available.
+TypeBox validates using standard JSON Schema assertion policies by default. It is possible to override some of these policies to have TypeBox assert inline with TypeScript static assertion rules. The following policy overrides are available.
 
 ```typescript
+// Disallow undefined values for optional properties (default is false)
+//
+// const A: { x?: number } = { x: undefined } - disallowed when enabled
+
+TypeSystem.ExactOptionalPropertyTypes = true
+
 // Allow arrays to validate as object types (default is false)
 //
 // const A: {} = [] - allowed in TS

From ec5d319fde571aee171c44456bb1f4304e9cf10f Mon Sep 17 00:00:00 2001
From: ulucs <ulucs@users.noreply.github.com>
Date: Wed, 26 Apr 2023 14:19:02 +0300
Subject: [PATCH 120/369] Documentation (#415)

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 323c3efd9..beeaa3547 100644
--- a/readme.md
+++ b/readme.md
@@ -959,7 +959,7 @@ type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
 
 <a name='types-guards'></a>
 
-### Type Gaurds
+### Type Guards
 
 TypeBox provides a `TypeGuard` module that can be used for reflection and asserting values as types.
 

From 11b5e1cbf9bdfe0e59d27d2d6d37cf56f173a71d Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 27 Apr 2023 15:39:52 +0900
Subject: [PATCH 121/369] Numeric Indexed Keys (#416)

---
 example/trpc/readme.md             | 20 +++++-----
 package-lock.json                  |  4 +-
 package.json                       |  2 +-
 src/typebox.ts                     |  5 ++-
 test/runtime/type/guard/indexed.ts | 44 +++++++++++++++++++++
 test/static/indexed.ts             | 63 +++++++++++++++++++++---------
 6 files changed, 105 insertions(+), 33 deletions(-)

diff --git a/example/trpc/readme.md b/example/trpc/readme.md
index 5a2b36158..adcb43aa7 100644
--- a/example/trpc/readme.md
+++ b/example/trpc/readme.md
@@ -44,21 +44,21 @@ export const appRouter = t.router({
 
 ## RpcType
 
-Unlike Zod, Yup, Superstruct, TypeBox types are pure JSON Schema and do not implement built a in `parse` or `validate` function. Because of this, you will need to wrap the Type in a TRPC compatible function which implements `parse` or `validate` on behalf of TRPC. As JSON Schema is a formal specification, there are a number of ways you can choose to implement this function, the following shows recommended implementations.
+Unlike Zod, Yup, Superstruct, TypeBox types are pure JSON Schema and do not implement a built in `parse()` or `validate()` function. Because of this, you will need to wrap the Type in a TRPC compatible function which implements `parse()` on behalf of TRPC. As JSON Schema is a formal specification, there are a number of ways you may choose to implement this function. The following are some recommended implementations.
 
 <a name="TypeCompiler"></a>
 
-### With [TypeCompiler](https://www.typescriptlang.org/dev/bug-workbench/?target=99&lib=true&ts=4.7.4#code/PTAEAEDMEsBsFMB2BDAtvAXKATgBwMYAuAnrvAHSEDOAUNKrgPbaGgDeoAKgMr4AW8VMlABfUJGyNUoAOTgq0RPljJo2YCTIAjRgA8ZdBs1YdOpeAGEpuOPGyjxk6XIVKVajeZ27g+a7ewDeiYWdi4AJQAFCwBRbEl7MQkpWXBCPHxgKjsANzsDGnhdENZIAFclQmhGRFBwgjMyAB5OUCLCJAATKi5eASEAPgAKKn5BZCxOABoceEg7JHx4Kkm+8YBtAF1QAF5QLYBKdhpQUD9EKlYx-ABrXa5zKwYA8iebBBGxoRnsOYWlZYHE6zQhlbC1IY5ZCwMqYUAVG6IRgAd0QRx2A2Op1O0EgQ2uN1eAlukOhsIOR1+oPBoChMPgwNO50uYVwyEIfBm6CoVGQAHN4A49utyKKCeQ4gkqKT6QdNusAAybRmgDmSZGgRDwDWcKKxeLMIYcbm8gVYAAGABI2Cb+fAksxQNa2RyROaZn5OnCZAAhACCABEAPrhGIARQAqjFuJwZKIgacRDQkzQQBAYAgUOgsJIyh1sJRaMFjGFFNBCLrog5ks40hksrl8oYSmFGoKkk5Uq5lKp1Jp4N4gkZQhx6vg29XOzJyMAMv2CszWMhOp0AJKIXB5+5jttDNvkADyWgAVvAiEbgRMHmRyAA5MqoLR2IYHKbArSTcx3h9P7Av5MUjQNCLqAy6dAeeabqwew7uYe5fvej7PoBwE1Cy0GgGWFZ6uQ+C-Oy8D-oUxQliByC4Lg4SMHmdj3IQ5C5vmF6nGBWD0bgkhLJ0YIMtioDkIoUFDGB65QQm2LkNRhBCWBEHSXm4mnOQACOsLYMQQxGphG5biI6KYoJebkMIADU2lQeQWhHGm-YALS8vMAFAA)
+### With [TypeCompiler](https://www.typescriptlang.org/play?#code/JYWwDg9gTgLgBAbzgFQJ5gKYGELmAGwyjgF84AzKXOAcgAEBnYAOwGN8BDYKAehnQwAjCAA8erXGAJEaAWABQoSLEQoAyqwAWGEB1JwDhytXpM2nbnwHCRcxeGjwkyAEoAFLAFEoVYmSNUILR0MFBgrDwMRABuMgoKGCLK8OQArmwwwBDMcC7haJgAPMhwiTAYzAAmDOpaOhwAfAAUDHW6AFwoADRwUBjkRBWsGAydyBraugDaALpwALxwswCUiAoGEswM8HWsANYLKAI4eIRQAHQnUoQtbRw9fQN9bCPL670YMKlQOU3RHPhUhhOuk9swIAB3ZireYNNbyQxwYDkOBNXZ7S7afZ-AFA5arPpfH5wf6AjDvDbZbaqMAcGCaHogEYMDgAcww+kW6PO3l8DBxZOW5wAYtxtk1lgBCClwelUCFwZgYBWuDy86BNJBMhgs9mdAAGABIENrdRgyORoHBjbT6SR9T0JJVgbQAEIAQQAIgB9FyeACKAFVPGpkDRSG8EaQFCQgA)
 
 The following uses the TypeCompiler to perform JIT optimized type checking for TRPC.
 
 ```typescript
-import { TSchema } from '@sinclair/typebox'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { TSchema } from '@sinclair/typebox'
 import { TRPCError } from '@trpc/server'
 
-export function RpcType<T extends TSchema>(schema: T) {
-  const check = TypeCompiler.Compile(schema)
+export function RpcType<T extends TSchema>(schema: T, references: TSchema[] = []) {
+  const check = TypeCompiler.Compile(schema, references)
   return (value: unknown) => {
     if (check.Check(value)) return value
     const { path, message } = check.Errors(value).First()!
@@ -69,18 +69,18 @@ export function RpcType<T extends TSchema>(schema: T) {
 
 <a name="Value"></a>
 
-### With [Value](https://www.typescriptlang.org/dev/bug-workbench/?target=99&lib=true&ts=4.7.4#code/PTAEAEDMEsBsFMB2BDAtvAXKATgBwMYAuAnrvAHSEDOAUNKrgPbaGgDeoAasrAK7ygAvqEjZGqUAHJwVaInyxk0bMBJkARowAewAG49+kug2asOAFQDK+ABbxUyISLETps+YuWrS8TVqP0TCzsoOYASgAKAMIAothi2E6i4lLghHj4wFTw2Lo5RjTwWkGskLzyhNCMiKBhBOY+ADzmoEWESAAmVKHWdg4AfAAUVLb2yFjmADQ48JA5SPjwVBO9YwDaALqgALygmwCU7DSgM4S82DWD+nyYoOUA1oiMAO6Ih9v9Rycn0JCD3DdyFE7Ph7sNRg5ptd+PtDth4GcLqBofBjt98NUqGZQLhkIQbNN0FQqMgAOYCYS7NbkGkA-jkOIJKjgvrIabwubw+RLKEGeD7DZrAAMGzRJ3xYmeoEQ8Cl4WijOYgw4RJJ5KwAAMACRsVVk+DCSDMUA63H4wQa6YYjq3SQAIQAggARAD6YRiAEUAKoxSzmSRCfZowQ0EM0EAQGAIFDoLBiXjtbCUWiBUwhOTQQjyqJJFypdIELI5PLYAImYIWHy5lJuOQKJQqNS+bRlkohOr4BpkauucjADJNgoYxBY0DIDodACSiFwCZ2tXqPkGXYoAHl1AAreBEZVo8ahHzkAByvFQ6hyg32kzR6gmh5PZ4vQcEsJoNGHo-HHVXCdnrF2HYrsu96nue2CXkG76Yqw-6gBmWaRFE5D4PCeLwJeb5FG2H6sMguC4GEjAJjk86EOQ8aJruJxflgZG4GIiwdOcqLfKA5ByH+gxftOf5Bqx5BEYQnFfj+QkJnx3zkAAjvw2DEIMypwTOc4vjsnwcQm5COAA1Epf7kOohwRk2AC0JJzKG+xAA)
+### With [Value](https://www.typescriptlang.org/play?#code/JYWwDg9gTgLgBAbzgNQIYBsCuBTOBfOQwgMyghDgHIABAZ2ADsBjdVYKAehgE8xsAjCAA8OANww5KAWABQoSLERwAKgGUmAC2whU+IqXJU6jFm048+godLnho8JMoBKABQDCAUShkoegxRoYKDAmDlpsKFEIm1lsIQV4YkxmGGAIBjgnEOVebAAeZTg4mGwGABNaFXUtHQA+AApaTW1UAC4VABo4KGxiCNKmbFp2tWadAG0AXTgAXjgpgEpEWUIemEwoDPrxLGx25IBrBggAdwYlmdrlmSI4YGI4erRdgDo3LSYDxrHULp6+nrMIZdHY4BZLNYbDKg7ArIhMdK0BxwMCoGAaLogIa0VAAc1wBDmzxwLy8Plo3xqvzgMIWLwAYuwkfUFgBCOGEdFkE5wBjYHnOdxk6D1JBY2g4-HtAAGABIEOLJdgCMRoHB5aj0XhpV0EWU9lQAEIAQQAIgB9JweACKAFUPKplJR8As4XhZHggA)
 
-The following performs dynamic type checking without code evaluation.
+The following uses dynamic type checking without code evaluation. This is slower to validate, but may be required in restricted code evaluation environments.
 
 ```typescript
 import { Value } from '@sinclair/typebox/value'
 import { TSchema } from '@sinclair/typebox'
 import { TRPCError } from '@trpc/server'
 
-export function RpcType<T extends TSchema>(schema: T) {
+export function RpcType<T extends TSchema>(schema: T, references: TSchema[] = []) {
   return (value: unknown) => {
-    if (Value.Check(schema, value)) return value
+    if (Value.Check(schema, references, value)) return value
     const { path, message } = Value.Errors(schema, value).First()!
     throw new TRPCError({ message: `${message} for ${path}`, code: 'BAD_REQUEST' })
   }
@@ -89,7 +89,7 @@ export function RpcType<T extends TSchema>(schema: T) {
 
 <a name="Ajv"></a>
 
-### With [Ajv](https://www.typescriptlang.org/dev/bug-workbench/?target=99&lib=true&ts=4.7.4#code/PTAEAEDMEsBsFMB2BDAtvAXKATgBwMYAuAnrvAHSEDOAUNKrgPbaGgDeoAKgMr4AW8VMgA0oboWSFo+UAF9QkbI1SgA5OCrRE+WMmjZgJMgCNGAD1V0GzVh04AlAAoBhAKLYl2OQqUr1hPHxgKnhsADdQy3omFlAAQQArMJ9lNWQk4AATaCpCYAAmAAYiyxp4MxjWSABXbSlGRFB7Ak5SeAAeTlBywiRMqi5eASEAPgAKKn5BZCxOUWx4SFCkfHgqWaHpgG0AXVAAXlBdgEp2GlBQfAbc0HTkw8R4AHd4pLHj85xF5e018khmK5kPwxmMFksFr9TvsRrckuRkJlMpshGDvpDVscPhcrogblN8ABrA5wsLkK4MODwCZTITYr6EarYRpjMLIWDVTCgWqExCMJ6IY5YcSSaSdWEws4XC7QSBjAmE1nszlYhlMxpsjnwT44662UDoKhUZAAc3goi0uWQv0ckj43kOCvIoU8VAAhFtCjsdaBCHwlC9Hi8HC53J4xhxDcazVgAAYAEjYUdN8HkAK8ictEhtdtksdEV0yXNUACE4gARAD69lcAEUAKqubicVRyemyGgdmggCAwBAodBYJTVXrYSi0aI2digLTQQgh5zeRSpfyBYKhCLYKLWWJ2NpL3xqDRaHR6AxGeCmCxWSrT5r4VpkA8r8jAQIX0q4m6IzIASUQuAjiS96PtSoHkAA8sYCTwEQEafDMXBtOQABy1SoMYoTvMInzGLMyFoRhWEfLIWI0DQX6sD+EEjoBrCHCBbRjOBhGYdg7wfBReq+iSs7zk4zjkgskjUpx5S3pRty4Lg9iMCOoQkoQ5DDqO8EXD+WBKbgSirJkTLatKoDkFodFjD+-50fSFzkHJhCmdRtEjlZRkAI6ctgxCghwJlAaRBywj5SnIKAADUM4ASO5DGKcPYXgAtMaSydscQA)
+### With [Ajv](https://www.typescriptlang.org/play?#code/JYWwDg9gTgLgBAbzgFQMoGMAWBTEBDAGjlRjxmHTgF84AzKCEOAcgAEBnYAO3QBs9gUAPQwAnmGwAjCAA9mAWABQoSLEQoASgAUAwgFEoDKNTimzdBkzYwoYdEPbYoANycLl4aPACCAK2cWjCx4-kIAJsDsMEIATAAM8e5K2DKq8LQArjzkEFxwGnbI4tgAPMhwKTDYXGHsKBg4+AB8ABTsWLh4AFwoRFDYtE7V6NjsPWgd+ADaALpwALxwswCUiEqm6LlRcCEBi1zYAO5wfs4ty+tw-YP9PKMAdLTQenhYLS3XQ3er8007-vc8GEwg1Oh8Bl8RssLooNlt4B10ABrBb-Zz3TbgYC8bBtSZ4GGmfowDJQPItZx4XgZbA9LJIrgQQ5cZY9EhkChlP6-NawszAWhwFqIpEUqk06FXbAkslwSnU7CXOFcbZIECjdh4ADm2CI3CieDuWjImBMixF9ycRnYAEIpnEZkq4DBMAxjgdjshtPpDNAWmqNdraXAAAYAEgQ6vYmp1NCexgj+tIRpNVBDRE2YWDzAAQt4ACIAfQ0egAigBVPSoZDMaiE6hKKhAA)
 
 The following uses Ajv to perform more generalized JSON Schema checks across the complete JSON Schema specification.
 
diff --git a/package-lock.json b/package-lock.json
index 43f8a0abe..e330584a8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.6",
+  "version": "0.28.7",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.6",
+      "version": "0.28.7",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 4b0198722..8883728d5 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.6",
+  "version": "0.28.7",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 65feb5990..3a4a7bd67 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -369,7 +369,7 @@ export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, In
 // --------------------------------------------------------------------------
 // prettier-ignore
 export type TKeyOfProperties<T extends TSchema> = Static<T> extends infer S
-  ? UnionToTuple<{[K in keyof S]: TLiteral<`${Assert<K, TLiteralValue>}`>}[keyof S]>
+  ? UnionToTuple<{[K in keyof S]: TLiteral<Assert<K, TLiteralValue>>}[keyof S]>
   : []
 // prettier-ignore
 export type TKeyOfIndicesArray<T extends TSchema[]> = UnionToTuple<keyof T & `${number}`>
@@ -1943,7 +1943,8 @@ export namespace IndexedAccessor {
     return Type.Never()
   }
   export function Resolve(schema: TSchema, keys: Key[], options: SchemaOptions = {}): TSchema {
-    return Type.Union(keys.map((key) => Visit(schema, key.toString())))
+    // prettier-ignore
+    return Type.Union(keys.map((key) => Visit(schema, key.toString())), options)
   }
 }
 // --------------------------------------------------------------------------
diff --git a/test/runtime/type/guard/indexed.ts b/test/runtime/type/guard/indexed.ts
index bc47ba647..822267285 100644
--- a/test/runtime/type/guard/indexed.ts
+++ b/test/runtime/type/guard/indexed.ts
@@ -233,4 +233,48 @@ describe('type/guard/TIndex', () => {
     Assert.isTrue(TypeGuard.TNumber(I.anyOf[1]))
     Assert.isTrue(TypeGuard.TThis(I.anyOf[2]))
   })
+  it('Should Index 27', () => {
+    const T = Type.Object({
+      0: Type.String(),
+      1: Type.Number(),
+    })
+    const I = Type.Index(T, [0, 1])
+    Assert.isTrue(TypeGuard.TUnion(I))
+    Assert.isTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.isTrue(TypeGuard.TNumber(I.anyOf[1]))
+  })
+  it('Should Index 28', () => {
+    const T = Type.Object({
+      0: Type.String(),
+      '1': Type.Number(),
+    })
+    const I = Type.Index(T, [0, '1'])
+    Assert.isTrue(TypeGuard.TUnion(I))
+    Assert.isTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.isTrue(TypeGuard.TNumber(I.anyOf[1]))
+  })
+  it('Should Index 29', () => {
+    const T = Type.Object({
+      0: Type.String(),
+      '1': Type.Number(),
+    })
+    const I = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal('1')]))
+    Assert.isTrue(TypeGuard.TUnion(I))
+    Assert.isTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.isTrue(TypeGuard.TNumber(I.anyOf[1]))
+  })
+  it('Should Index 30', () => {
+    const T = Type.Object({
+      0: Type.String(),
+      '1': Type.Number(),
+    })
+    const I = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal(1)]))
+    Assert.isTrue(TypeGuard.TUnion(I))
+    Assert.isTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.isTrue(TypeGuard.TNumber(I.anyOf[1]))
+    // Note: Expect TNever for anyOf[1] but permit for TNumber due to IndexedAccess
+    // Resolve() which currently cannot differentiate between string and numeric keys
+    // on the object. This may be resolvable in later revisions, but test for this
+    // fall-through to ensure case is documented. For review.
+  })
 })
diff --git a/test/static/indexed.ts b/test/static/indexed.ts
index aa27690d3..c2cf5f9b6 100644
--- a/test/static/indexed.ts
+++ b/test/static/indexed.ts
@@ -6,60 +6,60 @@ import { Type, Static } from '@sinclair/typebox'
     x: Type.Number(),
     y: Type.String(),
   })
-  const I = Type.Index(T, ['x', 'y'])
-  Expect(I).ToInfer<number | string>()
+  const R = Type.Index(T, ['x', 'y'])
+  type O = Static<typeof R>
+  Expect(R).ToInfer<number | string>()
 }
 {
   const T = Type.Tuple([Type.Number(), Type.String(), Type.Boolean()])
-  const I = Type.Index(T, Type.Union([Type.Literal('0'), Type.Literal('1')]))
-  Expect(I).ToInfer<number | string>()
+  const R = Type.Index(T, Type.Union([Type.Literal('0'), Type.Literal('1')]))
+  type O = Static<typeof R>
+  Expect(R).ToInfer<number | string>()
 }
 {
   const T = Type.Tuple([Type.Number(), Type.String(), Type.Boolean()])
-  const I = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal(1)]))
-  Expect(I).ToInfer<number | string>()
+  const R = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal(1)]))
+  type O = Static<typeof R>
+  Expect(R).ToInfer<number | string>()
 }
 {
   const T = Type.Object({
     ab: Type.Number(),
     ac: Type.String(),
   })
-  const I = Type.Index(T, Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])]))
-  Expect(I).ToInfer<number | string>()
+
+  const R = Type.Index(T, Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])]))
+  type O = Static<typeof R>
+  Expect(R).ToInfer<number | string>()
 }
 {
   const A = Type.Tuple([Type.String(), Type.Boolean()])
-
   const R = Type.Index(A, Type.Number())
-
+  type O = Static<typeof R>
   Expect(R).ToInfer<string | boolean>()
 }
 {
   const A = Type.Tuple([Type.String()])
-
   const R = Type.Index(A, Type.Number())
-
+  type O = Static<typeof R>
   Expect(R).ToInfer<string>()
 }
 {
   const A = Type.Tuple([])
-
   const R = Type.Index(A, Type.Number())
-
+  type O = Static<typeof R>
   Expect(R).ToInfer<never>()
 }
 {
   const A = Type.Object({})
-
   const R = Type.Index(A, Type.BigInt()) // Support Overload
-
+  type O = Static<typeof R>
   Expect(R).ToInfer<never>()
 }
 {
   const A = Type.Array(Type.Number())
-
   const R = Type.Index(A, Type.BigInt()) // Support Overload
-
+  type O = Static<typeof R>
   Expect(R).ToInfer<never>()
 }
 // ------------------------------------------------------------------
@@ -75,6 +75,7 @@ import { Type, Static } from '@sinclair/typebox'
   const B = Type.Object({ x: Type.String(), y: Type.Number() })
   const C = Type.Intersect([A, B])
   const R = Type.Index(C, ['y'])
+  type O = Static<typeof R>
   Expect(R).ToBe<1>()
 }
 {
@@ -87,6 +88,7 @@ import { Type, Static } from '@sinclair/typebox'
   const B = Type.Object({ x: Type.String(), y: Type.Number() })
   const C = Type.Intersect([A, B])
   const R = Type.Index(C, ['x'])
+  type O = Static<typeof R>
   Expect(R).ToBe<string>()
 }
 {
@@ -99,6 +101,7 @@ import { Type, Static } from '@sinclair/typebox'
   const B = Type.Object({ x: Type.String(), y: Type.Number() })
   const C = Type.Intersect([A, B])
   const R = Type.Index(C, ['x', 'y'])
+  type O = Static<typeof R>
   Expect(R).ToBe<string | 1>()
 }
 {
@@ -111,6 +114,7 @@ import { Type, Static } from '@sinclair/typebox'
   const B = Type.Object({ x: Type.Number(), y: Type.Number() })
   const C = Type.Intersect([A, B])
   const R = Type.Index(C, ['x'])
+  type O = Static<typeof R>
   Expect(R).ToBe<never>()
 }
 {
@@ -123,6 +127,7 @@ import { Type, Static } from '@sinclair/typebox'
   const B = Type.Object({ x: Type.Number(), y: Type.Number() })
   const C = Type.Intersect([A, B])
   const R = Type.Index(C, ['y'])
+  type O = Static<typeof R>
   Expect(R).ToBe<number>()
 }
 {
@@ -135,6 +140,7 @@ import { Type, Static } from '@sinclair/typebox'
   const B = Type.Object({ x: Type.Number(), y: Type.Number() })
   const C = Type.Intersect([A, B])
   const R = Type.Index(C, ['x', 'y'])
+  type O = Static<typeof R>
   Expect(R).ToBe<number>()
 }
 {
@@ -223,3 +229,24 @@ import { Type, Static } from '@sinclair/typebox'
   type O = Static<typeof R>
   Expect(R).ToBe<string | number>()
 }
+// ------------------------------------------------
+// Numeric | String Variants
+// ------------------------------------------------
+{
+  const T = Type.Object({
+    0: Type.Number(),
+    '1': Type.String(),
+  })
+  const R = Type.Index(T, [0, '1'])
+  type O = Static<typeof R>
+  Expect(R).ToBe<string | number>()
+}
+{
+  const T = Type.Object({
+    0: Type.Number(),
+    '1': Type.String(),
+  })
+  const R = Type.Index(T, Type.KeyOf(T))
+  type O = Static<typeof R>
+  Expect(R).ToBe<string | number>()
+}

From a4f412b63c0c8811f03362959725569ddaa43300 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 28 Apr 2023 18:17:18 +0900
Subject: [PATCH 122/369] Construct Composite Using Indexed Access Type (#420)

---
 package-lock.json                    |  4 +-
 package.json                         |  2 +-
 src/typebox.ts                       | 69 +++++-----------------------
 test/runtime/type/guard/composite.ts | 15 ++++--
 test/static/composite.ts             | 29 +++++++-----
 5 files changed, 43 insertions(+), 76 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index e330584a8..5b4dbac6e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.7",
+  "version": "0.28.8",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.7",
+      "version": "0.28.8",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 8883728d5..fd300dcf6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.7",
+  "version": "0.28.8",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 3a4a7bd67..618e85a90 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -194,34 +194,18 @@ export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['retur
 // --------------------------------------------------------------------------
 // TComposite
 // --------------------------------------------------------------------------
-export type TCompositeIsOptional<T extends TSchema> = T extends TOptional<T> | TReadonlyOptional<T> ? true : false
 // prettier-ignore
-export type TCompositeOptional<T extends TSchema[]> = T extends [infer L, ...infer R] 
-  ? TCompositeIsOptional<AssertType<L>> extends false ? false 
-  : TCompositeOptional<AssertRest<R>> : true
-export type TCompositeKeyOfUnion1<T extends TObject> = keyof T['properties']
-// prettier-ignore
-export type TCompositeKeyOfUnion2<T extends TObject[]> = T extends [infer L, ...infer R] 
-  ? TCompositeKeyOfUnion1<Assert<L, TObject>> | TCompositeKeyOfUnion2<Assert<R, TObject[]>> 
-  : never
-export type TCompositeKeyOf<T extends TObject[]> = UnionToTuple<TCompositeKeyOfUnion2<T>>
-export type TCompositePropertiesWithKey1<T extends TObject, K extends Key> = K extends keyof T['properties'] ? [T['properties'][K]] : []
-// prettier-ignore
-export type TCompositePropertiesWithKey2<T extends TObject[], K extends Key> = T extends [infer L, ...infer R] 
-  ? [...TCompositePropertiesWithKey1<Assert<L, TObject>, K>, ...TCompositePropertiesWithKey2<Assert<R, TObject[]>, K>]
-  : []
-// prettier-ignore
-export type TCompositeObjectProperty<T extends TObject[], K extends Key> = TCompositePropertiesWithKey2<T, K> extends infer S ? 
-  TCompositeOptional<AssertRest<S>> extends true
-    ? { [_ in K]: TOptional<IntersectType<AssertRest<S>>> }
-    : { [_ in K]: IntersectType<AssertRest<S>> }
+export type TCompositeReduce<T extends TIntersect<TObject[]>, K extends string[]> = K extends [infer L, ...infer R] 
+  ? { [_ in Assert<L, string>]: TIndexType<T, Assert<L, string>> } & TCompositeReduce<T, Assert<R, string[]>> 
   : {}
 // prettier-ignore
-export type TCompositeObjectsWithKeys<T extends TObject[], K extends Key[]> = K extends [infer L, ...infer R] ? L extends Key
-    ? TCompositeObjectProperty<T, L> & TCompositeObjectsWithKeys<T, Assert<R, Key[]>>
-    : {} 
+export type TCompositeSelect<T extends TIntersect<TObject[]>> = UnionToTuple<keyof Static<T>> extends infer K 
+  ? Evaluate<TCompositeReduce<T, Assert<K, string[]>>> 
   : {}
-export type TComposite<T extends TObject[]> = Ensure<TObject<Evaluate<TCompositeObjectsWithKeys<T, Assert<TCompositeKeyOf<T>, Key[]>>>>>
+// prettier-ignore
+export type TComposite<T extends TObject[]> = TIntersect<T> extends infer R 
+  ? TObject<TCompositeSelect<Assert<R, TIntersect<TObject[]>>>>
+  : TObject<{}>
 // --------------------------------------------------------------------------
 // TConstructor
 // --------------------------------------------------------------------------
@@ -2337,39 +2321,10 @@ export class StandardTypeBuilder extends TypeBuilder {
   }
   /** `[Standard]` Creates a Composite object type. */
   public Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T> {
-    const isOptionalAll = (objects: TObject[], key: string) => objects.every((object) => !(key in object.properties) || IsOptional(object.properties[key]))
-    const IsOptional = (schema: TSchema) => TypeGuard.TOptional(schema) || TypeGuard.TReadonlyOptional(schema)
-    const [required, optional] = [new Set<string>(), new Set<string>()]
-    for (const object of objects) {
-      for (const key of globalThis.Object.getOwnPropertyNames(object.properties)) {
-        if (isOptionalAll(objects, key)) optional.add(key)
-      }
-    }
-    for (const object of objects) {
-      for (const key of globalThis.Object.getOwnPropertyNames(object.properties)) {
-        if (!optional.has(key)) required.add(key)
-      }
-    }
-    const properties = {} as Record<keyof any, any>
-    for (const object of objects) {
-      for (const [key, schema] of Object.entries(object.properties)) {
-        const property = TypeClone.Clone(schema, {})
-        if (!optional.has(key)) delete property[Modifier]
-        if (key in properties) {
-          properties[key] = TypeGuard.TIntersect(properties[key]) ? this.Intersect([...properties[key].allOf, property]) : this.Intersect([properties[key], property])
-        } else {
-          properties[key] = property
-        }
-      }
-    }
-    for (const key of globalThis.Object.getOwnPropertyNames(properties)) {
-      properties[key] = optional.has(key) ? this.Optional(properties[key]) : properties[key]
-    }
-    if (required.size > 0) {
-      return this.Create({ ...options, [Kind]: 'Object', type: 'object', properties, required: [...required] })
-    } else {
-      return this.Create({ ...options, [Kind]: 'Object', type: 'object', properties })
-    }
+    const intersect: any = Type.Intersect(objects, {})
+    const keys = KeyResolver.ResolveKeys(intersect, { includePatterns: false })
+    const properties = keys.reduce((acc, key) => ({ ...acc, [key]: Type.Index(intersect, [key]) }), {} as TProperties)
+    return Type.Object(properties, options) as TComposite<T>
   }
   /** `[Standard]` Creates a Enum type */
   public Enum<T extends Record<string, string | number>>(item: T, options: SchemaOptions = {}): TEnum<T> {
diff --git a/test/runtime/type/guard/composite.ts b/test/runtime/type/guard/composite.ts
index 23405772a..86ced5e53 100644
--- a/test/runtime/type/guard/composite.ts
+++ b/test/runtime/type/guard/composite.ts
@@ -20,8 +20,15 @@ describe('type/guard/TComposite', () => {
     const T = Type.Composite([Type.Object({ x: Type.Optional(Type.Number()) }), Type.Object({ x: Type.Number() })])
     Assert.isEqual(TypeGuard.TOptional(T.properties.x), false)
   })
-  it('Should produce optional property if all properties are optional', () => {
-    const T = Type.Composite([Type.Object({ x: Type.Optional(Type.Number()) }), Type.Object({ x: Type.Optional(Type.Number()) })])
-    Assert.isEqual(TypeGuard.TOptional(T.properties.x), true)
-  })
+  // Note for: https://github.com/sinclairzx81/typebox/issues/419
+  // Determining if a composite property is optional requires a deep check for all properties gathered during a indexed access
+  // call. Currently, there isn't a trivial way to perform this check without running into possibly infinite instantiation issues.
+  // The optional check is only specific to overlapping properties. Singular properties will continue to work as expected. The
+  // rule is "if all composite properties for a key are optional, then the composite property is optional". Defer this test and
+  // document as minor breaking change.
+  //
+  // it('Should produce optional property if all properties are optional', () => {
+  //   const T = Type.Composite([Type.Object({ x: Type.Optional(Type.Number()) }), Type.Object({ x: Type.Optional(Type.Number()) })])
+  //   Assert.isEqual(TypeGuard.TOptional(T.properties.x), true)
+  // })
 })
diff --git a/test/static/composite.ts b/test/static/composite.ts
index fcbc5c4a9..b4399e20f 100644
--- a/test/static/composite.ts
+++ b/test/static/composite.ts
@@ -43,19 +43,24 @@ import { Type, Static } from '@sinclair/typebox'
     A: number
   }>()
 }
-// Overlapping All Optional
+// Overlapping All Optional (Deferred)
+// Note for: https://github.com/sinclairzx81/typebox/issues/419
+// Determining if a composite property is optional requires a deep check for all properties gathered during a indexed access
+// call. Currently, there isn't a trivial way to perform this check without running into possibly infinite instantiation issues.
+// The optional check is only specific to overlapping properties. Singular properties will continue to work as expected. The
+// rule is "if all composite properties for a key are optional, then the composite property is optional". Defer this test and
+// document as minor breaking change.
 {
-  const A = Type.Object({
-    A: Type.Optional(Type.Number()),
-  })
-  const B = Type.Object({
-    A: Type.Optional(Type.Number()),
-  })
-  const T = Type.Composite([A, B])
-
-  Expect(T).ToInfer<{
-    A: number | undefined
-  }>()
+  // const A = Type.Object({
+  //   A: Type.Optional(Type.Number()),
+  // })
+  // const B = Type.Object({
+  //   A: Type.Optional(Type.Number()),
+  // })
+  // const T = Type.Composite([A, B])
+  // Expect(T).ToInfer<{
+  //   A: number | undefined
+  // }>()
 }
 // Distinct Properties
 {

From d4d6ffccd6adc7d6ee61f69926f853349e95b3d2 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 1 May 2023 23:23:45 +0900
Subject: [PATCH 123/369] Template Literal DSL (#423)

---
 example/template-dsl/index.ts        |  29 --------
 example/template-dsl/readme.md       |  31 --------
 example/template-dsl/template-dsl.ts | 105 ---------------------------
 package-lock.json                    |   4 +-
 package.json                         |   2 +-
 readme.md                            |  67 ++++++++++-------
 src/typebox.ts                       |  77 +++++++++++++++++++-
 7 files changed, 120 insertions(+), 195 deletions(-)
 delete mode 100644 example/template-dsl/index.ts
 delete mode 100644 example/template-dsl/readme.md
 delete mode 100644 example/template-dsl/template-dsl.ts

diff --git a/example/template-dsl/index.ts b/example/template-dsl/index.ts
deleted file mode 100644
index 44f129157..000000000
--- a/example/template-dsl/index.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/template-dsl
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-export * from './template-dsl'
\ No newline at end of file
diff --git a/example/template-dsl/readme.md b/example/template-dsl/readme.md
deleted file mode 100644
index e55dba237..000000000
--- a/example/template-dsl/readme.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# TemplateLiteral DSL
-
-This example implements a small string based DSL for dynamically parsing strings into `TTemplateLiteral` types at runtime. The `template-dsl.ts` script provided with this example contains the full implementation. It can be copied and pasted into projects with TypeBox 0.28.0 or higher installed. 
-
-The example is a candiate for possible inclusion in TypeBox under a `Type.TemplateLiteral(template_dsl_string)` overloaded type function.
-
-## Example
-
-The DSL supports a similar syntax to TypeScript template literal type syntax. The following shows general usage.
-
-```typescript
-import { Static } from '@sinclair/typebox'
-import { TemplateLiteral } from './template-dsl'
-
-// ----------------------------------------------------------------
-// Path
-// ----------------------------------------------------------------
-
-const Path = TemplateLiteral('/users/${number}/posts/${string}')
-
-type Path = Static<typeof Path> // type Path = '/users/${number}/posts/${string}'
-
-// ----------------------------------------------------------------
-// Bytes
-// ----------------------------------------------------------------
-
-const Byte = TemplateLiteral('${0|1}${0|1}${0|1}${0|1}${0|1}${0|1}${0|1}${0|1}')
-
-type Byte = Static<typeof Byte> // type Byte = '00000000' | '00000001' | '00000010' ... | '11111111' 
-```
-
diff --git a/example/template-dsl/template-dsl.ts b/example/template-dsl/template-dsl.ts
deleted file mode 100644
index ad110da3a..000000000
--- a/example/template-dsl/template-dsl.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/template-dsl
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { Type, TTemplateLiteral, TLiteral, TTemplateLiteralKind, TNumber, TString, TBoolean, TBigInt, Assert,  Ensure, UnionType } from '@sinclair/typebox'
-
-// -------------------------------------------------------------------------
-// Helpers
-// -------------------------------------------------------------------------
-export type Trim<T> = T extends `${' '}${infer U}` ? Trim<U> : T extends `${infer U}${' '}` ? Trim<U> : T
-// -------------------------------------------------------------------------
-// TTemplateLiteralParser
-// -------------------------------------------------------------------------
-// prettier-ignore
-export type TTemplateLiteralParserUnionLiteral<T extends string> = 
-  T extends `${infer L}|${infer R}` ? [TLiteral<Trim<L>>, ...TTemplateLiteralParserUnionLiteral<R>] : 
-  T extends `${infer L}` ? [TLiteral<Trim<L>>] : 
-  []
-export type TTemplateLiteralParserUnion<T extends string> = UnionType<TTemplateLiteralParserUnionLiteral<T>>
-// prettier-ignore
-export type TTemplateLiteralParserTerminal<T extends string> = 
-  T extends 'boolean' ? TBoolean :  
-  T extends 'bigint' ? TBigInt :  
-  T extends 'number' ? TNumber :
-  T extends 'string' ? TString :
-  TTemplateLiteralParserUnion<T>
-// prettier-ignore
-export type TTemplateLiteralParserTemplate<T extends string> = 
-  T extends `{${infer L}}${infer R}` ? [TTemplateLiteralParserTerminal<L>, ...TTemplateLiteralParserTemplate<R>] :
-  T extends `${infer L}$${infer R}`  ? [TLiteral<L>, ...TTemplateLiteralParserTemplate<R>] :
-  T extends `${infer L}`             ? [TLiteral<L>] : 
-  []
-export type TTemplateLiteralParser<T extends string> = Ensure<TTemplateLiteral<Assert<TTemplateLiteralParserTemplate<T>, TTemplateLiteralKind[]>>>
-// ---------------------------------------------------------------------
-// TemplateLiteralParser
-// ---------------------------------------------------------------------
-namespace TemplateLiteralParser {
-  export function * ParseUnion(template: string): IterableIterator<TTemplateLiteralKind> {
-    const trim = template.trim().replace(/"|'/g, '')
-    if(trim === 'boolean') return yield Type.Boolean()
-    if(trim === 'number') return yield Type.Number()
-    if(trim === 'bigint') return yield Type.BigInt()
-    if(trim === 'string') return yield Type.String()
-    const literals = trim.split('|').map(literal => Type.Literal(literal.trim()))
-    return yield literals.length === 0 ? Type.Never() : literals.length === 1 ? literals[0] : Type.Union(literals)
-  }
-  export function * ParseTerminal(template: string): IterableIterator<TTemplateLiteralKind> {
-    if(template[1] !== '{') {
-      const L = Type.Literal('$')
-      const R = ParseLiteral(template.slice(1))
-      return yield * [L, ...R]
-    }
-    for(let i = 2; i < template.length; i++) {
-      if(template[i] === '}') {
-        const L = ParseUnion(template.slice(2, i))
-        const R = ParseLiteral(template.slice(i+1))
-        return yield * [...L, ...R]
-      }
-    }
-    yield Type.Literal(template)
-  }
-  export function * ParseLiteral(template: string): IterableIterator<TTemplateLiteralKind> {
-    for(let i = 0; i < template.length; i++) {
-      if(template[i] === '$') {
-        const L = Type.Literal(template.slice(0, i))
-        const R = ParseTerminal(template.slice(i))
-        return yield * [L, ...R]
-      }
-    }
-    yield Type.Literal(template)
-  }
-  export function Parse(template: string): TTemplateLiteral {
-    return Type.TemplateLiteral([...ParseLiteral(template)])
-  }
-}
-// ------------------------------------------------------------------------------------------
-// TemplateLiteral DSL
-// ------------------------------------------------------------------------------------------
-export function TemplateLiteral<T extends string>(template: T): TTemplateLiteralParser<T> {
-  return TemplateLiteralParser.Parse(template)
-}
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index 5b4dbac6e..347be6872 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.8",
+  "version": "0.28.9",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.8",
+      "version": "0.28.9",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index fd300dcf6..1cb30d7a7 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.8",
+  "version": "0.28.9",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index beeaa3547..19148dea4 100644
--- a/readme.md
+++ b/readme.md
@@ -83,7 +83,7 @@ License MIT
   - [References](#types-references)
   - [Recursive](#types-recursive)
   - [Conditional](#types-conditional)
-  - [Template](#types-template-literal)
+  - [Template Literal](#types-template-literal)
   - [Indexed](#types-indexed)
   - [Rest](#types-rest)
   - [Guards](#types-guards)
@@ -814,11 +814,13 @@ type T2 = Static<typeof T2>                        // type T2 = string
 
 ### Template Literal Types
 
-Template Literal types are supported with `Type.TemplateLiteral`
+TypeBox supports Template Literal types using `Type.TemplateLiteral`. These types can be created using a simple template DSL syntax, however more complex template literals can be created by passing an array of literal and union types. The examples below show the template DSL syntax.
 
 ```typescript
 // TypeScript
 
+type P = `/post/${string}/user/${number}`            // type P = `/post/${string}/user/${number}`
+
 type T = `option${'A'|'B'}`                          // type T = 'optionA' | 'optionB'
 
 type R = Record<T, string>                           // type R = {
@@ -828,13 +830,17 @@ type R = Record<T, string>                           // type R = {
 
 // TypeBox
 
-const T = Type.TemplateLiteral([                     // const T = {
-  Type.Literal('option'),                            //   pattern: '^option(A|B)$',
-  Type.Union([                                       //   type: 'string'
-    Type.Literal('A'),                               // }
-    Type.Literal('B')
-  ])
-])
+const P = Type.TemplateLiteral('/post/${string}/user/${number}')
+
+                                                     // const P = {
+                                                     //   type: 'string',
+                                                     //   pattern: '^/post/(.*)/user/(0|[1-9][0-9]*)$'
+                                                     // }
+
+const T = Type.TemplateLiteral('option${A|B}')       // const T = {
+                                                     //   pattern: '^option(A|B)$',
+                                                     //   type: 'string'
+                                                     // }
 
 const R = Type.Record(T, Type.String())              // const R = {
                                                      //   type: 'object',
@@ -848,37 +854,48 @@ const R = Type.Record(T, Type.String())              // const R = {
                                                      //     }
                                                      //   }
                                                      // }
-
-type T = Static<typeof T>                            // type T = 'optionA' | 'optionB'
-
-type R = Static<typeof R>                            // type R = {
-                                                     //   optionA: string
-                                                     //   optionB: string
-                                                     // }
 ```
 
 <a name='types-indexed'></a>
 
 ### Indexed Access Types
 
-Indexed Access types are supported with `Type.Index`
+TypeBox supports Indexed Access types using `Type.Index`. This feature provides a consistent way to access property types without having to extract them from the underlying schema representation. Indexed accessors are supported for object and tuples, as well as nested union and intersect types.
 
 ```typescript
-const T = Type.Object({                              // type T = {
-  x: Type.Number(),                                  //   x: number
-  y: Type.String(),                                  //   y: string
-  z: Type.Boolean()                                  //   z: boolean
-})                                                   // }
+const T = Type.Object({                              // const T = {
+  x: Type.Number(),                                  //   type: 'object',
+  y: Type.String(),                                  //   required: ['x', 'y', 'z'],
+  z: Type.Boolean()                                  //   properties: {
+})                                                   //     x: { type: 'number' },
+                                                     //     y: { type: 'string' },
+                                                     //     z: { type: 'string' },
+                                                     //   }
+                                                     // }
 
-const A = Type.Index(T, ['x'])                       // type A = T['x']
+const A = Type.Index(T, ['x'])                       // const A = { type: 'number' }
 
-const B = Type.Index(T, Type.KeyOf(T))               // type B = T[keyof T]
+const B = Type.Index(T, ['x', 'y'])                  // const B = { 
+                                                     //   anyOf: [
+                                                     //     { type: 'number' },  
+                                                     //     { type: 'string' }
+                                                     //   ]
+                                                     // }
+
+const C = Type.Index(T, Type.KeyOf(T))               // const C = { 
+                                                     //   anyOf: [
+                                                     //     { type: 'number' },  
+                                                     //     { type: 'string' },
+                                                     //     { type: 'boolean' }
+                                                     //   ]
+                                                     // }
 ```
+
 <a name='types-rest'></a>
 
 ### Rest Types
 
-Rest parameters are supported with `Type.Rest`. This function is used to extract interior arrays from tuples to allow them to compose with the JavaScript spread operator `...`. This type can be used for tuple concatination and variadic function composition.
+Rest parameters are supported with `Type.Rest`. This function is used to extract interior type elements from tuples which enables them to compose with the JavaScript spread operator `...`. This type can be used for tuple concatination as well as for variadic functions.
 
 ```typescript
 // TypeScript
diff --git a/src/typebox.ts b/src/typebox.ts
index 618e85a90..6f2bc1b13 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -51,6 +51,7 @@ export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : ne
 export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L]
 export type Discard<T extends unknown[], D extends unknown> = T extends [infer L, ...infer R] ? (L extends D ? Discard<R, D> : [L, ...Discard<R, D>]) : []
 export type Flat<T> = T extends [] ? [] : T extends [infer L] ? [...Flat<L>] : T extends [infer L, ...infer R] ? [...Flat<L>, ...Flat<R>] : [T]
+export type Trim<T> = T extends `${' '}${infer U}` ? Trim<U> : T extends `${infer U}${' '}` ? Trim<U> : T
 export type Assert<T, E> = T extends E ? T : never
 export type Evaluate<T> = T extends infer O ? { [K in keyof O]: O[K] } : never
 export type Ensure<T> = T extends infer U ? U : never
@@ -622,6 +623,29 @@ export interface TSymbol extends TSchema, SchemaOptions {
   type: 'null'
   typeOf: 'Symbol'
 }
+// -------------------------------------------------------------------------
+// TTemplateLiteralParserDsl
+// -------------------------------------------------------------------------
+// prettier-ignore
+export type TTemplateLiteralDslParserUnionLiteral<T extends string> = 
+  T extends `${infer L}|${infer R}` ? [TLiteral<Trim<L>>, ...TTemplateLiteralDslParserUnionLiteral<R>] : 
+  T extends `${infer L}` ? [TLiteral<Trim<L>>] : 
+  []
+export type TTemplateLiteralDslParserUnion<T extends string> = UnionType<TTemplateLiteralDslParserUnionLiteral<T>>
+// prettier-ignore
+export type TTemplateLiteralDslParserTerminal<T extends string> = 
+  T extends 'boolean' ? TBoolean :  
+  T extends 'bigint' ? TBigInt :  
+  T extends 'number' ? TNumber :
+  T extends 'string' ? TString :
+  TTemplateLiteralDslParserUnion<T>
+// prettier-ignore
+export type TTemplateLiteralDslParserTemplate<T extends string> = 
+  T extends `{${infer L}}${infer R}` ? [TTemplateLiteralDslParserTerminal<L>, ...TTemplateLiteralDslParserTemplate<R>] :
+  T extends `${infer L}$${infer R}`  ? [TLiteral<L>, ...TTemplateLiteralDslParserTemplate<R>] :
+  T extends `${infer L}`             ? [TLiteral<L>] : 
+  []
+export type TTemplateLiteralDslParser<T extends string> = Ensure<TTemplateLiteral<Assert<TTemplateLiteralDslParserTemplate<T>, TTemplateLiteralKind[]>>>
 // --------------------------------------------------------------------------
 // TTemplateLiteral
 // --------------------------------------------------------------------------
@@ -2268,6 +2292,48 @@ export namespace TemplateLiteralGenerator {
     throw Error('TemplateLiteralGenerator: Unknown expression')
   }
 }
+// ---------------------------------------------------------------------
+// TemplateLiteralDslParser
+// ---------------------------------------------------------------------
+export namespace TemplateLiteralDslParser {
+  function* ParseUnion(template: string): IterableIterator<TTemplateLiteralKind> {
+    const trim = template.trim().replace(/"|'/g, '')
+    if (trim === 'boolean') return yield Type.Boolean()
+    if (trim === 'number') return yield Type.Number()
+    if (trim === 'bigint') return yield Type.BigInt()
+    if (trim === 'string') return yield Type.String()
+    const literals = trim.split('|').map((literal) => Type.Literal(literal.trim()))
+    return yield literals.length === 0 ? Type.Never() : literals.length === 1 ? literals[0] : Type.Union(literals)
+  }
+  function* ParseTerminal(template: string): IterableIterator<TTemplateLiteralKind> {
+    if (template[1] !== '{') {
+      const L = Type.Literal('$')
+      const R = ParseLiteral(template.slice(1))
+      return yield* [L, ...R]
+    }
+    for (let i = 2; i < template.length; i++) {
+      if (template[i] === '}') {
+        const L = ParseUnion(template.slice(2, i))
+        const R = ParseLiteral(template.slice(i + 1))
+        return yield* [...L, ...R]
+      }
+    }
+    yield Type.Literal(template)
+  }
+  function* ParseLiteral(template: string): IterableIterator<TTemplateLiteralKind> {
+    for (let i = 0; i < template.length; i++) {
+      if (template[i] === '$') {
+        const L = Type.Literal(template.slice(0, i))
+        const R = ParseTerminal(template.slice(i))
+        return yield* [L, ...R]
+      }
+    }
+    yield Type.Literal(template)
+  }
+  export function Parse(template_dsl: string): TTemplateLiteralKind[] {
+    return [...ParseLiteral(template_dsl)]
+  }
+}
 // --------------------------------------------------------------------------
 // TypeOrdinal: Used for auto $id generation
 // --------------------------------------------------------------------------
@@ -2606,9 +2672,16 @@ export class StandardTypeBuilder extends TypeBuilder {
   public String(options: StringOptions = {}): TString {
     return this.Create({ ...options, [Kind]: 'String', type: 'string' })
   }
+  /** `[Experimental]` Creates a template literal type from dsl string */
+  public TemplateLiteral<T extends string>(dsl: T, options?: SchemaOptions): TTemplateLiteralDslParser<T>
+  /** `[Standard]` Creates a template literal type */
+  public TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>
   /** `[Standard]` Creates a template literal type */
-  public TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options: SchemaOptions = {}): TTemplateLiteral<T> {
-    const pattern = TemplateLiteralPattern.Create(kinds)
+  public TemplateLiteral(unresolved: unknown, options: SchemaOptions = {}) {
+    // prettier-ignore
+    const pattern = (typeof unresolved === 'string')
+      ? TemplateLiteralPattern.Create(TemplateLiteralDslParser.Parse(unresolved))
+      : TemplateLiteralPattern.Create(unresolved as TTemplateLiteralKind[])
     return this.Create({ ...options, [Kind]: 'TemplateLiteral', type: 'string', pattern })
   }
   /** `[Standard]` Creates a Tuple type */

From c5da476c491329707f555fcbf8fd032a829f0624 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 8 May 2023 02:26:17 +0900
Subject: [PATCH 124/369] Documentation

---
 readme.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/readme.md b/readme.md
index 19148dea4..fc40b0023 100644
--- a/readme.md
+++ b/readme.md
@@ -11,7 +11,6 @@
 
 [![npm version](https://badge.fury.io/js/%40sinclair%2Ftypebox.svg)](https://badge.fury.io/js/%40sinclair%2Ftypebox)
 [![Downloads](https://img.shields.io/npm/dm/%40sinclair%2Ftypebox.svg)](https://www.npmjs.com/package/%40sinclair%2Ftypebox)
-[![Install Size](https://packagephobia.com/badge?p=@sinclair/typebox)](https://packagephobia.com/result?p=@sinclair/typebox)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![GitHub CI](https://github.com/sinclairzx81/typebox/workflows/GitHub%20CI/badge.svg)](https://github.com/sinclairzx81/typebox/actions)
 

From f80f0ff350fa887419eaf3e7f11357061240966b Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 10 May 2023 16:11:20 +0900
Subject: [PATCH 125/369] Workbench (#431)

---
 readme.md     |  38 +++++++++++++++++++++++++++++---------
 workbench.png | Bin 0 -> 43713 bytes
 2 files changed, 29 insertions(+), 9 deletions(-)
 create mode 100644 workbench.png

diff --git a/readme.md b/readme.md
index fc40b0023..3145e7d64 100644
--- a/readme.md
+++ b/readme.md
@@ -108,6 +108,7 @@ License MIT
   - [Types](#typesystem-types)
   - [Formats](#typesystem-formats)
   - [Policies](#typesystem-policies)
+- [Workbench](#workbench)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
   - [Validate](#benchmark-validate)
@@ -1345,26 +1346,31 @@ import { TypeSystem } from '@sinclair/typebox/system'
 
 ### Types
 
-Use the `Type(...)` function to create a custom type. This function will return a type factory function that can be used to construct the type. The following creates a Point type.
+Use the `Type(...)` function to create custom types. This function lets you specify custom value assertion logic and will return a type factory function which is used to instance the type. This function accepts two generic arguments, the first is the inference type, the second is options used to constrain the type. The following creates a Vector type.
 
 ```typescript
-type PointOptions = { }                              // The Type Options
+type VectorOptions = { abs: boolean }       
 
-type PointType = { x: number, y: number }            // The Static<T> Type
+type Vector = { x: number, y: number }
 
-const Point = TypeSystem.Type<PointType, PointOptions>('Point', (options, value) => {
+const Vector = TypeSystem.Type<Vector, VectorOptions>('Vector', (options, value) => {
   return (
     typeof value === 'object' && value !== null &&
-    typeof value.x === 'number' && 
-    typeof value.y === 'number'
+    'x' in value && typeof value.x === 'number' && 
+    'y' in value && typeof value.y === 'number' && 
+    (options.abs ? (value.x === Math.abs(value.x) && value.y === Math.abs(value.y)) : true)
   )
 })
 
-const T = Point()
+const T = Vector({ abs: true })
 
-type T = Static<typeof T>                             // type T = { x: number, y: number }
+type T = Static<typeof T>                            // type T = Vector
 
-const R = Value.Check(T, { x: 1, y: 2 })              // const R = true
+const R1 = Value.Check(T, { x: 1, y: 1 })            // const R1 = true
+
+const R2 = Value.Check(T, { x: 1, y: '1' })          // const R2 = false
+
+const R3 = Value.Check(T, { x: 1, y: -1 })           // const R3 = false
 ```
 
 <a name='typesystem-formats'></a>
@@ -1409,6 +1415,20 @@ TypeSystem.AllowArrayObjects = true
 TypeSystem.AllowNaN = true                      
 ```
 
+<a name='workbench'></a>
+
+## Workbench
+
+TypeBox offers a web based code generation tool that can be used to create TypeBox types from TypeScript type definitions. This tool is written to prototype new TypeBox features, but can be used to rapidly convert TypeScript type definitions in to TypeBox types as well as raw JSON Schema.
+
+[Workbench Link Here](https://sinclairzx81.github.io/typebox-workbench/)
+
+<div align='center'>
+	
+<a href="https://sinclairzx81.github.io/typebox-workbench/"><img src="https://github.com/sinclairzx81/typebox/blob/master/workbench.png?raw=true" /></a>
+
+</div>
+
 <a name='benchmark'></a>
 
 ## Benchmark
diff --git a/workbench.png b/workbench.png
new file mode 100644
index 0000000000000000000000000000000000000000..817b9d17445d7ab66329ade51e302536cda28385
GIT binary patch
literal 43713
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

literal 0
HcmV?d00001


From 8ca61abeb5f66a19493b06847c7c9c48bf5a2397 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 10 May 2023 22:26:28 +0900
Subject: [PATCH 126/369] Documentation

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 3145e7d64..6ff5dbb9b 100644
--- a/readme.md
+++ b/readme.md
@@ -11,8 +11,8 @@
 
 [![npm version](https://badge.fury.io/js/%40sinclair%2Ftypebox.svg)](https://badge.fury.io/js/%40sinclair%2Ftypebox)
 [![Downloads](https://img.shields.io/npm/dm/%40sinclair%2Ftypebox.svg)](https://www.npmjs.com/package/%40sinclair%2Ftypebox)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![GitHub CI](https://github.com/sinclairzx81/typebox/workflows/GitHub%20CI/badge.svg)](https://github.com/sinclairzx81/typebox/actions)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 </div>
 

From 9b33feb5fad14c3833e37113e13a313ba7f12bd5 Mon Sep 17 00:00:00 2001
From: Grzegorz Uriasz <gorbak25@gmail.com>
Date: Sat, 13 May 2023 09:00:12 -0700
Subject: [PATCH 127/369] Corrected Scope for Additional Properties (#434)

---
 src/compiler/compiler.ts           |  4 +-
 test/runtime/compiler/intersect.ts |  7 +++
 test/runtime/compiler/object.ts    | 85 ++++++++++++++++++++++++++++++
 3 files changed, 94 insertions(+), 2 deletions(-)

diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index bf0d67a91..b2ffb9c76 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -216,7 +216,7 @@ export namespace TypeCompiler {
       yield `${check1} && ${check2}`
     } else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
       const keyCheck = PushLocal(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`)
-      const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key) || ${CreateExpression(schema.unevaluatedProperties, references, 'value[key]')})`
+      const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key) || ${CreateExpression(schema.unevaluatedProperties, references, `${value}[key]`)})`
       yield `${check1} && ${check2}`
     } else {
       yield `${check1}`
@@ -273,7 +273,7 @@ export namespace TypeCompiler {
       }
     }
     if (typeof schema.additionalProperties === 'object') {
-      const expression = CreateExpression(schema.additionalProperties, references, 'value[key]')
+      const expression = CreateExpression(schema.additionalProperties, references, `${value}[key]`)
       const keys = `[${knownKeys.map((key) => `'${key}'`).join(', ')}]`
       yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`
     }
diff --git a/test/runtime/compiler/intersect.ts b/test/runtime/compiler/intersect.ts
index 0f9d5272c..ce7f934c7 100644
--- a/test/runtime/compiler/intersect.ts
+++ b/test/runtime/compiler/intersect.ts
@@ -54,6 +54,13 @@ describe('type/compiler/Intersect', () => {
     Ok(T, { x: 1, y: 2, z: 3 })
     Fail(T, { x: 1, y: 2, z: '1' })
   })
+  it('Should intersect two nested objects and allow unevaluated properties of number', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const T = Type.Object({ nested: Type.Intersect([A, B], { unevaluatedProperties: Type.Number() }) })
+    Ok(T, { nested: { x: 1, y: 2, z: 3 } })
+    Fail(T, { nested: { x: 1, y: 2, z: '1' } })
+  })
   it('Should intersect two union objects with overlapping properties of the same type', () => {
     const A = Type.Union([Type.Object({ x: Type.Number() })])
     const B = Type.Union([Type.Object({ x: Type.Number() })])
diff --git a/test/runtime/compiler/object.ts b/test/runtime/compiler/object.ts
index 187207b3c..f1299f7e1 100644
--- a/test/runtime/compiler/object.ts
+++ b/test/runtime/compiler/object.ts
@@ -215,6 +215,91 @@ describe('type/compiler/Object', () => {
       z: 3,
     })
   })
+
+  it('Should validate nested schema additional properties of string', () => {
+    const T = Type.Object({
+      nested: Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        {
+          additionalProperties: Type.String(),
+        },
+      ),
+    })
+    Ok(T, {
+      nested: {
+        x: 1,
+        y: 2,
+        z: 'hello',
+      },
+    })
+    Fail(T, {
+      nested: {
+        x: 1,
+        y: 2,
+        z: 3,
+      },
+    })
+  })
+  it('Should validate nested schema additional properties of array', () => {
+    const T = Type.Object({
+      nested: Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        {
+          additionalProperties: Type.Array(Type.Number()),
+        },
+      ),
+    })
+    Ok(T, {
+      nested: {
+        x: 1,
+        y: 2,
+        z: [0, 1, 2],
+      },
+    })
+    Fail(T, {
+      nested: {
+        x: 1,
+        y: 2,
+        z: 3,
+      },
+    })
+  })
+  it('Should validate nested schema additional properties of object', () => {
+    const T = Type.Object({
+      nested: Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        {
+          additionalProperties: Type.Object({
+            z: Type.Number(),
+          }),
+        },
+      ),
+    })
+    Ok(T, {
+      nested: {
+        x: 1,
+        y: 2,
+        z: { z: 1 },
+      },
+    })
+    Fail(T, {
+      nested: {
+        x: 1,
+        y: 2,
+        z: 3,
+      },
+    })
+  })
+
   it('Should check for property key if property type is undefined', () => {
     const T = Type.Object({ x: Type.Undefined() })
     Ok(T, { x: undefined })

From f740515feb51d35826425caae4a880f6650ca7ae Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sun, 14 May 2023 01:03:49 +0900
Subject: [PATCH 128/369] Revision 0.28.10

---
 package-lock.json | 4 ++--
 package.json      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 347be6872..640ff4d4c 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.9",
+  "version": "0.28.10",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.9",
+      "version": "0.28.10",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 1cb30d7a7..07cc9d478 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.9",
+  "version": "0.28.10",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

From 41dae20a284f93567e03b4244eeb104d6b4508c3 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 17 May 2023 12:08:41 +0900
Subject: [PATCH 129/369] Additional Fast Path Undefined Checks (#439)

---
 package-lock.json               |  4 ++--
 package.json                    |  2 +-
 src/typebox.ts                  |  8 ++++++++
 src/value/check.ts              |  4 ++--
 test/runtime/compiler/object.ts | 27 +++++++++++++++++++++++++++
 5 files changed, 40 insertions(+), 5 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 640ff4d4c..5e568c440 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.10",
+  "version": "0.28.11",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.10",
+      "version": "0.28.11",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 07cc9d478..f889ab997 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.10",
+  "version": "0.28.11",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 6f2bc1b13..a6c405a49 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -1353,6 +1353,14 @@ export namespace TypeGuard {
 export namespace ExtendsUndefined {
   export function Check(schema: TSchema): boolean {
     if (schema[Kind] === 'Undefined') return true
+    if (schema[Kind] === 'Not') {
+      const not = schema as TNot
+      return Check(not.allOf[1])
+    }
+    if (schema[Kind] === 'Intersect') {
+      const intersect = schema as TIntersect
+      return intersect.allOf.every((schema) => Check(schema))
+    }
     if (schema[Kind] === 'Union') {
       const union = schema as TUnion
       return union.anyOf.some((schema) => Check(schema))
diff --git a/src/value/check.ts b/src/value/check.ts
index 9b62e00fe..0700dbdd7 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -238,8 +238,8 @@ export namespace ValueCheck {
         if (!Visit(property, references, value[knownKey])) {
           return false
         }
-        if (Types.ExtendsUndefined.Check(property)) {
-          return knownKey in value
+        if (Types.ExtendsUndefined.Check(property) && !(knownKey in value)) {
+          return false
         }
       } else {
         if (IsExactOptionalProperty(value, knownKey) && !Visit(property, references, value[knownKey])) {
diff --git a/test/runtime/compiler/object.ts b/test/runtime/compiler/object.ts
index f1299f7e1..872b987b7 100644
--- a/test/runtime/compiler/object.ts
+++ b/test/runtime/compiler/object.ts
@@ -2,6 +2,33 @@ import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
 describe('type/compiler/Object', () => {
+  // -----------------------------------------------------
+  // TypeCompiler Only
+  // -----------------------------------------------------
+  it('Should handle extends undefined check 1', () => {
+    const T = Type.Object({
+      A: Type.Not(Type.Number(), Type.Undefined()),
+      B: Type.Union([Type.Number(), Type.Undefined()]),
+      C: Type.Intersect([Type.Undefined(), Type.Undefined()]),
+    })
+    Ok(T, {
+      A: undefined,
+      B: undefined,
+      C: undefined,
+    })
+  })
+  // https://github.com/sinclairzx81/typebox/issues/437
+  it('Should handle extends undefined check 2', () => {
+    const T = Type.Object({
+      A: Type.Not(Type.Null(), Type.Undefined()),
+    })
+    Ok(T, { A: undefined })
+    Fail(T, { A: null })
+    Fail(T, {})
+  })
+  // -----------------------------------------------------
+  // Standard Checks
+  // -----------------------------------------------------
   it('Should not validate a number', () => {
     const T = Type.Object({})
     Fail(T, 42)

From 81724d1a72ea18faa36560dac9df5dc402fa14bb Mon Sep 17 00:00:00 2001
From: Erfan Safari <erfanshield@outlook.com>
Date: Wed, 17 May 2023 12:25:04 +0330
Subject: [PATCH 130/369] Documentation (#436)

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 6ff5dbb9b..27e2563bc 100644
--- a/readme.md
+++ b/readme.md
@@ -1277,7 +1277,7 @@ The TypeCompiler is provided as an optional import.
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 ```
 
-Use the `Compile(...)` function to compile a type.
+Use the `Compile(...)` function to compile a type. Note that compilation is an expensive operation that should typically be performed once per type during application start up. TypeBox does not cache previously compiled types, so applications are expected to hold references to each compiled type for the lifetime of the application.
 
 ```typescript
 const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{

From 0b3d247370217d2f77e5728b1246b0955e1743a7 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Thu, 18 May 2023 14:38:53 +0900
Subject: [PATCH 131/369] Documentation

---
 example/typedef/typedef.ts | 12 +++++++++---
 readme.md                  |  2 +-
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/example/typedef/typedef.ts b/example/typedef/typedef.ts
index 544d1b893..131f7ed55 100644
--- a/example/typedef/typedef.ts
+++ b/example/typedef/typedef.ts
@@ -267,11 +267,17 @@ export namespace TypeDefCheck {
     return IsInt(value, 0, Number.MAX_SAFE_INTEGER)
   }
   function Union(schema: TUnion, value: unknown): boolean {
-    return IsObject(value) && 
+    if (!(
+      IsObject(value) && 
       schema.discriminator in value &&
       IsString(value[schema.discriminator]) &&
-      value[schema.discriminator] as any in schema.mapping &&
-      Visit(schema.mapping[value[schema.discriminator] as any], value)
+      value[schema.discriminator] as any in schema.mapping
+    )) return false
+    // We shouldn't create objects just to omit the discriminator (optimize)
+    const inner = globalThis.Object.keys(value).reduce((acc, key) => {
+      return key === schema.discriminator ? acc : { [key]: value[key] }
+    }, {})
+    return Visit(schema.mapping[value[schema.discriminator] as any], inner)
   }
   function Visit(schema: Types.TSchema, value: unknown): boolean {
     const anySchema = schema as any
diff --git a/readme.md b/readme.md
index 27e2563bc..e79f444df 100644
--- a/readme.md
+++ b/readme.md
@@ -1419,7 +1419,7 @@ TypeSystem.AllowNaN = true
 
 ## Workbench
 
-TypeBox offers a web based code generation tool that can be used to create TypeBox types from TypeScript type definitions. This tool is written to prototype new TypeBox features, but can be used to rapidly convert TypeScript type definitions in to TypeBox types as well as raw JSON Schema.
+TypeBox offers a small web based code generation tool that can be used to convert TypeScript types into TypeBox type definitions as well as a variety of other formats.
 
 [Workbench Link Here](https://sinclairzx81.github.io/typebox-workbench/)
 

From 00939c13465a052bba8b43cd3715f27f909ecd2b Mon Sep 17 00:00:00 2001
From: Pierre Dahmani <hi@pierre-dev.com>
Date: Tue, 23 May 2023 05:06:27 +0200
Subject: [PATCH 132/369] Ecosystem (#435)

---
 readme.md | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index e79f444df..a65a96b2d 100644
--- a/readme.md
+++ b/readme.md
@@ -109,6 +109,7 @@ License MIT
   - [Formats](#typesystem-formats)
   - [Policies](#typesystem-policies)
 - [Workbench](#workbench)
+- [Ecosystem](#ecosystem)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
   - [Validate](#benchmark-validate)
@@ -1424,11 +1425,22 @@ TypeBox offers a small web based code generation tool that can be used to conver
 [Workbench Link Here](https://sinclairzx81.github.io/typebox-workbench/)
 
 <div align='center'>
-	
+
 <a href="https://sinclairzx81.github.io/typebox-workbench/"><img src="https://github.com/sinclairzx81/typebox/blob/master/workbench.png?raw=true" /></a>
 
 </div>
 
+<a name='ecosystem'></a>
+
+## Ecosystem
+
+| Package Name  | Short Description |
+| ------------- | ------------- |
+| [elysia](https://github.com/elysiajs/elysia) | Fast and friendly Bun web framework |
+| [fastify-type-provider-typebox](https://github.com/fastify/fastify-type-provider-typebox) | Fastify TypeBox integration with the Fastify Type Provider |
+| [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
+| [ts2typebox](https://github.com/xddq/ts2typebox)  | Cli tool to generate TypeBox JSON schemas based on your Typescript types |
+
 <a name='benchmark'></a>
 
 ## Benchmark

From 21b83967894e6a0736cd455a4f7a870022e46b09 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 23 May 2023 12:13:02 +0900
Subject: [PATCH 133/369] Ecosystem

---
 readme.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/readme.md b/readme.md
index a65a96b2d..8267839d8 100644
--- a/readme.md
+++ b/readme.md
@@ -1434,6 +1434,8 @@ TypeBox offers a small web based code generation tool that can be used to conver
 
 ## Ecosystem
 
+The following is a list of community packages that provide additional framework integration and tooling support for TypeBox.
+
 | Package Name  | Short Description |
 | ------------- | ------------- |
 | [elysia](https://github.com/elysiajs/elysia) | Fast and friendly Bun web framework |

From 479ad6777f2b596122b89a1aa6337bcd9cc3c6c0 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 23 May 2023 12:13:22 +0900
Subject: [PATCH 134/369] Ecosystem

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 8267839d8..f646c72a5 100644
--- a/readme.md
+++ b/readme.md
@@ -1436,7 +1436,7 @@ TypeBox offers a small web based code generation tool that can be used to conver
 
 The following is a list of community packages that provide additional framework integration and tooling support for TypeBox.
 
-| Package Name  | Short Description |
+| Package   |  Description |
 | ------------- | ------------- |
 | [elysia](https://github.com/elysiajs/elysia) | Fast and friendly Bun web framework |
 | [fastify-type-provider-typebox](https://github.com/fastify/fastify-type-provider-typebox) | Fastify TypeBox integration with the Fastify Type Provider |

From 1903324127bf656343900ba2c8cd1b9406673c15 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 25 May 2023 14:49:16 +0900
Subject: [PATCH 135/369] Support Enum Inference In Template Literal (#445)

---
 package-lock.json                         | 18 +++++++--------
 package.json                              |  4 ++--
 readme.md                                 |  2 +-
 src/typebox.ts                            |  2 +-
 test/runtime/compiler/template-literal.ts | 24 +++++++++++++++++++
 test/static/enum.ts                       | 16 +++++++------
 test/static/template-literal.ts           | 28 +++++++++++++++++++++++
 7 files changed, 74 insertions(+), 20 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 5e568c440..a5be00a23 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.11",
+  "version": "0.28.12",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.11",
+      "version": "0.28.12",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
@@ -18,7 +18,7 @@
         "chai": "^4.3.6",
         "mocha": "^9.2.2",
         "prettier": "^2.7.1",
-        "typescript": "^5.0.2"
+        "typescript": "^5.0.4"
       }
     },
     "node_modules/@esbuild/linux-loong64": {
@@ -1410,9 +1410,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.0.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.2.tgz",
-      "integrity": "sha512-wVORMBGO/FAs/++blGNeAVdbNKtIh1rbBL2EyQ1+J9lClJ93KiiKe8PmFIVdXhHcyv44SL9oglmfeSsndo0jRw==",
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.4.tgz",
+      "integrity": "sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -2442,9 +2442,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.0.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.2.tgz",
-      "integrity": "sha512-wVORMBGO/FAs/++blGNeAVdbNKtIh1rbBL2EyQ1+J9lClJ93KiiKe8PmFIVdXhHcyv44SL9oglmfeSsndo0jRw==",
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.4.tgz",
+      "integrity": "sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==",
       "dev": true
     },
     "uri-js": {
diff --git a/package.json b/package.json
index f889ab997..a6df44510 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.11",
+  "version": "0.28.12",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -42,6 +42,6 @@
     "chai": "^4.3.6",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^5.0.2"
+    "typescript": "^5.0.4"
   }
 }
diff --git a/readme.md b/readme.md
index f646c72a5..282c4febd 100644
--- a/readme.md
+++ b/readme.md
@@ -1434,7 +1434,7 @@ TypeBox offers a small web based code generation tool that can be used to conver
 
 ## Ecosystem
 
-The following is a list of community packages that provide additional framework integration and tooling support for TypeBox.
+The following is a list of community packages that provide general tooling and framework support for TypeBox.
 
 | Package   |  Description |
 | ------------- | ------------- |
diff --git a/src/typebox.ts b/src/typebox.ts
index a6c405a49..de871f3b1 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -244,7 +244,7 @@ export interface TEnumOption<T> {
 export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
   [Kind]: 'Union'
   static: T[keyof T]
-  anyOf: TLiteral<string | number>[]
+  anyOf: TLiteral<T[keyof T]>[]
 }
 // --------------------------------------------------------------------------
 // TExtends
diff --git a/test/runtime/compiler/template-literal.ts b/test/runtime/compiler/template-literal.ts
index fb2ebdadb..d0357ae96 100644
--- a/test/runtime/compiler/template-literal.ts
+++ b/test/runtime/compiler/template-literal.ts
@@ -183,4 +183,28 @@ describe('type/compiler/TemplateLiteral', () => {
     Ok(T, 'Adddd')
     Fail(T, 'X')
   })
+  it('Should validate enum (implicit)', () => {
+    enum E {
+      A,
+      B,
+      C,
+    }
+    const T = Type.TemplateLiteral([Type.Literal('hello'), Type.Enum(E)])
+    Ok(T, 'hello0')
+    Ok(T, 'hello1')
+    Ok(T, 'hello2')
+    Fail(T, 'hello3')
+  })
+  it('Should validate enum (explicit)', () => {
+    enum E {
+      A,
+      B = 'B',
+      C = 'C',
+    }
+    const T = Type.TemplateLiteral([Type.Literal('hello'), Type.Enum(E)])
+    Ok(T, 'hello0')
+    Ok(T, 'helloB')
+    Ok(T, 'helloC')
+    Fail(T, 'helloD')
+  })
 })
diff --git a/test/static/enum.ts b/test/static/enum.ts
index aee807c9f..e44ae72aa 100644
--- a/test/static/enum.ts
+++ b/test/static/enum.ts
@@ -1,12 +1,14 @@
 import { Expect } from './assert'
 import { Type, Static } from '@sinclair/typebox'
 
-enum E {
-  A,
-  B = 'hello',
-  C = 42,
-}
+{
+  enum E {
+    A,
+    B = 'hello',
+    C = 42,
+  }
 
-const T = Type.Enum(E)
+  const T = Type.Enum(E)
 
-Expect(T).ToBe<Static<typeof T>>() // ?
+  Expect(T).ToBe<Static<typeof T>>() // ?
+}
diff --git a/test/static/template-literal.ts b/test/static/template-literal.ts
index c46d94af3..1b8ebf3b1 100644
--- a/test/static/template-literal.ts
+++ b/test/static/template-literal.ts
@@ -42,3 +42,31 @@ import { Type } from '@sinclair/typebox'
   const T = Type.TemplateLiteral([Type.Boolean()])
   Expect(T).ToInfer<`${boolean}`>()
 }
+{
+  // Enum Implicit
+  enum E {
+    A,
+    B,
+    C,
+  }
+  const A = Type.Enum(E)
+  const T = Type.TemplateLiteral([Type.Literal('hello'), A])
+  Expect(T).ToInfer<'hello0' | 'hello1' | 'hello2'>()
+}
+{
+  // Enum Explicit
+  enum E {
+    A,
+    B = 'B',
+    C = 'C',
+  }
+  const A = Type.Enum(E)
+  const T = Type.TemplateLiteral([Type.Literal('hello'), A])
+  Expect(T).ToInfer<'hello0' | 'helloB' | 'helloC'>()
+}
+{
+  // Enum Object Explicit
+  const A = Type.Enum(Object.freeze({ a: 'A', b: 'B' }))
+  const T = Type.TemplateLiteral([Type.Literal('hello'), A])
+  Expect(T).ToInfer<'helloA' | 'helloB'>()
+}

From 963447cee6fae1c313927f22d69d50f46d750fff Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 26 May 2023 13:33:03 +0900
Subject: [PATCH 136/369] Assert Array Constraints Before Elements (#448)

---
 package-lock.json        | 4 ++--
 package.json             | 2 +-
 src/compiler/compiler.ts | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index a5be00a23..cf8638870 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.12",
+  "version": "0.28.13",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.12",
+      "version": "0.28.13",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index a6df44510..98d695221 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.12",
+  "version": "0.28.13",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index b2ffb9c76..d737b58d6 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -171,10 +171,10 @@ export namespace TypeCompiler {
   }
   function* Array(schema: Types.TArray, references: Types.TSchema[], value: string): IterableIterator<string> {
     const expression = CreateExpression(schema.items, references, 'value')
-    yield `Array.isArray(${value}) && ${value}.every(value => ${expression})`
     if (IsNumber(schema.minItems)) yield `${value}.length >= ${schema.minItems}`
     if (IsNumber(schema.maxItems)) yield `${value}.length <= ${schema.maxItems}`
     if (schema.uniqueItems === true) yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`
+    yield `Array.isArray(${value}) && ${value}.every(value => ${expression})`
   }
   function* BigInt(schema: Types.TBigInt, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'bigint')`

From 5a5160984dc94fff662f2a69f8252e2d88029363 Mon Sep 17 00:00:00 2001
From: Pierre Dahmani <hi@pierre-dev.com>
Date: Sun, 28 May 2023 04:12:12 +0200
Subject: [PATCH 137/369] Ecosystem (#450)

---
 readme.md | 119 +++++++++++++++++++++++++++---------------------------
 1 file changed, 60 insertions(+), 59 deletions(-)

diff --git a/readme.md b/readme.md
index 282c4febd..5b9bcbbcb 100644
--- a/readme.md
+++ b/readme.md
@@ -3,7 +3,7 @@
 <h1>TypeBox</h1>
 
 <p>JSON Schema Type Builder with Static Type Resolution for TypeScript</p>
-	
+
 <img src="https://github.com/sinclairzx81/typebox/blob/master/typebox.png?raw=true" />
 
 <br />
@@ -65,7 +65,7 @@ type T = Static<typeof T>                            // type T = {
 
 TypeBox is a runtime type builder that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type assertion rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
 
-This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire. 
+This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire.
 
 License MIT
 
@@ -145,23 +145,23 @@ type T = {
 
 const T = Type.Object({                              // const T = {
   id: Type.String(),                                 //   type: 'object',
-  name: Type.String(),                               //   properties: { 
-  timestamp: Type.Integer()                          //     id: { 
-})                                                   //       type: 'string' 
+  name: Type.String(),                               //   properties: {
+  timestamp: Type.Integer()                          //     id: {
+})                                                   //       type: 'string'
                                                      //     },
-                                                     //     name: { 
-                                                     //       type: 'string' 
+                                                     //     name: {
+                                                     //       type: 'string'
                                                      //     },
-                                                     //     timestamp: { 
-                                                     //       type: 'integer' 
+                                                     //     timestamp: {
+                                                     //       type: 'integer'
                                                      //     }
-                                                     //   }, 
+                                                     //   },
                                                      //   required: [
                                                      //     'id',
                                                      //     'name',
                                                      //     'timestamp'
                                                      //   ]
-                                                     // } 
+                                                     // }
 
 //--------------------------------------------------------------------------------------------
 //
@@ -186,7 +186,7 @@ import { Value } from '@sinclair/typebox/value'
 function receive(value: T) {                         // ... as a Static Type
 
   if(Value.Check(T, value)) {                        // ... as a JSON Schema
-  
+
     // ok...
   }
 }
@@ -196,7 +196,7 @@ function receive(value: T) {                         // ... as a Static Type
 
 ## Types
 
-TypeBox types are JSON schema fragments that can be composed into more complex types. Each fragment is structured such that a JSON schema compliant validator can runtime assert a value the same way TypeScript will statically assert a type. TypeBox provides a set of Standard types which are used create JSON schema compliant schematics as well as an Extended type set used to create schematics for constructs native to JavaScript. 
+TypeBox types are JSON schema fragments that can be composed into more complex types. Each fragment is structured such that a JSON schema compliant validator can runtime assert a value the same way TypeScript will statically assert a type. TypeBox provides a set of Standard types which are used create JSON schema compliant schematics as well as an Extended type set used to create schematics for constructs native to JavaScript.
 
 <a name='types-standard'></a>
 
@@ -645,22 +645,22 @@ You can pass JSON Schema options on the last argument of any type. Option hints
 
 ```typescript
 // String must be an email
-const T = Type.String({                              // const T = { 
+const T = Type.String({                              // const T = {
   format: 'email'                                    //   type: 'string',
-})                                                   //   format: 'email' 
+})                                                   //   format: 'email'
                                                      // }
 
 // Mumber must be a multiple of 2
-const T = Type.Number({                              // const T = { 
-  multipleOf: 2                                      //  type: 'number', 
-})                                                   //  multipleOf: 2 
+const T = Type.Number({                              // const T = {
+  multipleOf: 2                                      //  type: 'number',
+})                                                   //  multipleOf: 2
                                                      // }
 
 // Array must have at least 5 integer values
-const T = Type.Array(Type.Integer(), {               // const T = { 
+const T = Type.Array(Type.Integer(), {               // const T = {
   minItems: 5                                        //   type: 'array',
-})                                                   //   minItems: 5,        
-                                                     //   items: { 
+})                                                   //   minItems: 5,
+                                                     //   items: {
                                                      //     type: 'integer'
                                                      //   }
                                                      // }
@@ -737,7 +737,7 @@ const T = Type.String({ $id: 'T' })                  // const T = {
                                                      //    $id: 'T',
                                                      //    type: 'string'
                                                      // }
-                                             
+
 const R = Type.Ref(T)                                // const R = {
                                                      //    $ref: 'T'
                                                      // }
@@ -808,7 +808,7 @@ type T0 = Static<typeof T0>                        // type T0 = false
 
 type T1 = Static<typeof T1>                        // type T1 = number
 
-type T2 = Static<typeof T2>                        // type T2 = string 
+type T2 = Static<typeof T2>                        // type T2 = string
 ```
 
 <a name='types-template-literal'></a>
@@ -876,16 +876,16 @@ const T = Type.Object({                              // const T = {
 
 const A = Type.Index(T, ['x'])                       // const A = { type: 'number' }
 
-const B = Type.Index(T, ['x', 'y'])                  // const B = { 
+const B = Type.Index(T, ['x', 'y'])                  // const B = {
                                                      //   anyOf: [
-                                                     //     { type: 'number' },  
+                                                     //     { type: 'number' },
                                                      //     { type: 'string' }
                                                      //   ]
                                                      // }
 
-const C = Type.Index(T, Type.KeyOf(T))               // const C = { 
+const C = Type.Index(T, Type.KeyOf(T))               // const C = {
                                                      //   anyOf: [
-                                                     //     { type: 'number' },  
+                                                     //     { type: 'number' },
                                                      //     { type: 'string' },
                                                      //     { type: 'boolean' }
                                                      //   ]
@@ -987,7 +987,7 @@ import { Type, TypeGuard } from '@sinclair/typebox'
 const T = Type.String()
 
 if(TypeGuard.TString(T)) {
-    
+
   // T is TString
 }
 ```
@@ -1012,12 +1012,12 @@ const T = Type.Object({                              // const T = {
                                                      // }
 
 const U = Type.Strict(T)                             // const U = {
-                                                     //   type: 'object', 
-                                                     //   properties: { 
-                                                     //     name: { 
-                                                     //       type: 'string' 
-                                                     //     } 
-                                                     //   } 
+                                                     //   type: 'object',
+                                                     //   properties: {
+                                                     //     name: {
+                                                     //       type: 'string'
+                                                     //     }
+                                                     //   }
                                                      // }
 ```
 
@@ -1183,21 +1183,21 @@ const R = [...Value.Errors(T, { x: '42' })]          // const R = [{
 Use the Mutate function to perform a deep mutable value assignment while retaining internal references.
 
 ```typescript
-const Y = { z: 1 }                                   // const Y = { z: 1 } 
+const Y = { z: 1 }                                   // const Y = { z: 1 }
 
 const X = { y: Y }                                   // const X = { y: { z: 1 } }
 
-const A = { x: X }                                   // const A = { x: { y: { z: 1 } } }             
+const A = { x: X }                                   // const A = { x: { y: { z: 1 } } }
 
 
-Value.Mutate(A, { x: { y: { z: 2 } } })              // const A' = { x: { y: { z: 2 } } }   
+Value.Mutate(A, { x: { y: { z: 2 } } })              // const A' = { x: { y: { z: 2 } } }
 
 const R0 = A.x.y.z === 2                             // const R0 = 2
 
 const R1 = A.x.y === Y                               // const R1 = true
 
 const R2 = A.x === X                                 // const R2 = true
-```     
+```
 
 <a name='values-pointer'></a>
 
@@ -1241,29 +1241,29 @@ import addFormats from 'ajv-formats'
 import Ajv        from 'ajv'
 
 const ajv = addFormats(new Ajv({}), [
-  'date-time', 
-  'time', 
-  'date', 
-  'email',  
-  'hostname', 
-  'ipv4', 
-  'ipv6', 
-  'uri', 
-  'uri-reference', 
+  'date-time',
+  'time',
+  'date',
+  'email',
+  'hostname',
+  'ipv4',
+  'ipv6',
+  'uri',
+  'uri-reference',
   'uuid',
-  'uri-template', 
-  'json-pointer', 
-  'relative-json-pointer', 
+  'uri-template',
+  'json-pointer',
+  'relative-json-pointer',
   'regex'
 ])
 
-const C = ajv.compile(Type.Object({                
+const C = ajv.compile(Type.Object({
   x: Type.Number(),
   y: Type.Number(),
   z: Type.Number()
 }))
 
-const R = C({ x: 1, y: 2, z: 3 })                    // const R = true 
+const R = C({ x: 1, y: 2, z: 3 })                    // const R = true
 ```
 
 <a name='typecheck-typecompiler'></a>
@@ -1350,15 +1350,15 @@ import { TypeSystem } from '@sinclair/typebox/system'
 Use the `Type(...)` function to create custom types. This function lets you specify custom value assertion logic and will return a type factory function which is used to instance the type. This function accepts two generic arguments, the first is the inference type, the second is options used to constrain the type. The following creates a Vector type.
 
 ```typescript
-type VectorOptions = { abs: boolean }       
+type VectorOptions = { abs: boolean }
 
 type Vector = { x: number, y: number }
 
 const Vector = TypeSystem.Type<Vector, VectorOptions>('Vector', (options, value) => {
   return (
     typeof value === 'object' && value !== null &&
-    'x' in value && typeof value.x === 'number' && 
-    'y' in value && typeof value.y === 'number' && 
+    'x' in value && typeof value.x === 'number' &&
+    'y' in value && typeof value.y === 'number' &&
     (options.abs ? (value.x === Math.abs(value.x) && value.y === Math.abs(value.y)) : true)
   )
 })
@@ -1383,7 +1383,7 @@ Use the `Format(...)` function to create a custom string format. The following c
 ```typescript
 TypeSystem.Format('lowercase', value => value === value.toLowerCase()) // format should be lowercase
 
-const T = Type.String({ format: 'lowercase' })       
+const T = Type.String({ format: 'lowercase' })
 
 const A = Value.Check(T, 'Hello')                    // const A = false
 
@@ -1407,13 +1407,13 @@ TypeSystem.ExactOptionalPropertyTypes = true
 //
 // const A: {} = [] - allowed in TS
 
-TypeSystem.AllowArrayObjects = true                  
+TypeSystem.AllowArrayObjects = true
 
 // Allow numeric values to be NaN or + or - Infinity (default is false)
 //
 // const A: number = NaN - allowed in TS
 
-TypeSystem.AllowNaN = true                      
+TypeSystem.AllowNaN = true
 ```
 
 <a name='workbench'></a>
@@ -1441,7 +1441,8 @@ The following is a list of community packages that provide general tooling and f
 | [elysia](https://github.com/elysiajs/elysia) | Fast and friendly Bun web framework |
 | [fastify-type-provider-typebox](https://github.com/fastify/fastify-type-provider-typebox) | Fastify TypeBox integration with the Fastify Type Provider |
 | [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
-| [ts2typebox](https://github.com/xddq/ts2typebox)  | Cli tool to generate TypeBox JSON schemas based on your Typescript types |
+| [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from JSON schemas |
+| [ts2typebox](https://github.com/xddq/ts2typebox)  | Creating TypeBox code from Typescript types |
 
 <a name='benchmark'></a>
 

From 1be023b6d0c7b5906d7c766ea9fcdb6aeacf1075 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 30 May 2023 04:18:11 +0900
Subject: [PATCH 138/369] Assert Key for Any and Unknown Property Types (#452)

---
 example/typedef/typedef.ts      |  24 +++---
 package-lock.json               |   4 +-
 package.json                    |   2 +-
 readme.md                       | 130 ++++++++++++++++----------------
 src/compiler/compiler.ts        |   8 +-
 src/value/check.ts              |   8 +-
 test/runtime/compiler/object.ts |  28 +++++++
 7 files changed, 122 insertions(+), 82 deletions(-)

diff --git a/example/typedef/typedef.ts b/example/typedef/typedef.ts
index 131f7ed55..c89b52a56 100644
--- a/example/typedef/typedef.ts
+++ b/example/typedef/typedef.ts
@@ -175,18 +175,18 @@ export interface TUnion<D extends string = string, T extends TStruct[] = TStruct
 // TypeRegistry
 // --------------------------------------------------------------------------
 Types.TypeRegistry.Set<TArray>('TypeDef:Array', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TArray>('TypeDef:Boolean', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TArray>('TypeDef:Int8', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TArray>('TypeDef:Int16', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TArray>('TypeDef:Int32', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TArray>('TypeDef:Uint8', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TArray>('TypeDef:Uint16', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TArray>('TypeDef:Uint32', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TArray>('TypeDef:Record', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TArray>('TypeDef:String', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TArray>('TypeDef:Struct', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TArray>('TypeDef:Timestamp', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TArray>('TypeDef:Union', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TBoolean>('TypeDef:Boolean', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TInt8>('TypeDef:Int8', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TInt16>('TypeDef:Int16', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TInt32>('TypeDef:Int32', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TUint8>('TypeDef:Uint8', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TUint16>('TypeDef:Uint16', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TUint32>('TypeDef:Uint32', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TRecord>('TypeDef:Record', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TString>('TypeDef:String', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TStruct>('TypeDef:Struct', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TTimestamp>('TypeDef:Timestamp', (schema, value) => TypeDefCheck.Check(schema, value))
+Types.TypeRegistry.Set<TUnion>('TypeDef:Union', (schema, value) => TypeDefCheck.Check(schema, value))
 // --------------------------------------------------------------------------
 // TypeDefCheck
 // --------------------------------------------------------------------------
diff --git a/package-lock.json b/package-lock.json
index cf8638870..75f6630b2 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.13",
+  "version": "0.28.14",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.13",
+      "version": "0.28.14",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 98d695221..1a60169aa 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.13",
+  "version": "0.28.14",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 5b9bcbbcb..673870cb6 100644
--- a/readme.md
+++ b/readme.md
@@ -1462,35 +1462,35 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │    1000    │ '    243 ms' │ '      8 ms' │ '   30.38 x' │
-│ Literal_Number             │    1000    │ '    195 ms' │ '      5 ms' │ '   39.00 x' │
-│ Literal_Boolean            │    1000    │ '    162 ms' │ '      4 ms' │ '   40.50 x' │
-│ Primitive_Number           │    1000    │ '    168 ms' │ '      6 ms' │ '   28.00 x' │
-│ Primitive_String           │    1000    │ '    164 ms' │ '      5 ms' │ '   32.80 x' │
-│ Primitive_String_Pattern   │    1000    │ '    214 ms' │ '      9 ms' │ '   23.78 x' │
-│ Primitive_Boolean          │    1000    │ '    132 ms' │ '      4 ms' │ '   33.00 x' │
-│ Primitive_Null             │    1000    │ '    148 ms' │ '      4 ms' │ '   37.00 x' │
-│ Object_Unconstrained       │    1000    │ '   1158 ms' │ '     30 ms' │ '   38.60 x' │
-│ Object_Constrained         │    1000    │ '   1263 ms' │ '     25 ms' │ '   50.52 x' │
-│ Object_Vector3             │    1000    │ '    384 ms' │ '      7 ms' │ '   54.86 x' │
-│ Object_Box3D               │    1000    │ '   1932 ms' │ '     27 ms' │ '   71.56 x' │
-│ Tuple_Primitive            │    1000    │ '    478 ms' │ '     14 ms' │ '   34.14 x' │
-│ Tuple_Object               │    1000    │ '   1232 ms' │ '     14 ms' │ '   88.00 x' │
-│ Composite_Intersect        │    1000    │ '    671 ms' │ '     17 ms' │ '   39.47 x' │
-│ Composite_Union            │    1000    │ '    537 ms' │ '     18 ms' │ '   29.83 x' │
-│ Math_Vector4               │    1000    │ '    816 ms' │ '     14 ms' │ '   58.29 x' │
-│ Math_Matrix4               │    1000    │ '    417 ms' │ '      6 ms' │ '   69.50 x' │
-│ Array_Primitive_Number     │    1000    │ '    378 ms' │ '      5 ms' │ '   75.60 x' │
-│ Array_Primitive_String     │    1000    │ '    353 ms' │ '      6 ms' │ '   58.83 x' │
-│ Array_Primitive_Boolean    │    1000    │ '    279 ms' │ '      5 ms' │ '   55.80 x' │
-│ Array_Object_Unconstrained │    1000    │ '   1794 ms' │ '     20 ms' │ '   89.70 x' │
-│ Array_Object_Constrained   │    1000    │ '   1586 ms' │ '     19 ms' │ '   83.47 x' │
-│ Array_Tuple_Primitive      │    1000    │ '    791 ms' │ '     13 ms' │ '   60.85 x' │
-│ Array_Tuple_Object         │    1000    │ '   1638 ms' │ '     17 ms' │ '   96.35 x' │
-│ Array_Composite_Intersect  │    1000    │ '    796 ms' │ '     17 ms' │ '   46.82 x' │
-│ Array_Composite_Union      │    1000    │ '    798 ms' │ '     15 ms' │ '   53.20 x' │
-│ Array_Math_Vector4         │    1000    │ '   1127 ms' │ '     14 ms' │ '   80.50 x' │
-│ Array_Math_Matrix4         │    1000    │ '    677 ms' │ '      9 ms' │ '   75.22 x' │
+│ Literal_String             │    1000    │ '    230 ms' │ '      7 ms' │ '   32.86 x' │
+│ Literal_Number             │    1000    │ '    171 ms' │ '      4 ms' │ '   42.75 x' │
+│ Literal_Boolean            │    1000    │ '    148 ms' │ '      4 ms' │ '   37.00 x' │
+│ Primitive_Number           │    1000    │ '    160 ms' │ '      6 ms' │ '   26.67 x' │
+│ Primitive_String           │    1000    │ '    149 ms' │ '      6 ms' │ '   24.83 x' │
+│ Primitive_String_Pattern   │    1000    │ '    199 ms' │ '      9 ms' │ '   22.11 x' │
+│ Primitive_Boolean          │    1000    │ '    126 ms' │ '      3 ms' │ '   42.00 x' │
+│ Primitive_Null             │    1000    │ '    141 ms' │ '      4 ms' │ '   35.25 x' │
+│ Object_Unconstrained       │    1000    │ '   1105 ms' │ '     27 ms' │ '   40.93 x' │
+│ Object_Constrained         │    1000    │ '   1178 ms' │ '     22 ms' │ '   53.55 x' │
+│ Object_Vector3             │    1000    │ '    368 ms' │ '      8 ms' │ '   46.00 x' │
+│ Object_Box3D               │    1000    │ '   1668 ms' │ '     28 ms' │ '   59.57 x' │
+│ Tuple_Primitive            │    1000    │ '    446 ms' │ '     12 ms' │ '   37.17 x' │
+│ Tuple_Object               │    1000    │ '   1146 ms' │ '     15 ms' │ '   76.40 x' │
+│ Composite_Intersect        │    1000    │ '    661 ms' │ '     18 ms' │ '   36.72 x' │
+│ Composite_Union            │    1000    │ '    513 ms' │ '     17 ms' │ '   30.18 x' │
+│ Math_Vector4               │    1000    │ '    767 ms' │ '     10 ms' │ '   76.70 x' │
+│ Math_Matrix4               │    1000    │ '    396 ms' │ '     10 ms' │ '   39.60 x' │
+│ Array_Primitive_Number     │    1000    │ '    353 ms' │ '      8 ms' │ '   44.13 x' │
+│ Array_Primitive_String     │    1000    │ '    358 ms' │ '      5 ms' │ '   71.60 x' │
+│ Array_Primitive_Boolean    │    1000    │ '    265 ms' │ '      3 ms' │ '   88.33 x' │
+│ Array_Object_Unconstrained │    1000    │ '   1476 ms' │ '     19 ms' │ '   77.68 x' │
+│ Array_Object_Constrained   │    1000    │ '   1698 ms' │ '     20 ms' │ '   84.90 x' │
+│ Array_Tuple_Primitive      │    1000    │ '    654 ms' │ '      9 ms' │ '   72.67 x' │
+│ Array_Tuple_Object         │    1000    │ '   1492 ms' │ '     15 ms' │ '   99.47 x' │
+│ Array_Composite_Intersect  │    1000    │ '   1045 ms' │ '     16 ms' │ '   65.31 x' │
+│ Array_Composite_Union      │    1000    │ '    702 ms' │ '     14 ms' │ '   50.14 x' │
+│ Array_Math_Vector4         │    1000    │ '   1016 ms' │ '     12 ms' │ '   84.67 x' │
+│ Array_Math_Matrix4         │    1000    │ '    621 ms' │ '      5 ms' │ '  124.20 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1504,37 +1504,37 @@ This benchmark measures validation performance for varying types. You can review
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │  1000000   │ '     24 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
-│ Literal_Number             │  1000000   │ '     21 ms' │ '     17 ms' │ '     10 ms' │ '    1.70 x' │
-│ Literal_Boolean            │  1000000   │ '     19 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│ Primitive_Number           │  1000000   │ '     24 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
-│ Primitive_String           │  1000000   │ '     26 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Primitive_String_Pattern   │  1000000   │ '    159 ms' │ '     45 ms' │ '     36 ms' │ '    1.25 x' │
-│ Primitive_Boolean          │  1000000   │ '     22 ms' │ '     17 ms' │ '     10 ms' │ '    1.70 x' │
-│ Primitive_Null             │  1000000   │ '     23 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Object_Unconstrained       │  1000000   │ '    914 ms' │ '     34 ms' │ '     26 ms' │ '    1.31 x' │
-│ Object_Constrained         │  1000000   │ '   1095 ms' │ '     50 ms' │ '     38 ms' │ '    1.32 x' │
-│ Object_Vector3             │  1000000   │ '    414 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
-│ Object_Box3D               │  1000000   │ '   1933 ms' │ '     55 ms' │ '     53 ms' │ '    1.04 x' │
-│ Object_Recursive           │  1000000   │ '   4995 ms' │ '    378 ms' │ '    177 ms' │ '    2.14 x' │
-│ Tuple_Primitive            │  1000000   │ '    168 ms' │ '     24 ms' │ '     13 ms' │ '    1.85 x' │
-│ Tuple_Object               │  1000000   │ '    681 ms' │ '     31 ms' │ '     19 ms' │ '    1.63 x' │
-│ Composite_Intersect        │  1000000   │ '    718 ms' │ '     25 ms' │ '     15 ms' │ '    1.67 x' │
-│ Composite_Union            │  1000000   │ '    511 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
-│ Math_Vector4               │  1000000   │ '    285 ms' │ '     23 ms' │ '     12 ms' │ '    1.92 x' │
-│ Math_Matrix4               │  1000000   │ '   1197 ms' │ '     39 ms' │ '     28 ms' │ '    1.39 x' │
-│ Array_Primitive_Number     │  1000000   │ '    294 ms' │ '     22 ms' │ '     12 ms' │ '    1.83 x' │
-│ Array_Primitive_String     │  1000000   │ '    251 ms' │ '     22 ms' │ '     14 ms' │ '    1.57 x' │
-│ Array_Primitive_Boolean    │  1000000   │ '    131 ms' │ '     22 ms' │ '     14 ms' │ '    1.57 x' │
-│ Array_Object_Unconstrained │  1000000   │ '   5249 ms' │ '     69 ms' │ '     56 ms' │ '    1.23 x' │
-│ Array_Object_Constrained   │  1000000   │ '   5299 ms' │ '    127 ms' │ '    123 ms' │ '    1.03 x' │
-│ Array_Object_Recursive     │  1000000   │ '  19609 ms' │ '   1711 ms' │ '    608 ms' │ '    2.81 x' │
-│ Array_Tuple_Primitive      │  1000000   │ '    734 ms' │ '     38 ms' │ '     30 ms' │ '    1.27 x' │
-│ Array_Tuple_Object         │  1000000   │ '   2843 ms' │ '     63 ms' │ '     51 ms' │ '    1.24 x' │
-│ Array_Composite_Intersect  │  1000000   │ '   2794 ms' │ '     43 ms' │ '     36 ms' │ '    1.19 x' │
-│ Array_Composite_Union      │  1000000   │ '   1892 ms' │ '     66 ms' │ '     33 ms' │ '    2.00 x' │
-│ Array_Math_Vector4         │  1000000   │ '   1177 ms' │ '     37 ms' │ '     23 ms' │ '    1.61 x' │
-│ Array_Math_Matrix4         │  1000000   │ '   5115 ms' │ '    110 ms' │ '     85 ms' │ '    1.29 x' │
+│ Literal_String             │  1000000   │ '     22 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
+│ Literal_Number             │  1000000   │ '     19 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Literal_Boolean            │  1000000   │ '     18 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Primitive_Number           │  1000000   │ '     23 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Primitive_String           │  1000000   │ '     23 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
+│ Primitive_String_Pattern   │  1000000   │ '    171 ms' │ '     42 ms' │ '     36 ms' │ '    1.17 x' │
+│ Primitive_Boolean          │  1000000   │ '     20 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Primitive_Null             │  1000000   │ '     21 ms' │ '     16 ms' │ '      8 ms' │ '    2.00 x' │
+│ Object_Unconstrained       │  1000000   │ '   1099 ms' │ '     31 ms' │ '     25 ms' │ '    1.24 x' │
+│ Object_Constrained         │  1000000   │ '   1224 ms' │ '     51 ms' │ '     36 ms' │ '    1.42 x' │
+│ Object_Vector3             │  1000000   │ '    420 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
+│ Object_Box3D               │  1000000   │ '   2012 ms' │ '     53 ms' │ '     43 ms' │ '    1.23 x' │
+│ Object_Recursive           │  1000000   │ '   5080 ms' │ '    320 ms' │ '    150 ms' │ '    2.13 x' │
+│ Tuple_Primitive            │  1000000   │ '    154 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
+│ Tuple_Object               │  1000000   │ '    749 ms' │ '     27 ms' │ '     18 ms' │ '    1.50 x' │
+│ Composite_Intersect        │  1000000   │ '    775 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
+│ Composite_Union            │  1000000   │ '    533 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
+│ Math_Vector4               │  1000000   │ '    275 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
+│ Math_Matrix4               │  1000000   │ '   1136 ms' │ '     37 ms' │ '     26 ms' │ '    1.42 x' │
+│ Array_Primitive_Number     │  1000000   │ '    316 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
+│ Array_Primitive_String     │  1000000   │ '    239 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
+│ Array_Primitive_Boolean    │  1000000   │ '    151 ms' │ '     20 ms' │ '     15 ms' │ '    1.33 x' │
+│ Array_Object_Unconstrained │  1000000   │ '   5809 ms' │ '     64 ms' │ '     56 ms' │ '    1.14 x' │
+│ Array_Object_Constrained   │  1000000   │ '   6210 ms' │ '    123 ms' │ '    101 ms' │ '    1.22 x' │
+│ Array_Object_Recursive     │  1000000   │ '  21779 ms' │ '   1466 ms' │ '    548 ms' │ '    2.68 x' │
+│ Array_Tuple_Primitive      │  1000000   │ '    730 ms' │ '     36 ms' │ '     29 ms' │ '    1.24 x' │
+│ Array_Tuple_Object         │  1000000   │ '   3259 ms' │ '     63 ms' │ '     49 ms' │ '    1.29 x' │
+│ Array_Composite_Intersect  │  1000000   │ '   3276 ms' │ '     44 ms' │ '     34 ms' │ '    1.29 x' │
+│ Array_Composite_Union      │  1000000   │ '   2279 ms' │ '     64 ms' │ '     31 ms' │ '    2.06 x' │
+│ Array_Math_Vector4         │  1000000   │ '   1139 ms' │ '     36 ms' │ '     23 ms' │ '    1.57 x' │
+│ Array_Math_Matrix4         │  1000000   │ '   4924 ms' │ '    110 ms' │ '     92 ms' │ '    1.20 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1548,11 +1548,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '127.1 kb' │ ' 56.7 kb' │  '2.24 x'   │
-│ typebox/errors       │ '110.9 kb' │ ' 48.9 kb' │  '2.27 x'   │
-│ typebox/system       │ ' 76.3 kb' │ ' 31.2 kb' │  '2.44 x'   │
-│ typebox/value        │ '176.8 kb' │ ' 76.5 kb' │  '2.31 x'   │
-│ typebox              │ ' 75.2 kb' │ ' 30.8 kb' │  '2.44 x'   │
+│ typebox/compiler     │ '128.0 kb' │ ' 56.9 kb' │  '2.25 x'   │
+│ typebox/errors       │ '111.6 kb' │ ' 49.1 kb' │  '2.27 x'   │
+│ typebox/system       │ ' 77.0 kb' │ ' 31.5 kb' │  '2.45 x'   │
+│ typebox/value        │ '177.7 kb' │ ' 76.8 kb' │  '2.31 x'   │
+│ typebox              │ ' 75.9 kb' │ ' 31.0 kb' │  '2.45 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index d737b58d6..424ed4c49 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -143,6 +143,12 @@ export namespace TypeCompiler {
   function IsString(value: unknown): value is string {
     return typeof value === 'string'
   }
+  // ----------------------------------------------------------------------
+  // SchemaGuards
+  // ----------------------------------------------------------------------
+  function IsAnyOrUnknown(schema: Types.TSchema) {
+    return schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown'
+  }
   // -------------------------------------------------------------------
   // Polices
   // -------------------------------------------------------------------
@@ -258,7 +264,7 @@ export namespace TypeCompiler {
       const property = schema.properties[knownKey]
       if (schema.required && schema.required.includes(knownKey)) {
         yield* Visit(property, references, memberExpression)
-        if (Types.ExtendsUndefined.Check(property)) yield `('${knownKey}' in ${value})`
+        if (Types.ExtendsUndefined.Check(property) || IsAnyOrUnknown(property)) yield `('${knownKey}' in ${value})`
       } else {
         const expression = CreateExpression(property, references, memberExpression)
         yield IsExactOptionalProperty(value, knownKey, expression)
diff --git a/src/value/check.ts b/src/value/check.ts
index 0700dbdd7..40c2fd5ef 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -60,6 +60,12 @@ export namespace ValueCheck {
     return value !== undefined
   }
   // ----------------------------------------------------------------------
+  // SchemaGuards
+  // ----------------------------------------------------------------------
+  function IsAnyOrUnknown(schema: Types.TSchema) {
+    return schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown'
+  }
+  // ----------------------------------------------------------------------
   // Policies
   // ----------------------------------------------------------------------
   function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string) {
@@ -238,7 +244,7 @@ export namespace ValueCheck {
         if (!Visit(property, references, value[knownKey])) {
           return false
         }
-        if (Types.ExtendsUndefined.Check(property) && !(knownKey in value)) {
+        if ((Types.ExtendsUndefined.Check(property) || IsAnyOrUnknown(property)) && !(knownKey in value)) {
           return false
         }
       } else {
diff --git a/test/runtime/compiler/object.ts b/test/runtime/compiler/object.ts
index 872b987b7..47a59a685 100644
--- a/test/runtime/compiler/object.ts
+++ b/test/runtime/compiler/object.ts
@@ -361,4 +361,32 @@ describe('type/compiler/Object', () => {
     Ok(T, { x: undefined })
     Ok(T, {})
   })
+  it('Should check for required property of any', () => {
+    const T = Type.Object({ x: Type.Any() })
+    Fail(T, {})
+    Ok(T, { x: undefined })
+    Ok(T, { x: 1 })
+    Ok(T, { x: true })
+  })
+  it('Should check for required property of unknown', () => {
+    const T = Type.Object({ x: Type.Unknown() })
+    Fail(T, {})
+    Ok(T, { x: undefined })
+    Ok(T, { x: 1 })
+    Ok(T, { x: true })
+  })
+  it('Should check for required property of any (when optional)', () => {
+    const T = Type.Object({ x: Type.Optional(Type.Any()) })
+    Ok(T, {})
+    Ok(T, { x: undefined })
+    Ok(T, { x: 1 })
+    Ok(T, { x: true })
+  })
+  it('Should check for required property of unknown (when optional)', () => {
+    const T = Type.Object({ x: Type.Optional(Type.Unknown()) })
+    Ok(T, {})
+    Ok(T, { x: undefined })
+    Ok(T, { x: 1 })
+    Ok(T, { x: true })
+  })
 })

From 935394faacaa5449fe6bc02846fc1e535163619e Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 30 May 2023 04:19:29 +0900
Subject: [PATCH 139/369] Documentation

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 673870cb6..be7b63f5d 100644
--- a/readme.md
+++ b/readme.md
@@ -1192,7 +1192,7 @@ const A = { x: X }                                   // const A = { x: { y: { z:
 
 Value.Mutate(A, { x: { y: { z: 2 } } })              // const A' = { x: { y: { z: 2 } } }
 
-const R0 = A.x.y.z === 2                             // const R0 = 2
+const R0 = A.x.y.z === 2                             // const R0 = true
 
 const R1 = A.x.y === Y                               // const R1 = true
 

From 8878f5a9ae0073c0bb52e145d172739911dd1570 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Fri, 2 Jun 2023 11:23:15 +0900
Subject: [PATCH 140/369] Update TypeScript 5.1.3

---
 package-lock.json | 16 ++++++++--------
 package.json      |  2 +-
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 75f6630b2..8a8b8f60f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -18,7 +18,7 @@
         "chai": "^4.3.6",
         "mocha": "^9.2.2",
         "prettier": "^2.7.1",
-        "typescript": "^5.0.4"
+        "typescript": "^5.1.3"
       }
     },
     "node_modules/@esbuild/linux-loong64": {
@@ -1410,16 +1410,16 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.0.4",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.4.tgz",
-      "integrity": "sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==",
+      "version": "5.1.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.1.3.tgz",
+      "integrity": "sha512-XH627E9vkeqhlZFQuL+UsyAXEnibT0kWR2FWONlr4sTjvxyJYnyefgrkyECLzM5NenmKzRAy2rR/OlYLA1HkZw==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
       },
       "engines": {
-        "node": ">=12.20"
+        "node": ">=14.17"
       }
     },
     "node_modules/uri-js": {
@@ -2442,9 +2442,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.0.4",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.4.tgz",
-      "integrity": "sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==",
+      "version": "5.1.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.1.3.tgz",
+      "integrity": "sha512-XH627E9vkeqhlZFQuL+UsyAXEnibT0kWR2FWONlr4sTjvxyJYnyefgrkyECLzM5NenmKzRAy2rR/OlYLA1HkZw==",
       "dev": true
     },
     "uri-js": {
diff --git a/package.json b/package.json
index 1a60169aa..7dad4c690 100644
--- a/package.json
+++ b/package.json
@@ -42,6 +42,6 @@
     "chai": "^4.3.6",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.1.3"
   }
 }

From 2b0d0f4d37080c9a2fb1a1b50923a0e5e43a03a0 Mon Sep 17 00:00:00 2001
From: melbourne2991 <wleach1992@gmail.com>
Date: Sat, 10 Jun 2023 17:12:22 +1000
Subject: [PATCH 141/369] Hoist Types with Identifiers (#456)

Co-authored-by: Will Leach <willleach@Wills-MacBook-Pro.local>
---
 src/compiler/compiler.ts | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 424ed4c49..9a6b6cbc5 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -364,19 +364,25 @@ export namespace TypeCompiler {
     state_remote_custom_types.set(schema_key, schema)
     yield `custom('${schema[Types.Kind]}', '${schema_key}', ${value})`
   }
-  function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: string, root = false): IterableIterator<string> {
     const references_ = IsString(schema.$id) ? [...references, schema] : references
     const schema_ = schema as any
     // Reference: Referenced schemas can originate from either additional schemas
     // or inline in the schema itself. Ideally the recursive path should align to
     // reference path. Consider for refactor.
-    if (IsString(schema.$id) && !state_local_function_names.has(schema.$id)) {
-      state_local_function_names.add(schema.$id)
+    if (IsString(schema.$id)) {
       const name = CreateFunctionName(schema.$id)
-      const body = CreateFunction(name, schema, references, 'value')
-      PushFunction(body)
-      yield `${name}(${value})`
-      return
+
+      if (!state_local_function_names.has(schema.$id)) {
+        state_local_function_names.add(schema.$id)
+        const body = CreateFunction(name, schema, references, 'value')
+        PushFunction(body)
+      }
+
+      if (!root) {
+        yield `${name}(${value})`
+        return
+      }
     }
     switch (schema_[Types.Kind]) {
       case 'Any':
@@ -458,7 +464,7 @@ export namespace TypeCompiler {
     return `check_${Identifier.Encode($id)}`
   }
   function CreateFunction(name: string, schema: Types.TSchema, references: Types.TSchema[], value: string): string {
-    const expression = [...Visit(schema, references, value)].map((condition) => `    ${condition}`).join(' &&\n')
+    const expression = [...Visit(schema, references, value, true)].map((condition) => `    ${condition}`).join(' &&\n')
     return `function ${name}(value) {\n  return (\n${expression}\n )\n}`
   }
   function PushFunction(functionBody: string) {

From 5823bf99f2ab13895a5af2b82990d30c685fdbbe Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 10 Jun 2023 17:04:26 +0900
Subject: [PATCH 142/369] Ensure Types With Identifiers are Hoisted (#458)

---
 package-lock.json        |   4 +-
 package.json             |   2 +-
 readme.md                | 122 +++++++++++++++++++--------------------
 src/compiler/compiler.ts |  21 ++++---
 4 files changed, 74 insertions(+), 75 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 8a8b8f60f..92701e4ed 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.14",
+  "version": "0.28.15",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.14",
+      "version": "0.28.15",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 7dad4c690..eb06253a7 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.14",
+  "version": "0.28.15",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index be7b63f5d..49f8b1c85 100644
--- a/readme.md
+++ b/readme.md
@@ -1462,35 +1462,35 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │    1000    │ '    230 ms' │ '      7 ms' │ '   32.86 x' │
-│ Literal_Number             │    1000    │ '    171 ms' │ '      4 ms' │ '   42.75 x' │
-│ Literal_Boolean            │    1000    │ '    148 ms' │ '      4 ms' │ '   37.00 x' │
-│ Primitive_Number           │    1000    │ '    160 ms' │ '      6 ms' │ '   26.67 x' │
-│ Primitive_String           │    1000    │ '    149 ms' │ '      6 ms' │ '   24.83 x' │
-│ Primitive_String_Pattern   │    1000    │ '    199 ms' │ '      9 ms' │ '   22.11 x' │
-│ Primitive_Boolean          │    1000    │ '    126 ms' │ '      3 ms' │ '   42.00 x' │
-│ Primitive_Null             │    1000    │ '    141 ms' │ '      4 ms' │ '   35.25 x' │
-│ Object_Unconstrained       │    1000    │ '   1105 ms' │ '     27 ms' │ '   40.93 x' │
-│ Object_Constrained         │    1000    │ '   1178 ms' │ '     22 ms' │ '   53.55 x' │
-│ Object_Vector3             │    1000    │ '    368 ms' │ '      8 ms' │ '   46.00 x' │
-│ Object_Box3D               │    1000    │ '   1668 ms' │ '     28 ms' │ '   59.57 x' │
-│ Tuple_Primitive            │    1000    │ '    446 ms' │ '     12 ms' │ '   37.17 x' │
-│ Tuple_Object               │    1000    │ '   1146 ms' │ '     15 ms' │ '   76.40 x' │
-│ Composite_Intersect        │    1000    │ '    661 ms' │ '     18 ms' │ '   36.72 x' │
-│ Composite_Union            │    1000    │ '    513 ms' │ '     17 ms' │ '   30.18 x' │
-│ Math_Vector4               │    1000    │ '    767 ms' │ '     10 ms' │ '   76.70 x' │
-│ Math_Matrix4               │    1000    │ '    396 ms' │ '     10 ms' │ '   39.60 x' │
-│ Array_Primitive_Number     │    1000    │ '    353 ms' │ '      8 ms' │ '   44.13 x' │
-│ Array_Primitive_String     │    1000    │ '    358 ms' │ '      5 ms' │ '   71.60 x' │
-│ Array_Primitive_Boolean    │    1000    │ '    265 ms' │ '      3 ms' │ '   88.33 x' │
-│ Array_Object_Unconstrained │    1000    │ '   1476 ms' │ '     19 ms' │ '   77.68 x' │
-│ Array_Object_Constrained   │    1000    │ '   1698 ms' │ '     20 ms' │ '   84.90 x' │
-│ Array_Tuple_Primitive      │    1000    │ '    654 ms' │ '      9 ms' │ '   72.67 x' │
-│ Array_Tuple_Object         │    1000    │ '   1492 ms' │ '     15 ms' │ '   99.47 x' │
-│ Array_Composite_Intersect  │    1000    │ '   1045 ms' │ '     16 ms' │ '   65.31 x' │
-│ Array_Composite_Union      │    1000    │ '    702 ms' │ '     14 ms' │ '   50.14 x' │
-│ Array_Math_Vector4         │    1000    │ '   1016 ms' │ '     12 ms' │ '   84.67 x' │
-│ Array_Math_Matrix4         │    1000    │ '    621 ms' │ '      5 ms' │ '  124.20 x' │
+│ Literal_String             │    1000    │ '    220 ms' │ '      6 ms' │ '   36.67 x' │
+│ Literal_Number             │    1000    │ '    172 ms' │ '      4 ms' │ '   43.00 x' │
+│ Literal_Boolean            │    1000    │ '    162 ms' │ '      4 ms' │ '   40.50 x' │
+│ Primitive_Number           │    1000    │ '    161 ms' │ '      6 ms' │ '   26.83 x' │
+│ Primitive_String           │    1000    │ '    154 ms' │ '      4 ms' │ '   38.50 x' │
+│ Primitive_String_Pattern   │    1000    │ '    204 ms' │ '     10 ms' │ '   20.40 x' │
+│ Primitive_Boolean          │    1000    │ '    131 ms' │ '      4 ms' │ '   32.75 x' │
+│ Primitive_Null             │    1000    │ '    142 ms' │ '      5 ms' │ '   28.40 x' │
+│ Object_Unconstrained       │    1000    │ '   1263 ms' │ '     29 ms' │ '   43.55 x' │
+│ Object_Constrained         │    1000    │ '   1267 ms' │ '     24 ms' │ '   52.79 x' │
+│ Object_Vector3             │    1000    │ '    382 ms' │ '      7 ms' │ '   54.57 x' │
+│ Object_Box3D               │    1000    │ '   1723 ms' │ '     28 ms' │ '   61.54 x' │
+│ Tuple_Primitive            │    1000    │ '    495 ms' │ '     13 ms' │ '   38.08 x' │
+│ Tuple_Object               │    1000    │ '   1271 ms' │ '     16 ms' │ '   79.44 x' │
+│ Composite_Intersect        │    1000    │ '    656 ms' │ '     19 ms' │ '   34.53 x' │
+│ Composite_Union            │    1000    │ '    529 ms' │ '     18 ms' │ '   29.39 x' │
+│ Math_Vector4               │    1000    │ '    802 ms' │ '     14 ms' │ '   57.29 x' │
+│ Math_Matrix4               │    1000    │ '    411 ms' │ '      6 ms' │ '   68.50 x' │
+│ Array_Primitive_Number     │    1000    │ '    369 ms' │ '      6 ms' │ '   61.50 x' │
+│ Array_Primitive_String     │    1000    │ '    369 ms' │ '      4 ms' │ '   92.25 x' │
+│ Array_Primitive_Boolean    │    1000    │ '    297 ms' │ '      3 ms' │ '   99.00 x' │
+│ Array_Object_Unconstrained │    1000    │ '   1582 ms' │ '     20 ms' │ '   79.10 x' │
+│ Array_Object_Constrained   │    1000    │ '   1629 ms' │ '     19 ms' │ '   85.74 x' │
+│ Array_Tuple_Primitive      │    1000    │ '    652 ms' │ '     12 ms' │ '   54.33 x' │
+│ Array_Tuple_Object         │    1000    │ '   1587 ms' │ '     16 ms' │ '   99.19 x' │
+│ Array_Composite_Intersect  │    1000    │ '   1051 ms' │ '     15 ms' │ '   70.07 x' │
+│ Array_Composite_Union      │    1000    │ '    733 ms' │ '     15 ms' │ '   48.87 x' │
+│ Array_Math_Vector4         │    1000    │ '   1071 ms' │ '     12 ms' │ '   89.25 x' │
+│ Array_Math_Matrix4         │    1000    │ '    636 ms' │ '      5 ms' │ '  127.20 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1504,37 +1504,37 @@ This benchmark measures validation performance for varying types. You can review
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │  1000000   │ '     22 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
-│ Literal_Number             │  1000000   │ '     19 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Literal_Boolean            │  1000000   │ '     18 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Primitive_Number           │  1000000   │ '     23 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Primitive_String           │  1000000   │ '     23 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
-│ Primitive_String_Pattern   │  1000000   │ '    171 ms' │ '     42 ms' │ '     36 ms' │ '    1.17 x' │
-│ Primitive_Boolean          │  1000000   │ '     20 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Primitive_Null             │  1000000   │ '     21 ms' │ '     16 ms' │ '      8 ms' │ '    2.00 x' │
-│ Object_Unconstrained       │  1000000   │ '   1099 ms' │ '     31 ms' │ '     25 ms' │ '    1.24 x' │
-│ Object_Constrained         │  1000000   │ '   1224 ms' │ '     51 ms' │ '     36 ms' │ '    1.42 x' │
-│ Object_Vector3             │  1000000   │ '    420 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
-│ Object_Box3D               │  1000000   │ '   2012 ms' │ '     53 ms' │ '     43 ms' │ '    1.23 x' │
-│ Object_Recursive           │  1000000   │ '   5080 ms' │ '    320 ms' │ '    150 ms' │ '    2.13 x' │
-│ Tuple_Primitive            │  1000000   │ '    154 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
-│ Tuple_Object               │  1000000   │ '    749 ms' │ '     27 ms' │ '     18 ms' │ '    1.50 x' │
-│ Composite_Intersect        │  1000000   │ '    775 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
-│ Composite_Union            │  1000000   │ '    533 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
-│ Math_Vector4               │  1000000   │ '    275 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
-│ Math_Matrix4               │  1000000   │ '   1136 ms' │ '     37 ms' │ '     26 ms' │ '    1.42 x' │
-│ Array_Primitive_Number     │  1000000   │ '    316 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
-│ Array_Primitive_String     │  1000000   │ '    239 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
-│ Array_Primitive_Boolean    │  1000000   │ '    151 ms' │ '     20 ms' │ '     15 ms' │ '    1.33 x' │
-│ Array_Object_Unconstrained │  1000000   │ '   5809 ms' │ '     64 ms' │ '     56 ms' │ '    1.14 x' │
-│ Array_Object_Constrained   │  1000000   │ '   6210 ms' │ '    123 ms' │ '    101 ms' │ '    1.22 x' │
-│ Array_Object_Recursive     │  1000000   │ '  21779 ms' │ '   1466 ms' │ '    548 ms' │ '    2.68 x' │
-│ Array_Tuple_Primitive      │  1000000   │ '    730 ms' │ '     36 ms' │ '     29 ms' │ '    1.24 x' │
-│ Array_Tuple_Object         │  1000000   │ '   3259 ms' │ '     63 ms' │ '     49 ms' │ '    1.29 x' │
-│ Array_Composite_Intersect  │  1000000   │ '   3276 ms' │ '     44 ms' │ '     34 ms' │ '    1.29 x' │
-│ Array_Composite_Union      │  1000000   │ '   2279 ms' │ '     64 ms' │ '     31 ms' │ '    2.06 x' │
-│ Array_Math_Vector4         │  1000000   │ '   1139 ms' │ '     36 ms' │ '     23 ms' │ '    1.57 x' │
-│ Array_Math_Matrix4         │  1000000   │ '   4924 ms' │ '    110 ms' │ '     92 ms' │ '    1.20 x' │
+│ Literal_String             │  1000000   │ '     24 ms' │ '      5 ms' │ '      5 ms' │ '    1.00 x' │
+│ Literal_Number             │  1000000   │ '     21 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Literal_Boolean            │  1000000   │ '     18 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
+│ Primitive_Number           │  1000000   │ '     25 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
+│ Primitive_String           │  1000000   │ '     25 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Primitive_String_Pattern   │  1000000   │ '    174 ms' │ '     44 ms' │ '     36 ms' │ '    1.22 x' │
+│ Primitive_Boolean          │  1000000   │ '     22 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Primitive_Null             │  1000000   │ '     22 ms' │ '     16 ms' │ '      9 ms' │ '    1.78 x' │
+│ Object_Unconstrained       │  1000000   │ '   1065 ms' │ '     33 ms' │ '     25 ms' │ '    1.32 x' │
+│ Object_Constrained         │  1000000   │ '   1192 ms' │ '     53 ms' │ '     38 ms' │ '    1.39 x' │
+│ Object_Vector3             │  1000000   │ '    410 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
+│ Object_Box3D               │  1000000   │ '   1939 ms' │ '     54 ms' │ '     50 ms' │ '    1.08 x' │
+│ Object_Recursive           │  1000000   │ '   5248 ms' │ '    355 ms' │ '    149 ms' │ '    2.38 x' │
+│ Tuple_Primitive            │  1000000   │ '    163 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
+│ Tuple_Object               │  1000000   │ '    737 ms' │ '     29 ms' │ '     20 ms' │ '    1.45 x' │
+│ Composite_Intersect        │  1000000   │ '    761 ms' │ '     24 ms' │ '     15 ms' │ '    1.60 x' │
+│ Composite_Union            │  1000000   │ '    519 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
+│ Math_Vector4               │  1000000   │ '    247 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
+│ Math_Matrix4               │  1000000   │ '   1045 ms' │ '     39 ms' │ '     27 ms' │ '    1.44 x' │
+│ Array_Primitive_Number     │  1000000   │ '    256 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
+│ Array_Primitive_String     │  1000000   │ '    222 ms' │ '     21 ms' │ '     14 ms' │ '    1.50 x' │
+│ Array_Primitive_Boolean    │  1000000   │ '    149 ms' │ '     22 ms' │ '     16 ms' │ '    1.38 x' │
+│ Array_Object_Unconstrained │  1000000   │ '   5473 ms' │ '     67 ms' │ '     59 ms' │ '    1.14 x' │
+│ Array_Object_Constrained   │  1000000   │ '   5548 ms' │ '    130 ms' │ '    116 ms' │ '    1.12 x' │
+│ Array_Object_Recursive     │  1000000   │ '  21047 ms' │ '   1710 ms' │ '    584 ms' │ '    2.93 x' │
+│ Array_Tuple_Primitive      │  1000000   │ '    691 ms' │ '     35 ms' │ '     29 ms' │ '    1.21 x' │
+│ Array_Tuple_Object         │  1000000   │ '   3075 ms' │ '     63 ms' │ '     50 ms' │ '    1.26 x' │
+│ Array_Composite_Intersect  │  1000000   │ '   3126 ms' │ '     44 ms' │ '     35 ms' │ '    1.26 x' │
+│ Array_Composite_Union      │  1000000   │ '   2086 ms' │ '     68 ms' │ '     33 ms' │ '    2.06 x' │
+│ Array_Math_Vector4         │  1000000   │ '   1069 ms' │ '     38 ms' │ '     23 ms' │ '    1.65 x' │
+│ Array_Math_Matrix4         │  1000000   │ '   4559 ms' │ '    111 ms' │ '     88 ms' │ '    1.26 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1548,7 +1548,7 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '128.0 kb' │ ' 56.9 kb' │  '2.25 x'   │
+│ typebox/compiler     │ '128.0 kb' │ ' 57.0 kb' │  '2.25 x'   │
 │ typebox/errors       │ '111.6 kb' │ ' 49.1 kb' │  '2.27 x'   │
 │ typebox/system       │ ' 77.0 kb' │ ' 31.5 kb' │  '2.45 x'   │
 │ typebox/value        │ '177.7 kb' │ ' 76.8 kb' │  '2.31 x'   │
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 9a6b6cbc5..961f9fffb 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -367,22 +367,18 @@ export namespace TypeCompiler {
   function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: string, root = false): IterableIterator<string> {
     const references_ = IsString(schema.$id) ? [...references, schema] : references
     const schema_ = schema as any
-    // Reference: Referenced schemas can originate from either additional schemas
-    // or inline in the schema itself. Ideally the recursive path should align to
-    // reference path. Consider for refactor.
+    // Rule: Types with identifiers are hoisted into their own functions. The following will generate a function for the schema
+    // and yield the call to that function. This call is only made if NOT the root type which allows the generated function to
+    // yield its expression. The root argument is only true when making calls via CreateFunction(). Note there is potential to
+    // omit the root argument and conditional by refactoring the logic below. Consider for review.
     if (IsString(schema.$id)) {
       const name = CreateFunctionName(schema.$id)
-
       if (!state_local_function_names.has(schema.$id)) {
         state_local_function_names.add(schema.$id)
         const body = CreateFunction(name, schema, references, 'value')
         PushFunction(body)
       }
-
-      if (!root) {
-        yield `${name}(${value})`
-        return
-      }
+      if (!root) return yield `${name}(${value})`
     }
     switch (schema_[Types.Kind]) {
       case 'Any':
@@ -483,9 +479,12 @@ export namespace TypeCompiler {
   // -------------------------------------------------------------------
   function Build<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): string {
     ResetCompiler()
-    const check = CreateFunction('check', schema, references, 'value')
+    const check = CreateFunction('check', schema, references, 'value') // interior visit
     const locals = GetLocals()
-    return `${locals.join('\n')}\nreturn ${check}`
+    // prettier-ignore
+    return IsString(schema.$id) // ensure top level schemas with $id's are hoisted
+      ? `${locals.join('\n')}\nreturn function check(value) {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
+      : `${locals.join('\n')}\nreturn ${check}`
   }
   /** Returns the generated assertion code used to validate this type. */
   export function Code<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []) {

From d2c023ad4ed2ec578a92ab3f9d4661aaf7c61617 Mon Sep 17 00:00:00 2001
From: Alex Badmashkaev <eto.ya@list.ru>
Date: Tue, 13 Jun 2023 13:07:14 +0300
Subject: [PATCH 143/369] Documentation (#463)

---
 readme.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/readme.md b/readme.md
index 49f8b1c85..c362be839 100644
--- a/readme.md
+++ b/readme.md
@@ -483,7 +483,7 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │ ])                             │                             │   ],                           │
 │ const T = Type.Tuple([         │                             │   additionalItems: false,      │
 |   ...Type.Rest(A),             │                             │   minItems: 4,                 │
-|   ...Type.Test(B)              │                             │   maxItems: 4                  │
+|   ...Type.Rest(B)              │                             │   maxItems: 4                  │
 │ ])                             │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -896,7 +896,7 @@ const C = Type.Index(T, Type.KeyOf(T))               // const C = {
 
 ### Rest Types
 
-Rest parameters are supported with `Type.Rest`. This function is used to extract interior type elements from tuples which enables them to compose with the JavaScript spread operator `...`. This type can be used for tuple concatination as well as for variadic functions.
+Rest parameters are supported with `Type.Rest`. This function is used to extract interior type elements from tuples which enables them to compose with the JavaScript spread operator `...`. This type can be used for tuple concatenation as well as for variadic functions.
 
 ```typescript
 // TypeScript
@@ -1335,7 +1335,7 @@ console.log(C.Code())                                // return function check(va
 
 ## TypeSystem
 
-The TypeBox TypeSystem module provides functionality to define types above and beyond the Standard and Extended type sets as well as control various assertion polices. Configurations made to the TypeSystem module are observed by both `TypeCompiler` and `Value` modules.
+The TypeBox TypeSystem module provides functionality to define types above and beyond the Standard and Extended type sets as well as control various assertion policies. Configurations made to the TypeSystem module are observed by both `TypeCompiler` and `Value` modules.
 
 The TypeSystem module is provided as an optional import.
 

From fc188b2ef67634820610de833c54cdc45703f47e Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Thu, 15 Jun 2023 11:55:10 +0900
Subject: [PATCH 144/369] Documentation

---
 readme.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/readme.md b/readme.md
index c362be839..7d7b48faf 100644
--- a/readme.md
+++ b/readme.md
@@ -870,7 +870,7 @@ const T = Type.Object({                              // const T = {
   z: Type.Boolean()                                  //   properties: {
 })                                                   //     x: { type: 'number' },
                                                      //     y: { type: 'string' },
-                                                     //     z: { type: 'string' },
+                                                     //     z: { type: 'string' }
                                                      //   }
                                                      // }
 
@@ -908,14 +908,14 @@ type C = [...T, number]                              // type C = [number, number
 type F = (...param: C) => void                       // type F = (
                                                      //   param0: number,
                                                      //   param1: number,
-                                                     //   param2: number,
+                                                     //   param2: number
                                                      // ) => void
 
 // TypeBox
 
 const T = Type.Tuple([                               // const T: TTuple<[
   Type.Number(),                                     //   TNumber,
-  Type.Number()                                      //   TNumber,
+  Type.Number()                                      //   TNumber
 ])                                                   // ]>
 
 const C = Type.Tuple([                               // const C: TTuple<[

From 75fd14092153466a1f5a539eaa45ea317d1e8f76 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 20 Jun 2023 16:07:50 +0900
Subject: [PATCH 145/369] Array Assertion Order (#467)

---
 package-lock.json        |  4 ++--
 package.json             |  2 +-
 src/compiler/compiler.ts | 24 ++++++++++++++----------
 3 files changed, 17 insertions(+), 13 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 92701e4ed..43f63db8b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.15",
+  "version": "0.28.16",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.15",
+      "version": "0.28.16",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index eb06253a7..30dc668ed 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.15",
+  "version": "0.28.16",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 961f9fffb..f7a71b074 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -176,11 +176,12 @@ export namespace TypeCompiler {
     yield 'true'
   }
   function* Array(schema: Types.TArray, references: Types.TSchema[], value: string): IterableIterator<string> {
-    const expression = CreateExpression(schema.items, references, 'value')
+    yield `Array.isArray(${value})`
     if (IsNumber(schema.minItems)) yield `${value}.length >= ${schema.minItems}`
     if (IsNumber(schema.maxItems)) yield `${value}.length <= ${schema.maxItems}`
     if (schema.uniqueItems === true) yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`
-    yield `Array.isArray(${value}) && ${value}.every(value => ${expression})`
+    const expression = CreateExpression(schema.items, references, 'value')
+    yield `${value}.every(value => ${expression})`
   }
   function* BigInt(schema: Types.TBigInt, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'bigint')`
@@ -302,9 +303,9 @@ export namespace TypeCompiler {
     const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
     if (index === -1) throw new TypeCompilerDereferenceError(schema)
     const target = references[index]
-    // Reference: If we have seen this reference before we can just yield and return
-    // the function call. If this isn't the case we defer to visit to generate and
-    // set the function for subsequent passes. Consider for refactor.
+    // Reference: If we have seen this reference before we can just yield and
+    // return the function call. If this isn't the case we defer to visit to
+    // generate and set the function for subsequent passes.
     if (state_local_function_names.has(schema.$ref)) return yield `${CreateFunctionName(schema.$ref)}(${value})`
     yield* Visit(target, references, value)
   }
@@ -333,7 +334,7 @@ export namespace TypeCompiler {
     yield `${func}(${value})`
   }
   function* Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: string): IterableIterator<string> {
-    yield `(Array.isArray(${value}))`
+    yield `Array.isArray(${value})`
     if (schema.items === undefined) return yield `${value}.length === 0`
     yield `(${value}.length === ${schema.maxItems})`
     for (let i = 0; i < schema.items.length; i++) {
@@ -367,10 +368,13 @@ export namespace TypeCompiler {
   function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: string, root = false): IterableIterator<string> {
     const references_ = IsString(schema.$id) ? [...references, schema] : references
     const schema_ = schema as any
-    // Rule: Types with identifiers are hoisted into their own functions. The following will generate a function for the schema
-    // and yield the call to that function. This call is only made if NOT the root type which allows the generated function to
-    // yield its expression. The root argument is only true when making calls via CreateFunction(). Note there is potential to
-    // omit the root argument and conditional by refactoring the logic below. Consider for review.
+    // Rule: Types with identifiers are hoisted into their own functions.
+    // The following will generate a function for the schema and yield the
+    // call to that function. This call is only made if NOT the root type
+    // which allows the generated function to yield its expression. The
+    // root argument is only true when making calls via CreateFunction().
+    // Note there is potential to omit the root argument and conditional
+    // by refactoring the logic below. Consider for review.
     if (IsString(schema.$id)) {
       const name = CreateFunctionName(schema.$id)
       if (!state_local_function_names.has(schema.$id)) {

From 772e566449b1db5b4136453d1661b0299b834f66 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 22 Jun 2023 01:52:36 +0900
Subject: [PATCH 146/369] TypeCompiler Multiple Language Support (#469)

---
 package-lock.json        |  4 +-
 package.json             |  2 +-
 src/compiler/compiler.ts | 80 +++++++++++++++++++++++-----------------
 3 files changed, 50 insertions(+), 36 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 43f63db8b..84a84be8d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.16",
+  "version": "0.28.17",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.16",
+      "version": "0.28.17",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 30dc668ed..ba31a48e2 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.16",
+  "version": "0.28.17",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index f7a71b074..fa5383ffd 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -129,6 +129,10 @@ export class TypeCompilerTypeGuardError extends Error {
     super('TypeCompiler: Preflight validation check failed to guard for the given schema')
   }
 }
+
+export interface TypeCompilerOptions {
+  language: 'typescript' | 'javascript'
+}
 /** Compiles Types for Runtime Type Checking */
 export namespace TypeCompiler {
   // -------------------------------------------------------------------
@@ -181,7 +185,8 @@ export namespace TypeCompiler {
     if (IsNumber(schema.maxItems)) yield `${value}.length <= ${schema.maxItems}`
     if (schema.uniqueItems === true) yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`
     const expression = CreateExpression(schema.items, references, 'value')
-    yield `${value}.every(value => ${expression})`
+    const parameter = CreateParameter('value')
+    yield `${value}.every((${parameter}) => ${expression})`
   }
   function* BigInt(schema: Types.TBigInt, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'bigint')`
@@ -192,7 +197,7 @@ export namespace TypeCompiler {
     if (IsBigInt(schema.maximum)) yield `${value} <= BigInt(${schema.maximum})`
   }
   function* Boolean(schema: Types.TBoolean, references: Types.TSchema[], value: string): IterableIterator<string> {
-    yield `typeof ${value} === 'boolean'`
+    yield `(typeof ${value} === 'boolean')`
   }
   function* Constructor(schema: Types.TConstructor, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield* Visit(schema.returns, references, `${value}.prototype`)
@@ -205,7 +210,7 @@ export namespace TypeCompiler {
     if (IsNumber(schema.maximumTimestamp)) yield `${value}.getTime() <= ${schema.maximumTimestamp}`
   }
   function* Function(schema: Types.TFunction, references: Types.TSchema[], value: string): IterableIterator<string> {
-    yield `typeof ${value} === 'function'`
+    yield `(typeof ${value} === 'function')`
   }
   function* Integer(schema: Types.TInteger, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`
@@ -220,20 +225,20 @@ export namespace TypeCompiler {
     if (schema.unevaluatedProperties === false) {
       const keyCheck = PushLocal(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`)
       const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key))`
-      yield `${check1} && ${check2}`
+      yield `(${check1} && ${check2})`
     } else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
       const keyCheck = PushLocal(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`)
       const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key) || ${CreateExpression(schema.unevaluatedProperties, references, `${value}[key]`)})`
-      yield `${check1} && ${check2}`
+      yield `(${check1} && ${check2})`
     } else {
-      yield `${check1}`
+      yield `(${check1})`
     }
   }
   function* Literal(schema: Types.TLiteral, references: Types.TSchema[], value: string): IterableIterator<string> {
     if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
-      yield `${value} === ${schema.const}`
+      yield `(${value} === ${schema.const})`
     } else {
-      yield `${value} === '${schema.const}'`
+      yield `(${value} === '${schema.const}')`
     }
   }
   function* Never(schema: Types.TNever, references: Types.TSchema[], value: string): IterableIterator<string> {
@@ -245,7 +250,7 @@ export namespace TypeCompiler {
     yield `!${left} && ${right}`
   }
   function* Null(schema: Types.TNull, references: Types.TSchema[], value: string): IterableIterator<string> {
-    yield `${value} === null`
+    yield `(${value} === null)`
   }
   function* Number(schema: Types.TNumber, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield IsNumberCheck(value)
@@ -306,7 +311,7 @@ export namespace TypeCompiler {
     // Reference: If we have seen this reference before we can just yield and
     // return the function call. If this isn't the case we defer to visit to
     // generate and set the function for subsequent passes.
-    if (state_local_function_names.has(schema.$ref)) return yield `${CreateFunctionName(schema.$ref)}(${value})`
+    if (state.functions.has(schema.$ref)) return yield `${CreateFunctionName(schema.$ref)}(${value})`
     yield* Visit(target, references, value)
   }
   function* String(schema: Types.TString, references: Types.TSchema[], value: string): IterableIterator<string> {
@@ -361,8 +366,8 @@ export namespace TypeCompiler {
     yield IsVoidCheck(value)
   }
   function* UserDefined(schema: Types.TSchema, references: Types.TSchema[], value: string): IterableIterator<string> {
-    const schema_key = `schema_key_${state_remote_custom_types.size}`
-    state_remote_custom_types.set(schema_key, schema)
+    const schema_key = `schema_key_${state.customs.size}`
+    state.customs.set(schema_key, schema)
     yield `custom('${schema[Types.Kind]}', '${schema_key}', ${value})`
   }
   function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: string, root = false): IterableIterator<string> {
@@ -377,8 +382,8 @@ export namespace TypeCompiler {
     // by refactoring the logic below. Consider for review.
     if (IsString(schema.$id)) {
       const name = CreateFunctionName(schema.$id)
-      if (!state_local_function_names.has(schema.$id)) {
-        state_local_function_names.add(schema.$id)
+      if (!state.functions.has(schema.$id)) {
+        state.functions.add(schema.$id)
         const body = CreateFunction(name, schema, references, 'value')
         PushFunction(body)
       }
@@ -449,13 +454,12 @@ export namespace TypeCompiler {
   // -------------------------------------------------------------------
   // Compiler State
   // -------------------------------------------------------------------
-  const state_local_variables = new Set<string>() // local variables and functions
-  const state_local_function_names = new Set<string>() // local function names used call ref validators
-  const state_remote_custom_types = new Map<string, unknown>() // remote custom types used during compilation
-  function ResetCompiler() {
-    state_local_variables.clear()
-    state_local_function_names.clear()
-    state_remote_custom_types.clear()
+  // prettier-ignore
+  const state = {
+    language: 'javascript' as TypeCompilerOptions['language'], // target language
+    variables: new Set<string>(),                              // local variables
+    functions: new Set<string>(),                              // local functions
+    customs: new Map<string, unknown>(),                       // custom type data
   }
   function CreateExpression(schema: Types.TSchema, references: Types.TSchema[], value: string): string {
     return `(${[...Visit(schema, references, value)].join(' && ')})`
@@ -463,48 +467,58 @@ export namespace TypeCompiler {
   function CreateFunctionName($id: string) {
     return `check_${Identifier.Encode($id)}`
   }
+  function CreateParameter(name: string) {
+    const annotation = state.language === 'typescript' ? ': any' : ''
+    return `${name}${annotation}`
+  }
   function CreateFunction(name: string, schema: Types.TSchema, references: Types.TSchema[], value: string): string {
     const expression = [...Visit(schema, references, value, true)].map((condition) => `    ${condition}`).join(' &&\n')
-    return `function ${name}(value) {\n  return (\n${expression}\n )\n}`
+    const parameter = CreateParameter('value')
+    return `function ${name}(${parameter}) {\n  return (\n${expression}\n )\n}`
   }
   function PushFunction(functionBody: string) {
-    state_local_variables.add(functionBody)
+    state.variables.add(functionBody)
   }
   function PushLocal(expression: string) {
-    const local = `local_${state_local_variables.size}`
-    state_local_variables.add(`const ${local} = ${expression}`)
+    const local = `local_${state.variables.size}`
+    state.variables.add(`const ${local} = ${expression}`)
     return local
   }
   function GetLocals() {
-    return [...state_local_variables.values()]
+    return [...state.variables.values()]
   }
   // -------------------------------------------------------------------
   // Compile
   // -------------------------------------------------------------------
   function Build<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): string {
-    ResetCompiler()
     const check = CreateFunction('check', schema, references, 'value') // interior visit
     const locals = GetLocals()
+    const parameter = CreateParameter('value')
     // prettier-ignore
     return IsString(schema.$id) // ensure top level schemas with $id's are hoisted
-      ? `${locals.join('\n')}\nreturn function check(value) {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
+      ? `${locals.join('\n')}\nreturn function check(${parameter}) {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
       : `${locals.join('\n')}\nreturn ${check}`
   }
   /** Returns the generated assertion code used to validate this type. */
-  export function Code<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []) {
+  export function Code<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = [], options: TypeCompilerOptions = { language: 'javascript' }) {
+    // compiler-reset
+    state.language = options.language
+    state.variables.clear()
+    state.functions.clear()
+    state.customs.clear()
     if (!Types.TypeGuard.TSchema(schema)) throw new TypeCompilerTypeGuardError(schema)
     for (const schema of references) if (!Types.TypeGuard.TSchema(schema)) throw new TypeCompilerTypeGuardError(schema)
     return Build(schema, references)
   }
   /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
   export function Compile<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []): TypeCheck<T> {
-    const code = Code(schema, references)
-    const custom_schemas = new Map(state_remote_custom_types)
+    const code = Code(schema, references, { language: 'javascript' })
+    const customs = new Map(state.customs)
     const compiledFunction = globalThis.Function('custom', 'format', 'hash', code)
     const checkFunction = compiledFunction(
       (kind: string, schema_key: string, value: unknown) => {
-        if (!Types.TypeRegistry.Has(kind) || !custom_schemas.has(schema_key)) return false
-        const schema = custom_schemas.get(schema_key)!
+        if (!Types.TypeRegistry.Has(kind) || !customs.has(schema_key)) return false
+        const schema = customs.get(schema_key)!
         const func = Types.TypeRegistry.Get(kind)!
         return func(schema, value)
       },

From 28d0f332f26b1c7c5ba13de0501d6078d009d9c5 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 22 Jun 2023 13:08:39 +0900
Subject: [PATCH 147/369] TypeCompiler Return Type Annotation (#470)

---
 package-lock.json        |  4 ++--
 package.json             |  2 +-
 src/compiler/compiler.ts | 27 ++++++++++++++++-----------
 3 files changed, 19 insertions(+), 14 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 84a84be8d..675abfe05 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.17",
+  "version": "0.28.18",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.17",
+      "version": "0.28.18",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index ba31a48e2..a2e701284 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.17",
+  "version": "0.28.18",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index fa5383ffd..4ba3c8e3e 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -131,7 +131,7 @@ export class TypeCompilerTypeGuardError extends Error {
 }
 
 export interface TypeCompilerOptions {
-  language: 'typescript' | 'javascript'
+  language?: 'typescript' | 'javascript'
 }
 /** Compiles Types for Runtime Type Checking */
 export namespace TypeCompiler {
@@ -185,7 +185,7 @@ export namespace TypeCompiler {
     if (IsNumber(schema.maxItems)) yield `${value}.length <= ${schema.maxItems}`
     if (schema.uniqueItems === true) yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`
     const expression = CreateExpression(schema.items, references, 'value')
-    const parameter = CreateParameter('value')
+    const parameter = CreateParameter('value', 'any')
     yield `${value}.every((${parameter}) => ${expression})`
   }
   function* BigInt(schema: Types.TBigInt, references: Types.TSchema[], value: string): IterableIterator<string> {
@@ -461,20 +461,24 @@ export namespace TypeCompiler {
     functions: new Set<string>(),                              // local functions
     customs: new Map<string, unknown>(),                       // custom type data
   }
-  function CreateExpression(schema: Types.TSchema, references: Types.TSchema[], value: string): string {
-    return `(${[...Visit(schema, references, value)].join(' && ')})`
-  }
   function CreateFunctionName($id: string) {
     return `check_${Identifier.Encode($id)}`
   }
-  function CreateParameter(name: string) {
-    const annotation = state.language === 'typescript' ? ': any' : ''
+  function CreateExpression(schema: Types.TSchema, references: Types.TSchema[], value: string): string {
+    return `(${[...Visit(schema, references, value)].join(' && ')})`
+  }
+  function CreateParameter(name: string, type: string) {
+    const annotation = state.language === 'typescript' ? `: ${type}` : ''
     return `${name}${annotation}`
   }
+  function CreateReturns(type: string) {
+    return state.language === 'typescript' ? `: ${type}` : ''
+  }
   function CreateFunction(name: string, schema: Types.TSchema, references: Types.TSchema[], value: string): string {
     const expression = [...Visit(schema, references, value, true)].map((condition) => `    ${condition}`).join(' &&\n')
-    const parameter = CreateParameter('value')
-    return `function ${name}(${parameter}) {\n  return (\n${expression}\n )\n}`
+    const parameter = CreateParameter('value', 'any')
+    const returns = CreateReturns('boolean')
+    return `function ${name}(${parameter})${returns} {\n  return (\n${expression}\n )\n}`
   }
   function PushFunction(functionBody: string) {
     state.variables.add(functionBody)
@@ -493,10 +497,11 @@ export namespace TypeCompiler {
   function Build<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): string {
     const check = CreateFunction('check', schema, references, 'value') // interior visit
     const locals = GetLocals()
-    const parameter = CreateParameter('value')
+    const parameter = CreateParameter('value', 'any')
+    const returns = CreateReturns('boolean')
     // prettier-ignore
     return IsString(schema.$id) // ensure top level schemas with $id's are hoisted
-      ? `${locals.join('\n')}\nreturn function check(${parameter}) {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
+      ? `${locals.join('\n')}\nreturn function check(${parameter})${returns} {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
       : `${locals.join('\n')}\nreturn ${check}`
   }
   /** Returns the generated assertion code used to validate this type. */

From 06f3c399a249edf7517a27f5e4bf07a0614e5cc6 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 27 Jun 2023 04:24:56 +0900
Subject: [PATCH 148/369] Check for Non-Terminating Recursive Types  (#476)

---
 package-lock.json                      |  4 +--
 package.json                           |  2 +-
 src/value/create.ts                    | 34 ++++++++++++++++++--------
 src/value/value.ts                     |  2 +-
 test/runtime/value/create/recursive.ts | 25 ++++++++++++++++++-
 test/runtime/value/create/ref.ts       |  5 ++++
 6 files changed, 57 insertions(+), 15 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 675abfe05..84a231b3e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.18",
+  "version": "0.28.19",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.18",
+      "version": "0.28.19",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index a2e701284..7404794dd 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.18",
+  "version": "0.28.19",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/create.ts b/src/value/create.ts
index dace6a6a2..ae2e9b18d 100644
--- a/src/value/create.ts
+++ b/src/value/create.ts
@@ -57,6 +57,11 @@ export class ValueCreateDereferenceError extends Error {
     super(`ValueCreate: Unable to dereference schema with $id '${schema.$ref}'`)
   }
 }
+export class ValueCreateRecursiveInstantiationError extends Error {
+  constructor(public readonly schema: Types.TSchema, public readonly recursiveMaxDepth: number) {
+    super('ValueCreate: Value cannot be created as recursive type may produce value of infinite size. Consider using a default.')
+  }
+}
 // --------------------------------------------------------------------------
 // ValueCreate
 // --------------------------------------------------------------------------
@@ -84,7 +89,7 @@ export namespace ValueCreate {
       return schema.default
     } else if (schema.minItems !== undefined) {
       return globalThis.Array.from({ length: schema.minItems }).map((item) => {
-        return ValueCreate.Create(schema.items, references)
+        return Visit(schema.items, references)
       })
     } else {
       return []
@@ -108,7 +113,7 @@ export namespace ValueCreate {
     if ('default' in schema) {
       return schema.default
     } else {
-      const value = ValueCreate.Create(schema.returns, references) as any
+      const value = Visit(schema.returns, references) as any
       if (typeof value === 'object' && !globalThis.Array.isArray(value)) {
         return class {
           constructor() {
@@ -136,7 +141,7 @@ export namespace ValueCreate {
     if ('default' in schema) {
       return schema.default
     } else {
-      return () => ValueCreate.Create(schema.returns, references)
+      return () => Visit(schema.returns, references)
     }
   }
   function Integer(schema: Types.TInteger, references: Types.TSchema[]): any {
@@ -204,7 +209,7 @@ export namespace ValueCreate {
       return (
         schema.default ||
         globalThis.Object.entries(schema.properties).reduce((acc, [key, schema]) => {
-          return required.has(key) ? { ...acc, [key]: ValueCreate.Create(schema, references) } : { ...acc }
+          return required.has(key) ? { ...acc, [key]: Visit(schema, references) } : { ...acc }
         }, {})
       )
     }
@@ -213,7 +218,7 @@ export namespace ValueCreate {
     if ('default' in schema) {
       return schema.default
     } else {
-      return globalThis.Promise.resolve(ValueCreate.Create(schema.item, references))
+      return globalThis.Promise.resolve(Visit(schema.item, references))
     }
   }
   function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[]): any {
@@ -223,7 +228,7 @@ export namespace ValueCreate {
     } else if (!(keyPattern === Types.PatternStringExact || keyPattern === Types.PatternNumberExact)) {
       const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|')
       return propertyKeys.reduce((acc, key) => {
-        return { ...acc, [key]: Create(valueSchema, references) }
+        return { ...acc, [key]: Visit(valueSchema, references) }
       }, {})
     } else {
       return {}
@@ -233,7 +238,7 @@ export namespace ValueCreate {
     if ('default' in schema) {
       return schema.default
     } else {
-      const index = references.findIndex((foreign) => foreign.$id === schema.$id)
+      const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
       if (index === -1) throw new ValueCreateDereferenceError(schema)
       const target = references[index]
       return Visit(target, references)
@@ -283,10 +288,11 @@ export namespace ValueCreate {
     return sequence.next().value
   }
   function This(schema: Types.TThis, references: Types.TSchema[]): any {
+    if (recursiveDepth++ > recursiveMaxDepth) throw new ValueCreateRecursiveInstantiationError(schema, recursiveMaxDepth)
     if ('default' in schema) {
       return schema.default
     } else {
-      const index = references.findIndex((foreign) => foreign.$id === schema.$id)
+      const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
       if (index === -1) throw new ValueCreateDereferenceError(schema)
       const target = references[index]
       return Visit(target, references)
@@ -299,7 +305,7 @@ export namespace ValueCreate {
     if (schema.items === undefined) {
       return []
     } else {
-      return globalThis.Array.from({ length: schema.minItems }).map((_, index) => ValueCreate.Create((schema.items as any[])[index], references))
+      return globalThis.Array.from({ length: schema.minItems }).map((_, index) => Visit((schema.items as any[])[index], references))
     }
   }
   function Undefined(schema: Types.TUndefined, references: Types.TSchema[]): any {
@@ -315,7 +321,7 @@ export namespace ValueCreate {
     } else if (schema.anyOf.length === 0) {
       throw new Error('ValueCreate.Union: Cannot create Union with zero variants')
     } else {
-      return ValueCreate.Create(schema.anyOf[0], references)
+      return Visit(schema.anyOf[0], references)
     }
   }
   function Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[]): any {
@@ -414,7 +420,15 @@ export namespace ValueCreate {
         return UserDefined(schema_, references_)
     }
   }
+  // --------------------------------------------------------
+  // State
+  // --------------------------------------------------------
+  const recursiveMaxDepth = 512
+  let recursiveDepth = 0
+
+  /** Creates a value from the given schema and references */
   export function Create<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T> {
+    recursiveDepth = 0
     return Visit(schema, references)
   }
 }
diff --git a/src/value/value.ts b/src/value/value.ts
index ed9335d28..96bf2982f 100644
--- a/src/value/value.ts
+++ b/src/value/value.ts
@@ -27,7 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import * as Types from '../typebox'
-import { ValueErrors, ValueErrorIterator, ValueError } from '../errors/index'
+import { ValueErrors, ValueErrorIterator } from '../errors/index'
 import { ValueMutate, Mutable } from './mutate'
 import { ValueHash } from './hash'
 import { ValueEqual } from './equal'
diff --git a/test/runtime/value/create/recursive.ts b/test/runtime/value/create/recursive.ts
index b12dd0b0c..3f78233f2 100644
--- a/test/runtime/value/create/recursive.ts
+++ b/test/runtime/value/create/recursive.ts
@@ -15,7 +15,6 @@ describe('value/create/Recursive', () => {
       nodes: [],
     })
   })
-
   it('Should create default', () => {
     const T = Type.Recursive(
       (This) =>
@@ -27,4 +26,28 @@ describe('value/create/Recursive', () => {
     )
     Assert.isEqual(Value.Create(T), 7)
   })
+  it('Should throw on infinite type', () => {
+    const T = Type.Recursive((This) =>
+      Type.Object({
+        x: This,
+      }),
+    )
+    Assert.throws(() => Value.Create(T))
+  })
+  it('Should not throw on recursive type when terminating sub type proceeds self', () => {
+    const T = Type.Recursive((This) =>
+      Type.Object({
+        x: Type.Union([Type.Null(), This]),
+      }),
+    )
+    Assert.isEqual(Value.Create(T), { x: null })
+  })
+  it('Should not throw on recursive type when self is optional', () => {
+    const T = Type.Recursive((This) =>
+      Type.Object({
+        x: Type.Optional(This),
+      }),
+    )
+    Assert.isEqual(Value.Create(T), {})
+  })
 })
diff --git a/test/runtime/value/create/ref.ts b/test/runtime/value/create/ref.ts
index 16c7e4abd..b296f0bb2 100644
--- a/test/runtime/value/create/ref.ts
+++ b/test/runtime/value/create/ref.ts
@@ -27,4 +27,9 @@ describe('value/create/Ref', () => {
     const R = Type.Ref(T, { default: 'override' })
     Assert.isEqual(Value.Create(R), 'override') // terminated at R default value
   })
+  it('Should dereference remote schema via $ref', () => {
+    const R = Type.Number({ $id: 'S' })
+    const T = Type.Object({ x: Type.Ref(R) })
+    Assert.isEqual(Value.Create(T, [R]), { x: 0 })
+  })
 })

From 3b6c9849bf962abfa6898bc06bff44fbcd1d3262 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 27 Jun 2023 17:14:42 +0900
Subject: [PATCH 149/369] Resolve Numeric Constraint Reporting Error  (#479)

---
 package-lock.json    | 4 ++--
 package.json         | 2 +-
 src/errors/errors.ts | 6 +++---
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 84a231b3e..683b43e5d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.19",
+  "version": "0.28.20",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.19",
+      "version": "0.28.20",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 7404794dd..d6fb9bfdd 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.19",
+  "version": "0.28.20",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 6b637d347..6c7203e1d 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -66,7 +66,7 @@ export enum ValueErrorType {
   NumberMultipleOf,
   NumberExclusiveMinimum,
   NumberExclusiveMaximum,
-  NumberMinumum,
+  NumberMinimum,
   NumberMaximum,
   Object,
   ObjectMinProperties,
@@ -329,10 +329,10 @@ export namespace ValueErrors {
       yield { type: ValueErrorType.NumberExclusiveMaximum, schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` }
     }
     if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
-      yield { type: ValueErrorType.NumberMaximum, schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` }
+      yield { type: ValueErrorType.NumberMinimum, schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` }
     }
     if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
-      yield { type: ValueErrorType.NumberMinumum, schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` }
+      yield { type: ValueErrorType.NumberMaximum, schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` }
     }
   }
   function* Object(schema: Types.TObject, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {

From ebef7cc1cad04ab1be459e1a673fcb31fd571ff1 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 2 Jul 2023 22:37:54 +0900
Subject: [PATCH 150/369] Revision 0.29.0 (#483)

---
 changelog/0.29.0.md                | 108 ++++++++++++++++++++++++
 package-lock.json                  |  18 ++--
 package.json                       |   4 +-
 readme.md                          |  77 ++++++++++++-----
 src/compiler/compiler.ts           |   5 +-
 src/errors/errors.ts               |   3 +-
 src/typebox.ts                     |  62 ++++++++------
 src/value/cast.ts                  |   2 +-
 src/value/check.ts                 |   2 +-
 src/value/create.ts                |   7 +-
 test/runtime/compiler/not.ts       |  47 ++++++-----
 test/runtime/compiler/object.ts    |   4 +-
 test/runtime/schema/not.ts         |  47 ++++++-----
 test/runtime/type/extends/index.ts |   1 +
 test/runtime/type/extends/not.ts   | 130 +++++++++++++++++++++++++++++
 test/runtime/type/guard/not.ts     |  10 +--
 test/runtime/value/cast/not.ts     |  25 ++----
 test/runtime/value/check/not.ts    |   6 --
 test/runtime/value/create/not.ts   |  11 ++-
 test/static/not.ts                 |   8 +-
 typebox.png                        | Bin 946728 -> 872194 bytes
 workbench.png                      | Bin 43713 -> 0 bytes
 22 files changed, 431 insertions(+), 146 deletions(-)
 create mode 100644 changelog/0.29.0.md
 create mode 100644 test/runtime/type/extends/not.ts
 delete mode 100644 workbench.png

diff --git a/changelog/0.29.0.md b/changelog/0.29.0.md
new file mode 100644
index 000000000..e4cca9f49
--- /dev/null
+++ b/changelog/0.29.0.md
@@ -0,0 +1,108 @@
+## [0.29.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.29.0)
+
+## Overview
+
+Revision 0.29.0 makes a minor interface and schema representation change to the `Type.Not` type. This revision also includes a fix for indexed access types on TypeScript 5.1.6. 
+
+As this revision constitutes a breaking representation change for `Type.Not`, a minor semver revision is required.
+
+## Type.Not Representation Change
+
+The `Type.Not` was first introduced in Revision 0.26.0. This type accepted two arguments, the first is the `not` type, the second is the `allowed` type. In 0.26.0, TypeBox would treat the `allowed` type as the inferred type with the schema represented in the following form.
+
+### 0.26.0
+
+```typescript
+// allow all numbers except the number 42
+//
+const T = Type.Not(Type.Literal(42), Type.Number())
+//                 ^                 ^
+//                 not type          allowed type
+
+// represented as
+//
+const T = {
+  allOf: [
+    { not: { const: 42 } },
+    { type: 'number' }
+  ]
+}
+
+// inferred as
+//
+type T = Static<typeof T>              // type T = number
+```
+In 0.26.0. the rationale for the second `allowed` argument was provide a correct static type to infer, where one could describe what the type wasn't on the first and what it was on the second (with inference of operating on the second argument). This approach was to echo possible suggestions for negated type syntax in TypeScript.
+
+```typescript
+type T = number & not 42 // not actual typescript syntax!
+```
+
+### 0.29.0
+
+Revision 0.29.0 changes the `Type.Not` type to take a single `not` argument only. This type statically infers as `unknown`
+
+```typescript
+// allow all types except the literal number 42
+//
+const T = Type.Not(Type.Literal(42)) 
+//                 ^
+//                 not type 
+
+// represented as
+//
+const T = { not: { const: 42 } }
+
+// inferred as
+//
+type T = Static<typeof T>              // type T = unknown
+
+```
+### Upgrading to 0.29.0
+
+In revision 0.29.0, you can express the 0.26.0 Not type via `Type.Intersect` which explicitly creates the `allOf` representation. The type inference works in this case as intersected `number & unknown` yields the most narrowed type (which is `number`)
+
+```typescript
+// allow all numbers except the number 42
+//
+const T = Type.Intersect([ Type.Not(Type.Literal(42)), Type.Number() ])
+//                         ^                           ^
+//                         not type                    allowed type
+
+// represented as
+//
+const T = {
+  allOf: [
+    { not: { const: 42 } },
+    { type: 'number' }
+  ]
+}
+// inferred as
+//
+type T = Static<typeof T>              // type T = number
+```
+The 0.29.0 `Not` type properly represents the JSON Schema `not` keyword in its simplest form, as well as making better use of the type intersection narrowing capabilities of TypeScript with respect to inference.
+
+### Invert Not 
+
+In revision 0.29.0, it is possible to invert the `Not` type. TypeBox will track each inversion and statically infer appropriately.
+
+```typescript
+// not not string
+//
+const T = Type.Not(Type.Not(Type.String()))
+
+// represented as
+//
+const T = {
+  not: {
+    not: {
+      type: "string"
+    }
+  }
+}
+
+// inferred as
+//
+type T = Static<typeof T>              // type T = string
+```
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index 683b43e5d..98d18eb2c 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.20",
+  "version": "0.29.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.28.20",
+      "version": "0.29.0",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
@@ -18,7 +18,7 @@
         "chai": "^4.3.6",
         "mocha": "^9.2.2",
         "prettier": "^2.7.1",
-        "typescript": "^5.1.3"
+        "typescript": "^5.1.6"
       }
     },
     "node_modules/@esbuild/linux-loong64": {
@@ -1410,9 +1410,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.1.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.1.3.tgz",
-      "integrity": "sha512-XH627E9vkeqhlZFQuL+UsyAXEnibT0kWR2FWONlr4sTjvxyJYnyefgrkyECLzM5NenmKzRAy2rR/OlYLA1HkZw==",
+      "version": "5.1.6",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.1.6.tgz",
+      "integrity": "sha512-zaWCozRZ6DLEWAWFrVDz1H6FVXzUSfTy5FUMWsQlU8Ym5JP9eO4xkTIROFCQvhQf61z6O/G6ugw3SgAnvvm+HA==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -2442,9 +2442,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.1.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.1.3.tgz",
-      "integrity": "sha512-XH627E9vkeqhlZFQuL+UsyAXEnibT0kWR2FWONlr4sTjvxyJYnyefgrkyECLzM5NenmKzRAy2rR/OlYLA1HkZw==",
+      "version": "5.1.6",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.1.6.tgz",
+      "integrity": "sha512-zaWCozRZ6DLEWAWFrVDz1H6FVXzUSfTy5FUMWsQlU8Ym5JP9eO4xkTIROFCQvhQf61z6O/G6ugw3SgAnvvm+HA==",
       "dev": true
     },
     "uri-js": {
diff --git a/package.json b/package.json
index d6fb9bfdd..6cc25a10f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.20",
+  "version": "0.29.0",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -42,6 +42,6 @@
     "chai": "^4.3.6",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^5.1.3"
+    "typescript": "^5.1.6"
   }
 }
diff --git a/readme.md b/readme.md
index 7d7b48faf..1ff66fddc 100644
--- a/readme.md
+++ b/readme.md
@@ -84,6 +84,7 @@ License MIT
   - [Conditional](#types-conditional)
   - [Template Literal](#types-template-literal)
   - [Indexed](#types-indexed)
+  - [Not](#types-not)
   - [Rest](#types-rest)
   - [Guards](#types-guards)
   - [Unsafe](#types-unsafe)
@@ -353,20 +354,11 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Not(            | type T = string             │ const T = {                    │
-|   Type.Union([                 │                             │   allOf: [{                    │
-│     Type.Literal('x'),         │                             │     not: {                     │
-│     Type.Literal('y'),         │                             │       anyOf: [                 │
-│     Type.Literal('z')          │                             │         { const: 'x' },        │
-│   ]),                          │                             │         { const: 'y' },        │
-│   Type.String()                │                             │         { const: 'z' }         │
-│ )                              │                             │       ]                        │
-│                                │                             │     }                          │
-│                                │                             │   }, {                         │
-│                                │                             │     type: 'string'             │
-│                                │                             │   }]                           │
+│ const T = Type.Not(            | type T = unknown            │ const T = {                    │
+│   Type.String()                │                             │   not: {                       │
+│ )                              │                             │     type: 'string'             │
+│                                │                             │   }                            │
 │                                │                             │ }                              │
-│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Extends(        │ type T =                    │ const T = {                    │
 │   Type.String(),               │  string extends number      │   const: false,                │
@@ -650,7 +642,7 @@ const T = Type.String({                              // const T = {
 })                                                   //   format: 'email'
                                                      // }
 
-// Mumber must be a multiple of 2
+// Number must be a multiple of 2
 const T = Type.Number({                              // const T = {
   multipleOf: 2                                      //  type: 'number',
 })                                                   //  multipleOf: 2
@@ -892,6 +884,49 @@ const C = Type.Index(T, Type.KeyOf(T))               // const C = {
                                                      // }
 ```
 
+<a name='types-not'></a>
+
+### Not Types
+
+Not types are supported with `Type.Not`. This type represents the JSON Schema `not` keyword and will statically infer as `unknown`. Note that negated (or not) types are not supported in TypeScript, but can still be partially expressed by interpreting `not` as the broad type `unknown`. When used with intersect types, the Not type can create refined assertion rules for types by leveraging TypeScript's ability to narrow from `unknown` to an intended type through intersection.
+
+For example, consider a type which is `number` but not `1 | 2 | 3` and where the static type would still technically be a `number`. The following shows a pseudo TypeScript example using `not` followed by the TypeBox implementation.
+
+```typescript
+// Pseudo TypeScript
+
+type T = number & not (1 | 2 | 3)                    // allow all numbers except 1, 2, 3
+
+// TypeBox
+
+const T = Type.Intersect([                           // const T = {
+  Type.Number(),                                     //   allOf: [
+  Type.Not(Type.Union([                              //     { type: "number" },
+    Type.Literal(1),                                 //     {
+    Type.Literal(2),                                 //       not: {
+    Type.Literal(3)                                  //         anyOf: [
+  ]))                                                //           { const: 1, type: "number" },
+])                                                   //           { const: 2, type: "number" },
+                                                     //           { const: 3, type: "number" }
+                                                     //         ]
+                                                     //       }
+                                                     //     }
+                                                     //   ]
+                                                     // }
+
+type T = Static<typeof T>                            // evaluates as:
+                                                     //
+                                                     // type T = (number & (not (1 | 2 | 3)))
+                                                     // type T = (number & (unknown))
+                                                     // type T = (number) 
+```
+
+The Not type can be used with constraints to define schematics for types that would otherwise be difficult to express.
+```typescript
+const Even = Type.Number({ multipleOf: 2 })
+
+const Odd = Type.Intersect([Type.Number(), Type.Not(Even)])          
+```
 <a name='types-rest'></a>
 
 ### Rest Types
@@ -1420,29 +1455,25 @@ TypeSystem.AllowNaN = true
 
 ## Workbench
 
-TypeBox offers a small web based code generation tool that can be used to convert TypeScript types into TypeBox type definitions as well as a variety of other formats.
+TypeBox offers a web based code generation tool that can be used to convert TypeScript types into TypeBox types as well as a variety of other runtime type representations.
 
 [Workbench Link Here](https://sinclairzx81.github.io/typebox-workbench/)
 
-<div align='center'>
-
-<a href="https://sinclairzx81.github.io/typebox-workbench/"><img src="https://github.com/sinclairzx81/typebox/blob/master/workbench.png?raw=true" /></a>
-
-</div>
-
 <a name='ecosystem'></a>
 
 ## Ecosystem
 
-The following is a list of community packages that provide general tooling and framework support for TypeBox.
+The following is a list of community packages that provide general tooling and framework integration support for TypeBox.
 
 | Package   |  Description |
 | ------------- | ------------- |
 | [elysia](https://github.com/elysiajs/elysia) | Fast and friendly Bun web framework |
 | [fastify-type-provider-typebox](https://github.com/fastify/fastify-type-provider-typebox) | Fastify TypeBox integration with the Fastify Type Provider |
+| [feathersjs](https://github.com/feathersjs/feathers) | The API and real-time application framework |
 | [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
 | [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from JSON schemas |
-| [ts2typebox](https://github.com/xddq/ts2typebox)  | Creating TypeBox code from Typescript types |
+| [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
+| [typebox-validators](https://github.com/jtlapp/typebox-validators) | Advanced validators supporting discriminated and heterogeneous unions |
 
 <a name='benchmark'></a>
 
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 4ba3c8e3e..49e8ddb95 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -245,9 +245,8 @@ export namespace TypeCompiler {
     yield `false`
   }
   function* Not(schema: Types.TNot, references: Types.TSchema[], value: string): IterableIterator<string> {
-    const left = CreateExpression(schema.allOf[0].not, references, value)
-    const right = CreateExpression(schema.allOf[1], references, value)
-    yield `!${left} && ${right}`
+    const expression = CreateExpression(schema.not, references, value)
+    yield `(!${expression})`
   }
   function* Null(schema: Types.TNull, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(${value} === null)`
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 6c7203e1d..aa5fe28be 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -305,10 +305,9 @@ export namespace ValueErrors {
     yield { type: ValueErrorType.Never, schema, path, value, message: `Value cannot be validated` }
   }
   function* Not(schema: Types.TNot, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (Visit(schema.allOf[0].not, references, path, value).next().done === true) {
+    if (Visit(schema.not, references, path, value).next().done === true) {
       yield { type: ValueErrorType.Not, schema, path, value, message: `Value should not validate` }
     }
-    yield* Visit(schema.allOf[1], references, path, value)
   }
   function* Null(schema: Types.TNull, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
     if (!(value === null)) {
diff --git a/src/typebox.ts b/src/typebox.ts
index de871f3b1..f5c04c6aa 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -313,21 +313,13 @@ export type TIndexRestMany<T extends TSchema, K extends Key[]> =
  K extends [infer L, ...infer R] ? [TIndexType<T, Assert<L, Key>>, ...TIndexRestMany<T, Assert<R, Key[]>>] :
  []
 // prettier-ignore
-export type TIndexReduce<T extends TSchema, K extends Key[]> =
-  T extends TRecursive<infer S> ? TIndexReduce<S, K> :
+export type TIndex<T extends TSchema, K extends Key[]> =
+  T extends TRecursive<infer S> ? TIndex<S, K> :
   T extends TIntersect ? UnionType<Flat<TIndexRestMany<T, K>>> :
   T extends TUnion     ? UnionType<Flat<TIndexRestMany<T, K>>> :
   T extends TObject    ? UnionType<Flat<TIndexRestMany<T, K>>> :
   T extends TTuple     ? UnionType<Flat<TIndexRestMany<T, K>>> :
   TNever
-// prettier-ignore
-export type TIndex<T extends TSchema, K extends TSchema> =
-  [T, K] extends [TTuple, TNumber]  ? UnionType<Assert<T['items'], TSchema[]>> :  
-  [T, K] extends [TArray, TNumber]  ? AssertType<T['items']> :
-  K extends TTemplateLiteral        ? TIndexReduce<T, TTemplateLiteralKeyRest<K>> :
-  K extends TUnion<TLiteral<Key>[]> ? TIndexReduce<T, TUnionLiteralKeyRest<K>> :
-  K extends TLiteral<Key>           ? TIndexReduce<T, [K['const']]> :
-  TNever
 // --------------------------------------------------------------------------
 // TInteger
 // --------------------------------------------------------------------------
@@ -393,10 +385,10 @@ export interface TNever extends TSchema {
 // --------------------------------------------------------------------------
 // TNot
 // --------------------------------------------------------------------------
-export interface TNot<Not extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
+export interface TNot<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Not'
-  static: Static<T>
-  allOf: [{ not: Not }, T]
+  static: T extends TNot<infer U> ? Static<U> : unknown
+  not: T
 }
 // --------------------------------------------------------------------------
 // TNull
@@ -1063,11 +1055,7 @@ export namespace TypeGuard {
     return (
       TKind(schema) && 
       schema[Kind] === 'Not' && 
-      IsArray(schema.allOf) && 
-      schema.allOf.length === 2 && 
-      IsObject(schema.allOf[0]) && 
-      TSchema(schema.allOf[0].not) && 
-      TSchema(schema.allOf[1]) 
+      TSchema(schema.not) 
     )
   }
   /** Returns true if the given schema is TNull */
@@ -1354,8 +1342,7 @@ export namespace ExtendsUndefined {
   export function Check(schema: TSchema): boolean {
     if (schema[Kind] === 'Undefined') return true
     if (schema[Kind] === 'Not') {
-      const not = schema as TNot
-      return Check(not.allOf[1])
+      return !Check(schema.not)
     }
     if (schema[Kind] === 'Intersect') {
       const intersect = schema as TIntersect
@@ -1551,6 +1538,18 @@ export namespace TypeExtends {
     return TypeExtendsResult.True
   }
   // --------------------------------------------------------------------------
+  // Not
+  // --------------------------------------------------------------------------
+  function ResolveNot<T extends TNot>(schema: T): TUnknown | TNot['not'] {
+    let [current, depth]: [TSchema, number] = [schema, 0]
+    while (true) {
+      if (!TypeGuard.TNot(current)) break
+      current = current.not
+      depth += 1
+    }
+    return depth % 2 === 0 ? current : Type.Unknown()
+  }
+  // --------------------------------------------------------------------------
   // Null
   // --------------------------------------------------------------------------
   function Null(left: TNull, right: TSchema) {
@@ -1858,6 +1857,9 @@ export namespace TypeExtends {
     return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   function Visit(left: TSchema, right: TSchema): TypeExtendsResult {
+    // Not Unwrap
+    if (TypeGuard.TNot(left)) return Visit(ResolveNot(left), right)
+    if (TypeGuard.TNot(right)) return Visit(left, ResolveNot(right))
     // Template Literal Union Unwrap
     if (TypeGuard.TTemplateLiteral(left)) return Visit(TemplateLiteralResolver.Resolve(left), right)
     if (TypeGuard.TTemplateLiteral(right)) return Visit(left, TemplateLiteralResolver.Resolve(right))
@@ -2441,9 +2443,19 @@ export class StandardTypeBuilder extends TypeBuilder {
     }
   }
   /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndexReduce<T, Assert<K, Key[]>>
+  public Index<T extends TTuple, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): UnionType<Assert<T['items'], TSchema[]>>
+  /** `[Standard]` Returns indexed property types for the given keys */
+  public Index<T extends TArray, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): AssertType<T['items']>
+  /** `[Standard]` Returns indexed property types for the given keys */
+  public Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyRest<K>>
+  /** `[Standard]` Returns indexed property types for the given keys */
+  public Index<T extends TSchema, K extends TLiteral<Key>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, [K['const']]>
+  /** `[Standard]` Returns indexed property types for the given keys */
+  public Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, Key[]>>
+  /** `[Standard]` Returns indexed property types for the given keys */
+  public Index<T extends TSchema, K extends TUnion<TLiteral<Key>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TUnionLiteralKeyRest<K>>
   /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TSchema, K extends TSchema>(schema: T, key: K, options?: SchemaOptions): TIndex<T, K>
+  public Index<T extends TSchema, K extends TSchema>(schema: T, key: K, options?: SchemaOptions): TSchema
   /** `[Standard]` Returns indexed property types for the given keys */
   public Index(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
     if (TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved)) {
@@ -2508,9 +2520,9 @@ export class StandardTypeBuilder extends TypeBuilder {
   public Never(options: SchemaOptions = {}): TNever {
     return this.Create({ ...options, [Kind]: 'Never', not: {} })
   }
-  /** `[Standard]` Creates a Not type. The first argument is the disallowed type, the second is the allowed. */
-  public Not<N extends TSchema, T extends TSchema>(not: N, schema: T, options?: SchemaOptions): TNot<N, T> {
-    return this.Create({ ...options, [Kind]: 'Not', allOf: [{ not: TypeClone.Clone(not, {}) }, TypeClone.Clone(schema, {})] })
+  /** `[Standard]` Creates a Not type */
+  public Not<T extends TSchema>(not: T, options?: SchemaOptions): TNot<T> {
+    return this.Create({ ...options, [Kind]: 'Not', not })
   }
   /** `[Standard]` Creates a Null type */
   public Null(options: SchemaOptions = {}): TNull {
diff --git a/src/value/cast.ts b/src/value/cast.ts
index 66bb2abce..1ff3db94c 100644
--- a/src/value/cast.ts
+++ b/src/value/cast.ts
@@ -178,7 +178,7 @@ export namespace ValueCast {
     throw new ValueCastNeverTypeError(schema)
   }
   function Not(schema: Types.TNot, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema.allOf[1], references)
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
   }
   function Null(schema: Types.TNull, references: Types.TSchema[], value: any): any {
     return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
diff --git a/src/value/check.ts b/src/value/check.ts
index 40c2fd5ef..a0458cb8f 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -201,7 +201,7 @@ export namespace ValueCheck {
     return false
   }
   function Not(schema: Types.TNot, references: Types.TSchema[], value: any): boolean {
-    return !Visit(schema.allOf[0].not, references, value) && Visit(schema.allOf[1], references, value)
+    return !Visit(schema.not, references, value)
   }
   function Null(schema: Types.TNull, references: Types.TSchema[], value: any): boolean {
     return value === null
diff --git a/src/value/create.ts b/src/value/create.ts
index ae2e9b18d..66973e3d4 100644
--- a/src/value/create.ts
+++ b/src/value/create.ts
@@ -42,6 +42,11 @@ export class ValueCreateNeverTypeError extends Error {
     super('ValueCreate: Never types cannot be created')
   }
 }
+export class ValueCreateNotTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('ValueCreate: Not types must have a default value')
+  }
+}
 export class ValueCreateIntersectTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
     super('ValueCreate: Intersect produced invalid value. Consider using a default value.')
@@ -182,7 +187,7 @@ export namespace ValueCreate {
     if ('default' in schema) {
       return schema.default
     } else {
-      return Visit(schema.allOf[1], references)
+      throw new ValueCreateNotTypeError(schema)
     }
   }
   function Null(schema: Types.TNull, references: Types.TSchema[]): any {
diff --git a/test/runtime/compiler/not.ts b/test/runtime/compiler/not.ts
index 27a07c5ba..144b31de4 100644
--- a/test/runtime/compiler/not.ts
+++ b/test/runtime/compiler/not.ts
@@ -2,37 +2,44 @@ import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
 describe('type/compiler/Not', () => {
-  it('Should validate with not number', () => {
-    const T = Type.Not(Type.Number(), Type.String())
+  it('Should validate not number', () => {
+    const T = Type.Not(Type.Number())
     Fail(T, 1)
-    Ok(T, 'A')
+    Ok(T, '1')
   })
-  it('Should validate with union left', () => {
+  it('Should validate not not number', () => {
+    const T = Type.Not(Type.Not(Type.Number()))
+    Ok(T, 1)
+    Fail(T, '1')
+  })
+  it('Should validate not union', () => {
     // prettier-ignore
     const T = Type.Not(Type.Union([
       Type.Literal('A'), 
       Type.Literal('B'), 
       Type.Literal('C')
-    ]), Type.String())
+    ]))
     Fail(T, 'A')
     Fail(T, 'B')
     Fail(T, 'C')
     Ok(T, 'D')
   })
-  it('Should validate with union right', () => {
-    // prettier-ignore
-    const T = Type.Not(Type.Number(), Type.Union([
-      Type.String(),
-      Type.Boolean()
-    ]))
-    Fail(T, 1)
-    Ok(T, 'A')
-    Ok(T, true)
-  })
-  it('Should not validate with symmetric left right', () => {
-    // prettier-ignore
-    const T = Type.Not(Type.Number(), Type.Number())
-    Fail(T, 1)
-    Fail(T, true) // not a number, but not a number either?
+  it('Should validate not object intersection', () => {
+    const T = Type.Intersect([
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+      Type.Object({
+        x: Type.Not(Type.Literal(0)),
+        y: Type.Not(Type.Literal(0)),
+        z: Type.Not(Type.Literal(0)),
+      }),
+    ])
+    Fail(T, { x: 0, y: 0, z: 0 })
+    Fail(T, { x: 1, y: 0, z: 0 })
+    Fail(T, { x: 1, y: 1, z: 0 })
+    Ok(T, { x: 1, y: 1, z: 1 })
   })
 })
diff --git a/test/runtime/compiler/object.ts b/test/runtime/compiler/object.ts
index 47a59a685..5b3079344 100644
--- a/test/runtime/compiler/object.ts
+++ b/test/runtime/compiler/object.ts
@@ -7,7 +7,7 @@ describe('type/compiler/Object', () => {
   // -----------------------------------------------------
   it('Should handle extends undefined check 1', () => {
     const T = Type.Object({
-      A: Type.Not(Type.Number(), Type.Undefined()),
+      A: Type.Not(Type.Number()),
       B: Type.Union([Type.Number(), Type.Undefined()]),
       C: Type.Intersect([Type.Undefined(), Type.Undefined()]),
     })
@@ -20,7 +20,7 @@ describe('type/compiler/Object', () => {
   // https://github.com/sinclairzx81/typebox/issues/437
   it('Should handle extends undefined check 2', () => {
     const T = Type.Object({
-      A: Type.Not(Type.Null(), Type.Undefined()),
+      A: Type.Not(Type.Null()),
     })
     Ok(T, { A: undefined })
     Fail(T, { A: null })
diff --git a/test/runtime/schema/not.ts b/test/runtime/schema/not.ts
index c8ec36faf..491de05b4 100644
--- a/test/runtime/schema/not.ts
+++ b/test/runtime/schema/not.ts
@@ -2,37 +2,44 @@ import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
 describe('type/schema/Not', () => {
-  it('Should validate with not number', () => {
-    const T = Type.Not(Type.Number(), Type.String())
+  it('Should validate not number', () => {
+    const T = Type.Not(Type.Number())
     Fail(T, 1)
-    Ok(T, 'A')
+    Ok(T, '1')
   })
-  it('Should validate with union left', () => {
+  it('Should validate not not number', () => {
+    const T = Type.Not(Type.Not(Type.Number()))
+    Ok(T, 1)
+    Fail(T, '1')
+  })
+  it('Should validate not union', () => {
     // prettier-ignore
     const T = Type.Not(Type.Union([
       Type.Literal('A'), 
       Type.Literal('B'), 
       Type.Literal('C')
-    ]), Type.String())
+    ]))
     Fail(T, 'A')
     Fail(T, 'B')
     Fail(T, 'C')
     Ok(T, 'D')
   })
-  it('Should validate with union right', () => {
-    // prettier-ignore
-    const T = Type.Not(Type.Number(), Type.Union([
-      Type.String(),
-      Type.Boolean()
-    ]))
-    Fail(T, 1)
-    Ok(T, 'A')
-    Ok(T, true)
-  })
-  it('Should not validate with symmetric left right', () => {
-    // prettier-ignore
-    const T = Type.Not(Type.Number(), Type.Number())
-    Fail(T, 1)
-    Fail(T, true) // not a number, but not a number either?
+  it('Should validate not object intersection', () => {
+    const T = Type.Intersect([
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+      Type.Object({
+        x: Type.Not(Type.Literal(0)),
+        y: Type.Not(Type.Literal(0)),
+        z: Type.Not(Type.Literal(0)),
+      }),
+    ])
+    Fail(T, { x: 0, y: 0, z: 0 })
+    Fail(T, { x: 1, y: 0, z: 0 })
+    Fail(T, { x: 1, y: 1, z: 0 })
+    Ok(T, { x: 1, y: 1, z: 1 })
   })
 })
diff --git a/test/runtime/type/extends/index.ts b/test/runtime/type/extends/index.ts
index 1bd1dc959..be6eed0b2 100644
--- a/test/runtime/type/extends/index.ts
+++ b/test/runtime/type/extends/index.ts
@@ -7,6 +7,7 @@ import './date'
 import './function'
 import './integer'
 import './literal'
+import './not'
 import './null'
 import './number'
 import './object'
diff --git a/test/runtime/type/extends/not.ts b/test/runtime/type/extends/not.ts
new file mode 100644
index 000000000..be5bbfa9b
--- /dev/null
+++ b/test/runtime/type/extends/not.ts
@@ -0,0 +1,130 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+// ---------------------------------------------------------------------------
+// Note: Not is equivalent to Unknown with the exception of nested negation.
+// ---------------------------------------------------------------------------
+describe('type/extends/Not', () => {
+  // ---------------------------------------------------------------------------
+  // Nested
+  // ---------------------------------------------------------------------------
+  it('Should extend with nested negation', () => {
+    const T1 = Type.String()
+    const T2 = Type.Not(T1)
+    const T3 = Type.Not(T2)
+    const T4 = Type.Not(T3)
+    const T5 = Type.Not(T4)
+
+    const R1 = TypeExtends.Extends(T1, Type.String())
+    const R2 = TypeExtends.Extends(T2, Type.String())
+    const R3 = TypeExtends.Extends(T3, Type.String())
+    const R4 = TypeExtends.Extends(T4, Type.String())
+    const R5 = TypeExtends.Extends(T5, Type.String())
+
+    Assert.isEqual(R1, TypeExtendsResult.True)
+    Assert.isEqual(R2, TypeExtendsResult.False)
+    Assert.isEqual(R3, TypeExtendsResult.True)
+    Assert.isEqual(R4, TypeExtendsResult.False)
+    Assert.isEqual(R5, TypeExtendsResult.True)
+  })
+
+  // ---------------------------------------------------------------------------
+  // Not as Unknown Tests
+  // ---------------------------------------------------------------------------
+  it('Should extend Any', () => {
+    type T = unknown extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Any())
+    Assert.isEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Unknown', () => {
+    type T = unknown extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Unknown())
+    Assert.isEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend String', () => {
+    type T = unknown extends string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.String())
+    Assert.isEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Boolean', () => {
+    type T = unknown extends boolean ? 1 : 2
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Boolean())
+    Assert.isEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Number', () => {
+    type T = unknown extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Number())
+    Assert.isEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Integer', () => {
+    type T = unknown extends number ? 1 : 2
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Integer())
+    Assert.isEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Array 1', () => {
+    type T = unknown extends Array<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Array(Type.Any()))
+    Assert.isEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Array 2', () => {
+    type T = unknown extends Array<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Array(Type.String()))
+    Assert.isEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Tuple', () => {
+    type T = unknown extends [number, number] ? 1 : 2
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.isEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Object 1', () => {
+    type T = unknown extends {} ? 1 : 2
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Object({}))
+    Assert.isEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Object 2', () => {
+    type T = unknown extends { a: number } ? 1 : 2
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Object({ a: Type.Number() }))
+    Assert.isEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Union 1', () => {
+    type T = unknown extends number | string ? 1 : 2
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Union([Type.Number(), Type.String()]))
+    Assert.isEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Union 2', () => {
+    type T = unknown extends any | number ? 1 : 2 // 1
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Union([Type.Any(), Type.String()]))
+    Assert.isEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Union 3', () => {
+    type T = unknown extends unknown | number ? 1 : 2 // 1
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Union([Type.Unknown(), Type.String()]))
+    Assert.isEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Union 4', () => {
+    type T = unknown extends unknown | any ? 1 : 2 // 1
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Union([Type.Unknown(), Type.String()]))
+    Assert.isEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Null', () => {
+    type T = unknown extends null ? 1 : 2
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Null())
+    Assert.isEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Undefined', () => {
+    type T = unknown extends undefined ? 1 : 2
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Undefined())
+    Assert.isEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Void', () => {
+    type T = unknown extends void ? 1 : 2
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Void())
+    Assert.isEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Date', () => {
+    type T = unknown extends Date ? 1 : 2
+    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Date())
+    Assert.isEqual(R, TypeExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/guard/not.ts b/test/runtime/type/guard/not.ts
index b5a8bf07a..1bb7c2c87 100644
--- a/test/runtime/type/guard/not.ts
+++ b/test/runtime/type/guard/not.ts
@@ -4,20 +4,16 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TNot', () => {
   it('Should guard for TNot', () => {
-    const R = TypeGuard.TNot(Type.Not(Type.String(), Type.String()))
+    const R = TypeGuard.TNot(Type.Not(Type.String()))
     Assert.isEqual(R, true)
   })
   it('Should not guard for TNot 1', () => {
-    const R = TypeGuard.TNot(Type.Not(null as any, Type.String()))
-    Assert.isEqual(R, false)
-  })
-  it('Should not guard for TNot 2', () => {
-    const R = TypeGuard.TNot(Type.Not(Type.String(), null as any))
+    const R = TypeGuard.TNot(Type.Not(null as any))
     Assert.isEqual(R, false)
   })
   it('Should not guard for TNot with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TNot(Type.Not(Type.String(), Type.String()), { $id: 1 })
+    const R = TypeGuard.TNot(Type.Not(Type.String()), { $id: 1 })
     Assert.isEqual(R, true)
   })
 })
diff --git a/test/runtime/value/cast/not.ts b/test/runtime/value/cast/not.ts
index 0fc2d1ed4..e0713d473 100644
--- a/test/runtime/value/cast/not.ts
+++ b/test/runtime/value/cast/not.ts
@@ -3,57 +3,50 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/cast/Not', () => {
-  const T = Type.Not(Type.String(), Type.Number())
-  const E = 0
+  const T = Type.Not(Type.String(), { default: 0 })
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.isEqual(result, 0) // default
   })
   it('Should upcast from number', () => {
     const value = 0
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.isEqual(result, value)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.isEqual(result, value)
   })
   it('Should preserve', () => {
     const value = 100
     const result = Value.Cast(T, value)
     Assert.isEqual(result, 100)
   })
-  it('Should not preserve when schema is illogical', () => {
-    const T = Type.Not(Type.Number(), Type.Number())
-    const value = 100
-    const result = Value.Cast(T, value)
-    Assert.isEqual(result, 0)
-  })
 })
diff --git a/test/runtime/value/check/not.ts b/test/runtime/value/check/not.ts
index abfc89597..780d08c24 100644
--- a/test/runtime/value/check/not.ts
+++ b/test/runtime/value/check/not.ts
@@ -30,10 +30,4 @@ describe('value/check/Not', () => {
     Assert.isEqual(Value.Check(T, 'A'), true)
     Assert.isEqual(Value.Check(T, true), true)
   })
-  it('Should not validate with symmetric left right', () => {
-    // prettier-ignore
-    const T = Type.Not(Type.Number(), Type.Number())
-    Assert.isEqual(Value.Check(T, 1), false)
-    Assert.isEqual(Value.Check(T, true), false)
-  })
 })
diff --git a/test/runtime/value/create/not.ts b/test/runtime/value/create/not.ts
index 433e8552f..9890372c6 100644
--- a/test/runtime/value/create/not.ts
+++ b/test/runtime/value/create/not.ts
@@ -3,18 +3,17 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/create/Not', () => {
-  it('Should create value', () => {
-    const T = Type.Not(Type.String(), Type.Number())
-    const R = Value.Create(T)
-    Assert.isEqual(R, 0)
+  it('Should throw without default value', () => {
+    const T = Type.Not(Type.String())
+    Assert.throws(() => Value.Create(T))
   })
   it('Should create value with default inner', () => {
-    const T = Type.Not(Type.String(), Type.Number({ default: 100 }))
+    const T = Type.Not(Type.String(), { default: 100 })
     const R = Value.Create(T)
     Assert.isEqual(R, 100)
   })
   it('Should create value with default outer', () => {
-    const T = Type.Not(Type.String(), Type.Number(), { default: 100 })
+    const T = Type.Not(Type.String(), { default: 100 })
     const R = Value.Create(T)
     Assert.isEqual(R, 100)
   })
diff --git a/test/static/not.ts b/test/static/not.ts
index ea157157a..aa8a74d87 100644
--- a/test/static/not.ts
+++ b/test/static/not.ts
@@ -2,6 +2,10 @@ import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
 {
-  const T = Type.Not(Type.Number(), Type.String())
-  Expect(T).ToInfer<string>()
+  const T = Type.Not(Type.Number())
+  Expect(T).ToInfer<unknown>()
+}
+{
+  const T = Type.Not(Type.Not(Type.Number()))
+  Expect(T).ToInfer<number>()
 }
diff --git a/typebox.png b/typebox.png
index ed053e1f3df23df4eca1b25d94b0df721437a1e9..d38acd1373310d36660ee8f346de3c31259a8a01 100644
GIT binary patch
literal 872194
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%0DVn_#%4b^_
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
Vz~r4H)K&lh002ovPDHLkV1g0b>|_7{

literal 946728
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%0Ahz4OCA5{ySR@m#xkrQaLe
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%0D_qOlSO~8l$4<98g-Mltb*5H+5
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%0D6${Pcq+tJHh?RYA#{UyuGWFqa
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
N002ovPDHLkV1hI>{(S%d

diff --git a/workbench.png b/workbench.png
deleted file mode 100644
index 817b9d17445d7ab66329ade51e302536cda28385..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 43713
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


From 337532d20ad74cfb2c1ba4ae594b4465f274a539 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Mon, 3 Jul 2023 00:08:49 +0900
Subject: [PATCH 151/369] Revision 0.29.0

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 1ff66fddc..1c1262c4b 100644
--- a/readme.md
+++ b/readme.md
@@ -888,7 +888,7 @@ const C = Type.Index(T, Type.KeyOf(T))               // const C = {
 
 ### Not Types
 
-Not types are supported with `Type.Not`. This type represents the JSON Schema `not` keyword and will statically infer as `unknown`. Note that negated (or not) types are not supported in TypeScript, but can still be partially expressed by interpreting `not` as the broad type `unknown`. When used with intersect types, the Not type can create refined assertion rules for types by leveraging TypeScript's ability to narrow from `unknown` to an intended type through intersection.
+Not types are supported with `Type.Not`. This type represents the JSON Schema `not` keyword and will statically infer as `unknown`. Note that Not types are not supported in TypeScript, but can still be partially expressed by interpreting `not` as the broad type `unknown`. When used in intersections, the Not type can be used to create refined assertion rules for specific types, with the inference derived from TypeScript's ability to narrow from `unknown` to `T` via intersection.
 
 For example, consider a type which is `number` but not `1 | 2 | 3` and where the static type would still technically be a `number`. The following shows a pseudo TypeScript example using `not` followed by the TypeBox implementation.
 

From bdeb24f15fe872d9da793cfd33820553f384f1b4 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 3 Jul 2023 03:52:38 +0900
Subject: [PATCH 152/369] Revision 0.29.1 (#485)

---
 package-lock.json                |  4 ++--
 package.json                     |  2 +-
 readme.md                        |  1 +
 src/typebox.ts                   | 32 ++++++++++++++++++++++++--------
 test/runtime/type/extends/not.ts | 15 +++++++++++++++
 test/static/not.ts               | 15 +++++++++++++++
 6 files changed, 58 insertions(+), 11 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 98d18eb2c..3cb6da902 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.29.0",
+  "version": "0.29.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.29.0",
+      "version": "0.29.1",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 6cc25a10f..cbdd26dc4 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.29.0",
+  "version": "0.29.1",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 1c1262c4b..7e7caaaac 100644
--- a/readme.md
+++ b/readme.md
@@ -1473,6 +1473,7 @@ The following is a list of community packages that provide general tooling and f
 | [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
 | [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from JSON schemas |
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
+| [typebox-client](https://github.com/flodlc/typebox-client) | Type safe http client library for Fastify |
 | [typebox-validators](https://github.com/jtlapp/typebox-validators) | Advanced validators supporting discriminated and heterogeneous unions |
 
 <a name='benchmark'></a>
diff --git a/src/typebox.ts b/src/typebox.ts
index f5c04c6aa..b9acbdf05 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -1540,7 +1540,7 @@ export namespace TypeExtends {
   // --------------------------------------------------------------------------
   // Not
   // --------------------------------------------------------------------------
-  function ResolveNot<T extends TNot>(schema: T): TUnknown | TNot['not'] {
+  function UnwrapNot<T extends TNot>(schema: T): TUnknown | TNot['not'] {
     let [current, depth]: [TSchema, number] = [schema, 0]
     while (true) {
       if (!TypeGuard.TNot(current)) break
@@ -1549,6 +1549,14 @@ export namespace TypeExtends {
     }
     return depth % 2 === 0 ? current : Type.Unknown()
   }
+  function Not(left: TSchema, right: TSchema) {
+    // TypeScript has no concept of negated types, and attempts to correctly check the negated
+    // type at runtime would put TypeBox at odds with TypeScripts ability to statically infer
+    // the type. Instead we unwrap to either unknown or T and continue evaluating.
+    if (TypeGuard.TNot(left)) return Visit(UnwrapNot(left), right)
+    if (TypeGuard.TNot(right)) return Visit(left, UnwrapNot(right))
+    throw new Error(`TypeExtends: Invalid fallthrough for Not`)
+  }
   // --------------------------------------------------------------------------
   // Null
   // --------------------------------------------------------------------------
@@ -1764,6 +1772,17 @@ export namespace TypeExtends {
     return TypeGuard.TSymbol(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
+  // TemplateLiteral
+  // --------------------------------------------------------------------------
+  function TemplateLiteral(left: TSchema, right: TSchema) {
+    // TemplateLiteral types are resolved to either unions for finite expressions or string
+    // for infinite expressions. Here we call to TemplateLiteralResolver to resolve for
+    // either type and continue evaluating.
+    if (TypeGuard.TTemplateLiteral(left)) return Visit(TemplateLiteralResolver.Resolve(left), right)
+    if (TypeGuard.TTemplateLiteral(right)) return Visit(left, TemplateLiteralResolver.Resolve(right))
+    throw new Error(`TypeExtends: Invalid fallthrough for TemplateLiteral`)
+  }
+  // --------------------------------------------------------------------------
   // Tuple
   // --------------------------------------------------------------------------
   function TupleRight(left: TSchema, right: TTuple) {
@@ -1857,13 +1876,10 @@ export namespace TypeExtends {
     return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   function Visit(left: TSchema, right: TSchema): TypeExtendsResult {
-    // Not Unwrap
-    if (TypeGuard.TNot(left)) return Visit(ResolveNot(left), right)
-    if (TypeGuard.TNot(right)) return Visit(left, ResolveNot(right))
-    // Template Literal Union Unwrap
-    if (TypeGuard.TTemplateLiteral(left)) return Visit(TemplateLiteralResolver.Resolve(left), right)
-    if (TypeGuard.TTemplateLiteral(right)) return Visit(left, TemplateLiteralResolver.Resolve(right))
-    // Standard Extends
+    // Resolvable Types
+    if (TypeGuard.TTemplateLiteral(left) || TypeGuard.TTemplateLiteral(right)) return TemplateLiteral(left, right)
+    if (TypeGuard.TNot(left) || TypeGuard.TNot(right)) return Not(left, right)
+    // Standard Types
     if (TypeGuard.TAny(left)) return Any(left, right)
     if (TypeGuard.TArray(left)) return Array(left, right)
     if (TypeGuard.TBigInt(left)) return BigInt(left, right)
diff --git a/test/runtime/type/extends/not.ts b/test/runtime/type/extends/not.ts
index be5bbfa9b..e23e5352f 100644
--- a/test/runtime/type/extends/not.ts
+++ b/test/runtime/type/extends/not.ts
@@ -6,6 +6,21 @@ import { Assert } from '../../assert/index'
 // Note: Not is equivalent to Unknown with the exception of nested negation.
 // ---------------------------------------------------------------------------
 describe('type/extends/Not', () => {
+  // -------------------------------------------------------------------------
+  // Issue: type T = number extends not number ? true : false // true
+  //        type T = number extends unknown ? true : false    // true
+  //
+  // TypeScript does not support type negation. The best TypeBox can do is
+  // treat "not" as "unknown". From this standpoint, the extends assignability
+  // check needs to return true for the following case to keep TypeBox aligned
+  // with TypeScript static inference.
+  // -------------------------------------------------------------------------
+  it('Should extend with unknown assignability check', () => {
+    const A = Type.Number()
+    const B = Type.Not(Type.Number())
+    const R = TypeExtends.Extends(A, B)
+    Assert.isEqual(R, TypeExtendsResult.True) // we would expect false
+  })
   // ---------------------------------------------------------------------------
   // Nested
   // ---------------------------------------------------------------------------
diff --git a/test/static/not.ts b/test/static/not.ts
index aa8a74d87..de3abbf7d 100644
--- a/test/static/not.ts
+++ b/test/static/not.ts
@@ -1,6 +1,21 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
+{
+  // -------------------------------------------------------------------------
+  // Issue: type T = number extends not number ? true : false // true
+  //        type T = number extends unknown ? true : false    // true
+  //
+  // TypeScript does not support type negation. The best TypeBox can do is
+  // treat "not" as "unknown". From this standpoint, the extends assignability
+  // check needs to return true for the following case to keep TypeBox aligned
+  // with TypeScript static inference.
+  // -------------------------------------------------------------------------
+  const A = Type.Number()
+  const B = Type.Not(Type.Number())
+  const T = Type.Extends(A, B, Type.Literal(true), Type.Literal(false))
+  Expect(T).ToInfer<true>()
+}
 {
   const T = Type.Not(Type.Number())
   Expect(T).ToInfer<unknown>()

From 1504082b96fcc3702a8fabe23deb35e5507c3b9b Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Mon, 3 Jul 2023 05:09:23 +0900
Subject: [PATCH 153/369] Revision 0.29.1

---
 changelog/0.29.0.md | 44 ++++++++++++++++++++++++++++++++++++++++----
 readme.md           | 20 +++++++++++---------
 2 files changed, 51 insertions(+), 13 deletions(-)

diff --git a/changelog/0.29.0.md b/changelog/0.29.0.md
index e4cca9f49..1291219d7 100644
--- a/changelog/0.29.0.md
+++ b/changelog/0.29.0.md
@@ -6,6 +6,15 @@ Revision 0.29.0 makes a minor interface and schema representation change to the
 
 As this revision constitutes a breaking representation change for `Type.Not`, a minor semver revision is required.
 
+## Contents
+
+- Enhancements
+  - [Type.Not Representation Change](#Representation-Change)
+  - [Not Inversion](#Not-Inversion)
+  - [Inference Limitations](#Inference-Limitations)
+
+<a name="Representation-Change"></a>
+
 ## Type.Not Representation Change
 
 The `Type.Not` was first introduced in Revision 0.26.0. This type accepted two arguments, the first is the `not` type, the second is the `allowed` type. In 0.26.0, TypeBox would treat the `allowed` type as the inferred type with the schema represented in the following form.
@@ -81,11 +90,13 @@ const T = {
 //
 type T = Static<typeof T>              // type T = number
 ```
-The 0.29.0 `Not` type properly represents the JSON Schema `not` keyword in its simplest form, as well as making better use of the type intersection narrowing capabilities of TypeScript with respect to inference.
+The 0.29.0 `Not` type properly represents the JSON Schema `not` keyword in its simplest form, as well as making better use of intersection type narrowing capabilities of TypeScript.
 
-### Invert Not 
+<a name="Not-Inversion"></a>
 
-In revision 0.29.0, it is possible to invert the `Not` type. TypeBox will track each inversion and statically infer appropriately.
+## Not Inversion
+
+The not type can be inverted through nesting.
 
 ```typescript
 // not not string
@@ -105,4 +116,29 @@ const T = {
 // inferred as
 //
 type T = Static<typeof T>              // type T = string
-```
\ No newline at end of file
+```
+
+<a name="Inference-Limitations"></a>
+
+## Inference Limitations
+
+Not types are synonymous with the concept of [negated types](https://github.com/microsoft/TypeScript/issues/4196) which are not supported in the TypeScript language. Because of this, it is not currently possible to infer negated types in a way one would naturally expect for some cases. Consider the following.
+
+```typescript
+const T = Type.Intersect([Type.String(), Type.Not(Type.String())])
+
+type T = Static<typeof T> // type T = string & not string
+                          // actual: string
+                          // expect: never
+```
+As such, the use of Not types should be used with some consideration to current limitations, and reserved primarily for narrowing cases such as the following.
+
+```typescript
+const T = Type.Intersect([Type.String(), Type.Not(Type.Literal('disallowed string'))])
+
+type T = Static<typeof T> // type T = string & not 'disallowed string'
+                          // actual: string
+                          // expect: string
+```
+
+
diff --git a/readme.md b/readme.md
index 7e7caaaac..a39085005 100644
--- a/readme.md
+++ b/readme.md
@@ -888,14 +888,16 @@ const C = Type.Index(T, Type.KeyOf(T))               // const C = {
 
 ### Not Types
 
-Not types are supported with `Type.Not`. This type represents the JSON Schema `not` keyword and will statically infer as `unknown`. Note that Not types are not supported in TypeScript, but can still be partially expressed by interpreting `not` as the broad type `unknown`. When used in intersections, the Not type can be used to create refined assertion rules for specific types, with the inference derived from TypeScript's ability to narrow from `unknown` to `T` via intersection.
-
-For example, consider a type which is `number` but not `1 | 2 | 3` and where the static type would still technically be a `number`. The following shows a pseudo TypeScript example using `not` followed by the TypeBox implementation.
+TypeBox has partial support for the JSON schema `not` keyword with `Type.Not`. This type is synonymous with the concept of a [negated types](https://github.com/microsoft/TypeScript/issues/4196) which are not supported in the TypeScript language. TypeBox does provide partial inference support via the intersection of `T & not U` (where all negated types infer as `unknown`). This can be used in the following context.
 
 ```typescript
-// Pseudo TypeScript
+// TypeScript
 
-type T = number & not (1 | 2 | 3)                    // allow all numbers except 1, 2, 3
+type T = Exclude<number, 1 | 2 | 3>                  // all numbers except 1, 2, 3
+                                                     //
+                                                     // ideally expressed as: 
+                                                     //
+                                                     // type T = number & not (1 | 2 | 3)
 
 // TypeBox
 
@@ -914,11 +916,11 @@ const T = Type.Intersect([                           // const T = {
                                                      //   ]
                                                      // }
 
-type T = Static<typeof T>                            // evaluates as:
+type T = Static<typeof T>                            // inferred:
                                                      //
-                                                     // type T = (number & (not (1 | 2 | 3)))
-                                                     // type T = (number & (unknown))
-                                                     // type T = (number) 
+                                                     // type T = number & not (1 | 2 | 3)
+                                                     // type T = number & unknown
+                                                     // type T = number
 ```
 
 The Not type can be used with constraints to define schematics for types that would otherwise be difficult to express.

From c8d8a701c7fe4d13d2d737cddf0ec99101f6160d Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 4 Jul 2023 06:27:34 +0900
Subject: [PATCH 154/369] Revision 0.29.2 (#486)

---
 changelog/0.29.2.md                          | 141 +++++++
 example/codegen/formatter.ts                 |  63 ---
 example/codegen/index.ts                     |  32 --
 example/codegen/tsconfig.json                |   4 -
 example/codegen/typebox-to-typescript.ts     | 187 ---------
 example/codegen/typebox-to-zod.ts            | 275 -------------
 example/codegen/typescript-to-json-schema.ts | 360 -----------------
 example/codegen/typescript-to-typebox.ts     | 383 -------------------
 package.json                                 |   2 +-
 readme.md                                    | 126 +++---
 src/typebox.ts                               |  95 ++++-
 test/runtime/type/guard/composite.ts         |  30 +-
 test/runtime/type/guard/indexed.ts           |  38 ++
 test/runtime/type/normalize/index.ts         |   1 +
 test/runtime/type/normalize/indexed.ts       | 140 +++++++
 15 files changed, 494 insertions(+), 1383 deletions(-)
 create mode 100644 changelog/0.29.2.md
 delete mode 100644 example/codegen/formatter.ts
 delete mode 100644 example/codegen/index.ts
 delete mode 100644 example/codegen/tsconfig.json
 delete mode 100644 example/codegen/typebox-to-typescript.ts
 delete mode 100644 example/codegen/typebox-to-zod.ts
 delete mode 100644 example/codegen/typescript-to-json-schema.ts
 delete mode 100644 example/codegen/typescript-to-typebox.ts
 create mode 100644 test/runtime/type/normalize/indexed.ts

diff --git a/changelog/0.29.2.md b/changelog/0.29.2.md
new file mode 100644
index 000000000..f87cfc217
--- /dev/null
+++ b/changelog/0.29.2.md
@@ -0,0 +1,141 @@
+## [0.29.2](https://www.npmjs.com/package/@sinclair/typebox/v/0.29.2)
+
+## Overview
+
+Revision 0.29.2 includes enhancements to `Type.Index`
+
+This revision contains no breaking changes
+
+## Contents
+
+- Enhancements
+  - [Modifier Index Resolver](#Modifier-Index-Resolver)
+  - [Indexed Intersect](#Indexed-Intersect)
+  - [Indexed Union](#Indexed-Union)
+  - [Composite](#Composite)
+
+<a name="Modifier-Index-Resolver"></a>
+
+## Modifier Index Resolver
+
+Revision 0.29.2 re-introduces optional property narrowing for Indexed Access Types. This functionality is specific when indexing overlapping properties with one or more optional modifiers. Revision 0.28.0 attempted to implement this narrowing, however was pulled due to instantiation issues raised on issue [419](https://github.com/sinclairzx81/typebox/issues/419) (specific to composite narrowing)
+
+Revision 0.29.2 attempts to re-introduce this functionality using a different resolution strategy. It uses Indexed Access Types as the construct in which to apply such narrowing and expands upon Union and Intersection type normalization for optional modifier unwrap and remapping. This approach unifies Composite inference with Index Access Types and makes provisions for a possible `Type.Mapped` feature in later releases.
+
+<a name="Indexed-Intersect"></a>
+
+## Indexed Intersect
+
+The following are the index resolver cases for intersect types.
+
+### Case 1
+```typescript
+const T = Type.Intersect([
+  Type.Object({ x: Type.Optional(Type.Number()) }),
+  Type.Object({ x: Type.Optional(Type.Number()) })
+])
+
+const I = Type.Index(T, ['x']) 
+
+// type I = TOptional<TUnion<[TNumber, TNumber]>>
+```
+### Case 2
+```typescript
+const T = Type.Intersect([
+  Type.Object({ x: Type.Optional(Type.Number()) }),
+  Type.Object({ x: Type.Number() })
+])
+
+const I = Type.Index(T, ['x']) 
+
+// type I = TUnion<[TNumber, TNumber]>
+```
+### Case 3
+```typescript
+const T = Type.Intersect([
+  Type.Object({ x: Type.Number() }),
+  Type.Object({ x: Type.Number() })
+])
+
+const I = Type.Index(T, ['x']) 
+
+// type I = TUnion<[TNumber, TNumber]>
+```
+<a name="Indexed-Union"></a>
+
+## Indexed Union
+
+The following are the index resolver cases for union types.
+
+### Case 1
+```typescript
+const T = Type.Union([
+  Type.Object({ x: Type.Optional(Type.Number()) }),
+  Type.Object({ x: Type.Optional(Type.Number()) })
+])
+
+const I = Type.Index(T, ['x']) 
+
+// type I = TOptional<TUnion<[TNumber, TNumber]>>
+```
+### Case 2
+```typescript
+const T = Type.Union([
+  Type.Object({ x: Type.Optional(Type.Number()) }),
+  Type.Object({ x: Type.Number() })
+])
+
+const I = Type.Index(T, ['x']) 
+
+// type I = TOptional<TUnion<[TNumber, TNumber]>>
+```
+### Case 3
+```typescript
+const T = Type.Union([
+  Type.Object({ x: Type.Number() }),
+  Type.Object({ x: Type.Number() })
+])
+
+const I = Type.Index(T, ['x']) 
+
+// type I = TUnion<[TNumber, TNumber]>
+```
+<a name="Composite"></a>
+
+## Composite
+
+The following are the resolver cases for indexed types when applied to composite intersection.
+
+### Case 1
+```typescript
+const T = Type.Composite([
+  Type.Object({ x: Type.Optional(Type.Number()) }),
+  Type.Object({ x: Type.Optional(Type.Number()) })
+])
+
+// type T = TObject<{
+//    x: TOptional<TUnion<[TNumber, TNumber]>>
+// }>
+```
+### Case 2
+```typescript
+const T = Type.Composite([
+  Type.Object({ x: Type.Optional(Type.Number()) }),
+  Type.Object({ x: Type.Number() })
+])
+
+// type T = TObject<{
+//   x: TUnion<[TNumber, TNumber]>
+// }>
+```
+### Case 3
+```typescript
+const T = Type.Composite([
+  Type.Object({ x: Type.Number() }),
+  Type.Object({ x: Type.Number() })
+])
+
+// type T = TObject<{
+//   x: TUnion<[TNumber, TNumber]>
+// }>
+```
\ No newline at end of file
diff --git a/example/codegen/formatter.ts b/example/codegen/formatter.ts
deleted file mode 100644
index ffa6b58c2..000000000
--- a/example/codegen/formatter.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/codegen
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-export namespace Formatter {
-  export function Includes(line: string, token: string) {
-    return line.includes(token)
-  }
-  function IntentBefore(line: string) {
-    if (Includes(line, '({') && Includes(line, '})')) return 0
-    if (Includes(line, '([') && Includes(line, '])')) return 0
-    if (Includes(line, '{') && Includes(line, '}')) return 0
-    if (Includes(line, '])')) return -1
-    if (Includes(line, '})')) return -1
-    if (Includes(line, '}')) return -1
-    if (Includes(line, ']')) return -1
-    return 0
-  }
-  function IndentAfter(line: string) {
-    if (Includes(line, '({') && Includes(line, '})')) return 0
-    if (Includes(line, '([') && Includes(line, '])')) return 0
-    if (Includes(line, '{') && Includes(line, '}')) return 0
-    if (Includes(line, '([')) return 1
-    if (Includes(line, '({')) return 1
-    if (Includes(line, '{')) return 1
-    if (Includes(line, '[')) return 1
-    return 0
-  }
-  export function Format(input: string): string {
-    const output: string[] = []
-    let indent = 0
-    for (const line of input.split('\n').map((n) => n.trim())) {
-      indent += IntentBefore(line)
-      output.push(`${''.padStart(indent * 2, ' ')}${line}`)
-      indent += IndentAfter(line)
-    }
-    return output.join('\n')
-  }
-}
diff --git a/example/codegen/index.ts b/example/codegen/index.ts
deleted file mode 100644
index 0513ff9ca..000000000
--- a/example/codegen/index.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/codegen
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-export { TypeBoxToTypeScript } from './typebox-to-typescript'
-export { TypeBoxToZod } from './typebox-to-zod'
-export { TypeScriptToJsonSchema } from './typescript-to-json-schema'
-export { TypeScriptToTypeBox } from './typescript-to-typebox'
diff --git a/example/codegen/tsconfig.json b/example/codegen/tsconfig.json
deleted file mode 100644
index 6710ecd93..000000000
--- a/example/codegen/tsconfig.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "files": ["index.ts"]
-}
diff --git a/example/codegen/typebox-to-typescript.ts b/example/codegen/typebox-to-typescript.ts
deleted file mode 100644
index f7f76713a..000000000
--- a/example/codegen/typebox-to-typescript.ts
+++ /dev/null
@@ -1,187 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/codegen
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { Formatter } from './formatter'
-import * as Types from '@sinclair/typebox'
-
-export namespace TypeBoxToTypeScript {
-  function Any(schema: Types.TAny) {
-    return 'any'
-  }
-  function Array(schema: Types.TArray) {
-    const items = Visit(schema.items)
-    return `Array<${items}>`
-  }
-  function Boolean(schema: Types.TBoolean) {
-    return 'boolean'
-  }
-  function Constructor(schema: Types.TConstructor) {
-    const params = schema.parameters.map((param) => Visit(param)).join(', ')
-    const returns = Visit(schema.returns)
-    return `new (${params}) => ${returns}`
-  }
-  function Function(schema: Types.TFunction) {
-    const params = schema.parameters.map((param) => Visit(param)).join(', ')
-    const returns = Visit(schema.returns)
-    return `(${params}) => ${returns}`
-  }
-  function Integer(schema: Types.TInteger) {
-    return 'number'
-  }
-  function Intersect(schema: Types.TIntersect) {
-    return `(${schema.allOf.map((schema) => Visit(schema)).join(' & ')})`
-  }
-  function Literal(schema: Types.TLiteral) {
-    if (typeof schema.const === 'string') {
-      return `'${schema.const}'`
-    } else {
-      return `${schema.const}`
-    }
-  }
-  function Never(schema: Types.TNever) {
-    return 'never'
-  }
-  function Null(schema: Types.TNull) {
-    return 'null'
-  }
-  function String(schema: Types.TString) {
-    return 'string'
-  }
-  function Number(schema: Types.TNumber) {
-    return 'number'
-  }
-  function Object(schema: Types.TObject) {
-    const properties: string = globalThis.Object.entries(schema.properties)
-      .map(([key, value]) => {
-        return `${key}: ${Visit(value)}`
-      })
-      .join(',\n')
-    return `{\n${properties}\n}`
-  }
-  function Promise(schema: Types.TPromise) {
-    const item = Visit(schema.item)
-    return `Promise<${item}>`
-  }
-  function Record(schema: Types.TRecord) {
-    for (const [key, value] of globalThis.Object.entries(schema.patternProperties)) {
-      const type = Visit(value)
-      if (key === Types.PatternNumberExact) {
-        return `Record<number, ${type}>`
-      } else {
-        return `Record<string, ${type}>`
-      }
-    }
-    throw Error('TypeBoxToTypeScript: Unreachable')
-  }
-  function Ref(schema: Types.TRef) {
-    return schema.$ref
-  }
-  function This(schema: Types.TThis) {
-    return schema.$ref
-  }
-  function Tuple(schema: Types.TTuple) {
-    if (schema.items === undefined) return `[]`
-    const items = schema.items.map((schema) => Visit(schema)).join(', ')
-    return `[${items}]`
-  }
-  function UInt8Array(schema: Types.TUint8Array) {
-    return `Uint8Array`
-  }
-  function Undefined(schema: Types.TUndefined) {
-    return `undefined`
-  }
-  function Union(schema: Types.TUnion) {
-    return `${schema.anyOf.map((schema) => Visit(schema)).join(' | ')}`
-  }
-  function Unknown(schema: Types.TUnknown) {
-    return `unknown`
-  }
-  function Void(schema: Types.TVoid) {
-    return `void`
-  }
-  function Visit(schema: Types.TSchema): string {
-    if (Types.TypeGuard.TAny(schema)) {
-      return Any(schema)
-    } else if (Types.TypeGuard.TArray(schema)) {
-      return Array(schema)
-    } else if (Types.TypeGuard.TBoolean(schema)) {
-      return Boolean(schema)
-    } else if (Types.TypeGuard.TConstructor(schema)) {
-      return Constructor(schema)
-    } else if (Types.TypeGuard.TFunction(schema)) {
-      return Function(schema)
-    } else if (Types.TypeGuard.TInteger(schema)) {
-      return Integer(schema)
-    } else if (Types.TypeGuard.TIntersect(schema)) {
-      return Intersect(schema)
-    } else if (Types.TypeGuard.TLiteral(schema)) {
-      return Literal(schema)
-    } else if (Types.TypeGuard.TNever(schema)) {
-      return Never(schema)
-    } else if (Types.TypeGuard.TNull(schema)) {
-      return Null(schema)
-    } else if (Types.TypeGuard.TNumber(schema)) {
-      return Number(schema)
-    } else if (Types.TypeGuard.TObject(schema)) {
-      return Object(schema)
-    } else if (Types.TypeGuard.TPromise(schema)) {
-      return Promise(schema)
-    } else if (Types.TypeGuard.TRecord(schema)) {
-      return Record(schema)
-    } else if (Types.TypeGuard.TRef(schema)) {
-      return Ref(schema)
-    } else if (Types.TypeGuard.TString(schema)) {
-      return String(schema)
-    } else if (Types.TypeGuard.TThis(schema)) {
-      return This(schema)
-    } else if (Types.TypeGuard.TTuple(schema)) {
-      return Tuple(schema)
-    } else if (Types.TypeGuard.TUint8Array(schema)) {
-      return UInt8Array(schema)
-    } else if (Types.TypeGuard.TUndefined(schema)) {
-      return Undefined(schema)
-    } else if (Types.TypeGuard.TUnion(schema)) {
-      return Union(schema)
-    } else if (Types.TypeGuard.TUnknown(schema)) {
-      return Unknown(schema)
-    } else if (Types.TypeGuard.TVoid(schema)) {
-      return Void(schema)
-    } else {
-      throw Error('TypeBoxToTypeScript: Unknown type')
-    }
-  }
-  /** Generates TypeScript code from TypeBox types */
-  export function Generate(schema: Types.TSchema, references: Types.TSchema[] = []) {
-    const result: string[] = []
-    for (const reference of references) {
-      result.push(`type ${reference.$id} = ${[...Visit(reference)].join('')}`)
-    }
-    result.push(`type ${schema.$id || 'T'} = ${[...Visit(schema)].join('')}`)
-    return Formatter.Format(result.join('\n\n'))
-  }
-}
diff --git a/example/codegen/typebox-to-zod.ts b/example/codegen/typebox-to-zod.ts
deleted file mode 100644
index bfcdc4b0c..000000000
--- a/example/codegen/typebox-to-zod.ts
+++ /dev/null
@@ -1,275 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/codegen
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { Formatter } from './formatter'
-import * as Types from '@sinclair/typebox'
-
-// --------------------------------------------------------------------------
-// Errors
-// --------------------------------------------------------------------------
-export class TypeBoxToZodNonReferentialType extends Error {
-  constructor(message: string) {
-    super(`TypeBoxToZod: ${message}`)
-  }
-}
-export class TypeBoxToZodUnsupportedType extends Error {
-  constructor(message: string) {
-    super(`TypeBoxToZod: ${message}`)
-  }
-}
-// --------------------------------------------------------------------------
-// Transform
-// --------------------------------------------------------------------------
-export interface ZodCodegenOptions {
-  imports: boolean
-  exports: boolean
-}
-export namespace TypeBoxToZod {
-  function Any(schema: Types.TAny) {
-    return `z.any()`
-  }
-  function Array(schema: Types.TArray) {
-    const items = Visit(schema.items)
-    return `z.array(${items})`
-  }
-  function Boolean(schema: Types.TBoolean) {
-    return `z.boolean()`
-  }
-  function Constructor(schema: Types.TConstructor): string {
-    throw new TypeBoxToZodUnsupportedType(`TConstructor`)
-  }
-  function Function(schema: Types.TFunction) {
-    const params = schema.parameters.map((param) => Visit(param)).join(`, `)
-    const returns = Visit(schema.returns)
-    return `z.function().args(${params}).returns(${returns})`
-  }
-  function Integer(schema: Types.TInteger) {
-    const buffer: string[] = []
-    buffer.push(`z.number().int()`)
-    if (schema.minimum !== undefined) buffer.push(`.min(${schema.minimum})`)
-    if (schema.maximum !== undefined) buffer.push(`.max(${schema.maximum})`)
-    if (schema.exclusiveMaximum !== undefined) buffer.push(`.max(${schema.exclusiveMaximum - 1})`)
-    if (schema.exclusiveMinimum !== undefined) buffer.push(`.max(${schema.exclusiveMinimum + 1})`)
-    if (schema.multipleOf !== undefined) buffer.push(`.multipleOf(${schema.multipleOf})`)
-    return buffer.join(``)
-  }
-  function Intersect(schema: Types.TIntersect) {
-    // note: Zod only supports binary intersection. While correct, this is partially at odds with TypeScript's
-    // ability to distribute across (A & B & C). This code reduces intersection to binary ops.
-    function reduce(rest: Types.TSchema[]): string {
-      if (rest.length === 0) throw Error('Expected at least one intersect type')
-      if (rest.length === 1) return Visit(rest[0])
-      const [left, right] = [rest[0], rest.slice(1)]
-      return `z.intersection(${Visit(left)}, ${reduce(right)})`
-    }
-    return reduce(schema.allOf)
-  }
-  function Literal(schema: Types.TLiteral) {
-    if (typeof schema.const === `string`) {
-      return `z.literal('${schema.const}')`
-    } else {
-      return `z.literal(${schema.const})`
-    }
-  }
-  function Never(schema: Types.TNever) {
-    return `z.never()`
-  }
-  function Null(schema: Types.TNull) {
-    return `z.null()`
-  }
-  function String(schema: Types.TString) {
-    const buffer: string[] = []
-    buffer.push(`z.string()`)
-    if (schema.maxLength !== undefined) buffer.push(`.max(${schema.maxLength})`)
-    if (schema.minLength !== undefined) buffer.push(`.min(${schema.minLength})`)
-    return buffer.join(``)
-  }
-  function Number(schema: Types.TNumber) {
-    const buffer: string[] = []
-    buffer.push(`z.number()`)
-    if (schema.minimum !== undefined) buffer.push(`.min(${schema.minimum})`)
-    if (schema.maximum !== undefined) buffer.push(`.max(${schema.maximum})`)
-    if (schema.exclusiveMaximum !== undefined) buffer.push(`.max(${schema.exclusiveMaximum - 1})`)
-    if (schema.exclusiveMinimum !== undefined) buffer.push(`.max(${schema.exclusiveMinimum + 1})`)
-    if (schema.multipleOf !== undefined) buffer.push(`.multipleOf(${schema.multipleOf})`)
-    return buffer.join(``)
-  }
-  function Object(schema: Types.TObject) {
-    const properties: string = globalThis.Object.entries(schema.properties)
-      .map(([key, value]) => {
-        const quoted = key.includes('-') || '1234567890'.includes(key.charAt(0))
-        const property = quoted ? `'${key}'` : key
-        return [`Optional`, `ReadonlyOptional`].includes(value[Types.Modifier] as string) ? `${property}: ${Visit(value)}.optional()` : `${property}: ${Visit(value)}`
-      })
-      .join(`,\n`)
-    const buffer: string[] = []
-    buffer.push(`z.object({\n${properties}\n})`)
-    if (schema.additionalProperties === false) buffer.push(`.strict()`)
-    return buffer.join(``)
-  }
-  function Promise(schema: Types.TPromise) {
-    const item = Visit(schema.item)
-    return `${item}.promise()`
-  }
-  function Record(schema: Types.TRecord) {
-    for (const [key, value] of globalThis.Object.entries(schema.patternProperties)) {
-      const type = Visit(value)
-      if (key === `^(0|[1-9][0-9]*)$`) {
-        throw new TypeBoxToZodUnsupportedType(`TRecord<TNumber, TUnknown>`)
-      } else {
-        return `z.record(${type})`
-      }
-    }
-    throw Error(`TypeBoxToZod: Unreachable`)
-  }
-  function Ref(schema: Types.TRef) {
-    if (!reference_map.has(schema.$ref!)) throw new TypeBoxToZodNonReferentialType(schema.$ref!)
-    return schema.$ref
-  }
-  function This(schema: Types.TThis) {
-    if (!reference_map.has(schema.$ref!)) throw new TypeBoxToZodNonReferentialType(schema.$ref!)
-    recursive_set.add(schema.$ref)
-    return schema.$ref
-  }
-  function Tuple(schema: Types.TTuple) {
-    if (schema.items === undefined) return `[]`
-    const items = schema.items.map((schema) => Visit(schema)).join(`, `)
-    return `z.tuple([${items}])`
-  }
-  function UInt8Array(schema: Types.TUint8Array): string {
-    throw new TypeBoxToZodUnsupportedType(`TUint8Array`)
-  }
-  function Undefined(schema: Types.TUndefined) {
-    return `z.undefined()`
-  }
-  function Union(schema: Types.TUnion) {
-    return `z.union([${schema.anyOf.map((schema) => Visit(schema)).join(`, `)}])`
-  }
-  function Unknown(schema: Types.TUnknown) {
-    return `z.unknown()`
-  }
-  function Void(schema: Types.TVoid) {
-    return `z.void()`
-  }
-  function Visit(schema: Types.TSchema): string {
-    if (schema.$id !== undefined) reference_map.set(schema.$id, schema)
-    if (Types.TypeGuard.TAny(schema)) {
-      return Any(schema)
-    } else if (Types.TypeGuard.TArray(schema)) {
-      return Array(schema)
-    } else if (Types.TypeGuard.TBoolean(schema)) {
-      return Boolean(schema)
-    } else if (Types.TypeGuard.TConstructor(schema)) {
-      return Constructor(schema)
-    } else if (Types.TypeGuard.TFunction(schema)) {
-      return Function(schema)
-    } else if (Types.TypeGuard.TInteger(schema)) {
-      return Integer(schema)
-    } else if (Types.TypeGuard.TIntersect(schema)) {
-      return Intersect(schema)
-    } else if (Types.TypeGuard.TLiteral(schema)) {
-      return Literal(schema)
-    } else if (Types.TypeGuard.TNever(schema)) {
-      return Never(schema)
-    } else if (Types.TypeGuard.TNull(schema)) {
-      return Null(schema)
-    } else if (Types.TypeGuard.TNumber(schema)) {
-      return Number(schema)
-    } else if (Types.TypeGuard.TObject(schema)) {
-      return Object(schema)
-    } else if (Types.TypeGuard.TPromise(schema)) {
-      return Promise(schema)
-    } else if (Types.TypeGuard.TRecord(schema)) {
-      return Record(schema)
-    } else if (Types.TypeGuard.TRef(schema)) {
-      return Ref(schema)
-    } else if (Types.TypeGuard.TString(schema)) {
-      return String(schema)
-    } else if (Types.TypeGuard.TThis(schema)) {
-      return This(schema)
-    } else if (Types.TypeGuard.TTuple(schema)) {
-      return Tuple(schema)
-    } else if (Types.TypeGuard.TUint8Array(schema)) {
-      return UInt8Array(schema)
-    } else if (Types.TypeGuard.TUndefined(schema)) {
-      return Undefined(schema)
-    } else if (Types.TypeGuard.TUnion(schema)) {
-      return Union(schema)
-    } else if (Types.TypeGuard.TUnknown(schema)) {
-      return Unknown(schema)
-    } else if (Types.TypeGuard.TVoid(schema)) {
-      return Void(schema)
-    } else {
-      throw Error(`TypeBoxToZod: Unknown type`)
-    }
-  }
-  const reference_map = new Map<string, Types.TSchema>()
-  const recursive_set = new Set<string>()
-  /** Renders a Zod definition of a TypeBox type */
-  export function Generate(schema: Types.TSchema, references: Types.TSchema[], options: ZodCodegenOptions = { imports: true, exports: false }) {
-    const emitted = new Set<string>()
-    const exports = options.exports ? 'export' : ''
-    const imports_code: string[] = []
-    const reference_code: string[] = []
-    const type_code: string[] = []
-    // initialize root schematic and reference map
-    if (schema.$id === undefined) schema.$id = `T_Generated`
-    for (const reference of references) {
-      if (reference.$id === undefined) throw new TypeBoxToZodNonReferentialType(JSON.stringify(reference))
-      reference_map.set(reference.$id, reference)
-    }
-    // render-code: Imports required for the generated code
-    if (options.imports) {
-      imports_code.push(`import z from 'zod'`)
-    }
-    // render-type: If we detect the root schematic has been referenced, we interpret this as a recursive
-    // root. It`s noted that zod performs 4x slower when wrapped in a lazy(() => ...), so this is considered
-    // an optimization.
-    const typedef = [...Visit(schema)].join(``)
-    if (recursive_set.has(schema.$id!)) {
-      type_code.push(`${exports} const ${schema.$id || `T`} = z.lazy(() => ${Formatter.Format(typedef)})`)
-    } else {
-      type_code.push(`${exports} const ${schema.$id || `T`} = ${Formatter.Format(typedef)}`)
-    }
-    emitted.add(schema.$id!)
-    // render-reference: References may either be recursive or not. We track a recursive_set when visiting
-    // schemas of type TSelf. If we`ve never observed the reference through recursion, when it should be safe
-    // to omit the lazy(() => ...) wrap.
-    for (const reference of reference_map.values()) {
-      if (emitted.has(reference.$id!)) continue
-      const typedef = [...Visit(schema)].join(``)
-      if (recursive_set.has(reference.$id!)) {
-        reference_code.push(`${exports} const ${reference.$id} = z.lazy(() => ${typedef})`)
-      } else {
-        reference_code.push(`${exports} const ${reference.$id} = ${typedef}`)
-      }
-      emitted.add(reference.$id!)
-    }
-    return Formatter.Format([...imports_code, ...reference_code, ...type_code].join(`\n\n`))
-  }
-}
diff --git a/example/codegen/typescript-to-json-schema.ts b/example/codegen/typescript-to-json-schema.ts
deleted file mode 100644
index 3318fa63d..000000000
--- a/example/codegen/typescript-to-json-schema.ts
+++ /dev/null
@@ -1,360 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/codegen
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { Formatter } from './formatter'
-import * as ts from 'typescript'
-
-export namespace TypeScriptToJsonSchema {
-  function isReadonlyProperty(node: ts.PropertySignature): boolean {
-    return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'readonly') !== undefined
-  }
-  function isOptionalProperty(node: ts.PropertySignature) {
-    return node.questionToken !== undefined
-  }
-  function isExport(node: ts.InterfaceDeclaration | ts.TypeAliasDeclaration | ts.EnumDeclaration): boolean {
-    return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'export') !== undefined
-  }
-  function* SourceFile(node: ts.SourceFile): IterableIterator<string> {
-    for (const next of node.getChildren()) {
-      yield* Visit(next)
-    }
-  }
-  function* PropertySignature(node: ts.PropertySignature): IterableIterator<string> {
-    const [readonly, optional] = [isReadonlyProperty(node), isOptionalProperty(node)]
-    const type = Collect(node.type)
-    if (readonly && optional) {
-      return yield `${node.name.getText()}: ${type}`
-    } else if (readonly) {
-      return yield `${node.name.getText()}: ${type}`
-    } else if (optional) {
-      return yield `${node.name.getText()}: ${type}`
-    } else {
-      return yield `${node.name.getText()}: ${type}`
-    }
-  }
-  function* ArrayTypeNode(node: ts.ArrayTypeNode): IterableIterator<string> {
-    const type = Collect(node.elementType)
-    yield `{
-      type: 'array',
-      items: ${type}
-    }`
-  }
-  function* TupleTypeNode(node: ts.TupleTypeNode): IterableIterator<string> {
-    const types = node.elements.map((type) => Collect(type)).join(',\n')
-    yield `{
-      type: 'array',
-      items: [${types}],
-      minItems: ${node.elements.length},
-      maxItems: ${node.elements.length}
-    }`
-  }
-  function* UnionTypeNode(node: ts.UnionTypeNode): IterableIterator<string> {
-    const types = node.types.map((type) => Collect(type)).join(',\n')
-    yield `{
-      anyOf: [
-        ${types}
-      ]
-    }`
-  }
-  function* IntersectionTypeNode(node: ts.IntersectionTypeNode): IterableIterator<string> {
-    const types = node.types.map((type) => Collect(type)).join(',\n')
-    yield `{
-      allOf: [
-        ${types}
-      ]
-    }`
-  }
-  function* TypeOperatorNode(node: ts.TypeOperatorNode): IterableIterator<string> {
-    return yield UnknownType('TypeOperatorNode')
-  }
-  function* Parameter(node: ts.ParameterDeclaration): IterableIterator<string> {
-    yield Collect(node.type)
-  }
-  function* FunctionTypeNode(node: ts.FunctionTypeNode): IterableIterator<string> {
-    return yield UnknownType('FunctionTypeNode')
-  }
-  function* ConstructorTypeNode(node: ts.ConstructorTypeNode): IterableIterator<string> {
-    return yield UnknownType('ConstructorTypeNode')
-  }
-  function* EnumMember(node: ts.EnumMember): IterableIterator<string> {
-    if (node.initializer) {
-      return yield `{
-        const: ${node.initializer.getText()}
-      }`
-    }
-    return yield `{
-      const: '${node.name.getText()}'
-    }`
-  }
-  function* EnumDeclaration(node: ts.EnumDeclaration): IterableIterator<string> {
-    const exports = isExport(node) ? 'export ' : ''
-    const name = node.name.getText()
-    const members = node.members.map((member) => Collect(member)).join(',\n')
-    yield `${exports}const ${name} = {
-      anyOf: [
-        ${members}
-      ]
-    }`
-  }
-  function* InterfaceDeclaration(node: ts.InterfaceDeclaration): IterableIterator<string> {
-    if (node.typeParameters) {
-      const exports = isExport(node) ? 'export ' : ''
-      const members = node.members.map((member) => Collect(member)).join(',\n')
-      // prettier-ignore
-      const required = node.members.filter((member) => member.questionToken === undefined).map((member) => `'${member.name?.getText()}'`).join(',\n')
-      const constraints = node.typeParameters.map((param) => `${Collect(param)}`).join(', ')
-      const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(', ')
-      const definition = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ({
-        type: 'object',
-        properties: {
-          ${members}
-        },
-        required: [
-          ${required}
-        ],
-      })`
-      yield `${definition}`
-    } else {
-      const exports = isExport(node) ? 'export ' : ''
-      const members = node.members.map((member) => Collect(member)).join(',\n')
-      const required = node.members
-        .filter((member) => member.questionToken === undefined)
-        .map((member) => `'${member.name?.getText()}'`)
-        .join(',\n')
-      const definition = `${exports}const ${node.name.getText()} = {
-        type: 'object',
-        properties: {
-          ${members}
-        },
-        required: [
-          ${required}
-        ]
-      }`
-      yield `${definition}`
-    }
-  }
-  function* TypeAliasDeclaration(node: ts.TypeAliasDeclaration): IterableIterator<string> {
-    if (node.typeParameters) {
-      const exports = isExport(node) ? 'export ' : ''
-      const constraints = node.typeParameters.map((param) => `${Collect(param)}`).join(', ')
-      const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(', ')
-      const type = Collect(node.type)
-      const definition = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => (${type})`
-      yield `${definition}`
-    } else {
-      const exports = isExport(node) ? 'export ' : ''
-      const type = Collect(node.type)
-      const definition = `${exports}const ${node.name.getText()} = ${type}`
-      yield `${definition}`
-    }
-  }
-  function* TypeParameterDeclaration(node: ts.TypeParameterDeclaration): IterableIterator<string> {
-    yield node.name.getText()
-  }
-  function* ParenthesizedTypeNode(node: ts.ParenthesizedTypeNode): IterableIterator<string> {
-    yield Collect(node.type)
-  }
-  function* RestTypeNode(node: ts.RestTypeNode): IterableIterator<string> {
-    return yield UnknownType('RestTypeNode')
-  }
-  function* ConditionalTypeNode(node: ts.ConditionalTypeNode): IterableIterator<string> {
-    return yield UnknownType('ConditionalTypeNode')
-  }
-  function* TypeReferenceNode(node: ts.TypeReferenceNode): IterableIterator<string> {
-    const name = node.typeName.getText()
-    const args = node.typeArguments ? `(${node.typeArguments.map((type) => Collect(type)).join(', ')})` : ''
-    if (name === 'Array') {
-      return yield `{ type: 'array', items: ${args} }`
-    } else if (name === 'Record') {
-      return yield UnknownType('Record')
-    } else if (name === 'Partial') {
-      return yield UnknownType('Partial')
-    } else if (name === 'Uint8Array') {
-      return yield UnknownType('Uint8Array')
-    } else if (name === 'Required') {
-      return yield UnknownType('Required')
-    } else if (name === 'Omit') {
-      return yield UnknownType('Omit')
-    } else if (name === 'Pick') {
-      return yield UnknownType('Pick')
-    } else if (name === 'Promise') {
-      return yield UnknownType('Promise')
-    } else if (name === 'ReturnType') {
-      return yield UnknownType('ReturnType')
-    } else if (name === 'InstanceType') {
-      return yield UnknownType('InstanceType')
-    } else if (name === 'Parameters') {
-      return yield UnknownType('Parameters')
-    } else if (name === 'ConstructorParameters') {
-      return yield UnknownType('ConstructorParameters')
-    } else if (name === 'Exclude') {
-      return yield UnknownType('Exclude')
-    } else if (name === 'Extract') {
-      return yield UnknownType('Extract')
-    } else {
-      return yield `${name}${args}`
-    }
-  }
-  function* TypeLiteralNode(node: ts.TypeLiteralNode): IterableIterator<string> {
-    const members = node.members.map((member) => Collect(member)).join(',\n')
-    const required = node.members
-      .filter((member) => member.questionToken === undefined)
-      .map((member) => `'${member.name?.getText()}'`)
-      .join(',\n')
-    yield `{
-      type: 'object',
-      properties: {
-        ${members}
-      },
-      required: [
-        ${required}
-      ]
-    }`
-  }
-  function* LiteralTypeNode(node: ts.LiteralTypeNode): IterableIterator<string> {
-    const text = node.getText()
-    if (text === 'null')
-      return yield `{ 
-      type: 'null' 
-    }`
-    yield `{ 
-      const: ${node.getText()} 
-    }`
-  }
-  function* FunctionDeclaration(node: ts.FunctionDeclaration): IterableIterator<string> {
-    yield node.getText()
-  }
-  function* ClassDeclaration(node: ts.ClassDeclaration): IterableIterator<string> {
-    yield node.getText()
-  }
-  function Collect(node: ts.Node | undefined): string {
-    return `${[...Visit(node)].join('')}`
-  }
-  function CollectNewLine(node: ts.Node | undefined): string {
-    return [...Visit(node)].join('\n\n')
-  }
-  function UnknownType(name: string = 'Unknown'): string {
-    return `{ not: { /* unsupported type '${name}' */ } }`
-  }
-  function KnownType(type: string): string {
-    return ['{', `type: '${type}'`, '}'].join('\n')
-  }
-  function* Visit(node: ts.Node | undefined): IterableIterator<string> {
-    if (node === undefined) return
-    if (ts.isSourceFile(node)) {
-      return yield* SourceFile(node)
-    } else if (ts.isInterfaceDeclaration(node)) {
-      return yield* InterfaceDeclaration(node)
-    } else if (ts.isTypeAliasDeclaration(node)) {
-      return yield* TypeAliasDeclaration(node)
-    } else if (ts.isParameter(node)) {
-      return yield* Parameter(node)
-    } else if (ts.isFunctionTypeNode(node)) {
-      return yield* FunctionTypeNode(node)
-    } else if (ts.isConstructorTypeNode(node)) {
-      return yield* ConstructorTypeNode(node)
-    } else if (ts.isEnumMember(node)) {
-      return yield* EnumMember(node)
-    } else if (ts.isEnumDeclaration(node)) {
-      return yield* EnumDeclaration(node)
-    } else if (ts.isPropertySignature(node)) {
-      return yield* PropertySignature(node)
-    } else if (ts.isTypeReferenceNode(node)) {
-      return yield* TypeReferenceNode(node)
-    } else if (ts.isTypeLiteralNode(node)) {
-      return yield* TypeLiteralNode(node)
-    } else if (ts.isLiteralTypeNode(node)) {
-      return yield* LiteralTypeNode(node)
-    } else if (ts.isArrayTypeNode(node)) {
-      return yield* ArrayTypeNode(node)
-    } else if (ts.isTupleTypeNode(node)) {
-      return yield* TupleTypeNode(node)
-    } else if (ts.isIntersectionTypeNode(node)) {
-      return yield* IntersectionTypeNode(node)
-    } else if (ts.isUnionTypeNode(node)) {
-      return yield* UnionTypeNode(node)
-    } else if (ts.isTypeOperatorNode(node)) {
-      return yield* TypeOperatorNode(node)
-    } else if (ts.isTypeParameterDeclaration(node)) {
-      return yield* TypeParameterDeclaration(node)
-    } else if (ts.isParenthesizedTypeNode(node)) {
-      return yield* ParenthesizedTypeNode(node)
-    } else if (ts.isRestTypeNode(node)) {
-      return yield* RestTypeNode(node)
-    } else if (ts.isFunctionDeclaration(node)) {
-      return yield* FunctionDeclaration(node)
-    } else if (ts.isClassDeclaration(node)) {
-      return yield* ClassDeclaration(node)
-    } else if (ts.isConditionalTypeNode(node)) {
-      return yield* ConditionalTypeNode(node)
-    } else if (ts.isIdentifier(node)) {
-      return yield node.getText()
-    } else if (node.kind === ts.SyntaxKind.ExportKeyword) {
-      return yield `export`
-    } else if (node.kind === ts.SyntaxKind.KeyOfKeyword) {
-      return yield UnknownType()
-    } else if (node.kind === ts.SyntaxKind.NumberKeyword) {
-      return yield KnownType('number')
-    } else if (node.kind === ts.SyntaxKind.BigIntKeyword) {
-      return yield UnknownType()
-    } else if (node.kind === ts.SyntaxKind.StringKeyword) {
-      return yield KnownType('string')
-    } else if (node.kind === ts.SyntaxKind.BooleanKeyword) {
-      return yield KnownType('boolean')
-    } else if (node.kind === ts.SyntaxKind.UndefinedKeyword) {
-      return yield UnknownType('undefined')
-    } else if (node.kind === ts.SyntaxKind.UnknownKeyword) {
-      return yield `{ }`
-    } else if (node.kind === ts.SyntaxKind.AnyKeyword) {
-      return yield `{ }`
-    } else if (node.kind === ts.SyntaxKind.NeverKeyword) {
-      return yield `{ not: { } }`
-    } else if (node.kind === ts.SyntaxKind.NullKeyword) {
-      return yield KnownType('null')
-    } else if (node.kind === ts.SyntaxKind.VoidKeyword) {
-      return yield UnknownType('void')
-    } else if (node.kind === ts.SyntaxKind.EndOfFileToken) {
-      return
-    } else if (node.kind === ts.SyntaxKind.SyntaxList) {
-      for (const child of node.getChildren()) {
-        yield* Visit(child)
-      }
-      return
-    } else {
-      console.log('Unhandled:', ts.SyntaxKind[node.kind])
-      return yield node.getText()
-    }
-  }
-  /** Generates JsonSchema schematics from TypeScript interface and type definitions */
-  export function Generate(typescriptCode: string) {
-    const source = ts.createSourceFile('code.ts', typescriptCode, ts.ScriptTarget.ESNext, true)
-    const declarations = CollectNewLine(source)
-    const types = Formatter.Format(declarations)
-    return [types].join('\n')
-  }
-}
\ No newline at end of file
diff --git a/example/codegen/typescript-to-typebox.ts b/example/codegen/typescript-to-typebox.ts
deleted file mode 100644
index 7f69b2451..000000000
--- a/example/codegen/typescript-to-typebox.ts
+++ /dev/null
@@ -1,383 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/codegen
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { Formatter } from './formatter'
-import * as ts from 'typescript'
-
-// -------------------------------------------------------------------------
-// [TypeScriptToTypeBox]
-// -------------------------------------------------------------------------
-/** Generates TypeBox types from TypeScript code */
-export namespace TypeScriptToTypeBox {
-  // tracked for recursive types and used to associate This type references
-  let recursiveDeclaration: ts.TypeAliasDeclaration | ts.InterfaceDeclaration | null = null
-  // tracked for injecting typebox import statements
-  let useImports = false
-  // tracked for injecting TSchema import statements
-  let useGenerics = false
-  // tracked for each generated type.
-  const typeNames = new Set<string>()
-
-  function FindRecursiveParent(decl: ts.InterfaceDeclaration | ts.TypeAliasDeclaration, node: ts.Node): boolean {
-    return (ts.isTypeReferenceNode(node) && decl.name.getText() === node.typeName.getText()) || node.getChildren().some((node) => FindRecursiveParent(decl, node))
-  }
-  function IsRecursiveType(decl: ts.InterfaceDeclaration | ts.TypeAliasDeclaration) {
-    return ts.isTypeAliasDeclaration(decl) ? [decl.type].some((node) => FindRecursiveParent(decl, node)) : decl.members.some((node) => FindRecursiveParent(decl, node))
-  }
-  function IsReadonlyProperty(node: ts.PropertySignature): boolean {
-    return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'readonly') !== undefined
-  }
-  function IsOptionalProperty(node: ts.PropertySignature) {
-    return node.questionToken !== undefined
-  }
-  function IsExport(node: ts.InterfaceDeclaration | ts.TypeAliasDeclaration | ts.EnumDeclaration | ts.ModuleDeclaration): boolean {
-    return node.modifiers !== undefined && node.modifiers.find((modifier) => modifier.getText() === 'export') !== undefined
-  }
-  function IsNamespace(node: ts.ModuleDeclaration) {
-    return node.flags === ts.NodeFlags.Namespace
-  }
-  function* SourceFile(node: ts.SourceFile): IterableIterator<string> {
-    for (const next of node.getChildren()) {
-      yield* Visit(next)
-    }
-  }
-  function* PropertySignature(node: ts.PropertySignature): IterableIterator<string> {
-    const [readonly, optional] = [IsReadonlyProperty(node), IsOptionalProperty(node)]
-    const type = Collect(node.type)
-    if (readonly && optional) {
-      return yield `${node.name.getText()}: Type.ReadonlyOptional(${type})`
-    } else if (readonly) {
-      return yield `${node.name.getText()}: Type.Readonly(${type})`
-    } else if (optional) {
-      return yield `${node.name.getText()}: Type.Optional(${type})`
-    } else {
-      return yield `${node.name.getText()}: ${type}`
-    }
-  }
-  function* ArrayTypeNode(node: ts.ArrayTypeNode): IterableIterator<string> {
-    const type = Collect(node.elementType)
-    yield `Type.Array(${type})`
-  }
-  function* TupleTypeNode(node: ts.TupleTypeNode): IterableIterator<string> {
-    const types = node.elements.map((type) => Collect(type)).join(',\n')
-    yield `Type.Tuple([\n${types}\n])`
-  }
-  function* UnionTypeNode(node: ts.UnionTypeNode): IterableIterator<string> {
-    const types = node.types.map((type) => Collect(type)).join(',\n')
-    yield `Type.Union([\n${types}\n])`
-  }
-  // -------------------------------------------------------------------------
-  // TemplateLiteral
-  // -------------------------------------------------------------------------
-  // prettier-ignore
-  function* TemplateLiteralTypeNode(node: ts.TemplateLiteralTypeNode) {
-    const collect = node.getChildren().map(node => Collect(node)).join('')
-    yield `Type.TemplateLiteral([${collect.slice(0, collect.length - 2)}])` // can't remove trailing here
-  }
-  // prettier-ignore
-  function* TemplateLiteralTypeSpan(node: ts.TemplateLiteralTypeSpan) {
-    const collect = node.getChildren().map(node => Collect(node)).join(', ')
-    if(collect.length > 0) yield `${collect}`
-  }
-  function* TemplateHead(node: ts.TemplateHead) {
-    if (node.text.length > 0) yield `Type.Literal('${node.text}'), `
-  }
-  function* TemplateMiddle(node: ts.TemplateMiddle) {
-    if (node.text.length > 0) yield `Type.Literal('${node.text}'), `
-  }
-  function* TemplateTail(node: ts.TemplateTail) {
-    if (node.text.length > 0) yield `Type.Literal('${node.text}'), `
-  }
-  function* IntersectionTypeNode(node: ts.IntersectionTypeNode): IterableIterator<string> {
-    const types = node.types.map((type) => Collect(type)).join(',\n')
-    yield `Type.Intersect([\n${types}\n])`
-  }
-  function* TypeOperatorNode(node: ts.TypeOperatorNode): IterableIterator<string> {
-    if (node.operator === ts.SyntaxKind.KeyOfKeyword) {
-      const type = Collect(node.type)
-      yield `Type.KeyOf(${type})`
-    }
-    if (node.operator === ts.SyntaxKind.ReadonlyKeyword) {
-      yield Collect(node.type)
-    }
-  }
-  function* Parameter(node: ts.ParameterDeclaration): IterableIterator<string> {
-    yield Collect(node.type)
-  }
-  function* FunctionTypeNode(node: ts.FunctionTypeNode): IterableIterator<string> {
-    const parameters = node.parameters.map((param) => Collect(param)).join(', ')
-    const returns = Collect(node.type)
-    yield `Type.Function([${parameters}], ${returns})`
-  }
-  function* ConstructorTypeNode(node: ts.ConstructorTypeNode): IterableIterator<string> {
-    const parameters = node.parameters.map((param) => Collect(param)).join(', ')
-    const returns = Collect(node.type)
-    yield `Type.Constructor([${parameters}], ${returns})`
-  }
-  function* EnumDeclaration(node: ts.EnumDeclaration): IterableIterator<string> {
-    useImports = true
-    const exports = IsExport(node) ? 'export ' : ''
-    const members = node.members.map((member) => member.getText()).join(', ')
-    const enumType = `${exports}enum ${node.name.getText()}Enum { ${members} }`
-    const type = `${exports}const ${node.name.getText()} = Type.Enum(${node.name.getText()}Enum)`
-    yield [enumType, '', type].join('\n')
-    typeNames.add(node.name.getText())
-  }
-  // Collects members on behalf of InterfaceDeclaration and TypeLiteralNode. This function may yield an object
-  // with additionalProperties if we find an indexer in the members set.
-  function CollectObjectMembers(members: ts.NodeArray<ts.TypeElement>): string {
-    const properties = members.filter((member) => !ts.isIndexSignatureDeclaration(member))
-    const indexers = members.filter((member) => ts.isIndexSignatureDeclaration(member))
-    const propertyCollect = properties.map((property) => Collect(property)).join(',\n')
-    const indexer = indexers.length > 0 ? Collect(indexers[indexers.length - 1]) : ''
-    if (properties.length === 0 && indexer.length > 0) {
-      return `{},\n{\nadditionalProperties: ${indexer}\n }`
-    } else if (properties.length > 0 && indexer.length > 0) {
-      return `{\n${propertyCollect}\n},\n{\nadditionalProperties: ${indexer}\n }`
-    } else {
-      return `{\n${propertyCollect}\n}`
-    }
-  }
-  function* TypeLiteralNode(node: ts.TypeLiteralNode): IterableIterator<string> {
-    const members = CollectObjectMembers(node.members)
-    yield* `Type.Object(${members})`
-  }
-  function* InterfaceDeclaration(node: ts.InterfaceDeclaration): IterableIterator<string> {
-    useImports = true
-    const isRecursiveType = IsRecursiveType(node)
-    if (isRecursiveType) recursiveDeclaration = node
-    const heritage = node.heritageClauses !== undefined ? node.heritageClauses.flatMap((node) => Collect(node)) : []
-    if (node.typeParameters) {
-      useGenerics = true
-      const exports = IsExport(node) ? 'export ' : ''
-      const constraints = node.typeParameters.map((param) => `${Collect(param)} extends TSchema`).join(', ')
-      const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(', ')
-      const names = node.typeParameters.map((param) => `${Collect(param)}`).join(', ')
-      const members = CollectObjectMembers(node.members)
-      const staticDeclaration = `${exports}type ${node.name.getText()}<${constraints}> = Static<ReturnType<typeof ${node.name.getText()}<${names}>>>`
-      const rawTypeExpression = IsRecursiveType(node) ? `Type.Recursive(This => Type.Object(${members}))` : `Type.Object(${members})`
-      const typeExpression = heritage.length === 0 ? rawTypeExpression : `Type.Intersect([${heritage.join(', ')}, ${rawTypeExpression}])`
-      const typeDeclaration = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${typeExpression}`
-      yield `${staticDeclaration}\n${typeDeclaration}`
-    } else {
-      const exports = IsExport(node) ? 'export ' : ''
-      const members = CollectObjectMembers(node.members)
-      const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`
-      const rawTypeExpression = IsRecursiveType(node) ? `Type.Recursive(This => Type.Object(${members}))` : `Type.Object(${members})`
-      const typeExpression = heritage.length === 0 ? rawTypeExpression : `Type.Intersect([${heritage.join(', ')}, ${rawTypeExpression}])`
-      const typeDeclaration = `${exports}const ${node.name.getText()} = ${typeExpression}`
-      yield `${staticDeclaration}\n${typeDeclaration}`
-    }
-    typeNames.add(node.name.getText())
-    recursiveDeclaration = null
-  }
-  function* TypeAliasDeclaration(node: ts.TypeAliasDeclaration): IterableIterator<string> {
-    useImports = true
-    const isRecursiveType = IsRecursiveType(node)
-    if (isRecursiveType) recursiveDeclaration = node
-    if (node.typeParameters) {
-      useGenerics = true
-      const exports = IsExport(node) ? 'export ' : ''
-      const constraints = node.typeParameters.map((param) => `${Collect(param)} extends TSchema`).join(', ')
-      const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(', ')
-      const names = node.typeParameters.map((param) => Collect(param)).join(', ')
-      const type = Collect(node.type)
-      const staticDeclaration = `${exports}type ${node.name.getText()}<${constraints}> = Static<ReturnType<typeof ${node.name.getText()}<${names}>>>`
-      const typeDeclaration = isRecursiveType
-        ? `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => Type.Recursive(This => ${type})`
-        : `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${type}`
-      yield `${staticDeclaration}\n${typeDeclaration}`
-    } else {
-      const exports = IsExport(node) ? 'export ' : ''
-      const type = Collect(node.type)
-      const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`
-      const typeDeclaration = isRecursiveType ? `${exports}const ${node.name.getText()} = Type.Recursive(This => ${type})` : `${exports}const ${node.name.getText()} = ${type}`
-      yield `${staticDeclaration}\n${typeDeclaration}`
-    }
-    typeNames.add(node.name.getText())
-    recursiveDeclaration = null
-  }
-  function* HeritageClause(node: ts.HeritageClause): IterableIterator<string> {
-    const types = node.types.map((node) => Collect(node))
-    if (types.length === 1) return yield types[0]
-    yield `Type.Intersect([${types.join(', ')}])`
-  }
-  function* ExpressionWithTypeArguments(node: ts.ExpressionWithTypeArguments): IterableIterator<string> {
-    const name = Collect(node.expression)
-    const typeArguments = node.typeArguments === undefined ? [] : node.typeArguments.map((node) => Collect(node))
-    // todo: default type argument (resolve `= number` from `type Foo<T = number>`)
-    return yield typeArguments.length === 0 ? `${name}` : `${name}(${typeArguments.join(', ')})`
-  }
-  function* TypeParameterDeclaration(node: ts.TypeParameterDeclaration): IterableIterator<string> {
-    yield node.name.getText()
-  }
-  function* ParenthesizedTypeNode(node: ts.ParenthesizedTypeNode): IterableIterator<string> {
-    yield Collect(node.type)
-  }
-  function* RestTypeNode(node: ts.RestTypeNode): IterableIterator<string> {
-    yield `Type.Rest()`
-  }
-  function* ConditionalTypeNode(node: ts.ConditionalTypeNode): IterableIterator<string> {
-    const checkType = Collect(node.checkType)
-    const extendsType = Collect(node.extendsType)
-    const trueType = Collect(node.trueType)
-    const falseType = Collect(node.falseType)
-    yield `Type.Extends(${checkType}, ${extendsType}, ${trueType}, ${falseType})`
-  }
-  function* isIndexSignatureDeclaration(node: ts.IndexSignatureDeclaration) {
-    // note: we ignore the key and just return the type. this is a mismatch between
-    // object and record types. Address in TypeBox by unifying validation paths
-    // for objects and record types.
-    yield Collect(node.type)
-  }
-  function* TypeReferenceNode(node: ts.TypeReferenceNode): IterableIterator<string> {
-    const name = node.typeName.getText()
-    const args = node.typeArguments ? `(${node.typeArguments.map((type) => Collect(type)).join(', ')})` : ''
-    if (name === 'Array') return yield `Type.Array${args}`
-    if (name === 'Record') return yield `Type.Record${args}`
-    if (name === 'Partial') return yield `Type.Partial${args}`
-    if (name === 'Uint8Array') return yield `Type.Uint8Array()`
-    if (name === 'Date') return yield `Type.Date()`
-    if (name === 'Required') return yield `Type.Required${args}`
-    if (name === 'Omit') return yield `Type.Omit${args}`
-    if (name === 'Pick') return yield `Type.Pick${args}`
-    if (name === 'Promise') return yield `Type.Promise${args}`
-    if (name === 'ReturnType') return yield `Type.ReturnType${args}`
-    if (name === 'InstanceType') return yield `Type.InstanceType${args}`
-    if (name === 'Parameters') return yield `Type.Parameters${args}`
-    if (name === 'ConstructorParameters') return yield `Type.ConstructorParameters${args}`
-    if (name === 'Exclude') return yield `Type.Exclude${args}`
-    if (name === 'Extract') return yield `Type.Extract${args}`
-    if (recursiveDeclaration !== null && FindRecursiveParent(recursiveDeclaration, node)) return yield `This`
-    if (typeNames.has(name)) return yield `${name}${args}`
-    if (name in globalThis) return yield `Type.Never(/* Unsupported Type '${name}' */)`
-    return yield `${name}${args}`
-  }
-  function* LiteralTypeNode(node: ts.LiteralTypeNode): IterableIterator<string> {
-    const text = node.getText()
-    if (text === 'null') return yield `Type.Null()`
-    yield `Type.Literal(${node.getText()})`
-  }
-  function* ModuleDeclaration(node: ts.ModuleDeclaration): IterableIterator<string> {
-    const export_specifier = IsExport(node) ? 'export ' : ''
-    const module_specifier = IsNamespace(node) ? 'namespace' : 'module'
-    yield `${export_specifier}${module_specifier} ${node.name.getText()} {`
-    yield* Visit(node.body)
-    yield `}`
-  }
-  function* ModuleBlock(node: ts.ModuleBlock): IterableIterator<string> {
-    for (const statement of node.statements) {
-      yield* Visit(statement)
-    }
-  }
-  function* FunctionDeclaration(node: ts.FunctionDeclaration): IterableIterator<string> {
-    yield node.getText()
-  }
-  function* ClassDeclaration(node: ts.ClassDeclaration): IterableIterator<string> {
-    yield node.getText()
-  }
-  function Collect(node: ts.Node | undefined): string {
-    return `${[...Visit(node)].join('')}`
-  }
-  function CollectNewLine(node: ts.Node | undefined): string {
-    return [...Visit(node)].join('\n\n')
-  }
-  function* Visit(node: ts.Node | undefined): IterableIterator<string> {
-    if (node === undefined) return
-    if (ts.isSourceFile(node)) return yield* SourceFile(node)
-    if (ts.isInterfaceDeclaration(node)) return yield* InterfaceDeclaration(node)
-    if (ts.isTypeAliasDeclaration(node)) return yield* TypeAliasDeclaration(node)
-    if (ts.isParameter(node)) return yield* Parameter(node)
-    if (ts.isFunctionTypeNode(node)) return yield* FunctionTypeNode(node)
-    if (ts.isConstructorTypeNode(node)) return yield* ConstructorTypeNode(node)
-    if (ts.isEnumDeclaration(node)) return yield* EnumDeclaration(node)
-    if (ts.isPropertySignature(node)) return yield* PropertySignature(node)
-    if (ts.isTypeReferenceNode(node)) return yield* TypeReferenceNode(node)
-    if (ts.isTypeLiteralNode(node)) return yield* TypeLiteralNode(node)
-    if (ts.isLiteralTypeNode(node)) return yield* LiteralTypeNode(node)
-    if (ts.isModuleDeclaration(node)) return yield* ModuleDeclaration(node)
-    if (ts.isModuleBlock(node)) return yield* ModuleBlock(node)
-    if (ts.isArrayTypeNode(node)) return yield* ArrayTypeNode(node)
-    if (ts.isTupleTypeNode(node)) return yield* TupleTypeNode(node)
-    if (ts.isIntersectionTypeNode(node)) return yield* IntersectionTypeNode(node)
-    if (ts.isUnionTypeNode(node)) return yield* UnionTypeNode(node)
-    if (ts.isTemplateLiteralTypeNode(node)) return yield* TemplateLiteralTypeNode(node)
-    if (ts.isTemplateLiteralTypeSpan(node)) return yield* TemplateLiteralTypeSpan(node)
-    if (ts.isTemplateHead(node)) return yield* TemplateHead(node)
-    if (ts.isTemplateMiddle(node)) return yield* TemplateMiddle(node)
-    if (ts.isTemplateTail(node)) return yield* TemplateTail(node)
-    if (ts.isTypeOperatorNode(node)) return yield* TypeOperatorNode(node)
-    if (ts.isHeritageClause(node)) return yield* HeritageClause(node)
-    if (ts.isExpressionWithTypeArguments(node)) return yield* ExpressionWithTypeArguments(node)
-    if (ts.isTypeParameterDeclaration(node)) return yield* TypeParameterDeclaration(node)
-    if (ts.isParenthesizedTypeNode(node)) return yield* ParenthesizedTypeNode(node)
-    if (ts.isRestTypeNode(node)) return yield* RestTypeNode(node)
-    if (ts.isFunctionDeclaration(node)) return yield* FunctionDeclaration(node)
-    if (ts.isClassDeclaration(node)) return yield* ClassDeclaration(node)
-    if (ts.isConditionalTypeNode(node)) return yield* ConditionalTypeNode(node)
-    if (ts.isIndexSignatureDeclaration(node)) return yield* isIndexSignatureDeclaration(node)
-    if (ts.isIdentifier(node)) return yield node.getText()
-    if (node.kind === ts.SyntaxKind.ExportKeyword) return yield `export`
-    if (node.kind === ts.SyntaxKind.KeyOfKeyword) return yield `Type.KeyOf()`
-    if (node.kind === ts.SyntaxKind.NumberKeyword) return yield `Type.Number()`
-    if (node.kind === ts.SyntaxKind.BigIntKeyword) return yield `Type.BigInt()`
-    if (node.kind === ts.SyntaxKind.StringKeyword) return yield `Type.String()`
-    if (node.kind === ts.SyntaxKind.BooleanKeyword) return yield `Type.Boolean()`
-    if (node.kind === ts.SyntaxKind.UndefinedKeyword) return yield `Type.Undefined()`
-    if (node.kind === ts.SyntaxKind.UnknownKeyword) return yield `Type.Unknown()`
-    if (node.kind === ts.SyntaxKind.AnyKeyword) return yield `Type.Any()`
-    if (node.kind === ts.SyntaxKind.NeverKeyword) return yield `Type.Never()`
-    if (node.kind === ts.SyntaxKind.NullKeyword) return yield `Type.Null()`
-    if (node.kind === ts.SyntaxKind.VoidKeyword) return yield `Type.Void()`
-    if (node.kind === ts.SyntaxKind.EndOfFileToken) return
-    if (node.kind === ts.SyntaxKind.SyntaxList) {
-      for (const child of node.getChildren()) {
-        yield* Visit(child)
-      }
-      return
-    }
-    console.log('Unhandled:', ts.SyntaxKind[node.kind])
-    return yield node.getText()
-  }
-  /** Generates TypeBox types from TypeScript interface and type definitions */
-  export function Generate(typescriptCode: string) {
-    typeNames.clear()
-    useImports = false
-    useGenerics = false
-    const source = ts.createSourceFile('code.ts', typescriptCode, ts.ScriptTarget.ESNext, true)
-    const typeDeclarations = CollectNewLine(source)
-    const importStatments: string[] = []
-    if (useImports) {
-      if (useGenerics) importStatments.push(`import { Type, Static, TSchema } from '@sinclair/typebox'`)
-      if (!useGenerics) importStatments.push(`import { Type, Static } from '@sinclair/typebox'`)
-    }
-    const imports = importStatments.join('\n')
-    const types = Formatter.Format(typeDeclarations)
-    return [imports, '', types].join('\n')
-  }
-}
diff --git a/package.json b/package.json
index cbdd26dc4..2b017e2bf 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.29.1",
+  "version": "0.29.2",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index a39085005..7f5d64338 100644
--- a/readme.md
+++ b/readme.md
@@ -1496,35 +1496,35 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │    1000    │ '    220 ms' │ '      6 ms' │ '   36.67 x' │
-│ Literal_Number             │    1000    │ '    172 ms' │ '      4 ms' │ '   43.00 x' │
-│ Literal_Boolean            │    1000    │ '    162 ms' │ '      4 ms' │ '   40.50 x' │
+│ Literal_String             │    1000    │ '    227 ms' │ '      7 ms' │ '   32.43 x' │
+│ Literal_Number             │    1000    │ '    180 ms' │ '      6 ms' │ '   30.00 x' │
+│ Literal_Boolean            │    1000    │ '    152 ms' │ '      5 ms' │ '   30.40 x' │
 │ Primitive_Number           │    1000    │ '    161 ms' │ '      6 ms' │ '   26.83 x' │
-│ Primitive_String           │    1000    │ '    154 ms' │ '      4 ms' │ '   38.50 x' │
-│ Primitive_String_Pattern   │    1000    │ '    204 ms' │ '     10 ms' │ '   20.40 x' │
-│ Primitive_Boolean          │    1000    │ '    131 ms' │ '      4 ms' │ '   32.75 x' │
-│ Primitive_Null             │    1000    │ '    142 ms' │ '      5 ms' │ '   28.40 x' │
-│ Object_Unconstrained       │    1000    │ '   1263 ms' │ '     29 ms' │ '   43.55 x' │
-│ Object_Constrained         │    1000    │ '   1267 ms' │ '     24 ms' │ '   52.79 x' │
-│ Object_Vector3             │    1000    │ '    382 ms' │ '      7 ms' │ '   54.57 x' │
-│ Object_Box3D               │    1000    │ '   1723 ms' │ '     28 ms' │ '   61.54 x' │
-│ Tuple_Primitive            │    1000    │ '    495 ms' │ '     13 ms' │ '   38.08 x' │
-│ Tuple_Object               │    1000    │ '   1271 ms' │ '     16 ms' │ '   79.44 x' │
-│ Composite_Intersect        │    1000    │ '    656 ms' │ '     19 ms' │ '   34.53 x' │
-│ Composite_Union            │    1000    │ '    529 ms' │ '     18 ms' │ '   29.39 x' │
-│ Math_Vector4               │    1000    │ '    802 ms' │ '     14 ms' │ '   57.29 x' │
-│ Math_Matrix4               │    1000    │ '    411 ms' │ '      6 ms' │ '   68.50 x' │
-│ Array_Primitive_Number     │    1000    │ '    369 ms' │ '      6 ms' │ '   61.50 x' │
-│ Array_Primitive_String     │    1000    │ '    369 ms' │ '      4 ms' │ '   92.25 x' │
-│ Array_Primitive_Boolean    │    1000    │ '    297 ms' │ '      3 ms' │ '   99.00 x' │
-│ Array_Object_Unconstrained │    1000    │ '   1582 ms' │ '     20 ms' │ '   79.10 x' │
-│ Array_Object_Constrained   │    1000    │ '   1629 ms' │ '     19 ms' │ '   85.74 x' │
-│ Array_Tuple_Primitive      │    1000    │ '    652 ms' │ '     12 ms' │ '   54.33 x' │
-│ Array_Tuple_Object         │    1000    │ '   1587 ms' │ '     16 ms' │ '   99.19 x' │
-│ Array_Composite_Intersect  │    1000    │ '   1051 ms' │ '     15 ms' │ '   70.07 x' │
-│ Array_Composite_Union      │    1000    │ '    733 ms' │ '     15 ms' │ '   48.87 x' │
-│ Array_Math_Vector4         │    1000    │ '   1071 ms' │ '     12 ms' │ '   89.25 x' │
-│ Array_Math_Matrix4         │    1000    │ '    636 ms' │ '      5 ms' │ '  127.20 x' │
+│ Primitive_String           │    1000    │ '    150 ms' │ '      8 ms' │ '   18.75 x' │
+│ Primitive_String_Pattern   │    1000    │ '    202 ms' │ '      9 ms' │ '   22.44 x' │
+│ Primitive_Boolean          │    1000    │ '    133 ms' │ '      3 ms' │ '   44.33 x' │
+│ Primitive_Null             │    1000    │ '    147 ms' │ '      3 ms' │ '   49.00 x' │
+│ Object_Unconstrained       │    1000    │ '   1145 ms' │ '     31 ms' │ '   36.94 x' │
+│ Object_Constrained         │    1000    │ '   1241 ms' │ '     26 ms' │ '   47.73 x' │
+│ Object_Vector3             │    1000    │ '    407 ms' │ '      7 ms' │ '   58.14 x' │
+│ Object_Box3D               │    1000    │ '   1781 ms' │ '     27 ms' │ '   65.96 x' │
+│ Tuple_Primitive            │    1000    │ '    489 ms' │ '     13 ms' │ '   37.62 x' │
+│ Tuple_Object               │    1000    │ '   1278 ms' │ '     34 ms' │ '   37.59 x' │
+│ Composite_Intersect        │    1000    │ '    613 ms' │ '     16 ms' │ '   38.31 x' │
+│ Composite_Union            │    1000    │ '    543 ms' │ '     18 ms' │ '   30.17 x' │
+│ Math_Vector4               │    1000    │ '    819 ms' │ '     13 ms' │ '   63.00 x' │
+│ Math_Matrix4               │    1000    │ '    407 ms' │ '      7 ms' │ '   58.14 x' │
+│ Array_Primitive_Number     │    1000    │ '    372 ms' │ '      6 ms' │ '   62.00 x' │
+│ Array_Primitive_String     │    1000    │ '    329 ms' │ '      6 ms' │ '   54.83 x' │
+│ Array_Primitive_Boolean    │    1000    │ '    313 ms' │ '      3 ms' │ '  104.33 x' │
+│ Array_Object_Unconstrained │    1000    │ '   1780 ms' │ '     20 ms' │ '   89.00 x' │
+│ Array_Object_Constrained   │    1000    │ '   1494 ms' │ '     21 ms' │ '   71.14 x' │
+│ Array_Tuple_Primitive      │    1000    │ '    917 ms' │ '     10 ms' │ '   91.70 x' │
+│ Array_Tuple_Object         │    1000    │ '   1666 ms' │ '     13 ms' │ '  128.15 x' │
+│ Array_Composite_Intersect  │    1000    │ '    791 ms' │ '     18 ms' │ '   43.94 x' │
+│ Array_Composite_Union      │    1000    │ '    833 ms' │ '     17 ms' │ '   49.00 x' │
+│ Array_Math_Vector4         │    1000    │ '   1161 ms' │ '     15 ms' │ '   77.40 x' │
+│ Array_Math_Matrix4         │    1000    │ '    697 ms' │ '     10 ms' │ '   69.70 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1538,37 +1538,37 @@ This benchmark measures validation performance for varying types. You can review
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │  1000000   │ '     24 ms' │ '      5 ms' │ '      5 ms' │ '    1.00 x' │
-│ Literal_Number             │  1000000   │ '     21 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Literal_String             │  1000000   │ '     25 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
+│ Literal_Number             │  1000000   │ '     19 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
 │ Literal_Boolean            │  1000000   │ '     18 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
-│ Primitive_Number           │  1000000   │ '     25 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
-│ Primitive_String           │  1000000   │ '     25 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Primitive_String_Pattern   │  1000000   │ '    174 ms' │ '     44 ms' │ '     36 ms' │ '    1.22 x' │
-│ Primitive_Boolean          │  1000000   │ '     22 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Primitive_Null             │  1000000   │ '     22 ms' │ '     16 ms' │ '      9 ms' │ '    1.78 x' │
-│ Object_Unconstrained       │  1000000   │ '   1065 ms' │ '     33 ms' │ '     25 ms' │ '    1.32 x' │
-│ Object_Constrained         │  1000000   │ '   1192 ms' │ '     53 ms' │ '     38 ms' │ '    1.39 x' │
-│ Object_Vector3             │  1000000   │ '    410 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
-│ Object_Box3D               │  1000000   │ '   1939 ms' │ '     54 ms' │ '     50 ms' │ '    1.08 x' │
-│ Object_Recursive           │  1000000   │ '   5248 ms' │ '    355 ms' │ '    149 ms' │ '    2.38 x' │
-│ Tuple_Primitive            │  1000000   │ '    163 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
-│ Tuple_Object               │  1000000   │ '    737 ms' │ '     29 ms' │ '     20 ms' │ '    1.45 x' │
-│ Composite_Intersect        │  1000000   │ '    761 ms' │ '     24 ms' │ '     15 ms' │ '    1.60 x' │
-│ Composite_Union            │  1000000   │ '    519 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
-│ Math_Vector4               │  1000000   │ '    247 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
-│ Math_Matrix4               │  1000000   │ '   1045 ms' │ '     39 ms' │ '     27 ms' │ '    1.44 x' │
-│ Array_Primitive_Number     │  1000000   │ '    256 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
-│ Array_Primitive_String     │  1000000   │ '    222 ms' │ '     21 ms' │ '     14 ms' │ '    1.50 x' │
-│ Array_Primitive_Boolean    │  1000000   │ '    149 ms' │ '     22 ms' │ '     16 ms' │ '    1.38 x' │
-│ Array_Object_Unconstrained │  1000000   │ '   5473 ms' │ '     67 ms' │ '     59 ms' │ '    1.14 x' │
-│ Array_Object_Constrained   │  1000000   │ '   5548 ms' │ '    130 ms' │ '    116 ms' │ '    1.12 x' │
-│ Array_Object_Recursive     │  1000000   │ '  21047 ms' │ '   1710 ms' │ '    584 ms' │ '    2.93 x' │
-│ Array_Tuple_Primitive      │  1000000   │ '    691 ms' │ '     35 ms' │ '     29 ms' │ '    1.21 x' │
-│ Array_Tuple_Object         │  1000000   │ '   3075 ms' │ '     63 ms' │ '     50 ms' │ '    1.26 x' │
-│ Array_Composite_Intersect  │  1000000   │ '   3126 ms' │ '     44 ms' │ '     35 ms' │ '    1.26 x' │
-│ Array_Composite_Union      │  1000000   │ '   2086 ms' │ '     68 ms' │ '     33 ms' │ '    2.06 x' │
-│ Array_Math_Vector4         │  1000000   │ '   1069 ms' │ '     38 ms' │ '     23 ms' │ '    1.65 x' │
-│ Array_Math_Matrix4         │  1000000   │ '   4559 ms' │ '    111 ms' │ '     88 ms' │ '    1.26 x' │
+│ Primitive_Number           │  1000000   │ '     26 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
+│ Primitive_String           │  1000000   │ '     25 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│ Primitive_String_Pattern   │  1000000   │ '    160 ms' │ '     42 ms' │ '     36 ms' │ '    1.17 x' │
+│ Primitive_Boolean          │  1000000   │ '     24 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
+│ Primitive_Null             │  1000000   │ '     24 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
+│ Object_Unconstrained       │  1000000   │ '   1111 ms' │ '     34 ms' │ '     24 ms' │ '    1.42 x' │
+│ Object_Constrained         │  1000000   │ '   1262 ms' │ '     51 ms' │ '     37 ms' │ '    1.38 x' │
+│ Object_Vector3             │  1000000   │ '    445 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
+│ Object_Box3D               │  1000000   │ '   2029 ms' │ '     66 ms' │ '     48 ms' │ '    1.38 x' │
+│ Object_Recursive           │  1000000   │ '   5121 ms' │ '    464 ms' │ '    156 ms' │ '    2.97 x' │
+│ Tuple_Primitive            │  1000000   │ '    158 ms' │ '     22 ms' │ '     12 ms' │ '    1.83 x' │
+│ Tuple_Object               │  1000000   │ '    761 ms' │ '     30 ms' │ '     18 ms' │ '    1.67 x' │
+│ Composite_Intersect        │  1000000   │ '    828 ms' │ '     24 ms' │ '     13 ms' │ '    1.85 x' │
+│ Composite_Union            │  1000000   │ '    529 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
+│ Math_Vector4               │  1000000   │ '    252 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
+│ Math_Matrix4               │  1000000   │ '   1024 ms' │ '     38 ms' │ '     27 ms' │ '    1.41 x' │
+│ Array_Primitive_Number     │  1000000   │ '    264 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
+│ Array_Primitive_String     │  1000000   │ '    240 ms' │ '     20 ms' │ '     13 ms' │ '    1.54 x' │
+│ Array_Primitive_Boolean    │  1000000   │ '    137 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
+│ Array_Object_Unconstrained │  1000000   │ '   6050 ms' │ '     66 ms' │ '     55 ms' │ '    1.20 x' │
+│ Array_Object_Constrained   │  1000000   │ '   5954 ms' │ '    124 ms' │ '    116 ms' │ '    1.07 x' │
+│ Array_Object_Recursive     │  1000000   │ '  21074 ms' │ '   1611 ms' │ '    626 ms' │ '    2.57 x' │
+│ Array_Tuple_Primitive      │  1000000   │ '    683 ms' │ '     37 ms' │ '     30 ms' │ '    1.23 x' │
+│ Array_Tuple_Object         │  1000000   │ '   3366 ms' │ '     69 ms' │ '     54 ms' │ '    1.28 x' │
+│ Array_Composite_Intersect  │  1000000   │ '   3285 ms' │ '     45 ms' │ '     36 ms' │ '    1.25 x' │
+│ Array_Composite_Union      │  1000000   │ '   2229 ms' │ '     69 ms' │ '     34 ms' │ '    2.03 x' │
+│ Array_Math_Vector4         │  1000000   │ '   1192 ms' │ '     38 ms' │ '     25 ms' │ '    1.52 x' │
+│ Array_Math_Matrix4         │  1000000   │ '   4916 ms' │ '    111 ms' │ '     88 ms' │ '    1.26 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1582,11 +1582,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '128.0 kb' │ ' 57.0 kb' │  '2.25 x'   │
-│ typebox/errors       │ '111.6 kb' │ ' 49.1 kb' │  '2.27 x'   │
-│ typebox/system       │ ' 77.0 kb' │ ' 31.5 kb' │  '2.45 x'   │
-│ typebox/value        │ '177.7 kb' │ ' 76.8 kb' │  '2.31 x'   │
-│ typebox              │ ' 75.9 kb' │ ' 31.0 kb' │  '2.45 x'   │
+│ typebox/compiler     │ '130.3 kb' │ ' 58.2 kb' │  '2.24 x'   │
+│ typebox/errors       │ '113.3 kb' │ ' 49.8 kb' │  '2.27 x'   │
+│ typebox/system       │ ' 78.8 kb' │ ' 32.2 kb' │  '2.45 x'   │
+│ typebox/value        │ '180.0 kb' │ ' 77.7 kb' │  '2.32 x'   │
+│ typebox              │ ' 77.7 kb' │ ' 31.7 kb' │  '2.45 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/typebox.ts b/src/typebox.ts
index b9acbdf05..5d8c046d0 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -62,11 +62,6 @@ export type AssertProperties<T> = T extends TProperties ? T : TProperties
 export type AssertRest<T, E extends TSchema[] = TSchema[]> = T extends E ? T : []
 export type AssertType<T, E extends TSchema = TSchema> = T extends E ? T : TNever
 // --------------------------------------------------------------------------
-// Type Normalization
-// --------------------------------------------------------------------------
-export type IntersectType<T extends TSchema[]> = T extends [] ? TNever : T extends [TSchema] ? AssertType<T[0]> : TIntersect<T>
-export type UnionType<T extends TSchema[]> = T extends [] ? TNever : T extends [TSchema] ? AssertType<T[0]> : TUnion<T>
-// --------------------------------------------------------------------------
 // Modifiers
 // --------------------------------------------------------------------------
 export type TModifier = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>
@@ -74,6 +69,56 @@ export type TReadonly<T extends TSchema> = T & { [Modifier]: 'Readonly' }
 export type TOptional<T extends TSchema> = T & { [Modifier]: 'Optional' }
 export type TReadonlyOptional<T extends TSchema> = T & { [Modifier]: 'ReadonlyOptional' }
 // --------------------------------------------------------------------------
+// Optional Unwrap
+// --------------------------------------------------------------------------
+// prettier-ignore
+export type OptionalUnwrapType<T extends TSchema> =
+  T extends (TOptional<infer S> | TReadonlyOptional<infer S>)
+    ? OptionalUnwrapType<S>
+    : T
+// prettier-ignore
+export type OptionalUnwrapRest<T extends TSchema[]> = T extends [infer L, ...infer R]
+  ? L extends (TOptional<infer S> | TReadonlyOptional<infer S>)
+    ? [OptionalUnwrapType<AssertType<S>>, ...OptionalUnwrapRest<AssertRest<R>>] 
+    : [L, ...OptionalUnwrapRest<AssertRest<R>>]
+  :  []
+// --------------------------------------------------------------------------
+// IntersectType
+// --------------------------------------------------------------------------
+// prettier-ignore
+export type IntersectOptional<T extends TSchema[]> = T extends [infer L, ...infer R] 
+  ? L extends TOptional<AssertType<L>> | TReadonlyOptional<AssertType<L>> 
+    ? IntersectOptional<AssertRest<R>> 
+    : false
+  : true
+// prettier-ignore
+export type IntersectResolve<T extends TSchema[], U = OptionalUnwrapRest<AssertRest<T>>> = IntersectOptional<AssertRest<T>> extends true
+  ? TOptional<TIntersect<AssertRest<U>>>
+  : TIntersect<AssertRest<U>>
+// prettier-ignore
+export type IntersectType<T extends TSchema[]> = 
+    T extends [] ? TNever : 
+    T extends [TSchema] ? AssertType<T[0]> : 
+    IntersectResolve<T>
+// --------------------------------------------------------------------------
+// UnionType
+// --------------------------------------------------------------------------
+// prettier-ignore
+export type UnionOptional<T extends TSchema[]> = T extends [infer L, ...infer R]
+  ? L extends (TOptional<AssertType<L>> | TReadonlyOptional<AssertType<L>>)
+    ? true 
+    : UnionOptional<AssertRest<R>> 
+  : false
+// prettier-ignore
+export type UnionResolve<T extends TSchema[], U = OptionalUnwrapRest<AssertRest<T>>> = UnionOptional<AssertRest<T>> extends true
+  ? TOptional<TUnion<AssertRest<U>>>
+  : TUnion<AssertRest<U>>
+// prettier-ignore
+export type UnionType<T extends TSchema[]> = 
+  T extends [] ? TNever : 
+  T extends [TSchema] ? AssertType<T[0]> : 
+  UnionResolve<T>
+// --------------------------------------------------------------------------
 // Key
 // --------------------------------------------------------------------------
 export type Key = string | number
@@ -297,6 +342,7 @@ export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends T
 // --------------------------------------------------------------------------
 // TIndex
 // --------------------------------------------------------------------------
+
 export type TIndexRest<T extends TSchema[], K extends Key> = T extends [infer L, ...infer R] ? [TIndexType<AssertType<L>, K>, ...TIndexRest<AssertRest<R>, K>] : []
 export type TIndexProperty<T extends TProperties, K extends Key> = K extends keyof T ? [T[K]] : []
 export type TIndexTuple<T extends TSchema[], K extends Key> = K extends keyof T ? [T[K]] : []
@@ -308,6 +354,7 @@ export type TIndexType<T extends TSchema, K extends Key> =
   T extends TObject<infer S>    ? UnionType<AssertRest<Flat<TIndexProperty<S, K>>>> :
   T extends TTuple<infer S>     ? UnionType<AssertRest<Flat<TIndexTuple<S, K>>>> :
   []
+
 // prettier-ignore
 export type TIndexRestMany<T extends TSchema, K extends Key[]> = 
  K extends [infer L, ...infer R] ? [TIndexType<T, Assert<L, Key>>, ...TIndexRestMany<T, Assert<R, Key[]>>] :
@@ -320,6 +367,7 @@ export type TIndex<T extends TSchema, K extends Key[]> =
   T extends TObject    ? UnionType<Flat<TIndexRestMany<T, K>>> :
   T extends TTuple     ? UnionType<Flat<TIndexRestMany<T, K>>> :
   TNever
+
 // --------------------------------------------------------------------------
 // TInteger
 // --------------------------------------------------------------------------
@@ -1947,16 +1995,41 @@ export namespace TypeClone {
 // IndexedAccessor
 // --------------------------------------------------------------------------
 export namespace IndexedAccessor {
+  function OptionalUnwrap(schema: TSchema[]): TSchema[] {
+    return schema.map((schema) => {
+      const { [Modifier]: _, ...clone } = TypeClone.Clone(schema, {})
+      return clone
+    })
+  }
+  function IsIntersectOptional(schema: TSchema[]): boolean {
+    return schema.every((schema) => TypeGuard.TOptional(schema))
+  }
+  function IsUnionOptional(schema: TSchema[]): boolean {
+    return schema.some((schema) => TypeGuard.TOptional(schema))
+  }
+  function ResolveIntersect(schema: TIntersect): TSchema {
+    const optional = IsIntersectOptional(schema.allOf)
+    return optional ? Type.Optional(Type.Intersect(OptionalUnwrap(schema.allOf))) : schema
+  }
+  function ResolveUnion(schema: TUnion): TSchema {
+    const optional = IsUnionOptional(schema.anyOf)
+    return optional ? Type.Optional(Type.Union(OptionalUnwrap(schema.anyOf))) : schema
+  }
+  function ResolveOptional(schema: TSchema) {
+    if (schema[Kind] === 'Intersect') return ResolveIntersect(schema as TIntersect)
+    if (schema[Kind] === 'Union') return ResolveUnion(schema as TUnion)
+    return schema
+  }
   function Intersect(schema: TIntersect, key: string): TSchema {
-    const schemas = schema.allOf.reduce((acc, schema) => {
+    const resolved = schema.allOf.reduce((acc, schema) => {
       const indexed = Visit(schema, key)
       return indexed[Kind] === 'Never' ? acc : [...acc, indexed]
     }, [] as TSchema[])
-    return Type.Intersect(schemas)
+    return ResolveOptional(Type.Intersect(resolved))
   }
   function Union(schema: TUnion, key: string): TSchema {
-    const schemas = schema.anyOf.map((schema) => Visit(schema, key))
-    return Type.Union(schemas)
+    const resolved = schema.anyOf.map((schema) => Visit(schema, key))
+    return ResolveOptional(Type.Union(resolved))
   }
   function Object(schema: TObject, key: string): TSchema {
     const property = schema.properties[key]
@@ -1977,8 +2050,8 @@ export namespace IndexedAccessor {
     return Type.Never()
   }
   export function Resolve(schema: TSchema, keys: Key[], options: SchemaOptions = {}): TSchema {
-    // prettier-ignore
-    return Type.Union(keys.map((key) => Visit(schema, key.toString())), options)
+    const resolved = keys.map((key) => Visit(schema, key.toString()))
+    return ResolveOptional(Type.Union(resolved, options))
   }
 }
 // --------------------------------------------------------------------------
diff --git a/test/runtime/type/guard/composite.ts b/test/runtime/type/guard/composite.ts
index 86ced5e53..f473d31fd 100644
--- a/test/runtime/type/guard/composite.ts
+++ b/test/runtime/type/guard/composite.ts
@@ -27,8 +27,30 @@ describe('type/guard/TComposite', () => {
   // rule is "if all composite properties for a key are optional, then the composite property is optional". Defer this test and
   // document as minor breaking change.
   //
-  // it('Should produce optional property if all properties are optional', () => {
-  //   const T = Type.Composite([Type.Object({ x: Type.Optional(Type.Number()) }), Type.Object({ x: Type.Optional(Type.Number()) })])
-  //   Assert.isEqual(TypeGuard.TOptional(T.properties.x), true)
-  // })
+  it('Should produce optional property if all composited properties are optional', () => {
+    // prettier-ignore
+    const T = Type.Composite([
+      Type.Object({ x: Type.Optional(Type.Number()) }), 
+      Type.Object({ x: Type.Optional(Type.Number()) })
+    ])
+    Assert.isEqual(TypeGuard.TOptional(T.properties.x), true)
+    Assert.isTrue(T.required === undefined)
+  })
+  it('Should produce required property if some composited properties are not optional', () => {
+    // prettier-ignore
+    const T = Type.Composite([
+      Type.Object({ x: Type.Optional(Type.Number()) }), 
+      Type.Object({ x: Type.Number() })
+    ])
+    Assert.isEqual(TypeGuard.TOptional(T.properties.x), false)
+    Assert.isTrue(T.required!.includes('x'))
+  })
+  it('Should preserve single optional property', () => {
+    // prettier-ignore
+    const T = Type.Composite([
+      Type.Object({ x: Type.Optional(Type.Number()) }), 
+    ])
+    Assert.isEqual(TypeGuard.TOptional(T.properties.x), true)
+    Assert.isTrue(T.required === undefined)
+  })
 })
diff --git a/test/runtime/type/guard/indexed.ts b/test/runtime/type/guard/indexed.ts
index 822267285..4003880c3 100644
--- a/test/runtime/type/guard/indexed.ts
+++ b/test/runtime/type/guard/indexed.ts
@@ -277,4 +277,42 @@ describe('type/guard/TIndex', () => {
     // on the object. This may be resolvable in later revisions, but test for this
     // fall-through to ensure case is documented. For review.
   })
+  // --------------------------------------------------------
+  // Modifier Optional Indexing
+  // --------------------------------------------------------
+  it('Should Index 31', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.String()),
+      y: Type.Number(),
+    })
+    const I = Type.Index(T, ['x'])
+    Assert.isTrue(TypeGuard.TOptional(I))
+    Assert.isTrue(TypeGuard.TString(I))
+  })
+  it('Should Index 32', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.String()),
+      y: Type.Number(),
+    })
+    const I = Type.Index(T, ['y'])
+    Assert.isFalse(TypeGuard.TOptional(I))
+    Assert.isTrue(TypeGuard.TNumber(I))
+  })
+  it('Should Index 33', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.String()),
+      y: Type.Number(),
+    })
+    const I = Type.Index(T, ['x', 'y'])
+    Assert.isTrue(TypeGuard.TOptional(I))
+    Assert.isTrue(TypeGuard.TUnion(I))
+    Assert.isTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.isTrue(TypeGuard.TNumber(I.anyOf[1]))
+  })
+  it('Should Index 34', () => {
+    const T = Type.String()
+    // @ts-ignore
+    const I = Type.Index(T, ['x'])
+    Assert.isTrue(TypeGuard.TNever(I))
+  })
 })
diff --git a/test/runtime/type/normalize/index.ts b/test/runtime/type/normalize/index.ts
index d0d7e13fd..051f3a9bb 100644
--- a/test/runtime/type/normalize/index.ts
+++ b/test/runtime/type/normalize/index.ts
@@ -1,5 +1,6 @@
 import './exclude'
 import './extract'
 import './intersect'
+import './indexed'
 import './record'
 import './union'
diff --git a/test/runtime/type/normalize/indexed.ts b/test/runtime/type/normalize/indexed.ts
new file mode 100644
index 000000000..eba47cb00
--- /dev/null
+++ b/test/runtime/type/normalize/indexed.ts
@@ -0,0 +1,140 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/normal/Index', () => {
+  // ---------------------------------------------------------
+  // Array
+  // ---------------------------------------------------------
+  it('Normalize Array 1', () => {
+    const T = Type.Array(Type.String())
+    const I = Type.Index(T, Type.Number())
+    Assert.isEqual(TypeGuard.TString(I), true)
+  })
+  // ---------------------------------------------------------
+  // Tuple
+  // ---------------------------------------------------------
+  it('Normalize Tuple 1', () => {
+    const T = Type.Tuple([Type.String(), Type.Number()])
+    const I = Type.Index(T, Type.Number())
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TNumber(I.anyOf[1]), true)
+  })
+  it('Normalize Tuple 2', () => {
+    const T = Type.Tuple([Type.String(), Type.Number()])
+    const I = Type.Index(T, [0, 1])
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TNumber(I.anyOf[1]), true)
+  })
+  it('Normalize Tuple 3', () => {
+    const T = Type.Tuple([Type.String(), Type.Number()])
+    const I = Type.Index(T, ['0', '1'])
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TNumber(I.anyOf[1]), true)
+  })
+  it('Normalize Tuple 4', () => {
+    const T = Type.Tuple([Type.String(), Type.Number()])
+    const I = Type.Index(T, ['0'])
+    Assert.isEqual(TypeGuard.TString(I), true)
+  })
+  it('Normalize Tuple 5', () => {
+    const T = Type.Tuple([Type.String(), Type.Number()])
+    const I = Type.Index(T, ['1'])
+    Assert.isEqual(TypeGuard.TNumber(I), true)
+  })
+  // ---------------------------------------------------------
+  // Intersect
+  // ---------------------------------------------------------
+  it('Normalize Intersect 1', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.Optional(Type.String()) }), Type.Object({ x: Type.Optional(Type.String()) })])
+    const I = Type.Index(T, ['x'])
+    Assert.isEqual(TypeGuard.TOptional(I), true)
+    Assert.isEqual(TypeGuard.TIntersect(I), true)
+    Assert.isEqual(TypeGuard.TString(I.allOf[0]), true)
+    Assert.isEqual(TypeGuard.TString(I.allOf[1]), true)
+  })
+  it('Normalize Intersect 2', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.Optional(Type.String()) }), Type.Object({ x: Type.String() })])
+    const I = Type.Index(T, ['x'])
+    Assert.isEqual(TypeGuard.TOptional(I), false)
+    Assert.isEqual(TypeGuard.TIntersect(I), true)
+    Assert.isEqual(TypeGuard.TString(I.allOf[0]), true)
+    Assert.isEqual(TypeGuard.TString(I.allOf[1]), true)
+  })
+  it('Normalize Intersect 3', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.String() }), Type.Object({ x: Type.String() })])
+    const I = Type.Index(T, ['x'])
+    Assert.isEqual(TypeGuard.TOptional(I), false)
+    Assert.isEqual(TypeGuard.TIntersect(I), true)
+    Assert.isEqual(TypeGuard.TString(I.allOf[0]), true)
+    Assert.isEqual(TypeGuard.TString(I.allOf[1]), true)
+  })
+  it('Normalize Intersect 4', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.String() })])
+    const I = Type.Index(T, ['x'])
+    Assert.isEqual(TypeGuard.TString(I), true)
+  })
+  it('Normalize Intersect 5', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.String() }), Type.Object({ y: Type.String() })])
+    const I = Type.Index(T, ['x', 'y'])
+    Assert.isEqual(TypeGuard.TOptional(I), false)
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
+  })
+  it('Normalize Intersect 6', () => {
+    const T = Type.Recursive(() => Type.Intersect([Type.Object({ x: Type.String() }), Type.Object({ y: Type.String() })]))
+    const I = Type.Index(T, ['x', 'y'])
+    Assert.isEqual(TypeGuard.TOptional(I), false)
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
+  })
+  // ---------------------------------------------------------
+  // Union
+  // ---------------------------------------------------------
+  it('Normalize Union 1', () => {
+    const T = Type.Union([Type.Object({ x: Type.Optional(Type.String()) }), Type.Object({ x: Type.Optional(Type.String()) })])
+    const I = Type.Index(T, ['x'])
+    Assert.isEqual(TypeGuard.TOptional(I), true)
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
+  })
+  it('Normalize Union 2', () => {
+    const T = Type.Union([Type.Object({ x: Type.Optional(Type.String()) }), Type.Object({ x: Type.String() })])
+    const I = Type.Index(T, ['x'])
+    Assert.isEqual(TypeGuard.TOptional(I), true)
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
+  })
+  it('Normalize Union 3', () => {
+    const T = Type.Union([Type.Object({ x: Type.String() }), Type.Object({ x: Type.String() })])
+    const I = Type.Index(T, ['x'])
+    Assert.isEqual(TypeGuard.TOptional(I), false)
+    Assert.isEqual(TypeGuard.TUnion(I), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
+    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
+  })
+  it('Normalize Union 4', () => {
+    const T = Type.Union([Type.Object({ x: Type.String() })])
+    const I = Type.Index(T, ['x'])
+    Assert.isEqual(TypeGuard.TString(I), true)
+  })
+  it('Normalize Union 5', () => {
+    const T = Type.Union([Type.Object({ x: Type.String() }), Type.Object({ y: Type.String() })])
+    // @ts-ignore
+    const I = Type.Index(T, ['x', 'y'])
+    Assert.isEqual(TypeGuard.TNever(I), false)
+  })
+  it('Normalize Union 6', () => {
+    const T = Type.Recursive(() => Type.Union([Type.Object({ x: Type.String() }), Type.Object({ y: Type.String() })]))
+    // @ts-ignore
+    const I = Type.Index(T, ['x', 'y'])
+    Assert.isEqual(TypeGuard.TNever(I), false)
+  })
+})

From da10cc09fa4adc159dccaaac9d6ff038f970c1e6 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 4 Jul 2023 07:27:22 +0900
Subject: [PATCH 155/369] Revision 0.29.3 (#487)

---
 package.json         | 2 +-
 src/typebox.ts       | 4 ++--
 test/static/keyof.ts | 9 +++++++++
 3 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/package.json b/package.json
index 2b017e2bf..2971f5b17 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.29.2",
+  "version": "0.29.3",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 5d8c046d0..f67705d80 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -393,9 +393,9 @@ export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, In
 // TKeyOf
 // --------------------------------------------------------------------------
 // prettier-ignore
-export type TKeyOfProperties<T extends TSchema> = Static<T> extends infer S
+export type TKeyOfProperties<T extends TSchema> = Discard<Static<T> extends infer S
   ? UnionToTuple<{[K in keyof S]: TLiteral<Assert<K, TLiteralValue>>}[keyof S]>
-  : []
+  : [], undefined> // note: optional properties produce undefined types in tuple result. discard.
 // prettier-ignore
 export type TKeyOfIndicesArray<T extends TSchema[]> = UnionToTuple<keyof T & `${number}`>
 // prettier-ignore
diff --git a/test/static/keyof.ts b/test/static/keyof.ts
index bda75e87f..e5ad39fed 100644
--- a/test/static/keyof.ts
+++ b/test/static/keyof.ts
@@ -91,3 +91,12 @@ import { Type } from '@sinclair/typebox'
   const K = Type.KeyOf(T)
   Expect(K).ToInfer<'a' | 'b' | 'c' | 'd'>()
 }
+{
+  const T = Type.Object({
+    a: Type.Optional(Type.String()),
+    b: Type.Optional(Type.String()),
+    c: Type.Optional(Type.String()),
+  })
+  const K = Type.KeyOf(T)
+  Expect(K).ToInfer<'a' | 'b' | 'c'>()
+}

From 3f50917d98e5c9160fb5d7a1c8bbe9f6ab3e560c Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 5 Jul 2023 00:09:03 +0900
Subject: [PATCH 156/369] Scheduled Nightly Builds (#488)

---
 .github/workflows/{ci.yml => build.yml} |  8 ++---
 .github/workflows/nightly.yml           | 30 +++++++++++++++++
 hammer.mjs                              | 44 ++++++++++++-------------
 package-lock.json                       |  4 +--
 readme.md                               |  4 +--
 5 files changed, 60 insertions(+), 30 deletions(-)
 rename .github/workflows/{ci.yml => build.yml} (90%)
 create mode 100644 .github/workflows/nightly.yml

diff --git a/.github/workflows/ci.yml b/.github/workflows/build.yml
similarity index 90%
rename from .github/workflows/ci.yml
rename to .github/workflows/build.yml
index b1192b393..e482eb7e1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/build.yml
@@ -1,7 +1,5 @@
-name: GitHub CI
-
+name: Build
 on: [push, pull_request]
-
 jobs:
   TypeBox:
     runs-on: ${{ matrix.os }}
@@ -12,11 +10,13 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: Install Node
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v3
         with:
           node-version: ${{ matrix.node }}
+
       - name: Install Packages
         run: npm install
+
       - name: Build Library
         run: npm run build
       - name: Test Library
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
new file mode 100644
index 000000000..7ad6b9d88
--- /dev/null
+++ b/.github/workflows/nightly.yml
@@ -0,0 +1,30 @@
+name: Build Nightly
+on:
+  schedule:
+    - cron: '0 18 * * *' # 6pm Daily
+jobs:
+  TypeBox:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        node: [20.x]
+        os: [ubuntu-latest]
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node }}
+
+      - name: Install Packages
+        run: npm install
+
+      - name: Install TypeScript Latest
+        run: npm install typescript@latest
+      - name: Build TypeBox
+        run: npm run build
+
+      - name: Install TypeScript Next
+        run: npm install typescript@next
+      - name: Build TypeBox
+        run: npm run build
\ No newline at end of file
diff --git a/hammer.mjs b/hammer.mjs
index e47b88f82..a6bca8b8b 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -5,59 +5,59 @@ import { readFileSync } from 'fs'
 // Clean
 // -------------------------------------------------------------------------------
 export async function clean() {
-    await folder('target').delete()
+	await folder('target').delete()
 }
 // -------------------------------------------------------------------------------
 // Format
 // -------------------------------------------------------------------------------
 export async function format() {
-    await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test example/index.ts benchmark')
+	await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test example/index.ts benchmark')
 }
 // -------------------------------------------------------------------------------
 // Start
 // -------------------------------------------------------------------------------
 export async function start(example = 'index') {
-    await shell(`hammer run example/${example}.ts --dist target/example/${example}`)
+	await shell(`hammer run example/${example}.ts --dist target/example/${example}`)
 }
 // -------------------------------------------------------------------------------
 // Benchmark
 // -------------------------------------------------------------------------------
 export async function benchmark() {
-    await compression()
-    await measurement()
+	await compression()
+	await measurement()
 }
 // -------------------------------------------------------------------------------
 // Test
 // -------------------------------------------------------------------------------
 export async function test_static() {
-    await shell(`tsc -p test/static/tsconfig.json --noEmit --strict`)
+	await shell(`tsc -p test/static/tsconfig.json --noEmit --strict`)
 }
-export async function test_runtime(filter) {
-    await shell(`hammer build ./test/runtime/index.ts --dist target/test/runtime --platform node`)
-    await shell(`mocha target/test/runtime/index.js -g "${filter}"`)
+export async function test_runtime(filter = '') {
+	await shell(`hammer build ./test/runtime/index.ts --dist target/test/runtime --platform node`)
+	await shell(`mocha target/test/runtime/index.js -g "${filter}"`)
 }
 export async function test(filter = '') {
-    await test_static()
-    await test_runtime(filter)
+	await test_static()
+	await test_runtime(filter)
 }
 // -------------------------------------------------------------------------------
 // Build
 // -------------------------------------------------------------------------------
 export async function build(target = 'target/build') {
-    await test()
-    await folder(target).delete()
-    await shell(`tsc -p ./src/tsconfig.json --outDir ${target}`)
-    await folder(target).add('package.json')
-    await folder(target).add('readme.md')
-    await folder(target).add('license')
-    await shell(`cd ${target} && npm pack`)
+	await test()
+	await folder(target).delete()
+	await shell(`tsc -p ./src/tsconfig.json --outDir ${target}`)
+	await folder(target).add('package.json')
+	await folder(target).add('readme.md')
+	await folder(target).add('license')
+	await shell(`cd ${target} && npm pack`)
 }
 // -------------------------------------------------------------
 // Publish
 // -------------------------------------------------------------
 export async function publish(otp, target = 'target/build') {
-    const { version } = JSON.parse(readFileSync('package.json', 'utf8'))
-    await shell(`cd ${target} && npm publish sinclair-typebox-${version}.tgz --access=public --otp ${otp}`)
-    await shell(`git tag ${version}`)
-    await shell(`git push origin ${version}`)
+	const { version } = JSON.parse(readFileSync('package.json', 'utf8'))
+	await shell(`cd ${target} && npm publish sinclair-typebox-${version}.tgz --access=public --otp ${otp}`)
+	await shell(`git tag ${version}`)
+	await shell(`git push origin ${version}`)
 }
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index 3cb6da902..31f90d3b1 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.29.1",
+  "version": "0.29.3",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.29.1",
+      "version": "0.29.3",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/readme.md b/readme.md
index 7f5d64338..68c792208 100644
--- a/readme.md
+++ b/readme.md
@@ -11,8 +11,8 @@
 
 [![npm version](https://badge.fury.io/js/%40sinclair%2Ftypebox.svg)](https://badge.fury.io/js/%40sinclair%2Ftypebox)
 [![Downloads](https://img.shields.io/npm/dm/%40sinclair%2Ftypebox.svg)](https://www.npmjs.com/package/%40sinclair%2Ftypebox)
-[![GitHub CI](https://github.com/sinclairzx81/typebox/workflows/GitHub%20CI/badge.svg)](https://github.com/sinclairzx81/typebox/actions)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Build](https://github.com/sinclairzx81/typebox/actions/workflows/build.yml/badge.svg)](https://github.com/sinclairzx81/typebox/actions/workflows/build.yml)
+[![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 </div>
 

From 185eb13dc9ee1ad62ef683b0620d3cdaadad0cae Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 5 Jul 2023 05:05:16 +0900
Subject: [PATCH 157/369] General Maintenance (#489)

---
 example/collections/readme.md                 |   3 +
 example/experimental/experimental.ts          | 109 ----
 example/experimental/index.ts                 |   6 +-
 example/experimental/readme.md                |  64 ++-
 example/experimental/readonly-object.ts       |  68 +++
 .../index.ts => experimental/union-enum.ts}   |  22 +-
 .../index.ts => experimental/union-oneof.ts}  |  19 +-
 example/formats/readme.md                     |  30 +-
 .../{intersect.ts => intersect-0.25.0.ts}     |   0
 example/typedef/readme.md                     | 315 ++++++++---
 example/typedef/typedef.ts                    | 212 ++++----
 example/typemap/readme.md                     |   7 -
 example/typemap/typemap.ts                    | 496 ------------------
 hammer.mjs                                    |  42 +-
 14 files changed, 543 insertions(+), 850 deletions(-)
 create mode 100644 example/collections/readme.md
 delete mode 100644 example/experimental/experimental.ts
 create mode 100644 example/experimental/readonly-object.ts
 rename example/{typedef/index.ts => experimental/union-enum.ts} (56%)
 rename example/{legacy/index.ts => experimental/union-oneof.ts} (59%)
 rename example/legacy/{intersect.ts => intersect-0.25.0.ts} (100%)
 delete mode 100644 example/typemap/readme.md
 delete mode 100644 example/typemap/typemap.ts

diff --git a/example/collections/readme.md b/example/collections/readme.md
new file mode 100644
index 000000000..9c7adf48f
--- /dev/null
+++ b/example/collections/readme.md
@@ -0,0 +1,3 @@
+# Collections
+
+This example implements runtime type safe generic `Array`, `Map` and `Set` collection types using TypeBox types as the generic type arguments.
\ No newline at end of file
diff --git a/example/experimental/experimental.ts b/example/experimental/experimental.ts
deleted file mode 100644
index facf22474..000000000
--- a/example/experimental/experimental.ts
+++ /dev/null
@@ -1,109 +0,0 @@
-
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/experimental
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import * as Types from '@sinclair/typebox'
-import { Value } from '@sinclair/typebox/value'
-
-// -------------------------------------------------------------------------------------
-// TReadonlyObject
-// -------------------------------------------------------------------------------------
-export type TReadonlyArray<T extends Types.TSchema[]> = Types.Assert<{ [K in keyof T]: TReadonlyObject<Types.Assert<T[K], Types.TSchema>> }, Types.TSchema[]>
-// prettier-ignore
-export type TReadonlyProperties<T extends Types.TProperties> = Types.Evaluate<Types.Assert<{
-  [K in keyof T]: 
-    T[K] extends Types.TReadonlyOptional<infer U> ? Types.TReadonlyOptional<U> : 
-    T[K] extends Types.TReadonly<infer U>         ? Types.TReadonly<U> : 
-    T[K] extends Types.TOptional<infer U>         ? Types.TReadonlyOptional<U> : 
-    Types.TReadonly<T[K]>
-}, Types.TProperties>>
-// prettier-ignore
-export type TReadonlyObject<T extends Types.TSchema> = 
-  T extends Types.TIntersect<infer S> ? Types.TIntersect<TReadonlyArray<S>> : 
-  T extends Types.TUnion<infer S>     ? Types.TUnion<TReadonlyArray<S>> : 
-  T extends Types.TObject<infer S>    ? Types.TObject<TReadonlyProperties<S>> : 
-  Types.TReadonly<T>
-
-// -------------------------------------------------------------------------------------
-// TUnionEnum
-// -------------------------------------------------------------------------------------
-export interface TUnionEnum<T extends (string | number)[]> extends Types.TSchema {
-  [Types.Kind]: 'UnionEnum'
-  static: T[number]
-  enum: T
-}
-// -------------------------------------------------------------------------------------
-// UnionOneOf
-// -------------------------------------------------------------------------------------
-export interface UnionOneOf<T extends Types.TSchema[]> extends Types.TSchema {
-  [Types.Kind]: 'UnionOneOf'
-  static: { [K in keyof T]: Types.Static<T[K]> }[number]
-  oneOf: T
-}
-// -------------------------------------------------------------------------------------
-// ExperimentalTypeBuilder
-// -------------------------------------------------------------------------------------
-export class ExperimentalTypeBuilder extends Types.ExtendedTypeBuilder {
-  /** `[Experimental]` Remaps a Intersect, Union or Object as readonly */
-  public ReadonlyObject<T extends Types.TSchema>(schema: T): TReadonlyObject<T> {
-    function Apply(property: Types.TSchema): any {
-      // prettier-ignore
-      switch (property[Types.Modifier]) {
-        case 'ReadonlyOptional': property[Types.Modifier] = 'ReadonlyOptional'; break
-        case 'Readonly': property[Types.Modifier] = 'Readonly'; break
-        case 'Optional': property[Types.Modifier] = 'ReadonlyOptional'; break
-        default: property[Types.Modifier] = 'Readonly'; break
-      }
-      return property
-    }
-    // prettier-ignore
-    return (Types.TypeGuard.TIntersect(schema) || Types.TypeGuard.TUnion(schema) || Types.TypeGuard.TObject(schema)) 
-      ? Types.ObjectMap.Map<TReadonlyObject<T>>(schema, (schema) => {
-        globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]))
-      return schema
-    }, {}) : Apply(schema)
-  }
-  /** `[Experimental]` Creates a Union type with a `enum` schema representation  */
-  public UnionEnum<T extends (string | number)[]>(values: [...T], options: Types.SchemaOptions = {}) {
-    function UnionEnumCheck(schema: TUnionEnum<(string | number)[]>, value: unknown) {
-      return (typeof value === 'string' || typeof value === 'number') && schema.enum.includes(value)
-    }
-    if (!Types.TypeRegistry.Has('UnionEnum')) Types.TypeRegistry.Set('UnionEnum', UnionEnumCheck)
-    return { ...options, [Types.Kind]: 'UnionEnum', enum: values } as TUnionEnum<T>
-  }
-  /** `[Experimental]` Creates a Union type with a `oneOf` schema representation */
-  public UnionOneOf<T extends Types.TSchema[]>(oneOf: [...T], options: Types.SchemaOptions = {}) {
-    function UnionOneOfCheck(schema: UnionOneOf<Types.TSchema[]>, value: unknown) {
-      return 1 === schema.oneOf.reduce((acc: number, schema: any) => (Value.Check(schema, value) ? acc + 1 : acc), 0)
-    }
-    if (!Types.TypeRegistry.Has('UnionOneOf')) Types.TypeRegistry.Set('UnionOneOf', UnionOneOfCheck)
-    return { ...options, [Types.Kind]: 'UnionOneOf', oneOf } as UnionOneOf<T>
-  }
-}
-
-export const Type = new ExperimentalTypeBuilder()
\ No newline at end of file
diff --git a/example/experimental/index.ts b/example/experimental/index.ts
index 9dcc0367b..daddc72d8 100644
--- a/example/experimental/index.ts
+++ b/example/experimental/index.ts
@@ -1,6 +1,6 @@
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox/extensions
+@sinclair/typebox/experimental
 
 The MIT License (MIT)
 
@@ -26,4 +26,6 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export * from './experimental'
+export * from './readonly-object'
+export * from './union-enum'
+export * from './union-oneof'
diff --git a/example/experimental/readme.md b/example/experimental/readme.md
index 16f8b3873..d22128721 100644
--- a/example/experimental/readme.md
+++ b/example/experimental/readme.md
@@ -1,30 +1,54 @@
-# ExperimentalTypeBuilder
+# Experimental Types
 
-An experimental TypeBox type builder with additional custom types.
+These examples are a set of experiemental candidate types that may introduced into TypeBox in future.
 
-## Overview
+## ReadonlyObject
 
-The TypeBox TypeBuilder classes are designed to be extended with user defined types. Instances where you may wish to do this are if your application is dependent on custom schematics and/or non-JSON serializable values (an example of which might be a Mongo's `ObjectId` or other such non-serializable value)
+Maps an object properties as `readonly`.
 
-## Application Type Builder
+```typescript
+import { ReadonlyObject } from './experimental'
+
+const T = ReadonlyObject(Type.Object({
+  x: Type.Number()
+}))
+
+type T = Static<typeof T>                           // type T = {
+                                                    //   readonly x: number
+                                                    // }
+```
+## UnionEnum
 
-The following shows creating a simple `ApplicationTypeBuilder` with additional types `Nullable` and `StringEnum`. These types are fairly common in OpenAPI implementations.
+Creates an `enum` union string schema representation.
 
 ```typescript
-import { StandardTypeBuilder, Static, TSchema } from '@sinclair/typebox'
-
-export class ApplicationTypeBuilder extends StandardTypeBuilder { // only JSON Schema types
-  public Nullable<T extends TSchema>(schema: T) {
-    return this.Unsafe<Static<T> | null>({ ...schema, nullable: true })
-  }
-  public StringEnum<T extends string[]>(values: [...T]) {
-    return this.Unsafe<T[number]>({ type: 'string', enum: values })
-  }
-}
-
-export const Type = new ApplicationTypeBuilder()    // re-export!
+import { UnionEnum } from './experimental'
+
+
+const T = UnionEnum(['A', 'B', 'C'])                // const T = {
+                                                    //   enum: ['A', 'B', 'C']
+                                                    // }
+
+type T = Static<typeof T>                           // type T = 'A' | 'B' | 'C'
+
 ```
+## UnionOneOf
+
+Creates a `oneOf` union representation.
+
+
+```typescript
+import { UnionOneOf } from './experimental'
+
+
+const T = UnionOneOf([                              // const T = {
+  Type.Literal('A'),                                //   oneOf: [
+  Type.Literal('B'),                                //     { const: 'A' },
+  Type.Literal('C')                                 //     { const: 'B' },
+])                                                  //     { const: 'C' },
+                                                    //   ]
+                                                    // }
 
-## Experimental Type Builder
+type T = Static<typeof T>                           // type T = 'A' | 'B' | 'C'
 
-The `experimental.ts` file provided with this example shows advanced usage by creating complex types for potential inclusion in the TypeBox library in later revisions. It is offered for reference, experimentation and is open to contributor submission.
\ No newline at end of file
+```
\ No newline at end of file
diff --git a/example/experimental/readonly-object.ts b/example/experimental/readonly-object.ts
new file mode 100644
index 000000000..b6ce4bacc
--- /dev/null
+++ b/example/experimental/readonly-object.ts
@@ -0,0 +1,68 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/experimental
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '@sinclair/typebox'
+
+// -------------------------------------------------------------------------------------
+// TReadonlyObject
+// -------------------------------------------------------------------------------------
+export type TReadonlyArray<T extends Types.TSchema[]> = Types.Assert<{ [K in keyof T]: TReadonlyObject<Types.Assert<T[K], Types.TSchema>> }, Types.TSchema[]>
+// prettier-ignore
+export type TReadonlyProperties<T extends Types.TProperties> = Types.Evaluate<Types.Assert<{
+  [K in keyof T]:
+  T[K] extends Types.TReadonlyOptional<infer U> ? Types.TReadonlyOptional<U> :
+  T[K] extends Types.TReadonly<infer U> ? Types.TReadonly<U> :
+  T[K] extends Types.TOptional<infer U> ? Types.TReadonlyOptional<U> :
+  Types.TReadonly<T[K]>
+}, Types.TProperties>>
+// prettier-ignore
+export type TReadonlyObject<T extends Types.TSchema> =
+  T extends Types.TIntersect<infer S> ? Types.TIntersect<TReadonlyArray<S>> :
+  T extends Types.TUnion<infer S> ? Types.TUnion<TReadonlyArray<S>> :
+  T extends Types.TObject<infer S> ? Types.TObject<TReadonlyProperties<S>> :
+  Types.TReadonly<T>
+
+/** `[Experimental]` Remaps a Intersect, Union or Object as readonly */
+export function ReadonlyObject<T extends Types.TSchema>(schema: T): TReadonlyObject<T> {
+  function Apply(property: Types.TSchema): any {
+    // prettier-ignore
+    switch (property[Types.Modifier]) {
+      case 'ReadonlyOptional': property[Types.Modifier] = 'ReadonlyOptional'; break
+      case 'Readonly': property[Types.Modifier] = 'Readonly'; break
+      case 'Optional': property[Types.Modifier] = 'ReadonlyOptional'; break
+      default: property[Types.Modifier] = 'Readonly'; break
+    }
+    return property
+  }
+  // prettier-ignore
+  return (Types.TypeGuard.TIntersect(schema) || Types.TypeGuard.TUnion(schema) || Types.TypeGuard.TObject(schema))
+    ? Types.ObjectMap.Map<TReadonlyObject<T>>(schema, (schema) => {
+      globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]))
+      return schema
+    }, {}) : Apply(schema)
+}
\ No newline at end of file
diff --git a/example/typedef/index.ts b/example/experimental/union-enum.ts
similarity index 56%
rename from example/typedef/index.ts
rename to example/experimental/union-enum.ts
index b5db4f7aa..9f0bd77f1 100644
--- a/example/typedef/index.ts
+++ b/example/experimental/union-enum.ts
@@ -1,6 +1,6 @@
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox/typedef
+@sinclair/typebox/experimental
 
 The MIT License (MIT)
 
@@ -26,4 +26,22 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export * from './typedef'
+import * as Types from '@sinclair/typebox'
+
+// -------------------------------------------------------------------------------------
+// TUnionEnum
+// -------------------------------------------------------------------------------------
+export interface TUnionEnum<T extends (string | number)[]> extends Types.TSchema {
+  [Types.Kind]: 'UnionEnum'
+  static: T[number]
+  enum: T
+}
+
+/** `[Experimental]` Creates a Union type with a `enum` schema representation  */
+export function UnionEnum<T extends (string | number)[]>(values: [...T], options: Types.SchemaOptions = {}) {
+  function UnionEnumCheck(schema: TUnionEnum<(string | number)[]>, value: unknown) {
+    return (typeof value === 'string' || typeof value === 'number') && schema.enum.includes(value)
+  }
+  if (!Types.TypeRegistry.Has('UnionEnum')) Types.TypeRegistry.Set('UnionEnum', UnionEnumCheck)
+  return { ...options, [Types.Kind]: 'UnionEnum', enum: values } as TUnionEnum<T>
+}
\ No newline at end of file
diff --git a/example/legacy/index.ts b/example/experimental/union-oneof.ts
similarity index 59%
rename from example/legacy/index.ts
rename to example/experimental/union-oneof.ts
index 79f17933b..cec504644 100644
--- a/example/legacy/index.ts
+++ b/example/experimental/union-oneof.ts
@@ -1,6 +1,6 @@
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox/legacy
+@sinclair/typebox/experimental
 
 The MIT License (MIT)
 
@@ -26,4 +26,19 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export * from './intersect'
\ No newline at end of file
+import * as Types from '@sinclair/typebox'
+import { Value } from '@sinclair/typebox/value'
+
+export interface TUnionOneOf<T extends Types.TSchema[]> extends Types.TSchema {
+  [Types.Kind]: 'UnionOneOf'
+  static: { [K in keyof T]: Types.Static<T[K]> }[number]
+  oneOf: T
+}
+/** `[Experimental]` Creates a Union type with a `oneOf` schema representation */
+export function UnionOneOf<T extends Types.TSchema[]>(oneOf: [...T], options: Types.SchemaOptions = {}) {
+  function UnionOneOfCheck(schema: TUnionOneOf<Types.TSchema[]>, value: unknown) {
+    return 1 === schema.oneOf.reduce((acc: number, schema: any) => (Value.Check(schema, value) ? acc + 1 : acc), 0)
+  }
+  if (!Types.TypeRegistry.Has('UnionOneOf')) Types.TypeRegistry.Set('UnionOneOf', UnionOneOfCheck)
+  return { ...options, [Types.Kind]: 'UnionOneOf', oneOf } as TUnionOneOf<T>
+}
\ No newline at end of file
diff --git a/example/formats/readme.md b/example/formats/readme.md
index 03eb80d35..02d7b0c28 100644
--- a/example/formats/readme.md
+++ b/example/formats/readme.md
@@ -1,35 +1,11 @@
-# String Formats
+# Formats
 
-TypeBox does not implement any string formats by default. However it is possible to register user defined formats using the `FormatRegistry`. Once registered, the format becomes available to both `Value` and `TypeCompiler` modules.
+This example provides TypeCompiler supported versions of the `ajv-formats` package.
 
-## FormatRegistry
-
-The following shows basic usage of the format registry
-
-```typescript
-import { Type, FormatRegistry } from '@sinclair/typebox'
-import { Value } from '@sinclair/typebox/value'
-
-// Register the 'foo-only' format. The format checks for 'foo' only.
-FormatRegistry.Set('foo-only', value => value === 'foo')
-
-const T = Type.String({ format: 'foo-only' })
-
-// Validate
-Value.Check(T, 'foo') // true
-Value.Check(T, 'bar') // false
-```
-
-## Standard Formats
+## Standard
 
 The `standard.ts` file provided with this example implements several standard string formats. 
 
-```typescript
-import './standard'
-```
-
-The following formats are implemented by `standard.ts`
-
 | Format      | Description |
 | ---         | --- |
 | `email`     | Internet email address, see [RFC 5321, section 4.1.2.](http://tools.ietf.org/html/rfc5321#section-4.1.2) |
diff --git a/example/legacy/intersect.ts b/example/legacy/intersect-0.25.0.ts
similarity index 100%
rename from example/legacy/intersect.ts
rename to example/legacy/intersect-0.25.0.ts
diff --git a/example/typedef/readme.md b/example/typedef/readme.md
index 07837ad72..80639ff02 100644
--- a/example/typedef/readme.md
+++ b/example/typedef/readme.md
@@ -1,81 +1,266 @@
 # TypeDef
 
-TypeBox may offer support for [RPC8927](https://www.rfc-editor.org/rfc/rfc8927) JSON Type Definition in future revisions of the library. This specification is much simpler than JSON Schema but can be useful when describing schematics that need to be shared with nominal type languages.
+TypeBox is considering support for the JSON Type Definition [RFC8927](https://www.rfc-editor.org/rfc/rfc8927) specification in future releases. This specification is similar to JSON Schema but provides a constrained type representation that enables schematics to map more naturally to [nominal type systems](https://en.wikipedia.org/wiki/Nominal_type_system) as well as offering type primitives such as `int8`, `uint32` or `float32`. JSON Type Definition can be useful in applications that need to express and share data structures in a way that can be understood by a wide range of programming languages outside of JavaScript.
+
+License MIT
+
+## Contents
+- [Usage](#Usage)
+- [Types](#Types)
+- [Unions](#Unions)
+- [Check](#Check)
 
 ## Usage
 
-The file `typedef.ts` provided with this example contains the provisional implementation for RPC8927.
+TypeBox currently doesn't publish TypeDef as part of the mainline package. However the TypeDef functionality is written to be a standalone module you can copy into your project. You will also need `@sinclair/typebox` installed. You can obtain the `typedef` module from `example/typedef/typedef.ts` contained within this repository. 
 
 ```typescript
-import { Value } from '@sinclair/typebox/value'
 import { Type, Static } from './typedef'
 
-const T = Type.Struct('T', {                         // const T = {
-  x: Type.Float32(),                                 //   properties: {
-  y: Type.Float32(),                                 //     x: { type: "float32" },
-  z: Type.Float32()                                  //     y: { type: 'float32' },
-})                                                   //     z: { type: 'float32' }
-                                                     //   }
-                                                     // }
-
-type T = Static<typeof T>                            // type T = {
-                                                     //   x: number,
-                                                     //   z: number,
-                                                     //   y: number
-                                                     // }
-
-const R = Value.Check(T, { x: 1, y: 2, z: 3 })       // const R = true
+const T = Type.Struct({                // const T = {
+  x: Type.Float32(),                   //   properties: {
+  y: Type.Float32(),                   //     x: { type: 'float32' },
+  z: Type.Float32()                    //     y: { type: 'float32' },
+})                                     //     z: { type: 'float32' }
+                                       //   }
+                                       // }
+
+type T = Static<typeof T>              // type T = {
+                                       //   x: number,
+                                       //   y: number,
+                                       //   z: number
+                                       // }
 ```
 
-### Unions
+## Types
 
-The JSON Type Definition has a different representation for unions and is primarily orientated towards discriminated unions. To use unions, you will need to name each struct on the first argument. TypeBox will take care of producing the union representation and static type.
+The following types are supported by the typedef module. Please note these types are not compatible with the JSON Schema specification and should not be combined with the standard TypeBox types.
 
 ```typescript
-import { Type, Static } from './typedef'
+┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
+│ TypeBox                        │ TypeScript                  │ JSON Type Definition           │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Boolean()       │ type T = boolean            │ const T = {                    │
+│                                │                             │   type: 'boolean'              │
+│                                │                             │ }                              │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.String()        │ type T = string             │ const T = {                    │
+│                                │                             │   type: 'string'               │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Float32()       │ type T = number             │ const T = {                    │
+│                                │                             │   type: 'float32'              │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Float64()       │ type T = number             │ const T = {                    │
+│                                │                             │   type: 'float64'              │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Int8()          │ type T = number             │ const T = {                    │
+│                                │                             │   type: 'int8'                 │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Int16()         │ type T = number             │ const T = {                    │
+│                                │                             │   type: 'int16'                │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Int32()         │ type T = number             │ const T = {                    │
+│                                │                             │   type: 'int32'                │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Uint8()         │ type T = number             │ const T = {                    │
+│                                │                             │   type: 'uint8'                │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Uint16()        │ type T = number             │ const T = {                    │
+│                                │                             │   type: 'uint16'               │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Uint32()        │ type T = number             │ const T = {                    │
+│                                │                             │   type: 'uint32'               │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Timestamp()     │ type T = number             │ const T = {                    │
+│                                │                             │   type: 'timestamp'            │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Struct([        │ type T = {                  │ const T = {                    │
+│   x: Type.Float32(),           │   x: number,                │   properties: {                │
+│   y: Type.Float32(),           │   y: number                 │     x: number,                 │
+│ ])                             │ }                           │     y: number                  │
+│                                │                             │   }                            │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Array(          │ type T = number[]           │ const T = {                    │
+│   Type.Float32()               │                             │   elements: {                  │
+│ )                              │                             │     type: 'float32'            │
+│                                │                             │   }                            │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Record(         │ type T = Record<            │ const T = {                    │
+│   Type.Float32()               │   string,                   │   values: {                    │
+│ )                              │   number                    │     type: 'float32'            │
+│                                │ >                           │   }                            │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Enum([          │ type T = 'A' | 'B' | 'C'    │ const T = {                    │
+│   'A', 'B', 'C'                │                             │   enum: [                      │
+│ ])                             │                             │     'A',                       │
+│                                │                             │     'B',                       │
+│                                │                             │     'C'                        │
+│                                │                             │   ]                            │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Union([         │ type T = {                  │ const T = {                    │
+│   Type.Struct({                │   kind: '0',                │   discriminator: 'kind',       │
+│     x: Type.Float32()          │   x: number                 │   mapping: {                   │
+│   }),                          │ } | {                       │     '0': {                     │
+│   Type.Struct({                │   kind: '1'                 │       properties: {            │
+│     y: Type.Float32()          │   y: number                 │         x: {                   │
+│   ])                           │ }                           │           type: 'float32'      │
+│ ], 'kind')                     │                             │         }                      │
+│                                │                             │       }                        │
+│                                │                             │     },                         │
+│                                │                             │     '1':  {                    |
+│                                │                             │       properties: {            │
+│                                │                             │         y: {                   │
+│                                │                             │           type: 'float32'      │
+│                                │                             │         }                      │
+│                                │                             │       }                        │
+│                                │                             │     }                          │
+│                                │                             │   }                            │
+│                                │                             │ }                              │
+│                                │                             │                                │
+└────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
+```
+
+## Unions
 
-const Vector2 = Type.Struct('Vector2', {             // const Vector2 = {
-  x: Type.Float32(),                                 //   properties: {
-  y: Type.Float32(),                                 //     x: { type: 'float32' },
-})                                                   //     y: { type: 'float32' }
-                                                     //   }
-                                                     // }
-
-const Vector3 = Type.Struct('Vector3', {             // const Vector3 = {
-  x: Type.Float32(),                                 //   properties: {
-  y: Type.Float32(),                                 //     x: { type: 'float32' },
-  z: Type.Float32()                                  //     y: { type: 'float32' },
-})                                                   //     z: { type: 'float32' }
-                                                     //   }
-                                                     // }
-
-const Union = Type.Union('type', [                   //  const Union = {
-  Vector2,                                           //    discriminator: 'type',
-  Vector3                                            //    mapping: {
-])                                                   //      Vector2: {
-                                                     //        properties: {
-                                                     //         x: { type: 'float32' },
-                                                     //         y: { type: 'float32' },
-                                                     //       }
-                                                     //     },
-                                                     //     Vector3: {
-                                                     //       properties: {
-                                                     //         x: { type: 'float32' },
-                                                     //         y: { type: 'float32' },
-                                                     //         z: { type: 'float32' }
-                                                     //       }
-                                                     //     }
-                                                     //   }
-                                                     // }
-
-type Union = Static<typeof Union>                    // type Union = {
-                                                     //   type: 'Vector2'
-                                                     //   x: number
-                                                     //   y: number
-                                                     // } | {
-                                                     //   type: 'Vector3'
-                                                     //   x: number
-                                                     //   y: number
-                                                     //   z: number
-                                                     // }    
+TypeBox supports JSON Type Definition discriminated unions with `Type.Union`. This type works similar its JSON Schema counterpart, but can only accept types of `Type.Struct` and will infer each struct with an additional named `discriminator` field. The representation for discriminated unions are also quite different, where instead of `anyOf` or `oneOf`, a set of  `mapping` properties are used for each sub type.
+
+```typescript
+const Vector2 = Type.Struct({          // const Vector2 = {
+  x: Type.Float32(),                   //   properties: {
+  y: Type.Float32()                    //     x: { type: 'float32' },
+})                                     //     y: { type: 'float32' }
+                                       //   }
+                                       // }
+
+const Vector3 = Type.Struct({          // const Vector3 = {
+  x: Type.Float32(),                   //   properties: {
+  y: Type.Float32(),                   //     x: { type: 'float32' },
+  z: Type.Float32()                    //     y: { type: 'float32' },
+})                                     //     z: { type: 'float32' }
+                                       //   }
+                                       // }
+
+const Vector4 = Type.Struct({          // const Vector4 = {
+  x: Type.Float32(),                   //   properties: {
+  y: Type.Float32(),                   //     x: { type: 'float32' },
+  z: Type.Float32(),                   //     y: { type: 'float32' },
+  w: Type.Float32()                    //     z: { type: 'float32' },
+})                                     //     w: { type: 'float32' }
+                                       //   }
+                                       // }
+
+const T = Type.Union([                 // const T = {
+  Vector2,                             //   discriminator: 'type',
+  Vector3,                             //   mapping: {
+  Vector4                              //     0: {
+])                                     //       properties: {
+                                       //         x: { type: 'float32' },
+                                       //         y: { type: 'float32' }
+                                       //       }
+                                       //     },
+                                       //     1: {
+                                       //       properties: {
+                                       //         x: { type: 'float32' },
+                                       //         y: { type: 'float32' },
+                                       //         z: { type: 'float32' }
+                                       //       }
+                                       //     },
+                                       //     2: {
+                                       //       properties: {
+                                       //         x: { type: 'float32' },
+                                       //         y: { type: 'float32' },
+                                       //         z: { type: 'float32' }
+                                       //       } 
+                                       //     }
+                                       //   }
+                                       // }
+
+
+type T = Static<typeof T>              // type T = {
+                                       //   type: '0',
+                                       //   x: number,
+                                       //   y: number
+                                       // } | {
+                                       //   type: '1',
+                                       //   x: number,
+                                       //   y: number,
+                                       //   y: number
+                                       // } | {
+                                       //   type: '2',
+                                       //   x: number,
+                                       //   y: number,
+                                       //   y: number,
+                                       //   w: number
+                                       // }
 ```
+To type check a value matching the above union, the value will need to contain the discriminator property `type` with a value matching one of the sub type `mapping` keys. The inference type shown above can be a good reference point to understand the structure of the expected value. Nominal type systems will use the discriminator to an expected target type.
+
+The following are examples of valid and invalid union data.
+
+```typescript
+
+const V = { x: 1, y: 1 }                    // invalid Vector2
+
+const V = { type: '0', x: 1, y: 1 }         // valid Vector2
+
+const V = { type: '0', x: 1, y: 1, z: 1 }   // invalid Vector2
+
+const V = { type: '1', x: 1, y: 1, z: 1 }   // valid Vector3
+```
+
+
+## Check
+
+TypeDef types are partially supported with the `TypeCompiler` and `Value` checking modules through the extensible type system in TypeBox. Please note these types are not optimized for JIT performance and do not provide deep error reporting support. For more fully featured validation support consider Ajv. Documentation of Ajv support can be found [here](https://ajv.js.org/json-type-definition.html).
+
+The following is TypeDef used with TypeBox's type checking infrastructure.
+
+```typescript
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { Value } from '@sinclair/typebox/value'
+
+const T = Type.Struct({
+  x: Type.Float32(),
+  y: Type.Float32(),
+  z: Type.Float32()
+})
+
+const V = {
+  x: 1,
+  y: 2,
+  z: 3
+}
+
+const R1 = TypeCompiler.Compile(T).Check(V)      // true
+
+const R2 = Value.Check(T, V)                     // true
+```
\ No newline at end of file
diff --git a/example/typedef/typedef.ts b/example/typedef/typedef.ts
index c89b52a56..6999df589 100644
--- a/example/typedef/typedef.ts
+++ b/example/typedef/typedef.ts
@@ -26,13 +26,20 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export { type Static, TSchema, PropertiesReduce, TReadonly, TReadonlyOptional, TOptional } from '@sinclair/typebox'
+export { Static, Evaluate, TSchema, PropertiesReduce, TReadonly, TReadonlyOptional, TOptional } from '@sinclair/typebox'
 import * as Types from '@sinclair/typebox'
 
 // --------------------------------------------------------------------------
-// Symbols
+// Utility Types
 // --------------------------------------------------------------------------
-export const Name = Symbol.for('TypeBox:Name')
+export type Assert<T, U> = T extends U ? T : never
+export type Base = { m: string, t: string }
+export type Base16 = { m: 'F', t: '01', '0': '1', '1': '2', '2': '3', '3': '4', '4': '5', '5': '6', '6': '7', '7': '8', '8': '9', '9': 'A', 'A': 'B', 'B': 'C', 'C': 'D', 'D': 'E', 'E': 'F', 'F': '0' }
+export type Base10 = { m: '9', t: '01', '0': '1', '1': '2', '2': '3', '3': '4', '4': '5', '5': '6', '6': '7', '7': '8', '8': '9', '9': '0' }
+export type Reverse<T extends string> = T extends `${infer L}${infer R}` ? `${Reverse<R>}${L}` : T
+export type Tick<T extends string, B extends Base> = T extends keyof B ? B[T] : never
+export type Next<T extends string, B extends Base> = T extends Assert<B, Base>['m'] ? Assert<B, Base>['t'] : T extends `${infer L}${infer R}` ? L extends Assert<B, Base>['m'] ? `${Assert<Tick<L, B>, string>}${Next<R, B>}` : `${Assert<Tick<L, B>, string>}${R}` : never
+export type Increment<T extends string, B extends Base = Base10> = Reverse<Next<Reverse<T>, B>>
 // --------------------------------------------------------------------------
 // TArray
 // --------------------------------------------------------------------------
@@ -50,6 +57,19 @@ export interface TBoolean extends Types.TSchema {
   type: 'boolean'
 }
 // --------------------------------------------------------------------------
+// TUnion
+// --------------------------------------------------------------------------
+type InferUnion<T extends TStruct[], D extends string, Index = string> = T extends [infer L, ...infer R]
+  ? Types.Evaluate<{ [_ in D]: Index } & Types.Static<Types.AssertType<L>>> | InferUnion<Types.AssertRest<R>, D, Increment<Types.Assert<Index, string>>>
+  : never
+
+export interface TUnion<T extends TStruct[] = TStruct[], D extends string = string> extends Types.TSchema {
+  [Types.Kind]: 'TypeDef:Union'
+  static: InferUnion<T, D, '0'>
+  discriminator: D,
+  mapping: T
+}
+// --------------------------------------------------------------------------
 // TEnum
 // --------------------------------------------------------------------------
 export interface TEnum<T extends string[] = string[]> extends Types.TSchema {
@@ -60,7 +80,7 @@ export interface TEnum<T extends string[] = string[]> extends Types.TSchema {
 // --------------------------------------------------------------------------
 // TFloat32
 // --------------------------------------------------------------------------
-export interface TFloat32 extends Types.TSchema  {
+export interface TFloat32 extends Types.TSchema {
   [Types.Kind]: 'TypeDef:Float32'
   type: 'float32'
   static: number
@@ -68,7 +88,7 @@ export interface TFloat32 extends Types.TSchema  {
 // --------------------------------------------------------------------------
 // TFloat64
 // --------------------------------------------------------------------------
-export interface TFloat64 extends Types.TSchema  {
+export interface TFloat64 extends Types.TSchema {
   [Types.Kind]: 'TypeDef:Float64'
   type: 'float64'
   static: number
@@ -76,7 +96,7 @@ export interface TFloat64 extends Types.TSchema  {
 // --------------------------------------------------------------------------
 // TInt8
 // --------------------------------------------------------------------------
-export interface TInt8 extends Types.TSchema  {
+export interface TInt8 extends Types.TSchema {
   [Types.Kind]: 'TypeDef:Int8'
   type: 'int8'
   static: number
@@ -84,7 +104,7 @@ export interface TInt8 extends Types.TSchema  {
 // --------------------------------------------------------------------------
 // TInt16
 // --------------------------------------------------------------------------
-export interface TInt16 extends Types.TSchema  {
+export interface TInt16 extends Types.TSchema {
   [Types.Kind]: 'TypeDef:Int16'
   type: 'int16'
   static: number
@@ -92,7 +112,7 @@ export interface TInt16 extends Types.TSchema  {
 // --------------------------------------------------------------------------
 // TInt32
 // --------------------------------------------------------------------------
-export interface TInt32 extends Types.TSchema  {
+export interface TInt32 extends Types.TSchema {
   [Types.Kind]: 'TypeDef:Int32'
   type: 'int32'
   static: number
@@ -100,7 +120,7 @@ export interface TInt32 extends Types.TSchema  {
 // --------------------------------------------------------------------------
 // TUint8
 // --------------------------------------------------------------------------
-export interface TUint8 extends Types.TSchema  {
+export interface TUint8 extends Types.TSchema {
   [Types.Kind]: 'TypeDef:Uint8'
   type: 'uint8'
   static: number
@@ -108,7 +128,7 @@ export interface TUint8 extends Types.TSchema  {
 // --------------------------------------------------------------------------
 // TUint16
 // --------------------------------------------------------------------------
-export interface TUint16 extends Types.TSchema  {
+export interface TUint16 extends Types.TSchema {
   [Types.Kind]: 'TypeDef:Uint16'
   type: 'uint16'
   static: number
@@ -148,12 +168,11 @@ type RequiredKeys<T extends TFields> = { [K in keyof T]: T[K] extends (Types.TRe
 export interface StructOptions {
   additionalProperties?: boolean
 }
-export interface TStruct<D extends string = string, T extends TFields = TFields> extends Types.TSchema, StructOptions {
-  [Name]: D
+export interface TStruct<T extends TFields = TFields> extends Types.TSchema, StructOptions {
   [Types.Kind]: 'TypeDef:Struct'
   static: Types.PropertiesReduce<T, this['params']>
-  optionalProperties: {[K in Types.Assert<OptionalKeys<T>, keyof T>]: T[K] }
-  properties: {[K in Types.Assert<RequiredKeys<T>, keyof T>]: T[K] }
+  optionalProperties: { [K in Types.Assert<OptionalKeys<T>, keyof T>]: T[K] }
+  properties: { [K in Types.Assert<RequiredKeys<T>, keyof T>]: T[K] }
 }
 // --------------------------------------------------------------------------
 // TTimestamp
@@ -163,43 +182,34 @@ export interface TTimestamp extends Types.TSchema {
   static: number
 }
 // --------------------------------------------------------------------------
-// TUnion
-// --------------------------------------------------------------------------
-export interface TUnion<D extends string = string, T extends TStruct[] = TStruct[]> extends Types.TSchema {
-  [Types.Kind]: 'TypeDef:Union'
-  static: Types.Evaluate<{ [K in keyof T]: { [key in D]: T[K][typeof Name] } & Types.Static<T[K]> }[number]>
-  discriminator: D, 
-  mapping: T
-}
-// --------------------------------------------------------------------------
 // TypeRegistry
 // --------------------------------------------------------------------------
-Types.TypeRegistry.Set<TArray>('TypeDef:Array', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TBoolean>('TypeDef:Boolean', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TInt8>('TypeDef:Int8', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TInt16>('TypeDef:Int16', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TInt32>('TypeDef:Int32', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TUint8>('TypeDef:Uint8', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TUint16>('TypeDef:Uint16', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TUint32>('TypeDef:Uint32', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TRecord>('TypeDef:Record', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TString>('TypeDef:String', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TStruct>('TypeDef:Struct', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TTimestamp>('TypeDef:Timestamp', (schema, value) => TypeDefCheck.Check(schema, value))
-Types.TypeRegistry.Set<TUnion>('TypeDef:Union', (schema, value) => TypeDefCheck.Check(schema, value))
-// --------------------------------------------------------------------------
-// TypeDefCheck
-// --------------------------------------------------------------------------
-export class TypeDefCheckUnionTypeError extends Error {
+Types.TypeRegistry.Set<TArray>('TypeDef:Array', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TBoolean>('TypeDef:Boolean', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TUnion>('TypeDef:Union', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TInt8>('TypeDef:Int8', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TInt16>('TypeDef:Int16', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TInt32>('TypeDef:Int32', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TUint8>('TypeDef:Uint8', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TUint16>('TypeDef:Uint16', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TUint32>('TypeDef:Uint32', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TRecord>('TypeDef:Record', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TString>('TypeDef:String', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TStruct>('TypeDef:Struct', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TTimestamp>('TypeDef:Timestamp', (schema, value) => ValueCheck.Check(schema, value))
+// --------------------------------------------------------------------------
+// ValueCheck
+// --------------------------------------------------------------------------
+export class ValueCheckError extends Error {
   constructor(public readonly schema: Types.TSchema) {
-    super('TypeDefCheck: Unknown type')
+    super('ValueCheck: Unknown type')
   }
 }
-export namespace TypeDefCheck {
+export namespace ValueCheck {
   // ------------------------------------------------------------------------
   // Guards
   // ------------------------------------------------------------------------
-  function IsObject(value: unknown): value is Record<keyof any, unknown> {
+  function IsObject(value: unknown): value is Record<keyof any, any> {
     return typeof value === 'object' && value !== null && !globalThis.Array.isArray(value)
   }
   function IsArray(value: unknown): value is unknown[] {
@@ -253,37 +263,46 @@ export namespace TypeDefCheck {
   function String(schema: TString, value: unknown): boolean {
     return typeof value === 'string'
   }
-  function Struct(schema: TStruct, value: unknown): boolean {
+  function Struct(schema: TStruct, value: unknown, descriminator?: string): boolean {
+    if (!IsObject(value)) return false
     const optionalKeys = schema.optionalProperties === undefined ? [] : globalThis.Object.getOwnPropertyNames(schema.optionalProperties)
     const requiredKeys = schema.properties === undefined ? [] : globalThis.Object.getOwnPropertyNames(schema.properties)
-    if(!(IsObject(value) && 
-      optionalKeys.every(key => key in value ? Visit((schema.optionalProperties as any)[key], value[key]) : true) &&
-      requiredKeys.every(key => key in value && Visit(((schema as any).properties[key] as any), value[key])))) return false
-    if(schema.additionalProperties === true) return true
     const unknownKeys = globalThis.Object.getOwnPropertyNames(value)
-    return unknownKeys.every(key => optionalKeys.includes(key) || requiredKeys.includes(key))
+    for (const requiredKey of requiredKeys) {
+      if (!(requiredKey in value)) return false
+      const requiredProperty = value[requiredKey]
+      const requiredSchema = (schema as any).properties[requiredKey]
+      if (!Visit(requiredSchema, requiredProperty)) return false
+    }
+    for (const optionalKey of optionalKeys) {
+      if (!(optionalKey in value)) continue
+      const optionalProperty = value[optionalKey]
+      const optionalSchema = (schema as any).properties[optionalKey]
+      if (!Visit(optionalSchema, optionalProperty)) return false
+    }
+    if (schema.additionalProperties === true) return true
+    const knownKeys = [...optionalKeys, ...requiredKeys]
+    for (const unknownKey of unknownKeys) if (!knownKeys.includes(unknownKey) && (descriminator !== undefined && unknownKey !== descriminator)) return false
+    for (const knownKey of knownKeys) if (!unknownKeys.includes(knownKey)) return false
+    return true
   }
   function Timestamp(schema: TString, value: unknown): boolean {
     return IsInt(value, 0, Number.MAX_SAFE_INTEGER)
   }
   function Union(schema: TUnion, value: unknown): boolean {
-    if (!(
-      IsObject(value) && 
-      schema.discriminator in value &&
-      IsString(value[schema.discriminator]) &&
-      value[schema.discriminator] as any in schema.mapping
-    )) return false
-    // We shouldn't create objects just to omit the discriminator (optimize)
-    const inner = globalThis.Object.keys(value).reduce((acc, key) => {
-      return key === schema.discriminator ? acc : { [key]: value[key] }
-    }, {})
-    return Visit(schema.mapping[value[schema.discriminator] as any], inner)
+    if (!IsObject(value)) return false
+    if (!(schema.discriminator in value)) return false
+    if (!IsString(value[schema.discriminator])) return false
+    if (!(value[schema.discriminator] in schema.mapping)) return false
+    const struct = schema.mapping[value[schema.discriminator]] as TStruct
+    return Struct(struct, value, schema.discriminator)
   }
   function Visit(schema: Types.TSchema, value: unknown): boolean {
     const anySchema = schema as any
-    switch(anySchema[Types.Kind]) {
+    switch (anySchema[Types.Kind]) {
       case 'TypeDef:Array': return Array(anySchema, value)
       case 'TypeDef:Boolean': return Boolean(anySchema, value)
+      case 'TypeDef:Union': return Union(anySchema, value)
       case 'TypeDef:Enum': return Enum(anySchema, value)
       case 'TypeDef:Float32': return Float32(anySchema, value)
       case 'TypeDef:Float64': return Float64(anySchema, value)
@@ -297,11 +316,10 @@ export namespace TypeDefCheck {
       case 'TypeDef:String': return String(anySchema, value)
       case 'TypeDef:Struct': return Struct(anySchema, value)
       case 'TypeDef:Timestamp': return Timestamp(anySchema, value)
-      case 'TypeDef:Union': return Union(anySchema, value)
-      default: throw new TypeDefCheckUnionTypeError(anySchema)
+      default: throw new ValueCheckError(anySchema)
     }
   }
-  export function Check(schema: Types.TSchema, value: unknown): boolean {
+  export function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T> {
     return Visit(schema, value)
   }
 }
@@ -325,83 +343,79 @@ export class TypeDefTypeBuilder extends Types.TypeBuilder {
     return { [Types.Modifier]: 'Readonly', ...schema }
   }
   // ------------------------------------------------------------------------
-  // Modifiers
+  // Types
   // ------------------------------------------------------------------------
-  /** `[Standard]` Creates a TypeDef Array type */
+  /** [Standard] Creates a Array type */
   public Array<T extends Types.TSchema>(elements: T): TArray<T> {
     return this.Create({ [Types.Kind]: 'TypeDef:Array', elements })
   }
-  /** `[Standard]` Creates a TypeDef Boolean type */
+  /** [Standard] Creates a Boolean type */
   public Boolean(): TBoolean {
     return this.Create({ [Types.Kind]: 'TypeDef:Boolean', type: 'boolean' })
   }
-  /** `[Standard]` Creates a TypeDef Enum type */
+  /** [Standard] Creates a Enum type */
   public Enum<T extends string[]>(values: [...T]): TEnum<T> {
     return this.Create({ [Types.Kind]: 'TypeDef:Enum', enum: values })
   }
-  /** `[Standard]` Creates a TypeDef Float32 type */
+  /** [Standard] Creates a Float32 type */
   public Float32(): TFloat32 {
     return this.Create({ [Types.Kind]: 'TypeDef:Float32', type: 'float32' })
   }
-  /** `[Standard]` Creates a TypeDef Float64 type */
+  /** [Standard] Creates a Float64 type */
   public Float64(): TFloat64 {
     return this.Create({ [Types.Kind]: 'TypeDef:Float64', type: 'float64' })
   }
-  /** `[Standard]` Creates a TypeDef Int8 type */
+  /** [Standard] Creates a Int8 type */
   public Int8(): TInt8 {
     return this.Create({ [Types.Kind]: 'TypeDef:Int8', type: 'int8' })
   }
-  /** `[Standard]` Creates a TypeDef Int16 type */
+  /** [Standard] Creates a Int16 type */
   public Int16(): TInt16 {
     return this.Create({ [Types.Kind]: 'TypeDef:Int16', type: 'int16' })
   }
-  /** `[Standard]` Creates a TypeDef Int32 type */
+  /** [Standard] Creates a Int32 type */
   public Int32(): TInt32 {
     return this.Create({ [Types.Kind]: 'TypeDef:Int32', type: 'int32' })
   }
-  /** `[Standard]` Creates a TypeDef Uint8 type */
+  /** [Standard] Creates a Uint8 type */
   public Uint8(): TUint8 {
     return this.Create({ [Types.Kind]: 'TypeDef:Uint8', type: 'uint8' })
   }
-  /** `[Standard]` Creates a TypeDef Uint16 type */
+  /** [Standard] Creates a Uint16 type */
   public Uint16(): TUint16 {
     return this.Create({ [Types.Kind]: 'TypeDef:Uint16', type: 'uint16' })
   }
-  /** `[Standard]` Creates a TypeDef Uint32 type */
+  /** [Standard] Creates a Uint32 type */
   public Uint32(): TUint32 {
     return this.Create({ [Types.Kind]: 'TypeDef:Uint32', type: 'uint32' })
   }
-  /** `[Standard]` Creates a TypeDef Record type */
+  /** [Standard] Creates a Record type */
   public Record<T extends Types.TSchema>(values: T): TRecord<T> {
-    return this.Create({ [Types.Kind]: 'TypeDef:Record',values })
+    return this.Create({ [Types.Kind]: 'TypeDef:Record', values })
   }
-  /** `[Standard]` Creates a TypeDef String type */
+  /** [Standard] Creates a String type */
   public String(): TString {
-    return this.Create({ [Types.Kind]: 'TypeDef:String',type: 'string' })
-  }  
-  /** `[Standard]` Creates a TypeDef Struct type */
-  public Struct<N extends string, T extends TFields>(name: N, fields: T, options?: StructOptions): TStruct<N, T> {
+    return this.Create({ [Types.Kind]: 'TypeDef:String', type: 'string' })
+  }
+  /** [Standard] Creates a Struct type */
+  public Struct<T extends TFields>(fields: T, options?: StructOptions): TStruct<T> {
     const optionalProperties = globalThis.Object.getOwnPropertyNames(fields).reduce((acc, key) => (Types.TypeGuard.TOptional(fields[key]) || Types.TypeGuard.TReadonlyOptional(fields[key]) ? { ...acc, [key]: fields[key] } : { ...acc }), {} as TFields)
-    const properties = globalThis.Object.getOwnPropertyNames(fields).reduce((acc, key) => (Types.TypeGuard.TOptional(fields[key]) || Types.TypeGuard.TReadonlyOptional(fields[key]) ? {... acc } : { ...acc, [key]: fields[key] }), {} as TFields)
-    const optionalPropertiesObject = globalThis.Object.getOwnPropertyNames(optionalProperties).length > 0 ? { optionalProperties: optionalProperties } : {}
-    const propertiesObject = globalThis.Object.getOwnPropertyNames(properties).length === 0 ? {} : { properties: properties }
-    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Struct', [Name]: name, ...propertiesObject, ...optionalPropertiesObject })
+    const properties = globalThis.Object.getOwnPropertyNames(fields).reduce((acc, key) => (Types.TypeGuard.TOptional(fields[key]) || Types.TypeGuard.TReadonlyOptional(fields[key]) ? { ...acc } : { ...acc, [key]: fields[key] }), {} as TFields)
+    const optionalObject = globalThis.Object.getOwnPropertyNames(optionalProperties).length > 0 ? { optionalProperties: optionalProperties } : {}
+    const requiredObject = globalThis.Object.getOwnPropertyNames(properties).length === 0 ? {} : { properties: properties }
+    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Struct', ...requiredObject, ...optionalObject })
+  }
+  /** [Standard] Creates a Union type */
+  public Union<T extends TStruct<TFields>[], D extends string = 'type'>(structs: [...T], discriminator?: D): TUnion<T, D> {
+    discriminator = (discriminator || 'type') as D
+    if (structs.length === 0) throw new Error('TypeDefTypeBuilder: Union types must contain at least one struct')
+    const mapping = structs.reduce((acc, current, index) => ({ ...acc, [index.toString()]: current }), {})
+    return this.Create({ [Types.Kind]: 'TypeDef:Union', discriminator, mapping })
   }
-  /** `[Standard]` Creates a TypeDef Timestamp type */
+  /** [Standard] Creates a Timestamp type */
   public Timestamp(): TTimestamp {
     return this.Create({ [Types.Kind]: 'TypeDef:Timestamp', type: 'timestamp' })
   }
-
-  /** `[Standard]` Creates a TypeDef Discriminated Union type */
-  public Union<D extends string, T extends TStruct<string, TFields>[]>(discriminator: D, objects: [...T]): TUnion<D, T> {
-    if(objects.length === 0) throw new Error('TypeDefTypeBuilder: Union types must have at least one object') 
-    const exists = objects.every(object => typeof object[Name] === 'string')
-    if(!exists) throw new Error('TypeDefTypeBuilder: All union objects MUST have a descriminator')
-    const unique = objects.reduce((set, current) => set.add(current[Name]), new Set<string>())
-    if(unique.size !== objects.length) throw new Error('TypeDefTypeBuilder: All union objects MUST unique descriminator strings')
-    const mapping = objects.reduce((acc, current) => ({ ...acc, [current[Name]]: current  }), {})
-    return this.Create({ [Types.Kind]: 'TypeDef:Union', discriminator, mapping })
-  }
 }
 
 /** JSON Type Definition Type Builder */
diff --git a/example/typemap/readme.md b/example/typemap/readme.md
deleted file mode 100644
index fdadd3ab2..000000000
--- a/example/typemap/readme.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# TypeMap
-
-TypeMap is a fluent type builder abstraction built on top of TypeBox. It is modelled after the Yup and Zod and libraries, but internally uses TypeBox for type composition, inference and runtime type assertion. It supports the same advanced compositional types as TypeBox (including generics, conditional, recursive and template literal types), but offers this functionality as a set of chainable lowercase types. 
-
-Like TypeBox, TypeMap internally uses JSON schema for its type representation. It provides access to the TypeBox compiler infrastructure with the `.compile()` and `.code()` methods which are available on all types, and access to the internal schema via `.schema()`. Types also implement `.check()` and `.cast()` for convenience. 
-
-TypeMap is implemented as an example for reference purposes only.
\ No newline at end of file
diff --git a/example/typemap/typemap.ts b/example/typemap/typemap.ts
deleted file mode 100644
index 9352ff370..000000000
--- a/example/typemap/typemap.ts
+++ /dev/null
@@ -1,496 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/typemap
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { TypeCompiler, ValueError, TypeCheck } from '@sinclair/typebox/compiler'
-import { Value, ValueErrorIterator } from '@sinclair/typebox/value'
-import { TypeSystem } from '@sinclair/typebox/system'
-import * as T from '@sinclair/typebox'
-
-// -------------------------------------------------------------------------------------------------
-// Formats
-// -------------------------------------------------------------------------------------------------
-// prettier-ignore
-TypeSystem.Format('email', (value) => /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(value))
-// prettier-ignore
-TypeSystem.Format('uuid', (value) => /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i.test(value))
-// prettier-ignore
-TypeSystem.Format('url', (value) => /^(?:https?|wss?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu.test(value))
-// prettier-ignore
-TypeSystem.Format('ipv6', (value) => /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i.test(value))
-// prettier-ignore
-TypeSystem.Format('ipv4', (value) => /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/.test(value))
-// -------------------------------------------------------------------------------------------------
-// Type Mapping
-// -------------------------------------------------------------------------------------------------
-export type TypeToType<T extends Type> = T extends Type<infer S> ? S : never
-export type TypeToTuple<T extends Type[]> = {
-  [K in keyof T]: T[K] extends Type<infer S> ? S : never
-}
-export type TypeToProperties<T extends PropertiesType> = T.Assert<
-  {
-    [K in keyof T]: T[K] extends Type<infer S> ? S : never
-  },
-  T.TProperties
->
-export type PropertiesType = Record<keyof any, Type>
-// prettier-ignore
-export type TemplateLiteralType = 
-  | Type<T.TUnion> 
-  | Type<T.TLiteral> 
-  | Type<T.TInteger>
-  | Type<T.TTemplateLiteral> 
-  | Type<T.TNumber> 
-  | Type<T.TBigInt> 
-  | Type<T.TString> 
-  | Type<T.TBoolean> 
-  | Type<T.TNever>;
-// -------------------------------------------------------------------------------------------------
-// Error
-// -------------------------------------------------------------------------------------------------
-export class TypeValueError extends Error {
-  constructor(public readonly errors: ValueError[]) {
-    super('TypeValueError: Invalid Value')
-  }
-}
-// -------------------------------------------------------------------------------------------------
-// Assert
-// -------------------------------------------------------------------------------------------------
-export interface TypeAssert<T extends T.TSchema> {
-  check(value: unknown): value is T.Static<T>
-  errors(value: unknown): ValueErrorIterator
-  code(): string
-}
-export class TypeAssertDynamic<T extends T.TSchema> implements TypeAssert<T> {
-  readonly #schema: T
-  constructor(schema: T) {
-    this.#schema = schema
-  }
-  public check(value: unknown): value is T.Static<T, []> {
-    return Value.Check(this.#schema, [], value)
-  }
-  public errors(value: unknown): ValueErrorIterator {
-    return Value.Errors(this.#schema, [], value)
-  }
-  public code(): string {
-    return TypeCompiler.Code(this.#schema)
-  }
-}
-export class TypeAssertCompiled<T extends T.TSchema> implements TypeAssert<T> {
-  readonly #typecheck: TypeCheck<T>
-  constructor(schema: T) {
-    this.#typecheck = TypeCompiler.Compile(schema)
-  }
-  public check(value: unknown): value is T.Static<T, []> {
-    return this.#typecheck.Check(value)
-  }
-  public errors(value: unknown): ValueErrorIterator {
-    return this.#typecheck.Errors(value)
-  }
-  public code(): string {
-    return this.#typecheck.Code()
-  }
-}
-// -----------------------------------------------------------------------------------------
-// Type
-// -----------------------------------------------------------------------------------------
-export class Type<T extends T.TSchema = T.TSchema> {
-  #assert: TypeAssert<T>
-  #schema: T
-  constructor(schema: T) {
-    this.#assert = new TypeAssertDynamic(schema)
-    this.#schema = schema
-  }
-  /** Augments this type with the given options */
-  public options(options: T.SchemaOptions) {
-    return new Type({ ...this.schema, ...options } as T)
-  }
-  /** Maps a property as readonly and optional */
-  public readonlyOptional(): Type<T.TReadonlyOptional<T>> {
-    return new Type(T.Type.ReadonlyOptional(this.#schema))
-  }
-  /** Maps a property as optional */
-  public optional(): Type<T.TOptional<T>> {
-    return new Type(T.Type.Optional(this.#schema))
-  }
-  /** Maps a property as readonly */
-  public readonly(): Type<T.TReadonly<T>> {
-    return new Type(T.Type.Readonly(this.#schema))
-  }
-  /** Composes this type as a intersect with the given type */
-  public and<U extends Type>(type: U): Type<T.TIntersect<[T, TypeToType<U>]>> {
-    return new Type(T.Type.Intersect([this.#schema, type.schema()])) as any
-  }
-  /** Composes this type as a union with the given type */
-  public or<U extends Type>(type: U): Type<T.TUnion<[T, TypeToType<U>]>> {
-    return new Type(T.Type.Union([this.#schema, type.schema()])) as any
-  }
-  /** Picks the given properties from this type */
-  public pick<K extends (keyof T.Static<T>)[]>(keys: readonly [...K]): Type<T.TPick<T, K[number]>>
-  /** Picks the given properties from this type */
-  public pick<K extends T.TUnion<T.TLiteral<string>[]>>(keys: K): Type<T.TPick<T, T.TUnionOfLiteral<K>>>
-  /** Picks the given properties from this type */
-  public pick<K extends T.TLiteral<string>>(key: K): Type<T.TPick<T, K['const']>>
-  /** Picks the given properties from this type */
-  public pick<K extends T.TNever>(key: K): Type<T.TPick<T, never>> {
-    return new Type(T.Type.Pick(this.#schema, key))
-  }
-  /** Omits the given properties from this type */
-  public omit<K extends (keyof T.Static<T>)[]>(keys: readonly [...K]): Type<T.TOmit<T, K[number]>>
-  /** Omits the given properties from this type */
-  public omit<K extends T.TUnion<T.TLiteral<string>[]>>(keys: K): Type<T.TOmit<T, T.TUnionOfLiteral<K>>>
-  /** Omits the given properties from this type */
-  public omit<K extends T.TLiteral<string>>(key: K): Type<T.TOmit<T, K['const']>>
-  /** Omits the given properties from this type */
-  public omit<K extends T.TNever>(key: K): Type<T.TOmit<T, never>> {
-    return new Type(T.Type.Omit(this.#schema, key))
-  }
-  /** Applies partial to this type */
-  public partial(): Type<T.TPartial<T>> {
-    return new Type(T.Type.Partial(this.#schema))
-  }
-  /** Applies required to this type */
-  public required(): Type<T.TRequired<T>> {
-    return new Type(T.Type.Required(this.schema()))
-  }
-  /** Returns the keys of this type */
-  public keyof(): Type<T.TKeyOf<T>> {
-    return new Type(T.Type.KeyOf(this.schema()))
-  }
-  /** Checks this value and throws if invalid */
-  public assert(value: unknown): void {
-    if (this.#assert.check(value)) return
-    throw new TypeValueError([...this.#assert.errors(value)])
-  }
-  /** Casts this value into this type */
-  public cast(value: unknown): T.Static<T> {
-    return Value.Cast(this.#schema, [], value)
-  }
-  /** Returns true if this value is valid for this type */
-  public check(value: unknown): value is T.Static<T> {
-    return this.#assert.check(value)
-  }
-  /** Returns the assertion code for this type */
-  public code(): string {
-    return this.#assert.code()
-  }
-  /** Creates a default value for this type */
-  public create(): T.Static<T> {
-    return Value.Create(this.#schema, [])
-  }
-  /** Sets a default value for this type */
-  public default(value: T.Static<T>): this {
-    return new Type({ ...this.#schema, default: value }) as this
-  }
-  /** Parses the given value and returns the valid if valid. Otherwise throw. */
-  public parse(value: unknown): T.Static<T> {
-    this.assert(value)
-    return value
-  }
-  /** Compiles this type */
-  public compile(): this {
-    const compiled = new Type(this.#schema)
-    compiled.#assert = new TypeAssertCompiled(this.#schema)
-    return compiled as this
-  }
-  /** Returns the schema associated with this type */
-  public schema(): T {
-    return Value.Clone(this.#schema)
-  }
-}
-// -----------------------------------------------------------------------------------------
-// Array
-// -----------------------------------------------------------------------------------------
-export class ArrayType<T extends T.TArray<T.TSchema>> extends Type<T> {
-  public maxItems(n: number) {
-    return this.options({ maxItems: n })
-  }
-  public minItems(n: number) {
-    return this.options({ minItems: n })
-  }
-  public length(n: number) {
-    return this.options({ minItems: n, maxItems: n })
-  }
-  public uniqueItems() {
-    return this.options({ uniqueItems: true })
-  }
-}
-// -----------------------------------------------------------------------------------------
-// Object
-// -----------------------------------------------------------------------------------------
-export class ObjectType<T extends T.TObject = T.TObject> extends Type<T> {
-  public strict() {
-    return this.options({ additionalProperties: false })
-  }
-}
-// -----------------------------------------------------------------------------------------
-// String
-// -----------------------------------------------------------------------------------------
-export class StringType extends Type<T.TString> {
-  public minLength(n: number) {
-    return this.options({ minLength: n })
-  }
-  public maxLength(n: number) {
-    return this.options({ maxLength: n })
-  }
-  public length(n: number) {
-    return this.options({ maxLength: n, minLength: n })
-  }
-  public email() {
-    return this.options({ format: 'email' })
-  }
-  public uuid() {
-    return this.options({ format: 'uuid' })
-  }
-  public url() {
-    return this.options({ format: 'url' })
-  }
-  public ipv6() {
-    return this.options({ format: 'ipv6' })
-  }
-  public ipv4() {
-    return this.options({ format: 'ipv4' })
-  }
-}
-// -----------------------------------------------------------------------------------------
-// Number
-// -----------------------------------------------------------------------------------------
-export class NumberType extends Type<T.TNumber> {
-  public exclusiveMinimum(n: number) {
-    return this.options({ exclusiveMinimum: n })
-  }
-  public minimum(n: number) {
-    return this.options({ minimum: n })
-  }
-  public exclusiveMaximum(n: number) {
-    return this.options({ exclusiveMaximum: n })
-  }
-  public maximum(n: number) {
-    return this.options({ maximum: n })
-  }
-  public multipleOf(n: number) {
-    return this.options({ multipleOf: n })
-  }
-  public positive() {
-    return this.options({ minimum: 0 })
-  }
-  public negative() {
-    return this.options({ maximum: 0 })
-  }
-}
-// -----------------------------------------------------------------------------------------
-// Integer
-// -----------------------------------------------------------------------------------------
-export class IntegerType extends Type<T.TInteger> {
-  public exclusiveMinimum(n: number) {
-    return this.options({ exclusiveMinimum: n })
-  }
-  public minimum(n: number) {
-    return this.options({ minimum: n })
-  }
-  public exclusiveMaximum(n: number) {
-    return this.options({ exclusiveMaximum: n })
-  }
-  public maximum(n: number) {
-    return this.options({ maximum: n })
-  }
-  public multipleOf(n: number) {
-    return this.options({ multipleOf: n })
-  }
-  public positive() {
-    return this.options({ minimum: 0 })
-  }
-  public negative() {
-    return this.options({ maximum: 0 })
-  }
-}
-// -----------------------------------------------------------------------------------------
-// BigInt
-// -----------------------------------------------------------------------------------------
-export class BigIntType extends Type<T.TBigInt> {
-  public exclusiveMinimum(n: bigint) {
-    return this.options({ exclusiveMinimum: n })
-  }
-  public minimum(n: bigint) {
-    return this.options({ minimum: n })
-  }
-  public exclusiveMaximum(n: bigint) {
-    return this.options({ exclusiveMaximum: n })
-  }
-  public maximum(n: bigint) {
-    return this.options({ maximum: n })
-  }
-  public multipleOf(n: bigint) {
-    return this.options({ multipleOf: n })
-  }
-  public positive() {
-    return this.options({ minimum: BigInt(0) })
-  }
-  public negative() {
-    return this.options({ maximum: BigInt(0) })
-  }
-}
-// -----------------------------------------------------------------------------------------
-// Uint8Array
-// -----------------------------------------------------------------------------------------
-export class ModelUint8Array<T extends T.TUint8Array> extends Type<T> {
-  public minByteLength(n: number) {
-    return this.options({ minByteLength: n })
-  }
-  public maxByteLength(n: number) {
-    return this.options({ maxByteLength: n })
-  }
-}
-// -----------------------------------------------------------------------------------------
-// Record
-// -----------------------------------------------------------------------------------------
-export class RecordType<T extends T.TSchema> extends Type<T.TRecord<T.TString, T>> {}
-// -----------------------------------------------------------------------------------------
-// Recursive
-// -----------------------------------------------------------------------------------------
-export class ThisType extends Type<T.TThis> {}
-export class RecursiveType<T extends T.TSchema = T.TSchema> extends Type<T> {}
-// -----------------------------------------------------------------------------------------
-// ModelBuilder
-// -----------------------------------------------------------------------------------------
-export class ModelBuilder {
-  /** Creates an any type */
-  public any() {
-    return new Type(T.Type.Any())
-  }
-  /** Creates an array type */
-  public array<T extends Type>(type: T) {
-    return new ArrayType(T.Type.Array(type.schema()))
-  }
-  /** Creates boolean type */
-  public boolean() {
-    return new Type(T.Type.Boolean())
-  }
-  /** Creates a bigint type */
-  public bigint() {
-    return new BigIntType(T.Type.BigInt())
-  }
-  /** Creates a date type */
-  public date() {
-    return new Type(T.Type.Date())
-  }
-  /** Creates a integer type */
-  public integer() {
-    return new IntegerType(T.Type.Integer())
-  }
-  /** Creates a number type */
-  public number() {
-    return new NumberType(T.Type.Number())
-  }
-  /** Creates a intersect type */
-  public intersect<T extends Type[]>(types: [...T]): Type<T.TIntersect<TypeToTuple<T>>> {
-    const internal = types.map((type) => type.schema())
-    return new Type(T.Type.Intersect(internal)) as any
-  }
-  /** Creates an keyof type */
-  public keyof<T extends Type>(type: T): Type<T.TKeyOf<TypeToType<T>>> {
-    return new Type(T.Type.KeyOf(type.schema())) as any
-  }
-  /** Creates a literal type */
-  public literal<T extends T.TLiteralValue>(value: T) {
-    return new Type(T.Type.Literal(value))
-  }
-  /** Creates a never type */
-  public never() {
-    return new Type(T.Type.Never())
-  }
-  /** Creates a null type */
-  public null() {
-    return new Type(T.Type.Null())
-  }
-  /** Creates a object type */
-  public object<T extends PropertiesType>(properties: T): Type<T.TObject<TypeToProperties<T>>> {
-    const mapped = Object.keys(properties).reduce((acc, key) => ({ ...acc, [key]: properties[key].schema() }), {} as T.TProperties)
-    return new ObjectType(T.Type.Object(mapped)) as any
-  }
-  /** Creates a partial type */
-  public partial<T extends Type>(type: T): Type<TypeToType<T>> {
-    return new Type(T.Type.Partial(type.schema())) as any
-  }
-  /** Creates a promise type */
-  public promise<T extends Type>(type: T): Type<TypeToType<T>> {
-    return new Type(T.Type.Promise(type.schema())) as any
-  }
-  /** Creates an unknown type */
-  public unknown() {
-    return new Type(T.Type.Unknown())
-  }
-  /** Creates a record type */
-  public record<T extends Type>(type: T): RecordType<TypeToType<T>> {
-    return new Type(T.Type.Record(T.Type.String(), type.schema())) as any
-  }
-  /** Creates a recursive type */
-  public recursive<T extends T.TSchema>(callback: (This: ThisType) => Type<T>) {
-    // prettier-ignore
-    return new Type(T.Type.Recursive((This) => callback(new ThisType(This)).schema()))
-  }
-  /** Creates a required type */
-  public required<T extends Type>(type: T) {
-    return new Type(T.Type.Required(type.schema()))
-  }
-  /** Creates a string type */
-  public string() {
-    return new StringType(T.Type.String())
-  }
-  /** Creates a symbol type */
-  public symbol() {
-    return new Type(T.Type.Symbol())
-  }
-  /** Creates a template literal type */
-  public templateLiteral<T extends TemplateLiteralType[]>(types: [...T]): Type<T.TTemplateLiteral<TypeToTuple<T>>> {
-    const mapped = types.map((type) => type.schema())
-    return new Type(T.Type.TemplateLiteral(mapped as any))
-  }
-  /** Creates a tuple type */
-  public tuple<T extends Type[]>(types: [...T]): Type<T.TTuple<TypeToTuple<T>>> {
-    return new Type(T.Type.Tuple(types.map((type) => type.schema()))) as any
-  }
-  /** Creates a uint8array type */
-  public uint8array() {
-    return new Type(T.Type.Uint8Array())
-  }
-  /** Creates an undefined type */
-  public undefined() {
-    return new Type(T.Type.Undefined())
-  }
-  /** Creates a union type */
-  public union<T extends Type[]>(union: [...T]): Type<T.TUnion<TypeToTuple<T>>> {
-    const mapped = union.map((type) => type.schema())
-    return new Type(T.Type.Union(mapped)) as any
-  }
-}
-
-export type Infer<T extends Type> = T extends Type<infer S> ? T.Static<S> : unknown
-
-export const TypeBuilder = new ModelBuilder()
-
-export default TypeBuilder
diff --git a/hammer.mjs b/hammer.mjs
index a6bca8b8b..61e8b06aa 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -5,59 +5,59 @@ import { readFileSync } from 'fs'
 // Clean
 // -------------------------------------------------------------------------------
 export async function clean() {
-	await folder('target').delete()
+  await folder('target').delete()
 }
 // -------------------------------------------------------------------------------
 // Format
 // -------------------------------------------------------------------------------
 export async function format() {
-	await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test example/index.ts benchmark')
+  await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test example/index.ts benchmark')
 }
 // -------------------------------------------------------------------------------
 // Start
 // -------------------------------------------------------------------------------
 export async function start(example = 'index') {
-	await shell(`hammer run example/${example}.ts --dist target/example/${example}`)
+  await shell(`hammer run example/${example}.ts --dist target/example/${example}`)
 }
 // -------------------------------------------------------------------------------
 // Benchmark
 // -------------------------------------------------------------------------------
 export async function benchmark() {
-	await compression()
-	await measurement()
+  await compression()
+  await measurement()
 }
 // -------------------------------------------------------------------------------
 // Test
 // -------------------------------------------------------------------------------
 export async function test_static() {
-	await shell(`tsc -p test/static/tsconfig.json --noEmit --strict`)
+  await shell(`tsc -p test/static/tsconfig.json --noEmit --strict`)
 }
 export async function test_runtime(filter = '') {
-	await shell(`hammer build ./test/runtime/index.ts --dist target/test/runtime --platform node`)
-	await shell(`mocha target/test/runtime/index.js -g "${filter}"`)
+  await shell(`hammer build ./test/runtime/index.ts --dist target/test/runtime --platform node`)
+  await shell(`mocha target/test/runtime/index.js -g "${filter}"`)
 }
 export async function test(filter = '') {
-	await test_static()
-	await test_runtime(filter)
+  await test_static()
+  await test_runtime(filter)
 }
 // -------------------------------------------------------------------------------
 // Build
 // -------------------------------------------------------------------------------
 export async function build(target = 'target/build') {
-	await test()
-	await folder(target).delete()
-	await shell(`tsc -p ./src/tsconfig.json --outDir ${target}`)
-	await folder(target).add('package.json')
-	await folder(target).add('readme.md')
-	await folder(target).add('license')
-	await shell(`cd ${target} && npm pack`)
+  await test()
+  await folder(target).delete()
+  await shell(`tsc -p ./src/tsconfig.json --outDir ${target}`)
+  await folder(target).add('package.json')
+  await folder(target).add('readme.md')
+  await folder(target).add('license')
+  await shell(`cd ${target} && npm pack`)
 }
 // -------------------------------------------------------------
 // Publish
 // -------------------------------------------------------------
 export async function publish(otp, target = 'target/build') {
-	const { version } = JSON.parse(readFileSync('package.json', 'utf8'))
-	await shell(`cd ${target} && npm publish sinclair-typebox-${version}.tgz --access=public --otp ${otp}`)
-	await shell(`git tag ${version}`)
-	await shell(`git push origin ${version}`)
+  const { version } = JSON.parse(readFileSync('package.json', 'utf8'))
+  await shell(`cd ${target} && npm publish sinclair-typebox-${version}.tgz --access=public --otp ${otp}`)
+  await shell(`git tag ${version}`)
+  await shell(`git push origin ${version}`)
 }
\ No newline at end of file

From 2e8818e71dbc30abbfa9ec3f4a96e85c85d2c410 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 6 Jul 2023 10:09:47 +0900
Subject: [PATCH 158/369] Composite Type Optimization (#492)

---
 hammer.mjs               |  7 ++++
 package-lock.json        |  4 +-
 package.json             |  7 +++-
 readme.md                | 58 +++++++++++++++++-----------
 src/typebox.ts           | 33 ++++++++++------
 test/static/composite.ts | 82 ++++++++++++++++++++++++++++++++--------
 6 files changed, 137 insertions(+), 54 deletions(-)

diff --git a/hammer.mjs b/hammer.mjs
index 61e8b06aa..5f37c1eb7 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -29,7 +29,14 @@ export async function benchmark() {
 // -------------------------------------------------------------------------------
 // Test
 // -------------------------------------------------------------------------------
+export async function test_typescript() {
+  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', 'next', 'latest']) {
+    await shell(`npm install typescript@${version} --no-save`)
+    await test_static()
+  }
+}
 export async function test_static() {
+  await shell(`tsc -v`)
   await shell(`tsc -p test/static/tsconfig.json --noEmit --strict`)
 }
 export async function test_runtime(filter = '') {
diff --git a/package-lock.json b/package-lock.json
index 31f90d3b1..7b9cb58d1 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.29.3",
+  "version": "0.29.4",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.29.3",
+      "version": "0.29.4",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 2971f5b17..1212620a3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.29.3",
+  "version": "0.29.4",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -24,10 +24,13 @@
     "url": "https://github.com/sinclairzx81/typebox"
   },
   "scripts": {
+    "test:typescript": "hammer task test_typescript",
+    "test:static": "hammer task test_static",
+    "test:runtime": "hammer task test_runtime",
+    "test": "hammer task test",
     "clean": "hammer task clean",
     "format": "hammer task format",
     "start": "hammer task start",
-    "test": "hammer task test",
     "benchmark": "hammer task benchmark",
     "build": "hammer task build",
     "publish": "hammer task publish"
diff --git a/readme.md b/readme.md
index 68c792208..4bf1b532b 100644
--- a/readme.md
+++ b/readme.md
@@ -335,15 +335,15 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Composite([     │ type I = {                  │ const T = {                    │
+│ const T = Type.Composite([     │ type T = {                  │ const T = {                    │
 │   Type.Object({                │   x: number                 │   type: 'object',              │
 │     x: Type.Number()           │ } & {                       │   required: ['x', 'y'],        │
 │   }),                          │   y: number                 │   properties: {                │
 │   Type.Object({                │ }                           │     x: {                       │
 │     y: Type.Number()           │                             │       type: 'number'           │
-│   })                           │ type T = {                  │     },                         │
-│ ])                             │   [K in keyof I]: I[K]      │     y: {                       │
-│                                │ }                           │       type: 'number'           │
+│   })                           │                             │     },                         │
+│ ])                             │                             │     y: {                       │
+│                                │                             │       type: 'number'           │
 │                                │                             │     }                          │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
@@ -739,12 +739,12 @@ const R = Type.Ref(T)                                // const R = {
 
 ### Recursive Types
 
-Recursive types are supported with `Type.Recursive`
+Recursive types are supported with `Type.Recursive`.
 
 ```typescript
-const Node = Type.Recursive(Node => Type.Object({    // const Node = {
+const Node = Type.Recursive(This => Type.Object({    // const Node = {
   id: Type.String(),                                 //   $id: 'Node',
-  nodes: Type.Array(Node)                            //   type: 'object',
+  nodes: Type.Array(This)                            //   type: 'object',
 }), { $id: 'Node' })                                 //   properties: {
                                                      //     id: {
                                                      //       type: 'string'
@@ -776,38 +776,50 @@ function test(node: Node) {
 
 ### Conditional Types
 
-Conditional types are supported with `Type.Extends`, `Type.Exclude` and `Type.Extract`
+TypeBox supports conditional types with `Type.Extends`. This type will perform a structural assignment check for the first two parameters and return a `true` or `false` type from the second two parameters. The types `Type.Exclude` and `Type.Extract` are also supported.
 
 ```typescript
 // TypeScript
 
 type T0 = string extends number ? true : false       // type T0 = false
 
-type T1 = Extract<string | number, number>           // type T1 = number
+type T1 = Extract<(1 | 2 | 3), 1>                    // type T1 = 1
 
-type T2 = Exclude<string | number, number>           // type T2 = string
+type T2 = Exclude<(1 | 2 | 3), 1>                    // type T2 = 2 | 3
 
 // TypeBox
 
-const T0 = Type.Extends(Type.String(), Type.Number(), Type.Literal(true), Type.Literal(false))
-
-const T1 = Type.Extract(Type.Union([Type.String(), Type.Number()]), Type.Number())
-
-const T2 = Type.Exclude(Type.Union([Type.String(), Type.Number()]), Type.Number())
-
-
-type T0 = Static<typeof T0>                        // type T0 = false
+const T0 = Type.Extends(                             // const T0: TLiteral<false>
+  Type.String(), 
+  Type.Number(), 
+  Type.Literal(true), 
+  Type.Literal(false)
+)
 
-type T1 = Static<typeof T1>                        // type T1 = number
+const T1 = Type.Extract(                             // const T1: TLiteral<1>
+  Type.Union([
+    Type.Literal(1), 
+    Type.Literal(2), 
+    Type.Literal(3) 
+  ]), 
+  Type.Literal(1)
+)
 
-type T2 = Static<typeof T2>                        // type T2 = string
+const T2 = Type.Exclude(                            // const T2: TUnion<[
+  Type.Union([                                      //   TLiteral<2>,
+    Type.Literal(1),                                //   TLiteral<3>
+    Type.Literal(2),                                // ]>
+    Type.Literal(3) 
+  ]), 
+  Type.Literal(1)
+)
 ```
 
 <a name='types-template-literal'></a>
 
 ### Template Literal Types
 
-TypeBox supports Template Literal types using `Type.TemplateLiteral`. These types can be created using a simple template DSL syntax, however more complex template literals can be created by passing an array of literal and union types. The examples below show the template DSL syntax.
+TypeBox supports template literal types with `Type.TemplateLiteral`. This type implements an embedded DSL syntax to match the TypeScript template literal syntax. This type can also be composed by passing an array of union and literal types as parameters. The following example shows the DSL syntax.
 
 ```typescript
 // TypeScript
@@ -853,7 +865,7 @@ const R = Type.Record(T, Type.String())              // const R = {
 
 ### Indexed Access Types
 
-TypeBox supports Indexed Access types using `Type.Index`. This feature provides a consistent way to access property types without having to extract them from the underlying schema representation. Indexed accessors are supported for object and tuples, as well as nested union and intersect types.
+TypeBox supports indexed access types using `Type.Index`. This type provides a consistent way to access interior property and array element types without having to extract them from the underlying schema representation. Indexed access types are supported for object, array, tuple, union and intersect types.
 
 ```typescript
 const T = Type.Object({                              // const T = {
@@ -888,7 +900,7 @@ const C = Type.Index(T, Type.KeyOf(T))               // const C = {
 
 ### Not Types
 
-TypeBox has partial support for the JSON schema `not` keyword with `Type.Not`. This type is synonymous with the concept of a [negated types](https://github.com/microsoft/TypeScript/issues/4196) which are not supported in the TypeScript language. TypeBox does provide partial inference support via the intersection of `T & not U` (where all negated types infer as `unknown`). This can be used in the following context.
+TypeBox provides support for the `not` keyword with `Type.Not`. This type is synonymous with [negated types](https://github.com/microsoft/TypeScript/issues/4196) which are not supported in the TypeScript language. Partial inference of this type can be attained via the intersection of `T & not U` (where all Not types infer as `unknown`). This approach can be used to narrow for broader types in the following context.
 
 ```typescript
 // TypeScript
diff --git a/src/typebox.ts b/src/typebox.ts
index f67705d80..0c9945cf7 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -241,16 +241,20 @@ export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['retur
 // TComposite
 // --------------------------------------------------------------------------
 // prettier-ignore
-export type TCompositeReduce<T extends TIntersect<TObject[]>, K extends string[]> = K extends [infer L, ...infer R] 
-  ? { [_ in Assert<L, string>]: TIndexType<T, Assert<L, string>> } & TCompositeReduce<T, Assert<R, string[]>> 
-  : {}
+export type TCompositeKeys<T extends TObject[]> = T extends [infer L, ...infer R] 
+  ? keyof Assert<L, TObject>['properties'] | TCompositeKeys<Assert<R, TObject[]>>
+  : never
 // prettier-ignore
-export type TCompositeSelect<T extends TIntersect<TObject[]>> = UnionToTuple<keyof Static<T>> extends infer K 
-  ? Evaluate<TCompositeReduce<T, Assert<K, string[]>>> 
+export type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[]> = K extends [infer L, ...infer R] 
+  ? { [_ in Assert<L, string>]: TIndexType<T, Assert<L, string>> } & TCompositeIndex<T, Assert<R, string[]>> 
   : {}
 // prettier-ignore
-export type TComposite<T extends TObject[]> = TIntersect<T> extends infer R 
-  ? TObject<TCompositeSelect<Assert<R, TIntersect<TObject[]>>>>
+export type TCompositeReduce<T extends TObject[]> = UnionToTuple<TCompositeKeys<T>> extends infer K 
+  ? Evaluate<TCompositeIndex<TIntersect<T>, Assert<K, string[]>>> 
+  : {} //                    ^ indexed via intersection of T
+// prettier-ignore
+export type TComposite<T extends TObject[]> = TIntersect<T> extends TIntersect 
+  ? TObject<TCompositeReduce<T>>
   : TObject<{}>
 // --------------------------------------------------------------------------
 // TConstructor
@@ -640,12 +644,21 @@ export type StringFormatOption =
   | 'json-pointer'
   | 'relative-json-pointer'
   | 'regex'
+  | ({} & string)
+// prettier-ignore
+export type StringContentEncodingOption = 
+  | '7bit' 
+  | '8bit' 
+  | 'binary' 
+  | 'quoted-printable' 
+  | 'base64' 
+  | ({} & string)
 export interface StringOptions extends SchemaOptions {
   minLength?: number
   maxLength?: number
   pattern?: string
-  format?: string
-  contentEncoding?: '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64'
+  format?: StringFormatOption
+  contentEncoding?: StringContentEncodingOption
   contentMediaType?: string
 }
 export interface TString extends TSchema, StringOptions {
@@ -731,9 +744,7 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
 // TTuple
 // --------------------------------------------------------------------------
 export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? AssertRest<R> : never
-
 export type TTupleInfer<T extends TSchema[], P extends unknown[]> = T extends [infer L, ...infer R] ? [Static<AssertType<L>, P>, ...TTupleInfer<AssertRest<R>, P>] : []
-
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
   [Kind]: 'Tuple'
   static: TTupleInfer<T, this['params']> // { [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : T[K] }
diff --git a/test/static/composite.ts b/test/static/composite.ts
index b4399e20f..cf9bb88a0 100644
--- a/test/static/composite.ts
+++ b/test/static/composite.ts
@@ -1,7 +1,9 @@
 import { Expect } from './assert'
-import { Type, Static } from '@sinclair/typebox'
+import { Type, TObject, TIntersect, TNumber, TBoolean } from '@sinclair/typebox'
 
+// ----------------------------------------------------------------------------
 // Overlapping - Non Varying
+// ----------------------------------------------------------------------------
 {
   const A = Type.Object({
     A: Type.Number(),
@@ -15,7 +17,9 @@ import { Type, Static } from '@sinclair/typebox'
     A: number
   }>()
 }
+// ----------------------------------------------------------------------------
 // Overlapping - Varying
+// ----------------------------------------------------------------------------
 {
   const A = Type.Object({
     A: Type.Number(),
@@ -29,7 +33,9 @@ import { Type, Static } from '@sinclair/typebox'
     A: never
   }>()
 }
+// ----------------------------------------------------------------------------
 // Overlapping Single Optional
+// ----------------------------------------------------------------------------
 {
   const A = Type.Object({
     A: Type.Optional(Type.Number()),
@@ -43,26 +49,50 @@ import { Type, Static } from '@sinclair/typebox'
     A: number
   }>()
 }
+// ----------------------------------------------------------------------------
 // Overlapping All Optional (Deferred)
+//
 // Note for: https://github.com/sinclairzx81/typebox/issues/419
-// Determining if a composite property is optional requires a deep check for all properties gathered during a indexed access
-// call. Currently, there isn't a trivial way to perform this check without running into possibly infinite instantiation issues.
-// The optional check is only specific to overlapping properties. Singular properties will continue to work as expected. The
-// rule is "if all composite properties for a key are optional, then the composite property is optional". Defer this test and
-// document as minor breaking change.
+// ----------------------------------------------------------------------------
 {
-  // const A = Type.Object({
-  //   A: Type.Optional(Type.Number()),
-  // })
-  // const B = Type.Object({
-  //   A: Type.Optional(Type.Number()),
-  // })
-  // const T = Type.Composite([A, B])
-  // Expect(T).ToInfer<{
-  //   A: number | undefined
-  // }>()
+  const A = Type.Object({
+    A: Type.Optional(Type.Number()),
+  })
+  const B = Type.Object({
+    A: Type.Optional(Type.Number()),
+  })
+  const T = Type.Composite([A, B])
+  Expect(T).ToInfer<{
+    A: number | undefined
+  }>()
 }
+{
+  const A = Type.Object({
+    A: Type.Optional(Type.Number()),
+  })
+  const B = Type.Object({
+    A: Type.Number(),
+  })
+  const T = Type.Composite([A, B])
+  Expect(T).ToInfer<{
+    A: number
+  }>()
+}
+{
+  const A = Type.Object({
+    A: Type.Number(),
+  })
+  const B = Type.Object({
+    A: Type.Number(),
+  })
+  const T = Type.Composite([A, B])
+  Expect(T).ToInfer<{
+    A: number
+  }>()
+}
+// ----------------------------------------------------------------------------
 // Distinct Properties
+// ----------------------------------------------------------------------------
 {
   const A = Type.Object({
     A: Type.Number(),
@@ -77,3 +107,23 @@ import { Type, Static } from '@sinclair/typebox'
     B: number
   }>()
 }
+// ----------------------------------------------------------------------------
+// Intersection Quirk
+//
+// TypeScript has an evaluation quirk for the following case where the first
+// type evaluates the sub property as never, but the second evaluates the
+// entire type as never. There is probably a reason for this behavior, but
+// TypeBox supports the former evaluation.
+//
+// { x: number } & { x: string }  -> { x: number } & { x: string } => { x: never }
+// { x: number } & { x: boolean } ->  never -> ...
+// ----------------------------------------------------------------------------
+{
+  // prettier-ignore
+  const T: TObject<{
+    x: TIntersect<[TNumber, TBoolean]>
+  }> = Type.Composite([
+    Type.Object({ x: Type.Number() }),
+    Type.Object({ x: Type.Boolean() })
+  ])
+}

From 3dce951e8b0b9d204299251e985275c72fa9c0e6 Mon Sep 17 00:00:00 2001
From: Andrew Smiley <jayalfredprufrock@gmail.com>
Date: Tue, 18 Jul 2023 13:04:34 -0400
Subject: [PATCH 159/369] Resolve Max Properties Error Message (#501)

---
 src/errors/errors.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index aa5fe28be..92663dcc8 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -342,7 +342,7 @@ export namespace ValueErrors {
       yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` }
     }
     if (IsDefined<number>(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-      yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` }
+      yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.maxProperties} properties` }
     }
     const requiredKeys = globalThis.Array.isArray(schema.required) ? schema.required : ([] as string[])
     const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties)

From b19575f16a84b5f92cfedefb01075ce402352e85 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 19 Jul 2023 02:06:39 +0900
Subject: [PATCH 160/369] Revision 0.29.5

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 1212620a3..3077ceb3e 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.29.4",
+  "version": "0.29.5",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

From 2bf9244b0a782dc0bf8438d3fae011b72fef9545 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 19 Jul 2023 02:25:31 +0900
Subject: [PATCH 161/369] Resolve Max Properties Error Message (#502)

---
 package.json         | 2 +-
 src/errors/errors.ts | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/package.json b/package.json
index 3077ceb3e..71c6e2c79 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.29.5",
+  "version": "0.29.6",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 92663dcc8..73e76bec7 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -342,7 +342,7 @@ export namespace ValueErrors {
       yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` }
     }
     if (IsDefined<number>(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-      yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.maxProperties} properties` }
+      yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have no more than ${schema.maxProperties} properties` }
     }
     const requiredKeys = globalThis.Array.isArray(schema.required) ? schema.required : ([] as string[])
     const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties)
@@ -391,7 +391,7 @@ export namespace ValueErrors {
       yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` }
     }
     if (IsDefined<number>(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-      yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` }
+      yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have no more than ${schema.maxProperties} properties` }
     }
     const [patternKey, patternSchema] = globalThis.Object.entries(schema.patternProperties)[0]
     const regex = new RegExp(patternKey)

From da4944361ba87dcb959ccba05750d6c3e262bf16 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 22 Jul 2023 21:08:48 +0900
Subject: [PATCH 162/369] TypeGuards for TypeDef (#504)

---
 example/typedef/typedef.ts | 253 ++++++++++++++++++++++++++++++-------
 1 file changed, 204 insertions(+), 49 deletions(-)

diff --git a/example/typedef/typedef.ts b/example/typedef/typedef.ts
index 6999df589..cfec35e41 100644
--- a/example/typedef/typedef.ts
+++ b/example/typedef/typedef.ts
@@ -26,7 +26,6 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export { Static, Evaluate, TSchema, PropertiesReduce, TReadonly, TReadonlyOptional, TOptional } from '@sinclair/typebox'
 import * as Types from '@sinclair/typebox'
 
 // --------------------------------------------------------------------------
@@ -41,6 +40,12 @@ export type Tick<T extends string, B extends Base> = T extends keyof B ? B[T] :
 export type Next<T extends string, B extends Base> = T extends Assert<B, Base>['m'] ? Assert<B, Base>['t'] : T extends `${infer L}${infer R}` ? L extends Assert<B, Base>['m'] ? `${Assert<Tick<L, B>, string>}${Next<R, B>}` : `${Assert<Tick<L, B>, string>}${R}` : never
 export type Increment<T extends string, B extends Base = Base10> = Reverse<Next<Reverse<T>, B>>
 // --------------------------------------------------------------------------
+// SchemaOptions
+// --------------------------------------------------------------------------
+export interface SchemaOptions {
+  [name: string]: any
+}
+// --------------------------------------------------------------------------
 // TArray
 // --------------------------------------------------------------------------
 export interface TArray<T extends Types.TSchema = Types.TSchema> extends Types.TSchema {
@@ -158,6 +163,7 @@ export interface TRecord<T extends Types.TSchema = Types.TSchema> extends Types.
 // --------------------------------------------------------------------------
 export interface TString extends Types.TSchema {
   [Types.Kind]: 'TypeDef:String'
+  type: 'string'
   static: string
 }
 // --------------------------------------------------------------------------
@@ -165,7 +171,7 @@ export interface TString extends Types.TSchema {
 // --------------------------------------------------------------------------
 type OptionalKeys<T extends TFields> = { [K in keyof T]: T[K] extends (Types.TReadonlyOptional<T[K]> | Types.TOptional<T[K]>) ? T[K] : never }
 type RequiredKeys<T extends TFields> = { [K in keyof T]: T[K] extends (Types.TReadonlyOptional<T[K]> | Types.TOptional<T[K]>) ? never : T[K] }
-export interface StructOptions {
+export interface StructOptions extends SchemaOptions {
   additionalProperties?: boolean
 }
 export interface TStruct<T extends TFields = TFields> extends Types.TSchema, StructOptions {
@@ -179,24 +185,52 @@ export interface TStruct<T extends TFields = TFields> extends Types.TSchema, Str
 // --------------------------------------------------------------------------
 export interface TTimestamp extends Types.TSchema {
   [Types.Kind]: 'TypeDef:Timestamp'
-  static: number
+  type: 'timestamp'
+  static: string
 }
 // --------------------------------------------------------------------------
-// TypeRegistry
-// --------------------------------------------------------------------------
-Types.TypeRegistry.Set<TArray>('TypeDef:Array', (schema, value) => ValueCheck.Check(schema, value))
-Types.TypeRegistry.Set<TBoolean>('TypeDef:Boolean', (schema, value) => ValueCheck.Check(schema, value))
-Types.TypeRegistry.Set<TUnion>('TypeDef:Union', (schema, value) => ValueCheck.Check(schema, value))
-Types.TypeRegistry.Set<TInt8>('TypeDef:Int8', (schema, value) => ValueCheck.Check(schema, value))
-Types.TypeRegistry.Set<TInt16>('TypeDef:Int16', (schema, value) => ValueCheck.Check(schema, value))
-Types.TypeRegistry.Set<TInt32>('TypeDef:Int32', (schema, value) => ValueCheck.Check(schema, value))
-Types.TypeRegistry.Set<TUint8>('TypeDef:Uint8', (schema, value) => ValueCheck.Check(schema, value))
-Types.TypeRegistry.Set<TUint16>('TypeDef:Uint16', (schema, value) => ValueCheck.Check(schema, value))
-Types.TypeRegistry.Set<TUint32>('TypeDef:Uint32', (schema, value) => ValueCheck.Check(schema, value))
-Types.TypeRegistry.Set<TRecord>('TypeDef:Record', (schema, value) => ValueCheck.Check(schema, value))
-Types.TypeRegistry.Set<TString>('TypeDef:String', (schema, value) => ValueCheck.Check(schema, value))
-Types.TypeRegistry.Set<TStruct>('TypeDef:Struct', (schema, value) => ValueCheck.Check(schema, value))
-Types.TypeRegistry.Set<TTimestamp>('TypeDef:Timestamp', (schema, value) => ValueCheck.Check(schema, value))
+// TimestampFormat
+// --------------------------------------------------------------------------
+export namespace TimestampFormat {
+  const DATE_TIME_SEPARATOR = /t|\s/i
+  const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i
+  const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/
+  const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+  function IsLeapYear(year: number): boolean {
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)
+  }
+  function IsDate(str: string): boolean {
+    const matches: string[] | null = DATE.exec(str)
+    if (!matches) return false
+    const year: number = +matches[1]
+    const month: number = +matches[2]
+    const day: number = +matches[3]
+    return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && IsLeapYear(year) ? 29 : DAYS[month])
+  }
+  function IsTime(str: string, strictTimeZone?: boolean): boolean {
+    const matches: string[] | null = TIME.exec(str)
+    if (!matches) return false
+    const hr: number = +matches[1]
+    const min: number = +matches[2]
+    const sec: number = +matches[3]
+    const tz: string | undefined = matches[4]
+    const tzSign: number = matches[5] === '-' ? -1 : 1
+    const tzH: number = +(matches[6] || 0)
+    const tzM: number = +(matches[7] || 0)
+    if (tzH > 23 || tzM > 59 || (strictTimeZone && !tz)) return false
+    if (hr <= 23 && min <= 59 && sec < 60) return true
+    const utcMin = min - tzM * tzSign
+    const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0)
+    return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61
+  }
+  function IsDateTime(value: string, strictTimeZone?: boolean): boolean {
+    const dateTime: string[] = value.split(DATE_TIME_SEPARATOR)
+    return dateTime.length === 2 && IsDate(dateTime[0]) && IsTime(dateTime[1], strictTimeZone)
+  }
+  export function Check(value: string): boolean {
+    return IsDateTime(value)
+  }
+}
 // --------------------------------------------------------------------------
 // ValueCheck
 // --------------------------------------------------------------------------
@@ -287,7 +321,7 @@ export namespace ValueCheck {
     return true
   }
   function Timestamp(schema: TString, value: unknown): boolean {
-    return IsInt(value, 0, Number.MAX_SAFE_INTEGER)
+    return IsString(value) && TimestampFormat.Check(value)
   }
   function Union(schema: TUnion, value: unknown): boolean {
     if (!IsObject(value)) return false
@@ -324,9 +358,130 @@ export namespace ValueCheck {
   }
 }
 // --------------------------------------------------------------------------
-// TypeDefTypeBuilder
+// TypeGuard
+// --------------------------------------------------------------------------
+export namespace TypeGuard {
+  // ------------------------------------------------------------------------
+  // Guards
+  // ------------------------------------------------------------------------
+  function IsObject(value: unknown): value is Record<keyof any, unknown> {
+    return typeof value === 'object'
+  }
+  function IsArray(value: unknown): value is unknown[] {
+    return globalThis.Array.isArray(value)
+  }
+  function IsOptionalBoolean(value: unknown): value is boolean | undefined {
+    return IsBoolean(value) || value === undefined
+  }
+  function IsBoolean(value: unknown): value is boolean {
+    return typeof value === 'boolean'
+  }
+  function IsString(value: unknown): value is string {
+    return typeof value === 'string'
+  }
+  // ------------------------------------------------------------------------
+  // Types
+  // ------------------------------------------------------------------------
+  export function TArray(schema: unknown): schema is TArray {
+    return IsObject(schema) && schema[Types.Kind] === 'TypeDef:Array' && TSchema(schema['elements'])
+  }
+  export function TBoolean(schema: unknown): schema is TBoolean {
+    return IsObject(schema) && schema[Types.Kind] === 'TypeDef:Boolean' && schema['type'] === 'boolean'
+  }
+  export function TUnion(schema: unknown): schema is TUnion {
+    if(!(IsObject(schema) && schema[Types.Kind] === 'TypeDef:Union' && IsString(schema['discriminator']) && IsObject(schema['mapping']))) return false
+    return globalThis.Object.getOwnPropertyNames(schema['mapping']).every(key => TSchema((schema['mapping'] as any)[key]))
+  }
+  export function TEnum(schema: unknown): schema is TEnum {
+    return IsObject(schema) && schema[Types.Kind] === 'TypeDef:Enum' && IsArray(schema['enum']) && schema['enum'].every(item => IsString(item))
+  }
+  export function TFloat32(schema: unknown): schema is TFloat32 {
+    return IsObject(schema) && schema[Types.Kind] === 'TypeDef:Float32' && schema['type'] === 'float32'
+  }
+  export function TFloat64(schema: unknown): schema is TFloat64 {
+    return IsObject(schema) && schema[Types.Kind] === 'TypeDef:Float64' && schema['type'] === 'float64'
+  }
+  export function TInt8(schema: unknown): schema is TInt8 {
+    return IsObject(schema) && schema[Types.Kind] === 'TypeDef:Int8' && schema['type'] === 'int8'
+  }
+  export function TInt16(schema: unknown): schema is TInt16 {
+    return IsObject(schema) && schema[Types.Kind] === 'TypeDef:Int16' && schema['type'] === 'int16'
+  }
+  export function TInt32(schema: unknown): schema is TInt32 {
+    return IsObject(schema) && schema[Types.Kind] === 'TypeDef:Int32' && schema['type'] === 'int32'
+  }
+  export function TUint8(schema: unknown): schema is TUint8 {
+    return IsObject(schema) && schema[Types.Kind] === 'TypeDef:Uint8' && schema['type'] === 'uint8'
+  }
+  export function TUint16(schema: unknown): schema is TUint16 {
+    return IsObject(schema) && schema[Types.Kind] === 'TypeDef:Uint16' && schema['type'] === 'uint16'
+  }
+  export function TUint32(schema: unknown): schema is TUint32 {
+    return IsObject(schema) && schema[Types.Kind] === 'TypeDef:Uint32' && schema['type'] === 'uint32'
+  }
+  export function TRecord(schema: unknown): schema is TRecord {
+    return IsObject(schema) && schema[Types.Kind] === 'TypeDef:Record' && TSchema(schema['values'])
+  }
+  export function TString(schema: unknown): schema is TString {
+    return IsObject(schema) && schema[Types.Kind] === 'TypeDef:String' && schema['type'] === 'string'
+  }
+  export function TStruct(schema: unknown): schema is TStruct {
+    if(!(IsObject(schema) && schema[Types.Kind] === 'TypeDef:Struct' && IsOptionalBoolean(schema['additionalProperties']))) return false
+    const optionalProperties = schema['optionalProperties']
+    const requiredProperties = schema['properties']
+    const optionalCheck = optionalProperties === undefined || IsObject(optionalProperties) && globalThis.Object.getOwnPropertyNames(optionalProperties).every(key => TSchema(optionalProperties[key]))
+    const requiredCheck = requiredProperties === undefined || IsObject(requiredProperties) && globalThis.Object.getOwnPropertyNames(requiredProperties).every(key => TSchema(requiredProperties[key]))
+    return optionalCheck && requiredCheck
+  }
+  export function TTimestamp(schema: unknown): schema is TTimestamp {
+    return IsObject(schema) && schema[Types.Kind] === 'TypeDef:Timestamp' && schema['type'] === 'timestamp'
+  }
+  export function TKind(schema: unknown): schema is Types.TKind {
+    return IsObject(schema) && Types.Kind in schema && typeof (schema as any)[Types.Kind] === 'string' // TS 4.1.5: any required for symbol indexer
+  }
+  export function TSchema(schema: unknown): schema is Types.TSchema {
+    // prettier-ignore
+    return (
+      TArray(schema) || 
+      TBoolean(schema) || 
+      TUnion(schema) || 
+      TEnum(schema) ||
+      TFloat32(schema) ||
+      TFloat64(schema) ||
+      TInt8(schema) ||
+      TInt16(schema) ||
+      TInt32(schema) ||
+      TUint8(schema) ||
+      TUint16(schema) ||
+      TUint32(schema) ||
+      TRecord(schema) ||
+      TString(schema) ||
+      TStruct(schema) ||
+      TTimestamp(schema) ||
+      (TKind(schema) && Types.TypeRegistry.Has(schema[Types.Kind]))
+    )
+  }
+}
+// --------------------------------------------------------------------------
+// TypeRegistry
+// --------------------------------------------------------------------------
+Types.TypeRegistry.Set<TArray>('TypeDef:Array', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TBoolean>('TypeDef:Boolean', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TUnion>('TypeDef:Union', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TInt8>('TypeDef:Int8', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TInt16>('TypeDef:Int16', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TInt32>('TypeDef:Int32', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TUint8>('TypeDef:Uint8', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TUint16>('TypeDef:Uint16', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TUint32>('TypeDef:Uint32', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TRecord>('TypeDef:Record', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TString>('TypeDef:String', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TStruct>('TypeDef:Struct', (schema, value) => ValueCheck.Check(schema, value))
+Types.TypeRegistry.Set<TTimestamp>('TypeDef:Timestamp', (schema, value) => ValueCheck.Check(schema, value))
+// --------------------------------------------------------------------------
+// TypeDefBuilder
 // --------------------------------------------------------------------------
-export class TypeDefTypeBuilder extends Types.TypeBuilder {
+export class TypeDefBuilder extends Types.TypeBuilder {
   // ------------------------------------------------------------------------
   // Modifiers
   // ------------------------------------------------------------------------
@@ -346,56 +501,56 @@ export class TypeDefTypeBuilder extends Types.TypeBuilder {
   // Types
   // ------------------------------------------------------------------------
   /** [Standard] Creates a Array type */
-  public Array<T extends Types.TSchema>(elements: T): TArray<T> {
-    return this.Create({ [Types.Kind]: 'TypeDef:Array', elements })
+  public Array<T extends Types.TSchema>(elements: T, options: SchemaOptions = {}): TArray<T> {
+    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Array', elements })
   }
   /** [Standard] Creates a Boolean type */
-  public Boolean(): TBoolean {
-    return this.Create({ [Types.Kind]: 'TypeDef:Boolean', type: 'boolean' })
+  public Boolean(options: SchemaOptions = {}): TBoolean {
+    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Boolean', type: 'boolean' })
   }
   /** [Standard] Creates a Enum type */
-  public Enum<T extends string[]>(values: [...T]): TEnum<T> {
-    return this.Create({ [Types.Kind]: 'TypeDef:Enum', enum: values })
+  public Enum<T extends string[]>(values: [...T], options: SchemaOptions = {}): TEnum<T> {
+    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Enum', enum: values })
   }
   /** [Standard] Creates a Float32 type */
-  public Float32(): TFloat32 {
-    return this.Create({ [Types.Kind]: 'TypeDef:Float32', type: 'float32' })
+  public Float32(options: SchemaOptions = {}): TFloat32 {
+    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Float32', type: 'float32' })
   }
   /** [Standard] Creates a Float64 type */
-  public Float64(): TFloat64 {
-    return this.Create({ [Types.Kind]: 'TypeDef:Float64', type: 'float64' })
+  public Float64(options: SchemaOptions = {}): TFloat64 {
+    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Float64', type: 'float64' })
   }
   /** [Standard] Creates a Int8 type */
-  public Int8(): TInt8 {
-    return this.Create({ [Types.Kind]: 'TypeDef:Int8', type: 'int8' })
+  public Int8(options: SchemaOptions = {}): TInt8 {
+    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Int8', type: 'int8' })
   }
   /** [Standard] Creates a Int16 type */
-  public Int16(): TInt16 {
-    return this.Create({ [Types.Kind]: 'TypeDef:Int16', type: 'int16' })
+  public Int16(options: SchemaOptions = {}): TInt16 {
+    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Int16', type: 'int16' })
   }
   /** [Standard] Creates a Int32 type */
-  public Int32(): TInt32 {
-    return this.Create({ [Types.Kind]: 'TypeDef:Int32', type: 'int32' })
+  public Int32(options: SchemaOptions = {}): TInt32 {
+    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Int32', type: 'int32' })
   }
   /** [Standard] Creates a Uint8 type */
-  public Uint8(): TUint8 {
-    return this.Create({ [Types.Kind]: 'TypeDef:Uint8', type: 'uint8' })
+  public Uint8(options: SchemaOptions = {}): TUint8 {
+    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Uint8', type: 'uint8' })
   }
   /** [Standard] Creates a Uint16 type */
-  public Uint16(): TUint16 {
-    return this.Create({ [Types.Kind]: 'TypeDef:Uint16', type: 'uint16' })
+  public Uint16(options: SchemaOptions = {}): TUint16 {
+    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Uint16', type: 'uint16' })
   }
   /** [Standard] Creates a Uint32 type */
-  public Uint32(): TUint32 {
-    return this.Create({ [Types.Kind]: 'TypeDef:Uint32', type: 'uint32' })
+  public Uint32(options: SchemaOptions = {}): TUint32 {
+    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Uint32', type: 'uint32' })
   }
   /** [Standard] Creates a Record type */
-  public Record<T extends Types.TSchema>(values: T): TRecord<T> {
-    return this.Create({ [Types.Kind]: 'TypeDef:Record', values })
+  public Record<T extends Types.TSchema>(values: T, options: SchemaOptions = {}): TRecord<T> {
+    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Record', values })
   }
   /** [Standard] Creates a String type */
-  public String(): TString {
-    return this.Create({ [Types.Kind]: 'TypeDef:String', type: 'string' })
+  public String(options: SchemaOptions = {}): TString {
+    return this.Create({ ...options, [Types.Kind]: 'TypeDef:String', type: 'string' })
   }
   /** [Standard] Creates a Struct type */
   public Struct<T extends TFields>(fields: T, options?: StructOptions): TStruct<T> {
@@ -408,7 +563,7 @@ export class TypeDefTypeBuilder extends Types.TypeBuilder {
   /** [Standard] Creates a Union type */
   public Union<T extends TStruct<TFields>[], D extends string = 'type'>(structs: [...T], discriminator?: D): TUnion<T, D> {
     discriminator = (discriminator || 'type') as D
-    if (structs.length === 0) throw new Error('TypeDefTypeBuilder: Union types must contain at least one struct')
+    if (structs.length === 0) throw new Error('TypeDefBuilder: Union types must contain at least one struct')
     const mapping = structs.reduce((acc, current, index) => ({ ...acc, [index.toString()]: current }), {})
     return this.Create({ [Types.Kind]: 'TypeDef:Union', discriminator, mapping })
   }
@@ -419,5 +574,5 @@ export class TypeDefTypeBuilder extends Types.TypeBuilder {
 }
 
 /** JSON Type Definition Type Builder */
-export const Type = new TypeDefTypeBuilder()
+export const Type = new TypeDefBuilder()
 

From 5a093bff4486adc5587793a5def1acf8ef19f0b1 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 1 Aug 2023 15:53:05 +0900
Subject: [PATCH 163/369] Revision 0.30.0 (#513)

---
 benchmark/compression/index.ts                |    2 +-
 .../compression/module/typebox-compiler.ts    |    3 +-
 .../compression/module/typebox-errors.ts      |    4 +-
 .../compression/module/typebox-system.ts      |    2 +-
 benchmark/compression/module/typebox-value.ts |    3 +-
 benchmark/measurement/module/cases.ts         |    2 +-
 changelog/0.30.0.md                           |  419 +++++
 example/experimental/readme.md                |   54 -
 example/experimental/readonly-object.ts       |   68 -
 example/legacy/intersect-0.25.0.ts            |   66 -
 example/trpc/readme.md                        |  111 --
 {example => examples}/collections/array.ts    |   31 -
 {example => examples}/collections/index.ts    |    0
 {example => examples}/collections/map.ts      |   26 -
 {example => examples}/collections/readme.md   |    0
 {example => examples}/collections/set.ts      |   16 +-
 {example => examples}/formats/index.ts        |    0
 {example => examples}/formats/readme.md       |    0
 {example => examples}/formats/standard.ts     |    0
 {example => examples}/index.ts                |    0
 examples/prototypes/const.ts                  |   61 +
 examples/prototypes/evaluate.ts               |  135 ++
 .../prototypes}/index.ts                      |    6 +-
 examples/prototypes/partial-deep.ts           |   65 +
 examples/prototypes/readme.md                 |  114 ++
 .../prototypes}/union-enum.ts                 |   18 +-
 .../prototypes}/union-oneof.ts                |   24 +-
 examples/transform/index.ts                   |   29 +
 examples/transform/readme.md                  |   83 +
 examples/transform/transform.ts               |  346 +++++
 examples/trpc/readme.md                       |   46 +
 examples/typedef/index.ts                     |   29 +
 {example => examples}/typedef/readme.md       |    0
 {example => examples}/typedef/typedef.ts      |  106 +-
 hammer.mjs                                    |   15 +-
 package-lock.json                             |    4 +-
 package.json                                  |   16 +-
 readme.md                                     |  436 +++---
 src/compiler/compiler.ts                      |  412 ++---
 src/errors/errors.ts                          |  861 ++++++-----
 src/system/system.ts                          |    8 +-
 src/typebox.ts                                | 1369 +++++++++--------
 src/value/cast.ts                             |  480 +++---
 src/value/check.ts                            |  763 ++++-----
 src/value/clone.ts                            |   85 +-
 src/value/convert.ts                          |  616 ++++----
 src/value/create.ts                           |  673 ++++----
 src/value/delta.ts                            |  234 ++-
 src/value/equal.ts                            |   74 +-
 src/value/guard.ts                            |  145 ++
 src/value/hash.ts                             |  261 ++--
 src/value/index.ts                            |    7 +-
 src/value/is.ts                               |   54 -
 src/value/mutate.ts                           |  127 +-
 src/value/pointer.ts                          |   17 +-
 src/value/value.ts                            |   76 +-
 test/runtime/assert/assert.ts                 |   32 +-
 test/runtime/compiler/array.ts                |   62 +-
 test/runtime/compiler/async-iterator.ts       |   20 +
 test/runtime/compiler/bigint.ts               |    4 -
 test/runtime/compiler/boolean.ts              |    6 -
 test/runtime/compiler/enum.ts                 |    3 -
 test/runtime/compiler/index.ts                |    4 +-
 test/runtime/compiler/integer.ts              |    8 -
 test/runtime/compiler/intersect.ts            |    1 -
 test/runtime/compiler/iterator.ts             |   20 +
 test/runtime/compiler/keyof.ts                |    3 -
 test/runtime/compiler/object.ts               |    2 -
 test/runtime/compiler/partial.ts              |   26 +-
 test/runtime/compiler/pick.ts                 |    3 -
 test/runtime/compiler/readonly-optional.ts    |    4 +-
 test/runtime/compiler/readonly.ts             |    1 -
 test/runtime/compiler/record.ts               |    4 +-
 test/runtime/compiler/recursive.ts            |    8 +-
 test/runtime/compiler/ref.ts                  |    9 +-
 test/runtime/compiler/regex.ts                |   35 -
 test/runtime/compiler/regexp.ts               |   65 +
 test/runtime/compiler/required.ts             |   15 +-
 test/runtime/compiler/string.ts               |    6 -
 test/runtime/compiler/template-literal.ts     |    1 -
 test/runtime/compiler/tuple.ts                |    8 -
 test/runtime/compiler/uint8array.ts           |    9 -
 test/runtime/compiler/union.ts                |    6 -
 test/runtime/compiler/validate.ts             |    7 -
 test/runtime/errors/iterator.ts               |   26 +-
 test/runtime/schema/array.ts                  |   65 +-
 test/runtime/schema/boolean.ts                |    6 -
 test/runtime/schema/composite.ts              |    2 +-
 test/runtime/schema/date.ts                   |  124 +-
 test/runtime/schema/enum.ts                   |    3 -
 test/runtime/schema/index.ts                  |    3 +-
 test/runtime/schema/integer.ts                |   11 -
 test/runtime/schema/intersect.ts              |    1 -
 test/runtime/schema/keyof.ts                  |    3 -
 test/runtime/schema/literal.ts                |    4 -
 test/runtime/schema/modifier.ts               |    3 -
 test/runtime/schema/null.ts                   |    6 -
 test/runtime/schema/number.ts                 |    7 -
 test/runtime/schema/object.ts                 |    6 -
 test/runtime/schema/omit.ts                   |    6 +-
 test/runtime/schema/partial.ts                |   16 +-
 test/runtime/schema/pick.ts                   |    6 +-
 test/runtime/schema/readonly-optional.ts      |    4 +-
 test/runtime/schema/readonly.ts               |    1 -
 test/runtime/schema/record.ts                 |    4 +-
 test/runtime/schema/recursive.ts              |    8 +-
 test/runtime/schema/ref.ts                    |    2 -
 test/runtime/schema/regex.ts                  |   35 -
 test/runtime/schema/regexp.ts                 |   65 +
 test/runtime/schema/required.ts               |   15 +-
 test/runtime/schema/string.ts                 |    6 -
 test/runtime/schema/template-literal.ts       |    1 -
 test/runtime/schema/tuple.ts                  |    8 -
 test/runtime/schema/uint8array.ts             |  105 +-
 test/runtime/schema/union.ts                  |    6 -
 test/runtime/schema/validate.ts               |    3 -
 test/runtime/schema/void.ts                   |    6 -
 test/runtime/system/system.ts                 |    8 +-
 test/runtime/type/extends/any.ts              |   36 +-
 test/runtime/type/extends/array.ts            |  100 +-
 test/runtime/type/extends/async-iterator.ts   |   72 +
 test/runtime/type/extends/bigint.ts           |   38 +-
 test/runtime/type/extends/boolean.ts          |   34 +-
 test/runtime/type/extends/constructor.ts      |   82 +-
 test/runtime/type/extends/date.ts             |   36 +-
 test/runtime/type/extends/function.ts         |   82 +-
 test/runtime/type/extends/index.ts            |    2 +
 test/runtime/type/extends/integer.ts          |   36 +-
 test/runtime/type/extends/iterator.ts         |   72 +
 test/runtime/type/extends/literal.ts          |  100 +-
 test/runtime/type/extends/not.ts              |   50 +-
 test/runtime/type/extends/null.ts             |   38 +-
 test/runtime/type/extends/number.ts           |   36 +-
 test/runtime/type/extends/object.ts           |   56 +-
 test/runtime/type/extends/promise.ts          |   78 +-
 test/runtime/type/extends/record.ts           |   64 +-
 test/runtime/type/extends/string.ts           |   42 +-
 test/runtime/type/extends/symbol.ts           |   40 +-
 test/runtime/type/extends/template-literal.ts |   60 +-
 test/runtime/type/extends/tuple.ts            |   62 +-
 test/runtime/type/extends/uint8array.ts       |   36 +-
 test/runtime/type/extends/undefined.ts        |   34 +-
 test/runtime/type/extends/union.ts            |   52 +-
 test/runtime/type/extends/unknown.ts          |   38 +-
 test/runtime/type/extends/void.ts             |   40 +-
 test/runtime/type/guard/any.ts                |    6 +-
 test/runtime/type/guard/array.ts              |   23 +-
 test/runtime/type/guard/async-iterator.ts     |   22 +
 test/runtime/type/guard/awaited.ts            |   41 +
 test/runtime/type/guard/bigint.ts             |    6 +-
 test/runtime/type/guard/boolean.ts            |    6 +-
 test/runtime/type/guard/capitalize.ts         |    9 +
 test/runtime/type/guard/composite.ts          |   24 +-
 test/runtime/type/guard/constructor.ts        |   14 +-
 test/runtime/type/guard/date.ts               |   20 +-
 test/runtime/type/guard/exclude.ts            |   36 +-
 test/runtime/type/guard/extract.ts            |   48 +-
 test/runtime/type/guard/function.ts           |   14 +-
 test/runtime/type/guard/index.ts              |   10 +-
 test/runtime/type/guard/indexed.ts            |  178 +--
 test/runtime/type/guard/integer.ts            |   16 +-
 test/runtime/type/guard/intersect.ts          |    4 +-
 test/runtime/type/guard/iterator.ts           |   22 +
 test/runtime/type/guard/keyof.ts              |   32 +-
 test/runtime/type/guard/literal.ts            |   12 +-
 test/runtime/type/guard/lowercase.ts          |    9 +
 test/runtime/type/guard/not.ts                |    6 +-
 test/runtime/type/guard/null.ts               |    6 +-
 test/runtime/type/guard/number.ts             |   16 +-
 test/runtime/type/guard/object.ts             |   29 +-
 test/runtime/type/guard/omit.ts               |   36 +-
 test/runtime/type/guard/partial.ts            |   40 +-
 test/runtime/type/guard/pick.ts               |   38 +-
 test/runtime/type/guard/promise.ts            |   14 +-
 test/runtime/type/guard/record.ts             |   76 +-
 test/runtime/type/guard/ref.ts                |    8 +-
 test/runtime/type/guard/required.ts           |   40 +
 test/runtime/type/guard/rest.ts               |    8 +-
 test/runtime/type/guard/string.ts             |   17 +-
 test/runtime/type/guard/symbol.ts             |    6 +-
 test/runtime/type/guard/template-literal.ts   |   18 +-
 test/runtime/type/guard/this.ts               |    4 +-
 test/runtime/type/guard/tuple.ts              |    8 +-
 test/runtime/type/guard/uint8array.ts         |   14 +-
 test/runtime/type/guard/uncapitalize.ts       |   10 +
 test/runtime/type/guard/undefined.ts          |    6 +-
 test/runtime/type/guard/union.ts              |   20 +-
 test/runtime/type/guard/unknown.ts            |    6 +-
 test/runtime/type/guard/unsafe.ts             |   17 +-
 test/runtime/type/guard/uppercase.ts          |   10 +
 test/runtime/type/guard/void.ts               |    6 +-
 test/runtime/type/index.ts                    |    1 +
 test/runtime/type/normalize/exclude.ts        |    6 +-
 test/runtime/type/normalize/extract.ts        |   10 +-
 test/runtime/type/normalize/indexed.ts        |   96 +-
 test/runtime/type/normalize/intersect.ts      |    6 +-
 test/runtime/type/normalize/record.ts         |    2 +-
 test/runtime/type/normalize/union.ts          |    6 +-
 test/runtime/type/registry/format.ts          |    6 +-
 test/runtime/type/registry/type.ts            |    6 +-
 test/runtime/type/template/finite.ts          |   24 +-
 test/runtime/type/template/generate.ts        |   74 +-
 test/runtime/type/template/parser.ts          |   78 +-
 test/runtime/type/template/pattern.ts         |   10 +-
 test/runtime/type/value/guard.ts              |  109 ++
 test/runtime/type/value/index.ts              |    1 +
 test/runtime/value/cast/any.ts                |   18 +-
 test/runtime/value/cast/array.ts              |   44 +-
 test/runtime/value/cast/async-iterator.ts     |   37 +
 test/runtime/value/cast/bigint.ts             |   18 +-
 test/runtime/value/cast/boolean.ts            |   18 +-
 test/runtime/value/cast/composite.ts          |   20 +-
 test/runtime/value/cast/custom.ts             |   16 +-
 test/runtime/value/cast/date.ts               |   12 +-
 test/runtime/value/cast/enum.ts               |   20 +-
 test/runtime/value/cast/index.ts              |    4 +-
 test/runtime/value/cast/integer.ts            |   14 +-
 test/runtime/value/cast/intersect.ts          |   16 +-
 test/runtime/value/cast/iterator.ts           |   37 +
 test/runtime/value/cast/keyof.ts              |   18 +-
 test/runtime/value/cast/literal.ts            |   18 +-
 test/runtime/value/cast/never.ts              |   16 +-
 test/runtime/value/cast/not.ts                |   18 +-
 test/runtime/value/cast/null.ts               |   18 +-
 test/runtime/value/cast/number.ts             |   16 +-
 test/runtime/value/cast/object.ts             |   28 +-
 test/runtime/value/cast/record.ts             |   21 +-
 test/runtime/value/cast/recursive.ts          |   18 +-
 .../value/cast/{regex.ts => regexp.ts}        |   20 +-
 test/runtime/value/cast/string.ts             |   14 +-
 test/runtime/value/cast/symbol.ts             |   18 +-
 test/runtime/value/cast/template-literal.ts   |   18 +-
 test/runtime/value/cast/tuple.ts              |   26 +-
 test/runtime/value/cast/uint8array.ts         |   18 +-
 test/runtime/value/cast/undefined.ts          |   18 +-
 test/runtime/value/cast/union.ts              |   39 +-
 test/runtime/value/cast/unknown.ts            |   18 +-
 test/runtime/value/cast/void.ts               |   18 +-
 test/runtime/value/check/any.ts               |   16 +-
 test/runtime/value/check/array.ts             |   76 +-
 test/runtime/value/check/async-iterator.ts    |   24 +
 test/runtime/value/check/bigint.ts            |   17 +-
 test/runtime/value/check/boolean.ts           |   16 +-
 test/runtime/value/check/composite.ts         |   15 +-
 test/runtime/value/check/custom.ts            |   40 +-
 test/runtime/value/check/date.ts              |   18 +-
 test/runtime/value/check/enum.ts              |   11 +-
 test/runtime/value/check/index.ts             |    4 +-
 test/runtime/value/check/integer.ts           |   16 +-
 test/runtime/value/check/intersect.ts         |   54 +-
 test/runtime/value/check/iterator.ts          |   24 +
 test/runtime/value/check/keyof.ts             |   12 +-
 test/runtime/value/check/literal.ts           |    8 +-
 test/runtime/value/check/never.ts             |   14 +-
 test/runtime/value/check/not.ts               |   18 +-
 test/runtime/value/check/null.ts              |   16 +-
 test/runtime/value/check/number.ts            |   24 +-
 test/runtime/value/check/object.ts            |   73 +-
 test/runtime/value/check/record.ts            |   46 +-
 test/runtime/value/check/recursive.ts         |   10 +-
 test/runtime/value/check/ref.ts               |   20 +-
 test/runtime/value/check/regex.ts             |   19 -
 test/runtime/value/check/regexp.ts            |   36 +
 test/runtime/value/check/string.ts            |   16 +-
 test/runtime/value/check/symbol.ts            |   18 +-
 test/runtime/value/check/template-literal.ts  |  134 +-
 test/runtime/value/check/tuple.ts             |   10 +-
 test/runtime/value/check/uint8array.ts        |    8 +-
 test/runtime/value/check/undefined.ts         |   16 +-
 test/runtime/value/check/union.ts             |   12 +-
 test/runtime/value/check/unknown.ts           |   16 +-
 test/runtime/value/check/void.ts              |   16 +-
 test/runtime/value/clone/clone.ts             |   69 +-
 test/runtime/value/convert/any.ts             |   14 +-
 test/runtime/value/convert/array.ts           |   20 +-
 test/runtime/value/convert/async-iterator.ts  |   20 +
 test/runtime/value/convert/bigint.ts          |   16 +-
 test/runtime/value/convert/boolean.ts         |   58 +-
 test/runtime/value/convert/composite.ts       |    2 +-
 test/runtime/value/convert/constructor.ts     |   20 +
 test/runtime/value/convert/custom.ts          |    6 +-
 test/runtime/value/convert/date.ts            |   18 +-
 test/runtime/value/convert/function.ts        |   20 +
 test/runtime/value/convert/index.ts           |    7 +-
 test/runtime/value/convert/integer.ts         |   28 +-
 test/runtime/value/convert/iterator.ts        |   20 +
 test/runtime/value/convert/literal.ts         |   30 +-
 test/runtime/value/convert/never.ts           |    6 +-
 test/runtime/value/convert/null.ts            |    6 +-
 test/runtime/value/convert/number.ts          |   29 +-
 test/runtime/value/convert/object.ts          |    2 +-
 test/runtime/value/convert/promise.ts         |   21 +
 test/runtime/value/convert/record.ts          |    2 +-
 .../value/convert/{regex.ts => regexp.ts}     |    0
 test/runtime/value/convert/string.ts          |   26 +-
 test/runtime/value/convert/symbol.ts          |    4 +-
 test/runtime/value/convert/tuple.ts           |    6 +-
 test/runtime/value/convert/undefined.ts       |    4 +-
 test/runtime/value/convert/union.ts           |    8 +-
 test/runtime/value/convert/unknown.ts         |   14 +-
 test/runtime/value/create/any.ts              |    4 +-
 test/runtime/value/create/array.ts            |    6 +-
 test/runtime/value/create/async-iterator.ts   |   16 +
 test/runtime/value/create/bigint.ts           |    4 +-
 test/runtime/value/create/boolean.ts          |    4 +-
 test/runtime/value/create/composite.ts        |    6 +-
 test/runtime/value/create/constructor.ts      |    5 +-
 test/runtime/value/create/custom.ts           |    4 +-
 test/runtime/value/create/enum.ts             |    4 +-
 test/runtime/value/create/function.ts         |    5 +-
 test/runtime/value/create/index.ts            |    4 +-
 test/runtime/value/create/integer.ts          |    4 +-
 test/runtime/value/create/intersect.ts        |   19 +-
 test/runtime/value/create/iterator.ts         |   16 +
 test/runtime/value/create/keyof.ts            |    4 +-
 test/runtime/value/create/literal.ts          |    8 +-
 test/runtime/value/create/never.ts            |    2 +-
 test/runtime/value/create/not.ts              |    6 +-
 test/runtime/value/create/null.ts             |    4 +-
 test/runtime/value/create/number.ts           |    4 +-
 test/runtime/value/create/object.ts           |   14 +-
 test/runtime/value/create/record.ts           |    4 +-
 test/runtime/value/create/recursive.ts        |   10 +-
 test/runtime/value/create/ref.ts              |    6 +-
 .../value/create/{regex.ts => regexp.ts}      |    8 +-
 test/runtime/value/create/string.ts           |    4 +-
 test/runtime/value/create/symbol.ts           |    4 +-
 test/runtime/value/create/template-literal.ts |   12 +-
 test/runtime/value/create/tuple.ts            |    8 +-
 test/runtime/value/create/uint8array.ts       |   18 +-
 test/runtime/value/create/undefined.ts        |    4 +-
 test/runtime/value/create/union.ts            |    8 +-
 test/runtime/value/create/unknown.ts          |    4 +-
 test/runtime/value/create/void.ts             |    5 +-
 test/runtime/value/delta/diff.ts              |  159 +-
 test/runtime/value/delta/patch.ts             |  157 +-
 test/runtime/value/equal/equal.ts             |   60 +-
 test/runtime/value/guard/guard.ts             |  302 ++++
 test/runtime/value/guard/index.ts             |    1 +
 test/runtime/value/hash/hash.ts               |  140 +-
 test/runtime/value/index.ts                   |    1 +
 test/runtime/value/mutate/mutate.ts           |   40 +-
 test/runtime/value/pointer/pointer.ts         |  245 ++-
 test/static/async-iterator.ts                 |    4 +
 test/static/awaited.ts                        |   20 +
 test/static/capitalize.ts                     |    4 +
 test/static/index.ts                          |    9 +-
 test/static/iterator.ts                       |    4 +
 test/static/lowercase.ts                      |    4 +
 test/static/modifier.ts                       |    2 +-
 test/static/readonly-optional.ts              |    2 +-
 test/static/record.ts                         |    2 +-
 test/static/{regex.ts => regexp.ts}           |    2 +-
 test/static/required.ts                       |    3 -
 test/static/uncapitalize.ts                   |    4 +
 test/static/uppercase.ts                      |    4 +
 tsconfig.json                                 |   33 +
 357 files changed, 8977 insertions(+), 6875 deletions(-)
 create mode 100644 changelog/0.30.0.md
 delete mode 100644 example/experimental/readme.md
 delete mode 100644 example/experimental/readonly-object.ts
 delete mode 100644 example/legacy/intersect-0.25.0.ts
 delete mode 100644 example/trpc/readme.md
 rename {example => examples}/collections/array.ts (99%)
 rename {example => examples}/collections/index.ts (100%)
 rename {example => examples}/collections/map.ts (97%)
 rename {example => examples}/collections/readme.md (100%)
 rename {example => examples}/collections/set.ts (99%)
 rename {example => examples}/formats/index.ts (100%)
 rename {example => examples}/formats/readme.md (100%)
 rename {example => examples}/formats/standard.ts (100%)
 rename {example => examples}/index.ts (100%)
 create mode 100644 examples/prototypes/const.ts
 create mode 100644 examples/prototypes/evaluate.ts
 rename {example/experimental => examples/prototypes}/index.ts (92%)
 create mode 100644 examples/prototypes/partial-deep.ts
 create mode 100644 examples/prototypes/readme.md
 rename {example/experimental => examples/prototypes}/union-enum.ts (78%)
 rename {example/experimental => examples/prototypes}/union-oneof.ts (61%)
 create mode 100644 examples/transform/index.ts
 create mode 100644 examples/transform/readme.md
 create mode 100644 examples/transform/transform.ts
 create mode 100644 examples/trpc/readme.md
 create mode 100644 examples/typedef/index.ts
 rename {example => examples}/typedef/readme.md (100%)
 rename {example => examples}/typedef/typedef.ts (87%)
 create mode 100644 src/value/guard.ts
 delete mode 100644 src/value/is.ts
 create mode 100644 test/runtime/compiler/async-iterator.ts
 create mode 100644 test/runtime/compiler/iterator.ts
 delete mode 100644 test/runtime/compiler/regex.ts
 create mode 100644 test/runtime/compiler/regexp.ts
 delete mode 100644 test/runtime/schema/modifier.ts
 delete mode 100644 test/runtime/schema/regex.ts
 create mode 100644 test/runtime/schema/regexp.ts
 create mode 100644 test/runtime/type/extends/async-iterator.ts
 create mode 100644 test/runtime/type/extends/iterator.ts
 create mode 100644 test/runtime/type/guard/async-iterator.ts
 create mode 100644 test/runtime/type/guard/awaited.ts
 create mode 100644 test/runtime/type/guard/capitalize.ts
 create mode 100644 test/runtime/type/guard/iterator.ts
 create mode 100644 test/runtime/type/guard/lowercase.ts
 create mode 100644 test/runtime/type/guard/required.ts
 create mode 100644 test/runtime/type/guard/uncapitalize.ts
 create mode 100644 test/runtime/type/guard/uppercase.ts
 create mode 100644 test/runtime/type/value/guard.ts
 create mode 100644 test/runtime/type/value/index.ts
 create mode 100644 test/runtime/value/cast/async-iterator.ts
 create mode 100644 test/runtime/value/cast/iterator.ts
 rename test/runtime/value/cast/{regex.ts => regexp.ts} (78%)
 create mode 100644 test/runtime/value/check/async-iterator.ts
 create mode 100644 test/runtime/value/check/iterator.ts
 delete mode 100644 test/runtime/value/check/regex.ts
 create mode 100644 test/runtime/value/check/regexp.ts
 create mode 100644 test/runtime/value/convert/async-iterator.ts
 create mode 100644 test/runtime/value/convert/constructor.ts
 create mode 100644 test/runtime/value/convert/function.ts
 create mode 100644 test/runtime/value/convert/iterator.ts
 create mode 100644 test/runtime/value/convert/promise.ts
 rename test/runtime/value/convert/{regex.ts => regexp.ts} (100%)
 create mode 100644 test/runtime/value/create/async-iterator.ts
 create mode 100644 test/runtime/value/create/iterator.ts
 rename test/runtime/value/create/{regex.ts => regexp.ts} (66%)
 create mode 100644 test/runtime/value/guard/guard.ts
 create mode 100644 test/runtime/value/guard/index.ts
 create mode 100644 test/static/async-iterator.ts
 create mode 100644 test/static/awaited.ts
 create mode 100644 test/static/capitalize.ts
 create mode 100644 test/static/iterator.ts
 create mode 100644 test/static/lowercase.ts
 rename test/static/{regex.ts => regexp.ts} (62%)
 create mode 100644 test/static/uncapitalize.ts
 create mode 100644 test/static/uppercase.ts

diff --git a/benchmark/compression/index.ts b/benchmark/compression/index.ts
index fc49651ab..521031315 100644
--- a/benchmark/compression/index.ts
+++ b/benchmark/compression/index.ts
@@ -19,7 +19,7 @@ export async function compression() {
   const tests = readdirSync('benchmark/compression/module').map((name) => basename(name, extname(name)))
   const results = await Promise.all(tests.map((test) => measure(test)))
   const present = results.reduce((acc, c) => {
-    return { ...acc, [c.test.replace('-', '/')]: { Compiled: c.compiled, Minified: c.minified, Compression: `${c.ratio.toFixed(2)} x` } }
+    return { ...acc, [c.test.replace(/-/g, '/')]: { Compiled: c.compiled, Minified: c.minified, Compression: `${c.ratio.toFixed(2)} x` } }
   }, {})
   console.table(present)
 }
diff --git a/benchmark/compression/module/typebox-compiler.ts b/benchmark/compression/module/typebox-compiler.ts
index 97a54ba07..4d23bb2f2 100644
--- a/benchmark/compression/module/typebox-compiler.ts
+++ b/benchmark/compression/module/typebox-compiler.ts
@@ -1,4 +1,3 @@
 import { TypeCompiler } from '@sinclair/typebox/compiler'
-import { Type } from '@sinclair/typebox'
 
-const T = TypeCompiler.Compile(Type.String())
+console.log(TypeCompiler)
diff --git a/benchmark/compression/module/typebox-errors.ts b/benchmark/compression/module/typebox-errors.ts
index 883bf9614..4a6324bbb 100644
--- a/benchmark/compression/module/typebox-errors.ts
+++ b/benchmark/compression/module/typebox-errors.ts
@@ -1,3 +1,3 @@
-import { ValueErrorType } from '@sinclair/typebox/errors'
+import * as ValueErrors from '@sinclair/typebox/errors'
 
-console.log(ValueErrorType)
+console.log(ValueErrors)
diff --git a/benchmark/compression/module/typebox-system.ts b/benchmark/compression/module/typebox-system.ts
index 929092b50..f148a55cf 100644
--- a/benchmark/compression/module/typebox-system.ts
+++ b/benchmark/compression/module/typebox-system.ts
@@ -1,3 +1,3 @@
 import { TypeSystem } from '@sinclair/typebox/system'
 
-TypeSystem.AllowNaN = true
+console.log(TypeSystem)
diff --git a/benchmark/compression/module/typebox-value.ts b/benchmark/compression/module/typebox-value.ts
index f616f8256..a5e563352 100644
--- a/benchmark/compression/module/typebox-value.ts
+++ b/benchmark/compression/module/typebox-value.ts
@@ -1,4 +1,3 @@
 import { Value } from '@sinclair/typebox/value'
-import { Type } from '@sinclair/typebox'
 
-const T = Value.Create(Type.String())
+console.log(Value)
diff --git a/benchmark/measurement/module/cases.ts b/benchmark/measurement/module/cases.ts
index 36ec2d7d9..8325c80ba 100644
--- a/benchmark/measurement/module/cases.ts
+++ b/benchmark/measurement/module/cases.ts
@@ -11,7 +11,7 @@ export namespace Cases {
 
   export const Primitive_String = Type.String()
 
-  export const Primitive_String_Pattern = Type.RegEx(/foo/, { default: 'foo' })
+  export const Primitive_String_Pattern = Type.RegExp(/foo/, { default: 'foo' })
 
   export const Primitive_Boolean = Type.Boolean()
 
diff --git a/changelog/0.30.0.md b/changelog/0.30.0.md
new file mode 100644
index 000000000..31899d3fe
--- /dev/null
+++ b/changelog/0.30.0.md
@@ -0,0 +1,419 @@
+## [0.30.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.30.0)
+
+## Overview
+
+Revision 0.30.0 is a milestone revision for the TypeBox project. It is primarily focused on internal optimizations, refactoring work to reduce package and bundle sizes, enable increased modularity of internal sub modules (with some considerations given to future ESM publishing), renaming internal functions to address react native bundling issues and consolidating shared internal modules to reduce overall code overhead.
+
+This revision also implements several new features, including new validation constraints for Array, new types for iterators, new utility types, a TypeScript code generation option for the compiler, enhancements made to modifiers and better options for TypeScript to TypeBox code translation. This revision also includes new examples including a transform type for handling IO encode an decode as well as a reference implementation for JSON Type Definition specification.
+
+This revision includes breaking changes and some deprecations. It requires a minor semver revision.
+
+## Contents
+
+- Enhancements
+  - [TypeScript Code Generation](#TypeScript-Code-Generation)
+  - [Optional and Readonly](#Optional-and-Readonly)
+  - [Iterator and AsyncIterator](#Iterator-and-AsyncIterator)
+  - [Order Independent References](#Order-Independent-References)
+  - [Value Submodules](#Value-Submodules)
+  - [Array Contains Constraint](#Array-Contains-Constraint)
+  - [Additional Utility Types](#Additional-Utility-Types)
+  - [Reduced Package Size](#Reduced-Package-Size)
+  - [TypeBox Codegen](#TypeBox-Codegen)
+- Examples
+  - [JSON Type Definition](#JSON-Type-Definition)
+  - [Prototype Types](#Prototype-Types)
+  - [Transform Types](#Transform-Types)
+- Breaking
+  - [Extended Type Representation-Change](#Extended-Type-Representation-Change)
+  - [Modifier Symbol Deprecated](#Modifier-Deprecated)
+  - [RegEx Renamed To RegExp](#RegEx-Renamed-To-RegExp)
+  - [ValueErrorType Custom Renamed To Kind](#ValueErrorType-Custom-Renamed-To-Kind)
+
+<a name="TypeScript Code Generation"></a>
+
+## TypeScript Code Generation
+
+Revision 0.30.0 adds TypeScript code generation support to the TypeCompiler. By specifying the language option on the `.Code()` function, TypeBox will add type annotations to the compiled output. This functionality can be used to produce typed TS functions for projects that preference AOT compilation.
+
+```typescript
+const Code = TypeCompiler.Code(Type.String(), {     // return function check(value: any): boolean {
+  language: 'typescript'                            //   return (
+})                                                  //     (typeof value === 'string')
+                                                    //   )
+                                                    // }
+```
+
+<a name="Optional-and-Readonly"></a>
+
+## Optional and Readonly
+
+Revision 0.30.0 deprecates the `[Modifier]` symbol and introduces two new symbols, `[Readonly]` and `[Optional]`. This change is carried out to simplify type inference as well as to simplify runtime mapping logic. This change should not implicate users leveraging the `Type.*` purely for type composition, however implementors using TypeBox for reflection and code generation should update to the new symbols.
+
+```typescript
+// Revision 0.29.0
+//
+const A = Type.ReadonlyOptional(Type.Number())     // const A: TReadonlyOptional<TNumber> = {
+                                                   //   type: 'number',
+                                                   //   [TypeBox.Modifier]: 'ReadonlyOptional'
+                                                   // }
+
+const B = Type.Readonly(Type.Number())             // const B: TReadonly<TNumber> = {
+                                                   //   type: 'number',
+                                                   //   [TypeBox.Modifier]: 'Readonly'
+                                                   // }
+
+const C = Type.Optional(Type.Number())             // const C: TOptional<TNumber> = {
+                                                   //   type: 'number',
+                                                   //   [TypeBox.Modifier]: 'Optional'
+                                                   // }
+
+// Revision 0.30.0
+//
+const A = Type.ReadonlyOptional(Type.Number())     // const A: TReadonly<TOptional<TNumber>> = {
+                                                   //   type: 'number',
+                                                   //   [TypeBox.Readonly]: 'Readonly',
+                                                   //   [TypeBox.Optional]: 'Optional'
+                                                   // }
+
+const B = Type.Readonly(Type.Number())             // const B: TReadonly<TNumber> = {
+                                                   //   type: 'number',
+                                                   //   [TypeBox.Readonly]: 'Readonly'
+                                                   // }
+
+const C = Type.Optional(Type.Number())             // const C: TOptional<TNumber> = {
+                                                   //   type: 'number',
+                                                   //   [TypeBox.Optional]: 'Optional'
+                                                   // }
+```
+
+<a name="Iterator-and-AsyncIterator"></a>
+
+## Iterator and AsyncIterator
+
+Revision 0.30.0 adds the types `Iterator` and `AsyncIterator`. These types add to the existing non-validatable extended type set and can be used build callable generator functions. These types are written primarily to describe RPC network interfaces that return multiple values. Examples of which may include web socket streams or reading database result cursors over a network.
+
+```typescript
+// Revision 0.30.0
+//
+const Enumerable = <T extends TSchema>(T: T) => Type.Function([
+  Type.Number({ description: 'Start index' }),
+  Type.Number({ description: 'End index' })
+], Type.Iterator(T))
+
+const EnumerableNumber = Enumerable(Type.Number())
+
+const Range: Static<typeof EnumerableNumber> = function * (start: number, end: number) {
+  for(let i = start; i < end; i++) yield i
+}
+
+const R = [...Range(10, 20)]                 // const R = [10, 11, 12, ..., 19]
+```
+
+<a name="Order-Independent-References"></a>
+
+## Order Independent References
+
+Revision 0.30.0 adds an overload for `Ref` to enable non order dependent type referencing. Prior to this revision, reference targets needed to be defined first before being referenced. Revision 0.30.0 lifts this restriction and allows referencing of "yet to be defined" targets through the use of `typeof` operator. This overload borrows on TypeScript's ability to derive type information irrespective of topological ordering.
+
+This overload is implemented for "TypeScript to TypeBox" code generation utilities where TypeScript types are not guaranteed ordered in a runtime sorted fashion.
+
+```typescript
+// Revision 0.29.0
+//
+const R = Type.Ref(T)                              // Error: T isn't defined yet
+
+const T = Type.Object({
+  x: Type.Number(),
+  y: Type.Number(),
+  z: Type.Number()
+}, { $id: 'T' })
+
+// Revision 0.30.0
+//
+const R = Type.Ref<typeof T>('T')                  // Ok: infer from typeof T
+
+const T = Type.Object({
+  x: Type.Number(),
+  y: Type.Number(),
+  z: Type.Number()
+}, { $id: 'T' })
+```
+
+<a name="Value-Submodules"></a>
+
+## Value Submodules
+
+Revision 0.30.0 carries out a number of refactorings for the `Value.*` modules to enable each submodule to be imported individually. These refactorings are support better "pay to play" library characteristics, allowing users to import only the submodules they need. This update also makes provisions for ESM publishing by removing internal namespaces.
+
+The top level `Value.*` namespace will remain on all subsequent versions of TypeBox.
+
+```typescript
+// Revision 0.29.0
+//
+import { Value } from '@sinclair/typebox/value'           // Value.* namespace
+
+const A = Value.Create(Type.String())              
+
+// Revision 0.30.0
+//
+import { Create } from '@sinclair/typebox/value/create'   // Only Create()
+
+const A = Create(Type.String())                  
+```
+
+<a name="Array-Contains-Constraint"></a>
+
+## Array Contains Constraint
+
+Revision 0.30.0 implements validation support for the `contains` keyword as well as the draft 2019-09 `minContains` and `maxContains` constraints on `Array`. Documentation on these constraints can be found https://json-schema.org/understanding-json-schema/reference/array.html#contains
+
+```typescript
+// Revision 0.30.0
+//
+const T = Type.Array(Type.Number(), {
+  contains: Type.Literal(1),
+  minContains: 3,
+  maxContains: 5
+})
+
+Value.Check(T, [1, 1, 1])                          // true - between 3 and 5 instances of 1
+Value.Check(T, [1, 1, 1, 1, 1])                    // true - between 3 and 5 instances of 1
+Value.Check(T, [0, 1, 1, 1, 1, 1])                 // true - between 3 and 5 instances of 1
+Value.Check(T, [1, 1])                             // false - less than 3 instances of 1
+Value.Check(T, [1, 1, 1, 1, 1, 1])                 // false - more than 5 instances of 1
+Value.Check(T, [0])                                // false - no instances of 1
+```
+
+<a name="Additional-Utility-Types"></a>
+
+## Additional Utility Types
+
+Revision 0.30.0 adds the utility types `Awaited`, `Uppercase`, `Lowercase`, `Capitalize`, and `Uncapitalize` to the supported type set.
+
+```typescript
+// Revision 0.30.0
+const T1 = Type.Awaited(Type.Promise(Type.String()))  // const T1: TString
+
+const T2 = Type.Uppercase(Type.Literal('hello'))      // const T2: TLiteral<'HELLO'>
+
+const T3 = Type.Lowercase(Type.Literal('HELLO'))      // const T3: TLiteral<'hello'>
+
+const T4 = Type.Capitalize(Type.Literal('hello'))     // const T4: TLiteral<'Hello'>
+
+const T5 = Type.Uncapitalize(Type.Literal('HELLO'))   // const T5: TLiteral<'hELLO'>
+```
+A full list of TypeScript utility types can be found at this [link](https://www.typescriptlang.org/docs/handbook/utility-types.html).
+
+<a name="Reduced-Package-Size"></a>
+
+## Reduced Package Size
+
+Revision 0.30.0 carries out several internal refactorings to reduce package and bundle sizes. This work is largely an ongoing process with provisional work carried out across `type`, `value` and `compiler` modules. Revision 0.30.0 manages to weigh in slightly less than Revision 0.29.0 with the additional functionality provided on the revision.
+
+```typescript
+// Revision 0.29.0
+//
+┌──────────────────────┬────────────┬────────────┬─────────────┐
+│       (index)        │  Compiled  │  Minified  │ Compression │
+├──────────────────────┼────────────┼────────────┼─────────────┤
+│ typebox/compiler     │ '130.3 kb' │ ' 58.2 kb' │  '2.24 x'   │
+│ typebox/errors       │ '113.3 kb' │ ' 49.8 kb' │  '2.27 x'   │
+│ typebox/system       │ ' 78.8 kb' │ ' 32.2 kb' │  '2.45 x'   │
+│ typebox/value        │ '180.0 kb' │ ' 77.7 kb' │  '2.32 x'   │
+│ typebox              │ ' 77.7 kb' │ ' 31.7 kb' │  '2.45 x'   │
+└──────────────────────┴────────────┴────────────┴─────────────┘
+
+// Revision 0.30.0
+//
+┌──────────────────────┬────────────┬────────────┬─────────────┐
+│       (index)        │  Compiled  │  Minified  │ Compression │
+├──────────────────────┼────────────┼────────────┼─────────────┤
+│ typebox/compiler     │ '129.4 kb' │ ' 58.6 kb' │  '2.21 x'   │
+│ typebox/errors       │ '111.6 kb' │ ' 50.1 kb' │  '2.23 x'   │
+│ typebox/system       │ ' 76.5 kb' │ ' 31.7 kb' │  '2.41 x'   │
+│ typebox/value        │ '180.7 kb' │ ' 79.3 kb' │  '2.28 x'   │
+│ typebox              │ ' 75.4 kb' │ ' 31.3 kb' │  '2.41 x'   │
+└──────────────────────┴────────────┴────────────┴─────────────┘
+```
+
+<a name="TypeBox-Codegen"></a>
+
+## TypeBox Codegen
+
+Revision 0.30.0 offers an external code generation API tool which can be used to programmatically convert TypeScript types into TypeBox types.
+
+[TypeBox-Code Project](https://github.com/sinclairzx81/typebox-codegen)
+
+```typescript
+import * as Codegen from '@sinclair/typebox-codegen'
+
+const Code = Codegen.TypeScriptToTypeBox.Generate(`
+  type T = { x: number, y: number, z: number }
+`)
+
+console.log(Code)
+
+// Output:
+//
+// import { Type, Static } from '@sinclair/typebox'
+// 
+// type T = Static<typeof T>
+// const T = Type.Object({
+//   x: Type.Number(),
+//   y: Type.Number(),
+//   z: Type.Number()
+// })
+```
+
+<a name="JSON-Type-Definition"></a>
+
+## JSON Type Definition
+
+Revision 0.30.0 includes a reference implementation for JSON Type Definition (RFC 8927). This specification is currently under consideration for inclusion in the TypeBox library as an alternative schema representation for nominal type systems. The implementation currently contains all types expressed in the JSON Type Definition spec, but omits constraints such and `minimum` and `maximum` values (which are not formally represented in the specification).
+
+The implementation is offered as a single file which can be copied in to projects with TypeBox installed. This implementation may be enhanced over the next few revisions (with some potential to implement mapping types such as partial, required, omit, pick, keyof). This specification will be considered for inclusion under `@sinclair/typebox/typedef` if there is enough interest.
+
+```typescript
+import { Type } from './typedef'                   // from: examples/typedef/typedef.ts
+
+const T3 = Type.Struct({                           // const T3 = {
+  x: Type.Float32(),                               //   properties: {
+  y: Type.Float32(),                               //     x: { type: 'float32' },
+  z: Type.Float32()                                //     y: { type: 'float32' },
+})                                                 //     z: { type: 'float32' }
+                                                   //   }
+                                                   // }
+
+const T2 = Type.Struct({                           // const T3 = {
+  x: Type.Float32(),                               //   properties: {    
+  y: Type.Float32()                                //     x: { type: 'float32' },
+})                                                 //     y: { type: 'float32' }
+                                                   //   }
+                                                   // }
+
+const U = Type.Union([                             // const U = {
+  T3,                                              //   discriminator: 'type',
+  T2                                               //   mapping: {
+])                                                 //     0: {
+                                                   //       properties: {
+                                                   //         x: { type: 'float32' },
+                                                   //         y: { type: 'float32' },
+                                                   //         z: { type: 'float32' }
+                                                   //       }
+                                                   //     },
+                                                   //     1: {
+                                                   //       properties: {
+                                                   //         x: { type: 'float32' },
+                                                   //         y: { type: 'float32' }
+                                                   //       }
+                                                   //     }
+                                                   //   }
+                                                   // }
+```
+
+<a name="Prototype-Types"></a>
+
+## Prototype Types
+
+Revision 0.30.0 renames `Experimental` types to `Prototype` types within the examples directory. Updates here include additional documentation and rationales for the existing types `UnionOneOf`, `UnionEnum`, `Const`, and includes two new types `Evaluate` and `PartialDeep`. These types are written as standalone modules and can be copied into a project for direct use. The TypeBox project is open to community discussions around the inclusion of these types in future revisions.
+
+<a name="Transform-Types"></a>
+
+## Transform Types
+
+Revision 0.30.0 provides a reference implementation for Transform types. There has been some interest from users to offer combinators similar to Zod's `.transform()` function that permits remapping values during `.parse()` like operations. As TypeBox types do not have fluent combinators or a parse function (and are just JSON Schema objects), introducing similar functionality without augmenting types or implementing a `.parse()` on all types has proven to be particularily challenging.
+
+The reference Transform implementation implements a workable design by augmenting TypeBox types with codec functions outside the type system. These functions allow values to be structurally encoded and decoded through the `.parseLike()` functions `Encode()` and `Decode()`. TypeBox adopts the `io-ts` perspective for value transformation, viewing the act of transforming values primarily the role of dedicated codec system. As much of this functionality is considered high level and above and beyond the type system, Transform types will not likely be added to TypeBox type system; but rather added as an optional import in later revisions. 
+
+```typescript
+import { Transform, Encode, Decode } from './transform'
+
+const Timestamp = Transform(Type.Number(), {       // The Transform function wraps a TypeBox type with two codec
+  decode: (value) => new Date(value),              // functions which implement logic to decode a received value
+  encode: (value) => value.getTime(),              // (i.e. number) into a application type (Date). The encode
+})                                                 // function handles the reverse mapping.
+
+type N = Static<typeof N>                          // type N = { timestamp: number }
+                                                   //
+const N = Type.Object({                            // Transform types are to be used like any other type and will
+  timestamp: Timestamp                             // infer as the original TypeBox type. For example, the type `N` 
+})                                                 // above will infer as { timestamp: number } (as derived from 
+                                                   // the TB type)
+
+
+
+const D = Decode(N, { timestamp: 123 })            // const D = { timestamp: Date(123) }
+                                                   //
+                                                   // The Decode function accepts any type plus a value. The Decode 
+                                                   // function return type will be that of the transforms decode() 
+                                                   // return type (which is Date), with the second argument statically
+                                                   // typed as N. This function acts as a kind of parse() that returns 
+                                                   // the decoded type or throws on validation error.
+                                               
+
+const E = Encode(N, { timestamp: new Date(123) })  // const E = { timestamp: 123 }
+                                                   //
+                                                   // The encode function performs the inverse, accepting the
+                                                   // decoded type { timestamp: Date } and re-encoding to the
+                                                   // target type { timestamp: number }. This function will
+                                                   // also throw on validation error.
+```
+
+<a name="Extended-Type-Representation-Change"></a>
+
+## Extended Type Representation Change
+
+Revision 0.30.0 updates representations for all extended types. This change is made due to TypeBox's observed role as a general purpose JavaScript validation library as well as to deprecate support for extended type validation in Ajv which was only ever partially functional at best.
+
+Attempts were made on Revision 0.25.0 to restructure extended types to provide Ajv hooks for custom type configuration. These hooks used the `type` property where `{ type: 'object', instanceOf: 'Type' }` was used to configure schematics for JavaScript objects, and `{ type: 'null', typeOf: 'Type' }` was used for JavaScript primitives. Despite these hooks, Ajv would still struggle with validation of primitive types (such as `undefined`), and for the types `Function`, `Constructor` and `Promise`; these were meaningless to Ajv and it did not make sense to try provide hooks for a validator that could not make use of them.
+
+This change represents a move towards a formal specification to express pure JavaScript constructs which is partially under discussion within the runtime type community. This change will implicate the use of `Uint8Array` and `Date` objects when configuring for Ajv. A supplimentary fallback will be provided in the `/examples` directory using `Type.Unsafe`
+
+```typescript
+// Revision 0.29.0
+//
+const T = Type.Date()                              // const T: TDate = { type: 'object', instanceOf: 'Date' }
+
+const U = Type.Undefined()                         // const U: TUndefined = { type: 'null', typeOf: 'Undefined' }
+
+// Revision 0.30.0
+//
+const T = Type.Date()                              // const T: TDate = { type: 'Date' }
+
+const U = Type.Undefined()                         // const U: TUndefined = { type: 'undefined' }
+```
+
+<a name="RegEx-Renamed-To-RegExp"></a>
+
+## RegEx Renamed To RegExp
+
+Revision 0.30.0 marks `Type.RegEx` as deprecated but provides `Type.RegExp` as an alternative (matching the JavaScript `RegExp` type name). Additionally this type has also been moved from the `Standard` to `Extended` type set. The `RegExp` type will no longer considered part of the Standard type set due to JavaScript Regular Expressions supporting a wider range of symbols and control characeters than is supported by the ECMA262 subset used by the JSON Schema specification. Information on the ECMA262 subset supported by JSON Schema can be found at the following Url https://json-schema.org/understanding-json-schema/reference/regular_expressions.html
+
+As `Type.RegEx()` is widely used, this function will be retained under the `@deprecated` annotation for the 0.30.0 revision.
+
+```typescript
+// Revision 0.29.0
+
+const T = Type.RegEx(/abc/) 
+
+// Revision 0.30.0
+
+const A = Type.RegEx(/abc/)                       // deprecation warning!
+
+const B = Type.RegExp(/abc/)                      // Extended Type
+
+const T = Type.String({ pattern: /abc/.source })  // Standard Type
+```
+For Unicode (UTF-16) support on 0.30.0, the recommendation is to continue using user defined formats.
+
+```typescript
+import { Type, FormatRegistry } from '@sinclair/typebox'
+
+FormatRegistry.Set('emoji', value => /<a?:.+?:\d{18}>|\p{Extended_Pictographic}/gu.test(value))
+
+const T = Type.String({ format: 'emoji' })
+
+Value.Check(T, '♥️♦️♠️♣️')                         // Ok
+```
+For information on configuring custom formats on Ajv, refer to https://ajv.js.org/guide/formats.html#user-defined-formats
diff --git a/example/experimental/readme.md b/example/experimental/readme.md
deleted file mode 100644
index d22128721..000000000
--- a/example/experimental/readme.md
+++ /dev/null
@@ -1,54 +0,0 @@
-# Experimental Types
-
-These examples are a set of experiemental candidate types that may introduced into TypeBox in future.
-
-## ReadonlyObject
-
-Maps an object properties as `readonly`.
-
-```typescript
-import { ReadonlyObject } from './experimental'
-
-const T = ReadonlyObject(Type.Object({
-  x: Type.Number()
-}))
-
-type T = Static<typeof T>                           // type T = {
-                                                    //   readonly x: number
-                                                    // }
-```
-## UnionEnum
-
-Creates an `enum` union string schema representation.
-
-```typescript
-import { UnionEnum } from './experimental'
-
-
-const T = UnionEnum(['A', 'B', 'C'])                // const T = {
-                                                    //   enum: ['A', 'B', 'C']
-                                                    // }
-
-type T = Static<typeof T>                           // type T = 'A' | 'B' | 'C'
-
-```
-## UnionOneOf
-
-Creates a `oneOf` union representation.
-
-
-```typescript
-import { UnionOneOf } from './experimental'
-
-
-const T = UnionOneOf([                              // const T = {
-  Type.Literal('A'),                                //   oneOf: [
-  Type.Literal('B'),                                //     { const: 'A' },
-  Type.Literal('C')                                 //     { const: 'B' },
-])                                                  //     { const: 'C' },
-                                                    //   ]
-                                                    // }
-
-type T = Static<typeof T>                           // type T = 'A' | 'B' | 'C'
-
-```
\ No newline at end of file
diff --git a/example/experimental/readonly-object.ts b/example/experimental/readonly-object.ts
deleted file mode 100644
index b6ce4bacc..000000000
--- a/example/experimental/readonly-object.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/experimental
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import * as Types from '@sinclair/typebox'
-
-// -------------------------------------------------------------------------------------
-// TReadonlyObject
-// -------------------------------------------------------------------------------------
-export type TReadonlyArray<T extends Types.TSchema[]> = Types.Assert<{ [K in keyof T]: TReadonlyObject<Types.Assert<T[K], Types.TSchema>> }, Types.TSchema[]>
-// prettier-ignore
-export type TReadonlyProperties<T extends Types.TProperties> = Types.Evaluate<Types.Assert<{
-  [K in keyof T]:
-  T[K] extends Types.TReadonlyOptional<infer U> ? Types.TReadonlyOptional<U> :
-  T[K] extends Types.TReadonly<infer U> ? Types.TReadonly<U> :
-  T[K] extends Types.TOptional<infer U> ? Types.TReadonlyOptional<U> :
-  Types.TReadonly<T[K]>
-}, Types.TProperties>>
-// prettier-ignore
-export type TReadonlyObject<T extends Types.TSchema> =
-  T extends Types.TIntersect<infer S> ? Types.TIntersect<TReadonlyArray<S>> :
-  T extends Types.TUnion<infer S> ? Types.TUnion<TReadonlyArray<S>> :
-  T extends Types.TObject<infer S> ? Types.TObject<TReadonlyProperties<S>> :
-  Types.TReadonly<T>
-
-/** `[Experimental]` Remaps a Intersect, Union or Object as readonly */
-export function ReadonlyObject<T extends Types.TSchema>(schema: T): TReadonlyObject<T> {
-  function Apply(property: Types.TSchema): any {
-    // prettier-ignore
-    switch (property[Types.Modifier]) {
-      case 'ReadonlyOptional': property[Types.Modifier] = 'ReadonlyOptional'; break
-      case 'Readonly': property[Types.Modifier] = 'Readonly'; break
-      case 'Optional': property[Types.Modifier] = 'ReadonlyOptional'; break
-      default: property[Types.Modifier] = 'Readonly'; break
-    }
-    return property
-  }
-  // prettier-ignore
-  return (Types.TypeGuard.TIntersect(schema) || Types.TypeGuard.TUnion(schema) || Types.TypeGuard.TObject(schema))
-    ? Types.ObjectMap.Map<TReadonlyObject<T>>(schema, (schema) => {
-      globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]))
-      return schema
-    }, {}) : Apply(schema)
-}
\ No newline at end of file
diff --git a/example/legacy/intersect-0.25.0.ts b/example/legacy/intersect-0.25.0.ts
deleted file mode 100644
index d2fbd9545..000000000
--- a/example/legacy/intersect-0.25.0.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/legacy
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { TObject, ObjectOptions, Modifier, Kind, TSchema, Static } from '@sinclair/typebox'
-
-export type IntersectLegacyReduce<I extends unknown, T extends readonly any[]> = T extends [infer A, ...infer B] ? IntersectLegacyReduce<I & A, B> : I extends object ? I : {}
-export type IntersectLegacyEvaluate<T extends readonly TObject[], P extends unknown[]> = { [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never }
-export type IntersectLegacyProperties<T extends readonly TObject[]> = {
-  [K in keyof T]: T[K] extends TObject<infer P> ? P : {}
-}
-export interface TIntersectLegacy<T extends TObject[] = TObject[]> extends TObject {
-  static: IntersectLegacyReduce<unknown, IntersectLegacyEvaluate<T, this['params']>>
-  properties: IntersectLegacyReduce<unknown, IntersectLegacyProperties<T>>
-}
-
-/** `Legacy` Creates a legacy intersect type. */
-export function IntersectLegacy<T extends TObject[]>(objects: [...T], options: ObjectOptions = {}): TIntersectLegacy<T> {
-  const isOptional = (schema: TSchema) => (schema[Modifier] && schema[Modifier] === 'Optional') || schema[Modifier] === 'ReadonlyOptional'
-  const [required, optional] = [new Set<string>(), new Set<string>()]
-  for (const object of objects) {
-    for (const [key, schema] of Object.entries(object.properties)) {
-      if (isOptional(schema)) optional.add(key)
-    }
-  }
-  for (const object of objects) {
-    for (const key of Object.keys(object.properties)) {
-      if (!optional.has(key)) required.add(key)
-    }
-  }
-  const properties = {} as Record<string, any>
-  for (const object of objects) {
-    for (const [key, schema] of Object.entries(object.properties)) {
-      properties[key] = properties[key] === undefined ? schema : { [Kind]: 'Union', anyOf: [properties[key], { ...schema }] }
-    }
-  }
-  if (required.size > 0) {
-    return { ...options, [Kind]: 'Object', type: 'object', properties, required: [...required] } as any
-  } else {
-    return { ...options, [Kind]: 'Object', type: 'object', properties } as any
-  }
-}
diff --git a/example/trpc/readme.md b/example/trpc/readme.md
deleted file mode 100644
index adcb43aa7..000000000
--- a/example/trpc/readme.md
+++ /dev/null
@@ -1,111 +0,0 @@
-# Using TypeBox with TRPC
-
-To use TypeBox with TRPC, you will need to wrap types passed to procedures within a TRPC compatible assertion function. Once wrapped, TypeBox can provide TRPC auto type inference for procedures, enhanced runtime checking performance as well as provide options to enabling publishable procedure schematics based on the JSON Schema specification.
-
-## Contents
-
-- [Example](#Example)
-- [RpcType](#RpcType)
-  - [TypeCompiler](#TypeCompiler)
-  - [Value](#Value)
-  - [Ajv](#Ajv)
-
-<a name="Example"></a>
-
-## Example
-
-The following shows a minimal TypeBox + TRPC setup with the `RpcType` wrapper function described in the sections below.
-
-```typescript
-import { Type } from '@sinclair/typebox'
-import { initTRPC } from '@trpc/server'
-import { RpcType } from './rpctype'
-
-const addInput = RpcType(
-  Type.Object({
-    a: Type.Number(),
-    b: Type.Number(),
-  }),
-)
-
-const addOutput = RpcType(Type.Number())
-
-const t = initTRPC.create()
-
-export const appRouter = t.router({
-  add: t.procedure
-    .input(addInput)
-    .output(addOutput)
-    .query(({ input }) => input.a + input.b), // type-safe
-})
-```
-
-<a name="RpcType"></a>
-
-## RpcType
-
-Unlike Zod, Yup, Superstruct, TypeBox types are pure JSON Schema and do not implement a built in `parse()` or `validate()` function. Because of this, you will need to wrap the Type in a TRPC compatible function which implements `parse()` on behalf of TRPC. As JSON Schema is a formal specification, there are a number of ways you may choose to implement this function. The following are some recommended implementations.
-
-<a name="TypeCompiler"></a>
-
-### With [TypeCompiler](https://www.typescriptlang.org/play?#code/JYWwDg9gTgLgBAbzgFQJ5gKYGELmAGwyjgF84AzKXOAcgAEBnYAOwGN8BDYKAehnQwAjCAA8erXGAJEaAWABQoSLEQoAyqwAWGEB1JwDhytXpM2nbnwHCRcxeGjwkyAEoAFLAFEoVYmSNUILR0MFBgrDwMRABuMgoKGCLK8OQArmwwwBDMcC7haJgAPMhwiTAYzAAmDOpaOhwAfAAUDHW6AFwoADRwUBjkRBWsGAydyBraugDaALpwALxwswCUiAoGEswM8HWsANYLKAI4eIRQAHQnUoQtbRw9fQN9bCPL670YMKlQOU3RHPhUhhOuk9swIAB3ZireYNNbyQxwYDkOBNXZ7S7afZ-AFA5arPpfH5wf6AjDvDbZbaqMAcGCaHogEYMDgAcww+kW6PO3l8DBxZOW5wAYtxtk1lgBCClwelUCFwZgYBWuDy86BNJBMhgs9mdAAGABIENrdRgyORoHBjbT6SR9T0JJVgbQAEIAQQAIgB9FyeACKAFVPGpkDRSG8EaQFCQgA)
-
-The following uses the TypeCompiler to perform JIT optimized type checking for TRPC.
-
-```typescript
-import { TypeCompiler } from '@sinclair/typebox/compiler'
-import { TSchema } from '@sinclair/typebox'
-import { TRPCError } from '@trpc/server'
-
-export function RpcType<T extends TSchema>(schema: T, references: TSchema[] = []) {
-  const check = TypeCompiler.Compile(schema, references)
-  return (value: unknown) => {
-    if (check.Check(value)) return value
-    const { path, message } = check.Errors(value).First()!
-    throw new TRPCError({ message: `${message} for ${path}`, code: 'BAD_REQUEST' })
-  }
-}
-```
-
-<a name="Value"></a>
-
-### With [Value](https://www.typescriptlang.org/play?#code/JYWwDg9gTgLgBAbzgNQIYBsCuBTOBfOQwgMyghDgHIABAZ2ADsBjdVYKAehgE8xsAjCAA8OANww5KAWABQoSLERwAKgGUmAC2whU+IqXJU6jFm048+godLnho8JMoBKABQDCAUShkoegxRoYKDAmDlpsKFEIm1lsIQV4YkxmGGAIBjgnEOVebAAeZTg4mGwGABNaFXUtHQA+AApaTW1UAC4VABo4KGxiCNKmbFp2tWadAG0AXTgAXjgpgEpEWUIemEwoDPrxLGx25IBrBggAdwYlmdrlmSI4YGI4erRdgDo3LSYDxrHULp6+nrMIZdHY4BZLNYbDKg7ArIhMdK0BxwMCoGAaLogIa0VAAc1wBDmzxwLy8Plo3xqvzgMIWLwAYuwkfUFgBCOGEdFkE5wBjYHnOdxk6D1JBY2g4-HtAAGABIEOLJdgCMRoHB5aj0XhpV0EWU9lQAEIAQQAIgB9JweACKAFUPKplJR8As4XhZHggA)
-
-The following uses dynamic type checking without code evaluation. This is slower to validate, but may be required in restricted code evaluation environments.
-
-```typescript
-import { Value } from '@sinclair/typebox/value'
-import { TSchema } from '@sinclair/typebox'
-import { TRPCError } from '@trpc/server'
-
-export function RpcType<T extends TSchema>(schema: T, references: TSchema[] = []) {
-  return (value: unknown) => {
-    if (Value.Check(schema, references, value)) return value
-    const { path, message } = Value.Errors(schema, value).First()!
-    throw new TRPCError({ message: `${message} for ${path}`, code: 'BAD_REQUEST' })
-  }
-}
-```
-
-<a name="Ajv"></a>
-
-### With [Ajv](https://www.typescriptlang.org/play?#code/JYWwDg9gTgLgBAbzgFQMoGMAWBTEBDAGjlRjxmHTgF84AzKCEOAcgAEBnYAO3QBs9gUAPQwAnmGwAjCAA9mAWABQoSLEQoASgAUAwgFEoDKNTimzdBkzYwoYdEPbYoANycLl4aPACCAK2cWjCx4-kIAJsDsMEIATAAM8e5K2DKq8LQArjzkEFxwGnbI4tgAPMhwKTDYXGHsKBg4+AB8ABTsWLh4AFwoRFDYtE7V6NjsPWgd+ADaALpwALxwswCUiEqm6LlRcCEBi1zYAO5wfs4ty+tw-YP9PKMAdLTQenhYLS3XQ3er8007-vc8GEwg1Oh8Bl8RssLooNlt4B10ABrBb-Zz3TbgYC8bBtSZ4GGmfowDJQPItZx4XgZbA9LJIrgQQ5cZY9EhkChlP6-NawszAWhwFqIpEUqk06FXbAkslwSnU7CXOFcbZIECjdh4ADm2CI3CieDuWjImBMixF9ycRnYAEIpnEZkq4DBMAxjgdjshtPpDNAWmqNdraXAAAYAEgQ6vYmp1NCexgj+tIRpNVBDRE2YWDzAAQt4ACIAfQ0egAigBVPSoZDMaiE6hKKhAA)
-
-The following uses Ajv to perform more generalized JSON Schema checks across the complete JSON Schema specification.
-
-```typescript
-import { TSchema, Static } from '@sinclair/typebox'
-import { TRPCError } from '@trpc/server'
-import Ajv from 'ajv/dist/2020'
-
-export function RpcType<T extends TSchema>(schema: T, references: TSchema[] = []) {
-  const ajv = new Ajv()
-  references.forEach((reference) => ajv.addSchema(reference))
-  const check = ajv.compile(schema)
-  return (value: unknown): Static<T> => {
-    if (check(value)) return value
-    const { message, instancePath } = check.errors![0]
-    throw new TRPCError({ message: `${message} for ${instancePath}`, code: 'BAD_REQUEST' })
-  }
-}
-```
diff --git a/example/collections/array.ts b/examples/collections/array.ts
similarity index 99%
rename from example/collections/array.ts
rename to examples/collections/array.ts
index 8bc93a37b..1a7a7550b 100644
--- a/example/collections/array.ts
+++ b/examples/collections/array.ts
@@ -33,7 +33,6 @@ import { Value } from '@sinclair/typebox/value'
 // ----------------------------------------------------------------
 // TypeArrayError
 // ----------------------------------------------------------------
-
 export class TypeArrayError extends Error {
   constructor(message: string) {
     super(`${message}`)
@@ -44,15 +43,12 @@ export class TypeArrayLengthError extends Error {
     super('arrayLength not a number')
   }
 }
-
 // ----------------------------------------------------------------
 // TypeArray<T>
 // ----------------------------------------------------------------
-
 export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
   readonly #typeCheck: TypeCheck<T>
   readonly #values: Static<T>[]
-
   constructor(schema: T, arrayLength: number = 0) {
     if (typeof arrayLength !== 'number') throw new TypeArrayLengthError()
     this.#typeCheck = TypeCompiler.Compile(schema)
@@ -61,33 +57,27 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
       this.#values[i] = Value.Create(schema)
     }
   }
-
   // ---------------------------------------------------
   // Indexer
   // ---------------------------------------------------
-
   /** Sets the value at the given index */
   public set(index: number, item: Static<T>): void {
     this.#assertIndexInBounds(index)
     this.#assertItem(index, item)
     this.#values[index] = item
   }
-
   // ---------------------------------------------------
   // Array<T>
   // ---------------------------------------------------
-
   /** Iterator for values in this array */
   public [Symbol.iterator](): IterableIterator<Static<T>> {
     return this.#values[Symbol.iterator]() as IterableIterator<T>
   }
-
   /** Gets the value at the given index */
   public at(index: number): Static<T> {
     this.#assertIndexInBounds(index)
     return this.#values[index] as T
   }
-
   /**
    * Gets the length of the array. This is a number one higher than the highest index in the array.
    */
@@ -106,7 +96,6 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
   public toLocaleString(): string {
     return this.#values.toLocaleString()
   }
-
   /**
    * Removes the last element from an array and returns it.
    * If the array is empty, undefined is returned and the array is not modified.
@@ -128,7 +117,6 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
    * @param items Additional arrays and/or items to add to the end of the array.
    */
   public concat(...items: ConcatArray<Static<T>>[]): Static<T>[]
-
   /**
    * Combines two or more arrays.
    * This method returns a new array without modifying any existing arrays.
@@ -138,7 +126,6 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
     this.#assertItems(items)
     return this.#values.concat(...items) as Static<T>[]
   }
-
   /**
    * Adds all the elements of an array into a string, separated by the specified separator string.
    * @param separator A string used to separate one element of the array from the next in the resulting string. If omitted, the array elements are separated with a comma.
@@ -160,7 +147,6 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
   public shift(): Static<T> | undefined {
     return this.#values.shift() as Static<T> | undefined
   }
-
   /**
    * Returns a copy of a section of an array.
    * For both start and end, a negative index can be used to indicate an offset from the end of the array.
@@ -173,7 +159,6 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
   public slice(start?: number, end?: number): Static<T>[] {
     return this.#values.slice(start, end) as Static<T>[]
   }
-
   /**
    * Sorts an array in place.
    * This method mutates the array and returns a reference to the same array.
@@ -188,7 +173,6 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
     this.#values.sort(compareFn as any)
     return this
   }
-
   /**
    * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
    * @param start The zero-based location in the array from which to start removing elements.
@@ -196,7 +180,6 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
    * @returns An array containing the elements that were deleted.
    */
   public splice(start: number, deleteCount?: number): Static<T>[]
-
   /**
    * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
    * @param start The zero-based location in the array from which to start removing elements.
@@ -208,7 +191,6 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
     this.#assertItems(items)
     return this.#values.splice(start, deleteCount, items) as Static<T>[]
   }
-
   /**
    * Inserts new elements at the start of an array, and returns the new length of the array.
    * @param items Elements to insert at the start of the array.
@@ -217,7 +199,6 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
     this.#assertItems(items)
     return this.#values.unshift(items)
   }
-
   /**
    * Returns the index of the first occurrence of a value in an array, or -1 if it is not present.
    * @param searchElement The value to locate in the array.
@@ -226,7 +207,6 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
   public indexOf(searchElement: Static<T>, fromIndex?: number): number {
     return this.#values.indexOf(searchElement, fromIndex)
   }
-
   /**
    * Returns the index of the last occurrence of a specified value in an array, or -1 if it is not present.
    * @param searchElement The value to locate in the array.
@@ -235,7 +215,6 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
   public lastIndexOf(searchElement: Static<T>, fromIndex?: number): number {
     return this.#values.lastIndexOf(searchElement, fromIndex)
   }
-
   /**
    * Determines whether all the members of an array satisfy the specified test.
    * @param predicate A function that accepts up to three arguments. The every method calls
@@ -245,7 +224,6 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
    * If thisArg is omitted, undefined is used as the this value.
    */
   public every<S extends T>(predicate: (value: Static<T>, index: number, array: Static<T>[]) => value is Static<S>, thisArg?: any): this is Static<S>[]
-
   /**
    * Determines whether all the members of an array satisfy the specified test.
    * @param predicate A function that accepts up to three arguments. The every method calls
@@ -257,7 +235,6 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
   public every(predicate: (value: Static<T>, index: number, array: Static<T>[]) => unknown, thisArg?: any): boolean {
     return this.#values.every(predicate as any, thisArg)
   }
-
   /**
    * Determines whether the specified callback function returns true for any element of an array.
    * @param predicate A function that accepts up to three arguments. The some method calls
@@ -269,7 +246,6 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
   public some(predicate: (value: Static<T>, index: number, array: T[]) => unknown, thisArg?: any): boolean {
     return this.#values.some(predicate as any, thisArg)
   }
-
   /**
    * Performs the specified action for each element in an array.
    * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
@@ -286,7 +262,6 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
   public map<U>(callbackfn: (value: Static<T>, index: number, array: Static<T>[]) => U, thisArg?: any): U[] {
     return this.#values.map(callbackfn as any, thisArg)
   }
-
   /**
    * Returns the elements of an array that meet the condition specified in a callback function.
    * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.
@@ -302,7 +277,6 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
   public filter(predicate: any, thisArg: any): any {
     return this.#values.filter(predicate as any, thisArg)
   }
-
   /**
    * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
    * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
@@ -335,11 +309,9 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
   public reduceRight(callbackfn: any, initialValue?: any): any {
     return this.#values.reduceRight(callbackfn, initialValue)
   }
-
   // ---------------------------------------------------
   // Assertions
   // ---------------------------------------------------
-
   #formatError(errors: ValueError[]) {
     return errors.map((error) => `${error.message} ${error.path}`).join('. ')
   }
@@ -348,21 +320,18 @@ export class TypeArray<T extends TSchema> implements Iterable<Static<T>> {
     if (index >= 0 && index < this.#values.length) return
     throw new TypeArrayError(`Index ${index} is outside the bounds of this Array.`)
   }
-
   /** Asserts the given values */
   #assertItem(index: number, item: unknown): asserts item is Static<T> {
     if (this.#typeCheck.Check(item)) return
     const message = this.#formatError([...this.#typeCheck.Errors(item)])
     throw new TypeArrayError(`Item at Index ${index} is invalid. ${message}`)
   }
-
   /** Asserts the given values */
   #assertItems(items: unknown[]): asserts items is Static<T>[] {
     for (let i = 0; i < items.length; i++) {
       this.#assertItem(i, items[i])
     }
   }
-
   /** Creates a typed array from an existing array */
   public static from<T extends TSchema>(schema: T, iterable: IterableIterator<Static<T>> | Array<Static<T>>): TypeArray<T> {
     if (globalThis.Array.isArray(iterable)) {
diff --git a/example/collections/index.ts b/examples/collections/index.ts
similarity index 100%
rename from example/collections/index.ts
rename to examples/collections/index.ts
diff --git a/example/collections/map.ts b/examples/collections/map.ts
similarity index 97%
rename from example/collections/map.ts
rename to examples/collections/map.ts
index debda1af6..2fa3dffed 100644
--- a/example/collections/map.ts
+++ b/examples/collections/map.ts
@@ -33,39 +33,29 @@ import { Value } from '@sinclair/typebox/value'
 // ----------------------------------------------------------------
 // TypeMapKeyError
 // ----------------------------------------------------------------
-
 export class TypeMapKeyError extends Error {
   constructor(message: string) {
     super(`${message} for key`)
   }
 }
-
-// ----------------------------------------------------------------
-// TypeMapKeyError
-// ----------------------------------------------------------------
-
 export class TypeMapValueError extends Error {
   constructor(key: unknown, message: string) {
     super(`${message} for key ${JSON.stringify(key)}`)
   }
 }
-
 // ----------------------------------------------------------------
 // TypeMap<K, V>
 // ----------------------------------------------------------------
-
 // prettier-ignore
 type TypeMapEntries<K extends TSchema, V extends TSchema> =
   | Iterable<[Static<K>, Static<V>]> 
   | Array<[Static<K>, Static<V>]>
-
 /** Runtime type checked Map collection */
 export class TypeMap<K extends TSchema, V extends TSchema> {
   readonly #keycheck: TypeCheck<K>
   readonly #valuecheck: TypeCheck<V>
   readonly #keys: Map<bigint, Static<K>>
   readonly #values: Map<bigint, Static<V>>
-
   /** Constructs a new HashMap of the given key and value types. */
   constructor(key: K, value: V, entries: TypeMapEntries<K, V> = []) {
     this.#keycheck = TypeCompiler.Compile(key)
@@ -76,40 +66,33 @@ export class TypeMap<K extends TSchema, V extends TSchema> {
       this.set(key, value)
     }
   }
-
   /** Iterator for this TypeMap */
   public *[Symbol.iterator](): IterableIterator<[Static<K>, Static<V>]> {
     for (const [key, value] of this.#values) {
       yield [this.#keys.get(key)!, value]
     }
   }
-
   /** Iterator for the keys in this TypeMap */
   public *keys(): IterableIterator<Static<K>> {
     yield* this.#keys.values()
   }
-
   /** Iterator for the values in this TypeMap */
   public *values(): IterableIterator<Static<V>> {
     yield* this.#values.values()
   }
-
   /** Clears all entries in this map */
   public clear(): void {
     this.#values.clear()
     this.#keys.clear()
   }
-
   /** Executes a provided function once per each key/value pair in the Map, in insertion order. */
   public forEach(callbackfn: (value: Static<V>, key: Static<K>, map: TypeMap<K, V>) => void, thisArg?: any): void {
     this.#values.forEach((value, key) => callbackfn(value, this.#keys.get(key)!, this))
   }
-
   /** @returns the number of elements in the TypeMap. */
   public get size(): number {
     return this.#values.size
   }
-
   /**
    * @returns boolean indicating whether an element with the specified key exists or not.
    */
@@ -117,7 +100,6 @@ export class TypeMap<K extends TSchema, V extends TSchema> {
     this.#assertKey(key)
     return this.#values.has(this.#encodeKey(key))
   }
-
   /**
    * Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.
    * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
@@ -126,7 +108,6 @@ export class TypeMap<K extends TSchema, V extends TSchema> {
     this.#assertKey(key)
     return this.#values.get(this.#encodeKey(key))!
   }
-
   /**
    * Adds a new element with a specified key and value to the Map. If an element with the same key already exists, the element will be updated.
    */
@@ -137,7 +118,6 @@ export class TypeMap<K extends TSchema, V extends TSchema> {
     this.#keys.set(encodedKey, key)
     this.#values.set(encodedKey, value)
   }
-
   /**
    * @returns true if an element in the Map existed and has been removed, or false if the element does not exist.
    */
@@ -147,33 +127,27 @@ export class TypeMap<K extends TSchema, V extends TSchema> {
     this.#keys.delete(encodedKey)
     return this.#values.delete(encodedKey)
   }
-
   // ---------------------------------------------------
   // Encoder
   // ---------------------------------------------------
-
   /** Encodes the key as a 64bit numeric */
   #encodeKey(key: Static<K>) {
     return Value.Hash(key)
   }
-
   // ---------------------------------------------------
   // Assertions
   // ---------------------------------------------------
-
   #formatError(errors: ValueError[]) {
     return errors
       .map((error) => `${error.message} ${error.path}`)
       .join('. ')
       .trim()
   }
-
   /** Asserts the key matches the key schema  */
   #assertKey(key: unknown): asserts key is Static<K> {
     if (this.#keycheck.Check(key)) return
     throw new TypeMapKeyError(this.#formatError([...this.#keycheck.Errors(key)]))
   }
-
   /** Asserts the key matches the value schema  */
   #assertValue(key: Static<K>, value: unknown): asserts value is Static<V> {
     if (this.#valuecheck.Check(value)) return
diff --git a/example/collections/readme.md b/examples/collections/readme.md
similarity index 100%
rename from example/collections/readme.md
rename to examples/collections/readme.md
diff --git a/example/collections/set.ts b/examples/collections/set.ts
similarity index 99%
rename from example/collections/set.ts
rename to examples/collections/set.ts
index 6ca6e055a..4e8d31213 100644
--- a/example/collections/set.ts
+++ b/examples/collections/set.ts
@@ -31,19 +31,16 @@ import { TSchema, Static } from '@sinclair/typebox'
 import { Value } from '@sinclair/typebox/value'
 
 // ----------------------------------------------------------------
-// TypeSetError
+// Errors
 // ----------------------------------------------------------------
-
 export class TypeSetError extends Error {
   constructor(message: string) {
     super(`${message}`)
   }
 }
-
 // ----------------------------------------------------------------
 // TypeSet
 // ----------------------------------------------------------------
-
 /** Runtime type checked Set collection */
 export class TypeSet<T extends TSchema> {
   readonly #valuecheck: TypeCheck<T>
@@ -55,19 +52,16 @@ export class TypeSet<T extends TSchema> {
       this.add(value)
     }
   }
-
   /** Adds a value to this set */
   public add(value: Static<T>): this {
     this.#assertValue(value)
     this.values.set(this.#encodeKey(value), value)
     return this
   }
-
   /** Clears the values in this set */
   public clear(): void {
     this.values.clear()
   }
-
   /**
    * Removes a specified value from the Set.
    * @returns Returns true if an element in the Set existed and has been removed, or false if the element does not exist.
@@ -75,38 +69,31 @@ export class TypeSet<T extends TSchema> {
   public delete(value: Static<T>): boolean {
     return this.values.delete(this.#encodeKey(value))
   }
-
   /** Executes a provided function once per each value in the Set object, in insertion order. */
   public forEach(callbackfn: (value: Static<T>, value2: Static<T>, set: TypeSet<T>) => void, thisArg?: any): void {
     this.values.forEach((value, value2) => callbackfn(value, value2, this), thisArg)
   }
-
   /**
    * @returns a boolean indicating whether an element with the specified value exists in the Set or not.
    */
   public has(value: Static<T>): boolean {
     return this.values.has(this.#encodeKey(value))
   }
-
   /**
    * @returns the number of (unique) elements in Set.
    */
   public get size(): number {
     return this.values.size
   }
-
   // ---------------------------------------------------
   // Encoder
   // ---------------------------------------------------
-
   #encodeKey(value: Static<T>) {
     return Value.Hash(value)
   }
-
   // ---------------------------------------------------
   // Assertions
   // ---------------------------------------------------
-
   /** Formats errors */
   #formatError(errors: ValueError[]) {
     return errors
@@ -114,7 +101,6 @@ export class TypeSet<T extends TSchema> {
       .join('. ')
       .trim()
   }
-
   /** Asserts the key matches the value schema  */
   #assertValue(value: unknown): asserts value is Static<T> {
     if (this.#valuecheck.Check(value)) return
diff --git a/example/formats/index.ts b/examples/formats/index.ts
similarity index 100%
rename from example/formats/index.ts
rename to examples/formats/index.ts
diff --git a/example/formats/readme.md b/examples/formats/readme.md
similarity index 100%
rename from example/formats/readme.md
rename to examples/formats/readme.md
diff --git a/example/formats/standard.ts b/examples/formats/standard.ts
similarity index 100%
rename from example/formats/standard.ts
rename to examples/formats/standard.ts
diff --git a/example/index.ts b/examples/index.ts
similarity index 100%
rename from example/index.ts
rename to examples/index.ts
diff --git a/examples/prototypes/const.ts b/examples/prototypes/const.ts
new file mode 100644
index 000000000..75399a0aa
--- /dev/null
+++ b/examples/prototypes/const.ts
@@ -0,0 +1,61 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/prototypes
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Type, ObjectMap, TypeGuard, TSchema, TIntersect, TUnion, TObject, TProperties, TReadonly, AssertProperties, AssertType, AssertRest, Evaluate, ReadonlyUnwrapType } from '@sinclair/typebox'
+
+// -------------------------------------------------------------------------------------
+// TConst
+// -------------------------------------------------------------------------------------
+// prettier-ignore
+export type TConstArray<T extends TSchema[], E extends boolean> = T extends [infer L, ...infer R]
+  ? [TConst<AssertType<L>, E>, ...TConstArray<AssertRest<R>, E>]
+  : []
+// prettier-ignore
+export type TConstProperties<T extends TProperties, E extends boolean> = Evaluate<AssertProperties<{
+  [K in keyof T]: TConst<ReadonlyUnwrapType<T[K]>, E>
+}>>
+// prettier-ignore
+export type TConst<T extends TSchema, E extends boolean> =
+  T extends TIntersect<infer S> ? TIntersect<TConstArray<S, false>> :
+  T extends TUnion<infer S> ? TUnion<TConstArray<S, false>> :
+  T extends TObject<infer S> ? TObject<TConstProperties<S, false>> :
+  E extends true ? T : TReadonly<T>
+// -------------------------------------------------------------------------------------
+// Const
+// -------------------------------------------------------------------------------------
+/** `[Experimental]` Assigns readonly to all interior properties */
+export function Const<T extends TSchema>(schema: T): TConst<T, true> {
+  const mappable = (TypeGuard.TIntersect(schema) || TypeGuard.TUnion(schema) || TypeGuard.TObject(schema))
+  // prettier-ignore
+  return mappable ? ObjectMap.Map(schema, (object) => {
+    const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
+      return { ...acc, [key]: Type.Readonly(object.properties[key] )}
+    }, {} as TProperties)
+    return Type.Object(properties, {...object})
+  }, {}) : schema as any
+}
\ No newline at end of file
diff --git a/examples/prototypes/evaluate.ts b/examples/prototypes/evaluate.ts
new file mode 100644
index 000000000..5fa7b2128
--- /dev/null
+++ b/examples/prototypes/evaluate.ts
@@ -0,0 +1,135 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/prototypes
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import {
+  AssertRest,
+  AssertType,
+  Static,  
+  Type, 
+  TypeGuard, 
+  TSchema,  
+  TObject, 
+  Evaluate, 
+  TArray, 
+  TFunction, 
+  TConstructor, 
+  TPromise, 
+  TIterator, 
+  TAsyncIterator, 
+  TTuple, 
+  TProperties, 
+  TIntersect, 
+  IntersectType, 
+  TUnion, 
+  TNever 
+} from '@sinclair/typebox'
+
+// --------------------------------------------------------------------------
+// TEvaluate
+// --------------------------------------------------------------------------
+// prettier-ignore
+export type TEvaluateIntersectType<L extends TSchema, R extends TSchema> = (
+  Static<L> extends Static<R> ? 
+    Static<R> extends Static<L> ? R :
+    Static<L> extends Static<R> ? L :
+    TNever : 
+  Static<R> extends Static<L> ? R : 
+    TNever
+)
+// prettier-ignore
+export type TEvaluateIntersectRest<T extends TSchema[]> = 
+  T extends [infer L, infer R, ...infer Rest] ? TEvaluateIntersectRest<[TEvaluateIntersectType<AssertType<L>, AssertType<R>>, ...AssertRest<Rest>]> : 
+  T
+// prettier-ignore
+export type TEvaluateProperties<T extends TProperties> = Evaluate<{
+  [K in keyof T]: TEvaluate<T[K]>
+}>
+// prettier-ignore
+export type TEvaluateArray<T extends TSchema[]> =  T extends [infer L, ...infer R] ? 
+  [TEvaluate<AssertType<L>>, ...TEvaluateArray<AssertRest<R>>] : 
+  []
+// prettier-ignore
+export type TEvaluate<T extends TSchema> = 
+  T extends TIntersect<infer S>            ? IntersectType<TEvaluateIntersectRest<S>> :
+  T extends TUnion<infer S>                ? TUnion<TEvaluateArray<S>> :
+  T extends TConstructor<infer P, infer R> ? TConstructor<TEvaluateArray<P>, TEvaluate<R>> : 
+  T extends TFunction<infer P, infer R>    ? TFunction<TEvaluateArray<P>, TEvaluate<R>> : 
+  T extends TObject<infer S>               ? TObject<TEvaluateProperties<S>> : 
+  T extends TTuple<infer S>                ? TTuple<TEvaluateArray<S>> :
+  T extends TArray<infer S>                ? TArray<TEvaluate<S>> :
+  T extends TPromise<infer S>              ? TPromise<TEvaluate<S>> :
+  T extends TIterator<infer S>             ? TIterator<TEvaluate<S>> :
+  T extends TAsyncIterator<infer S>        ? TAsyncIterator<TEvaluate<S>> :
+  T
+// --------------------------------------------------------------------------
+// Evaluate
+// --------------------------------------------------------------------------
+// prettier-ignore
+export function EvaluateIntersectType<X extends TSchema, Y extends TSchema>(L: X, R: Y) {
+  return Type.Extends(L, R, 
+    Type.Extends(R, L, R, 
+    Type.Extends(L, R, L, 
+  Type.Never())), 
+    Type.Extends(R, L, R, 
+    Type.Never()))
+}
+// prettier-ignore
+export function EvaluateIntersectRest<T extends TSchema[]>(T: [...T]): TEvaluateIntersectRest<T> {
+  if(T.length >= 2) {
+    const [L, R, ...Rest] = T
+    return EvaluateIntersectRest([EvaluateIntersectType(L, R), ...Rest]) as any
+  } else {
+    return T as any
+  }
+}
+export function EvaluateProperties<T extends TProperties>(properties: T) {
+  return Object.getOwnPropertyNames(properties).reduce((acc, key) => {
+    return { ...acc, [key]: Evaluate(properties[key]) }
+  }, {} as TProperties)
+}
+export function EvaluateArray<T extends TSchema[] | undefined>(rest: T) {
+  if (rest === undefined) return [] // for tuple items
+  return rest.map((schema) => Evaluate(schema))
+}
+// prettier-ignore
+export function Evaluate<T extends TSchema>(schema: T): TEvaluate<T> {
+  return (
+    TypeGuard.TIntersect(schema)     ? Type.Intersect(EvaluateIntersectRest(schema.allOf)) :
+    TypeGuard.TUnion(schema)         ? Type.Union(EvaluateArray(schema.anyOf)) :
+    TypeGuard.TAsyncIterator(schema) ? Type.AsyncIterator(Evaluate(schema.items)) :
+    TypeGuard.TIterator(schema)      ? Type.Iterator(Evaluate(schema.items)) :
+    TypeGuard.TObject(schema)        ? Type.Object(EvaluateProperties(schema.properties)) :
+    TypeGuard.TConstructor(schema)   ? Type.Constructor(EvaluateArray(schema.parameters), Evaluate(schema.returns)) :
+    TypeGuard.TFunction(schema)      ? Type.Function(EvaluateArray(schema.parameters), Evaluate(schema.returns)) :
+    TypeGuard.TTuple(schema)         ? Type.Tuple(EvaluateArray(schema.items)) :
+    TypeGuard.TArray(schema)         ? Type.Promise(Evaluate(schema.items)) :
+    TypeGuard.TPromise(schema)       ? Type.Promise(Evaluate(schema.item)) :
+    schema 
+  ) as TEvaluate<T>
+}
+
diff --git a/example/experimental/index.ts b/examples/prototypes/index.ts
similarity index 92%
rename from example/experimental/index.ts
rename to examples/prototypes/index.ts
index daddc72d8..ef44e7d95 100644
--- a/example/experimental/index.ts
+++ b/examples/prototypes/index.ts
@@ -1,6 +1,6 @@
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox/experimental
+@sinclair/typebox/prototypes
 
 The MIT License (MIT)
 
@@ -26,6 +26,8 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export * from './readonly-object'
+export * from './const'
+export * from './evaluate'
+export * from './partial-deep'
 export * from './union-enum'
 export * from './union-oneof'
diff --git a/examples/prototypes/partial-deep.ts b/examples/prototypes/partial-deep.ts
new file mode 100644
index 000000000..1315b65b0
--- /dev/null
+++ b/examples/prototypes/partial-deep.ts
@@ -0,0 +1,65 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/prototypes
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TypeGuard, Type, TSchema, TIntersect, TUnion, TObject, TPartial, TProperties, AssertRest, AssertType, Evaluate } from '@sinclair/typebox'
+
+// -------------------------------------------------------------------------------------
+// TDeepPartial
+// -------------------------------------------------------------------------------------
+export type TPartialDeepProperties<T extends TProperties> = {
+  [K in keyof T]: TPartial<T[K]>
+}
+export type TPartialDeepRest<T extends TSchema[]> = T extends [infer L, ...infer R]
+  ? [TPartial<AssertType<L>>, ...TPartialDeepRest<AssertRest<R>>]
+  : []
+export type TPartialDeep<T extends TSchema> = 
+  T extends TIntersect<infer S> ? TIntersect<TPartialDeepRest<S>> :
+  T extends TUnion<infer S> ? TUnion<TPartialDeepRest<S>> :
+  T extends TObject<infer S> ? TPartial<TObject<Evaluate<TPartialDeepProperties<S>>>> :
+  T
+// -------------------------------------------------------------------------------------
+// DeepPartial
+// -------------------------------------------------------------------------------------
+function PartialDeepProperties<T extends TProperties>(properties: T) {
+  return Object.getOwnPropertyNames(properties).reduce((acc, key) => {
+    return {...acc, [key]: Type.Partial(properties[key])}
+  }, {} as TProperties)
+}
+function PartialDeepRest<T extends TSchema[]>(rest: [...T]): TPartialDeepRest<T> {
+  const [L, ...R] = rest
+  return (R.length > 0) ? [Type.Partial(L), ...PartialDeepRest(R)] : [] as any
+}
+/** Maps the given schema as deep partial, making all properties and sub properties optional */
+export function PartialDeep<T extends TSchema>(type: T): TPartialDeep<T> {
+  return (
+    TypeGuard.TIntersect(type) ? Type.Intersect(PartialDeepRest(type.allOf)) :
+    TypeGuard.TUnion(type) ? Type.Union(PartialDeepRest(type.anyOf)) :
+    TypeGuard.TObject(type) ? Type.Partial(Type.Object(PartialDeepProperties(type.properties))) :
+    type
+  ) as any
+}
\ No newline at end of file
diff --git a/examples/prototypes/readme.md b/examples/prototypes/readme.md
new file mode 100644
index 000000000..77a962c70
--- /dev/null
+++ b/examples/prototypes/readme.md
@@ -0,0 +1,114 @@
+# TypeBox Prototypes
+
+TypeBox prototypes are a set of types that are either under consideration for inclusion into the library, or have been requested by users but cannot be added to the library either due to complexity, using schematics that fall outside the supported TypeBox or should be expressed by users via advanced type composition. 
+
+Each prototype is written as a standalone module that can be copied into projects and used directly, or integrated into extended type builders.
+
+## Const
+
+This type will wrap all interior properties as `readonly` leaving the outer type unwrapped. This type is analogous to the `Readonly<T>` TypeScript utility type, but as TypeBox uses this name as a property modifier, the name `Const` is used.
+
+```typescript
+import { Const } from './prototypes'
+
+const T = Const(Type.Object({                       // const T: TObject<{
+  x: Type.Number()                                  //   x: Type.Readonly(Type.Number())
+}))                                                 // }>
+
+type T = Static<typeof T>                           // type T = {
+                                                    //   readonly x: number
+                                                    // }
+```
+## Evaluate
+
+This type is an advanced mapping type will evaluate for schema redundancy by reducing evaluating intersection rest arguments. This type detects if intersection would produce illogical `never`, removes duplicates and handles intersection type narrowing. This type is a strong candidate for inclusion into the TypeBox library but is pending an equivalent redundancy check for `union` rest arguments. 
+
+```typescript
+import { Evaluate } from './prototypes'
+
+// Evaluate for Duplicates
+//
+const T = Type.Intersect([ Type.Number(), Type.Number(), Type.Number() ])
+
+const E = Evaluate(T)                               // const E: TNumber
+
+// Evaluate for TNever
+//
+const T = Type.Intersect([ Type.Number(), Type.String() ])
+
+const E = Evaluate(T)                               // const E: TIntersect<[TNumber, TString]>
+
+// Evaluate for most narrowed type
+//
+const T = Type.Intersect([ Type.Number(), Type.Literal(1) ])
+
+const E = Evaluate(T)                               // const E: TLiteral<1>
+```
+
+## PartialDeep
+
+Maps the given schema as deep partial, making all properties and sub properties optional. This type is asked for on occation, but as there is no TypeScript equivalent and because this type is typically handled through end user type mapping, this type is left out of TypeBox.
+
+```typescript
+import { PartialDeep } from './prototypes'
+
+const T = Type.Object({ 
+  x: Type.Object({
+    x: Type.Number(),
+    y: Type.Number()
+  }),
+  y: Type.Object({
+    x: Type.Number(),
+    y: Type.Number()
+  })
+})
+
+const P = PartialDeep(T)
+
+type P = Static<typeof P>                           // type P = {
+                                                    //   x?: {
+                                                    //     x?: number,
+                                                    //     y?: number
+                                                    //   },
+                                                    //   y?: {
+                                                    //     x?: number,
+                                                    //     y?: number
+                                                    //   },
+                                                    // }
+```
+
+## UnionEnum
+
+Creates an `enum` union string schema representation. This type is often requested by OpenAPI users, particularily for documentation presentation. As TypeBox standardizes on `anyOf` for all unions, this type is generally at odds with TypeBox's internal representation. Some considerations for internally remapping this type into a `anyOf` through composition have been considered (and would be feasible), but as TypeScript doesn't have multiple representations for unions, neither should TypeBox, making this type an unlikely candidate.
+
+```typescript
+import { UnionEnum } from './prototypes'
+
+
+const T = UnionEnum(['A', 'B', 'C'])                // const T = {
+                                                    //   enum: ['A', 'B', 'C']
+                                                    // }
+
+type T = Static<typeof T>                           // type T = 'A' | 'B' | 'C'
+
+```
+## UnionOneOf
+
+Creates a `oneOf` union representation. This type is often requested by users looking for discriminated union support (which is not formally supported by JSON Schema). TypeBox omits this type as `oneOf` has the potential to create illogical schematics where values match more than one sub schema (making type inference extremely difficult). TypeBox preferences users explicitly narrowing on a overlapping union post type check, making `anyOf` the ideal representation, leaving the `oneOf` type an unlikely candidate for inclusion in the library.
+
+
+```typescript
+import { UnionOneOf } from './prototypes'
+
+
+const T = UnionOneOf([                              // const T = {
+  Type.Literal('A'),                                //   oneOf: [
+  Type.Literal('B'),                                //     { const: 'A' },
+  Type.Literal('C')                                 //     { const: 'B' },
+])                                                  //     { const: 'C' },
+                                                    //   ]
+                                                    // }
+
+type T = Static<typeof T>                           // type T = 'A' | 'B' | 'C'
+
+```
\ No newline at end of file
diff --git a/example/experimental/union-enum.ts b/examples/prototypes/union-enum.ts
similarity index 78%
rename from example/experimental/union-enum.ts
rename to examples/prototypes/union-enum.ts
index 9f0bd77f1..ee55d202c 100644
--- a/example/experimental/union-enum.ts
+++ b/examples/prototypes/union-enum.ts
@@ -1,6 +1,6 @@
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox/experimental
+@sinclair/typebox/prototypes
 
 The MIT License (MIT)
 
@@ -26,22 +26,24 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import * as Types from '@sinclair/typebox'
+import { TypeRegistry, Kind, TSchema, SchemaOptions } from '@sinclair/typebox'
 
 // -------------------------------------------------------------------------------------
 // TUnionEnum
 // -------------------------------------------------------------------------------------
-export interface TUnionEnum<T extends (string | number)[]> extends Types.TSchema {
-  [Types.Kind]: 'UnionEnum'
+export interface TUnionEnum<T extends (string | number)[]> extends TSchema {
+  [Kind]: 'UnionEnum'
   static: T[number]
   enum: T
 }
-
+// -------------------------------------------------------------------------------------
+// UnionEnum
+// -------------------------------------------------------------------------------------
 /** `[Experimental]` Creates a Union type with a `enum` schema representation  */
-export function UnionEnum<T extends (string | number)[]>(values: [...T], options: Types.SchemaOptions = {}) {
+export function UnionEnum<T extends (string | number)[]>(values: [...T], options: SchemaOptions = {}) {
   function UnionEnumCheck(schema: TUnionEnum<(string | number)[]>, value: unknown) {
     return (typeof value === 'string' || typeof value === 'number') && schema.enum.includes(value)
   }
-  if (!Types.TypeRegistry.Has('UnionEnum')) Types.TypeRegistry.Set('UnionEnum', UnionEnumCheck)
-  return { ...options, [Types.Kind]: 'UnionEnum', enum: values } as TUnionEnum<T>
+  if (!TypeRegistry.Has('UnionEnum')) TypeRegistry.Set('UnionEnum', UnionEnumCheck)
+  return { ...options, [Kind]: 'UnionEnum', enum: values } as TUnionEnum<T>
 }
\ No newline at end of file
diff --git a/example/experimental/union-oneof.ts b/examples/prototypes/union-oneof.ts
similarity index 61%
rename from example/experimental/union-oneof.ts
rename to examples/prototypes/union-oneof.ts
index cec504644..5129d457a 100644
--- a/example/experimental/union-oneof.ts
+++ b/examples/prototypes/union-oneof.ts
@@ -1,6 +1,6 @@
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox/experimental
+@sinclair/typebox/prototypes
 
 The MIT License (MIT)
 
@@ -26,19 +26,25 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import * as Types from '@sinclair/typebox'
+import { TypeRegistry, Kind, Static, TSchema, SchemaOptions } from '@sinclair/typebox'
 import { Value } from '@sinclair/typebox/value'
 
-export interface TUnionOneOf<T extends Types.TSchema[]> extends Types.TSchema {
-  [Types.Kind]: 'UnionOneOf'
-  static: { [K in keyof T]: Types.Static<T[K]> }[number]
+// -------------------------------------------------------------------------------------
+// TUnionOneOf
+// -------------------------------------------------------------------------------------
+export interface TUnionOneOf<T extends TSchema[]> extends TSchema {
+  [Kind]: 'UnionOneOf'
+  static: { [K in keyof T]: Static<T[K]> }[number]
   oneOf: T
 }
+// -------------------------------------------------------------------------------------
+// UnionOneOf
+// -------------------------------------------------------------------------------------
 /** `[Experimental]` Creates a Union type with a `oneOf` schema representation */
-export function UnionOneOf<T extends Types.TSchema[]>(oneOf: [...T], options: Types.SchemaOptions = {}) {
-  function UnionOneOfCheck(schema: TUnionOneOf<Types.TSchema[]>, value: unknown) {
+export function UnionOneOf<T extends TSchema[]>(oneOf: [...T], options: SchemaOptions = {}) {
+  function UnionOneOfCheck(schema: TUnionOneOf<TSchema[]>, value: unknown) {
     return 1 === schema.oneOf.reduce((acc: number, schema: any) => (Value.Check(schema, value) ? acc + 1 : acc), 0)
   }
-  if (!Types.TypeRegistry.Has('UnionOneOf')) Types.TypeRegistry.Set('UnionOneOf', UnionOneOfCheck)
-  return { ...options, [Types.Kind]: 'UnionOneOf', oneOf } as TUnionOneOf<T>
+  if (!TypeRegistry.Has('UnionOneOf')) TypeRegistry.Set('UnionOneOf', UnionOneOfCheck)
+  return { ...options, [Kind]: 'UnionOneOf', oneOf } as TUnionOneOf<T>
 }
\ No newline at end of file
diff --git a/examples/transform/index.ts b/examples/transform/index.ts
new file mode 100644
index 000000000..d0bddc5f1
--- /dev/null
+++ b/examples/transform/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/transform
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './transform'
\ No newline at end of file
diff --git a/examples/transform/readme.md b/examples/transform/readme.md
new file mode 100644
index 000000000..bb02bc888
--- /dev/null
+++ b/examples/transform/readme.md
@@ -0,0 +1,83 @@
+# Transform Types
+
+Transform Types are an experimental codec system that supports deferred encode and decode of typed data structures received over IO interfaces. This system is undergoing consideration for inclusion in the TypeBox library.
+
+### Design
+
+The following is the high level design for Transform types. It consists of three functions, `Transform`, `Decode` and `Encode`. The following is the general usage.
+
+```typescript
+import { Transform, Encode, Decode } from './transform'
+
+const Timestamp = Transform(Type.Number(), {       // The Transform function wraps a TypeBox type with two codec
+  decode: (value) => new Date(value),              // functions which implement logic to decode a received value
+  encode: (value) => value.getTime(),              // (i.e. number) into a application type (Date). The encode
+})                                                 // function handles the reverse mapping.
+
+type N = Static<typeof N>                          // type N = { timestamp: number }
+                                                   //
+const N = Type.Object({                            // Transform types are to be used like any other type and will
+  timestamp: Timestamp                             // infer as the original TypeBox type. For example, the type `N` 
+})                                                 // above will infer as { timestamp: number } (as derived from 
+                                                   // the TB type)
+
+
+
+const D = Decode(N, { timestamp: 123 })            // const D = { timestamp: Date(123) }
+                                                   //
+                                                   // The Decode function accepts any type plus a value. The Decode 
+                                                   // function return type will be that of the transforms decode() 
+                                                   // return type (which is Date), with the second argument statically
+                                                   // typed as N. This function acts as a kind of parse() that returns 
+                                                   // the decoded type or throws on validation error.
+                                               
+
+const E = Encode(N, { timestamp: new Date(123) })  // const E = { timestamp: 123 }
+                                                   //
+                                                   // The encode function performs the inverse, accepting the
+                                                   // decoded type { timestamp: Date } and re-encoding to the
+                                                   // target type { timestamp: number }. This function will
+                                                   // also throw on validation error.
+```
+### Integration
+
+A practical use case for Transform types is the automatic encode and decode of values received over the network. The following is an example implementation using the Fastify web framework with the TypeBox Type Provider (used for auto type inference). Note that this usage wouldn't be exclusive to Fastify. The implementation below uses explicit Decode and Encode within a route handler.
+
+```typescript
+import { Type, TypeBoxTypeProvider } from '@fastify/type-provider-typebox'
+import Fastify from 'fastify'
+
+const Data = Type.Object({                       
+  timestamp: Transform(Type.Number(), {       
+    decode: (value) => new Date(value),         
+    encode: (value) => value.getTime(),     
+  })                           
+})
+
+Fastify().withTypeProvider<TypeBoxTypeProvider>().post('/', {
+  schema: {
+    body: Data
+    response: { 200: Data }
+  }
+}, (req, res) => {
+  const decoded = Decode(Data, req.body)           // decode { timestamp: number }
+                                                   //     as { timestamp: Date }
+
+  // ... some operations on decoded value
+  //
+  // i.e. decoded.timestamp.getTime()
+
+  const encoded = Encode(Data, decoded)            // encode { timetamp: Date }
+                                                   //     as { timestamp: number }
+  
+  res.status(200).send(encoded)                    // send!
+})
+```
+
+### Current Status
+
+From the example above, the current design of Transform types would require explicit Encode and Decode within a route handler (or other function in receipt of data); and it would be very challenging for general purpose frameworks to integrate this functionality in a more concise fashion (currently). 
+
+Possible options to make this more cohesive may be to provide route wrapping functions to handle codec execution and type inference.  More integrated solutions would involve framework maintainers offering codec supportive type definitions to act as hooks for auto static inference (on both decode and encode phases). The latter option is the preference but would require a fair amount of engineering in downstream frameworks.
+
+Given the many unknowns and general complexity surrounding this feature, TypeBox offers the Transform implementation to the community (as a single `transform.ts` module) for experimentation and general feedback. TypeBox welcomes third party packages, example user integrations, code enhancements or general insight into end user usage patterns.
\ No newline at end of file
diff --git a/examples/transform/transform.ts b/examples/transform/transform.ts
new file mode 100644
index 000000000..31d20f26c
--- /dev/null
+++ b/examples/transform/transform.ts
@@ -0,0 +1,346 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/transform
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '@sinclair/typebox'
+import * as ValueGuard from '@sinclair/typebox/value/guard'
+import * as ValueCheck from '@sinclair/typebox/value/check'
+
+// --------------------------------------------------------------------------
+// Symbols
+// --------------------------------------------------------------------------
+export const TransformSymbol = Symbol.for('TypeBox.Transform')
+
+// ----------------------------------------------------------------------------------------------
+// Errors
+// ----------------------------------------------------------------------------------------------
+export class TransformDecodeError extends Error {
+  constructor(public readonly schema: Types.TSchema, public readonly value: unknown) {
+    super('ValueTransform: The value passed to decode was invalid')
+  }
+}
+export class TransformEncodeError extends Error {
+  constructor(public readonly schema: Types.TSchema, public readonly value: unknown) {
+    super('ValueTransform: The encode function returned an invalid value')
+  }
+}
+export class ValueTransformUnknownTypeError extends Error {
+  constructor(public readonly schema: Types.TSchema) {
+    super('Unknown type')
+  }
+}
+export class ValueTransformDereferenceError extends Error {
+  constructor(public readonly schema: Types.TRef | Types.TThis) {
+    super(`Unable to dereference type with $id '${schema.$ref}'`)
+  }
+}
+export class ValueTransformFallthroughError extends Error {
+  constructor(public readonly schema: Types.TSchema, public readonly value: unknown, public mode: ValueTransformMode) {
+    super('Unexpected transform error')
+  }
+}
+export class ValueTransformCodecError extends Error {
+  constructor(public readonly schema: Types.TSchema, public readonly value: unknown, public mode: ValueTransformMode, error: any) {
+    super(`${error instanceof Error ? error.message : 'Unknown'}`)
+  }
+}
+export type ValueTransformMode = 'encode' | 'decode'
+
+// ----------------------------------------------------------------------------------------------
+// Apply
+// ----------------------------------------------------------------------------------------------
+function Apply(schema: Types.TSchema, value: any, mode: ValueTransformMode) {
+  try {
+    if (!HasTransform(schema)) return value
+    const transform = schema[TransformSymbol] as unknown as TransformCodec
+    if (mode === 'decode') return transform.decode(value)
+    if (mode === 'encode') return transform.encode(value)
+  } catch (error) {
+    throw new ValueTransformCodecError(schema, value, mode, error)
+  }
+}
+// --------------------------------------------------------------------------
+// Guards
+// --------------------------------------------------------------------------
+function HasTransform(schema: Types.TSchema): schema is Types.TSchema & { [TransformSymbol]: TransformCodec } {
+  return ValueGuard.HasPropertyKey(schema, TransformSymbol)
+}
+// ----------------------------------------------------------------------------------------------
+// Transform
+// ----------------------------------------------------------------------------------------------
+function TAny(schema: Types.TAny, references: Types.TSchema[], value: any, mode: ValueTransformMode): any {
+  return Apply(schema, value, mode)
+}
+function TArray(schema: Types.TArray, references: Types.TSchema[], value: any, mode: ValueTransformMode): any {
+  const transformed = Apply(schema, value, mode)
+  return transformed.map((value: any) => Visit(schema.items, references, value, mode))
+}
+function TBigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TBoolean(schema: Types.TBoolean, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TConstructor(schema: Types.TConstructor, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TDate(schema: Types.TDate, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TFunction(schema: Types.TFunction, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TInteger(schema: Types.TInteger, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TLiteral(schema: Types.TLiteral, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TNever(schema: Types.TNever, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TNull(schema: Types.TNull, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TNumber(schema: Types.TNumber, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TObject(schema: Types.TObject, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Object.keys(schema.properties).reduce((acc, key) => {
+    return value[key] !== undefined ? { ...acc, [key]: Visit(schema.properties[key], references, value[key], mode) } : { ...acc }
+  }, value)
+}
+function TPromise(schema: Types.TSchema, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  const transformed = Apply(schema, value, mode)
+  const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0]
+  const property = schema.patternProperties[propertyKey]
+  const result = {} as Record<string, unknown>
+  for (const [propKey, propValue] of Object.entries(transformed)) {
+    result[propKey] = Visit(property, references, propValue, mode)
+  }
+  return result
+}
+function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+  if (index === -1) throw new ValueTransformDereferenceError(schema)
+  const target = references[index]
+  const resolved = Visit(target, references, value, mode)
+  return Apply(schema, resolved, mode)
+}
+function TString(schema: Types.TString, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TSymbol(schema: Types.TSymbol, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TTemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TThis(schema: Types.TThis, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+  if (index === -1) throw new ValueTransformDereferenceError(schema)
+  const target = references[index]
+  const resolved = Visit(target, references, value, mode)
+  return Apply(schema, resolved, mode)
+}
+function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  const transformed = Apply(schema, value, mode)
+  // prettier-ignore
+  return Apply(schema, transformed.map((value: any, index: any) => {
+    return index < schema.items!.length ? Visit(schema.items![index], references, value, mode) : value
+  }), mode)
+}
+function TUndefined(schema: Types.TUndefined, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  const transformed = Apply(schema, value, mode)
+  for (const subschema of schema.anyOf) {
+    const inner = Visit(subschema, references, transformed, mode)
+    if (ValueCheck.Check(subschema, references, inner)) {
+      return Apply(schema, inner, mode)
+    }
+  }
+  return transformed
+}
+function TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TUnknown(schema: Types.TUnknown, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TVoid(schema: Types.TVoid, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function TKind(schema: Types.TSchema, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
+  return Apply(schema, value, mode)
+}
+function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any, mode: ValueTransformMode): any {
+  const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references
+  const schema_ = schema as any
+  switch (schema[Types.Kind]) {
+    case 'Any':
+      return TAny(schema_, references_, value, mode)
+    case 'Array':
+      return TArray(schema_, references_, value, mode)
+    case 'BigInt':
+      return TBigInt(schema_, references_, value, mode)
+    case 'Boolean':
+      return TBoolean(schema_, references_, value, mode)
+    case 'Constructor':
+      return TConstructor(schema_, references_, value, mode)
+    case 'Date':
+      return TDate(schema_, references_, value, mode)
+    case 'Function':
+      return TFunction(schema_, references_, value, mode)
+    case 'Integer':
+      return TInteger(schema_, references_, value, mode)
+    case 'Intersect':
+      return TIntersect(schema_, references_, value, mode)
+    case 'Literal':
+      return TLiteral(schema_, references_, value, mode)
+    case 'Never':
+      return TNever(schema_, references_, value, mode)
+    case 'Null':
+      return TNull(schema_, references_, value, mode)
+    case 'Number':
+      return TNumber(schema_, references_, value, mode)
+    case 'Object':
+      return TObject(schema_, references_, value, mode)
+    case 'Promise':
+      return TPromise(schema_, references_, value, mode)
+    case 'Record':
+      return TRecord(schema_, references_, value, mode)
+    case 'Ref':
+      return TRef(schema_, references_, value, mode)
+    case 'String':
+      return TString(schema_, references_, value, mode)
+    case 'Symbol':
+      return TSymbol(schema_, references_, value, mode)
+    case 'TemplateLiteral':
+      return TTemplateLiteral(schema_, references_, value, mode)
+    case 'This':
+      return TThis(schema_, references_, value, mode)
+    case 'Tuple':
+      return TTuple(schema_, references_, value, mode)
+    case 'Undefined':
+      return TUndefined(schema_, references_, value, mode)
+    case 'Union':
+      return TUnion(schema_, references_, value, mode)
+    case 'Uint8Array':
+      return TUint8Array(schema_, references_, value, mode)
+    case 'Unknown':
+      return TUnknown(schema_, references_, value, mode)
+    case 'Void':
+      return TVoid(schema_, references_, value, mode)
+    default:
+      if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueTransformUnknownTypeError(schema_)
+      return TKind(schema_, references_, value, mode)
+  }
+}
+// --------------------------------------------------------------------------
+// Transform Unwrap
+// --------------------------------------------------------------------------
+// prettier-ignore
+export type TransformUnwrapProperties<T extends Types.TProperties> = {
+  [K in keyof T]: TransformUnwrap<T[K]>
+}
+// prettier-ignore
+export type TransformUnwrapRest<T extends Types.TSchema[]> = T extends [infer L, ...infer R]
+  ? [TransformUnwrap<Types.AssertType<L>>, ...TransformUnwrapRest<Types.AssertRest<R>>]
+  : []
+// prettier-ignore
+export type TransformUnwrap<T extends Types.TSchema> =
+  T extends TTransform<infer _, infer R> ? Types.TUnsafe<R> : 
+  T extends Types.TConstructor<infer P, infer R> ? Types.TConstructor<Types.AssertRest<TransformUnwrapRest<P>>, TransformUnwrap<R>> :
+  T extends Types.TFunction<infer P, infer R> ? Types.TFunction<Types.AssertRest<TransformUnwrapRest<P>>, TransformUnwrap<R>> :
+  T extends Types.TIntersect<infer S> ? Types.TIntersect<Types.AssertRest<TransformUnwrapRest<S>>> :
+  T extends Types.TUnion<infer S> ? Types.TUnion<Types.AssertRest<TransformUnwrapRest<S>>> :
+  T extends Types.TNot<infer S> ? Types.TNot<TransformUnwrap<S>> :
+  T extends Types.TTuple<infer S> ? Types.TTuple<Types.AssertRest<TransformUnwrapRest<S>>> :
+  T extends Types.TAsyncIterator<infer S> ? Types.TAsyncIterator<TransformUnwrap<S>> :
+  T extends Types.TIterator<infer S> ? Types.TIterator<TransformUnwrap<S>> :
+  T extends Types.TObject<infer S> ? Types.TObject<Types.Evaluate<TransformUnwrapProperties<S>>> :
+  T extends Types.TRecord<infer K, infer S> ? Types.TRecord<K, TransformUnwrap<S>> :
+  T extends Types.TArray<infer S> ? Types.TArray<TransformUnwrap<S>> :
+  T extends Types.TPromise<infer S> ? Types.TPromise<TransformUnwrap<S>> :
+  T
+// --------------------------------------------------------------------------
+// Transform Types
+// --------------------------------------------------------------------------
+export type TransformFunction<T = any, U = any> = (value: T) => U
+
+export interface TransformCodec<Input extends Types.TSchema = Types.TSchema, Output extends unknown = unknown> {
+  decode: TransformFunction<Types.Static<Input>, Output>
+  encode: TransformFunction<Output, Types.Static<Input>>
+}
+export interface TTransform<Input extends Types.TSchema = Types.TSchema, Output extends unknown = unknown> extends Types.TSchema {
+  static: Types.Static<Input>
+  [TransformSymbol]: TransformCodec<Input, Output>
+  [key: string]: any
+}
+// --------------------------------------------------------------------------
+// Transform Functions
+// --------------------------------------------------------------------------
+/** Creates a transform type by applying transform codec */
+export function Transform<Input extends Types.TSchema, Output extends unknown>(schema: Input, codec: TransformCodec<Input, Output>): TTransform<Input, Output> {
+  if (!HasTransform(schema)) return { ...schema, [TransformSymbol]: codec } as TTransform<Input, Output>
+  const mapped_encode = (value: unknown) => schema[TransformSymbol].encode(codec.encode(value as any))
+  const mapped_decode = (value: unknown) => codec.decode(schema[TransformSymbol].decode(value))
+  const mapped_codec = { encode: mapped_encode, decode: mapped_decode }
+  return { ...schema, [TransformSymbol]: mapped_codec } as TTransform<Input, Output>
+}
+/** Decodes a value using the given type. Will apply an transform codecs found for any sub type */
+export function Decode<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: Types.Static<T>): Types.Static<TransformUnwrap<T>>
+/** Decodes a value using the given type. Will apply an transform codecs found for any sub type */
+export function Decode<T extends Types.TSchema>(schema: T, value: Types.Static<T>): Types.Static<TransformUnwrap<T>>
+/** Decodes a value using the given type. Will apply an transform codecs found for any sub type */
+export function Decode(...args: any[]) {
+  const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
+  const check = ValueCheck.Check(schema, references, value)
+  if (!check) throw new TransformDecodeError(schema, value)
+  const decoded = Visit(schema, references, value, 'decode')
+  return decoded
+}
+/** Encodes a value using the given type. Will apply an transforms found for any sub type */
+export function Encode<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: Types.Static<TransformUnwrap<T>>): Types.Static<T>
+/** Encodes a value using the given type. Will apply an transforms found for any sub type */
+export function Encode<T extends Types.TSchema>(schema: T, value: Types.Static<TransformUnwrap<T>>): Types.Static<T>
+/** Encodes a value using the given type. Will apply an transforms found for any sub type */
+export function Encode(...args: any[]) {
+  const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
+  const encoded = Visit(schema, references, value, 'encode')
+  const check = ValueCheck.Check(schema, references, encoded)
+  if (!check) throw new TransformEncodeError(schema, value)
+  return encoded
+}
diff --git a/examples/trpc/readme.md b/examples/trpc/readme.md
new file mode 100644
index 000000000..c5c7051e8
--- /dev/null
+++ b/examples/trpc/readme.md
@@ -0,0 +1,46 @@
+# Using TypeBox with TRPC
+
+To use TypeBox with TRPC, you will need to wrap types in a TRPC compatible validation function. The following shows wrapping a type using the TypeCompiler.
+
+<a name="Example"></a>
+
+## Example
+
+[TypeScript Link Here](https://www.typescriptlang.org/play?#code/JYWwDg9gTgLgBAbzsAdsGAVASgBQMIA0c2+AolFNHAL5wBmlIcA5AAIxRgDGA9AM4BTKADchzALAAoUJFiJiATzAC8EcMAA2QmvUYtWfVFw0BDYFB4wlAgEYQAHjy5qwmsVJnR4SDNaIYAZS4ACwEQEx0GNX1DFGMzCytlO3sJSSkeHjgAWly8-ILCouKS0rLyvIys1XUtPjgI32UGlAATOCgBGABXKBR6iOMIPl6BeioSPCqcitm5+YWCqQF7WXg6briYYAgUOCxuJoEAHgw4FZgBNvrAkLCTAD4ACj478IAuYiJOuiErrgEfE+t1C4QA2gBdOAAXjgkIAlIgpHA4M5+vA7lwANYwxTKGquLRQAB0BLcLzeJm+Al+nTigPhyI6XV6eyewhMGm6Ak+myxKAgAHcUIjoQ8kZIUSjgHQ4E9MVjSaFsezOdz4YjOj0+nAOVyBEyUWi+N44GATDBgkQQIC+CYAOZjWiwhXE8iUKB8VX6+HEgBi5hNT3hAEJDXBLZRBXAUAJo5N3dAnkgbXw7Y7PgADAAkCFT6YEtDoVFz5st1EzRGcrR5LAAQgBBAAiAH0sKQAIoAVVIAQwzBojMlNCk1Gmiwnk6nlUkmTgXYL4+ny5XZSkxvg8FhqHQk2JXE6FoEwfXuxNDVa7VhMGJYEoANaoyZxNQYG6MCeBy4Rye4aOxIAeRsAArAQuA-BBwxRExgWsYkADluhAGwhGDAgoLgGxYOUBCkJQqA0PDaghxRDVnwgd83w-L8fz-ODEOQ1CSNI5jiQAR25KAFCeZNkBQKjBxhcVX3fYkIgAaj4qjiRsRE5ySARsjtX4pGWVYvFRM94BMMAwCwCjLigXEb0od9UKQJkTEvOBR3hIA)
+
+```typescript
+import { initTRPC, TRPCError } from '@trpc/server'
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { Type, TSchema } from '@sinclair/typebox'
+
+// ---------------------------------------------------------------------------------
+// Compiles a Type and returns a closure for TRPC
+// ---------------------------------------------------------------------------------
+export function RpcType<T extends TSchema>(schema: T, references: TSchema[] = []) {
+  const check = TypeCompiler.Compile(schema, references)
+  return (value: unknown) => {
+    if (check.Check(value)) return value
+    const { path, message } = check.Errors(value).First()!
+    throw new TRPCError({ message: `${message} for ${path}`, code: 'BAD_REQUEST' })
+  }
+}
+// ---------------------------------------------------------------------------------
+// Usage
+// ---------------------------------------------------------------------------------
+const t = initTRPC.create()
+const add = t.procedure
+  .input(RpcType(
+    Type.Object({
+      a: Type.Number(),
+      b: Type.Number(),
+    })
+  ))
+  .output(RpcType(
+    Type.Number()
+   ))
+  .query(({ input }) => input.a + input.b) // type-safe
+
+export const appRouter = t.router({ 
+  add 
+})
+```
\ No newline at end of file
diff --git a/examples/typedef/index.ts b/examples/typedef/index.ts
new file mode 100644
index 000000000..495e365c3
--- /dev/null
+++ b/examples/typedef/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/typedef
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './typedef'
\ No newline at end of file
diff --git a/example/typedef/readme.md b/examples/typedef/readme.md
similarity index 100%
rename from example/typedef/readme.md
rename to examples/typedef/readme.md
diff --git a/example/typedef/typedef.ts b/examples/typedef/typedef.ts
similarity index 87%
rename from example/typedef/typedef.ts
rename to examples/typedef/typedef.ts
index cfec35e41..9c959318d 100644
--- a/example/typedef/typedef.ts
+++ b/examples/typedef/typedef.ts
@@ -42,7 +42,7 @@ export type Increment<T extends string, B extends Base = Base10> = Reverse<Next<
 // --------------------------------------------------------------------------
 // SchemaOptions
 // --------------------------------------------------------------------------
-export interface SchemaOptions {
+export interface Metadata {
   [name: string]: any
 }
 // --------------------------------------------------------------------------
@@ -169,12 +169,12 @@ export interface TString extends Types.TSchema {
 // --------------------------------------------------------------------------
 // TStruct
 // --------------------------------------------------------------------------
-type OptionalKeys<T extends TFields> = { [K in keyof T]: T[K] extends (Types.TReadonlyOptional<T[K]> | Types.TOptional<T[K]>) ? T[K] : never }
-type RequiredKeys<T extends TFields> = { [K in keyof T]: T[K] extends (Types.TReadonlyOptional<T[K]> | Types.TOptional<T[K]>) ? never : T[K] }
-export interface StructOptions extends SchemaOptions {
+type OptionalKeys<T extends TFields> = { [K in keyof T]: T[K] extends (Types.TOptional<T[K]>) ? T[K] : never }
+type RequiredKeys<T extends TFields> = { [K in keyof T]: T[K] extends (Types.TOptional<T[K]>) ? never : T[K] }
+export interface StructMetadata extends Metadata {
   additionalProperties?: boolean
 }
-export interface TStruct<T extends TFields = TFields> extends Types.TSchema, StructOptions {
+export interface TStruct<T extends TFields = TFields> extends Types.TSchema, StructMetadata {
   [Types.Kind]: 'TypeDef:Struct'
   static: Types.PropertiesReduce<T, this['params']>
   optionalProperties: { [K in Types.Assert<OptionalKeys<T>, keyof T>]: T[K] }
@@ -188,6 +188,11 @@ export interface TTimestamp extends Types.TSchema {
   type: 'timestamp'
   static: string
 }
+// --------------------------------------------------------------------------
+// Static
+// --------------------------------------------------------------------------
+export type Static<T extends Types.TSchema, P extends unknown[] = []> = Types.Static<T, P>
+
 // --------------------------------------------------------------------------
 // TimestampFormat
 // --------------------------------------------------------------------------
@@ -481,95 +486,102 @@ Types.TypeRegistry.Set<TTimestamp>('TypeDef:Timestamp', (schema, value) => Value
 // --------------------------------------------------------------------------
 // TypeDefBuilder
 // --------------------------------------------------------------------------
-export class TypeDefBuilder extends Types.TypeBuilder {
+export class TypeDefBuilder {
+  // ------------------------------------------------------------------------
+  // Core
+  // ------------------------------------------------------------------------
+  protected Create(schema: Record<PropertyKey, any>, metadata: Record<keyof any, any>): any {
+    const keys = globalThis.Object.getOwnPropertyNames(metadata)
+    return keys.length > 0 ? { ...schema, metadata: { ...metadata } } : { ...schema }
+  }
+  /** [Standard] Removes compositing symbols from this schema */
+  public Strict<T extends Types.TSchema>(schema: T): T {
+    return JSON.parse(JSON.stringify(schema)) as T
+  }
   // ------------------------------------------------------------------------
   // Modifiers
   // ------------------------------------------------------------------------
-  /** `[Modifier]` Creates a Optional property */
+  /** `[Standard]` Creates an Optional property */
   public Optional<T extends Types.TSchema>(schema: T): Types.TOptional<T> {
-    return { [Types.Modifier]: 'Optional', ...Types.TypeClone.Clone(schema, {}) }
-  }
-  /** `[Modifier]` Creates a ReadonlyOptional property */
-  public ReadonlyOptional<T extends Types.TSchema>(schema: T): Types.TReadonlyOptional<T> {
-    return { [Types.Modifier]: 'ReadonlyOptional', ...Types.TypeClone.Clone(schema, {}) }
+    return this.Optional(schema)
   }
-  /** `[Modifier]` Creates a Readonly object or property */
+  /** `[Standard]` Creates a Readonly property */
   public Readonly<T extends Types.TSchema>(schema: T): Types.TReadonly<T> {
-    return { [Types.Modifier]: 'Readonly', ...schema }
+    return this.Readonly(schema)
   }
   // ------------------------------------------------------------------------
   // Types
   // ------------------------------------------------------------------------
   /** [Standard] Creates a Array type */
-  public Array<T extends Types.TSchema>(elements: T, options: SchemaOptions = {}): TArray<T> {
-    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Array', elements })
+  public Array<T extends Types.TSchema>(elements: T, metadata: Metadata = {}): TArray<T> {
+    return this.Create({ [Types.Kind]: 'TypeDef:Array', elements }, metadata)
   }
   /** [Standard] Creates a Boolean type */
-  public Boolean(options: SchemaOptions = {}): TBoolean {
-    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Boolean', type: 'boolean' })
+  public Boolean(metadata: Metadata = {}): TBoolean {
+    return this.Create({ [Types.Kind]: 'TypeDef:Boolean', type: 'boolean' }, metadata)
   }
   /** [Standard] Creates a Enum type */
-  public Enum<T extends string[]>(values: [...T], options: SchemaOptions = {}): TEnum<T> {
-    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Enum', enum: values })
+  public Enum<T extends string[]>(values: [...T], metadata: Metadata = {}): TEnum<T> {
+    return this.Create({[Types.Kind]: 'TypeDef:Enum', enum: values }, metadata )
   }
   /** [Standard] Creates a Float32 type */
-  public Float32(options: SchemaOptions = {}): TFloat32 {
-    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Float32', type: 'float32' })
+  public Float32(metadata: Metadata = {}): TFloat32 {
+    return this.Create({ [Types.Kind]: 'TypeDef:Float32', type: 'float32' }, metadata)
   }
   /** [Standard] Creates a Float64 type */
-  public Float64(options: SchemaOptions = {}): TFloat64 {
-    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Float64', type: 'float64' })
+  public Float64(metadata: Metadata = {}): TFloat64 {
+    return this.Create({  [Types.Kind]: 'TypeDef:Float64', type: 'float64' }, metadata)
   }
   /** [Standard] Creates a Int8 type */
-  public Int8(options: SchemaOptions = {}): TInt8 {
-    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Int8', type: 'int8' })
+  public Int8(metadata: Metadata = {}): TInt8 {
+    return this.Create({ [Types.Kind]: 'TypeDef:Int8', type: 'int8' }, metadata)
   }
   /** [Standard] Creates a Int16 type */
-  public Int16(options: SchemaOptions = {}): TInt16 {
-    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Int16', type: 'int16' })
+  public Int16(metadata: Metadata = {}): TInt16 {
+    return this.Create({ [Types.Kind]: 'TypeDef:Int16', type: 'int16' }, metadata)
   }
   /** [Standard] Creates a Int32 type */
-  public Int32(options: SchemaOptions = {}): TInt32 {
-    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Int32', type: 'int32' })
+  public Int32(metadata: Metadata = {}): TInt32 {
+    return this.Create({ [Types.Kind]: 'TypeDef:Int32', type: 'int32' }, metadata)
   }
   /** [Standard] Creates a Uint8 type */
-  public Uint8(options: SchemaOptions = {}): TUint8 {
-    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Uint8', type: 'uint8' })
+  public Uint8(metadata: Metadata = {}): TUint8 {
+    return this.Create({ [Types.Kind]: 'TypeDef:Uint8', type: 'uint8' }, metadata)
   }
   /** [Standard] Creates a Uint16 type */
-  public Uint16(options: SchemaOptions = {}): TUint16 {
-    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Uint16', type: 'uint16' })
+  public Uint16(metadata: Metadata = {}): TUint16 {
+    return this.Create({ [Types.Kind]: 'TypeDef:Uint16', type: 'uint16' }, metadata)
   }
   /** [Standard] Creates a Uint32 type */
-  public Uint32(options: SchemaOptions = {}): TUint32 {
-    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Uint32', type: 'uint32' })
+  public Uint32(metadata: Metadata = {}): TUint32 {
+    return this.Create({ [Types.Kind]: 'TypeDef:Uint32', type: 'uint32' }, metadata)
   }
   /** [Standard] Creates a Record type */
-  public Record<T extends Types.TSchema>(values: T, options: SchemaOptions = {}): TRecord<T> {
-    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Record', values })
+  public Record<T extends Types.TSchema>(values: T, metadata: Metadata = {}): TRecord<T> {
+    return this.Create({ [Types.Kind]: 'TypeDef:Record', values },metadata)
   }
   /** [Standard] Creates a String type */
-  public String(options: SchemaOptions = {}): TString {
-    return this.Create({ ...options, [Types.Kind]: 'TypeDef:String', type: 'string' })
+  public String(metadata: Metadata = {}): TString {
+    return this.Create({ [Types.Kind]: 'TypeDef:String', type: 'string' }, metadata)
   }
   /** [Standard] Creates a Struct type */
-  public Struct<T extends TFields>(fields: T, options?: StructOptions): TStruct<T> {
-    const optionalProperties = globalThis.Object.getOwnPropertyNames(fields).reduce((acc, key) => (Types.TypeGuard.TOptional(fields[key]) || Types.TypeGuard.TReadonlyOptional(fields[key]) ? { ...acc, [key]: fields[key] } : { ...acc }), {} as TFields)
-    const properties = globalThis.Object.getOwnPropertyNames(fields).reduce((acc, key) => (Types.TypeGuard.TOptional(fields[key]) || Types.TypeGuard.TReadonlyOptional(fields[key]) ? { ...acc } : { ...acc, [key]: fields[key] }), {} as TFields)
+  public Struct<T extends TFields>(fields: T, metadata: StructMetadata = {}): TStruct<T> {
+    const optionalProperties = globalThis.Object.getOwnPropertyNames(fields).reduce((acc, key) => (Types.TypeGuard.TOptional(fields[key]) ? { ...acc, [key]: fields[key] } : { ...acc }), {} as TFields)
+    const properties = globalThis.Object.getOwnPropertyNames(fields).reduce((acc, key) => (Types.TypeGuard.TOptional(fields[key]) ? { ...acc } : { ...acc, [key]: fields[key] }), {} as TFields)
     const optionalObject = globalThis.Object.getOwnPropertyNames(optionalProperties).length > 0 ? { optionalProperties: optionalProperties } : {}
     const requiredObject = globalThis.Object.getOwnPropertyNames(properties).length === 0 ? {} : { properties: properties }
-    return this.Create({ ...options, [Types.Kind]: 'TypeDef:Struct', ...requiredObject, ...optionalObject })
+    return this.Create({ [Types.Kind]: 'TypeDef:Struct', ...requiredObject, ...optionalObject }, metadata)
   }
   /** [Standard] Creates a Union type */
   public Union<T extends TStruct<TFields>[], D extends string = 'type'>(structs: [...T], discriminator?: D): TUnion<T, D> {
     discriminator = (discriminator || 'type') as D
     if (structs.length === 0) throw new Error('TypeDefBuilder: Union types must contain at least one struct')
     const mapping = structs.reduce((acc, current, index) => ({ ...acc, [index.toString()]: current }), {})
-    return this.Create({ [Types.Kind]: 'TypeDef:Union', discriminator, mapping })
+    return this.Create({ [Types.Kind]: 'TypeDef:Union', discriminator, mapping }, {})
   }
   /** [Standard] Creates a Timestamp type */
-  public Timestamp(): TTimestamp {
-    return this.Create({ [Types.Kind]: 'TypeDef:Timestamp', type: 'timestamp' })
+  public Timestamp(metadata: Metadata = {}): TTimestamp {
+    return this.Create({ [Types.Kind]: 'TypeDef:Timestamp', type: 'timestamp' }, metadata)
   }
 }
 
diff --git a/hammer.mjs b/hammer.mjs
index 5f37c1eb7..3bf3406f6 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -11,13 +11,13 @@ export async function clean() {
 // Format
 // -------------------------------------------------------------------------------
 export async function format() {
-  await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test example/index.ts benchmark')
+  await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test examples/index.ts benchmark')
 }
 // -------------------------------------------------------------------------------
 // Start
 // -------------------------------------------------------------------------------
-export async function start(example = 'index') {
-  await shell(`hammer run example/${example}.ts --dist target/example/${example}`)
+export async function start() {
+  await shell(`hammer run examples/index.ts --dist target/examples`)
 }
 // -------------------------------------------------------------------------------
 // Benchmark
@@ -64,7 +64,16 @@ export async function build(target = 'target/build') {
 // -------------------------------------------------------------
 export async function publish(otp, target = 'target/build') {
   const { version } = JSON.parse(readFileSync('package.json', 'utf8'))
+  if(version.includes('-dev')) throw Error(`package version should not include -dev specifier`)
   await shell(`cd ${target} && npm publish sinclair-typebox-${version}.tgz --access=public --otp ${otp}`)
   await shell(`git tag ${version}`)
   await shell(`git push origin ${version}`)
+}
+// -------------------------------------------------------------
+// Publish-Dev
+// -------------------------------------------------------------
+export async function publish_dev(otp, target = 'target/build') {
+  const { version } = JSON.parse(readFileSync(`${target}/package.json`, 'utf8'))
+  if(!version.includes('-dev')) throw Error(`development package version should include -dev specifier`)
+  await shell(`cd ${target} && npm publish sinclair-typebox-${version}.tgz --access=public --otp ${otp} --tag dev`)
 }
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index 7b9cb58d1..2c3f6f9a9 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.29.4",
+  "version": "0.30.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.29.4",
+      "version": "0.30.0",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 71c6e2c79..7f372b309 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.29.6",
+  "version": "0.30.0",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -16,6 +16,17 @@
     "./compiler": "./compiler/index.js",
     "./errors": "./errors/index.js",
     "./system": "./system/index.js",
+    "./value/cast": "./value/cast.js",
+    "./value/check": "./value/check.js",
+    "./value/clone": "./value/clone.js",
+    "./value/convert": "./value/convert.js",
+    "./value/create": "./value/create.js",
+    "./value/delta": "./value/delta.js",
+    "./value/equal": "./value/equal.js",
+    "./value/guard": "./value/guard.js",
+    "./value/hash": "./value/hash.js",
+    "./value/mutate": "./value/mutate.js",
+    "./value/pointer": "./value/pointer.js",
     "./value": "./value/index.js",
     ".": "./typebox.js"
   },
@@ -33,7 +44,8 @@
     "start": "hammer task start",
     "benchmark": "hammer task benchmark",
     "build": "hammer task build",
-    "publish": "hammer task publish"
+    "publish": "hammer task publish",
+    "publish:dev": "hammer task publish_dev"
   },
   "devDependencies": {
     "@sinclair/hammer": "^0.17.1",
diff --git a/readme.md b/readme.md
index 4bf1b532b..2e8f6e443 100644
--- a/readme.md
+++ b/readme.md
@@ -63,7 +63,7 @@ type T = Static<typeof T>                            // type T = {
 
 ## Overview
 
-TypeBox is a runtime type builder that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type assertion rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
+TypeBox is a runtime type builder that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type assertion rules of the TypeScript language. TypeBox allows one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
 
 This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire.
 
@@ -72,19 +72,20 @@ License MIT
 ## Contents
 - [Install](#install)
 - [Overview](#overview)
+- [Features](#features)
 - [Usage](#usage)
 - [Types](#types)
   - [Standard](#types-standard)
   - [Extended](#types-extended)
-  - [Modifiers](#types-modifiers)
   - [Options](#types-options)
+  - [Properties](#types-properties)
   - [Generics](#types-generics)
   - [References](#types-references)
   - [Recursive](#types-recursive)
   - [Conditional](#types-conditional)
   - [Template Literal](#types-template-literal)
   - [Indexed](#types-indexed)
-  - [Not](#types-not)
+  - [Negated](#types-negated)
   - [Rest](#types-rest)
   - [Guards](#types-guards)
   - [Unsafe](#types-unsafe)
@@ -109,7 +110,7 @@ License MIT
   - [Types](#typesystem-types)
   - [Formats](#typesystem-formats)
   - [Policies](#typesystem-policies)
-- [Workbench](#workbench)
+- [Transform](#Transform)
 - [Ecosystem](#ecosystem)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
@@ -197,13 +198,13 @@ function receive(value: T) {                         // ... as a Static Type
 
 ## Types
 
-TypeBox types are JSON schema fragments that can be composed into more complex types. Each fragment is structured such that a JSON schema compliant validator can runtime assert a value the same way TypeScript will statically assert a type. TypeBox provides a set of Standard types which are used create JSON schema compliant schematics as well as an Extended type set used to create schematics for constructs native to JavaScript.
+TypeBox types are JSON schema fragments that compose into complex types. Each fragment is structured such that a JSON schema compliant validator can runtime assert a value the same way TypeScript will statically assert a type. TypeBox provides a set of Standard types which are used create JSON schema compliant schematics as well as an Extended type set used to create schematics for constructs native to JavaScript.
 
 <a name='types-standard'></a>
 
 ### Standard Types
 
-The following table lists the Standard TypeBox types. These types are fully compatible with the JSON Schema Draft 6 specification.
+The following table lists the Standard TypeBox types. These types are fully compatible with the JSON Schema Draft 7 specification.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
@@ -336,10 +337,10 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Composite([     │ type T = {                  │ const T = {                    │
-│   Type.Object({                │   x: number                 │   type: 'object',              │
-│     x: Type.Number()           │ } & {                       │   required: ['x', 'y'],        │
-│   }),                          │   y: number                 │   properties: {                │
-│   Type.Object({                │ }                           │     x: {                       │
+│   Type.Object({                │   x: number,                │   type: 'object',              │
+│     x: Type.Number()           │   y: number                 │   required: ['x', 'y'],        │
+│   }),                          │ }                           │   properties: {                │
+│   Type.Object({                │                             │     x: {                       │
 │     y: Type.Number()           │                             │       type: 'number'           │
 │   })                           │                             │     },                         │
 │ ])                             │                             │     y: {                       │
@@ -386,6 +387,12 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │ )                              │                             │                                │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Pattern('^xy$') │ type T = string             │ const T = {                    │
+│                                │                             │    type: 'string',             │
+│                                │                             │    pattern: '^xy$'             │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const U = Type.Union([         │ type U = 'open' | 'close'   │ const T = {                    │
 │   Type.Literal('open'),        │                             │   type: 'string',              │
 │   Type.Literal('close')        │ type T = `on${U}`           │   pattern: '^on(open|close)$'  │
@@ -504,10 +511,9 @@ TypeBox provides several extended types that can be used to produce schematics f
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Constructor([   │ type T = new (              │ const T = {                    │
-│   Type.String(),               │  arg0: string,              │   type: 'object',              │
-│   Type.Number()                │  arg1: number               │   instanceOf: 'Constructor',   │
-│ ], Type.Boolean())             │ ) => boolean                │   parameters: [{               │
-│                                │                             │     type: 'string'             │
+│   Type.String(),               │  arg0: string,              │   type: 'constructor',         │
+│   Type.Number()                │  arg0: number               │   parameters: [{               │
+│ ], Type.Boolean())             │ ) => boolean                │     type: 'string'             │
 │                                │                             │   }, {                         │
 │                                │                             │     type: 'number'             │
 │                                │                             │   }],                          │
@@ -518,10 +524,9 @@ TypeBox provides several extended types that can be used to produce schematics f
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Function([      │ type T = (                  │ const T = {                    │
-|   Type.String(),               │  arg0: string,              │   type : 'object',             │
-│   Type.Number()                │  arg1: number               │   instanceOf: 'Function',      │
-│ ], Type.Boolean())             │ ) => boolean                │   parameters: [{               │
-│                                │                             │     type: 'string'             │
+|   Type.String(),               │  arg0: string,              │   type: 'function',            │
+│   Type.Number()                │  arg1: number               │   parameters: [{               │
+│ ], Type.Boolean())             │ ) => boolean                │     type: 'string'             │
 │                                │                             │   }, {                         │
 │                                │                             │     type: 'number'             │
 │                                │                             │   }],                          │
@@ -532,64 +537,95 @@ TypeBox provides several extended types that can be used to produce schematics f
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Promise(        │ type T = Promise<string>    │ const T = {                    │
-│   Type.String()                │                             │   type: 'object',              │
-│ )                              │                             │   instanceOf: 'Promise',       │
-│                                │                             │   item: {                      │
+│   Type.String()                │                             │   type: 'Promise',             │
+│ )                              │                             │   item: {                      │
 │                                │                             │     type: 'string'             │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Iterator(       │ type T =                    │ const T = {                    │
+│   Type.String()                │   IterableIterator<string>  │   type: 'Iterator',            │
+│ )                              │                             │   items: {                     │
+│                                │                             │     type: 'string'             │
+│                                │                             │   }                            │
+│                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Uint8Array()    │ type T = Uint8Array         │ const T = {                    │
-│                                │                             │   type: 'object',              │
-│                                │                             │   instanceOf: 'Uint8Array'     │
+│ const T =                      │ type T =                    │ const T = {                    │
+│   Type.AsyncIterator(          │   AsyncIterableIterator<    │   type: 'AsyncIterator',       │
+│     Type.String()              │    string                   │   items: {                     │
+│   )                            │   >                         │     type: 'string'             │
+│                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Date()          │ type T = Date               │ const T = {                    │
-│                                │                             │   type: 'object',              │
-│                                │                             │   instanceOf: 'Date'           │
+│ const T = Type.Uint8Array()    │ type T = Uint8Array         │ const T = {                    │
+│                                │                             │   type: 'Uint8Array'           │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Undefined()     │ type T = undefined          │ const T = {                    │
-│                                │                             │   type: 'null',                │
-│                                │                             │   typeOf: 'Undefined'          │
+│ const T = Type.Date()          │ type T = Date               │ const T = {                    │
+│                                │                             │   type: 'Date'                 │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.RegEx(/foo/)    │ type T = string             │ const T = {                    │
-│                                │                             │    type: 'string',             │
-│                                │                             │    pattern: 'foo'              │
+│ const T = Type.Undefined()     │ type T = undefined          │ const T = {                    │
+│                                │                             │   type: 'undefined'            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Symbol()        │ type T = symbol             │ const T = {                    │
-│                                │                             │   type: 'null',                │
-│                                │                             │   typeOf: 'Symbol'             │
+│                                │                             │   type: 'symbol'               │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.BigInt()        │ type T = bigint             │ const T = {                    │
-│                                │                             │   type: 'null',                │
-│                                │                             │   typeOf: 'BigInt'             │
+│                                │                             │   type: 'bigint'               │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Void()          │ type T = void               │ const T = {                    │
-│                                │                             │   type: 'null'                 │
-│                                │                             │   typeOf: 'Void'               │
+│                                │                             │   type: 'void'                 │
 │                                │                             │ }                              │
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name='types-modifiers'></a>
+<a name='types-options'></a>
+
+### Options
+
+You can pass JSON Schema options on the last argument of any type. Option hints specific to each type are provided for convenience.
+
+```typescript
+// String must be an email
+const T = Type.String({                              // const T = {
+  format: 'email'                                    //   type: 'string',
+})                                                   //   format: 'email'
+                                                     // }
+
+// Number must be a multiple of 2
+const T = Type.Number({                              // const T = {
+  multipleOf: 2                                      //  type: 'number',
+})                                                   //  multipleOf: 2
+                                                     // }
+
+// Array must have at least 5 integer values
+const T = Type.Array(Type.Integer(), {               // const T = {
+  minItems: 5                                        //   type: 'array',
+})                                                   //   minItems: 5,
+                                                     //   items: {
+                                                     //     type: 'integer'
+                                                     //   }
+                                                     // }
+```
+
+<a name='types-properties'></a>
 
-### Modifiers
+### Properties
 
-TypeBox provides modifiers that allow schema properties to be statically inferred as `readonly` or `optional`. The following table shows the supported modifiers and how they map between TypeScript and JSON Schema.
+Object properties can be modified with `readonly` or `optional`. The following table shows how these modifiers map between TypeScript and JSON Schema.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
@@ -597,7 +633,7 @@ TypeBox provides modifiers that allow schema properties to be statically inferre
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Object({        │ type T = {                  │ const T = {                    │
-│   name: Type.Optional(         │   name?: string             │   type: 'object',              │
+│   name: Type.ReadonlyOptional( │   readonly name?: string    │   type: 'object',              │
 │     Type.String()              │ }                           │   properties: {                │
 │   )                            │                             │     name: {                    │
 │ })  	                         │                             │       type: 'string'           │
@@ -618,7 +654,7 @@ TypeBox provides modifiers that allow schema properties to be statically inferre
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Object({        │ type T = {                  │ const T = {                    │
-│   name: Type.ReadonlyOptional( │   readonly name?: string    │   type: 'object',              │
+│   name: Type.Optional(         │   name?: string             │   type: 'object',              │
 │     Type.String()              │ }                           │   properties: {                │
 │   )                            │                             │     name: {                    │
 │ })  	                         │                             │       type: 'string'           │
@@ -628,42 +664,11 @@ TypeBox provides modifiers that allow schema properties to be statically inferre
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
-
-<a name='types-options'></a>
-
-### Options
-
-You can pass JSON Schema options on the last argument of any type. Option hints specific to each type are provided for convenience.
-
-```typescript
-// String must be an email
-const T = Type.String({                              // const T = {
-  format: 'email'                                    //   type: 'string',
-})                                                   //   format: 'email'
-                                                     // }
-
-// Number must be a multiple of 2
-const T = Type.Number({                              // const T = {
-  multipleOf: 2                                      //  type: 'number',
-})                                                   //  multipleOf: 2
-                                                     // }
-
-// Array must have at least 5 integer values
-const T = Type.Array(Type.Integer(), {               // const T = {
-  minItems: 5                                        //   type: 'array',
-})                                                   //   minItems: 5,
-                                                     //   items: {
-                                                     //     type: 'integer'
-                                                     //   }
-                                                     // }
-
-```
-
 <a name='types-generics'></a>
 
 ### Generic Types
 
-Generic types can be created with generic functions constrained to type `TSchema`. The following creates a generic `Vector<T>` type.
+Generic types are created with generic functions. All TypeBox types extend the sub type `TSchema` so it is common to constrain function arguments to this type. The following creates a generic `Vector<T>` type.
 
 ```typescript
 import { Type, Static, TSchema } from '@sinclair/typebox'
@@ -685,25 +690,9 @@ type NumberVector = Static<typeof NumberVector>      // type NumberVector = {
                                                      //   y: number,
                                                      //   z: number
                                                      // }
-
-const BooleanVector = Vector(Type.Boolean())         // const BooleanVector = {
-                                                     //   type: 'object',
-                                                     //   required: ['x', 'y', 'z'],
-                                                     //   properties: {
-                                                     //     x: { type: 'boolean' },
-                                                     //     y: { type: 'boolean' },
-                                                     //     z: { type: 'boolean' }
-                                                     //   }
-                                                     // }
-
-type BooleanVector = Static<typeof BooleanVector>    // type BooleanVector = {
-                                                     //   x: boolean,
-                                                     //   y: boolean,
-                                                     //   z: boolean
-                                                     // }
 ```
 
-The following creates a generic `Nullable<T>` type.
+Generic types can be used to create aliases for more complex types. The following creates a `Nullable<T>` type.
 
 ```typescript
 const Nullable = <T extends TSchema>(schema: T) => Type.Union([schema, Type.Null()])
@@ -722,24 +711,26 @@ type T = Static<typeof T>                           // type T = string | null
 
 ### Reference Types
 
-Reference types are supported with `Type.Ref`. The target type must specify a valid `$id`.
+Reference types are supported with `Ref`.
 
 ```typescript
 const T = Type.String({ $id: 'T' })                  // const T = {
-                                                     //    $id: 'T',
-                                                     //    type: 'string'
+                                                     //   $id: 'T',
+                                                     //   type: 'string'
                                                      // }
 
-const R = Type.Ref(T)                                // const R = {
-                                                     //    $ref: 'T'
+const R = Type.Ref<typeof T>('T')                    // const R = {
+                                                     //   $ref: 'T'
                                                      // }
+
+type R = Static<typeof R>                            // type R = string
 ```
 
 <a name='types-recursive'></a>
 
 ### Recursive Types
 
-Recursive types are supported with `Type.Recursive`.
+Recursive types are supported with `Recursive`. Recursive type inference is also supported.
 
 ```typescript
 const Node = Type.Recursive(This => Type.Object({    // const Node = {
@@ -776,7 +767,7 @@ function test(node: Node) {
 
 ### Conditional Types
 
-TypeBox supports conditional types with `Type.Extends`. This type will perform a structural assignment check for the first two parameters and return a `true` or `false` type from the second two parameters. The types `Type.Exclude` and `Type.Extract` are also supported.
+TypeBox supports conditional types with `Extends`. This type performs a structural assignment check against the first two parameters and returns either the `true` or `false` type as given from the second two parameters. The conditional types `Exclude` and `Extract` are also supported.
 
 ```typescript
 // TypeScript
@@ -789,17 +780,17 @@ type T2 = Exclude<(1 | 2 | 3), 1>                    // type T2 = 2 | 3
 
 // TypeBox
 
-const T0 = Type.Extends(                             // const T0: TLiteral<false>
-  Type.String(), 
-  Type.Number(), 
-  Type.Literal(true), 
+const T0 = Type.Extends(                             // const T0: TLiteral<false> = {
+  Type.String(),                                     //   type: 'boolean',
+  Type.Number(),                                     //   const: false
+  Type.Literal(true),                                // }
   Type.Literal(false)
 )
 
-const T1 = Type.Extract(                             // const T1: TLiteral<1>
-  Type.Union([
-    Type.Literal(1), 
-    Type.Literal(2), 
+const T1 = Type.Extract(                             // const T1: TLiteral<1> = {
+  Type.Union([                                       //   type: 'number',
+    Type.Literal(1),                                 //   const: 1
+    Type.Literal(2),                                 // }
     Type.Literal(3) 
   ]), 
   Type.Literal(1)
@@ -808,42 +799,38 @@ const T1 = Type.Extract(                             // const T1: TLiteral<1>
 const T2 = Type.Exclude(                            // const T2: TUnion<[
   Type.Union([                                      //   TLiteral<2>,
     Type.Literal(1),                                //   TLiteral<3>
-    Type.Literal(2),                                // ]>
-    Type.Literal(3) 
-  ]), 
-  Type.Literal(1)
-)
+    Type.Literal(2),                                // ]> = {
+    Type.Literal(3)                                 //   anyOf: [{
+  ]),                                               //     type: 'number',
+  Type.Literal(1)                                   //     const: 2
+)                                                   //   }, {
+                                                    //     type: 'number',
+                                                    //     const: 3
+                                                    //   }]
+                                                    // }
 ```
 
 <a name='types-template-literal'></a>
 
 ### Template Literal Types
 
-TypeBox supports template literal types with `Type.TemplateLiteral`. This type implements an embedded DSL syntax to match the TypeScript template literal syntax. This type can also be composed by passing an array of union and literal types as parameters. The following example shows the DSL syntax.
+TypeBox supports template literal types with `TemplateLiteral`. This type provides an embedded DSL syntax that is similar to the TypeScript template literal syntax. These type can also be composed by passing a tuple of exterior union and literal types. The following example shows the DSL syntax.
 
 ```typescript
 // TypeScript
 
-type P = `/post/${string}/user/${number}`            // type P = `/post/${string}/user/${number}`
-
-type T = `option${'A'|'B'}`                          // type T = 'optionA' | 'optionB'
+type T = `option${'A'|'B'|'C'}`                      // type T = 'optionA' | 'optionB' | 'optionC'
 
 type R = Record<T, string>                           // type R = {
                                                      //   optionA: string
                                                      //   optionB: string
+                                                     //   optionC: string
                                                      // }
 
 // TypeBox
 
-const P = Type.TemplateLiteral('/post/${string}/user/${number}')
-
-                                                     // const P = {
-                                                     //   type: 'string',
-                                                     //   pattern: '^/post/(.*)/user/(0|[1-9][0-9]*)$'
-                                                     // }
-
-const T = Type.TemplateLiteral('option${A|B}')       // const T = {
-                                                     //   pattern: '^option(A|B)$',
+const T = Type.TemplateLiteral('option${A|B|C}')     // const T = {
+                                                     //   pattern: '^option(A|B|C)$',
                                                      //   type: 'string'
                                                      // }
 
@@ -857,6 +844,9 @@ const R = Type.Record(T, Type.String())              // const R = {
                                                      //     optionB: {
                                                      //       type: 'string'
                                                      //     }
+                                                     //     optionC: {
+                                                     //       type: 'string'
+                                                     //     }
                                                      //   }
                                                      // }
 ```
@@ -865,7 +855,7 @@ const R = Type.Record(T, Type.String())              // const R = {
 
 ### Indexed Access Types
 
-TypeBox supports indexed access types using `Type.Index`. This type provides a consistent way to access interior property and array element types without having to extract them from the underlying schema representation. Indexed access types are supported for object, array, tuple, union and intersect types.
+TypeBox supports indexed access types using `Index`. This type provides a consistent way of accessing interior property and array element types without having to extract them from the underlying schema representation. Indexed access types are supported for object, array, tuple, union and intersect types.
 
 ```typescript
 const T = Type.Object({                              // const T = {
@@ -896,20 +886,27 @@ const C = Type.Index(T, Type.KeyOf(T))               // const C = {
                                                      // }
 ```
 
-<a name='types-not'></a>
+<a name='types-negated'></a>
+
+### Negated Types
 
-### Not Types
+TypeBox has support for type negation with `Not`. This type will always infer as `unknown`.
 
-TypeBox provides support for the `not` keyword with `Type.Not`. This type is synonymous with [negated types](https://github.com/microsoft/TypeScript/issues/4196) which are not supported in the TypeScript language. Partial inference of this type can be attained via the intersection of `T & not U` (where all Not types infer as `unknown`). This approach can be used to narrow for broader types in the following context.
+```typescript
+const T = Type.Not(Type.String())                   // const T = {
+                                                    //   not: { type: 'string' }
+                                                    // }
+
+type T = Static<typeof T>                           // type T = unknown
+                                                    //
+                                                    // where T could be any type other than string
+```
+Type negation can be useful for certain forms of type narrowing. For example, consider a type that represents a `number` but not the numbers `1, 2, 3`. The example below shows an imaginary TypeScript syntax to express such a type followed by the TypeBox representation.
 
 ```typescript
 // TypeScript
 
-type T = Exclude<number, 1 | 2 | 3>                  // all numbers except 1, 2, 3
-                                                     //
-                                                     // ideally expressed as: 
-                                                     //
-                                                     // type T = number & not (1 | 2 | 3)
+type T = number & not (1 | 2 | 3)                    // not actual syntax
 
 // TypeBox
 
@@ -928,14 +925,9 @@ const T = Type.Intersect([                           // const T = {
                                                      //   ]
                                                      // }
 
-type T = Static<typeof T>                            // inferred:
-                                                     //
-                                                     // type T = number & not (1 | 2 | 3)
-                                                     // type T = number & unknown
-                                                     // type T = number
+type T = Static<typeof T>                            // type T = number
 ```
-
-The Not type can be used with constraints to define schematics for types that would otherwise be difficult to express.
+This type can be used with constraints to create schematics that would otherwise be difficult to express.
 ```typescript
 const Even = Type.Number({ multipleOf: 2 })
 
@@ -945,7 +937,7 @@ const Odd = Type.Intersect([Type.Number(), Type.Not(Even)])
 
 ### Rest Types
 
-Rest parameters are supported with `Type.Rest`. This function is used to extract interior type elements from tuples which enables them to compose with the JavaScript spread operator `...`. This type can be used for tuple concatenation as well as for variadic functions.
+Rest parameters are supported with `Rest`. This function is used to extract interior type elements from tuples which enables them to compose with the JavaScript spread operator `...`. This type can be used for tuple concatenation as well function parameter assignment.
 
 ```typescript
 // TypeScript
@@ -983,7 +975,7 @@ const F = Type.Function(Type.Rest(C), Type.Void())   // const F: TFunction<[
 
 ### Unsafe Types
 
-Use `Type.Unsafe` to create custom schematics with user defined inference rules.
+TypeBox supports the creation of user defined schematics with user defined inference rules using the Unsafe type.
 
 ```typescript
 const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
@@ -993,7 +985,7 @@ const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
 type T = Static<typeof T>                            // type T = string
 ```
 
-The `Type.Unsafe` type can be useful to express specific OpenAPI schema representations.
+This type can be useful to create various extended schematics, such as those used by OpenAPI.
 
 ```typescript
 import { Type, Static, TSchema } from '@sinclair/typebox'
@@ -1028,12 +1020,12 @@ type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
 
 ### Type Guards
 
-TypeBox provides a `TypeGuard` module that can be used for reflection and asserting values as types.
+TypeBox provides a TypeGuard module to assert JavaScript values are valid TypeBox types.
 
 ```typescript
-import { Type, TypeGuard } from '@sinclair/typebox'
+import { Type, Kind, TypeGuard } from '@sinclair/typebox'
 
-const T = Type.String()
+const T = { [Kind]: 'String', type: 'string' }
 
 if(TypeGuard.TString(T)) {
 
@@ -1045,7 +1037,7 @@ if(TypeGuard.TString(T)) {
 
 ### Strict
 
-TypeBox schemas contain the `Kind` and `Modifier` symbol properties. These properties are used for type composition and reflection. These properties are not strictly valid JSON schema; so in some cases it may be desirable to omit them. TypeBox provides a `Type.Strict` function that will omit these properties if necessary.
+TypeBox types contain various symbol properties that are used for reflection, composition and compilation. These properties are not strictly valid JSON schema; so in some cases it may be desirable to omit them. TypeBox provides a `Strict` function that will omit these properties if necessary.
 
 ```typescript
 const T = Type.Object({                              // const T = {
@@ -1053,9 +1045,9 @@ const T = Type.Object({                              // const T = {
 })                                                   //   type: 'object',
                                                      //   properties: {
                                                      //     name: {
-                                                     //       [Kind]: 'String',
                                                      //       type: 'string',
-                                                     //       [Modifier]: 'Optional'
+                                                     //       [Kind]: 'String',
+                                                     //       [Optional]: 'Optional'
                                                      //     }
                                                      //   }
                                                      // }
@@ -1118,7 +1110,7 @@ const R = Value.Check(T, { x: 1 })                   // const R = true
 
 ### Convert
 
-Use the Convert function to convert a value into its target type if a reasonable conversion is possible.
+Use the Convert function to convert a value into its target type if a reasonable conversion is possible. This function may return an invalid value and should be checked before use. It's return type is `unknown`.
 
 ```typescript
 const T = Type.Object({ x: Type.Number() })
@@ -1270,7 +1262,7 @@ ValuePointer.Set(A, '/z', 1)                         // const A' = { x: 1, y: 1,
 
 ## TypeCheck
 
-TypeBox types target JSON Schema draft 6 so are compatible with any validator that supports this specification. TypeBox also provides a built in type checking compiler designed specifically for high performance compilation and value assertion.
+TypeBox types target JSON Schema draft 7 so are compatible with any validator that supports this specification. TypeBox also provides a built in type checking compiler designed specifically for high performance compilation and value assertion.
 
 The following sections detail using Ajv and TypeBox's compiler infrastructure.
 
@@ -1465,13 +1457,13 @@ TypeSystem.AllowArrayObjects = true
 TypeSystem.AllowNaN = true
 ```
 
-<a name='workbench'></a>
+<a name='transform'></a>
 
-## Workbench
+## TypeBox Transform
 
-TypeBox offers a web based code generation tool that can be used to convert TypeScript types into TypeBox types as well as a variety of other runtime type representations.
+TypeBox offers a small web based code generation tool that can be used to convert TypeScript types into TypeBox types as well as a variety of other runtime type representations.
 
-[Workbench Link Here](https://sinclairzx81.github.io/typebox-workbench/)
+[TypeBox Transform Link Here](https://sinclairzx81.github.io/typebox-transform/)
 
 <a name='ecosystem'></a>
 
@@ -1508,35 +1500,35 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │    1000    │ '    227 ms' │ '      7 ms' │ '   32.43 x' │
-│ Literal_Number             │    1000    │ '    180 ms' │ '      6 ms' │ '   30.00 x' │
-│ Literal_Boolean            │    1000    │ '    152 ms' │ '      5 ms' │ '   30.40 x' │
-│ Primitive_Number           │    1000    │ '    161 ms' │ '      6 ms' │ '   26.83 x' │
-│ Primitive_String           │    1000    │ '    150 ms' │ '      8 ms' │ '   18.75 x' │
-│ Primitive_String_Pattern   │    1000    │ '    202 ms' │ '      9 ms' │ '   22.44 x' │
-│ Primitive_Boolean          │    1000    │ '    133 ms' │ '      3 ms' │ '   44.33 x' │
-│ Primitive_Null             │    1000    │ '    147 ms' │ '      3 ms' │ '   49.00 x' │
-│ Object_Unconstrained       │    1000    │ '   1145 ms' │ '     31 ms' │ '   36.94 x' │
-│ Object_Constrained         │    1000    │ '   1241 ms' │ '     26 ms' │ '   47.73 x' │
-│ Object_Vector3             │    1000    │ '    407 ms' │ '      7 ms' │ '   58.14 x' │
-│ Object_Box3D               │    1000    │ '   1781 ms' │ '     27 ms' │ '   65.96 x' │
-│ Tuple_Primitive            │    1000    │ '    489 ms' │ '     13 ms' │ '   37.62 x' │
-│ Tuple_Object               │    1000    │ '   1278 ms' │ '     34 ms' │ '   37.59 x' │
-│ Composite_Intersect        │    1000    │ '    613 ms' │ '     16 ms' │ '   38.31 x' │
-│ Composite_Union            │    1000    │ '    543 ms' │ '     18 ms' │ '   30.17 x' │
-│ Math_Vector4               │    1000    │ '    819 ms' │ '     13 ms' │ '   63.00 x' │
-│ Math_Matrix4               │    1000    │ '    407 ms' │ '      7 ms' │ '   58.14 x' │
-│ Array_Primitive_Number     │    1000    │ '    372 ms' │ '      6 ms' │ '   62.00 x' │
-│ Array_Primitive_String     │    1000    │ '    329 ms' │ '      6 ms' │ '   54.83 x' │
-│ Array_Primitive_Boolean    │    1000    │ '    313 ms' │ '      3 ms' │ '  104.33 x' │
-│ Array_Object_Unconstrained │    1000    │ '   1780 ms' │ '     20 ms' │ '   89.00 x' │
-│ Array_Object_Constrained   │    1000    │ '   1494 ms' │ '     21 ms' │ '   71.14 x' │
-│ Array_Tuple_Primitive      │    1000    │ '    917 ms' │ '     10 ms' │ '   91.70 x' │
-│ Array_Tuple_Object         │    1000    │ '   1666 ms' │ '     13 ms' │ '  128.15 x' │
-│ Array_Composite_Intersect  │    1000    │ '    791 ms' │ '     18 ms' │ '   43.94 x' │
-│ Array_Composite_Union      │    1000    │ '    833 ms' │ '     17 ms' │ '   49.00 x' │
-│ Array_Math_Vector4         │    1000    │ '   1161 ms' │ '     15 ms' │ '   77.40 x' │
-│ Array_Math_Matrix4         │    1000    │ '    697 ms' │ '     10 ms' │ '   69.70 x' │
+│ Literal_String             │    1000    │ '    232 ms' │ '      8 ms' │ '   29.00 x' │
+│ Literal_Number             │    1000    │ '    179 ms' │ '      6 ms' │ '   29.83 x' │
+│ Literal_Boolean            │    1000    │ '    154 ms' │ '      3 ms' │ '   51.33 x' │
+│ Primitive_Number           │    1000    │ '    160 ms' │ '      7 ms' │ '   22.86 x' │
+│ Primitive_String           │    1000    │ '    149 ms' │ '      6 ms' │ '   24.83 x' │
+│ Primitive_String_Pattern   │    1000    │ '    191 ms' │ '      9 ms' │ '   21.22 x' │
+│ Primitive_Boolean          │    1000    │ '    135 ms' │ '      4 ms' │ '   33.75 x' │
+│ Primitive_Null             │    1000    │ '    144 ms' │ '      6 ms' │ '   24.00 x' │
+│ Object_Unconstrained       │    1000    │ '   1144 ms' │ '     30 ms' │ '   38.13 x' │
+│ Object_Constrained         │    1000    │ '   1228 ms' │ '     24 ms' │ '   51.17 x' │
+│ Object_Vector3             │    1000    │ '    380 ms' │ '      9 ms' │ '   42.22 x' │
+│ Object_Box3D               │    1000    │ '   1771 ms' │ '     30 ms' │ '   59.03 x' │
+│ Tuple_Primitive            │    1000    │ '    471 ms' │ '     11 ms' │ '   42.82 x' │
+│ Tuple_Object               │    1000    │ '   1272 ms' │ '     15 ms' │ '   84.80 x' │
+│ Composite_Intersect        │    1000    │ '    606 ms' │ '     17 ms' │ '   35.65 x' │
+│ Composite_Union            │    1000    │ '    560 ms' │ '     22 ms' │ '   25.45 x' │
+│ Math_Vector4               │    1000    │ '    824 ms' │ '     14 ms' │ '   58.86 x' │
+│ Math_Matrix4               │    1000    │ '    419 ms' │ '      9 ms' │ '   46.56 x' │
+│ Array_Primitive_Number     │    1000    │ '    382 ms' │ '      6 ms' │ '   63.67 x' │
+│ Array_Primitive_String     │    1000    │ '    324 ms' │ '      6 ms' │ '   54.00 x' │
+│ Array_Primitive_Boolean    │    1000    │ '    301 ms' │ '      4 ms' │ '   75.25 x' │
+│ Array_Object_Unconstrained │    1000    │ '   1734 ms' │ '     21 ms' │ '   82.57 x' │
+│ Array_Object_Constrained   │    1000    │ '   1509 ms' │ '     20 ms' │ '   75.45 x' │
+│ Array_Tuple_Primitive      │    1000    │ '    824 ms' │ '     14 ms' │ '   58.86 x' │
+│ Array_Tuple_Object         │    1000    │ '   1619 ms' │ '     16 ms' │ '  101.19 x' │
+│ Array_Composite_Intersect  │    1000    │ '    773 ms' │ '     16 ms' │ '   48.31 x' │
+│ Array_Composite_Union      │    1000    │ '    822 ms' │ '     17 ms' │ '   48.35 x' │
+│ Array_Math_Vector4         │    1000    │ '   1131 ms' │ '     13 ms' │ '   87.00 x' │
+│ Array_Math_Matrix4         │    1000    │ '    661 ms' │ '     10 ms' │ '   66.10 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1550,37 +1542,37 @@ This benchmark measures validation performance for varying types. You can review
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │  1000000   │ '     25 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
-│ Literal_Number             │  1000000   │ '     19 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
-│ Literal_Boolean            │  1000000   │ '     18 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
-│ Primitive_Number           │  1000000   │ '     26 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
-│ Primitive_String           │  1000000   │ '     25 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│ Primitive_String_Pattern   │  1000000   │ '    160 ms' │ '     42 ms' │ '     36 ms' │ '    1.17 x' │
-│ Primitive_Boolean          │  1000000   │ '     24 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
-│ Primitive_Null             │  1000000   │ '     24 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
-│ Object_Unconstrained       │  1000000   │ '   1111 ms' │ '     34 ms' │ '     24 ms' │ '    1.42 x' │
-│ Object_Constrained         │  1000000   │ '   1262 ms' │ '     51 ms' │ '     37 ms' │ '    1.38 x' │
-│ Object_Vector3             │  1000000   │ '    445 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
-│ Object_Box3D               │  1000000   │ '   2029 ms' │ '     66 ms' │ '     48 ms' │ '    1.38 x' │
-│ Object_Recursive           │  1000000   │ '   5121 ms' │ '    464 ms' │ '    156 ms' │ '    2.97 x' │
-│ Tuple_Primitive            │  1000000   │ '    158 ms' │ '     22 ms' │ '     12 ms' │ '    1.83 x' │
-│ Tuple_Object               │  1000000   │ '    761 ms' │ '     30 ms' │ '     18 ms' │ '    1.67 x' │
-│ Composite_Intersect        │  1000000   │ '    828 ms' │ '     24 ms' │ '     13 ms' │ '    1.85 x' │
-│ Composite_Union            │  1000000   │ '    529 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
-│ Math_Vector4               │  1000000   │ '    252 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
-│ Math_Matrix4               │  1000000   │ '   1024 ms' │ '     38 ms' │ '     27 ms' │ '    1.41 x' │
-│ Array_Primitive_Number     │  1000000   │ '    264 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
-│ Array_Primitive_String     │  1000000   │ '    240 ms' │ '     20 ms' │ '     13 ms' │ '    1.54 x' │
-│ Array_Primitive_Boolean    │  1000000   │ '    137 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
-│ Array_Object_Unconstrained │  1000000   │ '   6050 ms' │ '     66 ms' │ '     55 ms' │ '    1.20 x' │
-│ Array_Object_Constrained   │  1000000   │ '   5954 ms' │ '    124 ms' │ '    116 ms' │ '    1.07 x' │
-│ Array_Object_Recursive     │  1000000   │ '  21074 ms' │ '   1611 ms' │ '    626 ms' │ '    2.57 x' │
-│ Array_Tuple_Primitive      │  1000000   │ '    683 ms' │ '     37 ms' │ '     30 ms' │ '    1.23 x' │
-│ Array_Tuple_Object         │  1000000   │ '   3366 ms' │ '     69 ms' │ '     54 ms' │ '    1.28 x' │
-│ Array_Composite_Intersect  │  1000000   │ '   3285 ms' │ '     45 ms' │ '     36 ms' │ '    1.25 x' │
-│ Array_Composite_Union      │  1000000   │ '   2229 ms' │ '     69 ms' │ '     34 ms' │ '    2.03 x' │
-│ Array_Math_Vector4         │  1000000   │ '   1192 ms' │ '     38 ms' │ '     25 ms' │ '    1.52 x' │
-│ Array_Math_Matrix4         │  1000000   │ '   4916 ms' │ '    111 ms' │ '     88 ms' │ '    1.26 x' │
+│ Literal_String             │  1000000   │ '     18 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
+│ Literal_Number             │  1000000   │ '     15 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
+│ Literal_Boolean            │  1000000   │ '     13 ms' │ '     16 ms' │ '      9 ms' │ '    1.78 x' │
+│ Primitive_Number           │  1000000   │ '     21 ms' │ '     16 ms' │ '      9 ms' │ '    1.78 x' │
+│ Primitive_String           │  1000000   │ '     19 ms' │ '     16 ms' │ '     10 ms' │ '    1.60 x' │
+│ Primitive_String_Pattern   │  1000000   │ '    150 ms' │ '     41 ms' │ '     35 ms' │ '    1.17 x' │
+│ Primitive_Boolean          │  1000000   │ '     17 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Primitive_Null             │  1000000   │ '     18 ms' │ '     16 ms' │ '      9 ms' │ '    1.78 x' │
+│ Object_Unconstrained       │  1000000   │ '   1001 ms' │ '     31 ms' │ '     24 ms' │ '    1.29 x' │
+│ Object_Constrained         │  1000000   │ '   1288 ms' │ '     50 ms' │ '     36 ms' │ '    1.39 x' │
+│ Object_Vector3             │  1000000   │ '    439 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
+│ Object_Box3D               │  1000000   │ '   2109 ms' │ '     52 ms' │ '     45 ms' │ '    1.16 x' │
+│ Object_Recursive           │  1000000   │ '   5337 ms' │ '    356 ms' │ '    162 ms' │ '    2.20 x' │
+│ Tuple_Primitive            │  1000000   │ '    164 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
+│ Tuple_Object               │  1000000   │ '    744 ms' │ '     29 ms' │ '     18 ms' │ '    1.61 x' │
+│ Composite_Intersect        │  1000000   │ '    764 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
+│ Composite_Union            │  1000000   │ '    516 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
+│ Math_Vector4               │  1000000   │ '    262 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
+│ Math_Matrix4               │  1000000   │ '   1089 ms' │ '     37 ms' │ '     27 ms' │ '    1.37 x' │
+│ Array_Primitive_Number     │  1000000   │ '    276 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
+│ Array_Primitive_String     │  1000000   │ '    228 ms' │ '     21 ms' │ '     14 ms' │ '    1.50 x' │
+│ Array_Primitive_Boolean    │  1000000   │ '    159 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
+│ Array_Object_Unconstrained │  1000000   │ '   5695 ms' │ '     77 ms' │ '     69 ms' │ '    1.12 x' │
+│ Array_Object_Constrained   │  1000000   │ '   5701 ms' │ '    127 ms' │ '    110 ms' │ '    1.15 x' │
+│ Array_Object_Recursive     │  1000000   │ '  21267 ms' │ '   1664 ms' │ '    573 ms' │ '    2.90 x' │
+│ Array_Tuple_Primitive      │  1000000   │ '    702 ms' │ '     40 ms' │ '     32 ms' │ '    1.25 x' │
+│ Array_Tuple_Object         │  1000000   │ '   3141 ms' │ '     68 ms' │ '     51 ms' │ '    1.33 x' │
+│ Array_Composite_Intersect  │  1000000   │ '   3145 ms' │ '     44 ms' │ '     35 ms' │ '    1.26 x' │
+│ Array_Composite_Union      │  1000000   │ '   2134 ms' │ '     68 ms' │ '     31 ms' │ '    2.19 x' │
+│ Array_Math_Vector4         │  1000000   │ '   1197 ms' │ '     37 ms' │ '     25 ms' │ '    1.48 x' │
+│ Array_Math_Matrix4         │  1000000   │ '   5323 ms' │ '    111 ms' │ '     96 ms' │ '    1.16 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1594,11 +1586,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '130.3 kb' │ ' 58.2 kb' │  '2.24 x'   │
-│ typebox/errors       │ '113.3 kb' │ ' 49.8 kb' │  '2.27 x'   │
-│ typebox/system       │ ' 78.8 kb' │ ' 32.2 kb' │  '2.45 x'   │
-│ typebox/value        │ '180.0 kb' │ ' 77.7 kb' │  '2.32 x'   │
-│ typebox              │ ' 77.7 kb' │ ' 31.7 kb' │  '2.45 x'   │
+│ typebox/compiler     │ '129.4 kb' │ ' 58.6 kb' │  '2.21 x'   │
+│ typebox/errors       │ '111.6 kb' │ ' 50.1 kb' │  '2.23 x'   │
+│ typebox/system       │ ' 76.5 kb' │ ' 31.7 kb' │  '2.41 x'   │
+│ typebox/value        │ '180.7 kb' │ ' 79.3 kb' │  '2.28 x'   │
+│ typebox              │ ' 75.4 kb' │ ' 31.3 kb' │  '2.41 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 49e8ddb95..9509e0d29 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -26,10 +26,11 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import * as Types from '../typebox'
-import { ValueErrors, ValueErrorIterator } from '../errors/index'
 import { TypeSystem } from '../system/index'
-import { ValueHash } from '../value/hash'
+import * as Types from '../typebox'
+import * as ValueErrors from '../errors/index'
+import * as ValueHash from '../value/hash'
+import * as ValueGuard from '../value/guard'
 
 // -------------------------------------------------------------------
 // CheckFunction
@@ -45,7 +46,7 @@ export class TypeCheck<T extends Types.TSchema> {
     return this.code
   }
   /** Returns an iterator for each error in this value. */
-  public Errors(value: unknown): ValueErrorIterator {
+  public Errors(value: unknown): ValueErrors.ValueErrorIterator {
     return ValueErrors.Errors(this.schema, this.references, value)
   }
   /** Returns true if the value matches the compiled type. */
@@ -112,7 +113,7 @@ namespace Identifier {
   }
 }
 // -------------------------------------------------------------------
-// TypeCompiler
+// Errors
 // -------------------------------------------------------------------
 export class TypeCompilerUnknownTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
@@ -121,7 +122,7 @@ export class TypeCompilerUnknownTypeError extends Error {
 }
 export class TypeCompilerDereferenceError extends Error {
   constructor(public readonly schema: Types.TRef) {
-    super(`TypeCompiler: Unable to dereference schema with $id '${schema.$ref}'`)
+    super(`TypeCompiler: Unable to dereference type with $id '${schema.$ref}'`)
   }
 }
 export class TypeCompilerTypeGuardError extends Error {
@@ -129,26 +130,17 @@ export class TypeCompilerTypeGuardError extends Error {
     super('TypeCompiler: Preflight validation check failed to guard for the given schema')
   }
 }
-
+// -------------------------------------------------------------------
+// TypeCompiler
+// -------------------------------------------------------------------
+export type TypeCompilerLanguageOption = 'typescript' | 'javascript'
 export interface TypeCompilerOptions {
-  language?: 'typescript' | 'javascript'
+  language?: TypeCompilerLanguageOption
 }
 /** Compiles Types for Runtime Type Checking */
 export namespace TypeCompiler {
-  // -------------------------------------------------------------------
-  // Guards
-  // -------------------------------------------------------------------
-  function IsBigInt(value: unknown): value is bigint {
-    return typeof value === 'bigint'
-  }
-  function IsNumber(value: unknown): value is number {
-    return typeof value === 'number' && globalThis.Number.isFinite(value)
-  }
-  function IsString(value: unknown): value is string {
-    return typeof value === 'string'
-  }
   // ----------------------------------------------------------------------
-  // SchemaGuards
+  // Guards
   // ----------------------------------------------------------------------
   function IsAnyOrUnknown(schema: Types.TSchema) {
     return schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown'
@@ -176,94 +168,113 @@ export namespace TypeCompiler {
   // -------------------------------------------------------------------
   // Types
   // -------------------------------------------------------------------
-  function* Any(schema: Types.TAny, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TAny(schema: Types.TAny, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield 'true'
   }
-  function* Array(schema: Types.TArray, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TArray(schema: Types.TArray, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `Array.isArray(${value})`
-    if (IsNumber(schema.minItems)) yield `${value}.length >= ${schema.minItems}`
-    if (IsNumber(schema.maxItems)) yield `${value}.length <= ${schema.maxItems}`
-    if (schema.uniqueItems === true) yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`
-    const expression = CreateExpression(schema.items, references, 'value')
-    const parameter = CreateParameter('value', 'any')
-    yield `${value}.every((${parameter}) => ${expression})`
+    const [parameter, accumulator] = [CreateParameter('value', 'any'), CreateParameter('acc', 'number')]
+    if (ValueGuard.IsNumber(schema.minItems)) yield `${value}.length >= ${schema.minItems}`
+    if (ValueGuard.IsNumber(schema.maxItems)) yield `${value}.length <= ${schema.maxItems}`
+    const elementExpression = CreateExpression(schema.items, references, 'value')
+    yield `${value}.every((${parameter}) => ${elementExpression})`
+    if (Types.TypeGuard.TSchema(schema.contains) || ValueGuard.IsNumber(schema.minContains) || ValueGuard.IsNumber(schema.maxContains)) {
+      const containsSchema = Types.TypeGuard.TSchema(schema.contains) ? schema.contains : Types.Type.Never()
+      const checkExpression = CreateExpression(containsSchema, references, 'value')
+      const checkMinContains = ValueGuard.IsNumber(schema.minContains) ? [`(count >= ${schema.minContains})`] : []
+      const checkMaxContains = ValueGuard.IsNumber(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : []
+      const checkCount = `const count = ${value}.reduce((${accumulator}, ${parameter}) => ${checkExpression} ? acc + 1 : acc, 0)`
+      const check = [`(count > 0)`, ...checkMinContains, ...checkMaxContains].join(' && ')
+      yield `((${parameter}) => { ${checkCount}; return ${check}})(${value})`
+    }
+    if (schema.uniqueItems === true) {
+      const check = `const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true`
+      const block = `const set = new Set(); for(const element of value) { ${check} }`
+      yield `((${parameter}) => { ${block} )(${value})`
+    }
+  }
+  function* TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield `(typeof value === 'object' && Symbol.asyncIterator in ${value})`
   }
-  function* BigInt(schema: Types.TBigInt, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TBigInt(schema: Types.TBigInt, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'bigint')`
-    if (IsBigInt(schema.multipleOf)) yield `(${value} % BigInt(${schema.multipleOf})) === 0`
-    if (IsBigInt(schema.exclusiveMinimum)) yield `${value} > BigInt(${schema.exclusiveMinimum})`
-    if (IsBigInt(schema.exclusiveMaximum)) yield `${value} < BigInt(${schema.exclusiveMaximum})`
-    if (IsBigInt(schema.minimum)) yield `${value} >= BigInt(${schema.minimum})`
-    if (IsBigInt(schema.maximum)) yield `${value} <= BigInt(${schema.maximum})`
+    if (ValueGuard.IsBigInt(schema.multipleOf)) yield `(${value} % BigInt(${schema.multipleOf})) === 0`
+    if (ValueGuard.IsBigInt(schema.exclusiveMinimum)) yield `${value} > BigInt(${schema.exclusiveMinimum})`
+    if (ValueGuard.IsBigInt(schema.exclusiveMaximum)) yield `${value} < BigInt(${schema.exclusiveMaximum})`
+    if (ValueGuard.IsBigInt(schema.minimum)) yield `${value} >= BigInt(${schema.minimum})`
+    if (ValueGuard.IsBigInt(schema.maximum)) yield `${value} <= BigInt(${schema.maximum})`
   }
-  function* Boolean(schema: Types.TBoolean, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TBoolean(schema: Types.TBoolean, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'boolean')`
   }
-  function* Constructor(schema: Types.TConstructor, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TConstructor(schema: Types.TConstructor, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield* Visit(schema.returns, references, `${value}.prototype`)
   }
-  function* Date(schema: Types.TDate, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TDate(schema: Types.TDate, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`
-    if (IsNumber(schema.exclusiveMinimumTimestamp)) yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`
-    if (IsNumber(schema.exclusiveMaximumTimestamp)) yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`
-    if (IsNumber(schema.minimumTimestamp)) yield `${value}.getTime() >= ${schema.minimumTimestamp}`
-    if (IsNumber(schema.maximumTimestamp)) yield `${value}.getTime() <= ${schema.maximumTimestamp}`
+    if (ValueGuard.IsNumber(schema.exclusiveMinimumTimestamp)) yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`
+    if (ValueGuard.IsNumber(schema.exclusiveMaximumTimestamp)) yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`
+    if (ValueGuard.IsNumber(schema.minimumTimestamp)) yield `${value}.getTime() >= ${schema.minimumTimestamp}`
+    if (ValueGuard.IsNumber(schema.maximumTimestamp)) yield `${value}.getTime() <= ${schema.maximumTimestamp}`
   }
-  function* Function(schema: Types.TFunction, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TFunction(schema: Types.TFunction, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'function')`
   }
-  function* Integer(schema: Types.TInteger, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TInteger(schema: Types.TInteger, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`
-    if (IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf}) === 0`
-    if (IsNumber(schema.exclusiveMinimum)) yield `${value} > ${schema.exclusiveMinimum}`
-    if (IsNumber(schema.exclusiveMaximum)) yield `${value} < ${schema.exclusiveMaximum}`
-    if (IsNumber(schema.minimum)) yield `${value} >= ${schema.minimum}`
-    if (IsNumber(schema.maximum)) yield `${value} <= ${schema.maximum}`
+    if (ValueGuard.IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf}) === 0`
+    if (ValueGuard.IsNumber(schema.exclusiveMinimum)) yield `${value} > ${schema.exclusiveMinimum}`
+    if (ValueGuard.IsNumber(schema.exclusiveMaximum)) yield `${value} < ${schema.exclusiveMaximum}`
+    if (ValueGuard.IsNumber(schema.minimum)) yield `${value} >= ${schema.minimum}`
+    if (ValueGuard.IsNumber(schema.maximum)) yield `${value} <= ${schema.maximum}`
   }
-  function* Intersect(schema: Types.TIntersect, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: string): IterableIterator<string> {
     const check1 = schema.allOf.map((schema: Types.TSchema) => CreateExpression(schema, references, value)).join(' && ')
     if (schema.unevaluatedProperties === false) {
-      const keyCheck = PushLocal(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`)
+      const keyCheck = CreateVariable(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`)
       const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key))`
       yield `(${check1} && ${check2})`
     } else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
-      const keyCheck = PushLocal(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`)
+      const keyCheck = CreateVariable(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`)
       const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key) || ${CreateExpression(schema.unevaluatedProperties, references, `${value}[key]`)})`
       yield `(${check1} && ${check2})`
     } else {
       yield `(${check1})`
     }
   }
-  function* Literal(schema: Types.TLiteral, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TIterator(schema: Types.TIterator, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield `(typeof value === 'object' && Symbol.iterator in ${value})`
+  }
+  function* TLiteral(schema: Types.TLiteral, references: Types.TSchema[], value: string): IterableIterator<string> {
     if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
       yield `(${value} === ${schema.const})`
     } else {
       yield `(${value} === '${schema.const}')`
     }
   }
-  function* Never(schema: Types.TNever, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TNever(schema: Types.TNever, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `false`
   }
-  function* Not(schema: Types.TNot, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TNot(schema: Types.TNot, references: Types.TSchema[], value: string): IterableIterator<string> {
     const expression = CreateExpression(schema.not, references, value)
     yield `(!${expression})`
   }
-  function* Null(schema: Types.TNull, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TNull(schema: Types.TNull, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(${value} === null)`
   }
-  function* Number(schema: Types.TNumber, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TNumber(schema: Types.TNumber, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield IsNumberCheck(value)
-    if (IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf}) === 0`
-    if (IsNumber(schema.exclusiveMinimum)) yield `${value} > ${schema.exclusiveMinimum}`
-    if (IsNumber(schema.exclusiveMaximum)) yield `${value} < ${schema.exclusiveMaximum}`
-    if (IsNumber(schema.minimum)) yield `${value} >= ${schema.minimum}`
-    if (IsNumber(schema.maximum)) yield `${value} <= ${schema.maximum}`
+    if (ValueGuard.IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf}) === 0`
+    if (ValueGuard.IsNumber(schema.exclusiveMinimum)) yield `${value} > ${schema.exclusiveMinimum}`
+    if (ValueGuard.IsNumber(schema.exclusiveMaximum)) yield `${value} < ${schema.exclusiveMaximum}`
+    if (ValueGuard.IsNumber(schema.minimum)) yield `${value} >= ${schema.minimum}`
+    if (ValueGuard.IsNumber(schema.maximum)) yield `${value} <= ${schema.maximum}`
   }
-  function* Object(schema: Types.TObject, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TObject(schema: Types.TObject, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield IsObjectCheck(value)
-    if (IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
-    if (IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
-    const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties)
+    if (ValueGuard.IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
+    if (ValueGuard.IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
+    const knownKeys = Object.getOwnPropertyNames(schema.properties)
     for (const knownKey of knownKeys) {
       const memberExpression = MemberExpression.Encode(value, knownKey)
       const property = schema.properties[knownKey]
@@ -289,55 +300,54 @@ export namespace TypeCompiler {
       yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`
     }
   }
-  function* Promise(schema: Types.TPromise<any>, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TPromise(schema: Types.TPromise<any>, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof value === 'object' && typeof ${value}.then === 'function')`
   }
-  function* Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield IsRecordCheck(value)
-    if (IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
-    if (IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
-    const [patternKey, patternSchema] = globalThis.Object.entries(schema.patternProperties)[0]
-    const local = PushLocal(`new RegExp(/${patternKey}/)`)
+    if (ValueGuard.IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
+    if (ValueGuard.IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
+    const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0]
+    const variable = CreateVariable(`new RegExp(/${patternKey}/)`)
     const check1 = CreateExpression(patternSchema, references, 'value')
     const check2 = Types.TypeGuard.TSchema(schema.additionalProperties) ? CreateExpression(schema.additionalProperties, references, value) : schema.additionalProperties === false ? 'false' : 'true'
-    const expression = `(${local}.test(key) ? ${check1} : ${check2})`
+    const expression = `(${variable}.test(key) ? ${check1} : ${check2})`
     yield `(Object.entries(${value}).every(([key, value]) => ${expression}))`
   }
-  function* Ref(schema: Types.TRef<any>, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: string): IterableIterator<string> {
     const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
     if (index === -1) throw new TypeCompilerDereferenceError(schema)
     const target = references[index]
-    // Reference: If we have seen this reference before we can just yield and
-    // return the function call. If this isn't the case we defer to visit to
-    // generate and set the function for subsequent passes.
+    // Reference: If we have seen this reference before we can just yield and return the function call.
+    // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
     if (state.functions.has(schema.$ref)) return yield `${CreateFunctionName(schema.$ref)}(${value})`
     yield* Visit(target, references, value)
   }
-  function* String(schema: Types.TString, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TString(schema: Types.TString, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'string')`
-    if (IsNumber(schema.minLength)) yield `${value}.length >= ${schema.minLength}`
-    if (IsNumber(schema.maxLength)) yield `${value}.length <= ${schema.maxLength}`
+    if (ValueGuard.IsNumber(schema.minLength)) yield `${value}.length >= ${schema.minLength}`
+    if (ValueGuard.IsNumber(schema.maxLength)) yield `${value}.length <= ${schema.maxLength}`
     if (schema.pattern !== undefined) {
-      const local = PushLocal(`${new RegExp(schema.pattern)};`)
-      yield `${local}.test(${value})`
+      const variable = CreateVariable(`${new RegExp(schema.pattern)};`)
+      yield `${variable}.test(${value})`
     }
     if (schema.format !== undefined) {
       yield `format('${schema.format}', ${value})`
     }
   }
-  function* Symbol(schema: Types.TSymbol, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TSymbol(schema: Types.TSymbol, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'symbol')`
   }
-  function* TemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TTemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'string')`
-    const local = PushLocal(`${new RegExp(schema.pattern)};`)
-    yield `${local}.test(${value})`
+    const variable = CreateVariable(`${new RegExp(schema.pattern)};`)
+    yield `${variable}.test(${value})`
   }
-  function* This(schema: Types.TThis, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TThis(schema: Types.TThis, references: Types.TSchema[], value: string): IterableIterator<string> {
     const func = CreateFunctionName(schema.$ref)
     yield `${func}(${value})`
   }
-  function* Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `Array.isArray(${value})`
     if (schema.items === undefined) return yield `${value}.length === 0`
     yield `(${value}.length === ${schema.maxItems})`
@@ -346,108 +356,110 @@ export namespace TypeCompiler {
       yield `${expression}`
     }
   }
-  function* Undefined(schema: Types.TUndefined, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TUndefined(schema: Types.TUndefined, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `${value} === undefined`
   }
-  function* Union(schema: Types.TUnion<any[]>, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TUnion(schema: Types.TUnion<any[]>, references: Types.TSchema[], value: string): IterableIterator<string> {
     const expressions = schema.anyOf.map((schema: Types.TSchema) => CreateExpression(schema, references, value))
     yield `(${expressions.join(' || ')})`
   }
-  function* Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `${value} instanceof Uint8Array`
-    if (IsNumber(schema.maxByteLength)) yield `(${value}.length <= ${schema.maxByteLength})`
-    if (IsNumber(schema.minByteLength)) yield `(${value}.length >= ${schema.minByteLength})`
+    if (ValueGuard.IsNumber(schema.maxByteLength)) yield `(${value}.length <= ${schema.maxByteLength})`
+    if (ValueGuard.IsNumber(schema.minByteLength)) yield `(${value}.length >= ${schema.minByteLength})`
   }
-  function* Unknown(schema: Types.TUnknown, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TUnknown(schema: Types.TUnknown, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield 'true'
   }
-  function* Void(schema: Types.TVoid, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* TVoid(schema: Types.TVoid, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield IsVoidCheck(value)
   }
-  function* UserDefined(schema: Types.TSchema, references: Types.TSchema[], value: string): IterableIterator<string> {
-    const schema_key = `schema_key_${state.customs.size}`
-    state.customs.set(schema_key, schema)
-    yield `custom('${schema[Types.Kind]}', '${schema_key}', ${value})`
+  function* TKind(schema: Types.TSchema, references: Types.TSchema[], value: string): IterableIterator<string> {
+    yield `kind('${schema[Types.Kind]}', ${value})`
   }
-  function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: string, root = false): IterableIterator<string> {
-    const references_ = IsString(schema.$id) ? [...references, schema] : references
+  function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: string, useHoisting: boolean = true): IterableIterator<string> {
+    const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references
     const schema_ = schema as any
-    // Rule: Types with identifiers are hoisted into their own functions.
-    // The following will generate a function for the schema and yield the
-    // call to that function. This call is only made if NOT the root type
-    // which allows the generated function to yield its expression. The
-    // root argument is only true when making calls via CreateFunction().
-    // Note there is potential to omit the root argument and conditional
-    // by refactoring the logic below. Consider for review.
-    if (IsString(schema.$id)) {
-      const name = CreateFunctionName(schema.$id)
-      if (!state.functions.has(schema.$id)) {
-        state.functions.add(schema.$id)
-        const body = CreateFunction(name, schema, references, 'value')
-        PushFunction(body)
+    // ----------------------------------------------------------------------------------
+    // Hoisting
+    // ----------------------------------------------------------------------------------
+    if (useHoisting && ValueGuard.IsString(schema.$id)) {
+      const functionName = CreateFunctionName(schema.$id)
+      if (state.functions.has(functionName)) {
+        return yield `${functionName}(${value})`
+      } else {
+        const functionCode = CreateFunction(functionName, schema, references, 'value', false)
+        state.functions.set(functionName, functionCode)
+        return yield `${functionName}(${value})`
       }
-      if (!root) return yield `${name}(${value})`
     }
+    // ----------------------------------------------------------------------------------
+    // Types
+    // ----------------------------------------------------------------------------------
     switch (schema_[Types.Kind]) {
       case 'Any':
-        return yield* Any(schema_, references_, value)
+        return yield* TAny(schema_, references_, value)
       case 'Array':
-        return yield* Array(schema_, references_, value)
+        return yield* TArray(schema_, references_, value)
+      case 'AsyncIterator':
+        return yield* TAsyncIterator(schema_, references_, value)
       case 'BigInt':
-        return yield* BigInt(schema_, references_, value)
+        return yield* TBigInt(schema_, references_, value)
       case 'Boolean':
-        return yield* Boolean(schema_, references_, value)
+        return yield* TBoolean(schema_, references_, value)
       case 'Constructor':
-        return yield* Constructor(schema_, references_, value)
+        return yield* TConstructor(schema_, references_, value)
       case 'Date':
-        return yield* Date(schema_, references_, value)
+        return yield* TDate(schema_, references_, value)
       case 'Function':
-        return yield* Function(schema_, references_, value)
+        return yield* TFunction(schema_, references_, value)
       case 'Integer':
-        return yield* Integer(schema_, references_, value)
+        return yield* TInteger(schema_, references_, value)
       case 'Intersect':
-        return yield* Intersect(schema_, references_, value)
+        return yield* TIntersect(schema_, references_, value)
+      case 'Iterator':
+        return yield* TIterator(schema_, references_, value)
       case 'Literal':
-        return yield* Literal(schema_, references_, value)
+        return yield* TLiteral(schema_, references_, value)
       case 'Never':
-        return yield* Never(schema_, references_, value)
+        return yield* TNever(schema_, references_, value)
       case 'Not':
-        return yield* Not(schema_, references_, value)
+        return yield* TNot(schema_, references_, value)
       case 'Null':
-        return yield* Null(schema_, references_, value)
+        return yield* TNull(schema_, references_, value)
       case 'Number':
-        return yield* Number(schema_, references_, value)
+        return yield* TNumber(schema_, references_, value)
       case 'Object':
-        return yield* Object(schema_, references_, value)
+        return yield* TObject(schema_, references_, value)
       case 'Promise':
-        return yield* Promise(schema_, references_, value)
+        return yield* TPromise(schema_, references_, value)
       case 'Record':
-        return yield* Record(schema_, references_, value)
+        return yield* TRecord(schema_, references_, value)
       case 'Ref':
-        return yield* Ref(schema_, references_, value)
+        return yield* TRef(schema_, references_, value)
       case 'String':
-        return yield* String(schema_, references_, value)
+        return yield* TString(schema_, references_, value)
       case 'Symbol':
-        return yield* Symbol(schema_, references_, value)
+        return yield* TSymbol(schema_, references_, value)
       case 'TemplateLiteral':
-        return yield* TemplateLiteral(schema_, references_, value)
+        return yield* TTemplateLiteral(schema_, references_, value)
       case 'This':
-        return yield* This(schema_, references_, value)
+        return yield* TThis(schema_, references_, value)
       case 'Tuple':
-        return yield* Tuple(schema_, references_, value)
+        return yield* TTuple(schema_, references_, value)
       case 'Undefined':
-        return yield* Undefined(schema_, references_, value)
+        return yield* TUndefined(schema_, references_, value)
       case 'Union':
-        return yield* Union(schema_, references_, value)
+        return yield* TUnion(schema_, references_, value)
       case 'Uint8Array':
-        return yield* Uint8Array(schema_, references_, value)
+        return yield* TUint8Array(schema_, references_, value)
       case 'Unknown':
-        return yield* Unknown(schema_, references_, value)
+        return yield* TUnknown(schema_, references_, value)
       case 'Void':
-        return yield* Void(schema_, references_, value)
+        return yield* TVoid(schema_, references_, value)
       default:
         if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new TypeCompilerUnknownTypeError(schema)
-        return yield* UserDefined(schema_, references_, value)
+        return yield* TKind(schema_, references_, value)
     }
   }
   // -------------------------------------------------------------------
@@ -455,16 +467,30 @@ export namespace TypeCompiler {
   // -------------------------------------------------------------------
   // prettier-ignore
   const state = {
-    language: 'javascript' as TypeCompilerOptions['language'], // target language
-    variables: new Set<string>(),                              // local variables
-    functions: new Set<string>(),                              // local functions
-    customs: new Map<string, unknown>(),                       // custom type data
+    language: 'javascript',                       // target language
+    functions: new Map<string, string>(),         // local functions
+    variables: new Map<string, string>(),         // local variables
+  }
+  // -------------------------------------------------------------------
+  // Compiler Factory
+  // -------------------------------------------------------------------
+  function CreateExpression(schema: Types.TSchema, references: Types.TSchema[], value: string, useHoisting: boolean = true): string {
+    return `(${[...Visit(schema, references, value, useHoisting)].join(' && ')})`
   }
   function CreateFunctionName($id: string) {
     return `check_${Identifier.Encode($id)}`
   }
-  function CreateExpression(schema: Types.TSchema, references: Types.TSchema[], value: string): string {
-    return `(${[...Visit(schema, references, value)].join(' && ')})`
+  function CreateVariable(expression: string) {
+    const variableName = `local_${state.variables.size}`
+    state.variables.set(variableName, `const ${variableName} = ${expression}`)
+    return variableName
+  }
+  function CreateFunction(name: string, schema: Types.TSchema, references: Types.TSchema[], value: string, useHoisting: boolean = true): string {
+    const [newline, pad] = ['\n', (length: number) => ''.padStart(length, ' ')]
+    const parameter = CreateParameter('value', 'any')
+    const returns = CreateReturns('boolean')
+    const expression = [...Visit(schema, references, value, useHoisting)].map((expression) => `${pad(4)}${expression}`).join(` &&${newline}`)
+    return `function ${name}(${parameter})${returns} {${newline}${pad(2)}return (${newline}${expression}${newline}${pad(2)})\n}`
   }
   function CreateParameter(name: string, type: string) {
     const annotation = state.language === 'typescript' ? `: ${type}` : ''
@@ -473,68 +499,62 @@ export namespace TypeCompiler {
   function CreateReturns(type: string) {
     return state.language === 'typescript' ? `: ${type}` : ''
   }
-  function CreateFunction(name: string, schema: Types.TSchema, references: Types.TSchema[], value: string): string {
-    const expression = [...Visit(schema, references, value, true)].map((condition) => `    ${condition}`).join(' &&\n')
-    const parameter = CreateParameter('value', 'any')
-    const returns = CreateReturns('boolean')
-    return `function ${name}(${parameter})${returns} {\n  return (\n${expression}\n )\n}`
-  }
-  function PushFunction(functionBody: string) {
-    state.variables.add(functionBody)
-  }
-  function PushLocal(expression: string) {
-    const local = `local_${state.variables.size}`
-    state.variables.add(`const ${local} = ${expression}`)
-    return local
-  }
-  function GetLocals() {
-    return [...state.variables.values()]
-  }
   // -------------------------------------------------------------------
   // Compile
   // -------------------------------------------------------------------
-  function Build<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): string {
-    const check = CreateFunction('check', schema, references, 'value') // interior visit
-    const locals = GetLocals()
+  function Build<T extends Types.TSchema>(schema: T, references: Types.TSchema[], options: TypeCompilerOptions): string {
+    const functionCode = CreateFunction('check', schema, references, 'value') // will populate functions and variables
     const parameter = CreateParameter('value', 'any')
     const returns = CreateReturns('boolean')
+    const functions = [...state.functions.values()]
+    const variables = [...state.variables.values()]
     // prettier-ignore
-    return IsString(schema.$id) // ensure top level schemas with $id's are hoisted
-      ? `${locals.join('\n')}\nreturn function check(${parameter})${returns} {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
-      : `${locals.join('\n')}\nreturn ${check}`
+    const checkFunction = ValueGuard.IsString(schema.$id) // ensure top level schemas with $id's are hoisted
+      ? `return function check(${parameter})${returns} {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
+      : `return ${functionCode}`
+    return [...variables, ...functions, checkFunction].join('\n')
   }
   /** Returns the generated assertion code used to validate this type. */
-  export function Code<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = [], options: TypeCompilerOptions = { language: 'javascript' }) {
+  export function Code<T extends Types.TSchema>(schema: T, references: Types.TSchema[], options?: TypeCompilerOptions): string
+  /** Returns the generated assertion code used to validate this type. */
+  export function Code<T extends Types.TSchema>(schema: T, options?: TypeCompilerOptions): string
+  /** Returns the generated assertion code used to validate this type. */
+  export function Code(...args: any[]) {
+    const defaults = { language: 'javascript' }
+    // prettier-ignore
+    const [schema, references, options] = (
+      args.length === 2 &&  ValueGuard.IsArray(args[1]) ? [args[0], args[1], defaults] :
+      args.length === 2 && !ValueGuard.IsArray(args[1]) ? [args[0], [], args[1]] :
+      args.length === 3 ? [args[0], args[1], args[2]] :
+      args.length === 1 ? [args[0], [], defaults] :
+      [null, [], defaults]
+    )
     // compiler-reset
     state.language = options.language
     state.variables.clear()
     state.functions.clear()
-    state.customs.clear()
     if (!Types.TypeGuard.TSchema(schema)) throw new TypeCompilerTypeGuardError(schema)
     for (const schema of references) if (!Types.TypeGuard.TSchema(schema)) throw new TypeCompilerTypeGuardError(schema)
-    return Build(schema, references)
+    return Build(schema, references, options)
   }
   /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
   export function Compile<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []): TypeCheck<T> {
-    const code = Code(schema, references, { language: 'javascript' })
-    const customs = new Map(state.customs)
-    const compiledFunction = globalThis.Function('custom', 'format', 'hash', code)
-    const checkFunction = compiledFunction(
-      (kind: string, schema_key: string, value: unknown) => {
-        if (!Types.TypeRegistry.Has(kind) || !customs.has(schema_key)) return false
-        const schema = customs.get(schema_key)!
-        const func = Types.TypeRegistry.Get(kind)!
-        return func(schema, value)
-      },
-      (format: string, value: string) => {
-        if (!Types.FormatRegistry.Has(format)) return false
-        const func = Types.FormatRegistry.Get(format)!
-        return func(value)
-      },
-      (value: unknown) => {
-        return ValueHash.Create(value)
-      },
-    )
-    return new TypeCheck(schema, references, checkFunction, code)
+    const generatedCode = Code(schema, references, { language: 'javascript' })
+    const compiledFunction = globalThis.Function('kind', 'format', 'hash', generatedCode)
+    function typeRegistryFunction(kind: string, value: unknown) {
+      if (!Types.TypeRegistry.Has(kind)) return false
+      const checkFunc = Types.TypeRegistry.Get(kind)!
+      return checkFunc(schema, value)
+    }
+    function formatRegistryFunction(format: string, value: string) {
+      if (!Types.FormatRegistry.Has(format)) return false
+      const checkFunc = Types.FormatRegistry.Get(format)!
+      return checkFunc(value)
+    }
+    function valueHashFunction(value: unknown) {
+      return ValueHash.Hash(value)
+    }
+    const checkFunction = compiledFunction(typeRegistryFunction, formatRegistryFunction, valueHashFunction)
+    return new TypeCheck(schema, references, checkFunction, generatedCode)
   }
 }
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 73e76bec7..f7ee21a19 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -25,18 +25,24 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
-import * as Types from '../typebox'
+
 import { TypeSystem } from '../system/index'
-import { ValueHash } from '../value/hash'
+import * as Types from '../typebox'
+import * as ValueHash from '../value/hash'
+import * as ValueGuard from '../value/guard'
 
-// -------------------------------------------------------------------
+// --------------------------------------------------------------------------
 // ValueErrorType
-// -------------------------------------------------------------------
+// --------------------------------------------------------------------------
 export enum ValueErrorType {
   Array,
   ArrayMinItems,
   ArrayMaxItems,
+  ArrayContains,
+  ArrayMinContains,
+  ArrayMaxContains,
   ArrayUniqueItems,
+  AsyncIterator,
   BigInt,
   BigIntMultipleOf,
   BigIntExclusiveMinimum,
@@ -58,6 +64,7 @@ export enum ValueErrorType {
   IntegerMaximum,
   Intersect,
   IntersectUnevaluatedProperties,
+  Iterator,
   Literal,
   Never,
   Not,
@@ -91,11 +98,11 @@ export enum ValueErrorType {
   Uint8ArrayMinByteLength,
   Uint8ArrayMaxByteLength,
   Void,
-  Custom,
+  Kind,
 }
-// -------------------------------------------------------------------
+// --------------------------------------------------------------------------
 // ValueError
-// -------------------------------------------------------------------
+// --------------------------------------------------------------------------
 export interface ValueError {
   type: ValueErrorType
   schema: Types.TSchema
@@ -103,9 +110,9 @@ export interface ValueError {
   value: unknown
   message: string
 }
-// -------------------------------------------------------------------
+// --------------------------------------------------------------------------
 // ValueErrorIterator
-// -------------------------------------------------------------------
+// --------------------------------------------------------------------------
 export class ValueErrorIterator {
   constructor(private readonly iterator: IterableIterator<ValueError>) {}
   public [Symbol.iterator]() {
@@ -117,9 +124,9 @@ export class ValueErrorIterator {
     return next.done ? undefined : next.value
   }
 }
-// -------------------------------------------------------------------
+// --------------------------------------------------------------------------
 // ValueErrors
-// -------------------------------------------------------------------
+// --------------------------------------------------------------------------
 export class ValueErrorsUnknownTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
     super('ValueErrors: Unknown type')
@@ -127,468 +134,490 @@ export class ValueErrorsUnknownTypeError extends Error {
 }
 export class ValueErrorsDereferenceError extends Error {
   constructor(public readonly schema: Types.TRef | Types.TThis) {
-    super(`ValueErrors: Unable to dereference schema with $id '${schema.$ref}'`)
+    super(`ValueErrors: Unable to dereference type with $id '${schema.$ref}'`)
   }
 }
-/** Provides functionality to generate a sequence of errors against a TypeBox type.  */
-export namespace ValueErrors {
-  // ----------------------------------------------------------------------
-  // Guards
-  // ----------------------------------------------------------------------
-  function IsBigInt(value: unknown): value is bigint {
-    return typeof value === 'bigint'
+// --------------------------------------------------------------------------
+// Guards
+// --------------------------------------------------------------------------
+function IsDefined<T>(value: unknown): value is T {
+  return value !== undefined
+}
+// --------------------------------------------------------------------------
+// Policies
+// --------------------------------------------------------------------------
+function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string) {
+  return TypeSystem.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined
+}
+function IsObject(value: unknown): value is Record<keyof any, unknown> {
+  const isObject = ValueGuard.IsObject(value)
+  return TypeSystem.AllowArrayObjects ? isObject : isObject && !ValueGuard.IsArray(value)
+}
+function IsRecordObject(value: unknown): value is Record<keyof any, unknown> {
+  return IsObject(value) && !(value instanceof Date) && !(value instanceof Uint8Array)
+}
+function IsNumber(value: unknown): value is number {
+  const isNumber = ValueGuard.IsNumber(value)
+  return TypeSystem.AllowNaN ? isNumber : isNumber && Number.isFinite(value)
+}
+function IsVoid(value: unknown): value is void {
+  const isUndefined = ValueGuard.IsUndefined(value)
+  return TypeSystem.AllowVoidNull ? isUndefined || value === null : isUndefined
+}
+// --------------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------------
+function* TAny(schema: Types.TAny, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {}
+function* TArray(schema: Types.TArray, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!ValueGuard.IsArray(value)) {
+    return yield { type: ValueErrorType.Array, schema, path, value, message: `Expected array` }
   }
-  function IsInteger(value: unknown): value is number {
-    return globalThis.Number.isInteger(value)
+  if (IsDefined<number>(schema.minItems) && !(value.length >= schema.minItems)) {
+    yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be greater or equal to ${schema.minItems}` }
   }
-  function IsString(value: unknown): value is string {
-    return typeof value === 'string'
+  if (IsDefined<number>(schema.maxItems) && !(value.length <= schema.maxItems)) {
+    yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` }
   }
-  function IsDefined<T>(value: unknown): value is T {
-    return value !== undefined
+
+  for (let i = 0; i < value.length; i++) {
+    yield* Visit(schema.items, references, `${path}/${i}`, value[i])
   }
-  // ----------------------------------------------------------------------
-  // Policies
-  // ----------------------------------------------------------------------
-  function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string) {
-    return TypeSystem.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined
+  // prettier-ignore
+  if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) { const hashed = ValueHash.Hash(element); if (set.has(hashed)) { return false } else { set.add(hashed) } } return true })())) {
+    yield { type: ValueErrorType.ArrayUniqueItems, schema, path, value, message: `Expected array elements to be unique` }
   }
-  function IsObject(value: unknown): value is Record<keyof any, unknown> {
-    const result = typeof value === 'object' && value !== null
-    return TypeSystem.AllowArrayObjects ? result : result && !globalThis.Array.isArray(value)
+  // contains
+  if (!(IsDefined(schema.contains) || IsNumber(schema.minContains) || IsNumber(schema.maxContains))) {
+    return
   }
-  function IsRecordObject(value: unknown): value is Record<keyof any, unknown> {
-    return IsObject(value) && !(value instanceof globalThis.Date) && !(value instanceof globalThis.Uint8Array)
+  const containsSchema = IsDefined<Types.TSchema>(schema.contains) ? schema.contains : Types.Type.Never()
+  const containsCount = value.reduce((acc: number, value, index) => (Visit(containsSchema, references, `${path}${index}`, value).next().done === true ? acc + 1 : acc), 0)
+  if (containsCount === 0) {
+    yield { type: ValueErrorType.ArrayContains, schema, path, value, message: `Expected array to contain at least one matching type` }
   }
-  function IsNumber(value: unknown): value is number {
-    const result = typeof value === 'number'
-    return TypeSystem.AllowNaN ? result : result && globalThis.Number.isFinite(value)
+  if (ValueGuard.IsNumber(schema.minContains) && containsCount < schema.minContains) {
+    yield { type: ValueErrorType.ArrayMinContains, schema, path, value, message: `Expected array to contain at least ${schema.minContains} matching types` }
   }
-  function IsVoid(value: unknown): value is void {
-    const result = value === undefined
-    return TypeSystem.AllowVoidNull ? result || value === null : result
+  if (ValueGuard.IsNumber(schema.maxContains) && containsCount > schema.maxContains) {
+    yield { type: ValueErrorType.ArrayMaxContains, schema, path, value, message: `Expected array to contain no more than ${schema.maxContains} matching types` }
   }
-
-  // ----------------------------------------------------------------------
-  // Types
-  // ----------------------------------------------------------------------
-  function* Any(schema: Types.TAny, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {}
-  function* Array(schema: Types.TArray, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!globalThis.Array.isArray(value)) {
-      return yield { type: ValueErrorType.Array, schema, path, value, message: `Expected array` }
-    }
-    if (IsDefined<number>(schema.minItems) && !(value.length >= schema.minItems)) {
-      yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be greater or equal to ${schema.minItems}` }
-    }
-    if (IsDefined<number>(schema.maxItems) && !(value.length <= schema.maxItems)) {
-      yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` }
-    }
-    // prettier-ignore
-    if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) { const hashed = ValueHash.Create(element); if (set.has(hashed)) { return false } else { set.add(hashed) } } return true })())) {
-      yield { type: ValueErrorType.ArrayUniqueItems, schema, path, value, message: `Expected array elements to be unique` }
-    }
-    for (let i = 0; i < value.length; i++) {
-      yield* Visit(schema.items, references, `${path}/${i}`, value[i])
-    }
+}
+function* TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!ValueGuard.IsAsyncIterator(value)) {
+    yield { type: ValueErrorType.AsyncIterator, schema, path, value, message: `Expected value to be an async iterator` }
   }
-  function* BigInt(schema: Types.TBigInt, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!IsBigInt(value)) {
-      return yield { type: ValueErrorType.BigInt, schema, path, value, message: `Expected bigint` }
-    }
-    if (IsDefined<bigint>(schema.multipleOf) && !(value % schema.multipleOf === globalThis.BigInt(0))) {
-      yield { type: ValueErrorType.BigIntMultipleOf, schema, path, value, message: `Expected bigint to be a multiple of ${schema.multipleOf}` }
-    }
-    if (IsDefined<bigint>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-      yield { type: ValueErrorType.BigIntExclusiveMinimum, schema, path, value, message: `Expected bigint to be greater than ${schema.exclusiveMinimum}` }
-    }
-    if (IsDefined<bigint>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-      yield { type: ValueErrorType.BigIntExclusiveMaximum, schema, path, value, message: `Expected bigint to be less than ${schema.exclusiveMaximum}` }
-    }
-    if (IsDefined<bigint>(schema.minimum) && !(value >= schema.minimum)) {
-      yield { type: ValueErrorType.BigIntMinimum, schema, path, value, message: `Expected bigint to be greater or equal to ${schema.minimum}` }
-    }
-    if (IsDefined<bigint>(schema.maximum) && !(value <= schema.maximum)) {
-      yield { type: ValueErrorType.BigIntMaximum, schema, path, value, message: `Expected bigint to be less or equal to ${schema.maximum}` }
-    }
+}
+function* TBigInt(schema: Types.TBigInt, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!ValueGuard.IsBigInt(value)) {
+    return yield { type: ValueErrorType.BigInt, schema, path, value, message: `Expected bigint` }
   }
-  function* Boolean(schema: Types.TBoolean, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(typeof value === 'boolean')) {
-      return yield { type: ValueErrorType.Boolean, schema, path, value, message: `Expected boolean` }
-    }
+  if (IsDefined<bigint>(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) {
+    yield { type: ValueErrorType.BigIntMultipleOf, schema, path, value, message: `Expected bigint to be a multiple of ${schema.multipleOf}` }
   }
-  function* Constructor(schema: Types.TConstructor, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    yield* Visit(schema.returns, references, path, value.prototype)
+  if (IsDefined<bigint>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+    yield { type: ValueErrorType.BigIntExclusiveMinimum, schema, path, value, message: `Expected bigint to be greater than ${schema.exclusiveMinimum}` }
   }
-  function* Date(schema: Types.TDate, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(value instanceof globalThis.Date)) {
-      return yield { type: ValueErrorType.Date, schema, path, value, message: `Expected Date object` }
-    }
-    if (!globalThis.isFinite(value.getTime())) {
-      return yield { type: ValueErrorType.Date, schema, path, value, message: `Invalid Date` }
-    }
-    if (IsDefined<number>(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
-      yield { type: ValueErrorType.DateExclusiveMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater than ${schema.exclusiveMinimum}` }
-    }
-    if (IsDefined<number>(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
-      yield { type: ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less than ${schema.exclusiveMaximum}` }
-    }
-    if (IsDefined<number>(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
-      yield { type: ValueErrorType.DateMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater or equal to ${schema.minimum}` }
-    }
-    if (IsDefined<number>(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
-      yield { type: ValueErrorType.DateMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less or equal to ${schema.maximum}` }
-    }
+  if (IsDefined<bigint>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    yield { type: ValueErrorType.BigIntExclusiveMaximum, schema, path, value, message: `Expected bigint to be less than ${schema.exclusiveMaximum}` }
   }
-  function* Function(schema: Types.TFunction, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(typeof value === 'function')) {
-      return yield { type: ValueErrorType.Function, schema, path, value, message: `Expected function` }
-    }
+  if (IsDefined<bigint>(schema.minimum) && !(value >= schema.minimum)) {
+    yield { type: ValueErrorType.BigIntMinimum, schema, path, value, message: `Expected bigint to be greater or equal to ${schema.minimum}` }
   }
-  function* Integer(schema: Types.TInteger, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!IsInteger(value)) {
-      return yield { type: ValueErrorType.Integer, schema, path, value, message: `Expected integer` }
-    }
-    if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-      yield { type: ValueErrorType.IntegerMultipleOf, schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` }
-    }
-    if (IsDefined<number>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-      yield { type: ValueErrorType.IntegerExclusiveMinimum, schema, path, value, message: `Expected integer to be greater than ${schema.exclusiveMinimum}` }
-    }
-    if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-      yield { type: ValueErrorType.IntegerExclusiveMaximum, schema, path, value, message: `Expected integer to be less than ${schema.exclusiveMaximum}` }
-    }
-    if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
-      yield { type: ValueErrorType.IntegerMinimum, schema, path, value, message: `Expected integer to be greater or equal to ${schema.minimum}` }
-    }
-    if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
-      yield { type: ValueErrorType.IntegerMaximum, schema, path, value, message: `Expected integer to be less or equal to ${schema.maximum}` }
-    }
+  if (IsDefined<bigint>(schema.maximum) && !(value <= schema.maximum)) {
+    yield { type: ValueErrorType.BigIntMaximum, schema, path, value, message: `Expected bigint to be less or equal to ${schema.maximum}` }
   }
-  function* Intersect(schema: Types.TIntersect, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    for (const inner of schema.allOf) {
-      const next = Visit(inner, references, path, value).next()
-      if (!next.done) {
-        yield next.value
-        yield { type: ValueErrorType.Intersect, schema, path, value, message: `Expected all sub schemas to be valid` }
-        return
-      }
+}
+function* TBoolean(schema: Types.TBoolean, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!ValueGuard.IsBoolean(value)) {
+    return yield { type: ValueErrorType.Boolean, schema, path, value, message: `Expected boolean` }
+  }
+}
+function* TConstructor(schema: Types.TConstructor, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  yield* Visit(schema.returns, references, path, value.prototype)
+}
+function* TDate(schema: Types.TDate, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!ValueGuard.IsDate(value)) {
+    return yield { type: ValueErrorType.Date, schema, path, value, message: `Expected Date object` }
+  }
+  if (!isFinite(value.getTime())) {
+    return yield { type: ValueErrorType.Date, schema, path, value, message: `Invalid Date` }
+  }
+  if (IsDefined<number>(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
+    yield { type: ValueErrorType.DateExclusiveMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater than ${schema.exclusiveMinimum}` }
+  }
+  if (IsDefined<number>(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+    yield { type: ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less than ${schema.exclusiveMaximum}` }
+  }
+  if (IsDefined<number>(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
+    yield { type: ValueErrorType.DateMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater or equal to ${schema.minimum}` }
+  }
+  if (IsDefined<number>(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
+    yield { type: ValueErrorType.DateMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less or equal to ${schema.maximum}` }
+  }
+}
+function* TFunction(schema: Types.TFunction, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!ValueGuard.IsFunction(value)) {
+    return yield { type: ValueErrorType.Function, schema, path, value, message: `Expected function` }
+  }
+}
+function* TInteger(schema: Types.TInteger, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!ValueGuard.IsInteger(value)) {
+    return yield { type: ValueErrorType.Integer, schema, path, value, message: `Expected integer` }
+  }
+  if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    yield { type: ValueErrorType.IntegerMultipleOf, schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` }
+  }
+  if (IsDefined<number>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+    yield { type: ValueErrorType.IntegerExclusiveMinimum, schema, path, value, message: `Expected integer to be greater than ${schema.exclusiveMinimum}` }
+  }
+  if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    yield { type: ValueErrorType.IntegerExclusiveMaximum, schema, path, value, message: `Expected integer to be less than ${schema.exclusiveMaximum}` }
+  }
+  if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
+    yield { type: ValueErrorType.IntegerMinimum, schema, path, value, message: `Expected integer to be greater or equal to ${schema.minimum}` }
+  }
+  if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
+    yield { type: ValueErrorType.IntegerMaximum, schema, path, value, message: `Expected integer to be less or equal to ${schema.maximum}` }
+  }
+}
+function* TIntersect(schema: Types.TIntersect, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  for (const inner of schema.allOf) {
+    const next = Visit(inner, references, path, value).next()
+    if (!next.done) {
+      yield next.value
+      yield { type: ValueErrorType.Intersect, schema, path, value, message: `Expected all sub schemas to be valid` }
+      return
     }
-    if (schema.unevaluatedProperties === false) {
-      const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema))
-      for (const valueKey of globalThis.Object.getOwnPropertyNames(value)) {
-        if (!keyCheck.test(valueKey)) {
-          yield { type: ValueErrorType.IntersectUnevaluatedProperties, schema, path: `${path}/${valueKey}`, value, message: `Unexpected property` }
-        }
+  }
+  if (schema.unevaluatedProperties === false) {
+    const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema))
+    for (const valueKey of Object.getOwnPropertyNames(value)) {
+      if (!keyCheck.test(valueKey)) {
+        yield { type: ValueErrorType.IntersectUnevaluatedProperties, schema, path: `${path}/${valueKey}`, value, message: `Unexpected property` }
       }
     }
-    if (typeof schema.unevaluatedProperties === 'object') {
-      const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema))
-      for (const valueKey of globalThis.Object.getOwnPropertyNames(value)) {
-        if (!keyCheck.test(valueKey)) {
-          const next = Visit(schema.unevaluatedProperties, references, `${path}/${valueKey}`, value[valueKey]).next()
-          if (!next.done) {
-            yield next.value
-            yield { type: ValueErrorType.IntersectUnevaluatedProperties, schema, path: `${path}/${valueKey}`, value, message: `Invalid additional property` }
-            return
-          }
+  }
+  if (typeof schema.unevaluatedProperties === 'object') {
+    const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema))
+    for (const valueKey of Object.getOwnPropertyNames(value)) {
+      if (!keyCheck.test(valueKey)) {
+        const next = Visit(schema.unevaluatedProperties, references, `${path}/${valueKey}`, value[valueKey]).next()
+        if (!next.done) {
+          yield next.value
+          yield { type: ValueErrorType.IntersectUnevaluatedProperties, schema, path: `${path}/${valueKey}`, value, message: `Invalid additional property` }
+          return
         }
       }
     }
   }
-  function* Literal(schema: Types.TLiteral, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(value === schema.const)) {
-      const error = typeof schema.const === 'string' ? `'${schema.const}'` : schema.const
-      return yield { type: ValueErrorType.Literal, schema, path, value, message: `Expected ${error}` }
-    }
+}
+function* TIterator(schema: Types.TIterator, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!(IsObject(value) && Symbol.iterator in value)) {
+    yield { type: ValueErrorType.Iterator, schema, path, value, message: `Expected value to be an iterator` }
   }
-  function* Never(schema: Types.TNever, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    yield { type: ValueErrorType.Never, schema, path, value, message: `Value cannot be validated` }
+}
+function* TLiteral(schema: Types.TLiteral, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!(value === schema.const)) {
+    const error = typeof schema.const === 'string' ? `'${schema.const}'` : schema.const
+    return yield { type: ValueErrorType.Literal, schema, path, value, message: `Expected ${error}` }
   }
-  function* Not(schema: Types.TNot, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (Visit(schema.not, references, path, value).next().done === true) {
-      yield { type: ValueErrorType.Not, schema, path, value, message: `Value should not validate` }
-    }
+}
+function* TNever(schema: Types.TNever, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  yield { type: ValueErrorType.Never, schema, path, value, message: `Value cannot be validated` }
+}
+function* TNot(schema: Types.TNot, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (Visit(schema.not, references, path, value).next().done === true) {
+    yield { type: ValueErrorType.Not, schema, path, value, message: `Value should not validate` }
   }
-  function* Null(schema: Types.TNull, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(value === null)) {
-      return yield { type: ValueErrorType.Null, schema, path, value, message: `Expected null` }
-    }
+}
+function* TNull(schema: Types.TNull, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!ValueGuard.IsNull(value)) {
+    return yield { type: ValueErrorType.Null, schema, path, value, message: `Expected null` }
   }
-  function* Number(schema: Types.TNumber, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!IsNumber(value)) {
-      return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` }
-    }
-    if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-      yield { type: ValueErrorType.NumberMultipleOf, schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` }
-    }
-    if (IsDefined<number>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-      yield { type: ValueErrorType.NumberExclusiveMinimum, schema, path, value, message: `Expected number to be greater than ${schema.exclusiveMinimum}` }
-    }
-    if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-      yield { type: ValueErrorType.NumberExclusiveMaximum, schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` }
-    }
-    if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
-      yield { type: ValueErrorType.NumberMinimum, schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` }
-    }
-    if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
-      yield { type: ValueErrorType.NumberMaximum, schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` }
-    }
+}
+function* TNumber(schema: Types.TNumber, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!IsNumber(value)) {
+    return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` }
   }
-  function* Object(schema: Types.TObject, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!IsObject(value)) {
-      return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
-    }
-    if (IsDefined<number>(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-      yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` }
-    }
-    if (IsDefined<number>(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-      yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have no more than ${schema.maxProperties} properties` }
-    }
-    const requiredKeys = globalThis.Array.isArray(schema.required) ? schema.required : ([] as string[])
-    const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties)
-    const unknownKeys = globalThis.Object.getOwnPropertyNames(value)
-    for (const knownKey of knownKeys) {
-      const property = schema.properties[knownKey]
-      if (schema.required && schema.required.includes(knownKey)) {
-        yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey])
-        if (Types.ExtendsUndefined.Check(schema) && !(knownKey in value)) {
-          yield { type: ValueErrorType.ObjectRequiredProperties, schema: property, path: `${path}/${knownKey}`, value: undefined, message: `Expected required property` }
-        }
-      } else {
-        if (IsExactOptionalProperty(value, knownKey)) {
-          yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey])
-        }
+  if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    yield { type: ValueErrorType.NumberMultipleOf, schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` }
+  }
+  if (IsDefined<number>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+    yield { type: ValueErrorType.NumberExclusiveMinimum, schema, path, value, message: `Expected number to be greater than ${schema.exclusiveMinimum}` }
+  }
+  if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    yield { type: ValueErrorType.NumberExclusiveMaximum, schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` }
+  }
+  if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
+    yield { type: ValueErrorType.NumberMinimum, schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` }
+  }
+  if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
+    yield { type: ValueErrorType.NumberMaximum, schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` }
+  }
+}
+function* TObject(schema: Types.TObject, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!IsObject(value)) {
+    return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
+  }
+  if (IsDefined<number>(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+    yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` }
+  }
+  if (IsDefined<number>(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+    yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have no more than ${schema.maxProperties} properties` }
+  }
+  const requiredKeys = Array.isArray(schema.required) ? schema.required : ([] as string[])
+  const knownKeys = Object.getOwnPropertyNames(schema.properties)
+  const unknownKeys = Object.getOwnPropertyNames(value)
+  for (const knownKey of knownKeys) {
+    const property = schema.properties[knownKey]
+    if (schema.required && schema.required.includes(knownKey)) {
+      yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey])
+      if (Types.ExtendsUndefined.Check(schema) && !(knownKey in value)) {
+        yield { type: ValueErrorType.ObjectRequiredProperties, schema: property, path: `${path}/${knownKey}`, value: undefined, message: `Expected required property` }
       }
-    }
-    for (const requiredKey of requiredKeys) {
-      if (unknownKeys.includes(requiredKey)) continue
-      yield { type: ValueErrorType.ObjectRequiredProperties, schema: schema.properties[requiredKey], path: `${path}/${requiredKey}`, value: undefined, message: `Expected required property` }
-    }
-    if (schema.additionalProperties === false) {
-      for (const valueKey of unknownKeys) {
-        if (!knownKeys.includes(valueKey)) {
-          yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${valueKey}`, value: value[valueKey], message: `Unexpected property` }
-        }
+    } else {
+      if (IsExactOptionalProperty(value, knownKey)) {
+        yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey])
       }
     }
-    if (typeof schema.additionalProperties === 'object') {
-      for (const valueKey of unknownKeys) {
-        if (knownKeys.includes(valueKey)) continue
-        yield* Visit(schema.additionalProperties as Types.TSchema, references, `${path}/${valueKey}`, value[valueKey])
+  }
+  for (const requiredKey of requiredKeys) {
+    if (unknownKeys.includes(requiredKey)) continue
+    yield { type: ValueErrorType.ObjectRequiredProperties, schema: schema.properties[requiredKey], path: `${path}/${requiredKey}`, value: undefined, message: `Expected required property` }
+  }
+  if (schema.additionalProperties === false) {
+    for (const valueKey of unknownKeys) {
+      if (!knownKeys.includes(valueKey)) {
+        yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${valueKey}`, value: value[valueKey], message: `Unexpected property` }
       }
     }
   }
-  function* Promise(schema: Types.TPromise, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(typeof value === 'object' && typeof value.then === 'function')) {
-      yield { type: ValueErrorType.Promise, schema, path, value, message: `Expected Promise` }
+  if (typeof schema.additionalProperties === 'object') {
+    for (const valueKey of unknownKeys) {
+      if (knownKeys.includes(valueKey)) continue
+      yield* Visit(schema.additionalProperties as Types.TSchema, references, `${path}/${valueKey}`, value[valueKey])
     }
   }
-  function* Record(schema: Types.TRecord, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!IsRecordObject(value)) {
-      return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected record object` }
-    }
-    if (IsDefined<number>(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-      yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` }
-    }
-    if (IsDefined<number>(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-      yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have no more than ${schema.maxProperties} properties` }
-    }
-    const [patternKey, patternSchema] = globalThis.Object.entries(schema.patternProperties)[0]
-    const regex = new RegExp(patternKey)
-    for (const [propertyKey, propertyValue] of globalThis.Object.entries(value)) {
-      if (regex.test(propertyKey)) {
-        yield* Visit(patternSchema, references, `${path}/${propertyKey}`, propertyValue)
-        continue
-      }
-      if (typeof schema.additionalProperties === 'object') {
-        yield* Visit(schema.additionalProperties, references, `${path}/${propertyKey}`, propertyValue)
-      }
-      if (schema.additionalProperties === false) {
-        const propertyPath = `${path}/${propertyKey}`
-        const message = `Unexpected property '${propertyPath}'`
-        return yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: propertyPath, value: propertyValue, message }
-      }
-    }
+}
+function* TPromise(schema: Types.TPromise, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!ValueGuard.IsPromise(value)) {
+    yield { type: ValueErrorType.Promise, schema, path, value, message: `Expected Promise` }
   }
-  function* Ref(schema: Types.TRef<any>, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-    if (index === -1) throw new ValueErrorsDereferenceError(schema)
-    const target = references[index]
-    yield* Visit(target, references, path, value)
+}
+function* TRecord(schema: Types.TRecord, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!IsRecordObject(value)) {
+    return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected record object` }
   }
-  function* String(schema: Types.TString, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!IsString(value)) {
-      return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' }
-    }
-    if (IsDefined<number>(schema.minLength) && !(value.length >= schema.minLength)) {
-      yield { type: ValueErrorType.StringMinLength, schema, path, value, message: `Expected string length greater or equal to ${schema.minLength}` }
-    }
-    if (IsDefined<number>(schema.maxLength) && !(value.length <= schema.maxLength)) {
-      yield { type: ValueErrorType.StringMaxLength, schema, path, value, message: `Expected string length less or equal to ${schema.maxLength}` }
+  if (IsDefined<number>(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+    yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` }
+  }
+  if (IsDefined<number>(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+    yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have no more than ${schema.maxProperties} properties` }
+  }
+  const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0]
+  const regex = new RegExp(patternKey)
+  for (const [propertyKey, propertyValue] of Object.entries(value)) {
+    if (regex.test(propertyKey)) {
+      yield* Visit(patternSchema, references, `${path}/${propertyKey}`, propertyValue)
+      continue
     }
-    if (schema.pattern !== undefined) {
-      const regex = new RegExp(schema.pattern)
-      if (!regex.test(value)) {
-        yield { type: ValueErrorType.StringPattern, schema, path, value, message: `Expected string to match pattern ${schema.pattern}` }
-      }
+    if (typeof schema.additionalProperties === 'object') {
+      yield* Visit(schema.additionalProperties, references, `${path}/${propertyKey}`, propertyValue)
     }
-    if (schema.format !== undefined) {
-      if (!Types.FormatRegistry.Has(schema.format)) {
-        yield { type: ValueErrorType.StringFormatUnknown, schema, path, value, message: `Unknown string format '${schema.format}'` }
-      } else {
-        const format = Types.FormatRegistry.Get(schema.format)!
-        if (!format(value)) {
-          yield { type: ValueErrorType.StringFormat, schema, path, value, message: `Expected string to match format '${schema.format}'` }
-        }
-      }
+    if (schema.additionalProperties === false) {
+      const propertyPath = `${path}/${propertyKey}`
+      const message = `Unexpected property '${propertyPath}'`
+      return yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: propertyPath, value: propertyValue, message }
     }
   }
-  function* Symbol(schema: Types.TSymbol, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(typeof value === 'symbol')) {
-      return yield { type: ValueErrorType.Symbol, schema, path, value, message: 'Expected symbol' }
-    }
+}
+function* TRef(schema: Types.TRef<any>, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+  if (index === -1) throw new ValueErrorsDereferenceError(schema)
+  const target = references[index]
+  yield* Visit(target, references, path, value)
+}
+function* TString(schema: Types.TString, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!ValueGuard.IsString(value)) {
+    return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' }
   }
-  function* TemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!IsString(value)) {
-      return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' }
-    }
+  if (IsDefined<number>(schema.minLength) && !(value.length >= schema.minLength)) {
+    yield { type: ValueErrorType.StringMinLength, schema, path, value, message: `Expected string length greater or equal to ${schema.minLength}` }
+  }
+  if (IsDefined<number>(schema.maxLength) && !(value.length <= schema.maxLength)) {
+    yield { type: ValueErrorType.StringMaxLength, schema, path, value, message: `Expected string length less or equal to ${schema.maxLength}` }
+  }
+  if (ValueGuard.IsString(schema.pattern)) {
     const regex = new RegExp(schema.pattern)
     if (!regex.test(value)) {
       yield { type: ValueErrorType.StringPattern, schema, path, value, message: `Expected string to match pattern ${schema.pattern}` }
     }
   }
-  function* This(schema: Types.TThis, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-    if (index === -1) throw new ValueErrorsDereferenceError(schema)
-    const target = references[index]
-    yield* Visit(target, references, path, value)
-  }
-  function* Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!globalThis.Array.isArray(value)) {
-      return yield { type: ValueErrorType.Array, schema, path, value, message: 'Expected Array' }
-    }
-    if (schema.items === undefined && !(value.length === 0)) {
-      return yield { type: ValueErrorType.TupleZeroLength, schema, path, value, message: 'Expected tuple to have 0 elements' }
-    }
-    if (!(value.length === schema.maxItems)) {
-      yield { type: ValueErrorType.TupleLength, schema, path, value, message: `Expected tuple to have ${schema.maxItems} elements` }
-    }
-    if (!schema.items) {
-      return
-    }
-    for (let i = 0; i < schema.items.length; i++) {
-      yield* Visit(schema.items[i], references, `${path}/${i}`, value[i])
+  if (ValueGuard.IsString(schema.format)) {
+    if (!Types.FormatRegistry.Has(schema.format)) {
+      yield { type: ValueErrorType.StringFormatUnknown, schema, path, value, message: `Unknown string format '${schema.format}'` }
+    } else {
+      const format = Types.FormatRegistry.Get(schema.format)!
+      if (!format(value)) {
+        yield { type: ValueErrorType.StringFormat, schema, path, value, message: `Expected string to match format '${schema.format}'` }
+      }
     }
   }
-  function* Undefined(schema: Types.TUndefined, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(value === undefined)) {
-      yield { type: ValueErrorType.Undefined, schema, path, value, message: `Expected undefined` }
-    }
+}
+function* TSymbol(schema: Types.TSymbol, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!ValueGuard.IsSymbol(value)) {
+    return yield { type: ValueErrorType.Symbol, schema, path, value, message: 'Expected symbol' }
   }
-  function* Union(schema: Types.TUnion, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    const errors: ValueError[] = []
-    for (const inner of schema.anyOf) {
-      const variantErrors = [...Visit(inner, references, path, value)]
-      if (variantErrors.length === 0) return
-      errors.push(...variantErrors)
-    }
-    if (errors.length > 0) {
-      yield { type: ValueErrorType.Union, schema, path, value, message: 'Expected value of union' }
-    }
-    for (const error of errors) {
-      yield error
-    }
+}
+function* TTemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!ValueGuard.IsString(value)) {
+    return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' }
   }
-  function* Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!(value instanceof globalThis.Uint8Array)) {
-      return yield { type: ValueErrorType.Uint8Array, schema, path, value, message: `Expected Uint8Array` }
-    }
-    if (IsDefined<number>(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
-      yield { type: ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length less or equal to ${schema.maxByteLength}` }
-    }
-    if (IsDefined<number>(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
-      yield { type: ValueErrorType.Uint8ArrayMinByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length greater or equal to ${schema.maxByteLength}` }
-    }
+  const regex = new RegExp(schema.pattern)
+  if (!regex.test(value)) {
+    yield { type: ValueErrorType.StringPattern, schema, path, value, message: `Expected string to match pattern ${schema.pattern}` }
   }
-  function* Unknown(schema: Types.TUnknown, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {}
-  function* Void(schema: Types.TVoid, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    if (!IsVoid(value)) {
-      return yield { type: ValueErrorType.Void, schema, path, value, message: `Expected void` }
-    }
+}
+function* TThis(schema: Types.TThis, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+  if (index === -1) throw new ValueErrorsDereferenceError(schema)
+  const target = references[index]
+  yield* Visit(target, references, path, value)
+}
+function* TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!ValueGuard.IsArray(value)) {
+    return yield { type: ValueErrorType.Array, schema, path, value, message: 'Expected Array' }
   }
-  function* UserDefined(schema: Types.TSchema, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    const check = Types.TypeRegistry.Get(schema[Types.Kind])!
-    if (!check(schema, value)) {
-      return yield { type: ValueErrorType.Custom, schema, path, value, message: `Expected kind ${schema[Types.Kind]}` }
-    }
+  if (schema.items === undefined && !(value.length === 0)) {
+    return yield { type: ValueErrorType.TupleZeroLength, schema, path, value, message: 'Expected tuple to have 0 elements' }
   }
-  function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-    const references_ = IsDefined<string>(schema.$id) ? [...references, schema] : references
-    const schema_ = schema as any
-    switch (schema_[Types.Kind]) {
-      case 'Any':
-        return yield* Any(schema_, references_, path, value)
-      case 'Array':
-        return yield* Array(schema_, references_, path, value)
-      case 'BigInt':
-        return yield* BigInt(schema_, references_, path, value)
-      case 'Boolean':
-        return yield* Boolean(schema_, references_, path, value)
-      case 'Constructor':
-        return yield* Constructor(schema_, references_, path, value)
-      case 'Date':
-        return yield* Date(schema_, references_, path, value)
-      case 'Function':
-        return yield* Function(schema_, references_, path, value)
-      case 'Integer':
-        return yield* Integer(schema_, references_, path, value)
-      case 'Intersect':
-        return yield* Intersect(schema_, references_, path, value)
-      case 'Literal':
-        return yield* Literal(schema_, references_, path, value)
-      case 'Never':
-        return yield* Never(schema_, references_, path, value)
-      case 'Not':
-        return yield* Not(schema_, references_, path, value)
-      case 'Null':
-        return yield* Null(schema_, references_, path, value)
-      case 'Number':
-        return yield* Number(schema_, references_, path, value)
-      case 'Object':
-        return yield* Object(schema_, references_, path, value)
-      case 'Promise':
-        return yield* Promise(schema_, references_, path, value)
-      case 'Record':
-        return yield* Record(schema_, references_, path, value)
-      case 'Ref':
-        return yield* Ref(schema_, references_, path, value)
-      case 'String':
-        return yield* String(schema_, references_, path, value)
-      case 'Symbol':
-        return yield* Symbol(schema_, references_, path, value)
-      case 'TemplateLiteral':
-        return yield* TemplateLiteral(schema_, references_, path, value)
-      case 'This':
-        return yield* This(schema_, references_, path, value)
-      case 'Tuple':
-        return yield* Tuple(schema_, references_, path, value)
-      case 'Undefined':
-        return yield* Undefined(schema_, references_, path, value)
-      case 'Union':
-        return yield* Union(schema_, references_, path, value)
-      case 'Uint8Array':
-        return yield* Uint8Array(schema_, references_, path, value)
-      case 'Unknown':
-        return yield* Unknown(schema_, references_, path, value)
-      case 'Void':
-        return yield* Void(schema_, references_, path, value)
-      default:
-        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueErrorsUnknownTypeError(schema)
-        return yield* UserDefined(schema_, references_, path, value)
-    }
+  if (!(value.length === schema.maxItems)) {
+    yield { type: ValueErrorType.TupleLength, schema, path, value, message: `Expected tuple to have ${schema.maxItems} elements` }
+  }
+  if (!schema.items) {
+    return
+  }
+  for (let i = 0; i < schema.items.length; i++) {
+    yield* Visit(schema.items[i], references, `${path}/${i}`, value[i])
+  }
+}
+function* TUndefined(schema: Types.TUndefined, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!(value === undefined)) {
+    yield { type: ValueErrorType.Undefined, schema, path, value, message: `Expected undefined` }
+  }
+}
+function* TUnion(schema: Types.TUnion, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  const errors: ValueError[] = []
+  for (const inner of schema.anyOf) {
+    const variantErrors = [...Visit(inner, references, path, value)]
+    if (variantErrors.length === 0) return
+    errors.push(...variantErrors)
+  }
+  if (errors.length > 0) {
+    yield { type: ValueErrorType.Union, schema, path, value, message: 'Expected value of union' }
+  }
+  for (const error of errors) {
+    yield error
   }
-  export function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): ValueErrorIterator {
-    const iterator = Visit(schema, references, '', value)
-    return new ValueErrorIterator(iterator)
+}
+function* TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!ValueGuard.IsUint8Array(value)) {
+    return yield { type: ValueErrorType.Uint8Array, schema, path, value, message: `Expected Uint8Array` }
+  }
+  if (IsDefined<number>(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
+    yield { type: ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length less or equal to ${schema.maxByteLength}` }
+  }
+  if (IsDefined<number>(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
+    yield { type: ValueErrorType.Uint8ArrayMinByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length greater or equal to ${schema.maxByteLength}` }
+  }
+}
+function* TUnknown(schema: Types.TUnknown, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {}
+function* TVoid(schema: Types.TVoid, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!IsVoid(value)) {
+    return yield { type: ValueErrorType.Void, schema, path, value, message: `Expected void` }
   }
 }
+function* TKind(schema: Types.TSchema, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  const check = Types.TypeRegistry.Get(schema[Types.Kind])!
+  if (!check(schema, value)) {
+    return yield { type: ValueErrorType.Kind, schema, path, value, message: `Expected kind ${schema[Types.Kind]}` }
+  }
+}
+function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  const references_ = IsDefined<string>(schema.$id) ? [...references, schema] : references
+  const schema_ = schema as any
+  switch (schema_[Types.Kind]) {
+    case 'Any':
+      return yield* TAny(schema_, references_, path, value)
+    case 'Array':
+      return yield* TArray(schema_, references_, path, value)
+    case 'AsyncIterator':
+      return yield* TAsyncIterator(schema_, references_, path, value)
+    case 'BigInt':
+      return yield* TBigInt(schema_, references_, path, value)
+    case 'Boolean':
+      return yield* TBoolean(schema_, references_, path, value)
+    case 'Constructor':
+      return yield* TConstructor(schema_, references_, path, value)
+    case 'Date':
+      return yield* TDate(schema_, references_, path, value)
+    case 'Function':
+      return yield* TFunction(schema_, references_, path, value)
+    case 'Integer':
+      return yield* TInteger(schema_, references_, path, value)
+    case 'Intersect':
+      return yield* TIntersect(schema_, references_, path, value)
+    case 'Iterator':
+      return yield* TIterator(schema_, references_, path, value)
+    case 'Literal':
+      return yield* TLiteral(schema_, references_, path, value)
+    case 'Never':
+      return yield* TNever(schema_, references_, path, value)
+    case 'Not':
+      return yield* TNot(schema_, references_, path, value)
+    case 'Null':
+      return yield* TNull(schema_, references_, path, value)
+    case 'Number':
+      return yield* TNumber(schema_, references_, path, value)
+    case 'Object':
+      return yield* TObject(schema_, references_, path, value)
+    case 'Promise':
+      return yield* TPromise(schema_, references_, path, value)
+    case 'Record':
+      return yield* TRecord(schema_, references_, path, value)
+    case 'Ref':
+      return yield* TRef(schema_, references_, path, value)
+    case 'String':
+      return yield* TString(schema_, references_, path, value)
+    case 'Symbol':
+      return yield* TSymbol(schema_, references_, path, value)
+    case 'TemplateLiteral':
+      return yield* TTemplateLiteral(schema_, references_, path, value)
+    case 'This':
+      return yield* TThis(schema_, references_, path, value)
+    case 'Tuple':
+      return yield* TTuple(schema_, references_, path, value)
+    case 'Undefined':
+      return yield* TUndefined(schema_, references_, path, value)
+    case 'Union':
+      return yield* TUnion(schema_, references_, path, value)
+    case 'Uint8Array':
+      return yield* TUint8Array(schema_, references_, path, value)
+    case 'Unknown':
+      return yield* TUnknown(schema_, references_, path, value)
+    case 'Void':
+      return yield* TVoid(schema_, references_, path, value)
+    default:
+      if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueErrorsUnknownTypeError(schema)
+      return yield* TKind(schema_, references_, path, value)
+  }
+}
+/** Returns an iterator for each error in this value. */
+export function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): ValueErrorIterator
+/** Returns an iterator for each error in this value. */
+export function Errors<T extends Types.TSchema>(schema: T, value: unknown): ValueErrorIterator
+/** Returns an iterator for each error in this value. */
+export function Errors(...args: any[]) {
+  const iterator = args.length === 3 ? Visit(args[0], args[1], '', args[2]) : Visit(args[0], [], '', args[1])
+  return new ValueErrorIterator(iterator)
+}
diff --git a/src/system/system.ts b/src/system/system.ts
index 880f800e4..4b5291fd2 100644
--- a/src/system/system.ts
+++ b/src/system/system.ts
@@ -38,12 +38,8 @@ export class TypeSystemDuplicateFormat extends Error {
     super(`Duplicate string format '${kind}' detected`)
   }
 }
-
 /** Creates user defined types and formats and provides overrides for value checking behaviours */
 export namespace TypeSystem {
-  // ------------------------------------------------------------------------
-  // Assertion Policies
-  // ------------------------------------------------------------------------
   /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
   export let ExactOptionalPropertyTypes: boolean = false
   /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
@@ -52,9 +48,7 @@ export namespace TypeSystem {
   export let AllowNaN: boolean = false
   /** Sets whether `null` should validate for void types. The default is `false` */
   export let AllowVoidNull: boolean = false
-  // ------------------------------------------------------------------------
-  // String Formats and Types
-  // ------------------------------------------------------------------------
+
   /** Creates a new type */
   export function Type<Type, Options = object>(kind: string, check: (options: Options, value: unknown) => boolean) {
     if (Types.TypeRegistry.Has(kind)) throw new TypeSystemDuplicateTypeKind(kind)
diff --git a/src/typebox.ts b/src/typebox.ts
index 0c9945cf7..2e7c407cf 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -29,7 +29,8 @@ THE SOFTWARE.
 // --------------------------------------------------------------------------
 // Symbols
 // --------------------------------------------------------------------------
-export const Modifier = Symbol.for('TypeBox.Modifier')
+export const Readonly = Symbol.for('TypeBox.Readonly')
+export const Optional = Symbol.for('TypeBox.Optional')
 export const Hint = Symbol.for('TypeBox.Hint')
 export const Kind = Symbol.for('TypeBox.Kind')
 // --------------------------------------------------------------------------
@@ -64,21 +65,34 @@ export type AssertType<T, E extends TSchema = TSchema> = T extends E ? T : TNeve
 // --------------------------------------------------------------------------
 // Modifiers
 // --------------------------------------------------------------------------
-export type TModifier = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>
-export type TReadonly<T extends TSchema> = T & { [Modifier]: 'Readonly' }
-export type TOptional<T extends TSchema> = T & { [Modifier]: 'Optional' }
-export type TReadonlyOptional<T extends TSchema> = T & { [Modifier]: 'ReadonlyOptional' }
+export type TModifier = TOptional<TSchema> | TReadonly<TSchema>
+export type TReadonly<T extends TSchema> = T & { [Readonly]: 'Readonly' }
+export type TOptional<T extends TSchema> = T & { [Optional]: 'Optional' }
+// --------------------------------------------------------------------------
+// Readonly Unwrap
+// --------------------------------------------------------------------------
+// prettier-ignore
+export type ReadonlyUnwrapType<T extends TSchema> =
+  T extends TReadonly<infer S> ? ReadonlyUnwrapType<S> : 
+  T extends TOptional<infer S> ? TOptional<ReadonlyUnwrapType<S>> :
+  T
+// prettier-ignore
+export type ReadonlyUnwrapRest<T extends TSchema[]> = T extends [infer L, ...infer R]
+  ? L extends TReadonly<infer S>
+    ? [ReadonlyUnwrapType<AssertType<S>>, ...ReadonlyUnwrapRest<AssertRest<R>>] 
+    : [L, ...ReadonlyUnwrapRest<AssertRest<R>>]
+  :  []
 // --------------------------------------------------------------------------
 // Optional Unwrap
 // --------------------------------------------------------------------------
 // prettier-ignore
 export type OptionalUnwrapType<T extends TSchema> =
-  T extends (TOptional<infer S> | TReadonlyOptional<infer S>)
-    ? OptionalUnwrapType<S>
-    : T
+  T extends TReadonly<infer S> ? TReadonly<OptionalUnwrapType<S>> :
+  T extends TOptional<infer S> ? OptionalUnwrapType<S> : 
+  T
 // prettier-ignore
 export type OptionalUnwrapRest<T extends TSchema[]> = T extends [infer L, ...infer R]
-  ? L extends (TOptional<infer S> | TReadonlyOptional<infer S>)
+  ? L extends TOptional<infer S>
     ? [OptionalUnwrapType<AssertType<S>>, ...OptionalUnwrapRest<AssertRest<R>>] 
     : [L, ...OptionalUnwrapRest<AssertRest<R>>]
   :  []
@@ -87,7 +101,7 @@ export type OptionalUnwrapRest<T extends TSchema[]> = T extends [infer L, ...inf
 // --------------------------------------------------------------------------
 // prettier-ignore
 export type IntersectOptional<T extends TSchema[]> = T extends [infer L, ...infer R] 
-  ? L extends TOptional<AssertType<L>> | TReadonlyOptional<AssertType<L>> 
+  ? L extends TOptional<AssertType<L>> 
     ? IntersectOptional<AssertRest<R>> 
     : false
   : true
@@ -105,7 +119,7 @@ export type IntersectType<T extends TSchema[]> =
 // --------------------------------------------------------------------------
 // prettier-ignore
 export type UnionOptional<T extends TSchema[]> = T extends [infer L, ...infer R]
-  ? L extends (TOptional<AssertType<L>> | TReadonlyOptional<AssertType<L>>)
+  ? L extends (TOptional<AssertType<L>>)
     ? true 
     : UnionOptional<AssertRest<R>> 
   : false
@@ -119,10 +133,6 @@ export type UnionType<T extends TSchema[]> =
   T extends [TSchema] ? AssertType<T[0]> : 
   UnionResolve<T>
 // --------------------------------------------------------------------------
-// Key
-// --------------------------------------------------------------------------
-export type Key = string | number
-// --------------------------------------------------------------------------
 // TSchema
 // --------------------------------------------------------------------------
 export interface SchemaOptions {
@@ -137,13 +147,18 @@ export interface SchemaOptions {
   default?: any
   /** Example values matching this schema */
   examples?: any
+  /** Optional annotation for readOnly */
+  readOnly?: boolean
+  /** Optional annotation for writeOnly */
+  writeOnly?: boolean
   [prop: string]: any
 }
 export interface TKind {
   [Kind]: string
 }
 export interface TSchema extends SchemaOptions, TKind {
-  [Modifier]?: string
+  [Readonly]?: string
+  [Optional]?: string
   [Hint]?: string
   params: unknown[]
   static: unknown
@@ -155,6 +170,7 @@ export type TAnySchema =
   | TSchema
   | TAny
   | TArray
+  | TAsyncIterator
   | TBigInt
   | TBoolean
   | TConstructor
@@ -163,6 +179,7 @@ export type TAnySchema =
   | TFunction
   | TInteger
   | TIntersect
+  | TIterator
   | TLiteral
   | TNot
   | TNull
@@ -202,9 +219,18 @@ export interface TAny extends TSchema {
 // TArray
 // --------------------------------------------------------------------------
 export interface ArrayOptions extends SchemaOptions {
-  uniqueItems?: boolean
+  /** The minimum number of items in this array */
   minItems?: number
+  /** The maximum number of items in this array */
   maxItems?: number
+  /** Should this schema contain unique items */
+  uniqueItems?: boolean
+  /** A schema for which some elements should match */
+  contains?: TSchema
+  /** A minimum number of contains schema matches */
+  minContains?: number
+  /** A maximum number of contains schema matches */
+  maxContains?: number
 }
 export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
   [Kind]: 'Array'
@@ -213,13 +239,34 @@ export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptio
   items: T
 }
 // --------------------------------------------------------------------------
+// TAsyncIterator
+// --------------------------------------------------------------------------
+export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'AsyncIterator'
+  static: AsyncIterableIterator<Static<T, this['params']>>
+  type: 'AsyncIterator'
+  items: T
+}
+// -------------------------------------------------------------------------------
+// Awaited
+// -------------------------------------------------------------------------------
+// prettier-ignore
+export type TAwaitedRest<T extends TSchema[]> = T extends [infer L, ...infer R]
+  ? [TAwaited<AssertType<L>>, ...TAwaitedRest<AssertRest<R>>]
+  : []
+// prettier-ignore
+export type TAwaited<T extends TSchema> = 
+  T extends TIntersect<infer S> ? TIntersect<TAwaitedRest<S>> :
+  T extends TUnion<infer S>     ? TUnion<TAwaitedRest<S>> :
+  T extends TPromise<infer S>   ? TAwaited<S> :
+  T
+// --------------------------------------------------------------------------
 // TBigInt
 // --------------------------------------------------------------------------
 export interface TBigInt extends TSchema, NumericOptions<bigint> {
   [Kind]: 'BigInt'
   static: bigint
-  type: 'null'
-  typeOf: 'BigInt'
+  type: 'bigint'
 }
 // --------------------------------------------------------------------------
 // TBoolean
@@ -263,8 +310,7 @@ export type TConstructorParameterArray<T extends readonly TSchema[], P extends u
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Constructor'
   static: new (...param: TConstructorParameterArray<T, this['params']>) => Static<U, this['params']>
-  type: 'object'
-  instanceOf: 'Constructor'
+  type: 'constructor'
   parameters: T
   returns: U
 }
@@ -272,16 +318,19 @@ export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema
 // TDate
 // --------------------------------------------------------------------------
 export interface DateOptions extends SchemaOptions {
+  /** The exclusive maximum timestamp value */
   exclusiveMaximumTimestamp?: number
+  /** The exclusive minimum timestamp value */
   exclusiveMinimumTimestamp?: number
+  /** The maximum timestamp value */
   maximumTimestamp?: number
+  /** The minimum timestamp value */
   minimumTimestamp?: number
 }
 export interface TDate extends TSchema, DateOptions {
   [Kind]: 'Date'
   static: Date
-  type: 'object'
-  instanceOf: 'Date'
+  type: 'date'
 }
 // --------------------------------------------------------------------------
 // TEnum
@@ -334,12 +383,11 @@ export type TExtract<T extends TSchema, U extends TSchema> =
 // --------------------------------------------------------------------------
 // TFunction
 // --------------------------------------------------------------------------
-export type TFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: Static<AssertType<T[K]>, P> }]
-export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+export type TFunctionParameters<T extends TSchema[], P extends unknown[]> = [...{ [K in keyof T]: Static<AssertType<T[K]>, P> }]
+export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Function'
   static: (...param: TFunctionParameters<T, this['params']>) => Static<U, this['params']>
-  type: 'object'
-  instanceOf: 'Function'
+  type: 'function'
   parameters: T
   returns: U
 }
@@ -347,31 +395,29 @@ export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends T
 // TIndex
 // --------------------------------------------------------------------------
 
-export type TIndexRest<T extends TSchema[], K extends Key> = T extends [infer L, ...infer R] ? [TIndexType<AssertType<L>, K>, ...TIndexRest<AssertRest<R>, K>] : []
-export type TIndexProperty<T extends TProperties, K extends Key> = K extends keyof T ? [T[K]] : []
-export type TIndexTuple<T extends TSchema[], K extends Key> = K extends keyof T ? [T[K]] : []
+export type TIndexRest<T extends TSchema[], K extends TPropertyKey> = T extends [infer L, ...infer R] ? [TIndexType<AssertType<L>, K>, ...TIndexRest<AssertRest<R>, K>] : []
+export type TIndexProperty<T extends TProperties, K extends TPropertyKey> = K extends keyof T ? [T[K]] : []
+export type TIndexTuple<T extends TSchema[], K extends TPropertyKey> = K extends keyof T ? [T[K]] : []
 // prettier-ignore
-export type TIndexType<T extends TSchema, K extends Key> =
+export type TIndexType<T extends TSchema, K extends TPropertyKey> =
   T extends TRecursive<infer S> ? TIndexType<S, K> :
   T extends TIntersect<infer S> ? IntersectType<AssertRest<Discard<Flat<TIndexRest<S, K>>, TNever>>> :
   T extends TUnion<infer S>     ? UnionType<AssertRest<Flat<TIndexRest<S, K>>>> :
   T extends TObject<infer S>    ? UnionType<AssertRest<Flat<TIndexProperty<S, K>>>> :
   T extends TTuple<infer S>     ? UnionType<AssertRest<Flat<TIndexTuple<S, K>>>> :
   []
-
 // prettier-ignore
-export type TIndexRestMany<T extends TSchema, K extends Key[]> = 
- K extends [infer L, ...infer R] ? [TIndexType<T, Assert<L, Key>>, ...TIndexRestMany<T, Assert<R, Key[]>>] :
+export type TIndexRestMany<T extends TSchema, K extends TPropertyKey[]> = 
+ K extends [infer L, ...infer R] ? [TIndexType<T, Assert<L, TPropertyKey>>, ...TIndexRestMany<T, Assert<R, TPropertyKey[]>>] :
  []
 // prettier-ignore
-export type TIndex<T extends TSchema, K extends Key[]> =
+export type TIndex<T extends TSchema, K extends TPropertyKey[]> =
   T extends TRecursive<infer S> ? TIndex<S, K> :
   T extends TIntersect ? UnionType<Flat<TIndexRestMany<T, K>>> :
   T extends TUnion     ? UnionType<Flat<TIndexRestMany<T, K>>> :
   T extends TObject    ? UnionType<Flat<TIndexRestMany<T, K>>> :
   T extends TTuple     ? UnionType<Flat<TIndexRestMany<T, K>>> :
   TNever
-
 // --------------------------------------------------------------------------
 // TInteger
 // --------------------------------------------------------------------------
@@ -394,6 +440,15 @@ export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, In
   allOf: [...T]
 }
 // --------------------------------------------------------------------------
+// TIterator
+// --------------------------------------------------------------------------
+export interface TIterator<T extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'Iterator'
+  static: IterableIterator<Static<T, this['params']>>
+  type: 'Iterator'
+  items: T
+}
+// --------------------------------------------------------------------------
 // TKeyOf
 // --------------------------------------------------------------------------
 // prettier-ignore
@@ -420,7 +475,10 @@ export type TKeyOf<T extends TSchema = TSchema> = (
 // --------------------------------------------------------------------------
 // TLiteral
 // --------------------------------------------------------------------------
-export type TLiteralValue = string | number | boolean // | bigint - supported but variant disable due to potential numeric type conflicts
+export type TLiteralValue = boolean | number | string // | bigint - supported but variant disable due to potential numeric type conflicts
+export type TLiteralBoolean = TLiteral<boolean>
+export type TLiteralNumber = TLiteral<number>
+export type TLiteralString = TLiteral<string>
 export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
   [Kind]: 'Literal'
   static: T
@@ -461,9 +519,9 @@ export interface TNumber extends TSchema, NumericOptions<number> {
 // --------------------------------------------------------------------------
 // TObject
 // --------------------------------------------------------------------------
-export type ReadonlyOptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never }[keyof T]
-export type ReadonlyPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never }[keyof T]
-export type OptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TOptional<TSchema> ? K : never }[keyof T]
+export type ReadonlyOptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never }[keyof T]
+export type ReadonlyPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? never : K) : never }[keyof T]
+export type OptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : K) : never }[keyof T]
 export type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>
 // prettier-ignore
 export type PropertiesReducer<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(
@@ -476,7 +534,8 @@ export type PropertiesReducer<T extends TProperties, R extends Record<keyof any,
 export type PropertiesReduce<T extends TProperties, P extends unknown[]> = PropertiesReducer<T, {
   [K in keyof T]: Static<T[K], P>
 }>
-export type TProperties = Record<keyof any, TSchema>
+export type TPropertyKey = string | number
+export type TProperties = Record<TPropertyKey, TSchema>
 export type ObjectProperties<T> = T extends TObject<infer U> ? U : never
 export type ObjectPropertyKeys<T> = T extends TObject<infer U> ? keyof U : never
 export type TAdditionalProperties = undefined | TSchema | boolean
@@ -496,13 +555,13 @@ export interface TObject<T extends TProperties = TProperties> extends TSchema, O
 // --------------------------------------------------------------------------
 // TOmit
 // --------------------------------------------------------------------------
-export type TOmitArray<T extends TSchema[], K extends keyof any> = AssertRest<{ [K2 in keyof T]: TOmit<AssertType<T[K2]>, K> }>
 export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<AssertProperties<Omit<T, K>>>
+export type TOmitRest<T extends TSchema[], K extends keyof any> = AssertRest<{ [K2 in keyof T]: TOmit<AssertType<T[K2]>, K> }>
 // prettier-ignore
 export type TOmit<T extends TSchema = TSchema, K extends keyof any = keyof any> = 
   T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> :
-  T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : 
-  T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : 
+  T extends TIntersect<infer S> ? TIntersect<TOmitRest<S, K>> : 
+  T extends TUnion<infer S> ? TUnion<TOmitRest<S, K>> : 
   T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : 
   T
 // --------------------------------------------------------------------------
@@ -513,26 +572,21 @@ export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>
 // TPartial
 // --------------------------------------------------------------------------
 export type TPartialObjectArray<T extends TObject[]> = AssertRest<{ [K in keyof T]: TPartial<AssertType<T[K], TObject>> }, TObject[]>
-export type TPartialArray<T extends TSchema[]> = AssertRest<{ [K in keyof T]: TPartial<AssertType<T[K]>> }>
+export type TPartialRest<T extends TSchema[]> = AssertRest<{ [K in keyof T]: TPartial<AssertType<T[K]>> }>
 // prettier-ignore
 export type TPartialProperties<T extends TProperties> = Evaluate<AssertProperties<{
-  [K in keyof T]: 
-    T[K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : 
-    T[K] extends TReadonly<infer U>         ? TReadonlyOptional<U> : 
-    T[K] extends TOptional<infer U>         ? TOptional<U>         : 
-    TOptional<T[K]>
+  [K in keyof T]: TOptional<T[K]>
 }>>
 // prettier-ignore
 export type TPartial<T extends TSchema> =  
   T extends TRecursive<infer S> ? TRecursive<TPartial<S>> :   
-  T extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : 
-  T extends TUnion<infer S>     ? TUnion<TPartialArray<S>> : 
+  T extends TIntersect<infer S> ? TIntersect<TPartialRest<S>> : 
+  T extends TUnion<infer S>     ? TUnion<TPartialRest<S>> : 
   T extends TObject<infer S>    ? TObject<TPartialProperties<S>> : 
   T
 // --------------------------------------------------------------------------
 // TPick
 // --------------------------------------------------------------------------
-export type TPickArray<T extends TSchema[], K extends keyof any> = { [K2 in keyof T]: TPick<AssertType<T[K2]>, K> }
 // Note the key K will overlap for varying TProperties gathered via recursive union and intersect traversal. Because of this,
 // we need to extract only keys assignable to T on K2. This behavior is only required for Pick only.
 // prettier-ignore
@@ -540,11 +594,12 @@ export type TPickProperties<T extends TProperties, K extends keyof any> =
   Pick<T, Assert<Extract<K, keyof T>, keyof T>> extends infer R ? ({
     [K in keyof R]: AssertType<R[K]> extends TSchema ? R[K] : never
   }): never
+export type TPickRest<T extends TSchema[], K extends keyof any> = { [K2 in keyof T]: TPick<AssertType<T[K2]>, K> }
 // prettier-ignore
 export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any> = 
   T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> :
-  T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : 
-  T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : 
+  T extends TIntersect<infer S> ? TIntersect<TPickRest<S, K>> : 
+  T extends TUnion<infer S> ? TUnion<TPickRest<S, K>> : 
   T extends TObject<infer S> ? TObject<TPickProperties<S, K>> :
   T
 // --------------------------------------------------------------------------
@@ -553,8 +608,7 @@ export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any>
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Promise'
   static: Promise<Static<T, this['params']>>
-  type: 'object'
-  instanceOf: 'Promise'
+  type: 'promise'
   item: TSchema
 }
 // --------------------------------------------------------------------------
@@ -606,20 +660,16 @@ export type TReturnType<T extends TFunction> = T['returns']
 // --------------------------------------------------------------------------
 // TRequired
 // --------------------------------------------------------------------------
-export type TRequiredArray<T extends TSchema[]> = AssertRest<{ [K in keyof T]: TRequired<AssertType<T[K]>> }>
+export type TRequiredRest<T extends TSchema[]> = AssertRest<{ [K in keyof T]: TRequired<AssertType<T[K]>> }>
 // prettier-ignore
 export type TRequiredProperties<T extends TProperties> = Evaluate<AssertProperties<{
-  [K in keyof T]: 
-    T[K] extends TReadonlyOptional<infer U> ? TReadonly<U> : 
-    T[K] extends TReadonly<infer U>         ? TReadonly<U> :  
-    T[K] extends TOptional<infer U>         ? U : 
-    T[K]
+  [K in keyof T]: T[K] extends TOptional<infer S> ? S : T[K]
 }>>
 // prettier-ignore
 export type TRequired<T extends TSchema> = 
   T extends TRecursive<infer S> ? TRecursive<TRequired<S>> :   
-  T extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : 
-  T extends TUnion<infer S>     ? TUnion<TRequiredArray<S>> : 
+  T extends TIntersect<infer S> ? TIntersect<TRequiredRest<S>> : 
+  T extends TUnion<infer S>     ? TUnion<TRequiredRest<S>> : 
   T extends TObject<infer S>    ? TObject<TRequiredProperties<S>> : 
   T
 // --------------------------------------------------------------------------
@@ -654,11 +704,17 @@ export type StringContentEncodingOption =
   | 'base64' 
   | ({} & string)
 export interface StringOptions extends SchemaOptions {
-  minLength?: number
+  /** The maximum string length */
   maxLength?: number
+  /** The minimum string length */
+  minLength?: number
+  /** A regular expression pattern this string should match */
   pattern?: string
+  /** A format this string should match */
   format?: StringFormatOption
+  /** The content encoding for this string */
   contentEncoding?: StringContentEncodingOption
+  /** The content media type for this string */
   contentMediaType?: string
 }
 export interface TString extends TSchema, StringOptions {
@@ -673,8 +729,7 @@ export type SymbolValue = string | number | undefined
 export interface TSymbol extends TSchema, SchemaOptions {
   [Kind]: 'Symbol'
   static: symbol
-  type: 'null'
-  typeOf: 'Symbol'
+  type: 'symbol'
 }
 // -------------------------------------------------------------------------
 // TTemplateLiteralParserDsl
@@ -733,7 +788,7 @@ export type TTemplateLiteralConst<T, Acc extends string> =
 export type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string = ''> = 
   T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` :
   Acc
-export type TTemplateLiteralKeyRest<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, Key[]>
+export type TTemplateLiteralKeyRest<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, TPropertyKey[]>
 export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
   [Kind]: 'TemplateLiteral'
   static: TTemplateLiteralUnion<T>
@@ -743,7 +798,6 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
 // --------------------------------------------------------------------------
 // TTuple
 // --------------------------------------------------------------------------
-export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? AssertRest<R> : never
 export type TTupleInfer<T extends TSchema[], P extends unknown[]> = T extends [infer L, ...infer R] ? [Static<AssertType<L>, P>, ...TTupleInfer<AssertRest<R>, P>] : []
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
   [Kind]: 'Tuple'
@@ -760,8 +814,7 @@ export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
 export interface TUndefined extends TSchema {
   [Kind]: 'Undefined'
   static: undefined
-  type: 'null'
-  typeOf: 'Undefined'
+  type: 'undefined'
 }
 // --------------------------------------------------------------------------
 // TUnionLiteral
@@ -794,8 +847,7 @@ export interface Uint8ArrayOptions extends SchemaOptions {
 export interface TUint8Array extends TSchema, Uint8ArrayOptions {
   [Kind]: 'Uint8Array'
   static: Uint8Array
-  instanceOf: 'Uint8Array'
-  type: 'object'
+  type: 'uint8array'
 }
 // --------------------------------------------------------------------------
 // TUnknown
@@ -820,8 +872,7 @@ export interface TUnsafe<T> extends TSchema {
 export interface TVoid extends TSchema {
   [Kind]: 'Void'
   static: void
-  type: 'null'
-  typeOf: 'Void'
+  type: 'void'
 }
 // --------------------------------------------------------------------------
 // Static<T>
@@ -843,6 +894,10 @@ export namespace TypeRegistry {
   export function Clear() {
     return map.clear()
   }
+  /** Deletes a registered type */
+  export function Delete(kind: string) {
+    return map.delete(kind)
+  }
   /** Returns true if this registry contains this kind */
   export function Has(kind: string) {
     return map.has(kind)
@@ -871,6 +926,10 @@ export namespace FormatRegistry {
   export function Clear() {
     return map.clear()
   }
+  /** Deletes a registered format */
+  export function Delete(format: string) {
+    return map.delete(format)
+  }
   /** Returns true if the user defined string format exists */
   export function Has(format: string) {
     return map.has(format)
@@ -885,6 +944,35 @@ export namespace FormatRegistry {
   }
 }
 // --------------------------------------------------------------------------
+// ValueGuard
+// --------------------------------------------------------------------------
+export namespace ValueGuard {
+  export function IsObject(value: unknown): value is Record<PropertyKey, unknown> {
+    return typeof value === 'object' && value !== null
+  }
+  export function IsArray(value: unknown): value is unknown[] {
+    return Array.isArray(value)
+  }
+  export function IsBoolean(value: unknown): value is boolean {
+    return typeof value === 'boolean'
+  }
+  export function IsNull(value: unknown): value is null {
+    return value === null
+  }
+  export function IsUndefined(value: unknown): value is undefined {
+    return value === undefined
+  }
+  export function IsBigInt(value: unknown): value is bigint {
+    return typeof value === 'bigint'
+  }
+  export function IsNumber(value: unknown): value is number {
+    return typeof value === 'number'
+  }
+  export function IsString(value: unknown): value is string {
+    return typeof value === 'string'
+  }
+}
+// --------------------------------------------------------------------------
 // TypeGuard
 // --------------------------------------------------------------------------
 export class TypeGuardUnknownTypeError extends Error {
@@ -894,12 +982,6 @@ export class TypeGuardUnknownTypeError extends Error {
 }
 /** Provides functions to test if JavaScript values are TypeBox types */
 export namespace TypeGuard {
-  function IsObject(value: unknown): value is Record<string | symbol, any> {
-    return typeof value === 'object' && value !== null && !Array.isArray(value)
-  }
-  function IsArray(value: unknown): value is any[] {
-    return typeof value === 'object' && value !== null && Array.isArray(value)
-  }
   function IsPattern(value: unknown): value is string {
     try {
       new RegExp(value as string)
@@ -909,7 +991,7 @@ export namespace TypeGuard {
     }
   }
   function IsControlCharacterFree(value: unknown): value is string {
-    if (typeof value !== 'string') return false
+    if (!ValueGuard.IsString(value)) return false
     for (let i = 0; i < value.length; i++) {
       const code = value.charCodeAt(i)
       if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
@@ -921,64 +1003,66 @@ export namespace TypeGuard {
   function IsAdditionalProperties(value: unknown): value is TAdditionalProperties {
     return IsOptionalBoolean(value) || TSchema(value)
   }
-  function IsBigInt(value: unknown): value is bigint {
-    return typeof value === 'bigint'
-  }
-  function IsString(value: unknown): value is string {
-    return typeof value === 'string'
-  }
-  function IsNumber(value: unknown): value is number {
-    return typeof value === 'number' && globalThis.Number.isFinite(value)
-  }
-  function IsBoolean(value: unknown): value is boolean {
-    return typeof value === 'boolean'
-  }
   function IsOptionalBigInt(value: unknown): value is bigint | undefined {
-    return value === undefined || (value !== undefined && IsBigInt(value))
+    return ValueGuard.IsUndefined(value) || ValueGuard.IsBigInt(value)
   }
   function IsOptionalNumber(value: unknown): value is number | undefined {
-    return value === undefined || (value !== undefined && IsNumber(value))
+    return ValueGuard.IsUndefined(value) || ValueGuard.IsNumber(value)
   }
   function IsOptionalBoolean(value: unknown): value is boolean | undefined {
-    return value === undefined || (value !== undefined && IsBoolean(value))
+    return ValueGuard.IsUndefined(value) || ValueGuard.IsBoolean(value)
   }
   function IsOptionalString(value: unknown): value is string | undefined {
-    return value === undefined || (value !== undefined && IsString(value))
+    return ValueGuard.IsUndefined(value) || ValueGuard.IsString(value)
   }
   function IsOptionalPattern(value: unknown): value is string | undefined {
-    return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value) && IsPattern(value))
+    return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value) && IsPattern(value))
   }
   function IsOptionalFormat(value: unknown): value is string | undefined {
-    return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value))
+    return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value))
   }
   function IsOptionalSchema(value: unknown): value is boolean | undefined {
-    return value === undefined || TSchema(value)
+    return ValueGuard.IsUndefined(value) || TSchema(value)
   }
   /** Returns true if the given schema is TAny */
   export function TAny(schema: unknown): schema is TAny {
-    return TKind(schema) && schema[Kind] === 'Any' && IsOptionalString(schema.$id)
+    // prettier-ignore
+    return (
+      TKindOf(schema, 'Any') &&
+      IsOptionalString(schema.$id)
+    )
   }
   /** Returns true if the given schema is TArray */
   export function TArray(schema: unknown): schema is TArray {
     return (
-      TKind(schema) &&
-      schema[Kind] === 'Array' &&
+      TKindOf(schema, 'Array') &&
       schema.type === 'array' &&
       IsOptionalString(schema.$id) &&
       TSchema(schema.items) &&
       IsOptionalNumber(schema.minItems) &&
       IsOptionalNumber(schema.maxItems) &&
-      IsOptionalBoolean(schema.uniqueItems)
+      IsOptionalBoolean(schema.uniqueItems) &&
+      IsOptionalSchema(schema.contains) &&
+      IsOptionalNumber(schema.minContains) &&
+      IsOptionalNumber(schema.maxContains)
+    )
+  }
+  /** Returns true if the given schema is TAsyncIterator */
+  export function TAsyncIterator(schema: unknown): schema is TAsyncIterator {
+    // prettier-ignore
+    return (
+      TKindOf(schema, 'AsyncIterator') && 
+      schema.type === 'AsyncIterator' &&
+      IsOptionalString(schema.$id) &&
+      TSchema(schema.items)
     )
   }
   /** Returns true if the given schema is TBigInt */
   export function TBigInt(schema: unknown): schema is TBigInt {
     // prettier-ignore
     return (
-      TKind(schema) && 
-      schema[Kind] === 'BigInt' && 
-      schema.type === 'null' &&
-      schema.typeOf === 'BigInt' &&
+      TKindOf(schema, 'BigInt') && 
+      schema.type === 'bigint' &&
       IsOptionalString(schema.$id) &&
       IsOptionalBigInt(schema.multipleOf) &&
       IsOptionalBigInt(schema.minimum) &&
@@ -991,8 +1075,7 @@ export namespace TypeGuard {
   export function TBoolean(schema: unknown): schema is TBoolean {
     // prettier-ignore
     return (
-      TKind(schema) &&
-      schema[Kind] === 'Boolean' && 
+      TKindOf(schema, 'Boolean') && 
       schema.type === 'boolean' && 
       IsOptionalString(schema.$id)
     )
@@ -1001,12 +1084,10 @@ export namespace TypeGuard {
   export function TConstructor(schema: unknown): schema is TConstructor {
     // prettier-ignore
     if (!(
-      TKind(schema) &&
-      schema[Kind] === 'Constructor' && 
-      schema.type === 'object' && 
-      schema.instanceOf === 'Constructor' && 
+      TKindOf(schema, 'Constructor') && 
+      schema.type === 'constructor' &&
       IsOptionalString(schema.$id) && 
-      IsArray(schema.parameters) && 
+      ValueGuard.IsArray(schema.parameters) && 
       TSchema(schema.returns))
     ) {
       return false
@@ -1019,10 +1100,8 @@ export namespace TypeGuard {
   /** Returns true if the given schema is TDate */
   export function TDate(schema: unknown): schema is TDate {
     return (
-      TKind(schema) &&
-      schema[Kind] === 'Date' &&
-      schema.type === 'object' &&
-      schema.instanceOf === 'Date' &&
+      TKindOf(schema, 'Date') &&
+      schema.type === 'Date' &&
       IsOptionalString(schema.$id) &&
       IsOptionalNumber(schema.minimumTimestamp) &&
       IsOptionalNumber(schema.maximumTimestamp) &&
@@ -1034,12 +1113,10 @@ export namespace TypeGuard {
   export function TFunction(schema: unknown): schema is TFunction {
     // prettier-ignore
     if (!(
-      TKind(schema) &&
-      schema[Kind] === 'Function' && 
-      schema.type === 'object' &&
-      schema.instanceOf === 'Function' &&
+      TKindOf(schema, 'Function') &&
+      schema.type === 'function' &&
       IsOptionalString(schema.$id) && 
-      IsArray(schema.parameters) && 
+      ValueGuard.IsArray(schema.parameters) && 
       TSchema(schema.returns))
     ) {
       return false
@@ -1052,8 +1129,7 @@ export namespace TypeGuard {
   /** Returns true if the given schema is TInteger */
   export function TInteger(schema: unknown): schema is TInteger {
     return (
-      TKind(schema) &&
-      schema[Kind] === 'Integer' &&
+      TKindOf(schema, 'Integer') &&
       schema.type === 'integer' &&
       IsOptionalString(schema.$id) &&
       IsOptionalNumber(schema.multipleOf) &&
@@ -1067,9 +1143,8 @@ export namespace TypeGuard {
   export function TIntersect(schema: unknown): schema is TIntersect {
     // prettier-ignore
     if (!(
-      TKind(schema) &&
-      schema[Kind] === 'Intersect' && 
-      IsArray(schema.allOf) && 
+      TKindOf(schema, 'Intersect') &&
+      ValueGuard.IsArray(schema.allOf) && 
       IsOptionalString(schema.type) &&
       (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) &&
       IsOptionalString(schema.$id))
@@ -1084,36 +1159,62 @@ export namespace TypeGuard {
     }
     return true
   }
+  /** Returns true if the given schema is TIterator */
+  export function TIterator(schema: unknown): schema is TIterator {
+    // prettier-ignore
+    return (
+      TKindOf(schema, 'Iterator') &&
+      schema.type === 'Iterator' &&
+      IsOptionalString(schema.$id) &&
+      TSchema(schema.items)
+    )
+  }
+  /** Returns true if the given schema is a TKind with the given name. */
+  export function TKindOf<T extends string>(schema: unknown, kind: T): schema is Record<PropertyKey, unknown> & { [Kind]: T } {
+    return TKind(schema) && schema[Kind] === kind
+  }
   /** Returns true if the given schema is TKind */
-  export function TKind(schema: unknown): schema is Record<typeof Kind | string, unknown> {
-    return IsObject(schema) && Kind in schema && typeof (schema as any)[Kind] === 'string' // TS 4.1.5: any required for symbol indexer
+  export function TKind(schema: unknown): schema is Record<PropertyKey, unknown> & { [Kind]: string } {
+    return ValueGuard.IsObject(schema) && Kind in schema && ValueGuard.IsString(schema[Kind])
   }
   /** Returns true if the given schema is TLiteral<string> */
   export function TLiteralString(schema: unknown): schema is TLiteral<string> {
-    return TKind(schema) && schema[Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'string'
+    return TLiteral(schema) && ValueGuard.IsString(schema.const)
   }
   /** Returns true if the given schema is TLiteral<number> */
   export function TLiteralNumber(schema: unknown): schema is TLiteral<number> {
-    return TKind(schema) && schema[Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'number'
+    return TLiteral(schema) && ValueGuard.IsNumber(schema.const)
   }
   /** Returns true if the given schema is TLiteral<boolean> */
   export function TLiteralBoolean(schema: unknown): schema is TLiteral<boolean> {
-    return TKind(schema) && schema[Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'boolean'
+    return TLiteral(schema) && ValueGuard.IsBoolean(schema.const)
   }
   /** Returns true if the given schema is TLiteral */
   export function TLiteral(schema: unknown): schema is TLiteral {
-    return TLiteralString(schema) || TLiteralNumber(schema) || TLiteralBoolean(schema)
+    // prettier-ignore
+    return (
+      TKindOf(schema, 'Literal') &&
+      IsOptionalString(schema.$id) && (
+        ValueGuard.IsBoolean(schema.const) ||
+        ValueGuard.IsNumber(schema.const) ||
+        ValueGuard.IsString(schema.const)
+      )
+    )
   }
   /** Returns true if the given schema is TNever */
   export function TNever(schema: unknown): schema is TNever {
-    return TKind(schema) && schema[Kind] === 'Never' && IsObject(schema.not) && globalThis.Object.getOwnPropertyNames(schema.not).length === 0
+    // prettier-ignore
+    return (
+      TKindOf(schema, 'Never') &&
+      ValueGuard.IsObject(schema.not) && 
+      Object.getOwnPropertyNames(schema.not).length === 0
+    )
   }
   /** Returns true if the given schema is TNot */
   export function TNot(schema: unknown): schema is TNot {
     // prettier-ignore
     return (
-      TKind(schema) && 
-      schema[Kind] === 'Not' && 
+      TKindOf(schema, 'Not') &&
       TSchema(schema.not) 
     )
   }
@@ -1121,8 +1222,7 @@ export namespace TypeGuard {
   export function TNull(schema: unknown): schema is TNull {
     // prettier-ignore
     return (
-      TKind(schema) && 
-      schema[Kind] === 'Null' && 
+      TKindOf(schema, 'Null') &&
       schema.type === 'null' && 
       IsOptionalString(schema.$id)
     )
@@ -1130,8 +1230,7 @@ export namespace TypeGuard {
   /** Returns true if the given schema is TNumber */
   export function TNumber(schema: unknown): schema is TNumber {
     return (
-      TKind(schema) &&
-      schema[Kind] === 'Number' &&
+      TKindOf(schema, 'Number') &&
       schema.type === 'number' &&
       IsOptionalString(schema.$id) &&
       IsOptionalNumber(schema.multipleOf) &&
@@ -1145,11 +1244,10 @@ export namespace TypeGuard {
   export function TObject(schema: unknown): schema is TObject {
     if (
       !(
-        TKind(schema) &&
-        schema[Kind] === 'Object' &&
+        TKindOf(schema, 'Object') &&
         schema.type === 'object' &&
         IsOptionalString(schema.$id) &&
-        IsObject(schema.properties) &&
+        ValueGuard.IsObject(schema.properties) &&
         IsAdditionalProperties(schema.additionalProperties) &&
         IsOptionalNumber(schema.minProperties) &&
         IsOptionalNumber(schema.maxProperties)
@@ -1167,10 +1265,8 @@ export namespace TypeGuard {
   export function TPromise(schema: unknown): schema is TPromise {
     // prettier-ignore
     return (
-      TKind(schema) && 
-      schema[Kind] === 'Promise' && 
-      schema.type === 'object' && 
-      schema.instanceOf === 'Promise' &&
+      TKindOf(schema, 'Promise') &&
+      schema.type === 'Promise' &&
       IsOptionalString(schema.$id) && 
       TSchema(schema.item)
     )
@@ -1179,16 +1275,15 @@ export namespace TypeGuard {
   export function TRecord(schema: unknown): schema is TRecord {
     // prettier-ignore
     if (!(
-      TKind(schema) && 
-      schema[Kind] === 'Record' && 
+      TKindOf(schema, 'Record') &&
       schema.type === 'object' && 
       IsOptionalString(schema.$id) && 
       IsAdditionalProperties(schema.additionalProperties) &&
-      IsObject(schema.patternProperties))
+      ValueGuard.IsObject(schema.patternProperties))
     ) {
       return false
     }
-    const keys = Object.keys(schema.patternProperties)
+    const keys = Object.getOwnPropertyNames(schema.patternProperties)
     if (keys.length !== 1) {
       return false
     }
@@ -1204,33 +1299,23 @@ export namespace TypeGuard {
   export function TRef(schema: unknown): schema is TRef {
     // prettier-ignore
     return (
-      TKind(schema) && 
-      schema[Kind] === 'Ref' && 
+      TKindOf(schema, 'Ref') &&
       IsOptionalString(schema.$id) && 
-      IsString(schema.$ref)
+      ValueGuard.IsString(schema.$ref)
     )
   }
   /** Returns true if the given schema is TString */
   export function TString(schema: unknown): schema is TString {
     return (
-      TKind(schema) &&
-      schema[Kind] === 'String' &&
-      schema.type === 'string' &&
-      IsOptionalString(schema.$id) &&
-      IsOptionalNumber(schema.minLength) &&
-      IsOptionalNumber(schema.maxLength) &&
-      IsOptionalPattern(schema.pattern) &&
-      IsOptionalFormat(schema.format)
+      TKindOf(schema, 'String') && schema.type === 'string' && IsOptionalString(schema.$id) && IsOptionalNumber(schema.minLength) && IsOptionalNumber(schema.maxLength) && IsOptionalPattern(schema.pattern) && IsOptionalFormat(schema.format)
     )
   }
   /** Returns true if the given schema is TSymbol */
   export function TSymbol(schema: unknown): schema is TSymbol {
     // prettier-ignore
     return (
-      TKind(schema) && 
-      schema[Kind] === 'Symbol' && 
-      schema.type === 'null' &&
-      schema.typeOf === 'Symbol' &&
+      TKindOf(schema, 'Symbol') &&
+      schema.type === 'symbol' &&
       IsOptionalString(schema.$id)
     )
   }
@@ -1238,10 +1323,9 @@ export namespace TypeGuard {
   export function TTemplateLiteral(schema: unknown): schema is TTemplateLiteral {
     // prettier-ignore
     return (
-      TKind(schema) && 
-      schema[Kind] === 'TemplateLiteral' && 
+      TKindOf(schema, 'TemplateLiteral') &&
       schema.type === 'string' &&
-      IsString(schema.pattern) &&
+      ValueGuard.IsString(schema.pattern) &&
       schema.pattern[0] === '^' &&
       schema.pattern[schema.pattern.length - 1] === '$'
     )
@@ -1250,30 +1334,28 @@ export namespace TypeGuard {
   export function TThis(schema: unknown): schema is TThis {
     // prettier-ignore
     return (
-      TKind(schema) && 
-      schema[Kind] === 'This' && 
+      TKindOf(schema, 'This') &&
       IsOptionalString(schema.$id) && 
-      IsString(schema.$ref)
+      ValueGuard.IsString(schema.$ref)
     )
   }
   /** Returns true if the given schema is TTuple */
   export function TTuple(schema: unknown): schema is TTuple {
     // prettier-ignore
     if (!(
-      TKind(schema) && 
-      schema[Kind] === 'Tuple' && 
+      TKindOf(schema, 'Tuple') &&
       schema.type === 'array' && 
       IsOptionalString(schema.$id) && 
-      IsNumber(schema.minItems) && 
-      IsNumber(schema.maxItems) && 
+      ValueGuard.IsNumber(schema.minItems) && 
+      ValueGuard.IsNumber(schema.maxItems) && 
       schema.minItems === schema.maxItems)
     ) {
       return false
     }
-    if (schema.items === undefined && schema.additionalItems === undefined && schema.minItems === 0) {
+    if (ValueGuard.IsUndefined(schema.items) && ValueGuard.IsUndefined(schema.additionalItems) && schema.minItems === 0) {
       return true
     }
-    if (!IsArray(schema.items)) {
+    if (!ValueGuard.IsArray(schema.items)) {
       return false
     }
     for (const inner of schema.items) {
@@ -1285,10 +1367,8 @@ export namespace TypeGuard {
   export function TUndefined(schema: unknown): schema is TUndefined {
     // prettier-ignore
     return (
-      TKind(schema) && 
-      schema[Kind] === 'Undefined' && 
-      schema.type === 'null' && 
-      schema.typeOf === 'Undefined' && 
+      TKindOf(schema, 'Undefined') &&
+      schema.type === 'undefined' &&
       IsOptionalString(schema.$id)
     )
   }
@@ -1300,9 +1380,8 @@ export namespace TypeGuard {
   export function TUnion(schema: unknown): schema is TUnion {
     // prettier-ignore
     if (!(
-      TKind(schema) && 
-      schema[Kind] === 'Union' && 
-      IsArray(schema.anyOf) && 
+      TKindOf(schema, 'Union') &&
+      ValueGuard.IsArray(schema.anyOf) && 
       IsOptionalString(schema.$id))
     ) {
       return false
@@ -1314,61 +1393,59 @@ export namespace TypeGuard {
   }
   /** Returns true if the given schema is TUint8Array */
   export function TUint8Array(schema: unknown): schema is TUint8Array {
-    return TKind(schema) && schema[Kind] === 'Uint8Array' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.instanceOf === 'Uint8Array' && IsOptionalNumber(schema.minByteLength) && IsOptionalNumber(schema.maxByteLength)
+    // prettier-ignore
+    return (
+      TKindOf(schema, 'Uint8Array') &&
+      schema.type === 'Uint8Array' && 
+      IsOptionalString(schema.$id) && 
+      IsOptionalNumber(schema.minByteLength) && 
+      IsOptionalNumber(schema.maxByteLength)
+    )
   }
   /** Returns true if the given schema is TUnknown */
   export function TUnknown(schema: unknown): schema is TUnknown {
     // prettier-ignore
     return (
-      TKind(schema) && 
-      schema[Kind] === 'Unknown' && 
+      TKindOf(schema, 'Unknown') &&
       IsOptionalString(schema.$id)
     )
   }
   /** Returns true if the given schema is a raw TUnsafe */
   export function TUnsafe(schema: unknown): schema is TUnsafe<unknown> {
-    // prettier-ignore
-    return (
-      TKind(schema) && 
-      schema[Kind] === 'Unsafe'
-    )
+    return TKindOf(schema, 'Unsafe')
   }
   /** Returns true if the given schema is TVoid */
   export function TVoid(schema: unknown): schema is TVoid {
     // prettier-ignore
     return (
-      TKind(schema) && 
-      schema[Kind] === 'Void' && 
-      schema.type === 'null' && 
-      schema.typeOf === 'Void' && 
+      TKindOf(schema, 'Void') &&
+      schema.type === 'void' &&
       IsOptionalString(schema.$id)
     )
   }
-  /** Returns true if this schema has the ReadonlyOptional modifier */
-  export function TReadonlyOptional<T extends TSchema>(schema: T): schema is TReadonlyOptional<T> {
-    return IsObject(schema) && schema[Modifier] === 'ReadonlyOptional'
-  }
   /** Returns true if this schema has the Readonly modifier */
   export function TReadonly<T extends TSchema>(schema: T): schema is TReadonly<T> {
-    return IsObject(schema) && schema[Modifier] === 'Readonly'
+    return ValueGuard.IsObject(schema) && schema[Readonly] === 'Readonly'
   }
   /** Returns true if this schema has the Optional modifier */
   export function TOptional<T extends TSchema>(schema: T): schema is TOptional<T> {
-    return IsObject(schema) && schema[Modifier] === 'Optional'
+    return ValueGuard.IsObject(schema) && schema[Optional] === 'Optional'
   }
   /** Returns true if the given schema is TSchema */
   export function TSchema(schema: unknown): schema is TSchema {
     return (
-      typeof schema === 'object' &&
+      ValueGuard.IsObject(schema) &&
       (TAny(schema) ||
         TArray(schema) ||
         TBoolean(schema) ||
         TBigInt(schema) ||
+        TAsyncIterator(schema) ||
         TConstructor(schema) ||
         TDate(schema) ||
         TFunction(schema) ||
         TInteger(schema) ||
         TIntersect(schema) ||
+        TIterator(schema) ||
         TLiteral(schema) ||
         TNever(schema) ||
         TNot(schema) ||
@@ -1430,13 +1507,34 @@ export namespace TypeExtends {
     return result === TypeExtendsResult.False ? TypeExtendsResult.False : TypeExtendsResult.True
   }
   // --------------------------------------------------------------------------
+  // StructuralRight
+  // --------------------------------------------------------------------------
+  function IsStructuralRight(right: TSchema): boolean {
+    // prettier-ignore
+    return (
+      TypeGuard.TNever(right) || 
+      TypeGuard.TIntersect(right) || 
+      TypeGuard.TUnion(right) || 
+      TypeGuard.TUnknown(right) || 
+      TypeGuard.TAny(right)
+    )
+  }
+  function StructuralRight(left: TSchema, right: TSchema) {
+    if (TypeGuard.TNever(right)) return TNeverRight(left, right)
+    if (TypeGuard.TIntersect(right)) return TIntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return TUnionRight(left, right)
+    if (TypeGuard.TUnknown(right)) return TUnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return TAnyRight(left, right)
+    throw Error('TypeExtends: StructuralRight')
+  }
+  // --------------------------------------------------------------------------
   // Any
   // --------------------------------------------------------------------------
-  function AnyRight(left: TSchema, right: TAny) {
+  function TAnyRight(left: TSchema, right: TAny) {
     return TypeExtendsResult.True
   }
-  function Any(left: TAny, right: TSchema) {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
+  function TAny(left: TAny, right: TSchema) {
+    if (TypeGuard.TIntersect(right)) return TIntersectRight(left, right)
     if (TypeGuard.TUnion(right) && right.anyOf.some((schema) => TypeGuard.TAny(schema) || TypeGuard.TUnknown(schema))) return TypeExtendsResult.True
     if (TypeGuard.TUnion(right)) return TypeExtendsResult.Union
     if (TypeGuard.TUnknown(right)) return TypeExtendsResult.True
@@ -1446,60 +1544,54 @@ export namespace TypeExtends {
   // --------------------------------------------------------------------------
   // Array
   // --------------------------------------------------------------------------
-  function ArrayRight(left: TSchema, right: TArray) {
+  function TArrayRight(left: TSchema, right: TArray) {
     if (TypeGuard.TUnknown(left)) return TypeExtendsResult.False
     if (TypeGuard.TAny(left)) return TypeExtendsResult.Union
     if (TypeGuard.TNever(left)) return TypeExtendsResult.True
     return TypeExtendsResult.False
   }
-  function Array(left: TArray, right: TSchema) {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+  function TArray(left: TArray, right: TSchema) {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
     if (TypeGuard.TObject(right) && IsObjectArrayLike(right)) return TypeExtendsResult.True
     if (!TypeGuard.TArray(right)) return TypeExtendsResult.False
     return IntoBooleanResult(Visit(left.items, right.items))
   }
   // --------------------------------------------------------------------------
+  // AsyncIterator
+  // --------------------------------------------------------------------------
+  function TAsyncIterator(left: TAsyncIterator, right: TSchema) {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (!TypeGuard.TAsyncIterator(right)) return TypeExtendsResult.False
+    return IntoBooleanResult(Visit(left.items, right.items))
+  }
+  // --------------------------------------------------------------------------
   // BigInt
   // --------------------------------------------------------------------------
-  function BigInt(left: TBigInt, right: TSchema): TypeExtendsResult {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TNever(right)) return NeverRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+  function TBigInt(left: TBigInt, right: TSchema): TypeExtendsResult {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
     return TypeGuard.TBigInt(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
   // Boolean
   // --------------------------------------------------------------------------
-  function BooleanRight(left: TSchema, right: TBoolean) {
-    if (TypeGuard.TLiteral(left) && typeof left.const === 'boolean') return TypeExtendsResult.True
+  function TBooleanRight(left: TSchema, right: TBoolean) {
+    if (TypeGuard.TLiteral(left) && ValueGuard.IsBoolean(left.const)) return TypeExtendsResult.True
     return TypeGuard.TBoolean(left) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
-  function Boolean(left: TBoolean, right: TSchema): TypeExtendsResult {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TNever(right)) return NeverRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+  function TBoolean(left: TBoolean, right: TSchema): TypeExtendsResult {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
     return TypeGuard.TBoolean(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
   // Constructor
   // --------------------------------------------------------------------------
-  function Constructor(left: TConstructor, right: TSchema) {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+  function TConstructor(left: TConstructor, right: TSchema) {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
     if (!TypeGuard.TConstructor(right)) return TypeExtendsResult.False
     if (left.parameters.length > right.parameters.length) return TypeExtendsResult.False
     if (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) {
@@ -1510,24 +1602,18 @@ export namespace TypeExtends {
   // --------------------------------------------------------------------------
   // Date
   // --------------------------------------------------------------------------
-  function Date(left: TDate, right: TSchema) {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+  function TDate(left: TDate, right: TSchema) {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
     return TypeGuard.TDate(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
   // Function
   // --------------------------------------------------------------------------
-  function Function(left: TFunction, right: TSchema) {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+  function TFunction(left: TFunction, right: TSchema) {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
     if (!TypeGuard.TFunction(right)) return TypeExtendsResult.False
     if (left.parameters.length > right.parameters.length) return TypeExtendsResult.False
     if (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) {
@@ -1538,68 +1624,59 @@ export namespace TypeExtends {
   // --------------------------------------------------------------------------
   // Integer
   // --------------------------------------------------------------------------
-  function IntegerRight(left: TSchema, right: TInteger) {
-    if (TypeGuard.TLiteral(left) && typeof left.const === 'number') return TypeExtendsResult.True
+  function TIntegerRight(left: TSchema, right: TInteger) {
+    if (TypeGuard.TLiteral(left) && ValueGuard.IsNumber(left.const)) return TypeExtendsResult.True
     return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
-  function Integer(left: TInteger, right: TSchema): TypeExtendsResult {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TNever(right)) return NeverRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+  function TInteger(left: TInteger, right: TSchema): TypeExtendsResult {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
     return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
   // Intersect
   // --------------------------------------------------------------------------
-  function IntersectRight(left: TSchema, right: TIntersect): TypeExtendsResult {
+  function TIntersectRight(left: TSchema, right: TIntersect): TypeExtendsResult {
     return right.allOf.every((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
-  function Intersect(left: TIntersect, right: TSchema) {
+  function TIntersect(left: TIntersect, right: TSchema) {
     return left.allOf.some((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
+  // Iterator
+  // --------------------------------------------------------------------------
+  function TIterator(left: TIterator, right: TSchema) {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (!TypeGuard.TIterator(right)) return TypeExtendsResult.False
+    return IntoBooleanResult(Visit(left.items, right.items))
+  }
+  // --------------------------------------------------------------------------
   // Literal
   // --------------------------------------------------------------------------
-  function IsLiteralString(schema: TLiteral) {
-    return typeof schema.const === 'string'
-  }
-  function IsLiteralNumber(schema: TLiteral) {
-    return typeof schema.const === 'number'
-  }
-  function IsLiteralBoolean(schema: TLiteral) {
-    return typeof schema.const === 'boolean'
-  }
-  function Literal(left: TLiteral, right: TSchema): TypeExtendsResult {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TNever(right)) return NeverRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
-    if (TypeGuard.TString(right)) return StringRight(left, right)
-    if (TypeGuard.TNumber(right)) return NumberRight(left, right)
-    if (TypeGuard.TInteger(right)) return IntegerRight(left, right)
-    if (TypeGuard.TBoolean(right)) return BooleanRight(left, right)
+  function TLiteral(left: TLiteral, right: TSchema): TypeExtendsResult {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
+    if (TypeGuard.TString(right)) return TStringRight(left, right)
+    if (TypeGuard.TNumber(right)) return TNumberRight(left, right)
+    if (TypeGuard.TInteger(right)) return TIntegerRight(left, right)
+    if (TypeGuard.TBoolean(right)) return TBooleanRight(left, right)
     return TypeGuard.TLiteral(right) && right.const === left.const ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
   // Never
   // --------------------------------------------------------------------------
-  function NeverRight(left: TSchema, right: TNever) {
+  function TNeverRight(left: TSchema, right: TNever) {
     return TypeExtendsResult.False
   }
-  function Never(left: TNever, right: TSchema) {
+  function TNever(left: TNever, right: TSchema) {
     return TypeExtendsResult.True
   }
   // --------------------------------------------------------------------------
   // Not
   // --------------------------------------------------------------------------
-  function UnwrapNot<T extends TNot>(schema: T): TUnknown | TNot['not'] {
+  function UnwrapTNot<T extends TNot>(schema: T): TUnknown | TNot['not'] {
     let [current, depth]: [TSchema, number] = [schema, 0]
     while (true) {
       if (!TypeGuard.TNot(current)) break
@@ -1608,49 +1685,41 @@ export namespace TypeExtends {
     }
     return depth % 2 === 0 ? current : Type.Unknown()
   }
-  function Not(left: TSchema, right: TSchema) {
+  function TNot(left: TSchema, right: TSchema) {
     // TypeScript has no concept of negated types, and attempts to correctly check the negated
     // type at runtime would put TypeBox at odds with TypeScripts ability to statically infer
     // the type. Instead we unwrap to either unknown or T and continue evaluating.
-    if (TypeGuard.TNot(left)) return Visit(UnwrapNot(left), right)
-    if (TypeGuard.TNot(right)) return Visit(left, UnwrapNot(right))
+    if (TypeGuard.TNot(left)) return Visit(UnwrapTNot(left), right)
+    if (TypeGuard.TNot(right)) return Visit(left, UnwrapTNot(right))
     throw new Error(`TypeExtends: Invalid fallthrough for Not`)
   }
   // --------------------------------------------------------------------------
   // Null
   // --------------------------------------------------------------------------
-  function Null(left: TNull, right: TSchema) {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TNever(right)) return NeverRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+  function TNull(left: TNull, right: TSchema) {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
     return TypeGuard.TNull(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
   // Number
   // --------------------------------------------------------------------------
-  function NumberRight(left: TSchema, right: TNumber) {
-    if (TypeGuard.TLiteral(left) && IsLiteralNumber(left)) return TypeExtendsResult.True
+  function TNumberRight(left: TSchema, right: TNumber) {
+    if (TypeGuard.TLiteralNumber(left)) return TypeExtendsResult.True
     return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
-  function Number(left: TNumber, right: TSchema): TypeExtendsResult {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TNever(right)) return NeverRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+  function TNumber(left: TNumber, right: TSchema): TypeExtendsResult {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
     return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
   // Object
   // --------------------------------------------------------------------------
   function IsObjectPropertyCount(schema: TObject, count: number) {
-    return globalThis.Object.keys(schema.properties).length === count
+    return Object.getOwnPropertyNames(schema.properties).length === count
   }
   function IsObjectStringLike(schema: TObject) {
     return IsObjectArrayLike(schema)
@@ -1705,13 +1774,13 @@ export namespace TypeExtends {
     if (TypeGuard.TOptional(left) && !TypeGuard.TOptional(right)) return TypeExtendsResult.False
     return TypeExtendsResult.True
   }
-  function ObjectRight(left: TSchema, right: TObject) {
+  function TObjectRight(left: TSchema, right: TObject) {
     if (TypeGuard.TUnknown(left)) return TypeExtendsResult.False
     if (TypeGuard.TAny(left)) return TypeExtendsResult.Union
     if (TypeGuard.TNever(left)) return TypeExtendsResult.True
-    if (TypeGuard.TLiteral(left) && IsLiteralString(left) && IsObjectStringLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TLiteral(left) && IsLiteralNumber(left) && IsObjectNumberLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TLiteral(left) && IsLiteralBoolean(left) && IsObjectBooleanLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TLiteralString(left) && IsObjectStringLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TLiteralNumber(left) && IsObjectNumberLike(right)) return TypeExtendsResult.True
+    if (TypeGuard.TLiteralBoolean(left) && IsObjectBooleanLike(right)) return TypeExtendsResult.True
     if (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right)) return TypeExtendsResult.True
     if (TypeGuard.TBigInt(left) && IsObjectBigIntLike(right)) return TypeExtendsResult.True
     if (TypeGuard.TString(left) && IsObjectStringLike(right)) return TypeExtendsResult.True
@@ -1733,14 +1802,11 @@ export namespace TypeExtends {
     }
     return TypeExtendsResult.False
   }
-  function Object(left: TObject, right: TSchema) {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+  function TObject(left: TObject, right: TSchema) {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
     if (!TypeGuard.TObject(right)) return TypeExtendsResult.False
-    for (const key of globalThis.Object.keys(right.properties)) {
+    for (const key of Object.getOwnPropertyNames(right.properties)) {
       if (!(key in left.properties)) return TypeExtendsResult.False
       if (Property(left.properties[key], right.properties[key]) === TypeExtendsResult.False) {
         return TypeExtendsResult.False
@@ -1751,11 +1817,8 @@ export namespace TypeExtends {
   // --------------------------------------------------------------------------
   // Promise
   // --------------------------------------------------------------------------
-  function Promise(left: TPromise, right: TSchema) {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+  function TPromise(left: TPromise, right: TSchema) {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
     if (TypeGuard.TObject(right) && IsObjectPromiseLike(right)) return TypeExtendsResult.True
     if (!TypeGuard.TPromise(right)) return TypeExtendsResult.False
     return IntoBooleanResult(Visit(left.item, right.item))
@@ -1773,15 +1836,15 @@ export namespace TypeExtends {
     if (PatternStringExact in schema.patternProperties) return schema.patternProperties[PatternStringExact]
     throw Error('TypeExtends: Cannot get record value')
   }
-  function RecordRight(left: TSchema, right: TRecord) {
+  function TRecordRight(left: TSchema, right: TRecord) {
     const Key = RecordKey(right)
     const Value = RecordValue(right)
-    if (TypeGuard.TLiteral(left) && IsLiteralString(left) && TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === TypeExtendsResult.True) return TypeExtendsResult.True
+    if (TypeGuard.TLiteralString(left) && TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === TypeExtendsResult.True) return TypeExtendsResult.True
     if (TypeGuard.TUint8Array(left) && TypeGuard.TNumber(Key)) return Visit(left, Value)
     if (TypeGuard.TString(left) && TypeGuard.TNumber(Key)) return Visit(left, Value)
     if (TypeGuard.TArray(left) && TypeGuard.TNumber(Key)) return Visit(left, Value)
     if (TypeGuard.TObject(left)) {
-      for (const key of globalThis.Object.keys(left.properties)) {
+      for (const key of Object.getOwnPropertyNames(left.properties)) {
         if (Property(Value, left.properties[key]) === TypeExtendsResult.False) {
           return TypeExtendsResult.False
         }
@@ -1790,50 +1853,39 @@ export namespace TypeExtends {
     }
     return TypeExtendsResult.False
   }
-  function Record(left: TRecord, right: TSchema) {
+  function TRecord(left: TRecord, right: TSchema) {
     const Value = RecordValue(left)
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
     if (!TypeGuard.TRecord(right)) return TypeExtendsResult.False
     return Visit(Value, RecordValue(right))
   }
   // --------------------------------------------------------------------------
   // String
   // --------------------------------------------------------------------------
-  function StringRight(left: TSchema, right: TString) {
-    if (TypeGuard.TLiteral(left) && typeof left.const === 'string') return TypeExtendsResult.True
+  function TStringRight(left: TSchema, right: TString) {
+    if (TypeGuard.TLiteral(left) && ValueGuard.IsString(left.const)) return TypeExtendsResult.True
     return TypeGuard.TString(left) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
-  function String(left: TString, right: TSchema): TypeExtendsResult {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TNever(right)) return NeverRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+  function TString(left: TString, right: TSchema): TypeExtendsResult {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
     return TypeGuard.TString(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
   // Symbol
   // --------------------------------------------------------------------------
-  function Symbol(left: TSymbol, right: TSchema): TypeExtendsResult {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TNever(right)) return NeverRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+  function TSymbol(left: TSymbol, right: TSchema): TypeExtendsResult {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
     return TypeGuard.TSymbol(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
   // TemplateLiteral
   // --------------------------------------------------------------------------
-  function TemplateLiteral(left: TSchema, right: TSchema) {
+  function TTemplateLiteral(left: TSchema, right: TSchema) {
     // TemplateLiteral types are resolved to either unions for finite expressions or string
     // for infinite expressions. Here we call to TemplateLiteralResolver to resolve for
     // either type and continue evaluating.
@@ -1844,79 +1896,75 @@ export namespace TypeExtends {
   // --------------------------------------------------------------------------
   // Tuple
   // --------------------------------------------------------------------------
-  function TupleRight(left: TSchema, right: TTuple) {
+  function IsArrayOfTuple(left: TTuple, right: TSchema) {
+    // prettier-ignore
+    return (
+      TypeGuard.TArray(right) && 
+      left.items !== undefined && 
+      left.items.every((schema) => Visit(schema, right.items) === TypeExtendsResult.True)
+    )
+  }
+  function TTupleRight(left: TSchema, right: TTuple) {
+    if (TypeGuard.TNever(left)) return TypeExtendsResult.True
     if (TypeGuard.TUnknown(left)) return TypeExtendsResult.False
     if (TypeGuard.TAny(left)) return TypeExtendsResult.Union
-    if (TypeGuard.TNever(left)) return TypeExtendsResult.True
     return TypeExtendsResult.False
   }
-  function IsArrayOfTuple(left: TTuple, right: TSchema) {
-    return TypeGuard.TArray(right) && left.items !== undefined && left.items.every((schema) => Visit(schema, right.items) === TypeExtendsResult.True)
-  }
-  function Tuple(left: TTuple, right: TSchema): TypeExtendsResult {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
+  function TTuple(left: TTuple, right: TSchema): TypeExtendsResult {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
     if (TypeGuard.TObject(right) && IsObjectArrayLike(right)) return TypeExtendsResult.True
     if (TypeGuard.TArray(right) && IsArrayOfTuple(left, right)) return TypeExtendsResult.True
     if (!TypeGuard.TTuple(right)) return TypeExtendsResult.False
-    if ((left.items === undefined && right.items !== undefined) || (left.items !== undefined && right.items === undefined)) return TypeExtendsResult.False
-    if (left.items === undefined && right.items === undefined) return TypeExtendsResult.True
+    if ((ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items)) || (!ValueGuard.IsUndefined(left.items) && ValueGuard.IsUndefined(right.items))) return TypeExtendsResult.False
+    if (ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items)) return TypeExtendsResult.True
     return left.items!.every((schema, index) => Visit(schema, right.items![index]) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
   // Uint8Array
   // --------------------------------------------------------------------------
-  function Uint8Array(left: TUint8Array, right: TSchema) {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+  function TUint8Array(left: TUint8Array, right: TSchema) {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
     return TypeGuard.TUint8Array(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
   // Undefined
   // --------------------------------------------------------------------------
-  function Undefined(left: TUndefined, right: TSchema) {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TNever(right)) return NeverRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return RecordRight(left, right)
+  function TUndefined(left: TUndefined, right: TSchema) {
+    if (IsStructuralRight(right)) return StructuralRight(left, right)
+    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
+    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
     if (TypeGuard.TVoid(right)) return VoidRight(left, right)
     return TypeGuard.TUndefined(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
   // Union
   // --------------------------------------------------------------------------
-  function UnionRight(left: TSchema, right: TUnion): TypeExtendsResult {
+  function TUnionRight(left: TSchema, right: TUnion): TypeExtendsResult {
     return right.anyOf.some((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
-  function Union(left: TUnion, right: TSchema): TypeExtendsResult {
+  function TUnion(left: TUnion, right: TSchema): TypeExtendsResult {
     return left.anyOf.every((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
   // Unknown
   // --------------------------------------------------------------------------
-  function UnknownRight(left: TSchema, right: TUnknown) {
+  function TUnknownRight(left: TSchema, right: TUnknown) {
     return TypeExtendsResult.True
   }
-  function Unknown(left: TUnknown, right: TSchema) {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TString(right)) return StringRight(left, right)
-    if (TypeGuard.TNumber(right)) return NumberRight(left, right)
-    if (TypeGuard.TInteger(right)) return IntegerRight(left, right)
-    if (TypeGuard.TBoolean(right)) return BooleanRight(left, right)
-    if (TypeGuard.TArray(right)) return ArrayRight(left, right)
-    if (TypeGuard.TTuple(right)) return TupleRight(left, right)
-    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+  function TUnknown(left: TUnknown, right: TSchema) {
+    if (TypeGuard.TNever(right)) return TNeverRight(left, right)
+    if (TypeGuard.TIntersect(right)) return TIntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return TUnionRight(left, right)
+    if (TypeGuard.TAny(right)) return TAnyRight(left, right)
+    if (TypeGuard.TString(right)) return TStringRight(left, right)
+    if (TypeGuard.TNumber(right)) return TNumberRight(left, right)
+    if (TypeGuard.TInteger(right)) return TIntegerRight(left, right)
+    if (TypeGuard.TBoolean(right)) return TBooleanRight(left, right)
+    if (TypeGuard.TArray(right)) return TArrayRight(left, right)
+    if (TypeGuard.TTuple(right)) return TTupleRight(left, right)
+    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
     return TypeGuard.TUnknown(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
@@ -1926,43 +1974,45 @@ export namespace TypeExtends {
     if (TypeGuard.TUndefined(left)) return TypeExtendsResult.True
     return TypeGuard.TUndefined(left) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
-  function Void(left: TVoid, right: TSchema) {
-    if (TypeGuard.TIntersect(right)) return IntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return UnionRight(left, right)
-    if (TypeGuard.TUnknown(right)) return UnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return AnyRight(left, right)
-    if (TypeGuard.TObject(right)) return ObjectRight(left, right)
+  function TVoid(left: TVoid, right: TSchema) {
+    if (TypeGuard.TIntersect(right)) return TIntersectRight(left, right)
+    if (TypeGuard.TUnion(right)) return TUnionRight(left, right)
+    if (TypeGuard.TUnknown(right)) return TUnknownRight(left, right)
+    if (TypeGuard.TAny(right)) return TAnyRight(left, right)
+    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
     return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   function Visit(left: TSchema, right: TSchema): TypeExtendsResult {
     // Resolvable Types
-    if (TypeGuard.TTemplateLiteral(left) || TypeGuard.TTemplateLiteral(right)) return TemplateLiteral(left, right)
-    if (TypeGuard.TNot(left) || TypeGuard.TNot(right)) return Not(left, right)
+    if (TypeGuard.TTemplateLiteral(left) || TypeGuard.TTemplateLiteral(right)) return TTemplateLiteral(left, right)
+    if (TypeGuard.TNot(left) || TypeGuard.TNot(right)) return TNot(left, right)
     // Standard Types
-    if (TypeGuard.TAny(left)) return Any(left, right)
-    if (TypeGuard.TArray(left)) return Array(left, right)
-    if (TypeGuard.TBigInt(left)) return BigInt(left, right)
-    if (TypeGuard.TBoolean(left)) return Boolean(left, right)
-    if (TypeGuard.TConstructor(left)) return Constructor(left, right)
-    if (TypeGuard.TDate(left)) return Date(left, right)
-    if (TypeGuard.TFunction(left)) return Function(left, right)
-    if (TypeGuard.TInteger(left)) return Integer(left, right)
-    if (TypeGuard.TIntersect(left)) return Intersect(left, right)
-    if (TypeGuard.TLiteral(left)) return Literal(left, right)
-    if (TypeGuard.TNever(left)) return Never(left, right)
-    if (TypeGuard.TNull(left)) return Null(left, right)
-    if (TypeGuard.TNumber(left)) return Number(left, right)
-    if (TypeGuard.TObject(left)) return Object(left, right)
-    if (TypeGuard.TRecord(left)) return Record(left, right)
-    if (TypeGuard.TString(left)) return String(left, right)
-    if (TypeGuard.TSymbol(left)) return Symbol(left, right)
-    if (TypeGuard.TTuple(left)) return Tuple(left, right)
-    if (TypeGuard.TPromise(left)) return Promise(left, right)
-    if (TypeGuard.TUint8Array(left)) return Uint8Array(left, right)
-    if (TypeGuard.TUndefined(left)) return Undefined(left, right)
-    if (TypeGuard.TUnion(left)) return Union(left, right)
-    if (TypeGuard.TUnknown(left)) return Unknown(left, right)
-    if (TypeGuard.TVoid(left)) return Void(left, right)
+    if (TypeGuard.TAny(left)) return TAny(left, right)
+    if (TypeGuard.TArray(left)) return TArray(left, right)
+    if (TypeGuard.TBigInt(left)) return TBigInt(left, right)
+    if (TypeGuard.TBoolean(left)) return TBoolean(left, right)
+    if (TypeGuard.TAsyncIterator(left)) return TAsyncIterator(left, right)
+    if (TypeGuard.TConstructor(left)) return TConstructor(left, right)
+    if (TypeGuard.TDate(left)) return TDate(left, right)
+    if (TypeGuard.TFunction(left)) return TFunction(left, right)
+    if (TypeGuard.TInteger(left)) return TInteger(left, right)
+    if (TypeGuard.TIntersect(left)) return TIntersect(left, right)
+    if (TypeGuard.TIterator(left)) return TIterator(left, right)
+    if (TypeGuard.TLiteral(left)) return TLiteral(left, right)
+    if (TypeGuard.TNever(left)) return TNever(left, right)
+    if (TypeGuard.TNull(left)) return TNull(left, right)
+    if (TypeGuard.TNumber(left)) return TNumber(left, right)
+    if (TypeGuard.TObject(left)) return TObject(left, right)
+    if (TypeGuard.TRecord(left)) return TRecord(left, right)
+    if (TypeGuard.TString(left)) return TString(left, right)
+    if (TypeGuard.TSymbol(left)) return TSymbol(left, right)
+    if (TypeGuard.TTuple(left)) return TTuple(left, right)
+    if (TypeGuard.TPromise(left)) return TPromise(left, right)
+    if (TypeGuard.TUint8Array(left)) return TUint8Array(left, right)
+    if (TypeGuard.TUndefined(left)) return TUndefined(left, right)
+    if (TypeGuard.TUnion(left)) return TUnion(left, right)
+    if (TypeGuard.TUnknown(left)) return TUnknown(left, right)
+    if (TypeGuard.TVoid(left)) return TVoid(left, right)
     throw Error(`TypeExtends: Unknown left type operand '${left[Kind]}'`)
   }
   export function Extends(left: TSchema, right: TSchema): TypeExtendsResult {
@@ -1974,31 +2024,21 @@ export namespace TypeExtends {
 // --------------------------------------------------------------------------
 /** Specialized Clone for Types */
 export namespace TypeClone {
-  function IsObject(value: unknown): value is Record<string | symbol, any> {
-    return typeof value === 'object' && value !== null
-  }
-  function IsArray(value: unknown): value is unknown[] {
-    return globalThis.Array.isArray(value)
+  function ObjectType(value: Record<keyof any, unknown>) {
+    const clonedProperties = Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {})
+    const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key as any]) }), {})
+    return { ...clonedProperties, ...clonedSymbols }
   }
-  function Array(value: unknown[]) {
+  function ArrayType(value: unknown[]) {
     return (value as any).map((value: unknown) => Visit(value as any))
   }
-  function Object(value: Record<keyof any, unknown>) {
-    const clonedProperties = globalThis.Object.getOwnPropertyNames(value).reduce((acc, key) => {
-      return { ...acc, [key]: Visit(value[key]) }
-    }, {})
-    const clonedSymbols = globalThis.Object.getOwnPropertySymbols(value).reduce((acc, key) => {
-      return { ...acc, [key]: Visit(value[key as any]) }
-    }, {})
-    return { ...clonedProperties, ...clonedSymbols }
-  }
   function Visit(value: unknown): any {
-    if (IsArray(value)) return Array(value)
-    if (IsObject(value)) return Object(value)
+    if (ValueGuard.IsArray(value)) return ArrayType(value)
+    if (ValueGuard.IsObject(value)) return ObjectType(value)
     return value
   }
   /** Clones a type. */
-  export function Clone<T extends TSchema>(schema: T, options: SchemaOptions): T {
+  export function Clone<T extends TSchema>(schema: T, options: SchemaOptions = {}): T {
     return { ...Visit(schema), ...options }
   }
 }
@@ -2008,7 +2048,7 @@ export namespace TypeClone {
 export namespace IndexedAccessor {
   function OptionalUnwrap(schema: TSchema[]): TSchema[] {
     return schema.map((schema) => {
-      const { [Modifier]: _, ...clone } = TypeClone.Clone(schema, {})
+      const { [Optional]: _, ...clone } = TypeClone.Clone(schema)
       return clone
     })
   }
@@ -2031,36 +2071,36 @@ export namespace IndexedAccessor {
     if (schema[Kind] === 'Union') return ResolveUnion(schema as TUnion)
     return schema
   }
-  function Intersect(schema: TIntersect, key: string): TSchema {
+  function TIntersect(schema: TIntersect, key: string): TSchema {
     const resolved = schema.allOf.reduce((acc, schema) => {
       const indexed = Visit(schema, key)
       return indexed[Kind] === 'Never' ? acc : [...acc, indexed]
     }, [] as TSchema[])
     return ResolveOptional(Type.Intersect(resolved))
   }
-  function Union(schema: TUnion, key: string): TSchema {
+  function TUnion(schema: TUnion, key: string): TSchema {
     const resolved = schema.anyOf.map((schema) => Visit(schema, key))
     return ResolveOptional(Type.Union(resolved))
   }
-  function Object(schema: TObject, key: string): TSchema {
+  function TObject(schema: TObject, key: string): TSchema {
     const property = schema.properties[key]
-    return property === undefined ? Type.Never() : Type.Union([property])
+    return ValueGuard.IsUndefined(property) ? Type.Never() : Type.Union([property])
   }
-  function Tuple(schema: TTuple, key: string): TSchema {
+  function TTuple(schema: TTuple, key: string): TSchema {
     const items = schema.items
-    if (items === undefined) return Type.Never()
+    if (ValueGuard.IsUndefined(items)) return Type.Never()
     const element = items[key as any as number] //
-    if (element === undefined) return Type.Never()
+    if (ValueGuard.IsUndefined(element)) return Type.Never()
     return element
   }
   function Visit(schema: TSchema, key: string): TSchema {
-    if (schema[Kind] === 'Intersect') return Intersect(schema as TIntersect, key)
-    if (schema[Kind] === 'Union') return Union(schema as TUnion, key)
-    if (schema[Kind] === 'Object') return Object(schema as TObject, key)
-    if (schema[Kind] === 'Tuple') return Tuple(schema as TTuple, key)
+    if (schema[Kind] === 'Intersect') return TIntersect(schema as TIntersect, key)
+    if (schema[Kind] === 'Union') return TUnion(schema as TUnion, key)
+    if (schema[Kind] === 'Object') return TObject(schema as TObject, key)
+    if (schema[Kind] === 'Tuple') return TTuple(schema as TTuple, key)
     return Type.Never()
   }
-  export function Resolve(schema: TSchema, keys: Key[], options: SchemaOptions = {}): TSchema {
+  export function Resolve(schema: TSchema, keys: TPropertyKey[], options: SchemaOptions = {}): TSchema {
     const resolved = keys.map((key) => Visit(schema, key.toString()))
     return ResolveOptional(Type.Union(resolved, options))
   }
@@ -2069,15 +2109,15 @@ export namespace IndexedAccessor {
 // ObjectMap
 // --------------------------------------------------------------------------
 export namespace ObjectMap {
-  function Intersect(schema: TIntersect, callback: (object: TObject) => TObject) {
+  function TIntersect(schema: TIntersect, callback: (object: TObject) => TObject) {
     // prettier-ignore
     return Type.Intersect(schema.allOf.map((inner) => Visit(inner, callback)), { ...schema })
   }
-  function Union(schema: TUnion, callback: (object: TObject) => TObject) {
+  function TUnion(schema: TUnion, callback: (object: TObject) => TObject) {
     // prettier-ignore
     return Type.Union(schema.anyOf.map((inner) => Visit(inner, callback)), { ...schema })
   }
-  function Object(schema: TObject, callback: (object: TObject) => TObject) {
+  function TObject(schema: TObject, callback: (object: TObject) => TObject) {
     return callback(schema)
   }
   function Visit(schema: TSchema, callback: (object: TObject) => TObject): TSchema {
@@ -2085,13 +2125,13 @@ export namespace ObjectMap {
     // prevent sub schema mapping as unregistered kinds will not pass TSchema checks. This is notable in the
     // case of TObject where unregistered property kinds cause the TObject check to fail. As mapping is only
     // used for composition, we use explicit checks instead.
-    if (schema[Kind] === 'Intersect') return Intersect(schema as TIntersect, callback)
-    if (schema[Kind] === 'Union') return Union(schema as TUnion, callback)
-    if (schema[Kind] === 'Object') return Object(schema as TObject, callback)
+    if (schema[Kind] === 'Intersect') return TIntersect(schema as TIntersect, callback)
+    if (schema[Kind] === 'Union') return TUnion(schema as TUnion, callback)
+    if (schema[Kind] === 'Object') return TObject(schema as TObject, callback)
     return schema
   }
   export function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T {
-    return { ...Visit(TypeClone.Clone(schema, {}), callback), ...options } as unknown as T
+    return { ...Visit(TypeClone.Clone(schema), callback), ...options } as unknown as T
   }
 }
 // --------------------------------------------------------------------------
@@ -2104,24 +2144,24 @@ export namespace KeyResolver {
   function UnwrapPattern(key: string) {
     return key[0] === '^' && key[key.length - 1] === '$' ? key.slice(1, key.length - 1) : key
   }
-  function Intersect(schema: TIntersect, options: KeyResolverOptions): string[] {
+  function TIntersect(schema: TIntersect, options: KeyResolverOptions): string[] {
     return schema.allOf.reduce((acc, schema) => [...acc, ...Visit(schema, options)], [] as string[])
   }
-  function Union(schema: TUnion, options: KeyResolverOptions): string[] {
+  function TUnion(schema: TUnion, options: KeyResolverOptions): string[] {
     const sets = schema.anyOf.map((inner) => Visit(inner, options))
     return [...sets.reduce((set, outer) => outer.map((key) => (sets.every((inner) => inner.includes(key)) ? set.add(key) : set))[0], new Set<string>())]
   }
-  function Object(schema: TObject, options: KeyResolverOptions): string[] {
-    return globalThis.Object.keys(schema.properties)
+  function TObject(schema: TObject, options: KeyResolverOptions): string[] {
+    return Object.getOwnPropertyNames(schema.properties)
   }
-  function Record(schema: TRecord, options: KeyResolverOptions): string[] {
-    return options.includePatterns ? globalThis.Object.keys(schema.patternProperties) : []
+  function TRecord(schema: TRecord, options: KeyResolverOptions): string[] {
+    return options.includePatterns ? Object.getOwnPropertyNames(schema.patternProperties) : []
   }
   function Visit(schema: TSchema, options: KeyResolverOptions): string[] {
-    if (TypeGuard.TIntersect(schema)) return Intersect(schema, options)
-    if (TypeGuard.TUnion(schema)) return Union(schema, options)
-    if (TypeGuard.TObject(schema)) return Object(schema, options)
-    if (TypeGuard.TRecord(schema)) return Record(schema, options)
+    if (TypeGuard.TIntersect(schema)) return TIntersect(schema, options)
+    if (TypeGuard.TUnion(schema)) return TUnion(schema, options)
+    if (TypeGuard.TObject(schema)) return TObject(schema, options)
+    if (TypeGuard.TRecord(schema)) return TRecord(schema, options)
     return []
   }
   /** Resolves an array of keys in this schema */
@@ -2141,7 +2181,7 @@ export namespace KeyResolver {
 export namespace KeyArrayResolver {
   /** Resolves an array of string[] keys from the given schema or array type. */
   export function Resolve(schema: TSchema | string[]): string[] {
-    if (globalThis.Array.isArray(schema)) return schema
+    if (Array.isArray(schema)) return schema
     if (TypeGuard.TUnionLiteral(schema)) return schema.anyOf.map((schema) => schema.const.toString())
     if (TypeGuard.TLiteral(schema)) return [schema.const as string]
     if (TypeGuard.TTemplateLiteral(schema)) {
@@ -2156,10 +2196,10 @@ export namespace KeyArrayResolver {
 // UnionResolver
 // --------------------------------------------------------------------------
 export namespace UnionResolver {
-  function* Union(union: TUnion): IterableIterator<TSchema> {
+  function* TUnion(union: TUnion): IterableIterator<TSchema> {
     for (const schema of union.anyOf) {
       if (schema[Kind] === 'Union') {
-        yield* Union(schema as TUnion)
+        yield* TUnion(schema as TUnion)
       } else {
         yield schema
       }
@@ -2167,7 +2207,7 @@ export namespace UnionResolver {
   }
   /** Returns a resolved union with interior unions flattened */
   export function Resolve(union: TUnion): TUnion {
-    return Type.Union([...Union(union)], { ...union })
+    return Type.Union([...TUnion(union)], { ...union })
   }
 }
 // --------------------------------------------------------------------------
@@ -2179,11 +2219,9 @@ export namespace TemplateLiteralPattern {
   }
   function Visit(schema: TSchema, acc: string): string {
     if (TypeGuard.TTemplateLiteral(schema)) {
-      const pattern = schema.pattern.slice(1, schema.pattern.length - 1)
-      return pattern
+      return schema.pattern.slice(1, schema.pattern.length - 1)
     } else if (TypeGuard.TUnion(schema)) {
-      const tokens = schema.anyOf.map((schema) => Visit(schema, acc)).join('|')
-      return `(${tokens})`
+      return `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})`
     } else if (TypeGuard.TNumber(schema)) {
       return `${acc}${PatternNumber}`
     } else if (TypeGuard.TInteger(schema)) {
@@ -2456,6 +2494,11 @@ export class TypeBuilder {
   protected Create<T>(schema: Omit<T, 'static' | 'params'>): T {
     return schema as any
   }
+  /** `[Utility]` Discards a property key from the given schema */
+  protected Discard(schema: TSchema, key: PropertyKey): TSchema {
+    const { [key as any]: _, ...rest } = schema
+    return rest as TSchema
+  }
   /** `[Standard]` Omits compositing symbols from this schema */
   public Strict<T extends TSchema>(schema: T): T {
     return JSON.parse(JSON.stringify(schema))
@@ -2468,17 +2511,17 @@ export class StandardTypeBuilder extends TypeBuilder {
   // ------------------------------------------------------------------------
   // Modifiers
   // ------------------------------------------------------------------------
-  /** `[Modifier]` Creates a Optional property */
-  public Optional<T extends TSchema>(schema: T): TOptional<T> {
-    return { [Modifier]: 'Optional', ...TypeClone.Clone(schema, {}) }
-  }
-  /** `[Modifier]` Creates a ReadonlyOptional property */
-  public ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T> {
-    return { [Modifier]: 'ReadonlyOptional', ...TypeClone.Clone(schema, {}) }
+  /** `[Standard]` Creates a Readonly and Optional property */
+  public ReadonlyOptional<T extends TSchema>(schema: T): TReadonly<TOptional<T>> {
+    return this.Readonly(this.Optional(schema))
   }
-  /** `[Modifier]` Creates a Readonly object or property */
+  /** `[Standard]` Creates a Readonly property */
   public Readonly<T extends TSchema>(schema: T): TReadonly<T> {
-    return { [Modifier]: 'Readonly', ...schema }
+    return { ...TypeClone.Clone(schema), [Readonly]: 'Readonly' }
+  }
+  /** `[Standard]` Creates an Optional property */
+  public Optional<T extends TSchema>(schema: T): TOptional<T> {
+    return { ...TypeClone.Clone(schema), [Optional]: 'Optional' }
   }
   // ------------------------------------------------------------------------
   // Types
@@ -2488,14 +2531,19 @@ export class StandardTypeBuilder extends TypeBuilder {
     return this.Create({ ...options, [Kind]: 'Any' })
   }
   /** `[Standard]` Creates an Array type */
-  public Array<T extends TSchema>(items: T, options: ArrayOptions = {}): TArray<T> {
-    return this.Create({ ...options, [Kind]: 'Array', type: 'array', items: TypeClone.Clone(items, {}) })
+  public Array<T extends TSchema>(schema: T, options: ArrayOptions = {}): TArray<T> {
+    return this.Create({ ...options, [Kind]: 'Array', type: 'array', items: TypeClone.Clone(schema) })
   }
   /** `[Standard]` Creates a Boolean type */
   public Boolean(options: SchemaOptions = {}): TBoolean {
     return this.Create({ ...options, [Kind]: 'Boolean', type: 'boolean' })
   }
-  /** `[Standard]` Creates a Composite object type. */
+  /** `[Standard]` Capitalize a LiteralString type */
+  public Capitalize<T extends TLiteral<string>>(schema: T, options: SchemaOptions = {}): TLiteral<Capitalize<T['const']>> {
+    const [first, rest] = [schema.const.slice(0, 1), schema.const.slice(1)]
+    return Type.Literal(`${first.toUpperCase()}${rest}` as Capitalize<T['const']>, options)
+  }
+  /** `[Standard]` Creates a Composite object type */
   public Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T> {
     const intersect: any = Type.Intersect(objects, {})
     const keys = KeyResolver.ResolveKeys(intersect, { includePatterns: false })
@@ -2505,11 +2553,11 @@ export class StandardTypeBuilder extends TypeBuilder {
   /** `[Standard]` Creates a Enum type */
   public Enum<T extends Record<string, string | number>>(item: T, options: SchemaOptions = {}): TEnum<T> {
     // prettier-ignore
-    const values = globalThis.Object.keys(item).filter((key) => isNaN(key as any)).map((key) => item[key]) as T[keyof T][]
-    const anyOf = values.map((value) => (typeof value === 'string' ? { [Kind]: 'Literal', type: 'string' as const, const: value } : { [Kind]: 'Literal', type: 'number' as const, const: value }))
+    const values = Object.getOwnPropertyNames(item).filter((key) => isNaN(key as any)).map((key) => item[key]) as T[keyof T][]
+    const anyOf = values.map((value) => (ValueGuard.IsString(value) ? { [Kind]: 'Literal', type: 'string' as const, const: value } : { [Kind]: 'Literal', type: 'number' as const, const: value }))
     return this.Create({ ...options, [Kind]: 'Union', anyOf })
   }
-  /** `[Standard]` A conditional type expression that will return the true type if the left type extends the right */
+  /** `[Standard]` Creates a Conditional type */
   public Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options: SchemaOptions = {}): TExtends<L, R, T, U> {
     switch (TypeExtends.Extends(left, right)) {
       case TypeExtendsResult.Union:
@@ -2520,53 +2568,53 @@ export class StandardTypeBuilder extends TypeBuilder {
         return TypeClone.Clone(falseType, options) as unknown as TExtends<L, R, T, U>
     }
   }
-  /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
-  public Exclude<L extends TSchema, R extends TSchema>(left: L, right: R, options: SchemaOptions = {}): TExclude<L, R> {
-    if (TypeGuard.TTemplateLiteral(left)) return this.Exclude(TemplateLiteralResolver.Resolve(left), right, options) as TExclude<L, R>
-    if (TypeGuard.TTemplateLiteral(right)) return this.Exclude(left, TemplateLiteralResolver.Resolve(right), options) as any as TExclude<L, R>
-    if (TypeGuard.TUnion(left)) {
-      const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) === TypeExtendsResult.False)
+  /** `[Standard]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+  public Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options: SchemaOptions = {}): TExclude<L, R> {
+    if (TypeGuard.TTemplateLiteral(unionType)) return this.Exclude(TemplateLiteralResolver.Resolve(unionType), excludedMembers, options) as TExclude<L, R>
+    if (TypeGuard.TTemplateLiteral(excludedMembers)) return this.Exclude(unionType, TemplateLiteralResolver.Resolve(excludedMembers), options) as any as TExclude<L, R>
+    if (TypeGuard.TUnion(unionType)) {
+      const narrowed = unionType.anyOf.filter((inner) => TypeExtends.Extends(inner, excludedMembers) === TypeExtendsResult.False)
       return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options)) as TExclude<L, R>
     } else {
-      return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Clone(left, options)) as any
+      return (TypeExtends.Extends(unionType, excludedMembers) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Clone(unionType, options)) as any
     }
   }
-  /** `[Standard]` Extracts from the left type any type that is assignable to the right */
-  public Extract<L extends TSchema, R extends TSchema>(left: L, right: R, options: SchemaOptions = {}): TExtract<L, R> {
-    if (TypeGuard.TTemplateLiteral(left)) return this.Extract(TemplateLiteralResolver.Resolve(left), right, options) as TExtract<L, R>
-    if (TypeGuard.TTemplateLiteral(right)) return this.Extract(left, TemplateLiteralResolver.Resolve(right), options) as any as TExtract<L, R>
-    if (TypeGuard.TUnion(left)) {
-      const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) !== TypeExtendsResult.False)
+  /** `[Standard]` Constructs a type by extracting from type all union members that are assignable to union */
+  public Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options: SchemaOptions = {}): TExtract<L, R> {
+    if (TypeGuard.TTemplateLiteral(type)) return this.Extract(TemplateLiteralResolver.Resolve(type), union, options) as TExtract<L, R>
+    if (TypeGuard.TTemplateLiteral(union)) return this.Extract(type, TemplateLiteralResolver.Resolve(union), options) as any as TExtract<L, R>
+    if (TypeGuard.TUnion(type)) {
+      const narrowed = type.anyOf.filter((inner) => TypeExtends.Extends(inner, union) !== TypeExtendsResult.False)
       return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options)) as TExtract<L, R>
     } else {
-      return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? TypeClone.Clone(left, options) : this.Never(options)) as any
+      return (TypeExtends.Extends(type, union) !== TypeExtendsResult.False ? TypeClone.Clone(type, options) : this.Never(options)) as any
     }
   }
-  /** `[Standard]` Returns indexed property types for the given keys */
+  /** `[Standard]` Returns an Indexed property type for the given keys */
   public Index<T extends TTuple, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): UnionType<Assert<T['items'], TSchema[]>>
-  /** `[Standard]` Returns indexed property types for the given keys */
+  /** `[Standard]` Returns an Indexed property type for the given keys */
   public Index<T extends TArray, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): AssertType<T['items']>
-  /** `[Standard]` Returns indexed property types for the given keys */
+  /** `[Standard]` Returns an Indexed property type for the given keys */
   public Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyRest<K>>
-  /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TSchema, K extends TLiteral<Key>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, [K['const']]>
-  /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, Key[]>>
-  /** `[Standard]` Returns indexed property types for the given keys */
-  public Index<T extends TSchema, K extends TUnion<TLiteral<Key>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TUnionLiteralKeyRest<K>>
-  /** `[Standard]` Returns indexed property types for the given keys */
+  /** `[Standard]` Returns an Indexed property type for the given keys */
+  public Index<T extends TSchema, K extends TLiteral<TPropertyKey>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, [K['const']]>
+  /** `[Standard]` Returns an Indexed property type for the given keys */
+  public Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, TPropertyKey[]>>
+  /** `[Standard]` Returns an Indexed property type for the given keys */
+  public Index<T extends TSchema, K extends TUnion<TLiteral<TPropertyKey>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TUnionLiteralKeyRest<K>>
+  /** `[Standard]` Returns an Indexed property type for the given keys */
   public Index<T extends TSchema, K extends TSchema>(schema: T, key: K, options?: SchemaOptions): TSchema
-  /** `[Standard]` Returns indexed property types for the given keys */
+  /** `[Standard]` Returns an Indexed property type for the given keys */
   public Index(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
     if (TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved)) {
       return TypeClone.Clone(schema.items, options)
     } else if (TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved)) {
-      const items = schema.items === undefined ? [] : schema.items
-      const cloned = items.map((schema) => TypeClone.Clone(schema, {}))
+      const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items
+      const cloned = items.map((schema) => TypeClone.Clone(schema))
       return this.Union(cloned, options)
     } else {
       const keys = KeyArrayResolver.Resolve(unresolved)
-      const clone = TypeClone.Clone(schema, {})
+      const clone = TypeClone.Clone(schema)
       return IndexedAccessor.Resolve(clone, keys, options)
     }
   }
@@ -2574,18 +2622,19 @@ export class StandardTypeBuilder extends TypeBuilder {
   public Integer(options: NumericOptions<number> = {}): TInteger {
     return this.Create({ ...options, [Kind]: 'Integer', type: 'integer' })
   }
-  /** `[Standard]` Creates a Intersect type */
+  /** `[Standard]` Creates an Intersect type */
   public Intersect(allOf: [], options?: SchemaOptions): TNever
-  /** `[Standard]` Creates a Intersect type */
+  /** `[Standard]` Creates an Intersect type */
   public Intersect<T extends [TSchema]>(allOf: [...T], options?: SchemaOptions): T[0]
-  // /** `[Standard]` Creates a Intersect type */
+  /** `[Standard]` Creates an Intersect type */
   public Intersect<T extends TSchema[]>(allOf: [...T], options?: IntersectOptions): TIntersect<T>
+  /** `[Standard]` Creates an Intersect type */
   public Intersect(allOf: TSchema[], options: IntersectOptions = {}) {
     if (allOf.length === 0) return Type.Never()
     if (allOf.length === 1) return TypeClone.Clone(allOf[0], options)
     const objects = allOf.every((schema) => TypeGuard.TObject(schema))
-    const cloned = allOf.map((schema) => TypeClone.Clone(schema, {}))
-    const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties) ? { unevaluatedProperties: TypeClone.Clone(options.unevaluatedProperties, {}) } : {}
+    const cloned = allOf.map((schema) => TypeClone.Clone(schema))
+    const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties) ? { unevaluatedProperties: TypeClone.Clone(options.unevaluatedProperties) } : {}
     if (options.unevaluatedProperties === false || TypeGuard.TSchema(options.unevaluatedProperties) || objects) {
       return this.Create({ ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: cloned })
     } else {
@@ -2600,7 +2649,7 @@ export class StandardTypeBuilder extends TypeBuilder {
       if (pattern === PatternStringExact) return this.String(options) as unknown as TKeyOf<T>
       throw Error('StandardTypeBuilder: Unable to resolve key type from Record key pattern')
     } else if (TypeGuard.TTuple(schema)) {
-      const items = schema.items === undefined ? [] : schema.items
+      const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items
       const literals = items.map((_, index) => Type.Literal(index))
       return this.Union(literals, options) as unknown as TKeyOf<T>
     } else if (TypeGuard.TArray(schema)) {
@@ -2616,13 +2665,17 @@ export class StandardTypeBuilder extends TypeBuilder {
   public Literal<T extends TLiteralValue>(value: T, options: SchemaOptions = {}): TLiteral<T> {
     return this.Create({ ...options, [Kind]: 'Literal', const: value, type: typeof value as 'string' | 'number' | 'boolean' })
   }
+  /** `[Standard]` Lowercase a LiteralString type */
+  public Lowercase<T extends TLiteral<string>>(schema: T, options: SchemaOptions = {}): TLiteral<Lowercase<T['const']>> {
+    return Type.Literal(schema.const.toLowerCase() as Lowercase<T['const']>, options)
+  }
   /** `[Standard]` Creates a Never type */
   public Never(options: SchemaOptions = {}): TNever {
     return this.Create({ ...options, [Kind]: 'Never', not: {} })
   }
   /** `[Standard]` Creates a Not type */
-  public Not<T extends TSchema>(not: T, options?: SchemaOptions): TNot<T> {
-    return this.Create({ ...options, [Kind]: 'Not', not })
+  public Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T> {
+    return this.Create({ ...options, [Kind]: 'Not', not: TypeClone.Clone(schema) })
   }
   /** `[Standard]` Creates a Null type */
   public Null(options: SchemaOptions = {}): TNull {
@@ -2634,81 +2687,75 @@ export class StandardTypeBuilder extends TypeBuilder {
   }
   /** `[Standard]` Creates an Object type */
   public Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
-    const propertyKeys = globalThis.Object.getOwnPropertyNames(properties)
-    const optionalKeys = propertyKeys.filter((key) => TypeGuard.TOptional(properties[key]) || TypeGuard.TReadonlyOptional(properties[key]))
+    const propertyKeys = Object.getOwnPropertyNames(properties)
+    const optionalKeys = propertyKeys.filter((key) => TypeGuard.TOptional(properties[key]))
     const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name))
-    const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Clone(options.additionalProperties, {}) } : {}
-    const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(properties[key], {}) }), {} as TProperties)
+    const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Clone(options.additionalProperties) } : {}
+    const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(properties[key]) }), {} as TProperties)
     if (requiredKeys.length > 0) {
       return this.Create({ ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys })
     } else {
       return this.Create({ ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties })
     }
   }
-  /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+  /** `[Standard]` Constructs a type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TOmit<T, K[number]>
-  /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+  /** `[Standard]` Constructs a type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionLiteralKeyRest<K>[number]>
-  /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+  /** `[Standard]` Constructs a type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TOmit<T, K['const']>
-  /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+  /** `[Standard]` Constructs a type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TOmit<T, TTemplateLiteralKeyRest<K>[number]>
-  /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+  /** `[Standard]` Constructs a type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TOmit<T, never>
+  /** `[Standard]` Constructs a type whose keys are omitted from the given type */
   public Omit(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
     const keys = KeyArrayResolver.Resolve(unresolved)
     // prettier-ignore
-    return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
-      if (schema.required) {
-        schema.required = schema.required.filter((key: string) => !keys.includes(key as any))
-        if (schema.required.length === 0) delete schema.required
+    return ObjectMap.Map(TypeClone.Clone(schema), (object) => {
+      if (ValueGuard.IsArray(object.required)) {
+        object.required = object.required.filter((key: string) => !keys.includes(key as any))
+        if (object.required.length === 0) delete object.required
       }
-      for (const key of globalThis.Object.keys(schema.properties)) {
-        if (keys.includes(key as any)) delete schema.properties[key]
+      for (const key of Object.getOwnPropertyNames(object.properties)) {
+        if (keys.includes(key as any)) delete object.properties[key]
       }
-      return this.Create(schema)
+      return this.Create(object)
     }, options)
   }
-  /** `[Standard]` Creates a mapped type where all properties are Optional */
+  /** `[Standard]` Constructs a type where all properties are optional */
   public Partial<T extends TSchema>(schema: T, options: ObjectOptions = {}): TPartial<T> {
-    function Apply(schema: TSchema) {
-      // prettier-ignore
-      switch (schema[Modifier]) {
-        case 'ReadonlyOptional': schema[Modifier] = 'ReadonlyOptional'; break;
-        case 'Readonly': schema[Modifier] = 'ReadonlyOptional'; break;
-        case 'Optional': schema[Modifier] = 'Optional'; break;
-        default: schema[Modifier] = 'Optional'; break;
-      }
-    }
     // prettier-ignore
-    return ObjectMap.Map<TPartial<T>>(TypeClone.Clone(schema, {}), (schema) => {
-      delete schema.required
-      globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]))
-      return schema
+    return ObjectMap.Map(schema, (object) => {
+      const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
+        return { ...acc, [key]: this.Optional(object.properties[key]) }
+      }, {} as TProperties)
+      return this.Object(properties, this.Discard(object, 'required') /* object used as options to retain other constraints */)
     }, options)
   }
-  /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+  /** `[Standard]` Constructs a type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TPick<T, K[number]>
-  /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+  /** `[Standard]` Constructs a type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionLiteralKeyRest<K>[number]>
-  /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+  /** `[Standard]` Constructs a type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TPick<T, K['const']>
-  /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+  /** `[Standard]` Constructs a type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TPick<T, TTemplateLiteralKeyRest<K>[number]>
-  /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
+  /** `[Standard]` Constructs a type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TPick<T, never>
+  /** `[Standard]` Constructs a type whose keys are picked from the given type */
   public Pick(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
     const keys = KeyArrayResolver.Resolve(unresolved)
     // prettier-ignore
-    return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
-      if (schema.required) {
-        schema.required = schema.required.filter((key: any) => keys.includes(key))
-        if (schema.required.length === 0) delete schema.required
+    return ObjectMap.Map(TypeClone.Clone(schema), (object) => {
+      if (ValueGuard.IsArray(object.required)) {
+        object.required = object.required.filter((key: any) => keys.includes(key))
+        if (object.required.length === 0) delete object.required
       }
-      for (const key of globalThis.Object.keys(schema.properties)) {
-        if (!keys.includes(key as any)) delete schema.properties[key]
+      for (const key of Object.getOwnPropertyNames(object.properties)) {
+        if (!keys.includes(key as any)) delete object.properties[key]
       }
-      return this.Create(schema)
+      return this.Create(object)
     }, options)
   }
   /** `[Standard]` Creates a Record type */
@@ -2727,79 +2774,75 @@ export class StandardTypeBuilder extends TypeBuilder {
       const expression = TemplateLiteralParser.ParseExact(key.pattern)
       // prettier-ignore
       return TemplateLiteralFinite.Check(expression)
-        ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(schema, {}) }), {} as TProperties), options))
-        : this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema, {}) }})
+        ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(schema) }), {} as TProperties), options))
+        : this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema) }})
     } else if (TypeGuard.TUnion(key)) {
       const union = UnionResolver.Resolve(key)
       if (TypeGuard.TUnionLiteral(union)) {
-        const properties = union.anyOf.reduce((acc: any, literal: any) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {} as TProperties)
+        const properties = union.anyOf.reduce((acc: any, literal: any) => ({ ...acc, [literal.const]: TypeClone.Clone(schema) }), {} as TProperties)
         return this.Object(properties, { ...options, [Hint]: 'Record' })
-      } else throw Error('TypeBuilder: Record key of type union contains non-literal types')
+      } else throw Error('StandardTypeBuilder: Record key of type union contains non-literal types')
     } else if (TypeGuard.TLiteral(key)) {
-      if (typeof key.const === 'string' || typeof key.const === 'number') {
-        return this.Object({ [key.const]: TypeClone.Clone(schema, {}) }, options)
-      } else throw Error('TypeBuilder: Record key of type literal is not of type string or number')
+      if (ValueGuard.IsString(key.const) || ValueGuard.IsNumber(key.const)) {
+        return this.Object({ [key.const]: TypeClone.Clone(schema) }, options)
+      } else throw Error('StandardTypeBuilder: Record key of type literal is not of type string or number')
     } else if (TypeGuard.TInteger(key) || TypeGuard.TNumber(key)) {
-      const pattern = PatternNumberExact
-      return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) } })
+      return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [PatternNumberExact]: TypeClone.Clone(schema) } })
     } else if (TypeGuard.TString(key)) {
-      const pattern = key.pattern === undefined ? PatternStringExact : key.pattern
-      return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) } })
+      const pattern = ValueGuard.IsUndefined(key.pattern) ? PatternStringExact : key.pattern
+      return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema) } })
     } else {
       throw Error(`StandardTypeBuilder: Record key is an invalid type`)
     }
   }
   /** `[Standard]` Creates a Recursive type */
   public Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options: SchemaOptions = {}): TRecursive<T> {
-    if (options.$id === undefined) (options as any).$id = `T${TypeOrdinal++}`
+    if (ValueGuard.IsUndefined(options.$id)) (options as any).$id = `T${TypeOrdinal++}`
     const thisType = callback({ [Kind]: 'This', $ref: `${options.$id}` } as any)
     thisType.$id = options.$id
     return this.Create({ ...options, [Hint]: 'Recursive', ...thisType } as any)
   }
   /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
-  public Ref<T extends TSchema>(schema: T, options: SchemaOptions = {}): TRef<T> {
-    if (schema.$id === undefined) throw Error('StandardTypeBuilder.Ref: Target type must specify an $id')
-    return this.Create({ ...options, [Kind]: 'Ref', $ref: schema.$id! })
-  }
-  /** `[Standard]` Creates a mapped type where all properties are Required */
+  public Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>
+  /** `[Standard]` Creates a Ref type. */
+  public Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>
+  /** `[Standard]` Creates a Ref type. */
+  public Ref(unresolved: TSchema | string, options: SchemaOptions = {}) {
+    if (ValueGuard.IsString(unresolved)) return this.Create({ ...options, [Kind]: 'Ref', $ref: unresolved })
+    if (ValueGuard.IsUndefined(unresolved.$id)) throw Error('StandardTypeBuilder.Ref: Target type must specify an $id')
+    return this.Create({ ...options, [Kind]: 'Ref', $ref: unresolved.$id! })
+  }
+  /** `[Standard]` Constructs a type where all properties are required */
   public Required<T extends TSchema>(schema: T, options: SchemaOptions = {}): TRequired<T> {
-    function Apply(schema: TSchema) {
-      // prettier-ignore
-      switch (schema[Modifier]) {
-        case 'ReadonlyOptional': schema[Modifier] = 'Readonly'; break
-        case 'Readonly': schema[Modifier] = 'Readonly'; break
-        case 'Optional': delete schema[Modifier]; break
-        default: delete schema[Modifier]; break
-      }
-    }
     // prettier-ignore
-    return ObjectMap.Map<TRequired<T>>(TypeClone.Clone(schema, {}), (schema) => {
-      schema.required = globalThis.Object.keys(schema.properties)
-      globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]))
-      return schema
+    return ObjectMap.Map(schema, (object) => {
+      const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
+        return { ...acc, [key]: this.Discard(object.properties[key], Optional) as TSchema }
+      }, {} as TProperties)
+      return this.Object(properties, object /* object used as options to retain other constraints  */)
     }, options)
   }
-  /** `[Standard]` Returns a schema array which allows types to compose with the JavaScript spread operator */
+  /** `[Standard]` Extracts the rest array from a Tuple */
   public Rest<T extends TSchema>(schema: T): TRest<T> {
     if (TypeGuard.TTuple(schema)) {
-      if (schema.items === undefined) return [] as TSchema[] as TRest<T>
-      return schema.items.map((schema) => TypeClone.Clone(schema, {})) as TRest<T>
+      if (ValueGuard.IsUndefined(schema.items)) return [] as TSchema[] as TRest<T>
+      return schema.items.map((schema) => TypeClone.Clone(schema)) as TRest<T>
     } else {
-      return [TypeClone.Clone(schema, {})] as TRest<T>
+      return [TypeClone.Clone(schema)] as TRest<T>
     }
   }
   /** `[Standard]` Creates a String type */
   public String(options: StringOptions = {}): TString {
     return this.Create({ ...options, [Kind]: 'String', type: 'string' })
   }
-  /** `[Experimental]` Creates a template literal type from dsl string */
-  public TemplateLiteral<T extends string>(dsl: T, options?: SchemaOptions): TTemplateLiteralDslParser<T>
-  /** `[Standard]` Creates a template literal type */
+  /** `[Standard]` Creates a TemplateLiteral type from template dsl string */
+  public TemplateLiteral<T extends string>(templateDsl: T, options?: SchemaOptions): TTemplateLiteralDslParser<T>
+  /** `[Standard]` Creates a TemplateLiteral type */
   public TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>
-  /** `[Standard]` Creates a template literal type */
+  /** `[Standard]` Creates a TemplateLiteral type */
   public TemplateLiteral(unresolved: unknown, options: SchemaOptions = {}) {
     // prettier-ignore
-    const pattern = (typeof unresolved === 'string')
+    const pattern = (ValueGuard.IsString(unresolved))
       ? TemplateLiteralPattern.Create(TemplateLiteralDslParser.Parse(unresolved))
       : TemplateLiteralPattern.Create(unresolved as TTemplateLiteralKind[])
     return this.Create({ ...options, [Kind]: 'TemplateLiteral', type: 'string', pattern })
@@ -2807,21 +2850,27 @@ export class StandardTypeBuilder extends TypeBuilder {
   /** `[Standard]` Creates a Tuple type */
   public Tuple<T extends TSchema[]>(items: [...T], options: SchemaOptions = {}): TTuple<T> {
     const [additionalItems, minItems, maxItems] = [false, items.length, items.length]
-    const clonedItems = items.map((item) => TypeClone.Clone(item, {}))
+    const clonedItems = items.map((item) => TypeClone.Clone(item))
     // prettier-ignore
     const schema = (items.length > 0 ? 
       { ...options, [Kind]: 'Tuple', type: 'array', items: clonedItems, additionalItems, minItems, maxItems } : 
       { ...options, [Kind]: 'Tuple', type: 'array', minItems, maxItems }) as any
     return this.Create(schema)
   }
+  /** `[Standard]` Uncapitalize a LiteralString type */
+  public Uncapitalize<T extends TLiteral<string>>(schema: T, options: SchemaOptions = {}): TLiteral<Uncapitalize<T['const']>> {
+    const [first, rest] = [schema.const.slice(0, 1), schema.const.slice(1)]
+    return Type.Literal(`${first.toLocaleLowerCase()}${rest}` as Uncapitalize<T['const']>, options)
+  }
   /** `[Standard]` Creates a Union type */
   public Union(anyOf: [], options?: SchemaOptions): TNever
   /** `[Standard]` Creates a Union type */
   public Union<T extends [TSchema]>(anyOf: [...T], options?: SchemaOptions): T[0]
   /** `[Standard]` Creates a Union type */
   public Union<T extends TSchema[]>(anyOf: [...T], options?: SchemaOptions): TUnion<T>
-  /** `[Experimental]` Remaps a TemplateLiteral into a Union representation. This function is known to cause TS compiler crashes for finite templates with large generation counts. Use with caution. */
+  /** `[Experimental]` Converts a TemplateLiteral into a Union */
   public Union<T extends TTemplateLiteral>(template: T): TUnionTemplateLiteral<T>
+  /** `[Standard]` Creates a Union type */
   public Union(union: TSchema[] | TTemplateLiteral, options: SchemaOptions = {}) {
     if (TypeGuard.TTemplateLiteral(union)) {
       return TemplateLiteralResolver.Resolve(union)
@@ -2829,7 +2878,7 @@ export class StandardTypeBuilder extends TypeBuilder {
       const anyOf = union
       if (anyOf.length === 0) return this.Never(options)
       if (anyOf.length === 1) return this.Create(TypeClone.Clone(anyOf[0], options))
-      const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema, {}))
+      const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema))
       return this.Create({ ...options, [Kind]: 'Union', anyOf: clonedAnyOf })
     }
   }
@@ -2837,18 +2886,41 @@ export class StandardTypeBuilder extends TypeBuilder {
   public Unknown(options: SchemaOptions = {}): TUnknown {
     return this.Create({ ...options, [Kind]: 'Unknown' })
   }
-  /** `[Standard]` Creates a Unsafe type that infers for the generic argument */
+  /** `[Standard]` Creates a Unsafe type that will infers as the generic argument T */
   public Unsafe<T>(options: UnsafeOptions = {}): TUnsafe<T> {
     return this.Create({ ...options, [Kind]: options[Kind] || 'Unsafe' })
   }
+  /** `[Standard]` Uppercase a LiteralString type */
+  public Uppercase<T extends TLiteral<string>>(schema: T, options: SchemaOptions = {}): TLiteral<Uppercase<T['const']>> {
+    return Type.Literal(schema.const.toUpperCase() as Uppercase<T['const']>, options)
+  }
 }
 // --------------------------------------------------------------------------
 // ExtendedTypeBuilder
 // --------------------------------------------------------------------------
 export class ExtendedTypeBuilder extends StandardTypeBuilder {
+  /** `[Extended]` Creates a AsyncIterator type */
+  public AsyncIterator<T extends TSchema>(items: T, options: SchemaOptions = {}): TAsyncIterator<T> {
+    return this.Create({ ...options, [Kind]: 'AsyncIterator', type: 'AsyncIterator', items: TypeClone.Clone(items) })
+  }
+  /** `[Extended]` Constructs a type by recursively unwrapping Promise types */
+  public Awaited<T extends TSchema>(schema: T, options: SchemaOptions = {}): TAwaited<T> {
+    const AwaitedRest = (rest: TSchema[]): TSchema[] => {
+      if (rest.length === 0) return rest
+      const [L, ...R] = rest
+      return [this.Awaited(L), ...AwaitedRest(R)]
+    }
+    // prettier-ignore
+    return (
+      TypeGuard.TIntersect(schema) ? Type.Intersect(AwaitedRest(schema.allOf)) : 
+      TypeGuard.TUnion(schema) ? Type.Union(AwaitedRest(schema.anyOf)) :
+      TypeGuard.TPromise(schema) ? this.Awaited(schema.item) : 
+      TypeClone.Clone(schema, options)
+    ) as TAwaited<T>
+  }
   /** `[Extended]` Creates a BigInt type */
   public BigInt(options: NumericOptions<bigint> = {}): TBigInt {
-    return this.Create({ ...options, [Kind]: 'BigInt', type: 'null', typeOf: 'BigInt' })
+    return this.Create({ ...options, [Kind]: 'BigInt', type: 'bigint' })
   }
   /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
   public ConstructorParameters<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TConstructorParameters<T> {
@@ -2856,60 +2928,73 @@ export class ExtendedTypeBuilder extends StandardTypeBuilder {
   }
   /** `[Extended]` Creates a Constructor type */
   public Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U> {
-    const clonedReturns = TypeClone.Clone(returns, {})
-    const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}))
-    return this.Create({ ...options, [Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: clonedParameters, returns: clonedReturns })
+    const clonedReturns = TypeClone.Clone(returns)
+    const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter))
+    return this.Create({ ...options, [Kind]: 'Constructor', type: 'constructor', parameters: clonedParameters, returns: clonedReturns })
   }
   /** `[Extended]` Creates a Date type */
   public Date(options: DateOptions = {}): TDate {
-    return this.Create({ ...options, [Kind]: 'Date', type: 'object', instanceOf: 'Date' })
+    return this.Create({ ...options, [Kind]: 'Date', type: 'Date' })
   }
   /** `[Extended]` Creates a Function type */
   public Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U> {
     const clonedReturns = TypeClone.Clone(returns, {})
-    const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}))
-    return this.Create({ ...options, [Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: clonedParameters, returns: clonedReturns })
+    const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter))
+    return this.Create({ ...options, [Kind]: 'Function', type: 'function', parameters: clonedParameters, returns: clonedReturns })
   }
-  /** `[Extended]` Extracts the InstanceType from the given Constructor */
+  /** `[Extended]` Extracts the InstanceType from the given Constructor type */
   public InstanceType<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TInstanceType<T> {
     return TypeClone.Clone(schema.returns, options)
   }
+  /** `[Extended]` Creates an Iterator type */
+  public Iterator<T extends TSchema>(items: T, options: SchemaOptions = {}): TIterator<T> {
+    return this.Create({ ...options, [Kind]: 'Iterator', type: 'Iterator', items: TypeClone.Clone(items) })
+  }
   /** `[Extended]` Extracts the Parameters from the given Function type */
   public Parameters<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TParameters<T> {
     return this.Tuple(schema.parameters, { ...options })
   }
   /** `[Extended]` Creates a Promise type */
   public Promise<T extends TSchema>(item: T, options: SchemaOptions = {}): TPromise<T> {
-    return this.Create({ ...options, [Kind]: 'Promise', type: 'object', instanceOf: 'Promise', item: TypeClone.Clone(item, {}) })
-  }
-  /** `[Extended]` Creates a regular expression type */
+    return this.Create({ ...options, [Kind]: 'Promise', type: 'Promise', item: TypeClone.Clone(item) })
+  }
+  /** `[Extended]` Creates a String type from a Regular Expression pattern */
+  public RegExp(pattern: string, options?: SchemaOptions): TString
+  /** `[Extended]` Creates a String type from a Regular Expression */
+  public RegExp(regex: RegExp, options?: SchemaOptions): TString
+  /** `[Extended]` Creates a String type */
+  public RegExp(unresolved: string | RegExp, options: SchemaOptions = {}) {
+    const pattern = ValueGuard.IsString(unresolved) ? unresolved : unresolved.source
+    return this.Create({ ...options, [Kind]: 'String', type: 'string', pattern })
+  }
+  /**
+   * @deprecated Use `Type.RegExp`
+   */
   public RegEx(regex: RegExp, options: SchemaOptions = {}): TString {
-    return this.Create({ ...options, [Kind]: 'String', type: 'string', pattern: regex.source })
+    return this.RegExp(regex, options)
   }
-  /** `[Extended]` Extracts the ReturnType from the given Function */
+  /** `[Extended]` Extracts the ReturnType from the given Function type */
   public ReturnType<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TReturnType<T> {
     return TypeClone.Clone(schema.returns, options)
   }
   /** `[Extended]` Creates a Symbol type */
   public Symbol(options?: SchemaOptions): TSymbol {
-    return this.Create({ ...options, [Kind]: 'Symbol', type: 'null', typeOf: 'Symbol' })
+    return this.Create({ ...options, [Kind]: 'Symbol', type: 'symbol' })
   }
   /** `[Extended]` Creates a Undefined type */
   public Undefined(options: SchemaOptions = {}): TUndefined {
-    return this.Create({ ...options, [Kind]: 'Undefined', type: 'null', typeOf: 'Undefined' })
+    return this.Create({ ...options, [Kind]: 'Undefined', type: 'undefined' })
   }
   /** `[Extended]` Creates a Uint8Array type */
   public Uint8Array(options: Uint8ArrayOptions = {}): TUint8Array {
-    return this.Create({ ...options, [Kind]: 'Uint8Array', type: 'object', instanceOf: 'Uint8Array' })
+    return this.Create({ ...options, [Kind]: 'Uint8Array', type: 'Uint8Array' })
   }
   /** `[Extended]` Creates a Void type */
   public Void(options: SchemaOptions = {}): TVoid {
-    return this.Create({ ...options, [Kind]: 'Void', type: 'null', typeOf: 'Void' })
+    return this.Create({ ...options, [Kind]: 'Void', type: 'void' })
   }
 }
-
-/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
+/** JSON Schema Type Builder with Static Resolution for TypeScript */
 export const StandardType = new StandardTypeBuilder()
-
-/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
+/** JSON Schema Type Builder with Static Resolution for TypeScript */
 export const Type = new ExtendedTypeBuilder()
diff --git a/src/value/cast.ts b/src/value/cast.ts
index 1ff3db94c..5b284dcbc 100644
--- a/src/value/cast.ts
+++ b/src/value/cast.ts
@@ -27,13 +27,14 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import * as Types from '../typebox'
-import { ValueCreate } from './create'
-import { ValueCheck } from './check'
-import { ValueClone } from './clone'
+import * as ValueCreate from './create'
+import * as ValueCheck from './check'
+import * as ValueClone from './clone'
+import * as ValueGuard from './guard'
 
-// ----------------------------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 // Errors
-// ----------------------------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 export class ValueCastReferenceTypeError extends Error {
   constructor(public readonly schema: Types.TRef | Types.TThis) {
     super(`ValueCast: Cannot locate referenced schema with $id '${schema.$ref}'`)
@@ -61,21 +62,22 @@ export class ValueCastUnknownTypeError extends Error {
 }
 export class ValueCastDereferenceError extends Error {
   constructor(public readonly schema: Types.TRef | Types.TThis) {
-    super(`ValueCast: Unable to dereference schema with $id '${schema.$ref}'`)
+    super(`ValueCast: Unable to dereference type with $id '${schema.$ref}'`)
   }
 }
-// ----------------------------------------------------------------------------------------------
-// The following will score a schema against a value. For objects, the score is the tally of
-// points awarded for each property of the value. Property points are (1.0 / propertyCount)
-// to prevent large property counts biasing results. Properties that match literal values are
-// maximally awarded as literals are typically used as union discriminator fields.
-// ----------------------------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+// The following will score a schema against a value. For objects, the score
+// is the tally of points awarded for each property of the value. Property
+// points are (1.0 / propertyCount) to prevent large property counts biasing
+// results. Properties that match literal values are maximally awarded as
+// literals are typically used as union discriminator fields.
+// --------------------------------------------------------------------------
 namespace UnionCastCreate {
   function Score(schema: Types.TSchema, references: Types.TSchema[], value: any): number {
-    if (schema[Types.Kind] === 'Object' && typeof value === 'object' && value !== null) {
+    if (schema[Types.Kind] === 'Object' && typeof value === 'object' && !ValueGuard.IsNull(value)) {
       const object = schema as Types.TObject
-      const keys = Object.keys(value)
-      const entries = globalThis.Object.entries(object.properties)
+      const keys = Object.getOwnPropertyNames(value)
+      const entries = Object.entries(object.properties)
       const [point, max] = [1 / entries.length, entries.length]
       return entries.reduce((acc, [key, schema]) => {
         const literal = schema[Types.Kind] === 'Literal' && schema.const === value[key] ? max : 0
@@ -99,237 +101,237 @@ namespace UnionCastCreate {
     return select
   }
   export function Create(union: Types.TUnion, references: Types.TSchema[], value: any) {
-    if (union.default !== undefined) {
+    if ('default' in union) {
       return union.default
     } else {
       const schema = Select(union, references, value)
-      return ValueCast.Cast(schema, references, value)
+      return Cast(schema, references, value)
     }
   }
 }
-
-export namespace ValueCast {
-  // ----------------------------------------------------------------------------------------------
-  // Guards
-  // ----------------------------------------------------------------------------------------------
-  function IsObject(value: unknown): value is Record<keyof any, unknown> {
-    return typeof value === 'object' && value !== null && !globalThis.Array.isArray(value)
-  }
-  function IsArray(value: unknown): value is unknown[] {
-    return typeof value === 'object' && globalThis.Array.isArray(value)
-  }
-  function IsNumber(value: unknown): value is number {
-    return typeof value === 'number' && !isNaN(value)
-  }
-  function IsString(value: unknown): value is string {
-    return typeof value === 'string'
-  }
-  // ----------------------------------------------------------------------------------------------
-  // Cast
-  // ----------------------------------------------------------------------------------------------
-  function Any(schema: Types.TAny, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-  }
-  function Array(schema: Types.TArray, references: Types.TSchema[], value: any): any {
-    if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
-    const created = IsArray(value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-    const minimum = IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...globalThis.Array.from({ length: schema.minItems - created.length }, () => null)] : created
-    const maximum = IsNumber(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum
-    const casted = maximum.map((value: unknown) => Visit(schema.items, references, value))
-    if (schema.uniqueItems !== true) return casted
-    const unique = [...new Set(casted)]
-    if (!ValueCheck.Check(schema, references, unique)) throw new ValueCastArrayUniqueItemsTypeError(schema, unique)
-    return unique
-  }
-  function BigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-  }
-  function Boolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-  }
-  function Constructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): any {
-    if (ValueCheck.Check(schema, references, value)) return ValueCreate.Create(schema, references)
-    const required = new Set(schema.returns.required || [])
-    const result = function () {}
-    for (const [key, property] of globalThis.Object.entries(schema.returns.properties)) {
-      if (!required.has(key) && value.prototype[key] === undefined) continue
-      result.prototype[key] = Visit(property as Types.TSchema, references, value.prototype[key])
-    }
-    return result
-  }
-  function Date(schema: Types.TDate, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-  }
-  function Function(schema: Types.TFunction, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-  }
-  function Integer(schema: Types.TInteger, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-  }
-  function Intersect(schema: Types.TIntersect, references: Types.TSchema[], value: any): any {
-    const created = ValueCreate.Create(schema, references)
-    const mapped = IsObject(created) && IsObject(value) ? { ...(created as any), ...value } : value
-    return ValueCheck.Check(schema, references, mapped) ? mapped : ValueCreate.Create(schema, references)
-  }
-  function Literal(schema: Types.TLiteral, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-  }
-  function Never(schema: Types.TNever, references: Types.TSchema[], value: any): any {
-    throw new ValueCastNeverTypeError(schema)
-  }
-  function Not(schema: Types.TNot, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-  }
-  function Null(schema: Types.TNull, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-  }
-  function Number(schema: Types.TNumber, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-  }
-  function Object(schema: Types.TObject, references: Types.TSchema[], value: any): any {
-    if (ValueCheck.Check(schema, references, value)) return value
-    if (value === null || typeof value !== 'object') return ValueCreate.Create(schema, references)
-    const required = new Set(schema.required || [])
-    const result = {} as Record<string, any>
-    for (const [key, property] of globalThis.Object.entries(schema.properties)) {
-      if (!required.has(key) && value[key] === undefined) continue
-      result[key] = Visit(property, references, value[key])
-    }
-    // additional schema properties
-    if (typeof schema.additionalProperties === 'object') {
-      const propertyNames = globalThis.Object.getOwnPropertyNames(schema.properties)
-      for (const propertyName of globalThis.Object.getOwnPropertyNames(value)) {
-        if (propertyNames.includes(propertyName)) continue
-        result[propertyName] = Visit(schema.additionalProperties, references, value[propertyName])
-      }
-    }
-    return result
-  }
-  function Promise(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-  }
-  function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): any {
-    if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
-    if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value) || value instanceof globalThis.Date) return ValueCreate.Create(schema, references)
-    const subschemaPropertyName = globalThis.Object.getOwnPropertyNames(schema.patternProperties)[0]
-    const subschema = schema.patternProperties[subschemaPropertyName]
-    const result = {} as Record<string, any>
-    for (const [propKey, propValue] of globalThis.Object.entries(value)) {
-      result[propKey] = Visit(subschema, references, propValue)
-    }
-    return result
-  }
-  function Ref(schema: Types.TRef<any>, references: Types.TSchema[], value: any): any {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-    if (index === -1) throw new ValueCastDereferenceError(schema)
-    const target = references[index]
-    return Visit(target, references, value)
-  }
-  function String(schema: Types.TString, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-  }
-  function Symbol(schema: Types.TSymbol, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-  }
-  function TemplateLiteral(schema: Types.TSymbol, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-  }
-  function This(schema: Types.TThis, references: Types.TSchema[], value: any): any {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-    if (index === -1) throw new ValueCastDereferenceError(schema)
-    const target = references[index]
-    return Visit(target, references, value)
-  }
-  function Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): any {
-    if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
-    if (!globalThis.Array.isArray(value)) return ValueCreate.Create(schema, references)
-    if (schema.items === undefined) return []
-    return schema.items.map((schema, index) => Visit(schema, references, value[index]))
-  }
-  function Undefined(schema: Types.TUndefined, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-  }
-  function Union(schema: Types.TUnion, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : UnionCastCreate.Create(schema, references, value)
-  }
-  function Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-  }
-  function Unknown(schema: Types.TUnknown, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-  }
-  function Void(schema: Types.TVoid, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-  }
-  function UserDefined(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-  }
-  export function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
-    const references_ = IsString(schema.$id) ? [...references, schema] : references
-    const schema_ = schema as any
-    switch (schema[Types.Kind]) {
-      case 'Any':
-        return Any(schema_, references_, value)
-      case 'Array':
-        return Array(schema_, references_, value)
-      case 'BigInt':
-        return BigInt(schema_, references_, value)
-      case 'Boolean':
-        return Boolean(schema_, references_, value)
-      case 'Constructor':
-        return Constructor(schema_, references_, value)
-      case 'Date':
-        return Date(schema_, references_, value)
-      case 'Function':
-        return Function(schema_, references_, value)
-      case 'Integer':
-        return Integer(schema_, references_, value)
-      case 'Intersect':
-        return Intersect(schema_, references_, value)
-      case 'Literal':
-        return Literal(schema_, references_, value)
-      case 'Never':
-        return Never(schema_, references_, value)
-      case 'Not':
-        return Not(schema_, references_, value)
-      case 'Null':
-        return Null(schema_, references_, value)
-      case 'Number':
-        return Number(schema_, references_, value)
-      case 'Object':
-        return Object(schema_, references_, value)
-      case 'Promise':
-        return Promise(schema_, references_, value)
-      case 'Record':
-        return Record(schema_, references_, value)
-      case 'Ref':
-        return Ref(schema_, references_, value)
-      case 'String':
-        return String(schema_, references_, value)
-      case 'Symbol':
-        return Symbol(schema_, references_, value)
-      case 'TemplateLiteral':
-        return TemplateLiteral(schema_, references_, value)
-      case 'This':
-        return This(schema_, references_, value)
-      case 'Tuple':
-        return Tuple(schema_, references_, value)
-      case 'Undefined':
-        return Undefined(schema_, references_, value)
-      case 'Union':
-        return Union(schema_, references_, value)
-      case 'Uint8Array':
-        return Uint8Array(schema_, references_, value)
-      case 'Unknown':
-        return Unknown(schema_, references_, value)
-      case 'Void':
-        return Void(schema_, references_, value)
-      default:
-        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueCastUnknownTypeError(schema_)
-        return UserDefined(schema_, references_, value)
+// --------------------------------------------------------------------------
+// Cast
+// --------------------------------------------------------------------------
+function TAny(schema: Types.TAny, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+}
+function TArray(schema: Types.TArray, references: Types.TSchema[], value: any): any {
+  if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
+  const created = ValueGuard.IsArray(value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+  const minimum = ValueGuard.IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...Array.from({ length: schema.minItems - created.length }, () => null)] : created
+  const maximum = ValueGuard.IsNumber(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum
+  const casted = maximum.map((value: unknown) => Visit(schema.items, references, value))
+  if (schema.uniqueItems !== true) return casted
+  const unique = [...new Set(casted)]
+  if (!ValueCheck.Check(schema, references, unique)) throw new ValueCastArrayUniqueItemsTypeError(schema, unique)
+  return unique
+}
+function TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+}
+function TBigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+}
+function TBoolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+}
+function TConstructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): any {
+  if (ValueCheck.Check(schema, references, value)) return ValueCreate.Create(schema, references)
+  const required = new Set(schema.returns.required || [])
+  const result = function () {}
+  for (const [key, property] of Object.entries(schema.returns.properties)) {
+    if (!required.has(key) && value.prototype[key] === undefined) continue
+    result.prototype[key] = Visit(property as Types.TSchema, references, value.prototype[key])
+  }
+  return result
+}
+function TDate(schema: Types.TDate, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+}
+function TFunction(schema: Types.TFunction, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+}
+function TInteger(schema: Types.TInteger, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+}
+function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any): any {
+  const created = ValueCreate.Create(schema, references)
+  const mapped = ValueGuard.IsPlainObject(created) && ValueGuard.IsPlainObject(value) ? { ...(created as any), ...value } : value
+  return ValueCheck.Check(schema, references, mapped) ? mapped : ValueCreate.Create(schema, references)
+}
+function TIterator(schema: Types.TIterator, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+}
+function TLiteral(schema: Types.TLiteral, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+}
+function TNever(schema: Types.TNever, references: Types.TSchema[], value: any): any {
+  throw new ValueCastNeverTypeError(schema)
+}
+function TNot(schema: Types.TNot, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+}
+function TNull(schema: Types.TNull, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+}
+function TNumber(schema: Types.TNumber, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+}
+function TObject(schema: Types.TObject, references: Types.TSchema[], value: any): any {
+  if (ValueCheck.Check(schema, references, value)) return value
+  if (value === null || typeof value !== 'object') return ValueCreate.Create(schema, references)
+  const required = new Set(schema.required || [])
+  const result = {} as Record<string, any>
+  for (const [key, property] of Object.entries(schema.properties)) {
+    if (!required.has(key) && value[key] === undefined) continue
+    result[key] = Visit(property, references, value[key])
+  }
+  // additional schema properties
+  if (typeof schema.additionalProperties === 'object') {
+    const propertyNames = Object.getOwnPropertyNames(schema.properties)
+    for (const propertyName of Object.getOwnPropertyNames(value)) {
+      if (propertyNames.includes(propertyName)) continue
+      result[propertyName] = Visit(schema.additionalProperties, references, value[propertyName])
     }
   }
-  export function Cast<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): Types.Static<T> {
-    return Visit(schema, references, ValueClone.Clone(value))
+  return result
+}
+function TPromise(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+}
+function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): any {
+  if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
+  if (value === null || typeof value !== 'object' || Array.isArray(value) || value instanceof Date) return ValueCreate.Create(schema, references)
+  const subschemaPropertyName = Object.getOwnPropertyNames(schema.patternProperties)[0]
+  const subschema = schema.patternProperties[subschemaPropertyName]
+  const result = {} as Record<string, any>
+  for (const [propKey, propValue] of Object.entries(value)) {
+    result[propKey] = Visit(subschema, references, propValue)
+  }
+  return result
+}
+function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any): any {
+  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+  if (index === -1) throw new ValueCastDereferenceError(schema)
+  const target = references[index]
+  return Visit(target, references, value)
+}
+function TString(schema: Types.TString, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+}
+function TSymbol(schema: Types.TSymbol, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+}
+function TTemplateLiteral(schema: Types.TSymbol, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+}
+function TThis(schema: Types.TThis, references: Types.TSchema[], value: any): any {
+  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+  if (index === -1) throw new ValueCastDereferenceError(schema)
+  const target = references[index]
+  return Visit(target, references, value)
+}
+function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): any {
+  if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
+  if (!ValueGuard.IsArray(value)) return ValueCreate.Create(schema, references)
+  if (schema.items === undefined) return []
+  return schema.items.map((schema, index) => Visit(schema, references, value[index]))
+}
+function TUndefined(schema: Types.TUndefined, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+}
+function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : UnionCastCreate.Create(schema, references, value)
+}
+function TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+}
+function TUnknown(schema: Types.TUnknown, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+}
+function TVoid(schema: Types.TVoid, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+}
+function TKind(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
+  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+}
+function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
+  const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references
+  const schema_ = schema as any
+  switch (schema[Types.Kind]) {
+    case 'Any':
+      return TAny(schema_, references_, value)
+    case 'Array':
+      return TArray(schema_, references_, value)
+    case 'AsyncIterator':
+      return TAsyncIterator(schema_, references_, value)
+    case 'BigInt':
+      return TBigInt(schema_, references_, value)
+    case 'Boolean':
+      return TBoolean(schema_, references_, value)
+    case 'Constructor':
+      return TConstructor(schema_, references_, value)
+    case 'Date':
+      return TDate(schema_, references_, value)
+    case 'Function':
+      return TFunction(schema_, references_, value)
+    case 'Integer':
+      return TInteger(schema_, references_, value)
+    case 'Intersect':
+      return TIntersect(schema_, references_, value)
+    case 'Iterator':
+      return TIterator(schema_, references_, value)
+    case 'Literal':
+      return TLiteral(schema_, references_, value)
+    case 'Never':
+      return TNever(schema_, references_, value)
+    case 'Not':
+      return TNot(schema_, references_, value)
+    case 'Null':
+      return TNull(schema_, references_, value)
+    case 'Number':
+      return TNumber(schema_, references_, value)
+    case 'Object':
+      return TObject(schema_, references_, value)
+    case 'Promise':
+      return TPromise(schema_, references_, value)
+    case 'Record':
+      return TRecord(schema_, references_, value)
+    case 'Ref':
+      return TRef(schema_, references_, value)
+    case 'String':
+      return TString(schema_, references_, value)
+    case 'Symbol':
+      return TSymbol(schema_, references_, value)
+    case 'TemplateLiteral':
+      return TTemplateLiteral(schema_, references_, value)
+    case 'This':
+      return TThis(schema_, references_, value)
+    case 'Tuple':
+      return TTuple(schema_, references_, value)
+    case 'Undefined':
+      return TUndefined(schema_, references_, value)
+    case 'Union':
+      return TUnion(schema_, references_, value)
+    case 'Uint8Array':
+      return TUint8Array(schema_, references_, value)
+    case 'Unknown':
+      return TUnknown(schema_, references_, value)
+    case 'Void':
+      return TVoid(schema_, references_, value)
+    default:
+      if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueCastUnknownTypeError(schema_)
+      return TKind(schema_, references_, value)
   }
 }
+// --------------------------------------------------------------------------
+// Cast
+// --------------------------------------------------------------------------
+/** Casts a value into a given type and references. The return value will retain as much information of the original value as possible. */
+export function Cast<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): Types.Static<T>
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
+export function Cast<T extends Types.TSchema>(schema: T, value: unknown): Types.Static<T>
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
+export function Cast(...args: any[]) {
+  return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1])
+}
diff --git a/src/value/check.ts b/src/value/check.ts
index a0458cb8f..624e08eda 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -26,13 +26,14 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import * as Types from '../typebox'
 import { TypeSystem } from '../system/index'
-import { ValueHash } from './hash'
+import * as Types from '../typebox'
+import * as ValueGuard from './guard'
+import * as ValueHash from './hash'
 
-// -------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 // Errors
-// -------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 export class ValueCheckUnknownTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
     super(`ValueCheck: ${schema[Types.Kind] ? `Unknown type '${schema[Types.Kind]}'` : 'Unknown type'}`)
@@ -40,423 +41,445 @@ export class ValueCheckUnknownTypeError extends Error {
 }
 export class ValueCheckDereferenceError extends Error {
   constructor(public readonly schema: Types.TRef | Types.TThis) {
-    super(`ValueCheck: Unable to dereference schema with $id '${schema.$ref}'`)
+    super(`ValueCheck: Unable to dereference type with $id '${schema.$ref}'`)
   }
 }
-export namespace ValueCheck {
-  // ----------------------------------------------------------------------
-  // Guards
-  // ----------------------------------------------------------------------
-  function IsBigInt(value: unknown): value is bigint {
-    return typeof value === 'bigint'
+// --------------------------------------------------------------------------
+// TypeGuards
+// --------------------------------------------------------------------------
+function IsAnyOrUnknown(schema: Types.TSchema) {
+  return schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown'
+}
+// --------------------------------------------------------------------------
+// Guards
+// --------------------------------------------------------------------------
+function IsDefined<T>(value: unknown): value is T {
+  return value !== undefined
+}
+// --------------------------------------------------------------------------
+// Policies
+// --------------------------------------------------------------------------
+function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string) {
+  return TypeSystem.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined
+}
+function IsObject(value: unknown): value is Record<keyof any, unknown> {
+  const isObject = ValueGuard.IsObject(value)
+  return TypeSystem.AllowArrayObjects ? isObject : isObject && !ValueGuard.IsArray(value)
+}
+function IsRecordObject(value: unknown): value is Record<keyof any, unknown> {
+  return IsObject(value) && !(value instanceof Date) && !(value instanceof Uint8Array)
+}
+function IsNumber(value: unknown): value is number {
+  const isNumber = ValueGuard.IsNumber(value)
+  return TypeSystem.AllowNaN ? isNumber : isNumber && Number.isFinite(value)
+}
+function IsVoid(value: unknown): value is void {
+  const isUndefined = ValueGuard.IsUndefined(value)
+  return TypeSystem.AllowVoidNull ? isUndefined || value === null : isUndefined
+}
+// --------------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------------
+function TAny(schema: Types.TAny, references: Types.TSchema[], value: any): boolean {
+  return true
+}
+function TArray(schema: Types.TArray, references: Types.TSchema[], value: any): boolean {
+  if (!Array.isArray(value)) {
+    return false
   }
-  function IsInteger(value: unknown): value is number {
-    return globalThis.Number.isInteger(value)
+  if (IsDefined<number>(schema.minItems) && !(value.length >= schema.minItems)) {
+    return false
   }
-  function IsString(value: unknown): value is string {
-    return typeof value === 'string'
+  if (IsDefined<number>(schema.maxItems) && !(value.length <= schema.maxItems)) {
+    return false
   }
-  function IsDefined<T>(value: unknown): value is T {
-    return value !== undefined
+  if (!value.every((value) => Visit(schema.items, references, value))) {
+    return false
   }
-  // ----------------------------------------------------------------------
-  // SchemaGuards
-  // ----------------------------------------------------------------------
-  function IsAnyOrUnknown(schema: Types.TSchema) {
-    return schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown'
+  // prettier-ignore
+  if (schema.uniqueItems === true && !((function() { const set = new Set(); for(const element of value) { const hashed = ValueHash.Hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())) {
+      return false
+    }
+  // contains
+  if (!(IsDefined(schema.contains) || IsNumber(schema.minContains) || IsNumber(schema.maxContains))) {
+    return true // exit
   }
-  // ----------------------------------------------------------------------
-  // Policies
-  // ----------------------------------------------------------------------
-  function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string) {
-    return TypeSystem.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined
+  const containsSchema = IsDefined<Types.TSchema>(schema.contains) ? schema.contains : Types.Type.Never()
+  const containsCount = value.reduce((acc, value) => (Visit(containsSchema, references, value) ? acc + 1 : acc), 0)
+  if (containsCount === 0) {
+    return false
   }
-  function IsObject(value: unknown): value is Record<keyof any, unknown> {
-    const result = typeof value === 'object' && value !== null
-    return TypeSystem.AllowArrayObjects ? result : result && !globalThis.Array.isArray(value)
+  if (IsNumber(schema.minContains) && containsCount < schema.minContains) {
+    return false
   }
-  function IsRecordObject(value: unknown): value is Record<keyof any, unknown> {
-    return IsObject(value) && !(value instanceof globalThis.Date) && !(value instanceof globalThis.Uint8Array)
+  if (IsNumber(schema.maxContains) && containsCount > schema.maxContains) {
+    return false
   }
-  function IsNumber(value: unknown): value is number {
-    const result = typeof value === 'number'
-    return TypeSystem.AllowNaN ? result : result && globalThis.Number.isFinite(value)
+  return true
+}
+function TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[], value: any): boolean {
+  return IsObject(value) && Symbol.asyncIterator in value
+}
+function TBigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any): boolean {
+  if (!ValueGuard.IsBigInt(value)) {
+    return false
   }
-  function IsVoid(value: unknown): value is void {
-    const result = value === undefined
-    return TypeSystem.AllowVoidNull ? result || value === null : result
+  if (IsDefined<bigint>(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) {
+    return false
   }
-  // ----------------------------------------------------------------------
-  // Types
-  // ----------------------------------------------------------------------
-  function Any(schema: Types.TAny, references: Types.TSchema[], value: any): boolean {
-    return true
+  if (IsDefined<bigint>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+    return false
   }
-  function Array(schema: Types.TArray, references: Types.TSchema[], value: any): boolean {
-    if (!globalThis.Array.isArray(value)) {
-      return false
-    }
-    if (IsDefined<number>(schema.minItems) && !(value.length >= schema.minItems)) {
-      return false
-    }
-    if (IsDefined<number>(schema.maxItems) && !(value.length <= schema.maxItems)) {
-      return false
-    }
-    // prettier-ignore
-    if (schema.uniqueItems === true && !((function() { const set = new Set(); for(const element of value) { const hashed = ValueHash.Create(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())) {
-      return false
-    }
-    return value.every((value) => Visit(schema.items, references, value))
+  if (IsDefined<bigint>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    return false
   }
-  function BigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any): boolean {
-    if (!IsBigInt(value)) {
-      return false
-    }
-    if (IsDefined<bigint>(schema.multipleOf) && !(value % schema.multipleOf === globalThis.BigInt(0))) {
-      return false
-    }
-    if (IsDefined<bigint>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-      return false
-    }
-    if (IsDefined<bigint>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-      return false
-    }
-    if (IsDefined<bigint>(schema.minimum) && !(value >= schema.minimum)) {
-      return false
-    }
-    if (IsDefined<bigint>(schema.maximum) && !(value <= schema.maximum)) {
-      return false
-    }
-    return true
+  if (IsDefined<bigint>(schema.minimum) && !(value >= schema.minimum)) {
+    return false
   }
-  function Boolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): boolean {
-    return typeof value === 'boolean'
+  if (IsDefined<bigint>(schema.maximum) && !(value <= schema.maximum)) {
+    return false
   }
-  function Constructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): boolean {
-    return Visit(schema.returns, references, value.prototype)
+  return true
+}
+function TBoolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): boolean {
+  return typeof value === 'boolean'
+}
+function TConstructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): boolean {
+  return Visit(schema.returns, references, value.prototype)
+}
+function TDate(schema: Types.TDate, references: Types.TSchema[], value: any): boolean {
+  if (!(value instanceof Date)) {
+    return false
   }
-  function Date(schema: Types.TDate, references: Types.TSchema[], value: any): boolean {
-    if (!(value instanceof globalThis.Date)) {
-      return false
-    }
-    if (!IsNumber(value.getTime())) {
-      return false
-    }
-    if (IsDefined<number>(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
-      return false
-    }
-    if (IsDefined<number>(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
-      return false
-    }
-    if (IsDefined<number>(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
-      return false
-    }
-    if (IsDefined<number>(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
-      return false
-    }
-    return true
+  if (!IsNumber(value.getTime())) {
+    return false
   }
-  function Function(schema: Types.TFunction, references: Types.TSchema[], value: any): boolean {
-    return typeof value === 'function'
+  if (IsDefined<number>(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
+    return false
   }
-  function Integer(schema: Types.TInteger, references: Types.TSchema[], value: any): boolean {
-    if (!IsInteger(value)) {
-      return false
-    }
-    if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-      return false
-    }
-    if (IsDefined<number>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-      return false
-    }
-    if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-      return false
-    }
-    if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
-      return false
-    }
-    if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
-      return false
-    }
-    return true
+  if (IsDefined<number>(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+    return false
   }
-  function Intersect(schema: Types.TIntersect, references: Types.TSchema[], value: any): boolean {
-    const check1 = schema.allOf.every((schema) => Visit(schema, references, value))
-    if (schema.unevaluatedProperties === false) {
-      const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema))
-      const check2 = globalThis.Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key))
-      return check1 && check2
-    } else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
-      const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema))
-      const check2 = globalThis.Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key) || Visit(schema.unevaluatedProperties as Types.TSchema, references, value[key]))
-      return check1 && check2
-    } else {
-      return check1
-    }
+  if (IsDefined<number>(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
+    return false
   }
-  function Literal(schema: Types.TLiteral, references: Types.TSchema[], value: any): boolean {
-    return value === schema.const
+  if (IsDefined<number>(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
+    return false
   }
-  function Never(schema: Types.TNever, references: Types.TSchema[], value: any): boolean {
+  return true
+}
+function TFunction(schema: Types.TFunction, references: Types.TSchema[], value: any): boolean {
+  return typeof value === 'function'
+}
+function TInteger(schema: Types.TInteger, references: Types.TSchema[], value: any): boolean {
+  if (!ValueGuard.IsInteger(value)) {
     return false
   }
-  function Not(schema: Types.TNot, references: Types.TSchema[], value: any): boolean {
-    return !Visit(schema.not, references, value)
+  if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    return false
   }
-  function Null(schema: Types.TNull, references: Types.TSchema[], value: any): boolean {
-    return value === null
+  if (IsDefined<number>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+    return false
   }
-  function Number(schema: Types.TNumber, references: Types.TSchema[], value: any): boolean {
-    if (!IsNumber(value)) {
-      return false
-    }
-    if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-      return false
-    }
-    if (IsDefined<number>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-      return false
-    }
-    if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-      return false
-    }
-    if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
-      return false
-    }
-    if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
-      return false
-    }
-    return true
+  if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    return false
   }
-  function Object(schema: Types.TObject, references: Types.TSchema[], value: any): boolean {
-    if (!IsObject(value)) {
-      return false
-    }
-    if (IsDefined<number>(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-      return false
-    }
-    if (IsDefined<number>(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-      return false
-    }
-    const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties)
-    for (const knownKey of knownKeys) {
-      const property = schema.properties[knownKey]
-      if (schema.required && schema.required.includes(knownKey)) {
-        if (!Visit(property, references, value[knownKey])) {
-          return false
-        }
-        if ((Types.ExtendsUndefined.Check(property) || IsAnyOrUnknown(property)) && !(knownKey in value)) {
-          return false
-        }
-      } else {
-        if (IsExactOptionalProperty(value, knownKey) && !Visit(property, references, value[knownKey])) {
-          return false
-        }
-      }
-    }
-    if (schema.additionalProperties === false) {
-      const valueKeys = globalThis.Object.getOwnPropertyNames(value)
-      // optimization: value is valid if schemaKey length matches the valueKey length
-      if (schema.required && schema.required.length === knownKeys.length && valueKeys.length === knownKeys.length) {
-        return true
-      } else {
-        return valueKeys.every((valueKey) => knownKeys.includes(valueKey))
-      }
-    } else if (typeof schema.additionalProperties === 'object') {
-      const valueKeys = globalThis.Object.getOwnPropertyNames(value)
-      return valueKeys.every((key) => knownKeys.includes(key) || Visit(schema.additionalProperties as Types.TSchema, references, value[key]))
-    } else {
-      return true
-    }
+  if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
+    return false
   }
-  function Promise(schema: Types.TPromise<any>, references: Types.TSchema[], value: any): boolean {
-    return typeof value === 'object' && typeof value.then === 'function'
+  if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
+    return false
   }
-  function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): boolean {
-    if (!IsRecordObject(value)) {
-      return false
-    }
-    if (IsDefined<number>(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-      return false
-    }
-    if (IsDefined<number>(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-      return false
-    }
-    const [patternKey, patternSchema] = globalThis.Object.entries(schema.patternProperties)[0]
-    const regex = new RegExp(patternKey)
-    return globalThis.Object.entries(value).every(([key, value]) => {
-      if (regex.test(key)) {
-        return Visit(patternSchema, references, value)
+  return true
+}
+function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any): boolean {
+  const check1 = schema.allOf.every((schema) => Visit(schema, references, value))
+  if (schema.unevaluatedProperties === false) {
+    const keyPattern = new RegExp(Types.KeyResolver.ResolvePattern(schema))
+    const check2 = Object.getOwnPropertyNames(value).every((key) => keyPattern.test(key))
+    return check1 && check2
+  } else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
+    const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema))
+    const check2 = Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key) || Visit(schema.unevaluatedProperties as Types.TSchema, references, value[key]))
+    return check1 && check2
+  } else {
+    return check1
+  }
+}
+function TIterator(schema: Types.TIterator, references: Types.TSchema[], value: any): boolean {
+  return IsObject(value) && Symbol.iterator in value
+}
+function TLiteral(schema: Types.TLiteral, references: Types.TSchema[], value: any): boolean {
+  return value === schema.const
+}
+function TNever(schema: Types.TNever, references: Types.TSchema[], value: any): boolean {
+  return false
+}
+function TNot(schema: Types.TNot, references: Types.TSchema[], value: any): boolean {
+  return !Visit(schema.not, references, value)
+}
+function TNull(schema: Types.TNull, references: Types.TSchema[], value: any): boolean {
+  return value === null
+}
+function TNumber(schema: Types.TNumber, references: Types.TSchema[], value: any): boolean {
+  if (!IsNumber(value)) {
+    return false
+  }
+  if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    return false
+  }
+  if (IsDefined<number>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+    return false
+  }
+  if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    return false
+  }
+  if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
+    return false
+  }
+  if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
+    return false
+  }
+  return true
+}
+function TObject(schema: Types.TObject, references: Types.TSchema[], value: any): boolean {
+  if (!IsObject(value)) {
+    return false
+  }
+  if (IsDefined<number>(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+    return false
+  }
+  if (IsDefined<number>(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+    return false
+  }
+  const knownKeys = Object.getOwnPropertyNames(schema.properties)
+  for (const knownKey of knownKeys) {
+    const property = schema.properties[knownKey]
+    if (schema.required && schema.required.includes(knownKey)) {
+      if (!Visit(property, references, value[knownKey])) {
+        return false
       }
-      if (typeof schema.additionalProperties === 'object') {
-        return Visit(schema.additionalProperties, references, value)
+      if ((Types.ExtendsUndefined.Check(property) || IsAnyOrUnknown(property)) && !(knownKey in value)) {
+        return false
       }
-      if (schema.additionalProperties === false) {
+    } else {
+      if (IsExactOptionalProperty(value, knownKey) && !Visit(property, references, value[knownKey])) {
         return false
       }
-      return true
-    })
-  }
-  function Ref(schema: Types.TRef<any>, references: Types.TSchema[], value: any): boolean {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-    if (index === -1) throw new ValueCheckDereferenceError(schema)
-    const target = references[index]
-    return Visit(target, references, value)
-  }
-  function String(schema: Types.TString, references: Types.TSchema[], value: any): boolean {
-    if (!IsString(value)) {
-      return false
-    }
-    if (IsDefined<number>(schema.minLength)) {
-      if (!(value.length >= schema.minLength)) return false
     }
-    if (IsDefined<number>(schema.maxLength)) {
-      if (!(value.length <= schema.maxLength)) return false
-    }
-    if (IsDefined<string>(schema.pattern)) {
-      const regex = new RegExp(schema.pattern)
-      if (!regex.test(value)) return false
-    }
-    if (IsDefined<string>(schema.format)) {
-      if (!Types.FormatRegistry.Has(schema.format)) return false
-      const func = Types.FormatRegistry.Get(schema.format)!
-      return func(value)
-    }
-    return true
   }
-  function Symbol(schema: Types.TSymbol, references: Types.TSchema[], value: any): boolean {
-    if (!(typeof value === 'symbol')) {
-      return false
+  if (schema.additionalProperties === false) {
+    const valueKeys = Object.getOwnPropertyNames(value)
+    // optimization: value is valid if schemaKey length matches the valueKey length
+    if (schema.required && schema.required.length === knownKeys.length && valueKeys.length === knownKeys.length) {
+      return true
+    } else {
+      return valueKeys.every((valueKey) => knownKeys.includes(valueKey))
     }
+  } else if (typeof schema.additionalProperties === 'object') {
+    const valueKeys = Object.getOwnPropertyNames(value)
+    return valueKeys.every((key) => knownKeys.includes(key) || Visit(schema.additionalProperties as Types.TSchema, references, value[key]))
+  } else {
     return true
   }
-  function TemplateLiteral(schema: Types.TTemplateLiteralKind, references: Types.TSchema[], value: any): boolean {
-    if (!IsString(value)) {
-      return false
-    }
-    return new RegExp(schema.pattern).test(value)
+}
+function TPromise(schema: Types.TPromise<any>, references: Types.TSchema[], value: any): boolean {
+  return typeof value === 'object' && typeof value.then === 'function'
+}
+function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): boolean {
+  if (!IsRecordObject(value)) {
+    return false
+  }
+  if (IsDefined<number>(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+    return false
   }
-  function This(schema: Types.TThis, references: Types.TSchema[], value: any): boolean {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-    if (index === -1) throw new ValueCheckDereferenceError(schema)
-    const target = references[index]
-    return Visit(target, references, value)
+  if (IsDefined<number>(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+    return false
   }
-  function Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): boolean {
-    if (!globalThis.Array.isArray(value)) {
-      return false
+  const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0]
+  const regex = new RegExp(patternKey)
+  return Object.entries(value).every(([key, value]) => {
+    if (regex.test(key)) {
+      return Visit(patternSchema, references, value)
     }
-    if (schema.items === undefined && !(value.length === 0)) {
-      return false
+    if (typeof schema.additionalProperties === 'object') {
+      return Visit(schema.additionalProperties, references, value)
     }
-    if (!(value.length === schema.maxItems)) {
+    if (schema.additionalProperties === false) {
       return false
     }
-    if (!schema.items) {
-      return true
-    }
-    for (let i = 0; i < schema.items.length; i++) {
-      if (!Visit(schema.items[i], references, value[i])) return false
-    }
     return true
+  })
+}
+function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any): boolean {
+  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+  if (index === -1) throw new ValueCheckDereferenceError(schema)
+  const target = references[index]
+  return Visit(target, references, value)
+}
+function TString(schema: Types.TString, references: Types.TSchema[], value: any): boolean {
+  if (!ValueGuard.IsString(value)) {
+    return false
   }
-  function Undefined(schema: Types.TUndefined, references: Types.TSchema[], value: any): boolean {
-    return value === undefined
+  if (IsDefined<number>(schema.minLength)) {
+    if (!(value.length >= schema.minLength)) return false
   }
-  function Union(schema: Types.TUnion<any[]>, references: Types.TSchema[], value: any): boolean {
-    return schema.anyOf.some((inner) => Visit(inner, references, value))
+  if (IsDefined<number>(schema.maxLength)) {
+    if (!(value.length <= schema.maxLength)) return false
   }
-  function Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): boolean {
-    if (!(value instanceof globalThis.Uint8Array)) {
-      return false
-    }
-    if (IsDefined<number>(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
-      return false
-    }
-    if (IsDefined<number>(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
-      return false
-    }
-    return true
+  if (IsDefined<string>(schema.pattern)) {
+    const regex = new RegExp(schema.pattern)
+    if (!regex.test(value)) return false
   }
-  function Unknown(schema: Types.TUnknown, references: Types.TSchema[], value: any): boolean {
+  if (IsDefined<string>(schema.format)) {
+    if (!Types.FormatRegistry.Has(schema.format)) return false
+    const func = Types.FormatRegistry.Get(schema.format)!
+    return func(value)
+  }
+  return true
+}
+function TSymbol(schema: Types.TSymbol, references: Types.TSchema[], value: any): boolean {
+  if (!(typeof value === 'symbol')) {
+    return false
+  }
+  return true
+}
+function TTemplateLiteral(schema: Types.TTemplateLiteralKind, references: Types.TSchema[], value: any): boolean {
+  if (!ValueGuard.IsString(value)) {
+    return false
+  }
+  return new RegExp(schema.pattern).test(value)
+}
+function TThis(schema: Types.TThis, references: Types.TSchema[], value: any): boolean {
+  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+  if (index === -1) throw new ValueCheckDereferenceError(schema)
+  const target = references[index]
+  return Visit(target, references, value)
+}
+function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): boolean {
+  if (!ValueGuard.IsArray(value)) {
+    return false
+  }
+  if (schema.items === undefined && !(value.length === 0)) {
+    return false
+  }
+  if (!(value.length === schema.maxItems)) {
+    return false
+  }
+  if (!schema.items) {
     return true
   }
-  function Void(schema: Types.TVoid, references: Types.TSchema[], value: any): boolean {
-    return IsVoid(value)
-  }
-  function UserDefined(schema: Types.TSchema, references: Types.TSchema[], value: unknown): boolean {
-    if (!Types.TypeRegistry.Has(schema[Types.Kind])) return false
-    const func = Types.TypeRegistry.Get(schema[Types.Kind])!
-    return func(schema, value)
-  }
-  function Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): boolean {
-    const references_ = IsDefined<string>(schema.$id) ? [...references, schema] : references
-    const schema_ = schema as any
-    switch (schema_[Types.Kind]) {
-      case 'Any':
-        return Any(schema_, references_, value)
-      case 'Array':
-        return Array(schema_, references_, value)
-      case 'BigInt':
-        return BigInt(schema_, references_, value)
-      case 'Boolean':
-        return Boolean(schema_, references_, value)
-      case 'Constructor':
-        return Constructor(schema_, references_, value)
-      case 'Date':
-        return Date(schema_, references_, value)
-      case 'Function':
-        return Function(schema_, references_, value)
-      case 'Integer':
-        return Integer(schema_, references_, value)
-      case 'Intersect':
-        return Intersect(schema_, references_, value)
-      case 'Literal':
-        return Literal(schema_, references_, value)
-      case 'Never':
-        return Never(schema_, references_, value)
-      case 'Not':
-        return Not(schema_, references_, value)
-      case 'Null':
-        return Null(schema_, references_, value)
-      case 'Number':
-        return Number(schema_, references_, value)
-      case 'Object':
-        return Object(schema_, references_, value)
-      case 'Promise':
-        return Promise(schema_, references_, value)
-      case 'Record':
-        return Record(schema_, references_, value)
-      case 'Ref':
-        return Ref(schema_, references_, value)
-      case 'String':
-        return String(schema_, references_, value)
-      case 'Symbol':
-        return Symbol(schema_, references_, value)
-      case 'TemplateLiteral':
-        return TemplateLiteral(schema_, references_, value)
-      case 'This':
-        return This(schema_, references_, value)
-      case 'Tuple':
-        return Tuple(schema_, references_, value)
-      case 'Undefined':
-        return Undefined(schema_, references_, value)
-      case 'Union':
-        return Union(schema_, references_, value)
-      case 'Uint8Array':
-        return Uint8Array(schema_, references_, value)
-      case 'Unknown':
-        return Unknown(schema_, references_, value)
-      case 'Void':
-        return Void(schema_, references_, value)
-      default:
-        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueCheckUnknownTypeError(schema_)
-        return UserDefined(schema_, references_, value)
-    }
+  for (let i = 0; i < schema.items.length; i++) {
+    if (!Visit(schema.items[i], references, value[i])) return false
   }
-  // -------------------------------------------------------------------------
-  // Check
-  // -------------------------------------------------------------------------
-  export function Check<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): boolean {
-    return Visit(schema, references, value)
+  return true
+}
+function TUndefined(schema: Types.TUndefined, references: Types.TSchema[], value: any): boolean {
+  return value === undefined
+}
+function TUnion(schema: Types.TUnion<any[]>, references: Types.TSchema[], value: any): boolean {
+  return schema.anyOf.some((inner) => Visit(inner, references, value))
+}
+function TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): boolean {
+  if (!(value instanceof Uint8Array)) {
+    return false
+  }
+  if (IsDefined<number>(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
+    return false
+  }
+  if (IsDefined<number>(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
+    return false
   }
+  return true
+}
+function TUnknown(schema: Types.TUnknown, references: Types.TSchema[], value: any): boolean {
+  return true
+}
+function TVoid(schema: Types.TVoid, references: Types.TSchema[], value: any): boolean {
+  return IsVoid(value)
+}
+function TKind(schema: Types.TSchema, references: Types.TSchema[], value: unknown): boolean {
+  if (!Types.TypeRegistry.Has(schema[Types.Kind])) return false
+  const func = Types.TypeRegistry.Get(schema[Types.Kind])!
+  return func(schema, value)
+}
+function Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): boolean {
+  const references_ = IsDefined<string>(schema.$id) ? [...references, schema] : references
+  const schema_ = schema as any
+  switch (schema_[Types.Kind]) {
+    case 'Any':
+      return TAny(schema_, references_, value)
+    case 'Array':
+      return TArray(schema_, references_, value)
+    case 'AsyncIterator':
+      return TAsyncIterator(schema_, references_, value)
+    case 'BigInt':
+      return TBigInt(schema_, references_, value)
+    case 'Boolean':
+      return TBoolean(schema_, references_, value)
+    case 'Constructor':
+      return TConstructor(schema_, references_, value)
+    case 'Date':
+      return TDate(schema_, references_, value)
+    case 'Function':
+      return TFunction(schema_, references_, value)
+    case 'Integer':
+      return TInteger(schema_, references_, value)
+    case 'Intersect':
+      return TIntersect(schema_, references_, value)
+    case 'Iterator':
+      return TIterator(schema_, references_, value)
+    case 'Literal':
+      return TLiteral(schema_, references_, value)
+    case 'Never':
+      return TNever(schema_, references_, value)
+    case 'Not':
+      return TNot(schema_, references_, value)
+    case 'Null':
+      return TNull(schema_, references_, value)
+    case 'Number':
+      return TNumber(schema_, references_, value)
+    case 'Object':
+      return TObject(schema_, references_, value)
+    case 'Promise':
+      return TPromise(schema_, references_, value)
+    case 'Record':
+      return TRecord(schema_, references_, value)
+    case 'Ref':
+      return TRef(schema_, references_, value)
+    case 'String':
+      return TString(schema_, references_, value)
+    case 'Symbol':
+      return TSymbol(schema_, references_, value)
+    case 'TemplateLiteral':
+      return TTemplateLiteral(schema_, references_, value)
+    case 'This':
+      return TThis(schema_, references_, value)
+    case 'Tuple':
+      return TTuple(schema_, references_, value)
+    case 'Undefined':
+      return TUndefined(schema_, references_, value)
+    case 'Union':
+      return TUnion(schema_, references_, value)
+    case 'Uint8Array':
+      return TUint8Array(schema_, references_, value)
+    case 'Unknown':
+      return TUnknown(schema_, references_, value)
+    case 'Void':
+      return TVoid(schema_, references_, value)
+    default:
+      if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueCheckUnknownTypeError(schema_)
+      return TKind(schema_, references_, value)
+  }
+}
+// --------------------------------------------------------------------------
+// Check
+// --------------------------------------------------------------------------
+/** Returns true if the value matches the given type. */
+export function Check<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): value is Types.Static<T>
+/** Returns true if the value matches the given type. */
+export function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>
+/** Returns true if the value matches the given type. */
+export function Check(...args: any[]) {
+  return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1])
 }
diff --git a/src/value/clone.ts b/src/value/clone.ts
index e8d3d2185..ef1ecb51d 100644
--- a/src/value/clone.ts
+++ b/src/value/clone.ts
@@ -26,38 +26,55 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { Is, ObjectType, ArrayType, TypedArrayType, ValueType } from './is'
-
-export namespace ValueClone {
-  function Array(value: ArrayType): any {
-    return value.map((element: any) => Clone(element))
-  }
-  function Date(value: Date): any {
-    return new globalThis.Date(value.toISOString())
-  }
-  function Object(value: ObjectType): any {
-    const keys = [...globalThis.Object.keys(value), ...globalThis.Object.getOwnPropertySymbols(value)]
-    return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {})
-  }
-  function TypedArray(value: TypedArrayType): any {
-    return value.slice()
-  }
-  function Value(value: ValueType): any {
-    return value
-  }
-  export function Clone<T extends unknown>(value: T): T {
-    if (Is.Date(value)) {
-      return Date(value)
-    } else if (Is.Object(value)) {
-      return Object(value)
-    } else if (Is.Array(value)) {
-      return Array(value)
-    } else if (Is.TypedArray(value)) {
-      return TypedArray(value)
-    } else if (Is.Value(value)) {
-      return Value(value)
-    } else {
-      throw new Error('ValueClone: Unable to clone value')
-    }
-  }
+import * as ValueGuard from './guard'
+
+// --------------------------------------------------------------------------
+// Clonable
+// --------------------------------------------------------------------------
+function ObjectType(value: ValueGuard.ObjectType): any {
+  const keys = [...Object.getOwnPropertyNames(value), ...Object.getOwnPropertySymbols(value)]
+  return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {})
+}
+function ArrayType(value: ValueGuard.ArrayType): any {
+  return value.map((element: any) => Clone(element))
+}
+function TypedArrayType(value: ValueGuard.TypedArrayType): any {
+  return value.slice()
+}
+function DateType(value: Date): any {
+  return new Date(value.toISOString())
+}
+function ValueType(value: ValueGuard.ValueType): any {
+  return value
+}
+// --------------------------------------------------------------------------
+// Non-Clonable
+// --------------------------------------------------------------------------
+function AsyncIteratorType(value: AsyncIterableIterator<unknown>): any {
+  return value
+}
+function IteratorType(value: IterableIterator<unknown>): any {
+  return value
+}
+function FunctionType(value: Function): any {
+  return value
+}
+function PromiseType(value: Promise<unknown>): any {
+  return value
+}
+// --------------------------------------------------------------------------
+// Clone
+// --------------------------------------------------------------------------
+/** Returns a clone of the given value */
+export function Clone<T extends unknown>(value: T): T {
+  if (ValueGuard.IsArray(value)) return ArrayType(value)
+  if (ValueGuard.IsAsyncIterator(value)) return AsyncIteratorType(value)
+  if (ValueGuard.IsFunction(value)) return FunctionType(value)
+  if (ValueGuard.IsIterator(value)) return IteratorType(value)
+  if (ValueGuard.IsPromise(value)) return PromiseType(value)
+  if (ValueGuard.IsDate(value)) return DateType(value)
+  if (ValueGuard.IsPlainObject(value)) return ObjectType(value)
+  if (ValueGuard.IsTypedArray(value)) return TypedArrayType(value)
+  if (ValueGuard.IsValueType(value)) return ValueType(value)
+  throw new Error('ValueClone: Unable to clone value')
 }
diff --git a/src/value/convert.ts b/src/value/convert.ts
index 00f397b9b..c38be43e3 100644
--- a/src/value/convert.ts
+++ b/src/value/convert.ts
@@ -27,12 +27,13 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import * as Types from '../typebox'
-import { ValueClone } from './clone'
-import { ValueCheck } from './check'
+import * as ValueClone from './clone'
+import * as ValueCheck from './check'
+import * as ValueGuard from './guard'
 
-// ----------------------------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 // Errors
-// ----------------------------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 export class ValueConvertUnknownTypeError extends Error {
   constructor(public readonly schema: Types.TSchema) {
     super('ValueConvert: Unknown type')
@@ -40,320 +41,313 @@ export class ValueConvertUnknownTypeError extends Error {
 }
 export class ValueConvertDereferenceError extends Error {
   constructor(public readonly schema: Types.TRef | Types.TThis) {
-    super(`ValueConvert: Unable to dereference schema with $id '${schema.$ref}'`)
+    super(`ValueConvert: Unable to dereference type with $id '${schema.$ref}'`)
   }
 }
-export namespace ValueConvert {
-  // ----------------------------------------------------------------------------------------------
-  // Guards
-  // ----------------------------------------------------------------------------------------------
-  function IsObject(value: unknown): value is Record<keyof any, unknown> {
-    return typeof value === 'object' && value !== null && !globalThis.Array.isArray(value)
-  }
-  function IsArray(value: unknown): value is unknown[] {
-    return typeof value === 'object' && globalThis.Array.isArray(value)
-  }
-  function IsDate(value: unknown): value is Date {
-    return typeof value === 'object' && value instanceof globalThis.Date
-  }
-  function IsSymbol(value: unknown): value is symbol {
-    return typeof value === 'symbol'
-  }
-  function IsString(value: unknown): value is string {
-    return typeof value === 'string'
-  }
-  function IsBoolean(value: unknown): value is boolean {
-    return typeof value === 'boolean'
-  }
-  function IsBigInt(value: unknown): value is bigint {
-    return typeof value === 'bigint'
-  }
-  function IsNumber(value: unknown): value is number {
-    return typeof value === 'number' && !isNaN(value)
-  }
-  function IsStringNumeric(value: unknown): value is string {
-    return IsString(value) && !isNaN(value as any) && !isNaN(parseFloat(value))
-  }
-  function IsValueToString(value: unknown): value is { toString: () => string } {
-    return IsBigInt(value) || IsBoolean(value) || IsNumber(value)
-  }
-  function IsValueTrue(value: unknown): value is true {
-    return value === true || (IsNumber(value) && value === 1) || (IsBigInt(value) && value === globalThis.BigInt('1')) || (IsString(value) && (value.toLowerCase() === 'true' || value === '1'))
-  }
-  function IsValueFalse(value: unknown): value is true {
-    return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === globalThis.BigInt('0')) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'))
-  }
-  function IsTimeStringWithTimeZone(value: unknown): value is string {
-    return IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value)
-  }
-  function IsTimeStringWithoutTimeZone(value: unknown): value is string {
-    return IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value)
-  }
-  function IsDateTimeStringWithTimeZone(value: unknown): value is string {
-    return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value)
-  }
-  function IsDateTimeStringWithoutTimeZone(value: unknown): value is string {
-    return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value)
-  }
-  function IsDateString(value: unknown): value is string {
-    return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value)
-  }
-  // ----------------------------------------------------------------------------------------------
-  // Convert
-  // ----------------------------------------------------------------------------------------------
-  function TryConvertLiteralString(value: unknown, target: string) {
-    const conversion = TryConvertString(value)
-    return conversion === target ? conversion : value
-  }
-  function TryConvertLiteralNumber(value: unknown, target: number) {
-    const conversion = TryConvertNumber(value)
-    return conversion === target ? conversion : value
-  }
-  function TryConvertLiteralBoolean(value: unknown, target: boolean) {
-    const conversion = TryConvertBoolean(value)
-    return conversion === target ? conversion : value
-  }
-  function TryConvertLiteral(schema: Types.TLiteral, value: unknown) {
-    if (typeof schema.const === 'string') {
-      return TryConvertLiteralString(value, schema.const)
-    } else if (typeof schema.const === 'number') {
-      return TryConvertLiteralNumber(value, schema.const)
-    } else if (typeof schema.const === 'boolean') {
-      return TryConvertLiteralBoolean(value, schema.const)
-    } else {
-      return ValueClone.Clone(value)
-    }
-  }
-  function TryConvertBoolean(value: unknown) {
-    return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value
-  }
-  function TryConvertBigInt(value: unknown) {
-    return IsStringNumeric(value) ? globalThis.BigInt(parseInt(value)) : IsNumber(value) ? globalThis.BigInt(value | 0) : IsValueFalse(value) ? 0 : IsValueTrue(value) ? 1 : value
-  }
-  function TryConvertString(value: unknown) {
-    return IsValueToString(value) ? value.toString() : IsSymbol(value) && value.description !== undefined ? value.description.toString() : value
-  }
-  function TryConvertNumber(value: unknown) {
-    return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value
-  }
-  function TryConvertInteger(value: unknown) {
-    return IsStringNumeric(value) ? parseInt(value) : IsNumber(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value
-  }
-  function TryConvertNull(value: unknown) {
-    return IsString(value) && value.toLowerCase() === 'null' ? null : value
-  }
-  function TryConvertUndefined(value: unknown) {
-    return IsString(value) && value === 'undefined' ? undefined : value
-  }
-  function TryConvertDate(value: unknown) {
-    // note: this function may return an invalid dates for the regex tests
-    // above. Invalid dates will however be checked during the casting
-    // function and will return a epoch date if invalid. Consider better
-    // string parsing for the iso dates in future revisions.
-    return IsDate(value)
-      ? value
-      : IsNumber(value)
-      ? new globalThis.Date(value)
-      : IsValueTrue(value)
-      ? new globalThis.Date(1)
-      : IsValueFalse(value)
-      ? new globalThis.Date(0)
-      : IsStringNumeric(value)
-      ? new globalThis.Date(parseInt(value))
-      : IsTimeStringWithoutTimeZone(value)
-      ? new globalThis.Date(`1970-01-01T${value}.000Z`)
-      : IsTimeStringWithTimeZone(value)
-      ? new globalThis.Date(`1970-01-01T${value}`)
-      : IsDateTimeStringWithoutTimeZone(value)
-      ? new globalThis.Date(`${value}.000Z`)
-      : IsDateTimeStringWithTimeZone(value)
-      ? new globalThis.Date(value)
-      : IsDateString(value)
-      ? new globalThis.Date(`${value}T00:00:00.000Z`)
-      : value
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Cast
-  // ----------------------------------------------------------------------------------------------
-  function Any(schema: Types.TAny, references: Types.TSchema[], value: any): any {
-    return value
-  }
-  function Array(schema: Types.TArray, references: Types.TSchema[], value: any): any {
-    if (IsArray(value)) {
-      return value.map((value) => Visit(schema.items, references, value))
-    }
-    return value
-  }
-  function BigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any): unknown {
-    return TryConvertBigInt(value)
-  }
-  function Boolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): unknown {
-    return TryConvertBoolean(value)
-  }
-  function Constructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): unknown {
+// --------------------------------------------------------------------------
+// Conversions
+// --------------------------------------------------------------------------
+function IsStringNumeric(value: unknown): value is string {
+  return ValueGuard.IsString(value) && !isNaN(value as any) && !isNaN(parseFloat(value))
+}
+function IsValueToString(value: unknown): value is { toString: () => string } {
+  return ValueGuard.IsBigInt(value) || ValueGuard.IsBoolean(value) || ValueGuard.IsNumber(value)
+}
+function IsValueTrue(value: unknown): value is true {
+  return value === true || (ValueGuard.IsNumber(value) && value === 1) || (ValueGuard.IsBigInt(value) && value === BigInt('1')) || (ValueGuard.IsString(value) && (value.toLowerCase() === 'true' || value === '1'))
+}
+function IsValueFalse(value: unknown): value is false {
+  return value === false || (ValueGuard.IsNumber(value) && value === 0) || (ValueGuard.IsBigInt(value) && value === BigInt('0')) || (ValueGuard.IsString(value) && (value.toLowerCase() === 'false' || value === '0'))
+}
+function IsTimeStringWithTimeZone(value: unknown): value is string {
+  return ValueGuard.IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value)
+}
+function IsTimeStringWithoutTimeZone(value: unknown): value is string {
+  return ValueGuard.IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value)
+}
+function IsDateTimeStringWithTimeZone(value: unknown): value is string {
+  return ValueGuard.IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value)
+}
+function IsDateTimeStringWithoutTimeZone(value: unknown): value is string {
+  return ValueGuard.IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value)
+}
+function IsDateString(value: unknown): value is string {
+  return ValueGuard.IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value)
+}
+// --------------------------------------------------------------------------
+// Convert
+// --------------------------------------------------------------------------
+function TryConvertLiteralString(value: unknown, target: string) {
+  const conversion = TryConvertString(value)
+  return conversion === target ? conversion : value
+}
+function TryConvertLiteralNumber(value: unknown, target: number) {
+  const conversion = TryConvertNumber(value)
+  return conversion === target ? conversion : value
+}
+function TryConvertLiteralBoolean(value: unknown, target: boolean) {
+  const conversion = TryConvertBoolean(value)
+  return conversion === target ? conversion : value
+}
+function TryConvertLiteral(schema: Types.TLiteral, value: unknown) {
+  if (typeof schema.const === 'string') {
+    return TryConvertLiteralString(value, schema.const)
+  } else if (typeof schema.const === 'number') {
+    return TryConvertLiteralNumber(value, schema.const)
+  } else if (typeof schema.const === 'boolean') {
+    return TryConvertLiteralBoolean(value, schema.const)
+  } else {
     return ValueClone.Clone(value)
   }
-  function Date(schema: Types.TDate, references: Types.TSchema[], value: any): unknown {
-    return TryConvertDate(value)
-  }
-  function Function(schema: Types.TFunction, references: Types.TSchema[], value: any): unknown {
-    return value
-  }
-  function Integer(schema: Types.TInteger, references: Types.TSchema[], value: any): unknown {
-    return TryConvertInteger(value)
-  }
-  function Intersect(schema: Types.TIntersect, references: Types.TSchema[], value: any): unknown {
-    return value
-  }
-  function Literal(schema: Types.TLiteral, references: Types.TSchema[], value: any): unknown {
-    return TryConvertLiteral(schema, value)
-  }
-  function Never(schema: Types.TNever, references: Types.TSchema[], value: any): unknown {
-    return value
-  }
-  function Null(schema: Types.TNull, references: Types.TSchema[], value: any): unknown {
-    return TryConvertNull(value)
-  }
-  function Number(schema: Types.TNumber, references: Types.TSchema[], value: any): unknown {
-    return TryConvertNumber(value)
-  }
-  function Object(schema: Types.TObject, references: Types.TSchema[], value: any): unknown {
-    if (IsObject(value))
-      return globalThis.Object.keys(schema.properties).reduce((acc, key) => {
-        return value[key] !== undefined ? { ...acc, [key]: Visit(schema.properties[key], references, value[key]) } : { ...acc }
-      }, value)
-    return value
-  }
-  function Promise(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown {
-    return value
-  }
-  function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): unknown {
-    const propertyKey = globalThis.Object.getOwnPropertyNames(schema.patternProperties)[0]
-    const property = schema.patternProperties[propertyKey]
-    const result = {} as Record<string, unknown>
-    for (const [propKey, propValue] of globalThis.Object.entries(value)) {
-      result[propKey] = Visit(property, references, propValue)
-    }
-    return result
-  }
-  function Ref(schema: Types.TRef<any>, references: Types.TSchema[], value: any): unknown {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-    if (index === -1) throw new ValueConvertDereferenceError(schema)
-    const target = references[index]
-    return Visit(target, references, value)
-  }
-  function String(schema: Types.TString, references: Types.TSchema[], value: any): unknown {
-    return TryConvertString(value)
-  }
-  function Symbol(schema: Types.TSymbol, references: Types.TSchema[], value: any): unknown {
-    return value
-  }
-  function TemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[], value: any) {
-    return value
-  }
-  function This(schema: Types.TThis, references: Types.TSchema[], value: any): unknown {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-    if (index === -1) throw new ValueConvertDereferenceError(schema)
-    const target = references[index]
-    return Visit(target, references, value)
-  }
-  function Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): unknown {
-    if (IsArray(value) && schema.items !== undefined) {
-      return value.map((value, index) => {
-        return index < schema.items!.length ? Visit(schema.items![index], references, value) : value
-      })
-    }
-    return value
-  }
-  function Undefined(schema: Types.TUndefined, references: Types.TSchema[], value: any): unknown {
-    return TryConvertUndefined(value)
-  }
-  function Union(schema: Types.TUnion, references: Types.TSchema[], value: any): unknown {
-    for (const subschema of schema.anyOf) {
-      const converted = Visit(subschema, references, value)
-      if (ValueCheck.Check(subschema, references, converted)) {
-        return converted
-      }
-    }
-    return value
-  }
-  function Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): unknown {
-    return value
-  }
-  function Unknown(schema: Types.TUnknown, references: Types.TSchema[], value: any): unknown {
-    return value
-  }
-  function Void(schema: Types.TVoid, references: Types.TSchema[], value: any): unknown {
-    return value
+}
+function TryConvertBoolean(value: unknown) {
+  return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value
+}
+function TryConvertBigInt(value: unknown) {
+  return IsStringNumeric(value) ? BigInt(parseInt(value)) : ValueGuard.IsNumber(value) ? BigInt(value | 0) : IsValueFalse(value) ? 0 : IsValueTrue(value) ? 1 : value
+}
+function TryConvertString(value: unknown) {
+  return IsValueToString(value) ? value.toString() : ValueGuard.IsSymbol(value) && value.description !== undefined ? value.description.toString() : value
+}
+function TryConvertNumber(value: unknown) {
+  return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value
+}
+function TryConvertInteger(value: unknown) {
+  return IsStringNumeric(value) ? parseInt(value) : ValueGuard.IsNumber(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value
+}
+function TryConvertNull(value: unknown) {
+  return ValueGuard.IsString(value) && value.toLowerCase() === 'null' ? null : value
+}
+function TryConvertUndefined(value: unknown) {
+  return ValueGuard.IsString(value) && value === 'undefined' ? undefined : value
+}
+function TryConvertDate(value: unknown) {
+  // --------------------------------------------------------------------------
+  // note: this function may return an invalid dates for the regex tests
+  // above. Invalid dates will however be checked during the casting function
+  // and will return a epoch date if invalid. Consider better string parsing
+  // for the iso dates in future revisions.
+  // --------------------------------------------------------------------------
+  return ValueGuard.IsDate(value)
+    ? value
+    : ValueGuard.IsNumber(value)
+    ? new Date(value)
+    : IsValueTrue(value)
+    ? new Date(1)
+    : IsValueFalse(value)
+    ? new Date(0)
+    : IsStringNumeric(value)
+    ? new Date(parseInt(value))
+    : IsTimeStringWithoutTimeZone(value)
+    ? new Date(`1970-01-01T${value}.000Z`)
+    : IsTimeStringWithTimeZone(value)
+    ? new Date(`1970-01-01T${value}`)
+    : IsDateTimeStringWithoutTimeZone(value)
+    ? new Date(`${value}.000Z`)
+    : IsDateTimeStringWithTimeZone(value)
+    ? new Date(value)
+    : IsDateString(value)
+    ? new Date(`${value}T00:00:00.000Z`)
+    : value
+}
+// --------------------------------------------------------------------------
+// Cast
+// --------------------------------------------------------------------------
+function TAny(schema: Types.TAny, references: Types.TSchema[], value: any): any {
+  return value
+}
+function TArray(schema: Types.TArray, references: Types.TSchema[], value: any): any {
+  if (ValueGuard.IsArray(value)) {
+    return value.map((value) => Visit(schema.items, references, value))
   }
-  function UserDefined(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown {
-    return value
+  return value
+}
+function TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[], value: any): any {
+  return value
+}
+function TBigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any): unknown {
+  return TryConvertBigInt(value)
+}
+function TBoolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): unknown {
+  return TryConvertBoolean(value)
+}
+function TConstructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): unknown {
+  return ValueClone.Clone(value)
+}
+function TDate(schema: Types.TDate, references: Types.TSchema[], value: any): unknown {
+  return TryConvertDate(value)
+}
+function TFunction(schema: Types.TFunction, references: Types.TSchema[], value: any): unknown {
+  return value
+}
+function TInteger(schema: Types.TInteger, references: Types.TSchema[], value: any): unknown {
+  return TryConvertInteger(value)
+}
+function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any): unknown {
+  return value
+}
+function TIterator(schema: Types.TIterator, references: Types.TSchema[], value: any): unknown {
+  return value
+}
+function TLiteral(schema: Types.TLiteral, references: Types.TSchema[], value: any): unknown {
+  return TryConvertLiteral(schema, value)
+}
+function TNever(schema: Types.TNever, references: Types.TSchema[], value: any): unknown {
+  return value
+}
+function TNull(schema: Types.TNull, references: Types.TSchema[], value: any): unknown {
+  return TryConvertNull(value)
+}
+function TNumber(schema: Types.TNumber, references: Types.TSchema[], value: any): unknown {
+  return TryConvertNumber(value)
+}
+function TObject(schema: Types.TObject, references: Types.TSchema[], value: any): unknown {
+  if (ValueGuard.IsObject(value))
+    return Object.getOwnPropertyNames(schema.properties).reduce((acc, key) => {
+      return value[key] !== undefined ? { ...acc, [key]: Visit(schema.properties[key], references, value[key]) } : { ...acc }
+    }, value)
+  return value
+}
+function TPromise(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown {
+  return value
+}
+function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): unknown {
+  const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0]
+  const property = schema.patternProperties[propertyKey]
+  const result = {} as Record<string, unknown>
+  for (const [propKey, propValue] of Object.entries(value)) {
+    result[propKey] = Visit(property, references, propValue)
+  }
+  return result
+}
+function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any): unknown {
+  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+  if (index === -1) throw new ValueConvertDereferenceError(schema)
+  const target = references[index]
+  return Visit(target, references, value)
+}
+function TString(schema: Types.TString, references: Types.TSchema[], value: any): unknown {
+  return TryConvertString(value)
+}
+function TSymbol(schema: Types.TSymbol, references: Types.TSchema[], value: any): unknown {
+  return value
+}
+function TTemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[], value: any) {
+  return value
+}
+function TThis(schema: Types.TThis, references: Types.TSchema[], value: any): unknown {
+  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+  if (index === -1) throw new ValueConvertDereferenceError(schema)
+  const target = references[index]
+  return Visit(target, references, value)
+}
+function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): unknown {
+  if (ValueGuard.IsArray(value) && !ValueGuard.IsUndefined(schema.items)) {
+    return value.map((value, index) => {
+      return index < schema.items!.length ? Visit(schema.items![index], references, value) : value
+    })
   }
-  export function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown {
-    const references_ = IsString(schema.$id) ? [...references, schema] : references
-    const schema_ = schema as any
-    switch (schema[Types.Kind]) {
-      case 'Any':
-        return Any(schema_, references_, value)
-      case 'Array':
-        return Array(schema_, references_, value)
-      case 'BigInt':
-        return BigInt(schema_, references_, value)
-      case 'Boolean':
-        return Boolean(schema_, references_, value)
-      case 'Constructor':
-        return Constructor(schema_, references_, value)
-      case 'Date':
-        return Date(schema_, references_, value)
-      case 'Function':
-        return Function(schema_, references_, value)
-      case 'Integer':
-        return Integer(schema_, references_, value)
-      case 'Intersect':
-        return Intersect(schema_, references_, value)
-      case 'Literal':
-        return Literal(schema_, references_, value)
-      case 'Never':
-        return Never(schema_, references_, value)
-      case 'Null':
-        return Null(schema_, references_, value)
-      case 'Number':
-        return Number(schema_, references_, value)
-      case 'Object':
-        return Object(schema_, references_, value)
-      case 'Promise':
-        return Promise(schema_, references_, value)
-      case 'Record':
-        return Record(schema_, references_, value)
-      case 'Ref':
-        return Ref(schema_, references_, value)
-      case 'String':
-        return String(schema_, references_, value)
-      case 'Symbol':
-        return Symbol(schema_, references_, value)
-      case 'TemplateLiteral':
-        return TemplateLiteral(schema_, references_, value)
-      case 'This':
-        return This(schema_, references_, value)
-      case 'Tuple':
-        return Tuple(schema_, references_, value)
-      case 'Undefined':
-        return Undefined(schema_, references_, value)
-      case 'Union':
-        return Union(schema_, references_, value)
-      case 'Uint8Array':
-        return Uint8Array(schema_, references_, value)
-      case 'Unknown':
-        return Unknown(schema_, references_, value)
-      case 'Void':
-        return Void(schema_, references_, value)
-      default:
-        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueConvertUnknownTypeError(schema_)
-        return UserDefined(schema_, references_, value)
+  return value
+}
+function TUndefined(schema: Types.TUndefined, references: Types.TSchema[], value: any): unknown {
+  return TryConvertUndefined(value)
+}
+function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any): unknown {
+  for (const subschema of schema.anyOf) {
+    const converted = Visit(subschema, references, value)
+    if (ValueCheck.Check(subschema, references, converted)) {
+      return converted
     }
   }
-  export function Convert<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): unknown {
-    return Visit(schema, references, ValueClone.Clone(value))
+  return value
+}
+function TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): unknown {
+  return value
+}
+function TUnknown(schema: Types.TUnknown, references: Types.TSchema[], value: any): unknown {
+  return value
+}
+function TVoid(schema: Types.TVoid, references: Types.TSchema[], value: any): unknown {
+  return value
+}
+function TKind(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown {
+  return value
+}
+function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown {
+  const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references
+  const schema_ = schema as any
+  switch (schema[Types.Kind]) {
+    case 'Any':
+      return TAny(schema_, references_, value)
+    case 'Array':
+      return TArray(schema_, references_, value)
+    case 'AsyncIterator':
+      return TAsyncIterator(schema_, references_, value)
+    case 'BigInt':
+      return TBigInt(schema_, references_, value)
+    case 'Boolean':
+      return TBoolean(schema_, references_, value)
+    case 'Constructor':
+      return TConstructor(schema_, references_, value)
+    case 'Date':
+      return TDate(schema_, references_, value)
+    case 'Function':
+      return TFunction(schema_, references_, value)
+    case 'Integer':
+      return TInteger(schema_, references_, value)
+    case 'Intersect':
+      return TIntersect(schema_, references_, value)
+    case 'Iterator':
+      return TIterator(schema_, references_, value)
+    case 'Literal':
+      return TLiteral(schema_, references_, value)
+    case 'Never':
+      return TNever(schema_, references_, value)
+    case 'Null':
+      return TNull(schema_, references_, value)
+    case 'Number':
+      return TNumber(schema_, references_, value)
+    case 'Object':
+      return TObject(schema_, references_, value)
+    case 'Promise':
+      return TPromise(schema_, references_, value)
+    case 'Record':
+      return TRecord(schema_, references_, value)
+    case 'Ref':
+      return TRef(schema_, references_, value)
+    case 'String':
+      return TString(schema_, references_, value)
+    case 'Symbol':
+      return TSymbol(schema_, references_, value)
+    case 'TemplateLiteral':
+      return TTemplateLiteral(schema_, references_, value)
+    case 'This':
+      return TThis(schema_, references_, value)
+    case 'Tuple':
+      return TTuple(schema_, references_, value)
+    case 'Undefined':
+      return TUndefined(schema_, references_, value)
+    case 'Union':
+      return TUnion(schema_, references_, value)
+    case 'Uint8Array':
+      return TUint8Array(schema_, references_, value)
+    case 'Unknown':
+      return TUnknown(schema_, references_, value)
+    case 'Void':
+      return TVoid(schema_, references_, value)
+    default:
+      if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueConvertUnknownTypeError(schema_)
+      return TKind(schema_, references_, value)
   }
 }
+// --------------------------------------------------------------------------
+// Convert
+// --------------------------------------------------------------------------
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+export function Convert<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): unknown
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+export function Convert<T extends Types.TSchema>(schema: T, value: unknown): unknown
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+export function Convert(...args: any[]) {
+  return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1])
+}
diff --git a/src/value/create.ts b/src/value/create.ts
index 66973e3d4..a2387b6f1 100644
--- a/src/value/create.ts
+++ b/src/value/create.ts
@@ -27,7 +27,8 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import * as Types from '../typebox'
-import { ValueCheck } from './check'
+import * as ValueCheck from './check'
+import * as ValueGuard from './guard'
 
 // --------------------------------------------------------------------------
 // Errors
@@ -59,7 +60,7 @@ export class ValueCreateTempateLiteralTypeError extends Error {
 }
 export class ValueCreateDereferenceError extends Error {
   constructor(public readonly schema: Types.TRef | Types.TThis) {
-    super(`ValueCreate: Unable to dereference schema with $id '${schema.$ref}'`)
+    super(`ValueCreate: Unable to dereference type with $id '${schema.$ref}'`)
   }
 }
 export class ValueCreateRecursiveInstantiationError extends Error {
@@ -68,372 +69,386 @@ export class ValueCreateRecursiveInstantiationError extends Error {
   }
 }
 // --------------------------------------------------------------------------
-// ValueCreate
+// Types
 // --------------------------------------------------------------------------
-export namespace ValueCreate {
-  // --------------------------------------------------------
-  // Guards
-  // --------------------------------------------------------
-  function IsString(value: unknown): value is string {
-    return typeof value === 'string'
-  }
-  // --------------------------------------------------------
-  // Types
-  // --------------------------------------------------------
-  function Any(schema: Types.TAny, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else {
-      return {}
-    }
+function TAny(schema: Types.TAny, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    return {}
   }
-  function Array(schema: Types.TArray, references: Types.TSchema[]): any {
-    if (schema.uniqueItems === true && schema.default === undefined) {
-      throw new Error('ValueCreate.Array: Arrays with uniqueItems require a default value')
-    } else if ('default' in schema) {
-      return schema.default
-    } else if (schema.minItems !== undefined) {
-      return globalThis.Array.from({ length: schema.minItems }).map((item) => {
-        return Visit(schema.items, references)
-      })
-    } else {
-      return []
-    }
+}
+function TArray(schema: Types.TArray, references: Types.TSchema[]): any {
+  if (schema.uniqueItems === true && !ValueGuard.HasPropertyKey(schema, 'default')) {
+    throw new Error('ValueCreate.Array: Array with the uniqueItems constraint requires a default value')
+  } else if ('contains' in schema && !ValueGuard.HasPropertyKey(schema, 'default')) {
+    throw new Error('ValueCreate.Array: Array with the contains constraint requires a default value')
+  } else if ('default' in schema) {
+    return schema.default
+  } else if (schema.minItems !== undefined) {
+    return Array.from({ length: schema.minItems }).map((item) => {
+      return Visit(schema.items, references)
+    })
+  } else {
+    return []
   }
-  function BigInt(schema: Types.TBigInt, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else {
-      return globalThis.BigInt(0)
-    }
+}
+function TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[]) {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    return (async function* () {})()
   }
-  function Boolean(schema: Types.TBoolean, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else {
-      return false
-    }
+}
+function TBigInt(schema: Types.TBigInt, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    return BigInt(0)
   }
-  function Constructor(schema: Types.TConstructor, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else {
-      const value = Visit(schema.returns, references) as any
-      if (typeof value === 'object' && !globalThis.Array.isArray(value)) {
-        return class {
-          constructor() {
-            for (const [key, val] of globalThis.Object.entries(value)) {
-              const self = this as any
-              self[key] = val
-            }
+}
+function TBoolean(schema: Types.TBoolean, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    return false
+  }
+}
+function TConstructor(schema: Types.TConstructor, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    const value = Visit(schema.returns, references) as any
+    if (typeof value === 'object' && !Array.isArray(value)) {
+      return class {
+        constructor() {
+          for (const [key, val] of Object.entries(value)) {
+            const self = this as any
+            self[key] = val
           }
         }
-      } else {
-        return class {}
       }
-    }
-  }
-  function Date(schema: Types.TDate, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else if (schema.minimumTimestamp !== undefined) {
-      return new globalThis.Date(schema.minimumTimestamp)
-    } else {
-      return new globalThis.Date(0)
-    }
-  }
-  function Function(schema: Types.TFunction, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
     } else {
-      return () => Visit(schema.returns, references)
+      return class {}
     }
   }
-  function Integer(schema: Types.TInteger, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else if (schema.minimum !== undefined) {
-      return schema.minimum
-    } else {
-      return 0
-    }
+}
+function TDate(schema: Types.TDate, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else if (schema.minimumTimestamp !== undefined) {
+    return new Date(schema.minimumTimestamp)
+  } else {
+    return new Date(0)
   }
-  function Intersect(schema: Types.TIntersect, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else {
-      // Note: The best we can do here is attempt to instance each sub type and apply through object assign. For non-object
-      // sub types, we just escape the assignment and just return the value. In the latter case, this is typically going to
-      // be a consequence of an illogical intersection.
-      const value = schema.allOf.reduce((acc, schema) => {
-        const next = Visit(schema, references) as any
-        return typeof next === 'object' ? { ...acc, ...next } : next
-      }, {})
-      if (!ValueCheck.Check(schema, references, value)) throw new ValueCreateIntersectTypeError(schema)
-      return value
-    }
+}
+function TFunction(schema: Types.TFunction, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    return () => Visit(schema.returns, references)
   }
-  function Literal(schema: Types.TLiteral, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else {
-      return schema.const
-    }
+}
+function TInteger(schema: Types.TInteger, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else if (schema.minimum !== undefined) {
+    return schema.minimum
+  } else {
+    return 0
   }
-  function Never(schema: Types.TNever, references: Types.TSchema[]): any {
-    throw new ValueCreateNeverTypeError(schema)
+}
+function TIntersect(schema: Types.TIntersect, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    // Note: The best we can do here is attempt to instance each sub type and apply through object assign. For non-object
+    // sub types, we just escape the assignment and just return the value. In the latter case, this is typically going to
+    // be a consequence of an illogical intersection.
+    const value = schema.allOf.reduce((acc, schema) => {
+      const next = Visit(schema, references) as any
+      return typeof next === 'object' ? { ...acc, ...next } : next
+    }, {})
+    if (!ValueCheck.Check(schema, references, value)) throw new ValueCreateIntersectTypeError(schema)
+    return value
   }
-  function Not(schema: Types.TNot, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else {
-      throw new ValueCreateNotTypeError(schema)
-    }
+}
+function TIterator(schema: Types.TIterator, references: Types.TSchema[]) {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    return (function* () {})()
   }
-  function Null(schema: Types.TNull, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else {
-      return null
-    }
+}
+function TLiteral(schema: Types.TLiteral, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    return schema.const
   }
-  function Number(schema: Types.TNumber, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else if (schema.minimum !== undefined) {
-      return schema.minimum
-    } else {
-      return 0
-    }
+}
+function TNever(schema: Types.TNever, references: Types.TSchema[]): any {
+  throw new ValueCreateNeverTypeError(schema)
+}
+function TNot(schema: Types.TNot, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    throw new ValueCreateNotTypeError(schema)
   }
-  function Object(schema: Types.TObject, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else {
-      const required = new Set(schema.required)
-      return (
-        schema.default ||
-        globalThis.Object.entries(schema.properties).reduce((acc, [key, schema]) => {
-          return required.has(key) ? { ...acc, [key]: Visit(schema, references) } : { ...acc }
-        }, {})
-      )
-    }
+}
+function TNull(schema: Types.TNull, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    return null
   }
-  function Promise(schema: Types.TPromise<any>, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else {
-      return globalThis.Promise.resolve(Visit(schema.item, references))
-    }
+}
+function TNumber(schema: Types.TNumber, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else if (schema.minimum !== undefined) {
+    return schema.minimum
+  } else {
+    return 0
   }
-  function Record(schema: Types.TRecord<any, any>, references: Types.TSchema[]): any {
-    const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0]
-    if ('default' in schema) {
-      return schema.default
-    } else if (!(keyPattern === Types.PatternStringExact || keyPattern === Types.PatternNumberExact)) {
-      const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|')
-      return propertyKeys.reduce((acc, key) => {
-        return { ...acc, [key]: Visit(valueSchema, references) }
+}
+function TObject(schema: Types.TObject, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    const required = new Set(schema.required)
+    return (
+      schema.default ||
+      Object.entries(schema.properties).reduce((acc, [key, schema]) => {
+        return required.has(key) ? { ...acc, [key]: Visit(schema, references) } : { ...acc }
       }, {})
-    } else {
-      return {}
-    }
+    )
   }
-  function Ref(schema: Types.TRef<any>, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else {
-      const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-      if (index === -1) throw new ValueCreateDereferenceError(schema)
-      const target = references[index]
-      return Visit(target, references)
-    }
+}
+function TPromise(schema: Types.TPromise<any>, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    return Promise.resolve(Visit(schema.item, references))
   }
-  function String(schema: Types.TString, references: Types.TSchema[]): any {
-    if (schema.pattern !== undefined) {
-      if (!('default' in schema)) {
-        throw new Error('ValueCreate.String: String types with patterns must specify a default value')
-      } else {
-        return schema.default
-      }
-    } else if (schema.format !== undefined) {
-      if (!('default' in schema)) {
-        throw new Error('ValueCreate.String: String types with formats must specify a default value')
-      } else {
-        return schema.default
-      }
-    } else {
-      if ('default' in schema) {
-        return schema.default
-      } else if (schema.minLength !== undefined) {
-        return globalThis.Array.from({ length: schema.minLength })
-          .map(() => '.')
-          .join('')
-      } else {
-        return ''
-      }
-    }
+}
+function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[]): any {
+  const [keyPattern, valueSchema] = Object.entries(schema.patternProperties)[0]
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else if (!(keyPattern === Types.PatternStringExact || keyPattern === Types.PatternNumberExact)) {
+    const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|')
+    return propertyKeys.reduce((acc, key) => {
+      return { ...acc, [key]: Visit(valueSchema, references) }
+    }, {})
+  } else {
+    return {}
   }
-  function Symbol(schema: Types.TString, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else if ('value' in schema) {
-      return globalThis.Symbol.for(schema.value)
-    } else {
-      return globalThis.Symbol()
-    }
+}
+function TRef(schema: Types.TRef<any>, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+    if (index === -1) throw new ValueCreateDereferenceError(schema)
+    const target = references[index]
+    return Visit(target, references)
   }
-  function TemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[]) {
-    if ('default' in schema) {
-      return schema.default
-    }
-    const expression = Types.TemplateLiteralParser.ParseExact(schema.pattern)
-    if (!Types.TemplateLiteralFinite.Check(expression)) throw new ValueCreateTempateLiteralTypeError(schema)
-    const sequence = Types.TemplateLiteralGenerator.Generate(expression)
-    return sequence.next().value
-  }
-  function This(schema: Types.TThis, references: Types.TSchema[]): any {
-    if (recursiveDepth++ > recursiveMaxDepth) throw new ValueCreateRecursiveInstantiationError(schema, recursiveMaxDepth)
-    if ('default' in schema) {
-      return schema.default
+}
+function TString(schema: Types.TString, references: Types.TSchema[]): any {
+  if (schema.pattern !== undefined) {
+    if (!ValueGuard.HasPropertyKey(schema, 'default')) {
+      throw new Error('ValueCreate.String: String types with patterns must specify a default value')
     } else {
-      const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-      if (index === -1) throw new ValueCreateDereferenceError(schema)
-      const target = references[index]
-      return Visit(target, references)
-    }
-  }
-  function Tuple(schema: Types.TTuple<any[]>, references: Types.TSchema[]): any {
-    if ('default' in schema) {
       return schema.default
     }
-    if (schema.items === undefined) {
-      return []
+  } else if (schema.format !== undefined) {
+    if (!ValueGuard.HasPropertyKey(schema, 'default')) {
+      throw new Error('ValueCreate.String: String types with formats must specify a default value')
     } else {
-      return globalThis.Array.from({ length: schema.minItems }).map((_, index) => Visit((schema.items as any[])[index], references))
-    }
-  }
-  function Undefined(schema: Types.TUndefined, references: Types.TSchema[]): any {
-    if ('default' in schema) {
       return schema.default
-    } else {
-      return undefined
     }
-  }
-  function Union(schema: Types.TUnion<any[]>, references: Types.TSchema[]): any {
-    if ('default' in schema) {
+  } else {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
       return schema.default
-    } else if (schema.anyOf.length === 0) {
-      throw new Error('ValueCreate.Union: Cannot create Union with zero variants')
+    } else if (schema.minLength !== undefined) {
+      return Array.from({ length: schema.minLength })
+        .map(() => '.')
+        .join('')
     } else {
-      return Visit(schema.anyOf[0], references)
+      return ''
     }
   }
-  function Uint8Array(schema: Types.TUint8Array, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else if (schema.minByteLength !== undefined) {
-      return new globalThis.Uint8Array(schema.minByteLength)
-    } else {
-      return new globalThis.Uint8Array(0)
-    }
+}
+function TSymbol(schema: Types.TString, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else if ('value' in schema) {
+    return Symbol.for(schema.value)
+  } else {
+    return Symbol()
   }
-  function Unknown(schema: Types.TUnknown, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else {
-      return {}
-    }
+}
+function TTemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[]) {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  }
+  const expression = Types.TemplateLiteralParser.ParseExact(schema.pattern)
+  if (!Types.TemplateLiteralFinite.Check(expression)) throw new ValueCreateTempateLiteralTypeError(schema)
+  const sequence = Types.TemplateLiteralGenerator.Generate(expression)
+  return sequence.next().value
+}
+function TThis(schema: Types.TThis, references: Types.TSchema[]): any {
+  if (recursiveDepth++ > recursiveMaxDepth) throw new ValueCreateRecursiveInstantiationError(schema, recursiveMaxDepth)
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
+    if (index === -1) throw new ValueCreateDereferenceError(schema)
+    const target = references[index]
+    return Visit(target, references)
   }
-  function Void(schema: Types.TVoid, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else {
-      return void 0
-    }
+}
+function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
   }
-  function UserDefined(schema: Types.TSchema, references: Types.TSchema[]): any {
-    if ('default' in schema) {
-      return schema.default
-    } else {
-      throw new Error('ValueCreate.UserDefined: User defined types must specify a default value')
-    }
+  if (schema.items === undefined) {
+    return []
+  } else {
+    return Array.from({ length: schema.minItems }).map((_, index) => Visit((schema.items as any[])[index], references))
   }
-  /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
-  export function Visit(schema: Types.TSchema, references: Types.TSchema[]): unknown {
-    const references_ = IsString(schema.$id) ? [...references, schema] : references
-    const schema_ = schema as any
-    switch (schema_[Types.Kind]) {
-      case 'Any':
-        return Any(schema_, references_)
-      case 'Array':
-        return Array(schema_, references_)
-      case 'BigInt':
-        return BigInt(schema_, references_)
-      case 'Boolean':
-        return Boolean(schema_, references_)
-      case 'Constructor':
-        return Constructor(schema_, references_)
-      case 'Date':
-        return Date(schema_, references_)
-      case 'Function':
-        return Function(schema_, references_)
-      case 'Integer':
-        return Integer(schema_, references_)
-      case 'Intersect':
-        return Intersect(schema_, references_)
-      case 'Literal':
-        return Literal(schema_, references_)
-      case 'Never':
-        return Never(schema_, references_)
-      case 'Not':
-        return Not(schema_, references_)
-      case 'Null':
-        return Null(schema_, references_)
-      case 'Number':
-        return Number(schema_, references_)
-      case 'Object':
-        return Object(schema_, references_)
-      case 'Promise':
-        return Promise(schema_, references_)
-      case 'Record':
-        return Record(schema_, references_)
-      case 'Ref':
-        return Ref(schema_, references_)
-      case 'String':
-        return String(schema_, references_)
-      case 'Symbol':
-        return Symbol(schema_, references_)
-      case 'TemplateLiteral':
-        return TemplateLiteral(schema_, references_)
-      case 'This':
-        return This(schema_, references_)
-      case 'Tuple':
-        return Tuple(schema_, references_)
-      case 'Undefined':
-        return Undefined(schema_, references_)
-      case 'Union':
-        return Union(schema_, references_)
-      case 'Uint8Array':
-        return Uint8Array(schema_, references_)
-      case 'Unknown':
-        return Unknown(schema_, references_)
-      case 'Void':
-        return Void(schema_, references_)
-      default:
-        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueCreateUnknownTypeError(schema_)
-        return UserDefined(schema_, references_)
-    }
+}
+function TUndefined(schema: Types.TUndefined, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    return undefined
   }
-  // --------------------------------------------------------
-  // State
-  // --------------------------------------------------------
-  const recursiveMaxDepth = 512
-  let recursiveDepth = 0
-
-  /** Creates a value from the given schema and references */
-  export function Create<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T> {
-    recursiveDepth = 0
-    return Visit(schema, references)
+}
+function TUnion(schema: Types.TUnion<any[]>, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else if (schema.anyOf.length === 0) {
+    throw new Error('ValueCreate.Union: Cannot create Union with zero variants')
+  } else {
+    return Visit(schema.anyOf[0], references)
   }
 }
+function TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else if (schema.minByteLength !== undefined) {
+    return new Uint8Array(schema.minByteLength)
+  } else {
+    return new Uint8Array(0)
+  }
+}
+function TUnknown(schema: Types.TUnknown, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    return {}
+  }
+}
+function TVoid(schema: Types.TVoid, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    return void 0
+  }
+}
+function TKind(schema: Types.TSchema, references: Types.TSchema[]): any {
+  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    throw new Error('ValueCreate: User defined types must specify a default value')
+  }
+}
+function Visit(schema: Types.TSchema, references: Types.TSchema[]): unknown {
+  const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references
+  const schema_ = schema as any
+  switch (schema_[Types.Kind]) {
+    case 'Any':
+      return TAny(schema_, references_)
+    case 'Array':
+      return TArray(schema_, references_)
+    case 'AsyncIterator':
+      return TAsyncIterator(schema_, references_)
+    case 'BigInt':
+      return TBigInt(schema_, references_)
+    case 'Boolean':
+      return TBoolean(schema_, references_)
+    case 'Constructor':
+      return TConstructor(schema_, references_)
+    case 'Date':
+      return TDate(schema_, references_)
+    case 'Function':
+      return TFunction(schema_, references_)
+    case 'Integer':
+      return TInteger(schema_, references_)
+    case 'Intersect':
+      return TIntersect(schema_, references_)
+    case 'Iterator':
+      return TIterator(schema_, references_)
+    case 'Literal':
+      return TLiteral(schema_, references_)
+    case 'Never':
+      return TNever(schema_, references_)
+    case 'Not':
+      return TNot(schema_, references_)
+    case 'Null':
+      return TNull(schema_, references_)
+    case 'Number':
+      return TNumber(schema_, references_)
+    case 'Object':
+      return TObject(schema_, references_)
+    case 'Promise':
+      return TPromise(schema_, references_)
+    case 'Record':
+      return TRecord(schema_, references_)
+    case 'Ref':
+      return TRef(schema_, references_)
+    case 'String':
+      return TString(schema_, references_)
+    case 'Symbol':
+      return TSymbol(schema_, references_)
+    case 'TemplateLiteral':
+      return TTemplateLiteral(schema_, references_)
+    case 'This':
+      return TThis(schema_, references_)
+    case 'Tuple':
+      return TTuple(schema_, references_)
+    case 'Undefined':
+      return TUndefined(schema_, references_)
+    case 'Union':
+      return TUnion(schema_, references_)
+    case 'Uint8Array':
+      return TUint8Array(schema_, references_)
+    case 'Unknown':
+      return TUnknown(schema_, references_)
+    case 'Void':
+      return TVoid(schema_, references_)
+    default:
+      if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueCreateUnknownTypeError(schema_)
+      return TKind(schema_, references_)
+  }
+}
+// --------------------------------------------------------------------------
+// State
+// --------------------------------------------------------------------------
+const recursiveMaxDepth = 512
+let recursiveDepth = 0
+// --------------------------------------------------------------------------
+// Create
+// --------------------------------------------------------------------------
+/** Creates a value from the given schema and references */
+export function Create<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T>
+/** Creates a value from the given schema */
+export function Create<T extends Types.TSchema>(schema: T): Types.Static<T>
+/** Creates a value from the given schema */
+export function Create(...args: any[]) {
+  recursiveDepth = 0
+  return args.length === 2 ? Visit(args[0], args[1]) : Visit(args[0], [])
+}
diff --git a/src/value/delta.ts b/src/value/delta.ts
index 427a1d675..5a8074645 100644
--- a/src/value/delta.ts
+++ b/src/value/delta.ts
@@ -27,41 +27,35 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { Type, Static } from '../typebox'
-import { Is, ObjectType, ArrayType, TypedArrayType, ValueType } from './is'
-import { ValueClone } from './clone'
 import { ValuePointer } from './pointer'
+import * as ValueGuard from './guard'
+import * as ValueClone from './clone'
 
-// ---------------------------------------------------------------------
-// Operations
-// ---------------------------------------------------------------------
-
+// --------------------------------------------------------------------------
+// Commands
+// --------------------------------------------------------------------------
 export type Insert = Static<typeof Insert>
 export const Insert = Type.Object({
   type: Type.Literal('insert'),
   path: Type.String(),
   value: Type.Unknown(),
 })
-
 export type Update = Static<typeof Update>
 export const Update = Type.Object({
   type: Type.Literal('update'),
   path: Type.String(),
   value: Type.Unknown(),
 })
-
 export type Delete = Static<typeof Delete>
 export const Delete = Type.Object({
   type: Type.Literal('delete'),
   path: Type.String(),
 })
-
 export type Edit = Static<typeof Edit>
 export const Edit = Type.Union([Insert, Update, Delete])
-
-// ---------------------------------------------------------------------
+// --------------------------------------------------------------------------
 // Errors
-// ---------------------------------------------------------------------
-
+// --------------------------------------------------------------------------
 export class ValueDeltaObjectWithSymbolKeyError extends Error {
   constructor(public readonly key: unknown) {
     super('ValueDelta: Cannot diff objects with symbol keys')
@@ -72,136 +66,112 @@ export class ValueDeltaUnableToDiffUnknownValue extends Error {
     super('ValueDelta: Unable to create diff edits for unknown value')
   }
 }
-
-// ---------------------------------------------------------------------
-// ValueDelta
-// ---------------------------------------------------------------------
-
-export namespace ValueDelta {
-  // ---------------------------------------------------------------------
-  // Edits
-  // ---------------------------------------------------------------------
-
-  function Update(path: string, value: unknown): Edit {
-    return { type: 'update', path, value } as any
+// --------------------------------------------------------------------------
+// Command Factory
+// --------------------------------------------------------------------------
+function CreateUpdate(path: string, value: unknown): Edit {
+  return { type: 'update', path, value }
+}
+function CreateInsert(path: string, value: unknown): Edit {
+  return { type: 'insert', path, value }
+}
+function CreateDelete(path: string): Edit {
+  return { type: 'delete', path }
+}
+// --------------------------------------------------------------------------
+// Diffing Generators
+// --------------------------------------------------------------------------
+function* ObjectType(path: string, current: ValueGuard.ObjectType, next: unknown): IterableIterator<Edit> {
+  if (!ValueGuard.IsPlainObject(next)) return yield CreateUpdate(path, next)
+  const currentKeys = [...Object.keys(current), ...Object.getOwnPropertySymbols(current)]
+  const nextKeys = [...Object.keys(next), ...Object.getOwnPropertySymbols(next)]
+  for (const key of currentKeys) {
+    if (ValueGuard.IsSymbol(key)) throw new ValueDeltaObjectWithSymbolKeyError(key)
+    if (ValueGuard.IsUndefined(next[key]) && nextKeys.includes(key)) yield CreateUpdate(`${path}/${String(key)}`, undefined)
   }
-
-  function Insert(path: string, value: unknown): Edit {
-    return { type: 'insert', path, value } as any
+  for (const key of nextKeys) {
+    if (ValueGuard.IsUndefined(current[key]) || ValueGuard.IsUndefined(next[key])) continue
+    if (ValueGuard.IsSymbol(key)) throw new ValueDeltaObjectWithSymbolKeyError(key)
+    yield* Visit(`${path}/${String(key)}`, current[key], next[key])
   }
-
-  function Delete(path: string): Edit {
-    return { type: 'delete', path } as any
+  for (const key of nextKeys) {
+    if (ValueGuard.IsSymbol(key)) throw new ValueDeltaObjectWithSymbolKeyError(key)
+    if (ValueGuard.IsUndefined(current[key])) yield CreateInsert(`${path}/${String(key)}`, next[key])
   }
-
-  // ---------------------------------------------------------------------
-  // Diff
-  // ---------------------------------------------------------------------
-
-  function* Object(path: string, current: ObjectType, next: unknown): IterableIterator<Edit> {
-    if (!Is.Object(next)) return yield Update(path, next)
-    const currentKeys = [...globalThis.Object.keys(current), ...globalThis.Object.getOwnPropertySymbols(current)]
-    const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)]
-    for (const key of currentKeys) {
-      if (typeof key === 'symbol') throw new ValueDeltaObjectWithSymbolKeyError(key)
-      if (next[key] === undefined && nextKeys.includes(key)) yield Update(`${path}/${String(key)}`, undefined)
-    }
-    for (const key of nextKeys) {
-      if (current[key] === undefined || next[key] === undefined) continue
-      if (typeof key === 'symbol') throw new ValueDeltaObjectWithSymbolKeyError(key)
-      yield* Visit(`${path}/${String(key)}`, current[key], next[key])
-    }
-    for (const key of nextKeys) {
-      if (typeof key === 'symbol') throw new ValueDeltaObjectWithSymbolKeyError(key)
-      if (current[key] === undefined) yield Insert(`${path}/${String(key)}`, next[key])
-    }
-    for (const key of currentKeys.reverse()) {
-      if (typeof key === 'symbol') throw new ValueDeltaObjectWithSymbolKeyError(key)
-      if (next[key] === undefined && !nextKeys.includes(key)) yield Delete(`${path}/${String(key)}`)
-    }
+  for (const key of currentKeys.reverse()) {
+    if (ValueGuard.IsSymbol(key)) throw new ValueDeltaObjectWithSymbolKeyError(key)
+    if (ValueGuard.IsUndefined(next[key]) && !nextKeys.includes(key)) yield CreateDelete(`${path}/${String(key)}`)
   }
-
-  function* Array(path: string, current: ArrayType, next: unknown): IterableIterator<Edit> {
-    if (!Is.Array(next)) return yield Update(path, next)
-    for (let i = 0; i < Math.min(current.length, next.length); i++) {
-      yield* Visit(`${path}/${i}`, current[i], next[i])
-    }
-    for (let i = 0; i < next.length; i++) {
-      if (i < current.length) continue
-      yield Insert(`${path}/${i}`, next[i])
-    }
-    for (let i = current.length - 1; i >= 0; i--) {
-      if (i < next.length) continue
-      yield Delete(`${path}/${i}`)
-    }
-  }
-
-  function* TypedArray(path: string, current: TypedArrayType, next: unknown): IterableIterator<Edit> {
-    if (!Is.TypedArray(next) || current.length !== next.length || globalThis.Object.getPrototypeOf(current).constructor.name !== globalThis.Object.getPrototypeOf(next).constructor.name) return yield Update(path, next)
-    for (let i = 0; i < Math.min(current.length, next.length); i++) {
-      yield* Visit(`${path}/${i}`, current[i], next[i])
-    }
+}
+function* ArrayType(path: string, current: ValueGuard.ArrayType, next: unknown): IterableIterator<Edit> {
+  if (!ValueGuard.IsArray(next)) return yield CreateUpdate(path, next)
+  for (let i = 0; i < Math.min(current.length, next.length); i++) {
+    yield* Visit(`${path}/${i}`, current[i], next[i])
   }
-
-  function* Value(path: string, current: ValueType, next: unknown): IterableIterator<Edit> {
-    if (current === next) return
-    yield Update(path, next)
+  for (let i = 0; i < next.length; i++) {
+    if (i < current.length) continue
+    yield CreateInsert(`${path}/${i}`, next[i])
   }
-
-  function* Visit(path: string, current: unknown, next: unknown): IterableIterator<Edit> {
-    if (Is.Object(current)) {
-      return yield* Object(path, current, next)
-    } else if (Is.Array(current)) {
-      return yield* Array(path, current, next)
-    } else if (Is.TypedArray(current)) {
-      return yield* TypedArray(path, current, next)
-    } else if (Is.Value(current)) {
-      return yield* Value(path, current, next)
-    } else {
-      throw new ValueDeltaUnableToDiffUnknownValue(current)
-    }
+  for (let i = current.length - 1; i >= 0; i--) {
+    if (i < next.length) continue
+    yield CreateDelete(`${path}/${i}`)
   }
-
-  export function Diff(current: unknown, next: unknown): Edit[] {
-    return [...Visit('', current, next)]
+}
+function* TypedArrayType(path: string, current: ValueGuard.TypedArrayType, next: unknown): IterableIterator<Edit> {
+  if (!ValueGuard.IsTypedArray(next) || current.length !== next.length || Object.getPrototypeOf(current).constructor.name !== Object.getPrototypeOf(next).constructor.name) return yield CreateUpdate(path, next)
+  for (let i = 0; i < Math.min(current.length, next.length); i++) {
+    yield* Visit(`${path}/${i}`, current[i], next[i])
   }
-
-  // ---------------------------------------------------------------------
-  // Patch
-  // ---------------------------------------------------------------------
-
-  function IsRootUpdate(edits: Edit[]): edits is [Update] {
-    return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update'
+}
+function* ValueType(path: string, current: ValueGuard.ValueType, next: unknown): IterableIterator<Edit> {
+  if (current === next) return
+  yield CreateUpdate(path, next)
+}
+function* Visit(path: string, current: unknown, next: unknown): IterableIterator<Edit> {
+  if (ValueGuard.IsPlainObject(current)) return yield* ObjectType(path, current, next)
+  if (ValueGuard.IsArray(current)) return yield* ArrayType(path, current, next)
+  if (ValueGuard.IsTypedArray(current)) return yield* TypedArrayType(path, current, next)
+  if (ValueGuard.IsValueType(current)) return yield* ValueType(path, current, next)
+  throw new ValueDeltaUnableToDiffUnknownValue(current)
+}
+// ---------------------------------------------------------------------
+// Diff
+// ---------------------------------------------------------------------
+export function Diff(current: unknown, next: unknown): Edit[] {
+  return [...Visit('', current, next)]
+}
+// ---------------------------------------------------------------------
+// Patch
+// ---------------------------------------------------------------------
+function IsRootUpdate(edits: Edit[]): edits is [Update] {
+  return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update'
+}
+function IsIdentity(edits: Edit[]) {
+  return edits.length === 0
+}
+export function Patch<T = any>(current: unknown, edits: Edit[]): T {
+  if (IsRootUpdate(edits)) {
+    return ValueClone.Clone(edits[0].value) as T
   }
-
-  function IsIdentity(edits: Edit[]) {
-    return edits.length === 0
+  if (IsIdentity(edits)) {
+    return ValueClone.Clone(current) as T
   }
-
-  export function Patch<T = any>(current: unknown, edits: Edit[]): T {
-    if (IsRootUpdate(edits)) {
-      return ValueClone.Clone(edits[0].value) as T
-    }
-    if (IsIdentity(edits)) {
-      return ValueClone.Clone(current) as T
-    }
-    const clone = ValueClone.Clone(current)
-    for (const edit of edits) {
-      switch (edit.type) {
-        case 'insert': {
-          ValuePointer.Set(clone, edit.path, edit.value)
-          break
-        }
-        case 'update': {
-          ValuePointer.Set(clone, edit.path, edit.value)
-          break
-        }
-        case 'delete': {
-          ValuePointer.Delete(clone, edit.path)
-          break
-        }
+  const clone = ValueClone.Clone(current)
+  for (const edit of edits) {
+    switch (edit.type) {
+      case 'insert': {
+        ValuePointer.Set(clone, edit.path, edit.value)
+        break
+      }
+      case 'update': {
+        ValuePointer.Set(clone, edit.path, edit.value)
+        break
+      }
+      case 'delete': {
+        ValuePointer.Delete(clone, edit.path)
+        break
       }
     }
-    return clone as T
   }
+  return clone as T
 }
diff --git a/src/value/equal.ts b/src/value/equal.ts
index ba3e2424c..48a5f9e5b 100644
--- a/src/value/equal.ts
+++ b/src/value/equal.ts
@@ -26,43 +26,41 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { Is, ObjectType, ArrayType, TypedArrayType, ValueType } from './is'
+import * as ValueGuard from './guard'
 
-export namespace ValueEqual {
-  function Object(left: ObjectType, right: unknown): boolean {
-    if (!Is.Object(right)) return false
-    const leftKeys = [...globalThis.Object.keys(left), ...globalThis.Object.getOwnPropertySymbols(left)]
-    const rightKeys = [...globalThis.Object.keys(right), ...globalThis.Object.getOwnPropertySymbols(right)]
-    if (leftKeys.length !== rightKeys.length) return false
-    return leftKeys.every((key) => Equal(left[key], right[key]))
-  }
-  function Date(left: Date, right: unknown): any {
-    return Is.Date(right) && left.getTime() === right.getTime()
-  }
-  function Array(left: ArrayType, right: unknown): any {
-    if (!Is.Array(right) || left.length !== right.length) return false
-    return left.every((value, index) => Equal(value, right[index]))
-  }
-  function TypedArray(left: TypedArrayType, right: unknown): any {
-    if (!Is.TypedArray(right) || left.length !== right.length || globalThis.Object.getPrototypeOf(left).constructor.name !== globalThis.Object.getPrototypeOf(right).constructor.name) return false
-    return left.every((value, index) => Equal(value, right[index]))
-  }
-  function Value(left: ValueType, right: unknown): any {
-    return left === right
-  }
-  export function Equal<T>(left: T, right: unknown): right is T {
-    if (Is.Object(left)) {
-      return Object(left, right)
-    } else if (Is.Date(left)) {
-      return Date(left, right)
-    } else if (Is.TypedArray(left)) {
-      return TypedArray(left, right)
-    } else if (Is.Array(left)) {
-      return Array(left, right)
-    } else if (Is.Value(left)) {
-      return Value(left, right)
-    } else {
-      throw new Error('ValueEquals: Unable to compare value')
-    }
-  }
+// --------------------------------------------------------------------------
+// Equality Checks
+// --------------------------------------------------------------------------
+function ObjectType(left: ValueGuard.ObjectType, right: unknown): boolean {
+  if (!ValueGuard.IsPlainObject(right)) return false
+  const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)]
+  const rightKeys = [...Object.keys(right), ...Object.getOwnPropertySymbols(right)]
+  if (leftKeys.length !== rightKeys.length) return false
+  return leftKeys.every((key) => Equal(left[key], right[key]))
+}
+function DateType(left: Date, right: unknown): any {
+  return ValueGuard.IsDate(right) && left.getTime() === right.getTime()
+}
+function ArrayType(left: ValueGuard.ArrayType, right: unknown): any {
+  if (!ValueGuard.IsArray(right) || left.length !== right.length) return false
+  return left.every((value, index) => Equal(value, right[index]))
+}
+function TypedArrayType(left: ValueGuard.TypedArrayType, right: unknown): any {
+  if (!ValueGuard.IsTypedArray(right) || left.length !== right.length || Object.getPrototypeOf(left).constructor.name !== Object.getPrototypeOf(right).constructor.name) return false
+  return left.every((value, index) => Equal(value, right[index]))
+}
+function ValueType(left: ValueGuard.ValueType, right: unknown): any {
+  return left === right
+}
+// --------------------------------------------------------------------------
+// Equal
+// --------------------------------------------------------------------------
+/** Returns true if the left value deep-equals the right */
+export function Equal<T>(left: T, right: unknown): right is T {
+  if (ValueGuard.IsPlainObject(left)) return ObjectType(left, right)
+  if (ValueGuard.IsDate(left)) return DateType(left, right)
+  if (ValueGuard.IsTypedArray(left)) return TypedArrayType(left, right)
+  if (ValueGuard.IsArray(left)) return ArrayType(left, right)
+  if (ValueGuard.IsValueType(left)) return ValueType(left, right)
+  throw new Error('ValueEquals: Unable to compare value')
 }
diff --git a/src/value/guard.ts b/src/value/guard.ts
new file mode 100644
index 000000000..ce47fb7cd
--- /dev/null
+++ b/src/value/guard.ts
@@ -0,0 +1,145 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+// --------------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------------
+export type ObjectType = Record<PropertyKey, unknown>
+export type ArrayType = unknown[]
+export type ValueType = null | undefined | symbol | bigint | number | boolean | string
+// prettier-ignore
+export type TypedArrayType = 
+  | Int8Array 
+  | Uint8Array 
+  | Uint8ClampedArray 
+  | Int16Array 
+  | Uint16Array 
+  | Int32Array 
+  | Uint32Array 
+  | Float32Array 
+  | Float64Array 
+  | BigInt64Array 
+  | BigUint64Array
+// --------------------------------------------------------------------------
+// Iterators
+// --------------------------------------------------------------------------
+/** Returns true if this value is an async iterator */
+export function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<any> {
+  return IsObject(value) && Symbol.asyncIterator in value
+}
+/** Returns true if this value is an iterator */
+export function IsIterator(value: unknown): value is IterableIterator<any> {
+  return IsObject(value) && Symbol.iterator in value
+}
+// --------------------------------------------------------------------------
+// Nominal
+// --------------------------------------------------------------------------
+/** Returns true if this value is a typed array */
+export function IsTypedArray(value: unknown): value is TypedArrayType {
+  return ArrayBuffer.isView(value)
+}
+/** Returns true if this value is a Promise */
+export function IsPromise(value: unknown): value is Promise<unknown> {
+  return value instanceof Promise
+}
+/** Returns true if the value is a Uint8Array */
+export function IsUint8Array(value: unknown): value is Uint8Array {
+  return value instanceof Uint8Array
+}
+/** Returns true if this value is a Date */
+export function IsDate(value: unknown): value is Date {
+  return value instanceof Date
+}
+// --------------------------------------------------------------------------
+// Standard
+// --------------------------------------------------------------------------
+/** Returns true if this value has this property key */
+export function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is ObjectType & Record<K, unknown> {
+  return key in value
+}
+/** Returns true if this object is not an instance of any other type */
+export function IsPlainObject(value: unknown): value is ObjectType {
+  return IsObject(value) && IsFunction(value.constructor) && value.constructor.name === 'Object'
+}
+/** Returns true of this value is an object type */
+export function IsObject(value: unknown): value is ObjectType {
+  return value !== null && typeof value === 'object'
+}
+/** Returns true if this value is an array, but not a typed array */
+export function IsArray(value: unknown): value is ArrayType {
+  return Array.isArray(value) && !ArrayBuffer.isView(value)
+}
+/** Returns true if this value is an undefined */
+export function IsUndefined(value: unknown): value is undefined {
+  return value === undefined
+}
+/** Returns true if this value is an null */
+export function IsNull(value: unknown): value is null {
+  return value === null
+}
+/** Returns true if this value is an boolean */
+export function IsBoolean(value: unknown): value is boolean {
+  return typeof value === 'boolean'
+}
+/** Returns true if this value is an number */
+export function IsNumber(value: unknown): value is number {
+  return typeof value === 'number'
+}
+/** Returns true if this value is an integer */
+export function IsInteger(value: unknown): value is number {
+  return IsNumber(value) && Number.isInteger(value)
+}
+/** Returns true if this value is bigint */
+export function IsBigInt(value: unknown): value is bigint {
+  return typeof value === 'bigint'
+}
+/** Returns true if this value is string */
+export function IsString(value: unknown): value is string {
+  return typeof value === 'string'
+}
+/** Returns true if this value is a function */
+export function IsFunction(value: unknown): value is Function {
+  return typeof value === 'function'
+}
+/** Returns true if this value is a symbol */
+export function IsSymbol(value: unknown): value is symbol {
+  return typeof value === 'symbol'
+}
+/** Returns true if this value is a value type such as number, string, boolean */
+export function IsValueType(value: unknown): value is ValueType {
+  // prettier-ignore
+  return (
+    IsBigInt(value) ||
+    IsBoolean(value) || 
+    IsNull(value) || 
+    IsNumber(value) || 
+    IsString(value) ||
+    IsSymbol(value) ||
+    IsUndefined(value)
+  )
+}
diff --git a/src/value/hash.ts b/src/value/hash.ts
index 5231ecce3..eeafffe07 100644
--- a/src/value/hash.ts
+++ b/src/value/hash.ts
@@ -26,166 +26,125 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import * as ValueGuard from './guard'
+
+// --------------------------------------------------------------------------
+// Errors
+// --------------------------------------------------------------------------
 export class ValueHashError extends Error {
   constructor(public readonly value: unknown) {
     super(`Hash: Unable to hash value`)
   }
 }
-export namespace ValueHash {
-  enum ByteMarker {
-    Undefined,
-    Null,
-    Boolean,
-    Number,
-    String,
-    Object,
-    Array,
-    Date,
-    Uint8Array,
-    Symbol,
-    BigInt,
-  }
-
-  // ----------------------------------------------------
-  // State
-  // ----------------------------------------------------
-  let Hash = globalThis.BigInt('14695981039346656037')
-  const [Prime, Size] = [globalThis.BigInt('1099511628211'), globalThis.BigInt('2') ** globalThis.BigInt('64')]
-  const Bytes = globalThis.Array.from({ length: 256 }).map((_, i) => globalThis.BigInt(i))
-  const F64 = new globalThis.Float64Array(1)
-  const F64In = new globalThis.DataView(F64.buffer)
-  const F64Out = new globalThis.Uint8Array(F64.buffer)
-  // ----------------------------------------------------
-  // Guards
-  // ----------------------------------------------------
-  function IsDate(value: unknown): value is Date {
-    return value instanceof globalThis.Date
-  }
-  function IsUint8Array(value: unknown): value is Uint8Array {
-    return value instanceof globalThis.Uint8Array
-  }
-  function IsArray(value: unknown): value is Array<unknown> {
-    return globalThis.Array.isArray(value)
-  }
-  function IsBoolean(value: unknown): value is boolean {
-    return typeof value === 'boolean'
-  }
-  function IsNull(value: unknown): value is null {
-    return value === null
-  }
-  function IsNumber(value: unknown): value is number {
-    return typeof value === 'number'
-  }
-  function IsSymbol(value: unknown): value is symbol {
-    return typeof value === 'symbol'
-  }
-  function IsBigInt(value: unknown): value is bigint {
-    return typeof value === 'bigint'
-  }
-  function IsObject(value: unknown): value is Record<string, unknown> {
-    return typeof value === 'object' && value !== null && !IsArray(value) && !IsDate(value) && !IsUint8Array(value)
-  }
-  function IsString(value: unknown): value is string {
-    return typeof value === 'string'
-  }
-  function IsUndefined(value: unknown): value is undefined {
-    return value === undefined
-  }
-  // ----------------------------------------------------
-  // Encoding
-  // ----------------------------------------------------
-  function Array(value: Array<unknown>) {
-    FNV1A64(ByteMarker.Array)
-    for (const item of value) {
-      Visit(item)
-    }
-  }
-  function Boolean(value: boolean) {
-    FNV1A64(ByteMarker.Boolean)
-    FNV1A64(value ? 1 : 0)
-  }
-  function BigInt(value: bigint) {
-    FNV1A64(ByteMarker.BigInt)
-    F64In.setBigInt64(0, value)
-    for (const byte of F64Out) {
-      FNV1A64(byte)
-    }
-  }
-  function Date(value: Date) {
-    FNV1A64(ByteMarker.Date)
-    Visit(value.getTime())
-  }
-  function Null(value: null) {
-    FNV1A64(ByteMarker.Null)
-  }
-  function Number(value: number) {
-    FNV1A64(ByteMarker.Number)
-    F64In.setFloat64(0, value)
-    for (const byte of F64Out) {
-      FNV1A64(byte)
-    }
-  }
-  function Object(value: Record<string, unknown>) {
-    FNV1A64(ByteMarker.Object)
-    for (const key of globalThis.Object.keys(value).sort()) {
-      Visit(key)
-      Visit(value[key])
-    }
-  }
-  function String(value: string) {
-    FNV1A64(ByteMarker.String)
-    for (let i = 0; i < value.length; i++) {
-      FNV1A64(value.charCodeAt(i))
-    }
-  }
-  function Symbol(value: symbol) {
-    FNV1A64(ByteMarker.Symbol)
-    Visit(value.description)
+// --------------------------------------------------------------------------
+// ByteMarker
+// --------------------------------------------------------------------------
+export enum ByteMarker {
+  Undefined,
+  Null,
+  Boolean,
+  Number,
+  String,
+  Object,
+  Array,
+  Date,
+  Uint8Array,
+  Symbol,
+  BigInt,
+}
+// --------------------------------------------------------------------------
+// State
+// --------------------------------------------------------------------------
+let Accumulator = BigInt('14695981039346656037')
+const [Prime, Size] = [BigInt('1099511628211'), BigInt('2') ** BigInt('64')]
+const Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i))
+const F64 = new Float64Array(1)
+const F64In = new DataView(F64.buffer)
+const F64Out = new Uint8Array(F64.buffer)
+// --------------------------------------------------------------------------
+// Hashing Functions
+// --------------------------------------------------------------------------
+function ArrayType(value: Array<unknown>) {
+  FNV1A64(ByteMarker.Array)
+  for (const item of value) {
+    Visit(item)
   }
-  function Uint8Array(value: Uint8Array) {
-    FNV1A64(ByteMarker.Uint8Array)
-    for (let i = 0; i < value.length; i++) {
-      FNV1A64(value[i])
-    }
+}
+function BooleanType(value: boolean) {
+  FNV1A64(ByteMarker.Boolean)
+  FNV1A64(value ? 1 : 0)
+}
+function BigIntType(value: bigint) {
+  FNV1A64(ByteMarker.BigInt)
+  F64In.setBigInt64(0, value)
+  for (const byte of F64Out) {
+    FNV1A64(byte)
   }
-  function Undefined(value: undefined) {
-    return FNV1A64(ByteMarker.Undefined)
+}
+function DateType(value: Date) {
+  FNV1A64(ByteMarker.Date)
+  Visit(value.getTime())
+}
+function NullType(value: null) {
+  FNV1A64(ByteMarker.Null)
+}
+function NumberType(value: number) {
+  FNV1A64(ByteMarker.Number)
+  F64In.setFloat64(0, value)
+  for (const byte of F64Out) {
+    FNV1A64(byte)
   }
-  function Visit(value: any) {
-    if (IsArray(value)) {
-      Array(value)
-    } else if (IsBoolean(value)) {
-      Boolean(value)
-    } else if (IsBigInt(value)) {
-      BigInt(value)
-    } else if (IsDate(value)) {
-      Date(value)
-    } else if (IsNull(value)) {
-      Null(value)
-    } else if (IsNumber(value)) {
-      Number(value)
-    } else if (IsObject(value)) {
-      Object(value)
-    } else if (IsString(value)) {
-      String(value)
-    } else if (IsSymbol(value)) {
-      Symbol(value)
-    } else if (IsUint8Array(value)) {
-      Uint8Array(value)
-    } else if (IsUndefined(value)) {
-      Undefined(value)
-    } else {
-      throw new ValueHashError(value)
-    }
+}
+function ObjectType(value: Record<string, unknown>) {
+  FNV1A64(ByteMarker.Object)
+  for (const key of globalThis.Object.keys(value).sort()) {
+    Visit(key)
+    Visit(value[key])
   }
-  function FNV1A64(byte: number) {
-    Hash = Hash ^ Bytes[byte]
-    Hash = (Hash * Prime) % Size
+}
+function StringType(value: string) {
+  FNV1A64(ByteMarker.String)
+  for (let i = 0; i < value.length; i++) {
+    FNV1A64(value.charCodeAt(i))
   }
-  /** Creates a FNV1A-64 non cryptographic hash of the given value */
-  export function Create(value: unknown) {
-    Hash = globalThis.BigInt('14695981039346656037')
-    Visit(value)
-    return Hash
+}
+function SymbolType(value: symbol) {
+  FNV1A64(ByteMarker.Symbol)
+  Visit(value.description)
+}
+function Uint8ArrayType(value: Uint8Array) {
+  FNV1A64(ByteMarker.Uint8Array)
+  for (let i = 0; i < value.length; i++) {
+    FNV1A64(value[i])
   }
 }
+function UndefinedType(value: undefined) {
+  return FNV1A64(ByteMarker.Undefined)
+}
+function Visit(value: any) {
+  if (ValueGuard.IsArray(value)) return ArrayType(value)
+  if (ValueGuard.IsBoolean(value)) return BooleanType(value)
+  if (ValueGuard.IsBigInt(value)) return BigIntType(value)
+  if (ValueGuard.IsDate(value)) return DateType(value)
+  if (ValueGuard.IsNull(value)) return NullType(value)
+  if (ValueGuard.IsNumber(value)) return NumberType(value)
+  if (ValueGuard.IsPlainObject(value)) return ObjectType(value)
+  if (ValueGuard.IsString(value)) return StringType(value)
+  if (ValueGuard.IsSymbol(value)) return SymbolType(value)
+  if (ValueGuard.IsUint8Array(value)) return Uint8ArrayType(value)
+  if (ValueGuard.IsUndefined(value)) return UndefinedType(value)
+  throw new ValueHashError(value)
+}
+function FNV1A64(byte: number) {
+  Accumulator = Accumulator ^ Bytes[byte]
+  Accumulator = (Accumulator * Prime) % Size
+}
+// --------------------------------------------------------------------------
+// Hash
+// --------------------------------------------------------------------------
+/** Creates a FNV1A-64 non cryptographic hash of the given value */
+export function Hash(value: unknown) {
+  Accumulator = BigInt('14695981039346656037')
+  Visit(value)
+  return Accumulator
+}
diff --git a/src/value/index.ts b/src/value/index.ts
index a2235b01f..e8beb3bbd 100644
--- a/src/value/index.ts
+++ b/src/value/index.ts
@@ -26,9 +26,8 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export { ValueError, ValueErrorIterator, ValueErrorType } from '../errors/index'
-export { ValueHash } from './hash'
+export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index'
 export { Edit, Insert, Update, Delete } from './delta'
 export { Mutable } from './mutate'
-export * from './pointer'
-export * from './value'
+export { ValuePointer } from './pointer'
+export { Value } from './value'
diff --git a/src/value/is.ts b/src/value/is.ts
deleted file mode 100644
index c808f9db6..000000000
--- a/src/value/is.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-export type ValueType = null | undefined | Function | symbol | bigint | number | boolean | string
-export type ObjectType = Record<string | number | symbol, unknown>
-export type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array
-export type ArrayType = unknown[]
-
-export namespace Is {
-  export function Object(value: unknown): value is ObjectType {
-    return value !== null && typeof value === 'object' && !globalThis.Array.isArray(value) && !ArrayBuffer.isView(value) && !(value instanceof globalThis.Date)
-  }
-
-  export function Date(value: unknown): value is Date {
-    return value instanceof globalThis.Date
-  }
-
-  export function Array(value: unknown): value is ArrayType {
-    return globalThis.Array.isArray(value) && !ArrayBuffer.isView(value)
-  }
-
-  export function Value(value: unknown): value is ValueType {
-    return value === null || value === undefined || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'bigint' || typeof value === 'number' || typeof value === 'boolean' || typeof value === 'string'
-  }
-
-  export function TypedArray(value: unknown): value is TypedArrayType {
-    return ArrayBuffer.isView(value)
-  }
-}
diff --git a/src/value/mutate.ts b/src/value/mutate.ts
index 44d11a6e7..bd4a952bf 100644
--- a/src/value/mutate.ts
+++ b/src/value/mutate.ts
@@ -26,10 +26,13 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { Is, TypedArrayType } from './is'
 import { ValuePointer } from './pointer'
-import { ValueClone } from './clone'
+import * as ValueClone from './clone'
+import * as ValueGuard from './guard'
 
+// --------------------------------------------------------------------------
+// Errors
+// --------------------------------------------------------------------------
 export class ValueMutateTypeMismatchError extends Error {
   constructor() {
     super('ValueMutate: Cannot assign due type mismatch of assignable values')
@@ -40,71 +43,79 @@ export class ValueMutateInvalidRootMutationError extends Error {
     super('ValueMutate: Only object and array types can be mutated at the root level')
   }
 }
+// --------------------------------------------------------------------------
+// Mutators
+// --------------------------------------------------------------------------
 export type Mutable = { [key: string]: unknown } | unknown[]
-export namespace ValueMutate {
-  function Object(root: Mutable, path: string, current: unknown, next: Record<string, unknown>) {
-    if (!Is.Object(current)) {
-      ValuePointer.Set(root, path, ValueClone.Clone(next))
-    } else {
-      const currentKeys = globalThis.Object.keys(current)
-      const nextKeys = globalThis.Object.keys(next)
-      for (const currentKey of currentKeys) {
-        if (!nextKeys.includes(currentKey)) {
-          delete current[currentKey]
-        }
-      }
-      for (const nextKey of nextKeys) {
-        if (!currentKeys.includes(nextKey)) {
-          current[nextKey] = null
-        }
-      }
-      for (const nextKey of nextKeys) {
-        Visit(root, `${path}/${nextKey}`, current[nextKey], next[nextKey])
+function ObjectType(root: Mutable, path: string, current: unknown, next: Record<string, unknown>) {
+  if (!ValueGuard.IsPlainObject(current)) {
+    ValuePointer.Set(root, path, ValueClone.Clone(next))
+  } else {
+    const currentKeys = Object.keys(current)
+    const nextKeys = Object.keys(next)
+    for (const currentKey of currentKeys) {
+      if (!nextKeys.includes(currentKey)) {
+        delete current[currentKey]
       }
     }
-  }
-  function Array(root: Mutable, path: string, current: unknown, next: unknown[]) {
-    if (!Is.Array(current)) {
-      ValuePointer.Set(root, path, ValueClone.Clone(next))
-    } else {
-      for (let index = 0; index < next.length; index++) {
-        Visit(root, `${path}/${index}`, current[index], next[index])
+    for (const nextKey of nextKeys) {
+      if (!currentKeys.includes(nextKey)) {
+        current[nextKey] = null
       }
-      current.splice(next.length)
     }
-  }
-  function TypedArray(root: Mutable, path: string, current: unknown, next: TypedArrayType) {
-    if (Is.TypedArray(current) && current.length === next.length) {
-      for (let i = 0; i < current.length; i++) {
-        current[i] = next[i]
-      }
-    } else {
-      ValuePointer.Set(root, path, ValueClone.Clone(next))
+    for (const nextKey of nextKeys) {
+      Visit(root, `${path}/${nextKey}`, current[nextKey], next[nextKey])
     }
   }
-  function Value(root: Mutable, path: string, current: unknown, next: unknown) {
-    if (current === next) return
-    ValuePointer.Set(root, path, next)
-  }
-  function Visit(root: Mutable, path: string, current: unknown, next: unknown) {
-    if (Is.Array(next)) {
-      return Array(root, path, current, next)
-    } else if (Is.TypedArray(next)) {
-      return TypedArray(root, path, current, next)
-    } else if (Is.Object(next)) {
-      return Object(root, path, current, next)
-    } else if (Is.Value(next)) {
-      return Value(root, path, current, next)
+}
+function ArrayType(root: Mutable, path: string, current: unknown, next: unknown[]) {
+  if (!ValueGuard.IsArray(current)) {
+    ValuePointer.Set(root, path, ValueClone.Clone(next))
+  } else {
+    for (let index = 0; index < next.length; index++) {
+      Visit(root, `${path}/${index}`, current[index], next[index])
     }
+    current.splice(next.length)
   }
-  /** Performs a deep mutable value assignment while retaining internal references. */
-  export function Mutate(current: Mutable, next: Mutable): void {
-    if (Is.TypedArray(current) || Is.Value(current) || Is.TypedArray(next) || Is.Value(next)) {
-      throw new ValueMutateInvalidRootMutationError()
-    }
-    if ((Is.Object(current) && Is.Array(next)) || (Is.Array(current) && Is.Object(next))) {
-      throw new ValueMutateTypeMismatchError()
+}
+function TypedArrayType(root: Mutable, path: string, current: unknown, next: ValueGuard.TypedArrayType) {
+  if (ValueGuard.IsTypedArray(current) && current.length === next.length) {
+    for (let i = 0; i < current.length; i++) {
+      current[i] = next[i]
     }
-    Visit(current, '', current, next)
+  } else {
+    ValuePointer.Set(root, path, ValueClone.Clone(next))
   }
 }
+function ValueType(root: Mutable, path: string, current: unknown, next: unknown) {
+  if (current === next) return
+  ValuePointer.Set(root, path, next)
+}
+function Visit(root: Mutable, path: string, current: unknown, next: unknown) {
+  if (ValueGuard.IsArray(next)) return ArrayType(root, path, current, next)
+  if (ValueGuard.IsTypedArray(next)) return TypedArrayType(root, path, current, next)
+  if (ValueGuard.IsPlainObject(next)) return ObjectType(root, path, current, next)
+  if (ValueGuard.IsValueType(next)) return ValueType(root, path, current, next)
+}
+// --------------------------------------------------------------------------
+// Mutate
+// --------------------------------------------------------------------------
+function IsNonMutableValue(value: unknown): value is Mutable {
+  return ValueGuard.IsTypedArray(value) || ValueGuard.IsValueType(value)
+}
+function IsMismatchedValue(current: unknown, next: unknown) {
+  // prettier-ignore
+  return (
+    (ValueGuard.IsPlainObject(current) && ValueGuard.IsArray(next)) || 
+    (ValueGuard.IsArray(current) && ValueGuard.IsPlainObject(next))
+  )
+}
+// --------------------------------------------------------------------------
+// Mutate
+// --------------------------------------------------------------------------
+/** Performs a deep mutable value assignment while retaining internal references */
+export function Mutate(current: Mutable, next: Mutable): void {
+  if (IsNonMutableValue(current) || IsNonMutableValue(next)) throw new ValueMutateInvalidRootMutationError()
+  if (IsMismatchedValue(current, next)) throw new ValueMutateTypeMismatchError()
+  Visit(current, '', current, next)
+}
diff --git a/src/value/pointer.ts b/src/value/pointer.ts
index 1e7718e89..6b03c2f1e 100644
--- a/src/value/pointer.ts
+++ b/src/value/pointer.ts
@@ -26,24 +26,27 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+// --------------------------------------------------------------------------
+// Errors
+// --------------------------------------------------------------------------
 export class ValuePointerRootSetError extends Error {
   constructor(public readonly value: unknown, public readonly path: string, public readonly update: unknown) {
     super('ValuePointer: Cannot set root value')
   }
 }
-
 export class ValuePointerRootDeleteError extends Error {
   constructor(public readonly value: unknown, public readonly path: string) {
     super('ValuePointer: Cannot delete root value')
   }
 }
-
+// --------------------------------------------------------------------------
+// ValuePointer
+// --------------------------------------------------------------------------
 /** Provides functionality to update values through RFC6901 string pointers */
 export namespace ValuePointer {
   function Escape(component: string) {
     return component.indexOf('~') === -1 ? component : component.replace(/~1/g, '/').replace(/~0/g, '~')
   }
-
   /** Formats the given pointer into navigable key components */
   export function* Format(pointer: string): IterableIterator<string> {
     if (pointer === '') return
@@ -64,7 +67,6 @@ export namespace ValuePointer {
     }
     yield Escape(pointer.slice(start))
   }
-
   /** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
   export function Set(value: any, pointer: string, update: unknown): void {
     if (pointer === '') throw new ValuePointerRootSetError(value, pointer, update)
@@ -77,7 +79,6 @@ export namespace ValuePointer {
     }
     owner[key] = update
   }
-
   /** Deletes a value at the given pointer */
   export function Delete(value: any, pointer: string): void {
     if (pointer === '') throw new ValuePointerRootDeleteError(value, pointer)
@@ -88,14 +89,13 @@ export namespace ValuePointer {
       next = next[component]
       key = component
     }
-    if (globalThis.Array.isArray(owner)) {
+    if (Array.isArray(owner)) {
       const index = parseInt(key)
       owner.splice(index, 1)
     } else {
       delete owner[key]
     }
   }
-
   /** Returns true if a value exists at the given pointer */
   export function Has(value: any, pointer: string): boolean {
     if (pointer === '') return true
@@ -106,9 +106,8 @@ export namespace ValuePointer {
       next = next[component]
       key = component
     }
-    return globalThis.Object.getOwnPropertyNames(owner).includes(key)
+    return Object.getOwnPropertyNames(owner).includes(key)
   }
-
   /** Gets the value at the given pointer */
   export function Get(value: any, pointer: string): any {
     if (pointer === '') return value
diff --git a/src/value/value.ts b/src/value/value.ts
index 96bf2982f..242edc490 100644
--- a/src/value/value.ts
+++ b/src/value/value.ts
@@ -26,82 +26,82 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import * as ValueErrors from '../errors/index'
+import * as ValueMutate from './mutate'
+import * as ValueHash from './hash'
+import * as ValueEqual from './equal'
+import * as ValueCast from './cast'
+import * as ValueClone from './clone'
+import * as ValueConvert from './convert'
+import * as ValueCreate from './create'
+import * as ValueCheck from './check'
+import * as ValueDelta from './delta'
 import * as Types from '../typebox'
-import { ValueErrors, ValueErrorIterator } from '../errors/index'
-import { ValueMutate, Mutable } from './mutate'
-import { ValueHash } from './hash'
-import { ValueEqual } from './equal'
-import { ValueCast } from './cast'
-import { ValueClone } from './clone'
-import { ValueConvert } from './convert'
-import { ValueCreate } from './create'
-import { ValueCheck } from './check'
-import { ValueDelta, Edit } from './delta'
 
-/** Provides functions to perform structural updates to JavaScript values */
+/** Functions to perform structural operations on JavaScript values */
 export namespace Value {
-  /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number, boolean and date values if a reasonable conversion is possible. */
-  export function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): Types.Static<T>
-  /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number, boolean and date values if a reasonable conversion is possible. */
+  /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
+  export function Cast<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): Types.Static<T>
+  /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
   export function Cast<T extends Types.TSchema>(schema: T, value: unknown): Types.Static<T>
+  /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
   export function Cast(...args: any[]) {
-    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
-    return ValueCast.Cast(schema, references, value)
+    return ValueCast.Cast.apply(ValueCast, args as any)
   }
-  /** Creates a value from the given type */
-  export function Create<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R]): Types.Static<T>
+  /** Creates a value from the given type and references */
+  export function Create<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T>
   /** Creates a value from the given type */
   export function Create<T extends Types.TSchema>(schema: T): Types.Static<T>
+  /** Creates a value from the given type */
   export function Create(...args: any[]) {
-    const [schema, references] = args.length === 2 ? [args[0], args[1]] : [args[0], []]
-    return ValueCreate.Create(schema, references)
+    return ValueCreate.Create.apply(ValueCreate, args as any)
   }
-  /** Returns true if the value matches the given type. */
-  export function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): value is Types.Static<T>
-  /** Returns true if the value matches the given type. */
+  /** Returns true if the value matches the given type and references */
+  export function Check<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): value is Types.Static<T>
+  /** Returns true if the value matches the given type */
   export function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>
+  /** Returns true if the value matches the given type */
   export function Check(...args: any[]) {
-    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
-    return ValueCheck.Check(schema, references, value)
+    return ValueCheck.Check.apply(ValueCheck, args as any)
   }
-  /** Converts any type mismatched values to their target type if a conversion is possible. */
-  export function Convert<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): unknown
-  /** Converts any type mismatched values to their target type if a conversion is possible. */
+  /** Converts any type mismatched values to their target type if a reasonable conversion is possible */
+  export function Convert<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): unknown
+  /** Converts any type mismatched values to their target type if a reasonable conversion is possibl. */
   export function Convert<T extends Types.TSchema>(schema: T, value: unknown): unknown
+  /** Converts any type mismatched values to their target type if a reasonable conversion is possible */
   export function Convert(...args: any[]) {
-    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
-    return ValueConvert.Convert(schema, references, value)
+    return ValueConvert.Convert.apply(ValueConvert, args as any)
   }
   /** Returns a structural clone of the given value */
   export function Clone<T>(value: T): T {
     return ValueClone.Clone(value)
   }
   /** Returns an iterator for each error in this value. */
-  export function Errors<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): ValueErrorIterator
+  export function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): ValueErrors.ValueErrorIterator
+  /** Returns an iterator for each error in this value. */
+  export function Errors<T extends Types.TSchema>(schema: T, value: unknown): ValueErrors.ValueErrorIterator
   /** Returns an iterator for each error in this value. */
-  export function Errors<T extends Types.TSchema>(schema: T, value: unknown): ValueErrorIterator
   export function Errors(...args: any[]) {
-    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
-    return ValueErrors.Errors(schema, references, value) as ValueErrorIterator
+    return ValueErrors.Errors.apply(ValueErrors, args as any)
   }
   /** Returns true if left and right values are structurally equal */
   export function Equal<T>(left: T, right: unknown): right is T {
     return ValueEqual.Equal(left, right)
   }
   /** Returns edits to transform the current value into the next value */
-  export function Diff(current: unknown, next: unknown): Edit[] {
+  export function Diff(current: unknown, next: unknown): ValueDelta.Edit[] {
     return ValueDelta.Diff(current, next)
   }
   /** Returns a FNV1A-64 non cryptographic hash of the given value */
   export function Hash(value: unknown): bigint {
-    return ValueHash.Create(value)
+    return ValueHash.Hash(value)
   }
   /** Returns a new value with edits applied to the given value */
-  export function Patch<T = any>(current: unknown, edits: Edit[]): T {
+  export function Patch<T = any>(current: unknown, edits: ValueDelta.Edit[]): T {
     return ValueDelta.Patch(current, edits) as T
   }
   /** Performs a deep mutable value assignment while retaining internal references. */
-  export function Mutate(current: Mutable, next: Mutable): void {
+  export function Mutate(current: ValueMutate.Mutable, next: ValueMutate.Mutable): void {
     ValueMutate.Mutate(current, next)
   }
 }
diff --git a/test/runtime/assert/assert.ts b/test/runtime/assert/assert.ts
index 83ab9a5d5..bfb4f391d 100644
--- a/test/runtime/assert/assert.ts
+++ b/test/runtime/assert/assert.ts
@@ -1,33 +1,27 @@
 import * as assert from 'assert'
 
 export namespace Assert {
-  let port = 9000
-  /** Generates a new port used for host binding */
-  export function nextPort() {
-    const next = port++
-    return next
-  }
-  export function isTrue(value: boolean) {
+  export function IsTrue(value: boolean): asserts value is true {
     return assert.strictEqual(value, true)
   }
-  export function isFalse(value: boolean) {
+  export function IsFalse(value: boolean): asserts value is false {
     return assert.strictEqual(value, false)
   }
-  export function isEqual(actual: unknown, expect: unknown) {
+  export function IsEqual(actual: unknown, expect: unknown) {
     if (actual instanceof Uint8Array && expect instanceof Uint8Array) {
       assert.equal(actual.length, expect.length)
       for (let i = 0; i < actual.length; i++) assert.equal(actual[i], expect[i])
     }
     return assert.deepEqual(actual, expect)
   }
-  export function notEqual(actual: unknown, expect: unknown) {
+  export function NotEqual(actual: unknown, expect: unknown) {
     return assert.notEqual(actual, expect)
   }
   let nextIdOrdinal = 0
-  export function nextId() {
-    return `nextID${nextIdOrdinal++}`
+  export function NextId() {
+    return `$id-${nextIdOrdinal++}`
   }
-  export function throws(callback: Function) {
+  export function Throws(callback: Function) {
     try {
       callback()
     } catch {
@@ -35,7 +29,7 @@ export namespace Assert {
     }
     throw Error('Expected throw')
   }
-  export async function throwsAsync(callback: Function) {
+  export async function ThrowsAsync(callback: Function) {
     try {
       await callback()
     } catch {
@@ -43,12 +37,12 @@ export namespace Assert {
     }
     throw Error('Expected throw')
   }
-  export function isTypeOf(value: any, type: any) {
-    if (typeof value === type) return
-    throw Error(`Value is not typeof ${type}`)
-  }
-  export function isInstanceOf(value: any, constructor: any) {
+  export function IsInstanceOf(value: any, constructor: any) {
     if (value instanceof constructor) return
     throw Error(`Value is not instance of ${constructor}`)
   }
+  export function IsTypeOf(value: any, type: any) {
+    if (typeof value === type) return
+    throw Error(`Value is not typeof ${type}`)
+  }
 }
diff --git a/test/runtime/compiler/array.ts b/test/runtime/compiler/array.ts
index a2ccad658..1b004d8d2 100644
--- a/test/runtime/compiler/array.ts
+++ b/test/runtime/compiler/array.ts
@@ -6,27 +6,22 @@ describe('type/compiler/Array', () => {
     const T = Type.Array(Type.Any())
     Ok(T, [0, true, 'hello', {}])
   })
-
   it('Should not validate varying array when item is number', () => {
     const T = Type.Array(Type.Number())
     Fail(T, [1, 2, 3, 'hello'])
   })
-
   it('Should validate for an array of unions', () => {
     const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
     Ok(T, [1, 'hello', 3, 'world'])
   })
-
   it('Should not validate for an array of unions where item is not in union.', () => {
     const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
     Fail(T, [1, 'hello', 3, 'world', true])
   })
-
   it('Should validate for an empty array', () => {
     const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
     Ok(T, [])
   })
-
   it('Should validate for an array of intersection types', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.String() })
@@ -38,7 +33,6 @@ describe('type/compiler/Array', () => {
       { a: 'hello', b: 'hello' },
     ])
   })
-
   it('Should not validate for an array of composite types when passing additionalProperties false', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.String() })
@@ -50,7 +44,6 @@ describe('type/compiler/Array', () => {
       { a: 'hello', b: 'hello', c: 'additional' },
     ])
   })
-
   it('Should validate an array of tuples', () => {
     const A = Type.String()
     const B = Type.Number()
@@ -62,7 +55,6 @@ describe('type/compiler/Array', () => {
       ['hello', 1],
     ])
   })
-
   it('Should not validate an array of tuples when tuple values are incorrect', () => {
     const A = Type.String()
     const B = Type.Number()
@@ -74,7 +66,6 @@ describe('type/compiler/Array', () => {
       [1, 'hello'],
     ])
   })
-
   it('Should not validate array with failed minItems', () => {
     const T = Type.Array(Type.Number(), { minItems: 3 })
     Fail(T, [0, 1])
@@ -83,6 +74,9 @@ describe('type/compiler/Array', () => {
     const T = Type.Array(Type.Number(), { maxItems: 3 })
     Fail(T, [0, 1, 2, 3])
   })
+  // ---------------------------------------------------------
+  // Unique Items
+  // ---------------------------------------------------------
   it('Should validate array with uniqueItems when items are distinct objects', () => {
     const T = Type.Array(Type.Object({ x: Type.Number(), y: Type.Number() }), { uniqueItems: true })
     Ok(T, [
@@ -101,4 +95,54 @@ describe('type/compiler/Array', () => {
     const T = Type.Array(Type.Number(), { uniqueItems: true })
     Fail(T, [0, 0])
   })
+  // ---------------------------------------------------------
+  // Contains
+  // ---------------------------------------------------------
+  it('Should validate for contains', () => {
+    const T = Type.Array(Type.Number(), { contains: Type.Literal(1) })
+    Ok(T, [1])
+    Ok(T, [1, 2])
+    Fail(T, [])
+    Fail(T, [2])
+  })
+  it('Should validate for minContains', () => {
+    const T = Type.Array(Type.Number(), { contains: Type.Literal(1), minContains: 3 })
+    Ok(T, [1, 1, 1, 2])
+    Ok(T, [2, 1, 1, 1, 2])
+    Ok(T, [1, 1, 1])
+    Fail(T, [])
+    Fail(T, [1, 1])
+    Fail(T, [2])
+  })
+  it('Should validate for maxContains', () => {
+    const T = Type.Array(Type.Number(), { contains: Type.Literal(1), maxContains: 3 })
+    Ok(T, [1, 1, 1])
+    Ok(T, [1, 1])
+    Ok(T, [2, 2, 2, 2, 1, 1, 1])
+    Fail(T, [1, 1, 1, 1])
+  })
+  it('Should validate for minContains and maxContains', () => {
+    const T = Type.Array(Type.Number(), { contains: Type.Literal(1), minContains: 3, maxContains: 5 })
+    Fail(T, [1, 1])
+    Ok(T, [1, 1, 1])
+    Ok(T, [1, 1, 1, 1])
+    Ok(T, [1, 1, 1, 1, 1])
+    Fail(T, [1, 1, 1, 1, 1, 1])
+  })
+  it('Should not validate minContains or maxContains when contains is unspecified', () => {
+    const T = Type.Array(Type.Number(), { minContains: 3, maxContains: 5 })
+    Fail(T, [1, 1])
+    Fail(T, [1, 1, 1])
+    Fail(T, [1, 1, 1, 1])
+    Fail(T, [1, 1, 1, 1, 1])
+    Fail(T, [1, 1, 1, 1, 1, 1])
+  })
+  it('Should produce illogical schema when contains is not sub type of items', () => {
+    const T = Type.Array(Type.Number(), { contains: Type.String(), minContains: 3, maxContains: 5 })
+    Fail(T, [1, 1])
+    Fail(T, [1, 1, 1])
+    Fail(T, [1, 1, 1, 1])
+    Fail(T, [1, 1, 1, 1, 1])
+    Fail(T, [1, 1, 1, 1, 1, 1])
+  })
 })
diff --git a/test/runtime/compiler/async-iterator.ts b/test/runtime/compiler/async-iterator.ts
new file mode 100644
index 000000000..f2afa82f6
--- /dev/null
+++ b/test/runtime/compiler/async-iterator.ts
@@ -0,0 +1,20 @@
+import { Type } from '@sinclair/typebox'
+import { Ok, Fail } from './validate'
+
+describe('type/compiler/AsyncIterator', () => {
+  it('Should validate a async iterator 1', () => {
+    async function* f() {}
+    const T = Type.AsyncIterator(Type.Any())
+    Ok(T, f())
+  })
+  it('Should validate a async iterator 2', () => {
+    const T = Type.AsyncIterator(Type.Any())
+    Ok(T, {
+      [Symbol.asyncIterator]: () => {},
+    })
+  })
+  it('Should not validate a async iterator', () => {
+    const T = Type.AsyncIterator(Type.Any())
+    Fail(T, {})
+  })
+})
diff --git a/test/runtime/compiler/bigint.ts b/test/runtime/compiler/bigint.ts
index 484573395..2a04cbc35 100644
--- a/test/runtime/compiler/bigint.ts
+++ b/test/runtime/compiler/bigint.ts
@@ -59,25 +59,21 @@ describe('type/compiler/BigInt', () => {
     Fail(T, BigInt(9))
     Ok(T, BigInt(10))
   })
-
   it('Should validate maximum', () => {
     const T = Type.BigInt({ maximum: BigInt(10) })
     Ok(T, BigInt(10))
     Fail(T, BigInt(11))
   })
-
   it('Should validate Date exclusiveMinimum', () => {
     const T = Type.BigInt({ exclusiveMinimum: BigInt(10) })
     Fail(T, BigInt(10))
     Ok(T, BigInt(11))
   })
-
   it('Should validate Date exclusiveMaximum', () => {
     const T = Type.BigInt({ exclusiveMaximum: BigInt(10) })
     Ok(T, BigInt(9))
     Fail(T, BigInt(10))
   })
-
   it('Should not validate NaN', () => {
     Fail(Type.Number(), NaN)
   })
diff --git a/test/runtime/compiler/boolean.ts b/test/runtime/compiler/boolean.ts
index 03f01d890..bbc54d942 100644
--- a/test/runtime/compiler/boolean.ts
+++ b/test/runtime/compiler/boolean.ts
@@ -7,32 +7,26 @@ describe('type/compiler/Boolean', () => {
     Ok(T, true)
     Ok(T, false)
   })
-
   it('Should not validate a number', () => {
     const T = Type.Boolean()
     Fail(T, 1)
   })
-
   it('Should not validate a string', () => {
     const T = Type.Boolean()
     Fail(T, 'true')
   })
-
   it('Should not validate an array', () => {
     const T = Type.Boolean()
     Fail(T, [true])
   })
-
   it('Should not validate an object', () => {
     const T = Type.Boolean()
     Fail(T, {})
   })
-
   it('Should not validate an null', () => {
     const T = Type.Boolean()
     Fail(T, null)
   })
-
   it('Should not validate an undefined', () => {
     const T = Type.Boolean()
     Fail(T, undefined)
diff --git a/test/runtime/compiler/enum.ts b/test/runtime/compiler/enum.ts
index 08460de6f..268e2c8cb 100644
--- a/test/runtime/compiler/enum.ts
+++ b/test/runtime/compiler/enum.ts
@@ -20,7 +20,6 @@ describe('type/compiler/Enum', () => {
     Fail(T, 'Foo')
     Fail(T, 'Bar')
   })
-
   it('Should validate when emum has defined string values', () => {
     enum Kind {
       Foo = 'foo',
@@ -30,7 +29,6 @@ describe('type/compiler/Enum', () => {
     Ok(T, 'foo')
     Ok(T, 'bar')
   })
-
   it('Should not validate when emum has defined string values and user passes numeric', () => {
     enum Kind {
       Foo = 'foo',
@@ -40,7 +38,6 @@ describe('type/compiler/Enum', () => {
     Fail(T, 0)
     Fail(T, 1)
   })
-
   it('Should validate when enum has one or more string values', () => {
     enum Kind {
       Foo,
diff --git a/test/runtime/compiler/index.ts b/test/runtime/compiler/index.ts
index 1e2fa7629..d0120684b 100644
--- a/test/runtime/compiler/index.ts
+++ b/test/runtime/compiler/index.ts
@@ -1,5 +1,6 @@
 import './any'
 import './array'
+import './async-iterator'
 import './bigint'
 import './boolean'
 import './composite'
@@ -9,6 +10,7 @@ import './unicode'
 import './enum'
 import './integer'
 import './intersect'
+import './iterator'
 import './keyof'
 import './literal'
 import './modifier'
@@ -26,7 +28,7 @@ import './readonly'
 import './recursive'
 import './record'
 import './ref'
-import './regex'
+import './regexp'
 import './required'
 import './string'
 import './symbol'
diff --git a/test/runtime/compiler/integer.ts b/test/runtime/compiler/integer.ts
index 598aa04b4..683842fbc 100644
--- a/test/runtime/compiler/integer.ts
+++ b/test/runtime/compiler/integer.ts
@@ -22,27 +22,22 @@ describe('type/compiler/Integer', () => {
     const T = Type.Integer()
     Ok(T, 1)
   })
-
   it('Should not validate string', () => {
     const T = Type.Integer()
     Fail(T, 'hello')
   })
-
   it('Should not validate boolean', () => {
     const T = Type.Integer()
     Fail(T, true)
   })
-
   it('Should not validate array', () => {
     const T = Type.Integer()
     Fail(T, [1, 2, 3])
   })
-
   it('Should not validate object', () => {
     const T = Type.Integer()
     Fail(T, { a: 1, b: 2 })
   })
-
   it('Should not validate null', () => {
     const T = Type.Integer()
     Fail(T, null)
@@ -64,19 +59,16 @@ describe('type/compiler/Integer', () => {
     Fail(T, 9)
     Ok(T, 10)
   })
-
   it('Should validate maximum', () => {
     const T = Type.Integer({ maximum: 10 })
     Ok(T, 10)
     Fail(T, 11)
   })
-
   it('Should validate Date exclusiveMinimum', () => {
     const T = Type.Integer({ exclusiveMinimum: 10 })
     Fail(T, 10)
     Ok(T, 11)
   })
-
   it('Should validate Date exclusiveMaximum', () => {
     const T = Type.Integer({ exclusiveMaximum: 10 })
     Ok(T, 9)
diff --git a/test/runtime/compiler/intersect.ts b/test/runtime/compiler/intersect.ts
index ce7f934c7..d7aae2e77 100644
--- a/test/runtime/compiler/intersect.ts
+++ b/test/runtime/compiler/intersect.ts
@@ -87,7 +87,6 @@ describe('type/compiler/Intersect', () => {
     const T = Type.Intersect([A, B])
     Fail(T, { x: 1, y: 1 })
   })
-
   it('unevaluatedProperties with Record 1', () => {
     const T = Type.Intersect(
       [
diff --git a/test/runtime/compiler/iterator.ts b/test/runtime/compiler/iterator.ts
new file mode 100644
index 000000000..630504929
--- /dev/null
+++ b/test/runtime/compiler/iterator.ts
@@ -0,0 +1,20 @@
+import { Type } from '@sinclair/typebox'
+import { Ok, Fail } from './validate'
+
+describe('type/compiler/Iterator', () => {
+  it('Should validate a iterator 1', () => {
+    function* f() {}
+    const T = Type.Iterator(Type.Any())
+    Ok(T, f())
+  })
+  it('Should validate a iterator 2', () => {
+    const T = Type.Iterator(Type.Any())
+    Ok(T, {
+      [Symbol.iterator]: () => {},
+    })
+  })
+  it('Should not validate a iterator', () => {
+    const T = Type.Iterator(Type.Any())
+    Fail(T, {})
+  })
+})
diff --git a/test/runtime/compiler/keyof.ts b/test/runtime/compiler/keyof.ts
index e96ad8762..5acec21da 100644
--- a/test/runtime/compiler/keyof.ts
+++ b/test/runtime/compiler/keyof.ts
@@ -16,7 +16,6 @@ describe('type/compiler/KeyOf', () => {
     Ok(T, 'z')
     Fail(T, 'w')
   })
-
   it('Should validate when using pick', () => {
     const T = Type.KeyOf(
       Type.Pick(
@@ -32,7 +31,6 @@ describe('type/compiler/KeyOf', () => {
     Ok(T, 'y')
     Fail(T, 'z')
   })
-
   it('Should validate when using omit', () => {
     const T = Type.KeyOf(
       Type.Omit(
@@ -44,7 +42,6 @@ describe('type/compiler/KeyOf', () => {
         ['x', 'y'],
       ),
     )
-
     Fail(T, 'x')
     Fail(T, 'y')
     Ok(T, 'z')
diff --git a/test/runtime/compiler/object.ts b/test/runtime/compiler/object.ts
index 5b3079344..9e526de49 100644
--- a/test/runtime/compiler/object.ts
+++ b/test/runtime/compiler/object.ts
@@ -242,7 +242,6 @@ describe('type/compiler/Object', () => {
       z: 3,
     })
   })
-
   it('Should validate nested schema additional properties of string', () => {
     const T = Type.Object({
       nested: Type.Object(
@@ -326,7 +325,6 @@ describe('type/compiler/Object', () => {
       },
     })
   })
-
   it('Should check for property key if property type is undefined', () => {
     const T = Type.Object({ x: Type.Undefined() })
     Ok(T, { x: undefined })
diff --git a/test/runtime/compiler/partial.ts b/test/runtime/compiler/partial.ts
index 684282403..72ab48c9e 100644
--- a/test/runtime/compiler/partial.ts
+++ b/test/runtime/compiler/partial.ts
@@ -1,10 +1,10 @@
 import { TypeSystem } from '@sinclair/typebox/system'
-import { Type, Kind, Modifier } from '@sinclair/typebox'
+import { Type, Kind, Optional, Readonly } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
 describe('type/compiler/Partial', () => {
-  it('Should convert a required object into a partial.', () => {
+  it('Should convert a required object into a partial', () => {
     const A = Type.Object(
       {
         x: Type.Number(),
@@ -14,16 +14,16 @@ describe('type/compiler/Partial', () => {
       { additionalProperties: false },
     )
     const T = Type.Partial(A)
-    Ok(T, { x: 1, y: 1, z: 1 })
-    Ok(T, { x: 1, y: 1 })
-    Ok(T, { x: 1 })
-    Ok(T, {})
+    console.log(T)
+    //Ok(T, { x: 1, y: 1, z: 1 })
+    //Ok(T, { x: 1, y: 1 })
+    //Ok(T, { x: 1 })
+    //Ok(T, {})
   })
-
   it('Should update modifier types correctly when converting to partial', () => {
     const A = Type.Object(
       {
-        x: Type.ReadonlyOptional(Type.Number()),
+        x: Type.Readonly(Type.Optional(Type.Number())),
         y: Type.Readonly(Type.Number()),
         z: Type.Optional(Type.Number()),
         w: Type.Number(),
@@ -31,10 +31,12 @@ describe('type/compiler/Partial', () => {
       { additionalProperties: false },
     )
     const T = Type.Partial(A)
-    strictEqual(T.properties.x[Modifier], 'ReadonlyOptional')
-    strictEqual(T.properties.y[Modifier], 'ReadonlyOptional')
-    strictEqual(T.properties.z[Modifier], 'Optional')
-    strictEqual(T.properties.w[Modifier], 'Optional')
+    strictEqual(T.properties.x[Readonly], 'Readonly')
+    strictEqual(T.properties.x[Optional], 'Optional')
+    strictEqual(T.properties.y[Readonly], 'Readonly')
+    strictEqual(T.properties.y[Optional], 'Optional')
+    strictEqual(T.properties.z[Optional], 'Optional')
+    strictEqual(T.properties.w[Optional], 'Optional')
   })
 
   it('Should inherit options from the source object', () => {
diff --git a/test/runtime/compiler/pick.ts b/test/runtime/compiler/pick.ts
index dd8f234b6..556aa9859 100644
--- a/test/runtime/compiler/pick.ts
+++ b/test/runtime/compiler/pick.ts
@@ -15,7 +15,6 @@ describe('type/compiler/Pick', () => {
     const T = Type.Pick(Vector3, ['x', 'y'])
     Ok(T, { x: 1, y: 1 })
   })
-
   it('Should remove required properties on the target schema', () => {
     const A = Type.Object(
       {
@@ -28,7 +27,6 @@ describe('type/compiler/Pick', () => {
     const T = Type.Pick(A, ['x', 'y'])
     strictEqual(T.required!.includes('z'), false)
   })
-
   it('Should inherit options from the source object', () => {
     const A = Type.Object(
       {
@@ -42,7 +40,6 @@ describe('type/compiler/Pick', () => {
     strictEqual(A.additionalProperties, false)
     strictEqual(T.additionalProperties, false)
   })
-
   it('Should pick with keyof object', () => {
     const A = Type.Object({
       x: Type.Number(),
diff --git a/test/runtime/compiler/readonly-optional.ts b/test/runtime/compiler/readonly-optional.ts
index 90ec45097..fdaef8b4e 100644
--- a/test/runtime/compiler/readonly-optional.ts
+++ b/test/runtime/compiler/readonly-optional.ts
@@ -6,7 +6,7 @@ describe('type/compiler/ReadonlyOptional', () => {
   it('Should validate object with optional', () => {
     const T = Type.Object(
       {
-        a: Type.ReadonlyOptional(Type.String()),
+        a: Type.Readonly(Type.Optional(Type.String())),
         b: Type.String(),
       },
       { additionalProperties: false },
@@ -17,7 +17,7 @@ describe('type/compiler/ReadonlyOptional', () => {
   it('Should remove required value from schema', () => {
     const T = Type.Object(
       {
-        a: Type.ReadonlyOptional(Type.String()),
+        a: Type.Readonly(Type.Optional(Type.String())),
         b: Type.String(),
       },
       { additionalProperties: false },
diff --git a/test/runtime/compiler/readonly.ts b/test/runtime/compiler/readonly.ts
index 3edbab2a3..1bc82d758 100644
--- a/test/runtime/compiler/readonly.ts
+++ b/test/runtime/compiler/readonly.ts
@@ -13,7 +13,6 @@ describe('type/compiler/Readonly', () => {
     )
     Ok(T, { a: 'hello', b: 'world' })
   })
-
   it('Should retain required array on object', () => {
     const T = Type.Object(
       {
diff --git a/test/runtime/compiler/record.ts b/test/runtime/compiler/record.ts
index 8bee7fa76..ab8381fb4 100644
--- a/test/runtime/compiler/record.ts
+++ b/test/runtime/compiler/record.ts
@@ -86,7 +86,7 @@ describe('type/compiler/Record', () => {
     Fail(R, { a: 1, b: 2, c: 3, d: 4 })
   })
   it('Should should validate when specifying regular expressions', () => {
-    const K = Type.RegEx(/^op_.*$/)
+    const K = Type.RegExp(/^op_.*$/)
     const T = Type.Record(K, Type.Number())
     Ok(T, {
       op_a: 1,
@@ -95,7 +95,7 @@ describe('type/compiler/Record', () => {
     })
   })
   it('Should should not validate when specifying regular expressions and passing invalid property', () => {
-    const K = Type.RegEx(/^op_.*$/)
+    const K = Type.RegExp(/^op_.*$/)
     const T = Type.Record(K, Type.Number(), { additionalProperties: false })
     Fail(T, {
       op_a: 1,
diff --git a/test/runtime/compiler/recursive.ts b/test/runtime/compiler/recursive.ts
index b5b1c37ac..513864ec6 100644
--- a/test/runtime/compiler/recursive.ts
+++ b/test/runtime/compiler/recursive.ts
@@ -10,9 +10,8 @@ describe('type/compiler/Recursive', () => {
         nodes: Type.Array(Node),
       }),
     )
-    Assert.isEqual(Node.$id === undefined, false)
+    Assert.IsEqual(Node.$id === undefined, false)
   })
-
   it('Should override default ordinal $id if specified', () => {
     const Node = Type.Recursive(
       (Node) =>
@@ -22,9 +21,8 @@ describe('type/compiler/Recursive', () => {
         }),
       { $id: 'Node' },
     )
-    Assert.isEqual(Node.$id === 'Node', true)
+    Assert.IsEqual(Node.$id === 'Node', true)
   })
-
   it('Should validate recursive node type', () => {
     const Node = Type.Recursive((This) =>
       Type.Object({
@@ -40,7 +38,6 @@ describe('type/compiler/Recursive', () => {
       ],
     })
   })
-
   it('Should validate wrapped recursive node type', () => {
     const Node = Type.Tuple([
       Type.Recursive((This) =>
@@ -60,7 +57,6 @@ describe('type/compiler/Recursive', () => {
       },
     ])
   })
-
   it('Should not validate wrapped recursive node type with invalid id', () => {
     const Node = Type.Tuple([
       Type.Recursive((This) =>
diff --git a/test/runtime/compiler/ref.ts b/test/runtime/compiler/ref.ts
index ef23a872e..88d564e40 100644
--- a/test/runtime/compiler/ref.ts
+++ b/test/runtime/compiler/ref.ts
@@ -10,7 +10,7 @@ describe('type/compiler/Ref', () => {
         y: Type.Number(),
         z: Type.Number(),
       },
-      { $id: Assert.nextId() },
+      { $id: Assert.NextId() },
     )
     const R = Type.Ref(T)
     Ok(
@@ -23,7 +23,6 @@ describe('type/compiler/Ref', () => {
       [T],
     )
   })
-
   it('Should not validate when passing invalid data', () => {
     const T = Type.Object(
       {
@@ -31,7 +30,7 @@ describe('type/compiler/Ref', () => {
         y: Type.Number(),
         z: Type.Number(),
       },
-      { $id: Assert.nextId() },
+      { $id: Assert.NextId() },
     )
     const R = Type.Ref(T)
     Fail(
@@ -43,7 +42,6 @@ describe('type/compiler/Ref', () => {
       [T],
     )
   })
-
   it('Should de-reference object property schema', () => {
     const T = Type.Object(
       {
@@ -51,7 +49,6 @@ describe('type/compiler/Ref', () => {
       },
       { $id: 'R' },
     )
-
     const R = Type.Object(
       {
         x: Type.Number(),
@@ -61,13 +58,11 @@ describe('type/compiler/Ref', () => {
       },
       { $id: 'T' },
     )
-
     Ok(R, { x: 1, y: 2, z: 3 }, [T])
     Ok(R, { x: 1, y: 2, z: 3, r: { name: 'hello' } }, [T])
     Fail(R, { x: 1, y: 2, z: 3, r: { name: 1 } }, [T])
     Fail(R, { x: 1, y: 2, z: 3, r: {} }, [T])
   })
-
   it('Should reference recursive schema', () => {
     const T = Type.Recursive((Node) =>
       Type.Object({
diff --git a/test/runtime/compiler/regex.ts b/test/runtime/compiler/regex.ts
deleted file mode 100644
index 5f3418047..000000000
--- a/test/runtime/compiler/regex.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { Ok, Fail } from './validate'
-
-describe('type/compiler/RegEx', () => {
-  it('Should validate numeric value', () => {
-    const T = Type.RegEx(/[012345]/)
-    Ok(T, '0')
-    Ok(T, '1')
-    Ok(T, '2')
-    Ok(T, '3')
-    Ok(T, '4')
-    Ok(T, '5')
-  })
-
-  it('Should validate true or false string value', () => {
-    const T = Type.RegEx(/true|false/)
-    Ok(T, 'true')
-    Ok(T, 'true')
-    Ok(T, 'true')
-    Ok(T, 'false')
-    Ok(T, 'false')
-    Ok(T, 'false')
-    Fail(T, '6')
-  })
-
-  it('Should not validate failed regex test', () => {
-    const T = Type.RegEx(/true|false/)
-    Fail(T, 'unknown')
-  })
-
-  it('Should pass numeric 5 digit test', () => {
-    const T = Type.RegEx(/[\d]{5}/)
-    Ok(T, '12345')
-  })
-})
diff --git a/test/runtime/compiler/regexp.ts b/test/runtime/compiler/regexp.ts
new file mode 100644
index 000000000..9a926893f
--- /dev/null
+++ b/test/runtime/compiler/regexp.ts
@@ -0,0 +1,65 @@
+import { Type } from '@sinclair/typebox'
+import { Ok, Fail } from './validate'
+
+describe('type/compiler/RegExp', () => {
+  //-----------------------------------------------------
+  // Regular Expression
+  //-----------------------------------------------------
+  it('Should validate regular expression 1', () => {
+    const T = Type.RegExp(/[012345]/)
+    Ok(T, '0')
+    Ok(T, '1')
+    Ok(T, '2')
+    Ok(T, '3')
+    Ok(T, '4')
+    Ok(T, '5')
+  })
+  it('Should validate regular expression 2', () => {
+    const T = Type.RegExp(/true|false/)
+    Ok(T, 'true')
+    Ok(T, 'true')
+    Ok(T, 'true')
+    Ok(T, 'false')
+    Ok(T, 'false')
+    Ok(T, 'false')
+    Fail(T, '6')
+  })
+  it('Should validate regular expression 3', () => {
+    const T = Type.RegExp(/true|false/)
+    Fail(T, 'unknown')
+  })
+  it('Should validate regular expression 4', () => {
+    const T = Type.RegExp(/[\d]{5}/)
+    Ok(T, '12345')
+  })
+  //-----------------------------------------------------
+  // Regular Pattern
+  //-----------------------------------------------------
+  it('Should validate pattern 1', () => {
+    const T = Type.RegExp('[012345]')
+    Ok(T, '0')
+    Ok(T, '1')
+    Ok(T, '2')
+    Ok(T, '3')
+    Ok(T, '4')
+    Ok(T, '5')
+  })
+  it('Should validate pattern 2', () => {
+    const T = Type.RegExp('true|false')
+    Ok(T, 'true')
+    Ok(T, 'true')
+    Ok(T, 'true')
+    Ok(T, 'false')
+    Ok(T, 'false')
+    Ok(T, 'false')
+    Fail(T, '6')
+  })
+  it('Should validate pattern 3', () => {
+    const T = Type.RegExp('true|false')
+    Fail(T, 'unknown')
+  })
+  it('Should validate pattern 4', () => {
+    const T = Type.RegExp('[\\d]{5}')
+    Ok(T, '12345')
+  })
+})
diff --git a/test/runtime/compiler/required.ts b/test/runtime/compiler/required.ts
index fc6f32f83..80360c949 100644
--- a/test/runtime/compiler/required.ts
+++ b/test/runtime/compiler/required.ts
@@ -1,4 +1,4 @@
-import { Type, Modifier } from '@sinclair/typebox'
+import { Type, Readonly, Optional } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
@@ -18,21 +18,19 @@ describe('type/compiler/compiler/Required', () => {
     Fail(T, { x: 1 })
     Fail(T, {})
   })
-
   it('Should update modifier types correctly when converting to required', () => {
     const A = Type.Object({
-      x: Type.ReadonlyOptional(Type.Number()),
+      x: Type.Readonly(Type.Optional(Type.Number())),
       y: Type.Readonly(Type.Number()),
       z: Type.Optional(Type.Number()),
       w: Type.Number(),
     })
     const T = Type.Required(A)
-    strictEqual(T.properties.x[Modifier], 'Readonly')
-    strictEqual(T.properties.y[Modifier], 'Readonly')
-    strictEqual(T.properties.z[Modifier], undefined)
-    strictEqual(T.properties.w[Modifier], undefined)
+    strictEqual(T.properties.x[Readonly], 'Readonly')
+    strictEqual(T.properties.y[Readonly], 'Readonly')
+    strictEqual(T.properties.z[Optional], undefined)
+    strictEqual(T.properties.w[Optional], undefined)
   })
-
   it('Should inherit options from the source object', () => {
     const A = Type.Object(
       {
@@ -46,7 +44,6 @@ describe('type/compiler/compiler/Required', () => {
     strictEqual(A.additionalPropeties, false)
     strictEqual(T.additionalPropeties, false)
   })
-
   // it('Should construct new object when targetting reference', () => {
   //   const T = Type.Object({ a: Type.String(), b: Type.String() }, { $id: 'T' })
   //   const R = Type.Ref(T)
diff --git a/test/runtime/compiler/string.ts b/test/runtime/compiler/string.ts
index 0f43dc025..99beae9a0 100644
--- a/test/runtime/compiler/string.ts
+++ b/test/runtime/compiler/string.ts
@@ -42,34 +42,28 @@ describe('type/compiler/String', () => {
     const T = Type.String({ format: 'email' })
     Ok(T, 'name@domain.com')
   })
-
   it('Should validate string format as uuid', () => {
     const T = Type.String({ format: 'uuid' })
     Ok(T, '4a7a17c9-2492-4a53-8e13-06ea2d3f3bbf')
   })
-
   it('Should validate string format as iso8601 date', () => {
     const T = Type.String({ format: 'date-time' })
     Ok(T, '2021-06-11T20:30:00-04:00')
   })
-
   it('Should validate minLength', () => {
     const T = Type.String({ minLength: 4 })
     Ok(T, '....')
     Fail(T, '...')
   })
-
   it('Should validate maxLength', () => {
     const T = Type.String({ maxLength: 4 })
     Ok(T, '....')
     Fail(T, '.....')
   })
-
   it('Should pass numeric 5 digit test', () => {
     const T = Type.String({ pattern: '[\\d]{5}' })
     Ok(T, '12345')
   })
-
   it('Should should escape characters in the pattern', () => {
     const T = Type.String({ pattern: '/a/' })
     Ok(T, '/a/')
diff --git a/test/runtime/compiler/template-literal.ts b/test/runtime/compiler/template-literal.ts
index d0357ae96..c967cf9ee 100644
--- a/test/runtime/compiler/template-literal.ts
+++ b/test/runtime/compiler/template-literal.ts
@@ -130,7 +130,6 @@ describe('type/compiler/TemplateLiteral', () => {
     Ok(T, 'ccc')
     Ok(T, 'dddd')
   })
-
   it('Should validate infinite pattern 5', () => {
     // prettier-ignore
     const T = Type.TemplateLiteral([
diff --git a/test/runtime/compiler/tuple.ts b/test/runtime/compiler/tuple.ts
index 63a436182..9e1b82052 100644
--- a/test/runtime/compiler/tuple.ts
+++ b/test/runtime/compiler/tuple.ts
@@ -9,50 +9,42 @@ describe('type/compiler/Tuple', () => {
     const T = Type.Tuple([A, B])
     Ok(T, ['hello', 42])
   })
-
   it('Should not validate tuple of [string, number] when reversed', () => {
     const A = Type.String()
     const B = Type.Number()
     const T = Type.Tuple([A, B])
     Fail(T, [42, 'hello'])
   })
-
   it('Should validate with empty tuple', () => {
     const T = Type.Tuple([])
     Ok(T, [])
   })
-
   it('Should not validate with empty tuple with more items', () => {
     const T = Type.Tuple([])
     Fail(T, [1])
   })
-
   it('Should not validate with empty tuple with less items', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
     Fail(T, [1])
   })
-
   it('Should validate tuple of objects', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
     const T = Type.Tuple([A, B])
     Ok(T, [{ a: 'hello' }, { b: 42 }])
   })
-
   it('Should not validate tuple of objects when reversed', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
     const T = Type.Tuple([A, B])
     Fail(T, [{ b: 42 }, { a: 'hello' }])
   })
-
   it('Should not validate tuple when array is less than tuple length', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
     const T = Type.Tuple([A, B])
     Fail(T, [{ a: 'hello' }])
   })
-
   it('Should not validate tuple when array is greater than tuple length', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
diff --git a/test/runtime/compiler/uint8array.ts b/test/runtime/compiler/uint8array.ts
index ae94d7872..274975b23 100644
--- a/test/runtime/compiler/uint8array.ts
+++ b/test/runtime/compiler/uint8array.ts
@@ -6,48 +6,39 @@ describe('type/compiler/Uint8Array', () => {
     const T = Type.Uint8Array()
     Fail(T, 1)
   })
-
   it('Should not validate string', () => {
     const T = Type.Uint8Array()
     Fail(T, 'hello')
   })
-
   it('Should not validate boolean', () => {
     const T = Type.Uint8Array()
     Fail(T, true)
   })
-
   it('Should not validate array', () => {
     const T = Type.Uint8Array()
     Fail(T, [1, 2, 3])
   })
-
   it('Should not validate object', () => {
     const T = Type.Uint8Array()
     Fail(T, { a: 1, b: 2 })
   })
-
   it('Should not validate null', () => {
     const T = Type.Uint8Array()
     Fail(T, null)
   })
-
   it('Should not validate undefined', () => {
     const T = Type.Uint8Array()
     Fail(T, undefined)
   })
-
   it('Should validate Uint8Array', () => {
     const T = Type.Uint8Array()
     Ok(T, new Uint8Array(100))
   })
-
   it('Should validate minByteLength', () => {
     const T = Type.Uint8Array({ minByteLength: 4 })
     Ok(T, new Uint8Array(4))
     Fail(T, new Uint8Array(3))
   })
-
   it('Should validate maxByteLength', () => {
     const T = Type.Uint8Array({ maxByteLength: 4 })
     Ok(T, new Uint8Array(4))
diff --git a/test/runtime/compiler/union.ts b/test/runtime/compiler/union.ts
index 8ad6e4f64..a1e1fe724 100644
--- a/test/runtime/compiler/union.ts
+++ b/test/runtime/compiler/union.ts
@@ -11,7 +11,6 @@ describe('type/compiler/Union', () => {
     Ok(T, true)
     Ok(T, 42)
   })
-
   it('Should validate union of objects', () => {
     const A = Type.Object({ a: Type.String() }, { additionalProperties: false })
     const B = Type.Object({ b: Type.String() }, { additionalProperties: false })
@@ -19,7 +18,6 @@ describe('type/compiler/Union', () => {
     Ok(T, { a: 'hello' })
     Ok(T, { b: 'world' })
   })
-
   it('Should fail to validate for descriminated union types', () => {
     const A = Type.Object({ kind: Type.Literal('A'), value: Type.String() })
     const B = Type.Object({ kind: Type.Literal('B'), value: Type.Number() })
@@ -27,7 +25,6 @@ describe('type/compiler/Union', () => {
     Fail(T, { kind: 'A', value: 42 }) // expect { kind: 'A', value: string }
     Fail(T, { kind: 'B', value: 'hello' }) // expect { kind: 'B', value: number }
   })
-
   it('Should validate union of objects where properties overlap', () => {
     const A = Type.Object({ a: Type.String() }, { additionalProperties: false })
     const B = Type.Object({ a: Type.String(), b: Type.String() }, { additionalProperties: false })
@@ -35,7 +32,6 @@ describe('type/compiler/Union', () => {
     Ok(T, { a: 'hello' }) // A
     Ok(T, { a: 'hello', b: 'world' }) // B
   })
-
   it('Should validate union of overlapping property of varying type', () => {
     const A = Type.Object({ a: Type.String(), b: Type.Number() }, { additionalProperties: false })
     const B = Type.Object({ a: Type.String(), b: Type.String() }, { additionalProperties: false })
@@ -43,7 +39,6 @@ describe('type/compiler/Union', () => {
     Ok(T, { a: 'hello', b: 42 }) // A
     Ok(T, { a: 'hello', b: 'world' }) // B
   })
-
   it('Should validate union of literal strings', () => {
     const A = Type.Literal('hello')
     const B = Type.Literal('world')
@@ -51,7 +46,6 @@ describe('type/compiler/Union', () => {
     Ok(T, 'hello') // A
     Ok(T, 'world') // B
   })
-
   it('Should not validate union of literal strings for unknown string', () => {
     const A = Type.Literal('hello')
     const B = Type.Literal('world')
diff --git a/test/runtime/compiler/validate.ts b/test/runtime/compiler/validate.ts
index b85a91c20..eb3ab6a0e 100644
--- a/test/runtime/compiler/validate.ts
+++ b/test/runtime/compiler/validate.ts
@@ -21,7 +21,6 @@ const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
 function isLeapYear(year: number): boolean {
   return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)
 }
-
 function isDate(str: string): boolean {
   const matches: string[] | null = DATE.exec(str)
   if (!matches) return false
@@ -30,7 +29,6 @@ function isDate(str: string): boolean {
   const day: number = +matches[3]
   return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month])
 }
-
 function isTime(str: string, strictTimeZone?: boolean): boolean {
   const matches: string[] | null = TIME.exec(str)
   if (!matches) return false
@@ -48,20 +46,16 @@ function isTime(str: string, strictTimeZone?: boolean): boolean {
   const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0)
   return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61
 }
-
 function isDateTime(str: string, strictTimeZone?: boolean): boolean {
   const dateTime: string[] = str.split(DATE_TIME_SEPARATOR)
   return dateTime.length === 2 && isDate(dateTime[0]) && isTime(dateTime[1], strictTimeZone)
 }
-
 // -------------------------------------------------------------------------
 // Use Formats
 // -------------------------------------------------------------------------
-
 FormatRegistry.Set('email', (value) => EMAIL.test(value))
 FormatRegistry.Set('uuid', (value) => UUID.test(value))
 FormatRegistry.Set('date-time', (value) => isDateTime(value, true))
-
 export function Ok<T extends TSchema>(schema: T, data: unknown, references: any[] = []) {
   const C = TypeCompiler.Compile(schema, references)
   const result = C.Check(data)
@@ -92,7 +86,6 @@ export function Ok<T extends TSchema>(schema: T, data: unknown, references: any[
     throw Error('expected ok')
   }
 }
-
 export function Fail<T extends TSchema>(schema: T, data: unknown, references: any[] = []) {
   const C = TypeCompiler.Compile(schema, references)
   const result = C.Check(data)
diff --git a/test/runtime/errors/iterator.ts b/test/runtime/errors/iterator.ts
index e0baf4404..1f1ef8858 100644
--- a/test/runtime/errors/iterator.ts
+++ b/test/runtime/errors/iterator.ts
@@ -1,32 +1,32 @@
 import { Type } from '@sinclair/typebox'
-import { ValueErrors } from '@sinclair/typebox/errors'
+import { Errors } from '@sinclair/typebox/errors'
 import { Assert } from '../assert'
 
 describe('errors/ValueErrorIterator', () => {
   it('Should return undefined for non error', () => {
-    const R = ValueErrors.Errors(Type.Number(), [], 1).First()
-    Assert.isEqual(R, undefined)
+    const R = Errors(Type.Number(), [], 1).First()
+    Assert.IsEqual(R, undefined)
   })
   it('Should return a value error when error', () => {
-    const { type, path, message } = ValueErrors.Errors(Type.Number(), [], '').First()!
-    Assert.isTypeOf(type, 'number')
-    Assert.isTypeOf(path, 'string')
-    Assert.isTypeOf(message, 'string')
+    const { type, path, message } = Errors(Type.Number(), [], '').First()!
+    Assert.IsTypeOf(type, 'number')
+    Assert.IsTypeOf(path, 'string')
+    Assert.IsTypeOf(message, 'string')
   })
   it('Should yield empty array for non error', () => {
-    const R = [...ValueErrors.Errors(Type.Number(), [], 1)]
-    Assert.isEqual(R.length, 0)
+    const R = [...Errors(Type.Number(), [], 1)]
+    Assert.IsEqual(R.length, 0)
   })
   it('Should yield array with 1 error when error', () => {
-    const R = [...ValueErrors.Errors(Type.Number(), [], 'foo')]
-    Assert.isEqual(R.length, 1)
+    const R = [...Errors(Type.Number(), [], 'foo')]
+    Assert.IsEqual(R.length, 1)
   })
   it('Should yield array with N errors when error', () => {
     // prettier-ignore
-    const R = [...ValueErrors.Errors(Type.Object({
+    const R = [...Errors(Type.Object({
       x: Type.Number(),
       y: Type.Number()
     }), [], {})] // require object to invoke internal check
-    Assert.isEqual(R.length > 1, true)
+    Assert.IsEqual(R.length > 1, true)
   })
 })
diff --git a/test/runtime/schema/array.ts b/test/runtime/schema/array.ts
index 3b9b972b6..d20e504c4 100644
--- a/test/runtime/schema/array.ts
+++ b/test/runtime/schema/array.ts
@@ -6,27 +6,22 @@ describe('type/schema/Array', () => {
     const T = Type.Array(Type.Any())
     Ok(T, [0, true, 'hello', {}])
   })
-
   it('Should not validate varying array when item is number', () => {
     const T = Type.Array(Type.Number())
     Fail(T, [1, 2, 3, 'hello'])
   })
-
   it('Should validate for an array of unions', () => {
     const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
     Ok(T, [1, 'hello', 3, 'world'])
   })
-
   it('Should not validate for an array of unions where item is not in union.', () => {
     const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
     Fail(T, [1, 'hello', 3, 'world', true])
   })
-
   it('Should validate for an empty array', () => {
     const T = Type.Array(Type.Union([Type.Number(), Type.String()]))
     Ok(T, [])
   })
-
   it('Should validate for an array of intersection types', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.String() })
@@ -38,11 +33,10 @@ describe('type/schema/Array', () => {
       { a: 'hello', b: 'hello' },
     ])
   })
-
-  it('Should not validate for an array of intersection types when passing additionalProperties false', () => {
+  it('Should not validate for an array of composite types when passing additionalProperties false', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.String() })
-    const C = Type.Intersect([A, B], { additionalProperties: false })
+    const C = Type.Composite([A, B], { additionalProperties: false })
     const T = Type.Array(C)
     Fail(T, [
       { a: 'hello', b: 'hello' },
@@ -50,7 +44,6 @@ describe('type/schema/Array', () => {
       { a: 'hello', b: 'hello', c: 'additional' },
     ])
   })
-
   it('Should validate an array of tuples', () => {
     const A = Type.String()
     const B = Type.Number()
@@ -62,7 +55,6 @@ describe('type/schema/Array', () => {
       ['hello', 1],
     ])
   })
-
   it('Should not validate an array of tuples when tuple values are incorrect', () => {
     const A = Type.String()
     const B = Type.Number()
@@ -82,6 +74,9 @@ describe('type/schema/Array', () => {
     const T = Type.Array(Type.Number(), { maxItems: 3 })
     Fail(T, [0, 1, 2, 3])
   })
+  // ---------------------------------------------------------
+  // Unique Items
+  // ---------------------------------------------------------
   it('Should validate array with uniqueItems when items are distinct objects', () => {
     const T = Type.Array(Type.Object({ x: Type.Number(), y: Type.Number() }), { uniqueItems: true })
     Ok(T, [
@@ -100,4 +95,54 @@ describe('type/schema/Array', () => {
     const T = Type.Array(Type.Number(), { uniqueItems: true })
     Fail(T, [0, 0])
   })
+  // ---------------------------------------------------------
+  // Contains
+  // ---------------------------------------------------------
+  it('Should validate for contains', () => {
+    const T = Type.Array(Type.Number(), { contains: Type.Literal(1) })
+    Ok(T, [1])
+    Ok(T, [1, 2])
+    Fail(T, [])
+    Fail(T, [2])
+  })
+  it('Should validate for minContains', () => {
+    const T = Type.Array(Type.Number(), { contains: Type.Literal(1), minContains: 3 })
+    Ok(T, [1, 1, 1, 2])
+    Ok(T, [2, 1, 1, 1, 2])
+    Ok(T, [1, 1, 1])
+    Fail(T, [])
+    Fail(T, [1, 1])
+    Fail(T, [2])
+  })
+  it('Should validate for maxContains', () => {
+    const T = Type.Array(Type.Number(), { contains: Type.Literal(1), maxContains: 3 })
+    Ok(T, [1, 1, 1])
+    Ok(T, [1, 1])
+    Ok(T, [2, 2, 2, 2, 1, 1, 1])
+    Fail(T, [1, 1, 1, 1])
+  })
+  it('Should validate for minContains and maxContains', () => {
+    const T = Type.Array(Type.Number(), { contains: Type.Literal(1), minContains: 3, maxContains: 5 })
+    Fail(T, [1, 1])
+    Ok(T, [1, 1, 1])
+    Ok(T, [1, 1, 1, 1])
+    Ok(T, [1, 1, 1, 1, 1])
+    Fail(T, [1, 1, 1, 1, 1, 1])
+  })
+  it('Should not validate minContains or maxContains when contains is unspecified', () => {
+    const T = Type.Array(Type.Number(), { minContains: 3, maxContains: 5 })
+    Fail(T, [1, 1])
+    Fail(T, [1, 1, 1])
+    Fail(T, [1, 1, 1, 1])
+    Fail(T, [1, 1, 1, 1, 1])
+    Fail(T, [1, 1, 1, 1, 1, 1])
+  })
+  it('Should produce illogical schema when contains is not sub type of items', () => {
+    const T = Type.Array(Type.Number(), { contains: Type.String(), minContains: 3, maxContains: 5 })
+    Fail(T, [1, 1])
+    Fail(T, [1, 1, 1])
+    Fail(T, [1, 1, 1, 1])
+    Fail(T, [1, 1, 1, 1, 1])
+    Fail(T, [1, 1, 1, 1, 1, 1])
+  })
 })
diff --git a/test/runtime/schema/boolean.ts b/test/runtime/schema/boolean.ts
index a784cf6b9..f8f75a55e 100644
--- a/test/runtime/schema/boolean.ts
+++ b/test/runtime/schema/boolean.ts
@@ -7,32 +7,26 @@ describe('type/schema/Boolean', () => {
     Ok(T, true)
     Ok(T, false)
   })
-
   it('Should not validate a number', () => {
     const T = Type.Boolean()
     Fail(T, 1)
   })
-
   it('Should not validate a string', () => {
     const T = Type.Boolean()
     Fail(T, 'true')
   })
-
   it('Should not validate an array', () => {
     const T = Type.Boolean()
     Fail(T, [true])
   })
-
   it('Should not validate an object', () => {
     const T = Type.Boolean()
     Fail(T, {})
   })
-
   it('Should not validate an null', () => {
     const T = Type.Boolean()
     Fail(T, null)
   })
-
   it('Should not validate an undefined', () => {
     const T = Type.Boolean()
     Fail(T, undefined)
diff --git a/test/runtime/schema/composite.ts b/test/runtime/schema/composite.ts
index 93061fca4..23e5d1055 100644
--- a/test/runtime/schema/composite.ts
+++ b/test/runtime/schema/composite.ts
@@ -89,6 +89,6 @@ describe('type/schema/Composite', () => {
     })
     const A = Type.Composite([T])
     const B = Type.Composite([T])
-    Assert.isEqual(A, B)
+    Assert.IsEqual(A, B)
   })
 })
diff --git a/test/runtime/schema/date.ts b/test/runtime/schema/date.ts
index 7843e4af1..659c704b9 100644
--- a/test/runtime/schema/date.ts
+++ b/test/runtime/schema/date.ts
@@ -1,66 +1,70 @@
-import { Type } from '@sinclair/typebox'
-import { Ok, Fail } from './validate'
+// ---------------------------------------------------
+// No Longer Supported
+// ---------------------------------------------------
+
+// import { Type } from '@sinclair/typebox'
+// import { Ok, Fail } from './validate'
 
 // ----------------------------------------------------
 // These tests are implemented by way of .addKeyword()
 // which are configured to use Value.Check()
 // ----------------------------------------------------
 
-describe('type/schema/Date', () => {
-  it('Should not validate number', () => {
-    const T = Type.Date()
-    Fail(T, 1)
-  })
-  it('Should not validate string', () => {
-    const T = Type.Date()
-    Fail(T, 'hello')
-  })
-  it('Should not validate boolean', () => {
-    const T = Type.Date()
-    Fail(T, true)
-  })
-  it('Should not validate array', () => {
-    const T = Type.Date()
-    Fail(T, [1, 2, 3])
-  })
-  it('Should not validate object', () => {
-    const T = Type.Date()
-    Fail(T, { a: 1, b: 2 })
-  })
-  it('Should not validate null', () => {
-    const T = Type.Date()
-    Fail(T, null)
-  })
-  it('Should not validate undefined', () => {
-    const T = Type.Date()
-    Fail(T, undefined)
-  })
-  it('Should validate Date', () => {
-    const T = Type.Date()
-    Ok(T, new Date())
-  })
-  it('Should not validate Date if is invalid', () => {
-    const T = Type.Date()
-    Fail(T, new Date('not-a-valid-date'))
-  })
-  it('Should validate Date minimumTimestamp', () => {
-    const T = Type.Date({ minimumTimestamp: 10 })
-    Fail(T, new Date(9))
-    Ok(T, new Date(10))
-  })
-  it('Should validate Date maximumTimestamp', () => {
-    const T = Type.Date({ maximumTimestamp: 10 })
-    Ok(T, new Date(10))
-    Fail(T, new Date(11))
-  })
-  it('Should validate Date exclusiveMinimumTimestamp', () => {
-    const T = Type.Date({ exclusiveMinimumTimestamp: 10 })
-    Fail(T, new Date(10))
-    Ok(T, new Date(11))
-  })
-  it('Should validate Date exclusiveMaximumTimestamp', () => {
-    const T = Type.Date({ exclusiveMaximumTimestamp: 10 })
-    Ok(T, new Date(9))
-    Fail(T, new Date(10))
-  })
-})
+// describe('type/schema/Date', () => {
+//   it('Should not validate number', () => {
+//     const T = Type.Date()
+//     Fail(T, 1)
+//   })
+//   it('Should not validate string', () => {
+//     const T = Type.Date()
+//     Fail(T, 'hello')
+//   })
+//   it('Should not validate boolean', () => {
+//     const T = Type.Date()
+//     Fail(T, true)
+//   })
+//   it('Should not validate array', () => {
+//     const T = Type.Date()
+//     Fail(T, [1, 2, 3])
+//   })
+//   it('Should not validate object', () => {
+//     const T = Type.Date()
+//     Fail(T, { a: 1, b: 2 })
+//   })
+//   it('Should not validate null', () => {
+//     const T = Type.Date()
+//     Fail(T, null)
+//   })
+//   it('Should not validate undefined', () => {
+//     const T = Type.Date()
+//     Fail(T, undefined)
+//   })
+//   it('Should validate Date', () => {
+//     const T = Type.Date()
+//     Ok(T, new Date())
+//   })
+//   it('Should not validate Date if is invalid', () => {
+//     const T = Type.Date()
+//     Fail(T, new Date('not-a-valid-date'))
+//   })
+//   it('Should validate Date minimumTimestamp', () => {
+//     const T = Type.Date({ minimumTimestamp: 10 })
+//     Fail(T, new Date(9))
+//     Ok(T, new Date(10))
+//   })
+//   it('Should validate Date maximumTimestamp', () => {
+//     const T = Type.Date({ maximumTimestamp: 10 })
+//     Ok(T, new Date(10))
+//     Fail(T, new Date(11))
+//   })
+//   it('Should validate Date exclusiveMinimumTimestamp', () => {
+//     const T = Type.Date({ exclusiveMinimumTimestamp: 10 })
+//     Fail(T, new Date(10))
+//     Ok(T, new Date(11))
+//   })
+//   it('Should validate Date exclusiveMaximumTimestamp', () => {
+//     const T = Type.Date({ exclusiveMaximumTimestamp: 10 })
+//     Ok(T, new Date(9))
+//     Fail(T, new Date(10))
+//   })
+// })
diff --git a/test/runtime/schema/enum.ts b/test/runtime/schema/enum.ts
index 4e52e0ead..910e16e27 100644
--- a/test/runtime/schema/enum.ts
+++ b/test/runtime/schema/enum.ts
@@ -20,7 +20,6 @@ describe('type/schema/Enum', () => {
     Fail(T, 'Foo')
     Fail(T, 'Bar')
   })
-
   it('Should validate when emum has defined string values', () => {
     enum Kind {
       Foo = 'foo',
@@ -30,7 +29,6 @@ describe('type/schema/Enum', () => {
     Ok(T, 'foo')
     Ok(T, 'bar')
   })
-
   it('Should not validate when emum has defined string values and user passes numeric', () => {
     enum Kind {
       Foo = 'foo',
@@ -40,7 +38,6 @@ describe('type/schema/Enum', () => {
     Fail(T, 0)
     Fail(T, 1)
   })
-
   it('Should validate when enum has one or more string values', () => {
     enum Kind {
       Foo,
diff --git a/test/runtime/schema/index.ts b/test/runtime/schema/index.ts
index 6f60c4ce7..0c6e11f6a 100644
--- a/test/runtime/schema/index.ts
+++ b/test/runtime/schema/index.ts
@@ -8,7 +8,6 @@ import './integer'
 import './intersect'
 import './keyof'
 import './literal'
-import './modifier'
 import './never'
 import './not'
 import './null'
@@ -23,7 +22,7 @@ import './readonly'
 import './recursive'
 import './record'
 import './ref'
-import './regex'
+import './regexp'
 import './required'
 import './string'
 import './template-literal'
diff --git a/test/runtime/schema/integer.ts b/test/runtime/schema/integer.ts
index 281774ac3..5d984691f 100644
--- a/test/runtime/schema/integer.ts
+++ b/test/runtime/schema/integer.ts
@@ -6,32 +6,26 @@ describe('type/schema/Integer', () => {
     const T = Type.Integer()
     Fail(T, 3.14)
   })
-
   it('Should validate integer', () => {
     const T = Type.Integer()
     Ok(T, 1)
   })
-
   it('Should not validate string', () => {
     const T = Type.Integer()
     Fail(T, 'hello')
   })
-
   it('Should not validate boolean', () => {
     const T = Type.Integer()
     Fail(T, true)
   })
-
   it('Should not validate array', () => {
     const T = Type.Integer()
     Fail(T, [1, 2, 3])
   })
-
   it('Should not validate object', () => {
     const T = Type.Integer()
     Fail(T, { a: 1, b: 2 })
   })
-
   it('Should not validate null', () => {
     const T = Type.Integer()
     Fail(T, null)
@@ -40,31 +34,26 @@ describe('type/schema/Integer', () => {
     const T = Type.Integer()
     Fail(T, undefined)
   })
-
   it('Should validate minimum', () => {
     const T = Type.Integer({ minimum: 10 })
     Fail(T, 9)
     Ok(T, 10)
   })
-
   it('Should validate maximum', () => {
     const T = Type.Integer({ maximum: 10 })
     Ok(T, 10)
     Fail(T, 11)
   })
-
   it('Should validate Date exclusiveMinimum', () => {
     const T = Type.Integer({ exclusiveMinimum: 10 })
     Fail(T, 10)
     Ok(T, 11)
   })
-
   it('Should validate Date exclusiveMaximum', () => {
     const T = Type.Integer({ exclusiveMaximum: 10 })
     Ok(T, 9)
     Fail(T, 10)
   })
-
   it('Should not validate NaN', () => {
     Fail(Type.Integer(), NaN)
   })
diff --git a/test/runtime/schema/intersect.ts b/test/runtime/schema/intersect.ts
index 55f4f0659..5e4b64a4f 100644
--- a/test/runtime/schema/intersect.ts
+++ b/test/runtime/schema/intersect.ts
@@ -80,7 +80,6 @@ describe('type/schema/Intersect', () => {
     const T = Type.Intersect([A, B])
     Fail(T, { x: 1, y: 1 })
   })
-
   it('unevaluatedProperties with Record 1', () => {
     const T = Type.Intersect(
       [
diff --git a/test/runtime/schema/keyof.ts b/test/runtime/schema/keyof.ts
index f637ee5f0..17b36914f 100644
--- a/test/runtime/schema/keyof.ts
+++ b/test/runtime/schema/keyof.ts
@@ -16,7 +16,6 @@ describe('type/schema/KeyOf', () => {
     Ok(T, 'z')
     Fail(T, 'w')
   })
-
   it('Should validate when using pick', () => {
     const T = Type.KeyOf(
       Type.Pick(
@@ -32,7 +31,6 @@ describe('type/schema/KeyOf', () => {
     Ok(T, 'y')
     Fail(T, 'z')
   })
-
   it('Should validate when using omit', () => {
     const T = Type.KeyOf(
       Type.Omit(
@@ -44,7 +42,6 @@ describe('type/schema/KeyOf', () => {
         ['x', 'y'],
       ),
     )
-
     Fail(T, 'x')
     Fail(T, 'y')
     Ok(T, 'z')
diff --git a/test/runtime/schema/literal.ts b/test/runtime/schema/literal.ts
index fe5e0f578..d517697d3 100644
--- a/test/runtime/schema/literal.ts
+++ b/test/runtime/schema/literal.ts
@@ -10,12 +10,10 @@ describe('type/schema/Literal', () => {
     const T = Type.Literal('hello')
     Ok(T, 'hello')
   })
-
   it('Should validate literal boolean', () => {
     const T = Type.Literal(true)
     Ok(T, true)
   })
-
   it('Should not validate invalid literal number', () => {
     const T = Type.Literal(42)
     Fail(T, 43)
@@ -28,13 +26,11 @@ describe('type/schema/Literal', () => {
     const T = Type.Literal(false)
     Fail(T, true)
   })
-
   it('Should validate literal union', () => {
     const T = Type.Union([Type.Literal(42), Type.Literal('hello')])
     Ok(T, 42)
     Ok(T, 'hello')
   })
-
   it('Should not validate invalid literal union', () => {
     const T = Type.Union([Type.Literal(42), Type.Literal('hello')])
     Fail(T, 43)
diff --git a/test/runtime/schema/modifier.ts b/test/runtime/schema/modifier.ts
deleted file mode 100644
index 43e76c2b1..000000000
--- a/test/runtime/schema/modifier.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { Type } from '@sinclair/typebox'
-
-describe('type/schema/Modifier', () => {})
diff --git a/test/runtime/schema/null.ts b/test/runtime/schema/null.ts
index bd9c709bb..b338d78eb 100644
--- a/test/runtime/schema/null.ts
+++ b/test/runtime/schema/null.ts
@@ -6,32 +6,26 @@ describe('type/schema/Null', () => {
     const T = Type.Null()
     Fail(T, 1)
   })
-
   it('Should not validate string', () => {
     const T = Type.Null()
     Fail(T, 'hello')
   })
-
   it('Should not validate boolean', () => {
     const T = Type.Null()
     Fail(T, true)
   })
-
   it('Should not validate array', () => {
     const T = Type.Null()
     Fail(T, [1, 2, 3])
   })
-
   it('Should not validate object', () => {
     const T = Type.Null()
     Fail(T, { a: 1, b: 2 })
   })
-
   it('Should not validate null', () => {
     const T = Type.Null()
     Ok(T, null)
   })
-
   it('Should not validate undefined', () => {
     const T = Type.Null()
     Fail(T, undefined)
diff --git a/test/runtime/schema/number.ts b/test/runtime/schema/number.ts
index 99140d591..880a85e4a 100644
--- a/test/runtime/schema/number.ts
+++ b/test/runtime/schema/number.ts
@@ -6,12 +6,10 @@ describe('type/schema/Number', () => {
     const T = Type.Number()
     Ok(T, 3.14)
   })
-
   it('Should validate integer', () => {
     const T = Type.Number()
     Ok(T, 1)
   })
-
   it('Should not validate string', () => {
     const T = Type.Number()
     Fail(T, 'hello')
@@ -36,31 +34,26 @@ describe('type/schema/Number', () => {
     const T = Type.Number()
     Fail(T, undefined)
   })
-
   it('Should validate minimum', () => {
     const T = Type.Number({ minimum: 10 })
     Fail(T, 9)
     Ok(T, 10)
   })
-
   it('Should validate maximum', () => {
     const T = Type.Number({ maximum: 10 })
     Ok(T, 10)
     Fail(T, 11)
   })
-
   it('Should validate Date exclusiveMinimum', () => {
     const T = Type.Number({ exclusiveMinimum: 10 })
     Fail(T, 10)
     Ok(T, 11)
   })
-
   it('Should validate Date exclusiveMaximum', () => {
     const T = Type.Number({ exclusiveMaximum: 10 })
     Ok(T, 9)
     Fail(T, 10)
   })
-
   it('Should not validate NaN', () => {
     Fail(Type.Number(), NaN)
   })
diff --git a/test/runtime/schema/object.ts b/test/runtime/schema/object.ts
index 98b9a2761..cabe95979 100644
--- a/test/runtime/schema/object.ts
+++ b/test/runtime/schema/object.ts
@@ -6,27 +6,22 @@ describe('type/schema/Object', () => {
     const T = Type.Object({})
     Fail(T, 42)
   })
-
   it('Should not validate a string', () => {
     const T = Type.Object({})
     Fail(T, 'hello')
   })
-
   it('Should not validate a boolean', () => {
     const T = Type.Object({})
     Fail(T, true)
   })
-
   it('Should not validate a null', () => {
     const T = Type.Object({})
     Fail(T, null)
   })
-
   it('Should not validate an array', () => {
     const T = Type.Object({})
     Fail(T, [1, 2])
   })
-
   it('Should validate with correct property values', () => {
     const T = Type.Object({
       a: Type.Number(),
@@ -43,7 +38,6 @@ describe('type/schema/Object', () => {
       e: { x: 10, y: 20 },
     })
   })
-
   it('Should not validate with incorrect property values', () => {
     const T = Type.Object({
       a: Type.Number(),
diff --git a/test/runtime/schema/omit.ts b/test/runtime/schema/omit.ts
index 3ba6a3aa3..7a1d6e108 100644
--- a/test/runtime/schema/omit.ts
+++ b/test/runtime/schema/omit.ts
@@ -15,7 +15,6 @@ describe('type/schema/Omit', () => {
     const T = Type.Omit(A, ['z'])
     Ok(T, { x: 1, y: 1 })
   })
-
   it('Should remove required properties on the target schema', () => {
     const A = Type.Object(
       {
@@ -28,12 +27,11 @@ describe('type/schema/Omit', () => {
     const T = Type.Omit(A, ['z'])
     strictEqual(T.required!.includes('z'), false)
   })
-
   it('Should delete the required property if no required properties remain', () => {
     const A = Type.Object(
       {
         x: Type.Optional(Type.Number()),
-        y: Type.ReadonlyOptional(Type.Number()),
+        y: Type.Readonly(Type.Optional(Type.Number())),
         z: Type.Number(),
       },
       { additionalProperties: false },
@@ -41,7 +39,6 @@ describe('type/schema/Omit', () => {
     const T = Type.Omit(A, ['z'])
     strictEqual(T.required, undefined)
   })
-
   it('Should inherit options from the source object', () => {
     const A = Type.Object(
       {
@@ -55,7 +52,6 @@ describe('type/schema/Omit', () => {
     strictEqual(A.additionalProperties, false)
     strictEqual(T.additionalProperties, false)
   })
-
   it('Should omit with keyof object', () => {
     const A = Type.Object({
       x: Type.Number(),
diff --git a/test/runtime/schema/partial.ts b/test/runtime/schema/partial.ts
index 9b9490288..c28f1368e 100644
--- a/test/runtime/schema/partial.ts
+++ b/test/runtime/schema/partial.ts
@@ -1,4 +1,4 @@
-import { Type, Modifier } from '@sinclair/typebox'
+import { Type, Readonly, Optional } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
@@ -18,11 +18,10 @@ describe('type/schema/Partial', () => {
     Ok(T, { x: 1 })
     Ok(T, {})
   })
-
   it('Should update modifier types correctly when converting to partial', () => {
     const A = Type.Object(
       {
-        x: Type.ReadonlyOptional(Type.Number()),
+        x: Type.Readonly(Type.Optional(Type.Number())),
         y: Type.Readonly(Type.Number()),
         z: Type.Optional(Type.Number()),
         w: Type.Number(),
@@ -30,12 +29,13 @@ describe('type/schema/Partial', () => {
       { additionalProperties: false },
     )
     const T = Type.Partial(A)
-    strictEqual(T.properties.x[Modifier], 'ReadonlyOptional')
-    strictEqual(T.properties.y[Modifier], 'ReadonlyOptional')
-    strictEqual(T.properties.z[Modifier], 'Optional')
-    strictEqual(T.properties.w[Modifier], 'Optional')
+    strictEqual(T.properties.x[Readonly], 'Readonly')
+    strictEqual(T.properties.x[Optional], 'Optional')
+    strictEqual(T.properties.y[Readonly], 'Readonly')
+    strictEqual(T.properties.y[Optional], 'Optional')
+    strictEqual(T.properties.z[Optional], 'Optional')
+    strictEqual(T.properties.w[Optional], 'Optional')
   })
-
   it('Should inherit options from the source object', () => {
     const A = Type.Object(
       {
diff --git a/test/runtime/schema/pick.ts b/test/runtime/schema/pick.ts
index 99f49f700..39dde3a06 100644
--- a/test/runtime/schema/pick.ts
+++ b/test/runtime/schema/pick.ts
@@ -15,7 +15,6 @@ describe('type/schema/Pick', () => {
     const T = Type.Pick(Vector3, ['x', 'y'])
     Ok(T, { x: 1, y: 1 })
   })
-
   it('Should remove required properties on the target schema', () => {
     const A = Type.Object(
       {
@@ -28,12 +27,11 @@ describe('type/schema/Pick', () => {
     const T = Type.Pick(A, ['x', 'y'])
     strictEqual(T.required!.includes('z'), false)
   })
-
   it('Should delete the required property if no required properties remain', () => {
     const A = Type.Object(
       {
         x: Type.Optional(Type.Number()),
-        y: Type.ReadonlyOptional(Type.Number()),
+        y: Type.Readonly(Type.Optional(Type.Number())),
         z: Type.Number(),
       },
       { additionalProperties: false },
@@ -41,7 +39,6 @@ describe('type/schema/Pick', () => {
     const T = Type.Pick(A, ['x', 'y'])
     strictEqual(T.required, undefined)
   })
-
   it('Should inherit options from the source object', () => {
     const A = Type.Object(
       {
@@ -55,7 +52,6 @@ describe('type/schema/Pick', () => {
     strictEqual(A.additionalProperties, false)
     strictEqual(T.additionalProperties, false)
   })
-
   it('Should pick with keyof object', () => {
     const A = Type.Object({
       x: Type.Number(),
diff --git a/test/runtime/schema/readonly-optional.ts b/test/runtime/schema/readonly-optional.ts
index 59f2f4baf..6025c3cf1 100644
--- a/test/runtime/schema/readonly-optional.ts
+++ b/test/runtime/schema/readonly-optional.ts
@@ -6,7 +6,7 @@ describe('type/schema/ReadonlyOptional', () => {
   it('Should validate object with optional', () => {
     const T = Type.Object(
       {
-        a: Type.ReadonlyOptional(Type.String()),
+        a: Type.Readonly(Type.Optional(Type.String())),
         b: Type.String(),
       },
       { additionalProperties: false },
@@ -17,7 +17,7 @@ describe('type/schema/ReadonlyOptional', () => {
   it('Should remove required value from schema', () => {
     const T = Type.Object(
       {
-        a: Type.ReadonlyOptional(Type.String()),
+        a: Type.Readonly(Type.Optional(Type.String())),
         b: Type.String(),
       },
       { additionalProperties: false },
diff --git a/test/runtime/schema/readonly.ts b/test/runtime/schema/readonly.ts
index 50f75eb99..a651d3af3 100644
--- a/test/runtime/schema/readonly.ts
+++ b/test/runtime/schema/readonly.ts
@@ -13,7 +13,6 @@ describe('type/schema/Readonly', () => {
     )
     Ok(T, { a: 'hello', b: 'world' })
   })
-
   it('Should retain required array on object', () => {
     const T = Type.Object(
       {
diff --git a/test/runtime/schema/record.ts b/test/runtime/schema/record.ts
index d772d8817..6a6ba818c 100644
--- a/test/runtime/schema/record.ts
+++ b/test/runtime/schema/record.ts
@@ -55,7 +55,7 @@ describe('type/schema/Record', () => {
     Fail(R, { a: 1, b: 2, c: 3, d: 4 })
   })
   it('Should should validate when specifying regular expressions', () => {
-    const K = Type.RegEx(/^op_.*$/)
+    const K = Type.RegExp(/^op_.*$/)
     const T = Type.Record(K, Type.Number())
     Ok(T, {
       op_a: 1,
@@ -64,7 +64,7 @@ describe('type/schema/Record', () => {
     })
   })
   it('Should should not validate when specifying regular expressions and passing invalid property', () => {
-    const K = Type.RegEx(/^op_.*$/)
+    const K = Type.RegExp(/^op_.*$/)
     const T = Type.Record(K, Type.Number(), { additionalProperties: false })
     Fail(T, {
       op_a: 1,
diff --git a/test/runtime/schema/recursive.ts b/test/runtime/schema/recursive.ts
index 8ec132c0c..b2f90d756 100644
--- a/test/runtime/schema/recursive.ts
+++ b/test/runtime/schema/recursive.ts
@@ -10,9 +10,8 @@ describe('type/schema/Recursive', () => {
         nodes: Type.Array(Node),
       }),
     )
-    Assert.isEqual(Node.$id === undefined, false)
+    Assert.IsEqual(Node.$id === undefined, false)
   })
-
   it('Should override default ordinal $id if specified', () => {
     const Node = Type.Recursive(
       (Node) =>
@@ -22,9 +21,8 @@ describe('type/schema/Recursive', () => {
         }),
       { $id: 'Node' },
     )
-    Assert.isEqual(Node.$id === 'Node', true)
+    Assert.IsEqual(Node.$id === 'Node', true)
   })
-
   it('Should validate recursive node type', () => {
     const Node = Type.Recursive((This) =>
       Type.Object({
@@ -40,7 +38,6 @@ describe('type/schema/Recursive', () => {
       ],
     })
   })
-
   it('Should validate wrapped recursive node type', () => {
     const Node = Type.Tuple([
       Type.Recursive((This) =>
@@ -60,7 +57,6 @@ describe('type/schema/Recursive', () => {
       },
     ])
   })
-
   it('Should not validate wrapped recursive node type with invalid id', () => {
     const Node = Type.Tuple([
       Type.Recursive((This) =>
diff --git a/test/runtime/schema/ref.ts b/test/runtime/schema/ref.ts
index cfab94010..a3d522f89 100644
--- a/test/runtime/schema/ref.ts
+++ b/test/runtime/schema/ref.ts
@@ -23,7 +23,6 @@ describe('type/schema/Ref', () => {
       [T],
     )
   })
-
   it('Should not validate when passing invalid data', () => {
     const T = Type.Object(
       {
@@ -60,7 +59,6 @@ describe('type/schema/Ref', () => {
       },
       { $id: 'T' },
     )
-
     Ok(T, { x: 1, y: 2, z: 3 }, [R])
     Ok(T, { x: 1, y: 2, z: 3, r: { name: 'hello' } }, [R])
     Fail(T, { x: 1, y: 2, z: 3, r: { name: 1 } }, [R])
diff --git a/test/runtime/schema/regex.ts b/test/runtime/schema/regex.ts
deleted file mode 100644
index 3c3b49a39..000000000
--- a/test/runtime/schema/regex.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import { Ok, Fail } from './validate'
-
-describe('type/schema/RegEx', () => {
-  it('Should validate numeric value', () => {
-    const T = Type.RegEx(/[012345]/)
-    Ok(T, '0')
-    Ok(T, '1')
-    Ok(T, '2')
-    Ok(T, '3')
-    Ok(T, '4')
-    Ok(T, '5')
-  })
-
-  it('Should validate true or false string value', () => {
-    const T = Type.RegEx(/true|false/)
-    Ok(T, 'true')
-    Ok(T, 'true')
-    Ok(T, 'true')
-    Ok(T, 'false')
-    Ok(T, 'false')
-    Ok(T, 'false')
-    Fail(T, '6')
-  })
-
-  it('Should not validate failed regex test', () => {
-    const T = Type.RegEx(/true|false/)
-    Fail(T, 'unknown')
-  })
-
-  it('Should pass numeric 5 digit test', () => {
-    const T = Type.RegEx(/[\d]{5}/)
-    Ok(T, '12345')
-  })
-})
diff --git a/test/runtime/schema/regexp.ts b/test/runtime/schema/regexp.ts
new file mode 100644
index 000000000..643b43b81
--- /dev/null
+++ b/test/runtime/schema/regexp.ts
@@ -0,0 +1,65 @@
+import { Type } from '@sinclair/typebox'
+import { Ok, Fail } from './validate'
+
+describe('type/schema/RegExp', () => {
+  //-----------------------------------------------------
+  // Regular Expression
+  //-----------------------------------------------------
+  it('Should validate regular expression 1', () => {
+    const T = Type.RegExp(/[012345]/)
+    Ok(T, '0')
+    Ok(T, '1')
+    Ok(T, '2')
+    Ok(T, '3')
+    Ok(T, '4')
+    Ok(T, '5')
+  })
+  it('Should validate regular expression 2', () => {
+    const T = Type.RegExp(/true|false/)
+    Ok(T, 'true')
+    Ok(T, 'true')
+    Ok(T, 'true')
+    Ok(T, 'false')
+    Ok(T, 'false')
+    Ok(T, 'false')
+    Fail(T, '6')
+  })
+  it('Should validate regular expression 3', () => {
+    const T = Type.RegExp(/true|false/)
+    Fail(T, 'unknown')
+  })
+  it('Should validate regular expression 4', () => {
+    const T = Type.RegExp(/[\d]{5}/)
+    Ok(T, '12345')
+  })
+  //-----------------------------------------------------
+  // Regular Pattern
+  //-----------------------------------------------------
+  it('Should validate pattern 1', () => {
+    const T = Type.RegExp('[012345]')
+    Ok(T, '0')
+    Ok(T, '1')
+    Ok(T, '2')
+    Ok(T, '3')
+    Ok(T, '4')
+    Ok(T, '5')
+  })
+  it('Should validate pattern 2', () => {
+    const T = Type.RegExp('true|false')
+    Ok(T, 'true')
+    Ok(T, 'true')
+    Ok(T, 'true')
+    Ok(T, 'false')
+    Ok(T, 'false')
+    Ok(T, 'false')
+    Fail(T, '6')
+  })
+  it('Should validate pattern 3', () => {
+    const T = Type.RegExp('true|false')
+    Fail(T, 'unknown')
+  })
+  it('Should validate pattern 4', () => {
+    const T = Type.RegExp('[\\d]{5}')
+    Ok(T, '12345')
+  })
+})
diff --git a/test/runtime/schema/required.ts b/test/runtime/schema/required.ts
index fc8b6149e..19ab20f5c 100644
--- a/test/runtime/schema/required.ts
+++ b/test/runtime/schema/required.ts
@@ -1,4 +1,4 @@
-import { Type, Modifier } from '@sinclair/typebox'
+import { Type, Readonly, Optional } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
@@ -18,21 +18,19 @@ describe('type/schema/Required', () => {
     Fail(T, { x: 1 })
     Fail(T, {})
   })
-
   it('Should update modifier types correctly when converting to required', () => {
     const A = Type.Object({
-      x: Type.ReadonlyOptional(Type.Number()),
+      x: Type.Readonly(Type.Optional(Type.Number())),
       y: Type.Readonly(Type.Number()),
       z: Type.Optional(Type.Number()),
       w: Type.Number(),
     })
     const T = Type.Required(A)
-    strictEqual(T.properties.x[Modifier], 'Readonly')
-    strictEqual(T.properties.y[Modifier], 'Readonly')
-    strictEqual(T.properties.z[Modifier], undefined)
-    strictEqual(T.properties.w[Modifier], undefined)
+    strictEqual(T.properties.x[Readonly], 'Readonly')
+    strictEqual(T.properties.y[Readonly], 'Readonly')
+    strictEqual(T.properties.z[Optional], undefined)
+    strictEqual(T.properties.w[Optional], undefined)
   })
-
   it('Should inherit options from the source object', () => {
     const A = Type.Object(
       {
@@ -46,7 +44,6 @@ describe('type/schema/Required', () => {
     strictEqual(A.additionalPropeties, false)
     strictEqual(T.additionalPropeties, false)
   })
-
   // it('Should construct new object when targetting reference', () => {
   //   const T = Type.Object({ a: Type.String(), b: Type.String() }, { $id: 'T' })
   //   const R = Type.Ref(T)
diff --git a/test/runtime/schema/string.ts b/test/runtime/schema/string.ts
index 3a536bddd..73b62efa2 100644
--- a/test/runtime/schema/string.ts
+++ b/test/runtime/schema/string.ts
@@ -30,34 +30,28 @@ describe('type/schema/String', () => {
     const T = Type.String()
     Fail(T, undefined)
   })
-
   it('Should validate string format as email', () => {
     const T = Type.String({ format: 'email' })
     Ok(T, 'name@domain.com')
   })
-
   it('Should validate string format as uuid', () => {
     const T = Type.String({ format: 'uuid' })
     Ok(T, '4a7a17c9-2492-4a53-8e13-06ea2d3f3bbf')
   })
-
   it('Should validate string format as iso8601 date', () => {
     const T = Type.String({ format: 'date-time' })
     Ok(T, '2021-06-11T20:30:00-04:00')
   })
-
   it('Should validate minLength', () => {
     const T = Type.String({ minLength: 4 })
     Ok(T, '....')
     Fail(T, '...')
   })
-
   it('Should validate maxLength', () => {
     const T = Type.String({ maxLength: 4 })
     Ok(T, '....')
     Fail(T, '.....')
   })
-
   it('Should pass numeric 5 digit test', () => {
     const T = Type.String({ pattern: '[\\d]{5}' })
     Ok(T, '12345')
diff --git a/test/runtime/schema/template-literal.ts b/test/runtime/schema/template-literal.ts
index 4b3b7985f..80c862b58 100644
--- a/test/runtime/schema/template-literal.ts
+++ b/test/runtime/schema/template-literal.ts
@@ -130,7 +130,6 @@ describe('type/schema/TemplateLiteral', () => {
     Ok(T, 'ccc')
     Ok(T, 'dddd')
   })
-
   it('Should validate infinite pattern 5', () => {
     // prettier-ignore
     const T = Type.TemplateLiteral([
diff --git a/test/runtime/schema/tuple.ts b/test/runtime/schema/tuple.ts
index 773586e04..22f9999dc 100644
--- a/test/runtime/schema/tuple.ts
+++ b/test/runtime/schema/tuple.ts
@@ -9,50 +9,42 @@ describe('type/schema/Tuple', () => {
     const T = Type.Tuple([A, B])
     Ok(T, ['hello', 42])
   })
-
   it('Should not validate tuple of [string, number] when reversed', () => {
     const A = Type.String()
     const B = Type.Number()
     const T = Type.Tuple([A, B])
     Fail(T, [42, 'hello'])
   })
-
   it('Should validate with empty tuple', () => {
     const T = Type.Tuple([])
     Ok(T, [])
   })
-
   it('Should not validate with empty tuple with more items', () => {
     const T = Type.Tuple([])
     Fail(T, [1])
   })
-
   it('Should not validate with empty tuple with less items', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
     Fail(T, [1])
   })
-
   it('Should validate tuple of objects', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
     const T = Type.Tuple([A, B])
     Ok(T, [{ a: 'hello' }, { b: 42 }])
   })
-
   it('Should not validate tuple of objects when reversed', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
     const T = Type.Tuple([A, B])
     Fail(T, [{ b: 42 }, { a: 'hello' }])
   })
-
   it('Should not validate tuple when array is less than tuple length', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
     const T = Type.Tuple([A, B])
     Fail(T, [{ a: 'hello' }])
   })
-
   it('Should not validate tuple when array is greater than tuple length', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
diff --git a/test/runtime/schema/uint8array.ts b/test/runtime/schema/uint8array.ts
index 04cb8f732..96e2dd39c 100644
--- a/test/runtime/schema/uint8array.ts
+++ b/test/runtime/schema/uint8array.ts
@@ -1,56 +1,49 @@
-import { Type } from '@sinclair/typebox'
-import { Ok, Fail } from './validate'
-
-describe('type/schema/Uint8Array', () => {
-  it('Should not validate number', () => {
-    const T = Type.Uint8Array()
-    Fail(T, 1)
-  })
-
-  it('Should not validate string', () => {
-    const T = Type.Uint8Array()
-    Fail(T, 'hello')
-  })
-
-  it('Should not validate boolean', () => {
-    const T = Type.Uint8Array()
-    Fail(T, true)
-  })
-
-  it('Should not validate array', () => {
-    const T = Type.Uint8Array()
-    Fail(T, [1, 2, 3])
-  })
-
-  it('Should not validate object', () => {
-    const T = Type.Uint8Array()
-    Fail(T, { a: 1, b: 2 })
-  })
-
-  it('Should not validate null', () => {
-    const T = Type.Uint8Array()
-    Fail(T, null)
-  })
-
-  it('Should not validate undefined', () => {
-    const T = Type.Uint8Array()
-    Fail(T, undefined)
-  })
-
-  it('Should validate Uint8Array', () => {
-    const T = Type.Uint8Array()
-    Ok(T, new Uint8Array(100))
-  })
-
-  it('Should validate minByteLength', () => {
-    const T = Type.Uint8Array({ minByteLength: 4 })
-    Ok(T, new Uint8Array(4))
-    Fail(T, new Uint8Array(3))
-  })
-
-  it('Should validate maxByteLength', () => {
-    const T = Type.Uint8Array({ maxByteLength: 4 })
-    Ok(T, new Uint8Array(4))
-    Fail(T, new Uint8Array(5))
-  })
-})
+// ---------------------------------------------------
+// No Longer Supported
+// ---------------------------------------------------
+// import { Type } from '@sinclair/typebox'
+// import { Ok, Fail } from './validate'
+// describe('type/schema/Uint8Array', () => {
+//   it('Should not validate number', () => {
+//     const T = Type.Uint8Array()
+//     Fail(T, 1)
+//   })
+//   it('Should not validate string', () => {
+//     const T = Type.Uint8Array()
+//     Fail(T, 'hello')
+//   })
+//   it('Should not validate boolean', () => {
+//     const T = Type.Uint8Array()
+//     Fail(T, true)
+//   })
+//   it('Should not validate array', () => {
+//     const T = Type.Uint8Array()
+//     Fail(T, [1, 2, 3])
+//   })
+//   it('Should not validate object', () => {
+//     const T = Type.Uint8Array()
+//     Fail(T, { a: 1, b: 2 })
+//   })
+//   it('Should not validate null', () => {
+//     const T = Type.Uint8Array()
+//     Fail(T, null)
+//   })
+//   it('Should not validate undefined', () => {
+//     const T = Type.Uint8Array()
+//     Fail(T, undefined)
+//   })
+//   it('Should validate Uint8Array', () => {
+//     const T = Type.Uint8Array()
+//     Ok(T, new Uint8Array(100))
+//   })
+//   it('Should validate minByteLength', () => {
+//     const T = Type.Uint8Array({ minByteLength: 4 })
+//     Ok(T, new Uint8Array(4))
+//     Fail(T, new Uint8Array(3))
+//   })
+//   it('Should validate maxByteLength', () => {
+//     const T = Type.Uint8Array({ maxByteLength: 4 })
+//     Ok(T, new Uint8Array(4))
+//     Fail(T, new Uint8Array(5))
+//   })
+// })
diff --git a/test/runtime/schema/union.ts b/test/runtime/schema/union.ts
index 10d3e5081..fc6493c91 100644
--- a/test/runtime/schema/union.ts
+++ b/test/runtime/schema/union.ts
@@ -11,7 +11,6 @@ describe('type/schema/Union', () => {
     Ok(T, true)
     Ok(T, 42)
   })
-
   it('Should validate union of objects', () => {
     const A = Type.Object({ a: Type.String() }, { additionalProperties: false })
     const B = Type.Object({ b: Type.String() }, { additionalProperties: false })
@@ -19,7 +18,6 @@ describe('type/schema/Union', () => {
     Ok(T, { a: 'hello' })
     Ok(T, { b: 'world' })
   })
-
   it('Should fail to validate for descriminated union types', () => {
     const A = Type.Object({ kind: Type.Literal('A'), value: Type.String() })
     const B = Type.Object({ kind: Type.Literal('B'), value: Type.Number() })
@@ -27,7 +25,6 @@ describe('type/schema/Union', () => {
     Fail(T, { kind: 'A', value: 42 }) // expect { kind: 'A', value: string }
     Fail(T, { kind: 'B', value: 'hello' }) // expect { kind: 'B', value: number }
   })
-
   it('Should validate union of objects where properties overlap', () => {
     const A = Type.Object({ a: Type.String() }, { additionalProperties: false })
     const B = Type.Object({ a: Type.String(), b: Type.String() }, { additionalProperties: false })
@@ -35,7 +32,6 @@ describe('type/schema/Union', () => {
     Ok(T, { a: 'hello' }) // A
     Ok(T, { a: 'hello', b: 'world' }) // B
   })
-
   it('Should validate union of overlapping property of varying type', () => {
     const A = Type.Object({ a: Type.String(), b: Type.Number() }, { additionalProperties: false })
     const B = Type.Object({ a: Type.String(), b: Type.String() }, { additionalProperties: false })
@@ -43,7 +39,6 @@ describe('type/schema/Union', () => {
     Ok(T, { a: 'hello', b: 42 }) // A
     Ok(T, { a: 'hello', b: 'world' }) // B
   })
-
   it('Should validate union of literal strings', () => {
     const A = Type.Literal('hello')
     const B = Type.Literal('world')
@@ -51,7 +46,6 @@ describe('type/schema/Union', () => {
     Ok(T, 'hello') // A
     Ok(T, 'world') // B
   })
-
   it('Should not validate union of literal strings for unknown string', () => {
     const A = Type.Literal('hello')
     const B = Type.Literal('world')
diff --git a/test/runtime/schema/validate.ts b/test/runtime/schema/validate.ts
index 6e9cf4eac..12648225b 100644
--- a/test/runtime/schema/validate.ts
+++ b/test/runtime/schema/validate.ts
@@ -25,7 +25,6 @@ function schemaOf(schemaOf: string, value: unknown, schema: unknown) {
       return false
   }
 }
-
 export function createAjv(references: AnySchema[]) {
   return addFormats(new Ajv({}), ['date-time', 'time', 'date', 'email', 'hostname', 'ipv4', 'ipv6', 'uri', 'uri-reference', 'uuid', 'uri-template', 'json-pointer', 'relative-json-pointer', 'regex'])
     .addKeyword({ type: 'object', keyword: 'instanceOf', validate: schemaOf })
@@ -38,7 +37,6 @@ export function createAjv(references: AnySchema[]) {
     .addKeyword('maxByteLength')
     .addSchema(references)
 }
-
 export function Ok<T extends TSchema>(type: T, data: unknown, additional: AnySchema[] = []) {
   const ajv = createAjv(additional)
   function execute() {
@@ -65,7 +63,6 @@ export function Ok<T extends TSchema>(type: T, data: unknown, additional: AnySch
     throw Error('expected ok')
   }
 }
-
 export function Fail<T extends TSchema>(type: T, data: unknown, additional: AnySchema[] = []) {
   const ajv = createAjv(additional)
   function execute() {
diff --git a/test/runtime/schema/void.ts b/test/runtime/schema/void.ts
index 99d984c3e..1aab66be4 100644
--- a/test/runtime/schema/void.ts
+++ b/test/runtime/schema/void.ts
@@ -6,32 +6,26 @@ describe('type/schema/Void', () => {
     const T = Type.Void()
     Fail(T, 1)
   })
-
   it('Should not validate string', () => {
     const T = Type.Void()
     Fail(T, 'hello')
   })
-
   it('Should not validate boolean', () => {
     const T = Type.Void()
     Fail(T, true)
   })
-
   it('Should not validate array', () => {
     const T = Type.Void()
     Fail(T, [1, 2, 3])
   })
-
   it('Should not validate object', () => {
     const T = Type.Void()
     Fail(T, { a: 1, b: 2 })
   })
-
   it('Should validate null', () => {
     const T = Type.Null()
     Ok(T, null)
   })
-
   it('Should not validate undefined', () => {
     const T = Type.Void()
     Fail(T, undefined)
diff --git a/test/runtime/system/system.ts b/test/runtime/system/system.ts
index 33e3373db..9528e6dc8 100644
--- a/test/runtime/system/system.ts
+++ b/test/runtime/system/system.ts
@@ -38,7 +38,6 @@ describe('system/TypeSystem/ExactOptionalPropertyTypes', () => {
     Ok(T, { x: undefined })
   })
 })
-
 describe('system/TypeSystem/AllowNaN', () => {
   before(() => {
     TypeSystem.AllowNaN = true
@@ -97,7 +96,6 @@ describe('system/TypeSystem/AllowNaN', () => {
     Fail(T, -Infinity)
   })
 })
-
 describe('system/TypeSystem/AllowArrayObjects', () => {
   before(() => {
     TypeSystem.AllowArrayObjects = true
@@ -174,7 +172,6 @@ describe('system/TypeSystem/AllowVoidNull', () => {
     Ok(T, null)
   })
 })
-
 describe('system/TypeSystem/Format', () => {
   it('Should create and validate a format', () => {
     TypeSystem.Format('CreateFormat0', (value) => value === value.toLowerCase())
@@ -184,10 +181,9 @@ describe('system/TypeSystem/Format', () => {
   })
   it('Should throw if registering the same format twice', () => {
     TypeSystem.Format('CreateFormat1', (value) => true)
-    Assert.throws(() => TypeSystem.Format('CreateFormat1', (value) => true))
+    Assert.Throws(() => TypeSystem.Format('CreateFormat1', (value) => true))
   })
 })
-
 describe('system/TypeSystem/Type', () => {
   it('Should create and validate a type', () => {
     type BigNumberOptions = { minimum?: bigint; maximum?: bigint }
@@ -204,6 +200,6 @@ describe('system/TypeSystem/Type', () => {
   })
   it('Should throw if registering the same type twice', () => {
     TypeSystem.Type('CreateType1', () => true)
-    Assert.throws(() => TypeSystem.Type('CreateType1', () => true))
+    Assert.Throws(() => TypeSystem.Type('CreateType1', () => true))
   })
 })
diff --git a/test/runtime/type/extends/any.ts b/test/runtime/type/extends/any.ts
index ae1ae1597..3dd3e83ee 100644
--- a/test/runtime/type/extends/any.ts
+++ b/test/runtime/type/extends/any.ts
@@ -6,91 +6,91 @@ describe('type/extends/Any', () => {
   it('Should extend Any', () => {
     type T = any extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = any extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = any extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Boolean', () => {
     type T = any extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Number', () => {
     type T = any extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Integer', () => {
     type T = any extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Array 1', () => {
     type T = any extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Array 2', () => {
     type T = any extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Array(Type.String()))
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Tuple', () => {
     type T = any extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Object 1', () => {
     type T = any extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Object 2', () => {
     type T = any extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Object 3', () => {
     type T = any extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Object({ a: Type.Number() }))
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Union 1', () => {
     type T = any extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Union 2', () => {
     type T = any extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Any(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = any extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Undefined', () => {
     type T = any extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Void', () => {
     type T = any extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Date', () => {
     type T = any extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
 })
diff --git a/test/runtime/type/extends/array.ts b/test/runtime/type/extends/array.ts
index ac7b04e45..b734bc8ab 100644
--- a/test/runtime/type/extends/array.ts
+++ b/test/runtime/type/extends/array.ts
@@ -9,22 +9,22 @@ describe('type/extends/Array', () => {
   it('Should extend Array Varying 1', () => {
     type T = Array<any> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array Varying 2', () => {
     type T = Array<string> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array Varying 3', () => {
     type T = Array<any> extends Array<string> ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.String()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array Varying 4', () => {
     type T = Array<number> extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Number()), Type.Array(Type.String()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   // ----------------------------------------------
   // Any
@@ -32,112 +32,112 @@ describe('type/extends/Array', () => {
   it('Should extend Any', () => {
     type T = Array<any> extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = Array<any> extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = Array<any> extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = Array<any> extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = Array<any> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = Array<any> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = Array<any> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array 2', () => {
     type T = Array<string> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array 3', () => {
     type T = Array<any> extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Tuple', () => {
     type T = Array<any> extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = Array<any> extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = Array<any> extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 3', () => {
     type T = Array<any> extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({ a: Type.Number() }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 4', () => {
     type T = Array<any> extends { length: '1' } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({ length: Type.Literal('1') }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 5', () => {
     type T = Array<any> extends { length: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({ length: Type.Number() }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 1', () => {
     type T = Array<any> extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = Array<any> extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = Array<any> extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = Array<string> extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 5', () => {
     type T = Array<any> extends any | Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Array(Type.String())]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = Array<any> extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = Array<any> extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   // ----------------------------------------------
   // Constrained
@@ -145,121 +145,121 @@ describe('type/extends/Array', () => {
   it('Should extend constrained Any', () => {
     type T = Array<string> extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Unknown', () => {
     type T = Array<string> extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained String', () => {
     type T = Array<string> extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Boolean', () => {
     type T = Array<string> extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Number', () => {
     type T = Array<string> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Integer', () => {
     type T = Array<string> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Array 1', () => {
     type T = Array<string> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Array 2', () => {
     type T = Array<string> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Array 3', () => {
     type T = Array<string> extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Tuple', () => {
     type T = Array<string> extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Object 1', () => {
     type T = Array<string> extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Object 2', () => {
     type T = Array<string> extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Object 3', () => {
     type T = Array<string> extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({ a: Type.Number() }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Object 4', () => {
     type T = Array<string> extends { length: '1' } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({ length: Type.Literal('1') }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Object 5', () => {
     type T = Array<string> extends { length: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({ length: Type.Number() }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Union 1', () => {
     type T = Array<string> extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Null(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Union 2', () => {
     type T = Array<string> extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Union 3', () => {
     type T = Array<string> extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Union 4', () => {
     type T = Array<string> extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Union 5', () => {
     type T = Array<string> extends any | Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.String())]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Null', () => {
     type T = Array<string> extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Undefined', () => {
     type T = Array<string> extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Void', () => {
     type T = Array<string> extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = Array<string> extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/async-iterator.ts b/test/runtime/type/extends/async-iterator.ts
new file mode 100644
index 000000000..4eba4c020
--- /dev/null
+++ b/test/runtime/type/extends/async-iterator.ts
@@ -0,0 +1,72 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/AsyncIterator', () => {
+  // ----------------------------------------------
+  // Generic Varying
+  // ----------------------------------------------
+  it('Should extend AsyncIterator 1', () => {
+    type T = AsyncIterableIterator<any> extends AsyncIterableIterator<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.AsyncIterator(Type.Any()), Type.AsyncIterator(Type.Any()))
+    Assert.IsEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend AsyncIterator 2', () => {
+    type T = AsyncIterableIterator<string> extends AsyncIterableIterator<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.AsyncIterator(Type.String()), Type.AsyncIterator(Type.String()))
+    Assert.IsEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend AsyncIterator 3', () => {
+    type T = AsyncIterableIterator<'hello'> extends AsyncIterableIterator<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.AsyncIterator(Type.Literal('hello')), Type.AsyncIterator(Type.String()))
+    Assert.IsEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend AsyncIterator 4', () => {
+    type T = AsyncIterableIterator<string> extends AsyncIterableIterator<'hello'> ? 1 : 2
+    const R = TypeExtends.Extends(Type.AsyncIterator(Type.String()), Type.AsyncIterator(Type.Literal('hello')))
+    Assert.IsEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend AsyncIterator 5', () => {
+    type T = AsyncIterableIterator<string> extends AsyncIterableIterator<'hello' | number> ? 1 : 2
+    const R = TypeExtends.Extends(Type.AsyncIterator(Type.String()), Type.AsyncIterator(Type.Union([Type.Literal('hello'), Type.Number()])))
+    Assert.IsEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend AsyncIterator 6', () => {
+    type T = AsyncIterableIterator<'hello' | number> extends AsyncIterableIterator<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.AsyncIterator(Type.Union([Type.Literal('hello'), Type.Number()])), Type.AsyncIterator(Type.String()))
+    Assert.IsEqual(R, TypeExtendsResult.False)
+  })
+  // --------------------------------------------------------------------
+  // Structural
+  // --------------------------------------------------------------------
+  it('Should extends Any 1', () => {
+    type T = AsyncIterableIterator<number> extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.AsyncIterator(Type.Number()), Type.Any())
+    Assert.IsEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extends Any 2', () => {
+    type T = any extends AsyncIterableIterator<number> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.AsyncIterator(Type.Number()))
+    Assert.IsEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extends Unknown 1', () => {
+    type T = AsyncIterableIterator<number> extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.AsyncIterator(Type.Number()), Type.Unknown())
+    Assert.IsEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extends Unknown 2', () => {
+    type T = unknown extends AsyncIterableIterator<number> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.AsyncIterator(Type.Number()))
+    Assert.IsEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extends Never 1', () => {
+    type T = AsyncIterableIterator<number> extends never ? 1 : 2
+    const R = TypeExtends.Extends(Type.AsyncIterator(Type.Number()), Type.Never())
+    Assert.IsEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extends Never 2', () => {
+    type T = never extends AsyncIterableIterator<number> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Never(), Type.AsyncIterator(Type.Number()))
+    Assert.IsEqual(R, TypeExtendsResult.True)
+  })
+})
diff --git a/test/runtime/type/extends/bigint.ts b/test/runtime/type/extends/bigint.ts
index 454e22cbe..5346cfa39 100644
--- a/test/runtime/type/extends/bigint.ts
+++ b/test/runtime/type/extends/bigint.ts
@@ -6,96 +6,96 @@ describe('type/extends/BigInt', () => {
   it('Should extend Any', () => {
     type T = bigint extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = bigint extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = bigint extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = bigint extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = bigint extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = bigint extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = bigint extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = bigint extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = bigint extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Record(Type.Number(), Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = bigint extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = bigint extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Object({ a: Type.Literal(10) }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = bigint extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = bigint extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = bigint extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 4', () => {
     type T = bigint extends boolean | bigint ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Union([Type.Boolean(), Type.BigInt()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = bigint extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = bigint extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = bigint extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = bigint extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.BigInt(), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/boolean.ts b/test/runtime/type/extends/boolean.ts
index 8bb9b460f..1d56e21eb 100644
--- a/test/runtime/type/extends/boolean.ts
+++ b/test/runtime/type/extends/boolean.ts
@@ -6,86 +6,86 @@ describe('type/extends/Boolean', () => {
   it('Should extend Any', () => {
     type T = boolean extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = boolean extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = boolean extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Number', () => {
     type T = boolean extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = boolean extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = boolean extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = boolean extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = boolean extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Record(Type.Number(), Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = boolean extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Object({}, { additionalProperties: false }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = boolean extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = boolean extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = boolean extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = boolean extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = boolean extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = boolean extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = boolean extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = boolean extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Boolean(), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/constructor.ts b/test/runtime/type/extends/constructor.ts
index 82211cbe1..f5b6151d9 100644
--- a/test/runtime/type/extends/constructor.ts
+++ b/test/runtime/type/extends/constructor.ts
@@ -6,206 +6,206 @@ describe('type/extends/Constructor', () => {
   it('Should extend Function', () => {
     type T = (new () => number) extends () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Function([], Type.Number()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Constructor 1', () => {
     type T = (new () => number) extends new () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Number()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 2', () => {
     type T = (new () => any) extends new () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 3', () => {
     type T = (new () => number) extends new () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 4', () => {
     type T = (new (a: number) => number) extends new () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([], Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Constructor 5', () => {
     type T = (new (a: number | string) => number) extends new (a: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Union([Type.Number(), Type.String()])], Type.Number()), Type.Constructor([Type.Number()], Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 6', () => {
     type T = (new (a: number) => number) extends new (a: number | string) => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([Type.Union([Type.Number(), Type.String()])], Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Constructor 7', () => {
     type T = (new (a: number, b: number) => number) extends new (a: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Number(), Type.Number()], Type.Number()), Type.Constructor([Type.Number()], Type.Number()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Constructor 8', () => {
     type T = (new (a: number) => number) extends new (a: number, b: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([Type.Number(), Type.Number()], Type.Number()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 9', () => {
     type T = (new () => number) extends new () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 9', () => {
     type T = (new () => any) extends new () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 10', () => {
     type T = (new () => Array<any>) extends new () => object ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Array(Type.Any())), Type.Constructor([], Type.Object({})))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 11', () => {
     type T = (new () => Array<string>) extends new () => object ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Array(Type.String())), Type.Constructor([], Type.Object({})))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 12', () => {
     type T = (new () => object) extends new () => Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Object({})), Type.Constructor([], Type.Array(Type.Any())))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Constructor 13', () => {
     type T = (new (a: unknown) => number) extends new (a: any) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Unknown()], Type.Number({})), Type.Constructor([Type.Any()], Type.Number({})))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 14', () => {
     type T = (new (a: any) => number) extends new (a: unknown) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([Type.Any()], Type.Number({})), Type.Constructor([Type.Unknown()], Type.Number({})))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 15', () => {
     type T = (new () => any) extends new () => unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Any({})), Type.Constructor([], Type.Unknown({})))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Constructor 16', () => {
     type T = (new () => unknown) extends new () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Unknown({})), Type.Constructor([], Type.Any({})))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Any', () => {
     type T = (new () => number) extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = (new () => number) extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = (new () => number) extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = (new () => number) extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = (new () => number) extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = (new () => number) extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = (new () => number) extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 3', () => {
     type T = (new () => number) extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = (new () => number) extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = (() => number) extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Record(Type.Number(), Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = (new () => number) extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = (new () => number) extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 3', () => {
     type T = (new () => number) extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({ a: Type.Number() }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 4', () => {
     type T = (new () => number) extends { length: '1' } ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({ length: Type.Literal('1') }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = (new () => number) extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Null(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = (new () => number) extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = (new () => number) extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = (new () => number) extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 5', () => {
     type T = (new () => number) extends any | Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.String())]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = (new () => number) extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = (new () => number) extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = (new () => number) extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = (new () => number) extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/date.ts b/test/runtime/type/extends/date.ts
index 7aba817c8..04df6c661 100644
--- a/test/runtime/type/extends/date.ts
+++ b/test/runtime/type/extends/date.ts
@@ -6,91 +6,91 @@ describe('type/extends/Date', () => {
   it('Should extend Any', () => {
     type T = Date extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = Date extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = Date extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = Date extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = Date extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = Date extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = Date extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = Date extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = Date extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Record(Type.Number(), Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = Date extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = Date extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = Date extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = Date extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = Date extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = Date extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = Date extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = Date extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = Date extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Date(), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
 })
diff --git a/test/runtime/type/extends/function.ts b/test/runtime/type/extends/function.ts
index 7823aa382..0b334087d 100644
--- a/test/runtime/type/extends/function.ts
+++ b/test/runtime/type/extends/function.ts
@@ -6,206 +6,206 @@ describe('type/extends/Function', () => {
   it('Should extend Constructor 1', () => {
     type T = (() => number) extends new () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Constructor([], Type.Number()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Function 1', () => {
     type T = (() => number) extends () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Function([], Type.Number()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 2', () => {
     type T = (() => any) extends () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 3', () => {
     type T = (() => number) extends () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 4', () => {
     type T = ((a: number) => number) extends () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Number()], Type.Number()), Type.Function([], Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Function 5', () => {
     type T = ((a: number | string) => number) extends (a: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Union([Type.Number(), Type.String()])], Type.Number()), Type.Function([Type.Number()], Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 6', () => {
     type T = ((a: number) => number) extends (a: number | string) => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Number()], Type.Number()), Type.Function([Type.Union([Type.Number(), Type.String()])], Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Function 7', () => {
     type T = ((a: number, b: number) => number) extends (a: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Number(), Type.Number()], Type.Number()), Type.Function([Type.Number()], Type.Number()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Function 8', () => {
     type T = ((a: number) => number) extends (a: number, b: number) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Number()], Type.Number()), Type.Function([Type.Number(), Type.Number()], Type.Number()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 9', () => {
     type T = (() => number) extends () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Function([], Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 9', () => {
     type T = (() => any) extends () => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 10', () => {
     type T = (() => Array<any>) extends () => object ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Array(Type.Any())), Type.Function([], Type.Object({})))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 11', () => {
     type T = (() => Array<string>) extends () => object ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Array(Type.String())), Type.Function([], Type.Object({})))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 12', () => {
     type T = (() => object) extends () => Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Object({})), Type.Function([], Type.Array(Type.Any())))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Function 13', () => {
     type T = ((a: unknown) => number) extends (a: any) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Unknown()], Type.Number({})), Type.Function([Type.Any()], Type.Number({})))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 14', () => {
     type T = ((a: any) => number) extends (a: unknown) => number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([Type.Any()], Type.Number({})), Type.Function([Type.Unknown()], Type.Number({})))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 15', () => {
     type T = (() => any) extends () => unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Any({})), Type.Function([], Type.Unknown({})))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Function 16', () => {
     type T = (() => unknown) extends () => any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Unknown({})), Type.Function([], Type.Any({})))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Any', () => {
     type T = (() => number) extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = (() => number) extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = (() => number) extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = (() => number) extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = (() => number) extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = (() => number) extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = (() => number) extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 3', () => {
     type T = (() => number) extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = (() => number) extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = (() => number) extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Record(Type.Number(), Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = (() => number) extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = (() => number) extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 3', () => {
     type T = (() => number) extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({ a: Type.Number() }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 4', () => {
     type T = (() => number) extends { length: '1' } ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({ length: Type.Literal('1') }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 5', () => {
     type T = (() => number) extends { length: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({ length: Type.Number() }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 1', () => {
     type T = (() => number) extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Null(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = (() => number) extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = (() => number) extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = (() => number) extends any | Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 5', () => {
     type T = (() => number) extends any | Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.String())]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = (() => number) extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = (() => number) extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = (() => number) extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/index.ts b/test/runtime/type/extends/index.ts
index be6eed0b2..c826cc0fe 100644
--- a/test/runtime/type/extends/index.ts
+++ b/test/runtime/type/extends/index.ts
@@ -1,11 +1,13 @@
 import './any'
 import './array'
+import './async-iterator'
 import './bigint'
 import './boolean'
 import './constructor'
 import './date'
 import './function'
 import './integer'
+import './iterator'
 import './literal'
 import './not'
 import './null'
diff --git a/test/runtime/type/extends/integer.ts b/test/runtime/type/extends/integer.ts
index d0113e0f2..1c5d00995 100644
--- a/test/runtime/type/extends/integer.ts
+++ b/test/runtime/type/extends/integer.ts
@@ -6,91 +6,91 @@ describe('type/extends/Integer', () => {
   it('Should extend Any', () => {
     type T = number extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = number extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = number extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = number extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = number extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Integer', () => {
     type T = number extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array', () => {
     type T = number extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = number extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = number extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Record(Type.Number(), Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = number extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = number extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Object({ a: Type.Literal(10) }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = number extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = number extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = number extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = number extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Integer(), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = number extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/iterator.ts b/test/runtime/type/extends/iterator.ts
new file mode 100644
index 000000000..1cf5b6bfd
--- /dev/null
+++ b/test/runtime/type/extends/iterator.ts
@@ -0,0 +1,72 @@
+import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/extends/Iterator', () => {
+  // ----------------------------------------------
+  // Generic Varying
+  // ----------------------------------------------
+  it('Should extend Iterator 1', () => {
+    type T = IterableIterator<any> extends IterableIterator<any> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Iterator(Type.Any()), Type.Iterator(Type.Any()))
+    Assert.IsEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Iterator 2', () => {
+    type T = IterableIterator<string> extends IterableIterator<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Iterator(Type.String()), Type.Iterator(Type.String()))
+    Assert.IsEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Iterator 3', () => {
+    type T = IterableIterator<'hello'> extends IterableIterator<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Iterator(Type.Literal('hello')), Type.Iterator(Type.String()))
+    Assert.IsEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extend Iterator 4', () => {
+    type T = IterableIterator<string> extends IterableIterator<'hello'> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Iterator(Type.String()), Type.Iterator(Type.Literal('hello')))
+    Assert.IsEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Iterator 5', () => {
+    type T = IterableIterator<string> extends IterableIterator<'hello' | number> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Iterator(Type.String()), Type.Iterator(Type.Union([Type.Literal('hello'), Type.Number()])))
+    Assert.IsEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend Iterator 6', () => {
+    type T = IterableIterator<'hello' | number> extends IterableIterator<string> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Iterator(Type.Union([Type.Literal('hello'), Type.Number()])), Type.Iterator(Type.String()))
+    Assert.IsEqual(R, TypeExtendsResult.False)
+  })
+  // --------------------------------------------------------------------
+  // Structural
+  // --------------------------------------------------------------------
+  it('Should extends Any 1', () => {
+    type T = IterableIterator<number> extends any ? 1 : 2
+    const R = TypeExtends.Extends(Type.Iterator(Type.Number()), Type.Any())
+    Assert.IsEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extends Any 2', () => {
+    type T = any extends IterableIterator<number> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Any(), Type.Iterator(Type.Number()))
+    Assert.IsEqual(R, TypeExtendsResult.Union)
+  })
+  it('Should extends Unknown 1', () => {
+    type T = IterableIterator<number> extends unknown ? 1 : 2
+    const R = TypeExtends.Extends(Type.Iterator(Type.Number()), Type.Unknown())
+    Assert.IsEqual(R, TypeExtendsResult.True)
+  })
+  it('Should extends Unknown 2', () => {
+    type T = unknown extends IterableIterator<number> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Unknown(), Type.Iterator(Type.Number()))
+    Assert.IsEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extends Never 1', () => {
+    type T = IterableIterator<number> extends never ? 1 : 2
+    const R = TypeExtends.Extends(Type.Iterator(Type.Number()), Type.Never())
+    Assert.IsEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extends Never 2', () => {
+    type T = never extends IterableIterator<number> ? 1 : 2
+    const R = TypeExtends.Extends(Type.Never(), Type.Iterator(Type.Number()))
+    Assert.IsEqual(R, TypeExtendsResult.True)
+  })
+})
diff --git a/test/runtime/type/extends/literal.ts b/test/runtime/type/extends/literal.ts
index a99e26a95..7c23890fc 100644
--- a/test/runtime/type/extends/literal.ts
+++ b/test/runtime/type/extends/literal.ts
@@ -9,77 +9,77 @@ describe('type/extends/Literal', () => {
   it('Should extend Any (String)', () => {
     type T = 'hello' extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown (String)', () => {
     type T = 'hello' extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String (String)', () => {
     type T = 'hello' extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Boolean (String)', () => {
     type T = 'hello' extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number (String)', () => {
     type T = 'hello' extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer (String)', () => {
     type T = 'hello' extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array (String)', () => {
     type T = 'hello' extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple (String)', () => {
     type T = 'hello' extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1 (String)', () => {
     type T = 'hello' extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Object({}, { additionalProperties: false }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2 (String)', () => {
     type T = 'hello' extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1 (String)', () => {
     type T = 'hello' extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2 (String)', () => {
     type T = 'hello' extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3 (String)', () => {
     type T = 'hello' extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null (String)', () => {
     type T = 'hello' extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined (String)', () => {
     type T = 'hello' extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   // -------------------------------------------------------------------
   // Number Literal
@@ -87,77 +87,77 @@ describe('type/extends/Literal', () => {
   it('Should extend Any (Number)', () => {
     type T = 10 extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown (Number)', () => {
     type T = 10 extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String (Number)', () => {
     type T = 10 extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean (Number)', () => {
     type T = 10 extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number (Number)', () => {
     type T = 10 extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Integer (Number)', () => {
     type T = 10 extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array (Number)', () => {
     type T = 10 extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple (Number)', () => {
     type T = 10 extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1 (Number)', () => {
     type T = 10 extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Object({}, { additionalProperties: false }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2 (Number)', () => {
     type T = 10 extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1 (Number)', () => {
     type T = 10 extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2 (Number)', () => {
     type T = 10 extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3 (Number)', () => {
     type T = 10 extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null (Number)', () => {
     type T = 10 extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined (Number)', () => {
     type T = 10 extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   // -------------------------------------------------------------------
   // Boolean Literal
@@ -165,101 +165,101 @@ describe('type/extends/Literal', () => {
   it('Should extend Any (Boolean)', () => {
     type T = true extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown (Boolean)', () => {
     type T = true extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String (Boolean)', () => {
     type T = true extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean (Boolean)', () => {
     type T = true extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Number (Boolean)', () => {
     type T = true extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer (Boolean)', () => {
     type T = true extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array (Boolean)', () => {
     type T = true extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple (Boolean)', () => {
     type T = true extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record 1', () => {
     type T = 'hello' extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal('hello'), Type.Record(Type.Number(), Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 2', () => {
     type T = 10 extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(10), Type.Record(Type.Number(), Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record 3', () => {
     type T = true extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Record(Type.Number(), Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1 (Boolean)', () => {
     type T = true extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Object({}, { additionalProperties: false }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2 (Boolean)', () => {
     type T = true extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1 (Boolean)', () => {
     type T = true extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2 (Boolean)', () => {
     type T = true extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3 (Boolean)', () => {
     type T = true extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null (Boolean)', () => {
     type T = true extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined (Boolean)', () => {
     type T = true extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = true extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = true extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Literal(true), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/not.ts b/test/runtime/type/extends/not.ts
index e23e5352f..53f8d1e40 100644
--- a/test/runtime/type/extends/not.ts
+++ b/test/runtime/type/extends/not.ts
@@ -19,7 +19,7 @@ describe('type/extends/Not', () => {
     const A = Type.Number()
     const B = Type.Not(Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True) // we would expect false
+    Assert.IsEqual(R, TypeExtendsResult.True) // we would expect false
   })
   // ---------------------------------------------------------------------------
   // Nested
@@ -37,11 +37,11 @@ describe('type/extends/Not', () => {
     const R4 = TypeExtends.Extends(T4, Type.String())
     const R5 = TypeExtends.Extends(T5, Type.String())
 
-    Assert.isEqual(R1, TypeExtendsResult.True)
-    Assert.isEqual(R2, TypeExtendsResult.False)
-    Assert.isEqual(R3, TypeExtendsResult.True)
-    Assert.isEqual(R4, TypeExtendsResult.False)
-    Assert.isEqual(R5, TypeExtendsResult.True)
+    Assert.IsEqual(R1, TypeExtendsResult.True)
+    Assert.IsEqual(R2, TypeExtendsResult.False)
+    Assert.IsEqual(R3, TypeExtendsResult.True)
+    Assert.IsEqual(R4, TypeExtendsResult.False)
+    Assert.IsEqual(R5, TypeExtendsResult.True)
   })
 
   // ---------------------------------------------------------------------------
@@ -50,96 +50,96 @@ describe('type/extends/Not', () => {
   it('Should extend Any', () => {
     type T = unknown extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = unknown extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = unknown extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = unknown extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = unknown extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = unknown extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = unknown extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = unknown extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Array(Type.String()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = unknown extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = unknown extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = unknown extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Object({ a: Type.Number() }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = unknown extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = unknown extends any | number ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Union([Type.Any(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = unknown extends unknown | number ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = unknown extends unknown | any ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = unknown extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = unknown extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = unknown extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = unknown extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/null.ts b/test/runtime/type/extends/null.ts
index dc9077b94..702e16271 100644
--- a/test/runtime/type/extends/null.ts
+++ b/test/runtime/type/extends/null.ts
@@ -6,96 +6,96 @@ describe('type/extends/Null', () => {
   it('Should extend Any', () => {
     type T = null extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = null extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = null extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = null extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = null extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = null extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = null extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = null extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = null extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Record(Type.Number(), Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = null extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Object({}, { additionalProperties: false }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = null extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = null extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = null extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = null extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = null extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = null extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Undefined', () => {
     type T = null extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = null extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = null extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Null(), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/number.ts b/test/runtime/type/extends/number.ts
index c34c88573..aa647eca6 100644
--- a/test/runtime/type/extends/number.ts
+++ b/test/runtime/type/extends/number.ts
@@ -6,91 +6,91 @@ describe('type/extends/Number', () => {
   it('Should extend Any', () => {
     type T = number extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = number extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = number extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = number extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = number extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Integer', () => {
     type T = number extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array', () => {
     type T = number extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = number extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = number extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Record(Type.Number(), Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = number extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Object({}, { additionalProperties: false }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = number extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = number extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = number extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = number extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = number extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = number extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/object.ts b/test/runtime/type/extends/object.ts
index 0ab311516..172eb46bf 100644
--- a/test/runtime/type/extends/object.ts
+++ b/test/runtime/type/extends/object.ts
@@ -11,42 +11,42 @@ describe('type/extends/Object', () => {
     const A = Type.Object({ x: Type.Number(), y: Type.Number() })
     const B = Type.Object({ x: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = { x: number } extends { x: number; y: number } ? 1 : 2
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ x: Type.Number(), y: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = { x: number; y: string } extends { x: number } ? 1 : 2
     const A = Type.Object({ x: Type.Number(), y: Type.String() })
     const B = Type.Object({ x: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 4', () => {
     type T = { x: number } extends { x: number; y: string } ? 1 : 2
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ x: Type.Number(), y: Type.String() })
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 5', () => {
     type T = { x: number | string } extends { x: number } ? 1 : 2
     const A = Type.Object({ x: Type.Union([Type.Number(), Type.String()]) })
     const B = Type.Object({ x: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 6', () => {
     type T = { x: number } extends { x: number | string } ? 1 : 2
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ x: Type.Union([Type.Number(), Type.String()]) })
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   // ----------------------------------------------------------
   // Record
@@ -56,35 +56,35 @@ describe('type/extends/Object', () => {
     const A = Type.Object({ a: Type.Number(), b: Type.Number() })
     const B = Type.Record(Type.String(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 3', () => {
     type T = { a: number; b: number } extends Record<number, number> ? 1 : 2
     const A = Type.Object({ a: Type.Number(), b: Type.Number() })
     const B = Type.Record(Type.Number(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 4', () => {
     type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Object({ a: Type.Number(), b: Type.Number() })
     const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 5', () => {
     type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Object({ a: Type.Number(), b: Type.Number() })
     const B = Type.Record(Type.String(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 6', () => {
     type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Object({ a: Type.Number(), b: Type.Number() })
     const B = Type.Record(Type.Number(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   // ----------------------------------------------------------
   // Standard
@@ -92,86 +92,86 @@ describe('type/extends/Object', () => {
   it('Should extend Any', () => {
     type T = { a: number } extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = { a: number } extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = { a: number } extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = { a: number } extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = { a: number } extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = { a: number } extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = { a: number } extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = { a: number } extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Object({}, { additionalProperties: false }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = { a: number } extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Object({ a: Type.Literal(10) }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = { a: number } extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 1', () => {
     type T = { a: number } extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Union([Type.Null(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = { a: number } extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = { a: number } extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = { a: number } extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = { a: number } extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = { a: number } extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = { a: number } extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/promise.ts b/test/runtime/type/extends/promise.ts
index 7ebd71de5..843786a64 100644
--- a/test/runtime/type/extends/promise.ts
+++ b/test/runtime/type/extends/promise.ts
@@ -9,22 +9,22 @@ describe('type/extends/Promise', () => {
   it('Should extend Promise Varying 1', () => {
     type T = Promise<any> extends Promise<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Promise(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Promise Varying 2', () => {
     type T = Promise<string> extends Promise<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.String()), Type.Promise(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Promise Varying 3', () => {
     type T = Promise<any> extends Promise<string> ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Promise(Type.String()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Promise Varying 4', () => {
     type T = Promise<number> extends Promise<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Promise(Type.String()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   // ----------------------------------------------
   // Any
@@ -32,87 +32,87 @@ describe('type/extends/Promise', () => {
   it('Should extend Any', () => {
     type T = Promise<any> extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = Promise<any> extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = Promise<any> extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = Promise<any> extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = Promise<any> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = Promise<any> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = Promise<any> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = Promise<any> extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = Promise<any> extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Record(Type.Number(), Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = Promise<any> extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Object({}, { additionalProperties: false }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = Promise<any> extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = Promise<any> extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 1', () => {
     type T = Promise<any> extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = Promise<any> extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = Promise<any> extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = Promise<any> extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = Promise<any> extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   // ----------------------------------------------
   // Constrained
@@ -120,91 +120,91 @@ describe('type/extends/Promise', () => {
   it('Should extend constrained Any', () => {
     type T = Promise<number> extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Unknown', () => {
     type T = Promise<number> extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained String', () => {
     type T = Promise<number> extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Boolean', () => {
     type T = Promise<number> extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Number', () => {
     type T = Promise<number> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Integer', () => {
     type T = Promise<number> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Array', () => {
     type T = Promise<number> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Tuple', () => {
     type T = Promise<number> extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Object 1', () => {
     type T = Promise<number> extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Object({}, { additionalProperties: false }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Object 2', () => {
     type T = Promise<number> extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Object 3', () => {
     type T = Promise<number> extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Union 1', () => {
     type T = Promise<number> extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Union 2', () => {
     type T = Promise<number> extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend constrained Union 2', () => {
     type T = Promise<number> extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Null', () => {
     type T = Promise<number> extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend constrained Undefined', () => {
     type T = Promise<number> extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = Promise<number> extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = Promise<number> extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/record.ts b/test/runtime/type/extends/record.ts
index 369e6050a..7ac3301c2 100644
--- a/test/runtime/type/extends/record.ts
+++ b/test/runtime/type/extends/record.ts
@@ -8,77 +8,77 @@ describe('type/extends/Record', () => {
     const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 2', () => {
     type T = Record<string, number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record 3', () => {
     type T = Record<number, number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record 4', () => {
     type T = Record<'a' | 'b', number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 5', () => {
     type T = Record<'a' | 'b', number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 6', () => {
     type T = Record<string, number> extends Record<'a' | 'b', number> ? true : false
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 7', () => {
     type T = Record<string, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Record(Type.String(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 8', () => {
     type T = Record<string, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Record(Type.Number(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 9', () => {
     type T = Record<number, number> extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
     const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record 10', () => {
     type T = Record<number, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
     const B = Type.Record(Type.String(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 11', () => {
     type T = Record<number, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
     const B = Type.Record(Type.Number(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   // -----
   it('Should extend Record 12', () => {
@@ -86,28 +86,28 @@ describe('type/extends/Record', () => {
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Record(Type.Integer(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 13', () => {
     type T = Record<number, number> extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
     const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record 14', () => {
     type T = Record<number, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
     const B = Type.Record(Type.String(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 15', () => {
     type T = Record<number, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
     const B = Type.Record(Type.Integer(), Type.Number())
     const R = TypeExtends.Extends(A, B)
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   // -------------------------------------------------------------------
   // Standard
@@ -115,86 +115,86 @@ describe('type/extends/Record', () => {
   it('Should extend Any', () => {
     type T = Record<number, number> extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = Record<number, number> extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = Record<number, number> extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = Record<number, number> extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = Record<number, number> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = Record<number, number> extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = Record<number, number> extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = Record<number, number> extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.String()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = Record<number, number> extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = Record<number, number> extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 3', () => {
     type T = Record<number, number> extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Object({ a: Type.Number() }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = Record<number, number> extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = Record<number, number> extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Any(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = Record<number, number> extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = Record<number, number> extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = Record<number, number> extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = Record<number, number> extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/string.ts b/test/runtime/type/extends/string.ts
index dc8954666..0dd95ecbe 100644
--- a/test/runtime/type/extends/string.ts
+++ b/test/runtime/type/extends/string.ts
@@ -6,106 +6,106 @@ describe('type/extends/String', () => {
   it('Should extend Any', () => {
     type T = string extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = string extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = string extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Boolean', () => {
     type T = string extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = string extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = string extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = string extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = string extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record 1', () => {
     type T = string extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 2', () => {
     type T = string extends Record<number, unknown> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Unknown()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 3', () => {
     type T = string extends Record<number, string> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.String()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 4', () => {
     type T = string extends Record<number, number> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Number()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = string extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Object({}, { additionalProperties: false }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = string extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = number extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = number extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = number extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = number extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = number extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = number extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Number(), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/symbol.ts b/test/runtime/type/extends/symbol.ts
index e80838409..03dc7aaf0 100644
--- a/test/runtime/type/extends/symbol.ts
+++ b/test/runtime/type/extends/symbol.ts
@@ -6,101 +6,101 @@ describe('type/extends/Symbol', () => {
   it('Should extend Any', () => {
     type T = symbol extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = symbol extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = symbol extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = symbol extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = symbol extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = symbol extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = symbol extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = symbol extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = symbol extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Record(Type.Number(), Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = symbol extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = symbol extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Object({ a: Type.Literal(10) }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = symbol extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = symbol extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = symbol extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 4', () => {
     type T = symbol extends boolean | symbol ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Union([Type.Boolean(), Type.Symbol()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = symbol extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = symbol extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = symbol extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = symbol extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Symbol', () => {
     type T = symbol extends symbol ? 1 : 2
     const R = TypeExtends.Extends(Type.Symbol(), Type.Symbol())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
 })
diff --git a/test/runtime/type/extends/template-literal.ts b/test/runtime/type/extends/template-literal.ts
index c8a98aa19..3dd6ff3d2 100644
--- a/test/runtime/type/extends/template-literal.ts
+++ b/test/runtime/type/extends/template-literal.ts
@@ -9,77 +9,77 @@ describe('type/extends/TemplateLiteral', () => {
   it('Should extend Any (hello)', () => {
     type T = 'hello' extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown (hello)', () => {
     type T = 'hello' extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String (hello)', () => {
     type T = 'hello' extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Boolean (hello)', () => {
     type T = 'hello' extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number (hello)', () => {
     type T = 'hello' extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer (hello)', () => {
     type T = 'hello' extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array (hello)', () => {
     type T = 'hello' extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple (hello)', () => {
     type T = 'hello' extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1 (hello)', () => {
     type T = 'hello' extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Object({}, { additionalProperties: false }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2 (hello)', () => {
     type T = 'hello' extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1 (hello)', () => {
     type T = 'hello' extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2 (hello)', () => {
     type T = 'hello' extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3 (hello)', () => {
     type T = 'hello' extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null (hello)', () => {
     type T = 'hello' extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined (hello)', () => {
     type T = 'hello' extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   // -------------------------------------------------------------------
   // String Literal 'hello' | 'world'
@@ -87,76 +87,76 @@ describe('type/extends/TemplateLiteral', () => {
   it('Should extend Any (hello | world)', () => {
     type T = 'hello' | 'world' extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown (hello | world)', () => {
     type T = 'hello' | 'world' extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String (hello | world)', () => {
     type T = 'hello' | 'world' extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Boolean (hello | world)', () => {
     type T = 'hello' | 'world' extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number (hello | world)', () => {
     type T = 'hello' | 'world' extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer (hello | world)', () => {
     type T = 'hello' | 'world' extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array (hello | world)', () => {
     type T = 'hello' | 'world' extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple (hello | world)', () => {
     type T = 'hello' | 'world' extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1 (hello | world)', () => {
     type T = 'hello' | 'world' extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Object({}, { additionalProperties: false }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2 (hello | world)', () => {
     type T = 'hello' | 'world' extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1 (hello | world)', () => {
     type T = 'hello' | 'world' extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2 (hello | world)', () => {
     type T = 'hello' | 'world' extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3 (hello | world)', () => {
     type T = 'hello' | 'world' extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null (hello | world)', () => {
     type T = 'hello' | 'world' extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined (hello | world)', () => {
     type T = 'hello' | 'world' extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/tuple.ts b/test/runtime/type/extends/tuple.ts
index f763fb884..b297655ab 100644
--- a/test/runtime/type/extends/tuple.ts
+++ b/test/runtime/type/extends/tuple.ts
@@ -6,156 +6,156 @@ describe('type/extends/Tuple', () => {
   it('Should extend Any', () => {
     type T = [string, number] extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = [string, number] extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = [string, number] extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = [string, number] extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = [string, number] extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = [string, number] extends Array<any> ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array 2', () => {
     type T = [string, number] extends Array<string> ? 1 : 2 // 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.String()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 3', () => {
     type T = [string, number] extends Array<string | number> ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Union([Type.String(), Type.Number()])))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Array 4', () => {
     type T = [string, number] extends Array<string | number | boolean> ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Union([Type.String(), Type.Number(), Type.Boolean()])))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Tuple 1', () => {
     type T = [string, number] extends [string, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Tuple 2', () => {
     type T = [string, number] extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple 3', () => {
     type T = [string, any] extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Any()]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple 4', () => {
     type T = [string, number] extends [string, any] ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Any()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Tuple 5', () => {
     type T = [string, unknown] extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Unknown()]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple 6', () => {
     type T = [string, number] extends [string, unknown] ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Unknown()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Tuple 7', () => {
     type T = [] extends [string, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([]), Type.Tuple([Type.String(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple 8', () => {
     type T = [string, number] extends [] ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record 1', () => {
     type T = [string, number] extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 2', () => {
     type T = [string, number] extends Record<number, unknown> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Unknown()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 3', () => {
     type T = [string, number] extends Record<number, string> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.String()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Record 4', () => {
     type T = [string, number] extends Record<number, number> ? 1 : 2
     const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Number()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = [string, number] extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Object({}, { additionalProperties: false }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = [string, number] extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = [string, number] extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 1', () => {
     type T = [string, number] extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = [string, number] extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = [string, number] extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = [string, number] extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = [string, number] extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = [string, number] extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = [string, number] extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/uint8array.ts b/test/runtime/type/extends/uint8array.ts
index 286e00d9e..828163dd1 100644
--- a/test/runtime/type/extends/uint8array.ts
+++ b/test/runtime/type/extends/uint8array.ts
@@ -6,91 +6,91 @@ describe('type/extends/Uint8Array', () => {
   it('Should extend Any', () => {
     type T = Uint8Array extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = Uint8Array extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = Uint8Array extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = Uint8Array extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = Uint8Array extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = Uint8Array extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = Uint8Array extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = Uint8Array extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = Uint8Array extends Record<number, any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Record(Type.Number(), Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 1', () => {
     type T = Uint8Array extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Object({}, { additionalProperties: false }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = Uint8Array extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = Uint8Array extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = Uint8Array extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = Uint8Array extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = Uint8Array extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = Uint8Array extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = Uint8Array extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = Uint8Array extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Uint8Array(), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/undefined.ts b/test/runtime/type/extends/undefined.ts
index 78b8f4a2b..664126124 100644
--- a/test/runtime/type/extends/undefined.ts
+++ b/test/runtime/type/extends/undefined.ts
@@ -6,86 +6,86 @@ describe('type/extends/Undefined', () => {
   it('Should extend Any', () => {
     type T = undefined extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = undefined extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = undefined extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = undefined extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = undefined extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = undefined extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = undefined extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = undefined extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Object({}, { additionalProperties: false }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = undefined extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = undefined extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = undefined extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = undefined extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = undefined extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = undefined extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = undefined extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Void', () => {
     type T = undefined extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Date', () => {
     type T = undefined extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Undefined(), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/union.ts b/test/runtime/type/extends/union.ts
index 35b00def8..e9eb05cef 100644
--- a/test/runtime/type/extends/union.ts
+++ b/test/runtime/type/extends/union.ts
@@ -6,131 +6,131 @@ describe('type/extends/Union', () => {
   it('Should extend Any', () => {
     type T = number | string extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = number | string extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = number | string extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = number | string extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = number | string extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = number | string extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = number | string extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = number | string extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Object({}, { additionalProperties: false }))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = number | string extends { a: 10 } ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = number | string extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number | string extends any | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Any(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = number | string extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 4', () => {
     type T = any | boolean extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Union 5', () => {
     type T = any | string extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Union 6', () => {
     type T = any | {} extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Union 7', () => {
     type T = any extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.Union)
+    Assert.IsEqual(R, TypeExtendsResult.Union)
   })
   it('Should extend Union 8', () => {
     type T = unknown | string extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Unknown(), Type.String()]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 9', () => {
     type T = unknown extends boolean | number ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = number | string extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = number | string extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = number | string extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void 2', () => {
     type T = number | string | void extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = number | string | void extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date 2', () => {
     type T = Date | number | string | void extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Date(), Type.Number(), Type.String()]), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend BigInt', () => {
     type T = bigint | number | string | void extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.BigInt(), Type.Number(), Type.String()]), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Symbol', () => {
     type T = symbol | number | string | void extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Union([Type.Symbol(), Type.Number(), Type.String()]), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/unknown.ts b/test/runtime/type/extends/unknown.ts
index 4a5adba9d..85dbf8654 100644
--- a/test/runtime/type/extends/unknown.ts
+++ b/test/runtime/type/extends/unknown.ts
@@ -6,96 +6,96 @@ describe('type/extends/Unknown', () => {
   it('Should extend Any', () => {
     type T = unknown extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = unknown extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = unknown extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = unknown extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = unknown extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = unknown extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = unknown extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = unknown extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Array(Type.String()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = unknown extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = unknown extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = unknown extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Object({ a: Type.Number() }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = unknown extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = unknown extends any | number ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Any(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = unknown extends unknown | number ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = unknown extends unknown | any ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = unknown extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = unknown extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = unknown extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = unknown extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Unknown(), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/void.ts b/test/runtime/type/extends/void.ts
index 8cf53aee2..106e1759e 100644
--- a/test/runtime/type/extends/void.ts
+++ b/test/runtime/type/extends/void.ts
@@ -6,101 +6,101 @@ describe('type/extends/Void', () => {
   it('Should extend Any', () => {
     type T = void extends any ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Any())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = void extends unknown ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Unknown())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = void extends string ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.String())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = void extends boolean ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Boolean())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = void extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Number())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = void extends number ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Integer())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = void extends Array<any> ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Array(Type.Any()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = void extends Array<string> ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Array(Type.String()))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = void extends [number, number] ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = void extends object ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = void extends {} ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Object({}))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = void extends { a: number } ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Object({ a: Type.Number() }))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = void extends number | string ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Number(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = void extends any | number ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Any(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = void extends unknown | number ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = void extends unknown | any ? 1 : 2 // 1
     const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = void extends null ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Null())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = void extends undefined ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Undefined())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = void extends void ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Void())
-    Assert.isEqual(R, TypeExtendsResult.True)
+    Assert.IsEqual(R, TypeExtendsResult.True)
   })
   it('Should extend Date', () => {
     type T = void extends Date ? 1 : 2
     const R = TypeExtends.Extends(Type.Void(), Type.Date())
-    Assert.isEqual(R, TypeExtendsResult.False)
+    Assert.IsEqual(R, TypeExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/guard/any.ts b/test/runtime/type/guard/any.ts
index ba3eaed09..bb35ccc03 100644
--- a/test/runtime/type/guard/any.ts
+++ b/test/runtime/type/guard/any.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TAny', () => {
   it('Should guard for TAny', () => {
     const R = TypeGuard.TAny(Type.Any())
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TAny', () => {
     const R = TypeGuard.TAny(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TAny with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TAny(Type.Any({ $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/array.ts b/test/runtime/type/guard/array.ts
index 80a185979..95b0063aa 100644
--- a/test/runtime/type/guard/array.ts
+++ b/test/runtime/type/guard/array.ts
@@ -5,14 +5,12 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TArray', () => {
   it('Should guard for TArray', () => {
     const R = TypeGuard.TArray(Type.Array(Type.Number()))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not guard for TArray', () => {
     const R = TypeGuard.TArray(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should guard for nested object TArray', () => {
     const R = TypeGuard.TArray(
       Type.Array(
@@ -22,9 +20,8 @@ describe('type/guard/TArray', () => {
         }),
       ),
     )
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not guard for nested object TArray', () => {
     const R = TypeGuard.TArray(
       Type.Array(
@@ -34,30 +31,26 @@ describe('type/guard/TArray', () => {
         }),
       ),
     )
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TArray with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TArray(Type.Array(Type.Number(), { $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TArray with invalid minItems', () => {
     // @ts-ignore
     const R = TypeGuard.TArray(Type.Array(Type.String(), { minItems: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TArray with invalid maxItems', () => {
     // @ts-ignore
     const R = TypeGuard.TArray(Type.Array(Type.String(), { maxItems: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TArray with invalid uniqueItems', () => {
     // @ts-ignore
     const R = TypeGuard.TArray(Type.Array(Type.String(), { uniqueItems: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/async-iterator.ts b/test/runtime/type/guard/async-iterator.ts
new file mode 100644
index 000000000..8b3567e5b
--- /dev/null
+++ b/test/runtime/type/guard/async-iterator.ts
@@ -0,0 +1,22 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TAsyncIterator', () => {
+  it('Should guard for TAsyncIterator', () => {
+    const T = Type.AsyncIterator(Type.Any())
+    const R = TypeGuard.TAsyncIterator(T)
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TAsyncIterator', () => {
+    const T = null
+    const R = TypeGuard.TAsyncIterator(T)
+    Assert.IsFalse(R)
+  })
+  it('Should not guard for TAsyncIterator with invalid $id', () => {
+    //@ts-ignore
+    const T = Type.AsyncIterator(Type.Any(), { $id: 1 })
+    const R = TypeGuard.TAsyncIterator(T)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/awaited.ts b/test/runtime/type/guard/awaited.ts
new file mode 100644
index 000000000..ef535a9ef
--- /dev/null
+++ b/test/runtime/type/guard/awaited.ts
@@ -0,0 +1,41 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/Awaited', () => {
+  it('Should guard for Awaited 1', () => {
+    const T = Type.Awaited(Type.String())
+    const R = TypeGuard.TString(T)
+    Assert.IsTrue(R)
+  })
+  it('Should guard for Awaited 2', () => {
+    const T = Type.Awaited(Type.Promise(Type.String()))
+    const R = TypeGuard.TString(T)
+    Assert.IsTrue(R)
+  })
+  it('Should guard for Awaited 3', () => {
+    const T = Type.Awaited(Type.Awaited(Type.Promise(Type.String())))
+    const R = TypeGuard.TString(T)
+    Assert.IsTrue(R)
+  })
+  it('Should guard for Awaited 4', () => {
+    const T = Type.Awaited(Type.Union([Type.Promise(Type.Promise(Type.String()))]))
+    Assert.IsTrue(TypeGuard.TString(T))
+  })
+  it('Should guard for Awaited 5', () => {
+    const T = Type.Awaited(Type.Union([Type.Promise(Type.Promise(Type.String())), Type.Number()]))
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsTrue(TypeGuard.TString(T.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TNumber(T.anyOf[1]))
+  })
+  it('Should guard for Awaited 6', () => {
+    const T = Type.Awaited(Type.Intersect([Type.Promise(Type.Promise(Type.String()))]))
+    Assert.IsTrue(TypeGuard.TString(T))
+  })
+  it('Should guard for Awaited 7', () => {
+    const T = Type.Awaited(Type.Intersect([Type.Promise(Type.Promise(Type.String())), Type.Number()]))
+    Assert.IsTrue(TypeGuard.TIntersect(T))
+    Assert.IsTrue(TypeGuard.TString(T.allOf[0]))
+    Assert.IsTrue(TypeGuard.TNumber(T.allOf[1]))
+  })
+})
diff --git a/test/runtime/type/guard/bigint.ts b/test/runtime/type/guard/bigint.ts
index 200294d8b..bc16722a0 100644
--- a/test/runtime/type/guard/bigint.ts
+++ b/test/runtime/type/guard/bigint.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TBigInt', () => {
   it('Should guard for TBigInt', () => {
     const R = TypeGuard.TBigInt(Type.BigInt())
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TBigInt', () => {
     const R = TypeGuard.TBigInt(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for BigInt with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TBigInt(Type.BigInt({ $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/boolean.ts b/test/runtime/type/guard/boolean.ts
index ec9d8b3cd..ecc50b90d 100644
--- a/test/runtime/type/guard/boolean.ts
+++ b/test/runtime/type/guard/boolean.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TBoolean', () => {
   it('Should guard for TBoolean', () => {
     const R = TypeGuard.TBoolean(Type.Boolean())
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TBoolean', () => {
     const R = TypeGuard.TBoolean(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TBoolean with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TBoolean(Type.Boolean({ $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/capitalize.ts b/test/runtime/type/guard/capitalize.ts
new file mode 100644
index 000000000..9e60fa035
--- /dev/null
+++ b/test/runtime/type/guard/capitalize.ts
@@ -0,0 +1,9 @@
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/Capitalize', () => {
+  it('Should guard for TCapitalize', () => {
+    const T = Type.Capitalize(Type.Literal('hello'))
+    Assert.IsEqual(T.const, 'Hello')
+  })
+})
diff --git a/test/runtime/type/guard/composite.ts b/test/runtime/type/guard/composite.ts
index f473d31fd..7d4fc1f4b 100644
--- a/test/runtime/type/guard/composite.ts
+++ b/test/runtime/type/guard/composite.ts
@@ -5,20 +5,20 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TComposite', () => {
   it('Should guard for distinct properties', () => {
     const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
-    Assert.isEqual(TypeGuard.TNumber(T.properties.x), true)
-    Assert.isEqual(TypeGuard.TNumber(T.properties.y), true)
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.x))
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.y))
   })
   it('Should guard for overlapping properties', () => {
     const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.Number() })])
-    Assert.isEqual(TypeGuard.TIntersect(T.properties.x), true)
+    Assert.IsTrue(TypeGuard.TIntersect(T.properties.x))
     // @ts-ignore
-    Assert.isEqual(TypeGuard.TNumber(T.properties.x.allOf[0]), true)
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.x.allOf[0]))
     // @ts-ignore
-    Assert.isEqual(TypeGuard.TNumber(T.properties.x.allOf[1]), true)
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.x.allOf[1]))
   })
   it('Should not produce optional property if all properties are not optional', () => {
     const T = Type.Composite([Type.Object({ x: Type.Optional(Type.Number()) }), Type.Object({ x: Type.Number() })])
-    Assert.isEqual(TypeGuard.TOptional(T.properties.x), false)
+    Assert.IsFalse(TypeGuard.TOptional(T.properties.x))
   })
   // Note for: https://github.com/sinclairzx81/typebox/issues/419
   // Determining if a composite property is optional requires a deep check for all properties gathered during a indexed access
@@ -33,8 +33,8 @@ describe('type/guard/TComposite', () => {
       Type.Object({ x: Type.Optional(Type.Number()) }), 
       Type.Object({ x: Type.Optional(Type.Number()) })
     ])
-    Assert.isEqual(TypeGuard.TOptional(T.properties.x), true)
-    Assert.isTrue(T.required === undefined)
+    Assert.IsTrue(TypeGuard.TOptional(T.properties.x))
+    Assert.IsEqual(T.required, undefined)
   })
   it('Should produce required property if some composited properties are not optional', () => {
     // prettier-ignore
@@ -42,15 +42,15 @@ describe('type/guard/TComposite', () => {
       Type.Object({ x: Type.Optional(Type.Number()) }), 
       Type.Object({ x: Type.Number() })
     ])
-    Assert.isEqual(TypeGuard.TOptional(T.properties.x), false)
-    Assert.isTrue(T.required!.includes('x'))
+    Assert.IsFalse(TypeGuard.TOptional(T.properties.x))
+    Assert.IsTrue(T.required!.includes('x'))
   })
   it('Should preserve single optional property', () => {
     // prettier-ignore
     const T = Type.Composite([
       Type.Object({ x: Type.Optional(Type.Number()) }), 
     ])
-    Assert.isEqual(TypeGuard.TOptional(T.properties.x), true)
-    Assert.isTrue(T.required === undefined)
+    Assert.IsTrue(TypeGuard.TOptional(T.properties.x))
+    Assert.IsEqual(T.required, undefined)
   })
 })
diff --git a/test/runtime/type/guard/constructor.ts b/test/runtime/type/guard/constructor.ts
index b60155859..967d04c1b 100644
--- a/test/runtime/type/guard/constructor.ts
+++ b/test/runtime/type/guard/constructor.ts
@@ -5,31 +5,31 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TConstructor', () => {
   it('Should guard for TConstructor', () => {
     const R = TypeGuard.TConstructor(Type.Constructor([], Type.Number()))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TConstructor', () => {
     const R = TypeGuard.TConstructor(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TConstructor with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TConstructor(Type.Constructor([], Type.Number(), { $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TConstructor with invalid Params', () => {
     const R = TypeGuard.TConstructor(Type.Constructor([{} as any, {} as any], Type.Number()))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TConstructor with invalid Return', () => {
     const R = TypeGuard.TConstructor(Type.Constructor([], {} as any))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should guard for TConstructor with empty Rest Tuple', () => {
     const R = TypeGuard.TConstructor(Type.Constructor(Type.Rest(Type.Tuple([])), Type.Number()))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should guard for TConstructor with Rest Tuple', () => {
     const R = TypeGuard.TConstructor(Type.Constructor(Type.Rest(Type.Tuple([Type.Number(), Type.String()])), Type.Number()))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/guard/date.ts b/test/runtime/type/guard/date.ts
index 98fb8db2f..2571c324a 100644
--- a/test/runtime/type/guard/date.ts
+++ b/test/runtime/type/guard/date.ts
@@ -5,41 +5,35 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TDate', () => {
   it('Should guard for TDate', () => {
     const R = TypeGuard.TDate(Type.Date())
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not guard for TDate', () => {
     const R = TypeGuard.TDate(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TDate with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TDate(Type.Number({ $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TDate with invalid minimum', () => {
     // @ts-ignore
     const R = TypeGuard.TDate(Type.Number({ minimum: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TDate with invalid maximum', () => {
     // @ts-ignore
     const R = TypeGuard.TDate(Type.Number({ maximum: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TDate with invalid exclusiveMinimum', () => {
     // @ts-ignore
     const R = TypeGuard.TDate(Type.Number({ exclusiveMinimum: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TDate with invalid exclusiveMaximum', () => {
     // @ts-ignore
     const R = TypeGuard.TDate(Type.Number({ exclusiveMaximum: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/exclude.ts b/test/runtime/type/guard/exclude.ts
index 4f6d3a29f..fe4f06ded 100644
--- a/test/runtime/type/guard/exclude.ts
+++ b/test/runtime/type/guard/exclude.ts
@@ -5,21 +5,21 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TExclude', () => {
   it('Should extract string from number', () => {
     const T = Type.Exclude(Type.String(), Type.Number())
-    Assert.isEqual(TypeGuard.TString(T), true)
+    Assert.IsTrue(TypeGuard.TString(T))
   })
   it('Should extract string from string', () => {
     const T = Type.Exclude(Type.String(), Type.String())
-    Assert.isEqual(TypeGuard.TNever(T), true)
+    Assert.IsTrue(TypeGuard.TNever(T))
   })
   it('Should extract string | number | boolean from string', () => {
     const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
-    Assert.isEqual(TypeGuard.TUnion(T), true)
-    Assert.isEqual(TypeGuard.TNumber(T.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TBoolean(T.anyOf[1]), true)
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsTrue(TypeGuard.TNumber(T.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TBoolean(T.anyOf[1]))
   })
   it('Should extract string | number | boolean from string | boolean', () => {
     const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Boolean()]))
-    Assert.isEqual(TypeGuard.TNumber(T), true)
+    Assert.IsTrue(TypeGuard.TNumber(T))
   })
   // ------------------------------------------------------------------------
   // TemplateLiteral | TemplateLiteral
@@ -28,20 +28,20 @@ describe('type/guard/TExclude', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const T = Type.Exclude(A, B)
-    Assert.isEqual(TypeGuard.TNever(T), true)
+    Assert.IsTrue(TypeGuard.TNever(T))
   })
   it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
     const T = Type.Exclude(A, B)
-    Assert.isEqual(['C'].includes(T.const), true)
+    Assert.IsTrue(['C'].includes(T.const))
   })
   it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
     const T = Type.Exclude(A, B)
-    Assert.isEqual(['C', 'B'].includes(T.anyOf[0].const), true)
-    Assert.isEqual(['C', 'B'].includes(T.anyOf[1].const), true)
+    Assert.IsTrue(['C', 'B'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['C', 'B'].includes(T.anyOf[1].const))
   })
   // ------------------------------------------------------------------------
   // TemplateLiteral | Union 1
@@ -50,20 +50,20 @@ describe('type/guard/TExclude', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const T = Type.Exclude(A, B)
-    Assert.isEqual(TypeGuard.TNever(T), true)
+    Assert.IsTrue(TypeGuard.TNever(T))
   })
   it('Should extract TemplateLiteral | Union 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.Union([Type.Literal('A'), Type.Literal('B')])
     const T = Type.Exclude(A, B)
-    Assert.isEqual(['C'].includes(T.const), true)
+    Assert.IsTrue(['C'].includes(T.const))
   })
   it('Should extract TemplateLiteral | Union 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.Union([Type.Literal('A')])
     const T = Type.Exclude(A, B)
-    Assert.isEqual(['C', 'B'].includes(T.anyOf[0].const), true)
-    Assert.isEqual(['C', 'B'].includes(T.anyOf[1].const), true)
+    Assert.IsTrue(['C', 'B'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['C', 'B'].includes(T.anyOf[1].const))
   })
   // ------------------------------------------------------------------------
   // Union | TemplateLiteral 1
@@ -72,19 +72,19 @@ describe('type/guard/TExclude', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const T = Type.Exclude(A, B)
-    Assert.isEqual(TypeGuard.TNever(T), true)
+    Assert.IsTrue(TypeGuard.TNever(T))
   })
   it('Should extract Union | TemplateLiteral 1', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
     const T = Type.Exclude(A, B)
-    Assert.isEqual(['C'].includes(T.const), true)
+    Assert.IsTrue(['C'].includes(T.const))
   })
   it('Should extract Union | TemplateLiteral 1', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
     const T = Type.Exclude(A, B)
-    Assert.isEqual(['C', 'B'].includes(T.anyOf[0].const), true)
-    Assert.isEqual(['C', 'B'].includes(T.anyOf[1].const), true)
+    Assert.IsTrue(['C', 'B'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['C', 'B'].includes(T.anyOf[1].const))
   })
 })
diff --git a/test/runtime/type/guard/extract.ts b/test/runtime/type/guard/extract.ts
index 13d59bd0c..9fe5f35ea 100644
--- a/test/runtime/type/guard/extract.ts
+++ b/test/runtime/type/guard/extract.ts
@@ -5,21 +5,21 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TExtract', () => {
   it('Should extract string from number', () => {
     const T = Type.Extract(Type.String(), Type.Number())
-    Assert.isEqual(TypeGuard.TNever(T), true)
+    Assert.IsTrue(TypeGuard.TNever(T))
   })
   it('Should extract string from string', () => {
     const T = Type.Extract(Type.String(), Type.String())
-    Assert.isEqual(TypeGuard.TString(T), true)
+    Assert.IsTrue(TypeGuard.TString(T))
   })
   it('Should extract string | number | boolean from string', () => {
     const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
-    Assert.isEqual(TypeGuard.TString(T), true)
+    Assert.IsTrue(TypeGuard.TString(T))
   })
   it('Should extract string | number | boolean from string | boolean', () => {
     const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Boolean()]))
-    Assert.isEqual(TypeGuard.TUnion(T), true)
-    Assert.isEqual(TypeGuard.TString(T.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TBoolean(T.anyOf[1]), true)
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsTrue(TypeGuard.TString(T.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TBoolean(T.anyOf[1]))
   })
   // ------------------------------------------------------------------------
   // TemplateLiteral | TemplateLiteral
@@ -28,22 +28,22 @@ describe('type/guard/TExtract', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const T = Type.Extract(A, B)
-    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[0].const), true)
-    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[1].const), true)
-    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[2].const), true)
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[1].const))
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[2].const))
   })
   it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
     const T = Type.Extract(A, B)
-    Assert.isEqual(['A', 'B'].includes(T.anyOf[0].const), true)
-    Assert.isEqual(['A', 'B'].includes(T.anyOf[1].const), true)
+    Assert.IsTrue(['A', 'B'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['A', 'B'].includes(T.anyOf[1].const))
   })
   it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
     const T = Type.Extract(A, B)
-    Assert.isEqual(['A'].includes(T.const), true)
+    Assert.IsTrue(['A'].includes(T.const))
   })
   // ------------------------------------------------------------------------
   // TemplateLiteral | Union 1
@@ -52,22 +52,22 @@ describe('type/guard/TExtract', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const T = Type.Extract(A, B)
-    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[0].const), true)
-    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[1].const), true)
-    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[2].const), true)
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[1].const))
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[2].const))
   })
   it('Should extract TemplateLiteral | Union 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.Union([Type.Literal('A'), Type.Literal('B')])
     const T = Type.Extract(A, B)
-    Assert.isEqual(['A', 'B'].includes(T.anyOf[0].const), true)
-    Assert.isEqual(['A', 'B'].includes(T.anyOf[1].const), true)
+    Assert.IsTrue(['A', 'B'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['A', 'B'].includes(T.anyOf[1].const))
   })
   it('Should extract TemplateLiteral | Union 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.Union([Type.Literal('A')])
     const T = Type.Extract(A, B)
-    Assert.isEqual(['A'].includes(T.const), true)
+    Assert.IsTrue(['A'].includes(T.const))
   })
   // ------------------------------------------------------------------------
   // Union | TemplateLiteral 1
@@ -76,21 +76,21 @@ describe('type/guard/TExtract', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const T = Type.Extract(A, B)
-    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[0].const), true)
-    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[1].const), true)
-    Assert.isEqual(['A', 'B', 'C'].includes(T.anyOf[2].const), true)
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[1].const))
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[2].const))
   })
   it('Should extract Union | TemplateLiteral 1', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
     const T = Type.Extract(A, B)
-    Assert.isEqual(['A', 'B'].includes(T.anyOf[0].const), true)
-    Assert.isEqual(['A', 'B'].includes(T.anyOf[1].const), true)
+    Assert.IsTrue(['A', 'B'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['A', 'B'].includes(T.anyOf[1].const))
   })
   it('Should extract Union | TemplateLiteral 1', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
     const T = Type.Extract(A, B)
-    Assert.isEqual(['A'].includes(T.const), true)
+    Assert.IsTrue(['A'].includes(T.const))
   })
 })
diff --git a/test/runtime/type/guard/function.ts b/test/runtime/type/guard/function.ts
index 2608266fd..79e66ba6f 100644
--- a/test/runtime/type/guard/function.ts
+++ b/test/runtime/type/guard/function.ts
@@ -5,31 +5,31 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TFunction', () => {
   it('Should guard for TFunction', () => {
     const R = TypeGuard.TFunction(Type.Function([], Type.Number()))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TFunction', () => {
     const R = TypeGuard.TFunction(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TFunction with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TFunction(Type.Function([], Type.Number(), { $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TFunction with invalid Params', () => {
     const R = TypeGuard.TFunction(Type.Function([{} as any, {} as any], Type.Number()))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TFunction with invalid Return', () => {
     const R = TypeGuard.TFunction(Type.Function([], {} as any))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should guard for TFunction with empty Rest Tuple', () => {
     const R = TypeGuard.TFunction(Type.Function(Type.Rest(Type.Tuple([])), Type.Number()))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should guard for TFunction with Rest Tuple', () => {
     const R = TypeGuard.TFunction(Type.Function(Type.Rest(Type.Tuple([Type.Number(), Type.String()])), Type.Number()))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/guard/index.ts b/test/runtime/type/guard/index.ts
index 969112f91..33ee2fb61 100644
--- a/test/runtime/type/guard/index.ts
+++ b/test/runtime/type/guard/index.ts
@@ -1,7 +1,10 @@
 import './any'
 import './array'
+import './async-iterator'
+import './awaited'
 import './bigint'
 import './boolean'
+import './capitalize'
 import './composite'
 import './constructor'
 import './date'
@@ -10,9 +13,11 @@ import './extract'
 import './function'
 import './indexed'
 import './integer'
-import './literal'
 import './intersect'
+import './iterator'
 import './keyof'
+import './literal'
+import './lowercase'
 import './not'
 import './null'
 import './number'
@@ -23,6 +28,7 @@ import './pick'
 import './promise'
 import './record'
 import './ref'
+import './required'
 import './rest'
 import './string'
 import './symbol'
@@ -30,8 +36,10 @@ import './template-literal'
 import './this'
 import './tuple'
 import './uint8array'
+import './uncapitalize'
 import './undefined'
 import './union'
 import './unknown'
 import './unsafe'
+import './uppercase'
 import './void'
diff --git a/test/runtime/type/guard/indexed.ts b/test/runtime/type/guard/indexed.ts
index 4003880c3..2a680f843 100644
--- a/test/runtime/type/guard/indexed.ts
+++ b/test/runtime/type/guard/indexed.ts
@@ -9,7 +9,7 @@ describe('type/guard/TIndex', () => {
       y: Type.String(),
     })
     const I = Type.Index(T, ['x'])
-    Assert.isTrue(TypeGuard.TNumber(I))
+    Assert.IsTrue(TypeGuard.TNumber(I))
   })
   it('Should Index 2', () => {
     const T = Type.Object({
@@ -17,9 +17,9 @@ describe('type/guard/TIndex', () => {
       y: Type.String(),
     })
     const I = Type.Index(T, ['x', 'y'])
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isTrue(TypeGuard.TNumber(I.anyOf[0]))
-    Assert.isTrue(TypeGuard.TString(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
   })
   it('Should Index 3', () => {
     const T = Type.Object({
@@ -27,9 +27,9 @@ describe('type/guard/TIndex', () => {
       y: Type.String(),
     })
     const I = Type.Index(T, Type.KeyOf(T))
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isTrue(TypeGuard.TNumber(I.anyOf[0]))
-    Assert.isTrue(TypeGuard.TString(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
   })
   it('Should Index 4', () => {
     const T = Type.Object({
@@ -37,108 +37,108 @@ describe('type/guard/TIndex', () => {
       ac: Type.String(),
     })
     const I = Type.Index(T, Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])]))
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isTrue(TypeGuard.TNumber(I.anyOf[0]))
-    Assert.isTrue(TypeGuard.TString(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
   })
   it('Should Index 5', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.String() })])
     const I = Type.Index(T, ['x', 'y'])
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isTrue(TypeGuard.TNumber(I.anyOf[0]))
-    Assert.isTrue(TypeGuard.TString(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
   })
   it('Should Index 6', () => {
     const T = Type.Union([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.String() })])
     const I = Type.Index(T, ['x'])
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isTrue(TypeGuard.TNumber(I.anyOf[0]))
-    Assert.isTrue(TypeGuard.TString(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
   })
   it('Should Index 7', () => {
     const T = Type.Array(Type.Null())
     const I = Type.Index(T, Type.Number())
-    Assert.isTrue(TypeGuard.TNull(I))
+    Assert.IsTrue(TypeGuard.TNull(I))
   })
   it('Should Index 6', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [0])
-    Assert.isTrue(TypeGuard.TLiteralString(I))
-    Assert.isEqual(I.const, 'hello')
+    Assert.IsTrue(TypeGuard.TLiteralString(I))
+    Assert.IsEqual(I.const, 'hello')
   })
   it('Should Index 8', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [1])
-    Assert.isTrue(TypeGuard.TLiteralString(I))
-    Assert.isEqual(I.const, 'world')
+    Assert.IsTrue(TypeGuard.TLiteralString(I))
+    Assert.IsEqual(I.const, 'world')
   })
   it('Should Index 9', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [0, 1])
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isEqual(I.anyOf[0].const, 'hello')
-    Assert.isEqual(I.anyOf[1].const, 'world')
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsEqual(I.anyOf[0].const, 'hello')
+    Assert.IsEqual(I.anyOf[1].const, 'world')
   })
   it('Should Index 10', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [1, 0])
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isEqual(I.anyOf[0].const, 'world')
-    Assert.isEqual(I.anyOf[1].const, 'hello')
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsEqual(I.anyOf[0].const, 'world')
+    Assert.IsEqual(I.anyOf[1].const, 'hello')
   })
   it('Should Index 11', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [0, 0, 0, 1])
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isEqual(I.anyOf[0].const, 'hello')
-    Assert.isEqual(I.anyOf[1].const, 'hello')
-    Assert.isEqual(I.anyOf[2].const, 'hello')
-    Assert.isEqual(I.anyOf[3].const, 'world')
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsEqual(I.anyOf[0].const, 'hello')
+    Assert.IsEqual(I.anyOf[1].const, 'hello')
+    Assert.IsEqual(I.anyOf[2].const, 'hello')
+    Assert.IsEqual(I.anyOf[3].const, 'world')
   })
   it('Should Index 12', () => {
     const T = Type.Tuple([Type.String(), Type.Boolean()])
     const I = Type.Index(T, Type.Number())
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.isTrue(TypeGuard.TBoolean(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TBoolean(I.anyOf[1]))
   })
   it('Should Index 13', () => {
     const T = Type.Tuple([Type.String()])
     const I = Type.Index(T, Type.Number())
-    Assert.isTrue(TypeGuard.TString(I))
+    Assert.IsTrue(TypeGuard.TString(I))
   })
   it('Should Index 14', () => {
     const T = Type.Tuple([])
     const I = Type.Index(T, Type.Number())
-    Assert.isTrue(TypeGuard.TNever(I))
+    Assert.IsTrue(TypeGuard.TNever(I))
   })
   it('Should Index 15', () => {
     const T = Type.Object({
       0: Type.Number(),
     })
     const I = Type.Index(T, Type.Literal(0))
-    Assert.isTrue(TypeGuard.TNumber(I))
+    Assert.IsTrue(TypeGuard.TNumber(I))
   })
   it('Should Index 16', () => {
     const T = Type.Object({
       0: Type.Number(),
     })
     const I = Type.Index(T, Type.Literal('0'))
-    Assert.isTrue(TypeGuard.TNumber(I))
+    Assert.IsTrue(TypeGuard.TNumber(I))
   })
   it('Should Index 17', () => {
     const T = Type.Object({
       '0': Type.Number(),
     })
     const I = Type.Index(T, Type.Literal(0))
-    Assert.isTrue(TypeGuard.TNumber(I))
+    Assert.IsTrue(TypeGuard.TNumber(I))
   })
   it('Should Index 18', () => {
     const T = Type.Object({
       '0': Type.Number(),
     })
     const I = Type.Index(T, Type.Literal('0'))
-    Assert.isTrue(TypeGuard.TNumber(I))
+    Assert.IsTrue(TypeGuard.TNumber(I))
   })
   it('Should Index 19', () => {
     const T = Type.Object({
@@ -147,9 +147,9 @@ describe('type/guard/TIndex', () => {
       2: Type.Boolean(),
     })
     const I = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal(2)]))
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isTrue(TypeGuard.TNumber(I.anyOf[0]))
-    Assert.isTrue(TypeGuard.TBoolean(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TBoolean(I.anyOf[1]))
   })
   it('Should Index 20', () => {
     const T = Type.Object({
@@ -158,7 +158,7 @@ describe('type/guard/TIndex', () => {
       2: Type.Boolean(),
     })
     const I = Type.Index(T, Type.BigInt())
-    Assert.isTrue(TypeGuard.TNever(I))
+    Assert.IsTrue(TypeGuard.TNever(I))
   })
   it('Should Index 21', () => {
     const T = Type.Object({
@@ -167,7 +167,7 @@ describe('type/guard/TIndex', () => {
       2: Type.Boolean(),
     })
     const I = Type.Index(T, Type.Object({}))
-    Assert.isTrue(TypeGuard.TNever(I))
+    Assert.IsTrue(TypeGuard.TNever(I))
   })
   it('Should Index 22', () => {
     const A = Type.Object({ x: Type.Literal('A') })
@@ -176,11 +176,11 @@ describe('type/guard/TIndex', () => {
     const D = Type.Object({ x: Type.Literal('D') })
     const T = Type.Intersect([A, B, C, D])
     const I = Type.Index(T, ['x'])
-    Assert.isTrue(TypeGuard.TIntersect(I))
-    Assert.isTrue(TypeGuard.TLiteral(I.allOf[0]))
-    Assert.isTrue(TypeGuard.TLiteral(I.allOf[1]))
-    Assert.isTrue(TypeGuard.TLiteral(I.allOf[2]))
-    Assert.isTrue(TypeGuard.TLiteral(I.allOf[3]))
+    Assert.IsTrue(TypeGuard.TIntersect(I))
+    Assert.IsTrue(TypeGuard.TLiteral(I.allOf[0]))
+    Assert.IsTrue(TypeGuard.TLiteral(I.allOf[1]))
+    Assert.IsTrue(TypeGuard.TLiteral(I.allOf[2]))
+    Assert.IsTrue(TypeGuard.TLiteral(I.allOf[3]))
   })
   it('Should Index 23', () => {
     const A = Type.Object({ x: Type.Literal('A') })
@@ -189,11 +189,11 @@ describe('type/guard/TIndex', () => {
     const D = Type.Object({ x: Type.Literal('D') })
     const T = Type.Union([A, B, C, D])
     const I = Type.Index(T, ['x'])
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isTrue(TypeGuard.TLiteral(I.anyOf[0]))
-    Assert.isTrue(TypeGuard.TLiteral(I.anyOf[1]))
-    Assert.isTrue(TypeGuard.TLiteral(I.anyOf[2]))
-    Assert.isTrue(TypeGuard.TLiteral(I.anyOf[3]))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TLiteral(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TLiteral(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.TLiteral(I.anyOf[2]))
+    Assert.IsTrue(TypeGuard.TLiteral(I.anyOf[3]))
   })
   it('Should Index 24', () => {
     const A = Type.Object({ x: Type.Literal('A'), y: Type.Number() })
@@ -202,9 +202,9 @@ describe('type/guard/TIndex', () => {
     const D = Type.Object({ x: Type.Literal('D') })
     const T = Type.Intersect([A, B, C, D])
     const I = Type.Index(T, ['x', 'y'])
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isTrue(TypeGuard.TIntersect(I.anyOf[0]))
-    Assert.isTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TIntersect(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
   })
   it('Should Index 25', () => {
     const A = Type.Object({ x: Type.Literal('A'), y: Type.Number() })
@@ -213,11 +213,11 @@ describe('type/guard/TIndex', () => {
     const D = Type.Object({ x: Type.Literal('D') })
     const T = Type.Intersect([A, B, C, D])
     const I = Type.Index(T, ['x', 'y'])
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isTrue(TypeGuard.TIntersect(I.anyOf[0]))
-    Assert.isTrue(TypeGuard.TIntersect(I.anyOf[1]))
-    Assert.isTrue(TypeGuard.TNumber(I.anyOf[1].allOf[0]))
-    Assert.isTrue(TypeGuard.TString(I.anyOf[1].allOf[1]))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TIntersect(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TIntersect(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1].allOf[0]))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[1].allOf[1]))
   })
   it('Should Index 26', () => {
     const T = Type.Recursive((This) =>
@@ -228,10 +228,10 @@ describe('type/guard/TIndex', () => {
       }),
     )
     const I = Type.Index(T, ['x', 'y', 'z'])
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.isTrue(TypeGuard.TNumber(I.anyOf[1]))
-    Assert.isTrue(TypeGuard.TThis(I.anyOf[2]))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.TThis(I.anyOf[2]))
   })
   it('Should Index 27', () => {
     const T = Type.Object({
@@ -239,9 +239,9 @@ describe('type/guard/TIndex', () => {
       1: Type.Number(),
     })
     const I = Type.Index(T, [0, 1])
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.isTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
   })
   it('Should Index 28', () => {
     const T = Type.Object({
@@ -249,9 +249,9 @@ describe('type/guard/TIndex', () => {
       '1': Type.Number(),
     })
     const I = Type.Index(T, [0, '1'])
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.isTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
   })
   it('Should Index 29', () => {
     const T = Type.Object({
@@ -259,9 +259,9 @@ describe('type/guard/TIndex', () => {
       '1': Type.Number(),
     })
     const I = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal('1')]))
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.isTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
   })
   it('Should Index 30', () => {
     const T = Type.Object({
@@ -269,9 +269,9 @@ describe('type/guard/TIndex', () => {
       '1': Type.Number(),
     })
     const I = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal(1)]))
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.isTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
     // Note: Expect TNever for anyOf[1] but permit for TNumber due to IndexedAccess
     // Resolve() which currently cannot differentiate between string and numeric keys
     // on the object. This may be resolvable in later revisions, but test for this
@@ -286,8 +286,8 @@ describe('type/guard/TIndex', () => {
       y: Type.Number(),
     })
     const I = Type.Index(T, ['x'])
-    Assert.isTrue(TypeGuard.TOptional(I))
-    Assert.isTrue(TypeGuard.TString(I))
+    Assert.IsTrue(TypeGuard.TOptional(I))
+    Assert.IsTrue(TypeGuard.TString(I))
   })
   it('Should Index 32', () => {
     const T = Type.Object({
@@ -295,8 +295,8 @@ describe('type/guard/TIndex', () => {
       y: Type.Number(),
     })
     const I = Type.Index(T, ['y'])
-    Assert.isFalse(TypeGuard.TOptional(I))
-    Assert.isTrue(TypeGuard.TNumber(I))
+    Assert.IsFalse(TypeGuard.TOptional(I))
+    Assert.IsTrue(TypeGuard.TNumber(I))
   })
   it('Should Index 33', () => {
     const T = Type.Object({
@@ -304,15 +304,15 @@ describe('type/guard/TIndex', () => {
       y: Type.Number(),
     })
     const I = Type.Index(T, ['x', 'y'])
-    Assert.isTrue(TypeGuard.TOptional(I))
-    Assert.isTrue(TypeGuard.TUnion(I))
-    Assert.isTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.isTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.TOptional(I))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
   })
   it('Should Index 34', () => {
     const T = Type.String()
     // @ts-ignore
     const I = Type.Index(T, ['x'])
-    Assert.isTrue(TypeGuard.TNever(I))
+    Assert.IsTrue(TypeGuard.TNever(I))
   })
 })
diff --git a/test/runtime/type/guard/integer.ts b/test/runtime/type/guard/integer.ts
index 1938d4d23..849aabdca 100644
--- a/test/runtime/type/guard/integer.ts
+++ b/test/runtime/type/guard/integer.ts
@@ -5,40 +5,40 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TInteger', () => {
   it('Should guard for TInteger', () => {
     const R = TypeGuard.TInteger(Type.Integer())
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TInteger', () => {
     const R = TypeGuard.TInteger(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TInteger with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TInteger with invalid multipleOf', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ multipleOf: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TInteger with invalid minimum', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ minimum: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TInteger with invalid maximum', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ maximum: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TInteger with invalid exclusiveMinimum', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ exclusiveMinimum: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TInteger with invalid exclusiveMaximum', () => {
     // @ts-ignore
     const R = TypeGuard.TInteger(Type.Integer({ exclusiveMaximum: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/intersect.ts b/test/runtime/type/guard/intersect.ts
index 9ed33e6b2..5cf94db7a 100644
--- a/test/runtime/type/guard/intersect.ts
+++ b/test/runtime/type/guard/intersect.ts
@@ -14,7 +14,7 @@ describe('type/guard/TUnion', () => {
         }),
       ]),
     )
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TIntersect', () => {
     const R = TypeGuard.TIntersect(
@@ -27,6 +27,6 @@ describe('type/guard/TUnion', () => {
         }),
       ]),
     )
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/iterator.ts b/test/runtime/type/guard/iterator.ts
new file mode 100644
index 000000000..b0dd08c4a
--- /dev/null
+++ b/test/runtime/type/guard/iterator.ts
@@ -0,0 +1,22 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TIterator', () => {
+  it('Should guard for TIterator', () => {
+    const T = Type.Iterator(Type.Any())
+    const R = TypeGuard.TIterator(T)
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TIterator', () => {
+    const T = null
+    const R = TypeGuard.TIterator(T)
+    Assert.IsFalse(R)
+  })
+  it('Should not guard for TIterator with invalid $id', () => {
+    //@ts-ignore
+    const T = Type.Iterator(Type.Any(), { $id: 1 })
+    const R = TypeGuard.TIterator(T)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/keyof.ts b/test/runtime/type/guard/keyof.ts
index cca0b0dae..d8b24ad74 100644
--- a/test/runtime/type/guard/keyof.ts
+++ b/test/runtime/type/guard/keyof.ts
@@ -9,9 +9,9 @@ describe('type/guard/TKeyOf', () => {
       y: Type.Number(),
     })
     const K = Type.KeyOf(T)
-    Assert.isEqual(TypeGuard.TUnion(K), true)
-    Assert.isEqual(TypeGuard.TLiteral(K.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TLiteral(K.anyOf[1]), true)
+    Assert.IsTrue(TypeGuard.TUnion(K))
+    Assert.IsTrue(TypeGuard.TLiteral(K.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TLiteral(K.anyOf[1]))
   })
   it('Should KeyOf 2', () => {
     const T = Type.Recursive((Self) =>
@@ -21,9 +21,9 @@ describe('type/guard/TKeyOf', () => {
       }),
     )
     const K = Type.KeyOf(T)
-    Assert.isEqual(TypeGuard.TUnion(K), true)
-    Assert.isEqual(TypeGuard.TLiteral(K.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TLiteral(K.anyOf[1]), true)
+    Assert.IsTrue(TypeGuard.TUnion(K))
+    Assert.IsTrue(TypeGuard.TLiteral(K.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TLiteral(K.anyOf[1]))
   })
   it('Should KeyOf 3', () => {
     const T = Type.Intersect([
@@ -35,9 +35,9 @@ describe('type/guard/TKeyOf', () => {
       }),
     ])
     const K = Type.KeyOf(T)
-    Assert.isEqual(TypeGuard.TUnion(K), true)
-    Assert.isEqual(TypeGuard.TLiteral(K.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TLiteral(K.anyOf[1]), true)
+    Assert.IsTrue(TypeGuard.TUnion(K))
+    Assert.IsTrue(TypeGuard.TLiteral(K.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TLiteral(K.anyOf[1]))
   })
   it('Should KeyOf 4', () => {
     const T = Type.Union([
@@ -49,28 +49,28 @@ describe('type/guard/TKeyOf', () => {
       }),
     ])
     const K = Type.KeyOf(T)
-    Assert.isEqual(TypeGuard.TNever(K), true)
+    Assert.IsTrue(TypeGuard.TNever(K))
   })
   it('Should KeyOf 5', () => {
     const T = Type.Null()
     const K = Type.KeyOf(T)
-    Assert.isEqual(TypeGuard.TNever(K), true)
+    Assert.IsTrue(TypeGuard.TNever(K))
   })
   it('Should KeyOf 6', () => {
     const T = Type.Array(Type.Number())
     const K = Type.KeyOf(T)
-    Assert.isEqual(TypeGuard.TNumber(K), true)
+    Assert.IsTrue(TypeGuard.TNumber(K))
   })
   it('Should KeyOf 7', () => {
     const T = Type.Tuple([])
     const K = Type.KeyOf(T)
-    Assert.isEqual(TypeGuard.TNever(K), true)
+    Assert.IsTrue(TypeGuard.TNever(K))
   })
   it('Should KeyOf 8', () => {
     const T = Type.Tuple([Type.Number(), Type.Null()])
     const K = Type.KeyOf(T)
-    Assert.isEqual(TypeGuard.TUnion(K), true)
-    Assert.isEqual(K.anyOf[0].const, '0')
-    Assert.isEqual(K.anyOf[1].const, '1')
+    Assert.IsTrue(TypeGuard.TUnion(K))
+    Assert.IsEqual(K.anyOf[0].const, '0')
+    Assert.IsEqual(K.anyOf[1].const, '1')
   })
 })
diff --git a/test/runtime/type/guard/literal.ts b/test/runtime/type/guard/literal.ts
index 70d568f39..b982a5e7e 100644
--- a/test/runtime/type/guard/literal.ts
+++ b/test/runtime/type/guard/literal.ts
@@ -5,28 +5,28 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TLiteral', () => {
   it('Should guard for TLiteral of String', () => {
     const R = TypeGuard.TLiteral(Type.Literal('hello'))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should guard for TLiteral of Number', () => {
     const R = TypeGuard.TLiteral(Type.Literal(42))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should guard for TLiteral of Boolean', () => {
     const R = TypeGuard.TLiteral(Type.Literal(true))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TLiteral of Null', () => {
     // @ts-ignore
     const R = TypeGuard.TLiteral(Type.Literal(null))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TLiteral', () => {
     const R = TypeGuard.TLiteral(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TLiteral with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TLiteral(Type.Literal(42, { $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/lowercase.ts b/test/runtime/type/guard/lowercase.ts
new file mode 100644
index 000000000..3a269cd2e
--- /dev/null
+++ b/test/runtime/type/guard/lowercase.ts
@@ -0,0 +1,9 @@
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/Lowercase', () => {
+  it('Should guard for Lowercase', () => {
+    const T = Type.Lowercase(Type.Literal('HELLO'))
+    Assert.IsEqual(T.const, 'hello')
+  })
+})
diff --git a/test/runtime/type/guard/not.ts b/test/runtime/type/guard/not.ts
index 1bb7c2c87..71e5695e4 100644
--- a/test/runtime/type/guard/not.ts
+++ b/test/runtime/type/guard/not.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TNot', () => {
   it('Should guard for TNot', () => {
     const R = TypeGuard.TNot(Type.Not(Type.String()))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TNot 1', () => {
     const R = TypeGuard.TNot(Type.Not(null as any))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TNot with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TNot(Type.Not(Type.String()), { $id: 1 })
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/guard/null.ts b/test/runtime/type/guard/null.ts
index 7fc7f1931..dbeca23ae 100644
--- a/test/runtime/type/guard/null.ts
+++ b/test/runtime/type/guard/null.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TNull', () => {
   it('Should guard for TNull', () => {
     const R = TypeGuard.TNull(Type.Null())
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TNull', () => {
     const R = TypeGuard.TNull(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TNull with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TNull(Type.Null({ $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/number.ts b/test/runtime/type/guard/number.ts
index de8782045..02b911665 100644
--- a/test/runtime/type/guard/number.ts
+++ b/test/runtime/type/guard/number.ts
@@ -5,40 +5,40 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TNumber', () => {
   it('Should guard for TNumber', () => {
     const R = TypeGuard.TNumber(Type.Number())
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TNumber', () => {
     const R = TypeGuard.TNumber(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TNumber with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TNumber with invalid multipleOf', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ multipleOf: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TNumber with invalid minimum', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ minimum: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TNumber with invalid maximum', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ maximum: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TNumber with invalid exclusiveMinimum', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ exclusiveMinimum: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TNumber with invalid exclusiveMaximum', () => {
     // @ts-ignore
     const R = TypeGuard.TNumber(Type.Number({ exclusiveMaximum: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/object.ts b/test/runtime/type/guard/object.ts
index 4811794bd..4f7cfcddf 100644
--- a/test/runtime/type/guard/object.ts
+++ b/test/runtime/type/guard/object.ts
@@ -10,23 +10,20 @@ describe('type/guard/TObject', () => {
         y: Type.Number(),
       }),
     )
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not guard for TObject', () => {
     const R = TypeGuard.TObject(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TObject with escape characters in property key', () => {
     const R = TypeGuard.TObject(
       Type.Object({
         'hello\nworld': Type.Number(),
       }),
     )
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TObject with invalid property values', () => {
     const R = TypeGuard.TObject(
       Type.Object({
@@ -34,9 +31,8 @@ describe('type/guard/TObject', () => {
         y: {} as any,
       }),
     )
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TObject with invalid additionalProperties', () => {
     const R = TypeGuard.TObject(
       Type.Object(
@@ -49,9 +45,8 @@ describe('type/guard/TObject', () => {
         },
       ),
     )
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TObject with invalid $id', () => {
     const R = TypeGuard.TObject(
       Type.Object(
@@ -64,9 +59,8 @@ describe('type/guard/TObject', () => {
         },
       ),
     )
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TObject with invalid minProperties', () => {
     const R = TypeGuard.TObject(
       Type.Object(
@@ -79,9 +73,8 @@ describe('type/guard/TObject', () => {
         },
       ),
     )
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TObject with invalid maxProperties', () => {
     const R = TypeGuard.TObject(
       Type.Object(
@@ -94,9 +87,8 @@ describe('type/guard/TObject', () => {
         },
       ),
     )
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should guard for TObject with invalid additional properties', () => {
     const R = TypeGuard.TObject(
       Type.Object(
@@ -110,9 +102,8 @@ describe('type/guard/TObject', () => {
         },
       ),
     )
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TObject with valid additional properties schema', () => {
     const R = TypeGuard.TObject(
       Type.Object(
@@ -125,6 +116,6 @@ describe('type/guard/TObject', () => {
         },
       ),
     )
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/guard/omit.ts b/test/runtime/type/guard/omit.ts
index 0c2ccaf1a..b7d52a17f 100644
--- a/test/runtime/type/guard/omit.ts
+++ b/test/runtime/type/guard/omit.ts
@@ -8,11 +8,11 @@ describe('type/guard/TOmit', () => {
   // -------------------------------------------------------------------------
   it('Should support TUnsafe omit properties with no Kind', () => {
     const T = Type.Omit(Type.Object({ x: Type.Unsafe({ x: 1 }), y: Type.Number() }), ['x'])
-    Assert.isEqual(T.required, ['y'])
+    Assert.IsEqual(T.required, ['y'])
   })
   it('Should support TUnsafe omit properties with unregistered Kind', () => {
     const T = Type.Omit(Type.Object({ x: Type.Unsafe({ x: 1, [Kind]: 'UnknownOmitType' }), y: Type.Number() }), ['x'])
-    Assert.isEqual(T.required, ['y'])
+    Assert.IsEqual(T.required, ['y'])
   })
   // -------------------------------------------------------------------------
   // Standard Tests
@@ -25,8 +25,8 @@ describe('type/guard/TOmit', () => {
       }),
       ['x'],
     )
-    Assert.isEqual(TypeGuard.TNumber(T.properties.y), true)
-    Assert.isEqual(T.required, ['y'])
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.y))
+    Assert.IsEqual(T.required, ['y'])
   })
   it('Should Omit 2', () => {
     const T = Type.Omit(
@@ -36,8 +36,8 @@ describe('type/guard/TOmit', () => {
       }),
       ['x'],
     )
-    Assert.isEqual(TypeGuard.TNumber(T.properties.y), true)
-    Assert.isEqual(T.required, undefined)
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.y))
+    Assert.IsEqual(T.required, undefined)
   })
   it('Should Omit 3', () => {
     const L = Type.Literal('x')
@@ -48,15 +48,15 @@ describe('type/guard/TOmit', () => {
       }),
       L,
     )
-    Assert.isEqual(TypeGuard.TNumber(T.properties.y), true)
-    Assert.isEqual(T.required, ['y'])
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.y))
+    Assert.IsEqual(T.required, ['y'])
   })
   it('Should Omit 4', () => {
     const L = Type.Literal('x')
     const T = Type.Omit(Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })]), L)
-    Assert.isEqual(TypeGuard.TNumber(T.allOf[1].properties.y), true)
+    Assert.IsEqual(TypeGuard.TNumber(T.allOf[1].properties.y), true)
     // @ts-ignore
-    Assert.isEqual(T.allOf[1].properties.x, undefined)
+    Assert.IsEqual(T.allOf[1].properties.x, undefined)
   })
   it('Should Omit 5', () => {
     const L = Type.Union([Type.Literal('x'), Type.Literal('y')])
@@ -68,11 +68,11 @@ describe('type/guard/TOmit', () => {
       L,
     )
     // @ts-ignore
-    Assert.isEqual(T.properties.x, undefined)
+    Assert.IsEqual(T.properties.x, undefined)
     // @ts-ignore
-    Assert.isEqual(T.properties.y, undefined)
+    Assert.IsEqual(T.properties.y, undefined)
     // @ts-ignore
-    Assert.isEqual(T.required, undefined)
+    Assert.IsEqual(T.required, undefined)
   })
   it('Should Omit 6', () => {
     const L = Type.Union([Type.Literal('x'), Type.Literal('y'), Type.Literal('z')])
@@ -84,11 +84,11 @@ describe('type/guard/TOmit', () => {
       L,
     )
     // @ts-ignore
-    Assert.isEqual(T.properties.x, undefined)
+    Assert.IsEqual(T.properties.x, undefined)
     // @ts-ignore
-    Assert.isEqual(T.properties.y, undefined)
+    Assert.IsEqual(T.properties.y, undefined)
     // @ts-ignore
-    Assert.isEqual(T.required, undefined)
+    Assert.IsEqual(T.required, undefined)
   })
   it('Should Omit 7', () => {
     const L = Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])])
@@ -100,7 +100,7 @@ describe('type/guard/TOmit', () => {
       }),
       L,
     )
-    Assert.isEqual(TypeGuard.TNumber(T.properties.ad), true)
-    Assert.isEqual(T.required, ['ad'])
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.ad))
+    Assert.IsEqual(T.required, ['ad'])
   })
 })
diff --git a/test/runtime/type/guard/partial.ts b/test/runtime/type/guard/partial.ts
index 523f2acc3..f7f996d59 100644
--- a/test/runtime/type/guard/partial.ts
+++ b/test/runtime/type/guard/partial.ts
@@ -1,23 +1,43 @@
-import { TypeSystem } from '@sinclair/typebox/system'
-import { TypeGuard } from '@sinclair/typebox'
-import { Type, Kind } from '@sinclair/typebox'
+import { TypeGuard, TypeRegistry, Type, Kind } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/TPartial', () => {
+  it('Should produce a valid TSchema', () => {
+    const T = Type.Partial(Type.Object({ x: Type.Number() }))
+    Assert.IsTrue(TypeGuard.TSchema(T))
+  })
   // -------------------------------------------------------------------------
   // case: https://github.com/sinclairzx81/typebox/issues/364
   // -------------------------------------------------------------------------
   it('Should support TUnsafe partial properties with no Kind', () => {
     const T = Type.Partial(Type.Object({ x: Type.Unsafe({ x: 1 }) }))
-    Assert.isEqual(T.required, undefined)
+    Assert.IsEqual(T.required, undefined)
   })
-  it('Should support TUnsafe partial properties with unregistered Kind', () => {
+  it('Should support TUnsafe partial properties with unknown Kind', () => {
     const T = Type.Partial(Type.Object({ x: Type.Unsafe({ [Kind]: 'UnknownPartialType', x: 1 }) }))
-    Assert.isEqual(T.required, undefined)
+    Assert.IsEqual(T.required, undefined)
+  })
+  it('Should support TUnsafe partial properties with known Kind', () => {
+    TypeRegistry.Set('KnownPartialType', () => true)
+    const T = Type.Partial(Type.Object({ x: Type.Unsafe({ [Kind]: 'KnownPartialType', x: 1 }) }))
+    Assert.IsEqual(T.required, undefined)
+  })
+  it('Should support applying partial to intersect', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const I = Type.Intersect([A, B])
+    const T = Type.Partial(I)
+    Assert.IsEqual(T.allOf.length, 2)
+    Assert.IsEqual(T.allOf[0].required, undefined)
+    Assert.IsEqual(T.allOf[1].required, undefined)
   })
-  it('Should support TUnsafe partial properties with registered Kind', () => {
-    const U = TypeSystem.Type('CustomPartialType', () => true)
-    const T = Type.Partial(Type.Object({ x: U() }))
-    Assert.isEqual(T.required, undefined)
+  it('Should support applying partial to union', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const I = Type.Union([A, B])
+    const T = Type.Partial(I)
+    Assert.IsEqual(T.anyOf.length, 2)
+    Assert.IsEqual(T.anyOf[0].required, undefined)
+    Assert.IsEqual(T.anyOf[1].required, undefined)
   })
 })
diff --git a/test/runtime/type/guard/pick.ts b/test/runtime/type/guard/pick.ts
index 43a22ce80..029160552 100644
--- a/test/runtime/type/guard/pick.ts
+++ b/test/runtime/type/guard/pick.ts
@@ -14,11 +14,11 @@ describe('type/guard/TPick', () => {
       }),
       ['x'],
     )
-    Assert.isEqual(T.required, ['x'])
+    Assert.IsEqual(T.required, ['x'])
   })
   it('Should support TUnsafe omit properties with unregistered Kind', () => {
     const T = Type.Pick(Type.Object({ x: Type.Unsafe({ x: 1, [Kind]: 'UnknownPickType' }), y: Type.Number() }), ['x'])
-    Assert.isEqual(T.required, ['x'])
+    Assert.IsEqual(T.required, ['x'])
   })
   // -------------------------------------------------------------------------
   // Standard Tests
@@ -31,8 +31,8 @@ describe('type/guard/TPick', () => {
       }),
       ['x'],
     )
-    Assert.isEqual(TypeGuard.TNumber(T.properties.x), true)
-    Assert.isEqual(T.required, ['x'])
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.x))
+    Assert.IsEqual(T.required, ['x'])
   })
   it('Should Pick 2', () => {
     const T = Type.Pick(
@@ -42,8 +42,8 @@ describe('type/guard/TPick', () => {
       }),
       ['x'],
     )
-    Assert.isEqual(TypeGuard.TNumber(T.properties.x), true)
-    Assert.isEqual(T.required, undefined)
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.x))
+    Assert.IsEqual(T.required, undefined)
   })
   it('Should Pick 3', () => {
     const L = Type.Literal('x')
@@ -54,16 +54,16 @@ describe('type/guard/TPick', () => {
       }),
       L,
     )
-    Assert.isEqual(TypeGuard.TNumber(T.properties.x), true)
-    Assert.isEqual(T.required, ['x'])
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.x))
+    Assert.IsEqual(T.required, ['x'])
   })
   it('Should Pick 4', () => {
     const L = Type.Literal('x')
     const T = Type.Pick(Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })]), L)
 
-    Assert.isEqual(TypeGuard.TNumber(T.allOf[0].properties.x), true)
+    Assert.IsTrue(TypeGuard.TNumber(T.allOf[0].properties.x))
     // @ts-ignore
-    Assert.isEqual(T.allOf[1].properties.y, undefined)
+    Assert.IsEqual(T.allOf[1].properties.y, undefined)
   })
   it('Should Pick 5', () => {
     const L = Type.Union([Type.Literal('x'), Type.Literal('y')])
@@ -74,9 +74,9 @@ describe('type/guard/TPick', () => {
       }),
       L,
     )
-    Assert.isEqual(TypeGuard.TNumber(T.properties.x), true)
-    Assert.isEqual(TypeGuard.TNumber(T.properties.y), true)
-    Assert.isEqual(T.required, ['x', 'y'])
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.x))
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.y))
+    Assert.IsEqual(T.required, ['x', 'y'])
   })
   it('Should Pick 6', () => {
     const L = Type.Union([Type.Literal('x'), Type.Literal('y'), Type.Literal('z')])
@@ -87,9 +87,9 @@ describe('type/guard/TPick', () => {
       }),
       L,
     )
-    Assert.isEqual(TypeGuard.TNumber(T.properties.x), true)
-    Assert.isEqual(TypeGuard.TNumber(T.properties.y), true)
-    Assert.isEqual(T.required, ['x', 'y'])
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.x))
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.y))
+    Assert.IsEqual(T.required, ['x', 'y'])
   })
   it('Should Pick 7', () => {
     const L = Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])])
@@ -101,8 +101,8 @@ describe('type/guard/TPick', () => {
       }),
       L,
     )
-    Assert.isEqual(TypeGuard.TNumber(T.properties.ab), true)
-    Assert.isEqual(TypeGuard.TNumber(T.properties.ac), true)
-    Assert.isEqual(T.required, ['ab', 'ac'])
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.ab))
+    Assert.IsTrue(TypeGuard.TNumber(T.properties.ac))
+    Assert.IsEqual(T.required, ['ab', 'ac'])
   })
 })
diff --git a/test/runtime/type/guard/promise.ts b/test/runtime/type/guard/promise.ts
index 96e49b0bd..f00ecc78a 100644
--- a/test/runtime/type/guard/promise.ts
+++ b/test/runtime/type/guard/promise.ts
@@ -5,20 +5,17 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TPromise', () => {
   it('Should guard for TPromise', () => {
     const R = TypeGuard.TPromise(Type.Promise(Type.Number()))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not guard for TPromise', () => {
     const R = TypeGuard.TPromise(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TPromise with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TPromise(Type.Promise(Type.Number(), { $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should guard for TPromise with nested TObject', () => {
     const R = TypeGuard.TPromise(
       Type.Promise(
@@ -28,9 +25,8 @@ describe('type/guard/TPromise', () => {
         }),
       ),
     )
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not guard for TPromise with nested TObject', () => {
     const R = TypeGuard.TPromise(
       Type.Promise(
@@ -40,6 +36,6 @@ describe('type/guard/TPromise', () => {
         }),
       ),
     )
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/record.ts b/test/runtime/type/guard/record.ts
index 94bea05ec..2703dd85d 100644
--- a/test/runtime/type/guard/record.ts
+++ b/test/runtime/type/guard/record.ts
@@ -8,74 +8,74 @@ describe('type/guard/TRecord', () => {
   // -------------------------------------------------------------
   it('Should guard overload 1', () => {
     const T = Type.Record(Type.Union([Type.Literal('A'), Type.Literal('B')]), Type.String(), { extra: 1 })
-    Assert.isTrue(TypeGuard.TObject(T))
-    Assert.isTrue(TypeGuard.TString(T.properties.A))
-    Assert.isTrue(TypeGuard.TString(T.properties.B))
-    Assert.isEqual(T.extra, 1)
+    Assert.IsTrue(TypeGuard.TObject(T))
+    Assert.IsTrue(TypeGuard.TString(T.properties.A))
+    Assert.IsTrue(TypeGuard.TString(T.properties.B))
+    Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 2', () => {
     const T = Type.Record(Type.Union([Type.Literal('A')]), Type.String(), { extra: 1 }) // unwrap as literal
-    Assert.isTrue(TypeGuard.TObject(T))
-    Assert.isTrue(TypeGuard.TString(T.properties.A))
-    Assert.isEqual(T.extra, 1)
+    Assert.IsTrue(TypeGuard.TObject(T))
+    Assert.IsTrue(TypeGuard.TString(T.properties.A))
+    Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 3', () => {
     // @ts-ignore
-    Assert.throws(() => Type.Record(Type.Union([]), Type.String(), { extra: 1 }))
+    Assert.Throws(() => Type.Record(Type.Union([]), Type.String(), { extra: 1 }))
   })
   it('Should guard overload 4', () => {
     const T = Type.Record(Type.Literal('A'), Type.String(), { extra: 1 })
-    Assert.isTrue(TypeGuard.TObject(T))
-    Assert.isTrue(TypeGuard.TString(T.properties.A))
-    Assert.isEqual(T.extra, 1)
+    Assert.IsTrue(TypeGuard.TObject(T))
+    Assert.IsTrue(TypeGuard.TString(T.properties.A))
+    Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 5', () => {
     const L = Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal('A'), Type.Literal('B')])])
     const T = Type.Record(L, Type.String(), { extra: 1 })
-    Assert.isTrue(TypeGuard.TObject(T))
-    Assert.isTrue(TypeGuard.TString(T.properties.helloA))
-    Assert.isTrue(TypeGuard.TString(T.properties.helloB))
-    Assert.isEqual(T.extra, 1)
+    Assert.IsTrue(TypeGuard.TObject(T))
+    Assert.IsTrue(TypeGuard.TString(T.properties.helloA))
+    Assert.IsTrue(TypeGuard.TString(T.properties.helloB))
+    Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 6', () => {
     const T = Type.Record(Type.Number(), Type.String(), { extra: 1 })
-    Assert.isTrue(TypeGuard.TRecord(T))
-    Assert.isTrue(TypeGuard.TString(T.patternProperties[PatternNumberExact]))
-    Assert.isEqual(T.extra, 1)
+    Assert.IsTrue(TypeGuard.TRecord(T))
+    Assert.IsTrue(TypeGuard.TString(T.patternProperties[PatternNumberExact]))
+    Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 7', () => {
     const T = Type.Record(Type.Integer(), Type.String(), { extra: 1 })
-    Assert.isTrue(TypeGuard.TRecord(T))
-    Assert.isTrue(TypeGuard.TString(T.patternProperties[PatternNumberExact]))
-    Assert.isEqual(T.extra, 1)
+    Assert.IsTrue(TypeGuard.TRecord(T))
+    Assert.IsTrue(TypeGuard.TString(T.patternProperties[PatternNumberExact]))
+    Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 8', () => {
     const T = Type.Record(Type.String(), Type.String(), { extra: 1 })
-    Assert.isTrue(TypeGuard.TRecord(T))
-    Assert.isTrue(TypeGuard.TString(T.patternProperties[PatternStringExact]))
-    Assert.isEqual(T.extra, 1)
+    Assert.IsTrue(TypeGuard.TRecord(T))
+    Assert.IsTrue(TypeGuard.TString(T.patternProperties[PatternStringExact]))
+    Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 9', () => {
     const L = Type.TemplateLiteral([Type.String(), Type.Literal('_foo')])
     const T = Type.Record(L, Type.String(), { extra: 1 })
-    Assert.isTrue(TypeGuard.TRecord(T))
-    Assert.isTrue(TypeGuard.TString(T.patternProperties[`^${PatternString}_foo$`]))
-    Assert.isEqual(T.extra, 1)
+    Assert.IsTrue(TypeGuard.TRecord(T))
+    Assert.IsTrue(TypeGuard.TString(T.patternProperties[`^${PatternString}_foo$`]))
+    Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 10', () => {
     const L = Type.Union([Type.Literal('A'), Type.Union([Type.Literal('B'), Type.Literal('C')])])
     const T = Type.Record(L, Type.String())
-    Assert.isTrue(TypeGuard.TObject(T))
-    Assert.isTrue(TypeGuard.TString(T.properties.A))
-    Assert.isTrue(TypeGuard.TString(T.properties.B))
-    Assert.isTrue(TypeGuard.TString(T.properties.C))
+    Assert.IsTrue(TypeGuard.TObject(T))
+    Assert.IsTrue(TypeGuard.TString(T.properties.A))
+    Assert.IsTrue(TypeGuard.TString(T.properties.B))
+    Assert.IsTrue(TypeGuard.TString(T.properties.C))
   })
   // -------------------------------------------------------------
   // Variants
   // -------------------------------------------------------------
   it('Should guard for TRecord', () => {
     const R = TypeGuard.TRecord(Type.Record(Type.String(), Type.Number()))
-    Assert.isTrue(R)
+    Assert.IsTrue(R)
   })
   it('Should guard for TRecord with TObject value', () => {
     const R = TypeGuard.TRecord(
@@ -87,16 +87,16 @@ describe('type/guard/TRecord', () => {
         }),
       ),
     )
-    Assert.isTrue(R)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TRecord', () => {
     const R = TypeGuard.TRecord(null)
-    Assert.isFalse(R)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TRecord with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TRecord(Type.Record(Type.String(), Type.Number(), { $id: 1 }))
-    Assert.isFalse(R)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TRecord with TObject value with invalid Property', () => {
     const R = TypeGuard.TRecord(
@@ -108,16 +108,16 @@ describe('type/guard/TRecord', () => {
         }),
       ),
     )
-    Assert.isFalse(R)
+    Assert.IsFalse(R)
   })
   it('Transform: Should should transform to TObject for single literal union value', () => {
     const K = Type.Union([Type.Literal('ok')])
     const R = TypeGuard.TObject(Type.Record(K, Type.Number()))
-    Assert.isTrue(R)
+    Assert.IsTrue(R)
   })
   it('Transform: Should should transform to TObject for multi literal union value', () => {
     const K = Type.Union([Type.Literal('A'), Type.Literal('B')])
     const R = TypeGuard.TObject(Type.Record(K, Type.Number()))
-    Assert.isTrue(R)
+    Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/guard/ref.ts b/test/runtime/type/guard/ref.ts
index 53b381954..83682d29d 100644
--- a/test/runtime/type/guard/ref.ts
+++ b/test/runtime/type/guard/ref.ts
@@ -6,20 +6,18 @@ describe('type/guard/TRef', () => {
   it('Should guard for TRef', () => {
     const T = Type.Number({ $id: 'T' })
     const R = TypeGuard.TRef(Type.Ref(T))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not guard for TRef', () => {
     const R = TypeGuard.TRef(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TRef with invalid $ref', () => {
     const T = Type.Number({ $id: 'T' })
     const S = Type.Ref(T)
     // @ts-ignore
     S.$ref = 1
     const R = TypeGuard.TRef(S)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/required.ts b/test/runtime/type/guard/required.ts
new file mode 100644
index 000000000..4090a91fa
--- /dev/null
+++ b/test/runtime/type/guard/required.ts
@@ -0,0 +1,40 @@
+import { TypeGuard, TypeRegistry, Type, Kind } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TRequired', () => {
+  it('Should produce a valid TSchema', () => {
+    const T = Type.Required(Type.Object({ x: Type.Number() }))
+    Assert.IsTrue(TypeGuard.TSchema(T))
+  })
+  it('Should support TUnsafe required properties with no Kind', () => {
+    const T = Type.Required(Type.Object({ x: Type.Optional(Type.Unsafe({ x: 1 })) }))
+    Assert.IsEqual(T.required, ['x'])
+  })
+  it('Should support TUnsafe required properties with unknown Kind', () => {
+    const T = Type.Required(Type.Object({ x: Type.Optional(Type.Unsafe({ [Kind]: 'UnknownRequiredType', x: 1 })) }))
+    Assert.IsEqual(T.required, ['x'])
+  })
+  it('Should support TUnsafe required properties with known Kind', () => {
+    TypeRegistry.Set('KnownRequiredType', () => true)
+    const T = Type.Required(Type.Object({ x: Type.Optional(Type.Unsafe({ [Kind]: 'KnownRequiredType', x: 1 })) }))
+    Assert.IsEqual(T.required, ['x'])
+  })
+  it('Should support applying required to intersect', () => {
+    const A = Type.Object({ x: Type.Optional(Type.Number()) })
+    const B = Type.Object({ y: Type.Optional(Type.Number()) })
+    const I = Type.Intersect([A, B])
+    const T = Type.Required(I)
+    Assert.IsEqual(T.allOf.length, 2)
+    Assert.IsEqual(T.allOf[0].required, ['x'])
+    Assert.IsEqual(T.allOf[1].required, ['y'])
+  })
+  it('Should support applying required to union', () => {
+    const A = Type.Object({ x: Type.Optional(Type.Number()) })
+    const B = Type.Object({ y: Type.Optional(Type.Number()) })
+    const I = Type.Union([A, B])
+    const T = Type.Required(I)
+    Assert.IsEqual(T.anyOf.length, 2)
+    Assert.IsEqual(T.anyOf[0].required, ['x'])
+    Assert.IsEqual(T.anyOf[1].required, ['y'])
+  })
+})
diff --git a/test/runtime/type/guard/rest.ts b/test/runtime/type/guard/rest.ts
index 1e9e831ee..c911da85c 100644
--- a/test/runtime/type/guard/rest.ts
+++ b/test/runtime/type/guard/rest.ts
@@ -6,17 +6,17 @@ describe('type/guard/TRest', () => {
   it('Should guard Rest 1', () => {
     const T = Type.Tuple([Type.String(), Type.Number()])
     const R = Type.Rest(T)
-    Assert.isTrue(TypeGuard.TString(R[0]))
-    Assert.isTrue(TypeGuard.TNumber(R[1]))
+    Assert.IsTrue(TypeGuard.TString(R[0]))
+    Assert.IsTrue(TypeGuard.TNumber(R[1]))
   })
   it('Should guard Rest 2', () => {
     const T = Type.Tuple([])
     const R = Type.Rest(T)
-    Assert.isEqual(R.length, 0)
+    Assert.IsEqual(R.length, 0)
   })
   it('Should guard Rest 3', () => {
     const T = Type.String()
     const R = Type.Rest(T)
-    Assert.isTrue(TypeGuard.TString(R[0]))
+    Assert.IsTrue(TypeGuard.TString(R[0]))
   })
 })
diff --git a/test/runtime/type/guard/string.ts b/test/runtime/type/guard/string.ts
index 308da7e62..50205a1da 100644
--- a/test/runtime/type/guard/string.ts
+++ b/test/runtime/type/guard/string.ts
@@ -5,35 +5,30 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TString', () => {
   it('Should guard for TString', () => {
     const R = TypeGuard.TString(Type.String())
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not guard for TString', () => {
     const R = TypeGuard.TString(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TString with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TString(Type.String({ $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TString with invalid minLength', () => {
     // @ts-ignore
     const R = TypeGuard.TString(Type.String({ minLength: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TString with invalid maxLength', () => {
     // @ts-ignore
     const R = TypeGuard.TString(Type.String({ maxLength: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TString with invalid pattern', () => {
     // @ts-ignore
     const R = TypeGuard.TString(Type.String({ pattern: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/symbol.ts b/test/runtime/type/guard/symbol.ts
index a22a53fd7..28041bfe2 100644
--- a/test/runtime/type/guard/symbol.ts
+++ b/test/runtime/type/guard/symbol.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TSymbol', () => {
   it('Should guard for TSymbol', () => {
     const R = TypeGuard.TSymbol(Type.Symbol())
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TSymbol', () => {
     const R = TypeGuard.TSymbol(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TSymbol with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TSymbol(Type.Symbol({ $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/template-literal.ts b/test/runtime/type/guard/template-literal.ts
index 79112c294..7637133c6 100644
--- a/test/runtime/type/guard/template-literal.ts
+++ b/test/runtime/type/guard/template-literal.ts
@@ -5,43 +5,43 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TTemplateLiteral', () => {
   it('Should guard for empty TemplateLiteral', () => {
     const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([]))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should guard for TSchema', () => {
     const R = TypeGuard.TSchema(Type.TemplateLiteral([]))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should guard for TemplateLiteral (TTemplateLiteral)', () => {
     const T = Type.TemplateLiteral([Type.Literal('hello')])
     const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([T, Type.Literal('world')]))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should guard for TemplateLiteral (TLiteral)', () => {
     const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([Type.Literal('hello')]))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should guard for TemplateLiteral (TString)', () => {
     const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([Type.String()]))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should guard for TemplateLiteral (TNumber)', () => {
     const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([Type.Number()]))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should guard for TemplateLiteral (TBoolean)', () => {
     const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([Type.Boolean()]))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for missing ^ expression prefix', () => {
     const T = Type.TemplateLiteral([Type.Literal('hello')])
     // @ts-ignore
     T.pattern = T.pattern.slice(1)
-    Assert.isEqual(TypeGuard.TTemplateLiteral(T), false)
+    Assert.IsFalse(TypeGuard.TTemplateLiteral(T))
   })
   it('Should not guard for missing $ expression postfix', () => {
     const T = Type.TemplateLiteral([Type.Literal('hello')])
     // @ts-ignore
     T.pattern = T.pattern.slice(0, T.pattern.length - 1)
-    Assert.isEqual(TypeGuard.TTemplateLiteral(T), false)
+    Assert.IsFalse(TypeGuard.TTemplateLiteral(T))
   })
 })
diff --git a/test/runtime/type/guard/this.ts b/test/runtime/type/guard/this.ts
index 1668c93ad..93508d53c 100644
--- a/test/runtime/type/guard/this.ts
+++ b/test/runtime/type/guard/this.ts
@@ -6,7 +6,7 @@ describe('type/guard/TThis', () => {
   it('Should guard for TThis', () => {
     Type.Recursive((This) => {
       const R = TypeGuard.TThis(This)
-      Assert.isEqual(R, true)
+      Assert.IsTrue(R)
       return Type.Object({ nodes: Type.Array(This) })
     })
   })
@@ -15,7 +15,7 @@ describe('type/guard/TThis', () => {
       // @ts-ignore
       This.$ref = 1
       const R = TypeGuard.TThis(This)
-      Assert.isEqual(R, false)
+      Assert.IsFalse(R)
       return Type.Object({ nodes: Type.Array(This) })
     })
   })
diff --git a/test/runtime/type/guard/tuple.ts b/test/runtime/type/guard/tuple.ts
index d438753b6..9326c23d2 100644
--- a/test/runtime/type/guard/tuple.ts
+++ b/test/runtime/type/guard/tuple.ts
@@ -5,19 +5,19 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TTuple', () => {
   it('Should guard for TTuple', () => {
     const R = TypeGuard.TTuple(Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TTuple', () => {
     const R = TypeGuard.TTuple(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TTuple with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TTuple(Type.Tuple([Type.Number(), Type.Number()], { $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TTuple with invalid Items', () => {
     const R = TypeGuard.TTuple(Type.Tuple([Type.Number(), {} as any]))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/uint8array.ts b/test/runtime/type/guard/uint8array.ts
index c2657f6af..cc058d8b3 100644
--- a/test/runtime/type/guard/uint8array.ts
+++ b/test/runtime/type/guard/uint8array.ts
@@ -5,29 +5,25 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TUint8Array', () => {
   it('Should guard for TUint8Array', () => {
     const R = TypeGuard.TUint8Array(Type.Uint8Array())
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not guard for TUint8Array', () => {
     const R = TypeGuard.TUint8Array(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TUint8Array with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TUint8Array(Type.Uint8Array({ $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TUint8Array with invalid minByteLength', () => {
     // @ts-ignore
     const R = TypeGuard.TUint8Array(Type.Uint8Array({ minByteLength: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not guard for TUint8Array with invalid maxByteLength', () => {
     // @ts-ignore
     const R = TypeGuard.TUint8Array(Type.Uint8Array({ maxByteLength: '1' }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/uncapitalize.ts b/test/runtime/type/guard/uncapitalize.ts
new file mode 100644
index 000000000..ece6195a3
--- /dev/null
+++ b/test/runtime/type/guard/uncapitalize.ts
@@ -0,0 +1,10 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/Uncapitalize', () => {
+  it('Should guard for Uncapitalize', () => {
+    const T = Type.Uncapitalize(Type.Literal('HELLO'))
+    Assert.IsEqual(T.const, 'hELLO')
+  })
+})
diff --git a/test/runtime/type/guard/undefined.ts b/test/runtime/type/guard/undefined.ts
index 7f6d4a593..8393bff76 100644
--- a/test/runtime/type/guard/undefined.ts
+++ b/test/runtime/type/guard/undefined.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TUndefined', () => {
   it('Should guard for TUndefined', () => {
     const R = TypeGuard.TUndefined(Type.Undefined())
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TUndefined', () => {
     const R = TypeGuard.TUndefined(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TUndefined with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TUndefined(Type.Undefined({ $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/union.ts b/test/runtime/type/guard/union.ts
index b28b0052c..62b485e40 100644
--- a/test/runtime/type/guard/union.ts
+++ b/test/runtime/type/guard/union.ts
@@ -14,11 +14,11 @@ describe('type/guard/TUnion', () => {
         }),
       ]),
     )
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TUnion', () => {
     const R = TypeGuard.TUnion(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should guard for TUnion with invalid $id', () => {
     const R = TypeGuard.TUnion(
@@ -38,7 +38,7 @@ describe('type/guard/TUnion', () => {
         },
       ),
     )
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TUnion with invalid variant', () => {
     const R = TypeGuard.TUnion(
@@ -49,7 +49,7 @@ describe('type/guard/TUnion', () => {
         {} as any,
       ]),
     )
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TUnion with invalid object variant', () => {
     const R = TypeGuard.TUnion(
@@ -62,25 +62,25 @@ describe('type/guard/TUnion', () => {
         }),
       ]),
     )
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Transform: Should transform to never for zero length union', () => {
     const T = Type.Union([])
     const R = TypeGuard.TNever(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Transform: Should unwrap union type for array of length === 1', () => {
     const T = Type.Union([Type.String()])
     const R = TypeGuard.TString(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Transform: Should retain union if array length > 1', () => {
     const T = Type.Union([Type.String(), Type.Number()])
     const R1 = TypeGuard.TUnion(T)
     const R2 = TypeGuard.TString(T.anyOf[0])
     const R3 = TypeGuard.TNumber(T.anyOf[1])
-    Assert.isEqual(R1, true)
-    Assert.isEqual(R2, true)
-    Assert.isEqual(R3, true)
+    Assert.IsTrue(R1)
+    Assert.IsTrue(R2)
+    Assert.IsTrue(R3)
   })
 })
diff --git a/test/runtime/type/guard/unknown.ts b/test/runtime/type/guard/unknown.ts
index 2c2dce22e..bd5cfcd03 100644
--- a/test/runtime/type/guard/unknown.ts
+++ b/test/runtime/type/guard/unknown.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TUnknown', () => {
   it('Should guard for TUnknown', () => {
     const R = TypeGuard.TUnknown(Type.Unknown())
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TUnknown', () => {
     const R = TypeGuard.TUnknown(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TUnknown with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TUnknown(Type.Unknown({ $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/unsafe.ts b/test/runtime/type/guard/unsafe.ts
index b54e1f16b..f43a2d78d 100644
--- a/test/runtime/type/guard/unsafe.ts
+++ b/test/runtime/type/guard/unsafe.ts
@@ -6,27 +6,28 @@ describe('type/guard/TUnsafe', () => {
   it('Should guard raw TUnsafe', () => {
     const T = Type.Unsafe({ x: 1 })
     const R = TypeGuard.TUnsafe(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should guard raw TUnsafe as TSchema', () => {
     const T = Type.Unsafe({ x: 1 })
     const R = TypeGuard.TSchema(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should guard override TUnsafe as TSchema when registered', () => {
-    TypeRegistry.Set('type/guard/TUnsafe/Type1', () => true)
-    const T = Type.Unsafe({ [Kind]: 'type/guard/TUnsafe/Type1' })
+    TypeRegistry.Set('UnsafeType', () => true)
+    const T = Type.Unsafe({ [Kind]: 'UnsafeType' })
     const R = TypeGuard.TSchema(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
+    TypeRegistry.Delete('UnsafeType')
   })
   it('Should not guard TUnsafe with unregistered kind', () => {
-    const T = Type.Unsafe({ [Kind]: 'type/guard/TUnsafe/Type2' })
+    const T = Type.Unsafe({ [Kind]: 'UnsafeType' })
     const R = TypeGuard.TUnsafe(T)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TString', () => {
     const T = Type.String()
     const R = TypeGuard.TUnsafe(T)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/uppercase.ts b/test/runtime/type/guard/uppercase.ts
new file mode 100644
index 000000000..f85bdad43
--- /dev/null
+++ b/test/runtime/type/guard/uppercase.ts
@@ -0,0 +1,10 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/Uppercase', () => {
+  it('Should guard for Uppercase', () => {
+    const T = Type.Uppercase(Type.Literal('hello'))
+    Assert.IsEqual(T.const, 'HELLO')
+  })
+})
diff --git a/test/runtime/type/guard/void.ts b/test/runtime/type/guard/void.ts
index 976639621..fb60e97a7 100644
--- a/test/runtime/type/guard/void.ts
+++ b/test/runtime/type/guard/void.ts
@@ -5,15 +5,15 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TVoid', () => {
   it('Should guard for TVoid', () => {
     const R = TypeGuard.TVoid(Type.Void())
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not guard for TVoid', () => {
     const R = TypeGuard.TVoid(null)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not guard for TVoid with invalid $id', () => {
     // @ts-ignore
     const R = TypeGuard.TVoid(Type.Void({ $id: 1 }))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/index.ts b/test/runtime/type/index.ts
index 0d61b85fd..dd13431a2 100644
--- a/test/runtime/type/index.ts
+++ b/test/runtime/type/index.ts
@@ -4,3 +4,4 @@ import './guard/index'
 import './normalize/index'
 import './registry/index'
 import './template/index'
+import './value/index'
diff --git a/test/runtime/type/normalize/exclude.ts b/test/runtime/type/normalize/exclude.ts
index 16a91ede6..299309d93 100644
--- a/test/runtime/type/normalize/exclude.ts
+++ b/test/runtime/type/normalize/exclude.ts
@@ -6,16 +6,16 @@ describe('type/normal/Exclude', () => {
   it('Normalize 1', () => {
     const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
     const R = TypeGuard.TUnion(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Normalize 2', () => {
     const T = Type.Exclude(Type.Union([Type.String(), Type.Number()]), Type.String())
     const R = TypeGuard.TNumber(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Normalize 3', () => {
     const T = Type.Exclude(Type.Union([Type.String()]), Type.String())
     const R = TypeGuard.TNever(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/normalize/extract.ts b/test/runtime/type/normalize/extract.ts
index f4b87a649..3e9c6f7e0 100644
--- a/test/runtime/type/normalize/extract.ts
+++ b/test/runtime/type/normalize/extract.ts
@@ -6,26 +6,26 @@ describe('type/normal/Extract', () => {
   it('Normalize 1', () => {
     const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Number()]))
     const R = TypeGuard.TUnion(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Normalize 2', () => {
     const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
     const R = TypeGuard.TString(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Normalize 3', () => {
     const T = Type.Extract(Type.Union([Type.String(), Type.Number()]), Type.String())
     const R = TypeGuard.TString(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Normalize 4', () => {
     const T = Type.Extract(Type.Union([Type.String()]), Type.String())
     const R = TypeGuard.TString(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Normalize 5', () => {
     const T = Type.Extract(Type.Union([]), Type.String())
     const R = TypeGuard.TNever(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/normalize/indexed.ts b/test/runtime/type/normalize/indexed.ts
index eba47cb00..8e726db80 100644
--- a/test/runtime/type/normalize/indexed.ts
+++ b/test/runtime/type/normalize/indexed.ts
@@ -9,7 +9,7 @@ describe('type/normal/Index', () => {
   it('Normalize Array 1', () => {
     const T = Type.Array(Type.String())
     const I = Type.Index(T, Type.Number())
-    Assert.isEqual(TypeGuard.TString(I), true)
+    Assert.IsTrue(TypeGuard.TString(I))
   })
   // ---------------------------------------------------------
   // Tuple
@@ -17,33 +17,33 @@ describe('type/normal/Index', () => {
   it('Normalize Tuple 1', () => {
     const T = Type.Tuple([Type.String(), Type.Number()])
     const I = Type.Index(T, Type.Number())
-    Assert.isEqual(TypeGuard.TUnion(I), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TNumber(I.anyOf[1]), true)
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
   })
   it('Normalize Tuple 2', () => {
     const T = Type.Tuple([Type.String(), Type.Number()])
     const I = Type.Index(T, [0, 1])
-    Assert.isEqual(TypeGuard.TUnion(I), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TNumber(I.anyOf[1]), true)
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
   })
   it('Normalize Tuple 3', () => {
     const T = Type.Tuple([Type.String(), Type.Number()])
     const I = Type.Index(T, ['0', '1'])
-    Assert.isEqual(TypeGuard.TUnion(I), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TNumber(I.anyOf[1]), true)
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
   })
   it('Normalize Tuple 4', () => {
     const T = Type.Tuple([Type.String(), Type.Number()])
     const I = Type.Index(T, ['0'])
-    Assert.isEqual(TypeGuard.TString(I), true)
+    Assert.IsTrue(TypeGuard.TString(I))
   })
   it('Normalize Tuple 5', () => {
     const T = Type.Tuple([Type.String(), Type.Number()])
     const I = Type.Index(T, ['1'])
-    Assert.isEqual(TypeGuard.TNumber(I), true)
+    Assert.IsTrue(TypeGuard.TNumber(I))
   })
   // ---------------------------------------------------------
   // Intersect
@@ -51,47 +51,47 @@ describe('type/normal/Index', () => {
   it('Normalize Intersect 1', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Optional(Type.String()) }), Type.Object({ x: Type.Optional(Type.String()) })])
     const I = Type.Index(T, ['x'])
-    Assert.isEqual(TypeGuard.TOptional(I), true)
-    Assert.isEqual(TypeGuard.TIntersect(I), true)
-    Assert.isEqual(TypeGuard.TString(I.allOf[0]), true)
-    Assert.isEqual(TypeGuard.TString(I.allOf[1]), true)
+    Assert.IsTrue(TypeGuard.TOptional(I))
+    Assert.IsTrue(TypeGuard.TIntersect(I))
+    Assert.IsTrue(TypeGuard.TString(I.allOf[0]))
+    Assert.IsTrue(TypeGuard.TString(I.allOf[1]))
   })
   it('Normalize Intersect 2', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Optional(Type.String()) }), Type.Object({ x: Type.String() })])
     const I = Type.Index(T, ['x'])
-    Assert.isEqual(TypeGuard.TOptional(I), false)
-    Assert.isEqual(TypeGuard.TIntersect(I), true)
-    Assert.isEqual(TypeGuard.TString(I.allOf[0]), true)
-    Assert.isEqual(TypeGuard.TString(I.allOf[1]), true)
+    Assert.IsFalse(TypeGuard.TOptional(I))
+    Assert.IsTrue(TypeGuard.TIntersect(I))
+    Assert.IsTrue(TypeGuard.TString(I.allOf[0]))
+    Assert.IsTrue(TypeGuard.TString(I.allOf[1]))
   })
   it('Normalize Intersect 3', () => {
     const T = Type.Intersect([Type.Object({ x: Type.String() }), Type.Object({ x: Type.String() })])
     const I = Type.Index(T, ['x'])
-    Assert.isEqual(TypeGuard.TOptional(I), false)
-    Assert.isEqual(TypeGuard.TIntersect(I), true)
-    Assert.isEqual(TypeGuard.TString(I.allOf[0]), true)
-    Assert.isEqual(TypeGuard.TString(I.allOf[1]), true)
+    Assert.IsFalse(TypeGuard.TOptional(I))
+    Assert.IsTrue(TypeGuard.TIntersect(I))
+    Assert.IsTrue(TypeGuard.TString(I.allOf[0]))
+    Assert.IsTrue(TypeGuard.TString(I.allOf[1]))
   })
   it('Normalize Intersect 4', () => {
     const T = Type.Intersect([Type.Object({ x: Type.String() })])
     const I = Type.Index(T, ['x'])
-    Assert.isEqual(TypeGuard.TString(I), true)
+    Assert.IsTrue(TypeGuard.TString(I))
   })
   it('Normalize Intersect 5', () => {
     const T = Type.Intersect([Type.Object({ x: Type.String() }), Type.Object({ y: Type.String() })])
     const I = Type.Index(T, ['x', 'y'])
-    Assert.isEqual(TypeGuard.TOptional(I), false)
-    Assert.isEqual(TypeGuard.TUnion(I), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
+    Assert.IsFalse(TypeGuard.TOptional(I))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
   })
   it('Normalize Intersect 6', () => {
     const T = Type.Recursive(() => Type.Intersect([Type.Object({ x: Type.String() }), Type.Object({ y: Type.String() })]))
     const I = Type.Index(T, ['x', 'y'])
-    Assert.isEqual(TypeGuard.TOptional(I), false)
-    Assert.isEqual(TypeGuard.TUnion(I), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
+    Assert.IsFalse(TypeGuard.TOptional(I))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
   })
   // ---------------------------------------------------------
   // Union
@@ -99,42 +99,42 @@ describe('type/normal/Index', () => {
   it('Normalize Union 1', () => {
     const T = Type.Union([Type.Object({ x: Type.Optional(Type.String()) }), Type.Object({ x: Type.Optional(Type.String()) })])
     const I = Type.Index(T, ['x'])
-    Assert.isEqual(TypeGuard.TOptional(I), true)
-    Assert.isEqual(TypeGuard.TUnion(I), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
+    Assert.IsTrue(TypeGuard.TOptional(I))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
   })
   it('Normalize Union 2', () => {
     const T = Type.Union([Type.Object({ x: Type.Optional(Type.String()) }), Type.Object({ x: Type.String() })])
     const I = Type.Index(T, ['x'])
-    Assert.isEqual(TypeGuard.TOptional(I), true)
-    Assert.isEqual(TypeGuard.TUnion(I), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
+    Assert.IsTrue(TypeGuard.TOptional(I))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
   })
   it('Normalize Union 3', () => {
     const T = Type.Union([Type.Object({ x: Type.String() }), Type.Object({ x: Type.String() })])
     const I = Type.Index(T, ['x'])
-    Assert.isEqual(TypeGuard.TOptional(I), false)
-    Assert.isEqual(TypeGuard.TUnion(I), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[0]), true)
-    Assert.isEqual(TypeGuard.TString(I.anyOf[1]), true)
+    Assert.IsFalse(TypeGuard.TOptional(I))
+    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
   })
   it('Normalize Union 4', () => {
     const T = Type.Union([Type.Object({ x: Type.String() })])
     const I = Type.Index(T, ['x'])
-    Assert.isEqual(TypeGuard.TString(I), true)
+    Assert.IsTrue(TypeGuard.TString(I))
   })
   it('Normalize Union 5', () => {
     const T = Type.Union([Type.Object({ x: Type.String() }), Type.Object({ y: Type.String() })])
     // @ts-ignore
     const I = Type.Index(T, ['x', 'y'])
-    Assert.isEqual(TypeGuard.TNever(I), false)
+    Assert.IsFalse(TypeGuard.TNever(I))
   })
   it('Normalize Union 6', () => {
     const T = Type.Recursive(() => Type.Union([Type.Object({ x: Type.String() }), Type.Object({ y: Type.String() })]))
     // @ts-ignore
     const I = Type.Index(T, ['x', 'y'])
-    Assert.isEqual(TypeGuard.TNever(I), false)
+    Assert.IsFalse(TypeGuard.TNever(I))
   })
 })
diff --git a/test/runtime/type/normalize/intersect.ts b/test/runtime/type/normalize/intersect.ts
index 3b712b5ea..3d449ad25 100644
--- a/test/runtime/type/normalize/intersect.ts
+++ b/test/runtime/type/normalize/intersect.ts
@@ -6,16 +6,16 @@ describe('type/normal/Intersect', () => {
   it('Normalize 1', () => {
     const T = Type.Intersect([Type.Number(), Type.String()])
     const R = TypeGuard.TIntersect(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Normalize 2', () => {
     const T = Type.Intersect([Type.Number()])
     const R = TypeGuard.TNumber(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Normalize 3', () => {
     const T = Type.Intersect([])
     const R = TypeGuard.TNever(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/normalize/record.ts b/test/runtime/type/normalize/record.ts
index 99b03383a..f7ad9334b 100644
--- a/test/runtime/type/normalize/record.ts
+++ b/test/runtime/type/normalize/record.ts
@@ -7,6 +7,6 @@ describe('type/normal/Record', () => {
     const K = Type.Union([Type.Literal('A'), Type.Literal('B')])
     const T = Type.Record(K, Type.String())
     const R = TypeGuard.TObject(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/normalize/union.ts b/test/runtime/type/normalize/union.ts
index aff9483fc..12e056fad 100644
--- a/test/runtime/type/normalize/union.ts
+++ b/test/runtime/type/normalize/union.ts
@@ -6,16 +6,16 @@ describe('type/normal/Union', () => {
   it('Normalize 1', () => {
     const T = Type.Union([Type.Number(), Type.String()])
     const R = TypeGuard.TUnion(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Normalize 2', () => {
     const T = Type.Union([Type.Number()])
     const R = TypeGuard.TNumber(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Normalize 3', () => {
     const T = Type.Union([])
     const R = TypeGuard.TNever(T)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/registry/format.ts b/test/runtime/type/registry/format.ts
index df2568182..ffa3d4c78 100644
--- a/test/runtime/type/registry/format.ts
+++ b/test/runtime/type/registry/format.ts
@@ -8,15 +8,15 @@ describe('type/FormatRegistry', () => {
   it('Should get format', () => {
     FormatRegistry.Set('test#format2', () => true)
     const format = FormatRegistry.Get('test#format2')
-    Assert.isEqual(typeof format, 'function')
+    Assert.IsEqual(typeof format, 'function')
   })
   it('Should return true if exists', () => {
     FormatRegistry.Set('test#format3', () => true)
-    Assert.isEqual(FormatRegistry.Has('test#format3'), true)
+    Assert.IsTrue(FormatRegistry.Has('test#format3'))
   })
   it('Should clear formats', () => {
     FormatRegistry.Set('test#format4', () => true)
     FormatRegistry.Clear()
-    Assert.isEqual(FormatRegistry.Has('test#format4'), false)
+    Assert.IsFalse(FormatRegistry.Has('test#format4'))
   })
 })
diff --git a/test/runtime/type/registry/type.ts b/test/runtime/type/registry/type.ts
index 0ad9a6613..60151ec9a 100644
--- a/test/runtime/type/registry/type.ts
+++ b/test/runtime/type/registry/type.ts
@@ -8,15 +8,15 @@ describe('type/TypeRegistry', () => {
   it('Should get type', () => {
     TypeRegistry.Set('test#type2', () => true)
     const format = TypeRegistry.Get('test#type2')
-    Assert.isEqual(typeof format, 'function')
+    Assert.IsEqual(typeof format, 'function')
   })
   it('Should return true if exists', () => {
     TypeRegistry.Set('test#type3', () => true)
-    Assert.isEqual(TypeRegistry.Has('test#type3'), true)
+    Assert.IsTrue(TypeRegistry.Has('test#type3'))
   })
   it('Should clear types', () => {
     TypeRegistry.Set('test#type4', () => true)
     TypeRegistry.Clear()
-    Assert.isEqual(TypeRegistry.Has('test#type4'), false)
+    Assert.IsFalse(TypeRegistry.Has('test#type4'))
   })
 })
diff --git a/test/runtime/type/template/finite.ts b/test/runtime/type/template/finite.ts
index 0941a39c2..0df00de7d 100644
--- a/test/runtime/type/template/finite.ts
+++ b/test/runtime/type/template/finite.ts
@@ -8,27 +8,27 @@ describe('type/TemplateLiteralFinite', () => {
   it('Finite 1', () => {
     const E = TemplateLiteralParser.Parse(`A`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Finite 2', () => {
     const E = TemplateLiteralParser.Parse(`A|B`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Finite 3', () => {
     const E = TemplateLiteralParser.Parse(`A(B|C)`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Finite 4', () => {
     const E = TemplateLiteralParser.Parse(`${PatternBoolean}`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Finite 5', () => {
     const E = TemplateLiteralParser.Parse(`\\.\\*`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   // ---------------------------------------------------------------
   // Infinite
@@ -36,36 +36,36 @@ describe('type/TemplateLiteralFinite', () => {
   it('Infinite 1', () => {
     const E = TemplateLiteralParser.Parse(`${PatternString}`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Infinite 2', () => {
     const E = TemplateLiteralParser.Parse(`${PatternNumber}`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Infinite 3', () => {
     const E = TemplateLiteralParser.Parse(`A|${PatternString}`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Infinite 4', () => {
     const E = TemplateLiteralParser.Parse(`A|${PatternNumber}`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Infinite 5', () => {
     const E = TemplateLiteralParser.Parse(`A(${PatternString})`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Infinite 6', () => {
     const E = TemplateLiteralParser.Parse(`A(${PatternNumber})`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Infinite 7', () => {
     const E = TemplateLiteralParser.Parse(`${PatternString}_foo`)
     const R = TemplateLiteralFinite.Check(E)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/template/generate.ts b/test/runtime/type/template/generate.ts
index 24ee76f25..eef3b8101 100644
--- a/test/runtime/type/template/generate.ts
+++ b/test/runtime/type/template/generate.ts
@@ -8,12 +8,12 @@ describe('type/TemplateLiteralGenerator', () => {
   it('Exact 1', () => {
     const E = TemplateLiteralParser.Parse('^$')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['^$'])
+    Assert.IsEqual(R, ['^$'])
   })
   it('Exact 2', () => {
     const E = TemplateLiteralParser.Parse('^A$')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['^A$'])
+    Assert.IsEqual(R, ['^A$'])
   })
   // ---------------------------------------------------------------
   // Patterns
@@ -21,17 +21,17 @@ describe('type/TemplateLiteralGenerator', () => {
   it('Pattern 1', () => {
     const E = TemplateLiteralParser.Parse('(true|false)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['true', 'false'])
+    Assert.IsEqual(R, ['true', 'false'])
   })
   it('Pattern 2', () => {
     const E = TemplateLiteralParser.Parse('(0|[1-9][0-9]*)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['0', '[1-9][0-9]*'])
+    Assert.IsEqual(R, ['0', '[1-9][0-9]*'])
   })
   it('Pattern 3', () => {
     const E = TemplateLiteralParser.Parse('.*')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['.*'])
+    Assert.IsEqual(R, ['.*'])
   })
   // ---------------------------------------------------------------
   // Expression
@@ -39,161 +39,161 @@ describe('type/TemplateLiteralGenerator', () => {
   it('Expression 1', () => {
     const E = TemplateLiteralParser.Parse(')')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, [')'])
+    Assert.IsEqual(R, [')'])
   })
   it('Expression 2', () => {
     const E = TemplateLiteralParser.Parse('\\)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['\\)'])
+    Assert.IsEqual(R, ['\\)'])
   })
   it('Expression 3', () => {
     const E = TemplateLiteralParser.Parse('\\(')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['\\('])
+    Assert.IsEqual(R, ['\\('])
   })
   it('Expression 4', () => {
     const E = TemplateLiteralParser.Parse('')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, [''])
+    Assert.IsEqual(R, [''])
   })
   it('Expression 5', () => {
     const E = TemplateLiteralParser.Parse('\\')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['\\'])
+    Assert.IsEqual(R, ['\\'])
   })
   it('Expression 6', () => {
     const E = TemplateLiteralParser.Parse('()')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, [''])
+    Assert.IsEqual(R, [''])
   })
   it('Expression 7', () => {
     const E = TemplateLiteralParser.Parse('(a)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['a'])
+    Assert.IsEqual(R, ['a'])
   })
   it('Expression 8', () => {
     const E = TemplateLiteralParser.Parse('()))')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['))'])
+    Assert.IsEqual(R, ['))'])
   })
   it('Expression 9', () => {
     const E = TemplateLiteralParser.Parse('())')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, [')'])
+    Assert.IsEqual(R, [')'])
   })
   it('Expression 10', () => {
     const E = TemplateLiteralParser.Parse('A|B')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['A', 'B'])
+    Assert.IsEqual(R, ['A', 'B'])
   })
   it('Expression 11', () => {
     const E = TemplateLiteralParser.Parse('A|(B)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['A', 'B'])
+    Assert.IsEqual(R, ['A', 'B'])
   })
   it('Expression 12', () => {
     const E = TemplateLiteralParser.Parse('A(B)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['AB'])
+    Assert.IsEqual(R, ['AB'])
   })
   it('Expression 13', () => {
     const E = TemplateLiteralParser.Parse('(A)B')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['AB'])
+    Assert.IsEqual(R, ['AB'])
   })
   it('Expression 14', () => {
     const E = TemplateLiteralParser.Parse('(A)|B')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['A', 'B'])
+    Assert.IsEqual(R, ['A', 'B'])
   })
   it('Expression 15', () => {
     const E = TemplateLiteralParser.Parse('|')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, [''])
+    Assert.IsEqual(R, [''])
   })
   it('Expression 16', () => {
     const E = TemplateLiteralParser.Parse('||')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, [''])
+    Assert.IsEqual(R, [''])
   })
   it('Expression 17', () => {
     const E = TemplateLiteralParser.Parse('||A')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['A'])
+    Assert.IsEqual(R, ['A'])
   })
   it('Expression 18', () => {
     const E = TemplateLiteralParser.Parse('A||')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['A'])
+    Assert.IsEqual(R, ['A'])
   })
   it('Expression 19', () => {
     const E = TemplateLiteralParser.Parse('A||B')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['A', 'B'])
+    Assert.IsEqual(R, ['A', 'B'])
   })
   it('Expression 20', () => {
     const E = TemplateLiteralParser.Parse('A|()|B')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['A', '', 'B'])
+    Assert.IsEqual(R, ['A', '', 'B'])
   })
   it('Expression 21', () => {
     const E = TemplateLiteralParser.Parse('A|(|)|B')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['A', '', 'B'])
+    Assert.IsEqual(R, ['A', '', 'B'])
   })
   it('Expression 22', () => {
     const E = TemplateLiteralParser.Parse('A|(||)|B')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['A', '', 'B'])
+    Assert.IsEqual(R, ['A', '', 'B'])
   })
   it('Expression 23', () => {
     const E = TemplateLiteralParser.Parse('|A(||)B|')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['AB'])
+    Assert.IsEqual(R, ['AB'])
   })
   it('Expression 24', () => {
     const E = TemplateLiteralParser.Parse('A(B)(C)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['ABC'])
+    Assert.IsEqual(R, ['ABC'])
   })
   it('Expression 25', () => {
     const E = TemplateLiteralParser.Parse('A(B)|(C)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['AB', 'C'])
+    Assert.IsEqual(R, ['AB', 'C'])
   })
   it('Expression 26', () => {
     const E = TemplateLiteralParser.Parse('A(B|C)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['AB', 'AC'])
+    Assert.IsEqual(R, ['AB', 'AC'])
   })
   it('Expression 27', () => {
     const E = TemplateLiteralParser.Parse('A|(B|C)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['A', 'B', 'C'])
+    Assert.IsEqual(R, ['A', 'B', 'C'])
   })
   it('Expression 28', () => {
     const E = TemplateLiteralParser.Parse('((A)B)C')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['ABC'])
+    Assert.IsEqual(R, ['ABC'])
   })
   it('Expression 29', () => {
     const E = TemplateLiteralParser.Parse('(0|1)(0|1)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['00', '01', '10', '11'])
+    Assert.IsEqual(R, ['00', '01', '10', '11'])
   })
   it('Expression 30', () => {
     const E = TemplateLiteralParser.Parse('(0|1)|(0|1)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['0', '1', '0', '1'])
+    Assert.IsEqual(R, ['0', '1', '0', '1'])
   })
   it('Expression 31', () => {
     const E = TemplateLiteralParser.Parse('(0|(1|0)|1)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['0', '1', '0', '1'])
+    Assert.IsEqual(R, ['0', '1', '0', '1'])
   })
   it('Expression 32', () => {
     const E = TemplateLiteralParser.Parse('(0(1|0)1)')
     const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.isEqual(R, ['011', '001'])
+    Assert.IsEqual(R, ['011', '001'])
   })
 })
diff --git a/test/runtime/type/template/parser.ts b/test/runtime/type/template/parser.ts
index 5c9654b78..1ed72176e 100644
--- a/test/runtime/type/template/parser.ts
+++ b/test/runtime/type/template/parser.ts
@@ -6,24 +6,24 @@ describe('type/TemplateLiteralParser', () => {
   // Throws
   // ---------------------------------------------------------------
   it('Throw 1', () => {
-    Assert.throws(() => TemplateLiteralParser.Parse('('))
+    Assert.Throws(() => TemplateLiteralParser.Parse('('))
   })
   it('Throw 2', () => {
-    Assert.throws(() => TemplateLiteralParser.Parse('('))
+    Assert.Throws(() => TemplateLiteralParser.Parse('('))
   })
   // ---------------------------------------------------------------
   // Exact (No Default Unwrap)
   // ---------------------------------------------------------------
   it('Exact 1', () => {
     const E = TemplateLiteralParser.Parse('^$')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'const',
       const: '^$',
     })
   })
   it('Exact 2', () => {
     const E = TemplateLiteralParser.Parse('^A$')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'const',
       const: '^A$',
     })
@@ -33,7 +33,7 @@ describe('type/TemplateLiteralParser', () => {
   // ---------------------------------------------------------------
   it('Pattern 1', () => {
     const E = TemplateLiteralParser.Parse('(true|false)')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'or',
       expr: [
         {
@@ -49,7 +49,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Pattern 2', () => {
     const E = TemplateLiteralParser.Parse('(0|[1-9][0-9]*)')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'or',
       expr: [
         {
@@ -65,7 +65,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Pattern 3', () => {
     const E = TemplateLiteralParser.Parse('.*')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'const',
       const: '.*',
     })
@@ -75,56 +75,56 @@ describe('type/TemplateLiteralParser', () => {
   // ---------------------------------------------------------------
   it('Expression 1', () => {
     const E = TemplateLiteralParser.Parse(')')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'const',
       const: ')',
     })
   })
   it('Expression 2', () => {
     const E = TemplateLiteralParser.Parse('\\)')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'const',
       const: '\\)',
     })
   })
   it('Expression 3', () => {
     const E = TemplateLiteralParser.Parse('\\(')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'const',
       const: '\\(',
     })
   })
   it('Expression 4', () => {
     const E = TemplateLiteralParser.Parse('')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'const',
       const: '',
     })
   })
   it('Expression 5', () => {
     const E = TemplateLiteralParser.Parse('\\')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'const',
       const: '\\',
     })
   })
   it('Expression 6', () => {
     const E = TemplateLiteralParser.Parse('()')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'const',
       const: '',
     })
   })
   it('Expression 7', () => {
     const E = TemplateLiteralParser.Parse('(a)')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'const',
       const: 'a',
     })
   })
   it('Expression 8', () => {
     const E = TemplateLiteralParser.Parse('()))')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'and',
       expr: [
         {
@@ -140,7 +140,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 9', () => {
     const E = TemplateLiteralParser.Parse('())')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'and',
       expr: [
         {
@@ -156,7 +156,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 10', () => {
     const E = TemplateLiteralParser.Parse('A|B')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'or',
       expr: [
         {
@@ -172,7 +172,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 11', () => {
     const E = TemplateLiteralParser.Parse('A|(B)')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'or',
       expr: [
         {
@@ -188,7 +188,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 12', () => {
     const E = TemplateLiteralParser.Parse('A(B)')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'and',
       expr: [
         {
@@ -204,7 +204,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 13', () => {
     const E = TemplateLiteralParser.Parse('(A)B')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'and',
       expr: [
         {
@@ -220,7 +220,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 14', () => {
     const E = TemplateLiteralParser.Parse('(A)|B')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'or',
       expr: [
         {
@@ -236,35 +236,35 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 15', () => {
     const E = TemplateLiteralParser.Parse('|')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'const',
       const: '',
     })
   })
   it('Expression 16', () => {
     const E = TemplateLiteralParser.Parse('||')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'const',
       const: '',
     })
   })
   it('Expression 17', () => {
     const E = TemplateLiteralParser.Parse('||A')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'const',
       const: 'A',
     })
   })
   it('Expression 18', () => {
     const E = TemplateLiteralParser.Parse('A||')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'const',
       const: 'A',
     })
   })
   it('Expression 19', () => {
     const E = TemplateLiteralParser.Parse('A||B')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'or',
       expr: [
         {
@@ -280,7 +280,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 20', () => {
     const E = TemplateLiteralParser.Parse('A|()|B')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'or',
       expr: [
         {
@@ -300,7 +300,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 21', () => {
     const E = TemplateLiteralParser.Parse('A|(|)|B')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'or',
       expr: [
         {
@@ -320,7 +320,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 22', () => {
     const E = TemplateLiteralParser.Parse('A|(||)|B')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'or',
       expr: [
         {
@@ -340,7 +340,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 23', () => {
     const E = TemplateLiteralParser.Parse('|A(||)B|')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'and',
       expr: [
         {
@@ -360,7 +360,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 24', () => {
     const E = TemplateLiteralParser.Parse('A(B)(C)')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'and',
       expr: [
         {
@@ -380,7 +380,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 25', () => {
     const E = TemplateLiteralParser.Parse('A(B)|(C)')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'or',
       expr: [
         {
@@ -405,7 +405,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 26', () => {
     const E = TemplateLiteralParser.Parse('A(B|C)')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'and',
       expr: [
         {
@@ -430,7 +430,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 27', () => {
     const E = TemplateLiteralParser.Parse('A|(B|C)')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'or',
       expr: [
         {
@@ -455,7 +455,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 28', () => {
     const E = TemplateLiteralParser.Parse('((A)B)C')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'and',
       expr: [
         {
@@ -480,7 +480,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 29', () => {
     const E = TemplateLiteralParser.Parse('(0|1)(0|1)')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'and',
       expr: [
         {
@@ -514,7 +514,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 30', () => {
     const E = TemplateLiteralParser.Parse('(0|1)|(0|1)')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'or',
       expr: [
         {
@@ -548,7 +548,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 31', () => {
     const E = TemplateLiteralParser.Parse('(0|(1|0)|1)')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'or',
       expr: [
         {
@@ -577,7 +577,7 @@ describe('type/TemplateLiteralParser', () => {
   })
   it('Expression 32', () => {
     const E = TemplateLiteralParser.Parse('(0(1|0)1)')
-    Assert.isEqual(E, {
+    Assert.IsEqual(E, {
       type: 'and',
       expr: [
         {
diff --git a/test/runtime/type/template/pattern.ts b/test/runtime/type/template/pattern.ts
index b87143069..68d30330a 100644
--- a/test/runtime/type/template/pattern.ts
+++ b/test/runtime/type/template/pattern.ts
@@ -4,26 +4,26 @@ import { Assert } from '../../assert/index'
 describe('type/TemplateLiteralPattern', () => {
   const Equal = (template: TTemplateLiteral, expect: string) => {
     const pattern = template.pattern.slice(1, template.pattern.length - 1)
-    Assert.isEqual(pattern, expect)
+    Assert.IsEqual(pattern, expect)
   }
   // ---------------------------------------------------------------
   // Escape
   // ---------------------------------------------------------------
   it('Escape 1', () => {
     const T = Type.TemplateLiteral([Type.Literal('.*')])
-    Assert.isEqual(T.pattern, '^\\.\\*$')
+    Assert.IsEqual(T.pattern, '^\\.\\*$')
   })
   it('Escape 2', () => {
     const T = Type.TemplateLiteral([Type.Literal('(')])
-    Assert.isEqual(T.pattern, '^\\($')
+    Assert.IsEqual(T.pattern, '^\\($')
   })
   it('Escape 3', () => {
     const T = Type.TemplateLiteral([Type.Literal(')')])
-    Assert.isEqual(T.pattern, '^\\)$')
+    Assert.IsEqual(T.pattern, '^\\)$')
   })
   it('Escape 4', () => {
     const T = Type.TemplateLiteral([Type.Literal('|')])
-    Assert.isEqual(T.pattern, '^\\|$')
+    Assert.IsEqual(T.pattern, '^\\|$')
   })
   // ---------------------------------------------------------------
   // Pattern
diff --git a/test/runtime/type/value/guard.ts b/test/runtime/type/value/guard.ts
new file mode 100644
index 000000000..51652350b
--- /dev/null
+++ b/test/runtime/type/value/guard.ts
@@ -0,0 +1,109 @@
+import { Assert } from '../../assert/index'
+import { ValueGuard } from '@sinclair/typebox'
+
+describe('type/ValueGuard', () => {
+  // -----------------------------------------------------
+  // IsNull
+  // -----------------------------------------------------
+  it('Should guard null 1', () => {
+    const R = ValueGuard.IsNull(null)
+    Assert.IsTrue(R)
+  })
+  it('Should guard null 2', () => {
+    const R = ValueGuard.IsNull({})
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsUndefined
+  // -----------------------------------------------------
+  it('Should guard undefined 1', () => {
+    const R = ValueGuard.IsUndefined(undefined)
+    Assert.IsTrue(R)
+  })
+  it('Should guard undefined 2', () => {
+    const R = ValueGuard.IsUndefined({})
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsBigInt
+  // -----------------------------------------------------
+  it('Should guard bigint 1', () => {
+    const R = ValueGuard.IsBigInt(1n)
+    Assert.IsTrue(R)
+  })
+  it('Should guard bigint 2', () => {
+    const R = ValueGuard.IsBigInt(1)
+    Assert.IsFalse(R)
+  })
+  it('Should guard bigint 3', () => {
+    const R = ValueGuard.IsBigInt('123')
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsNumber
+  // -----------------------------------------------------
+  it('Should guard number 1', () => {
+    const R = ValueGuard.IsNumber(1)
+    Assert.IsTrue(R)
+  })
+  it('Should guard number 2', () => {
+    const R = ValueGuard.IsNumber(3.14)
+    Assert.IsTrue(R)
+  })
+  it('Should guard number 3', () => {
+    const R = ValueGuard.IsNumber('')
+    Assert.IsFalse(R)
+  })
+  it('Should guard number 4', () => {
+    const R = ValueGuard.IsNumber(NaN)
+    Assert.IsTrue(R)
+  })
+  // -----------------------------------------------------
+  // IsString
+  // -----------------------------------------------------
+  it('Should guard string 1', () => {
+    const R = ValueGuard.IsString('')
+    Assert.IsTrue(R)
+  })
+  it('Should guard string 2', () => {
+    const R = ValueGuard.IsString(true)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsBoolean
+  // -----------------------------------------------------
+  it('Should guard boolean 1', () => {
+    const R = ValueGuard.IsBoolean(true)
+    Assert.IsTrue(R)
+  })
+  it('Should guard boolean 2', () => {
+    const R = ValueGuard.IsBoolean(1)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsObject
+  // -----------------------------------------------------
+  it('Should guard object 1', () => {
+    const R = ValueGuard.IsObject({})
+    Assert.IsTrue(R)
+  })
+  it('Should guard object 2', () => {
+    const R = ValueGuard.IsObject(1)
+    Assert.IsFalse(R)
+  })
+  it('Should guard object 3', () => {
+    const R = ValueGuard.IsObject([])
+    Assert.IsTrue(R)
+  })
+  // -----------------------------------------------------
+  // IsArray
+  // -----------------------------------------------------
+  it('Should guard array 1', () => {
+    const R = ValueGuard.IsArray([])
+    Assert.IsTrue(R)
+  })
+  it('Should guard array 2', () => {
+    const R = ValueGuard.IsArray({})
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/value/index.ts b/test/runtime/type/value/index.ts
new file mode 100644
index 000000000..4f2ca894f
--- /dev/null
+++ b/test/runtime/type/value/index.ts
@@ -0,0 +1 @@
+import './guard'
diff --git a/test/runtime/value/cast/any.ts b/test/runtime/value/cast/any.ts
index b5beef61a..832caf5f6 100644
--- a/test/runtime/value/cast/any.ts
+++ b/test/runtime/value/cast/any.ts
@@ -7,46 +7,46 @@ describe('value/cast/Any', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from boolean', () => {
     const value = false
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result.getTime(100), 100)
+    Assert.IsEqual(result.getTime(100), 100)
   })
   it('Should preserve', () => {
     const value = { a: 1, b: 2 }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, { a: 1, b: 2 })
+    Assert.IsEqual(result, { a: 1, b: 2 })
   })
 })
diff --git a/test/runtime/value/cast/array.ts b/test/runtime/value/cast/array.ts
index 904c51811..83ad7f6c7 100644
--- a/test/runtime/value/cast/array.ts
+++ b/test/runtime/value/cast/array.ts
@@ -8,91 +8,91 @@ describe('value/cast/Array', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, [1])
+    Assert.IsEqual(result, [1])
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preserve', () => {
     const value = [6, 7, 8]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, [6, 7, 8])
+    Assert.IsEqual(result, [6, 7, 8])
   })
   it('Should preserve with invalid element set to default', () => {
     const value = [6, 7, 8, 'hello', 9]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, [6, 7, 8, 0, 9])
+    Assert.IsEqual(result, [6, 7, 8, 0, 9])
   })
   // -----------------------------------------------------------------
   // Constraints: Ranges
   // -----------------------------------------------------------------
   it('Should cast array and truncate to maxItems from value', () => {
     const result = Value.Cast(Type.Array(Type.Number(), { maxItems: 3 }), [0, 1, 2, 4, 5, 6])
-    Assert.isEqual(result, [0, 1, 2])
+    Assert.IsEqual(result, [0, 1, 2])
   })
   it('Should cast arrays and append array to minItems from value', () => {
     const result = Value.Cast(Type.Array(Type.Number(), { minItems: 6 }), [0, 1, 2])
-    Assert.isEqual(result, [0, 1, 2, 0, 0, 0])
+    Assert.IsEqual(result, [0, 1, 2, 0, 0, 0])
   })
   it('Should cast array and truncate to maxItems from default value', () => {
     const result = Value.Cast(Type.Array(Type.Number(), { maxItems: 3, default: [0, 1, 2, 4, 5, 6] }), null)
-    Assert.isEqual(result, [0, 1, 2])
+    Assert.IsEqual(result, [0, 1, 2])
   })
   it('Should cast arrays and append array to minItems from default value', () => {
     const result = Value.Cast(Type.Array(Type.Number({ default: 1 }), { minItems: 6, default: [0, 1, 2] }), null)
-    Assert.isEqual(result, [0, 1, 2, 1, 1, 1])
+    Assert.IsEqual(result, [0, 1, 2, 1, 1, 1])
   })
   // -----------------------------------------------------------------
   // Constraints: Unique
   // -----------------------------------------------------------------
   it('Should cast arrays with uniqueItems with unique default value', () => {
     const result = Value.Cast(Type.Array(Type.Number(), { uniqueItems: true, default: [0, 1, 2] }), null)
-    Assert.isEqual(result, [0, 1, 2])
+    Assert.IsEqual(result, [0, 1, 2])
   })
   it('Should cast arrays with uniqueItems with unique value', () => {
     const result = Value.Cast(Type.Array(Type.Number(), { uniqueItems: true }), [0, 1, 2])
-    Assert.isEqual(result, [0, 1, 2])
+    Assert.IsEqual(result, [0, 1, 2])
   })
   it('Should throw when casting arrays with uniqueItems and no value or default value', () => {
-    Assert.throws(() => Value.Cast(Type.Array(Type.Number(), { uniqueItems: true }), null))
+    Assert.Throws(() => Value.Cast(Type.Array(Type.Number(), { uniqueItems: true }), null))
   })
   it('Should throw when casting arrays with uniqueItems and not enough values to populate set', () => {
-    Assert.throws(() => Value.Cast(Type.Array(Type.Number(), { minItems: 3, uniqueItems: true }), [0, 1]))
+    Assert.Throws(() => Value.Cast(Type.Array(Type.Number(), { minItems: 3, uniqueItems: true }), [0, 1]))
   })
   it('Should throw when casting arrays with uniqueItems and not enough default values to populate set', () => {
-    Assert.throws(() => Value.Cast(Type.Array(Type.Number(), { minItems: 3, uniqueItems: true, default: [0, 1] }), null))
+    Assert.Throws(() => Value.Cast(Type.Array(Type.Number(), { minItems: 3, uniqueItems: true, default: [0, 1] }), null))
   })
   // -----------------------------------------------------------------
   // Suggestion: https://github.com/sinclairzx81/typebox/issues/239
@@ -101,18 +101,18 @@ describe('value/cast/Array', () => {
     const T = Type.Array(Type.Number(), { uniqueItems: true })
     const value = [1, 1, 2, 2]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, [1, 2])
+    Assert.IsEqual(result, [1, 2])
   })
   it('Should should fill up with defaults to minItems', () => {
     const T = Type.Array(Type.Number(), { minItems: 3 })
     const value = [1, 2]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, [1, 2, 0])
+    Assert.IsEqual(result, [1, 2, 0])
   })
   it('Should should truncate to maxItems', () => {
     const T = Type.Array(Type.Number(), { maxItems: 3 })
     const value = [1, 2, 3, 4]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, [1, 2, 3])
+    Assert.IsEqual(result, [1, 2, 3])
   })
 })
diff --git a/test/runtime/value/cast/async-iterator.ts b/test/runtime/value/cast/async-iterator.ts
new file mode 100644
index 000000000..ac27c0971
--- /dev/null
+++ b/test/runtime/value/cast/async-iterator.ts
@@ -0,0 +1,37 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/AsyncIterator', () => {
+  const T = Type.AsyncIterator(Type.Any())
+  it('Should upcast from string', () => {
+    const value = 'world'
+    const result = Value.Cast(T, value)
+    Assert.IsTrue(Symbol.asyncIterator in result)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.IsTrue(Symbol.asyncIterator in result)
+  })
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.IsTrue(Symbol.asyncIterator in result)
+  })
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.IsTrue(Symbol.asyncIterator in result)
+  })
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.IsTrue(Symbol.asyncIterator in result)
+  })
+  it('Should preseve', () => {
+    const value = (async function* () {})()
+    const result = Value.Cast(T, value)
+    Assert.IsTrue(value === result)
+  })
+})
diff --git a/test/runtime/value/cast/bigint.ts b/test/runtime/value/cast/bigint.ts
index 57589c93e..873fa73db 100644
--- a/test/runtime/value/cast/bigint.ts
+++ b/test/runtime/value/cast/bigint.ts
@@ -8,46 +8,46 @@ describe('value/cast/BigInt', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 0
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preserve', () => {
     const value = BigInt(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, BigInt(100))
+    Assert.IsEqual(result, BigInt(100))
   })
 })
diff --git a/test/runtime/value/cast/boolean.ts b/test/runtime/value/cast/boolean.ts
index 6c14b5603..cbb976134 100644
--- a/test/runtime/value/cast/boolean.ts
+++ b/test/runtime/value/cast/boolean.ts
@@ -8,46 +8,46 @@ describe('value/cast/Boolean', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 0
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preserve', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
 })
diff --git a/test/runtime/value/cast/composite.ts b/test/runtime/value/cast/composite.ts
index 8be304b8e..1db6d804e 100644
--- a/test/runtime/value/cast/composite.ts
+++ b/test/runtime/value/cast/composite.ts
@@ -25,47 +25,47 @@ describe('value/cast/Composite', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = E
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast and preserve object', () => {
     const value = { x: 7, y: 8, z: 9 }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, {
+    Assert.IsEqual(result, {
       x: 7,
       y: 8,
       z: 9,
@@ -77,7 +77,7 @@ describe('value/cast/Composite', () => {
   it('Should upcast and preserve from incorrect properties', () => {
     const value = { x: {}, y: 8, z: 9 }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, {
+    Assert.IsEqual(result, {
       x: 0,
       y: 8,
       z: 9,
diff --git a/test/runtime/value/cast/custom.ts b/test/runtime/value/cast/custom.ts
index e29b21a7d..3bfb8959f 100644
--- a/test/runtime/value/cast/custom.ts
+++ b/test/runtime/value/cast/custom.ts
@@ -14,37 +14,37 @@ describe('value/cast/Custom', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = false
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preserve', () => {
     const value = { a: 'hello', b: 'world' }
@@ -55,6 +55,6 @@ describe('value/cast/Custom', () => {
       }),
       value,
     )
-    Assert.isEqual(result, { a: 'hello', b: 'world' })
+    Assert.IsEqual(result, { a: 'hello', b: 'world' })
   })
 })
diff --git a/test/runtime/value/cast/date.ts b/test/runtime/value/cast/date.ts
index ec681d908..4e6fc6016 100644
--- a/test/runtime/value/cast/date.ts
+++ b/test/runtime/value/cast/date.ts
@@ -8,31 +8,31 @@ describe('value/cast/Date', () => {
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preseve', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result.getTime(), 100)
+    Assert.IsEqual(result.getTime(), 100)
   })
 })
diff --git a/test/runtime/value/cast/enum.ts b/test/runtime/value/cast/enum.ts
index 1b0d1d12b..0013e8119 100644
--- a/test/runtime/value/cast/enum.ts
+++ b/test/runtime/value/cast/enum.ts
@@ -12,51 +12,51 @@ describe('value/cast/Boolean', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 123
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from enum A', () => {
     const value = Foo.A
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, Foo.A)
+    Assert.IsEqual(result, Foo.A)
   })
   it('Should upcast from enum B', () => {
     const value = Foo.B
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, Foo.B)
+    Assert.IsEqual(result, Foo.B)
   })
 })
diff --git a/test/runtime/value/cast/index.ts b/test/runtime/value/cast/index.ts
index 8db2c8711..be2225807 100644
--- a/test/runtime/value/cast/index.ts
+++ b/test/runtime/value/cast/index.ts
@@ -1,5 +1,6 @@
 import './any'
 import './array'
+import './async-iterator'
 import './bigint'
 import './boolean'
 import './composite'
@@ -8,6 +9,7 @@ import './date'
 import './enum'
 import './integer'
 import './intersect'
+import './iterator'
 import './keyof'
 import './literal'
 import './never'
@@ -17,7 +19,7 @@ import './number'
 import './object'
 import './recursive'
 import './record'
-import './regex'
+import './regexp'
 import './string'
 import './symbol'
 import './template-literal'
diff --git a/test/runtime/value/cast/integer.ts b/test/runtime/value/cast/integer.ts
index 534913a83..3a5b375c1 100644
--- a/test/runtime/value/cast/integer.ts
+++ b/test/runtime/value/cast/integer.ts
@@ -8,36 +8,36 @@ describe('value/cast/Integer', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, 1)
+    Assert.IsEqual(result, 1)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
 })
diff --git a/test/runtime/value/cast/intersect.ts b/test/runtime/value/cast/intersect.ts
index 596ecb2da..82044975f 100644
--- a/test/runtime/value/cast/intersect.ts
+++ b/test/runtime/value/cast/intersect.ts
@@ -10,7 +10,7 @@ describe('value/cast/Intersect', () => {
       Type.Object({ y: Type.Number() })
     ])
     const V = Value.Cast(T, 1)
-    Assert.isEqual(V, { x: 0, y: 0 })
+    Assert.IsEqual(V, { x: 0, y: 0 })
   })
   it('Should cast from an partial object and preserve', () => {
     // prettier-ignore
@@ -19,7 +19,7 @@ describe('value/cast/Intersect', () => {
       Type.Object({ y: Type.Number() })
     ])
     const V = Value.Cast(T, { x: 1 })
-    Assert.isEqual(V, { x: 1, y: 0 })
+    Assert.IsEqual(V, { x: 1, y: 0 })
   })
   it('Should cast and use default values', () => {
     // prettier-ignore
@@ -28,7 +28,7 @@ describe('value/cast/Intersect', () => {
       Type.Object({ y: Type.Number({ default: 42 }) })
     ])
     const V = Value.Cast(T, { x: 1 })
-    Assert.isEqual(V, { x: 1, y: 42 })
+    Assert.IsEqual(V, { x: 1, y: 42 })
   })
   it('Should throw with an illogical intersect', () => {
     // prettier-ignore
@@ -36,7 +36,7 @@ describe('value/cast/Intersect', () => {
       Type.Object({ x: Type.Number() }), 
       Type.Object({ x: Type.String() })
     ])
-    Assert.throws(() => Value.Cast(T, { x: 1 }))
+    Assert.Throws(() => Value.Cast(T, { x: 1 }))
   })
   it('Should throw with an illogical intersect (primative)', () => {
     // prettier-ignore
@@ -44,7 +44,7 @@ describe('value/cast/Intersect', () => {
       Type.Number(), 
       Type.String()
     ])
-    Assert.throws(() => Value.Cast(T, { x: 1 }))
+    Assert.Throws(() => Value.Cast(T, { x: 1 }))
   })
   it('Should use last intersected default for equivalent sub schemas', () => {
     // prettier-ignore
@@ -53,7 +53,7 @@ describe('value/cast/Intersect', () => {
       Type.Object({ x: Type.Number({ default: 1000 }) })
     ])
     const V = Value.Cast(T, null)
-    Assert.isEqual(V, { x: 1000 })
+    Assert.IsEqual(V, { x: 1000 })
   })
   it('Should use last intersected default for equivalent sub schemas (primitives)', () => {
     // prettier-ignore
@@ -62,7 +62,7 @@ describe('value/cast/Intersect', () => {
       Type.Number({ default: 1000 })
     ])
     const V = Value.Cast(T, null)
-    Assert.isEqual(V, 1000)
+    Assert.IsEqual(V, 1000)
   })
   it('Should preserve if default is specified', () => {
     // prettier-ignore
@@ -71,6 +71,6 @@ describe('value/cast/Intersect', () => {
       Type.Number({ default: 1000 })
     ])
     const V = Value.Cast(T, 2000)
-    Assert.isEqual(V, 2000)
+    Assert.IsEqual(V, 2000)
   })
 })
diff --git a/test/runtime/value/cast/iterator.ts b/test/runtime/value/cast/iterator.ts
new file mode 100644
index 000000000..14863180c
--- /dev/null
+++ b/test/runtime/value/cast/iterator.ts
@@ -0,0 +1,37 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Iterator', () => {
+  const T = Type.Iterator(Type.Any())
+  it('Should upcast from string', () => {
+    const value = 'world'
+    const result = Value.Cast(T, value)
+    Assert.IsTrue(Symbol.iterator in result)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.IsTrue(Symbol.iterator in result)
+  })
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.IsTrue(Symbol.iterator in result)
+  })
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.IsTrue(Symbol.iterator in result)
+  })
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.IsTrue(Symbol.iterator in result)
+  })
+  it('Should preseve', () => {
+    const value = (function* () {})()
+    const result = Value.Cast(T, value)
+    Assert.IsTrue(value === result)
+  })
+})
diff --git a/test/runtime/value/cast/keyof.ts b/test/runtime/value/cast/keyof.ts
index 81cd828d3..d0f41daf7 100644
--- a/test/runtime/value/cast/keyof.ts
+++ b/test/runtime/value/cast/keyof.ts
@@ -14,46 +14,46 @@ describe('value/cast/KeyOf', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preserve', () => {
     const value = 'y'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, 'y')
+    Assert.IsEqual(result, 'y')
   })
 })
diff --git a/test/runtime/value/cast/literal.ts b/test/runtime/value/cast/literal.ts
index 71ca7dff8..59b356908 100644
--- a/test/runtime/value/cast/literal.ts
+++ b/test/runtime/value/cast/literal.ts
@@ -8,46 +8,46 @@ describe('value/cast/Literal', () => {
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preseve', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, 'hello')
+    Assert.IsEqual(result, 'hello')
   })
 })
diff --git a/test/runtime/value/cast/never.ts b/test/runtime/value/cast/never.ts
index c493f32f2..eeb782ed8 100644
--- a/test/runtime/value/cast/never.ts
+++ b/test/runtime/value/cast/never.ts
@@ -6,34 +6,34 @@ describe('value/cast/Never', () => {
   const T = Type.Never()
   it('Should throw from string', () => {
     const value = 'hello'
-    Assert.throws(() => Value.Cast(T, value))
+    Assert.Throws(() => Value.Cast(T, value))
   })
   it('Should throw from number', () => {
     const value = 1
-    Assert.throws(() => Value.Cast(T, value))
+    Assert.Throws(() => Value.Cast(T, value))
   })
   it('Should throw from boolean', () => {
     const value = false
-    Assert.throws(() => Value.Cast(T, value))
+    Assert.Throws(() => Value.Cast(T, value))
   })
   it('Should throw from object', () => {
     const value = {}
-    Assert.throws(() => Value.Cast(T, value))
+    Assert.Throws(() => Value.Cast(T, value))
   })
   it('Should throw from array', () => {
     const value = [1]
-    Assert.throws(() => Value.Cast(T, value))
+    Assert.Throws(() => Value.Cast(T, value))
   })
   it('Should throw from undefined', () => {
     const value = undefined
-    Assert.throws(() => Value.Cast(T, value))
+    Assert.Throws(() => Value.Cast(T, value))
   })
   it('Should throw from null', () => {
     const value = null
-    Assert.throws(() => Value.Cast(T, value))
+    Assert.Throws(() => Value.Cast(T, value))
   })
   it('Should upcast from date', () => {
     const value = null
-    Assert.throws(() => Value.Cast(T, value))
+    Assert.Throws(() => Value.Cast(T, value))
   })
 })
diff --git a/test/runtime/value/cast/not.ts b/test/runtime/value/cast/not.ts
index e0713d473..d5802e646 100644
--- a/test/runtime/value/cast/not.ts
+++ b/test/runtime/value/cast/not.ts
@@ -7,46 +7,46 @@ describe('value/cast/Not', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, 0) // default
+    Assert.IsEqual(result, 0) // default
   })
   it('Should upcast from number', () => {
     const value = 0
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should preserve', () => {
     const value = 100
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, 100)
+    Assert.IsEqual(result, 100)
   })
 })
diff --git a/test/runtime/value/cast/null.ts b/test/runtime/value/cast/null.ts
index b4d019bd4..de1d5a737 100644
--- a/test/runtime/value/cast/null.ts
+++ b/test/runtime/value/cast/null.ts
@@ -8,46 +8,46 @@ describe('value/cast/Null', () => {
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preseve', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, null)
+    Assert.IsEqual(result, null)
   })
 })
diff --git a/test/runtime/value/cast/number.ts b/test/runtime/value/cast/number.ts
index 66d999c91..882ad6474 100644
--- a/test/runtime/value/cast/number.ts
+++ b/test/runtime/value/cast/number.ts
@@ -8,41 +8,41 @@ describe('value/cast/Number', () => {
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, 1)
+    Assert.IsEqual(result, 1)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preseve', () => {
     const value = 123
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, 123)
+    Assert.IsEqual(result, 123)
   })
 })
diff --git a/test/runtime/value/cast/object.ts b/test/runtime/value/cast/object.ts
index 3fa460100..56a0668de 100644
--- a/test/runtime/value/cast/object.ts
+++ b/test/runtime/value/cast/object.ts
@@ -22,47 +22,47 @@ describe('value/cast/Object', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = E
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preserve', () => {
     const value = { x: 7, y: 8, z: 9, a: 10, b: 11, c: 12 }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, {
+    Assert.IsEqual(result, {
       x: 7,
       y: 8,
       z: 9,
@@ -74,7 +74,7 @@ describe('value/cast/Object', () => {
   it('Should upcast and preserve partial object', () => {
     const value = { x: 7, y: 8, z: 9 }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, {
+    Assert.IsEqual(result, {
       x: 7,
       y: 8,
       z: 9,
@@ -86,7 +86,7 @@ describe('value/cast/Object', () => {
   it('Should upcast and preserve partial object with incorrect properties', () => {
     const value = { x: {}, y: 8, z: 9 }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, {
+    Assert.IsEqual(result, {
       x: 0,
       y: 8,
       z: 9,
@@ -98,7 +98,7 @@ describe('value/cast/Object', () => {
   it('Should upcast and preserve partial object and omit unknown properties', () => {
     const value = { x: 7, y: 8, z: 9, unknown: 'foo' }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, {
+    Assert.IsEqual(result, {
       x: 7,
       y: 8,
       z: 9,
@@ -127,7 +127,7 @@ describe('value/cast/Object', () => {
         z: true,
       },
     )
-    Assert.isEqual(result, {
+    Assert.IsEqual(result, {
       x: 1,
       y: 2,
       z: { a: 0, b: 0 },
@@ -153,7 +153,7 @@ describe('value/cast/Object', () => {
         z: { b: 1 },
       },
     )
-    Assert.isEqual(result, {
+    Assert.IsEqual(result, {
       x: 1,
       y: 2,
       z: { a: 0, b: 1 },
diff --git a/test/runtime/value/cast/record.ts b/test/runtime/value/cast/record.ts
index 1ef6828af..fa6ea9d72 100644
--- a/test/runtime/value/cast/record.ts
+++ b/test/runtime/value/cast/record.ts
@@ -12,46 +12,45 @@ describe('value/cast/Record', () => {
     }),
   )
   const E = {}
-
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = E
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preserve', () => {
     const value = {
@@ -59,7 +58,7 @@ describe('value/cast/Record', () => {
       b: { x: 4, y: 5, z: 6 },
     }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should preserve and patch invalid records', () => {
     const value = {
@@ -70,7 +69,7 @@ describe('value/cast/Record', () => {
       e: { x: 1, y: 2, w: 9000 },
     }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, {
+    Assert.IsEqual(result, {
       a: { x: 1, y: 2, z: 3 },
       b: { x: 4, y: 5, z: 0 },
       c: { x: 0, y: 0, z: 0 },
diff --git a/test/runtime/value/cast/recursive.ts b/test/runtime/value/cast/recursive.ts
index cf4316ba4..cb2616043 100644
--- a/test/runtime/value/cast/recursive.ts
+++ b/test/runtime/value/cast/recursive.ts
@@ -13,42 +13,42 @@ describe('value/cast/Recursive', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = E
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preserve', () => {
     const value = {
@@ -60,7 +60,7 @@ describe('value/cast/Recursive', () => {
       ],
     }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from varying types', () => {
     const TypeA = Type.Recursive((This) =>
diff --git a/test/runtime/value/cast/regex.ts b/test/runtime/value/cast/regexp.ts
similarity index 78%
rename from test/runtime/value/cast/regex.ts
rename to test/runtime/value/cast/regexp.ts
index d23bef49c..4bfc94c62 100644
--- a/test/runtime/value/cast/regex.ts
+++ b/test/runtime/value/cast/regexp.ts
@@ -3,51 +3,51 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/cast/RegEx', () => {
-  const T = Type.RegEx(/foo/, { default: 'foo' })
+  const T = Type.RegExp(/foo/, { default: 'foo' })
   const E = 'foo'
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, 'foo')
+    Assert.IsEqual(result, 'foo')
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preserve', () => {
     const value = 'foo'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
 })
diff --git a/test/runtime/value/cast/string.ts b/test/runtime/value/cast/string.ts
index ff8f5c11d..24d3fd6ab 100644
--- a/test/runtime/value/cast/string.ts
+++ b/test/runtime/value/cast/string.ts
@@ -8,36 +8,36 @@ describe('value/cast/String', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, 'hello')
+    Assert.IsEqual(result, 'hello')
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preserve', () => {
     const value = 'foo'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
 })
diff --git a/test/runtime/value/cast/symbol.ts b/test/runtime/value/cast/symbol.ts
index 05fd88049..18598e809 100644
--- a/test/runtime/value/cast/symbol.ts
+++ b/test/runtime/value/cast/symbol.ts
@@ -7,46 +7,46 @@ describe('value/cast/Symbol', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isTypeOf(result, 'symbol')
+    Assert.IsTypeOf(result, 'symbol')
   })
   it('Should upcast from number', () => {
     const value = 0
     const result = Value.Cast(T, value)
-    Assert.isTypeOf(result, 'symbol')
+    Assert.IsTypeOf(result, 'symbol')
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isTypeOf(result, 'symbol')
+    Assert.IsTypeOf(result, 'symbol')
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isTypeOf(result, 'symbol')
+    Assert.IsTypeOf(result, 'symbol')
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isTypeOf(result, 'symbol')
+    Assert.IsTypeOf(result, 'symbol')
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isTypeOf(result, 'symbol')
+    Assert.IsTypeOf(result, 'symbol')
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isTypeOf(result, 'symbol')
+    Assert.IsTypeOf(result, 'symbol')
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isTypeOf(result, 'symbol')
+    Assert.IsTypeOf(result, 'symbol')
   })
   it('Should preserve', () => {
     const value = Symbol('hello')
     const result = Value.Cast(T, value)
-    Assert.isEqual(result.description, value.description)
+    Assert.IsEqual(result.description, value.description)
   })
 })
diff --git a/test/runtime/value/cast/template-literal.ts b/test/runtime/value/cast/template-literal.ts
index 322928ba5..dc199e17a 100644
--- a/test/runtime/value/cast/template-literal.ts
+++ b/test/runtime/value/cast/template-literal.ts
@@ -8,46 +8,46 @@ describe('value/cast/TemplateLiteral', () => {
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preseve', () => {
     const value = 'helloworld'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, 'helloworld')
+    Assert.IsEqual(result, 'helloworld')
   })
 })
diff --git a/test/runtime/value/cast/tuple.ts b/test/runtime/value/cast/tuple.ts
index cb805cf6e..8d30bbed5 100644
--- a/test/runtime/value/cast/tuple.ts
+++ b/test/runtime/value/cast/tuple.ts
@@ -8,66 +8,66 @@ describe('value/cast/Tuple', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, [1, ''])
+    Assert.IsEqual(result, [1, ''])
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preserve', () => {
     const value = [42, 'world']
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast with empty', () => {
     const value = [] as any[]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should append with less than tuple length', () => {
     const value = [42]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, [42, ''])
+    Assert.IsEqual(result, [42, ''])
   })
   it('Should truncate with greater than tuple length', () => {
     const value = [42, '', true]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, [42, ''])
+    Assert.IsEqual(result, [42, ''])
   })
   it('Should preserve and patch invalid element', () => {
     const value = [{}, 'hello']
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, [0, 'hello'])
+    Assert.IsEqual(result, [0, 'hello'])
   })
 })
diff --git a/test/runtime/value/cast/uint8array.ts b/test/runtime/value/cast/uint8array.ts
index 4adf0eb44..6678cc715 100644
--- a/test/runtime/value/cast/uint8array.ts
+++ b/test/runtime/value/cast/uint8array.ts
@@ -8,46 +8,46 @@ describe('value/cast/Uint8Array', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preserve', () => {
     const value = new Uint8Array([6, 7, 8, 9, 10])
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
 })
diff --git a/test/runtime/value/cast/undefined.ts b/test/runtime/value/cast/undefined.ts
index 9821ee947..8bb23a4fe 100644
--- a/test/runtime/value/cast/undefined.ts
+++ b/test/runtime/value/cast/undefined.ts
@@ -8,46 +8,46 @@ describe('value/cast/Undefined', () => {
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preseve', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, undefined)
+    Assert.IsEqual(result, undefined)
   })
 })
diff --git a/test/runtime/value/cast/union.ts b/test/runtime/value/cast/union.ts
index 4ca73b41e..33d77b41d 100644
--- a/test/runtime/value/cast/union.ts
+++ b/test/runtime/value/cast/union.ts
@@ -28,91 +28,90 @@ describe('value/cast/Union', () => {
     y: 0,
     z: 0,
   }
-
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preserve A', () => {
     const value = { type: 'A', x: 1, y: 2, z: 3 }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should preserve B', () => {
     const value = { type: 'B', a: 'a', b: 'b', c: 'c' }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should infer through heuristics #1', () => {
     const value = { type: 'A', a: 'a', b: 'b', c: 'c' }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, { type: 'A', x: 0, y: 0, z: 0 })
+    Assert.IsEqual(result, { type: 'A', x: 0, y: 0, z: 0 })
   })
   it('Should infer through heuristics #2', () => {
     const value = { type: 'B', x: 1, y: 2, z: 3 }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, { type: 'B', a: '', b: '', c: '' })
+    Assert.IsEqual(result, { type: 'B', a: '', b: '', c: '' })
   })
   it('Should infer through heuristics #3', () => {
     const value = { type: 'A', a: 'a', b: 'b', c: null }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, { type: 'A', x: 0, y: 0, z: 0 })
+    Assert.IsEqual(result, { type: 'A', x: 0, y: 0, z: 0 })
   })
   it('Should infer through heuristics #4', () => {
     const value = { type: 'B', x: 1, y: 2, z: {} }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, { type: 'B', a: '', b: '', c: '' })
+    Assert.IsEqual(result, { type: 'B', a: '', b: '', c: '' })
   })
   it('Should infer through heuristics #5', () => {
     const value = { type: 'B', x: 1, y: 2, z: null }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, { type: 'B', a: '', b: '', c: '' })
+    Assert.IsEqual(result, { type: 'B', a: '', b: '', c: '' })
   })
   it('Should infer through heuristics #6', () => {
     const value = { x: 1 }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, { type: 'A', x: 1, y: 0, z: 0 })
+    Assert.IsEqual(result, { type: 'A', x: 1, y: 0, z: 0 })
   })
   it('Should infer through heuristics #7', () => {
     const value = { a: null } // property existing should contribute
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, { type: 'B', a: '', b: '', c: '' })
+    Assert.IsEqual(result, { type: 'B', a: '', b: '', c: '' })
   })
   it('Should cast with default value (create)', () => {
     const result = Value.Cast(
@@ -125,7 +124,7 @@ describe('value/cast/Union', () => {
         value: 'D',
       },
     )
-    Assert.isEqual(result, {
+    Assert.IsEqual(result, {
       id: 42,
       value: 'C',
     })
@@ -141,7 +140,7 @@ describe('value/cast/Union', () => {
         value: 'B',
       },
     )
-    Assert.isEqual(result, {
+    Assert.IsEqual(result, {
       id: 42,
       value: 'B',
     })
diff --git a/test/runtime/value/cast/unknown.ts b/test/runtime/value/cast/unknown.ts
index f6193fb7c..10058ef2e 100644
--- a/test/runtime/value/cast/unknown.ts
+++ b/test/runtime/value/cast/unknown.ts
@@ -7,46 +7,46 @@ describe('value/cast/Unknown', () => {
   it('Should upcast from string', () => {
     const value = 'hello'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from boolean', () => {
     const value = false
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, value)
+    Assert.IsEqual(result, value)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result: any = Value.Cast(T, value)
-    Assert.isEqual(result.getTime(), 100)
+    Assert.IsEqual(result.getTime(), 100)
   })
   it('Should preserve', () => {
     const value = { a: 1, b: 2 }
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, { a: 1, b: 2 })
+    Assert.IsEqual(result, { a: 1, b: 2 })
   })
 })
diff --git a/test/runtime/value/cast/void.ts b/test/runtime/value/cast/void.ts
index 6996f3bf0..41adb69e2 100644
--- a/test/runtime/value/cast/void.ts
+++ b/test/runtime/value/cast/void.ts
@@ -8,46 +8,46 @@ describe('value/cast/Void', () => {
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from number', () => {
     const value = 1
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from boolean', () => {
     const value = true
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should upcast from date', () => {
     const value = new Date(100)
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, E)
+    Assert.IsEqual(result, E)
   })
   it('Should preserve', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.isEqual(result, null)
+    Assert.IsEqual(result, null)
   })
 })
diff --git a/test/runtime/value/check/any.ts b/test/runtime/value/check/any.ts
index 1f46bb09a..302412c36 100644
--- a/test/runtime/value/check/any.ts
+++ b/test/runtime/value/check/any.ts
@@ -7,41 +7,41 @@ describe('value/check/Any', () => {
   it('Should pass string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should pass number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should pass boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should pass null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should pass undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should pass object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should pass array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should pass Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
 })
diff --git a/test/runtime/value/check/array.ts b/test/runtime/value/check/array.ts
index c0ef023b8..421a3e19a 100644
--- a/test/runtime/value/check/array.ts
+++ b/test/runtime/value/check/array.ts
@@ -7,48 +7,41 @@ describe('value/check/Array', () => {
     const T = Type.Array(Type.Number())
     const value = [1, 2, 3]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
-
   it('Should fail number array', () => {
     const T = Type.Array(Type.Number())
     const value = ['a', 'b', 'c']
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should pass object array', () => {
     const T = Type.Array(Type.Object({ x: Type.Number() }))
     const value = [{ x: 1 }, { x: 1 }, { x: 1 }]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
-
   it('Should fail object array', () => {
     const T = Type.Array(Type.Object({ x: Type.Number() }))
     const value = [{ x: 1 }, { x: 1 }, 1]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(Type.Array(Type.Any()), value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should validate array with unique primitive items', () => {
     const T = Type.Array(Type.Number(), { uniqueItems: true })
     const result = Value.Check(T, [0, 1, 2])
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
-
   it('Should not validate array with non-unique primitive items', () => {
     const T = Type.Array(Type.Number(), { uniqueItems: true })
     const result = Value.Check(T, [0, 0, 2])
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should validate array with unique object items', () => {
     const T = Type.Array(Type.Object({ x: Type.Number(), y: Type.Number() }), { uniqueItems: true })
     const result = Value.Check(T, [
@@ -56,9 +49,8 @@ describe('value/check/Array', () => {
       { x: 2, y: 2 },
       { x: 3, y: 3 },
     ])
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
-
   it('Should not validate array with non-unique object items', () => {
     const T = Type.Array(Type.Object({ x: Type.Number(), y: Type.Number() }), { uniqueItems: true })
     const result = Value.Check(T, [
@@ -66,6 +58,56 @@ describe('value/check/Array', () => {
       { x: 1, y: 1 },
       { x: 3, y: 3 },
     ])
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
+  })
+  // ---------------------------------------------------------
+  // Contains
+  // ---------------------------------------------------------
+  it('Should validate for contains', () => {
+    const T = Type.Array(Type.Number(), { contains: Type.Literal(1) })
+    Assert.IsTrue(Value.Check(T, [1]))
+    Assert.IsTrue(Value.Check(T, [1, 2]))
+    Assert.IsFalse(Value.Check(T, []))
+    Assert.IsFalse(Value.Check(T, [2]))
+  })
+  it('Should validate for minContains', () => {
+    const T = Type.Array(Type.Number(), { contains: Type.Literal(1), minContains: 3 })
+    Assert.IsTrue(Value.Check(T, [1, 1, 1, 2]))
+    Assert.IsTrue(Value.Check(T, [2, 1, 1, 1, 2]))
+    Assert.IsTrue(Value.Check(T, [1, 1, 1]))
+    Assert.IsFalse(Value.Check(T, []))
+    Assert.IsFalse(Value.Check(T, [1, 1]))
+    Assert.IsFalse(Value.Check(T, [2]))
+  })
+  it('Should validate for maxContains', () => {
+    const T = Type.Array(Type.Number(), { contains: Type.Literal(1), maxContains: 3 })
+    Assert.IsTrue(Value.Check(T, [1, 1, 1]))
+    Assert.IsTrue(Value.Check(T, [1, 1]))
+    Assert.IsTrue(Value.Check(T, [2, 2, 2, 2, 1, 1, 1]))
+    Assert.IsFalse(Value.Check(T, [1, 1, 1, 1]))
+  })
+  it('Should validate for minContains and maxContains', () => {
+    const T = Type.Array(Type.Number(), { contains: Type.Literal(1), minContains: 3, maxContains: 5 })
+    Assert.IsFalse(Value.Check(T, [1, 1]))
+    Assert.IsTrue(Value.Check(T, [1, 1, 1]))
+    Assert.IsTrue(Value.Check(T, [1, 1, 1, 1]))
+    Assert.IsTrue(Value.Check(T, [1, 1, 1, 1, 1]))
+    Assert.IsFalse(Value.Check(T, [1, 1, 1, 1, 1, 1]))
+  })
+  it('Should not validate minContains and maxContains when contains is unspecified', () => {
+    const T = Type.Array(Type.Number(), { minContains: 3, maxContains: 5 })
+    Assert.IsFalse(Value.Check(T, [1, 1]))
+    Assert.IsFalse(Value.Check(T, [1, 1, 1]))
+    Assert.IsFalse(Value.Check(T, [1, 1, 1, 1]))
+    Assert.IsFalse(Value.Check(T, [1, 1, 1, 1, 1]))
+    Assert.IsFalse(Value.Check(T, [1, 1, 1, 1, 1, 1]))
+  })
+  it('Should produce illogical schema when contains is not sub type of items', () => {
+    const T = Type.Array(Type.Number(), { contains: Type.String(), minContains: 3, maxContains: 5 })
+    Assert.IsFalse(Value.Check(T, [1, 1]))
+    Assert.IsFalse(Value.Check(T, [1, 1, 1]))
+    Assert.IsFalse(Value.Check(T, [1, 1, 1, 1]))
+    Assert.IsFalse(Value.Check(T, [1, 1, 1, 1, 1]))
+    Assert.IsFalse(Value.Check(T, [1, 1, 1, 1, 1, 1]))
   })
 })
diff --git a/test/runtime/value/check/async-iterator.ts b/test/runtime/value/check/async-iterator.ts
new file mode 100644
index 000000000..881f68c1c
--- /dev/null
+++ b/test/runtime/value/check/async-iterator.ts
@@ -0,0 +1,24 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/AsyncIterator', () => {
+  it('Should pass async iterator 1', () => {
+    async function* f() {}
+    const T = Type.AsyncIterator(Type.Any())
+    const result = Value.Check(T, f())
+    Assert.IsEqual(result, true)
+  })
+  it('Should pass async iterator 2', () => {
+    const T = Type.AsyncIterator(Type.Any())
+    const result = Value.Check(T, {
+      [Symbol.asyncIterator]: () => {},
+    })
+    Assert.IsEqual(result, true)
+  })
+  it('Should pass async iterator', () => {
+    const T = Type.AsyncIterator(Type.Any())
+    const result = Value.Check(T, {})
+    Assert.IsEqual(result, false)
+  })
+})
diff --git a/test/runtime/value/check/bigint.ts b/test/runtime/value/check/bigint.ts
index 2f663c384..b253926f5 100644
--- a/test/runtime/value/check/bigint.ts
+++ b/test/runtime/value/check/bigint.ts
@@ -7,38 +7,35 @@ describe('value/check/BigInt', () => {
   it('Should not validate NaN', () => {
     const T = Type.BigInt()
     const result = Value.Check(T, NaN)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should not validate +Infinity', () => {
     const T = Type.BigInt()
     const result = Value.Check(T, Infinity)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should not validate -Infinity', () => {
     const T = Type.BigInt()
     const result = Value.Check(T, -Infinity)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail integer', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should fail integer', () => {
     const value = 3.14
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should pass bigint', () => {
     const result = Value.Check(T, BigInt(0))
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
 })
diff --git a/test/runtime/value/check/boolean.ts b/test/runtime/value/check/boolean.ts
index d15d8b7d4..3eafcf878 100644
--- a/test/runtime/value/check/boolean.ts
+++ b/test/runtime/value/check/boolean.ts
@@ -7,41 +7,41 @@ describe('value/check/Boolean', () => {
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should pass boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should fail null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/composite.ts b/test/runtime/value/check/composite.ts
index fe4afa39f..7c12e76c8 100644
--- a/test/runtime/value/check/composite.ts
+++ b/test/runtime/value/check/composite.ts
@@ -14,7 +14,6 @@ describe('value/check/Composite', () => {
     c: Type.String(),
   })
   const T = Type.Composite([A, B])
-
   it('Should pass composite', () => {
     const value = {
       x: 1,
@@ -25,9 +24,8 @@ describe('value/check/Composite', () => {
       c: '1',
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
-
   it('Should fail intersect with invalid property', () => {
     const value = {
       x: true,
@@ -38,9 +36,8 @@ describe('value/check/Composite', () => {
       c: '1',
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should fail intersect with missing property', () => {
     const value = {
       y: 1,
@@ -50,15 +47,13 @@ describe('value/check/Composite', () => {
       c: '1',
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should fail intersect with primitive value', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should pass intersect with optional properties', () => {
     const A = Type.Object({
       x: Type.Optional(Type.Number()),
@@ -77,6 +72,6 @@ describe('value/check/Composite', () => {
       c: '1',
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
 })
diff --git a/test/runtime/value/check/custom.ts b/test/runtime/value/check/custom.ts
index 45e3dbba1..3072822f9 100644
--- a/test/runtime/value/check/custom.ts
+++ b/test/runtime/value/check/custom.ts
@@ -3,29 +3,27 @@ import { Type, Kind, TypeRegistry } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/check/Custom', () => {
-  TypeRegistry.Set('BigInt', (schema, value) => typeof value === 'bigint')
-
-  it('Should validate bigint', () => {
-    const T = Type.Unsafe({ [Kind]: 'BigInt' })
-    Assert.isEqual(Value.Check(T, 1n), true)
+  const FooBar = Type.Unsafe({ [Kind]: 'FooBar' })
+  before(() => {
+    TypeRegistry.Set('FooBar', (schema, value) => value === 'foobar')
   })
-
-  it('Should not validate bigint', () => {
-    const T = Type.Unsafe({ [Kind]: 'BigInt' })
-    Assert.isEqual(Value.Check(T, 1), false)
+  after(() => {
+    TypeRegistry.Delete('FooBar')
   })
-
-  it('Should validate bigint nested', () => {
-    const T = Type.Object({
-      x: Type.Unsafe({ [Kind]: 'BigInt' }),
-    })
-    Assert.isEqual(Value.Check(T, { x: 1n }), true)
+  it('Should validate foobar', () => {
+    Assert.IsEqual(Value.Check(FooBar, 'foobar'), true)
   })
-
-  it('Should not validate bigint nested', () => {
-    const T = Type.Object({
-      x: Type.Unsafe({ [Kind]: 'BigInt' }),
-    })
-    Assert.isEqual(Value.Check(T, { x: 1 }), false)
+  it('Should not validate foobar', () => {
+    Assert.IsEqual(Value.Check(FooBar, 1), false)
+  })
+  it('Should validate foobar nested', () => {
+    // prettier-ignore
+    const T = Type.Object({ x: FooBar })
+    Assert.IsEqual(Value.Check(T, { x: 'foobar' }), true)
+  })
+  it('Should not validate foobar nested', () => {
+    // prettier-ignore
+    const T = Type.Object({ x: FooBar })
+    Assert.IsEqual(Value.Check(T, { x: 1 }), false)
   })
 })
diff --git a/test/runtime/value/check/date.ts b/test/runtime/value/check/date.ts
index 2d4e74f8c..800c764b4 100644
--- a/test/runtime/value/check/date.ts
+++ b/test/runtime/value/check/date.ts
@@ -7,46 +7,46 @@ describe('value/check/Date', () => {
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should pass Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should not validate Date if is invalid', () => {
     const value = new Date('not-a-valid-date')
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/enum.ts b/test/runtime/value/check/enum.ts
index ec1395cdc..34d9612cf 100644
--- a/test/runtime/value/check/enum.ts
+++ b/test/runtime/value/check/enum.ts
@@ -8,27 +8,24 @@ describe('value/check/Enum', () => {
     B = 2,
   }
   const T = Type.Enum(Foo)
-
   it('Should pass enum option A', () => {
     const value = Foo.A
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
-
   it('Should pass enum option B', () => {
     const value = Foo.A
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
-
   it('Should fail unknown value', () => {
     const value = 'unknown'
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/index.ts b/test/runtime/value/check/index.ts
index f5cc52770..9dac82003 100644
--- a/test/runtime/value/check/index.ts
+++ b/test/runtime/value/check/index.ts
@@ -1,5 +1,6 @@
 import './any'
 import './array'
+import './async-iterator'
 import './bigint'
 import './boolean'
 import './composite'
@@ -8,6 +9,7 @@ import './date'
 import './enum'
 import './integer'
 import './intersect'
+import './iterator'
 import './keyof'
 import './literal'
 import './never'
@@ -18,7 +20,7 @@ import './object'
 import './recursive'
 import './ref'
 import './record'
-import './regex'
+import './regexp'
 import './string'
 import './symbol'
 import './template-literal'
diff --git a/test/runtime/value/check/integer.ts b/test/runtime/value/check/integer.ts
index 2db4fe7a7..9344a2937 100644
--- a/test/runtime/value/check/integer.ts
+++ b/test/runtime/value/check/integer.ts
@@ -4,38 +4,34 @@ import { Assert } from '../../assert/index'
 
 describe('value/check/Integer', () => {
   const T = Type.Integer()
-
   it('Should not validate NaN', () => {
     const T = Type.Integer()
     const result = Value.Check(T, NaN)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should not validate +Infinity', () => {
     const T = Type.Integer()
     const result = Value.Check(T, Infinity)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should not validate -Infinity', () => {
     const T = Type.Integer()
     const result = Value.Check(T, -Infinity)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should pass integer', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
-
   it('Should fail integer', () => {
     const value = 3.14
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/intersect.ts b/test/runtime/value/check/intersect.ts
index e41a9d0ad..e727f2bdb 100644
--- a/test/runtime/value/check/intersect.ts
+++ b/test/runtime/value/check/intersect.ts
@@ -7,79 +7,79 @@ describe('value/check/Intersect', () => {
     const A = Type.Number()
     const B = Type.Number()
     const T = Type.Intersect([A, B], {})
-    Assert.isEqual(Value.Check(T, 1), true)
+    Assert.IsEqual(Value.Check(T, 1), true)
   })
   it('Should not intersect string and number', () => {
     const A = Type.String()
     const B = Type.Number()
     const T = Type.Intersect([A, B], {})
-    Assert.isEqual(Value.Check(T, 1), false)
-    Assert.isEqual(Value.Check(T, '1'), false)
+    Assert.IsEqual(Value.Check(T, 1), false)
+    Assert.IsEqual(Value.Check(T, '1'), false)
   })
   it('Should intersect two objects', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ y: Type.Number() })
     const T = Type.Intersect([A, B], {})
-    Assert.isEqual(Value.Check(T, { x: 1, y: 1 }), true)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 1 }), true)
   })
   it('Should not intersect two objects with internal additionalProperties false', () => {
     const A = Type.Object({ x: Type.Number() }, { additionalProperties: false })
     const B = Type.Object({ y: Type.Number() }, { additionalProperties: false })
     const T = Type.Intersect([A, B], {})
-    Assert.isEqual(Value.Check(T, { x: 1, y: 1 }), false)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 1 }), false)
   })
   it('Should intersect two objects and mandate required properties', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ y: Type.Number() })
     const T = Type.Intersect([A, B], {})
-    Assert.isEqual(Value.Check(T, { x: 1, y: 1 }), true)
-    Assert.isEqual(Value.Check(T, { x: 1 }), false)
-    Assert.isEqual(Value.Check(T, { x: 1 }), false)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 1 }), true)
+    Assert.IsEqual(Value.Check(T, { x: 1 }), false)
+    Assert.IsEqual(Value.Check(T, { x: 1 }), false)
   })
   it('Should intersect two objects with unevaluated properties', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ y: Type.Number() })
     const T = Type.Intersect([A, B], {})
-    Assert.isEqual(Value.Check(T, { x: 1, y: 1, z: 1 }), true)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 1, z: 1 }), true)
   })
   it('Should intersect two objects and restrict unevaluated properties', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ y: Type.Number() })
     const T = Type.Intersect([A, B], { unevaluatedProperties: false })
-    Assert.isEqual(Value.Check(T, { x: 1, y: 1, z: 1 }), false)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 1, z: 1 }), false)
   })
   it('Should intersect two objects and allow unevaluated properties of number', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ y: Type.Number() })
     const T = Type.Intersect([A, B], { unevaluatedProperties: Type.Number() })
-    Assert.isEqual(Value.Check(T, { x: 1, y: 2, z: 3 }), true)
-    Assert.isEqual(Value.Check(T, { x: 1, y: 2, z: '1' }), false)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 2, z: 3 }), true)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 2, z: '1' }), false)
   })
   it('Should intersect two union objects with overlapping properties of the same type', () => {
     const A = Type.Union([Type.Object({ x: Type.Number() })])
     const B = Type.Union([Type.Object({ x: Type.Number() })])
     const T = Type.Intersect([A, B])
-    Assert.isEqual(Value.Check(T, { x: 1 }), true)
-    Assert.isEqual(Value.Check(T, { x: '1' }), false)
+    Assert.IsEqual(Value.Check(T, { x: 1 }), true)
+    Assert.IsEqual(Value.Check(T, { x: '1' }), false)
   })
   it('Should not intersect two union objects with overlapping properties of varying types', () => {
     const A = Type.Union([Type.Object({ x: Type.Number() })])
     const B = Type.Union([Type.Object({ x: Type.String() })])
     const T = Type.Intersect([A, B])
-    Assert.isEqual(Value.Check(T, { x: 1 }), false)
-    Assert.isEqual(Value.Check(T, { x: '1' }), false)
+    Assert.IsEqual(Value.Check(T, { x: 1 }), false)
+    Assert.IsEqual(Value.Check(T, { x: '1' }), false)
   })
   it('Should intersect two union objects with non-overlapping properties', () => {
     const A = Type.Union([Type.Object({ x: Type.Number() })])
     const B = Type.Union([Type.Object({ y: Type.Number() })])
     const T = Type.Intersect([A, B])
-    Assert.isEqual(Value.Check(T, { x: 1, y: 1 }), true)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 1 }), true)
   })
   it('Should not intersect two union objects with non-overlapping properties for additionalProperties false', () => {
     const A = Type.Union([Type.Object({ x: Type.Number() }, { additionalProperties: false })])
     const B = Type.Union([Type.Object({ y: Type.Number() }, { additionalProperties: false })])
     const T = Type.Intersect([A, B])
-    Assert.isEqual(Value.Check(T, { x: 1, y: 1 }), false)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 1 }), false)
   })
   it('unevaluatedProperties with Record 1', () => {
     const T = Type.Intersect(
@@ -94,7 +94,7 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: false,
       },
     )
-    Assert.isEqual(Value.Check(T, { x: 1, y: 2 }), true)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 2 }), true)
   })
   it('unevaluatedProperties with Record 2', () => {
     const T = Type.Intersect(
@@ -109,7 +109,7 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: false,
       },
     )
-    Assert.isEqual(Value.Check(T, { x: 1, y: 2, 0: 'hello' }), true)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 2, 0: 'hello' }), true)
   })
   it('unevaluatedProperties with Record 3', () => {
     const T = Type.Intersect(
@@ -124,7 +124,7 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: false,
       },
     )
-    Assert.isEqual(Value.Check(T, { x: 1, y: 2, 0: 1 }), false)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 2, 0: 1 }), false)
   })
   it('unevaluatedProperties with Record 4', () => {
     const T = Type.Intersect(
@@ -139,7 +139,7 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: Type.Boolean(),
       },
     )
-    Assert.isEqual(Value.Check(T, { x: 1, y: 2 }), true)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 2 }), true)
   })
   it('unevaluatedProperties with Record 5', () => {
     const T = Type.Intersect(
@@ -154,7 +154,7 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: Type.Boolean(),
       },
     )
-    Assert.isEqual(Value.Check(T, { x: 1, y: 2, z: true }), true)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 2, z: true }), true)
   })
   it('unevaluatedProperties with Record 6', () => {
     const T = Type.Intersect(
@@ -169,7 +169,7 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: Type.Boolean(),
       },
     )
-    Assert.isEqual(Value.Check(T, { x: 1, y: 2, z: 1 }), false)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 2, z: 1 }), false)
   })
   it('unevaluatedProperties with Record 7', () => {
     const T = Type.Intersect(
@@ -184,7 +184,7 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: Type.Boolean(),
       },
     )
-    Assert.isEqual(Value.Check(T, { x: 1, y: 2, 0: '' }), true)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 2, 0: '' }), true)
   })
   it('unevaluatedProperties with Record 8', () => {
     const T = Type.Intersect(
@@ -199,7 +199,7 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: Type.Boolean(),
       },
     )
-    Assert.isEqual(Value.Check(T, { x: 1, y: 2, 0: '', z: true }), true)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 2, 0: '', z: true }), true)
   })
   it('unevaluatedProperties with Record 9', () => {
     const T = Type.Intersect(
@@ -214,6 +214,6 @@ describe('value/check/Intersect', () => {
         unevaluatedProperties: Type.Boolean(),
       },
     )
-    Assert.isEqual(Value.Check(T, { x: 1, y: 2, 0: '', z: 1 }), false)
+    Assert.IsEqual(Value.Check(T, { x: 1, y: 2, 0: '', z: 1 }), false)
   })
 })
diff --git a/test/runtime/value/check/iterator.ts b/test/runtime/value/check/iterator.ts
new file mode 100644
index 000000000..69274d107
--- /dev/null
+++ b/test/runtime/value/check/iterator.ts
@@ -0,0 +1,24 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Iterator', () => {
+  it('Should pass iterator 1', () => {
+    function* f() {}
+    const T = Type.Iterator(Type.Any())
+    const result = Value.Check(T, f())
+    Assert.IsEqual(result, true)
+  })
+  it('Should pass iterator 2', () => {
+    const T = Type.Iterator(Type.Any())
+    const result = Value.Check(T, {
+      [Symbol.iterator]: () => {},
+    })
+    Assert.IsEqual(result, true)
+  })
+  it('Should pass iterator', () => {
+    const T = Type.Iterator(Type.Any())
+    const result = Value.Check(T, {})
+    Assert.IsEqual(result, false)
+  })
+})
diff --git a/test/runtime/value/check/keyof.ts b/test/runtime/value/check/keyof.ts
index ff9234f27..a3407c95d 100644
--- a/test/runtime/value/check/keyof.ts
+++ b/test/runtime/value/check/keyof.ts
@@ -10,28 +10,24 @@ describe('value/check/KeyOf', () => {
       z: Type.Number(),
     }),
   )
-
   it('Should pass keyof', () => {
     const value = 'x'
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
-
   it('Should fail keyof', () => {
     const value = 'w'
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should fail keyof with undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should fail keyof with null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/literal.ts b/test/runtime/value/check/literal.ts
index ae1e28dcb..4acca4557 100644
--- a/test/runtime/value/check/literal.ts
+++ b/test/runtime/value/check/literal.ts
@@ -7,21 +7,21 @@ describe('value/check/Literal', () => {
   it('Should pass literal', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should fail literal', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail literal with undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail literal with null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/never.ts b/test/runtime/value/check/never.ts
index 979e74474..325f189f3 100644
--- a/test/runtime/value/check/never.ts
+++ b/test/runtime/value/check/never.ts
@@ -7,36 +7,36 @@ describe('value/check/Never', () => {
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/not.ts b/test/runtime/value/check/not.ts
index 780d08c24..ba5471bf8 100644
--- a/test/runtime/value/check/not.ts
+++ b/test/runtime/value/check/not.ts
@@ -5,8 +5,8 @@ import { Assert } from '../../assert/index'
 describe('value/check/Not', () => {
   it('Should validate with not number', () => {
     const T = Type.Not(Type.Number(), Type.String())
-    Assert.isEqual(Value.Check(T, 1), false)
-    Assert.isEqual(Value.Check(T, 'A'), true)
+    Assert.IsEqual(Value.Check(T, 1), false)
+    Assert.IsEqual(Value.Check(T, 'A'), true)
   })
   it('Should validate with union left', () => {
     // prettier-ignore
@@ -15,10 +15,10 @@ describe('value/check/Not', () => {
             Type.Literal('B'),
             Type.Literal('C')
         ]), Type.String())
-    Assert.isEqual(Value.Check(T, 'A'), false)
-    Assert.isEqual(Value.Check(T, 'B'), false)
-    Assert.isEqual(Value.Check(T, 'C'), false)
-    Assert.isEqual(Value.Check(T, 'D'), true)
+    Assert.IsEqual(Value.Check(T, 'A'), false)
+    Assert.IsEqual(Value.Check(T, 'B'), false)
+    Assert.IsEqual(Value.Check(T, 'C'), false)
+    Assert.IsEqual(Value.Check(T, 'D'), true)
   })
   it('Should validate with union right', () => {
     // prettier-ignore
@@ -26,8 +26,8 @@ describe('value/check/Not', () => {
             Type.String(),
             Type.Boolean()
         ]))
-    Assert.isEqual(Value.Check(T, 1), false)
-    Assert.isEqual(Value.Check(T, 'A'), true)
-    Assert.isEqual(Value.Check(T, true), true)
+    Assert.IsEqual(Value.Check(T, 1), false)
+    Assert.IsEqual(Value.Check(T, 'A'), true)
+    Assert.IsEqual(Value.Check(T, true), true)
   })
 })
diff --git a/test/runtime/value/check/null.ts b/test/runtime/value/check/null.ts
index fea54f9ec..2a92ec855 100644
--- a/test/runtime/value/check/null.ts
+++ b/test/runtime/value/check/null.ts
@@ -7,41 +7,41 @@ describe('value/check/Null', () => {
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should pass null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should fail undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/number.ts b/test/runtime/value/check/number.ts
index 3b60578ed..a38909989 100644
--- a/test/runtime/value/check/number.ts
+++ b/test/runtime/value/check/number.ts
@@ -7,61 +7,61 @@ describe('value/check/Number', () => {
   it('Should not validate NaN', () => {
     const T = Type.Number()
     const result = Value.Check(T, NaN)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should not validate +Infinity', () => {
     const T = Type.Number()
     const result = Value.Check(T, Infinity)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should not validate -Infinity', () => {
     const T = Type.Number()
     const result = Value.Check(T, -Infinity)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should pass number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 
   it('Should fail NaN', () => {
     const result = Value.Check(Type.Number(), NaN)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/object.ts b/test/runtime/value/check/object.ts
index 65485881b..fe6b5b718 100644
--- a/test/runtime/value/check/object.ts
+++ b/test/runtime/value/check/object.ts
@@ -11,7 +11,6 @@ describe('value/check/Object', () => {
     b: Type.String(),
     c: Type.String(),
   })
-
   it('Should pass object', () => {
     const value = {
       x: 1,
@@ -22,9 +21,8 @@ describe('value/check/Object', () => {
       c: '1',
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
-
   it('Should fail object with additional properties', () => {
     const T = Type.Object(
       {
@@ -41,9 +39,8 @@ describe('value/check/Object', () => {
       a: 1,
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should fail object with invalid property', () => {
     const value = {
       x: true,
@@ -54,9 +51,8 @@ describe('value/check/Object', () => {
       c: '1',
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should fail object with missing property', () => {
     const value = {
       y: 1,
@@ -66,9 +62,8 @@ describe('value/check/Object', () => {
       c: '1',
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should pass object with optional properties', () => {
     const T = Type.Object({
       x: Type.Optional(Type.Number()),
@@ -84,21 +79,18 @@ describe('value/check/Object', () => {
       c: '1',
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
-
   it('Should fail object with null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should fail object with undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
-
   it('Should validate schema additional properties of string', () => {
     const T = Type.Object(
       {
@@ -109,8 +101,7 @@ describe('value/check/Object', () => {
         additionalProperties: Type.String(),
       },
     )
-
-    Assert.isEqual(
+    Assert.IsEqual(
       Value.Check(T, {
         x: 1,
         y: 2,
@@ -119,7 +110,7 @@ describe('value/check/Object', () => {
       true,
     )
 
-    Assert.isEqual(
+    Assert.IsEqual(
       Value.Check(T, {
         x: 1,
         y: 2,
@@ -128,7 +119,6 @@ describe('value/check/Object', () => {
       false,
     )
   })
-
   it('Should validate schema additional properties of array', () => {
     const T = Type.Object(
       {
@@ -139,8 +129,7 @@ describe('value/check/Object', () => {
         additionalProperties: Type.Array(Type.Number()),
       },
     )
-
-    Assert.isEqual(
+    Assert.IsEqual(
       Value.Check(T, {
         x: 1,
         y: 2,
@@ -148,8 +137,7 @@ describe('value/check/Object', () => {
       }),
       true,
     )
-
-    Assert.isEqual(
+    Assert.IsEqual(
       Value.Check(T, {
         x: 1,
         y: 2,
@@ -158,7 +146,6 @@ describe('value/check/Object', () => {
       false,
     )
   })
-
   it('Should validate schema additional properties of object', () => {
     const T = Type.Object(
       {
@@ -171,8 +158,7 @@ describe('value/check/Object', () => {
         }),
       },
     )
-
-    Assert.isEqual(
+    Assert.IsEqual(
       Value.Check(T, {
         x: 1,
         y: 2,
@@ -180,8 +166,7 @@ describe('value/check/Object', () => {
       }),
       true,
     )
-
-    Assert.isEqual(
+    Assert.IsEqual(
       Value.Check(T, {
         x: 1,
         y: 2,
@@ -192,36 +177,36 @@ describe('value/check/Object', () => {
   })
   it('Should check for property key if property type is undefined', () => {
     const T = Type.Object({ x: Type.Undefined() })
-    Assert.isEqual(Value.Check(T, { x: undefined }), true)
-    Assert.isEqual(Value.Check(T, {}), false)
+    Assert.IsEqual(Value.Check(T, { x: undefined }), true)
+    Assert.IsEqual(Value.Check(T, {}), false)
   })
   it('Should check for property key if property type extends undefined', () => {
     const T = Type.Object({ x: Type.Union([Type.Number(), Type.Undefined()]) })
-    Assert.isEqual(Value.Check(T, { x: 1 }), true)
-    Assert.isEqual(Value.Check(T, { x: undefined }), true)
-    Assert.isEqual(Value.Check(T, {}), false)
+    Assert.IsEqual(Value.Check(T, { x: 1 }), true)
+    Assert.IsEqual(Value.Check(T, { x: undefined }), true)
+    Assert.IsEqual(Value.Check(T, {}), false)
   })
   it('Should not check for property key if property type is undefined and optional', () => {
     const T = Type.Object({ x: Type.Optional(Type.Undefined()) })
-    Assert.isEqual(Value.Check(T, { x: undefined }), true)
-    Assert.isEqual(Value.Check(T, {}), true)
+    Assert.IsEqual(Value.Check(T, { x: undefined }), true)
+    Assert.IsEqual(Value.Check(T, {}), true)
   })
   it('Should not check for property key if property type extends undefined and optional', () => {
     const T = Type.Object({ x: Type.Optional(Type.Union([Type.Number(), Type.Undefined()])) })
-    Assert.isEqual(Value.Check(T, { x: 1 }), true)
-    Assert.isEqual(Value.Check(T, { x: undefined }), true)
-    Assert.isEqual(Value.Check(T, {}), true)
+    Assert.IsEqual(Value.Check(T, { x: 1 }), true)
+    Assert.IsEqual(Value.Check(T, { x: undefined }), true)
+    Assert.IsEqual(Value.Check(T, {}), true)
   })
   it('Should check undefined for optional property of number', () => {
     const T = Type.Object({ x: Type.Optional(Type.Number()) })
-    Assert.isEqual(Value.Check(T, { x: 1 }), true)
-    Assert.isEqual(Value.Check(T, { x: undefined }), true) // allowed by default
-    Assert.isEqual(Value.Check(T, {}), true)
+    Assert.IsEqual(Value.Check(T, { x: 1 }), true)
+    Assert.IsEqual(Value.Check(T, { x: undefined }), true) // allowed by default
+    Assert.IsEqual(Value.Check(T, {}), true)
   })
   it('Should check undefined for optional property of undefined', () => {
     const T = Type.Object({ x: Type.Optional(Type.Undefined()) })
-    Assert.isEqual(Value.Check(T, { x: 1 }), false)
-    Assert.isEqual(Value.Check(T, {}), true)
-    Assert.isEqual(Value.Check(T, { x: undefined }), true)
+    Assert.IsEqual(Value.Check(T, { x: 1 }), false)
+    Assert.IsEqual(Value.Check(T, {}), true)
+    Assert.IsEqual(Value.Check(T, { x: undefined }), true)
   })
 })
diff --git a/test/runtime/value/check/record.ts b/test/runtime/value/check/record.ts
index 1e36e37b1..c6e04ce8d 100644
--- a/test/runtime/value/check/record.ts
+++ b/test/runtime/value/check/record.ts
@@ -20,33 +20,33 @@ describe('value/check/Record', () => {
       },
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should fail when below minProperties', () => {
     const T = Type.Record(Type.String(), Type.Number(), { minProperties: 4 })
-    Assert.isEqual(Value.Check(T, { a: 1, b: 2, c: 3, d: 4 }), true)
-    Assert.isEqual(Value.Check(T, { a: 1, b: 2, c: 3 }), false)
+    Assert.IsEqual(Value.Check(T, { a: 1, b: 2, c: 3, d: 4 }), true)
+    Assert.IsEqual(Value.Check(T, { a: 1, b: 2, c: 3 }), false)
   })
   it('Should fail when above maxProperties', () => {
     const T = Type.Record(Type.String(), Type.Number(), { maxProperties: 4 })
-    Assert.isEqual(Value.Check(T, { a: 1, b: 2, c: 3, d: 4 }), true)
-    Assert.isEqual(Value.Check(T, { a: 1, b: 2, c: 3, d: 4, e: 5 }), false)
+    Assert.IsEqual(Value.Check(T, { a: 1, b: 2, c: 3, d: 4 }), true)
+    Assert.IsEqual(Value.Check(T, { a: 1, b: 2, c: 3, d: 4, e: 5 }), false)
   })
   it('Should fail with illogical minProperties | maxProperties', () => {
     const T = Type.Record(Type.String(), Type.Number(), { minProperties: 5, maxProperties: 4 })
-    Assert.isEqual(Value.Check(T, { a: 1, b: 2, c: 3 }), false)
-    Assert.isEqual(Value.Check(T, { a: 1, b: 2, c: 3, d: 4 }), false)
-    Assert.isEqual(Value.Check(T, { a: 1, b: 2, c: 3, d: 4, e: 5 }), false)
+    Assert.IsEqual(Value.Check(T, { a: 1, b: 2, c: 3 }), false)
+    Assert.IsEqual(Value.Check(T, { a: 1, b: 2, c: 3, d: 4 }), false)
+    Assert.IsEqual(Value.Check(T, { a: 1, b: 2, c: 3, d: 4, e: 5 }), false)
   })
   it('Should fail record with Date', () => {
     const T = Type.Record(Type.String(), Type.String())
     const result = Value.Check(T, new Date())
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail record with Uint8Array', () => {
     const T = Type.Record(Type.String(), Type.String())
     const result = Value.Check(T, new Uint8Array())
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail record with missing property', () => {
     const T = Type.Record(
@@ -64,7 +64,7 @@ describe('value/check/Record', () => {
       },
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail record with invalid property', () => {
     const T = Type.Record(
@@ -83,7 +83,7 @@ describe('value/check/Record', () => {
       },
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should pass record with optional property', () => {
     const T = Type.Record(
@@ -101,7 +101,7 @@ describe('value/check/Record', () => {
       },
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should pass record with optional property', () => {
     const T = Type.Record(
@@ -119,7 +119,7 @@ describe('value/check/Record', () => {
       },
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   // -------------------------------------------------
   // Number Key
@@ -132,7 +132,7 @@ describe('value/check/Record', () => {
       2: 'a',
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
 
   it('Should not pass record with invalid number key', () => {
@@ -143,7 +143,7 @@ describe('value/check/Record', () => {
       2: 'a',
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   // -------------------------------------------------
   // Integer Key
@@ -156,7 +156,7 @@ describe('value/check/Record', () => {
       2: 'a',
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should not pass record with invalid integer key', () => {
     const T = Type.Record(Type.Integer(), Type.String(), { additionalProperties: false })
@@ -166,7 +166,7 @@ describe('value/check/Record', () => {
       2: 'a',
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   // ------------------------------------------------------------
   // AdditionalProperties
@@ -174,26 +174,26 @@ describe('value/check/Record', () => {
   it('AdditionalProperties 1', () => {
     const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: true })
     const R = Value.Check(T, { 1: '', 2: '', x: 1, y: 2, z: 3 })
-    Assert.isEqual(R, true)
+    Assert.IsEqual(R, true)
   })
   it('AdditionalProperties 2', () => {
     const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: false })
     const R = Value.Check(T, { 1: '', 2: '', 3: '' })
-    Assert.isEqual(R, true)
+    Assert.IsEqual(R, true)
   })
   it('AdditionalProperties 3', () => {
     const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: false })
     const R = Value.Check(T, { 1: '', 2: '', x: '' })
-    Assert.isEqual(R, false)
+    Assert.IsEqual(R, false)
   })
   it('AdditionalProperties 4', () => {
     const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: Type.Boolean() })
     const R = Value.Check(T, { 1: '', 2: '', x: '' })
-    Assert.isEqual(R, false)
+    Assert.IsEqual(R, false)
   })
   it('AdditionalProperties 5', () => {
     const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: Type.Boolean() })
     const R = Value.Check(T, { 1: '', 2: '', x: true })
-    Assert.isEqual(R, true)
+    Assert.IsEqual(R, true)
   })
 })
diff --git a/test/runtime/value/check/recursive.ts b/test/runtime/value/check/recursive.ts
index f6c7b94be..1b6c60bb9 100644
--- a/test/runtime/value/check/recursive.ts
+++ b/test/runtime/value/check/recursive.ts
@@ -20,7 +20,7 @@ describe('value/check/Recursive', () => {
       ],
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
 
   it('Should fail recursive with invalid id', () => {
@@ -33,7 +33,7 @@ describe('value/check/Recursive', () => {
       ],
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 
   it('Should fail rec with invalid nodes', () => {
@@ -46,7 +46,7 @@ describe('value/check/Recursive', () => {
       ],
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 
   it('Should fail recursive with missing id', () => {
@@ -55,7 +55,7 @@ describe('value/check/Recursive', () => {
       nodes: [{ nodes: [] }, { id: 'C', nodes: [] }, { id: 'D', nodes: [] }],
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 
   it('Should fail rec with missing nodes', () => {
@@ -64,6 +64,6 @@ describe('value/check/Recursive', () => {
       nodes: [{ id: 'B' }, { id: 'C', nodes: [] }, { id: 'D', nodes: [] }],
     }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/ref.ts b/test/runtime/value/check/ref.ts
index e838a383a..cc541149d 100644
--- a/test/runtime/value/check/ref.ts
+++ b/test/runtime/value/check/ref.ts
@@ -10,10 +10,10 @@ describe('value/check/Ref', () => {
         y: Type.Number(),
         z: Type.Number(),
       },
-      { $id: Assert.nextId() },
+      { $id: Assert.NextId() },
     )
     const R = Type.Ref(T)
-    Assert.isEqual(
+    Assert.IsEqual(
       Value.Check(R, [T], {
         x: 1,
         y: 2,
@@ -30,10 +30,10 @@ describe('value/check/Ref', () => {
         y: Type.Number(),
         z: Type.Number(),
       },
-      { $id: Assert.nextId() },
+      { $id: Assert.NextId() },
     )
     const R = Type.Ref(T)
-    Assert.isEqual(
+    Assert.IsEqual(
       Value.Check(R, [T], {
         x: 1,
         y: 2,
@@ -59,10 +59,10 @@ describe('value/check/Ref', () => {
       },
       { $id: 'T' },
     )
-    Assert.isEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3 }), true)
-    Assert.isEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3, r: { name: 'hello' } }), true)
-    Assert.isEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3, r: { name: 1 } }), false)
-    Assert.isEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3, r: {} }), false)
+    Assert.IsEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3 }), true)
+    Assert.IsEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3, r: { name: 'hello' } }), true)
+    Assert.IsEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3, r: { name: 1 } }), false)
+    Assert.IsEqual(Value.Check(R, [T], { x: 1, y: 2, z: 3, r: {} }), false)
     // Ok(R, { x: 1, y: 2, z: 3 }, [T])
     // Ok(R, , [T])
     // Fail(R, , [T])
@@ -77,7 +77,7 @@ describe('value/check/Ref', () => {
       }),
     )
     const R = Type.Ref(T)
-    Assert.isEqual(Value.Check(R, [T], { id: '', nodes: [{ id: '', nodes: [] }] }), true)
-    Assert.isEqual(Value.Check(R, [T], { id: '', nodes: [{ id: 1, nodes: [] }] }), false)
+    Assert.IsEqual(Value.Check(R, [T], { id: '', nodes: [{ id: '', nodes: [] }] }), true)
+    Assert.IsEqual(Value.Check(R, [T], { id: '', nodes: [{ id: 1, nodes: [] }] }), false)
   })
 })
diff --git a/test/runtime/value/check/regex.ts b/test/runtime/value/check/regex.ts
deleted file mode 100644
index b56076ded..000000000
--- a/test/runtime/value/check/regex.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { Value } from '@sinclair/typebox/value'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
-
-describe('value/check/RegEx', () => {
-  it('Should pass regex', () => {
-    const T = Type.RegEx(/foo/)
-    const value = 'foo'
-    const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
-  })
-
-  it('Should fail regex', () => {
-    const T = Type.RegEx(/foo/)
-    const value = 'bar'
-    const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
-  })
-})
diff --git a/test/runtime/value/check/regexp.ts b/test/runtime/value/check/regexp.ts
new file mode 100644
index 000000000..ce843038e
--- /dev/null
+++ b/test/runtime/value/check/regexp.ts
@@ -0,0 +1,36 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/RegExp', () => {
+  // -------------------------------------------------
+  // Regular Expression
+  // -------------------------------------------------
+  it('Should pass regular expression 1', () => {
+    const T = Type.RegExp(/foo/)
+    const value = 'foo'
+    const result = Value.Check(T, value)
+    Assert.IsEqual(result, true)
+  })
+  it('Should pass regular expression 2', () => {
+    const T = Type.RegExp(/foo/)
+    const value = 'bar'
+    const result = Value.Check(T, value)
+    Assert.IsEqual(result, false)
+  })
+  // -------------------------------------------------
+  // Pattern
+  // -------------------------------------------------
+  it('Should pass pattern 1', () => {
+    const T = Type.RegExp('foo')
+    const value = 'foo'
+    const result = Value.Check(T, value)
+    Assert.IsEqual(result, true)
+  })
+  it('Should pass pattern 2', () => {
+    const T = Type.RegExp('foo')
+    const value = 'bar'
+    const result = Value.Check(T, value)
+    Assert.IsEqual(result, false)
+  })
+})
diff --git a/test/runtime/value/check/string.ts b/test/runtime/value/check/string.ts
index 1dbc26690..48a0eb6a9 100644
--- a/test/runtime/value/check/string.ts
+++ b/test/runtime/value/check/string.ts
@@ -7,41 +7,41 @@ describe('value/check/String', () => {
   it('Should pass string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/symbol.ts b/test/runtime/value/check/symbol.ts
index 12b343d15..ad342813d 100644
--- a/test/runtime/value/check/symbol.ts
+++ b/test/runtime/value/check/symbol.ts
@@ -7,46 +7,46 @@ describe('value/check/Symbol', () => {
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should pass symbol', () => {
     const value = Symbol(1)
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
 })
diff --git a/test/runtime/value/check/template-literal.ts b/test/runtime/value/check/template-literal.ts
index 44fbbb66b..0cffa6f86 100644
--- a/test/runtime/value/check/template-literal.ts
+++ b/test/runtime/value/check/template-literal.ts
@@ -9,23 +9,23 @@ describe('value/check/TemplateLiteral', () => {
   it('Should validate finite pattern 1', () => {
     // prettier-ignore
     const T = Type.TemplateLiteral([])
-    Assert.isEqual(Value.Check(T, ''), true)
-    Assert.isEqual(Value.Check(T, 'X'), false)
+    Assert.IsEqual(Value.Check(T, ''), true)
+    Assert.IsEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate finite pattern 1', () => {
     // prettier-ignore
     const T = Type.TemplateLiteral([Type.Boolean()])
-    Assert.isEqual(Value.Check(T, 'true'), true)
-    Assert.isEqual(Value.Check(T, 'false'), true)
-    Assert.isEqual(Value.Check(T, 'X'), false)
+    Assert.IsEqual(Value.Check(T, 'true'), true)
+    Assert.IsEqual(Value.Check(T, 'false'), true)
+    Assert.IsEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate finite pattern 2', () => {
     // prettier-ignore
     const T = Type.TemplateLiteral([
       Type.Literal('A')
     ])
-    Assert.isEqual(Value.Check(T, 'A'), true)
-    Assert.isEqual(Value.Check(T, 'X'), false)
+    Assert.IsEqual(Value.Check(T, 'A'), true)
+    Assert.IsEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate finite pattern 3', () => {
     // prettier-ignore
@@ -33,8 +33,8 @@ describe('value/check/TemplateLiteral', () => {
       Type.Literal('A'),
       Type.Literal('B')
     ])
-    Assert.isEqual(Value.Check(T, 'AB'), true)
-    Assert.isEqual(Value.Check(T, 'X'), false)
+    Assert.IsEqual(Value.Check(T, 'AB'), true)
+    Assert.IsEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate finite pattern 4', () => {
     // prettier-ignore
@@ -45,9 +45,9 @@ describe('value/check/TemplateLiteral', () => {
         Type.Literal('C')
       ]),
     ])
-    Assert.isEqual(Value.Check(T, 'AB'), true)
-    Assert.isEqual(Value.Check(T, 'AC'), true)
-    Assert.isEqual(Value.Check(T, 'X'), false)
+    Assert.IsEqual(Value.Check(T, 'AB'), true)
+    Assert.IsEqual(Value.Check(T, 'AC'), true)
+    Assert.IsEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate finite pattern 5', () => {
     // prettier-ignore
@@ -59,9 +59,9 @@ describe('value/check/TemplateLiteral', () => {
       ]),
       Type.Literal('D'),
     ])
-    Assert.isEqual(Value.Check(T, 'ABD'), true)
-    Assert.isEqual(Value.Check(T, 'ACD'), true)
-    Assert.isEqual(Value.Check(T, 'X'), false)
+    Assert.IsEqual(Value.Check(T, 'ABD'), true)
+    Assert.IsEqual(Value.Check(T, 'ACD'), true)
+    Assert.IsEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate finite pattern 6', () => {
     // prettier-ignore
@@ -75,11 +75,11 @@ describe('value/check/TemplateLiteral', () => {
         Type.Literal('1')
       ]),
     ])
-    Assert.isEqual(Value.Check(T, '00'), true)
-    Assert.isEqual(Value.Check(T, '01'), true)
-    Assert.isEqual(Value.Check(T, '10'), true)
-    Assert.isEqual(Value.Check(T, '11'), true)
-    Assert.isEqual(Value.Check(T, 'X'), false)
+    Assert.IsEqual(Value.Check(T, '00'), true)
+    Assert.IsEqual(Value.Check(T, '01'), true)
+    Assert.IsEqual(Value.Check(T, '10'), true)
+    Assert.IsEqual(Value.Check(T, '11'), true)
+    Assert.IsEqual(Value.Check(T, 'X'), false)
   })
   // --------------------------------------------------------
   // Infinite
@@ -89,47 +89,47 @@ describe('value/check/TemplateLiteral', () => {
     const T = Type.TemplateLiteral([
       Type.Number()
     ])
-    Assert.isEqual(Value.Check(T, '1'), true)
-    Assert.isEqual(Value.Check(T, '22'), true)
-    Assert.isEqual(Value.Check(T, '333'), true)
-    Assert.isEqual(Value.Check(T, '4444'), true)
-    Assert.isEqual(Value.Check(T, 'X'), false)
+    Assert.IsEqual(Value.Check(T, '1'), true)
+    Assert.IsEqual(Value.Check(T, '22'), true)
+    Assert.IsEqual(Value.Check(T, '333'), true)
+    Assert.IsEqual(Value.Check(T, '4444'), true)
+    Assert.IsEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate infinite pattern 2', () => {
     // prettier-ignore
     const T = Type.TemplateLiteral([
       Type.Integer()
     ])
-    Assert.isEqual(Value.Check(T, '1'), true)
-    Assert.isEqual(Value.Check(T, '22'), true)
-    Assert.isEqual(Value.Check(T, '333'), true)
-    Assert.isEqual(Value.Check(T, '4444'), true)
-    Assert.isEqual(Value.Check(T, 'X'), false)
+    Assert.IsEqual(Value.Check(T, '1'), true)
+    Assert.IsEqual(Value.Check(T, '22'), true)
+    Assert.IsEqual(Value.Check(T, '333'), true)
+    Assert.IsEqual(Value.Check(T, '4444'), true)
+    Assert.IsEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate infinite pattern 3', () => {
     // prettier-ignore
     const T = Type.TemplateLiteral([
       Type.BigInt()
     ])
-    Assert.isEqual(Value.Check(T, '1'), true)
-    Assert.isEqual(Value.Check(T, '22'), true)
-    Assert.isEqual(Value.Check(T, '333'), true)
-    Assert.isEqual(Value.Check(T, '4444'), true)
-    Assert.isEqual(Value.Check(T, 'X'), false)
+    Assert.IsEqual(Value.Check(T, '1'), true)
+    Assert.IsEqual(Value.Check(T, '22'), true)
+    Assert.IsEqual(Value.Check(T, '333'), true)
+    Assert.IsEqual(Value.Check(T, '4444'), true)
+    Assert.IsEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate infinite pattern 4', () => {
     // prettier-ignore
     const T = Type.TemplateLiteral([
       Type.String()
     ])
-    Assert.isEqual(Value.Check(T, '1'), true)
-    Assert.isEqual(Value.Check(T, '22'), true)
-    Assert.isEqual(Value.Check(T, '333'), true)
-    Assert.isEqual(Value.Check(T, '4444'), true)
-    Assert.isEqual(Value.Check(T, 'a'), true)
-    Assert.isEqual(Value.Check(T, 'bb'), true)
-    Assert.isEqual(Value.Check(T, 'ccc'), true)
-    Assert.isEqual(Value.Check(T, 'dddd'), true)
+    Assert.IsEqual(Value.Check(T, '1'), true)
+    Assert.IsEqual(Value.Check(T, '22'), true)
+    Assert.IsEqual(Value.Check(T, '333'), true)
+    Assert.IsEqual(Value.Check(T, '4444'), true)
+    Assert.IsEqual(Value.Check(T, 'a'), true)
+    Assert.IsEqual(Value.Check(T, 'bb'), true)
+    Assert.IsEqual(Value.Check(T, 'ccc'), true)
+    Assert.IsEqual(Value.Check(T, 'dddd'), true)
   })
 
   it('Should validate infinite pattern 5', () => {
@@ -138,11 +138,11 @@ describe('value/check/TemplateLiteral', () => {
       Type.Literal('A'),
       Type.Number()
     ])
-    Assert.isEqual(Value.Check(T, 'A1'), true)
-    Assert.isEqual(Value.Check(T, 'A22'), true)
-    Assert.isEqual(Value.Check(T, 'A333'), true)
-    Assert.isEqual(Value.Check(T, 'A4444'), true)
-    Assert.isEqual(Value.Check(T, 'X'), false)
+    Assert.IsEqual(Value.Check(T, 'A1'), true)
+    Assert.IsEqual(Value.Check(T, 'A22'), true)
+    Assert.IsEqual(Value.Check(T, 'A333'), true)
+    Assert.IsEqual(Value.Check(T, 'A4444'), true)
+    Assert.IsEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate infinite pattern 6', () => {
     // prettier-ignore
@@ -150,11 +150,11 @@ describe('value/check/TemplateLiteral', () => {
       Type.Literal('A'),
       Type.Integer()
     ])
-    Assert.isEqual(Value.Check(T, 'A1'), true)
-    Assert.isEqual(Value.Check(T, 'A22'), true)
-    Assert.isEqual(Value.Check(T, 'A333'), true)
-    Assert.isEqual(Value.Check(T, 'A4444'), true)
-    Assert.isEqual(Value.Check(T, 'X'), false)
+    Assert.IsEqual(Value.Check(T, 'A1'), true)
+    Assert.IsEqual(Value.Check(T, 'A22'), true)
+    Assert.IsEqual(Value.Check(T, 'A333'), true)
+    Assert.IsEqual(Value.Check(T, 'A4444'), true)
+    Assert.IsEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate infinite pattern 7', () => {
     // prettier-ignore
@@ -162,11 +162,11 @@ describe('value/check/TemplateLiteral', () => {
       Type.Literal('A'),
       Type.BigInt()
     ])
-    Assert.isEqual(Value.Check(T, 'A1'), true)
-    Assert.isEqual(Value.Check(T, 'A22'), true)
-    Assert.isEqual(Value.Check(T, 'A333'), true)
-    Assert.isEqual(Value.Check(T, 'A4444'), true)
-    Assert.isEqual(Value.Check(T, 'X'), false)
+    Assert.IsEqual(Value.Check(T, 'A1'), true)
+    Assert.IsEqual(Value.Check(T, 'A22'), true)
+    Assert.IsEqual(Value.Check(T, 'A333'), true)
+    Assert.IsEqual(Value.Check(T, 'A4444'), true)
+    Assert.IsEqual(Value.Check(T, 'X'), false)
   })
   it('Should validate infinite pattern 8', () => {
     // prettier-ignore
@@ -174,14 +174,14 @@ describe('value/check/TemplateLiteral', () => {
       Type.Literal('A'),
       Type.String()
     ])
-    Assert.isEqual(Value.Check(T, 'A1'), true)
-    Assert.isEqual(Value.Check(T, 'A22'), true)
-    Assert.isEqual(Value.Check(T, 'A333'), true)
-    Assert.isEqual(Value.Check(T, 'A4444'), true)
-    Assert.isEqual(Value.Check(T, 'Aa'), true)
-    Assert.isEqual(Value.Check(T, 'Abb'), true)
-    Assert.isEqual(Value.Check(T, 'Accc'), true)
-    Assert.isEqual(Value.Check(T, 'Adddd'), true)
-    Assert.isEqual(Value.Check(T, 'X'), false)
+    Assert.IsEqual(Value.Check(T, 'A1'), true)
+    Assert.IsEqual(Value.Check(T, 'A22'), true)
+    Assert.IsEqual(Value.Check(T, 'A333'), true)
+    Assert.IsEqual(Value.Check(T, 'A4444'), true)
+    Assert.IsEqual(Value.Check(T, 'Aa'), true)
+    Assert.IsEqual(Value.Check(T, 'Abb'), true)
+    Assert.IsEqual(Value.Check(T, 'Accc'), true)
+    Assert.IsEqual(Value.Check(T, 'Adddd'), true)
+    Assert.IsEqual(Value.Check(T, 'X'), false)
   })
 })
diff --git a/test/runtime/value/check/tuple.ts b/test/runtime/value/check/tuple.ts
index 2fc512f98..1a9f039c8 100644
--- a/test/runtime/value/check/tuple.ts
+++ b/test/runtime/value/check/tuple.ts
@@ -7,34 +7,34 @@ describe('value/check/Tuple', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
 
   it('Should fail when tuple is less than length', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
     const value = [1]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 
   it('Should fail when tuple is greater than length', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
     const value = [1, 1, 2]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 
   it('Should pass empty tuple', () => {
     const T = Type.Tuple([])
     const value = [] as any[]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
 
   it('Should fail empty tuple', () => {
     const T = Type.Tuple([])
     const value = [1]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/uint8array.ts b/test/runtime/value/check/uint8array.ts
index 21f526a79..c989fa966 100644
--- a/test/runtime/value/check/uint8array.ts
+++ b/test/runtime/value/check/uint8array.ts
@@ -7,27 +7,27 @@ describe('value/check/Uint8Array', () => {
     const T = Type.Uint8Array()
     const value = new Uint8Array(4)
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
 
   it('Should fail Uint8Array', () => {
     const T = Type.Uint8Array()
     const value = [0, 1, 2, 3]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 
   it('Should fail Uint8Array with undefined', () => {
     const T = Type.Uint8Array()
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 
   it('Should fail Uint8Array with null', () => {
     const T = Type.Uint8Array()
     const value = null
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/undefined.ts b/test/runtime/value/check/undefined.ts
index d25ec8303..bdc0099c0 100644
--- a/test/runtime/value/check/undefined.ts
+++ b/test/runtime/value/check/undefined.ts
@@ -7,41 +7,41 @@ describe('value/check/Undefined', () => {
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should pass undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/union.ts b/test/runtime/value/check/union.ts
index bbd29951e..c5a31b653 100644
--- a/test/runtime/value/check/union.ts
+++ b/test/runtime/value/check/union.ts
@@ -20,25 +20,25 @@ describe('value/check/Union', () => {
   it('Should pass union A', () => {
     const value = { type: 'A', x: 1, y: 1 }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
 
   it('Should pass union B', () => {
     const value = { type: 'B', x: true, y: false }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
 
   it('Should fail union A', () => {
     const value = { type: 'A', x: true, y: false }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 
   it('Should fail union B', () => {
     const value = { type: 'B', x: 1, y: 1 }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 
   it('Should pass union A with optional properties', () => {
@@ -55,7 +55,7 @@ describe('value/check/Union', () => {
     const T = Type.Union([A, B])
     const value = { type: 'A' }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
 
   it('Should fail union A with invalid optional properties', () => {
@@ -72,6 +72,6 @@ describe('value/check/Union', () => {
     const T = Type.Union([A, B])
     const value = { type: 'A', x: true, y: false }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 })
diff --git a/test/runtime/value/check/unknown.ts b/test/runtime/value/check/unknown.ts
index bb9943933..7026f3dcc 100644
--- a/test/runtime/value/check/unknown.ts
+++ b/test/runtime/value/check/unknown.ts
@@ -7,41 +7,41 @@ describe('value/check/Unknown', () => {
   it('Should pass string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should pass number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should pass boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should pass null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should pass undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should pass object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should pass array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should pass Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
 })
diff --git a/test/runtime/value/check/void.ts b/test/runtime/value/check/void.ts
index 0c1b26eb9..92ff30b74 100644
--- a/test/runtime/value/check/void.ts
+++ b/test/runtime/value/check/void.ts
@@ -7,41 +7,41 @@ describe('value/check/Void', () => {
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should pass null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should pass undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should fail Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
 })
diff --git a/test/runtime/value/clone/clone.ts b/test/runtime/value/clone/clone.ts
index 8655dd1ba..15ecb1f57 100644
--- a/test/runtime/value/clone/clone.ts
+++ b/test/runtime/value/clone/clone.ts
@@ -7,44 +7,36 @@ describe('value/clone/Clone', () => {
   // --------------------------------------------
   it('Should clone null', () => {
     const R = Value.Clone(null)
-    Assert.isEqual(R, null)
+    Assert.IsEqual(R, null)
   })
-
   it('Should clone undefined', () => {
     const R = Value.Clone(undefined)
-    Assert.isEqual(R, undefined)
+    Assert.IsEqual(R, undefined)
   })
-
   it('Should clone number', () => {
     const R = Value.Clone(1)
-    Assert.isEqual(R, 1)
+    Assert.IsEqual(R, 1)
   })
-
   it('Should clone bigint', () => {
     const R = Value.Clone(1n)
-    Assert.isEqual(R, 1n)
+    Assert.IsEqual(R, 1n)
   })
-
   it('Should clone boolean', () => {
     const R = Value.Clone(true)
-    Assert.isEqual(R, true)
+    Assert.IsEqual(R, true)
   })
-
   it('Should clone string', () => {
     const R = Value.Clone('hello')
-    Assert.isEqual(R, 'hello')
+    Assert.IsEqual(R, 'hello')
   })
-
   it('Should clone symbol', () => {
     const S = Symbol('hello')
     const R = Value.Clone(S)
-    Assert.isEqual(R, S)
+    Assert.IsEqual(R, S)
   })
-
   // --------------------------------------------
   // ObjectType
   // --------------------------------------------
-
   it('Should clone object #1', () => {
     const V = {
       x: 1,
@@ -52,9 +44,8 @@ describe('value/clone/Clone', () => {
       z: 3,
     }
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
-
   it('Should clone object #2', () => {
     const V = {
       x: 1,
@@ -67,9 +58,8 @@ describe('value/clone/Clone', () => {
       },
     }
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
-
   it('Should clone object #3', () => {
     const V = {
       x: 1,
@@ -78,7 +68,7 @@ describe('value/clone/Clone', () => {
       w: [0, 1, 2, 3, 4],
     }
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
   // --------------------------------------------
   // ArrayType
@@ -86,7 +76,7 @@ describe('value/clone/Clone', () => {
   it('Should clone array #1', () => {
     const V = [1, 2, 3, 4]
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
   it('Should clone array #2', () => {
     const V = [
@@ -96,7 +86,7 @@ describe('value/clone/Clone', () => {
       [1, 2, 3],
     ]
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
   it('Should clone array #3', () => {
     const V = [
@@ -106,72 +96,61 @@ describe('value/clone/Clone', () => {
       { x: 1, y: 2, z: 3 },
     ]
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
-
   it('Should clone Int8Array', () => {
     const V = new Int8Array([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
-
   it('Should clone Uint8Array', () => {
     const V = new Uint8Array([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
-
   it('Should clone Uint8ClampedArray', () => {
     const V = new Uint8ClampedArray([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
-
   it('Should clone Int16Array', () => {
     const V = new Int16Array([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
-
   it('Should clone Uint16Array', () => {
     const V = new Uint16Array([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
-
   it('Should clone Int32Array', () => {
     const V = new Int32Array([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
-
   it('Should clone Uint32Array', () => {
     const V = new Int32Array([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
-
   it('Should clone Float32Array', () => {
     const V = new Float32Array([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
-
   it('Should clone Float64Array', () => {
     const V = new Float64Array([1, 2, 3, 4])
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
-
   it('Should clone BigInt64Array', () => {
     const V = new BigInt64Array([1n, 2n, 3n, 4n])
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
-
   it('Should clone BigUint64Array', () => {
     const V = new BigUint64Array([1n, 2n, 3n, 4n])
     const R = Value.Clone(V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
 })
diff --git a/test/runtime/value/convert/any.ts b/test/runtime/value/convert/any.ts
index 81f57de58..96a6d5841 100644
--- a/test/runtime/value/convert/any.ts
+++ b/test/runtime/value/convert/any.ts
@@ -7,36 +7,36 @@ describe('value/convert/Any', () => {
   it('Should convert null', () => {
     const V = null
     const R = Value.Convert(T, V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
   it('Should convert undefined', () => {
     const V = undefined
     const R = Value.Convert(T, V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
   it('Should convert string', () => {
     const V = 'hello'
     const R = Value.Convert(T, V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
   it('Should convert number', () => {
     const V = 42
     const R = Value.Convert(T, V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
   it('Should convert boolean', () => {
     const V = true
     const R = Value.Convert(T, V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
   it('Should convert object', () => {
     const V = { x: 1 }
     const R = Value.Convert(T, V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
   it('Should convert array', () => {
     const V = [1, 2, 3]
     const R = Value.Convert(T, V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
 })
diff --git a/test/runtime/value/convert/array.ts b/test/runtime/value/convert/array.ts
index be8ed6af6..c8a040f3d 100644
--- a/test/runtime/value/convert/array.ts
+++ b/test/runtime/value/convert/array.ts
@@ -6,27 +6,27 @@ describe('value/convert/Array', () => {
   it('Should convert array of number', () => {
     const T = Type.Array(Type.Number())
     const R = Value.Convert(T, [1, 3.14, '1', '3.14', true, false, 'true', 'false', 'hello'])
-    Assert.isEqual(R, [1, 3.14, 1, 3.14, 1, 0, 1, 0, 'hello'])
+    Assert.IsEqual(R, [1, 3.14, 1, 3.14, 1, 0, 1, 0, 'hello'])
   })
   it('Should convert array of boolean', () => {
     const T = Type.Array(Type.Boolean())
     const R = Value.Convert(T, [1, 3.14, '1', '3.14', true, false, 'true', 'false', 'hello'])
-    Assert.isEqual(R, [true, 3.14, true, '3.14', true, false, true, false, 'hello'])
+    Assert.IsEqual(R, [true, 3.14, true, '3.14', true, false, true, false, 'hello'])
   })
   it('Should convert array of string', () => {
     const T = Type.Array(Type.String())
     const R = Value.Convert(T, [1, 3.14, '1', '3.14', true, false, 'true', 'false', 'hello'])
-    Assert.isEqual(R, ['1', '3.14', '1', '3.14', 'true', 'false', 'true', 'false', 'hello'])
+    Assert.IsEqual(R, ['1', '3.14', '1', '3.14', 'true', 'false', 'true', 'false', 'hello'])
   })
   it('Should convert array of date', () => {
     const T = Type.Array(Type.Date())
     const R = Value.Convert(T, [1, '1', true, false, 'true', 'false', 'hello']) as any[]
-    Assert.isEqual(R[0].getTime(), 1)
-    Assert.isEqual(R[1].getTime(), 1)
-    Assert.isEqual(R[2].getTime(), 1)
-    Assert.isEqual(R[3].getTime(), 0)
-    Assert.isEqual(R[4].getTime(), 1)
-    Assert.isEqual(R[5].getTime(), 0)
-    Assert.isEqual(R[6], 'hello')
+    Assert.IsEqual(R[0].getTime(), 1)
+    Assert.IsEqual(R[1].getTime(), 1)
+    Assert.IsEqual(R[2].getTime(), 1)
+    Assert.IsEqual(R[3].getTime(), 0)
+    Assert.IsEqual(R[4].getTime(), 1)
+    Assert.IsEqual(R[5].getTime(), 0)
+    Assert.IsEqual(R[6], 'hello')
   })
 })
diff --git a/test/runtime/value/convert/async-iterator.ts b/test/runtime/value/convert/async-iterator.ts
new file mode 100644
index 000000000..2429faf93
--- /dev/null
+++ b/test/runtime/value/convert/async-iterator.ts
@@ -0,0 +1,20 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+// --------------------------------------------------------
+// non-convertable pass through
+// --------------------------------------------------------
+describe('value/convert/AsyncIterator', () => {
+  const T = Type.AsyncIterator(Type.Any())
+  it('Should passthrough 1', () => {
+    const V = (async function* () {})()
+    const R = Value.Convert(T, V)
+    Assert.IsEqual(R, V)
+  })
+  it('Should passthrough 2', () => {
+    const V = 1
+    const R = Value.Convert(T, V)
+    Assert.IsEqual(R, V)
+  })
+})
diff --git a/test/runtime/value/convert/bigint.ts b/test/runtime/value/convert/bigint.ts
index 83a069632..c5057ab00 100644
--- a/test/runtime/value/convert/bigint.ts
+++ b/test/runtime/value/convert/bigint.ts
@@ -6,41 +6,41 @@ describe('value/convert/BigInt', () => {
   it('Should convert bitint from string 1', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, '1')
-    Assert.isEqual(R, BigInt(1))
+    Assert.IsEqual(R, BigInt(1))
   })
   it('Should convert bigint from string 2', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, '3.14')
-    Assert.isEqual(R, BigInt(3))
+    Assert.IsEqual(R, BigInt(3))
   })
   it('Should convert bitint from string 3', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, 'true')
-    Assert.isEqual(R, BigInt(1))
+    Assert.IsEqual(R, BigInt(1))
   })
   it('Should convert bigint from string 4', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, 'false')
-    Assert.isEqual(R, BigInt(0))
+    Assert.IsEqual(R, BigInt(0))
   })
   it('Should convert bitint from number 1', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, 1)
-    Assert.isEqual(R, BigInt(1))
+    Assert.IsEqual(R, BigInt(1))
   })
   it('Should convert bigint from number 2', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, 3.14)
-    Assert.isEqual(R, BigInt(3))
+    Assert.IsEqual(R, BigInt(3))
   })
   it('Should convert bitint from boolean 1', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, true)
-    Assert.isEqual(R, BigInt(1))
+    Assert.IsEqual(R, BigInt(1))
   })
   it('Should convert bigint from boolean 2', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, false)
-    Assert.isEqual(R, BigInt(0))
+    Assert.IsEqual(R, BigInt(0))
   })
 })
diff --git a/test/runtime/value/convert/boolean.ts b/test/runtime/value/convert/boolean.ts
index 2a72c08ee..8e91f6d5f 100644
--- a/test/runtime/value/convert/boolean.ts
+++ b/test/runtime/value/convert/boolean.ts
@@ -6,47 +6,47 @@ describe('value/convert/Boolean', () => {
   it('Should convert from string 1', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, '1')
-    Assert.isEqual(R, true)
+    Assert.IsEqual(R, true)
   })
   it('Should convert from string 2', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, '3.14')
-    Assert.isEqual(R, '3.14')
+    Assert.IsEqual(R, '3.14')
   })
   it('Should convert from string 3', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, 'true')
-    Assert.isEqual(R, true)
+    Assert.IsEqual(R, true)
   })
   it('Should convert from string 4', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, 'false')
-    Assert.isEqual(R, false)
+    Assert.IsEqual(R, false)
   })
   it('Should convert from number 1', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, 1)
-    Assert.isEqual(R, true)
+    Assert.IsEqual(R, true)
   })
   it('Should convert from number 2', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, 3.14)
-    Assert.isEqual(R, 3.14)
+    Assert.IsEqual(R, 3.14)
   })
   it('Should convert from number 3', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, 1.1)
-    Assert.isEqual(R, 1.1)
+    Assert.IsEqual(R, 1.1)
   })
   it('Should convert from boolean 1', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, true)
-    Assert.isEqual(R, true)
+    Assert.IsEqual(R, true)
   })
   it('Should convert from boolean 2', () => {
     const T = Type.Boolean()
     const R = Value.Convert(T, false)
-    Assert.isEqual(R, false)
+    Assert.IsEqual(R, false)
   })
   // ----------------------------------------------------------
   // Casts
@@ -54,101 +54,101 @@ describe('value/convert/Boolean', () => {
   it('Should convert string #1', () => {
     const value = 'hello'
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.isEqual(result, 'hello')
+    Assert.IsEqual(result, 'hello')
   })
   it('Should convert string #2', () => {
     const value = 'true'
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should convert string #3', () => {
     const value = 'TRUE'
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should convert string #4', () => {
     const value = 'false'
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should convert string #5', () => {
     const value = '0'
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should convert string #6', () => {
     const value = '1'
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should convert string #7', () => {
     const value = '0'
     const result = Value.Convert(Type.Boolean({ default: true }), value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should convert string #8', () => {
     const value = '1'
     const result = Value.Convert(Type.Boolean({ default: false }), value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should convert string #8', () => {
     const value = '2'
     const result = Value.Convert(Type.Boolean({ default: true }), value)
-    Assert.isEqual(result, '2')
+    Assert.IsEqual(result, '2')
   })
   it('Should convert number #1', () => {
     const value = 0
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should convert number #2', () => {
     const value = 1n
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should convert number #3', () => {
     const value = 1
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should convert number #4', () => {
     const value = 2
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.isEqual(result, 2)
+    Assert.IsEqual(result, 2)
   })
   it('Should convert number #5', () => {
     const value = 0
     const result = Value.Convert(Type.Boolean({ default: true }), value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should convert number #6', () => {
     const value = 1
     const result = Value.Convert(Type.Boolean({ default: false }), value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should convert number #7', () => {
     const value = 2
     const result = Value.Convert(Type.Boolean({ default: true }), value)
-    Assert.isEqual(result, 2)
+    Assert.IsEqual(result, 2)
   })
   it('Should convert true', () => {
     const value = true
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.isEqual(result, true)
+    Assert.IsEqual(result, true)
   })
   it('Should convert false', () => {
     const value = false
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.isEqual(result, false)
+    Assert.IsEqual(result, false)
   })
   it('Should convert object', () => {
     const value = {}
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.isEqual(result, {})
+    Assert.IsEqual(result, {})
   })
   it('Should convert array', () => {
     const value = [] as any[]
     const result = Value.Convert(Type.Boolean(), value)
-    Assert.isEqual(result, [])
+    Assert.IsEqual(result, [])
   })
 })
diff --git a/test/runtime/value/convert/composite.ts b/test/runtime/value/convert/composite.ts
index 5c7678984..7114db8bd 100644
--- a/test/runtime/value/convert/composite.ts
+++ b/test/runtime/value/convert/composite.ts
@@ -11,6 +11,6 @@ describe('value/convert/Composite', () => {
       Type.Object({ z: Type.Boolean() })
     ])
     const R = Value.Convert(T, { x: '42', y: 'true', z: 'hello' })
-    Assert.isEqual(R, { x: 42, y: true, z: 'hello' })
+    Assert.IsEqual(R, { x: 42, y: true, z: 'hello' })
   })
 })
diff --git a/test/runtime/value/convert/constructor.ts b/test/runtime/value/convert/constructor.ts
new file mode 100644
index 000000000..f1769c245
--- /dev/null
+++ b/test/runtime/value/convert/constructor.ts
@@ -0,0 +1,20 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+// --------------------------------------------------------
+// non-convertable pass through
+// --------------------------------------------------------
+describe('value/convert/Constructor', () => {
+  const T = Type.Constructor([], Type.Any())
+  it('Should passthrough 1', () => {
+    const V = function () {}
+    const R = Value.Convert(T, V)
+    Assert.IsEqual(R, V)
+  })
+  it('Should passthrough 2', () => {
+    const V = 1
+    const R = Value.Convert(T, V)
+    Assert.IsEqual(R, V)
+  })
+})
diff --git a/test/runtime/value/convert/custom.ts b/test/runtime/value/convert/custom.ts
index 5bc20d59c..e284fbe82 100644
--- a/test/runtime/value/convert/custom.ts
+++ b/test/runtime/value/convert/custom.ts
@@ -7,18 +7,18 @@ describe('value/convert/Custom', () => {
     const Custom = TypeSystem.Type('type/convert/Custom/1', () => true)
     const T = Custom()
     const R = Value.Convert(T, true)
-    Assert.isEqual(R, true)
+    Assert.IsEqual(R, true)
   })
   it('Should not convert 2', () => {
     const Custom = TypeSystem.Type('type/convert/Custom/2', () => true)
     const T = Custom()
     const R = Value.Convert(T, 42)
-    Assert.isEqual(R, 42)
+    Assert.IsEqual(R, 42)
   })
   it('Should not convert 3', () => {
     const Custom = TypeSystem.Type('type/convert/Custom/3', () => true)
     const T = Custom()
     const R = Value.Convert(T, 'hello')
-    Assert.isEqual(R, 'hello')
+    Assert.IsEqual(R, 'hello')
   })
 })
diff --git a/test/runtime/value/convert/date.ts b/test/runtime/value/convert/date.ts
index 171b5fb4c..abe6066a8 100644
--- a/test/runtime/value/convert/date.ts
+++ b/test/runtime/value/convert/date.ts
@@ -5,38 +5,38 @@ import { Assert } from '../../assert/index'
 describe('value/convert/Date', () => {
   it('Should convert from number', () => {
     const result = Value.Convert(Type.Date(), 123) as Date
-    Assert.isEqual(result.getTime(), 123)
+    Assert.IsEqual(result.getTime(), 123)
   })
   it('Should convert from numeric string', () => {
     const result = Value.Convert(Type.Date(), '123') as Date
-    Assert.isEqual(result.getTime(), 123)
+    Assert.IsEqual(result.getTime(), 123)
   })
   it('Should convert from boolean true (interpretted as numeric 1)', () => {
     const result = Value.Convert(Type.Date(), true) as Date
-    Assert.isEqual(result.getTime(), 1)
+    Assert.IsEqual(result.getTime(), 1)
   })
   it('Should convert from datetime string', () => {
     const result = Value.Convert(Type.Date(), '1980-02-03T01:02:03.000Z') as Date
-    Assert.isEqual(result.toISOString(), '1980-02-03T01:02:03.000Z')
+    Assert.IsEqual(result.toISOString(), '1980-02-03T01:02:03.000Z')
   })
   it('Should convert from datetime string without timezone', () => {
     const result = Value.Convert(Type.Date(), '1980-02-03T01:02:03') as Date
-    Assert.isEqual(result.toISOString(), '1980-02-03T01:02:03.000Z')
+    Assert.IsEqual(result.toISOString(), '1980-02-03T01:02:03.000Z')
   })
   it('Should convert from time with timezone', () => {
     const result = Value.Convert(Type.Date(), '01:02:03.000Z') as Date
-    Assert.isEqual(result.toISOString(), '1970-01-01T01:02:03.000Z')
+    Assert.IsEqual(result.toISOString(), '1970-01-01T01:02:03.000Z')
   })
   it('Should convert from time without timezone', () => {
     const result = Value.Convert(Type.Date(), '01:02:03') as Date
-    Assert.isEqual(result.toISOString(), '1970-01-01T01:02:03.000Z')
+    Assert.IsEqual(result.toISOString(), '1970-01-01T01:02:03.000Z')
   })
   it('Should convert from date string', () => {
     const result = Value.Convert(Type.Date(), '1980-02-03') as Date
-    Assert.isEqual(result.toISOString(), '1980-02-03T00:00:00.000Z')
+    Assert.IsEqual(result.toISOString(), '1980-02-03T00:00:00.000Z')
   })
   it('Should convert invalid strings to unix epoch 0', () => {
     const result = Value.Convert(Type.Date(), 'invalid-date') as Date
-    Assert.isEqual(result, 'invalid-date')
+    Assert.IsEqual(result, 'invalid-date')
   })
 })
diff --git a/test/runtime/value/convert/function.ts b/test/runtime/value/convert/function.ts
new file mode 100644
index 000000000..004aaa6be
--- /dev/null
+++ b/test/runtime/value/convert/function.ts
@@ -0,0 +1,20 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+// --------------------------------------------------------
+// non-convertable pass through
+// --------------------------------------------------------
+describe('value/convert/Function', () => {
+  const T = Type.Function([], Type.Any())
+  it('Should passthrough 1', () => {
+    const V = function () {}
+    const R = Value.Convert(T, V)
+    Assert.IsEqual(R, V)
+  })
+  it('Should passthrough 2', () => {
+    const V = 1
+    const R = Value.Convert(T, V)
+    Assert.IsEqual(R, V)
+  })
+})
diff --git a/test/runtime/value/convert/index.ts b/test/runtime/value/convert/index.ts
index a14997a97..8514f77cc 100644
--- a/test/runtime/value/convert/index.ts
+++ b/test/runtime/value/convert/index.ts
@@ -1,21 +1,26 @@
 import './any'
 import './array'
+import './async-iterator'
 import './bigint'
 import './boolean'
 import './composite'
+import './constructor'
 import './custom'
 import './date'
 import './enum'
+import './function'
 import './integer'
+import './iterator'
 import './keyof'
 import './literal'
 import './never'
 import './null'
 import './number'
 import './object'
+import './promise'
 import './recursive'
 import './record'
-import './regex'
+import './regexp'
 import './string'
 import './symbol'
 import './tuple'
diff --git a/test/runtime/value/convert/integer.ts b/test/runtime/value/convert/integer.ts
index 727bddf0c..1cecc93eb 100644
--- a/test/runtime/value/convert/integer.ts
+++ b/test/runtime/value/convert/integer.ts
@@ -6,27 +6,27 @@ describe('value/convert/Integer', () => {
   it('Should convert from string 1', () => {
     const T = Type.Integer()
     const R = Value.Convert(T, '3.14')
-    Assert.isEqual(R, 3)
+    Assert.IsEqual(R, 3)
   })
   it('Should convert from string 2', () => {
     const T = Type.Integer()
     const R = Value.Convert(T, '42')
-    Assert.isEqual(R, 42)
+    Assert.IsEqual(R, 42)
   })
   it('Should convert from boolean 1', () => {
     const T = Type.Integer()
     const R = Value.Convert(T, true)
-    Assert.isEqual(R, 1)
+    Assert.IsEqual(R, 1)
   })
   it('Should convert from boolean 2', () => {
     const T = Type.Integer()
     const R = Value.Convert(T, false)
-    Assert.isEqual(R, 0)
+    Assert.IsEqual(R, 0)
   })
   it('Should convert from number 1', () => {
     const T = Type.Integer()
     const R = Value.Convert(T, 3.14)
-    Assert.isEqual(R, 3)
+    Assert.IsEqual(R, 3)
   })
   // ----------------------------------------------------------
   // Casts
@@ -34,46 +34,46 @@ describe('value/convert/Integer', () => {
   it('Should convert string #1', () => {
     const value = 'hello'
     const result = Value.Convert(Type.Integer(), value)
-    Assert.isEqual(result, 'hello')
+    Assert.IsEqual(result, 'hello')
   })
   it('Should convert string #2', () => {
     const value = '3.14'
     const result = Value.Convert(Type.Integer(), value)
-    Assert.isEqual(result, 3)
+    Assert.IsEqual(result, 3)
   })
   it('Should convert string #3', () => {
     const value = '-0'
     const result = Value.Convert(Type.Integer(), value)
-    Assert.isEqual(result, 0)
+    Assert.IsEqual(result, 0)
   })
   it('Should convert string #4', () => {
     const value = '-100'
     const result = Value.Convert(Type.Integer(), value)
-    Assert.isEqual(result, -100)
+    Assert.IsEqual(result, -100)
   })
   it('Should convert number', () => {
     const value = 42
     const result = Value.Convert(Type.Integer(), value)
-    Assert.isEqual(result, 42)
+    Assert.IsEqual(result, 42)
   })
   it('Should convert true', () => {
     const value = true
     const result = Value.Convert(Type.Integer(), value)
-    Assert.isEqual(result, 1)
+    Assert.IsEqual(result, 1)
   })
   it('Should convert false', () => {
     const value = false
     const result = Value.Convert(Type.Integer(), value)
-    Assert.isEqual(result, 0)
+    Assert.IsEqual(result, 0)
   })
   it('Should convert object', () => {
     const value = {}
     const result = Value.Convert(Type.Integer(), value)
-    Assert.isEqual(result, {})
+    Assert.IsEqual(result, {})
   })
   it('Should convert array', () => {
     const value = [] as any[]
     const result = Value.Convert(Type.Integer(), value)
-    Assert.isEqual(result, [])
+    Assert.IsEqual(result, [])
   })
 })
diff --git a/test/runtime/value/convert/iterator.ts b/test/runtime/value/convert/iterator.ts
new file mode 100644
index 000000000..f9045d664
--- /dev/null
+++ b/test/runtime/value/convert/iterator.ts
@@ -0,0 +1,20 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+// --------------------------------------------------------
+// non-convertable pass through
+// --------------------------------------------------------
+describe('value/convert/Iterator', () => {
+  const T = Type.Iterator(Type.Any())
+  it('Should passthrough 1', () => {
+    const V = (function* () {})()
+    const R = Value.Convert(T, V)
+    Assert.IsEqual(R, V)
+  })
+  it('Should passthrough 2', () => {
+    const V = 1
+    const R = Value.Convert(T, V)
+    Assert.IsEqual(R, V)
+  })
+})
diff --git a/test/runtime/value/convert/literal.ts b/test/runtime/value/convert/literal.ts
index c46ba3dc6..f161b1720 100644
--- a/test/runtime/value/convert/literal.ts
+++ b/test/runtime/value/convert/literal.ts
@@ -6,80 +6,80 @@ describe('value/convert/Literal:String', () => {
   it('Should convert from number 1', () => {
     const T = Type.Literal('1')
     const R = Value.Convert(T, 1)
-    Assert.isEqual(R, '1')
+    Assert.IsEqual(R, '1')
   })
   it('Should convert from number 2', () => {
     const T = Type.Literal('1')
     const R = Value.Convert(T, 2)
-    Assert.isEqual(R, 2)
+    Assert.IsEqual(R, 2)
   })
   it('Should convert from boolean', () => {
     const T = Type.Literal('true')
     const R = Value.Convert(T, true)
-    Assert.isEqual(R, 'true')
+    Assert.IsEqual(R, 'true')
   })
 })
 describe('value/convert/Literal:Number', () => {
   it('Should convert from number 1', () => {
     const T = Type.Literal(3.14)
     const R = Value.Convert(T, '3.14')
-    Assert.isEqual(R, 3.14)
+    Assert.IsEqual(R, 3.14)
   })
   it('Should convert from number 2', () => {
     const T = Type.Literal(3.14)
     const R = Value.Convert(T, '3.15')
-    Assert.isEqual(R, '3.15')
+    Assert.IsEqual(R, '3.15')
   })
   it('Should convert from boolean 1', () => {
     const T = Type.Literal(1)
     const R = Value.Convert(T, true)
-    Assert.isEqual(R, 1)
+    Assert.IsEqual(R, 1)
   })
   it('Should convert from boolean 2', () => {
     const T = Type.Literal(0)
     const R = Value.Convert(T, false)
-    Assert.isEqual(R, 0)
+    Assert.IsEqual(R, 0)
   })
   it('Should convert from boolean 3', () => {
     const T = Type.Literal(2)
     const R = Value.Convert(T, true)
-    Assert.isEqual(R, true)
+    Assert.IsEqual(R, true)
   })
 })
 describe('value/convert/Literal:Boolean', () => {
   it('Should convert from number 1', () => {
     const T = Type.Literal(true)
     const R = Value.Convert(T, 3.14)
-    Assert.isEqual(R, 3.14)
+    Assert.IsEqual(R, 3.14)
   })
   it('Should convert from number 2', () => {
     const T = Type.Literal(true)
     const R = Value.Convert(T, 1)
-    Assert.isEqual(R, true)
+    Assert.IsEqual(R, true)
   })
   it('Should convert from string 1', () => {
     const T = Type.Literal(true)
     const R = Value.Convert(T, 'true')
-    Assert.isEqual(R, true)
+    Assert.IsEqual(R, true)
   })
   it('Should convert from string 2', () => {
     const T = Type.Literal(false)
     const R = Value.Convert(T, 'false')
-    Assert.isEqual(R, false)
+    Assert.IsEqual(R, false)
   })
   it('Should convert from string 3', () => {
     const T = Type.Literal(true)
     const R = Value.Convert(T, '1')
-    Assert.isEqual(R, true)
+    Assert.IsEqual(R, true)
   })
   it('Should convert from string 4', () => {
     const T = Type.Literal(false)
     const R = Value.Convert(T, '0')
-    Assert.isEqual(R, false)
+    Assert.IsEqual(R, false)
   })
   it('Should convert from string 5', () => {
     const T = Type.Literal(false)
     const R = Value.Convert(T, '2')
-    Assert.isEqual(R, '2')
+    Assert.IsEqual(R, '2')
   })
 })
diff --git a/test/runtime/value/convert/never.ts b/test/runtime/value/convert/never.ts
index 5f6d0c4a6..f0cea44bd 100644
--- a/test/runtime/value/convert/never.ts
+++ b/test/runtime/value/convert/never.ts
@@ -6,16 +6,16 @@ describe('value/convert/Never', () => {
   it('Should not convert 1', () => {
     const T = Type.Never()
     const R = Value.Convert(T, true)
-    Assert.isEqual(R, true)
+    Assert.IsEqual(R, true)
   })
   it('Should not convert 2', () => {
     const T = Type.Never()
     const R = Value.Convert(T, 42)
-    Assert.isEqual(R, 42)
+    Assert.IsEqual(R, 42)
   })
   it('Should not convert 3', () => {
     const T = Type.Never()
     const R = Value.Convert(T, 'true')
-    Assert.isEqual(R, 'true')
+    Assert.IsEqual(R, 'true')
   })
 })
diff --git a/test/runtime/value/convert/null.ts b/test/runtime/value/convert/null.ts
index 12d5ab1ee..f490e8bec 100644
--- a/test/runtime/value/convert/null.ts
+++ b/test/runtime/value/convert/null.ts
@@ -6,14 +6,14 @@ describe('value/convert/Null', () => {
   const T = Type.Null()
   it('Should convert from string 1', () => {
     const R = Value.Convert(T, 'null')
-    Assert.isEqual(R, null)
+    Assert.IsEqual(R, null)
   })
   it('Should convert from string 2', () => {
     const R = Value.Convert(T, 'NULL')
-    Assert.isEqual(R, null)
+    Assert.IsEqual(R, null)
   })
   it('Should convert from string 3', () => {
     const R = Value.Convert(T, 'nil')
-    Assert.isEqual(R, 'nil')
+    Assert.IsEqual(R, 'nil')
   })
 })
diff --git a/test/runtime/value/convert/number.ts b/test/runtime/value/convert/number.ts
index 05636653c..1f1f62c4d 100644
--- a/test/runtime/value/convert/number.ts
+++ b/test/runtime/value/convert/number.ts
@@ -6,71 +6,70 @@ describe('value/convert/Number', () => {
   const T = Type.Number()
   it('Should convert from string 1', () => {
     const R = Value.Convert(T, '3.14')
-    Assert.isEqual(R, 3.14)
+    Assert.IsEqual(R, 3.14)
   })
   it('Should convert from string 2', () => {
     const R = Value.Convert(T, '42')
-    Assert.isEqual(R, 42)
+    Assert.IsEqual(R, 42)
   })
   it('Should convert from boolean 1', () => {
     const R = Value.Convert(T, true)
-    Assert.isEqual(R, 1)
+    Assert.IsEqual(R, 1)
   })
   it('Should convert from boolean 2', () => {
     const R = Value.Convert(T, false)
-    Assert.isEqual(R, 0)
+    Assert.IsEqual(R, 0)
   })
   it('Should convert from number 1', () => {
     const R = Value.Convert(T, 3.14)
-    Assert.isEqual(R, 3.14)
+    Assert.IsEqual(R, 3.14)
   })
-
   // ----------------------------------------------------------
   // Casts
   // ----------------------------------------------------------
   it('Should convert string #1', () => {
     const value = 'hello'
     const result = Value.Convert(Type.Number(), value)
-    Assert.isEqual(result, 'hello')
+    Assert.IsEqual(result, 'hello')
   })
   it('Should convert string #2', () => {
     const value = '3.14'
     const result = Value.Convert(Type.Number(), value)
-    Assert.isEqual(result, 3.14)
+    Assert.IsEqual(result, 3.14)
   })
   it('Should convert string #3', () => {
     const value = '-0'
     const result = Value.Convert(Type.Number(), value)
-    Assert.isEqual(result, 0)
+    Assert.IsEqual(result, 0)
   })
   it('Should convert string #4', () => {
     const value = '-100'
     const result = Value.Convert(Type.Number(), value)
-    Assert.isEqual(result, -100)
+    Assert.IsEqual(result, -100)
   })
   it('Should convert number', () => {
     const value = 42
     const result = Value.Convert(Type.Number(), value)
-    Assert.isEqual(result, 42)
+    Assert.IsEqual(result, 42)
   })
   it('Should convert true', () => {
     const value = true
     const result = Value.Convert(Type.Number(), value)
-    Assert.isEqual(result, 1)
+    Assert.IsEqual(result, 1)
   })
   it('Should convert false', () => {
     const value = false
     const result = Value.Convert(Type.Number(), value)
-    Assert.isEqual(result, 0)
+    Assert.IsEqual(result, 0)
   })
   it('Should convert object', () => {
     const value = {}
     const result = Value.Convert(Type.String(), value)
-    Assert.isEqual(result, {})
+    Assert.IsEqual(result, {})
   })
   it('Should convert array', () => {
     const value = [] as any[]
     const result = Value.Convert(Type.String(), value)
-    Assert.isEqual(result, [])
+    Assert.IsEqual(result, [])
   })
 })
diff --git a/test/runtime/value/convert/object.ts b/test/runtime/value/convert/object.ts
index 27dd6e824..fa5e4ed70 100644
--- a/test/runtime/value/convert/object.ts
+++ b/test/runtime/value/convert/object.ts
@@ -11,6 +11,6 @@ describe('value/convert/Object', () => {
       z: Type.Boolean()
     })
     const R = Value.Convert(T, { x: '42', y: 'true', z: 'hello' })
-    Assert.isEqual(R, { x: 42, y: true, z: 'hello' })
+    Assert.IsEqual(R, { x: 42, y: true, z: 'hello' })
   })
 })
diff --git a/test/runtime/value/convert/promise.ts b/test/runtime/value/convert/promise.ts
new file mode 100644
index 000000000..254301489
--- /dev/null
+++ b/test/runtime/value/convert/promise.ts
@@ -0,0 +1,21 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+// --------------------------------------------------------
+// non-convertable pass through
+// --------------------------------------------------------
+describe('value/convert/Promise', () => {
+  const T = Type.Promise(Type.Any())
+  it('Should pass-through 1', () => {
+    const V = Promise.resolve(1)
+    const R = Value.Convert(T, V)
+    console.log(R)
+    Assert.IsEqual(R, V)
+  })
+  it('Should passthrough 2', () => {
+    const V = 1
+    const R = Value.Convert(T, V)
+    Assert.IsEqual(R, V)
+  })
+})
diff --git a/test/runtime/value/convert/record.ts b/test/runtime/value/convert/record.ts
index e773e8f25..961684000 100644
--- a/test/runtime/value/convert/record.ts
+++ b/test/runtime/value/convert/record.ts
@@ -6,6 +6,6 @@ describe('value/convert/Record', () => {
   it('Should convert record value to numeric', () => {
     const T = Type.Record(Type.String(), Type.Number())
     const V = Value.Convert(T, { x: '42', y: '24', z: 'hello' })
-    Assert.isEqual(V, { x: 42, y: '24', z: 'hello' })
+    Assert.IsEqual(V, { x: 42, y: '24', z: 'hello' })
   })
 })
diff --git a/test/runtime/value/convert/regex.ts b/test/runtime/value/convert/regexp.ts
similarity index 100%
rename from test/runtime/value/convert/regex.ts
rename to test/runtime/value/convert/regexp.ts
diff --git a/test/runtime/value/convert/string.ts b/test/runtime/value/convert/string.ts
index 3580bbda7..5ff0a8726 100644
--- a/test/runtime/value/convert/string.ts
+++ b/test/runtime/value/convert/string.ts
@@ -6,27 +6,27 @@ describe('value/convert/String', () => {
   const T = Type.String()
   it('Should convert from number 1', () => {
     const R = Value.Convert(T, 3.14)
-    Assert.isEqual(R, '3.14')
+    Assert.IsEqual(R, '3.14')
   })
   it('Should convert from number 2', () => {
     const R = Value.Convert(T, 3)
-    Assert.isEqual(R, '3')
+    Assert.IsEqual(R, '3')
   })
   it('Should convert from boolean 1', () => {
     const R = Value.Convert(T, true)
-    Assert.isEqual(R, 'true')
+    Assert.IsEqual(R, 'true')
   })
   it('Should convert from boolean 2', () => {
     const R = Value.Convert(T, false)
-    Assert.isEqual(R, 'false')
+    Assert.IsEqual(R, 'false')
   })
   it('Should convert from bigint', () => {
     const R = Value.Convert(T, BigInt(12345))
-    Assert.isEqual(R, '12345')
+    Assert.IsEqual(R, '12345')
   })
   it('Should convert from symbol', () => {
     const R = Value.Convert(T, Symbol(12345))
-    Assert.isEqual(R, '12345')
+    Assert.IsEqual(R, '12345')
   })
   // ----------------------------------------------------------
   // Casts
@@ -34,36 +34,36 @@ describe('value/convert/String', () => {
   it('Should convert string', () => {
     const value = 'hello'
     const result = Value.Convert(Type.String(), value)
-    Assert.isEqual(result, 'hello')
+    Assert.IsEqual(result, 'hello')
   })
   it('Should convert number #1', () => {
     const value = 42
     const result = Value.Convert(Type.String(), value)
-    Assert.isEqual(result, '42')
+    Assert.IsEqual(result, '42')
   })
   it('Should convert number #2', () => {
     const value = 42n
     const result = Value.Convert(Type.String(), value)
-    Assert.isEqual(result, '42')
+    Assert.IsEqual(result, '42')
   })
   it('Should convert true', () => {
     const value = true
     const result = Value.Convert(Type.String(), value)
-    Assert.isEqual(result, 'true')
+    Assert.IsEqual(result, 'true')
   })
   it('Should convert false', () => {
     const value = false
     const result = Value.Convert(Type.String(), value)
-    Assert.isEqual(result, 'false')
+    Assert.IsEqual(result, 'false')
   })
   it('Should convert object', () => {
     const value = {}
     const result = Value.Convert(Type.String(), value)
-    Assert.isEqual(result, {})
+    Assert.IsEqual(result, {})
   })
   it('Should convert array', () => {
     const value = [] as any[]
     const result = Value.Convert(Type.String(), value)
-    Assert.isEqual(result, [])
+    Assert.IsEqual(result, [])
   })
 })
diff --git a/test/runtime/value/convert/symbol.ts b/test/runtime/value/convert/symbol.ts
index 096b9c3cd..ce453f6a9 100644
--- a/test/runtime/value/convert/symbol.ts
+++ b/test/runtime/value/convert/symbol.ts
@@ -6,10 +6,10 @@ describe('value/convert/Symbol', () => {
   const T = Type.Symbol()
   it('Should convert from number 1', () => {
     const R = Value.Convert(T, 3.14)
-    Assert.isEqual(R, '3.14')
+    Assert.IsEqual(R, '3.14')
   })
   it('Should convert from number 2', () => {
     const R = Value.Convert(T, 3)
-    Assert.isEqual(R, '3')
+    Assert.IsEqual(R, '3')
   })
 })
diff --git a/test/runtime/value/convert/tuple.ts b/test/runtime/value/convert/tuple.ts
index 6047f3fc1..366ef8838 100644
--- a/test/runtime/value/convert/tuple.ts
+++ b/test/runtime/value/convert/tuple.ts
@@ -6,16 +6,16 @@ describe('value/convert/Tuple', () => {
   it('Should convert from Array 1', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
     const R = Value.Convert(T, ['1', 'true'])
-    Assert.isEqual(R, [1, true])
+    Assert.IsEqual(R, [1, true])
   })
   it('Should convert from Array 2', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
     const R = Value.Convert(T, ['1'])
-    Assert.isEqual(R, [1])
+    Assert.IsEqual(R, [1])
   })
   it('Should convert from Array 3', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
     const R = Value.Convert(T, ['1', '2', '3'])
-    Assert.isEqual(R, [1, 2, '3'])
+    Assert.IsEqual(R, [1, 2, '3'])
   })
 })
diff --git a/test/runtime/value/convert/undefined.ts b/test/runtime/value/convert/undefined.ts
index 90e9201a1..3feab7e40 100644
--- a/test/runtime/value/convert/undefined.ts
+++ b/test/runtime/value/convert/undefined.ts
@@ -6,10 +6,10 @@ describe('value/convert/Undefined', () => {
   const T = Type.Undefined()
   it('Should convert from string 1', () => {
     const R = Value.Convert(T, 'undefined')
-    Assert.isEqual(R, undefined)
+    Assert.IsEqual(R, undefined)
   })
   it('Should convert from string 2', () => {
     const R = Value.Convert(T, 'hello')
-    Assert.isEqual(R, 'hello')
+    Assert.IsEqual(R, 'hello')
   })
 })
diff --git a/test/runtime/value/convert/union.ts b/test/runtime/value/convert/union.ts
index 96c79b4dd..12f731b08 100644
--- a/test/runtime/value/convert/union.ts
+++ b/test/runtime/value/convert/union.ts
@@ -10,15 +10,15 @@ describe('value/convert/Union', () => {
     const V1 = Value.Convert(T, { x: '42' })
     const V2 = Value.Convert(T, { x: 'null' })
     const V3 = Value.Convert(T, { x: 'hello' })
-    Assert.isEqual(V1, { x: 42 })
-    Assert.isEqual(V2, { x: null })
-    Assert.isEqual(V3, { x: 'hello' })
+    Assert.IsEqual(V1, { x: 42 })
+    Assert.IsEqual(V2, { x: null })
+    Assert.IsEqual(V3, { x: 'hello' })
   })
   it('Should convert first variant in ambiguous conversion', () => {
     const T = Type.Object({
       x: Type.Union([Type.Boolean(), Type.Number()]),
     })
     const V1 = Value.Convert(T, { x: '1' })
-    Assert.isEqual(V1, { x: true })
+    Assert.IsEqual(V1, { x: true })
   })
 })
diff --git a/test/runtime/value/convert/unknown.ts b/test/runtime/value/convert/unknown.ts
index 7f43ce7f5..d3ca48479 100644
--- a/test/runtime/value/convert/unknown.ts
+++ b/test/runtime/value/convert/unknown.ts
@@ -7,36 +7,36 @@ describe('value/convert/Unknown', () => {
   it('Should convert null', () => {
     const V = null
     const R = Value.Convert(T, V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
   it('Should convert undefined', () => {
     const V = undefined
     const R = Value.Convert(T, V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
   it('Should convert string', () => {
     const V = 'hello'
     const R = Value.Convert(T, V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
   it('Should convert number', () => {
     const V = 42
     const R = Value.Convert(T, V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
   it('Should convert boolean', () => {
     const V = true
     const R = Value.Convert(T, V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
   it('Should convert object', () => {
     const V = { x: 1 }
     const R = Value.Convert(T, V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
   it('Should convert array', () => {
     const V = [1, 2, 3]
     const R = Value.Convert(T, V)
-    Assert.isEqual(R, V)
+    Assert.IsEqual(R, V)
   })
 })
diff --git a/test/runtime/value/create/any.ts b/test/runtime/value/create/any.ts
index 3dc08a4af..44809c7d1 100644
--- a/test/runtime/value/create/any.ts
+++ b/test/runtime/value/create/any.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/Any', () => {
   it('Should create value', () => {
     const T = Type.Any()
-    Assert.isEqual(Value.Create(T), {})
+    Assert.IsEqual(Value.Create(T), {})
   })
   it('Should create default', () => {
     const T = Type.Any({ default: 1 })
-    Assert.isEqual(Value.Create(T), 1)
+    Assert.IsEqual(Value.Create(T), 1)
   })
 })
diff --git a/test/runtime/value/create/array.ts b/test/runtime/value/create/array.ts
index e61a1a4f3..34377a245 100644
--- a/test/runtime/value/create/array.ts
+++ b/test/runtime/value/create/array.ts
@@ -5,14 +5,14 @@ import { Assert } from '../../assert/index'
 describe('value/create/Any', () => {
   it('Should create value', () => {
     const T = Type.Array(Type.String())
-    Assert.isEqual(Value.Create(T), [])
+    Assert.IsEqual(Value.Create(T), [])
   })
   it('Should create default', () => {
     const T = Type.Array(Type.String(), { default: ['1'] })
-    Assert.isEqual(Value.Create(T), ['1'])
+    Assert.IsEqual(Value.Create(T), ['1'])
   })
   it('Should create with minItems', () => {
     const T = Type.Array(Type.String(), { minItems: 4 })
-    Assert.isEqual(Value.Create(T), ['', '', '', ''])
+    Assert.IsEqual(Value.Create(T), ['', '', '', ''])
   })
 })
diff --git a/test/runtime/value/create/async-iterator.ts b/test/runtime/value/create/async-iterator.ts
new file mode 100644
index 000000000..da2516908
--- /dev/null
+++ b/test/runtime/value/create/async-iterator.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/AsyncIterator', () => {
+  it('Should create value', () => {
+    const T = Type.AsyncIterator(Type.Any())
+    const R = Value.Create(T)
+    Assert.IsTrue(Symbol.asyncIterator in R)
+  })
+  it('Should create default', () => {
+    const T = Type.AsyncIterator(Type.Any(), { default: 1 })
+    const R = Value.Create(T)
+    Assert.IsEqual(R, 1)
+  })
+})
diff --git a/test/runtime/value/create/bigint.ts b/test/runtime/value/create/bigint.ts
index 2409d73ec..9f53207c5 100644
--- a/test/runtime/value/create/bigint.ts
+++ b/test/runtime/value/create/bigint.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/BigInt', () => {
   it('Should create value', () => {
     const T = Type.BigInt()
-    Assert.isEqual(Value.Create(T), BigInt(0))
+    Assert.IsEqual(Value.Create(T), BigInt(0))
   })
   it('Should create default', () => {
     const T = Type.BigInt({ default: true })
-    Assert.isEqual(Value.Create(T), true)
+    Assert.IsEqual(Value.Create(T), true)
   })
 })
diff --git a/test/runtime/value/create/boolean.ts b/test/runtime/value/create/boolean.ts
index 853dd9ac4..28c1c4ea2 100644
--- a/test/runtime/value/create/boolean.ts
+++ b/test/runtime/value/create/boolean.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/Boolean', () => {
   it('Should create value', () => {
     const T = Type.Boolean()
-    Assert.isEqual(Value.Create(T), false)
+    Assert.IsEqual(Value.Create(T), false)
   })
   it('Should create default', () => {
     const T = Type.Boolean({ default: true })
-    Assert.isEqual(Value.Create(T), true)
+    Assert.IsEqual(Value.Create(T), true)
   })
 })
diff --git a/test/runtime/value/create/composite.ts b/test/runtime/value/create/composite.ts
index 40421aa6e..a19f506bc 100644
--- a/test/runtime/value/create/composite.ts
+++ b/test/runtime/value/create/composite.ts
@@ -15,7 +15,7 @@ describe('value/create/Composite', () => {
       c: Type.Number(),
     })
     const T = Type.Composite([A, B])
-    Assert.isEqual(Value.Create(T), {
+    Assert.IsEqual(Value.Create(T), {
       x: 0,
       y: 0,
       z: 0,
@@ -36,7 +36,7 @@ describe('value/create/Composite', () => {
       c: Type.Number({ default: 6 }),
     })
     const T = Type.Composite([A, B])
-    Assert.isEqual(Value.Create(T), {
+    Assert.IsEqual(Value.Create(T), {
       x: 1,
       y: 2,
       z: 3,
@@ -57,7 +57,7 @@ describe('value/create/Composite', () => {
       c: Type.Optional(Type.Number()),
     })
     const T = Type.Composite([A, B])
-    Assert.isEqual(Value.Create(T), {
+    Assert.IsEqual(Value.Create(T), {
       x: 0,
       y: 0,
       z: 0,
diff --git a/test/runtime/value/create/constructor.ts b/test/runtime/value/create/constructor.ts
index 7bf4d7777..39c54bdd1 100644
--- a/test/runtime/value/create/constructor.ts
+++ b/test/runtime/value/create/constructor.ts
@@ -13,9 +13,8 @@ describe('value/create/Constructor', () => {
     const C = Value.Create(T)
     const I = new C()
     const R = I.test()
-    Assert.isEqual(R, 123)
+    Assert.IsEqual(R, 123)
   })
-
   it('Should create default', () => {
     const T = Type.Constructor(
       [],
@@ -33,6 +32,6 @@ describe('value/create/Constructor', () => {
     const C = Value.Create(T)
     const I = new C()
     const R = I.test()
-    Assert.isEqual(R, 321)
+    Assert.IsEqual(R, 321)
   })
 })
diff --git a/test/runtime/value/create/custom.ts b/test/runtime/value/create/custom.ts
index 3c03cb110..8756a9c0a 100644
--- a/test/runtime/value/create/custom.ts
+++ b/test/runtime/value/create/custom.ts
@@ -6,12 +6,12 @@ describe('value/create/Custom', () => {
   it('Should create custom value with default', () => {
     TypeRegistry.Set('CustomCreate1', () => true)
     const T = Type.Unsafe({ [Kind]: 'CustomCreate1', default: 'hello' })
-    Assert.isEqual(Value.Create(T), 'hello')
+    Assert.IsEqual(Value.Create(T), 'hello')
   })
 
   it('Should throw when no default value is specified', () => {
     TypeRegistry.Set('CustomCreate2', () => true)
     const T = Type.Unsafe({ [Kind]: 'CustomCreate2' })
-    Assert.throws(() => Value.Create(T))
+    Assert.Throws(() => Value.Create(T))
   })
 })
diff --git a/test/runtime/value/create/enum.ts b/test/runtime/value/create/enum.ts
index 6a2cf1aa6..81acdc6f0 100644
--- a/test/runtime/value/create/enum.ts
+++ b/test/runtime/value/create/enum.ts
@@ -9,7 +9,7 @@ describe('value/create/Boolean', () => {
       B,
     }
     const T = Type.Enum(Foo)
-    Assert.isEqual(Value.Create(T), Foo.A)
+    Assert.IsEqual(Value.Create(T), Foo.A)
   })
   it('Should create default', () => {
     enum Foo {
@@ -17,6 +17,6 @@ describe('value/create/Boolean', () => {
       B,
     }
     const T = Type.Enum(Foo, { default: Foo.B })
-    Assert.isEqual(Value.Create(T), Foo.B)
+    Assert.IsEqual(Value.Create(T), Foo.B)
   })
 })
diff --git a/test/runtime/value/create/function.ts b/test/runtime/value/create/function.ts
index e69514260..0d1c2f1fb 100644
--- a/test/runtime/value/create/function.ts
+++ b/test/runtime/value/create/function.ts
@@ -7,13 +7,12 @@ describe('value/create/Function', () => {
     const T = Type.Function([], Type.Number({ default: 123 }))
     const F = Value.Create(T)
     const R = F()
-    Assert.isEqual(R, 123)
+    Assert.IsEqual(R, 123)
   })
-
   it('Should create default', () => {
     const T = Type.Function([], Type.Number({ default: 123 }), { default: () => 321 })
     const F = Value.Create(T)
     const R = F()
-    Assert.isEqual(R, 321)
+    Assert.IsEqual(R, 321)
   })
 })
diff --git a/test/runtime/value/create/index.ts b/test/runtime/value/create/index.ts
index 26caee56d..385f53f1e 100644
--- a/test/runtime/value/create/index.ts
+++ b/test/runtime/value/create/index.ts
@@ -1,5 +1,6 @@
 import './any'
 import './array'
+import './async-iterator'
 import './bigint'
 import './boolean'
 import './composite'
@@ -9,6 +10,7 @@ import './enum'
 import './function'
 import './integer'
 import './intersect'
+import './iterator'
 import './keyof'
 import './literal'
 import './never'
@@ -19,7 +21,7 @@ import './object'
 import './recursive'
 import './ref'
 import './record'
-import './regex'
+import './regexp'
 import './string'
 import './symbol'
 import './template-literal'
diff --git a/test/runtime/value/create/integer.ts b/test/runtime/value/create/integer.ts
index 8354172a0..f6dc35b39 100644
--- a/test/runtime/value/create/integer.ts
+++ b/test/runtime/value/create/integer.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/Integer', () => {
   it('Should create value', () => {
     const T = Type.Integer()
-    Assert.isEqual(Value.Create(T), 0)
+    Assert.IsEqual(Value.Create(T), 0)
   })
   it('Should create default', () => {
     const T = Type.Integer({ default: 7 })
-    Assert.isEqual(Value.Create(T), 7)
+    Assert.IsEqual(Value.Create(T), 7)
   })
 })
diff --git a/test/runtime/value/create/intersect.ts b/test/runtime/value/create/intersect.ts
index 195f2364d..771e07e2b 100644
--- a/test/runtime/value/create/intersect.ts
+++ b/test/runtime/value/create/intersect.ts
@@ -6,36 +6,35 @@ describe('value/create/Intersect', () => {
   it('Should create value', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
     const R = Value.Create(T)
-
-    Assert.isEqual(R, { x: 0, y: 0 })
+    Assert.IsEqual(R, { x: 0, y: 0 })
   })
   it('Should create value with default', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Number({ default: 100 }) }), Type.Object({ y: Type.Number({ default: 200 }) })])
     const R = Value.Create(T)
-    Assert.isEqual(R, { x: 100, y: 200 })
+    Assert.IsEqual(R, { x: 100, y: 200 })
   })
   it('Should create for overlapping intersection', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.Number(), y: Type.Number() })])
     const R = Value.Create(T)
-    Assert.isEqual(R, { x: 0, y: 0 })
+    Assert.IsEqual(R, { x: 0, y: 0 })
   })
   it('Should create with last intersected overlapping default', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Number({ default: 1 }) }), Type.Object({ x: Type.Number({ default: 2 }), y: Type.Number() })])
     const R = Value.Create(T)
-    Assert.isEqual(R, { x: 2, y: 0 })
+    Assert.IsEqual(R, { x: 2, y: 0 })
   })
   it('Should throw for non-constructable intersection 1', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.String() })])
-    Assert.throws(() => Value.Create(T))
+    Assert.Throws(() => Value.Create(T))
   })
   it('Should throw for non-constructable intersection 2', () => {
     const T = Type.Intersect([Type.String(), Type.Number()])
-    Assert.throws(() => Value.Create(T))
+    Assert.Throws(() => Value.Create(T))
   })
   it('Should not throw for non-constructable intersection with default', () => {
     const T = Type.Intersect([Type.String(), Type.Number()], { default: 'hello' })
     const R = Value.Create(T)
-    Assert.isEqual(R, 'hello')
+    Assert.IsEqual(R, 'hello')
   })
   it('Should create from nested intersection', () => {
     const T = Type.Intersect([
@@ -52,11 +51,11 @@ describe('value/create/Intersect', () => {
       ]),
     ])
     const R = Value.Create(T)
-    Assert.isEqual(R, { x: 1, y: 2, z: 3 })
+    Assert.IsEqual(R, { x: 1, y: 2, z: 3 })
   })
   it('Should create non varying primitive', () => {
     const T = Type.Intersect([Type.Number(), Type.Number(), Type.Number()])
     const R = Value.Create(T)
-    Assert.isEqual(R, 0)
+    Assert.IsEqual(R, 0)
   })
 })
diff --git a/test/runtime/value/create/iterator.ts b/test/runtime/value/create/iterator.ts
new file mode 100644
index 000000000..02ea1c991
--- /dev/null
+++ b/test/runtime/value/create/iterator.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Iterator', () => {
+  it('Should create value', () => {
+    const T = Type.Iterator(Type.Any())
+    const R = Value.Create(T)
+    Assert.IsTrue(Symbol.iterator in R)
+  })
+  it('Should create default', () => {
+    const T = Type.Iterator(Type.Any(), { default: 1 })
+    const R = Value.Create(T)
+    Assert.IsEqual(R, 1)
+  })
+})
diff --git a/test/runtime/value/create/keyof.ts b/test/runtime/value/create/keyof.ts
index 4f8aca015..0f4c33e1a 100644
--- a/test/runtime/value/create/keyof.ts
+++ b/test/runtime/value/create/keyof.ts
@@ -10,7 +10,7 @@ describe('value/create/KeyOf', () => {
         y: Type.Number(),
       }),
     )
-    Assert.isEqual(Value.Create(T), 'x')
+    Assert.IsEqual(Value.Create(T), 'x')
   })
   it('Should create default', () => {
     const T = Type.KeyOf(
@@ -20,6 +20,6 @@ describe('value/create/KeyOf', () => {
       }),
       { default: 'y' },
     )
-    Assert.isEqual(Value.Create(T), 'y')
+    Assert.IsEqual(Value.Create(T), 'y')
   })
 })
diff --git a/test/runtime/value/create/literal.ts b/test/runtime/value/create/literal.ts
index 8bdb7db2c..3004dcd97 100644
--- a/test/runtime/value/create/literal.ts
+++ b/test/runtime/value/create/literal.ts
@@ -5,18 +5,18 @@ import { Assert } from '../../assert/index'
 describe('value/create/Literal', () => {
   it('Should create literal string', () => {
     const T = Type.Literal('hello')
-    Assert.isEqual(Value.Create(T), 'hello')
+    Assert.IsEqual(Value.Create(T), 'hello')
   })
   it('Should create literal number', () => {
     const T = Type.Literal(1)
-    Assert.isEqual(Value.Create(T), 1)
+    Assert.IsEqual(Value.Create(T), 1)
   })
   it('Should create literal boolean', () => {
     const T = Type.Literal(true)
-    Assert.isEqual(Value.Create(T), true)
+    Assert.IsEqual(Value.Create(T), true)
   })
   it('Should create literal from default value', () => {
     const T = Type.Literal(true, { default: 'hello' })
-    Assert.isEqual(Value.Create(T), 'hello')
+    Assert.IsEqual(Value.Create(T), 'hello')
   })
 })
diff --git a/test/runtime/value/create/never.ts b/test/runtime/value/create/never.ts
index 437ff3ef3..55da1ea13 100644
--- a/test/runtime/value/create/never.ts
+++ b/test/runtime/value/create/never.ts
@@ -5,6 +5,6 @@ import { Assert } from '../../assert/index'
 describe('value/create/Never', () => {
   it('Should create value', () => {
     const T = Type.Never()
-    Assert.throws(() => Value.Create(T))
+    Assert.Throws(() => Value.Create(T))
   })
 })
diff --git a/test/runtime/value/create/not.ts b/test/runtime/value/create/not.ts
index 9890372c6..70f1ec2cb 100644
--- a/test/runtime/value/create/not.ts
+++ b/test/runtime/value/create/not.ts
@@ -5,16 +5,16 @@ import { Assert } from '../../assert/index'
 describe('value/create/Not', () => {
   it('Should throw without default value', () => {
     const T = Type.Not(Type.String())
-    Assert.throws(() => Value.Create(T))
+    Assert.Throws(() => Value.Create(T))
   })
   it('Should create value with default inner', () => {
     const T = Type.Not(Type.String(), { default: 100 })
     const R = Value.Create(T)
-    Assert.isEqual(R, 100)
+    Assert.IsEqual(R, 100)
   })
   it('Should create value with default outer', () => {
     const T = Type.Not(Type.String(), { default: 100 })
     const R = Value.Create(T)
-    Assert.isEqual(R, 100)
+    Assert.IsEqual(R, 100)
   })
 })
diff --git a/test/runtime/value/create/null.ts b/test/runtime/value/create/null.ts
index 3fc129a50..1c13270a7 100644
--- a/test/runtime/value/create/null.ts
+++ b/test/runtime/value/create/null.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/Null', () => {
   it('Should create value', () => {
     const T = Type.Null()
-    Assert.isEqual(Value.Create(T), null)
+    Assert.IsEqual(Value.Create(T), null)
   })
   it('Should create null from default value', () => {
     const T = Type.Null({ default: 'hello' })
-    Assert.isEqual(Value.Create(T), 'hello')
+    Assert.IsEqual(Value.Create(T), 'hello')
   })
 })
diff --git a/test/runtime/value/create/number.ts b/test/runtime/value/create/number.ts
index db68e95a5..756c3aa59 100644
--- a/test/runtime/value/create/number.ts
+++ b/test/runtime/value/create/number.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/Number', () => {
   it('Should create value', () => {
     const T = Type.Number()
-    Assert.isEqual(Value.Create(T), 0)
+    Assert.IsEqual(Value.Create(T), 0)
   })
   it('Should create default', () => {
     const T = Type.Number({ default: 7 })
-    Assert.isEqual(Value.Create(T), 7)
+    Assert.IsEqual(Value.Create(T), 7)
   })
 })
diff --git a/test/runtime/value/create/object.ts b/test/runtime/value/create/object.ts
index 8f0ff10b4..0d2ed1cad 100644
--- a/test/runtime/value/create/object.ts
+++ b/test/runtime/value/create/object.ts
@@ -9,35 +9,32 @@ describe('value/create/Object', () => {
       y: Type.Number(),
       z: Type.Number(),
     })
-    Assert.isEqual(Value.Create(T), {
+    Assert.IsEqual(Value.Create(T), {
       x: 0,
       y: 0,
       z: 0,
     })
   })
-
   it('Should create value with optional properties', () => {
     const T = Type.Object({
       x: Type.Optional(Type.Number()),
       y: Type.Optional(Type.Number()),
       z: Type.Optional(Type.Number()),
     })
-    Assert.isEqual(Value.Create(T), {})
+    Assert.IsEqual(Value.Create(T), {})
   })
-
   it('Should create default with default properties', () => {
     const T = Type.Object({
       x: Type.Number({ default: 1 }),
       y: Type.Number({ default: 2 }),
       z: Type.Number({ default: 3 }),
     })
-    Assert.isEqual(Value.Create(T), {
+    Assert.IsEqual(Value.Create(T), {
       x: 1,
       y: 2,
       z: 3,
     })
   })
-
   it('Should create nested object', () => {
     const T = Type.Object({
       x: Type.Number(),
@@ -49,14 +46,13 @@ describe('value/create/Object', () => {
         z: Type.Number(),
       }),
     })
-    Assert.isEqual(Value.Create(T), {
+    Assert.IsEqual(Value.Create(T), {
       x: 0,
       y: 0,
       z: 0,
       w: { x: 7, y: 0, z: 0 },
     })
   })
-
   it('Should create with default', () => {
     const T = Type.Object(
       {
@@ -66,7 +62,7 @@ describe('value/create/Object', () => {
       },
       { default: { x: 1, y: 2, z: 3 } },
     )
-    Assert.isEqual(Value.Create(T), {
+    Assert.IsEqual(Value.Create(T), {
       x: 1,
       y: 2,
       z: 3,
diff --git a/test/runtime/value/create/record.ts b/test/runtime/value/create/record.ts
index 05ebfd482..1a66fcc04 100644
--- a/test/runtime/value/create/record.ts
+++ b/test/runtime/value/create/record.ts
@@ -5,7 +5,7 @@ import { Assert } from '../../assert/index'
 describe('value/create/Record', () => {
   it('Should create value', () => {
     const T = Type.Record(Type.String(), Type.Object({}))
-    Assert.isEqual(Value.Create(T), {})
+    Assert.IsEqual(Value.Create(T), {})
   })
   it('Should create default', () => {
     const T = Type.Record(Type.String(), Type.Object({}), {
@@ -13,6 +13,6 @@ describe('value/create/Record', () => {
         x: {},
       },
     })
-    Assert.isEqual(Value.Create(T), { x: {} })
+    Assert.IsEqual(Value.Create(T), { x: {} })
   })
 })
diff --git a/test/runtime/value/create/recursive.ts b/test/runtime/value/create/recursive.ts
index 3f78233f2..2fb57e9df 100644
--- a/test/runtime/value/create/recursive.ts
+++ b/test/runtime/value/create/recursive.ts
@@ -10,7 +10,7 @@ describe('value/create/Recursive', () => {
         nodes: Type.Array(This),
       }),
     )
-    Assert.isEqual(Value.Create(T), {
+    Assert.IsEqual(Value.Create(T), {
       id: '',
       nodes: [],
     })
@@ -24,7 +24,7 @@ describe('value/create/Recursive', () => {
         }),
       { default: 7 },
     )
-    Assert.isEqual(Value.Create(T), 7)
+    Assert.IsEqual(Value.Create(T), 7)
   })
   it('Should throw on infinite type', () => {
     const T = Type.Recursive((This) =>
@@ -32,7 +32,7 @@ describe('value/create/Recursive', () => {
         x: This,
       }),
     )
-    Assert.throws(() => Value.Create(T))
+    Assert.Throws(() => Value.Create(T))
   })
   it('Should not throw on recursive type when terminating sub type proceeds self', () => {
     const T = Type.Recursive((This) =>
@@ -40,7 +40,7 @@ describe('value/create/Recursive', () => {
         x: Type.Union([Type.Null(), This]),
       }),
     )
-    Assert.isEqual(Value.Create(T), { x: null })
+    Assert.IsEqual(Value.Create(T), { x: null })
   })
   it('Should not throw on recursive type when self is optional', () => {
     const T = Type.Recursive((This) =>
@@ -48,6 +48,6 @@ describe('value/create/Recursive', () => {
         x: Type.Optional(This),
       }),
     )
-    Assert.isEqual(Value.Create(T), {})
+    Assert.IsEqual(Value.Create(T), {})
   })
 })
diff --git a/test/runtime/value/create/ref.ts b/test/runtime/value/create/ref.ts
index b296f0bb2..ce3d9d155 100644
--- a/test/runtime/value/create/ref.ts
+++ b/test/runtime/value/create/ref.ts
@@ -13,7 +13,7 @@ describe('value/create/Ref', () => {
       { $id: 'T', default: 'target' },
     )
     const R = Type.Ref(T)
-    Assert.throws(() => Value.Create(R))
+    Assert.Throws(() => Value.Create(R))
   })
   it('Should create ref default if ref default is defined', () => {
     const T = Type.Object(
@@ -25,11 +25,11 @@ describe('value/create/Ref', () => {
       { $id: 'T', default: 'target' },
     )
     const R = Type.Ref(T, { default: 'override' })
-    Assert.isEqual(Value.Create(R), 'override') // terminated at R default value
+    Assert.IsEqual(Value.Create(R), 'override') // terminated at R default value
   })
   it('Should dereference remote schema via $ref', () => {
     const R = Type.Number({ $id: 'S' })
     const T = Type.Object({ x: Type.Ref(R) })
-    Assert.isEqual(Value.Create(T, [R]), { x: 0 })
+    Assert.IsEqual(Value.Create(T, [R]), { x: 0 })
   })
 })
diff --git a/test/runtime/value/create/regex.ts b/test/runtime/value/create/regexp.ts
similarity index 66%
rename from test/runtime/value/create/regex.ts
rename to test/runtime/value/create/regexp.ts
index 8afa9fb8e..f1415fd6a 100644
--- a/test/runtime/value/create/regex.ts
+++ b/test/runtime/value/create/regexp.ts
@@ -4,13 +4,13 @@ import { Assert } from '../../assert/index'
 
 describe('value/create/RegEx', () => {
   it('Should throw without a default value', () => {
-    Assert.throws(() => {
-      const T = Type.RegEx(/foo/)
+    Assert.Throws(() => {
+      const T = Type.RegExp(/foo/)
       Value.Create(T)
     })
   })
   it('Should create default', () => {
-    const T = Type.RegEx(/foo/, { default: 'foo' })
-    Assert.isEqual(Value.Create(T), 'foo')
+    const T = Type.RegExp(/foo/, { default: 'foo' })
+    Assert.IsEqual(Value.Create(T), 'foo')
   })
 })
diff --git a/test/runtime/value/create/string.ts b/test/runtime/value/create/string.ts
index 41a0035ef..83ebe90f4 100644
--- a/test/runtime/value/create/string.ts
+++ b/test/runtime/value/create/string.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/String', () => {
   it('Should create value', () => {
     const T = Type.String()
-    Assert.isEqual(Value.Create(T), 0)
+    Assert.IsEqual(Value.Create(T), 0)
   })
   it('Should create default', () => {
     const T = Type.String({ default: 'hello' })
-    Assert.isEqual(Value.Create(T), 'hello')
+    Assert.IsEqual(Value.Create(T), 'hello')
   })
 })
diff --git a/test/runtime/value/create/symbol.ts b/test/runtime/value/create/symbol.ts
index 2c78809c2..90af86fa5 100644
--- a/test/runtime/value/create/symbol.ts
+++ b/test/runtime/value/create/symbol.ts
@@ -6,10 +6,10 @@ describe('value/create/Symbol', () => {
   it('Should create value', () => {
     const T = Type.Symbol()
     const V = Value.Create(T)
-    Assert.isEqual(typeof V, 'symbol')
+    Assert.IsEqual(typeof V, 'symbol')
   })
   it('Should create default', () => {
     const T = Type.Symbol({ default: true })
-    Assert.isEqual(Value.Create(T), true)
+    Assert.IsEqual(Value.Create(T), true)
   })
 })
diff --git a/test/runtime/value/create/template-literal.ts b/test/runtime/value/create/template-literal.ts
index 7103f1272..ccd9a84c3 100644
--- a/test/runtime/value/create/template-literal.ts
+++ b/test/runtime/value/create/template-literal.ts
@@ -6,30 +6,30 @@ describe('value/create/TemplateLiteral', () => {
   it('Should create pattern 1', () => {
     const T = Type.TemplateLiteral([Type.Literal('A')])
     const V = Value.Create(T)
-    Assert.isEqual(V, 'A')
+    Assert.IsEqual(V, 'A')
   })
   it('Should create pattern 2', () => {
     const T = Type.TemplateLiteral([Type.Literal('A'), Type.Literal('B')])
     const V = Value.Create(T)
-    Assert.isEqual(V, 'AB')
+    Assert.IsEqual(V, 'AB')
   })
   it('Should create pattern 3 (first only)', () => {
     const T = Type.TemplateLiteral([Type.Literal('A'), Type.Union([Type.Literal('B'), Type.Literal('C')])])
     const V = Value.Create(T)
-    Assert.isEqual(V, 'AB')
+    Assert.IsEqual(V, 'AB')
   })
   it('Should create pattern 4 (first only)', () => {
     const T = Type.TemplateLiteral([Type.Boolean()])
     const V = Value.Create(T)
-    Assert.isEqual(V, 'true')
+    Assert.IsEqual(V, 'true')
   })
   it('Should throw on infinite pattern', () => {
     const T = Type.TemplateLiteral([Type.Number()])
-    Assert.throws(() => Value.Create(T))
+    Assert.Throws(() => Value.Create(T))
   })
   it('Should create on infinite pattern with default', () => {
     const T = Type.TemplateLiteral([Type.Number()], { default: 42 })
     const V = Value.Create(T)
-    Assert.isEqual(V, 42)
+    Assert.IsEqual(V, 42)
   })
 })
diff --git a/test/runtime/value/create/tuple.ts b/test/runtime/value/create/tuple.ts
index 2edb53bd6..085296bba 100644
--- a/test/runtime/value/create/tuple.ts
+++ b/test/runtime/value/create/tuple.ts
@@ -5,18 +5,18 @@ import { Assert } from '../../assert/index'
 describe('value/create/Tuple', () => {
   it('Should create value', () => {
     const T = Type.Tuple([Type.Number(), Type.String()])
-    Assert.isEqual(Value.Create(T), [0, ''])
+    Assert.IsEqual(Value.Create(T), [0, ''])
   })
   it('Should create default', () => {
     const T = Type.Tuple([Type.Number(), Type.String()], { default: [7, 'hello'] })
-    Assert.isEqual(Value.Create(T), [7, 'hello'])
+    Assert.IsEqual(Value.Create(T), [7, 'hello'])
   })
   it('Should create default elements', () => {
     const T = Type.Tuple([Type.Number({ default: 7 }), Type.String({ default: 'hello' })])
-    Assert.isEqual(Value.Create(T), [7, 'hello'])
+    Assert.IsEqual(Value.Create(T), [7, 'hello'])
   })
   it('Should create default by overriding elements', () => {
     const T = Type.Tuple([Type.Number({ default: 7 }), Type.String({ default: 'hello' })], { default: [32, 'world'] })
-    Assert.isEqual(Value.Create(T), [32, 'world'])
+    Assert.IsEqual(Value.Create(T), [32, 'world'])
   })
 })
diff --git a/test/runtime/value/create/uint8array.ts b/test/runtime/value/create/uint8array.ts
index 1284f29f7..0dac37786 100644
--- a/test/runtime/value/create/uint8array.ts
+++ b/test/runtime/value/create/uint8array.ts
@@ -6,23 +6,21 @@ describe('value/create/Uint8Array', () => {
   it('Should create value', () => {
     const T = Type.Uint8Array()
     const value = Value.Create(T)
-    Assert.isInstanceOf(value, Uint8Array)
-    Assert.isEqual(value.length, 0)
+    Assert.IsInstanceOf(value, Uint8Array)
+    Assert.IsEqual(value.length, 0)
   })
-
   it('Should create default', () => {
     const T = Type.Uint8Array({ default: new Uint8Array([0, 1, 2, 3]) })
     const value = Value.Create(T)
-    Assert.isInstanceOf(value, Uint8Array)
-    Assert.isEqual(value.length, 4)
-    Assert.isEqual([value[0], value[1], value[2], value[3]], [0, 1, 2, 3])
+    Assert.IsInstanceOf(value, Uint8Array)
+    Assert.IsEqual(value.length, 4)
+    Assert.IsEqual([value[0], value[1], value[2], value[3]], [0, 1, 2, 3])
   })
-
   it('Should create with minByteLength', () => {
     const T = Type.Uint8Array({ minByteLength: 4 })
     const value = Value.Create(T)
-    Assert.isInstanceOf(value, Uint8Array)
-    Assert.isEqual(value.length, 4)
-    Assert.isEqual([value[0], value[1], value[2], value[3]], [0, 0, 0, 0])
+    Assert.IsInstanceOf(value, Uint8Array)
+    Assert.IsEqual(value.length, 4)
+    Assert.IsEqual([value[0], value[1], value[2], value[3]], [0, 0, 0, 0])
   })
 })
diff --git a/test/runtime/value/create/undefined.ts b/test/runtime/value/create/undefined.ts
index d9e3ed509..e2f530ee7 100644
--- a/test/runtime/value/create/undefined.ts
+++ b/test/runtime/value/create/undefined.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/Undefined', () => {
   it('Should create value', () => {
     const T = Type.Undefined()
-    Assert.isEqual(Value.Create(T), undefined)
+    Assert.IsEqual(Value.Create(T), undefined)
   })
   it('Should create value from default value', () => {
     const T = Type.Undefined({ default: 'hello' })
-    Assert.isEqual(Value.Create(T), 'hello')
+    Assert.IsEqual(Value.Create(T), 'hello')
   })
 })
diff --git a/test/runtime/value/create/union.ts b/test/runtime/value/create/union.ts
index 1d3c79677..37da0abaa 100644
--- a/test/runtime/value/create/union.ts
+++ b/test/runtime/value/create/union.ts
@@ -17,14 +17,13 @@ describe('value/create/Union', () => {
       z: Type.String(),
     })
     const T = Type.Union([A, B])
-    Assert.isEqual(Value.Create(T), {
+    Assert.IsEqual(Value.Create(T), {
       type: 'A',
       x: 0,
       y: 0,
       z: 0,
     })
   })
-
   it('Should create union Null', () => {
     const A = Type.Null()
     const B = Type.Object({
@@ -34,9 +33,8 @@ describe('value/create/Union', () => {
       z: Type.String(),
     })
     const T = Type.Union([A, B])
-    Assert.isEqual(Value.Create(T), null)
+    Assert.IsEqual(Value.Create(T), null)
   })
-
   it('Should create union Array', () => {
     const A = Type.Array(Type.String())
     const B = Type.Object({
@@ -46,6 +44,6 @@ describe('value/create/Union', () => {
       z: Type.String(),
     })
     const T = Type.Union([A, B])
-    Assert.isEqual(Value.Create(T), [])
+    Assert.IsEqual(Value.Create(T), [])
   })
 })
diff --git a/test/runtime/value/create/unknown.ts b/test/runtime/value/create/unknown.ts
index d75a062c8..a67b3ec8f 100644
--- a/test/runtime/value/create/unknown.ts
+++ b/test/runtime/value/create/unknown.ts
@@ -5,10 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/Unknown', () => {
   it('Should create value', () => {
     const T = Type.Unknown()
-    Assert.isEqual(Value.Create(T), {})
+    Assert.IsEqual(Value.Create(T), {})
   })
   it('Should create default', () => {
     const T = Type.Unknown({ default: 1 })
-    Assert.isEqual(Value.Create(T), 1)
+    Assert.IsEqual(Value.Create(T), 1)
   })
 })
diff --git a/test/runtime/value/create/void.ts b/test/runtime/value/create/void.ts
index 56c8a9a66..eb32ae1b9 100644
--- a/test/runtime/value/create/void.ts
+++ b/test/runtime/value/create/void.ts
@@ -5,11 +5,10 @@ import { Assert } from '../../assert/index'
 describe('value/create/Void', () => {
   it('Should create value', () => {
     const T = Type.Void()
-    Assert.isEqual(Value.Create(T), null)
+    Assert.IsEqual(Value.Create(T), null)
   })
-
   it('Should create value from default value', () => {
     const T = Type.Void({ default: 'hello' })
-    Assert.isEqual(Value.Create(T), 'hello')
+    Assert.IsEqual(Value.Create(T), 'hello')
   })
 })
diff --git a/test/runtime/value/delta/diff.ts b/test/runtime/value/delta/diff.ts
index bda3d0a1d..2943e157f 100644
--- a/test/runtime/value/delta/diff.ts
+++ b/test/runtime/value/delta/diff.ts
@@ -4,19 +4,15 @@ import { Assert } from '../../assert/index'
 // -----------------------------------------------------------------
 // Diff Factory
 // -----------------------------------------------------------------
-
-function Update(path: string, value: unknown): Edit<unknown> {
+function Update(path: string, value: unknown): Edit {
   return { type: 'update', path, value } as any
 }
-
-function Insert(path: string, value: unknown): Edit<unknown> {
+function Insert(path: string, value: unknown): Edit {
   return { type: 'insert', path, value } as any
 }
-
-function Delete(path: string): Edit<unknown> {
+function Delete(path: string): Edit {
   return { type: 'delete', path } as any
 }
-
 describe('value/delta/Diff', () => {
   // ----------------------------------------------------
   // Null
@@ -26,35 +22,35 @@ describe('value/delta/Diff', () => {
     const B = null
     const D = Value.Diff(A, B)
     const E = [] as Edit[]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff NULL undefined to undefined', () => {
     const A = undefined
     const B = undefined
     const D = Value.Diff(A, B)
     const E = [] as Edit[]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff NULL string to string', () => {
     const A = 'hello'
     const B = 'hello'
     const D = Value.Diff(A, B)
     const E = [] as Edit[]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff NULL number to number', () => {
     const A = 1
     const B = 1
     const D = Value.Diff(A, B)
     const E = [] as Edit[]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff NULL boolean to boolean', () => {
     const A = true
     const B = true
     const D = Value.Diff(A, B)
     const E = [] as Edit[]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff NULL symbol to symbol', () => {
     const S = Symbol('A')
@@ -62,363 +58,328 @@ describe('value/delta/Diff', () => {
     const B = S
     const D = Value.Diff(A, B)
     const E = [] as Edit[]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff NULL object to object', () => {
     const A = { x: 1, y: 2, z: 3 }
     const B = { x: 1, y: 2, z: 3 }
     const D = Value.Diff(A, B)
     const E = [] as Edit[]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff NULL array to array', () => {
     const A = [1, 2, 3]
     const B = [1, 2, 3]
     const D = Value.Diff(A, B)
     const E = [] as Edit[]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   // ----------------------------------------------------
   // Type Change Root
   // ----------------------------------------------------
-
   it('Should diff TYPE change number to null', () => {
     const A = 1
     const B = null
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff TYPE change null to undefined', () => {
     const A = null
     const B = undefined
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff TYPE change null to number', () => {
     const A = null
     const B = 1
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff TYPE change null to boolean', () => {
     const A = null
     const B = true
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff TYPE change null to string', () => {
     const A = null
     const B = 'hello'
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff TYPE change null to symbol', () => {
     const A = null
     const B = Symbol('A')
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff TYPE change null to object', () => {
     const A = null
     const B = { x: 1, y: 1, z: 1 }
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff TYPE change null to array', () => {
     const A = null
     const B = [1, 2, 3]
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   // ----------------------------------------------------
   // Value Change Root
   // ----------------------------------------------------
-
   it('Should diff VALUE change number', () => {
     const A = 1
     const B = 2
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff VALUE change boolean', () => {
     const A = false
     const B = true
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff VALUE change string', () => {
     const A = 'hello'
     const B = 'world'
     const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff VALUE change symbol', () => {
     const A = Symbol('A')
     const B = Symbol('B')
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const E = [Update('', B)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   // ----------------------------------------------------
   // Array
   // ----------------------------------------------------
-
   it('Should diff ELEMENT update', () => {
     const A = [1, 2, 3, 4]
     const B = [1, 2, 3, 9]
     const D = Value.Diff(A, B)
     const E = [Update('/3', 9)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff ELEMENT push', () => {
     const A = [1, 2, 3, 4]
     const B = [1, 2, 3, 4, 5]
     const D = Value.Diff(A, B)
     const E = [Insert('/4', 5)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff ELEMENT push twice', () => {
     const A = [1, 2, 3, 4]
     const B = [1, 2, 3, 4, 5, 6]
     const D = Value.Diff(A, B)
     const E = [Insert('/4', 5), Insert('/5', 6)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff ELEMENT pop', () => {
     const A = [1, 2, 3, 4]
     const B = [1, 2, 3]
     const D = Value.Diff(A, B)
     const E = [Delete('/3')]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff ELEMENT pop twice', () => {
     const A = [1, 2, 3, 4]
     const B = [1, 2]
     const D = Value.Diff(A, B)
     const E = [Delete('/3'), Delete('/2')]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff ELEMENT unshift', () => {
     const A = [1, 2, 3, 4]
     const B = [2, 3, 4]
     const D = Value.Diff(A, B)
     const E = [Update('/0', 2), Update('/1', 3), Update('/2', 4), Delete('/3')]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff ELEMENT unshift twice', () => {
     const A = [1, 2, 3, 4]
     const B = [3, 4]
     const D = Value.Diff(A, B)
     const E = [Update('/0', 3), Update('/1', 4), Delete('/3'), Delete('/2')]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   // ----------------------------------------------------
   // Object
   // ----------------------------------------------------
-
   it('Should diff PROPERTY insert', () => {
     const A = { x: 1, y: 1 }
     const B = { x: 1, y: 1, z: 1 }
     const D = Value.Diff(A, B)
     const E = [Insert('/z', 1)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff PROPERTY delete', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { x: 1, y: 1 }
     const D = Value.Diff(A, B)
     const E = [Delete('/z')]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff PROPERTY update', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { x: 1, y: 1, z: 2 }
     const D = Value.Diff(A, B)
     const E = [Update('/z', 2)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff PROPERTY all values', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { x: 2, y: 2, z: 2 }
     const D = Value.Diff(A, B)
     const E = [Update('/x', 2), Update('/y', 2), Update('/z', 2)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff PROPERTY all delete, all insert', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { a: 2, b: 2, c: 2 }
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const E = [Insert('/a', 2), Insert('/b', 2), Insert('/c', 2), Delete('/z'), Delete('/y'), Delete('/x')]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff PROPERTY update, insert and delete order preserved', () => {
     const A = { x: 1, y: 1, z: 1, w: 1 }
     const B = { a: 2, b: 2, c: 2, w: 2 }
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const E = [Update('/w', 2), Insert('/a', 2), Insert('/b', 2), Insert('/c', 2), Delete('/z'), Delete('/y'), Delete('/x')]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   // ----------------------------------------------------
   // Object Nested
   // ----------------------------------------------------
-
   it('Should diff NESTED OBJECT diff type change update', () => {
     const A = { v: 1 }
     const B = { v: { x: 1, y: 1, z: 1 } }
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const E = [Update('/v', B.v)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff NESTED OBJECT diff value change update', () => {
     const A = { v: 1 }
     const B = { v: 2 }
     const D = Value.Diff(A, B)
     const E = [Update('/v', B.v)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff NESTED OBJECT diff partial property update', () => {
     const A = { v: { x: 1, y: 1, z: 1 } }
     const B = { v: { x: 2, y: 2, z: 2 } }
     const D = Value.Diff(A, B)
     const E = [Update('/v/x', B.v.x), Update('/v/y', B.v.y), Update('/v/z', B.v.z)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff NESTED OBJECT diff partial property insert', () => {
     const A = { v: { x: 1, y: 1, z: 1 } }
     const B = { v: { x: 1, y: 1, z: 1, w: 1 } }
     const D = Value.Diff(A, B)
     const E = [Insert('/v/w', B.v.w)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff NESTED OBJECT diff partial property delete', () => {
     const A = { v: { x: 1, y: 1, z: 1 } }
     const B = { v: { x: 1, y: 1 } }
     const D = Value.Diff(A, B)
     const E = [Delete('/v/z')]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff NESTED OBJECT ordered diff - update, insert and delete', () => {
     const A = { v: { x: 1, y: 1 } }
     const B = { v: { x: 2, w: 2 } }
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const E = [Update('/v/x', B.v.x), Insert('/v/w', B.v.w), Delete('/v/y')]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   // ----------------------------------------------------
   // Array Nested
   // ----------------------------------------------------
-
   it('Should diff NESTED ARRAY object diff type change update', () => {
     const A = [{ v: 1 }]
     const B = [{ v: { x: 1, y: 1, z: 1 } }]
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const E = [Update('/0/v', B[0].v)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff NESTED ARRAY object diff value change update', () => {
     const A = [{ v: 1 }]
     const B = [{ v: 2 }]
     const D = Value.Diff(A, B)
     const E = [Update('/0/v', B[0].v)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff NESTED ARRAY object diff partial property update', () => {
     const A = [{ v: { x: 1, y: 1, z: 1 } }]
     const B = [{ v: { x: 2, y: 2, z: 2 } }]
     const D = Value.Diff(A, B)
     const E = [Update('/0/v/x', B[0].v.x), Update('/0/v/y', B[0].v.y), Update('/0/v/z', B[0].v.z)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
   it('Should diff NESTED ARRAY object diff partial property insert', () => {
     const A = [{ v: { x: 1, y: 1, z: 1 } }]
     const B = [{ v: { x: 1, y: 1, z: 1, w: 1 } }]
     const D = Value.Diff(A, B)
     const E = [Insert('/0/v/w', B[0].v.w)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff NESTED ARRAY object diff partial property delete', () => {
     const A = [{ v: { x: 1, y: 1, z: 1 } }]
     const B = [{ v: { x: 1, y: 1 } }]
     const D = Value.Diff(A, B)
     const E = [Delete('/0/v/z')]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff NESTED ARRAY update, insert and delete order preserved', () => {
     const A = [{ v: { x: 1, y: 1 } }]
     const B = [{ v: { x: 2, w: 2 } }]
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const E = [Update('/0/v/x', B[0].v.x), Insert('/0/v/w', B[0].v.w), Delete('/0/v/y')]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should throw if attempting to diff a current value with symbol key', () => {
     const A = [{ [Symbol('A')]: 1, v: { x: 1, y: 1 } }]
     const B = [{ v: { x: 2, w: 2 } }]
-    Assert.throws(() => Value.Diff<any>(A, B))
+    Assert.Throws(() => Value.Diff(A, B))
   })
-
   it('Should throw if attempting to diff a next value with symbol key', () => {
     const A = [{ v: { x: 1, y: 1 } }]
     const B = [{ [Symbol('A')]: 1, v: { x: 2, w: 2 } }]
-    Assert.throws(() => Value.Diff<any>(A, B))
+    Assert.Throws(() => Value.Diff(A, B))
   })
-
   it('Should diff a Uint8Array (same size)', () => {
     const A = new Uint8Array([0, 1, 2, 3])
     const B = new Uint8Array([0, 9, 2, 9])
     const D = Value.Diff(A, B)
     const E = [Update('/1', 9), Update('/3', 9)]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff a Uint8Array (less than requires full update)', () => {
     const A = new Uint8Array([0, 1, 2, 3])
     const B = new Uint8Array([0, 9, 2])
     const D = Value.Diff(A, B)
     const E = [Update('', new Uint8Array([0, 9, 2]))]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
-
   it('Should diff a Uint8Array (greater than requires full update)', () => {
     const A = new Uint8Array([0, 1, 2, 3])
     const B = new Uint8Array([0, 9, 2, 3, 4])
     const D = Value.Diff(A, B)
     const E = [Update('', new Uint8Array([0, 9, 2, 3, 4]))]
-    Assert.isEqual(D, E)
+    Assert.IsEqual(D, E)
   })
 })
diff --git a/test/runtime/value/delta/patch.ts b/test/runtime/value/delta/patch.ts
index cb9ac37f3..7e308c42a 100644
--- a/test/runtime/value/delta/patch.ts
+++ b/test/runtime/value/delta/patch.ts
@@ -10,35 +10,35 @@ describe('value/delta/Patch', () => {
     const B = null
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch NULL undefined to undefined', () => {
     const A = undefined
     const B = undefined
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch NULL string to string', () => {
     const A = 'hello'
     const B = 'hello'
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch NULL number to number', () => {
     const A = 1
     const B = 1
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch NULL boolean to boolean', () => {
     const A = true
     const B = true
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch NULL symbol to symbol', () => {
     const S = Symbol('A')
@@ -46,356 +46,323 @@ describe('value/delta/Patch', () => {
     const B = S
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch NULL object to object', () => {
     const A = { x: 1, y: 2, z: 3 }
     const B = { x: 1, y: 2, z: 3 }
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch NULL array to array', () => {
     const A = [1, 2, 3]
     const B = [1, 2, 3]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   // ----------------------------------------------------
   // Type Change Root
   // ----------------------------------------------------
-
   it('Should patch TYPE change number to null', () => {
     const A = 1
     const B = null
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch TYPE change null to undefined', () => {
     const A = null
     const B = undefined
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch TYPE change null to number', () => {
     const A = null
     const B = 1
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch TYPE change null to boolean', () => {
     const A = null
     const B = true
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch TYPE change null to string', () => {
     const A = null
     const B = 'hello'
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch TYPE change null to symbol', () => {
     const A = null
     const B = Symbol('A')
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch TYPE change null to object', () => {
     const A = null
     const B = { x: 1, y: 1, z: 1 }
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch TYPE change null to array', () => {
     const A = null
     const B = [1, 2, 3]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch TYPE change object to array', () => {
     const A = { x: 1, y: 2 }
     const B = [1, 2, 3]
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch TYPE change array to object', () => {
     const A = [1, 2, 3]
     const B = { x: 1, y: 2 }
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   // ----------------------------------------------------
   // Value Change Root
   // ----------------------------------------------------
-
   it('Should patch VALUE change number', () => {
     const A = 1
     const B = 2
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch VALUE change boolean', () => {
     const A = false
     const B = true
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch VALUE change string', () => {
     const A = 'hello'
     const B = 'world'
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch VALUE change symbol', () => {
     const A = Symbol('A')
     const B = Symbol('B')
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   // ----------------------------------------------------
   // Array
   // ----------------------------------------------------
-
   it('Should patch ELEMENT update', () => {
     const A = [1, 2, 3, 4]
     const B = [1, 2, 3, 9]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch ELEMENT push', () => {
     const A = [1, 2, 3, 4]
     const B = [1, 2, 3, 4, 5]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch ELEMENT push twice', () => {
     const A = [1, 2, 3, 4]
     const B = [1, 2, 3, 4, 5, 6]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch ELEMENT pop', () => {
     const A = [1, 2, 3, 4]
     const B = [1, 2, 3]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch ELEMENT pop twice', () => {
     const A = [1, 2, 3, 4]
     const B = [1, 2]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch ELEMENT unshift', () => {
     const A = [1, 2, 3, 4]
     const B = [2, 3, 4]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch ELEMENT unshift twice', () => {
     const A = [1, 2, 3, 4]
     const B = [3, 4]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   // ----------------------------------------------------
   // Object
   // ----------------------------------------------------
-
   it('Should patch PROPERTY insert', () => {
     const A = { x: 1, y: 1 }
     const B = { x: 1, y: 1, z: 1 }
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch PROPERTY delete', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { x: 1, y: 1 }
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch PROPERTY update', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { x: 1, y: 1, z: 2 }
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch PROPERTY all values', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { x: 2, y: 2, z: 2 }
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch PROPERTY all delete, all insert', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { a: 2, b: 2, c: 2 }
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch PROPERTY update, insert and delete order preserved', () => {
     const A = { x: 1, y: 1, z: 1, w: 1 }
     const B = { a: 2, b: 2, c: 2, w: 2 }
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   // ----------------------------------------------------
   // Object Nested
   // ----------------------------------------------------
-
   it('Should patch NESTED OBJECT diff type change update', () => {
     const A = { v: 1 }
     const B = { v: { x: 1, y: 1, z: 1 } }
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch NESTED OBJECT diff value change update', () => {
     const A = { v: 1 }
     const B = { v: 2 }
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch NESTED OBJECT diff partial property update', () => {
     const A = { v: { x: 1, y: 1, z: 1 } }
     const B = { v: { x: 2, y: 2, z: 2 } }
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch NESTED OBJECT update, insert and delete order preserved', () => {
     const A = { v: { x: 1, y: 1 } }
     const B = { v: { x: 2, w: 2 } }
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   // ----------------------------------------------------
   // Array Nested
   // ----------------------------------------------------
-
   it('Should patch NESTED ARRAY object diff type change update', () => {
     const A = [{ v: 1 }]
     const B = [{ v: { x: 1, y: 1, z: 1 } }]
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch NESTED ARRAY object diff value change update', () => {
     const A = [{ v: 1 }]
     const B = [{ v: 2 }]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch NESTED ARRAY object diff partial property update', () => {
     const A = [{ v: { x: 1, y: 1, z: 1 } }]
     const B = [{ v: { x: 2, y: 2, z: 2 } }]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   it('Should patch NESTED ARRAY object diff partial property insert', () => {
     const A = [{ v: { x: 1, y: 1, z: 1 } }]
     const B = [{ v: { x: 1, y: 1, z: 1, w: 1 } }]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch NESTED ARRAY object diff partial property delete', () => {
     const A = [{ v: { x: 1, y: 1, z: 1 } }]
     const B = [{ v: { x: 1, y: 1 } }]
     const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch NESTED ARRAY object ordered diff - update, insert and delete', () => {
     const A = [{ v: { x: 1, y: 1 } }]
     const B = [{ v: { x: 2, w: 2 } }]
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch Uint8Array (same size)', () => {
     const A = [{ v: new Uint8Array([0, 1, 3]) }]
     const B = [{ v: new Uint8Array([0, 1, 2]) }]
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch Uint8Array (less than size)', () => {
     const A = [{ v: new Uint8Array([0, 1, 3]) }]
     const B = [{ v: new Uint8Array([0, 1]) }]
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
-
   it('Should patch Uint8Array (greater than size)', () => {
     const A = [{ v: new Uint8Array([0, 1, 3]) }]
     const B = [{ v: new Uint8Array([0, 1, 2, 4]) }]
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
   // ----------------------------------------------------
   // Mega Values
   // ----------------------------------------------------
-
   it('Should patch MEGA value', () => {
     const A = [
       { a: { x: 1, y: 1 } },
@@ -440,8 +407,8 @@ describe('value/delta/Patch', () => {
         ],
       },
     ]
-    const D = Value.Diff<any>(A, B)
+    const D = Value.Diff(A, B)
     const P = Value.Patch(A, D)
-    Assert.isEqual(B, P)
+    Assert.IsEqual(B, P)
   })
 })
diff --git a/test/runtime/value/equal/equal.ts b/test/runtime/value/equal/equal.ts
index dda3c6b18..57382d800 100644
--- a/test/runtime/value/equal/equal.ts
+++ b/test/runtime/value/equal/equal.ts
@@ -4,108 +4,90 @@ import { Assert } from '../../assert/index'
 describe('value/equal/Equal', () => {
   it('Should equal null value', () => {
     const R = Value.Equal(null, null)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not equal null value', () => {
     const R = Value.Equal(null, 'null')
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should equal undefined value', () => {
     const R = Value.Equal(undefined, undefined)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not equal undefined value', () => {
     const R = Value.Equal(undefined, 'undefined')
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should equal symbol value', () => {
     const S1 = Symbol.for('test')
     const S2 = Symbol.for('test')
     const R = Value.Equal(S1, S2)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not equal symbol value', () => {
     const S1 = Symbol('test')
     const S2 = Symbol('test')
     const R = Value.Equal(S1, S2)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should equal string value', () => {
     const R = Value.Equal('hello', 'hello')
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
   it('Should not equal string value', () => {
     const R = Value.Equal('hello', 'world')
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should equal number value', () => {
     const R = Value.Equal(1, 1)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not equal number value', () => {
     const R = Value.Equal(1, 2)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should equal boolean value', () => {
     const R = Value.Equal(true, true)
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not equal boolean value', () => {
     const R = Value.Equal(true, false)
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should equal array value', () => {
     const R = Value.Equal([0, 1, 2], [0, 1, 2])
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not equal array value', () => {
     const R = Value.Equal([0, 1, 2], [0, 1, 3])
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not equal array value with additional elements', () => {
     const R = Value.Equal([0, 1, 2], [0, 1, 2, 3])
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should equal object value', () => {
     const R = Value.Equal({ x: 1, y: 2, z: 3 }, { x: 1, y: 2, z: 3 })
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not equal object value', () => {
     const R = Value.Equal({ x: 1, y: 2, z: 3 }, { x: 1, y: 2, z: 4 })
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should not equal object value with additional properties', () => {
     const R = Value.Equal({ x: 1, y: 2, z: 3 }, { x: 1, y: 2, z: 3, w: 1 })
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
-
   it('Should equal typed array value', () => {
     const R = Value.Equal(new Uint8Array([0, 1, 2]), new Uint8Array([0, 1, 2]))
-    Assert.isEqual(R, true)
+    Assert.IsTrue(R)
   })
-
   it('Should not equal typed array value', () => {
     const R = Value.Equal(new Uint8Array([0, 1, 2]), new Uint8Array([0, 1, 3]))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
   it('Should not equal typed array value with varying type', () => {
     const R = Value.Equal(new Uint8Array([0, 1, 2]), new Int8Array([0, 1, 2]))
-    Assert.isEqual(R, false)
+    Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/value/guard/guard.ts b/test/runtime/value/guard/guard.ts
new file mode 100644
index 000000000..d51511184
--- /dev/null
+++ b/test/runtime/value/guard/guard.ts
@@ -0,0 +1,302 @@
+import { Assert } from '../../assert/index'
+import * as ValueGuard from '@sinclair/typebox/value/guard'
+
+describe('value/guard/ValueGuard', () => {
+  // -----------------------------------------------------
+  // IsNull
+  // -----------------------------------------------------
+  it('Should guard null 1', () => {
+    const R = ValueGuard.IsNull(null)
+    Assert.IsTrue(R)
+  })
+  it('Should guard null 2', () => {
+    const R = ValueGuard.IsNull({})
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsUndefined
+  // -----------------------------------------------------
+  it('Should guard undefined 1', () => {
+    const R = ValueGuard.IsUndefined(undefined)
+    Assert.IsTrue(R)
+  })
+  it('Should guard undefined 2', () => {
+    const R = ValueGuard.IsUndefined({})
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsBigInt
+  // -----------------------------------------------------
+  it('Should guard bigint 1', () => {
+    const R = ValueGuard.IsBigInt(1n)
+    Assert.IsTrue(R)
+  })
+  it('Should guard bigint 2', () => {
+    const R = ValueGuard.IsBigInt(1)
+    Assert.IsFalse(R)
+  })
+  it('Should guard bigint 3', () => {
+    const R = ValueGuard.IsBigInt('123')
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsNumber
+  // -----------------------------------------------------
+  it('Should guard number 1', () => {
+    const R = ValueGuard.IsNumber(1)
+    Assert.IsTrue(R)
+  })
+  it('Should guard number 2', () => {
+    const R = ValueGuard.IsNumber(3.14)
+    Assert.IsTrue(R)
+  })
+  it('Should guard number 3', () => {
+    const R = ValueGuard.IsNumber('')
+    Assert.IsFalse(R)
+  })
+  it('Should guard number 4', () => {
+    const R = ValueGuard.IsNumber(NaN)
+    Assert.IsTrue(R)
+  })
+  // -----------------------------------------------------
+  // IsString
+  // -----------------------------------------------------
+  it('Should guard string 1', () => {
+    const R = ValueGuard.IsString('')
+    Assert.IsTrue(R)
+  })
+  it('Should guard string 2', () => {
+    const R = ValueGuard.IsString(true)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsBoolean
+  // -----------------------------------------------------
+  it('Should guard boolean 1', () => {
+    const R = ValueGuard.IsBoolean(true)
+    Assert.IsTrue(R)
+  })
+  it('Should guard boolean 2', () => {
+    const R = ValueGuard.IsBoolean(1)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsObject
+  // -----------------------------------------------------
+  it('Should guard object 1', () => {
+    const R = ValueGuard.IsObject({})
+    Assert.IsTrue(R)
+  })
+  it('Should guard object 2', () => {
+    const R = ValueGuard.IsObject(1)
+    Assert.IsFalse(R)
+  })
+  it('Should guard object 3', () => {
+    const R = ValueGuard.IsObject([])
+    Assert.IsTrue(R)
+  })
+  // -----------------------------------------------------
+  // IsArray
+  // -----------------------------------------------------
+  it('Should guard array 1', () => {
+    const R = ValueGuard.IsArray([])
+    Assert.IsTrue(R)
+  })
+  it('Should guard array 2', () => {
+    const R = ValueGuard.IsArray({})
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // Specialized (Values Only)
+  // -----------------------------------------------------
+  // -----------------------------------------------------
+  // IsAsyncIterator
+  // -----------------------------------------------------
+  it('Should guard async iterator 1', () => {
+    const R = ValueGuard.IsAsyncIterator((async function* (): any {})())
+    Assert.IsTrue(R)
+  })
+  it('Should guard async iterator 2', () => {
+    const R = ValueGuard.IsAsyncIterator((function* (): any {})())
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // HasPropertyKey
+  // -----------------------------------------------------
+  it('Should guard property key 1', () => {
+    const O = { x: 10 }
+    const R = ValueGuard.HasPropertyKey(O, 'x')
+    Assert.IsTrue(R)
+  })
+  it('Should guard property key 2', () => {
+    const O = { x: 10 }
+    const R = ValueGuard.HasPropertyKey(O, 'y')
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsDate
+  // -----------------------------------------------------
+  it('Should guard date 1', () => {
+    const R = ValueGuard.IsDate(new Date())
+    Assert.IsTrue(R)
+  })
+  it('Should guard date 2', () => {
+    const R = ValueGuard.IsDate({})
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsFunction
+  // -----------------------------------------------------
+  it('Should guard function 1', () => {
+    const R = ValueGuard.IsFunction(function () {})
+    Assert.IsTrue(R)
+  })
+  it('Should guard function 2', () => {
+    const R = ValueGuard.IsFunction({})
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsInteger
+  // -----------------------------------------------------
+  it('Should guard integer 1', () => {
+    const R = ValueGuard.IsInteger(1)
+    Assert.IsTrue(R)
+  })
+  it('Should guard integer 2', () => {
+    const R = ValueGuard.IsInteger(3.14)
+    Assert.IsFalse(R)
+  })
+  it('Should guard integer 3', () => {
+    const R = ValueGuard.IsInteger(NaN)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsIterator
+  // -----------------------------------------------------
+  it('Should guard iterator 1', () => {
+    const R = ValueGuard.IsIterator((function* () {})())
+    Assert.IsTrue(R)
+  })
+  it('Should guard iterator 2', () => {
+    const R = ValueGuard.IsIterator({})
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsPlainObject
+  // -----------------------------------------------------
+  it('Should guard plain object 1', () => {
+    const R = ValueGuard.IsPlainObject({})
+    Assert.IsTrue(R)
+  })
+  it('Should guard plain object 2', () => {
+    const R = ValueGuard.IsPlainObject(new (class {})())
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsPromise
+  // -----------------------------------------------------
+  it('Should guard promise 1', () => {
+    const R = ValueGuard.IsPromise(Promise.resolve(1))
+    Assert.IsTrue(R)
+  })
+  it('Should guard promise 2', () => {
+    const R = ValueGuard.IsPromise(new (class {})())
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsSymbol
+  // -----------------------------------------------------
+  it('Should guard symbol 1', () => {
+    const R = ValueGuard.IsSymbol(Symbol(1))
+    Assert.IsTrue(R)
+  })
+  it('Should guard symbol 2', () => {
+    const R = ValueGuard.IsSymbol(1)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsTypedArray
+  // -----------------------------------------------------
+  it('Should guard typed array 1', () => {
+    const R = ValueGuard.IsTypedArray(new Uint8Array(1))
+    Assert.IsTrue(R)
+  })
+  it('Should guard typed array 2', () => {
+    const R = ValueGuard.IsTypedArray(new Float32Array(1))
+    Assert.IsTrue(R)
+  })
+  it('Should guard typed array 3', () => {
+    const R = ValueGuard.IsTypedArray(new ArrayBuffer(1))
+    Assert.IsFalse(R)
+  })
+  it('Should guard typed array 4', () => {
+    const R = ValueGuard.IsTypedArray(1)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsUint8Array
+  // -----------------------------------------------------
+  it('Should guard uint8array 1', () => {
+    const R = ValueGuard.IsUint8Array(new Uint8Array(1))
+    Assert.IsTrue(R)
+  })
+  it('Should guard uint8array 2', () => {
+    const R = ValueGuard.IsUint8Array(new Float32Array(1))
+    Assert.IsFalse(R)
+  })
+  it('Should guard uint8array 2', () => {
+    const R = ValueGuard.IsUint8Array(1)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsValueType
+  // -----------------------------------------------------
+  it('Should guard value type 1', () => {
+    const R = ValueGuard.IsValueType(1)
+    Assert.IsTrue(R)
+  })
+  it('Should guard value type 2', () => {
+    const R = ValueGuard.IsValueType(true)
+    Assert.IsTrue(R)
+  })
+  it('Should guard value type 3', () => {
+    const R = ValueGuard.IsValueType(false)
+    Assert.IsTrue(R)
+  })
+  it('Should guard value type 4', () => {
+    const R = ValueGuard.IsValueType('hello')
+    Assert.IsTrue(R)
+  })
+  it('Should guard value type 5', () => {
+    const R = ValueGuard.IsValueType(1n)
+    Assert.IsTrue(R)
+  })
+  it('Should guard value type 6', () => {
+    const R = ValueGuard.IsValueType(null)
+    Assert.IsTrue(R)
+  })
+  it('Should guard value type 7', () => {
+    const R = ValueGuard.IsValueType(undefined)
+    Assert.IsTrue(R)
+  })
+  it('Should guard value type 8', () => {
+    const R = ValueGuard.IsValueType(function () {})
+    Assert.IsFalse(R)
+  })
+  it('Should guard value type 9', () => {
+    const R = ValueGuard.IsValueType({})
+    Assert.IsFalse(R)
+  })
+  it('Should guard value type 10', () => {
+    const R = ValueGuard.IsValueType([])
+    Assert.IsFalse(R)
+  })
+  it('Should guard value type 11', () => {
+    const R = ValueGuard.IsValueType(class {})
+    Assert.IsFalse(R)
+  })
+  it('Should guard value type 12', () => {
+    const R = ValueGuard.IsValueType(new (class {})())
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/value/guard/index.ts b/test/runtime/value/guard/index.ts
new file mode 100644
index 000000000..4f2ca894f
--- /dev/null
+++ b/test/runtime/value/guard/index.ts
@@ -0,0 +1 @@
+import './guard'
diff --git a/test/runtime/value/hash/hash.ts b/test/runtime/value/hash/hash.ts
index eac4765e8..b93b676f1 100644
--- a/test/runtime/value/hash/hash.ts
+++ b/test/runtime/value/hash/hash.ts
@@ -1,111 +1,111 @@
-import { ValueHash } from '@sinclair/typebox/value'
+import * as ValueHash from '@sinclair/typebox/value/hash'
 import { Assert } from '../../assert/index'
 
 describe('value/hash/Hash', () => {
   it('Should hash number', () => {
-    Assert.isEqual('bigint', typeof ValueHash.Create(1))
-    const A = ValueHash.Create(1)
-    const B = ValueHash.Create(2)
-    Assert.notEqual(A, B)
+    Assert.IsEqual('bigint', typeof ValueHash.Hash(1))
+    const A = ValueHash.Hash(1)
+    const B = ValueHash.Hash(2)
+    Assert.NotEqual(A, B)
   })
   it('Should hash string', () => {
-    Assert.isEqual('bigint', typeof ValueHash.Create('hello'))
-    const A = ValueHash.Create('hello')
-    const B = ValueHash.Create('world')
-    Assert.notEqual(A, B)
+    Assert.IsEqual('bigint', typeof ValueHash.Hash('hello'))
+    const A = ValueHash.Hash('hello')
+    const B = ValueHash.Hash('world')
+    Assert.NotEqual(A, B)
   })
   it('Should hash boolean', () => {
-    Assert.isEqual('bigint', typeof ValueHash.Create(true))
-    Assert.isEqual('bigint', typeof ValueHash.Create(false))
-    const A = ValueHash.Create(true)
-    const B = ValueHash.Create(false)
-    Assert.notEqual(A, B)
+    Assert.IsEqual('bigint', typeof ValueHash.Hash(true))
+    Assert.IsEqual('bigint', typeof ValueHash.Hash(false))
+    const A = ValueHash.Hash(true)
+    const B = ValueHash.Hash(false)
+    Assert.NotEqual(A, B)
   })
   it('Should hash null', () => {
-    Assert.isEqual('bigint', typeof ValueHash.Create(null))
-    const A = ValueHash.Create(null)
-    const B = ValueHash.Create(undefined)
-    Assert.notEqual(A, B)
+    Assert.IsEqual('bigint', typeof ValueHash.Hash(null))
+    const A = ValueHash.Hash(null)
+    const B = ValueHash.Hash(undefined)
+    Assert.NotEqual(A, B)
   })
   it('Should hash array', () => {
-    Assert.isEqual('bigint', typeof ValueHash.Create([0, 1, 2, 3]))
-    const A = ValueHash.Create([0, 1, 2, 3])
-    const B = ValueHash.Create([0, 2, 2, 3])
-    Assert.notEqual(A, B)
+    Assert.IsEqual('bigint', typeof ValueHash.Hash([0, 1, 2, 3]))
+    const A = ValueHash.Hash([0, 1, 2, 3])
+    const B = ValueHash.Hash([0, 2, 2, 3])
+    Assert.NotEqual(A, B)
   })
   it('Should hash object 1', () => {
     // prettier-ignore
-    Assert.isEqual('bigint', typeof ValueHash.Create({ x: 1, y: 2 }))
-    const A = ValueHash.Create({ x: 1, y: 2 })
-    const B = ValueHash.Create({ x: 2, y: 2 })
-    Assert.notEqual(A, B)
+    Assert.IsEqual('bigint', typeof ValueHash.Hash({ x: 1, y: 2 }))
+    const A = ValueHash.Hash({ x: 1, y: 2 })
+    const B = ValueHash.Hash({ x: 2, y: 2 })
+    Assert.NotEqual(A, B)
   })
   it('Should hash object 2', () => {
-    const A = ValueHash.Create({ x: 1, y: [1, 2] })
-    const B = ValueHash.Create({ x: 1, y: [1, 3] })
-    Assert.notEqual(A, B)
+    const A = ValueHash.Hash({ x: 1, y: [1, 2] })
+    const B = ValueHash.Hash({ x: 1, y: [1, 3] })
+    Assert.NotEqual(A, B)
   })
   it('Should hash object 3', () => {
-    const A = ValueHash.Create({ x: 1, y: undefined })
-    const B = ValueHash.Create({ x: 1 })
-    Assert.notEqual(A, B)
+    const A = ValueHash.Hash({ x: 1, y: undefined })
+    const B = ValueHash.Hash({ x: 1 })
+    Assert.NotEqual(A, B)
   })
   it('Should hash object 4', () => {
-    const A = ValueHash.Create({ x: 1, y: new Uint8Array([0, 1, 2]) })
-    const B = ValueHash.Create({ x: 1, y: [0, 1, 2] })
-    Assert.notEqual(A, B)
+    const A = ValueHash.Hash({ x: 1, y: new Uint8Array([0, 1, 2]) })
+    const B = ValueHash.Hash({ x: 1, y: [0, 1, 2] })
+    Assert.NotEqual(A, B)
   })
   it('Should hash object 5', () => {
-    const A = ValueHash.Create({ x: 1, y: undefined })
-    const B = ValueHash.Create({ x: 2, y: undefined })
-    Assert.notEqual(A, B)
+    const A = ValueHash.Hash({ x: 1, y: undefined })
+    const B = ValueHash.Hash({ x: 2, y: undefined })
+    Assert.NotEqual(A, B)
   })
   it('Should hash Date', () => {
-    Assert.isEqual('bigint', typeof ValueHash.Create(new Date()))
-    const A = ValueHash.Create(new Date(1))
-    const B = ValueHash.Create(new Date(2))
-    Assert.notEqual(A, B)
+    Assert.IsEqual('bigint', typeof ValueHash.Hash(new Date()))
+    const A = ValueHash.Hash(new Date(1))
+    const B = ValueHash.Hash(new Date(2))
+    Assert.NotEqual(A, B)
   })
   it('Should hash Uint8Array', () => {
-    Assert.isEqual('bigint', typeof ValueHash.Create(new Uint8Array([0, 1, 2, 3])))
-    const A = ValueHash.Create(new Uint8Array([0, 1, 2, 3]))
-    const B = ValueHash.Create(new Uint8Array([0, 2, 2, 3]))
-    Assert.notEqual(A, B)
+    Assert.IsEqual('bigint', typeof ValueHash.Hash(new Uint8Array([0, 1, 2, 3])))
+    const A = ValueHash.Hash(new Uint8Array([0, 1, 2, 3]))
+    const B = ValueHash.Hash(new Uint8Array([0, 2, 2, 3]))
+    Assert.NotEqual(A, B)
   })
   it('Should hash undefined', () => {
-    Assert.isEqual('bigint', typeof ValueHash.Create(undefined))
-    const A = ValueHash.Create(undefined)
-    const B = ValueHash.Create(null)
-    Assert.notEqual(A, B)
+    Assert.IsEqual('bigint', typeof ValueHash.Hash(undefined))
+    const A = ValueHash.Hash(undefined)
+    const B = ValueHash.Hash(null)
+    Assert.NotEqual(A, B)
   })
   it('Should hash symbol 1', () => {
-    Assert.isEqual('bigint', typeof ValueHash.Create(Symbol()))
-    const A = ValueHash.Create(Symbol(1))
-    const B = ValueHash.Create(Symbol())
-    Assert.notEqual(A, B)
+    Assert.IsEqual('bigint', typeof ValueHash.Hash(Symbol()))
+    const A = ValueHash.Hash(Symbol(1))
+    const B = ValueHash.Hash(Symbol())
+    Assert.NotEqual(A, B)
   })
   it('Should hash symbol 2', () => {
-    Assert.isEqual('bigint', typeof ValueHash.Create(Symbol()))
-    const A = ValueHash.Create(Symbol(1))
-    const B = ValueHash.Create(Symbol(2))
-    Assert.notEqual(A, B)
+    Assert.IsEqual('bigint', typeof ValueHash.Hash(Symbol()))
+    const A = ValueHash.Hash(Symbol(1))
+    const B = ValueHash.Hash(Symbol(2))
+    Assert.NotEqual(A, B)
   })
   it('Should hash symbol 2', () => {
-    Assert.isEqual('bigint', typeof ValueHash.Create(Symbol()))
-    const A = ValueHash.Create(Symbol(1))
-    const B = ValueHash.Create(Symbol(1))
-    Assert.isEqual(A, B)
+    Assert.IsEqual('bigint', typeof ValueHash.Hash(Symbol()))
+    const A = ValueHash.Hash(Symbol(1))
+    const B = ValueHash.Hash(Symbol(1))
+    Assert.IsEqual(A, B)
   })
   it('Should hash bigint 1', () => {
-    Assert.isEqual('bigint', typeof ValueHash.Create(BigInt(1)))
-    const A = ValueHash.Create(BigInt(1))
-    const B = ValueHash.Create(BigInt(2))
-    Assert.notEqual(A, B)
+    Assert.IsEqual('bigint', typeof ValueHash.Hash(BigInt(1)))
+    const A = ValueHash.Hash(BigInt(1))
+    const B = ValueHash.Hash(BigInt(2))
+    Assert.NotEqual(A, B)
   })
   it('Should hash bigint 2', () => {
-    Assert.isEqual('bigint', typeof ValueHash.Create(BigInt(1)))
-    const A = ValueHash.Create(BigInt(1))
-    const B = ValueHash.Create(BigInt(1))
-    Assert.isEqual(A, B)
+    Assert.IsEqual('bigint', typeof ValueHash.Hash(BigInt(1)))
+    const A = ValueHash.Hash(BigInt(1))
+    const B = ValueHash.Hash(BigInt(1))
+    Assert.IsEqual(A, B)
   })
 })
diff --git a/test/runtime/value/index.ts b/test/runtime/value/index.ts
index 57403d7b8..e318d92b4 100644
--- a/test/runtime/value/index.ts
+++ b/test/runtime/value/index.ts
@@ -5,6 +5,7 @@ import './convert'
 import './create'
 import './delta'
 import './equal'
+import './guard'
 import './hash'
 import './mutate'
 import './pointer'
diff --git a/test/runtime/value/mutate/mutate.ts b/test/runtime/value/mutate/mutate.ts
index fe5b5d053..f90fcd8f5 100644
--- a/test/runtime/value/mutate/mutate.ts
+++ b/test/runtime/value/mutate/mutate.ts
@@ -7,23 +7,23 @@ describe('value/mutate/Mutate', () => {
   // --------------------------------------------
   it('should throw 1', () => {
     // @ts-ignore
-    Assert.throws(() => Value.Mutate(1, 1))
+    Assert.Throws(() => Value.Mutate(1, 1))
   })
   it('should throw 2', () => {
     // @ts-ignore
-    Assert.throws(() => Value.Mutate({}, 1))
+    Assert.Throws(() => Value.Mutate({}, 1))
   })
   it('should throw 3', () => {
     // @ts-ignore
-    Assert.throws(() => Value.Mutate([], 1))
+    Assert.Throws(() => Value.Mutate([], 1))
   })
   it('should throw 4', () => {
     // @ts-ignore
-    Assert.throws(() => Value.Mutate({}, []))
+    Assert.Throws(() => Value.Mutate({}, []))
   })
   it('should throw 5', () => {
     // @ts-ignore
-    Assert.throws(() => Value.Mutate([], {}))
+    Assert.Throws(() => Value.Mutate([], {}))
   })
   // --------------------------------------------
   // Mutate
@@ -33,56 +33,56 @@ describe('value/mutate/Mutate', () => {
     const X = { y: Y }
     const A = { x: X }
     Value.Mutate(A, {})
-    Assert.isEqual(A, {})
+    Assert.IsEqual(A, {})
   })
   it('Should mutate 1', () => {
     const Y = { z: 1 }
     const X = { y: Y }
     const A = { x: X }
     Value.Mutate(A, { x: { y: { z: 2 } } })
-    Assert.isEqual(A.x.y.z, 2)
-    Assert.isEqual(A.x.y, Y)
-    Assert.isEqual(A.x, X)
+    Assert.IsEqual(A.x.y.z, 2)
+    Assert.IsEqual(A.x.y, Y)
+    Assert.IsEqual(A.x, X)
   })
   it('Should mutate 2', () => {
     const Y = { z: 1 }
     const X = { y: Y }
     const A = { x: X }
     Value.Mutate(A, { x: { y: { z: [1, 2, 3] } } })
-    Assert.isEqual(A.x.y.z, [1, 2, 3])
-    Assert.isEqual(A.x.y, Y)
-    Assert.isEqual(A.x, X)
+    Assert.IsEqual(A.x.y.z, [1, 2, 3])
+    Assert.IsEqual(A.x.y, Y)
+    Assert.IsEqual(A.x, X)
   })
   it('Should mutate 3', () => {
     const Y = { z: 1 }
     const X = { y: Y }
     const A = { x: X }
     Value.Mutate(A, { x: {} })
-    Assert.isEqual(A.x.y, undefined)
-    Assert.isEqual(A.x, X)
+    Assert.IsEqual(A.x.y, undefined)
+    Assert.IsEqual(A.x, X)
   })
   it('Should mutate 4', () => {
     const Y = { z: 1 }
     const X = { y: Y }
     const A = { x: X }
     Value.Mutate(A, { x: { y: 1 } })
-    Assert.isEqual(A.x.y, 1)
-    Assert.isEqual(A.x, X)
+    Assert.IsEqual(A.x.y, 1)
+    Assert.IsEqual(A.x, X)
   })
   it('Should mutate 5', () => {
     const Y = { z: 1 }
     const X = { y: Y }
     const A = { x: X }
     Value.Mutate(A, { x: { y: [1, 2, 3] } })
-    Assert.isEqual(A.x.y, [1, 2, 3])
-    Assert.isEqual(A.x, X)
+    Assert.IsEqual(A.x.y, [1, 2, 3])
+    Assert.IsEqual(A.x, X)
   })
   it('Should mutate 6', () => {
     const Y = { z: 1 }
     const X = { y: Y }
     const A = { x: X }
     Value.Mutate(A, { x: [1, 2, 3] })
-    Assert.notEqual(A.x, X)
-    Assert.isEqual(A.x, [1, 2, 3])
+    Assert.NotEqual(A.x, X)
+    Assert.IsEqual(A.x, [1, 2, 3])
   })
 })
diff --git a/test/runtime/value/pointer/pointer.ts b/test/runtime/value/pointer/pointer.ts
index 6c1ee1652..d359716eb 100644
--- a/test/runtime/value/pointer/pointer.ts
+++ b/test/runtime/value/pointer/pointer.ts
@@ -5,207 +5,172 @@ describe('value/pointer/Pointer', () => {
   //-----------------------------------------------
   // Format
   //-----------------------------------------------
-
   it('Should produce correct format #1', () => {
     const R = [...ValuePointer.Format('')]
-    Assert.isEqual(R, [])
+    Assert.IsEqual(R, [])
   })
-
   it('Should produce correct format #2', () => {
     const R = [...ValuePointer.Format('a')]
-    Assert.isEqual(R, ['a'])
+    Assert.IsEqual(R, ['a'])
   })
-
   it('Should produce correct format #3', () => {
     const R = [...ValuePointer.Format('/')]
-    Assert.isEqual(R, [''])
+    Assert.IsEqual(R, [''])
   })
-
   it('Should produce correct format #4', () => {
     const R = [...ValuePointer.Format('/x')]
-    Assert.isEqual(R, ['x'])
+    Assert.IsEqual(R, ['x'])
   })
-
   it('Should produce correct format #5', () => {
     const R = [...ValuePointer.Format('/x/')]
-    Assert.isEqual(R, ['x', ''])
+    Assert.IsEqual(R, ['x', ''])
   })
-
   it('Should produce correct format #6', () => {
     const R = [...ValuePointer.Format('/x//')]
-    Assert.isEqual(R, ['x', '', ''])
+    Assert.IsEqual(R, ['x', '', ''])
   })
-
   it('Should produce correct format #7', () => {
     const R = [...ValuePointer.Format('/x//y')]
-    Assert.isEqual(R, ['x', '', 'y'])
+    Assert.IsEqual(R, ['x', '', 'y'])
   })
-
   it('Should produce correct format #8', () => {
     const R = [...ValuePointer.Format('/x//y/')]
-    Assert.isEqual(R, ['x', '', 'y', ''])
+    Assert.IsEqual(R, ['x', '', 'y', ''])
   })
-
   it('Should produce correct format #9', () => {
     const R = [...ValuePointer.Format('/x/~0')]
-    Assert.isEqual(R, ['x', '~'])
+    Assert.IsEqual(R, ['x', '~'])
   })
-
   it('Should produce correct format #10', () => {
     const R = [...ValuePointer.Format('/x/~1')]
-    Assert.isEqual(R, ['x', '/'])
+    Assert.IsEqual(R, ['x', '/'])
   })
-
   it('Should produce correct format #11', () => {
     const R = [...ValuePointer.Format('/x/~0/')]
-    Assert.isEqual(R, ['x', '~', ''])
+    Assert.IsEqual(R, ['x', '~', ''])
   })
-
   it('Should produce correct format #12', () => {
     const R = [...ValuePointer.Format('/x/~1/')]
-    Assert.isEqual(R, ['x', '/', ''])
+    Assert.IsEqual(R, ['x', '/', ''])
   })
-
   it('Should produce correct format #13', () => {
     const R = [...ValuePointer.Format('/x/a~0b')]
-    Assert.isEqual(R, ['x', 'a~b'])
+    Assert.IsEqual(R, ['x', 'a~b'])
   })
-
   it('Should produce correct format #14', () => {
     const R = [...ValuePointer.Format('/x/a~1b')]
-    Assert.isEqual(R, ['x', 'a/b'])
+    Assert.IsEqual(R, ['x', 'a/b'])
   })
-
   it('Should produce correct format #15', () => {
     const R = [...ValuePointer.Format('/x/a~0b/')]
-    Assert.isEqual(R, ['x', 'a~b', ''])
+    Assert.IsEqual(R, ['x', 'a~b', ''])
   })
-
   it('Should produce correct format #16', () => {
     const R = [...ValuePointer.Format('/x/a~1b/')]
-    Assert.isEqual(R, ['x', 'a/b', ''])
+    Assert.IsEqual(R, ['x', 'a/b', ''])
   })
-
   it('Should produce correct format #17', () => {
     const R = [...ValuePointer.Format('/x/a~0b///y')]
-    Assert.isEqual(R, ['x', 'a~b', '', '', 'y'])
+    Assert.IsEqual(R, ['x', 'a~b', '', '', 'y'])
   })
-
   it('Should produce correct format #18', () => {
     const R = [...ValuePointer.Format('/x/a~1b///y')]
-    Assert.isEqual(R, ['x', 'a/b', '', '', 'y'])
+    Assert.IsEqual(R, ['x', 'a/b', '', '', 'y'])
   })
-
   it('Should produce correct format #19', () => {
     const R = [...ValuePointer.Format('/x/a~0b///')]
-    Assert.isEqual(R, ['x', 'a~b', '', '', ''])
+    Assert.IsEqual(R, ['x', 'a~b', '', '', ''])
   })
-
   it('Should produce correct format #20', () => {
     const R = [...ValuePointer.Format('/x/a~1b///')]
-    Assert.isEqual(R, ['x', 'a/b', '', '', ''])
+    Assert.IsEqual(R, ['x', 'a/b', '', '', ''])
   })
-
   //-----------------------------------------------
   // Get
   //-----------------------------------------------
-
   it('Should get array #1', () => {
     const V = [0, 1, 2, 3]
-    Assert.isEqual(ValuePointer.Get(V, ''), [0, 1, 2, 3])
-    Assert.isEqual(ValuePointer.Get(V, '/'), undefined)
-    Assert.isEqual(ValuePointer.Get(V, '/0'), 0)
-    Assert.isEqual(ValuePointer.Get(V, '/1'), 1)
-    Assert.isEqual(ValuePointer.Get(V, '/2'), 2)
-    Assert.isEqual(ValuePointer.Get(V, '/3'), 3)
+    Assert.IsEqual(ValuePointer.Get(V, ''), [0, 1, 2, 3])
+    Assert.IsEqual(ValuePointer.Get(V, '/'), undefined)
+    Assert.IsEqual(ValuePointer.Get(V, '/0'), 0)
+    Assert.IsEqual(ValuePointer.Get(V, '/1'), 1)
+    Assert.IsEqual(ValuePointer.Get(V, '/2'), 2)
+    Assert.IsEqual(ValuePointer.Get(V, '/3'), 3)
   })
-
   it('Should get array #2', () => {
     const V = [{ x: 0 }, { x: 1 }, { x: 2 }, { x: 3 }]
-    Assert.isEqual(ValuePointer.Get(V, ''), [{ x: 0 }, { x: 1 }, { x: 2 }, { x: 3 }])
-    Assert.isEqual(ValuePointer.Get(V, '/'), undefined)
-    Assert.isEqual(ValuePointer.Get(V, '/0'), { x: 0 })
-    Assert.isEqual(ValuePointer.Get(V, '/1'), { x: 1 })
-    Assert.isEqual(ValuePointer.Get(V, '/2'), { x: 2 })
-    Assert.isEqual(ValuePointer.Get(V, '/3'), { x: 3 })
-    Assert.isEqual(ValuePointer.Get(V, '/0/x'), 0)
-    Assert.isEqual(ValuePointer.Get(V, '/1/x'), 1)
-    Assert.isEqual(ValuePointer.Get(V, '/2/x'), 2)
-    Assert.isEqual(ValuePointer.Get(V, '/3/x'), 3)
+    Assert.IsEqual(ValuePointer.Get(V, ''), [{ x: 0 }, { x: 1 }, { x: 2 }, { x: 3 }])
+    Assert.IsEqual(ValuePointer.Get(V, '/'), undefined)
+    Assert.IsEqual(ValuePointer.Get(V, '/0'), { x: 0 })
+    Assert.IsEqual(ValuePointer.Get(V, '/1'), { x: 1 })
+    Assert.IsEqual(ValuePointer.Get(V, '/2'), { x: 2 })
+    Assert.IsEqual(ValuePointer.Get(V, '/3'), { x: 3 })
+    Assert.IsEqual(ValuePointer.Get(V, '/0/x'), 0)
+    Assert.IsEqual(ValuePointer.Get(V, '/1/x'), 1)
+    Assert.IsEqual(ValuePointer.Get(V, '/2/x'), 2)
+    Assert.IsEqual(ValuePointer.Get(V, '/3/x'), 3)
   })
-
   it('Should get object #1', () => {
     const V = { x: 0, y: 1, z: 2 }
-    Assert.isEqual(ValuePointer.Get(V, ''), { x: 0, y: 1, z: 2 })
-    Assert.isEqual(ValuePointer.Get(V, '/'), undefined)
-    Assert.isEqual(ValuePointer.Get(V, '/x'), 0)
-    Assert.isEqual(ValuePointer.Get(V, '/y'), 1)
-    Assert.isEqual(ValuePointer.Get(V, '/z'), 2)
+    Assert.IsEqual(ValuePointer.Get(V, ''), { x: 0, y: 1, z: 2 })
+    Assert.IsEqual(ValuePointer.Get(V, '/'), undefined)
+    Assert.IsEqual(ValuePointer.Get(V, '/x'), 0)
+    Assert.IsEqual(ValuePointer.Get(V, '/y'), 1)
+    Assert.IsEqual(ValuePointer.Get(V, '/z'), 2)
   })
-
   it('Should get object #2', () => {
     const V = { x: { x: 0 }, y: { x: 1 }, z: { x: 2 } }
-    Assert.isEqual(ValuePointer.Get(V, ''), { x: { x: 0 }, y: { x: 1 }, z: { x: 2 } })
-    Assert.isEqual(ValuePointer.Get(V, '/'), undefined)
-    Assert.isEqual(ValuePointer.Get(V, '/x'), { x: 0 })
-    Assert.isEqual(ValuePointer.Get(V, '/y'), { x: 1 })
-    Assert.isEqual(ValuePointer.Get(V, '/z'), { x: 2 })
+    Assert.IsEqual(ValuePointer.Get(V, ''), { x: { x: 0 }, y: { x: 1 }, z: { x: 2 } })
+    Assert.IsEqual(ValuePointer.Get(V, '/'), undefined)
+    Assert.IsEqual(ValuePointer.Get(V, '/x'), { x: 0 })
+    Assert.IsEqual(ValuePointer.Get(V, '/y'), { x: 1 })
+    Assert.IsEqual(ValuePointer.Get(V, '/z'), { x: 2 })
   })
-
   it('Should get object #3', () => {
     const V = { '': { x: -1 }, x: { '': { x: 1 } }, y: { '': { x: 2 } }, z: { '': { x: 3 } } }
-    Assert.isEqual(ValuePointer.Get(V, ''), { '': { x: -1 }, x: { '': { x: 1 } }, y: { '': { x: 2 } }, z: { '': { x: 3 } } })
-    Assert.isEqual(ValuePointer.Get(V, '/'), { x: -1 })
-    Assert.isEqual(ValuePointer.Get(V, '/x'), { '': { x: 1 } })
-    Assert.isEqual(ValuePointer.Get(V, '/y'), { '': { x: 2 } })
-    Assert.isEqual(ValuePointer.Get(V, '/z'), { '': { x: 3 } })
-    Assert.isEqual(ValuePointer.Get(V, '/x/'), { x: 1 })
-    Assert.isEqual(ValuePointer.Get(V, '/y/'), { x: 2 })
-    Assert.isEqual(ValuePointer.Get(V, '/z/'), { x: 3 })
-    Assert.isEqual(ValuePointer.Get(V, '/x//x'), 1)
-    Assert.isEqual(ValuePointer.Get(V, '/y//x'), 2)
-    Assert.isEqual(ValuePointer.Get(V, '/z//x'), 3)
+    Assert.IsEqual(ValuePointer.Get(V, ''), { '': { x: -1 }, x: { '': { x: 1 } }, y: { '': { x: 2 } }, z: { '': { x: 3 } } })
+    Assert.IsEqual(ValuePointer.Get(V, '/'), { x: -1 })
+    Assert.IsEqual(ValuePointer.Get(V, '/x'), { '': { x: 1 } })
+    Assert.IsEqual(ValuePointer.Get(V, '/y'), { '': { x: 2 } })
+    Assert.IsEqual(ValuePointer.Get(V, '/z'), { '': { x: 3 } })
+    Assert.IsEqual(ValuePointer.Get(V, '/x/'), { x: 1 })
+    Assert.IsEqual(ValuePointer.Get(V, '/y/'), { x: 2 })
+    Assert.IsEqual(ValuePointer.Get(V, '/z/'), { x: 3 })
+    Assert.IsEqual(ValuePointer.Get(V, '/x//x'), 1)
+    Assert.IsEqual(ValuePointer.Get(V, '/y//x'), 2)
+    Assert.IsEqual(ValuePointer.Get(V, '/z//x'), 3)
   })
-
   //-----------------------------------------------
   // Has
   //-----------------------------------------------
-
   it('Should return has true for undefined', () => {
     const V = undefined
-    Assert.isEqual(ValuePointer.Has(V, ''), true)
+    Assert.IsEqual(ValuePointer.Has(V, ''), true)
   })
-
   it('Should return has true for null', () => {
     const V = null
-    Assert.isEqual(ValuePointer.Has(V, ''), true)
+    Assert.IsEqual(ValuePointer.Has(V, ''), true)
   })
-
   it('Should return has true for object', () => {
     const V = {}
-    Assert.isEqual(ValuePointer.Has(V, ''), true)
+    Assert.IsEqual(ValuePointer.Has(V, ''), true)
   })
-
   it('Should return has true for array', () => {
     const V: any[] = []
-    Assert.isEqual(ValuePointer.Has(V, ''), true)
+    Assert.IsEqual(ValuePointer.Has(V, ''), true)
   })
-
   it('Should return has true for string', () => {
     const V = 'hello'
-    Assert.isEqual(ValuePointer.Has(V, ''), true)
+    Assert.IsEqual(ValuePointer.Has(V, ''), true)
   })
-
   it('Should return has true for number', () => {
     const V = 42
-    Assert.isEqual(ValuePointer.Has(V, ''), true)
+    Assert.IsEqual(ValuePointer.Has(V, ''), true)
   })
-
   it('Should return has true for boolean', () => {
     const V = false
-    Assert.isEqual(ValuePointer.Has(V, ''), true)
+    Assert.IsEqual(ValuePointer.Has(V, ''), true)
   })
-
   it('Should return has true for deeply nested', () => {
     const V = {
       '': { x: { y: { z: 1 } } },
@@ -216,58 +181,52 @@ describe('value/pointer/Pointer', () => {
       n: null,
     }
     // exists
-    Assert.isEqual(ValuePointer.Has(V, ''), true)
-    Assert.isEqual(ValuePointer.Has(V, '/'), true)
-    Assert.isEqual(ValuePointer.Has(V, '//x'), true)
-    Assert.isEqual(ValuePointer.Has(V, '//x/y'), true)
-    Assert.isEqual(ValuePointer.Has(V, '//x/y/z'), true)
-    Assert.isEqual(ValuePointer.Has(V, '/x'), true)
-    Assert.isEqual(ValuePointer.Has(V, '/y/x'), true)
-    Assert.isEqual(ValuePointer.Has(V, '/z'), true)
-    Assert.isEqual(ValuePointer.Has(V, '/z/0'), true)
-    Assert.isEqual(ValuePointer.Has(V, '/z/0/x'), true)
-    Assert.isEqual(ValuePointer.Has(V, '/z/1'), true)
-    Assert.isEqual(ValuePointer.Has(V, '/z/1/y'), true)
-    Assert.isEqual(ValuePointer.Has(V, '/x'), true)
-    Assert.isEqual(ValuePointer.Has(V, '/n'), true)
+    Assert.IsEqual(ValuePointer.Has(V, ''), true)
+    Assert.IsEqual(ValuePointer.Has(V, '/'), true)
+    Assert.IsEqual(ValuePointer.Has(V, '//x'), true)
+    Assert.IsEqual(ValuePointer.Has(V, '//x/y'), true)
+    Assert.IsEqual(ValuePointer.Has(V, '//x/y/z'), true)
+    Assert.IsEqual(ValuePointer.Has(V, '/x'), true)
+    Assert.IsEqual(ValuePointer.Has(V, '/y/x'), true)
+    Assert.IsEqual(ValuePointer.Has(V, '/z'), true)
+    Assert.IsEqual(ValuePointer.Has(V, '/z/0'), true)
+    Assert.IsEqual(ValuePointer.Has(V, '/z/0/x'), true)
+    Assert.IsEqual(ValuePointer.Has(V, '/z/1'), true)
+    Assert.IsEqual(ValuePointer.Has(V, '/z/1/y'), true)
+    Assert.IsEqual(ValuePointer.Has(V, '/x'), true)
+    Assert.IsEqual(ValuePointer.Has(V, '/n'), true)
   })
-
   //-----------------------------------------------
   // Set
   //-----------------------------------------------
-
   it('Should throw when setting root', () => {
     const V = {}
-    Assert.throws(() => ValuePointer.Set(V, '', { x: 1 }))
+    Assert.Throws(() => ValuePointer.Set(V, '', { x: 1 }))
   })
-
   it('Should set array values', () => {
     const V = [0, 1, 2]
     ValuePointer.Set(V, '/0', 3)
     ValuePointer.Set(V, '/1', 4)
     ValuePointer.Set(V, '/2', 5)
-    Assert.isEqual(V, [3, 4, 5])
+    Assert.IsEqual(V, [3, 4, 5])
   })
-
   it('Should set object values', () => {
     const V = { x: 0, y: 1, z: 2 }
     ValuePointer.Set(V, '/x', 3)
     ValuePointer.Set(V, '/y', 4)
     ValuePointer.Set(V, '/z', 5)
-    Assert.isEqual(V, { x: 3, y: 4, z: 5 })
+    Assert.IsEqual(V, { x: 3, y: 4, z: 5 })
   })
-
   it('Should set object values recursively #1', () => {
     const V = {}
     ValuePointer.Set(V, '/x/y/z', 1)
-    Assert.isEqual(V, { x: { y: { z: 1 } } })
+    Assert.IsEqual(V, { x: { y: { z: 1 } } })
   })
-
   it('Should set object values recursively #2', () => {
     const V = {}
     ValuePointer.Set(V, '/x/0/y/z/', 1)
     ValuePointer.Set(V, '/x/1/y/z/', 2)
-    Assert.isEqual(V, {
+    Assert.IsEqual(V, {
       x: {
         0: {
           y: {
@@ -286,16 +245,13 @@ describe('value/pointer/Pointer', () => {
       },
     })
   })
-
   //-----------------------------------------------
   // Delete
   //-----------------------------------------------
-
   it('Should throw when deleting root', () => {
     const V = {}
-    Assert.throws(() => ValuePointer.Delete(V, ''))
+    Assert.Throws(() => ValuePointer.Delete(V, ''))
   })
-
   it('Should delete object properties', () => {
     const V = {
       x: { x: 1, y: 2, z: 3 },
@@ -303,9 +259,8 @@ describe('value/pointer/Pointer', () => {
     }
     ValuePointer.Delete(V, '/x/y')
     ValuePointer.Delete(V, '/y')
-    Assert.isEqual(V, { x: { x: 1, z: 3 } })
+    Assert.IsEqual(V, { x: { x: 1, z: 3 } })
   })
-
   it('Should be a noop if property does not exist', () => {
     const V = {
       x: { x: 1, y: 2, z: 3 },
@@ -313,84 +268,74 @@ describe('value/pointer/Pointer', () => {
     }
     ValuePointer.Delete(V, '/x/w')
     ValuePointer.Delete(V, '/w')
-    Assert.isEqual(V, {
+    Assert.IsEqual(V, {
       x: { x: 1, y: 2, z: 3 },
       y: { x: 3, y: 4, z: 5 },
     })
   })
-
   it('Should not delete owner', () => {
     const V = { x: { y: { z: 1 } } }
     ValuePointer.Delete(V, '/x/y/z')
-    Assert.isEqual(V, { x: { y: {} } })
+    Assert.IsEqual(V, { x: { y: {} } })
   })
-
   it('Should delete owner', () => {
     const V = { x: { y: { z: 1 } } }
     ValuePointer.Delete(V, '/x/y')
-    Assert.isEqual(V, { x: {} })
+    Assert.IsEqual(V, { x: {} })
   })
-
   it('Should not throw if deleting null property', () => {
     const V = { x: { y: null } }
     ValuePointer.Delete(V, '/x/y/z')
-    Assert.isEqual(V, { x: { y: null } })
+    Assert.IsEqual(V, { x: { y: null } })
   })
-
   //-----------------------------------------------
   // Escapes
   //-----------------------------------------------
-
   it('Should support get ~0 pointer escape', () => {
     const V = {
       x: { '~': { x: 1 } },
     }
-    Assert.isEqual(ValuePointer.Get(V, '/x/~0'), { x: 1 })
+    Assert.IsEqual(ValuePointer.Get(V, '/x/~0'), { x: 1 })
   })
-
   it('Should support get ~1 pointer escape', () => {
     const V = {
       x: { '/': { x: 1 } },
     }
-    Assert.isEqual(ValuePointer.Get(V, '/x/~1'), { x: 1 })
+    Assert.IsEqual(ValuePointer.Get(V, '/x/~1'), { x: 1 })
   })
-
   it('Should support set ~0 pointer escape', () => {
     const V = {
       x: { '~': { x: 1 } },
     }
     ValuePointer.Set(V, '/x/~0', { x: 2 })
-    Assert.isEqual(V, {
+    Assert.IsEqual(V, {
       x: { '~': { x: 2 } },
     })
   })
-
   it('Should support set ~1 pointer escape', () => {
     const V = {
       x: { '/': { x: 1 } },
     }
     ValuePointer.Set(V, '/x/~1', { x: 2 })
-    Assert.isEqual(V, {
+    Assert.IsEqual(V, {
       x: { '/': { x: 2 } },
     })
   })
-
   it('Should support delete ~0 pointer escape', () => {
     const V = {
       x: { '~': { x: 1 } },
     }
     ValuePointer.Delete(V, '/x/~0')
-    Assert.isEqual(V, {
+    Assert.IsEqual(V, {
       x: {},
     })
   })
-
   it('Should support delete ~1 pointer escape', () => {
     const V = {
       x: { '/': { x: 1 } },
     }
     ValuePointer.Delete(V, '/x/~1')
-    Assert.isEqual(V, {
+    Assert.IsEqual(V, {
       x: {},
     })
   })
diff --git a/test/static/async-iterator.ts b/test/static/async-iterator.ts
new file mode 100644
index 000000000..3d8d8fd1a
--- /dev/null
+++ b/test/static/async-iterator.ts
@@ -0,0 +1,4 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.AsyncIterator(Type.String())).ToInfer<AsyncIterableIterator<string>>()
diff --git a/test/static/awaited.ts b/test/static/awaited.ts
new file mode 100644
index 000000000..f8b0f8228
--- /dev/null
+++ b/test/static/awaited.ts
@@ -0,0 +1,20 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.Awaited(Type.String())).ToInfer<string>()
+
+Expect(Type.Awaited(Type.Promise(Type.String()))).ToInfer<string>()
+
+Expect(Type.Awaited(Type.Promise(Type.Promise(Type.String())))).ToInfer<string>()
+
+// One Level
+
+Expect(Type.Awaited(Type.Union([Type.Promise(Type.String()), Type.Number()]))).ToInfer<string | number>()
+
+Expect(Type.Awaited(Type.Intersect([Type.Promise(Type.String()), Type.Number()]))).ToInfer<string & number>()
+
+// Two Levels
+
+Expect(Type.Awaited(Type.Union([Type.Promise(Type.Promise(Type.String())), Type.Number()]))).ToInfer<string | number>()
+
+Expect(Type.Awaited(Type.Intersect([Type.Promise(Type.Promise(Type.String())), Type.Number()]))).ToInfer<string & number>()
diff --git a/test/static/capitalize.ts b/test/static/capitalize.ts
new file mode 100644
index 000000000..a72fa79cc
--- /dev/null
+++ b/test/static/capitalize.ts
@@ -0,0 +1,4 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.Capitalize(Type.Literal('hello'))).ToInfer<'Hello'>()
diff --git a/test/static/index.ts b/test/static/index.ts
index 7cb57c759..be70f8a5c 100644
--- a/test/static/index.ts
+++ b/test/static/index.ts
@@ -1,7 +1,10 @@
 import './any'
 import './array'
+import './async-iterator'
+import './awaited'
 import './bigint'
 import './boolean'
+import './capitalize'
 import './composite'
 import './date'
 import './constructor-parameters'
@@ -13,8 +16,10 @@ import './function'
 import './indexed'
 import './instance-type'
 import './intersect'
+import './iterator'
 import './keyof'
 import './literal'
+import './lowercase'
 import './modifier'
 import './namespace'
 import './never'
@@ -32,7 +37,7 @@ import './readonly'
 import './recursive'
 import './record'
 import './ref'
-import './regex'
+import './regexp'
 import './required'
 import './rest'
 import './return-type'
@@ -41,5 +46,7 @@ import './string'
 import './symbol'
 import './template-literal'
 import './tuple'
+import './uncapitalize'
 import './union'
 import './unknown'
+import './uppercase'
diff --git a/test/static/iterator.ts b/test/static/iterator.ts
new file mode 100644
index 000000000..4728ad035
--- /dev/null
+++ b/test/static/iterator.ts
@@ -0,0 +1,4 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.Iterator(Type.String())).ToInfer<IterableIterator<string>>()
diff --git a/test/static/lowercase.ts b/test/static/lowercase.ts
new file mode 100644
index 000000000..56f9c2732
--- /dev/null
+++ b/test/static/lowercase.ts
@@ -0,0 +1,4 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.Lowercase(Type.Literal('HELLO'))).ToInfer<'hello'>()
diff --git a/test/static/modifier.ts b/test/static/modifier.ts
index c0950bdf2..07186f6d2 100644
--- a/test/static/modifier.ts
+++ b/test/static/modifier.ts
@@ -1,5 +1,5 @@
 import { Expect } from './assert'
-import { Type } from '@sinclair/typebox'
+import { Type, TSchema } from '@sinclair/typebox'
 
 // Asserts combinatory modifiers
 {
diff --git a/test/static/readonly-optional.ts b/test/static/readonly-optional.ts
index 622e809e2..377cab0cf 100644
--- a/test/static/readonly-optional.ts
+++ b/test/static/readonly-optional.ts
@@ -1,5 +1,5 @@
 import { Expect } from './assert'
-import { Type, Static } from '@sinclair/typebox'
+import { Type, TSchema } from '@sinclair/typebox'
 
 {
   const T = Type.Object({
diff --git a/test/static/record.ts b/test/static/record.ts
index 207e30d3f..7338d5f26 100644
--- a/test/static/record.ts
+++ b/test/static/record.ts
@@ -10,7 +10,7 @@ import { Type, Static } from '@sinclair/typebox'
 }
 {
   // type K = string
-  const K = Type.RegEx(/foo|bar/)
+  const K = Type.RegExp(/foo|bar/)
   const T = Type.Record(K, Type.Number())
   type T = Static<typeof T>
   Expect(T).ToInfer<Record<string, number>>()
diff --git a/test/static/regex.ts b/test/static/regexp.ts
similarity index 62%
rename from test/static/regex.ts
rename to test/static/regexp.ts
index ea2769da7..60feac2af 100644
--- a/test/static/regex.ts
+++ b/test/static/regexp.ts
@@ -1,4 +1,4 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.RegEx(/foo/)).ToInfer<string>()
+Expect(Type.RegExp(/foo/)).ToInfer<string>()
diff --git a/test/static/required.ts b/test/static/required.ts
index 30aa9ca1d..d688584b1 100644
--- a/test/static/required.ts
+++ b/test/static/required.ts
@@ -1,8 +1,5 @@
 import { Expect } from './assert'
 import { Type, Static } from '@sinclair/typebox'
-
-Expect(Type.RegEx(/foo/)).ToInfer<string>()
-
 {
   const T = Type.Required(
     Type.Object({
diff --git a/test/static/uncapitalize.ts b/test/static/uncapitalize.ts
new file mode 100644
index 000000000..4d7cb5afe
--- /dev/null
+++ b/test/static/uncapitalize.ts
@@ -0,0 +1,4 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.Uncapitalize(Type.Literal('HELLO'))).ToInfer<'hELLO'>()
diff --git a/test/static/uppercase.ts b/test/static/uppercase.ts
new file mode 100644
index 000000000..a8fcd1821
--- /dev/null
+++ b/test/static/uppercase.ts
@@ -0,0 +1,4 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+Expect(Type.Uppercase(Type.Literal('hello'))).ToInfer<'HELLO'>()
diff --git a/tsconfig.json b/tsconfig.json
index 0932a6a80..41a696de3 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -16,6 +16,39 @@
       "@sinclair/typebox/system": [
         "src/system/index.ts"
       ],
+      "@sinclair/typebox/value/cast": [
+        "src/value/cast.ts"
+      ],
+      "@sinclair/typebox/value/check": [
+        "src/value/check.ts"
+      ],
+      "@sinclair/typebox/value/clone": [
+        "src/value/clone.ts"
+      ],
+      "@sinclair/typebox/value/convert": [
+        "src/value/convert.ts"
+      ],
+      "@sinclair/typebox/value/create": [
+        "src/value/create.ts"
+      ],
+      "@sinclair/typebox/value/delta": [
+        "src/value/delta.ts"
+      ],
+      "@sinclair/typebox/value/equal": [
+        "src/value/equal.ts"
+      ],
+      "@sinclair/typebox/value/guard": [
+        "src/value/guard.ts"
+      ],
+      "@sinclair/typebox/value/hash": [
+        "src/value/hash.ts"
+      ],
+      "@sinclair/typebox/value/mutate": [
+        "src/value/mutate.ts"
+      ],
+      "@sinclair/typebox/value/pointer": [
+        "src/value/pointer.ts"
+      ],
       "@sinclair/typebox/value": [
         "src/value/index.ts"
       ],

From 61efbc17f6de6de462cca012ae979292ee450ad1 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 1 Aug 2023 15:55:43 +0900
Subject: [PATCH 164/369] Revision 0.30.0

---
 examples/transform/transform.ts | 10 +++++++---
 readme.md                       |  2 +-
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/examples/transform/transform.ts b/examples/transform/transform.ts
index 31d20f26c..32b9a15c2 100644
--- a/examples/transform/transform.ts
+++ b/examples/transform/transform.ts
@@ -133,9 +133,13 @@ function TNumber(schema: Types.TNumber, references: Types.TSchema[], value: any,
   return Apply(schema, value, mode)
 }
 function TObject(schema: Types.TObject, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Object.keys(schema.properties).reduce((acc, key) => {
-    return value[key] !== undefined ? { ...acc, [key]: Visit(schema.properties[key], references, value[key], mode) } : { ...acc }
-  }, value)
+  const transformed = Apply(schema, value, mode)
+  const properties = Object.keys(transformed).reduce((acc, key) => {
+    return key in schema.properties 
+      ? { ...acc, [key]: Visit(schema.properties[key], references, transformed[key], mode) }
+      : { ...acc, [key]: transformed[key] }
+  }, {})
+  return { ...properties }
 }
 function TPromise(schema: Types.TSchema, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
   return Apply(schema, value, mode)
diff --git a/readme.md b/readme.md
index 2e8f6e443..527bdd325 100644
--- a/readme.md
+++ b/readme.md
@@ -110,7 +110,7 @@ License MIT
   - [Types](#typesystem-types)
   - [Formats](#typesystem-formats)
   - [Policies](#typesystem-policies)
-- [Transform](#Transform)
+- [Transform](#transform)
 - [Ecosystem](#ecosystem)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)

From 72ffd1abca6337a1dc11e304d1c6428ab93ca973 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 2 Aug 2023 19:24:22 +0900
Subject: [PATCH 165/369] Intrinsic String Mapping (#516)

---
 package-lock.json                        |   4 +-
 package.json                             |   2 +-
 readme.md                                |  63 +++++++++-
 src/typebox.ts                           | 121 ++++++++++++++++---
 test/runtime/compiler/partial.ts         |  10 +-
 test/runtime/type/guard/capitalize.ts    |  23 +++-
 test/runtime/type/guard/lowercase.ts     |  23 +++-
 test/runtime/type/guard/uncapitalize.ts  |  24 +++-
 test/runtime/type/guard/uppercase.ts     |  24 +++-
 test/runtime/type/index.ts               |   1 +
 test/runtime/type/intrinsic/index.ts     |   1 +
 test/runtime/type/intrinsic/intrinsic.ts | 143 +++++++++++++++++++++++
 test/static/capitalize.ts                |   7 ++
 test/static/lowercase.ts                 |   7 ++
 test/static/uncapitalize.ts              |   7 ++
 test/static/uppercase.ts                 |   7 ++
 16 files changed, 426 insertions(+), 41 deletions(-)
 create mode 100644 test/runtime/type/intrinsic/index.ts
 create mode 100644 test/runtime/type/intrinsic/intrinsic.ts

diff --git a/package-lock.json b/package-lock.json
index 2c3f6f9a9..96f1ad970 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.30.0",
+  "version": "0.30.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.30.0",
+      "version": "0.30.1",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 7f372b309..bd16d7149 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.30.0",
+  "version": "0.30.1",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 527bdd325..8a071cfc4 100644
--- a/readme.md
+++ b/readme.md
@@ -84,6 +84,7 @@ License MIT
   - [Recursive](#types-recursive)
   - [Conditional](#types-conditional)
   - [Template Literal](#types-template-literal)
+  - [Intrinsic String](#types-intrinsic-string)
   - [Indexed](#types-indexed)
   - [Negated](#types-negated)
   - [Rest](#types-rest)
@@ -486,6 +487,30 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │ ])                             │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Uncapitalize(   │ type T = Uncapitalize<      │ const T = {                    │
+│   Type.Literal('Hello')        │   'Hello'                   │    type: 'string',             │
+│ )                              │ >                           │    const: 'hello'              │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Capitalize(     │ type T = Capitalize<        │ const T = {                    │
+│   Type.Literal('hello')        │   'hello'                   │    type: 'string',             │
+│ )                              │ >                           │    const: 'Hello'              │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Uppercase(      │ type T = Uppercase<         │ const T = {                    │
+│   Type.Literal('hello')        │   'hello'                   │    type: 'string',             │
+│ )                              │ >                           │    const: 'HELLO'              │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Lowercase(      │ type T = Lowercase<         │ const T = {                    │
+│   Type.Literal('HELLO')        │   'HELLO'                   │    type: 'string',             │
+│ )                              │ >                           │    const: 'hello'              │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Object({        │ type T = {                  │ const R = {                    │
 │    x: Type.Number(),           │   x: number,                │   $ref: 'T'                    │
 │    y: Type.Number()            │   y: number                 │ }                              │
@@ -851,6 +876,34 @@ const R = Type.Record(T, Type.String())              // const R = {
                                                      // }
 ```
 
+<a name='types-intrinsic-string'></a>
+
+### Intrinsic String Types
+
+TypeBox supports a set of intrinsic string mapping functions which can be used on string literals. These functions match the TypeScript string intrinsic types `Uppercase`, `Lowercase`, `Capitalize` and `Uncapitalize`. These functions are supported for literal strings, template literals and union types. The following shows the literal string usage.
+
+```typescript
+// TypeScript
+
+type A = Uncapitalize<'HELLO'>                      // type A = 'hELLO'
+
+type B = Capitalize<'hello'>                        // type B = 'Hello'
+
+type C = Uppercase<'hello'>                         // type C = 'HELLO'
+
+type D = Lowercase<'HELLO'>                         // type D = 'hello'
+
+// TypeBox
+
+const A = Type.Uncapitalize(Type.Literal('HELLO')) // const A: TLiteral<'hELLO'>
+
+const B = Type.Capitalize(Type.Literal('hello'))   // const B: TLiteral<'Hello'>
+
+const C = Type.Uppercase(Type.Literal('hello'))    // const C: TLiteral<'HELLO'>
+
+const D = Type.Lowercase(Type.Literal('HELLO'))    // const D: TLiteral<'hello'>
+```
+
 <a name='types-indexed'></a>
 
 ### Indexed Access Types
@@ -1586,11 +1639,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '129.4 kb' │ ' 58.6 kb' │  '2.21 x'   │
-│ typebox/errors       │ '111.6 kb' │ ' 50.1 kb' │  '2.23 x'   │
-│ typebox/system       │ ' 76.5 kb' │ ' 31.7 kb' │  '2.41 x'   │
-│ typebox/value        │ '180.7 kb' │ ' 79.3 kb' │  '2.28 x'   │
-│ typebox              │ ' 75.4 kb' │ ' 31.3 kb' │  '2.41 x'   │
+│ typebox/compiler     │ '131.4 kb' │ ' 59.4 kb' │  '2.21 x'   │
+│ typebox/errors       │ '113.6 kb' │ ' 50.9 kb' │  '2.23 x'   │
+│ typebox/system       │ ' 78.5 kb' │ ' 32.5 kb' │  '2.42 x'   │
+│ typebox/value        │ '182.8 kb' │ ' 80.0 kb' │  '2.28 x'   │
+│ typebox              │ ' 77.4 kb' │ ' 32.0 kb' │  '2.42 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/typebox.ts b/src/typebox.ts
index 2e7c407cf..8211fece1 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -248,7 +248,7 @@ export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
   items: T
 }
 // -------------------------------------------------------------------------------
-// Awaited
+// TAwaited
 // -------------------------------------------------------------------------------
 // prettier-ignore
 export type TAwaitedRest<T extends TSchema[]> = T extends [infer L, ...infer R]
@@ -394,7 +394,6 @@ export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema =
 // --------------------------------------------------------------------------
 // TIndex
 // --------------------------------------------------------------------------
-
 export type TIndexRest<T extends TSchema[], K extends TPropertyKey> = T extends [infer L, ...infer R] ? [TIndexType<AssertType<L>, K>, ...TIndexRest<AssertRest<R>, K>] : []
 export type TIndexProperty<T extends TProperties, K extends TPropertyKey> = K extends keyof T ? [T[K]] : []
 export type TIndexTuple<T extends TSchema[], K extends TPropertyKey> = K extends keyof T ? [T[K]] : []
@@ -419,6 +418,34 @@ export type TIndex<T extends TSchema, K extends TPropertyKey[]> =
   T extends TTuple     ? UnionType<Flat<TIndexRestMany<T, K>>> :
   TNever
 // --------------------------------------------------------------------------
+// TIntrinsic
+// --------------------------------------------------------------------------
+export type TIntrinsicMode = 'Uppercase' | 'Lowercase' | 'Capitalize' | 'Uncapitalize'
+// prettier-ignore
+export type TIntrinsicTemplateLiteral<T extends TTemplateLiteralKind[], M extends TIntrinsicMode> =
+  M extends ('Lowercase' | 'Uppercase')     ? T extends [infer L, ...infer R] ? [TIntrinsic<AssertType<L>, M>, ...TIntrinsicTemplateLiteral<AssertRest<R>, M>] : T :  
+  M extends ('Capitalize' | 'Uncapitalize') ? T extends [infer L, ...infer R] ? [TIntrinsic<AssertType<L>, M>, ...R] : T :  
+  T
+// prettier-ignore
+export type TIntrinsicLiteral<T, M extends TIntrinsicMode> = 
+  T extends string ? 
+    M extends 'Uncapitalize' ? Uncapitalize<T> :  
+    M extends 'Capitalize' ? Capitalize<T> :
+    M extends 'Uppercase' ? Uppercase<T> :
+    M extends 'Lowercase' ? Lowercase<T> :
+    string
+  : ''
+// prettier-ignore
+export type TIntrinsicRest<T extends TSchema[], M extends TIntrinsicMode> = T extends [infer L, ...infer R]
+  ? [TIntrinsic<AssertType<L>, M>, ...TIntrinsicRest<AssertRest<R>, M>]
+  : []
+// prettier-ignore
+export type TIntrinsic<T extends TSchema, M extends TIntrinsicMode> =
+  T extends TTemplateLiteral<infer S> ? TTemplateLiteral<TIntrinsicTemplateLiteral<S, M>> :
+  T extends TUnion<infer S> ? TUnion<TIntrinsicRest<S, M>> :
+  T extends TLiteral<infer S> ? TLiteral<TIntrinsicLiteral<S, M>> :
+  T
+// --------------------------------------------------------------------------
 // TInteger
 // --------------------------------------------------------------------------
 export interface TInteger extends TSchema, NumericOptions<number> {
@@ -1306,8 +1333,15 @@ export namespace TypeGuard {
   }
   /** Returns true if the given schema is TString */
   export function TString(schema: unknown): schema is TString {
+    // prettier-ignore
     return (
-      TKindOf(schema, 'String') && schema.type === 'string' && IsOptionalString(schema.$id) && IsOptionalNumber(schema.minLength) && IsOptionalNumber(schema.maxLength) && IsOptionalPattern(schema.pattern) && IsOptionalFormat(schema.format)
+      TKindOf(schema, 'String') && 
+      schema.type === 'string' && 
+      IsOptionalString(schema.$id) && 
+      IsOptionalNumber(schema.minLength) && 
+      IsOptionalNumber(schema.maxLength) && 
+      IsOptionalPattern(schema.pattern) && 
+      IsOptionalFormat(schema.format)
     )
   }
   /** Returns true if the given schema is TSymbol */
@@ -2106,6 +2140,61 @@ export namespace IndexedAccessor {
   }
 }
 // --------------------------------------------------------------------------
+// Intrinsic
+// --------------------------------------------------------------------------
+export namespace Intrinsic {
+  function Uncapitalize(value: string): string {
+    const [first, rest] = [value.slice(0, 1), value.slice(1)]
+    return `${first.toLowerCase()}${rest}`
+  }
+  function Capitalize(value: string): string {
+    const [first, rest] = [value.slice(0, 1), value.slice(1)]
+    return `${first.toUpperCase()}${rest}`
+  }
+  function Uppercase(value: string): string {
+    return value.toUpperCase()
+  }
+  function Lowercase(value: string): string {
+    return value.toLowerCase()
+  }
+  function IntrinsicTemplateLiteral(schema: TTemplateLiteral, mode: TIntrinsicMode) {
+    // note: template literals require special runtime handling as they are encoded in string patterns.
+    // This diverges from the mapped type which would otherwise map on the template literal kind.
+    const expression = TemplateLiteralParser.ParseExact(schema.pattern)
+    const finite = TemplateLiteralFinite.Check(expression)
+    if (!finite) return { ...schema, pattern: IntrinsicLiteral(schema.pattern, mode) } as any
+    const strings = [...TemplateLiteralGenerator.Generate(expression)]
+    const literals = strings.map((value) => Type.Literal(value))
+    const mapped = IntrinsicRest(literals as any, mode)
+    const union = Type.Union(mapped)
+    return Type.TemplateLiteral([union])
+  }
+  function IntrinsicLiteral(value: TLiteralValue, mode: TIntrinsicMode) {
+    // prettier-ignore
+    return typeof value === 'string' ? (
+      mode === 'Uncapitalize' ? Uncapitalize(value) :
+      mode === 'Capitalize' ? Capitalize(value) : 
+      mode === 'Uppercase' ? Uppercase(value) : 
+      mode === 'Lowercase' ? Lowercase(value) : 
+    value) : ''
+  }
+  function IntrinsicRest(schema: TSchema[], mode: TIntrinsicMode): TSchema[] {
+    if (schema.length === 0) return []
+    const [L, ...R] = schema
+    return [Map(L, mode), ...IntrinsicRest(R, mode)]
+  }
+  function Visit(schema: TSchema, mode: TIntrinsicMode) {
+    if (TypeGuard.TTemplateLiteral(schema)) return IntrinsicTemplateLiteral(schema, mode)
+    if (TypeGuard.TUnion(schema)) return Type.Union(IntrinsicRest(schema.anyOf, mode))
+    if (TypeGuard.TLiteral(schema)) return Type.Literal(IntrinsicLiteral(schema.const, mode))
+    return schema
+  }
+  /** Applies an intrinsic string manipulation to the given type. */
+  export function Map<T extends TSchema, M extends TIntrinsicMode>(schema: T, mode: M): TIntrinsic<T, M> {
+    return Visit(schema, mode)
+  }
+}
+// --------------------------------------------------------------------------
 // ObjectMap
 // --------------------------------------------------------------------------
 export namespace ObjectMap {
@@ -2538,10 +2627,9 @@ export class StandardTypeBuilder extends TypeBuilder {
   public Boolean(options: SchemaOptions = {}): TBoolean {
     return this.Create({ ...options, [Kind]: 'Boolean', type: 'boolean' })
   }
-  /** `[Standard]` Capitalize a LiteralString type */
-  public Capitalize<T extends TLiteral<string>>(schema: T, options: SchemaOptions = {}): TLiteral<Capitalize<T['const']>> {
-    const [first, rest] = [schema.const.slice(0, 1), schema.const.slice(1)]
-    return Type.Literal(`${first.toUpperCase()}${rest}` as Capitalize<T['const']>, options)
+  /** `[Standard]` Intrinsic function to Capitalize LiteralString types */
+  public Capitalize<T extends TSchema>(schema: T, options: SchemaOptions = {}): TIntrinsic<T, 'Capitalize'> {
+    return { ...Intrinsic.Map(TypeClone.Clone(schema), 'Capitalize'), ...options }
   }
   /** `[Standard]` Creates a Composite object type */
   public Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T> {
@@ -2665,9 +2753,9 @@ export class StandardTypeBuilder extends TypeBuilder {
   public Literal<T extends TLiteralValue>(value: T, options: SchemaOptions = {}): TLiteral<T> {
     return this.Create({ ...options, [Kind]: 'Literal', const: value, type: typeof value as 'string' | 'number' | 'boolean' })
   }
-  /** `[Standard]` Lowercase a LiteralString type */
-  public Lowercase<T extends TLiteral<string>>(schema: T, options: SchemaOptions = {}): TLiteral<Lowercase<T['const']>> {
-    return Type.Literal(schema.const.toLowerCase() as Lowercase<T['const']>, options)
+  /** `[Standard]` Intrinsic function to Lowercase LiteralString types */
+  public Lowercase<T extends TSchema>(schema: T, options: SchemaOptions = {}): TIntrinsic<T, 'Lowercase'> {
+    return { ...Intrinsic.Map(TypeClone.Clone(schema), 'Lowercase'), ...options }
   }
   /** `[Standard]` Creates a Never type */
   public Never(options: SchemaOptions = {}): TNever {
@@ -2857,10 +2945,9 @@ export class StandardTypeBuilder extends TypeBuilder {
       { ...options, [Kind]: 'Tuple', type: 'array', minItems, maxItems }) as any
     return this.Create(schema)
   }
-  /** `[Standard]` Uncapitalize a LiteralString type */
-  public Uncapitalize<T extends TLiteral<string>>(schema: T, options: SchemaOptions = {}): TLiteral<Uncapitalize<T['const']>> {
-    const [first, rest] = [schema.const.slice(0, 1), schema.const.slice(1)]
-    return Type.Literal(`${first.toLocaleLowerCase()}${rest}` as Uncapitalize<T['const']>, options)
+  /** `[Standard]` Intrinsic function to Uncapitalize LiteralString types */
+  public Uncapitalize<T extends TSchema>(schema: T, options: SchemaOptions = {}): TIntrinsic<T, 'Uncapitalize'> {
+    return { ...Intrinsic.Map(TypeClone.Clone(schema), 'Uncapitalize'), ...options }
   }
   /** `[Standard]` Creates a Union type */
   public Union(anyOf: [], options?: SchemaOptions): TNever
@@ -2890,9 +2977,9 @@ export class StandardTypeBuilder extends TypeBuilder {
   public Unsafe<T>(options: UnsafeOptions = {}): TUnsafe<T> {
     return this.Create({ ...options, [Kind]: options[Kind] || 'Unsafe' })
   }
-  /** `[Standard]` Uppercase a LiteralString type */
-  public Uppercase<T extends TLiteral<string>>(schema: T, options: SchemaOptions = {}): TLiteral<Uppercase<T['const']>> {
-    return Type.Literal(schema.const.toUpperCase() as Uppercase<T['const']>, options)
+  /** `[Standard]` Intrinsic function to Uppercase LiteralString types */
+  public Uppercase<T extends TSchema>(schema: T, options: SchemaOptions = {}): TIntrinsic<T, 'Uppercase'> {
+    return { ...Intrinsic.Map(TypeClone.Clone(schema), 'Uppercase'), ...options }
   }
 }
 // --------------------------------------------------------------------------
diff --git a/test/runtime/compiler/partial.ts b/test/runtime/compiler/partial.ts
index 72ab48c9e..51a1d93fc 100644
--- a/test/runtime/compiler/partial.ts
+++ b/test/runtime/compiler/partial.ts
@@ -14,11 +14,10 @@ describe('type/compiler/Partial', () => {
       { additionalProperties: false },
     )
     const T = Type.Partial(A)
-    console.log(T)
-    //Ok(T, { x: 1, y: 1, z: 1 })
-    //Ok(T, { x: 1, y: 1 })
-    //Ok(T, { x: 1 })
-    //Ok(T, {})
+    Ok(T, { x: 1, y: 1, z: 1 })
+    Ok(T, { x: 1, y: 1 })
+    Ok(T, { x: 1 })
+    Ok(T, {})
   })
   it('Should update modifier types correctly when converting to partial', () => {
     const A = Type.Object(
@@ -38,7 +37,6 @@ describe('type/compiler/Partial', () => {
     strictEqual(T.properties.z[Optional], 'Optional')
     strictEqual(T.properties.w[Optional], 'Optional')
   })
-
   it('Should inherit options from the source object', () => {
     const A = Type.Object(
       {
diff --git a/test/runtime/type/guard/capitalize.ts b/test/runtime/type/guard/capitalize.ts
index 9e60fa035..77720f423 100644
--- a/test/runtime/type/guard/capitalize.ts
+++ b/test/runtime/type/guard/capitalize.ts
@@ -1,9 +1,28 @@
-import { Type } from '@sinclair/typebox'
+import { TypeGuard, Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/Capitalize', () => {
-  it('Should guard for TCapitalize', () => {
+  it('Should guard for Capitalize 1', () => {
+    const T = Type.Capitalize(Type.Literal('hello'), { $id: 'hello', foo: 1 })
+    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsEqual(T.const, 'Hello')
+    Assert.IsEqual(T.$id, 'hello')
+    Assert.IsEqual(T.foo, 1)
+  })
+  it('Should guard for Capitalize 2', () => {
     const T = Type.Capitalize(Type.Literal('hello'))
+    Assert.IsTrue(TypeGuard.TLiteral(T))
     Assert.IsEqual(T.const, 'Hello')
   })
+  it('Should guard for Capitalize 3', () => {
+    const T = Type.Capitalize(Type.Union([Type.Literal('hello'), Type.Literal('world')]))
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'Hello')
+    Assert.IsEqual(T.anyOf[1].const, 'World')
+  })
+  it('Should guard for Capitalize 4', () => {
+    const T = Type.Capitalize(Type.TemplateLiteral('hello${0|1}'))
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(Hello0|Hello1)$')
+  })
 })
diff --git a/test/runtime/type/guard/lowercase.ts b/test/runtime/type/guard/lowercase.ts
index 3a269cd2e..7eaecf962 100644
--- a/test/runtime/type/guard/lowercase.ts
+++ b/test/runtime/type/guard/lowercase.ts
@@ -1,9 +1,28 @@
-import { Type } from '@sinclair/typebox'
+import { TypeGuard, Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/Lowercase', () => {
-  it('Should guard for Lowercase', () => {
+  it('Should guard for Lowercase 1', () => {
+    const T = Type.Lowercase(Type.Literal('HELLO'), { $id: 'hello', foo: 1 })
+    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsEqual(T.const, 'hello')
+    Assert.IsEqual(T.$id, 'hello')
+    Assert.IsEqual(T.foo, 1)
+  })
+  it('Should guard for Lowercase 2', () => {
     const T = Type.Lowercase(Type.Literal('HELLO'))
+    Assert.IsTrue(TypeGuard.TLiteral(T))
     Assert.IsEqual(T.const, 'hello')
   })
+  it('Should guard for Lowercase 3', () => {
+    const T = Type.Lowercase(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD')]))
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'hello')
+    Assert.IsEqual(T.anyOf[1].const, 'world')
+  })
+  it('Should guard for Lowercase 4', () => {
+    const T = Type.Lowercase(Type.TemplateLiteral('HELLO${0|1}'))
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(hello0|hello1)$')
+  })
 })
diff --git a/test/runtime/type/guard/uncapitalize.ts b/test/runtime/type/guard/uncapitalize.ts
index ece6195a3..a0fbd880b 100644
--- a/test/runtime/type/guard/uncapitalize.ts
+++ b/test/runtime/type/guard/uncapitalize.ts
@@ -1,10 +1,28 @@
-import { TypeGuard } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { TypeGuard, Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/Uncapitalize', () => {
-  it('Should guard for Uncapitalize', () => {
+  it('Should guard for Uncapitalize 1', () => {
+    const T = Type.Uncapitalize(Type.Literal('HELLO'), { $id: 'hello', foo: 1 })
+    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsEqual(T.const, 'hELLO')
+    Assert.IsEqual(T.$id, 'hello')
+    Assert.IsEqual(T.foo, 1)
+  })
+  it('Should guard for Uncapitalize 2', () => {
     const T = Type.Uncapitalize(Type.Literal('HELLO'))
+    Assert.IsTrue(TypeGuard.TLiteral(T))
     Assert.IsEqual(T.const, 'hELLO')
   })
+  it('Should guard for Uncapitalize 3', () => {
+    const T = Type.Uncapitalize(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD')]))
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'hELLO')
+    Assert.IsEqual(T.anyOf[1].const, 'wORLD')
+  })
+  it('Should guard for Uncapitalize 4', () => {
+    const T = Type.Uncapitalize(Type.TemplateLiteral('HELLO${0|1}'))
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(hELLO0|hELLO1)$')
+  })
 })
diff --git a/test/runtime/type/guard/uppercase.ts b/test/runtime/type/guard/uppercase.ts
index f85bdad43..241ead739 100644
--- a/test/runtime/type/guard/uppercase.ts
+++ b/test/runtime/type/guard/uppercase.ts
@@ -1,10 +1,28 @@
-import { TypeGuard } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { TypeGuard, Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/Uppercase', () => {
-  it('Should guard for Uppercase', () => {
+  it('Should guard for Uppercase 1', () => {
+    const T = Type.Uppercase(Type.Literal('hello'), { $id: 'hello', foo: 1 })
+    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsEqual(T.const, 'HELLO')
+    Assert.IsEqual(T.$id, 'hello')
+    Assert.IsEqual(T.foo, 1)
+  })
+  it('Should guard for Uppercase 2', () => {
     const T = Type.Uppercase(Type.Literal('hello'))
+    Assert.IsTrue(TypeGuard.TLiteral(T))
     Assert.IsEqual(T.const, 'HELLO')
   })
+  it('Should guard for Uppercase 3', () => {
+    const T = Type.Uppercase(Type.Union([Type.Literal('hello'), Type.Literal('world')]))
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'HELLO')
+    Assert.IsEqual(T.anyOf[1].const, 'WORLD')
+  })
+  it('Should guard for Uppercase 4', () => {
+    const T = Type.Uppercase(Type.TemplateLiteral('hello${0|1}'))
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(HELLO0|HELLO1)$')
+  })
 })
diff --git a/test/runtime/type/index.ts b/test/runtime/type/index.ts
index dd13431a2..bc394a539 100644
--- a/test/runtime/type/index.ts
+++ b/test/runtime/type/index.ts
@@ -1,6 +1,7 @@
 import './clone/index'
 import './extends/index'
 import './guard/index'
+import './intrinsic/index'
 import './normalize/index'
 import './registry/index'
 import './template/index'
diff --git a/test/runtime/type/intrinsic/index.ts b/test/runtime/type/intrinsic/index.ts
new file mode 100644
index 000000000..8bb9e079c
--- /dev/null
+++ b/test/runtime/type/intrinsic/index.ts
@@ -0,0 +1 @@
+import './intrinsic'
diff --git a/test/runtime/type/intrinsic/intrinsic.ts b/test/runtime/type/intrinsic/intrinsic.ts
new file mode 100644
index 000000000..074223c22
--- /dev/null
+++ b/test/runtime/type/intrinsic/intrinsic.ts
@@ -0,0 +1,143 @@
+import { TypeGuard, Intrinsic } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/intrinsic/IntrinsicString', () => {
+  // ----------------------------------------------------
+  // Passthrough
+  // ----------------------------------------------------
+  it('Should passthrough 1', () => {
+    const T = Intrinsic.Map(Type.String(), 'Capitalize')
+    Assert.IsTrue(TypeGuard.TString(T))
+  })
+  it('Should passthrough 2', () => {
+    const T = Intrinsic.Map(Type.Number(), 'Capitalize')
+    Assert.IsTrue(TypeGuard.TNumber(T))
+  })
+  it('Should passthrough 3', () => {
+    const T = Intrinsic.Map(
+      Type.Object({
+        x: Type.Number(),
+      }),
+      'Capitalize',
+    )
+    Assert.IsTrue(TypeGuard.TObject(T))
+  })
+  // ----------------------------------------------------
+  // Partial Passthrough
+  // ----------------------------------------------------
+  it('Should partial passthrough 3', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Literal('hello')
+    const U = Type.Union([A, B])
+    const T = Intrinsic.Map(U, 'Capitalize')
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsTrue(TypeGuard.TObject(T.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TLiteral(T.anyOf[1]))
+    Assert.IsEqual(T.anyOf[1].const, 'Hello')
+  })
+  // ----------------------------------------------------
+  // Mode: Literal
+  // ----------------------------------------------------
+  it('Should map literal: Capitalize', () => {
+    const T = Intrinsic.Map(Type.Literal('hello'), 'Capitalize')
+    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsEqual(T.const, 'Hello')
+  })
+  it('Should map literal: Uncapitalize', () => {
+    const T = Intrinsic.Map(Type.Literal('HELLO'), 'Uncapitalize')
+    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsEqual(T.const, 'hELLO')
+  })
+  it('Should map literal: Uppercase', () => {
+    const T = Intrinsic.Map(Type.Literal('hello'), 'Uppercase')
+    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsEqual(T.const, 'HELLO')
+  })
+  it('Should map literal: Lowercase', () => {
+    const T = Intrinsic.Map(Type.Literal('HELLO'), 'Lowercase')
+    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsEqual(T.const, 'hello')
+  })
+  // ----------------------------------------------------
+  // Mode: Literal Union
+  // ----------------------------------------------------
+  it('Should map literal union: Capitalize', () => {
+    const T = Intrinsic.Map(Type.Union([Type.Literal('hello'), Type.Literal('world')]), 'Capitalize')
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'Hello')
+    Assert.IsEqual(T.anyOf[1].const, 'World')
+  })
+  it('Should map literal union: Uncapitalize', () => {
+    const T = Intrinsic.Map(Type.Union([Type.Literal('Hello'), Type.Literal('World')]), 'Uncapitalize')
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'hello')
+    Assert.IsEqual(T.anyOf[1].const, 'world')
+  })
+  it('Should map literal union: Uppercase', () => {
+    const T = Intrinsic.Map(Type.Union([Type.Literal('hello'), Type.Literal('world')]), 'Uppercase')
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'HELLO')
+    Assert.IsEqual(T.anyOf[1].const, 'WORLD')
+  })
+  it('Should map literal union: Lowercase', () => {
+    const T = Intrinsic.Map(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD')]), 'Lowercase')
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'hello')
+    Assert.IsEqual(T.anyOf[1].const, 'world')
+  })
+  // ----------------------------------------------------
+  // Mode: TemplateLiteral
+  // ----------------------------------------------------
+  it('Should map template literal: Capitalize', () => {
+    const T = Intrinsic.Map(Type.TemplateLiteral('hello${1|2}world'), 'Capitalize')
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(Hello1world|Hello2world)$')
+  })
+  it('Should map template literal: Uncapitalize', () => {
+    const T = Intrinsic.Map(Type.TemplateLiteral('HELLO${1|2}WORLD'), 'Uncapitalize')
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(hELLO1WORLD|hELLO2WORLD)$')
+  })
+  it('Should map template literal: Uppercase', () => {
+    const T = Intrinsic.Map(Type.TemplateLiteral('hello${1|2}world'), 'Uppercase')
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(HELLO1WORLD|HELLO2WORLD)$')
+  })
+  it('Should map template literal: Lowercase', () => {
+    const T = Intrinsic.Map(Type.TemplateLiteral('HELLO${1|2}WORLD'), 'Lowercase')
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(hello1world|hello2world)$')
+  })
+  // ----------------------------------------------------
+  // Mode: TemplateLiteral Patterns
+  // ----------------------------------------------------
+  it('Should map template literal patterns 1', () => {
+    const T = Intrinsic.Map(Type.TemplateLiteral('HELLO${string}WORLD'), 'Lowercase')
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^hello(.*)world$')
+    console.log(T.pattern)
+  })
+  it('Should map template literal patterns 2', () => {
+    const T = Intrinsic.Map(Type.TemplateLiteral('HELLO${number}WORLD'), 'Lowercase')
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^hello(0|[1-9][0-9]*)world$')
+    console.log(T.pattern)
+  })
+  it('Should map template literal patterns 3', () => {
+    const T = Intrinsic.Map(Type.TemplateLiteral('${number}${string}'), 'Lowercase')
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(0|[1-9][0-9]*)(.*)$')
+    console.log(T.pattern)
+  })
+  it('Should map template literal patterns 3', () => {
+    const T = Intrinsic.Map(Type.TemplateLiteral('${number}HELLO${string}'), 'Lowercase')
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(0|[1-9][0-9]*)hello(.*)$')
+  })
+  it('Should map template literal patterns 3', () => {
+    const T = Intrinsic.Map(Type.TemplateLiteral('${string|number}HELLO'), 'Lowercase')
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(stringhello|numberhello)$')
+  })
+})
diff --git a/test/static/capitalize.ts b/test/static/capitalize.ts
index a72fa79cc..826075277 100644
--- a/test/static/capitalize.ts
+++ b/test/static/capitalize.ts
@@ -2,3 +2,10 @@ import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
 Expect(Type.Capitalize(Type.Literal('hello'))).ToInfer<'Hello'>()
+
+Expect(Type.Capitalize(Type.Union([Type.Literal('hello'), Type.Literal('world')]))).ToInfer<'Hello' | 'World'>()
+
+Expect(Type.Capitalize(Type.TemplateLiteral('hello${0|1}'))).ToInfer<'Hello0' | 'Hello1'>()
+
+// passthrough
+Expect(Type.Capitalize(Type.Object({ x: Type.Number() }))).ToInfer<{ x: number }>()
diff --git a/test/static/lowercase.ts b/test/static/lowercase.ts
index 56f9c2732..5a4f23cb8 100644
--- a/test/static/lowercase.ts
+++ b/test/static/lowercase.ts
@@ -2,3 +2,10 @@ import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
 Expect(Type.Lowercase(Type.Literal('HELLO'))).ToInfer<'hello'>()
+
+Expect(Type.Lowercase(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD')]))).ToInfer<'hello' | 'world'>()
+
+Expect(Type.Lowercase(Type.TemplateLiteral('HELLO${0|1}'))).ToInfer<'hello0' | 'hello1'>()
+
+// passthrough
+Expect(Type.Lowercase(Type.Object({ x: Type.Number() }))).ToInfer<{ x: number }>()
diff --git a/test/static/uncapitalize.ts b/test/static/uncapitalize.ts
index 4d7cb5afe..c44caa542 100644
--- a/test/static/uncapitalize.ts
+++ b/test/static/uncapitalize.ts
@@ -2,3 +2,10 @@ import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
 Expect(Type.Uncapitalize(Type.Literal('HELLO'))).ToInfer<'hELLO'>()
+
+Expect(Type.Uncapitalize(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD')]))).ToInfer<'hELLO' | 'wORLD'>()
+
+Expect(Type.Uncapitalize(Type.TemplateLiteral('HELLO${0|1}'))).ToInfer<'hELLO0' | 'hELLO1'>()
+
+// passthrough
+Expect(Type.Uncapitalize(Type.Object({ x: Type.Number() }))).ToInfer<{ x: number }>()
diff --git a/test/static/uppercase.ts b/test/static/uppercase.ts
index a8fcd1821..2c8e90ce5 100644
--- a/test/static/uppercase.ts
+++ b/test/static/uppercase.ts
@@ -2,3 +2,10 @@ import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
 Expect(Type.Uppercase(Type.Literal('hello'))).ToInfer<'HELLO'>()
+
+Expect(Type.Uppercase(Type.Union([Type.Literal('hello'), Type.Literal('world')]))).ToInfer<'HELLO' | 'WORLD'>()
+
+Expect(Type.Uppercase(Type.TemplateLiteral('HELLO${0|1}'))).ToInfer<'HELLO0' | 'HELLO1'>()
+
+// passthrough
+Expect(Type.Uppercase(Type.Object({ x: Type.Number() }))).ToInfer<{ x: number }>()

From 3a543656d6862ef4bc9eead582f1783d41b8bfc6 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 2 Aug 2023 19:59:39 +0900
Subject: [PATCH 166/369] Intrinsic String Mapping (#517)

---
 package-lock.json                        |  4 ++--
 package.json                             |  2 +-
 src/typebox.ts                           |  4 ++--
 test/runtime/type/guard/capitalize.ts    |  5 +++++
 test/runtime/type/guard/lowercase.ts     |  5 +++++
 test/runtime/type/guard/uncapitalize.ts  |  5 +++++
 test/runtime/type/guard/uppercase.ts     |  5 +++++
 test/runtime/type/intrinsic/intrinsic.ts | 23 +++++++++++++++++++++++
 test/static/capitalize.ts                |  3 +++
 test/static/lowercase.ts                 |  3 +++
 test/static/uncapitalize.ts              |  3 +++
 test/static/uppercase.ts                 |  3 +++
 12 files changed, 60 insertions(+), 5 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 96f1ad970..3c774d74c 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.30.1",
+  "version": "0.30.2",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.30.1",
+      "version": "0.30.2",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index bd16d7149..e2e0cb959 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.30.1",
+  "version": "0.30.2",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 8211fece1..8f37e240e 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -434,7 +434,7 @@ export type TIntrinsicLiteral<T, M extends TIntrinsicMode> =
     M extends 'Uppercase' ? Uppercase<T> :
     M extends 'Lowercase' ? Lowercase<T> :
     string
-  : ''
+  : T
 // prettier-ignore
 export type TIntrinsicRest<T extends TSchema[], M extends TIntrinsicMode> = T extends [infer L, ...infer R]
   ? [TIntrinsic<AssertType<L>, M>, ...TIntrinsicRest<AssertRest<R>, M>]
@@ -2176,7 +2176,7 @@ export namespace Intrinsic {
       mode === 'Capitalize' ? Capitalize(value) : 
       mode === 'Uppercase' ? Uppercase(value) : 
       mode === 'Lowercase' ? Lowercase(value) : 
-    value) : ''
+    value) : value.toString()
   }
   function IntrinsicRest(schema: TSchema[], mode: TIntrinsicMode): TSchema[] {
     if (schema.length === 0) return []
diff --git a/test/runtime/type/guard/capitalize.ts b/test/runtime/type/guard/capitalize.ts
index 77720f423..33ed2e9a8 100644
--- a/test/runtime/type/guard/capitalize.ts
+++ b/test/runtime/type/guard/capitalize.ts
@@ -25,4 +25,9 @@ describe('type/guard/Capitalize', () => {
     Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(Hello0|Hello1)$')
   })
+  it('Should guard for Capitalize 5', () => {
+    const T = Type.Capitalize(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(0), Type.Literal(1)])]))
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(Hello0|Hello1)$')
+  })
 })
diff --git a/test/runtime/type/guard/lowercase.ts b/test/runtime/type/guard/lowercase.ts
index 7eaecf962..5a07e5d41 100644
--- a/test/runtime/type/guard/lowercase.ts
+++ b/test/runtime/type/guard/lowercase.ts
@@ -25,4 +25,9 @@ describe('type/guard/Lowercase', () => {
     Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(hello0|hello1)$')
   })
+  it('Should guard for Lowercase 5', () => {
+    const T = Type.Lowercase(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(0), Type.Literal(1)])]))
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(hello0|hello1)$')
+  })
 })
diff --git a/test/runtime/type/guard/uncapitalize.ts b/test/runtime/type/guard/uncapitalize.ts
index a0fbd880b..d54b4e584 100644
--- a/test/runtime/type/guard/uncapitalize.ts
+++ b/test/runtime/type/guard/uncapitalize.ts
@@ -25,4 +25,9 @@ describe('type/guard/Uncapitalize', () => {
     Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(hELLO0|hELLO1)$')
   })
+  it('Should guard for Uncapitalize 5', () => {
+    const T = Type.Uncapitalize(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(0), Type.Literal(1)])]))
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(hELLO0|hELLO1)$')
+  })
 })
diff --git a/test/runtime/type/guard/uppercase.ts b/test/runtime/type/guard/uppercase.ts
index 241ead739..602ddf400 100644
--- a/test/runtime/type/guard/uppercase.ts
+++ b/test/runtime/type/guard/uppercase.ts
@@ -25,4 +25,9 @@ describe('type/guard/Uppercase', () => {
     Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(HELLO0|HELLO1)$')
   })
+  it('Should guard for Uppercase 5', () => {
+    const T = Type.Uppercase(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(0), Type.Literal(1)])]))
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(HELLO0|HELLO1)$')
+  })
 })
diff --git a/test/runtime/type/intrinsic/intrinsic.ts b/test/runtime/type/intrinsic/intrinsic.ts
index 074223c22..966f0df50 100644
--- a/test/runtime/type/intrinsic/intrinsic.ts
+++ b/test/runtime/type/intrinsic/intrinsic.ts
@@ -110,6 +110,29 @@ describe('type/intrinsic/IntrinsicString', () => {
     Assert.IsEqual(T.pattern, '^(hello1world|hello2world)$')
   })
   // ----------------------------------------------------
+  // Mode: TemplateLiteral Numeric
+  // ----------------------------------------------------
+  it('Should map template literal numeric: Capitalize', () => {
+    const T = Intrinsic.Map(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(1), Type.Literal(2)])]), 'Capitalize')
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(Hello1|Hello2)$')
+  })
+  it('Should map template literal numeric: Uncapitalize', () => {
+    const T = Intrinsic.Map(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(1), Type.Literal(2)])]), 'Uncapitalize')
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(hELLO1|hELLO2)$')
+  })
+  it('Should map template literal numeric: Uppercase', () => {
+    const T = Intrinsic.Map(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(1), Type.Literal(2)])]), 'Uppercase')
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(HELLO1|HELLO2)$')
+  })
+  it('Should map template literal numeric: Lowercase', () => {
+    const T = Intrinsic.Map(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(1), Type.Literal(2)])]), 'Lowercase')
+    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(hello1|hello2)$')
+  })
+  // ----------------------------------------------------
   // Mode: TemplateLiteral Patterns
   // ----------------------------------------------------
   it('Should map template literal patterns 1', () => {
diff --git a/test/static/capitalize.ts b/test/static/capitalize.ts
index 826075277..ca02c7398 100644
--- a/test/static/capitalize.ts
+++ b/test/static/capitalize.ts
@@ -7,5 +7,8 @@ Expect(Type.Capitalize(Type.Union([Type.Literal('hello'), Type.Literal('world')]
 
 Expect(Type.Capitalize(Type.TemplateLiteral('hello${0|1}'))).ToInfer<'Hello0' | 'Hello1'>()
 
+// prettier-ignore
+Expect(Type.Capitalize(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(1), Type.Literal(2)])]))).ToBe<'Hello1' | 'Hello2'>()
+
 // passthrough
 Expect(Type.Capitalize(Type.Object({ x: Type.Number() }))).ToInfer<{ x: number }>()
diff --git a/test/static/lowercase.ts b/test/static/lowercase.ts
index 5a4f23cb8..78c7f7a84 100644
--- a/test/static/lowercase.ts
+++ b/test/static/lowercase.ts
@@ -7,5 +7,8 @@ Expect(Type.Lowercase(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD')])
 
 Expect(Type.Lowercase(Type.TemplateLiteral('HELLO${0|1}'))).ToInfer<'hello0' | 'hello1'>()
 
+// prettier-ignore
+Expect(Type.Lowercase(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(1), Type.Literal(2)])]))).ToBe<'hello1' | 'hello2'>()
+
 // passthrough
 Expect(Type.Lowercase(Type.Object({ x: Type.Number() }))).ToInfer<{ x: number }>()
diff --git a/test/static/uncapitalize.ts b/test/static/uncapitalize.ts
index c44caa542..a52d0c023 100644
--- a/test/static/uncapitalize.ts
+++ b/test/static/uncapitalize.ts
@@ -7,5 +7,8 @@ Expect(Type.Uncapitalize(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD'
 
 Expect(Type.Uncapitalize(Type.TemplateLiteral('HELLO${0|1}'))).ToInfer<'hELLO0' | 'hELLO1'>()
 
+// prettier-ignore
+Expect(Type.Uncapitalize(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(1), Type.Literal(2)])]))).ToBe<'hELLO1' | 'hELLO2'>()
+
 // passthrough
 Expect(Type.Uncapitalize(Type.Object({ x: Type.Number() }))).ToInfer<{ x: number }>()
diff --git a/test/static/uppercase.ts b/test/static/uppercase.ts
index 2c8e90ce5..dafde13c6 100644
--- a/test/static/uppercase.ts
+++ b/test/static/uppercase.ts
@@ -7,5 +7,8 @@ Expect(Type.Uppercase(Type.Union([Type.Literal('hello'), Type.Literal('world')])
 
 Expect(Type.Uppercase(Type.TemplateLiteral('HELLO${0|1}'))).ToInfer<'HELLO0' | 'HELLO1'>()
 
+// prettier-ignore
+Expect(Type.Uppercase(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(1), Type.Literal(2)])]))).ToBe<'HELLO1' | 'HELLO2'>()
+
 // passthrough
 Expect(Type.Uppercase(Type.Object({ x: Type.Number() }))).ToInfer<{ x: number }>()

From 461883d20a13658904784d0daff031a89b67bb78 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 2 Aug 2023 21:36:00 +0900
Subject: [PATCH 167/369] Revision 0.30.0

---
 readme.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/readme.md b/readme.md
index 8a071cfc4..b89ddfe69 100644
--- a/readme.md
+++ b/readme.md
@@ -72,7 +72,6 @@ License MIT
 ## Contents
 - [Install](#install)
 - [Overview](#overview)
-- [Features](#features)
 - [Usage](#usage)
 - [Types](#types)
   - [Standard](#types-standard)

From 93547e50deb3d17eb47a07dfdfafb13e0febf52f Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Thu, 3 Aug 2023 06:47:07 +0900
Subject: [PATCH 168/369] Intrinsic String Mapping

---
 readme.md | 65 ++++++++++++++++++++++++++++++-------------------------
 1 file changed, 36 insertions(+), 29 deletions(-)

diff --git a/readme.md b/readme.md
index b89ddfe69..f3f6c2c3d 100644
--- a/readme.md
+++ b/readme.md
@@ -83,9 +83,9 @@ License MIT
   - [Recursive](#types-recursive)
   - [Conditional](#types-conditional)
   - [Template Literal](#types-template-literal)
-  - [Intrinsic String](#types-intrinsic-string)
   - [Indexed](#types-indexed)
   - [Negated](#types-negated)
+  - [Intrinsic](#types-intrinsic)
   - [Rest](#types-rest)
   - [Guards](#types-guards)
   - [Unsafe](#types-unsafe)
@@ -875,34 +875,6 @@ const R = Type.Record(T, Type.String())              // const R = {
                                                      // }
 ```
 
-<a name='types-intrinsic-string'></a>
-
-### Intrinsic String Types
-
-TypeBox supports a set of intrinsic string mapping functions which can be used on string literals. These functions match the TypeScript string intrinsic types `Uppercase`, `Lowercase`, `Capitalize` and `Uncapitalize`. These functions are supported for literal strings, template literals and union types. The following shows the literal string usage.
-
-```typescript
-// TypeScript
-
-type A = Uncapitalize<'HELLO'>                      // type A = 'hELLO'
-
-type B = Capitalize<'hello'>                        // type B = 'Hello'
-
-type C = Uppercase<'hello'>                         // type C = 'HELLO'
-
-type D = Lowercase<'HELLO'>                         // type D = 'hello'
-
-// TypeBox
-
-const A = Type.Uncapitalize(Type.Literal('HELLO')) // const A: TLiteral<'hELLO'>
-
-const B = Type.Capitalize(Type.Literal('hello'))   // const B: TLiteral<'Hello'>
-
-const C = Type.Uppercase(Type.Literal('hello'))    // const C: TLiteral<'HELLO'>
-
-const D = Type.Lowercase(Type.Literal('HELLO'))    // const D: TLiteral<'hello'>
-```
-
 <a name='types-indexed'></a>
 
 ### Indexed Access Types
@@ -985,6 +957,41 @@ const Even = Type.Number({ multipleOf: 2 })
 
 const Odd = Type.Intersect([Type.Number(), Type.Not(Even)])          
 ```
+
+<a name='types-intrinsic'></a>
+
+### Intrinsic String Types
+
+TypeBox supports TypeScript intrinsic string manipulation types `Uppercase`, `Lowercase`, `Capitalize` and `Uncapitalize`. These can be applied to string literals, template literals and unions. The following shows general usage.
+
+```typescript
+// TypeScript
+
+type A = Capitalize<'hello'>                        // type A = 'Hello'
+
+type B = Capitalize<'hello' | 'world'>              // type C = 'Hello' | 'World'
+
+type C = Capitalize<`hello${1|2|3}`>                // type B = 'Hello1' | 'Hello2' | 'Hello3'
+
+// TypeBox
+
+const A = Type.Capitalize(Type.Literal('hello'))    // const A: TLiteral<'Hello'>
+
+const B = Type.Capitalize(Type.Union([              // const B: TUnion<[
+  Type.Literal('hello'),                            //   TLiteral<'Hello'>,
+  Type.Literal('world')                             //   TLiteral<'World'>
+]))                                                 // ]>
+
+const C = Type.Capitalize(                          // const C: TTemplateLiteral<[
+  Type.TemplateLiteral('hello${1|2|3}')             //   TLiteral<'Hello'>,
+)                                                   //   TUnion<[
+                                                    //     TLiteral<'1'>,
+                                                    //     TLiteral<'2'>,
+                                                    //     TLiteral<'3'>
+                                                    //   ]>
+                                                    // ]>
+```
+
 <a name='types-rest'></a>
 
 ### Rest Types

From 934dc9a4ae3bde14825465b30e3cc4db1e6de754 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 5 Aug 2023 17:31:12 +0900
Subject: [PATCH 169/369] Send Kind To TypeRegistry Function (#522)

---
 package-lock.json                             |  4 +-
 package.json                                  |  2 +-
 src/compiler/compiler.ts                      | 11 ++-
 test/runtime/compiler/custom.ts               | 26 -------
 test/runtime/compiler/index.ts                |  2 +-
 test/runtime/compiler/kind.ts                 | 72 +++++++++++++++++++
 test/runtime/type/guard/index.ts              |  1 +
 test/runtime/type/guard/kind.ts               | 13 ++++
 test/runtime/value/cast/index.ts              |  2 +-
 .../runtime/value/cast/{custom.ts => kind.ts} | 18 ++---
 test/runtime/value/check/custom.ts            | 29 --------
 test/runtime/value/check/index.ts             |  2 +-
 test/runtime/value/check/kind.ts              | 70 ++++++++++++++++++
 test/runtime/value/convert/custom.ts          | 24 -------
 test/runtime/value/convert/index.ts           |  2 +-
 test/runtime/value/convert/kind.ts            | 39 ++++++++++
 test/runtime/value/create/custom.ts           | 17 -----
 test/runtime/value/create/index.ts            |  2 +-
 test/runtime/value/create/kind.ts             | 23 ++++++
 19 files changed, 244 insertions(+), 115 deletions(-)
 delete mode 100644 test/runtime/compiler/custom.ts
 create mode 100644 test/runtime/compiler/kind.ts
 create mode 100644 test/runtime/type/guard/kind.ts
 rename test/runtime/value/cast/{custom.ts => kind.ts} (73%)
 delete mode 100644 test/runtime/value/check/custom.ts
 create mode 100644 test/runtime/value/check/kind.ts
 delete mode 100644 test/runtime/value/convert/custom.ts
 create mode 100644 test/runtime/value/convert/kind.ts
 delete mode 100644 test/runtime/value/create/custom.ts
 create mode 100644 test/runtime/value/create/kind.ts

diff --git a/package-lock.json b/package-lock.json
index 3c774d74c..e71d5adf3 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.30.2",
+  "version": "0.30.3",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.30.2",
+      "version": "0.30.3",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index e2e0cb959..bee3ce854 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.30.2",
+  "version": "0.30.3",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 9509e0d29..c0bac349e 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -375,7 +375,9 @@ export namespace TypeCompiler {
     yield IsVoidCheck(value)
   }
   function* TKind(schema: Types.TSchema, references: Types.TSchema[], value: string): IterableIterator<string> {
-    yield `kind('${schema[Types.Kind]}', ${value})`
+    const instance = state.instances.size
+    state.instances.set(instance, schema)
+    yield `kind('${schema[Types.Kind]}', ${instance}, ${value})`
   }
   function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: string, useHoisting: boolean = true): IterableIterator<string> {
     const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references
@@ -470,6 +472,7 @@ export namespace TypeCompiler {
     language: 'javascript',                       // target language
     functions: new Map<string, string>(),         // local functions
     variables: new Map<string, string>(),         // local variables
+    instances: new Map<number, Types.TKind>()     // exterior kind instances
   }
   // -------------------------------------------------------------------
   // Compiler Factory
@@ -533,6 +536,7 @@ export namespace TypeCompiler {
     state.language = options.language
     state.variables.clear()
     state.functions.clear()
+    state.instances.clear()
     if (!Types.TypeGuard.TSchema(schema)) throw new TypeCompilerTypeGuardError(schema)
     for (const schema of references) if (!Types.TypeGuard.TSchema(schema)) throw new TypeCompilerTypeGuardError(schema)
     return Build(schema, references, options)
@@ -541,8 +545,9 @@ export namespace TypeCompiler {
   export function Compile<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []): TypeCheck<T> {
     const generatedCode = Code(schema, references, { language: 'javascript' })
     const compiledFunction = globalThis.Function('kind', 'format', 'hash', generatedCode)
-    function typeRegistryFunction(kind: string, value: unknown) {
-      if (!Types.TypeRegistry.Has(kind)) return false
+    function typeRegistryFunction(kind: string, instance: number, value: unknown) {
+      if (!Types.TypeRegistry.Has(kind) || !state.instances.has(instance)) return false
+      const schema = state.instances.get(instance)
       const checkFunc = Types.TypeRegistry.Get(kind)!
       return checkFunc(schema, value)
     }
diff --git a/test/runtime/compiler/custom.ts b/test/runtime/compiler/custom.ts
deleted file mode 100644
index 4380a9e82..000000000
--- a/test/runtime/compiler/custom.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { Type, Kind, TypeRegistry } from '@sinclair/typebox'
-import { Ok, Fail } from './validate'
-
-describe('type/compiler/Custom', () => {
-  TypeRegistry.Set('BigInt', (schema, value) => typeof value === 'bigint')
-  it('Should validate bigint', () => {
-    const T = Type.Unsafe({ [Kind]: 'BigInt' })
-    Ok(T, 1n)
-  })
-  it('Should not validate bigint', () => {
-    const T = Type.Unsafe({ [Kind]: 'BigInt' })
-    Fail(T, 1)
-  })
-  it('Should validate bigint nested', () => {
-    const T = Type.Object({
-      x: Type.Unsafe({ [Kind]: 'BigInt' }),
-    })
-    Ok(T, { x: 1n })
-  })
-  it('Should not validate bigint nested', () => {
-    const T = Type.Object({
-      x: Type.Unsafe({ [Kind]: 'BigInt' }),
-    })
-    Fail(T, { x: 1 })
-  })
-})
diff --git a/test/runtime/compiler/index.ts b/test/runtime/compiler/index.ts
index d0120684b..e47c1ce9b 100644
--- a/test/runtime/compiler/index.ts
+++ b/test/runtime/compiler/index.ts
@@ -4,7 +4,6 @@ import './async-iterator'
 import './bigint'
 import './boolean'
 import './composite'
-import './custom'
 import './date'
 import './unicode'
 import './enum'
@@ -12,6 +11,7 @@ import './integer'
 import './intersect'
 import './iterator'
 import './keyof'
+import './kind'
 import './literal'
 import './modifier'
 import './never'
diff --git a/test/runtime/compiler/kind.ts b/test/runtime/compiler/kind.ts
new file mode 100644
index 000000000..972c5def2
--- /dev/null
+++ b/test/runtime/compiler/kind.ts
@@ -0,0 +1,72 @@
+import { TypeRegistry, Type, Kind, TSchema } from '@sinclair/typebox'
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { Ok, Fail } from './validate'
+import { Assert } from '../assert'
+
+describe('type/compiler/Kind', () => {
+  // ------------------------------------------------------------
+  // Fixtures
+  // ------------------------------------------------------------
+  beforeEach(() => TypeRegistry.Set('PI', (_, value) => value === Math.PI))
+  afterEach(() => TypeRegistry.Delete('PI'))
+  // ------------------------------------------------------------
+  // Tests
+  // ------------------------------------------------------------
+  it('Should validate', () => {
+    const T = Type.Unsafe({ [Kind]: 'PI' })
+    Ok(T, Math.PI)
+  })
+  it('Should not validate', () => {
+    const T = Type.Unsafe({ [Kind]: 'PI' })
+    Fail(T, Math.PI * 2)
+  })
+  it('Should validate in object', () => {
+    const T = Type.Object({
+      x: Type.Unsafe({ [Kind]: 'PI' }),
+    })
+    Ok(T, { x: Math.PI })
+  })
+  it('Should not validate in object', () => {
+    const T = Type.Object({
+      x: Type.Unsafe({ [Kind]: 'PI' }),
+    })
+    Fail(T, { x: Math.PI * 2 })
+  })
+  it('Should validate in array', () => {
+    const T = Type.Array(Type.Unsafe({ [Kind]: 'PI' }))
+    Ok(T, [Math.PI])
+  })
+  it('Should not validate in array', () => {
+    const T = Type.Array(Type.Unsafe({ [Kind]: 'PI' }))
+    Fail(T, [Math.PI * 2])
+  })
+  it('Should validate in tuple', () => {
+    const T = Type.Tuple([Type.Unsafe({ [Kind]: 'PI' })])
+    Ok(T, [Math.PI])
+  })
+  it('Should not validate in tuple', () => {
+    const T = Type.Tuple([Type.Unsafe({ [Kind]: 'PI' })])
+    Fail(T, [Math.PI * 2])
+  })
+  // ------------------------------------------------------------
+  // Instances
+  // ------------------------------------------------------------
+  it('Should receive kind instance on registry callback', () => {
+    const stack: string[] = []
+    TypeRegistry.Set('Kind', (schema: unknown) => {
+      // prettier-ignore
+      return (typeof schema === 'object' && schema !== null && Kind in schema && schema[Kind] === 'Kind' && '$id' in schema && typeof schema.$id === 'string') 
+        ? (() => { stack.push(schema.$id); return true })()
+        : false
+    })
+    const A = { [Kind]: 'Kind', $id: 'A' } as TSchema
+    const B = { [Kind]: 'Kind', $id: 'B' } as TSchema
+    const T = Type.Object({ a: A, b: B })
+    const C = TypeCompiler.Compile(T)
+    const R = C.Check({ a: null, b: null })
+    Assert.IsTrue(R)
+    Assert.IsEqual(stack[0], 'A')
+    Assert.IsEqual(stack[1], 'B')
+    TypeRegistry.Delete('Kind')
+  })
+})
diff --git a/test/runtime/type/guard/index.ts b/test/runtime/type/guard/index.ts
index 33ee2fb61..c1cb4c70d 100644
--- a/test/runtime/type/guard/index.ts
+++ b/test/runtime/type/guard/index.ts
@@ -16,6 +16,7 @@ import './integer'
 import './intersect'
 import './iterator'
 import './keyof'
+import './kind'
 import './literal'
 import './lowercase'
 import './not'
diff --git a/test/runtime/type/guard/kind.ts b/test/runtime/type/guard/kind.ts
new file mode 100644
index 000000000..52c87f883
--- /dev/null
+++ b/test/runtime/type/guard/kind.ts
@@ -0,0 +1,13 @@
+import { TypeGuard, Kind } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TKind', () => {
+  it('Should guard 1', () => {
+    const T = { [Kind]: 'Kind' }
+    Assert.IsTrue(TypeGuard.TKind(T))
+  })
+  it('Should guard 2', () => {
+    const T = {}
+    Assert.IsFalse(TypeGuard.TKind(T))
+  })
+})
diff --git a/test/runtime/value/cast/index.ts b/test/runtime/value/cast/index.ts
index be2225807..911bd9f17 100644
--- a/test/runtime/value/cast/index.ts
+++ b/test/runtime/value/cast/index.ts
@@ -4,13 +4,13 @@ import './async-iterator'
 import './bigint'
 import './boolean'
 import './composite'
-import './custom'
 import './date'
 import './enum'
 import './integer'
 import './intersect'
 import './iterator'
 import './keyof'
+import './kind'
 import './literal'
 import './never'
 import './not'
diff --git a/test/runtime/value/cast/custom.ts b/test/runtime/value/cast/kind.ts
similarity index 73%
rename from test/runtime/value/cast/custom.ts
rename to test/runtime/value/cast/kind.ts
index 3bfb8959f..42cffc618 100644
--- a/test/runtime/value/cast/custom.ts
+++ b/test/runtime/value/cast/kind.ts
@@ -2,14 +2,16 @@ import { Value } from '@sinclair/typebox/value'
 import { Type, Kind, TypeRegistry } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('value/cast/Custom', () => {
-  before(() => {
-    TypeRegistry.Set('CustomCast', (schema, value) => value === 'hello' || value === 'world')
-  })
-  after(() => {
-    TypeRegistry.Clear()
-  })
-  const T = Type.Unsafe({ [Kind]: 'CustomCast', default: 'hello' })
+describe('value/cast/Kind', () => {
+  // ---------------------------------------------------------
+  // Fixtures
+  // ---------------------------------------------------------
+  before(() => TypeRegistry.Set('Kind', (schema, value) => value === 'hello' || value === 'world'))
+  after(() => TypeRegistry.Clear())
+  // ---------------------------------------------------------
+  // Tests
+  // ---------------------------------------------------------
+  const T = Type.Unsafe({ [Kind]: 'Kind', default: 'hello' })
   const E = 'hello'
   it('Should upcast from string', () => {
     const value = 'hello'
diff --git a/test/runtime/value/check/custom.ts b/test/runtime/value/check/custom.ts
deleted file mode 100644
index 3072822f9..000000000
--- a/test/runtime/value/check/custom.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import { Value } from '@sinclair/typebox/value'
-import { Type, Kind, TypeRegistry } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
-
-describe('type/check/Custom', () => {
-  const FooBar = Type.Unsafe({ [Kind]: 'FooBar' })
-  before(() => {
-    TypeRegistry.Set('FooBar', (schema, value) => value === 'foobar')
-  })
-  after(() => {
-    TypeRegistry.Delete('FooBar')
-  })
-  it('Should validate foobar', () => {
-    Assert.IsEqual(Value.Check(FooBar, 'foobar'), true)
-  })
-  it('Should not validate foobar', () => {
-    Assert.IsEqual(Value.Check(FooBar, 1), false)
-  })
-  it('Should validate foobar nested', () => {
-    // prettier-ignore
-    const T = Type.Object({ x: FooBar })
-    Assert.IsEqual(Value.Check(T, { x: 'foobar' }), true)
-  })
-  it('Should not validate foobar nested', () => {
-    // prettier-ignore
-    const T = Type.Object({ x: FooBar })
-    Assert.IsEqual(Value.Check(T, { x: 1 }), false)
-  })
-})
diff --git a/test/runtime/value/check/index.ts b/test/runtime/value/check/index.ts
index 9dac82003..a55d53a0b 100644
--- a/test/runtime/value/check/index.ts
+++ b/test/runtime/value/check/index.ts
@@ -4,13 +4,13 @@ import './async-iterator'
 import './bigint'
 import './boolean'
 import './composite'
-import './custom'
 import './date'
 import './enum'
 import './integer'
 import './intersect'
 import './iterator'
 import './keyof'
+import './kind'
 import './literal'
 import './never'
 import './not'
diff --git a/test/runtime/value/check/kind.ts b/test/runtime/value/check/kind.ts
new file mode 100644
index 000000000..91ad48a15
--- /dev/null
+++ b/test/runtime/value/check/kind.ts
@@ -0,0 +1,70 @@
+import { Value } from '@sinclair/typebox/value'
+import { TypeRegistry, Type, Kind, TSchema } from '@sinclair/typebox'
+import { Assert } from '../../assert'
+
+describe('value/check/Kind', () => {
+  // ------------------------------------------------------------
+  // Fixtures
+  // ------------------------------------------------------------
+  beforeEach(() => TypeRegistry.Set('PI', (_, value) => value === Math.PI))
+  afterEach(() => TypeRegistry.Delete('PI'))
+  // ------------------------------------------------------------
+  // Tests
+  // ------------------------------------------------------------
+  it('Should validate', () => {
+    const T = Type.Unsafe({ [Kind]: 'PI' })
+    Assert.IsTrue(Value.Check(T, Math.PI))
+  })
+  it('Should not validate', () => {
+    const T = Type.Unsafe({ [Kind]: 'PI' })
+    Assert.IsFalse(Value.Check(T, Math.PI * 2))
+  })
+  it('Should validate in object', () => {
+    const T = Type.Object({
+      x: Type.Unsafe({ [Kind]: 'PI' }),
+    })
+    Assert.IsTrue(Value.Check(T, { x: Math.PI }))
+  })
+  it('Should not validate in object', () => {
+    const T = Type.Object({
+      x: Type.Unsafe({ [Kind]: 'PI' }),
+    })
+    Assert.IsFalse(Value.Check(T, { x: Math.PI * 2 }))
+  })
+  it('Should validate in array', () => {
+    const T = Type.Array(Type.Unsafe({ [Kind]: 'PI' }))
+    Assert.IsTrue(Value.Check(T, [Math.PI]))
+  })
+  it('Should not validate in array', () => {
+    const T = Type.Array(Type.Unsafe({ [Kind]: 'PI' }))
+    Assert.IsFalse(Value.Check(T, [Math.PI * 2]))
+  })
+  it('Should validate in tuple', () => {
+    const T = Type.Tuple([Type.Unsafe({ [Kind]: 'PI' })])
+    Assert.IsTrue(Value.Check(T, [Math.PI]))
+  })
+  it('Should not validate in tuple', () => {
+    const T = Type.Tuple([Type.Unsafe({ [Kind]: 'PI' })])
+    Assert.IsFalse(Value.Check(T, [Math.PI * 2]))
+  })
+  // ------------------------------------------------------------
+  // Instances
+  // ------------------------------------------------------------
+  it('Should receive kind instance on registry callback', () => {
+    const stack: string[] = []
+    TypeRegistry.Set('Kind', (schema: unknown) => {
+      // prettier-ignore
+      return (typeof schema === 'object' && schema !== null && Kind in schema && schema[Kind] === 'Kind' && '$id' in schema && typeof schema.$id === 'string') 
+        ? (() => { stack.push(schema.$id); return true })()
+        : false
+    })
+    const A = { [Kind]: 'Kind', $id: 'A' } as TSchema
+    const B = { [Kind]: 'Kind', $id: 'B' } as TSchema
+    const T = Type.Object({ a: A, b: B })
+    const R = Value.Check(T, { a: null, b: null })
+    Assert.IsTrue(R)
+    Assert.IsEqual(stack[0], 'A')
+    Assert.IsEqual(stack[1], 'B')
+    TypeRegistry.Delete('Kind')
+  })
+})
diff --git a/test/runtime/value/convert/custom.ts b/test/runtime/value/convert/custom.ts
deleted file mode 100644
index e284fbe82..000000000
--- a/test/runtime/value/convert/custom.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { Value } from '@sinclair/typebox/value'
-import { TypeSystem } from '@sinclair/typebox/system'
-import { Assert } from '../../assert/index'
-
-describe('value/convert/Custom', () => {
-  it('Should not convert 1', () => {
-    const Custom = TypeSystem.Type('type/convert/Custom/1', () => true)
-    const T = Custom()
-    const R = Value.Convert(T, true)
-    Assert.IsEqual(R, true)
-  })
-  it('Should not convert 2', () => {
-    const Custom = TypeSystem.Type('type/convert/Custom/2', () => true)
-    const T = Custom()
-    const R = Value.Convert(T, 42)
-    Assert.IsEqual(R, 42)
-  })
-  it('Should not convert 3', () => {
-    const Custom = TypeSystem.Type('type/convert/Custom/3', () => true)
-    const T = Custom()
-    const R = Value.Convert(T, 'hello')
-    Assert.IsEqual(R, 'hello')
-  })
-})
diff --git a/test/runtime/value/convert/index.ts b/test/runtime/value/convert/index.ts
index 8514f77cc..09f006f09 100644
--- a/test/runtime/value/convert/index.ts
+++ b/test/runtime/value/convert/index.ts
@@ -5,7 +5,7 @@ import './bigint'
 import './boolean'
 import './composite'
 import './constructor'
-import './custom'
+import './kind'
 import './date'
 import './enum'
 import './function'
diff --git a/test/runtime/value/convert/kind.ts b/test/runtime/value/convert/kind.ts
new file mode 100644
index 000000000..116178c9b
--- /dev/null
+++ b/test/runtime/value/convert/kind.ts
@@ -0,0 +1,39 @@
+import { Value } from '@sinclair/typebox/value'
+import { TypeRegistry, Kind, TSchema } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Kind', () => {
+  // ---------------------------------------------------------
+  // Fixtures
+  // ---------------------------------------------------------
+  beforeEach(() => TypeRegistry.Set('Kind', () => true))
+  afterEach(() => TypeRegistry.Delete('Kind'))
+  // ---------------------------------------------------------
+  // Test
+  // ---------------------------------------------------------
+  it('Should not convert value 1', () => {
+    const T = { [Kind]: 'Kind' } as TSchema
+    const R = Value.Convert(T, true)
+    Assert.IsEqual(R, true)
+  })
+  it('Should not convert value 2', () => {
+    const T = { [Kind]: 'Kind' } as TSchema
+    const R = Value.Convert(T, 42)
+    Assert.IsEqual(R, 42)
+  })
+  it('Should not convert value 3', () => {
+    const T = { [Kind]: 'Kind' } as TSchema
+    const R = Value.Convert(T, 'hello')
+    Assert.IsEqual(R, 'hello')
+  })
+  it('Should not convert value 4', () => {
+    const T = { [Kind]: 'Kind' } as TSchema
+    const R = Value.Convert(T, { x: 1 })
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should not convert value 5', () => {
+    const T = { [Kind]: 'Kind' } as TSchema
+    const R = Value.Convert(T, [0, 1])
+    Assert.IsEqual(R, [0, 1])
+  })
+})
diff --git a/test/runtime/value/create/custom.ts b/test/runtime/value/create/custom.ts
deleted file mode 100644
index 8756a9c0a..000000000
--- a/test/runtime/value/create/custom.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { Value } from '@sinclair/typebox/value'
-import { Type, Kind, TypeRegistry } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
-
-describe('value/create/Custom', () => {
-  it('Should create custom value with default', () => {
-    TypeRegistry.Set('CustomCreate1', () => true)
-    const T = Type.Unsafe({ [Kind]: 'CustomCreate1', default: 'hello' })
-    Assert.IsEqual(Value.Create(T), 'hello')
-  })
-
-  it('Should throw when no default value is specified', () => {
-    TypeRegistry.Set('CustomCreate2', () => true)
-    const T = Type.Unsafe({ [Kind]: 'CustomCreate2' })
-    Assert.Throws(() => Value.Create(T))
-  })
-})
diff --git a/test/runtime/value/create/index.ts b/test/runtime/value/create/index.ts
index 385f53f1e..9bb482979 100644
--- a/test/runtime/value/create/index.ts
+++ b/test/runtime/value/create/index.ts
@@ -4,7 +4,6 @@ import './async-iterator'
 import './bigint'
 import './boolean'
 import './composite'
-import './custom'
 import './constructor'
 import './enum'
 import './function'
@@ -12,6 +11,7 @@ import './integer'
 import './intersect'
 import './iterator'
 import './keyof'
+import './kind'
 import './literal'
 import './never'
 import './not'
diff --git a/test/runtime/value/create/kind.ts b/test/runtime/value/create/kind.ts
new file mode 100644
index 000000000..3bb42d242
--- /dev/null
+++ b/test/runtime/value/create/kind.ts
@@ -0,0 +1,23 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type, Kind, TypeRegistry } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Kind', () => {
+  // ---------------------------------------------------------
+  // Fixtures
+  // ---------------------------------------------------------
+  beforeEach(() => TypeRegistry.Set('Kind', () => true))
+  afterEach(() => TypeRegistry.Delete('Kind'))
+  // ---------------------------------------------------------
+  // Tests
+  // ---------------------------------------------------------
+  it('Should create custom value with default', () => {
+    const T = Type.Unsafe({ [Kind]: 'Kind', default: 'hello' })
+    Assert.IsEqual(Value.Create(T), 'hello')
+  })
+  it('Should throw when no default value is specified', () => {
+    TypeRegistry.Set('Kind', () => true)
+    const T = Type.Unsafe({ [Kind]: 'Kind' })
+    Assert.Throws(() => Value.Create(T))
+  })
+})

From 8af419e37544ceb2916cff4dd3e15d45874768da Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 5 Aug 2023 21:39:31 +0900
Subject: [PATCH 170/369] Retain Registry Kinds on Compile (#523)

---
 package-lock.json                |  4 +--
 package.json                     |  2 +-
 src/compiler/compiler.ts         |  5 ++--
 test/runtime/compiler/kind.ts    | 51 ++++++++++++++++++++++++++++++++
 test/runtime/value/check/kind.ts | 37 +++++++++++++++++++++++
 5 files changed, 94 insertions(+), 5 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index e71d5adf3..45c146d60 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.30.3",
+  "version": "0.30.4",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.30.3",
+      "version": "0.30.4",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index bee3ce854..2b88f0e00 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.30.3",
+  "version": "0.30.4",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index c0bac349e..1fd7f1def 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -545,9 +545,10 @@ export namespace TypeCompiler {
   export function Compile<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []): TypeCheck<T> {
     const generatedCode = Code(schema, references, { language: 'javascript' })
     const compiledFunction = globalThis.Function('kind', 'format', 'hash', generatedCode)
+    const instances = new Map(state.instances)
     function typeRegistryFunction(kind: string, instance: number, value: unknown) {
-      if (!Types.TypeRegistry.Has(kind) || !state.instances.has(instance)) return false
-      const schema = state.instances.get(instance)
+      if (!Types.TypeRegistry.Has(kind) || !instances.has(instance)) return false
+      const schema = instances.get(instance)
       const checkFunc = Types.TypeRegistry.Get(kind)!
       return checkFunc(schema, value)
     }
diff --git a/test/runtime/compiler/kind.ts b/test/runtime/compiler/kind.ts
index 972c5def2..2b500cf5d 100644
--- a/test/runtime/compiler/kind.ts
+++ b/test/runtime/compiler/kind.ts
@@ -69,4 +69,55 @@ describe('type/compiler/Kind', () => {
     Assert.IsEqual(stack[1], 'B')
     TypeRegistry.Delete('Kind')
   })
+  // ------------------------------------------------------------
+  // Instances Retain
+  // ------------------------------------------------------------
+  it('Should retain kind instances on subsequent compile', () => {
+    let stack: string[] = []
+    TypeRegistry.Set('Kind', (schema: unknown) => {
+      // prettier-ignore
+      return (typeof schema === 'object' && schema !== null && Kind in schema && schema[Kind] === 'Kind' && '$id' in schema && typeof schema.$id === 'string') 
+        ? (() => { stack.push(schema.$id); return true })()
+        : false
+    })
+    const A = { [Kind]: 'Kind', $id: 'A' } as TSchema
+    const B = { [Kind]: 'Kind', $id: 'B' } as TSchema
+    const C = { [Kind]: 'Kind', $id: 'C' } as TSchema
+    const D = { [Kind]: 'Kind', $id: 'D' } as TSchema
+    const T1 = Type.Object({ a: A, b: B })
+    const T2 = Type.Object({ a: C, b: D })
+
+    // Compile T1 and run check, expect A and B
+    const C1 = TypeCompiler.Compile(T1)
+    const R1 = C1.Check({ a: null, b: null })
+    Assert.IsTrue(R1)
+    Assert.IsEqual(stack.length, 2)
+    Assert.IsEqual(stack[0], 'A')
+    Assert.IsEqual(stack[1], 'B')
+    stack = []
+    // compile T2 and force instance.clear()
+    const C2 = TypeCompiler.Compile(T2)
+    // run T1 check
+    const R2 = C1.Check({ a: null, b: null })
+    Assert.IsTrue(R2)
+    Assert.IsEqual(stack.length, 2)
+    Assert.IsEqual(stack[0], 'A')
+    Assert.IsEqual(stack[1], 'B')
+    stack = []
+    // run T2 check
+    const R3 = C2.Check({ a: null, b: null })
+    Assert.IsTrue(R3)
+    Assert.IsEqual(stack.length, 2)
+    Assert.IsEqual(stack[0], 'C')
+    Assert.IsEqual(stack[1], 'D')
+    stack = []
+    // run T1 check
+    const R4 = C1.Check({ a: null, b: null })
+    Assert.IsTrue(R4)
+    Assert.IsEqual(stack.length, 2)
+    Assert.IsEqual(stack[0], 'A')
+    Assert.IsEqual(stack[1], 'B')
+    stack = []
+    TypeRegistry.Delete('Kind')
+  })
 })
diff --git a/test/runtime/value/check/kind.ts b/test/runtime/value/check/kind.ts
index 91ad48a15..9a16eed65 100644
--- a/test/runtime/value/check/kind.ts
+++ b/test/runtime/value/check/kind.ts
@@ -67,4 +67,41 @@ describe('value/check/Kind', () => {
     Assert.IsEqual(stack[1], 'B')
     TypeRegistry.Delete('Kind')
   })
+  it('Should retain kind instances on subsequent check', () => {
+    let stack: string[] = []
+    TypeRegistry.Set('Kind', (schema: unknown) => {
+      // prettier-ignore
+      return (typeof schema === 'object' && schema !== null && Kind in schema && schema[Kind] === 'Kind' && '$id' in schema && typeof schema.$id === 'string') 
+        ? (() => { stack.push(schema.$id); return true })()
+        : false
+    })
+    const A = { [Kind]: 'Kind', $id: 'A' } as TSchema
+    const B = { [Kind]: 'Kind', $id: 'B' } as TSchema
+    const C = { [Kind]: 'Kind', $id: 'C' } as TSchema
+    const D = { [Kind]: 'Kind', $id: 'D' } as TSchema
+    const T1 = Type.Object({ a: A, b: B })
+    const T2 = Type.Object({ a: C, b: D })
+    // run T1 check
+    const R2 = Value.Check(T1, { a: null, b: null })
+    Assert.IsTrue(R2)
+    Assert.IsEqual(stack.length, 2)
+    Assert.IsEqual(stack[0], 'A')
+    Assert.IsEqual(stack[1], 'B')
+    stack = []
+    // run T2 check
+    const R3 = Value.Check(T2, { a: null, b: null })
+    Assert.IsTrue(R3)
+    Assert.IsEqual(stack.length, 2)
+    Assert.IsEqual(stack[0], 'C')
+    Assert.IsEqual(stack[1], 'D')
+    stack = []
+    // run T1 check
+    const R4 = Value.Check(T1, { a: null, b: null })
+    Assert.IsTrue(R4)
+    Assert.IsEqual(stack.length, 2)
+    Assert.IsEqual(stack[0], 'A')
+    Assert.IsEqual(stack[1], 'B')
+    stack = []
+    TypeRegistry.Delete('Kind')
+  })
 })

From 920343cbc7e987b432595088d1b002c11a52a9cb Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sat, 5 Aug 2023 21:41:56 +0900
Subject: [PATCH 171/369] Documentation

---
 readme.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/readme.md b/readme.md
index f3f6c2c3d..3cec6819c 100644
--- a/readme.md
+++ b/readme.md
@@ -110,7 +110,7 @@ License MIT
   - [Types](#typesystem-types)
   - [Formats](#typesystem-formats)
   - [Policies](#typesystem-policies)
-- [Transform](#transform)
+- [Workbench](#workbench)
 - [Ecosystem](#ecosystem)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
@@ -1516,13 +1516,13 @@ TypeSystem.AllowArrayObjects = true
 TypeSystem.AllowNaN = true
 ```
 
-<a name='transform'></a>
+<a name='workbench'></a>
 
-## TypeBox Transform
+## TypeBox Workbench
 
 TypeBox offers a small web based code generation tool that can be used to convert TypeScript types into TypeBox types as well as a variety of other runtime type representations.
 
-[TypeBox Transform Link Here](https://sinclairzx81.github.io/typebox-transform/)
+[TypeBox Workbench Link Here](https://sinclairzx81.github.io/typebox-workbench/)
 
 <a name='ecosystem'></a>
 

From 18d1cf7ac57c8b5f0292cb02ddbd1707e86c8c4c Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 12 Aug 2023 06:31:50 +0900
Subject: [PATCH 172/369] Revision 0.31.0 (#525)

---
 .../compression/module/typebox-errors.ts      |    4 +-
 changelog/0.31.0.md                           |  331 +++
 examples/collections/array.ts                 |    6 +-
 examples/collections/map.ts                   |    6 +-
 examples/collections/set.ts                   |    4 +-
 examples/formats/date-time.ts                 |   39 +
 examples/formats/date.ts                      |   44 +
 examples/formats/email.ts                     |   35 +
 examples/formats/index.ts                     |   37 +-
 examples/formats/ipv4.ts                      |   35 +
 examples/formats/ipv6.ts                      |   36 +
 examples/formats/readme.md                    |   19 -
 examples/formats/standard.ts                  |   74 -
 examples/formats/time.ts                      |   48 +
 examples/formats/url.ts                       |   36 +
 .../{transform/index.ts => formats/uuid.ts}   |   14 +-
 examples/transform/readme.md                  |   83 -
 examples/transform/transform.ts               |  350 ----
 examples/typedef/typedef.ts                   |   26 +-
 hammer.mjs                                    |    8 +-
 package-lock.json                             |  604 +++---
 package.json                                  |    8 +-
 readme.md                                     |  724 ++++---
 src/compiler/compiler.ts                      |  203 +-
 src/compiler/index.ts                         |    2 +-
 src/errors/errors.ts                          |  430 ++--
 src/system/system.ts                          |  219 +-
 src/typebox.ts                                | 1798 ++++++++++-------
 src/value/cast.ts                             |  224 +-
 src/value/check.ts                            |  160 +-
 src/value/clone.ts                            |   40 +-
 src/value/convert.ts                          |  154 +-
 src/value/create.ts                           |  116 +-
 src/value/delta.ts                            |   53 +-
 src/value/deref.ts                            |   41 +
 src/value/equal.ts                            |   29 +-
 src/value/guard.ts                            |    2 +-
 src/value/hash.ts                             |   28 +-
 src/value/mutate.ts                           |   36 +-
 src/value/pointer.ts                          |    4 +-
 src/value/transform.ts                        |  473 +++++
 src/value/value.ts                            |   22 +
 test/runtime/assert/assert.ts                 |    4 +-
 test/runtime/compiler/any.ts                  |    2 +-
 test/runtime/compiler/array.ts                |    2 +-
 test/runtime/compiler/async-iterator.ts       |    2 +-
 test/runtime/compiler/bigint.ts               |    2 +-
 test/runtime/compiler/boolean.ts              |    2 +-
 test/runtime/compiler/composite.ts            |    2 +-
 test/runtime/compiler/date.ts                 |   11 +-
 test/runtime/compiler/enum.ts                 |    2 +-
 test/runtime/compiler/index.ts                |    1 -
 test/runtime/compiler/integer.ts              |    2 +-
 test/runtime/compiler/intersect.ts            |    4 +-
 test/runtime/compiler/iterator.ts             |    2 +-
 test/runtime/compiler/keyof.ts                |    3 +-
 test/runtime/compiler/kind.ts                 |    2 +-
 test/runtime/compiler/literal.ts              |    2 +-
 test/runtime/compiler/modifier.ts             |    3 -
 test/runtime/compiler/never.ts                |    2 +-
 test/runtime/compiler/not.ts                  |    2 +-
 test/runtime/compiler/null.ts                 |    2 +-
 test/runtime/compiler/number.ts               |    2 +-
 test/runtime/compiler/object.ts               |    2 +-
 test/runtime/compiler/omit.ts                 |    2 +-
 test/runtime/compiler/optional.ts             |    2 +-
 test/runtime/compiler/partial.ts              |    2 +-
 test/runtime/compiler/pick.ts                 |    2 +-
 test/runtime/compiler/readonly-optional.ts    |    2 +-
 test/runtime/compiler/readonly.ts             |    2 +-
 test/runtime/compiler/record.ts               |    2 +-
 test/runtime/compiler/recursive.ts            |    2 +-
 test/runtime/compiler/ref.ts                  |    2 +-
 test/runtime/compiler/regexp.ts               |    2 +-
 test/runtime/compiler/required.ts             |    2 +-
 test/runtime/compiler/string.ts               |    2 +-
 test/runtime/compiler/symbol.ts               |    2 +-
 test/runtime/compiler/template-literal.ts     |    2 +-
 test/runtime/compiler/tuple.ts                |    3 +-
 test/runtime/compiler/uint8array.ts           |    2 +-
 test/runtime/compiler/unicode.ts              |    2 +-
 test/runtime/compiler/union.ts                |    2 +-
 test/runtime/compiler/unknown.ts              |    4 +-
 test/runtime/compiler/void.ts                 |    2 +-
 test/runtime/errors/index.ts                  |    3 +-
 test/runtime/errors/iterator/index.ts         |    1 +
 .../runtime/errors/{ => iterator}/iterator.ts |    2 +-
 test/runtime/errors/types/array-contains.ts   |   17 +
 .../errors/types/array-max-contains.ts        |   36 +
 test/runtime/errors/types/array-max-items.ts  |   22 +
 .../errors/types/array-min-contains.ts        |   28 +
 test/runtime/errors/types/array-min-items.ts  |   22 +
 .../errors/types/array-unique-items.ts        |   21 +
 test/runtime/errors/types/array.ts            |   27 +
 test/runtime/errors/types/async-iterator.ts   |   17 +
 .../errors/types/bigint-exclusive-maximum.ts  |   17 +
 .../errors/types/bigint-exclusive-minimum.ts  |   17 +
 test/runtime/errors/types/bigint-maximum.ts   |   17 +
 test/runtime/errors/types/bigint-minimum.ts   |   17 +
 .../errors/types/bigint-multiple-of.ts        |   17 +
 test/runtime/errors/types/bigint.ts           |   17 +
 test/runtime/errors/types/boolean.ts          |   17 +
 .../types/date-exclusive-maximum-timestamp.ts |   17 +
 .../types/date-exclusive-minimum-timestamp.ts |   17 +
 .../errors/types/date-maximum-timestamp.ts    |   17 +
 .../errors/types/date-minimum-timestamp.ts    |   17 +
 .../types/date-multiple-of-timestamp.ts       |   17 +
 test/runtime/errors/types/date.ts             |   17 +
 test/runtime/errors/types/function.ts         |   17 +
 test/runtime/errors/types/index.ts            |   63 +
 .../errors/types/integer-exclusive-maximum.ts |   17 +
 .../errors/types/integer-exclusive-minimum.ts |   17 +
 test/runtime/errors/types/integer-maximum.ts  |   17 +
 test/runtime/errors/types/integer-minimum.ts  |   17 +
 .../errors/types/integer-multiple-of.ts       |   17 +
 test/runtime/errors/types/integer.ts          |   17 +
 .../types/intersect-unevaluated-properties.ts |   36 +
 test/runtime/errors/types/intersect.ts        |   24 +
 test/runtime/errors/types/iterator.ts         |   17 +
 test/runtime/errors/types/kind.ts             |   25 +
 test/runtime/errors/types/literal.ts          |   46 +
 test/runtime/errors/types/never.ts            |   13 +
 test/runtime/errors/types/not.ts              |   17 +
 test/runtime/errors/types/null.ts             |   17 +
 .../errors/types/number-exclusive-maximum.ts  |   17 +
 .../errors/types/number-exclusive-minimum.ts  |   17 +
 test/runtime/errors/types/number-maximum.ts   |   17 +
 test/runtime/errors/types/number-minimum.ts   |   17 +
 .../errors/types/number-multiple-of.ts        |   17 +
 test/runtime/errors/types/number.ts           |   17 +
 .../types/object-additional-properties.ts     |   48 +
 .../errors/types/object-max-properties.ts     |   17 +
 .../errors/types/object-min-properties.ts     |   17 +
 .../errors/types/object-required-property.ts  |   22 +
 test/runtime/errors/types/object.ts           |   65 +
 test/runtime/errors/types/promise.ts          |   17 +
 test/runtime/errors/types/resolve.ts          |    7 +
 .../errors/types/string-format-unknown.ts     |   13 +
 test/runtime/errors/types/string-format.ts    |   25 +
 .../runtime/errors/types/string-max-length.ts |   17 +
 .../runtime/errors/types/string-min-length.ts |   17 +
 test/runtime/errors/types/string-pattern.ts   |   17 +
 test/runtime/errors/types/string.ts           |   17 +
 test/runtime/errors/types/symbol.ts           |   17 +
 test/runtime/errors/types/tuple-length.ts     |   56 +
 test/runtime/errors/types/tuple.ts            |   17 +
 .../types/uint8array-max-byte-length.ts       |   17 +
 .../types/uint8array-min-byte-length.ts       |   17 +
 test/runtime/errors/types/uint8array.ts       |   17 +
 test/runtime/errors/types/undefined.ts        |   17 +
 test/runtime/errors/types/union.ts            |   21 +
 test/runtime/errors/types/void.ts             |   32 +
 test/runtime/system/index.ts                  |    3 +-
 .../system/policy/allow-array-object.ts       |   65 +
 test/runtime/system/policy/allow-nan.ts       |   62 +
 test/runtime/system/policy/allow-null-void.ts |   31 +
 .../policy/exact-optional-property-types.ts   |   39 +
 test/runtime/system/policy/index.ts           |    4 +
 test/runtime/system/system.ts                 |  205 --
 test/runtime/system/type/format.ts            |   19 +
 test/runtime/system/type/index.ts             |    2 +
 test/runtime/system/type/type.ts              |   22 +
 test/runtime/type/guard/date.ts               |   23 +-
 test/runtime/type/guard/index.ts              |    1 +
 test/runtime/type/guard/intersect.ts          |    9 +-
 test/runtime/type/guard/omit.ts               |   17 +-
 test/runtime/type/guard/partial.ts            |   16 +-
 test/runtime/type/guard/pick.ts               |   17 +-
 test/runtime/type/guard/record.ts             |   24 +-
 test/runtime/type/guard/recursive.ts          |   16 +
 test/runtime/type/guard/required.ts           |   16 +-
 test/runtime/type/guard/rest.ts               |   67 +-
 test/runtime/type/intrinsic/intrinsic.ts      |    5 +-
 test/runtime/type/normalize/exclude.ts        |    2 +-
 test/runtime/type/normalize/extract.ts        |    2 +-
 test/runtime/type/normalize/indexed.ts        |    2 +-
 test/runtime/type/normalize/intersect.ts      |    2 +-
 test/runtime/type/normalize/record.ts         |    2 +-
 test/runtime/type/normalize/union.ts          |    2 +-
 test/runtime/type/registry/format.ts          |    2 +-
 test/runtime/type/registry/type.ts            |    2 +-
 test/runtime/type/template/finite.ts          |    2 +-
 test/runtime/type/template/generate.ts        |    2 +-
 test/runtime/type/template/parser.ts          |    2 +-
 test/runtime/type/template/pattern.ts         |    2 +-
 test/runtime/value/cast/regexp.ts             |    2 +-
 test/runtime/value/cast/void.ts               |    6 +-
 test/runtime/value/check/date.ts              |   53 +-
 test/runtime/value/convert/async-iterator.ts  |    3 -
 test/runtime/value/convert/constructor.ts     |    5 +-
 test/runtime/value/convert/function.ts        |    3 -
 test/runtime/value/convert/integer.ts         |    2 +-
 test/runtime/value/convert/iterator.ts        |    3 -
 test/runtime/value/convert/literal.ts         |    6 +-
 test/runtime/value/convert/number.ts          |    2 +-
 test/runtime/value/convert/promise.ts         |    6 +-
 test/runtime/value/convert/record.ts          |    2 +-
 test/runtime/value/convert/regexp.ts          |    2 +-
 test/runtime/value/convert/symbol.ts          |    8 +-
 test/runtime/value/convert/tuple.ts           |    2 +-
 test/runtime/value/create/array.ts            |    2 +-
 test/runtime/value/create/string.ts           |    2 +-
 test/runtime/value/create/void.ts             |    2 +-
 test/runtime/value/index.ts                   |    1 +
 test/runtime/value/transform/_nested.ts       |   52 +
 test/runtime/value/transform/any.ts           |   34 +
 test/runtime/value/transform/array.ts         |   97 +
 .../runtime/value/transform/async-iterator.ts |   40 +
 test/runtime/value/transform/bigint.ts        |   40 +
 test/runtime/value/transform/boolean.ts       |   40 +
 test/runtime/value/transform/constructor.ts   |   40 +
 test/runtime/value/transform/date.ts          |   40 +
 test/runtime/value/transform/function.ts      |   40 +
 test/runtime/value/transform/index.ts         |   31 +
 test/runtime/value/transform/integer.ts       |   40 +
 test/runtime/value/transform/intersect.ts     |  122 ++
 test/runtime/value/transform/iterator.ts      |   40 +
 test/runtime/value/transform/literal.ts       |   71 +
 test/runtime/value/transform/never.ts         |   33 +
 test/runtime/value/transform/not.ts           |   40 +
 test/runtime/value/transform/null.ts          |   40 +
 test/runtime/value/transform/number.ts        |   40 +
 test/runtime/value/transform/object.ts        |  153 ++
 test/runtime/value/transform/promise.ts       |   40 +
 test/runtime/value/transform/record.ts        |  123 ++
 test/runtime/value/transform/recursive.ts     |  131 ++
 test/runtime/value/transform/ref.ts           |   62 +
 test/runtime/value/transform/string.ts        |   40 +
 test/runtime/value/transform/symbol.ts        |   40 +
 .../value/transform/template-literal.ts       |   40 +
 test/runtime/value/transform/tuple.ts         |   98 +
 test/runtime/value/transform/undefined.ts     |   40 +
 test/runtime/value/transform/union.ts         |  170 ++
 test/runtime/value/transform/unknown.ts       |   34 +
 test/runtime/value/transform/unsafe.ts        |   46 +
 test/runtime/value/transform/void.ts          |   40 +
 test/static/any.ts                            |    2 +-
 test/static/array.ts                          |    8 +-
 test/static/assert.ts                         |    9 +-
 test/static/async-iterator.ts                 |    2 +-
 test/static/awaited.ts                        |   14 +-
 test/static/bigint.ts                         |    2 +-
 test/static/boolean.ts                        |    2 +-
 test/static/capitalize.ts                     |   10 +-
 test/static/composite.ts                      |   14 +-
 test/static/constructor-parameters.ts         |    2 +-
 test/static/constructor.ts                    |    2 +-
 test/static/date.ts                           |    2 +-
 test/static/enum.ts                           |    2 +-
 test/static/exclude.ts                        |   24 +-
 test/static/extract.ts                        |   24 +-
 test/static/function.ts                       |    2 +-
 test/static/index.ts                          |    1 +
 test/static/indexed.ts                        |   51 +-
 test/static/intersect.ts                      |    8 +-
 test/static/iterator.ts                       |    2 +-
 test/static/keyof.ts                          |   16 +-
 test/static/literal.ts                        |    6 +-
 test/static/lowercase.ts                      |   10 +-
 test/static/modifier.ts                       |    2 +-
 test/static/never.ts                          |    2 +-
 test/static/not.ts                            |    6 +-
 test/static/null.ts                           |    2 +-
 test/static/number.ts                         |    2 +-
 test/static/object.ts                         |    6 +-
 test/static/omit.ts                           |   12 +-
 test/static/optional.ts                       |    2 +-
 test/static/parameters.ts                     |    2 +-
 test/static/partial.ts                        |    6 +-
 test/static/pick.ts                           |   14 +-
 test/static/readonly-optional.ts              |    2 +-
 test/static/readonly.ts                       |    2 +-
 test/static/record.ts                         |   18 +-
 test/static/recursive.ts                      |   12 +-
 test/static/ref.ts                            |    4 +-
 test/static/regexp.ts                         |    2 +-
 test/static/required.ts                       |    6 +-
 test/static/rest.ts                           |   56 +-
 test/static/return-type.ts                    |    4 +-
 test/static/strict.ts                         |    2 +-
 test/static/string.ts                         |    2 +-
 test/static/symbol.ts                         |    2 +-
 test/static/template-literal.ts               |   22 +-
 test/static/transform.ts                      |  184 ++
 test/static/tuple.ts                          |    2 +-
 test/static/uncapitalize.ts                   |   10 +-
 test/static/union.ts                          |    8 +-
 test/static/unknown.ts                        |    2 +-
 test/static/uppercase.ts                      |   10 +-
 tsconfig.json                                 |    3 +
 290 files changed, 8014 insertions(+), 3458 deletions(-)
 create mode 100644 changelog/0.31.0.md
 create mode 100644 examples/formats/date-time.ts
 create mode 100644 examples/formats/date.ts
 create mode 100644 examples/formats/email.ts
 create mode 100644 examples/formats/ipv4.ts
 create mode 100644 examples/formats/ipv6.ts
 delete mode 100644 examples/formats/readme.md
 delete mode 100644 examples/formats/standard.ts
 create mode 100644 examples/formats/time.ts
 create mode 100644 examples/formats/url.ts
 rename examples/{transform/index.ts => formats/uuid.ts} (76%)
 delete mode 100644 examples/transform/readme.md
 delete mode 100644 examples/transform/transform.ts
 create mode 100644 src/value/deref.ts
 create mode 100644 src/value/transform.ts
 delete mode 100644 test/runtime/compiler/modifier.ts
 create mode 100644 test/runtime/errors/iterator/index.ts
 rename test/runtime/errors/{ => iterator}/iterator.ts (96%)
 create mode 100644 test/runtime/errors/types/array-contains.ts
 create mode 100644 test/runtime/errors/types/array-max-contains.ts
 create mode 100644 test/runtime/errors/types/array-max-items.ts
 create mode 100644 test/runtime/errors/types/array-min-contains.ts
 create mode 100644 test/runtime/errors/types/array-min-items.ts
 create mode 100644 test/runtime/errors/types/array-unique-items.ts
 create mode 100644 test/runtime/errors/types/array.ts
 create mode 100644 test/runtime/errors/types/async-iterator.ts
 create mode 100644 test/runtime/errors/types/bigint-exclusive-maximum.ts
 create mode 100644 test/runtime/errors/types/bigint-exclusive-minimum.ts
 create mode 100644 test/runtime/errors/types/bigint-maximum.ts
 create mode 100644 test/runtime/errors/types/bigint-minimum.ts
 create mode 100644 test/runtime/errors/types/bigint-multiple-of.ts
 create mode 100644 test/runtime/errors/types/bigint.ts
 create mode 100644 test/runtime/errors/types/boolean.ts
 create mode 100644 test/runtime/errors/types/date-exclusive-maximum-timestamp.ts
 create mode 100644 test/runtime/errors/types/date-exclusive-minimum-timestamp.ts
 create mode 100644 test/runtime/errors/types/date-maximum-timestamp.ts
 create mode 100644 test/runtime/errors/types/date-minimum-timestamp.ts
 create mode 100644 test/runtime/errors/types/date-multiple-of-timestamp.ts
 create mode 100644 test/runtime/errors/types/date.ts
 create mode 100644 test/runtime/errors/types/function.ts
 create mode 100644 test/runtime/errors/types/index.ts
 create mode 100644 test/runtime/errors/types/integer-exclusive-maximum.ts
 create mode 100644 test/runtime/errors/types/integer-exclusive-minimum.ts
 create mode 100644 test/runtime/errors/types/integer-maximum.ts
 create mode 100644 test/runtime/errors/types/integer-minimum.ts
 create mode 100644 test/runtime/errors/types/integer-multiple-of.ts
 create mode 100644 test/runtime/errors/types/integer.ts
 create mode 100644 test/runtime/errors/types/intersect-unevaluated-properties.ts
 create mode 100644 test/runtime/errors/types/intersect.ts
 create mode 100644 test/runtime/errors/types/iterator.ts
 create mode 100644 test/runtime/errors/types/kind.ts
 create mode 100644 test/runtime/errors/types/literal.ts
 create mode 100644 test/runtime/errors/types/never.ts
 create mode 100644 test/runtime/errors/types/not.ts
 create mode 100644 test/runtime/errors/types/null.ts
 create mode 100644 test/runtime/errors/types/number-exclusive-maximum.ts
 create mode 100644 test/runtime/errors/types/number-exclusive-minimum.ts
 create mode 100644 test/runtime/errors/types/number-maximum.ts
 create mode 100644 test/runtime/errors/types/number-minimum.ts
 create mode 100644 test/runtime/errors/types/number-multiple-of.ts
 create mode 100644 test/runtime/errors/types/number.ts
 create mode 100644 test/runtime/errors/types/object-additional-properties.ts
 create mode 100644 test/runtime/errors/types/object-max-properties.ts
 create mode 100644 test/runtime/errors/types/object-min-properties.ts
 create mode 100644 test/runtime/errors/types/object-required-property.ts
 create mode 100644 test/runtime/errors/types/object.ts
 create mode 100644 test/runtime/errors/types/promise.ts
 create mode 100644 test/runtime/errors/types/resolve.ts
 create mode 100644 test/runtime/errors/types/string-format-unknown.ts
 create mode 100644 test/runtime/errors/types/string-format.ts
 create mode 100644 test/runtime/errors/types/string-max-length.ts
 create mode 100644 test/runtime/errors/types/string-min-length.ts
 create mode 100644 test/runtime/errors/types/string-pattern.ts
 create mode 100644 test/runtime/errors/types/string.ts
 create mode 100644 test/runtime/errors/types/symbol.ts
 create mode 100644 test/runtime/errors/types/tuple-length.ts
 create mode 100644 test/runtime/errors/types/tuple.ts
 create mode 100644 test/runtime/errors/types/uint8array-max-byte-length.ts
 create mode 100644 test/runtime/errors/types/uint8array-min-byte-length.ts
 create mode 100644 test/runtime/errors/types/uint8array.ts
 create mode 100644 test/runtime/errors/types/undefined.ts
 create mode 100644 test/runtime/errors/types/union.ts
 create mode 100644 test/runtime/errors/types/void.ts
 create mode 100644 test/runtime/system/policy/allow-array-object.ts
 create mode 100644 test/runtime/system/policy/allow-nan.ts
 create mode 100644 test/runtime/system/policy/allow-null-void.ts
 create mode 100644 test/runtime/system/policy/exact-optional-property-types.ts
 create mode 100644 test/runtime/system/policy/index.ts
 delete mode 100644 test/runtime/system/system.ts
 create mode 100644 test/runtime/system/type/format.ts
 create mode 100644 test/runtime/system/type/index.ts
 create mode 100644 test/runtime/system/type/type.ts
 create mode 100644 test/runtime/type/guard/recursive.ts
 create mode 100644 test/runtime/value/transform/_nested.ts
 create mode 100644 test/runtime/value/transform/any.ts
 create mode 100644 test/runtime/value/transform/array.ts
 create mode 100644 test/runtime/value/transform/async-iterator.ts
 create mode 100644 test/runtime/value/transform/bigint.ts
 create mode 100644 test/runtime/value/transform/boolean.ts
 create mode 100644 test/runtime/value/transform/constructor.ts
 create mode 100644 test/runtime/value/transform/date.ts
 create mode 100644 test/runtime/value/transform/function.ts
 create mode 100644 test/runtime/value/transform/index.ts
 create mode 100644 test/runtime/value/transform/integer.ts
 create mode 100644 test/runtime/value/transform/intersect.ts
 create mode 100644 test/runtime/value/transform/iterator.ts
 create mode 100644 test/runtime/value/transform/literal.ts
 create mode 100644 test/runtime/value/transform/never.ts
 create mode 100644 test/runtime/value/transform/not.ts
 create mode 100644 test/runtime/value/transform/null.ts
 create mode 100644 test/runtime/value/transform/number.ts
 create mode 100644 test/runtime/value/transform/object.ts
 create mode 100644 test/runtime/value/transform/promise.ts
 create mode 100644 test/runtime/value/transform/record.ts
 create mode 100644 test/runtime/value/transform/recursive.ts
 create mode 100644 test/runtime/value/transform/ref.ts
 create mode 100644 test/runtime/value/transform/string.ts
 create mode 100644 test/runtime/value/transform/symbol.ts
 create mode 100644 test/runtime/value/transform/template-literal.ts
 create mode 100644 test/runtime/value/transform/tuple.ts
 create mode 100644 test/runtime/value/transform/undefined.ts
 create mode 100644 test/runtime/value/transform/union.ts
 create mode 100644 test/runtime/value/transform/unknown.ts
 create mode 100644 test/runtime/value/transform/unsafe.ts
 create mode 100644 test/runtime/value/transform/void.ts
 create mode 100644 test/static/transform.ts

diff --git a/benchmark/compression/module/typebox-errors.ts b/benchmark/compression/module/typebox-errors.ts
index 4a6324bbb..f1de81528 100644
--- a/benchmark/compression/module/typebox-errors.ts
+++ b/benchmark/compression/module/typebox-errors.ts
@@ -1,3 +1,3 @@
-import * as ValueErrors from '@sinclair/typebox/errors'
+import * as Errors from '@sinclair/typebox/errors'
 
-console.log(ValueErrors)
+console.log(Errors)
diff --git a/changelog/0.31.0.md b/changelog/0.31.0.md
new file mode 100644
index 000000000..4dc83aa48
--- /dev/null
+++ b/changelog/0.31.0.md
@@ -0,0 +1,331 @@
+## [0.31.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.31.0)
+
+## Overview
+
+Revision 0.31.0 is a subsequent milestone revision for the TypeBox library and a direct continuation of the work carried out in 0.30.0 to optimize and prepare TypeBox for a 1.0 release candidate. This revision implements a new codec system with Transform types, provides configurable error message generation for i18n support, adds a library wide exception type named TypeBoxError and generalizes the Rest type to enable richer composition. This revision also finalizes optimization work to reduce the TypeBox package size.
+
+This revision contains relatively minor breaking changes due to internal type renaming. A minor semver revision is required.
+
+## Contents
+
+- Enhancements
+  - [Transform Types](#Transform-Types)
+  - [Encode and Decode](#Encode-and-Decode)
+  - [StaticEncode and StaticDecode](#StaticEncode-and-StaticDecode)
+  - [Rest Types](#Rest-Types)
+  - [Record Key](#Record-Key)
+  - [TypeBoxError](#TypeBoxError)
+  - [TypeSystemErrorFunction](#TypeSystemErrorFunction)
+  - [Reduce Package Size](#Reduce-Package-Size)
+- Breaking
+  - [JsonTypeBuilder and JavaScriptTypeBuilder](#JsonTypeBuilder-and-JavaScriptTypeBuilder)
+  - [TypeSystemPolicy](#TypeSystemPolicy)
+
+<a name="Transform-Types"></a>
+
+## Transform Types
+
+Revision 0.31.0 includes a new codec system referred to as Transform types. A Transform type is used to augment a regular TypeBox type with Encode and Decode functions. These functions are invoked via the new Encode and Decode functions available on both Value and TypeCompiler modules.
+
+The following shows a Transform type which increments and decrements a number.
+
+```typescript
+import { Value } from '@sinclair/typebox/value'
+
+const T = Type.Transform(Type.Number())             // const T = {
+  .Decode(value => value + 1)                       //   type: 'number',
+  .Encode(value => value - 1)                       //   [Symbol(TypeBox.Kind)]: 'Number',
+                                                    //   [Symbol(TypeBox.Transform)]: { 
+                                                    //     Decode: [Function: Decode], 
+                                                    //     Encode: [Function: Encode] 
+                                                    //   }
+                                                    // }
+
+const A = Value.Decode(T, 0)                        // const A: number = 1
+
+const B = Value.Encode(T, 1)                        // const B: number = 0
+```
+
+<a name="Encode-and-Decode"></a>
+
+## Encode and Decode
+
+Revision 0.31.0 includes new functions to Decode and Encode values. These functions are written in service to Transform types, but can be used equally well without them. These functions return a typed value that matches the type being transformed. TypeBox will infer decode and encode differently, yielding the correct type as derived from the codec implementation.
+
+The following shows decoding and encoding between number to Date. Note these functions will throw if the value is invalid.
+
+```typescript
+const T = Type.Transform(Type.Number())
+  .Decode(value => new Date(value))               // number to Date
+  .Encode(value => value.getTime())               // Date to number
+
+// Ok
+//
+const A = Value.Decode(T, 42)                     // const A = new Date(42)
+
+const B = Value.Encode(T, new Date(42))           // const B = 42
+
+// Error
+//
+const C = Value.Decode(T, true)                   // Error: Expected number
+
+const D = Value.Encode(T, 'not a date')           // Error: getTime is not a function
+```
+The Decode function is extremely fast when decoding regular TypeBox types; and TypeBox will by pass codec execution if the type being decoded contains no interior Transforms (and will only use Check). When using Transforms however, these functions may incur a performance penelty due to codecs operating structurally on values using dynamic techniques (as would be the case for applications manually decoding values). As such the Decode design is built to be general and opt in, but not necessarily high performance. 
+
+<a name="StaticEncode-and-StaticDecode"></a>
+
+## StaticEncode and StaticDecode
+
+Revision 0.31.0 includes new inference types `StaticEncode` and `StaticDecode`. These types can be used to infer the encoded and decoded states of a Transform as well as regular TypeBox types. These types can be used to replace `Static` for `Request` and `Response` inference pipelines.
+
+The following shows an example `Route` function that uses Transform inference via `StaticDecode`.
+
+```typescript
+// Route
+// 
+export type RouteCallback<TRequest extends TSchema, TResponse extends TSchema> = 
+  (request: StaticDecode<TRequest>) => StaticDecode<TResponse> // replace Static with StaticDecode
+
+export function Route<TPath extends string, TRequest extends TSchema, TResponse extends TSchema>(
+  path: TPath,
+  requestType: TRequest,
+  responseType: TResponse,
+  callback: RouteCallback<TRequest, TResponse>
+) {
+  // route handling here ...
+
+  const input = null // receive input
+  const request = Value.Decode(requestType, input)
+  const response = callback(request)
+  const output = Value.Encode(responseType, response)
+  // send output
+}
+
+// Route: Without Transform
+//
+const Timestamp = Type.Number()
+
+Route('/exampleA', Timestamp, Timestamp, (value) => {
+  return value // value observed as number
+})
+
+// Route: With Transform
+// 
+const Timestamp = Type.Transform(Type.Number())
+  .Decode(value => new Date(value))
+  .Encode(value => value.getTime())
+
+Route('/exampleB', Timestamp, Timestamp, (value) => {
+  return value // value observed as Date
+})
+```
+
+<a name="Rest-Types"></a>
+
+## Rest Types
+
+Revision 0.31.0 updates the Rest type to support variadic tuple extraction from Union, Intersection and Tuple types. Previously the Rest type was limited to Tuple types only, but has been extended to other types to allow uniform remapping without having to extract types from specific schema representations.
+
+The following remaps a Tuple into a Union.
+
+```typescript
+const T = Type.Tuple([                              // const T = {
+  Type.String(),                                    //   type: 'array',
+  Type.Number()                                     //   items: [ 
+])                                                  //     { type: 'string' },
+                                                    //     { type: 'number' }
+                                                    //   ],
+                                                    //   additionalItems: false,
+                                                    //   minItems: 2,
+                                                    //   maxItems: 2,
+                                                    // }
+
+const R = Type.Rest(T)                              // const R = [
+                                                    //   { type: 'string' },
+                                                    //   { type: 'number' }
+                                                    // ]
+
+const U = Type.Union(R)                             // const U = {
+                                                    //   anyOf: [
+                                                    //     { type: 'string' },
+                                                    //     { type: 'number' }
+                                                    //   ]
+                                                    // }
+```
+This type can be used to remap Intersect a Composite
+
+```typescript
+const I = Type.Intersect([                          // const I = { 
+  Type.Object({ x: Type.Number() }),                //   allOf: [{
+  Type.Object({ y: Type.Number() })                 //     type: 'object',
+])                                                  //     required: ['x'],
+                                                    //     properties: {
+                                                    //       x: { type: 'number' }
+                                                    //     }
+                                                    //   }, {
+                                                    //     type: 'object',
+                                                    //     required: ['y'],
+                                                    //     properties: {
+                                                    //       y: { type: 'number' }
+                                                    //     }
+                                                    //   }]
+                                                    // }
+
+const C = Type.Composite(Type.Rest(I))              // const C = {
+                                                    //   type: 'object',
+                                                    //   required: ['x', 'y'],
+                                                    //   properties: {
+                                                    //     'x': { type: 'number' },
+                                                    //     'y': { type: 'number' }
+                                                    //   }
+                                                    // }
+```
+
+<a name="Record-Key"></a>
+
+## Record Key
+
+Revision 0.31.0 updates the inference strategy for Record types and generalizes RecordKey to TSchema. This update aims to help Record types compose better when used with generic functions. The update also removes the overloaded Record factory methods, opting for a full conditional inference path. It also removes the `RecordKey` type which would type error when used with Record overloads. The return type of Record will be TNever if passing an invalid key. Valid Record key types include TNumber, TString, TInteger, TTemplateLiteral, TLiteralString, TLiteralNumber and TUnion.
+
+```typescript
+// 0.30.0
+//
+import { RecordKey, TSchema } from '@sinclair/typebox'
+
+function StrictRecord<K extends RecordKey, T extends TSchema>(K: K, T: T) {
+  return Type.Record(K, T, { additionalProperties: false })    // Error: RecordKey unresolvable to overload
+}
+// 0.31.0
+//
+import { TSchema } from '@sinclair/typebox'
+
+function StrictRecord<K extends TSchema, T extends TSchema>(K: K, T: T) {
+  return Type.Record(K, T, { additionalProperties: false })    // Ok: dynamically mapped
+}
+
+const A = StrictRecord(Type.String(), Type.Null())             // const A: TRecord<TString, TNull>
+
+const B = StrictRecord(Type.Literal('A'), Type.Null())         // const B: TObject<{ A: TNull }>
+
+const C = StrictRecord(Type.BigInt(), Type.Null())             // const C: TNever
+```
+
+<a name="TypeBoxError"></a>
+
+## TypeBoxError
+
+Revision 0.31.0 updates all errors thrown by TypeBox to extend the sub type `TypeBoxError`. This can be used to help narrow down the source of errors in `try/catch` blocks.
+
+```typescript
+import { Type, TypeBoxError } from '@sinclair/typebox'
+import { Value } from '@sinclair/typebox/value'
+
+try {
+  const A = Value.Decode(Type.Number(), 'hello')
+} catch(error) {
+  if(error instanceof TypeBoxError) {
+    // typebox threw this error
+  }
+}
+```
+
+<a name="TypeSystemErrorFunction"></a>
+
+## TypeSystemErrorFunction
+
+Revision 0.31.0 adds functionality to remap error messages with the TypeSystemErrorFunction. This function is invoked whenever a validation error is generated in TypeBox. The following is an example of a custom TypeSystemErrorFunction using some of the messages TypeBox generates by default. TypeBox also provides the DefaultErrorFunction which can be used for fallthrough cases.
+
+```typescript
+import { TypeSystemErrorFunction, DefaultErrorFunction } from '@sinclair/typebox/system'
+
+// Example CustomErrorFunction
+export function CustomErrorFunction(schema: Types.TSchema, errorType: ValueErrorType) {
+  switch (errorType) {
+    case ValueErrorType.ArrayContains:
+      return 'Expected array to contain at least one matching value'
+    case ValueErrorType.ArrayMaxContains:
+      return `Expected array to contain no more than ${schema.maxContains} matching values`
+    case ValueErrorType.ArrayMinContains:
+      return `Expected array to contain at least ${schema.minContains} matching values`
+    ...
+    default: return DefaultErrorFunction(schema, errorType)
+  }
+}
+// Sets the CustomErrorFunction
+TypeSystemErrorFunction.Set(CustomErrorFunction)
+```
+It is possible to call `.Set()` on the TypeSystemErrorFunction module prior to each call to `.Errors()`. This can be useful for applications that require i18n support in their validation pipelines.
+
+<a name="Reduce Package Size"></a>
+
+## Reduce Package Size
+
+Revision 0.31.0 completes a full sweep of code optimizations and modularization to reduce package bundle size. The following table shows the bundle sizes inclusive of the new 0.31.0 functionality against 0.30.0.
+
+```typescript
+// Revision 0.30.0
+//
+┌──────────────────────┬────────────┬────────────┬─────────────┐
+│       (index)        │  Compiled  │  Minified  │ Compression │
+├──────────────────────┼────────────┼────────────┼─────────────┤
+│ typebox/compiler     │ '131.4 kb' │ ' 59.4 kb' │  '2.21 x'   │
+│ typebox/errors       │ '113.6 kb' │ ' 50.9 kb' │  '2.23 x'   │
+│ typebox/system       │ ' 78.5 kb' │ ' 32.5 kb' │  '2.42 x'   │
+│ typebox/value        │ '182.8 kb' │ ' 80.0 kb' │  '2.28 x'   │
+│ typebox              │ ' 77.4 kb' │ ' 32.0 kb' │  '2.42 x'   │
+└──────────────────────┴────────────┴────────────┴─────────────┘
+
+// Revision 0.31.0
+//
+┌──────────────────────┬────────────┬────────────┬─────────────┐
+│       (index)        │  Compiled  │  Minified  │ Compression │
+├──────────────────────┼────────────┼────────────┼─────────────┤
+│ typebox/compiler     │ '149.5 kb' │ ' 66.1 kb' │  '2.26 x'   │
+│ typebox/errors       │ '112.1 kb' │ ' 49.4 kb' │  '2.27 x'   │
+│ typebox/system       │ ' 83.2 kb' │ ' 37.1 kb' │  '2.24 x'   │
+│ typebox/value        │ '191.1 kb' │ ' 82.7 kb' │  '2.31 x'   │
+│ typebox              │ ' 73.0 kb' │ ' 31.9 kb' │  '2.29 x'   │
+└──────────────────────┴────────────┴────────────┴─────────────┘
+```
+
+Additional code reductions may not be possible without implicating code maintainability. The `typebox` module may however be broken down into sub modules in later revisions to further bolster modularity, but is retained as a single file on this revision for historical reasons (not necessarily technical ones).
+
+<a name="JsonTypeBuilder-and-JavaScriptTypeBuilder"></a>
+
+## JsonTypeBuilder and JavaScriptTypeBuilder
+
+Revision 0.31.0 renames the `StandardTypeBuilder` and `ExtendedTypeBuilder` to `JsonTypeBuilder` and `JavaScriptTypeBuilder` respectively. Applications that extend TypeBox's TypeBuilders will need to update to these names.
+
+```typescript
+// 0.30.0
+//
+export class ApplicationTypeBuilder extends ExtendedTypeBuilder {}
+
+// 0.31.0
+//
+export class ApplicationTypeBuilder extends JavaScriptTypeBuilder {}
+```
+These builders also update the jsdoc comment to `[Json]` and `[JavaScript]` inline with this new naming convention.
+
+<a name="TypeSystemPolicy"></a>
+
+## TypeSystemPolicy
+
+Revision 0.31.0 moves the `TypeSystem.Policy` configurations into a new type named `TypeSystemPolicy`. This change was done to unify internal policy checks used by the Value and Error modules during bundle size optimization; as well as to keep policy configurations contextually separate from the Type and Format API on the TypeSystem module.
+
+```typescript
+// Revision 0.30.0
+//
+import { TypeSystem } from '@sinclair/typebox/system'
+
+TypeSystem.AllowNaN = true
+
+// Revision 0.31.0
+//
+import { TypeSystemPolicy } from '@sinclair/typebox/system'
+
+TypeSystemPolicy.AllowNaN = true
+
+TypeSystemPolicy.IsNumberLike(NaN) // true
+```
\ No newline at end of file
diff --git a/examples/collections/array.ts b/examples/collections/array.ts
index 1a7a7550b..90f5d73b4 100644
--- a/examples/collections/array.ts
+++ b/examples/collections/array.ts
@@ -27,18 +27,18 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { TypeCheck, TypeCompiler, ValueError } from '@sinclair/typebox/compiler'
-import { TSchema, Static } from '@sinclair/typebox'
+import { TSchema, Static, TypeBoxError } from '@sinclair/typebox'
 import { Value } from '@sinclair/typebox/value'
 
 // ----------------------------------------------------------------
 // TypeArrayError
 // ----------------------------------------------------------------
-export class TypeArrayError extends Error {
+export class TypeArrayError extends TypeBoxError {
   constructor(message: string) {
     super(`${message}`)
   }
 }
-export class TypeArrayLengthError extends Error {
+export class TypeArrayLengthError extends TypeBoxError {
   constructor() {
     super('arrayLength not a number')
   }
diff --git a/examples/collections/map.ts b/examples/collections/map.ts
index 2fa3dffed..796140fe6 100644
--- a/examples/collections/map.ts
+++ b/examples/collections/map.ts
@@ -27,18 +27,18 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { TypeCheck, TypeCompiler, ValueError } from '@sinclair/typebox/compiler'
-import { TSchema, Static } from '@sinclair/typebox'
+import { TSchema, Static, TypeBoxError } from '@sinclair/typebox'
 import { Value } from '@sinclair/typebox/value'
 
 // ----------------------------------------------------------------
 // TypeMapKeyError
 // ----------------------------------------------------------------
-export class TypeMapKeyError extends Error {
+export class TypeMapKeyError extends TypeBoxError {
   constructor(message: string) {
     super(`${message} for key`)
   }
 }
-export class TypeMapValueError extends Error {
+export class TypeMapValueError extends TypeBoxError {
   constructor(key: unknown, message: string) {
     super(`${message} for key ${JSON.stringify(key)}`)
   }
diff --git a/examples/collections/set.ts b/examples/collections/set.ts
index 4e8d31213..8cf312a3e 100644
--- a/examples/collections/set.ts
+++ b/examples/collections/set.ts
@@ -27,13 +27,13 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { TypeCheck, TypeCompiler, ValueError } from '@sinclair/typebox/compiler'
-import { TSchema, Static } from '@sinclair/typebox'
+import { TSchema, Static, TypeBoxError } from '@sinclair/typebox'
 import { Value } from '@sinclair/typebox/value'
 
 // ----------------------------------------------------------------
 // Errors
 // ----------------------------------------------------------------
-export class TypeSetError extends Error {
+export class TypeSetError extends TypeBoxError {
   constructor(message: string) {
     super(`${message}`)
   }
diff --git a/examples/formats/date-time.ts b/examples/formats/date-time.ts
new file mode 100644
index 000000000..ed8ac29ac
--- /dev/null
+++ b/examples/formats/date-time.ts
@@ -0,0 +1,39 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/format
+
+The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { IsDate } from './date'
+import { IsTime } from './time'
+
+const DATE_TIME_SEPARATOR = /t|\s/i
+
+/**
+ * `[ajv-formats]` ISO8601 DateTime
+ * @example `2020-12-12T20:20:40+00:00`
+ */
+export function IsDateTime(value: string, strictTimeZone?: boolean): boolean {
+  const dateTime: string[] = value.split(DATE_TIME_SEPARATOR)
+  return dateTime.length === 2 && IsDate(dateTime[0]) && IsTime(dateTime[1], strictTimeZone)
+}
diff --git a/examples/formats/date.ts b/examples/formats/date.ts
new file mode 100644
index 000000000..fc006341b
--- /dev/null
+++ b/examples/formats/date.ts
@@ -0,0 +1,44 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/format
+
+The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/
+
+function IsLeapYear(year: number): boolean {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)
+}
+/**
+ * `[ajv-formats]` ISO8601 Date component
+ * @example `2020-12-12`
+ */
+export function IsDate(value: string): boolean {
+  const matches: string[] | null = DATE.exec(value)
+  if (!matches) return false
+  const year: number = +matches[1]
+  const month: number = +matches[2]
+  const day: number = +matches[3]
+  return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && IsLeapYear(year) ? 29 : DAYS[month])
+}
diff --git a/examples/formats/email.ts b/examples/formats/email.ts
new file mode 100644
index 000000000..430b7e470
--- /dev/null
+++ b/examples/formats/email.ts
@@ -0,0 +1,35 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/format
+
+The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+const Email = /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i
+
+/**
+ * `[ajv-formats]` Internet Email Address [RFC 5321, section 4.1.2.](http://tools.ietf.org/html/rfc5321#section-4.1.2)
+ * @example `user@domain.com`
+ */
+export function IsEmail(value: string): boolean {
+  return Email.test(value)
+}
diff --git a/examples/formats/index.ts b/examples/formats/index.ts
index 4251323c5..0b20821fe 100644
--- a/examples/formats/index.ts
+++ b/examples/formats/index.ts
@@ -1 +1,36 @@
-export * from './standard'
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/format
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './date-time'
+export * from './date'
+export * from './email'
+export * from './ipv4'
+export * from './ipv6'
+export * from './time'
+export * from './url'
+export * from './uuid'
diff --git a/examples/formats/ipv4.ts b/examples/formats/ipv4.ts
new file mode 100644
index 000000000..1cf506988
--- /dev/null
+++ b/examples/formats/ipv4.ts
@@ -0,0 +1,35 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/format
+
+The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+const IPv4 = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/
+
+/**
+ * `[ajv-formats]` IPv4 address according to dotted-quad ABNF syntax as defined in [RFC 2673, section 3.2](http://tools.ietf.org/html/rfc2673#section-3.2)
+ * @example `192.168.0.1`
+ */
+export function IsIPv4(value: string): boolean {
+  return IPv4.test(value)
+}
diff --git a/examples/formats/ipv6.ts b/examples/formats/ipv6.ts
new file mode 100644
index 000000000..819be3ff2
--- /dev/null
+++ b/examples/formats/ipv6.ts
@@ -0,0 +1,36 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/format
+
+The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+const IPv6 =
+  /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i
+
+/**
+ * `[ajv-formats]` IPv6 address as defined in [RFC 2373, section 2.2](http://tools.ietf.org/html/rfc2373#section-2.2).
+ * @example `2001:0db8:85a3:0000:0000:8a2e:0370:7334`
+ */
+export function IsIPv6(value: string): boolean {
+  return IPv6.test(value)
+}
diff --git a/examples/formats/readme.md b/examples/formats/readme.md
deleted file mode 100644
index 02d7b0c28..000000000
--- a/examples/formats/readme.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# Formats
-
-This example provides TypeCompiler supported versions of the `ajv-formats` package.
-
-## Standard
-
-The `standard.ts` file provided with this example implements several standard string formats. 
-
-| Format      | Description |
-| ---         | --- |
-| `email`     | Internet email address, see [RFC 5321, section 4.1.2.](http://tools.ietf.org/html/rfc5321#section-4.1.2) |
-| `date-time` | ISO8601 DateTime. example, `2018-11-13T20:20:39+00:00` |
-| `date`      | ISO8601 Date component, for example, `2018-11-13`                                  |
-| `time`      | ISO8601 Time component, for example, `20:20:39+00:00`                              |
-| `uuid`      | A Universally Unique Identifier as defined by [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122). |
-| `url`       | A uniform resource locator as defined in [RFC 1738](https://www.rfc-editor.org/rfc/rfc1738)
-| `ipv4`      | IPv4 address, according to dotted-quad ABNF syntax as defined in [RFC 2673, section 3.2](http://tools.ietf.org/html/rfc2673#section-3.2). |
-| `ipv6`      | IPv6 address, as defined in [RFC 2373, section 2.2](http://tools.ietf.org/html/rfc2373#section-2.2). |
-
diff --git a/examples/formats/standard.ts b/examples/formats/standard.ts
deleted file mode 100644
index 7a0d9b06e..000000000
--- a/examples/formats/standard.ts
+++ /dev/null
@@ -1,74 +0,0 @@
-import { FormatRegistry } from '@sinclair/typebox'
-
-// -------------------------------------------------------------------------------------------
-// Format Registration
-// -------------------------------------------------------------------------------------------
-FormatRegistry.Set('date-time', (value) => IsDateTime(value, true))
-FormatRegistry.Set('date', (value) => IsDate(value))
-FormatRegistry.Set('time', (value) => IsTime(value))
-FormatRegistry.Set('email', (value) => IsEmail(value))
-FormatRegistry.Set('uuid', (value) => IsUuid(value))
-FormatRegistry.Set('url', (value) => IsUrl(value))
-FormatRegistry.Set('ipv6', (value) => IsIPv6(value))
-FormatRegistry.Set('ipv4', (value) => IsIPv4(value))
-
-// -------------------------------------------------------------------------------------------
-// https://github.com/ajv-validator/ajv-formats/blob/master/src/formats.ts
-// -------------------------------------------------------------------------------------------
-
-const UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i
-const DATE_TIME_SEPARATOR = /t|\s/i
-const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i
-const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/
-const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-const IPV4 = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/
-const IPV6 = /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i
-const URL = /^(?:https?|wss?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu
-const EMAIL = /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i
-function IsLeapYear(year: number): boolean {
-  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)
-}
-function IsDate(str: string): boolean {
-  const matches: string[] | null = DATE.exec(str)
-  if (!matches) return false
-  const year: number = +matches[1]
-  const month: number = +matches[2]
-  const day: number = +matches[3]
-  return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && IsLeapYear(year) ? 29 : DAYS[month])
-}
-function IsTime(str: string, strictTimeZone?: boolean): boolean {
-  const matches: string[] | null = TIME.exec(str)
-  if (!matches) return false
-  const hr: number = +matches[1]
-  const min: number = +matches[2]
-  const sec: number = +matches[3]
-  const tz: string | undefined = matches[4]
-  const tzSign: number = matches[5] === '-' ? -1 : 1
-  const tzH: number = +(matches[6] || 0)
-  const tzM: number = +(matches[7] || 0)
-  if (tzH > 23 || tzM > 59 || (strictTimeZone && !tz)) return false
-  if (hr <= 23 && min <= 59 && sec < 60) return true
-  const utcMin = min - tzM * tzSign
-  const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0)
-  return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61
-}
-function IsDateTime(value: string, strictTimeZone?: boolean): boolean {
-  const dateTime: string[] = value.split(DATE_TIME_SEPARATOR)
-  return dateTime.length === 2 && IsDate(dateTime[0]) && IsTime(dateTime[1], strictTimeZone)
-}
-function IsEmail(value: string) {
-  return EMAIL.test(value)
-}
-function IsUuid(value: string) {
-  return UUID.test(value)
-}
-function IsUrl(value: string) {
-  return URL.test(value)
-}
-function IsIPv6(value: string) {
-  return IPV6.test(value)
-}
-function IsIPv4(value: string) {
-  return IPV4.test(value)
-}
-
diff --git a/examples/formats/time.ts b/examples/formats/time.ts
new file mode 100644
index 000000000..9002f6908
--- /dev/null
+++ b/examples/formats/time.ts
@@ -0,0 +1,48 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/format
+
+The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i
+
+/**
+ * `[ajv-formats]` ISO8601 Time component
+ * @example `20:20:39+00:00`
+ */
+export function IsTime(value: string, strictTimeZone?: boolean): boolean {
+  const matches: string[] | null = TIME.exec(value)
+  if (!matches) return false
+  const hr: number = +matches[1]
+  const min: number = +matches[2]
+  const sec: number = +matches[3]
+  const tz: string | undefined = matches[4]
+  const tzSign: number = matches[5] === '-' ? -1 : 1
+  const tzH: number = +(matches[6] || 0)
+  const tzM: number = +(matches[7] || 0)
+  if (tzH > 23 || tzM > 59 || (strictTimeZone && !tz)) return false
+  if (hr <= 23 && min <= 59 && sec < 60) return true
+  const utcMin = min - tzM * tzSign
+  const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0)
+  return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61
+}
diff --git a/examples/formats/url.ts b/examples/formats/url.ts
new file mode 100644
index 000000000..c01091eda
--- /dev/null
+++ b/examples/formats/url.ts
@@ -0,0 +1,36 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/format
+
+The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+const Url =
+  /^(?:https?|wss?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu
+
+/**
+ * `[ajv-formats:deprecated]` A uniform resource locator as defined in [RFC 1738](https://www.rfc-editor.org/rfc/rfc1738)
+ * @example `http://domain.com`
+ */
+export function IsUrl(value: string) {
+  return Url.test(value)
+}
diff --git a/examples/transform/index.ts b/examples/formats/uuid.ts
similarity index 76%
rename from examples/transform/index.ts
rename to examples/formats/uuid.ts
index d0bddc5f1..6213fba69 100644
--- a/examples/transform/index.ts
+++ b/examples/formats/uuid.ts
@@ -1,11 +1,9 @@
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox/transform
+@sinclair/typebox/format
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
@@ -26,4 +24,12 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export * from './transform'
\ No newline at end of file
+const Uuid = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i
+
+/**
+ * `[ajv-formats]` A Universally Unique Identifier as defined by [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122).
+ * @example `9aa8a673-8590-4db2-9830-01755844f7c1`
+ */
+export function IsUuid(value: string): boolean {
+  return Uuid.test(value)
+}
diff --git a/examples/transform/readme.md b/examples/transform/readme.md
deleted file mode 100644
index bb02bc888..000000000
--- a/examples/transform/readme.md
+++ /dev/null
@@ -1,83 +0,0 @@
-# Transform Types
-
-Transform Types are an experimental codec system that supports deferred encode and decode of typed data structures received over IO interfaces. This system is undergoing consideration for inclusion in the TypeBox library.
-
-### Design
-
-The following is the high level design for Transform types. It consists of three functions, `Transform`, `Decode` and `Encode`. The following is the general usage.
-
-```typescript
-import { Transform, Encode, Decode } from './transform'
-
-const Timestamp = Transform(Type.Number(), {       // The Transform function wraps a TypeBox type with two codec
-  decode: (value) => new Date(value),              // functions which implement logic to decode a received value
-  encode: (value) => value.getTime(),              // (i.e. number) into a application type (Date). The encode
-})                                                 // function handles the reverse mapping.
-
-type N = Static<typeof N>                          // type N = { timestamp: number }
-                                                   //
-const N = Type.Object({                            // Transform types are to be used like any other type and will
-  timestamp: Timestamp                             // infer as the original TypeBox type. For example, the type `N` 
-})                                                 // above will infer as { timestamp: number } (as derived from 
-                                                   // the TB type)
-
-
-
-const D = Decode(N, { timestamp: 123 })            // const D = { timestamp: Date(123) }
-                                                   //
-                                                   // The Decode function accepts any type plus a value. The Decode 
-                                                   // function return type will be that of the transforms decode() 
-                                                   // return type (which is Date), with the second argument statically
-                                                   // typed as N. This function acts as a kind of parse() that returns 
-                                                   // the decoded type or throws on validation error.
-                                               
-
-const E = Encode(N, { timestamp: new Date(123) })  // const E = { timestamp: 123 }
-                                                   //
-                                                   // The encode function performs the inverse, accepting the
-                                                   // decoded type { timestamp: Date } and re-encoding to the
-                                                   // target type { timestamp: number }. This function will
-                                                   // also throw on validation error.
-```
-### Integration
-
-A practical use case for Transform types is the automatic encode and decode of values received over the network. The following is an example implementation using the Fastify web framework with the TypeBox Type Provider (used for auto type inference). Note that this usage wouldn't be exclusive to Fastify. The implementation below uses explicit Decode and Encode within a route handler.
-
-```typescript
-import { Type, TypeBoxTypeProvider } from '@fastify/type-provider-typebox'
-import Fastify from 'fastify'
-
-const Data = Type.Object({                       
-  timestamp: Transform(Type.Number(), {       
-    decode: (value) => new Date(value),         
-    encode: (value) => value.getTime(),     
-  })                           
-})
-
-Fastify().withTypeProvider<TypeBoxTypeProvider>().post('/', {
-  schema: {
-    body: Data
-    response: { 200: Data }
-  }
-}, (req, res) => {
-  const decoded = Decode(Data, req.body)           // decode { timestamp: number }
-                                                   //     as { timestamp: Date }
-
-  // ... some operations on decoded value
-  //
-  // i.e. decoded.timestamp.getTime()
-
-  const encoded = Encode(Data, decoded)            // encode { timetamp: Date }
-                                                   //     as { timestamp: number }
-  
-  res.status(200).send(encoded)                    // send!
-})
-```
-
-### Current Status
-
-From the example above, the current design of Transform types would require explicit Encode and Decode within a route handler (or other function in receipt of data); and it would be very challenging for general purpose frameworks to integrate this functionality in a more concise fashion (currently). 
-
-Possible options to make this more cohesive may be to provide route wrapping functions to handle codec execution and type inference.  More integrated solutions would involve framework maintainers offering codec supportive type definitions to act as hooks for auto static inference (on both decode and encode phases). The latter option is the preference but would require a fair amount of engineering in downstream frameworks.
-
-Given the many unknowns and general complexity surrounding this feature, TypeBox offers the Transform implementation to the community (as a single `transform.ts` module) for experimentation and general feedback. TypeBox welcomes third party packages, example user integrations, code enhancements or general insight into end user usage patterns.
\ No newline at end of file
diff --git a/examples/transform/transform.ts b/examples/transform/transform.ts
deleted file mode 100644
index 32b9a15c2..000000000
--- a/examples/transform/transform.ts
+++ /dev/null
@@ -1,350 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/transform
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import * as Types from '@sinclair/typebox'
-import * as ValueGuard from '@sinclair/typebox/value/guard'
-import * as ValueCheck from '@sinclair/typebox/value/check'
-
-// --------------------------------------------------------------------------
-// Symbols
-// --------------------------------------------------------------------------
-export const TransformSymbol = Symbol.for('TypeBox.Transform')
-
-// ----------------------------------------------------------------------------------------------
-// Errors
-// ----------------------------------------------------------------------------------------------
-export class TransformDecodeError extends Error {
-  constructor(public readonly schema: Types.TSchema, public readonly value: unknown) {
-    super('ValueTransform: The value passed to decode was invalid')
-  }
-}
-export class TransformEncodeError extends Error {
-  constructor(public readonly schema: Types.TSchema, public readonly value: unknown) {
-    super('ValueTransform: The encode function returned an invalid value')
-  }
-}
-export class ValueTransformUnknownTypeError extends Error {
-  constructor(public readonly schema: Types.TSchema) {
-    super('Unknown type')
-  }
-}
-export class ValueTransformDereferenceError extends Error {
-  constructor(public readonly schema: Types.TRef | Types.TThis) {
-    super(`Unable to dereference type with $id '${schema.$ref}'`)
-  }
-}
-export class ValueTransformFallthroughError extends Error {
-  constructor(public readonly schema: Types.TSchema, public readonly value: unknown, public mode: ValueTransformMode) {
-    super('Unexpected transform error')
-  }
-}
-export class ValueTransformCodecError extends Error {
-  constructor(public readonly schema: Types.TSchema, public readonly value: unknown, public mode: ValueTransformMode, error: any) {
-    super(`${error instanceof Error ? error.message : 'Unknown'}`)
-  }
-}
-export type ValueTransformMode = 'encode' | 'decode'
-
-// ----------------------------------------------------------------------------------------------
-// Apply
-// ----------------------------------------------------------------------------------------------
-function Apply(schema: Types.TSchema, value: any, mode: ValueTransformMode) {
-  try {
-    if (!HasTransform(schema)) return value
-    const transform = schema[TransformSymbol] as unknown as TransformCodec
-    if (mode === 'decode') return transform.decode(value)
-    if (mode === 'encode') return transform.encode(value)
-  } catch (error) {
-    throw new ValueTransformCodecError(schema, value, mode, error)
-  }
-}
-// --------------------------------------------------------------------------
-// Guards
-// --------------------------------------------------------------------------
-function HasTransform(schema: Types.TSchema): schema is Types.TSchema & { [TransformSymbol]: TransformCodec } {
-  return ValueGuard.HasPropertyKey(schema, TransformSymbol)
-}
-// ----------------------------------------------------------------------------------------------
-// Transform
-// ----------------------------------------------------------------------------------------------
-function TAny(schema: Types.TAny, references: Types.TSchema[], value: any, mode: ValueTransformMode): any {
-  return Apply(schema, value, mode)
-}
-function TArray(schema: Types.TArray, references: Types.TSchema[], value: any, mode: ValueTransformMode): any {
-  const transformed = Apply(schema, value, mode)
-  return transformed.map((value: any) => Visit(schema.items, references, value, mode))
-}
-function TBigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TBoolean(schema: Types.TBoolean, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TConstructor(schema: Types.TConstructor, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TDate(schema: Types.TDate, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TFunction(schema: Types.TFunction, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TInteger(schema: Types.TInteger, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TLiteral(schema: Types.TLiteral, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TNever(schema: Types.TNever, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TNull(schema: Types.TNull, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TNumber(schema: Types.TNumber, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TObject(schema: Types.TObject, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  const transformed = Apply(schema, value, mode)
-  const properties = Object.keys(transformed).reduce((acc, key) => {
-    return key in schema.properties 
-      ? { ...acc, [key]: Visit(schema.properties[key], references, transformed[key], mode) }
-      : { ...acc, [key]: transformed[key] }
-  }, {})
-  return { ...properties }
-}
-function TPromise(schema: Types.TSchema, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  const transformed = Apply(schema, value, mode)
-  const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0]
-  const property = schema.patternProperties[propertyKey]
-  const result = {} as Record<string, unknown>
-  for (const [propKey, propValue] of Object.entries(transformed)) {
-    result[propKey] = Visit(property, references, propValue, mode)
-  }
-  return result
-}
-function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-  if (index === -1) throw new ValueTransformDereferenceError(schema)
-  const target = references[index]
-  const resolved = Visit(target, references, value, mode)
-  return Apply(schema, resolved, mode)
-}
-function TString(schema: Types.TString, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TSymbol(schema: Types.TSymbol, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TTemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TThis(schema: Types.TThis, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-  if (index === -1) throw new ValueTransformDereferenceError(schema)
-  const target = references[index]
-  const resolved = Visit(target, references, value, mode)
-  return Apply(schema, resolved, mode)
-}
-function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  const transformed = Apply(schema, value, mode)
-  // prettier-ignore
-  return Apply(schema, transformed.map((value: any, index: any) => {
-    return index < schema.items!.length ? Visit(schema.items![index], references, value, mode) : value
-  }), mode)
-}
-function TUndefined(schema: Types.TUndefined, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  const transformed = Apply(schema, value, mode)
-  for (const subschema of schema.anyOf) {
-    const inner = Visit(subschema, references, transformed, mode)
-    if (ValueCheck.Check(subschema, references, inner)) {
-      return Apply(schema, inner, mode)
-    }
-  }
-  return transformed
-}
-function TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TUnknown(schema: Types.TUnknown, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TVoid(schema: Types.TVoid, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function TKind(schema: Types.TSchema, references: Types.TSchema[], value: any, mode: ValueTransformMode) {
-  return Apply(schema, value, mode)
-}
-function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any, mode: ValueTransformMode): any {
-  const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references
-  const schema_ = schema as any
-  switch (schema[Types.Kind]) {
-    case 'Any':
-      return TAny(schema_, references_, value, mode)
-    case 'Array':
-      return TArray(schema_, references_, value, mode)
-    case 'BigInt':
-      return TBigInt(schema_, references_, value, mode)
-    case 'Boolean':
-      return TBoolean(schema_, references_, value, mode)
-    case 'Constructor':
-      return TConstructor(schema_, references_, value, mode)
-    case 'Date':
-      return TDate(schema_, references_, value, mode)
-    case 'Function':
-      return TFunction(schema_, references_, value, mode)
-    case 'Integer':
-      return TInteger(schema_, references_, value, mode)
-    case 'Intersect':
-      return TIntersect(schema_, references_, value, mode)
-    case 'Literal':
-      return TLiteral(schema_, references_, value, mode)
-    case 'Never':
-      return TNever(schema_, references_, value, mode)
-    case 'Null':
-      return TNull(schema_, references_, value, mode)
-    case 'Number':
-      return TNumber(schema_, references_, value, mode)
-    case 'Object':
-      return TObject(schema_, references_, value, mode)
-    case 'Promise':
-      return TPromise(schema_, references_, value, mode)
-    case 'Record':
-      return TRecord(schema_, references_, value, mode)
-    case 'Ref':
-      return TRef(schema_, references_, value, mode)
-    case 'String':
-      return TString(schema_, references_, value, mode)
-    case 'Symbol':
-      return TSymbol(schema_, references_, value, mode)
-    case 'TemplateLiteral':
-      return TTemplateLiteral(schema_, references_, value, mode)
-    case 'This':
-      return TThis(schema_, references_, value, mode)
-    case 'Tuple':
-      return TTuple(schema_, references_, value, mode)
-    case 'Undefined':
-      return TUndefined(schema_, references_, value, mode)
-    case 'Union':
-      return TUnion(schema_, references_, value, mode)
-    case 'Uint8Array':
-      return TUint8Array(schema_, references_, value, mode)
-    case 'Unknown':
-      return TUnknown(schema_, references_, value, mode)
-    case 'Void':
-      return TVoid(schema_, references_, value, mode)
-    default:
-      if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueTransformUnknownTypeError(schema_)
-      return TKind(schema_, references_, value, mode)
-  }
-}
-// --------------------------------------------------------------------------
-// Transform Unwrap
-// --------------------------------------------------------------------------
-// prettier-ignore
-export type TransformUnwrapProperties<T extends Types.TProperties> = {
-  [K in keyof T]: TransformUnwrap<T[K]>
-}
-// prettier-ignore
-export type TransformUnwrapRest<T extends Types.TSchema[]> = T extends [infer L, ...infer R]
-  ? [TransformUnwrap<Types.AssertType<L>>, ...TransformUnwrapRest<Types.AssertRest<R>>]
-  : []
-// prettier-ignore
-export type TransformUnwrap<T extends Types.TSchema> =
-  T extends TTransform<infer _, infer R> ? Types.TUnsafe<R> : 
-  T extends Types.TConstructor<infer P, infer R> ? Types.TConstructor<Types.AssertRest<TransformUnwrapRest<P>>, TransformUnwrap<R>> :
-  T extends Types.TFunction<infer P, infer R> ? Types.TFunction<Types.AssertRest<TransformUnwrapRest<P>>, TransformUnwrap<R>> :
-  T extends Types.TIntersect<infer S> ? Types.TIntersect<Types.AssertRest<TransformUnwrapRest<S>>> :
-  T extends Types.TUnion<infer S> ? Types.TUnion<Types.AssertRest<TransformUnwrapRest<S>>> :
-  T extends Types.TNot<infer S> ? Types.TNot<TransformUnwrap<S>> :
-  T extends Types.TTuple<infer S> ? Types.TTuple<Types.AssertRest<TransformUnwrapRest<S>>> :
-  T extends Types.TAsyncIterator<infer S> ? Types.TAsyncIterator<TransformUnwrap<S>> :
-  T extends Types.TIterator<infer S> ? Types.TIterator<TransformUnwrap<S>> :
-  T extends Types.TObject<infer S> ? Types.TObject<Types.Evaluate<TransformUnwrapProperties<S>>> :
-  T extends Types.TRecord<infer K, infer S> ? Types.TRecord<K, TransformUnwrap<S>> :
-  T extends Types.TArray<infer S> ? Types.TArray<TransformUnwrap<S>> :
-  T extends Types.TPromise<infer S> ? Types.TPromise<TransformUnwrap<S>> :
-  T
-// --------------------------------------------------------------------------
-// Transform Types
-// --------------------------------------------------------------------------
-export type TransformFunction<T = any, U = any> = (value: T) => U
-
-export interface TransformCodec<Input extends Types.TSchema = Types.TSchema, Output extends unknown = unknown> {
-  decode: TransformFunction<Types.Static<Input>, Output>
-  encode: TransformFunction<Output, Types.Static<Input>>
-}
-export interface TTransform<Input extends Types.TSchema = Types.TSchema, Output extends unknown = unknown> extends Types.TSchema {
-  static: Types.Static<Input>
-  [TransformSymbol]: TransformCodec<Input, Output>
-  [key: string]: any
-}
-// --------------------------------------------------------------------------
-// Transform Functions
-// --------------------------------------------------------------------------
-/** Creates a transform type by applying transform codec */
-export function Transform<Input extends Types.TSchema, Output extends unknown>(schema: Input, codec: TransformCodec<Input, Output>): TTransform<Input, Output> {
-  if (!HasTransform(schema)) return { ...schema, [TransformSymbol]: codec } as TTransform<Input, Output>
-  const mapped_encode = (value: unknown) => schema[TransformSymbol].encode(codec.encode(value as any))
-  const mapped_decode = (value: unknown) => codec.decode(schema[TransformSymbol].decode(value))
-  const mapped_codec = { encode: mapped_encode, decode: mapped_decode }
-  return { ...schema, [TransformSymbol]: mapped_codec } as TTransform<Input, Output>
-}
-/** Decodes a value using the given type. Will apply an transform codecs found for any sub type */
-export function Decode<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: Types.Static<T>): Types.Static<TransformUnwrap<T>>
-/** Decodes a value using the given type. Will apply an transform codecs found for any sub type */
-export function Decode<T extends Types.TSchema>(schema: T, value: Types.Static<T>): Types.Static<TransformUnwrap<T>>
-/** Decodes a value using the given type. Will apply an transform codecs found for any sub type */
-export function Decode(...args: any[]) {
-  const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
-  const check = ValueCheck.Check(schema, references, value)
-  if (!check) throw new TransformDecodeError(schema, value)
-  const decoded = Visit(schema, references, value, 'decode')
-  return decoded
-}
-/** Encodes a value using the given type. Will apply an transforms found for any sub type */
-export function Encode<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: Types.Static<TransformUnwrap<T>>): Types.Static<T>
-/** Encodes a value using the given type. Will apply an transforms found for any sub type */
-export function Encode<T extends Types.TSchema>(schema: T, value: Types.Static<TransformUnwrap<T>>): Types.Static<T>
-/** Encodes a value using the given type. Will apply an transforms found for any sub type */
-export function Encode(...args: any[]) {
-  const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
-  const encoded = Visit(schema, references, value, 'encode')
-  const check = ValueCheck.Check(schema, references, encoded)
-  if (!check) throw new TransformEncodeError(schema, value)
-  return encoded
-}
diff --git a/examples/typedef/typedef.ts b/examples/typedef/typedef.ts
index 9c959318d..5eb12a372 100644
--- a/examples/typedef/typedef.ts
+++ b/examples/typedef/typedef.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { TypeSystemErrorFunction, DefaultErrorFunction } from '@sinclair/typebox/system'
 import * as Types from '@sinclair/typebox'
 
 // --------------------------------------------------------------------------
@@ -239,9 +240,9 @@ export namespace TimestampFormat {
 // --------------------------------------------------------------------------
 // ValueCheck
 // --------------------------------------------------------------------------
-export class ValueCheckError extends Error {
+export class ValueCheckError extends Types.TypeBoxError {
   constructor(public readonly schema: Types.TSchema) {
-    super('ValueCheck: Unknown type')
+    super('Unknown type')
   }
 }
 export namespace ValueCheck {
@@ -484,6 +485,27 @@ Types.TypeRegistry.Set<TString>('TypeDef:String', (schema, value) => ValueCheck.
 Types.TypeRegistry.Set<TStruct>('TypeDef:Struct', (schema, value) => ValueCheck.Check(schema, value))
 Types.TypeRegistry.Set<TTimestamp>('TypeDef:Timestamp', (schema, value) => ValueCheck.Check(schema, value))
 // --------------------------------------------------------------------------
+// TypeSystemErrorFunction
+// --------------------------------------------------------------------------
+TypeSystemErrorFunction.Set((schema, type) => {
+  switch(schema[Types.Kind]) {
+    case 'TypeDef:Array': return 'Expected Array'
+    case 'TypeDef:Boolean': return 'Expected Boolean'
+    case 'TypeDef:Union': return 'Expected Union'
+    case 'TypeDef:Int8': return 'Expected Int8'
+    case 'TypeDef:Int16': return 'Expected Int16'
+    case 'TypeDef:Int32': return 'Expected Int32'
+    case 'TypeDef:Uint8': return 'Expected Uint8'
+    case 'TypeDef:Uint16': return 'Expected Uint16'
+    case 'TypeDef:Uint32': return 'Expected Uint32'
+    case 'TypeDef:Record': return 'Expected Record'
+    case 'TypeDef:String': return 'Expected String'
+    case 'TypeDef:Struct': return 'Expected Struct'
+    case 'TypeDef:Timestamp': return 'Expected Timestamp'
+  }
+  return DefaultErrorFunction(schema, type)
+})
+// --------------------------------------------------------------------------
 // TypeDefBuilder
 // --------------------------------------------------------------------------
 export class TypeDefBuilder {
diff --git a/hammer.mjs b/hammer.mjs
index 3bf3406f6..c99da14f9 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -22,10 +22,16 @@ export async function start() {
 // -------------------------------------------------------------------------------
 // Benchmark
 // -------------------------------------------------------------------------------
-export async function benchmark() {
+export async function benchmark_compression() {
   await compression()
+}
+export async function benchmark_measurement() {
   await measurement()
 }
+export async function benchmark() {
+  await benchmark_compression()
+  await benchmark_measurement()
+}
 // -------------------------------------------------------------------------------
 // Test
 // -------------------------------------------------------------------------------
diff --git a/package-lock.json b/package-lock.json
index 45c146d60..efe7b622e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,30 +1,44 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.30.4",
+  "version": "0.31.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.30.4",
+      "version": "0.31.0",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
-        "@types/chai": "^4.3.3",
         "@types/mocha": "^9.1.1",
         "@types/node": "^18.11.9",
         "ajv": "^8.12.0",
         "ajv-formats": "^2.1.1",
-        "chai": "^4.3.6",
         "mocha": "^9.2.2",
         "prettier": "^2.7.1",
         "typescript": "^5.1.6"
       }
     },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.15.18.tgz",
+      "integrity": "sha512-5GT+kcs2WVGjVs7+boataCkO5Fg0y4kCjzkB5bAip7H4jfnOS3dA6KPiww9W1OEKTKeAcUVhdZGvgI65OXmUnw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/@esbuild/linux-loong64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.14.53.tgz",
-      "integrity": "sha512-W2dAL6Bnyn4xa/QRSU3ilIK4EzD5wgYXKXJiS1HDF5vU3675qc2bvFyLwbUcdmssDveyndy7FbitrCoiV/eMLg==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.15.18.tgz",
+      "integrity": "sha512-L4jVKS82XVhw2nvzLg/19ClLWg0y27ulRwuP7lcyL6AbUWB5aPglXY3M21mauDQMDfRLs8cQmeT03r/+X3cZYQ==",
       "cpu": [
         "loong64"
       ],
@@ -38,24 +52,17 @@
       }
     },
     "node_modules/@sinclair/hammer": {
-      "version": "0.17.1",
-      "resolved": "https://registry.npmjs.org/@sinclair/hammer/-/hammer-0.17.1.tgz",
-      "integrity": "sha512-/M7KXwCaXdDmBJXQHpn1NWSTUg7Rmx6vzseVOax7IXhsBYj3vEGU5yt/Xh3XdRLVOEcyl4vGWgJ0pL9cmyrTJA==",
+      "version": "0.17.2",
+      "resolved": "https://registry.npmjs.org/@sinclair/hammer/-/hammer-0.17.2.tgz",
+      "integrity": "sha512-Nnzq4JuC3VB0JNEfxU4U9W65yCe4+/ft0+FGf6/HBn7BoxW3aigusstFdrzVdhjJ6NVABCwUBMgtYbD9X7Z94g==",
       "dev": true,
       "dependencies": {
-        "@sinclair/hammer": "^0.17.0",
-        "esbuild": "^0.14.53"
+        "esbuild": "^0.15.7"
       },
       "bin": {
         "hammer": "hammer"
       }
     },
-    "node_modules/@types/chai": {
-      "version": "4.3.3",
-      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.3.3.tgz",
-      "integrity": "sha512-hC7OMnszpxhZPduX+m+nrx+uFoLkWOMiR4oa/AZF3MuSETYTZmFfJAHqZEM8MVlvfG7BEUcgvtwoCTxBp6hm3g==",
-      "dev": true
-    },
     "node_modules/@types/mocha": {
       "version": "9.1.1",
       "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-9.1.1.tgz",
@@ -63,9 +70,9 @@
       "dev": true
     },
     "node_modules/@types/node": {
-      "version": "18.11.9",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.11.9.tgz",
-      "integrity": "sha512-CRpX21/kGdzjOpFsZSkcrXMGIBWMGNIHXXBVFSH+ggkftxg+XYP20TESbh+zFvFj3EQOl5byk0HTRn1IL6hbqg==",
+      "version": "18.17.2",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.17.2.tgz",
+      "integrity": "sha512-wBo3KqP/PBqje5TI9UTiuL3yWfP6sdPtjtygSOqcYZWT232dfDeDOnkDps5wqZBP9NgGgYrNejinl0faAuE+HQ==",
       "dev": true
     },
     "node_modules/@ungap/promise-all-settled": {
@@ -141,9 +148,9 @@
       }
     },
     "node_modules/anymatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz",
-      "integrity": "sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==",
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
       "dev": true,
       "dependencies": {
         "normalize-path": "^3.0.0",
@@ -159,15 +166,6 @@
       "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
       "dev": true
     },
-    "node_modules/assertion-error": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz",
-      "integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==",
-      "dev": true,
-      "engines": {
-        "node": "*"
-      }
-    },
     "node_modules/balanced-match": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
@@ -223,24 +221,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/chai": {
-      "version": "4.3.6",
-      "resolved": "https://registry.npmjs.org/chai/-/chai-4.3.6.tgz",
-      "integrity": "sha512-bbcp3YfHCUzMOvKqsztczerVgBKSsEijCySNlHHbX3VG1nskvqjz5Rfso1gGwD6w6oOV3eI60pKuMOV5MV7p3Q==",
-      "dev": true,
-      "dependencies": {
-        "assertion-error": "^1.1.0",
-        "check-error": "^1.0.2",
-        "deep-eql": "^3.0.1",
-        "get-func-name": "^2.0.0",
-        "loupe": "^2.3.1",
-        "pathval": "^1.1.1",
-        "type-detect": "^4.0.5"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/chalk": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
@@ -269,15 +249,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/check-error": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.2.tgz",
-      "integrity": "sha512-BrgHpW9NURQgzoNyjfq0Wu6VFO6D7IZEmJNdtgNqpzGG8RuNFHt2jQxWlAs4HMe119chBnv+34syEZtc6IhLtA==",
-      "dev": true,
-      "engines": {
-        "node": "*"
-      }
-    },
     "node_modules/chokidar": {
       "version": "3.5.3",
       "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
@@ -375,18 +346,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/deep-eql": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-3.0.1.tgz",
-      "integrity": "sha512-+QeIQyN5ZuO+3Uk5DYh6/1eKO0m0YmJFGNmFHGACpf1ClL1nmlV/p4gNgbl2pJGxgXb4faqo6UE+M5ACEMyVcw==",
-      "dev": true,
-      "dependencies": {
-        "type-detect": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=0.12"
-      }
-    },
     "node_modules/diff": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz",
@@ -403,9 +362,9 @@
       "dev": true
     },
     "node_modules/esbuild": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.14.53.tgz",
-      "integrity": "sha512-ohO33pUBQ64q6mmheX1mZ8mIXj8ivQY/L4oVuAshr+aJI+zLl+amrp3EodrUNDNYVrKJXGPfIHFGhO8slGRjuw==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.15.18.tgz",
+      "integrity": "sha512-x/R72SmW3sSFRm5zrrIjAhCeQSAWoni3CmHEqfQrZIQTM3lVCdehdwuIqaOtfC2slvpdlLa62GYoN8SxT23m6Q==",
       "dev": true,
       "hasInstallScript": true,
       "bin": {
@@ -415,33 +374,34 @@
         "node": ">=12"
       },
       "optionalDependencies": {
-        "@esbuild/linux-loong64": "0.14.53",
-        "esbuild-android-64": "0.14.53",
-        "esbuild-android-arm64": "0.14.53",
-        "esbuild-darwin-64": "0.14.53",
-        "esbuild-darwin-arm64": "0.14.53",
-        "esbuild-freebsd-64": "0.14.53",
-        "esbuild-freebsd-arm64": "0.14.53",
-        "esbuild-linux-32": "0.14.53",
-        "esbuild-linux-64": "0.14.53",
-        "esbuild-linux-arm": "0.14.53",
-        "esbuild-linux-arm64": "0.14.53",
-        "esbuild-linux-mips64le": "0.14.53",
-        "esbuild-linux-ppc64le": "0.14.53",
-        "esbuild-linux-riscv64": "0.14.53",
-        "esbuild-linux-s390x": "0.14.53",
-        "esbuild-netbsd-64": "0.14.53",
-        "esbuild-openbsd-64": "0.14.53",
-        "esbuild-sunos-64": "0.14.53",
-        "esbuild-windows-32": "0.14.53",
-        "esbuild-windows-64": "0.14.53",
-        "esbuild-windows-arm64": "0.14.53"
+        "@esbuild/android-arm": "0.15.18",
+        "@esbuild/linux-loong64": "0.15.18",
+        "esbuild-android-64": "0.15.18",
+        "esbuild-android-arm64": "0.15.18",
+        "esbuild-darwin-64": "0.15.18",
+        "esbuild-darwin-arm64": "0.15.18",
+        "esbuild-freebsd-64": "0.15.18",
+        "esbuild-freebsd-arm64": "0.15.18",
+        "esbuild-linux-32": "0.15.18",
+        "esbuild-linux-64": "0.15.18",
+        "esbuild-linux-arm": "0.15.18",
+        "esbuild-linux-arm64": "0.15.18",
+        "esbuild-linux-mips64le": "0.15.18",
+        "esbuild-linux-ppc64le": "0.15.18",
+        "esbuild-linux-riscv64": "0.15.18",
+        "esbuild-linux-s390x": "0.15.18",
+        "esbuild-netbsd-64": "0.15.18",
+        "esbuild-openbsd-64": "0.15.18",
+        "esbuild-sunos-64": "0.15.18",
+        "esbuild-windows-32": "0.15.18",
+        "esbuild-windows-64": "0.15.18",
+        "esbuild-windows-arm64": "0.15.18"
       }
     },
     "node_modules/esbuild-android-64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-android-64/-/esbuild-android-64-0.14.53.tgz",
-      "integrity": "sha512-fIL93sOTnEU+NrTAVMIKiAw0YH22HWCAgg4N4Z6zov2t0kY9RAJ50zY9ZMCQ+RT6bnOfDt8gCTnt/RaSNA2yRA==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-android-64/-/esbuild-android-64-0.15.18.tgz",
+      "integrity": "sha512-wnpt3OXRhcjfIDSZu9bnzT4/TNTDsOUvip0foZOUBG7QbSt//w3QV4FInVJxNhKc/ErhUxc5z4QjHtMi7/TbgA==",
       "cpu": [
         "x64"
       ],
@@ -455,9 +415,9 @@
       }
     },
     "node_modules/esbuild-android-arm64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-android-arm64/-/esbuild-android-arm64-0.14.53.tgz",
-      "integrity": "sha512-PC7KaF1v0h/nWpvlU1UMN7dzB54cBH8qSsm7S9mkwFA1BXpaEOufCg8hdoEI1jep0KeO/rjZVWrsH8+q28T77A==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-android-arm64/-/esbuild-android-arm64-0.15.18.tgz",
+      "integrity": "sha512-G4xu89B8FCzav9XU8EjsXacCKSG2FT7wW9J6hOc18soEHJdtWu03L3TQDGf0geNxfLTtxENKBzMSq9LlbjS8OQ==",
       "cpu": [
         "arm64"
       ],
@@ -471,9 +431,9 @@
       }
     },
     "node_modules/esbuild-darwin-64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-darwin-64/-/esbuild-darwin-64-0.14.53.tgz",
-      "integrity": "sha512-gE7P5wlnkX4d4PKvLBUgmhZXvL7lzGRLri17/+CmmCzfncIgq8lOBvxGMiQ4xazplhxq+72TEohyFMZLFxuWvg==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-darwin-64/-/esbuild-darwin-64-0.15.18.tgz",
+      "integrity": "sha512-2WAvs95uPnVJPuYKP0Eqx+Dl/jaYseZEUUT1sjg97TJa4oBtbAKnPnl3b5M9l51/nbx7+QAEtuummJZW0sBEmg==",
       "cpu": [
         "x64"
       ],
@@ -487,9 +447,9 @@
       }
     },
     "node_modules/esbuild-darwin-arm64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-darwin-arm64/-/esbuild-darwin-arm64-0.14.53.tgz",
-      "integrity": "sha512-otJwDU3hnI15Q98PX4MJbknSZ/WSR1I45il7gcxcECXzfN4Mrpft5hBDHXNRnCh+5858uPXBXA1Vaz2jVWLaIA==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-darwin-arm64/-/esbuild-darwin-arm64-0.15.18.tgz",
+      "integrity": "sha512-tKPSxcTJ5OmNb1btVikATJ8NftlyNlc8BVNtyT/UAr62JFOhwHlnoPrhYWz09akBLHI9nElFVfWSTSRsrZiDUA==",
       "cpu": [
         "arm64"
       ],
@@ -503,9 +463,9 @@
       }
     },
     "node_modules/esbuild-freebsd-64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-freebsd-64/-/esbuild-freebsd-64-0.14.53.tgz",
-      "integrity": "sha512-WkdJa8iyrGHyKiPF4lk0MiOF87Q2SkE+i+8D4Cazq3/iqmGPJ6u49je300MFi5I2eUsQCkaOWhpCVQMTKGww2w==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-freebsd-64/-/esbuild-freebsd-64-0.15.18.tgz",
+      "integrity": "sha512-TT3uBUxkteAjR1QbsmvSsjpKjOX6UkCstr8nMr+q7zi3NuZ1oIpa8U41Y8I8dJH2fJgdC3Dj3CXO5biLQpfdZA==",
       "cpu": [
         "x64"
       ],
@@ -519,9 +479,9 @@
       }
     },
     "node_modules/esbuild-freebsd-arm64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-freebsd-arm64/-/esbuild-freebsd-arm64-0.14.53.tgz",
-      "integrity": "sha512-9T7WwCuV30NAx0SyQpw8edbKvbKELnnm1FHg7gbSYaatH+c8WJW10g/OdM7JYnv7qkimw2ZTtSA+NokOLd2ydQ==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-freebsd-arm64/-/esbuild-freebsd-arm64-0.15.18.tgz",
+      "integrity": "sha512-R/oVr+X3Tkh+S0+tL41wRMbdWtpWB8hEAMsOXDumSSa6qJR89U0S/PpLXrGF7Wk/JykfpWNokERUpCeHDl47wA==",
       "cpu": [
         "arm64"
       ],
@@ -535,9 +495,9 @@
       }
     },
     "node_modules/esbuild-linux-32": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-32/-/esbuild-linux-32-0.14.53.tgz",
-      "integrity": "sha512-VGanLBg5en2LfGDgLEUxQko2lqsOS7MTEWUi8x91YmsHNyzJVT/WApbFFx3MQGhkf+XdimVhpyo5/G0PBY91zg==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-32/-/esbuild-linux-32-0.15.18.tgz",
+      "integrity": "sha512-lphF3HiCSYtaa9p1DtXndiQEeQDKPl9eN/XNoBf2amEghugNuqXNZA/ZovthNE2aa4EN43WroO0B85xVSjYkbg==",
       "cpu": [
         "ia32"
       ],
@@ -551,9 +511,9 @@
       }
     },
     "node_modules/esbuild-linux-64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-64/-/esbuild-linux-64-0.14.53.tgz",
-      "integrity": "sha512-pP/FA55j/fzAV7N9DF31meAyjOH6Bjuo3aSKPh26+RW85ZEtbJv9nhoxmGTd9FOqjx59Tc1ZbrJabuiXlMwuZQ==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-64/-/esbuild-linux-64-0.15.18.tgz",
+      "integrity": "sha512-hNSeP97IviD7oxLKFuii5sDPJ+QHeiFTFLoLm7NZQligur8poNOWGIgpQ7Qf8Balb69hptMZzyOBIPtY09GZYw==",
       "cpu": [
         "x64"
       ],
@@ -567,9 +527,9 @@
       }
     },
     "node_modules/esbuild-linux-arm": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-arm/-/esbuild-linux-arm-0.14.53.tgz",
-      "integrity": "sha512-/u81NGAVZMopbmzd21Nu/wvnKQK3pT4CrvQ8BTje1STXcQAGnfyKgQlj3m0j2BzYbvQxSy+TMck4TNV2onvoPA==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-arm/-/esbuild-linux-arm-0.15.18.tgz",
+      "integrity": "sha512-UH779gstRblS4aoS2qpMl3wjg7U0j+ygu3GjIeTonCcN79ZvpPee12Qun3vcdxX+37O5LFxz39XeW2I9bybMVA==",
       "cpu": [
         "arm"
       ],
@@ -583,9 +543,9 @@
       }
     },
     "node_modules/esbuild-linux-arm64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-arm64/-/esbuild-linux-arm64-0.14.53.tgz",
-      "integrity": "sha512-GDmWITT+PMsjCA6/lByYk7NyFssW4Q6in32iPkpjZ/ytSyH+xeEx8q7HG3AhWH6heemEYEWpTll/eui3jwlSnw==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-arm64/-/esbuild-linux-arm64-0.15.18.tgz",
+      "integrity": "sha512-54qr8kg/6ilcxd+0V3h9rjT4qmjc0CccMVWrjOEM/pEcUzt8X62HfBSeZfT2ECpM7104mk4yfQXkosY8Quptug==",
       "cpu": [
         "arm64"
       ],
@@ -599,9 +559,9 @@
       }
     },
     "node_modules/esbuild-linux-mips64le": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-mips64le/-/esbuild-linux-mips64le-0.14.53.tgz",
-      "integrity": "sha512-d6/XHIQW714gSSp6tOOX2UscedVobELvQlPMkInhx1NPz4ThZI9uNLQ4qQJHGBGKGfu+rtJsxM4NVHLhnNRdWQ==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-mips64le/-/esbuild-linux-mips64le-0.15.18.tgz",
+      "integrity": "sha512-Mk6Ppwzzz3YbMl/ZZL2P0q1tnYqh/trYZ1VfNP47C31yT0K8t9s7Z077QrDA/guU60tGNp2GOwCQnp+DYv7bxQ==",
       "cpu": [
         "mips64el"
       ],
@@ -615,9 +575,9 @@
       }
     },
     "node_modules/esbuild-linux-ppc64le": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-ppc64le/-/esbuild-linux-ppc64le-0.14.53.tgz",
-      "integrity": "sha512-ndnJmniKPCB52m+r6BtHHLAOXw+xBCWIxNnedbIpuREOcbSU/AlyM/2dA3BmUQhsHdb4w3amD5U2s91TJ3MzzA==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-ppc64le/-/esbuild-linux-ppc64le-0.15.18.tgz",
+      "integrity": "sha512-b0XkN4pL9WUulPTa/VKHx2wLCgvIAbgwABGnKMY19WhKZPT+8BxhZdqz6EgkqCLld7X5qiCY2F/bfpUUlnFZ9w==",
       "cpu": [
         "ppc64"
       ],
@@ -631,9 +591,9 @@
       }
     },
     "node_modules/esbuild-linux-riscv64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-riscv64/-/esbuild-linux-riscv64-0.14.53.tgz",
-      "integrity": "sha512-yG2sVH+QSix6ct4lIzJj329iJF3MhloLE6/vKMQAAd26UVPVkhMFqFopY+9kCgYsdeWvXdPgmyOuKa48Y7+/EQ==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-riscv64/-/esbuild-linux-riscv64-0.15.18.tgz",
+      "integrity": "sha512-ba2COaoF5wL6VLZWn04k+ACZjZ6NYniMSQStodFKH/Pu6RxzQqzsmjR1t9QC89VYJxBeyVPTaHuBMCejl3O/xg==",
       "cpu": [
         "riscv64"
       ],
@@ -647,9 +607,9 @@
       }
     },
     "node_modules/esbuild-linux-s390x": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-s390x/-/esbuild-linux-s390x-0.14.53.tgz",
-      "integrity": "sha512-OCJlgdkB+XPYndHmw6uZT7jcYgzmx9K+28PVdOa/eLjdoYkeAFvH5hTwX4AXGLZLH09tpl4bVsEtvuyUldaNCg==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-s390x/-/esbuild-linux-s390x-0.15.18.tgz",
+      "integrity": "sha512-VbpGuXEl5FCs1wDVp93O8UIzl3ZrglgnSQ+Hu79g7hZu6te6/YHgVJxCM2SqfIila0J3k0csfnf8VD2W7u2kzQ==",
       "cpu": [
         "s390x"
       ],
@@ -663,9 +623,9 @@
       }
     },
     "node_modules/esbuild-netbsd-64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-netbsd-64/-/esbuild-netbsd-64-0.14.53.tgz",
-      "integrity": "sha512-gp2SB+Efc7MhMdWV2+pmIs/Ja/Mi5rjw+wlDmmbIn68VGXBleNgiEZG+eV2SRS0kJEUyHNedDtwRIMzaohWedQ==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-netbsd-64/-/esbuild-netbsd-64-0.15.18.tgz",
+      "integrity": "sha512-98ukeCdvdX7wr1vUYQzKo4kQ0N2p27H7I11maINv73fVEXt2kyh4K4m9f35U1K43Xc2QGXlzAw0K9yoU7JUjOg==",
       "cpu": [
         "x64"
       ],
@@ -679,9 +639,9 @@
       }
     },
     "node_modules/esbuild-openbsd-64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-openbsd-64/-/esbuild-openbsd-64-0.14.53.tgz",
-      "integrity": "sha512-eKQ30ZWe+WTZmteDYg8S+YjHV5s4iTxeSGhJKJajFfQx9TLZJvsJX0/paqwP51GicOUruFpSUAs2NCc0a4ivQQ==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-openbsd-64/-/esbuild-openbsd-64-0.15.18.tgz",
+      "integrity": "sha512-yK5NCcH31Uae076AyQAXeJzt/vxIo9+omZRKj1pauhk3ITuADzuOx5N2fdHrAKPxN+zH3w96uFKlY7yIn490xQ==",
       "cpu": [
         "x64"
       ],
@@ -695,9 +655,9 @@
       }
     },
     "node_modules/esbuild-sunos-64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-sunos-64/-/esbuild-sunos-64-0.14.53.tgz",
-      "integrity": "sha512-OWLpS7a2FrIRukQqcgQqR1XKn0jSJoOdT+RlhAxUoEQM/IpytS3FXzCJM6xjUYtpO5GMY0EdZJp+ur2pYdm39g==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-sunos-64/-/esbuild-sunos-64-0.15.18.tgz",
+      "integrity": "sha512-On22LLFlBeLNj/YF3FT+cXcyKPEI263nflYlAhz5crxtp3yRG1Ugfr7ITyxmCmjm4vbN/dGrb/B7w7U8yJR9yw==",
       "cpu": [
         "x64"
       ],
@@ -711,9 +671,9 @@
       }
     },
     "node_modules/esbuild-windows-32": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-windows-32/-/esbuild-windows-32-0.14.53.tgz",
-      "integrity": "sha512-m14XyWQP5rwGW0tbEfp95U6A0wY0DYPInWBB7D69FAXUpBpBObRoGTKRv36lf2RWOdE4YO3TNvj37zhXjVL5xg==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-32/-/esbuild-windows-32-0.15.18.tgz",
+      "integrity": "sha512-o+eyLu2MjVny/nt+E0uPnBxYuJHBvho8vWsC2lV61A7wwTWC3jkN2w36jtA+yv1UgYkHRihPuQsL23hsCYGcOQ==",
       "cpu": [
         "ia32"
       ],
@@ -727,9 +687,9 @@
       }
     },
     "node_modules/esbuild-windows-64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-windows-64/-/esbuild-windows-64-0.14.53.tgz",
-      "integrity": "sha512-s9skQFF0I7zqnQ2K8S1xdLSfZFsPLuOGmSx57h2btSEswv0N0YodYvqLcJMrNMXh6EynOmWD7rz+0rWWbFpIHQ==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-64/-/esbuild-windows-64-0.15.18.tgz",
+      "integrity": "sha512-qinug1iTTaIIrCorAUjR0fcBk24fjzEedFYhhispP8Oc7SFvs+XeW3YpAKiKp8dRpizl4YYAhxMjlftAMJiaUw==",
       "cpu": [
         "x64"
       ],
@@ -743,9 +703,9 @@
       }
     },
     "node_modules/esbuild-windows-arm64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-windows-arm64/-/esbuild-windows-arm64-0.14.53.tgz",
-      "integrity": "sha512-E+5Gvb+ZWts+00T9II6wp2L3KG2r3iGxByqd/a1RmLmYWVsSVUjkvIxZuJ3hYTIbhLkH5PRwpldGTKYqVz0nzQ==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-arm64/-/esbuild-windows-arm64-0.15.18.tgz",
+      "integrity": "sha512-q9bsYzegpZcLziq0zgUi5KqGVtfhjxGbnksaBFYmWLxeV/S1fK4OLdq2DFYnXcLMjlZw2L0jLsk1eGoB522WXQ==",
       "cpu": [
         "arm64"
       ],
@@ -851,15 +811,6 @@
         "node": "6.* || 8.* || >= 10.*"
       }
     },
-    "node_modules/get-func-name": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.0.tgz",
-      "integrity": "sha512-Hm0ixYtaSZ/V7C8FJrtZIuBBI+iSgL+1Aq82zSu8VQNB4S3Gk8e7Qs3VwBDJAhmRZcFqkl3tQu36g/Foh5I5ig==",
-      "dev": true,
-      "engines": {
-        "node": "*"
-      }
-    },
     "node_modules/glob": {
       "version": "7.2.0",
       "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz",
@@ -1074,15 +1025,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/loupe": {
-      "version": "2.3.4",
-      "resolved": "https://registry.npmjs.org/loupe/-/loupe-2.3.4.tgz",
-      "integrity": "sha512-OvKfgCC2Ndby6aSTREl5aCCPTNIzlDfQZvZxNUrBrihDhL3xcrYegTblhmEiCrg2kKQz4XsFIaemE5BF4ybSaQ==",
-      "dev": true,
-      "dependencies": {
-        "get-func-name": "^2.0.0"
-      }
-    },
     "node_modules/minimatch": {
       "version": "4.2.1",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-4.2.1.tgz",
@@ -1222,15 +1164,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/pathval": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/pathval/-/pathval-1.1.1.tgz",
-      "integrity": "sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==",
-      "dev": true,
-      "engines": {
-        "node": "*"
-      }
-    },
     "node_modules/picomatch": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
@@ -1244,9 +1177,9 @@
       }
     },
     "node_modules/prettier": {
-      "version": "2.7.1",
-      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.7.1.tgz",
-      "integrity": "sha512-ujppO+MkdPqoVINuDFDRLClm7D78qbDt0/NR+wp5FqEZOoTNAjPHWj17QRhu7geIHJfcNhRk1XVQmF8Bp3ye+g==",
+      "version": "2.8.8",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.8.tgz",
+      "integrity": "sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==",
       "dev": true,
       "bin": {
         "prettier": "bin-prettier.js"
@@ -1259,9 +1192,9 @@
       }
     },
     "node_modules/punycode": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz",
-      "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==",
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz",
+      "integrity": "sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==",
       "dev": true,
       "engines": {
         "node": ">=6"
@@ -1400,15 +1333,6 @@
         "node": ">=8.0"
       }
     },
-    "node_modules/type-detect": {
-      "version": "4.0.8",
-      "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz",
-      "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==",
-      "dev": true,
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/typescript": {
       "version": "5.1.6",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.1.6.tgz",
@@ -1540,29 +1464,29 @@
     }
   },
   "dependencies": {
+    "@esbuild/android-arm": {
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.15.18.tgz",
+      "integrity": "sha512-5GT+kcs2WVGjVs7+boataCkO5Fg0y4kCjzkB5bAip7H4jfnOS3dA6KPiww9W1OEKTKeAcUVhdZGvgI65OXmUnw==",
+      "dev": true,
+      "optional": true
+    },
     "@esbuild/linux-loong64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.14.53.tgz",
-      "integrity": "sha512-W2dAL6Bnyn4xa/QRSU3ilIK4EzD5wgYXKXJiS1HDF5vU3675qc2bvFyLwbUcdmssDveyndy7FbitrCoiV/eMLg==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.15.18.tgz",
+      "integrity": "sha512-L4jVKS82XVhw2nvzLg/19ClLWg0y27ulRwuP7lcyL6AbUWB5aPglXY3M21mauDQMDfRLs8cQmeT03r/+X3cZYQ==",
       "dev": true,
       "optional": true
     },
     "@sinclair/hammer": {
-      "version": "0.17.1",
-      "resolved": "https://registry.npmjs.org/@sinclair/hammer/-/hammer-0.17.1.tgz",
-      "integrity": "sha512-/M7KXwCaXdDmBJXQHpn1NWSTUg7Rmx6vzseVOax7IXhsBYj3vEGU5yt/Xh3XdRLVOEcyl4vGWgJ0pL9cmyrTJA==",
+      "version": "0.17.2",
+      "resolved": "https://registry.npmjs.org/@sinclair/hammer/-/hammer-0.17.2.tgz",
+      "integrity": "sha512-Nnzq4JuC3VB0JNEfxU4U9W65yCe4+/ft0+FGf6/HBn7BoxW3aigusstFdrzVdhjJ6NVABCwUBMgtYbD9X7Z94g==",
       "dev": true,
       "requires": {
-        "@sinclair/hammer": "^0.17.0",
-        "esbuild": "^0.14.53"
+        "esbuild": "^0.15.7"
       }
     },
-    "@types/chai": {
-      "version": "4.3.3",
-      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.3.3.tgz",
-      "integrity": "sha512-hC7OMnszpxhZPduX+m+nrx+uFoLkWOMiR4oa/AZF3MuSETYTZmFfJAHqZEM8MVlvfG7BEUcgvtwoCTxBp6hm3g==",
-      "dev": true
-    },
     "@types/mocha": {
       "version": "9.1.1",
       "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-9.1.1.tgz",
@@ -1570,9 +1494,9 @@
       "dev": true
     },
     "@types/node": {
-      "version": "18.11.9",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.11.9.tgz",
-      "integrity": "sha512-CRpX21/kGdzjOpFsZSkcrXMGIBWMGNIHXXBVFSH+ggkftxg+XYP20TESbh+zFvFj3EQOl5byk0HTRn1IL6hbqg==",
+      "version": "18.17.2",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.17.2.tgz",
+      "integrity": "sha512-wBo3KqP/PBqje5TI9UTiuL3yWfP6sdPtjtygSOqcYZWT232dfDeDOnkDps5wqZBP9NgGgYrNejinl0faAuE+HQ==",
       "dev": true
     },
     "@ungap/promise-all-settled": {
@@ -1624,9 +1548,9 @@
       }
     },
     "anymatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz",
-      "integrity": "sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==",
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
       "dev": true,
       "requires": {
         "normalize-path": "^3.0.0",
@@ -1639,12 +1563,6 @@
       "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
       "dev": true
     },
-    "assertion-error": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz",
-      "integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==",
-      "dev": true
-    },
     "balanced-match": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
@@ -1688,21 +1606,6 @@
       "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==",
       "dev": true
     },
-    "chai": {
-      "version": "4.3.6",
-      "resolved": "https://registry.npmjs.org/chai/-/chai-4.3.6.tgz",
-      "integrity": "sha512-bbcp3YfHCUzMOvKqsztczerVgBKSsEijCySNlHHbX3VG1nskvqjz5Rfso1gGwD6w6oOV3eI60pKuMOV5MV7p3Q==",
-      "dev": true,
-      "requires": {
-        "assertion-error": "^1.1.0",
-        "check-error": "^1.0.2",
-        "deep-eql": "^3.0.1",
-        "get-func-name": "^2.0.0",
-        "loupe": "^2.3.1",
-        "pathval": "^1.1.1",
-        "type-detect": "^4.0.5"
-      }
-    },
     "chalk": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
@@ -1724,12 +1627,6 @@
         }
       }
     },
-    "check-error": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.2.tgz",
-      "integrity": "sha512-BrgHpW9NURQgzoNyjfq0Wu6VFO6D7IZEmJNdtgNqpzGG8RuNFHt2jQxWlAs4HMe119chBnv+34syEZtc6IhLtA==",
-      "dev": true
-    },
     "chokidar": {
       "version": "3.5.3",
       "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
@@ -1801,15 +1698,6 @@
       "integrity": "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==",
       "dev": true
     },
-    "deep-eql": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-3.0.1.tgz",
-      "integrity": "sha512-+QeIQyN5ZuO+3Uk5DYh6/1eKO0m0YmJFGNmFHGACpf1ClL1nmlV/p4gNgbl2pJGxgXb4faqo6UE+M5ACEMyVcw==",
-      "dev": true,
-      "requires": {
-        "type-detect": "^4.0.0"
-      }
-    },
     "diff": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz",
@@ -1823,171 +1711,172 @@
       "dev": true
     },
     "esbuild": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.14.53.tgz",
-      "integrity": "sha512-ohO33pUBQ64q6mmheX1mZ8mIXj8ivQY/L4oVuAshr+aJI+zLl+amrp3EodrUNDNYVrKJXGPfIHFGhO8slGRjuw==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.15.18.tgz",
+      "integrity": "sha512-x/R72SmW3sSFRm5zrrIjAhCeQSAWoni3CmHEqfQrZIQTM3lVCdehdwuIqaOtfC2slvpdlLa62GYoN8SxT23m6Q==",
       "dev": true,
       "requires": {
-        "@esbuild/linux-loong64": "0.14.53",
-        "esbuild-android-64": "0.14.53",
-        "esbuild-android-arm64": "0.14.53",
-        "esbuild-darwin-64": "0.14.53",
-        "esbuild-darwin-arm64": "0.14.53",
-        "esbuild-freebsd-64": "0.14.53",
-        "esbuild-freebsd-arm64": "0.14.53",
-        "esbuild-linux-32": "0.14.53",
-        "esbuild-linux-64": "0.14.53",
-        "esbuild-linux-arm": "0.14.53",
-        "esbuild-linux-arm64": "0.14.53",
-        "esbuild-linux-mips64le": "0.14.53",
-        "esbuild-linux-ppc64le": "0.14.53",
-        "esbuild-linux-riscv64": "0.14.53",
-        "esbuild-linux-s390x": "0.14.53",
-        "esbuild-netbsd-64": "0.14.53",
-        "esbuild-openbsd-64": "0.14.53",
-        "esbuild-sunos-64": "0.14.53",
-        "esbuild-windows-32": "0.14.53",
-        "esbuild-windows-64": "0.14.53",
-        "esbuild-windows-arm64": "0.14.53"
+        "@esbuild/android-arm": "0.15.18",
+        "@esbuild/linux-loong64": "0.15.18",
+        "esbuild-android-64": "0.15.18",
+        "esbuild-android-arm64": "0.15.18",
+        "esbuild-darwin-64": "0.15.18",
+        "esbuild-darwin-arm64": "0.15.18",
+        "esbuild-freebsd-64": "0.15.18",
+        "esbuild-freebsd-arm64": "0.15.18",
+        "esbuild-linux-32": "0.15.18",
+        "esbuild-linux-64": "0.15.18",
+        "esbuild-linux-arm": "0.15.18",
+        "esbuild-linux-arm64": "0.15.18",
+        "esbuild-linux-mips64le": "0.15.18",
+        "esbuild-linux-ppc64le": "0.15.18",
+        "esbuild-linux-riscv64": "0.15.18",
+        "esbuild-linux-s390x": "0.15.18",
+        "esbuild-netbsd-64": "0.15.18",
+        "esbuild-openbsd-64": "0.15.18",
+        "esbuild-sunos-64": "0.15.18",
+        "esbuild-windows-32": "0.15.18",
+        "esbuild-windows-64": "0.15.18",
+        "esbuild-windows-arm64": "0.15.18"
       }
     },
     "esbuild-android-64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-android-64/-/esbuild-android-64-0.14.53.tgz",
-      "integrity": "sha512-fIL93sOTnEU+NrTAVMIKiAw0YH22HWCAgg4N4Z6zov2t0kY9RAJ50zY9ZMCQ+RT6bnOfDt8gCTnt/RaSNA2yRA==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-android-64/-/esbuild-android-64-0.15.18.tgz",
+      "integrity": "sha512-wnpt3OXRhcjfIDSZu9bnzT4/TNTDsOUvip0foZOUBG7QbSt//w3QV4FInVJxNhKc/ErhUxc5z4QjHtMi7/TbgA==",
       "dev": true,
       "optional": true
     },
     "esbuild-android-arm64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-android-arm64/-/esbuild-android-arm64-0.14.53.tgz",
-      "integrity": "sha512-PC7KaF1v0h/nWpvlU1UMN7dzB54cBH8qSsm7S9mkwFA1BXpaEOufCg8hdoEI1jep0KeO/rjZVWrsH8+q28T77A==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-android-arm64/-/esbuild-android-arm64-0.15.18.tgz",
+      "integrity": "sha512-G4xu89B8FCzav9XU8EjsXacCKSG2FT7wW9J6hOc18soEHJdtWu03L3TQDGf0geNxfLTtxENKBzMSq9LlbjS8OQ==",
       "dev": true,
       "optional": true
     },
     "esbuild-darwin-64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-darwin-64/-/esbuild-darwin-64-0.14.53.tgz",
-      "integrity": "sha512-gE7P5wlnkX4d4PKvLBUgmhZXvL7lzGRLri17/+CmmCzfncIgq8lOBvxGMiQ4xazplhxq+72TEohyFMZLFxuWvg==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-darwin-64/-/esbuild-darwin-64-0.15.18.tgz",
+      "integrity": "sha512-2WAvs95uPnVJPuYKP0Eqx+Dl/jaYseZEUUT1sjg97TJa4oBtbAKnPnl3b5M9l51/nbx7+QAEtuummJZW0sBEmg==",
       "dev": true,
       "optional": true
     },
     "esbuild-darwin-arm64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-darwin-arm64/-/esbuild-darwin-arm64-0.14.53.tgz",
-      "integrity": "sha512-otJwDU3hnI15Q98PX4MJbknSZ/WSR1I45il7gcxcECXzfN4Mrpft5hBDHXNRnCh+5858uPXBXA1Vaz2jVWLaIA==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-darwin-arm64/-/esbuild-darwin-arm64-0.15.18.tgz",
+      "integrity": "sha512-tKPSxcTJ5OmNb1btVikATJ8NftlyNlc8BVNtyT/UAr62JFOhwHlnoPrhYWz09akBLHI9nElFVfWSTSRsrZiDUA==",
       "dev": true,
       "optional": true
     },
     "esbuild-freebsd-64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-freebsd-64/-/esbuild-freebsd-64-0.14.53.tgz",
-      "integrity": "sha512-WkdJa8iyrGHyKiPF4lk0MiOF87Q2SkE+i+8D4Cazq3/iqmGPJ6u49je300MFi5I2eUsQCkaOWhpCVQMTKGww2w==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-freebsd-64/-/esbuild-freebsd-64-0.15.18.tgz",
+      "integrity": "sha512-TT3uBUxkteAjR1QbsmvSsjpKjOX6UkCstr8nMr+q7zi3NuZ1oIpa8U41Y8I8dJH2fJgdC3Dj3CXO5biLQpfdZA==",
       "dev": true,
       "optional": true
     },
     "esbuild-freebsd-arm64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-freebsd-arm64/-/esbuild-freebsd-arm64-0.14.53.tgz",
-      "integrity": "sha512-9T7WwCuV30NAx0SyQpw8edbKvbKELnnm1FHg7gbSYaatH+c8WJW10g/OdM7JYnv7qkimw2ZTtSA+NokOLd2ydQ==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-freebsd-arm64/-/esbuild-freebsd-arm64-0.15.18.tgz",
+      "integrity": "sha512-R/oVr+X3Tkh+S0+tL41wRMbdWtpWB8hEAMsOXDumSSa6qJR89U0S/PpLXrGF7Wk/JykfpWNokERUpCeHDl47wA==",
       "dev": true,
       "optional": true
     },
     "esbuild-linux-32": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-32/-/esbuild-linux-32-0.14.53.tgz",
-      "integrity": "sha512-VGanLBg5en2LfGDgLEUxQko2lqsOS7MTEWUi8x91YmsHNyzJVT/WApbFFx3MQGhkf+XdimVhpyo5/G0PBY91zg==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-32/-/esbuild-linux-32-0.15.18.tgz",
+      "integrity": "sha512-lphF3HiCSYtaa9p1DtXndiQEeQDKPl9eN/XNoBf2amEghugNuqXNZA/ZovthNE2aa4EN43WroO0B85xVSjYkbg==",
       "dev": true,
       "optional": true
     },
     "esbuild-linux-64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-64/-/esbuild-linux-64-0.14.53.tgz",
-      "integrity": "sha512-pP/FA55j/fzAV7N9DF31meAyjOH6Bjuo3aSKPh26+RW85ZEtbJv9nhoxmGTd9FOqjx59Tc1ZbrJabuiXlMwuZQ==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-64/-/esbuild-linux-64-0.15.18.tgz",
+      "integrity": "sha512-hNSeP97IviD7oxLKFuii5sDPJ+QHeiFTFLoLm7NZQligur8poNOWGIgpQ7Qf8Balb69hptMZzyOBIPtY09GZYw==",
       "dev": true,
       "optional": true
     },
     "esbuild-linux-arm": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-arm/-/esbuild-linux-arm-0.14.53.tgz",
-      "integrity": "sha512-/u81NGAVZMopbmzd21Nu/wvnKQK3pT4CrvQ8BTje1STXcQAGnfyKgQlj3m0j2BzYbvQxSy+TMck4TNV2onvoPA==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-arm/-/esbuild-linux-arm-0.15.18.tgz",
+      "integrity": "sha512-UH779gstRblS4aoS2qpMl3wjg7U0j+ygu3GjIeTonCcN79ZvpPee12Qun3vcdxX+37O5LFxz39XeW2I9bybMVA==",
       "dev": true,
       "optional": true
     },
     "esbuild-linux-arm64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-arm64/-/esbuild-linux-arm64-0.14.53.tgz",
-      "integrity": "sha512-GDmWITT+PMsjCA6/lByYk7NyFssW4Q6in32iPkpjZ/ytSyH+xeEx8q7HG3AhWH6heemEYEWpTll/eui3jwlSnw==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-arm64/-/esbuild-linux-arm64-0.15.18.tgz",
+      "integrity": "sha512-54qr8kg/6ilcxd+0V3h9rjT4qmjc0CccMVWrjOEM/pEcUzt8X62HfBSeZfT2ECpM7104mk4yfQXkosY8Quptug==",
       "dev": true,
       "optional": true
     },
     "esbuild-linux-mips64le": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-mips64le/-/esbuild-linux-mips64le-0.14.53.tgz",
-      "integrity": "sha512-d6/XHIQW714gSSp6tOOX2UscedVobELvQlPMkInhx1NPz4ThZI9uNLQ4qQJHGBGKGfu+rtJsxM4NVHLhnNRdWQ==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-mips64le/-/esbuild-linux-mips64le-0.15.18.tgz",
+      "integrity": "sha512-Mk6Ppwzzz3YbMl/ZZL2P0q1tnYqh/trYZ1VfNP47C31yT0K8t9s7Z077QrDA/guU60tGNp2GOwCQnp+DYv7bxQ==",
       "dev": true,
       "optional": true
     },
     "esbuild-linux-ppc64le": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-ppc64le/-/esbuild-linux-ppc64le-0.14.53.tgz",
-      "integrity": "sha512-ndnJmniKPCB52m+r6BtHHLAOXw+xBCWIxNnedbIpuREOcbSU/AlyM/2dA3BmUQhsHdb4w3amD5U2s91TJ3MzzA==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-ppc64le/-/esbuild-linux-ppc64le-0.15.18.tgz",
+      "integrity": "sha512-b0XkN4pL9WUulPTa/VKHx2wLCgvIAbgwABGnKMY19WhKZPT+8BxhZdqz6EgkqCLld7X5qiCY2F/bfpUUlnFZ9w==",
       "dev": true,
       "optional": true
     },
     "esbuild-linux-riscv64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-riscv64/-/esbuild-linux-riscv64-0.14.53.tgz",
-      "integrity": "sha512-yG2sVH+QSix6ct4lIzJj329iJF3MhloLE6/vKMQAAd26UVPVkhMFqFopY+9kCgYsdeWvXdPgmyOuKa48Y7+/EQ==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-riscv64/-/esbuild-linux-riscv64-0.15.18.tgz",
+      "integrity": "sha512-ba2COaoF5wL6VLZWn04k+ACZjZ6NYniMSQStodFKH/Pu6RxzQqzsmjR1t9QC89VYJxBeyVPTaHuBMCejl3O/xg==",
       "dev": true,
       "optional": true
     },
     "esbuild-linux-s390x": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-s390x/-/esbuild-linux-s390x-0.14.53.tgz",
-      "integrity": "sha512-OCJlgdkB+XPYndHmw6uZT7jcYgzmx9K+28PVdOa/eLjdoYkeAFvH5hTwX4AXGLZLH09tpl4bVsEtvuyUldaNCg==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-s390x/-/esbuild-linux-s390x-0.15.18.tgz",
+      "integrity": "sha512-VbpGuXEl5FCs1wDVp93O8UIzl3ZrglgnSQ+Hu79g7hZu6te6/YHgVJxCM2SqfIila0J3k0csfnf8VD2W7u2kzQ==",
       "dev": true,
       "optional": true
     },
     "esbuild-netbsd-64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-netbsd-64/-/esbuild-netbsd-64-0.14.53.tgz",
-      "integrity": "sha512-gp2SB+Efc7MhMdWV2+pmIs/Ja/Mi5rjw+wlDmmbIn68VGXBleNgiEZG+eV2SRS0kJEUyHNedDtwRIMzaohWedQ==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-netbsd-64/-/esbuild-netbsd-64-0.15.18.tgz",
+      "integrity": "sha512-98ukeCdvdX7wr1vUYQzKo4kQ0N2p27H7I11maINv73fVEXt2kyh4K4m9f35U1K43Xc2QGXlzAw0K9yoU7JUjOg==",
       "dev": true,
       "optional": true
     },
     "esbuild-openbsd-64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-openbsd-64/-/esbuild-openbsd-64-0.14.53.tgz",
-      "integrity": "sha512-eKQ30ZWe+WTZmteDYg8S+YjHV5s4iTxeSGhJKJajFfQx9TLZJvsJX0/paqwP51GicOUruFpSUAs2NCc0a4ivQQ==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-openbsd-64/-/esbuild-openbsd-64-0.15.18.tgz",
+      "integrity": "sha512-yK5NCcH31Uae076AyQAXeJzt/vxIo9+omZRKj1pauhk3ITuADzuOx5N2fdHrAKPxN+zH3w96uFKlY7yIn490xQ==",
       "dev": true,
       "optional": true
     },
     "esbuild-sunos-64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-sunos-64/-/esbuild-sunos-64-0.14.53.tgz",
-      "integrity": "sha512-OWLpS7a2FrIRukQqcgQqR1XKn0jSJoOdT+RlhAxUoEQM/IpytS3FXzCJM6xjUYtpO5GMY0EdZJp+ur2pYdm39g==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-sunos-64/-/esbuild-sunos-64-0.15.18.tgz",
+      "integrity": "sha512-On22LLFlBeLNj/YF3FT+cXcyKPEI263nflYlAhz5crxtp3yRG1Ugfr7ITyxmCmjm4vbN/dGrb/B7w7U8yJR9yw==",
       "dev": true,
       "optional": true
     },
     "esbuild-windows-32": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-windows-32/-/esbuild-windows-32-0.14.53.tgz",
-      "integrity": "sha512-m14XyWQP5rwGW0tbEfp95U6A0wY0DYPInWBB7D69FAXUpBpBObRoGTKRv36lf2RWOdE4YO3TNvj37zhXjVL5xg==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-32/-/esbuild-windows-32-0.15.18.tgz",
+      "integrity": "sha512-o+eyLu2MjVny/nt+E0uPnBxYuJHBvho8vWsC2lV61A7wwTWC3jkN2w36jtA+yv1UgYkHRihPuQsL23hsCYGcOQ==",
       "dev": true,
       "optional": true
     },
     "esbuild-windows-64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-windows-64/-/esbuild-windows-64-0.14.53.tgz",
-      "integrity": "sha512-s9skQFF0I7zqnQ2K8S1xdLSfZFsPLuOGmSx57h2btSEswv0N0YodYvqLcJMrNMXh6EynOmWD7rz+0rWWbFpIHQ==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-64/-/esbuild-windows-64-0.15.18.tgz",
+      "integrity": "sha512-qinug1iTTaIIrCorAUjR0fcBk24fjzEedFYhhispP8Oc7SFvs+XeW3YpAKiKp8dRpizl4YYAhxMjlftAMJiaUw==",
       "dev": true,
       "optional": true
     },
     "esbuild-windows-arm64": {
-      "version": "0.14.53",
-      "resolved": "https://registry.npmjs.org/esbuild-windows-arm64/-/esbuild-windows-arm64-0.14.53.tgz",
-      "integrity": "sha512-E+5Gvb+ZWts+00T9II6wp2L3KG2r3iGxByqd/a1RmLmYWVsSVUjkvIxZuJ3hYTIbhLkH5PRwpldGTKYqVz0nzQ==",
+      "version": "0.15.18",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-arm64/-/esbuild-windows-arm64-0.15.18.tgz",
+      "integrity": "sha512-q9bsYzegpZcLziq0zgUi5KqGVtfhjxGbnksaBFYmWLxeV/S1fK4OLdq2DFYnXcLMjlZw2L0jLsk1eGoB522WXQ==",
       "dev": true,
       "optional": true
     },
@@ -2053,12 +1942,6 @@
       "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
       "dev": true
     },
-    "get-func-name": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.0.tgz",
-      "integrity": "sha512-Hm0ixYtaSZ/V7C8FJrtZIuBBI+iSgL+1Aq82zSu8VQNB4S3Gk8e7Qs3VwBDJAhmRZcFqkl3tQu36g/Foh5I5ig==",
-      "dev": true
-    },
     "glob": {
       "version": "7.2.0",
       "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz",
@@ -2215,15 +2098,6 @@
         "is-unicode-supported": "^0.1.0"
       }
     },
-    "loupe": {
-      "version": "2.3.4",
-      "resolved": "https://registry.npmjs.org/loupe/-/loupe-2.3.4.tgz",
-      "integrity": "sha512-OvKfgCC2Ndby6aSTREl5aCCPTNIzlDfQZvZxNUrBrihDhL3xcrYegTblhmEiCrg2kKQz4XsFIaemE5BF4ybSaQ==",
-      "dev": true,
-      "requires": {
-        "get-func-name": "^2.0.0"
-      }
-    },
     "minimatch": {
       "version": "4.2.1",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-4.2.1.tgz",
@@ -2322,12 +2196,6 @@
       "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
       "dev": true
     },
-    "pathval": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/pathval/-/pathval-1.1.1.tgz",
-      "integrity": "sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==",
-      "dev": true
-    },
     "picomatch": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
@@ -2335,15 +2203,15 @@
       "dev": true
     },
     "prettier": {
-      "version": "2.7.1",
-      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.7.1.tgz",
-      "integrity": "sha512-ujppO+MkdPqoVINuDFDRLClm7D78qbDt0/NR+wp5FqEZOoTNAjPHWj17QRhu7geIHJfcNhRk1XVQmF8Bp3ye+g==",
+      "version": "2.8.8",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.8.tgz",
+      "integrity": "sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==",
       "dev": true
     },
     "punycode": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz",
-      "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==",
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz",
+      "integrity": "sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==",
       "dev": true
     },
     "randombytes": {
@@ -2435,12 +2303,6 @@
         "is-number": "^7.0.0"
       }
     },
-    "type-detect": {
-      "version": "4.0.8",
-      "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz",
-      "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==",
-      "dev": true
-    },
     "typescript": {
       "version": "5.1.6",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.1.6.tgz",
diff --git a/package.json b/package.json
index 2b88f0e00..295d4384e 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.30.4",
+  "version": "0.31.0",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -22,11 +22,13 @@
     "./value/convert": "./value/convert.js",
     "./value/create": "./value/create.js",
     "./value/delta": "./value/delta.js",
+    "./value/deref": "./value/deref.js",
     "./value/equal": "./value/equal.js",
     "./value/guard": "./value/guard.js",
     "./value/hash": "./value/hash.js",
     "./value/mutate": "./value/mutate.js",
     "./value/pointer": "./value/pointer.js",
+    "./value/transform": "./value/transform.js",
     "./value": "./value/index.js",
     ".": "./typebox.js"
   },
@@ -42,6 +44,8 @@
     "clean": "hammer task clean",
     "format": "hammer task format",
     "start": "hammer task start",
+    "benchmark:compression": "hammer task benchmark_compression",
+    "benchmark:measurement": "hammer task benchmark_measurement",
     "benchmark": "hammer task benchmark",
     "build": "hammer task build",
     "publish": "hammer task publish",
@@ -49,12 +53,10 @@
   },
   "devDependencies": {
     "@sinclair/hammer": "^0.17.1",
-    "@types/chai": "^4.3.3",
     "@types/mocha": "^9.1.1",
     "@types/node": "^18.11.9",
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "chai": "^4.3.6",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
     "typescript": "^5.1.6"
diff --git a/readme.md b/readme.md
index 3cec6819c..4b80a0671 100644
--- a/readme.md
+++ b/readme.md
@@ -2,7 +2,7 @@
 
 <h1>TypeBox</h1>
 
-<p>JSON Schema Type Builder with Static Type Resolution for TypeScript</p>
+<p>Json Schema Type Builder with Static Type Resolution for TypeScript</p>
 
 <img src="https://github.com/sinclairzx81/typebox/blob/master/typebox.png?raw=true" />
 
@@ -25,21 +25,16 @@
 $ npm install @sinclair/typebox --save
 ```
 
-#### Deno
-```typescript
-import { Static, Type } from 'npm:@sinclair/typebox'
-```
-
-#### Esm
+#### Esm + Deno
 
 ```typescript
-import { Static, Type } from 'https://esm.sh/@sinclair/typebox'
+import { Type, Static } from 'https://esm.sh/@sinclair/typebox'
 ```
 
 ## Example
 
 ```typescript
-import { Static, Type } from '@sinclair/typebox'
+import { Type, Static } from '@sinclair/typebox'
 
 const T = Type.Object({                              // const T = {
   x: Type.Number(),                                  //   type: 'object',
@@ -63,9 +58,11 @@ type T = Static<typeof T>                            // type T = {
 
 ## Overview
 
-TypeBox is a runtime type builder that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type assertion rules of the TypeScript language. TypeBox allows one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
+TypeBox is a runtime type builder that creates Json Schema objects that infer as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript and runtime checked using standard Json Schema validation.
 
-This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire.
+TypeBox is designed to be a runtime type system based on industry standard specifications for use in distributed systems. It offers serializable and publishable types as standard, a fully extensible type system capable of supporting multiple schema specifications, a high performance runtime validation compiler, various tools for working with dynamic data and offers detailed structured error reporting.
+
+TypeBox can be used as a simple tool to build up complex schemas or integrated into applications to enable high performance runtime validation for data received over the wire.
 
 License MIT
 
@@ -74,20 +71,20 @@ License MIT
 - [Overview](#overview)
 - [Usage](#usage)
 - [Types](#types)
-  - [Standard](#types-standard)
-  - [Extended](#types-extended)
+  - [Json](#types-json)
+  - [JavaScript](#types-javascript)
   - [Options](#types-options)
   - [Properties](#types-properties)
   - [Generics](#types-generics)
   - [References](#types-references)
   - [Recursive](#types-recursive)
   - [Conditional](#types-conditional)
-  - [Template Literal](#types-template-literal)
+  - [Template Literal](#types-templateliteral)
   - [Indexed](#types-indexed)
-  - [Negated](#types-negated)
-  - [Intrinsic](#types-intrinsic)
   - [Rest](#types-rest)
-  - [Guards](#types-guards)
+  - [Transform](#types-transform)
+  - [Intrinsic](#types-intrinsic)
+  - [Guard](#types-guard)
   - [Unsafe](#types-unsafe)
   - [Strict](#types-strict)
 - [Values](#values)
@@ -96,6 +93,8 @@ License MIT
   - [Check](#values-check)
   - [Convert](#values-convert)
   - [Cast](#values-cast)
+  - [Decode](#values-decode)
+  - [Encode](#values-decode)
   - [Equal](#values-equal)
   - [Hash](#values-hash)
   - [Diff](#values-diff)
@@ -103,14 +102,19 @@ License MIT
   - [Errors](#values-errors)
   - [Mutate](#values-mutate)
   - [Pointer](#values-pointer)
+- [TypeRegistry](#typeregistry)
+  - [Type](#typeregistry-type)
+  - [Format](#typeregistry-format)
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
   - [TypeCompiler](#typecheck-typecompiler)
 - [TypeSystem](#typesystem)
   - [Types](#typesystem-types)
   - [Formats](#typesystem-formats)
+  - [Errors](#typesystem-errors)
   - [Policies](#typesystem-policies)
 - [Workbench](#workbench)
+- [Codegen](#codegen)
 - [Ecosystem](#ecosystem)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
@@ -125,7 +129,7 @@ License MIT
 The following shows general usage.
 
 ```typescript
-import { Static, Type } from '@sinclair/typebox'
+import { Type, Static } from '@sinclair/typebox'
 
 //--------------------------------------------------------------------------------------------
 //
@@ -179,7 +183,7 @@ type T = Static<typeof T>                            // type T = {
 
 //--------------------------------------------------------------------------------------------
 //
-// ... then use the type both as JSON schema and as a TypeScript type.
+// ... then use the type both as Json Schema and as a TypeScript type.
 //
 //--------------------------------------------------------------------------------------------
 
@@ -187,7 +191,7 @@ import { Value } from '@sinclair/typebox/value'
 
 function receive(value: T) {                         // ... as a Static Type
 
-  if(Value.Check(T, value)) {                        // ... as a JSON Schema
+  if(Value.Check(T, value)) {                        // ... as a Json Schema
 
     // ok...
   }
@@ -198,17 +202,17 @@ function receive(value: T) {                         // ... as a Static Type
 
 ## Types
 
-TypeBox types are JSON schema fragments that compose into complex types. Each fragment is structured such that a JSON schema compliant validator can runtime assert a value the same way TypeScript will statically assert a type. TypeBox provides a set of Standard types which are used create JSON schema compliant schematics as well as an Extended type set used to create schematics for constructs native to JavaScript.
+TypeBox types are Json Schema fragments that compose into more complex types. Each fragment is structured such that any Json Schema compliant validator can runtime assert a value the same way TypeScript will statically assert a type. TypeBox offers a set of Json Types which are used to create Json Schema compliant schematics as well as a JavaScript type set used to create schematics for constructs native to JavaScript.
 
-<a name='types-standard'></a>
+<a name='types-json'></a>
 
-### Standard Types
+### Json Types
 
-The following table lists the Standard TypeBox types. These types are fully compatible with the JSON Schema Draft 7 specification.
+The following table lists the supported Json types. These types are fully compatible with the Json Schema Draft 7 specification.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
-│ TypeBox                        │ TypeScript                  │ JSON Schema                    │
+│ TypeBox                        │ TypeScript                  │ Json Schema                    │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Any()           │ type T = any                │ const T = { }                  │
@@ -387,12 +391,6 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │ )                              │                             │                                │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Pattern('^xy$') │ type T = string             │ const T = {                    │
-│                                │                             │    type: 'string',             │
-│                                │                             │    pattern: '^xy$'             │
-│                                │                             │ }                              │
-│                                │                             │                                │
-├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const U = Type.Union([         │ type U = 'open' | 'close'   │ const T = {                    │
 │   Type.Literal('open'),        │                             │   type: 'string',              │
 │   Type.Literal('close')        │ type T = `on${U}`           │   pattern: '^on(open|close)$'  │
@@ -523,11 +521,11 @@ The following table lists the Standard TypeBox types. These types are fully comp
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name='types-extended'></a>
+<a name='types-javascript'></a>
 
-### Extended Types
+### JavaScript Types
 
-TypeBox provides several extended types that can be used to produce schematics for common JavaScript constructs. These types can not be used with standard JSON schema validators; but are useful to help frame schematics for RPC interfaces that may receive JSON validated data. Extended types are prefixed with the `[Extended]` doc comment for convenience. The following table lists the supported types.
+TypeBox provides an extended type set that can be used to create schematics for common JavaScript constructs. These types can not be used with any standard Json Schema validator; but can be used to frame schematics for interfaces that may receive Json validated data. JavaScript types are prefixed with the `[JavaScript]` jsdoc comment for convenience. The following table lists the supported types.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
@@ -568,6 +566,14 @@ TypeBox provides several extended types that can be used to produce schematics f
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T =                      │ type T =                    │ const T = {                    │
+│   Type.AsyncIterator(          │   AsyncIterableIterator<    │   type: 'AsyncIterator',       │
+│     Type.String()              │    string                   │   items: {                     │
+│   )                            │   >                         │     type: 'string'             │
+│                                │                             │   }                            │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Iterator(       │ type T =                    │ const T = {                    │
 │   Type.String()                │   IterableIterator<string>  │   type: 'Iterator',            │
 │ )                              │                             │   items: {                     │
@@ -576,11 +582,9 @@ TypeBox provides several extended types that can be used to produce schematics f
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T =                      │ type T =                    │ const T = {                    │
-│   Type.AsyncIterator(          │   AsyncIterableIterator<    │   type: 'AsyncIterator',       │
-│     Type.String()              │    string                   │   items: {                     │
-│   )                            │   >                         │     type: 'string'             │
-│                                │                             │   }                            │
+│ const T = Type.RegExp(/abc/)   │ type T = string             │ const T = {                    │
+│                                │                             │   type: 'string'               │
+│                                │                             │   pattern: 'abc'               │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -620,7 +624,7 @@ TypeBox provides several extended types that can be used to produce schematics f
 
 ### Options
 
-You can pass JSON Schema options on the last argument of any type. Option hints specific to each type are provided for convenience.
+You can pass Json Schema options on the last argument of any type. Option hints specific to each type are provided for convenience.
 
 ```typescript
 // String must be an email
@@ -649,11 +653,11 @@ const T = Type.Array(Type.Integer(), {               // const T = {
 
 ### Properties
 
-Object properties can be modified with `readonly` or `optional`. The following table shows how these modifiers map between TypeScript and JSON Schema.
+Object properties can be modified with Readonly and Optional. The following table shows how these modifiers map between TypeScript and Json Schema.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
-│ TypeBox                        │ TypeScript                  │ JSON Schema                    │
+│ TypeBox                        │ TypeScript                  │ Json Schema                    │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Object({        │ type T = {                  │ const T = {                    │
@@ -692,7 +696,7 @@ Object properties can be modified with `readonly` or `optional`. The following t
 
 ### Generic Types
 
-Generic types are created with generic functions. All TypeBox types extend the sub type `TSchema` so it is common to constrain function arguments to this type. The following creates a generic `Vector<T>` type.
+Generic types can be created with generic functions. All types extend the base type TSchema. It is common to constrain generic function arguments to this type. The following creates a generic Vector type.
 
 ```typescript
 import { Type, Static, TSchema } from '@sinclair/typebox'
@@ -716,32 +720,32 @@ type NumberVector = Static<typeof NumberVector>      // type NumberVector = {
                                                      // }
 ```
 
-Generic types can be used to create aliases for more complex types. The following creates a `Nullable<T>` type.
+Generic types are often used to create aliases for more complex types. The following creates a Nullable generic type.
 
 ```typescript
 const Nullable = <T extends TSchema>(schema: T) => Type.Union([schema, Type.Null()])
 
-const T = Nullable(Type.String())                   // const T = {
-                                                    //   anyOf: [
-                                                    //     { type: 'string' },
-                                                    //     { type: 'null' }
-                                                    //   ]
-                                                    // }
+const T = Nullable(Type.String())                    // const T = {
+                                                     //   anyOf: [
+                                                     //     { type: 'string' },
+                                                     //     { type: 'null' }
+                                                     //   ]
+                                                     // }
 
-type T = Static<typeof T>                           // type T = string | null
+type T = Static<typeof T>                            // type T = string | null
 ```
 
 <a name='types-references'></a>
 
 ### Reference Types
 
-Reference types are supported with `Ref`.
+Reference types are supported with Ref.
 
 ```typescript
 const T = Type.String({ $id: 'T' })                  // const T = {
                                                      //   $id: 'T',
                                                      //   type: 'string'
-                                                     // }
+                                                     // } 
 
 const R = Type.Ref<typeof T>('T')                    // const R = {
                                                      //   $ref: 'T'
@@ -754,7 +758,7 @@ type R = Static<typeof R>                            // type R = string
 
 ### Recursive Types
 
-Recursive types are supported with `Recursive`. Recursive type inference is also supported.
+TypeBox supports singular recursive data structures. Recursive type inference is also supported. The following creates a recursive Node data structure.
 
 ```typescript
 const Node = Type.Recursive(This => Type.Object({    // const Node = {
@@ -791,7 +795,7 @@ function test(node: Node) {
 
 ### Conditional Types
 
-TypeBox supports conditional types with `Extends`. This type performs a structural assignment check against the first two parameters and returns either the `true` or `false` type as given from the second two parameters. The conditional types `Exclude` and `Extract` are also supported.
+TypeBox supports runtime conditional types with Extends. This type will perform a structural assignability check for the first two arguments and returns one of the second two arguments based on the result. The Extends type is modelled after TypeScript conditional types. The Exclude and Extract conditional types are also supported.
 
 ```typescript
 // TypeScript
@@ -820,25 +824,25 @@ const T1 = Type.Extract(                             // const T1: TLiteral<1> =
   Type.Literal(1)
 )
 
-const T2 = Type.Exclude(                            // const T2: TUnion<[
-  Type.Union([                                      //   TLiteral<2>,
-    Type.Literal(1),                                //   TLiteral<3>
-    Type.Literal(2),                                // ]> = {
-    Type.Literal(3)                                 //   anyOf: [{
-  ]),                                               //     type: 'number',
-  Type.Literal(1)                                   //     const: 2
-)                                                   //   }, {
-                                                    //     type: 'number',
-                                                    //     const: 3
-                                                    //   }]
-                                                    // }
+const T2 = Type.Exclude(                             // const T2: TUnion<[
+  Type.Union([                                       //   TLiteral<2>,
+    Type.Literal(1),                                 //   TLiteral<3>
+    Type.Literal(2),                                 // ]> = {
+    Type.Literal(3)                                  //   anyOf: [{
+  ]),                                                //     type: 'number',
+  Type.Literal(1)                                    //     const: 2
+)                                                    //   }, {
+                                                     //     type: 'number',
+                                                     //     const: 3
+                                                     //   }]
+                                                     // }
 ```
 
-<a name='types-template-literal'></a>
+<a name='types-templateliteral'></a>
 
 ### Template Literal Types
 
-TypeBox supports template literal types with `TemplateLiteral`. This type provides an embedded DSL syntax that is similar to the TypeScript template literal syntax. These type can also be composed by passing a tuple of exterior union and literal types. The following example shows the DSL syntax.
+TypeBox supports template literal types with TemplateLiteral. This type can be created using a string syntax that is similar to the TypeScript template literal syntax. This type can also be constructed by passing an array of Union and Literal types in sequence. The following example shows the string syntax.
 
 ```typescript
 // TypeScript
@@ -879,7 +883,7 @@ const R = Type.Record(T, Type.String())              // const R = {
 
 ### Indexed Access Types
 
-TypeBox supports indexed access types using `Index`. This type provides a consistent way of accessing interior property and array element types without having to extract them from the underlying schema representation. Indexed access types are supported for object, array, tuple, union and intersect types.
+TypeBox supports Indexed Access Types with Index. This type enables uniform access to interior property and array element types without having to extract them from the underlying schema representation. This type is supported for Object, Array, Tuple, Union and Intersect types.
 
 ```typescript
 const T = Type.Object({                              // const T = {
@@ -910,150 +914,117 @@ const C = Type.Index(T, Type.KeyOf(T))               // const C = {
                                                      // }
 ```
 
-<a name='types-negated'></a>
-
-### Negated Types
-
-TypeBox has support for type negation with `Not`. This type will always infer as `unknown`.
+<a name='types-rest'></a>
 
-```typescript
-const T = Type.Not(Type.String())                   // const T = {
-                                                    //   not: { type: 'string' }
-                                                    // }
+### Rest Types
 
-type T = Static<typeof T>                           // type T = unknown
-                                                    //
-                                                    // where T could be any type other than string
-```
-Type negation can be useful for certain forms of type narrowing. For example, consider a type that represents a `number` but not the numbers `1, 2, 3`. The example below shows an imaginary TypeScript syntax to express such a type followed by the TypeBox representation.
+TypeBox provides the Rest type to uniformly extract variadic tuples from Intersect, Union and Tuple types. This type can be useful to remap variadic types into different forms. The following uses Rest to remap a Tuple into a Union.
 
 ```typescript
-// TypeScript
-
-type T = number & not (1 | 2 | 3)                    // not actual syntax
+const T = Type.Tuple([                               // const T = {
+  Type.String(),                                     //   type: 'array',
+  Type.Number()                                      //   items: [ 
+])                                                   //     { type: 'string' },
+                                                     //     { type: 'number' }
+                                                     //   ],
+                                                     //   additionalItems: false,
+                                                     //   minItems: 2,
+                                                     //   maxItems: 2,
+                                                     // }
 
-// TypeBox
+const R = Type.Rest(T)                               // const R = [
+                                                     //   { type: 'string' },
+                                                     //   { type: 'number' }
+                                                     // ]
 
-const T = Type.Intersect([                           // const T = {
-  Type.Number(),                                     //   allOf: [
-  Type.Not(Type.Union([                              //     { type: "number" },
-    Type.Literal(1),                                 //     {
-    Type.Literal(2),                                 //       not: {
-    Type.Literal(3)                                  //         anyOf: [
-  ]))                                                //           { const: 1, type: "number" },
-])                                                   //           { const: 2, type: "number" },
-                                                     //           { const: 3, type: "number" }
-                                                     //         ]
-                                                     //       }
-                                                     //     }
+const U = Type.Union(R)                              // const U = {
+                                                     //   anyOf: [
+                                                     //     { type: 'string' },
+                                                     //     { type: 'number' }
                                                      //   ]
                                                      // }
-
-type T = Static<typeof T>                            // type T = number
-```
-This type can be used with constraints to create schematics that would otherwise be difficult to express.
-```typescript
-const Even = Type.Number({ multipleOf: 2 })
-
-const Odd = Type.Intersect([Type.Number(), Type.Not(Even)])          
 ```
 
-<a name='types-intrinsic'></a>
+<a name='types-transform'></a>
 
-### Intrinsic String Types
+### Transform Types
 
-TypeBox supports TypeScript intrinsic string manipulation types `Uppercase`, `Lowercase`, `Capitalize` and `Uncapitalize`. These can be applied to string literals, template literals and unions. The following shows general usage.
+TypeBox supports bi-directional decode and encode with Transform types. These types are designed to operate with the Value and TypeCompiler Encode and Decode functions. Transform types are useful to convert Json encoded values into constructs more natural to JavaScript. The following creates a Transform type to convert between Date and number using the Value module.
 
 ```typescript
-// TypeScript
-
-type A = Capitalize<'hello'>                        // type A = 'Hello'
+import { Value } from '@sinclair/typebox/value'
 
-type B = Capitalize<'hello' | 'world'>              // type C = 'Hello' | 'World'
+const T = Type.Transform(Type.Number())
+  .Decode(value => new Date(value))                  // required: number to Date
+  .Encode(value => value.getTime())                  // required: Date to number
 
-type C = Capitalize<`hello${1|2|3}`>                // type B = 'Hello1' | 'Hello2' | 'Hello3'
+const decoded = Value.Decode(T, 0)                   // const decoded = Date(1970-01-01T00:00:00.000Z)
+const encoded = Value.Encode(T, decoded)             // const encoded = 0
+```
+Use the StaticEncode or StaticDecode types to infer a Transform type.
+```typescript
+import { Static, StaticDecode, StaticEncode } from '@sinclair/typebox'
 
-// TypeBox
+const T = Type.Transform(Type.Array(Type.Number(), { uniqueItems: true }))         
+  .Decode(value => new Set(value))
+  .Encode(value => [...value])
 
-const A = Type.Capitalize(Type.Literal('hello'))    // const A: TLiteral<'Hello'>
-
-const B = Type.Capitalize(Type.Union([              // const B: TUnion<[
-  Type.Literal('hello'),                            //   TLiteral<'Hello'>,
-  Type.Literal('world')                             //   TLiteral<'World'>
-]))                                                 // ]>
-
-const C = Type.Capitalize(                          // const C: TTemplateLiteral<[
-  Type.TemplateLiteral('hello${1|2|3}')             //   TLiteral<'Hello'>,
-)                                                   //   TUnion<[
-                                                    //     TLiteral<'1'>,
-                                                    //     TLiteral<'2'>,
-                                                    //     TLiteral<'3'>
-                                                    //   ]>
-                                                    // ]>
+type D = StaticDecode<typeof T>                      // type D = Set<number>      
+type E = StaticEncode<typeof T>                      // type E = Array<number>
+type T = Static<typeof T>                            // type T = Array<number>
 ```
 
-<a name='types-rest'></a>
+<a name='types-intrinsic'></a>
 
-### Rest Types
+### Intrinsic Types
 
-Rest parameters are supported with `Rest`. This function is used to extract interior type elements from tuples which enables them to compose with the JavaScript spread operator `...`. This type can be used for tuple concatenation as well function parameter assignment.
+TypeBox supports the TypeScript Intrinsic String Manipulation types Uppercase, Lowercase, Capitalize and Uncapitalize. These types can be used to remap String Literal, TemplateLiteral and Union types.
 
 ```typescript
 // TypeScript
 
-type T = [number, number]                            // type T = [number, number]
-
-type C = [...T, number]                              // type C = [number, number, number]
-
-type F = (...param: C) => void                       // type F = (
-                                                     //   param0: number,
-                                                     //   param1: number,
-                                                     //   param2: number
-                                                     // ) => void
+type A = Capitalize<'hello'>                         // type A = 'Hello'
+type B = Capitalize<'hello' | 'world'>               // type C = 'Hello' | 'World'
+type C = Capitalize<`hello${1|2|3}`>                 // type B = 'Hello1' | 'Hello2' | 'Hello3'
 
 // TypeBox
 
-const T = Type.Tuple([                               // const T: TTuple<[
-  Type.Number(),                                     //   TNumber,
-  Type.Number()                                      //   TNumber
-])                                                   // ]>
+const A = Type.Capitalize(Type.Literal('hello'))     // const A: TLiteral<'Hello'>
 
-const C = Type.Tuple([                               // const C: TTuple<[
-  ...Type.Rest(T),                                   //   TNumber,
-  Type.Number()                                      //   TNumber,
-])                                                   //   TNumber
-                                                     // ]>
+const B = Type.Capitalize(Type.Union([               // const B: TUnion<[
+  Type.Literal('hello'),                             //   TLiteral<'Hello'>,
+  Type.Literal('world')                              //   TLiteral<'World'>
+]))                                                  // ]>
 
-const F = Type.Function(Type.Rest(C), Type.Void())   // const F: TFunction<[
-                                                     //   TNumber,
-                                                     //   TNumber,
-                                                     //   TNumber
-                                                     // ], TVoid>
+const C = Type.Capitalize(                           // const C: TTemplateLiteral<[
+  Type.TemplateLiteral('hello${1|2|3}')              //   TLiteral<'Hello'>,
+)                                                    //   TUnion<[
+                                                     //     TLiteral<'1'>,
+                                                     //     TLiteral<'2'>,
+                                                     //     TLiteral<'3'>
+                                                     //   ]>
+                                                     // ]>
 ```
+
 <a name='types-unsafe'></a>
 
 ### Unsafe Types
 
-TypeBox supports the creation of user defined schematics with user defined inference rules using the Unsafe type.
+TypeBox supports user defined types with Unsafe. This type allows you to specify both schema representation and inference type. The following creates an Unsafe type with a number schema that infers as string.
 
 ```typescript
 const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
                                                      //   type: 'number'
                                                      // }
 
-type T = Static<typeof T>                            // type T = string
+type T = Static<typeof T>                            // type T = string - ?
 ```
-
-This type can be useful to create various extended schematics, such as those used by OpenAPI.
-
+The Unsafe type is often used to create schematics for extended specifications like OpenAPI
 ```typescript
-import { Type, Static, TSchema } from '@sinclair/typebox'
 
-// Nullable<T>
-
-function Nullable<T extends TSchema>(schema: T) {
-  return Type.Unsafe<Static<T> | null>({ ...schema, nullable: true })
-}
+const Nullable = <T extends TSchema>(schema: T) => Type.Unsafe<Static<T> | null>({ 
+  ...schema, nullable: true 
+})
 
 const T = Nullable(Type.String())                    // const T = {
                                                      //   type: 'string',
@@ -1062,33 +1033,29 @@ const T = Nullable(Type.String())                    // const T = {
 
 type T = Static<typeof T>                            // type T = string | null
 
-// StringEnum<string[]>
-
-function StringEnum<T extends string[]>(values: [...T]) {
-  return Type.Unsafe<T[number]>({ type: 'string', enum: values })
-}
-
-const T = StringEnum(['A', 'B', 'C'])                // const T = {
+const StringEnum = <T extends string[]>(values: [...T]) => Type.Unsafe<T[number]>({ 
+  type: 'string', enum: values 
+})
+const S = StringEnum(['A', 'B', 'C'])                // const S = {
                                                      //   enum: ['A', 'B', 'C']
                                                      // }
 
-type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
+type S = Static<typeof T>                            // type S = 'A' | 'B' | 'C'
 ```
+<a name='types-guard'></a>
 
-<a name='types-guards'></a>
+### Type Guard
 
-### Type Guards
-
-TypeBox provides a TypeGuard module to assert JavaScript values are valid TypeBox types.
+TypeBox can type check its own types with the TypeGuard module. This module is written for reflection and provides structural tests for every TypeBox type. Functions of this module return `is` guards which can be used with TypeScript control flow assertions to obtain schema inference. The following guards that the value A is TString.
 
 ```typescript
 import { Type, Kind, TypeGuard } from '@sinclair/typebox'
 
-const T = { [Kind]: 'String', type: 'string' }
+const A: unknown = { ... }
 
-if(TypeGuard.TString(T)) {
+if(TypeGuard.TString(A)) {
 
-  // T is TString
+  A.type                                             // A.type = 'string'
 }
 ```
 
@@ -1096,7 +1063,7 @@ if(TypeGuard.TString(T)) {
 
 ### Strict
 
-TypeBox types contain various symbol properties that are used for reflection, composition and compilation. These properties are not strictly valid JSON schema; so in some cases it may be desirable to omit them. TypeBox provides a `Strict` function that will omit these properties if necessary.
+TypeBox types contain various symbol properties that are used for reflection, composition and compilation. These properties are not strictly valid Json Schema; so in some cases it may be desirable to omit them. TypeBox provides a `Strict` function that will omit these properties if necessary.
 
 ```typescript
 const T = Type.Object({                              // const T = {
@@ -1125,7 +1092,7 @@ const U = Type.Strict(T)                             // const U = {
 
 ## Values
 
-TypeBox provides an optional utility module that can be used to perform common operations on JavaScript values. This module includes functionality to create, check and cast values from types as well as check equality, clone, diff and patch JavaScript values. This module is provided via optional import.
+TypeBox provides an optional utility module that can be used to perform structural operations on JavaScript values. This module includes functionality to create, check and cast values from types as well as check equality, clone, diff and patch JavaScript values. This module is provided via optional import.
 
 ```typescript
 import { Value } from '@sinclair/typebox/value'
@@ -1147,7 +1114,7 @@ const A = Value.Create(T)                            // const A = { x: 0, y: 42
 
 ### Clone
 
-Use the Clone function to deeply clone a value
+Use the Clone function to deeply clone a value.
 
 ```typescript
 const A = Value.Clone({ x: 1, y: 2, z: 3 })          // const A = { x: 1, y: 2, z: 3 }
@@ -1157,7 +1124,7 @@ const A = Value.Clone({ x: 1, y: 2, z: 3 })          // const A = { x: 1, y: 2,
 
 ### Check
 
-Use the Check function to type check a value
+Use the Check function to type check a value.
 
 ```typescript
 const T = Type.Object({ x: Type.Number() })
@@ -1169,21 +1136,21 @@ const R = Value.Check(T, { x: 1 })                   // const R = true
 
 ### Convert
 
-Use the Convert function to convert a value into its target type if a reasonable conversion is possible. This function may return an invalid value and should be checked before use. It's return type is `unknown`.
+Use the Convert function to convert a value into its target type if a reasonable conversion is possible. This function may return an invalid value and should be checked before use. Its return type is `unknown`.
 
 ```typescript
 const T = Type.Object({ x: Type.Number() })
 
-const R1 = Value.Convert(T, { x: '3.14' })          // const R1 = { x: 3.14 }
+const R1 = Value.Convert(T, { x: '3.14' })           // const R1 = { x: 3.14 }
 
-const R2 = Value.Convert(T, { x: 'not a number' })  // const R2 = { x: 'not a number' }
+const R2 = Value.Convert(T, { x: 'not a number' })   // const R2 = { x: 'not a number' }
 ```
 
 <a name='values-cast'></a>
 
 ### Cast
 
-Use the Cast function to cast a value into a type. The cast function will retain as much information as possible from the original value.
+Use the Cast function to cast a value with a type. The cast function will retain as much information as possible from the original value.
 
 ```typescript
 const T = Type.Object({ x: Type.Number(), y: Type.Number() }, { additionalProperties: false })
@@ -1195,6 +1162,29 @@ const Y = Value.Cast(T, { x: 1 })                    // const Y = { x: 1, y: 0 }
 const Z = Value.Cast(T, { x: 1, y: 2, z: 3 })        // const Z = { x: 1, y: 2 }
 ```
 
+<a name='values-decode'></a>
+
+### Decode
+
+Use the Decode function to decode a value from a type, or throw if the value is invalid. The return value will infer as the decoded type. This function will run Transform codecs if available.
+
+```typescript
+const A = Type.Decode(Type.String(), 'hello')        // const A = 'hello'
+
+const B = Type.Decode(Type.String(), 42)             // throw
+```
+<a name='values-decode'></a>
+
+### Encode
+
+Use the Encode function to encode a value to a type, or throw if the value is invalid. The return value will infer as the encoded type. This function will run Transform codecs if available.
+
+```typescript
+const A = Type.Encode(Type.String(), 'hello')        // const A = 'hello'
+
+const B = Type.Encode(Type.String(), 42)             // throw
+```
+
 <a name='values-equal'></a>
 
 ### Equal
@@ -1215,31 +1205,31 @@ const R = Value.Equal(                               // const R = true
 Use the Hash function to create a [FNV1A-64](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function) non cryptographic hash of a value.
 
 ```typescript
-const A = Value.Hash({ x: 1, y: 2, z: 3 })          // const A = 2910466848807138541n
+const A = Value.Hash({ x: 1, y: 2, z: 3 })           // const A = 2910466848807138541n
 
-const B = Value.Hash({ x: 1, y: 4, z: 3 })          // const B = 1418369778807423581n
+const B = Value.Hash({ x: 1, y: 4, z: 3 })           // const B = 1418369778807423581n
 ```
 
 <a name='values-diff'></a>
 
 ### Diff
 
-Use the Diff function to produce a sequence of edits to transform one value into another.
+Use the Diff function to generate a sequence of edits that will transform one value into another.
 
 ```typescript
-const E = Value.Diff(                               // const E = [
-  { x: 1, y: 2, z: 3 },                             //   { type: 'update', path: '/y', value: 4 },
-  { y: 4, z: 5, w: 6 }                              //   { type: 'update', path: '/z', value: 5 },
-)                                                   //   { type: 'insert', path: '/w', value: 6 },
-                                                    //   { type: 'delete', path: '/x' }
-                                                    // ]
+const E = Value.Diff(                                // const E = [
+  { x: 1, y: 2, z: 3 },                              //   { type: 'update', path: '/y', value: 4 },
+  { y: 4, z: 5, w: 6 }                               //   { type: 'update', path: '/z', value: 5 },
+)                                                    //   { type: 'insert', path: '/w', value: 6 },
+                                                     //   { type: 'delete', path: '/x' }
+                                                     // ]
 ```
 
 <a name='values-patch'></a>
 
 ### Patch
 
-Use the Patch function to apply edits
+Use the Patch function to apply a sequence of edits.
 
 ```typescript
 const A = { x: 1, y: 2 }
@@ -1258,7 +1248,7 @@ const C = Value.Patch<typeof B>(A, E)                // const C = { x: 3 }
 
 ### Errors
 
-Use the Errors function enumerate validation errors.
+Use the Errors function to enumerate validation errors.
 
 ```typescript
 const T = Type.Object({ x: Type.Number(), y: Type.Number() })
@@ -1284,18 +1274,13 @@ Use the Mutate function to perform a deep mutable value assignment while retaini
 
 ```typescript
 const Y = { z: 1 }                                   // const Y = { z: 1 }
-
 const X = { y: Y }                                   // const X = { y: { z: 1 } }
-
 const A = { x: X }                                   // const A = { x: { y: { z: 1 } } }
 
-
 Value.Mutate(A, { x: { y: { z: 2 } } })              // const A' = { x: { y: { z: 2 } } }
 
 const R0 = A.x.y.z === 2                             // const R0 = true
-
 const R1 = A.x.y === Y                               // const R1 = true
-
 const R2 = A.x === X                                 // const R2 = true
 ```
 
@@ -1303,7 +1288,7 @@ const R2 = A.x === X                                 // const R2 = true
 
 ### Pointer
 
-Use ValuePointer to perform mutable updates on existing values using [RFC6901](https://www.rfc-editor.org/rfc/rfc6901) JSON Pointers.
+Use ValuePointer to perform mutable updates on existing values using [RFC6901](https://www.rfc-editor.org/rfc/rfc6901) Json Pointers.
 
 ```typescript
 import { ValuePointer } from '@sinclair/typebox/value'
@@ -1311,19 +1296,55 @@ import { ValuePointer } from '@sinclair/typebox/value'
 const A = { x: 0, y: 0, z: 0 }
 
 ValuePointer.Set(A, '/x', 1)                         // const A' = { x: 1, y: 0, z: 0 }
-
 ValuePointer.Set(A, '/y', 1)                         // const A' = { x: 1, y: 1, z: 0 }
-
 ValuePointer.Set(A, '/z', 1)                         // const A' = { x: 1, y: 1, z: 1 }
 ```
 
+<a name='typeregistry'></a>
+
+## TypeRegistry
+
+The TypeBox type system can be extended with additional types and formats using the TypeRegistry and FormatRegistry modules. These modules integrate deeply with TypeBox's internal type checking infrastructure and can be used to create application specific types, or register schematics for alternative specifications.
+
+<a name='typeregistry-type'></a>
+
+### TypeRegistry
+
+Use the TypeRegistry to register a new type. The Kind must match the registered type name.
+
+```typescript
+import { TypeRegistry, Kind } from '@sinclair/typebox'
+
+TypeRegistry.Set('Foo', (schema, value) => value === 'foo')
+
+const A = Value.Check({ [Kind]: 'Foo' }, 'foo')      // const A = true
+const B = Value.Check({ [Kind]: 'Foo' }, 'bar')      // const B = false
+```
+
+<a name='typeregistry-format'></a>
+
+### FormatRegistry
+
+Use the FormatRegistry to register a string format.
+
+```typescript
+import { FormatRegistry } from '@sinclair/typebox'
+
+FormatRegistry.Set('foo', (value) => value === 'foo')
+
+const T = Type.String({ format: 'foo' })
+
+const A = Value.Check(T, 'foo')                      // const A = true
+const B = Value.Check(T, 'bar')                      // const B = false
+```
+
 <a name='typecheck'></a>
 
 ## TypeCheck
 
-TypeBox types target JSON Schema draft 7 so are compatible with any validator that supports this specification. TypeBox also provides a built in type checking compiler designed specifically for high performance compilation and value assertion.
+TypeBox types target Json Schema Draft 7 and are compatible with any validator that supports this specification. TypeBox also provides a built in type checking compiler designed specifically for TypeBox types that offers high performance compilation and value checking.
 
-The following sections detail using Ajv and TypeBox's compiler infrastructure.
+The following sections detail using Ajv and the TypeBox compiler infrastructure.
 
 <a name='typecheck-ajv'></a>
 
@@ -1357,20 +1378,20 @@ const ajv = addFormats(new Ajv({}), [
   'regex'
 ])
 
-const C = ajv.compile(Type.Object({
+const validate = ajv.compile(Type.Object({
   x: Type.Number(),
   y: Type.Number(),
   z: Type.Number()
 }))
 
-const R = C({ x: 1, y: 2, z: 3 })                    // const R = true
+const R = validate({ x: 1, y: 2, z: 3 })             // const R = true
 ```
 
 <a name='typecheck-typecompiler'></a>
 
 ### TypeCompiler
 
-The TypeBox TypeCompiler is a high performance JIT compiler that transforms TypeBox types into optimized JavaScript validation routines. The compiler is tuned for fast compilation as well as fast value assertion. It is designed to serve as a validation backend that can be integrated into larger applications; but can also be used as a general purpose validator.
+The TypeBox TypeCompiler is a high performance JIT validation compiler that transforms TypeBox types into optimized JavaScript validation routines. The compiler is tuned for fast compilation as well as fast value assertion. It is built to serve as a validation backend that can be integrated into larger applications. It can also be used for code generation.
 
 The TypeCompiler is provided as an optional import.
 
@@ -1378,7 +1399,7 @@ The TypeCompiler is provided as an optional import.
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 ```
 
-Use the `Compile(...)` function to compile a type. Note that compilation is an expensive operation that should typically be performed once per type during application start up. TypeBox does not cache previously compiled types, so applications are expected to hold references to each compiled type for the lifetime of the application.
+Use the Compile function to JIT compile a type. Note that compilation is generally an expensive operation and should only be performed once per type during application start up. TypeBox does not cache previously compiled types, and applications are expected to hold references to each compiled type for the lifetime of the application.
 
 ```typescript
 const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
@@ -1390,7 +1411,7 @@ const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObje
 const R = C.Check({ x: 1, y: 2, z: 3 })              // const R = true
 ```
 
-Use the `Errors(...)` function to produce diagnostic errors for a value. The `Errors(...)` function will return an iterator that if enumerated; will perform an exhaustive check across the entire value and yield any error found. For performance, this function should only be called after failed `Check(...)`. Applications may also choose to yield only the first value to avoid exhaustive error generation.
+Use the Errors function to generate diagnostic errors for a value. The Errors function will return an iterator that when enumerated; will perform an exhaustive check across the entire value yielding any error found. For performance, this function should only be called after a failed Check. Applications may also choose to yield only the first value to avoid exhaustive error generation.
 
 ```typescript
 const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
@@ -1401,7 +1422,14 @@ const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObje
 
 const value = { }
 
-const errors = [...C.Errors(value)]                  // const errors = [{
+const first = C.Errors(value).First()                // const first = {
+                                                     //   schema: { type: 'number' },
+                                                     //   path: '/x',
+                                                     //   value: undefined,
+                                                     //   message: 'Expected number'
+                                                     // }
+
+const all = [...C.Errors(value)]                     // const all = [{
                                                      //   schema: { type: 'number' },
                                                      //   path: '/x',
                                                      //   value: undefined,
@@ -1419,116 +1447,160 @@ const errors = [...C.Errors(value)]                  // const errors = [{
                                                      // }]
 ```
 
-Compiled routines can be inspected with the `.Code()` function.
+Use the Code function to generate assertion functions as strings. This function can be used to create high performance assertions that can be written to disk as importable modules. The following generates code to check a string.
 
 ```typescript
-const C = TypeCompiler.Compile(Type.String())        // const C: TypeCheck<TString>
-
-console.log(C.Code())                                // return function check(value) {
+const C = TypeCompiler.Code(Type.String())           // const C = `return function check(value) {
                                                      //   return (
                                                      //     (typeof value === 'string')
                                                      //   )
-                                                     // }
+                                                     // }`
 ```
 
 <a name='typesystem'></a>
 
 ## TypeSystem
 
-The TypeBox TypeSystem module provides functionality to define types above and beyond the Standard and Extended type sets as well as control various assertion policies. Configurations made to the TypeSystem module are observed by both `TypeCompiler` and `Value` modules.
-
-The TypeSystem module is provided as an optional import.
-
-```typescript
-import { TypeSystem } from '@sinclair/typebox/system'
-```
+The TypeBox TypeSystem module provides functionality to define types above and beyond the built-in Json and JavaScript type sets. They also manage TypeBox's localization options (i18n) for error message generation and can control various assertion policies used when type checking. Configurations made to the TypeSystem module are observed by the TypeCompiler, Value and Error modules.
 
 <a name='typesystem-types'></a>
 
 ### Types
 
-Use the `Type(...)` function to create custom types. This function lets you specify custom value assertion logic and will return a type factory function which is used to instance the type. This function accepts two generic arguments, the first is the inference type, the second is options used to constrain the type. The following creates a Vector type.
+Use the TypeSystem Type function to register a user defined type.
 
 ```typescript
-type VectorOptions = { abs: boolean }
-
-type Vector = { x: number, y: number }
+import { TypeSystem } from '@sinclair/typebox/system'
 
-const Vector = TypeSystem.Type<Vector, VectorOptions>('Vector', (options, value) => {
-  return (
-    typeof value === 'object' && value !== null &&
-    'x' in value && typeof value.x === 'number' &&
-    'y' in value && typeof value.y === 'number' &&
-    (options.abs ? (value.x === Math.abs(value.x) && value.y === Math.abs(value.y)) : true)
-  )
+const StringSet = TypeSystem.Type<Set<string>>('StringSet', (options, value) => {
+  return value instanceof Set && [...value].every(value => typeof value === 'string')
 })
 
-const T = Vector({ abs: true })
-
-type T = Static<typeof T>                            // type T = Vector
+const T = StringSet({})                              // Pass options if any
 
-const R1 = Value.Check(T, { x: 1, y: 1 })            // const R1 = true
+const A = Value.Check(T, new Set())                  // const A = true
+const B = Value.Check(T, new Set(['hello']))         // const B = true
+const C = Value.Check(T, new Set([1]))               // const C = false
 
-const R2 = Value.Check(T, { x: 1, y: '1' })          // const R2 = false
-
-const R3 = Value.Check(T, { x: 1, y: -1 })           // const R3 = false
 ```
 
 <a name='typesystem-formats'></a>
 
 ### Formats
 
-Use the `Format(...)` function to create a custom string format. The following creates a format that checks for lowercase strings.
+Use the TypeSystem Format function to register a string format.
 
 ```typescript
-TypeSystem.Format('lowercase', value => value === value.toLowerCase()) // format should be lowercase
+import { TypeSystem } from '@sinclair/typebox/system'
+
+const F = TypeSystem.Format('foo', value => value === 'Foo')   
+
+const T = Type.String({ format: F })
+
+const A = Value.Check(T, 'foo')                      // const A = true
+const B = Value.Check(T, 'bar')                      // const B = false
+```
+
+<a name='typesystem-errors'></a>
 
-const T = Type.String({ format: 'lowercase' })
+### Errors
 
-const A = Value.Check(T, 'Hello')                    // const A = false
+Use the TypeSystemErrorFunction to override validation error messages. This can be used to localize errors or create error messages for user defined types.
 
-const B = Value.Check(T, 'hello')                    // const B = true
+```typescript
+import { TypeSystemErrorFunction, ValueErrorType, DefaultErrorFunction } from '@sinclair/typebox/system'
+
+TypeSystemErrorFunction.Set((schema, errorType) => { // i18n override
+  switch(errorType) {
+    /* en-US */ case ValueErrorType.String: return 'Expected string'
+    /* fr-FR */ case ValueErrorType.Number: return 'Nombre attendu'  
+    /* ko-KR */ case ValueErrorType.Boolean: return '예상 부울'      
+    /* en-US */ default: return DefaultErrorFunction(schema, errorType)          
+  }
+})
+const T = Type.Object({                              // const T = { ... }
+  x: Type.String(),
+  y: Type.Number(),
+  z: Type.Boolean()
+})
+const E = [...Value.Errors(T, {                      // const E = [{
+  x: null,                                           //   type: 48,
+  y: null,                                           //   schema: { ... },
+  z: null                                            //   path: '/x',
+})]                                                  //   value: null,
+                                                     //   message: 'Expected string'
+                                                     // }, {
+                                                     //   type: 34,
+                                                     //   schema: { ... },
+                                                     //   path: '/y',
+                                                     //   value: null,
+                                                     //   message: 'Nombre attendu'
+                                                     // }, {
+                                                     //   type: 14,
+                                                     //   schema: { ... },
+                                                     //   path: '/z',
+                                                     //   value: null,
+                                                     //   message: '예상 부울'
+                                                     // }]
 ```
 
 <a name='typesystem-policies'></a>
 
 ### Policies
 
-TypeBox validates using standard JSON Schema assertion policies by default. It is possible to override some of these policies to have TypeBox assert inline with TypeScript static assertion rules. The following policy overrides are available.
+TypeBox validates using standard Json Schema assertion policies by default. The TypeSystemPolicy module can override some of these to have TypeBox check values inline with TypeScript static assertions. It also provides overrides for certain checking rules related to non-serializable values (such as void) which can be useful in Json based protocols such as JsonRpc-2. 
+
+The following overrides are available.
 
 ```typescript
+import { TypeSystemPolicy } from '@sinclair/typebox/system'
+
 // Disallow undefined values for optional properties (default is false)
 //
 // const A: { x?: number } = { x: undefined } - disallowed when enabled
 
-TypeSystem.ExactOptionalPropertyTypes = true
+TypeSystemPolicy.ExactOptionalPropertyTypes = true
 
 // Allow arrays to validate as object types (default is false)
 //
 // const A: {} = [] - allowed in TS
 
-TypeSystem.AllowArrayObjects = true
+TypeSystemPolicy.AllowArrayObject = true
 
 // Allow numeric values to be NaN or + or - Infinity (default is false)
 //
 // const A: number = NaN - allowed in TS
 
-TypeSystem.AllowNaN = true
+TypeSystemPolicy.AllowNaN = true
+
+// Allow void types to check with undefined and null (default is false)
+//
+// Used to signal void return on Json-RPC 2.0 protocol
+
+TypeSystemPolicy.AllowNullVoid = true
 ```
 
 <a name='workbench'></a>
 
 ## TypeBox Workbench
 
-TypeBox offers a small web based code generation tool that can be used to convert TypeScript types into TypeBox types as well as a variety of other runtime type representations.
+TypeBox offers a web based code generation tool that can convert TypeScript types into TypeBox types as well as several other ecosystem libraries.
 
 [TypeBox Workbench Link Here](https://sinclairzx81.github.io/typebox-workbench/)
 
+<a name='codegen'></a>
+
+## TypeBox Codegen
+
+TypeBox provides a code generation library that can be used to automate type translation between TypeScript and TypeBox. This library also includes functionality to transform TypeScript types to other ecosystem libraries.
+
+[TypeBox Codegen Link Here](https://github.com/sinclairzx81/typebox-codegen)
+
 <a name='ecosystem'></a>
 
 ## Ecosystem
 
-The following is a list of community packages that provide general tooling and framework integration support for TypeBox.
+The following is a list of community packages that offer general tooling, extended functionality and framework integration support for TypeBox.
 
 | Package   |  Description |
 | ------------- | ------------- |
@@ -1536,7 +1608,7 @@ The following is a list of community packages that provide general tooling and f
 | [fastify-type-provider-typebox](https://github.com/fastify/fastify-type-provider-typebox) | Fastify TypeBox integration with the Fastify Type Provider |
 | [feathersjs](https://github.com/feathersjs/feathers) | The API and real-time application framework |
 | [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
-| [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from JSON schemas |
+| [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from Json Schemas |
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
 | [typebox-client](https://github.com/flodlc/typebox-client) | Type safe http client library for Fastify |
 | [typebox-validators](https://github.com/jtlapp/typebox-validators) | Advanced validators supporting discriminated and heterogeneous unions |
@@ -1559,35 +1631,35 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │    1000    │ '    232 ms' │ '      8 ms' │ '   29.00 x' │
-│ Literal_Number             │    1000    │ '    179 ms' │ '      6 ms' │ '   29.83 x' │
-│ Literal_Boolean            │    1000    │ '    154 ms' │ '      3 ms' │ '   51.33 x' │
-│ Primitive_Number           │    1000    │ '    160 ms' │ '      7 ms' │ '   22.86 x' │
-│ Primitive_String           │    1000    │ '    149 ms' │ '      6 ms' │ '   24.83 x' │
-│ Primitive_String_Pattern   │    1000    │ '    191 ms' │ '      9 ms' │ '   21.22 x' │
-│ Primitive_Boolean          │    1000    │ '    135 ms' │ '      4 ms' │ '   33.75 x' │
-│ Primitive_Null             │    1000    │ '    144 ms' │ '      6 ms' │ '   24.00 x' │
-│ Object_Unconstrained       │    1000    │ '   1144 ms' │ '     30 ms' │ '   38.13 x' │
-│ Object_Constrained         │    1000    │ '   1228 ms' │ '     24 ms' │ '   51.17 x' │
-│ Object_Vector3             │    1000    │ '    380 ms' │ '      9 ms' │ '   42.22 x' │
-│ Object_Box3D               │    1000    │ '   1771 ms' │ '     30 ms' │ '   59.03 x' │
-│ Tuple_Primitive            │    1000    │ '    471 ms' │ '     11 ms' │ '   42.82 x' │
-│ Tuple_Object               │    1000    │ '   1272 ms' │ '     15 ms' │ '   84.80 x' │
-│ Composite_Intersect        │    1000    │ '    606 ms' │ '     17 ms' │ '   35.65 x' │
-│ Composite_Union            │    1000    │ '    560 ms' │ '     22 ms' │ '   25.45 x' │
-│ Math_Vector4               │    1000    │ '    824 ms' │ '     14 ms' │ '   58.86 x' │
-│ Math_Matrix4               │    1000    │ '    419 ms' │ '      9 ms' │ '   46.56 x' │
-│ Array_Primitive_Number     │    1000    │ '    382 ms' │ '      6 ms' │ '   63.67 x' │
-│ Array_Primitive_String     │    1000    │ '    324 ms' │ '      6 ms' │ '   54.00 x' │
-│ Array_Primitive_Boolean    │    1000    │ '    301 ms' │ '      4 ms' │ '   75.25 x' │
-│ Array_Object_Unconstrained │    1000    │ '   1734 ms' │ '     21 ms' │ '   82.57 x' │
-│ Array_Object_Constrained   │    1000    │ '   1509 ms' │ '     20 ms' │ '   75.45 x' │
-│ Array_Tuple_Primitive      │    1000    │ '    824 ms' │ '     14 ms' │ '   58.86 x' │
-│ Array_Tuple_Object         │    1000    │ '   1619 ms' │ '     16 ms' │ '  101.19 x' │
-│ Array_Composite_Intersect  │    1000    │ '    773 ms' │ '     16 ms' │ '   48.31 x' │
-│ Array_Composite_Union      │    1000    │ '    822 ms' │ '     17 ms' │ '   48.35 x' │
-│ Array_Math_Vector4         │    1000    │ '   1131 ms' │ '     13 ms' │ '   87.00 x' │
-│ Array_Math_Matrix4         │    1000    │ '    661 ms' │ '     10 ms' │ '   66.10 x' │
+│ Literal_String             │    1000    │ '    216 ms' │ '      9 ms' │ '   24.00 x' │
+│ Literal_Number             │    1000    │ '    169 ms' │ '      7 ms' │ '   24.14 x' │
+│ Literal_Boolean            │    1000    │ '    150 ms' │ '      5 ms' │ '   30.00 x' │
+│ Primitive_Number           │    1000    │ '    161 ms' │ '      7 ms' │ '   23.00 x' │
+│ Primitive_String           │    1000    │ '    148 ms' │ '      6 ms' │ '   24.67 x' │
+│ Primitive_String_Pattern   │    1000    │ '    185 ms' │ '      9 ms' │ '   20.56 x' │
+│ Primitive_Boolean          │    1000    │ '    132 ms' │ '      4 ms' │ '   33.00 x' │
+│ Primitive_Null             │    1000    │ '    141 ms' │ '      3 ms' │ '   47.00 x' │
+│ Object_Unconstrained       │    1000    │ '   1109 ms' │ '     30 ms' │ '   36.97 x' │
+│ Object_Constrained         │    1000    │ '   1200 ms' │ '     24 ms' │ '   50.00 x' │
+│ Object_Vector3             │    1000    │ '    379 ms' │ '      9 ms' │ '   42.11 x' │
+│ Object_Box3D               │    1000    │ '   1709 ms' │ '     30 ms' │ '   56.97 x' │
+│ Tuple_Primitive            │    1000    │ '    456 ms' │ '     14 ms' │ '   32.57 x' │
+│ Tuple_Object               │    1000    │ '   1229 ms' │ '     17 ms' │ '   72.29 x' │
+│ Composite_Intersect        │    1000    │ '    570 ms' │ '     17 ms' │ '   33.53 x' │
+│ Composite_Union            │    1000    │ '    513 ms' │ '     19 ms' │ '   27.00 x' │
+│ Math_Vector4               │    1000    │ '    782 ms' │ '     13 ms' │ '   60.15 x' │
+│ Math_Matrix4               │    1000    │ '    393 ms' │ '     12 ms' │ '   32.75 x' │
+│ Array_Primitive_Number     │    1000    │ '    361 ms' │ '     12 ms' │ '   30.08 x' │
+│ Array_Primitive_String     │    1000    │ '    296 ms' │ '      5 ms' │ '   59.20 x' │
+│ Array_Primitive_Boolean    │    1000    │ '    315 ms' │ '      4 ms' │ '   78.75 x' │
+│ Array_Object_Unconstrained │    1000    │ '   1721 ms' │ '     22 ms' │ '   78.23 x' │
+│ Array_Object_Constrained   │    1000    │ '   1450 ms' │ '     21 ms' │ '   69.05 x' │
+│ Array_Tuple_Primitive      │    1000    │ '    813 ms' │ '     13 ms' │ '   62.54 x' │
+│ Array_Tuple_Object         │    1000    │ '   1537 ms' │ '     17 ms' │ '   90.41 x' │
+│ Array_Composite_Intersect  │    1000    │ '    753 ms' │ '     17 ms' │ '   44.29 x' │
+│ Array_Composite_Union      │    1000    │ '    808 ms' │ '     16 ms' │ '   50.50 x' │
+│ Array_Math_Vector4         │    1000    │ '   1118 ms' │ '     16 ms' │ '   69.88 x' │
+│ Array_Math_Matrix4         │    1000    │ '    690 ms' │ '      9 ms' │ '   76.67 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1601,37 +1673,37 @@ This benchmark measures validation performance for varying types. You can review
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │  1000000   │ '     18 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
-│ Literal_Number             │  1000000   │ '     15 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
-│ Literal_Boolean            │  1000000   │ '     13 ms' │ '     16 ms' │ '      9 ms' │ '    1.78 x' │
-│ Primitive_Number           │  1000000   │ '     21 ms' │ '     16 ms' │ '      9 ms' │ '    1.78 x' │
-│ Primitive_String           │  1000000   │ '     19 ms' │ '     16 ms' │ '     10 ms' │ '    1.60 x' │
-│ Primitive_String_Pattern   │  1000000   │ '    150 ms' │ '     41 ms' │ '     35 ms' │ '    1.17 x' │
-│ Primitive_Boolean          │  1000000   │ '     17 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Primitive_Null             │  1000000   │ '     18 ms' │ '     16 ms' │ '      9 ms' │ '    1.78 x' │
-│ Object_Unconstrained       │  1000000   │ '   1001 ms' │ '     31 ms' │ '     24 ms' │ '    1.29 x' │
-│ Object_Constrained         │  1000000   │ '   1288 ms' │ '     50 ms' │ '     36 ms' │ '    1.39 x' │
-│ Object_Vector3             │  1000000   │ '    439 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
-│ Object_Box3D               │  1000000   │ '   2109 ms' │ '     52 ms' │ '     45 ms' │ '    1.16 x' │
-│ Object_Recursive           │  1000000   │ '   5337 ms' │ '    356 ms' │ '    162 ms' │ '    2.20 x' │
-│ Tuple_Primitive            │  1000000   │ '    164 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
-│ Tuple_Object               │  1000000   │ '    744 ms' │ '     29 ms' │ '     18 ms' │ '    1.61 x' │
-│ Composite_Intersect        │  1000000   │ '    764 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
-│ Composite_Union            │  1000000   │ '    516 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
-│ Math_Vector4               │  1000000   │ '    262 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
-│ Math_Matrix4               │  1000000   │ '   1089 ms' │ '     37 ms' │ '     27 ms' │ '    1.37 x' │
-│ Array_Primitive_Number     │  1000000   │ '    276 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
-│ Array_Primitive_String     │  1000000   │ '    228 ms' │ '     21 ms' │ '     14 ms' │ '    1.50 x' │
-│ Array_Primitive_Boolean    │  1000000   │ '    159 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
-│ Array_Object_Unconstrained │  1000000   │ '   5695 ms' │ '     77 ms' │ '     69 ms' │ '    1.12 x' │
-│ Array_Object_Constrained   │  1000000   │ '   5701 ms' │ '    127 ms' │ '    110 ms' │ '    1.15 x' │
-│ Array_Object_Recursive     │  1000000   │ '  21267 ms' │ '   1664 ms' │ '    573 ms' │ '    2.90 x' │
-│ Array_Tuple_Primitive      │  1000000   │ '    702 ms' │ '     40 ms' │ '     32 ms' │ '    1.25 x' │
-│ Array_Tuple_Object         │  1000000   │ '   3141 ms' │ '     68 ms' │ '     51 ms' │ '    1.33 x' │
-│ Array_Composite_Intersect  │  1000000   │ '   3145 ms' │ '     44 ms' │ '     35 ms' │ '    1.26 x' │
-│ Array_Composite_Union      │  1000000   │ '   2134 ms' │ '     68 ms' │ '     31 ms' │ '    2.19 x' │
-│ Array_Math_Vector4         │  1000000   │ '   1197 ms' │ '     37 ms' │ '     25 ms' │ '    1.48 x' │
-│ Array_Math_Matrix4         │  1000000   │ '   5323 ms' │ '    111 ms' │ '     96 ms' │ '    1.16 x' │
+│ Literal_String             │  1000000   │ '     24 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
+│ Literal_Number             │  1000000   │ '     15 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
+│ Literal_Boolean            │  1000000   │ '     14 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
+│ Primitive_Number           │  1000000   │ '     25 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
+│ Primitive_String           │  1000000   │ '     21 ms' │ '     24 ms' │ '      9 ms' │ '    2.67 x' │
+│ Primitive_String_Pattern   │  1000000   │ '    156 ms' │ '     43 ms' │ '     38 ms' │ '    1.13 x' │
+│ Primitive_Boolean          │  1000000   │ '     18 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Primitive_Null             │  1000000   │ '     20 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Object_Unconstrained       │  1000000   │ '   1055 ms' │ '     32 ms' │ '     24 ms' │ '    1.33 x' │
+│ Object_Constrained         │  1000000   │ '   1232 ms' │ '     49 ms' │ '     43 ms' │ '    1.14 x' │
+│ Object_Vector3             │  1000000   │ '    432 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
+│ Object_Box3D               │  1000000   │ '   1993 ms' │ '     54 ms' │ '     46 ms' │ '    1.17 x' │
+│ Object_Recursive           │  1000000   │ '   5115 ms' │ '    342 ms' │ '    159 ms' │ '    2.15 x' │
+│ Tuple_Primitive            │  1000000   │ '    156 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
+│ Tuple_Object               │  1000000   │ '    740 ms' │ '     29 ms' │ '     18 ms' │ '    1.61 x' │
+│ Composite_Intersect        │  1000000   │ '    797 ms' │ '     26 ms' │ '     14 ms' │ '    1.86 x' │
+│ Composite_Union            │  1000000   │ '    530 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
+│ Math_Vector4               │  1000000   │ '    240 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
+│ Math_Matrix4               │  1000000   │ '   1036 ms' │ '     39 ms' │ '     27 ms' │ '    1.44 x' │
+│ Array_Primitive_Number     │  1000000   │ '    248 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
+│ Array_Primitive_String     │  1000000   │ '    227 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
+│ Array_Primitive_Boolean    │  1000000   │ '    138 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
+│ Array_Object_Unconstrained │  1000000   │ '   5540 ms' │ '     66 ms' │ '     59 ms' │ '    1.12 x' │
+│ Array_Object_Constrained   │  1000000   │ '   5750 ms' │ '    123 ms' │ '    108 ms' │ '    1.14 x' │
+│ Array_Object_Recursive     │  1000000   │ '  21842 ms' │ '   1771 ms' │ '    599 ms' │ '    2.96 x' │
+│ Array_Tuple_Primitive      │  1000000   │ '    715 ms' │ '     36 ms' │ '     29 ms' │ '    1.24 x' │
+│ Array_Tuple_Object         │  1000000   │ '   3131 ms' │ '     63 ms' │ '     50 ms' │ '    1.26 x' │
+│ Array_Composite_Intersect  │  1000000   │ '   3064 ms' │ '     44 ms' │ '     35 ms' │ '    1.26 x' │
+│ Array_Composite_Union      │  1000000   │ '   2172 ms' │ '     65 ms' │ '     31 ms' │ '    2.10 x' │
+│ Array_Math_Vector4         │  1000000   │ '   1032 ms' │ '     37 ms' │ '     24 ms' │ '    1.54 x' │
+│ Array_Math_Matrix4         │  1000000   │ '   4859 ms' │ '    114 ms' │ '     86 ms' │ '    1.33 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1645,11 +1717,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '131.4 kb' │ ' 59.4 kb' │  '2.21 x'   │
-│ typebox/errors       │ '113.6 kb' │ ' 50.9 kb' │  '2.23 x'   │
-│ typebox/system       │ ' 78.5 kb' │ ' 32.5 kb' │  '2.42 x'   │
-│ typebox/value        │ '182.8 kb' │ ' 80.0 kb' │  '2.28 x'   │
-│ typebox              │ ' 77.4 kb' │ ' 32.0 kb' │  '2.42 x'   │
+│ typebox/compiler     │ '148.9 kb' │ ' 65.8 kb' │  '2.26 x'   │
+│ typebox/errors       │ '111.5 kb' │ ' 49.1 kb' │  '2.27 x'   │
+│ typebox/system       │ ' 82.6 kb' │ ' 36.8 kb' │  '2.24 x'   │
+│ typebox/value        │ '190.5 kb' │ ' 82.4 kb' │  '2.31 x'   │
+│ typebox              │ ' 72.4 kb' │ ' 31.6 kb' │  '2.29 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 1fd7f1def..d469ccde3 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -26,11 +26,13 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { TypeSystem } from '../system/index'
+import { EncodeTransform, DecodeTransform, HasTransform, TransformDecodeCheckError, TransformEncodeCheckError } from '../value/transform'
+import { IsArray, IsString, IsNumber, IsBigInt } from '../value/guard'
+import { Errors, ValueErrorIterator } from '../errors/errors'
+import { TypeSystemPolicy } from '../system/index'
+import { Deref } from '../value/deref'
+import { Hash } from '../value/hash'
 import * as Types from '../typebox'
-import * as ValueErrors from '../errors/index'
-import * as ValueHash from '../value/hash'
-import * as ValueGuard from '../value/guard'
 
 // -------------------------------------------------------------------
 // CheckFunction
@@ -40,19 +42,33 @@ export type CheckFunction = (value: unknown) => boolean
 // TypeCheck
 // -------------------------------------------------------------------
 export class TypeCheck<T extends Types.TSchema> {
-  constructor(private readonly schema: T, private readonly references: Types.TSchema[], private readonly checkFunc: CheckFunction, private readonly code: string) {}
+  private readonly hasTransform: boolean
+  constructor(private readonly schema: T, private readonly references: Types.TSchema[], private readonly checkFunc: CheckFunction, private readonly code: string) {
+    this.hasTransform = HasTransform.Has(schema, references)
+  }
   /** Returns the generated assertion code used to validate this type. */
   public Code(): string {
     return this.code
   }
   /** Returns an iterator for each error in this value. */
-  public Errors(value: unknown): ValueErrors.ValueErrorIterator {
-    return ValueErrors.Errors(this.schema, this.references, value)
+  public Errors(value: unknown): ValueErrorIterator {
+    return Errors(this.schema, this.references, value)
   }
   /** Returns true if the value matches the compiled type. */
   public Check(value: unknown): value is Types.Static<T> {
     return this.checkFunc(value)
   }
+  /** Decodes a value or throws if error */
+  public Decode(value: unknown): Types.StaticDecode<T> {
+    if (!this.checkFunc(value)) throw new TransformDecodeCheckError(this.schema, value, this.Errors(value).First()!)
+    return this.hasTransform ? DecodeTransform.Decode(this.schema, this.references, value, (_, __, value) => this.Check(value)) : value
+  }
+  /** Encodes a value or throws if error */
+  public Encode(value: unknown): Types.StaticEncode<T> {
+    const encoded = this.hasTransform ? EncodeTransform.Encode(this.schema, this.references, value, (_, __, value) => this.Check(value)) : value
+    if (!this.checkFunc(encoded)) throw new TransformEncodeCheckError(this.schema, value, this.Errors(value).First()!)
+    return encoded
+  }
 }
 // -------------------------------------------------------------------
 // Character
@@ -115,26 +131,43 @@ namespace Identifier {
 // -------------------------------------------------------------------
 // Errors
 // -------------------------------------------------------------------
-export class TypeCompilerUnknownTypeError extends Error {
+export class TypeCompilerUnknownTypeError extends Types.TypeBoxError {
   constructor(public readonly schema: Types.TSchema) {
-    super('TypeCompiler: Unknown type')
+    super('Unknown type')
   }
 }
-export class TypeCompilerDereferenceError extends Error {
-  constructor(public readonly schema: Types.TRef) {
-    super(`TypeCompiler: Unable to dereference type with $id '${schema.$ref}'`)
+export class TypeCompilerTypeGuardError extends Types.TypeBoxError {
+  constructor(public readonly schema: Types.TSchema) {
+    super('Preflight validation check failed to guard for the given schema')
   }
 }
-export class TypeCompilerTypeGuardError extends Error {
-  constructor(public readonly schema: Types.TSchema) {
-    super('TypeCompiler: Preflight validation check failed to guard for the given schema')
+// -------------------------------------------------------------------
+// Policy
+// -------------------------------------------------------------------
+export namespace Policy {
+  export function IsExactOptionalProperty(value: string, key: string, expression: string) {
+    return TypeSystemPolicy.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${MemberExpression.Encode(value, key)} !== undefined ? ${expression} : true)`
+  }
+  export function IsObjectLike(value: string): string {
+    return !TypeSystemPolicy.AllowArrayObject ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`
+  }
+  export function IsRecordLike(value: string): string {
+    return !TypeSystemPolicy.AllowArrayObject
+      ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
+      : `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
+  }
+  export function IsNumberLike(value: string): string {
+    return !TypeSystemPolicy.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`
+  }
+  export function IsVoidLike(value: string): string {
+    return TypeSystemPolicy.AllowNullVoid ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`
   }
 }
 // -------------------------------------------------------------------
 // TypeCompiler
 // -------------------------------------------------------------------
 export type TypeCompilerLanguageOption = 'typescript' | 'javascript'
-export interface TypeCompilerOptions {
+export interface TypeCompilerCodegenOptions {
   language?: TypeCompilerLanguageOption
 }
 /** Compiles Types for Runtime Type Checking */
@@ -146,26 +179,6 @@ export namespace TypeCompiler {
     return schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown'
   }
   // -------------------------------------------------------------------
-  // Polices
-  // -------------------------------------------------------------------
-  function IsExactOptionalProperty(value: string, key: string, expression: string) {
-    return TypeSystem.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${MemberExpression.Encode(value, key)} !== undefined ? ${expression} : true)`
-  }
-  function IsObjectCheck(value: string): string {
-    return !TypeSystem.AllowArrayObjects ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`
-  }
-  function IsRecordCheck(value: string): string {
-    return !TypeSystem.AllowArrayObjects
-      ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
-      : `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
-  }
-  function IsNumberCheck(value: string): string {
-    return !TypeSystem.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`
-  }
-  function IsVoidCheck(value: string): string {
-    return TypeSystem.AllowVoidNull ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`
-  }
-  // -------------------------------------------------------------------
   // Types
   // -------------------------------------------------------------------
   function* TAny(schema: Types.TAny, references: Types.TSchema[], value: string): IterableIterator<string> {
@@ -174,15 +187,15 @@ export namespace TypeCompiler {
   function* TArray(schema: Types.TArray, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `Array.isArray(${value})`
     const [parameter, accumulator] = [CreateParameter('value', 'any'), CreateParameter('acc', 'number')]
-    if (ValueGuard.IsNumber(schema.minItems)) yield `${value}.length >= ${schema.minItems}`
-    if (ValueGuard.IsNumber(schema.maxItems)) yield `${value}.length <= ${schema.maxItems}`
+    if (IsNumber(schema.maxItems)) yield `${value}.length <= ${schema.maxItems}`
+    if (IsNumber(schema.minItems)) yield `${value}.length >= ${schema.minItems}`
     const elementExpression = CreateExpression(schema.items, references, 'value')
     yield `${value}.every((${parameter}) => ${elementExpression})`
-    if (Types.TypeGuard.TSchema(schema.contains) || ValueGuard.IsNumber(schema.minContains) || ValueGuard.IsNumber(schema.maxContains)) {
+    if (Types.TypeGuard.TSchema(schema.contains) || IsNumber(schema.minContains) || IsNumber(schema.maxContains)) {
       const containsSchema = Types.TypeGuard.TSchema(schema.contains) ? schema.contains : Types.Type.Never()
       const checkExpression = CreateExpression(containsSchema, references, 'value')
-      const checkMinContains = ValueGuard.IsNumber(schema.minContains) ? [`(count >= ${schema.minContains})`] : []
-      const checkMaxContains = ValueGuard.IsNumber(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : []
+      const checkMinContains = IsNumber(schema.minContains) ? [`(count >= ${schema.minContains})`] : []
+      const checkMaxContains = IsNumber(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : []
       const checkCount = `const count = ${value}.reduce((${accumulator}, ${parameter}) => ${checkExpression} ? acc + 1 : acc, 0)`
       const check = [`(count > 0)`, ...checkMinContains, ...checkMaxContains].join(' && ')
       yield `((${parameter}) => { ${checkCount}; return ${check}})(${value})`
@@ -198,11 +211,11 @@ export namespace TypeCompiler {
   }
   function* TBigInt(schema: Types.TBigInt, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'bigint')`
-    if (ValueGuard.IsBigInt(schema.multipleOf)) yield `(${value} % BigInt(${schema.multipleOf})) === 0`
-    if (ValueGuard.IsBigInt(schema.exclusiveMinimum)) yield `${value} > BigInt(${schema.exclusiveMinimum})`
-    if (ValueGuard.IsBigInt(schema.exclusiveMaximum)) yield `${value} < BigInt(${schema.exclusiveMaximum})`
-    if (ValueGuard.IsBigInt(schema.minimum)) yield `${value} >= BigInt(${schema.minimum})`
-    if (ValueGuard.IsBigInt(schema.maximum)) yield `${value} <= BigInt(${schema.maximum})`
+    if (IsBigInt(schema.exclusiveMaximum)) yield `${value} < BigInt(${schema.exclusiveMaximum})`
+    if (IsBigInt(schema.exclusiveMinimum)) yield `${value} > BigInt(${schema.exclusiveMinimum})`
+    if (IsBigInt(schema.maximum)) yield `${value} <= BigInt(${schema.maximum})`
+    if (IsBigInt(schema.minimum)) yield `${value} >= BigInt(${schema.minimum})`
+    if (IsBigInt(schema.multipleOf)) yield `(${value} % BigInt(${schema.multipleOf})) === 0`
   }
   function* TBoolean(schema: Types.TBoolean, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'boolean')`
@@ -212,21 +225,22 @@ export namespace TypeCompiler {
   }
   function* TDate(schema: Types.TDate, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`
-    if (ValueGuard.IsNumber(schema.exclusiveMinimumTimestamp)) yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`
-    if (ValueGuard.IsNumber(schema.exclusiveMaximumTimestamp)) yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`
-    if (ValueGuard.IsNumber(schema.minimumTimestamp)) yield `${value}.getTime() >= ${schema.minimumTimestamp}`
-    if (ValueGuard.IsNumber(schema.maximumTimestamp)) yield `${value}.getTime() <= ${schema.maximumTimestamp}`
+    if (IsNumber(schema.exclusiveMaximumTimestamp)) yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`
+    if (IsNumber(schema.exclusiveMinimumTimestamp)) yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`
+    if (IsNumber(schema.maximumTimestamp)) yield `${value}.getTime() <= ${schema.maximumTimestamp}`
+    if (IsNumber(schema.minimumTimestamp)) yield `${value}.getTime() >= ${schema.minimumTimestamp}`
+    if (IsNumber(schema.multipleOfTimestamp)) yield `(${value}.getTime() % ${schema.multipleOfTimestamp}) === 0`
   }
   function* TFunction(schema: Types.TFunction, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'function')`
   }
   function* TInteger(schema: Types.TInteger, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`
-    if (ValueGuard.IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf}) === 0`
-    if (ValueGuard.IsNumber(schema.exclusiveMinimum)) yield `${value} > ${schema.exclusiveMinimum}`
-    if (ValueGuard.IsNumber(schema.exclusiveMaximum)) yield `${value} < ${schema.exclusiveMaximum}`
-    if (ValueGuard.IsNumber(schema.minimum)) yield `${value} >= ${schema.minimum}`
-    if (ValueGuard.IsNumber(schema.maximum)) yield `${value} <= ${schema.maximum}`
+    if (IsNumber(schema.exclusiveMaximum)) yield `${value} < ${schema.exclusiveMaximum}`
+    if (IsNumber(schema.exclusiveMinimum)) yield `${value} > ${schema.exclusiveMinimum}`
+    if (IsNumber(schema.maximum)) yield `${value} <= ${schema.maximum}`
+    if (IsNumber(schema.minimum)) yield `${value} >= ${schema.minimum}`
+    if (IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf}) === 0`
   }
   function* TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: string): IterableIterator<string> {
     const check1 = schema.allOf.map((schema: Types.TSchema) => CreateExpression(schema, references, value)).join(' && ')
@@ -263,17 +277,17 @@ export namespace TypeCompiler {
     yield `(${value} === null)`
   }
   function* TNumber(schema: Types.TNumber, references: Types.TSchema[], value: string): IterableIterator<string> {
-    yield IsNumberCheck(value)
-    if (ValueGuard.IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf}) === 0`
-    if (ValueGuard.IsNumber(schema.exclusiveMinimum)) yield `${value} > ${schema.exclusiveMinimum}`
-    if (ValueGuard.IsNumber(schema.exclusiveMaximum)) yield `${value} < ${schema.exclusiveMaximum}`
-    if (ValueGuard.IsNumber(schema.minimum)) yield `${value} >= ${schema.minimum}`
-    if (ValueGuard.IsNumber(schema.maximum)) yield `${value} <= ${schema.maximum}`
+    yield Policy.IsNumberLike(value)
+    if (IsNumber(schema.exclusiveMaximum)) yield `${value} < ${schema.exclusiveMaximum}`
+    if (IsNumber(schema.exclusiveMinimum)) yield `${value} > ${schema.exclusiveMinimum}`
+    if (IsNumber(schema.maximum)) yield `${value} <= ${schema.maximum}`
+    if (IsNumber(schema.minimum)) yield `${value} >= ${schema.minimum}`
+    if (IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf}) === 0`
   }
   function* TObject(schema: Types.TObject, references: Types.TSchema[], value: string): IterableIterator<string> {
-    yield IsObjectCheck(value)
-    if (ValueGuard.IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
-    if (ValueGuard.IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
+    yield Policy.IsObjectLike(value)
+    if (IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
+    if (IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
     const knownKeys = Object.getOwnPropertyNames(schema.properties)
     for (const knownKey of knownKeys) {
       const memberExpression = MemberExpression.Encode(value, knownKey)
@@ -283,7 +297,7 @@ export namespace TypeCompiler {
         if (Types.ExtendsUndefined.Check(property) || IsAnyOrUnknown(property)) yield `('${knownKey}' in ${value})`
       } else {
         const expression = CreateExpression(property, references, memberExpression)
-        yield IsExactOptionalProperty(value, knownKey, expression)
+        yield Policy.IsExactOptionalProperty(value, knownKey, expression)
       }
     }
     if (schema.additionalProperties === false) {
@@ -304,9 +318,9 @@ export namespace TypeCompiler {
     yield `(typeof value === 'object' && typeof ${value}.then === 'function')`
   }
   function* TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: string): IterableIterator<string> {
-    yield IsRecordCheck(value)
-    if (ValueGuard.IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
-    if (ValueGuard.IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
+    yield Policy.IsRecordLike(value)
+    if (IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
+    if (IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
     const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0]
     const variable = CreateVariable(`new RegExp(/${patternKey}/)`)
     const check1 = CreateExpression(patternSchema, references, 'value')
@@ -315,9 +329,7 @@ export namespace TypeCompiler {
     yield `(Object.entries(${value}).every(([key, value]) => ${expression}))`
   }
   function* TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: string): IterableIterator<string> {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-    if (index === -1) throw new TypeCompilerDereferenceError(schema)
-    const target = references[index]
+    const target = Deref(schema, references)
     // Reference: If we have seen this reference before we can just yield and return the function call.
     // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
     if (state.functions.has(schema.$ref)) return yield `${CreateFunctionName(schema.$ref)}(${value})`
@@ -325,8 +337,8 @@ export namespace TypeCompiler {
   }
   function* TString(schema: Types.TString, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'string')`
-    if (ValueGuard.IsNumber(schema.minLength)) yield `${value}.length >= ${schema.minLength}`
-    if (ValueGuard.IsNumber(schema.maxLength)) yield `${value}.length <= ${schema.maxLength}`
+    if (IsNumber(schema.maxLength)) yield `${value}.length <= ${schema.maxLength}`
+    if (IsNumber(schema.minLength)) yield `${value}.length >= ${schema.minLength}`
     if (schema.pattern !== undefined) {
       const variable = CreateVariable(`${new RegExp(schema.pattern)};`)
       yield `${variable}.test(${value})`
@@ -344,8 +356,8 @@ export namespace TypeCompiler {
     yield `${variable}.test(${value})`
   }
   function* TThis(schema: Types.TThis, references: Types.TSchema[], value: string): IterableIterator<string> {
-    const func = CreateFunctionName(schema.$ref)
-    yield `${func}(${value})`
+    // Note: This types are assured to be hoisted prior to this call. Just yield the function.
+    yield `${CreateFunctionName(schema.$ref)}(${value})`
   }
   function* TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `Array.isArray(${value})`
@@ -365,14 +377,14 @@ export namespace TypeCompiler {
   }
   function* TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield `${value} instanceof Uint8Array`
-    if (ValueGuard.IsNumber(schema.maxByteLength)) yield `(${value}.length <= ${schema.maxByteLength})`
-    if (ValueGuard.IsNumber(schema.minByteLength)) yield `(${value}.length >= ${schema.minByteLength})`
+    if (IsNumber(schema.maxByteLength)) yield `(${value}.length <= ${schema.maxByteLength})`
+    if (IsNumber(schema.minByteLength)) yield `(${value}.length >= ${schema.minByteLength})`
   }
   function* TUnknown(schema: Types.TUnknown, references: Types.TSchema[], value: string): IterableIterator<string> {
     yield 'true'
   }
   function* TVoid(schema: Types.TVoid, references: Types.TSchema[], value: string): IterableIterator<string> {
-    yield IsVoidCheck(value)
+    yield Policy.IsVoidLike(value)
   }
   function* TKind(schema: Types.TSchema, references: Types.TSchema[], value: string): IterableIterator<string> {
     const instance = state.instances.size
@@ -380,12 +392,12 @@ export namespace TypeCompiler {
     yield `kind('${schema[Types.Kind]}', ${instance}, ${value})`
   }
   function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: string, useHoisting: boolean = true): IterableIterator<string> {
-    const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references
+    const references_ = IsString(schema.$id) ? [...references, schema] : references
     const schema_ = schema as any
     // ----------------------------------------------------------------------------------
     // Hoisting
     // ----------------------------------------------------------------------------------
-    if (useHoisting && ValueGuard.IsString(schema.$id)) {
+    if (useHoisting && IsString(schema.$id)) {
       const functionName = CreateFunctionName(schema.$id)
       if (state.functions.has(functionName)) {
         return yield `${functionName}(${value})`
@@ -395,9 +407,6 @@ export namespace TypeCompiler {
         return yield `${functionName}(${value})`
       }
     }
-    // ----------------------------------------------------------------------------------
-    // Types
-    // ----------------------------------------------------------------------------------
     switch (schema_[Types.Kind]) {
       case 'Any':
         return yield* TAny(schema_, references_, value)
@@ -505,29 +514,29 @@ export namespace TypeCompiler {
   // -------------------------------------------------------------------
   // Compile
   // -------------------------------------------------------------------
-  function Build<T extends Types.TSchema>(schema: T, references: Types.TSchema[], options: TypeCompilerOptions): string {
+  function Build<T extends Types.TSchema>(schema: T, references: Types.TSchema[], options: TypeCompilerCodegenOptions): string {
     const functionCode = CreateFunction('check', schema, references, 'value') // will populate functions and variables
     const parameter = CreateParameter('value', 'any')
     const returns = CreateReturns('boolean')
     const functions = [...state.functions.values()]
     const variables = [...state.variables.values()]
     // prettier-ignore
-    const checkFunction = ValueGuard.IsString(schema.$id) // ensure top level schemas with $id's are hoisted
+    const checkFunction = IsString(schema.$id) // ensure top level schemas with $id's are hoisted
       ? `return function check(${parameter})${returns} {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
       : `return ${functionCode}`
     return [...variables, ...functions, checkFunction].join('\n')
   }
-  /** Returns the generated assertion code used to validate this type. */
-  export function Code<T extends Types.TSchema>(schema: T, references: Types.TSchema[], options?: TypeCompilerOptions): string
-  /** Returns the generated assertion code used to validate this type. */
-  export function Code<T extends Types.TSchema>(schema: T, options?: TypeCompilerOptions): string
-  /** Returns the generated assertion code used to validate this type. */
+  /** Generates the code used to assert this type and returns it as a string */
+  export function Code<T extends Types.TSchema>(schema: T, references: Types.TSchema[], options?: TypeCompilerCodegenOptions): string
+  /** Generates the code used to assert this type and returns it as a string */
+  export function Code<T extends Types.TSchema>(schema: T, options?: TypeCompilerCodegenOptions): string
+  /** Generates the code used to assert this type and returns it as a string */
   export function Code(...args: any[]) {
     const defaults = { language: 'javascript' }
     // prettier-ignore
     const [schema, references, options] = (
-      args.length === 2 &&  ValueGuard.IsArray(args[1]) ? [args[0], args[1], defaults] :
-      args.length === 2 && !ValueGuard.IsArray(args[1]) ? [args[0], [], args[1]] :
+      args.length === 2 &&  IsArray(args[1]) ? [args[0], args[1], defaults] :
+      args.length === 2 && !IsArray(args[1]) ? [args[0], [], args[1]] :
       args.length === 3 ? [args[0], args[1], args[2]] :
       args.length === 1 ? [args[0], [], defaults] :
       [null, [], defaults]
@@ -541,15 +550,15 @@ export namespace TypeCompiler {
     for (const schema of references) if (!Types.TypeGuard.TSchema(schema)) throw new TypeCompilerTypeGuardError(schema)
     return Build(schema, references, options)
   }
-  /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
+  /** Compiles a TypeBox type for optimal runtime type checking. Types must be valid TypeBox types of TSchema */
   export function Compile<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []): TypeCheck<T> {
     const generatedCode = Code(schema, references, { language: 'javascript' })
     const compiledFunction = globalThis.Function('kind', 'format', 'hash', generatedCode)
     const instances = new Map(state.instances)
     function typeRegistryFunction(kind: string, instance: number, value: unknown) {
       if (!Types.TypeRegistry.Has(kind) || !instances.has(instance)) return false
-      const schema = instances.get(instance)
       const checkFunc = Types.TypeRegistry.Get(kind)!
+      const schema = instances.get(instance)!
       return checkFunc(schema, value)
     }
     function formatRegistryFunction(format: string, value: string) {
@@ -557,10 +566,10 @@ export namespace TypeCompiler {
       const checkFunc = Types.FormatRegistry.Get(format)!
       return checkFunc(value)
     }
-    function valueHashFunction(value: unknown) {
-      return ValueHash.Hash(value)
+    function hashFunction(value: unknown) {
+      return Hash(value)
     }
-    const checkFunction = compiledFunction(typeRegistryFunction, formatRegistryFunction, valueHashFunction)
+    const checkFunction = compiledFunction(typeRegistryFunction, formatRegistryFunction, hashFunction)
     return new TypeCheck(schema, references, checkFunction, generatedCode)
   }
 }
diff --git a/src/compiler/index.ts b/src/compiler/index.ts
index e747dd76a..cc91cb40b 100644
--- a/src/compiler/index.ts
+++ b/src/compiler/index.ts
@@ -26,5 +26,5 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export { ValueError, ValueErrorType } from '../errors/index'
+export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index'
 export * from './compiler'
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index f7ee21a19..f9b4b4edc 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -26,79 +26,79 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { TypeSystem } from '../system/index'
+import { IsArray, IsUint8Array, IsDate, IsPromise, IsFunction, IsAsyncIterator, IsIterator, IsBoolean, IsNumber, IsBigInt, IsString, IsSymbol, IsInteger, IsNull, IsUndefined } from '../value/guard'
+import { TypeSystemPolicy, TypeSystemErrorFunction } from '../system/system'
+import { Deref } from '../value/deref'
+import { Hash } from '../value/hash'
 import * as Types from '../typebox'
-import * as ValueHash from '../value/hash'
-import * as ValueGuard from '../value/guard'
 
 // --------------------------------------------------------------------------
 // ValueErrorType
 // --------------------------------------------------------------------------
 export enum ValueErrorType {
-  Array,
-  ArrayMinItems,
-  ArrayMaxItems,
   ArrayContains,
-  ArrayMinContains,
   ArrayMaxContains,
+  ArrayMaxItems,
+  ArrayMinContains,
+  ArrayMinItems,
   ArrayUniqueItems,
+  Array,
   AsyncIterator,
-  BigInt,
-  BigIntMultipleOf,
-  BigIntExclusiveMinimum,
   BigIntExclusiveMaximum,
-  BigIntMinimum,
+  BigIntExclusiveMinimum,
   BigIntMaximum,
+  BigIntMinimum,
+  BigIntMultipleOf,
+  BigInt,
   Boolean,
-  Date,
-  DateExclusiveMinimumTimestamp,
   DateExclusiveMaximumTimestamp,
-  DateMinimumTimestamp,
+  DateExclusiveMinimumTimestamp,
   DateMaximumTimestamp,
+  DateMinimumTimestamp,
+  DateMultipleOfTimestamp,
+  Date,
   Function,
-  Integer,
-  IntegerMultipleOf,
-  IntegerExclusiveMinimum,
   IntegerExclusiveMaximum,
-  IntegerMinimum,
+  IntegerExclusiveMinimum,
   IntegerMaximum,
-  Intersect,
+  IntegerMinimum,
+  IntegerMultipleOf,
+  Integer,
   IntersectUnevaluatedProperties,
+  Intersect,
   Iterator,
+  Kind,
   Literal,
   Never,
   Not,
   Null,
-  Number,
-  NumberMultipleOf,
-  NumberExclusiveMinimum,
   NumberExclusiveMaximum,
-  NumberMinimum,
+  NumberExclusiveMinimum,
   NumberMaximum,
-  Object,
-  ObjectMinProperties,
-  ObjectMaxProperties,
+  NumberMinimum,
+  NumberMultipleOf,
+  Number,
   ObjectAdditionalProperties,
-  ObjectRequiredProperties,
+  ObjectMaxProperties,
+  ObjectMinProperties,
+  ObjectRequiredProperty,
+  Object,
   Promise,
-  RecordKeyNumeric,
-  RecordKeyString,
-  String,
-  StringMinLength,
-  StringMaxLength,
-  StringPattern,
   StringFormatUnknown,
   StringFormat,
+  StringMaxLength,
+  StringMinLength,
+  StringPattern,
+  String,
   Symbol,
-  TupleZeroLength,
   TupleLength,
+  Tuple,
+  Uint8ArrayMaxByteLength,
+  Uint8ArrayMinByteLength,
+  Uint8Array,
   Undefined,
   Union,
-  Uint8Array,
-  Uint8ArrayMinByteLength,
-  Uint8ArrayMaxByteLength,
   Void,
-  Kind,
 }
 // --------------------------------------------------------------------------
 // ValueError
@@ -111,6 +111,20 @@ export interface ValueError {
   message: string
 }
 // --------------------------------------------------------------------------
+// ValueErrors
+// --------------------------------------------------------------------------
+export class ValueErrorsUnknownTypeError extends Types.TypeBoxError {
+  constructor(public readonly schema: Types.TSchema) {
+    super('Unknown type')
+  }
+}
+// --------------------------------------------------------------------------
+// Guards
+// --------------------------------------------------------------------------
+function IsDefined<T>(value: unknown): value is T {
+  return value !== undefined
+}
+// --------------------------------------------------------------------------
 // ValueErrorIterator
 // --------------------------------------------------------------------------
 export class ValueErrorIterator {
@@ -125,175 +139,127 @@ export class ValueErrorIterator {
   }
 }
 // --------------------------------------------------------------------------
-// ValueErrors
+// Create
 // --------------------------------------------------------------------------
-export class ValueErrorsUnknownTypeError extends Error {
-  constructor(public readonly schema: Types.TSchema) {
-    super('ValueErrors: Unknown type')
-  }
-}
-export class ValueErrorsDereferenceError extends Error {
-  constructor(public readonly schema: Types.TRef | Types.TThis) {
-    super(`ValueErrors: Unable to dereference type with $id '${schema.$ref}'`)
-  }
-}
-// --------------------------------------------------------------------------
-// Guards
-// --------------------------------------------------------------------------
-function IsDefined<T>(value: unknown): value is T {
-  return value !== undefined
-}
-// --------------------------------------------------------------------------
-// Policies
-// --------------------------------------------------------------------------
-function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string) {
-  return TypeSystem.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined
-}
-function IsObject(value: unknown): value is Record<keyof any, unknown> {
-  const isObject = ValueGuard.IsObject(value)
-  return TypeSystem.AllowArrayObjects ? isObject : isObject && !ValueGuard.IsArray(value)
-}
-function IsRecordObject(value: unknown): value is Record<keyof any, unknown> {
-  return IsObject(value) && !(value instanceof Date) && !(value instanceof Uint8Array)
-}
-function IsNumber(value: unknown): value is number {
-  const isNumber = ValueGuard.IsNumber(value)
-  return TypeSystem.AllowNaN ? isNumber : isNumber && Number.isFinite(value)
-}
-function IsVoid(value: unknown): value is void {
-  const isUndefined = ValueGuard.IsUndefined(value)
-  return TypeSystem.AllowVoidNull ? isUndefined || value === null : isUndefined
+function Create(type: ValueErrorType, schema: Types.TSchema, path: string, value: unknown): ValueError {
+  return { type, schema, path, value, message: TypeSystemErrorFunction.Get()(schema, type) }
 }
 // --------------------------------------------------------------------------
 // Types
 // --------------------------------------------------------------------------
 function* TAny(schema: Types.TAny, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {}
 function* TArray(schema: Types.TArray, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!ValueGuard.IsArray(value)) {
-    return yield { type: ValueErrorType.Array, schema, path, value, message: `Expected array` }
+  if (!IsArray(value)) {
+    return yield Create(ValueErrorType.Array, schema, path, value)
   }
   if (IsDefined<number>(schema.minItems) && !(value.length >= schema.minItems)) {
-    yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be greater or equal to ${schema.minItems}` }
+    yield Create(ValueErrorType.ArrayMinItems, schema, path, value)
   }
   if (IsDefined<number>(schema.maxItems) && !(value.length <= schema.maxItems)) {
-    yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` }
+    yield Create(ValueErrorType.ArrayMaxItems, schema, path, value)
   }
-
   for (let i = 0; i < value.length; i++) {
     yield* Visit(schema.items, references, `${path}/${i}`, value[i])
   }
   // prettier-ignore
-  if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) { const hashed = ValueHash.Hash(element); if (set.has(hashed)) { return false } else { set.add(hashed) } } return true })())) {
-    yield { type: ValueErrorType.ArrayUniqueItems, schema, path, value, message: `Expected array elements to be unique` }
+  if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) { const hashed = Hash(element); if (set.has(hashed)) { return false } else { set.add(hashed) } } return true })())) {
+    yield Create(ValueErrorType.ArrayUniqueItems, schema, path, value)
   }
   // contains
-  if (!(IsDefined(schema.contains) || IsNumber(schema.minContains) || IsNumber(schema.maxContains))) {
+  if (!(IsDefined(schema.contains) || IsDefined(schema.minContains) || IsDefined(schema.maxContains))) {
     return
   }
   const containsSchema = IsDefined<Types.TSchema>(schema.contains) ? schema.contains : Types.Type.Never()
   const containsCount = value.reduce((acc: number, value, index) => (Visit(containsSchema, references, `${path}${index}`, value).next().done === true ? acc + 1 : acc), 0)
   if (containsCount === 0) {
-    yield { type: ValueErrorType.ArrayContains, schema, path, value, message: `Expected array to contain at least one matching type` }
+    yield Create(ValueErrorType.ArrayContains, schema, path, value)
   }
-  if (ValueGuard.IsNumber(schema.minContains) && containsCount < schema.minContains) {
-    yield { type: ValueErrorType.ArrayMinContains, schema, path, value, message: `Expected array to contain at least ${schema.minContains} matching types` }
+  if (IsNumber(schema.minContains) && containsCount < schema.minContains) {
+    yield Create(ValueErrorType.ArrayMinContains, schema, path, value)
   }
-  if (ValueGuard.IsNumber(schema.maxContains) && containsCount > schema.maxContains) {
-    yield { type: ValueErrorType.ArrayMaxContains, schema, path, value, message: `Expected array to contain no more than ${schema.maxContains} matching types` }
+  if (IsNumber(schema.maxContains) && containsCount > schema.maxContains) {
+    yield Create(ValueErrorType.ArrayMaxContains, schema, path, value)
   }
 }
 function* TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!ValueGuard.IsAsyncIterator(value)) {
-    yield { type: ValueErrorType.AsyncIterator, schema, path, value, message: `Expected value to be an async iterator` }
-  }
+  if (!IsAsyncIterator(value)) yield Create(ValueErrorType.AsyncIterator, schema, path, value)
 }
 function* TBigInt(schema: Types.TBigInt, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!ValueGuard.IsBigInt(value)) {
-    return yield { type: ValueErrorType.BigInt, schema, path, value, message: `Expected bigint` }
-  }
-  if (IsDefined<bigint>(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) {
-    yield { type: ValueErrorType.BigIntMultipleOf, schema, path, value, message: `Expected bigint to be a multiple of ${schema.multipleOf}` }
+  if (!IsBigInt(value)) return yield Create(ValueErrorType.BigInt, schema, path, value)
+  if (IsDefined<bigint>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path, value)
   }
   if (IsDefined<bigint>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield { type: ValueErrorType.BigIntExclusiveMinimum, schema, path, value, message: `Expected bigint to be greater than ${schema.exclusiveMinimum}` }
+    yield Create(ValueErrorType.BigIntExclusiveMinimum, schema, path, value)
   }
-  if (IsDefined<bigint>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield { type: ValueErrorType.BigIntExclusiveMaximum, schema, path, value, message: `Expected bigint to be less than ${schema.exclusiveMaximum}` }
+  if (IsDefined<bigint>(schema.maximum) && !(value <= schema.maximum)) {
+    yield Create(ValueErrorType.BigIntMaximum, schema, path, value)
   }
   if (IsDefined<bigint>(schema.minimum) && !(value >= schema.minimum)) {
-    yield { type: ValueErrorType.BigIntMinimum, schema, path, value, message: `Expected bigint to be greater or equal to ${schema.minimum}` }
+    yield Create(ValueErrorType.BigIntMinimum, schema, path, value)
   }
-  if (IsDefined<bigint>(schema.maximum) && !(value <= schema.maximum)) {
-    yield { type: ValueErrorType.BigIntMaximum, schema, path, value, message: `Expected bigint to be less or equal to ${schema.maximum}` }
+  if (IsDefined<bigint>(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) {
+    yield Create(ValueErrorType.BigIntMultipleOf, schema, path, value)
   }
 }
 function* TBoolean(schema: Types.TBoolean, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!ValueGuard.IsBoolean(value)) {
-    return yield { type: ValueErrorType.Boolean, schema, path, value, message: `Expected boolean` }
-  }
+  if (!IsBoolean(value)) yield Create(ValueErrorType.Boolean, schema, path, value)
 }
 function* TConstructor(schema: Types.TConstructor, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
   yield* Visit(schema.returns, references, path, value.prototype)
 }
 function* TDate(schema: Types.TDate, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!ValueGuard.IsDate(value)) {
-    return yield { type: ValueErrorType.Date, schema, path, value, message: `Expected Date object` }
-  }
-  if (!isFinite(value.getTime())) {
-    return yield { type: ValueErrorType.Date, schema, path, value, message: `Invalid Date` }
+  if (!IsDate(value)) return yield Create(ValueErrorType.Date, schema, path, value)
+  if (IsDefined<number>(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+    yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value)
   }
   if (IsDefined<number>(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
-    yield { type: ValueErrorType.DateExclusiveMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater than ${schema.exclusiveMinimum}` }
+    yield Create(ValueErrorType.DateExclusiveMinimumTimestamp, schema, path, value)
   }
-  if (IsDefined<number>(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
-    yield { type: ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less than ${schema.exclusiveMaximum}` }
+  if (IsDefined<number>(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
+    yield Create(ValueErrorType.DateMaximumTimestamp, schema, path, value)
   }
   if (IsDefined<number>(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
-    yield { type: ValueErrorType.DateMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater or equal to ${schema.minimum}` }
+    yield Create(ValueErrorType.DateMinimumTimestamp, schema, path, value)
   }
-  if (IsDefined<number>(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
-    yield { type: ValueErrorType.DateMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less or equal to ${schema.maximum}` }
+  if (IsDefined<number>(schema.multipleOfTimestamp) && !(value.getTime() % schema.multipleOfTimestamp === 0)) {
+    yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path, value)
   }
 }
 function* TFunction(schema: Types.TFunction, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!ValueGuard.IsFunction(value)) {
-    return yield { type: ValueErrorType.Function, schema, path, value, message: `Expected function` }
-  }
+  if (!IsFunction(value)) yield Create(ValueErrorType.Function, schema, path, value)
 }
 function* TInteger(schema: Types.TInteger, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!ValueGuard.IsInteger(value)) {
-    return yield { type: ValueErrorType.Integer, schema, path, value, message: `Expected integer` }
-  }
-  if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-    yield { type: ValueErrorType.IntegerMultipleOf, schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` }
+  if (!IsInteger(value)) return yield Create(ValueErrorType.Integer, schema, path, value)
+  if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path, value)
   }
   if (IsDefined<number>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield { type: ValueErrorType.IntegerExclusiveMinimum, schema, path, value, message: `Expected integer to be greater than ${schema.exclusiveMinimum}` }
+    yield Create(ValueErrorType.IntegerExclusiveMinimum, schema, path, value)
   }
-  if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield { type: ValueErrorType.IntegerExclusiveMaximum, schema, path, value, message: `Expected integer to be less than ${schema.exclusiveMaximum}` }
+  if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
+    yield Create(ValueErrorType.IntegerMaximum, schema, path, value)
   }
   if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
-    yield { type: ValueErrorType.IntegerMinimum, schema, path, value, message: `Expected integer to be greater or equal to ${schema.minimum}` }
+    yield Create(ValueErrorType.IntegerMinimum, schema, path, value)
   }
-  if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
-    yield { type: ValueErrorType.IntegerMaximum, schema, path, value, message: `Expected integer to be less or equal to ${schema.maximum}` }
+  if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    yield Create(ValueErrorType.IntegerMultipleOf, schema, path, value)
   }
 }
 function* TIntersect(schema: Types.TIntersect, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
   for (const inner of schema.allOf) {
     const next = Visit(inner, references, path, value).next()
     if (!next.done) {
+      yield Create(ValueErrorType.Intersect, schema, path, value)
       yield next.value
-      yield { type: ValueErrorType.Intersect, schema, path, value, message: `Expected all sub schemas to be valid` }
-      return
     }
   }
   if (schema.unevaluatedProperties === false) {
     const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema))
     for (const valueKey of Object.getOwnPropertyNames(value)) {
       if (!keyCheck.test(valueKey)) {
-        yield { type: ValueErrorType.IntersectUnevaluatedProperties, schema, path: `${path}/${valueKey}`, value, message: `Unexpected property` }
+        yield Create(ValueErrorType.IntersectUnevaluatedProperties, schema, `${path}/${valueKey}`, value)
       }
     }
   }
@@ -302,93 +268,63 @@ function* TIntersect(schema: Types.TIntersect, references: Types.TSchema[], path
     for (const valueKey of Object.getOwnPropertyNames(value)) {
       if (!keyCheck.test(valueKey)) {
         const next = Visit(schema.unevaluatedProperties, references, `${path}/${valueKey}`, value[valueKey]).next()
-        if (!next.done) {
-          yield next.value
-          yield { type: ValueErrorType.IntersectUnevaluatedProperties, schema, path: `${path}/${valueKey}`, value, message: `Invalid additional property` }
-          return
-        }
+        if (!next.done) yield next.value // yield interior
       }
     }
   }
 }
 function* TIterator(schema: Types.TIterator, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!(IsObject(value) && Symbol.iterator in value)) {
-    yield { type: ValueErrorType.Iterator, schema, path, value, message: `Expected value to be an iterator` }
-  }
+  if (!IsIterator(value)) yield Create(ValueErrorType.Iterator, schema, path, value)
 }
 function* TLiteral(schema: Types.TLiteral, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!(value === schema.const)) {
-    const error = typeof schema.const === 'string' ? `'${schema.const}'` : schema.const
-    return yield { type: ValueErrorType.Literal, schema, path, value, message: `Expected ${error}` }
-  }
+  if (!(value === schema.const)) yield Create(ValueErrorType.Literal, schema, path, value)
 }
 function* TNever(schema: Types.TNever, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  yield { type: ValueErrorType.Never, schema, path, value, message: `Value cannot be validated` }
+  yield Create(ValueErrorType.Never, schema, path, value)
 }
 function* TNot(schema: Types.TNot, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (Visit(schema.not, references, path, value).next().done === true) {
-    yield { type: ValueErrorType.Not, schema, path, value, message: `Value should not validate` }
-  }
+  if (Visit(schema.not, references, path, value).next().done === true) yield Create(ValueErrorType.Not, schema, path, value)
 }
 function* TNull(schema: Types.TNull, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!ValueGuard.IsNull(value)) {
-    return yield { type: ValueErrorType.Null, schema, path, value, message: `Expected null` }
-  }
+  if (!IsNull(value)) yield Create(ValueErrorType.Null, schema, path, value)
 }
 function* TNumber(schema: Types.TNumber, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!IsNumber(value)) {
-    return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` }
-  }
-  if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-    yield { type: ValueErrorType.NumberMultipleOf, schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` }
+  if (!TypeSystemPolicy.IsNumberLike(value)) return yield Create(ValueErrorType.Number, schema, path, value)
+  if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    yield Create(ValueErrorType.NumberExclusiveMaximum, schema, path, value)
   }
   if (IsDefined<number>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield { type: ValueErrorType.NumberExclusiveMinimum, schema, path, value, message: `Expected number to be greater than ${schema.exclusiveMinimum}` }
+    yield Create(ValueErrorType.NumberExclusiveMinimum, schema, path, value)
   }
-  if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield { type: ValueErrorType.NumberExclusiveMaximum, schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` }
+  if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
+    yield Create(ValueErrorType.NumberMaximum, schema, path, value)
   }
   if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
-    yield { type: ValueErrorType.NumberMinimum, schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` }
+    yield Create(ValueErrorType.NumberMinimum, schema, path, value)
   }
-  if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
-    yield { type: ValueErrorType.NumberMaximum, schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` }
+  if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    yield Create(ValueErrorType.NumberMultipleOf, schema, path, value)
   }
 }
 function* TObject(schema: Types.TObject, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!IsObject(value)) {
-    return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` }
-  }
+  if (!TypeSystemPolicy.IsObjectLike(value)) return yield Create(ValueErrorType.Object, schema, path, value)
   if (IsDefined<number>(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-    yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` }
+    yield Create(ValueErrorType.ObjectMinProperties, schema, path, value)
   }
   if (IsDefined<number>(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-    yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have no more than ${schema.maxProperties} properties` }
+    yield Create(ValueErrorType.ObjectMaxProperties, schema, path, value)
   }
   const requiredKeys = Array.isArray(schema.required) ? schema.required : ([] as string[])
   const knownKeys = Object.getOwnPropertyNames(schema.properties)
   const unknownKeys = Object.getOwnPropertyNames(value)
-  for (const knownKey of knownKeys) {
-    const property = schema.properties[knownKey]
-    if (schema.required && schema.required.includes(knownKey)) {
-      yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey])
-      if (Types.ExtendsUndefined.Check(schema) && !(knownKey in value)) {
-        yield { type: ValueErrorType.ObjectRequiredProperties, schema: property, path: `${path}/${knownKey}`, value: undefined, message: `Expected required property` }
-      }
-    } else {
-      if (IsExactOptionalProperty(value, knownKey)) {
-        yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey])
-      }
-    }
-  }
   for (const requiredKey of requiredKeys) {
     if (unknownKeys.includes(requiredKey)) continue
-    yield { type: ValueErrorType.ObjectRequiredProperties, schema: schema.properties[requiredKey], path: `${path}/${requiredKey}`, value: undefined, message: `Expected required property` }
+    yield Create(ValueErrorType.ObjectRequiredProperty, schema.properties[requiredKey], `${path}/${requiredKey}`, undefined)
   }
   if (schema.additionalProperties === false) {
     for (const valueKey of unknownKeys) {
       if (!knownKeys.includes(valueKey)) {
-        yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${valueKey}`, value: value[valueKey], message: `Unexpected property` }
+        yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path}/${valueKey}`, value[valueKey])
       }
     }
   }
@@ -398,101 +334,96 @@ function* TObject(schema: Types.TObject, references: Types.TSchema[], path: stri
       yield* Visit(schema.additionalProperties as Types.TSchema, references, `${path}/${valueKey}`, value[valueKey])
     }
   }
+  for (const knownKey of knownKeys) {
+    const property = schema.properties[knownKey]
+    if (schema.required && schema.required.includes(knownKey)) {
+      yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey])
+      if (Types.ExtendsUndefined.Check(schema) && !(knownKey in value)) {
+        yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path}/${knownKey}`, undefined)
+      }
+    } else {
+      if (TypeSystemPolicy.IsExactOptionalProperty(value, knownKey)) {
+        yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey])
+      }
+    }
+  }
 }
 function* TPromise(schema: Types.TPromise, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!ValueGuard.IsPromise(value)) {
-    yield { type: ValueErrorType.Promise, schema, path, value, message: `Expected Promise` }
-  }
+  if (!IsPromise(value)) yield Create(ValueErrorType.Promise, schema, path, value)
 }
 function* TRecord(schema: Types.TRecord, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!IsRecordObject(value)) {
-    return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected record object` }
-  }
+  if (!TypeSystemPolicy.IsRecordLike(value)) return yield Create(ValueErrorType.Object, schema, path, value)
   if (IsDefined<number>(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-    yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` }
+    yield Create(ValueErrorType.ObjectMinProperties, schema, path, value)
   }
   if (IsDefined<number>(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-    yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have no more than ${schema.maxProperties} properties` }
+    yield Create(ValueErrorType.ObjectMaxProperties, schema, path, value)
   }
   const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0]
   const regex = new RegExp(patternKey)
   for (const [propertyKey, propertyValue] of Object.entries(value)) {
-    if (regex.test(propertyKey)) {
-      yield* Visit(patternSchema, references, `${path}/${propertyKey}`, propertyValue)
-      continue
-    }
-    if (typeof schema.additionalProperties === 'object') {
-      yield* Visit(schema.additionalProperties, references, `${path}/${propertyKey}`, propertyValue)
+    if (regex.test(propertyKey)) yield* Visit(patternSchema, references, `${path}/${propertyKey}`, propertyValue)
+  }
+  if (typeof schema.additionalProperties === 'object') {
+    for (const [propertyKey, propertyValue] of Object.entries(value)) {
+      if (!regex.test(propertyKey)) yield* Visit(schema.additionalProperties as Types.TSchema, references, `${path}/${propertyKey}`, propertyValue)
     }
-    if (schema.additionalProperties === false) {
-      const propertyPath = `${path}/${propertyKey}`
-      const message = `Unexpected property '${propertyPath}'`
-      return yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: propertyPath, value: propertyValue, message }
+  }
+  if (schema.additionalProperties === false) {
+    for (const [propertyKey, propertyValue] of Object.entries(value)) {
+      if (regex.test(propertyKey)) continue
+      return yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path}/${propertyKey}`, propertyValue)
     }
   }
 }
 function* TRef(schema: Types.TRef<any>, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-  if (index === -1) throw new ValueErrorsDereferenceError(schema)
-  const target = references[index]
-  yield* Visit(target, references, path, value)
+  yield* Visit(Deref(schema, references), references, path, value)
 }
 function* TString(schema: Types.TString, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!ValueGuard.IsString(value)) {
-    return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' }
-  }
+  if (!IsString(value)) return yield Create(ValueErrorType.String, schema, path, value)
   if (IsDefined<number>(schema.minLength) && !(value.length >= schema.minLength)) {
-    yield { type: ValueErrorType.StringMinLength, schema, path, value, message: `Expected string length greater or equal to ${schema.minLength}` }
+    yield Create(ValueErrorType.StringMinLength, schema, path, value)
   }
   if (IsDefined<number>(schema.maxLength) && !(value.length <= schema.maxLength)) {
-    yield { type: ValueErrorType.StringMaxLength, schema, path, value, message: `Expected string length less or equal to ${schema.maxLength}` }
+    yield Create(ValueErrorType.StringMaxLength, schema, path, value)
   }
-  if (ValueGuard.IsString(schema.pattern)) {
+  if (IsString(schema.pattern)) {
     const regex = new RegExp(schema.pattern)
     if (!regex.test(value)) {
-      yield { type: ValueErrorType.StringPattern, schema, path, value, message: `Expected string to match pattern ${schema.pattern}` }
+      yield Create(ValueErrorType.StringPattern, schema, path, value)
     }
   }
-  if (ValueGuard.IsString(schema.format)) {
+  if (IsString(schema.format)) {
     if (!Types.FormatRegistry.Has(schema.format)) {
-      yield { type: ValueErrorType.StringFormatUnknown, schema, path, value, message: `Unknown string format '${schema.format}'` }
+      yield Create(ValueErrorType.StringFormatUnknown, schema, path, value)
     } else {
       const format = Types.FormatRegistry.Get(schema.format)!
       if (!format(value)) {
-        yield { type: ValueErrorType.StringFormat, schema, path, value, message: `Expected string to match format '${schema.format}'` }
+        yield Create(ValueErrorType.StringFormat, schema, path, value)
       }
     }
   }
 }
 function* TSymbol(schema: Types.TSymbol, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!ValueGuard.IsSymbol(value)) {
-    return yield { type: ValueErrorType.Symbol, schema, path, value, message: 'Expected symbol' }
-  }
+  if (!IsSymbol(value)) yield Create(ValueErrorType.Symbol, schema, path, value)
 }
 function* TTemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!ValueGuard.IsString(value)) {
-    return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' }
-  }
+  if (!IsString(value)) return yield Create(ValueErrorType.String, schema, path, value)
   const regex = new RegExp(schema.pattern)
   if (!regex.test(value)) {
-    yield { type: ValueErrorType.StringPattern, schema, path, value, message: `Expected string to match pattern ${schema.pattern}` }
+    yield Create(ValueErrorType.StringPattern, schema, path, value)
   }
 }
 function* TThis(schema: Types.TThis, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-  if (index === -1) throw new ValueErrorsDereferenceError(schema)
-  const target = references[index]
-  yield* Visit(target, references, path, value)
+  yield* Visit(Deref(schema, references), references, path, value)
 }
 function* TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!ValueGuard.IsArray(value)) {
-    return yield { type: ValueErrorType.Array, schema, path, value, message: 'Expected Array' }
-  }
+  if (!IsArray(value)) return yield Create(ValueErrorType.Tuple, schema, path, value)
   if (schema.items === undefined && !(value.length === 0)) {
-    return yield { type: ValueErrorType.TupleZeroLength, schema, path, value, message: 'Expected tuple to have 0 elements' }
+    return yield Create(ValueErrorType.TupleLength, schema, path, value)
   }
   if (!(value.length === schema.maxItems)) {
-    yield { type: ValueErrorType.TupleLength, schema, path, value, message: `Expected tuple to have ${schema.maxItems} elements` }
+    return yield Create(ValueErrorType.TupleLength, schema, path, value)
   }
   if (!schema.items) {
     return
@@ -502,46 +433,35 @@ function* TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], path:
   }
 }
 function* TUndefined(schema: Types.TUndefined, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!(value === undefined)) {
-    yield { type: ValueErrorType.Undefined, schema, path, value, message: `Expected undefined` }
-  }
+  if (!IsUndefined(value)) yield Create(ValueErrorType.Undefined, schema, path, value)
 }
 function* TUnion(schema: Types.TUnion, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  const errors: ValueError[] = []
-  for (const inner of schema.anyOf) {
-    const variantErrors = [...Visit(inner, references, path, value)]
-    if (variantErrors.length === 0) return
-    errors.push(...variantErrors)
-  }
-  if (errors.length > 0) {
-    yield { type: ValueErrorType.Union, schema, path, value, message: 'Expected value of union' }
+  let count = 0
+  for (const subschema of schema.anyOf) {
+    const errors = [...Visit(subschema, references, path, value)]
+    if (errors.length === 0) return // matched
+    count += errors.length
   }
-  for (const error of errors) {
-    yield error
+  if (count > 0) {
+    yield Create(ValueErrorType.Union, schema, path, value)
   }
 }
 function* TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!ValueGuard.IsUint8Array(value)) {
-    return yield { type: ValueErrorType.Uint8Array, schema, path, value, message: `Expected Uint8Array` }
-  }
+  if (!IsUint8Array(value)) return yield Create(ValueErrorType.Uint8Array, schema, path, value)
   if (IsDefined<number>(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
-    yield { type: ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length less or equal to ${schema.maxByteLength}` }
+    yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value)
   }
   if (IsDefined<number>(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
-    yield { type: ValueErrorType.Uint8ArrayMinByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length greater or equal to ${schema.maxByteLength}` }
+    yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path, value)
   }
 }
 function* TUnknown(schema: Types.TUnknown, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {}
 function* TVoid(schema: Types.TVoid, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  if (!IsVoid(value)) {
-    return yield { type: ValueErrorType.Void, schema, path, value, message: `Expected void` }
-  }
+  if (!TypeSystemPolicy.IsVoidLike(value)) yield Create(ValueErrorType.Void, schema, path, value)
 }
 function* TKind(schema: Types.TSchema, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
   const check = Types.TypeRegistry.Get(schema[Types.Kind])!
-  if (!check(schema, value)) {
-    return yield { type: ValueErrorType.Kind, schema, path, value, message: `Expected kind ${schema[Types.Kind]}` }
-  }
+  if (!check(schema, value)) yield Create(ValueErrorType.Kind, schema, path, value)
 }
 function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
   const references_ = IsDefined<string>(schema.$id) ? [...references, schema] : references
diff --git a/src/system/system.ts b/src/system/system.ts
index 4b5291fd2..528286259 100644
--- a/src/system/system.ts
+++ b/src/system/system.ts
@@ -26,31 +26,30 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { IsObject, IsArray, IsNumber, IsUndefined } from '../value/guard'
+import { ValueErrorType } from '../errors/errors'
 import * as Types from '../typebox'
 
-export class TypeSystemDuplicateTypeKind extends Error {
+// --------------------------------------------------------------------------
+// Errors
+// --------------------------------------------------------------------------
+export class TypeSystemDuplicateTypeKind extends Types.TypeBoxError {
   constructor(kind: string) {
     super(`Duplicate type kind '${kind}' detected`)
   }
 }
-export class TypeSystemDuplicateFormat extends Error {
+export class TypeSystemDuplicateFormat extends Types.TypeBoxError {
   constructor(kind: string) {
     super(`Duplicate string format '${kind}' detected`)
   }
 }
+// -------------------------------------------------------------------------------------------
+// TypeSystem
+// -------------------------------------------------------------------------------------------
 /** Creates user defined types and formats and provides overrides for value checking behaviours */
 export namespace TypeSystem {
-  /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
-  export let ExactOptionalPropertyTypes: boolean = false
-  /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
-  export let AllowArrayObjects: boolean = false
-  /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
-  export let AllowNaN: boolean = false
-  /** Sets whether `null` should validate for void types. The default is `false` */
-  export let AllowVoidNull: boolean = false
-
   /** Creates a new type */
-  export function Type<Type, Options = object>(kind: string, check: (options: Options, value: unknown) => boolean) {
+  export function Type<Type, Options = Record<PropertyKey, unknown>>(kind: string, check: (options: Options, value: unknown) => boolean) {
     if (Types.TypeRegistry.Has(kind)) throw new TypeSystemDuplicateTypeKind(kind)
     Types.TypeRegistry.Set(kind, check)
     return (options: Partial<Options> = {}) => Types.Type.Unsafe<Type>({ ...options, [Types.Kind]: kind })
@@ -62,3 +61,199 @@ export namespace TypeSystem {
     return format
   }
 }
+// --------------------------------------------------------------------------
+// TypeSystemErrorFunction
+// --------------------------------------------------------------------------
+/** Manages error message providers */
+export namespace TypeSystemErrorFunction {
+  let errorMessageFunction: ErrorFunction = DefaultErrorFunction
+  /** Resets the error message function to en-us */
+  export function Reset() {
+    errorMessageFunction = DefaultErrorFunction
+  }
+  /** Sets the error message function used to generate error messages */
+  export function Set(callback: ErrorFunction) {
+    errorMessageFunction = callback
+  }
+  /** Gets the error message function */
+  export function Get(): ErrorFunction {
+    return errorMessageFunction
+  }
+}
+// --------------------------------------------------------------------------
+// TypeSystemPolicy
+// --------------------------------------------------------------------------
+/** Shared assertion routines used by the value and errors modules */
+export namespace TypeSystemPolicy {
+  /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
+  export let ExactOptionalPropertyTypes: boolean = false
+  /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
+  export let AllowArrayObject: boolean = false
+  /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
+  export let AllowNaN: boolean = false
+  /** Sets whether `null` should validate for void types. The default is `false` */
+  export let AllowNullVoid: boolean = false
+  /** Asserts this value using the ExactOptionalPropertyTypes policy */
+  export function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string) {
+    return ExactOptionalPropertyTypes ? key in value : value[key] !== undefined
+  }
+  /** Asserts this value using the AllowArrayObjects policy */
+  export function IsObjectLike(value: unknown): value is Record<keyof any, unknown> {
+    const isObject = IsObject(value)
+    return AllowArrayObject ? isObject : isObject && !IsArray(value)
+  }
+  /** Asserts this value as a record using the AllowArrayObjects policy */
+  export function IsRecordLike(value: unknown): value is Record<keyof any, unknown> {
+    return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array)
+  }
+  /** Asserts this value using the AllowNaN policy */
+  export function IsNumberLike(value: unknown): value is number {
+    const isNumber = IsNumber(value)
+    return AllowNaN ? isNumber : isNumber && Number.isFinite(value)
+  }
+  /** Asserts this value using the AllowVoidNull policy */
+  export function IsVoidLike(value: unknown): value is void {
+    const isUndefined = IsUndefined(value)
+    return AllowNullVoid ? isUndefined || value === null : isUndefined
+  }
+}
+// --------------------------------------------------------------------------
+// ErrorFunction
+// --------------------------------------------------------------------------
+export type ErrorFunction = (schema: Types.TSchema, type: ValueErrorType) => string
+// --------------------------------------------------------------------------
+// DefaultErrorFunction
+// --------------------------------------------------------------------------
+/** Creates an error message using en-US as the default locale */
+export function DefaultErrorFunction(schema: Types.TSchema, errorType: ValueErrorType) {
+  switch (errorType) {
+    case ValueErrorType.ArrayContains:
+      return 'Expected array to contain at least one matching value'
+    case ValueErrorType.ArrayMaxContains:
+      return `Expected array to contain no more than ${schema.maxContains} matching values`
+    case ValueErrorType.ArrayMinContains:
+      return `Expected array to contain at least ${schema.minContains} matching values`
+    case ValueErrorType.ArrayMaxItems:
+      return `Expected array length to be less or equal to ${schema.maxItems}`
+    case ValueErrorType.ArrayMinItems:
+      return `Expected array length to be greater or equal to ${schema.minItems}`
+    case ValueErrorType.ArrayUniqueItems:
+      return 'Expected array elements to be unique'
+    case ValueErrorType.Array:
+      return 'Expected array'
+    case ValueErrorType.AsyncIterator:
+      return 'Expected AsyncIterator'
+    case ValueErrorType.BigIntExclusiveMaximum:
+      return `Expected bigint to be less than ${schema.exclusiveMaximum}`
+    case ValueErrorType.BigIntExclusiveMinimum:
+      return `Expected bigint to be greater than ${schema.exclusiveMinimum}`
+    case ValueErrorType.BigIntMaximum:
+      return `Expected bigint to be less or equal to ${schema.maximum}`
+    case ValueErrorType.BigIntMinimum:
+      return `Expected bigint to be greater or equal to ${schema.minimum}`
+    case ValueErrorType.BigIntMultipleOf:
+      return `Expected bigint to be a multiple of ${schema.multipleOf}`
+    case ValueErrorType.BigInt:
+      return 'Expected bigint'
+    case ValueErrorType.Boolean:
+      return 'Expected boolean'
+    case ValueErrorType.DateExclusiveMinimumTimestamp:
+      return `Expected Date timestamp to be greater than ${schema.exclusiveMinimumTimestamp}`
+    case ValueErrorType.DateExclusiveMaximumTimestamp:
+      return `Expected Date timestamp to be less than ${schema.exclusiveMaximumTimestamp}`
+    case ValueErrorType.DateMinimumTimestamp:
+      return `Expected Date timestamp to be greater or equal to ${schema.minimumTimestamp}`
+    case ValueErrorType.DateMaximumTimestamp:
+      return `Expected Date timestamp to be less or equal to ${schema.maximumTimestamp}`
+    case ValueErrorType.DateMultipleOfTimestamp:
+      return `Expected Date timestamp to be a multiple of ${schema.multipleOfTimestamp}`
+    case ValueErrorType.Date:
+      return 'Expected Date'
+    case ValueErrorType.Function:
+      return 'Expected function'
+    case ValueErrorType.IntegerExclusiveMaximum:
+      return `Expected integer to be less than ${schema.exclusiveMaximum}`
+    case ValueErrorType.IntegerExclusiveMinimum:
+      return `Expected integer to be greater than ${schema.exclusiveMinimum}`
+    case ValueErrorType.IntegerMaximum:
+      return `Expected integer to be less or equal to ${schema.maximum}`
+    case ValueErrorType.IntegerMinimum:
+      return `Expected integer to be greater or equal to ${schema.minimum}`
+    case ValueErrorType.IntegerMultipleOf:
+      return `Expected integer to be a multiple of ${schema.multipleOf}`
+    case ValueErrorType.Integer:
+      return 'Expected integer'
+    case ValueErrorType.IntersectUnevaluatedProperties:
+      return 'Unexpected property'
+    case ValueErrorType.Intersect:
+      return 'Expected all values to match'
+    case ValueErrorType.Iterator:
+      return 'Expected Iterator'
+    case ValueErrorType.Literal:
+      return `Expected ${typeof schema.const === 'string' ? `'${schema.const}'` : schema.const}`
+    case ValueErrorType.Never:
+      return 'Never'
+    case ValueErrorType.Not:
+      return 'Value should not match'
+    case ValueErrorType.Null:
+      return 'Expected null'
+    case ValueErrorType.NumberExclusiveMaximum:
+      return `Expected number to be less than ${schema.exclusiveMaximum}`
+    case ValueErrorType.NumberExclusiveMinimum:
+      return `Expected number to be greater than ${schema.exclusiveMinimum}`
+    case ValueErrorType.NumberMaximum:
+      return `Expected number to be less or equal to ${schema.maximum}`
+    case ValueErrorType.NumberMinimum:
+      return `Expected number to be greater or equal to ${schema.minimum}`
+    case ValueErrorType.NumberMultipleOf:
+      return `Expected number to be a multiple of ${schema.multipleOf}`
+    case ValueErrorType.Number:
+      return 'Expected number'
+    case ValueErrorType.Object:
+      return 'Expected object'
+    case ValueErrorType.ObjectAdditionalProperties:
+      return 'Unexpected property'
+    case ValueErrorType.ObjectMaxProperties:
+      return `Expected object to have no more than ${schema.maxProperties} properties`
+    case ValueErrorType.ObjectMinProperties:
+      return `Expected object to have at least ${schema.minProperties} properties`
+    case ValueErrorType.ObjectRequiredProperty:
+      return 'Required property'
+    case ValueErrorType.Promise:
+      return 'Expected Promise'
+    case ValueErrorType.StringFormatUnknown:
+      return `Unknown format '${schema.format}'`
+    case ValueErrorType.StringFormat:
+      return `Expected string to match '${schema.format}' format`
+    case ValueErrorType.StringMaxLength:
+      return `Expected string length less or equal to ${schema.maxLength}`
+    case ValueErrorType.StringMinLength:
+      return `Expected string length greater or equal to ${schema.minLength}`
+    case ValueErrorType.StringPattern:
+      return `Expected string to match '${schema.pattern}'`
+    case ValueErrorType.String:
+      return 'Expected string'
+    case ValueErrorType.Symbol:
+      return 'Expected symbol'
+    case ValueErrorType.TupleLength:
+      return `Expected tuple to have ${schema.maxItems || 0} elements`
+    case ValueErrorType.Tuple:
+      return 'Expected tuple'
+    case ValueErrorType.Uint8ArrayMaxByteLength:
+      return `Expected byte length less or equal to ${schema.maxByteLength}`
+    case ValueErrorType.Uint8ArrayMinByteLength:
+      return `Expected byte length greater or equal to ${schema.minByteLength}`
+    case ValueErrorType.Uint8Array:
+      return 'Expected Uint8Array'
+    case ValueErrorType.Undefined:
+      return 'Expected undefined'
+    case ValueErrorType.Union:
+      return 'Expected union value'
+    case ValueErrorType.Void:
+      return 'Expected void'
+    case ValueErrorType.Kind:
+      return `Expected kind '${schema[Types.Kind]}'`
+    default:
+      return 'Unknown error type'
+  }
+}
diff --git a/src/typebox.ts b/src/typebox.ts
index 8f37e240e..412d6412d 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -29,6 +29,7 @@ THE SOFTWARE.
 // --------------------------------------------------------------------------
 // Symbols
 // --------------------------------------------------------------------------
+export const Transform = Symbol.for('TypeBox.Transform')
 export const Readonly = Symbol.for('TypeBox.Readonly')
 export const Optional = Symbol.for('TypeBox.Optional')
 export const Hint = Symbol.for('TypeBox.Hint')
@@ -326,6 +327,8 @@ export interface DateOptions extends SchemaOptions {
   maximumTimestamp?: number
   /** The minimum timestamp value */
   minimumTimestamp?: number
+  /** The multiple of timestamp value */
+  multipleOfTimestamp?: number
 }
 export interface TDate extends TSchema, DateOptions {
   [Kind]: 'Date'
@@ -567,8 +570,11 @@ export type ObjectProperties<T> = T extends TObject<infer U> ? U : never
 export type ObjectPropertyKeys<T> = T extends TObject<infer U> ? keyof U : never
 export type TAdditionalProperties = undefined | TSchema | boolean
 export interface ObjectOptions extends SchemaOptions {
+  /** Additional property constraints for this object */
   additionalProperties?: TAdditionalProperties
+  /** The minimum number of properties allowed on this object */
   minProperties?: number
+  /** The maximum number of properties allowed on this object */
   maxProperties?: number
 }
 export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
@@ -641,16 +647,39 @@ export interface TPromise<T extends TSchema = TSchema> extends TSchema {
 // --------------------------------------------------------------------------
 // TRecord
 // --------------------------------------------------------------------------
-export type RecordTemplateLiteralObjectType<K extends TTemplateLiteral, T extends TSchema> = Ensure<TObject<Evaluate<{ [_ in Static<K>]: T }>>>
-export type RecordTemplateLiteralType<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends true ? RecordTemplateLiteralObjectType<K, T> : TRecord<K, T>
-export type RecordUnionLiteralType<K extends TUnion, T extends TSchema> = Static<K> extends string ? Ensure<TObject<{ [X in Static<K>]: T }>> : never
-export type RecordLiteralType<K extends TLiteral<string | number>, T extends TSchema> = Ensure<TObject<{ [K2 in K['const']]: T }>>
-export type RecordNumberType<K extends TInteger | TNumber, T extends TSchema> = Ensure<TRecord<K, T>>
-export type RecordStringType<K extends TString, T extends TSchema> = Ensure<TRecord<K, T>>
-export type RecordKey = TUnion<TLiteral<string | number>[]> | TLiteral<string | number> | TTemplateLiteral | TInteger | TNumber | TString
-export interface TRecord<K extends RecordKey = RecordKey, T extends TSchema = TSchema> extends TSchema {
+export type TRecordFromUnionLiteralString<K extends TLiteralString, T extends TSchema> = { [_ in K['const']]: T }
+export type TRecordFromUnionLiteralNumber<K extends TLiteralNumber, T extends TSchema> = { [_ in K['const']]: T }
+// prettier-ignore
+export type TRecordFromUnionRest<K extends TSchema[], T extends TSchema> = K extends [infer L, ...infer R] ? (
+  L extends TUnion<infer S> ? TRecordFromUnionRest<S, T> & TRecordFromUnionRest<AssertRest<R>, T> :
+  L extends TLiteralString ? TRecordFromUnionLiteralString<L, T> & TRecordFromUnionRest<AssertRest<R>, T> :
+  L extends TLiteralNumber ? TRecordFromUnionLiteralNumber<L, T> & TRecordFromUnionRest<AssertRest<R>, T> :
+{}) : {}
+export type TRecordFromUnion<K extends TSchema[], T extends TSchema> = Ensure<TObject<AssertProperties<Evaluate<TRecordFromUnionRest<K, T>>>>>
+export type TRecordFromTemplateLiteralKeyInfinite<T extends TSchema> = Ensure<TRecord<TString, T>>
+export type TRecordFromTemplateLiteralKeyFinite<K extends TTemplateLiteral, T extends TSchema, I = Static<K>> = Ensure<TObject<Evaluate<{ [_ in Assert<I, string>]: T }>>>
+// prettier-ignore
+export type TRecordFromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends false 
+  ? TRecordFromTemplateLiteralKeyInfinite<T> 
+  : TRecordFromTemplateLiteralKeyFinite<K, T>
+export type TRecordFromLiteralStringKey<K extends TLiteralString, T extends TSchema> = Ensure<TObject<{ [_ in K['const']]: T }>>
+export type TRecordFromLiteralNumberKey<K extends TLiteralNumber, T extends TSchema> = Ensure<TObject<{ [_ in K['const']]: T }>>
+export type TRecordFromStringKey<K extends TString, T extends TSchema> = Ensure<TRecord<K, T>>
+export type TRecordFromNumberKey<K extends TNumber, T extends TSchema> = Ensure<TRecord<K, T>>
+export type TRecordFromIntegerKey<K extends TInteger, T extends TSchema> = Ensure<TRecord<K, T>>
+// prettier-ignore
+export type TRecordResolve<K extends TSchema, T extends TSchema> = 
+  K extends TUnion<infer S> ? TRecordFromUnion<S, T> :
+  K extends TTemplateLiteral ? TRecordFromTemplateLiteralKey<K, T> :
+  K extends TLiteralString ? TRecordFromLiteralStringKey<K, T> :
+  K extends TLiteralNumber ? TRecordFromLiteralNumberKey<K, T> :
+  K extends TString ? TRecordFromStringKey<K, T> :
+  K extends TNumber ? TRecordFromNumberKey<K, T> :
+  K extends TInteger ? TRecordFromIntegerKey<K, T> :
+  TNever
+export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Record'
-  static: Record<Static<K>, Static<T, this['params']>>
+  static: Record<Assert<Static<K>, string | number>, Static<T, this['params']>>
   type: 'object'
   patternProperties: { [pattern: string]: T }
   additionalProperties: TAdditionalProperties
@@ -679,7 +708,7 @@ export interface TRef<T extends TSchema = TSchema> extends TSchema {
 // --------------------------------------------------------------------------
 // TRest
 // --------------------------------------------------------------------------
-export type TRest<T extends TSchema> = T extends TTuple<infer R> ? Assert<R, TSchema[]> : Assert<[T], TSchema[]>
+export type TRest<T extends TSchema> = T extends TIntersect<infer R> ? R : T extends TUnion<infer R> ? R : T extends TTuple<infer R> ? R : []
 // --------------------------------------------------------------------------
 // TReturnType
 // --------------------------------------------------------------------------
@@ -823,12 +852,52 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
   pattern: string // todo: it may be possible to infer this pattern
 }
 // --------------------------------------------------------------------------
+// TTransform
+// --------------------------------------------------------------------------
+// prettier-ignore
+export type DecodeStaticProperties<T extends TProperties> = {
+  [K in keyof T]: DecodeStaticType<T[K]>
+}
+// prettier-ignore
+export type DecodeStaticRest<T extends TSchema[]> = T extends [infer L, ...infer R]
+  ? [DecodeStaticType<AssertType<L>>, ...DecodeStaticRest<AssertRest<R>>]
+  : []
+// prettier-ignore
+export type DecodeStaticType<T extends TSchema> =
+  T extends TTransform<infer _, infer R>   ? TUnsafe<R> : 
+  T extends TArray<infer S> ? TArray<DecodeStaticType<S>> :
+  T extends TAsyncIterator<infer S> ? TAsyncIterator<DecodeStaticType<S>> :
+  T extends TConstructor<infer P, infer R> ? TConstructor<AssertRest<DecodeStaticRest<P>>, DecodeStaticType<R>> :
+  T extends TFunction<infer P, infer R> ? TFunction<AssertRest<DecodeStaticRest<P>>, DecodeStaticType<R>> :
+  T extends TIntersect<infer S> ? TIntersect<AssertRest<DecodeStaticRest<S>>> :
+  T extends TIterator<infer S> ? TIterator<DecodeStaticType<S>> :
+  T extends TNot<infer S> ? TNot<DecodeStaticType<S>> :
+  T extends TObject<infer S> ? TObject<Evaluate<DecodeStaticProperties<S>>> :
+  T extends TPromise<infer S> ? TPromise<DecodeStaticType<S>> :
+  T extends TRecord<infer K, infer S> ? TRecord<K, DecodeStaticType<S>> :
+  T extends TRecursive<infer S> ? TRecursive<DecodeStaticType<S>> :
+  T extends TRef<infer S> ? TRef<DecodeStaticType<S>> :
+  T extends TTuple<infer S> ? TTuple<AssertRest<DecodeStaticRest<S>>> :
+  T extends TUnion<infer S> ? TUnion<AssertRest<DecodeStaticRest<S>>> :
+  T
+export type TransformFunction<T = any, U = any> = (value: T) => U
+export interface TransformOptions<I extends TSchema = TSchema, O extends unknown = unknown> {
+  Decode: TransformFunction<StaticDecode<I>, O>
+  Encode: TransformFunction<O, StaticDecode<I>>
+}
+export type TTransformResolve<T extends TSchema, P extends unknown[] = []> = T extends TTransform<infer _, infer S> ? S : Static<T, P>
+export interface TTransform<I extends TSchema = TSchema, O extends unknown = unknown> extends TSchema {
+  static: TTransformResolve<I, this['params']>
+  [Transform]: TransformOptions<I, O>
+  [key: string]: any
+}
+// --------------------------------------------------------------------------
 // TTuple
 // --------------------------------------------------------------------------
-export type TTupleInfer<T extends TSchema[], P extends unknown[]> = T extends [infer L, ...infer R] ? [Static<AssertType<L>, P>, ...TTupleInfer<AssertRest<R>, P>] : []
+export type TTupleRest<T extends TSchema[], P extends unknown[]> = T extends [infer L, ...infer R] ? [Static<AssertType<L>, P>, ...TTupleRest<AssertRest<R>, P>] : []
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
   [Kind]: 'Tuple'
-  static: TTupleInfer<T, this['params']> // { [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : T[K] }
+  static: TTupleRest<T, this['params']>
   type: 'array'
   items?: T
   additionalItems?: false
@@ -904,7 +973,11 @@ export interface TVoid extends TSchema {
 // --------------------------------------------------------------------------
 // Static<T>
 // --------------------------------------------------------------------------
-/** Infers a static type from a TypeBox type */
+/** Creates the decoded static form for a TypeBox type */
+export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<DecodeStaticType<T>, P>
+/** Creates the encoded static form for a TypeBox type */
+export type StaticEncode<T extends TSchema, P extends unknown[] = []> = Static<T, P>
+/** Creates the static type for a TypeBox type */
 export type Static<T extends TSchema, P extends unknown[] = []> = (T & { params: P })['static']
 // --------------------------------------------------------------------------
 // TypeRegistry
@@ -939,6 +1012,14 @@ export namespace TypeRegistry {
   }
 }
 // --------------------------------------------------------------------------
+// TypeBoxError
+// --------------------------------------------------------------------------
+export class TypeBoxError extends Error {
+  constructor(message: string) {
+    super(message)
+  }
+}
+// --------------------------------------------------------------------------
 // TypeRegistry
 // --------------------------------------------------------------------------
 export type FormatRegistryValidationFunction = (value: string) => boolean
@@ -973,40 +1054,45 @@ export namespace FormatRegistry {
 // --------------------------------------------------------------------------
 // ValueGuard
 // --------------------------------------------------------------------------
+/** Provides functions to type guard raw JavaScript values */
 export namespace ValueGuard {
-  export function IsObject(value: unknown): value is Record<PropertyKey, unknown> {
-    return typeof value === 'object' && value !== null
-  }
+  /** Returns true if this value is an array */
   export function IsArray(value: unknown): value is unknown[] {
     return Array.isArray(value)
   }
+  /** Returns true if this value is bigint */
+  export function IsBigInt(value: unknown): value is bigint {
+    return typeof value === 'bigint'
+  }
+  /** Returns true if this value is a boolean */
   export function IsBoolean(value: unknown): value is boolean {
     return typeof value === 'boolean'
   }
+  /** Returns true if this value is null */
   export function IsNull(value: unknown): value is null {
     return value === null
   }
-  export function IsUndefined(value: unknown): value is undefined {
-    return value === undefined
-  }
-  export function IsBigInt(value: unknown): value is bigint {
-    return typeof value === 'bigint'
-  }
+  /** Returns true if this value is number */
   export function IsNumber(value: unknown): value is number {
     return typeof value === 'number'
   }
+  /** Returns true if this value is an object */
+  export function IsObject(value: unknown): value is Record<PropertyKey, unknown> {
+    return typeof value === 'object' && value !== null
+  }
+  /** Returns true if this value is string */
   export function IsString(value: unknown): value is string {
     return typeof value === 'string'
   }
+  /** Returns true if this value is undefined */
+  export function IsUndefined(value: unknown): value is undefined {
+    return value === undefined
+  }
 }
 // --------------------------------------------------------------------------
 // TypeGuard
 // --------------------------------------------------------------------------
-export class TypeGuardUnknownTypeError extends Error {
-  constructor(public readonly schema: unknown) {
-    super('TypeGuard: Unknown type')
-  }
-}
+export class TypeGuardUnknownTypeError extends TypeBoxError {}
 /** Provides functions to test if JavaScript values are TypeBox types */
 export namespace TypeGuard {
   function IsPattern(value: unknown): value is string {
@@ -1051,7 +1137,7 @@ export namespace TypeGuard {
   function IsOptionalSchema(value: unknown): value is boolean | undefined {
     return ValueGuard.IsUndefined(value) || TSchema(value)
   }
-  /** Returns true if the given schema is TAny */
+  /** Returns true if the given value is TAny */
   export function TAny(schema: unknown): schema is TAny {
     // prettier-ignore
     return (
@@ -1059,7 +1145,7 @@ export namespace TypeGuard {
       IsOptionalString(schema.$id)
     )
   }
-  /** Returns true if the given schema is TArray */
+  /** Returns true if the given value is TArray */
   export function TArray(schema: unknown): schema is TArray {
     return (
       TKindOf(schema, 'Array') &&
@@ -1074,7 +1160,7 @@ export namespace TypeGuard {
       IsOptionalNumber(schema.maxContains)
     )
   }
-  /** Returns true if the given schema is TAsyncIterator */
+  /** Returns true if the given value is TAsyncIterator */
   export function TAsyncIterator(schema: unknown): schema is TAsyncIterator {
     // prettier-ignore
     return (
@@ -1084,21 +1170,21 @@ export namespace TypeGuard {
       TSchema(schema.items)
     )
   }
-  /** Returns true if the given schema is TBigInt */
+  /** Returns true if the given value is TBigInt */
   export function TBigInt(schema: unknown): schema is TBigInt {
     // prettier-ignore
     return (
       TKindOf(schema, 'BigInt') && 
       schema.type === 'bigint' &&
       IsOptionalString(schema.$id) &&
-      IsOptionalBigInt(schema.multipleOf) &&
-      IsOptionalBigInt(schema.minimum) &&
-      IsOptionalBigInt(schema.maximum) &&
+      IsOptionalBigInt(schema.exclusiveMaximum) &&
       IsOptionalBigInt(schema.exclusiveMinimum) &&
-      IsOptionalBigInt(schema.exclusiveMaximum)
+      IsOptionalBigInt(schema.maximum) &&
+      IsOptionalBigInt(schema.minimum) &&
+      IsOptionalBigInt(schema.multipleOf) 
     )
   }
-  /** Returns true if the given schema is TBoolean */
+  /** Returns true if the given value is TBoolean */
   export function TBoolean(schema: unknown): schema is TBoolean {
     // prettier-ignore
     return (
@@ -1107,86 +1193,70 @@ export namespace TypeGuard {
       IsOptionalString(schema.$id)
     )
   }
-  /** Returns true if the given schema is TConstructor */
+  /** Returns true if the given value is TConstructor */
   export function TConstructor(schema: unknown): schema is TConstructor {
     // prettier-ignore
-    if (!(
+    return (
       TKindOf(schema, 'Constructor') && 
       schema.type === 'constructor' &&
       IsOptionalString(schema.$id) && 
-      ValueGuard.IsArray(schema.parameters) && 
-      TSchema(schema.returns))
-    ) {
-      return false
-    }
-    for (const parameter of schema.parameters) {
-      if (!TSchema(parameter)) return false
-    }
-    return true
+      ValueGuard.IsArray(schema.parameters) &&
+      schema.parameters.every(schema => TSchema(schema)) &&
+      TSchema(schema.returns)
+    )
   }
-  /** Returns true if the given schema is TDate */
+  /** Returns true if the given value is TDate */
   export function TDate(schema: unknown): schema is TDate {
     return (
       TKindOf(schema, 'Date') &&
       schema.type === 'Date' &&
       IsOptionalString(schema.$id) &&
-      IsOptionalNumber(schema.minimumTimestamp) &&
-      IsOptionalNumber(schema.maximumTimestamp) &&
+      IsOptionalNumber(schema.exclusiveMaximumTimestamp) &&
       IsOptionalNumber(schema.exclusiveMinimumTimestamp) &&
-      IsOptionalNumber(schema.exclusiveMaximumTimestamp)
+      IsOptionalNumber(schema.maximumTimestamp) &&
+      IsOptionalNumber(schema.minimumTimestamp) &&
+      IsOptionalNumber(schema.multipleOfTimestamp)
     )
   }
-  /** Returns true if the given schema is TFunction */
+  /** Returns true if the given value is TFunction */
   export function TFunction(schema: unknown): schema is TFunction {
     // prettier-ignore
-    if (!(
+    return (
       TKindOf(schema, 'Function') &&
       schema.type === 'function' &&
       IsOptionalString(schema.$id) && 
       ValueGuard.IsArray(schema.parameters) && 
-      TSchema(schema.returns))
-    ) {
-      return false
-    }
-    for (const parameter of schema.parameters) {
-      if (!TSchema(parameter)) return false
-    }
-    return true
+      schema.parameters.every(schema => TSchema(schema)) &&
+      TSchema(schema.returns)
+    )
   }
-  /** Returns true if the given schema is TInteger */
+  /** Returns true if the given value is TInteger */
   export function TInteger(schema: unknown): schema is TInteger {
     return (
       TKindOf(schema, 'Integer') &&
       schema.type === 'integer' &&
       IsOptionalString(schema.$id) &&
-      IsOptionalNumber(schema.multipleOf) &&
-      IsOptionalNumber(schema.minimum) &&
-      IsOptionalNumber(schema.maximum) &&
+      IsOptionalNumber(schema.exclusiveMaximum) &&
       IsOptionalNumber(schema.exclusiveMinimum) &&
-      IsOptionalNumber(schema.exclusiveMaximum)
+      IsOptionalNumber(schema.maximum) &&
+      IsOptionalNumber(schema.minimum) &&
+      IsOptionalNumber(schema.multipleOf)
     )
   }
-  /** Returns true if the given schema is TIntersect */
+  /** Returns true if the given value is TIntersect */
   export function TIntersect(schema: unknown): schema is TIntersect {
     // prettier-ignore
-    if (!(
+    return (
       TKindOf(schema, 'Intersect') &&
+      (ValueGuard.IsString(schema.type) && schema.type !== 'object' ? false : true) &&
       ValueGuard.IsArray(schema.allOf) && 
+      schema.allOf.every(schema => TSchema(schema) && !TTransform(schema)) &&
       IsOptionalString(schema.type) &&
       (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) &&
-      IsOptionalString(schema.$id))
-    ) {
-      return false
-    }
-    if ('type' in schema && schema.type !== 'object') {
-      return false
-    }
-    for (const inner of schema.allOf) {
-      if (!TSchema(inner)) return false
-    }
-    return true
+      IsOptionalString(schema.$id)
+    )
   }
-  /** Returns true if the given schema is TIterator */
+  /** Returns true if the given value is TIterator */
   export function TIterator(schema: unknown): schema is TIterator {
     // prettier-ignore
     return (
@@ -1196,27 +1266,27 @@ export namespace TypeGuard {
       TSchema(schema.items)
     )
   }
-  /** Returns true if the given schema is a TKind with the given name. */
+  /** Returns true if the given value is a TKind with the given name. */
   export function TKindOf<T extends string>(schema: unknown, kind: T): schema is Record<PropertyKey, unknown> & { [Kind]: T } {
     return TKind(schema) && schema[Kind] === kind
   }
-  /** Returns true if the given schema is TKind */
+  /** Returns true if the given value is TKind */
   export function TKind(schema: unknown): schema is Record<PropertyKey, unknown> & { [Kind]: string } {
     return ValueGuard.IsObject(schema) && Kind in schema && ValueGuard.IsString(schema[Kind])
   }
-  /** Returns true if the given schema is TLiteral<string> */
+  /** Returns true if the given value is TLiteral<string> */
   export function TLiteralString(schema: unknown): schema is TLiteral<string> {
     return TLiteral(schema) && ValueGuard.IsString(schema.const)
   }
-  /** Returns true if the given schema is TLiteral<number> */
+  /** Returns true if the given value is TLiteral<number> */
   export function TLiteralNumber(schema: unknown): schema is TLiteral<number> {
     return TLiteral(schema) && ValueGuard.IsNumber(schema.const)
   }
-  /** Returns true if the given schema is TLiteral<boolean> */
+  /** Returns true if the given value is TLiteral<boolean> */
   export function TLiteralBoolean(schema: unknown): schema is TLiteral<boolean> {
     return TLiteral(schema) && ValueGuard.IsBoolean(schema.const)
   }
-  /** Returns true if the given schema is TLiteral */
+  /** Returns true if the given value is TLiteral */
   export function TLiteral(schema: unknown): schema is TLiteral {
     // prettier-ignore
     return (
@@ -1228,7 +1298,7 @@ export namespace TypeGuard {
       )
     )
   }
-  /** Returns true if the given schema is TNever */
+  /** Returns true if the given value is TNever */
   export function TNever(schema: unknown): schema is TNever {
     // prettier-ignore
     return (
@@ -1237,7 +1307,7 @@ export namespace TypeGuard {
       Object.getOwnPropertyNames(schema.not).length === 0
     )
   }
-  /** Returns true if the given schema is TNot */
+  /** Returns true if the given value is TNot */
   export function TNot(schema: unknown): schema is TNot {
     // prettier-ignore
     return (
@@ -1245,7 +1315,7 @@ export namespace TypeGuard {
       TSchema(schema.not) 
     )
   }
-  /** Returns true if the given schema is TNull */
+  /** Returns true if the given value is TNull */
   export function TNull(schema: unknown): schema is TNull {
     // prettier-ignore
     return (
@@ -1254,41 +1324,34 @@ export namespace TypeGuard {
       IsOptionalString(schema.$id)
     )
   }
-  /** Returns true if the given schema is TNumber */
+  /** Returns true if the given value is TNumber */
   export function TNumber(schema: unknown): schema is TNumber {
     return (
       TKindOf(schema, 'Number') &&
       schema.type === 'number' &&
       IsOptionalString(schema.$id) &&
-      IsOptionalNumber(schema.multipleOf) &&
-      IsOptionalNumber(schema.minimum) &&
-      IsOptionalNumber(schema.maximum) &&
+      IsOptionalNumber(schema.exclusiveMaximum) &&
       IsOptionalNumber(schema.exclusiveMinimum) &&
-      IsOptionalNumber(schema.exclusiveMaximum)
+      IsOptionalNumber(schema.maximum) &&
+      IsOptionalNumber(schema.minimum) &&
+      IsOptionalNumber(schema.multipleOf)
     )
   }
-  /** Returns true if the given schema is TObject */
+  /** Returns true if the given value is TObject */
   export function TObject(schema: unknown): schema is TObject {
-    if (
-      !(
-        TKindOf(schema, 'Object') &&
-        schema.type === 'object' &&
-        IsOptionalString(schema.$id) &&
-        ValueGuard.IsObject(schema.properties) &&
-        IsAdditionalProperties(schema.additionalProperties) &&
-        IsOptionalNumber(schema.minProperties) &&
-        IsOptionalNumber(schema.maxProperties)
-      )
-    ) {
-      return false
-    }
-    for (const [key, value] of Object.entries(schema.properties)) {
-      if (!IsControlCharacterFree(key)) return false
-      if (!TSchema(value)) return false
-    }
-    return true
+    // prettier-ignore
+    return (
+      TKindOf(schema, 'Object') &&
+      schema.type === 'object' &&
+      IsOptionalString(schema.$id) &&
+      ValueGuard.IsObject(schema.properties) &&
+      IsAdditionalProperties(schema.additionalProperties) &&
+      IsOptionalNumber(schema.minProperties) &&
+      IsOptionalNumber(schema.maxProperties) &&
+      Object.entries(schema.properties).every(([key, schema]) => IsControlCharacterFree(key) && TSchema(schema))
+    )
   }
-  /** Returns true if the given schema is TPromise */
+  /** Returns true if the given value is TPromise */
   export function TPromise(schema: unknown): schema is TPromise {
     // prettier-ignore
     return (
@@ -1298,31 +1361,31 @@ export namespace TypeGuard {
       TSchema(schema.item)
     )
   }
-  /** Returns true if the given schema is TRecord */
+  /** Returns true if the given value is TRecord */
   export function TRecord(schema: unknown): schema is TRecord {
     // prettier-ignore
-    if (!(
+    return (
       TKindOf(schema, 'Record') &&
       schema.type === 'object' && 
       IsOptionalString(schema.$id) && 
       IsAdditionalProperties(schema.additionalProperties) &&
-      ValueGuard.IsObject(schema.patternProperties))
-    ) {
-      return false
-    }
-    const keys = Object.getOwnPropertyNames(schema.patternProperties)
-    if (keys.length !== 1) {
-      return false
-    }
-    if (!IsPattern(keys[0])) {
-      return false
-    }
-    if (!TSchema(schema.patternProperties[keys[0]])) {
-      return false
-    }
-    return true
+      ValueGuard.IsObject(schema.patternProperties) &&
+      ((schema: Record<PropertyKey, unknown>) => {
+        const keys = Object.getOwnPropertyNames(schema.patternProperties)
+        return (
+          keys.length === 1 &&
+          IsPattern(keys[0]) &&
+          ValueGuard.IsObject(schema.patternProperties) &&
+          TSchema(schema.patternProperties[keys[0]])
+        )
+      })(schema)
+    )
+  }
+  /** Returns true if this value is TRecursive */
+  export function TRecursive(schema: unknown): schema is { [Hint]: 'Recursive' } {
+    return ValueGuard.IsObject(schema) && Hint in schema && schema[Hint] === 'Recursive'
   }
-  /** Returns true if the given schema is TRef */
+  /** Returns true if the given value is TRef */
   export function TRef(schema: unknown): schema is TRef {
     // prettier-ignore
     return (
@@ -1331,7 +1394,7 @@ export namespace TypeGuard {
       ValueGuard.IsString(schema.$ref)
     )
   }
-  /** Returns true if the given schema is TString */
+  /** Returns true if the given value is TString */
   export function TString(schema: unknown): schema is TString {
     // prettier-ignore
     return (
@@ -1344,7 +1407,7 @@ export namespace TypeGuard {
       IsOptionalFormat(schema.format)
     )
   }
-  /** Returns true if the given schema is TSymbol */
+  /** Returns true if the given value is TSymbol */
   export function TSymbol(schema: unknown): schema is TSymbol {
     // prettier-ignore
     return (
@@ -1353,7 +1416,7 @@ export namespace TypeGuard {
       IsOptionalString(schema.$id)
     )
   }
-  /** Returns true if the given schema is TTemplateLiteral */
+  /** Returns true if the given value is TTemplateLiteral */
   export function TTemplateLiteral(schema: unknown): schema is TTemplateLiteral {
     // prettier-ignore
     return (
@@ -1364,7 +1427,7 @@ export namespace TypeGuard {
       schema.pattern[schema.pattern.length - 1] === '$'
     )
   }
-  /** Returns true if the given schema is TThis */
+  /** Returns true if the given value is TThis */
   export function TThis(schema: unknown): schema is TThis {
     // prettier-ignore
     return (
@@ -1373,31 +1436,31 @@ export namespace TypeGuard {
       ValueGuard.IsString(schema.$ref)
     )
   }
-  /** Returns true if the given schema is TTuple */
+  /** Returns true of this value is TTransform */
+  export function TTransform(schema: unknown): schema is { [Transform]: TransformOptions } {
+    return ValueGuard.IsObject(schema) && Transform in schema
+  }
+  /** Returns true if the given value is TTuple */
   export function TTuple(schema: unknown): schema is TTuple {
     // prettier-ignore
-    if (!(
+    return (
       TKindOf(schema, 'Tuple') &&
       schema.type === 'array' && 
       IsOptionalString(schema.$id) && 
       ValueGuard.IsNumber(schema.minItems) && 
       ValueGuard.IsNumber(schema.maxItems) && 
-      schema.minItems === schema.maxItems)
-    ) {
-      return false
-    }
-    if (ValueGuard.IsUndefined(schema.items) && ValueGuard.IsUndefined(schema.additionalItems) && schema.minItems === 0) {
-      return true
-    }
-    if (!ValueGuard.IsArray(schema.items)) {
-      return false
-    }
-    for (const inner of schema.items) {
-      if (!TSchema(inner)) return false
-    }
-    return true
+      schema.minItems === schema.maxItems &&
+      (( // empty
+        ValueGuard.IsUndefined(schema.items) &&
+        ValueGuard.IsUndefined(schema.additionalItems) &&
+        schema.minItems === 0
+      ) || (
+        ValueGuard.IsArray(schema.items) && 
+        schema.items.every(schema => TSchema(schema))
+      ))
+    )
   }
-  /** Returns true if the given schema is TUndefined */
+  /** Returns true if the given value is TUndefined */
   export function TUndefined(schema: unknown): schema is TUndefined {
     // prettier-ignore
     return (
@@ -1406,26 +1469,22 @@ export namespace TypeGuard {
       IsOptionalString(schema.$id)
     )
   }
-  /** Returns true if the given schema is TUnion<Literal<string | number>[]> */
+  /** Returns true if the given value is TUnion<Literal<string | number>[]> */
   export function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral[]> {
     return TUnion(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema))
   }
-  /** Returns true if the given schema is TUnion */
+  /** Returns true if the given value is TUnion */
   export function TUnion(schema: unknown): schema is TUnion {
     // prettier-ignore
-    if (!(
+    return (
       TKindOf(schema, 'Union') &&
-      ValueGuard.IsArray(schema.anyOf) && 
-      IsOptionalString(schema.$id))
-    ) {
-      return false
-    }
-    for (const inner of schema.anyOf) {
-      if (!TSchema(inner)) return false
-    }
-    return true
+      IsOptionalString(schema.$id) &&
+      ValueGuard.IsObject(schema) &&
+      ValueGuard.IsArray(schema.anyOf) &&
+      schema.anyOf.every(schema => TSchema(schema))
+    )
   }
-  /** Returns true if the given schema is TUint8Array */
+  /** Returns true if the given value is TUint8Array */
   export function TUint8Array(schema: unknown): schema is TUint8Array {
     // prettier-ignore
     return (
@@ -1436,7 +1495,7 @@ export namespace TypeGuard {
       IsOptionalNumber(schema.maxByteLength)
     )
   }
-  /** Returns true if the given schema is TUnknown */
+  /** Returns true if the given value is TUnknown */
   export function TUnknown(schema: unknown): schema is TUnknown {
     // prettier-ignore
     return (
@@ -1444,11 +1503,11 @@ export namespace TypeGuard {
       IsOptionalString(schema.$id)
     )
   }
-  /** Returns true if the given schema is a raw TUnsafe */
+  /** Returns true if the given value is a raw TUnsafe */
   export function TUnsafe(schema: unknown): schema is TUnsafe<unknown> {
     return TKindOf(schema, 'Unsafe')
   }
-  /** Returns true if the given schema is TVoid */
+  /** Returns true if the given value is TVoid */
   export function TVoid(schema: unknown): schema is TVoid {
     // prettier-ignore
     return (
@@ -1457,15 +1516,15 @@ export namespace TypeGuard {
       IsOptionalString(schema.$id)
     )
   }
-  /** Returns true if this schema has the Readonly modifier */
+  /** Returns true if this value has a Readonly symbol */
   export function TReadonly<T extends TSchema>(schema: T): schema is TReadonly<T> {
     return ValueGuard.IsObject(schema) && schema[Readonly] === 'Readonly'
   }
-  /** Returns true if this schema has the Optional modifier */
+  /** Returns true if this value has a Optional symbol */
   export function TOptional<T extends TSchema>(schema: T): schema is TOptional<T> {
     return ValueGuard.IsObject(schema) && schema[Optional] === 'Optional'
   }
-  /** Returns true if the given schema is TSchema */
+  /** Returns true if the given value is TSchema */
   export function TSchema(schema: unknown): schema is TSchema {
     return (
       ValueGuard.IsObject(schema) &&
@@ -1510,24 +1569,21 @@ export namespace TypeGuard {
 /** Fast undefined check used for properties of type undefined */
 export namespace ExtendsUndefined {
   export function Check(schema: TSchema): boolean {
-    if (schema[Kind] === 'Undefined') return true
-    if (schema[Kind] === 'Not') {
-      return !Check(schema.not)
-    }
-    if (schema[Kind] === 'Intersect') {
-      const intersect = schema as TIntersect
-      return intersect.allOf.every((schema) => Check(schema))
-    }
-    if (schema[Kind] === 'Union') {
-      const union = schema as TUnion
-      return union.anyOf.some((schema) => Check(schema))
-    }
-    return false
+    return schema[Kind] === 'Intersect'
+      ? (schema as TIntersect).allOf.every((schema) => Check(schema))
+      : schema[Kind] === 'Union'
+      ? (schema as TUnion).anyOf.some((schema) => Check(schema))
+      : schema[Kind] === 'Undefined'
+      ? true
+      : schema[Kind] === 'Not'
+      ? !Check(schema.not)
+      : false
   }
 }
 // --------------------------------------------------------------------------
 // TypeExtends
 // --------------------------------------------------------------------------
+export class TypeExtendsError extends TypeBoxError {}
 export enum TypeExtendsResult {
   Union,
   True,
@@ -1538,7 +1594,13 @@ export namespace TypeExtends {
   // IntoBooleanResult
   // --------------------------------------------------------------------------
   function IntoBooleanResult(result: TypeExtendsResult) {
-    return result === TypeExtendsResult.False ? TypeExtendsResult.False : TypeExtendsResult.True
+    return result === TypeExtendsResult.False ? result : TypeExtendsResult.True
+  }
+  // --------------------------------------------------------------------------
+  // Throw
+  // --------------------------------------------------------------------------
+  function Throw(message: string): never {
+    throw new TypeExtendsError(message)
   }
   // --------------------------------------------------------------------------
   // StructuralRight
@@ -1554,12 +1616,15 @@ export namespace TypeExtends {
     )
   }
   function StructuralRight(left: TSchema, right: TSchema) {
-    if (TypeGuard.TNever(right)) return TNeverRight(left, right)
-    if (TypeGuard.TIntersect(right)) return TIntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return TUnionRight(left, right)
-    if (TypeGuard.TUnknown(right)) return TUnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return TAnyRight(left, right)
-    throw Error('TypeExtends: StructuralRight')
+    // prettier-ignore
+    return (
+      TypeGuard.TNever(right) ? TNeverRight(left, right) :
+      TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
+      TypeGuard.TUnion(right) ? TUnionRight(left, right) :
+      TypeGuard.TUnknown(right) ? TUnknownRight(left, right) :
+      TypeGuard.TAny(right) ? TAnyRight(left, right) :
+      Throw('StructuralRight')
+    )
   }
   // --------------------------------------------------------------------------
   // Any
@@ -1568,135 +1633,181 @@ export namespace TypeExtends {
     return TypeExtendsResult.True
   }
   function TAny(left: TAny, right: TSchema) {
-    if (TypeGuard.TIntersect(right)) return TIntersectRight(left, right)
-    if (TypeGuard.TUnion(right) && right.anyOf.some((schema) => TypeGuard.TAny(schema) || TypeGuard.TUnknown(schema))) return TypeExtendsResult.True
-    if (TypeGuard.TUnion(right)) return TypeExtendsResult.Union
-    if (TypeGuard.TUnknown(right)) return TypeExtendsResult.True
-    if (TypeGuard.TAny(right)) return TypeExtendsResult.True
-    return TypeExtendsResult.Union
+    // prettier-ignore
+    return (
+      TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
+      (TypeGuard.TUnion(right) && right.anyOf.some((schema) => TypeGuard.TAny(schema) || TypeGuard.TUnknown(schema))) ? TypeExtendsResult.True :
+      TypeGuard.TUnion(right) ? TypeExtendsResult.Union  :
+      TypeGuard.TUnknown(right) ? TypeExtendsResult.True :
+      TypeGuard.TAny(right) ? TypeExtendsResult.True :
+      TypeExtendsResult.Union
+    )
   }
   // --------------------------------------------------------------------------
   // Array
   // --------------------------------------------------------------------------
   function TArrayRight(left: TSchema, right: TArray) {
-    if (TypeGuard.TUnknown(left)) return TypeExtendsResult.False
-    if (TypeGuard.TAny(left)) return TypeExtendsResult.Union
-    if (TypeGuard.TNever(left)) return TypeExtendsResult.True
-    return TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      TypeGuard.TUnknown(left) ? TypeExtendsResult.False :
+      TypeGuard.TAny(left) ?TypeExtendsResult.Union :
+      TypeGuard.TNever(left) ? TypeExtendsResult.True :
+      TypeExtendsResult.False
+    )
   }
   function TArray(left: TArray, right: TSchema) {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right) && IsObjectArrayLike(right)) return TypeExtendsResult.True
-    if (!TypeGuard.TArray(right)) return TypeExtendsResult.False
-    return IntoBooleanResult(Visit(left.items, right.items))
+    // prettier-ignore
+    return (
+      TypeGuard.TObject(right) && IsObjectArrayLike(right) ? TypeExtendsResult.True :
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      !TypeGuard.TArray(right) ? TypeExtendsResult.False :
+      IntoBooleanResult(Visit(left.items, right.items))
+    )
   }
   // --------------------------------------------------------------------------
   // AsyncIterator
   // --------------------------------------------------------------------------
   function TAsyncIterator(left: TAsyncIterator, right: TSchema) {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (!TypeGuard.TAsyncIterator(right)) return TypeExtendsResult.False
-    return IntoBooleanResult(Visit(left.items, right.items))
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      !TypeGuard.TAsyncIterator(right) ? TypeExtendsResult.False :
+      IntoBooleanResult(Visit(left.items, right.items))
+    )
   }
   // --------------------------------------------------------------------------
   // BigInt
   // --------------------------------------------------------------------------
   function TBigInt(left: TBigInt, right: TSchema): TypeExtendsResult {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
-    return TypeGuard.TBigInt(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TObject(right) ? TObjectRight(left, right) :
+      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+      TypeGuard.TBigInt(right) ? TypeExtendsResult.True : 
+      TypeExtendsResult.False
+    )
   }
   // --------------------------------------------------------------------------
   // Boolean
   // --------------------------------------------------------------------------
   function TBooleanRight(left: TSchema, right: TBoolean) {
-    if (TypeGuard.TLiteral(left) && ValueGuard.IsBoolean(left.const)) return TypeExtendsResult.True
-    return TypeGuard.TBoolean(left) ? TypeExtendsResult.True : TypeExtendsResult.False
+    return TypeGuard.TLiteral(left) && ValueGuard.IsBoolean(left.const) ? TypeExtendsResult.True : TypeGuard.TBoolean(left) ? TypeExtendsResult.True : TypeExtendsResult.False
   }
   function TBoolean(left: TBoolean, right: TSchema): TypeExtendsResult {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
-    return TypeGuard.TBoolean(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TObject(right) ? TObjectRight(left, right) :
+      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+      TypeGuard.TBoolean(right) ? TypeExtendsResult.True : 
+      TypeExtendsResult.False
+    )
   }
   // --------------------------------------------------------------------------
   // Constructor
   // --------------------------------------------------------------------------
   function TConstructor(left: TConstructor, right: TSchema) {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
-    if (!TypeGuard.TConstructor(right)) return TypeExtendsResult.False
-    if (left.parameters.length > right.parameters.length) return TypeExtendsResult.False
-    if (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) {
-      return TypeExtendsResult.False
-    }
-    return IntoBooleanResult(Visit(left.returns, right.returns))
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TObject(right) ? TObjectRight(left, right) :
+      !TypeGuard.TConstructor(right) ? TypeExtendsResult.False :
+      left.parameters.length > right.parameters.length ? TypeExtendsResult.False :
+      (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) ? TypeExtendsResult.False :
+      IntoBooleanResult(Visit(left.returns, right.returns))
+    )
   }
   // --------------------------------------------------------------------------
   // Date
   // --------------------------------------------------------------------------
   function TDate(left: TDate, right: TSchema) {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
-    return TypeGuard.TDate(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TObject(right) ? TObjectRight(left, right) :
+      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+      TypeGuard.TDate(right) ? TypeExtendsResult.True : 
+      TypeExtendsResult.False
+    )
   }
   // --------------------------------------------------------------------------
   // Function
   // --------------------------------------------------------------------------
   function TFunction(left: TFunction, right: TSchema) {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
-    if (!TypeGuard.TFunction(right)) return TypeExtendsResult.False
-    if (left.parameters.length > right.parameters.length) return TypeExtendsResult.False
-    if (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) {
-      return TypeExtendsResult.False
-    }
-    return IntoBooleanResult(Visit(left.returns, right.returns))
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TObject(right) ? TObjectRight(left, right) :
+      !TypeGuard.TFunction(right) ? TypeExtendsResult.False :
+      left.parameters.length > right.parameters.length ? TypeExtendsResult.False :
+      (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) ? TypeExtendsResult.False :
+      IntoBooleanResult(Visit(left.returns, right.returns))
+    )
   }
   // --------------------------------------------------------------------------
   // Integer
   // --------------------------------------------------------------------------
   function TIntegerRight(left: TSchema, right: TInteger) {
-    if (TypeGuard.TLiteral(left) && ValueGuard.IsNumber(left.const)) return TypeExtendsResult.True
-    return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      TypeGuard.TLiteral(left) && ValueGuard.IsNumber(left.const) ? TypeExtendsResult.True :
+      TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : 
+      TypeExtendsResult.False
+    )
   }
   function TInteger(left: TInteger, right: TSchema): TypeExtendsResult {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
-    return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : 
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TObject(right) ? TObjectRight(left, right) :
+      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+      TypeExtendsResult.False
+    )
   }
   // --------------------------------------------------------------------------
   // Intersect
   // --------------------------------------------------------------------------
   function TIntersectRight(left: TSchema, right: TIntersect): TypeExtendsResult {
-    return right.allOf.every((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return right.allOf.every((schema) => Visit(left, schema) === TypeExtendsResult.True) 
+      ? TypeExtendsResult.True 
+      : TypeExtendsResult.False
   }
   function TIntersect(left: TIntersect, right: TSchema) {
-    return left.allOf.some((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return left.allOf.some((schema) => Visit(schema, right) === TypeExtendsResult.True) 
+      ? TypeExtendsResult.True 
+      : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
   // Iterator
   // --------------------------------------------------------------------------
   function TIterator(left: TIterator, right: TSchema) {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (!TypeGuard.TIterator(right)) return TypeExtendsResult.False
-    return IntoBooleanResult(Visit(left.items, right.items))
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      !TypeGuard.TIterator(right) ? TypeExtendsResult.False :
+      IntoBooleanResult(Visit(left.items, right.items))
+    )
   }
   // --------------------------------------------------------------------------
   // Literal
   // --------------------------------------------------------------------------
   function TLiteral(left: TLiteral, right: TSchema): TypeExtendsResult {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
-    if (TypeGuard.TString(right)) return TStringRight(left, right)
-    if (TypeGuard.TNumber(right)) return TNumberRight(left, right)
-    if (TypeGuard.TInteger(right)) return TIntegerRight(left, right)
-    if (TypeGuard.TBoolean(right)) return TBooleanRight(left, right)
-    return TypeGuard.TLiteral(right) && right.const === left.const ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      TypeGuard.TLiteral(right) && right.const === left.const ? TypeExtendsResult.True : 
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TObject(right) ? TObjectRight(left, right) :
+      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+      TypeGuard.TString(right) ? TStringRight(left, right) :
+      TypeGuard.TNumber(right) ? TNumberRight(left, right) :
+      TypeGuard.TInteger(right) ? TIntegerRight(left, right) :
+      TypeGuard.TBoolean(right) ? TBooleanRight(left, right) :
+      TypeExtendsResult.False
+    )
   }
   // --------------------------------------------------------------------------
   // Never
@@ -1723,31 +1834,46 @@ export namespace TypeExtends {
     // TypeScript has no concept of negated types, and attempts to correctly check the negated
     // type at runtime would put TypeBox at odds with TypeScripts ability to statically infer
     // the type. Instead we unwrap to either unknown or T and continue evaluating.
-    if (TypeGuard.TNot(left)) return Visit(UnwrapTNot(left), right)
-    if (TypeGuard.TNot(right)) return Visit(left, UnwrapTNot(right))
-    throw new Error(`TypeExtends: Invalid fallthrough for Not`)
+    // prettier-ignore
+    return (
+      TypeGuard.TNot(left) ? Visit(UnwrapTNot(left), right) :
+      TypeGuard.TNot(right) ? Visit(left, UnwrapTNot(right)) :
+      Throw('Invalid fallthrough for Not')
+    )
   }
   // --------------------------------------------------------------------------
   // Null
   // --------------------------------------------------------------------------
   function TNull(left: TNull, right: TSchema) {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
-    return TypeGuard.TNull(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TObject(right) ? TObjectRight(left, right) :
+      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+      TypeGuard.TNull(right) ? TypeExtendsResult.True : 
+      TypeExtendsResult.False
+    )
   }
   // --------------------------------------------------------------------------
   // Number
   // --------------------------------------------------------------------------
   function TNumberRight(left: TSchema, right: TNumber) {
-    if (TypeGuard.TLiteralNumber(left)) return TypeExtendsResult.True
-    return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      TypeGuard.TLiteralNumber(left) ? TypeExtendsResult.True :
+      TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : 
+      TypeExtendsResult.False
+    )
   }
   function TNumber(left: TNumber, right: TSchema): TypeExtendsResult {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
-    return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TObject(right) ? TObjectRight(left, right) :
+      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+      TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : 
+      TypeExtendsResult.False
+    )
   }
   // --------------------------------------------------------------------------
   // Object
@@ -1804,117 +1930,156 @@ export namespace TypeExtends {
   // Property
   // --------------------------------------------------------------------------
   function Property(left: TSchema, right: TSchema) {
-    if (Visit(left, right) === TypeExtendsResult.False) return TypeExtendsResult.False
-    if (TypeGuard.TOptional(left) && !TypeGuard.TOptional(right)) return TypeExtendsResult.False
-    return TypeExtendsResult.True
+    // prettier-ignore
+    return (
+      Visit(left, right) === TypeExtendsResult.False ? TypeExtendsResult.False :
+      TypeGuard.TOptional(left) && !TypeGuard.TOptional(right) ? TypeExtendsResult.False :
+      TypeExtendsResult.True
+    )
   }
   function TObjectRight(left: TSchema, right: TObject) {
-    if (TypeGuard.TUnknown(left)) return TypeExtendsResult.False
-    if (TypeGuard.TAny(left)) return TypeExtendsResult.Union
-    if (TypeGuard.TNever(left)) return TypeExtendsResult.True
-    if (TypeGuard.TLiteralString(left) && IsObjectStringLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TLiteralNumber(left) && IsObjectNumberLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TLiteralBoolean(left) && IsObjectBooleanLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TBigInt(left) && IsObjectBigIntLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TString(left) && IsObjectStringLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TNumber(left) && IsObjectNumberLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TInteger(left) && IsObjectNumberLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TBoolean(left) && IsObjectBooleanLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TUint8Array(left) && IsObjectUint8ArrayLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TDate(left) && IsObjectDateLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TConstructor(left) && IsObjectConstructorLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TFunction(left) && IsObjectFunctionLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TRecord(left) && TypeGuard.TString(RecordKey(left))) {
-      // When expressing a Record with literal key values, the Record is converted into a Object with
-      // the Hint assigned as `Record`. This is used to invert the extends logic.
-      return right[Hint] === 'Record' ? TypeExtendsResult.True : TypeExtendsResult.False
-    }
-    if (TypeGuard.TRecord(left) && TypeGuard.TNumber(RecordKey(left))) {
-      return IsObjectPropertyCount(right, 0) ? TypeExtendsResult.True : TypeExtendsResult.False
-    }
-    return TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      TypeGuard.TUnknown(left) ? TypeExtendsResult.False :
+      TypeGuard.TAny(left) ? TypeExtendsResult.Union : (
+        TypeGuard.TNever(left) ||
+        (TypeGuard.TLiteralString(left) && IsObjectStringLike(right)) ||
+        (TypeGuard.TLiteralNumber(left) && IsObjectNumberLike(right)) ||
+        (TypeGuard.TLiteralBoolean(left) && IsObjectBooleanLike(right)) ||
+        (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right)) ||
+        (TypeGuard.TBigInt(left) && IsObjectBigIntLike(right)) ||
+        (TypeGuard.TString(left) && IsObjectStringLike(right)) ||
+        (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right)) ||
+        (TypeGuard.TNumber(left) && IsObjectNumberLike(right)) ||
+        (TypeGuard.TInteger(left) && IsObjectNumberLike(right)) ||
+        (TypeGuard.TBoolean(left) && IsObjectBooleanLike(right)) ||
+        (TypeGuard.TUint8Array(left) && IsObjectUint8ArrayLike(right)) ||
+        (TypeGuard.TDate(left) && IsObjectDateLike(right)) ||
+        (TypeGuard.TConstructor(left) && IsObjectConstructorLike(right)) ||
+        (TypeGuard.TFunction(left) && IsObjectFunctionLike(right)) 
+      ) ? TypeExtendsResult.True :
+      (TypeGuard.TRecord(left) && TypeGuard.TString(RecordKey(left))) ? (() => {
+        // When expressing a Record with literal key values, the Record is converted into a Object with
+        // the Hint assigned as `Record`. This is used to invert the extends logic.
+        return right[Hint] === 'Record' ? TypeExtendsResult.True : TypeExtendsResult.False
+      })() :
+      (TypeGuard.TRecord(left) && TypeGuard.TNumber(RecordKey(left))) ? (() => {
+        return IsObjectPropertyCount(right, 0) 
+          ? TypeExtendsResult.True 
+          : TypeExtendsResult.False
+      })() :
+      TypeExtendsResult.False
+    )
   }
   function TObject(left: TObject, right: TSchema) {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
-    if (!TypeGuard.TObject(right)) return TypeExtendsResult.False
-    for (const key of Object.getOwnPropertyNames(right.properties)) {
-      if (!(key in left.properties)) return TypeExtendsResult.False
-      if (Property(left.properties[key], right.properties[key]) === TypeExtendsResult.False) {
-        return TypeExtendsResult.False
-      }
-    }
-    return TypeExtendsResult.True
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+      !TypeGuard.TObject(right) ? TypeExtendsResult.False :
+      (() => {
+        for (const key of Object.getOwnPropertyNames(right.properties)) {
+          if (!(key in left.properties)) return TypeExtendsResult.False
+          if (Property(left.properties[key], right.properties[key]) === TypeExtendsResult.False) {
+            return TypeExtendsResult.False
+          }
+        }
+        return TypeExtendsResult.True
+      })()
+    )
   }
   // --------------------------------------------------------------------------
   // Promise
   // --------------------------------------------------------------------------
   function TPromise(left: TPromise, right: TSchema) {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right) && IsObjectPromiseLike(right)) return TypeExtendsResult.True
-    if (!TypeGuard.TPromise(right)) return TypeExtendsResult.False
-    return IntoBooleanResult(Visit(left.item, right.item))
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TObject(right) && IsObjectPromiseLike(right) ? TypeExtendsResult.True :
+      !TypeGuard.TPromise(right) ? TypeExtendsResult.False :
+      IntoBooleanResult(Visit(left.item, right.item))
+    )
   }
   // --------------------------------------------------------------------------
   // Record
   // --------------------------------------------------------------------------
   function RecordKey(schema: TRecord) {
-    if (PatternNumberExact in schema.patternProperties) return Type.Number()
-    if (PatternStringExact in schema.patternProperties) return Type.String()
-    throw Error('TypeExtends: Cannot get record key')
+    // prettier-ignore
+    return (
+      PatternNumberExact in schema.patternProperties ? Type.Number() :
+      PatternStringExact in schema.patternProperties ? Type.String() :
+      Throw('Unknown record key pattern')
+    )
   }
   function RecordValue(schema: TRecord) {
-    if (PatternNumberExact in schema.patternProperties) return schema.patternProperties[PatternNumberExact]
-    if (PatternStringExact in schema.patternProperties) return schema.patternProperties[PatternStringExact]
-    throw Error('TypeExtends: Cannot get record value')
+    // prettier-ignore
+    return (
+      PatternNumberExact in schema.patternProperties ? schema.patternProperties[PatternNumberExact] :
+      PatternStringExact in schema.patternProperties ? schema.patternProperties[PatternStringExact] :
+      Throw('Unable to get record value schema')
+    )
   }
   function TRecordRight(left: TSchema, right: TRecord) {
-    const Key = RecordKey(right)
-    const Value = RecordValue(right)
-    if (TypeGuard.TLiteralString(left) && TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === TypeExtendsResult.True) return TypeExtendsResult.True
-    if (TypeGuard.TUint8Array(left) && TypeGuard.TNumber(Key)) return Visit(left, Value)
-    if (TypeGuard.TString(left) && TypeGuard.TNumber(Key)) return Visit(left, Value)
-    if (TypeGuard.TArray(left) && TypeGuard.TNumber(Key)) return Visit(left, Value)
-    if (TypeGuard.TObject(left)) {
-      for (const key of Object.getOwnPropertyNames(left.properties)) {
-        if (Property(Value, left.properties[key]) === TypeExtendsResult.False) {
-          return TypeExtendsResult.False
+    const [Key, Value] = [RecordKey(right), RecordValue(right)]
+    // prettier-ignore
+    return (
+      (TypeGuard.TLiteralString(left) && TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === TypeExtendsResult.True) ? TypeExtendsResult.True :
+      TypeGuard.TUint8Array(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) :
+      TypeGuard.TString(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) :
+      TypeGuard.TArray(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) :
+      TypeGuard.TObject(left) ? (() => {
+        for (const key of Object.getOwnPropertyNames(left.properties)) {
+          if (Property(Value, left.properties[key]) === TypeExtendsResult.False) {
+            return TypeExtendsResult.False
+          }
         }
-      }
-      return TypeExtendsResult.True
-    }
-    return TypeExtendsResult.False
+        return TypeExtendsResult.True
+      })() : 
+      TypeExtendsResult.False
+    )
   }
   function TRecord(left: TRecord, right: TSchema) {
-    const Value = RecordValue(left)
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
-    if (!TypeGuard.TRecord(right)) return TypeExtendsResult.False
-    return Visit(Value, RecordValue(right))
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TObject(right) ? TObjectRight(left, right) :
+      !TypeGuard.TRecord(right) ? TypeExtendsResult.False :
+      Visit(RecordValue(left), RecordValue(right))
+    )
   }
   // --------------------------------------------------------------------------
   // String
   // --------------------------------------------------------------------------
   function TStringRight(left: TSchema, right: TString) {
-    if (TypeGuard.TLiteral(left) && ValueGuard.IsString(left.const)) return TypeExtendsResult.True
-    return TypeGuard.TString(left) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      TypeGuard.TLiteral(left) && ValueGuard.IsString(left.const) ? TypeExtendsResult.True :
+      TypeGuard.TString(left) ? TypeExtendsResult.True : 
+      TypeExtendsResult.False
+    )
   }
   function TString(left: TString, right: TSchema): TypeExtendsResult {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
-    return TypeGuard.TString(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TObject(right) ? TObjectRight(left, right) :
+      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+      TypeGuard.TString(right) ? TypeExtendsResult.True : 
+      TypeExtendsResult.False
+    )
   }
   // --------------------------------------------------------------------------
   // Symbol
   // --------------------------------------------------------------------------
   function TSymbol(left: TSymbol, right: TSchema): TypeExtendsResult {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
-    return TypeGuard.TSymbol(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TObject(right) ? TObjectRight(left, right) :
+      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+      TypeGuard.TSymbol(right) ? TypeExtendsResult.True : 
+      TypeExtendsResult.False
+    )
   }
   // --------------------------------------------------------------------------
   // TemplateLiteral
@@ -1923,9 +2088,12 @@ export namespace TypeExtends {
     // TemplateLiteral types are resolved to either unions for finite expressions or string
     // for infinite expressions. Here we call to TemplateLiteralResolver to resolve for
     // either type and continue evaluating.
-    if (TypeGuard.TTemplateLiteral(left)) return Visit(TemplateLiteralResolver.Resolve(left), right)
-    if (TypeGuard.TTemplateLiteral(right)) return Visit(left, TemplateLiteralResolver.Resolve(right))
-    throw new Error(`TypeExtends: Invalid fallthrough for TemplateLiteral`)
+    // prettier-ignore
+    return (
+      TypeGuard.TTemplateLiteral(left) ? Visit(TemplateLiteralResolver.Resolve(left), right) :
+      TypeGuard.TTemplateLiteral(right) ? Visit(left, TemplateLiteralResolver.Resolve(right)) :
+      Throw('Invalid fallthrough for TemplateLiteral')
+    )
   }
   // --------------------------------------------------------------------------
   // Tuple
@@ -1939,47 +2107,68 @@ export namespace TypeExtends {
     )
   }
   function TTupleRight(left: TSchema, right: TTuple) {
-    if (TypeGuard.TNever(left)) return TypeExtendsResult.True
-    if (TypeGuard.TUnknown(left)) return TypeExtendsResult.False
-    if (TypeGuard.TAny(left)) return TypeExtendsResult.Union
-    return TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      TypeGuard.TNever(left) ? TypeExtendsResult.True :
+      TypeGuard.TUnknown(left) ? TypeExtendsResult.False :
+      TypeGuard.TAny(left) ? TypeExtendsResult.Union :
+      TypeExtendsResult.False
+    )
   }
   function TTuple(left: TTuple, right: TSchema): TypeExtendsResult {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right) && IsObjectArrayLike(right)) return TypeExtendsResult.True
-    if (TypeGuard.TArray(right) && IsArrayOfTuple(left, right)) return TypeExtendsResult.True
-    if (!TypeGuard.TTuple(right)) return TypeExtendsResult.False
-    if ((ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items)) || (!ValueGuard.IsUndefined(left.items) && ValueGuard.IsUndefined(right.items))) return TypeExtendsResult.False
-    if (ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items)) return TypeExtendsResult.True
-    return left.items!.every((schema, index) => Visit(schema, right.items![index]) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TObject(right) && IsObjectArrayLike(right) ? TypeExtendsResult.True :
+      TypeGuard.TArray(right) && IsArrayOfTuple(left, right) ? TypeExtendsResult.True :
+      !TypeGuard.TTuple(right) ? TypeExtendsResult.False :
+      (ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items)) || (!ValueGuard.IsUndefined(left.items) && ValueGuard.IsUndefined(right.items)) ? TypeExtendsResult.False :
+      (ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items)) ? TypeExtendsResult.True :
+      left.items!.every((schema, index) => Visit(schema, right.items![index]) === TypeExtendsResult.True) ? TypeExtendsResult.True : 
+      TypeExtendsResult.False
+    )
   }
   // --------------------------------------------------------------------------
   // Uint8Array
   // --------------------------------------------------------------------------
   function TUint8Array(left: TUint8Array, right: TSchema) {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
-    return TypeGuard.TUint8Array(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TObject(right) ? TObjectRight(left, right) :
+      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+      TypeGuard.TUint8Array(right) ? TypeExtendsResult.True : 
+      TypeExtendsResult.False
+    )
   }
   // --------------------------------------------------------------------------
   // Undefined
   // --------------------------------------------------------------------------
   function TUndefined(left: TUndefined, right: TSchema) {
-    if (IsStructuralRight(right)) return StructuralRight(left, right)
-    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
-    if (TypeGuard.TRecord(right)) return TRecordRight(left, right)
-    if (TypeGuard.TVoid(right)) return VoidRight(left, right)
-    return TypeGuard.TUndefined(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      IsStructuralRight(right) ? StructuralRight(left, right) :
+      TypeGuard.TObject(right) ? TObjectRight(left, right) :
+      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+      TypeGuard.TVoid(right) ? VoidRight(left, right) :
+      TypeGuard.TUndefined(right) ? TypeExtendsResult.True : 
+      TypeExtendsResult.False
+    )
   }
   // --------------------------------------------------------------------------
   // Union
   // --------------------------------------------------------------------------
   function TUnionRight(left: TSchema, right: TUnion): TypeExtendsResult {
-    return right.anyOf.some((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return right.anyOf.some((schema) => Visit(left, schema) === TypeExtendsResult.True) 
+      ? TypeExtendsResult.True 
+      : TypeExtendsResult.False
   }
   function TUnion(left: TUnion, right: TSchema): TypeExtendsResult {
-    return left.anyOf.every((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return left.anyOf.every((schema) => Visit(schema, right) === TypeExtendsResult.True) 
+      ? TypeExtendsResult.True 
+      : TypeExtendsResult.False
   }
   // --------------------------------------------------------------------------
   // Unknown
@@ -1988,66 +2177,77 @@ export namespace TypeExtends {
     return TypeExtendsResult.True
   }
   function TUnknown(left: TUnknown, right: TSchema) {
-    if (TypeGuard.TNever(right)) return TNeverRight(left, right)
-    if (TypeGuard.TIntersect(right)) return TIntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return TUnionRight(left, right)
-    if (TypeGuard.TAny(right)) return TAnyRight(left, right)
-    if (TypeGuard.TString(right)) return TStringRight(left, right)
-    if (TypeGuard.TNumber(right)) return TNumberRight(left, right)
-    if (TypeGuard.TInteger(right)) return TIntegerRight(left, right)
-    if (TypeGuard.TBoolean(right)) return TBooleanRight(left, right)
-    if (TypeGuard.TArray(right)) return TArrayRight(left, right)
-    if (TypeGuard.TTuple(right)) return TTupleRight(left, right)
-    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
-    return TypeGuard.TUnknown(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return (
+      TypeGuard.TNever(right) ? TNeverRight(left, right) :
+      TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
+      TypeGuard.TUnion(right) ? TUnionRight(left, right) :
+      TypeGuard.TAny(right) ? TAnyRight(left, right) :
+      TypeGuard.TString(right) ? TStringRight(left, right) :
+      TypeGuard.TNumber(right) ? TNumberRight(left, right) :
+      TypeGuard.TInteger(right) ? TIntegerRight(left, right) :
+      TypeGuard.TBoolean(right) ? TBooleanRight(left, right) :
+      TypeGuard.TArray(right) ? TArrayRight(left, right) :
+      TypeGuard.TTuple(right) ? TTupleRight(left, right) :
+      TypeGuard.TObject(right) ? TObjectRight(left, right) :
+      TypeGuard.TUnknown(right) ? TypeExtendsResult.True : 
+      TypeExtendsResult.False
+    )
   }
   // --------------------------------------------------------------------------
   // Void
   // --------------------------------------------------------------------------
   function VoidRight(left: TSchema, right: TVoid) {
-    if (TypeGuard.TUndefined(left)) return TypeExtendsResult.True
-    return TypeGuard.TUndefined(left) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return TypeGuard.TUndefined(left) ? TypeExtendsResult.True :
+      TypeGuard.TUndefined(left) ? TypeExtendsResult.True : 
+      TypeExtendsResult.False
   }
   function TVoid(left: TVoid, right: TSchema) {
-    if (TypeGuard.TIntersect(right)) return TIntersectRight(left, right)
-    if (TypeGuard.TUnion(right)) return TUnionRight(left, right)
-    if (TypeGuard.TUnknown(right)) return TUnknownRight(left, right)
-    if (TypeGuard.TAny(right)) return TAnyRight(left, right)
-    if (TypeGuard.TObject(right)) return TObjectRight(left, right)
-    return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False
+    // prettier-ignore
+    return TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
+      TypeGuard.TUnion(right) ? TUnionRight(left, right) :
+      TypeGuard.TUnknown(right) ? TUnknownRight(left, right) :
+      TypeGuard.TAny(right) ? TAnyRight(left, right) :
+      TypeGuard.TObject(right) ? TObjectRight(left, right) :
+      TypeGuard.TVoid(right) ? TypeExtendsResult.True : 
+      TypeExtendsResult.False
   }
   function Visit(left: TSchema, right: TSchema): TypeExtendsResult {
-    // Resolvable Types
-    if (TypeGuard.TTemplateLiteral(left) || TypeGuard.TTemplateLiteral(right)) return TTemplateLiteral(left, right)
-    if (TypeGuard.TNot(left) || TypeGuard.TNot(right)) return TNot(left, right)
-    // Standard Types
-    if (TypeGuard.TAny(left)) return TAny(left, right)
-    if (TypeGuard.TArray(left)) return TArray(left, right)
-    if (TypeGuard.TBigInt(left)) return TBigInt(left, right)
-    if (TypeGuard.TBoolean(left)) return TBoolean(left, right)
-    if (TypeGuard.TAsyncIterator(left)) return TAsyncIterator(left, right)
-    if (TypeGuard.TConstructor(left)) return TConstructor(left, right)
-    if (TypeGuard.TDate(left)) return TDate(left, right)
-    if (TypeGuard.TFunction(left)) return TFunction(left, right)
-    if (TypeGuard.TInteger(left)) return TInteger(left, right)
-    if (TypeGuard.TIntersect(left)) return TIntersect(left, right)
-    if (TypeGuard.TIterator(left)) return TIterator(left, right)
-    if (TypeGuard.TLiteral(left)) return TLiteral(left, right)
-    if (TypeGuard.TNever(left)) return TNever(left, right)
-    if (TypeGuard.TNull(left)) return TNull(left, right)
-    if (TypeGuard.TNumber(left)) return TNumber(left, right)
-    if (TypeGuard.TObject(left)) return TObject(left, right)
-    if (TypeGuard.TRecord(left)) return TRecord(left, right)
-    if (TypeGuard.TString(left)) return TString(left, right)
-    if (TypeGuard.TSymbol(left)) return TSymbol(left, right)
-    if (TypeGuard.TTuple(left)) return TTuple(left, right)
-    if (TypeGuard.TPromise(left)) return TPromise(left, right)
-    if (TypeGuard.TUint8Array(left)) return TUint8Array(left, right)
-    if (TypeGuard.TUndefined(left)) return TUndefined(left, right)
-    if (TypeGuard.TUnion(left)) return TUnion(left, right)
-    if (TypeGuard.TUnknown(left)) return TUnknown(left, right)
-    if (TypeGuard.TVoid(left)) return TVoid(left, right)
-    throw Error(`TypeExtends: Unknown left type operand '${left[Kind]}'`)
+    // prettier-ignore
+    return (
+      // resolvable
+      (TypeGuard.TTemplateLiteral(left) || TypeGuard.TTemplateLiteral(right)) ? TTemplateLiteral(left, right) :
+      (TypeGuard.TNot(left) || TypeGuard.TNot(right)) ? TNot(left, right) :
+      // standard
+      TypeGuard.TAny(left) ? TAny(left, right) :
+      TypeGuard.TArray(left) ? TArray(left, right) :
+      TypeGuard.TBigInt(left) ? TBigInt(left, right) :
+      TypeGuard.TBoolean(left) ? TBoolean(left, right) :
+      TypeGuard.TAsyncIterator(left) ? TAsyncIterator(left, right) :
+      TypeGuard.TConstructor(left) ? TConstructor(left, right) :
+      TypeGuard.TDate(left) ? TDate(left, right) :
+      TypeGuard.TFunction(left) ? TFunction(left, right) :
+      TypeGuard.TInteger(left) ? TInteger(left, right) :
+      TypeGuard.TIntersect(left) ? TIntersect(left, right) :
+      TypeGuard.TIterator(left) ? TIterator(left, right) :
+      TypeGuard.TLiteral(left) ? TLiteral(left, right) :
+      TypeGuard.TNever(left) ? TNever(left, right) :
+      TypeGuard.TNull(left) ? TNull(left, right) :
+      TypeGuard.TNumber(left) ? TNumber(left, right) :
+      TypeGuard.TObject(left) ? TObject(left, right) :
+      TypeGuard.TRecord(left) ? TRecord(left, right) :
+      TypeGuard.TString(left) ? TString(left, right) :
+      TypeGuard.TSymbol(left) ? TSymbol(left, right) :
+      TypeGuard.TTuple(left) ? TTuple(left, right) :
+      TypeGuard.TPromise(left) ? TPromise(left, right) :
+      TypeGuard.TUint8Array(left) ? TUint8Array(left, right) :
+      TypeGuard.TUndefined(left) ? TUndefined(left, right) :
+      TypeGuard.TUnion(left) ? TUnion(left, right) :
+      TypeGuard.TUnknown(left) ? TUnknown(left, right) :
+      TypeGuard.TVoid(left) ? TVoid(left, right) :
+      Throw(`Unknown left type operand '${left[Kind]}'`)
+    )
   }
   export function Extends(left: TSchema, right: TSchema): TypeExtendsResult {
     return Visit(left, right)
@@ -2067,12 +2267,17 @@ export namespace TypeClone {
     return (value as any).map((value: unknown) => Visit(value as any))
   }
   function Visit(value: unknown): any {
-    if (ValueGuard.IsArray(value)) return ArrayType(value)
-    if (ValueGuard.IsObject(value)) return ObjectType(value)
-    return value
+    // prettier-ignore
+    return ValueGuard.IsArray(value) ? ArrayType(value) :
+      ValueGuard.IsObject(value) ? ObjectType(value) :
+      value
+  }
+  /** Clones a Rest */
+  export function Rest<T extends TSchema[]>(schemas: [...T]): T {
+    return schemas.map((schema) => Type(schema)) as T
   }
-  /** Clones a type. */
-  export function Clone<T extends TSchema>(schema: T, options: SchemaOptions = {}): T {
+  /** Clones a Type */
+  export function Type<T extends TSchema>(schema: T, options: SchemaOptions = {}): T {
     return { ...Visit(schema), ...options }
   }
 }
@@ -2082,7 +2287,7 @@ export namespace TypeClone {
 export namespace IndexedAccessor {
   function OptionalUnwrap(schema: TSchema[]): TSchema[] {
     return schema.map((schema) => {
-      const { [Optional]: _, ...clone } = TypeClone.Clone(schema)
+      const { [Optional]: _, ...clone } = TypeClone.Type(schema)
       return clone
     })
   }
@@ -2093,17 +2298,16 @@ export namespace IndexedAccessor {
     return schema.some((schema) => TypeGuard.TOptional(schema))
   }
   function ResolveIntersect(schema: TIntersect): TSchema {
-    const optional = IsIntersectOptional(schema.allOf)
-    return optional ? Type.Optional(Type.Intersect(OptionalUnwrap(schema.allOf))) : schema
+    return IsIntersectOptional(schema.allOf) ? Type.Optional(Type.Intersect(OptionalUnwrap(schema.allOf))) : schema
   }
   function ResolveUnion(schema: TUnion): TSchema {
-    const optional = IsUnionOptional(schema.anyOf)
-    return optional ? Type.Optional(Type.Union(OptionalUnwrap(schema.anyOf))) : schema
+    return IsUnionOptional(schema.anyOf) ? Type.Optional(Type.Union(OptionalUnwrap(schema.anyOf))) : schema
   }
   function ResolveOptional(schema: TSchema) {
-    if (schema[Kind] === 'Intersect') return ResolveIntersect(schema as TIntersect)
-    if (schema[Kind] === 'Union') return ResolveUnion(schema as TUnion)
-    return schema
+    // prettier-ignore
+    return schema[Kind] === 'Intersect' ? ResolveIntersect(schema as TIntersect) :
+      schema[Kind] === 'Union' ? ResolveUnion(schema as TUnion) :
+      schema
   }
   function TIntersect(schema: TIntersect, key: string): TSchema {
     const resolved = schema.allOf.reduce((acc, schema) => {
@@ -2128,11 +2332,12 @@ export namespace IndexedAccessor {
     return element
   }
   function Visit(schema: TSchema, key: string): TSchema {
-    if (schema[Kind] === 'Intersect') return TIntersect(schema as TIntersect, key)
-    if (schema[Kind] === 'Union') return TUnion(schema as TUnion, key)
-    if (schema[Kind] === 'Object') return TObject(schema as TObject, key)
-    if (schema[Kind] === 'Tuple') return TTuple(schema as TTuple, key)
-    return Type.Never()
+    // prettier-ignore
+    return schema[Kind] === 'Intersect' ? TIntersect(schema as TIntersect, key) :
+      schema[Kind] === 'Union' ? TUnion(schema as TUnion, key) :
+      schema[Kind] === 'Object' ? TObject(schema as TObject, key) :
+      schema[Kind] === 'Tuple' ? TTuple(schema as TTuple, key) :
+      Type.Never()
   }
   export function Resolve(schema: TSchema, keys: TPropertyKey[], options: SchemaOptions = {}): TSchema {
     const resolved = keys.map((key) => Visit(schema, key.toString()))
@@ -2184,10 +2389,11 @@ export namespace Intrinsic {
     return [Map(L, mode), ...IntrinsicRest(R, mode)]
   }
   function Visit(schema: TSchema, mode: TIntrinsicMode) {
-    if (TypeGuard.TTemplateLiteral(schema)) return IntrinsicTemplateLiteral(schema, mode)
-    if (TypeGuard.TUnion(schema)) return Type.Union(IntrinsicRest(schema.anyOf, mode))
-    if (TypeGuard.TLiteral(schema)) return Type.Literal(IntrinsicLiteral(schema.const, mode))
-    return schema
+    // prettier-ignore
+    return TypeGuard.TTemplateLiteral(schema) ?  IntrinsicTemplateLiteral(schema, mode) :
+      TypeGuard.TUnion(schema) ? Type.Union(IntrinsicRest(schema.anyOf, mode)) :
+      TypeGuard.TLiteral(schema) ? Type.Literal(IntrinsicLiteral(schema.const, mode)) :
+      schema
   }
   /** Applies an intrinsic string manipulation to the given type. */
   export function Map<T extends TSchema, M extends TIntrinsicMode>(schema: T, mode: M): TIntrinsic<T, M> {
@@ -2214,13 +2420,16 @@ export namespace ObjectMap {
     // prevent sub schema mapping as unregistered kinds will not pass TSchema checks. This is notable in the
     // case of TObject where unregistered property kinds cause the TObject check to fail. As mapping is only
     // used for composition, we use explicit checks instead.
-    if (schema[Kind] === 'Intersect') return TIntersect(schema as TIntersect, callback)
-    if (schema[Kind] === 'Union') return TUnion(schema as TUnion, callback)
-    if (schema[Kind] === 'Object') return TObject(schema as TObject, callback)
-    return schema
+    // prettier-ignore
+    return (
+      schema[Kind] === 'Intersect' ? TIntersect(schema as TIntersect, callback) : 
+      schema[Kind] === 'Union' ? TUnion(schema as TUnion, callback) : 
+      schema[Kind] === 'Object' ? TObject(schema as TObject, callback) : 
+      schema
+    )
   }
   export function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T {
-    return { ...Visit(TypeClone.Clone(schema), callback), ...options } as unknown as T
+    return { ...Visit(TypeClone.Type(schema), callback), ...options } as unknown as T
   }
 }
 // --------------------------------------------------------------------------
@@ -2247,11 +2456,14 @@ export namespace KeyResolver {
     return options.includePatterns ? Object.getOwnPropertyNames(schema.patternProperties) : []
   }
   function Visit(schema: TSchema, options: KeyResolverOptions): string[] {
-    if (TypeGuard.TIntersect(schema)) return TIntersect(schema, options)
-    if (TypeGuard.TUnion(schema)) return TUnion(schema, options)
-    if (TypeGuard.TObject(schema)) return TObject(schema, options)
-    if (TypeGuard.TRecord(schema)) return TRecord(schema, options)
-    return []
+    // prettier-ignore
+    return (
+      TypeGuard.TIntersect(schema) ? TIntersect(schema, options) :
+      TypeGuard.TUnion(schema) ? TUnion(schema, options) :
+      TypeGuard.TObject(schema) ? TObject(schema, options) :
+      TypeGuard.TRecord(schema) ? TRecord(schema, options) : 
+      []
+    )
   }
   /** Resolves an array of keys in this schema */
   export function ResolveKeys(schema: TSchema, options: KeyResolverOptions): string[] {
@@ -2267,18 +2479,19 @@ export namespace KeyResolver {
 // --------------------------------------------------------------------------
 // KeyArrayResolver
 // --------------------------------------------------------------------------
+export class KeyArrayResolverError extends TypeBoxError {}
 export namespace KeyArrayResolver {
   /** Resolves an array of string[] keys from the given schema or array type. */
   export function Resolve(schema: TSchema | string[]): string[] {
-    if (Array.isArray(schema)) return schema
-    if (TypeGuard.TUnionLiteral(schema)) return schema.anyOf.map((schema) => schema.const.toString())
-    if (TypeGuard.TLiteral(schema)) return [schema.const as string]
-    if (TypeGuard.TTemplateLiteral(schema)) {
-      const expression = TemplateLiteralParser.ParseExact(schema.pattern)
-      if (!TemplateLiteralFinite.Check(expression)) throw Error('KeyArrayResolver: Cannot resolve keys from infinite template expression')
-      return [...TemplateLiteralGenerator.Generate(expression)]
-    }
-    return []
+    // prettier-ignore
+    return Array.isArray(schema) ? schema :
+      TypeGuard.TUnionLiteral(schema) ? schema.anyOf.map((schema) => schema.const.toString()) :
+      TypeGuard.TLiteral(schema) ? [schema.const as string] :
+      TypeGuard.TTemplateLiteral(schema) ? (() => {
+        const expression = TemplateLiteralParser.ParseExact(schema.pattern)
+        if (!TemplateLiteralFinite.Check(expression)) throw new KeyArrayResolverError('Cannot resolve keys from infinite template expression')
+        return [...TemplateLiteralGenerator.Generate(expression)]
+      })() : []
   }
 }
 // --------------------------------------------------------------------------
@@ -2302,32 +2515,27 @@ export namespace UnionResolver {
 // --------------------------------------------------------------------------
 // TemplateLiteralPattern
 // --------------------------------------------------------------------------
+export class TemplateLiteralPatternError extends TypeBoxError {}
 export namespace TemplateLiteralPattern {
+  function Throw(message: string): never {
+    throw new TemplateLiteralPatternError(message)
+  }
   function Escape(value: string) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
   }
   function Visit(schema: TSchema, acc: string): string {
-    if (TypeGuard.TTemplateLiteral(schema)) {
-      return schema.pattern.slice(1, schema.pattern.length - 1)
-    } else if (TypeGuard.TUnion(schema)) {
-      return `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})`
-    } else if (TypeGuard.TNumber(schema)) {
-      return `${acc}${PatternNumber}`
-    } else if (TypeGuard.TInteger(schema)) {
-      return `${acc}${PatternNumber}`
-    } else if (TypeGuard.TBigInt(schema)) {
-      return `${acc}${PatternNumber}`
-    } else if (TypeGuard.TString(schema)) {
-      return `${acc}${PatternString}`
-    } else if (TypeGuard.TLiteral(schema)) {
-      return `${acc}${Escape(schema.const.toString())}`
-    } else if (TypeGuard.TBoolean(schema)) {
-      return `${acc}${PatternBoolean}`
-    } else if (TypeGuard.TNever(schema)) {
-      throw Error('TemplateLiteralPattern: TemplateLiteral cannot operate on types of TNever')
-    } else {
-      throw Error(`TemplateLiteralPattern: Unexpected Kind '${schema[Kind]}'`)
-    }
+    // prettier-ignore
+    return (
+      TypeGuard.TTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
+      TypeGuard.TUnion(schema) ? `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})` :
+      TypeGuard.TNumber(schema) ? `${acc}${PatternNumber}` :
+      TypeGuard.TInteger(schema) ? `${acc}${PatternNumber}` :
+      TypeGuard.TBigInt(schema) ? `${acc}${PatternNumber}` :
+      TypeGuard.TString(schema) ? `${acc}${PatternString}` :
+      TypeGuard.TLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` :
+      TypeGuard.TBoolean(schema) ? `${acc}${PatternBoolean}` :
+      Throw(`Unexpected Kind '${schema[Kind]}'`)
+    )
   }
   export function Create(kinds: TTemplateLiteralKind[]): string {
     return `^${kinds.map((schema) => Visit(schema, '')).join('')}\$`
@@ -2348,11 +2556,7 @@ export namespace TemplateLiteralResolver {
 // --------------------------------------------------------------------------------------
 // TemplateLiteralParser
 // --------------------------------------------------------------------------------------
-export class TemplateLiteralParserError extends Error {
-  constructor(message: string) {
-    super(message)
-  }
-}
+export class TemplateLiteralParserError extends TypeBoxError {}
 export namespace TemplateLiteralParser {
   export type Expression = And | Or | Const
   export type Const = { type: 'const'; const: string }
@@ -2447,16 +2651,18 @@ export namespace TemplateLiteralParser {
         index = end - 1
       }
     }
-    if (expressions.length === 0) return { type: 'const', const: '' }
-    if (expressions.length === 1) return expressions[0]
-    return { type: 'and', expr: expressions }
+    // prettier-ignore
+    return (expressions.length === 0) ? { type: 'const', const: '' } :
+      (expressions.length === 1) ? expressions[0] :
+      { type: 'and', expr: expressions }
   }
   /** Parses a pattern and returns an expression tree */
   export function Parse(pattern: string): Expression {
-    if (IsGroup(pattern)) return Parse(InGroup(pattern))
-    if (IsPrecedenceOr(pattern)) return Or(pattern)
-    if (IsPrecedenceAnd(pattern)) return And(pattern)
-    return { type: 'const', const: pattern }
+    // prettier-ignore
+    return IsGroup(pattern) ? Parse(InGroup(pattern)) :
+      IsPrecedenceOr(pattern) ? Or(pattern) :
+      IsPrecedenceAnd(pattern) ? And(pattern) :
+      { type: 'const', const: pattern }
   }
   /** Parses a pattern and strips forward and trailing ^ and $ */
   export function ParseExact(pattern: string): Expression {
@@ -2466,7 +2672,11 @@ export namespace TemplateLiteralParser {
 // --------------------------------------------------------------------------------------
 // TemplateLiteralFinite
 // --------------------------------------------------------------------------------------
+export class TemplateLiteralFiniteError extends TypeBoxError {}
 export namespace TemplateLiteralFinite {
+  function Throw(message: string): never {
+    throw new TemplateLiteralFiniteError(message)
+  }
   function IsNumber(expression: TemplateLiteralParser.Expression): boolean {
     // prettier-ignore
     return (
@@ -2493,17 +2703,19 @@ export namespace TemplateLiteralFinite {
     return expression.type === 'const' && expression.const === '.*'
   }
   export function Check(expression: TemplateLiteralParser.Expression): boolean {
-    if (IsBoolean(expression)) return true
-    if (IsNumber(expression) || IsString(expression)) return false
-    if (expression.type === 'and') return expression.expr.every((expr) => Check(expr))
-    if (expression.type === 'or') return expression.expr.every((expr) => Check(expr))
-    if (expression.type === 'const') return true
-    throw Error(`TemplateLiteralFinite: Unknown expression type`)
+    // prettier-ignore
+    return IsBoolean(expression) ? true :
+      IsNumber(expression) || IsString(expression) ? false :
+      (expression.type === 'and') ? expression.expr.every((expr) => Check(expr)) :
+      (expression.type === 'or') ? expression.expr.every((expr) => Check(expr)) :
+      (expression.type === 'const') ? true :
+      Throw(`Unknown expression type`)
   }
 }
 // --------------------------------------------------------------------------------------
 // TemplateLiteralGenerator
 // --------------------------------------------------------------------------------------
+export class TemplateLiteralGeneratorError extends TypeBoxError {}
 export namespace TemplateLiteralGenerator {
   function* Reduce(buffer: string[][]): IterableIterator<string> {
     if (buffer.length === 1) return yield* buffer[0]
@@ -2523,10 +2735,13 @@ export namespace TemplateLiteralGenerator {
     return yield expression.const
   }
   export function* Generate(expression: TemplateLiteralParser.Expression): IterableIterator<string> {
-    if (expression.type === 'and') return yield* And(expression)
-    if (expression.type === 'or') return yield* Or(expression)
-    if (expression.type === 'const') return yield* Const(expression)
-    throw Error('TemplateLiteralGenerator: Unknown expression')
+    // prettier-ignore
+    return (
+      expression.type === 'and' ? yield* And(expression) :
+      expression.type === 'or' ? yield* Or(expression) :
+      expression.type === 'const' ? yield* Const(expression) :
+      (() => { throw new TemplateLiteralGeneratorError('Unknown expression') })()
+    )
   }
 }
 // ---------------------------------------------------------------------
@@ -2535,12 +2750,21 @@ export namespace TemplateLiteralGenerator {
 export namespace TemplateLiteralDslParser {
   function* ParseUnion(template: string): IterableIterator<TTemplateLiteralKind> {
     const trim = template.trim().replace(/"|'/g, '')
-    if (trim === 'boolean') return yield Type.Boolean()
-    if (trim === 'number') return yield Type.Number()
-    if (trim === 'bigint') return yield Type.BigInt()
-    if (trim === 'string') return yield Type.String()
-    const literals = trim.split('|').map((literal) => Type.Literal(literal.trim()))
-    return yield literals.length === 0 ? Type.Never() : literals.length === 1 ? literals[0] : Type.Union(literals)
+    // prettier-ignore
+    return (
+      trim === 'boolean' ? yield Type.Boolean() :
+      trim === 'number' ? yield Type.Number() :
+      trim === 'bigint' ? yield Type.BigInt() :
+      trim === 'string' ? yield Type.String() :
+      yield (() => {
+        const literals = trim.split('|').map((literal) => Type.Literal(literal.trim()))
+        return (
+          literals.length === 0 ? Type.Never() : 
+          literals.length === 1 ? literals[0] : 
+          Type.Union(literals)
+        )
+      })()
+    )
   }
   function* ParseTerminal(template: string): IterableIterator<TTemplateLiteralKind> {
     if (template[1] !== '{') {
@@ -2571,6 +2795,33 @@ export namespace TemplateLiteralDslParser {
     return [...ParseLiteral(template_dsl)]
   }
 }
+// ---------------------------------------------------------------------
+// TransformBuilder
+// ---------------------------------------------------------------------
+export class TransformDecodeBuilder<T extends TSchema> {
+  constructor(private readonly schema: T) {}
+  public Decode<U extends unknown, D extends TransformFunction<StaticDecode<T>, U>>(decode: D): TransformEncodeBuilder<T, D> {
+    return new TransformEncodeBuilder(this.schema, decode)
+  }
+}
+export class TransformEncodeBuilder<T extends TSchema, D extends TransformFunction> {
+  constructor(private readonly schema: T, private readonly decode: D) {}
+  public Encode<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E): TTransform<T, ReturnType<D>> {
+    const schema = TypeClone.Type(this.schema)
+    // prettier-ignore
+    return (
+      TypeGuard.TTransform(schema) ? (() => {
+        const Encode = (value: unknown) => schema[Transform].Encode(encode(value as any))
+        const Decode = (value: unknown) => this.decode(schema[Transform].Decode(value))
+        const Codec = { Encode: Encode, Decode: Decode }
+        return { ...schema, [Transform]: Codec }
+      })() : (() => {
+        const Codec = { Decode: this.decode, Encode: encode }
+        return { ...schema, [Transform]: Codec }
+      })()
+    ) as TTransform<T, ReturnType<D>>
+  }
+}
 // --------------------------------------------------------------------------
 // TypeOrdinal: Used for auto $id generation
 // --------------------------------------------------------------------------
@@ -2578,229 +2829,257 @@ let TypeOrdinal = 0
 // --------------------------------------------------------------------------
 // TypeBuilder
 // --------------------------------------------------------------------------
+export class TypeBuilderError extends TypeBoxError {}
 export class TypeBuilder {
-  /** `[Utility]` Creates a schema without `static` and `params` types */
+  /** `[Internal]` Creates a schema without `static` and `params` types */
   protected Create<T>(schema: Omit<T, 'static' | 'params'>): T {
     return schema as any
   }
-  /** `[Utility]` Discards a property key from the given schema */
+  /** `[Internal]` Throws a TypeBuilder error with the given message */
+  protected Throw(message: string): never {
+    throw new TypeBuilderError(message)
+  }
+  /** `[Internal]` Discards a property key from the given schema */
   protected Discard(schema: TSchema, key: PropertyKey): TSchema {
     const { [key as any]: _, ...rest } = schema
     return rest as TSchema
   }
-  /** `[Standard]` Omits compositing symbols from this schema */
+  /** `[Json]` Omits compositing symbols from this schema */
   public Strict<T extends TSchema>(schema: T): T {
     return JSON.parse(JSON.stringify(schema))
   }
 }
 // --------------------------------------------------------------------------
-// StandardTypeBuilder
+// JsonTypeBuilder
 // --------------------------------------------------------------------------
-export class StandardTypeBuilder extends TypeBuilder {
+export class JsonTypeBuilder extends TypeBuilder {
   // ------------------------------------------------------------------------
   // Modifiers
   // ------------------------------------------------------------------------
-  /** `[Standard]` Creates a Readonly and Optional property */
+  /** `[Json]` Creates a Readonly and Optional property */
   public ReadonlyOptional<T extends TSchema>(schema: T): TReadonly<TOptional<T>> {
     return this.Readonly(this.Optional(schema))
   }
-  /** `[Standard]` Creates a Readonly property */
+  /** `[Json]` Creates a Readonly property */
   public Readonly<T extends TSchema>(schema: T): TReadonly<T> {
-    return { ...TypeClone.Clone(schema), [Readonly]: 'Readonly' }
+    return { ...TypeClone.Type(schema), [Readonly]: 'Readonly' }
   }
-  /** `[Standard]` Creates an Optional property */
+  /** `[Json]` Creates an Optional property */
   public Optional<T extends TSchema>(schema: T): TOptional<T> {
-    return { ...TypeClone.Clone(schema), [Optional]: 'Optional' }
+    return { ...TypeClone.Type(schema), [Optional]: 'Optional' }
   }
   // ------------------------------------------------------------------------
   // Types
   // ------------------------------------------------------------------------
-  /** `[Standard]` Creates an Any type */
+  /** `[Json]` Creates an Any type */
   public Any(options: SchemaOptions = {}): TAny {
     return this.Create({ ...options, [Kind]: 'Any' })
   }
-  /** `[Standard]` Creates an Array type */
+  /** `[Json]` Creates an Array type */
   public Array<T extends TSchema>(schema: T, options: ArrayOptions = {}): TArray<T> {
-    return this.Create({ ...options, [Kind]: 'Array', type: 'array', items: TypeClone.Clone(schema) })
+    return this.Create({ ...options, [Kind]: 'Array', type: 'array', items: TypeClone.Type(schema) })
   }
-  /** `[Standard]` Creates a Boolean type */
+  /** `[Json]` Creates a Boolean type */
   public Boolean(options: SchemaOptions = {}): TBoolean {
     return this.Create({ ...options, [Kind]: 'Boolean', type: 'boolean' })
   }
-  /** `[Standard]` Intrinsic function to Capitalize LiteralString types */
+  /** `[Json]` Intrinsic function to Capitalize LiteralString types */
   public Capitalize<T extends TSchema>(schema: T, options: SchemaOptions = {}): TIntrinsic<T, 'Capitalize'> {
-    return { ...Intrinsic.Map(TypeClone.Clone(schema), 'Capitalize'), ...options }
+    return { ...Intrinsic.Map(TypeClone.Type(schema), 'Capitalize'), ...options }
   }
-  /** `[Standard]` Creates a Composite object type */
+  /** `[Json]` Creates a Composite object type */
   public Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T> {
     const intersect: any = Type.Intersect(objects, {})
     const keys = KeyResolver.ResolveKeys(intersect, { includePatterns: false })
     const properties = keys.reduce((acc, key) => ({ ...acc, [key]: Type.Index(intersect, [key]) }), {} as TProperties)
     return Type.Object(properties, options) as TComposite<T>
   }
-  /** `[Standard]` Creates a Enum type */
+  /** `[Json]` Creates a Enum type */
   public Enum<T extends Record<string, string | number>>(item: T, options: SchemaOptions = {}): TEnum<T> {
     // prettier-ignore
     const values = Object.getOwnPropertyNames(item).filter((key) => isNaN(key as any)).map((key) => item[key]) as T[keyof T][]
-    const anyOf = values.map((value) => (ValueGuard.IsString(value) ? { [Kind]: 'Literal', type: 'string' as const, const: value } : { [Kind]: 'Literal', type: 'number' as const, const: value }))
+    // prettier-ignore
+    const anyOf = values.map((value) => ValueGuard.IsString(value) 
+      ? { [Kind]: 'Literal', type: 'string' as const, const: value } 
+      : { [Kind]: 'Literal', type: 'number' as const, const: value }
+    )
     return this.Create({ ...options, [Kind]: 'Union', anyOf })
   }
-  /** `[Standard]` Creates a Conditional type */
+  /** `[Json]` Creates a Conditional type */
   public Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options: SchemaOptions = {}): TExtends<L, R, T, U> {
     switch (TypeExtends.Extends(left, right)) {
       case TypeExtendsResult.Union:
-        return this.Union([TypeClone.Clone(trueType, options), TypeClone.Clone(falseType, options)]) as any as TExtends<L, R, T, U>
+        return this.Union([TypeClone.Type(trueType, options), TypeClone.Type(falseType, options)]) as any as TExtends<L, R, T, U>
       case TypeExtendsResult.True:
-        return TypeClone.Clone(trueType, options) as unknown as TExtends<L, R, T, U>
+        return TypeClone.Type(trueType, options) as unknown as TExtends<L, R, T, U>
       case TypeExtendsResult.False:
-        return TypeClone.Clone(falseType, options) as unknown as TExtends<L, R, T, U>
+        return TypeClone.Type(falseType, options) as unknown as TExtends<L, R, T, U>
     }
   }
-  /** `[Standard]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+  /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
   public Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options: SchemaOptions = {}): TExclude<L, R> {
-    if (TypeGuard.TTemplateLiteral(unionType)) return this.Exclude(TemplateLiteralResolver.Resolve(unionType), excludedMembers, options) as TExclude<L, R>
-    if (TypeGuard.TTemplateLiteral(excludedMembers)) return this.Exclude(unionType, TemplateLiteralResolver.Resolve(excludedMembers), options) as any as TExclude<L, R>
-    if (TypeGuard.TUnion(unionType)) {
-      const narrowed = unionType.anyOf.filter((inner) => TypeExtends.Extends(inner, excludedMembers) === TypeExtendsResult.False)
-      return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options)) as TExclude<L, R>
-    } else {
-      return (TypeExtends.Extends(unionType, excludedMembers) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Clone(unionType, options)) as any
-    }
-  }
-  /** `[Standard]` Constructs a type by extracting from type all union members that are assignable to union */
+    // prettier-ignore
+    return (
+      TypeGuard.TTemplateLiteral(unionType) ? this.Exclude(TemplateLiteralResolver.Resolve(unionType), excludedMembers, options) :
+      TypeGuard.TTemplateLiteral(excludedMembers) ? this.Exclude(unionType, TemplateLiteralResolver.Resolve(excludedMembers), options) :
+      TypeGuard.TUnion(unionType) ? (() => {
+        const narrowed = unionType.anyOf.filter((inner) => TypeExtends.Extends(inner, excludedMembers) === TypeExtendsResult.False)
+        return (narrowed.length === 1 ? TypeClone.Type(narrowed[0], options) : this.Union(narrowed, options)) as TExclude<L, R>
+      })() :
+      TypeExtends.Extends(unionType, excludedMembers) !== TypeExtendsResult.False ? this.Never(options) : 
+      TypeClone.Type(unionType, options)
+    ) as TExclude<L, R>
+  }
+  /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
   public Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options: SchemaOptions = {}): TExtract<L, R> {
-    if (TypeGuard.TTemplateLiteral(type)) return this.Extract(TemplateLiteralResolver.Resolve(type), union, options) as TExtract<L, R>
-    if (TypeGuard.TTemplateLiteral(union)) return this.Extract(type, TemplateLiteralResolver.Resolve(union), options) as any as TExtract<L, R>
-    if (TypeGuard.TUnion(type)) {
-      const narrowed = type.anyOf.filter((inner) => TypeExtends.Extends(inner, union) !== TypeExtendsResult.False)
-      return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options)) as TExtract<L, R>
-    } else {
-      return (TypeExtends.Extends(type, union) !== TypeExtendsResult.False ? TypeClone.Clone(type, options) : this.Never(options)) as any
-    }
-  }
-  /** `[Standard]` Returns an Indexed property type for the given keys */
-  public Index<T extends TTuple, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): UnionType<Assert<T['items'], TSchema[]>>
-  /** `[Standard]` Returns an Indexed property type for the given keys */
+    // prettier-ignore
+    return (
+      TypeGuard.TTemplateLiteral(type) ? this.Extract(TemplateLiteralResolver.Resolve(type), union, options) :
+      TypeGuard.TTemplateLiteral(union) ? this.Extract(type, TemplateLiteralResolver.Resolve(union), options) :
+      TypeGuard.TUnion(type) ? (() => {
+        const narrowed = type.anyOf.filter((inner) => TypeExtends.Extends(inner, union) !== TypeExtendsResult.False)
+        return (narrowed.length === 1 ? TypeClone.Type(narrowed[0], options) : this.Union(narrowed, options))
+      })() :
+      TypeExtends.Extends(type, union) !== TypeExtendsResult.False ? TypeClone.Type(type, options) : 
+      this.Never(options)
+    ) as TExtract<L, R>
+  }
+  /** `[Json]` Returns an Indexed property type for the given keys */
   public Index<T extends TArray, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): AssertType<T['items']>
-  /** `[Standard]` Returns an Indexed property type for the given keys */
+  /** `[Json]` Returns an Indexed property type for the given keys */
+  public Index<T extends TTuple, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, TPropertyKey[]>>
+  /** `[Json]` Returns an Indexed property type for the given keys */
+  public Index<T extends TTuple, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): UnionType<AssertRest<T['items']>>
+  /** `[Json]` Returns an Indexed property type for the given keys */
   public Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyRest<K>>
-  /** `[Standard]` Returns an Indexed property type for the given keys */
+  /** `[Json]` Returns an Indexed property type for the given keys */
   public Index<T extends TSchema, K extends TLiteral<TPropertyKey>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, [K['const']]>
-  /** `[Standard]` Returns an Indexed property type for the given keys */
+  /** `[Json]` Returns an Indexed property type for the given keys */
   public Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, TPropertyKey[]>>
-  /** `[Standard]` Returns an Indexed property type for the given keys */
+  /** `[Json]` Returns an Indexed property type for the given keys */
   public Index<T extends TSchema, K extends TUnion<TLiteral<TPropertyKey>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TUnionLiteralKeyRest<K>>
-  /** `[Standard]` Returns an Indexed property type for the given keys */
+  /** `[Json]` Returns an Indexed property type for the given keys */
   public Index<T extends TSchema, K extends TSchema>(schema: T, key: K, options?: SchemaOptions): TSchema
-  /** `[Standard]` Returns an Indexed property type for the given keys */
+  /** `[Json]` Returns an Indexed property type for the given keys */
   public Index(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
-    if (TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved)) {
-      return TypeClone.Clone(schema.items, options)
-    } else if (TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved)) {
-      const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items
-      const cloned = items.map((schema) => TypeClone.Clone(schema))
-      return this.Union(cloned, options)
-    } else {
-      const keys = KeyArrayResolver.Resolve(unresolved)
-      const clone = TypeClone.Clone(schema)
-      return IndexedAccessor.Resolve(clone, keys, options)
-    }
+    // prettier-ignore
+    return (
+      TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved) ? (() => {
+        return TypeClone.Type(schema.items, options)
+      })() : 
+      TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved) ? (() => {
+        const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items
+        const cloned = items.map((schema) => TypeClone.Type(schema))
+        return this.Union(cloned, options)
+      })() : (() => {
+        const keys = KeyArrayResolver.Resolve(unresolved)
+        const clone = TypeClone.Type(schema)
+        return IndexedAccessor.Resolve(clone, keys, options)
+      })()
+    )
   }
-  /** `[Standard]` Creates an Integer type */
+  /** `[Json]` Creates an Integer type */
   public Integer(options: NumericOptions<number> = {}): TInteger {
     return this.Create({ ...options, [Kind]: 'Integer', type: 'integer' })
   }
-  /** `[Standard]` Creates an Intersect type */
+  /** `[Json]` Creates an Intersect type */
   public Intersect(allOf: [], options?: SchemaOptions): TNever
-  /** `[Standard]` Creates an Intersect type */
+  /** `[Json]` Creates an Intersect type */
   public Intersect<T extends [TSchema]>(allOf: [...T], options?: SchemaOptions): T[0]
-  /** `[Standard]` Creates an Intersect type */
+  /** `[Json]` Creates an Intersect type */
   public Intersect<T extends TSchema[]>(allOf: [...T], options?: IntersectOptions): TIntersect<T>
-  /** `[Standard]` Creates an Intersect type */
+  /** `[Json]` Creates an Intersect type */
   public Intersect(allOf: TSchema[], options: IntersectOptions = {}) {
     if (allOf.length === 0) return Type.Never()
-    if (allOf.length === 1) return TypeClone.Clone(allOf[0], options)
+    if (allOf.length === 1) return TypeClone.Type(allOf[0], options)
+    if (allOf.some((schema) => TypeGuard.TTransform(schema))) this.Throw('Cannot intersect transform types')
     const objects = allOf.every((schema) => TypeGuard.TObject(schema))
-    const cloned = allOf.map((schema) => TypeClone.Clone(schema))
-    const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties) ? { unevaluatedProperties: TypeClone.Clone(options.unevaluatedProperties) } : {}
-    if (options.unevaluatedProperties === false || TypeGuard.TSchema(options.unevaluatedProperties) || objects) {
-      return this.Create({ ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: cloned })
-    } else {
-      return this.Create({ ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: cloned })
-    }
-  }
-  /** `[Standard]` Creates a KeyOf type */
+    const cloned = TypeClone.Rest(allOf)
+    // prettier-ignore
+    const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties) 
+      ? { unevaluatedProperties: TypeClone.Type(options.unevaluatedProperties) } 
+      : {}
+    return options.unevaluatedProperties === false || TypeGuard.TSchema(options.unevaluatedProperties) || objects
+      ? this.Create({ ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: cloned })
+      : this.Create({ ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: cloned })
+  }
+  /** `[Json]` Creates a KeyOf type */
   public KeyOf<T extends TSchema>(schema: T, options: SchemaOptions = {}): TKeyOf<T> {
-    if (TypeGuard.TRecord(schema)) {
-      const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
-      if (pattern === PatternNumberExact) return this.Number(options) as unknown as TKeyOf<T>
-      if (pattern === PatternStringExact) return this.String(options) as unknown as TKeyOf<T>
-      throw Error('StandardTypeBuilder: Unable to resolve key type from Record key pattern')
-    } else if (TypeGuard.TTuple(schema)) {
-      const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items
-      const literals = items.map((_, index) => Type.Literal(index))
-      return this.Union(literals, options) as unknown as TKeyOf<T>
-    } else if (TypeGuard.TArray(schema)) {
-      return this.Number(options) as unknown as TKeyOf<T>
-    } else {
-      const keys = KeyResolver.ResolveKeys(schema, { includePatterns: false })
-      if (keys.length === 0) return this.Never(options) as TKeyOf<T>
-      const literals = keys.map((key) => this.Literal(key))
-      return this.Union(literals, options) as unknown as TKeyOf<T>
-    }
-  }
-  /** `[Standard]` Creates a Literal type */
+    // prettier-ignore
+    return (
+      TypeGuard.TRecord(schema) ? (() => {
+        const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
+        return (
+          pattern === PatternNumberExact ? this.Number(options) :
+          pattern === PatternStringExact ? this.String(options) :
+          this.Throw('Unable to resolve key type from Record key pattern')
+        )
+      })() :
+      TypeGuard.TTuple(schema) ? (() => {
+        const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items
+        const literals = items.map((_, index) => Type.Literal(index.toString()))
+        return this.Union(literals, options)
+      })() : 
+      TypeGuard.TArray(schema) ? (() => {
+        return this.Number(options)
+      })() : (() => {
+        const keys = KeyResolver.ResolveKeys(schema, { includePatterns: false })
+        if (keys.length === 0) return this.Never(options) as TKeyOf<T>
+        const literals = keys.map((key) => this.Literal(key))
+        return this.Union(literals, options)
+      })()
+    ) as unknown as TKeyOf<T>
+  }
+  /** `[Json]` Creates a Literal type */
   public Literal<T extends TLiteralValue>(value: T, options: SchemaOptions = {}): TLiteral<T> {
     return this.Create({ ...options, [Kind]: 'Literal', const: value, type: typeof value as 'string' | 'number' | 'boolean' })
   }
-  /** `[Standard]` Intrinsic function to Lowercase LiteralString types */
+  /** `[Json]` Intrinsic function to Lowercase LiteralString types */
   public Lowercase<T extends TSchema>(schema: T, options: SchemaOptions = {}): TIntrinsic<T, 'Lowercase'> {
-    return { ...Intrinsic.Map(TypeClone.Clone(schema), 'Lowercase'), ...options }
+    return { ...Intrinsic.Map(TypeClone.Type(schema), 'Lowercase'), ...options }
   }
-  /** `[Standard]` Creates a Never type */
+  /** `[Json]` Creates a Never type */
   public Never(options: SchemaOptions = {}): TNever {
     return this.Create({ ...options, [Kind]: 'Never', not: {} })
   }
-  /** `[Standard]` Creates a Not type */
+  /** `[Json]` Creates a Not type */
   public Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T> {
-    return this.Create({ ...options, [Kind]: 'Not', not: TypeClone.Clone(schema) })
+    return this.Create({ ...options, [Kind]: 'Not', not: TypeClone.Type(schema) })
   }
-  /** `[Standard]` Creates a Null type */
+  /** `[Json]` Creates a Null type */
   public Null(options: SchemaOptions = {}): TNull {
     return this.Create({ ...options, [Kind]: 'Null', type: 'null' })
   }
-  /** `[Standard]` Creates a Number type */
+  /** `[Json]` Creates a Number type */
   public Number(options: NumericOptions<number> = {}): TNumber {
     return this.Create({ ...options, [Kind]: 'Number', type: 'number' })
   }
-  /** `[Standard]` Creates an Object type */
+  /** `[Json]` Creates an Object type */
   public Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
     const propertyKeys = Object.getOwnPropertyNames(properties)
     const optionalKeys = propertyKeys.filter((key) => TypeGuard.TOptional(properties[key]))
     const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name))
-    const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Clone(options.additionalProperties) } : {}
-    const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(properties[key]) }), {} as TProperties)
-    if (requiredKeys.length > 0) {
-      return this.Create({ ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys })
-    } else {
-      return this.Create({ ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties })
-    }
+    const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Type(options.additionalProperties) } : {}
+    const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Type(properties[key]) }), {} as TProperties)
+    return requiredKeys.length > 0
+      ? this.Create({ ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys })
+      : this.Create({ ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties })
   }
-  /** `[Standard]` Constructs a type whose keys are omitted from the given type */
+  /** `[Json]` Constructs a type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TOmit<T, K[number]>
-  /** `[Standard]` Constructs a type whose keys are omitted from the given type */
+  /** `[Json]` Constructs a type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionLiteralKeyRest<K>[number]>
-  /** `[Standard]` Constructs a type whose keys are omitted from the given type */
+  /** `[Json]` Constructs a type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TOmit<T, K['const']>
-  /** `[Standard]` Constructs a type whose keys are omitted from the given type */
+  /** `[Json]` Constructs a type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TOmit<T, TTemplateLiteralKeyRest<K>[number]>
-  /** `[Standard]` Constructs a type whose keys are omitted from the given type */
+  /** `[Json]` Constructs a type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TOmit<T, never>
-  /** `[Standard]` Constructs a type whose keys are omitted from the given type */
+  /** `[Json]` Constructs a type whose keys are omitted from the given type */
   public Omit(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
     const keys = KeyArrayResolver.Resolve(unresolved)
     // prettier-ignore
-    return ObjectMap.Map(TypeClone.Clone(schema), (object) => {
+    return ObjectMap.Map(this.Discard(TypeClone.Type(schema), Transform), (object) => {
       if (ValueGuard.IsArray(object.required)) {
         object.required = object.required.filter((key: string) => !keys.includes(key as any))
         if (object.required.length === 0) delete object.required
@@ -2811,31 +3090,31 @@ export class StandardTypeBuilder extends TypeBuilder {
       return this.Create(object)
     }, options)
   }
-  /** `[Standard]` Constructs a type where all properties are optional */
+  /** `[Json]` Constructs a type where all properties are optional */
   public Partial<T extends TSchema>(schema: T, options: ObjectOptions = {}): TPartial<T> {
     // prettier-ignore
-    return ObjectMap.Map(schema, (object) => {
+    return ObjectMap.Map(this.Discard(TypeClone.Type(schema), Transform), (object) => {
       const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
         return { ...acc, [key]: this.Optional(object.properties[key]) }
       }, {} as TProperties)
       return this.Object(properties, this.Discard(object, 'required') /* object used as options to retain other constraints */)
     }, options)
   }
-  /** `[Standard]` Constructs a type whose keys are picked from the given type */
+  /** `[Json]` Constructs a type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TPick<T, K[number]>
-  /** `[Standard]` Constructs a type whose keys are picked from the given type */
+  /** `[Json]` Constructs a type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionLiteralKeyRest<K>[number]>
-  /** `[Standard]` Constructs a type whose keys are picked from the given type */
+  /** `[Json]` Constructs a type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TPick<T, K['const']>
-  /** `[Standard]` Constructs a type whose keys are picked from the given type */
+  /** `[Json]` Constructs a type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TPick<T, TTemplateLiteralKeyRest<K>[number]>
-  /** `[Standard]` Constructs a type whose keys are picked from the given type */
+  /** `[Json]` Constructs a type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TPick<T, never>
-  /** `[Standard]` Constructs a type whose keys are picked from the given type */
+  /** `[Json]` Constructs a type whose keys are picked from the given type */
   public Pick(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
     const keys = KeyArrayResolver.Resolve(unresolved)
     // prettier-ignore
-    return ObjectMap.Map(TypeClone.Clone(schema), (object) => {
+    return ObjectMap.Map(this.Discard(TypeClone.Type(schema), Transform), (object) => {
       if (ValueGuard.IsArray(object.required)) {
         object.required = object.required.filter((key: any) => keys.includes(key))
         if (object.required.length === 0) delete object.required
@@ -2846,208 +3125,205 @@ export class StandardTypeBuilder extends TypeBuilder {
       return this.Create(object)
     }, options)
   }
-  /** `[Standard]` Creates a Record type */
-  public Record<K extends TUnion, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordUnionLiteralType<K, T>
-  /** `[Standard]` Creates a Record type */
-  public Record<K extends TLiteral<string | number>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordLiteralType<K, T>
-  /** `[Standard]` Creates a Record type */
-  public Record<K extends TTemplateLiteral, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordTemplateLiteralType<K, T>
-  /** `[Standard]` Creates a Record type */
-  public Record<K extends TInteger | TNumber, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordNumberType<K, T>
-  /** `[Standard]` Creates a Record type */
-  public Record<K extends TString, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordStringType<K, T>
-  /** `[Standard]` Creates a Record type */
-  public Record(key: RecordKey, schema: TSchema, options: ObjectOptions = {}) {
-    if (TypeGuard.TTemplateLiteral(key)) {
-      const expression = TemplateLiteralParser.ParseExact(key.pattern)
-      // prettier-ignore
-      return TemplateLiteralFinite.Check(expression)
-        ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(schema) }), {} as TProperties), options))
-        : this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema) }})
-    } else if (TypeGuard.TUnion(key)) {
-      const union = UnionResolver.Resolve(key)
-      if (TypeGuard.TUnionLiteral(union)) {
-        const properties = union.anyOf.reduce((acc: any, literal: any) => ({ ...acc, [literal.const]: TypeClone.Clone(schema) }), {} as TProperties)
-        return this.Object(properties, { ...options, [Hint]: 'Record' })
-      } else throw Error('StandardTypeBuilder: Record key of type union contains non-literal types')
-    } else if (TypeGuard.TLiteral(key)) {
-      if (ValueGuard.IsString(key.const) || ValueGuard.IsNumber(key.const)) {
-        return this.Object({ [key.const]: TypeClone.Clone(schema) }, options)
-      } else throw Error('StandardTypeBuilder: Record key of type literal is not of type string or number')
-    } else if (TypeGuard.TInteger(key) || TypeGuard.TNumber(key)) {
-      return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [PatternNumberExact]: TypeClone.Clone(schema) } })
-    } else if (TypeGuard.TString(key)) {
-      const pattern = ValueGuard.IsUndefined(key.pattern) ? PatternStringExact : key.pattern
-      return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema) } })
-    } else {
-      throw Error(`StandardTypeBuilder: Record key is an invalid type`)
-    }
+  /** `[Json]` Creates a Record type */
+  public Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options: ObjectOptions = {}): TRecordResolve<K, T> {
+    // prettier-ignore
+    return (
+      TypeGuard.TTemplateLiteral(key) ? (() => {
+        const expression = TemplateLiteralParser.ParseExact(key.pattern)
+        // prettier-ignore
+        return TemplateLiteralFinite.Check(expression)
+          ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Type(schema) }), {} as TProperties), options))
+          : this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Type(schema) }})
+      })() :
+      TypeGuard.TUnion(key) ? (() => {
+        const union = UnionResolver.Resolve(key)
+        if (TypeGuard.TUnionLiteral(union)) {
+          const properties = union.anyOf.reduce((acc: any, literal: any) => ({ ...acc, [literal.const]: TypeClone.Type(schema) }), {} as TProperties)
+          return this.Object(properties, { ...options, [Hint]: 'Record' })
+        } else this.Throw('Record key of type union contains non-literal types')
+      })() : 
+      TypeGuard.TLiteral(key) ? (() => {
+        // prettier-ignore
+        return (ValueGuard.IsString(key.const) || ValueGuard.IsNumber(key.const))
+        ? this.Object({ [key.const]: TypeClone.Type(schema) }, options)
+        : this.Throw('Record key of type literal is not of type string or number')
+      })() : 
+      TypeGuard.TInteger(key) || TypeGuard.TNumber(key) ? (() => {
+        return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [PatternNumberExact]: TypeClone.Type(schema) } })
+      })() : 
+      TypeGuard.TString(key) ? (() => {
+        const pattern = ValueGuard.IsUndefined(key.pattern) ? PatternStringExact : key.pattern
+        return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Type(schema) } })
+      })() : 
+      this.Never()
+    )
   }
-  /** `[Standard]` Creates a Recursive type */
+  /** `[Json]` Creates a Recursive type */
   public Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options: SchemaOptions = {}): TRecursive<T> {
     if (ValueGuard.IsUndefined(options.$id)) (options as any).$id = `T${TypeOrdinal++}`
     const thisType = callback({ [Kind]: 'This', $ref: `${options.$id}` } as any)
     thisType.$id = options.$id
     return this.Create({ ...options, [Hint]: 'Recursive', ...thisType } as any)
   }
-  /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
+  /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
   public Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>
-  /** `[Standard]` Creates a Ref type. */
+  /** `[Json]` Creates a Ref type. */
   public Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>
-  /** `[Standard]` Creates a Ref type. */
+  /** `[Json]` Creates a Ref type. */
   public Ref(unresolved: TSchema | string, options: SchemaOptions = {}) {
     if (ValueGuard.IsString(unresolved)) return this.Create({ ...options, [Kind]: 'Ref', $ref: unresolved })
-    if (ValueGuard.IsUndefined(unresolved.$id)) throw Error('StandardTypeBuilder.Ref: Target type must specify an $id')
+    if (ValueGuard.IsUndefined(unresolved.$id)) this.Throw('Reference target type must specify an $id')
     return this.Create({ ...options, [Kind]: 'Ref', $ref: unresolved.$id! })
   }
-  /** `[Standard]` Constructs a type where all properties are required */
+  /** `[Json]` Constructs a type where all properties are required */
   public Required<T extends TSchema>(schema: T, options: SchemaOptions = {}): TRequired<T> {
     // prettier-ignore
-    return ObjectMap.Map(schema, (object) => {
+    return ObjectMap.Map(this.Discard(TypeClone.Type(schema), Transform), (object) => {
       const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
         return { ...acc, [key]: this.Discard(object.properties[key], Optional) as TSchema }
       }, {} as TProperties)
       return this.Object(properties, object /* object used as options to retain other constraints  */)
     }, options)
   }
-  /** `[Standard]` Extracts the rest array from a Tuple */
+  /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
   public Rest<T extends TSchema>(schema: T): TRest<T> {
-    if (TypeGuard.TTuple(schema)) {
-      if (ValueGuard.IsUndefined(schema.items)) return [] as TSchema[] as TRest<T>
-      return schema.items.map((schema) => TypeClone.Clone(schema)) as TRest<T>
-    } else {
-      return [TypeClone.Clone(schema)] as TRest<T>
-    }
+    return (
+      TypeGuard.TTuple(schema) && !ValueGuard.IsUndefined(schema.items) ? TypeClone.Rest(schema.items) : TypeGuard.TIntersect(schema) ? TypeClone.Rest(schema.allOf) : TypeGuard.TUnion(schema) ? TypeClone.Rest(schema.anyOf) : []
+    ) as TRest<T>
   }
-  /** `[Standard]` Creates a String type */
+  /** `[Json]` Creates a String type */
   public String(options: StringOptions = {}): TString {
     return this.Create({ ...options, [Kind]: 'String', type: 'string' })
   }
-  /** `[Standard]` Creates a TemplateLiteral type from template dsl string */
+  /** `[Json]` Creates a TemplateLiteral type from template dsl string */
   public TemplateLiteral<T extends string>(templateDsl: T, options?: SchemaOptions): TTemplateLiteralDslParser<T>
-  /** `[Standard]` Creates a TemplateLiteral type */
+  /** `[Json]` Creates a TemplateLiteral type */
   public TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>
-  /** `[Standard]` Creates a TemplateLiteral type */
+  /** `[Json]` Creates a TemplateLiteral type */
   public TemplateLiteral(unresolved: unknown, options: SchemaOptions = {}) {
     // prettier-ignore
-    const pattern = (ValueGuard.IsString(unresolved))
+    const pattern = ValueGuard.IsString(unresolved)
       ? TemplateLiteralPattern.Create(TemplateLiteralDslParser.Parse(unresolved))
       : TemplateLiteralPattern.Create(unresolved as TTemplateLiteralKind[])
     return this.Create({ ...options, [Kind]: 'TemplateLiteral', type: 'string', pattern })
   }
-  /** `[Standard]` Creates a Tuple type */
+  /** `[Json]` Creates a Transform type */
+  public Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I> {
+    return new TransformDecodeBuilder(schema)
+  }
+  /** `[Json]` Creates a Tuple type */
   public Tuple<T extends TSchema[]>(items: [...T], options: SchemaOptions = {}): TTuple<T> {
     const [additionalItems, minItems, maxItems] = [false, items.length, items.length]
-    const clonedItems = items.map((item) => TypeClone.Clone(item))
+    const clonedItems = TypeClone.Rest(items)
     // prettier-ignore
     const schema = (items.length > 0 ? 
       { ...options, [Kind]: 'Tuple', type: 'array', items: clonedItems, additionalItems, minItems, maxItems } : 
       { ...options, [Kind]: 'Tuple', type: 'array', minItems, maxItems }) as any
     return this.Create(schema)
   }
-  /** `[Standard]` Intrinsic function to Uncapitalize LiteralString types */
+  /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
   public Uncapitalize<T extends TSchema>(schema: T, options: SchemaOptions = {}): TIntrinsic<T, 'Uncapitalize'> {
-    return { ...Intrinsic.Map(TypeClone.Clone(schema), 'Uncapitalize'), ...options }
+    return { ...Intrinsic.Map(TypeClone.Type(schema), 'Uncapitalize'), ...options }
   }
-  /** `[Standard]` Creates a Union type */
+  /** `[Json]` Creates a Union type */
   public Union(anyOf: [], options?: SchemaOptions): TNever
-  /** `[Standard]` Creates a Union type */
+  /** `[Json]` Creates a Union type */
   public Union<T extends [TSchema]>(anyOf: [...T], options?: SchemaOptions): T[0]
-  /** `[Standard]` Creates a Union type */
+  /** `[Json]` Creates a Union type */
   public Union<T extends TSchema[]>(anyOf: [...T], options?: SchemaOptions): TUnion<T>
-  /** `[Experimental]` Converts a TemplateLiteral into a Union */
+  /** `[Json-Experimental]` Converts a TemplateLiteral into a Union */
   public Union<T extends TTemplateLiteral>(template: T): TUnionTemplateLiteral<T>
-  /** `[Standard]` Creates a Union type */
+  /** `[Json]` Creates a Union type */
   public Union(union: TSchema[] | TTemplateLiteral, options: SchemaOptions = {}) {
-    if (TypeGuard.TTemplateLiteral(union)) {
-      return TemplateLiteralResolver.Resolve(union)
-    } else {
-      const anyOf = union
-      if (anyOf.length === 0) return this.Never(options)
-      if (anyOf.length === 1) return this.Create(TypeClone.Clone(anyOf[0], options))
-      const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema))
-      return this.Create({ ...options, [Kind]: 'Union', anyOf: clonedAnyOf })
-    }
-  }
-  /** `[Standard]` Creates an Unknown type */
+    // prettier-ignore
+    return TypeGuard.TTemplateLiteral(union) 
+      ? TemplateLiteralResolver.Resolve(union)
+      : (() => {
+        const anyOf = union
+        if (anyOf.length === 0) return this.Never(options)
+        if (anyOf.length === 1) return this.Create(TypeClone.Type(anyOf[0], options))
+        const clonedAnyOf = TypeClone.Rest(anyOf)
+        return this.Create({ ...options, [Kind]: 'Union', anyOf: clonedAnyOf })
+      })()
+  }
+  /** `[Json]` Creates an Unknown type */
   public Unknown(options: SchemaOptions = {}): TUnknown {
     return this.Create({ ...options, [Kind]: 'Unknown' })
   }
-  /** `[Standard]` Creates a Unsafe type that will infers as the generic argument T */
+  /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
   public Unsafe<T>(options: UnsafeOptions = {}): TUnsafe<T> {
     return this.Create({ ...options, [Kind]: options[Kind] || 'Unsafe' })
   }
-  /** `[Standard]` Intrinsic function to Uppercase LiteralString types */
+  /** `[Json]` Intrinsic function to Uppercase LiteralString types */
   public Uppercase<T extends TSchema>(schema: T, options: SchemaOptions = {}): TIntrinsic<T, 'Uppercase'> {
-    return { ...Intrinsic.Map(TypeClone.Clone(schema), 'Uppercase'), ...options }
+    return { ...Intrinsic.Map(TypeClone.Type(schema), 'Uppercase'), ...options }
   }
 }
 // --------------------------------------------------------------------------
-// ExtendedTypeBuilder
+// JavaScriptTypeBuilder
 // --------------------------------------------------------------------------
-export class ExtendedTypeBuilder extends StandardTypeBuilder {
-  /** `[Extended]` Creates a AsyncIterator type */
+export class JavaScriptTypeBuilder extends JsonTypeBuilder {
+  /** `[JavaScript]` Creates a AsyncIterator type */
   public AsyncIterator<T extends TSchema>(items: T, options: SchemaOptions = {}): TAsyncIterator<T> {
-    return this.Create({ ...options, [Kind]: 'AsyncIterator', type: 'AsyncIterator', items: TypeClone.Clone(items) })
+    return this.Create({ ...options, [Kind]: 'AsyncIterator', type: 'AsyncIterator', items: TypeClone.Type(items) })
   }
-  /** `[Extended]` Constructs a type by recursively unwrapping Promise types */
+  /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
   public Awaited<T extends TSchema>(schema: T, options: SchemaOptions = {}): TAwaited<T> {
-    const AwaitedRest = (rest: TSchema[]): TSchema[] => {
-      if (rest.length === 0) return rest
+    // prettier-ignore
+    const Unwrap = (rest: TSchema[]): TSchema[] => rest.length > 0 ? (() => {
       const [L, ...R] = rest
-      return [this.Awaited(L), ...AwaitedRest(R)]
-    }
+      return [this.Awaited(L), ...Unwrap(R)]
+    })() : rest
     // prettier-ignore
     return (
-      TypeGuard.TIntersect(schema) ? Type.Intersect(AwaitedRest(schema.allOf)) : 
-      TypeGuard.TUnion(schema) ? Type.Union(AwaitedRest(schema.anyOf)) :
+      TypeGuard.TIntersect(schema) ? Type.Intersect(Unwrap(schema.allOf)) : 
+      TypeGuard.TUnion(schema) ? Type.Union(Unwrap(schema.anyOf)) :
       TypeGuard.TPromise(schema) ? this.Awaited(schema.item) : 
-      TypeClone.Clone(schema, options)
+      TypeClone.Type(schema, options)
     ) as TAwaited<T>
   }
-  /** `[Extended]` Creates a BigInt type */
+  /** `[JavaScript]` Creates a BigInt type */
   public BigInt(options: NumericOptions<bigint> = {}): TBigInt {
     return this.Create({ ...options, [Kind]: 'BigInt', type: 'bigint' })
   }
-  /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
+  /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
   public ConstructorParameters<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TConstructorParameters<T> {
     return this.Tuple([...schema.parameters], { ...options })
   }
-  /** `[Extended]` Creates a Constructor type */
+  /** `[JavaScript]` Creates a Constructor type */
   public Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U> {
-    const clonedReturns = TypeClone.Clone(returns)
-    const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter))
+    const [clonedParameters, clonedReturns] = [TypeClone.Rest(parameters), TypeClone.Type(returns)]
     return this.Create({ ...options, [Kind]: 'Constructor', type: 'constructor', parameters: clonedParameters, returns: clonedReturns })
   }
-  /** `[Extended]` Creates a Date type */
+  /** `[JavaScript]` Creates a Date type */
   public Date(options: DateOptions = {}): TDate {
     return this.Create({ ...options, [Kind]: 'Date', type: 'Date' })
   }
-  /** `[Extended]` Creates a Function type */
+  /** `[JavaScript]` Creates a Function type */
   public Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U> {
-    const clonedReturns = TypeClone.Clone(returns, {})
-    const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter))
+    const [clonedParameters, clonedReturns] = [TypeClone.Rest(parameters), TypeClone.Type(returns)]
     return this.Create({ ...options, [Kind]: 'Function', type: 'function', parameters: clonedParameters, returns: clonedReturns })
   }
-  /** `[Extended]` Extracts the InstanceType from the given Constructor type */
+  /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
   public InstanceType<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TInstanceType<T> {
-    return TypeClone.Clone(schema.returns, options)
+    return TypeClone.Type(schema.returns, options)
   }
-  /** `[Extended]` Creates an Iterator type */
+  /** `[JavaScript]` Creates an Iterator type */
   public Iterator<T extends TSchema>(items: T, options: SchemaOptions = {}): TIterator<T> {
-    return this.Create({ ...options, [Kind]: 'Iterator', type: 'Iterator', items: TypeClone.Clone(items) })
+    return this.Create({ ...options, [Kind]: 'Iterator', type: 'Iterator', items: TypeClone.Type(items) })
   }
-  /** `[Extended]` Extracts the Parameters from the given Function type */
+  /** `[JavaScript]` Extracts the Parameters from the given Function type */
   public Parameters<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TParameters<T> {
     return this.Tuple(schema.parameters, { ...options })
   }
-  /** `[Extended]` Creates a Promise type */
+  /** `[JavaScript]` Creates a Promise type */
   public Promise<T extends TSchema>(item: T, options: SchemaOptions = {}): TPromise<T> {
-    return this.Create({ ...options, [Kind]: 'Promise', type: 'Promise', item: TypeClone.Clone(item) })
+    return this.Create({ ...options, [Kind]: 'Promise', type: 'Promise', item: TypeClone.Type(item) })
   }
-  /** `[Extended]` Creates a String type from a Regular Expression pattern */
+  /** `[JavaScript]` Creates a String type from a Regular Expression pattern */
   public RegExp(pattern: string, options?: SchemaOptions): TString
-  /** `[Extended]` Creates a String type from a Regular Expression */
+  /** `[JavaScript]` Creates a String type from a Regular Expression */
   public RegExp(regex: RegExp, options?: SchemaOptions): TString
   /** `[Extended]` Creates a String type */
   public RegExp(unresolved: string | RegExp, options: SchemaOptions = {}) {
@@ -3060,28 +3336,28 @@ export class ExtendedTypeBuilder extends StandardTypeBuilder {
   public RegEx(regex: RegExp, options: SchemaOptions = {}): TString {
     return this.RegExp(regex, options)
   }
-  /** `[Extended]` Extracts the ReturnType from the given Function type */
+  /** `[JavaScript]` Extracts the ReturnType from the given Function type */
   public ReturnType<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TReturnType<T> {
-    return TypeClone.Clone(schema.returns, options)
+    return TypeClone.Type(schema.returns, options)
   }
-  /** `[Extended]` Creates a Symbol type */
+  /** `[JavaScript]` Creates a Symbol type */
   public Symbol(options?: SchemaOptions): TSymbol {
     return this.Create({ ...options, [Kind]: 'Symbol', type: 'symbol' })
   }
-  /** `[Extended]` Creates a Undefined type */
+  /** `[JavaScript]` Creates a Undefined type */
   public Undefined(options: SchemaOptions = {}): TUndefined {
     return this.Create({ ...options, [Kind]: 'Undefined', type: 'undefined' })
   }
-  /** `[Extended]` Creates a Uint8Array type */
+  /** `[JavaScript]` Creates a Uint8Array type */
   public Uint8Array(options: Uint8ArrayOptions = {}): TUint8Array {
     return this.Create({ ...options, [Kind]: 'Uint8Array', type: 'Uint8Array' })
   }
-  /** `[Extended]` Creates a Void type */
+  /** `[JavaScript]` Creates a Void type */
   public Void(options: SchemaOptions = {}): TVoid {
     return this.Create({ ...options, [Kind]: 'Void', type: 'void' })
   }
 }
-/** JSON Schema Type Builder with Static Resolution for TypeScript */
-export const StandardType = new StandardTypeBuilder()
-/** JSON Schema Type Builder with Static Resolution for TypeScript */
-export const Type = new ExtendedTypeBuilder()
+/** Json Type Builder with Static Resolution for TypeScript */
+export const JsonType = new JsonTypeBuilder()
+/** JavaScript Type Builder with Static Resolution for TypeScript */
+export const Type = new JavaScriptTypeBuilder()
diff --git a/src/value/cast.ts b/src/value/cast.ts
index 5b284dcbc..16e3ec9cf 100644
--- a/src/value/cast.ts
+++ b/src/value/cast.ts
@@ -26,43 +26,34 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { IsPlainObject, IsArray, IsString, IsNumber, IsNull } from './guard'
+import { Create } from './create'
+import { Check } from './check'
+import { Clone } from './clone'
+import { Deref } from './deref'
 import * as Types from '../typebox'
-import * as ValueCreate from './create'
-import * as ValueCheck from './check'
-import * as ValueClone from './clone'
-import * as ValueGuard from './guard'
 
 // --------------------------------------------------------------------------
 // Errors
 // --------------------------------------------------------------------------
-export class ValueCastReferenceTypeError extends Error {
-  constructor(public readonly schema: Types.TRef | Types.TThis) {
-    super(`ValueCast: Cannot locate referenced schema with $id '${schema.$ref}'`)
-  }
-}
-export class ValueCastArrayUniqueItemsTypeError extends Error {
+export class ValueCastArrayUniqueItemsTypeError extends Types.TypeBoxError {
   constructor(public readonly schema: Types.TSchema, public readonly value: unknown) {
-    super('ValueCast: Array cast produced invalid data due to uniqueItems constraint')
+    super('Array cast produced invalid data due to uniqueItems constraint')
   }
 }
-export class ValueCastNeverTypeError extends Error {
+export class ValueCastNeverTypeError extends Types.TypeBoxError {
   constructor(public readonly schema: Types.TSchema) {
-    super('ValueCast: Never types cannot be cast')
+    super('Never types cannot be cast')
   }
 }
-export class ValueCastRecursiveTypeError extends Error {
+export class ValueCastRecursiveTypeError extends Types.TypeBoxError {
   constructor(public readonly schema: Types.TSchema) {
-    super('ValueCast.Recursive: Cannot cast recursive schemas')
+    super('Cannot cast recursive schemas')
   }
 }
-export class ValueCastUnknownTypeError extends Error {
+export class ValueCastUnknownTypeError extends Types.TypeBoxError {
   constructor(public readonly schema: Types.TSchema) {
-    super('ValueCast: Unknown type')
-  }
-}
-export class ValueCastDereferenceError extends Error {
-  constructor(public readonly schema: Types.TRef | Types.TThis) {
-    super(`ValueCast: Unable to dereference type with $id '${schema.$ref}'`)
+    super('Unknown type')
   }
 }
 // --------------------------------------------------------------------------
@@ -74,19 +65,19 @@ export class ValueCastDereferenceError extends Error {
 // --------------------------------------------------------------------------
 namespace UnionCastCreate {
   function Score(schema: Types.TSchema, references: Types.TSchema[], value: any): number {
-    if (schema[Types.Kind] === 'Object' && typeof value === 'object' && !ValueGuard.IsNull(value)) {
+    if (schema[Types.Kind] === 'Object' && typeof value === 'object' && !IsNull(value)) {
       const object = schema as Types.TObject
       const keys = Object.getOwnPropertyNames(value)
       const entries = Object.entries(object.properties)
       const [point, max] = [1 / entries.length, entries.length]
       return entries.reduce((acc, [key, schema]) => {
         const literal = schema[Types.Kind] === 'Literal' && schema.const === value[key] ? max : 0
-        const checks = ValueCheck.Check(schema, references, value[key]) ? point : 0
+        const checks = Check(schema, references, value[key]) ? point : 0
         const exists = keys.includes(key) ? point : 0
         return acc + (literal + checks + exists)
       }, 0)
     } else {
-      return ValueCheck.Check(schema, references, value) ? 1 : 0
+      return Check(schema, references, value) ? 1 : 0
     }
   }
   function Select(union: Types.TUnion, references: Types.TSchema[], value: any): Types.TSchema {
@@ -110,33 +101,30 @@ namespace UnionCastCreate {
   }
 }
 // --------------------------------------------------------------------------
-// Cast
+// Default
 // --------------------------------------------------------------------------
-function TAny(schema: Types.TAny, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+export function DefaultClone(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
+  return Check(schema, references, value) ? Clone(value) : Create(schema, references)
+}
+export function Default(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
+  return Check(schema, references, value) ? value : Create(schema, references)
 }
+// --------------------------------------------------------------------------
+// Cast
+// --------------------------------------------------------------------------
 function TArray(schema: Types.TArray, references: Types.TSchema[], value: any): any {
-  if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
-  const created = ValueGuard.IsArray(value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-  const minimum = ValueGuard.IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...Array.from({ length: schema.minItems - created.length }, () => null)] : created
-  const maximum = ValueGuard.IsNumber(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum
+  if (Check(schema, references, value)) return Clone(value)
+  const created = IsArray(value) ? Clone(value) : Create(schema, references)
+  const minimum = IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...Array.from({ length: schema.minItems - created.length }, () => null)] : created
+  const maximum = IsNumber(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum
   const casted = maximum.map((value: unknown) => Visit(schema.items, references, value))
   if (schema.uniqueItems !== true) return casted
   const unique = [...new Set(casted)]
-  if (!ValueCheck.Check(schema, references, unique)) throw new ValueCastArrayUniqueItemsTypeError(schema, unique)
+  if (!Check(schema, references, unique)) throw new ValueCastArrayUniqueItemsTypeError(schema, unique)
   return unique
 }
-function TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-}
-function TBigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-}
-function TBoolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-}
 function TConstructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): any {
-  if (ValueCheck.Check(schema, references, value)) return ValueCreate.Create(schema, references)
+  if (Check(schema, references, value)) return Create(schema, references)
   const required = new Set(schema.returns.required || [])
   const result = function () {}
   for (const [key, property] of Object.entries(schema.returns.properties)) {
@@ -145,41 +133,17 @@ function TConstructor(schema: Types.TConstructor, references: Types.TSchema[], v
   }
   return result
 }
-function TDate(schema: Types.TDate, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-}
-function TFunction(schema: Types.TFunction, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-}
-function TInteger(schema: Types.TInteger, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-}
 function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any): any {
-  const created = ValueCreate.Create(schema, references)
-  const mapped = ValueGuard.IsPlainObject(created) && ValueGuard.IsPlainObject(value) ? { ...(created as any), ...value } : value
-  return ValueCheck.Check(schema, references, mapped) ? mapped : ValueCreate.Create(schema, references)
-}
-function TIterator(schema: Types.TIterator, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-}
-function TLiteral(schema: Types.TLiteral, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
+  const created = Create(schema, references)
+  const mapped = IsPlainObject(created) && IsPlainObject(value) ? { ...(created as any), ...value } : value
+  return Check(schema, references, mapped) ? mapped : Create(schema, references)
 }
 function TNever(schema: Types.TNever, references: Types.TSchema[], value: any): any {
   throw new ValueCastNeverTypeError(schema)
 }
-function TNot(schema: Types.TNot, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-}
-function TNull(schema: Types.TNull, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-}
-function TNumber(schema: Types.TNumber, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-}
 function TObject(schema: Types.TObject, references: Types.TSchema[], value: any): any {
-  if (ValueCheck.Check(schema, references, value)) return value
-  if (value === null || typeof value !== 'object') return ValueCreate.Create(schema, references)
+  if (Check(schema, references, value)) return value
+  if (value === null || typeof value !== 'object') return Create(schema, references)
   const required = new Set(schema.required || [])
   const result = {} as Record<string, any>
   for (const [key, property] of Object.entries(schema.properties)) {
@@ -196,12 +160,9 @@ function TObject(schema: Types.TObject, references: Types.TSchema[], value: any)
   }
   return result
 }
-function TPromise(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-}
 function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): any {
-  if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
-  if (value === null || typeof value !== 'object' || Array.isArray(value) || value instanceof Date) return ValueCreate.Create(schema, references)
+  if (Check(schema, references, value)) return Clone(value)
+  if (value === null || typeof value !== 'object' || Array.isArray(value) || value instanceof Date) return Create(schema, references)
   const subschemaPropertyName = Object.getOwnPropertyNames(schema.patternProperties)[0]
   const subschema = schema.patternProperties[subschemaPropertyName]
   const result = {} as Record<string, any>
@@ -211,117 +172,78 @@ function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], v
   return result
 }
 function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any): any {
-  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-  if (index === -1) throw new ValueCastDereferenceError(schema)
-  const target = references[index]
-  return Visit(target, references, value)
-}
-function TString(schema: Types.TString, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references)
-}
-function TSymbol(schema: Types.TSymbol, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-}
-function TTemplateLiteral(schema: Types.TSymbol, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+  return Visit(Deref(schema, references), references, value)
 }
 function TThis(schema: Types.TThis, references: Types.TSchema[], value: any): any {
-  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-  if (index === -1) throw new ValueCastDereferenceError(schema)
-  const target = references[index]
-  return Visit(target, references, value)
+  return Visit(Deref(schema, references), references, value)
 }
 function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): any {
-  if (ValueCheck.Check(schema, references, value)) return ValueClone.Clone(value)
-  if (!ValueGuard.IsArray(value)) return ValueCreate.Create(schema, references)
+  if (Check(schema, references, value)) return Clone(value)
+  if (!IsArray(value)) return Create(schema, references)
   if (schema.items === undefined) return []
   return schema.items.map((schema, index) => Visit(schema, references, value[index]))
 }
-function TUndefined(schema: Types.TUndefined, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-}
 function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : UnionCastCreate.Create(schema, references, value)
-}
-function TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-}
-function TUnknown(schema: Types.TUnknown, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-}
-function TVoid(schema: Types.TVoid, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
-}
-function TKind(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
-  return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references)
+  return Check(schema, references, value) ? Clone(value) : UnionCastCreate.Create(schema, references, value)
 }
 function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
-  const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references
+  const references_ = IsString(schema.$id) ? [...references, schema] : references
   const schema_ = schema as any
   switch (schema[Types.Kind]) {
-    case 'Any':
-      return TAny(schema_, references_, value)
+    // ------------------------------------------------------
+    // Structural
+    // ------------------------------------------------------
     case 'Array':
       return TArray(schema_, references_, value)
-    case 'AsyncIterator':
-      return TAsyncIterator(schema_, references_, value)
-    case 'BigInt':
-      return TBigInt(schema_, references_, value)
-    case 'Boolean':
-      return TBoolean(schema_, references_, value)
     case 'Constructor':
       return TConstructor(schema_, references_, value)
-    case 'Date':
-      return TDate(schema_, references_, value)
-    case 'Function':
-      return TFunction(schema_, references_, value)
-    case 'Integer':
-      return TInteger(schema_, references_, value)
     case 'Intersect':
       return TIntersect(schema_, references_, value)
-    case 'Iterator':
-      return TIterator(schema_, references_, value)
-    case 'Literal':
-      return TLiteral(schema_, references_, value)
     case 'Never':
       return TNever(schema_, references_, value)
-    case 'Not':
-      return TNot(schema_, references_, value)
-    case 'Null':
-      return TNull(schema_, references_, value)
-    case 'Number':
-      return TNumber(schema_, references_, value)
     case 'Object':
       return TObject(schema_, references_, value)
-    case 'Promise':
-      return TPromise(schema_, references_, value)
     case 'Record':
       return TRecord(schema_, references_, value)
     case 'Ref':
       return TRef(schema_, references_, value)
-    case 'String':
-      return TString(schema_, references_, value)
-    case 'Symbol':
-      return TSymbol(schema_, references_, value)
-    case 'TemplateLiteral':
-      return TTemplateLiteral(schema_, references_, value)
     case 'This':
       return TThis(schema_, references_, value)
     case 'Tuple':
       return TTuple(schema_, references_, value)
-    case 'Undefined':
-      return TUndefined(schema_, references_, value)
     case 'Union':
       return TUnion(schema_, references_, value)
+    // ------------------------------------------------------
+    // DefaultClone
+    // ------------------------------------------------------
+    case 'Date':
+    case 'Symbol':
     case 'Uint8Array':
-      return TUint8Array(schema_, references_, value)
+      return DefaultClone(schema, references, value)
+    // ------------------------------------------------------
+    // Default
+    // ------------------------------------------------------
+    case 'Any':
+    case 'AsyncIterator':
+    case 'BigInt':
+    case 'Boolean':
+    case 'Function':
+    case 'Integer':
+    case 'Iterator':
+    case 'Literal':
+    case 'Not':
+    case 'Null':
+    case 'Number':
+    case 'Promise':
+    case 'String':
+    case 'TemplateLiteral':
+    case 'Undefined':
     case 'Unknown':
-      return TUnknown(schema_, references_, value)
     case 'Void':
-      return TVoid(schema_, references_, value)
+      return Default(schema_, references_, value)
     default:
       if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueCastUnknownTypeError(schema_)
-      return TKind(schema_, references_, value)
+      return Default(schema_, references_, value)
   }
 }
 // --------------------------------------------------------------------------
diff --git a/src/value/check.ts b/src/value/check.ts
index 624e08eda..7e987708c 100644
--- a/src/value/check.ts
+++ b/src/value/check.ts
@@ -26,22 +26,18 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { TypeSystem } from '../system/index'
+import { IsArray, IsUint8Array, IsDate, IsPromise, IsFunction, IsAsyncIterator, IsIterator, IsBoolean, IsNumber, IsBigInt, IsString, IsSymbol, IsInteger, IsNull, IsUndefined } from './guard'
+import { TypeSystemPolicy } from '../system/index'
+import { Deref } from './deref'
+import { Hash } from './hash'
 import * as Types from '../typebox'
-import * as ValueGuard from './guard'
-import * as ValueHash from './hash'
 
 // --------------------------------------------------------------------------
 // Errors
 // --------------------------------------------------------------------------
-export class ValueCheckUnknownTypeError extends Error {
+export class ValueCheckUnknownTypeError extends Types.TypeBoxError {
   constructor(public readonly schema: Types.TSchema) {
-    super(`ValueCheck: ${schema[Types.Kind] ? `Unknown type '${schema[Types.Kind]}'` : 'Unknown type'}`)
-  }
-}
-export class ValueCheckDereferenceError extends Error {
-  constructor(public readonly schema: Types.TRef | Types.TThis) {
-    super(`ValueCheck: Unable to dereference type with $id '${schema.$ref}'`)
+    super(`Unknown type`)
   }
 }
 // --------------------------------------------------------------------------
@@ -57,36 +53,13 @@ function IsDefined<T>(value: unknown): value is T {
   return value !== undefined
 }
 // --------------------------------------------------------------------------
-// Policies
-// --------------------------------------------------------------------------
-function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string) {
-  return TypeSystem.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined
-}
-function IsObject(value: unknown): value is Record<keyof any, unknown> {
-  const isObject = ValueGuard.IsObject(value)
-  return TypeSystem.AllowArrayObjects ? isObject : isObject && !ValueGuard.IsArray(value)
-}
-function IsRecordObject(value: unknown): value is Record<keyof any, unknown> {
-  return IsObject(value) && !(value instanceof Date) && !(value instanceof Uint8Array)
-}
-function IsNumber(value: unknown): value is number {
-  const isNumber = ValueGuard.IsNumber(value)
-  return TypeSystem.AllowNaN ? isNumber : isNumber && Number.isFinite(value)
-}
-function IsVoid(value: unknown): value is void {
-  const isUndefined = ValueGuard.IsUndefined(value)
-  return TypeSystem.AllowVoidNull ? isUndefined || value === null : isUndefined
-}
-// --------------------------------------------------------------------------
 // Types
 // --------------------------------------------------------------------------
 function TAny(schema: Types.TAny, references: Types.TSchema[], value: any): boolean {
   return true
 }
 function TArray(schema: Types.TArray, references: Types.TSchema[], value: any): boolean {
-  if (!Array.isArray(value)) {
-    return false
-  }
+  if (!IsArray(value)) return false
   if (IsDefined<number>(schema.minItems) && !(value.length >= schema.minItems)) {
     return false
   }
@@ -97,7 +70,7 @@ function TArray(schema: Types.TArray, references: Types.TSchema[], value: any):
     return false
   }
   // prettier-ignore
-  if (schema.uniqueItems === true && !((function() { const set = new Set(); for(const element of value) { const hashed = ValueHash.Hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())) {
+  if (schema.uniqueItems === true && !((function() { const set = new Set(); for(const element of value) { const hashed = Hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())) {
       return false
     }
   // contains
@@ -105,7 +78,7 @@ function TArray(schema: Types.TArray, references: Types.TSchema[], value: any):
     return true // exit
   }
   const containsSchema = IsDefined<Types.TSchema>(schema.contains) ? schema.contains : Types.Type.Never()
-  const containsCount = value.reduce((acc, value) => (Visit(containsSchema, references, value) ? acc + 1 : acc), 0)
+  const containsCount = value.reduce((acc: number, value) => (Visit(containsSchema, references, value) ? acc + 1 : acc), 0)
   if (containsCount === 0) {
     return false
   }
@@ -118,76 +91,72 @@ function TArray(schema: Types.TArray, references: Types.TSchema[], value: any):
   return true
 }
 function TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[], value: any): boolean {
-  return IsObject(value) && Symbol.asyncIterator in value
+  return IsAsyncIterator(value)
 }
 function TBigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any): boolean {
-  if (!ValueGuard.IsBigInt(value)) {
-    return false
-  }
-  if (IsDefined<bigint>(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) {
+  if (!IsBigInt(value)) return false
+  if (IsDefined<bigint>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
     return false
   }
   if (IsDefined<bigint>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
     return false
   }
-  if (IsDefined<bigint>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+  if (IsDefined<bigint>(schema.maximum) && !(value <= schema.maximum)) {
     return false
   }
   if (IsDefined<bigint>(schema.minimum) && !(value >= schema.minimum)) {
     return false
   }
-  if (IsDefined<bigint>(schema.maximum) && !(value <= schema.maximum)) {
+  if (IsDefined<bigint>(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) {
     return false
   }
   return true
 }
 function TBoolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): boolean {
-  return typeof value === 'boolean'
+  return IsBoolean(value)
 }
 function TConstructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): boolean {
   return Visit(schema.returns, references, value.prototype)
 }
 function TDate(schema: Types.TDate, references: Types.TSchema[], value: any): boolean {
-  if (!(value instanceof Date)) {
-    return false
-  }
-  if (!IsNumber(value.getTime())) {
+  if (!IsDate(value)) return false
+  if (IsDefined<number>(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
     return false
   }
   if (IsDefined<number>(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
     return false
   }
-  if (IsDefined<number>(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+  if (IsDefined<number>(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
     return false
   }
   if (IsDefined<number>(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
     return false
   }
-  if (IsDefined<number>(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
+  if (IsDefined<number>(schema.multipleOfTimestamp) && !(value.getTime() % schema.multipleOfTimestamp === 0)) {
     return false
   }
   return true
 }
 function TFunction(schema: Types.TFunction, references: Types.TSchema[], value: any): boolean {
-  return typeof value === 'function'
+  return IsFunction(value)
 }
 function TInteger(schema: Types.TInteger, references: Types.TSchema[], value: any): boolean {
-  if (!ValueGuard.IsInteger(value)) {
+  if (!IsInteger(value)) {
     return false
   }
-  if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+  if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
     return false
   }
   if (IsDefined<number>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
     return false
   }
-  if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+  if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
     return false
   }
   if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
     return false
   }
-  if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
+  if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
     return false
   }
   return true
@@ -207,7 +176,7 @@ function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value
   }
 }
 function TIterator(schema: Types.TIterator, references: Types.TSchema[], value: any): boolean {
-  return IsObject(value) && Symbol.iterator in value
+  return IsIterator(value)
 }
 function TLiteral(schema: Types.TLiteral, references: Types.TSchema[], value: any): boolean {
   return value === schema.const
@@ -219,33 +188,29 @@ function TNot(schema: Types.TNot, references: Types.TSchema[], value: any): bool
   return !Visit(schema.not, references, value)
 }
 function TNull(schema: Types.TNull, references: Types.TSchema[], value: any): boolean {
-  return value === null
+  return IsNull(value)
 }
 function TNumber(schema: Types.TNumber, references: Types.TSchema[], value: any): boolean {
-  if (!IsNumber(value)) {
-    return false
-  }
-  if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+  if (!TypeSystemPolicy.IsNumberLike(value)) return false
+  if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
     return false
   }
   if (IsDefined<number>(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
     return false
   }
-  if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    return false
-  }
   if (IsDefined<number>(schema.minimum) && !(value >= schema.minimum)) {
     return false
   }
   if (IsDefined<number>(schema.maximum) && !(value <= schema.maximum)) {
     return false
   }
+  if (IsDefined<number>(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    return false
+  }
   return true
 }
 function TObject(schema: Types.TObject, references: Types.TSchema[], value: any): boolean {
-  if (!IsObject(value)) {
-    return false
-  }
+  if (!TypeSystemPolicy.IsObjectLike(value)) return false
   if (IsDefined<number>(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
     return false
   }
@@ -263,7 +228,7 @@ function TObject(schema: Types.TObject, references: Types.TSchema[], value: any)
         return false
       }
     } else {
-      if (IsExactOptionalProperty(value, knownKey) && !Visit(property, references, value[knownKey])) {
+      if (TypeSystemPolicy.IsExactOptionalProperty(value, knownKey) && !Visit(property, references, value[knownKey])) {
         return false
       }
     }
@@ -284,10 +249,10 @@ function TObject(schema: Types.TObject, references: Types.TSchema[], value: any)
   }
 }
 function TPromise(schema: Types.TPromise<any>, references: Types.TSchema[], value: any): boolean {
-  return typeof value === 'object' && typeof value.then === 'function'
+  return IsPromise(value)
 }
 function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): boolean {
-  if (!IsRecordObject(value)) {
+  if (!TypeSystemPolicy.IsRecordLike(value)) {
     return false
   }
   if (IsDefined<number>(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
@@ -298,27 +263,27 @@ function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], v
   }
   const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0]
   const regex = new RegExp(patternKey)
-  return Object.entries(value).every(([key, value]) => {
-    if (regex.test(key)) {
-      return Visit(patternSchema, references, value)
-    }
-    if (typeof schema.additionalProperties === 'object') {
-      return Visit(schema.additionalProperties, references, value)
-    }
-    if (schema.additionalProperties === false) {
-      return false
-    }
-    return true
+  // prettier-ignore
+  const check1 = Object.entries(value).every(([key, value]) => {
+    return (regex.test(key)) ? Visit(patternSchema, references, value) : true
   })
+  // prettier-ignore
+  const check2 = typeof schema.additionalProperties === 'object' ? Object.entries(value).every(([key, value]) => {
+    return (!regex.test(key)) ? Visit(schema.additionalProperties as Types.TSchema, references, value) : true
+  }) : true
+  const check3 =
+    schema.additionalProperties === false
+      ? Object.getOwnPropertyNames(value).every((key) => {
+          return regex.test(key)
+        })
+      : true
+  return check1 && check2 && check3
 }
 function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any): boolean {
-  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-  if (index === -1) throw new ValueCheckDereferenceError(schema)
-  const target = references[index]
-  return Visit(target, references, value)
+  return Visit(Deref(schema, references), references, value)
 }
 function TString(schema: Types.TString, references: Types.TSchema[], value: any): boolean {
-  if (!ValueGuard.IsString(value)) {
+  if (!IsString(value)) {
     return false
   }
   if (IsDefined<number>(schema.minLength)) {
@@ -339,25 +304,16 @@ function TString(schema: Types.TString, references: Types.TSchema[], value: any)
   return true
 }
 function TSymbol(schema: Types.TSymbol, references: Types.TSchema[], value: any): boolean {
-  if (!(typeof value === 'symbol')) {
-    return false
-  }
-  return true
+  return IsSymbol(value)
 }
 function TTemplateLiteral(schema: Types.TTemplateLiteralKind, references: Types.TSchema[], value: any): boolean {
-  if (!ValueGuard.IsString(value)) {
-    return false
-  }
-  return new RegExp(schema.pattern).test(value)
+  return IsString(value) && new RegExp(schema.pattern).test(value)
 }
 function TThis(schema: Types.TThis, references: Types.TSchema[], value: any): boolean {
-  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-  if (index === -1) throw new ValueCheckDereferenceError(schema)
-  const target = references[index]
-  return Visit(target, references, value)
+  return Visit(Deref(schema, references), references, value)
 }
 function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): boolean {
-  if (!ValueGuard.IsArray(value)) {
+  if (!IsArray(value)) {
     return false
   }
   if (schema.items === undefined && !(value.length === 0)) {
@@ -375,13 +331,13 @@ function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value:
   return true
 }
 function TUndefined(schema: Types.TUndefined, references: Types.TSchema[], value: any): boolean {
-  return value === undefined
+  return IsUndefined(value)
 }
 function TUnion(schema: Types.TUnion<any[]>, references: Types.TSchema[], value: any): boolean {
   return schema.anyOf.some((inner) => Visit(inner, references, value))
 }
 function TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): boolean {
-  if (!(value instanceof Uint8Array)) {
+  if (!IsUint8Array(value)) {
     return false
   }
   if (IsDefined<number>(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
@@ -396,7 +352,7 @@ function TUnknown(schema: Types.TUnknown, references: Types.TSchema[], value: an
   return true
 }
 function TVoid(schema: Types.TVoid, references: Types.TSchema[], value: any): boolean {
-  return IsVoid(value)
+  return TypeSystemPolicy.IsVoidLike(value)
 }
 function TKind(schema: Types.TSchema, references: Types.TSchema[], value: unknown): boolean {
   if (!Types.TypeRegistry.Has(schema[Types.Kind])) return false
diff --git a/src/value/clone.ts b/src/value/clone.ts
index ef1ecb51d..a2e2d1f30 100644
--- a/src/value/clone.ts
+++ b/src/value/clone.ts
@@ -26,40 +26,26 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import * as ValueGuard from './guard'
+import { IsArray, IsDate, IsPlainObject, IsTypedArray, IsValueType } from './guard'
+import type { ObjectType, ArrayType, TypedArrayType, ValueType } from './guard'
 
 // --------------------------------------------------------------------------
 // Clonable
 // --------------------------------------------------------------------------
-function ObjectType(value: ValueGuard.ObjectType): any {
+function ObjectType(value: ObjectType): any {
   const keys = [...Object.getOwnPropertyNames(value), ...Object.getOwnPropertySymbols(value)]
   return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {})
 }
-function ArrayType(value: ValueGuard.ArrayType): any {
+function ArrayType(value: ArrayType): any {
   return value.map((element: any) => Clone(element))
 }
-function TypedArrayType(value: ValueGuard.TypedArrayType): any {
+function TypedArrayType(value: TypedArrayType): any {
   return value.slice()
 }
 function DateType(value: Date): any {
   return new Date(value.toISOString())
 }
-function ValueType(value: ValueGuard.ValueType): any {
-  return value
-}
-// --------------------------------------------------------------------------
-// Non-Clonable
-// --------------------------------------------------------------------------
-function AsyncIteratorType(value: AsyncIterableIterator<unknown>): any {
-  return value
-}
-function IteratorType(value: IterableIterator<unknown>): any {
-  return value
-}
-function FunctionType(value: Function): any {
-  return value
-}
-function PromiseType(value: Promise<unknown>): any {
+function ValueType(value: ValueType): any {
   return value
 }
 // --------------------------------------------------------------------------
@@ -67,14 +53,10 @@ function PromiseType(value: Promise<unknown>): any {
 // --------------------------------------------------------------------------
 /** Returns a clone of the given value */
 export function Clone<T extends unknown>(value: T): T {
-  if (ValueGuard.IsArray(value)) return ArrayType(value)
-  if (ValueGuard.IsAsyncIterator(value)) return AsyncIteratorType(value)
-  if (ValueGuard.IsFunction(value)) return FunctionType(value)
-  if (ValueGuard.IsIterator(value)) return IteratorType(value)
-  if (ValueGuard.IsPromise(value)) return PromiseType(value)
-  if (ValueGuard.IsDate(value)) return DateType(value)
-  if (ValueGuard.IsPlainObject(value)) return ObjectType(value)
-  if (ValueGuard.IsTypedArray(value)) return TypedArrayType(value)
-  if (ValueGuard.IsValueType(value)) return ValueType(value)
+  if (IsArray(value)) return ArrayType(value)
+  if (IsDate(value)) return DateType(value)
+  if (IsPlainObject(value)) return ObjectType(value)
+  if (IsTypedArray(value)) return TypedArrayType(value)
+  if (IsValueType(value)) return ValueType(value)
   throw new Error('ValueClone: Unable to clone value')
 }
diff --git a/src/value/convert.ts b/src/value/convert.ts
index c38be43e3..fd64cfacf 100644
--- a/src/value/convert.ts
+++ b/src/value/convert.ts
@@ -26,53 +26,49 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { IsArray, IsObject, IsDate, IsUndefined, IsString, IsNumber, IsBoolean, IsBigInt, IsSymbol } from './guard'
+import { Clone } from './clone'
+import { Check } from './check'
+import { Deref } from './deref'
 import * as Types from '../typebox'
-import * as ValueClone from './clone'
-import * as ValueCheck from './check'
-import * as ValueGuard from './guard'
 
 // --------------------------------------------------------------------------
 // Errors
 // --------------------------------------------------------------------------
-export class ValueConvertUnknownTypeError extends Error {
+export class ValueConvertUnknownTypeError extends Types.TypeBoxError {
   constructor(public readonly schema: Types.TSchema) {
-    super('ValueConvert: Unknown type')
-  }
-}
-export class ValueConvertDereferenceError extends Error {
-  constructor(public readonly schema: Types.TRef | Types.TThis) {
-    super(`ValueConvert: Unable to dereference type with $id '${schema.$ref}'`)
+    super('Unknown type')
   }
 }
 // --------------------------------------------------------------------------
 // Conversions
 // --------------------------------------------------------------------------
 function IsStringNumeric(value: unknown): value is string {
-  return ValueGuard.IsString(value) && !isNaN(value as any) && !isNaN(parseFloat(value))
+  return IsString(value) && !isNaN(value as any) && !isNaN(parseFloat(value))
 }
 function IsValueToString(value: unknown): value is { toString: () => string } {
-  return ValueGuard.IsBigInt(value) || ValueGuard.IsBoolean(value) || ValueGuard.IsNumber(value)
+  return IsBigInt(value) || IsBoolean(value) || IsNumber(value)
 }
 function IsValueTrue(value: unknown): value is true {
-  return value === true || (ValueGuard.IsNumber(value) && value === 1) || (ValueGuard.IsBigInt(value) && value === BigInt('1')) || (ValueGuard.IsString(value) && (value.toLowerCase() === 'true' || value === '1'))
+  return value === true || (IsNumber(value) && value === 1) || (IsBigInt(value) && value === BigInt('1')) || (IsString(value) && (value.toLowerCase() === 'true' || value === '1'))
 }
 function IsValueFalse(value: unknown): value is false {
-  return value === false || (ValueGuard.IsNumber(value) && value === 0) || (ValueGuard.IsBigInt(value) && value === BigInt('0')) || (ValueGuard.IsString(value) && (value.toLowerCase() === 'false' || value === '0'))
+  return value === false || (IsNumber(value) && (value === 0 || Object.is(value, -0))) || (IsBigInt(value) && value === BigInt('0')) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0' || value === '-0'))
 }
 function IsTimeStringWithTimeZone(value: unknown): value is string {
-  return ValueGuard.IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value)
+  return IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value)
 }
 function IsTimeStringWithoutTimeZone(value: unknown): value is string {
-  return ValueGuard.IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value)
+  return IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value)
 }
 function IsDateTimeStringWithTimeZone(value: unknown): value is string {
-  return ValueGuard.IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value)
+  return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value)
 }
 function IsDateTimeStringWithoutTimeZone(value: unknown): value is string {
-  return ValueGuard.IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value)
+  return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value)
 }
 function IsDateString(value: unknown): value is string {
-  return ValueGuard.IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value)
+  return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value)
 }
 // --------------------------------------------------------------------------
 // Convert
@@ -97,29 +93,29 @@ function TryConvertLiteral(schema: Types.TLiteral, value: unknown) {
   } else if (typeof schema.const === 'boolean') {
     return TryConvertLiteralBoolean(value, schema.const)
   } else {
-    return ValueClone.Clone(value)
+    return Clone(value)
   }
 }
 function TryConvertBoolean(value: unknown) {
   return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value
 }
 function TryConvertBigInt(value: unknown) {
-  return IsStringNumeric(value) ? BigInt(parseInt(value)) : ValueGuard.IsNumber(value) ? BigInt(value | 0) : IsValueFalse(value) ? 0 : IsValueTrue(value) ? 1 : value
+  return IsStringNumeric(value) ? BigInt(parseInt(value)) : IsNumber(value) ? BigInt(value | 0) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value
 }
 function TryConvertString(value: unknown) {
-  return IsValueToString(value) ? value.toString() : ValueGuard.IsSymbol(value) && value.description !== undefined ? value.description.toString() : value
+  return IsValueToString(value) ? value.toString() : IsSymbol(value) && value.description !== undefined ? value.description.toString() : value
 }
 function TryConvertNumber(value: unknown) {
   return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value
 }
 function TryConvertInteger(value: unknown) {
-  return IsStringNumeric(value) ? parseInt(value) : ValueGuard.IsNumber(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value
+  return IsStringNumeric(value) ? parseInt(value) : IsNumber(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value
 }
 function TryConvertNull(value: unknown) {
-  return ValueGuard.IsString(value) && value.toLowerCase() === 'null' ? null : value
+  return IsString(value) && value.toLowerCase() === 'null' ? null : value
 }
 function TryConvertUndefined(value: unknown) {
-  return ValueGuard.IsString(value) && value === 'undefined' ? undefined : value
+  return IsString(value) && value === 'undefined' ? undefined : value
 }
 function TryConvertDate(value: unknown) {
   // --------------------------------------------------------------------------
@@ -128,9 +124,9 @@ function TryConvertDate(value: unknown) {
   // and will return a epoch date if invalid. Consider better string parsing
   // for the iso dates in future revisions.
   // --------------------------------------------------------------------------
-  return ValueGuard.IsDate(value)
+  return IsDate(value)
     ? value
-    : ValueGuard.IsNumber(value)
+    : IsNumber(value)
     ? new Date(value)
     : IsValueTrue(value)
     ? new Date(1)
@@ -151,50 +147,35 @@ function TryConvertDate(value: unknown) {
     : value
 }
 // --------------------------------------------------------------------------
-// Cast
+// Default
 // --------------------------------------------------------------------------
-function TAny(schema: Types.TAny, references: Types.TSchema[], value: any): any {
+export function Default(value: any) {
   return value
 }
+// --------------------------------------------------------------------------
+// Convert
+// --------------------------------------------------------------------------
 function TArray(schema: Types.TArray, references: Types.TSchema[], value: any): any {
-  if (ValueGuard.IsArray(value)) {
+  if (IsArray(value)) {
     return value.map((value) => Visit(schema.items, references, value))
   }
   return value
 }
-function TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[], value: any): any {
-  return value
-}
 function TBigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any): unknown {
   return TryConvertBigInt(value)
 }
 function TBoolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): unknown {
   return TryConvertBoolean(value)
 }
-function TConstructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): unknown {
-  return ValueClone.Clone(value)
-}
 function TDate(schema: Types.TDate, references: Types.TSchema[], value: any): unknown {
   return TryConvertDate(value)
 }
-function TFunction(schema: Types.TFunction, references: Types.TSchema[], value: any): unknown {
-  return value
-}
 function TInteger(schema: Types.TInteger, references: Types.TSchema[], value: any): unknown {
   return TryConvertInteger(value)
 }
-function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any): unknown {
-  return value
-}
-function TIterator(schema: Types.TIterator, references: Types.TSchema[], value: any): unknown {
-  return value
-}
 function TLiteral(schema: Types.TLiteral, references: Types.TSchema[], value: any): unknown {
   return TryConvertLiteral(schema, value)
 }
-function TNever(schema: Types.TNever, references: Types.TSchema[], value: any): unknown {
-  return value
-}
 function TNull(schema: Types.TNull, references: Types.TSchema[], value: any): unknown {
   return TryConvertNull(value)
 }
@@ -202,15 +183,12 @@ function TNumber(schema: Types.TNumber, references: Types.TSchema[], value: any)
   return TryConvertNumber(value)
 }
 function TObject(schema: Types.TObject, references: Types.TSchema[], value: any): unknown {
-  if (ValueGuard.IsObject(value))
+  if (IsObject(value))
     return Object.getOwnPropertyNames(schema.properties).reduce((acc, key) => {
       return value[key] !== undefined ? { ...acc, [key]: Visit(schema.properties[key], references, value[key]) } : { ...acc }
     }, value)
   return value
 }
-function TPromise(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown {
-  return value
-}
 function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): unknown {
   const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0]
   const property = schema.patternProperties[propertyKey]
@@ -221,28 +199,19 @@ function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], v
   return result
 }
 function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any): unknown {
-  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-  if (index === -1) throw new ValueConvertDereferenceError(schema)
-  const target = references[index]
-  return Visit(target, references, value)
+  return Visit(Deref(schema, references), references, value)
 }
 function TString(schema: Types.TString, references: Types.TSchema[], value: any): unknown {
   return TryConvertString(value)
 }
 function TSymbol(schema: Types.TSymbol, references: Types.TSchema[], value: any): unknown {
-  return value
-}
-function TTemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[], value: any) {
-  return value
+  return IsString(value) || IsNumber(value) ? Symbol(value) : value
 }
 function TThis(schema: Types.TThis, references: Types.TSchema[], value: any): unknown {
-  const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-  if (index === -1) throw new ValueConvertDereferenceError(schema)
-  const target = references[index]
-  return Visit(target, references, value)
+  return Visit(Deref(schema, references), references, value)
 }
 function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): unknown {
-  if (ValueGuard.IsArray(value) && !ValueGuard.IsUndefined(schema.items)) {
+  if (IsArray(value) && !IsUndefined(schema.items)) {
     return value.map((value, index) => {
       return index < schema.items!.length ? Visit(schema.items![index], references, value) : value
     })
@@ -255,62 +224,37 @@ function TUndefined(schema: Types.TUndefined, references: Types.TSchema[], value
 function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any): unknown {
   for (const subschema of schema.anyOf) {
     const converted = Visit(subschema, references, value)
-    if (ValueCheck.Check(subschema, references, converted)) {
+    if (Check(subschema, references, converted)) {
       return converted
     }
   }
   return value
 }
-function TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): unknown {
-  return value
-}
-function TUnknown(schema: Types.TUnknown, references: Types.TSchema[], value: any): unknown {
-  return value
-}
-function TVoid(schema: Types.TVoid, references: Types.TSchema[], value: any): unknown {
-  return value
-}
-function TKind(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown {
-  return value
-}
 function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown {
-  const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references
+  const references_ = IsString(schema.$id) ? [...references, schema] : references
   const schema_ = schema as any
   switch (schema[Types.Kind]) {
-    case 'Any':
-      return TAny(schema_, references_, value)
+    // ------------------------------------------------------
+    // Structural
+    // ------------------------------------------------------
     case 'Array':
       return TArray(schema_, references_, value)
-    case 'AsyncIterator':
-      return TAsyncIterator(schema_, references_, value)
     case 'BigInt':
       return TBigInt(schema_, references_, value)
     case 'Boolean':
       return TBoolean(schema_, references_, value)
-    case 'Constructor':
-      return TConstructor(schema_, references_, value)
     case 'Date':
       return TDate(schema_, references_, value)
-    case 'Function':
-      return TFunction(schema_, references_, value)
     case 'Integer':
       return TInteger(schema_, references_, value)
-    case 'Intersect':
-      return TIntersect(schema_, references_, value)
-    case 'Iterator':
-      return TIterator(schema_, references_, value)
     case 'Literal':
       return TLiteral(schema_, references_, value)
-    case 'Never':
-      return TNever(schema_, references_, value)
     case 'Null':
       return TNull(schema_, references_, value)
     case 'Number':
       return TNumber(schema_, references_, value)
     case 'Object':
       return TObject(schema_, references_, value)
-    case 'Promise':
-      return TPromise(schema_, references_, value)
     case 'Record':
       return TRecord(schema_, references_, value)
     case 'Ref':
@@ -319,8 +263,6 @@ function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any):
       return TString(schema_, references_, value)
     case 'Symbol':
       return TSymbol(schema_, references_, value)
-    case 'TemplateLiteral':
-      return TTemplateLiteral(schema_, references_, value)
     case 'This':
       return TThis(schema_, references_, value)
     case 'Tuple':
@@ -329,15 +271,25 @@ function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any):
       return TUndefined(schema_, references_, value)
     case 'Union':
       return TUnion(schema_, references_, value)
+    // ------------------------------------------------------
+    // Default
+    // ------------------------------------------------------
+    case 'Any':
+    case 'AsyncIterator':
+    case 'Constructor':
+    case 'Function':
+    case 'Intersect':
+    case 'Iterator':
+    case 'Never':
+    case 'Promise':
+    case 'TemplateLiteral':
     case 'Uint8Array':
-      return TUint8Array(schema_, references_, value)
     case 'Unknown':
-      return TUnknown(schema_, references_, value)
     case 'Void':
-      return TVoid(schema_, references_, value)
+      return Default(value)
     default:
       if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueConvertUnknownTypeError(schema_)
-      return TKind(schema_, references_, value)
+      return Default(value)
   }
 }
 // --------------------------------------------------------------------------
diff --git a/src/value/create.ts b/src/value/create.ts
index a2387b6f1..1013bbbdb 100644
--- a/src/value/create.ts
+++ b/src/value/create.ts
@@ -26,62 +26,58 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { HasPropertyKey, IsString } from './guard'
+import { Check } from './check'
+import { Deref } from './deref'
 import * as Types from '../typebox'
-import * as ValueCheck from './check'
-import * as ValueGuard from './guard'
 
 // --------------------------------------------------------------------------
 // Errors
 // --------------------------------------------------------------------------
-export class ValueCreateUnknownTypeError extends Error {
+export class ValueCreateUnknownTypeError extends Types.TypeBoxError {
   constructor(public readonly schema: Types.TSchema) {
-    super('ValueCreate: Unknown type')
+    super('Unknown type')
   }
 }
-export class ValueCreateNeverTypeError extends Error {
+export class ValueCreateNeverTypeError extends Types.TypeBoxError {
   constructor(public readonly schema: Types.TSchema) {
-    super('ValueCreate: Never types cannot be created')
+    super('Never types cannot be created')
   }
 }
-export class ValueCreateNotTypeError extends Error {
+export class ValueCreateNotTypeError extends Types.TypeBoxError {
   constructor(public readonly schema: Types.TSchema) {
-    super('ValueCreate: Not types must have a default value')
+    super('Not types must have a default value')
   }
 }
-export class ValueCreateIntersectTypeError extends Error {
+export class ValueCreateIntersectTypeError extends Types.TypeBoxError {
   constructor(public readonly schema: Types.TSchema) {
-    super('ValueCreate: Intersect produced invalid value. Consider using a default value.')
+    super('Intersect produced invalid value. Consider using a default value.')
   }
 }
-export class ValueCreateTempateLiteralTypeError extends Error {
+export class ValueCreateTempateLiteralTypeError extends Types.TypeBoxError {
   constructor(public readonly schema: Types.TSchema) {
-    super('ValueCreate: Can only create template literal values from patterns that produce finite sequences. Consider using a default value.')
+    super('Can only create template literal values from patterns that produce finite sequences. Consider using a default value.')
   }
 }
-export class ValueCreateDereferenceError extends Error {
-  constructor(public readonly schema: Types.TRef | Types.TThis) {
-    super(`ValueCreate: Unable to dereference type with $id '${schema.$ref}'`)
-  }
-}
-export class ValueCreateRecursiveInstantiationError extends Error {
+export class ValueCreateRecursiveInstantiationError extends Types.TypeBoxError {
   constructor(public readonly schema: Types.TSchema, public readonly recursiveMaxDepth: number) {
-    super('ValueCreate: Value cannot be created as recursive type may produce value of infinite size. Consider using a default.')
+    super('Value cannot be created as recursive type may produce value of infinite size. Consider using a default.')
   }
 }
 // --------------------------------------------------------------------------
 // Types
 // --------------------------------------------------------------------------
 function TAny(schema: Types.TAny, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return {}
   }
 }
 function TArray(schema: Types.TArray, references: Types.TSchema[]): any {
-  if (schema.uniqueItems === true && !ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (schema.uniqueItems === true && !HasPropertyKey(schema, 'default')) {
     throw new Error('ValueCreate.Array: Array with the uniqueItems constraint requires a default value')
-  } else if ('contains' in schema && !ValueGuard.HasPropertyKey(schema, 'default')) {
+  } else if ('contains' in schema && !HasPropertyKey(schema, 'default')) {
     throw new Error('ValueCreate.Array: Array with the contains constraint requires a default value')
   } else if ('default' in schema) {
     return schema.default
@@ -94,28 +90,28 @@ function TArray(schema: Types.TArray, references: Types.TSchema[]): any {
   }
 }
 function TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[]) {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return (async function* () {})()
   }
 }
 function TBigInt(schema: Types.TBigInt, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return BigInt(0)
   }
 }
 function TBoolean(schema: Types.TBoolean, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return false
   }
 }
 function TConstructor(schema: Types.TConstructor, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     const value = Visit(schema.returns, references) as any
@@ -134,7 +130,7 @@ function TConstructor(schema: Types.TConstructor, references: Types.TSchema[]):
   }
 }
 function TDate(schema: Types.TDate, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else if (schema.minimumTimestamp !== undefined) {
     return new Date(schema.minimumTimestamp)
@@ -143,14 +139,14 @@ function TDate(schema: Types.TDate, references: Types.TSchema[]): any {
   }
 }
 function TFunction(schema: Types.TFunction, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return () => Visit(schema.returns, references)
   }
 }
 function TInteger(schema: Types.TInteger, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else if (schema.minimum !== undefined) {
     return schema.minimum
@@ -159,7 +155,7 @@ function TInteger(schema: Types.TInteger, references: Types.TSchema[]): any {
   }
 }
 function TIntersect(schema: Types.TIntersect, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     // Note: The best we can do here is attempt to instance each sub type and apply through object assign. For non-object
@@ -169,19 +165,19 @@ function TIntersect(schema: Types.TIntersect, references: Types.TSchema[]): any
       const next = Visit(schema, references) as any
       return typeof next === 'object' ? { ...acc, ...next } : next
     }, {})
-    if (!ValueCheck.Check(schema, references, value)) throw new ValueCreateIntersectTypeError(schema)
+    if (!Check(schema, references, value)) throw new ValueCreateIntersectTypeError(schema)
     return value
   }
 }
 function TIterator(schema: Types.TIterator, references: Types.TSchema[]) {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return (function* () {})()
   }
 }
 function TLiteral(schema: Types.TLiteral, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return schema.const
@@ -191,21 +187,21 @@ function TNever(schema: Types.TNever, references: Types.TSchema[]): any {
   throw new ValueCreateNeverTypeError(schema)
 }
 function TNot(schema: Types.TNot, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     throw new ValueCreateNotTypeError(schema)
   }
 }
 function TNull(schema: Types.TNull, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return null
   }
 }
 function TNumber(schema: Types.TNumber, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else if (schema.minimum !== undefined) {
     return schema.minimum
@@ -214,7 +210,7 @@ function TNumber(schema: Types.TNumber, references: Types.TSchema[]): any {
   }
 }
 function TObject(schema: Types.TObject, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     const required = new Set(schema.required)
@@ -227,7 +223,7 @@ function TObject(schema: Types.TObject, references: Types.TSchema[]): any {
   }
 }
 function TPromise(schema: Types.TPromise<any>, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return Promise.resolve(Visit(schema.item, references))
@@ -235,7 +231,7 @@ function TPromise(schema: Types.TPromise<any>, references: Types.TSchema[]): any
 }
 function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[]): any {
   const [keyPattern, valueSchema] = Object.entries(schema.patternProperties)[0]
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else if (!(keyPattern === Types.PatternStringExact || keyPattern === Types.PatternNumberExact)) {
     const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|')
@@ -247,30 +243,27 @@ function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[]):
   }
 }
 function TRef(schema: Types.TRef<any>, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-    if (index === -1) throw new ValueCreateDereferenceError(schema)
-    const target = references[index]
-    return Visit(target, references)
+    return Visit(Deref(schema, references), references)
   }
 }
 function TString(schema: Types.TString, references: Types.TSchema[]): any {
   if (schema.pattern !== undefined) {
-    if (!ValueGuard.HasPropertyKey(schema, 'default')) {
+    if (!HasPropertyKey(schema, 'default')) {
       throw new Error('ValueCreate.String: String types with patterns must specify a default value')
     } else {
       return schema.default
     }
   } else if (schema.format !== undefined) {
-    if (!ValueGuard.HasPropertyKey(schema, 'default')) {
+    if (!HasPropertyKey(schema, 'default')) {
       throw new Error('ValueCreate.String: String types with formats must specify a default value')
     } else {
       return schema.default
     }
   } else {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if (HasPropertyKey(schema, 'default')) {
       return schema.default
     } else if (schema.minLength !== undefined) {
       return Array.from({ length: schema.minLength })
@@ -282,7 +275,7 @@ function TString(schema: Types.TString, references: Types.TSchema[]): any {
   }
 }
 function TSymbol(schema: Types.TString, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else if ('value' in schema) {
     return Symbol.for(schema.value)
@@ -291,7 +284,7 @@ function TSymbol(schema: Types.TString, references: Types.TSchema[]): any {
   }
 }
 function TTemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[]) {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   }
   const expression = Types.TemplateLiteralParser.ParseExact(schema.pattern)
@@ -301,17 +294,14 @@ function TTemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSch
 }
 function TThis(schema: Types.TThis, references: Types.TSchema[]): any {
   if (recursiveDepth++ > recursiveMaxDepth) throw new ValueCreateRecursiveInstantiationError(schema, recursiveMaxDepth)
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref)
-    if (index === -1) throw new ValueCreateDereferenceError(schema)
-    const target = references[index]
-    return Visit(target, references)
+    return Visit(Deref(schema, references), references)
   }
 }
 function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   }
   if (schema.items === undefined) {
@@ -321,14 +311,14 @@ function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[]): any {
   }
 }
 function TUndefined(schema: Types.TUndefined, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return undefined
   }
 }
 function TUnion(schema: Types.TUnion<any[]>, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else if (schema.anyOf.length === 0) {
     throw new Error('ValueCreate.Union: Cannot create Union with zero variants')
@@ -337,7 +327,7 @@ function TUnion(schema: Types.TUnion<any[]>, references: Types.TSchema[]): any {
   }
 }
 function TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else if (schema.minByteLength !== undefined) {
     return new Uint8Array(schema.minByteLength)
@@ -346,28 +336,28 @@ function TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[]): an
   }
 }
 function TUnknown(schema: Types.TUnknown, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return {}
   }
 }
 function TVoid(schema: Types.TVoid, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return void 0
   }
 }
 function TKind(schema: Types.TSchema, references: Types.TSchema[]): any {
-  if (ValueGuard.HasPropertyKey(schema, 'default')) {
+  if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
-    throw new Error('ValueCreate: User defined types must specify a default value')
+    throw new Error('User defined types must specify a default value')
   }
 }
 function Visit(schema: Types.TSchema, references: Types.TSchema[]): unknown {
-  const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references
+  const references_ = IsString(schema.$id) ? [...references, schema] : references
   const schema_ = schema as any
   switch (schema_[Types.Kind]) {
     case 'Any':
diff --git a/src/value/delta.ts b/src/value/delta.ts
index 5a8074645..5a2092dc0 100644
--- a/src/value/delta.ts
+++ b/src/value/delta.ts
@@ -26,10 +26,11 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { IsPlainObject, IsArray, IsTypedArray, IsValueType, IsSymbol, IsUndefined } from './guard'
+import type { ObjectType, ArrayType, TypedArrayType, ValueType } from './guard'
 import { Type, Static } from '../typebox'
 import { ValuePointer } from './pointer'
-import * as ValueGuard from './guard'
-import * as ValueClone from './clone'
+import { Clone } from './clone'
 
 // --------------------------------------------------------------------------
 // Commands
@@ -58,12 +59,12 @@ export const Edit = Type.Union([Insert, Update, Delete])
 // --------------------------------------------------------------------------
 export class ValueDeltaObjectWithSymbolKeyError extends Error {
   constructor(public readonly key: unknown) {
-    super('ValueDelta: Cannot diff objects with symbol keys')
+    super('Cannot diff objects with symbol keys')
   }
 }
 export class ValueDeltaUnableToDiffUnknownValue extends Error {
   constructor(public readonly value: unknown) {
-    super('ValueDelta: Unable to create diff edits for unknown value')
+    super('Unable to create diff edits for unknown value')
   }
 }
 // --------------------------------------------------------------------------
@@ -81,30 +82,30 @@ function CreateDelete(path: string): Edit {
 // --------------------------------------------------------------------------
 // Diffing Generators
 // --------------------------------------------------------------------------
-function* ObjectType(path: string, current: ValueGuard.ObjectType, next: unknown): IterableIterator<Edit> {
-  if (!ValueGuard.IsPlainObject(next)) return yield CreateUpdate(path, next)
+function* ObjectType(path: string, current: ObjectType, next: unknown): IterableIterator<Edit> {
+  if (!IsPlainObject(next)) return yield CreateUpdate(path, next)
   const currentKeys = [...Object.keys(current), ...Object.getOwnPropertySymbols(current)]
   const nextKeys = [...Object.keys(next), ...Object.getOwnPropertySymbols(next)]
   for (const key of currentKeys) {
-    if (ValueGuard.IsSymbol(key)) throw new ValueDeltaObjectWithSymbolKeyError(key)
-    if (ValueGuard.IsUndefined(next[key]) && nextKeys.includes(key)) yield CreateUpdate(`${path}/${String(key)}`, undefined)
+    if (IsSymbol(key)) throw new ValueDeltaObjectWithSymbolKeyError(key)
+    if (IsUndefined(next[key]) && nextKeys.includes(key)) yield CreateUpdate(`${path}/${String(key)}`, undefined)
   }
   for (const key of nextKeys) {
-    if (ValueGuard.IsUndefined(current[key]) || ValueGuard.IsUndefined(next[key])) continue
-    if (ValueGuard.IsSymbol(key)) throw new ValueDeltaObjectWithSymbolKeyError(key)
+    if (IsUndefined(current[key]) || IsUndefined(next[key])) continue
+    if (IsSymbol(key)) throw new ValueDeltaObjectWithSymbolKeyError(key)
     yield* Visit(`${path}/${String(key)}`, current[key], next[key])
   }
   for (const key of nextKeys) {
-    if (ValueGuard.IsSymbol(key)) throw new ValueDeltaObjectWithSymbolKeyError(key)
-    if (ValueGuard.IsUndefined(current[key])) yield CreateInsert(`${path}/${String(key)}`, next[key])
+    if (IsSymbol(key)) throw new ValueDeltaObjectWithSymbolKeyError(key)
+    if (IsUndefined(current[key])) yield CreateInsert(`${path}/${String(key)}`, next[key])
   }
   for (const key of currentKeys.reverse()) {
-    if (ValueGuard.IsSymbol(key)) throw new ValueDeltaObjectWithSymbolKeyError(key)
-    if (ValueGuard.IsUndefined(next[key]) && !nextKeys.includes(key)) yield CreateDelete(`${path}/${String(key)}`)
+    if (IsSymbol(key)) throw new ValueDeltaObjectWithSymbolKeyError(key)
+    if (IsUndefined(next[key]) && !nextKeys.includes(key)) yield CreateDelete(`${path}/${String(key)}`)
   }
 }
-function* ArrayType(path: string, current: ValueGuard.ArrayType, next: unknown): IterableIterator<Edit> {
-  if (!ValueGuard.IsArray(next)) return yield CreateUpdate(path, next)
+function* ArrayType(path: string, current: ArrayType, next: unknown): IterableIterator<Edit> {
+  if (!IsArray(next)) return yield CreateUpdate(path, next)
   for (let i = 0; i < Math.min(current.length, next.length); i++) {
     yield* Visit(`${path}/${i}`, current[i], next[i])
   }
@@ -117,21 +118,21 @@ function* ArrayType(path: string, current: ValueGuard.ArrayType, next: unknown):
     yield CreateDelete(`${path}/${i}`)
   }
 }
-function* TypedArrayType(path: string, current: ValueGuard.TypedArrayType, next: unknown): IterableIterator<Edit> {
-  if (!ValueGuard.IsTypedArray(next) || current.length !== next.length || Object.getPrototypeOf(current).constructor.name !== Object.getPrototypeOf(next).constructor.name) return yield CreateUpdate(path, next)
+function* TypedArrayType(path: string, current: TypedArrayType, next: unknown): IterableIterator<Edit> {
+  if (!IsTypedArray(next) || current.length !== next.length || Object.getPrototypeOf(current).constructor.name !== Object.getPrototypeOf(next).constructor.name) return yield CreateUpdate(path, next)
   for (let i = 0; i < Math.min(current.length, next.length); i++) {
     yield* Visit(`${path}/${i}`, current[i], next[i])
   }
 }
-function* ValueType(path: string, current: ValueGuard.ValueType, next: unknown): IterableIterator<Edit> {
+function* ValueType(path: string, current: ValueType, next: unknown): IterableIterator<Edit> {
   if (current === next) return
   yield CreateUpdate(path, next)
 }
 function* Visit(path: string, current: unknown, next: unknown): IterableIterator<Edit> {
-  if (ValueGuard.IsPlainObject(current)) return yield* ObjectType(path, current, next)
-  if (ValueGuard.IsArray(current)) return yield* ArrayType(path, current, next)
-  if (ValueGuard.IsTypedArray(current)) return yield* TypedArrayType(path, current, next)
-  if (ValueGuard.IsValueType(current)) return yield* ValueType(path, current, next)
+  if (IsPlainObject(current)) return yield* ObjectType(path, current, next)
+  if (IsArray(current)) return yield* ArrayType(path, current, next)
+  if (IsTypedArray(current)) return yield* TypedArrayType(path, current, next)
+  if (IsValueType(current)) return yield* ValueType(path, current, next)
   throw new ValueDeltaUnableToDiffUnknownValue(current)
 }
 // ---------------------------------------------------------------------
@@ -151,12 +152,12 @@ function IsIdentity(edits: Edit[]) {
 }
 export function Patch<T = any>(current: unknown, edits: Edit[]): T {
   if (IsRootUpdate(edits)) {
-    return ValueClone.Clone(edits[0].value) as T
+    return Clone(edits[0].value) as T
   }
   if (IsIdentity(edits)) {
-    return ValueClone.Clone(current) as T
+    return Clone(current) as T
   }
-  const clone = ValueClone.Clone(current)
+  const clone = Clone(current)
   for (const edit of edits) {
     switch (edit.type) {
       case 'insert': {
diff --git a/src/value/deref.ts b/src/value/deref.ts
new file mode 100644
index 000000000..cf9ebd798
--- /dev/null
+++ b/src/value/deref.ts
@@ -0,0 +1,41 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TypeBoxError, TSchema, TRef, TThis } from '../typebox'
+
+export class TypeDereferenceError extends TypeBoxError {
+  constructor(public readonly schema: TRef | TThis) {
+    super(`Unable to dereference schema with $id '${schema.$id}'`)
+  }
+}
+/** Dereferences a schema from the references array or throws if not found */
+export function Deref(schema: TRef | TThis, references: TSchema[]): TSchema {
+  const index = references.findIndex((target) => target.$id === schema.$ref)
+  if (index === -1) throw new TypeDereferenceError(schema)
+  return references[index]
+}
diff --git a/src/value/equal.ts b/src/value/equal.ts
index 48a5f9e5b..558d96f8b 100644
--- a/src/value/equal.ts
+++ b/src/value/equal.ts
@@ -26,30 +26,31 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import * as ValueGuard from './guard'
+import { IsPlainObject, IsDate, IsArray, IsTypedArray, IsValueType } from './guard'
+import type { ObjectType, ArrayType, TypedArrayType, ValueType } from './guard'
 
 // --------------------------------------------------------------------------
 // Equality Checks
 // --------------------------------------------------------------------------
-function ObjectType(left: ValueGuard.ObjectType, right: unknown): boolean {
-  if (!ValueGuard.IsPlainObject(right)) return false
+function ObjectType(left: ObjectType, right: unknown): boolean {
+  if (!IsPlainObject(right)) return false
   const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)]
   const rightKeys = [...Object.keys(right), ...Object.getOwnPropertySymbols(right)]
   if (leftKeys.length !== rightKeys.length) return false
   return leftKeys.every((key) => Equal(left[key], right[key]))
 }
 function DateType(left: Date, right: unknown): any {
-  return ValueGuard.IsDate(right) && left.getTime() === right.getTime()
+  return IsDate(right) && left.getTime() === right.getTime()
 }
-function ArrayType(left: ValueGuard.ArrayType, right: unknown): any {
-  if (!ValueGuard.IsArray(right) || left.length !== right.length) return false
+function ArrayType(left: ArrayType, right: unknown): any {
+  if (!IsArray(right) || left.length !== right.length) return false
   return left.every((value, index) => Equal(value, right[index]))
 }
-function TypedArrayType(left: ValueGuard.TypedArrayType, right: unknown): any {
-  if (!ValueGuard.IsTypedArray(right) || left.length !== right.length || Object.getPrototypeOf(left).constructor.name !== Object.getPrototypeOf(right).constructor.name) return false
+function TypedArrayType(left: TypedArrayType, right: unknown): any {
+  if (!IsTypedArray(right) || left.length !== right.length || Object.getPrototypeOf(left).constructor.name !== Object.getPrototypeOf(right).constructor.name) return false
   return left.every((value, index) => Equal(value, right[index]))
 }
-function ValueType(left: ValueGuard.ValueType, right: unknown): any {
+function ValueType(left: ValueType, right: unknown): any {
   return left === right
 }
 // --------------------------------------------------------------------------
@@ -57,10 +58,10 @@ function ValueType(left: ValueGuard.ValueType, right: unknown): any {
 // --------------------------------------------------------------------------
 /** Returns true if the left value deep-equals the right */
 export function Equal<T>(left: T, right: unknown): right is T {
-  if (ValueGuard.IsPlainObject(left)) return ObjectType(left, right)
-  if (ValueGuard.IsDate(left)) return DateType(left, right)
-  if (ValueGuard.IsTypedArray(left)) return TypedArrayType(left, right)
-  if (ValueGuard.IsArray(left)) return ArrayType(left, right)
-  if (ValueGuard.IsValueType(left)) return ValueType(left, right)
+  if (IsPlainObject(left)) return ObjectType(left, right)
+  if (IsDate(left)) return DateType(left, right)
+  if (IsTypedArray(left)) return TypedArrayType(left, right)
+  if (IsArray(left)) return ArrayType(left, right)
+  if (IsValueType(left)) return ValueType(left, right)
   throw new Error('ValueEquals: Unable to compare value')
 }
diff --git a/src/value/guard.ts b/src/value/guard.ts
index ce47fb7cd..5d5bb17ec 100644
--- a/src/value/guard.ts
+++ b/src/value/guard.ts
@@ -73,7 +73,7 @@ export function IsUint8Array(value: unknown): value is Uint8Array {
 }
 /** Returns true if this value is a Date */
 export function IsDate(value: unknown): value is Date {
-  return value instanceof Date
+  return value instanceof Date && Number.isFinite(value.getTime())
 }
 // --------------------------------------------------------------------------
 // Standard
diff --git a/src/value/hash.ts b/src/value/hash.ts
index eeafffe07..fdeec07a5 100644
--- a/src/value/hash.ts
+++ b/src/value/hash.ts
@@ -1,6 +1,6 @@
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox/hash
+@sinclair/typebox/value
 
 The MIT License (MIT)
 
@@ -26,14 +26,14 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import * as ValueGuard from './guard'
+import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsPlainObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from './guard'
 
 // --------------------------------------------------------------------------
 // Errors
 // --------------------------------------------------------------------------
 export class ValueHashError extends Error {
   constructor(public readonly value: unknown) {
-    super(`Hash: Unable to hash value`)
+    super(`Unable to hash value`)
   }
 }
 // --------------------------------------------------------------------------
@@ -122,17 +122,17 @@ function UndefinedType(value: undefined) {
   return FNV1A64(ByteMarker.Undefined)
 }
 function Visit(value: any) {
-  if (ValueGuard.IsArray(value)) return ArrayType(value)
-  if (ValueGuard.IsBoolean(value)) return BooleanType(value)
-  if (ValueGuard.IsBigInt(value)) return BigIntType(value)
-  if (ValueGuard.IsDate(value)) return DateType(value)
-  if (ValueGuard.IsNull(value)) return NullType(value)
-  if (ValueGuard.IsNumber(value)) return NumberType(value)
-  if (ValueGuard.IsPlainObject(value)) return ObjectType(value)
-  if (ValueGuard.IsString(value)) return StringType(value)
-  if (ValueGuard.IsSymbol(value)) return SymbolType(value)
-  if (ValueGuard.IsUint8Array(value)) return Uint8ArrayType(value)
-  if (ValueGuard.IsUndefined(value)) return UndefinedType(value)
+  if (IsArray(value)) return ArrayType(value)
+  if (IsBoolean(value)) return BooleanType(value)
+  if (IsBigInt(value)) return BigIntType(value)
+  if (IsDate(value)) return DateType(value)
+  if (IsNull(value)) return NullType(value)
+  if (IsNumber(value)) return NumberType(value)
+  if (IsPlainObject(value)) return ObjectType(value)
+  if (IsString(value)) return StringType(value)
+  if (IsSymbol(value)) return SymbolType(value)
+  if (IsUint8Array(value)) return Uint8ArrayType(value)
+  if (IsUndefined(value)) return UndefinedType(value)
   throw new ValueHashError(value)
 }
 function FNV1A64(byte: number) {
diff --git a/src/value/mutate.ts b/src/value/mutate.ts
index bd4a952bf..42d563c4a 100644
--- a/src/value/mutate.ts
+++ b/src/value/mutate.ts
@@ -26,21 +26,21 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { IsPlainObject, IsArray, IsTypedArray, IsValueType, type TypedArrayType } from './guard'
 import { ValuePointer } from './pointer'
-import * as ValueClone from './clone'
-import * as ValueGuard from './guard'
+import { Clone } from './clone'
 
 // --------------------------------------------------------------------------
 // Errors
 // --------------------------------------------------------------------------
 export class ValueMutateTypeMismatchError extends Error {
   constructor() {
-    super('ValueMutate: Cannot assign due type mismatch of assignable values')
+    super('Cannot assign due type mismatch of assignable values')
   }
 }
 export class ValueMutateInvalidRootMutationError extends Error {
   constructor() {
-    super('ValueMutate: Only object and array types can be mutated at the root level')
+    super('Only object and array types can be mutated at the root level')
   }
 }
 // --------------------------------------------------------------------------
@@ -48,8 +48,8 @@ export class ValueMutateInvalidRootMutationError extends Error {
 // --------------------------------------------------------------------------
 export type Mutable = { [key: string]: unknown } | unknown[]
 function ObjectType(root: Mutable, path: string, current: unknown, next: Record<string, unknown>) {
-  if (!ValueGuard.IsPlainObject(current)) {
-    ValuePointer.Set(root, path, ValueClone.Clone(next))
+  if (!IsPlainObject(current)) {
+    ValuePointer.Set(root, path, Clone(next))
   } else {
     const currentKeys = Object.keys(current)
     const nextKeys = Object.keys(next)
@@ -69,8 +69,8 @@ function ObjectType(root: Mutable, path: string, current: unknown, next: Record<
   }
 }
 function ArrayType(root: Mutable, path: string, current: unknown, next: unknown[]) {
-  if (!ValueGuard.IsArray(current)) {
-    ValuePointer.Set(root, path, ValueClone.Clone(next))
+  if (!IsArray(current)) {
+    ValuePointer.Set(root, path, Clone(next))
   } else {
     for (let index = 0; index < next.length; index++) {
       Visit(root, `${path}/${index}`, current[index], next[index])
@@ -78,13 +78,13 @@ function ArrayType(root: Mutable, path: string, current: unknown, next: unknown[
     current.splice(next.length)
   }
 }
-function TypedArrayType(root: Mutable, path: string, current: unknown, next: ValueGuard.TypedArrayType) {
-  if (ValueGuard.IsTypedArray(current) && current.length === next.length) {
+function TypedArrayType(root: Mutable, path: string, current: unknown, next: TypedArrayType) {
+  if (IsTypedArray(current) && current.length === next.length) {
     for (let i = 0; i < current.length; i++) {
       current[i] = next[i]
     }
   } else {
-    ValuePointer.Set(root, path, ValueClone.Clone(next))
+    ValuePointer.Set(root, path, Clone(next))
   }
 }
 function ValueType(root: Mutable, path: string, current: unknown, next: unknown) {
@@ -92,22 +92,22 @@ function ValueType(root: Mutable, path: string, current: unknown, next: unknown)
   ValuePointer.Set(root, path, next)
 }
 function Visit(root: Mutable, path: string, current: unknown, next: unknown) {
-  if (ValueGuard.IsArray(next)) return ArrayType(root, path, current, next)
-  if (ValueGuard.IsTypedArray(next)) return TypedArrayType(root, path, current, next)
-  if (ValueGuard.IsPlainObject(next)) return ObjectType(root, path, current, next)
-  if (ValueGuard.IsValueType(next)) return ValueType(root, path, current, next)
+  if (IsArray(next)) return ArrayType(root, path, current, next)
+  if (IsTypedArray(next)) return TypedArrayType(root, path, current, next)
+  if (IsPlainObject(next)) return ObjectType(root, path, current, next)
+  if (IsValueType(next)) return ValueType(root, path, current, next)
 }
 // --------------------------------------------------------------------------
 // Mutate
 // --------------------------------------------------------------------------
 function IsNonMutableValue(value: unknown): value is Mutable {
-  return ValueGuard.IsTypedArray(value) || ValueGuard.IsValueType(value)
+  return IsTypedArray(value) || IsValueType(value)
 }
 function IsMismatchedValue(current: unknown, next: unknown) {
   // prettier-ignore
   return (
-    (ValueGuard.IsPlainObject(current) && ValueGuard.IsArray(next)) || 
-    (ValueGuard.IsArray(current) && ValueGuard.IsPlainObject(next))
+    (IsPlainObject(current) && IsArray(next)) || 
+    (IsArray(current) && IsPlainObject(next))
   )
 }
 // --------------------------------------------------------------------------
diff --git a/src/value/pointer.ts b/src/value/pointer.ts
index 6b03c2f1e..995ce8129 100644
--- a/src/value/pointer.ts
+++ b/src/value/pointer.ts
@@ -31,12 +31,12 @@ THE SOFTWARE.
 // --------------------------------------------------------------------------
 export class ValuePointerRootSetError extends Error {
   constructor(public readonly value: unknown, public readonly path: string, public readonly update: unknown) {
-    super('ValuePointer: Cannot set root value')
+    super('Cannot set root value')
   }
 }
 export class ValuePointerRootDeleteError extends Error {
   constructor(public readonly value: unknown, public readonly path: string) {
-    super('ValuePointer: Cannot delete root value')
+    super('Cannot delete root value')
   }
 }
 // --------------------------------------------------------------------------
diff --git a/src/value/transform.ts b/src/value/transform.ts
new file mode 100644
index 000000000..e1608edab
--- /dev/null
+++ b/src/value/transform.ts
@@ -0,0 +1,473 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { IsString, IsPlainObject, IsArray, IsValueType } from './guard'
+import { ValueError } from '../errors/errors'
+import { Deref } from './deref'
+import * as Types from '../typebox'
+
+// -------------------------------------------------------------------------
+// CheckFunction
+// -------------------------------------------------------------------------
+export type CheckFunction = (schema: Types.TSchema, references: Types.TSchema[], value: unknown) => boolean
+
+// -------------------------------------------------------------------------
+// Errors
+// -------------------------------------------------------------------------
+export class TransformUnknownTypeError extends Types.TypeBoxError {
+  constructor(public readonly schema: Types.TRef | Types.TThis) {
+    super(`Unknown type`)
+  }
+}
+export class TransformDecodeCheckError extends Types.TypeBoxError {
+  constructor(public readonly schema: Types.TSchema, public readonly value: unknown, public readonly error: ValueError) {
+    super(`Unable to decode due to invalid value`)
+  }
+}
+export class TransformEncodeCheckError extends Types.TypeBoxError {
+  constructor(public readonly schema: Types.TSchema, public readonly value: unknown, public readonly error: ValueError) {
+    super(`Unable to encode due to invalid value`)
+  }
+}
+export class TransformDecodeError extends Types.TypeBoxError {
+  constructor(public readonly schema: Types.TSchema, public readonly value: unknown, error: any) {
+    super(`${error instanceof Error ? error.message : 'Unknown error'}`)
+  }
+}
+export class TransformEncodeError extends Types.TypeBoxError {
+  constructor(public readonly schema: Types.TSchema, public readonly value: unknown, error: any) {
+    super(`${error instanceof Error ? error.message : 'Unknown error'}`)
+  }
+}
+// -------------------------------------------------------------------------
+// HasTransform
+// -------------------------------------------------------------------------
+/** Recursively checks a schema for transform codecs */
+export namespace HasTransform {
+  function TArray(schema: Types.TArray, references: Types.TSchema[]): boolean {
+    return Types.TypeGuard.TTransform(schema) || Visit(schema.items, references)
+  }
+  function TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[]): boolean {
+    return Types.TypeGuard.TTransform(schema) || Visit(schema.items, references)
+  }
+  function TConstructor(schema: Types.TConstructor, references: Types.TSchema[]) {
+    return Types.TypeGuard.TTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema.returns, references))
+  }
+  function TFunction(schema: Types.TFunction, references: Types.TSchema[]) {
+    return Types.TypeGuard.TTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema.returns, references))
+  }
+  function TIntersect(schema: Types.TIntersect, references: Types.TSchema[]) {
+    return Types.TypeGuard.TTransform(schema) || Types.TypeGuard.TTransform(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references))
+  }
+  function TIterator(schema: Types.TIterator, references: Types.TSchema[]) {
+    return Types.TypeGuard.TTransform(schema) || Visit(schema.items, references)
+  }
+  function TNot(schema: Types.TNot, references: Types.TSchema[]) {
+    return Types.TypeGuard.TTransform(schema) || Visit(schema.not, references)
+  }
+  function TObject(schema: Types.TObject, references: Types.TSchema[]) {
+    // prettier-ignore
+    return (Types.TypeGuard.TTransform(schema) || Object.values(schema.properties).some((schema) => Visit(schema, references)) || Types.TypeGuard.TSchema(schema.additionalProperties) && Visit(schema.additionalProperties, references)
+    )
+  }
+  function TPromise(schema: Types.TPromise, references: Types.TSchema[]) {
+    return Types.TypeGuard.TTransform(schema) || Visit(schema.item, references)
+  }
+  function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[]) {
+    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
+    const property = schema.patternProperties[pattern]
+    return Types.TypeGuard.TTransform(schema) || Visit(property, references) || (Types.TypeGuard.TSchema(schema.additionalProperties) && Types.TypeGuard.TTransform(schema.additionalProperties))
+  }
+  function TRef(schema: Types.TRef<any>, references: Types.TSchema[]) {
+    if (Types.TypeGuard.TTransform(schema)) return true
+    return Visit(Deref(schema, references), references)
+  }
+  function TThis(schema: Types.TThis, references: Types.TSchema[]) {
+    if (Types.TypeGuard.TTransform(schema)) return true
+    return Visit(Deref(schema, references), references)
+  }
+  function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[]) {
+    return Types.TypeGuard.TTransform(schema) || (Types.TypeGuard.TSchema(schema.items) && schema.items.some((schema) => Visit(schema, references)))
+  }
+  function TUnion(schema: Types.TUnion, references: Types.TSchema[]) {
+    return Types.TypeGuard.TTransform(schema) || schema.anyOf.some((schema) => Visit(schema, references))
+  }
+  function Visit(schema: Types.TSchema, references: Types.TSchema[]): boolean {
+    const references_ = IsString(schema.$id) ? [...references, schema] : references
+    const schema_ = schema as any
+    if (schema.$id && visited.has(schema.$id)) return false
+    if (schema.$id) visited.add(schema.$id)
+    switch (schema[Types.Kind]) {
+      // ------------------------------------------------------
+      // Structural
+      // ------------------------------------------------------
+      case 'Array':
+        return TArray(schema_, references_)
+      case 'AsyncIterator':
+        return TAsyncIterator(schema_, references_)
+      case 'Constructor':
+        return TConstructor(schema_, references_)
+      case 'Function':
+        return TFunction(schema_, references_)
+      case 'Intersect':
+        return TIntersect(schema_, references_)
+      case 'Iterator':
+        return TIterator(schema_, references_)
+      case 'Not':
+        return TNot(schema_, references_)
+      case 'Object':
+        return TObject(schema_, references_)
+      case 'Promise':
+        return TPromise(schema_, references_)
+      case 'Record':
+        return TRecord(schema_, references_)
+      case 'Ref':
+        return TRef(schema_, references_)
+      case 'This':
+        return TThis(schema_, references_)
+      case 'Tuple':
+        return TTuple(schema_, references_)
+      case 'Union':
+        return TUnion(schema_, references_)
+      // ------------------------------------------------------
+      // Default
+      // ------------------------------------------------------
+      case 'Any':
+      case 'BigInt':
+      case 'Boolean':
+      case 'Date':
+      case 'Integer':
+      case 'Literal':
+      case 'Never':
+      case 'Null':
+      case 'Number':
+      case 'String':
+      case 'Symbol':
+      case 'TemplateLiteral':
+      case 'Undefined':
+      case 'Uint8Array':
+      case 'Unknown':
+      case 'Void':
+        return Types.TypeGuard.TTransform(schema)
+      default:
+        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new TransformUnknownTypeError(schema_)
+        return Types.TypeGuard.TTransform(schema)
+    }
+  }
+  const visited = new Set<string>()
+  /** Returns true if this schema contains a transform codec */
+  export function Has(schema: Types.TSchema, references: Types.TSchema[]): boolean {
+    visited.clear()
+    return Visit(schema, references)
+  }
+}
+// -------------------------------------------------------------------------
+// DecodeTransform
+// -------------------------------------------------------------------------
+/** Decodes a value using transform decoders if available. Does not ensure correct results. */
+export namespace DecodeTransform {
+  function Default(schema: Types.TSchema, value: any) {
+    try {
+      return Types.TypeGuard.TTransform(schema) ? schema[Types.Transform].Decode(value) : value
+    } catch (error) {
+      throw new TransformDecodeError(schema, value, error)
+    }
+  }
+  function TArray(schema: Types.TArray, references: Types.TSchema[], value: any): any {
+    const elements1 = value.map((value: any) => Visit(schema.items, references, value)) as unknown[]
+    return Default(schema, elements1)
+  }
+  function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any) {
+    if (!IsPlainObject(value) || IsValueType(value)) return Default(schema, value)
+    const keys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false })
+    const properties1 = Object.entries(value).reduce((acc, [key, value]) => {
+      return !keys.includes(key) ? { ...acc, [key]: value } : { ...acc, [key]: Default(Types.IndexedAccessor.Resolve(schema, [key]), value) }
+    }, {} as Record<any, any>)
+    if (!Types.TypeGuard.TTransform(schema.unevaluatedProperties)) return Default(schema, properties1)
+    const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
+      return keys.includes(key) ? { ...acc, [key]: value } : { ...acc, [key]: Default(schema.unevaluatedProperties as Types.TSchema, value) }
+    }, {} as Record<any, any>)
+    return Default(schema, properties2)
+  }
+  function TNot(schema: Types.TNot, references: Types.TSchema[], value: any) {
+    const value1 = Visit(schema.not, references, value)
+    return Default(schema, value1)
+  }
+  function TObject(schema: Types.TObject, references: Types.TSchema[], value: any) {
+    if (!IsPlainObject(value)) return Default(schema, value)
+    const properties1 = Object.entries(value).reduce((acc, [key, value]) => {
+      return !(key in schema.properties) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(schema.properties[key], references, value) }
+    }, {} as Record<any, any>)
+    if (!Types.TypeGuard.TSchema(schema.additionalProperties)) return Default(schema, properties1)
+    const additionalProperties = schema.additionalProperties as Types.TSchema
+    const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
+      return key in schema.properties ? { ...acc, [key]: value } : { ...acc, [key]: Visit(additionalProperties, references, value) }
+    }, {} as Record<any, any>)
+    return Default(schema, properties2)
+  }
+  function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any) {
+    if (!IsPlainObject(value)) return Default(schema, value)
+    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
+    const property = schema.patternProperties[pattern]
+    const regex = new RegExp(pattern)
+    const properties1 = Object.entries(value).reduce((acc, [key, value]) => {
+      return !regex.test(key) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(property, references, value) }
+    }, {} as Record<any, any>)
+    if (!Types.TypeGuard.TSchema(schema.additionalProperties)) return Default(schema, properties1)
+    const additionalProperties = schema.additionalProperties as Types.TSchema
+    const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
+      return regex.test(key) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(additionalProperties, references, value) }
+    }, {} as Record<any, any>)
+    return Default(schema, properties2)
+  }
+  function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any) {
+    const target = Deref(schema, references)
+    const resolved = Visit(target, references, value)
+    return Default(schema, resolved)
+  }
+  function TThis(schema: Types.TThis, references: Types.TSchema[], value: any) {
+    const target = Deref(schema, references)
+    const resolved = Visit(target, references, value)
+    return Default(schema, resolved)
+  }
+  function TTuple(schema: Types.TTuple, references: Types.TSchema[], value: any) {
+    const value1 = IsArray(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, value[index])) : []
+    return Default(schema, value1)
+  }
+  function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any) {
+    const value1 = Default(schema, value)
+    for (const subschema of schema.anyOf) {
+      if (!checkFunction(subschema, references, value1)) continue
+      return Visit(subschema, references, value1)
+    }
+    return value1
+  }
+  function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
+    const references_ = typeof schema.$id === 'string' ? [...references, schema] : references
+    const schema_ = schema as any
+    switch (schema[Types.Kind]) {
+      // ------------------------------------------------------
+      // Structural
+      // ------------------------------------------------------
+      case 'Array':
+        return TArray(schema_, references_, value)
+      case 'Intersect':
+        return TIntersect(schema_, references_, value)
+      case 'Not':
+        return TNot(schema_, references_, value)
+      case 'Object':
+        return TObject(schema_, references_, value)
+      case 'Record':
+        return TRecord(schema_, references_, value)
+      case 'Ref':
+        return TRef(schema_, references_, value)
+      case 'Symbol':
+        return Default(schema_, value)
+      case 'This':
+        return TThis(schema_, references_, value)
+      case 'Tuple':
+        return TTuple(schema_, references_, value)
+      case 'Union':
+        return TUnion(schema_, references_, value)
+      // ------------------------------------------------------
+      // Default
+      // ------------------------------------------------------
+      case 'Any':
+      case 'AsyncIterator':
+      case 'BigInt':
+      case 'Boolean':
+      case 'Constructor':
+      case 'Date':
+      case 'Function':
+      case 'Integer':
+      case 'Iterator':
+      case 'Literal':
+      case 'Never':
+      case 'Null':
+      case 'Number':
+      case 'Promise':
+      case 'String':
+      case 'TemplateLiteral':
+      case 'Undefined':
+      case 'Uint8Array':
+      case 'Unknown':
+      case 'Void':
+        return Default(schema_, value)
+      default:
+        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new TransformUnknownTypeError(schema_)
+        return Default(schema_, value)
+    }
+  }
+  let checkFunction: CheckFunction = () => false
+  export function Decode(schema: Types.TSchema, references: Types.TSchema[], value: unknown, check: CheckFunction): unknown {
+    checkFunction = check
+    return Visit(schema, references, value)
+  }
+}
+// -------------------------------------------------------------------------
+// DecodeTransform
+// -------------------------------------------------------------------------
+/** Encodes a value using transform encoders if available. Does not ensure correct results. */
+export namespace EncodeTransform {
+  function Default(schema: Types.TSchema, value: any) {
+    try {
+      return Types.TypeGuard.TTransform(schema) ? schema[Types.Transform].Encode(value) : value
+    } catch (error) {
+      throw new TransformEncodeError(schema, value, error)
+    }
+  }
+  function TArray(schema: Types.TArray, references: Types.TSchema[], value: any): any {
+    const elements1 = Default(schema, value)
+    return elements1.map((value: any) => Visit(schema.items, references, value)) as unknown[]
+  }
+  function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any) {
+    const properties1 = Default(schema, value)
+    if (!IsPlainObject(value) || IsValueType(value)) return properties1
+    const keys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false })
+    const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
+      return !keys.includes(key) ? { ...acc, [key]: value } : { ...acc, [key]: Default(Types.IndexedAccessor.Resolve(schema, [key]), value) }
+    }, {} as Record<any, any>)
+    if (!Types.TypeGuard.TTransform(schema.unevaluatedProperties)) return Default(schema, properties2)
+    return Object.entries(properties2).reduce((acc, [key, value]) => {
+      return keys.includes(key) ? { ...acc, [key]: value } : { ...acc, [key]: Default(schema.unevaluatedProperties as Types.TSchema, value) }
+    }, {} as Record<any, any>)
+  }
+  function TNot(schema: Types.TNot, references: Types.TSchema[], value: any) {
+    const value1 = Default(schema, value)
+    return Default(schema.not, value1)
+  }
+  function TObject(schema: Types.TObject, references: Types.TSchema[], value: any) {
+    const properties1 = Default(schema, value) as Record<any, any>
+    if (!IsPlainObject(value)) return properties1
+    const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
+      return !(key in schema.properties) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(schema.properties[key], references, value) }
+    }, {} as Record<any, any>)
+    if (!Types.TypeGuard.TSchema(schema.additionalProperties)) return properties2
+    const additionalProperties = schema.additionalProperties as Types.TSchema
+    return Object.entries(properties2).reduce((acc, [key, value]) => {
+      return key in schema.properties ? { ...acc, [key]: value } : { ...acc, [key]: Visit(additionalProperties, references, value) }
+    }, {} as Record<any, any>)
+  }
+  function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any) {
+    const properties1 = Default(schema, value) as Record<any, any>
+    if (!IsPlainObject(value)) return properties1
+    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
+    const property = schema.patternProperties[pattern]
+    const regex = new RegExp(pattern)
+    const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
+      return !regex.test(key) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(property, references, value) }
+    }, {} as Record<any, any>)
+    if (!Types.TypeGuard.TSchema(schema.additionalProperties)) return Default(schema, properties2)
+    const additionalProperties = schema.additionalProperties as Types.TSchema
+    return Object.entries(properties2).reduce((acc, [key, value]) => {
+      return regex.test(key) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(additionalProperties, references, value) }
+    }, {} as Record<any, any>)
+  }
+  function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any) {
+    const target = Deref(schema, references)
+    const resolved = Visit(target, references, value)
+    return Default(schema, resolved)
+  }
+  function TThis(schema: Types.TThis, references: Types.TSchema[], value: any) {
+    const target = Deref(schema, references)
+    const resolved = Visit(target, references, value)
+    return Default(schema, resolved)
+  }
+  function TTuple(schema: Types.TTuple, references: Types.TSchema[], value: any) {
+    const value1 = Default(schema, value)
+    return IsArray(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, value1[index])) : []
+  }
+  function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any) {
+    for (const subschema of schema.anyOf) {
+      if (!checkFunction(subschema, references, value)) continue
+      const value1 = Visit(subschema, references, value)
+      return Default(schema, value1)
+    }
+    return Default(schema, value)
+  }
+  function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
+    const references_ = typeof schema.$id === 'string' ? [...references, schema] : references
+    const schema_ = schema as any
+    switch (schema[Types.Kind]) {
+      // ------------------------------------------------------
+      // Structural
+      // ------------------------------------------------------
+      case 'Array':
+        return TArray(schema_, references_, value)
+      case 'Intersect':
+        return TIntersect(schema_, references_, value)
+      case 'Not':
+        return TNot(schema_, references_, value)
+      case 'Object':
+        return TObject(schema_, references_, value)
+      case 'Record':
+        return TRecord(schema_, references_, value)
+      case 'Ref':
+        return TRef(schema_, references_, value)
+      case 'This':
+        return TThis(schema_, references_, value)
+      case 'Tuple':
+        return TTuple(schema_, references_, value)
+      case 'Union':
+        return TUnion(schema_, references_, value)
+      // ------------------------------------------------------
+      // Apply
+      // ------------------------------------------------------
+      case 'Any':
+      case 'AsyncIterator':
+      case 'BigInt':
+      case 'Boolean':
+      case 'Constructor':
+      case 'Date':
+      case 'Function':
+      case 'Integer':
+      case 'Iterator':
+      case 'Literal':
+      case 'Never':
+      case 'Null':
+      case 'Number':
+      case 'Promise':
+      case 'String':
+      case 'Symbol':
+      case 'TemplateLiteral':
+      case 'Undefined':
+      case 'Uint8Array':
+      case 'Unknown':
+      case 'Void':
+        return Default(schema_, value)
+      default:
+        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new TransformUnknownTypeError(schema_)
+        return Default(schema_, value)
+    }
+  }
+  let checkFunction: CheckFunction = () => false
+  export function Encode(schema: Types.TSchema, references: Types.TSchema[], value: unknown, check: CheckFunction): unknown {
+    checkFunction = check
+    return Visit(schema, references, value)
+  }
+}
diff --git a/src/value/value.ts b/src/value/value.ts
index 242edc490..59b8dbe00 100644
--- a/src/value/value.ts
+++ b/src/value/value.ts
@@ -36,6 +36,7 @@ import * as ValueConvert from './convert'
 import * as ValueCreate from './create'
 import * as ValueCheck from './check'
 import * as ValueDelta from './delta'
+import * as ValueTransform from './transform'
 import * as Types from '../typebox'
 
 /** Functions to perform structural operations on JavaScript values */
@@ -76,6 +77,27 @@ export namespace Value {
   export function Clone<T>(value: T): T {
     return ValueClone.Clone(value)
   }
+  /** Decodes a value or throws if error */
+  export function Decode<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): Types.StaticDecode<T>
+  /** Decodes a value or throws if error */
+  export function Decode<T extends Types.TSchema>(schema: T, value: unknown): Types.StaticDecode<T>
+  /** Decodes a value or throws if error */
+  export function Decode(...args: any[]) {
+    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
+    if (!Check(schema, references, value)) throw new ValueTransform.TransformDecodeCheckError(schema, value, Errors(schema, references, value).First()!)
+    return ValueTransform.DecodeTransform.Decode(schema, references, value, ValueCheck.Check)
+  }
+  /** Encodes a value or throws if error */
+  export function Encode<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): Types.StaticEncode<T>
+  /** Encodes a value or throws if error */
+  export function Encode<T extends Types.TSchema>(schema: T, value: unknown): Types.StaticEncode<T>
+  /** Encodes a value or throws if error */
+  export function Encode(...args: any[]) {
+    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
+    const encoded = ValueTransform.EncodeTransform.Encode(schema, references, value, ValueCheck.Check)
+    if (!Check(schema, references, encoded)) throw new ValueTransform.TransformEncodeCheckError(schema, value, Errors(schema, references, value).First()!)
+    return encoded
+  }
   /** Returns an iterator for each error in this value. */
   export function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): ValueErrors.ValueErrorIterator
   /** Returns an iterator for each error in this value. */
diff --git a/test/runtime/assert/assert.ts b/test/runtime/assert/assert.ts
index bfb4f391d..65ca4aa10 100644
--- a/test/runtime/assert/assert.ts
+++ b/test/runtime/assert/assert.ts
@@ -12,7 +12,7 @@ export namespace Assert {
       assert.equal(actual.length, expect.length)
       for (let i = 0; i < actual.length; i++) assert.equal(actual[i], expect[i])
     }
-    return assert.deepEqual(actual, expect)
+    return assert.deepStrictEqual(actual, expect)
   }
   export function NotEqual(actual: unknown, expect: unknown) {
     return assert.notEqual(actual, expect)
@@ -37,7 +37,7 @@ export namespace Assert {
     }
     throw Error('Expected throw')
   }
-  export function IsInstanceOf(value: any, constructor: any) {
+  export function IsInstanceOf<T extends new (...args: any[]) => any>(value: any, constructor: T): asserts value is InstanceType<T> {
     if (value instanceof constructor) return
     throw Error(`Value is not instance of ${constructor}`)
   }
diff --git a/test/runtime/compiler/any.ts b/test/runtime/compiler/any.ts
index 949147d7f..fb4c7de56 100644
--- a/test/runtime/compiler/any.ts
+++ b/test/runtime/compiler/any.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok } from './validate'
 
-describe('type/compiler/Any', () => {
+describe('compiler/Any', () => {
   it('Should validate number', () => {
     const T = Type.Any()
     Ok(T, 1)
diff --git a/test/runtime/compiler/array.ts b/test/runtime/compiler/array.ts
index 1b004d8d2..ae8fa4a6a 100644
--- a/test/runtime/compiler/array.ts
+++ b/test/runtime/compiler/array.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Array', () => {
+describe('compiler/Array', () => {
   it('Should validate an array of any', () => {
     const T = Type.Array(Type.Any())
     Ok(T, [0, true, 'hello', {}])
diff --git a/test/runtime/compiler/async-iterator.ts b/test/runtime/compiler/async-iterator.ts
index f2afa82f6..52dcf5e8d 100644
--- a/test/runtime/compiler/async-iterator.ts
+++ b/test/runtime/compiler/async-iterator.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/AsyncIterator', () => {
+describe('compiler/AsyncIterator', () => {
   it('Should validate a async iterator 1', () => {
     async function* f() {}
     const T = Type.AsyncIterator(Type.Any())
diff --git a/test/runtime/compiler/bigint.ts b/test/runtime/compiler/bigint.ts
index 2a04cbc35..2e9c48a4e 100644
--- a/test/runtime/compiler/bigint.ts
+++ b/test/runtime/compiler/bigint.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/BigInt', () => {
+describe('compiler/BigInt', () => {
   it('Should not validate number', () => {
     const T = Type.BigInt()
     Fail(T, 3.14)
diff --git a/test/runtime/compiler/boolean.ts b/test/runtime/compiler/boolean.ts
index bbc54d942..e401585b1 100644
--- a/test/runtime/compiler/boolean.ts
+++ b/test/runtime/compiler/boolean.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Boolean', () => {
+describe('compiler/Boolean', () => {
   it('Should validate a boolean', () => {
     const T = Type.Boolean()
     Ok(T, true)
diff --git a/test/runtime/compiler/composite.ts b/test/runtime/compiler/composite.ts
index 48466589d..3186c8302 100644
--- a/test/runtime/compiler/composite.ts
+++ b/test/runtime/compiler/composite.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Composite', () => {
+describe('compiler/Composite', () => {
   it('Should compose two objects', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
diff --git a/test/runtime/compiler/date.ts b/test/runtime/compiler/date.ts
index dfda22522..b4425f63c 100644
--- a/test/runtime/compiler/date.ts
+++ b/test/runtime/compiler/date.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Date', () => {
+describe('compiler/Date', () => {
   it('Should not validate number', () => {
     const T = Type.Date()
     Fail(T, 1)
@@ -53,8 +53,8 @@ describe('type/compiler/Date', () => {
   })
   it('Should validate Date maximumTimestamp', () => {
     const T = Type.Date({ maximumTimestamp: 10 })
-    Ok(T, new Date(10))
     Fail(T, new Date(11))
+    Ok(T, new Date(10))
   })
   it('Should validate Date exclusiveMinimumTimestamp', () => {
     const T = Type.Date({ exclusiveMinimumTimestamp: 10 })
@@ -63,7 +63,12 @@ describe('type/compiler/Date', () => {
   })
   it('Should validate Date exclusiveMaximumTimestamp', () => {
     const T = Type.Date({ exclusiveMaximumTimestamp: 10 })
-    Ok(T, new Date(9))
     Fail(T, new Date(10))
+    Ok(T, new Date(9))
+  })
+  it('Should validate Date multipleOfTimestamp', () => {
+    const T = Type.Date({ multipleOfTimestamp: 2 })
+    Fail(T, new Date(1))
+    Ok(T, new Date(2))
   })
 })
diff --git a/test/runtime/compiler/enum.ts b/test/runtime/compiler/enum.ts
index 268e2c8cb..679e4ac9c 100644
--- a/test/runtime/compiler/enum.ts
+++ b/test/runtime/compiler/enum.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Enum', () => {
+describe('compiler/Enum', () => {
   it('Should validate when emum uses default numeric values', () => {
     enum Kind {
       Foo, // = 0
diff --git a/test/runtime/compiler/index.ts b/test/runtime/compiler/index.ts
index e47c1ce9b..0524426fc 100644
--- a/test/runtime/compiler/index.ts
+++ b/test/runtime/compiler/index.ts
@@ -13,7 +13,6 @@ import './iterator'
 import './keyof'
 import './kind'
 import './literal'
-import './modifier'
 import './never'
 import './not'
 import './null'
diff --git a/test/runtime/compiler/integer.ts b/test/runtime/compiler/integer.ts
index 683842fbc..51720440e 100644
--- a/test/runtime/compiler/integer.ts
+++ b/test/runtime/compiler/integer.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Integer', () => {
+describe('compiler/Integer', () => {
   it('Should not validate number', () => {
     const T = Type.Integer()
     Fail(T, 3.14)
diff --git a/test/runtime/compiler/intersect.ts b/test/runtime/compiler/intersect.ts
index d7aae2e77..652e3be7f 100644
--- a/test/runtime/compiler/intersect.ts
+++ b/test/runtime/compiler/intersect.ts
@@ -1,7 +1,7 @@
-import { Type, Static } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Intersect', () => {
+describe('compiler/Intersect', () => {
   it('Should intersect number and number', () => {
     const A = Type.Number()
     const B = Type.Number()
diff --git a/test/runtime/compiler/iterator.ts b/test/runtime/compiler/iterator.ts
index 630504929..e5c5e0bb1 100644
--- a/test/runtime/compiler/iterator.ts
+++ b/test/runtime/compiler/iterator.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Iterator', () => {
+describe('compiler/Iterator', () => {
   it('Should validate a iterator 1', () => {
     function* f() {}
     const T = Type.Iterator(Type.Any())
diff --git a/test/runtime/compiler/keyof.ts b/test/runtime/compiler/keyof.ts
index 5acec21da..a1d5cc458 100644
--- a/test/runtime/compiler/keyof.ts
+++ b/test/runtime/compiler/keyof.ts
@@ -1,8 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
-import { strictEqual } from 'assert'
 
-describe('type/compiler/KeyOf', () => {
+describe('compiler/KeyOf', () => {
   it('Should validate with all object keys as a kind of union', () => {
     const T = Type.KeyOf(
       Type.Object({
diff --git a/test/runtime/compiler/kind.ts b/test/runtime/compiler/kind.ts
index 2b500cf5d..1f0274b00 100644
--- a/test/runtime/compiler/kind.ts
+++ b/test/runtime/compiler/kind.ts
@@ -3,7 +3,7 @@ import { TypeCompiler } from '@sinclair/typebox/compiler'
 import { Ok, Fail } from './validate'
 import { Assert } from '../assert'
 
-describe('type/compiler/Kind', () => {
+describe('compiler/Kind', () => {
   // ------------------------------------------------------------
   // Fixtures
   // ------------------------------------------------------------
diff --git a/test/runtime/compiler/literal.ts b/test/runtime/compiler/literal.ts
index ce81439d8..d2d17155a 100644
--- a/test/runtime/compiler/literal.ts
+++ b/test/runtime/compiler/literal.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Literal', () => {
+describe('compiler/Literal', () => {
   it('Should validate literal number', () => {
     const T = Type.Literal(42)
     Ok(T, 42)
diff --git a/test/runtime/compiler/modifier.ts b/test/runtime/compiler/modifier.ts
deleted file mode 100644
index 39f16c447..000000000
--- a/test/runtime/compiler/modifier.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { Type } from '@sinclair/typebox'
-
-describe('type/compiler/Modifier', () => {})
diff --git a/test/runtime/compiler/never.ts b/test/runtime/compiler/never.ts
index 6cc53bb93..e1a8c3afc 100644
--- a/test/runtime/compiler/never.ts
+++ b/test/runtime/compiler/never.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Fail } from './validate'
 
-describe('type/compiler/Never', () => {
+describe('compiler/Never', () => {
   it('Should not validate number', () => {
     const T = Type.Never()
     Fail(T, 1)
diff --git a/test/runtime/compiler/not.ts b/test/runtime/compiler/not.ts
index 144b31de4..3621e91c4 100644
--- a/test/runtime/compiler/not.ts
+++ b/test/runtime/compiler/not.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Not', () => {
+describe('compiler/Not', () => {
   it('Should validate not number', () => {
     const T = Type.Not(Type.Number())
     Fail(T, 1)
diff --git a/test/runtime/compiler/null.ts b/test/runtime/compiler/null.ts
index fcc8257fa..b23335f0b 100644
--- a/test/runtime/compiler/null.ts
+++ b/test/runtime/compiler/null.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Null', () => {
+describe('compiler/Null', () => {
   it('Should not validate number', () => {
     const T = Type.Null()
     Fail(T, 1)
diff --git a/test/runtime/compiler/number.ts b/test/runtime/compiler/number.ts
index 59081b8e3..7a97df5f5 100644
--- a/test/runtime/compiler/number.ts
+++ b/test/runtime/compiler/number.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Number', () => {
+describe('compiler/Number', () => {
   it('Should validate number', () => {
     const T = Type.Number()
     Ok(T, 3.14)
diff --git a/test/runtime/compiler/object.ts b/test/runtime/compiler/object.ts
index 9e526de49..10c154b4b 100644
--- a/test/runtime/compiler/object.ts
+++ b/test/runtime/compiler/object.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Object', () => {
+describe('compiler/Object', () => {
   // -----------------------------------------------------
   // TypeCompiler Only
   // -----------------------------------------------------
diff --git a/test/runtime/compiler/omit.ts b/test/runtime/compiler/omit.ts
index 9c38ff7c3..8ff7b1509 100644
--- a/test/runtime/compiler/omit.ts
+++ b/test/runtime/compiler/omit.ts
@@ -2,7 +2,7 @@ import { Type, Kind } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 import { deepEqual, strictEqual } from 'assert'
 
-describe('type/compiler/Omit', () => {
+describe('compiler/Omit', () => {
   it('Should omit properties on the source schema', () => {
     const A = Type.Object(
       {
diff --git a/test/runtime/compiler/optional.ts b/test/runtime/compiler/optional.ts
index a78384e67..5c24e175c 100644
--- a/test/runtime/compiler/optional.ts
+++ b/test/runtime/compiler/optional.ts
@@ -2,7 +2,7 @@ import { strictEqual } from 'assert'
 import { Type } from '@sinclair/typebox'
 import { Ok } from './validate'
 
-describe('type/compiler/Optional', () => {
+describe('compiler/Optional', () => {
   it('Should validate object with optional', () => {
     const T = Type.Object(
       {
diff --git a/test/runtime/compiler/partial.ts b/test/runtime/compiler/partial.ts
index 51a1d93fc..870e6979b 100644
--- a/test/runtime/compiler/partial.ts
+++ b/test/runtime/compiler/partial.ts
@@ -3,7 +3,7 @@ import { Type, Kind, Optional, Readonly } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
-describe('type/compiler/Partial', () => {
+describe('compiler/Partial', () => {
   it('Should convert a required object into a partial', () => {
     const A = Type.Object(
       {
diff --git a/test/runtime/compiler/pick.ts b/test/runtime/compiler/pick.ts
index 556aa9859..227a55b27 100644
--- a/test/runtime/compiler/pick.ts
+++ b/test/runtime/compiler/pick.ts
@@ -2,7 +2,7 @@ import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
-describe('type/compiler/Pick', () => {
+describe('compiler/Pick', () => {
   it('Should pick properties from the source schema', () => {
     const Vector3 = Type.Object(
       {
diff --git a/test/runtime/compiler/readonly-optional.ts b/test/runtime/compiler/readonly-optional.ts
index fdaef8b4e..e4aeffc88 100644
--- a/test/runtime/compiler/readonly-optional.ts
+++ b/test/runtime/compiler/readonly-optional.ts
@@ -2,7 +2,7 @@ import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
-describe('type/compiler/ReadonlyOptional', () => {
+describe('compiler/ReadonlyOptional', () => {
   it('Should validate object with optional', () => {
     const T = Type.Object(
       {
diff --git a/test/runtime/compiler/readonly.ts b/test/runtime/compiler/readonly.ts
index 1bc82d758..b852feb44 100644
--- a/test/runtime/compiler/readonly.ts
+++ b/test/runtime/compiler/readonly.ts
@@ -2,7 +2,7 @@ import { deepStrictEqual, strictEqual } from 'assert'
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Readonly', () => {
+describe('compiler/Readonly', () => {
   it('Should validate object with readonly', () => {
     const T = Type.Object(
       {
diff --git a/test/runtime/compiler/record.ts b/test/runtime/compiler/record.ts
index ab8381fb4..cd9322b08 100644
--- a/test/runtime/compiler/record.ts
+++ b/test/runtime/compiler/record.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Record', () => {
+describe('compiler/Record', () => {
   // -------------------------------------------------------------
   // Issues
   // -------------------------------------------------------------
diff --git a/test/runtime/compiler/recursive.ts b/test/runtime/compiler/recursive.ts
index 513864ec6..0b537eca3 100644
--- a/test/runtime/compiler/recursive.ts
+++ b/test/runtime/compiler/recursive.ts
@@ -2,7 +2,7 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert/index'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Recursive', () => {
+describe('compiler/Recursive', () => {
   it('Should generate default ordinal $id if not specified', () => {
     const Node = Type.Recursive((Node) =>
       Type.Object({
diff --git a/test/runtime/compiler/ref.ts b/test/runtime/compiler/ref.ts
index 88d564e40..771a7b4f6 100644
--- a/test/runtime/compiler/ref.ts
+++ b/test/runtime/compiler/ref.ts
@@ -2,7 +2,7 @@ import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 import { Assert } from '../assert/index'
 
-describe('type/compiler/Ref', () => {
+describe('compiler/Ref', () => {
   it('Should should validate when referencing a type', () => {
     const T = Type.Object(
       {
diff --git a/test/runtime/compiler/regexp.ts b/test/runtime/compiler/regexp.ts
index 9a926893f..8d5d9ea39 100644
--- a/test/runtime/compiler/regexp.ts
+++ b/test/runtime/compiler/regexp.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/RegExp', () => {
+describe('compiler/RegExp', () => {
   //-----------------------------------------------------
   // Regular Expression
   //-----------------------------------------------------
diff --git a/test/runtime/compiler/required.ts b/test/runtime/compiler/required.ts
index 80360c949..14ca1bf5f 100644
--- a/test/runtime/compiler/required.ts
+++ b/test/runtime/compiler/required.ts
@@ -2,7 +2,7 @@ import { Type, Readonly, Optional } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
-describe('type/compiler/compiler/Required', () => {
+describe('compiler/Required', () => {
   it('Should convert a partial object into a required object', () => {
     const A = Type.Object(
       {
diff --git a/test/runtime/compiler/string.ts b/test/runtime/compiler/string.ts
index 99beae9a0..2086bc3bd 100644
--- a/test/runtime/compiler/string.ts
+++ b/test/runtime/compiler/string.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/String', () => {
+describe('compiler/String', () => {
   it('Should not validate number', () => {
     const T = Type.String()
     Fail(T, 1)
diff --git a/test/runtime/compiler/symbol.ts b/test/runtime/compiler/symbol.ts
index fcca5a548..a35052612 100644
--- a/test/runtime/compiler/symbol.ts
+++ b/test/runtime/compiler/symbol.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Symbol', () => {
+describe('compiler/Symbol', () => {
   it('Should not validate a boolean', () => {
     const T = Type.Symbol()
     Fail(T, true)
diff --git a/test/runtime/compiler/template-literal.ts b/test/runtime/compiler/template-literal.ts
index c967cf9ee..7c0589cf0 100644
--- a/test/runtime/compiler/template-literal.ts
+++ b/test/runtime/compiler/template-literal.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/TemplateLiteral', () => {
+describe('compiler/TemplateLiteral', () => {
   // --------------------------------------------------------
   // Finite
   // --------------------------------------------------------
diff --git a/test/runtime/compiler/tuple.ts b/test/runtime/compiler/tuple.ts
index 9e1b82052..9271681a1 100644
--- a/test/runtime/compiler/tuple.ts
+++ b/test/runtime/compiler/tuple.ts
@@ -1,8 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
-import { Assert } from '../assert'
 
-describe('type/compiler/Tuple', () => {
+describe('compiler/Tuple', () => {
   it('Should validate tuple of [string, number]', () => {
     const A = Type.String()
     const B = Type.Number()
diff --git a/test/runtime/compiler/uint8array.ts b/test/runtime/compiler/uint8array.ts
index 274975b23..306498726 100644
--- a/test/runtime/compiler/uint8array.ts
+++ b/test/runtime/compiler/uint8array.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Uint8Array', () => {
+describe('compiler/Uint8Array', () => {
   it('Should not validate number', () => {
     const T = Type.Uint8Array()
     Fail(T, 1)
diff --git a/test/runtime/compiler/unicode.ts b/test/runtime/compiler/unicode.ts
index 2e65bd6cf..0e3e569d4 100644
--- a/test/runtime/compiler/unicode.ts
+++ b/test/runtime/compiler/unicode.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok } from './validate'
 
-describe('type/compiler/Unicode', () => {
+describe('compiler/Unicode', () => {
   // ---------------------------------------------------------
   // Identifiers
   // ---------------------------------------------------------
diff --git a/test/runtime/compiler/union.ts b/test/runtime/compiler/union.ts
index a1e1fe724..7cd710678 100644
--- a/test/runtime/compiler/union.ts
+++ b/test/runtime/compiler/union.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Union', () => {
+describe('compiler/Union', () => {
   it('Should validate union of string, number and boolean', () => {
     const A = Type.String()
     const B = Type.Number()
diff --git a/test/runtime/compiler/unknown.ts b/test/runtime/compiler/unknown.ts
index 30376d8e3..124a9f4a6 100644
--- a/test/runtime/compiler/unknown.ts
+++ b/test/runtime/compiler/unknown.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
-import { Ok, Fail } from './validate'
+import { Ok } from './validate'
 
-describe('type/compiler/Unknown', () => {
+describe('compiler/Unknown', () => {
   it('Should validate number', () => {
     const T = Type.Any()
     Ok(T, 1)
diff --git a/test/runtime/compiler/void.ts b/test/runtime/compiler/void.ts
index 4963c0e4e..4a203436c 100644
--- a/test/runtime/compiler/void.ts
+++ b/test/runtime/compiler/void.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/compiler/Void', () => {
+describe('compiler/Void', () => {
   it('Should not validate number', () => {
     const T = Type.Void()
     Fail(T, 1)
diff --git a/test/runtime/errors/index.ts b/test/runtime/errors/index.ts
index 41d3ac147..db746b1ff 100644
--- a/test/runtime/errors/index.ts
+++ b/test/runtime/errors/index.ts
@@ -1 +1,2 @@
-import './iterator'
+import './iterator/index'
+import './types/index'
diff --git a/test/runtime/errors/iterator/index.ts b/test/runtime/errors/iterator/index.ts
new file mode 100644
index 000000000..41d3ac147
--- /dev/null
+++ b/test/runtime/errors/iterator/index.ts
@@ -0,0 +1 @@
+import './iterator'
diff --git a/test/runtime/errors/iterator.ts b/test/runtime/errors/iterator/iterator.ts
similarity index 96%
rename from test/runtime/errors/iterator.ts
rename to test/runtime/errors/iterator/iterator.ts
index 1f1ef8858..d32cd126d 100644
--- a/test/runtime/errors/iterator.ts
+++ b/test/runtime/errors/iterator/iterator.ts
@@ -1,6 +1,6 @@
 import { Type } from '@sinclair/typebox'
 import { Errors } from '@sinclair/typebox/errors'
-import { Assert } from '../assert'
+import { Assert } from '../../assert'
 
 describe('errors/ValueErrorIterator', () => {
   it('Should return undefined for non error', () => {
diff --git a/test/runtime/errors/types/array-contains.ts b/test/runtime/errors/types/array-contains.ts
new file mode 100644
index 000000000..fe73e01f9
--- /dev/null
+++ b/test/runtime/errors/types/array-contains.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/ArrayMaxContainsItems', () => {
+  const T = Type.Array(Type.Any(), { contains: Type.Literal(1) })
+  it('Should pass 0', () => {
+    const R = Resolve(T, [1])
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, [2])
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.ArrayContains)
+  })
+})
diff --git a/test/runtime/errors/types/array-max-contains.ts b/test/runtime/errors/types/array-max-contains.ts
new file mode 100644
index 000000000..df55b1e10
--- /dev/null
+++ b/test/runtime/errors/types/array-max-contains.ts
@@ -0,0 +1,36 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/ArrayMaxContainsItems', () => {
+  const T = Type.Array(Type.Any(), { contains: Type.Literal(1), maxContains: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, [1, 1, 1, 1])
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, null)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Array)
+  })
+  it('Should pass 2', () => {
+    const R = Resolve(T, [1, 1, 1, 1, 1])
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.ArrayMaxContains)
+  })
+  it('Should pass 3', () => {
+    const R = Resolve(T, [])
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.ArrayContains)
+  })
+  it('Should pass 4', () => {
+    const R = Resolve(T, [1, 2, 3, 4])
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 5', () => {
+    const R = Resolve(T, [2, 3, 4])
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.ArrayContains)
+  })
+})
diff --git a/test/runtime/errors/types/array-max-items.ts b/test/runtime/errors/types/array-max-items.ts
new file mode 100644
index 000000000..b24fdc86f
--- /dev/null
+++ b/test/runtime/errors/types/array-max-items.ts
@@ -0,0 +1,22 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/ArrayMaxItems', () => {
+  const T = Type.Array(Type.Any(), { maxItems: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, [1, 2, 3, 4])
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, null)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Array)
+  })
+  it('Should pass 2', () => {
+    const R = Resolve(T, [1, 2, 3, 4, 5])
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.ArrayMaxItems)
+  })
+})
diff --git a/test/runtime/errors/types/array-min-contains.ts b/test/runtime/errors/types/array-min-contains.ts
new file mode 100644
index 000000000..a8240684a
--- /dev/null
+++ b/test/runtime/errors/types/array-min-contains.ts
@@ -0,0 +1,28 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/ArrayMinContainsItems', () => {
+  const T = Type.Array(Type.Any(), { contains: Type.Literal(1), minContains: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, [1, 1, 1, 1])
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, null)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Array)
+  })
+  it('Should pass 2', () => {
+    const R = Resolve(T, [1])
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.ArrayMinContains)
+  })
+  it('Should pass 3', () => {
+    const R = Resolve(T, [])
+    Assert.IsEqual(R.length, 2)
+    Assert.IsEqual(R[0].type, ValueErrorType.ArrayContains)
+    Assert.IsEqual(R[1].type, ValueErrorType.ArrayMinContains)
+  })
+})
diff --git a/test/runtime/errors/types/array-min-items.ts b/test/runtime/errors/types/array-min-items.ts
new file mode 100644
index 000000000..fc1770a08
--- /dev/null
+++ b/test/runtime/errors/types/array-min-items.ts
@@ -0,0 +1,22 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/ArrayMinItems', () => {
+  const T = Type.Array(Type.Any(), { minItems: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, [1, 2, 3, 4])
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, null)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Array)
+  })
+  it('Should pass 2', () => {
+    const R = Resolve(T, [])
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.ArrayMinItems)
+  })
+})
diff --git a/test/runtime/errors/types/array-unique-items.ts b/test/runtime/errors/types/array-unique-items.ts
new file mode 100644
index 000000000..d6f502cd6
--- /dev/null
+++ b/test/runtime/errors/types/array-unique-items.ts
@@ -0,0 +1,21 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/ArrayUniqueItems', () => {
+  const T = Type.Array(Type.Any(), { uniqueItems: true })
+  it('Should pass 0', () => {
+    const R = Resolve(T, [1, 2, 3, 4])
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 2', () => {
+    const R = Resolve(T, [])
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 3', () => {
+    const R = Resolve(T, [1, 1, 3, 4])
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.ArrayUniqueItems)
+  })
+})
diff --git a/test/runtime/errors/types/array.ts b/test/runtime/errors/types/array.ts
new file mode 100644
index 000000000..eb6904de2
--- /dev/null
+++ b/test/runtime/errors/types/array.ts
@@ -0,0 +1,27 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Array', () => {
+  const T = Type.Array(Type.Any())
+  it('Should pass 0', () => {
+    const R = Resolve(T, [1, 2, 3])
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 1)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Array)
+  })
+  it('Should pass 2', () => {
+    const R = Resolve(T, {})
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Array)
+  })
+  it('Should pass 3', () => {
+    const R = Resolve(T, null)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Array)
+  })
+})
diff --git a/test/runtime/errors/types/async-iterator.ts b/test/runtime/errors/types/async-iterator.ts
new file mode 100644
index 000000000..55f6f17d8
--- /dev/null
+++ b/test/runtime/errors/types/async-iterator.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/AsyncIterator', () => {
+  const T = Type.AsyncIterator(Type.Any())
+  it('Should pass 0', () => {
+    const R = Resolve(T, (async function* (): any {})())
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 1)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.AsyncIterator)
+  })
+})
diff --git a/test/runtime/errors/types/bigint-exclusive-maximum.ts b/test/runtime/errors/types/bigint-exclusive-maximum.ts
new file mode 100644
index 000000000..9acf831ef
--- /dev/null
+++ b/test/runtime/errors/types/bigint-exclusive-maximum.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/BigIntExclusiveMaximum', () => {
+  const T = Type.BigInt({ exclusiveMaximum: 4n })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 0n)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 4n)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.BigIntExclusiveMaximum)
+  })
+})
diff --git a/test/runtime/errors/types/bigint-exclusive-minimum.ts b/test/runtime/errors/types/bigint-exclusive-minimum.ts
new file mode 100644
index 000000000..80a19f4d2
--- /dev/null
+++ b/test/runtime/errors/types/bigint-exclusive-minimum.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/BigIntExclusiveMinimum', () => {
+  const T = Type.BigInt({ exclusiveMinimum: 4n })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 5n)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 4n)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.BigIntExclusiveMinimum)
+  })
+})
diff --git a/test/runtime/errors/types/bigint-maximum.ts b/test/runtime/errors/types/bigint-maximum.ts
new file mode 100644
index 000000000..fe5f2090b
--- /dev/null
+++ b/test/runtime/errors/types/bigint-maximum.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/BigIntMaximum', () => {
+  const T = Type.BigInt({ maximum: 4n })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 0n)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 5n)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.BigIntMaximum)
+  })
+})
diff --git a/test/runtime/errors/types/bigint-minimum.ts b/test/runtime/errors/types/bigint-minimum.ts
new file mode 100644
index 000000000..1f2177311
--- /dev/null
+++ b/test/runtime/errors/types/bigint-minimum.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/BigIntMinimum', () => {
+  const T = Type.BigInt({ minimum: 4n })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 4n)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 3n)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.BigIntMinimum)
+  })
+})
diff --git a/test/runtime/errors/types/bigint-multiple-of.ts b/test/runtime/errors/types/bigint-multiple-of.ts
new file mode 100644
index 000000000..f7fe277a1
--- /dev/null
+++ b/test/runtime/errors/types/bigint-multiple-of.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/BigIntMultipleOf', () => {
+  const T = Type.BigInt({ multipleOf: 2n })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 0n)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 1n)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.BigIntMultipleOf)
+  })
+})
diff --git a/test/runtime/errors/types/bigint.ts b/test/runtime/errors/types/bigint.ts
new file mode 100644
index 000000000..4f7ed05b3
--- /dev/null
+++ b/test/runtime/errors/types/bigint.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/BigInt', () => {
+  const T = Type.BigInt()
+  it('Should pass 0', () => {
+    const R = Resolve(T, 0n)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 0)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.BigInt)
+  })
+})
diff --git a/test/runtime/errors/types/boolean.ts b/test/runtime/errors/types/boolean.ts
new file mode 100644
index 000000000..5ed8edce1
--- /dev/null
+++ b/test/runtime/errors/types/boolean.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Boolean', () => {
+  const T = Type.Boolean()
+  it('Should pass 0', () => {
+    const R = Resolve(T, true)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 0)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Boolean)
+  })
+})
diff --git a/test/runtime/errors/types/date-exclusive-maximum-timestamp.ts b/test/runtime/errors/types/date-exclusive-maximum-timestamp.ts
new file mode 100644
index 000000000..ab1c29197
--- /dev/null
+++ b/test/runtime/errors/types/date-exclusive-maximum-timestamp.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/DateExclusiveMaximumTimestamp', () => {
+  const T = Type.Date({ exclusiveMaximumTimestamp: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, new Date(0))
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, new Date(4))
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.DateExclusiveMaximumTimestamp)
+  })
+})
diff --git a/test/runtime/errors/types/date-exclusive-minimum-timestamp.ts b/test/runtime/errors/types/date-exclusive-minimum-timestamp.ts
new file mode 100644
index 000000000..a9f439ef7
--- /dev/null
+++ b/test/runtime/errors/types/date-exclusive-minimum-timestamp.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/DateExclusiveMinimumTimestamp', () => {
+  const T = Type.Date({ exclusiveMinimumTimestamp: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, new Date(5))
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, new Date(4))
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.DateExclusiveMinimumTimestamp)
+  })
+})
diff --git a/test/runtime/errors/types/date-maximum-timestamp.ts b/test/runtime/errors/types/date-maximum-timestamp.ts
new file mode 100644
index 000000000..11e8805a3
--- /dev/null
+++ b/test/runtime/errors/types/date-maximum-timestamp.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/DateMaximumTimestamp', () => {
+  const T = Type.Date({ maximumTimestamp: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, new Date(0))
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, new Date(5))
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.DateMaximumTimestamp)
+  })
+})
diff --git a/test/runtime/errors/types/date-minimum-timestamp.ts b/test/runtime/errors/types/date-minimum-timestamp.ts
new file mode 100644
index 000000000..311fc474e
--- /dev/null
+++ b/test/runtime/errors/types/date-minimum-timestamp.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/DateMinimumTimestamp', () => {
+  const T = Type.Date({ minimumTimestamp: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, new Date(4))
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, new Date(3))
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.DateMinimumTimestamp)
+  })
+})
diff --git a/test/runtime/errors/types/date-multiple-of-timestamp.ts b/test/runtime/errors/types/date-multiple-of-timestamp.ts
new file mode 100644
index 000000000..8c3404ac1
--- /dev/null
+++ b/test/runtime/errors/types/date-multiple-of-timestamp.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/DateMultipleOfTimestamp', () => {
+  const T = Type.Date({ multipleOfTimestamp: 2 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, new Date(0))
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, new Date(1))
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.DateMultipleOfTimestamp)
+  })
+})
diff --git a/test/runtime/errors/types/date.ts b/test/runtime/errors/types/date.ts
new file mode 100644
index 000000000..01a553ec2
--- /dev/null
+++ b/test/runtime/errors/types/date.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Date', () => {
+  const T = Type.Date()
+  it('Should pass 0', () => {
+    const R = Resolve(T, new Date())
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 0)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Date)
+  })
+})
diff --git a/test/runtime/errors/types/function.ts b/test/runtime/errors/types/function.ts
new file mode 100644
index 000000000..4fbb628a8
--- /dev/null
+++ b/test/runtime/errors/types/function.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Function', () => {
+  const T = Type.Function([], Type.Any())
+  it('Should pass 0', () => {
+    const R = Resolve(T, function (): any {})
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 1)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Function)
+  })
+})
diff --git a/test/runtime/errors/types/index.ts b/test/runtime/errors/types/index.ts
new file mode 100644
index 000000000..077ccbe9e
--- /dev/null
+++ b/test/runtime/errors/types/index.ts
@@ -0,0 +1,63 @@
+import './array-contains'
+import './array-max-contains'
+import './array-min-items'
+import './array-min-contains'
+import './array-max-items'
+import './array-unique-items'
+import './array'
+import './async-iterator'
+import './bigint-exclusive-maximum'
+import './bigint-exclusive-minimum'
+import './bigint-maximum'
+import './bigint-minimum'
+import './bigint-multiple-of'
+import './bigint'
+import './boolean'
+import './date-exclusive-maximum-timestamp'
+import './date-exclusive-minimum-timestamp'
+import './date-maximum-timestamp'
+import './date-minimum-timestamp'
+import './date-multiple-of-timestamp'
+import './date'
+import './function'
+import './integer-exclusive-maximum'
+import './integer-exclusive-minimum'
+import './integer-maximum'
+import './integer-minimum'
+import './integer-multiple-of'
+import './integer'
+import './intersect-unevaluated-properties'
+import './intersect'
+import './iterator'
+import './kind'
+import './literal'
+import './never'
+import './not'
+import './null'
+import './number-exclusive-maximum'
+import './number-exclusive-minimum'
+import './number-maximum'
+import './number-minimum'
+import './number'
+import './number-multiple-of'
+import './object-additional-properties'
+import './object-max-properties'
+import './object-min-properties'
+import './object-required-property'
+import './object'
+import './promise'
+import './string-format-unknown'
+import './string-format'
+import './string-max-length'
+import './string-min-length'
+import './string-pattern'
+import './string'
+import './symbol'
+import './tuple-length'
+import './tuple'
+import './uint8array-max-byte-length'
+import './uint8array-min-byte-length'
+import './uint8array'
+import './undefined'
+import './union'
+import './void'
diff --git a/test/runtime/errors/types/integer-exclusive-maximum.ts b/test/runtime/errors/types/integer-exclusive-maximum.ts
new file mode 100644
index 000000000..0667c1060
--- /dev/null
+++ b/test/runtime/errors/types/integer-exclusive-maximum.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/IntegerExclusiveMaximum', () => {
+  const T = Type.Integer({ exclusiveMaximum: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 0)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 4)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.IntegerExclusiveMaximum)
+  })
+})
diff --git a/test/runtime/errors/types/integer-exclusive-minimum.ts b/test/runtime/errors/types/integer-exclusive-minimum.ts
new file mode 100644
index 000000000..e59556a93
--- /dev/null
+++ b/test/runtime/errors/types/integer-exclusive-minimum.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/IntegerExclusiveMinimum', () => {
+  const T = Type.Integer({ exclusiveMinimum: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 5)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 4)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.IntegerExclusiveMinimum)
+  })
+})
diff --git a/test/runtime/errors/types/integer-maximum.ts b/test/runtime/errors/types/integer-maximum.ts
new file mode 100644
index 000000000..fbe028570
--- /dev/null
+++ b/test/runtime/errors/types/integer-maximum.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/IntegerMaximum', () => {
+  const T = Type.Integer({ maximum: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 0)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 5)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.IntegerMaximum)
+  })
+})
diff --git a/test/runtime/errors/types/integer-minimum.ts b/test/runtime/errors/types/integer-minimum.ts
new file mode 100644
index 000000000..f7590e110
--- /dev/null
+++ b/test/runtime/errors/types/integer-minimum.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/IntegerMinimum', () => {
+  const T = Type.Integer({ minimum: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 4)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 3)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.IntegerMinimum)
+  })
+})
diff --git a/test/runtime/errors/types/integer-multiple-of.ts b/test/runtime/errors/types/integer-multiple-of.ts
new file mode 100644
index 000000000..38a0e14ff
--- /dev/null
+++ b/test/runtime/errors/types/integer-multiple-of.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/IntegerMultipleOf', () => {
+  const T = Type.Integer({ multipleOf: 2 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 0)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 1)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.IntegerMultipleOf)
+  })
+})
diff --git a/test/runtime/errors/types/integer.ts b/test/runtime/errors/types/integer.ts
new file mode 100644
index 000000000..5f671ed63
--- /dev/null
+++ b/test/runtime/errors/types/integer.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Integer', () => {
+  const T = Type.Integer()
+  it('Should pass 0', () => {
+    const R = Resolve(T, 0)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 0n)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Integer)
+  })
+})
diff --git a/test/runtime/errors/types/intersect-unevaluated-properties.ts b/test/runtime/errors/types/intersect-unevaluated-properties.ts
new file mode 100644
index 000000000..58624b214
--- /dev/null
+++ b/test/runtime/errors/types/intersect-unevaluated-properties.ts
@@ -0,0 +1,36 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/IntersectUnevaluatedProperties', () => {
+  const T1 = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })], {
+    unevaluatedProperties: false,
+  })
+  it('Should pass 0', () => {
+    const R = Resolve(T1, { x: 1, y: 2 })
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T1, { x: 1, y: 2, z: 3 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.IntersectUnevaluatedProperties)
+  })
+  const T2 = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })], {
+    unevaluatedProperties: Type.String(),
+  })
+  it('Should pass 3', () => {
+    const R = Resolve(T2, { x: 1, y: 2, z: '1' })
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 4', () => {
+    const R = Resolve(T2, { x: 1, y: 2, a: 1, b: 2 })
+    Assert.IsEqual(R.length, 2)
+    Assert.IsEqual(R[0].type, ValueErrorType.String)
+    Assert.IsEqual(R[0].path, '/a')
+    Assert.IsEqual(R[0].value, 1)
+    Assert.IsEqual(R[1].type, ValueErrorType.String)
+    Assert.IsEqual(R[1].path, '/b')
+    Assert.IsEqual(R[1].value, 2)
+  })
+})
diff --git a/test/runtime/errors/types/intersect.ts b/test/runtime/errors/types/intersect.ts
new file mode 100644
index 000000000..e45b0dd19
--- /dev/null
+++ b/test/runtime/errors/types/intersect.ts
@@ -0,0 +1,24 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Intersect', () => {
+  const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
+  it('Should pass 0', () => {
+    const R = Resolve(T, { x: 1, y: 1 })
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, { x: 1 })
+    Assert.IsEqual(R.length, 2)
+    Assert.IsEqual(R[0].type, ValueErrorType.Intersect)
+    Assert.IsEqual(R[1].type, ValueErrorType.ObjectRequiredProperty)
+  })
+  it('Should pass 2', () => {
+    const R = Resolve(T, { y: 1 })
+    Assert.IsEqual(R.length, 2)
+    Assert.IsEqual(R[0].type, ValueErrorType.Intersect)
+    Assert.IsEqual(R[1].type, ValueErrorType.ObjectRequiredProperty)
+  })
+})
diff --git a/test/runtime/errors/types/iterator.ts b/test/runtime/errors/types/iterator.ts
new file mode 100644
index 000000000..f1ceee268
--- /dev/null
+++ b/test/runtime/errors/types/iterator.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Iterator', () => {
+  const T = Type.Iterator(Type.Any())
+  it('Should pass 0', () => {
+    const R = Resolve(T, (function* (): any {})())
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 1)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Iterator)
+  })
+})
diff --git a/test/runtime/errors/types/kind.ts b/test/runtime/errors/types/kind.ts
new file mode 100644
index 000000000..c8865353e
--- /dev/null
+++ b/test/runtime/errors/types/kind.ts
@@ -0,0 +1,25 @@
+import { TypeRegistry, Kind, TSchema } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Kind', () => {
+  // ----------------------------------------------------
+  // Fixture
+  // ----------------------------------------------------
+  beforeEach(() => TypeRegistry.Set('Foo', (schema, value) => value === 'foo'))
+  afterEach(() => TypeRegistry.Delete('Foo'))
+  // ----------------------------------------------------
+  // Test
+  // ----------------------------------------------------
+  const T = { [Kind]: 'Foo' } as TSchema
+  it('Should pass 0', () => {
+    const R = Resolve(T, 'foo')
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 1)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Kind)
+  })
+})
diff --git a/test/runtime/errors/types/literal.ts b/test/runtime/errors/types/literal.ts
new file mode 100644
index 000000000..2fe351133
--- /dev/null
+++ b/test/runtime/errors/types/literal.ts
@@ -0,0 +1,46 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Literal', () => {
+  // -----------------------------------------------------
+  // LiteralString
+  // -----------------------------------------------------
+  const T1 = Type.Literal('hello')
+  it('Should pass 0', () => {
+    const R = Resolve(T1, 'hello')
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T1, 'world')
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Literal)
+  })
+  // -----------------------------------------------------
+  // LiteralNumber
+  // -----------------------------------------------------
+  const T2 = Type.Literal(0)
+  it('Should pass 2', () => {
+    const R = Resolve(T2, 0)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 3', () => {
+    const R = Resolve(T2, 1)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Literal)
+  })
+  // -----------------------------------------------------
+  // LiteralBoolean
+  // -----------------------------------------------------
+  const T3 = Type.Literal(true)
+  it('Should pass 4', () => {
+    const R = Resolve(T3, true)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 5', () => {
+    const R = Resolve(T3, false)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Literal)
+  })
+})
diff --git a/test/runtime/errors/types/never.ts b/test/runtime/errors/types/never.ts
new file mode 100644
index 000000000..e85e808ff
--- /dev/null
+++ b/test/runtime/errors/types/never.ts
@@ -0,0 +1,13 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Never', () => {
+  const T = Type.Never()
+  it('Should pass 1', () => {
+    const R = Resolve(T, 0)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Never)
+  })
+})
diff --git a/test/runtime/errors/types/not.ts b/test/runtime/errors/types/not.ts
new file mode 100644
index 000000000..01d3605c5
--- /dev/null
+++ b/test/runtime/errors/types/not.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Not', () => {
+  const T = Type.Not(Type.String())
+  it('Should pass 0', () => {
+    const R = Resolve(T, true)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 'hello')
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Not)
+  })
+})
diff --git a/test/runtime/errors/types/null.ts b/test/runtime/errors/types/null.ts
new file mode 100644
index 000000000..0b897dc6a
--- /dev/null
+++ b/test/runtime/errors/types/null.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Null', () => {
+  const T = Type.Null()
+  it('Should pass 0', () => {
+    const R = Resolve(T, null)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 1)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Null)
+  })
+})
diff --git a/test/runtime/errors/types/number-exclusive-maximum.ts b/test/runtime/errors/types/number-exclusive-maximum.ts
new file mode 100644
index 000000000..b80ce9417
--- /dev/null
+++ b/test/runtime/errors/types/number-exclusive-maximum.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/NumberExclusiveMaximum', () => {
+  const T = Type.Number({ exclusiveMaximum: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 0)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 4)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.NumberExclusiveMaximum)
+  })
+})
diff --git a/test/runtime/errors/types/number-exclusive-minimum.ts b/test/runtime/errors/types/number-exclusive-minimum.ts
new file mode 100644
index 000000000..c474a8dd7
--- /dev/null
+++ b/test/runtime/errors/types/number-exclusive-minimum.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/NumberExclusiveMinimum', () => {
+  const T = Type.Number({ exclusiveMinimum: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 5)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 4)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.NumberExclusiveMinimum)
+  })
+})
diff --git a/test/runtime/errors/types/number-maximum.ts b/test/runtime/errors/types/number-maximum.ts
new file mode 100644
index 000000000..fa4a3ec1d
--- /dev/null
+++ b/test/runtime/errors/types/number-maximum.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/NumberMaximum', () => {
+  const T = Type.Number({ maximum: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 0)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 5)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.NumberMaximum)
+  })
+})
diff --git a/test/runtime/errors/types/number-minimum.ts b/test/runtime/errors/types/number-minimum.ts
new file mode 100644
index 000000000..8d8f4bfc2
--- /dev/null
+++ b/test/runtime/errors/types/number-minimum.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/NumberMinimum', () => {
+  const T = Type.Number({ minimum: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 4)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 3)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.NumberMinimum)
+  })
+})
diff --git a/test/runtime/errors/types/number-multiple-of.ts b/test/runtime/errors/types/number-multiple-of.ts
new file mode 100644
index 000000000..921a2367d
--- /dev/null
+++ b/test/runtime/errors/types/number-multiple-of.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/NumberMultipleOf', () => {
+  const T = Type.Number({ multipleOf: 2 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 0)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 1)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.NumberMultipleOf)
+  })
+})
diff --git a/test/runtime/errors/types/number.ts b/test/runtime/errors/types/number.ts
new file mode 100644
index 000000000..0055c4dc1
--- /dev/null
+++ b/test/runtime/errors/types/number.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Number', () => {
+  const T = Type.Number()
+  it('Should pass 0', () => {
+    const R = Resolve(T, 0)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 0n)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Number)
+  })
+})
diff --git a/test/runtime/errors/types/object-additional-properties.ts b/test/runtime/errors/types/object-additional-properties.ts
new file mode 100644
index 000000000..9cad1bfc0
--- /dev/null
+++ b/test/runtime/errors/types/object-additional-properties.ts
@@ -0,0 +1,48 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/ObjectAdditionalProperties', () => {
+  // ----------------------------------------------------------
+  // additionalProperties: false
+  // ----------------------------------------------------------
+  const T1 = Type.Object(
+    {
+      x: Type.Number(),
+    },
+    { additionalProperties: false },
+  )
+  it('Should pass 0', () => {
+    const R = Resolve(T1, { x: 1 })
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T1, { x: 1, y: 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.ObjectAdditionalProperties)
+  })
+  // ----------------------------------------------------------
+  // additionalProperties: TSchema
+  // ----------------------------------------------------------
+  const T2 = Type.Object(
+    {
+      x: Type.Number(),
+    },
+    { additionalProperties: Type.String() },
+  )
+  it('Should pass 2', () => {
+    const R = Resolve(T2, { x: 1 })
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 3', () => {
+    const R = Resolve(T2, { x: 1, a: 1, b: 2 })
+    Assert.IsEqual(R.length, 2)
+    Assert.IsEqual(R[0].type, ValueErrorType.String)
+    Assert.IsEqual(R[0].path, '/a')
+    Assert.IsEqual(R[0].value, 1)
+    Assert.IsEqual(R[1].type, ValueErrorType.String)
+    Assert.IsEqual(R[1].path, '/b')
+    Assert.IsEqual(R[1].value, 2)
+  })
+})
diff --git a/test/runtime/errors/types/object-max-properties.ts b/test/runtime/errors/types/object-max-properties.ts
new file mode 100644
index 000000000..ee042e3f0
--- /dev/null
+++ b/test/runtime/errors/types/object-max-properties.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/ObjectMaxProperties', () => {
+  const T = Type.Object({}, { maxProperties: 2 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, { x: 1, y: 2 })
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, { x: 1, y: 2, z: 3 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.ObjectMaxProperties)
+  })
+})
diff --git a/test/runtime/errors/types/object-min-properties.ts b/test/runtime/errors/types/object-min-properties.ts
new file mode 100644
index 000000000..428a8b7e3
--- /dev/null
+++ b/test/runtime/errors/types/object-min-properties.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/ObjectMinProperties', () => {
+  const T = Type.Object({}, { minProperties: 2 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, { x: 1, y: 2 })
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, { x: 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.ObjectMinProperties)
+  })
+})
diff --git a/test/runtime/errors/types/object-required-property.ts b/test/runtime/errors/types/object-required-property.ts
new file mode 100644
index 000000000..4019885a7
--- /dev/null
+++ b/test/runtime/errors/types/object-required-property.ts
@@ -0,0 +1,22 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/ObjectRequiredProperty', () => {
+  const T = Type.Object({ x: Type.Number(), y: Type.Number() })
+  it('Should pass 0', () => {
+    const R = Resolve(T, { x: 1, y: 2 })
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, { x: 1 })
+    Assert.IsEqual(R.length, 2)
+    Assert.IsEqual(R[0].type, ValueErrorType.ObjectRequiredProperty)
+    Assert.IsEqual(R[0].path, '/y')
+    Assert.IsEqual(R[0].value, undefined)
+    Assert.IsEqual(R[1].type, ValueErrorType.Number)
+    Assert.IsEqual(R[1].path, '/y')
+    Assert.IsEqual(R[1].value, undefined)
+  })
+})
diff --git a/test/runtime/errors/types/object.ts b/test/runtime/errors/types/object.ts
new file mode 100644
index 000000000..3e9b86de8
--- /dev/null
+++ b/test/runtime/errors/types/object.ts
@@ -0,0 +1,65 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Object', () => {
+  // -----------------------------------------------------------------
+  // Object
+  // -----------------------------------------------------------------
+  const T1 = Type.Object({ x: Type.Number(), y: Type.Number() })
+  it('Should pass 0', () => {
+    const R = Resolve(T1, { x: 1, y: 2 })
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T1, null)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Object)
+  })
+  // -----------------------------------------------------------------
+  // Object: Optional
+  // -----------------------------------------------------------------
+  const T2 = Type.Object({ x: Type.Optional(Type.Number()) })
+  it('Should pass 2', () => {
+    const R = Resolve(T2, {})
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 3', () => {
+    const R = Resolve(T2, { x: 1 })
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 4', () => {
+    const R = Resolve(T2, { x: '' })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Number)
+    Assert.IsEqual(R[0].path, '/x')
+    Assert.IsEqual(R[0].value, '')
+  })
+  // -----------------------------------------------------------------
+  // Object: Optional Multiple
+  // -----------------------------------------------------------------
+  const T3 = Type.Partial(Type.Object({ x: Type.Number(), y: Type.Number() }))
+  it('Should pass 5', () => {
+    const R = Resolve(T3, {})
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 6', () => {
+    const R = Resolve(T3, { x: 1 })
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 7', () => {
+    const R = Resolve(T3, { y: 1 })
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 8', () => {
+    const R = Resolve(T3, { x: 'a', y: 'b' })
+    Assert.IsEqual(R.length, 2)
+    Assert.IsEqual(R[0].type, ValueErrorType.Number)
+    Assert.IsEqual(R[0].path, '/x')
+    Assert.IsEqual(R[0].value, 'a')
+    Assert.IsEqual(R[1].type, ValueErrorType.Number)
+    Assert.IsEqual(R[1].path, '/y')
+    Assert.IsEqual(R[1].value, 'b')
+  })
+})
diff --git a/test/runtime/errors/types/promise.ts b/test/runtime/errors/types/promise.ts
new file mode 100644
index 000000000..81dbe426a
--- /dev/null
+++ b/test/runtime/errors/types/promise.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Promise', () => {
+  const T = Type.Promise(Type.Any())
+  it('Should pass 0', () => {
+    const R = Resolve(T, Promise.resolve(0))
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 0)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Promise)
+  })
+})
diff --git a/test/runtime/errors/types/resolve.ts b/test/runtime/errors/types/resolve.ts
new file mode 100644
index 000000000..e636137be
--- /dev/null
+++ b/test/runtime/errors/types/resolve.ts
@@ -0,0 +1,7 @@
+import { Errors } from '@sinclair/typebox/errors'
+import { TSchema } from '@sinclair/typebox'
+
+/** Resolves errors */
+export function Resolve<T extends TSchema>(schema: T, value: unknown) {
+  return [...Errors(schema, value)]
+}
diff --git a/test/runtime/errors/types/string-format-unknown.ts b/test/runtime/errors/types/string-format-unknown.ts
new file mode 100644
index 000000000..b40e9622d
--- /dev/null
+++ b/test/runtime/errors/types/string-format-unknown.ts
@@ -0,0 +1,13 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/StringFormatUnknown', () => {
+  const T = Type.String({ format: 'unknown' })
+  it('Should pass 1', () => {
+    const R = Resolve(T, '')
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.StringFormatUnknown)
+  })
+})
diff --git a/test/runtime/errors/types/string-format.ts b/test/runtime/errors/types/string-format.ts
new file mode 100644
index 000000000..d4f03453c
--- /dev/null
+++ b/test/runtime/errors/types/string-format.ts
@@ -0,0 +1,25 @@
+import { Type, FormatRegistry } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/StringFormat', () => {
+  // ----------------------------------------------
+  // Fixture
+  // ----------------------------------------------
+  beforeEach(() => FormatRegistry.Set('foo', (value) => value === 'foo'))
+  afterEach(() => FormatRegistry.Delete('foo'))
+  // ----------------------------------------------
+  // Tests
+  // ----------------------------------------------
+  const T = Type.String({ format: 'foo' })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 'foo')
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 'bar')
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.StringFormat)
+  })
+})
diff --git a/test/runtime/errors/types/string-max-length.ts b/test/runtime/errors/types/string-max-length.ts
new file mode 100644
index 000000000..973ab2665
--- /dev/null
+++ b/test/runtime/errors/types/string-max-length.ts
@@ -0,0 +1,17 @@
+import { Type, FormatRegistry } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/StringMaxLength', () => {
+  const T = Type.String({ maxLength: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, '1234')
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, '12345')
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.StringMaxLength)
+  })
+})
diff --git a/test/runtime/errors/types/string-min-length.ts b/test/runtime/errors/types/string-min-length.ts
new file mode 100644
index 000000000..aa96f9257
--- /dev/null
+++ b/test/runtime/errors/types/string-min-length.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/StringMinLength', () => {
+  const T = Type.String({ minLength: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, '1234')
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, '123')
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.StringMinLength)
+  })
+})
diff --git a/test/runtime/errors/types/string-pattern.ts b/test/runtime/errors/types/string-pattern.ts
new file mode 100644
index 000000000..07c2f0655
--- /dev/null
+++ b/test/runtime/errors/types/string-pattern.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/StringPattern', () => {
+  const T = Type.String({ pattern: '123' })
+  it('Should pass 0', () => {
+    const R = Resolve(T, '123')
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, '321')
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.StringPattern)
+  })
+})
diff --git a/test/runtime/errors/types/string.ts b/test/runtime/errors/types/string.ts
new file mode 100644
index 000000000..79003ccfd
--- /dev/null
+++ b/test/runtime/errors/types/string.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/String', () => {
+  const T = Type.String()
+  it('Should pass 0', () => {
+    const R = Resolve(T, 'hello')
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 1)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.String)
+  })
+})
diff --git a/test/runtime/errors/types/symbol.ts b/test/runtime/errors/types/symbol.ts
new file mode 100644
index 000000000..ced5c216b
--- /dev/null
+++ b/test/runtime/errors/types/symbol.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Symbol', () => {
+  const T = Type.Symbol()
+  it('Should pass 0', () => {
+    const R = Resolve(T, Symbol(1))
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 1)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Symbol)
+  })
+})
diff --git a/test/runtime/errors/types/tuple-length.ts b/test/runtime/errors/types/tuple-length.ts
new file mode 100644
index 000000000..e8265e63d
--- /dev/null
+++ b/test/runtime/errors/types/tuple-length.ts
@@ -0,0 +1,56 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/TupleLength', () => {
+  // ----------------------------------------------
+  // Tuple: Empty
+  // ----------------------------------------------
+  const T1 = Type.Tuple([])
+  it('Should pass 0', () => {
+    const R = Resolve(T1, [])
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T1, [1])
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.TupleLength)
+  })
+  // ----------------------------------------------
+  // Tuple: One
+  // ----------------------------------------------
+  const T2 = Type.Tuple([Type.Number()])
+  it('Should pass 2', () => {
+    const R = Resolve(T2, [1])
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 3', () => {
+    const R = Resolve(T2, [])
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.TupleLength)
+  })
+  it('Should pass 4', () => {
+    const R = Resolve(T2, [1, 1])
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.TupleLength)
+  })
+  // ----------------------------------------------
+  // Tuple: Element
+  // ----------------------------------------------
+  const T3 = Type.Tuple([Type.Number(), Type.Number()])
+  it('Should pass 5', () => {
+    const R = Resolve(T3, [1, 1])
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 6', () => {
+    const R = Resolve(T3, ['a', 'b'])
+    Assert.IsEqual(R.length, 2)
+    Assert.IsEqual(R[0].type, ValueErrorType.Number)
+    Assert.IsEqual(R[0].path, '/0')
+    Assert.IsEqual(R[0].value, 'a')
+    Assert.IsEqual(R[1].type, ValueErrorType.Number)
+    Assert.IsEqual(R[1].path, '/1')
+    Assert.IsEqual(R[1].value, 'b')
+  })
+})
diff --git a/test/runtime/errors/types/tuple.ts b/test/runtime/errors/types/tuple.ts
new file mode 100644
index 000000000..acfa15070
--- /dev/null
+++ b/test/runtime/errors/types/tuple.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Tuple', () => {
+  const T = Type.Tuple([])
+  it('Should pass 0', () => {
+    const R = Resolve(T, [])
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 1)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Tuple)
+  })
+})
diff --git a/test/runtime/errors/types/uint8array-max-byte-length.ts b/test/runtime/errors/types/uint8array-max-byte-length.ts
new file mode 100644
index 000000000..4e530e1aa
--- /dev/null
+++ b/test/runtime/errors/types/uint8array-max-byte-length.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Uint8ArrayMaxByteLength', () => {
+  const T = Type.Uint8Array({ maxByteLength: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, new Uint8Array(4))
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, new Uint8Array(5))
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Uint8ArrayMaxByteLength)
+  })
+})
diff --git a/test/runtime/errors/types/uint8array-min-byte-length.ts b/test/runtime/errors/types/uint8array-min-byte-length.ts
new file mode 100644
index 000000000..0ecc7c1b7
--- /dev/null
+++ b/test/runtime/errors/types/uint8array-min-byte-length.ts
@@ -0,0 +1,17 @@
+import { Type, FormatRegistry } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Uint8ArrayMinByteLength', () => {
+  const T = Type.Uint8Array({ minByteLength: 4 })
+  it('Should pass 0', () => {
+    const R = Resolve(T, new Uint8Array(4))
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, new Uint8Array(3))
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Uint8ArrayMinByteLength)
+  })
+})
diff --git a/test/runtime/errors/types/uint8array.ts b/test/runtime/errors/types/uint8array.ts
new file mode 100644
index 000000000..51b99dbc5
--- /dev/null
+++ b/test/runtime/errors/types/uint8array.ts
@@ -0,0 +1,17 @@
+import { Type, FormatRegistry } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Uint8Array', () => {
+  const T = Type.Uint8Array()
+  it('Should pass 0', () => {
+    const R = Resolve(T, new Uint8Array(4))
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, null)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Uint8Array)
+  })
+})
diff --git a/test/runtime/errors/types/undefined.ts b/test/runtime/errors/types/undefined.ts
new file mode 100644
index 000000000..ac3be5d4f
--- /dev/null
+++ b/test/runtime/errors/types/undefined.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Undefined', () => {
+  const T = Type.Undefined()
+  it('Should pass 0', () => {
+    const R = Resolve(T, undefined)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 0)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Undefined)
+  })
+})
diff --git a/test/runtime/errors/types/union.ts b/test/runtime/errors/types/union.ts
new file mode 100644
index 000000000..df110ed30
--- /dev/null
+++ b/test/runtime/errors/types/union.ts
@@ -0,0 +1,21 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/Union', () => {
+  const T = Type.Union([Type.String(), Type.Number()])
+  it('Should pass 0', () => {
+    const R = Resolve(T, '1')
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 1)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 2', () => {
+    const R = Resolve(T, true)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Union)
+  })
+})
diff --git a/test/runtime/errors/types/void.ts b/test/runtime/errors/types/void.ts
new file mode 100644
index 000000000..cd5132f78
--- /dev/null
+++ b/test/runtime/errors/types/void.ts
@@ -0,0 +1,32 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+import { TypeSystemPolicy } from '@sinclair/typebox/system'
+
+describe('errors/type/Void', () => {
+  const T = Type.Void()
+  it('Should pass 0', () => {
+    const R = Resolve(T, void 0)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, undefined)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 2', () => {
+    const R = Resolve(T, void 1)
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 3', () => {
+    const R = Resolve(T, null)
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.Void)
+  })
+  it('Should pass 4', () => {
+    TypeSystemPolicy.AllowNullVoid = true
+    const R = Resolve(T, null)
+    Assert.IsEqual(R.length, 0)
+    TypeSystemPolicy.AllowNullVoid = false
+  })
+})
diff --git a/test/runtime/system/index.ts b/test/runtime/system/index.ts
index a3fc40210..8365111b5 100644
--- a/test/runtime/system/index.ts
+++ b/test/runtime/system/index.ts
@@ -1 +1,2 @@
-import './system'
+import './policy/index'
+import './type/index'
diff --git a/test/runtime/system/policy/allow-array-object.ts b/test/runtime/system/policy/allow-array-object.ts
new file mode 100644
index 000000000..7e23d5491
--- /dev/null
+++ b/test/runtime/system/policy/allow-array-object.ts
@@ -0,0 +1,65 @@
+import { Ok, Fail } from '../../compiler/validate'
+import { TypeSystemPolicy } from '@sinclair/typebox/system'
+import { Type } from '@sinclair/typebox'
+
+describe('system/TypeSystemPolicy/AllowArrayObject', () => {
+  beforeEach(() => {
+    TypeSystemPolicy.AllowArrayObject = true
+  })
+  afterEach(() => {
+    TypeSystemPolicy.AllowArrayObject = false
+  })
+  // ---------------------------------------------------------------
+  // Object
+  // ---------------------------------------------------------------
+  it('Should validate arrays with empty objects', () => {
+    const T = Type.Object({})
+    Ok(T, [0, 1, 2])
+  })
+  it('Should validate arrays with objects with length property', () => {
+    const T = Type.Object({ length: Type.Number() })
+    Ok(T, [0, 1, 2])
+  })
+  it('Should validate arrays with objects with additionalProperties false when array has no elements', () => {
+    const T = Type.Object({ length: Type.Number() }, { additionalProperties: false })
+    Ok(T, [])
+  })
+  it('Should not validate arrays with objects with additionalProperties false when array has elements', () => {
+    const T = Type.Object({ length: Type.Number() }, { additionalProperties: false })
+    Fail(T, [0, 1, 2])
+  })
+  it('Should not validate arrays with objects when length property is string', () => {
+    const T = Type.Object({ length: Type.String() })
+    Fail(T, [0, 1, 2])
+  })
+  // ---------------------------------------------------------------
+  // Record
+  // ---------------------------------------------------------------
+  it('Should validate arrays as Records with String Keys', () => {
+    const T = Type.Record(Type.String(), Type.Number())
+    Ok(T, [0, 1, 2])
+  })
+  it('Should validate arrays as Records with Number Keys', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    Ok(T, [0, 1, 2])
+  })
+  it('Should validate arrays as Records with Integer Keys', () => {
+    const T = Type.Record(Type.Integer(), Type.Number())
+    Ok(T, [0, 1, 2])
+  })
+  it('Should not validate arrays as Records with Object Values', () => {
+    const T = Type.Record(
+      Type.String(),
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+    )
+    Ok(T, [
+      { x: 1, y: 1, z: 1 },
+      { x: 1, y: 1, z: 1 },
+      { x: 1, y: 1, z: 1 },
+    ])
+  })
+})
diff --git a/test/runtime/system/policy/allow-nan.ts b/test/runtime/system/policy/allow-nan.ts
new file mode 100644
index 000000000..54ec151cf
--- /dev/null
+++ b/test/runtime/system/policy/allow-nan.ts
@@ -0,0 +1,62 @@
+import { Ok, Fail } from '../../compiler/validate'
+import { TypeSystemPolicy } from '@sinclair/typebox/system'
+import { Type } from '@sinclair/typebox'
+
+describe('system/TypeSystemPolicy/AllowNaN', () => {
+  beforeEach(() => {
+    TypeSystemPolicy.AllowNaN = true
+  })
+  afterEach(() => {
+    TypeSystemPolicy.AllowNaN = false
+  })
+  // ---------------------------------------------------------------
+  // Number
+  // ---------------------------------------------------------------
+  it('Should validate number with NaN', () => {
+    const T = Type.Number()
+    Ok(T, NaN)
+  })
+  it('Should validate number with +Infinity', () => {
+    const T = Type.Number()
+    Ok(T, Infinity)
+  })
+  it('Should validate number with -Infinity', () => {
+    const T = Type.Number()
+    Ok(T, -Infinity)
+  })
+  // ---------------------------------------------------------------
+  // Integer
+  //
+  // Note: The Number.isInteger() test will fail for NaN. Because
+  // of this we cannot reasonably override NaN handling for integers.
+  // ---------------------------------------------------------------
+  it('Should not validate integer with NaN', () => {
+    const T = Type.Integer()
+    Fail(T, NaN)
+  })
+  it('Should not validate integer with +Infinity', () => {
+    const T = Type.Integer()
+    Fail(T, Infinity)
+  })
+  it('Should not validate integer with -Infinity', () => {
+    const T = Type.Integer()
+    Fail(T, -Infinity)
+  })
+  // ---------------------------------------------------------------
+  // BigInt
+  //
+  // Note: We expect failures here as bigint isn't IEEE754
+  // ---------------------------------------------------------------
+  it('Should not validate bigint with NaN', () => {
+    const T = Type.BigInt()
+    Fail(T, NaN)
+  })
+  it('Should not validate bigint with +Infinity', () => {
+    const T = Type.BigInt()
+    Fail(T, Infinity)
+  })
+  it('Should not validate bigint with -Infinity', () => {
+    const T = Type.BigInt()
+    Fail(T, -Infinity)
+  })
+})
diff --git a/test/runtime/system/policy/allow-null-void.ts b/test/runtime/system/policy/allow-null-void.ts
new file mode 100644
index 000000000..5903890fa
--- /dev/null
+++ b/test/runtime/system/policy/allow-null-void.ts
@@ -0,0 +1,31 @@
+import { Ok } from '../../compiler/validate'
+import { TypeSystemPolicy } from '@sinclair/typebox/system'
+import { Type } from '@sinclair/typebox'
+
+describe('system/TypeSystemPolicy/AllowNullVoid', () => {
+  beforeEach(() => {
+    TypeSystemPolicy.AllowNullVoid = true
+  })
+  afterEach(() => {
+    TypeSystemPolicy.AllowNullVoid = false
+  })
+  // ---------------------------------------------------------------
+  // Object
+  // ---------------------------------------------------------------
+  it('Should validate with null', () => {
+    const T = Type.Void()
+    Ok(T, null)
+  })
+  it('Should validate with undefined', () => {
+    const T = Type.Void()
+    Ok(T, undefined)
+  })
+  it('Should validate with void 0', () => {
+    const T = Type.Void()
+    Ok(T, void 0)
+  })
+  it('Should validate with void 1', () => {
+    const T = Type.Void()
+    Ok(T, void 1)
+  })
+})
diff --git a/test/runtime/system/policy/exact-optional-property-types.ts b/test/runtime/system/policy/exact-optional-property-types.ts
new file mode 100644
index 000000000..6c6e63bca
--- /dev/null
+++ b/test/runtime/system/policy/exact-optional-property-types.ts
@@ -0,0 +1,39 @@
+import { Ok, Fail } from '../../compiler/validate'
+import { TypeSystemPolicy } from '@sinclair/typebox/system'
+import { Type } from '@sinclair/typebox'
+
+describe('system/TypeSystemPolicy/ExactOptionalPropertyTypes', () => {
+  beforeEach(() => {
+    TypeSystemPolicy.ExactOptionalPropertyTypes = true
+  })
+  afterEach(() => {
+    TypeSystemPolicy.ExactOptionalPropertyTypes = false
+  })
+  // ---------------------------------------------------------------
+  // Number
+  // ---------------------------------------------------------------
+  it('Should not validate optional number', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.Number()),
+    })
+    Ok(T, {})
+    Ok(T, { x: 1 })
+    Fail(T, { x: undefined })
+  })
+  it('Should not validate undefined', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.Undefined()),
+    })
+    Ok(T, {})
+    Fail(T, { x: 1 })
+    Ok(T, { x: undefined })
+  })
+  it('Should validate optional number | undefined', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.Union([Type.Number(), Type.Undefined()])),
+    })
+    Ok(T, {})
+    Ok(T, { x: 1 })
+    Ok(T, { x: undefined })
+  })
+})
diff --git a/test/runtime/system/policy/index.ts b/test/runtime/system/policy/index.ts
new file mode 100644
index 000000000..29bf29666
--- /dev/null
+++ b/test/runtime/system/policy/index.ts
@@ -0,0 +1,4 @@
+import './allow-array-object'
+import './allow-nan'
+import './allow-null-void'
+import './exact-optional-property-types'
diff --git a/test/runtime/system/system.ts b/test/runtime/system/system.ts
deleted file mode 100644
index 9528e6dc8..000000000
--- a/test/runtime/system/system.ts
+++ /dev/null
@@ -1,205 +0,0 @@
-import { Ok, Fail } from '../compiler/validate'
-import { Assert } from '../assert/index'
-import { TypeSystem } from '@sinclair/typebox/system'
-import { Type } from '@sinclair/typebox'
-
-describe('system/TypeSystem/ExactOptionalPropertyTypes', () => {
-  before(() => {
-    TypeSystem.ExactOptionalPropertyTypes = true
-  })
-  after(() => {
-    TypeSystem.ExactOptionalPropertyTypes = false
-  })
-  // ---------------------------------------------------------------
-  // Number
-  // ---------------------------------------------------------------
-  it('Should not validate optional number', () => {
-    const T = Type.Object({
-      x: Type.Optional(Type.Number()),
-    })
-    Ok(T, {})
-    Ok(T, { x: 1 })
-    Fail(T, { x: undefined })
-  })
-  it('Should not validate undefined', () => {
-    const T = Type.Object({
-      x: Type.Optional(Type.Undefined()),
-    })
-    Ok(T, {})
-    Fail(T, { x: 1 })
-    Ok(T, { x: undefined })
-  })
-  it('Should validate optional number | undefined', () => {
-    const T = Type.Object({
-      x: Type.Optional(Type.Union([Type.Number(), Type.Undefined()])),
-    })
-    Ok(T, {})
-    Ok(T, { x: 1 })
-    Ok(T, { x: undefined })
-  })
-})
-describe('system/TypeSystem/AllowNaN', () => {
-  before(() => {
-    TypeSystem.AllowNaN = true
-  })
-  after(() => {
-    TypeSystem.AllowNaN = false
-  })
-  // ---------------------------------------------------------------
-  // Number
-  // ---------------------------------------------------------------
-  it('Should validate number with NaN', () => {
-    const T = Type.Number()
-    Ok(T, NaN)
-  })
-  it('Should validate number with +Infinity', () => {
-    const T = Type.Number()
-    Ok(T, Infinity)
-  })
-  it('Should validate number with -Infinity', () => {
-    const T = Type.Number()
-    Ok(T, -Infinity)
-  })
-  // ---------------------------------------------------------------
-  // Integer
-  //
-  // Note: The Number.isInteger() test will fail for NaN. Because
-  // of this we cannot reasonably override NaN handling for integers.
-  // ---------------------------------------------------------------
-  it('Should not validate integer with NaN', () => {
-    const T = Type.Integer()
-    Fail(T, NaN)
-  })
-  it('Should not validate integer with +Infinity', () => {
-    const T = Type.Integer()
-    Fail(T, Infinity)
-  })
-  it('Should not validate integer with -Infinity', () => {
-    const T = Type.Integer()
-    Fail(T, -Infinity)
-  })
-  // ---------------------------------------------------------------
-  // BigInt
-  //
-  // Note: We expect failures here as bigint isn't IEEE754
-  // ---------------------------------------------------------------
-  it('Should not validate bigint with NaN', () => {
-    const T = Type.BigInt()
-    Fail(T, NaN)
-  })
-  it('Should not validate bigint with +Infinity', () => {
-    const T = Type.BigInt()
-    Fail(T, Infinity)
-  })
-  it('Should not validate bigint with -Infinity', () => {
-    const T = Type.BigInt()
-    Fail(T, -Infinity)
-  })
-})
-describe('system/TypeSystem/AllowArrayObjects', () => {
-  before(() => {
-    TypeSystem.AllowArrayObjects = true
-  })
-  after(() => {
-    TypeSystem.AllowArrayObjects = false
-  })
-  // ---------------------------------------------------------------
-  // Object
-  // ---------------------------------------------------------------
-  it('Should validate arrays with empty objects', () => {
-    const T = Type.Object({})
-    Ok(T, [0, 1, 2])
-  })
-  it('Should validate arrays with objects with length property', () => {
-    const T = Type.Object({ length: Type.Number() })
-    Ok(T, [0, 1, 2])
-  })
-  it('Should validate arrays with objects with additionalProperties false when array has no elements', () => {
-    const T = Type.Object({ length: Type.Number() }, { additionalProperties: false })
-    Ok(T, [])
-  })
-  it('Should not validate arrays with objects with additionalProperties false when array has elements', () => {
-    const T = Type.Object({ length: Type.Number() }, { additionalProperties: false })
-    Fail(T, [0, 1, 2])
-  })
-  it('Should not validate arrays with objects when length property is string', () => {
-    const T = Type.Object({ length: Type.String() })
-    Fail(T, [0, 1, 2])
-  })
-  // ---------------------------------------------------------------
-  // Record
-  // ---------------------------------------------------------------
-  it('Should validate arrays as Records with String Keys', () => {
-    const T = Type.Record(Type.String(), Type.Number())
-    Ok(T, [0, 1, 2])
-  })
-  it('Should validate arrays as Records with Number Keys', () => {
-    const T = Type.Record(Type.Number(), Type.Number())
-    Ok(T, [0, 1, 2])
-  })
-  it('Should validate arrays as Records with Integer Keys', () => {
-    const T = Type.Record(Type.Integer(), Type.Number())
-    Ok(T, [0, 1, 2])
-  })
-  it('Should not validate arrays as Records with Object Values', () => {
-    const T = Type.Record(
-      Type.String(),
-      Type.Object({
-        x: Type.Number(),
-        y: Type.Number(),
-        z: Type.Number(),
-      }),
-    )
-    Ok(T, [
-      { x: 1, y: 1, z: 1 },
-      { x: 1, y: 1, z: 1 },
-      { x: 1, y: 1, z: 1 },
-    ])
-  })
-})
-describe('system/TypeSystem/AllowVoidNull', () => {
-  before(() => {
-    TypeSystem.AllowVoidNull = true
-  })
-  after(() => {
-    TypeSystem.AllowVoidNull = false
-  })
-  // ---------------------------------------------------------------
-  // Object
-  // ---------------------------------------------------------------
-  it('Should validate with null', () => {
-    const T = Type.Void()
-    Ok(T, null)
-  })
-})
-describe('system/TypeSystem/Format', () => {
-  it('Should create and validate a format', () => {
-    TypeSystem.Format('CreateFormat0', (value) => value === value.toLowerCase())
-    const T = Type.String({ format: 'CreateFormat0' })
-    Ok(T, 'action')
-    Fail(T, 'ACTION')
-  })
-  it('Should throw if registering the same format twice', () => {
-    TypeSystem.Format('CreateFormat1', (value) => true)
-    Assert.Throws(() => TypeSystem.Format('CreateFormat1', (value) => true))
-  })
-})
-describe('system/TypeSystem/Type', () => {
-  it('Should create and validate a type', () => {
-    type BigNumberOptions = { minimum?: bigint; maximum?: bigint }
-    const BigNumber = TypeSystem.Type<bigint, BigNumberOptions>('CreateType0', (options, value) => {
-      if (typeof value !== 'bigint') return false
-      if (options.maximum !== undefined && value > options.maximum) return false
-      if (options.minimum !== undefined && value < options.minimum) return false
-      return true
-    })
-    const T = BigNumber({ minimum: 10n, maximum: 20n })
-    Ok(T, 15n)
-    Fail(T, 5n)
-    Fail(T, 25n)
-  })
-  it('Should throw if registering the same type twice', () => {
-    TypeSystem.Type('CreateType1', () => true)
-    Assert.Throws(() => TypeSystem.Type('CreateType1', () => true))
-  })
-})
diff --git a/test/runtime/system/type/format.ts b/test/runtime/system/type/format.ts
new file mode 100644
index 000000000..bac7c9160
--- /dev/null
+++ b/test/runtime/system/type/format.ts
@@ -0,0 +1,19 @@
+import { Ok, Fail } from '../../compiler/validate'
+import { Assert } from '../../assert/index'
+import { TypeSystem } from '@sinclair/typebox/system'
+import { Type, FormatRegistry } from '@sinclair/typebox'
+
+describe('system/TypeSystem/Format', () => {
+  it('Should create and validate a format', () => {
+    const Foo = TypeSystem.Format('Foo', (value) => value === 'foo')
+    const T = Type.String({ format: Foo })
+    Ok(T, 'foo')
+    Fail(T, 'bar')
+    FormatRegistry.Delete('Foo')
+  })
+  it('Should throw if registering the same type twice', () => {
+    TypeSystem.Format('Foo', () => true)
+    Assert.Throws(() => TypeSystem.Format('Foo', () => true))
+    FormatRegistry.Delete('Foo')
+  })
+})
diff --git a/test/runtime/system/type/index.ts b/test/runtime/system/type/index.ts
new file mode 100644
index 000000000..1afccae94
--- /dev/null
+++ b/test/runtime/system/type/index.ts
@@ -0,0 +1,2 @@
+import './format'
+import './type'
diff --git a/test/runtime/system/type/type.ts b/test/runtime/system/type/type.ts
new file mode 100644
index 000000000..86288f595
--- /dev/null
+++ b/test/runtime/system/type/type.ts
@@ -0,0 +1,22 @@
+import { Ok, Fail } from '../../compiler/validate'
+import { TypeSystem } from '@sinclair/typebox/system'
+import { TypeRegistry } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('system/TypeSystem/Type', () => {
+  it('Should create and validate a type', () => {
+    const Foo = TypeSystem.Type<string>('Foo', (options, value) => {
+      Assert.IsEqual(options.option, 'test')
+      return value === 'foo'
+    })
+    const T = Foo({ option: 'test' })
+    Ok(T, 'foo')
+    Fail(T, 'bar')
+    TypeRegistry.Delete('Foo')
+  })
+  it('Should throw if registering the same type twice', () => {
+    TypeSystem.Type('Foo', () => true)
+    Assert.Throws(() => TypeSystem.Type('Foo', () => true))
+    TypeRegistry.Delete('Foo')
+  })
+})
diff --git a/test/runtime/type/guard/date.ts b/test/runtime/type/guard/date.ts
index 2571c324a..a9534a4ab 100644
--- a/test/runtime/type/guard/date.ts
+++ b/test/runtime/type/guard/date.ts
@@ -13,27 +13,32 @@ describe('type/guard/TDate', () => {
   })
   it('Should not guard for TDate with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TDate(Type.Number({ $id: 1 }))
+    const R = TypeGuard.TDate(Type.Date({ $id: 1 }))
     Assert.IsFalse(R)
   })
-  it('Should not guard for TDate with invalid minimum', () => {
+  it('Should not guard for TDate with invalid exclusiveMaximumTimestamp', () => {
     // @ts-ignore
-    const R = TypeGuard.TDate(Type.Number({ minimum: '1' }))
+    const R = TypeGuard.TDate(Type.Date({ exclusiveMaximumTimestamp: '1' }))
     Assert.IsFalse(R)
   })
-  it('Should not guard for TDate with invalid maximum', () => {
+  it('Should not guard for TDate with invalid exclusiveMinimumTimestamp', () => {
     // @ts-ignore
-    const R = TypeGuard.TDate(Type.Number({ maximum: '1' }))
+    const R = TypeGuard.TDate(Type.Date({ exclusiveMinimumTimestamp: '1' }))
     Assert.IsFalse(R)
   })
-  it('Should not guard for TDate with invalid exclusiveMinimum', () => {
+  it('Should not guard for TDate with invalid maximumTimestamp', () => {
     // @ts-ignore
-    const R = TypeGuard.TDate(Type.Number({ exclusiveMinimum: '1' }))
+    const R = TypeGuard.TDate(Type.Date({ maximumTimestamp: '1' }))
     Assert.IsFalse(R)
   })
-  it('Should not guard for TDate with invalid exclusiveMaximum', () => {
+  it('Should not guard for TDate with invalid minimumTimestamp', () => {
     // @ts-ignore
-    const R = TypeGuard.TDate(Type.Number({ exclusiveMaximum: '1' }))
+    const R = TypeGuard.TDate(Type.Date({ minimumTimestamp: '1' }))
+    Assert.IsFalse(R)
+  })
+  it('Should not guard for TDate with invalid multipleOfTimestamp', () => {
+    // @ts-ignore
+    const R = TypeGuard.TDate(Type.Date({ multipleOfTimestamp: '1' }))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/index.ts b/test/runtime/type/guard/index.ts
index c1cb4c70d..534c10f17 100644
--- a/test/runtime/type/guard/index.ts
+++ b/test/runtime/type/guard/index.ts
@@ -28,6 +28,7 @@ import './partial'
 import './pick'
 import './promise'
 import './record'
+import './recursive'
 import './ref'
 import './required'
 import './rest'
diff --git a/test/runtime/type/guard/intersect.ts b/test/runtime/type/guard/intersect.ts
index 5cf94db7a..25c069c7b 100644
--- a/test/runtime/type/guard/intersect.ts
+++ b/test/runtime/type/guard/intersect.ts
@@ -2,7 +2,7 @@ import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/guard/TUnion', () => {
+describe('type/guard/TIntersect', () => {
   it('Should guard for TIntersect', () => {
     const R = TypeGuard.TIntersect(
       Type.Intersect([
@@ -29,4 +29,11 @@ describe('type/guard/TUnion', () => {
     )
     Assert.IsFalse(R)
   })
+  it('Should throw for intersected transform types', () => {
+    const N = Type.Transform(Type.Number())
+      .Decode((value) => value)
+      .Encode((value) => value)
+
+    Assert.Throws(() => Type.Intersect([N, N]))
+  })
 })
diff --git a/test/runtime/type/guard/omit.ts b/test/runtime/type/guard/omit.ts
index b7d52a17f..1ceb07b1e 100644
--- a/test/runtime/type/guard/omit.ts
+++ b/test/runtime/type/guard/omit.ts
@@ -1,5 +1,4 @@
-import { TypeGuard } from '@sinclair/typebox'
-import { Type, Kind } from '@sinclair/typebox'
+import { TypeGuard, Type, Kind, Transform } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/TOmit', () => {
@@ -103,4 +102,18 @@ describe('type/guard/TOmit', () => {
     Assert.IsTrue(TypeGuard.TNumber(T.properties.ad))
     Assert.IsEqual(T.required, ['ad'])
   })
+  it('Should discard transform', () => {
+    const S = Type.Transform(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.String(),
+      }),
+      {
+        Decode: (value) => value,
+        Encode: (value) => value,
+      },
+    )
+    const T = Type.Omit(S, ['x'])
+    Assert.IsFalse(Transform in T)
+  })
 })
diff --git a/test/runtime/type/guard/partial.ts b/test/runtime/type/guard/partial.ts
index f7f996d59..8cb963bde 100644
--- a/test/runtime/type/guard/partial.ts
+++ b/test/runtime/type/guard/partial.ts
@@ -1,4 +1,4 @@
-import { TypeGuard, TypeRegistry, Type, Kind } from '@sinclair/typebox'
+import { TypeGuard, TypeRegistry, Type, Kind, Transform } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/TPartial', () => {
@@ -40,4 +40,18 @@ describe('type/guard/TPartial', () => {
     Assert.IsEqual(T.anyOf[0].required, undefined)
     Assert.IsEqual(T.anyOf[1].required, undefined)
   })
+  it('Should discard transform', () => {
+    const S = Type.Transform(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.String(),
+      }),
+      {
+        Decode: (value) => value,
+        Encode: (value) => value,
+      },
+    )
+    const T = Type.Partial(S)
+    Assert.IsFalse(Transform in T)
+  })
 })
diff --git a/test/runtime/type/guard/pick.ts b/test/runtime/type/guard/pick.ts
index 029160552..b25094ad5 100644
--- a/test/runtime/type/guard/pick.ts
+++ b/test/runtime/type/guard/pick.ts
@@ -1,5 +1,4 @@
-import { TypeGuard } from '@sinclair/typebox'
-import { Type, Kind } from '@sinclair/typebox'
+import { TypeGuard, Type, Kind, Transform } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/TPick', () => {
@@ -105,4 +104,18 @@ describe('type/guard/TPick', () => {
     Assert.IsTrue(TypeGuard.TNumber(T.properties.ac))
     Assert.IsEqual(T.required, ['ab', 'ac'])
   })
+  it('Should discard transform', () => {
+    const S = Type.Transform(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.String(),
+      }),
+      {
+        Decode: (value) => value,
+        Encode: (value) => value,
+      },
+    )
+    const T = Type.Pick(S, ['x'])
+    Assert.IsFalse(Transform in T)
+  })
 })
diff --git a/test/runtime/type/guard/record.ts b/test/runtime/type/guard/record.ts
index 2703dd85d..6855175fa 100644
--- a/test/runtime/type/guard/record.ts
+++ b/test/runtime/type/guard/record.ts
@@ -21,15 +21,21 @@ describe('type/guard/TRecord', () => {
   })
   it('Should guard overload 3', () => {
     // @ts-ignore
-    Assert.Throws(() => Type.Record(Type.Union([]), Type.String(), { extra: 1 }))
+    const T = Type.Record(Type.Union([]), Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.TNever(T))
   })
   it('Should guard overload 4', () => {
+    // @ts-ignore
+    const T = Type.Record(Type.BigInt(), Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.TNever(T))
+  })
+  it('Should guard overload 5', () => {
     const T = Type.Record(Type.Literal('A'), Type.String(), { extra: 1 })
     Assert.IsTrue(TypeGuard.TObject(T))
     Assert.IsTrue(TypeGuard.TString(T.properties.A))
     Assert.IsEqual(T.extra, 1)
   })
-  it('Should guard overload 5', () => {
+  it('Should guard overload 6', () => {
     const L = Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal('A'), Type.Literal('B')])])
     const T = Type.Record(L, Type.String(), { extra: 1 })
     Assert.IsTrue(TypeGuard.TObject(T))
@@ -37,32 +43,32 @@ describe('type/guard/TRecord', () => {
     Assert.IsTrue(TypeGuard.TString(T.properties.helloB))
     Assert.IsEqual(T.extra, 1)
   })
-  it('Should guard overload 6', () => {
+  it('Should guard overload 7', () => {
     const T = Type.Record(Type.Number(), Type.String(), { extra: 1 })
     Assert.IsTrue(TypeGuard.TRecord(T))
     Assert.IsTrue(TypeGuard.TString(T.patternProperties[PatternNumberExact]))
     Assert.IsEqual(T.extra, 1)
   })
-  it('Should guard overload 7', () => {
+  it('Should guard overload 8', () => {
     const T = Type.Record(Type.Integer(), Type.String(), { extra: 1 })
     Assert.IsTrue(TypeGuard.TRecord(T))
     Assert.IsTrue(TypeGuard.TString(T.patternProperties[PatternNumberExact]))
     Assert.IsEqual(T.extra, 1)
   })
-  it('Should guard overload 8', () => {
+  it('Should guard overload 9', () => {
     const T = Type.Record(Type.String(), Type.String(), { extra: 1 })
     Assert.IsTrue(TypeGuard.TRecord(T))
     Assert.IsTrue(TypeGuard.TString(T.patternProperties[PatternStringExact]))
     Assert.IsEqual(T.extra, 1)
   })
-  it('Should guard overload 9', () => {
+  it('Should guard overload 10', () => {
     const L = Type.TemplateLiteral([Type.String(), Type.Literal('_foo')])
     const T = Type.Record(L, Type.String(), { extra: 1 })
     Assert.IsTrue(TypeGuard.TRecord(T))
     Assert.IsTrue(TypeGuard.TString(T.patternProperties[`^${PatternString}_foo$`]))
     Assert.IsEqual(T.extra, 1)
   })
-  it('Should guard overload 10', () => {
+  it('Should guard overload 11', () => {
     const L = Type.Union([Type.Literal('A'), Type.Union([Type.Literal('B'), Type.Literal('C')])])
     const T = Type.Record(L, Type.String())
     Assert.IsTrue(TypeGuard.TObject(T))
@@ -110,12 +116,12 @@ describe('type/guard/TRecord', () => {
     )
     Assert.IsFalse(R)
   })
-  it('Transform: Should should transform to TObject for single literal union value', () => {
+  it('Normalize: Should should normalize to TObject for single literal union value', () => {
     const K = Type.Union([Type.Literal('ok')])
     const R = TypeGuard.TObject(Type.Record(K, Type.Number()))
     Assert.IsTrue(R)
   })
-  it('Transform: Should should transform to TObject for multi literal union value', () => {
+  it('Normalize: Should should normalize to TObject for multi literal union value', () => {
     const K = Type.Union([Type.Literal('A'), Type.Literal('B')])
     const R = TypeGuard.TObject(Type.Record(K, Type.Number()))
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/recursive.ts b/test/runtime/type/guard/recursive.ts
new file mode 100644
index 000000000..8585e17b1
--- /dev/null
+++ b/test/runtime/type/guard/recursive.ts
@@ -0,0 +1,16 @@
+import { TypeGuard, PatternNumberExact, PatternStringExact, PatternString, PatternNumber } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TRecursive', () => {
+  it('Should guard 1', () => {
+    const T = Type.Recursive((This) => Type.Object({ nodes: This }))
+    Assert.IsTrue(TypeGuard.TRecursive(T))
+    Assert.IsTrue(TypeGuard.TObject(T))
+  })
+  it('Should guard 2', () => {
+    const T = Type.Recursive((This) => Type.Tuple([This]))
+    Assert.IsTrue(TypeGuard.TRecursive(T))
+    Assert.IsTrue(TypeGuard.TTuple(T))
+  })
+})
diff --git a/test/runtime/type/guard/required.ts b/test/runtime/type/guard/required.ts
index 4090a91fa..67c0b3858 100644
--- a/test/runtime/type/guard/required.ts
+++ b/test/runtime/type/guard/required.ts
@@ -1,4 +1,4 @@
-import { TypeGuard, TypeRegistry, Type, Kind } from '@sinclair/typebox'
+import { TypeGuard, TypeRegistry, Type, Kind, Transform } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/TRequired', () => {
@@ -37,4 +37,18 @@ describe('type/guard/TRequired', () => {
     Assert.IsEqual(T.anyOf[0].required, ['x'])
     Assert.IsEqual(T.anyOf[1].required, ['y'])
   })
+  it('Should discard transform', () => {
+    const S = Type.Transform(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.String(),
+      }),
+      {
+        Decode: (value) => value,
+        Encode: (value) => value,
+      },
+    )
+    const T = Type.Required(S)
+    Assert.IsFalse(Transform in T)
+  })
 })
diff --git a/test/runtime/type/guard/rest.ts b/test/runtime/type/guard/rest.ts
index c911da85c..4c22803d5 100644
--- a/test/runtime/type/guard/rest.ts
+++ b/test/runtime/type/guard/rest.ts
@@ -1,22 +1,59 @@
-import { TypeGuard } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, TypeGuard } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/TRest', () => {
-  it('Should guard Rest 1', () => {
-    const T = Type.Tuple([Type.String(), Type.Number()])
-    const R = Type.Rest(T)
-    Assert.IsTrue(TypeGuard.TString(R[0]))
-    Assert.IsTrue(TypeGuard.TNumber(R[1]))
+  it('Should guard 1', () => {
+    // union never
+    const A = Type.String()
+    const B = Type.Union(Type.Rest(A))
+    Assert.IsTrue(TypeGuard.TNever(B))
   })
-  it('Should guard Rest 2', () => {
-    const T = Type.Tuple([])
-    const R = Type.Rest(T)
-    Assert.IsEqual(R.length, 0)
+  it('Should guard 2', () => {
+    // intersect never
+    const A = Type.String()
+    const B = Type.Intersect(Type.Rest(A))
+    Assert.IsTrue(TypeGuard.TNever(B))
   })
-  it('Should guard Rest 3', () => {
-    const T = Type.String()
-    const R = Type.Rest(T)
-    Assert.IsTrue(TypeGuard.TString(R[0]))
+  it('Should guard 3', () => {
+    // tuple
+    const A = Type.Tuple([Type.Number(), Type.String()])
+    const B = Type.Union(Type.Rest(A))
+    Assert.IsTrue(TypeGuard.TUnion(B))
+    Assert.IsEqual(B.anyOf.length, 2)
+    Assert.IsTrue(TypeGuard.TNumber(B.anyOf[0]))
+    Assert.IsTrue(TypeGuard.TString(B.anyOf[1]))
+  })
+  it('Should guard 4', () => {
+    // tuple spread
+    const A = Type.Tuple([Type.Literal(1), Type.Literal(2)])
+    const B = Type.Tuple([Type.Literal(3), Type.Literal(4)])
+    const C = Type.Tuple([...Type.Rest(A), ...Type.Rest(B)])
+    Assert.IsTrue(TypeGuard.TTuple(C))
+    Assert.IsEqual(C.items!.length, 4)
+    Assert.IsEqual(C.items![0].const, 1)
+    Assert.IsEqual(C.items![1].const, 2)
+    Assert.IsEqual(C.items![2].const, 3)
+    Assert.IsEqual(C.items![3].const, 4)
+  })
+  it('Should guard 5', () => {
+    // union to intersect
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.String() })
+    const C = Type.Union([A, B])
+    const D = Type.Intersect(Type.Rest(C))
+    Assert.IsTrue(TypeGuard.TIntersect(D))
+    Assert.IsEqual(D.allOf.length, 2)
+    Assert.IsTrue(TypeGuard.TObject(D.allOf[0]))
+    Assert.IsTrue(TypeGuard.TObject(D.allOf[1]))
+  })
+  it('Should guard 6', () => {
+    // intersect to composite
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.String() })
+    const C = Type.Intersect([A, B])
+    const D = Type.Composite(Type.Rest(C))
+    Assert.IsTrue(TypeGuard.TObject(D))
+    Assert.IsTrue(TypeGuard.TNumber(D.properties.x))
+    Assert.IsTrue(TypeGuard.TString(D.properties.y))
   })
 })
diff --git a/test/runtime/type/intrinsic/intrinsic.ts b/test/runtime/type/intrinsic/intrinsic.ts
index 966f0df50..3ff191aee 100644
--- a/test/runtime/type/intrinsic/intrinsic.ts
+++ b/test/runtime/type/intrinsic/intrinsic.ts
@@ -2,7 +2,7 @@ import { TypeGuard, Intrinsic } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/intrinsic/IntrinsicString', () => {
+describe('type/intrinsic/Map', () => {
   // ----------------------------------------------------
   // Passthrough
   // ----------------------------------------------------
@@ -139,19 +139,16 @@ describe('type/intrinsic/IntrinsicString', () => {
     const T = Intrinsic.Map(Type.TemplateLiteral('HELLO${string}WORLD'), 'Lowercase')
     Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^hello(.*)world$')
-    console.log(T.pattern)
   })
   it('Should map template literal patterns 2', () => {
     const T = Intrinsic.Map(Type.TemplateLiteral('HELLO${number}WORLD'), 'Lowercase')
     Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^hello(0|[1-9][0-9]*)world$')
-    console.log(T.pattern)
   })
   it('Should map template literal patterns 3', () => {
     const T = Intrinsic.Map(Type.TemplateLiteral('${number}${string}'), 'Lowercase')
     Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(0|[1-9][0-9]*)(.*)$')
-    console.log(T.pattern)
   })
   it('Should map template literal patterns 3', () => {
     const T = Intrinsic.Map(Type.TemplateLiteral('${number}HELLO${string}'), 'Lowercase')
diff --git a/test/runtime/type/normalize/exclude.ts b/test/runtime/type/normalize/exclude.ts
index 299309d93..908f16145 100644
--- a/test/runtime/type/normalize/exclude.ts
+++ b/test/runtime/type/normalize/exclude.ts
@@ -2,7 +2,7 @@ import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/normal/Exclude', () => {
+describe('type/normalize/Exclude', () => {
   it('Normalize 1', () => {
     const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
     const R = TypeGuard.TUnion(T)
diff --git a/test/runtime/type/normalize/extract.ts b/test/runtime/type/normalize/extract.ts
index 3e9c6f7e0..e1dc98195 100644
--- a/test/runtime/type/normalize/extract.ts
+++ b/test/runtime/type/normalize/extract.ts
@@ -2,7 +2,7 @@ import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/normal/Extract', () => {
+describe('type/normalize/Extract', () => {
   it('Normalize 1', () => {
     const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Number()]))
     const R = TypeGuard.TUnion(T)
diff --git a/test/runtime/type/normalize/indexed.ts b/test/runtime/type/normalize/indexed.ts
index 8e726db80..c149c66ae 100644
--- a/test/runtime/type/normalize/indexed.ts
+++ b/test/runtime/type/normalize/indexed.ts
@@ -2,7 +2,7 @@ import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/normal/Index', () => {
+describe('type/normalize/Index', () => {
   // ---------------------------------------------------------
   // Array
   // ---------------------------------------------------------
diff --git a/test/runtime/type/normalize/intersect.ts b/test/runtime/type/normalize/intersect.ts
index 3d449ad25..34837db79 100644
--- a/test/runtime/type/normalize/intersect.ts
+++ b/test/runtime/type/normalize/intersect.ts
@@ -2,7 +2,7 @@ import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/normal/Intersect', () => {
+describe('type/normalize/Intersect', () => {
   it('Normalize 1', () => {
     const T = Type.Intersect([Type.Number(), Type.String()])
     const R = TypeGuard.TIntersect(T)
diff --git a/test/runtime/type/normalize/record.ts b/test/runtime/type/normalize/record.ts
index f7ad9334b..9f419429d 100644
--- a/test/runtime/type/normalize/record.ts
+++ b/test/runtime/type/normalize/record.ts
@@ -2,7 +2,7 @@ import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/normal/Record', () => {
+describe('type/normalize/Record', () => {
   it('Normalize 1', () => {
     const K = Type.Union([Type.Literal('A'), Type.Literal('B')])
     const T = Type.Record(K, Type.String())
diff --git a/test/runtime/type/normalize/union.ts b/test/runtime/type/normalize/union.ts
index 12e056fad..3c5d468a4 100644
--- a/test/runtime/type/normalize/union.ts
+++ b/test/runtime/type/normalize/union.ts
@@ -2,7 +2,7 @@ import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/normal/Union', () => {
+describe('type/normalize/Union', () => {
   it('Normalize 1', () => {
     const T = Type.Union([Type.Number(), Type.String()])
     const R = TypeGuard.TUnion(T)
diff --git a/test/runtime/type/registry/format.ts b/test/runtime/type/registry/format.ts
index ffa3d4c78..812a3de6f 100644
--- a/test/runtime/type/registry/format.ts
+++ b/test/runtime/type/registry/format.ts
@@ -1,7 +1,7 @@
 import { FormatRegistry } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/FormatRegistry', () => {
+describe('type/registry/Format', () => {
   it('Should set format', () => {
     FormatRegistry.Set('test#format1', () => true)
   })
diff --git a/test/runtime/type/registry/type.ts b/test/runtime/type/registry/type.ts
index 60151ec9a..b36d2a8d4 100644
--- a/test/runtime/type/registry/type.ts
+++ b/test/runtime/type/registry/type.ts
@@ -1,7 +1,7 @@
 import { TypeRegistry } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/TypeRegistry', () => {
+describe('type/registry/Type', () => {
   it('Should set type', () => {
     TypeRegistry.Set('test#type1', () => true)
   })
diff --git a/test/runtime/type/template/finite.ts b/test/runtime/type/template/finite.ts
index 0df00de7d..53028dff9 100644
--- a/test/runtime/type/template/finite.ts
+++ b/test/runtime/type/template/finite.ts
@@ -1,7 +1,7 @@
 import { PatternString, PatternBoolean, PatternNumber, TemplateLiteralParser, TemplateLiteralFinite } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/TemplateLiteralFinite', () => {
+describe('type/templateliteral/TemplateLiteralFinite', () => {
   // ---------------------------------------------------------------
   // Finite
   // ---------------------------------------------------------------
diff --git a/test/runtime/type/template/generate.ts b/test/runtime/type/template/generate.ts
index eef3b8101..73aa9cfc3 100644
--- a/test/runtime/type/template/generate.ts
+++ b/test/runtime/type/template/generate.ts
@@ -1,7 +1,7 @@
 import { TemplateLiteralParser, TemplateLiteralGenerator } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/TemplateLiteralGenerator', () => {
+describe('type/templateliteral/TemplateLiteralGenerator', () => {
   // ---------------------------------------------------------------
   // Exact (No Default Unwrap)
   // ---------------------------------------------------------------
diff --git a/test/runtime/type/template/parser.ts b/test/runtime/type/template/parser.ts
index 1ed72176e..5ab50afbf 100644
--- a/test/runtime/type/template/parser.ts
+++ b/test/runtime/type/template/parser.ts
@@ -1,7 +1,7 @@
 import { TemplateLiteralParser } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/TemplateLiteralParser', () => {
+describe('type/templateliteral/TemplateLiteralParser', () => {
   // ---------------------------------------------------------------
   // Throws
   // ---------------------------------------------------------------
diff --git a/test/runtime/type/template/pattern.ts b/test/runtime/type/template/pattern.ts
index 68d30330a..6fdf85ca7 100644
--- a/test/runtime/type/template/pattern.ts
+++ b/test/runtime/type/template/pattern.ts
@@ -1,7 +1,7 @@
 import { Type, TTemplateLiteral, PatternNumber, PatternString, PatternBoolean } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/TemplateLiteralPattern', () => {
+describe('type/templateliteral/TemplateLiteralPattern', () => {
   const Equal = (template: TTemplateLiteral, expect: string) => {
     const pattern = template.pattern.slice(1, template.pattern.length - 1)
     Assert.IsEqual(pattern, expect)
diff --git a/test/runtime/value/cast/regexp.ts b/test/runtime/value/cast/regexp.ts
index 4bfc94c62..6b4e05950 100644
--- a/test/runtime/value/cast/regexp.ts
+++ b/test/runtime/value/cast/regexp.ts
@@ -2,7 +2,7 @@ import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('value/cast/RegEx', () => {
+describe('value/cast/RegExp', () => {
   const T = Type.RegExp(/foo/, { default: 'foo' })
   const E = 'foo'
   it('Should upcast from string', () => {
diff --git a/test/runtime/value/cast/void.ts b/test/runtime/value/cast/void.ts
index 41adb69e2..3a0dd6f4f 100644
--- a/test/runtime/value/cast/void.ts
+++ b/test/runtime/value/cast/void.ts
@@ -4,7 +4,7 @@ import { Assert } from '../../assert/index'
 
 describe('value/cast/Void', () => {
   const T = Type.Void()
-  const E = null
+  const E = undefined
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
@@ -46,8 +46,8 @@ describe('value/cast/Void', () => {
     Assert.IsEqual(result, E)
   })
   it('Should preserve', () => {
-    const value = null
+    const value = undefined
     const result = Value.Cast(T, value)
-    Assert.IsEqual(result, null)
+    Assert.IsEqual(result, undefined)
   })
 })
diff --git a/test/runtime/value/check/date.ts b/test/runtime/value/check/date.ts
index 800c764b4..fd3cca859 100644
--- a/test/runtime/value/check/date.ts
+++ b/test/runtime/value/check/date.ts
@@ -7,46 +7,81 @@ describe('value/check/Date', () => {
   it('Should fail string', () => {
     const value = 'hello'
     const result = Value.Check(T, value)
-    Assert.IsEqual(result, false)
+    Assert.IsFalse(result)
   })
   it('Should fail number', () => {
     const value = 1
     const result = Value.Check(T, value)
-    Assert.IsEqual(result, false)
+    Assert.IsFalse(result)
   })
   it('Should fail boolean', () => {
     const value = true
     const result = Value.Check(T, value)
-    Assert.IsEqual(result, false)
+    Assert.IsFalse(result)
   })
   it('Should fail null', () => {
     const value = null
     const result = Value.Check(T, value)
-    Assert.IsEqual(result, false)
+    Assert.IsFalse(result)
   })
   it('Should fail undefined', () => {
     const value = undefined
     const result = Value.Check(T, value)
-    Assert.IsEqual(result, false)
+    Assert.IsFalse(result)
   })
   it('Should fail object', () => {
     const value = { a: 1 }
     const result = Value.Check(T, value)
-    Assert.IsEqual(result, false)
+    Assert.IsFalse(result)
   })
   it('Should fail array', () => {
     const value = [1, 2]
     const result = Value.Check(T, value)
-    Assert.IsEqual(result, false)
+    Assert.IsFalse(result)
   })
   it('Should pass Date', () => {
     const value = new Date()
     const result = Value.Check(T, value)
-    Assert.IsEqual(result, true)
+    Assert.IsTrue(result)
   })
   it('Should not validate Date if is invalid', () => {
     const value = new Date('not-a-valid-date')
     const result = Value.Check(T, value)
-    Assert.IsEqual(result, false)
+    Assert.IsFalse(result)
+  })
+  it('Should validate Date minimumTimestamp', () => {
+    const T = Type.Date({ minimumTimestamp: 10 })
+    const R1 = Value.Check(T, new Date(9))
+    const R2 = Value.Check(T, new Date(10))
+    Assert.IsFalse(R1)
+    Assert.IsTrue(R2)
+  })
+  it('Should validate Date maximumTimestamp', () => {
+    const T = Type.Date({ maximumTimestamp: 10 })
+    const R1 = Value.Check(T, new Date(11))
+    const R2 = Value.Check(T, new Date(10))
+    Assert.IsFalse(R1)
+    Assert.IsTrue(R2)
+  })
+  it('Should validate Date exclusiveMinimumTimestamp', () => {
+    const T = Type.Date({ exclusiveMinimumTimestamp: 10 })
+    const R1 = Value.Check(T, new Date(10))
+    const R2 = Value.Check(T, new Date(11))
+    Assert.IsFalse(R1)
+    Assert.IsTrue(R2)
+  })
+  it('Should validate Date exclusiveMaximumTimestamp', () => {
+    const T = Type.Date({ exclusiveMaximumTimestamp: 10 })
+    const R1 = Value.Check(T, new Date(10))
+    const R2 = Value.Check(T, new Date(9))
+    Assert.IsFalse(R1)
+    Assert.IsTrue(R2)
+  })
+  it('Should validate Date multipleOfTimestamp', () => {
+    const T = Type.Date({ multipleOfTimestamp: 2 })
+    const R1 = Value.Check(T, new Date(1))
+    const R2 = Value.Check(T, new Date(2))
+    Assert.IsFalse(R1)
+    Assert.IsTrue(R2)
   })
 })
diff --git a/test/runtime/value/convert/async-iterator.ts b/test/runtime/value/convert/async-iterator.ts
index 2429faf93..bec76a3d7 100644
--- a/test/runtime/value/convert/async-iterator.ts
+++ b/test/runtime/value/convert/async-iterator.ts
@@ -2,9 +2,6 @@ import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-// --------------------------------------------------------
-// non-convertable pass through
-// --------------------------------------------------------
 describe('value/convert/AsyncIterator', () => {
   const T = Type.AsyncIterator(Type.Any())
   it('Should passthrough 1', () => {
diff --git a/test/runtime/value/convert/constructor.ts b/test/runtime/value/convert/constructor.ts
index f1769c245..dabd0a2fb 100644
--- a/test/runtime/value/convert/constructor.ts
+++ b/test/runtime/value/convert/constructor.ts
@@ -2,13 +2,10 @@ import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-// --------------------------------------------------------
-// non-convertable pass through
-// --------------------------------------------------------
 describe('value/convert/Constructor', () => {
   const T = Type.Constructor([], Type.Any())
   it('Should passthrough 1', () => {
-    const V = function () {}
+    const V = class {}
     const R = Value.Convert(T, V)
     Assert.IsEqual(R, V)
   })
diff --git a/test/runtime/value/convert/function.ts b/test/runtime/value/convert/function.ts
index 004aaa6be..74e72dd7f 100644
--- a/test/runtime/value/convert/function.ts
+++ b/test/runtime/value/convert/function.ts
@@ -2,9 +2,6 @@ import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-// --------------------------------------------------------
-// non-convertable pass through
-// --------------------------------------------------------
 describe('value/convert/Function', () => {
   const T = Type.Function([], Type.Any())
   it('Should passthrough 1', () => {
diff --git a/test/runtime/value/convert/integer.ts b/test/runtime/value/convert/integer.ts
index 1cecc93eb..8f17ff4c1 100644
--- a/test/runtime/value/convert/integer.ts
+++ b/test/runtime/value/convert/integer.ts
@@ -44,7 +44,7 @@ describe('value/convert/Integer', () => {
   it('Should convert string #3', () => {
     const value = '-0'
     const result = Value.Convert(Type.Integer(), value)
-    Assert.IsEqual(result, 0)
+    Assert.IsEqual(result, -0)
   })
   it('Should convert string #4', () => {
     const value = '-100'
diff --git a/test/runtime/value/convert/iterator.ts b/test/runtime/value/convert/iterator.ts
index f9045d664..1dbf33702 100644
--- a/test/runtime/value/convert/iterator.ts
+++ b/test/runtime/value/convert/iterator.ts
@@ -2,9 +2,6 @@ import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-// --------------------------------------------------------
-// non-convertable pass through
-// --------------------------------------------------------
 describe('value/convert/Iterator', () => {
   const T = Type.Iterator(Type.Any())
   it('Should passthrough 1', () => {
diff --git a/test/runtime/value/convert/literal.ts b/test/runtime/value/convert/literal.ts
index f161b1720..c85ac2441 100644
--- a/test/runtime/value/convert/literal.ts
+++ b/test/runtime/value/convert/literal.ts
@@ -2,7 +2,7 @@ import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('value/convert/Literal:String', () => {
+describe('value/convert/LiteralString', () => {
   it('Should convert from number 1', () => {
     const T = Type.Literal('1')
     const R = Value.Convert(T, 1)
@@ -19,7 +19,7 @@ describe('value/convert/Literal:String', () => {
     Assert.IsEqual(R, 'true')
   })
 })
-describe('value/convert/Literal:Number', () => {
+describe('value/convert/LiteralNumber', () => {
   it('Should convert from number 1', () => {
     const T = Type.Literal(3.14)
     const R = Value.Convert(T, '3.14')
@@ -46,7 +46,7 @@ describe('value/convert/Literal:Number', () => {
     Assert.IsEqual(R, true)
   })
 })
-describe('value/convert/Literal:Boolean', () => {
+describe('value/convert/LiteralBoolean', () => {
   it('Should convert from number 1', () => {
     const T = Type.Literal(true)
     const R = Value.Convert(T, 3.14)
diff --git a/test/runtime/value/convert/number.ts b/test/runtime/value/convert/number.ts
index 1f1f62c4d..8c151db12 100644
--- a/test/runtime/value/convert/number.ts
+++ b/test/runtime/value/convert/number.ts
@@ -40,7 +40,7 @@ describe('value/convert/Number', () => {
   it('Should convert string #3', () => {
     const value = '-0'
     const result = Value.Convert(Type.Number(), value)
-    Assert.IsEqual(result, 0)
+    Assert.IsEqual(result, -0)
   })
   it('Should convert string #4', () => {
     const value = '-100'
diff --git a/test/runtime/value/convert/promise.ts b/test/runtime/value/convert/promise.ts
index 254301489..9d0439277 100644
--- a/test/runtime/value/convert/promise.ts
+++ b/test/runtime/value/convert/promise.ts
@@ -2,15 +2,11 @@ import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-// --------------------------------------------------------
-// non-convertable pass through
-// --------------------------------------------------------
 describe('value/convert/Promise', () => {
   const T = Type.Promise(Type.Any())
-  it('Should pass-through 1', () => {
+  it('Should passthrough 1', () => {
     const V = Promise.resolve(1)
     const R = Value.Convert(T, V)
-    console.log(R)
     Assert.IsEqual(R, V)
   })
   it('Should passthrough 2', () => {
diff --git a/test/runtime/value/convert/record.ts b/test/runtime/value/convert/record.ts
index 961684000..90c24f440 100644
--- a/test/runtime/value/convert/record.ts
+++ b/test/runtime/value/convert/record.ts
@@ -6,6 +6,6 @@ describe('value/convert/Record', () => {
   it('Should convert record value to numeric', () => {
     const T = Type.Record(Type.String(), Type.Number())
     const V = Value.Convert(T, { x: '42', y: '24', z: 'hello' })
-    Assert.IsEqual(V, { x: 42, y: '24', z: 'hello' })
+    Assert.IsEqual(V, { x: 42, y: 24, z: 'hello' })
   })
 })
diff --git a/test/runtime/value/convert/regexp.ts b/test/runtime/value/convert/regexp.ts
index 8f4efad92..c2282b47b 100644
--- a/test/runtime/value/convert/regexp.ts
+++ b/test/runtime/value/convert/regexp.ts
@@ -2,6 +2,6 @@ import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('value/convert/RegEx', () => {
+describe('value/convert/RegExp', () => {
   it('Should convert', () => {})
 })
diff --git a/test/runtime/value/convert/symbol.ts b/test/runtime/value/convert/symbol.ts
index ce453f6a9..6ef559da2 100644
--- a/test/runtime/value/convert/symbol.ts
+++ b/test/runtime/value/convert/symbol.ts
@@ -5,11 +5,11 @@ import { Assert } from '../../assert/index'
 describe('value/convert/Symbol', () => {
   const T = Type.Symbol()
   it('Should convert from number 1', () => {
-    const R = Value.Convert(T, 3.14)
-    Assert.IsEqual(R, '3.14')
+    const R = Value.Convert(T, 3.14) as Symbol
+    Assert.IsEqual(R.description, '3.14')
   })
   it('Should convert from number 2', () => {
-    const R = Value.Convert(T, 3)
-    Assert.IsEqual(R, '3')
+    const R = Value.Convert(T, 3) as Symbol
+    Assert.IsEqual(R.description, '3')
   })
 })
diff --git a/test/runtime/value/convert/tuple.ts b/test/runtime/value/convert/tuple.ts
index 366ef8838..663caf0f8 100644
--- a/test/runtime/value/convert/tuple.ts
+++ b/test/runtime/value/convert/tuple.ts
@@ -6,7 +6,7 @@ describe('value/convert/Tuple', () => {
   it('Should convert from Array 1', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
     const R = Value.Convert(T, ['1', 'true'])
-    Assert.IsEqual(R, [1, true])
+    Assert.IsEqual(R, [1, 1])
   })
   it('Should convert from Array 2', () => {
     const T = Type.Tuple([Type.Number(), Type.Number()])
diff --git a/test/runtime/value/create/array.ts b/test/runtime/value/create/array.ts
index 34377a245..ae042f8ce 100644
--- a/test/runtime/value/create/array.ts
+++ b/test/runtime/value/create/array.ts
@@ -2,7 +2,7 @@ import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('value/create/Any', () => {
+describe('value/create/Array', () => {
   it('Should create value', () => {
     const T = Type.Array(Type.String())
     Assert.IsEqual(Value.Create(T), [])
diff --git a/test/runtime/value/create/string.ts b/test/runtime/value/create/string.ts
index 83ebe90f4..222f03180 100644
--- a/test/runtime/value/create/string.ts
+++ b/test/runtime/value/create/string.ts
@@ -5,7 +5,7 @@ import { Assert } from '../../assert/index'
 describe('value/create/String', () => {
   it('Should create value', () => {
     const T = Type.String()
-    Assert.IsEqual(Value.Create(T), 0)
+    Assert.IsEqual(Value.Create(T), '')
   })
   it('Should create default', () => {
     const T = Type.String({ default: 'hello' })
diff --git a/test/runtime/value/create/void.ts b/test/runtime/value/create/void.ts
index eb32ae1b9..1bef38828 100644
--- a/test/runtime/value/create/void.ts
+++ b/test/runtime/value/create/void.ts
@@ -5,7 +5,7 @@ import { Assert } from '../../assert/index'
 describe('value/create/Void', () => {
   it('Should create value', () => {
     const T = Type.Void()
-    Assert.IsEqual(Value.Create(T), null)
+    Assert.IsEqual(Value.Create(T), undefined)
   })
   it('Should create value from default value', () => {
     const T = Type.Void({ default: 'hello' })
diff --git a/test/runtime/value/index.ts b/test/runtime/value/index.ts
index e318d92b4..de126d75d 100644
--- a/test/runtime/value/index.ts
+++ b/test/runtime/value/index.ts
@@ -9,3 +9,4 @@ import './guard'
 import './hash'
 import './mutate'
 import './pointer'
+import './transform'
diff --git a/test/runtime/value/transform/_nested.ts b/test/runtime/value/transform/_nested.ts
new file mode 100644
index 000000000..700de2c38
--- /dev/null
+++ b/test/runtime/value/transform/_nested.ts
@@ -0,0 +1,52 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Nested', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T11 = Type.Transform(Type.Literal(1))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  const T12 = Type.Transform(T11)
+    .Decode((value) => value)
+    .Encode((value) => value)
+  const T13 = Type.Transform(T12)
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T13, 1)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T13, 1)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T13, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T21 = Type.Transform(Type.Literal(1))
+    .Decode((value) => 2 as const)
+    .Encode((value) => 1 as const)
+  const T22 = Type.Transform(T21)
+    .Decode((value) => 3 as const)
+    .Encode((value) => 2 as const)
+  const T23 = Type.Transform(T22)
+    .Decode((value) => 4 as const)
+    .Encode((value) => 3 as const)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T23, 1)
+    Assert.IsEqual(R, 4)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T23, 4)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T23, null))
+  })
+})
diff --git a/test/runtime/value/transform/any.ts b/test/runtime/value/transform/any.ts
new file mode 100644
index 000000000..91281c315
--- /dev/null
+++ b/test/runtime/value/transform/any.ts
@@ -0,0 +1,34 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Any', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Any())
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T0, 123)
+    Assert.IsEqual(R, 123)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T0, 123)
+    Assert.IsEqual(R, 123)
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Any())
+    .Decode((value) => 1)
+    .Encode((value) => 2)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, null)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsEqual(R, 2)
+  })
+})
diff --git a/test/runtime/value/transform/array.ts b/test/runtime/value/transform/array.ts
new file mode 100644
index 000000000..96afb073e
--- /dev/null
+++ b/test/runtime/value/transform/array.ts
@@ -0,0 +1,97 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Array', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Array(Type.Number()))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T0, [0, 1, 2])
+    Assert.IsEqual(R, [0, 1, 2])
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T0, [0, 1, 2])
+    Assert.IsEqual(R, [0, 1, 2])
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Array(Type.Number()))
+    .Decode((value) => 1)
+    .Encode((value) => [0, 1, 2])
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, [])
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsEqual(R, [0, 1, 2])
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+  // --------------------------------------------------------
+  // Elements
+  // --------------------------------------------------------
+  const B2 = Type.Transform(Type.Boolean())
+    .Decode((value) => (value ? 'TRUE' : 'FALSE'))
+    .Encode((value) => (value === 'TRUE' ? true : false))
+  const T2 = Type.Array(B2)
+  it('Should decode elements', () => {
+    const R = Value.Decode(T2, [true, false])
+    Assert.IsEqual(R, ['TRUE', 'FALSE'])
+  })
+  it('Should encode elements', () => {
+    const R = Value.Encode(T2, ['TRUE', 'FALSE'])
+    Assert.IsEqual(R, [true, false])
+  })
+  it('Should throw on elements decode', () => {
+    Assert.Throws(() => Value.Decode(T2, null))
+  })
+  // --------------------------------------------------------
+  // Elements Contains (Not Supported)
+  // --------------------------------------------------------
+  const N3 = Type.Transform(Type.Literal(1))
+    .Decode((value) => 'hello')
+    .Encode((value) => 1 as const)
+  const T3 = Type.Array(Type.Number(), {
+    contains: N3,
+  })
+  it('Should decode contains', () => {
+    const R = Value.Decode(T3, [1, 2, 3])
+    Assert.IsEqual(R, [1, 2, 3])
+  })
+  it('Should throw on contains encode', () => {
+    Assert.Throws(() => Value.Encode(T3, ['hello', 2, 3]))
+  })
+  it('Should throw on contains decode', () => {
+    Assert.Throws(() => Value.Decode(T3, null))
+  })
+  // ------------------------------------------------------------
+  // Set
+  // ------------------------------------------------------------
+  const T4 = Type.Transform(Type.Array(Type.Number()))
+    .Decode((value) => new Set(value))
+    .Encode((value) => [...value])
+  it('should decode set', () => {
+    const R = Value.Decode(T4, [1, 1, 2, 3])
+    Assert.IsInstanceOf(R, Set)
+    Assert.IsTrue(R.has(1))
+    Assert.IsTrue(R.has(2))
+    Assert.IsTrue(R.has(3))
+  })
+  it('should encode set', () => {
+    const R = Value.Encode(T4, new Set([1, 2, 3]))
+    Assert.IsEqual(R, [1, 2, 3])
+  })
+  it('Should throw on set decode', () => {
+    Assert.Throws(() => Value.Decode(T4, {}))
+  })
+})
diff --git a/test/runtime/value/transform/async-iterator.ts b/test/runtime/value/transform/async-iterator.ts
new file mode 100644
index 000000000..c418d723f
--- /dev/null
+++ b/test/runtime/value/transform/async-iterator.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/AsyncIterator', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.AsyncIterator(Type.Number()))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, (async function* (): any {})())
+    Assert.IsTrue(Symbol.asyncIterator in R)
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, (async function* (): any {})())
+    Assert.IsTrue(Symbol.asyncIterator in R)
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.AsyncIterator(Type.Number()))
+    .Decode((value) => 1)
+    .Encode((value) => (async function* (): any {})())
+  it('Should decode', () => {
+    const R = Value.Decode(T1, (async function* (): any {})())
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsTrue(Symbol.asyncIterator in R)
+  })
+  it('Should throw on decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+})
diff --git a/test/runtime/value/transform/bigint.ts b/test/runtime/value/transform/bigint.ts
new file mode 100644
index 000000000..ffc66b058
--- /dev/null
+++ b/test/runtime/value/transform/bigint.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/BigInt', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.BigInt())
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, 5n)
+    Assert.IsEqual(R, 5n)
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, 5n)
+    Assert.IsEqual(R, 5n)
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.BigInt())
+    .Decode((value) => 1)
+    .Encode((value) => 2n)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, 1n)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsEqual(R, 2n)
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+})
diff --git a/test/runtime/value/transform/boolean.ts b/test/runtime/value/transform/boolean.ts
new file mode 100644
index 000000000..1421a1e8a
--- /dev/null
+++ b/test/runtime/value/transform/boolean.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Boolean', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Boolean())
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, true)
+    Assert.IsEqual(R, true)
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, false)
+    Assert.IsEqual(R, false)
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Boolean())
+    .Decode((value) => 1)
+    .Encode((value) => true)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, true)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsEqual(R, true)
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+})
diff --git a/test/runtime/value/transform/constructor.ts b/test/runtime/value/transform/constructor.ts
new file mode 100644
index 000000000..0cfe28d43
--- /dev/null
+++ b/test/runtime/value/transform/constructor.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Constructor', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Constructor([], Type.Any()))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, class {})
+    Assert.IsTypeOf(R, 'function')
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, class {})
+    Assert.IsTypeOf(R, 'function')
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Constructor([], Type.Any()))
+    .Decode((value) => 1)
+    .Encode((value) => class {})
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, class {})
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsTypeOf(R, 'function')
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+})
diff --git a/test/runtime/value/transform/date.ts b/test/runtime/value/transform/date.ts
new file mode 100644
index 000000000..1d83713e0
--- /dev/null
+++ b/test/runtime/value/transform/date.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Date', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Date())
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, new Date(123))
+    Assert.IsEqual(R, new Date(123))
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, new Date(123))
+    Assert.IsEqual(R, new Date(123))
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Date())
+    .Decode((value) => 1)
+    .Encode((value) => new Date())
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, new Date())
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsInstanceOf(R, Date)
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+})
diff --git a/test/runtime/value/transform/function.ts b/test/runtime/value/transform/function.ts
new file mode 100644
index 000000000..5d94b8d72
--- /dev/null
+++ b/test/runtime/value/transform/function.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Function', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Function([], Type.Any()))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, class {})
+    Assert.IsTypeOf(R, 'function')
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, class {})
+    Assert.IsTypeOf(R, 'function')
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Function([], Type.Any()))
+    .Decode((value) => 1)
+    .Encode((value) => function () {})
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, function () {})
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsTypeOf(R, 'function')
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+})
diff --git a/test/runtime/value/transform/index.ts b/test/runtime/value/transform/index.ts
new file mode 100644
index 000000000..2dc90ff81
--- /dev/null
+++ b/test/runtime/value/transform/index.ts
@@ -0,0 +1,31 @@
+import './_nested'
+import './any'
+import './array'
+import './async-iterator'
+import './bigint'
+import './boolean'
+import './constructor'
+import './date'
+import './function'
+import './integer'
+import './intersect'
+import './iterator'
+import './literal'
+import './never'
+import './not'
+import './null'
+import './number'
+import './object'
+import './promise'
+import './record'
+import './recursive'
+import './ref'
+import './string'
+import './symbol'
+import './template-literal'
+import './tuple'
+import './undefined'
+import './union'
+import './unknown'
+import './unsafe'
+import './void'
diff --git a/test/runtime/value/transform/integer.ts b/test/runtime/value/transform/integer.ts
new file mode 100644
index 000000000..2f91f3f35
--- /dev/null
+++ b/test/runtime/value/transform/integer.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Integer', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Integer())
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, 42)
+    Assert.IsEqual(R, 42)
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, 42)
+    Assert.IsEqual(R, 42)
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Integer())
+    .Decode((value) => 1)
+    .Encode((value) => 2)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, 1)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsEqual(R, 2)
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+})
diff --git a/test/runtime/value/transform/intersect.ts b/test/runtime/value/transform/intersect.ts
new file mode 100644
index 000000000..342f93abe
--- /dev/null
+++ b/test/runtime/value/transform/intersect.ts
@@ -0,0 +1,122 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Intersect', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  // prettier-ignore
+  const T0 = Type.Transform(Type.Intersect([
+    Type.Object({ x: Type.Number() }), 
+    Type.Object({ y: Type.Number() })
+  ]))
+  .Decode(value => value)
+  .Encode(value => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  // prettier-ignore
+  const T1 = Type.Transform(Type.Intersect([
+    Type.Object({ x: Type.Number() }), 
+    Type.Object({ y: Type.Number() })
+  ]))
+  .Decode((value) => 1)
+  .Encode((value) => ({ x: 1, y: 2 }))
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, { x: 1, y: 2 })
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+  // --------------------------------------------------------
+  // Mapped Property
+  // --------------------------------------------------------
+  const N2 = Type.Transform(Type.Number())
+    .Decode((value) => value.toString())
+    .Encode((value) => parseFloat(value))
+  // prettier-ignore
+  const T2 = Type.Transform(Type.Intersect([
+    Type.Object({ x: Type.Number() }), 
+    Type.Object({ y: N2 })
+  ]))
+  .Decode((value) => value)
+  .Encode((value) => value)
+  it('Should decode property', () => {
+    const R = Value.Decode(T2, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: '2' })
+  })
+  it('Should encode property', () => {
+    const R = Value.Encode(T2, { x: 1, y: '2' })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should throw on property decode', () => {
+    Assert.Throws(() => Value.Decode(T2, null))
+  })
+  // --------------------------------------------------------
+  // Unevaluated Property
+  // --------------------------------------------------------
+  const N3 = Type.Transform(Type.Number())
+    .Decode((value) => value.toString())
+    .Encode((value) => parseFloat(value))
+  // prettier-ignore
+  const T3 = Type.Intersect([
+    Type.Object({ x: Type.Number() }), 
+    Type.Object({ y: Type.Number() })
+  ], {
+    unevaluatedProperties: N3
+  })
+  it('Should decode unevaluated property', () => {
+    const R = Value.Decode(T3, { x: 1, y: 2, z: 3 })
+    Assert.IsEqual(R, { x: 1, y: 2, z: '3' })
+  })
+  it('Should encode unevaluated property', () => {
+    const R = Value.Encode(T3, { x: 1, y: 2, z: '3' })
+    Assert.IsEqual(R, { x: 1, y: 2, z: 3 })
+  })
+  it('Should throw on unevaluated property decode', () => {
+    Assert.Throws(() => Value.Decode(T3, null))
+  })
+  // --------------------------------------------------------
+  // Transform Intersection Interior (Not Supported)
+  // --------------------------------------------------------
+  it('Should throw on intersected interior transform types', () => {
+    const N4 = Type.Transform(Type.Number())
+      .Decode((value) => value)
+      .Encode((value) => value)
+    Assert.Throws(() => Type.Intersect([N4, N4]))
+  })
+  // --------------------------------------------------------
+  // Transform Intersection Exterior
+  // --------------------------------------------------------
+  const T4 = Type.Transform(Type.Intersect([Type.Number(), Type.Number()]))
+    .Decode((value) => value + 1)
+    .Encode((value) => value - 1)
+  it('Should decode exterior value type', () => {
+    const R = Value.Decode(T4, 1)
+    Assert.IsEqual(R, 2)
+  })
+  it('Should encode exterior value type', () => {
+    const R = Value.Encode(T4, 2)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should throw on exterior value type decode', () => {
+    Assert.Throws(() => Value.Decode(T4, null))
+  })
+})
diff --git a/test/runtime/value/transform/iterator.ts b/test/runtime/value/transform/iterator.ts
new file mode 100644
index 000000000..90bc03773
--- /dev/null
+++ b/test/runtime/value/transform/iterator.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Iterator', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Iterator(Type.Number()))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, (function* (): any {})())
+    Assert.IsTrue(Symbol.iterator in R)
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, (function* (): any {})())
+    Assert.IsTrue(Symbol.iterator in R)
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Iterator(Type.Number()))
+    .Decode((value) => 1)
+    .Encode((value) => (function* (): any {})())
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, (function* (): any {})())
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsTrue(Symbol.iterator in R)
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+})
diff --git a/test/runtime/value/transform/literal.ts b/test/runtime/value/transform/literal.ts
new file mode 100644
index 000000000..9e0f9e41c
--- /dev/null
+++ b/test/runtime/value/transform/literal.ts
@@ -0,0 +1,71 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Literal', () => {
+  // -----------------------------------------------
+  // Identity
+  // -----------------------------------------------
+  const T0 = Type.Transform(Type.Literal(123))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T0, 123)
+    Assert.IsEqual(R, 123)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T0, 123)
+    Assert.IsEqual(R, 123)
+  })
+  // -----------------------------------------------
+  // LiteralString
+  // -----------------------------------------------
+  const T1 = Type.Transform(Type.Literal('hello'))
+    .Decode((value) => 1)
+    .Encode((value) => 'hello' as const)
+  it('Should decode literal string', () => {
+    const R = Value.Decode(T1, 'hello')
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode literal string', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsEqual(R, 'hello')
+  })
+  it('Should throw on decode literal string', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+  // -----------------------------------------------
+  // LiteralNumber
+  // -----------------------------------------------
+  const T2 = Type.Transform(Type.Literal(2))
+    .Decode((value) => 1)
+    .Encode((value) => 2 as const)
+  it('Should decode literal number', () => {
+    const R = Value.Decode(T2, 2)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode literal number', () => {
+    const R = Value.Encode(T2, null)
+    Assert.IsEqual(R, 2)
+  })
+  it('Should throw on decode literal number', () => {
+    Assert.Throws(() => Value.Decode(T2, null))
+  })
+  // -----------------------------------------------
+  // LiteralBoolean
+  // -----------------------------------------------
+  const T3 = Type.Transform(Type.Literal(true))
+    .Decode((value) => 1)
+    .Encode((value) => true as const)
+  it('Should decode literal boolean', () => {
+    const R = Value.Decode(T3, true)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode literal boolean', () => {
+    const R = Value.Encode(T3, null)
+    Assert.IsEqual(R, true)
+  })
+  it('Should throw on decode literal boolean', () => {
+    Assert.Throws(() => Value.Decode(T3, null))
+  })
+})
diff --git a/test/runtime/value/transform/never.ts b/test/runtime/value/transform/never.ts
new file mode 100644
index 000000000..3a5414821
--- /dev/null
+++ b/test/runtime/value/transform/never.ts
@@ -0,0 +1,33 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Never', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Never())
+    .Decode((value) => value)
+    // @ts-ignore
+    .Encode((value) => value)
+  it('Should throw on identity encode', () => {
+    Assert.Throws(() => Value.Encode(T0, undefined))
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, undefined))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Never())
+    // @ts-ignore
+    .Decode((value) => 1)
+    // @ts-ignore
+    .Encode((value) => 1)
+  it('Should throw on mapped encode', () => {
+    Assert.Throws(() => Value.Encode(T1, undefined))
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, undefined))
+  })
+})
diff --git a/test/runtime/value/transform/not.ts b/test/runtime/value/transform/not.ts
new file mode 100644
index 000000000..97277223e
--- /dev/null
+++ b/test/runtime/value/transform/not.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Not', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Not(Type.String()))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, 1)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, 1)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, ''))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Not(Type.String()))
+    .Decode((value) => 1)
+    .Encode((value) => 2)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, null)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsEqual(R, 2)
+  })
+  it('Should throw on decode not', () => {
+    Assert.Throws(() => Value.Decode(T1, 'hello'))
+  })
+})
diff --git a/test/runtime/value/transform/null.ts b/test/runtime/value/transform/null.ts
new file mode 100644
index 000000000..a113d1566
--- /dev/null
+++ b/test/runtime/value/transform/null.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Null', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Null())
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, undefined))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Null())
+    .Decode((value) => 1)
+    .Encode((value) => null)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, null)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, 123)
+    Assert.IsEqual(R, null)
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, undefined))
+  })
+})
diff --git a/test/runtime/value/transform/number.ts b/test/runtime/value/transform/number.ts
new file mode 100644
index 000000000..dcd9328c7
--- /dev/null
+++ b/test/runtime/value/transform/number.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Number', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Number())
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, 42)
+    Assert.IsEqual(R, 42)
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, 42)
+    Assert.IsEqual(R, 42)
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Number())
+    .Decode((value) => value + 1)
+    .Encode((value) => value - 1)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, 1)
+    Assert.IsEqual(R, 2)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, 2)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, undefined))
+  })
+})
diff --git a/test/runtime/value/transform/object.ts b/test/runtime/value/transform/object.ts
new file mode 100644
index 000000000..2c3c0b423
--- /dev/null
+++ b/test/runtime/value/transform/object.ts
@@ -0,0 +1,153 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Object', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(
+    Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    }),
+  )
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, undefined))
+  })
+  // ----------------------------------------------------------
+  // Object
+  // ----------------------------------------------------------
+  const T1 = Type.Transform(
+    Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    }),
+  )
+    .Decode((value) => 42)
+    .Encode((value) => ({ x: 1, y: 2 }))
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, { x: 1, y: 2 })
+    Assert.IsEqual(R, 42)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, undefined))
+  })
+  // ----------------------------------------------------------
+  // Object: Transform Property
+  // ----------------------------------------------------------
+  const N2 = Type.Transform(Type.Integer())
+    .Decode((value) => value.toString())
+    .Encode((value) => parseInt(value))
+  const T2 = Type.Object({
+    x: N2,
+    y: N2,
+  })
+  it('Should decode transform property', () => {
+    const R = Value.Decode(T2, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: '1', y: '2' })
+  })
+  it('Should encode transform property', () => {
+    const R = Value.Encode(T2, { x: '1', y: '2' })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should throw on decode transform property', () => {
+    Assert.Throws(() => Value.Decode(T2, undefined))
+  })
+  // ----------------------------------------------------------
+  // Object: Transform Property Nested (Twizzle)
+  // ----------------------------------------------------------
+  const N3 = Type.Transform(Type.Integer())
+    .Decode((value) => value.toString())
+    .Encode((value) => parseInt(value))
+  const T3 = Type.Transform(
+    Type.Object({
+      x: N3,
+      y: N3,
+    }),
+  )
+    .Decode((value) => ({ x: value.y, y: value.x }))
+    .Encode((value) => ({ x: value.y, y: value.x }))
+  it('Should decode transform property nested', () => {
+    const R = Value.Decode(T3, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: '2', y: '1' })
+  })
+  it('Should encode transform property nested', () => {
+    const R = Value.Encode(T3, { x: '1', y: '2' })
+    Assert.IsEqual(R, { x: 2, y: 1 })
+  })
+  it('Should throw on decode transform property nested', () => {
+    Assert.Throws(() => Value.Decode(T3, undefined))
+  })
+  // ----------------------------------------------------------
+  // Object Additional Properties
+  // ----------------------------------------------------------
+  const N4 = Type.Transform(Type.Integer())
+    .Decode((value) => value.toString())
+    .Encode((value) => parseInt(value))
+  const T4 = Type.Transform(
+    Type.Object(
+      {
+        x: Type.Number(),
+      },
+      {
+        additionalProperties: N4,
+      },
+    ),
+  )
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode additional property', () => {
+    const R = Value.Decode(T4, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: '2' })
+  })
+  it('Should encode additional property', () => {
+    const R = Value.Encode(T4, { x: 1, y: '5' })
+    Assert.IsEqual(R, { x: 1, y: 5 })
+  })
+  it('Should throw on additional property 1', () => {
+    Assert.Throws(() => Value.Decode(T4, undefined))
+  })
+  it('Should throw on additional property 2', () => {
+    Assert.Throws(() => Value.Decode(T4, { x: 1, y: true }))
+  })
+  // ------------------------------------------------------------
+  // Map
+  // ------------------------------------------------------------
+  const T5 = Type.Transform(Type.Object({ x: Type.String(), y: Type.String() }))
+    .Decode((value) => new Map(Object.entries(value)))
+    .Encode((value) => Object.fromEntries(value.entries()) as any)
+  it('should decode map', () => {
+    const R = Value.Decode(T5, { x: 'hello', y: 'world' })
+    Assert.IsInstanceOf(R, Map)
+    Assert.IsEqual(R.get('x'), 'hello')
+    Assert.IsEqual(R.get('y'), 'world')
+  })
+  it('should encode map', () => {
+    const R = Value.Encode(
+      T5,
+      new Map([
+        ['x', 'hello'],
+        ['y', 'world'],
+      ]),
+    )
+    Assert.IsEqual(R, { x: 'hello', y: 'world' })
+  })
+  it('Should throw on map decode', () => {
+    Assert.Throws(() => Value.Decode(T5, {}))
+  })
+})
diff --git a/test/runtime/value/transform/promise.ts b/test/runtime/value/transform/promise.ts
new file mode 100644
index 000000000..9a4f33c45
--- /dev/null
+++ b/test/runtime/value/transform/promise.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Promise', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Promise(Type.Number()))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, Promise.resolve(1))
+    Assert.IsTrue(R instanceof Promise)
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, Promise.resolve(1))
+    Assert.IsTrue(R instanceof Promise)
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, undefined))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T = Type.Transform(Type.Promise(Type.Number()))
+    .Decode((value) => 1)
+    .Encode((value) => Promise.resolve(1))
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T, Promise.resolve(1))
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T, null)
+    Assert.IsTrue(R instanceof Promise)
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T, null))
+  })
+})
diff --git a/test/runtime/value/transform/record.ts b/test/runtime/value/transform/record.ts
new file mode 100644
index 000000000..2b2bc3d82
--- /dev/null
+++ b/test/runtime/value/transform/record.ts
@@ -0,0 +1,123 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Record', () => {
+  // ------------------------------------------------------------
+  // Identity
+  // ------------------------------------------------------------
+  const T0 = Type.Transform(Type.Record(Type.String(), Type.Boolean()))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, {
+      a: true,
+      b: false,
+    })
+    Assert.IsEqual(R, {
+      a: true,
+      b: false,
+    })
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, {
+      a: true,
+      b: false,
+    })
+    Assert.IsEqual(R, {
+      a: true,
+      b: false,
+    })
+  })
+  it('Should throw on identity', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // ------------------------------------------------------------
+  // Additional Properties True
+  // ------------------------------------------------------------
+  const N1 = Type.Transform(Type.Number())
+    .Decode((value) => `number-${value.toString()}`)
+    .Encode((value) => parseFloat(value.replace(/number-/g, '')))
+  const T1 = Type.Record(Type.Number(), N1)
+  it('Should decode additional properties allowed', () => {
+    const R = Value.Decode(T1, {
+      0: 1,
+      a: true,
+    })
+    Assert.IsEqual(R, {
+      0: 'number-1',
+      a: true,
+    })
+  })
+  it('Should encode additional properties allowed', () => {
+    const R = Value.Encode(T1, {
+      0: 'number-1',
+      a: true,
+    })
+    Assert.IsEqual(R, {
+      0: 1,
+      a: true,
+    })
+  })
+  it('Should throw on additional properties allowed', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+  // ------------------------------------------------------------
+  // Complex Transform
+  // ------------------------------------------------------------
+  const N2 = Type.Transform(Type.Number())
+    .Decode((value) => `number-${value.toString()}`)
+    .Encode((value) => parseFloat(value.replace(/number-/g, '')))
+  const B2 = Type.Transform(Type.Boolean())
+    .Decode((value) => (value ? 'TRUE' : 'FALSE'))
+    .Encode((value) => (value === 'TRUE' ? true : false))
+  const T3 = Type.Record(Type.Number(), N2, { additionalProperties: B2 })
+  it('Should decode complex', () => {
+    const R = Value.Decode(T3, {
+      0: 1,
+      a: true,
+    })
+    Assert.IsEqual(R, {
+      0: 'number-1',
+      a: 'TRUE',
+    })
+  })
+  it('Should encode complex', () => {
+    const R = Value.Encode(T3, {
+      0: 'number-1',
+      a: 'TRUE',
+    })
+    Assert.IsEqual(R, {
+      0: 1,
+      a: true,
+    })
+  })
+  it('Should throw on complex decode', () => {
+    Assert.Throws(() => Value.Decode(T3, null))
+  })
+  // ------------------------------------------------------------
+  // Map
+  // ------------------------------------------------------------
+  const T4 = Type.Transform(Type.Record(Type.String(), Type.String()))
+    .Decode((value) => new Map(Object.entries(value)))
+    .Encode((value) => Object.fromEntries(value.entries()))
+  it('should decode map', () => {
+    const R = Value.Decode(T4, { x: 'hello', y: 'world' })
+    Assert.IsInstanceOf(R, Map)
+    Assert.IsEqual(R.get('x'), 'hello')
+    Assert.IsEqual(R.get('y'), 'world')
+  })
+  it('should encode map', () => {
+    const R = Value.Encode(
+      T4,
+      new Map([
+        ['x', 'hello'],
+        ['y', 'world'],
+      ]),
+    )
+    Assert.IsEqual(R, { x: 'hello', y: 'world' })
+  })
+  it('Should throw on map decode', () => {
+    Assert.Throws(() => Value.Decode(T4, null))
+  })
+})
diff --git a/test/runtime/value/transform/recursive.ts b/test/runtime/value/transform/recursive.ts
new file mode 100644
index 000000000..2b22d42e1
--- /dev/null
+++ b/test/runtime/value/transform/recursive.ts
@@ -0,0 +1,131 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Recursive', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(
+    Type.Recursive((This) =>
+      Type.Object({
+        value: Type.Number(),
+        nodes: Type.Array(This),
+      }),
+    ),
+  )
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, {
+      value: 1,
+      nodes: [
+        { value: 2, nodes: [] },
+        { value: 3, nodes: [] },
+      ],
+    })
+    Assert.IsEqual(R, {
+      value: 1,
+      nodes: [
+        { value: 2, nodes: [] },
+        { value: 3, nodes: [] },
+      ],
+    })
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, {
+      value: 1,
+      nodes: [
+        { value: 2, nodes: [] },
+        { value: 3, nodes: [] },
+      ],
+    })
+    Assert.IsEqual(R, {
+      value: 1,
+      nodes: [
+        { value: 2, nodes: [] },
+        { value: 3, nodes: [] },
+      ],
+    })
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, undefined))
+  })
+  // -----------------------------------------------
+  // Mapped
+  // -----------------------------------------------
+  const T1 = Type.Transform(
+    Type.Recursive((This) =>
+      Type.Object({
+        value: Type.Number(),
+        nodes: Type.Array(This),
+      }),
+    ),
+  )
+    .Decode((value) => 1)
+    .Encode((value) => ({ value: 1, nodes: [] }))
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, {
+      value: 1,
+      nodes: [
+        { value: 2, nodes: [] },
+        { value: 3, nodes: [] },
+      ],
+    })
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsEqual(R, { value: 1, nodes: [] })
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+  // -----------------------------------------------
+  // Recursive Property Remap
+  // -----------------------------------------------
+  const N2 = Type.Transform(Type.Number())
+    .Decode((value) => new Date(value))
+    .Encode((value) => value.getTime())
+  const T2 = Type.Recursive((This) =>
+    Type.Object({
+      value: N2,
+      nodes: Type.Array(This),
+    }),
+  )
+  it('Should decode property', () => {
+    const R = Value.Decode(T2, {
+      value: 1,
+      nodes: [
+        { value: 2, nodes: [] },
+        { value: 3, nodes: [] },
+      ],
+    })
+    Assert.IsEqual(R, {
+      value: new Date(1),
+      nodes: [
+        { value: new Date(2), nodes: [] },
+        { value: new Date(3), nodes: [] },
+      ],
+    })
+  })
+  it('Should encode property', () => {
+    const R = Value.Encode(T2, {
+      value: new Date(1),
+      nodes: [
+        { value: new Date(2), nodes: [] },
+        { value: new Date(3), nodes: [] },
+      ],
+    })
+    Assert.IsEqual(R, {
+      value: 1,
+      nodes: [
+        { value: 2, nodes: [] },
+        { value: 3, nodes: [] },
+      ],
+    })
+  })
+  it('Should throw on decode property', () => {
+    Assert.Throws(() => Value.Decode(T2, null))
+  })
+})
diff --git a/test/runtime/value/transform/ref.ts b/test/runtime/value/transform/ref.ts
new file mode 100644
index 000000000..20385f9bb
--- /dev/null
+++ b/test/runtime/value/transform/ref.ts
@@ -0,0 +1,62 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Ref', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const N0 = Type.Number({ $id: 'N0' })
+  const T0 = Type.Transform(Type.Ref(N0))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T0, [N0], 0)
+    Assert.IsEqual(R, 0)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T0, [N0], 0)
+    Assert.IsEqual(R, 0)
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const N1 = Type.Number({ $id: 'N1' })
+  const T1 = Type.Transform(Type.Ref(N1))
+    .Decode((value) => value + 1)
+    .Encode((value) => value - 1)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, [N1], 0)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, [N1], 1)
+    Assert.IsEqual(R, 0)
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+  // --------------------------------------------------------
+  // Mapped Remote
+  // --------------------------------------------------------
+  const N2 = Type.Transform(Type.Number({ $id: 'N2' }))
+    .Decode((value) => value + 1)
+    .Encode((value) => value - 1)
+  const T2 = Type.Transform(Type.Ref(N2))
+    .Decode((value) => value + 1)
+    .Encode((value) => value - 1)
+  it('Should decode mapped remote', () => {
+    const R = Value.Decode(T2, [N2], 0)
+    Assert.IsEqual(R, 2)
+  })
+  it('Should encode mapped remote', () => {
+    const R = Value.Encode(T2, [N2], 2)
+    Assert.IsEqual(R, 0)
+  })
+  it('Should throw on mapped remote decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+})
diff --git a/test/runtime/value/transform/string.ts b/test/runtime/value/transform/string.ts
new file mode 100644
index 000000000..6c15c074f
--- /dev/null
+++ b/test/runtime/value/transform/string.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/String', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.String())
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, 'hello')
+    Assert.IsEqual(R, 'hello')
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, 'hello')
+    Assert.IsEqual(R, 'hello')
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.String())
+    .Decode((value) => value.split('').reverse().join(''))
+    .Encode((value) => value.split('').reverse().join(''))
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, 'ABC')
+    Assert.IsEqual(R, 'CBA')
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, 'CBA')
+    Assert.IsEqual(R, 'ABC')
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+})
diff --git a/test/runtime/value/transform/symbol.ts b/test/runtime/value/transform/symbol.ts
new file mode 100644
index 000000000..5dfca318d
--- /dev/null
+++ b/test/runtime/value/transform/symbol.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/String', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Symbol())
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, Symbol('hello'))
+    Assert.IsEqual(R.description, 'hello')
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, Symbol('hello'))
+    Assert.IsEqual(R.description, 'hello')
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Symbol())
+    .Decode((value) => Symbol(value.description?.split('').reverse().join('')))
+    .Encode((value) => Symbol(value.description?.split('').reverse().join('')))
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, Symbol('ABC'))
+    Assert.IsEqual(R.description, 'CBA')
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, Symbol('CBA'))
+    Assert.IsEqual(R.description, 'ABC')
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+})
diff --git a/test/runtime/value/transform/template-literal.ts b/test/runtime/value/transform/template-literal.ts
new file mode 100644
index 000000000..174abaa2b
--- /dev/null
+++ b/test/runtime/value/transform/template-literal.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/TemplateLiteral', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.TemplateLiteral([Type.Literal('hello')]))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, 'hello')
+    Assert.IsEqual(R, 'hello')
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, 'hello')
+    Assert.IsEqual(R, 'hello')
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.TemplateLiteral([Type.Literal('ABC')]))
+    .Decode((value) => value.split('').reverse().join('') as 'CBA')
+    .Encode((value) => value.split('').reverse().join('') as 'ABC')
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, 'ABC')
+    Assert.IsEqual(R, 'CBA')
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, 'CBA')
+    Assert.IsEqual(R, 'ABC')
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+})
diff --git a/test/runtime/value/transform/tuple.ts b/test/runtime/value/transform/tuple.ts
new file mode 100644
index 000000000..cf6b9d51f
--- /dev/null
+++ b/test/runtime/value/transform/tuple.ts
@@ -0,0 +1,98 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Tuple', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Tuple([Type.Number(), Type.Number()]))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, [1, 2])
+    Assert.IsEqual(R, [1, 2])
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, [1, 2])
+    Assert.IsEqual(R, [1, 2])
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Tuple([Type.Number()]))
+    .Decode((value) => [value[0] + 1] as [number])
+    .Encode((value) => [value[0] - 1] as [number])
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, [0])
+    Assert.IsEqual(R, [1])
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, [1])
+    Assert.IsEqual(R, [0])
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+  // --------------------------------------------------------
+  // Mapped Element
+  // --------------------------------------------------------
+  const N2 = Type.Transform(Type.Number())
+    .Decode((value) => value + 1)
+    .Encode((value) => value - 1)
+  const T2 = Type.Transform(Type.Tuple([N2]))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode mapped element', () => {
+    const R = Value.Decode(T2, [0])
+    Assert.IsEqual(R, [1])
+  })
+  it('Should encode mapped element', () => {
+    const R = Value.Encode(T2, [1])
+    Assert.IsEqual(R, [0])
+  })
+  it('Should throw on mapped element decode', () => {
+    Assert.Throws(() => Value.Decode(T2, null))
+  })
+  // --------------------------------------------------------
+  // Mapped Element
+  // --------------------------------------------------------
+  const N3 = Type.Transform(Type.Number())
+    .Decode((value) => value + 1)
+    .Encode((value) => value - 1)
+  const T3 = Type.Transform(Type.Tuple([N3]))
+    .Decode((value) => [value[0].toString()])
+    .Encode((value) => [parseFloat(value[0])] as [number])
+  it('Should decode mapped element', () => {
+    const R = Value.Decode(T3, [0])
+    Assert.IsEqual(R, ['1'])
+  })
+  it('Should encode mapped element', () => {
+    const R = Value.Encode(T3, ['1'])
+    Assert.IsEqual(R, [0])
+  })
+  it('Should throw on mapped element decode', () => {
+    Assert.Throws(() => Value.Decode(T3, null))
+  })
+  // ------------------------------------------------------------
+  // Set
+  // ------------------------------------------------------------
+  const T4 = Type.Transform(Type.Tuple([Type.Number()]))
+    .Decode((value) => new Set(value))
+    .Encode((value) => [...value] as any)
+  it('should decode set', () => {
+    const R = Value.Decode(T4, [1])
+    Assert.IsInstanceOf(R, Set)
+    Assert.IsTrue(R.has(1))
+  })
+  it('should encode set', () => {
+    const R = Value.Encode(T4, new Set([1]))
+    Assert.IsEqual(R, [1])
+  })
+  it('Should throw on set decode', () => {
+    Assert.Throws(() => Value.Decode(T4, {}))
+  })
+})
diff --git a/test/runtime/value/transform/undefined.ts b/test/runtime/value/transform/undefined.ts
new file mode 100644
index 000000000..7f8582a9e
--- /dev/null
+++ b/test/runtime/value/transform/undefined.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Undefined', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Undefined())
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, undefined)
+    Assert.IsEqual(R, undefined)
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, undefined)
+    Assert.IsEqual(R, undefined)
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Undefined())
+    .Decode((value) => null)
+    .Encode((value) => undefined)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, undefined)
+    Assert.IsEqual(R, null)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsEqual(R, undefined)
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+})
diff --git a/test/runtime/value/transform/union.ts b/test/runtime/value/transform/union.ts
new file mode 100644
index 000000000..993c87002
--- /dev/null
+++ b/test/runtime/value/transform/union.ts
@@ -0,0 +1,170 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Union', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  // prettier-ignore
+  const T0 = Type.Transform(Type.Union([
+    Type.Object({ x: Type.Number() }),
+    Type.Object({ y: Type.Number() })
+  ]))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, { x: 1 })
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, { y: 2 })
+    Assert.IsEqual(R, { y: 2 })
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  // prettier-ignore
+  const T1 = Type.Transform(Type.Union([
+    Type.Object({ type: Type.Literal('hello') }),
+    Type.Object({ type: Type.Literal('world') })
+  ]))
+    .Decode((value) => 'test' as const)
+    .Encode((value) => ({ type: 'hello' as const }))
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, { type: 'hello' })
+    Assert.IsEqual(R, 'test')
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, 'test')
+    Assert.IsEqual(R, { type: 'hello' })
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+  // --------------------------------------------------------
+  // Mapped ValueType
+  // --------------------------------------------------------
+  const M21 = Type.Transform(Type.Number())
+    .Decode((value) => value + 1)
+    .Encode((value) => value - 1)
+  const M22 = Type.Transform(M21)
+    .Decode((value) => value + 1)
+    .Encode((value) => value - 1)
+  // prettier-ignore
+  const T2 = Type.Transform(Type.Union([Type.String(), M22]))
+    .Decode((value) => value)
+    .Encode((value) => {
+      if (value === 'hello') return 'world'
+      return value
+    })
+  it('Should decode value type 1', () => {
+    const R = Value.Decode(T2, 0)
+    Assert.IsEqual(R, 2)
+  })
+  it('Should decode value type 2', () => {
+    const R = Value.Decode(T2, 'hello')
+    Assert.IsEqual(R, 'hello')
+  })
+  it('Should encode value type 1', () => {
+    const R = Value.Encode(T2, 'hello')
+    Assert.IsEqual(R, 'world')
+  })
+  it('Should encode value type 2', () => {
+    const R = Value.Encode(T2, 2)
+    Assert.IsEqual(R, 0)
+  })
+  it('Should throw on value type decode', () => {
+    Assert.Throws(() => Value.Decode(T2, null))
+  })
+  // --------------------------------------------------------
+  // Mapped ObjectType
+  // --------------------------------------------------------
+  const N31 = Type.Transform(
+    Type.Object({
+      x: Type.Number(),
+    }),
+  )
+    .Decode((value) => ({ x: value.x + 1 }))
+    .Encode((value) => ({ x: value.x - 1 }))
+  const N32 = Type.Transform(
+    Type.Object({
+      x: Type.String(),
+    }),
+  )
+    .Decode((value) => ({ x: value.x.split('').reverse().join('') }))
+    .Encode((value) => ({ x: value.x.split('').reverse().join('') }))
+  // prettier-ignore
+  const T3 = Type.Transform(Type.Union([N31, N32]))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode object types 1', () => {
+    const R = Value.Decode(T3, { x: 0 })
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should decode object types 2', () => {
+    const R = Value.Decode(T3, { x: 'abc' })
+    Assert.IsEqual(R, { x: 'cba' })
+  })
+  it('Should encode object types 1', () => {
+    const R = Value.Encode(T3, { x: 1 })
+    Assert.IsEqual(R, { x: 0 })
+  })
+  it('Should encode object types 2', () => {
+    const R = Value.Encode(T3, { x: 'cba' })
+    Assert.IsEqual(R, { x: 'abc' })
+  })
+  it('Should throw on object types decode', () => {
+    Assert.Throws(() => Value.Decode(T3, null))
+  })
+  // --------------------------------------------------------
+  // Mapped Mixed Types
+  // --------------------------------------------------------
+  const N41 = Type.Transform(Type.Number())
+    .Decode((value) => value + 1)
+    .Encode((value) => value - 1)
+  const N42 = Type.Transform(
+    Type.Object({
+      x: Type.Number(),
+    }),
+  )
+    .Decode((value) => ({ x: value.x + 1 }))
+    .Encode((value) => ({ x: value.x - 1 }))
+  const N43 = Type.Transform(Type.Tuple([Type.Number()]))
+    .Decode((value) => [value[0] + 1])
+    .Encode((value) => [value[0] - 1] as [number])
+  // prettier-ignore
+  const T4 = Type.Transform(Type.Union([N41, N42, N43]))
+    .Decode((value) => typeof value === 'number' ? value + 1 : value)
+    .Encode((value) => typeof value === 'number' ? value - 1 : value)
+  it('Should decode mixed types 1', () => {
+    const R = Value.Decode(T4, { x: 0 })
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should decode mixed types 2', () => {
+    const R = Value.Decode(T4, 0)
+    Assert.IsEqual(R, 2)
+  })
+  it('Should decode mixed types 3', () => {
+    const R = Value.Decode(T4, [0])
+    Assert.IsEqual(R, [1])
+  })
+  it('Should encode mixed types 1', () => {
+    const R = Value.Encode(T4, { x: 1 })
+    Assert.IsEqual(R, { x: 0 })
+  })
+  it('Should encode mixed types 2', () => {
+    const R = Value.Encode(T4, 2)
+    Assert.IsEqual(R, 0)
+  })
+  it('Should encode mixed types 3', () => {
+    const R = Value.Encode(T4, [1])
+    Assert.IsEqual(R, [0])
+  })
+  it('Should throw on mixed types decode', () => {
+    Assert.Throws(() => Value.Decode(T4, null))
+  })
+})
diff --git a/test/runtime/value/transform/unknown.ts b/test/runtime/value/transform/unknown.ts
new file mode 100644
index 000000000..2fe673a17
--- /dev/null
+++ b/test/runtime/value/transform/unknown.ts
@@ -0,0 +1,34 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Unknown', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Unknown())
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T0, 123)
+    Assert.IsEqual(R, 123)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T0, 123)
+    Assert.IsEqual(R, 123)
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Unknown())
+    .Decode((value) => 1)
+    .Encode((value) => 2)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, null)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsEqual(R, 2)
+  })
+})
diff --git a/test/runtime/value/transform/unsafe.ts b/test/runtime/value/transform/unsafe.ts
new file mode 100644
index 000000000..76d31cb4f
--- /dev/null
+++ b/test/runtime/value/transform/unsafe.ts
@@ -0,0 +1,46 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type, Kind, TypeRegistry } from '@sinclair/typebox'
+
+describe('value/transform/Unsafe', () => {
+  // --------------------------------------------------------
+  // Fixtures
+  // --------------------------------------------------------
+  beforeEach(() => TypeRegistry.Set('Foo', (schema, value) => value !== null)) // throw on null
+  afterEach(() => TypeRegistry.Delete('Foo'))
+  const Foo = Type.Unsafe<string>({ [Kind]: 'Foo' })
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Foo)
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, 'hello')
+    Assert.IsEqual(R, 'hello')
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, 'hello')
+    Assert.IsEqual(R, 'hello')
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Foo)
+    .Decode((value) => value.split('').reverse().join(''))
+    .Encode((value) => value.split('').reverse().join(''))
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, 'ABC')
+    Assert.IsEqual(R, 'CBA')
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, 'CBA')
+    Assert.IsEqual(R, 'ABC')
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+})
diff --git a/test/runtime/value/transform/void.ts b/test/runtime/value/transform/void.ts
new file mode 100644
index 000000000..16cd87248
--- /dev/null
+++ b/test/runtime/value/transform/void.ts
@@ -0,0 +1,40 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Void', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Void())
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, undefined)
+    Assert.IsEqual(R, undefined)
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, undefined)
+    Assert.IsEqual(R, undefined)
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Void())
+    .Decode((value) => null)
+    .Encode((value) => undefined)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, undefined)
+    Assert.IsEqual(R, null)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsEqual(R, undefined)
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+})
diff --git a/test/static/any.ts b/test/static/any.ts
index abe16019e..90b417006 100644
--- a/test/static/any.ts
+++ b/test/static/any.ts
@@ -1,4 +1,4 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.Any()).ToInfer<any>()
+Expect(Type.Any()).ToStatic<any>()
diff --git a/test/static/array.ts b/test/static/array.ts
index 1b52abc7c..2ec60f3cc 100644
--- a/test/static/array.ts
+++ b/test/static/array.ts
@@ -1,7 +1,7 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.Array(Type.String())).ToInfer<string[]>()
+Expect(Type.Array(Type.String())).ToStatic<string[]>()
 
 Expect(
   Type.Array(
@@ -11,7 +11,7 @@ Expect(
       z: Type.String(),
     }),
   ),
-).ToInfer<
+).ToStatic<
   {
     x: number
     y: boolean
@@ -19,6 +19,6 @@ Expect(
   }[]
 >()
 
-Expect(Type.Array(Type.Array(Type.String()))).ToInfer<string[][]>()
+Expect(Type.Array(Type.Array(Type.String()))).ToStatic<string[][]>()
 
-Expect(Type.Array(Type.Tuple([Type.String(), Type.Number()]))).ToInfer<[string, number][]>()
+Expect(Type.Array(Type.Tuple([Type.String(), Type.Number()]))).ToStatic<[string, number][]>()
diff --git a/test/static/assert.ts b/test/static/assert.ts
index 4b8763847..0e764d992 100644
--- a/test/static/assert.ts
+++ b/test/static/assert.ts
@@ -1,8 +1,9 @@
-import { Static, TSchema } from '@sinclair/typebox'
+import { Static, StaticDecode, StaticEncode, TSchema } from '@sinclair/typebox'
 
-export function Expect<T extends TSchema, S = Static<T>>(schema: T) {
+export function Expect<T extends TSchema>(schema: T) {
   return {
-    ToInfer: <U extends S>() => {},
-    ToBe: <U extends S>() => {},
+    ToStatic: <U extends Static<T>>() => {},
+    ToStaticDecode: <U extends StaticDecode<T>>() => {},
+    ToStaticEncode: <U extends StaticEncode<T>>() => {},
   }
 }
diff --git a/test/static/async-iterator.ts b/test/static/async-iterator.ts
index 3d8d8fd1a..75364f1b0 100644
--- a/test/static/async-iterator.ts
+++ b/test/static/async-iterator.ts
@@ -1,4 +1,4 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.AsyncIterator(Type.String())).ToInfer<AsyncIterableIterator<string>>()
+Expect(Type.AsyncIterator(Type.String())).ToStatic<AsyncIterableIterator<string>>()
diff --git a/test/static/awaited.ts b/test/static/awaited.ts
index f8b0f8228..303e30f89 100644
--- a/test/static/awaited.ts
+++ b/test/static/awaited.ts
@@ -1,20 +1,20 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.Awaited(Type.String())).ToInfer<string>()
+Expect(Type.Awaited(Type.String())).ToStatic<string>()
 
-Expect(Type.Awaited(Type.Promise(Type.String()))).ToInfer<string>()
+Expect(Type.Awaited(Type.Promise(Type.String()))).ToStatic<string>()
 
-Expect(Type.Awaited(Type.Promise(Type.Promise(Type.String())))).ToInfer<string>()
+Expect(Type.Awaited(Type.Promise(Type.Promise(Type.String())))).ToStatic<string>()
 
 // One Level
 
-Expect(Type.Awaited(Type.Union([Type.Promise(Type.String()), Type.Number()]))).ToInfer<string | number>()
+Expect(Type.Awaited(Type.Union([Type.Promise(Type.String()), Type.Number()]))).ToStatic<string | number>()
 
-Expect(Type.Awaited(Type.Intersect([Type.Promise(Type.String()), Type.Number()]))).ToInfer<string & number>()
+Expect(Type.Awaited(Type.Intersect([Type.Promise(Type.String()), Type.Number()]))).ToStatic<string & number>()
 
 // Two Levels
 
-Expect(Type.Awaited(Type.Union([Type.Promise(Type.Promise(Type.String())), Type.Number()]))).ToInfer<string | number>()
+Expect(Type.Awaited(Type.Union([Type.Promise(Type.Promise(Type.String())), Type.Number()]))).ToStatic<string | number>()
 
-Expect(Type.Awaited(Type.Intersect([Type.Promise(Type.Promise(Type.String())), Type.Number()]))).ToInfer<string & number>()
+Expect(Type.Awaited(Type.Intersect([Type.Promise(Type.Promise(Type.String())), Type.Number()]))).ToStatic<string & number>()
diff --git a/test/static/bigint.ts b/test/static/bigint.ts
index a18b437ba..40c5b90e0 100644
--- a/test/static/bigint.ts
+++ b/test/static/bigint.ts
@@ -1,4 +1,4 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.BigInt()).ToInfer<bigint>()
+Expect(Type.BigInt()).ToStatic<bigint>()
diff --git a/test/static/boolean.ts b/test/static/boolean.ts
index d1b9f4c79..9e1b01316 100644
--- a/test/static/boolean.ts
+++ b/test/static/boolean.ts
@@ -1,4 +1,4 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.Boolean()).ToInfer<boolean>()
+Expect(Type.Boolean()).ToStatic<boolean>()
diff --git a/test/static/capitalize.ts b/test/static/capitalize.ts
index ca02c7398..b2982203e 100644
--- a/test/static/capitalize.ts
+++ b/test/static/capitalize.ts
@@ -1,14 +1,14 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.Capitalize(Type.Literal('hello'))).ToInfer<'Hello'>()
+Expect(Type.Capitalize(Type.Literal('hello'))).ToStatic<'Hello'>()
 
-Expect(Type.Capitalize(Type.Union([Type.Literal('hello'), Type.Literal('world')]))).ToInfer<'Hello' | 'World'>()
+Expect(Type.Capitalize(Type.Union([Type.Literal('hello'), Type.Literal('world')]))).ToStatic<'Hello' | 'World'>()
 
-Expect(Type.Capitalize(Type.TemplateLiteral('hello${0|1}'))).ToInfer<'Hello0' | 'Hello1'>()
+Expect(Type.Capitalize(Type.TemplateLiteral('hello${0|1}'))).ToStatic<'Hello0' | 'Hello1'>()
 
 // prettier-ignore
-Expect(Type.Capitalize(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(1), Type.Literal(2)])]))).ToBe<'Hello1' | 'Hello2'>()
+Expect(Type.Capitalize(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(1), Type.Literal(2)])]))).ToStatic<'Hello1' | 'Hello2'>()
 
 // passthrough
-Expect(Type.Capitalize(Type.Object({ x: Type.Number() }))).ToInfer<{ x: number }>()
+Expect(Type.Capitalize(Type.Object({ x: Type.Number() }))).ToStatic<{ x: number }>()
diff --git a/test/static/composite.ts b/test/static/composite.ts
index cf9bb88a0..62528245c 100644
--- a/test/static/composite.ts
+++ b/test/static/composite.ts
@@ -13,7 +13,7 @@ import { Type, TObject, TIntersect, TNumber, TBoolean } from '@sinclair/typebox'
   })
   const T = Type.Composite([A, B])
 
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A: number
   }>()
 }
@@ -29,7 +29,7 @@ import { Type, TObject, TIntersect, TNumber, TBoolean } from '@sinclair/typebox'
   })
   const T = Type.Composite([A, B])
 
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A: never
   }>()
 }
@@ -45,7 +45,7 @@ import { Type, TObject, TIntersect, TNumber, TBoolean } from '@sinclair/typebox'
   })
   const T = Type.Composite([A, B])
 
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A: number
   }>()
 }
@@ -62,7 +62,7 @@ import { Type, TObject, TIntersect, TNumber, TBoolean } from '@sinclair/typebox'
     A: Type.Optional(Type.Number()),
   })
   const T = Type.Composite([A, B])
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A: number | undefined
   }>()
 }
@@ -74,7 +74,7 @@ import { Type, TObject, TIntersect, TNumber, TBoolean } from '@sinclair/typebox'
     A: Type.Number(),
   })
   const T = Type.Composite([A, B])
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A: number
   }>()
 }
@@ -86,7 +86,7 @@ import { Type, TObject, TIntersect, TNumber, TBoolean } from '@sinclair/typebox'
     A: Type.Number(),
   })
   const T = Type.Composite([A, B])
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A: number
   }>()
 }
@@ -102,7 +102,7 @@ import { Type, TObject, TIntersect, TNumber, TBoolean } from '@sinclair/typebox'
   })
   const T = Type.Composite([A, B])
 
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A: number
     B: number
   }>()
diff --git a/test/static/constructor-parameters.ts b/test/static/constructor-parameters.ts
index 68081e37f..43db97852 100644
--- a/test/static/constructor-parameters.ts
+++ b/test/static/constructor-parameters.ts
@@ -10,4 +10,4 @@ const C = Type.Constructor(
 
 const P = Type.ConstructorParameters(C)
 
-Expect(P).ToInfer<[number, string]>()
+Expect(P).ToStatic<[number, string]>()
diff --git a/test/static/constructor.ts b/test/static/constructor.ts
index 8e05d8c40..a05363991 100644
--- a/test/static/constructor.ts
+++ b/test/static/constructor.ts
@@ -8,4 +8,4 @@ const C = Type.Constructor(
   }),
 )
 
-Expect(C).ToInfer<new (param_0: number, param_1: string) => { method: (param_0: number, param_1: string) => boolean }>()
+Expect(C).ToStatic<new (param_0: number, param_1: string) => { method: (param_0: number, param_1: string) => boolean }>()
diff --git a/test/static/date.ts b/test/static/date.ts
index 5907ac9eb..fe20220d5 100644
--- a/test/static/date.ts
+++ b/test/static/date.ts
@@ -1,4 +1,4 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.Date()).ToInfer<Date>()
+Expect(Type.Date()).ToStatic<Date>()
diff --git a/test/static/enum.ts b/test/static/enum.ts
index e44ae72aa..2833716b7 100644
--- a/test/static/enum.ts
+++ b/test/static/enum.ts
@@ -10,5 +10,5 @@ import { Type, Static } from '@sinclair/typebox'
 
   const T = Type.Enum(E)
 
-  Expect(T).ToBe<Static<typeof T>>() // ?
+  Expect(T).ToStatic<Static<typeof T>>() // ?
 }
diff --git a/test/static/exclude.ts b/test/static/exclude.ts
index 526e7bc60..bca6d820a 100644
--- a/test/static/exclude.ts
+++ b/test/static/exclude.ts
@@ -3,15 +3,15 @@ import { Expect } from './assert'
 
 {
   const T = Type.Exclude(Type.String(), Type.String())
-  Expect(T).ToBe<never>()
+  Expect(T).ToStatic<never>()
 }
 {
   const T = Type.Exclude(Type.String(), Type.Number())
-  Expect(T).ToBe<string>()
+  Expect(T).ToStatic<string>()
 }
 {
   const T = Type.Exclude(Type.Union([Type.Number(), Type.String(), Type.Boolean()]), Type.Number())
-  Expect(T).ToBe<boolean | string>()
+  Expect(T).ToStatic<boolean | string>()
 }
 // ------------------------------------------------------------------------
 // TemplateLiteral | TemplateLiteral
@@ -21,20 +21,20 @@ import { Expect } from './assert'
   const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
 
   const T = Type.Exclude(A, B)
-  Expect(T).ToBe<never>()
+  Expect(T).ToStatic<never>()
 }
 {
   const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
   const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
 
   const T = Type.Exclude(A, B)
-  Expect(T).ToBe<'C'>()
+  Expect(T).ToStatic<'C'>()
 }
 {
   const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
   const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
   const T = Type.Exclude(A, B)
-  Expect(T).ToBe<'C' | 'B'>()
+  Expect(T).ToStatic<'C' | 'B'>()
 }
 // ------------------------------------------------------------------------
 // TemplateLiteral | Union
@@ -44,20 +44,20 @@ import { Expect } from './assert'
   const B = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
 
   const T = Type.Exclude(A, B)
-  Expect(T).ToBe<never>()
+  Expect(T).ToStatic<never>()
 }
 {
   const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
   const B = Type.Union([Type.Literal('A'), Type.Literal('B')])
 
   const T = Type.Exclude(A, B)
-  Expect(T).ToBe<'C'>()
+  Expect(T).ToStatic<'C'>()
 }
 {
   const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
   const B = Type.Union([Type.Literal('A')])
   const T = Type.Exclude(A, B)
-  Expect(T).ToBe<'C' | 'B'>()
+  Expect(T).ToStatic<'C' | 'B'>()
 }
 // ------------------------------------------------------------------------
 // Union | TemplateLiteral
@@ -67,18 +67,18 @@ import { Expect } from './assert'
   const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
 
   const T = Type.Exclude(A, B)
-  Expect(T).ToBe<never>()
+  Expect(T).ToStatic<never>()
 }
 {
   const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
   const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
 
   const T = Type.Exclude(A, B)
-  Expect(T).ToBe<'C'>()
+  Expect(T).ToStatic<'C'>()
 }
 {
   const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
   const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
   const T = Type.Exclude(A, B)
-  Expect(T).ToBe<'C' | 'B'>()
+  Expect(T).ToStatic<'C' | 'B'>()
 }
diff --git a/test/static/extract.ts b/test/static/extract.ts
index 9e4073836..4bd3dc833 100644
--- a/test/static/extract.ts
+++ b/test/static/extract.ts
@@ -3,15 +3,15 @@ import { Expect } from './assert'
 
 {
   const T = Type.Extract(Type.String(), Type.String())
-  Expect(T).ToBe<string>()
+  Expect(T).ToStatic<string>()
 }
 {
   const T = Type.Extract(Type.String(), Type.Number())
-  Expect(T).ToBe<string>()
+  Expect(T).ToStatic<string>()
 }
 {
   const T = Type.Extract(Type.Union([Type.Number(), Type.String(), Type.Boolean()]), Type.Number())
-  Expect(T).ToBe<number>()
+  Expect(T).ToStatic<number>()
 }
 // ------------------------------------------------------------------------
 // TemplateLiteral | TemplateLiteral
@@ -21,20 +21,20 @@ import { Expect } from './assert'
   const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
 
   const T = Type.Extract(A, B)
-  Expect(T).ToBe<'A' | 'B' | 'C'>()
+  Expect(T).ToStatic<'A' | 'B' | 'C'>()
 }
 {
   const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
   const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
 
   const T = Type.Extract(A, B)
-  Expect(T).ToBe<'A' | 'B'>()
+  Expect(T).ToStatic<'A' | 'B'>()
 }
 {
   const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
   const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
   const T = Type.Extract(A, B)
-  Expect(T).ToBe<'A'>()
+  Expect(T).ToStatic<'A'>()
 }
 // ------------------------------------------------------------------------
 // TemplateLiteral | Union
@@ -43,20 +43,20 @@ import { Expect } from './assert'
   const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
   const B = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
   const T = Type.Extract(A, B)
-  Expect(T).ToBe<'A' | 'B' | 'C'>()
+  Expect(T).ToStatic<'A' | 'B' | 'C'>()
 }
 {
   const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
   const B = Type.Union([Type.Literal('A'), Type.Literal('B')])
 
   const T = Type.Extract(A, B)
-  Expect(T).ToBe<'A' | 'B'>()
+  Expect(T).ToStatic<'A' | 'B'>()
 }
 {
   const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
   const B = Type.Union([Type.Literal('A')])
   const T = Type.Extract(A, B)
-  Expect(T).ToBe<'A'>()
+  Expect(T).ToStatic<'A'>()
 }
 // ------------------------------------------------------------------------
 // Union | TemplateLiteral
@@ -66,18 +66,18 @@ import { Expect } from './assert'
   const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
 
   const T = Type.Extract(A, B)
-  Expect(T).ToBe<'A' | 'B' | 'C'>()
+  Expect(T).ToStatic<'A' | 'B' | 'C'>()
 }
 {
   const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
   const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
 
   const T = Type.Extract(A, B)
-  Expect(T).ToBe<'A' | 'B'>()
+  Expect(T).ToStatic<'A' | 'B'>()
 }
 {
   const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
   const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
   const T = Type.Extract(A, B)
-  Expect(T).ToBe<'A'>()
+  Expect(T).ToStatic<'A'>()
 }
diff --git a/test/static/function.ts b/test/static/function.ts
index 824075f7c..623aa911e 100644
--- a/test/static/function.ts
+++ b/test/static/function.ts
@@ -8,4 +8,4 @@ const C = Type.Function(
   }),
 )
 
-Expect(C).ToInfer<(param_0: number, param_1: string) => { method: (param_0: number, param_1: string) => boolean }>()
+Expect(C).ToStatic<(param_0: number, param_1: string) => { method: (param_0: number, param_1: string) => boolean }>()
diff --git a/test/static/index.ts b/test/static/index.ts
index be70f8a5c..d1c757f10 100644
--- a/test/static/index.ts
+++ b/test/static/index.ts
@@ -45,6 +45,7 @@ import './strict'
 import './string'
 import './symbol'
 import './template-literal'
+import './transform'
 import './tuple'
 import './uncapitalize'
 import './union'
diff --git a/test/static/indexed.ts b/test/static/indexed.ts
index c2cf5f9b6..cc0c9f24a 100644
--- a/test/static/indexed.ts
+++ b/test/static/indexed.ts
@@ -8,19 +8,19 @@ import { Type, Static } from '@sinclair/typebox'
   })
   const R = Type.Index(T, ['x', 'y'])
   type O = Static<typeof R>
-  Expect(R).ToInfer<number | string>()
+  Expect(R).ToStatic<number | string>()
 }
 {
   const T = Type.Tuple([Type.Number(), Type.String(), Type.Boolean()])
   const R = Type.Index(T, Type.Union([Type.Literal('0'), Type.Literal('1')]))
   type O = Static<typeof R>
-  Expect(R).ToInfer<number | string>()
+  Expect(R).ToStatic<number | string>()
 }
 {
   const T = Type.Tuple([Type.Number(), Type.String(), Type.Boolean()])
   const R = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal(1)]))
   type O = Static<typeof R>
-  Expect(R).ToInfer<number | string>()
+  Expect(R).ToStatic<number | string>()
 }
 {
   const T = Type.Object({
@@ -30,37 +30,37 @@ import { Type, Static } from '@sinclair/typebox'
 
   const R = Type.Index(T, Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])]))
   type O = Static<typeof R>
-  Expect(R).ToInfer<number | string>()
+  Expect(R).ToStatic<number | string>()
 }
 {
   const A = Type.Tuple([Type.String(), Type.Boolean()])
   const R = Type.Index(A, Type.Number())
   type O = Static<typeof R>
-  Expect(R).ToInfer<string | boolean>()
+  Expect(R).ToStatic<string | boolean>()
 }
 {
   const A = Type.Tuple([Type.String()])
   const R = Type.Index(A, Type.Number())
   type O = Static<typeof R>
-  Expect(R).ToInfer<string>()
+  Expect(R).ToStatic<string>()
 }
 {
   const A = Type.Tuple([])
   const R = Type.Index(A, Type.Number())
   type O = Static<typeof R>
-  Expect(R).ToInfer<never>()
+  Expect(R).ToStatic<never>()
 }
 {
   const A = Type.Object({})
   const R = Type.Index(A, Type.BigInt()) // Support Overload
   type O = Static<typeof R>
-  Expect(R).ToInfer<never>()
+  Expect(R).ToStatic<never>()
 }
 {
   const A = Type.Array(Type.Number())
   const R = Type.Index(A, Type.BigInt()) // Support Overload
   type O = Static<typeof R>
-  Expect(R).ToInfer<never>()
+  Expect(R).ToStatic<never>()
 }
 // ------------------------------------------------------------------
 // Intersections
@@ -76,7 +76,7 @@ import { Type, Static } from '@sinclair/typebox'
   const C = Type.Intersect([A, B])
   const R = Type.Index(C, ['y'])
   type O = Static<typeof R>
-  Expect(R).ToBe<1>()
+  Expect(R).ToStatic<1>()
 }
 {
   type A = { x: string; y: 1 }
@@ -89,7 +89,7 @@ import { Type, Static } from '@sinclair/typebox'
   const C = Type.Intersect([A, B])
   const R = Type.Index(C, ['x'])
   type O = Static<typeof R>
-  Expect(R).ToBe<string>()
+  Expect(R).ToStatic<string>()
 }
 {
   type A = { x: string; y: 1 }
@@ -102,7 +102,7 @@ import { Type, Static } from '@sinclair/typebox'
   const C = Type.Intersect([A, B])
   const R = Type.Index(C, ['x', 'y'])
   type O = Static<typeof R>
-  Expect(R).ToBe<string | 1>()
+  Expect(R).ToStatic<string | 1>()
 }
 {
   type A = { x: string; y: number }
@@ -115,7 +115,7 @@ import { Type, Static } from '@sinclair/typebox'
   const C = Type.Intersect([A, B])
   const R = Type.Index(C, ['x'])
   type O = Static<typeof R>
-  Expect(R).ToBe<never>()
+  Expect(R).ToStatic<never>()
 }
 {
   type A = { x: string; y: number }
@@ -128,7 +128,7 @@ import { Type, Static } from '@sinclair/typebox'
   const C = Type.Intersect([A, B])
   const R = Type.Index(C, ['y'])
   type O = Static<typeof R>
-  Expect(R).ToBe<number>()
+  Expect(R).ToStatic<number>()
 }
 {
   type A = { x: string; y: number }
@@ -141,7 +141,7 @@ import { Type, Static } from '@sinclair/typebox'
   const C = Type.Intersect([A, B])
   const R = Type.Index(C, ['x', 'y'])
   type O = Static<typeof R>
-  Expect(R).ToBe<number>()
+  Expect(R).ToStatic<number>()
 }
 {
   type A = { x: string; y: 1 }
@@ -158,7 +158,7 @@ import { Type, Static } from '@sinclair/typebox'
   const I = Type.Intersect([Type.Intersect([A, B]), Type.Intersect([C, D])])
   const R = Type.Index(I, ['x', 'y'])
   type O = Static<typeof R>
-  Expect(R).ToBe<string | 1>()
+  Expect(R).ToStatic<string | 1>()
 }
 {
   type A = { x: string; y: 1 }
@@ -175,7 +175,7 @@ import { Type, Static } from '@sinclair/typebox'
   const I = Type.Intersect([Type.Intersect([A, B]), Type.Intersect([C, D])])
   const R = Type.Index(I, ['x', 'y'])
   type O = Static<typeof R>
-  Expect(R).ToBe<1>()
+  Expect(R).ToStatic<1>()
 }
 {
   type A = { x: string; y: 1 }
@@ -192,7 +192,7 @@ import { Type, Static } from '@sinclair/typebox'
   const I = Type.Intersect([Type.Union([A, B]), Type.Intersect([C, D])])
   const R = Type.Index(I, ['x', 'y'])
   type O = Static<typeof R>
-  Expect(R).ToBe<number | string>()
+  Expect(R).ToStatic<number | string>()
 }
 {
   type A = { x: 'A'; y: 1 }
@@ -209,7 +209,7 @@ import { Type, Static } from '@sinclair/typebox'
   const I = Type.Union([A, B, C, D])
   const R = Type.Index(I, Type.Union([Type.Literal('x')]))
   type O = Static<typeof R>
-  Expect(R).ToBe<'A' | 'B' | 'C' | 'D'>()
+  Expect(R).ToStatic<'A' | 'B' | 'C' | 'D'>()
 }
 {
   type I = {
@@ -227,7 +227,7 @@ import { Type, Static } from '@sinclair/typebox'
   )
   const R = Type.Index(I, ['x', 'y', 'z']) // z unresolvable
   type O = Static<typeof R>
-  Expect(R).ToBe<string | number>()
+  Expect(R).ToStatic<string | number>()
 }
 // ------------------------------------------------
 // Numeric | String Variants
@@ -239,7 +239,7 @@ import { Type, Static } from '@sinclair/typebox'
   })
   const R = Type.Index(T, [0, '1'])
   type O = Static<typeof R>
-  Expect(R).ToBe<string | number>()
+  Expect(R).ToStatic<string | number>()
 }
 {
   const T = Type.Object({
@@ -248,5 +248,12 @@ import { Type, Static } from '@sinclair/typebox'
   })
   const R = Type.Index(T, Type.KeyOf(T))
   type O = Static<typeof R>
-  Expect(R).ToBe<string | number>()
+  Expect(R).ToStatic<string | number>()
+}
+{
+  const P = Type.Tuple([Type.Number(), Type.String()])
+  const R = Type.Object({
+    x: Type.Index(P, [0, 1]),
+  })
+  Expect(R).ToStatic<{ x: number | string }>()
 }
diff --git a/test/static/intersect.ts b/test/static/intersect.ts
index b7cf181b6..8fc36160e 100644
--- a/test/static/intersect.ts
+++ b/test/static/intersect.ts
@@ -12,7 +12,7 @@ import { Type, TOptional, TString, Static } from '@sinclair/typebox'
   })
   const T = Type.Intersect([A, B])
 
-  Expect(T).ToInfer<
+  Expect(T).ToStatic<
     {
       A: string
       B: string
@@ -32,8 +32,8 @@ import { Type, TOptional, TString, Static } from '@sinclair/typebox'
   })
   const T = Type.Intersect([A, B])
 
-  Expect(T.properties.A).ToBe<TOptional<TString>>()
-  Expect(T.properties.B).ToBe<TString>()
+  Expect(T.properties.A).ToStatic<TOptional<TString>>()
+  Expect(T.properties.B).ToStatic<TString>()
 }
 
 // https://github.com/sinclairzx81/typebox/issues/113
@@ -50,5 +50,5 @@ import { Type, TOptional, TString, Static } from '@sinclair/typebox'
   // invert equivelence (expect true both cases)
   type T1 = T extends { A: string } & ({ B: string } | { C: string }) ? true : false
   type T2 = { A: string } & ({ B: string } | { C: string }) extends T ? true : false
-  Expect(T).ToBe<{ A: string } & ({ B: string } | { C: string })>() // solved!
+  Expect(T).ToStatic<{ A: string } & ({ B: string } | { C: string })>() // solved!
 }
diff --git a/test/static/iterator.ts b/test/static/iterator.ts
index 4728ad035..5727f641f 100644
--- a/test/static/iterator.ts
+++ b/test/static/iterator.ts
@@ -1,4 +1,4 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.Iterator(Type.String())).ToInfer<IterableIterator<string>>()
+Expect(Type.Iterator(Type.String())).ToStatic<IterableIterator<string>>()
diff --git a/test/static/keyof.ts b/test/static/keyof.ts
index e5ad39fed..10d21df36 100644
--- a/test/static/keyof.ts
+++ b/test/static/keyof.ts
@@ -9,7 +9,7 @@ import { Type } from '@sinclair/typebox'
       C: Type.Null(),
     }),
   )
-  Expect(K).ToInfer<'A' | 'B' | 'C'>()
+  Expect(K).ToStatic<'A' | 'B' | 'C'>()
 }
 
 {
@@ -24,7 +24,7 @@ import { Type } from '@sinclair/typebox'
 
   const K = Type.KeyOf(T)
 
-  Expect(K).ToInfer<'A' | 'B'>()
+  Expect(K).ToStatic<'A' | 'B'>()
 }
 
 {
@@ -39,7 +39,7 @@ import { Type } from '@sinclair/typebox'
 
   const K = Type.KeyOf(T)
 
-  Expect(K).ToInfer<'C'>()
+  Expect(K).ToStatic<'C'>()
 }
 
 {
@@ -53,7 +53,7 @@ import { Type } from '@sinclair/typebox'
       ['A', 'B'],
     ),
   )
-  Expect(T).ToInfer<'C'>()
+  Expect(T).ToStatic<'C'>()
 }
 {
   {
@@ -70,13 +70,13 @@ import { Type } from '@sinclair/typebox'
 
     const K1 = Type.KeyOf(T)
 
-    Expect(K1).ToInfer<'type' | 'x' | 'y' | 'z'>()
+    Expect(K1).ToStatic<'type' | 'x' | 'y' | 'z'>()
 
     const P = Type.Omit(T, ['type', 'x'])
 
     const K2 = Type.KeyOf(P)
 
-    Expect(K2).ToInfer<'y' | 'z'>()
+    Expect(K2).ToStatic<'y' | 'z'>()
   }
 }
 {
@@ -89,7 +89,7 @@ import { Type } from '@sinclair/typebox'
     }),
   )
   const K = Type.KeyOf(T)
-  Expect(K).ToInfer<'a' | 'b' | 'c' | 'd'>()
+  Expect(K).ToStatic<'a' | 'b' | 'c' | 'd'>()
 }
 {
   const T = Type.Object({
@@ -98,5 +98,5 @@ import { Type } from '@sinclair/typebox'
     c: Type.Optional(Type.String()),
   })
   const K = Type.KeyOf(T)
-  Expect(K).ToInfer<'a' | 'b' | 'c'>()
+  Expect(K).ToStatic<'a' | 'b' | 'c'>()
 }
diff --git a/test/static/literal.ts b/test/static/literal.ts
index 461f43475..8a76ffd4f 100644
--- a/test/static/literal.ts
+++ b/test/static/literal.ts
@@ -1,8 +1,8 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.Literal('hello')).ToInfer<'hello'>()
+Expect(Type.Literal('hello')).ToStatic<'hello'>()
 
-Expect(Type.Literal(true)).ToInfer<true>()
+Expect(Type.Literal(true)).ToStatic<true>()
 
-Expect(Type.Literal(42)).ToInfer<42>()
+Expect(Type.Literal(42)).ToStatic<42>()
diff --git a/test/static/lowercase.ts b/test/static/lowercase.ts
index 78c7f7a84..f04ce5ece 100644
--- a/test/static/lowercase.ts
+++ b/test/static/lowercase.ts
@@ -1,14 +1,14 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.Lowercase(Type.Literal('HELLO'))).ToInfer<'hello'>()
+Expect(Type.Lowercase(Type.Literal('HELLO'))).ToStatic<'hello'>()
 
-Expect(Type.Lowercase(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD')]))).ToInfer<'hello' | 'world'>()
+Expect(Type.Lowercase(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD')]))).ToStatic<'hello' | 'world'>()
 
-Expect(Type.Lowercase(Type.TemplateLiteral('HELLO${0|1}'))).ToInfer<'hello0' | 'hello1'>()
+Expect(Type.Lowercase(Type.TemplateLiteral('HELLO${0|1}'))).ToStatic<'hello0' | 'hello1'>()
 
 // prettier-ignore
-Expect(Type.Lowercase(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(1), Type.Literal(2)])]))).ToBe<'hello1' | 'hello2'>()
+Expect(Type.Lowercase(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(1), Type.Literal(2)])]))).ToStatic<'hello1' | 'hello2'>()
 
 // passthrough
-Expect(Type.Lowercase(Type.Object({ x: Type.Number() }))).ToInfer<{ x: number }>()
+Expect(Type.Lowercase(Type.Object({ x: Type.Number() }))).ToStatic<{ x: number }>()
diff --git a/test/static/modifier.ts b/test/static/modifier.ts
index 07186f6d2..cb108b6d3 100644
--- a/test/static/modifier.ts
+++ b/test/static/modifier.ts
@@ -9,7 +9,7 @@ import { Type, TSchema } from '@sinclair/typebox'
     C: Type.Optional(Type.String()),
     D: Type.String(),
   })
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     readonly A?: string
     readonly B: string
     C?: string
diff --git a/test/static/never.ts b/test/static/never.ts
index 5eae99bec..8261621e6 100644
--- a/test/static/never.ts
+++ b/test/static/never.ts
@@ -3,5 +3,5 @@ import { Type } from '@sinclair/typebox'
 
 {
   const T = Type.Never()
-  Expect(T).ToInfer<never>()
+  Expect(T).ToStatic<never>()
 }
diff --git a/test/static/not.ts b/test/static/not.ts
index de3abbf7d..5c95fa0ce 100644
--- a/test/static/not.ts
+++ b/test/static/not.ts
@@ -14,13 +14,13 @@ import { Type } from '@sinclair/typebox'
   const A = Type.Number()
   const B = Type.Not(Type.Number())
   const T = Type.Extends(A, B, Type.Literal(true), Type.Literal(false))
-  Expect(T).ToInfer<true>()
+  Expect(T).ToStatic<true>()
 }
 {
   const T = Type.Not(Type.Number())
-  Expect(T).ToInfer<unknown>()
+  Expect(T).ToStatic<unknown>()
 }
 {
   const T = Type.Not(Type.Not(Type.Number()))
-  Expect(T).ToInfer<number>()
+  Expect(T).ToStatic<number>()
 }
diff --git a/test/static/null.ts b/test/static/null.ts
index 36993ffe3..50f474bec 100644
--- a/test/static/null.ts
+++ b/test/static/null.ts
@@ -1,4 +1,4 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.Null()).ToInfer<null>()
+Expect(Type.Null()).ToStatic<null>()
diff --git a/test/static/number.ts b/test/static/number.ts
index 2b1717110..17a41ee5c 100644
--- a/test/static/number.ts
+++ b/test/static/number.ts
@@ -1,4 +1,4 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.Number()).ToInfer<number>()
+Expect(Type.Number()).ToStatic<number>()
diff --git a/test/static/object.ts b/test/static/object.ts
index c9d57419c..d7f4b0ef5 100644
--- a/test/static/object.ts
+++ b/test/static/object.ts
@@ -8,7 +8,7 @@ import { Type } from '@sinclair/typebox'
     C: Type.String(),
   })
 
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A: string
     B: string
     C: string
@@ -32,7 +32,7 @@ import { Type } from '@sinclair/typebox'
       C: Type.String(),
     }),
   })
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A: {
       A: string
       B: string
@@ -62,7 +62,7 @@ import { Type } from '@sinclair/typebox'
     },
   )
   // note: Pending TypeScript support for negated types.
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A: number
     B: number
     C: number
diff --git a/test/static/omit.ts b/test/static/omit.ts
index 98b93ba57..7b1bb5644 100644
--- a/test/static/omit.ts
+++ b/test/static/omit.ts
@@ -12,7 +12,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     C: string
   }>()
 }
@@ -30,7 +30,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     C: string
   }>()
 }
@@ -50,7 +50,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     C: string
   }>()
 }
@@ -66,7 +66,7 @@ import { Type, Static } from '@sinclair/typebox'
   })
   const T = Type.Intersect([Union, Extended])
 
-  Expect(T).ToInfer<
+  Expect(T).ToStatic<
     (
       | {
           type: 'A'
@@ -86,7 +86,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   const P = Type.Omit(T, ['type', 'x'])
 
-  Expect(P).ToInfer<
+  Expect(P).ToStatic<
     ({} | {} | {}) & {
       y: number
       z: number
@@ -95,7 +95,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   const O = Type.Partial(P)
 
-  Expect(O).ToInfer<
+  Expect(O).ToStatic<
     ({} | {} | {}) & {
       y?: number | undefined
       z?: number | undefined
diff --git a/test/static/optional.ts b/test/static/optional.ts
index aba6c4e8c..b3342692a 100644
--- a/test/static/optional.ts
+++ b/test/static/optional.ts
@@ -8,7 +8,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A?: string
   }>()
 }
diff --git a/test/static/parameters.ts b/test/static/parameters.ts
index 02ad9c989..439ee9efe 100644
--- a/test/static/parameters.ts
+++ b/test/static/parameters.ts
@@ -10,4 +10,4 @@ const C = Type.Function(
 
 const P = Type.Parameters(C)
 
-Expect(P).ToInfer<[number, string]>()
+Expect(P).ToStatic<[number, string]>()
diff --git a/test/static/partial.ts b/test/static/partial.ts
index a9e591f94..d0d075a84 100644
--- a/test/static/partial.ts
+++ b/test/static/partial.ts
@@ -11,7 +11,7 @@ import { Type, Static } from '@sinclair/typebox'
   )
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A?: string
     B?: string
     C?: string
@@ -31,7 +31,7 @@ import { Type, Static } from '@sinclair/typebox'
 
     const T = Type.Intersect([Union, Extended])
 
-    Expect(T).ToInfer<
+    Expect(T).ToStatic<
       (
         | {
             type: 'A'
@@ -51,7 +51,7 @@ import { Type, Static } from '@sinclair/typebox'
 
     const P = Type.Partial(T)
 
-    Expect(P).ToInfer<
+    Expect(P).ToStatic<
       (
         | {
             type?: 'A' | undefined
diff --git a/test/static/pick.ts b/test/static/pick.ts
index f9d825571..de29ba4bb 100644
--- a/test/static/pick.ts
+++ b/test/static/pick.ts
@@ -12,7 +12,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A: string
     B: string
   }>()
@@ -31,7 +31,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A: string
     B: string
   }>()
@@ -52,7 +52,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A: string
     B: string
   }>()
@@ -69,7 +69,7 @@ import { Type, Static } from '@sinclair/typebox'
   })
   const T = Type.Intersect([Union, Extended])
 
-  Expect(T).ToInfer<
+  Expect(T).ToStatic<
     (
       | {
           type: 'A'
@@ -89,11 +89,11 @@ import { Type, Static } from '@sinclair/typebox'
 
   const K = Type.KeyOf(T)
 
-  Expect(K).ToInfer<'type' | 'x' | 'y' | 'z'>()
+  Expect(K).ToStatic<'type' | 'x' | 'y' | 'z'>()
 
   const P = Type.Pick(T, ['type', 'x'])
 
-  Expect(P).ToInfer<
+  Expect(P).ToStatic<
     (
       | {
           type: 'A'
@@ -111,7 +111,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   const O = Type.Partial(P)
 
-  Expect(O).ToInfer<
+  Expect(O).ToStatic<
     (
       | {
           type?: 'A' | undefined
diff --git a/test/static/readonly-optional.ts b/test/static/readonly-optional.ts
index 377cab0cf..3191dcd75 100644
--- a/test/static/readonly-optional.ts
+++ b/test/static/readonly-optional.ts
@@ -5,7 +5,7 @@ import { Type, TSchema } from '@sinclair/typebox'
   const T = Type.Object({
     A: Type.ReadonlyOptional(Type.String()),
   })
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     readonly A?: string
   }>()
 }
diff --git a/test/static/readonly.ts b/test/static/readonly.ts
index 6cce5ebb3..4d1668346 100644
--- a/test/static/readonly.ts
+++ b/test/static/readonly.ts
@@ -8,7 +8,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     readonly A: string
   }>()
 }
diff --git a/test/static/record.ts b/test/static/record.ts
index 7338d5f26..a314c46ff 100644
--- a/test/static/record.ts
+++ b/test/static/record.ts
@@ -6,29 +6,29 @@ import { Type, Static } from '@sinclair/typebox'
   const T = Type.Record(K, Type.Number())
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<Record<string, number>>()
+  Expect(T).ToStatic<Record<string, number>>()
 }
 {
   // type K = string
   const K = Type.RegExp(/foo|bar/)
   const T = Type.Record(K, Type.Number())
   type T = Static<typeof T>
-  Expect(T).ToInfer<Record<string, number>>()
+  Expect(T).ToStatic<Record<string, number>>()
 }
 {
   // type K = number
   const K = Type.Number()
   const T = Type.Record(K, Type.Number())
   type T = Static<typeof T>
-  Expect(T).ToInfer<Record<string, number>>()
-  Expect(T).ToInfer<Record<number, number>>()
+  Expect(T).ToStatic<Record<string, number>>()
+  Expect(T).ToStatic<Record<number, number>>()
 }
 {
   // type K = 'A' | 'B' | 'C'
   const K = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
   const T = Type.Record(K, Type.Number())
   type T = Static<typeof T>
-  Expect(T).ToInfer<Record<'A' | 'B' | 'C', number>>()
+  Expect(T).ToStatic<Record<'A' | 'B' | 'C', number>>()
 }
 {
   // type K = keyof { A: number, B: number, C: number }
@@ -41,7 +41,7 @@ import { Type, Static } from '@sinclair/typebox'
   )
   const T = Type.Record(K, Type.Number())
   type T = Static<typeof T>
-  Expect(T).ToInfer<Record<'A' | 'B' | 'C', number>>()
+  Expect(T).ToStatic<Record<'A' | 'B' | 'C', number>>()
 }
 {
   // type K = keyof Omit<{ A: number, B: number, C: number }, 'C'>
@@ -57,16 +57,16 @@ import { Type, Static } from '@sinclair/typebox'
   )
   const T = Type.Record(K, Type.Number())
   type T = Static<typeof T>
-  Expect(T).ToInfer<Record<'A' | 'B', number>>()
+  Expect(T).ToStatic<Record<'A' | 'B', number>>()
 }
 
 {
   const T = Type.Record(Type.Number(), Type.String())
 
-  Expect(T).ToInfer<Record<number, string>>()
+  Expect(T).ToStatic<Record<number, string>>()
 }
 {
   const T = Type.Record(Type.Integer(), Type.String())
 
-  Expect(T).ToInfer<Record<number, string>>()
+  Expect(T).ToStatic<Record<number, string>>()
 }
diff --git a/test/static/recursive.ts b/test/static/recursive.ts
index 06ca5d025..7f79ab6f5 100644
--- a/test/static/recursive.ts
+++ b/test/static/recursive.ts
@@ -10,7 +10,7 @@ import { Type, Static } from '@sinclair/typebox'
     }),
   )
   type T = Static<typeof R>
-  Expect(R).ToInfer<{ id: string; nodes: T[] }>()
+  Expect(R).ToStatic<{ id: string; nodes: T[] }>()
 }
 {
   // keyof
@@ -21,7 +21,7 @@ import { Type, Static } from '@sinclair/typebox'
     }),
   )
   const T = Type.KeyOf(R)
-  Expect(T).ToInfer<'id' | 'nodes'>()
+  Expect(T).ToStatic<'id' | 'nodes'>()
 }
 {
   // partial
@@ -32,7 +32,7 @@ import { Type, Static } from '@sinclair/typebox'
     }),
   )
   const T = Type.Partial(R)
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     id: string | undefined
     nodes: Static<typeof T>[] | undefined
   }>()
@@ -47,7 +47,7 @@ import { Type, Static } from '@sinclair/typebox'
   )
   const P = Type.Partial(R)
   const T = Type.Required(P)
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     id: string
     nodes: Static<typeof T>[]
   }>()
@@ -61,7 +61,7 @@ import { Type, Static } from '@sinclair/typebox'
     }),
   )
   const T = Type.Pick(R, ['id'])
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     id: string
   }>()
 }
@@ -74,7 +74,7 @@ import { Type, Static } from '@sinclair/typebox'
     }),
   )
   const T = Type.Omit(R, ['id'])
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     nodes: Static<typeof T>[]
   }>()
 }
diff --git a/test/static/ref.ts b/test/static/ref.ts
index c4abe3675..47ccd9b29 100644
--- a/test/static/ref.ts
+++ b/test/static/ref.ts
@@ -8,6 +8,6 @@ import { Type, Static } from '@sinclair/typebox'
   type T = Static<typeof T>
   type R = Static<typeof R>
 
-  Expect(T).ToInfer<string>()
-  Expect(R).ToInfer<string>()
+  Expect(T).ToStatic<string>()
+  Expect(R).ToStatic<string>()
 }
diff --git a/test/static/regexp.ts b/test/static/regexp.ts
index 60feac2af..7f9413071 100644
--- a/test/static/regexp.ts
+++ b/test/static/regexp.ts
@@ -1,4 +1,4 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.RegExp(/foo/)).ToInfer<string>()
+Expect(Type.RegExp(/foo/)).ToStatic<string>()
diff --git a/test/static/required.ts b/test/static/required.ts
index d688584b1..cbf9fd4e4 100644
--- a/test/static/required.ts
+++ b/test/static/required.ts
@@ -11,7 +11,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A: string
     B: string
     C: string
@@ -32,7 +32,7 @@ import { Type, Static } from '@sinclair/typebox'
 
     const P = Type.Partial(T)
 
-    Expect(P).ToInfer<
+    Expect(P).ToStatic<
       (
         | {
             type?: 'A' | undefined
@@ -52,7 +52,7 @@ import { Type, Static } from '@sinclair/typebox'
 
     const R = Type.Required(P)
 
-    Expect(R).ToInfer<
+    Expect(R).ToStatic<
       (
         | {
             type: 'A'
diff --git a/test/static/rest.ts b/test/static/rest.ts
index 129e22aa4..4f2bba7f0 100644
--- a/test/static/rest.ts
+++ b/test/static/rest.ts
@@ -1,36 +1,52 @@
 import { Expect } from './assert'
 import { Type, Static } from '@sinclair/typebox'
-
 {
-  const A = Type.Tuple([Type.Literal(1), Type.Literal(2)])
-  const B = Type.Tuple([Type.Literal(3), Type.Literal(4)])
-  const C = Type.Tuple([...Type.Rest(A), ...Type.Rest(B)])
-  Expect(C).ToInfer<[1, 2, 3, 4]>()
+  // union never
+  const A = Type.String()
+  const B = Type.Union(Type.Rest(A))
+  Expect(B).ToStatic<never>()
 }
 {
+  // intersect never
   const A = Type.String()
-  const B = Type.Tuple([Type.Literal(3), Type.Literal(4)])
-  const C = Type.Tuple([...Type.Rest(A), ...Type.Rest(B)])
-  Expect(C).ToInfer<[string, 3, 4]>()
+  const B = Type.Intersect(Type.Rest(A))
+  Expect(B).ToStatic<never>()
 }
 {
-  const A = Type.Tuple([Type.Literal(1), Type.Literal(2)])
-  const B = Type.String()
-  const C = Type.Tuple([...Type.Rest(A), ...Type.Rest(B)])
-  Expect(C).ToInfer<[1, 2, string]>()
+  // tuple
+  const A = Type.Tuple([Type.Number(), Type.String()])
+  const B = Type.Union(Type.Rest(A))
+  Expect(B).ToStatic<string | number>()
 }
 {
+  // tuple spread
   const A = Type.Tuple([Type.Literal(1), Type.Literal(2)])
-  const B = Type.Union(Type.Rest(A))
-  Expect(B).ToInfer<1 | 2>()
+  const B = Type.Tuple([Type.Literal(3), Type.Literal(4)])
+  const C = Type.Tuple([...Type.Rest(A), ...Type.Rest(B)])
+  Expect(C).ToStatic<[1, 2, 3, 4]>()
 }
 {
-  const A = Type.Tuple([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
-  const B = Type.Intersect(Type.Rest(A))
-  Expect(B).ToInfer<{ x: number } & { y: number }>()
+  // union to intersect
+  const A = Type.Object({ x: Type.Number() })
+  const B = Type.Object({ y: Type.String() })
+  const C = Type.Union([A, B])
+  const D = Type.Intersect(Type.Rest(C))
+  Expect(D).ToStatic<
+    {
+      x: number
+    } & {
+      y: string
+    }
+  >()
 }
 {
-  const A = Type.Tuple([Type.Literal(1), Type.Literal(2)])
-  const B = Type.Function(Type.Rest(A), Type.Null())
-  Expect(B).ToInfer<(a: 1, b: 2) => null>()
+  // intersect to composite
+  const A = Type.Object({ x: Type.Number() })
+  const B = Type.Object({ y: Type.String() })
+  const C = Type.Intersect([A, B])
+  const D = Type.Composite(Type.Rest(C))
+  Expect(D).ToStatic<{
+    x: number
+    y: string
+  }>()
 }
diff --git a/test/static/return-type.ts b/test/static/return-type.ts
index d394484ee..aa463509b 100644
--- a/test/static/return-type.ts
+++ b/test/static/return-type.ts
@@ -6,7 +6,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<string>()
+  Expect(T).ToStatic<string>()
 }
 
 {
@@ -14,5 +14,5 @@ import { Type, Static } from '@sinclair/typebox'
 
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<number>()
+  Expect(T).ToStatic<number>()
 }
diff --git a/test/static/strict.ts b/test/static/strict.ts
index a389c8963..a6a0ebcac 100644
--- a/test/static/strict.ts
+++ b/test/static/strict.ts
@@ -12,7 +12,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<{
+  Expect(T).ToStatic<{
     A: string
     B: string
     C: string
diff --git a/test/static/string.ts b/test/static/string.ts
index 5f21e625b..609dad5ad 100644
--- a/test/static/string.ts
+++ b/test/static/string.ts
@@ -1,4 +1,4 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.String()).ToInfer<string>()
+Expect(Type.String()).ToStatic<string>()
diff --git a/test/static/symbol.ts b/test/static/symbol.ts
index 633541438..13c8c6aeb 100644
--- a/test/static/symbol.ts
+++ b/test/static/symbol.ts
@@ -1,4 +1,4 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.Symbol()).ToInfer<symbol>()
+Expect(Type.Symbol()).ToStatic<symbol>()
diff --git a/test/static/template-literal.ts b/test/static/template-literal.ts
index 1b8ebf3b1..f0ec8444e 100644
--- a/test/static/template-literal.ts
+++ b/test/static/template-literal.ts
@@ -4,43 +4,43 @@ import { Type } from '@sinclair/typebox'
 {
   // Empty
   const T = Type.TemplateLiteral([])
-  Expect(T).ToInfer<''>()
+  Expect(T).ToStatic<''>()
 }
 {
   // Literal
   const T = Type.TemplateLiteral([Type.Literal('hello')])
-  Expect(T).ToInfer<'hello'>()
+  Expect(T).ToStatic<'hello'>()
 }
 {
   // And Sequence
   const T = Type.TemplateLiteral([Type.Literal('hello'), Type.Literal('world')])
-  Expect(T).ToInfer<'helloworld'>()
+  Expect(T).ToStatic<'helloworld'>()
 }
 {
   // And / Or Sequence
   const T = Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal('1'), Type.Literal('2')])])
-  Expect(T).ToInfer<'hello1' | 'hello2'>()
+  Expect(T).ToStatic<'hello1' | 'hello2'>()
 }
 {
   // Auxiliary Template
   const A = Type.TemplateLiteral([Type.Union([Type.Literal('1'), Type.Literal('2')])])
   const T = Type.TemplateLiteral([Type.Literal('hello'), A])
-  Expect(T).ToInfer<'hello1' | 'hello2'>()
+  Expect(T).ToStatic<'hello1' | 'hello2'>()
 }
 {
   // String
   const T = Type.TemplateLiteral([Type.String()])
-  Expect(T).ToInfer<`${string}`>()
+  Expect(T).ToStatic<`${string}`>()
 }
 {
   // Number
   const T = Type.TemplateLiteral([Type.Number()])
-  Expect(T).ToInfer<`${number}`>()
+  Expect(T).ToStatic<`${number}`>()
 }
 {
   // Boolean
   const T = Type.TemplateLiteral([Type.Boolean()])
-  Expect(T).ToInfer<`${boolean}`>()
+  Expect(T).ToStatic<`${boolean}`>()
 }
 {
   // Enum Implicit
@@ -51,7 +51,7 @@ import { Type } from '@sinclair/typebox'
   }
   const A = Type.Enum(E)
   const T = Type.TemplateLiteral([Type.Literal('hello'), A])
-  Expect(T).ToInfer<'hello0' | 'hello1' | 'hello2'>()
+  Expect(T).ToStatic<'hello0' | 'hello1' | 'hello2'>()
 }
 {
   // Enum Explicit
@@ -62,11 +62,11 @@ import { Type } from '@sinclair/typebox'
   }
   const A = Type.Enum(E)
   const T = Type.TemplateLiteral([Type.Literal('hello'), A])
-  Expect(T).ToInfer<'hello0' | 'helloB' | 'helloC'>()
+  Expect(T).ToStatic<'hello0' | 'helloB' | 'helloC'>()
 }
 {
   // Enum Object Explicit
   const A = Type.Enum(Object.freeze({ a: 'A', b: 'B' }))
   const T = Type.TemplateLiteral([Type.Literal('hello'), A])
-  Expect(T).ToInfer<'helloA' | 'helloB'>()
+  Expect(T).ToStatic<'helloA' | 'helloB'>()
 }
diff --git a/test/static/transform.ts b/test/static/transform.ts
new file mode 100644
index 000000000..99e7e067a
--- /dev/null
+++ b/test/static/transform.ts
@@ -0,0 +1,184 @@
+import { Type, Static, StaticDecode, TObject, TNumber } from '@sinclair/typebox'
+import { Expect } from './assert'
+{
+  // string > number
+  const T = Type.Transform(Type.Number())
+    .Decode((value) => value.toString())
+    .Encode((value) => parseFloat(value))
+
+  Expect(T).ToStaticDecode<string>()
+  Expect(T).ToStaticEncode<number>()
+  Expect(T).ToStatic<number>()
+}
+{
+  // boolean > union
+  const T = Type.Transform(Type.Boolean())
+    .Decode((value) => (value ? (1 as const) : (2 as const)))
+    .Encode((value) => true)
+
+  Expect(T).ToStatic<boolean>()
+  Expect(T).ToStaticDecode<1 | 2>()
+  Expect(T).ToStaticEncode<boolean>()
+}
+{
+  // literal > union
+  const T = Type.Transform(Type.Union([Type.Literal(1), Type.Literal(2)]))
+    .Decode((value) => true as const)
+    .Encode((value) => (value ? (1 as const) : (2 as const)))
+  Expect(T).ToStatic<1 | 2>()
+  Expect(T).ToStaticDecode<true>()
+  Expect(T).ToStaticEncode<1 | 2>()
+}
+{
+  // nested: 1 > 2 > 3
+  const T1 = Type.Transform(Type.Literal(1))
+    .Decode((value) => 2 as const)
+    .Encode((value) => 1 as const)
+
+  const T2 = Type.Transform(T1)
+    .Decode((value) => 3 as const)
+    .Encode((value) => 2 as const)
+
+  Expect(T1).ToStatic<1>()
+  Expect(T1).ToStaticDecode<2>()
+  Expect(T1).ToStaticEncode<1>()
+
+  Expect(T2).ToStatic<2>() // resolve to base
+  Expect(T2).ToStaticDecode<3>()
+  Expect(T2).ToStaticEncode<2>()
+}
+{
+  // nested: 1 > 2 > 3 > 4
+  const T1 = Type.Transform(Type.Literal(1))
+    .Decode((value) => 2 as const)
+    .Encode((value) => 1 as const)
+
+  const T2 = Type.Transform(T1)
+    .Decode((value) => 3 as const)
+    .Encode((value) => 2 as const)
+
+  const T3 = Type.Transform(T2)
+    .Decode((value) => 4 as const)
+    .Encode((value) => 3 as const)
+
+  Expect(T1).ToStatic<1>()
+  Expect(T1).ToStaticDecode<2>()
+  Expect(T1).ToStaticEncode<1>()
+
+  Expect(T2).ToStatic<2>()
+  Expect(T2).ToStaticDecode<3>()
+  Expect(T2).ToStaticEncode<2>()
+
+  Expect(T3).ToStatic<3>()
+  Expect(T3).ToStaticDecode<4>()
+  Expect(T3).ToStaticEncode<3>()
+}
+{
+  // recursive > 1
+  // prettier-ignore
+  const T = Type.Transform(Type.Recursive(This => Type.Object({
+    id: Type.String(),
+    nodes: Type.Array(This)
+  })))
+    .Decode((value) => 1 as const)
+    .Encode((value) => ({
+      id: 'A',
+      nodes: [
+        { id: 'B', nodes: [] }, 
+        { id: 'C', nodes: [] }
+      ]
+    }))
+
+  interface N {
+    id: string
+    nodes: this[]
+  }
+  Expect(T).ToStatic<N>()
+  Expect(T).ToStaticDecode<1>()
+  Expect(T).ToStaticEncode<N>()
+}
+{
+  // recursive > 1 > 2
+  interface N {
+    id: string
+    nodes: this[]
+  }
+  // prettier-ignore
+  const T1 = Type.Transform(Type.Recursive(This => Type.Object({
+    id: Type.String(),
+    nodes: Type.Array(This)
+  })))
+    .Decode((value) => 1 as const)
+    .Encode((value) => ({
+      id: 'A',
+      nodes: [
+        { id: 'B', nodes: [] }, 
+        { id: 'C', nodes: [] }
+      ]
+    }))
+
+  const T2 = Type.Transform(T1)
+    .Decode((value) => 2 as const)
+    .Encode((value) => 1 as const)
+
+  Expect(T1).ToStatic<N>()
+  Expect(T1).ToStaticDecode<1>()
+  Expect(T1).ToStaticEncode<N>()
+
+  Expect(T2).ToStatic<1>()
+  Expect(T2).ToStaticDecode<2>()
+  Expect(T2).ToStaticEncode<1>()
+}
+{
+  // deep-nesting
+  // prettier-ignore
+  const T = Type.Transform(Type.Transform(Type.Transform(Type.Transform(Type.Transform(Type.Transform(Type.Transform(Type.Transform(Type.Transform(Type.Literal(1))
+  .Decode((value) => value)
+  .Encode((value) => value))
+  .Decode((value) => value)
+  .Encode((value) => value))
+  .Decode((value) => value)
+  .Encode((value) => value))
+  .Decode((value) => value)
+  .Encode((value) => value))
+  .Decode((value) => value)
+  .Encode((value) => value))
+  .Decode((value) => value)
+  .Encode((value) => value))
+  .Decode((value) => value)
+  .Encode((value) => value))
+  .Decode((value) => value)
+  .Encode((value) => value))
+  .Decode((value) => value)
+  .Encode((value) => value)
+
+  Expect(T).ToStatic<1>()
+  Expect(T).ToStaticDecode<1>()
+  Expect(T).ToStaticEncode<1>()
+}
+{
+  // null to typebox type
+  // prettier-ignore
+  const T = Type.Transform(Type.Null())
+    .Decode(value => Type.Object({ 
+      x: Type.Number(), 
+      y: Type.Number(),
+      z: Type.Number()
+    }))
+    .Encode(value => null)
+  Expect(T).ToStatic<null>()
+  Expect(T).ToStaticDecode<
+    TObject<{
+      x: TNumber
+      y: TNumber
+      z: TNumber
+    }>
+  >()
+  Expect(T).ToStaticEncode<null>()
+  type T = StaticDecode<typeof T>
+  type S = Static<T> // type S = {
+  //   x: number;
+  //   y: number;
+  //   z: number;
+  // } // lol
+}
diff --git a/test/static/tuple.ts b/test/static/tuple.ts
index 2ced852bc..61fde9821 100644
--- a/test/static/tuple.ts
+++ b/test/static/tuple.ts
@@ -6,5 +6,5 @@ import { Type, Static } from '@sinclair/typebox'
 
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<[number, string, boolean]>()
+  Expect(T).ToStatic<[number, string, boolean]>()
 }
diff --git a/test/static/uncapitalize.ts b/test/static/uncapitalize.ts
index a52d0c023..226504b94 100644
--- a/test/static/uncapitalize.ts
+++ b/test/static/uncapitalize.ts
@@ -1,14 +1,14 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.Uncapitalize(Type.Literal('HELLO'))).ToInfer<'hELLO'>()
+Expect(Type.Uncapitalize(Type.Literal('HELLO'))).ToStatic<'hELLO'>()
 
-Expect(Type.Uncapitalize(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD')]))).ToInfer<'hELLO' | 'wORLD'>()
+Expect(Type.Uncapitalize(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD')]))).ToStatic<'hELLO' | 'wORLD'>()
 
-Expect(Type.Uncapitalize(Type.TemplateLiteral('HELLO${0|1}'))).ToInfer<'hELLO0' | 'hELLO1'>()
+Expect(Type.Uncapitalize(Type.TemplateLiteral('HELLO${0|1}'))).ToStatic<'hELLO0' | 'hELLO1'>()
 
 // prettier-ignore
-Expect(Type.Uncapitalize(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(1), Type.Literal(2)])]))).ToBe<'hELLO1' | 'hELLO2'>()
+Expect(Type.Uncapitalize(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(1), Type.Literal(2)])]))).ToStatic<'hELLO1' | 'hELLO2'>()
 
 // passthrough
-Expect(Type.Uncapitalize(Type.Object({ x: Type.Number() }))).ToInfer<{ x: number }>()
+Expect(Type.Uncapitalize(Type.Object({ x: Type.Number() }))).ToStatic<{ x: number }>()
diff --git a/test/static/union.ts b/test/static/union.ts
index 114d685fc..3529e5465 100644
--- a/test/static/union.ts
+++ b/test/static/union.ts
@@ -8,7 +8,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<string | number>()
+  Expect(T).ToStatic<string | number>()
 }
 {
   const A = Type.Object({
@@ -23,7 +23,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<
+  Expect(T).ToStatic<
     | {
         A: string
         B: string
@@ -48,7 +48,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   type T = Static<typeof T>
 
-  Expect(T).ToInfer<
+  Expect(T).ToStatic<
     | {
         A: string
         B: string
@@ -69,5 +69,5 @@ import { Type, Static } from '@sinclair/typebox'
 
 {
   const T = Type.Union([])
-  Expect(T).ToInfer<never>()
+  Expect(T).ToStatic<never>()
 }
diff --git a/test/static/unknown.ts b/test/static/unknown.ts
index 28168a2a4..0ff2e5d81 100644
--- a/test/static/unknown.ts
+++ b/test/static/unknown.ts
@@ -1,4 +1,4 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.Unknown()).ToInfer<unknown>()
+Expect(Type.Unknown()).ToStatic<unknown>()
diff --git a/test/static/uppercase.ts b/test/static/uppercase.ts
index dafde13c6..2341feab6 100644
--- a/test/static/uppercase.ts
+++ b/test/static/uppercase.ts
@@ -1,14 +1,14 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-Expect(Type.Uppercase(Type.Literal('hello'))).ToInfer<'HELLO'>()
+Expect(Type.Uppercase(Type.Literal('hello'))).ToStatic<'HELLO'>()
 
-Expect(Type.Uppercase(Type.Union([Type.Literal('hello'), Type.Literal('world')]))).ToInfer<'HELLO' | 'WORLD'>()
+Expect(Type.Uppercase(Type.Union([Type.Literal('hello'), Type.Literal('world')]))).ToStatic<'HELLO' | 'WORLD'>()
 
-Expect(Type.Uppercase(Type.TemplateLiteral('HELLO${0|1}'))).ToInfer<'HELLO0' | 'HELLO1'>()
+Expect(Type.Uppercase(Type.TemplateLiteral('HELLO${0|1}'))).ToStatic<'HELLO0' | 'HELLO1'>()
 
 // prettier-ignore
-Expect(Type.Uppercase(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(1), Type.Literal(2)])]))).ToBe<'HELLO1' | 'HELLO2'>()
+Expect(Type.Uppercase(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(1), Type.Literal(2)])]))).ToStatic<'HELLO1' | 'HELLO2'>()
 
 // passthrough
-Expect(Type.Uppercase(Type.Object({ x: Type.Number() }))).ToInfer<{ x: number }>()
+Expect(Type.Uppercase(Type.Object({ x: Type.Number() }))).ToStatic<{ x: number }>()
diff --git a/tsconfig.json b/tsconfig.json
index 41a696de3..ec148af39 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -49,6 +49,9 @@
       "@sinclair/typebox/value/pointer": [
         "src/value/pointer.ts"
       ],
+      "@sinclair/typebox/value/transform": [
+        "src/value/transform/index.ts"
+      ],
       "@sinclair/typebox/value": [
         "src/value/index.ts"
       ],

From 824bd8821a8934725b791abda40079c099f6f7da Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 14 Aug 2023 12:44:55 +0900
Subject: [PATCH 173/369] Revision 0.31.1 (#533)

---
 package.json                            |  2 +-
 readme.md                               |  6 +-
 src/value/transform.ts                  |  4 +-
 test/runtime/compiler/constructor.ts    | 80 +++++++++++++++++++++++
 test/runtime/compiler/function.ts       | 25 +++++++
 test/runtime/compiler/index.ts          |  2 +
 test/runtime/value/check/constructor.ts | 87 +++++++++++++++++++++++++
 test/runtime/value/check/function.ts    | 28 ++++++++
 test/runtime/value/check/index.ts       |  2 +
 9 files changed, 229 insertions(+), 7 deletions(-)
 create mode 100644 test/runtime/compiler/constructor.ts
 create mode 100644 test/runtime/compiler/function.ts
 create mode 100644 test/runtime/value/check/constructor.ts
 create mode 100644 test/runtime/value/check/function.ts

diff --git a/package.json b/package.json
index 295d4384e..fbe8febe3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.0",
+  "version": "0.31.1",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 4b80a0671..d19ccfd62 100644
--- a/readme.md
+++ b/readme.md
@@ -58,11 +58,9 @@ type T = Static<typeof T>                            // type T = {
 
 ## Overview
 
-TypeBox is a runtime type builder that creates Json Schema objects that infer as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript and runtime checked using standard Json Schema validation.
+TypeBox is a runtime type builder that creates Json Schema objects that infer as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript or runtime checked using standard Json Schema validation.
 
-TypeBox is designed to be a runtime type system based on industry standard specifications for use in distributed systems. It offers serializable and publishable types as standard, a fully extensible type system capable of supporting multiple schema specifications, a high performance runtime validation compiler, various tools for working with dynamic data and offers detailed structured error reporting.
-
-TypeBox can be used as a simple tool to build up complex schemas or integrated into applications to enable high performance runtime validation for data received over the wire.
+TypeBox is designed to be a runtime type system based on industry standard specifications. It offers serializable and publishable types as standard, a fully extensible type system capable of supporting multiple schema specifications, a high performance runtime validation compiler, various tools for working with dynamic data and offers detailed structured error reporting. It can either be used as a simple tool to build up complex schemas or integrated into applications to enable high performance runtime validation for data received over the wire.
 
 License MIT
 
diff --git a/src/value/transform.ts b/src/value/transform.ts
index e1608edab..12faf5834 100644
--- a/src/value/transform.ts
+++ b/src/value/transform.ts
@@ -76,10 +76,10 @@ export namespace HasTransform {
     return Types.TypeGuard.TTransform(schema) || Visit(schema.items, references)
   }
   function TConstructor(schema: Types.TConstructor, references: Types.TSchema[]) {
-    return Types.TypeGuard.TTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema.returns, references))
+    return Types.TypeGuard.TTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references))
   }
   function TFunction(schema: Types.TFunction, references: Types.TSchema[]) {
-    return Types.TypeGuard.TTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema.returns, references))
+    return Types.TypeGuard.TTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references))
   }
   function TIntersect(schema: Types.TIntersect, references: Types.TSchema[]) {
     return Types.TypeGuard.TTransform(schema) || Types.TypeGuard.TTransform(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references))
diff --git a/test/runtime/compiler/constructor.ts b/test/runtime/compiler/constructor.ts
new file mode 100644
index 000000000..324faf111
--- /dev/null
+++ b/test/runtime/compiler/constructor.ts
@@ -0,0 +1,80 @@
+import { Type } from '@sinclair/typebox'
+import { Ok, Fail } from './validate'
+
+describe('compiler/Constructor', () => {
+  it('Should validate constructor 1', () => {
+    const T = Type.Constructor([], Type.Object({}))
+    Ok(T, class {})
+  })
+  it('Should validate constructor 2', () => {
+    const T = Type.Constructor([Type.Number()], Type.Object({}))
+    // note: constructor arguments are non-checkable
+    Ok(T, class {})
+  })
+  it('Should validate constructor 3', () => {
+    const T = Type.Constructor(
+      [Type.Number()],
+      Type.Object({
+        method: Type.Function([], Type.Void()),
+      }),
+    )
+    Ok(
+      T,
+      class {
+        method() {}
+      },
+    )
+  })
+  it('Should validate constructor 4', () => {
+    const T = Type.Constructor(
+      [Type.Number()],
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+    )
+    Ok(
+      T,
+      class {
+        get x() {
+          return 1
+        }
+        get y() {
+          return 1
+        }
+        get z() {
+          return 1
+        }
+      },
+    )
+  })
+  it('Should not validate constructor 1', () => {
+    const T = Type.Constructor([Type.Number()], Type.Object({}))
+    Fail(T, 1)
+  })
+  it('Should not validate constructor 2', () => {
+    const T = Type.Constructor(
+      [Type.Number()],
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+    )
+    Fail(
+      T,
+      class {
+        get x() {
+          return null
+        }
+        get y() {
+          return null
+        }
+        get z() {
+          return null
+        }
+      },
+    )
+  })
+})
diff --git a/test/runtime/compiler/function.ts b/test/runtime/compiler/function.ts
new file mode 100644
index 000000000..29a604b96
--- /dev/null
+++ b/test/runtime/compiler/function.ts
@@ -0,0 +1,25 @@
+import { Type } from '@sinclair/typebox'
+import { Ok, Fail } from './validate'
+
+describe('compiler/Function', () => {
+  it('Should validate function 1', () => {
+    const T = Type.Function([Type.Number()], Type.Number())
+    Ok(T, function () {})
+  })
+  it('Should validate function 2', () => {
+    const T = Type.Function([Type.Number()], Type.Number())
+    // note: validation only checks typeof 'function'
+    Ok(T, function (a: string, b: string, c: string, d: string) {})
+  })
+  it('Should validate function 3', () => {
+    const T = Type.Function([Type.Number()], Type.Number())
+    // note: validation only checks typeof 'function'
+    Ok(T, function () {
+      return 'not-a-number'
+    })
+  })
+  it('Should not validate function', () => {
+    const T = Type.Function([Type.Number()], Type.Number())
+    Fail(T, 1)
+  })
+})
diff --git a/test/runtime/compiler/index.ts b/test/runtime/compiler/index.ts
index 0524426fc..db87a1e15 100644
--- a/test/runtime/compiler/index.ts
+++ b/test/runtime/compiler/index.ts
@@ -4,9 +4,11 @@ import './async-iterator'
 import './bigint'
 import './boolean'
 import './composite'
+import './constructor'
 import './date'
 import './unicode'
 import './enum'
+import './function'
 import './integer'
 import './intersect'
 import './iterator'
diff --git a/test/runtime/value/check/constructor.ts b/test/runtime/value/check/constructor.ts
new file mode 100644
index 000000000..ba553e3d6
--- /dev/null
+++ b/test/runtime/value/check/constructor.ts
@@ -0,0 +1,87 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Constructor', () => {
+  it('Should validate constructor 1', () => {
+    const T = Type.Constructor([], Type.Object({}))
+    Assert.IsTrue(Value.Check(T, class {}))
+  })
+  it('Should validate constructor 2', () => {
+    const T = Type.Constructor([Type.Number()], Type.Object({}))
+    // note: constructor arguments are non-checkable
+    Assert.IsTrue(Value.Check(T, class {}))
+  })
+  it('Should validate constructor 3', () => {
+    const T = Type.Constructor(
+      [Type.Number()],
+      Type.Object({
+        method: Type.Function([], Type.Void()),
+      }),
+    )
+    Assert.IsTrue(
+      Value.Check(
+        T,
+        class {
+          method() {}
+        },
+      ),
+    )
+  })
+  it('Should validate constructor 4', () => {
+    const T = Type.Constructor(
+      [Type.Number()],
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+    )
+    Assert.IsTrue(
+      Value.Check(
+        T,
+        class {
+          get x() {
+            return 1
+          }
+          get y() {
+            return 1
+          }
+          get z() {
+            return 1
+          }
+        },
+      ),
+    )
+  })
+  it('Should not validate constructor 1', () => {
+    const T = Type.Constructor([Type.Number()], Type.Object({}))
+    Assert.IsFalse(Value.Check(T, 1))
+  })
+  it('Should not validate constructor 2', () => {
+    const T = Type.Constructor(
+      [Type.Number()],
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+    )
+    Assert.IsFalse(
+      Value.Check(
+        T,
+        class {
+          get x() {
+            return null
+          }
+          get y() {
+            return null
+          }
+          get z() {
+            return null
+          }
+        },
+      ),
+    )
+  })
+})
diff --git a/test/runtime/value/check/function.ts b/test/runtime/value/check/function.ts
new file mode 100644
index 000000000..d7842f3c5
--- /dev/null
+++ b/test/runtime/value/check/function.ts
@@ -0,0 +1,28 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Function', () => {
+  it('Should validate function 1', () => {
+    const T = Type.Function([Type.Number()], Type.Number())
+    Assert.IsTrue(Value.Check(T, function () {}))
+  })
+  it('Should validate function 2', () => {
+    const T = Type.Function([Type.Number()], Type.Number())
+    // note: validation only checks typeof 'function'
+    Assert.IsTrue(Value.Check(T, function (a: string, b: string, c: string, d: string) {}))
+  })
+  it('Should validate function 3', () => {
+    const T = Type.Function([Type.Number()], Type.Number())
+    // note: validation only checks typeof 'function'
+    Assert.IsTrue(
+      Value.Check(T, function () {
+        return 'not-a-number'
+      }),
+    )
+  })
+  it('Should not validate function', () => {
+    const T = Type.Function([Type.Number()], Type.Number())
+    Assert.IsFalse(Value.Check(T, 1))
+  })
+})
diff --git a/test/runtime/value/check/index.ts b/test/runtime/value/check/index.ts
index a55d53a0b..7b51cf3bf 100644
--- a/test/runtime/value/check/index.ts
+++ b/test/runtime/value/check/index.ts
@@ -4,8 +4,10 @@ import './async-iterator'
 import './bigint'
 import './boolean'
 import './composite'
+import './constructor'
 import './date'
 import './enum'
+import './function'
 import './integer'
 import './intersect'
 import './iterator'

From 483a0f7093be6e970a1043653c1c819af02af31c Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sat, 19 Aug 2023 15:41:58 +0900
Subject: [PATCH 174/369] Documentation

---
 readme.md | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/readme.md b/readme.md
index d19ccfd62..582456434 100644
--- a/readme.md
+++ b/readme.md
@@ -60,7 +60,9 @@ type T = Static<typeof T>                            // type T = {
 
 TypeBox is a runtime type builder that creates Json Schema objects that infer as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript or runtime checked using standard Json Schema validation.
 
-TypeBox is designed to be a runtime type system based on industry standard specifications. It offers serializable and publishable types as standard, a fully extensible type system capable of supporting multiple schema specifications, a high performance runtime validation compiler, various tools for working with dynamic data and offers detailed structured error reporting. It can either be used as a simple tool to build up complex schemas or integrated into applications to enable high performance runtime validation for data received over the wire.
+TypeBox is built upon industry standard specifications. It offers reflectable, serializable and publishable types as standard, a fully extensible type system capable of supporting multiple schema specifications, includes a high performance validation compiler, offers various tools for working with dynamic data and provides detailed structured error reporting. 
+
+TypeBox can be used as a simple tool to build up complex schemas or integrated into applications to enable high performance runtime validation for data received over the wire.
 
 License MIT
 
@@ -1167,9 +1169,9 @@ const Z = Value.Cast(T, { x: 1, y: 2, z: 3 })        // const Z = { x: 1, y: 2 }
 Use the Decode function to decode a value from a type, or throw if the value is invalid. The return value will infer as the decoded type. This function will run Transform codecs if available.
 
 ```typescript
-const A = Type.Decode(Type.String(), 'hello')        // const A = 'hello'
+const A = Value.Decode(Type.String(), 'hello')        // const A = 'hello'
 
-const B = Type.Decode(Type.String(), 42)             // throw
+const B = Value.Decode(Type.String(), 42)             // throw
 ```
 <a name='values-decode'></a>
 
@@ -1178,9 +1180,9 @@ const B = Type.Decode(Type.String(), 42)             // throw
 Use the Encode function to encode a value to a type, or throw if the value is invalid. The return value will infer as the encoded type. This function will run Transform codecs if available.
 
 ```typescript
-const A = Type.Encode(Type.String(), 'hello')        // const A = 'hello'
+const A = Value.Encode(Type.String(), 'hello')        // const A = 'hello'
 
-const B = Type.Encode(Type.String(), 42)             // throw
+const B = Value.Encode(Type.String(), 42)             // throw
 ```
 
 <a name='values-equal'></a>

From d758fb5846a7b80f9b3f8281786c86f32f4a64d0 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 23 Aug 2023 04:32:17 +0900
Subject: [PATCH 175/369] Escape for Single Quote Literal Value (#540)

---
 package-lock.json                |  4 ++--
 package.json                     |  2 +-
 src/compiler/compiler.ts         | 10 +++++++++-
 test/runtime/compiler/literal.ts | 11 +++++++++++
 test/runtime/schema/literal.ts   | 11 +++++++++++
 5 files changed, 34 insertions(+), 4 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index efe7b622e..2b0ccba85 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.0",
+  "version": "0.31.2",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.0",
+      "version": "0.31.2",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index fbe8febe3..7b85f51eb 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.1",
+  "version": "0.31.2",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index d469ccde3..25c463a9f 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -129,6 +129,14 @@ namespace Identifier {
   }
 }
 // -------------------------------------------------------------------
+// LiteralString
+// -------------------------------------------------------------------
+namespace LiteralString {
+  export function Escape(content: string) {
+    return content.replace(/'/g, "\\'")
+  }
+}
+// -------------------------------------------------------------------
 // Errors
 // -------------------------------------------------------------------
 export class TypeCompilerUnknownTypeError extends Types.TypeBoxError {
@@ -263,7 +271,7 @@ export namespace TypeCompiler {
     if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
       yield `(${value} === ${schema.const})`
     } else {
-      yield `(${value} === '${schema.const}')`
+      yield `(${value} === '${LiteralString.Escape(schema.const)}')`
     }
   }
   function* TNever(schema: Types.TNever, references: Types.TSchema[], value: string): IterableIterator<string> {
diff --git a/test/runtime/compiler/literal.ts b/test/runtime/compiler/literal.ts
index d2d17155a..5cd3e289b 100644
--- a/test/runtime/compiler/literal.ts
+++ b/test/runtime/compiler/literal.ts
@@ -36,4 +36,15 @@ describe('compiler/Literal', () => {
     Fail(T, 43)
     Fail(T, 'world')
   })
+  // reference: https://github.com/sinclairzx81/typebox/issues/539
+  it('Should escape single quote literals', () => {
+    const T = Type.Literal("it's")
+    Ok(T, "it's")
+    Fail(T, "it''s")
+  })
+  it('Should escape multiple single quote literals', () => {
+    const T = Type.Literal("'''''''''")
+    Ok(T, "'''''''''")
+    Fail(T, "''''''''") // minus 1
+  })
 })
diff --git a/test/runtime/schema/literal.ts b/test/runtime/schema/literal.ts
index d517697d3..d14d5b784 100644
--- a/test/runtime/schema/literal.ts
+++ b/test/runtime/schema/literal.ts
@@ -36,4 +36,15 @@ describe('type/schema/Literal', () => {
     Fail(T, 43)
     Fail(T, 'world')
   })
+  // reference: https://github.com/sinclairzx81/typebox/issues/539
+  it('Should escape single quote literals', () => {
+    const T = Type.Literal("it's")
+    Ok(T, "it's")
+    Fail(T, "it''s")
+  })
+  it('Should escape multiple single quote literals', () => {
+    const T = Type.Literal("'''''''''")
+    Ok(T, "'''''''''")
+    Fail(T, "''''''''") // minus 1
+  })
 })

From f005478de11dda8db5c274273c334c04398085cf Mon Sep 17 00:00:00 2001
From: Hamish Cox <20359560+HamishWHC@users.noreply.github.com>
Date: Fri, 25 Aug 2023 15:23:24 +1000
Subject: [PATCH 176/369] Decode Modifiers (#544)

* Handle TOptionals in DecodeStaticType

Fixes #543

* Readonly and Optional

---------

Co-authored-by: sinclair <haydn.developer@gmail.com>
---
 src/typebox.ts | 48 +++++++++++++++++++++++++++---------------------
 1 file changed, 27 insertions(+), 21 deletions(-)

diff --git a/src/typebox.ts b/src/typebox.ts
index 412d6412d..b4538363b 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -855,30 +855,36 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
 // TTransform
 // --------------------------------------------------------------------------
 // prettier-ignore
-export type DecodeStaticProperties<T extends TProperties> = {
-  [K in keyof T]: DecodeStaticType<T[K]>
+export type DecodeModifier<D extends TSchema, T extends TSchema> =
+  T extends TReadonly<T> & TOptional<T> ? TReadonly<TOptional<D>> :
+  T extends TReadonly<T> ? TReadonly<D> :
+  T extends TOptional<T> ? TOptional<D> :
+  D
+// prettier-ignore
+export type DecodeProperties<T extends TProperties> = {
+  [K in keyof T]: DecodeType<T[K]>
 }
 // prettier-ignore
-export type DecodeStaticRest<T extends TSchema[]> = T extends [infer L, ...infer R]
-  ? [DecodeStaticType<AssertType<L>>, ...DecodeStaticRest<AssertRest<R>>]
+export type DecodeRest<T extends TSchema[]> = T extends [infer L, ...infer R]
+  ? [DecodeType<AssertType<L>>, ...DecodeRest<AssertRest<R>>]
   : []
 // prettier-ignore
-export type DecodeStaticType<T extends TSchema> =
-  T extends TTransform<infer _, infer R>   ? TUnsafe<R> : 
-  T extends TArray<infer S> ? TArray<DecodeStaticType<S>> :
-  T extends TAsyncIterator<infer S> ? TAsyncIterator<DecodeStaticType<S>> :
-  T extends TConstructor<infer P, infer R> ? TConstructor<AssertRest<DecodeStaticRest<P>>, DecodeStaticType<R>> :
-  T extends TFunction<infer P, infer R> ? TFunction<AssertRest<DecodeStaticRest<P>>, DecodeStaticType<R>> :
-  T extends TIntersect<infer S> ? TIntersect<AssertRest<DecodeStaticRest<S>>> :
-  T extends TIterator<infer S> ? TIterator<DecodeStaticType<S>> :
-  T extends TNot<infer S> ? TNot<DecodeStaticType<S>> :
-  T extends TObject<infer S> ? TObject<Evaluate<DecodeStaticProperties<S>>> :
-  T extends TPromise<infer S> ? TPromise<DecodeStaticType<S>> :
-  T extends TRecord<infer K, infer S> ? TRecord<K, DecodeStaticType<S>> :
-  T extends TRecursive<infer S> ? TRecursive<DecodeStaticType<S>> :
-  T extends TRef<infer S> ? TRef<DecodeStaticType<S>> :
-  T extends TTuple<infer S> ? TTuple<AssertRest<DecodeStaticRest<S>>> :
-  T extends TUnion<infer S> ? TUnion<AssertRest<DecodeStaticRest<S>>> :
+export type DecodeType<T extends TSchema> =
+  T extends TTransform<infer _, infer R> ? DecodeModifier<TUnsafe<R>, T> : 
+  T extends TArray<infer S> ? DecodeModifier<TArray<DecodeType<S>>, T> :
+  T extends TAsyncIterator<infer S> ? DecodeModifier<TAsyncIterator<DecodeType<S>>, T> :
+  T extends TConstructor<infer P, infer R> ? DecodeModifier<TConstructor<AssertRest<DecodeRest<P>>, DecodeType<R>>, T> :
+  T extends TFunction<infer P, infer R> ? DecodeModifier<TFunction<AssertRest<DecodeRest<P>>, DecodeType<R>>, T> :
+  T extends TIntersect<infer S> ? DecodeModifier<TIntersect<AssertRest<DecodeRest<S>>>, T> :
+  T extends TIterator<infer S> ? DecodeModifier<TIterator<DecodeType<S>>, T> :
+  T extends TNot<infer S> ? DecodeModifier<TNot<DecodeType<S>>, T> :
+  T extends TObject<infer S> ? DecodeModifier<TObject<Evaluate<DecodeProperties<S>>>, T> :
+  T extends TPromise<infer S> ? DecodeModifier<TPromise<DecodeType<S>>, T> :
+  T extends TRecord<infer K, infer S> ? DecodeModifier<TRecord<K, DecodeType<S>>, T> :
+  T extends TRecursive<infer S> ? DecodeModifier<TRecursive<DecodeType<S>>, T> :
+  T extends TRef<infer S> ? DecodeModifier<TRef<DecodeType<S>>, T> :
+  T extends TTuple<infer S> ? DecodeModifier<TTuple<AssertRest<DecodeRest<S>>>, T> :
+  T extends TUnion<infer S> ? DecodeModifier<TUnion<AssertRest<DecodeRest<S>>>, T> :
   T
 export type TransformFunction<T = any, U = any> = (value: T) => U
 export interface TransformOptions<I extends TSchema = TSchema, O extends unknown = unknown> {
@@ -974,7 +980,7 @@ export interface TVoid extends TSchema {
 // Static<T>
 // --------------------------------------------------------------------------
 /** Creates the decoded static form for a TypeBox type */
-export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<DecodeStaticType<T>, P>
+export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<DecodeType<T>, P>
 /** Creates the encoded static form for a TypeBox type */
 export type StaticEncode<T extends TSchema, P extends unknown[] = []> = Static<T, P>
 /** Creates the static type for a TypeBox type */

From 0762bd31a7e33c8702b2e8031d6ec6dffdae6d07 Mon Sep 17 00:00:00 2001
From: Sjors Smits <smits.sjors@gmail.com>
Date: Fri, 25 Aug 2023 07:48:12 +0200
Subject: [PATCH 177/369] Exterior RegExp Encode (#542)

---
 src/compiler/compiler.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 25c463a9f..0c9d2b958 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -330,7 +330,7 @@ export namespace TypeCompiler {
     if (IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
     if (IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
     const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0]
-    const variable = CreateVariable(`new RegExp(/${patternKey}/)`)
+    const variable = CreateVariable(`${new RegExp(patternKey)}`)
     const check1 = CreateExpression(patternSchema, references, 'value')
     const check2 = Types.TypeGuard.TSchema(schema.additionalProperties) ? CreateExpression(schema.additionalProperties, references, value) : schema.additionalProperties === false ? 'false' : 'true'
     const expression = `(${variable}.test(key) ? ${check1} : ${check2})`

From 6e0b99937e3d70448a86dd6c58de6cbf37598dd5 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 25 Aug 2023 16:07:45 +0900
Subject: [PATCH 178/369] Revision 0.31.3 (#545)

---
 hammer.mjs                               |  2 +-
 package-lock.json                        | 18 +++++------
 package.json                             |  4 +--
 readme.md                                |  7 +++--
 test/runtime/compiler/record.ts          | 22 +++++++++++--
 test/runtime/index.ts                    |  2 +-
 test/runtime/schema/any.ts               |  2 +-
 test/runtime/schema/array.ts             |  2 +-
 test/runtime/schema/boolean.ts           |  2 +-
 test/runtime/schema/composite.ts         |  2 +-
 test/runtime/schema/date.ts              |  2 +-
 test/runtime/schema/enum.ts              |  2 +-
 test/runtime/schema/integer.ts           |  2 +-
 test/runtime/schema/intersect.ts         |  2 +-
 test/runtime/schema/keyof.ts             |  3 +-
 test/runtime/schema/literal.ts           |  2 +-
 test/runtime/schema/never.ts             |  2 +-
 test/runtime/schema/not.ts               |  2 +-
 test/runtime/schema/null.ts              |  2 +-
 test/runtime/schema/number.ts            |  2 +-
 test/runtime/schema/object.ts            |  2 +-
 test/runtime/schema/omit.ts              |  2 +-
 test/runtime/schema/optional.ts          |  2 +-
 test/runtime/schema/partial.ts           | 22 ++++++-------
 test/runtime/schema/pick.ts              | 12 +++----
 test/runtime/schema/readonly-optional.ts |  8 ++---
 test/runtime/schema/readonly.ts          | 10 +++---
 test/runtime/schema/record.ts            | 24 ++++++++++++--
 test/runtime/schema/recursive.ts         |  6 ++--
 test/runtime/schema/ref.ts               |  3 +-
 test/runtime/schema/regexp.ts            |  2 +-
 test/runtime/schema/required.ts          | 16 +++++-----
 test/runtime/schema/string.ts            |  2 +-
 test/runtime/schema/template-literal.ts  |  2 +-
 test/runtime/schema/tuple.ts             |  3 +-
 test/runtime/schema/uint8array.ts        |  2 +-
 test/runtime/schema/union.ts             |  2 +-
 test/runtime/schema/unknown.ts           |  4 +--
 test/runtime/schema/unsafe.ts            |  2 +-
 test/runtime/schema/void.ts              |  2 +-
 test/runtime/value/check/record.ts       | 40 ++++++++++++++++++++++++
 test/static/transform.ts                 | 32 +++++++++++++++++++
 42 files changed, 196 insertions(+), 88 deletions(-)

diff --git a/hammer.mjs b/hammer.mjs
index c99da14f9..76e8ea38e 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -36,7 +36,7 @@ export async function benchmark() {
 // Test
 // -------------------------------------------------------------------------------
 export async function test_typescript() {
-  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', 'next', 'latest']) {
+  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', 'next', 'latest']) {
     await shell(`npm install typescript@${version} --no-save`)
     await test_static()
   }
diff --git a/package-lock.json b/package-lock.json
index 2b0ccba85..283e9a681 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.2",
+  "version": "0.31.3",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.2",
+      "version": "0.31.3",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
@@ -16,7 +16,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^9.2.2",
         "prettier": "^2.7.1",
-        "typescript": "^5.1.6"
+        "typescript": "^5.2.2"
       }
     },
     "node_modules/@esbuild/android-arm": {
@@ -1334,9 +1334,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.1.6",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.1.6.tgz",
-      "integrity": "sha512-zaWCozRZ6DLEWAWFrVDz1H6FVXzUSfTy5FUMWsQlU8Ym5JP9eO4xkTIROFCQvhQf61z6O/G6ugw3SgAnvvm+HA==",
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.2.2.tgz",
+      "integrity": "sha512-mI4WrpHsbCIcwT9cF4FZvr80QUeKvsUsUvKDoR+X/7XHQH98xYD8YHZg7ANtz2GtZt/CBq2QJ0thkGJMHfqc1w==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -2304,9 +2304,9 @@
       }
     },
     "typescript": {
-      "version": "5.1.6",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.1.6.tgz",
-      "integrity": "sha512-zaWCozRZ6DLEWAWFrVDz1H6FVXzUSfTy5FUMWsQlU8Ym5JP9eO4xkTIROFCQvhQf61z6O/G6ugw3SgAnvvm+HA==",
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.2.2.tgz",
+      "integrity": "sha512-mI4WrpHsbCIcwT9cF4FZvr80QUeKvsUsUvKDoR+X/7XHQH98xYD8YHZg7ANtz2GtZt/CBq2QJ0thkGJMHfqc1w==",
       "dev": true
     },
     "uri-js": {
diff --git a/package.json b/package.json
index 7b85f51eb..7ceb60964 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.2",
+  "version": "0.31.3",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -59,6 +59,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^5.1.6"
+    "typescript": "^5.2.2"
   }
 }
diff --git a/readme.md b/readme.md
index 582456434..05345fec0 100644
--- a/readme.md
+++ b/readme.md
@@ -60,7 +60,7 @@ type T = Static<typeof T>                            // type T = {
 
 TypeBox is a runtime type builder that creates Json Schema objects that infer as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript or runtime checked using standard Json Schema validation.
 
-TypeBox is built upon industry standard specifications. It offers reflectable, serializable and publishable types as standard, a fully extensible type system capable of supporting multiple schema specifications, includes a high performance validation compiler, offers various tools for working with dynamic data and provides detailed structured error reporting. 
+TypeBox types are designed to express industry standard schematics as TypeScript types. All types are runtime reflectable, serializable and publishable by default. It includes an extensible type system able to represent type safe schematics for multiple schema specifications. It also provides a high performance validation compiler, various tools for working with dynamic data and offers detailed structured error reporting. 
 
 TypeBox can be used as a simple tool to build up complex schemas or integrated into applications to enable high performance runtime validation for data received over the wire.
 
@@ -949,7 +949,7 @@ const U = Type.Union(R)                              // const U = {
 
 ### Transform Types
 
-TypeBox supports bi-directional decode and encode with Transform types. These types are designed to operate with the Value and TypeCompiler Encode and Decode functions. Transform types are useful to convert Json encoded values into constructs more natural to JavaScript. The following creates a Transform type to convert between Date and number using the Value module.
+TypeBox supports value decoding and encoding with Transform types. These types work in tandem with the Encode and Decode functions available on the Value and TypeCompiler modules. Transform types can be used to convert Json encoded values into constructs more natural to JavaScript. The following creates a Transform type to decode numbers into Dates using the Value module.
 
 ```typescript
 import { Value } from '@sinclair/typebox/value'
@@ -1604,13 +1604,16 @@ The following is a list of community packages that offer general tooling, extend
 
 | Package   |  Description |
 | ------------- | ------------- |
+| [drizzle-typebox](https://www.npmjs.com/package/drizzle-typebox) | Generates TypeBox types from Drizzle ORM schemas |
 | [elysia](https://github.com/elysiajs/elysia) | Fast and friendly Bun web framework |
 | [fastify-type-provider-typebox](https://github.com/fastify/fastify-type-provider-typebox) | Fastify TypeBox integration with the Fastify Type Provider |
 | [feathersjs](https://github.com/feathersjs/feathers) | The API and real-time application framework |
 | [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
+| [h3-typebox](https://github.com/kevinmarrec/h3-typebox) | Schema validation utilities for h3 using TypeBox & Ajv |
 | [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from Json Schemas |
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
 | [typebox-client](https://github.com/flodlc/typebox-client) | Type safe http client library for Fastify |
+| [typebox-form-parser](https://github.com/jtlapp/typebox-form-parser) | Parses form and query data based on TypeBox schemas |
 | [typebox-validators](https://github.com/jtlapp/typebox-validators) | Advanced validators supporting discriminated and heterogeneous unions |
 
 <a name='benchmark'></a>
diff --git a/test/runtime/compiler/record.ts b/test/runtime/compiler/record.ts
index cd9322b08..89368d724 100644
--- a/test/runtime/compiler/record.ts
+++ b/test/runtime/compiler/record.ts
@@ -85,7 +85,7 @@ describe('compiler/Record', () => {
     const R = Type.Record(Type.KeyOf(T), Type.Number(), { additionalProperties: false })
     Fail(R, { a: 1, b: 2, c: 3, d: 4 })
   })
-  it('Should should validate when specifying regular expressions', () => {
+  it('Should validate when specifying regular expressions', () => {
     const K = Type.RegExp(/^op_.*$/)
     const T = Type.Record(K, Type.Number())
     Ok(T, {
@@ -94,7 +94,7 @@ describe('compiler/Record', () => {
       op_c: 3,
     })
   })
-  it('Should should not validate when specifying regular expressions and passing invalid property', () => {
+  it('Should not validate when specifying regular expressions and passing invalid property', () => {
     const K = Type.RegExp(/^op_.*$/)
     const T = Type.Record(K, Type.Number(), { additionalProperties: false })
     Fail(T, {
@@ -103,6 +103,24 @@ describe('compiler/Record', () => {
       aop_c: 3,
     })
   })
+  it('Should validate with quoted string pattern', () => {
+    const K = Type.String({ pattern: "'(a|b|c)" })
+    const T = Type.Record(K, Type.Number())
+    Ok(T, {
+      "'a": 1,
+      "'b": 2,
+      "'c": 3,
+    })
+  })
+  it('Should validate with forward-slash pattern', () => {
+    const K = Type.String({ pattern: '/(a|b|c)' })
+    const T = Type.Record(K, Type.Number())
+    Ok(T, {
+      '/a': 1,
+      '/b': 2,
+      '/c': 3,
+    })
+  })
   // ------------------------------------------------------------
   // Integer Keys
   // ------------------------------------------------------------
diff --git a/test/runtime/index.ts b/test/runtime/index.ts
index 5a8bca7ab..8f53de837 100644
--- a/test/runtime/index.ts
+++ b/test/runtime/index.ts
@@ -1,6 +1,6 @@
 import './compiler/index'
-import './errors/index'
 import './schema/index'
+import './errors/index'
 import './system/index'
 import './type/index'
 import './value/index'
diff --git a/test/runtime/schema/any.ts b/test/runtime/schema/any.ts
index 3e857c831..695113f09 100644
--- a/test/runtime/schema/any.ts
+++ b/test/runtime/schema/any.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok } from './validate'
 
-describe('type/schema/Any', () => {
+describe('compiler-ajv/Any', () => {
   it('Should validate number', () => {
     const T = Type.Any()
     Ok(T, 1)
diff --git a/test/runtime/schema/array.ts b/test/runtime/schema/array.ts
index d20e504c4..dd9feaea4 100644
--- a/test/runtime/schema/array.ts
+++ b/test/runtime/schema/array.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/Array', () => {
+describe('compiler-ajv/Array', () => {
   it('Should validate an array of any', () => {
     const T = Type.Array(Type.Any())
     Ok(T, [0, true, 'hello', {}])
diff --git a/test/runtime/schema/boolean.ts b/test/runtime/schema/boolean.ts
index f8f75a55e..6ff4f7861 100644
--- a/test/runtime/schema/boolean.ts
+++ b/test/runtime/schema/boolean.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/Boolean', () => {
+describe('compiler-ajv/Boolean', () => {
   it('Should validate a boolean', () => {
     const T = Type.Boolean()
     Ok(T, true)
diff --git a/test/runtime/schema/composite.ts b/test/runtime/schema/composite.ts
index 23e5d1055..41e8a8ac9 100644
--- a/test/runtime/schema/composite.ts
+++ b/test/runtime/schema/composite.ts
@@ -2,7 +2,7 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../assert'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/Composite', () => {
+describe('compiler-ajv/Composite', () => {
   it('Should compose two objects', () => {
     const A = Type.Object({ a: Type.String() })
     const B = Type.Object({ b: Type.Number() })
diff --git a/test/runtime/schema/date.ts b/test/runtime/schema/date.ts
index 659c704b9..f5f8e12fc 100644
--- a/test/runtime/schema/date.ts
+++ b/test/runtime/schema/date.ts
@@ -10,7 +10,7 @@
 // which are configured to use Value.Check()
 // ----------------------------------------------------
 
-// describe('type/schema/Date', () => {
+// describe('compiler-ajv/Date', () => {
 //   it('Should not validate number', () => {
 //     const T = Type.Date()
 //     Fail(T, 1)
diff --git a/test/runtime/schema/enum.ts b/test/runtime/schema/enum.ts
index 910e16e27..c4599be98 100644
--- a/test/runtime/schema/enum.ts
+++ b/test/runtime/schema/enum.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/Enum', () => {
+describe('compiler-ajv/Enum', () => {
   it('Should validate when emum uses default numeric values', () => {
     enum Kind {
       Foo, // = 0
diff --git a/test/runtime/schema/integer.ts b/test/runtime/schema/integer.ts
index 5d984691f..664eacf7b 100644
--- a/test/runtime/schema/integer.ts
+++ b/test/runtime/schema/integer.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/Integer', () => {
+describe('compiler-ajv/Integer', () => {
   it('Should not validate number', () => {
     const T = Type.Integer()
     Fail(T, 3.14)
diff --git a/test/runtime/schema/intersect.ts b/test/runtime/schema/intersect.ts
index 5e4b64a4f..00fe0ac1a 100644
--- a/test/runtime/schema/intersect.ts
+++ b/test/runtime/schema/intersect.ts
@@ -1,7 +1,7 @@
 import { Type, Static } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/Intersect', () => {
+describe('compiler-ajv/Intersect', () => {
   it('Should intersect number and number', () => {
     const A = Type.Number()
     const B = Type.Number()
diff --git a/test/runtime/schema/keyof.ts b/test/runtime/schema/keyof.ts
index 17b36914f..0734a2f93 100644
--- a/test/runtime/schema/keyof.ts
+++ b/test/runtime/schema/keyof.ts
@@ -1,8 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
-import { strictEqual } from 'assert'
 
-describe('type/schema/KeyOf', () => {
+describe('compiler-ajv/KeyOf', () => {
   it('Should validate with all object keys as a kind of union', () => {
     const T = Type.KeyOf(
       Type.Object({
diff --git a/test/runtime/schema/literal.ts b/test/runtime/schema/literal.ts
index d14d5b784..a41d69044 100644
--- a/test/runtime/schema/literal.ts
+++ b/test/runtime/schema/literal.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/Literal', () => {
+describe('compiler-ajv/Literal', () => {
   it('Should validate literal number', () => {
     const T = Type.Literal(42)
     Ok(T, 42)
diff --git a/test/runtime/schema/never.ts b/test/runtime/schema/never.ts
index 8a3f6e386..49904f4eb 100644
--- a/test/runtime/schema/never.ts
+++ b/test/runtime/schema/never.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Fail } from './validate'
 
-describe('type/schema/Never', () => {
+describe('compiler-ajv/Never', () => {
   it('Should not validate number', () => {
     const T = Type.Never()
     Fail(T, 1)
diff --git a/test/runtime/schema/not.ts b/test/runtime/schema/not.ts
index 491de05b4..013cf28a5 100644
--- a/test/runtime/schema/not.ts
+++ b/test/runtime/schema/not.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/Not', () => {
+describe('compiler-ajv/Not', () => {
   it('Should validate not number', () => {
     const T = Type.Not(Type.Number())
     Fail(T, 1)
diff --git a/test/runtime/schema/null.ts b/test/runtime/schema/null.ts
index b338d78eb..4947b0cf9 100644
--- a/test/runtime/schema/null.ts
+++ b/test/runtime/schema/null.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/Null', () => {
+describe('compiler-ajv/Null', () => {
   it('Should not validate number', () => {
     const T = Type.Null()
     Fail(T, 1)
diff --git a/test/runtime/schema/number.ts b/test/runtime/schema/number.ts
index 880a85e4a..30dd7fb8a 100644
--- a/test/runtime/schema/number.ts
+++ b/test/runtime/schema/number.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/Number', () => {
+describe('compiler-ajv/Number', () => {
   it('Should validate number', () => {
     const T = Type.Number()
     Ok(T, 3.14)
diff --git a/test/runtime/schema/object.ts b/test/runtime/schema/object.ts
index cabe95979..c096bc546 100644
--- a/test/runtime/schema/object.ts
+++ b/test/runtime/schema/object.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/Object', () => {
+describe('compiler-ajv/Object', () => {
   it('Should not validate a number', () => {
     const T = Type.Object({})
     Fail(T, 42)
diff --git a/test/runtime/schema/omit.ts b/test/runtime/schema/omit.ts
index 7a1d6e108..0053c6808 100644
--- a/test/runtime/schema/omit.ts
+++ b/test/runtime/schema/omit.ts
@@ -2,7 +2,7 @@ import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
-describe('type/schema/Omit', () => {
+describe('compiler-ajv/Omit', () => {
   it('Should omit properties on the source schema', () => {
     const A = Type.Object(
       {
diff --git a/test/runtime/schema/optional.ts b/test/runtime/schema/optional.ts
index 298550f73..a5d39dd6f 100644
--- a/test/runtime/schema/optional.ts
+++ b/test/runtime/schema/optional.ts
@@ -2,7 +2,7 @@ import { strictEqual } from 'assert'
 import { Type } from '@sinclair/typebox'
 import { Ok } from './validate'
 
-describe('type/schema/Optional', () => {
+describe('compiler-ajv/Optional', () => {
   it('Should validate object with optional', () => {
     const T = Type.Object(
       {
diff --git a/test/runtime/schema/partial.ts b/test/runtime/schema/partial.ts
index c28f1368e..5e56d704a 100644
--- a/test/runtime/schema/partial.ts
+++ b/test/runtime/schema/partial.ts
@@ -1,8 +1,8 @@
 import { Type, Readonly, Optional } from '@sinclair/typebox'
-import { Ok, Fail } from './validate'
-import { strictEqual } from 'assert'
+import { Ok } from './validate'
+import { Assert } from '../assert'
 
-describe('type/schema/Partial', () => {
+describe('compiler-ajv/Partial', () => {
   it('Should convert a required object into a partial.', () => {
     const A = Type.Object(
       {
@@ -29,12 +29,12 @@ describe('type/schema/Partial', () => {
       { additionalProperties: false },
     )
     const T = Type.Partial(A)
-    strictEqual(T.properties.x[Readonly], 'Readonly')
-    strictEqual(T.properties.x[Optional], 'Optional')
-    strictEqual(T.properties.y[Readonly], 'Readonly')
-    strictEqual(T.properties.y[Optional], 'Optional')
-    strictEqual(T.properties.z[Optional], 'Optional')
-    strictEqual(T.properties.w[Optional], 'Optional')
+    Assert.IsEqual(T.properties.x[Readonly], 'Readonly')
+    Assert.IsEqual(T.properties.x[Optional], 'Optional')
+    Assert.IsEqual(T.properties.y[Readonly], 'Readonly')
+    Assert.IsEqual(T.properties.y[Optional], 'Optional')
+    Assert.IsEqual(T.properties.z[Optional], 'Optional')
+    Assert.IsEqual(T.properties.w[Optional], 'Optional')
   })
   it('Should inherit options from the source object', () => {
     const A = Type.Object(
@@ -46,7 +46,7 @@ describe('type/schema/Partial', () => {
       { additionalProperties: false },
     )
     const T = Type.Partial(A)
-    strictEqual(A.additionalProperties, false)
-    strictEqual(T.additionalProperties, false)
+    Assert.IsEqual(A.additionalProperties, false)
+    Assert.IsEqual(T.additionalProperties, false)
   })
 })
diff --git a/test/runtime/schema/pick.ts b/test/runtime/schema/pick.ts
index 39dde3a06..e9c09c700 100644
--- a/test/runtime/schema/pick.ts
+++ b/test/runtime/schema/pick.ts
@@ -1,8 +1,8 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
-import { strictEqual } from 'assert'
+import { Assert } from '../assert'
 
-describe('type/schema/Pick', () => {
+describe('compiler-ajv/Pick', () => {
   it('Should pick properties from the source schema', () => {
     const Vector3 = Type.Object(
       {
@@ -25,7 +25,7 @@ describe('type/schema/Pick', () => {
       { additionalProperties: false },
     )
     const T = Type.Pick(A, ['x', 'y'])
-    strictEqual(T.required!.includes('z'), false)
+    Assert.IsEqual(T.required!.includes('z'), false)
   })
   it('Should delete the required property if no required properties remain', () => {
     const A = Type.Object(
@@ -37,7 +37,7 @@ describe('type/schema/Pick', () => {
       { additionalProperties: false },
     )
     const T = Type.Pick(A, ['x', 'y'])
-    strictEqual(T.required, undefined)
+    Assert.IsEqual(T.required, undefined)
   })
   it('Should inherit options from the source object', () => {
     const A = Type.Object(
@@ -49,8 +49,8 @@ describe('type/schema/Pick', () => {
       { additionalProperties: false },
     )
     const T = Type.Pick(A, ['x', 'y'])
-    strictEqual(A.additionalProperties, false)
-    strictEqual(T.additionalProperties, false)
+    Assert.IsEqual(A.additionalProperties, false)
+    Assert.IsEqual(T.additionalProperties, false)
   })
   it('Should pick with keyof object', () => {
     const A = Type.Object({
diff --git a/test/runtime/schema/readonly-optional.ts b/test/runtime/schema/readonly-optional.ts
index 6025c3cf1..cbdd883ff 100644
--- a/test/runtime/schema/readonly-optional.ts
+++ b/test/runtime/schema/readonly-optional.ts
@@ -1,8 +1,8 @@
 import { Type } from '@sinclair/typebox'
-import { Ok, Fail } from './validate'
-import { strictEqual } from 'assert'
+import { Ok } from './validate'
+import { Assert } from '../assert'
 
-describe('type/schema/ReadonlyOptional', () => {
+describe('compiler-ajv/ReadonlyOptional', () => {
   it('Should validate object with optional', () => {
     const T = Type.Object(
       {
@@ -22,6 +22,6 @@ describe('type/schema/ReadonlyOptional', () => {
       },
       { additionalProperties: false },
     )
-    strictEqual(T.required!.includes('a'), false)
+    Assert.IsEqual(T.required!.includes('a'), false)
   })
 })
diff --git a/test/runtime/schema/readonly.ts b/test/runtime/schema/readonly.ts
index a651d3af3..c26dd62f6 100644
--- a/test/runtime/schema/readonly.ts
+++ b/test/runtime/schema/readonly.ts
@@ -1,8 +1,8 @@
-import { deepStrictEqual, strictEqual } from 'assert'
 import { Type } from '@sinclair/typebox'
-import { Ok, Fail } from './validate'
+import { Ok } from './validate'
+import { Assert } from '../assert'
 
-describe('type/schema/Readonly', () => {
+describe('compiler-ajv/Readonly', () => {
   it('Should validate object with readonly', () => {
     const T = Type.Object(
       {
@@ -21,7 +21,7 @@ describe('type/schema/Readonly', () => {
       },
       { additionalProperties: false },
     )
-    strictEqual(T.required!.includes('a'), true)
-    strictEqual(T.required!.includes('b'), true)
+    Assert.IsEqual(T.required!.includes('a'), true)
+    Assert.IsEqual(T.required!.includes('b'), true)
   })
 })
diff --git a/test/runtime/schema/record.ts b/test/runtime/schema/record.ts
index 6a6ba818c..082a58fb2 100644
--- a/test/runtime/schema/record.ts
+++ b/test/runtime/schema/record.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/Record', () => {
+describe('compiler-ajv/Record', () => {
   it('Should validate when all property values are numbers', () => {
     const T = Type.Record(Type.String(), Type.Number())
     Ok(T, { a: 1, b: 2, c: 3 })
@@ -54,7 +54,7 @@ describe('type/schema/Record', () => {
     const R = Type.Record(Type.KeyOf(T), Type.Number(), { additionalProperties: false })
     Fail(R, { a: 1, b: 2, c: 3, d: 4 })
   })
-  it('Should should validate when specifying regular expressions', () => {
+  it('Should validate when specifying regular expressions', () => {
     const K = Type.RegExp(/^op_.*$/)
     const T = Type.Record(K, Type.Number())
     Ok(T, {
@@ -63,7 +63,7 @@ describe('type/schema/Record', () => {
       op_c: 3,
     })
   })
-  it('Should should not validate when specifying regular expressions and passing invalid property', () => {
+  it('Should not validate when specifying regular expressions and passing invalid property', () => {
     const K = Type.RegExp(/^op_.*$/)
     const T = Type.Record(K, Type.Number(), { additionalProperties: false })
     Fail(T, {
@@ -72,6 +72,24 @@ describe('type/schema/Record', () => {
       aop_c: 3,
     })
   })
+  it('Should validate with quoted string pattern', () => {
+    const K = Type.String({ pattern: "'(a|b|c)" })
+    const T = Type.Record(K, Type.Number())
+    Ok(T, {
+      "'a": 1,
+      "'b": 2,
+      "'c": 3,
+    })
+  })
+  it('Should validate with forward-slash pattern', () => {
+    const K = Type.String({ pattern: '/(a|b|c)' })
+    const T = Type.Record(K, Type.Number())
+    Ok(T, {
+      '/a': 1,
+      '/b': 2,
+      '/c': 3,
+    })
+  })
   // ------------------------------------------------------------
   // Integer Keys
   // ------------------------------------------------------------
diff --git a/test/runtime/schema/recursive.ts b/test/runtime/schema/recursive.ts
index b2f90d756..0a04dc313 100644
--- a/test/runtime/schema/recursive.ts
+++ b/test/runtime/schema/recursive.ts
@@ -1,8 +1,8 @@
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../assert/index'
 import { Ok, Fail } from './validate'
+import { Assert } from '../assert/index'
 
-describe('type/schema/Recursive', () => {
+describe('compiler-ajv/Recursive', () => {
   it('Should generate default ordinal $id if not specified', () => {
     const Node = Type.Recursive((Node) =>
       Type.Object({
@@ -10,7 +10,7 @@ describe('type/schema/Recursive', () => {
         nodes: Type.Array(Node),
       }),
     )
-    Assert.IsEqual(Node.$id === undefined, false)
+    Assert.IsFalse(Node.$id === undefined)
   })
   it('Should override default ordinal $id if specified', () => {
     const Node = Type.Recursive(
diff --git a/test/runtime/schema/ref.ts b/test/runtime/schema/ref.ts
index a3d522f89..d9bf5c954 100644
--- a/test/runtime/schema/ref.ts
+++ b/test/runtime/schema/ref.ts
@@ -1,8 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
-import { Assert } from '../assert/index'
 
-describe('type/schema/Ref', () => {
+describe('compiler-ajv/Ref', () => {
   it('Should should validate when referencing a type', () => {
     const T = Type.Object(
       {
diff --git a/test/runtime/schema/regexp.ts b/test/runtime/schema/regexp.ts
index 643b43b81..dcfae6e8d 100644
--- a/test/runtime/schema/regexp.ts
+++ b/test/runtime/schema/regexp.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/RegExp', () => {
+describe('compiler-ajv/RegExp', () => {
   //-----------------------------------------------------
   // Regular Expression
   //-----------------------------------------------------
diff --git a/test/runtime/schema/required.ts b/test/runtime/schema/required.ts
index 19ab20f5c..7df4b1875 100644
--- a/test/runtime/schema/required.ts
+++ b/test/runtime/schema/required.ts
@@ -1,8 +1,8 @@
 import { Type, Readonly, Optional } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
-import { strictEqual } from 'assert'
+import { Assert } from '../assert'
 
-describe('type/schema/Required', () => {
+describe('compiler-ajv/Required', () => {
   it('Should convert a partial object into a required object', () => {
     const A = Type.Object(
       {
@@ -26,10 +26,10 @@ describe('type/schema/Required', () => {
       w: Type.Number(),
     })
     const T = Type.Required(A)
-    strictEqual(T.properties.x[Readonly], 'Readonly')
-    strictEqual(T.properties.y[Readonly], 'Readonly')
-    strictEqual(T.properties.z[Optional], undefined)
-    strictEqual(T.properties.w[Optional], undefined)
+    Assert.IsEqual(T.properties.x[Readonly], 'Readonly')
+    Assert.IsEqual(T.properties.y[Readonly], 'Readonly')
+    Assert.IsEqual(T.properties.z[Optional], undefined)
+    Assert.IsEqual(T.properties.w[Optional], undefined)
   })
   it('Should inherit options from the source object', () => {
     const A = Type.Object(
@@ -41,8 +41,8 @@ describe('type/schema/Required', () => {
       { additionalPropeties: false },
     )
     const T = Type.Required(A)
-    strictEqual(A.additionalPropeties, false)
-    strictEqual(T.additionalPropeties, false)
+    Assert.IsEqual(A.additionalPropeties, false)
+    Assert.IsEqual(T.additionalPropeties, false)
   })
   // it('Should construct new object when targetting reference', () => {
   //   const T = Type.Object({ a: Type.String(), b: Type.String() }, { $id: 'T' })
diff --git a/test/runtime/schema/string.ts b/test/runtime/schema/string.ts
index 73b62efa2..33729175e 100644
--- a/test/runtime/schema/string.ts
+++ b/test/runtime/schema/string.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/String', () => {
+describe('compiler-ajv/String', () => {
   it('Should not validate number', () => {
     const T = Type.String()
     Fail(T, 1)
diff --git a/test/runtime/schema/template-literal.ts b/test/runtime/schema/template-literal.ts
index 80c862b58..ad083a50b 100644
--- a/test/runtime/schema/template-literal.ts
+++ b/test/runtime/schema/template-literal.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/TemplateLiteral', () => {
+describe('compiler-ajv/TemplateLiteral', () => {
   // --------------------------------------------------------
   // Finite
   // --------------------------------------------------------
diff --git a/test/runtime/schema/tuple.ts b/test/runtime/schema/tuple.ts
index 22f9999dc..96dfc1aa3 100644
--- a/test/runtime/schema/tuple.ts
+++ b/test/runtime/schema/tuple.ts
@@ -1,8 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
-import { Assert } from '../assert'
 
-describe('type/schema/Tuple', () => {
+describe('compiler-ajv/Tuple', () => {
   it('Should validate tuple of [string, number]', () => {
     const A = Type.String()
     const B = Type.Number()
diff --git a/test/runtime/schema/uint8array.ts b/test/runtime/schema/uint8array.ts
index 96e2dd39c..b50979504 100644
--- a/test/runtime/schema/uint8array.ts
+++ b/test/runtime/schema/uint8array.ts
@@ -3,7 +3,7 @@
 // ---------------------------------------------------
 // import { Type } from '@sinclair/typebox'
 // import { Ok, Fail } from './validate'
-// describe('type/schema/Uint8Array', () => {
+// describe('compiler-ajv/Uint8Array', () => {
 //   it('Should not validate number', () => {
 //     const T = Type.Uint8Array()
 //     Fail(T, 1)
diff --git a/test/runtime/schema/union.ts b/test/runtime/schema/union.ts
index fc6493c91..ab18c1e18 100644
--- a/test/runtime/schema/union.ts
+++ b/test/runtime/schema/union.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/Union', () => {
+describe('compiler-ajv/Union', () => {
   it('Should validate union of string, number and boolean', () => {
     const A = Type.String()
     const B = Type.Number()
diff --git a/test/runtime/schema/unknown.ts b/test/runtime/schema/unknown.ts
index 2bc681767..8ad7cfacf 100644
--- a/test/runtime/schema/unknown.ts
+++ b/test/runtime/schema/unknown.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
-import { Ok, Fail } from './validate'
+import { Ok } from './validate'
 
-describe('type/schema/Unknown', () => {
+describe('compiler-ajv/Unknown', () => {
   it('Should validate number', () => {
     const T = Type.Any()
     Ok(T, 1)
diff --git a/test/runtime/schema/unsafe.ts b/test/runtime/schema/unsafe.ts
index 509d2d4fb..6a53eea0a 100644
--- a/test/runtime/schema/unsafe.ts
+++ b/test/runtime/schema/unsafe.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/Unsafe', () => {
+describe('compiler-ajv/Unsafe', () => {
   it('Should validate an unsafe type', () => {
     const T = Type.Unsafe({
       type: 'object',
diff --git a/test/runtime/schema/void.ts b/test/runtime/schema/void.ts
index 1aab66be4..547ead1ae 100644
--- a/test/runtime/schema/void.ts
+++ b/test/runtime/schema/void.ts
@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('type/schema/Void', () => {
+describe('compiler-ajv/Void', () => {
   it('Should not validate number', () => {
     const T = Type.Void()
     Fail(T, 1)
diff --git a/test/runtime/value/check/record.ts b/test/runtime/value/check/record.ts
index c6e04ce8d..2e4bd7362 100644
--- a/test/runtime/value/check/record.ts
+++ b/test/runtime/value/check/record.ts
@@ -121,6 +121,46 @@ describe('value/check/Record', () => {
     const result = Value.Check(T, value)
     Assert.IsEqual(result, true)
   })
+  it('Should validate when specifying regular expressions', () => {
+    const K = Type.RegExp(/^op_.*$/)
+    const T = Type.Record(K, Type.Number())
+    const R = Value.Check(T, {
+      op_a: 1,
+      op_b: 2,
+      op_c: 3,
+    })
+    Assert.IsTrue(R)
+  })
+  it('Should not validate when specifying regular expressions and passing invalid property', () => {
+    const K = Type.RegExp(/^op_.*$/)
+    const T = Type.Record(K, Type.Number(), { additionalProperties: false })
+    const R = Value.Check(T, {
+      op_a: 1,
+      op_b: 2,
+      aop_c: 3,
+    })
+    Assert.IsFalse(R)
+  })
+  it('Should validate with quoted string pattern', () => {
+    const K = Type.String({ pattern: "'(a|b|c)" })
+    const T = Type.Record(K, Type.Number())
+    const R = Value.Check(T, {
+      "'a": 1,
+      "'b": 2,
+      "'c": 3,
+    })
+    Assert.IsTrue(R)
+  })
+  it('Should validate with forward-slash pattern', () => {
+    const K = Type.String({ pattern: '/(a|b|c)' })
+    const T = Type.Record(K, Type.Number())
+    const R = Value.Check(T, {
+      '/a': 1,
+      '/b': 2,
+      '/c': 3,
+    })
+    Assert.IsTrue(R)
+  })
   // -------------------------------------------------
   // Number Key
   // -------------------------------------------------
diff --git a/test/static/transform.ts b/test/static/transform.ts
index 99e7e067a..3e02df125 100644
--- a/test/static/transform.ts
+++ b/test/static/transform.ts
@@ -182,3 +182,35 @@ import { Expect } from './assert'
   //   z: number;
   // } // lol
 }
+{
+  // ensure decode as optional
+  // prettier-ignore
+  const T = Type.Object({
+    x: Type.Optional(Type.Number()),
+    y: Type.Optional(Type.Number())
+  })
+  Expect(T).ToStaticDecode<{ x: undefined; y: undefined }>()
+  Expect(T).ToStaticDecode<{ x: 1; y: 1 }>()
+}
+{
+  // ensure decode as readonly
+  // prettier-ignore
+  const T = Type.Object({
+    x: Type.Readonly(Type.Number()),
+    y: Type.Readonly(Type.Number())
+  })
+  Expect(T).ToStaticDecode<{ readonly x: 1; readonly y: 1 }>()
+}
+{
+  // ensure decode as optional union
+  // prettier-ignore
+  const T = Type.Object({
+    x: Type.Optional(Type.Union([
+      Type.String(),
+      Type.Number()
+    ]))
+  })
+  Expect(T).ToStaticDecode<{ x: 1 }>()
+  Expect(T).ToStaticDecode<{ x: '1' }>()
+  Expect(T).ToStaticDecode<{ x: undefined }>()
+}

From 5a8a0af0d3ec6e00d63571f88951858dac4d494b Mon Sep 17 00:00:00 2001
From: Josh Michaels <31548851+joshmossas@users.noreply.github.com>
Date: Sat, 26 Aug 2023 02:09:26 -0500
Subject: [PATCH 179/369] Type inference for Type.Enum (#551)

---
 src/typebox.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/typebox.ts b/src/typebox.ts
index b4538363b..d33380c12 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -2901,7 +2901,7 @@ export class JsonTypeBuilder extends TypeBuilder {
     return Type.Object(properties, options) as TComposite<T>
   }
   /** `[Json]` Creates a Enum type */
-  public Enum<T extends Record<string, string | number>>(item: T, options: SchemaOptions = {}): TEnum<T> {
+  public Enum<V extends string | number, T extends Record<string, V>>(item: T, options: SchemaOptions = {}): TEnum<T> {
     // prettier-ignore
     const values = Object.getOwnPropertyNames(item).filter((key) => isNaN(key as any)).map((key) => item[key]) as T[keyof T][]
     // prettier-ignore

From 085714eb8c49ec59dcc49ede8c53f584763e0ada Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 26 Aug 2023 16:20:22 +0900
Subject: [PATCH 180/369] Revision 0.31.4 (#550)

---
 package-lock.json                                          | 4 ++--
 package.json                                               | 2 +-
 src/system/index.ts                                        | 1 +
 test/runtime/{schema => compiler-ajv}/any.ts               | 0
 test/runtime/{schema => compiler-ajv}/array.ts             | 0
 test/runtime/{schema => compiler-ajv}/boolean.ts           | 0
 test/runtime/{schema => compiler-ajv}/composite.ts         | 0
 test/runtime/{schema => compiler-ajv}/date.ts              | 0
 test/runtime/{schema => compiler-ajv}/enum.ts              | 0
 test/runtime/{schema => compiler-ajv}/index.ts             | 0
 test/runtime/{schema => compiler-ajv}/integer.ts           | 0
 test/runtime/{schema => compiler-ajv}/intersect.ts         | 0
 test/runtime/{schema => compiler-ajv}/keyof.ts             | 0
 test/runtime/{schema => compiler-ajv}/literal.ts           | 0
 test/runtime/{schema => compiler-ajv}/never.ts             | 0
 test/runtime/{schema => compiler-ajv}/not.ts               | 0
 test/runtime/{schema => compiler-ajv}/null.ts              | 0
 test/runtime/{schema => compiler-ajv}/number.ts            | 0
 test/runtime/{schema => compiler-ajv}/object.ts            | 0
 test/runtime/{schema => compiler-ajv}/omit.ts              | 0
 test/runtime/{schema => compiler-ajv}/optional.ts          | 0
 test/runtime/{schema => compiler-ajv}/partial.ts           | 0
 test/runtime/{schema => compiler-ajv}/pick.ts              | 0
 test/runtime/{schema => compiler-ajv}/readonly-optional.ts | 0
 test/runtime/{schema => compiler-ajv}/readonly.ts          | 0
 test/runtime/{schema => compiler-ajv}/record.ts            | 0
 test/runtime/{schema => compiler-ajv}/recursive.ts         | 0
 test/runtime/{schema => compiler-ajv}/ref.ts               | 0
 test/runtime/{schema => compiler-ajv}/regexp.ts            | 0
 test/runtime/{schema => compiler-ajv}/required.ts          | 0
 test/runtime/{schema => compiler-ajv}/string.ts            | 0
 test/runtime/{schema => compiler-ajv}/template-literal.ts  | 0
 test/runtime/{schema => compiler-ajv}/tuple.ts             | 0
 test/runtime/{schema => compiler-ajv}/uint8array.ts        | 0
 test/runtime/{schema => compiler-ajv}/union.ts             | 0
 test/runtime/{schema => compiler-ajv}/unknown.ts           | 0
 test/runtime/{schema => compiler-ajv}/unsafe.ts            | 0
 test/runtime/{schema => compiler-ajv}/validate.ts          | 0
 test/runtime/{schema => compiler-ajv}/void.ts              | 0
 test/runtime/index.ts                                      | 2 +-
 40 files changed, 5 insertions(+), 4 deletions(-)
 rename test/runtime/{schema => compiler-ajv}/any.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/array.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/boolean.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/composite.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/date.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/enum.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/index.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/integer.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/intersect.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/keyof.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/literal.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/never.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/not.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/null.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/number.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/object.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/omit.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/optional.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/partial.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/pick.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/readonly-optional.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/readonly.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/record.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/recursive.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/ref.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/regexp.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/required.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/string.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/template-literal.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/tuple.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/uint8array.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/union.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/unknown.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/unsafe.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/validate.ts (100%)
 rename test/runtime/{schema => compiler-ajv}/void.ts (100%)

diff --git a/package-lock.json b/package-lock.json
index 283e9a681..8cb18ccff 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.3",
+  "version": "0.31.4",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.3",
+      "version": "0.31.4",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 7ceb60964..475121baf 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.3",
+  "version": "0.31.4",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/system/index.ts b/src/system/index.ts
index 457186e0b..21c978add 100644
--- a/src/system/index.ts
+++ b/src/system/index.ts
@@ -26,4 +26,5 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+export { ValueErrorType } from '../errors/errors'
 export * from './system'
diff --git a/test/runtime/schema/any.ts b/test/runtime/compiler-ajv/any.ts
similarity index 100%
rename from test/runtime/schema/any.ts
rename to test/runtime/compiler-ajv/any.ts
diff --git a/test/runtime/schema/array.ts b/test/runtime/compiler-ajv/array.ts
similarity index 100%
rename from test/runtime/schema/array.ts
rename to test/runtime/compiler-ajv/array.ts
diff --git a/test/runtime/schema/boolean.ts b/test/runtime/compiler-ajv/boolean.ts
similarity index 100%
rename from test/runtime/schema/boolean.ts
rename to test/runtime/compiler-ajv/boolean.ts
diff --git a/test/runtime/schema/composite.ts b/test/runtime/compiler-ajv/composite.ts
similarity index 100%
rename from test/runtime/schema/composite.ts
rename to test/runtime/compiler-ajv/composite.ts
diff --git a/test/runtime/schema/date.ts b/test/runtime/compiler-ajv/date.ts
similarity index 100%
rename from test/runtime/schema/date.ts
rename to test/runtime/compiler-ajv/date.ts
diff --git a/test/runtime/schema/enum.ts b/test/runtime/compiler-ajv/enum.ts
similarity index 100%
rename from test/runtime/schema/enum.ts
rename to test/runtime/compiler-ajv/enum.ts
diff --git a/test/runtime/schema/index.ts b/test/runtime/compiler-ajv/index.ts
similarity index 100%
rename from test/runtime/schema/index.ts
rename to test/runtime/compiler-ajv/index.ts
diff --git a/test/runtime/schema/integer.ts b/test/runtime/compiler-ajv/integer.ts
similarity index 100%
rename from test/runtime/schema/integer.ts
rename to test/runtime/compiler-ajv/integer.ts
diff --git a/test/runtime/schema/intersect.ts b/test/runtime/compiler-ajv/intersect.ts
similarity index 100%
rename from test/runtime/schema/intersect.ts
rename to test/runtime/compiler-ajv/intersect.ts
diff --git a/test/runtime/schema/keyof.ts b/test/runtime/compiler-ajv/keyof.ts
similarity index 100%
rename from test/runtime/schema/keyof.ts
rename to test/runtime/compiler-ajv/keyof.ts
diff --git a/test/runtime/schema/literal.ts b/test/runtime/compiler-ajv/literal.ts
similarity index 100%
rename from test/runtime/schema/literal.ts
rename to test/runtime/compiler-ajv/literal.ts
diff --git a/test/runtime/schema/never.ts b/test/runtime/compiler-ajv/never.ts
similarity index 100%
rename from test/runtime/schema/never.ts
rename to test/runtime/compiler-ajv/never.ts
diff --git a/test/runtime/schema/not.ts b/test/runtime/compiler-ajv/not.ts
similarity index 100%
rename from test/runtime/schema/not.ts
rename to test/runtime/compiler-ajv/not.ts
diff --git a/test/runtime/schema/null.ts b/test/runtime/compiler-ajv/null.ts
similarity index 100%
rename from test/runtime/schema/null.ts
rename to test/runtime/compiler-ajv/null.ts
diff --git a/test/runtime/schema/number.ts b/test/runtime/compiler-ajv/number.ts
similarity index 100%
rename from test/runtime/schema/number.ts
rename to test/runtime/compiler-ajv/number.ts
diff --git a/test/runtime/schema/object.ts b/test/runtime/compiler-ajv/object.ts
similarity index 100%
rename from test/runtime/schema/object.ts
rename to test/runtime/compiler-ajv/object.ts
diff --git a/test/runtime/schema/omit.ts b/test/runtime/compiler-ajv/omit.ts
similarity index 100%
rename from test/runtime/schema/omit.ts
rename to test/runtime/compiler-ajv/omit.ts
diff --git a/test/runtime/schema/optional.ts b/test/runtime/compiler-ajv/optional.ts
similarity index 100%
rename from test/runtime/schema/optional.ts
rename to test/runtime/compiler-ajv/optional.ts
diff --git a/test/runtime/schema/partial.ts b/test/runtime/compiler-ajv/partial.ts
similarity index 100%
rename from test/runtime/schema/partial.ts
rename to test/runtime/compiler-ajv/partial.ts
diff --git a/test/runtime/schema/pick.ts b/test/runtime/compiler-ajv/pick.ts
similarity index 100%
rename from test/runtime/schema/pick.ts
rename to test/runtime/compiler-ajv/pick.ts
diff --git a/test/runtime/schema/readonly-optional.ts b/test/runtime/compiler-ajv/readonly-optional.ts
similarity index 100%
rename from test/runtime/schema/readonly-optional.ts
rename to test/runtime/compiler-ajv/readonly-optional.ts
diff --git a/test/runtime/schema/readonly.ts b/test/runtime/compiler-ajv/readonly.ts
similarity index 100%
rename from test/runtime/schema/readonly.ts
rename to test/runtime/compiler-ajv/readonly.ts
diff --git a/test/runtime/schema/record.ts b/test/runtime/compiler-ajv/record.ts
similarity index 100%
rename from test/runtime/schema/record.ts
rename to test/runtime/compiler-ajv/record.ts
diff --git a/test/runtime/schema/recursive.ts b/test/runtime/compiler-ajv/recursive.ts
similarity index 100%
rename from test/runtime/schema/recursive.ts
rename to test/runtime/compiler-ajv/recursive.ts
diff --git a/test/runtime/schema/ref.ts b/test/runtime/compiler-ajv/ref.ts
similarity index 100%
rename from test/runtime/schema/ref.ts
rename to test/runtime/compiler-ajv/ref.ts
diff --git a/test/runtime/schema/regexp.ts b/test/runtime/compiler-ajv/regexp.ts
similarity index 100%
rename from test/runtime/schema/regexp.ts
rename to test/runtime/compiler-ajv/regexp.ts
diff --git a/test/runtime/schema/required.ts b/test/runtime/compiler-ajv/required.ts
similarity index 100%
rename from test/runtime/schema/required.ts
rename to test/runtime/compiler-ajv/required.ts
diff --git a/test/runtime/schema/string.ts b/test/runtime/compiler-ajv/string.ts
similarity index 100%
rename from test/runtime/schema/string.ts
rename to test/runtime/compiler-ajv/string.ts
diff --git a/test/runtime/schema/template-literal.ts b/test/runtime/compiler-ajv/template-literal.ts
similarity index 100%
rename from test/runtime/schema/template-literal.ts
rename to test/runtime/compiler-ajv/template-literal.ts
diff --git a/test/runtime/schema/tuple.ts b/test/runtime/compiler-ajv/tuple.ts
similarity index 100%
rename from test/runtime/schema/tuple.ts
rename to test/runtime/compiler-ajv/tuple.ts
diff --git a/test/runtime/schema/uint8array.ts b/test/runtime/compiler-ajv/uint8array.ts
similarity index 100%
rename from test/runtime/schema/uint8array.ts
rename to test/runtime/compiler-ajv/uint8array.ts
diff --git a/test/runtime/schema/union.ts b/test/runtime/compiler-ajv/union.ts
similarity index 100%
rename from test/runtime/schema/union.ts
rename to test/runtime/compiler-ajv/union.ts
diff --git a/test/runtime/schema/unknown.ts b/test/runtime/compiler-ajv/unknown.ts
similarity index 100%
rename from test/runtime/schema/unknown.ts
rename to test/runtime/compiler-ajv/unknown.ts
diff --git a/test/runtime/schema/unsafe.ts b/test/runtime/compiler-ajv/unsafe.ts
similarity index 100%
rename from test/runtime/schema/unsafe.ts
rename to test/runtime/compiler-ajv/unsafe.ts
diff --git a/test/runtime/schema/validate.ts b/test/runtime/compiler-ajv/validate.ts
similarity index 100%
rename from test/runtime/schema/validate.ts
rename to test/runtime/compiler-ajv/validate.ts
diff --git a/test/runtime/schema/void.ts b/test/runtime/compiler-ajv/void.ts
similarity index 100%
rename from test/runtime/schema/void.ts
rename to test/runtime/compiler-ajv/void.ts
diff --git a/test/runtime/index.ts b/test/runtime/index.ts
index 8f53de837..fb4f897fd 100644
--- a/test/runtime/index.ts
+++ b/test/runtime/index.ts
@@ -1,5 +1,5 @@
 import './compiler/index'
-import './schema/index'
+import './compiler-ajv/index'
 import './errors/index'
 import './system/index'
 import './type/index'

From dd71b52db61a43216ef6864b0caff9ead5d17c9c Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 27 Aug 2023 15:00:39 +0900
Subject: [PATCH 181/369] Revision 0.31.5 (#552)

---
 package-lock.json |  4 ++--
 package.json      |  2 +-
 readme.md         | 38 +++++++++++++++++++-------------------
 src/typebox.ts    | 14 +++++++-------
 4 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 8cb18ccff..3d79d5069 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.4",
+  "version": "0.31.5",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.4",
+      "version": "0.31.5",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 475121baf..7d45a33f4 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.4",
+  "version": "0.31.5",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 05345fec0..4a28c9058 100644
--- a/readme.md
+++ b/readme.md
@@ -277,7 +277,7 @@ The following table lists the supported Json types. These types are fully compat
 │ const T = Type.Tuple([         │ type T = [number, number]   │ const T = {                    │
 │   Type.Number(),               │                             │   type: 'array',               │
 │   Type.Number()                │                             │   items: [{                    │
-│ ])                             │                             │      type: 'number'            │
+│ ])                             │                             │     type: 'number'             │
 │                                │                             │   }, {                         │
 │                                │                             │     type: 'number'             │
 │                                │                             │   }],                          │
@@ -312,9 +312,9 @@ The following table lists the supported Json types. These types are fully compat
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Union([         │ type T = string | number    │ const T = {                    │
 │   Type.String(),               │                             │   anyOf: [{                    │
-│   Type.Number()                │                             │      type: 'string'            │
+│   Type.Number()                │                             │     type: 'string'             │
 │ ])                             │                             │   }, {                         │
-│                                │                             │      type: 'number'            │
+│                                │                             │     type: 'number'             │
 │                                │                             │   }]                           │
 │                                │                             │ }                              │
 │                                │                             │                                │
@@ -472,10 +472,10 @@ The following table lists the supported Json types. These types are fully compat
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const A = Type.Tuple([         │ type A = [0, 1]             │ const T = {                    │
 │   Type.Literal(0),             │ type B = [2, 3]             │   type: 'array',               │
-│   Type.Literal(1)              │ type T = [...A, ...B]       │   items: [                     │
-│ ])                             │                             │     { const: 0 },              │
-│ const B = Type.Tuple([         │                             │     { const: 1 },              │
-|   Type.Literal(2),             │                             │     { const: 2 },              │
+│   Type.Literal(1)              │ type T = [                  │   items: [                     │
+│ ])                             │   ...A,                     │     { const: 0 },              │
+│ const B = Type.Tuple([         │   ...B                      │     { const: 1 },              │
+|   Type.Literal(2),             │ ]                           │     { const: 2 },              │
 |   Type.Literal(3)              │                             │     { const: 3 }               │
 │ ])                             │                             │   ],                           │
 │ const T = Type.Tuple([         │                             │   additionalItems: false,      │
@@ -485,26 +485,26 @@ The following table lists the supported Json types. These types are fully compat
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Uncapitalize(   │ type T = Uncapitalize<      │ const T = {                    │
-│   Type.Literal('Hello')        │   'Hello'                   │    type: 'string',             │
-│ )                              │ >                           │    const: 'hello'              │
+│   Type.Literal('Hello')        │   'Hello'                   │   type: 'string',              │
+│ )                              │ >                           │   const: 'hello'               │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Capitalize(     │ type T = Capitalize<        │ const T = {                    │
-│   Type.Literal('hello')        │   'hello'                   │    type: 'string',             │
-│ )                              │ >                           │    const: 'Hello'              │
+│   Type.Literal('hello')        │   'hello'                   │   type: 'string',              │
+│ )                              │ >                           │   const: 'Hello'               │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Uppercase(      │ type T = Uppercase<         │ const T = {                    │
-│   Type.Literal('hello')        │   'hello'                   │    type: 'string',             │
-│ )                              │ >                           │    const: 'HELLO'              │
+│   Type.Literal('hello')        │   'hello'                   │   type: 'string',              │
+│ )                              │ >                           │   const: 'HELLO'               │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Lowercase(      │ type T = Lowercase<         │ const T = {                    │
-│   Type.Literal('HELLO')        │   'HELLO'                   │    type: 'string',             │
-│ )                              │ >                           │    const: 'hello'              │
+│   Type.Literal('HELLO')        │   'HELLO'                   │   type: 'string',              │
+│ )                              │ >                           │   const: 'hello'               │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -533,26 +533,26 @@ TypeBox provides an extended type set that can be used to create schematics for
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Constructor([   │ type T = new (              │ const T = {                    │
-│   Type.String(),               │  arg0: string,              │   type: 'constructor',         │
+│   Type.String(),               │  arg0: string,              │   type: 'Constructor',         │
 │   Type.Number()                │  arg0: number               │   parameters: [{               │
 │ ], Type.Boolean())             │ ) => boolean                │     type: 'string'             │
 │                                │                             │   }, {                         │
 │                                │                             │     type: 'number'             │
 │                                │                             │   }],                          │
-│                                │                             │   return: {                    │
+│                                │                             │   returns: {                   │
 │                                │                             │     type: 'boolean'            │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Function([      │ type T = (                  │ const T = {                    │
-|   Type.String(),               │  arg0: string,              │   type: 'function',            │
+|   Type.String(),               │  arg0: string,              │   type: 'Function',            │
 │   Type.Number()                │  arg1: number               │   parameters: [{               │
 │ ], Type.Boolean())             │ ) => boolean                │     type: 'string'             │
 │                                │                             │   }, {                         │
 │                                │                             │     type: 'number'             │
 │                                │                             │   }],                          │
-│                                │                             │   return: {                    │
+│                                │                             │   returns: {                   │
 │                                │                             │     type: 'boolean'            │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
diff --git a/src/typebox.ts b/src/typebox.ts
index d33380c12..d4f7ca769 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -311,7 +311,7 @@ export type TConstructorParameterArray<T extends readonly TSchema[], P extends u
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Constructor'
   static: new (...param: TConstructorParameterArray<T, this['params']>) => Static<U, this['params']>
-  type: 'constructor'
+  type: 'Constructor'
   parameters: T
   returns: U
 }
@@ -390,7 +390,7 @@ export type TFunctionParameters<T extends TSchema[], P extends unknown[]> = [...
 export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Function'
   static: (...param: TFunctionParameters<T, this['params']>) => Static<U, this['params']>
-  type: 'function'
+  type: 'Function'
   parameters: T
   returns: U
 }
@@ -641,7 +641,7 @@ export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any>
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Promise'
   static: Promise<Static<T, this['params']>>
-  type: 'promise'
+  type: 'Promise'
   item: TSchema
 }
 // --------------------------------------------------------------------------
@@ -1204,7 +1204,7 @@ export namespace TypeGuard {
     // prettier-ignore
     return (
       TKindOf(schema, 'Constructor') && 
-      schema.type === 'constructor' &&
+      schema.type === 'Constructor' &&
       IsOptionalString(schema.$id) && 
       ValueGuard.IsArray(schema.parameters) &&
       schema.parameters.every(schema => TSchema(schema)) &&
@@ -1229,7 +1229,7 @@ export namespace TypeGuard {
     // prettier-ignore
     return (
       TKindOf(schema, 'Function') &&
-      schema.type === 'function' &&
+      schema.type === 'Function' &&
       IsOptionalString(schema.$id) && 
       ValueGuard.IsArray(schema.parameters) && 
       schema.parameters.every(schema => TSchema(schema)) &&
@@ -3300,7 +3300,7 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
   /** `[JavaScript]` Creates a Constructor type */
   public Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U> {
     const [clonedParameters, clonedReturns] = [TypeClone.Rest(parameters), TypeClone.Type(returns)]
-    return this.Create({ ...options, [Kind]: 'Constructor', type: 'constructor', parameters: clonedParameters, returns: clonedReturns })
+    return this.Create({ ...options, [Kind]: 'Constructor', type: 'Constructor', parameters: clonedParameters, returns: clonedReturns })
   }
   /** `[JavaScript]` Creates a Date type */
   public Date(options: DateOptions = {}): TDate {
@@ -3309,7 +3309,7 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
   /** `[JavaScript]` Creates a Function type */
   public Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U> {
     const [clonedParameters, clonedReturns] = [TypeClone.Rest(parameters), TypeClone.Type(returns)]
-    return this.Create({ ...options, [Kind]: 'Function', type: 'function', parameters: clonedParameters, returns: clonedReturns })
+    return this.Create({ ...options, [Kind]: 'Function', type: 'Function', parameters: clonedParameters, returns: clonedReturns })
   }
   /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
   public InstanceType<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TInstanceType<T> {

From 67925c10a36c786e538d502034c7af08397e52e9 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 29 Aug 2023 18:24:26 +0900
Subject: [PATCH 182/369] Revision 0.31.6 (#560)

---
 package-lock.json                |  4 +--
 package.json                     |  2 +-
 src/typebox.ts                   | 47 +++++++++++++++-----------------
 src/value/value.ts               |  8 +++---
 test/static/readonly-optional.ts | 19 ++++++++++++-
 test/static/transform.ts         | 33 +++++++++++++++++++++-
 6 files changed, 79 insertions(+), 34 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 3d79d5069..c9126a5d3 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.5",
+  "version": "0.31.6",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.5",
+      "version": "0.31.6",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 7d45a33f4..d4ca52eea 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.5",
+  "version": "0.31.6",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index d4f7ca769..b89bab520 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -66,7 +66,7 @@ export type AssertType<T, E extends TSchema = TSchema> = T extends E ? T : TNeve
 // --------------------------------------------------------------------------
 // Modifiers
 // --------------------------------------------------------------------------
-export type TModifier = TOptional<TSchema> | TReadonly<TSchema>
+export type TReadonlyOptional<T extends TSchema> = TOptional<T> & TReadonly<T>
 export type TReadonly<T extends TSchema> = T & { [Readonly]: 'Readonly' }
 export type TOptional<T extends TSchema> = T & { [Optional]: 'Optional' }
 // --------------------------------------------------------------------------
@@ -855,37 +855,34 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
 // TTransform
 // --------------------------------------------------------------------------
 // prettier-ignore
-export type DecodeModifier<D extends TSchema, T extends TSchema> =
-  T extends TReadonly<T> & TOptional<T> ? TReadonly<TOptional<D>> :
-  T extends TReadonly<T> ? TReadonly<D> :
-  T extends TOptional<T> ? TOptional<D> :
-  D
-// prettier-ignore
 export type DecodeProperties<T extends TProperties> = {
   [K in keyof T]: DecodeType<T[K]>
 }
 // prettier-ignore
-export type DecodeRest<T extends TSchema[]> = T extends [infer L, ...infer R]
-  ? [DecodeType<AssertType<L>>, ...DecodeRest<AssertRest<R>>]
+export type DecodeRest<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+  ? [DecodeType<L>, ...DecodeRest<R>]
   : []
 // prettier-ignore
-export type DecodeType<T extends TSchema> =
-  T extends TTransform<infer _, infer R> ? DecodeModifier<TUnsafe<R>, T> : 
-  T extends TArray<infer S> ? DecodeModifier<TArray<DecodeType<S>>, T> :
-  T extends TAsyncIterator<infer S> ? DecodeModifier<TAsyncIterator<DecodeType<S>>, T> :
-  T extends TConstructor<infer P, infer R> ? DecodeModifier<TConstructor<AssertRest<DecodeRest<P>>, DecodeType<R>>, T> :
-  T extends TFunction<infer P, infer R> ? DecodeModifier<TFunction<AssertRest<DecodeRest<P>>, DecodeType<R>>, T> :
-  T extends TIntersect<infer S> ? DecodeModifier<TIntersect<AssertRest<DecodeRest<S>>>, T> :
-  T extends TIterator<infer S> ? DecodeModifier<TIterator<DecodeType<S>>, T> :
-  T extends TNot<infer S> ? DecodeModifier<TNot<DecodeType<S>>, T> :
-  T extends TObject<infer S> ? DecodeModifier<TObject<Evaluate<DecodeProperties<S>>>, T> :
-  T extends TPromise<infer S> ? DecodeModifier<TPromise<DecodeType<S>>, T> :
-  T extends TRecord<infer K, infer S> ? DecodeModifier<TRecord<K, DecodeType<S>>, T> :
-  T extends TRecursive<infer S> ? DecodeModifier<TRecursive<DecodeType<S>>, T> :
-  T extends TRef<infer S> ? DecodeModifier<TRef<DecodeType<S>>, T> :
-  T extends TTuple<infer S> ? DecodeModifier<TTuple<AssertRest<DecodeRest<S>>>, T> :
-  T extends TUnion<infer S> ? DecodeModifier<TUnion<AssertRest<DecodeRest<S>>>, T> :
+export type DecodeType<T extends TSchema> = (
+  T extends TOptional<infer S extends TSchema> ? TOptional<DecodeType<S>> :
+  T extends TReadonly<infer S extends TSchema> ? TReadonly<DecodeType<S>> :
+  T extends TTransform<infer _, infer R> ? TUnsafe<R> :
+  T extends TArray<infer S extends TSchema> ? Array<DecodeType<S>> :
+  T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> :
+  T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<P, DecodeType<R>> :
+  T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<P, DecodeType<R>> :
+  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<S> :
+  T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> :
+  T extends TNot<infer S extends TSchema> ? TNot<DecodeType<S>> :
+  T extends TObject<infer S> ? TObject<Evaluate<DecodeProperties<S>>> :
+  T extends TPromise<infer S extends TSchema> ? TPromise<DecodeType<S>> :
+  T extends TRecord<infer K, infer S> ? TRecord<K, DecodeType<S>> :
+  T extends TRecursive<infer S extends TSchema> ? TRecursive<DecodeType<S>> :
+  T extends TRef<infer S extends TSchema> ? TRef<DecodeType<S>> :
+  T extends TTuple<infer S extends TSchema[]> ? TTuple<S> :
+  T extends TUnion<infer S extends TSchema[]> ? TUnion<S> :
   T
+)
 export type TransformFunction<T = any, U = any> = (value: T) => U
 export interface TransformOptions<I extends TSchema = TSchema, O extends unknown = unknown> {
   Decode: TransformFunction<StaticDecode<I>, O>
diff --git a/src/value/value.ts b/src/value/value.ts
index 59b8dbe00..edeec7dae 100644
--- a/src/value/value.ts
+++ b/src/value/value.ts
@@ -78,9 +78,9 @@ export namespace Value {
     return ValueClone.Clone(value)
   }
   /** Decodes a value or throws if error */
-  export function Decode<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): Types.StaticDecode<T>
+  export function Decode<T extends Types.TSchema, D = Types.StaticDecode<T>>(schema: T, references: Types.TSchema[], value: unknown): D
   /** Decodes a value or throws if error */
-  export function Decode<T extends Types.TSchema>(schema: T, value: unknown): Types.StaticDecode<T>
+  export function Decode<T extends Types.TSchema, D = Types.StaticDecode<T>>(schema: T, value: unknown): D
   /** Decodes a value or throws if error */
   export function Decode(...args: any[]) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
@@ -88,9 +88,9 @@ export namespace Value {
     return ValueTransform.DecodeTransform.Decode(schema, references, value, ValueCheck.Check)
   }
   /** Encodes a value or throws if error */
-  export function Encode<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): Types.StaticEncode<T>
+  export function Encode<T extends Types.TSchema, E = Types.StaticEncode<T>>(schema: T, references: Types.TSchema[], value: unknown): E
   /** Encodes a value or throws if error */
-  export function Encode<T extends Types.TSchema>(schema: T, value: unknown): Types.StaticEncode<T>
+  export function Encode<T extends Types.TSchema, E = Types.StaticEncode<T>>(schema: T, value: unknown): E
   /** Encodes a value or throws if error */
   export function Encode(...args: any[]) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
diff --git a/test/static/readonly-optional.ts b/test/static/readonly-optional.ts
index 3191dcd75..aca58d0ba 100644
--- a/test/static/readonly-optional.ts
+++ b/test/static/readonly-optional.ts
@@ -1,5 +1,5 @@
 import { Expect } from './assert'
-import { Type, TSchema } from '@sinclair/typebox'
+import { Type, TSchema, TReadonlyOptional } from '@sinclair/typebox'
 
 {
   const T = Type.Object({
@@ -9,3 +9,20 @@ import { Type, TSchema } from '@sinclair/typebox'
     readonly A?: string
   }>()
 }
+{
+  const T = Type.ReadonlyOptional(Type.String())
+  function test(_: TReadonlyOptional<TSchema>) {}
+  test(T)
+}
+{
+  const T = Type.Readonly(Type.String())
+  function test(_: TReadonlyOptional<TSchema>) {}
+  // @ts-expect-error
+  test(T)
+}
+{
+  const T = Type.Optional(Type.String())
+  function test(_: TReadonlyOptional<TSchema>) {}
+  // @ts-expect-error
+  test(T)
+}
\ No newline at end of file
diff --git a/test/static/transform.ts b/test/static/transform.ts
index 3e02df125..e6770917e 100644
--- a/test/static/transform.ts
+++ b/test/static/transform.ts
@@ -1,4 +1,4 @@
-import { Type, Static, StaticDecode, TObject, TNumber } from '@sinclair/typebox'
+import { Type, TSchema, Static, StaticDecode, TObject, TNumber } from '@sinclair/typebox'
 import { Expect } from './assert'
 {
   // string > number
@@ -214,3 +214,34 @@ import { Expect } from './assert'
   Expect(T).ToStaticDecode<{ x: '1' }>()
   Expect(T).ToStaticDecode<{ x: undefined }>()
 }
+{ // should decode within generic function context
+  // https://github.com/sinclairzx81/typebox/issues/554
+  // prettier-ignore
+  const ArrayOrSingle = <T extends TSchema>(schema: T) =>
+    Type.Transform(Type.Union([schema, Type.Array(schema)]))
+      .Decode((value) => (Array.isArray(value) ? value : [value]))
+      .Encode((value) => (value.length === 1 ? value[0] : value) as Static<T>[]);
+  const T = ArrayOrSingle(Type.String())
+  Expect(T).ToStaticDecode<string[]>()
+}
+{
+  // should correctly decode record keys
+  // https://github.com/sinclairzx81/typebox/issues/555
+  // prettier-ignore
+  const T = Type.Object({
+    x: Type.Optional(Type.Record(Type.Number(), Type.String()))
+  })
+  type A = StaticDecode<typeof T>
+  type Test<A, E> = E extends A ? true : false
+  type E1 = Test<A, {}>
+  type E2 = Test<A, { x: undefined }>
+  type E3 = Test<A, { x: { 1: '' } }>
+  type E4 = Test<A, { x: { 1: 1 } }>
+  type E5 = Test<A, { x: { x: 1 } }>
+  // assignment
+  const E1: E1 = true
+  const E2: E2 = true
+  const E3: E3 = true
+  const E4: E4 = false
+  const E5: E5 = true
+}

From c41d29ae3b480a61eff2228270de267afd0c53be Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 29 Aug 2023 18:25:24 +0900
Subject: [PATCH 183/369] Formatting

---
 test/static/readonly-optional.ts | 2 +-
 test/static/transform.ts         | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/test/static/readonly-optional.ts b/test/static/readonly-optional.ts
index aca58d0ba..f51696bd7 100644
--- a/test/static/readonly-optional.ts
+++ b/test/static/readonly-optional.ts
@@ -25,4 +25,4 @@ import { Type, TSchema, TReadonlyOptional } from '@sinclair/typebox'
   function test(_: TReadonlyOptional<TSchema>) {}
   // @ts-expect-error
   test(T)
-}
\ No newline at end of file
+}
diff --git a/test/static/transform.ts b/test/static/transform.ts
index e6770917e..a6a529e42 100644
--- a/test/static/transform.ts
+++ b/test/static/transform.ts
@@ -214,7 +214,8 @@ import { Expect } from './assert'
   Expect(T).ToStaticDecode<{ x: '1' }>()
   Expect(T).ToStaticDecode<{ x: undefined }>()
 }
-{ // should decode within generic function context
+{
+  // should decode within generic function context
   // https://github.com/sinclairzx81/typebox/issues/554
   // prettier-ignore
   const ArrayOrSingle = <T extends TSchema>(schema: T) =>

From 233cc2215a4ee58b2fa2bd9c4bb59d03bfb37874 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 30 Aug 2023 03:44:17 +0900
Subject: [PATCH 184/369] Revision 0.31.7 (#562)

---
 package-lock.json        | 4 ++--
 package.json             | 2 +-
 src/typebox.ts           | 2 +-
 test/static/transform.ts | 8 ++++++++
 4 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index c9126a5d3..3870c3066 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.6",
+  "version": "0.31.7",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.6",
+      "version": "0.31.7",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index d4ca52eea..8b547772a 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.6",
+  "version": "0.31.7",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index b89bab520..7a3fa3e01 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -867,7 +867,7 @@ export type DecodeType<T extends TSchema> = (
   T extends TOptional<infer S extends TSchema> ? TOptional<DecodeType<S>> :
   T extends TReadonly<infer S extends TSchema> ? TReadonly<DecodeType<S>> :
   T extends TTransform<infer _, infer R> ? TUnsafe<R> :
-  T extends TArray<infer S extends TSchema> ? Array<DecodeType<S>> :
+  T extends TArray<infer S extends TSchema> ? TArray<DecodeType<S>> :
   T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> :
   T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<P, DecodeType<R>> :
   T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<P, DecodeType<R>> :
diff --git a/test/static/transform.ts b/test/static/transform.ts
index a6a529e42..f1e4f6368 100644
--- a/test/static/transform.ts
+++ b/test/static/transform.ts
@@ -246,3 +246,11 @@ import { Expect } from './assert'
   const E4: E4 = false
   const E5: E5 = true
 }
+{
+  // should correctly decode array
+  // https://github.com/sinclairzx81/typebox/issues/561
+  const T = Type.Object({
+    x: Type.Array(Type.Object({ y: Type.String() })),
+  })
+  Expect(T).ToStaticDecode<{ x: { y: string }[] }>()
+}

From 010ff1840c7ab43d3df6a52f922e365184635217 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 30 Aug 2023 04:59:00 +0900
Subject: [PATCH 185/369] Documentation

---
 readme.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/readme.md b/readme.md
index 4a28c9058..cd4af3af3 100644
--- a/readme.md
+++ b/readme.md
@@ -58,11 +58,11 @@ type T = Static<typeof T>                            // type T = {
 
 ## Overview
 
-TypeBox is a runtime type builder that creates Json Schema objects that infer as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript or runtime checked using standard Json Schema validation.
+TypeBox is a runtime type builder that creates Json Schema objects that infer as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript or runtime asserted using standard Json Schema validation.
 
-TypeBox types are designed to express industry standard schematics as TypeScript types. All types are runtime reflectable, serializable and publishable by default. It includes an extensible type system able to represent type safe schematics for multiple schema specifications. It also provides a high performance validation compiler, various tools for working with dynamic data and offers detailed structured error reporting. 
+TypeBox uses industry standard schematics for runtime type representation; enabling types to be reflected, serialized and published directly. Its type system is fully extensible and able to support type representation for multiple schema specifications. It also provides a high performance validation compiler, various tools for working with dynamic data and offers detailed structured error reporting. 
 
-TypeBox can be used as a simple tool to build up complex schemas or integrated into applications to enable high performance runtime validation for data received over the wire.
+TypeBox can be used as a simple tool to build up complex schemas or integrated into applications and frameworks to enable high performance runtime type checking for data received over the wire.
 
 License MIT
 

From 9c42cbc1e00caaed670d12de36e73021b2afc1a0 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 31 Aug 2023 05:35:49 +0900
Subject: [PATCH 186/369] Revision 0.31.8 (#566)

* Discard on Mapped Object Types

* Discard Identifier Tests
---
 package-lock.json                   |  4 ++--
 package.json                        |  2 +-
 src/typebox.ts                      | 22 ++++++++++---------
 test/runtime/type/guard/omit.ts     | 34 +++++++++++++++++++----------
 test/runtime/type/guard/partial.ts  | 34 +++++++++++++++++++----------
 test/runtime/type/guard/pick.ts     | 34 +++++++++++++++++++----------
 test/runtime/type/guard/required.ts | 34 +++++++++++++++++++----------
 7 files changed, 103 insertions(+), 61 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 3870c3066..8333c62ba 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.7",
+  "version": "0.31.8",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.7",
+      "version": "0.31.8",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 8b547772a..a50bc679e 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.7",
+  "version": "0.31.8",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 7a3fa3e01..bd4190a2e 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -2842,10 +2842,12 @@ export class TypeBuilder {
   protected Throw(message: string): never {
     throw new TypeBuilderError(message)
   }
-  /** `[Internal]` Discards a property key from the given schema */
-  protected Discard(schema: TSchema, key: PropertyKey): TSchema {
-    const { [key as any]: _, ...rest } = schema
-    return rest as TSchema
+  /** `[Internal]` Discards property keys from the given record type */
+  protected Discard(record: Record<PropertyKey, any>, keys: PropertyKey[]) {
+    return keys.reduce((acc, key) => {
+      const { [key as any]: _, ...rest } = acc
+      return rest
+    }, record) as any
   }
   /** `[Json]` Omits compositing symbols from this schema */
   public Strict<T extends TSchema>(schema: T): T {
@@ -3082,7 +3084,7 @@ export class JsonTypeBuilder extends TypeBuilder {
   public Omit(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
     const keys = KeyArrayResolver.Resolve(unresolved)
     // prettier-ignore
-    return ObjectMap.Map(this.Discard(TypeClone.Type(schema), Transform), (object) => {
+    return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ['$id', Transform]), (object) => {
       if (ValueGuard.IsArray(object.required)) {
         object.required = object.required.filter((key: string) => !keys.includes(key as any))
         if (object.required.length === 0) delete object.required
@@ -3096,11 +3098,11 @@ export class JsonTypeBuilder extends TypeBuilder {
   /** `[Json]` Constructs a type where all properties are optional */
   public Partial<T extends TSchema>(schema: T, options: ObjectOptions = {}): TPartial<T> {
     // prettier-ignore
-    return ObjectMap.Map(this.Discard(TypeClone.Type(schema), Transform), (object) => {
+    return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ['$id', Transform]), (object) => {
       const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
         return { ...acc, [key]: this.Optional(object.properties[key]) }
       }, {} as TProperties)
-      return this.Object(properties, this.Discard(object, 'required') /* object used as options to retain other constraints */)
+      return this.Object(properties, this.Discard(object, ['required']) /* object used as options to retain other constraints */)
     }, options)
   }
   /** `[Json]` Constructs a type whose keys are picked from the given type */
@@ -3117,7 +3119,7 @@ export class JsonTypeBuilder extends TypeBuilder {
   public Pick(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
     const keys = KeyArrayResolver.Resolve(unresolved)
     // prettier-ignore
-    return ObjectMap.Map(this.Discard(TypeClone.Type(schema), Transform), (object) => {
+    return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ['$id', Transform]), (object) => {
       if (ValueGuard.IsArray(object.required)) {
         object.required = object.required.filter((key: any) => keys.includes(key))
         if (object.required.length === 0) delete object.required
@@ -3182,9 +3184,9 @@ export class JsonTypeBuilder extends TypeBuilder {
   /** `[Json]` Constructs a type where all properties are required */
   public Required<T extends TSchema>(schema: T, options: SchemaOptions = {}): TRequired<T> {
     // prettier-ignore
-    return ObjectMap.Map(this.Discard(TypeClone.Type(schema), Transform), (object) => {
+    return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ['$id', Transform]), (object) => {
       const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
-        return { ...acc, [key]: this.Discard(object.properties[key], Optional) as TSchema }
+        return { ...acc, [key]: this.Discard(object.properties[key], [Optional]) as TSchema }
       }, {} as TProperties)
       return this.Object(properties, object /* object used as options to retain other constraints  */)
     }, options)
diff --git a/test/runtime/type/guard/omit.ts b/test/runtime/type/guard/omit.ts
index 1ceb07b1e..7b19d146c 100644
--- a/test/runtime/type/guard/omit.ts
+++ b/test/runtime/type/guard/omit.ts
@@ -102,18 +102,28 @@ describe('type/guard/TOmit', () => {
     Assert.IsTrue(TypeGuard.TNumber(T.properties.ad))
     Assert.IsEqual(T.required, ['ad'])
   })
+  // ----------------------------------------------------------------
+  // Discard
+  // ----------------------------------------------------------------
+  it('Should override $id', () => {
+    const A = Type.Object({ x: Type.Number() }, { $id: 'A' })
+    const T = Type.Omit(A, ['x'], { $id: 'T' })
+    Assert.IsEqual(T.$id!, 'T')
+  })
+  it('Should discard $id', () => {
+    const A = Type.Object({ x: Type.Number() }, { $id: 'A' })
+    const T = Type.Omit(A, ['x'])
+    Assert.IsFalse('$id' in T)
+  })
   it('Should discard transform', () => {
-    const S = Type.Transform(
-      Type.Object({
-        x: Type.Number(),
-        y: Type.String(),
-      }),
-      {
-        Decode: (value) => value,
-        Encode: (value) => value,
-      },
-    )
-    const T = Type.Omit(S, ['x'])
-    Assert.IsFalse(Transform in T)
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+    })
+    const S = Type.Transform(T)
+      .Decode((value) => value)
+      .Encode((value) => value)
+    const R = Type.Omit(S, ['x'])
+    Assert.IsFalse(Transform in R)
   })
 })
diff --git a/test/runtime/type/guard/partial.ts b/test/runtime/type/guard/partial.ts
index 8cb963bde..cd248bb31 100644
--- a/test/runtime/type/guard/partial.ts
+++ b/test/runtime/type/guard/partial.ts
@@ -40,18 +40,28 @@ describe('type/guard/TPartial', () => {
     Assert.IsEqual(T.anyOf[0].required, undefined)
     Assert.IsEqual(T.anyOf[1].required, undefined)
   })
+  // ----------------------------------------------------------------
+  // Discard
+  // ----------------------------------------------------------------
+  it('Should override $id', () => {
+    const A = Type.Object({ x: Type.Number() }, { $id: 'A' })
+    const T = Type.Partial(A, { $id: 'T' })
+    Assert.IsEqual(T.$id!, 'T')
+  })
+  it('Should discard $id', () => {
+    const A = Type.Object({ x: Type.Number() }, { $id: 'A' })
+    const T = Type.Partial(A)
+    Assert.IsFalse('$id' in T)
+  })
   it('Should discard transform', () => {
-    const S = Type.Transform(
-      Type.Object({
-        x: Type.Number(),
-        y: Type.String(),
-      }),
-      {
-        Decode: (value) => value,
-        Encode: (value) => value,
-      },
-    )
-    const T = Type.Partial(S)
-    Assert.IsFalse(Transform in T)
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+    })
+    const S = Type.Transform(T)
+      .Decode((value) => value)
+      .Encode((value) => value)
+    const R = Type.Partial(S)
+    Assert.IsFalse(Transform in R)
   })
 })
diff --git a/test/runtime/type/guard/pick.ts b/test/runtime/type/guard/pick.ts
index b25094ad5..0fcd90573 100644
--- a/test/runtime/type/guard/pick.ts
+++ b/test/runtime/type/guard/pick.ts
@@ -104,18 +104,28 @@ describe('type/guard/TPick', () => {
     Assert.IsTrue(TypeGuard.TNumber(T.properties.ac))
     Assert.IsEqual(T.required, ['ab', 'ac'])
   })
+  // ----------------------------------------------------------------
+  // Discard
+  // ----------------------------------------------------------------
+  it('Should override $id', () => {
+    const A = Type.Object({ x: Type.Number() }, { $id: 'A' })
+    const T = Type.Pick(A, ['x'], { $id: 'T' })
+    Assert.IsEqual(T.$id!, 'T')
+  })
+  it('Should discard $id', () => {
+    const A = Type.Object({ x: Type.Number() }, { $id: 'A' })
+    const T = Type.Pick(A, ['x'])
+    Assert.IsFalse('$id' in T)
+  })
   it('Should discard transform', () => {
-    const S = Type.Transform(
-      Type.Object({
-        x: Type.Number(),
-        y: Type.String(),
-      }),
-      {
-        Decode: (value) => value,
-        Encode: (value) => value,
-      },
-    )
-    const T = Type.Pick(S, ['x'])
-    Assert.IsFalse(Transform in T)
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+    })
+    const S = Type.Transform(T)
+      .Decode((value) => value)
+      .Encode((value) => value)
+    const R = Type.Pick(S, ['x'])
+    Assert.IsFalse(Transform in R)
   })
 })
diff --git a/test/runtime/type/guard/required.ts b/test/runtime/type/guard/required.ts
index 67c0b3858..5af8134d5 100644
--- a/test/runtime/type/guard/required.ts
+++ b/test/runtime/type/guard/required.ts
@@ -37,18 +37,28 @@ describe('type/guard/TRequired', () => {
     Assert.IsEqual(T.anyOf[0].required, ['x'])
     Assert.IsEqual(T.anyOf[1].required, ['y'])
   })
+  // ----------------------------------------------------------------
+  // Discard
+  // ----------------------------------------------------------------
+  it('Should override $id', () => {
+    const A = Type.Object({ x: Type.Number() }, { $id: 'A' })
+    const T = Type.Required(A, { $id: 'T' })
+    Assert.IsEqual(T.$id!, 'T')
+  })
+  it('Should discard $id', () => {
+    const A = Type.Object({ x: Type.Number() }, { $id: 'A' })
+    const T = Type.Required(A)
+    Assert.IsFalse('$id' in T)
+  })
   it('Should discard transform', () => {
-    const S = Type.Transform(
-      Type.Object({
-        x: Type.Number(),
-        y: Type.String(),
-      }),
-      {
-        Decode: (value) => value,
-        Encode: (value) => value,
-      },
-    )
-    const T = Type.Required(S)
-    Assert.IsFalse(Transform in T)
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+    })
+    const S = Type.Transform(T)
+      .Decode((value) => value)
+      .Encode((value) => value)
+    const R = Type.Required(S)
+    Assert.IsFalse(Transform in R)
   })
 })

From 224a4bee5bbc57c57cd7ba3e2f2d5bdcd3ba1898 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 3 Sep 2023 23:04:51 +0900
Subject: [PATCH 187/369] Revision 0.31.9 (#567)

* Experimental Enum

* Reset Example

* More strict type assertions (#569)

* Add experimental type assertions and change tests accordingly

* Improve assertion debugging showing the expected type in the error

* Add complex constraint

* Add reference to equality condition

* Fix intersection assertion

* Add ToStaticNever assertion and fix tests accordingly

* Improve test for record with enum key

* Formatting | Enum Union Test

* version

* Constrain to TEnumValue

* Constrain TEnum Argument to TEnumValue

* Ensure Distinct Values

* Enum and Record Guard Tests

* Minor Refactor on Static Assert

---------

Co-authored-by: Angelo Di Pilla <angelo.dipilla@mail.polimi.it>
---
 package-lock.json                 |  4 +-
 package.json                      |  2 +-
 src/typebox.ts                    | 23 ++++-----
 test/runtime/type/guard/enum.ts   | 81 +++++++++++++++++++++++++++++++
 test/runtime/type/guard/index.ts  |  1 +
 test/runtime/type/guard/record.ts | 13 +++++
 test/static/assert.ts             | 64 ++++++++++++++++++++++--
 test/static/awaited.ts            |  4 +-
 test/static/composite.ts          |  2 +-
 test/static/enum.ts               |  4 +-
 test/static/exclude.ts            |  8 +--
 test/static/indexed.ts            |  8 +--
 test/static/intersect.ts          |  5 +-
 test/static/never.ts              |  2 +-
 test/static/record.ts             | 14 ++++++
 test/static/recursive.ts          |  4 +-
 test/static/rest.ts               |  4 +-
 test/static/transform.ts          | 19 +++-----
 test/static/union.ts              |  2 +-
 19 files changed, 210 insertions(+), 54 deletions(-)
 create mode 100644 test/runtime/type/guard/enum.ts

diff --git a/package-lock.json b/package-lock.json
index 8333c62ba..67acd05fd 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.8",
+  "version": "0.31.9",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.8",
+      "version": "0.31.9",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index a50bc679e..ce7831fe5 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.8",
+  "version": "0.31.9",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index bd4190a2e..edca58f8a 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -176,7 +176,6 @@ export type TAnySchema =
   | TBoolean
   | TConstructor
   | TDate
-  | TEnum
   | TFunction
   | TInteger
   | TIntersect
@@ -338,15 +337,12 @@ export interface TDate extends TSchema, DateOptions {
 // --------------------------------------------------------------------------
 // TEnum
 // --------------------------------------------------------------------------
-export interface TEnumOption<T> {
-  type: 'number' | 'string'
-  const: T
-}
-export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
-  [Kind]: 'Union'
-  static: T[keyof T]
-  anyOf: TLiteral<T[keyof T]>[]
-}
+export type TEnumRecord = Record<TEnumKey, TEnumValue>
+export type TEnumValue = string | number
+export type TEnumKey = string
+export type TEnumToLiteralUnion<T extends TEnumValue> = T extends TEnumValue ? TLiteral<T> : never
+export type TEnumToLiteralTuple<T extends TEnumValue> = UnionToTuple<TEnumToLiteralUnion<T>>
+export type TEnum<T extends TEnumValue> = Ensure<TUnion<AssertRest<TEnumToLiteralTuple<T>>>>
 // --------------------------------------------------------------------------
 // TExtends
 // --------------------------------------------------------------------------
@@ -2900,11 +2896,12 @@ export class JsonTypeBuilder extends TypeBuilder {
     return Type.Object(properties, options) as TComposite<T>
   }
   /** `[Json]` Creates a Enum type */
-  public Enum<V extends string | number, T extends Record<string, V>>(item: T, options: SchemaOptions = {}): TEnum<T> {
+  public Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T[keyof T]> {
     // prettier-ignore
-    const values = Object.getOwnPropertyNames(item).filter((key) => isNaN(key as any)).map((key) => item[key]) as T[keyof T][]
+    const values1 = Object.getOwnPropertyNames(item).filter((key) => isNaN(key as any)).map((key) => item[key]) as T[keyof T][]
+    const values2 = [...new Set(values1)] // ensure distinct
     // prettier-ignore
-    const anyOf = values.map((value) => ValueGuard.IsString(value) 
+    const anyOf = values2.map((value) => ValueGuard.IsString(value) 
       ? { [Kind]: 'Literal', type: 'string' as const, const: value } 
       : { [Kind]: 'Literal', type: 'number' as const, const: value }
     )
diff --git a/test/runtime/type/guard/enum.ts b/test/runtime/type/guard/enum.ts
new file mode 100644
index 000000000..9294ddee9
--- /dev/null
+++ b/test/runtime/type/guard/enum.ts
@@ -0,0 +1,81 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TEnum', () => {
+  // ----------------------------------------------------------------
+  // Enum
+  // ----------------------------------------------------------------
+  it('Should guard for TEnum Enum 1', () => {
+    enum E {
+      A = 1,
+      B = 2,
+      C = 3,
+    }
+    const T = Type.Enum(E)
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 1)
+    Assert.IsEqual(T.anyOf[1].const, 2)
+    Assert.IsEqual(T.anyOf[2].const, 3)
+  })
+  it('Should guard for TEnum Enum 2', () => {
+    enum E {
+      A = 'X',
+      B = 'Y',
+      C = 'Z',
+    }
+    const T = Type.Enum(E)
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'X')
+    Assert.IsEqual(T.anyOf[1].const, 'Y')
+    Assert.IsEqual(T.anyOf[2].const, 'Z')
+  })
+  it('Should guard for TEnum Enum 3', () => {
+    enum E {
+      A = 'X',
+      B = 'Y',
+      C = 'X',
+    }
+    const T = Type.Enum(E)
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'X')
+    Assert.IsEqual(T.anyOf[1].const, 'Y')
+    Assert.IsEqual(T.anyOf.length, 2)
+  })
+  // ----------------------------------------------------------------
+  // Object Literal
+  // ----------------------------------------------------------------
+  it('Should guard for TEnum Object Literal 1', () => {
+    const T = Type.Enum({
+      A: 1,
+      B: 2,
+      C: 3,
+    })
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 1)
+    Assert.IsEqual(T.anyOf[1].const, 2)
+    Assert.IsEqual(T.anyOf[2].const, 3)
+  })
+  it('Should guard for TEnum Object Literal 2', () => {
+    const T = Type.Enum({
+      A: 'X',
+      B: 'Y',
+      C: 'Z',
+    })
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'X')
+    Assert.IsEqual(T.anyOf[1].const, 'Y')
+    Assert.IsEqual(T.anyOf[2].const, 'Z')
+  })
+  it('Should guard for TEnum Object Literal 3', () => {
+    const T = Type.Enum({
+      A: 'X',
+      B: 'Y',
+      C: 'X',
+    })
+    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'X')
+    Assert.IsEqual(T.anyOf[1].const, 'Y')
+    Assert.IsEqual(T.anyOf.length, 2)
+  })
+})
diff --git a/test/runtime/type/guard/index.ts b/test/runtime/type/guard/index.ts
index 534c10f17..3533d6d53 100644
--- a/test/runtime/type/guard/index.ts
+++ b/test/runtime/type/guard/index.ts
@@ -8,6 +8,7 @@ import './capitalize'
 import './composite'
 import './constructor'
 import './date'
+import './enum'
 import './exclude'
 import './extract'
 import './function'
diff --git a/test/runtime/type/guard/record.ts b/test/runtime/type/guard/record.ts
index 6855175fa..987d8bd84 100644
--- a/test/runtime/type/guard/record.ts
+++ b/test/runtime/type/guard/record.ts
@@ -76,6 +76,19 @@ describe('type/guard/TRecord', () => {
     Assert.IsTrue(TypeGuard.TString(T.properties.B))
     Assert.IsTrue(TypeGuard.TString(T.properties.C))
   })
+  it('Should guard overload 12', () => {
+    enum E {
+      A = 'X',
+      B = 'Y',
+      C = 'Z',
+    }
+    const T = Type.Enum(E)
+    const R = Type.Record(T, Type.Null())
+    Assert.IsTrue(TypeGuard.TObject(R))
+    Assert.IsTrue(TypeGuard.TNull(R.properties.X))
+    Assert.IsTrue(TypeGuard.TNull(R.properties.Y))
+    Assert.IsTrue(TypeGuard.TNull(R.properties.Z))
+  })
   // -------------------------------------------------------------
   // Variants
   // -------------------------------------------------------------
diff --git a/test/static/assert.ts b/test/static/assert.ts
index 0e764d992..9a10c8c07 100644
--- a/test/static/assert.ts
+++ b/test/static/assert.ts
@@ -1,9 +1,65 @@
 import { Static, StaticDecode, StaticEncode, TSchema } from '@sinclair/typebox'
 
+// ------------------------------------------------------------------
+// Symbols
+// ------------------------------------------------------------------
+export declare const Unsatisfiable: unique symbol
+// Warning: `never` and `any` satisfy the constraint `extends Expected<...>`
+export type Expected<_> = { [Unsatisfiable]: never }
+// ------------------------------------------------------------------
+// Gates
+// ------------------------------------------------------------------
+export type If<T, Y, N> = T extends true ? Y : N
+export type And<T, U> = If<T, U, false>
+export type Or<T, U> = If<T, true, U>
+export type Not<T> = If<T, false, true>
+// ------------------------------------------------------------------
+// Helpers
+// ------------------------------------------------------------------
+export type Extends<T, U> = [T] extends [U] ? true : false
+export type IsAny<T> = 0 extends 1 & T ? true : false
+export type IsNever<T> = Extends<T, never>
+// ------------------------------------------------------------------
+// Constraints
+// ------------------------------------------------------------------
+// See https://github.com/microsoft/TypeScript/issues/51011
+export type CircularHelper<T, U> = [T] extends U ? T : Expected<T>
+// See https://github.com/Microsoft/TypeScript/issues/27024
+export type ConstrainEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? T : Expected<T>
+export type ConstraintMutuallyExtend<T, U> = CircularHelper<T, [U]>
+// If U is never, there's nothing we can do
+export type ComplexConstraint<T, U> = If<
+  // If U is any, we can't use Expect<T> or it would satisfy the constraint
+  And<Not<IsAny<T>>, IsAny<U>>,
+  never,
+  If<
+    Or<
+      // If they are both any we are happy
+      And<IsAny<T>, IsAny<U>>,
+      // If T extends U, but not because it's any, we are happy
+      And<Extends<T, U>, Not<IsAny<T>>>
+    >,
+    T,
+    Expected<T>
+  >
+>
+// ------------------------------------------------------------------
+// Expect
+// ------------------------------------------------------------------
+export type ExpectResult<T extends TSchema> = If<
+  IsNever<Static<T>>,
+  { ToStaticNever(): void },
+  {
+    ToStatic<U extends ComplexConstraint<Static<T>, U>>(): void
+    ToStaticDecode<U extends ComplexConstraint<StaticDecode<T>, U>>(): void
+    ToStaticEncode<U extends ComplexConstraint<StaticEncode<T>, U>>(): void
+  }
+>
 export function Expect<T extends TSchema>(schema: T) {
   return {
-    ToStatic: <U extends Static<T>>() => {},
-    ToStaticDecode: <U extends StaticDecode<T>>() => {},
-    ToStaticEncode: <U extends StaticEncode<T>>() => {},
-  }
+    ToStatic() {},
+    ToStaticNever() {},
+    ToStaticDecode() {},
+    ToStaticEncode() {},
+  } as ExpectResult<T>
 }
diff --git a/test/static/awaited.ts b/test/static/awaited.ts
index 303e30f89..e9c235c65 100644
--- a/test/static/awaited.ts
+++ b/test/static/awaited.ts
@@ -11,10 +11,10 @@ Expect(Type.Awaited(Type.Promise(Type.Promise(Type.String())))).ToStatic<string>
 
 Expect(Type.Awaited(Type.Union([Type.Promise(Type.String()), Type.Number()]))).ToStatic<string | number>()
 
-Expect(Type.Awaited(Type.Intersect([Type.Promise(Type.String()), Type.Number()]))).ToStatic<string & number>()
+Expect(Type.Awaited(Type.Intersect([Type.Promise(Type.Object({ a: Type.String() })), Type.Object({ b: Type.Number() })]))).ToStatic<{ a: string } & { b: number }>()
 
 // Two Levels
 
 Expect(Type.Awaited(Type.Union([Type.Promise(Type.Promise(Type.String())), Type.Number()]))).ToStatic<string | number>()
 
-Expect(Type.Awaited(Type.Intersect([Type.Promise(Type.Promise(Type.String())), Type.Number()]))).ToStatic<string & number>()
+Expect(Type.Awaited(Type.Intersect([Type.Promise(Type.Promise(Type.Object({ a: Type.String() }))), Type.Object({ b: Type.Number() })]))).ToStatic<{ a: string } & { b: number }>()
diff --git a/test/static/composite.ts b/test/static/composite.ts
index 62528245c..70751619e 100644
--- a/test/static/composite.ts
+++ b/test/static/composite.ts
@@ -63,7 +63,7 @@ import { Type, TObject, TIntersect, TNumber, TBoolean } from '@sinclair/typebox'
   })
   const T = Type.Composite([A, B])
   Expect(T).ToStatic<{
-    A: number | undefined
+    A?: number | undefined
   }>()
 }
 {
diff --git a/test/static/enum.ts b/test/static/enum.ts
index 2833716b7..6d754e2f4 100644
--- a/test/static/enum.ts
+++ b/test/static/enum.ts
@@ -7,8 +7,6 @@ import { Type, Static } from '@sinclair/typebox'
     B = 'hello',
     C = 42,
   }
-
   const T = Type.Enum(E)
-
-  Expect(T).ToStatic<Static<typeof T>>() // ?
+  Expect(T).ToStatic<E.A | E.B | E.C>()
 }
diff --git a/test/static/exclude.ts b/test/static/exclude.ts
index bca6d820a..14e1a5104 100644
--- a/test/static/exclude.ts
+++ b/test/static/exclude.ts
@@ -3,7 +3,7 @@ import { Expect } from './assert'
 
 {
   const T = Type.Exclude(Type.String(), Type.String())
-  Expect(T).ToStatic<never>()
+  Expect(T).ToStaticNever()
 }
 {
   const T = Type.Exclude(Type.String(), Type.Number())
@@ -21,7 +21,7 @@ import { Expect } from './assert'
   const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
 
   const T = Type.Exclude(A, B)
-  Expect(T).ToStatic<never>()
+  Expect(T).ToStaticNever()
 }
 {
   const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
@@ -44,7 +44,7 @@ import { Expect } from './assert'
   const B = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
 
   const T = Type.Exclude(A, B)
-  Expect(T).ToStatic<never>()
+  Expect(T).ToStaticNever()
 }
 {
   const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
@@ -67,7 +67,7 @@ import { Expect } from './assert'
   const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
 
   const T = Type.Exclude(A, B)
-  Expect(T).ToStatic<never>()
+  Expect(T).ToStaticNever()
 }
 {
   const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
diff --git a/test/static/indexed.ts b/test/static/indexed.ts
index cc0c9f24a..a33af5130 100644
--- a/test/static/indexed.ts
+++ b/test/static/indexed.ts
@@ -48,19 +48,19 @@ import { Type, Static } from '@sinclair/typebox'
   const A = Type.Tuple([])
   const R = Type.Index(A, Type.Number())
   type O = Static<typeof R>
-  Expect(R).ToStatic<never>()
+  Expect(R).ToStaticNever()
 }
 {
   const A = Type.Object({})
   const R = Type.Index(A, Type.BigInt()) // Support Overload
   type O = Static<typeof R>
-  Expect(R).ToStatic<never>()
+  Expect(R).ToStatic<unknown>()
 }
 {
   const A = Type.Array(Type.Number())
   const R = Type.Index(A, Type.BigInt()) // Support Overload
   type O = Static<typeof R>
-  Expect(R).ToStatic<never>()
+  Expect(R).ToStatic<unknown>()
 }
 // ------------------------------------------------------------------
 // Intersections
@@ -115,7 +115,7 @@ import { Type, Static } from '@sinclair/typebox'
   const C = Type.Intersect([A, B])
   const R = Type.Index(C, ['x'])
   type O = Static<typeof R>
-  Expect(R).ToStatic<never>()
+  Expect(R).ToStaticNever()
 }
 {
   type A = { x: string; y: number }
diff --git a/test/static/intersect.ts b/test/static/intersect.ts
index 8fc36160e..f4fbffbf0 100644
--- a/test/static/intersect.ts
+++ b/test/static/intersect.ts
@@ -1,5 +1,5 @@
 import { Expect } from './assert'
-import { Type, TOptional, TString, Static } from '@sinclair/typebox'
+import { Type, Static } from '@sinclair/typebox'
 
 {
   const A = Type.Object({
@@ -32,8 +32,7 @@ import { Type, TOptional, TString, Static } from '@sinclair/typebox'
   })
   const T = Type.Intersect([A, B])
 
-  Expect(T.properties.A).ToStatic<TOptional<TString>>()
-  Expect(T.properties.B).ToStatic<TString>()
+  Expect(T).ToStatic<{ A?: string | undefined } & { B: string }>()
 }
 
 // https://github.com/sinclairzx81/typebox/issues/113
diff --git a/test/static/never.ts b/test/static/never.ts
index 8261621e6..18dc62564 100644
--- a/test/static/never.ts
+++ b/test/static/never.ts
@@ -3,5 +3,5 @@ import { Type } from '@sinclair/typebox'
 
 {
   const T = Type.Never()
-  Expect(T).ToStatic<never>()
+  Expect(T).ToStaticNever()
 }
diff --git a/test/static/record.ts b/test/static/record.ts
index a314c46ff..35aa0bb13 100644
--- a/test/static/record.ts
+++ b/test/static/record.ts
@@ -70,3 +70,17 @@ import { Type, Static } from '@sinclair/typebox'
 
   Expect(T).ToStatic<Record<number, string>>()
 }
+
+{
+  enum E {
+    A = 'X',
+    B = 'Y',
+    C = 'Z',
+  }
+  const T = Type.Record(Type.Enum(E), Type.Number())
+  Expect(T).ToStatic<{
+    X: number
+    Y: number
+    Z: number
+  }>()
+}
diff --git a/test/static/recursive.ts b/test/static/recursive.ts
index 7f79ab6f5..cfd5a76c5 100644
--- a/test/static/recursive.ts
+++ b/test/static/recursive.ts
@@ -33,8 +33,8 @@ import { Type, Static } from '@sinclair/typebox'
   )
   const T = Type.Partial(R)
   Expect(T).ToStatic<{
-    id: string | undefined
-    nodes: Static<typeof T>[] | undefined
+    id?: string | undefined
+    nodes?: Static<typeof T>[] | undefined
   }>()
 }
 {
diff --git a/test/static/rest.ts b/test/static/rest.ts
index 4f2bba7f0..0d364a406 100644
--- a/test/static/rest.ts
+++ b/test/static/rest.ts
@@ -4,13 +4,13 @@ import { Type, Static } from '@sinclair/typebox'
   // union never
   const A = Type.String()
   const B = Type.Union(Type.Rest(A))
-  Expect(B).ToStatic<never>()
+  Expect(B).ToStaticNever()
 }
 {
   // intersect never
   const A = Type.String()
   const B = Type.Intersect(Type.Rest(A))
-  Expect(B).ToStatic<never>()
+  Expect(B).ToStaticNever()
 }
 {
   // tuple
diff --git a/test/static/transform.ts b/test/static/transform.ts
index f1e4f6368..b633f9674 100644
--- a/test/static/transform.ts
+++ b/test/static/transform.ts
@@ -84,7 +84,7 @@ import { Expect } from './assert'
     .Encode((value) => ({
       id: 'A',
       nodes: [
-        { id: 'B', nodes: [] }, 
+        { id: 'B', nodes: [] },
         { id: 'C', nodes: [] }
       ]
     }))
@@ -112,7 +112,7 @@ import { Expect } from './assert'
     .Encode((value) => ({
       id: 'A',
       nodes: [
-        { id: 'B', nodes: [] }, 
+        { id: 'B', nodes: [] },
         { id: 'C', nodes: [] }
       ]
     }))
@@ -160,8 +160,8 @@ import { Expect } from './assert'
   // null to typebox type
   // prettier-ignore
   const T = Type.Transform(Type.Null())
-    .Decode(value => Type.Object({ 
-      x: Type.Number(), 
+    .Decode(value => Type.Object({
+      x: Type.Number(),
       y: Type.Number(),
       z: Type.Number()
     }))
@@ -180,7 +180,7 @@ import { Expect } from './assert'
   //   x: number;
   //   y: number;
   //   z: number;
-  // } // lol
+  // }
 }
 {
   // ensure decode as optional
@@ -189,8 +189,7 @@ import { Expect } from './assert'
     x: Type.Optional(Type.Number()),
     y: Type.Optional(Type.Number())
   })
-  Expect(T).ToStaticDecode<{ x: undefined; y: undefined }>()
-  Expect(T).ToStaticDecode<{ x: 1; y: 1 }>()
+  Expect(T).ToStaticDecode<{ x?: number | undefined; y?: number | undefined }>()
 }
 {
   // ensure decode as readonly
@@ -199,7 +198,7 @@ import { Expect } from './assert'
     x: Type.Readonly(Type.Number()),
     y: Type.Readonly(Type.Number())
   })
-  Expect(T).ToStaticDecode<{ readonly x: 1; readonly y: 1 }>()
+  Expect(T).ToStaticDecode<{ readonly x: number; readonly y: number }>()
 }
 {
   // ensure decode as optional union
@@ -210,9 +209,7 @@ import { Expect } from './assert'
       Type.Number()
     ]))
   })
-  Expect(T).ToStaticDecode<{ x: 1 }>()
-  Expect(T).ToStaticDecode<{ x: '1' }>()
-  Expect(T).ToStaticDecode<{ x: undefined }>()
+  Expect(T).ToStaticDecode<{ x?: string | number | undefined }>()
 }
 {
   // should decode within generic function context
diff --git a/test/static/union.ts b/test/static/union.ts
index 3529e5465..9c9895ee0 100644
--- a/test/static/union.ts
+++ b/test/static/union.ts
@@ -69,5 +69,5 @@ import { Type, Static } from '@sinclair/typebox'
 
 {
   const T = Type.Union([])
-  Expect(T).ToStatic<never>()
+  Expect(T).ToStaticNever()
 }

From 2b83dc6ad26bd20e3f0ff3991b8ac487bbfc61dc Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 3 Sep 2023 23:47:17 +0900
Subject: [PATCH 188/369] Revision 0.31.9 (#570)

---
 src/typebox.ts                  | 16 ++++++--------
 test/runtime/type/guard/enum.ts | 39 +++++++++++++++++++++++++++++++++
 test/static/enum.ts             | 32 ++++++++++++++++++++++++++-
 test/static/index.ts            |  4 ++--
 4 files changed, 79 insertions(+), 12 deletions(-)

diff --git a/src/typebox.ts b/src/typebox.ts
index edca58f8a..4934b2bf5 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -342,7 +342,8 @@ export type TEnumValue = string | number
 export type TEnumKey = string
 export type TEnumToLiteralUnion<T extends TEnumValue> = T extends TEnumValue ? TLiteral<T> : never
 export type TEnumToLiteralTuple<T extends TEnumValue> = UnionToTuple<TEnumToLiteralUnion<T>>
-export type TEnum<T extends TEnumValue> = Ensure<TUnion<AssertRest<TEnumToLiteralTuple<T>>>>
+export type TEnumToUnion<T extends TEnumValue, R = UnionType<AssertRest<TEnumToLiteralTuple<T>>>> = R extends TLiteralString ? TNever : R // Note: Empty enum evaluates as TLiteralString
+export type TEnum<T extends TEnumValue> = Ensure<TEnumToUnion<T>>
 // --------------------------------------------------------------------------
 // TExtends
 // --------------------------------------------------------------------------
@@ -2896,16 +2897,13 @@ export class JsonTypeBuilder extends TypeBuilder {
     return Type.Object(properties, options) as TComposite<T>
   }
   /** `[Json]` Creates a Enum type */
-  public Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T[keyof T]> {
+  public Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options: SchemaOptions = {}): TEnum<T[keyof T]> {
+    if (item === undefined) return this.Union([], options) as TEnum<T[keyof T]>
     // prettier-ignore
     const values1 = Object.getOwnPropertyNames(item).filter((key) => isNaN(key as any)).map((key) => item[key]) as T[keyof T][]
-    const values2 = [...new Set(values1)] // ensure distinct
-    // prettier-ignore
-    const anyOf = values2.map((value) => ValueGuard.IsString(value) 
-      ? { [Kind]: 'Literal', type: 'string' as const, const: value } 
-      : { [Kind]: 'Literal', type: 'number' as const, const: value }
-    )
-    return this.Create({ ...options, [Kind]: 'Union', anyOf })
+    const values2 = [...new Set(values1)] // distinct
+    const anyOf = values2.map((value) => Type.Literal(value))
+    return this.Union(anyOf, options) as TEnum<T[keyof T]>
   }
   /** `[Json]` Creates a Conditional type */
   public Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options: SchemaOptions = {}): TExtends<L, R, T, U> {
diff --git a/test/runtime/type/guard/enum.ts b/test/runtime/type/guard/enum.ts
index 9294ddee9..81a415a0c 100644
--- a/test/runtime/type/guard/enum.ts
+++ b/test/runtime/type/guard/enum.ts
@@ -3,6 +3,45 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/TEnum', () => {
+  // ----------------------------------------------------------------
+  // Options
+  // ----------------------------------------------------------------
+  it('Should guard for Options 1', () => {
+    const T = Type.Enum({ x: 1 }, { extra: 'hello', $id: 'T' })
+    Assert.IsEqual(T.extra, 'hello')
+    Assert.IsEqual(T.$id, 'T')
+  })
+  it('Should guard for Options 2', () => {
+    enum E {
+      x,
+    }
+    const T = Type.Enum(E, { extra: 'hello', $id: 'T' })
+    Assert.IsEqual(T.extra, 'hello')
+    Assert.IsEqual(T.$id, 'T')
+  })
+  it('Should guard for Options 3', () => {
+    enum E {}
+    const T = Type.Enum(E, { extra: 'hello', $id: 'T' })
+    Assert.IsEqual(T.extra, 'hello')
+    Assert.IsEqual(T.$id, 'T')
+  })
+  it('Should guard for Options 4', () => {
+    const T = Type.Enum({}, { extra: 'hello', $id: 'T' })
+    Assert.IsEqual(T.extra, 'hello')
+    Assert.IsEqual(T.$id, 'T')
+  })
+  // ----------------------------------------------------------------
+  // Empty
+  // ----------------------------------------------------------------
+  it('Should guard for Empty 1', () => {
+    const T = Type.Enum({})
+    Assert.IsTrue(TypeGuard.TNever(T))
+  })
+  it('Should guard for Empty 2', () => {
+    enum E {}
+    const T = Type.Enum(E)
+    Assert.IsTrue(TypeGuard.TNever(T))
+  })
   // ----------------------------------------------------------------
   // Enum
   // ----------------------------------------------------------------
diff --git a/test/static/enum.ts b/test/static/enum.ts
index 6d754e2f4..456e60e2c 100644
--- a/test/static/enum.ts
+++ b/test/static/enum.ts
@@ -1,7 +1,8 @@
 import { Expect } from './assert'
-import { Type, Static } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
 
 {
+  // expect all variants
   enum E {
     A,
     B = 'hello',
@@ -10,3 +11,32 @@ import { Type, Static } from '@sinclair/typebox'
   const T = Type.Enum(E)
   Expect(T).ToStatic<E.A | E.B | E.C>()
 }
+{
+  // expect all variants
+  const T = Type.Enum({
+    A: 1,
+    B: 2,
+    C: 3,
+  })
+  Expect(T).ToStatic<1 | 2 | 3>()
+}
+{
+  // expect variant overlap to reduce
+  const T = Type.Enum({
+    A: 1,
+    B: 2,
+    C: 2, // overlap
+  })
+  Expect(T).ToStatic<1 | 2>()
+}
+{
+  // expect empty enum to be never
+  enum E {}
+  const T = Type.Enum(E)
+  Expect(T).ToStaticNever()
+}
+{
+  // expect empty enum to be never
+  const T = Type.Enum({})
+  Expect(T).ToStaticNever()
+}
diff --git a/test/static/index.ts b/test/static/index.ts
index d1c757f10..911f5ec19 100644
--- a/test/static/index.ts
+++ b/test/static/index.ts
@@ -6,10 +6,10 @@ import './bigint'
 import './boolean'
 import './capitalize'
 import './composite'
-import './date'
 import './constructor-parameters'
 import './constructor'
-import './emum'
+import './date'
+import './enum'
 import './extract'
 import './exclude'
 import './function'

From 0a52b29cb5dcd2d7aa26c101ac827dcd75f594bd Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 3 Sep 2023 23:53:14 +0900
Subject: [PATCH 189/369] Revision 0.31.9 (#571)

---
 src/typebox.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/typebox.ts b/src/typebox.ts
index 4934b2bf5..509722211 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -2898,7 +2898,7 @@ export class JsonTypeBuilder extends TypeBuilder {
   }
   /** `[Json]` Creates a Enum type */
   public Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options: SchemaOptions = {}): TEnum<T[keyof T]> {
-    if (item === undefined) return this.Union([], options) as TEnum<T[keyof T]>
+    if (ValueGuard.IsUndefined(item)) return this.Union([], options) as TEnum<T[keyof T]>
     // prettier-ignore
     const values1 = Object.getOwnPropertyNames(item).filter((key) => isNaN(key as any)).map((key) => item[key]) as T[keyof T][]
     const values2 = [...new Set(values1)] // distinct

From 276ddeb443522b312ed9a290404d99f028a7d743 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 5 Sep 2023 02:49:33 +0900
Subject: [PATCH 190/369] Revision 0.31.10 (#573)

* Union, Intersect and Tuple Decode Rest

* Version

* Transform Tests
---
 package-lock.json        |  4 ++--
 package.json             |  2 +-
 src/typebox.ts           |  6 +++---
 test/static/transform.ts | 27 +++++++++++++++++++++++++++
 4 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 67acd05fd..12d0df7ec 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.9",
+  "version": "0.31.10",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.9",
+      "version": "0.31.10",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index ce7831fe5..3e0138cb3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.9",
+  "version": "0.31.10",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 509722211..f8f5b946f 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -868,7 +868,7 @@ export type DecodeType<T extends TSchema> = (
   T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> :
   T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<P, DecodeType<R>> :
   T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<P, DecodeType<R>> :
-  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<S> :
+  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<DecodeRest<S>> :
   T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> :
   T extends TNot<infer S extends TSchema> ? TNot<DecodeType<S>> :
   T extends TObject<infer S> ? TObject<Evaluate<DecodeProperties<S>>> :
@@ -876,8 +876,8 @@ export type DecodeType<T extends TSchema> = (
   T extends TRecord<infer K, infer S> ? TRecord<K, DecodeType<S>> :
   T extends TRecursive<infer S extends TSchema> ? TRecursive<DecodeType<S>> :
   T extends TRef<infer S extends TSchema> ? TRef<DecodeType<S>> :
-  T extends TTuple<infer S extends TSchema[]> ? TTuple<S> :
-  T extends TUnion<infer S extends TSchema[]> ? TUnion<S> :
+  T extends TTuple<infer S extends TSchema[]> ? TTuple<DecodeRest<S>> :
+  T extends TUnion<infer S extends TSchema[]> ? TUnion<DecodeRest<S>> :
   T
 )
 export type TransformFunction<T = any, U = any> = (value: T) => U
diff --git a/test/static/transform.ts b/test/static/transform.ts
index b633f9674..6395e19ff 100644
--- a/test/static/transform.ts
+++ b/test/static/transform.ts
@@ -251,3 +251,30 @@ import { Expect } from './assert'
   })
   Expect(T).ToStaticDecode<{ x: { y: string }[] }>()
 }
+{
+  // should decode generic union
+  const GenericUnion = <T extends TSchema>(t: T) => Type.Union([t, Type.Null()])
+  const T = Type.Transform(Type.String())
+    .Decode((value) => new Date(value))
+    .Encode((value) => value.toISOString())
+  Expect(T).ToStaticDecode<Date>()
+  Expect(GenericUnion(T)).ToStaticDecode<Date | null>()
+}
+{
+  // should decode generic tuple
+  const GenericTuple = <T extends TSchema>(t: T) => Type.Tuple([t, Type.Null()])
+  const T = Type.Transform(Type.String())
+    .Decode((value) => new Date(value))
+    .Encode((value) => value.toISOString())
+  Expect(T).ToStaticDecode<Date>()
+  Expect(GenericTuple(T)).ToStaticDecode<[Date, null]>()
+}
+{
+  // should decode generic intersect
+  const GenericIntersect = <T extends TSchema>(t: T) => Type.Intersect([t, Type.Literal(1)])
+  const T = Type.Transform(Type.Number())
+    .Decode((value) => value)
+    .Encode((value) => value)
+  Expect(T).ToStaticDecode<number>()
+  Expect(GenericIntersect(T)).ToStaticDecode<1>()
+}

From fc0bb0e9f25d2e8cc40abf88944dd15299a65b39 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 6 Sep 2023 00:46:25 +0900
Subject: [PATCH 191/369] Revision 0.31.11 (#575)

* Resolve for Single String Enum

* Version

* Update TEnum to accept TEnumRecord as Generic Argument

* Use TEnum<T> as Assert
---
 package-lock.json               |  4 +--
 package.json                    |  2 +-
 src/typebox.ts                  | 14 +++++-----
 test/runtime/type/guard/enum.ts | 47 ++++++++++++++++++++++++---------
 test/static/enum.ts             |  4 +--
 5 files changed, 47 insertions(+), 24 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 12d0df7ec..db3a526b8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.10",
+  "version": "0.31.11",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.10",
+      "version": "0.31.11",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 3e0138cb3..e3d9b895c 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.10",
+  "version": "0.31.11",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index f8f5b946f..78539e42f 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -340,10 +340,10 @@ export interface TDate extends TSchema, DateOptions {
 export type TEnumRecord = Record<TEnumKey, TEnumValue>
 export type TEnumValue = string | number
 export type TEnumKey = string
-export type TEnumToLiteralUnion<T extends TEnumValue> = T extends TEnumValue ? TLiteral<T> : never
+export type TEnumToLiteralUnion<T extends TEnumValue> = T extends TEnumValue ? TLiteral<T> : never // Note: Empty enums infer as TLiteral<string>
 export type TEnumToLiteralTuple<T extends TEnumValue> = UnionToTuple<TEnumToLiteralUnion<T>>
-export type TEnumToUnion<T extends TEnumValue, R = UnionType<AssertRest<TEnumToLiteralTuple<T>>>> = R extends TLiteralString ? TNever : R // Note: Empty enum evaluates as TLiteralString
-export type TEnum<T extends TEnumValue> = Ensure<TEnumToUnion<T>>
+export type TEnumToUnion<T extends TEnumValue> = UnionType<AssertRest<TEnumToLiteralTuple<T>>>
+export type TEnum<T extends TEnumRecord> = TEnumToUnion<T[keyof T]>
 // --------------------------------------------------------------------------
 // TExtends
 // --------------------------------------------------------------------------
@@ -2897,13 +2897,13 @@ export class JsonTypeBuilder extends TypeBuilder {
     return Type.Object(properties, options) as TComposite<T>
   }
   /** `[Json]` Creates a Enum type */
-  public Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options: SchemaOptions = {}): TEnum<T[keyof T]> {
-    if (ValueGuard.IsUndefined(item)) return this.Union([], options) as TEnum<T[keyof T]>
+  public Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options: SchemaOptions = {}): TEnum<T> {
+    if (ValueGuard.IsUndefined(item)) return this.Never(options) as TEnum<T>
     // prettier-ignore
     const values1 = Object.getOwnPropertyNames(item).filter((key) => isNaN(key as any)).map((key) => item[key]) as T[keyof T][]
-    const values2 = [...new Set(values1)] // distinct
+    const values2 = [...new Set(values1)]
     const anyOf = values2.map((value) => Type.Literal(value))
-    return this.Union(anyOf, options) as TEnum<T[keyof T]>
+    return this.Union(anyOf, options) as TEnum<T>
   }
   /** `[Json]` Creates a Conditional type */
   public Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options: SchemaOptions = {}): TExtends<L, R, T, U> {
diff --git a/test/runtime/type/guard/enum.ts b/test/runtime/type/guard/enum.ts
index 81a415a0c..fd4ee99e1 100644
--- a/test/runtime/type/guard/enum.ts
+++ b/test/runtime/type/guard/enum.ts
@@ -42,10 +42,24 @@ describe('type/guard/TEnum', () => {
     const T = Type.Enum(E)
     Assert.IsTrue(TypeGuard.TNever(T))
   })
+
   // ----------------------------------------------------------------
   // Enum
   // ----------------------------------------------------------------
+  it('Should guard for TEnum Enum 0', () => {
+    enum E {}
+    const T = Type.Enum(E)
+    Assert.IsTrue(TypeGuard.TNever(T))
+  })
   it('Should guard for TEnum Enum 1', () => {
+    enum E {
+      A,
+    }
+    const T = Type.Enum(E)
+    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsEqual(T.const, E.A)
+  })
+  it('Should guard for TEnum Enum 2', () => {
     enum E {
       A = 1,
       B = 2,
@@ -53,11 +67,11 @@ describe('type/guard/TEnum', () => {
     }
     const T = Type.Enum(E)
     Assert.IsTrue(TypeGuard.TUnion(T))
-    Assert.IsEqual(T.anyOf[0].const, 1)
-    Assert.IsEqual(T.anyOf[1].const, 2)
-    Assert.IsEqual(T.anyOf[2].const, 3)
+    Assert.IsEqual(T.anyOf[0].const, E.A)
+    Assert.IsEqual(T.anyOf[1].const, E.B)
+    Assert.IsEqual(T.anyOf[2].const, E.C)
   })
-  it('Should guard for TEnum Enum 2', () => {
+  it('Should guard for TEnum Enum 3', () => {
     enum E {
       A = 'X',
       B = 'Y',
@@ -65,11 +79,11 @@ describe('type/guard/TEnum', () => {
     }
     const T = Type.Enum(E)
     Assert.IsTrue(TypeGuard.TUnion(T))
-    Assert.IsEqual(T.anyOf[0].const, 'X')
-    Assert.IsEqual(T.anyOf[1].const, 'Y')
-    Assert.IsEqual(T.anyOf[2].const, 'Z')
+    Assert.IsEqual(T.anyOf[0].const, E.A)
+    Assert.IsEqual(T.anyOf[1].const, E.B)
+    Assert.IsEqual(T.anyOf[2].const, E.C)
   })
-  it('Should guard for TEnum Enum 3', () => {
+  it('Should guard for TEnum Enum 4', () => {
     enum E {
       A = 'X',
       B = 'Y',
@@ -77,14 +91,23 @@ describe('type/guard/TEnum', () => {
     }
     const T = Type.Enum(E)
     Assert.IsTrue(TypeGuard.TUnion(T))
-    Assert.IsEqual(T.anyOf[0].const, 'X')
-    Assert.IsEqual(T.anyOf[1].const, 'Y')
+    Assert.IsEqual(T.anyOf[0].const, E.A)
+    Assert.IsEqual(T.anyOf[1].const, E.B)
     Assert.IsEqual(T.anyOf.length, 2)
   })
   // ----------------------------------------------------------------
   // Object Literal
   // ----------------------------------------------------------------
+  it('Should guard for TEnum Object Literal 0', () => {
+    const T = Type.Enum({})
+    Assert.IsTrue(TypeGuard.TNever(T))
+  })
   it('Should guard for TEnum Object Literal 1', () => {
+    const T = Type.Enum({ A: 1 })
+    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsEqual(T.const, 1)
+  })
+  it('Should guard for TEnum Object Literal 2', () => {
     const T = Type.Enum({
       A: 1,
       B: 2,
@@ -95,7 +118,7 @@ describe('type/guard/TEnum', () => {
     Assert.IsEqual(T.anyOf[1].const, 2)
     Assert.IsEqual(T.anyOf[2].const, 3)
   })
-  it('Should guard for TEnum Object Literal 2', () => {
+  it('Should guard for TEnum Object Literal 3', () => {
     const T = Type.Enum({
       A: 'X',
       B: 'Y',
@@ -106,7 +129,7 @@ describe('type/guard/TEnum', () => {
     Assert.IsEqual(T.anyOf[1].const, 'Y')
     Assert.IsEqual(T.anyOf[2].const, 'Z')
   })
-  it('Should guard for TEnum Object Literal 3', () => {
+  it('Should guard for TEnum Object Literal 4', () => {
     const T = Type.Enum({
       A: 'X',
       B: 'Y',
diff --git a/test/static/enum.ts b/test/static/enum.ts
index 456e60e2c..9818acfe1 100644
--- a/test/static/enum.ts
+++ b/test/static/enum.ts
@@ -30,10 +30,10 @@ import { Type } from '@sinclair/typebox'
   Expect(T).ToStatic<1 | 2>()
 }
 {
-  // expect empty enum to be never
+  // expect empty enum to be string (as empty enums T[keyof T] evaluates as string)
   enum E {}
   const T = Type.Enum(E)
-  Expect(T).ToStaticNever()
+  Expect(T).ToStatic<string>()
 }
 {
   // expect empty enum to be never

From df991dee6b389f22e4224821a5212aa46786b286 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 6 Sep 2023 01:45:10 +0900
Subject: [PATCH 192/369] Revision 0.31.12 (#581)

* Detected Empty Enum via Reverse Extends Check

* Version
---
 package-lock.json   | 4 ++--
 package.json        | 2 +-
 src/typebox.ts      | 3 ++-
 test/static/enum.ts | 2 +-
 4 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index db3a526b8..24a7963cb 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.11",
+  "version": "0.31.12",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.11",
+      "version": "0.31.12",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index e3d9b895c..db2656753 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.11",
+  "version": "0.31.12",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 78539e42f..08318db0a 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -340,7 +340,8 @@ export interface TDate extends TSchema, DateOptions {
 export type TEnumRecord = Record<TEnumKey, TEnumValue>
 export type TEnumValue = string | number
 export type TEnumKey = string
-export type TEnumToLiteralUnion<T extends TEnumValue> = T extends TEnumValue ? TLiteral<T> : never // Note: Empty enums infer as TLiteral<string>
+export type TEnumToLiteralUnion<T extends TEnumValue> = T extends TEnumValue ? string extends T ? TNever : TLiteral<T> : never 
+//                                                                             ^ empty enums evaluate as string
 export type TEnumToLiteralTuple<T extends TEnumValue> = UnionToTuple<TEnumToLiteralUnion<T>>
 export type TEnumToUnion<T extends TEnumValue> = UnionType<AssertRest<TEnumToLiteralTuple<T>>>
 export type TEnum<T extends TEnumRecord> = TEnumToUnion<T[keyof T]>
diff --git a/test/static/enum.ts b/test/static/enum.ts
index 9818acfe1..b49472864 100644
--- a/test/static/enum.ts
+++ b/test/static/enum.ts
@@ -33,7 +33,7 @@ import { Type } from '@sinclair/typebox'
   // expect empty enum to be string (as empty enums T[keyof T] evaluates as string)
   enum E {}
   const T = Type.Enum(E)
-  Expect(T).ToStatic<string>()
+  Expect(T).ToStaticNever()
 }
 {
   // expect empty enum to be never

From 4211f4a669261ee9cfafce53038bafc15b61eea4 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 6 Sep 2023 01:46:21 +0900
Subject: [PATCH 193/369] Revision 0.31.12

---
 src/typebox.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/typebox.ts b/src/typebox.ts
index 08318db0a..c4059ac31 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -340,7 +340,7 @@ export interface TDate extends TSchema, DateOptions {
 export type TEnumRecord = Record<TEnumKey, TEnumValue>
 export type TEnumValue = string | number
 export type TEnumKey = string
-export type TEnumToLiteralUnion<T extends TEnumValue> = T extends TEnumValue ? string extends T ? TNever : TLiteral<T> : never 
+export type TEnumToLiteralUnion<T extends TEnumValue> = T extends TEnumValue ? (string extends T ? TNever : TLiteral<T>) : never
 //                                                                             ^ empty enums evaluate as string
 export type TEnumToLiteralTuple<T extends TEnumValue> = UnionToTuple<TEnumToLiteralUnion<T>>
 export type TEnumToUnion<T extends TEnumValue> = UnionType<AssertRest<TEnumToLiteralTuple<T>>>

From 4edc46c2efed4b7ff2a0f1689802dcfdb02b50cc Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 6 Sep 2023 02:49:46 +0900
Subject: [PATCH 194/369] Revision 0.31.13 (#583)

* Support Intersect Value Conversion

* Update Test To Include Non Converted Property
---
 package-lock.json                       |  4 +--
 package.json                            |  2 +-
 src/value/convert.ts                    |  9 ++++-
 test/runtime/value/convert/index.ts     |  1 +
 test/runtime/value/convert/intersect.ts | 45 +++++++++++++++++++++++++
 5 files changed, 57 insertions(+), 4 deletions(-)
 create mode 100644 test/runtime/value/convert/intersect.ts

diff --git a/package-lock.json b/package-lock.json
index 24a7963cb..2a2ee6347 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.12",
+  "version": "0.31.13",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.12",
+      "version": "0.31.13",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index db2656753..fbb0e3392 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.12",
+  "version": "0.31.13",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/convert.ts b/src/value/convert.ts
index fd64cfacf..60ba2e1f3 100644
--- a/src/value/convert.ts
+++ b/src/value/convert.ts
@@ -173,6 +173,12 @@ function TDate(schema: Types.TDate, references: Types.TSchema[], value: any): un
 function TInteger(schema: Types.TInteger, references: Types.TSchema[], value: any): unknown {
   return TryConvertInteger(value)
 }
+function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any): unknown {
+  // prettier-ignore
+  return (schema.allOf.every(schema => Types.TypeGuard.TObject(schema)))
+    ? Visit(Types.Type.Composite(schema.allOf as Types.TObject[]), references, value)
+    : Visit(schema.allOf[0], references, value)
+}
 function TLiteral(schema: Types.TLiteral, references: Types.TSchema[], value: any): unknown {
   return TryConvertLiteral(schema, value)
 }
@@ -247,6 +253,8 @@ function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any):
       return TDate(schema_, references_, value)
     case 'Integer':
       return TInteger(schema_, references_, value)
+    case 'Intersect':
+      return TIntersect(schema_, references_, value)
     case 'Literal':
       return TLiteral(schema_, references_, value)
     case 'Null':
@@ -278,7 +286,6 @@ function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any):
     case 'AsyncIterator':
     case 'Constructor':
     case 'Function':
-    case 'Intersect':
     case 'Iterator':
     case 'Never':
     case 'Promise':
diff --git a/test/runtime/value/convert/index.ts b/test/runtime/value/convert/index.ts
index 09f006f09..ec3e1b6e8 100644
--- a/test/runtime/value/convert/index.ts
+++ b/test/runtime/value/convert/index.ts
@@ -10,6 +10,7 @@ import './date'
 import './enum'
 import './function'
 import './integer'
+import './intersect'
 import './iterator'
 import './keyof'
 import './literal'
diff --git a/test/runtime/value/convert/intersect.ts b/test/runtime/value/convert/intersect.ts
new file mode 100644
index 000000000..5c2e2bb37
--- /dev/null
+++ b/test/runtime/value/convert/intersect.ts
@@ -0,0 +1,45 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/convert/Intersect', () => {
+  it('Should convert intersected objects', () => {
+    // prettier-ignore
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() })
+    ])
+    const R = Value.Convert(T, { x: '1', y: '2' })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should not convert for non object exclusive intersect', () => {
+    // prettier-ignore
+    const T = Type.Intersect([
+      Type.Number(),
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() })
+    ])
+    const R = Value.Convert(T, { x: '1', y: '2' })
+    Assert.IsEqual(R, { x: '1', y: '2' })
+  })
+  it('Should convert first type for object exclusive intersect 1', () => {
+    // prettier-ignore
+    const T = Type.Intersect([
+      Type.Number(),
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() })
+    ])
+    const R = Value.Convert(T, '123')
+    Assert.IsEqual(R, 123)
+  })
+  it('Should convert first type for object exclusive intersect 2', () => {
+    // prettier-ignore
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() }),
+      Type.Number(),
+    ])
+    const R = Value.Convert(T, { x: '3', y: '4' })
+    Assert.IsEqual(R, { x: 3, y: '4' })
+  })
+})

From 6b27faba280aefed60fb598e1b05896e603b221d Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 6 Sep 2023 05:12:54 +0900
Subject: [PATCH 195/369] Revision 0.31.14 (#584)

* Revert 0.31.8 Enum

* Intercept for Enum on StaticDecode
---
 package-lock.json                     |  4 +--
 package.json                          |  2 +-
 src/typebox.ts                        | 16 +++++-----
 test/runtime/value/transform/enum.ts  | 45 +++++++++++++++++++++++++++
 test/runtime/value/transform/index.ts |  1 +
 test/static/enum.ts                   |  2 +-
 test/static/record.ts                 |  6 +---
 test/static/transform.ts              | 13 ++++++++
 8 files changed, 73 insertions(+), 16 deletions(-)
 create mode 100644 test/runtime/value/transform/enum.ts

diff --git a/package-lock.json b/package-lock.json
index 2a2ee6347..51286a331 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.13",
+  "version": "0.31.14",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.13",
+      "version": "0.31.14",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index fbb0e3392..13a376c7c 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.13",
+  "version": "0.31.14",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index c4059ac31..3e4f0c420 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -176,6 +176,7 @@ export type TAnySchema =
   | TBoolean
   | TConstructor
   | TDate
+  | TEnum
   | TFunction
   | TInteger
   | TIntersect
@@ -340,11 +341,12 @@ export interface TDate extends TSchema, DateOptions {
 export type TEnumRecord = Record<TEnumKey, TEnumValue>
 export type TEnumValue = string | number
 export type TEnumKey = string
-export type TEnumToLiteralUnion<T extends TEnumValue> = T extends TEnumValue ? (string extends T ? TNever : TLiteral<T>) : never
-//                                                                             ^ empty enums evaluate as string
-export type TEnumToLiteralTuple<T extends TEnumValue> = UnionToTuple<TEnumToLiteralUnion<T>>
-export type TEnumToUnion<T extends TEnumValue> = UnionType<AssertRest<TEnumToLiteralTuple<T>>>
-export type TEnum<T extends TEnumRecord> = TEnumToUnion<T[keyof T]>
+export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
+  [Kind]: 'Union'
+  [Hint]: 'Enum'
+  static: T[keyof T]
+  anyOf: TLiteral<T[keyof T]>[]
+}
 // --------------------------------------------------------------------------
 // TExtends
 // --------------------------------------------------------------------------
@@ -868,6 +870,7 @@ export type DecodeType<T extends TSchema> = (
   T extends TArray<infer S extends TSchema> ? TArray<DecodeType<S>> :
   T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> :
   T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<P, DecodeType<R>> :
+  T extends TEnum<infer S> ? TEnum<S> : // intercept for union. interior non decodable
   T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<P, DecodeType<R>> :
   T extends TIntersect<infer S extends TSchema[]> ? TIntersect<DecodeRest<S>> :
   T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> :
@@ -2899,12 +2902,11 @@ export class JsonTypeBuilder extends TypeBuilder {
   }
   /** `[Json]` Creates a Enum type */
   public Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options: SchemaOptions = {}): TEnum<T> {
-    if (ValueGuard.IsUndefined(item)) return this.Never(options) as TEnum<T>
     // prettier-ignore
     const values1 = Object.getOwnPropertyNames(item).filter((key) => isNaN(key as any)).map((key) => item[key]) as T[keyof T][]
     const values2 = [...new Set(values1)]
     const anyOf = values2.map((value) => Type.Literal(value))
-    return this.Union(anyOf, options) as TEnum<T>
+    return this.Union(anyOf, { ...options, [Hint]: 'Enum' }) as TEnum<T>
   }
   /** `[Json]` Creates a Conditional type */
   public Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options: SchemaOptions = {}): TExtends<L, R, T, U> {
diff --git a/test/runtime/value/transform/enum.ts b/test/runtime/value/transform/enum.ts
new file mode 100644
index 000000000..1df8f7793
--- /dev/null
+++ b/test/runtime/value/transform/enum.ts
@@ -0,0 +1,45 @@
+import { Assert } from '../../assert'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+describe('value/transform/Enum', () => {
+  enum E {
+    A,
+    B,
+    C,
+  }
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(Type.Enum(E))
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Value.Decode(T0, E.A)
+    Assert.IsEqual(R, E.A)
+  })
+  it('Should encode identity', () => {
+    const R = Value.Encode(T0, E.A)
+    Assert.IsEqual(R, E.A)
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Value.Decode(T0, null))
+  })
+  // --------------------------------------------------------
+  // Mapped
+  // --------------------------------------------------------
+  const T1 = Type.Transform(Type.Enum(E))
+    .Decode((value) => 1)
+    .Encode((value) => E.A)
+  it('Should decode mapped', () => {
+    const R = Value.Decode(T1, E.A)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should encode mapped', () => {
+    const R = Value.Encode(T1, null)
+    Assert.IsEqual(R, E.A)
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Value.Decode(T1, null))
+  })
+})
diff --git a/test/runtime/value/transform/index.ts b/test/runtime/value/transform/index.ts
index 2dc90ff81..bc4fb931a 100644
--- a/test/runtime/value/transform/index.ts
+++ b/test/runtime/value/transform/index.ts
@@ -6,6 +6,7 @@ import './bigint'
 import './boolean'
 import './constructor'
 import './date'
+import './enum'
 import './function'
 import './integer'
 import './intersect'
diff --git a/test/static/enum.ts b/test/static/enum.ts
index b49472864..9818acfe1 100644
--- a/test/static/enum.ts
+++ b/test/static/enum.ts
@@ -33,7 +33,7 @@ import { Type } from '@sinclair/typebox'
   // expect empty enum to be string (as empty enums T[keyof T] evaluates as string)
   enum E {}
   const T = Type.Enum(E)
-  Expect(T).ToStaticNever()
+  Expect(T).ToStatic<string>()
 }
 {
   // expect empty enum to be never
diff --git a/test/static/record.ts b/test/static/record.ts
index 35aa0bb13..9a2ccb639 100644
--- a/test/static/record.ts
+++ b/test/static/record.ts
@@ -78,9 +78,5 @@ import { Type, Static } from '@sinclair/typebox'
     C = 'Z',
   }
   const T = Type.Record(Type.Enum(E), Type.Number())
-  Expect(T).ToStatic<{
-    X: number
-    Y: number
-    Z: number
-  }>()
+  Expect(T).ToStatic<{}>()
 }
diff --git a/test/static/transform.ts b/test/static/transform.ts
index 6395e19ff..468787ef2 100644
--- a/test/static/transform.ts
+++ b/test/static/transform.ts
@@ -278,3 +278,16 @@ import { Expect } from './assert'
   Expect(T).ToStaticDecode<number>()
   Expect(GenericIntersect(T)).ToStaticDecode<1>()
 }
+{
+  // should decode enum
+  enum E {
+    A,
+    B,
+    C,
+  }
+  const T = Type.Transform(Type.Enum(E))
+    .Decode((value) => 1 as const)
+    .Encode((value) => E.A)
+  Expect(T).ToStaticDecode<1>()
+  Expect(T).ToStaticEncode<E>()
+}

From f2ccea962345dcee8f8880d315d7f4d7a1bde0ee Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 14 Sep 2023 16:15:24 +0900
Subject: [PATCH 196/369] Revision 0.31.15 (#594)

* Support Unicode Hash

* Version
---
 package-lock.json               |  4 ++--
 package.json                    |  2 +-
 readme.md                       |  6 ++----
 src/value/hash.ts               | 13 ++++++++++++-
 test/runtime/value/hash/hash.ts | 11 +++++++++++
 5 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 51286a331..fb6e03401 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.14",
+  "version": "0.31.15",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.14",
+      "version": "0.31.15",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 13a376c7c..4ecd1237b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.14",
+  "version": "0.31.15",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index cd4af3af3..3133e0c8a 100644
--- a/readme.md
+++ b/readme.md
@@ -58,11 +58,9 @@ type T = Static<typeof T>                            // type T = {
 
 ## Overview
 
-TypeBox is a runtime type builder that creates Json Schema objects that infer as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript or runtime asserted using standard Json Schema validation.
+TypeBox is a runtime type builder that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type assertion rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
 
-TypeBox uses industry standard schematics for runtime type representation; enabling types to be reflected, serialized and published directly. Its type system is fully extensible and able to support type representation for multiple schema specifications. It also provides a high performance validation compiler, various tools for working with dynamic data and offers detailed structured error reporting. 
-
-TypeBox can be used as a simple tool to build up complex schemas or integrated into applications and frameworks to enable high performance runtime type checking for data received over the wire.
+This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire.
 
 License MIT
 
diff --git a/src/value/hash.ts b/src/value/hash.ts
index fdeec07a5..cd8935ead 100644
--- a/src/value/hash.ts
+++ b/src/value/hash.ts
@@ -62,6 +62,15 @@ const F64 = new Float64Array(1)
 const F64In = new DataView(F64.buffer)
 const F64Out = new Uint8Array(F64.buffer)
 // --------------------------------------------------------------------------
+// NumberToBytes
+// --------------------------------------------------------------------------
+function* NumberToBytes(value: number): IterableIterator<number> {
+  const byteCount = value === 0 ? 1 : Math.ceil(Math.floor(Math.log2(value) + 1) / 8)
+  for (let i = 0; i < byteCount; i++) {
+    yield (value >> (8 * (byteCount - 1 - i))) & 0xff
+  }
+}
+// --------------------------------------------------------------------------
 // Hashing Functions
 // --------------------------------------------------------------------------
 function ArrayType(value: Array<unknown>) {
@@ -105,7 +114,9 @@ function ObjectType(value: Record<string, unknown>) {
 function StringType(value: string) {
   FNV1A64(ByteMarker.String)
   for (let i = 0; i < value.length; i++) {
-    FNV1A64(value.charCodeAt(i))
+    for (const byte of NumberToBytes(value.charCodeAt(i))) {
+      FNV1A64(byte)
+    }
   }
 }
 function SymbolType(value: symbol) {
diff --git a/test/runtime/value/hash/hash.ts b/test/runtime/value/hash/hash.ts
index b93b676f1..8d06d509f 100644
--- a/test/runtime/value/hash/hash.ts
+++ b/test/runtime/value/hash/hash.ts
@@ -108,4 +108,15 @@ describe('value/hash/Hash', () => {
     const B = ValueHash.Hash(BigInt(1))
     Assert.IsEqual(A, B)
   })
+  // ----------------------------------------------------------------
+  // Unicode
+  // ----------------------------------------------------------------
+  it('Should hash unicode 1 (retain single byte hash)', () => {
+    const hash = ValueHash.Hash('a')
+    Assert.IsEqual(hash, 586962220959696054n)
+  })
+  it('Should hash unicode 2', () => {
+    const hash = ValueHash.Hash('안녕 세계')
+    Assert.IsEqual(hash, 11219208047802711777n)
+  })
 })

From ce94ca097f4f581a7006545e7e3b7b0055dd51c8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mart=C3=ADn=20Acosta?= <tinchoz49@gmail.com>
Date: Mon, 18 Sep 2023 21:51:27 -0300
Subject: [PATCH 197/369] Ecosystem (#599)

---
 readme.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/readme.md b/readme.md
index 3133e0c8a..d93cf5fb1 100644
--- a/readme.md
+++ b/readme.md
@@ -1608,6 +1608,7 @@ The following is a list of community packages that offer general tooling, extend
 | [feathersjs](https://github.com/feathersjs/feathers) | The API and real-time application framework |
 | [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
 | [h3-typebox](https://github.com/kevinmarrec/h3-typebox) | Schema validation utilities for h3 using TypeBox & Ajv |
+| [openapi-box](https://github.com/geut/openapi-box) | Generate TypeBox schemas from your openapi spec and use it as an http client library. |
 | [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from Json Schemas |
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
 | [typebox-client](https://github.com/flodlc/typebox-client) | Type safe http client library for Fastify |

From edd757833430d056ef776212729a45305471e717 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 19 Sep 2023 09:58:37 +0900
Subject: [PATCH 198/369] Ecosystem

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index d93cf5fb1..16449a07b 100644
--- a/readme.md
+++ b/readme.md
@@ -1608,7 +1608,7 @@ The following is a list of community packages that offer general tooling, extend
 | [feathersjs](https://github.com/feathersjs/feathers) | The API and real-time application framework |
 | [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
 | [h3-typebox](https://github.com/kevinmarrec/h3-typebox) | Schema validation utilities for h3 using TypeBox & Ajv |
-| [openapi-box](https://github.com/geut/openapi-box) | Generate TypeBox schemas from your openapi spec and use it as an http client library. |
+| [openapi-box](https://github.com/geut/openapi-box) | Generate TypeBox types from OpenApi IDL + Http client library |
 | [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from Json Schemas |
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
 | [typebox-client](https://github.com/flodlc/typebox-client) | Type safe http client library for Fastify |

From dc4e70de42ab96b8d6b1d215fc3cee0ca2e057a6 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 25 Sep 2023 15:55:50 +0900
Subject: [PATCH 199/369] Revision 0.31.16 (#605)

* Support Infinite Template Literal Record Key

* Tests

* Version
---
 package-lock.json                   |  4 +-
 package.json                        |  2 +-
 src/typebox.ts                      |  4 +-
 test/runtime/compiler-ajv/record.ts | 63 +++++++++++++++++++++++++++++
 test/runtime/compiler/record.ts     | 63 +++++++++++++++++++++++++++++
 test/static/record.ts               | 17 +++++++-
 6 files changed, 147 insertions(+), 6 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index fb6e03401..88a7f79c7 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.15",
+  "version": "0.31.16",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.15",
+      "version": "0.31.16",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 4ecd1237b..fe958029c 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.15",
+  "version": "0.31.16",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 3e4f0c420..4514b9c80 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -656,11 +656,11 @@ export type TRecordFromUnionRest<K extends TSchema[], T extends TSchema> = K ext
   L extends TLiteralNumber ? TRecordFromUnionLiteralNumber<L, T> & TRecordFromUnionRest<AssertRest<R>, T> :
 {}) : {}
 export type TRecordFromUnion<K extends TSchema[], T extends TSchema> = Ensure<TObject<AssertProperties<Evaluate<TRecordFromUnionRest<K, T>>>>>
-export type TRecordFromTemplateLiteralKeyInfinite<T extends TSchema> = Ensure<TRecord<TString, T>>
+export type TRecordFromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>
 export type TRecordFromTemplateLiteralKeyFinite<K extends TTemplateLiteral, T extends TSchema, I = Static<K>> = Ensure<TObject<Evaluate<{ [_ in Assert<I, string>]: T }>>>
 // prettier-ignore
 export type TRecordFromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends false 
-  ? TRecordFromTemplateLiteralKeyInfinite<T> 
+  ? TRecordFromTemplateLiteralKeyInfinite<K, T> 
   : TRecordFromTemplateLiteralKeyFinite<K, T>
 export type TRecordFromLiteralStringKey<K extends TLiteralString, T extends TSchema> = Ensure<TObject<{ [_ in K['const']]: T }>>
 export type TRecordFromLiteralNumberKey<K extends TLiteralNumber, T extends TSchema> = Ensure<TObject<{ [_ in K['const']]: T }>>
diff --git a/test/runtime/compiler-ajv/record.ts b/test/runtime/compiler-ajv/record.ts
index 082a58fb2..75b739b9c 100644
--- a/test/runtime/compiler-ajv/record.ts
+++ b/test/runtime/compiler-ajv/record.ts
@@ -175,4 +175,67 @@ describe('compiler-ajv/Record', () => {
     const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: Type.Boolean() })
     Ok(T, { 1: '', 2: '', x: true })
   })
+  // ----------------------------------------------------------------
+  // TemplateLiteral
+  // ----------------------------------------------------------------
+  it('TemplateLiteral 1', () => {
+    const K = Type.TemplateLiteral('key${number}')
+    const R = Type.Record(K, Type.Number(), { additionalProperties: false })
+    Ok(R, {
+      key0: 1,
+      key1: 1,
+      key2: 1,
+    })
+  })
+  it('TemplateLiteral 2', () => {
+    const K = Type.TemplateLiteral('key${number}')
+    const R = Type.Record(K, Type.Number())
+    Ok(R, { keyA: 0 })
+  })
+  it('TemplateLiteral 3', () => {
+    const K = Type.TemplateLiteral('key${number}')
+    const R = Type.Record(K, Type.Number(), { additionalProperties: false })
+    Fail(R, { keyA: 0 })
+  })
+  it('TemplateLiteral 4', () => {
+    const K = Type.TemplateLiteral('key${number}')
+    const R = Type.Record(K, Type.Number())
+    const T = Type.Object({ x: Type.Number(), y: Type.Number() })
+    const I = Type.Intersect([R, T], { unevaluatedProperties: false })
+    Ok(I, {
+      x: 1,
+      y: 2,
+      key0: 1,
+      key1: 1,
+      key2: 1,
+    })
+  })
+  it('TemplateLiteral 5', () => {
+    const K = Type.TemplateLiteral('key${number}')
+    const R = Type.Record(K, Type.Number())
+    const T = Type.Object({ x: Type.Number(), y: Type.Number() })
+    const I = Type.Intersect([R, T])
+    Ok(I, {
+      x: 1,
+      y: 2,
+      z: 3,
+      key0: 1,
+      key1: 1,
+      key2: 1,
+    })
+  })
+  it('TemplateLiteral 6', () => {
+    const K = Type.TemplateLiteral('key${number}')
+    const R = Type.Record(K, Type.Number())
+    const T = Type.Object({ x: Type.Number(), y: Type.Number() })
+    const I = Type.Intersect([R, T], { unevaluatedProperties: false })
+    Fail(I, {
+      x: 1,
+      y: 2,
+      z: 3,
+      key0: 1,
+      key1: 1,
+      key2: 1,
+    })
+  })
 })
diff --git a/test/runtime/compiler/record.ts b/test/runtime/compiler/record.ts
index 89368d724..8b7cfbb65 100644
--- a/test/runtime/compiler/record.ts
+++ b/test/runtime/compiler/record.ts
@@ -206,4 +206,67 @@ describe('compiler/Record', () => {
     const T = Type.Record(Type.Number(), Type.String(), { additionalProperties: Type.Boolean() })
     Ok(T, { 1: '', 2: '', x: true })
   })
+  // ----------------------------------------------------------------
+  // TemplateLiteral
+  // ----------------------------------------------------------------
+  it('TemplateLiteral 1', () => {
+    const K = Type.TemplateLiteral('key${number}')
+    const R = Type.Record(K, Type.Number(), { additionalProperties: false })
+    Ok(R, {
+      key0: 1,
+      key1: 1,
+      key2: 1,
+    })
+  })
+  it('TemplateLiteral 2', () => {
+    const K = Type.TemplateLiteral('key${number}')
+    const R = Type.Record(K, Type.Number())
+    Ok(R, { keyA: 0 })
+  })
+  it('TemplateLiteral 3', () => {
+    const K = Type.TemplateLiteral('key${number}')
+    const R = Type.Record(K, Type.Number(), { additionalProperties: false })
+    Fail(R, { keyA: 0 })
+  })
+  it('TemplateLiteral 4', () => {
+    const K = Type.TemplateLiteral('key${number}')
+    const R = Type.Record(K, Type.Number())
+    const T = Type.Object({ x: Type.Number(), y: Type.Number() })
+    const I = Type.Intersect([R, T], { unevaluatedProperties: false })
+    Ok(I, {
+      x: 1,
+      y: 2,
+      key0: 1,
+      key1: 1,
+      key2: 1,
+    })
+  })
+  it('TemplateLiteral 5', () => {
+    const K = Type.TemplateLiteral('key${number}')
+    const R = Type.Record(K, Type.Number())
+    const T = Type.Object({ x: Type.Number(), y: Type.Number() })
+    const I = Type.Intersect([R, T])
+    Ok(I, {
+      x: 1,
+      y: 2,
+      z: 3,
+      key0: 1,
+      key1: 1,
+      key2: 1,
+    })
+  })
+  it('TemplateLiteral 6', () => {
+    const K = Type.TemplateLiteral('key${number}')
+    const R = Type.Record(K, Type.Number())
+    const T = Type.Object({ x: Type.Number(), y: Type.Number() })
+    const I = Type.Intersect([R, T], { unevaluatedProperties: false })
+    Fail(I, {
+      x: 1,
+      y: 2,
+      z: 3,
+      key0: 1,
+      key1: 1,
+      key2: 1,
+    })
+  })
 })
diff --git a/test/static/record.ts b/test/static/record.ts
index 9a2ccb639..819c0ad27 100644
--- a/test/static/record.ts
+++ b/test/static/record.ts
@@ -70,7 +70,6 @@ import { Type, Static } from '@sinclair/typebox'
 
   Expect(T).ToStatic<Record<number, string>>()
 }
-
 {
   enum E {
     A = 'X',
@@ -80,3 +79,19 @@ import { Type, Static } from '@sinclair/typebox'
   const T = Type.Record(Type.Enum(E), Type.Number())
   Expect(T).ToStatic<{}>()
 }
+{
+  // should support infinite record keys
+  // https://github.com/sinclairzx81/typebox/issues/604
+  const K = Type.TemplateLiteral('key${number}')
+  const R = Type.Record(K, Type.Number())
+  Expect(R).ToStatic<Record<`key${number}`, number>>()
+}
+{
+  // should support infinite record keys with intersect
+  // https://github.com/sinclairzx81/typebox/issues/604
+  const K = Type.TemplateLiteral('key${number}')
+  const R = Type.Record(K, Type.Number())
+  const T = Type.Object({ x: Type.Number(), y: Type.Number() })
+  const I = Type.Intersect([R, T])
+  Expect(I).ToStatic<Record<`key${number}`, number> & { x: number; y: number }>()
+}

From 04f4da2fd670c8e6e341a02a007f8fe47265a099 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 26 Sep 2023 16:20:50 +0900
Subject: [PATCH 200/369] Revision 0.31.17 (#608)

* Fix Compiler Contains Check

* Updates

* Version
---
 package-lock.json                  |  4 +--
 package.json                       |  2 +-
 src/compiler/compiler.ts           |  2 +-
 test/runtime/compiler-ajv/array.ts | 38 +++++++++++++++++++++++++++
 test/runtime/compiler/array.ts     | 38 +++++++++++++++++++++++++++
 test/runtime/value/check/array.ts  | 42 ++++++++++++++++++++++++++++++
 6 files changed, 122 insertions(+), 4 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 88a7f79c7..849e6bbd8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.16",
+  "version": "0.31.17",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.16",
+      "version": "0.31.17",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index fe958029c..198997ca2 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.16",
+  "version": "0.31.17",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 0c9d2b958..9e840ca92 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -204,7 +204,7 @@ export namespace TypeCompiler {
       const checkExpression = CreateExpression(containsSchema, references, 'value')
       const checkMinContains = IsNumber(schema.minContains) ? [`(count >= ${schema.minContains})`] : []
       const checkMaxContains = IsNumber(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : []
-      const checkCount = `const count = ${value}.reduce((${accumulator}, ${parameter}) => ${checkExpression} ? acc + 1 : acc, 0)`
+      const checkCount = `const count = value.reduce((${accumulator}, ${parameter}) => ${checkExpression} ? acc + 1 : acc, 0)`
       const check = [`(count > 0)`, ...checkMinContains, ...checkMaxContains].join(' && ')
       yield `((${parameter}) => { ${checkCount}; return ${check}})(${value})`
     }
diff --git a/test/runtime/compiler-ajv/array.ts b/test/runtime/compiler-ajv/array.ts
index dd9feaea4..589bc03ac 100644
--- a/test/runtime/compiler-ajv/array.ts
+++ b/test/runtime/compiler-ajv/array.ts
@@ -145,4 +145,42 @@ describe('compiler-ajv/Array', () => {
     Fail(T, [1, 1, 1, 1, 1])
     Fail(T, [1, 1, 1, 1, 1, 1])
   })
+  // ----------------------------------------------------------------
+  // Issue: https://github.com/sinclairzx81/typebox/discussions/607
+  // ----------------------------------------------------------------
+  it('Should correctly handle undefined array properties', () => {
+    const Answer = Type.Object({
+      text: Type.String(),
+      isCorrect: Type.Boolean(),
+    })
+    const Question = Type.Object({
+      text: Type.String(),
+      options: Type.Array(Answer, {
+        minContains: 1,
+        maxContains: 1,
+        contains: Type.Object({
+          text: Type.String(),
+          isCorrect: Type.Literal(true),
+        }),
+      }),
+    })
+    Fail(Question, { text: 'A' })
+    Fail(Question, { text: 'A', options: [] })
+    Ok(Question, { text: 'A', options: [{ text: 'A', isCorrect: true }] })
+    Ok(Question, {
+      text: 'A',
+      options: [
+        { text: 'A', isCorrect: true },
+        { text: 'B', isCorrect: false },
+      ],
+    })
+    Fail(Question, { text: 'A', options: [{ text: 'A', isCorrect: false }] })
+    Fail(Question, {
+      text: 'A',
+      options: [
+        { text: 'A', isCorrect: true },
+        { text: 'B', isCorrect: true },
+      ],
+    })
+  })
 })
diff --git a/test/runtime/compiler/array.ts b/test/runtime/compiler/array.ts
index ae8fa4a6a..70af4c500 100644
--- a/test/runtime/compiler/array.ts
+++ b/test/runtime/compiler/array.ts
@@ -145,4 +145,42 @@ describe('compiler/Array', () => {
     Fail(T, [1, 1, 1, 1, 1])
     Fail(T, [1, 1, 1, 1, 1, 1])
   })
+  // ----------------------------------------------------------------
+  // Issue: https://github.com/sinclairzx81/typebox/discussions/607
+  // ----------------------------------------------------------------
+  it('Should correctly handle undefined array properties', () => {
+    const Answer = Type.Object({
+      text: Type.String(),
+      isCorrect: Type.Boolean(),
+    })
+    const Question = Type.Object({
+      text: Type.String(),
+      options: Type.Array(Answer, {
+        minContains: 1,
+        maxContains: 1,
+        contains: Type.Object({
+          text: Type.String(),
+          isCorrect: Type.Literal(true),
+        }),
+      }),
+    })
+    Fail(Question, { text: 'A' })
+    Fail(Question, { text: 'A', options: [] })
+    Ok(Question, { text: 'A', options: [{ text: 'A', isCorrect: true }] })
+    Ok(Question, {
+      text: 'A',
+      options: [
+        { text: 'A', isCorrect: true },
+        { text: 'B', isCorrect: false },
+      ],
+    })
+    Fail(Question, { text: 'A', options: [{ text: 'A', isCorrect: false }] })
+    Fail(Question, {
+      text: 'A',
+      options: [
+        { text: 'A', isCorrect: true },
+        { text: 'B', isCorrect: true },
+      ],
+    })
+  })
 })
diff --git a/test/runtime/value/check/array.ts b/test/runtime/value/check/array.ts
index 421a3e19a..9ad1be58c 100644
--- a/test/runtime/value/check/array.ts
+++ b/test/runtime/value/check/array.ts
@@ -110,4 +110,46 @@ describe('value/check/Array', () => {
     Assert.IsFalse(Value.Check(T, [1, 1, 1, 1, 1]))
     Assert.IsFalse(Value.Check(T, [1, 1, 1, 1, 1, 1]))
   })
+  // ----------------------------------------------------------------
+  // Issue: https://github.com/sinclairzx81/typebox/discussions/607
+  // ----------------------------------------------------------------
+  it('Should correctly handle undefined array properties', () => {
+    const Answer = Type.Object({
+      text: Type.String(),
+      isCorrect: Type.Boolean(),
+    })
+    const Question = Type.Object({
+      text: Type.String(),
+      options: Type.Array(Answer, {
+        minContains: 1,
+        maxContains: 1,
+        contains: Type.Object({
+          text: Type.String(),
+          isCorrect: Type.Literal(true),
+        }),
+      }),
+    })
+    Assert.IsFalse(Value.Check(Question, { text: 'A' }))
+    Assert.IsFalse(Value.Check(Question, { text: 'A', options: [] }))
+    Assert.IsTrue(Value.Check(Question, { text: 'A', options: [{ text: 'A', isCorrect: true }] }))
+    Assert.IsTrue(
+      Value.Check(Question, {
+        text: 'A',
+        options: [
+          { text: 'A', isCorrect: true },
+          { text: 'B', isCorrect: false },
+        ],
+      }),
+    )
+    Assert.IsFalse(Value.Check(Question, { text: 'A', options: [{ text: 'A', isCorrect: false }] }))
+    Assert.IsFalse(
+      Value.Check(Question, {
+        text: 'A',
+        options: [
+          { text: 'A', isCorrect: true },
+          { text: 'B', isCorrect: true },
+        ],
+      }),
+    )
+  })
 })

From 8f723677ad27917945ac27db52203a5e727bd814 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Thu, 5 Oct 2023 16:12:18 +0900
Subject: [PATCH 201/369] Hammer 0.18.0

---
 package-lock.json | 391 ++++++++++++++++++++++------------------------
 package.json      |   2 +-
 2 files changed, 184 insertions(+), 209 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 849e6bbd8..9869d6ff3 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,7 +9,7 @@
       "version": "0.31.17",
       "license": "MIT",
       "devDependencies": {
-        "@sinclair/hammer": "^0.17.1",
+        "@sinclair/hammer": "^0.18.0",
         "@types/mocha": "^9.1.1",
         "@types/node": "^18.11.9",
         "ajv": "^8.12.0",
@@ -19,26 +19,10 @@
         "typescript": "^5.2.2"
       }
     },
-    "node_modules/@esbuild/android-arm": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.15.18.tgz",
-      "integrity": "sha512-5GT+kcs2WVGjVs7+boataCkO5Fg0y4kCjzkB5bAip7H4jfnOS3dA6KPiww9W1OEKTKeAcUVhdZGvgI65OXmUnw==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
     "node_modules/@esbuild/linux-loong64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.15.18.tgz",
-      "integrity": "sha512-L4jVKS82XVhw2nvzLg/19ClLWg0y27ulRwuP7lcyL6AbUWB5aPglXY3M21mauDQMDfRLs8cQmeT03r/+X3cZYQ==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.15.7.tgz",
+      "integrity": "sha512-IKznSJOsVUuyt7cDzzSZyqBEcZe+7WlBqTVXiF1OXP/4Nm387ToaXZ0fyLwI1iBlI/bzpxVq411QE2/Bt2XWWw==",
       "cpu": [
         "loong64"
       ],
@@ -52,12 +36,12 @@
       }
     },
     "node_modules/@sinclair/hammer": {
-      "version": "0.17.2",
-      "resolved": "https://registry.npmjs.org/@sinclair/hammer/-/hammer-0.17.2.tgz",
-      "integrity": "sha512-Nnzq4JuC3VB0JNEfxU4U9W65yCe4+/ft0+FGf6/HBn7BoxW3aigusstFdrzVdhjJ6NVABCwUBMgtYbD9X7Z94g==",
+      "version": "0.18.0",
+      "resolved": "https://registry.npmjs.org/@sinclair/hammer/-/hammer-0.18.0.tgz",
+      "integrity": "sha512-nIrsOWvvCV/SjTSU4qcOsY3mEO8ErN2WBWzbn6mVpqDajy36lG9WbDEfR6Agm3LbN2pdPl1HGjKuiHpbpOTZ2A==",
       "dev": true,
       "dependencies": {
-        "esbuild": "^0.15.7"
+        "esbuild": "0.15.7"
       },
       "bin": {
         "hammer": "hammer"
@@ -362,9 +346,9 @@
       "dev": true
     },
     "node_modules/esbuild": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.15.18.tgz",
-      "integrity": "sha512-x/R72SmW3sSFRm5zrrIjAhCeQSAWoni3CmHEqfQrZIQTM3lVCdehdwuIqaOtfC2slvpdlLa62GYoN8SxT23m6Q==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.15.7.tgz",
+      "integrity": "sha512-7V8tzllIbAQV1M4QoE52ImKu8hT/NLGlGXkiDsbEU5PS6K8Mn09ZnYoS+dcmHxOS9CRsV4IRAMdT3I67IyUNXw==",
       "dev": true,
       "hasInstallScript": true,
       "bin": {
@@ -374,34 +358,33 @@
         "node": ">=12"
       },
       "optionalDependencies": {
-        "@esbuild/android-arm": "0.15.18",
-        "@esbuild/linux-loong64": "0.15.18",
-        "esbuild-android-64": "0.15.18",
-        "esbuild-android-arm64": "0.15.18",
-        "esbuild-darwin-64": "0.15.18",
-        "esbuild-darwin-arm64": "0.15.18",
-        "esbuild-freebsd-64": "0.15.18",
-        "esbuild-freebsd-arm64": "0.15.18",
-        "esbuild-linux-32": "0.15.18",
-        "esbuild-linux-64": "0.15.18",
-        "esbuild-linux-arm": "0.15.18",
-        "esbuild-linux-arm64": "0.15.18",
-        "esbuild-linux-mips64le": "0.15.18",
-        "esbuild-linux-ppc64le": "0.15.18",
-        "esbuild-linux-riscv64": "0.15.18",
-        "esbuild-linux-s390x": "0.15.18",
-        "esbuild-netbsd-64": "0.15.18",
-        "esbuild-openbsd-64": "0.15.18",
-        "esbuild-sunos-64": "0.15.18",
-        "esbuild-windows-32": "0.15.18",
-        "esbuild-windows-64": "0.15.18",
-        "esbuild-windows-arm64": "0.15.18"
+        "@esbuild/linux-loong64": "0.15.7",
+        "esbuild-android-64": "0.15.7",
+        "esbuild-android-arm64": "0.15.7",
+        "esbuild-darwin-64": "0.15.7",
+        "esbuild-darwin-arm64": "0.15.7",
+        "esbuild-freebsd-64": "0.15.7",
+        "esbuild-freebsd-arm64": "0.15.7",
+        "esbuild-linux-32": "0.15.7",
+        "esbuild-linux-64": "0.15.7",
+        "esbuild-linux-arm": "0.15.7",
+        "esbuild-linux-arm64": "0.15.7",
+        "esbuild-linux-mips64le": "0.15.7",
+        "esbuild-linux-ppc64le": "0.15.7",
+        "esbuild-linux-riscv64": "0.15.7",
+        "esbuild-linux-s390x": "0.15.7",
+        "esbuild-netbsd-64": "0.15.7",
+        "esbuild-openbsd-64": "0.15.7",
+        "esbuild-sunos-64": "0.15.7",
+        "esbuild-windows-32": "0.15.7",
+        "esbuild-windows-64": "0.15.7",
+        "esbuild-windows-arm64": "0.15.7"
       }
     },
     "node_modules/esbuild-android-64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-android-64/-/esbuild-android-64-0.15.18.tgz",
-      "integrity": "sha512-wnpt3OXRhcjfIDSZu9bnzT4/TNTDsOUvip0foZOUBG7QbSt//w3QV4FInVJxNhKc/ErhUxc5z4QjHtMi7/TbgA==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-android-64/-/esbuild-android-64-0.15.7.tgz",
+      "integrity": "sha512-p7rCvdsldhxQr3YHxptf1Jcd86dlhvc3EQmQJaZzzuAxefO9PvcI0GLOa5nCWem1AJ8iMRu9w0r5TG8pHmbi9w==",
       "cpu": [
         "x64"
       ],
@@ -415,9 +398,9 @@
       }
     },
     "node_modules/esbuild-android-arm64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-android-arm64/-/esbuild-android-arm64-0.15.18.tgz",
-      "integrity": "sha512-G4xu89B8FCzav9XU8EjsXacCKSG2FT7wW9J6hOc18soEHJdtWu03L3TQDGf0geNxfLTtxENKBzMSq9LlbjS8OQ==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-android-arm64/-/esbuild-android-arm64-0.15.7.tgz",
+      "integrity": "sha512-L775l9ynJT7rVqRM5vo+9w5g2ysbOCfsdLV4CWanTZ1k/9Jb3IYlQ06VCI1edhcosTYJRECQFJa3eAvkx72eyQ==",
       "cpu": [
         "arm64"
       ],
@@ -431,9 +414,9 @@
       }
     },
     "node_modules/esbuild-darwin-64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-darwin-64/-/esbuild-darwin-64-0.15.18.tgz",
-      "integrity": "sha512-2WAvs95uPnVJPuYKP0Eqx+Dl/jaYseZEUUT1sjg97TJa4oBtbAKnPnl3b5M9l51/nbx7+QAEtuummJZW0sBEmg==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-darwin-64/-/esbuild-darwin-64-0.15.7.tgz",
+      "integrity": "sha512-KGPt3r1c9ww009t2xLB6Vk0YyNOXh7hbjZ3EecHoVDxgtbUlYstMPDaReimKe6eOEfyY4hBEEeTvKwPsiH5WZg==",
       "cpu": [
         "x64"
       ],
@@ -447,9 +430,9 @@
       }
     },
     "node_modules/esbuild-darwin-arm64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-darwin-arm64/-/esbuild-darwin-arm64-0.15.18.tgz",
-      "integrity": "sha512-tKPSxcTJ5OmNb1btVikATJ8NftlyNlc8BVNtyT/UAr62JFOhwHlnoPrhYWz09akBLHI9nElFVfWSTSRsrZiDUA==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-darwin-arm64/-/esbuild-darwin-arm64-0.15.7.tgz",
+      "integrity": "sha512-kBIHvtVqbSGajN88lYMnR3aIleH3ABZLLFLxwL2stiuIGAjGlQW741NxVTpUHQXUmPzxi6POqc9npkXa8AcSZQ==",
       "cpu": [
         "arm64"
       ],
@@ -463,9 +446,9 @@
       }
     },
     "node_modules/esbuild-freebsd-64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-freebsd-64/-/esbuild-freebsd-64-0.15.18.tgz",
-      "integrity": "sha512-TT3uBUxkteAjR1QbsmvSsjpKjOX6UkCstr8nMr+q7zi3NuZ1oIpa8U41Y8I8dJH2fJgdC3Dj3CXO5biLQpfdZA==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-freebsd-64/-/esbuild-freebsd-64-0.15.7.tgz",
+      "integrity": "sha512-hESZB91qDLV5MEwNxzMxPfbjAhOmtfsr9Wnuci7pY6TtEh4UDuevmGmkUIjX/b+e/k4tcNBMf7SRQ2mdNuK/HQ==",
       "cpu": [
         "x64"
       ],
@@ -479,9 +462,9 @@
       }
     },
     "node_modules/esbuild-freebsd-arm64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-freebsd-arm64/-/esbuild-freebsd-arm64-0.15.18.tgz",
-      "integrity": "sha512-R/oVr+X3Tkh+S0+tL41wRMbdWtpWB8hEAMsOXDumSSa6qJR89U0S/PpLXrGF7Wk/JykfpWNokERUpCeHDl47wA==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-freebsd-arm64/-/esbuild-freebsd-arm64-0.15.7.tgz",
+      "integrity": "sha512-dLFR0ChH5t+b3J8w0fVKGvtwSLWCv7GYT2Y2jFGulF1L5HftQLzVGN+6pi1SivuiVSmTh28FwUhi9PwQicXI6Q==",
       "cpu": [
         "arm64"
       ],
@@ -495,9 +478,9 @@
       }
     },
     "node_modules/esbuild-linux-32": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-32/-/esbuild-linux-32-0.15.18.tgz",
-      "integrity": "sha512-lphF3HiCSYtaa9p1DtXndiQEeQDKPl9eN/XNoBf2amEghugNuqXNZA/ZovthNE2aa4EN43WroO0B85xVSjYkbg==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-32/-/esbuild-linux-32-0.15.7.tgz",
+      "integrity": "sha512-v3gT/LsONGUZcjbt2swrMjwxo32NJzk+7sAgtxhGx1+ZmOFaTRXBAi1PPfgpeo/J//Un2jIKm/I+qqeo4caJvg==",
       "cpu": [
         "ia32"
       ],
@@ -511,9 +494,9 @@
       }
     },
     "node_modules/esbuild-linux-64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-64/-/esbuild-linux-64-0.15.18.tgz",
-      "integrity": "sha512-hNSeP97IviD7oxLKFuii5sDPJ+QHeiFTFLoLm7NZQligur8poNOWGIgpQ7Qf8Balb69hptMZzyOBIPtY09GZYw==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-64/-/esbuild-linux-64-0.15.7.tgz",
+      "integrity": "sha512-LxXEfLAKwOVmm1yecpMmWERBshl+Kv5YJ/1KnyAr6HRHFW8cxOEsEfisD3sVl/RvHyW//lhYUVSuy9jGEfIRAQ==",
       "cpu": [
         "x64"
       ],
@@ -527,9 +510,9 @@
       }
     },
     "node_modules/esbuild-linux-arm": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-arm/-/esbuild-linux-arm-0.15.18.tgz",
-      "integrity": "sha512-UH779gstRblS4aoS2qpMl3wjg7U0j+ygu3GjIeTonCcN79ZvpPee12Qun3vcdxX+37O5LFxz39XeW2I9bybMVA==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-arm/-/esbuild-linux-arm-0.15.7.tgz",
+      "integrity": "sha512-JKgAHtMR5f75wJTeuNQbyznZZa+pjiUHV7sRZp42UNdyXC6TiUYMW/8z8yIBAr2Fpad8hM1royZKQisqPABPvQ==",
       "cpu": [
         "arm"
       ],
@@ -543,9 +526,9 @@
       }
     },
     "node_modules/esbuild-linux-arm64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-arm64/-/esbuild-linux-arm64-0.15.18.tgz",
-      "integrity": "sha512-54qr8kg/6ilcxd+0V3h9rjT4qmjc0CccMVWrjOEM/pEcUzt8X62HfBSeZfT2ECpM7104mk4yfQXkosY8Quptug==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-arm64/-/esbuild-linux-arm64-0.15.7.tgz",
+      "integrity": "sha512-P3cfhudpzWDkglutWgXcT2S7Ft7o2e3YDMrP1n0z2dlbUZghUkKCyaWw0zhp4KxEEzt/E7lmrtRu/pGWnwb9vw==",
       "cpu": [
         "arm64"
       ],
@@ -559,9 +542,9 @@
       }
     },
     "node_modules/esbuild-linux-mips64le": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-mips64le/-/esbuild-linux-mips64le-0.15.18.tgz",
-      "integrity": "sha512-Mk6Ppwzzz3YbMl/ZZL2P0q1tnYqh/trYZ1VfNP47C31yT0K8t9s7Z077QrDA/guU60tGNp2GOwCQnp+DYv7bxQ==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-mips64le/-/esbuild-linux-mips64le-0.15.7.tgz",
+      "integrity": "sha512-T7XKuxl0VpeFLCJXub6U+iybiqh0kM/bWOTb4qcPyDDwNVhLUiPcGdG2/0S7F93czUZOKP57YiLV8YQewgLHKw==",
       "cpu": [
         "mips64el"
       ],
@@ -575,9 +558,9 @@
       }
     },
     "node_modules/esbuild-linux-ppc64le": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-ppc64le/-/esbuild-linux-ppc64le-0.15.18.tgz",
-      "integrity": "sha512-b0XkN4pL9WUulPTa/VKHx2wLCgvIAbgwABGnKMY19WhKZPT+8BxhZdqz6EgkqCLld7X5qiCY2F/bfpUUlnFZ9w==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-ppc64le/-/esbuild-linux-ppc64le-0.15.7.tgz",
+      "integrity": "sha512-6mGuC19WpFN7NYbecMIJjeQgvDb5aMuvyk0PDYBJrqAEMkTwg3Z98kEKuCm6THHRnrgsdr7bp4SruSAxEM4eJw==",
       "cpu": [
         "ppc64"
       ],
@@ -591,9 +574,9 @@
       }
     },
     "node_modules/esbuild-linux-riscv64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-riscv64/-/esbuild-linux-riscv64-0.15.18.tgz",
-      "integrity": "sha512-ba2COaoF5wL6VLZWn04k+ACZjZ6NYniMSQStodFKH/Pu6RxzQqzsmjR1t9QC89VYJxBeyVPTaHuBMCejl3O/xg==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-riscv64/-/esbuild-linux-riscv64-0.15.7.tgz",
+      "integrity": "sha512-uUJsezbswAYo/X7OU/P+PuL/EI9WzxsEQXDekfwpQ23uGiooxqoLFAPmXPcRAt941vjlY9jtITEEikWMBr+F/g==",
       "cpu": [
         "riscv64"
       ],
@@ -607,9 +590,9 @@
       }
     },
     "node_modules/esbuild-linux-s390x": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-s390x/-/esbuild-linux-s390x-0.15.18.tgz",
-      "integrity": "sha512-VbpGuXEl5FCs1wDVp93O8UIzl3ZrglgnSQ+Hu79g7hZu6te6/YHgVJxCM2SqfIila0J3k0csfnf8VD2W7u2kzQ==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-s390x/-/esbuild-linux-s390x-0.15.7.tgz",
+      "integrity": "sha512-+tO+xOyTNMc34rXlSxK7aCwJgvQyffqEM5MMdNDEeMU3ss0S6wKvbBOQfgd5jRPblfwJ6b+bKiz0g5nABpY0QQ==",
       "cpu": [
         "s390x"
       ],
@@ -623,9 +606,9 @@
       }
     },
     "node_modules/esbuild-netbsd-64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-netbsd-64/-/esbuild-netbsd-64-0.15.18.tgz",
-      "integrity": "sha512-98ukeCdvdX7wr1vUYQzKo4kQ0N2p27H7I11maINv73fVEXt2kyh4K4m9f35U1K43Xc2QGXlzAw0K9yoU7JUjOg==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-netbsd-64/-/esbuild-netbsd-64-0.15.7.tgz",
+      "integrity": "sha512-yVc4Wz+Pu3cP5hzm5kIygNPrjar/v5WCSoRmIjCPWfBVJkZNb5brEGKUlf+0Y759D48BCWa0WHrWXaNy0DULTQ==",
       "cpu": [
         "x64"
       ],
@@ -639,9 +622,9 @@
       }
     },
     "node_modules/esbuild-openbsd-64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-openbsd-64/-/esbuild-openbsd-64-0.15.18.tgz",
-      "integrity": "sha512-yK5NCcH31Uae076AyQAXeJzt/vxIo9+omZRKj1pauhk3ITuADzuOx5N2fdHrAKPxN+zH3w96uFKlY7yIn490xQ==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-openbsd-64/-/esbuild-openbsd-64-0.15.7.tgz",
+      "integrity": "sha512-GsimbwC4FSR4lN3wf8XmTQ+r8/0YSQo21rWDL0XFFhLHKlzEA4SsT1Tl8bPYu00IU6UWSJ+b3fG/8SB69rcuEQ==",
       "cpu": [
         "x64"
       ],
@@ -655,9 +638,9 @@
       }
     },
     "node_modules/esbuild-sunos-64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-sunos-64/-/esbuild-sunos-64-0.15.18.tgz",
-      "integrity": "sha512-On22LLFlBeLNj/YF3FT+cXcyKPEI263nflYlAhz5crxtp3yRG1Ugfr7ITyxmCmjm4vbN/dGrb/B7w7U8yJR9yw==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-sunos-64/-/esbuild-sunos-64-0.15.7.tgz",
+      "integrity": "sha512-8CDI1aL/ts0mDGbWzjEOGKXnU7p3rDzggHSBtVryQzkSOsjCHRVe0iFYUuhczlxU1R3LN/E7HgUO4NXzGGP/Ag==",
       "cpu": [
         "x64"
       ],
@@ -671,9 +654,9 @@
       }
     },
     "node_modules/esbuild-windows-32": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-windows-32/-/esbuild-windows-32-0.15.18.tgz",
-      "integrity": "sha512-o+eyLu2MjVny/nt+E0uPnBxYuJHBvho8vWsC2lV61A7wwTWC3jkN2w36jtA+yv1UgYkHRihPuQsL23hsCYGcOQ==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-32/-/esbuild-windows-32-0.15.7.tgz",
+      "integrity": "sha512-cOnKXUEPS8EGCzRSFa1x6NQjGhGsFlVgjhqGEbLTPsA7x4RRYiy2RKoArNUU4iR2vHmzqS5Gr84MEumO/wxYKA==",
       "cpu": [
         "ia32"
       ],
@@ -687,9 +670,9 @@
       }
     },
     "node_modules/esbuild-windows-64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-windows-64/-/esbuild-windows-64-0.15.18.tgz",
-      "integrity": "sha512-qinug1iTTaIIrCorAUjR0fcBk24fjzEedFYhhispP8Oc7SFvs+XeW3YpAKiKp8dRpizl4YYAhxMjlftAMJiaUw==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-64/-/esbuild-windows-64-0.15.7.tgz",
+      "integrity": "sha512-7MI08Ec2sTIDv+zH6StNBKO+2hGUYIT42GmFyW6MBBWWtJhTcQLinKS6ldIN1d52MXIbiJ6nXyCJ+LpL4jBm3Q==",
       "cpu": [
         "x64"
       ],
@@ -703,9 +686,9 @@
       }
     },
     "node_modules/esbuild-windows-arm64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-windows-arm64/-/esbuild-windows-arm64-0.15.18.tgz",
-      "integrity": "sha512-q9bsYzegpZcLziq0zgUi5KqGVtfhjxGbnksaBFYmWLxeV/S1fK4OLdq2DFYnXcLMjlZw2L0jLsk1eGoB522WXQ==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-arm64/-/esbuild-windows-arm64-0.15.7.tgz",
+      "integrity": "sha512-R06nmqBlWjKHddhRJYlqDd3Fabx9LFdKcjoOy08YLimwmsswlFBJV4rXzZCxz/b7ZJXvrZgj8DDv1ewE9+StMw==",
       "cpu": [
         "arm64"
       ],
@@ -1464,27 +1447,20 @@
     }
   },
   "dependencies": {
-    "@esbuild/android-arm": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.15.18.tgz",
-      "integrity": "sha512-5GT+kcs2WVGjVs7+boataCkO5Fg0y4kCjzkB5bAip7H4jfnOS3dA6KPiww9W1OEKTKeAcUVhdZGvgI65OXmUnw==",
-      "dev": true,
-      "optional": true
-    },
     "@esbuild/linux-loong64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.15.18.tgz",
-      "integrity": "sha512-L4jVKS82XVhw2nvzLg/19ClLWg0y27ulRwuP7lcyL6AbUWB5aPglXY3M21mauDQMDfRLs8cQmeT03r/+X3cZYQ==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.15.7.tgz",
+      "integrity": "sha512-IKznSJOsVUuyt7cDzzSZyqBEcZe+7WlBqTVXiF1OXP/4Nm387ToaXZ0fyLwI1iBlI/bzpxVq411QE2/Bt2XWWw==",
       "dev": true,
       "optional": true
     },
     "@sinclair/hammer": {
-      "version": "0.17.2",
-      "resolved": "https://registry.npmjs.org/@sinclair/hammer/-/hammer-0.17.2.tgz",
-      "integrity": "sha512-Nnzq4JuC3VB0JNEfxU4U9W65yCe4+/ft0+FGf6/HBn7BoxW3aigusstFdrzVdhjJ6NVABCwUBMgtYbD9X7Z94g==",
+      "version": "0.18.0",
+      "resolved": "https://registry.npmjs.org/@sinclair/hammer/-/hammer-0.18.0.tgz",
+      "integrity": "sha512-nIrsOWvvCV/SjTSU4qcOsY3mEO8ErN2WBWzbn6mVpqDajy36lG9WbDEfR6Agm3LbN2pdPl1HGjKuiHpbpOTZ2A==",
       "dev": true,
       "requires": {
-        "esbuild": "^0.15.7"
+        "esbuild": "0.15.7"
       }
     },
     "@types/mocha": {
@@ -1711,172 +1687,171 @@
       "dev": true
     },
     "esbuild": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.15.18.tgz",
-      "integrity": "sha512-x/R72SmW3sSFRm5zrrIjAhCeQSAWoni3CmHEqfQrZIQTM3lVCdehdwuIqaOtfC2slvpdlLa62GYoN8SxT23m6Q==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.15.7.tgz",
+      "integrity": "sha512-7V8tzllIbAQV1M4QoE52ImKu8hT/NLGlGXkiDsbEU5PS6K8Mn09ZnYoS+dcmHxOS9CRsV4IRAMdT3I67IyUNXw==",
       "dev": true,
       "requires": {
-        "@esbuild/android-arm": "0.15.18",
-        "@esbuild/linux-loong64": "0.15.18",
-        "esbuild-android-64": "0.15.18",
-        "esbuild-android-arm64": "0.15.18",
-        "esbuild-darwin-64": "0.15.18",
-        "esbuild-darwin-arm64": "0.15.18",
-        "esbuild-freebsd-64": "0.15.18",
-        "esbuild-freebsd-arm64": "0.15.18",
-        "esbuild-linux-32": "0.15.18",
-        "esbuild-linux-64": "0.15.18",
-        "esbuild-linux-arm": "0.15.18",
-        "esbuild-linux-arm64": "0.15.18",
-        "esbuild-linux-mips64le": "0.15.18",
-        "esbuild-linux-ppc64le": "0.15.18",
-        "esbuild-linux-riscv64": "0.15.18",
-        "esbuild-linux-s390x": "0.15.18",
-        "esbuild-netbsd-64": "0.15.18",
-        "esbuild-openbsd-64": "0.15.18",
-        "esbuild-sunos-64": "0.15.18",
-        "esbuild-windows-32": "0.15.18",
-        "esbuild-windows-64": "0.15.18",
-        "esbuild-windows-arm64": "0.15.18"
+        "@esbuild/linux-loong64": "0.15.7",
+        "esbuild-android-64": "0.15.7",
+        "esbuild-android-arm64": "0.15.7",
+        "esbuild-darwin-64": "0.15.7",
+        "esbuild-darwin-arm64": "0.15.7",
+        "esbuild-freebsd-64": "0.15.7",
+        "esbuild-freebsd-arm64": "0.15.7",
+        "esbuild-linux-32": "0.15.7",
+        "esbuild-linux-64": "0.15.7",
+        "esbuild-linux-arm": "0.15.7",
+        "esbuild-linux-arm64": "0.15.7",
+        "esbuild-linux-mips64le": "0.15.7",
+        "esbuild-linux-ppc64le": "0.15.7",
+        "esbuild-linux-riscv64": "0.15.7",
+        "esbuild-linux-s390x": "0.15.7",
+        "esbuild-netbsd-64": "0.15.7",
+        "esbuild-openbsd-64": "0.15.7",
+        "esbuild-sunos-64": "0.15.7",
+        "esbuild-windows-32": "0.15.7",
+        "esbuild-windows-64": "0.15.7",
+        "esbuild-windows-arm64": "0.15.7"
       }
     },
     "esbuild-android-64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-android-64/-/esbuild-android-64-0.15.18.tgz",
-      "integrity": "sha512-wnpt3OXRhcjfIDSZu9bnzT4/TNTDsOUvip0foZOUBG7QbSt//w3QV4FInVJxNhKc/ErhUxc5z4QjHtMi7/TbgA==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-android-64/-/esbuild-android-64-0.15.7.tgz",
+      "integrity": "sha512-p7rCvdsldhxQr3YHxptf1Jcd86dlhvc3EQmQJaZzzuAxefO9PvcI0GLOa5nCWem1AJ8iMRu9w0r5TG8pHmbi9w==",
       "dev": true,
       "optional": true
     },
     "esbuild-android-arm64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-android-arm64/-/esbuild-android-arm64-0.15.18.tgz",
-      "integrity": "sha512-G4xu89B8FCzav9XU8EjsXacCKSG2FT7wW9J6hOc18soEHJdtWu03L3TQDGf0geNxfLTtxENKBzMSq9LlbjS8OQ==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-android-arm64/-/esbuild-android-arm64-0.15.7.tgz",
+      "integrity": "sha512-L775l9ynJT7rVqRM5vo+9w5g2ysbOCfsdLV4CWanTZ1k/9Jb3IYlQ06VCI1edhcosTYJRECQFJa3eAvkx72eyQ==",
       "dev": true,
       "optional": true
     },
     "esbuild-darwin-64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-darwin-64/-/esbuild-darwin-64-0.15.18.tgz",
-      "integrity": "sha512-2WAvs95uPnVJPuYKP0Eqx+Dl/jaYseZEUUT1sjg97TJa4oBtbAKnPnl3b5M9l51/nbx7+QAEtuummJZW0sBEmg==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-darwin-64/-/esbuild-darwin-64-0.15.7.tgz",
+      "integrity": "sha512-KGPt3r1c9ww009t2xLB6Vk0YyNOXh7hbjZ3EecHoVDxgtbUlYstMPDaReimKe6eOEfyY4hBEEeTvKwPsiH5WZg==",
       "dev": true,
       "optional": true
     },
     "esbuild-darwin-arm64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-darwin-arm64/-/esbuild-darwin-arm64-0.15.18.tgz",
-      "integrity": "sha512-tKPSxcTJ5OmNb1btVikATJ8NftlyNlc8BVNtyT/UAr62JFOhwHlnoPrhYWz09akBLHI9nElFVfWSTSRsrZiDUA==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-darwin-arm64/-/esbuild-darwin-arm64-0.15.7.tgz",
+      "integrity": "sha512-kBIHvtVqbSGajN88lYMnR3aIleH3ABZLLFLxwL2stiuIGAjGlQW741NxVTpUHQXUmPzxi6POqc9npkXa8AcSZQ==",
       "dev": true,
       "optional": true
     },
     "esbuild-freebsd-64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-freebsd-64/-/esbuild-freebsd-64-0.15.18.tgz",
-      "integrity": "sha512-TT3uBUxkteAjR1QbsmvSsjpKjOX6UkCstr8nMr+q7zi3NuZ1oIpa8U41Y8I8dJH2fJgdC3Dj3CXO5biLQpfdZA==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-freebsd-64/-/esbuild-freebsd-64-0.15.7.tgz",
+      "integrity": "sha512-hESZB91qDLV5MEwNxzMxPfbjAhOmtfsr9Wnuci7pY6TtEh4UDuevmGmkUIjX/b+e/k4tcNBMf7SRQ2mdNuK/HQ==",
       "dev": true,
       "optional": true
     },
     "esbuild-freebsd-arm64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-freebsd-arm64/-/esbuild-freebsd-arm64-0.15.18.tgz",
-      "integrity": "sha512-R/oVr+X3Tkh+S0+tL41wRMbdWtpWB8hEAMsOXDumSSa6qJR89U0S/PpLXrGF7Wk/JykfpWNokERUpCeHDl47wA==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-freebsd-arm64/-/esbuild-freebsd-arm64-0.15.7.tgz",
+      "integrity": "sha512-dLFR0ChH5t+b3J8w0fVKGvtwSLWCv7GYT2Y2jFGulF1L5HftQLzVGN+6pi1SivuiVSmTh28FwUhi9PwQicXI6Q==",
       "dev": true,
       "optional": true
     },
     "esbuild-linux-32": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-32/-/esbuild-linux-32-0.15.18.tgz",
-      "integrity": "sha512-lphF3HiCSYtaa9p1DtXndiQEeQDKPl9eN/XNoBf2amEghugNuqXNZA/ZovthNE2aa4EN43WroO0B85xVSjYkbg==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-32/-/esbuild-linux-32-0.15.7.tgz",
+      "integrity": "sha512-v3gT/LsONGUZcjbt2swrMjwxo32NJzk+7sAgtxhGx1+ZmOFaTRXBAi1PPfgpeo/J//Un2jIKm/I+qqeo4caJvg==",
       "dev": true,
       "optional": true
     },
     "esbuild-linux-64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-64/-/esbuild-linux-64-0.15.18.tgz",
-      "integrity": "sha512-hNSeP97IviD7oxLKFuii5sDPJ+QHeiFTFLoLm7NZQligur8poNOWGIgpQ7Qf8Balb69hptMZzyOBIPtY09GZYw==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-64/-/esbuild-linux-64-0.15.7.tgz",
+      "integrity": "sha512-LxXEfLAKwOVmm1yecpMmWERBshl+Kv5YJ/1KnyAr6HRHFW8cxOEsEfisD3sVl/RvHyW//lhYUVSuy9jGEfIRAQ==",
       "dev": true,
       "optional": true
     },
     "esbuild-linux-arm": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-arm/-/esbuild-linux-arm-0.15.18.tgz",
-      "integrity": "sha512-UH779gstRblS4aoS2qpMl3wjg7U0j+ygu3GjIeTonCcN79ZvpPee12Qun3vcdxX+37O5LFxz39XeW2I9bybMVA==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-arm/-/esbuild-linux-arm-0.15.7.tgz",
+      "integrity": "sha512-JKgAHtMR5f75wJTeuNQbyznZZa+pjiUHV7sRZp42UNdyXC6TiUYMW/8z8yIBAr2Fpad8hM1royZKQisqPABPvQ==",
       "dev": true,
       "optional": true
     },
     "esbuild-linux-arm64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-arm64/-/esbuild-linux-arm64-0.15.18.tgz",
-      "integrity": "sha512-54qr8kg/6ilcxd+0V3h9rjT4qmjc0CccMVWrjOEM/pEcUzt8X62HfBSeZfT2ECpM7104mk4yfQXkosY8Quptug==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-arm64/-/esbuild-linux-arm64-0.15.7.tgz",
+      "integrity": "sha512-P3cfhudpzWDkglutWgXcT2S7Ft7o2e3YDMrP1n0z2dlbUZghUkKCyaWw0zhp4KxEEzt/E7lmrtRu/pGWnwb9vw==",
       "dev": true,
       "optional": true
     },
     "esbuild-linux-mips64le": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-mips64le/-/esbuild-linux-mips64le-0.15.18.tgz",
-      "integrity": "sha512-Mk6Ppwzzz3YbMl/ZZL2P0q1tnYqh/trYZ1VfNP47C31yT0K8t9s7Z077QrDA/guU60tGNp2GOwCQnp+DYv7bxQ==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-mips64le/-/esbuild-linux-mips64le-0.15.7.tgz",
+      "integrity": "sha512-T7XKuxl0VpeFLCJXub6U+iybiqh0kM/bWOTb4qcPyDDwNVhLUiPcGdG2/0S7F93czUZOKP57YiLV8YQewgLHKw==",
       "dev": true,
       "optional": true
     },
     "esbuild-linux-ppc64le": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-ppc64le/-/esbuild-linux-ppc64le-0.15.18.tgz",
-      "integrity": "sha512-b0XkN4pL9WUulPTa/VKHx2wLCgvIAbgwABGnKMY19WhKZPT+8BxhZdqz6EgkqCLld7X5qiCY2F/bfpUUlnFZ9w==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-ppc64le/-/esbuild-linux-ppc64le-0.15.7.tgz",
+      "integrity": "sha512-6mGuC19WpFN7NYbecMIJjeQgvDb5aMuvyk0PDYBJrqAEMkTwg3Z98kEKuCm6THHRnrgsdr7bp4SruSAxEM4eJw==",
       "dev": true,
       "optional": true
     },
     "esbuild-linux-riscv64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-riscv64/-/esbuild-linux-riscv64-0.15.18.tgz",
-      "integrity": "sha512-ba2COaoF5wL6VLZWn04k+ACZjZ6NYniMSQStodFKH/Pu6RxzQqzsmjR1t9QC89VYJxBeyVPTaHuBMCejl3O/xg==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-riscv64/-/esbuild-linux-riscv64-0.15.7.tgz",
+      "integrity": "sha512-uUJsezbswAYo/X7OU/P+PuL/EI9WzxsEQXDekfwpQ23uGiooxqoLFAPmXPcRAt941vjlY9jtITEEikWMBr+F/g==",
       "dev": true,
       "optional": true
     },
     "esbuild-linux-s390x": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-linux-s390x/-/esbuild-linux-s390x-0.15.18.tgz",
-      "integrity": "sha512-VbpGuXEl5FCs1wDVp93O8UIzl3ZrglgnSQ+Hu79g7hZu6te6/YHgVJxCM2SqfIila0J3k0csfnf8VD2W7u2kzQ==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-linux-s390x/-/esbuild-linux-s390x-0.15.7.tgz",
+      "integrity": "sha512-+tO+xOyTNMc34rXlSxK7aCwJgvQyffqEM5MMdNDEeMU3ss0S6wKvbBOQfgd5jRPblfwJ6b+bKiz0g5nABpY0QQ==",
       "dev": true,
       "optional": true
     },
     "esbuild-netbsd-64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-netbsd-64/-/esbuild-netbsd-64-0.15.18.tgz",
-      "integrity": "sha512-98ukeCdvdX7wr1vUYQzKo4kQ0N2p27H7I11maINv73fVEXt2kyh4K4m9f35U1K43Xc2QGXlzAw0K9yoU7JUjOg==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-netbsd-64/-/esbuild-netbsd-64-0.15.7.tgz",
+      "integrity": "sha512-yVc4Wz+Pu3cP5hzm5kIygNPrjar/v5WCSoRmIjCPWfBVJkZNb5brEGKUlf+0Y759D48BCWa0WHrWXaNy0DULTQ==",
       "dev": true,
       "optional": true
     },
     "esbuild-openbsd-64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-openbsd-64/-/esbuild-openbsd-64-0.15.18.tgz",
-      "integrity": "sha512-yK5NCcH31Uae076AyQAXeJzt/vxIo9+omZRKj1pauhk3ITuADzuOx5N2fdHrAKPxN+zH3w96uFKlY7yIn490xQ==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-openbsd-64/-/esbuild-openbsd-64-0.15.7.tgz",
+      "integrity": "sha512-GsimbwC4FSR4lN3wf8XmTQ+r8/0YSQo21rWDL0XFFhLHKlzEA4SsT1Tl8bPYu00IU6UWSJ+b3fG/8SB69rcuEQ==",
       "dev": true,
       "optional": true
     },
     "esbuild-sunos-64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-sunos-64/-/esbuild-sunos-64-0.15.18.tgz",
-      "integrity": "sha512-On22LLFlBeLNj/YF3FT+cXcyKPEI263nflYlAhz5crxtp3yRG1Ugfr7ITyxmCmjm4vbN/dGrb/B7w7U8yJR9yw==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-sunos-64/-/esbuild-sunos-64-0.15.7.tgz",
+      "integrity": "sha512-8CDI1aL/ts0mDGbWzjEOGKXnU7p3rDzggHSBtVryQzkSOsjCHRVe0iFYUuhczlxU1R3LN/E7HgUO4NXzGGP/Ag==",
       "dev": true,
       "optional": true
     },
     "esbuild-windows-32": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-windows-32/-/esbuild-windows-32-0.15.18.tgz",
-      "integrity": "sha512-o+eyLu2MjVny/nt+E0uPnBxYuJHBvho8vWsC2lV61A7wwTWC3jkN2w36jtA+yv1UgYkHRihPuQsL23hsCYGcOQ==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-32/-/esbuild-windows-32-0.15.7.tgz",
+      "integrity": "sha512-cOnKXUEPS8EGCzRSFa1x6NQjGhGsFlVgjhqGEbLTPsA7x4RRYiy2RKoArNUU4iR2vHmzqS5Gr84MEumO/wxYKA==",
       "dev": true,
       "optional": true
     },
     "esbuild-windows-64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-windows-64/-/esbuild-windows-64-0.15.18.tgz",
-      "integrity": "sha512-qinug1iTTaIIrCorAUjR0fcBk24fjzEedFYhhispP8Oc7SFvs+XeW3YpAKiKp8dRpizl4YYAhxMjlftAMJiaUw==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-64/-/esbuild-windows-64-0.15.7.tgz",
+      "integrity": "sha512-7MI08Ec2sTIDv+zH6StNBKO+2hGUYIT42GmFyW6MBBWWtJhTcQLinKS6ldIN1d52MXIbiJ6nXyCJ+LpL4jBm3Q==",
       "dev": true,
       "optional": true
     },
     "esbuild-windows-arm64": {
-      "version": "0.15.18",
-      "resolved": "https://registry.npmjs.org/esbuild-windows-arm64/-/esbuild-windows-arm64-0.15.18.tgz",
-      "integrity": "sha512-q9bsYzegpZcLziq0zgUi5KqGVtfhjxGbnksaBFYmWLxeV/S1fK4OLdq2DFYnXcLMjlZw2L0jLsk1eGoB522WXQ==",
+      "version": "0.15.7",
+      "resolved": "https://registry.npmjs.org/esbuild-windows-arm64/-/esbuild-windows-arm64-0.15.7.tgz",
+      "integrity": "sha512-R06nmqBlWjKHddhRJYlqDd3Fabx9LFdKcjoOy08YLimwmsswlFBJV4rXzZCxz/b7ZJXvrZgj8DDv1ewE9+StMw==",
       "dev": true,
       "optional": true
     },
diff --git a/package.json b/package.json
index 198997ca2..d3e7e5d90 100644
--- a/package.json
+++ b/package.json
@@ -52,7 +52,7 @@
     "publish:dev": "hammer task publish_dev"
   },
   "devDependencies": {
-    "@sinclair/hammer": "^0.17.1",
+    "@sinclair/hammer": "^0.18.0",
     "@types/mocha": "^9.1.1",
     "@types/node": "^18.11.9",
     "ajv": "^8.12.0",

From 0252b4a696aebf22c912bf70d897cc7898329540 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 17 Oct 2023 22:54:22 +0900
Subject: [PATCH 202/369] Revision 0.31.18 (#635)

* Support Generic Union Interior Transform

* Update Test

* Optimize Union Encode Check
---
 package-lock.json                     |  4 +--
 package.json                          |  2 +-
 src/value/transform.ts                |  7 +++++
 test/runtime/value/transform/union.ts | 43 +++++++++++++++++++++++----
 4 files changed, 47 insertions(+), 9 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 9869d6ff3..12347b661 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.17",
+  "version": "0.31.18",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.17",
+      "version": "0.31.18",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.18.0",
diff --git a/package.json b/package.json
index d3e7e5d90..b3a03d866 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.17",
+  "version": "0.31.18",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/transform.ts b/src/value/transform.ts
index 12faf5834..281917f18 100644
--- a/src/value/transform.ts
+++ b/src/value/transform.ts
@@ -403,11 +403,18 @@ export namespace EncodeTransform {
     return IsArray(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, value1[index])) : []
   }
   function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any) {
+    // test value against union variants
     for (const subschema of schema.anyOf) {
       if (!checkFunction(subschema, references, value)) continue
       const value1 = Visit(subschema, references, value)
       return Default(schema, value1)
     }
+    // test transformed value against union variants
+    for (const subschema of schema.anyOf) {
+      const value1 = Visit(subschema, references, value)
+      if (!checkFunction(schema, references, value1)) continue
+      return Default(schema, value1)
+    }
     return Default(schema, value)
   }
   function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
diff --git a/test/runtime/value/transform/union.ts b/test/runtime/value/transform/union.ts
index 993c87002..d1a9cebc5 100644
--- a/test/runtime/value/transform/union.ts
+++ b/test/runtime/value/transform/union.ts
@@ -1,6 +1,6 @@
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
-import { Type } from '@sinclair/typebox'
+import { Type, TSchema } from '@sinclair/typebox'
 
 describe('value/transform/Union', () => {
   // --------------------------------------------------------
@@ -126,11 +126,10 @@ describe('value/transform/Union', () => {
   const N41 = Type.Transform(Type.Number())
     .Decode((value) => value + 1)
     .Encode((value) => value - 1)
-  const N42 = Type.Transform(
-    Type.Object({
-      x: Type.Number(),
-    }),
-  )
+  // prettier-ignore
+  const N42 = Type.Transform(Type.Object({
+    x: Type.Number()
+  }))
     .Decode((value) => ({ x: value.x + 1 }))
     .Encode((value) => ({ x: value.x - 1 }))
   const N43 = Type.Transform(Type.Tuple([Type.Number()]))
@@ -167,4 +166,36 @@ describe('value/transform/Union', () => {
   it('Should throw on mixed types decode', () => {
     Assert.Throws(() => Value.Decode(T4, null))
   })
+  // --------------------------------------------------------
+  // Interior Union Transform
+  //
+  // https://github.com/sinclairzx81/typebox/issues/631
+  // --------------------------------------------------------
+  const T51 = Type.Transform(Type.String())
+    .Decode((value) => new Date(value))
+    .Encode((value) => value.toISOString())
+  const T52 = Type.Union([Type.Null(), T51])
+  it('Should decode interior union 1', () => {
+    const R = Value.Decode(T52, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should decode interior union 2', () => {
+    const R = Value.Decode(T52, new Date().toISOString())
+    Assert.IsInstanceOf(R, Date)
+  })
+  it('Should encode interior union 1', () => {
+    const R = Value.Encode(T52, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should encode interior union 2', () => {
+    const D = new Date()
+    const R = Value.Encode(T52, D)
+    Assert.IsEqual(R, D.toISOString())
+  })
+  it('Should throw on interior union decode', () => {
+    Assert.Throws(() => Value.Decode(T52, {}))
+  })
+  it('Should throw on interior union encode', () => {
+    Assert.Throws(() => Value.Encode(T52, 1))
+  })
 })

From b0b66890008bab3b8fcaf94498f753bb72eaf8d5 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 26 Oct 2023 03:26:27 +0900
Subject: [PATCH 203/369] Revision 0.31.19 (#644)

* Encode Error Path for RFC9601 Escape Sequences

* Record Tests + Version
---
 package-lock.json                             |   4 +-
 package.json                                  |   2 +-
 src/errors/errors.ts                          |  24 +--
 test/runtime/errors/types/index.ts            |   2 +
 .../errors/types/object-pointer-property.ts   | 139 ++++++++++++++++++
 .../errors/types/record-pointer-property.ts   |  70 +++++++++
 6 files changed, 229 insertions(+), 12 deletions(-)
 create mode 100644 test/runtime/errors/types/object-pointer-property.ts
 create mode 100644 test/runtime/errors/types/record-pointer-property.ts

diff --git a/package-lock.json b/package-lock.json
index 12347b661..c831cfa01 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.18",
+  "version": "0.31.19",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.18",
+      "version": "0.31.19",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.18.0",
diff --git a/package.json b/package.json
index b3a03d866..85d102ed9 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.18",
+  "version": "0.31.19",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index f9b4b4edc..9f09e1f55 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -119,6 +119,12 @@ export class ValueErrorsUnknownTypeError extends Types.TypeBoxError {
   }
 }
 // --------------------------------------------------------------------------
+// EscapeKey
+// --------------------------------------------------------------------------
+export function EscapeKey(key: string): string {
+  return key.replace(/~/g, '~0').replace(/\//g, '~1') // RFC6901 Path
+}
+// --------------------------------------------------------------------------
 // Guards
 // --------------------------------------------------------------------------
 function IsDefined<T>(value: unknown): value is T {
@@ -319,31 +325,31 @@ function* TObject(schema: Types.TObject, references: Types.TSchema[], path: stri
   const unknownKeys = Object.getOwnPropertyNames(value)
   for (const requiredKey of requiredKeys) {
     if (unknownKeys.includes(requiredKey)) continue
-    yield Create(ValueErrorType.ObjectRequiredProperty, schema.properties[requiredKey], `${path}/${requiredKey}`, undefined)
+    yield Create(ValueErrorType.ObjectRequiredProperty, schema.properties[requiredKey], `${path}/${EscapeKey(requiredKey)}`, undefined)
   }
   if (schema.additionalProperties === false) {
     for (const valueKey of unknownKeys) {
       if (!knownKeys.includes(valueKey)) {
-        yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path}/${valueKey}`, value[valueKey])
+        yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path}/${EscapeKey(valueKey)}`, value[valueKey])
       }
     }
   }
   if (typeof schema.additionalProperties === 'object') {
     for (const valueKey of unknownKeys) {
       if (knownKeys.includes(valueKey)) continue
-      yield* Visit(schema.additionalProperties as Types.TSchema, references, `${path}/${valueKey}`, value[valueKey])
+      yield* Visit(schema.additionalProperties as Types.TSchema, references, `${path}/${EscapeKey(valueKey)}`, value[valueKey])
     }
   }
   for (const knownKey of knownKeys) {
     const property = schema.properties[knownKey]
     if (schema.required && schema.required.includes(knownKey)) {
-      yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey])
+      yield* Visit(property, references, `${path}/${EscapeKey(knownKey)}`, value[knownKey])
       if (Types.ExtendsUndefined.Check(schema) && !(knownKey in value)) {
-        yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path}/${knownKey}`, undefined)
+        yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path}/${EscapeKey(knownKey)}`, undefined)
       }
     } else {
       if (TypeSystemPolicy.IsExactOptionalProperty(value, knownKey)) {
-        yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey])
+        yield* Visit(property, references, `${path}/${EscapeKey(knownKey)}`, value[knownKey])
       }
     }
   }
@@ -362,17 +368,17 @@ function* TRecord(schema: Types.TRecord, references: Types.TSchema[], path: stri
   const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0]
   const regex = new RegExp(patternKey)
   for (const [propertyKey, propertyValue] of Object.entries(value)) {
-    if (regex.test(propertyKey)) yield* Visit(patternSchema, references, `${path}/${propertyKey}`, propertyValue)
+    if (regex.test(propertyKey)) yield* Visit(patternSchema, references, `${path}/${EscapeKey(propertyKey)}`, propertyValue)
   }
   if (typeof schema.additionalProperties === 'object') {
     for (const [propertyKey, propertyValue] of Object.entries(value)) {
-      if (!regex.test(propertyKey)) yield* Visit(schema.additionalProperties as Types.TSchema, references, `${path}/${propertyKey}`, propertyValue)
+      if (!regex.test(propertyKey)) yield* Visit(schema.additionalProperties as Types.TSchema, references, `${path}/${EscapeKey(propertyKey)}`, propertyValue)
     }
   }
   if (schema.additionalProperties === false) {
     for (const [propertyKey, propertyValue] of Object.entries(value)) {
       if (regex.test(propertyKey)) continue
-      return yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path}/${propertyKey}`, propertyValue)
+      return yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path}/${EscapeKey(propertyKey)}`, propertyValue)
     }
   }
 }
diff --git a/test/runtime/errors/types/index.ts b/test/runtime/errors/types/index.ts
index 077ccbe9e..44730ba30 100644
--- a/test/runtime/errors/types/index.ts
+++ b/test/runtime/errors/types/index.ts
@@ -43,9 +43,11 @@ import './number-multiple-of'
 import './object-additional-properties'
 import './object-max-properties'
 import './object-min-properties'
+import './object-pointer-property'
 import './object-required-property'
 import './object'
 import './promise'
+import './record-pointer-property'
 import './string-format-unknown'
 import './string-format'
 import './string-max-length'
diff --git a/test/runtime/errors/types/object-pointer-property.ts b/test/runtime/errors/types/object-pointer-property.ts
new file mode 100644
index 000000000..ccf045896
--- /dev/null
+++ b/test/runtime/errors/types/object-pointer-property.ts
@@ -0,0 +1,139 @@
+import { Type } from '@sinclair/typebox'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/ObjectPointerProperty', () => {
+  // ----------------------------------------------------------------
+  // Known
+  // ----------------------------------------------------------------
+  it('Should produce known pointer property path 1', () => {
+    const T = Type.Object({ 'a/b': Type.String() })
+    const R = Resolve(T, { 'a/b': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/a~1b')
+  })
+  it('Should produce known pointer property path 2', () => {
+    const T = Type.Object({ 'a~b': Type.String() })
+    const R = Resolve(T, { 'a~b': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/a~0b')
+  })
+  it('Should produce known pointer property path 3', () => {
+    const T = Type.Object({ 'a/b~c': Type.String() })
+    const R = Resolve(T, { 'a/b~c': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/a~1b~0c')
+  })
+  it('Should produce known pointer property path 4', () => {
+    const T = Type.Object({ 'a~b/c': Type.String() })
+    const R = Resolve(T, { 'a~b/c': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/a~0b~1c')
+  })
+  it('Should produce known pointer property path 5', () => {
+    const T = Type.Object({ 'a~b/c/d': Type.String() })
+    const R = Resolve(T, { 'a~b/c/d': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/a~0b~1c~1d')
+  })
+  it('Should produce known pointer property path 6', () => {
+    const T = Type.Object({ 'a~b/c/d~e': Type.String() })
+    const R = Resolve(T, { 'a~b/c/d~e': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/a~0b~1c~1d~0e')
+  })
+  // ----------------------------------------------------------------
+  // Unknown Additional
+  // ----------------------------------------------------------------
+  it('Should produce unknown pointer property path 1', () => {
+    const T = Type.Object({}, { additionalProperties: false })
+    const R = Resolve(T, { 'a/b': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/a~1b')
+  })
+  it('Should produce unknown pointer property path 2', () => {
+    const T = Type.Object({}, { additionalProperties: false })
+    const R = Resolve(T, { 'a~b': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/a~0b')
+  })
+  // ----------------------------------------------------------------
+  // Unknown Constrained
+  // ----------------------------------------------------------------
+  it('Should produce unknown constrained pointer property path 1', () => {
+    const T = Type.Object({}, { additionalProperties: Type.String() })
+    const R = Resolve(T, { 'a/b': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/a~1b')
+  })
+  it('Should produce unknown constrained pointer property path 2', () => {
+    const T = Type.Object({}, { additionalProperties: Type.String() })
+    const R = Resolve(T, { 'a~b': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/a~0b')
+  })
+  // ----------------------------------------------------------------
+  // Nested
+  // ----------------------------------------------------------------
+  it('Should produce nested pointer 1', () => {
+    const T = Type.Object({
+      'x/y': Type.Object({
+        z: Type.Object({
+          w: Type.String(),
+        }),
+      }),
+    })
+    const R = Resolve(T, { 'x/y': { z: { w: 1 } } })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/x~1y/z/w')
+  })
+  it('Should produce nested pointer 2', () => {
+    const T = Type.Object({
+      x: Type.Object({
+        'y/z': Type.Object({
+          w: Type.String(),
+        }),
+      }),
+    })
+    const R = Resolve(T, { x: { 'y/z': { w: 1 } } })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/x/y~1z/w')
+  })
+  it('Should produce nested pointer 3', () => {
+    const T = Type.Object({
+      x: Type.Object({
+        y: Type.Object({
+          'z/w': Type.String(),
+        }),
+      }),
+    })
+    const R = Resolve(T, { x: { y: { 'z/w': 1 } } })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/x/y/z~1w')
+  })
+  // ----------------------------------------------------------------
+  // Nested Array
+  // ----------------------------------------------------------------
+  it('Should produce nested array pointer property path 1', () => {
+    const T = Type.Object({
+      'x/y': Type.Object({
+        z: Type.Array(Type.String()),
+      }),
+    })
+    const R = Resolve(T, { 'x/y': { z: ['a', 'b', 1] } })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/x~1y/z/2')
+  })
+  it('Should produce nested array pointer property path 2', () => {
+    const T = Type.Object({
+      x: Type.Array(
+        Type.Object({
+          'y/z': Type.String(),
+        }),
+      ),
+    })
+    const R = Resolve(T, { x: [{ 'y/z': 'a' }, { 'y/z': 'b' }, { 'y/z': 1 }] })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/x/2/y~1z')
+  })
+})
diff --git a/test/runtime/errors/types/record-pointer-property.ts b/test/runtime/errors/types/record-pointer-property.ts
new file mode 100644
index 000000000..a2dbd3436
--- /dev/null
+++ b/test/runtime/errors/types/record-pointer-property.ts
@@ -0,0 +1,70 @@
+import { Type } from '@sinclair/typebox'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/RecordPointerProperty', () => {
+  // ----------------------------------------------------------------
+  // Known
+  // ----------------------------------------------------------------
+  it('Should produce known pointer property path 1', () => {
+    const T = Type.Record(Type.String(), Type.String())
+    const R = Resolve(T, { 'a/b': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/a~1b')
+  })
+  it('Should produce known pointer property path 2', () => {
+    const T = Type.Record(Type.String(), Type.String())
+    const R = Resolve(T, { 'a~b': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/a~0b')
+  })
+  // ----------------------------------------------------------------
+  // Unknown
+  // ----------------------------------------------------------------
+  it('Should produce unknown pointer property path 1', () => {
+    const T = Type.Record(Type.Number(), Type.String(), {
+      additionalProperties: false,
+    })
+    const R = Resolve(T, { 'a/b': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/a~1b')
+  })
+  it('Should produce unknown pointer property path 1', () => {
+    const T = Type.Record(Type.Number(), Type.String(), {
+      additionalProperties: false,
+    })
+    const R = Resolve(T, { 'a~b': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/a~0b')
+  })
+  // ----------------------------------------------------------------
+  // Unknown Constrained
+  // ----------------------------------------------------------------
+  it('Should produce unknown constrained pointer property path 1', () => {
+    const T = Type.Record(Type.Number(), Type.String(), {
+      additionalProperties: Type.String(),
+    })
+    const R = Resolve(T, { 'a/b': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/a~1b')
+  })
+  it('Should produce unknown constrained pointer property path 1', () => {
+    const T = Type.Record(Type.Number(), Type.String(), {
+      additionalProperties: Type.String(),
+    })
+    const R = Resolve(T, { 'a~b': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/a~0b')
+  })
+  // ----------------------------------------------------------------
+  // PatternProperties
+  // ----------------------------------------------------------------
+  it('Should produce pattern pointer property path 1', () => {
+    const T = Type.Record(Type.TemplateLiteral('${string}/${string}/c'), Type.String(), {
+      additionalProperties: false,
+    })
+    const R = Resolve(T, { 'x/y/z': 1 })
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].path, '/x~1y~1z')
+  })
+})

From a9cfd7e9c34a211a242d4baa0d1b5655563f237c Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 26 Oct 2023 18:21:38 +0900
Subject: [PATCH 204/369] Revision 0.31.20 (#647)

* Support Enum Key Inference on Record Types

* Version

* Use Constrained Key Type of TEnum
---
 package-lock.json     |  4 ++--
 package.json          |  2 +-
 src/typebox.ts        |  3 +++
 test/static/record.ts | 35 ++++++++++++++++++++++++++++++++++-
 4 files changed, 40 insertions(+), 4 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index c831cfa01..49319b749 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.19",
+  "version": "0.31.20",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.19",
+      "version": "0.31.20",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.18.0",
diff --git a/package.json b/package.json
index 85d102ed9..42fe99b9f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.19",
+  "version": "0.31.20",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 4514b9c80..700e1c3ad 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -650,6 +650,8 @@ export interface TPromise<T extends TSchema = TSchema> extends TSchema {
 export type TRecordFromUnionLiteralString<K extends TLiteralString, T extends TSchema> = { [_ in K['const']]: T }
 export type TRecordFromUnionLiteralNumber<K extends TLiteralNumber, T extends TSchema> = { [_ in K['const']]: T }
 // prettier-ignore
+export type TRecordFromEnumKey<K extends TEnum, T extends TSchema> = Ensure<TRecord<K, T>>
+// prettier-ignore
 export type TRecordFromUnionRest<K extends TSchema[], T extends TSchema> = K extends [infer L, ...infer R] ? (
   L extends TUnion<infer S> ? TRecordFromUnionRest<S, T> & TRecordFromUnionRest<AssertRest<R>, T> :
   L extends TLiteralString ? TRecordFromUnionLiteralString<L, T> & TRecordFromUnionRest<AssertRest<R>, T> :
@@ -669,6 +671,7 @@ export type TRecordFromNumberKey<K extends TNumber, T extends TSchema> = Ensure<
 export type TRecordFromIntegerKey<K extends TInteger, T extends TSchema> = Ensure<TRecord<K, T>>
 // prettier-ignore
 export type TRecordResolve<K extends TSchema, T extends TSchema> = 
+  K extends TEnum<infer _> ? TRecordFromEnumKey<K, T> : // Enum before Union (intercept Hint)
   K extends TUnion<infer S> ? TRecordFromUnion<S, T> :
   K extends TTemplateLiteral ? TRecordFromTemplateLiteralKey<K, T> :
   K extends TLiteralString ? TRecordFromLiteralStringKey<K, T> :
diff --git a/test/static/record.ts b/test/static/record.ts
index 819c0ad27..1951bd4cd 100644
--- a/test/static/record.ts
+++ b/test/static/record.ts
@@ -71,13 +71,46 @@ import { Type, Static } from '@sinclair/typebox'
   Expect(T).ToStatic<Record<number, string>>()
 }
 {
+  // Should support enum keys 1
   enum E {
     A = 'X',
     B = 'Y',
     C = 'Z',
   }
   const T = Type.Record(Type.Enum(E), Type.Number())
-  Expect(T).ToStatic<{}>()
+  Expect(T).ToStatic<{
+    X: number
+    Y: number
+    Z: number
+  }>()
+}
+{
+  // Should support enum keys 2
+  enum E {
+    A,
+    B,
+    C,
+  }
+  const T = Type.Record(Type.Enum(E), Type.Number())
+  Expect(T).ToStatic<{
+    0: number
+    1: number
+    2: number
+  }>()
+}
+{
+  // Should support enum keys 3
+  enum E {
+    A = 1,
+    B = '2',
+    C = 'Z',
+  }
+  const T = Type.Record(Type.Enum(E), Type.Number())
+  Expect(T).ToStatic<{
+    1: number
+    2: number
+    Z: number
+  }>()
 }
 {
   // should support infinite record keys

From ce1ace5ffb8fe6625a793e01089f274a82c82ab8 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 29 Oct 2023 20:46:06 +0900
Subject: [PATCH 205/369] Revision 0.31.21 (#650)

* Extends Optional Property Check

* Additional Tests and Version
---
 package-lock.json                   |  4 +-
 package.json                        |  2 +-
 src/typebox.ts                      | 78 ++++++++++++++++-------------
 test/runtime/type/extends/object.ts | 51 +++++++++++++++++++
 4 files changed, 98 insertions(+), 37 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 49319b749..613c25ef0 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.20",
+  "version": "0.31.21",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.20",
+      "version": "0.31.21",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.18.0",
diff --git a/package.json b/package.json
index 42fe99b9f..0b8deb405 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.20",
+  "version": "0.31.21",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 700e1c3ad..0f9d2e03c 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -1144,6 +1144,9 @@ export namespace TypeGuard {
   function IsOptionalSchema(value: unknown): value is boolean | undefined {
     return ValueGuard.IsUndefined(value) || TSchema(value)
   }
+  // ----------------------------------------------------------------
+  // Types
+  // ----------------------------------------------------------------
   /** Returns true if the given value is TAny */
   export function TAny(schema: unknown): schema is TAny {
     // prettier-ignore
@@ -1533,40 +1536,42 @@ export namespace TypeGuard {
   }
   /** Returns true if the given value is TSchema */
   export function TSchema(schema: unknown): schema is TSchema {
+    // prettier-ignore
     return (
-      ValueGuard.IsObject(schema) &&
-      (TAny(schema) ||
-        TArray(schema) ||
-        TBoolean(schema) ||
-        TBigInt(schema) ||
-        TAsyncIterator(schema) ||
-        TConstructor(schema) ||
-        TDate(schema) ||
-        TFunction(schema) ||
-        TInteger(schema) ||
-        TIntersect(schema) ||
-        TIterator(schema) ||
-        TLiteral(schema) ||
-        TNever(schema) ||
-        TNot(schema) ||
-        TNull(schema) ||
-        TNumber(schema) ||
-        TObject(schema) ||
-        TPromise(schema) ||
-        TRecord(schema) ||
-        TRef(schema) ||
-        TString(schema) ||
-        TSymbol(schema) ||
-        TTemplateLiteral(schema) ||
-        TThis(schema) ||
-        TTuple(schema) ||
-        TUndefined(schema) ||
-        TUnion(schema) ||
-        TUint8Array(schema) ||
-        TUnknown(schema) ||
-        TUnsafe(schema) ||
-        TVoid(schema) ||
-        (TKind(schema) && TypeRegistry.Has(schema[Kind] as any)))
+      ValueGuard.IsObject(schema)
+    ) && (
+      TAny(schema) ||
+      TArray(schema) ||
+      TBoolean(schema) ||
+      TBigInt(schema) ||
+      TAsyncIterator(schema) ||
+      TConstructor(schema) ||
+      TDate(schema) ||
+      TFunction(schema) ||
+      TInteger(schema) ||
+      TIntersect(schema) ||
+      TIterator(schema) ||
+      TLiteral(schema) ||
+      TNever(schema) ||
+      TNot(schema) ||
+      TNull(schema) ||
+      TNumber(schema) ||
+      TObject(schema) ||
+      TPromise(schema) ||
+      TRecord(schema) ||
+      TRef(schema) ||
+      TString(schema) ||
+      TSymbol(schema) ||
+      TTemplateLiteral(schema) ||
+      TThis(schema) ||
+      TTuple(schema) ||
+      TUndefined(schema) ||
+      TUnion(schema) ||
+      TUint8Array(schema) ||
+      TUnknown(schema) ||
+      TUnsafe(schema) ||
+      TVoid(schema) ||
+      (TKind(schema) && TypeRegistry.Has(schema[Kind] as any))
     )
   }
 }
@@ -1986,7 +1991,12 @@ export namespace TypeExtends {
       !TypeGuard.TObject(right) ? TypeExtendsResult.False :
       (() => {
         for (const key of Object.getOwnPropertyNames(right.properties)) {
-          if (!(key in left.properties)) return TypeExtendsResult.False
+          if (!(key in left.properties) && !TypeGuard.TOptional(right.properties[key])) {
+            return TypeExtendsResult.False
+          }
+          if(TypeGuard.TOptional(right.properties[key])) {
+            return TypeExtendsResult.True
+          }
           if (Property(left.properties[key], right.properties[key]) === TypeExtendsResult.False) {
             return TypeExtendsResult.False
           }
diff --git a/test/runtime/type/extends/object.ts b/test/runtime/type/extends/object.ts
index 172eb46bf..8bc3a6e63 100644
--- a/test/runtime/type/extends/object.ts
+++ b/test/runtime/type/extends/object.ts
@@ -174,4 +174,55 @@ describe('type/extends/Object', () => {
     const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Date())
     Assert.IsEqual(R, TypeExtendsResult.False)
   })
+  // ----------------------------------------------------------------
+  // Optional
+  // ----------------------------------------------------------------
+  it('Should extend optional 1', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ a: Type.Optional(Type.Number()) })
+    const C = TypeExtends.Extends(A, B)
+    Assert.IsEqual(C, TypeExtendsResult.True)
+  })
+  it('Should extend optional 2', () => {
+    const A = Type.Object({ a: Type.Number() })
+    const B = Type.Object({ a: Type.Optional(Type.Number()) })
+    const C = TypeExtends.Extends(B, A)
+    Assert.IsEqual(C, TypeExtendsResult.False)
+  })
+  it('Should extend optional 3', () => {
+    const A = Type.Object({
+      x: Type.Optional(Type.Number()),
+      y: Type.Number(),
+    })
+    const B = Type.Object({
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    const R = TypeExtends.Extends(A, B)
+    Assert.IsEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend optional 4', () => {
+    const A = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    })
+    const B = Type.Object({
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    const R = TypeExtends.Extends(A, B)
+    Assert.IsEqual(R, TypeExtendsResult.False)
+  })
+  it('Should extend optional 5', () => {
+    const A = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    })
+    const B = Type.Object({
+      y: Type.Number(),
+      z: Type.Optional(Type.Number()),
+    })
+    const R = TypeExtends.Extends(A, B)
+    Assert.IsEqual(R, TypeExtendsResult.True)
+  })
 })

From f049ce389055bc4f170c8e707680499165f20e07 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 3 Nov 2023 00:44:16 +0900
Subject: [PATCH 206/369] Revision 0.31.22 (#652)

* Ensure Record into Object for known Enum keys

* Version and Static Tests
---
 package-lock.json     |  4 ++--
 package.json          |  2 +-
 src/typebox.ts        |  5 +++--
 test/static/record.ts | 48 +++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 54 insertions(+), 5 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 613c25ef0..a8b8a5930 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.21",
+  "version": "0.31.22",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.21",
+      "version": "0.31.22",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.18.0",
diff --git a/package.json b/package.json
index 0b8deb405..2cb992096 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.21",
+  "version": "0.31.22",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 0f9d2e03c..e105237f6 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -650,7 +650,7 @@ export interface TPromise<T extends TSchema = TSchema> extends TSchema {
 export type TRecordFromUnionLiteralString<K extends TLiteralString, T extends TSchema> = { [_ in K['const']]: T }
 export type TRecordFromUnionLiteralNumber<K extends TLiteralNumber, T extends TSchema> = { [_ in K['const']]: T }
 // prettier-ignore
-export type TRecordFromEnumKey<K extends TEnum, T extends TSchema> = Ensure<TRecord<K, T>>
+export type TRecordFromEnumKey<K extends Record<string, string | number>, T extends TSchema> = Ensure<TObject<{ [_ in K[keyof K]]: T }>>
 // prettier-ignore
 export type TRecordFromUnionRest<K extends TSchema[], T extends TSchema> = K extends [infer L, ...infer R] ? (
   L extends TUnion<infer S> ? TRecordFromUnionRest<S, T> & TRecordFromUnionRest<AssertRest<R>, T> :
@@ -671,7 +671,7 @@ export type TRecordFromNumberKey<K extends TNumber, T extends TSchema> = Ensure<
 export type TRecordFromIntegerKey<K extends TInteger, T extends TSchema> = Ensure<TRecord<K, T>>
 // prettier-ignore
 export type TRecordResolve<K extends TSchema, T extends TSchema> = 
-  K extends TEnum<infer _> ? TRecordFromEnumKey<K, T> : // Enum before Union (intercept Hint)
+  K extends TEnum<infer S> ? TRecordFromEnumKey<S, T> : // Enum before Union (intercept Hint)
   K extends TUnion<infer S> ? TRecordFromUnion<S, T> :
   K extends TTemplateLiteral ? TRecordFromTemplateLiteralKey<K, T> :
   K extends TLiteralString ? TRecordFromLiteralStringKey<K, T> :
@@ -2915,6 +2915,7 @@ export class JsonTypeBuilder extends TypeBuilder {
   }
   /** `[Json]` Creates a Enum type */
   public Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options: SchemaOptions = {}): TEnum<T> {
+    if (ValueGuard.IsUndefined(item)) return this.Throw('Enum undefined or empty')
     // prettier-ignore
     const values1 = Object.getOwnPropertyNames(item).filter((key) => isNaN(key as any)).map((key) => item[key]) as T[keyof T][]
     const values2 = [...new Set(values1)]
diff --git a/test/static/record.ts b/test/static/record.ts
index 1951bd4cd..e21356595 100644
--- a/test/static/record.ts
+++ b/test/static/record.ts
@@ -128,3 +128,51 @@ import { Type, Static } from '@sinclair/typebox'
   const I = Type.Intersect([R, T])
   Expect(I).ToStatic<Record<`key${number}`, number> & { x: number; y: number }>()
 }
+{
+  // expect T as Object
+  enum E {
+    A,
+    B,
+    C,
+  }
+  const T = Type.Record(Type.Enum(E), Type.Number())
+  Expect(T).ToStatic<{
+    0: number
+    1: number
+    2: number
+  }>
+}
+{
+  // expect T as Partial Object
+  enum E {
+    A,
+    B,
+    C,
+  }
+  const T = Type.Partial(Type.Record(Type.Enum(E), Type.Number()))
+  Expect(T).ToStatic<{
+    0?: number
+    1?: number
+    2?: number
+  }>
+}
+{
+  // expect T to support named properties
+  enum E {
+    A = 'A',
+    B = 'B',
+    C = 'C',
+  }
+  const T = Type.Record(Type.Enum(E), Type.Number())
+  Expect(T).ToStatic<{
+    A: number
+    B: number
+    C: number
+  }>
+}
+{
+  // expect T to support named properties
+  enum E {}
+  const T = Type.Record(Type.Enum(E), Type.Number())
+  Expect(T).ToStatic<{}>
+}

From f89bc81fac78f823718a9d50cece67bd3db48c2a Mon Sep 17 00:00:00 2001
From: Florian De la comble <f.delacomble@gmail.com>
Date: Tue, 7 Nov 2023 15:48:21 +0100
Subject: [PATCH 207/369] Ecosystem (#656)

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 16449a07b..48c5a97f0 100644
--- a/readme.md
+++ b/readme.md
@@ -1611,7 +1611,7 @@ The following is a list of community packages that offer general tooling, extend
 | [openapi-box](https://github.com/geut/openapi-box) | Generate TypeBox types from OpenApi IDL + Http client library |
 | [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from Json Schemas |
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
-| [typebox-client](https://github.com/flodlc/typebox-client) | Type safe http client library for Fastify |
+| [http-wizard](https://github.com/flodlc/http-wizard) | Type safe http client library for Fastify |
 | [typebox-form-parser](https://github.com/jtlapp/typebox-form-parser) | Parses form and query data based on TypeBox schemas |
 | [typebox-validators](https://github.com/jtlapp/typebox-validators) | Advanced validators supporting discriminated and heterogeneous unions |
 

From a770b94c737d7771ca249fb645aad8e915032c60 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 8 Nov 2023 00:29:44 +0900
Subject: [PATCH 208/369] Revision 0.31.23 (#658)

* Modifier Inference Path on Required and Partial

* Formatting

* Sort Ecosystem
---
 package-lock.json       |  4 ++--
 package.json            |  2 +-
 readme.md               |  2 +-
 src/typebox.ts          | 12 ++++++++++--
 test/static/partial.ts  | 17 ++++++++++++++++-
 test/static/required.ts | 16 ++++++++++++++++
 6 files changed, 46 insertions(+), 7 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index a8b8a5930..92ca683d4 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.22",
+  "version": "0.31.23",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.22",
+      "version": "0.31.23",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.18.0",
diff --git a/package.json b/package.json
index 2cb992096..cc5ea9f99 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.22",
+  "version": "0.31.23",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 48c5a97f0..d4868e0d7 100644
--- a/readme.md
+++ b/readme.md
@@ -1608,10 +1608,10 @@ The following is a list of community packages that offer general tooling, extend
 | [feathersjs](https://github.com/feathersjs/feathers) | The API and real-time application framework |
 | [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
 | [h3-typebox](https://github.com/kevinmarrec/h3-typebox) | Schema validation utilities for h3 using TypeBox & Ajv |
+| [http-wizard](https://github.com/flodlc/http-wizard) | Type safe http client library for Fastify |
 | [openapi-box](https://github.com/geut/openapi-box) | Generate TypeBox types from OpenApi IDL + Http client library |
 | [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from Json Schemas |
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
-| [http-wizard](https://github.com/flodlc/http-wizard) | Type safe http client library for Fastify |
 | [typebox-form-parser](https://github.com/jtlapp/typebox-form-parser) | Parses form and query data based on TypeBox schemas |
 | [typebox-validators](https://github.com/jtlapp/typebox-validators) | Advanced validators supporting discriminated and heterogeneous unions |
 
diff --git a/src/typebox.ts b/src/typebox.ts
index e105237f6..64bb30df1 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -608,7 +608,11 @@ export type TPartialObjectArray<T extends TObject[]> = AssertRest<{ [K in keyof
 export type TPartialRest<T extends TSchema[]> = AssertRest<{ [K in keyof T]: TPartial<AssertType<T[K]>> }>
 // prettier-ignore
 export type TPartialProperties<T extends TProperties> = Evaluate<AssertProperties<{
-  [K in keyof T]: TOptional<T[K]>
+  [K in keyof T]: 
+    T[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : 
+    T[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : 
+    T[K] extends (TOptional<infer S>) ? TOptional<S> : 
+    TOptional<T[K]>
 }>>
 // prettier-ignore
 export type TPartial<T extends TSchema> =  
@@ -722,7 +726,11 @@ export type TReturnType<T extends TFunction> = T['returns']
 export type TRequiredRest<T extends TSchema[]> = AssertRest<{ [K in keyof T]: TRequired<AssertType<T[K]>> }>
 // prettier-ignore
 export type TRequiredProperties<T extends TProperties> = Evaluate<AssertProperties<{
-  [K in keyof T]: T[K] extends TOptional<infer S> ? S : T[K]
+  [K in keyof T]: 
+    T[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> : 
+    T[K] extends (TReadonly<infer S>) ? TReadonly<S> : 
+    T[K] extends (TOptional<infer S>) ? S : 
+    T[K]
 }>>
 // prettier-ignore
 export type TRequired<T extends TSchema> = 
diff --git a/test/static/partial.ts b/test/static/partial.ts
index d0d075a84..f4f81b023 100644
--- a/test/static/partial.ts
+++ b/test/static/partial.ts
@@ -1,6 +1,6 @@
 import { Expect } from './assert'
 import { Type, Static } from '@sinclair/typebox'
-
+import * as Types from '@sinclair/typebox'
 {
   const T = Type.Partial(
     Type.Object({
@@ -70,3 +70,18 @@ import { Type, Static } from '@sinclair/typebox'
     >()
   }
 }
+{
+  // https://github.com/sinclairzx81/typebox/issues/655
+  const T = Type.Object({
+    a: Type.ReadonlyOptional(Type.Number()),
+    b: Type.Readonly(Type.Number()),
+    c: Type.Optional(Type.Number()),
+    d: Type.Number(),
+  })
+  const R: Types.TObject<{
+    a: Types.TReadonlyOptional<Types.TNumber>
+    b: Types.TReadonlyOptional<Types.TNumber>
+    c: Types.TOptional<Types.TNumber>
+    d: Types.TOptional<Types.TNumber>
+  }> = Type.Partial(T)
+}
diff --git a/test/static/required.ts b/test/static/required.ts
index cbf9fd4e4..a35c61f22 100644
--- a/test/static/required.ts
+++ b/test/static/required.ts
@@ -1,5 +1,6 @@
 import { Expect } from './assert'
 import { Type, Static } from '@sinclair/typebox'
+import * as Types from '@sinclair/typebox'
 {
   const T = Type.Required(
     Type.Object({
@@ -71,3 +72,18 @@ import { Type, Static } from '@sinclair/typebox'
     >()
   }
 }
+{
+  // https://github.com/sinclairzx81/typebox/issues/655
+  const T = Type.Object({
+    a: Type.ReadonlyOptional(Type.Number()),
+    b: Type.Readonly(Type.Number()),
+    c: Type.Optional(Type.Number()),
+    d: Type.Number(),
+  })
+  const R: Types.TObject<{
+    a: Types.TReadonly<Types.TNumber>
+    b: Types.TReadonly<Types.TNumber>
+    c: Types.TNumber
+    d: Types.TNumber
+  }> = Type.Required(T)
+}

From 9cb7b028a9267bb0ee96eda23760dca7937892af Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 15 Nov 2023 15:26:34 +0900
Subject: [PATCH 209/369] Revision 0.31.24 (#664)

* Improve Function and Constructor Inference

* Comment updates on Static types
---
 package-lock.json          |  4 ++--
 package.json               |  2 +-
 src/typebox.ts             | 34 ++++++++++++++++++++--------------
 test/static/constructor.ts | 38 +++++++++++++++++++++++++++++---------
 test/static/function.ts    | 35 ++++++++++++++++++++++++++++-------
 test/static/transform.ts   | 18 ++++++++++++++++++
 6 files changed, 98 insertions(+), 33 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 92ca683d4..184112058 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.23",
+  "version": "0.31.24",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.23",
+      "version": "0.31.24",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.18.0",
diff --git a/package.json b/package.json
index cc5ea9f99..471eb0a1a 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.23",
+  "version": "0.31.24",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 64bb30df1..9afde820d 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -242,9 +242,10 @@ export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptio
 // --------------------------------------------------------------------------
 // TAsyncIterator
 // --------------------------------------------------------------------------
+export type TAsyncIteratorResolve<T extends TSchema, P extends unknown[]> = Ensure<AsyncIterableIterator<Static<T, P>>>
 export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'AsyncIterator'
-  static: AsyncIterableIterator<Static<T, this['params']>>
+  static: TAsyncIteratorResolve<T, this['params']>
   type: 'AsyncIterator'
   items: T
 }
@@ -280,7 +281,7 @@ export interface TBoolean extends TSchema {
 // --------------------------------------------------------------------------
 // TConstructorParameters
 // --------------------------------------------------------------------------
-export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>
+export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = Ensure<TTuple<T['parameters']>>
 // --------------------------------------------------------------------------
 // TInstanceType
 // --------------------------------------------------------------------------
@@ -307,10 +308,12 @@ export type TComposite<T extends TObject[]> = TIntersect<T> extends TIntersect
 // --------------------------------------------------------------------------
 // TConstructor
 // --------------------------------------------------------------------------
-export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{ [K in keyof T]: Static<AssertType<T[K]>, P> }]
+export type TConstructorReturnTypeResolve<T extends TSchema, P extends unknown[]> = Static<T, P>
+export type TConstructorParametersResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TFunctionParametersResolve<R, P>] : []
+export type TConstructorResolve<T extends TSchema[], U extends TSchema, P extends unknown[]> = Ensure<new (...param: TConstructorParametersResolve<T, P>) => TConstructorReturnTypeResolve<U, P>>
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Constructor'
-  static: new (...param: TConstructorParameterArray<T, this['params']>) => Static<U, this['params']>
+  static: TConstructorResolve<T, U, this['params']>
   type: 'Constructor'
   parameters: T
   returns: U
@@ -386,10 +389,12 @@ export type TExtract<T extends TSchema, U extends TSchema> =
 // --------------------------------------------------------------------------
 // TFunction
 // --------------------------------------------------------------------------
-export type TFunctionParameters<T extends TSchema[], P extends unknown[]> = [...{ [K in keyof T]: Static<AssertType<T[K]>, P> }]
+export type TFunctionReturnTypeResolve<T extends TSchema, P extends unknown[]> = Static<T, P>
+export type TFunctionParametersResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TFunctionParametersResolve<R, P>] : []
+export type TFunctionResolve<T extends TSchema[], U extends TSchema, P extends unknown[]> = Ensure<(...param: TFunctionParametersResolve<T, P>) => TFunctionReturnTypeResolve<U, P>>
 export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Function'
-  static: (...param: TFunctionParameters<T, this['params']>) => Static<U, this['params']>
+  static: TFunctionResolve<T, U, this['params']>
   type: 'Function'
   parameters: T
   returns: U
@@ -472,9 +477,10 @@ export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, In
 // --------------------------------------------------------------------------
 // TIterator
 // --------------------------------------------------------------------------
+export type TIteratorResolve<T extends TSchema, P extends unknown[]> = Ensure<IterableIterator<Static<T, P>>>
 export interface TIterator<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Iterator'
-  static: IterableIterator<Static<T, this['params']>>
+  static: TIteratorResolve<T, this['params']>
   type: 'Iterator'
   items: T
 }
@@ -880,9 +886,9 @@ export type DecodeType<T extends TSchema> = (
   T extends TTransform<infer _, infer R> ? TUnsafe<R> :
   T extends TArray<infer S extends TSchema> ? TArray<DecodeType<S>> :
   T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> :
-  T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<P, DecodeType<R>> :
+  T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<DecodeRest<P>, DecodeType<R>> :
   T extends TEnum<infer S> ? TEnum<S> : // intercept for union. interior non decodable
-  T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<P, DecodeType<R>> :
+  T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<DecodeRest<P>, DecodeType<R>> :
   T extends TIntersect<infer S extends TSchema[]> ? TIntersect<DecodeRest<S>> :
   T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> :
   T extends TNot<infer S extends TSchema> ? TNot<DecodeType<S>> :
@@ -988,11 +994,11 @@ export interface TVoid extends TSchema {
 // --------------------------------------------------------------------------
 // Static<T>
 // --------------------------------------------------------------------------
-/** Creates the decoded static form for a TypeBox type */
+/** Creates an decoded static type from a TypeBox type */
 export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<DecodeType<T>, P>
-/** Creates the encoded static form for a TypeBox type */
+/** Creates an encoded static type from a TypeBox type */
 export type StaticEncode<T extends TSchema, P extends unknown[] = []> = Static<T, P>
-/** Creates the static type for a TypeBox type */
+/** Creates a static type from a TypeBox type */
 export type Static<T extends TSchema, P extends unknown[] = []> = (T & { params: P })['static']
 // --------------------------------------------------------------------------
 // TypeRegistry
@@ -3313,7 +3319,7 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     return this.Create({ ...options, [Kind]: 'BigInt', type: 'bigint' })
   }
   /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-  public ConstructorParameters<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TConstructorParameters<T> {
+  public ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options: SchemaOptions = {}): TConstructorParameters<T> {
     return this.Tuple([...schema.parameters], { ...options })
   }
   /** `[JavaScript]` Creates a Constructor type */
@@ -3339,7 +3345,7 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     return this.Create({ ...options, [Kind]: 'Iterator', type: 'Iterator', items: TypeClone.Type(items) })
   }
   /** `[JavaScript]` Extracts the Parameters from the given Function type */
-  public Parameters<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TParameters<T> {
+  public Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options: SchemaOptions = {}): TParameters<T> {
     return this.Tuple(schema.parameters, { ...options })
   }
   /** `[JavaScript]` Creates a Promise type */
diff --git a/test/static/constructor.ts b/test/static/constructor.ts
index a05363991..c91d398e7 100644
--- a/test/static/constructor.ts
+++ b/test/static/constructor.ts
@@ -1,11 +1,31 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
-
-const C = Type.Constructor(
-  [Type.Number(), Type.String()],
-  Type.Object({
-    method: Type.Function([Type.Number(), Type.String()], Type.Boolean()),
-  }),
-)
-
-Expect(C).ToStatic<new (param_0: number, param_1: string) => { method: (param_0: number, param_1: string) => boolean }>()
+{
+  // simple
+  const T = Type.Constructor([Type.Number(), Type.Boolean()], Type.String())
+  Expect(T).ToStatic<new (param_0: number, param_1: boolean) => string>()
+}
+{
+  // nested
+  // prettier-ignore
+  const T = Type.Constructor([Type.Number(), Type.String()], Type.Object({
+    method: Type.Constructor([Type.Number(), Type.String()], Type.Boolean()),
+  }))
+  Expect(T).ToStatic<new (param_0: number, param_1: string) => { method: new (param_0: number, param_1: string) => boolean }>()
+}
+{
+  // decode 2
+  const S = Type.Transform(Type.Integer())
+    .Decode((value) => new Date(value))
+    .Encode((value) => value.getTime())
+  const T = Type.Constructor([S], Type.String())
+  Expect(T).ToStaticDecode<new (param_0: Date) => string>()
+}
+{
+  // decode 1
+  const S = Type.Transform(Type.Integer())
+    .Decode((value) => new Date(value))
+    .Encode((value) => value.getTime())
+  const T = Type.Constructor([Type.Number()], S)
+  Expect(T).ToStaticDecode<new (param_0: number) => Date>()
+}
diff --git a/test/static/function.ts b/test/static/function.ts
index 623aa911e..a204187a6 100644
--- a/test/static/function.ts
+++ b/test/static/function.ts
@@ -1,11 +1,32 @@
 import { Expect } from './assert'
 import { Type } from '@sinclair/typebox'
 
-const C = Type.Function(
-  [Type.Number(), Type.String()],
-  Type.Object({
+{
+  // simple
+  const T = Type.Function([Type.Number(), Type.Boolean()], Type.String())
+  Expect(T).ToStatic<(param_0: number, param_1: boolean) => string>()
+}
+{
+  // nested
+  // prettier-ignore
+  const T = Type.Function([Type.Number(), Type.String()], Type.Object({
     method: Type.Function([Type.Number(), Type.String()], Type.Boolean()),
-  }),
-)
-
-Expect(C).ToStatic<(param_0: number, param_1: string) => { method: (param_0: number, param_1: string) => boolean }>()
+  }))
+  Expect(T).ToStatic<(param_0: number, param_1: string) => { method: (param_0: number, param_1: string) => boolean }>()
+}
+{
+  // decode 2
+  const S = Type.Transform(Type.Integer())
+    .Decode((value) => new Date(value))
+    .Encode((value) => value.getTime())
+  const T = Type.Function([S], Type.String())
+  Expect(T).ToStaticDecode<(param_0: Date) => string>()
+}
+{
+  // decode 1
+  const S = Type.Transform(Type.Integer())
+    .Decode((value) => new Date(value))
+    .Encode((value) => value.getTime())
+  const T = Type.Function([Type.Number()], S)
+  Expect(T).ToStaticDecode<(param_0: number) => Date>()
+}
diff --git a/test/static/transform.ts b/test/static/transform.ts
index 468787ef2..917628a67 100644
--- a/test/static/transform.ts
+++ b/test/static/transform.ts
@@ -291,3 +291,21 @@ import { Expect } from './assert'
   Expect(T).ToStaticDecode<1>()
   Expect(T).ToStaticEncode<E>()
 }
+{
+  // should transform functions
+  const S = Type.Transform(Type.Number())
+    .Decode((value) => new Date(value))
+    .Encode((value) => value.getTime())
+  const T = Type.Function([S], S)
+  Expect(T).ToStaticDecode<(x: Date) => Date>()
+  Expect(T).ToStaticEncode<(x: number) => number>()
+}
+{
+  // should transform constructors
+  const S = Type.Transform(Type.Number())
+    .Decode((value) => new Date(value))
+    .Encode((value) => value.getTime())
+  const T = Type.Constructor([S], S)
+  Expect(T).ToStaticDecode<new (x: Date) => Date>()
+  Expect(T).ToStaticEncode<new (x: number) => number>()
+}

From 5bd9f12eb16cbede35a3ec7f9d4d325e4aee04a1 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 15 Nov 2023 22:43:37 +0900
Subject: [PATCH 210/369] Revision 0.31.25 (#666)

* Github Rendering Fix

* Resolve Iterators

* Version
---
 package-lock.json | 4 ++--
 package.json      | 2 +-
 src/typebox.ts    | 8 ++++----
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 184112058..79a891d45 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.24",
+  "version": "0.31.25",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.24",
+      "version": "0.31.25",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.18.0",
diff --git a/package.json b/package.json
index 471eb0a1a..62752db56 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.24",
+  "version": "0.31.25",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index 9afde820d..aef60231f 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -242,7 +242,7 @@ export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptio
 // --------------------------------------------------------------------------
 // TAsyncIterator
 // --------------------------------------------------------------------------
-export type TAsyncIteratorResolve<T extends TSchema, P extends unknown[]> = Ensure<AsyncIterableIterator<Static<T, P>>>
+export type TAsyncIteratorResolve<T extends TSchema, P extends unknown[]> = AsyncIterableIterator<Ensure<Static<T, P>>>
 export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'AsyncIterator'
   static: TAsyncIteratorResolve<T, this['params']>
@@ -477,7 +477,7 @@ export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, In
 // --------------------------------------------------------------------------
 // TIterator
 // --------------------------------------------------------------------------
-export type TIteratorResolve<T extends TSchema, P extends unknown[]> = Ensure<IterableIterator<Static<T, P>>>
+export type TIteratorResolve<T extends TSchema, P extends unknown[]> = IterableIterator<Ensure<Static<T, P>>>
 export interface TIterator<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Iterator'
   static: TIteratorResolve<T, this['params']>
@@ -858,13 +858,13 @@ export type TTemplateLiteralConst<T, Acc extends string> =
   T extends TBoolean ? `${boolean}` :
   never
 // prettier-ignore
-export type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string = ''> = 
+export type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string> = 
   T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` :
   Acc
 export type TTemplateLiteralKeyRest<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, TPropertyKey[]>
 export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
   [Kind]: 'TemplateLiteral'
-  static: TTemplateLiteralUnion<T>
+  static: TTemplateLiteralUnion<T, ''>
   type: 'string'
   pattern: string // todo: it may be possible to infer this pattern
 }

From 262de46e6c406ce101807885c4e76e2df535a8b8 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 18 Nov 2023 18:09:15 +0900
Subject: [PATCH 211/369] Revision 0.31.26 (#669)

* Tuple Transform Check | Check Both Value and Compiler Encoding in Tests

* Iterator Update | Version

* Revert Iterator Inference
---
 package-lock.json                             |  4 +-
 package.json                                  |  2 +-
 src/compiler/compiler.ts                      |  4 +-
 src/typebox.ts                                |  6 +-
 src/value/transform.ts                        | 19 +++---
 src/value/value.ts                            | 12 ++--
 test/runtime/value/transform/_encoder.ts      | 33 +++++++++++
 test/runtime/value/transform/any.ts           |  9 +--
 test/runtime/value/transform/array.ts         | 31 +++++-----
 .../runtime/value/transform/async-iterator.ts | 13 ++--
 test/runtime/value/transform/bigint.ts        | 13 ++--
 test/runtime/value/transform/boolean.ts       | 13 ++--
 test/runtime/value/transform/constructor.ts   | 13 ++--
 test/runtime/value/transform/date.ts          | 13 ++--
 test/runtime/value/transform/enum.ts          | 13 ++--
 test/runtime/value/transform/function.ts      | 13 ++--
 test/runtime/value/transform/integer.ts       | 13 ++--
 test/runtime/value/transform/intersect.ts     | 31 +++++-----
 test/runtime/value/transform/iterator.ts      | 13 ++--
 test/runtime/value/transform/literal.ts       | 23 ++++----
 test/runtime/value/transform/never.ts         |  9 +--
 test/runtime/value/transform/not.ts           | 13 ++--
 test/runtime/value/transform/null.ts          | 13 ++--
 test/runtime/value/transform/number.ts        | 13 ++--
 test/runtime/value/transform/object.ts        | 39 ++++++------
 test/runtime/value/transform/promise.ts       | 13 ++--
 test/runtime/value/transform/record.ts        | 25 ++++----
 test/runtime/value/transform/recursive.ts     | 19 +++---
 test/runtime/value/transform/ref.ts           | 19 +++---
 test/runtime/value/transform/string.ts        | 35 +++++------
 test/runtime/value/transform/symbol.ts        | 13 ++--
 .../value/transform/template-literal.ts       | 13 ++--
 test/runtime/value/transform/tuple.ts         | 31 +++++-----
 test/runtime/value/transform/undefined.ts     | 13 ++--
 test/runtime/value/transform/union.ts         | 59 ++++++++++---------
 test/runtime/value/transform/unknown.ts       |  9 +--
 test/runtime/value/transform/unsafe.ts        | 13 ++--
 37 files changed, 349 insertions(+), 291 deletions(-)
 create mode 100644 test/runtime/value/transform/_encoder.ts

diff --git a/package-lock.json b/package-lock.json
index 79a891d45..48e7f7e19 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.25",
+  "version": "0.31.26",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.25",
+      "version": "0.31.26",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.18.0",
diff --git a/package.json b/package.json
index 62752db56..f7aa93d5b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.25",
+  "version": "0.31.26",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 9e840ca92..fe03f6d2e 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -61,11 +61,11 @@ export class TypeCheck<T extends Types.TSchema> {
   /** Decodes a value or throws if error */
   public Decode(value: unknown): Types.StaticDecode<T> {
     if (!this.checkFunc(value)) throw new TransformDecodeCheckError(this.schema, value, this.Errors(value).First()!)
-    return this.hasTransform ? DecodeTransform.Decode(this.schema, this.references, value, (_, __, value) => this.Check(value)) : value
+    return this.hasTransform ? DecodeTransform.Decode(this.schema, this.references, value) : value
   }
   /** Encodes a value or throws if error */
   public Encode(value: unknown): Types.StaticEncode<T> {
-    const encoded = this.hasTransform ? EncodeTransform.Encode(this.schema, this.references, value, (_, __, value) => this.Check(value)) : value
+    const encoded = this.hasTransform ? EncodeTransform.Encode(this.schema, this.references, value) : value
     if (!this.checkFunc(encoded)) throw new TransformEncodeCheckError(this.schema, value, this.Errors(value).First()!)
     return encoded
   }
diff --git a/src/typebox.ts b/src/typebox.ts
index aef60231f..bb6c50bf4 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -242,10 +242,9 @@ export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptio
 // --------------------------------------------------------------------------
 // TAsyncIterator
 // --------------------------------------------------------------------------
-export type TAsyncIteratorResolve<T extends TSchema, P extends unknown[]> = AsyncIterableIterator<Ensure<Static<T, P>>>
 export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'AsyncIterator'
-  static: TAsyncIteratorResolve<T, this['params']>
+  static: AsyncIterableIterator<Static<T, this['params']>>
   type: 'AsyncIterator'
   items: T
 }
@@ -477,10 +476,9 @@ export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, In
 // --------------------------------------------------------------------------
 // TIterator
 // --------------------------------------------------------------------------
-export type TIteratorResolve<T extends TSchema, P extends unknown[]> = IterableIterator<Ensure<Static<T, P>>>
 export interface TIterator<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Iterator'
-  static: TIteratorResolve<T, this['params']>
+  static: IterableIterator<Static<T, this['params']>>
   type: 'Iterator'
   items: T
 }
diff --git a/src/value/transform.ts b/src/value/transform.ts
index 281917f18..d0c7daba5 100644
--- a/src/value/transform.ts
+++ b/src/value/transform.ts
@@ -26,9 +26,10 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsString, IsPlainObject, IsArray, IsValueType } from './guard'
+import { IsString, IsPlainObject, IsArray, IsValueType, IsUndefined } from './guard'
 import { ValueError } from '../errors/errors'
 import { Deref } from './deref'
+import { Check } from './check'
 import * as Types from '../typebox'
 
 // -------------------------------------------------------------------------
@@ -112,7 +113,7 @@ export namespace HasTransform {
     return Visit(Deref(schema, references), references)
   }
   function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[]) {
-    return Types.TypeGuard.TTransform(schema) || (Types.TypeGuard.TSchema(schema.items) && schema.items.some((schema) => Visit(schema, references)))
+    return Types.TypeGuard.TTransform(schema) || (!IsUndefined(schema.items) && schema.items.some((schema) => Visit(schema, references)))
   }
   function TUnion(schema: Types.TUnion, references: Types.TSchema[]) {
     return Types.TypeGuard.TTransform(schema) || schema.anyOf.some((schema) => Visit(schema, references))
@@ -262,7 +263,7 @@ export namespace DecodeTransform {
   function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any) {
     const value1 = Default(schema, value)
     for (const subschema of schema.anyOf) {
-      if (!checkFunction(subschema, references, value1)) continue
+      if (!Check(subschema, references, value1)) continue
       return Visit(subschema, references, value1)
     }
     return value1
@@ -323,9 +324,7 @@ export namespace DecodeTransform {
         return Default(schema_, value)
     }
   }
-  let checkFunction: CheckFunction = () => false
-  export function Decode(schema: Types.TSchema, references: Types.TSchema[], value: unknown, check: CheckFunction): unknown {
-    checkFunction = check
+  export function Decode(schema: Types.TSchema, references: Types.TSchema[], value: unknown): unknown {
     return Visit(schema, references, value)
   }
 }
@@ -405,14 +404,14 @@ export namespace EncodeTransform {
   function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any) {
     // test value against union variants
     for (const subschema of schema.anyOf) {
-      if (!checkFunction(subschema, references, value)) continue
+      if (!Check(subschema, references, value)) continue
       const value1 = Visit(subschema, references, value)
       return Default(schema, value1)
     }
     // test transformed value against union variants
     for (const subschema of schema.anyOf) {
       const value1 = Visit(subschema, references, value)
-      if (!checkFunction(schema, references, value1)) continue
+      if (!Check(schema, references, value1)) continue
       return Default(schema, value1)
     }
     return Default(schema, value)
@@ -472,9 +471,7 @@ export namespace EncodeTransform {
         return Default(schema_, value)
     }
   }
-  let checkFunction: CheckFunction = () => false
-  export function Encode(schema: Types.TSchema, references: Types.TSchema[], value: unknown, check: CheckFunction): unknown {
-    checkFunction = check
+  export function Encode(schema: Types.TSchema, references: Types.TSchema[], value: unknown): unknown {
     return Visit(schema, references, value)
   }
 }
diff --git a/src/value/value.ts b/src/value/value.ts
index edeec7dae..9cf27168b 100644
--- a/src/value/value.ts
+++ b/src/value/value.ts
@@ -78,23 +78,23 @@ export namespace Value {
     return ValueClone.Clone(value)
   }
   /** Decodes a value or throws if error */
-  export function Decode<T extends Types.TSchema, D = Types.StaticDecode<T>>(schema: T, references: Types.TSchema[], value: unknown): D
+  export function Decode<T extends Types.TSchema, R = Types.StaticDecode<T>>(schema: T, references: Types.TSchema[], value: unknown): R
   /** Decodes a value or throws if error */
-  export function Decode<T extends Types.TSchema, D = Types.StaticDecode<T>>(schema: T, value: unknown): D
+  export function Decode<T extends Types.TSchema, R = Types.StaticDecode<T>>(schema: T, value: unknown): R
   /** Decodes a value or throws if error */
   export function Decode(...args: any[]) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
     if (!Check(schema, references, value)) throw new ValueTransform.TransformDecodeCheckError(schema, value, Errors(schema, references, value).First()!)
-    return ValueTransform.DecodeTransform.Decode(schema, references, value, ValueCheck.Check)
+    return ValueTransform.DecodeTransform.Decode(schema, references, value)
   }
   /** Encodes a value or throws if error */
-  export function Encode<T extends Types.TSchema, E = Types.StaticEncode<T>>(schema: T, references: Types.TSchema[], value: unknown): E
+  export function Encode<T extends Types.TSchema, R = Types.StaticEncode<T>>(schema: T, references: Types.TSchema[], value: unknown): R
   /** Encodes a value or throws if error */
-  export function Encode<T extends Types.TSchema, E = Types.StaticEncode<T>>(schema: T, value: unknown): E
+  export function Encode<T extends Types.TSchema, R = Types.StaticEncode<T>>(schema: T, value: unknown): R
   /** Encodes a value or throws if error */
   export function Encode(...args: any[]) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
-    const encoded = ValueTransform.EncodeTransform.Encode(schema, references, value, ValueCheck.Check)
+    const encoded = ValueTransform.EncodeTransform.Encode(schema, references, value)
     if (!Check(schema, references, encoded)) throw new ValueTransform.TransformEncodeCheckError(schema, value, Errors(schema, references, value).First()!)
     return encoded
   }
diff --git a/test/runtime/value/transform/_encoder.ts b/test/runtime/value/transform/_encoder.ts
new file mode 100644
index 000000000..8449787e6
--- /dev/null
+++ b/test/runtime/value/transform/_encoder.ts
@@ -0,0 +1,33 @@
+import { IsAsyncIterator, IsIterator, IsFunction, IsSymbol } from '@sinclair/typebox/value/guard'
+import { TSchema, StaticDecode, StaticEncode } from '@sinclair/typebox'
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { Value } from '@sinclair/typebox/value'
+import { Assert } from '../../assert/index'
+
+function AssertSame(actual: unknown, expect: unknown) {
+  if (IsAsyncIterator(actual) && IsAsyncIterator(expect)) return
+  if (IsIterator(actual) && IsIterator(expect)) return
+  if (IsSymbol(actual) && IsSymbol(expect)) return
+  if (IsFunction(actual) && IsFunction(expect)) return
+  Assert.IsEqual(actual, expect)
+}
+
+export function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R
+export function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R
+export function Decode(...args: any[]) {
+  const [schema, references, value] = args.length === 2 ? [args[0], [], args[1]] : [args[0], args[1], args[2]]
+  const value1 = TypeCompiler.Compile(schema as TSchema, references).Decode(value)
+  const value2 = Value.Decode(schema as TSchema, references, value)
+  AssertSame(value1, value2)
+  return value2
+}
+
+export function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, references: TSchema[], value: unknown): R
+export function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, value: unknown): R
+export function Encode(...args: any[]) {
+  const [schema, references, value] = args.length === 2 ? [args[0], [], args[1]] : [args[0], args[1], args[2]]
+  const value1 = TypeCompiler.Compile(schema as TSchema, references).Encode(value)
+  const value2 = Value.Encode(schema as TSchema, references, value)
+  AssertSame(value1, value2)
+  return value2
+}
diff --git a/test/runtime/value/transform/any.ts b/test/runtime/value/transform/any.ts
index 91281c315..a1b27e28c 100644
--- a/test/runtime/value/transform/any.ts
+++ b/test/runtime/value/transform/any.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,11 +11,11 @@ describe('value/transform/Any', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode mapped', () => {
-    const R = Value.Decode(T0, 123)
+    const R = Encoder.Decode(T0, 123)
     Assert.IsEqual(R, 123)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T0, 123)
+    const R = Encoder.Encode(T0, 123)
     Assert.IsEqual(R, 123)
   })
   // --------------------------------------------------------
@@ -24,11 +25,11 @@ describe('value/transform/Any', () => {
     .Decode((value) => 1)
     .Encode((value) => 2)
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, null)
+    const R = Encoder.Decode(T1, null)
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsEqual(R, 2)
   })
 })
diff --git a/test/runtime/value/transform/array.ts b/test/runtime/value/transform/array.ts
index 96afb073e..8f688b2e8 100644
--- a/test/runtime/value/transform/array.ts
+++ b/test/runtime/value/transform/array.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/Array', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode mapped', () => {
-    const R = Value.Decode(T0, [0, 1, 2])
+    const R = Encoder.Decode(T0, [0, 1, 2])
     Assert.IsEqual(R, [0, 1, 2])
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T0, [0, 1, 2])
+    const R = Encoder.Encode(T0, [0, 1, 2])
     Assert.IsEqual(R, [0, 1, 2])
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,15 +28,15 @@ describe('value/transform/Array', () => {
     .Decode((value) => 1)
     .Encode((value) => [0, 1, 2])
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, [])
+    const R = Encoder.Decode(T1, [])
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsEqual(R, [0, 1, 2])
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
   // --------------------------------------------------------
   // Elements
@@ -45,15 +46,15 @@ describe('value/transform/Array', () => {
     .Encode((value) => (value === 'TRUE' ? true : false))
   const T2 = Type.Array(B2)
   it('Should decode elements', () => {
-    const R = Value.Decode(T2, [true, false])
+    const R = Encoder.Decode(T2, [true, false])
     Assert.IsEqual(R, ['TRUE', 'FALSE'])
   })
   it('Should encode elements', () => {
-    const R = Value.Encode(T2, ['TRUE', 'FALSE'])
+    const R = Encoder.Encode(T2, ['TRUE', 'FALSE'])
     Assert.IsEqual(R, [true, false])
   })
   it('Should throw on elements decode', () => {
-    Assert.Throws(() => Value.Decode(T2, null))
+    Assert.Throws(() => Encoder.Decode(T2, null))
   })
   // --------------------------------------------------------
   // Elements Contains (Not Supported)
@@ -65,14 +66,14 @@ describe('value/transform/Array', () => {
     contains: N3,
   })
   it('Should decode contains', () => {
-    const R = Value.Decode(T3, [1, 2, 3])
+    const R = Encoder.Decode(T3, [1, 2, 3])
     Assert.IsEqual(R, [1, 2, 3])
   })
   it('Should throw on contains encode', () => {
-    Assert.Throws(() => Value.Encode(T3, ['hello', 2, 3]))
+    Assert.Throws(() => Encoder.Encode(T3, ['hello', 2, 3]))
   })
   it('Should throw on contains decode', () => {
-    Assert.Throws(() => Value.Decode(T3, null))
+    Assert.Throws(() => Encoder.Decode(T3, null))
   })
   // ------------------------------------------------------------
   // Set
@@ -81,17 +82,17 @@ describe('value/transform/Array', () => {
     .Decode((value) => new Set(value))
     .Encode((value) => [...value])
   it('should decode set', () => {
-    const R = Value.Decode(T4, [1, 1, 2, 3])
+    const R = Encoder.Decode(T4, [1, 1, 2, 3])
     Assert.IsInstanceOf(R, Set)
     Assert.IsTrue(R.has(1))
     Assert.IsTrue(R.has(2))
     Assert.IsTrue(R.has(3))
   })
   it('should encode set', () => {
-    const R = Value.Encode(T4, new Set([1, 2, 3]))
+    const R = Encoder.Encode(T4, new Set([1, 2, 3]))
     Assert.IsEqual(R, [1, 2, 3])
   })
   it('Should throw on set decode', () => {
-    Assert.Throws(() => Value.Decode(T4, {}))
+    Assert.Throws(() => Encoder.Decode(T4, {}))
   })
 })
diff --git a/test/runtime/value/transform/async-iterator.ts b/test/runtime/value/transform/async-iterator.ts
index c418d723f..aed1f3eb3 100644
--- a/test/runtime/value/transform/async-iterator.ts
+++ b/test/runtime/value/transform/async-iterator.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/AsyncIterator', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, (async function* (): any {})())
+    const R = Encoder.Decode(T0, (async function* (): any {})())
     Assert.IsTrue(Symbol.asyncIterator in R)
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, (async function* (): any {})())
+    const R = Encoder.Encode(T0, (async function* (): any {})())
     Assert.IsTrue(Symbol.asyncIterator in R)
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,14 +28,14 @@ describe('value/transform/AsyncIterator', () => {
     .Decode((value) => 1)
     .Encode((value) => (async function* (): any {})())
   it('Should decode', () => {
-    const R = Value.Decode(T1, (async function* (): any {})())
+    const R = Encoder.Decode(T1, (async function* (): any {})())
     Assert.IsEqual(R, 1)
   })
   it('Should encode', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsTrue(Symbol.asyncIterator in R)
   })
   it('Should throw on decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
 })
diff --git a/test/runtime/value/transform/bigint.ts b/test/runtime/value/transform/bigint.ts
index ffc66b058..280af3114 100644
--- a/test/runtime/value/transform/bigint.ts
+++ b/test/runtime/value/transform/bigint.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/BigInt', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, 5n)
+    const R = Encoder.Decode(T0, 5n)
     Assert.IsEqual(R, 5n)
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, 5n)
+    const R = Encoder.Encode(T0, 5n)
     Assert.IsEqual(R, 5n)
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,14 +28,14 @@ describe('value/transform/BigInt', () => {
     .Decode((value) => 1)
     .Encode((value) => 2n)
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, 1n)
+    const R = Encoder.Decode(T1, 1n)
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsEqual(R, 2n)
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
 })
diff --git a/test/runtime/value/transform/boolean.ts b/test/runtime/value/transform/boolean.ts
index 1421a1e8a..ed9c47cee 100644
--- a/test/runtime/value/transform/boolean.ts
+++ b/test/runtime/value/transform/boolean.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/Boolean', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, true)
+    const R = Encoder.Decode(T0, true)
     Assert.IsEqual(R, true)
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, false)
+    const R = Encoder.Encode(T0, false)
     Assert.IsEqual(R, false)
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,14 +28,14 @@ describe('value/transform/Boolean', () => {
     .Decode((value) => 1)
     .Encode((value) => true)
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, true)
+    const R = Encoder.Decode(T1, true)
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsEqual(R, true)
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
 })
diff --git a/test/runtime/value/transform/constructor.ts b/test/runtime/value/transform/constructor.ts
index 0cfe28d43..67ae9d19a 100644
--- a/test/runtime/value/transform/constructor.ts
+++ b/test/runtime/value/transform/constructor.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/Constructor', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, class {})
+    const R = Encoder.Decode(T0, class {})
     Assert.IsTypeOf(R, 'function')
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, class {})
+    const R = Encoder.Encode(T0, class {})
     Assert.IsTypeOf(R, 'function')
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,14 +28,14 @@ describe('value/transform/Constructor', () => {
     .Decode((value) => 1)
     .Encode((value) => class {})
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, class {})
+    const R = Encoder.Decode(T1, class {})
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsTypeOf(R, 'function')
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
 })
diff --git a/test/runtime/value/transform/date.ts b/test/runtime/value/transform/date.ts
index 1d83713e0..bc7fec5f5 100644
--- a/test/runtime/value/transform/date.ts
+++ b/test/runtime/value/transform/date.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/Date', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, new Date(123))
+    const R = Encoder.Decode(T0, new Date(123))
     Assert.IsEqual(R, new Date(123))
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, new Date(123))
+    const R = Encoder.Encode(T0, new Date(123))
     Assert.IsEqual(R, new Date(123))
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,14 +28,14 @@ describe('value/transform/Date', () => {
     .Decode((value) => 1)
     .Encode((value) => new Date())
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, new Date())
+    const R = Encoder.Decode(T1, new Date())
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsInstanceOf(R, Date)
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
 })
diff --git a/test/runtime/value/transform/enum.ts b/test/runtime/value/transform/enum.ts
index 1df8f7793..b681ae33b 100644
--- a/test/runtime/value/transform/enum.ts
+++ b/test/runtime/value/transform/enum.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -15,15 +16,15 @@ describe('value/transform/Enum', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, E.A)
+    const R = Encoder.Decode(T0, E.A)
     Assert.IsEqual(R, E.A)
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, E.A)
+    const R = Encoder.Encode(T0, E.A)
     Assert.IsEqual(R, E.A)
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -32,14 +33,14 @@ describe('value/transform/Enum', () => {
     .Decode((value) => 1)
     .Encode((value) => E.A)
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, E.A)
+    const R = Encoder.Decode(T1, E.A)
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsEqual(R, E.A)
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
 })
diff --git a/test/runtime/value/transform/function.ts b/test/runtime/value/transform/function.ts
index 5d94b8d72..4bd89abc6 100644
--- a/test/runtime/value/transform/function.ts
+++ b/test/runtime/value/transform/function.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/Function', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, class {})
+    const R = Encoder.Decode(T0, class {})
     Assert.IsTypeOf(R, 'function')
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, class {})
+    const R = Encoder.Encode(T0, class {})
     Assert.IsTypeOf(R, 'function')
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,14 +28,14 @@ describe('value/transform/Function', () => {
     .Decode((value) => 1)
     .Encode((value) => function () {})
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, function () {})
+    const R = Encoder.Decode(T1, function () {})
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsTypeOf(R, 'function')
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
 })
diff --git a/test/runtime/value/transform/integer.ts b/test/runtime/value/transform/integer.ts
index 2f91f3f35..099439aff 100644
--- a/test/runtime/value/transform/integer.ts
+++ b/test/runtime/value/transform/integer.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/Integer', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, 42)
+    const R = Encoder.Decode(T0, 42)
     Assert.IsEqual(R, 42)
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, 42)
+    const R = Encoder.Encode(T0, 42)
     Assert.IsEqual(R, 42)
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,14 +28,14 @@ describe('value/transform/Integer', () => {
     .Decode((value) => 1)
     .Encode((value) => 2)
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, 1)
+    const R = Encoder.Decode(T1, 1)
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsEqual(R, 2)
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
 })
diff --git a/test/runtime/value/transform/intersect.ts b/test/runtime/value/transform/intersect.ts
index 342f93abe..0d7f39043 100644
--- a/test/runtime/value/transform/intersect.ts
+++ b/test/runtime/value/transform/intersect.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -14,15 +15,15 @@ describe('value/transform/Intersect', () => {
   .Decode(value => value)
   .Encode(value => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, { x: 1, y: 2 })
+    const R = Encoder.Decode(T0, { x: 1, y: 2 })
     Assert.IsEqual(R, { x: 1, y: 2 })
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, { x: 1, y: 2 })
+    const R = Encoder.Encode(T0, { x: 1, y: 2 })
     Assert.IsEqual(R, { x: 1, y: 2 })
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -35,15 +36,15 @@ describe('value/transform/Intersect', () => {
   .Decode((value) => 1)
   .Encode((value) => ({ x: 1, y: 2 }))
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, { x: 1, y: 2 })
+    const R = Encoder.Decode(T1, { x: 1, y: 2 })
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsEqual(R, { x: 1, y: 2 })
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
   // --------------------------------------------------------
   // Mapped Property
@@ -59,15 +60,15 @@ describe('value/transform/Intersect', () => {
   .Decode((value) => value)
   .Encode((value) => value)
   it('Should decode property', () => {
-    const R = Value.Decode(T2, { x: 1, y: 2 })
+    const R = Encoder.Decode(T2, { x: 1, y: 2 })
     Assert.IsEqual(R, { x: 1, y: '2' })
   })
   it('Should encode property', () => {
-    const R = Value.Encode(T2, { x: 1, y: '2' })
+    const R = Encoder.Encode(T2, { x: 1, y: '2' })
     Assert.IsEqual(R, { x: 1, y: 2 })
   })
   it('Should throw on property decode', () => {
-    Assert.Throws(() => Value.Decode(T2, null))
+    Assert.Throws(() => Encoder.Decode(T2, null))
   })
   // --------------------------------------------------------
   // Unevaluated Property
@@ -83,15 +84,15 @@ describe('value/transform/Intersect', () => {
     unevaluatedProperties: N3
   })
   it('Should decode unevaluated property', () => {
-    const R = Value.Decode(T3, { x: 1, y: 2, z: 3 })
+    const R = Encoder.Decode(T3, { x: 1, y: 2, z: 3 })
     Assert.IsEqual(R, { x: 1, y: 2, z: '3' })
   })
   it('Should encode unevaluated property', () => {
-    const R = Value.Encode(T3, { x: 1, y: 2, z: '3' })
+    const R = Encoder.Encode(T3, { x: 1, y: 2, z: '3' })
     Assert.IsEqual(R, { x: 1, y: 2, z: 3 })
   })
   it('Should throw on unevaluated property decode', () => {
-    Assert.Throws(() => Value.Decode(T3, null))
+    Assert.Throws(() => Encoder.Decode(T3, null))
   })
   // --------------------------------------------------------
   // Transform Intersection Interior (Not Supported)
@@ -109,14 +110,14 @@ describe('value/transform/Intersect', () => {
     .Decode((value) => value + 1)
     .Encode((value) => value - 1)
   it('Should decode exterior value type', () => {
-    const R = Value.Decode(T4, 1)
+    const R = Encoder.Decode(T4, 1)
     Assert.IsEqual(R, 2)
   })
   it('Should encode exterior value type', () => {
-    const R = Value.Encode(T4, 2)
+    const R = Encoder.Encode(T4, 2)
     Assert.IsEqual(R, 1)
   })
   it('Should throw on exterior value type decode', () => {
-    Assert.Throws(() => Value.Decode(T4, null))
+    Assert.Throws(() => Encoder.Decode(T4, null))
   })
 })
diff --git a/test/runtime/value/transform/iterator.ts b/test/runtime/value/transform/iterator.ts
index 90bc03773..66188acf1 100644
--- a/test/runtime/value/transform/iterator.ts
+++ b/test/runtime/value/transform/iterator.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/Iterator', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, (function* (): any {})())
+    const R = Encoder.Decode(T0, (function* (): any {})())
     Assert.IsTrue(Symbol.iterator in R)
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, (function* (): any {})())
+    const R = Encoder.Encode(T0, (function* (): any {})())
     Assert.IsTrue(Symbol.iterator in R)
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,14 +28,14 @@ describe('value/transform/Iterator', () => {
     .Decode((value) => 1)
     .Encode((value) => (function* (): any {})())
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, (function* (): any {})())
+    const R = Encoder.Decode(T1, (function* (): any {})())
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsTrue(Symbol.iterator in R)
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
 })
diff --git a/test/runtime/value/transform/literal.ts b/test/runtime/value/transform/literal.ts
index 9e0f9e41c..ef88502bb 100644
--- a/test/runtime/value/transform/literal.ts
+++ b/test/runtime/value/transform/literal.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,11 +11,11 @@ describe('value/transform/Literal', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode mapped', () => {
-    const R = Value.Decode(T0, 123)
+    const R = Encoder.Decode(T0, 123)
     Assert.IsEqual(R, 123)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T0, 123)
+    const R = Encoder.Encode(T0, 123)
     Assert.IsEqual(R, 123)
   })
   // -----------------------------------------------
@@ -24,15 +25,15 @@ describe('value/transform/Literal', () => {
     .Decode((value) => 1)
     .Encode((value) => 'hello' as const)
   it('Should decode literal string', () => {
-    const R = Value.Decode(T1, 'hello')
+    const R = Encoder.Decode(T1, 'hello')
     Assert.IsEqual(R, 1)
   })
   it('Should encode literal string', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsEqual(R, 'hello')
   })
   it('Should throw on decode literal string', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
   // -----------------------------------------------
   // LiteralNumber
@@ -41,15 +42,15 @@ describe('value/transform/Literal', () => {
     .Decode((value) => 1)
     .Encode((value) => 2 as const)
   it('Should decode literal number', () => {
-    const R = Value.Decode(T2, 2)
+    const R = Encoder.Decode(T2, 2)
     Assert.IsEqual(R, 1)
   })
   it('Should encode literal number', () => {
-    const R = Value.Encode(T2, null)
+    const R = Encoder.Encode(T2, null)
     Assert.IsEqual(R, 2)
   })
   it('Should throw on decode literal number', () => {
-    Assert.Throws(() => Value.Decode(T2, null))
+    Assert.Throws(() => Encoder.Decode(T2, null))
   })
   // -----------------------------------------------
   // LiteralBoolean
@@ -58,14 +59,14 @@ describe('value/transform/Literal', () => {
     .Decode((value) => 1)
     .Encode((value) => true as const)
   it('Should decode literal boolean', () => {
-    const R = Value.Decode(T3, true)
+    const R = Encoder.Decode(T3, true)
     Assert.IsEqual(R, 1)
   })
   it('Should encode literal boolean', () => {
-    const R = Value.Encode(T3, null)
+    const R = Encoder.Encode(T3, null)
     Assert.IsEqual(R, true)
   })
   it('Should throw on decode literal boolean', () => {
-    Assert.Throws(() => Value.Decode(T3, null))
+    Assert.Throws(() => Encoder.Decode(T3, null))
   })
 })
diff --git a/test/runtime/value/transform/never.ts b/test/runtime/value/transform/never.ts
index 3a5414821..97e03478a 100644
--- a/test/runtime/value/transform/never.ts
+++ b/test/runtime/value/transform/never.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -11,10 +12,10 @@ describe('value/transform/Never', () => {
     // @ts-ignore
     .Encode((value) => value)
   it('Should throw on identity encode', () => {
-    Assert.Throws(() => Value.Encode(T0, undefined))
+    Assert.Throws(() => Encoder.Encode(T0, undefined))
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, undefined))
+    Assert.Throws(() => Encoder.Decode(T0, undefined))
   })
   // --------------------------------------------------------
   // Mapped
@@ -25,9 +26,9 @@ describe('value/transform/Never', () => {
     // @ts-ignore
     .Encode((value) => 1)
   it('Should throw on mapped encode', () => {
-    Assert.Throws(() => Value.Encode(T1, undefined))
+    Assert.Throws(() => Encoder.Encode(T1, undefined))
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, undefined))
+    Assert.Throws(() => Encoder.Decode(T1, undefined))
   })
 })
diff --git a/test/runtime/value/transform/not.ts b/test/runtime/value/transform/not.ts
index 97277223e..68387ee58 100644
--- a/test/runtime/value/transform/not.ts
+++ b/test/runtime/value/transform/not.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/Not', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, 1)
+    const R = Encoder.Decode(T0, 1)
     Assert.IsEqual(R, 1)
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, 1)
+    const R = Encoder.Encode(T0, 1)
     Assert.IsEqual(R, 1)
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, ''))
+    Assert.Throws(() => Encoder.Decode(T0, ''))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,14 +28,14 @@ describe('value/transform/Not', () => {
     .Decode((value) => 1)
     .Encode((value) => 2)
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, null)
+    const R = Encoder.Decode(T1, null)
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsEqual(R, 2)
   })
   it('Should throw on decode not', () => {
-    Assert.Throws(() => Value.Decode(T1, 'hello'))
+    Assert.Throws(() => Encoder.Decode(T1, 'hello'))
   })
 })
diff --git a/test/runtime/value/transform/null.ts b/test/runtime/value/transform/null.ts
index a113d1566..0cf90dc05 100644
--- a/test/runtime/value/transform/null.ts
+++ b/test/runtime/value/transform/null.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/Null', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, null)
+    const R = Encoder.Decode(T0, null)
     Assert.IsEqual(R, null)
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, null)
+    const R = Encoder.Encode(T0, null)
     Assert.IsEqual(R, null)
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, undefined))
+    Assert.Throws(() => Encoder.Decode(T0, undefined))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,14 +28,14 @@ describe('value/transform/Null', () => {
     .Decode((value) => 1)
     .Encode((value) => null)
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, null)
+    const R = Encoder.Decode(T1, null)
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, 123)
+    const R = Encoder.Encode(T1, 123)
     Assert.IsEqual(R, null)
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, undefined))
+    Assert.Throws(() => Encoder.Decode(T1, undefined))
   })
 })
diff --git a/test/runtime/value/transform/number.ts b/test/runtime/value/transform/number.ts
index dcd9328c7..2f06b50ff 100644
--- a/test/runtime/value/transform/number.ts
+++ b/test/runtime/value/transform/number.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/Number', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, 42)
+    const R = Encoder.Decode(T0, 42)
     Assert.IsEqual(R, 42)
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, 42)
+    const R = Encoder.Encode(T0, 42)
     Assert.IsEqual(R, 42)
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,14 +28,14 @@ describe('value/transform/Number', () => {
     .Decode((value) => value + 1)
     .Encode((value) => value - 1)
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, 1)
+    const R = Encoder.Decode(T1, 1)
     Assert.IsEqual(R, 2)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, 2)
+    const R = Encoder.Encode(T1, 2)
     Assert.IsEqual(R, 1)
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, undefined))
+    Assert.Throws(() => Encoder.Decode(T1, undefined))
   })
 })
diff --git a/test/runtime/value/transform/object.ts b/test/runtime/value/transform/object.ts
index 2c3c0b423..0a73a998e 100644
--- a/test/runtime/value/transform/object.ts
+++ b/test/runtime/value/transform/object.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -15,15 +16,15 @@ describe('value/transform/Object', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, { x: 1, y: 2 })
+    const R = Encoder.Decode(T0, { x: 1, y: 2 })
     Assert.IsEqual(R, { x: 1, y: 2 })
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, { x: 1, y: 2 })
+    const R = Encoder.Encode(T0, { x: 1, y: 2 })
     Assert.IsEqual(R, { x: 1, y: 2 })
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, undefined))
+    Assert.Throws(() => Encoder.Decode(T0, undefined))
   })
   // ----------------------------------------------------------
   // Object
@@ -37,15 +38,15 @@ describe('value/transform/Object', () => {
     .Decode((value) => 42)
     .Encode((value) => ({ x: 1, y: 2 }))
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, { x: 1, y: 2 })
+    const R = Encoder.Decode(T1, { x: 1, y: 2 })
     Assert.IsEqual(R, 42)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsEqual(R, { x: 1, y: 2 })
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, undefined))
+    Assert.Throws(() => Encoder.Decode(T1, undefined))
   })
   // ----------------------------------------------------------
   // Object: Transform Property
@@ -58,15 +59,15 @@ describe('value/transform/Object', () => {
     y: N2,
   })
   it('Should decode transform property', () => {
-    const R = Value.Decode(T2, { x: 1, y: 2 })
+    const R = Encoder.Decode(T2, { x: 1, y: 2 })
     Assert.IsEqual(R, { x: '1', y: '2' })
   })
   it('Should encode transform property', () => {
-    const R = Value.Encode(T2, { x: '1', y: '2' })
+    const R = Encoder.Encode(T2, { x: '1', y: '2' })
     Assert.IsEqual(R, { x: 1, y: 2 })
   })
   it('Should throw on decode transform property', () => {
-    Assert.Throws(() => Value.Decode(T2, undefined))
+    Assert.Throws(() => Encoder.Decode(T2, undefined))
   })
   // ----------------------------------------------------------
   // Object: Transform Property Nested (Twizzle)
@@ -83,15 +84,15 @@ describe('value/transform/Object', () => {
     .Decode((value) => ({ x: value.y, y: value.x }))
     .Encode((value) => ({ x: value.y, y: value.x }))
   it('Should decode transform property nested', () => {
-    const R = Value.Decode(T3, { x: 1, y: 2 })
+    const R = Encoder.Decode(T3, { x: 1, y: 2 })
     Assert.IsEqual(R, { x: '2', y: '1' })
   })
   it('Should encode transform property nested', () => {
-    const R = Value.Encode(T3, { x: '1', y: '2' })
+    const R = Encoder.Encode(T3, { x: '1', y: '2' })
     Assert.IsEqual(R, { x: 2, y: 1 })
   })
   it('Should throw on decode transform property nested', () => {
-    Assert.Throws(() => Value.Decode(T3, undefined))
+    Assert.Throws(() => Encoder.Decode(T3, undefined))
   })
   // ----------------------------------------------------------
   // Object Additional Properties
@@ -112,18 +113,18 @@ describe('value/transform/Object', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode additional property', () => {
-    const R = Value.Decode(T4, { x: 1, y: 2 })
+    const R = Encoder.Decode(T4, { x: 1, y: 2 })
     Assert.IsEqual(R, { x: 1, y: '2' })
   })
   it('Should encode additional property', () => {
-    const R = Value.Encode(T4, { x: 1, y: '5' })
+    const R = Encoder.Encode(T4, { x: 1, y: '5' })
     Assert.IsEqual(R, { x: 1, y: 5 })
   })
   it('Should throw on additional property 1', () => {
-    Assert.Throws(() => Value.Decode(T4, undefined))
+    Assert.Throws(() => Encoder.Decode(T4, undefined))
   })
   it('Should throw on additional property 2', () => {
-    Assert.Throws(() => Value.Decode(T4, { x: 1, y: true }))
+    Assert.Throws(() => Encoder.Decode(T4, { x: 1, y: true }))
   })
   // ------------------------------------------------------------
   // Map
@@ -132,13 +133,13 @@ describe('value/transform/Object', () => {
     .Decode((value) => new Map(Object.entries(value)))
     .Encode((value) => Object.fromEntries(value.entries()) as any)
   it('should decode map', () => {
-    const R = Value.Decode(T5, { x: 'hello', y: 'world' })
+    const R = Encoder.Decode(T5, { x: 'hello', y: 'world' })
     Assert.IsInstanceOf(R, Map)
     Assert.IsEqual(R.get('x'), 'hello')
     Assert.IsEqual(R.get('y'), 'world')
   })
   it('should encode map', () => {
-    const R = Value.Encode(
+    const R = Encoder.Encode(
       T5,
       new Map([
         ['x', 'hello'],
@@ -148,6 +149,6 @@ describe('value/transform/Object', () => {
     Assert.IsEqual(R, { x: 'hello', y: 'world' })
   })
   it('Should throw on map decode', () => {
-    Assert.Throws(() => Value.Decode(T5, {}))
+    Assert.Throws(() => Encoder.Decode(T5, {}))
   })
 })
diff --git a/test/runtime/value/transform/promise.ts b/test/runtime/value/transform/promise.ts
index 9a4f33c45..991bf5822 100644
--- a/test/runtime/value/transform/promise.ts
+++ b/test/runtime/value/transform/promise.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/Promise', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, Promise.resolve(1))
+    const R = Encoder.Decode(T0, Promise.resolve(1))
     Assert.IsTrue(R instanceof Promise)
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, Promise.resolve(1))
+    const R = Encoder.Encode(T0, Promise.resolve(1))
     Assert.IsTrue(R instanceof Promise)
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, undefined))
+    Assert.Throws(() => Encoder.Decode(T0, undefined))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,14 +28,14 @@ describe('value/transform/Promise', () => {
     .Decode((value) => 1)
     .Encode((value) => Promise.resolve(1))
   it('Should decode mapped', () => {
-    const R = Value.Decode(T, Promise.resolve(1))
+    const R = Encoder.Decode(T, Promise.resolve(1))
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T, null)
+    const R = Encoder.Encode(T, null)
     Assert.IsTrue(R instanceof Promise)
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T, null))
+    Assert.Throws(() => Encoder.Decode(T, null))
   })
 })
diff --git a/test/runtime/value/transform/record.ts b/test/runtime/value/transform/record.ts
index 2b2bc3d82..a91172dbf 100644
--- a/test/runtime/value/transform/record.ts
+++ b/test/runtime/value/transform/record.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,7 +11,7 @@ describe('value/transform/Record', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, {
+    const R = Encoder.Decode(T0, {
       a: true,
       b: false,
     })
@@ -20,7 +21,7 @@ describe('value/transform/Record', () => {
     })
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, {
+    const R = Encoder.Encode(T0, {
       a: true,
       b: false,
     })
@@ -30,7 +31,7 @@ describe('value/transform/Record', () => {
     })
   })
   it('Should throw on identity', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // ------------------------------------------------------------
   // Additional Properties True
@@ -40,7 +41,7 @@ describe('value/transform/Record', () => {
     .Encode((value) => parseFloat(value.replace(/number-/g, '')))
   const T1 = Type.Record(Type.Number(), N1)
   it('Should decode additional properties allowed', () => {
-    const R = Value.Decode(T1, {
+    const R = Encoder.Decode(T1, {
       0: 1,
       a: true,
     })
@@ -50,7 +51,7 @@ describe('value/transform/Record', () => {
     })
   })
   it('Should encode additional properties allowed', () => {
-    const R = Value.Encode(T1, {
+    const R = Encoder.Encode(T1, {
       0: 'number-1',
       a: true,
     })
@@ -60,7 +61,7 @@ describe('value/transform/Record', () => {
     })
   })
   it('Should throw on additional properties allowed', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
   // ------------------------------------------------------------
   // Complex Transform
@@ -73,7 +74,7 @@ describe('value/transform/Record', () => {
     .Encode((value) => (value === 'TRUE' ? true : false))
   const T3 = Type.Record(Type.Number(), N2, { additionalProperties: B2 })
   it('Should decode complex', () => {
-    const R = Value.Decode(T3, {
+    const R = Encoder.Decode(T3, {
       0: 1,
       a: true,
     })
@@ -83,7 +84,7 @@ describe('value/transform/Record', () => {
     })
   })
   it('Should encode complex', () => {
-    const R = Value.Encode(T3, {
+    const R = Encoder.Encode(T3, {
       0: 'number-1',
       a: 'TRUE',
     })
@@ -93,7 +94,7 @@ describe('value/transform/Record', () => {
     })
   })
   it('Should throw on complex decode', () => {
-    Assert.Throws(() => Value.Decode(T3, null))
+    Assert.Throws(() => Encoder.Decode(T3, null))
   })
   // ------------------------------------------------------------
   // Map
@@ -102,13 +103,13 @@ describe('value/transform/Record', () => {
     .Decode((value) => new Map(Object.entries(value)))
     .Encode((value) => Object.fromEntries(value.entries()))
   it('should decode map', () => {
-    const R = Value.Decode(T4, { x: 'hello', y: 'world' })
+    const R = Encoder.Decode(T4, { x: 'hello', y: 'world' })
     Assert.IsInstanceOf(R, Map)
     Assert.IsEqual(R.get('x'), 'hello')
     Assert.IsEqual(R.get('y'), 'world')
   })
   it('should encode map', () => {
-    const R = Value.Encode(
+    const R = Encoder.Encode(
       T4,
       new Map([
         ['x', 'hello'],
@@ -118,6 +119,6 @@ describe('value/transform/Record', () => {
     Assert.IsEqual(R, { x: 'hello', y: 'world' })
   })
   it('Should throw on map decode', () => {
-    Assert.Throws(() => Value.Decode(T4, null))
+    Assert.Throws(() => Encoder.Decode(T4, null))
   })
 })
diff --git a/test/runtime/value/transform/recursive.ts b/test/runtime/value/transform/recursive.ts
index 2b22d42e1..abea62630 100644
--- a/test/runtime/value/transform/recursive.ts
+++ b/test/runtime/value/transform/recursive.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -17,7 +18,7 @@ describe('value/transform/Recursive', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, {
+    const R = Encoder.Decode(T0, {
       value: 1,
       nodes: [
         { value: 2, nodes: [] },
@@ -33,7 +34,7 @@ describe('value/transform/Recursive', () => {
     })
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, {
+    const R = Encoder.Encode(T0, {
       value: 1,
       nodes: [
         { value: 2, nodes: [] },
@@ -49,7 +50,7 @@ describe('value/transform/Recursive', () => {
     })
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, undefined))
+    Assert.Throws(() => Encoder.Decode(T0, undefined))
   })
   // -----------------------------------------------
   // Mapped
@@ -65,7 +66,7 @@ describe('value/transform/Recursive', () => {
     .Decode((value) => 1)
     .Encode((value) => ({ value: 1, nodes: [] }))
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, {
+    const R = Encoder.Decode(T1, {
       value: 1,
       nodes: [
         { value: 2, nodes: [] },
@@ -75,11 +76,11 @@ describe('value/transform/Recursive', () => {
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsEqual(R, { value: 1, nodes: [] })
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
   // -----------------------------------------------
   // Recursive Property Remap
@@ -94,7 +95,7 @@ describe('value/transform/Recursive', () => {
     }),
   )
   it('Should decode property', () => {
-    const R = Value.Decode(T2, {
+    const R = Encoder.Decode(T2, {
       value: 1,
       nodes: [
         { value: 2, nodes: [] },
@@ -110,7 +111,7 @@ describe('value/transform/Recursive', () => {
     })
   })
   it('Should encode property', () => {
-    const R = Value.Encode(T2, {
+    const R = Encoder.Encode(T2, {
       value: new Date(1),
       nodes: [
         { value: new Date(2), nodes: [] },
@@ -126,6 +127,6 @@ describe('value/transform/Recursive', () => {
     })
   })
   it('Should throw on decode property', () => {
-    Assert.Throws(() => Value.Decode(T2, null))
+    Assert.Throws(() => Encoder.Decode(T2, null))
   })
 })
diff --git a/test/runtime/value/transform/ref.ts b/test/runtime/value/transform/ref.ts
index 20385f9bb..92d252c29 100644
--- a/test/runtime/value/transform/ref.ts
+++ b/test/runtime/value/transform/ref.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -11,15 +12,15 @@ describe('value/transform/Ref', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode mapped', () => {
-    const R = Value.Decode(T0, [N0], 0)
+    const R = Encoder.Decode(T0, [N0], 0)
     Assert.IsEqual(R, 0)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T0, [N0], 0)
+    const R = Encoder.Encode(T0, [N0], 0)
     Assert.IsEqual(R, 0)
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -29,15 +30,15 @@ describe('value/transform/Ref', () => {
     .Decode((value) => value + 1)
     .Encode((value) => value - 1)
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, [N1], 0)
+    const R = Encoder.Decode(T1, [N1], 0)
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, [N1], 1)
+    const R = Encoder.Encode(T1, [N1], 1)
     Assert.IsEqual(R, 0)
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
   // --------------------------------------------------------
   // Mapped Remote
@@ -49,14 +50,14 @@ describe('value/transform/Ref', () => {
     .Decode((value) => value + 1)
     .Encode((value) => value - 1)
   it('Should decode mapped remote', () => {
-    const R = Value.Decode(T2, [N2], 0)
+    const R = Encoder.Decode(T2, [N2], 0)
     Assert.IsEqual(R, 2)
   })
   it('Should encode mapped remote', () => {
-    const R = Value.Encode(T2, [N2], 2)
+    const R = Encoder.Encode(T2, [N2], 2)
     Assert.IsEqual(R, 0)
   })
   it('Should throw on mapped remote decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
 })
diff --git a/test/runtime/value/transform/string.ts b/test/runtime/value/transform/string.ts
index 6c15c074f..3419c8691 100644
--- a/test/runtime/value/transform/string.ts
+++ b/test/runtime/value/transform/string.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -6,20 +7,20 @@ describe('value/transform/String', () => {
   // --------------------------------------------------------
   // Identity
   // --------------------------------------------------------
-  const T0 = Type.Transform(Type.String())
-    .Decode((value) => value)
-    .Encode((value) => value)
-  it('Should decode identity', () => {
-    const R = Value.Decode(T0, 'hello')
-    Assert.IsEqual(R, 'hello')
-  })
-  it('Should encode identity', () => {
-    const R = Value.Encode(T0, 'hello')
-    Assert.IsEqual(R, 'hello')
-  })
-  it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
-  })
+  // const T0 = Type.Transform(Type.String())
+  //   .Decode((value) => value)
+  //   .Encode((value) => value)
+  // it('Should decode identity', () => {
+  //   const R = Encoder.Decode(T0, 'hello')
+  //   Assert.IsEqual(R, 'hello')
+  // })
+  // it('Should encode identity', () => {
+  //   const R = Encoder.Encode(T0, 'hello')
+  //   Assert.IsEqual(R, 'hello')
+  // })
+  // it('Should throw on identity decode', () => {
+  //   Assert.Throws(() => Encoder.Decode(T0, null))
+  // })
   // --------------------------------------------------------
   // Mapped
   // --------------------------------------------------------
@@ -27,14 +28,14 @@ describe('value/transform/String', () => {
     .Decode((value) => value.split('').reverse().join(''))
     .Encode((value) => value.split('').reverse().join(''))
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, 'ABC')
+    const R = Encoder.Decode(T1, 'ABC')
     Assert.IsEqual(R, 'CBA')
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, 'CBA')
+    const R = Encoder.Encode(T1, 'CBA')
     Assert.IsEqual(R, 'ABC')
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
 })
diff --git a/test/runtime/value/transform/symbol.ts b/test/runtime/value/transform/symbol.ts
index 5dfca318d..a04a9d661 100644
--- a/test/runtime/value/transform/symbol.ts
+++ b/test/runtime/value/transform/symbol.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/String', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, Symbol('hello'))
+    const R = Encoder.Decode(T0, Symbol('hello'))
     Assert.IsEqual(R.description, 'hello')
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, Symbol('hello'))
+    const R = Encoder.Encode(T0, Symbol('hello'))
     Assert.IsEqual(R.description, 'hello')
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,14 +28,14 @@ describe('value/transform/String', () => {
     .Decode((value) => Symbol(value.description?.split('').reverse().join('')))
     .Encode((value) => Symbol(value.description?.split('').reverse().join('')))
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, Symbol('ABC'))
+    const R = Encoder.Decode(T1, Symbol('ABC'))
     Assert.IsEqual(R.description, 'CBA')
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, Symbol('CBA'))
+    const R = Encoder.Encode(T1, Symbol('CBA'))
     Assert.IsEqual(R.description, 'ABC')
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
 })
diff --git a/test/runtime/value/transform/template-literal.ts b/test/runtime/value/transform/template-literal.ts
index 174abaa2b..3c8130a04 100644
--- a/test/runtime/value/transform/template-literal.ts
+++ b/test/runtime/value/transform/template-literal.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/TemplateLiteral', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, 'hello')
+    const R = Encoder.Decode(T0, 'hello')
     Assert.IsEqual(R, 'hello')
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, 'hello')
+    const R = Encoder.Encode(T0, 'hello')
     Assert.IsEqual(R, 'hello')
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,14 +28,14 @@ describe('value/transform/TemplateLiteral', () => {
     .Decode((value) => value.split('').reverse().join('') as 'CBA')
     .Encode((value) => value.split('').reverse().join('') as 'ABC')
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, 'ABC')
+    const R = Encoder.Decode(T1, 'ABC')
     Assert.IsEqual(R, 'CBA')
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, 'CBA')
+    const R = Encoder.Encode(T1, 'CBA')
     Assert.IsEqual(R, 'ABC')
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
 })
diff --git a/test/runtime/value/transform/tuple.ts b/test/runtime/value/transform/tuple.ts
index cf6b9d51f..4b48377bc 100644
--- a/test/runtime/value/transform/tuple.ts
+++ b/test/runtime/value/transform/tuple.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/Tuple', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, [1, 2])
+    const R = Encoder.Decode(T0, [1, 2])
     Assert.IsEqual(R, [1, 2])
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, [1, 2])
+    const R = Encoder.Encode(T0, [1, 2])
     Assert.IsEqual(R, [1, 2])
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,15 +28,15 @@ describe('value/transform/Tuple', () => {
     .Decode((value) => [value[0] + 1] as [number])
     .Encode((value) => [value[0] - 1] as [number])
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, [0])
+    const R = Encoder.Decode(T1, [0])
     Assert.IsEqual(R, [1])
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, [1])
+    const R = Encoder.Encode(T1, [1])
     Assert.IsEqual(R, [0])
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
   // --------------------------------------------------------
   // Mapped Element
@@ -47,15 +48,15 @@ describe('value/transform/Tuple', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode mapped element', () => {
-    const R = Value.Decode(T2, [0])
+    const R = Encoder.Decode(T2, [0])
     Assert.IsEqual(R, [1])
   })
   it('Should encode mapped element', () => {
-    const R = Value.Encode(T2, [1])
+    const R = Encoder.Encode(T2, [1])
     Assert.IsEqual(R, [0])
   })
   it('Should throw on mapped element decode', () => {
-    Assert.Throws(() => Value.Decode(T2, null))
+    Assert.Throws(() => Encoder.Decode(T2, null))
   })
   // --------------------------------------------------------
   // Mapped Element
@@ -67,15 +68,15 @@ describe('value/transform/Tuple', () => {
     .Decode((value) => [value[0].toString()])
     .Encode((value) => [parseFloat(value[0])] as [number])
   it('Should decode mapped element', () => {
-    const R = Value.Decode(T3, [0])
+    const R = Encoder.Decode(T3, [0])
     Assert.IsEqual(R, ['1'])
   })
   it('Should encode mapped element', () => {
-    const R = Value.Encode(T3, ['1'])
+    const R = Encoder.Encode(T3, ['1'])
     Assert.IsEqual(R, [0])
   })
   it('Should throw on mapped element decode', () => {
-    Assert.Throws(() => Value.Decode(T3, null))
+    Assert.Throws(() => Encoder.Decode(T3, null))
   })
   // ------------------------------------------------------------
   // Set
@@ -84,15 +85,15 @@ describe('value/transform/Tuple', () => {
     .Decode((value) => new Set(value))
     .Encode((value) => [...value] as any)
   it('should decode set', () => {
-    const R = Value.Decode(T4, [1])
+    const R = Encoder.Decode(T4, [1])
     Assert.IsInstanceOf(R, Set)
     Assert.IsTrue(R.has(1))
   })
   it('should encode set', () => {
-    const R = Value.Encode(T4, new Set([1]))
+    const R = Encoder.Encode(T4, new Set([1]))
     Assert.IsEqual(R, [1])
   })
   it('Should throw on set decode', () => {
-    Assert.Throws(() => Value.Decode(T4, {}))
+    Assert.Throws(() => Encoder.Decode(T4, {}))
   })
 })
diff --git a/test/runtime/value/transform/undefined.ts b/test/runtime/value/transform/undefined.ts
index 7f8582a9e..60c5a4c01 100644
--- a/test/runtime/value/transform/undefined.ts
+++ b/test/runtime/value/transform/undefined.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,15 +11,15 @@ describe('value/transform/Undefined', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, undefined)
+    const R = Encoder.Decode(T0, undefined)
     Assert.IsEqual(R, undefined)
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, undefined)
+    const R = Encoder.Encode(T0, undefined)
     Assert.IsEqual(R, undefined)
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -27,14 +28,14 @@ describe('value/transform/Undefined', () => {
     .Decode((value) => null)
     .Encode((value) => undefined)
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, undefined)
+    const R = Encoder.Decode(T1, undefined)
     Assert.IsEqual(R, null)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsEqual(R, undefined)
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
 })
diff --git a/test/runtime/value/transform/union.ts b/test/runtime/value/transform/union.ts
index d1a9cebc5..93eeff81c 100644
--- a/test/runtime/value/transform/union.ts
+++ b/test/runtime/value/transform/union.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type, TSchema } from '@sinclair/typebox'
@@ -14,15 +15,15 @@ describe('value/transform/Union', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, { x: 1 })
+    const R = Encoder.Decode(T0, { x: 1 })
     Assert.IsEqual(R, { x: 1 })
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, { y: 2 })
+    const R = Encoder.Encode(T0, { y: 2 })
     Assert.IsEqual(R, { y: 2 })
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -35,15 +36,15 @@ describe('value/transform/Union', () => {
     .Decode((value) => 'test' as const)
     .Encode((value) => ({ type: 'hello' as const }))
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, { type: 'hello' })
+    const R = Encoder.Decode(T1, { type: 'hello' })
     Assert.IsEqual(R, 'test')
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, 'test')
+    const R = Encoder.Encode(T1, 'test')
     Assert.IsEqual(R, { type: 'hello' })
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
   // --------------------------------------------------------
   // Mapped ValueType
@@ -62,23 +63,23 @@ describe('value/transform/Union', () => {
       return value
     })
   it('Should decode value type 1', () => {
-    const R = Value.Decode(T2, 0)
+    const R = Encoder.Decode(T2, 0)
     Assert.IsEqual(R, 2)
   })
   it('Should decode value type 2', () => {
-    const R = Value.Decode(T2, 'hello')
+    const R = Encoder.Decode(T2, 'hello')
     Assert.IsEqual(R, 'hello')
   })
   it('Should encode value type 1', () => {
-    const R = Value.Encode(T2, 'hello')
+    const R = Encoder.Encode(T2, 'hello')
     Assert.IsEqual(R, 'world')
   })
   it('Should encode value type 2', () => {
-    const R = Value.Encode(T2, 2)
+    const R = Encoder.Encode(T2, 2)
     Assert.IsEqual(R, 0)
   })
   it('Should throw on value type decode', () => {
-    Assert.Throws(() => Value.Decode(T2, null))
+    Assert.Throws(() => Encoder.Decode(T2, null))
   })
   // --------------------------------------------------------
   // Mapped ObjectType
@@ -102,23 +103,23 @@ describe('value/transform/Union', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode object types 1', () => {
-    const R = Value.Decode(T3, { x: 0 })
+    const R = Encoder.Decode(T3, { x: 0 })
     Assert.IsEqual(R, { x: 1 })
   })
   it('Should decode object types 2', () => {
-    const R = Value.Decode(T3, { x: 'abc' })
+    const R = Encoder.Decode(T3, { x: 'abc' })
     Assert.IsEqual(R, { x: 'cba' })
   })
   it('Should encode object types 1', () => {
-    const R = Value.Encode(T3, { x: 1 })
+    const R = Encoder.Encode(T3, { x: 1 })
     Assert.IsEqual(R, { x: 0 })
   })
   it('Should encode object types 2', () => {
-    const R = Value.Encode(T3, { x: 'cba' })
+    const R = Encoder.Encode(T3, { x: 'cba' })
     Assert.IsEqual(R, { x: 'abc' })
   })
   it('Should throw on object types decode', () => {
-    Assert.Throws(() => Value.Decode(T3, null))
+    Assert.Throws(() => Encoder.Decode(T3, null))
   })
   // --------------------------------------------------------
   // Mapped Mixed Types
@@ -140,31 +141,31 @@ describe('value/transform/Union', () => {
     .Decode((value) => typeof value === 'number' ? value + 1 : value)
     .Encode((value) => typeof value === 'number' ? value - 1 : value)
   it('Should decode mixed types 1', () => {
-    const R = Value.Decode(T4, { x: 0 })
+    const R = Encoder.Decode(T4, { x: 0 })
     Assert.IsEqual(R, { x: 1 })
   })
   it('Should decode mixed types 2', () => {
-    const R = Value.Decode(T4, 0)
+    const R = Encoder.Decode(T4, 0)
     Assert.IsEqual(R, 2)
   })
   it('Should decode mixed types 3', () => {
-    const R = Value.Decode(T4, [0])
+    const R = Encoder.Decode(T4, [0])
     Assert.IsEqual(R, [1])
   })
   it('Should encode mixed types 1', () => {
-    const R = Value.Encode(T4, { x: 1 })
+    const R = Encoder.Encode(T4, { x: 1 })
     Assert.IsEqual(R, { x: 0 })
   })
   it('Should encode mixed types 2', () => {
-    const R = Value.Encode(T4, 2)
+    const R = Encoder.Encode(T4, 2)
     Assert.IsEqual(R, 0)
   })
   it('Should encode mixed types 3', () => {
-    const R = Value.Encode(T4, [1])
+    const R = Encoder.Encode(T4, [1])
     Assert.IsEqual(R, [0])
   })
   it('Should throw on mixed types decode', () => {
-    Assert.Throws(() => Value.Decode(T4, null))
+    Assert.Throws(() => Encoder.Decode(T4, null))
   })
   // --------------------------------------------------------
   // Interior Union Transform
@@ -176,26 +177,26 @@ describe('value/transform/Union', () => {
     .Encode((value) => value.toISOString())
   const T52 = Type.Union([Type.Null(), T51])
   it('Should decode interior union 1', () => {
-    const R = Value.Decode(T52, null)
+    const R = Encoder.Decode(T52, null)
     Assert.IsEqual(R, null)
   })
   it('Should decode interior union 2', () => {
-    const R = Value.Decode(T52, new Date().toISOString())
+    const R = Encoder.Decode(T52, new Date().toISOString())
     Assert.IsInstanceOf(R, Date)
   })
   it('Should encode interior union 1', () => {
-    const R = Value.Encode(T52, null)
+    const R = Encoder.Encode(T52, null)
     Assert.IsEqual(R, null)
   })
   it('Should encode interior union 2', () => {
     const D = new Date()
-    const R = Value.Encode(T52, D)
+    const R = Encoder.Encode(T52, D)
     Assert.IsEqual(R, D.toISOString())
   })
   it('Should throw on interior union decode', () => {
-    Assert.Throws(() => Value.Decode(T52, {}))
+    Assert.Throws(() => Encoder.Decode(T52, {}))
   })
   it('Should throw on interior union encode', () => {
-    Assert.Throws(() => Value.Encode(T52, 1))
+    Assert.Throws(() => Encoder.Encode(T52, 1))
   })
 })
diff --git a/test/runtime/value/transform/unknown.ts b/test/runtime/value/transform/unknown.ts
index 2fe673a17..463980d57 100644
--- a/test/runtime/value/transform/unknown.ts
+++ b/test/runtime/value/transform/unknown.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -10,11 +11,11 @@ describe('value/transform/Unknown', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode mapped', () => {
-    const R = Value.Decode(T0, 123)
+    const R = Encoder.Decode(T0, 123)
     Assert.IsEqual(R, 123)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T0, 123)
+    const R = Encoder.Encode(T0, 123)
     Assert.IsEqual(R, 123)
   })
   // --------------------------------------------------------
@@ -24,11 +25,11 @@ describe('value/transform/Unknown', () => {
     .Decode((value) => 1)
     .Encode((value) => 2)
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, null)
+    const R = Encoder.Decode(T1, null)
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, null)
+    const R = Encoder.Encode(T1, null)
     Assert.IsEqual(R, 2)
   })
 })
diff --git a/test/runtime/value/transform/unsafe.ts b/test/runtime/value/transform/unsafe.ts
index 76d31cb4f..f679e01c9 100644
--- a/test/runtime/value/transform/unsafe.ts
+++ b/test/runtime/value/transform/unsafe.ts
@@ -1,3 +1,4 @@
+import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type, Kind, TypeRegistry } from '@sinclair/typebox'
@@ -16,15 +17,15 @@ describe('value/transform/Unsafe', () => {
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode identity', () => {
-    const R = Value.Decode(T0, 'hello')
+    const R = Encoder.Decode(T0, 'hello')
     Assert.IsEqual(R, 'hello')
   })
   it('Should encode identity', () => {
-    const R = Value.Encode(T0, 'hello')
+    const R = Encoder.Encode(T0, 'hello')
     Assert.IsEqual(R, 'hello')
   })
   it('Should throw on identity decode', () => {
-    Assert.Throws(() => Value.Decode(T0, null))
+    Assert.Throws(() => Encoder.Decode(T0, null))
   })
   // --------------------------------------------------------
   // Mapped
@@ -33,14 +34,14 @@ describe('value/transform/Unsafe', () => {
     .Decode((value) => value.split('').reverse().join(''))
     .Encode((value) => value.split('').reverse().join(''))
   it('Should decode mapped', () => {
-    const R = Value.Decode(T1, 'ABC')
+    const R = Encoder.Decode(T1, 'ABC')
     Assert.IsEqual(R, 'CBA')
   })
   it('Should encode mapped', () => {
-    const R = Value.Encode(T1, 'CBA')
+    const R = Encoder.Encode(T1, 'CBA')
     Assert.IsEqual(R, 'ABC')
   })
   it('Should throw on mapped decode', () => {
-    Assert.Throws(() => Value.Decode(T1, null))
+    Assert.Throws(() => Encoder.Decode(T1, null))
   })
 })

From 06bd0b8ded36feaa57403396c9131b875b62b191 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sat, 18 Nov 2023 18:21:09 +0900
Subject: [PATCH 212/369] Formatting

---
 test/runtime/value/transform/_encoder.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/test/runtime/value/transform/_encoder.ts b/test/runtime/value/transform/_encoder.ts
index 8449787e6..06d82410b 100644
--- a/test/runtime/value/transform/_encoder.ts
+++ b/test/runtime/value/transform/_encoder.ts
@@ -1,4 +1,4 @@
-import { IsAsyncIterator, IsIterator, IsFunction, IsSymbol } from '@sinclair/typebox/value/guard'
+import { IsAsyncIterator, IsIterator, IsFunction, IsSymbol, IsDate } from '@sinclair/typebox/value/guard'
 import { TSchema, StaticDecode, StaticEncode } from '@sinclair/typebox'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 import { Value } from '@sinclair/typebox/value'
@@ -9,6 +9,9 @@ function AssertSame(actual: unknown, expect: unknown) {
   if (IsIterator(actual) && IsIterator(expect)) return
   if (IsSymbol(actual) && IsSymbol(expect)) return
   if (IsFunction(actual) && IsFunction(expect)) return
+  if (IsDate(actual) && IsDate(expect)) {
+    return Assert.IsEqual(actual.getTime(), expect.getTime())
+  }
   Assert.IsEqual(actual, expect)
 }
 

From ea217ccc06f4349c6830d55c698231275e72004a Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 20 Nov 2023 04:42:13 +0900
Subject: [PATCH 213/369] Revision 0.31.27 (#671)

* Clone Date and Uint8Array types

* Date Default is  Current Time

* Tests
---
 package-lock.json                       |  4 ++--
 package.json                            |  2 +-
 src/typebox.ts                          | 26 +++++++++++++++++----
 src/value/create.ts                     |  2 +-
 test/runtime/assert/assert.ts           |  5 +++++
 test/runtime/value/cast/date.ts         | 10 ++++-----
 test/runtime/value/create/date.ts       | 30 +++++++++++++++++++++++++
 test/runtime/value/create/index.ts      |  1 +
 test/runtime/value/create/uint8array.ts |  8 +++++++
 test/runtime/value/transform/date.ts    |  4 ++--
 10 files changed, 77 insertions(+), 15 deletions(-)
 create mode 100644 test/runtime/value/create/date.ts

diff --git a/package-lock.json b/package-lock.json
index 48e7f7e19..b7f256f22 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.26",
+  "version": "0.31.27",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.26",
+      "version": "0.31.27",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.18.0",
diff --git a/package.json b/package.json
index f7aa93d5b..e5fc6ea76 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.26",
+  "version": "0.31.27",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index bb6c50bf4..57e8cb27b 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -1087,6 +1087,10 @@ export namespace ValueGuard {
   export function IsBoolean(value: unknown): value is boolean {
     return typeof value === 'boolean'
   }
+  /** Returns true if this value is a Date object */
+  export function IsDate(value: unknown): value is Date {
+    return value instanceof globalThis.Date
+  }
   /** Returns true if this value is null */
   export function IsNull(value: unknown): value is null {
     return value === null
@@ -1103,6 +1107,10 @@ export namespace ValueGuard {
   export function IsString(value: unknown): value is string {
     return typeof value === 'string'
   }
+  /** Returns true if this value is a Uint8Array */
+  export function IsUint8Array(value: unknown): value is Uint8Array {
+    return value instanceof globalThis.Uint8Array
+  }
   /** Returns true if this value is undefined */
   export function IsUndefined(value: unknown): value is undefined {
     return value === undefined
@@ -2287,19 +2295,29 @@ export namespace TypeExtends {
 // --------------------------------------------------------------------------
 /** Specialized Clone for Types */
 export namespace TypeClone {
+  function ArrayType(value: unknown[]) {
+    return (value as any).map((value: unknown) => Visit(value as any))
+  }
+  function DateType(value: Date) {
+    return new Date(value.getTime())
+  }
+  function Uint8ArrayType(value: Uint8Array) {
+    return new Uint8Array(value)
+  }
   function ObjectType(value: Record<keyof any, unknown>) {
     const clonedProperties = Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {})
     const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key as any]) }), {})
     return { ...clonedProperties, ...clonedSymbols }
   }
-  function ArrayType(value: unknown[]) {
-    return (value as any).map((value: unknown) => Visit(value as any))
-  }
   function Visit(value: unknown): any {
     // prettier-ignore
-    return ValueGuard.IsArray(value) ? ArrayType(value) :
+    return (
+      ValueGuard.IsArray(value) ? ArrayType(value) :
+      ValueGuard.IsDate(value) ? DateType(value) : 
+      ValueGuard.IsUint8Array(value) ? Uint8ArrayType(value) :
       ValueGuard.IsObject(value) ? ObjectType(value) :
       value
+    )
   }
   /** Clones a Rest */
   export function Rest<T extends TSchema[]>(schemas: [...T]): T {
diff --git a/src/value/create.ts b/src/value/create.ts
index 1013bbbdb..b36b42f41 100644
--- a/src/value/create.ts
+++ b/src/value/create.ts
@@ -135,7 +135,7 @@ function TDate(schema: Types.TDate, references: Types.TSchema[]): any {
   } else if (schema.minimumTimestamp !== undefined) {
     return new Date(schema.minimumTimestamp)
   } else {
-    return new Date(0)
+    return new Date()
   }
 }
 function TFunction(schema: Types.TFunction, references: Types.TSchema[]): any {
diff --git a/test/runtime/assert/assert.ts b/test/runtime/assert/assert.ts
index 65ca4aa10..2e9a92944 100644
--- a/test/runtime/assert/assert.ts
+++ b/test/runtime/assert/assert.ts
@@ -17,6 +17,11 @@ export namespace Assert {
   export function NotEqual(actual: unknown, expect: unknown) {
     return assert.notEqual(actual, expect)
   }
+  /** Asserts a numeric value is within range of the expected */
+  export function InRange(value: number, expect: number, range: number) {
+    if (Math.abs(value - expect) <= range) return
+    throw Error('Expected value to be in range')
+  }
   let nextIdOrdinal = 0
   export function NextId() {
     return `$id-${nextIdOrdinal++}`
diff --git a/test/runtime/value/cast/date.ts b/test/runtime/value/cast/date.ts
index 4e6fc6016..e204acf36 100644
--- a/test/runtime/value/cast/date.ts
+++ b/test/runtime/value/cast/date.ts
@@ -8,27 +8,27 @@ describe('value/cast/Date', () => {
   it('Should upcast from string', () => {
     const value = 'world'
     const result = Value.Cast(T, value)
-    Assert.IsEqual(result, E)
+    Assert.InRange(result.getTime(), new Date().getTime(), 1000)
   })
   it('Should upcast from object', () => {
     const value = {}
     const result = Value.Cast(T, value)
-    Assert.IsEqual(result, E)
+    Assert.InRange(result.getTime(), new Date().getTime(), 1000)
   })
   it('Should upcast from array', () => {
     const value = [1]
     const result = Value.Cast(T, value)
-    Assert.IsEqual(result, E)
+    Assert.InRange(result.getTime(), new Date().getTime(), 1000)
   })
   it('Should upcast from undefined', () => {
     const value = undefined
     const result = Value.Cast(T, value)
-    Assert.IsEqual(result, E)
+    Assert.InRange(result.getTime(), new Date().getTime(), 1000)
   })
   it('Should upcast from null', () => {
     const value = null
     const result = Value.Cast(T, value)
-    Assert.IsEqual(result, E)
+    Assert.InRange(result.getTime(), new Date().getTime(), 1000)
   })
   it('Should preseve', () => {
     const value = new Date(100)
diff --git a/test/runtime/value/create/date.ts b/test/runtime/value/create/date.ts
new file mode 100644
index 000000000..37c12b7ee
--- /dev/null
+++ b/test/runtime/value/create/date.ts
@@ -0,0 +1,30 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Date', () => {
+  it('Should create value', () => {
+    const T = Type.Date()
+    const A = Value.Create(T)
+    const B = new Date()
+    Assert.InRange(A.getTime(), B.getTime(), 1000)
+  })
+  it('Should create default', () => {
+    const T = Type.Date({ default: new Date(1001) })
+    const A = Value.Create(T)
+    const B = new Date(1001)
+    Assert.IsEqual(A, B)
+  })
+  it('Should create value nested', () => {
+    const T = Type.Object({ value: Type.Date() })
+    const A = Value.Create(T)
+    const B = { value: new Date() }
+    Assert.InRange(A.value.getTime(), B.value.getTime(), 1000)
+  })
+  it('Should create default nested', () => {
+    const T = Type.Object({ value: Type.Date({ default: new Date(1001) }) })
+    const A = Value.Create(T)
+    const B = { value: new Date(1001) }
+    Assert.IsEqual(A, B)
+  })
+})
diff --git a/test/runtime/value/create/index.ts b/test/runtime/value/create/index.ts
index 9bb482979..7b51cf3bf 100644
--- a/test/runtime/value/create/index.ts
+++ b/test/runtime/value/create/index.ts
@@ -5,6 +5,7 @@ import './bigint'
 import './boolean'
 import './composite'
 import './constructor'
+import './date'
 import './enum'
 import './function'
 import './integer'
diff --git a/test/runtime/value/create/uint8array.ts b/test/runtime/value/create/uint8array.ts
index 0dac37786..faf044f43 100644
--- a/test/runtime/value/create/uint8array.ts
+++ b/test/runtime/value/create/uint8array.ts
@@ -23,4 +23,12 @@ describe('value/create/Uint8Array', () => {
     Assert.IsEqual(value.length, 4)
     Assert.IsEqual([value[0], value[1], value[2], value[3]], [0, 0, 0, 0])
   })
+  it('Should create value nested', () => {
+    const T = Type.Object({ value: Type.Uint8Array() })
+    Assert.IsEqual(Value.Create(T), { value: new Uint8Array() })
+  })
+  it('Should create default nested', () => {
+    const T = Type.Object({ value: Type.Date({ default: new Uint8Array([1, 2, 3, 4]) }) })
+    Assert.IsEqual(Value.Create(T), { value: new Uint8Array([1, 2, 3, 4]) })
+  })
 })
diff --git a/test/runtime/value/transform/date.ts b/test/runtime/value/transform/date.ts
index bc7fec5f5..e81ff7a89 100644
--- a/test/runtime/value/transform/date.ts
+++ b/test/runtime/value/transform/date.ts
@@ -26,9 +26,9 @@ describe('value/transform/Date', () => {
   // --------------------------------------------------------
   const T1 = Type.Transform(Type.Date())
     .Decode((value) => 1)
-    .Encode((value) => new Date())
+    .Encode((value) => new Date(0))
   it('Should decode mapped', () => {
-    const R = Encoder.Decode(T1, new Date())
+    const R = Encoder.Decode(T1, new Date(0))
     Assert.IsEqual(R, 1)
   })
   it('Should encode mapped', () => {

From 6fd7dac6a4e0aa9229c37d76ec2c4238c968ce8b Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 20 Nov 2023 21:53:12 +0900
Subject: [PATCH 214/369] Revision 0.31.28 (#674)

* Update Intersect Transform Logic

* Tests

* Version
---
 package-lock.json                         |   4 +-
 package.json                              |   2 +-
 readme.md                                 |  10 +-
 src/value/transform.ts                    | 308 ++++++++++------------
 test/runtime/value/transform/intersect.ts |  57 ++++
 5 files changed, 200 insertions(+), 181 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index b7f256f22..a9ffcd256 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.27",
+  "version": "0.31.28",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.27",
+      "version": "0.31.28",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.18.0",
diff --git a/package.json b/package.json
index e5fc6ea76..04d98e936 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.27",
+  "version": "0.31.28",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index d4868e0d7..8ba350169 100644
--- a/readme.md
+++ b/readme.md
@@ -1719,11 +1719,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '148.9 kb' │ ' 65.8 kb' │  '2.26 x'   │
-│ typebox/errors       │ '111.5 kb' │ ' 49.1 kb' │  '2.27 x'   │
-│ typebox/system       │ ' 82.6 kb' │ ' 36.8 kb' │  '2.24 x'   │
-│ typebox/value        │ '190.5 kb' │ ' 82.4 kb' │  '2.31 x'   │
-│ typebox              │ ' 72.4 kb' │ ' 31.6 kb' │  '2.29 x'   │
+│ typebox/compiler     │ '163.6 kb' │ ' 71.6 kb' │  '2.28 x'   │
+│ typebox/errors       │ '113.3 kb' │ ' 50.1 kb' │  '2.26 x'   │
+│ typebox/system       │ ' 83.9 kb' │ ' 37.5 kb' │  '2.24 x'   │
+│ typebox/value        │ '191.1 kb' │ ' 82.3 kb' │  '2.32 x'   │
+│ typebox              │ ' 73.8 kb' │ ' 32.3 kb' │  '2.29 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/value/transform.ts b/src/value/transform.ts
index d0c7daba5..bb377f9a1 100644
--- a/src/value/transform.ts
+++ b/src/value/transform.ts
@@ -32,19 +32,9 @@ import { Deref } from './deref'
 import { Check } from './check'
 import * as Types from '../typebox'
 
-// -------------------------------------------------------------------------
-// CheckFunction
-// -------------------------------------------------------------------------
-export type CheckFunction = (schema: Types.TSchema, references: Types.TSchema[], value: unknown) => boolean
-
 // -------------------------------------------------------------------------
 // Errors
 // -------------------------------------------------------------------------
-export class TransformUnknownTypeError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TRef | Types.TThis) {
-    super(`Unknown type`)
-  }
-}
 export class TransformDecodeCheckError extends Types.TypeBoxError {
   constructor(public readonly schema: Types.TSchema, public readonly value: unknown, public readonly error: ValueError) {
     super(`Unable to decode due to invalid value`)
@@ -65,9 +55,9 @@ export class TransformEncodeError extends Types.TypeBoxError {
     super(`${error instanceof Error ? error.message : 'Unknown error'}`)
   }
 }
-// -------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // HasTransform
-// -------------------------------------------------------------------------
+// ------------------------------------------------------------------
 /** Recursively checks a schema for transform codecs */
 export namespace HasTransform {
   function TArray(schema: Types.TArray, references: Types.TSchema[]): boolean {
@@ -124,9 +114,6 @@ export namespace HasTransform {
     if (schema.$id && visited.has(schema.$id)) return false
     if (schema.$id) visited.add(schema.$id)
     switch (schema[Types.Kind]) {
-      // ------------------------------------------------------
-      // Structural
-      // ------------------------------------------------------
       case 'Array':
         return TArray(schema_, references_)
       case 'AsyncIterator':
@@ -155,28 +142,7 @@ export namespace HasTransform {
         return TTuple(schema_, references_)
       case 'Union':
         return TUnion(schema_, references_)
-      // ------------------------------------------------------
-      // Default
-      // ------------------------------------------------------
-      case 'Any':
-      case 'BigInt':
-      case 'Boolean':
-      case 'Date':
-      case 'Integer':
-      case 'Literal':
-      case 'Never':
-      case 'Null':
-      case 'Number':
-      case 'String':
-      case 'Symbol':
-      case 'TemplateLiteral':
-      case 'Undefined':
-      case 'Uint8Array':
-      case 'Unknown':
-      case 'Void':
-        return Types.TypeGuard.TTransform(schema)
       default:
-        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new TransformUnknownTypeError(schema_)
         return Types.TypeGuard.TTransform(schema)
     }
   }
@@ -187,9 +153,9 @@ export namespace HasTransform {
     return Visit(schema, references)
   }
 }
-// -------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // DecodeTransform
-// -------------------------------------------------------------------------
+// ------------------------------------------------------------------
 /** Decodes a value using transform decoders if available. Does not ensure correct results. */
 export namespace DecodeTransform {
   function Default(schema: Types.TSchema, value: any) {
@@ -199,82 +165,105 @@ export namespace DecodeTransform {
       throw new TransformDecodeError(schema, value, error)
     }
   }
+  // prettier-ignore
   function TArray(schema: Types.TArray, references: Types.TSchema[], value: any): any {
-    const elements1 = value.map((value: any) => Visit(schema.items, references, value)) as unknown[]
-    return Default(schema, elements1)
+    return (IsArray(value))
+      ? Default(schema, value.map((value: any) => Visit(schema.items, references, value)))
+      : Default(schema, value)
   }
+  // prettier-ignore
   function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any) {
     if (!IsPlainObject(value) || IsValueType(value)) return Default(schema, value)
-    const keys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false })
-    const properties1 = Object.entries(value).reduce((acc, [key, value]) => {
-      return !keys.includes(key) ? { ...acc, [key]: value } : { ...acc, [key]: Default(Types.IndexedAccessor.Resolve(schema, [key]), value) }
-    }, {} as Record<any, any>)
-    if (!Types.TypeGuard.TTransform(schema.unevaluatedProperties)) return Default(schema, properties1)
-    const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
-      return keys.includes(key) ? { ...acc, [key]: value } : { ...acc, [key]: Default(schema.unevaluatedProperties as Types.TSchema, value) }
-    }, {} as Record<any, any>)
-    return Default(schema, properties2)
+    const knownKeys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false })
+    const knownProperties = knownKeys.reduce((value, key) => {
+      return (key in value)
+        ? { ...value, [key]: Visit(Types.IndexedAccessor.Resolve(schema, [key]), references, value[key]) }
+        : value
+    }, value)
+    if (!Types.TypeGuard.TTransform(schema.unevaluatedProperties)) {
+      return Default(schema, knownProperties)
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties)
+    const unevaluatedProperties = schema.unevaluatedProperties as Types.TSchema
+    const unknownProperties = unknownKeys.reduce((value, key) => {
+      return !knownKeys.includes(key)
+        ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }
+        : value
+    }, knownProperties)
+    return Default(schema, unknownProperties)
   }
   function TNot(schema: Types.TNot, references: Types.TSchema[], value: any) {
-    const value1 = Visit(schema.not, references, value)
-    return Default(schema, value1)
+    return Default(schema, Visit(schema.not, references, value))
   }
+  // prettier-ignore
   function TObject(schema: Types.TObject, references: Types.TSchema[], value: any) {
     if (!IsPlainObject(value)) return Default(schema, value)
-    const properties1 = Object.entries(value).reduce((acc, [key, value]) => {
-      return !(key in schema.properties) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(schema.properties[key], references, value) }
-    }, {} as Record<any, any>)
-    if (!Types.TypeGuard.TSchema(schema.additionalProperties)) return Default(schema, properties1)
+    const knownKeys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false })
+    const knownProperties = knownKeys.reduce((value, key) => {
+      return (key in value) 
+        ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }  
+        : value
+    }, value)
+    if (!Types.TypeGuard.TSchema(schema.additionalProperties)) {
+      return Default(schema, knownProperties)
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties)
     const additionalProperties = schema.additionalProperties as Types.TSchema
-    const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
-      return key in schema.properties ? { ...acc, [key]: value } : { ...acc, [key]: Visit(additionalProperties, references, value) }
-    }, {} as Record<any, any>)
-    return Default(schema, properties2)
-  }
+    const unknownProperties = unknownKeys.reduce((value, key) => {
+      return !knownKeys.includes(key)
+      ? { ...value, [key]: Default(additionalProperties, value[key]) }
+      : value
+    }, knownProperties)
+    return Default(schema, unknownProperties)
+  }
+  // prettier-ignore
   function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any) {
     if (!IsPlainObject(value)) return Default(schema, value)
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
-    const property = schema.patternProperties[pattern]
-    const regex = new RegExp(pattern)
-    const properties1 = Object.entries(value).reduce((acc, [key, value]) => {
-      return !regex.test(key) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(property, references, value) }
-    }, {} as Record<any, any>)
-    if (!Types.TypeGuard.TSchema(schema.additionalProperties)) return Default(schema, properties1)
+    const knownKeys = new RegExp(pattern)
+    const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
+      return knownKeys.test(key) 
+        ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
+        : value
+    }, value)
+    if (!Types.TypeGuard.TSchema(schema.additionalProperties)) {
+      return Default(schema, knownProperties)
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties)
     const additionalProperties = schema.additionalProperties as Types.TSchema
-    const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
-      return regex.test(key) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(additionalProperties, references, value) }
-    }, {} as Record<any, any>)
-    return Default(schema, properties2)
+    const unknownProperties = unknownKeys.reduce((value, key) => {
+      return !knownKeys.test(key)
+      ? { ...value, [key]: Default(additionalProperties, value[key]) }
+      : value
+    }, knownProperties)
+    return Default(schema, unknownProperties)
   }
   function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any) {
     const target = Deref(schema, references)
-    const resolved = Visit(target, references, value)
-    return Default(schema, resolved)
+    return Default(schema, Visit(target, references, value))
   }
   function TThis(schema: Types.TThis, references: Types.TSchema[], value: any) {
     const target = Deref(schema, references)
-    const resolved = Visit(target, references, value)
-    return Default(schema, resolved)
+    return Default(schema, Visit(target, references, value))
   }
+  // prettier-ignore
   function TTuple(schema: Types.TTuple, references: Types.TSchema[], value: any) {
-    const value1 = IsArray(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, value[index])) : []
-    return Default(schema, value1)
+    return (IsArray(value) && IsArray(schema.items))
+      ? Default(schema, schema.items.map((schema, index) => Visit(schema, references, value[index])))
+      : Default(schema, value)
   }
   function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any) {
-    const value1 = Default(schema, value)
+    const defaulted = Default(schema, value)
     for (const subschema of schema.anyOf) {
-      if (!Check(subschema, references, value1)) continue
-      return Visit(subschema, references, value1)
+      if (!Check(subschema, references, defaulted)) continue
+      return Visit(subschema, references, defaulted)
     }
-    return value1
+    return defaulted
   }
   function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
     const references_ = typeof schema.$id === 'string' ? [...references, schema] : references
     const schema_ = schema as any
     switch (schema[Types.Kind]) {
-      // ------------------------------------------------------
-      // Structural
-      // ------------------------------------------------------
       case 'Array':
         return TArray(schema_, references_, value)
       case 'Intersect':
@@ -295,32 +284,7 @@ export namespace DecodeTransform {
         return TTuple(schema_, references_, value)
       case 'Union':
         return TUnion(schema_, references_, value)
-      // ------------------------------------------------------
-      // Default
-      // ------------------------------------------------------
-      case 'Any':
-      case 'AsyncIterator':
-      case 'BigInt':
-      case 'Boolean':
-      case 'Constructor':
-      case 'Date':
-      case 'Function':
-      case 'Integer':
-      case 'Iterator':
-      case 'Literal':
-      case 'Never':
-      case 'Null':
-      case 'Number':
-      case 'Promise':
-      case 'String':
-      case 'TemplateLiteral':
-      case 'Undefined':
-      case 'Uint8Array':
-      case 'Unknown':
-      case 'Void':
-        return Default(schema_, value)
       default:
-        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new TransformUnknownTypeError(schema_)
         return Default(schema_, value)
     }
   }
@@ -328,9 +292,9 @@ export namespace DecodeTransform {
     return Visit(schema, references, value)
   }
 }
-// -------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // DecodeTransform
-// -------------------------------------------------------------------------
+// ------------------------------------------------------------------
 /** Encodes a value using transform encoders if available. Does not ensure correct results. */
 export namespace EncodeTransform {
   function Default(schema: Types.TSchema, value: any) {
@@ -340,52 +304,79 @@ export namespace EncodeTransform {
       throw new TransformEncodeError(schema, value, error)
     }
   }
+  // prettier-ignore
   function TArray(schema: Types.TArray, references: Types.TSchema[], value: any): any {
-    const elements1 = Default(schema, value)
-    return elements1.map((value: any) => Visit(schema.items, references, value)) as unknown[]
+    const defaulted = Default(schema, value)
+    return IsArray(defaulted)
+      ? defaulted.map((value: any) => Visit(schema.items, references, value))
+      : defaulted
   }
+  // prettier-ignore
   function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any) {
-    const properties1 = Default(schema, value)
-    if (!IsPlainObject(value) || IsValueType(value)) return properties1
-    const keys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false })
-    const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
-      return !keys.includes(key) ? { ...acc, [key]: value } : { ...acc, [key]: Default(Types.IndexedAccessor.Resolve(schema, [key]), value) }
-    }, {} as Record<any, any>)
-    if (!Types.TypeGuard.TTransform(schema.unevaluatedProperties)) return Default(schema, properties2)
-    return Object.entries(properties2).reduce((acc, [key, value]) => {
-      return keys.includes(key) ? { ...acc, [key]: value } : { ...acc, [key]: Default(schema.unevaluatedProperties as Types.TSchema, value) }
-    }, {} as Record<any, any>)
+    const defaulted = Default(schema, value)
+    if (!IsPlainObject(value) || IsValueType(value)) return defaulted
+    const knownKeys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false })
+    const knownProperties = knownKeys.reduce((value, key) => {
+      return key in defaulted 
+        ? { ...value, [key]: Visit(Types.IndexedAccessor.Resolve(schema, [key]), references, value[key]) } 
+        : value
+    }, defaulted)
+    if (!Types.TypeGuard.TTransform(schema.unevaluatedProperties)) {
+      return Default(schema, knownProperties)
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties)
+    const unevaluatedProperties = schema.unevaluatedProperties as Types.TSchema
+    return unknownKeys.reduce((value, key) => {
+      return !knownKeys.includes(key) 
+        ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }  
+        : value
+    }, knownProperties)
   }
   function TNot(schema: Types.TNot, references: Types.TSchema[], value: any) {
-    const value1 = Default(schema, value)
-    return Default(schema.not, value1)
+    return Default(schema.not, Default(schema, value))
   }
+  // prettier-ignore
   function TObject(schema: Types.TObject, references: Types.TSchema[], value: any) {
-    const properties1 = Default(schema, value) as Record<any, any>
-    if (!IsPlainObject(value)) return properties1
-    const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
-      return !(key in schema.properties) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(schema.properties[key], references, value) }
-    }, {} as Record<any, any>)
-    if (!Types.TypeGuard.TSchema(schema.additionalProperties)) return properties2
+    const defaulted = Default(schema, value)
+    if (!IsPlainObject(value)) return defaulted
+    const knownKeys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false })
+    const knownProperties = knownKeys.reduce((value, key) => {
+      return key in value 
+        ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) } 
+        : value
+    }, defaulted)
+    if (!Types.TypeGuard.TSchema(schema.additionalProperties)) {
+      return knownProperties
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties)
     const additionalProperties = schema.additionalProperties as Types.TSchema
-    return Object.entries(properties2).reduce((acc, [key, value]) => {
-      return key in schema.properties ? { ...acc, [key]: value } : { ...acc, [key]: Visit(additionalProperties, references, value) }
-    }, {} as Record<any, any>)
+    return unknownKeys.reduce((value, key) => {
+      return !knownKeys.includes(key) 
+        ? { ...value, [key]: Default(additionalProperties, value[key]) }  
+        : value
+    }, knownProperties)
   }
+  // prettier-ignore
   function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any) {
-    const properties1 = Default(schema, value) as Record<any, any>
-    if (!IsPlainObject(value)) return properties1
+    const defaulted = Default(schema, value) as Record<any, any>
+    if (!IsPlainObject(value)) return defaulted
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
-    const property = schema.patternProperties[pattern]
-    const regex = new RegExp(pattern)
-    const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
-      return !regex.test(key) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(property, references, value) }
-    }, {} as Record<any, any>)
-    if (!Types.TypeGuard.TSchema(schema.additionalProperties)) return Default(schema, properties2)
+    const knownKeys = new RegExp(pattern)
+    const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
+      return knownKeys.test(key) 
+        ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
+        : value
+    }, defaulted)
+    if (!Types.TypeGuard.TSchema(schema.additionalProperties)) {
+      return Default(schema, knownProperties)
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties)
     const additionalProperties = schema.additionalProperties as Types.TSchema
-    return Object.entries(properties2).reduce((acc, [key, value]) => {
-      return regex.test(key) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(additionalProperties, references, value) }
-    }, {} as Record<any, any>)
+    return unknownKeys.reduce((value, key) => {
+      return !knownKeys.test(key) 
+        ? { ...value, [key]: Default(additionalProperties, value[key]) }  
+        : value
+    }, knownProperties)
   }
   function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any) {
     const target = Deref(schema, references)
@@ -420,9 +411,6 @@ export namespace EncodeTransform {
     const references_ = typeof schema.$id === 'string' ? [...references, schema] : references
     const schema_ = schema as any
     switch (schema[Types.Kind]) {
-      // ------------------------------------------------------
-      // Structural
-      // ------------------------------------------------------
       case 'Array':
         return TArray(schema_, references_, value)
       case 'Intersect':
@@ -441,33 +429,7 @@ export namespace EncodeTransform {
         return TTuple(schema_, references_, value)
       case 'Union':
         return TUnion(schema_, references_, value)
-      // ------------------------------------------------------
-      // Apply
-      // ------------------------------------------------------
-      case 'Any':
-      case 'AsyncIterator':
-      case 'BigInt':
-      case 'Boolean':
-      case 'Constructor':
-      case 'Date':
-      case 'Function':
-      case 'Integer':
-      case 'Iterator':
-      case 'Literal':
-      case 'Never':
-      case 'Null':
-      case 'Number':
-      case 'Promise':
-      case 'String':
-      case 'Symbol':
-      case 'TemplateLiteral':
-      case 'Undefined':
-      case 'Uint8Array':
-      case 'Unknown':
-      case 'Void':
-        return Default(schema_, value)
       default:
-        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new TransformUnknownTypeError(schema_)
         return Default(schema_, value)
     }
   }
diff --git a/test/runtime/value/transform/intersect.ts b/test/runtime/value/transform/intersect.ts
index 0d7f39043..7e0bcc825 100644
--- a/test/runtime/value/transform/intersect.ts
+++ b/test/runtime/value/transform/intersect.ts
@@ -120,4 +120,61 @@ describe('value/transform/Intersect', () => {
   it('Should throw on exterior value type decode', () => {
     Assert.Throws(() => Encoder.Decode(T4, null))
   })
+  // --------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/discussions/672
+  // --------------------------------------------------------
+  // prettier-ignore
+  {
+    const A = Type.Object({ isHybrid: Type.Boolean() })
+    const T = Type.Transform(A)
+      .Decode((value) => ({ isHybrid: value.isHybrid ? 1 : 0 }))
+      .Encode((value) => ({ isHybrid: value.isHybrid === 1 ? true : false }))
+    const I = Type.Intersect([
+      Type.Object({ model: Type.String() }),
+      Type.Object({ features: Type.Array(T) }),
+    ])
+    it('Should decode nested 1', () => {
+      const value = Value.Decode(T, { isHybrid: true })
+      Assert.IsEqual(value, { isHybrid: 1 })
+    })
+    // prettier-ignore
+    it('Should decode nested 2', () => {
+      const value = Value.Decode(I, {
+        model: 'Prius',
+        features: [
+          { isHybrid: true },
+          { isHybrid: false }
+        ],
+      })
+      Assert.IsEqual(value, {
+        model: 'Prius',
+        features: [
+          { isHybrid: 1 },
+          { isHybrid: 0 }
+        ],
+      })
+    })
+    it('should encode nested 1', () => {
+      let value = Value.Encode(T, { isHybrid: 1 })
+      Assert.IsEqual(value, { isHybrid: true })
+    })
+    // prettier-ignore
+    it('Should encode nested 2', () => {
+      const value = Value.Encode(I, {
+        model: 'Prius',
+        features: [
+          { isHybrid: 1 },
+          { isHybrid: 0 }
+        ],
+      })
+      Assert.IsEqual(value, {
+        model: 'Prius',
+        features: [
+          { isHybrid: true },
+          { isHybrid: false }
+
+        ],
+      })
+    })
+  }
 })

From 573cdb169456b6d0ede981559e2184c6caf601da Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 21 Nov 2023 12:22:00 +0900
Subject: [PATCH 215/369] TypeScript 5.3.2

---
 hammer.mjs        |  2 +-
 package-lock.json | 14 +++++++-------
 package.json      |  2 +-
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/hammer.mjs b/hammer.mjs
index 76e8ea38e..2e02a034e 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -36,7 +36,7 @@ export async function benchmark() {
 // Test
 // -------------------------------------------------------------------------------
 export async function test_typescript() {
-  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', 'next', 'latest']) {
+  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', 'next', 'latest']) {
     await shell(`npm install typescript@${version} --no-save`)
     await test_static()
   }
diff --git a/package-lock.json b/package-lock.json
index a9ffcd256..88740ec7e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -16,7 +16,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^9.2.2",
         "prettier": "^2.7.1",
-        "typescript": "^5.2.2"
+        "typescript": "^5.3.2"
       }
     },
     "node_modules/@esbuild/linux-loong64": {
@@ -1317,9 +1317,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.2.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.2.2.tgz",
-      "integrity": "sha512-mI4WrpHsbCIcwT9cF4FZvr80QUeKvsUsUvKDoR+X/7XHQH98xYD8YHZg7ANtz2GtZt/CBq2QJ0thkGJMHfqc1w==",
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.2.tgz",
+      "integrity": "sha512-6l+RyNy7oAHDfxC4FzSJcz9vnjTKxrLpDG5M2Vu4SHRVNg6xzqZp6LYSR9zjqQTu8DU/f5xwxUdADOkbrIX2gQ==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -2279,9 +2279,9 @@
       }
     },
     "typescript": {
-      "version": "5.2.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.2.2.tgz",
-      "integrity": "sha512-mI4WrpHsbCIcwT9cF4FZvr80QUeKvsUsUvKDoR+X/7XHQH98xYD8YHZg7ANtz2GtZt/CBq2QJ0thkGJMHfqc1w==",
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.2.tgz",
+      "integrity": "sha512-6l+RyNy7oAHDfxC4FzSJcz9vnjTKxrLpDG5M2Vu4SHRVNg6xzqZp6LYSR9zjqQTu8DU/f5xwxUdADOkbrIX2gQ==",
       "dev": true
     },
     "uri-js": {
diff --git a/package.json b/package.json
index 04d98e936..064dc20a4 100644
--- a/package.json
+++ b/package.json
@@ -59,6 +59,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^5.2.2"
+    "typescript": "^5.3.2"
   }
 }

From ca4000cc9a4e0343f764ef65113ba62928f5cf0d Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 22 Dec 2023 14:00:46 +0900
Subject: [PATCH 216/369] Revision 0.32.0 (#689)

---
 .github/workflows/build.yml                   |    2 +-
 .github/workflows/nightly.yml                 |    2 +-
 benchmark/measurement/index.ts                |    5 -
 changelog/0.24.6.md                           |    2 +-
 changelog/0.32.0.md                           |  473 +++
 example/annotation/annotation.ts              |  148 +
 example/annotation/index.ts                   |    1 +
 {examples => example}/collections/array.ts    |    0
 {examples => example}/collections/index.ts    |    0
 {examples => example}/collections/map.ts      |    0
 {examples => example}/collections/readme.md   |    0
 {examples => example}/collections/set.ts      |    0
 {examples => example}/formats/date-time.ts    |    0
 {examples => example}/formats/date.ts         |    0
 {examples => example}/formats/email.ts        |    0
 {examples => example}/formats/index.ts        |    0
 {examples => example}/formats/ipv4.ts         |    0
 {examples => example}/formats/ipv6.ts         |    0
 {examples => example}/formats/time.ts         |    0
 {examples => example}/formats/url.ts          |    0
 {examples => example}/formats/uuid.ts         |    0
 {examples => example}/index.ts                |    0
 {examples => example}/prototypes/evaluate.ts  |   23 +-
 {examples => example}/prototypes/index.ts     |    1 -
 .../prototypes/partial-deep.ts                |   15 +-
 {examples => example}/prototypes/readme.md    |    0
 .../prototypes/union-enum.ts                  |    0
 .../prototypes/union-oneof.ts                 |    0
 {examples => example}/typedef/index.ts        |    0
 {examples => example}/typedef/readme.md       |    0
 {examples => example}/typedef/typedef.ts      |   53 +-
 examples/trpc/readme.md                       |   46 -
 hammer.mjs                                    |   46 +-
 license                                       |    4 +-
 package-lock.json                             |  623 ++-
 package.json                                  |   36 +-
 readme.md                                     |  803 ++--
 src/compiler/compiler.ts                      |  334 +-
 src/compiler/index.ts                         |    2 +-
 src/errors/errors.ts                          |  264 +-
 src/errors/function.ts                        |  193 +
 src/errors/index.ts                           |    3 +-
 src/index.ts                                  |  117 +
 src/system/index.ts                           |    4 +-
 src/system/policy.ts                          |   67 +
 src/system/system.ts                          |  225 +-
 src/tsconfig.json                             |    2 +-
 src/type/any/any.ts                           |   40 +
 src/type/any/index.ts                         |   29 +
 src/type/array/array.ts                       |   62 +
 src/type/array/index.ts                       |   29 +
 src/type/async-iterator/async-iterator.ts     |   48 +
 src/type/async-iterator/index.ts              |   29 +
 src/type/awaited/awaited.ts                   |  105 +
 src/type/awaited/index.ts                     |   29 +
 src/type/bigint/bigint.ts                     |   51 +
 src/type/bigint/index.ts                      |   29 +
 src/type/boolean/boolean.ts                   |   44 +
 src/type/boolean/index.ts                     |   29 +
 src/type/clone/index.ts                       |   30 +
 src/type/clone/type.ts                        |   39 +
 src/type/clone/value.ts                       |   62 +
 src/type/composite/composite.ts               |   75 +
 src/type/composite/index.ts                   |   29 +
 src/type/const/const.ts                       |  135 +
 src/type/const/index.ts                       |   29 +
 .../constructor-parameters.ts                 |   46 +
 src/type/constructor-parameters/index.ts      |   29 +
 src/type/constructor/constructor.ts           |   67 +
 src/type/constructor/index.ts                 |   29 +
 src/type/date/date.ts                         |   56 +
 src/type/date/index.ts                        |   29 +
 src/type/deref/deref.ts                       |  174 +
 src/type/deref/index.ts                       |   29 +
 src/type/discard/discard.ts                   |   35 +
 src/type/discard/index.ts                     |   29 +
 src/type/enum/enum.ts                         |   58 +
 src/type/enum/index.ts                        |   29 +
 src/type/error/error.ts                       |   34 +
 src/type/error/index.ts                       |   29 +
 .../exclude/exclude-from-mapped-result.ts     |   89 +
 src/type/exclude/exclude.ts                   |   96 +
 src/type/exclude/index.ts                     |   30 +
 src/type/extends/extends-check.ts             |  776 ++++
 src/type/extends/extends-from-mapped-key.ts   |  129 +
 .../extends/extends-from-mapped-result.ts     |  101 +
 src/type/extends/extends-undefined.ts         |   55 +
 src/type/extends/extends.ts                   |   80 +
 src/type/extends/index.ts                     |   33 +
 .../extract/extract-from-mapped-result.ts     |   89 +
 src/type/extract/extract.ts                   |   94 +
 src/type/extract/index.ts                     |   30 +
 src/type/function/function.ts                 |   67 +
 src/type/function/index.ts                    |   29 +
 src/type/guard/index.ts                       |   30 +
 src/type/guard/type.ts                        |  618 +++
 src/type/guard/value.ts                       |   88 +
 src/type/helpers/helpers.ts                   |   69 +
 src/type/helpers/index.ts                     |   29 +
 src/type/index.ts                             |   98 +
 src/type/indexed/index.ts                     |   32 +
 src/type/indexed/indexed-from-mapped-key.ts   |  103 +
 .../indexed/indexed-from-mapped-result.ts     |   90 +
 src/type/indexed/indexed-property-keys.ts     |  103 +
 src/type/indexed/indexed.ts                   |  241 ++
 src/type/instance-type/index.ts               |   29 +
 src/type/instance-type/instance-type.ts       |   38 +
 src/type/integer/index.ts                     |   29 +
 src/type/integer/integer.ts                   |   51 +
 src/type/intersect/index.ts                   |   31 +
 src/type/intersect/intersect-create.ts        |   52 +
 src/type/intersect/intersect-evaluated.ts     |  127 +
 .../type/intersect/intersect-type.ts          |   55 +-
 src/type/intersect/intersect.ts               |   55 +
 src/type/intrinsic/capitalize.ts              |   37 +
 src/type/intrinsic/index.ts                   |   34 +
 .../intrinsic/intrinsic-from-mapped-key.ts    |  113 +
 src/type/intrinsic/intrinsic.ts               |  148 +
 src/type/intrinsic/lowercase.ts               |   37 +
 src/type/intrinsic/uncapitalize.ts            |   37 +
 src/type/intrinsic/uppercase.ts               |   37 +
 src/type/iterator/index.ts                    |   29 +
 src/type/iterator/iterator.ts                 |   48 +
 src/type/keyof/index.ts                       |   31 +
 src/type/keyof/keyof-from-mapped-result.ts    |   83 +
 src/type/keyof/keyof-property-keys.ts         |  176 +
 src/type/keyof/keyof.ts                       |   85 +
 src/type/literal/index.ts                     |   29 +
 src/type/literal/literal.ts                   |   53 +
 src/type/mapped/index.ts                      |   31 +
 src/type/mapped/mapped-key.ts                 |   43 +
 src/type/mapped/mapped-result.ts              |   44 +
 src/type/mapped/mapped.ts                     |  283 ++
 src/type/never/index.ts                       |   28 +
 src/type/never/never.ts                       |   44 +
 src/type/not/index.ts                         |   29 +
 src/type/not/not.ts                           |   46 +
 src/type/null/index.ts                        |   29 +
 src/type/null/null.ts                         |   44 +
 src/type/number/index.ts                      |   29 +
 src/type/number/number.ts                     |   51 +
 src/type/object/index.ts                      |   29 +
 src/type/object/object.ts                     |   99 +
 src/type/omit/index.ts                        |   31 +
 src/type/omit/omit-from-mapped-key.ts         |  111 +
 src/type/omit/omit-from-mapped-result.ts      |   89 +
 src/type/omit/omit.ts                         |  132 +
 src/type/optional/index.ts                    |   30 +
 .../optional/optional-from-mapped-result.ts   |   88 +
 src/type/optional/optional.ts                 |   82 +
 src/type/parameters/index.ts                  |   29 +
 src/type/parameters/parameters.ts             |   43 +
 src/type/partial/index.ts                     |   30 +
 .../partial/partial-from-mapped-result.ts     |   83 +
 src/type/partial/partial.ts                   |  114 +
 src/type/patterns/index.ts                    |   29 +
 src/type/patterns/patterns.ts                 |   34 +
 src/type/pick/index.ts                        |   31 +
 src/type/pick/pick-from-mapped-key.ts         |  111 +
 src/type/pick/pick-from-mapped-result.ts      |   89 +
 src/type/pick/pick.ts                         |  122 +
 src/type/promise/index.ts                     |   29 +
 src/type/promise/promise.ts                   |   48 +
 src/type/readonly-optional/index.ts           |   29 +
 .../readonly-optional/readonly-optional.ts    |   38 +
 src/type/readonly/index.ts                    |   30 +
 .../readonly/readonly-from-mapped-result.ts   |   88 +
 src/type/readonly/readonly.ts                 |   82 +
 src/type/record/index.ts                      |   29 +
 src/type/record/record.ts                     |  224 ++
 src/type/recursive/index.ts                   |   29 +
 src/type/recursive/recursive.ts               |   63 +
 src/type/ref/index.ts                         |   29 +
 src/type/ref/ref.ts                           |   57 +
 src/type/regexp/index.ts                      |   29 +
 src/type/regexp/regexp.ts                     |   50 +
 src/type/registry/format.ts                   |   55 +
 src/type/registry/index.ts                    |   30 +
 src/type/registry/type.ts                     |   56 +
 src/type/required/index.ts                    |   30 +
 .../required/required-from-mapped-result.ts   |   83 +
 src/type/required/required.ts                 |  118 +
 src/type/rest/index.ts                        |   29 +
 src/type/rest/rest.ts                         |   65 +
 src/type/return-type/index.ts                 |   29 +
 src/type/return-type/return-type.ts           |   38 +
 src/type/schema/anyschema.ts                  |   97 +
 src/type/schema/index.ts                      |   30 +
 src/type/schema/schema.ts                     |   58 +
 src/type/sets/index.ts                        |   29 +
 src/type/sets/set.ts                          |  147 +
 src/type/static/index.ts                      |   29 +
 src/type/static/static.ts                     |   93 +
 src/type/strict/index.ts                      |   29 +
 src/type/strict/strict.ts                     |   34 +
 src/type/string/index.ts                      |   29 +
 src/type/string/string.ts                     |   86 +
 src/type/symbol/index.ts                      |   29 +
 src/type/symbol/symbol.ts                     |   41 +
 src/type/symbols/index.ts                     |   29 +
 src/type/symbols/symbols.ts                   |   38 +
 src/type/template-literal/finite.ts           |  119 +
 src/type/template-literal/generate.ts         |  148 +
 src/type/template-literal/index.ts            |   35 +
 src/type/template-literal/parse.ts            |  167 +
 src/type/template-literal/pattern.ts          |   77 +
 src/type/template-literal/syntax.ts           |  117 +
 src/type/template-literal/template-literal.ts |  102 +
 src/type/template-literal/union.ts            |   44 +
 src/type/transform/index.ts                   |   29 +
 src/type/transform/transform.ts               |   88 +
 src/type/tuple/index.ts                       |   29 +
 src/type/tuple/tuple.ts                       |   64 +
 src/type/type/index.ts                        |   43 +
 src/type/type/javascript.ts                   |  123 +
 src/type/type/json.ts                         |  338 ++
 src/type/type/type.ts                         |   89 +
 src/type/uint8array/index.ts                  |   29 +
 src/type/uint8array/uint8array.ts             |   44 +
 src/type/undefined/index.ts                   |   29 +
 src/type/undefined/undefined.ts               |   40 +
 src/type/union/index.ts                       |   31 +
 src/type/union/union-create.ts                |   36 +
 src/type/union/union-evaluated.ts             |  122 +
 src/type/union/union-type.ts                  |   48 +
 src/type/union/union.ts                       |   49 +
 src/type/unknown/index.ts                     |   29 +
 src/type/unknown/unknown.ts                   |   42 +
 src/type/unsafe/index.ts                      |   29 +
 src/type/unsafe/unsafe.ts                     |   45 +
 src/type/void/index.ts                        |   29 +
 src/type/void/void.ts                         |   44 +
 src/typebox.ts                                | 3410 -----------------
 src/value/{ => cast}/cast.ts                  |  230 +-
 src/value/cast/index.ts                       |   29 +
 src/value/{ => check}/check.ts                |  243 +-
 src/value/check/index.ts                      |   29 +
 src/value/clean/clean.ts                      |  184 +
 src/value/clean/index.ts                      |   29 +
 src/value/{ => clone}/clone.ts                |   15 +-
 src/value/clone/index.ts                      |   29 +
 src/value/{ => convert}/convert.ts            |  277 +-
 src/value/convert/index.ts                    |   29 +
 src/value/{ => create}/create.ts              |  280 +-
 src/value/create/index.ts                     |   29 +
 src/value/default/default.ts                  |  185 +
 src/value/default/index.ts                    |   29 +
 src/value/{ => delta}/delta.ts                |   99 +-
 src/value/delta/index.ts                      |   29 +
 src/value/{ => deref}/deref.ts                |    5 +-
 src/value/deref/index.ts                      |   29 +
 src/value/{ => equal}/equal.ts                |   12 +-
 src/value/equal/index.ts                      |   29 +
 src/value/{ => guard}/guard.ts                |    4 +-
 src/value/guard/index.ts                      |   29 +
 src/value/{ => hash}/hash.ts                  |   31 +-
 src/value/hash/index.ts                       |   29 +
 src/value/index.ts                            |   56 +-
 src/value/mutate/index.ts                     |   29 +
 src/value/{ => mutate}/mutate.ts              |   42 +-
 src/value/pointer.ts                          |  121 -
 src/value/pointer/index.ts                    |   29 +
 src/value/pointer/pointer.ts                  |  127 +
 src/value/transform.ts                        |  439 ---
 src/value/transform/decode.ts                 |  216 ++
 src/value/transform/encode.ts                 |  223 ++
 src/value/transform/has.ts                    |  167 +
 src/value/transform/index.ts                  |   31 +
 src/value/value.ts                            |  129 -
 src/value/value/index.ts                      |   29 +
 src/value/value/value.ts                      |  146 +
 .../benchmark}/compression/index.ts           |    6 +-
 .../compression/module/typebox-compiler.ts    |    0
 .../compression/module/typebox-errors.ts      |    0
 .../compression/module/typebox-system.ts      |    0
 .../compression/module/typebox-value.ts       |    0
 .../benchmark}/compression/module/typebox.ts  |    0
 {benchmark => task/benchmark}/index.ts        |    0
 task/benchmark/measurement/index.ts           |    5 +
 .../measurement/module/benchmark.ts           |    0
 .../benchmark}/measurement/module/cases.ts    |    2 +-
 .../benchmark}/measurement/module/check.ts    |    2 +-
 .../benchmark}/measurement/module/compile.ts  |    2 +-
 .../benchmark}/measurement/module/index.ts    |    0
 .../benchmark}/measurement/module/result.ts   |    0
 task/build/common/remove-notices.ts           |   82 +
 task/build/import/build.ts                    |   40 +
 task/build/import/compile.ts                  |   40 +
 task/build/import/convert-to-esm.ts           |  110 +
 task/build/index.ts                           |   31 +
 task/build/redirect/build.ts                  |   38 +
 task/build/redirect/create-package-json.ts    |   96 +
 task/build/redirect/create-redirect-paths.ts  |   51 +
 task/build/require/build.ts                   |   38 +
 task/build/require/compile.ts                 |   40 +
 test/runtime/assert/assert.ts                 |    6 +-
 test/runtime/compiler-ajv/const.ts            |   39 +
 test/runtime/compiler-ajv/index.ts            |    3 +-
 test/runtime/compiler-ajv/partial.ts          |   14 +-
 test/runtime/compiler-ajv/required.ts         |   10 +-
 test/runtime/compiler-ajv/string-pattern.ts   |   65 +
 test/runtime/compiler-ajv/validate.ts         |   14 +-
 test/runtime/compiler/const.ts                |   39 +
 test/runtime/compiler/index.ts                |    2 +
 test/runtime/compiler/partial.ts              |   14 +-
 test/runtime/compiler/regexp.ts               |   63 +-
 test/runtime/compiler/required.ts             |   10 +-
 .../regexp.ts => compiler/string-pattern.ts}  |   18 +-
 test/runtime/errors/types/index.ts            |    1 +
 test/runtime/errors/types/regexp.ts           |   17 +
 test/runtime/type/extends/any.ts              |   75 +-
 test/runtime/type/extends/array.ts            |  203 +-
 test/runtime/type/extends/async-iterator.ts   |   51 +-
 test/runtime/type/extends/bigint.ts           |   79 +-
 test/runtime/type/extends/boolean.ts          |   71 +-
 test/runtime/type/extends/constructor.ts      |  167 +-
 test/runtime/type/extends/date.ts             |   75 +-
 test/runtime/type/extends/function.ts         |  167 +-
 test/runtime/type/extends/index.ts            |    1 +
 test/runtime/type/extends/integer.ts          |   75 +-
 test/runtime/type/extends/iterator.ts         |   51 +-
 test/runtime/type/extends/literal.ts          |  203 +-
 test/runtime/type/extends/not.ts              |  103 +-
 test/runtime/type/extends/null.ts             |   79 +-
 test/runtime/type/extends/number.ts           |   75 +-
 test/runtime/type/extends/object.ts           |  135 +-
 test/runtime/type/extends/promise.ts          |  159 +-
 test/runtime/type/extends/record.ts           |  131 +-
 test/runtime/type/extends/regexp.ts           |  113 +
 test/runtime/type/extends/string.ts           |   87 +-
 test/runtime/type/extends/symbol.ts           |   83 +-
 test/runtime/type/extends/template-literal.ts |  123 +-
 test/runtime/type/extends/tuple.ts            |  127 +-
 test/runtime/type/extends/uint8array.ts       |   75 +-
 test/runtime/type/extends/undefined.ts        |   71 +-
 test/runtime/type/extends/union.ts            |  107 +-
 test/runtime/type/extends/unknown.ts          |   79 +-
 test/runtime/type/extends/void.ts             |   83 +-
 test/runtime/type/guard/any.ts                |    6 +-
 test/runtime/type/guard/array.ts              |   16 +-
 test/runtime/type/guard/async-iterator.ts     |    6 +-
 test/runtime/type/guard/awaited.ts            |   22 +-
 test/runtime/type/guard/bigint.ts             |    6 +-
 test/runtime/type/guard/boolean.ts            |    6 +-
 test/runtime/type/guard/capitalize.ts         |   10 +-
 test/runtime/type/guard/composite.ts          |   18 +-
 test/runtime/type/guard/const.ts              |  124 +
 test/runtime/type/guard/constructor.ts        |   14 +-
 test/runtime/type/guard/date.ts               |   16 +-
 test/runtime/type/guard/deref.ts              |  110 +
 test/runtime/type/guard/enum.ts               |   24 +-
 test/runtime/type/guard/exclude.ts            |   18 +-
 test/runtime/type/guard/extract.ts            |   12 +-
 test/runtime/type/guard/function.ts           |   14 +-
 test/runtime/type/guard/index.ts              |    4 +
 test/runtime/type/guard/indexed.ts            |  169 +-
 test/runtime/type/guard/integer.ts            |   16 +-
 test/runtime/type/guard/intersect.ts          |    4 +-
 test/runtime/type/guard/iterator.ts           |    6 +-
 test/runtime/type/guard/keyof.ts              |   28 +-
 test/runtime/type/guard/kind.ts               |    4 +-
 test/runtime/type/guard/literal.ts            |   12 +-
 test/runtime/type/guard/lowercase.ts          |   10 +-
 test/runtime/type/guard/mapped.ts             |  609 +++
 test/runtime/type/guard/not.ts                |    6 +-
 test/runtime/type/guard/null.ts               |    6 +-
 test/runtime/type/guard/number.ts             |   16 +-
 test/runtime/type/guard/object.ts             |   20 +-
 test/runtime/type/guard/omit.ts               |   14 +-
 test/runtime/type/guard/partial.ts            |    6 +-
 test/runtime/type/guard/pick.ts               |   24 +-
 test/runtime/type/guard/promise.ts            |   10 +-
 test/runtime/type/guard/record.ts             |   70 +-
 test/runtime/type/guard/recursive.ts          |    8 +-
 test/runtime/type/guard/ref.ts                |    6 +-
 test/runtime/type/guard/regexp.ts             |   23 +
 test/runtime/type/guard/required.ts           |    6 +-
 test/runtime/type/guard/rest.ts               |   24 +-
 test/runtime/type/guard/string.ts             |   12 +-
 test/runtime/type/guard/symbol.ts             |    6 +-
 test/runtime/type/guard/template-literal.ts   |   18 +-
 test/runtime/type/guard/this.ts               |    4 +-
 test/runtime/type/guard/tuple.ts              |    8 +-
 test/runtime/type/guard/uint8array.ts         |   10 +-
 test/runtime/type/guard/uncapitalize.ts       |   10 +-
 test/runtime/type/guard/undefined.ts          |    6 +-
 test/runtime/type/guard/union.ts              |   24 +-
 test/runtime/type/guard/unknown.ts            |    6 +-
 test/runtime/type/guard/unsafe.ts             |   10 +-
 test/runtime/type/guard/uppercase.ts          |   10 +-
 test/runtime/type/guard/void.ts               |    6 +-
 test/runtime/type/index.ts                    |    2 +-
 test/runtime/type/intrinsic/intrinsic.ts      |  109 +-
 test/runtime/type/normalize/exclude.ts        |    6 +-
 test/runtime/type/normalize/extract.ts        |   10 +-
 test/runtime/type/normalize/indexed.ts        |   96 +-
 test/runtime/type/normalize/intersect.ts      |    6 +-
 test/runtime/type/normalize/record.ts         |    2 +-
 test/runtime/type/normalize/union.ts          |    6 +-
 test/runtime/type/template-literal/finite.ts  |   71 +
 .../runtime/type/template-literal/generate.ts |  199 +
 .../{template => template-literal}/index.ts   |    2 +-
 .../parser.ts => template-literal/parse.ts}   |   82 +-
 .../{template => template-literal}/pattern.ts |    2 +-
 test/runtime/type/template/finite.ts          |   71 -
 test/runtime/type/template/generate.ts        |  199 -
 test/runtime/type/value/guard.ts              |   78 +
 test/runtime/value/cast/regexp.ts             |    7 +
 test/runtime/value/check/const.ts             |   42 +
 test/runtime/value/check/index.ts             |    1 +
 test/runtime/value/clean/any.ts               |   11 +
 test/runtime/value/clean/array.ts             |   21 +
 test/runtime/value/clean/async-iterator.ts    |   11 +
 test/runtime/value/clean/bigint.ts            |   11 +
 test/runtime/value/clean/boolean.ts           |   11 +
 test/runtime/value/clean/composite.ts         |   11 +
 test/runtime/value/clean/constructor.ts       |   11 +
 test/runtime/value/clean/date.ts              |   11 +
 test/runtime/value/clean/enum.ts              |   11 +
 test/runtime/value/clean/function.ts          |   11 +
 test/runtime/value/clean/index.ts             |   34 +
 test/runtime/value/clean/integer.ts           |   11 +
 test/runtime/value/clean/intersect.ts         |  346 ++
 test/runtime/value/clean/iterator.ts          |   11 +
 test/runtime/value/clean/keyof.ts             |   11 +
 test/runtime/value/clean/kind.ts              |   11 +
 test/runtime/value/clean/literal.ts           |   11 +
 test/runtime/value/clean/never.ts             |   11 +
 test/runtime/value/clean/not.ts               |   11 +
 test/runtime/value/clean/null.ts              |   11 +
 test/runtime/value/clean/number.ts            |   11 +
 test/runtime/value/clean/object.ts            |  178 +
 test/runtime/value/clean/promise.ts           |   11 +
 test/runtime/value/clean/record.ts            |  114 +
 test/runtime/value/clean/recursive.ts         |  112 +
 test/runtime/value/clean/ref.ts               |   78 +
 test/runtime/value/clean/regexp.ts            |   11 +
 test/runtime/value/clean/string.ts            |   11 +
 test/runtime/value/clean/symbol.ts            |   11 +
 test/runtime/value/clean/template-literal.ts  |   11 +
 test/runtime/value/clean/tuple.ts             |  110 +
 test/runtime/value/clean/uint8array.ts        |   11 +
 test/runtime/value/clean/undefined.ts         |   11 +
 test/runtime/value/clean/union.ts             |  134 +
 test/runtime/value/clean/unknown.ts           |   11 +
 test/runtime/value/clean/void.ts              |   11 +
 test/runtime/value/create/regexp.ts           |    7 +
 test/runtime/value/default/any.ts             |   16 +
 test/runtime/value/default/array.ts           |   24 +
 test/runtime/value/default/async-iterator.ts  |   16 +
 test/runtime/value/default/bigint.ts          |   16 +
 test/runtime/value/default/boolean.ts         |   16 +
 test/runtime/value/default/composite.ts       |   16 +
 test/runtime/value/default/constructor.ts     |   16 +
 test/runtime/value/default/date.ts            |   16 +
 test/runtime/value/default/enum.ts            |   16 +
 test/runtime/value/default/function.ts        |   16 +
 test/runtime/value/default/index.ts           |   35 +
 test/runtime/value/default/integer.ts         |   16 +
 test/runtime/value/default/intersect.ts       |  106 +
 test/runtime/value/default/iterator.ts        |   16 +
 test/runtime/value/default/keyof.ts           |   16 +
 test/runtime/value/default/kind.ts            |   16 +
 test/runtime/value/default/literal.ts         |   16 +
 test/runtime/value/default/never.ts           |   16 +
 test/runtime/value/default/not.ts             |   16 +
 test/runtime/value/default/null.ts            |   16 +
 test/runtime/value/default/number.ts          |   16 +
 test/runtime/value/default/object.ts          |  180 +
 test/runtime/value/default/promise.ts         |   16 +
 test/runtime/value/default/record.ts          |   66 +
 test/runtime/value/default/recursive.ts       |   58 +
 test/runtime/value/default/ref.ts             |   33 +
 test/runtime/value/default/regexp.ts          |   16 +
 test/runtime/value/default/string.ts          |   16 +
 test/runtime/value/default/symbol.ts          |   16 +
 .../runtime/value/default/template-literal.ts |   16 +
 test/runtime/value/default/tuple.ts           |   44 +
 test/runtime/value/default/uint8array.ts      |   16 +
 test/runtime/value/default/undefined.ts       |   16 +
 test/runtime/value/default/union.ts           |  110 +
 test/runtime/value/default/unknown.ts         |   16 +
 test/runtime/value/default/void.ts            |   16 +
 test/runtime/value/guard/guard.ts             |    2 +-
 test/runtime/value/hash/hash.ts               |  108 +-
 test/runtime/value/index.ts                   |    2 +
 test/runtime/value/transform/_encoder.ts      |    2 +-
 test/runtime/value/transform/union.ts         |   43 +-
 test/static/assert.ts                         |   41 +-
 test/static/const.ts                          |   41 +
 test/static/deref.ts                          |   56 +
 test/static/index.ts                          |    3 +
 test/static/indexed.ts                        |   25 +-
 test/static/mapped.ts                         |  404 ++
 test/static/optional.ts                       |   35 +
 test/static/readonly.ts                       |   36 +
 test/static/record.ts                         |    3 +-
 test/static/template-literal.ts               |    7 +
 test/static/transform.ts                      |   12 +-
 test/static/union.ts                          |   33 +
 tsconfig.json                                 |   64 +-
 501 files changed, 25083 insertions(+), 8133 deletions(-)
 delete mode 100644 benchmark/measurement/index.ts
 create mode 100644 changelog/0.32.0.md
 create mode 100644 example/annotation/annotation.ts
 create mode 100644 example/annotation/index.ts
 rename {examples => example}/collections/array.ts (100%)
 rename {examples => example}/collections/index.ts (100%)
 rename {examples => example}/collections/map.ts (100%)
 rename {examples => example}/collections/readme.md (100%)
 rename {examples => example}/collections/set.ts (100%)
 rename {examples => example}/formats/date-time.ts (100%)
 rename {examples => example}/formats/date.ts (100%)
 rename {examples => example}/formats/email.ts (100%)
 rename {examples => example}/formats/index.ts (100%)
 rename {examples => example}/formats/ipv4.ts (100%)
 rename {examples => example}/formats/ipv6.ts (100%)
 rename {examples => example}/formats/time.ts (100%)
 rename {examples => example}/formats/url.ts (100%)
 rename {examples => example}/formats/uuid.ts (100%)
 rename {examples => example}/index.ts (100%)
 rename {examples => example}/prototypes/evaluate.ts (82%)
 rename {examples => example}/prototypes/index.ts (98%)
 rename {examples => example}/prototypes/partial-deep.ts (84%)
 rename {examples => example}/prototypes/readme.md (100%)
 rename {examples => example}/prototypes/union-enum.ts (100%)
 rename {examples => example}/prototypes/union-oneof.ts (100%)
 rename {examples => example}/typedef/index.ts (100%)
 rename {examples => example}/typedef/readme.md (100%)
 rename {examples => example}/typedef/typedef.ts (93%)
 delete mode 100644 examples/trpc/readme.md
 create mode 100644 src/errors/function.ts
 create mode 100644 src/index.ts
 create mode 100644 src/system/policy.ts
 create mode 100644 src/type/any/any.ts
 create mode 100644 src/type/any/index.ts
 create mode 100644 src/type/array/array.ts
 create mode 100644 src/type/array/index.ts
 create mode 100644 src/type/async-iterator/async-iterator.ts
 create mode 100644 src/type/async-iterator/index.ts
 create mode 100644 src/type/awaited/awaited.ts
 create mode 100644 src/type/awaited/index.ts
 create mode 100644 src/type/bigint/bigint.ts
 create mode 100644 src/type/bigint/index.ts
 create mode 100644 src/type/boolean/boolean.ts
 create mode 100644 src/type/boolean/index.ts
 create mode 100644 src/type/clone/index.ts
 create mode 100644 src/type/clone/type.ts
 create mode 100644 src/type/clone/value.ts
 create mode 100644 src/type/composite/composite.ts
 create mode 100644 src/type/composite/index.ts
 create mode 100644 src/type/const/const.ts
 create mode 100644 src/type/const/index.ts
 create mode 100644 src/type/constructor-parameters/constructor-parameters.ts
 create mode 100644 src/type/constructor-parameters/index.ts
 create mode 100644 src/type/constructor/constructor.ts
 create mode 100644 src/type/constructor/index.ts
 create mode 100644 src/type/date/date.ts
 create mode 100644 src/type/date/index.ts
 create mode 100644 src/type/deref/deref.ts
 create mode 100644 src/type/deref/index.ts
 create mode 100644 src/type/discard/discard.ts
 create mode 100644 src/type/discard/index.ts
 create mode 100644 src/type/enum/enum.ts
 create mode 100644 src/type/enum/index.ts
 create mode 100644 src/type/error/error.ts
 create mode 100644 src/type/error/index.ts
 create mode 100644 src/type/exclude/exclude-from-mapped-result.ts
 create mode 100644 src/type/exclude/exclude.ts
 create mode 100644 src/type/exclude/index.ts
 create mode 100644 src/type/extends/extends-check.ts
 create mode 100644 src/type/extends/extends-from-mapped-key.ts
 create mode 100644 src/type/extends/extends-from-mapped-result.ts
 create mode 100644 src/type/extends/extends-undefined.ts
 create mode 100644 src/type/extends/extends.ts
 create mode 100644 src/type/extends/index.ts
 create mode 100644 src/type/extract/extract-from-mapped-result.ts
 create mode 100644 src/type/extract/extract.ts
 create mode 100644 src/type/extract/index.ts
 create mode 100644 src/type/function/function.ts
 create mode 100644 src/type/function/index.ts
 create mode 100644 src/type/guard/index.ts
 create mode 100644 src/type/guard/type.ts
 create mode 100644 src/type/guard/value.ts
 create mode 100644 src/type/helpers/helpers.ts
 create mode 100644 src/type/helpers/index.ts
 create mode 100644 src/type/index.ts
 create mode 100644 src/type/indexed/index.ts
 create mode 100644 src/type/indexed/indexed-from-mapped-key.ts
 create mode 100644 src/type/indexed/indexed-from-mapped-result.ts
 create mode 100644 src/type/indexed/indexed-property-keys.ts
 create mode 100644 src/type/indexed/indexed.ts
 create mode 100644 src/type/instance-type/index.ts
 create mode 100644 src/type/instance-type/instance-type.ts
 create mode 100644 src/type/integer/index.ts
 create mode 100644 src/type/integer/integer.ts
 create mode 100644 src/type/intersect/index.ts
 create mode 100644 src/type/intersect/intersect-create.ts
 create mode 100644 src/type/intersect/intersect-evaluated.ts
 rename examples/prototypes/const.ts => src/type/intersect/intersect-type.ts (50%)
 create mode 100644 src/type/intersect/intersect.ts
 create mode 100644 src/type/intrinsic/capitalize.ts
 create mode 100644 src/type/intrinsic/index.ts
 create mode 100644 src/type/intrinsic/intrinsic-from-mapped-key.ts
 create mode 100644 src/type/intrinsic/intrinsic.ts
 create mode 100644 src/type/intrinsic/lowercase.ts
 create mode 100644 src/type/intrinsic/uncapitalize.ts
 create mode 100644 src/type/intrinsic/uppercase.ts
 create mode 100644 src/type/iterator/index.ts
 create mode 100644 src/type/iterator/iterator.ts
 create mode 100644 src/type/keyof/index.ts
 create mode 100644 src/type/keyof/keyof-from-mapped-result.ts
 create mode 100644 src/type/keyof/keyof-property-keys.ts
 create mode 100644 src/type/keyof/keyof.ts
 create mode 100644 src/type/literal/index.ts
 create mode 100644 src/type/literal/literal.ts
 create mode 100644 src/type/mapped/index.ts
 create mode 100644 src/type/mapped/mapped-key.ts
 create mode 100644 src/type/mapped/mapped-result.ts
 create mode 100644 src/type/mapped/mapped.ts
 create mode 100644 src/type/never/index.ts
 create mode 100644 src/type/never/never.ts
 create mode 100644 src/type/not/index.ts
 create mode 100644 src/type/not/not.ts
 create mode 100644 src/type/null/index.ts
 create mode 100644 src/type/null/null.ts
 create mode 100644 src/type/number/index.ts
 create mode 100644 src/type/number/number.ts
 create mode 100644 src/type/object/index.ts
 create mode 100644 src/type/object/object.ts
 create mode 100644 src/type/omit/index.ts
 create mode 100644 src/type/omit/omit-from-mapped-key.ts
 create mode 100644 src/type/omit/omit-from-mapped-result.ts
 create mode 100644 src/type/omit/omit.ts
 create mode 100644 src/type/optional/index.ts
 create mode 100644 src/type/optional/optional-from-mapped-result.ts
 create mode 100644 src/type/optional/optional.ts
 create mode 100644 src/type/parameters/index.ts
 create mode 100644 src/type/parameters/parameters.ts
 create mode 100644 src/type/partial/index.ts
 create mode 100644 src/type/partial/partial-from-mapped-result.ts
 create mode 100644 src/type/partial/partial.ts
 create mode 100644 src/type/patterns/index.ts
 create mode 100644 src/type/patterns/patterns.ts
 create mode 100644 src/type/pick/index.ts
 create mode 100644 src/type/pick/pick-from-mapped-key.ts
 create mode 100644 src/type/pick/pick-from-mapped-result.ts
 create mode 100644 src/type/pick/pick.ts
 create mode 100644 src/type/promise/index.ts
 create mode 100644 src/type/promise/promise.ts
 create mode 100644 src/type/readonly-optional/index.ts
 create mode 100644 src/type/readonly-optional/readonly-optional.ts
 create mode 100644 src/type/readonly/index.ts
 create mode 100644 src/type/readonly/readonly-from-mapped-result.ts
 create mode 100644 src/type/readonly/readonly.ts
 create mode 100644 src/type/record/index.ts
 create mode 100644 src/type/record/record.ts
 create mode 100644 src/type/recursive/index.ts
 create mode 100644 src/type/recursive/recursive.ts
 create mode 100644 src/type/ref/index.ts
 create mode 100644 src/type/ref/ref.ts
 create mode 100644 src/type/regexp/index.ts
 create mode 100644 src/type/regexp/regexp.ts
 create mode 100644 src/type/registry/format.ts
 create mode 100644 src/type/registry/index.ts
 create mode 100644 src/type/registry/type.ts
 create mode 100644 src/type/required/index.ts
 create mode 100644 src/type/required/required-from-mapped-result.ts
 create mode 100644 src/type/required/required.ts
 create mode 100644 src/type/rest/index.ts
 create mode 100644 src/type/rest/rest.ts
 create mode 100644 src/type/return-type/index.ts
 create mode 100644 src/type/return-type/return-type.ts
 create mode 100644 src/type/schema/anyschema.ts
 create mode 100644 src/type/schema/index.ts
 create mode 100644 src/type/schema/schema.ts
 create mode 100644 src/type/sets/index.ts
 create mode 100644 src/type/sets/set.ts
 create mode 100644 src/type/static/index.ts
 create mode 100644 src/type/static/static.ts
 create mode 100644 src/type/strict/index.ts
 create mode 100644 src/type/strict/strict.ts
 create mode 100644 src/type/string/index.ts
 create mode 100644 src/type/string/string.ts
 create mode 100644 src/type/symbol/index.ts
 create mode 100644 src/type/symbol/symbol.ts
 create mode 100644 src/type/symbols/index.ts
 create mode 100644 src/type/symbols/symbols.ts
 create mode 100644 src/type/template-literal/finite.ts
 create mode 100644 src/type/template-literal/generate.ts
 create mode 100644 src/type/template-literal/index.ts
 create mode 100644 src/type/template-literal/parse.ts
 create mode 100644 src/type/template-literal/pattern.ts
 create mode 100644 src/type/template-literal/syntax.ts
 create mode 100644 src/type/template-literal/template-literal.ts
 create mode 100644 src/type/template-literal/union.ts
 create mode 100644 src/type/transform/index.ts
 create mode 100644 src/type/transform/transform.ts
 create mode 100644 src/type/tuple/index.ts
 create mode 100644 src/type/tuple/tuple.ts
 create mode 100644 src/type/type/index.ts
 create mode 100644 src/type/type/javascript.ts
 create mode 100644 src/type/type/json.ts
 create mode 100644 src/type/type/type.ts
 create mode 100644 src/type/uint8array/index.ts
 create mode 100644 src/type/uint8array/uint8array.ts
 create mode 100644 src/type/undefined/index.ts
 create mode 100644 src/type/undefined/undefined.ts
 create mode 100644 src/type/union/index.ts
 create mode 100644 src/type/union/union-create.ts
 create mode 100644 src/type/union/union-evaluated.ts
 create mode 100644 src/type/union/union-type.ts
 create mode 100644 src/type/union/union.ts
 create mode 100644 src/type/unknown/index.ts
 create mode 100644 src/type/unknown/unknown.ts
 create mode 100644 src/type/unsafe/index.ts
 create mode 100644 src/type/unsafe/unsafe.ts
 create mode 100644 src/type/void/index.ts
 create mode 100644 src/type/void/void.ts
 delete mode 100644 src/typebox.ts
 rename src/value/{ => cast}/cast.ts (51%)
 create mode 100644 src/value/cast/index.ts
 rename src/value/{ => check}/check.ts (58%)
 create mode 100644 src/value/check/index.ts
 create mode 100644 src/value/clean/clean.ts
 create mode 100644 src/value/clean/index.ts
 rename src/value/{ => clone}/clone.ts (92%)
 create mode 100644 src/value/clone/index.ts
 rename src/value/{ => convert}/convert.ts (53%)
 create mode 100644 src/value/convert/index.ts
 rename src/value/{ => create}/create.ts (52%)
 create mode 100644 src/value/create/index.ts
 create mode 100644 src/value/default/default.ts
 create mode 100644 src/value/default/index.ts
 rename src/value/{ => delta}/delta.ts (71%)
 create mode 100644 src/value/delta/index.ts
 rename src/value/{ => deref}/deref.ts (89%)
 create mode 100644 src/value/deref/index.ts
 rename src/value/{ => equal}/equal.ts (97%)
 create mode 100644 src/value/equal/index.ts
 rename src/value/{ => guard}/guard.ts (99%)
 create mode 100644 src/value/guard/index.ts
 rename src/value/{ => hash}/hash.ts (95%)
 create mode 100644 src/value/hash/index.ts
 create mode 100644 src/value/mutate/index.ts
 rename src/value/{ => mutate}/mutate.ts (85%)
 delete mode 100644 src/value/pointer.ts
 create mode 100644 src/value/pointer/index.ts
 create mode 100644 src/value/pointer/pointer.ts
 delete mode 100644 src/value/transform.ts
 create mode 100644 src/value/transform/decode.ts
 create mode 100644 src/value/transform/encode.ts
 create mode 100644 src/value/transform/has.ts
 create mode 100644 src/value/transform/index.ts
 delete mode 100644 src/value/value.ts
 create mode 100644 src/value/value/index.ts
 create mode 100644 src/value/value/value.ts
 rename {benchmark => task/benchmark}/compression/index.ts (71%)
 rename {benchmark => task/benchmark}/compression/module/typebox-compiler.ts (100%)
 rename {benchmark => task/benchmark}/compression/module/typebox-errors.ts (100%)
 rename {benchmark => task/benchmark}/compression/module/typebox-system.ts (100%)
 rename {benchmark => task/benchmark}/compression/module/typebox-value.ts (100%)
 rename {benchmark => task/benchmark}/compression/module/typebox.ts (100%)
 rename {benchmark => task/benchmark}/index.ts (100%)
 create mode 100644 task/benchmark/measurement/index.ts
 rename {benchmark => task/benchmark}/measurement/module/benchmark.ts (100%)
 rename {benchmark => task/benchmark}/measurement/module/cases.ts (97%)
 rename {benchmark => task/benchmark}/measurement/module/check.ts (93%)
 rename {benchmark => task/benchmark}/measurement/module/compile.ts (95%)
 rename {benchmark => task/benchmark}/measurement/module/index.ts (100%)
 rename {benchmark => task/benchmark}/measurement/module/result.ts (100%)
 create mode 100644 task/build/common/remove-notices.ts
 create mode 100644 task/build/import/build.ts
 create mode 100644 task/build/import/compile.ts
 create mode 100644 task/build/import/convert-to-esm.ts
 create mode 100644 task/build/index.ts
 create mode 100644 task/build/redirect/build.ts
 create mode 100644 task/build/redirect/create-package-json.ts
 create mode 100644 task/build/redirect/create-redirect-paths.ts
 create mode 100644 task/build/require/build.ts
 create mode 100644 task/build/require/compile.ts
 create mode 100644 test/runtime/compiler-ajv/const.ts
 create mode 100644 test/runtime/compiler-ajv/string-pattern.ts
 create mode 100644 test/runtime/compiler/const.ts
 rename test/runtime/{compiler-ajv/regexp.ts => compiler/string-pattern.ts} (72%)
 create mode 100644 test/runtime/errors/types/regexp.ts
 create mode 100644 test/runtime/type/extends/regexp.ts
 create mode 100644 test/runtime/type/guard/const.ts
 create mode 100644 test/runtime/type/guard/deref.ts
 create mode 100644 test/runtime/type/guard/mapped.ts
 create mode 100644 test/runtime/type/guard/regexp.ts
 create mode 100644 test/runtime/type/template-literal/finite.ts
 create mode 100644 test/runtime/type/template-literal/generate.ts
 rename test/runtime/type/{template => template-literal}/index.ts (76%)
 rename test/runtime/type/{template/parser.ts => template-literal/parse.ts} (82%)
 rename test/runtime/type/{template => template-literal}/pattern.ts (98%)
 delete mode 100644 test/runtime/type/template/finite.ts
 delete mode 100644 test/runtime/type/template/generate.ts
 create mode 100644 test/runtime/value/check/const.ts
 create mode 100644 test/runtime/value/clean/any.ts
 create mode 100644 test/runtime/value/clean/array.ts
 create mode 100644 test/runtime/value/clean/async-iterator.ts
 create mode 100644 test/runtime/value/clean/bigint.ts
 create mode 100644 test/runtime/value/clean/boolean.ts
 create mode 100644 test/runtime/value/clean/composite.ts
 create mode 100644 test/runtime/value/clean/constructor.ts
 create mode 100644 test/runtime/value/clean/date.ts
 create mode 100644 test/runtime/value/clean/enum.ts
 create mode 100644 test/runtime/value/clean/function.ts
 create mode 100644 test/runtime/value/clean/index.ts
 create mode 100644 test/runtime/value/clean/integer.ts
 create mode 100644 test/runtime/value/clean/intersect.ts
 create mode 100644 test/runtime/value/clean/iterator.ts
 create mode 100644 test/runtime/value/clean/keyof.ts
 create mode 100644 test/runtime/value/clean/kind.ts
 create mode 100644 test/runtime/value/clean/literal.ts
 create mode 100644 test/runtime/value/clean/never.ts
 create mode 100644 test/runtime/value/clean/not.ts
 create mode 100644 test/runtime/value/clean/null.ts
 create mode 100644 test/runtime/value/clean/number.ts
 create mode 100644 test/runtime/value/clean/object.ts
 create mode 100644 test/runtime/value/clean/promise.ts
 create mode 100644 test/runtime/value/clean/record.ts
 create mode 100644 test/runtime/value/clean/recursive.ts
 create mode 100644 test/runtime/value/clean/ref.ts
 create mode 100644 test/runtime/value/clean/regexp.ts
 create mode 100644 test/runtime/value/clean/string.ts
 create mode 100644 test/runtime/value/clean/symbol.ts
 create mode 100644 test/runtime/value/clean/template-literal.ts
 create mode 100644 test/runtime/value/clean/tuple.ts
 create mode 100644 test/runtime/value/clean/uint8array.ts
 create mode 100644 test/runtime/value/clean/undefined.ts
 create mode 100644 test/runtime/value/clean/union.ts
 create mode 100644 test/runtime/value/clean/unknown.ts
 create mode 100644 test/runtime/value/clean/void.ts
 create mode 100644 test/runtime/value/default/any.ts
 create mode 100644 test/runtime/value/default/array.ts
 create mode 100644 test/runtime/value/default/async-iterator.ts
 create mode 100644 test/runtime/value/default/bigint.ts
 create mode 100644 test/runtime/value/default/boolean.ts
 create mode 100644 test/runtime/value/default/composite.ts
 create mode 100644 test/runtime/value/default/constructor.ts
 create mode 100644 test/runtime/value/default/date.ts
 create mode 100644 test/runtime/value/default/enum.ts
 create mode 100644 test/runtime/value/default/function.ts
 create mode 100644 test/runtime/value/default/index.ts
 create mode 100644 test/runtime/value/default/integer.ts
 create mode 100644 test/runtime/value/default/intersect.ts
 create mode 100644 test/runtime/value/default/iterator.ts
 create mode 100644 test/runtime/value/default/keyof.ts
 create mode 100644 test/runtime/value/default/kind.ts
 create mode 100644 test/runtime/value/default/literal.ts
 create mode 100644 test/runtime/value/default/never.ts
 create mode 100644 test/runtime/value/default/not.ts
 create mode 100644 test/runtime/value/default/null.ts
 create mode 100644 test/runtime/value/default/number.ts
 create mode 100644 test/runtime/value/default/object.ts
 create mode 100644 test/runtime/value/default/promise.ts
 create mode 100644 test/runtime/value/default/record.ts
 create mode 100644 test/runtime/value/default/recursive.ts
 create mode 100644 test/runtime/value/default/ref.ts
 create mode 100644 test/runtime/value/default/regexp.ts
 create mode 100644 test/runtime/value/default/string.ts
 create mode 100644 test/runtime/value/default/symbol.ts
 create mode 100644 test/runtime/value/default/template-literal.ts
 create mode 100644 test/runtime/value/default/tuple.ts
 create mode 100644 test/runtime/value/default/uint8array.ts
 create mode 100644 test/runtime/value/default/undefined.ts
 create mode 100644 test/runtime/value/default/union.ts
 create mode 100644 test/runtime/value/default/unknown.ts
 create mode 100644 test/runtime/value/default/void.ts
 create mode 100644 test/static/const.ts
 create mode 100644 test/static/deref.ts
 create mode 100644 test/static/mapped.ts

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index e482eb7e1..7d9b21121 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -8,7 +8,7 @@ jobs:
         node: [16.x, 18.x, 20.x]
         os: [ubuntu-latest, windows-latest, macOS-latest]
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Install Node
         uses: actions/setup-node@v3
         with:
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index 7ad6b9d88..d43b3bc2c 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -10,7 +10,7 @@ jobs:
         node: [20.x]
         os: [ubuntu-latest]
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Install Node
         uses: actions/setup-node@v3
         with:
diff --git a/benchmark/measurement/index.ts b/benchmark/measurement/index.ts
deleted file mode 100644
index 6175663af..000000000
--- a/benchmark/measurement/index.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import { shell } from '@sinclair/hammer'
-
-export async function measurement() {
-  await shell(`hammer run benchmark/measurement/module/index.ts --dist target/benchmark/measurement`)
-}
diff --git a/changelog/0.24.6.md b/changelog/0.24.6.md
index 68477e071..b329dec8f 100644
--- a/changelog/0.24.6.md
+++ b/changelog/0.24.6.md
@@ -13,7 +13,7 @@ const T: any = {}                                    // T is any
 
 const { type } = T                                   // unsafe: type is any
 
-if(TypeGuard.TString(T)) {
+if(TypeGuard.IsString(T)) {
     
   const { type } = T                                 // safe: type is 'string'
 }
diff --git a/changelog/0.32.0.md b/changelog/0.32.0.md
new file mode 100644
index 000000000..83a1bddfc
--- /dev/null
+++ b/changelog/0.32.0.md
@@ -0,0 +1,473 @@
+## [0.32.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.32.0)
+
+## Overview
+
+Revision 0.32.0 adds support for ESM and carries out the work necessary to fully modularize the TypeBox type system to enable selective type imports. This revision also adds three new types (Mapped, Const, and Deref), along with two new Value functions (Clean and Default) as well as many enhancements to existing types (Index, KeyOf, RegExp, Optional and Readonly). This revision also carries out many internal optimizations to enhance type inference across all types.
+
+This revision is a milestone revision for the TypeBox project. It has several breaking changes and requires a minor revision.
+
+## Contents
+
+- [Type Imports](#Type-Imports)
+- [Value Function Import](#Value-Function-Imports)
+- [CommonJS and ESM](#CommonJS-and-ESM)
+- [Types](#Types)
+  - [Mapped Type](#Types-Mapped-Type)
+  - [Const Type](#Types-Const-Type)
+  - [Deref Type](#Types-Deref-Type)
+  - [RegExp Type](#Types-RegExp-Type)
+  - [Subtract Modifiers](#Types-Subtract-Modifiers)
+- [Values](#Values)
+  - [Clean Function](#Values-Clean-Function)
+  - [Default Function](#Values-Default-Function)
+- [Errors](#Errors)
+  - [Error Parameter](#Errors-Error-Parameter)
+- [Optimizations](#Optimizations)
+  - [Bundle Size](#Optimizations-Bundle-Size)
+- [Breaking](#Breaking)
+  - [Renamed Symbols](#Breaking-Renamed-Symbols)
+  - [TypeGuard Interface Change](#Breaking-TypeGuard-Interface-Change)
+  - [Value Submodule Imports](#Breaking-Value-Submodule-Imports)
+  - [Error Function](#Breaking-Error-Function)
+  - [RegEx](#Breaking-RegEx)
+
+<a name="Type-Imports"></a>
+
+### Type Imports
+
+Revision 0.32.0 adds the ability to import types individually.
+
+```typescript
+import { Type, type Static } from '@sinclair/typebox'                   // classic   - 37.0 kb minified
+
+import { Object, String, Number, type Static } from '@sinclair/typebox' // selective - 6.5 kb minified
+```
+
+<a name="Value-Function-Imports"></a>
+
+### Value Function Imports
+
+Revision 0.32.0 adds the ability to import value functions from the `/value` module path.
+
+```typescript
+import { Value } from '@sinclair/typebox/value'                         // classic   - 61.5 kb minified
+
+import { Check } from '@sinclair/typebox/value'                         // selective - 18.2 kb minified
+```
+
+### CommonJS and ESM
+
+<a name="CommonJS-and-ESM"></a>
+
+Revision 0.32.0 now publishes both CommonJS and ESM builds of TypeBox. Existing CommonJS users should not be impacted by the addition of ESM. For ESM users however, particularily those using bundlers, it's now possible to benefit from deep tree shake optimizations provided by modern bundler tooling. 
+
+<a name="Types"></a>
+
+## Types
+
+Revision 0.32.0 adds three new types to the type system and makes enhancements to Readonly and Optional modifiers.
+
+<a name="Types-Mapped-Type"></a>
+
+### Mapped Type
+
+Revision 0.32.0 adds the Mapped type which replicates TS [Mapped Types](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html) at runtime. The following shows the syntax comparison between TypeScript and TypeBox.
+
+#### TypeScript
+
+```typescript
+type T = {
+  x: number,
+  y: number,
+  z: number
+}
+
+type M = { [K in keyof T]: T[K] } // a mapped type
+```
+#### TypeBox
+```typescript
+const T = Type.Object({
+  x: Type.Number(),
+  y: Type.Number(),
+  z: Type.Number()
+})
+
+const M = Type.Mapped(Type.KeyOf(T), K => Type.Index(T, K)) // a mapped type
+```
+Mapped types use a functional design to replicate the TypeScript feature. For users interested in this type, it may be helpful to use the [TypeBox Workbench](https://sinclairzx81.github.io/typebox-workbench/) which can generate runtime Mapped types from TypeScript syntax.
+
+<a name="Types-Const-Type"></a>
+
+### Const Type
+
+Revision 0.32.0 adds a new Const type that creates `readonly` types from object, array and primitive literal values. This type analogs the TypeScript `as const` syntax. The following shows general usage.
+
+```typescript
+const A = Type.Const(1 as const)                               // const A: TLiteral<1>
+
+const B = Type.Const([1, 2, 3] as const)                       // const B: TReadonly<TTuple<[
+                                                               //   TLiteral<1>,
+                                                               //   TLiteral<2>,
+                                                               //   TLiteral<3>
+                                                               // ]>>
+
+const C = Type.Const({                                         // const C: TObject<{
+  x: 1,                                                        //  x: TReadonly<TLiteral<1>>,
+  y: 2,                                                        //  y: TReadonly<TLiteral<2>>,
+  z: 3                                                         //  z: TReadonly<TLiteral<3>>,
+} as const)                                                    // }>                                            
+```
+Revision 0.32.0 continues support for TypeScript 4.0, and because of this, the `as const` syntax must be appended to each literal value passed to the Const type. When TypeBox ends support for 4.0, updates will be made to this type to make use of [Const Type Parameters](https://devblogs.microsoft.com/typescript/announcing-typescript-5-0/#const-type-parameters). This update will enable TypeBox to correctly infer the readonly literal type without the need for `as const`.
+
+
+<a name="Types-Deref-Type"></a>
+
+### Deref Type
+
+Revision 0.32.0 adds a new Type.Deref type which can be used to dereference type schematics.
+
+```typescript
+const Vector = Type.Object({                                   // const Vector = {
+  x: Type.Number(),                                            //   type: 'object',
+  y: Type.Number(),                                            //   required: ['x', 'y', 'z'],
+}, { $id: 'Vector' })                                          //   properties: {
+                                                               //     x: { type: 'number' },
+                                                               //     y: { type: 'number' }
+                                                               //   },
+                                                               //   $id: 'Vector'
+                                                               // }
+
+const VectorRef = Type.Ref(Vector)                             // const VectorRef = {
+                                                               //   $ref: 'Vector'
+                                                               // }
+// ... Embedded Reference Type
+
+const Vertex = Type.Object({                                   // const Vertex = {
+  position: VectorRef,                                         //   type: 'object',
+  texcoord: VectorRef,                                         //   required: ['position', 'texcoord'],
+})                                                             //   properties: {
+                                                               //     position: { $ref: 'Vector' },
+                                                               //     texcoord: { $ref: 'Vector' }
+                                                               //   }
+                                                               // }
+
+// ... Dereferenced Embedded Reference Type
+
+const VertexDeref = Type.Deref(Vertex, [Vector])               // const VertexDeref = {
+                                                               //   type: 'object',
+                                                               //   required: ['position', 'texcoord'],
+                                                               //   properties: {
+                                                               //     position: {
+                                                               //       type: 'object',
+                                                               //       required: ['x', 'y', 'z'],
+                                                               //       properties: {
+                                                               //         x: { type: 'number' },
+                                                               //         y: { type: 'number' }
+                                                               //       }
+                                                               //     },
+                                                               //     texcoord: {
+                                                               //       type: 'object',
+                                                               //       required: ['x', 'y', 'z'],
+                                                               //       properties: {
+                                                               //         x: { type: 'number' },
+                                                               //         y: { type: 'number' }
+                                                               //       }
+                                                               //     }
+                                                               //   }
+                                                               // }
+```
+The addition of Deref was prompted by issues composing reference types with mapping types (such as Partial, Required, Pick and Omit) which is generally not supported. Prior to Revision 0.32.0, there was some expectation for users to maintain and dereference types manually. In 0.32.0, users will still need to maintain references, but Deref will offer a more convenient mechanism to normalize reference types prior to composition.
+
+
+<a name="Types-RegExp-Type"></a>
+
+### RegExp Type
+
+Revision 0.32.0 updates RegExp to support the full ECMA 262 regular expression syntax. In previous revisions, this type had been expressed as an alias for `TString` with a `pattern` to try ensure compliance with the [regular expression](https://json-schema.org/understanding-json-schema/reference/regular_expressions) subset supported by Json Schema. In Revision 0.32.0, RegExp is given a new type representation unto itself (named `TRegExp`) which houses both `source` and `flags` properties used to reconstruct a JavaScript regular expression object, making it properly distinct from `TString` and fully supportive of UTF-16.
+
+```typescript
+// Case Insensitive
+
+const T = Type.RegExp(/abc/i)                                  // const T = {
+                                                               //   type: 'RegExp',
+                                                               //   source: 'abc',
+                                                               //   flags: 'i'
+                                                               // }
+
+type T = Static<typeof T>                                      // type T = string
+
+Value.Check(T, 'abc')                                          // ok
+Value.Check(T, 'ABC')                                          // ok
+
+// Extended Syntax
+
+const E = Type.RegExp(/<a?:.+?:\d{18}>|\p{Extended_Pictographic}/gu)
+
+Value.Check(E, '♥️♦️♠️♣️')                                         // ok - emoji supported
+```
+
+The RegExp type can be thought of as a more capable TemplateLiteral that can only reasonably infer as `string`. Additionally, the RegExp inference type of `string` is unique to the other `[JavaScript]` types in that it does not infer as it's named type. The updates to RegExp were prompted by the limitations with Json Schema expressions, and to provide better options for users requiring general Unicode validation support. For Json Schema compliance, the recommendation moving forward will be to use either String with pattern or TemplateLiteral.
+
+```typescript
+const T = Type.String({ pattern: '^(a|b|c)$' })                // Json Schema compliant
+
+const T = Type.TemplateLiteral('${a|b|c}')                     // Json Schema compliant
+
+const T = Type.RegExp(/$(a|b|c)$/)                             // Non Json Schema compliant
+```
+
+<a name="Types-Subtractive-Modifiers"></a>
+
+### Subtract Modifier
+
+Revision 0.32.0 adds new overloads for Readonly and Optional modifiers that enable them to subtract (or remove) that modifier from a type. Both Readonly and Optional now accept an optional secondary boolean argument that if `false`, will remove the modifier.
+
+#### TypeScript
+```typescript
+type T = {
+  x?: number,
+  y?: number
+}
+type M = { [K in keyof T]-?: T[K] } // -? - subtract optional modifier
+```
+#### TypeBox
+```typescript
+const T = Type.Object({
+  x: Type.Optional(Type.Number()),
+  y: Type.Optional(Type.Number())
+})
+const M = Type.Mapped(Type.KeyOf(T), K => {
+  return Type.Optional(Type.Index(T, K), false) // false - subtract optional modifier
+})
+```
+Subtractive modifiers are provided in support of the new Mapped type feature.
+
+<a name="Values"></a>
+
+## Values
+
+Revision 0.32.0 adds two new functions to the Value module.
+
+<a name="Values-Clean-Function"></a>
+
+### Clean Function
+
+Revision 0.32.0 adds a new Clean function that can be used to omit any values unknown to the type. This function will work irrespective of if `additionalProperties` is specified on the type. The Clean function is intended to replicate the functionality of Ajv's `removeAdditional` configuration.
+
+```typescript
+const T = Type.Object({ 
+  x: Type.Number(), 
+  y: Type.Number() 
+})
+
+const X = Value.Clean(T, null)                                  // const 'X = null
+
+const Y = Value.Clean(T, { x: 1 })                              // const 'Y = { x: 1 }
+
+const Z = Value.Clean(T, { x: 1, y: 2, z: 3 })                  // const 'Z = { x: 1, y: 2 }
+```
+
+Note: the Clean function does not check the validity of the value being cleaned, and does not provide assurances that the result will be valid. Its return value is `unknown` and should be checked before use.
+
+<a name="Values-Default-Function"></a>
+
+### Default Function
+
+Revision 0.32.0 adds a new Default function that can be used to add missing values if the type specifies a `default` annotation. This function is intended to replicate Ajv's `useDefaults` functionality.
+
+```typescript
+const T = Type.Object({ 
+  x: Type.Number({ default: 0 }), 
+  y: Type.Number({ default: 0 })
+})
+
+const X = Value.Default(T, null)                               // const 'X = null - non-enumerable
+
+const Y = Value.Default(T, { })                                // const 'Y = { x: 0, y: 0 }
+
+const Z = Value.Default(T, { x: 1 })                           // const 'Z = { x: 1, y: 0 }
+```
+
+The Default function does not check the validity of the value being defaulted, and does not provide assurances that the result will be valid. Its return value is `unknown` and should be checked before use.
+
+<a name="Optimizations"></a>
+
+## Optimizations
+
+Following the work to modularize TypeBox's type system, additional optimizations were carried out across each submodule to only import dependent type infrastructure. This has led to some fairly significant reductions in output sizes across each submodule. The main TypeBox import has increased in size due in part to the new Mapped types feature and other associative types, however selective imports supported on this revision should offer options for users concerned about output bundle size. There will be contined work to optimize the new type system throughout 0.32.0 and subsequent revisions.
+
+The following shows the comparisons between 0.31.0 and 0.32.0.
+
+<a name="Optimizations-Bundle-Size"></a>
+
+```typescript
+// Revision 0.31.0
+
+┌──────────────────────┬────────────┬────────────┬─────────────┐
+│       (index)        │  Compiled  │  Minified  │ Compression │
+├──────────────────────┼────────────┼────────────┼─────────────┤
+│ typebox/compiler     │ '163.6 kb' │ ' 71.6 kb' │  '2.28 x'   │
+│ typebox/errors       │ '113.3 kb' │ ' 50.1 kb' │  '2.26 x'   │
+│ typebox/system       │ ' 83.9 kb' │ ' 37.5 kb' │  '2.24 x'   │
+│ typebox/value        │ '191.1 kb' │ ' 82.3 kb' │  '2.32 x'   │
+│ typebox              │ ' 73.8 kb' │ ' 32.3 kb' │  '2.29 x'   │
+└──────────────────────┴────────────┴────────────┴─────────────┘
+
+//  Revision 0.32.0
+
+┌──────────────────────┬────────────┬────────────┬─────────────┐
+│       (index)        │  Compiled  │  Minified  │ Compression │
+├──────────────────────┼────────────┼────────────┼─────────────┤
+│ typebox/compiler     │ '120.6 kb' │ ' 52.9 kb' │  '2.28 x'   │
+│ typebox/errors       │ ' 55.7 kb' │ ' 25.5 kb' │  '2.19 x'   │
+│ typebox/system       │ '  4.7 kb' │ '  2.0 kb' │  '2.33 x'   │
+│ typebox/value        │ '146.2 kb' │ ' 62.0 kb' │  '2.36 x'   │
+│ typebox              │ ' 91.4 kb' │ ' 37.8 kb' │  '2.42 x'   │
+└──────────────────────┴────────────┴────────────┴─────────────┘
+```
+<a name="Errors"></a>
+
+## Errors
+
+Revision 0.32.0 makes some enhancements to errors.
+
+<a name="Errors-Error-Parameter"></a>
+
+### Error Parameter
+
+Revision 0.32.0 updates TypeBox's ErrorFunction to accept an ErrorParameter that contains additional information regarding the cause of a validation error. In Revision 0.31.0, only `errorType` and `schema` were passed through to this function. In 0.32.0 the additional properties `value` and `path` are also passed through. This update was prompted by some users needing to be able to generate specific error messages derived from specific values or other associated information.
+
+The following shows the changes from 0.31.0 to 0.32.0.
+
+```typescript
+// Revision 0.31.0
+
+import { TypeSystemErrorFunction } from '@sinclair/typebox/system'
+
+TypeSystemErrorFunction.Set((schema, errorType) => {
+
+   return 'oh no, an error!'
+})
+
+// Revision 0.32.0
+
+import { SetErrorFunction } from '@sinclair/typebox/errors'
+
+SetErrorFunction(({ schema, errorType, path, value }) => { // as destructured object
+
+  return 'oh no, an error!'
+})
+```
+Note that Revision 0.32.0 does make a breaking interface change by moving the ErrorFunction from `/system` to `/errors`. See breaking changes for more information.
+
+<a name="Breaking"></a>
+
+## Breaking
+
+The following list the breaking changes in Revision 0.32.0.
+
+
+<a name="Breaking-Renamed-Symbols"></a>
+
+### Renamed Symbols
+
+Revision 0.32.0 renames the `Optional`, `Required` and `Transform` symbols to `OptionalKind`, `RequiredKind` and `TransformKind`. This change was necessary to avoid conflicts with exported type functions.
+
+```typescript
+// Revision 0.31.0
+import { Kind, Hint, Optional, Required, Transform } from '@sinclair/typebox' // these are symbols
+
+// Revision 0.32.0
+import { 
+  Kind, Hint, OptionalKind, RequiredKind, TransformKind,                      // these are symbols
+  Optional, Required, Transform                                               // these are type imports
+} from '@sinclair/typebox' 
+```
+
+<a name="Breaking-TypeGuard-Interface-Change"></a>
+
+### TypeGuard Interface Change
+
+Revision 0.32.0 has a breaking interface change on the TypeGuard utility where the `T` prefixed guard functions have been updated to use the `Is` prefix. This naming change is perhaps somewhat more sensible than the previous naming, however the update was largely prompted by TypeScript compiler issues where interface types (i.e. `TString`) where conflicting with the `TString` functions leading to breakage in CommonJS.
+
+```typescript
+// Revision 0.31.0
+
+import { TypeGuard, Kind } from '@sinclair/typebox'
+
+const R = TypeGuard.TString({ ... })
+
+// Revision 0.32.0
+
+import { TypeGuard } from '@sinclair/typebox'
+
+const R = TypeGuard.IsString({ ... })
+```
+
+<a name="Breaking-Value-Submodule-Imports"></a>
+
+### Value Submodule Imports
+
+The value submodule function import paths are unfortunately no longer supported. Instead, these can be imported directly on the `/value` path. The need to break the submodule paths was mostly due to complexities configuring dual ESM and CommonJS publishing for the package, as well as retaining support for pre and post node16 module resolution (of which many complexities reside, both for Node as well as for TypeScript type module resolution)
+
+```typescript
+// Revision 0.31.0
+
+import { Check } from '@sinclair/typebox/value/check'
+
+// Revision 0.32.0
+
+import { Check } from '@sinclair/typebox/value'
+```
+
+<a name="Breaking-Error-Function"></a>
+
+### Error Function
+
+The TypeSystemErrorFunction has been replaced with SetErrorFunction which can be imported on the `/errors` submodule. This change is generally a tidy up, and to reserve the `/system` submodule for type system policy configuration, as well as future Json Schema generation options (draft 2020-12)
+
+```typescript
+// Revision 0.31.0
+
+import { TypeSystemErrorFunction, ValueErrorType, DefaultErrorFunction } from '@sinclair/typebox/system'
+
+TypeSystemErrorFunction.Set((schema, errorType) => { // i18n override
+  switch(errorType) {
+    /* en-US */ case ValueErrorType.String: return 'Expected string'
+    /* fr-FR */ case ValueErrorType.Number: return 'Nombre attendu'  
+    /* ko-KR */ case ValueErrorType.Boolean: return '예상 부울'      
+    /* en-US */ default: return DefaultErrorFunction(schema, errorType)          
+  }
+})
+
+// Revision 0.32.0
+
+import { SetErrorFunction, ValueErrorType, DefaultErrorFunction } from '@sinclair/typebox/errors'
+
+SetErrorFunction((error) => { // i18n override
+  switch(error.errorType) {
+    /* en-US */ case ValueErrorType.String: return 'Expected string'
+    /* fr-FR */ case ValueErrorType.Number: return 'Nombre attendu'  
+    /* ko-KR */ case ValueErrorType.Boolean: return '예상 부울'      
+    /* en-US */ default: return DefaultErrorFunction(error)          
+  }
+})
+```
+
+<a name="Breaking-RegEx"></a>
+
+### RegEx
+
+This RegEx function was flagged for deprecation on 0.30.0. It has been removed on Revision 0.32.0. Use the Type.RegExp type, or Type.String with a pattern to remain compatible with the Json Schema specification.
+
+```typescript
+// Revision 0.31.0
+
+const T = Type.RegEx(/abc/)                                    // deprecation warning
+
+// Revision 0.32.0
+
+const A = Type.RegExp(/abc/)                                   // JavaScript Type
+
+const B = Type.String({ pattern: /abc/.source })               // Json Type
+```
\ No newline at end of file
diff --git a/example/annotation/annotation.ts b/example/annotation/annotation.ts
new file mode 100644
index 000000000..26bebaf0d
--- /dev/null
+++ b/example/annotation/annotation.ts
@@ -0,0 +1,148 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '@sinclair/typebox'
+
+// -------------------------------------------------------------------
+// Annotation
+//
+// Generates TypeScript Type Annotations from TypeBox types
+// -------------------------------------------------------------------
+/** Generates TypeScript Type Annotations from TypeBox types */
+export namespace Annotation {
+  // -----------------------------------------------------------------
+  // Escape
+  // -----------------------------------------------------------------
+  function Escape(content: string) {
+    return content.replace(/'/g, "\\'")
+  }
+  // -----------------------------------------------------------------
+  // Types
+  // -----------------------------------------------------------------
+  function Intersect(schema: Types.TSchema[], references: Types.TSchema[]): string {
+    const [L, ...R] = schema
+    // prettier-ignore
+    return R.length === 0
+      ? `${Visit(L, references)}`
+      : `${Visit(L, references)} & ${Intersect(R, references)}`
+  }
+  function Union(schema: Types.TSchema[], references: Types.TSchema[]): string {
+    const [L, ...R] = schema
+    // prettier-ignore
+    return R.length === 0
+      ? `${Visit(L, references)}`
+      : `${Visit(L, references)} | ${Union(R, references)}`
+  }
+  function Tuple(schema: Types.TSchema[], references: Types.TSchema[]): string {
+    const [L, ...R] = schema
+    // prettier-ignore
+    return R.length > 0
+      ? `${Visit(L, references)}, ${Tuple(R, references)}`
+      : ``
+  }
+  function Property(schema: Types.TProperties, K: string, references: Types.TSchema[]): string {
+    const TK = schema[K]
+    // prettier-ignore
+    return (
+      Types.TypeGuard.IsOptional(TK) && Types.TypeGuard.IsReadonly(TK) ? `readonly ${K}?: ${Visit(TK, references)}` :
+      Types.TypeGuard.IsReadonly(TK) ? `readonly ${K}: ${Visit(TK, references)}` :
+      Types.TypeGuard.IsOptional(TK) ? `${K}?: ${Visit(TK, references)}` :
+      `${K}: ${Visit(TK, references)}`
+    )
+  }
+  function Properties(schema: Types.TProperties, K: string[], references: Types.TSchema[]): string {
+    const [L, ...R] = K
+    // prettier-ignore
+    return R.length === 0
+      ? `${Property(schema, L, references)}`
+      : `${Property(schema, L, references)}; ${Properties(schema, R, references)}`
+  }
+  function Parameters(schema: Types.TSchema[], I: number, references: Types.TSchema[]): string {
+    const [L, ...R] = schema
+    // prettier-ignore
+    return R.length === 0
+      ? `param_${I}: ${Visit(L, references)}`
+      : `param_${I}: ${Visit(L, references)}, ${Parameters(R, I + 1, references)}`
+  }
+  function Literal(schema: Types.TLiteral, references: Types.TSchema[]): string {
+    return typeof schema.const === 'string' ? `'${Escape(schema.const)}'` : schema.const.toString()
+  }
+  function Record(schema: Types.TRecord, references: Types.TSchema[]): string {
+    // prettier-ignore
+    return (
+      Types.PatternBooleanExact in schema.patternProperties ? `Record<boolean, ${Visit(schema.patternProperties[Types.PatternBooleanExact], references)}>` : 
+      Types.PatternNumberExact in schema.patternProperties ? `Record<number, ${Visit(schema.patternProperties[Types.PatternNumberExact], references)}>` : 
+      Types.PatternStringExact in schema.patternProperties ? `Record<string, ${Visit(schema.patternProperties[Types.PatternStringExact], references)}>` : 
+      `{}`
+    )
+  }
+  function TemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[]) {
+    const E = Types.TemplateLiteralParseExact(schema.pattern)
+    if (!Types.IsTemplateLiteralExpressionFinite(E)) return 'string'
+    return [...Types.TemplateLiteralExpressionGenerate(E)].map((literal) => `'${Escape(literal)}'`).join(' | ')
+  }
+  function Visit(schema: Types.TSchema, references: Types.TSchema[]): string {
+    // prettier-ignore
+    return (
+      Types.TypeGuard.IsAny(schema) ? 'any' :
+      Types.TypeGuard.IsArray(schema) ? `${Visit(schema.items, references)}[]` :
+      Types.TypeGuard.IsAsyncIterator(schema) ? `AsyncIterableIterator<${Visit(schema.items, references)}>` :
+      Types.TypeGuard.IsBigInt(schema) ? `bigint` :
+      Types.TypeGuard.IsBoolean(schema) ? `boolean` :
+      Types.TypeGuard.IsConstructor(schema) ? `new (${Parameters(schema.parameter, 0, references)}) => ${Visit(schema.returns, references)}` :
+      Types.TypeGuard.IsDate(schema) ? 'Date' :
+      Types.TypeGuard.IsFunction(schema) ? `(${Parameters(schema.parameters, 0, references)}) => ${Visit(schema.returns, references)}` :
+      Types.TypeGuard.IsInteger(schema) ? 'number' :
+      Types.TypeGuard.IsIntersect(schema) ? `(${Intersect(schema.allOf, references)})` :
+      Types.TypeGuard.IsIterator(schema) ? `IterableIterator<${Visit(schema.items, references)}>` :
+      Types.TypeGuard.IsLiteral(schema) ? `${Literal(schema, references)}` :
+      Types.TypeGuard.IsNever(schema) ? `never` :
+      Types.TypeGuard.IsNull(schema) ? `null` :
+      Types.TypeGuard.IsNot(schema) ? 'unknown' :
+      Types.TypeGuard.IsNumber(schema) ? 'number' :
+      Types.TypeGuard.IsObject(schema) ? `{ ${Properties(schema.properties, Object.getOwnPropertyNames(schema.properties), references)} }` :
+      Types.TypeGuard.IsPromise(schema) ? `Promise<${Visit(schema.item, references)}>` :
+      Types.TypeGuard.IsRecord(schema) ? `${Record(schema, references)}` :
+      Types.TypeGuard.IsRef(schema) ? `${Visit(Types.Type.Deref(schema, references), references)}` :
+      Types.TypeGuard.IsString(schema) ? 'string' :
+      Types.TypeGuard.IsSymbol(schema) ? 'symbol' :
+      Types.TypeGuard.IsTemplateLiteral(schema) ? `${TemplateLiteral(schema, references)}` :
+      Types.TypeGuard.IsThis(schema) ?  'unknown' : // requires named interface
+      Types.TypeGuard.IsTuple(schema) ? `[${Tuple(schema.items || [], references)}]` :
+      Types.TypeGuard.IsUint8Array(schema) ? `Uint8Array` :
+      Types.TypeGuard.IsUndefined(schema) ? 'undefined' :
+      Types.TypeGuard.IsUnion(schema) ? `${Union(schema.anyOf, references)}` :
+      Types.TypeGuard.IsVoid(schema) ? `void` :
+      'unknown'
+    )
+  }
+  /** Generates a TypeScript annotation for the given schema */
+  export function Code(schema: Types.TSchema, references: Types.TSchema[] = []): string {
+    return Visit(schema, references)
+  }
+}
\ No newline at end of file
diff --git a/example/annotation/index.ts b/example/annotation/index.ts
new file mode 100644
index 000000000..34ccf2617
--- /dev/null
+++ b/example/annotation/index.ts
@@ -0,0 +1 @@
+export * from './annotation'
\ No newline at end of file
diff --git a/examples/collections/array.ts b/example/collections/array.ts
similarity index 100%
rename from examples/collections/array.ts
rename to example/collections/array.ts
diff --git a/examples/collections/index.ts b/example/collections/index.ts
similarity index 100%
rename from examples/collections/index.ts
rename to example/collections/index.ts
diff --git a/examples/collections/map.ts b/example/collections/map.ts
similarity index 100%
rename from examples/collections/map.ts
rename to example/collections/map.ts
diff --git a/examples/collections/readme.md b/example/collections/readme.md
similarity index 100%
rename from examples/collections/readme.md
rename to example/collections/readme.md
diff --git a/examples/collections/set.ts b/example/collections/set.ts
similarity index 100%
rename from examples/collections/set.ts
rename to example/collections/set.ts
diff --git a/examples/formats/date-time.ts b/example/formats/date-time.ts
similarity index 100%
rename from examples/formats/date-time.ts
rename to example/formats/date-time.ts
diff --git a/examples/formats/date.ts b/example/formats/date.ts
similarity index 100%
rename from examples/formats/date.ts
rename to example/formats/date.ts
diff --git a/examples/formats/email.ts b/example/formats/email.ts
similarity index 100%
rename from examples/formats/email.ts
rename to example/formats/email.ts
diff --git a/examples/formats/index.ts b/example/formats/index.ts
similarity index 100%
rename from examples/formats/index.ts
rename to example/formats/index.ts
diff --git a/examples/formats/ipv4.ts b/example/formats/ipv4.ts
similarity index 100%
rename from examples/formats/ipv4.ts
rename to example/formats/ipv4.ts
diff --git a/examples/formats/ipv6.ts b/example/formats/ipv6.ts
similarity index 100%
rename from examples/formats/ipv6.ts
rename to example/formats/ipv6.ts
diff --git a/examples/formats/time.ts b/example/formats/time.ts
similarity index 100%
rename from examples/formats/time.ts
rename to example/formats/time.ts
diff --git a/examples/formats/url.ts b/example/formats/url.ts
similarity index 100%
rename from examples/formats/url.ts
rename to example/formats/url.ts
diff --git a/examples/formats/uuid.ts b/example/formats/uuid.ts
similarity index 100%
rename from examples/formats/uuid.ts
rename to example/formats/uuid.ts
diff --git a/examples/index.ts b/example/index.ts
similarity index 100%
rename from examples/index.ts
rename to example/index.ts
diff --git a/examples/prototypes/evaluate.ts b/example/prototypes/evaluate.ts
similarity index 82%
rename from examples/prototypes/evaluate.ts
rename to example/prototypes/evaluate.ts
index 5fa7b2128..530972fa7 100644
--- a/examples/prototypes/evaluate.ts
+++ b/example/prototypes/evaluate.ts
@@ -44,7 +44,6 @@ import {
   TTuple, 
   TProperties, 
   TIntersect, 
-  IntersectType, 
   TUnion, 
   TNever 
 } from '@sinclair/typebox'
@@ -75,7 +74,7 @@ export type TEvaluateArray<T extends TSchema[]> =  T extends [infer L, ...infer
   []
 // prettier-ignore
 export type TEvaluate<T extends TSchema> = 
-  T extends TIntersect<infer S>            ? IntersectType<TEvaluateIntersectRest<S>> :
+  T extends TIntersect<infer S>            ? TIntersect<TEvaluateIntersectRest<S>> :
   T extends TUnion<infer S>                ? TUnion<TEvaluateArray<S>> :
   T extends TConstructor<infer P, infer R> ? TConstructor<TEvaluateArray<P>, TEvaluate<R>> : 
   T extends TFunction<infer P, infer R>    ? TFunction<TEvaluateArray<P>, TEvaluate<R>> : 
@@ -119,16 +118,16 @@ export function EvaluateArray<T extends TSchema[] | undefined>(rest: T) {
 // prettier-ignore
 export function Evaluate<T extends TSchema>(schema: T): TEvaluate<T> {
   return (
-    TypeGuard.TIntersect(schema)     ? Type.Intersect(EvaluateIntersectRest(schema.allOf)) :
-    TypeGuard.TUnion(schema)         ? Type.Union(EvaluateArray(schema.anyOf)) :
-    TypeGuard.TAsyncIterator(schema) ? Type.AsyncIterator(Evaluate(schema.items)) :
-    TypeGuard.TIterator(schema)      ? Type.Iterator(Evaluate(schema.items)) :
-    TypeGuard.TObject(schema)        ? Type.Object(EvaluateProperties(schema.properties)) :
-    TypeGuard.TConstructor(schema)   ? Type.Constructor(EvaluateArray(schema.parameters), Evaluate(schema.returns)) :
-    TypeGuard.TFunction(schema)      ? Type.Function(EvaluateArray(schema.parameters), Evaluate(schema.returns)) :
-    TypeGuard.TTuple(schema)         ? Type.Tuple(EvaluateArray(schema.items)) :
-    TypeGuard.TArray(schema)         ? Type.Promise(Evaluate(schema.items)) :
-    TypeGuard.TPromise(schema)       ? Type.Promise(Evaluate(schema.item)) :
+    TypeGuard.IsIntersect(schema)     ? Type.Intersect(EvaluateIntersectRest(schema.allOf)) :
+    TypeGuard.IsUnion(schema)         ? Type.Union(EvaluateArray(schema.anyOf)) :
+    TypeGuard.IsAsyncIterator(schema) ? Type.AsyncIterator(Evaluate(schema.items)) :
+    TypeGuard.IsIterator(schema)      ? Type.Iterator(Evaluate(schema.items)) :
+    TypeGuard.IsObject(schema)        ? Type.Object(EvaluateProperties(schema.properties)) :
+    TypeGuard.IsConstructor(schema)   ? Type.Constructor(EvaluateArray(schema.parameters), Evaluate(schema.returns)) :
+    TypeGuard.IsFunction(schema)      ? Type.Function(EvaluateArray(schema.parameters), Evaluate(schema.returns)) :
+    TypeGuard.IsTuple(schema)         ? Type.Tuple(EvaluateArray(schema.items)) :
+    TypeGuard.IsArray(schema)         ? Type.Promise(Evaluate(schema.items)) :
+    TypeGuard.IsPromise(schema)       ? Type.Promise(Evaluate(schema.item)) :
     schema 
   ) as TEvaluate<T>
 }
diff --git a/examples/prototypes/index.ts b/example/prototypes/index.ts
similarity index 98%
rename from examples/prototypes/index.ts
rename to example/prototypes/index.ts
index ef44e7d95..4a70931c8 100644
--- a/examples/prototypes/index.ts
+++ b/example/prototypes/index.ts
@@ -26,7 +26,6 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export * from './const'
 export * from './evaluate'
 export * from './partial-deep'
 export * from './union-enum'
diff --git a/examples/prototypes/partial-deep.ts b/example/prototypes/partial-deep.ts
similarity index 84%
rename from examples/prototypes/partial-deep.ts
rename to example/prototypes/partial-deep.ts
index 1315b65b0..c0896186c 100644
--- a/examples/prototypes/partial-deep.ts
+++ b/example/prototypes/partial-deep.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { TypeGuard, Type, TSchema, TIntersect, TUnion, TObject, TPartial, TProperties, AssertRest, AssertType, Evaluate } from '@sinclair/typebox'
+import { TypeGuard, Type, TSchema, TIntersect, TUnion, TObject, TPartial, TProperties, Evaluate } from '@sinclair/typebox'
 
 // -------------------------------------------------------------------------------------
 // TDeepPartial
@@ -34,9 +34,10 @@ import { TypeGuard, Type, TSchema, TIntersect, TUnion, TObject, TPartial, TPrope
 export type TPartialDeepProperties<T extends TProperties> = {
   [K in keyof T]: TPartial<T[K]>
 }
-export type TPartialDeepRest<T extends TSchema[]> = T extends [infer L, ...infer R]
-  ? [TPartial<AssertType<L>>, ...TPartialDeepRest<AssertRest<R>>]
-  : []
+export type TPartialDeepRest<T extends TSchema[]> = 
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? [TPartial<L>, ...TPartialDeepRest<R>]
+    : []
 export type TPartialDeep<T extends TSchema> = 
   T extends TIntersect<infer S> ? TIntersect<TPartialDeepRest<S>> :
   T extends TUnion<infer S> ? TUnion<TPartialDeepRest<S>> :
@@ -57,9 +58,9 @@ function PartialDeepRest<T extends TSchema[]>(rest: [...T]): TPartialDeepRest<T>
 /** Maps the given schema as deep partial, making all properties and sub properties optional */
 export function PartialDeep<T extends TSchema>(type: T): TPartialDeep<T> {
   return (
-    TypeGuard.TIntersect(type) ? Type.Intersect(PartialDeepRest(type.allOf)) :
-    TypeGuard.TUnion(type) ? Type.Union(PartialDeepRest(type.anyOf)) :
-    TypeGuard.TObject(type) ? Type.Partial(Type.Object(PartialDeepProperties(type.properties))) :
+    TypeGuard.IsIntersect(type) ? Type.Intersect(PartialDeepRest(type.allOf)) :
+    TypeGuard.IsUnion(type) ? Type.Union(PartialDeepRest(type.anyOf)) :
+    TypeGuard.IsObject(type) ? Type.Partial(Type.Object(PartialDeepProperties(type.properties))) :
     type
   ) as any
 }
\ No newline at end of file
diff --git a/examples/prototypes/readme.md b/example/prototypes/readme.md
similarity index 100%
rename from examples/prototypes/readme.md
rename to example/prototypes/readme.md
diff --git a/examples/prototypes/union-enum.ts b/example/prototypes/union-enum.ts
similarity index 100%
rename from examples/prototypes/union-enum.ts
rename to example/prototypes/union-enum.ts
diff --git a/examples/prototypes/union-oneof.ts b/example/prototypes/union-oneof.ts
similarity index 100%
rename from examples/prototypes/union-oneof.ts
rename to example/prototypes/union-oneof.ts
diff --git a/examples/typedef/index.ts b/example/typedef/index.ts
similarity index 100%
rename from examples/typedef/index.ts
rename to example/typedef/index.ts
diff --git a/examples/typedef/readme.md b/example/typedef/readme.md
similarity index 100%
rename from examples/typedef/readme.md
rename to example/typedef/readme.md
diff --git a/examples/typedef/typedef.ts b/example/typedef/typedef.ts
similarity index 93%
rename from examples/typedef/typedef.ts
rename to example/typedef/typedef.ts
index 5eb12a372..233ac5c7c 100644
--- a/examples/typedef/typedef.ts
+++ b/example/typedef/typedef.ts
@@ -26,22 +26,11 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { TypeSystemErrorFunction, DefaultErrorFunction } from '@sinclair/typebox/system'
-import * as Types from '@sinclair/typebox'
+import { SetErrorFunction, DefaultErrorFunction } from '@sinclair/typebox/errors'
+import * as Types from '@sinclair/typebox/type'
 
 // --------------------------------------------------------------------------
-// Utility Types
-// --------------------------------------------------------------------------
-export type Assert<T, U> = T extends U ? T : never
-export type Base = { m: string, t: string }
-export type Base16 = { m: 'F', t: '01', '0': '1', '1': '2', '2': '3', '3': '4', '4': '5', '5': '6', '6': '7', '7': '8', '8': '9', '9': 'A', 'A': 'B', 'B': 'C', 'C': 'D', 'D': 'E', 'E': 'F', 'F': '0' }
-export type Base10 = { m: '9', t: '01', '0': '1', '1': '2', '2': '3', '3': '4', '4': '5', '5': '6', '6': '7', '7': '8', '8': '9', '9': '0' }
-export type Reverse<T extends string> = T extends `${infer L}${infer R}` ? `${Reverse<R>}${L}` : T
-export type Tick<T extends string, B extends Base> = T extends keyof B ? B[T] : never
-export type Next<T extends string, B extends Base> = T extends Assert<B, Base>['m'] ? Assert<B, Base>['t'] : T extends `${infer L}${infer R}` ? L extends Assert<B, Base>['m'] ? `${Assert<Tick<L, B>, string>}${Next<R, B>}` : `${Assert<Tick<L, B>, string>}${R}` : never
-export type Increment<T extends string, B extends Base = Base10> = Reverse<Next<Reverse<T>, B>>
-// --------------------------------------------------------------------------
-// SchemaOptions
+// Metadata
 // --------------------------------------------------------------------------
 export interface Metadata {
   [name: string]: any
@@ -65,9 +54,10 @@ export interface TBoolean extends Types.TSchema {
 // --------------------------------------------------------------------------
 // TUnion
 // --------------------------------------------------------------------------
-type InferUnion<T extends TStruct[], D extends string, Index = string> = T extends [infer L, ...infer R]
-  ? Types.Evaluate<{ [_ in D]: Index } & Types.Static<Types.AssertType<L>>> | InferUnion<Types.AssertRest<R>, D, Increment<Types.Assert<Index, string>>>
-  : never
+export type InferUnion<T extends TStruct[], D extends string, Index = string> = 
+  T extends [infer L extends TStruct, ...infer R extends TStruct[]]
+    ? Types.Evaluate<{ [_ in D]: Index } & Types.Static<L>> | InferUnion<R, D, Types.Increment<Types.Assert<Index, string>>>
+    : never
 
 export interface TUnion<T extends TStruct[] = TStruct[], D extends string = string> extends Types.TSchema {
   [Types.Kind]: 'TypeDef:Union'
@@ -170,14 +160,31 @@ export interface TString extends Types.TSchema {
 // --------------------------------------------------------------------------
 // TStruct
 // --------------------------------------------------------------------------
+// used for structural type inference
 type OptionalKeys<T extends TFields> = { [K in keyof T]: T[K] extends (Types.TOptional<T[K]>) ? T[K] : never }
 type RequiredKeys<T extends TFields> = { [K in keyof T]: T[K] extends (Types.TOptional<T[K]>) ? never : T[K] }
+// static inference
+type ReadonlyOptionalPropertyKeys<T extends TFields> = { [K in keyof T]: T[K] extends Types.TReadonly<Types.TSchema> ? (T[K] extends Types.TOptional<T[K]> ? K : never) : never }[keyof T]
+type ReadonlyPropertyKeys<T extends TFields> = { [K in keyof T]: T[K] extends Types.TReadonly<Types.TSchema> ? (T[K] extends Types.TOptional<T[K]> ? never : K) : never }[keyof T]
+type OptionalPropertyKeys<T extends TFields> = { [K in keyof T]: T[K] extends Types.TOptional<Types.TSchema> ? (T[K] extends Types.TReadonly<T[K]> ? never : K) : never }[keyof T]
+type RequiredPropertyKeys<T extends TFields> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>
+// prettier-ignore
+type StructStaticProperties<T extends TFields, R extends Record<keyof any, unknown>> = Types.Evaluate<(
+  Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> &
+  Readonly<Pick<R, ReadonlyPropertyKeys<T>>> &
+  Partial<Pick<R, OptionalPropertyKeys<T>>> &
+  Required<Pick<R, RequiredPropertyKeys<T>>>
+)>
+// prettier-ignore
+export type StructStatic<T extends TFields, P extends unknown[]> = StructStaticProperties<T, {
+  [K in keyof T]: Static<T[K], P>
+}>
 export interface StructMetadata extends Metadata {
   additionalProperties?: boolean
 }
 export interface TStruct<T extends TFields = TFields> extends Types.TSchema, StructMetadata {
   [Types.Kind]: 'TypeDef:Struct'
-  static: Types.PropertiesReduce<T, this['params']>
+  static: StructStatic<T, this['params']>
   optionalProperties: { [K in Types.Assert<OptionalKeys<T>, keyof T>]: T[K] }
   properties: { [K in Types.Assert<RequiredKeys<T>, keyof T>]: T[K] }
 }
@@ -487,8 +494,8 @@ Types.TypeRegistry.Set<TTimestamp>('TypeDef:Timestamp', (schema, value) => Value
 // --------------------------------------------------------------------------
 // TypeSystemErrorFunction
 // --------------------------------------------------------------------------
-TypeSystemErrorFunction.Set((schema, type) => {
-  switch(schema[Types.Kind]) {
+SetErrorFunction((error) => {
+  switch(error.schema[Types.Kind]) {
     case 'TypeDef:Array': return 'Expected Array'
     case 'TypeDef:Boolean': return 'Expected Boolean'
     case 'TypeDef:Union': return 'Expected Union'
@@ -503,7 +510,7 @@ TypeSystemErrorFunction.Set((schema, type) => {
     case 'TypeDef:Struct': return 'Expected Struct'
     case 'TypeDef:Timestamp': return 'Expected Timestamp'
   }
-  return DefaultErrorFunction(schema, type)
+  return DefaultErrorFunction(error)
 })
 // --------------------------------------------------------------------------
 // TypeDefBuilder
@@ -588,8 +595,8 @@ export class TypeDefBuilder {
   }
   /** [Standard] Creates a Struct type */
   public Struct<T extends TFields>(fields: T, metadata: StructMetadata = {}): TStruct<T> {
-    const optionalProperties = globalThis.Object.getOwnPropertyNames(fields).reduce((acc, key) => (Types.TypeGuard.TOptional(fields[key]) ? { ...acc, [key]: fields[key] } : { ...acc }), {} as TFields)
-    const properties = globalThis.Object.getOwnPropertyNames(fields).reduce((acc, key) => (Types.TypeGuard.TOptional(fields[key]) ? { ...acc } : { ...acc, [key]: fields[key] }), {} as TFields)
+    const optionalProperties = globalThis.Object.getOwnPropertyNames(fields).reduce((acc, key) => (Types.TypeGuard.IsOptional(fields[key]) ? { ...acc, [key]: fields[key] } : { ...acc }), {} as TFields)
+    const properties = globalThis.Object.getOwnPropertyNames(fields).reduce((acc, key) => (Types.TypeGuard.IsOptional(fields[key]) ? { ...acc } : { ...acc, [key]: fields[key] }), {} as TFields)
     const optionalObject = globalThis.Object.getOwnPropertyNames(optionalProperties).length > 0 ? { optionalProperties: optionalProperties } : {}
     const requiredObject = globalThis.Object.getOwnPropertyNames(properties).length === 0 ? {} : { properties: properties }
     return this.Create({ [Types.Kind]: 'TypeDef:Struct', ...requiredObject, ...optionalObject }, metadata)
diff --git a/examples/trpc/readme.md b/examples/trpc/readme.md
deleted file mode 100644
index c5c7051e8..000000000
--- a/examples/trpc/readme.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# Using TypeBox with TRPC
-
-To use TypeBox with TRPC, you will need to wrap types in a TRPC compatible validation function. The following shows wrapping a type using the TypeCompiler.
-
-<a name="Example"></a>
-
-## Example
-
-[TypeScript Link Here](https://www.typescriptlang.org/play?#code/JYWwDg9gTgLgBAbzsAdsGAVASgBQMIA0c2+AolFNHAL5wBmlIcA5AAIxRgDGA9AM4BTKADchzALAAoUJFiJiATzAC8EcMAA2QmvUYtWfVFw0BDYFB4wlAgEYQAHjy5qwmsVJnR4SDNaIYAZS4ACwEQEx0GNX1DFGMzCytlO3sJSSkeHjgAWly8-ILCouKS0rLyvIys1XUtPjgI32UGlAATOCgBGABXKBR6iOMIPl6BeioSPCqcitm5+YWCqQF7WXg6briYYAgUOCxuJoEAHgw4FZgBNvrAkLCTAD4ACj478IAuYiJOuiErrgEfE+t1C4QA2gBdOAAXjgkIAlIgpHA4M5+vA7lwANYwxTKGquLRQAB0BLcLzeJm+Al+nTigPhyI6XV6eyewhMGm6Ak+myxKAgAHcUIjoQ8kZIUSjgHQ4E9MVjSaFsezOdz4YjOj0+nAOVyBEyUWi+N44GATDBgkQQIC+CYAOZjWiwhXE8iUKB8VX6+HEgBi5hNT3hAEJDXBLZRBXAUAJo5N3dAnkgbXw7Y7PgADAAkCFT6YEtDoVFz5st1EzRGcrR5LAAQgBBAAiAH0sKQAIoAVVIAQwzBojMlNCk1Gmiwnk6nlUkmTgXYL4+ny5XZSkxvg8FhqHQk2JXE6FoEwfXuxNDVa7VhMGJYEoANaoyZxNQYG6MCeBy4Rye4aOxIAeRsAArAQuA-BBwxRExgWsYkADluhAGwhGDAgoLgGxYOUBCkJQqA0PDaghxRDVnwgd83w-L8fz-ODEOQ1CSNI5jiQAR25KAFCeZNkBQKjBxhcVX3fYkIgAaj4qjiRsRE5ySARsjtX4pGWVYvFRM94BMMAwCwCjLigXEb0od9UKQJkTEvOBR3hIA)
-
-```typescript
-import { initTRPC, TRPCError } from '@trpc/server'
-import { TypeCompiler } from '@sinclair/typebox/compiler'
-import { Type, TSchema } from '@sinclair/typebox'
-
-// ---------------------------------------------------------------------------------
-// Compiles a Type and returns a closure for TRPC
-// ---------------------------------------------------------------------------------
-export function RpcType<T extends TSchema>(schema: T, references: TSchema[] = []) {
-  const check = TypeCompiler.Compile(schema, references)
-  return (value: unknown) => {
-    if (check.Check(value)) return value
-    const { path, message } = check.Errors(value).First()!
-    throw new TRPCError({ message: `${message} for ${path}`, code: 'BAD_REQUEST' })
-  }
-}
-// ---------------------------------------------------------------------------------
-// Usage
-// ---------------------------------------------------------------------------------
-const t = initTRPC.create()
-const add = t.procedure
-  .input(RpcType(
-    Type.Object({
-      a: Type.Number(),
-      b: Type.Number(),
-    })
-  ))
-  .output(RpcType(
-    Type.Number()
-   ))
-  .query(({ input }) => input.a + input.b) // type-safe
-
-export const appRouter = t.router({ 
-  add 
-})
-```
\ No newline at end of file
diff --git a/hammer.mjs b/hammer.mjs
index 2e02a034e..661d90a28 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -1,36 +1,32 @@
-import { compression, measurement } from './benchmark'
-import { readFileSync } from 'fs'
+import * as Benchmark from './task/benchmark'
+import * as Build from './task/build'
+import * as Fs from 'fs'
 
 // -------------------------------------------------------------------------------
 // Clean
 // -------------------------------------------------------------------------------
 export async function clean() {
+  await folder('node_modules/typebox').delete()
   await folder('target').delete()
 }
 // -------------------------------------------------------------------------------
 // Format
 // -------------------------------------------------------------------------------
 export async function format() {
-  await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test examples/index.ts benchmark')
+  await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test task example/index.ts')
 }
 // -------------------------------------------------------------------------------
 // Start
 // -------------------------------------------------------------------------------
 export async function start() {
-  await shell(`hammer run examples/index.ts --dist target/examples`)
+  await shell(`hammer run example/index.ts --dist target/example`)
 }
 // -------------------------------------------------------------------------------
 // Benchmark
 // -------------------------------------------------------------------------------
-export async function benchmark_compression() {
-  await compression()
-}
-export async function benchmark_measurement() {
-  await measurement()
-}
 export async function benchmark() {
-  await benchmark_compression()
-  await benchmark_measurement()
+  await Benchmark.compression()
+  await Benchmark.measurement()
 }
 // -------------------------------------------------------------------------------
 // Test
@@ -56,20 +52,36 @@ export async function test(filter = '') {
 // -------------------------------------------------------------------------------
 // Build
 // -------------------------------------------------------------------------------
+export async function build_check(target = 'target/build') {
+  const { version } = JSON.parse(Fs.readFileSync('package.json', 'utf8'))
+  await shell(`cd ${target} && attw sinclair-typebox-${version}.tgz`)
+}
 export async function build(target = 'target/build') {
   await test()
-  await folder(target).delete()
-  await shell(`tsc -p ./src/tsconfig.json --outDir ${target}`)
-  await folder(target).add('package.json')
+  await clean()
+  await Promise.all([
+    Build.Import.build(target),
+    Build.Require.build(target),
+    Build.Redirect.build(target)
+  ])
   await folder(target).add('readme.md')
   await folder(target).add('license')
   await shell(`cd ${target} && npm pack`)
+  await build_check(target)
+}
+// -------------------------------------------------------------------------------
+// Install
+// -------------------------------------------------------------------------------
+export async function install_local() {
+  await clean()
+  await build('target/typebox')
+  await folder('node_modules').add('target/typebox')
 }
 // -------------------------------------------------------------
 // Publish
 // -------------------------------------------------------------
 export async function publish(otp, target = 'target/build') {
-  const { version } = JSON.parse(readFileSync('package.json', 'utf8'))
+  const { version } = JSON.parse(Fs.readFileSync('package.json', 'utf8'))
   if(version.includes('-dev')) throw Error(`package version should not include -dev specifier`)
   await shell(`cd ${target} && npm publish sinclair-typebox-${version}.tgz --access=public --otp ${otp}`)
   await shell(`git tag ${version}`)
@@ -79,7 +91,7 @@ export async function publish(otp, target = 'target/build') {
 // Publish-Dev
 // -------------------------------------------------------------
 export async function publish_dev(otp, target = 'target/build') {
-  const { version } = JSON.parse(readFileSync(`${target}/package.json`, 'utf8'))
+  const { version } = JSON.parse(Fs.readFileSync(`${target}/package.json`, 'utf8'))
   if(!version.includes('-dev')) throw Error(`development package version should include -dev specifier`)
   await shell(`cd ${target} && npm publish sinclair-typebox-${version}.tgz --access=public --otp ${otp} --tag dev`)
 }
\ No newline at end of file
diff --git a/license b/license
index 08641fd64..971ec5da8 100644
--- a/license
+++ b/license
@@ -1,4 +1,6 @@
-TypeBox: JSON Schema Type Builder with Static Type Resolution for TypeScript 
+TypeBox
+
+Json Schema Type Builder with Static Type Resolution for TypeScript 
 
 The MIT License (MIT)
 
diff --git a/package-lock.json b/package-lock.json
index 88740ec7e..6ce4d3fae 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,17 +1,18 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.28",
+  "version": "0.32.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.28",
+      "version": "0.32.0",
       "license": "MIT",
       "devDependencies": {
+        "@arethetypeswrong/cli": "^0.13.2",
         "@sinclair/hammer": "^0.18.0",
         "@types/mocha": "^9.1.1",
-        "@types/node": "^18.11.9",
+        "@types/node": "^20.10.1",
         "ajv": "^8.12.0",
         "ajv-formats": "^2.1.1",
         "mocha": "^9.2.2",
@@ -19,6 +20,59 @@
         "typescript": "^5.3.2"
       }
     },
+    "node_modules/@andrewbranch/untar.js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@andrewbranch/untar.js/-/untar.js-1.0.3.tgz",
+      "integrity": "sha512-Jh15/qVmrLGhkKJBdXlK1+9tY4lZruYjsgkDFj08ZmDiWVBLJcqkok7Z0/R0In+i1rScBpJlSvrTS2Lm41Pbnw==",
+      "dev": true
+    },
+    "node_modules/@arethetypeswrong/cli": {
+      "version": "0.13.2",
+      "resolved": "https://registry.npmjs.org/@arethetypeswrong/cli/-/cli-0.13.2.tgz",
+      "integrity": "sha512-eqRWeFFiI58xwsiUfZSdZsmNCaqqtxmSPP9554ajiCDrB/aNzq5VktVK7dNiT9PamunNeoej4KbDBnkNwVacvg==",
+      "dev": true,
+      "dependencies": {
+        "@arethetypeswrong/core": "0.13.2",
+        "chalk": "^4.1.2",
+        "cli-table3": "^0.6.3",
+        "commander": "^10.0.1",
+        "marked": "^9.1.2",
+        "marked-terminal": "^6.0.0",
+        "semver": "^7.5.4"
+      },
+      "bin": {
+        "attw": "dist/index.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@arethetypeswrong/core": {
+      "version": "0.13.2",
+      "resolved": "https://registry.npmjs.org/@arethetypeswrong/core/-/core-0.13.2.tgz",
+      "integrity": "sha512-1l6ygar+6TH4o1JipWWGCEZlOhAwEShm1yKx+CgIByNjCzufbu6k9DNbDmBjdouusNRhBIOYQe1UHnJig+GtAw==",
+      "dev": true,
+      "dependencies": {
+        "@andrewbranch/untar.js": "^1.0.3",
+        "fflate": "^0.7.4",
+        "semver": "^7.5.4",
+        "typescript": "5.3.2",
+        "validate-npm-package-name": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@colors/colors": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.5.0.tgz",
+      "integrity": "sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==",
+      "dev": true,
+      "optional": true,
+      "engines": {
+        "node": ">=0.1.90"
+      }
+    },
     "node_modules/@esbuild/linux-loong64": {
       "version": "0.15.7",
       "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.15.7.tgz",
@@ -47,6 +101,18 @@
         "hammer": "hammer"
       }
     },
+    "node_modules/@sindresorhus/is": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz",
+      "integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/is?sponsor=1"
+      }
+    },
     "node_modules/@types/mocha": {
       "version": "9.1.1",
       "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-9.1.1.tgz",
@@ -54,10 +120,13 @@
       "dev": true
     },
     "node_modules/@types/node": {
-      "version": "18.17.2",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.17.2.tgz",
-      "integrity": "sha512-wBo3KqP/PBqje5TI9UTiuL3yWfP6sdPtjtygSOqcYZWT232dfDeDOnkDps5wqZBP9NgGgYrNejinl0faAuE+HQ==",
-      "dev": true
+      "version": "20.10.1",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.10.1.tgz",
+      "integrity": "sha512-T2qwhjWwGH81vUEx4EXmBKsTJRXFXNZTL4v0gi01+zyBmCwzE6TyHszqX01m+QHTEq+EZNo13NeJIdEqf+Myrg==",
+      "dev": true,
+      "dependencies": {
+        "undici-types": "~5.26.4"
+      }
     },
     "node_modules/@ungap/promise-all-settled": {
       "version": "1.1.2",
@@ -107,6 +176,21 @@
         "node": ">=6"
       }
     },
+    "node_modules/ansi-escapes": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-6.2.0.tgz",
+      "integrity": "sha512-kzRaCqXnpzWs+3z5ABPQiVke+iq0KXkHo8xiWV4RPTi5Yli0l97BEQuhXV1s7+aSU/fu1kUuxgS4MsQ0fRuygw==",
+      "dev": true,
+      "dependencies": {
+        "type-fest": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/ansi-regex": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
@@ -131,6 +215,12 @@
         "url": "https://github.com/chalk/ansi-styles?sponsor=1"
       }
     },
+    "node_modules/ansicolors": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/ansicolors/-/ansicolors-0.3.2.tgz",
+      "integrity": "sha512-QXu7BPrP29VllRxH8GwB7x5iX5qWKAAMLqKQGWTeLWVlNHNOpVMJ91dsxQAIWXpjuW5wqvxu3Jd/nRjrJ+0pqg==",
+      "dev": true
+    },
     "node_modules/anymatch": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
@@ -193,6 +283,15 @@
       "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==",
       "dev": true
     },
+    "node_modules/builtins": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/builtins/-/builtins-5.0.1.tgz",
+      "integrity": "sha512-qwVpFEHNfhYJIzNRBvd2C1kyo6jz3ZSMPyyuR47OPdiKWlbYnZNyDWuyR175qDnAJLiCo5fBBqPb3RiXgWlkOQ==",
+      "dev": true,
+      "dependencies": {
+        "semver": "^7.0.0"
+      }
+    },
     "node_modules/camelcase": {
       "version": "6.3.0",
       "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz",
@@ -205,6 +304,19 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/cardinal": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/cardinal/-/cardinal-2.1.1.tgz",
+      "integrity": "sha512-JSr5eOgoEymtYHBjNWyjrMqet9Am2miJhlfKNdqLp6zoeAh0KN5dRAcxlecj5mAJrmQomgiOBj35xHLrFjqBpw==",
+      "dev": true,
+      "dependencies": {
+        "ansicolors": "~0.3.2",
+        "redeyed": "~2.1.0"
+      },
+      "bin": {
+        "cdl": "bin/cdl.js"
+      }
+    },
     "node_modules/chalk": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
@@ -233,6 +345,15 @@
         "node": ">=8"
       }
     },
+    "node_modules/char-regex": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz",
+      "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/chokidar": {
       "version": "3.5.3",
       "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
@@ -260,6 +381,21 @@
         "fsevents": "~2.3.2"
       }
     },
+    "node_modules/cli-table3": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/cli-table3/-/cli-table3-0.6.3.tgz",
+      "integrity": "sha512-w5Jac5SykAeZJKntOxJCrm63Eg5/4dhMWIcuTbo9rpE+brgaSZo0RuNJZeOyMgsUdhDeojvgyQLmjI+K50ZGyg==",
+      "dev": true,
+      "dependencies": {
+        "string-width": "^4.2.0"
+      },
+      "engines": {
+        "node": "10.* || >= 12.*"
+      },
+      "optionalDependencies": {
+        "@colors/colors": "1.5.0"
+      }
+    },
     "node_modules/cliui": {
       "version": "7.0.4",
       "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz",
@@ -289,6 +425,15 @@
       "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
       "dev": true
     },
+    "node_modules/commander": {
+      "version": "10.0.1",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz",
+      "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==",
+      "dev": true,
+      "engines": {
+        "node": ">=14"
+      }
+    },
     "node_modules/concat-map": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
@@ -345,6 +490,12 @@
       "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
       "dev": true
     },
+    "node_modules/emojilib": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/emojilib/-/emojilib-2.4.0.tgz",
+      "integrity": "sha512-5U0rVMU5Y2n2+ykNLQqMoqklN9ICBT/KsvC1Gz6vqHbz2AXXGkG+Pm5rMWk/8Vjrr/mY9985Hi8DYzn1F09Nyw==",
+      "dev": true
+    },
     "node_modules/esbuild": {
       "version": "0.15.7",
       "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.15.7.tgz",
@@ -722,12 +873,31 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/esprima": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+      "dev": true,
+      "bin": {
+        "esparse": "bin/esparse.js",
+        "esvalidate": "bin/esvalidate.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/fast-deep-equal": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
       "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
       "dev": true
     },
+    "node_modules/fflate": {
+      "version": "0.7.4",
+      "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.7.4.tgz",
+      "integrity": "sha512-5u2V/CDW15QM1XbbgS+0DfPxVB+jUKhWEKuuFuHncbk3tEEqzmoXL+2KyOFuKGqOnmdIy0/davWF1CkuwtibCw==",
+      "dev": true
+    },
     "node_modules/fill-range": {
       "version": "7.0.1",
       "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
@@ -1008,6 +1178,62 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/lru-cache": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
+      "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
+      "dev": true,
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/marked": {
+      "version": "9.1.6",
+      "resolved": "https://registry.npmjs.org/marked/-/marked-9.1.6.tgz",
+      "integrity": "sha512-jcByLnIFkd5gSXZmjNvS1TlmRhCXZjIzHYlaGkPlLIekG55JDR2Z4va9tZwCiP+/RDERiNhMOFu01xd6O5ct1Q==",
+      "dev": true,
+      "bin": {
+        "marked": "bin/marked.js"
+      },
+      "engines": {
+        "node": ">= 16"
+      }
+    },
+    "node_modules/marked-terminal": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/marked-terminal/-/marked-terminal-6.1.0.tgz",
+      "integrity": "sha512-QaCSF6NV82oo6K0szEnmc65ooDeW0T/Adcyf0fcW+Hto2GT1VADFg8dn1zaeHqzj65fqDH1hMNChGNRaC/lbkA==",
+      "dev": true,
+      "dependencies": {
+        "ansi-escapes": "^6.2.0",
+        "cardinal": "^2.1.1",
+        "chalk": "^5.3.0",
+        "cli-table3": "^0.6.3",
+        "node-emoji": "^2.1.0",
+        "supports-hyperlinks": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      },
+      "peerDependencies": {
+        "marked": ">=1 <11"
+      }
+    },
+    "node_modules/marked-terminal/node_modules/chalk": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz",
+      "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==",
+      "dev": true,
+      "engines": {
+        "node": "^12.17.0 || ^14.13 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
     "node_modules/minimatch": {
       "version": "4.2.1",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-4.2.1.tgz",
@@ -1081,6 +1307,21 @@
         "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
       }
     },
+    "node_modules/node-emoji": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/node-emoji/-/node-emoji-2.1.3.tgz",
+      "integrity": "sha512-E2WEOVsgs7O16zsURJ/eH8BqhF029wGpEOnv7Urwdo2wmQanOACwJQh0devF9D9RhoZru0+9JXIS0dBXIAz+lA==",
+      "dev": true,
+      "dependencies": {
+        "@sindresorhus/is": "^4.6.0",
+        "char-regex": "^1.0.2",
+        "emojilib": "^2.4.0",
+        "skin-tone": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/normalize-path": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
@@ -1204,6 +1445,15 @@
         "node": ">=8.10.0"
       }
     },
+    "node_modules/redeyed": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/redeyed/-/redeyed-2.1.1.tgz",
+      "integrity": "sha512-FNpGGo1DycYAdnrKFxCMmKYgo/mILAqtRYbkdQD8Ep/Hk2PQ5+aEAEx+IU713RTDmuBaH0c8P5ZozurNu5ObRQ==",
+      "dev": true,
+      "dependencies": {
+        "esprima": "~4.0.0"
+      }
+    },
     "node_modules/require-directory": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
@@ -1242,6 +1492,21 @@
         }
       ]
     },
+    "node_modules/semver": {
+      "version": "7.5.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz",
+      "integrity": "sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==",
+      "dev": true,
+      "dependencies": {
+        "lru-cache": "^6.0.0"
+      },
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/serialize-javascript": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz",
@@ -1251,6 +1516,18 @@
         "randombytes": "^2.1.0"
       }
     },
+    "node_modules/skin-tone": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/skin-tone/-/skin-tone-2.0.0.tgz",
+      "integrity": "sha512-kUMbT1oBJCpgrnKoSr0o6wPtvRWT9W9UKvGLwfJYO2WuahZRHOpEyL1ckyMGgMWh0UdpmaoFqKKD29WTomNEGA==",
+      "dev": true,
+      "dependencies": {
+        "unicode-emoji-modifier-base": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/string-width": {
       "version": "4.2.3",
       "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
@@ -1304,6 +1581,31 @@
         "url": "https://github.com/chalk/supports-color?sponsor=1"
       }
     },
+    "node_modules/supports-hyperlinks": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/supports-hyperlinks/-/supports-hyperlinks-3.0.0.tgz",
+      "integrity": "sha512-QBDPHyPQDRTy9ku4URNGY5Lah8PAaXs6tAAwp55sL5WCsSW7GIfdf6W5ixfziW+t7wh3GVvHyHHyQ1ESsoRvaA==",
+      "dev": true,
+      "dependencies": {
+        "has-flag": "^4.0.0",
+        "supports-color": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=14.18"
+      }
+    },
+    "node_modules/supports-hyperlinks/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/to-regex-range": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
@@ -1316,6 +1618,18 @@
         "node": ">=8.0"
       }
     },
+    "node_modules/type-fest": {
+      "version": "3.13.1",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-3.13.1.tgz",
+      "integrity": "sha512-tLq3bSNx+xSpwvAJnzrK0Ep5CLNWjvFTOp71URMaAEWBfRb9nnJiBoUe0tF8bI4ZFO3omgBR6NvnbzVUT3Ly4g==",
+      "dev": true,
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/typescript": {
       "version": "5.3.2",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.2.tgz",
@@ -1329,6 +1643,21 @@
         "node": ">=14.17"
       }
     },
+    "node_modules/undici-types": {
+      "version": "5.26.5",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
+      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
+      "dev": true
+    },
+    "node_modules/unicode-emoji-modifier-base": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unicode-emoji-modifier-base/-/unicode-emoji-modifier-base-1.0.0.tgz",
+      "integrity": "sha512-yLSH4py7oFH3oG/9K+XWrz1pSi3dfUrWEnInbxMfArOfc1+33BlGPQtLsOYwvdMy11AwUBetYuaRxSPqgkq+8g==",
+      "dev": true,
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/uri-js": {
       "version": "4.4.1",
       "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
@@ -1338,6 +1667,18 @@
         "punycode": "^2.1.0"
       }
     },
+    "node_modules/validate-npm-package-name": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/validate-npm-package-name/-/validate-npm-package-name-5.0.0.tgz",
+      "integrity": "sha512-YuKoXDAhBYxY7SfOKxHBDoSyENFeW5VvIIQp2TGQuit8gpK6MnWaQelBKxso72DoxTZfZdcP3W90LqpSkgPzLQ==",
+      "dev": true,
+      "dependencies": {
+        "builtins": "^5.0.0"
+      },
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -1391,6 +1732,12 @@
         "node": ">=10"
       }
     },
+    "node_modules/yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+      "dev": true
+    },
     "node_modules/yargs": {
       "version": "16.2.0",
       "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz",
@@ -1447,6 +1794,47 @@
     }
   },
   "dependencies": {
+    "@andrewbranch/untar.js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@andrewbranch/untar.js/-/untar.js-1.0.3.tgz",
+      "integrity": "sha512-Jh15/qVmrLGhkKJBdXlK1+9tY4lZruYjsgkDFj08ZmDiWVBLJcqkok7Z0/R0In+i1rScBpJlSvrTS2Lm41Pbnw==",
+      "dev": true
+    },
+    "@arethetypeswrong/cli": {
+      "version": "0.13.2",
+      "resolved": "https://registry.npmjs.org/@arethetypeswrong/cli/-/cli-0.13.2.tgz",
+      "integrity": "sha512-eqRWeFFiI58xwsiUfZSdZsmNCaqqtxmSPP9554ajiCDrB/aNzq5VktVK7dNiT9PamunNeoej4KbDBnkNwVacvg==",
+      "dev": true,
+      "requires": {
+        "@arethetypeswrong/core": "0.13.2",
+        "chalk": "^4.1.2",
+        "cli-table3": "^0.6.3",
+        "commander": "^10.0.1",
+        "marked": "^9.1.2",
+        "marked-terminal": "^6.0.0",
+        "semver": "^7.5.4"
+      }
+    },
+    "@arethetypeswrong/core": {
+      "version": "0.13.2",
+      "resolved": "https://registry.npmjs.org/@arethetypeswrong/core/-/core-0.13.2.tgz",
+      "integrity": "sha512-1l6ygar+6TH4o1JipWWGCEZlOhAwEShm1yKx+CgIByNjCzufbu6k9DNbDmBjdouusNRhBIOYQe1UHnJig+GtAw==",
+      "dev": true,
+      "requires": {
+        "@andrewbranch/untar.js": "^1.0.3",
+        "fflate": "^0.7.4",
+        "semver": "^7.5.4",
+        "typescript": "5.3.2",
+        "validate-npm-package-name": "^5.0.0"
+      }
+    },
+    "@colors/colors": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.5.0.tgz",
+      "integrity": "sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==",
+      "dev": true,
+      "optional": true
+    },
     "@esbuild/linux-loong64": {
       "version": "0.15.7",
       "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.15.7.tgz",
@@ -1463,6 +1851,12 @@
         "esbuild": "0.15.7"
       }
     },
+    "@sindresorhus/is": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz",
+      "integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==",
+      "dev": true
+    },
     "@types/mocha": {
       "version": "9.1.1",
       "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-9.1.1.tgz",
@@ -1470,10 +1864,13 @@
       "dev": true
     },
     "@types/node": {
-      "version": "18.17.2",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.17.2.tgz",
-      "integrity": "sha512-wBo3KqP/PBqje5TI9UTiuL3yWfP6sdPtjtygSOqcYZWT232dfDeDOnkDps5wqZBP9NgGgYrNejinl0faAuE+HQ==",
-      "dev": true
+      "version": "20.10.1",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.10.1.tgz",
+      "integrity": "sha512-T2qwhjWwGH81vUEx4EXmBKsTJRXFXNZTL4v0gi01+zyBmCwzE6TyHszqX01m+QHTEq+EZNo13NeJIdEqf+Myrg==",
+      "dev": true,
+      "requires": {
+        "undici-types": "~5.26.4"
+      }
     },
     "@ungap/promise-all-settled": {
       "version": "1.1.2",
@@ -1508,6 +1905,15 @@
       "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==",
       "dev": true
     },
+    "ansi-escapes": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-6.2.0.tgz",
+      "integrity": "sha512-kzRaCqXnpzWs+3z5ABPQiVke+iq0KXkHo8xiWV4RPTi5Yli0l97BEQuhXV1s7+aSU/fu1kUuxgS4MsQ0fRuygw==",
+      "dev": true,
+      "requires": {
+        "type-fest": "^3.0.0"
+      }
+    },
     "ansi-regex": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
@@ -1523,6 +1929,12 @@
         "color-convert": "^2.0.1"
       }
     },
+    "ansicolors": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/ansicolors/-/ansicolors-0.3.2.tgz",
+      "integrity": "sha512-QXu7BPrP29VllRxH8GwB7x5iX5qWKAAMLqKQGWTeLWVlNHNOpVMJ91dsxQAIWXpjuW5wqvxu3Jd/nRjrJ+0pqg==",
+      "dev": true
+    },
     "anymatch": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
@@ -1576,12 +1988,31 @@
       "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==",
       "dev": true
     },
+    "builtins": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/builtins/-/builtins-5.0.1.tgz",
+      "integrity": "sha512-qwVpFEHNfhYJIzNRBvd2C1kyo6jz3ZSMPyyuR47OPdiKWlbYnZNyDWuyR175qDnAJLiCo5fBBqPb3RiXgWlkOQ==",
+      "dev": true,
+      "requires": {
+        "semver": "^7.0.0"
+      }
+    },
     "camelcase": {
       "version": "6.3.0",
       "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz",
       "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==",
       "dev": true
     },
+    "cardinal": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/cardinal/-/cardinal-2.1.1.tgz",
+      "integrity": "sha512-JSr5eOgoEymtYHBjNWyjrMqet9Am2miJhlfKNdqLp6zoeAh0KN5dRAcxlecj5mAJrmQomgiOBj35xHLrFjqBpw==",
+      "dev": true,
+      "requires": {
+        "ansicolors": "~0.3.2",
+        "redeyed": "~2.1.0"
+      }
+    },
     "chalk": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
@@ -1603,6 +2034,12 @@
         }
       }
     },
+    "char-regex": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz",
+      "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==",
+      "dev": true
+    },
     "chokidar": {
       "version": "3.5.3",
       "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
@@ -1619,6 +2056,16 @@
         "readdirp": "~3.6.0"
       }
     },
+    "cli-table3": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/cli-table3/-/cli-table3-0.6.3.tgz",
+      "integrity": "sha512-w5Jac5SykAeZJKntOxJCrm63Eg5/4dhMWIcuTbo9rpE+brgaSZo0RuNJZeOyMgsUdhDeojvgyQLmjI+K50ZGyg==",
+      "dev": true,
+      "requires": {
+        "@colors/colors": "1.5.0",
+        "string-width": "^4.2.0"
+      }
+    },
     "cliui": {
       "version": "7.0.4",
       "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz",
@@ -1645,6 +2092,12 @@
       "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
       "dev": true
     },
+    "commander": {
+      "version": "10.0.1",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz",
+      "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==",
+      "dev": true
+    },
     "concat-map": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
@@ -1686,6 +2139,12 @@
       "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
       "dev": true
     },
+    "emojilib": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/emojilib/-/emojilib-2.4.0.tgz",
+      "integrity": "sha512-5U0rVMU5Y2n2+ykNLQqMoqklN9ICBT/KsvC1Gz6vqHbz2AXXGkG+Pm5rMWk/8Vjrr/mY9985Hi8DYzn1F09Nyw==",
+      "dev": true
+    },
     "esbuild": {
       "version": "0.15.7",
       "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.15.7.tgz",
@@ -1867,12 +2326,24 @@
       "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
       "dev": true
     },
+    "esprima": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+      "dev": true
+    },
     "fast-deep-equal": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
       "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
       "dev": true
     },
+    "fflate": {
+      "version": "0.7.4",
+      "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.7.4.tgz",
+      "integrity": "sha512-5u2V/CDW15QM1XbbgS+0DfPxVB+jUKhWEKuuFuHncbk3tEEqzmoXL+2KyOFuKGqOnmdIy0/davWF1CkuwtibCw==",
+      "dev": true
+    },
     "fill-range": {
       "version": "7.0.1",
       "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
@@ -2073,6 +2544,43 @@
         "is-unicode-supported": "^0.1.0"
       }
     },
+    "lru-cache": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
+      "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
+      "dev": true,
+      "requires": {
+        "yallist": "^4.0.0"
+      }
+    },
+    "marked": {
+      "version": "9.1.6",
+      "resolved": "https://registry.npmjs.org/marked/-/marked-9.1.6.tgz",
+      "integrity": "sha512-jcByLnIFkd5gSXZmjNvS1TlmRhCXZjIzHYlaGkPlLIekG55JDR2Z4va9tZwCiP+/RDERiNhMOFu01xd6O5ct1Q==",
+      "dev": true
+    },
+    "marked-terminal": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/marked-terminal/-/marked-terminal-6.1.0.tgz",
+      "integrity": "sha512-QaCSF6NV82oo6K0szEnmc65ooDeW0T/Adcyf0fcW+Hto2GT1VADFg8dn1zaeHqzj65fqDH1hMNChGNRaC/lbkA==",
+      "dev": true,
+      "requires": {
+        "ansi-escapes": "^6.2.0",
+        "cardinal": "^2.1.1",
+        "chalk": "^5.3.0",
+        "cli-table3": "^0.6.3",
+        "node-emoji": "^2.1.0",
+        "supports-hyperlinks": "^3.0.0"
+      },
+      "dependencies": {
+        "chalk": {
+          "version": "5.3.0",
+          "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz",
+          "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==",
+          "dev": true
+        }
+      }
+    },
     "minimatch": {
       "version": "4.2.1",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-4.2.1.tgz",
@@ -2126,6 +2634,18 @@
       "integrity": "sha512-n6Vs/3KGyxPQd6uO0eH4Bv0ojGSUvuLlIHtC3Y0kEO23YRge8H9x1GCzLn28YX0H66pMkxuaeESFq4tKISKwdw==",
       "dev": true
     },
+    "node-emoji": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/node-emoji/-/node-emoji-2.1.3.tgz",
+      "integrity": "sha512-E2WEOVsgs7O16zsURJ/eH8BqhF029wGpEOnv7Urwdo2wmQanOACwJQh0devF9D9RhoZru0+9JXIS0dBXIAz+lA==",
+      "dev": true,
+      "requires": {
+        "@sindresorhus/is": "^4.6.0",
+        "char-regex": "^1.0.2",
+        "emojilib": "^2.4.0",
+        "skin-tone": "^2.0.0"
+      }
+    },
     "normalize-path": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
@@ -2207,6 +2727,15 @@
         "picomatch": "^2.2.1"
       }
     },
+    "redeyed": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/redeyed/-/redeyed-2.1.1.tgz",
+      "integrity": "sha512-FNpGGo1DycYAdnrKFxCMmKYgo/mILAqtRYbkdQD8Ep/Hk2PQ5+aEAEx+IU713RTDmuBaH0c8P5ZozurNu5ObRQ==",
+      "dev": true,
+      "requires": {
+        "esprima": "~4.0.0"
+      }
+    },
     "require-directory": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
@@ -2225,6 +2754,15 @@
       "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
       "dev": true
     },
+    "semver": {
+      "version": "7.5.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz",
+      "integrity": "sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==",
+      "dev": true,
+      "requires": {
+        "lru-cache": "^6.0.0"
+      }
+    },
     "serialize-javascript": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz",
@@ -2234,6 +2772,15 @@
         "randombytes": "^2.1.0"
       }
     },
+    "skin-tone": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/skin-tone/-/skin-tone-2.0.0.tgz",
+      "integrity": "sha512-kUMbT1oBJCpgrnKoSr0o6wPtvRWT9W9UKvGLwfJYO2WuahZRHOpEyL1ckyMGgMWh0UdpmaoFqKKD29WTomNEGA==",
+      "dev": true,
+      "requires": {
+        "unicode-emoji-modifier-base": "^1.0.0"
+      }
+    },
     "string-width": {
       "version": "4.2.3",
       "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
@@ -2269,6 +2816,27 @@
         "has-flag": "^4.0.0"
       }
     },
+    "supports-hyperlinks": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/supports-hyperlinks/-/supports-hyperlinks-3.0.0.tgz",
+      "integrity": "sha512-QBDPHyPQDRTy9ku4URNGY5Lah8PAaXs6tAAwp55sL5WCsSW7GIfdf6W5ixfziW+t7wh3GVvHyHHyQ1ESsoRvaA==",
+      "dev": true,
+      "requires": {
+        "has-flag": "^4.0.0",
+        "supports-color": "^7.0.0"
+      },
+      "dependencies": {
+        "supports-color": {
+          "version": "7.2.0",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+          "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+          "dev": true,
+          "requires": {
+            "has-flag": "^4.0.0"
+          }
+        }
+      }
+    },
     "to-regex-range": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
@@ -2278,12 +2846,30 @@
         "is-number": "^7.0.0"
       }
     },
+    "type-fest": {
+      "version": "3.13.1",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-3.13.1.tgz",
+      "integrity": "sha512-tLq3bSNx+xSpwvAJnzrK0Ep5CLNWjvFTOp71URMaAEWBfRb9nnJiBoUe0tF8bI4ZFO3omgBR6NvnbzVUT3Ly4g==",
+      "dev": true
+    },
     "typescript": {
       "version": "5.3.2",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.2.tgz",
       "integrity": "sha512-6l+RyNy7oAHDfxC4FzSJcz9vnjTKxrLpDG5M2Vu4SHRVNg6xzqZp6LYSR9zjqQTu8DU/f5xwxUdADOkbrIX2gQ==",
       "dev": true
     },
+    "undici-types": {
+      "version": "5.26.5",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
+      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
+      "dev": true
+    },
+    "unicode-emoji-modifier-base": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unicode-emoji-modifier-base/-/unicode-emoji-modifier-base-1.0.0.tgz",
+      "integrity": "sha512-yLSH4py7oFH3oG/9K+XWrz1pSi3dfUrWEnInbxMfArOfc1+33BlGPQtLsOYwvdMy11AwUBetYuaRxSPqgkq+8g==",
+      "dev": true
+    },
     "uri-js": {
       "version": "4.4.1",
       "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
@@ -2293,6 +2879,15 @@
         "punycode": "^2.1.0"
       }
     },
+    "validate-npm-package-name": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/validate-npm-package-name/-/validate-npm-package-name-5.0.0.tgz",
+      "integrity": "sha512-YuKoXDAhBYxY7SfOKxHBDoSyENFeW5VvIIQp2TGQuit8gpK6MnWaQelBKxso72DoxTZfZdcP3W90LqpSkgPzLQ==",
+      "dev": true,
+      "requires": {
+        "builtins": "^5.0.0"
+      }
+    },
     "which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -2331,6 +2926,12 @@
       "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
       "dev": true
     },
+    "yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+      "dev": true
+    },
     "yargs": {
       "version": "16.2.0",
       "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz",
diff --git a/package.json b/package.json
index 064dc20a4..342d3bc79 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.28",
-  "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
+  "version": "0.32.0",
+  "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
     "json-schema",
@@ -10,28 +10,6 @@
   ],
   "author": "sinclairzx81",
   "license": "MIT",
-  "main": "./typebox.js",
-  "types": "./typebox.d.ts",
-  "exports": {
-    "./compiler": "./compiler/index.js",
-    "./errors": "./errors/index.js",
-    "./system": "./system/index.js",
-    "./value/cast": "./value/cast.js",
-    "./value/check": "./value/check.js",
-    "./value/clone": "./value/clone.js",
-    "./value/convert": "./value/convert.js",
-    "./value/create": "./value/create.js",
-    "./value/delta": "./value/delta.js",
-    "./value/deref": "./value/deref.js",
-    "./value/equal": "./value/equal.js",
-    "./value/guard": "./value/guard.js",
-    "./value/hash": "./value/hash.js",
-    "./value/mutate": "./value/mutate.js",
-    "./value/pointer": "./value/pointer.js",
-    "./value/transform": "./value/transform.js",
-    "./value": "./value/index.js",
-    ".": "./typebox.js"
-  },
   "repository": {
     "type": "git",
     "url": "https://github.com/sinclairzx81/typebox"
@@ -40,21 +18,21 @@
     "test:typescript": "hammer task test_typescript",
     "test:static": "hammer task test_static",
     "test:runtime": "hammer task test_runtime",
+    "install:local": "hammer task install_local",
+    "benchmark": "hammer task benchmark",
+    "build": "hammer task build",
     "test": "hammer task test",
     "clean": "hammer task clean",
     "format": "hammer task format",
     "start": "hammer task start",
-    "benchmark:compression": "hammer task benchmark_compression",
-    "benchmark:measurement": "hammer task benchmark_measurement",
-    "benchmark": "hammer task benchmark",
-    "build": "hammer task build",
     "publish": "hammer task publish",
     "publish:dev": "hammer task publish_dev"
   },
   "devDependencies": {
+    "@arethetypeswrong/cli": "^0.13.2",
     "@sinclair/hammer": "^0.18.0",
     "@types/mocha": "^9.1.1",
-    "@types/node": "^18.11.9",
+    "@types/node": "^20.10.1",
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
     "mocha": "^9.2.2",
diff --git a/readme.md b/readme.md
index 8ba350169..d6671201b 100644
--- a/readme.md
+++ b/readme.md
@@ -20,21 +20,14 @@
 
 ## Install
 
-#### Npm
 ```bash
 $ npm install @sinclair/typebox --save
 ```
 
-#### Esm + Deno
-
-```typescript
-import { Type, Static } from 'https://esm.sh/@sinclair/typebox'
-```
-
 ## Example
 
 ```typescript
-import { Type, Static } from '@sinclair/typebox'
+import { Type, type Static } from '@sinclair/typebox'
 
 const T = Type.Object({                              // const T = {
   x: Type.Number(),                                  //   type: 'object',
@@ -58,9 +51,9 @@ type T = Static<typeof T>                            // type T = {
 
 ## Overview
 
-TypeBox is a runtime type builder that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type assertion rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
+TypeBox is a runtime type builder that creates in-memory Json Schema objects that infer as TypeScript types. The schematics produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript and runtime asserted using standard Json Schema validation.
 
-This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire.
+This library is built to be a runtime type system offering similar capabilities to TypeScript's static type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.
 
 License MIT
 
@@ -71,17 +64,19 @@ License MIT
 - [Types](#types)
   - [Json](#types-json)
   - [JavaScript](#types-javascript)
+  - [Import](#types-import)
   - [Options](#types-options)
   - [Properties](#types-properties)
   - [Generics](#types-generics)
   - [References](#types-references)
   - [Recursive](#types-recursive)
-  - [Conditional](#types-conditional)
-  - [Template Literal](#types-templateliteral)
+  - [Template Literal](#types-template-literal)
   - [Indexed](#types-indexed)
-  - [Rest](#types-rest)
-  - [Transform](#types-transform)
+  - [Mapped](#types-mapped)
+  - [Conditional](#types-conditional)
   - [Intrinsic](#types-intrinsic)
+  - [Transform](#types-transform)
+  - [Rest](#types-rest)
   - [Guard](#types-guard)
   - [Unsafe](#types-unsafe)
   - [Strict](#types-strict)
@@ -90,6 +85,8 @@ License MIT
   - [Clone](#values-clone)
   - [Check](#values-check)
   - [Convert](#values-convert)
+  - [Default](#values-default)
+  - [Clean](#values-clean)
   - [Cast](#values-cast)
   - [Decode](#values-decode)
   - [Encode](#values-decode)
@@ -107,10 +104,8 @@ License MIT
   - [Ajv](#typecheck-ajv)
   - [TypeCompiler](#typecheck-typecompiler)
 - [TypeSystem](#typesystem)
-  - [Types](#typesystem-types)
-  - [Formats](#typesystem-formats)
-  - [Errors](#typesystem-errors)
   - [Policies](#typesystem-policies)
+- [Error Function](#error-function)
 - [Workbench](#workbench)
 - [Codegen](#codegen)
 - [Ecosystem](#ecosystem)
@@ -127,7 +122,7 @@ License MIT
 The following shows general usage.
 
 ```typescript
-import { Type, Static } from '@sinclair/typebox'
+import { Type, type Static } from '@sinclair/typebox'
 
 //--------------------------------------------------------------------------------------------
 //
@@ -297,6 +292,22 @@ The following table lists the supported Json types. These types are fully compat
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Const({         │ type T = {                  │ const T = {                    │
+│   x: 1,                        │   readonly x: 1,            │   type: 'object',              │
+│   y: 2,                        │   readonly y: 2             │   required: ['x', 'y'],        │
+│ } as const)                    │ }                           │   properties: {                │
+│                                │                             │     x: {                       │
+│                                │                             │       type: 'number',          │
+│                                │                             │       const: 1                 │
+│                                │                             │     },                         │
+│                                │                             │     y: {                       │
+│                                │                             │       type: 'number',          │
+│                                │                             │       const: 2                 │
+│                                │                             │     }                          │
+│                                │                             │   }                            │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.KeyOf(          │ type T = keyof {            │ const T = {                    │
 │   Type.Object({                │   x: number,                │   anyOf: [{                    │
 │     x: Type.Number(),          │   y: number                 │     type: 'string',            │
@@ -365,8 +376,8 @@ The following table lists the supported Json types. These types are fully compat
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Extends(        │ type T =                    │ const T = {                    │
 │   Type.String(),               │  string extends number      │   const: false,                │
-│   Type.Number(),               │  true : false               │   type: 'boolean'              │
-│   Type.Literal(true),          │                             │ }                              │
+│   Type.Number(),               │    ? true                   │   type: 'boolean'              │
+│   Type.Literal(true),          │    : false                  │ }                              │
 │   Type.Literal(false)          │                             │                                │
 │ )                              │                             │                                │
 │                                │                             │                                │
@@ -389,6 +400,20 @@ The following table lists the supported Json types. These types are fully compat
 │ )                              │                             │                                │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Mapped(         │ type T = {                  │ const T = {                    │
+│   Type.Union([                 │   [_ in 'x' | 'y'] : number │   type: 'object',              │
+│     Type.Literal('x'),         │ }                           │   required: ['x', 'y'],        │
+│     Type.Literal('y')          │                             │   properties: {                │
+│   ]),                          │                             │     x: {                       │
+│   () => Type.Number()          │                             │       type: 'number'           │
+│ )                              │                             │     },                         │
+│                                │                             │     y: {                       │
+│                                │                             │       type: 'number'           │
+│                                │                             │     }                          │
+│                                │                             │   }                            │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const U = Type.Union([         │ type U = 'open' | 'close'   │ const T = {                    │
 │   Type.Literal('open'),        │                             │   type: 'string',              │
 │   Type.Literal('close')        │ type T = `on${U}`           │   pattern: '^on(open|close)$'  │
@@ -580,9 +605,10 @@ TypeBox provides an extended type set that can be used to create schematics for
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.RegExp(/abc/)   │ type T = string             │ const T = {                    │
-│                                │                             │   type: 'string'               │
-│                                │                             │   pattern: 'abc'               │
+│ const T = Type.RegExp(/abc/i)  │ type T = string             │ const T = {                    │
+│                                │                             │   type: 'RegExp'               │
+│                                │                             │   source: 'abc'                │
+│                                │                             │   flags: 'i'                   │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -618,11 +644,27 @@ TypeBox provides an extended type set that can be used to create schematics for
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
+<a name='types-import'></a>
+
+### Import
+
+Import the Type namespace to bring in TypeBox's full type system. This is recommended for most users.
+
+```typescript
+import { Type, type Static } from '@sinclair/typebox'
+```
+
+You can also selectively import types. This enables modern bundlers to tree shake for unused types.
+
+```typescript
+import { Object, Number, String, Boolean, type Static } from '@sinclair/typebox'
+```
+
 <a name='types-options'></a>
 
 ### Options
 
-You can pass Json Schema options on the last argument of any type. Option hints specific to each type are provided for convenience.
+You can pass Json Schema options on the last argument of any given type. Option hints specific to each type are provided for convenience.
 
 ```typescript
 // String must be an email
@@ -690,35 +732,27 @@ Object properties can be modified with Readonly and Optional. The following tabl
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
+
 <a name='types-generics'></a>
 
 ### Generic Types
 
-Generic types can be created with generic functions. All types extend the base type TSchema. It is common to constrain generic function arguments to this type. The following creates a generic Vector type.
+Generic types can be created with functions. TypeBox types extend the TSchema interface so you should constrain parameters to this type. The following creates a generic Vector type.
 
 ```typescript
-import { Type, Static, TSchema } from '@sinclair/typebox'
+import { Type, type Static, type TSchema } from '@sinclair/typebox'
 
-const Vector = <T extends TSchema>(t: T) => Type.Object({ x: t, y: t, z: t })
+const Vector = <T extends TSchema>(T: T) => 
+  Type.Object({                                      // type Vector<T> = {
+    x: T,                                            //   x: T,
+    y: T,                                            //   y: T,
+    z: T                                             //   z: T
+  })                                                 // }
 
-const NumberVector = Vector(Type.Number())           // const NumberVector = {
-                                                     //   type: 'object',
-                                                     //   required: ['x', 'y', 'z'],
-                                                     //   properties: {
-                                                     //     x: { type: 'number' },
-                                                     //     y: { type: 'number' },
-                                                     //     z: { type: 'number' }
-                                                     //   }
-                                                     // }
-
-type NumberVector = Static<typeof NumberVector>      // type NumberVector = {
-                                                     //   x: number,
-                                                     //   y: number,
-                                                     //   z: number
-                                                     // }
+const NumberVector = Vector(Type.Number())           // type NumberVector = Vector<number>
 ```
 
-Generic types are often used to create aliases for more complex types. The following creates a Nullable generic type.
+Generic types are often used to create aliases for complex types. The following creates a Nullable generic type.
 
 ```typescript
 const Nullable = <T extends TSchema>(schema: T) => Type.Union([schema, Type.Null()])
@@ -737,26 +771,69 @@ type T = Static<typeof T>                            // type T = string | null
 
 ### Reference Types
 
-Reference types are supported with Ref.
+Reference types can be created with Ref. These types infer the same as the target type but only store a named `$ref` to the target type.
 
 ```typescript
-const T = Type.String({ $id: 'T' })                  // const T = {
-                                                     //   $id: 'T',
-                                                     //   type: 'string'
-                                                     // } 
+const Vector = Type.Object({                         // const Vector = {
+  x: Type.Number(),                                  //   type: 'object',
+  y: Type.Number(),                                  //   required: ['x', 'y', 'z'],
+}, { $id: 'Vector' })                                //   properties: {
+                                                     //     x: { type: 'number' },
+                                                     //     y: { type: 'number' }
+                                                     //   },
+                                                     //   $id: 'Vector'
+                                                     // }
 
-const R = Type.Ref<typeof T>('T')                    // const R = {
-                                                     //   $ref: 'T'
+const VectorRef = Type.Ref(Vector)                   // const VectorRef = {
+                                                     //   $ref: 'Vector'
                                                      // }
 
-type R = Static<typeof R>                            // type R = string
+type VectorRef = Static<typeof VectorRef>            // type VectorRef = {
+                                                     //    x: number,
+                                                     //    y: number
+                                                     // }
+```
+Use Deref to dereference a type. This function will replace any interior reference with the target type.
+```typescript
+const Vertex = Type.Object({                         // const Vertex = {
+  position: VectorRef,                               //   type: 'object',
+  texcoord: VectorRef,                               //   required: ['position', 'texcoord'],
+})                                                   //   properties: {
+                                                     //     position: { $ref: 'Vector' },
+                                                     //     texcoord: { $ref: 'Vector' }
+                                                     //   }
+                                                     // }
+
+const VertexDeref = Type.Deref(Vertex, [Vector])     // const VertexDeref = {
+                                                     //   type: 'object',
+                                                     //   required: ['position', 'texcoord'],
+                                                     //   properties: {
+                                                     //     position: {
+                                                     //       type: 'object',
+                                                     //       required: ['x', 'y', 'z'],
+                                                     //       properties: {
+                                                     //         x: { type: 'number' },
+                                                     //         y: { type: 'number' }
+                                                     //       }
+                                                     //     },
+                                                     //     texcoord: {
+                                                     //       type: 'object',
+                                                     //       required: ['x', 'y', 'z'],
+                                                     //       properties: {
+                                                     //         x: { type: 'number' },
+                                                     //         y: { type: 'number' }
+                                                     //       }
+                                                     //     }
+                                                     //   }
+                                                     // }
 ```
+Note that Ref types do not store structural information about the type they're referencing. Because of this, these types cannot be used with some mapping types (such as Partial or Pick). For applications that require mapping on Ref, use Deref to normalize the type first.
 
 <a name='types-recursive'></a>
 
 ### Recursive Types
 
-TypeBox supports singular recursive data structures. Recursive type inference is also supported. The following creates a recursive Node data structure.
+TypeBox supports recursive data structures with Recursive. This type wraps an interior type and provides it a `this` context that allows the type to reference itself. The following creates a recursive type. Singular recursive inference is also supported.
 
 ```typescript
 const Node = Type.Recursive(This => Type.Object({    // const Node = {
@@ -789,175 +866,187 @@ function test(node: Node) {
 }
 ```
 
-<a name='types-conditional'></a>
+<a name='types-template-literal'></a>
 
-### Conditional Types
+### Template Literal Types
 
-TypeBox supports runtime conditional types with Extends. This type will perform a structural assignability check for the first two arguments and returns one of the second two arguments based on the result. The Extends type is modelled after TypeScript conditional types. The Exclude and Extract conditional types are also supported.
+TypeBox supports template literal types with TemplateLiteral. This type can be created using a syntax similar to the TypeScript template literal syntax or composed from exterior types. TypeBox encodes template literals as regular expressions which enables the template to be checked by Json Schema validators. This type also supports regular expression parsing that enables template patterns to be used for generative types. The following shows both TypeScript and TypeBox usage.
 
 ```typescript
 // TypeScript
 
-type T0 = string extends number ? true : false       // type T0 = false
-
-type T1 = Extract<(1 | 2 | 3), 1>                    // type T1 = 1
+type K = `prop${'A'|'B'|'C'}`                        // type T = 'propA' | 'propB' | 'propC'
 
-type T2 = Exclude<(1 | 2 | 3), 1>                    // type T2 = 2 | 3
+type R = Record<K, string>                           // type R = {
+                                                     //   propA: string
+                                                     //   propB: string
+                                                     //   propC: string
+                                                     // }
 
 // TypeBox
 
-const T0 = Type.Extends(                             // const T0: TLiteral<false> = {
-  Type.String(),                                     //   type: 'boolean',
-  Type.Number(),                                     //   const: false
-  Type.Literal(true),                                // }
-  Type.Literal(false)
-)
-
-const T1 = Type.Extract(                             // const T1: TLiteral<1> = {
-  Type.Union([                                       //   type: 'number',
-    Type.Literal(1),                                 //   const: 1
-    Type.Literal(2),                                 // }
-    Type.Literal(3) 
-  ]), 
-  Type.Literal(1)
-)
+const K = Type.TemplateLiteral('prop${A|B|C}')       // const K: TTemplateLiteral<[
+                                                     //   TLiteral<'prop'>,
+                                                     //   TUnion<[
+                                                     //      TLiteral<'A'>,
+                                                     //      TLiteral<'B'>,
+                                                     //      TLiteral<'C'>,
+                                                     //   ]>
+                                                     // ]>
 
-const T2 = Type.Exclude(                             // const T2: TUnion<[
-  Type.Union([                                       //   TLiteral<2>,
-    Type.Literal(1),                                 //   TLiteral<3>
-    Type.Literal(2),                                 // ]> = {
-    Type.Literal(3)                                  //   anyOf: [{
-  ]),                                                //     type: 'number',
-  Type.Literal(1)                                    //     const: 2
-)                                                    //   }, {
-                                                     //     type: 'number',
-                                                     //     const: 3
-                                                     //   }]
-                                                     // }
+const R = Type.Record(K, Type.String())              // const R: TObject<{
+                                                     //   hello1: TString,
+                                                     //   hello2: TString,
+                                                     //   hello3: TString,
+                                                     // }>
 ```
 
-<a name='types-templateliteral'></a>
+<a name='types-indexed'></a>
 
-### Template Literal Types
+### Indexed Access Types
 
-TypeBox supports template literal types with TemplateLiteral. This type can be created using a string syntax that is similar to the TypeScript template literal syntax. This type can also be constructed by passing an array of Union and Literal types in sequence. The following example shows the string syntax.
+TypeBox supports indexed access types with Index. This type enables uniform access to interior property and element types without having to extract them from the underlying schema representation. This type is supported for Object, Array, Tuple, Union and Intersect types.
 
 ```typescript
-// TypeScript
+const T = Type.Object({                              // type T = {
+  x: Type.Number(),                                  //   x: number,
+  y: Type.String(),                                  //   y: string,
+  z: Type.Boolean()                                  //   z: boolean
+})                                                   // }
+
+const A = Type.Index(T, ['x'])                       // type A = T['x']
+                                                     //
+                                                     // ... evaluated as
+                                                     //
+                                                     // const A: TNumber
+
+const B = Type.Index(T, ['x', 'y'])                  // type B = T['x' | 'y']
+                                                     //
+                                                     // ... evaluated as
+                                                     //
+                                                     // const B: TUnion<[
+                                                     //   TNumber,
+                                                     //   TString,
+                                                     // ]>
 
-type T = `option${'A'|'B'|'C'}`                      // type T = 'optionA' | 'optionB' | 'optionC'
+const C = Type.Index(T, Type.KeyOf(T))               // type C = T[keyof T]
+                                                     //
+                                                     // ... evaluated as
+                                                     // 
+                                                     // const C: TUnion<[
+                                                     //   TNumber,
+                                                     //   TString,
+                                                     //   TBoolean
+                                                     // ]>
+```
 
-type R = Record<T, string>                           // type R = {
-                                                     //   optionA: string
-                                                     //   optionB: string
-                                                     //   optionC: string
-                                                     // }
+<a name='types-mapped'></a>
 
-// TypeBox
+### Mapped Types
 
-const T = Type.TemplateLiteral('option${A|B|C}')     // const T = {
-                                                     //   pattern: '^option(A|B|C)$',
-                                                     //   type: 'string'
-                                                     // }
+TypeBox supports mapped object types with Mapped. This type accepts two arguments, the first is a union type typically derived from KeyOf, the second is a mapping function that receives a mapping key `K` that can be used to index properties of a type. The following implements Partial using mapped types.
 
-const R = Type.Record(T, Type.String())              // const R = {
-                                                     //   type: 'object',
-                                                     //   required: ['optionA', 'optionB'],
-                                                     //   properties: {
-                                                     //     optionA: {
-                                                     //       type: 'string'
-                                                     //     },
-                                                     //     optionB: {
-                                                     //       type: 'string'
-                                                     //     }
-                                                     //     optionC: {
-                                                     //       type: 'string'
-                                                     //     }
-                                                     //   }
-                                                     // }
+```typescript
+const T = Type.Object({                              // type T = {
+  x: Type.Number(),                                  //   x: number,
+  y: Type.String(),                                  //   y: string,
+  z: Type.Boolean()                                  //   z: boolean
+})                                                   // }
+
+const M = Type.Mapped(Type.KeyOf(T), K => {          // type M = { [K in keyof T]?: T[K] }
+  return Type.Optional(Type.Index(T, K))             //
+})                                                   // ... evaluated as
+                                                     // 
+                                                     // const M: TObject<{
+                                                     //   x: TOptional<TNumber>,
+                                                     //   y: TOptional<TString>,
+                                                     //   z: TOptional<TBoolean>
+                                                     // }>
 ```
 
-<a name='types-indexed'></a>
+<a name='types-conditional'></a>
 
-### Indexed Access Types
+### Conditional Types
 
-TypeBox supports Indexed Access Types with Index. This type enables uniform access to interior property and array element types without having to extract them from the underlying schema representation. This type is supported for Object, Array, Tuple, Union and Intersect types.
+TypeBox supports runtime conditional types with Extends. This type performs a structural assignability check against the first (`left`) and second (`right`) arguments and will return either the third (`true`) or fourth (`false`) argument based on the result. The conditional types Exclude and Extract are also supported. The following shows both TypeScript and TypeBox examples of conditional types.
 
 ```typescript
-const T = Type.Object({                              // const T = {
-  x: Type.Number(),                                  //   type: 'object',
-  y: Type.String(),                                  //   required: ['x', 'y', 'z'],
-  z: Type.Boolean()                                  //   properties: {
-})                                                   //     x: { type: 'number' },
-                                                     //     y: { type: 'string' },
-                                                     //     z: { type: 'string' }
-                                                     //   }
-                                                     // }
-
-const A = Type.Index(T, ['x'])                       // const A = { type: 'number' }
+// Extends
+const A = Type.Extends(                              // type A = string extends number ? 1 : 2
+  Type.String(),                                     //   
+  Type.Number(),                                     // ... evaluated as
+  Type.Literal(1),                                   //
+  Type.Literal(2)                                    // const A: TLiteral<2>
+)
 
-const B = Type.Index(T, ['x', 'y'])                  // const B = {
-                                                     //   anyOf: [
-                                                     //     { type: 'number' },
-                                                     //     { type: 'string' }
-                                                     //   ]
-                                                     // }
+// Extract
+const B = Type.Extract(                              // type B = Extract<1 | 2 | 3, 1>
+  Type.Union([                                       //
+    Type.Literal(1),                                 // ... evaluated as
+    Type.Literal(2),                                 //
+    Type.Literal(3)                                  // const B: TLiteral<1>
+  ]), 
+  Type.Literal(1)
+)
 
-const C = Type.Index(T, Type.KeyOf(T))               // const C = {
-                                                     //   anyOf: [
-                                                     //     { type: 'number' },
-                                                     //     { type: 'string' },
-                                                     //     { type: 'boolean' }
-                                                     //   ]
-                                                     // }
+// Exclude
+const C = Type.Exclude(                              // type C = Exclude<1 | 2 | 3, 1>
+  Type.Union([                                       // 
+    Type.Literal(1),                                 // ... evaluated as
+    Type.Literal(2),                                 //
+    Type.Literal(3)                                  // const C: TUnion<[
+  ]),                                                //   TLiteral<2>,
+  Type.Literal(1)                                    //   TLiteral<3>,
+)                                                    // ]>
 ```
 
-<a name='types-rest'></a>
+<a name='types-intrinsic'></a>
 
-### Rest Types
+### Intrinsic Types
 
-TypeBox provides the Rest type to uniformly extract variadic tuples from Intersect, Union and Tuple types. This type can be useful to remap variadic types into different forms. The following uses Rest to remap a Tuple into a Union.
+TypeBox supports the TypeScript intrinsic string manipulation types Uppercase, Lowercase, Capitalize and Uncapitalize. These types can be used to remap Literal, Template Literal and Union of Literal types.
 
 ```typescript
-const T = Type.Tuple([                               // const T = {
-  Type.String(),                                     //   type: 'array',
-  Type.Number()                                      //   items: [ 
-])                                                   //     { type: 'string' },
-                                                     //     { type: 'number' }
-                                                     //   ],
-                                                     //   additionalItems: false,
-                                                     //   minItems: 2,
-                                                     //   maxItems: 2,
-                                                     // }
+// TypeScript
+type A = Capitalize<'hello'>                         // type A = 'Hello'
 
-const R = Type.Rest(T)                               // const R = [
-                                                     //   { type: 'string' },
-                                                     //   { type: 'number' }
-                                                     // ]
+type B = Capitalize<'hello' | 'world'>               // type C = 'Hello' | 'World'
 
-const U = Type.Union(R)                              // const U = {
-                                                     //   anyOf: [
-                                                     //     { type: 'string' },
-                                                     //     { type: 'number' }
-                                                     //   ]
-                                                     // }
+type C = Capitalize<`hello${1|2|3}`>                 // type B = 'Hello1' | 'Hello2' | 'Hello3'
+
+// TypeBox
+const A = Type.Capitalize(Type.Literal('hello'))     // const A: TLiteral<'Hello'>
+
+const B = Type.Capitalize(Type.Union([               // const B: TUnion<[
+  Type.Literal('hello'),                             //   TLiteral<'Hello'>,
+  Type.Literal('world')                              //   TLiteral<'World'>
+]))                                                  // ]>
+
+const C = Type.Capitalize(                           // const C: TTemplateLiteral<[
+  Type.TemplateLiteral('hello${1|2|3}')              //   TLiteral<'Hello'>,
+)                                                    //   TUnion<[
+                                                     //     TLiteral<'1'>,
+                                                     //     TLiteral<'2'>,
+                                                     //     TLiteral<'3'>
+                                                     //   ]>
+                                                     // ]>
 ```
 
 <a name='types-transform'></a>
 
 ### Transform Types
 
-TypeBox supports value decoding and encoding with Transform types. These types work in tandem with the Encode and Decode functions available on the Value and TypeCompiler modules. Transform types can be used to convert Json encoded values into constructs more natural to JavaScript. The following creates a Transform type to decode numbers into Dates using the Value module.
+TypeBox supports value decoding and encoding with Transform types. These types work in tandem with the Encode and Decode functions available on the Value and TypeCompiler submodules. Transform types can be used to convert Json encoded values into constructs more natural to JavaScript. The following creates a Transform type to decode numbers into Dates using the Value submodule.
 
 ```typescript
 import { Value } from '@sinclair/typebox/value'
 
 const T = Type.Transform(Type.Number())
-  .Decode(value => new Date(value))                  // required: number to Date
-  .Encode(value => value.getTime())                  // required: Date to number
+  .Decode(value => new Date(value))                  // decode: number to Date
+  .Encode(value => value.getTime())                  // encode: Date to number
 
-const decoded = Value.Decode(T, 0)                   // const decoded = Date(1970-01-01T00:00:00.000Z)
-const encoded = Value.Encode(T, decoded)             // const encoded = 0
+const D = Value.Decode(T, 0)                         // const D = Date(1970-01-01T00:00:00.000Z)
+const E = Value.Encode(T, D)                         // const E = 0
 ```
 Use the StaticEncode or StaticDecode types to infer a Transform type.
 ```typescript
@@ -972,35 +1061,23 @@ type E = StaticEncode<typeof T>                      // type E = Array<number>
 type T = Static<typeof T>                            // type T = Array<number>
 ```
 
-<a name='types-intrinsic'></a>
+<a name='types-rest'></a>
 
-### Intrinsic Types
+### Rest Types
 
-TypeBox supports the TypeScript Intrinsic String Manipulation types Uppercase, Lowercase, Capitalize and Uncapitalize. These types can be used to remap String Literal, TemplateLiteral and Union types.
+TypeBox provides the Rest type to uniformly extract variadic tuples from Intersect, Union and Tuple types. This type can be useful to remap variadic types into different forms. The following uses Rest to remap a Tuple into a Union.
 
 ```typescript
-// TypeScript
-
-type A = Capitalize<'hello'>                         // type A = 'Hello'
-type B = Capitalize<'hello' | 'world'>               // type C = 'Hello' | 'World'
-type C = Capitalize<`hello${1|2|3}`>                 // type B = 'Hello1' | 'Hello2' | 'Hello3'
-
-// TypeBox
-
-const A = Type.Capitalize(Type.Literal('hello'))     // const A: TLiteral<'Hello'>
+const T = Type.Tuple([                               // const T: TTuple<[
+  Type.String(),                                     //   TString,
+  Type.Number()                                      //   TNumber
+])                                                   // ]>
 
-const B = Type.Capitalize(Type.Union([               // const B: TUnion<[
-  Type.Literal('hello'),                             //   TLiteral<'Hello'>,
-  Type.Literal('world')                              //   TLiteral<'World'>
-]))                                                  // ]>
+const R = Type.Rest(T)                               // const R: [TString, TNumber]
 
-const C = Type.Capitalize(                           // const C: TTemplateLiteral<[
-  Type.TemplateLiteral('hello${1|2|3}')              //   TLiteral<'Hello'>,
-)                                                    //   TUnion<[
-                                                     //     TLiteral<'1'>,
-                                                     //     TLiteral<'2'>,
-                                                     //     TLiteral<'3'>
-                                                     //   ]>
+const U = Type.Union(R)                              // const T: TUnion<[
+                                                     //   TString,
+                                                     //   TNumber
                                                      // ]>
 ```
 
@@ -1011,13 +1088,11 @@ const C = Type.Capitalize(                           // const C: TTemplateLitera
 TypeBox supports user defined types with Unsafe. This type allows you to specify both schema representation and inference type. The following creates an Unsafe type with a number schema that infers as string.
 
 ```typescript
-const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
-                                                     //   type: 'number'
-                                                     // }
+const T = Type.Unsafe<string>({ type: 'number' })    // const T = { type: 'number' }
 
 type T = Static<typeof T>                            // type T = string - ?
 ```
-The Unsafe type is often used to create schematics for extended specifications like OpenAPI
+The Unsafe type is often used to create schematics for extended specifications like OpenAPI.
 ```typescript
 
 const Nullable = <T extends TSchema>(schema: T) => Type.Unsafe<Static<T> | null>({ 
@@ -1042,18 +1117,18 @@ type S = Static<typeof T>                            // type S = 'A' | 'B' | 'C'
 ```
 <a name='types-guard'></a>
 
-### Type Guard
+### TypeGuard
 
-TypeBox can type check its own types with the TypeGuard module. This module is written for reflection and provides structural tests for every TypeBox type. Functions of this module return `is` guards which can be used with TypeScript control flow assertions to obtain schema inference. The following guards that the value A is TString.
+TypeBox can check its own types with the TypeGuard module. This module is written for type introspection and provides structural tests for every built-in TypeBox type. Functions of this module return `is` guards which can be used with control flow assertions to obtain schema inference for unknown values. The following guards that the value `T` is TString.
 
 ```typescript
-import { Type, Kind, TypeGuard } from '@sinclair/typebox'
+import { TypeGuard, Kind } from '@sinclair/typebox'
 
-const A: unknown = { ... }
+const T = { [Kind]: 'String', type: 'string' }
 
-if(TypeGuard.TString(A)) {
+if(TypeGuard.IsString(T)) {
 
-  A.type                                             // A.type = 'string'
+  // T is TString
 }
 ```
 
@@ -1065,13 +1140,13 @@ TypeBox types contain various symbol properties that are used for reflection, co
 
 ```typescript
 const T = Type.Object({                              // const T = {
-  name: Type.Optional(Type.String())                 //   [Kind]: 'Object',
+  name: Type.Optional(Type.String())                 //   [Symbol(TypeBox.Kind)]: 'Object',
 })                                                   //   type: 'object',
                                                      //   properties: {
                                                      //     name: {
                                                      //       type: 'string',
-                                                     //       [Kind]: 'String',
-                                                     //       [Optional]: 'Optional'
+                                                     //       [Symbol(TypeBox.Kind)]: 'String',
+                                                     //       [Symbol(TypeBox.Optional)]: 'Optional'
                                                      //     }
                                                      //   }
                                                      // }
@@ -1090,7 +1165,7 @@ const U = Type.Strict(T)                             // const U = {
 
 ## Values
 
-TypeBox provides an optional utility module that can be used to perform structural operations on JavaScript values. This module includes functionality to create, check and cast values from types as well as check equality, clone, diff and patch JavaScript values. This module is provided via optional import.
+TypeBox provides an optional Value submodule that can be used to perform structural operations on JavaScript values. This submodule includes functionality to create, check and cast values from types as well as check equality, clone, diff and patch JavaScript values. This submodule is provided via optional import.
 
 ```typescript
 import { Value } from '@sinclair/typebox/value'
@@ -1144,11 +1219,49 @@ const R1 = Value.Convert(T, { x: '3.14' })           // const R1 = { x: 3.14 }
 const R2 = Value.Convert(T, { x: 'not a number' })   // const R2 = { x: 'not a number' }
 ```
 
+<a name='values-clean'></a>
+
+### Clean
+
+Use Clean to remove excess properties from a value. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first.
+
+```typescript
+const T = Type.Object({ 
+  x: Type.Number(), 
+  y: Type.Number() 
+})
+
+const X = Value.Clean(T, null)                        // const 'X = null
+
+const Y = Value.Clean(T, { x: 1 })                    // const 'Y = { x: 1 }
+
+const Z = Value.Clean(T, { x: 1, y: 2, z: 3 })        // const 'Z = { x: 1, y: 2 }
+```
+
+<a name='values-default'></a>
+
+### Default
+
+Use Default to generate missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first.
+
+```typescript
+const T = Type.Object({ 
+  x: Type.Number({ default: 0 }), 
+  y: Type.Number({ default: 0 })
+})
+
+const X = Value.Default(T, null)                        // const 'X = null - non-enumerable
+
+const Y = Value.Default(T, { })                         // const 'Y = { x: 0, y: 0 }
+
+const Z = Value.Default(T, { x: 1 })                    // const 'Z = { x: 1, y: 0 }
+```
+
 <a name='values-cast'></a>
 
 ### Cast
 
-Use the Cast function to cast a value with a type. The cast function will retain as much information as possible from the original value.
+Use the Cast function to upcast a value into a target type. This function will retain as much infomation as possible from the original value. The Cast function is intended to be used in data migration scenarios where existing values need to be upgraded to match a modified type.
 
 ```typescript
 const T = Type.Object({ x: Type.Number(), y: Type.Number() }, { additionalProperties: false })
@@ -1164,7 +1277,7 @@ const Z = Value.Cast(T, { x: 1, y: 2, z: 3 })        // const Z = { x: 1, y: 2 }
 
 ### Decode
 
-Use the Decode function to decode a value from a type, or throw if the value is invalid. The return value will infer as the decoded type. This function will run Transform codecs if available.
+Use the Decode function to decode a value from a type or throw if the value is invalid. The return value will infer as the decoded type. This function will run Transform codecs if available.
 
 ```typescript
 const A = Value.Decode(Type.String(), 'hello')        // const A = 'hello'
@@ -1175,7 +1288,7 @@ const B = Value.Decode(Type.String(), 42)             // throw
 
 ### Encode
 
-Use the Encode function to encode a value to a type, or throw if the value is invalid. The return value will infer as the encoded type. This function will run Transform codecs if available.
+Use the Encode function to encode a value to a type or throw if the value is invalid. The return value will infer as the encoded type. This function will run Transform codecs if available.
 
 ```typescript
 const A = Value.Encode(Type.String(), 'hello')        // const A = 'hello'
@@ -1275,7 +1388,7 @@ const Y = { z: 1 }                                   // const Y = { z: 1 }
 const X = { y: Y }                                   // const X = { y: { z: 1 } }
 const A = { x: X }                                   // const A = { x: { y: { z: 1 } } }
 
-Value.Mutate(A, { x: { y: { z: 2 } } })              // const A' = { x: { y: { z: 2 } } }
+Value.Mutate(A, { x: { y: { z: 2 } } })              // A' = { x: { y: { z: 2 } } }
 
 const R0 = A.x.y.z === 2                             // const R0 = true
 const R1 = A.x.y === Y                               // const R1 = true
@@ -1293,9 +1406,9 @@ import { ValuePointer } from '@sinclair/typebox/value'
 
 const A = { x: 0, y: 0, z: 0 }
 
-ValuePointer.Set(A, '/x', 1)                         // const A' = { x: 1, y: 0, z: 0 }
-ValuePointer.Set(A, '/y', 1)                         // const A' = { x: 1, y: 1, z: 0 }
-ValuePointer.Set(A, '/z', 1)                         // const A' = { x: 1, y: 1, z: 1 }
+ValuePointer.Set(A, '/x', 1)                         // A' = { x: 1, y: 0, z: 0 }
+ValuePointer.Set(A, '/y', 1)                         // A' = { x: 1, y: 1, z: 0 }
+ValuePointer.Set(A, '/z', 1)                         // A' = { x: 1, y: 1, z: 1 }
 ```
 
 <a name='typeregistry'></a>
@@ -1308,15 +1421,18 @@ The TypeBox type system can be extended with additional types and formats using
 
 ### TypeRegistry
 
-Use the TypeRegistry to register a new type. The Kind must match the registered type name.
+Use the TypeRegistry to register a type. The Kind must match the registered type name.
 
 ```typescript
-import { TypeRegistry, Kind } from '@sinclair/typebox'
+import { TSchema, Kind, TypeRegistry } from '@sinclair/typebox'
 
 TypeRegistry.Set('Foo', (schema, value) => value === 'foo')
 
-const A = Value.Check({ [Kind]: 'Foo' }, 'foo')      // const A = true
-const B = Value.Check({ [Kind]: 'Foo' }, 'bar')      // const B = false
+const Foo = { [Kind]: 'Foo' } as TSchema 
+
+const A = Value.Check(Foo, 'foo')                    // const A = true
+
+const B = Value.Check(Foo, 'bar')                    // const B = false
 ```
 
 <a name='typeregistry-format'></a>
@@ -1333,6 +1449,7 @@ FormatRegistry.Set('foo', (value) => value === 'foo')
 const T = Type.String({ format: 'foo' })
 
 const A = Value.Check(T, 'foo')                      // const A = true
+
 const B = Value.Check(T, 'bar')                      // const B = false
 ```
 
@@ -1445,7 +1562,7 @@ const all = [...C.Errors(value)]                     // const all = [{
                                                      // }]
 ```
 
-Use the Code function to generate assertion functions as strings. This function can be used to create high performance assertions that can be written to disk as importable modules. The following generates code to check a string.
+Use the Code function to generate assertion functions as strings. This function can be used to generate code that can be written to disk as importable modules. This technique is sometimes referred to as Ahead of Time (AOT) compilation. The following generates code to check a string.
 
 ```typescript
 const C = TypeCompiler.Code(Type.String())           // const C = `return function check(value) {
@@ -1459,68 +1576,70 @@ const C = TypeCompiler.Code(Type.String())           // const C = `return functi
 
 ## TypeSystem
 
-The TypeBox TypeSystem module provides functionality to define types above and beyond the built-in Json and JavaScript type sets. They also manage TypeBox's localization options (i18n) for error message generation and can control various assertion policies used when type checking. Configurations made to the TypeSystem module are observed by the TypeCompiler, Value and Error modules.
+The TypeBox TypeSystem module provides configurations to use either Json Schema or TypeScript type checking semantics. Configurations made to the TypeSystem module are observed by the TypeCompiler, Value and Error modules.
 
-<a name='typesystem-types'></a>
+<a name='typesystem-policies'></a>
 
-### Types
+### Policies
 
-Use the TypeSystem Type function to register a user defined type.
+TypeBox validates using standard Json Schema assertion policies by default. The TypeSystemPolicy module can override some of these to have TypeBox assert values inline with TypeScript static checks. It also provides overrides for certain checking rules related to non-serializable values (such as void) which can be helpful in Json based protocols such as Json Rpc 2.0. 
 
-```typescript
-import { TypeSystem } from '@sinclair/typebox/system'
+The following overrides are available.
 
-const StringSet = TypeSystem.Type<Set<string>>('StringSet', (options, value) => {
-  return value instanceof Set && [...value].every(value => typeof value === 'string')
-})
+```typescript
+import { TypeSystemPolicy } from '@sinclair/typebox/system'
 
-const T = StringSet({})                              // Pass options if any
+// Disallow undefined values for optional properties (default is false)
+//
+// const A: { x?: number } = { x: undefined } - disallowed when enabled
 
-const A = Value.Check(T, new Set())                  // const A = true
-const B = Value.Check(T, new Set(['hello']))         // const B = true
-const C = Value.Check(T, new Set([1]))               // const C = false
+TypeSystemPolicy.ExactOptionalPropertyTypes = true
 
-```
+// Allow arrays to validate as object types (default is false)
+//
+// const A: {} = [] - allowed in TS
 
-<a name='typesystem-formats'></a>
+TypeSystemPolicy.AllowArrayObject = true
 
-### Formats
+// Allow numeric values to be NaN or + or - Infinity (default is false)
+//
+// const A: number = NaN - allowed in TS
 
-Use the TypeSystem Format function to register a string format.
+TypeSystemPolicy.AllowNaN = true
 
-```typescript
-import { TypeSystem } from '@sinclair/typebox/system'
+// Allow void types to check with undefined and null (default is false)
+//
+// Used to signal void return on Json-Rpc 2.0 protocol
 
-const F = TypeSystem.Format('foo', value => value === 'Foo')   
+TypeSystemPolicy.AllowNullVoid = true
+```
 
-const T = Type.String({ format: F })
+<a name='error-function'></a>
 
-const A = Value.Check(T, 'foo')                      // const A = true
-const B = Value.Check(T, 'bar')                      // const B = false
-```
+## Error Function
 
-<a name='typesystem-errors'></a>
+Error messages in TypeBox can be customized by defining an ErrorFunction. This function allows for the localization of error messages as well as enabling custom error messages for custom types. By default, TypeBox will generate messages using the `en-US` locale. To support additional locales, you can replicate the function found in `src/errors/function.ts` and create a locale specific translation. The function can then be set via SetErrorFunction.
 
-### Errors
+The following example shows an inline error function that intercepts errors for String, Number and Boolean only. The DefaultErrorFunction is used to return a default error message.
 
-Use the TypeSystemErrorFunction to override validation error messages. This can be used to localize errors or create error messages for user defined types.
 
 ```typescript
-import { TypeSystemErrorFunction, ValueErrorType, DefaultErrorFunction } from '@sinclair/typebox/system'
+import { SetErrorFunction, DefaultErrorFunction, ValueErrorType } from '@sinclair/typebox/errors'
 
-TypeSystemErrorFunction.Set((schema, errorType) => { // i18n override
-  switch(errorType) {
+SetErrorFunction((error) => { // i18n override
+  switch(error.errorType) {
     /* en-US */ case ValueErrorType.String: return 'Expected string'
     /* fr-FR */ case ValueErrorType.Number: return 'Nombre attendu'  
     /* ko-KR */ case ValueErrorType.Boolean: return '예상 부울'      
-    /* en-US */ default: return DefaultErrorFunction(schema, errorType)          
+    /* en-US */ default: return DefaultErrorFunction(error)          
   }
 })
-const T = Type.Object({                              // const T = { ... }
-  x: Type.String(),
-  y: Type.Number(),
-  z: Type.Boolean()
-})
+const T = Type.Object({                              // const T: TObject<{
+  x: Type.String(),                                  //  TString,
+  y: Type.Number(),                                  //  TNumber,
+  z: Type.Boolean()                                  //  TBoolean
+})                                                   // }>
+
 const E = [...Value.Errors(T, {                      // const E = [{
   x: null,                                           //   type: 48,
   y: null,                                           //   schema: { ... },
@@ -1542,42 +1661,6 @@ const E = [...Value.Errors(T, {                      // const E = [{
                                                      // }]
 ```
 
-<a name='typesystem-policies'></a>
-
-### Policies
-
-TypeBox validates using standard Json Schema assertion policies by default. The TypeSystemPolicy module can override some of these to have TypeBox check values inline with TypeScript static assertions. It also provides overrides for certain checking rules related to non-serializable values (such as void) which can be useful in Json based protocols such as JsonRpc-2. 
-
-The following overrides are available.
-
-```typescript
-import { TypeSystemPolicy } from '@sinclair/typebox/system'
-
-// Disallow undefined values for optional properties (default is false)
-//
-// const A: { x?: number } = { x: undefined } - disallowed when enabled
-
-TypeSystemPolicy.ExactOptionalPropertyTypes = true
-
-// Allow arrays to validate as object types (default is false)
-//
-// const A: {} = [] - allowed in TS
-
-TypeSystemPolicy.AllowArrayObject = true
-
-// Allow numeric values to be NaN or + or - Infinity (default is false)
-//
-// const A: number = NaN - allowed in TS
-
-TypeSystemPolicy.AllowNaN = true
-
-// Allow void types to check with undefined and null (default is false)
-//
-// Used to signal void return on Json-RPC 2.0 protocol
-
-TypeSystemPolicy.AllowNullVoid = true
-```
-
 <a name='workbench'></a>
 
 ## TypeBox Workbench
@@ -1590,7 +1673,7 @@ TypeBox offers a web based code generation tool that can convert TypeScript type
 
 ## TypeBox Codegen
 
-TypeBox provides a code generation library that can be used to automate type translation between TypeScript and TypeBox. This library also includes functionality to transform TypeScript types to other ecosystem libraries.
+TypeBox provides a code generation library that can be integrated into toolchains to automate type translation between TypeScript and TypeBox. This library also includes functionality to transform TypeScript types to other ecosystem libraries.
 
 [TypeBox Codegen Link Here](https://github.com/sinclairzx81/typebox-codegen)
 
@@ -1619,7 +1702,7 @@ The following is a list of community packages that offer general tooling, extend
 
 ## Benchmark
 
-This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.12.0 running on Node 20.0.0.
+This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.12.0 running on Node 20.10.0.
 
 For additional comparative benchmarks, please refer to [typescript-runtime-type-benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/).
 
@@ -1627,41 +1710,41 @@ For additional comparative benchmarks, please refer to [typescript-runtime-type-
 
 ### Compile
 
-This benchmark measures compilation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/measurement/module/compile.ts).
+This benchmark measures compilation performance for varying types.
 
 ```typescript
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │    1000    │ '    216 ms' │ '      9 ms' │ '   24.00 x' │
-│ Literal_Number             │    1000    │ '    169 ms' │ '      7 ms' │ '   24.14 x' │
-│ Literal_Boolean            │    1000    │ '    150 ms' │ '      5 ms' │ '   30.00 x' │
-│ Primitive_Number           │    1000    │ '    161 ms' │ '      7 ms' │ '   23.00 x' │
-│ Primitive_String           │    1000    │ '    148 ms' │ '      6 ms' │ '   24.67 x' │
-│ Primitive_String_Pattern   │    1000    │ '    185 ms' │ '      9 ms' │ '   20.56 x' │
-│ Primitive_Boolean          │    1000    │ '    132 ms' │ '      4 ms' │ '   33.00 x' │
-│ Primitive_Null             │    1000    │ '    141 ms' │ '      3 ms' │ '   47.00 x' │
-│ Object_Unconstrained       │    1000    │ '   1109 ms' │ '     30 ms' │ '   36.97 x' │
-│ Object_Constrained         │    1000    │ '   1200 ms' │ '     24 ms' │ '   50.00 x' │
-│ Object_Vector3             │    1000    │ '    379 ms' │ '      9 ms' │ '   42.11 x' │
-│ Object_Box3D               │    1000    │ '   1709 ms' │ '     30 ms' │ '   56.97 x' │
-│ Tuple_Primitive            │    1000    │ '    456 ms' │ '     14 ms' │ '   32.57 x' │
-│ Tuple_Object               │    1000    │ '   1229 ms' │ '     17 ms' │ '   72.29 x' │
-│ Composite_Intersect        │    1000    │ '    570 ms' │ '     17 ms' │ '   33.53 x' │
-│ Composite_Union            │    1000    │ '    513 ms' │ '     19 ms' │ '   27.00 x' │
-│ Math_Vector4               │    1000    │ '    782 ms' │ '     13 ms' │ '   60.15 x' │
-│ Math_Matrix4               │    1000    │ '    393 ms' │ '     12 ms' │ '   32.75 x' │
-│ Array_Primitive_Number     │    1000    │ '    361 ms' │ '     12 ms' │ '   30.08 x' │
-│ Array_Primitive_String     │    1000    │ '    296 ms' │ '      5 ms' │ '   59.20 x' │
-│ Array_Primitive_Boolean    │    1000    │ '    315 ms' │ '      4 ms' │ '   78.75 x' │
-│ Array_Object_Unconstrained │    1000    │ '   1721 ms' │ '     22 ms' │ '   78.23 x' │
-│ Array_Object_Constrained   │    1000    │ '   1450 ms' │ '     21 ms' │ '   69.05 x' │
-│ Array_Tuple_Primitive      │    1000    │ '    813 ms' │ '     13 ms' │ '   62.54 x' │
-│ Array_Tuple_Object         │    1000    │ '   1537 ms' │ '     17 ms' │ '   90.41 x' │
-│ Array_Composite_Intersect  │    1000    │ '    753 ms' │ '     17 ms' │ '   44.29 x' │
-│ Array_Composite_Union      │    1000    │ '    808 ms' │ '     16 ms' │ '   50.50 x' │
-│ Array_Math_Vector4         │    1000    │ '   1118 ms' │ '     16 ms' │ '   69.88 x' │
-│ Array_Math_Matrix4         │    1000    │ '    690 ms' │ '      9 ms' │ '   76.67 x' │
+│ Literal_String             │    1000    │ '    242 ms' │ '     10 ms' │ '   24.20 x' │
+│ Literal_Number             │    1000    │ '    200 ms' │ '      8 ms' │ '   25.00 x' │
+│ Literal_Boolean            │    1000    │ '    168 ms' │ '      6 ms' │ '   28.00 x' │
+│ Primitive_Number           │    1000    │ '    165 ms' │ '      8 ms' │ '   20.63 x' │
+│ Primitive_String           │    1000    │ '    154 ms' │ '      6 ms' │ '   25.67 x' │
+│ Primitive_String_Pattern   │    1000    │ '    208 ms' │ '     14 ms' │ '   14.86 x' │
+│ Primitive_Boolean          │    1000    │ '    142 ms' │ '      6 ms' │ '   23.67 x' │
+│ Primitive_Null             │    1000    │ '    143 ms' │ '      6 ms' │ '   23.83 x' │
+│ Object_Unconstrained       │    1000    │ '   1217 ms' │ '     31 ms' │ '   39.26 x' │
+│ Object_Constrained         │    1000    │ '   1275 ms' │ '     26 ms' │ '   49.04 x' │
+│ Object_Vector3             │    1000    │ '    405 ms' │ '     12 ms' │ '   33.75 x' │
+│ Object_Box3D               │    1000    │ '   1833 ms' │ '     27 ms' │ '   67.89 x' │
+│ Tuple_Primitive            │    1000    │ '    475 ms' │ '     13 ms' │ '   36.54 x' │
+│ Tuple_Object               │    1000    │ '   1267 ms' │ '     30 ms' │ '   42.23 x' │
+│ Composite_Intersect        │    1000    │ '    604 ms' │ '     18 ms' │ '   33.56 x' │
+│ Composite_Union            │    1000    │ '    545 ms' │ '     20 ms' │ '   27.25 x' │
+│ Math_Vector4               │    1000    │ '    829 ms' │ '     12 ms' │ '   69.08 x' │
+│ Math_Matrix4               │    1000    │ '    405 ms' │ '     10 ms' │ '   40.50 x' │
+│ Array_Primitive_Number     │    1000    │ '    372 ms' │ '     12 ms' │ '   31.00 x' │
+│ Array_Primitive_String     │    1000    │ '    327 ms' │ '      5 ms' │ '   65.40 x' │
+│ Array_Primitive_Boolean    │    1000    │ '    300 ms' │ '      4 ms' │ '   75.00 x' │
+│ Array_Object_Unconstrained │    1000    │ '   1755 ms' │ '     21 ms' │ '   83.57 x' │
+│ Array_Object_Constrained   │    1000    │ '   1516 ms' │ '     20 ms' │ '   75.80 x' │
+│ Array_Tuple_Primitive      │    1000    │ '    825 ms' │ '     14 ms' │ '   58.93 x' │
+│ Array_Tuple_Object         │    1000    │ '   1616 ms' │ '     16 ms' │ '  101.00 x' │
+│ Array_Composite_Intersect  │    1000    │ '    776 ms' │ '     16 ms' │ '   48.50 x' │
+│ Array_Composite_Union      │    1000    │ '    820 ms' │ '     14 ms' │ '   58.57 x' │
+│ Array_Math_Vector4         │    1000    │ '   1166 ms' │ '     15 ms' │ '   77.73 x' │
+│ Array_Math_Matrix4         │    1000    │ '    695 ms' │ '      8 ms' │ '   86.88 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1669,43 +1752,43 @@ This benchmark measures compilation performance for varying types. You can revie
 
 ### Validate
 
-This benchmark measures validation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/measurement/module/check.ts).
+This benchmark measures validation performance for varying types.
 
 ```typescript
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │  1000000   │ '     24 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
-│ Literal_Number             │  1000000   │ '     15 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
-│ Literal_Boolean            │  1000000   │ '     14 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
-│ Primitive_Number           │  1000000   │ '     25 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
-│ Primitive_String           │  1000000   │ '     21 ms' │ '     24 ms' │ '      9 ms' │ '    2.67 x' │
-│ Primitive_String_Pattern   │  1000000   │ '    156 ms' │ '     43 ms' │ '     38 ms' │ '    1.13 x' │
+│ Literal_String             │  1000000   │ '     18 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
+│ Literal_Number             │  1000000   │ '     16 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
+│ Literal_Boolean            │  1000000   │ '     15 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│ Primitive_Number           │  1000000   │ '     21 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│ Primitive_String           │  1000000   │ '     22 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
+│ Primitive_String_Pattern   │  1000000   │ '    155 ms' │ '     41 ms' │ '     34 ms' │ '    1.21 x' │
 │ Primitive_Boolean          │  1000000   │ '     18 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Primitive_Null             │  1000000   │ '     20 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Object_Unconstrained       │  1000000   │ '   1055 ms' │ '     32 ms' │ '     24 ms' │ '    1.33 x' │
-│ Object_Constrained         │  1000000   │ '   1232 ms' │ '     49 ms' │ '     43 ms' │ '    1.14 x' │
-│ Object_Vector3             │  1000000   │ '    432 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
-│ Object_Box3D               │  1000000   │ '   1993 ms' │ '     54 ms' │ '     46 ms' │ '    1.17 x' │
-│ Object_Recursive           │  1000000   │ '   5115 ms' │ '    342 ms' │ '    159 ms' │ '    2.15 x' │
-│ Tuple_Primitive            │  1000000   │ '    156 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
-│ Tuple_Object               │  1000000   │ '    740 ms' │ '     29 ms' │ '     18 ms' │ '    1.61 x' │
-│ Composite_Intersect        │  1000000   │ '    797 ms' │ '     26 ms' │ '     14 ms' │ '    1.86 x' │
-│ Composite_Union            │  1000000   │ '    530 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
-│ Math_Vector4               │  1000000   │ '    240 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
-│ Math_Matrix4               │  1000000   │ '   1036 ms' │ '     39 ms' │ '     27 ms' │ '    1.44 x' │
-│ Array_Primitive_Number     │  1000000   │ '    248 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
-│ Array_Primitive_String     │  1000000   │ '    227 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
-│ Array_Primitive_Boolean    │  1000000   │ '    138 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
-│ Array_Object_Unconstrained │  1000000   │ '   5540 ms' │ '     66 ms' │ '     59 ms' │ '    1.12 x' │
-│ Array_Object_Constrained   │  1000000   │ '   5750 ms' │ '    123 ms' │ '    108 ms' │ '    1.14 x' │
-│ Array_Object_Recursive     │  1000000   │ '  21842 ms' │ '   1771 ms' │ '    599 ms' │ '    2.96 x' │
-│ Array_Tuple_Primitive      │  1000000   │ '    715 ms' │ '     36 ms' │ '     29 ms' │ '    1.24 x' │
-│ Array_Tuple_Object         │  1000000   │ '   3131 ms' │ '     63 ms' │ '     50 ms' │ '    1.26 x' │
-│ Array_Composite_Intersect  │  1000000   │ '   3064 ms' │ '     44 ms' │ '     35 ms' │ '    1.26 x' │
-│ Array_Composite_Union      │  1000000   │ '   2172 ms' │ '     65 ms' │ '     31 ms' │ '    2.10 x' │
-│ Array_Math_Vector4         │  1000000   │ '   1032 ms' │ '     37 ms' │ '     24 ms' │ '    1.54 x' │
-│ Array_Math_Matrix4         │  1000000   │ '   4859 ms' │ '    114 ms' │ '     86 ms' │ '    1.33 x' │
+│ Primitive_Null             │  1000000   │ '     19 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Object_Unconstrained       │  1000000   │ '   1003 ms' │ '     32 ms' │ '     24 ms' │ '    1.33 x' │
+│ Object_Constrained         │  1000000   │ '   1265 ms' │ '     49 ms' │ '     38 ms' │ '    1.29 x' │
+│ Object_Vector3             │  1000000   │ '    418 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
+│ Object_Box3D               │  1000000   │ '   2035 ms' │ '     56 ms' │ '     49 ms' │ '    1.14 x' │
+│ Object_Recursive           │  1000000   │ '   5243 ms' │ '    326 ms' │ '    157 ms' │ '    2.08 x' │
+│ Tuple_Primitive            │  1000000   │ '    153 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
+│ Tuple_Object               │  1000000   │ '    781 ms' │ '     28 ms' │ '     18 ms' │ '    1.56 x' │
+│ Composite_Intersect        │  1000000   │ '    742 ms' │ '     25 ms' │ '     14 ms' │ '    1.79 x' │
+│ Composite_Union            │  1000000   │ '    558 ms' │ '     24 ms' │ '     13 ms' │ '    1.85 x' │
+│ Math_Vector4               │  1000000   │ '    246 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
+│ Math_Matrix4               │  1000000   │ '   1052 ms' │ '     43 ms' │ '     28 ms' │ '    1.54 x' │
+│ Array_Primitive_Number     │  1000000   │ '    272 ms' │ '     22 ms' │ '     12 ms' │ '    1.83 x' │
+│ Array_Primitive_String     │  1000000   │ '    235 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
+│ Array_Primitive_Boolean    │  1000000   │ '    134 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
+│ Array_Object_Unconstrained │  1000000   │ '   6280 ms' │ '     65 ms' │ '     59 ms' │ '    1.10 x' │
+│ Array_Object_Constrained   │  1000000   │ '   6076 ms' │ '    130 ms' │ '    119 ms' │ '    1.09 x' │
+│ Array_Object_Recursive     │  1000000   │ '  22738 ms' │ '   1730 ms' │ '    635 ms' │ '    2.72 x' │
+│ Array_Tuple_Primitive      │  1000000   │ '    689 ms' │ '     35 ms' │ '     30 ms' │ '    1.17 x' │
+│ Array_Tuple_Object         │  1000000   │ '   3266 ms' │ '     63 ms' │ '     52 ms' │ '    1.21 x' │
+│ Array_Composite_Intersect  │  1000000   │ '   3310 ms' │ '     44 ms' │ '     36 ms' │ '    1.22 x' │
+│ Array_Composite_Union      │  1000000   │ '   2432 ms' │ '     69 ms' │ '     33 ms' │ '    2.09 x' │
+│ Array_Math_Vector4         │  1000000   │ '   1158 ms' │ '     37 ms' │ '     24 ms' │ '    1.54 x' │
+│ Array_Math_Matrix4         │  1000000   │ '   5435 ms' │ '    132 ms' │ '     92 ms' │ '    1.43 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1719,11 +1802,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '163.6 kb' │ ' 71.6 kb' │  '2.28 x'   │
-│ typebox/errors       │ '113.3 kb' │ ' 50.1 kb' │  '2.26 x'   │
-│ typebox/system       │ ' 83.9 kb' │ ' 37.5 kb' │  '2.24 x'   │
-│ typebox/value        │ '191.1 kb' │ ' 82.3 kb' │  '2.32 x'   │
-│ typebox              │ ' 73.8 kb' │ ' 32.3 kb' │  '2.29 x'   │
+│ typebox/compiler     │ '120.6 kb' │ ' 52.9 kb' │  '2.28 x'   │
+│ typebox/errors       │ ' 55.7 kb' │ ' 25.5 kb' │  '2.19 x'   │
+│ typebox/system       │ '  4.7 kb' │ '  2.0 kb' │  '2.33 x'   │
+│ typebox/value        │ '146.2 kb' │ ' 62.0 kb' │  '2.36 x'   │
+│ typebox              │ ' 91.4 kb' │ ' 37.8 kb' │  '2.42 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index fe03f6d2e..7f7368c19 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -26,25 +26,70 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { EncodeTransform, DecodeTransform, HasTransform, TransformDecodeCheckError, TransformEncodeCheckError } from '../value/transform'
-import { IsArray, IsString, IsNumber, IsBigInt } from '../value/guard'
-import { Errors, ValueErrorIterator } from '../errors/errors'
+import { TransformEncode, TransformDecode, HasTransform, TransformDecodeCheckError, TransformEncodeCheckError } from '../value/transform/index'
+import { Errors, ValueErrorIterator } from '../errors/index'
 import { TypeSystemPolicy } from '../system/index'
-import { Deref } from '../value/deref'
-import { Hash } from '../value/hash'
-import * as Types from '../typebox'
+import { TypeBoxError } from '../type/error/index'
+import { Deref } from '../value/deref/index'
+import { Hash } from '../value/hash/index'
+import { Kind } from '../type/symbols/index'
 
-// -------------------------------------------------------------------
+import { TypeRegistry, FormatRegistry } from '../type/registry/index'
+import { KeyOfPattern } from '../type/keyof/index'
+import { ExtendsUndefinedCheck } from '../type/extends/extends-undefined'
+
+import type { TSchema } from '../type/schema/index'
+import type { TAsyncIterator } from '../type/async-iterator/index'
+import type { TAny } from '../type/any/index'
+import type { TArray } from '../type/array/index'
+import type { TBigInt } from '../type/bigint/index'
+import type { TBoolean } from '../type/boolean/index'
+import type { TDate } from '../type/date/index'
+import type { TConstructor } from '../type/constructor/index'
+import type { TFunction } from '../type/function/index'
+import type { TInteger } from '../type/integer/index'
+import type { TIntersect } from '../type/intersect/index'
+import type { TIterator } from '../type/iterator/index'
+import type { TLiteral } from '../type/literal/index'
+import { Never, type TNever } from '../type/never/index'
+import type { TNot } from '../type/not/index'
+import type { TNull } from '../type/null/index'
+import type { TNumber } from '../type/number/index'
+import type { TObject } from '../type/object/index'
+import type { TPromise } from '../type/promise/index'
+import type { TRecord } from '../type/record/index'
+import type { TRef } from '../type/ref/index'
+import type { TRegExp } from '../type/regexp/index'
+import type { TTemplateLiteral } from '../type/template-literal/index'
+import type { TThis } from '../type/recursive/index'
+import type { TTuple } from '../type/tuple/index'
+import type { TUnion } from '../type/union/index'
+import type { TUnknown } from '../type/unknown/index'
+import type { Static, StaticDecode, StaticEncode } from '../type/static/index'
+import type { TString } from '../type/string/index'
+import type { TSymbol } from '../type/symbol/index'
+import type { TUndefined } from '../type/undefined/index'
+import type { TUint8Array } from '../type/uint8array/index'
+import type { TVoid } from '../type/void/index'
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsArray, IsString, IsNumber, IsBigInt } from '../value/guard/index'
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsSchema } from '../type/guard/type'
+// ------------------------------------------------------------------
 // CheckFunction
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 export type CheckFunction = (value: unknown) => boolean
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 // TypeCheck
-// -------------------------------------------------------------------
-export class TypeCheck<T extends Types.TSchema> {
+// ------------------------------------------------------------------
+export class TypeCheck<T extends TSchema> {
   private readonly hasTransform: boolean
-  constructor(private readonly schema: T, private readonly references: Types.TSchema[], private readonly checkFunc: CheckFunction, private readonly code: string) {
-    this.hasTransform = HasTransform.Has(schema, references)
+  constructor(private readonly schema: T, private readonly references: TSchema[], private readonly checkFunc: CheckFunction, private readonly code: string) {
+    this.hasTransform = HasTransform(schema, references)
   }
   /** Returns the generated assertion code used to validate this type. */
   public Code(): string {
@@ -55,24 +100,24 @@ export class TypeCheck<T extends Types.TSchema> {
     return Errors(this.schema, this.references, value)
   }
   /** Returns true if the value matches the compiled type. */
-  public Check(value: unknown): value is Types.Static<T> {
+  public Check(value: unknown): value is Static<T> {
     return this.checkFunc(value)
   }
   /** Decodes a value or throws if error */
-  public Decode(value: unknown): Types.StaticDecode<T> {
+  public Decode(value: unknown): StaticDecode<T> {
     if (!this.checkFunc(value)) throw new TransformDecodeCheckError(this.schema, value, this.Errors(value).First()!)
-    return this.hasTransform ? DecodeTransform.Decode(this.schema, this.references, value) : value
+    return this.hasTransform ? TransformDecode(this.schema, this.references, value) : value
   }
   /** Encodes a value or throws if error */
-  public Encode(value: unknown): Types.StaticEncode<T> {
-    const encoded = this.hasTransform ? EncodeTransform.Encode(this.schema, this.references, value) : value
+  public Encode(value: unknown): StaticEncode<T> {
+    const encoded = this.hasTransform ? TransformEncode(this.schema, this.references, value) : value
     if (!this.checkFunc(encoded)) throw new TransformEncodeCheckError(this.schema, value, this.Errors(value).First()!)
     return encoded
   }
 }
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Character
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 namespace Character {
   export function DollarSign(code: number) {
     return code === 36
@@ -87,9 +132,9 @@ namespace Character {
     return code >= 48 && code <= 57
   }
 }
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 // MemberExpression
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 namespace MemberExpression {
   function IsFirstCharacterNumeric(value: string) {
     if (value.length === 0) return false
@@ -111,9 +156,9 @@ namespace MemberExpression {
     return IsAccessor(key) ? `${object}.${key}` : `${object}['${EscapeHyphen(key)}']`
   }
 }
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Identifier
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 namespace Identifier {
   export function Encode($id: string) {
     const buffer: string[] = []
@@ -128,30 +173,30 @@ namespace Identifier {
     return buffer.join('').replace(/__/g, '_')
   }
 }
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 // LiteralString
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 namespace LiteralString {
   export function Escape(content: string) {
     return content.replace(/'/g, "\\'")
   }
 }
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Errors
-// -------------------------------------------------------------------
-export class TypeCompilerUnknownTypeError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema) {
+// ------------------------------------------------------------------
+export class TypeCompilerUnknownTypeError extends TypeBoxError {
+  constructor(public readonly schema: TSchema) {
     super('Unknown type')
   }
 }
-export class TypeCompilerTypeGuardError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema) {
+export class TypeCompilerTypeGuardError extends TypeBoxError {
+  constructor(public readonly schema: TSchema) {
     super('Preflight validation check failed to guard for the given schema')
   }
 }
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Policy
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 export namespace Policy {
   export function IsExactOptionalProperty(value: string, key: string, expression: string) {
     return TypeSystemPolicy.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${MemberExpression.Encode(value, key)} !== undefined ? ${expression} : true)`
@@ -171,36 +216,36 @@ export namespace Policy {
     return TypeSystemPolicy.AllowNullVoid ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`
   }
 }
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 // TypeCompiler
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 export type TypeCompilerLanguageOption = 'typescript' | 'javascript'
 export interface TypeCompilerCodegenOptions {
   language?: TypeCompilerLanguageOption
 }
 /** Compiles Types for Runtime Type Checking */
 export namespace TypeCompiler {
-  // ----------------------------------------------------------------------
+  // ----------------------------------------------------------------
   // Guards
-  // ----------------------------------------------------------------------
-  function IsAnyOrUnknown(schema: Types.TSchema) {
-    return schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown'
+  // ----------------------------------------------------------------
+  function IsAnyOrUnknown(schema: TSchema) {
+    return schema[Kind] === 'Any' || schema[Kind] === 'Unknown'
   }
-  // -------------------------------------------------------------------
+  // ----------------------------------------------------------------
   // Types
-  // -------------------------------------------------------------------
-  function* TAny(schema: Types.TAny, references: Types.TSchema[], value: string): IterableIterator<string> {
+  // ----------------------------------------------------------------
+  function* FromAny(schema: TAny, references: TSchema[], value: string): IterableIterator<string> {
     yield 'true'
   }
-  function* TArray(schema: Types.TArray, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromArray(schema: TArray, references: TSchema[], value: string): IterableIterator<string> {
     yield `Array.isArray(${value})`
     const [parameter, accumulator] = [CreateParameter('value', 'any'), CreateParameter('acc', 'number')]
     if (IsNumber(schema.maxItems)) yield `${value}.length <= ${schema.maxItems}`
     if (IsNumber(schema.minItems)) yield `${value}.length >= ${schema.minItems}`
     const elementExpression = CreateExpression(schema.items, references, 'value')
     yield `${value}.every((${parameter}) => ${elementExpression})`
-    if (Types.TypeGuard.TSchema(schema.contains) || IsNumber(schema.minContains) || IsNumber(schema.maxContains)) {
-      const containsSchema = Types.TypeGuard.TSchema(schema.contains) ? schema.contains : Types.Type.Never()
+    if (IsSchema(schema.contains) || IsNumber(schema.minContains) || IsNumber(schema.maxContains)) {
+      const containsSchema = IsSchema(schema.contains) ? schema.contains : Never()
       const checkExpression = CreateExpression(containsSchema, references, 'value')
       const checkMinContains = IsNumber(schema.minContains) ? [`(count >= ${schema.minContains})`] : []
       const checkMaxContains = IsNumber(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : []
@@ -214,10 +259,10 @@ export namespace TypeCompiler {
       yield `((${parameter}) => { ${block} )(${value})`
     }
   }
-  function* TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromAsyncIterator(schema: TAsyncIterator, references: TSchema[], value: string): IterableIterator<string> {
     yield `(typeof value === 'object' && Symbol.asyncIterator in ${value})`
   }
-  function* TBigInt(schema: Types.TBigInt, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromBigInt(schema: TBigInt, references: TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'bigint')`
     if (IsBigInt(schema.exclusiveMaximum)) yield `${value} < BigInt(${schema.exclusiveMaximum})`
     if (IsBigInt(schema.exclusiveMinimum)) yield `${value} > BigInt(${schema.exclusiveMinimum})`
@@ -225,13 +270,13 @@ export namespace TypeCompiler {
     if (IsBigInt(schema.minimum)) yield `${value} >= BigInt(${schema.minimum})`
     if (IsBigInt(schema.multipleOf)) yield `(${value} % BigInt(${schema.multipleOf})) === 0`
   }
-  function* TBoolean(schema: Types.TBoolean, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromBoolean(schema: TBoolean, references: TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'boolean')`
   }
-  function* TConstructor(schema: Types.TConstructor, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromConstructor(schema: TConstructor, references: TSchema[], value: string): IterableIterator<string> {
     yield* Visit(schema.returns, references, `${value}.prototype`)
   }
-  function* TDate(schema: Types.TDate, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromDate(schema: TDate, references: TSchema[], value: string): IterableIterator<string> {
     yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`
     if (IsNumber(schema.exclusiveMaximumTimestamp)) yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`
     if (IsNumber(schema.exclusiveMinimumTimestamp)) yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`
@@ -239,10 +284,10 @@ export namespace TypeCompiler {
     if (IsNumber(schema.minimumTimestamp)) yield `${value}.getTime() >= ${schema.minimumTimestamp}`
     if (IsNumber(schema.multipleOfTimestamp)) yield `(${value}.getTime() % ${schema.multipleOfTimestamp}) === 0`
   }
-  function* TFunction(schema: Types.TFunction, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromFunction(schema: TFunction, references: TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'function')`
   }
-  function* TInteger(schema: Types.TInteger, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromInteger(schema: TInteger, references: TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`
     if (IsNumber(schema.exclusiveMaximum)) yield `${value} < ${schema.exclusiveMaximum}`
     if (IsNumber(schema.exclusiveMinimum)) yield `${value} > ${schema.exclusiveMinimum}`
@@ -250,41 +295,41 @@ export namespace TypeCompiler {
     if (IsNumber(schema.minimum)) yield `${value} >= ${schema.minimum}`
     if (IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf}) === 0`
   }
-  function* TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: string): IterableIterator<string> {
-    const check1 = schema.allOf.map((schema: Types.TSchema) => CreateExpression(schema, references, value)).join(' && ')
+  function* FromIntersect(schema: TIntersect, references: TSchema[], value: string): IterableIterator<string> {
+    const check1 = schema.allOf.map((schema: TSchema) => CreateExpression(schema, references, value)).join(' && ')
     if (schema.unevaluatedProperties === false) {
-      const keyCheck = CreateVariable(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`)
+      const keyCheck = CreateVariable(`${new RegExp(KeyOfPattern(schema))};`)
       const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key))`
       yield `(${check1} && ${check2})`
-    } else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
-      const keyCheck = CreateVariable(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`)
+    } else if (IsSchema(schema.unevaluatedProperties)) {
+      const keyCheck = CreateVariable(`${new RegExp(KeyOfPattern(schema))};`)
       const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key) || ${CreateExpression(schema.unevaluatedProperties, references, `${value}[key]`)})`
       yield `(${check1} && ${check2})`
     } else {
       yield `(${check1})`
     }
   }
-  function* TIterator(schema: Types.TIterator, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromIterator(schema: TIterator, references: TSchema[], value: string): IterableIterator<string> {
     yield `(typeof value === 'object' && Symbol.iterator in ${value})`
   }
-  function* TLiteral(schema: Types.TLiteral, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromLiteral(schema: TLiteral, references: TSchema[], value: string): IterableIterator<string> {
     if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
       yield `(${value} === ${schema.const})`
     } else {
       yield `(${value} === '${LiteralString.Escape(schema.const)}')`
     }
   }
-  function* TNever(schema: Types.TNever, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromNever(schema: TNever, references: TSchema[], value: string): IterableIterator<string> {
     yield `false`
   }
-  function* TNot(schema: Types.TNot, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromNot(schema: TNot, references: TSchema[], value: string): IterableIterator<string> {
     const expression = CreateExpression(schema.not, references, value)
     yield `(!${expression})`
   }
-  function* TNull(schema: Types.TNull, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromNull(schema: TNull, references: TSchema[], value: string): IterableIterator<string> {
     yield `(${value} === null)`
   }
-  function* TNumber(schema: Types.TNumber, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromNumber(schema: TNumber, references: TSchema[], value: string): IterableIterator<string> {
     yield Policy.IsNumberLike(value)
     if (IsNumber(schema.exclusiveMaximum)) yield `${value} < ${schema.exclusiveMaximum}`
     if (IsNumber(schema.exclusiveMinimum)) yield `${value} > ${schema.exclusiveMinimum}`
@@ -292,7 +337,7 @@ export namespace TypeCompiler {
     if (IsNumber(schema.minimum)) yield `${value} >= ${schema.minimum}`
     if (IsNumber(schema.multipleOf)) yield `(${value} % ${schema.multipleOf}) === 0`
   }
-  function* TObject(schema: Types.TObject, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromObject(schema: TObject, references: TSchema[], value: string): IterableIterator<string> {
     yield Policy.IsObjectLike(value)
     if (IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
     if (IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
@@ -302,7 +347,7 @@ export namespace TypeCompiler {
       const property = schema.properties[knownKey]
       if (schema.required && schema.required.includes(knownKey)) {
         yield* Visit(property, references, memberExpression)
-        if (Types.ExtendsUndefined.Check(property) || IsAnyOrUnknown(property)) yield `('${knownKey}' in ${value})`
+        if (ExtendsUndefinedCheck(property) || IsAnyOrUnknown(property)) yield `('${knownKey}' in ${value})`
       } else {
         const expression = CreateExpression(property, references, memberExpression)
         yield Policy.IsExactOptionalProperty(value, knownKey, expression)
@@ -322,28 +367,33 @@ export namespace TypeCompiler {
       yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`
     }
   }
-  function* TPromise(schema: Types.TPromise<any>, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromPromise(schema: TPromise, references: TSchema[], value: string): IterableIterator<string> {
     yield `(typeof value === 'object' && typeof ${value}.then === 'function')`
   }
-  function* TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromRecord(schema: TRecord, references: TSchema[], value: string): IterableIterator<string> {
     yield Policy.IsRecordLike(value)
     if (IsNumber(schema.minProperties)) yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`
     if (IsNumber(schema.maxProperties)) yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`
     const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0]
     const variable = CreateVariable(`${new RegExp(patternKey)}`)
     const check1 = CreateExpression(patternSchema, references, 'value')
-    const check2 = Types.TypeGuard.TSchema(schema.additionalProperties) ? CreateExpression(schema.additionalProperties, references, value) : schema.additionalProperties === false ? 'false' : 'true'
+    const check2 = IsSchema(schema.additionalProperties) ? CreateExpression(schema.additionalProperties, references, value) : schema.additionalProperties === false ? 'false' : 'true'
     const expression = `(${variable}.test(key) ? ${check1} : ${check2})`
     yield `(Object.entries(${value}).every(([key, value]) => ${expression}))`
   }
-  function* TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromRef(schema: TRef, references: TSchema[], value: string): IterableIterator<string> {
     const target = Deref(schema, references)
     // Reference: If we have seen this reference before we can just yield and return the function call.
     // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
     if (state.functions.has(schema.$ref)) return yield `${CreateFunctionName(schema.$ref)}(${value})`
     yield* Visit(target, references, value)
   }
-  function* TString(schema: Types.TString, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromRegExp(schema: TRegExp, references: TSchema[], value: string): IterableIterator<string> {
+    const variable = CreateVariable(`${new RegExp(schema.source, schema.flags)};`)
+    yield `(typeof ${value} === 'string')`
+    yield `${variable}.test(${value})`
+  }
+  function* FromString(schema: TString, references: TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'string')`
     if (IsNumber(schema.maxLength)) yield `${value}.length <= ${schema.maxLength}`
     if (IsNumber(schema.minLength)) yield `${value}.length >= ${schema.minLength}`
@@ -355,19 +405,19 @@ export namespace TypeCompiler {
       yield `format('${schema.format}', ${value})`
     }
   }
-  function* TSymbol(schema: Types.TSymbol, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromSymbol(schema: TSymbol, references: TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'symbol')`
   }
-  function* TTemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromTemplateLiteral(schema: TTemplateLiteral, references: TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'string')`
     const variable = CreateVariable(`${new RegExp(schema.pattern)};`)
     yield `${variable}.test(${value})`
   }
-  function* TThis(schema: Types.TThis, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromThis(schema: TThis, references: TSchema[], value: string): IterableIterator<string> {
     // Note: This types are assured to be hoisted prior to this call. Just yield the function.
     yield `${CreateFunctionName(schema.$ref)}(${value})`
   }
-  function* TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromTuple(schema: TTuple, references: TSchema[], value: string): IterableIterator<string> {
     yield `Array.isArray(${value})`
     if (schema.items === undefined) return yield `${value}.length === 0`
     yield `(${value}.length === ${schema.maxItems})`
@@ -376,35 +426,35 @@ export namespace TypeCompiler {
       yield `${expression}`
     }
   }
-  function* TUndefined(schema: Types.TUndefined, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromUndefined(schema: TUndefined, references: TSchema[], value: string): IterableIterator<string> {
     yield `${value} === undefined`
   }
-  function* TUnion(schema: Types.TUnion<any[]>, references: Types.TSchema[], value: string): IterableIterator<string> {
-    const expressions = schema.anyOf.map((schema: Types.TSchema) => CreateExpression(schema, references, value))
+  function* FromUnion(schema: TUnion, references: TSchema[], value: string): IterableIterator<string> {
+    const expressions = schema.anyOf.map((schema: TSchema) => CreateExpression(schema, references, value))
     yield `(${expressions.join(' || ')})`
   }
-  function* TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromUint8Array(schema: TUint8Array, references: TSchema[], value: string): IterableIterator<string> {
     yield `${value} instanceof Uint8Array`
     if (IsNumber(schema.maxByteLength)) yield `(${value}.length <= ${schema.maxByteLength})`
     if (IsNumber(schema.minByteLength)) yield `(${value}.length >= ${schema.minByteLength})`
   }
-  function* TUnknown(schema: Types.TUnknown, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromUnknown(schema: TUnknown, references: TSchema[], value: string): IterableIterator<string> {
     yield 'true'
   }
-  function* TVoid(schema: Types.TVoid, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromVoid(schema: TVoid, references: TSchema[], value: string): IterableIterator<string> {
     yield Policy.IsVoidLike(value)
   }
-  function* TKind(schema: Types.TSchema, references: Types.TSchema[], value: string): IterableIterator<string> {
+  function* FromKind(schema: TSchema, references: TSchema[], value: string): IterableIterator<string> {
     const instance = state.instances.size
     state.instances.set(instance, schema)
-    yield `kind('${schema[Types.Kind]}', ${instance}, ${value})`
+    yield `kind('${schema[Kind]}', ${instance}, ${value})`
   }
-  function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: string, useHoisting: boolean = true): IterableIterator<string> {
+  function* Visit(schema: TSchema, references: TSchema[], value: string, useHoisting: boolean = true): IterableIterator<string> {
     const references_ = IsString(schema.$id) ? [...references, schema] : references
     const schema_ = schema as any
-    // ----------------------------------------------------------------------------------
+    // --------------------------------------------------------------
     // Hoisting
-    // ----------------------------------------------------------------------------------
+    // --------------------------------------------------------------
     if (useHoisting && IsString(schema.$id)) {
       const functionName = CreateFunctionName(schema.$id)
       if (state.functions.has(functionName)) {
@@ -415,86 +465,88 @@ export namespace TypeCompiler {
         return yield `${functionName}(${value})`
       }
     }
-    switch (schema_[Types.Kind]) {
+    switch (schema_[Kind]) {
       case 'Any':
-        return yield* TAny(schema_, references_, value)
+        return yield* FromAny(schema_, references_, value)
       case 'Array':
-        return yield* TArray(schema_, references_, value)
+        return yield* FromArray(schema_, references_, value)
       case 'AsyncIterator':
-        return yield* TAsyncIterator(schema_, references_, value)
+        return yield* FromAsyncIterator(schema_, references_, value)
       case 'BigInt':
-        return yield* TBigInt(schema_, references_, value)
+        return yield* FromBigInt(schema_, references_, value)
       case 'Boolean':
-        return yield* TBoolean(schema_, references_, value)
+        return yield* FromBoolean(schema_, references_, value)
       case 'Constructor':
-        return yield* TConstructor(schema_, references_, value)
+        return yield* FromConstructor(schema_, references_, value)
       case 'Date':
-        return yield* TDate(schema_, references_, value)
+        return yield* FromDate(schema_, references_, value)
       case 'Function':
-        return yield* TFunction(schema_, references_, value)
+        return yield* FromFunction(schema_, references_, value)
       case 'Integer':
-        return yield* TInteger(schema_, references_, value)
+        return yield* FromInteger(schema_, references_, value)
       case 'Intersect':
-        return yield* TIntersect(schema_, references_, value)
+        return yield* FromIntersect(schema_, references_, value)
       case 'Iterator':
-        return yield* TIterator(schema_, references_, value)
+        return yield* FromIterator(schema_, references_, value)
       case 'Literal':
-        return yield* TLiteral(schema_, references_, value)
+        return yield* FromLiteral(schema_, references_, value)
       case 'Never':
-        return yield* TNever(schema_, references_, value)
+        return yield* FromNever(schema_, references_, value)
       case 'Not':
-        return yield* TNot(schema_, references_, value)
+        return yield* FromNot(schema_, references_, value)
       case 'Null':
-        return yield* TNull(schema_, references_, value)
+        return yield* FromNull(schema_, references_, value)
       case 'Number':
-        return yield* TNumber(schema_, references_, value)
+        return yield* FromNumber(schema_, references_, value)
       case 'Object':
-        return yield* TObject(schema_, references_, value)
+        return yield* FromObject(schema_, references_, value)
       case 'Promise':
-        return yield* TPromise(schema_, references_, value)
+        return yield* FromPromise(schema_, references_, value)
       case 'Record':
-        return yield* TRecord(schema_, references_, value)
+        return yield* FromRecord(schema_, references_, value)
       case 'Ref':
-        return yield* TRef(schema_, references_, value)
+        return yield* FromRef(schema_, references_, value)
+      case 'RegExp':
+        return yield* FromRegExp(schema_, references_, value)
       case 'String':
-        return yield* TString(schema_, references_, value)
+        return yield* FromString(schema_, references_, value)
       case 'Symbol':
-        return yield* TSymbol(schema_, references_, value)
+        return yield* FromSymbol(schema_, references_, value)
       case 'TemplateLiteral':
-        return yield* TTemplateLiteral(schema_, references_, value)
+        return yield* FromTemplateLiteral(schema_, references_, value)
       case 'This':
-        return yield* TThis(schema_, references_, value)
+        return yield* FromThis(schema_, references_, value)
       case 'Tuple':
-        return yield* TTuple(schema_, references_, value)
+        return yield* FromTuple(schema_, references_, value)
       case 'Undefined':
-        return yield* TUndefined(schema_, references_, value)
+        return yield* FromUndefined(schema_, references_, value)
       case 'Union':
-        return yield* TUnion(schema_, references_, value)
+        return yield* FromUnion(schema_, references_, value)
       case 'Uint8Array':
-        return yield* TUint8Array(schema_, references_, value)
+        return yield* FromUint8Array(schema_, references_, value)
       case 'Unknown':
-        return yield* TUnknown(schema_, references_, value)
+        return yield* FromUnknown(schema_, references_, value)
       case 'Void':
-        return yield* TVoid(schema_, references_, value)
+        return yield* FromVoid(schema_, references_, value)
       default:
-        if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new TypeCompilerUnknownTypeError(schema)
-        return yield* TKind(schema_, references_, value)
+        if (!TypeRegistry.Has(schema_[Kind])) throw new TypeCompilerUnknownTypeError(schema)
+        return yield* FromKind(schema_, references_, value)
     }
   }
-  // -------------------------------------------------------------------
+  // ----------------------------------------------------------------
   // Compiler State
-  // -------------------------------------------------------------------
+  // ----------------------------------------------------------------
   // prettier-ignore
   const state = {
-    language: 'javascript',                       // target language
-    functions: new Map<string, string>(),         // local functions
-    variables: new Map<string, string>(),         // local variables
-    instances: new Map<number, Types.TKind>()     // exterior kind instances
+    language: 'javascript',                   // target language
+    functions: new Map<string, string>(),     // local functions
+    variables: new Map<string, string>(),     // local variables
+    instances: new Map<number, TSchema>()     // exterior kind instances
   }
-  // -------------------------------------------------------------------
+  // ----------------------------------------------------------------
   // Compiler Factory
-  // -------------------------------------------------------------------
-  function CreateExpression(schema: Types.TSchema, references: Types.TSchema[], value: string, useHoisting: boolean = true): string {
+  // ----------------------------------------------------------------
+  function CreateExpression(schema: TSchema, references: TSchema[], value: string, useHoisting: boolean = true): string {
     return `(${[...Visit(schema, references, value, useHoisting)].join(' && ')})`
   }
   function CreateFunctionName($id: string) {
@@ -505,7 +557,7 @@ export namespace TypeCompiler {
     state.variables.set(variableName, `const ${variableName} = ${expression}`)
     return variableName
   }
-  function CreateFunction(name: string, schema: Types.TSchema, references: Types.TSchema[], value: string, useHoisting: boolean = true): string {
+  function CreateFunction(name: string, schema: TSchema, references: TSchema[], value: string, useHoisting: boolean = true): string {
     const [newline, pad] = ['\n', (length: number) => ''.padStart(length, ' ')]
     const parameter = CreateParameter('value', 'any')
     const returns = CreateReturns('boolean')
@@ -519,10 +571,10 @@ export namespace TypeCompiler {
   function CreateReturns(type: string) {
     return state.language === 'typescript' ? `: ${type}` : ''
   }
-  // -------------------------------------------------------------------
+  // ----------------------------------------------------------------
   // Compile
-  // -------------------------------------------------------------------
-  function Build<T extends Types.TSchema>(schema: T, references: Types.TSchema[], options: TypeCompilerCodegenOptions): string {
+  // ----------------------------------------------------------------
+  function Build<T extends TSchema>(schema: T, references: TSchema[], options: TypeCompilerCodegenOptions): string {
     const functionCode = CreateFunction('check', schema, references, 'value') // will populate functions and variables
     const parameter = CreateParameter('value', 'any')
     const returns = CreateReturns('boolean')
@@ -535,9 +587,9 @@ export namespace TypeCompiler {
     return [...variables, ...functions, checkFunction].join('\n')
   }
   /** Generates the code used to assert this type and returns it as a string */
-  export function Code<T extends Types.TSchema>(schema: T, references: Types.TSchema[], options?: TypeCompilerCodegenOptions): string
+  export function Code<T extends TSchema>(schema: T, references: TSchema[], options?: TypeCompilerCodegenOptions): string
   /** Generates the code used to assert this type and returns it as a string */
-  export function Code<T extends Types.TSchema>(schema: T, options?: TypeCompilerCodegenOptions): string
+  export function Code<T extends TSchema>(schema: T, options?: TypeCompilerCodegenOptions): string
   /** Generates the code used to assert this type and returns it as a string */
   export function Code(...args: any[]) {
     const defaults = { language: 'javascript' }
@@ -554,24 +606,24 @@ export namespace TypeCompiler {
     state.variables.clear()
     state.functions.clear()
     state.instances.clear()
-    if (!Types.TypeGuard.TSchema(schema)) throw new TypeCompilerTypeGuardError(schema)
-    for (const schema of references) if (!Types.TypeGuard.TSchema(schema)) throw new TypeCompilerTypeGuardError(schema)
+    if (!IsSchema(schema)) throw new TypeCompilerTypeGuardError(schema)
+    for (const schema of references) if (!IsSchema(schema)) throw new TypeCompilerTypeGuardError(schema)
     return Build(schema, references, options)
   }
   /** Compiles a TypeBox type for optimal runtime type checking. Types must be valid TypeBox types of TSchema */
-  export function Compile<T extends Types.TSchema>(schema: T, references: Types.TSchema[] = []): TypeCheck<T> {
+  export function Compile<T extends TSchema>(schema: T, references: TSchema[] = []): TypeCheck<T> {
     const generatedCode = Code(schema, references, { language: 'javascript' })
     const compiledFunction = globalThis.Function('kind', 'format', 'hash', generatedCode)
     const instances = new Map(state.instances)
     function typeRegistryFunction(kind: string, instance: number, value: unknown) {
-      if (!Types.TypeRegistry.Has(kind) || !instances.has(instance)) return false
-      const checkFunc = Types.TypeRegistry.Get(kind)!
+      if (!TypeRegistry.Has(kind) || !instances.has(instance)) return false
+      const checkFunc = TypeRegistry.Get(kind)!
       const schema = instances.get(instance)!
       return checkFunc(schema, value)
     }
     function formatRegistryFunction(format: string, value: string) {
-      if (!Types.FormatRegistry.Has(format)) return false
-      const checkFunc = Types.FormatRegistry.Get(format)!
+      if (!FormatRegistry.Has(format)) return false
+      const checkFunc = FormatRegistry.Get(format)!
       return checkFunc(value)
     }
     function hashFunction(value: unknown) {
diff --git a/src/compiler/index.ts b/src/compiler/index.ts
index cc91cb40b..48b4c10e8 100644
--- a/src/compiler/index.ts
+++ b/src/compiler/index.ts
@@ -27,4 +27,4 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index'
-export * from './compiler'
+export { TypeCompiler, TypeCheck, type TypeCompilerCodegenOptions, type TypeCompilerLanguageOption, TypeCompilerTypeGuardError, TypeCompilerUnknownTypeError } from './compiler'
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 9f09e1f55..c84ebab9e 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -26,15 +26,72 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsArray, IsUint8Array, IsDate, IsPromise, IsFunction, IsAsyncIterator, IsIterator, IsBoolean, IsNumber, IsBigInt, IsString, IsSymbol, IsInteger, IsNull, IsUndefined } from '../value/guard'
-import { TypeSystemPolicy, TypeSystemErrorFunction } from '../system/system'
-import { Deref } from '../value/deref'
-import { Hash } from '../value/hash'
-import * as Types from '../typebox'
+import { TypeSystemPolicy } from '../system/index'
+import { KeyOfPattern } from '../type/keyof/index'
+import { TypeRegistry, FormatRegistry } from '../type/registry/index'
+import { ExtendsUndefinedCheck } from '../type/extends/extends-undefined'
+import { GetErrorFunction } from './function'
+import { TypeBoxError } from '../type/error/index'
+import { Deref } from '../value/deref/index'
+import { Hash } from '../value/hash/index'
+import { Kind } from '../type/symbols/index'
 
-// --------------------------------------------------------------------------
+import type { TSchema } from '../type/schema/index'
+import type { TAsyncIterator } from '../type/async-iterator/index'
+import type { TAny } from '../type/any/index'
+import type { TArray } from '../type/array/index'
+import type { TBigInt } from '../type/bigint/index'
+import type { TBoolean } from '../type/boolean/index'
+import type { TDate } from '../type/date/index'
+import type { TConstructor } from '../type/constructor/index'
+import type { TFunction } from '../type/function/index'
+import type { TInteger } from '../type/integer/index'
+import type { TIntersect } from '../type/intersect/index'
+import type { TIterator } from '../type/iterator/index'
+import type { TLiteral } from '../type/literal/index'
+import { Never, type TNever } from '../type/never/index'
+import type { TNot } from '../type/not/index'
+import type { TNull } from '../type/null/index'
+import type { TNumber } from '../type/number/index'
+import type { TObject } from '../type/object/index'
+import type { TPromise } from '../type/promise/index'
+import type { TRecord } from '../type/record/index'
+import type { TRef } from '../type/ref/index'
+import type { TRegExp } from '../type/regexp/index'
+import type { TTemplateLiteral } from '../type/template-literal/index'
+import type { TThis } from '../type/recursive/index'
+import type { TTuple } from '../type/tuple/index'
+import type { TUnion } from '../type/union/index'
+import type { TUnknown } from '../type/unknown/index'
+import type { TString } from '../type/string/index'
+import type { TSymbol } from '../type/symbol/index'
+import type { TUndefined } from '../type/undefined/index'
+import type { TUint8Array } from '../type/uint8array/index'
+import type { TVoid } from '../type/void/index'
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+import { 
+  IsArray, 
+  IsUint8Array, 
+  IsDate, 
+  IsPromise, 
+  IsFunction, 
+  IsAsyncIterator, 
+  IsIterator, 
+  IsBoolean, 
+  IsNumber, 
+  IsBigInt, 
+  IsString, 
+  IsSymbol, 
+  IsInteger, 
+  IsNull, 
+  IsUndefined 
+} from '../value/guard/index'
+// ------------------------------------------------------------------
 // ValueErrorType
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 export enum ValueErrorType {
   ArrayContains,
   ArrayMaxContains,
@@ -84,6 +141,7 @@ export enum ValueErrorType {
   ObjectRequiredProperty,
   Object,
   Promise,
+  RegExp,
   StringFormatUnknown,
   StringFormat,
   StringMaxLength,
@@ -100,39 +158,39 @@ export enum ValueErrorType {
   Union,
   Void,
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // ValueError
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 export interface ValueError {
   type: ValueErrorType
-  schema: Types.TSchema
+  schema: TSchema
   path: string
   value: unknown
   message: string
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // ValueErrors
-// --------------------------------------------------------------------------
-export class ValueErrorsUnknownTypeError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema) {
+// ------------------------------------------------------------------
+export class ValueErrorsUnknownTypeError extends TypeBoxError {
+  constructor(public readonly schema: TSchema) {
     super('Unknown type')
   }
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // EscapeKey
-// --------------------------------------------------------------------------
-export function EscapeKey(key: string): string {
+// ------------------------------------------------------------------
+function EscapeKey(key: string): string {
   return key.replace(/~/g, '~0').replace(/\//g, '~1') // RFC6901 Path
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Guards
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function IsDefined<T>(value: unknown): value is T {
   return value !== undefined
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // ValueErrorIterator
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 export class ValueErrorIterator {
   constructor(private readonly iterator: IterableIterator<ValueError>) {}
   public [Symbol.iterator]() {
@@ -147,14 +205,14 @@ export class ValueErrorIterator {
 // --------------------------------------------------------------------------
 // Create
 // --------------------------------------------------------------------------
-function Create(type: ValueErrorType, schema: Types.TSchema, path: string, value: unknown): ValueError {
-  return { type, schema, path, value, message: TypeSystemErrorFunction.Get()(schema, type) }
+function Create(errorType: ValueErrorType, schema: TSchema, path: string, value: unknown): ValueError {
+  return { type: errorType, schema, path, value, message: GetErrorFunction()({ errorType, path, schema, value }) }
 }
 // --------------------------------------------------------------------------
 // Types
 // --------------------------------------------------------------------------
-function* TAny(schema: Types.TAny, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {}
-function* TArray(schema: Types.TArray, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromAny(schema: TAny, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {}
+function* FromArray(schema: TArray, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsArray(value)) {
     return yield Create(ValueErrorType.Array, schema, path, value)
   }
@@ -175,7 +233,7 @@ function* TArray(schema: Types.TArray, references: Types.TSchema[], path: string
   if (!(IsDefined(schema.contains) || IsDefined(schema.minContains) || IsDefined(schema.maxContains))) {
     return
   }
-  const containsSchema = IsDefined<Types.TSchema>(schema.contains) ? schema.contains : Types.Type.Never()
+  const containsSchema = IsDefined<TSchema>(schema.contains) ? schema.contains : Never()
   const containsCount = value.reduce((acc: number, value, index) => (Visit(containsSchema, references, `${path}${index}`, value).next().done === true ? acc + 1 : acc), 0)
   if (containsCount === 0) {
     yield Create(ValueErrorType.ArrayContains, schema, path, value)
@@ -187,10 +245,10 @@ function* TArray(schema: Types.TArray, references: Types.TSchema[], path: string
     yield Create(ValueErrorType.ArrayMaxContains, schema, path, value)
   }
 }
-function* TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromAsyncIterator(schema: TAsyncIterator, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsAsyncIterator(value)) yield Create(ValueErrorType.AsyncIterator, schema, path, value)
 }
-function* TBigInt(schema: Types.TBigInt, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromBigInt(schema: TBigInt, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsBigInt(value)) return yield Create(ValueErrorType.BigInt, schema, path, value)
   if (IsDefined<bigint>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
     yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path, value)
@@ -208,13 +266,13 @@ function* TBigInt(schema: Types.TBigInt, references: Types.TSchema[], path: stri
     yield Create(ValueErrorType.BigIntMultipleOf, schema, path, value)
   }
 }
-function* TBoolean(schema: Types.TBoolean, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromBoolean(schema: TBoolean, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsBoolean(value)) yield Create(ValueErrorType.Boolean, schema, path, value)
 }
-function* TConstructor(schema: Types.TConstructor, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromConstructor(schema: TConstructor, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   yield* Visit(schema.returns, references, path, value.prototype)
 }
-function* TDate(schema: Types.TDate, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromDate(schema: TDate, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsDate(value)) return yield Create(ValueErrorType.Date, schema, path, value)
   if (IsDefined<number>(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
     yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value)
@@ -232,10 +290,10 @@ function* TDate(schema: Types.TDate, references: Types.TSchema[], path: string,
     yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path, value)
   }
 }
-function* TFunction(schema: Types.TFunction, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromFunction(schema: TFunction, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsFunction(value)) yield Create(ValueErrorType.Function, schema, path, value)
 }
-function* TInteger(schema: Types.TInteger, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromInteger(schema: TInteger, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsInteger(value)) return yield Create(ValueErrorType.Integer, schema, path, value)
   if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
     yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path, value)
@@ -253,7 +311,7 @@ function* TInteger(schema: Types.TInteger, references: Types.TSchema[], path: st
     yield Create(ValueErrorType.IntegerMultipleOf, schema, path, value)
   }
 }
-function* TIntersect(schema: Types.TIntersect, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromIntersect(schema: TIntersect, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   for (const inner of schema.allOf) {
     const next = Visit(inner, references, path, value).next()
     if (!next.done) {
@@ -262,7 +320,7 @@ function* TIntersect(schema: Types.TIntersect, references: Types.TSchema[], path
     }
   }
   if (schema.unevaluatedProperties === false) {
-    const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema))
+    const keyCheck = new RegExp(KeyOfPattern(schema))
     for (const valueKey of Object.getOwnPropertyNames(value)) {
       if (!keyCheck.test(valueKey)) {
         yield Create(ValueErrorType.IntersectUnevaluatedProperties, schema, `${path}/${valueKey}`, value)
@@ -270,7 +328,7 @@ function* TIntersect(schema: Types.TIntersect, references: Types.TSchema[], path
     }
   }
   if (typeof schema.unevaluatedProperties === 'object') {
-    const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema))
+    const keyCheck = new RegExp(KeyOfPattern(schema))
     for (const valueKey of Object.getOwnPropertyNames(value)) {
       if (!keyCheck.test(valueKey)) {
         const next = Visit(schema.unevaluatedProperties, references, `${path}/${valueKey}`, value[valueKey]).next()
@@ -279,22 +337,22 @@ function* TIntersect(schema: Types.TIntersect, references: Types.TSchema[], path
     }
   }
 }
-function* TIterator(schema: Types.TIterator, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromIterator(schema: TIterator, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsIterator(value)) yield Create(ValueErrorType.Iterator, schema, path, value)
 }
-function* TLiteral(schema: Types.TLiteral, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromLiteral(schema: TLiteral, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!(value === schema.const)) yield Create(ValueErrorType.Literal, schema, path, value)
 }
-function* TNever(schema: Types.TNever, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromNever(schema: TNever, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   yield Create(ValueErrorType.Never, schema, path, value)
 }
-function* TNot(schema: Types.TNot, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromNot(schema: TNot, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (Visit(schema.not, references, path, value).next().done === true) yield Create(ValueErrorType.Not, schema, path, value)
 }
-function* TNull(schema: Types.TNull, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromNull(schema: TNull, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsNull(value)) yield Create(ValueErrorType.Null, schema, path, value)
 }
-function* TNumber(schema: Types.TNumber, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromNumber(schema: TNumber, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!TypeSystemPolicy.IsNumberLike(value)) return yield Create(ValueErrorType.Number, schema, path, value)
   if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
     yield Create(ValueErrorType.NumberExclusiveMaximum, schema, path, value)
@@ -312,7 +370,7 @@ function* TNumber(schema: Types.TNumber, references: Types.TSchema[], path: stri
     yield Create(ValueErrorType.NumberMultipleOf, schema, path, value)
   }
 }
-function* TObject(schema: Types.TObject, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromObject(schema: TObject, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!TypeSystemPolicy.IsObjectLike(value)) return yield Create(ValueErrorType.Object, schema, path, value)
   if (IsDefined<number>(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
     yield Create(ValueErrorType.ObjectMinProperties, schema, path, value)
@@ -337,14 +395,14 @@ function* TObject(schema: Types.TObject, references: Types.TSchema[], path: stri
   if (typeof schema.additionalProperties === 'object') {
     for (const valueKey of unknownKeys) {
       if (knownKeys.includes(valueKey)) continue
-      yield* Visit(schema.additionalProperties as Types.TSchema, references, `${path}/${EscapeKey(valueKey)}`, value[valueKey])
+      yield* Visit(schema.additionalProperties as TSchema, references, `${path}/${EscapeKey(valueKey)}`, value[valueKey])
     }
   }
   for (const knownKey of knownKeys) {
     const property = schema.properties[knownKey]
     if (schema.required && schema.required.includes(knownKey)) {
       yield* Visit(property, references, `${path}/${EscapeKey(knownKey)}`, value[knownKey])
-      if (Types.ExtendsUndefined.Check(schema) && !(knownKey in value)) {
+      if (ExtendsUndefinedCheck(schema) && !(knownKey in value)) {
         yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path}/${EscapeKey(knownKey)}`, undefined)
       }
     } else {
@@ -354,10 +412,10 @@ function* TObject(schema: Types.TObject, references: Types.TSchema[], path: stri
     }
   }
 }
-function* TPromise(schema: Types.TPromise, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromPromise(schema: TPromise, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsPromise(value)) yield Create(ValueErrorType.Promise, schema, path, value)
 }
-function* TRecord(schema: Types.TRecord, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromRecord(schema: TRecord, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!TypeSystemPolicy.IsRecordLike(value)) return yield Create(ValueErrorType.Object, schema, path, value)
   if (IsDefined<number>(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
     yield Create(ValueErrorType.ObjectMinProperties, schema, path, value)
@@ -372,7 +430,7 @@ function* TRecord(schema: Types.TRecord, references: Types.TSchema[], path: stri
   }
   if (typeof schema.additionalProperties === 'object') {
     for (const [propertyKey, propertyValue] of Object.entries(value)) {
-      if (!regex.test(propertyKey)) yield* Visit(schema.additionalProperties as Types.TSchema, references, `${path}/${EscapeKey(propertyKey)}`, propertyValue)
+      if (!regex.test(propertyKey)) yield* Visit(schema.additionalProperties as TSchema, references, `${path}/${EscapeKey(propertyKey)}`, propertyValue)
     }
   }
   if (schema.additionalProperties === false) {
@@ -382,10 +440,16 @@ function* TRecord(schema: Types.TRecord, references: Types.TSchema[], path: stri
     }
   }
 }
-function* TRef(schema: Types.TRef<any>, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromRef(schema: TRef, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   yield* Visit(Deref(schema, references), references, path, value)
 }
-function* TString(schema: Types.TString, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromRegExp(schema: TRegExp, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  const regex = new RegExp(schema.source, schema.flags)
+  if (!regex.test(value)) {
+    return yield Create(ValueErrorType.RegExp, schema, path, value)
+  }
+}
+function* FromString(schema: TString, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsString(value)) return yield Create(ValueErrorType.String, schema, path, value)
   if (IsDefined<number>(schema.minLength) && !(value.length >= schema.minLength)) {
     yield Create(ValueErrorType.StringMinLength, schema, path, value)
@@ -400,30 +464,30 @@ function* TString(schema: Types.TString, references: Types.TSchema[], path: stri
     }
   }
   if (IsString(schema.format)) {
-    if (!Types.FormatRegistry.Has(schema.format)) {
+    if (!FormatRegistry.Has(schema.format)) {
       yield Create(ValueErrorType.StringFormatUnknown, schema, path, value)
     } else {
-      const format = Types.FormatRegistry.Get(schema.format)!
+      const format = FormatRegistry.Get(schema.format)!
       if (!format(value)) {
         yield Create(ValueErrorType.StringFormat, schema, path, value)
       }
     }
   }
 }
-function* TSymbol(schema: Types.TSymbol, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromSymbol(schema: TSymbol, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsSymbol(value)) yield Create(ValueErrorType.Symbol, schema, path, value)
 }
-function* TTemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromTemplateLiteral(schema: TTemplateLiteral, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsString(value)) return yield Create(ValueErrorType.String, schema, path, value)
   const regex = new RegExp(schema.pattern)
   if (!regex.test(value)) {
     yield Create(ValueErrorType.StringPattern, schema, path, value)
   }
 }
-function* TThis(schema: Types.TThis, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromThis(schema: TThis, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   yield* Visit(Deref(schema, references), references, path, value)
 }
-function* TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromTuple(schema: TTuple<any[]>, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsArray(value)) return yield Create(ValueErrorType.Tuple, schema, path, value)
   if (schema.items === undefined && !(value.length === 0)) {
     return yield Create(ValueErrorType.TupleLength, schema, path, value)
@@ -438,10 +502,10 @@ function* TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], path:
     yield* Visit(schema.items[i], references, `${path}/${i}`, value[i])
   }
 }
-function* TUndefined(schema: Types.TUndefined, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromUndefined(schema: TUndefined, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsUndefined(value)) yield Create(ValueErrorType.Undefined, schema, path, value)
 }
-function* TUnion(schema: Types.TUnion, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromUnion(schema: TUnion, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   let count = 0
   for (const subschema of schema.anyOf) {
     const errors = [...Visit(subschema, references, path, value)]
@@ -452,7 +516,7 @@ function* TUnion(schema: Types.TUnion, references: Types.TSchema[], path: string
     yield Create(ValueErrorType.Union, schema, path, value)
   }
 }
-function* TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromUint8Array(schema: TUint8Array, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsUint8Array(value)) return yield Create(ValueErrorType.Uint8Array, schema, path, value)
   if (IsDefined<number>(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
     yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value)
@@ -461,87 +525,89 @@ function* TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], pa
     yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path, value)
   }
 }
-function* TUnknown(schema: Types.TUnknown, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {}
-function* TVoid(schema: Types.TVoid, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* FromUnknown(schema: TUnknown, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {}
+function* FromVoid(schema: TVoid, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!TypeSystemPolicy.IsVoidLike(value)) yield Create(ValueErrorType.Void, schema, path, value)
 }
-function* TKind(schema: Types.TSchema, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  const check = Types.TypeRegistry.Get(schema[Types.Kind])!
+function* FromKind(schema: TSchema, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  const check = TypeRegistry.Get(schema[Kind])!
   if (!check(schema, value)) yield Create(ValueErrorType.Kind, schema, path, value)
 }
-function* Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], path: string, value: any): IterableIterator<ValueError> {
+function* Visit<T extends TSchema>(schema: T, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   const references_ = IsDefined<string>(schema.$id) ? [...references, schema] : references
   const schema_ = schema as any
-  switch (schema_[Types.Kind]) {
+  switch (schema_[Kind]) {
     case 'Any':
-      return yield* TAny(schema_, references_, path, value)
+      return yield* FromAny(schema_, references_, path, value)
     case 'Array':
-      return yield* TArray(schema_, references_, path, value)
+      return yield* FromArray(schema_, references_, path, value)
     case 'AsyncIterator':
-      return yield* TAsyncIterator(schema_, references_, path, value)
+      return yield* FromAsyncIterator(schema_, references_, path, value)
     case 'BigInt':
-      return yield* TBigInt(schema_, references_, path, value)
+      return yield* FromBigInt(schema_, references_, path, value)
     case 'Boolean':
-      return yield* TBoolean(schema_, references_, path, value)
+      return yield* FromBoolean(schema_, references_, path, value)
     case 'Constructor':
-      return yield* TConstructor(schema_, references_, path, value)
+      return yield* FromConstructor(schema_, references_, path, value)
     case 'Date':
-      return yield* TDate(schema_, references_, path, value)
+      return yield* FromDate(schema_, references_, path, value)
     case 'Function':
-      return yield* TFunction(schema_, references_, path, value)
+      return yield* FromFunction(schema_, references_, path, value)
     case 'Integer':
-      return yield* TInteger(schema_, references_, path, value)
+      return yield* FromInteger(schema_, references_, path, value)
     case 'Intersect':
-      return yield* TIntersect(schema_, references_, path, value)
+      return yield* FromIntersect(schema_, references_, path, value)
     case 'Iterator':
-      return yield* TIterator(schema_, references_, path, value)
+      return yield* FromIterator(schema_, references_, path, value)
     case 'Literal':
-      return yield* TLiteral(schema_, references_, path, value)
+      return yield* FromLiteral(schema_, references_, path, value)
     case 'Never':
-      return yield* TNever(schema_, references_, path, value)
+      return yield* FromNever(schema_, references_, path, value)
     case 'Not':
-      return yield* TNot(schema_, references_, path, value)
+      return yield* FromNot(schema_, references_, path, value)
     case 'Null':
-      return yield* TNull(schema_, references_, path, value)
+      return yield* FromNull(schema_, references_, path, value)
     case 'Number':
-      return yield* TNumber(schema_, references_, path, value)
+      return yield* FromNumber(schema_, references_, path, value)
     case 'Object':
-      return yield* TObject(schema_, references_, path, value)
+      return yield* FromObject(schema_, references_, path, value)
     case 'Promise':
-      return yield* TPromise(schema_, references_, path, value)
+      return yield* FromPromise(schema_, references_, path, value)
     case 'Record':
-      return yield* TRecord(schema_, references_, path, value)
+      return yield* FromRecord(schema_, references_, path, value)
     case 'Ref':
-      return yield* TRef(schema_, references_, path, value)
+      return yield* FromRef(schema_, references_, path, value)
+    case 'RegExp':
+      return yield* FromRegExp(schema_, references_, path, value)
     case 'String':
-      return yield* TString(schema_, references_, path, value)
+      return yield* FromString(schema_, references_, path, value)
     case 'Symbol':
-      return yield* TSymbol(schema_, references_, path, value)
+      return yield* FromSymbol(schema_, references_, path, value)
     case 'TemplateLiteral':
-      return yield* TTemplateLiteral(schema_, references_, path, value)
+      return yield* FromTemplateLiteral(schema_, references_, path, value)
     case 'This':
-      return yield* TThis(schema_, references_, path, value)
+      return yield* FromThis(schema_, references_, path, value)
     case 'Tuple':
-      return yield* TTuple(schema_, references_, path, value)
+      return yield* FromTuple(schema_, references_, path, value)
     case 'Undefined':
-      return yield* TUndefined(schema_, references_, path, value)
+      return yield* FromUndefined(schema_, references_, path, value)
     case 'Union':
-      return yield* TUnion(schema_, references_, path, value)
+      return yield* FromUnion(schema_, references_, path, value)
     case 'Uint8Array':
-      return yield* TUint8Array(schema_, references_, path, value)
+      return yield* FromUint8Array(schema_, references_, path, value)
     case 'Unknown':
-      return yield* TUnknown(schema_, references_, path, value)
+      return yield* FromUnknown(schema_, references_, path, value)
     case 'Void':
-      return yield* TVoid(schema_, references_, path, value)
+      return yield* FromVoid(schema_, references_, path, value)
     default:
-      if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueErrorsUnknownTypeError(schema)
-      return yield* TKind(schema_, references_, path, value)
+      if (!TypeRegistry.Has(schema_[Kind])) throw new ValueErrorsUnknownTypeError(schema)
+      return yield* FromKind(schema_, references_, path, value)
   }
 }
 /** Returns an iterator for each error in this value. */
-export function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): ValueErrorIterator
+export function Errors<T extends TSchema>(schema: T, references: TSchema[], value: unknown): ValueErrorIterator
 /** Returns an iterator for each error in this value. */
-export function Errors<T extends Types.TSchema>(schema: T, value: unknown): ValueErrorIterator
+export function Errors<T extends TSchema>(schema: T, value: unknown): ValueErrorIterator
 /** Returns an iterator for each error in this value. */
 export function Errors(...args: any[]) {
   const iterator = args.length === 3 ? Visit(args[0], args[1], '', args[2]) : Visit(args[0], [], '', args[1])
diff --git a/src/errors/function.ts b/src/errors/function.ts
new file mode 100644
index 000000000..bba4ff53b
--- /dev/null
+++ b/src/errors/function.ts
@@ -0,0 +1,193 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/system
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TSchema } from '../type/schema/index'
+import { Kind } from '../type/symbols/index'
+import { ValueErrorType } from './errors'
+
+/** Creates an error message using en-US as the default locale */
+export function DefaultErrorFunction(error: ErrorFunctionParameter) {
+  switch (error.errorType) {
+    case ValueErrorType.ArrayContains:
+      return 'Expected array to contain at least one matching value'
+    case ValueErrorType.ArrayMaxContains:
+      return `Expected array to contain no more than ${error.schema.maxContains} matching values`
+    case ValueErrorType.ArrayMinContains:
+      return `Expected array to contain at least ${error.schema.minContains} matching values`
+    case ValueErrorType.ArrayMaxItems:
+      return `Expected array length to be less or equal to ${error.schema.maxItems}`
+    case ValueErrorType.ArrayMinItems:
+      return `Expected array length to be greater or equal to ${error.schema.minItems}`
+    case ValueErrorType.ArrayUniqueItems:
+      return 'Expected array elements to be unique'
+    case ValueErrorType.Array:
+      return 'Expected array'
+    case ValueErrorType.AsyncIterator:
+      return 'Expected AsyncIterator'
+    case ValueErrorType.BigIntExclusiveMaximum:
+      return `Expected bigint to be less than ${error.schema.exclusiveMaximum}`
+    case ValueErrorType.BigIntExclusiveMinimum:
+      return `Expected bigint to be greater than ${error.schema.exclusiveMinimum}`
+    case ValueErrorType.BigIntMaximum:
+      return `Expected bigint to be less or equal to ${error.schema.maximum}`
+    case ValueErrorType.BigIntMinimum:
+      return `Expected bigint to be greater or equal to ${error.schema.minimum}`
+    case ValueErrorType.BigIntMultipleOf:
+      return `Expected bigint to be a multiple of ${error.schema.multipleOf}`
+    case ValueErrorType.BigInt:
+      return 'Expected bigint'
+    case ValueErrorType.Boolean:
+      return 'Expected boolean'
+    case ValueErrorType.DateExclusiveMinimumTimestamp:
+      return `Expected Date timestamp to be greater than ${error.schema.exclusiveMinimumTimestamp}`
+    case ValueErrorType.DateExclusiveMaximumTimestamp:
+      return `Expected Date timestamp to be less than ${error.schema.exclusiveMaximumTimestamp}`
+    case ValueErrorType.DateMinimumTimestamp:
+      return `Expected Date timestamp to be greater or equal to ${error.schema.minimumTimestamp}`
+    case ValueErrorType.DateMaximumTimestamp:
+      return `Expected Date timestamp to be less or equal to ${error.schema.maximumTimestamp}`
+    case ValueErrorType.DateMultipleOfTimestamp:
+      return `Expected Date timestamp to be a multiple of ${error.schema.multipleOfTimestamp}`
+    case ValueErrorType.Date:
+      return 'Expected Date'
+    case ValueErrorType.Function:
+      return 'Expected function'
+    case ValueErrorType.IntegerExclusiveMaximum:
+      return `Expected integer to be less than ${error.schema.exclusiveMaximum}`
+    case ValueErrorType.IntegerExclusiveMinimum:
+      return `Expected integer to be greater than ${error.schema.exclusiveMinimum}`
+    case ValueErrorType.IntegerMaximum:
+      return `Expected integer to be less or equal to ${error.schema.maximum}`
+    case ValueErrorType.IntegerMinimum:
+      return `Expected integer to be greater or equal to ${error.schema.minimum}`
+    case ValueErrorType.IntegerMultipleOf:
+      return `Expected integer to be a multiple of ${error.schema.multipleOf}`
+    case ValueErrorType.Integer:
+      return 'Expected integer'
+    case ValueErrorType.IntersectUnevaluatedProperties:
+      return 'Unexpected property'
+    case ValueErrorType.Intersect:
+      return 'Expected all values to match'
+    case ValueErrorType.Iterator:
+      return 'Expected Iterator'
+    case ValueErrorType.Literal:
+      return `Expected ${typeof error.schema.const === 'string' ? `'${error.schema.const}'` : error.schema.const}`
+    case ValueErrorType.Never:
+      return 'Never'
+    case ValueErrorType.Not:
+      return 'Value should not match'
+    case ValueErrorType.Null:
+      return 'Expected null'
+    case ValueErrorType.NumberExclusiveMaximum:
+      return `Expected number to be less than ${error.schema.exclusiveMaximum}`
+    case ValueErrorType.NumberExclusiveMinimum:
+      return `Expected number to be greater than ${error.schema.exclusiveMinimum}`
+    case ValueErrorType.NumberMaximum:
+      return `Expected number to be less or equal to ${error.schema.maximum}`
+    case ValueErrorType.NumberMinimum:
+      return `Expected number to be greater or equal to ${error.schema.minimum}`
+    case ValueErrorType.NumberMultipleOf:
+      return `Expected number to be a multiple of ${error.schema.multipleOf}`
+    case ValueErrorType.Number:
+      return 'Expected number'
+    case ValueErrorType.Object:
+      return 'Expected object'
+    case ValueErrorType.ObjectAdditionalProperties:
+      return 'Unexpected property'
+    case ValueErrorType.ObjectMaxProperties:
+      return `Expected object to have no more than ${error.schema.maxProperties} properties`
+    case ValueErrorType.ObjectMinProperties:
+      return `Expected object to have at least ${error.schema.minProperties} properties`
+    case ValueErrorType.ObjectRequiredProperty:
+      return 'Required property'
+    case ValueErrorType.Promise:
+      return 'Expected Promise'
+    case ValueErrorType.RegExp:
+      return 'Expected string to match regular expression'
+    case ValueErrorType.StringFormatUnknown:
+      return `Unknown format '${error.schema.format}'`
+    case ValueErrorType.StringFormat:
+      return `Expected string to match '${error.schema.format}' format`
+    case ValueErrorType.StringMaxLength:
+      return `Expected string length less or equal to ${error.schema.maxLength}`
+    case ValueErrorType.StringMinLength:
+      return `Expected string length greater or equal to ${error.schema.minLength}`
+    case ValueErrorType.StringPattern:
+      return `Expected string to match '${error.schema.pattern}'`
+    case ValueErrorType.String:
+      return 'Expected string'
+    case ValueErrorType.Symbol:
+      return 'Expected symbol'
+    case ValueErrorType.TupleLength:
+      return `Expected tuple to have ${error.schema.maxItems || 0} elements`
+    case ValueErrorType.Tuple:
+      return 'Expected tuple'
+    case ValueErrorType.Uint8ArrayMaxByteLength:
+      return `Expected byte length less or equal to ${error.schema.maxByteLength}`
+    case ValueErrorType.Uint8ArrayMinByteLength:
+      return `Expected byte length greater or equal to ${error.schema.minByteLength}`
+    case ValueErrorType.Uint8Array:
+      return 'Expected Uint8Array'
+    case ValueErrorType.Undefined:
+      return 'Expected undefined'
+    case ValueErrorType.Union:
+      return 'Expected union value'
+    case ValueErrorType.Void:
+      return 'Expected void'
+    case ValueErrorType.Kind:
+      return `Expected kind '${error.schema[Kind]}'`
+    default:
+      return 'Unknown error type'
+  }
+}
+
+// ------------------------------------------------------------------
+// ErrorFunction
+// ------------------------------------------------------------------
+export type ErrorFunctionParameter = {
+  /** The type of validation error */
+  errorType: ValueErrorType
+  /** The path of the error */
+  path: string
+  /** The schema associated with the error */
+  schema: TSchema
+  /** The value associated with the error */
+  value: unknown
+}
+export type ErrorFunction = (parameter: ErrorFunctionParameter) => string
+/** Manages error message providers */
+let errorFunction: ErrorFunction = DefaultErrorFunction
+
+/** Sets the error function used to generate error messages. */
+export function SetErrorFunction(callback: ErrorFunction) {
+  errorFunction = callback
+}
+/** Gets the error function used to generate error messages */
+export function GetErrorFunction(): ErrorFunction {
+  return errorFunction
+}
diff --git a/src/errors/index.ts b/src/errors/index.ts
index 71cdce9af..b5a10ef10 100644
--- a/src/errors/index.ts
+++ b/src/errors/index.ts
@@ -26,4 +26,5 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export * from './errors'
+export { Errors, ValueError, ValueErrorIterator, ValueErrorType, ValueErrorsUnknownTypeError } from './errors'
+export { DefaultErrorFunction, GetErrorFunction, SetErrorFunction, type ErrorFunction } from './function'
diff --git a/src/index.ts b/src/index.ts
new file mode 100644
index 000000000..6c243906b
--- /dev/null
+++ b/src/index.ts
@@ -0,0 +1,117 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+export { Kind, Hint, ReadonlyKind, OptionalKind, TransformKind } from './type/symbols/index'
+export { PatternBoolean, PatternBooleanExact, PatternNumber, PatternNumberExact, PatternString, PatternStringExact } from './type/patterns/index'
+export { TypeRegistry, FormatRegistry } from './type/registry/index'
+export { TypeGuard, ValueGuard } from './type/guard/index'
+export { CloneType, CloneRest } from './type/clone/type'
+export { TypeBoxError } from './type/error/index'
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+export { Any, type TAny } from './type/any/index'
+export { Array, type TArray, type ArrayOptions } from './type/array/index'
+export { AsyncIterator, type TAsyncIterator } from './type/async-iterator/index'
+export { Awaited, type TAwaited } from './type/awaited/index'
+export { BigInt, type TBigInt, type BigIntOptions } from './type/bigint/index'
+export { Boolean, type TBoolean } from './type/boolean/index'
+export { Composite, type TComposite } from './type/composite/index'
+export { Const, type TConst } from './type/const/index'
+export { Constructor, type TConstructor } from './type/constructor/index'
+export { ConstructorParameters, type TConstructorParameters } from './type/constructor-parameters/index'
+export { Date, type TDate, type DateOptions } from './type/date/index'
+export { Deref, type TDeref } from './type/deref/index'
+export { Enum, type TEnum } from './type/enum/index'
+export { Exclude, type TExclude, type TExcludeFromMappedResult } from './type/exclude/index'
+export { Extends, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './type/extends/index'
+export { Extract, type TExtract, type TExtractFromMappedResult } from './type/extract/index'
+export { Function, type TFunction } from './type/function/index'
+export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index'
+export { Index, IndexPropertyKeys, IndexFromMappedKey, IndexFromMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult } from './type/indexed/index'
+export { InstanceType, type TInstanceType } from './type/instance-type/index'
+export { Integer, type TInteger, type IntegerOptions } from './type/integer/index'
+export { Intersect, IntersectEvaluated, type TIntersect, type TIntersectEvaluated, type IntersectOptions } from './type/intersect/index'
+export { Iterator, type TIterator } from './type/iterator/index'
+export { Intrinsic, IntrinsicFromMappedKey, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index'
+export { KeyOf, type TKeyOf, type KeyOfFromMappedResult, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index'
+export { Literal, type TLiteral } from './type/literal/index'
+export { Mapped, MappedKey, MappedResult, type TMapped, type TMappedKey, type TMappedResult, type TMappedFunction } from './type/mapped/index'
+export { Never, type TNever } from './type/never/index'
+export { Not, type TNot } from './type/not/index'
+export { Null, type TNull } from './type/null/index'
+export { Number, type TNumber, type NumberOptions } from './type/number/index'
+export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index'
+export { Omit, type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from './type/omit/index'
+export { Optional, OptionalFromMappedResult, type TOptional, type TOptionalWithFlag, type TOptionalFromMappedResult } from './type/optional/index'
+export { Parameters, type TParameters } from './type/parameters/index'
+export { Partial, PartialFromMappedResult, type TPartial, type TPartialFromMappedResult } from './type/partial/index'
+export { Pick, type TPick, type TPickFromMappedKey, type TPickFromMappedResult } from './type/pick/index'
+export { Promise, type TPromise } from './type/promise/index'
+export { Readonly, ReadonlyFromMappedResult, type TReadonly, type TReadonlyWithFlag, type TReadonlyFromMappedResult } from './type/readonly/index'
+export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index'
+export { Record, type TRecord } from './type/record/index'
+export { Recursive, type TRecursive, type TThis } from './type/recursive/index'
+export { Ref, type TRef } from './type/ref/index'
+export { RegExp, type TRegExp } from './type/regexp/index'
+export { Required, type TRequired, type TRequiredFromMappedResult } from './type/required/index'
+export { Rest, type TRest } from './type/rest/index'
+export { ReturnType, type TReturnType } from './type/return-type/index'
+export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from './type/schema/index'
+export { type Static, type StaticDecode, type StaticEncode } from './type/static/index'
+export { Strict } from './type/strict/index'
+export { String, type TString, type StringOptions, type StringFormatOption, type StringContentEncodingOption } from './type/string/index'
+export { Symbol, type TSymbol, type TSymbolValue as SymbolValue } from './type/symbol/index'
+export {
+  TemplateLiteral,
+  IsTemplateLiteralFinite,
+  IsTemplateLiteralExpressionFinite,
+  TemplateLiteralParse,
+  TemplateLiteralParseExact,
+  TemplateLiteralGenerate,
+  TemplateLiteralExpressionGenerate,
+  type TTemplateLiteral,
+  type TIsTemplateLiteralFinite,
+  type TTemplateLiteralGenerate,
+  type TTemplateLiteralKind,
+} from './type/template-literal/index'
+export { Transform, TransformDecodeBuilder, TransformEncodeBuilder, type TTransform, type TransformOptions, type TransformFunction } from './type/transform/index'
+export { Tuple, type TTuple } from './type/tuple/index'
+export { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from './type/uint8array/index'
+export { Undefined, type TUndefined } from './type/undefined/index'
+export { Union, UnionEvaluated, type TUnion, type TUnionEvaluated } from './type/union/index'
+export { Unknown, type TUnknown } from './type/unknown/index'
+export { Unsafe, type TUnsafe } from './type/unsafe/index'
+export { Void, type TVoid } from './type/void/index'
+// ------------------------------------------------------------------
+// Namespace
+// ------------------------------------------------------------------
+export { Type, JsonTypeBuilder, JavaScriptTypeBuilder } from './type/type/index'
diff --git a/src/system/index.ts b/src/system/index.ts
index 21c978add..fe79f6d08 100644
--- a/src/system/index.ts
+++ b/src/system/index.ts
@@ -26,5 +26,5 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export { ValueErrorType } from '../errors/errors'
-export * from './system'
+export { TypeSystemPolicy } from './policy'
+export { TypeSystem, TypeSystemDuplicateFormat, TypeSystemDuplicateTypeKind } from './system'
diff --git a/src/system/policy.ts b/src/system/policy.ts
new file mode 100644
index 000000000..04c4a4ec2
--- /dev/null
+++ b/src/system/policy.ts
@@ -0,0 +1,67 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/system
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { IsObject, IsArray, IsNumber, IsUndefined } from '../value/guard/index'
+
+export namespace TypeSystemPolicy {
+  // ------------------------------------------------------------------
+  // TypeSystemPolicy
+  // ------------------------------------------------------------------
+  /** Shared assertion routines used by the value and errors modules */
+  /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
+  export let ExactOptionalPropertyTypes: boolean = false
+  /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
+  export let AllowArrayObject: boolean = false
+  /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
+  export let AllowNaN: boolean = false
+  /** Sets whether `null` should validate for void types. The default is `false` */
+  export let AllowNullVoid: boolean = false
+  /** Asserts this value using the ExactOptionalPropertyTypes policy */
+  export function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string) {
+    return ExactOptionalPropertyTypes ? key in value : value[key] !== undefined
+  }
+  /** Asserts this value using the AllowArrayObjects policy */
+  export function IsObjectLike(value: unknown): value is Record<keyof any, unknown> {
+    const isObject = IsObject(value)
+    return AllowArrayObject ? isObject : isObject && !IsArray(value)
+  }
+  /** Asserts this value as a record using the AllowArrayObjects policy */
+  export function IsRecordLike(value: unknown): value is Record<keyof any, unknown> {
+    return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array)
+  }
+  /** Asserts this value using the AllowNaN policy */
+  export function IsNumberLike(value: unknown): value is number {
+    const isNumber = IsNumber(value)
+    return AllowNaN ? isNumber : isNumber && Number.isFinite(value)
+  }
+  /** Asserts this value using the AllowVoidNull policy */
+  export function IsVoidLike(value: unknown): value is void {
+    const isUndefined = IsUndefined(value)
+    return AllowNullVoid ? isUndefined || value === null : isUndefined
+  }
+}
diff --git a/src/system/system.ts b/src/system/system.ts
index 528286259..0c1535b05 100644
--- a/src/system/system.ts
+++ b/src/system/system.ts
@@ -26,234 +26,39 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsObject, IsArray, IsNumber, IsUndefined } from '../value/guard'
-import { ValueErrorType } from '../errors/errors'
-import * as Types from '../typebox'
+import { TypeRegistry, FormatRegistry } from '../type/registry/index'
+import { Unsafe } from '../type/unsafe/index'
+import { Kind } from '../type/symbols/index'
+import { TypeBoxError } from '../type/error/index'
 
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Errors
-// --------------------------------------------------------------------------
-export class TypeSystemDuplicateTypeKind extends Types.TypeBoxError {
+// ------------------------------------------------------------------
+export class TypeSystemDuplicateTypeKind extends TypeBoxError {
   constructor(kind: string) {
     super(`Duplicate type kind '${kind}' detected`)
   }
 }
-export class TypeSystemDuplicateFormat extends Types.TypeBoxError {
+export class TypeSystemDuplicateFormat extends TypeBoxError {
   constructor(kind: string) {
     super(`Duplicate string format '${kind}' detected`)
   }
 }
-// -------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // TypeSystem
-// -------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------
 /** Creates user defined types and formats and provides overrides for value checking behaviours */
 export namespace TypeSystem {
   /** Creates a new type */
   export function Type<Type, Options = Record<PropertyKey, unknown>>(kind: string, check: (options: Options, value: unknown) => boolean) {
-    if (Types.TypeRegistry.Has(kind)) throw new TypeSystemDuplicateTypeKind(kind)
-    Types.TypeRegistry.Set(kind, check)
-    return (options: Partial<Options> = {}) => Types.Type.Unsafe<Type>({ ...options, [Types.Kind]: kind })
+    if (TypeRegistry.Has(kind)) throw new TypeSystemDuplicateTypeKind(kind)
+    TypeRegistry.Set(kind, check)
+    return (options: Partial<Options> = {}) => Unsafe<Type>({ ...options, [Kind]: kind })
   }
   /** Creates a new string format */
   export function Format<F extends string>(format: F, check: (value: string) => boolean): F {
-    if (Types.FormatRegistry.Has(format)) throw new TypeSystemDuplicateFormat(format)
-    Types.FormatRegistry.Set(format, check)
+    if (FormatRegistry.Has(format)) throw new TypeSystemDuplicateFormat(format)
+    FormatRegistry.Set(format, check)
     return format
   }
 }
-// --------------------------------------------------------------------------
-// TypeSystemErrorFunction
-// --------------------------------------------------------------------------
-/** Manages error message providers */
-export namespace TypeSystemErrorFunction {
-  let errorMessageFunction: ErrorFunction = DefaultErrorFunction
-  /** Resets the error message function to en-us */
-  export function Reset() {
-    errorMessageFunction = DefaultErrorFunction
-  }
-  /** Sets the error message function used to generate error messages */
-  export function Set(callback: ErrorFunction) {
-    errorMessageFunction = callback
-  }
-  /** Gets the error message function */
-  export function Get(): ErrorFunction {
-    return errorMessageFunction
-  }
-}
-// --------------------------------------------------------------------------
-// TypeSystemPolicy
-// --------------------------------------------------------------------------
-/** Shared assertion routines used by the value and errors modules */
-export namespace TypeSystemPolicy {
-  /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
-  export let ExactOptionalPropertyTypes: boolean = false
-  /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
-  export let AllowArrayObject: boolean = false
-  /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
-  export let AllowNaN: boolean = false
-  /** Sets whether `null` should validate for void types. The default is `false` */
-  export let AllowNullVoid: boolean = false
-  /** Asserts this value using the ExactOptionalPropertyTypes policy */
-  export function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string) {
-    return ExactOptionalPropertyTypes ? key in value : value[key] !== undefined
-  }
-  /** Asserts this value using the AllowArrayObjects policy */
-  export function IsObjectLike(value: unknown): value is Record<keyof any, unknown> {
-    const isObject = IsObject(value)
-    return AllowArrayObject ? isObject : isObject && !IsArray(value)
-  }
-  /** Asserts this value as a record using the AllowArrayObjects policy */
-  export function IsRecordLike(value: unknown): value is Record<keyof any, unknown> {
-    return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array)
-  }
-  /** Asserts this value using the AllowNaN policy */
-  export function IsNumberLike(value: unknown): value is number {
-    const isNumber = IsNumber(value)
-    return AllowNaN ? isNumber : isNumber && Number.isFinite(value)
-  }
-  /** Asserts this value using the AllowVoidNull policy */
-  export function IsVoidLike(value: unknown): value is void {
-    const isUndefined = IsUndefined(value)
-    return AllowNullVoid ? isUndefined || value === null : isUndefined
-  }
-}
-// --------------------------------------------------------------------------
-// ErrorFunction
-// --------------------------------------------------------------------------
-export type ErrorFunction = (schema: Types.TSchema, type: ValueErrorType) => string
-// --------------------------------------------------------------------------
-// DefaultErrorFunction
-// --------------------------------------------------------------------------
-/** Creates an error message using en-US as the default locale */
-export function DefaultErrorFunction(schema: Types.TSchema, errorType: ValueErrorType) {
-  switch (errorType) {
-    case ValueErrorType.ArrayContains:
-      return 'Expected array to contain at least one matching value'
-    case ValueErrorType.ArrayMaxContains:
-      return `Expected array to contain no more than ${schema.maxContains} matching values`
-    case ValueErrorType.ArrayMinContains:
-      return `Expected array to contain at least ${schema.minContains} matching values`
-    case ValueErrorType.ArrayMaxItems:
-      return `Expected array length to be less or equal to ${schema.maxItems}`
-    case ValueErrorType.ArrayMinItems:
-      return `Expected array length to be greater or equal to ${schema.minItems}`
-    case ValueErrorType.ArrayUniqueItems:
-      return 'Expected array elements to be unique'
-    case ValueErrorType.Array:
-      return 'Expected array'
-    case ValueErrorType.AsyncIterator:
-      return 'Expected AsyncIterator'
-    case ValueErrorType.BigIntExclusiveMaximum:
-      return `Expected bigint to be less than ${schema.exclusiveMaximum}`
-    case ValueErrorType.BigIntExclusiveMinimum:
-      return `Expected bigint to be greater than ${schema.exclusiveMinimum}`
-    case ValueErrorType.BigIntMaximum:
-      return `Expected bigint to be less or equal to ${schema.maximum}`
-    case ValueErrorType.BigIntMinimum:
-      return `Expected bigint to be greater or equal to ${schema.minimum}`
-    case ValueErrorType.BigIntMultipleOf:
-      return `Expected bigint to be a multiple of ${schema.multipleOf}`
-    case ValueErrorType.BigInt:
-      return 'Expected bigint'
-    case ValueErrorType.Boolean:
-      return 'Expected boolean'
-    case ValueErrorType.DateExclusiveMinimumTimestamp:
-      return `Expected Date timestamp to be greater than ${schema.exclusiveMinimumTimestamp}`
-    case ValueErrorType.DateExclusiveMaximumTimestamp:
-      return `Expected Date timestamp to be less than ${schema.exclusiveMaximumTimestamp}`
-    case ValueErrorType.DateMinimumTimestamp:
-      return `Expected Date timestamp to be greater or equal to ${schema.minimumTimestamp}`
-    case ValueErrorType.DateMaximumTimestamp:
-      return `Expected Date timestamp to be less or equal to ${schema.maximumTimestamp}`
-    case ValueErrorType.DateMultipleOfTimestamp:
-      return `Expected Date timestamp to be a multiple of ${schema.multipleOfTimestamp}`
-    case ValueErrorType.Date:
-      return 'Expected Date'
-    case ValueErrorType.Function:
-      return 'Expected function'
-    case ValueErrorType.IntegerExclusiveMaximum:
-      return `Expected integer to be less than ${schema.exclusiveMaximum}`
-    case ValueErrorType.IntegerExclusiveMinimum:
-      return `Expected integer to be greater than ${schema.exclusiveMinimum}`
-    case ValueErrorType.IntegerMaximum:
-      return `Expected integer to be less or equal to ${schema.maximum}`
-    case ValueErrorType.IntegerMinimum:
-      return `Expected integer to be greater or equal to ${schema.minimum}`
-    case ValueErrorType.IntegerMultipleOf:
-      return `Expected integer to be a multiple of ${schema.multipleOf}`
-    case ValueErrorType.Integer:
-      return 'Expected integer'
-    case ValueErrorType.IntersectUnevaluatedProperties:
-      return 'Unexpected property'
-    case ValueErrorType.Intersect:
-      return 'Expected all values to match'
-    case ValueErrorType.Iterator:
-      return 'Expected Iterator'
-    case ValueErrorType.Literal:
-      return `Expected ${typeof schema.const === 'string' ? `'${schema.const}'` : schema.const}`
-    case ValueErrorType.Never:
-      return 'Never'
-    case ValueErrorType.Not:
-      return 'Value should not match'
-    case ValueErrorType.Null:
-      return 'Expected null'
-    case ValueErrorType.NumberExclusiveMaximum:
-      return `Expected number to be less than ${schema.exclusiveMaximum}`
-    case ValueErrorType.NumberExclusiveMinimum:
-      return `Expected number to be greater than ${schema.exclusiveMinimum}`
-    case ValueErrorType.NumberMaximum:
-      return `Expected number to be less or equal to ${schema.maximum}`
-    case ValueErrorType.NumberMinimum:
-      return `Expected number to be greater or equal to ${schema.minimum}`
-    case ValueErrorType.NumberMultipleOf:
-      return `Expected number to be a multiple of ${schema.multipleOf}`
-    case ValueErrorType.Number:
-      return 'Expected number'
-    case ValueErrorType.Object:
-      return 'Expected object'
-    case ValueErrorType.ObjectAdditionalProperties:
-      return 'Unexpected property'
-    case ValueErrorType.ObjectMaxProperties:
-      return `Expected object to have no more than ${schema.maxProperties} properties`
-    case ValueErrorType.ObjectMinProperties:
-      return `Expected object to have at least ${schema.minProperties} properties`
-    case ValueErrorType.ObjectRequiredProperty:
-      return 'Required property'
-    case ValueErrorType.Promise:
-      return 'Expected Promise'
-    case ValueErrorType.StringFormatUnknown:
-      return `Unknown format '${schema.format}'`
-    case ValueErrorType.StringFormat:
-      return `Expected string to match '${schema.format}' format`
-    case ValueErrorType.StringMaxLength:
-      return `Expected string length less or equal to ${schema.maxLength}`
-    case ValueErrorType.StringMinLength:
-      return `Expected string length greater or equal to ${schema.minLength}`
-    case ValueErrorType.StringPattern:
-      return `Expected string to match '${schema.pattern}'`
-    case ValueErrorType.String:
-      return 'Expected string'
-    case ValueErrorType.Symbol:
-      return 'Expected symbol'
-    case ValueErrorType.TupleLength:
-      return `Expected tuple to have ${schema.maxItems || 0} elements`
-    case ValueErrorType.Tuple:
-      return 'Expected tuple'
-    case ValueErrorType.Uint8ArrayMaxByteLength:
-      return `Expected byte length less or equal to ${schema.maxByteLength}`
-    case ValueErrorType.Uint8ArrayMinByteLength:
-      return `Expected byte length greater or equal to ${schema.minByteLength}`
-    case ValueErrorType.Uint8Array:
-      return 'Expected Uint8Array'
-    case ValueErrorType.Undefined:
-      return 'Expected undefined'
-    case ValueErrorType.Union:
-      return 'Expected union value'
-    case ValueErrorType.Void:
-      return 'Expected void'
-    case ValueErrorType.Kind:
-      return `Expected kind '${schema[Types.Kind]}'`
-    default:
-      return 'Unknown error type'
-  }
-}
diff --git a/src/tsconfig.json b/src/tsconfig.json
index c78307cfa..e53e3ebf1 100644
--- a/src/tsconfig.json
+++ b/src/tsconfig.json
@@ -1,4 +1,4 @@
 {
   "extends": "../tsconfig.json",
-  "files": ["compiler/index.ts", "errors/index.ts", "system/index.ts", "value/index.ts", "typebox.ts"]
+  "files": ["compiler/index.ts", "errors/index.ts", "system/index.ts", "type/index.ts", "value/index.ts", "index.ts"]
 }
diff --git a/src/type/any/any.ts b/src/type/any/any.ts
new file mode 100644
index 000000000..e462db9f5
--- /dev/null
+++ b/src/type/any/any.ts
@@ -0,0 +1,40 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+export interface TAny extends TSchema {
+  [Kind]: 'Any'
+  static: any
+}
+
+/** `[Json]` Creates an Any type */
+export function Any(options: SchemaOptions = {}): TAny {
+  return { ...options, [Kind]: 'Any' } as unknown as TAny
+}
diff --git a/src/type/any/index.ts b/src/type/any/index.ts
new file mode 100644
index 000000000..29688e122
--- /dev/null
+++ b/src/type/any/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './any'
diff --git a/src/type/array/array.ts b/src/type/array/array.ts
new file mode 100644
index 000000000..1165e6268
--- /dev/null
+++ b/src/type/array/array.ts
@@ -0,0 +1,62 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Static } from '../static/index'
+import { Kind } from '../symbols/index'
+import { CloneType } from '../clone/type'
+
+export interface ArrayOptions extends SchemaOptions {
+  /** The minimum number of items in this array */
+  minItems?: number
+  /** The maximum number of items in this array */
+  maxItems?: number
+  /** Should this schema contain unique items */
+  uniqueItems?: boolean
+  /** A schema for which some elements should match */
+  contains?: TSchema
+  /** A minimum number of contains schema matches */
+  minContains?: number
+  /** A maximum number of contains schema matches */
+  maxContains?: number
+}
+export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
+  [Kind]: 'Array'
+  static: Array<Static<T, this['params']>>
+  type: 'array'
+  items: T
+}
+/** `[Json]` Creates an Array type */
+export function Array<T extends TSchema>(schema: T, options: ArrayOptions = {}): TArray<T> {
+  return {
+    ...options,
+    [Kind]: 'Array',
+    type: 'array',
+    items: CloneType(schema),
+  } as unknown as TArray<T>
+}
diff --git a/src/type/array/index.ts b/src/type/array/index.ts
new file mode 100644
index 000000000..ae02b63c0
--- /dev/null
+++ b/src/type/array/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './array'
diff --git a/src/type/async-iterator/async-iterator.ts b/src/type/async-iterator/async-iterator.ts
new file mode 100644
index 000000000..9ee5f8755
--- /dev/null
+++ b/src/type/async-iterator/async-iterator.ts
@@ -0,0 +1,48 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Static } from '../static/index'
+import { Kind } from '../symbols/index'
+import { CloneType } from '../clone/type'
+
+export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'AsyncIterator'
+  static: AsyncIterableIterator<Static<T, this['params']>>
+  type: 'AsyncIterator'
+  items: T
+}
+/** `[JavaScript]` Creates a AsyncIterator type */
+export function AsyncIterator<T extends TSchema>(items: T, options: SchemaOptions = {}): TAsyncIterator<T> {
+  return {
+    ...options,
+    [Kind]: 'AsyncIterator',
+    type: 'AsyncIterator',
+    items: CloneType(items),
+  } as unknown as TAsyncIterator<T>
+}
diff --git a/src/type/async-iterator/index.ts b/src/type/async-iterator/index.ts
new file mode 100644
index 000000000..d6bc7cb22
--- /dev/null
+++ b/src/type/async-iterator/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './async-iterator'
diff --git a/src/type/awaited/awaited.ts b/src/type/awaited/awaited.ts
new file mode 100644
index 000000000..8eec616c4
--- /dev/null
+++ b/src/type/awaited/awaited.ts
@@ -0,0 +1,105 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Intersect, type TIntersect } from '../intersect/index'
+import { Union, type TUnion } from '../union/index'
+import { type TPromise } from '../promise/index'
+import { CloneType } from '../clone/type'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsIntersect, IsUnion, IsPromise } from '../guard/type'
+// ------------------------------------------------------------------
+// FromRest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> =
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TFromRest<R, [...Acc, TFromSchema<L>]>
+    : Acc
+// prettier-ignore
+function FromRest<T extends TSchema[]>(T: [...T]) : TFromRest<T> {
+  return T.map(L => FromSchema(L)) as TFromRest<T>
+}
+// ----------------------------------------------------------------
+// FromIntersect
+// ----------------------------------------------------------------
+// prettier-ignore
+type TFromIntersect<T extends TSchema[]> = TIntersect<TFromRest<T>>
+// prettier-ignore
+function FromIntersect<T extends TSchema[]>(T: [...T]): TFromIntersect<T> {
+  return Intersect(FromRest(T) as TSchema[]) as unknown as TFromIntersect<T>
+}
+// ----------------------------------------------------------------
+// FromUnion
+// ----------------------------------------------------------------
+// prettier-ignore
+type TFromUnion<T extends TSchema[]> = TUnion<TFromRest<T>>
+// prettier-ignore
+function FromUnion<T extends TSchema[]>(T: [...T]): TFromUnion<T> {
+  return Union(FromRest(T) as TSchema[]) as unknown as TFromUnion<T>
+}
+// ----------------------------------------------------------------
+// Promise
+// ----------------------------------------------------------------
+type TFromPromise<T extends TSchema> = TFromSchema<T>
+// prettier-ignore
+function FromPromise<T extends TSchema>(T: T): TFromPromise<T> {
+  return FromSchema(T) as TFromPromise<T>
+}
+// ----------------------------------------------------------------
+// FromSchema
+// ----------------------------------------------------------------
+// prettier-ignore
+type TFromSchema<T extends TSchema> =
+  T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> :
+  T extends TUnion<infer S> ? TUnion<TFromRest<S>> :
+  T extends TPromise<infer S> ? TFromSchema<S> :
+  T
+// prettier-ignore
+function FromSchema<T extends TSchema>(T: T): TFromSchema<T> {
+  return (
+    IsIntersect(T) ? FromIntersect(T.allOf) :
+    IsUnion(T) ? FromUnion(T.anyOf) :
+    IsPromise(T) ? FromPromise(T.item) :
+    T
+  ) as TFromSchema<T>
+}
+// ------------------------------------------------------------------
+// TAwaited
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TAwaited<T extends TSchema> = (
+  TFromSchema<T>
+)
+/** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
+export function Awaited<T extends TSchema>(T: T, options: SchemaOptions = {}): TFromSchema<T> {
+  return CloneType(FromSchema(T), options)
+}
diff --git a/src/type/awaited/index.ts b/src/type/awaited/index.ts
new file mode 100644
index 000000000..26a23a571
--- /dev/null
+++ b/src/type/awaited/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './awaited'
diff --git a/src/type/bigint/bigint.ts b/src/type/bigint/bigint.ts
new file mode 100644
index 000000000..53b0fb28d
--- /dev/null
+++ b/src/type/bigint/bigint.ts
@@ -0,0 +1,51 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+export interface BigIntOptions extends SchemaOptions {
+  exclusiveMaximum?: bigint
+  exclusiveMinimum?: bigint
+  maximum?: bigint
+  minimum?: bigint
+  multipleOf?: bigint
+}
+export interface TBigInt extends TSchema, BigIntOptions {
+  [Kind]: 'BigInt'
+  static: bigint
+  type: 'bigint'
+}
+/** `[JavaScript]` Creates a BigInt type */
+export function BigInt(options: BigIntOptions = {}): TBigInt {
+  return {
+    ...options,
+    [Kind]: 'BigInt',
+    type: 'bigint',
+  } as TBigInt
+}
diff --git a/src/type/bigint/index.ts b/src/type/bigint/index.ts
new file mode 100644
index 000000000..ce8f4fbf9
--- /dev/null
+++ b/src/type/bigint/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './bigint'
diff --git a/src/type/boolean/boolean.ts b/src/type/boolean/boolean.ts
new file mode 100644
index 000000000..7d3fe1aed
--- /dev/null
+++ b/src/type/boolean/boolean.ts
@@ -0,0 +1,44 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+export interface TBoolean extends TSchema {
+  [Kind]: 'Boolean'
+  static: boolean
+  type: 'boolean'
+}
+/** `[Json]` Creates a Boolean type */
+export function Boolean(options: SchemaOptions = {}): TBoolean {
+  return {
+    ...options,
+    [Kind]: 'Boolean',
+    type: 'boolean',
+  } as unknown as TBoolean
+}
diff --git a/src/type/boolean/index.ts b/src/type/boolean/index.ts
new file mode 100644
index 000000000..aad153cb3
--- /dev/null
+++ b/src/type/boolean/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './boolean'
diff --git a/src/type/clone/index.ts b/src/type/clone/index.ts
new file mode 100644
index 000000000..44bd8cb28
--- /dev/null
+++ b/src/type/clone/index.ts
@@ -0,0 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * as TypeClone from './type'
+export * as ValueClone from './value'
diff --git a/src/type/clone/type.ts b/src/type/clone/type.ts
new file mode 100644
index 000000000..08d1c3f43
--- /dev/null
+++ b/src/type/clone/type.ts
@@ -0,0 +1,39 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Clone } from './value'
+
+/** Clones a Rest */
+export function CloneRest<T extends TSchema[]>(schemas: T): T {
+  return schemas.map((schema) => CloneType(schema)) as T
+}
+/** Clones a Type */
+export function CloneType<T extends TSchema>(schema: T, options: SchemaOptions = {}): T {
+  return { ...Clone(schema), ...options }
+}
diff --git a/src/type/clone/value.ts b/src/type/clone/value.ts
new file mode 100644
index 000000000..03e880482
--- /dev/null
+++ b/src/type/clone/value.ts
@@ -0,0 +1,62 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as ValueGuard from '../guard/value'
+
+function ArrayType(value: unknown[]) {
+  return (value as any).map((value: unknown) => Visit(value as any))
+}
+function DateType(value: Date) {
+  return new Date(value.getTime())
+}
+function Uint8ArrayType(value: Uint8Array) {
+  return new Uint8Array(value)
+}
+function RegExpType(value: RegExp) {
+  return new RegExp(value.source, value.flags)
+}
+function ObjectType(value: Record<keyof any, unknown>) {
+  const clonedProperties = Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {})
+  const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key as any]) }), {})
+  return { ...clonedProperties, ...clonedSymbols }
+}
+// prettier-ignore
+function Visit(value: unknown): any {
+  return (
+    ValueGuard.IsArray(value) ? ArrayType(value) : 
+    ValueGuard.IsDate(value) ? DateType(value) : 
+    ValueGuard.IsUint8Array(value) ? Uint8ArrayType(value) : 
+    ValueGuard.IsRegExp(value) ? RegExpType(value) :
+    ValueGuard.IsObject(value) ? ObjectType(value) : 
+    value
+  )
+}
+/** Clones a value */
+export function Clone<T>(value: T): T {
+  return Visit(value)
+}
diff --git a/src/type/composite/composite.ts b/src/type/composite/composite.ts
new file mode 100644
index 000000000..0bfe80434
--- /dev/null
+++ b/src/type/composite/composite.ts
@@ -0,0 +1,75 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import type { UnionToTuple, Assert, Evaluate } from '../helpers/index'
+import { Object, type TObject, type TProperties, type ObjectOptions } from '../object/index'
+import { Intersect, type TIntersect } from '../intersect/index'
+import { Index, type TIndex } from '../indexed/index'
+import { KeyOfPropertyKeys } from '../keyof/index'
+import { CloneType } from '../clone/type'
+
+// ------------------------------------------------------------------
+// TCompositeKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+type TCompositeKeys<T extends TObject[], Acc extends PropertyKey = never> =
+  T extends [infer L extends TObject, ...infer R extends TObject[]]
+    ? TCompositeKeys<R, Acc | keyof L['properties']>
+    : Acc
+// ------------------------------------------------------------------
+// TCompositeIndex
+// ------------------------------------------------------------------
+// prettier-ignore
+type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[], Acc extends TProperties = {}> =
+  K extends [infer L extends string, ...infer R extends string[]]
+    ? TCompositeIndex<T, R, Acc & { [_ in L]: TIndex<T, [L]> }>
+    : Acc
+// prettier-ignore
+type TCompositeReduce<T extends TObject[]> = UnionToTuple<TCompositeKeys<T>> extends infer K
+  ? Evaluate<TCompositeIndex<TIntersect<T>, Assert<K, string[]>>>
+  : {} //                    ^ indexed via intersection of T
+// prettier-ignore
+type TCompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect
+  ? TObject<TCompositeReduce<T>>
+  : TObject<{}>
+function CompositeResolve<T extends TObject[]>(T: [...T]): TCompositeResolve<T> {
+  const intersect: TSchema = Intersect(T, {})
+  const keys = KeyOfPropertyKeys(intersect) as string[]
+  const properties = keys.reduce((acc, key) => ({ ...acc, [key]: Index(intersect, [key]) }), {} as TProperties)
+  return Object(properties) as TCompositeResolve<T>
+}
+// ------------------------------------------------------------------
+// TComposite
+// ------------------------------------------------------------------
+export type TComposite<T extends TObject[]> = TCompositeResolve<T>
+
+/** `[Json]` Creates a Composite object type */
+export function Composite<T extends TObject[]>(T: [...T], options?: ObjectOptions): TComposite<T> {
+  return CloneType(CompositeResolve(T) as TObject, options) as TComposite<T>
+}
diff --git a/src/type/composite/index.ts b/src/type/composite/index.ts
new file mode 100644
index 000000000..2fe294b71
--- /dev/null
+++ b/src/type/composite/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './composite'
diff --git a/src/type/const/const.ts b/src/type/const/const.ts
new file mode 100644
index 000000000..b3ce2ac58
--- /dev/null
+++ b/src/type/const/const.ts
@@ -0,0 +1,135 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { AssertRest, Evaluate } from '../helpers/index'
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { TProperties } from '../object/index'
+
+import { Any, type TAny } from '../any/index'
+import { BigInt, type TBigInt } from '../bigint/index'
+import { Date, type TDate } from '../date/index'
+import { Function as FunctionType, type TFunction } from '../function/index'
+import { Literal, type TLiteral } from '../literal/index'
+import { type TNever } from '../never/index'
+import { Null, type TNull } from '../null/index'
+import { Object, type TObject } from '../object/index'
+import { Symbol, type TSymbol } from '../symbol/index'
+import { Tuple, type TTuple } from '../tuple/index'
+import { Readonly, type TReadonly } from '../readonly/index'
+import { Undefined, type TUndefined } from '../undefined/index'
+import { Uint8Array, type TUint8Array } from '../uint8array/index'
+import { Unknown, type TUnknown } from '../unknown/index'
+import { TypeClone } from '../clone/index'
+
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsArray, IsNumber, IsBigInt, IsUint8Array, IsDate, IsIterator, IsObject, IsAsyncIterator, IsFunction, IsUndefined, IsNull, IsSymbol, IsBoolean, IsString } from '../guard/value'
+// ------------------------------------------------------------------
+// FromArray
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromArray<T extends readonly unknown[]> = 
+  T extends readonly [infer L extends unknown, ...infer R extends unknown[]] 
+    ? [FromValue<L, false>, ...TFromArray<R>] 
+    : T
+// prettier-ignore
+function FromArray<T extends readonly unknown[]>(T: [...T]): TFromArray<T> {
+  return T.map(L => FromValue(L, false)) as TFromArray<T>
+}
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperties<T extends Record<PropertyKey, unknown>> = {
+  -readonly [K in keyof T]: FromValue<T[K], false> extends infer R extends TSchema 
+    ? TReadonly<R>
+    : TReadonly<TNever>
+}
+// prettier-ignore
+function FromProperties<T extends Record<PropertyKey, unknown>>(value: T): TFromProperties<T> {
+  return globalThis.Object.getOwnPropertyNames(value).reduce((acc, key) => {
+    return { ...acc, [key]: Readonly(FromValue(value[key], false)) }
+  }, {} as TProperties) as unknown as TFromProperties<T>
+}
+// ------------------------------------------------------------------
+// ConditionalReadonly - Only applied if not root
+// ------------------------------------------------------------------
+type TConditionalReadonly<T extends TSchema, Root extends boolean> = Root extends true ? T : TReadonly<T>
+function ConditionalReadonly<T extends TSchema, Root extends boolean>(T: T, root: Root): TConditionalReadonly<T, Root> {
+  return (root === true ? T : Readonly(T)) as unknown as TConditionalReadonly<T, Root>
+}
+// ------------------------------------------------------------------
+// FromValue
+// ------------------------------------------------------------------
+// prettier-ignore
+type FromValue<T, Root extends boolean> = 
+  T extends AsyncIterableIterator<unknown> ? TConditionalReadonly<TAny, Root> : 
+  T extends IterableIterator<unknown> ? TConditionalReadonly<TAny, Root> : 
+  T extends readonly unknown[] ? TReadonly<TTuple<AssertRest<TFromArray<T>>>> :
+  T extends Uint8Array ? TUint8Array :
+  T extends Date ? TDate :
+  T extends Record<PropertyKey, unknown> ? TConditionalReadonly<TObject<Evaluate<TFromProperties<T>>>, Root> :
+  T extends Function ? TConditionalReadonly<TFunction<[], TUnknown>, Root> : 
+  T extends undefined ? TUndefined :
+  T extends null ? TNull :
+  T extends symbol ? TSymbol :
+  T extends number ? TLiteral<T> : 
+  T extends boolean ? TLiteral<T> :
+  T extends string ? TLiteral<T> : 
+  T extends bigint ? TBigInt : 
+  TObject<{}>
+// prettier-ignore
+function FromValue<T, Root extends boolean>(value: T, root: Root): FromValue<T, Root> {
+  return (
+    IsAsyncIterator(value) ? ConditionalReadonly(Any(), root) :
+    IsIterator(value) ? ConditionalReadonly(Any(), root) :
+    IsArray(value) ? Readonly(Tuple(FromArray(value) as TSchema[])) :
+    IsUint8Array(value) ? Uint8Array() :
+    IsDate(value) ?  Date() :
+    IsObject(value) ? ConditionalReadonly(Object(FromProperties(value as Record<PropertyKey, unknown>) as TProperties), root) :
+    IsFunction(value) ? ConditionalReadonly(FunctionType([], Unknown()), root) :
+    IsUndefined(value) ? Undefined() :
+    IsNull(value) ? Null() :
+    IsSymbol(value) ? Symbol() :
+    IsBigInt(value) ? BigInt() :
+    IsNumber(value) ? Literal(value) :
+    IsBoolean(value) ? Literal(value) :
+    IsString(value) ? Literal(value) :
+    Object({})
+  ) as FromValue<T, Root>
+}
+// ------------------------------------------------------------------
+// TConst
+// ------------------------------------------------------------------
+export type TConst<T> = FromValue<T, true>
+
+/** `[JavaScript]` Creates a readonly const type from the given value. */
+export function Const</* const (not supported in 4.0) */ T>(T: T, options: SchemaOptions = {}): TConst<T> {
+  return TypeClone.CloneType(FromValue(T, true), options) as TConst<T>
+}
diff --git a/src/type/const/index.ts b/src/type/const/index.ts
new file mode 100644
index 000000000..f13d0f549
--- /dev/null
+++ b/src/type/const/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './const'
diff --git a/src/type/constructor-parameters/constructor-parameters.ts b/src/type/constructor-parameters/constructor-parameters.ts
new file mode 100644
index 000000000..e2cb70e19
--- /dev/null
+++ b/src/type/constructor-parameters/constructor-parameters.ts
@@ -0,0 +1,46 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Ensure } from '../helpers/index'
+import type { TConstructor } from '../constructor/index'
+import { Tuple, type TTuple } from '../tuple/index'
+import { CloneRest } from '../clone/type'
+
+// ------------------------------------------------------------------
+// ConstructorParameters
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = (
+  Ensure<TTuple<T['parameters']>>
+)
+
+/** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
+export function ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options: SchemaOptions = {}): TConstructorParameters<T> {
+  return Tuple(CloneRest(schema.parameters), { ...options })
+}
diff --git a/src/type/constructor-parameters/index.ts b/src/type/constructor-parameters/index.ts
new file mode 100644
index 000000000..23f9c265b
--- /dev/null
+++ b/src/type/constructor-parameters/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './constructor-parameters'
diff --git a/src/type/constructor/constructor.ts b/src/type/constructor/constructor.ts
new file mode 100644
index 000000000..c4e37e8fc
--- /dev/null
+++ b/src/type/constructor/constructor.ts
@@ -0,0 +1,67 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Static } from '../static/index'
+import type { Ensure } from '../helpers/index'
+import { CloneType, CloneRest } from '../clone/type'
+import { Kind } from '../symbols/index'
+
+// ------------------------------------------------------------------
+// TConstructorStatic
+// ------------------------------------------------------------------
+type ConstructorStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>
+// prettier-ignore
+type ConstructorStaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = 
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? ConstructorStaticParameters<R, P, [...Acc, Static<L, P>]>
+    : Acc
+// prettier-ignore
+type ConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (
+  Ensure<new (...param: ConstructorStaticParameters<T, P>) => ConstructorStaticReturnType<U, P>>
+)
+// ------------------------------------------------------------------
+// TConstructor
+// ------------------------------------------------------------------
+export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'Constructor'
+  static: ConstructorStatic<T, U, this['params']>
+  type: 'Constructor'
+  parameters: T
+  returns: U
+}
+/** `[JavaScript]` Creates a Constructor type */
+export function Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U> {
+  return {
+    ...options,
+    [Kind]: 'Constructor',
+    type: 'Constructor',
+    parameters: CloneRest(parameters),
+    returns: CloneType(returns),
+  } as unknown as TConstructor<T, U>
+}
diff --git a/src/type/constructor/index.ts b/src/type/constructor/index.ts
new file mode 100644
index 000000000..8e75965f7
--- /dev/null
+++ b/src/type/constructor/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './constructor'
diff --git a/src/type/date/date.ts b/src/type/date/date.ts
new file mode 100644
index 000000000..9e45ec214
--- /dev/null
+++ b/src/type/date/date.ts
@@ -0,0 +1,56 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+export interface DateOptions extends SchemaOptions {
+  /** The exclusive maximum timestamp value */
+  exclusiveMaximumTimestamp?: number
+  /** The exclusive minimum timestamp value */
+  exclusiveMinimumTimestamp?: number
+  /** The maximum timestamp value */
+  maximumTimestamp?: number
+  /** The minimum timestamp value */
+  minimumTimestamp?: number
+  /** The multiple of timestamp value */
+  multipleOfTimestamp?: number
+}
+export interface TDate extends TSchema, DateOptions {
+  [Kind]: 'Date'
+  static: Date
+  type: 'date'
+}
+/** `[JavaScript]` Creates a Date type */
+export function Date(options: DateOptions = {}): TDate {
+  return {
+    ...options,
+    [Kind]: 'Date',
+    type: 'Date',
+  } as unknown as TDate
+}
diff --git a/src/type/date/index.ts b/src/type/date/index.ts
new file mode 100644
index 000000000..932ee5def
--- /dev/null
+++ b/src/type/date/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './date'
diff --git a/src/type/deref/deref.ts b/src/type/deref/deref.ts
new file mode 100644
index 000000000..84fa78421
--- /dev/null
+++ b/src/type/deref/deref.ts
@@ -0,0 +1,174 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import type { Evaluate } from '../helpers/index'
+import type { TTuple } from '../tuple/index'
+import type { TIntersect } from '../intersect/index'
+import type { TUnion } from '../union/index'
+import type { TPromise } from '../promise/index'
+import type { TAsyncIterator } from '../async-iterator/index'
+import type { TIterator } from '../iterator/index'
+import type { TArray } from '../array/index'
+import type { TConstructor } from '../constructor/index'
+import type { TFunction } from '../function/index'
+import type { TRef } from '../ref/index'
+import type { TObject, TProperties } from '../object/index'
+import { CloneType, CloneRest } from '../clone/type'
+import { Discard } from '../discard/index'
+import { IsUndefined } from '../guard/value'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsConstructor, IsFunction, IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsPromise, IsAsyncIterator, IsIterator, IsRef } from '../guard/type'
+// ------------------------------------------------------------------
+// FromRest
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+   ? TFromRest<R, [...Acc, DerefResolve<L>]>
+   : Acc
+)
+function FromRest(schema: TSchema[], references: TSchema[]) {
+  return schema.map((schema) => Deref(schema, references))
+}
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type FromProperties<T extends TProperties> = Evaluate<{
+  [K in keyof T]: DerefResolve<T[K]>
+}>
+// prettier-ignore
+function FromProperties(properties: TProperties, references: TSchema[]) {
+  return globalThis.Object.getOwnPropertyNames(properties).reduce((acc, key) => {
+    return {...acc, [key]: Deref(properties[key], references) }
+  }, {} as TProperties)
+}
+// prettier-ignore
+function FromConstructor(schema: TConstructor, references: TSchema[]) {
+  schema.parameters = FromRest(schema.parameters, references)
+  schema.returns = Deref(schema.returns, references)
+  return schema
+}
+// prettier-ignore
+function FromFunction(schema: TFunction, references: TSchema[]) {
+  schema.parameters = FromRest(schema.parameters, references)
+  schema.returns = Deref(schema.returns, references)
+  return schema
+}
+// prettier-ignore
+function FromIntersect(schema: TIntersect, references: TSchema[]) {
+  schema.allOf = FromRest(schema.allOf, references)
+  return schema
+}
+// prettier-ignore
+function FromUnion(schema: TUnion, references: TSchema[]) {
+  schema.anyOf = FromRest(schema.anyOf, references)
+  return schema
+}
+// prettier-ignore
+function FromTuple(schema: TTuple, references: TSchema[]) {
+  if(IsUndefined(schema.items)) return schema
+  schema.items = FromRest(schema.items, references)
+  return schema
+}
+// prettier-ignore
+function FromArray(schema: TArray, references: TSchema[]) {
+  schema.items = Deref(schema.items, references)
+  return schema
+}
+// prettier-ignore
+function FromObject(schema: TObject, references: TSchema[]) {
+  schema.properties = FromProperties(schema.properties, references)
+  return schema
+}
+// prettier-ignore
+function FromPromise(schema: TPromise, references: TSchema[]) {
+  schema.item = Deref(schema.item, references)
+  return schema
+}
+// prettier-ignore
+function FromAsyncIterator(schema: TAsyncIterator, references: TSchema[]) {
+  schema.items = Deref(schema.items, references)
+  return schema
+}
+// prettier-ignore
+function FromIterator(schema: TIterator, references: TSchema[]) {
+  schema.items = Deref(schema.items, references)
+  return schema
+}
+// prettier-ignore
+function FromRef(schema: TRef, references: TSchema[]) {
+  const target = references.find(remote => remote.$id === schema.$ref)
+  if(target === undefined) throw Error(`Unable to dereference schema with $id ${schema.$ref}`)
+  const discard = Discard(target, ['$id']) as TSchema
+  return Deref(discard, references)
+}
+// prettier-ignore
+export type DerefResolve<T extends TSchema> =
+  T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<S>, DerefResolve<R>> :
+  T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<S>, DerefResolve<R>> :
+  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> :
+  T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> :
+  T extends TTuple<infer S extends TSchema[]> ? TTuple<TFromRest<S>> :
+  T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> :
+  T extends TArray<infer S extends TSchema> ? TArray<DerefResolve<S>> :
+  T extends TPromise<infer S extends TSchema> ? TPromise<DerefResolve<S>> :
+  T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DerefResolve<S>> :
+  T extends TIterator<infer S extends TSchema> ? TIterator<DerefResolve<S>> :
+  T extends TRef<infer S extends TSchema> ? DerefResolve<S> :
+  T
+// prettier-ignore
+export function DerefResolve<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>  {
+  return (
+    IsConstructor(schema) ? FromConstructor(schema, references) :
+    IsFunction(schema) ? FromFunction(schema, references) :
+    IsIntersect(schema) ? FromIntersect(schema, references) :
+    IsUnion(schema) ? FromUnion(schema, references) :
+    IsTuple(schema) ? FromTuple(schema, references) :
+    IsArray(schema) ? FromArray(schema, references) :
+    IsObject(schema) ? FromObject(schema, references) :
+    IsPromise(schema) ? FromPromise(schema, references) :
+    IsAsyncIterator(schema) ? FromAsyncIterator(schema, references) :
+    IsIterator(schema) ? FromIterator(schema, references) :
+    IsRef(schema) ? FromRef(schema, references) :
+    schema
+  ) as TDeref<T> 
+}
+// ------------------------------------------------------------------
+// TDeref
+// ------------------------------------------------------------------
+export type TDeref<T extends TSchema> = DerefResolve<T>
+
+/** `[Json]` Creates a dereferenced type */
+export function Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T> {
+  return DerefResolve(CloneType(schema), CloneRest(references))
+}
diff --git a/src/type/deref/index.ts b/src/type/deref/index.ts
new file mode 100644
index 000000000..496b4d6f0
--- /dev/null
+++ b/src/type/deref/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './deref'
diff --git a/src/type/discard/discard.ts b/src/type/discard/discard.ts
new file mode 100644
index 000000000..f531f4d49
--- /dev/null
+++ b/src/type/discard/discard.ts
@@ -0,0 +1,35 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+function DiscardKey(value: Record<PropertyKey, any>, key: PropertyKey) {
+  const { [key]: _, ...rest } = value
+  return rest
+}
+export function Discard(value: Record<PropertyKey, any>, keys: PropertyKey[]) {
+  return keys.reduce((acc, key) => DiscardKey(acc, key), value)
+}
diff --git a/src/type/discard/index.ts b/src/type/discard/index.ts
new file mode 100644
index 000000000..43fb9af56
--- /dev/null
+++ b/src/type/discard/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './discard'
diff --git a/src/type/enum/enum.ts b/src/type/enum/enum.ts
new file mode 100644
index 000000000..4a92aeed2
--- /dev/null
+++ b/src/type/enum/enum.ts
@@ -0,0 +1,58 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Literal, type TLiteral } from '../literal/index'
+import { Kind, Hint } from '../symbols/index'
+import { Union } from '../union/index'
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsUndefined } from '../guard/value'
+// ------------------------------------------------------------------
+// TEnum
+// ------------------------------------------------------------------
+export type TEnumRecord = Record<TEnumKey, TEnumValue>
+export type TEnumValue = string | number
+export type TEnumKey = string
+export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
+  [Kind]: 'Union'
+  [Hint]: 'Enum'
+  static: T[keyof T]
+  anyOf: TLiteral<T[keyof T]>[]
+}
+/** `[Json]` Creates a Enum type */
+export function Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options: SchemaOptions = {}): TEnum<T> {
+  if (IsUndefined(item)) throw new Error('Enum undefined or empty')
+  const values1 = globalThis.Object.getOwnPropertyNames(item)
+    .filter((key) => isNaN(key as any))
+    .map((key) => item[key]) as T[keyof T][]
+  const values2 = [...new Set(values1)]
+  const anyOf = values2.map((value) => Literal(value))
+  return Union(anyOf, { ...options, [Hint]: 'Enum' }) as unknown as TEnum<T>
+}
diff --git a/src/type/enum/index.ts b/src/type/enum/index.ts
new file mode 100644
index 000000000..d5dfd4a6f
--- /dev/null
+++ b/src/type/enum/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './enum'
diff --git a/src/type/error/error.ts b/src/type/error/error.ts
new file mode 100644
index 000000000..652352632
--- /dev/null
+++ b/src/type/error/error.ts
@@ -0,0 +1,34 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+/** The base Error type thrown for all TypeBox exceptions  */
+export class TypeBoxError extends Error {
+  constructor(message: string) {
+    super(message)
+  }
+}
diff --git a/src/type/error/index.ts b/src/type/error/index.ts
new file mode 100644
index 000000000..277d5e011
--- /dev/null
+++ b/src/type/error/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './error'
diff --git a/src/type/exclude/exclude-from-mapped-result.ts b/src/type/exclude/exclude-from-mapped-result.ts
new file mode 100644
index 000000000..858bbfd9b
--- /dev/null
+++ b/src/type/exclude/exclude-from-mapped-result.ts
@@ -0,0 +1,89 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { TProperties } from '../object/index'
+import { MappedResult, type TMappedResult } from '../mapped/index'
+import { Exclude, type TExclude } from './exclude'
+
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperties<
+  K extends TProperties,
+  T extends TSchema
+> = (
+  { [K2 in keyof K]: TExclude<K[K2], T> }   
+)
+// prettier-ignore
+function FromProperties<
+  P extends TProperties,
+  T extends TSchema
+>(P: P, U: T, options: SchemaOptions): TFromProperties<P, T> {
+  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+    return {...Acc, [K2]: Exclude(P[K2], U, options) }
+  }, {}) as TFromProperties<P, T>
+}
+// ------------------------------------------------------------------
+// FromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromMappedResult<
+  R extends TMappedResult,
+  T extends TSchema
+> = (
+  TFromProperties<R['properties'], T>
+  )
+// prettier-ignore
+function FromMappedResult<
+  R extends TMappedResult,
+  T extends TSchema
+>(R: R, T: T, options: SchemaOptions): TFromMappedResult<R, T> {
+  return FromProperties(R.properties, T, options) as TFromMappedResult<R, T>
+}
+// ------------------------------------------------------------------
+// ExcludeFromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TExcludeFromMappedResult<
+  R extends TMappedResult,
+  T extends TSchema,
+  P extends TProperties = TFromMappedResult<R, T>
+> = (
+  TMappedResult<P>
+)
+// prettier-ignore
+export function ExcludeFromMappedResult<
+  R extends TMappedResult,
+  T extends TSchema,
+  P extends TProperties = TFromMappedResult<R, T>
+>(R: R, T: T, options: SchemaOptions): TMappedResult<P> {
+  const P = FromMappedResult(R, T, options) as unknown as P
+  return MappedResult(P) 
+}
diff --git a/src/type/exclude/exclude.ts b/src/type/exclude/exclude.ts
new file mode 100644
index 000000000..751e9e154
--- /dev/null
+++ b/src/type/exclude/exclude.ts
@@ -0,0 +1,96 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { UnionToTuple, AssertRest, AssertType, Assert } from '../helpers/index'
+import type { TMappedResult } from '../mapped/index'
+import { TemplateLiteralToUnion, type TTemplateLiteral } from '../template-literal/index'
+import { Union, type TUnion } from '../union/index'
+import { Never, type TNever } from '../never/index'
+import { type TLiteral } from '../literal/index'
+import { type Static } from '../static/index'
+import { type TUnionEvaluated } from '../union/index'
+import { ExtendsCheck, ExtendsResult } from '../extends/index'
+import { CloneType } from '../clone/type'
+import { ExcludeFromMappedResult, type TExcludeFromMappedResult } from './exclude-from-mapped-result'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/type'
+// ------------------------------------------------------------------
+// ExcludeResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+type TExcludeTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
+// prettier-ignore
+type TExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = (
+  Exclude<Static<T>, Static<U>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never
+)
+// prettier-ignore
+type TExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
+  [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? never : T[K]
+}[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never
+// prettier-ignore
+type TExcludeResolve<T extends TSchema, U extends TSchema> =
+  T extends TTemplateLiteral ? TExcludeTemplateLiteral<T, U> :
+  T extends TUnion<infer S> ? TExcludeArray<S, U> :
+  T extends U 
+    ? TNever 
+    : T
+// prettier-ignore
+function ExcludeResolve<L extends TSchema, R extends TSchema>(L: L, R: R): TExcludeResolve<L, R> {
+  return (
+    IsTemplateLiteral(L) ? ExcludeResolve(TemplateLiteralToUnion(L), R) :
+    IsTemplateLiteral(R) ? ExcludeResolve(L, TemplateLiteralToUnion(R)) :
+    IsUnion(L) ? (() => {
+      const narrowed = L.anyOf.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False)
+      return (narrowed.length === 1 ? narrowed[0] : Union(narrowed))
+    })() :
+    ExtendsCheck(L, R) !== ExtendsResult.False ? Never() :
+    L
+  ) as TExcludeResolve<L, R>
+}
+// ------------------------------------------------------------------
+// TExclude
+// ------------------------------------------------------------------
+export type TExclude<T extends TSchema, U extends TSchema> = TExcludeResolve<T, U>
+
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+export function Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+export function Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+export function Exclude(unionType: TSchema, excludedMembers: TSchema, options: SchemaOptions = {}) {
+  if (IsMappedResult(unionType)) {
+    return ExcludeFromMappedResult(unionType, excludedMembers, options)
+  } else {
+    const E = ExcludeResolve(unionType, excludedMembers) as any
+    return CloneType(E, options)
+  }
+}
diff --git a/src/type/exclude/index.ts b/src/type/exclude/index.ts
new file mode 100644
index 000000000..b83e080b5
--- /dev/null
+++ b/src/type/exclude/index.ts
@@ -0,0 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './exclude-from-mapped-result'
+export * from './exclude'
diff --git a/src/type/extends/extends-check.ts b/src/type/extends/extends-check.ts
new file mode 100644
index 000000000..d726d91ea
--- /dev/null
+++ b/src/type/extends/extends-check.ts
@@ -0,0 +1,776 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { type TAny, Any } from '../any/index'
+import { type TArray } from '../array/index'
+import { type TAsyncIterator } from '../async-iterator/index'
+import { type TBigInt } from '../bigint/index'
+import { type TBoolean } from '../boolean/index'
+import { type TConstructor } from '../constructor/index'
+import { type TDate } from '../date/index'
+import { type TFunction, Function as FunctionType } from '../function/index'
+import { type TInteger } from '../integer/index'
+import { type TIntersect } from '../intersect/index'
+import { type TIterator } from '../iterator/index'
+import { type TLiteral } from '../literal/index'
+import { type TNever } from '../never/index'
+import { type TNot } from '../not/index'
+import { type TNull } from '../null/index'
+import { type TNumber, Number } from '../number/index'
+import { type TObject } from '../object/index'
+import { type TPromise } from '../promise/index'
+import { type TRecord } from '../record/index'
+import { type TSchema } from '../schema/index'
+import { type TString, String } from '../string/index'
+import { type TSymbol } from '../symbol/index'
+import { type TTuple } from '../tuple/index'
+import { type TUint8Array } from '../uint8array/index'
+import { type TUndefined } from '../undefined/index'
+import { type TUnion } from '../union/index'
+import { type TUnknown, Unknown } from '../unknown/index'
+import { type TVoid } from '../void/index'
+
+import { TemplateLiteralToUnion } from '../template-literal/index'
+import { PatternNumberExact, PatternStringExact } from '../patterns/index'
+import { Kind, Hint } from '../symbols/index'
+import { TypeBoxError } from '../error/index'
+import { TypeGuard, ValueGuard } from '../guard/index'
+
+export class ExtendsResolverError extends TypeBoxError {}
+
+export enum ExtendsResult {
+  Union,
+  True,
+  False,
+}
+// ------------------------------------------------------------------
+// IntoBooleanResult
+// ------------------------------------------------------------------
+// prettier-ignore
+function IntoBooleanResult(result: ExtendsResult) {
+  return result === ExtendsResult.False ? result : ExtendsResult.True
+}
+// ------------------------------------------------------------------
+// Throw
+// ------------------------------------------------------------------
+// prettier-ignore
+function Throw(message: string): never {
+  throw new ExtendsResolverError(message)
+}
+// ------------------------------------------------------------------
+// StructuralRight
+// ------------------------------------------------------------------
+// prettier-ignore
+function IsStructuralRight(right: TSchema): boolean {
+  return (
+    TypeGuard.IsNever(right) ||
+    TypeGuard.IsIntersect(right) ||
+    TypeGuard.IsUnion(right) ||
+    TypeGuard.IsUnknown(right) ||
+    TypeGuard.IsAny(right)
+  )
+}
+// prettier-ignore
+function StructuralRight(left: TSchema, right: TSchema) {
+  return (
+    TypeGuard.IsNever(right) ? FromNeverRight(left, right) :
+    TypeGuard.IsIntersect(right) ? FromIntersectRight(left, right) :
+    TypeGuard.IsUnion(right) ? FromUnionRight(left, right) :
+    TypeGuard.IsUnknown(right) ? FromUnknownRight(left, right) :
+    TypeGuard.IsAny(right) ? FromAnyRight(left, right) :
+    Throw('StructuralRight')
+  )
+}
+// ------------------------------------------------------------------
+// Any
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromAnyRight(left: TSchema, right: TAny) {
+  return ExtendsResult.True
+}
+// prettier-ignore
+function FromAny(left: TAny, right: TSchema) {
+  return (
+    TypeGuard.IsIntersect(right) ? FromIntersectRight(left, right) :
+    (TypeGuard.IsUnion(right) && right.anyOf.some((schema) => TypeGuard.IsAny(schema) || TypeGuard.IsUnknown(schema))) ? ExtendsResult.True :
+    TypeGuard.IsUnion(right) ? ExtendsResult.Union :
+    TypeGuard.IsUnknown(right) ? ExtendsResult.True :
+    TypeGuard.IsAny(right) ? ExtendsResult.True :
+    ExtendsResult.Union
+  )
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromArrayRight(left: TSchema, right: TArray) {
+  return (
+    TypeGuard.IsUnknown(left) ? ExtendsResult.False :
+    TypeGuard.IsAny(left) ? ExtendsResult.Union :
+    TypeGuard.IsNever(left) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// prettier-ignore
+function FromArray(left: TArray, right: TSchema) {
+  return (
+    TypeGuard.IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True :
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    !TypeGuard.IsArray(right) ? ExtendsResult.False :
+    IntoBooleanResult(Visit(left.items, right.items))
+  )
+}
+// ------------------------------------------------------------------
+// AsyncIterator
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromAsyncIterator(left: TAsyncIterator, right: TSchema) {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    !TypeGuard.IsAsyncIterator(right) ? ExtendsResult.False :
+    IntoBooleanResult(Visit(left.items, right.items))
+  )
+}
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromBigInt(left: TBigInt, right: TSchema): ExtendsResult {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+    TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
+    TypeGuard.IsBigInt(right) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromBooleanRight(left: TSchema, right: TBoolean) {
+  return (
+    TypeGuard.IsLiteralBoolean(left) ? ExtendsResult.True : 
+    TypeGuard.IsBoolean(left) ? ExtendsResult.True : 
+    ExtendsResult.False
+  )
+}
+// prettier-ignore
+function FromBoolean(left: TBoolean, right: TSchema): ExtendsResult {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+    TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
+    TypeGuard.IsBoolean(right) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// ------------------------------------------------------------------
+// Constructor
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromConstructor(left: TConstructor, right: TSchema) {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+    !TypeGuard.IsConstructor(right) ? ExtendsResult.False :
+    left.parameters.length > right.parameters.length ? ExtendsResult.False :
+    (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === ExtendsResult.True)) ? ExtendsResult.False :
+    IntoBooleanResult(Visit(left.returns, right.returns))
+  )
+}
+// ------------------------------------------------------------------
+// Date
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromDate(left: TDate, right: TSchema) {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+    TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
+    TypeGuard.IsDate(right) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// ------------------------------------------------------------------
+// Function
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromFunction(left: TFunction, right: TSchema) {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+    !TypeGuard.IsFunction(right) ? ExtendsResult.False :
+    left.parameters.length > right.parameters.length ? ExtendsResult.False :
+    (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === ExtendsResult.True)) ? ExtendsResult.False :
+    IntoBooleanResult(Visit(left.returns, right.returns))
+  )
+}
+// ------------------------------------------------------------------
+// Integer
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromIntegerRight(left: TSchema, right: TInteger) {
+  return (
+    TypeGuard.IsLiteral(left) && ValueGuard.IsNumber(left.const) ? ExtendsResult.True :
+    TypeGuard.IsNumber(left) || TypeGuard.IsInteger(left) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// prettier-ignore
+function FromInteger(left: TInteger, right: TSchema): ExtendsResult {
+  return (
+    TypeGuard.IsInteger(right) || TypeGuard.IsNumber(right) ? ExtendsResult.True :
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+    TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
+    ExtendsResult.False
+  )
+}
+// ------------------------------------------------------------------
+// Intersect
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromIntersectRight(left: TSchema, right: TIntersect): ExtendsResult {
+  return right.allOf.every((schema) => Visit(left, schema) === ExtendsResult.True)
+    ? ExtendsResult.True
+    : ExtendsResult.False
+}
+// prettier-ignore
+function FromIntersect(left: TIntersect, right: TSchema) {
+  return left.allOf.some((schema) => Visit(schema, right) === ExtendsResult.True)
+    ? ExtendsResult.True
+    : ExtendsResult.False
+}
+// ------------------------------------------------------------------
+// Iterator
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromIterator(left: TIterator, right: TSchema) {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    !TypeGuard.IsIterator(right) ? ExtendsResult.False :
+    IntoBooleanResult(Visit(left.items, right.items))
+  )
+}
+// ------------------------------------------------------------------
+// Literal
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromLiteral(left: TLiteral, right: TSchema): ExtendsResult {
+  return (
+    TypeGuard.IsLiteral(right) && right.const === left.const ? ExtendsResult.True :
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+    TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
+    TypeGuard.IsString(right) ? FromStringRight(left, right) :
+    TypeGuard.IsNumber(right) ? FromNumberRight(left, right) :
+    TypeGuard.IsInteger(right) ? FromIntegerRight(left, right) :
+    TypeGuard.IsBoolean(right) ? FromBooleanRight(left, right) :
+    ExtendsResult.False
+  )
+}
+// ------------------------------------------------------------------
+// Never
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromNeverRight(left: TSchema, right: TNever) {
+  return ExtendsResult.False
+}
+// prettier-ignore
+function FromNever(left: TNever, right: TSchema) {
+  return ExtendsResult.True
+}
+// ------------------------------------------------------------------
+// Not
+// ------------------------------------------------------------------
+// prettier-ignore
+function UnwrapTNot<T extends TNot>(schema: T): TUnknown | TNot['not'] {
+  let [current, depth]: [TSchema, number] = [schema, 0]
+  while (true) {
+    if (!TypeGuard.IsNot(current)) break
+    current = current.not
+    depth += 1
+  }
+  return depth % 2 === 0 ? current : Unknown()
+}
+// prettier-ignore
+function FromNot(left: TSchema, right: TSchema) {
+  // TypeScript has no concept of negated types, and attempts to correctly check the negated
+  // type at runtime would put TypeBox at odds with TypeScripts ability to statically infer
+  // the type. Instead we unwrap to either unknown or T and continue evaluating.
+  // prettier-ignore
+  return (
+    TypeGuard.IsNot(left) ? Visit(UnwrapTNot(left), right) :
+    TypeGuard.IsNot(right) ? Visit(left, UnwrapTNot(right)) :
+    Throw('Invalid fallthrough for Not')
+  )
+}
+// ------------------------------------------------------------------
+// Null
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromNull(left: TNull, right: TSchema) {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+    TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
+    TypeGuard.IsNull(right) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromNumberRight(left: TSchema, right: TNumber) {
+  return (
+    TypeGuard.IsLiteralNumber(left) ? ExtendsResult.True :
+    TypeGuard.IsNumber(left) || TypeGuard.IsInteger(left) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// prettier-ignore
+function FromNumber(left: TNumber, right: TSchema): ExtendsResult {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+    TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
+    TypeGuard.IsInteger(right) || TypeGuard.IsNumber(right) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+// prettier-ignore
+function IsObjectPropertyCount(schema: TObject, count: number) {
+  return Object.getOwnPropertyNames(schema.properties).length === count
+}
+// prettier-ignore
+function IsObjectStringLike(schema: TObject) {
+  return IsObjectArrayLike(schema)
+}
+// prettier-ignore
+function IsObjectSymbolLike(schema: TObject) {
+  return IsObjectPropertyCount(schema, 0) || (
+    IsObjectPropertyCount(schema, 1) && 'description' in schema.properties && TypeGuard.IsUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && ((
+      TypeGuard.IsString(schema.properties.description.anyOf[0]) &&
+      TypeGuard.IsUndefined(schema.properties.description.anyOf[1])
+    ) || (
+        TypeGuard.IsString(schema.properties.description.anyOf[1]) &&
+        TypeGuard.IsUndefined(schema.properties.description.anyOf[0])
+      ))
+  )
+}
+// prettier-ignore
+function IsObjectNumberLike(schema: TObject) {
+  return IsObjectPropertyCount(schema, 0)
+}
+// prettier-ignore
+function IsObjectBooleanLike(schema: TObject) {
+  return IsObjectPropertyCount(schema, 0)
+}
+// prettier-ignore
+function IsObjectBigIntLike(schema: TObject) {
+  return IsObjectPropertyCount(schema, 0)
+}
+// prettier-ignore
+function IsObjectDateLike(schema: TObject) {
+  return IsObjectPropertyCount(schema, 0)
+}
+// prettier-ignore
+function IsObjectUint8ArrayLike(schema: TObject) {
+  return IsObjectArrayLike(schema)
+}
+// prettier-ignore
+function IsObjectFunctionLike(schema: TObject) {
+  const length = Number()
+  return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'length' in schema.properties && IntoBooleanResult(Visit(schema.properties['length'], length)) === ExtendsResult.True)
+}
+// prettier-ignore
+function IsObjectConstructorLike(schema: TObject) {
+  return IsObjectPropertyCount(schema, 0)
+}
+// prettier-ignore
+function IsObjectArrayLike(schema: TObject) {
+  const length = Number()
+  return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'length' in schema.properties && IntoBooleanResult(Visit(schema.properties['length'], length)) === ExtendsResult.True)
+}
+// prettier-ignore
+function IsObjectPromiseLike(schema: TObject) {
+  const then = FunctionType([Any()], Any())
+  return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'then' in schema.properties && IntoBooleanResult(Visit(schema.properties['then'], then)) === ExtendsResult.True)
+}
+// ------------------------------------------------------------------
+// Property
+// ------------------------------------------------------------------
+// prettier-ignore
+function Property(left: TSchema, right: TSchema) {
+  return (
+    Visit(left, right) === ExtendsResult.False ? ExtendsResult.False :
+    TypeGuard.IsOptional(left) && !TypeGuard.IsOptional(right) ? ExtendsResult.False :
+    ExtendsResult.True
+  )
+}
+// prettier-ignore
+function FromObjectRight(left: TSchema, right: TObject) {
+  return (
+    TypeGuard.IsUnknown(left) ? ExtendsResult.False :
+    TypeGuard.IsAny(left) ? ExtendsResult.Union : (
+      TypeGuard.IsNever(left) ||
+      (TypeGuard.IsLiteralString(left) && IsObjectStringLike(right)) ||
+      (TypeGuard.IsLiteralNumber(left) && IsObjectNumberLike(right)) ||
+      (TypeGuard.IsLiteralBoolean(left) && IsObjectBooleanLike(right)) ||
+      (TypeGuard.IsSymbol(left) && IsObjectSymbolLike(right)) ||
+      (TypeGuard.IsBigInt(left) && IsObjectBigIntLike(right)) ||
+      (TypeGuard.IsString(left) && IsObjectStringLike(right)) ||
+      (TypeGuard.IsSymbol(left) && IsObjectSymbolLike(right)) ||
+      (TypeGuard.IsNumber(left) && IsObjectNumberLike(right)) ||
+      (TypeGuard.IsInteger(left) && IsObjectNumberLike(right)) ||
+      (TypeGuard.IsBoolean(left) && IsObjectBooleanLike(right)) ||
+      (TypeGuard.IsUint8Array(left) && IsObjectUint8ArrayLike(right)) ||
+      (TypeGuard.IsDate(left) && IsObjectDateLike(right)) ||
+      (TypeGuard.IsConstructor(left) && IsObjectConstructorLike(right)) ||
+      (TypeGuard.IsFunction(left) && IsObjectFunctionLike(right))
+    ) ? ExtendsResult.True :
+    (TypeGuard.IsRecord(left) && TypeGuard.IsString(RecordKey(left))) ? (() => {
+      // When expressing a Record with literal key values, the Record is converted into a Object with
+      // the Hint assigned as `Record`. This is used to invert the extends logic.
+      return right[Hint] === 'Record' ? ExtendsResult.True : ExtendsResult.False
+    })() :
+    (TypeGuard.IsRecord(left) && TypeGuard.IsNumber(RecordKey(left))) ? (() => {
+      return IsObjectPropertyCount(right, 0) ? ExtendsResult.True : ExtendsResult.False
+    })() :
+    ExtendsResult.False
+  )
+}
+// prettier-ignore
+function FromObject(left: TObject, right: TSchema) {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
+    !TypeGuard.IsObject(right) ? ExtendsResult.False :
+    (() => {
+        for (const key of Object.getOwnPropertyNames(right.properties)) {
+          if (!(key in left.properties) && !TypeGuard.IsOptional(right.properties[key])) {
+          return ExtendsResult.False
+        }
+        if (TypeGuard.IsOptional(right.properties[key])) {
+          return ExtendsResult.True
+        }
+        if (Property(left.properties[key], right.properties[key]) === ExtendsResult.False) {
+          return ExtendsResult.False
+        }
+      }
+      return ExtendsResult.True
+    })()
+  )
+}
+// ------------------------------------------------------------------
+// Promise
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromPromise(left: TPromise, right: TSchema) {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsObject(right) && IsObjectPromiseLike(right) ? ExtendsResult.True :
+    !TypeGuard.IsPromise(right) ? ExtendsResult.False :
+    IntoBooleanResult(Visit(left.item, right.item))
+  )
+}
+// ------------------------------------------------------------------
+// Record
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordKey(schema: TRecord) {
+  return (
+    PatternNumberExact in schema.patternProperties ? Number() :
+    PatternStringExact in schema.patternProperties ? String() :
+    Throw('Unknown record key pattern')
+  )
+}
+// prettier-ignore
+function RecordValue(schema: TRecord) {
+  return (
+    PatternNumberExact in schema.patternProperties ? schema.patternProperties[PatternNumberExact] :
+    PatternStringExact in schema.patternProperties ? schema.patternProperties[PatternStringExact] :
+    Throw('Unable to get record value schema')
+  )
+}
+// prettier-ignore
+function FromRecordRight(left: TSchema, right: TRecord) {
+  const [Key, Value] = [RecordKey(right), RecordValue(right)]
+  return (
+    (
+      TypeGuard.IsLiteralString(left) && TypeGuard.IsNumber(Key) && IntoBooleanResult(Visit(left, Value)) === ExtendsResult.True) ? ExtendsResult.True :
+      TypeGuard.IsUint8Array(left) && TypeGuard.IsNumber(Key) ? Visit(left, Value) :
+      TypeGuard.IsString(left) && TypeGuard.IsNumber(Key) ? Visit(left, Value) :
+      TypeGuard.IsArray(left) && TypeGuard.IsNumber(Key) ? Visit(left, Value) :
+      TypeGuard.IsObject(left) ? (() => {
+        for (const key of Object.getOwnPropertyNames(left.properties)) {
+          if (Property(Value, left.properties[key]) === ExtendsResult.False) {
+            return ExtendsResult.False
+          }
+        }
+        return ExtendsResult.True
+      })() :
+    ExtendsResult.False
+  )
+}
+// prettier-ignore
+function FromRecord(left: TRecord, right: TSchema) {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+    !TypeGuard.IsRecord(right) ? ExtendsResult.False :
+    Visit(RecordValue(left), RecordValue(right))
+  )
+}
+// ------------------------------------------------------------------
+// RegExp
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromRegExp(left: TSchema, right: TSchema) {
+  // Note: RegExp types evaluate as strings, not RegExp objects.
+  // Here we remap either into string and continue evaluating.
+  const L = TypeGuard.IsRegExp(left) ? String() : left
+  const R = TypeGuard.IsRegExp(right) ? String() : right
+  return Visit(L, R)
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromStringRight(left: TSchema, right: TString) {
+  return (
+    TypeGuard.IsLiteral(left) && ValueGuard.IsString(left.const) ? ExtendsResult.True :
+    TypeGuard.IsString(left) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// prettier-ignore
+function FromString(left: TString, right: TSchema): ExtendsResult {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+    TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
+    TypeGuard.IsString(right) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// ------------------------------------------------------------------
+// Symbol
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromSymbol(left: TSymbol, right: TSchema): ExtendsResult {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+    TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
+    TypeGuard.IsSymbol(right) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// ------------------------------------------------------------------
+// TemplateLiteral
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromTemplateLiteral(left: TSchema, right: TSchema) {
+  // TemplateLiteral types are resolved to either unions for finite expressions or string
+  // for infinite expressions. Here we call to TemplateLiteralResolver to resolve for
+  // either type and continue evaluating.
+  return (
+    TypeGuard.IsTemplateLiteral(left) ? Visit(TemplateLiteralToUnion(left), right) :
+    TypeGuard.IsTemplateLiteral(right) ? Visit(left, TemplateLiteralToUnion(right)) :
+    Throw('Invalid fallthrough for TemplateLiteral')
+  )
+}
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+function IsArrayOfTuple(left: TTuple, right: TSchema) {
+  return (
+    TypeGuard.IsArray(right) &&
+    left.items !== undefined &&
+    left.items.every((schema) => Visit(schema, right.items) === ExtendsResult.True)
+  )
+}
+// prettier-ignore
+function FromTupleRight(left: TSchema, right: TTuple) {
+  return (
+    TypeGuard.IsNever(left) ? ExtendsResult.True :
+    TypeGuard.IsUnknown(left) ? ExtendsResult.False :
+    TypeGuard.IsAny(left) ? ExtendsResult.Union :
+    ExtendsResult.False
+  )
+}
+// prettier-ignore
+function FromTuple(left: TTuple, right: TSchema): ExtendsResult {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True :
+    TypeGuard.IsArray(right) && IsArrayOfTuple(left, right) ? ExtendsResult.True :
+    !TypeGuard.IsTuple(right) ? ExtendsResult.False :
+    (ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items)) || (!ValueGuard.IsUndefined(left.items) && ValueGuard.IsUndefined(right.items)) ? ExtendsResult.False :
+    (ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items)) ? ExtendsResult.True :
+    left.items!.every((schema, index) => Visit(schema, right.items![index]) === ExtendsResult.True) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// ------------------------------------------------------------------
+// Uint8Array
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromUint8Array(left: TUint8Array, right: TSchema) {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+    TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
+    TypeGuard.IsUint8Array(right) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// ------------------------------------------------------------------
+// Undefined
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromUndefined(left: TUndefined, right: TSchema) {
+  return (
+    IsStructuralRight(right) ? StructuralRight(left, right) :
+    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+    TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
+    TypeGuard.IsVoid(right) ? FromVoidRight(left, right) :
+    TypeGuard.IsUndefined(right) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromUnionRight(left: TSchema, right: TUnion): ExtendsResult {
+  return right.anyOf.some((schema) => Visit(left, schema) === ExtendsResult.True)
+    ? ExtendsResult.True
+    : ExtendsResult.False
+}
+// prettier-ignore
+function FromUnion(left: TUnion, right: TSchema): ExtendsResult {
+  return left.anyOf.every((schema) => Visit(schema, right) === ExtendsResult.True)
+    ? ExtendsResult.True
+    : ExtendsResult.False
+}
+// ------------------------------------------------------------------
+// Unknown
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromUnknownRight(left: TSchema, right: TUnknown) {
+  return ExtendsResult.True
+}
+// prettier-ignore
+function FromUnknown(left: TUnknown, right: TSchema) {
+  return (
+    TypeGuard.IsNever(right) ? FromNeverRight(left, right) :
+    TypeGuard.IsIntersect(right) ? FromIntersectRight(left, right) :
+    TypeGuard.IsUnion(right) ? FromUnionRight(left, right) :
+    TypeGuard.IsAny(right) ? FromAnyRight(left, right) :
+    TypeGuard.IsString(right) ? FromStringRight(left, right) :
+    TypeGuard.IsNumber(right) ? FromNumberRight(left, right) :
+    TypeGuard.IsInteger(right) ? FromIntegerRight(left, right) :
+    TypeGuard.IsBoolean(right) ? FromBooleanRight(left, right) :
+    TypeGuard.IsArray(right) ? FromArrayRight(left, right) :
+    TypeGuard.IsTuple(right) ? FromTupleRight(left, right) :
+    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+    TypeGuard.IsUnknown(right) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// ------------------------------------------------------------------
+// Void
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromVoidRight(left: TSchema, right: TVoid) {
+  return (
+    TypeGuard.IsUndefined(left) ? ExtendsResult.True :
+    TypeGuard.IsUndefined(left) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// prettier-ignore
+function FromVoid(left: TVoid, right: TSchema) {
+  return (
+    TypeGuard.IsIntersect(right) ? FromIntersectRight(left, right) :
+    TypeGuard.IsUnion(right) ? FromUnionRight(left, right) :
+    TypeGuard.IsUnknown(right) ? FromUnknownRight(left, right) :
+    TypeGuard.IsAny(right) ? FromAnyRight(left, right) :
+    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+    TypeGuard.IsVoid(right) ? ExtendsResult.True :
+    ExtendsResult.False
+  )
+}
+// prettier-ignore
+function Visit(left: TSchema, right: TSchema): ExtendsResult {
+  return (
+    // resolvable
+    (TypeGuard.IsTemplateLiteral(left) || TypeGuard.IsTemplateLiteral(right)) ? FromTemplateLiteral(left, right) :
+    (TypeGuard.IsRegExp(left) || TypeGuard.IsRegExp(right)) ? FromRegExp(left, right) :
+    (TypeGuard.IsNot(left) || TypeGuard.IsNot(right)) ? FromNot(left, right) :
+    // standard
+    TypeGuard.IsAny(left) ? FromAny(left, right) :
+    TypeGuard.IsArray(left) ? FromArray(left, right) :
+    TypeGuard.IsBigInt(left) ? FromBigInt(left, right) :
+    TypeGuard.IsBoolean(left) ? FromBoolean(left, right) :
+    TypeGuard.IsAsyncIterator(left) ? FromAsyncIterator(left, right) :
+    TypeGuard.IsConstructor(left) ? FromConstructor(left, right) :
+    TypeGuard.IsDate(left) ? FromDate(left, right) :
+    TypeGuard.IsFunction(left) ? FromFunction(left, right) :
+    TypeGuard.IsInteger(left) ? FromInteger(left, right) :
+    TypeGuard.IsIntersect(left) ? FromIntersect(left, right) :
+    TypeGuard.IsIterator(left) ? FromIterator(left, right) :
+    TypeGuard.IsLiteral(left) ? FromLiteral(left, right) :
+    TypeGuard.IsNever(left) ? FromNever(left, right) :
+    TypeGuard.IsNull(left) ? FromNull(left, right) :
+    TypeGuard.IsNumber(left) ? FromNumber(left, right) :
+    TypeGuard.IsObject(left) ? FromObject(left, right) :
+    TypeGuard.IsRecord(left) ? FromRecord(left, right) :
+    TypeGuard.IsString(left) ? FromString(left, right) :
+    TypeGuard.IsSymbol(left) ? FromSymbol(left, right) :
+    TypeGuard.IsTuple(left) ? FromTuple(left, right) :
+    TypeGuard.IsPromise(left) ? FromPromise(left, right) :
+    TypeGuard.IsUint8Array(left) ? FromUint8Array(left, right) :
+    TypeGuard.IsUndefined(left) ? FromUndefined(left, right) :
+    TypeGuard.IsUnion(left) ? FromUnion(left, right) :
+    TypeGuard.IsUnknown(left) ? FromUnknown(left, right) :
+    TypeGuard.IsVoid(left) ? FromVoid(left, right) :
+    Throw(`Unknown left type operand '${left[Kind]}'`)
+  )
+}
+export function ExtendsCheck(left: TSchema, right: TSchema): ExtendsResult {
+  return Visit(left, right)
+}
diff --git a/src/type/extends/extends-from-mapped-key.ts b/src/type/extends/extends-from-mapped-key.ts
new file mode 100644
index 000000000..acc955ee5
--- /dev/null
+++ b/src/type/extends/extends-from-mapped-key.ts
@@ -0,0 +1,129 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { TProperties } from '../object/index'
+import type { Assert } from '../helpers/index'
+import { MappedResult, type TMappedResult, type TMappedKey } from '../mapped/index'
+import { Literal, type TLiteral, type TLiteralValue } from '../literal/index'
+import { Extends, type TExtends } from './extends'
+
+// ------------------------------------------------------------------
+// FromPropertyKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromPropertyKey<
+  K extends PropertyKey,
+  U extends TSchema,
+  L extends TSchema,
+  R extends TSchema
+> = {
+    [_ in K]: TExtends<TLiteral<Assert<K, TLiteralValue>>, U, L, R>
+  }
+// prettier-ignore
+function FromPropertyKey<
+  K extends PropertyKey,
+  U extends TSchema,
+  L extends TSchema,
+  R extends TSchema
+>(K: K, U: U, L: L, R: R, options: SchemaOptions): TFromPropertyKey<K, U, L, R> {
+  return {
+    [K]: Extends(Literal(K as TLiteralValue), U, L, R, options) as any
+  } as TFromPropertyKey<K, U, L, R>
+}
+// ------------------------------------------------------------------
+// FromPropertyKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromPropertyKeys<
+  K extends PropertyKey[],
+  U extends TSchema,
+  L extends TSchema,
+  R extends TSchema,
+  Acc extends TProperties = {}
+> = (
+  K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]]
+    ? TFromPropertyKeys<RK, U, L, R, Acc & TFromPropertyKey<LK, U, L, R>>
+    : Acc
+)
+// prettier-ignore
+function FromPropertyKeys<
+  K extends PropertyKey[],
+  U extends TSchema,
+  L extends TSchema,
+  R extends TSchema
+>(K: [...K], U: U, L: L, R: R, options: SchemaOptions): TFromPropertyKeys<K, U, L, R> {
+  return K.reduce((Acc, LK) => {
+    return { ...Acc, ...FromPropertyKey(LK, U, L, R, options) }
+  }, {} as TProperties) as TFromPropertyKeys<K, U, L, R> 
+}
+// ------------------------------------------------------------------
+// FromMappedKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromMappedKey<
+  K extends TMappedKey,
+  U extends TSchema,
+  L extends TSchema,
+  R extends TSchema
+> = (
+    TFromPropertyKeys<K['keys'], U, L, R>
+  )
+// prettier-ignore
+function FromMappedKey<
+  K extends TMappedKey,
+  U extends TSchema,
+  L extends TSchema,
+  R extends TSchema
+>(K: K, U: U, L: L, R: R, options: SchemaOptions): TFromMappedKey<K, U, L, R> {
+  return FromPropertyKeys(K.keys, U, L, R, options) as TFromMappedKey<K, U, L, R>
+}
+// ------------------------------------------------------------------
+// ExtendsFromMappedKey
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TExtendsFromMappedKey<
+  T extends TMappedKey,
+  U extends TSchema,
+  L extends TSchema,
+  R extends TSchema,
+  P extends TProperties = TFromMappedKey<T, U, L, R>
+> = (
+  TMappedResult<P>
+)
+// prettier-ignore
+export function ExtendsFromMappedKey<
+  T extends TMappedKey,
+  U extends TSchema,
+  L extends TSchema,
+  R extends TSchema,
+  P extends TProperties = TFromMappedKey<T, U, L, R>
+>(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P> {
+  const P = FromMappedKey(T, U, L, R, options) as unknown as P
+  return MappedResult(P) 
+}
diff --git a/src/type/extends/extends-from-mapped-result.ts b/src/type/extends/extends-from-mapped-result.ts
new file mode 100644
index 000000000..d34c5dc80
--- /dev/null
+++ b/src/type/extends/extends-from-mapped-result.ts
@@ -0,0 +1,101 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { TProperties } from '../object/index'
+import { MappedResult, type TMappedResult } from '../mapped/index'
+import { Extends, type TExtends } from './extends'
+
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperties<
+  P extends TProperties,
+  Right extends TSchema,
+  False extends TSchema,
+  True extends TSchema
+> = (
+  { [K2 in keyof P]: TExtends<P[K2], Right, False, True> }   
+)
+// prettier-ignore
+function FromProperties<
+  P extends TProperties,
+  Right extends TSchema,
+  True extends TSchema,
+  False extends TSchema
+>(P: P, Right: Right, True: True, False: False, options: SchemaOptions): TFromProperties<P, Right, True, False> {
+  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+    return {...Acc, [K2]: Extends(P[K2], Right, True, False, options) }
+  }, {}) as TFromProperties<P, Right, True, False>
+}
+// ------------------------------------------------------------------
+// FromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromMappedResult<
+  Left extends TMappedResult,
+  Right extends TSchema,
+  True extends TSchema,
+  False extends TSchema
+> = (
+  TFromProperties<Left['properties'], Right, True, False>
+)
+// prettier-ignore
+function FromMappedResult<
+  Left extends TMappedResult,
+  Right extends TSchema,
+  True extends TSchema,
+  False extends TSchema
+>(Left: Left, Right: Right, True: True, False: False, options: SchemaOptions): TFromMappedResult<Left, Right, True, False> {
+  return FromProperties(Left.properties, Right, True, False, options) as TFromMappedResult<Left, Right, True, False>
+}
+// ------------------------------------------------------------------
+// ExtendsFromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TExtendsFromMappedResult<
+  Left extends TMappedResult,
+  Right extends TSchema,
+  True extends TSchema,
+  False extends TSchema,
+  P extends TProperties = TFromMappedResult<Left, Right, True, False>
+> = (
+  TMappedResult<P>
+)
+// prettier-ignore
+export function ExtendsFromMappedResult<
+  Left extends TMappedResult,
+  Right extends TSchema,
+  True extends TSchema,
+  False extends TSchema,
+  P extends TProperties = TFromMappedResult<Left, Right, True, False>
+>(Left: Left, Right: Right, True: True, False: False, options: SchemaOptions): TMappedResult<P> {
+  const P = FromMappedResult(Left, Right, True, False, options) as unknown as P
+  return MappedResult(P) 
+}
diff --git a/src/type/extends/extends-undefined.ts b/src/type/extends/extends-undefined.ts
new file mode 100644
index 000000000..f6c275c6a
--- /dev/null
+++ b/src/type/extends/extends-undefined.ts
@@ -0,0 +1,55 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import type { TIntersect } from '../intersect/index'
+import type { TUnion } from '../union/index'
+import type { TNot } from '../not/index'
+import { Kind } from '../symbols/index'
+
+/** Fast undefined check used for properties of type undefined */
+function Intersect(schema: TIntersect) {
+  return schema.allOf.every((schema) => ExtendsUndefinedCheck(schema))
+}
+function Union(schema: TUnion) {
+  return schema.anyOf.some((schema) => ExtendsUndefinedCheck(schema))
+}
+function Not(schema: TNot) {
+  return !ExtendsUndefinedCheck(schema.not)
+}
+/** Fast undefined check used for properties of type undefined */
+// prettier-ignore
+export function ExtendsUndefinedCheck(schema: TSchema): boolean {
+  return (
+    schema[Kind] === 'Intersect' ? Intersect(schema as TIntersect) :
+    schema[Kind] === 'Union' ? Union(schema as TUnion) :
+    schema[Kind] === 'Not' ? Not(schema as TNot) :
+    schema[Kind] === 'Undefined' ? true :
+    false
+  )
+}
diff --git a/src/type/extends/extends.ts b/src/type/extends/extends.ts
new file mode 100644
index 000000000..e91a9d629
--- /dev/null
+++ b/src/type/extends/extends.ts
@@ -0,0 +1,80 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Static } from '../static/index'
+import { type TUnion, Union } from '../union/index'
+import { TMappedKey, TMappedResult } from '../mapped/index'
+import { ExtendsCheck, ExtendsResult } from './extends-check'
+import { UnionToTuple } from '../helpers/index'
+import { CloneType } from '../clone/type'
+import { ExtendsFromMappedKey, type TExtendsFromMappedKey } from './extends-from-mapped-key'
+import { ExtendsFromMappedResult, type TExtendsFromMappedResult } from './extends-from-mapped-result'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsMappedKey, IsMappedResult } from '../guard/type'
+
+// prettier-ignore
+type TExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = (
+  (Static<L> extends Static<R> ? T : U) extends infer O extends TSchema ?
+    UnionToTuple<O> extends [infer X extends TSchema, infer Y extends TSchema]
+    ? TUnion<[X, Y]>
+    : O
+    : never
+)
+// prettier-ignore
+function ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U): TExtendsResolve<L, R, T, U> {
+  const R = ExtendsCheck(left, right)
+  return (
+    R === ExtendsResult.Union ? Union([trueType, falseType]) : 
+    R === ExtendsResult.True ? trueType : 
+    falseType
+  ) as unknown as TExtendsResolve<L, R, T, U>
+}
+// ------------------------------------------------------------------
+// TExtends
+// ------------------------------------------------------------------
+export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema> = TExtendsResolve<L, R, T, F>
+
+/** `[Json]` Creates a Conditional type */
+export function Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedResult<L, R, T, F>
+/** `[Json]` Creates a Conditional type */
+export function Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedKey<L, R, T, F>
+/** `[Json]` Creates a Conditional type */
+export function Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>
+/** `[Json]` Creates a Conditional type */
+export function Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options: SchemaOptions = {}) {
+  // prettier-ignore
+  return (
+    IsMappedResult(L) ? ExtendsFromMappedResult(L, R, T, F, options) :
+    IsMappedKey(L) ? CloneType(ExtendsFromMappedKey(L, R, T, F, options)) :
+    CloneType(ExtendsResolve(L, R, T, F), options)
+  ) as TExtends<L, R, T, F>
+}
diff --git a/src/type/extends/index.ts b/src/type/extends/index.ts
new file mode 100644
index 000000000..330381d55
--- /dev/null
+++ b/src/type/extends/index.ts
@@ -0,0 +1,33 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './extends-check'
+export * from './extends-from-mapped-key'
+export * from './extends-from-mapped-result'
+export * from './extends-undefined'
+export * from './extends'
diff --git a/src/type/extract/extract-from-mapped-result.ts b/src/type/extract/extract-from-mapped-result.ts
new file mode 100644
index 000000000..96191929c
--- /dev/null
+++ b/src/type/extract/extract-from-mapped-result.ts
@@ -0,0 +1,89 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { TProperties } from '../object/index'
+import { MappedResult, type TMappedResult } from '../mapped/index'
+import { Extract, type TExtract } from './extract'
+
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperties<
+  P extends TProperties,
+  T extends TSchema
+> = (
+  { [K2 in keyof P]: TExtract<P[K2], T> }   
+)
+// prettier-ignore
+function FromProperties<
+  P extends TProperties,
+  T extends TSchema
+>(P: P, T: T, options: SchemaOptions): TFromProperties<P, T> {
+  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+    return {...Acc, [K2]: Extract(P[K2], T, options) }
+  }, {}) as TFromProperties<P, T>
+}
+// ------------------------------------------------------------------
+// FromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromMappedResult<
+  R extends TMappedResult,
+  T extends TSchema
+> = (
+  TFromProperties<R['properties'], T>
+)
+// prettier-ignore
+function FromMappedResult<
+  R extends TMappedResult,
+  T extends TSchema
+>(R: R, T: T, options: SchemaOptions): TFromMappedResult<R, T> {
+  return FromProperties(R.properties, T, options) as TFromMappedResult<R, T>
+}
+// ------------------------------------------------------------------
+// ExtractFromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TExtractFromMappedResult<
+  R extends TMappedResult,
+  T extends TSchema,
+  P extends TProperties = TFromMappedResult<R, T>
+> = (
+  TMappedResult<P>
+)
+// prettier-ignore
+export function ExtractFromMappedResult<
+  R extends TMappedResult,
+  T extends TSchema,
+  P extends TProperties = TFromMappedResult<R, T>
+>(R: R, T: T, options: SchemaOptions): TMappedResult<P> {
+  const P = FromMappedResult(R, T, options) as unknown as P
+  return MappedResult(P) 
+}
diff --git a/src/type/extract/extract.ts b/src/type/extract/extract.ts
new file mode 100644
index 000000000..2ef499831
--- /dev/null
+++ b/src/type/extract/extract.ts
@@ -0,0 +1,94 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Assert, AssertRest, AssertType, UnionToTuple } from '../helpers/index'
+import type { TMappedResult } from '../mapped/index'
+import { TemplateLiteralToUnion, type TTemplateLiteral } from '../template-literal/index'
+import { type TLiteral } from '../literal/index'
+import { Union, type TUnion } from '../union/index'
+import { type Static } from '../static/index'
+import { Never } from '../never/index'
+import { type TUnionEvaluated } from '../union/index'
+import { ExtendsCheck, ExtendsResult } from '../extends/index'
+import { CloneType } from '../clone/type'
+import { ExtractFromMappedResult, type TExtractFromMappedResult } from './extract-from-mapped-result'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/type'
+// ------------------------------------------------------------------
+// ExtractResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
+// prettier-ignore
+type TFromTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? TFromTemplateLiteralResult<Assert<S, string>> : never
+// prettier-ignore
+type TFromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<
+  { [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? T[K] : never
+}[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never
+// prettier-ignore
+type TExtractResolve<T extends TSchema, U extends TSchema> = (
+  T extends TTemplateLiteral ? TFromTemplateLiteral<T, U> :
+  T extends TUnion<infer S> ? TFromArray<S, U> :
+  T
+)
+// prettier-ignore
+function ExtractResolve<L extends TSchema, R extends TSchema>(L: L, R: R): TExtractResolve<L, R> {
+  return (
+    IsTemplateLiteral(L)  ? ExtractResolve(TemplateLiteralToUnion(L), R) :
+    IsTemplateLiteral(R) ? ExtractResolve(L, TemplateLiteralToUnion(R) as any) :
+    IsUnion(L) ? (() => {
+      const narrowed = L.anyOf.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False)
+      return (narrowed.length === 1 ? narrowed[0] : Union(narrowed))
+    })() :
+      ExtendsCheck(L, R) !== ExtendsResult.False ? L :
+      Never()
+  ) as TExtractResolve<L, R>
+}
+// ------------------------------------------------------------------
+// TExtract
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TExtract<T extends TSchema, U extends TSchema> = TExtractResolve<T, U>
+
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+export function Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+export function Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+export function Extract(type: TSchema, union: TSchema, options: SchemaOptions = {}) {
+  if (IsMappedResult(type)) {
+    return ExtractFromMappedResult(type, union, options)
+  } else {
+    const E = ExtractResolve(type, union)
+    return CloneType(E, options)
+  }
+}
diff --git a/src/type/extract/index.ts b/src/type/extract/index.ts
new file mode 100644
index 000000000..3fd310772
--- /dev/null
+++ b/src/type/extract/index.ts
@@ -0,0 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './extract-from-mapped-result'
+export * from './extract'
diff --git a/src/type/function/function.ts b/src/type/function/function.ts
new file mode 100644
index 000000000..7c97429a4
--- /dev/null
+++ b/src/type/function/function.ts
@@ -0,0 +1,67 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Static } from '../static/index'
+import type { Ensure } from '../helpers/index'
+import { CloneType, CloneRest } from '../clone/type'
+import { Kind } from '../symbols/index'
+
+// ------------------------------------------------------------------
+// FunctionStatic
+// ------------------------------------------------------------------
+type FunctionStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>
+// prettier-ignore
+type FunctionStaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = 
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? FunctionStaticParameters<R, P, [...Acc, Static<L, P>]>
+    : Acc
+// prettier-ignore
+type FunctionStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (
+  Ensure<(...param: FunctionStaticParameters<T, P>) => FunctionStaticReturnType<U, P>>
+)
+// ------------------------------------------------------------------
+// TFunction
+// ------------------------------------------------------------------
+export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'Function'
+  static: FunctionStatic<T, U, this['params']>
+  type: 'Function'
+  parameters: T
+  returns: U
+}
+/** `[JavaScript]` Creates a Function type */
+export function Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U> {
+  return {
+    ...options,
+    [Kind]: 'Function',
+    type: 'Function',
+    parameters: CloneRest(parameters),
+    returns: CloneType(returns),
+  } as unknown as TFunction<T, U>
+}
diff --git a/src/type/function/index.ts b/src/type/function/index.ts
new file mode 100644
index 000000000..3399c7270
--- /dev/null
+++ b/src/type/function/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './function'
diff --git a/src/type/guard/index.ts b/src/type/guard/index.ts
new file mode 100644
index 000000000..2e7cc05ad
--- /dev/null
+++ b/src/type/guard/index.ts
@@ -0,0 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * as TypeGuard from './type'
+export * as ValueGuard from './value'
diff --git a/src/type/guard/type.ts b/src/type/guard/type.ts
new file mode 100644
index 000000000..9794a4fcb
--- /dev/null
+++ b/src/type/guard/type.ts
@@ -0,0 +1,618 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as ValueGuard from './value'
+import { Kind, Hint, TransformKind, ReadonlyKind, OptionalKind } from '../symbols/index'
+import { TypeBoxError } from '../error/index'
+import { TransformOptions } from '../transform/index'
+import { TTemplateLiteral, TTemplateLiteralKind } from '../template-literal/index'
+import { TArray } from '../array/index'
+import { TBoolean } from '../boolean/index'
+import type { TRecord } from '../record/index'
+import type { TString } from '../string/index'
+import type { TUnion } from '../union/index'
+import type { TAny } from '../any/index'
+import type { TAsyncIterator } from '../async-iterator/index'
+import type { TBigInt } from '../bigint/index'
+import type { TConstructor } from '../constructor/index'
+import type { TFunction } from '../function/index'
+import type { TInteger } from '../integer/index'
+import type { TIntersect } from '../intersect/index'
+import type { TIterator } from '../iterator/index'
+import type { TLiteral, TLiteralValue } from '../literal/index'
+import type { TMappedKey, TMappedResult } from '../mapped/index'
+import type { TNever } from '../never/index'
+import type { TNot } from '../not/index'
+import type { TNull } from '../null/index'
+import type { TNumber } from '../number/index'
+import type { TObject, TAdditionalProperties, TProperties } from '../object/index'
+import type { TOptional } from '../optional/index'
+import type { TPromise } from '../promise/index'
+import type { TReadonly } from '../readonly/index'
+import type { TRef } from '../ref/index'
+import type { TRegExp } from '../regexp/index'
+import type { TSchema } from '../schema/index'
+import type { TSymbol } from '../symbol/index'
+import type { TTuple } from '../tuple/index'
+import type { TUint8Array } from '../uint8array/index'
+import type { TUndefined } from '../undefined/index'
+import type { TUnknown } from '../unknown/index'
+import type { TUnsafe } from '../unsafe/index'
+import type { TVoid } from '../void/index'
+import type { TDate } from '../date/index'
+import type { TThis } from '../recursive/index'
+
+export class TypeGuardUnknownTypeError extends TypeBoxError {}
+
+const KnownTypes = [
+  'Any',
+  'Array',
+  'AsyncIterator',
+  'BigInt',
+  'Boolean',
+  'Constructor',
+  'Date',
+  'Enum',
+  'Function',
+  'Integer',
+  'Intersect',
+  'Iterator',
+  'Literal',
+  'MappedKey',
+  'MappedResult',
+  'Not',
+  'Null',
+  'Number',
+  'Object',
+  'Promise',
+  'Record',
+  'Ref',
+  'RegExp',
+  'String',
+  'Symbol',
+  'TemplateLiteral',
+  'This',
+  'Tuple',
+  'Undefined',
+  'Union',
+  'Uint8Array',
+  'Unknown',
+  'Void',
+]
+function IsPattern(value: unknown): value is string {
+  try {
+    new RegExp(value as string)
+    return true
+  } catch {
+    return false
+  }
+}
+function IsControlCharacterFree(value: unknown): value is string {
+  if (!ValueGuard.IsString(value)) return false
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i)
+    if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
+      return false
+    }
+  }
+  return true
+}
+function IsAdditionalProperties(value: unknown): value is TAdditionalProperties {
+  return IsOptionalBoolean(value) || IsSchema(value)
+}
+function IsOptionalBigInt(value: unknown): value is bigint | undefined {
+  return ValueGuard.IsUndefined(value) || ValueGuard.IsBigInt(value)
+}
+function IsOptionalNumber(value: unknown): value is number | undefined {
+  return ValueGuard.IsUndefined(value) || ValueGuard.IsNumber(value)
+}
+function IsOptionalBoolean(value: unknown): value is boolean | undefined {
+  return ValueGuard.IsUndefined(value) || ValueGuard.IsBoolean(value)
+}
+function IsOptionalString(value: unknown): value is string | undefined {
+  return ValueGuard.IsUndefined(value) || ValueGuard.IsString(value)
+}
+function IsOptionalPattern(value: unknown): value is string | undefined {
+  return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value) && IsPattern(value))
+}
+function IsOptionalFormat(value: unknown): value is string | undefined {
+  return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value))
+}
+function IsOptionalSchema(value: unknown): value is boolean | undefined {
+  return ValueGuard.IsUndefined(value) || IsSchema(value)
+}
+// ------------------------------------------------------------------
+// Modifiers
+// ------------------------------------------------------------------
+/** Returns true if this value has a Readonly symbol */
+export function IsReadonly<T extends TSchema>(value: T): value is TReadonly<T> {
+  return ValueGuard.IsObject(value) && value[ReadonlyKind] === 'Readonly'
+}
+/** Returns true if this value has a Optional symbol */
+export function IsOptional<T extends TSchema>(value: T): value is TOptional<T> {
+  return ValueGuard.IsObject(value) && value[OptionalKind] === 'Optional'
+}
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+/** Returns true if the given value is TAny */
+export function IsAny(value: unknown): value is TAny {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Any') &&
+    IsOptionalString(value.$id)
+  )
+}
+/** Returns true if the given value is TArray */
+export function IsArray(value: unknown): value is TArray {
+  return (
+    IsKindOf(value, 'Array') &&
+    value.type === 'array' &&
+    IsOptionalString(value.$id) &&
+    IsSchema(value.items) &&
+    IsOptionalNumber(value.minItems) &&
+    IsOptionalNumber(value.maxItems) &&
+    IsOptionalBoolean(value.uniqueItems) &&
+    IsOptionalSchema(value.contains) &&
+    IsOptionalNumber(value.minContains) &&
+    IsOptionalNumber(value.maxContains)
+  )
+}
+/** Returns true if the given value is TAsyncIterator */
+export function IsAsyncIterator(value: unknown): value is TAsyncIterator {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'AsyncIterator') &&
+    value.type === 'AsyncIterator' &&
+    IsOptionalString(value.$id) &&
+    IsSchema(value.items)
+  )
+}
+/** Returns true if the given value is TBigInt */
+export function IsBigInt(value: unknown): value is TBigInt {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'BigInt') &&
+    value.type === 'bigint' &&
+    IsOptionalString(value.$id) &&
+    IsOptionalBigInt(value.exclusiveMaximum) &&
+    IsOptionalBigInt(value.exclusiveMinimum) &&
+    IsOptionalBigInt(value.maximum) &&
+    IsOptionalBigInt(value.minimum) &&
+    IsOptionalBigInt(value.multipleOf)
+  )
+}
+/** Returns true if the given value is TBoolean */
+export function IsBoolean(value: unknown): value is TBoolean {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Boolean') &&
+    value.type === 'boolean' &&
+    IsOptionalString(value.$id)
+  )
+}
+/** Returns true if the given value is TConstructor */
+export function IsConstructor(value: unknown): value is TConstructor {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Constructor') &&
+    value.type === 'Constructor' &&
+    IsOptionalString(value.$id) &&
+    ValueGuard.IsArray(value.parameters) &&
+    value.parameters.every(schema => IsSchema(schema)) &&
+    IsSchema(value.returns)
+  )
+}
+/** Returns true if the given value is TDate */
+export function IsDate(value: unknown): value is TDate {
+  return (
+    IsKindOf(value, 'Date') &&
+    value.type === 'Date' &&
+    IsOptionalString(value.$id) &&
+    IsOptionalNumber(value.exclusiveMaximumTimestamp) &&
+    IsOptionalNumber(value.exclusiveMinimumTimestamp) &&
+    IsOptionalNumber(value.maximumTimestamp) &&
+    IsOptionalNumber(value.minimumTimestamp) &&
+    IsOptionalNumber(value.multipleOfTimestamp)
+  )
+}
+/** Returns true if the given value is TFunction */
+export function IsFunction(value: unknown): value is TFunction {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Function') &&
+    value.type === 'Function' &&
+    IsOptionalString(value.$id) &&
+    ValueGuard.IsArray(value.parameters) &&
+    value.parameters.every(schema => IsSchema(schema)) &&
+    IsSchema(value.returns)
+  )
+}
+/** Returns true if the given value is TInteger */
+export function IsInteger(value: unknown): value is TInteger {
+  return (
+    IsKindOf(value, 'Integer') &&
+    value.type === 'integer' &&
+    IsOptionalString(value.$id) &&
+    IsOptionalNumber(value.exclusiveMaximum) &&
+    IsOptionalNumber(value.exclusiveMinimum) &&
+    IsOptionalNumber(value.maximum) &&
+    IsOptionalNumber(value.minimum) &&
+    IsOptionalNumber(value.multipleOf)
+  )
+}
+/** Returns true if the given schema is TProperties */
+export function IsProperties(value: unknown): value is TProperties {
+  // prettier-ignore
+  return (
+    ValueGuard.IsObject(value) && 
+    Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema(schema))
+  )
+}
+/** Returns true if the given value is TIntersect */
+export function IsIntersect(value: unknown): value is TIntersect {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Intersect') &&
+    (ValueGuard.IsString(value.type) && value.type !== 'object' ? false : true) &&
+    ValueGuard.IsArray(value.allOf) &&
+    value.allOf.every(schema => IsSchema(schema) && !IsTransform(schema)) &&
+    IsOptionalString(value.type) &&
+    (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) &&
+    IsOptionalString(value.$id)
+  )
+}
+/** Returns true if the given value is TIterator */
+export function IsIterator(value: unknown): value is TIterator {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Iterator') &&
+    value.type === 'Iterator' &&
+    IsOptionalString(value.$id) &&
+    IsSchema(value.items)
+  )
+}
+/** Returns true if the given value is a TKind with the given name. */
+export function IsKindOf<T extends string>(value: unknown, kind: T): value is Record<PropertyKey, unknown> & { [Kind]: T } {
+  return ValueGuard.IsObject(value) && Kind in value && value[Kind] === kind
+}
+/** Returns true if the given value is TLiteral<string> */
+export function IsLiteralString(value: unknown): value is TLiteral<string> {
+  return IsLiteral(value) && ValueGuard.IsString(value.const)
+}
+/** Returns true if the given value is TLiteral<number> */
+export function IsLiteralNumber(value: unknown): value is TLiteral<number> {
+  return IsLiteral(value) && ValueGuard.IsNumber(value.const)
+}
+/** Returns true if the given value is TLiteral<boolean> */
+export function IsLiteralBoolean(value: unknown): value is TLiteral<boolean> {
+  return IsLiteral(value) && ValueGuard.IsBoolean(value.const)
+}
+/** Returns true if the given value is TLiteral */
+export function IsLiteral(value: unknown): value is TLiteral {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Literal') &&
+    IsOptionalString(value.$id) && IsLiteralValue(value.const)
+  )
+}
+/** Returns true if the given value is a TLiteralValue */
+export function IsLiteralValue(value: unknown): value is TLiteralValue {
+  return ValueGuard.IsBoolean(value) || ValueGuard.IsNumber(value) || ValueGuard.IsString(value)
+}
+/** Returns true if the given value is a TMappedKey */
+export function IsMappedKey(value: unknown): value is TMappedKey {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'MappedKey') &&
+    ValueGuard.IsArray(value.keys) &&
+    value.keys.every(key => ValueGuard.IsNumber(key) || ValueGuard.IsString(key))
+  )
+}
+/** Returns true if the given value is TMappedResult */
+export function IsMappedResult(value: unknown): value is TMappedResult {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'MappedResult') && 
+    IsProperties(value.properties)
+  )
+}
+/** Returns true if the given value is TNever */
+export function IsNever(value: unknown): value is TNever {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Never') &&
+    ValueGuard.IsObject(value.not) &&
+    Object.getOwnPropertyNames(value.not).length === 0
+  )
+}
+/** Returns true if the given value is TNot */
+export function IsNot(value: unknown): value is TNot {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Not') &&
+    IsSchema(value.not)
+  )
+}
+/** Returns true if the given value is TNull */
+export function IsNull(value: unknown): value is TNull {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Null') &&
+    value.type === 'null' &&
+    IsOptionalString(value.$id)
+  )
+}
+/** Returns true if the given value is TNumber */
+export function IsNumber(value: unknown): value is TNumber {
+  return (
+    IsKindOf(value, 'Number') &&
+    value.type === 'number' &&
+    IsOptionalString(value.$id) &&
+    IsOptionalNumber(value.exclusiveMaximum) &&
+    IsOptionalNumber(value.exclusiveMinimum) &&
+    IsOptionalNumber(value.maximum) &&
+    IsOptionalNumber(value.minimum) &&
+    IsOptionalNumber(value.multipleOf)
+  )
+}
+/** Returns true if the given value is TObject */
+export function IsObject(value: unknown): value is TObject {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Object') &&
+    value.type === 'object' &&
+    IsOptionalString(value.$id) &&
+    IsProperties(value.properties) &&
+    IsAdditionalProperties(value.additionalProperties) &&
+    IsOptionalNumber(value.minProperties) &&
+    IsOptionalNumber(value.maxProperties)
+  )
+}
+/** Returns true if the given value is TPromise */
+export function IsPromise(value: unknown): value is TPromise {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Promise') &&
+    value.type === 'Promise' &&
+    IsOptionalString(value.$id) &&
+    IsSchema(value.item)
+  )
+}
+/** Returns true if the given value is TRecord */
+export function IsRecord(value: unknown): value is TRecord {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Record') &&
+    value.type === 'object' &&
+    IsOptionalString(value.$id) &&
+    IsAdditionalProperties(value.additionalProperties) &&
+    ValueGuard.IsObject(value.patternProperties) &&
+    ((schema: Record<PropertyKey, unknown>) => {
+      const keys = Object.getOwnPropertyNames(schema.patternProperties)
+      return (
+        keys.length === 1 &&
+        IsPattern(keys[0]) &&
+        ValueGuard.IsObject(schema.patternProperties) &&
+        IsSchema(schema.patternProperties[keys[0]])
+      )
+    })(value)
+  )
+}
+/** Returns true if this value is TRecursive */
+export function IsRecursive(value: unknown): value is { [Hint]: 'Recursive' } {
+  return ValueGuard.IsObject(value) && Hint in value && value[Hint] === 'Recursive'
+}
+/** Returns true if the given value is TRef */
+export function IsRef(value: unknown): value is TRef {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Ref') &&
+    IsOptionalString(value.$id) &&
+    ValueGuard.IsString(value.$ref)
+  )
+}
+/** Returns true if the given value is TRegExp */
+export function IsRegExp(value: unknown): value is TRegExp {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'RegExp') &&
+    IsOptionalString(value.$id) &&
+    ValueGuard.IsString(value.source) &&
+    ValueGuard.IsString(value.flags)
+  )
+}
+/** Returns true if the given value is TString */
+export function IsString(value: unknown): value is TString {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'String') &&
+    value.type === 'string' &&
+    IsOptionalString(value.$id) &&
+    IsOptionalNumber(value.minLength) &&
+    IsOptionalNumber(value.maxLength) &&
+    IsOptionalPattern(value.pattern) &&
+    IsOptionalFormat(value.format)
+  )
+}
+/** Returns true if the given value is TSymbol */
+export function IsSymbol(value: unknown): value is TSymbol {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Symbol') &&
+    value.type === 'symbol' &&
+    IsOptionalString(value.$id)
+  )
+}
+/** Returns true if the given value is TTemplateLiteral */
+export function IsTemplateLiteral(value: unknown): value is TTemplateLiteral<TTemplateLiteralKind[]> {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'TemplateLiteral') &&
+    value.type === 'string' &&
+    ValueGuard.IsString(value.pattern) &&
+    value.pattern[0] === '^' &&
+    value.pattern[value.pattern.length - 1] === '$'
+  )
+}
+/** Returns true if the given value is TThis */
+export function IsThis(value: unknown): value is TThis {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'This') &&
+    IsOptionalString(value.$id) &&
+    ValueGuard.IsString(value.$ref)
+  )
+}
+/** Returns true of this value is TTransform */
+export function IsTransform(value: unknown): value is { [TransformKind]: TransformOptions } {
+  return ValueGuard.IsObject(value) && TransformKind in value
+}
+/** Returns true if the given value is TTuple */
+export function IsTuple(value: unknown): value is TTuple {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Tuple') &&
+    value.type === 'array' &&
+    IsOptionalString(value.$id) &&
+    ValueGuard.IsNumber(value.minItems) &&
+    ValueGuard.IsNumber(value.maxItems) &&
+    value.minItems === value.maxItems &&
+    (( // empty
+      ValueGuard.IsUndefined(value.items) &&
+      ValueGuard.IsUndefined(value.additionalItems) &&
+      value.minItems === 0
+    ) || (
+        ValueGuard.IsArray(value.items) &&
+        value.items.every(schema => IsSchema(schema))
+      ))
+  )
+}
+/** Returns true if the given value is TUndefined */
+export function IsUndefined(value: unknown): value is TUndefined {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Undefined') &&
+    value.type === 'undefined' &&
+    IsOptionalString(value.$id)
+  )
+}
+/** Returns true if the given value is TUnion<Literal<string | number>[]> */
+export function IsUnionLiteral(value: unknown): value is TUnion<TLiteral[]> {
+  return IsUnion(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema))
+}
+/** Returns true if the given value is TUnion */
+export function IsUnion(value: unknown): value is TUnion {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Union') &&
+    IsOptionalString(value.$id) &&
+    ValueGuard.IsObject(value) &&
+    ValueGuard.IsArray(value.anyOf) &&
+    value.anyOf.every(schema => IsSchema(schema))
+  )
+}
+/** Returns true if the given value is TUint8Array */
+export function IsUint8Array(value: unknown): value is TUint8Array {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Uint8Array') &&
+    value.type === 'Uint8Array' &&
+    IsOptionalString(value.$id) &&
+    IsOptionalNumber(value.minByteLength) &&
+    IsOptionalNumber(value.maxByteLength)
+  )
+}
+/** Returns true if the given value is TUnknown */
+export function IsUnknown(value: unknown): value is TUnknown {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Unknown') &&
+    IsOptionalString(value.$id)
+  )
+}
+/** Returns true if the given value is a raw TUnsafe */
+export function IsUnsafe(value: unknown): value is TUnsafe<unknown> {
+  return IsKindOf(value, 'Unsafe')
+}
+/** Returns true if the given value is TVoid */
+export function IsVoid(value: unknown): value is TVoid {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Void') &&
+    value.type === 'void' &&
+    IsOptionalString(value.$id)
+  )
+}
+/** Returns true if the given value is TKind */
+export function IsKind(value: unknown): value is Record<PropertyKey, unknown> & { [Kind]: string } {
+  return ValueGuard.IsObject(value) && Kind in value && ValueGuard.IsString(value[Kind]) && !KnownTypes.includes(value[Kind] as string)
+}
+/** Returns true if the given value is TSchema */
+export function IsSchema(value: unknown): value is TSchema {
+  // prettier-ignore
+  return (
+    ValueGuard.IsObject(value)
+  ) && (
+      IsAny(value) ||
+      IsArray(value) ||
+      IsBoolean(value) ||
+      IsBigInt(value) ||
+      IsAsyncIterator(value) ||
+      IsConstructor(value) ||
+      IsDate(value) ||
+      IsFunction(value) ||
+      IsInteger(value) ||
+      IsIntersect(value) ||
+      IsIterator(value) ||
+      IsLiteral(value) ||
+      IsMappedKey(value) ||
+      IsMappedResult(value) ||
+      IsNever(value) ||
+      IsNot(value) ||
+      IsNull(value) ||
+      IsNumber(value) ||
+      IsObject(value) ||
+      IsPromise(value) ||
+      IsRecord(value) ||
+      IsRef(value) ||
+      IsRegExp(value) ||
+      IsString(value) ||
+      IsSymbol(value) ||
+      IsTemplateLiteral(value) ||
+      IsThis(value) ||
+      IsTuple(value) ||
+      IsUndefined(value) ||
+      IsUnion(value) ||
+      IsUint8Array(value) ||
+      IsUnknown(value) ||
+      IsUnsafe(value) ||
+      IsVoid(value) ||
+      IsKind(value)
+    )
+}
diff --git a/src/type/guard/value.ts b/src/type/guard/value.ts
new file mode 100644
index 000000000..e09fb9bbc
--- /dev/null
+++ b/src/type/guard/value.ts
@@ -0,0 +1,88 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+/** Returns true if this value is an async iterator */
+export function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<unknown> {
+  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value
+}
+/** Returns true if this value is an array */
+export function IsArray(value: unknown): value is unknown[] {
+  return Array.isArray(value)
+}
+/** Returns true if this value is bigint */
+export function IsBigInt(value: unknown): value is bigint {
+  return typeof value === 'bigint'
+}
+/** Returns true if this value is a boolean */
+export function IsBoolean(value: unknown): value is boolean {
+  return typeof value === 'boolean'
+}
+/** Returns true if this value is a Date object */
+export function IsDate(value: unknown): value is Date {
+  return value instanceof globalThis.Date
+}
+/** Returns true if this value is a function */
+export function IsFunction(value: unknown): value is Function {
+  return typeof value === 'function'
+}
+/** Returns true if this value is an iterator */
+export function IsIterator(value: unknown): value is IterableIterator<unknown> {
+  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value
+}
+/** Returns true if this value is null */
+export function IsNull(value: unknown): value is null {
+  return value === null
+}
+/** Returns true if this value is number */
+export function IsNumber(value: unknown): value is number {
+  return typeof value === 'number'
+}
+/** Returns true if this value is an object */
+export function IsObject(value: unknown): value is Record<PropertyKey, unknown> {
+  return typeof value === 'object' && value !== null
+}
+/** Returns true if this value is RegExp */
+export function IsRegExp(value: unknown): value is RegExp {
+  return value instanceof globalThis.RegExp
+}
+/** Returns true if this value is string */
+export function IsString(value: unknown): value is string {
+  return typeof value === 'string'
+}
+/** Returns true if this value is symbol */
+export function IsSymbol(value: unknown): value is symbol {
+  return typeof value === 'symbol'
+}
+/** Returns true if this value is a Uint8Array */
+export function IsUint8Array(value: unknown): value is Uint8Array {
+  return value instanceof globalThis.Uint8Array
+}
+/** Returns true if this value is undefined */
+export function IsUndefined(value: unknown): value is undefined {
+  return value === undefined
+}
diff --git a/src/type/helpers/helpers.ts b/src/type/helpers/helpers.ts
new file mode 100644
index 000000000..84263c6d5
--- /dev/null
+++ b/src/type/helpers/helpers.ts
@@ -0,0 +1,69 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import type { TProperties } from '../object/index'
+import type { TNever } from '../never/index'
+// ------------------------------------------------------------------
+// Helper: Common
+// ------------------------------------------------------------------
+export type TupleToIntersect<T extends any[]> = T extends [infer I] ? I : T extends [infer I, ...infer R] ? I & TupleToIntersect<R> : never
+export type TupleToUnion<T extends any[]> = { [K in keyof T]: T[K] }[number]
+export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never
+export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never
+export type UnionToTuple<U, Acc extends unknown[] = [], R = UnionLast<U>> = [U] extends [never] ? Acc : UnionToTuple<Exclude<U, R>, [Extract<U, R>, ...Acc]>
+export type Trim<T> = T extends `${' '}${infer U}` ? Trim<U> : T extends `${infer U}${' '}` ? Trim<U> : T
+export type Assert<T, E> = T extends E ? T : never
+export type Evaluate<T> = T extends infer O ? { [K in keyof O]: O[K] } : never
+export type Ensure<T> = T extends infer U ? U : never
+export type EmptyString = ''
+export type ZeroString = '0'
+// ------------------------------------------------------------------
+// Helper: Increment
+// ------------------------------------------------------------------
+type IncrementBase = { m: '9'; t: '01'; '0': '1'; '1': '2'; '2': '3'; '3': '4'; '4': '5'; '5': '6'; '6': '7'; '7': '8'; '8': '9'; '9': '0' }
+type IncrementTake<T extends keyof IncrementBase> = IncrementBase[T]
+type IncrementStep<T extends string> = T extends IncrementBase['m']
+  ? IncrementBase['t']
+  : T extends `${infer L extends keyof IncrementBase}${infer R}`
+  ? L extends IncrementBase['m']
+    ? `${IncrementTake<L>}${IncrementStep<R>}`
+    : `${IncrementTake<L>}${R}`
+  : never
+type IncrementReverse<T extends string> = T extends `${infer L}${infer R}` ? `${IncrementReverse<R>}${L}` : T
+export type Increment<T extends string> = IncrementReverse<IncrementStep<IncrementReverse<T>>>
+/** Increments the given string value + 1 */
+export function Increment<T extends string>(T: T): Increment<T> {
+  return (parseInt(T) + 1).toString() as Increment<T>
+}
+// ------------------------------------------------------------------
+// Helper: Type Asserts
+// ------------------------------------------------------------------
+export type AssertProperties<T> = T extends TProperties ? T : TProperties
+export type AssertRest<T, E extends TSchema[] = TSchema[]> = T extends E ? T : []
+export type AssertType<T, E extends TSchema = TSchema> = T extends E ? T : TNever
diff --git a/src/type/helpers/index.ts b/src/type/helpers/index.ts
new file mode 100644
index 000000000..4d6559c8a
--- /dev/null
+++ b/src/type/helpers/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './helpers'
diff --git a/src/type/index.ts b/src/type/index.ts
new file mode 100644
index 000000000..d47dbf308
--- /dev/null
+++ b/src/type/index.ts
@@ -0,0 +1,98 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './any/index'
+export * from './array/index'
+export * from './async-iterator/index'
+export * from './awaited/index'
+export * from './bigint/index'
+export * from './boolean/index'
+export * from './clone/index'
+export * from './composite/index'
+export * from './const/index'
+export * from './constructor/index'
+export * from './constructor-parameters/index'
+export * from './date/index'
+export * from './deref/index'
+export * from './discard/index'
+export * from './enum/index'
+export * from './error/index'
+export * from './exclude/index'
+export * from './extends/index'
+export * from './extract/index'
+export * from './function/index'
+export * from './guard/index'
+export * from './helpers/index'
+export * from './indexed/index'
+export * from './instance-type/index'
+export * from './integer/index'
+export * from './intersect/index'
+export * from './intrinsic/index'
+export * from './iterator/index'
+export * from './keyof/index'
+export * from './literal/index'
+export * from './mapped/index'
+export * from './never/index'
+export * from './not/index'
+export * from './null/index'
+export * from './number/index'
+export * from './object/index'
+export * from './omit/index'
+export * from './optional/index'
+export * from './parameters/index'
+export * from './partial/index'
+export * from './patterns/index'
+export * from './pick/index'
+export * from './promise/index'
+export * from './readonly/index'
+export * from './readonly-optional/index'
+export * from './record/index'
+export * from './recursive/index'
+export * from './ref/index'
+export * from './regexp/index'
+export * from './registry/index'
+export * from './required/index'
+export * from './rest/index'
+export * from './return-type/index'
+export * from './schema/index'
+export * from './sets/index'
+export * from './static/index'
+export * from './strict/index'
+export * from './string/index'
+export * from './symbol/index'
+export * from './symbols/index'
+export * from './template-literal/index'
+export * from './transform/index'
+export * from './tuple/index'
+export * from './type/index'
+export * from './uint8array/index'
+export * from './undefined/index'
+export * from './union/index'
+export * from './unknown/index'
+export * from './unsafe/index'
+export * from './void/index'
diff --git a/src/type/indexed/index.ts b/src/type/indexed/index.ts
new file mode 100644
index 000000000..bdd973af4
--- /dev/null
+++ b/src/type/indexed/index.ts
@@ -0,0 +1,32 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './indexed-from-mapped-key'
+export * from './indexed-from-mapped-result'
+export * from './indexed-property-keys'
+export * from './indexed'
diff --git a/src/type/indexed/indexed-from-mapped-key.ts b/src/type/indexed/indexed-from-mapped-key.ts
new file mode 100644
index 000000000..5b1567c49
--- /dev/null
+++ b/src/type/indexed/indexed-from-mapped-key.ts
@@ -0,0 +1,103 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Evaluate } from '../helpers/index'
+import type { TProperties } from '../object/index'
+import { Index, type TIndex } from './indexed'
+import { MappedResult, type TMappedResult, type TMappedKey } from '../mapped/index'
+
+// ------------------------------------------------------------------
+// MappedIndexPropertyKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TMappedIndexPropertyKey<
+  T extends TSchema, 
+  K extends PropertyKey
+> = {
+  [_ in K]: TIndex<T, [K]>
+}
+// prettier-ignore
+function MappedIndexPropertyKey<
+  T extends TSchema, 
+  K extends PropertyKey
+>(T: T, K: K, options: SchemaOptions): TMappedIndexPropertyKey<T, K> {
+  return { [K]: Index(T, [K], options) } as TMappedIndexPropertyKey<T, K>
+}
+// ------------------------------------------------------------------
+// MappedIndexPropertyKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+type TMappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TProperties = {}> = (
+  K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+    ? TMappedIndexPropertyKeys<T, R, Acc & TMappedIndexPropertyKey<T, L>>
+    : Acc
+)
+// prettier-ignore
+function MappedIndexPropertyKeys<
+  T extends TSchema, 
+  K extends PropertyKey[]
+>(T: T, K: [...K], options: SchemaOptions): TMappedIndexPropertyKeys<T, K> {
+  return K.reduce((Acc, L) => {
+    return { ...Acc, ...MappedIndexPropertyKey(T, L, options) }
+  }, {} as TProperties) as TMappedIndexPropertyKeys<T, K>
+}
+// ------------------------------------------------------------------
+// MappedIndexProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TMappedIndexProperties<T extends TSchema, K extends TMappedKey> = Evaluate<
+  TMappedIndexPropertyKeys<T, K['keys']>
+>
+// prettier-ignore
+function MappedIndexProperties<
+  T extends TSchema, 
+  K extends TMappedKey
+>(T: T, K: K, options: SchemaOptions): TMappedIndexProperties<T, K> {
+  return MappedIndexPropertyKeys(T, K.keys, options) as TMappedIndexProperties<T, K>
+}
+// ------------------------------------------------------------------
+// TIndexFromMappedKey
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TIndexFromMappedKey<
+  T extends TSchema, 
+  K extends TMappedKey, 
+  P extends TProperties = TMappedIndexProperties<T, K>
+> = (
+  TMappedResult<P>
+)
+// prettier-ignore
+export function IndexFromMappedKey<
+  T extends TSchema, 
+  K extends TMappedKey, 
+  P extends TProperties = TMappedIndexProperties<T, K>
+>(T: T, K: K, options: SchemaOptions): TMappedResult<P> {
+  const P = MappedIndexProperties(T, K, options) as unknown as P
+  return MappedResult(P)
+}
diff --git a/src/type/indexed/indexed-from-mapped-result.ts b/src/type/indexed/indexed-from-mapped-result.ts
new file mode 100644
index 000000000..f685717ca
--- /dev/null
+++ b/src/type/indexed/indexed-from-mapped-result.ts
@@ -0,0 +1,90 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { TProperties } from '../object/index'
+import { MappedResult, type TMappedResult } from '../mapped/index'
+import { IndexPropertyKeys, type TIndexPropertyKeys } from './indexed-property-keys'
+import { Index, type TIndex } from './index'
+
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperties<
+  T extends TSchema,
+  P extends TProperties
+> = (
+  { [K2 in keyof P]: TIndex<T, TIndexPropertyKeys<P[K2]>> }   
+)
+// prettier-ignore
+function FromProperties<
+  T extends TSchema,
+  P extends TProperties
+>(T: T, P: P, options: SchemaOptions): TFromProperties<T, P> {
+  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+    return {...Acc, [K2]: Index(T, IndexPropertyKeys(P[K2]), options) }
+  }, {}) as TFromProperties<T, P>
+}
+// ------------------------------------------------------------------
+// FromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromMappedResult<
+  T extends TSchema,
+  R extends TMappedResult
+> = (
+  TFromProperties<T, R['properties']>
+)
+// prettier-ignore
+function FromMappedResult<
+  T extends TSchema,
+  R extends TMappedResult
+>(T: T, R: R, options: SchemaOptions): TFromMappedResult<T, R> {
+  return FromProperties(T, R.properties, options) as TFromMappedResult<T, R>
+}
+// ------------------------------------------------------------------
+// TIndexFromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TIndexFromMappedResult<
+  T extends TSchema,
+  R extends TMappedResult,
+  P extends TProperties = TFromMappedResult<T, R>
+> = (
+  TMappedResult<P>
+)
+// prettier-ignore
+export function IndexFromMappedResult<
+  T extends TSchema,
+  R extends TMappedResult,
+  P extends TProperties = TFromMappedResult<T, R>
+>(T: T, R: R, options: SchemaOptions): TMappedResult<P> {
+  const P = FromMappedResult(T, R, options) as unknown as P
+  return MappedResult(P) 
+}
diff --git a/src/type/indexed/indexed-property-keys.ts b/src/type/indexed/indexed-property-keys.ts
new file mode 100644
index 000000000..58f689811
--- /dev/null
+++ b/src/type/indexed/indexed-property-keys.ts
@@ -0,0 +1,103 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TemplateLiteralGenerate, type TTemplateLiteralGenerate, type TTemplateLiteral } from '../template-literal/index'
+import type { TLiteral, TLiteralValue } from '../literal/index'
+import type { TInteger } from '../integer/index'
+import type { TNumber } from '../number/index'
+import type { TSchema } from '../schema/index'
+import type { TUnion } from '../union/index'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsTemplateLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../guard/type'
+// ------------------------------------------------------------------
+// FromTemplateLiteral
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromTemplateLiteral<T extends TTemplateLiteral, R extends string[] = TTemplateLiteralGenerate<T>> = (R)
+// prettier-ignore
+function FromTemplateLiteral<T extends TTemplateLiteral>(T: T): TFromTemplateLiteral<T> {
+  const R = TemplateLiteralGenerate(T) as string[]
+  return R.map(S => S.toString()) as TFromTemplateLiteral<T>
+}
+// ------------------------------------------------------------------
+// FromUnion
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromUnion<T extends TSchema[], Acc extends string[] = []> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]] 
+    ? TFromUnion<R, [...Acc, ...TIndexPropertyKeys<L>]>
+    : Acc
+)
+// prettier-ignore
+function FromUnion<T extends TSchema[]>(T: T): TFromUnion<T> {
+  return T.reduce((Acc, L) => {
+    return [...Acc, ...IndexPropertyKeys(L)]
+  }, [] as string[]) as TFromUnion<T>
+}
+// ------------------------------------------------------------------
+// FromLiteral
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromLiteral<T extends TLiteralValue> = (
+  T extends PropertyKey 
+    ? [`${T}`] 
+    : []
+)
+// prettier-ignore
+function FromLiteral<T extends TLiteralValue>(T: T): TFromLiteral<T> {
+  return (
+    [(T as string).toString()] // TS 5.4 observes TLiteralValue as not having a toString()
+  ) as TFromLiteral<T>
+}
+// ------------------------------------------------------------------
+// IndexedKeyResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TIndexPropertyKeys<T extends TSchema> = (
+  T extends TTemplateLiteral  ? TFromTemplateLiteral<T> :
+  T extends TUnion<infer S>   ? TFromUnion<S> :
+  T extends TLiteral<infer S> ? TFromLiteral<S> :
+  T extends TNumber           ? ['[number]'] :  
+  T extends TInteger          ? ['[number]'] :
+  []
+)
+/** Returns a tuple of PropertyKeys derived from the given TSchema */
+// prettier-ignore
+export function IndexPropertyKeys<T extends TSchema>(T: T): TIndexPropertyKeys<T> {
+  return [...new Set<string>((
+    IsTemplateLiteral(T) ? FromTemplateLiteral(T) :
+    IsUnion(T) ? FromUnion(T.anyOf) :
+    IsLiteral(T) ? FromLiteral(T.const) :
+    IsNumber(T) ? ['[number]'] : 
+    IsInteger(T) ? ['[number]'] :
+    []
+  ))] as TIndexPropertyKeys<T>
+}
diff --git a/src/type/indexed/indexed.ts b/src/type/indexed/indexed.ts
new file mode 100644
index 000000000..bea542a69
--- /dev/null
+++ b/src/type/indexed/indexed.ts
@@ -0,0 +1,241 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { type TSchema, SchemaOptions } from '../schema/index'
+import { type TObject, type TProperties } from '../object/index'
+import { type Assert } from '../helpers/index'
+import { Never, type TNever } from '../never/index'
+import { type TRecursive } from '../recursive/index'
+import { type TIntersect } from '../intersect/index'
+import { TMappedResult, type TMappedKey } from '../mapped/index'
+import { type TUnion } from '../union/index'
+import { type TTuple } from '../tuple/index'
+import { type TArray } from '../array/index'
+import { IntersectEvaluated, type TIntersectEvaluated } from '../intersect/index'
+import { UnionEvaluated, type TUnionEvaluated } from '../union/index'
+import { CloneType } from '../clone/type'
+
+import { IndexPropertyKeys, type TIndexPropertyKeys } from './indexed-property-keys'
+import { IndexFromMappedKey, type TIndexFromMappedKey } from './indexed-from-mapped-key'
+import { IndexFromMappedResult, type TIndexFromMappedResult } from './indexed-from-mapped-result'
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion } from '../guard/type'
+
+// ------------------------------------------------------------------
+// FromRest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TFromRest<R, K, [...Acc, Assert<TFromKey<L, K>, TSchema>]>
+    : Acc
+)
+// prettier-ignore
+function FromRest<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TFromRest<T, K> {
+  return T.map(L => FromKey(L, K)) as TFromRest<T, K>
+}
+// ------------------------------------------------------------------
+// FromIntersectRest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromIntersectRest<T extends TSchema[], Acc extends TSchema[] = []> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? L extends TNever
+      ? TFromIntersectRest<R, [...Acc]>
+      : TFromIntersectRest<R, [...Acc, L]>
+    : Acc
+)
+// prettier-ignore
+function FromIntersectRest<T extends TSchema[]>(T: [...T]): TFromIntersectRest<T> {
+  return T.filter(L => !IsNever(L)) as never
+}
+// prettier-ignore
+type TFromIntersect<T extends TSchema[], K extends PropertyKey> = (
+  TIntersectEvaluated<TFromIntersectRest<TFromRest<T, K>>>
+)
+// prettier-ignore
+function FromIntersect<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TFromIntersect<T, K> {
+  return (
+    IntersectEvaluated(FromIntersectRest(FromRest(T as TSchema[], K)))
+  ) as TFromIntersect<T, K>
+}
+// ------------------------------------------------------------------
+// FromUnionRest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromUnionRest<T extends TSchema[]> = T
+// prettier-ignore
+function FromUnionRest<T extends TSchema[]>(T: [...T]): TFromUnionRest<T> {
+  return T as never // review this
+}
+// ------------------------------------------------------------------
+// FromUnion
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromUnion<T extends TSchema[], K extends PropertyKey> = (
+  TUnionEvaluated<TFromUnionRest<TFromRest<T, K>>>
+)
+// prettier-ignore
+function FromUnion<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TFromUnion<T, K> {
+  return (
+    UnionEvaluated(FromUnionRest(FromRest(T as TSchema[], K)))
+  ) as TFromUnion<T, K>
+}
+// ------------------------------------------------------------------
+// FromTuple
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromTuple<T extends TSchema[], K extends PropertyKey> = (
+  K extends keyof T ? T[K] : 
+  K extends '[number]' ? TUnionEvaluated<T> : 
+  TNever
+)
+// prettier-ignore
+function FromTuple<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TFromTuple<T, K>  {
+  return (
+    K in T ? T[K as number] : 
+    K === '[number]' ? UnionEvaluated(T) : 
+    Never()
+  ) as TFromTuple<T, K>
+}
+// ------------------------------------------------------------------
+// FromArray
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromArray<T extends TSchema, K extends PropertyKey> = (
+  K extends '[number]' 
+    ? T 
+    : TNever
+)
+// prettier-ignore
+function FromArray<T extends TSchema, K extends PropertyKey>(T: T, K: K): TFromArray<T, K>  {
+  return (
+    K === '[number]' 
+      ? T 
+      : Never()
+  ) as TFromArray<T, K>
+}
+// ------------------------------------------------------------------
+// FromProperty
+// ------------------------------------------------------------------
+type AssertPropertyKey<T> = Assert<T, string | number>
+
+// prettier-ignore
+type TFromProperty<
+  T extends TProperties, 
+  K extends PropertyKey,
+> = (
+  // evaluate for string keys
+  K extends keyof T 
+    ? T[K] 
+    // evaluate for numeric keys
+    : `${AssertPropertyKey<K>}` extends `${AssertPropertyKey<keyof T>}` 
+      ? T[AssertPropertyKey<K>]
+      : TNever
+)
+// prettier-ignore
+function FromProperty<T extends TProperties, K extends PropertyKey>(T: T, K: K): TFromProperty<T, K> {
+  return (K in T ? T[K as string] : Never()) as TFromProperty<T, K>
+}
+// ------------------------------------------------------------------
+// FromKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromKey<T extends TSchema, K extends PropertyKey> = (
+  T extends TRecursive<infer S> ? TFromKey<S, K> :
+  T extends TIntersect<infer S> ? TFromIntersect<S, K> :
+  T extends TUnion<infer S> ? TFromUnion<S, K> :
+  T extends TTuple<infer S> ? TFromTuple<S, K> :
+  T extends TArray<infer S> ? TFromArray<S, K> :
+  T extends TObject<infer S> ? TFromProperty<S, K> :
+  TNever
+)
+// prettier-ignore
+function FromKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): TFromKey<T, K> {
+  return (
+    IsIntersect(T) ? FromIntersect(T.allOf, K) :
+    IsUnion(T) ? FromUnion(T.anyOf, K) :
+    IsTuple(T) ? FromTuple(T.items ?? [], K) :
+    IsArray(T) ? FromArray(T.items, K) :
+    IsObject(T) ? FromProperty(T.properties, K) :
+    Never()
+  ) as TFromKey<T, K>
+}
+// ------------------------------------------------------------------
+// FromKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromKeys<T extends TSchema, K extends PropertyKey[], Acc extends TSchema[] = []> = (
+  K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+    ? TFromKeys<T, R, [...Acc, Assert<TFromKey<T, L>, TSchema>]>
+    : Acc
+)
+// prettier-ignore
+function FromKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TFromKeys<T, K> {
+  return K.map(L => FromKey(T, L)) as TFromKeys<T, K>
+}
+// ------------------------------------------------------------------
+// FromSchema
+// ------------------------------------------------------------------
+// prettier-ignore
+type FromSchema<T extends TSchema, K extends PropertyKey[]> = (
+  TUnionEvaluated<TFromKeys<T, K>>
+)
+// prettier-ignore
+function FromSchema<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromSchema<T, K> {
+  return (
+    UnionEvaluated(FromKeys(T, K as PropertyKey[]))
+  ) as FromSchema<T, K>
+}
+// ------------------------------------------------------------------
+// TIndex
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TIndex<T extends TSchema, K extends PropertyKey[]> = (
+  FromSchema<T, K>
+)
+/** `[Json]` Returns an Indexed property type for the given keys */
+export function Index<T extends TSchema, K extends TMappedResult>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedResult<T, K>
+/** `[Json]` Returns an Indexed property type for the given keys */
+export function Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>
+/** `[Json]` Returns an Indexed property type for the given keys */
+export function Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>
+/** `[Json]` Returns an Indexed property type for the given keys */
+export function Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>
+/** `[Json]` Returns an Indexed property type for the given keys */
+export function Index(T: TSchema, K: any, options: SchemaOptions = {}): any {
+  // prettier-ignore
+  return (
+    IsMappedResult(K) ? CloneType(IndexFromMappedResult(T, K, options)) :
+    IsMappedKey(K) ? CloneType(IndexFromMappedKey(T, K, options)) :
+    IsSchema(K) ? CloneType(FromSchema(T, IndexPropertyKeys(K)), options) :
+    CloneType(FromSchema(T, K as string[]), options)
+  )
+}
diff --git a/src/type/instance-type/index.ts b/src/type/instance-type/index.ts
new file mode 100644
index 000000000..aa85b717a
--- /dev/null
+++ b/src/type/instance-type/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './instance-type'
diff --git a/src/type/instance-type/instance-type.ts b/src/type/instance-type/instance-type.ts
new file mode 100644
index 000000000..f26503419
--- /dev/null
+++ b/src/type/instance-type/instance-type.ts
@@ -0,0 +1,38 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { TConstructor } from '../constructor/index'
+import { CloneType } from '../clone/type'
+
+export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns']
+
+/** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
+export function InstanceType<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TInstanceType<T> {
+  return CloneType(schema.returns, options)
+}
diff --git a/src/type/integer/index.ts b/src/type/integer/index.ts
new file mode 100644
index 000000000..73513ebc8
--- /dev/null
+++ b/src/type/integer/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './integer'
diff --git a/src/type/integer/integer.ts b/src/type/integer/integer.ts
new file mode 100644
index 000000000..23ed802af
--- /dev/null
+++ b/src/type/integer/integer.ts
@@ -0,0 +1,51 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+export interface IntegerOptions extends SchemaOptions {
+  exclusiveMaximum?: number
+  exclusiveMinimum?: number
+  maximum?: number
+  minimum?: number
+  multipleOf?: number
+}
+export interface TInteger extends TSchema, IntegerOptions {
+  [Kind]: 'Integer'
+  static: number
+  type: 'integer'
+}
+/** `[Json]` Creates an Integer type */
+export function Integer(options: IntegerOptions = {}): TInteger {
+  return {
+    ...options,
+    [Kind]: 'Integer',
+    type: 'integer',
+  } as unknown as TInteger
+}
diff --git a/src/type/intersect/index.ts b/src/type/intersect/index.ts
new file mode 100644
index 000000000..c2f3d3ba4
--- /dev/null
+++ b/src/type/intersect/index.ts
@@ -0,0 +1,31 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './intersect-evaluated'
+export * from './intersect-type'
+export * from './intersect'
diff --git a/src/type/intersect/intersect-create.ts b/src/type/intersect/intersect-create.ts
new file mode 100644
index 000000000..815c27e9a
--- /dev/null
+++ b/src/type/intersect/intersect-create.ts
@@ -0,0 +1,52 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import { Kind } from '../symbols/index'
+import { CloneType, CloneRest } from '../clone/type'
+import type { TIntersect, IntersectOptions } from './intersect-type'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsObject, IsSchema } from '../guard/type'
+// ------------------------------------------------------------------
+// IntersectCreate
+// ------------------------------------------------------------------
+// prettier-ignore
+export function IntersectCreate<T extends TSchema[]>(T: [...T], options: IntersectOptions): TIntersect<T> {
+  const allObjects = T.every((schema) => IsObject(schema))
+  const clonedUnevaluatedProperties = IsSchema(options.unevaluatedProperties) 
+    ? { unevaluatedProperties: CloneType(options.unevaluatedProperties) } 
+    : {}
+  return (
+    (options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects
+      ? { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: CloneRest(T) }
+      : { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: CloneRest(T) })
+  ) as TIntersect<T>
+}
diff --git a/src/type/intersect/intersect-evaluated.ts b/src/type/intersect/intersect-evaluated.ts
new file mode 100644
index 000000000..5f6f25ba4
--- /dev/null
+++ b/src/type/intersect/intersect-evaluated.ts
@@ -0,0 +1,127 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { SchemaOptions, TSchema } from '../schema/index'
+import { OptionalKind } from '../symbols/index'
+import { CloneType } from '../clone/type'
+import { Discard } from '../discard/index'
+
+import { Never, type TNever } from '../never/index'
+import { Optional, type TOptional } from '../optional/index'
+import type { TReadonly } from '../readonly/index'
+
+import { TIntersect, IntersectOptions } from './intersect-type'
+import { IntersectCreate } from './intersect-create'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+import { 
+  IsOptional,
+  IsTransform,
+} from '../guard/type'
+
+// ------------------------------------------------------------------
+// IsIntersectOptional
+// ------------------------------------------------------------------
+// prettier-ignore
+type TIsIntersectOptional<T extends TSchema[]> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]] 
+    ? L extends TOptional<TSchema> 
+      ? TIsIntersectOptional<R> 
+      : false 
+    : true
+)
+// prettier-ignore
+function IsIntersectOptional<T extends TSchema[]>(T: T): TIsIntersectOptional<T> {
+  return T.every(L => IsOptional(L)) as TIsIntersectOptional<T>
+}
+// ------------------------------------------------------------------
+// RemoveOptionalFromType
+// ------------------------------------------------------------------
+// prettier-ignore
+type TRemoveOptionalFromType<T extends TSchema> = (
+  T extends TReadonly<infer S extends TSchema> ? TReadonly<TRemoveOptionalFromType<S>> :
+  T extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromType<S> :
+  T
+)
+// prettier-ignore
+function RemoveOptionalFromType<T extends TSchema>(T: T): TRemoveOptionalFromType<T> {
+  return (
+    Discard(T, [OptionalKind])
+    ) as TRemoveOptionalFromType<T>
+}
+// ------------------------------------------------------------------
+// RemoveOptionalFromRest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TRemoveOptionalFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+  ? L extends TOptional<infer S extends TSchema>
+    ? TRemoveOptionalFromRest<R, [...Acc, TRemoveOptionalFromType<S>]>
+    : TRemoveOptionalFromRest<R, [...Acc, L]>
+  : Acc
+)
+// prettier-ignore
+function RemoveOptionalFromRest<T extends TSchema[]>(T: T): TRemoveOptionalFromRest<T> {
+  return T.map(L => IsOptional(L) ? RemoveOptionalFromType(L) : L) as TRemoveOptionalFromRest<T>
+}
+// ------------------------------------------------------------------
+// ResolveIntersect
+// ------------------------------------------------------------------
+// prettier-ignore
+type TResolveIntersect<T extends TSchema[]> = (
+  TIsIntersectOptional<T> extends true 
+    ? TOptional<TIntersect<TRemoveOptionalFromRest<T>>> 
+    : TIntersect<TRemoveOptionalFromRest<T>>
+)
+// prettier-ignore
+function ResolveIntersect<T extends TSchema[]>(T: [...T], options: SchemaOptions): TResolveIntersect<T> {
+  return (
+    IsIntersectOptional(T)
+      ? Optional(IntersectCreate(RemoveOptionalFromRest(T) as TSchema[], options))
+      : IntersectCreate(RemoveOptionalFromRest(T) as TSchema[], options)
+  ) as unknown as TResolveIntersect<T>
+}
+// ------------------------------------------------------------------
+// IntersectEvaluated
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TIntersectEvaluated<T extends TSchema[]> = (
+  T extends [] ? TNever :
+  T extends [TSchema] ? T[0] :
+  TResolveIntersect<T>
+)
+/** `[Json]` Creates an evaluated Intersect type */
+export function IntersectEvaluated<T extends TSchema[], R = TIntersectEvaluated<T>>(T: [...T], options: IntersectOptions = {}): R {
+  if (T.length === 0) return Never(options) as R
+  if (T.length === 1) return CloneType(T[0], options) as R
+  if (T.some((schema) => IsTransform(schema))) throw new Error('Cannot intersect transform types')
+  return ResolveIntersect(T, options) as R
+}
diff --git a/examples/prototypes/const.ts b/src/type/intersect/intersect-type.ts
similarity index 50%
rename from examples/prototypes/const.ts
rename to src/type/intersect/intersect-type.ts
index 75399a0aa..991c3674e 100644
--- a/examples/prototypes/const.ts
+++ b/src/type/intersect/intersect-type.ts
@@ -1,6 +1,6 @@
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox/prototypes
+@sinclair/typebox/type
 
 The MIT License (MIT)
 
@@ -26,36 +26,31 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { Type, ObjectMap, TypeGuard, TSchema, TIntersect, TUnion, TObject, TProperties, TReadonly, AssertProperties, AssertType, AssertRest, Evaluate, ReadonlyUnwrapType } from '@sinclair/typebox'
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Static } from '../static/index'
+import { Kind } from '../symbols/index'
 
-// -------------------------------------------------------------------------------------
-// TConst
-// -------------------------------------------------------------------------------------
+// ------------------------------------------------------------------
+// IntersectStatic
+// ------------------------------------------------------------------
 // prettier-ignore
-export type TConstArray<T extends TSchema[], E extends boolean> = T extends [infer L, ...infer R]
-  ? [TConst<AssertType<L>, E>, ...TConstArray<AssertRest<R>, E>]
-  : []
+type TIntersectStatic<T extends TSchema[], P extends unknown[], Acc extends unknown = unknown> = 
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TIntersectStatic<R, P, Acc & Static<L, P>>
+    : Acc
+// ------------------------------------------------------------------
+// TIntersect
+// ------------------------------------------------------------------
 // prettier-ignore
-export type TConstProperties<T extends TProperties, E extends boolean> = Evaluate<AssertProperties<{
-  [K in keyof T]: TConst<ReadonlyUnwrapType<T[K]>, E>
-}>>
+export type TUnevaluatedProperties = undefined | TSchema | boolean
 // prettier-ignore
-export type TConst<T extends TSchema, E extends boolean> =
-  T extends TIntersect<infer S> ? TIntersect<TConstArray<S, false>> :
-  T extends TUnion<infer S> ? TUnion<TConstArray<S, false>> :
-  T extends TObject<infer S> ? TObject<TConstProperties<S, false>> :
-  E extends true ? T : TReadonly<T>
-// -------------------------------------------------------------------------------------
-// Const
-// -------------------------------------------------------------------------------------
-/** `[Experimental]` Assigns readonly to all interior properties */
-export function Const<T extends TSchema>(schema: T): TConst<T, true> {
-  const mappable = (TypeGuard.TIntersect(schema) || TypeGuard.TUnion(schema) || TypeGuard.TObject(schema))
-  // prettier-ignore
-  return mappable ? ObjectMap.Map(schema, (object) => {
-    const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
-      return { ...acc, [key]: Type.Readonly(object.properties[key] )}
-    }, {} as TProperties)
-    return Type.Object(properties, {...object})
-  }, {}) : schema as any
-}
\ No newline at end of file
+export interface IntersectOptions extends SchemaOptions {
+  unevaluatedProperties?: TUnevaluatedProperties
+}
+// prettier-ignore
+export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
+  [Kind]: 'Intersect'
+  static: TIntersectStatic<T, this['params']>
+  type?: 'object'
+  allOf: [...T]
+}
diff --git a/src/type/intersect/intersect.ts b/src/type/intersect/intersect.ts
new file mode 100644
index 000000000..b06c1dd80
--- /dev/null
+++ b/src/type/intersect/intersect.ts
@@ -0,0 +1,55 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import { CloneType } from '../clone/type'
+import { Never, type TNever } from '../never/index'
+
+import { TIntersect, IntersectOptions } from './intersect-type'
+import { IntersectCreate } from './intersect-create'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsTransform } from '../guard/type'
+// ------------------------------------------------------------------
+// Intersect
+// ------------------------------------------------------------------
+// prettier-ignore
+export type Intersect<T extends TSchema[]> = (
+  T extends [] ? TNever :
+  T extends [TSchema] ? T[0] :
+  TIntersect<T>
+)
+/** `[Json]` Creates an evaluated Intersect type */
+export function Intersect<T extends TSchema[]>(T: [...T], options: IntersectOptions = {}): Intersect<T> {
+  if (T.length === 0) return Never(options) as Intersect<T>
+  if (T.length === 1) return CloneType(T[0], options) as Intersect<T>
+  if (T.some((schema) => IsTransform(schema))) throw new Error('Cannot intersect transform types')
+  return IntersectCreate(T, options) as Intersect<T>
+}
diff --git a/src/type/intrinsic/capitalize.ts b/src/type/intrinsic/capitalize.ts
new file mode 100644
index 000000000..0bb053da8
--- /dev/null
+++ b/src/type/intrinsic/capitalize.ts
@@ -0,0 +1,37 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Intrinsic, type TIntrinsic } from './intrinsic'
+
+// prettier-ignore
+export type TCapitalize<T extends TSchema> = TIntrinsic<T, 'Capitalize'>
+/** `[Json]` Intrinsic function to Capitalize LiteralString types */
+export function Capitalize<T extends TSchema>(T: T, options: SchemaOptions = {}): TCapitalize<T> {
+  return Intrinsic(T, 'Capitalize', options)
+}
diff --git a/src/type/intrinsic/index.ts b/src/type/intrinsic/index.ts
new file mode 100644
index 000000000..d5c9aedc3
--- /dev/null
+++ b/src/type/intrinsic/index.ts
@@ -0,0 +1,34 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './capitalize'
+export * from './intrinsic-from-mapped-key'
+export * from './intrinsic'
+export * from './lowercase'
+export * from './uncapitalize'
+export * from './uppercase'
diff --git a/src/type/intrinsic/intrinsic-from-mapped-key.ts b/src/type/intrinsic/intrinsic-from-mapped-key.ts
new file mode 100644
index 000000000..b1c1b5f3d
--- /dev/null
+++ b/src/type/intrinsic/intrinsic-from-mapped-key.ts
@@ -0,0 +1,113 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { SchemaOptions } from '../schema/index'
+import type { TProperties } from '../object/index'
+import { Assert } from '../helpers/index'
+import { MappedResult, type TMappedResult, type TMappedKey } from '../mapped/index'
+import { Intrinsic, type TIntrinsic, type IntrinsicMode } from './intrinsic'
+import { Literal, type TLiteral, type TLiteralValue } from '../literal/index'
+
+// ------------------------------------------------------------------
+// MappedIntrinsicPropertyKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TMappedIntrinsicPropertyKey<
+  K extends PropertyKey,
+  M extends IntrinsicMode,
+> = {
+    [_ in K]: TIntrinsic<TLiteral<Assert<K, TLiteralValue>>, M>
+  }
+// prettier-ignore
+function MappedIntrinsicPropertyKey<
+  K extends PropertyKey,
+  M extends IntrinsicMode,
+>(K: K, M: M, options: SchemaOptions): TMappedIntrinsicPropertyKey<K, M> {
+  return {
+    [K]: Intrinsic(Literal(K as TLiteralValue), M, options)
+  } as TMappedIntrinsicPropertyKey<K, M>
+}
+// ------------------------------------------------------------------
+// MappedIntrinsicPropertyKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+type TMappedIntrinsicPropertyKeys<
+  K extends PropertyKey[],
+  M extends IntrinsicMode,
+  Acc extends TProperties = {}
+> = (
+  K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+    ? TMappedIntrinsicPropertyKeys<R, M, Acc & TMappedIntrinsicPropertyKey<L, M>>
+    : Acc
+)
+// prettier-ignore
+function MappedIntrinsicPropertyKeys<
+  K extends PropertyKey[],
+  M extends IntrinsicMode
+>(K: [...K], M: M, options: SchemaOptions): TMappedIntrinsicPropertyKeys<K, M> {
+  return K.reduce((Acc, L) => {
+    return { ...Acc, ...MappedIntrinsicPropertyKey(L, M, options) }
+  }, {} as TProperties) as TMappedIntrinsicPropertyKeys<K, M>
+}
+// ------------------------------------------------------------------
+// MappedIntrinsicProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TMappedIntrinsicProperties<
+  K extends TMappedKey,
+  M extends IntrinsicMode,
+> = (
+  TMappedIntrinsicPropertyKeys<K['keys'], M>
+  )
+// prettier-ignore
+function MappedIntrinsicProperties<
+  K extends TMappedKey,
+  M extends IntrinsicMode,
+>(T: K, M: M, options: SchemaOptions): TMappedIntrinsicProperties<K, M> {
+  return MappedIntrinsicPropertyKeys(T['keys'], M, options) as TMappedIntrinsicProperties<K, M>
+}
+// ------------------------------------------------------------------
+// IntrinsicFromMappedKey
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TIntrinsicFromMappedKey<
+  K extends TMappedKey,
+  M extends IntrinsicMode,
+  P extends TProperties = TMappedIntrinsicProperties<K, M>
+> = (
+  TMappedResult<P>
+)
+// prettier-ignore
+export function IntrinsicFromMappedKey<
+  K extends TMappedKey,
+  M extends IntrinsicMode,
+  P extends TProperties = TMappedIntrinsicProperties<K, M>
+>(T: K, M: M, options: SchemaOptions): TMappedResult<P> {
+  const P = MappedIntrinsicProperties(T, M, options) as unknown as P
+  return MappedResult(P) 
+}
diff --git a/src/type/intrinsic/intrinsic.ts b/src/type/intrinsic/intrinsic.ts
new file mode 100644
index 000000000..5080aa60f
--- /dev/null
+++ b/src/type/intrinsic/intrinsic.ts
@@ -0,0 +1,148 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralExpressionFinite, TemplateLiteralExpressionGenerate, type TTemplateLiteral, type TTemplateLiteralKind } from '../template-literal/index'
+import { IntrinsicFromMappedKey, type TIntrinsicFromMappedKey } from './intrinsic-from-mapped-key'
+import { Literal, type TLiteral, type TLiteralValue } from '../literal/index'
+import { Union, type TUnion } from '../union/index'
+import { type TMappedKey } from '../mapped/index'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsMappedKey, IsTemplateLiteral, IsUnion, IsLiteral } from '../guard/type'
+// ------------------------------------------------------------------
+// Apply
+// ------------------------------------------------------------------
+function ApplyUncapitalize(value: string): string {
+  const [first, rest] = [value.slice(0, 1), value.slice(1)]
+  return [first.toLowerCase(), rest].join('')
+}
+function ApplyCapitalize(value: string): string {
+  const [first, rest] = [value.slice(0, 1), value.slice(1)]
+  return [first.toUpperCase(), rest].join('')
+}
+function ApplyUppercase(value: string): string {
+  return value.toUpperCase()
+}
+function ApplyLowercase(value: string): string {
+  return value.toLowerCase()
+}
+// ------------------------------------------------------------------
+// IntrinsicMode
+// ------------------------------------------------------------------
+export type IntrinsicMode = 'Uppercase' | 'Lowercase' | 'Capitalize' | 'Uncapitalize'
+// ------------------------------------------------------------------
+// FromTemplateLiteral
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode> =
+  M extends IntrinsicMode ?
+    T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]]
+      ? [TIntrinsic<L, M>, ...TFromTemplateLiteral<R, M>]
+      : T
+    : T
+function FromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode>(schema: TTemplateLiteral, mode: IntrinsicMode, options: SchemaOptions): TFromTemplateLiteral<T, M> {
+  // note: template literals require special runtime handling as they are encoded in string patterns.
+  // This diverges from the mapped type which would otherwise map on the template literal kind.
+  const expression = TemplateLiteralParseExact(schema.pattern)
+  const finite = IsTemplateLiteralExpressionFinite(expression)
+  if (!finite) return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) } as any
+  const strings = [...TemplateLiteralExpressionGenerate(expression)]
+  const literals = strings.map((value) => Literal(value))
+  const mapped = FromRest(literals as any, mode)
+  const union = Union(mapped)
+  return TemplateLiteral([union], options) as unknown as TFromTemplateLiteral<T, M>
+}
+// ------------------------------------------------------------------
+// FromLiteralValue
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromLiteralValue<T, M extends IntrinsicMode> = (
+    T extends string ?
+      M extends 'Uncapitalize' ? Uncapitalize<T> :
+      M extends 'Capitalize' ? Capitalize<T> :
+      M extends 'Uppercase' ? Uppercase<T> :
+      M extends 'Lowercase' ? Lowercase<T> :
+      string
+    : T
+)
+// prettier-ignore
+function FromLiteralValue(value: TLiteralValue, mode: IntrinsicMode) {
+  return (
+    typeof value === 'string' ? (
+      mode === 'Uncapitalize' ? ApplyUncapitalize(value) :
+      mode === 'Capitalize' ? ApplyCapitalize(value) :
+      mode === 'Uppercase' ? ApplyUppercase(value) :
+      mode === 'Lowercase' ? ApplyLowercase(value) :
+      value
+    ) : value.toString()
+  )
+}
+// ------------------------------------------------------------------
+// FromRest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRest<T extends TSchema[], M extends IntrinsicMode, Acc extends TSchema[] = []> =
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TFromRest<R, M, [...Acc, TIntrinsic<L, M>]>
+    : Acc
+// prettier-ignore
+function FromRest<T extends TSchema[], M extends IntrinsicMode>(T: [...T], M: M): TFromRest<T, M> {
+  return T.map(L => Intrinsic(L, M)) as TFromRest<T, M>
+}
+// ------------------------------------------------------------------
+// TIntrinsic
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TIntrinsic<T extends TSchema, M extends IntrinsicMode> =
+  // Intrinsic-Mapped-Inference
+  T extends TMappedKey ? TIntrinsicFromMappedKey<T, M> :
+  // Standard-Inference
+  T extends TTemplateLiteral<infer S> ? TTemplateLiteral<TFromTemplateLiteral<S, M>> :
+  T extends TUnion<infer S> ? TUnion<TFromRest<S, M>> :
+  T extends TLiteral<infer S> ? TLiteral<TFromLiteralValue<S, M>> :
+  T
+/** Applies an intrinsic string manipulation to the given type. */
+export function Intrinsic<T extends TMappedKey, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsicFromMappedKey<T, M>
+/** Applies an intrinsic string manipulation to the given type. */
+export function Intrinsic<T extends TSchema, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsic<T, M>
+/** Applies an intrinsic string manipulation to the given type. */
+export function Intrinsic(schema: TSchema, mode: IntrinsicMode, options: SchemaOptions = {}): any {
+  // prettier-ignore
+  return (
+    // Intrinsic-Mapped-Inference
+    IsMappedKey(schema) ? IntrinsicFromMappedKey(schema, mode, options) :
+    // Standard-Inference
+    IsTemplateLiteral(schema) ? FromTemplateLiteral(schema, mode, schema) :
+    IsUnion(schema) ? Union(FromRest(schema.anyOf, mode), options) :
+    IsLiteral(schema) ? Literal(FromLiteralValue(schema.const, mode), options) :
+    schema
+  )
+}
diff --git a/src/type/intrinsic/lowercase.ts b/src/type/intrinsic/lowercase.ts
new file mode 100644
index 000000000..835d39b4f
--- /dev/null
+++ b/src/type/intrinsic/lowercase.ts
@@ -0,0 +1,37 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Intrinsic, type TIntrinsic } from './intrinsic'
+
+// prettier-ignore
+export type TLowercase<T extends TSchema> = TIntrinsic<T, 'Lowercase'>
+/** `[Json]` Intrinsic function to Lowercase LiteralString types */
+export function Lowercase<T extends TSchema>(T: T, options: SchemaOptions = {}): TLowercase<T> {
+  return Intrinsic(T, 'Lowercase', options)
+}
diff --git a/src/type/intrinsic/uncapitalize.ts b/src/type/intrinsic/uncapitalize.ts
new file mode 100644
index 000000000..d69502253
--- /dev/null
+++ b/src/type/intrinsic/uncapitalize.ts
@@ -0,0 +1,37 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Intrinsic, type TIntrinsic } from './intrinsic'
+
+// prettier-ignore
+export type TUncapitalize<T extends TSchema> = TIntrinsic<T, 'Uncapitalize'>
+/** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
+export function Uncapitalize<T extends TSchema>(T: T, options: SchemaOptions = {}): TUncapitalize<T> {
+  return Intrinsic(T, 'Uncapitalize', options)
+}
diff --git a/src/type/intrinsic/uppercase.ts b/src/type/intrinsic/uppercase.ts
new file mode 100644
index 000000000..52ee4fa67
--- /dev/null
+++ b/src/type/intrinsic/uppercase.ts
@@ -0,0 +1,37 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Intrinsic, type TIntrinsic } from './intrinsic'
+
+// prettier-ignore
+export type TUppercase<T extends TSchema> = TIntrinsic<T, 'Uppercase'>
+/** `[Json]` Intrinsic function to Uppercase LiteralString types */
+export function Uppercase<T extends TSchema>(T: T, options: SchemaOptions = {}): TUppercase<T> {
+  return Intrinsic(T, 'Uppercase', options)
+}
diff --git a/src/type/iterator/index.ts b/src/type/iterator/index.ts
new file mode 100644
index 000000000..8c41f54e3
--- /dev/null
+++ b/src/type/iterator/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './iterator'
diff --git a/src/type/iterator/iterator.ts b/src/type/iterator/iterator.ts
new file mode 100644
index 000000000..74a37a236
--- /dev/null
+++ b/src/type/iterator/iterator.ts
@@ -0,0 +1,48 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Static } from '../static/index'
+import { CloneType } from '../clone/type'
+import { Kind } from '../symbols/index'
+
+export interface TIterator<T extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'Iterator'
+  static: IterableIterator<Static<T, this['params']>>
+  type: 'Iterator'
+  items: T
+}
+/** `[JavaScript]` Creates an Iterator type */
+export function Iterator<T extends TSchema>(items: T, options: SchemaOptions = {}): TIterator<T> {
+  return {
+    ...options,
+    [Kind]: 'Iterator',
+    type: 'Iterator',
+    items: CloneType(items),
+  } as unknown as TIterator<T>
+}
diff --git a/src/type/keyof/index.ts b/src/type/keyof/index.ts
new file mode 100644
index 000000000..03a32c098
--- /dev/null
+++ b/src/type/keyof/index.ts
@@ -0,0 +1,31 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './keyof-from-mapped-result'
+export * from './keyof-property-keys'
+export * from './keyof'
diff --git a/src/type/keyof/keyof-from-mapped-result.ts b/src/type/keyof/keyof-from-mapped-result.ts
new file mode 100644
index 000000000..97709295c
--- /dev/null
+++ b/src/type/keyof/keyof-from-mapped-result.ts
@@ -0,0 +1,83 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { SchemaOptions } from '../schema/index'
+import type { TProperties } from '../object/index'
+import { MappedResult, type TMappedResult } from '../mapped/index'
+import { KeyOf, type TKeyOf } from './keyof'
+
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperties<
+  K extends TProperties
+> = (
+  { [K2 in keyof K]: TKeyOf<K[K2]> }   
+)
+// prettier-ignore
+function FromProperties<
+  K extends TProperties
+>(K: K, options: SchemaOptions): TFromProperties<K> {
+  return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+    return {...Acc, [K2]: KeyOf(K[K2], options) }
+  }, {}) as TFromProperties<K>
+}
+// ------------------------------------------------------------------
+// FromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromMappedResult<
+  R extends TMappedResult
+> = (
+  TFromProperties<R['properties']>
+)
+// prettier-ignore
+function FromMappedResult<
+  R extends TMappedResult
+>(R: R, options: SchemaOptions): TFromMappedResult<R> {
+  return FromProperties(R.properties, options) as TFromMappedResult<R>
+}
+// ------------------------------------------------------------------
+// KeyOfFromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TKeyOfFromMappedResult<
+  R extends TMappedResult,
+  P extends TProperties = TFromMappedResult<R>
+> = (
+  TMappedResult<P>
+)
+// prettier-ignore
+export function KeyOfFromMappedResult<
+  R extends TMappedResult,
+  P extends TProperties = TFromMappedResult<R>
+>(R: R, options: SchemaOptions): TMappedResult<P> {
+  const P = FromMappedResult(R, options) as unknown as P
+  return MappedResult(P) 
+}
diff --git a/src/type/keyof/keyof-property-keys.ts b/src/type/keyof/keyof-property-keys.ts
new file mode 100644
index 000000000..63cb1a49e
--- /dev/null
+++ b/src/type/keyof/keyof-property-keys.ts
@@ -0,0 +1,176 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import { type ZeroString, type UnionToTuple, Increment } from '../helpers/index'
+import type { TRecursive } from '../recursive/index'
+import type { TIntersect } from '../intersect/index'
+import type { TUnion } from '../union/index'
+import type { TTuple } from '../tuple/index'
+import type { TArray } from '../array/index'
+import type { TObject, TProperties } from '../object/index'
+import { SetUnionMany, SetIntersectMany, type TSetUnionMany, type TSetIntersectMany } from '../sets/index'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsRecord } from '../guard/type'
+// ------------------------------------------------------------------
+// FromRest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRest<T extends TSchema[], Acc extends PropertyKey[][] = []> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TFromRest<R, [...Acc, TKeyOfPropertyKeys<L>]>
+    : Acc
+)
+// prettier-ignore
+function FromRest<T extends TSchema[]>(T: [...T]): TFromRest<T> {
+  return T.reduce((Acc, L) => {
+    return [...Acc, KeyOfPropertyKeys(L)]
+  }, [] as PropertyKey[][]) as TFromRest<T>
+}
+// ------------------------------------------------------------------
+// FromIntersect
+// ------------------------------------------------------------------
+// prettier-ignore
+type FromIntersect<
+  T extends TSchema[], 
+  C extends PropertyKey[][] = TFromRest<T>,
+  R extends PropertyKey[] = TSetUnionMany<C>
+> = R
+// prettier-ignore
+function FromIntersect<T extends TSchema[]>(T: [...T]): FromIntersect<T> {
+  const C = FromRest(T) as PropertyKey[][]
+  const R = SetUnionMany(C)
+  return R as FromIntersect<T>
+}
+// ------------------------------------------------------------------
+// FromUnion
+// ------------------------------------------------------------------
+// prettier-ignore
+type FromUnion<
+  T extends TSchema[], 
+  C extends PropertyKey[][] = TFromRest<T>,
+  R extends PropertyKey[] = TSetIntersectMany<C>
+> = R
+// prettier-ignore
+function FromUnion<T extends TSchema[]>(T: [...T]): FromUnion<T> {
+  const C = FromRest(T) as PropertyKey[][]
+  const R = SetIntersectMany(C)
+  return R as FromUnion<T>
+}
+// ------------------------------------------------------------------
+// FromTuple
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromTuple<T extends TSchema[], I extends string = ZeroString, Acc extends PropertyKey[] = []> = 
+  T extends [infer _ extends TSchema, ...infer R extends TSchema[]]
+    ? TFromTuple<R, Increment<I>, [...Acc, I]>
+    : Acc
+// prettier-ignore
+function FromTuple<T extends TSchema[]>(T: [...T]): TFromTuple<T> {
+  return T.map((_, I) => I.toString()) as TFromTuple<T>
+}
+// ------------------------------------------------------------------
+// FromArray
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromArray<_ extends TSchema> = (
+  ['[number]']
+)
+// prettier-ignore
+function FromArray<_ extends TSchema>(_: _): TFromArray<_> {
+  return (
+    ['[number]']
+  )
+}
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperties<T extends TProperties> = (
+  UnionToTuple<keyof T>
+)
+// prettier-ignore
+function FromProperties<T extends TProperties>(T: T): TFromProperties<T> {
+  return (
+    globalThis.Object.getOwnPropertyNames(T)
+  ) as TFromProperties<T>
+}
+// ------------------------------------------------------------------
+// FromPatternProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromPatternProperties(patternProperties: Record<PropertyKey, TSchema>): string[] {
+  if(!includePatternProperties) return []
+  const patternPropertyKeys = globalThis.Object.getOwnPropertyNames(patternProperties)
+  return patternPropertyKeys.map(key => {
+    return (key[0] === '^' && key[key.length - 1] === '$') 
+      ? key.slice(1, key.length - 1) 
+      : key
+  })
+}
+// ------------------------------------------------------------------
+// KeyOfPropertyKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TKeyOfPropertyKeys<T extends TSchema> = (
+  T extends TRecursive<infer S> ? TKeyOfPropertyKeys<S> :
+  T extends TIntersect<infer S> ? FromIntersect<S> :
+  T extends TUnion<infer S> ? FromUnion<S> :
+  T extends TTuple<infer S> ? TFromTuple<S> :
+  T extends TArray<infer S> ? TFromArray<S> :
+  T extends TObject<infer S> ? TFromProperties<S> :
+  []
+)
+/** Returns a tuple of PropertyKeys derived from the given TSchema. */
+// prettier-ignore
+export function KeyOfPropertyKeys<T extends TSchema>(T: T): TKeyOfPropertyKeys<T> {
+  return (
+    IsIntersect(T) ? FromIntersect(T.allOf) :
+    IsUnion(T) ? FromUnion(T.anyOf) :
+    IsTuple(T) ? FromTuple(T.items ?? []) :
+    IsArray(T) ? FromArray(T.items) :
+    IsObject(T) ? FromProperties(T.properties) :
+    IsRecord(T) ? FromPatternProperties(T.patternProperties) :
+    []
+  ) as TKeyOfPropertyKeys<T>
+}
+// ----------------------------------------------------------------
+// KeyOfPattern
+// ----------------------------------------------------------------
+let includePatternProperties = false
+/** Returns a regular expression pattern derived from the given TSchema */
+export function KeyOfPattern(schema: TSchema): string {
+  includePatternProperties = true
+  const keys = KeyOfPropertyKeys(schema)
+  includePatternProperties = false
+  const pattern = keys.map((key) => `(${key})`)
+  return `^(${pattern.join('|')})$`
+}
diff --git a/src/type/keyof/keyof.ts b/src/type/keyof/keyof.ts
new file mode 100644
index 000000000..1c6192136
--- /dev/null
+++ b/src/type/keyof/keyof.ts
@@ -0,0 +1,85 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import type { Assert, Ensure } from '../helpers/index'
+import type { TMappedResult } from '../mapped/index'
+import type { SchemaOptions } from '../schema/index'
+import { Literal, type TLiteral, type TLiteralValue } from '../literal/index'
+import { Number, type TNumber } from '../number/index'
+import { KeyOfPropertyKeys, type TKeyOfPropertyKeys } from './keyof-property-keys'
+import { UnionEvaluated, type TUnionEvaluated } from '../union/index'
+import { CloneType } from '../clone/type'
+import { KeyOfFromMappedResult, type TKeyOfFromMappedResult } from './keyof-from-mapped-result'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsMappedResult } from '../guard/type'
+// ------------------------------------------------------------------
+// FromPropertyKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromPropertyKeys<T extends PropertyKey[], Acc extends TSchema[] = []> = (
+  T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+    ? L extends '[number]'
+      ? TFromPropertyKeys<R, [...Acc, TNumber]>
+      : TFromPropertyKeys<R, [...Acc, TLiteral<Assert<L, TLiteralValue>>]>
+    : Acc
+)
+// prettier-ignore
+function FromPropertyKeys<T extends PropertyKey[]>(T: [...T]): TFromPropertyKeys<T> {
+  return T.map(L => L === '[number]' ? Number() : Literal(L as TLiteralValue)) as TFromPropertyKeys<T>
+}
+// ------------------------------------------------------------------
+// KeyOfTypeResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TKeyOf<
+  T extends TSchema, 
+  K extends PropertyKey[] = TKeyOfPropertyKeys<T>,
+  S extends TSchema[] = TFromPropertyKeys<K>,
+  U = TUnionEvaluated<S>
+> = (
+  Ensure<U>
+)
+/** `[Json]` Creates a KeyOf type */
+export function KeyOf<T extends TMappedResult>(T: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>
+/** `[Json]` Creates a KeyOf type */
+export function KeyOf<T extends TSchema>(T: T, options?: SchemaOptions): TKeyOf<T>
+/** `[Json]` Creates a KeyOf type */
+export function KeyOf(T: TSchema, options: SchemaOptions = {}): any {
+  if (IsMappedResult(T)) {
+    return KeyOfFromMappedResult(T, options)
+  } else {
+    const K = KeyOfPropertyKeys(T)
+    const S = FromPropertyKeys(K)
+    const U = UnionEvaluated(S)
+    return CloneType(U, options)
+  }
+}
diff --git a/src/type/literal/index.ts b/src/type/literal/index.ts
new file mode 100644
index 000000000..d4cb53ef2
--- /dev/null
+++ b/src/type/literal/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './literal'
diff --git a/src/type/literal/literal.ts b/src/type/literal/literal.ts
new file mode 100644
index 000000000..8754ffd7c
--- /dev/null
+++ b/src/type/literal/literal.ts
@@ -0,0 +1,53 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+// ------------------------------------------------------------------
+// TLiteralValue
+// ------------------------------------------------------------------
+export type TLiteralValue = boolean | number | string // | bigint - supported but variant disable due to potential numeric type conflicts
+
+// ------------------------------------------------------------------
+// TLiteral
+// ------------------------------------------------------------------
+export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
+  [Kind]: 'Literal'
+  static: T
+  const: T
+}
+/** `[Json]` Creates a Literal type */
+export function Literal<T extends TLiteralValue>(value: T, options: SchemaOptions = {}): TLiteral<T> {
+  return {
+    ...options,
+    [Kind]: 'Literal',
+    const: value,
+    type: typeof value as 'string' | 'number' | 'boolean',
+  } as unknown as TLiteral<T>
+}
diff --git a/src/type/mapped/index.ts b/src/type/mapped/index.ts
new file mode 100644
index 000000000..5e1f19bb1
--- /dev/null
+++ b/src/type/mapped/index.ts
@@ -0,0 +1,31 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './mapped-key'
+export * from './mapped-result'
+export * from './mapped'
diff --git a/src/type/mapped/mapped-key.ts b/src/type/mapped/mapped-key.ts
new file mode 100644
index 000000000..24ad79526
--- /dev/null
+++ b/src/type/mapped/mapped-key.ts
@@ -0,0 +1,43 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+export interface TMappedKey<T extends PropertyKey[] = PropertyKey[]> extends TSchema {
+  [Kind]: 'MappedKey'
+  static: T[number]
+  keys: T
+}
+// prettier-ignore
+export function MappedKey<T extends PropertyKey[]>(T: [...T]): TMappedKey<T> {
+  return {
+    [Kind]: 'MappedKey',
+    keys: T
+  } as unknown as TMappedKey<T> 
+}
diff --git a/src/type/mapped/mapped-result.ts b/src/type/mapped/mapped-result.ts
new file mode 100644
index 000000000..84908ea3b
--- /dev/null
+++ b/src/type/mapped/mapped-result.ts
@@ -0,0 +1,44 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import type { TProperties } from '../object/index'
+import { Kind } from '../symbols/index'
+
+export interface TMappedResult<T extends TProperties = TProperties> extends TSchema {
+  [Kind]: 'MappedResult'
+  properties: T
+  static: unknown
+}
+// prettier-ignore
+export function MappedResult<T extends TProperties>(properties: T): TMappedResult<T> {
+  return {
+    [Kind]: 'MappedResult',
+    properties
+  } as never
+}
diff --git a/src/type/mapped/mapped.ts b/src/type/mapped/mapped.ts
new file mode 100644
index 000000000..49ab254e7
--- /dev/null
+++ b/src/type/mapped/mapped.ts
@@ -0,0 +1,283 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import type { Ensure, Evaluate, Assert } from '../helpers/index'
+import { Kind, OptionalKind, ReadonlyKind } from '../symbols/index'
+import { CloneType } from '../clone/type'
+import { Discard } from '../discard/index'
+// evaluation types
+import { Array, type TArray } from '../array/index'
+import { AsyncIterator, type TAsyncIterator } from '../async-iterator/index'
+import { Constructor, type TConstructor } from '../constructor/index'
+import { Function as FunctionType, type TFunction } from '../function/index'
+import { IndexPropertyKeys, type TIndexPropertyKeys } from '../indexed/index'
+import { Intersect, type TIntersect } from '../intersect/index'
+import { Iterator, type TIterator } from '../iterator/index'
+import { Literal, type TLiteral, type TLiteralValue } from '../literal/index'
+import { Object, type TObject, type TProperties, type ObjectOptions } from '../object/index'
+import { Optional, type TOptional } from '../optional/index'
+import { Promise, type TPromise } from '../promise/index'
+import { Readonly, type TReadonly } from '../readonly/index'
+import { Tuple, type TTuple } from '../tuple/index'
+import { Union, type TUnion } from '../union/index'
+// operator
+import { SetIncludes, type TSetIncludes } from '../sets/index'
+// mapping types
+import { MappedResult, type TMappedResult } from './mapped-result'
+import type { TMappedKey } from './mapped-key'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+import {
+  IsArray,
+  IsAsyncIterator,
+  IsConstructor,
+  IsFunction,
+  IsIntersect,
+  IsIterator,
+  IsReadonly,
+  IsMappedResult,
+  IsMappedKey,
+  IsObject,
+  IsOptional,
+  IsPromise,
+  IsSchema,
+  IsTuple,
+  IsUnion,
+} from '../guard/type'
+// ------------------------------------------------------------------
+// FromMappedResult
+//
+// We only evaluate the context (K) if it is a keyof P. Otherwise we
+// remap the back to a MappedResult with the expectation it will be
+// evaluated by an outer context. Note that overlapping keys in the
+// outer context may result in incorrect evaluation of the outer
+// context. Reproduction code below.
+//
+// type S = {
+//   [L in 'A' | 'B']: {
+//     [R in 'B' | 'C']: [L, R] // issue: overlapping 'B'
+//   }
+// }
+//
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromMappedResult<K extends PropertyKey, P extends TProperties> = (
+  K extends keyof P 
+    ? FromSchemaType<K, P[K]>
+    : TMappedResult<P>
+)
+// prettier-ignore
+function FromMappedResult<K extends PropertyKey, P extends TProperties>(K: K, P: P): TFromMappedResult<K, P> {
+  return (
+    K in P 
+      ? FromSchemaType(K, P[K as string])
+      : MappedResult(P)
+  ) as TFromMappedResult<K, P>
+}
+// ------------------------------------------------------------------
+// MappedKeyToKnownMappedResultProperties
+//
+// This path is used when K is in the PropertyKey set of P. This is
+// the standard (fast) path when not nesting mapped types.
+// ------------------------------------------------------------------
+// prettier-ignore
+type TMappedKeyToKnownMappedResultProperties<K extends PropertyKey> = {
+  [_ in K]: TLiteral<Assert<K, TLiteralValue>>
+}
+// prettier-ignore
+function MappedKeyToKnownMappedResultProperties<K extends PropertyKey>(K: K): TMappedKeyToKnownMappedResultProperties<K> {
+  return { [K]: Literal(K as TLiteralValue) } as TMappedKeyToKnownMappedResultProperties<K>
+}
+// ------------------------------------------------------------------
+// MappedKeyToUnknownMappedResultProperties
+//
+// This path is used when K is outside the set of P. This indicates
+// that the K originates from outside the current mappped type. This
+// path is very slow as we need to construct a full MappedResult
+// to be evaluated by the exterior mapped type.
+// ------------------------------------------------------------------
+// prettier-ignore
+type TMappedKeyToUnknownMappedResultProperties<P extends PropertyKey[], Acc extends TProperties = {}> = (
+  P extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+    ? TMappedKeyToUnknownMappedResultProperties<R, Acc & { [_ in L]: TLiteral<Assert<L, TLiteralValue>> }>
+    : Acc
+)
+// prettier-ignore
+function MappedKeyToUnknownMappedResultProperties<P extends PropertyKey[]>(P: [...P]): TMappedKeyToUnknownMappedResultProperties<P> {
+  return P.reduce((Acc, L) => {
+    return { ...Acc, [L]: Literal(L as TLiteralValue) }
+  }, {} as TProperties) as TMappedKeyToUnknownMappedResultProperties<P>
+}
+// ------------------------------------------------------------------
+// MappedKeyToMappedResultProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TMappedKeyToMappedResultProperties<K extends PropertyKey, P extends PropertyKey[]> = (
+  TSetIncludes<P, K> extends true
+    ? TMappedKeyToKnownMappedResultProperties<K>
+    : TMappedKeyToUnknownMappedResultProperties<P>
+)
+// prettier-ignore
+function MappedKeyToMappedResultProperties<K extends PropertyKey, P extends PropertyKey[]>(K: K, P: [...P]): TMappedKeyToMappedResultProperties<K, P> {
+  return (
+    SetIncludes(P, K)
+      ? MappedKeyToKnownMappedResultProperties(K)
+      : MappedKeyToUnknownMappedResultProperties(P)
+  ) as TMappedKeyToMappedResultProperties<K, P>
+}
+// prettier-ignore
+type TFromMappedKey<
+  K extends PropertyKey, 
+  P extends PropertyKey[],
+  R extends TProperties = TMappedKeyToMappedResultProperties<K, P>
+> = (
+  TFromMappedResult<K, R>
+)
+// prettier-ignore
+function FromMappedKey<K extends PropertyKey, P extends PropertyKey[]>(K: K, P: [...P]) {
+  const R = MappedKeyToMappedResultProperties(K, P)
+  return FromMappedResult(K, R)
+}
+// ------------------------------------------------------------------
+// FromRest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRest<K extends PropertyKey, T extends TSchema[], Acc extends TSchema[] = []> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TFromRest<K, R, [...Acc, FromSchemaType<K, L>]>
+    : Acc
+)
+// prettier-ignore
+function FromRest<K extends PropertyKey, T extends TSchema[]>(K: K, T: [...T]): TFromRest<K, T> {
+  return T.map(L => FromSchemaType(K, L)) as TFromRest<K, T>
+}
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type FromProperties<K extends PropertyKey, T extends TProperties, R extends TProperties = Evaluate<{
+  [K2 in keyof T]: FromSchemaType<K, T[K2]>
+}>> = R
+// prettier-ignore
+function FromProperties<K extends PropertyKey, T extends TProperties>(K: K, T: T): FromProperties<K, T> {
+  return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K2) => {
+    return { ...Acc, [K2]: FromSchemaType(K, T[K2]) }
+  }, {}) as FromProperties<K, T>
+}
+// ------------------------------------------------------------------
+// FromMappedPropertyKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type FromSchemaType<K extends PropertyKey, T extends TSchema> = (
+  // unevaluated modifier types
+  T extends TReadonly<infer S> ? TReadonly<FromSchemaType<K, S>> :
+  T extends TOptional<infer S> ? TOptional<FromSchemaType<K, S>> :
+  // unevaluated mapped types
+  T extends TMappedResult<infer P> ? TFromMappedResult<K, P> :
+  T extends TMappedKey<infer P> ? TFromMappedKey<K, P> :
+  // unevaluated types
+  T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<K, S>, FromSchemaType<K, R>> :
+  T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<K, S>, FromSchemaType<K, R>> :
+  T extends TAsyncIterator<infer S> ? TAsyncIterator<FromSchemaType<K, S>> :
+  T extends TIterator<infer S> ? TIterator<FromSchemaType<K, S>> :
+  T extends TIntersect<infer S> ? TIntersect<TFromRest<K, S>> :
+  T extends TUnion<infer S> ? TUnion<TFromRest<K, S>> :
+  T extends TTuple<infer S> ? TTuple<TFromRest<K, S>> :
+  T extends TObject<infer S> ? TObject<FromProperties<K, S>> :
+  T extends TArray<infer S> ? TArray<FromSchemaType<K, S>> :
+  T extends TPromise<infer S> ? TPromise<FromSchemaType<K, S>> :
+  T
+)
+// prettier-ignore
+function FromSchemaType<K extends PropertyKey, T extends TSchema>(K: K, T: T): FromSchemaType<K, T> {
+  return (
+    // unevaluated modifier types
+    IsOptional(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]) as TSchema)) :
+    IsReadonly(T) ? Readonly(FromSchemaType(K, Discard(T, [ReadonlyKind]) as TSchema)) :
+    // unevaluated mapped types
+    IsMappedResult(T) ? FromMappedResult(K, T.properties) :
+    IsMappedKey(T) ? FromMappedKey(K, T.keys) :
+    // unevaluated types
+    IsConstructor(T) ? Constructor(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
+    IsFunction(T) ? FunctionType(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
+    IsAsyncIterator(T) ? AsyncIterator(FromSchemaType(K, T.items)) :
+    IsIterator(T) ? Iterator(FromSchemaType(K, T.items)) :
+    IsIntersect(T) ? Intersect(FromRest(K, T.allOf)) :
+    IsUnion(T) ? Union(FromRest(K, T.anyOf)) :
+    IsTuple(T) ? Tuple(FromRest(K, T.items ?? [])) :
+    IsObject(T) ? Object(FromProperties(K, T.properties)) :
+    IsArray(T) ? Array(FromSchemaType(K, T.items)) :
+    IsPromise(T) ? Promise(FromSchemaType(K, T.item)) :
+    T
+  ) as FromSchemaType<K, T>
+}
+// ------------------------------------------------------------------
+// FromMappedFunctionReturnType
+// ------------------------------------------------------------------
+// prettier-ignore
+type FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema, Acc extends TProperties = {}> = (
+  K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+    ? FromMappedFunctionReturnType<R, T, Acc & { [_ in L]: FromSchemaType<L, T> }>
+    : Acc
+)
+// prettier-ignore
+function FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T, Acc: TProperties = {}): FromMappedFunctionReturnType<K, T> {
+  return K.reduce((Acc, L) => {
+    return { ...Acc, [L]: FromSchemaType(L, T) }
+  }, {} as TProperties) as FromMappedFunctionReturnType<K, T>
+}
+// ------------------------------------------------------------------
+// TMappedFunction
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TMappedFunction<K extends PropertyKey[], I = TMappedKey<K>> = (T: I) => TSchema
+// ------------------------------------------------------------------
+// TMapped
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TMapped<
+  K extends PropertyKey[], 
+  F extends TMappedFunction<K>,
+  R extends TProperties = Evaluate<FromMappedFunctionReturnType<K, ReturnType<F>>>, 
+> = Ensure<TObject<R>>
+
+/** `[Json]` Creates a Mapped object type */
+export function Mapped<K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>, F extends TMappedFunction<I> = TMappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R
+/** `[Json]` Creates a Mapped object type */
+export function Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = TMappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R
+/** `[Json]` Creates a Mapped object type */
+export function Mapped(key: any, map: Function, options: ObjectOptions = {}) {
+  const K = IsSchema(key) ? IndexPropertyKeys(key) : (key as PropertyKey[])
+  const RT = map({ [Kind]: 'MappedKey', keys: K } as TMappedKey)
+  const R = FromMappedFunctionReturnType(K, RT)
+  return CloneType(Object(R), options)
+}
diff --git a/src/type/never/index.ts b/src/type/never/index.ts
new file mode 100644
index 000000000..913504405
--- /dev/null
+++ b/src/type/never/index.ts
@@ -0,0 +1,28 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+export * from './never'
diff --git a/src/type/never/never.ts b/src/type/never/never.ts
new file mode 100644
index 000000000..7fc22f7fe
--- /dev/null
+++ b/src/type/never/never.ts
@@ -0,0 +1,44 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+export interface TNever extends TSchema {
+  [Kind]: 'Never'
+  static: never
+  not: {}
+}
+/** `[Json]` Creates a Never type */
+export function Never(options: SchemaOptions = {}): TNever {
+  return {
+    ...options,
+    [Kind]: 'Never',
+    not: {},
+  } as unknown as TNever
+}
diff --git a/src/type/not/index.ts b/src/type/not/index.ts
new file mode 100644
index 000000000..49cf9dca8
--- /dev/null
+++ b/src/type/not/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './not'
diff --git a/src/type/not/not.ts b/src/type/not/not.ts
new file mode 100644
index 000000000..df0a93a74
--- /dev/null
+++ b/src/type/not/not.ts
@@ -0,0 +1,46 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Static } from '../static/index'
+import { CloneType } from '../clone/type'
+import { Kind } from '../symbols/index'
+
+export interface TNot<T extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'Not'
+  static: T extends TNot<infer U> ? Static<U> : unknown
+  not: T
+}
+/** `[Json]` Creates a Not type */
+export function Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T> {
+  return {
+    ...options,
+    [Kind]: 'Not',
+    not: CloneType(schema),
+  } as unknown as TNot<T>
+}
diff --git a/src/type/null/index.ts b/src/type/null/index.ts
new file mode 100644
index 000000000..281bef4f4
--- /dev/null
+++ b/src/type/null/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './null'
diff --git a/src/type/null/null.ts b/src/type/null/null.ts
new file mode 100644
index 000000000..6dad0c7d8
--- /dev/null
+++ b/src/type/null/null.ts
@@ -0,0 +1,44 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+export interface TNull extends TSchema {
+  [Kind]: 'Null'
+  static: null
+  type: 'null'
+}
+/** `[Json]` Creates a Null type */
+export function Null(options: SchemaOptions = {}): TNull {
+  return {
+    ...options,
+    [Kind]: 'Null',
+    type: 'null',
+  } as unknown as TNull
+}
diff --git a/src/type/number/index.ts b/src/type/number/index.ts
new file mode 100644
index 000000000..c43f623c7
--- /dev/null
+++ b/src/type/number/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './number'
diff --git a/src/type/number/number.ts b/src/type/number/number.ts
new file mode 100644
index 000000000..1ae3ed8fd
--- /dev/null
+++ b/src/type/number/number.ts
@@ -0,0 +1,51 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+export interface NumberOptions extends SchemaOptions {
+  exclusiveMaximum?: number
+  exclusiveMinimum?: number
+  maximum?: number
+  minimum?: number
+  multipleOf?: number
+}
+export interface TNumber extends TSchema, NumberOptions {
+  [Kind]: 'Number'
+  static: number
+  type: 'number'
+}
+/** `[Json]` Creates a Number type */
+export function Number(options: NumberOptions = {}): TNumber {
+  return {
+    ...options,
+    [Kind]: 'Number',
+    type: 'number',
+  } as unknown as TNumber
+}
diff --git a/src/type/object/index.ts b/src/type/object/index.ts
new file mode 100644
index 000000000..5bebd5824
--- /dev/null
+++ b/src/type/object/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './object'
diff --git a/src/type/object/object.ts b/src/type/object/object.ts
new file mode 100644
index 000000000..a68c53f9e
--- /dev/null
+++ b/src/type/object/object.ts
@@ -0,0 +1,99 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Static } from '../static/index'
+import type { Evaluate } from '../helpers/index'
+import type { TReadonly } from '../readonly/index'
+import type { TOptional } from '../optional/index'
+import { CloneType } from '../clone/type'
+import { Kind } from '../symbols/index'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsOptional, IsSchema } from '../guard/type'
+
+// ------------------------------------------------------------------
+// ObjectStatic
+// ------------------------------------------------------------------
+type ReadonlyOptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never }[keyof T]
+type ReadonlyPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? never : K) : never }[keyof T]
+type OptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : K) : never }[keyof T]
+type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>
+
+// prettier-ignore
+type ObjectStaticProperties<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(
+  Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> &
+  Readonly<Pick<R, ReadonlyPropertyKeys<T>>> &
+  Partial<Pick<R, OptionalPropertyKeys<T>>> &
+  Required<Pick<R, RequiredPropertyKeys<T>>>
+)>
+// prettier-ignore
+type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, {
+  [K in keyof T]: Static<T[K], P>
+}>
+// ------------------------------------------------------------------
+// TProperties
+// ------------------------------------------------------------------
+export type TPropertyKey = string | number // Consider making this PropertyKey
+export type TProperties = Record<TPropertyKey, TSchema>
+// ------------------------------------------------------------------
+// TObject
+// ------------------------------------------------------------------
+export type TAdditionalProperties = undefined | TSchema | boolean
+export interface ObjectOptions extends SchemaOptions {
+  /** Additional property constraints for this object */
+  additionalProperties?: TAdditionalProperties
+  /** The minimum number of properties allowed on this object */
+  minProperties?: number
+  /** The maximum number of properties allowed on this object */
+  maxProperties?: number
+}
+export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
+  [Kind]: 'Object'
+  static: ObjectStatic<T, this['params']>
+  additionalProperties?: TAdditionalProperties
+  type: 'object'
+  properties: T
+  required?: string[]
+}
+/** `[Json]` Creates an Object type */
+export function _Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
+  const propertyKeys = globalThis.Object.getOwnPropertyNames(properties)
+  const optionalKeys = propertyKeys.filter((key) => IsOptional(properties[key]))
+  const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name))
+  const clonedAdditionalProperties = IsSchema(options.additionalProperties) ? { additionalProperties: CloneType(options.additionalProperties) } : {}
+  const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: CloneType(properties[key]) }), {} as TProperties)
+  return (requiredKeys.length > 0
+    ? { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys }
+    : { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties }) as unknown as TObject<T>
+}
+
+/** `[Json]` Creates an Object type */
+export const Object = _Object
diff --git a/src/type/omit/index.ts b/src/type/omit/index.ts
new file mode 100644
index 000000000..c5e44415a
--- /dev/null
+++ b/src/type/omit/index.ts
@@ -0,0 +1,31 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './omit-from-mapped-key'
+export * from './omit-from-mapped-result'
+export * from './omit'
diff --git a/src/type/omit/omit-from-mapped-key.ts b/src/type/omit/omit-from-mapped-key.ts
new file mode 100644
index 000000000..efac50d8f
--- /dev/null
+++ b/src/type/omit/omit-from-mapped-key.ts
@@ -0,0 +1,111 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { TProperties } from '../object/index'
+import { MappedResult, type TMappedResult, type TMappedKey } from '../mapped/index'
+import { Omit, type TOmit } from './omit'
+
+// ------------------------------------------------------------------
+// FromPropertyKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromPropertyKey<
+  T extends TSchema,
+  K extends PropertyKey,
+> = {
+    [_ in K]: TOmit<T, [K]>
+  }
+// prettier-ignore
+function FromPropertyKey<
+  T extends TSchema,
+  K extends PropertyKey,
+>(T: T, K: K, options: SchemaOptions): TFromPropertyKey<T, K> {
+  return {
+    [K]: Omit(T, [K], options)
+  } as TFromPropertyKey<T, K>
+}
+// ------------------------------------------------------------------
+// FromPropertyKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromPropertyKeys<
+  T extends TSchema,
+  K extends PropertyKey[],
+  Acc extends TProperties = {}
+> = (
+  K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]]
+    ? TFromPropertyKeys<T, RK, Acc & TFromPropertyKey<T, LK>>
+    : Acc
+)
+// prettier-ignore
+function FromPropertyKeys<
+  T extends TSchema,
+  K extends PropertyKey[]
+>(T: T, K: [...K], options: SchemaOptions): TFromPropertyKeys<T, K> {
+  return K.reduce((Acc, LK) => {
+    return { ...Acc, ...FromPropertyKey(T, LK, options) }
+  }, {} as TProperties) as TFromPropertyKeys<T, K>
+}
+// ------------------------------------------------------------------
+// FromMappedKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromMappedKey<
+  T extends TSchema,
+  K extends TMappedKey,
+> = (
+  TFromPropertyKeys<T, K['keys']>
+)
+// prettier-ignore
+function FromMappedKey<
+  T extends TSchema,
+  K extends TMappedKey,
+>(T: T, K: K, options: SchemaOptions): TFromMappedKey<T, K> {
+  return FromPropertyKeys(T, K.keys, options) as TFromMappedKey<T, K>
+}
+// ------------------------------------------------------------------
+// OmitFromMappedKey
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TOmitFromMappedKey<
+  T extends TSchema,
+  K extends TMappedKey,
+  P extends TProperties = TFromMappedKey<T, K>
+> = (
+  TMappedResult<P>
+)
+// prettier-ignore
+export function OmitFromMappedKey<
+  T extends TSchema,
+  K extends TMappedKey,
+  P extends TProperties = TFromMappedKey<T, K>
+>(T: T, K: K, options: SchemaOptions): TMappedResult<P> {
+  const P = FromMappedKey(T, K, options) as unknown as P
+  return MappedResult(P) 
+}
diff --git a/src/type/omit/omit-from-mapped-result.ts b/src/type/omit/omit-from-mapped-result.ts
new file mode 100644
index 000000000..c6dd8b9a7
--- /dev/null
+++ b/src/type/omit/omit-from-mapped-result.ts
@@ -0,0 +1,89 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { SchemaOptions } from '../schema/index'
+import type { TProperties } from '../object/index'
+import { MappedResult, type TMappedResult } from '../mapped/index'
+import { Omit, type TOmit } from './omit'
+
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperties<
+  P extends TProperties,
+  K extends PropertyKey[],
+> = (
+  { [K2 in keyof P]: TOmit<P[K2], K> }   
+)
+// prettier-ignore
+function FromProperties<
+  P extends TProperties,
+  K extends PropertyKey[],
+>(P: P, K: [...K], options: SchemaOptions): TFromProperties<P, K> {
+  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+    return {...Acc, [K2]: Omit(P[K2], K, options) }
+  }, {}) as TFromProperties<P, K>
+}
+// ------------------------------------------------------------------
+// FromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromMappedResult<
+  R extends TMappedResult,
+  K extends PropertyKey[],
+> = (
+  TFromProperties<R['properties'], K>
+)
+// prettier-ignore
+function FromMappedResult<
+  R extends TMappedResult,
+  K extends PropertyKey[]
+>(R: R, K: [...K], options: SchemaOptions): TFromMappedResult<R, K> {
+  return FromProperties(R.properties, K, options) as TFromMappedResult<R, K>
+}
+// ------------------------------------------------------------------
+// TOmitFromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TOmitFromMappedResult<
+  T extends TMappedResult,
+  K extends PropertyKey[],
+  P extends TProperties = TFromMappedResult<T, K>
+> = (
+  TMappedResult<P>
+)
+// prettier-ignore
+export function OmitFromMappedResult<
+  R extends TMappedResult,
+  K extends PropertyKey[],
+  P extends TProperties = TFromMappedResult<R, K>
+>(R: R, K: [...K], options: SchemaOptions): TMappedResult<P> {
+  const P = FromMappedResult(R, K, options) as unknown as P
+  return MappedResult(P) 
+}
diff --git a/src/type/omit/omit.ts b/src/type/omit/omit.ts
new file mode 100644
index 000000000..e0afd1060
--- /dev/null
+++ b/src/type/omit/omit.ts
@@ -0,0 +1,132 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { TupleToUnion, Evaluate } from '../helpers/index'
+import { type TRecursive } from '../recursive/index'
+import type { TMappedKey, TMappedResult } from '../mapped/index'
+import { Intersect, type TIntersect } from '../intersect/index'
+import { Union, type TUnion } from '../union/index'
+import { Object, type TObject, type TProperties } from '../object/index'
+import { IndexPropertyKeys, type TIndexPropertyKeys } from '../indexed/index'
+import { Discard } from '../discard/index'
+import { TransformKind } from '../symbols/index'
+import { CloneType } from '../clone/type'
+import { OmitFromMappedKey, type TOmitFromMappedKey } from './omit-from-mapped-key'
+import { OmitFromMappedResult, type TOmitFromMappedResult } from './omit-from-mapped-result'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsMappedKey, IsIntersect, IsUnion, IsObject, IsSchema, IsMappedResult } from '../guard/type'
+
+// ------------------------------------------------------------------
+// FromIntersect
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]] 
+    ? TFromIntersect<R, K, [...Acc, TOmitResolve<L, K>]>
+    : Acc
+)
+// prettier-ignore
+function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K) {
+  return T.map((T) => OmitResolve(T, K)) as TFromIntersect<T, K>
+}
+// ------------------------------------------------------------------
+// FromUnion
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]] 
+    ? TFromUnion<R, K, [...Acc, TOmitResolve<L, K>]>
+    : Acc
+)
+// prettier-ignore
+function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K) {
+  return T.map((T) => OmitResolve(T, K)) as TFromUnion<T, K>
+}
+// ------------------------------------------------------------------
+// FromProperty
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromProperty<T extends Record<any, any>, K extends PropertyKey>(T: T, K: K) {
+  const { [K]: _, ...R } = T
+  return R as TProperties
+}
+// prettier-ignore
+type TFromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Omit<T, I>>
+// prettier-ignore
+function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K) {
+  return K.reduce((T, K2) => {
+    return FromProperty(T, K2)
+  }, T as TProperties)
+}
+// ------------------------------------------------------------------
+// OmitResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TOmitResolve<T extends TProperties, K extends PropertyKey[]> = 
+  T extends TRecursive<infer S> ? TRecursive<TOmitResolve<S, K>> : 
+  T extends TIntersect<infer S> ? TIntersect<TFromIntersect<S, K>> : 
+  T extends TUnion<infer S> ? TUnion<TFromUnion<S, K>> : 
+  T extends TObject<infer S> ? TObject<TFromProperties<S, K>> : 
+  TObject<{}>
+// prettier-ignore
+export function OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TOmitResolve<T, K> {
+  return (
+    IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) : 
+    IsUnion(T) ? Union(FromUnion(T.anyOf, K)) : 
+    IsObject(T) ? Object(FromProperties(T.properties, K)) : 
+    Object({})
+  ) as TOmitResolve<T, K>
+}
+// ------------------------------------------------------------------
+// TOmit
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TOmit<T extends TSchema, K extends PropertyKey[]> = TOmitResolve<T, K>
+
+/** `[Json]` Constructs a type whose keys are omitted from the given type */
+export function Omit<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TOmitFromMappedResult<T, K>
+/** `[Json]` Constructs a type whose keys are omitted from the given type */
+export function Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TOmitFromMappedKey<T, K>
+/** `[Json]` Constructs a type whose keys are omitted from the given type */
+export function Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>
+/** `[Json]` Constructs a type whose keys are omitted from the given type */
+export function Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>
+export function Omit(T: TSchema, K: any, options: SchemaOptions = {}): any {
+  // mapped
+  if (IsMappedKey(K)) return OmitFromMappedKey(T, K, options)
+  if (IsMappedResult(T)) return OmitFromMappedResult(T, K, options)
+  // non-mapped
+  const I = IsSchema(K) ? IndexPropertyKeys(K) : (K as string[])
+  const D = Discard(T, [TransformKind, '$id', 'required']) as TSchema
+  const R = CloneType(OmitResolve(T, I), options)
+  return { ...D, ...R }
+}
diff --git a/src/type/optional/index.ts b/src/type/optional/index.ts
new file mode 100644
index 000000000..b861f8e73
--- /dev/null
+++ b/src/type/optional/index.ts
@@ -0,0 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './optional-from-mapped-result'
+export * from './optional'
diff --git a/src/type/optional/optional-from-mapped-result.ts b/src/type/optional/optional-from-mapped-result.ts
new file mode 100644
index 000000000..28ad4eaf6
--- /dev/null
+++ b/src/type/optional/optional-from-mapped-result.ts
@@ -0,0 +1,88 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TProperties } from '../object/index'
+import { MappedResult, type TMappedResult } from '../mapped/index'
+import { Optional, type TOptionalWithFlag } from './optional'
+
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperties<
+  P extends TProperties,
+  F extends boolean,
+> = (
+  { [K2 in keyof P]: TOptionalWithFlag<P[K2], F> }   
+)
+// prettier-ignore
+function FromProperties<
+  P extends TProperties,
+  F extends boolean,
+>(P: P, F: F): TFromProperties<P, F> {
+  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+    return {...Acc, [K2]: Optional(P[K2], F) }
+  }, {}) as TFromProperties<P, F>
+}
+// ------------------------------------------------------------------
+// FromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromMappedResult<
+  R extends TMappedResult,
+  F extends boolean,
+> = (
+  TFromProperties<R['properties'], F>
+)
+// prettier-ignore
+function FromMappedResult<
+  R extends TMappedResult,
+  F extends boolean,
+>(R: R, F: F): TFromMappedResult<R, F> {
+  return FromProperties(R.properties, F) as TFromMappedResult<R, F>
+}
+// ------------------------------------------------------------------
+// OptionalFromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TOptionalFromMappedResult<
+  R extends TMappedResult,
+  F extends boolean,
+  P extends TProperties = TFromMappedResult<R, F>
+> = (
+  TMappedResult<P>
+)
+// prettier-ignore
+export function OptionalFromMappedResult<
+  R extends TMappedResult,
+  F extends boolean,
+  P extends TProperties = TFromMappedResult<R, F>
+>(R: R, F: F): TMappedResult<P> {
+  const P = FromMappedResult(R, F) as unknown as P
+  return MappedResult(P) 
+}
diff --git a/src/type/optional/optional.ts b/src/type/optional/optional.ts
new file mode 100644
index 000000000..867117b4d
--- /dev/null
+++ b/src/type/optional/optional.ts
@@ -0,0 +1,82 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import type { Ensure } from '../helpers/index'
+import { OptionalKind } from '../symbols/index'
+import { CloneType } from '../clone/type'
+import { Discard } from '../discard/index'
+import type { TMappedResult } from '../mapped/index'
+
+import { OptionalFromMappedResult, type TOptionalFromMappedResult } from './optional-from-mapped-result'
+import { IsMappedResult } from '../guard/type'
+// ------------------------------------------------------------------
+// RemoveOptional
+// ------------------------------------------------------------------
+type TRemoveOptional<T extends TSchema> = T extends TOptional<infer S> ? S : T
+function RemoveOptional<T extends TSchema>(schema: T) {
+  return Discard(CloneType(schema), [OptionalKind])
+}
+// ------------------------------------------------------------------
+// AddOptional
+// ------------------------------------------------------------------
+type TAddOptional<T extends TSchema> = T extends TOptional<infer S> ? TOptional<S> : Ensure<TOptional<T>>
+function AddOptional<T extends TSchema>(schema: T) {
+  return { ...CloneType(schema), [OptionalKind]: 'Optional' }
+}
+// prettier-ignore
+export type TOptionalWithFlag<T extends TSchema, F extends boolean> = 
+  F extends false 
+    ? TRemoveOptional<T> 
+    : TAddOptional<T>
+// prettier-ignore
+function OptionalWithFlag<T extends TSchema, F extends boolean>(schema: T, F: F) {
+  return (
+    F === false
+      ? RemoveOptional(schema)
+      : AddOptional(schema)
+  )
+}
+// ------------------------------------------------------------------
+// Optional
+// ------------------------------------------------------------------
+export type TOptional<T extends TSchema> = T & { [OptionalKind]: 'Optional' }
+
+/** `[Json]` Creates a Optional property */
+export function Optional<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TOptionalFromMappedResult<T, F>
+/** `[Json]` Creates a Optional property */
+export function Optional<T extends TSchema, F extends boolean>(schema: T, enable: F): TOptionalWithFlag<T, F>
+/** `[Json]` Creates a Optional property */
+export function Optional<T extends TMappedResult>(schema: T): TOptionalFromMappedResult<T, true>
+/** `[Json]` Creates a Optional property */
+export function Optional<T extends TSchema>(schema: T): TOptionalWithFlag<T, true>
+/** `[Json]` Creates a Optional property */
+export function Optional(schema: TSchema, enable?: boolean): any {
+  const F = enable ?? true
+  return IsMappedResult(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F)
+}
diff --git a/src/type/parameters/index.ts b/src/type/parameters/index.ts
new file mode 100644
index 000000000..195fafbb0
--- /dev/null
+++ b/src/type/parameters/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './parameters'
diff --git a/src/type/parameters/parameters.ts b/src/type/parameters/parameters.ts
new file mode 100644
index 000000000..e2d4bb2f0
--- /dev/null
+++ b/src/type/parameters/parameters.ts
@@ -0,0 +1,43 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { TFunction } from '../function/index'
+import type { Ensure } from '../helpers/index'
+import { Tuple, type TTuple } from '../tuple/index'
+import { CloneRest } from '../clone/type'
+
+// ------------------------------------------------------------------
+// Parameters
+// ------------------------------------------------------------------
+export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>
+
+/** `[JavaScript]` Extracts the Parameters from the given Function type */
+export function Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options: SchemaOptions = {}): TParameters<T> {
+  return Tuple(CloneRest(schema.parameters), { ...options })
+}
diff --git a/src/type/partial/index.ts b/src/type/partial/index.ts
new file mode 100644
index 000000000..af7c8ba58
--- /dev/null
+++ b/src/type/partial/index.ts
@@ -0,0 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './partial-from-mapped-result'
+export * from './partial'
diff --git a/src/type/partial/partial-from-mapped-result.ts b/src/type/partial/partial-from-mapped-result.ts
new file mode 100644
index 000000000..23fb89d14
--- /dev/null
+++ b/src/type/partial/partial-from-mapped-result.ts
@@ -0,0 +1,83 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { SchemaOptions } from '../schema/index'
+import type { TProperties } from '../object/index'
+import { MappedResult, type TMappedResult } from '../mapped/index'
+import { Partial, type TPartial } from './partial'
+
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperties<
+  P extends TProperties
+> = (
+  { [K2 in keyof P]: TPartial<P[K2]> }   
+)
+// prettier-ignore
+function FromProperties<
+  P extends TProperties
+>(K: P, options: SchemaOptions): TFromProperties<P> {
+  return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+    return {...Acc, [K2]: Partial(K[K2], options) }
+  }, {}) as TFromProperties<P>
+}
+// ------------------------------------------------------------------
+// FromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromMappedResult<
+  R extends TMappedResult
+> = (
+  TFromProperties<R['properties']>
+)
+// prettier-ignore
+function FromMappedResult<
+  R extends TMappedResult
+>(R: R, options: SchemaOptions): TFromMappedResult<R> {
+  return FromProperties(R.properties, options) as TFromMappedResult<R>
+}
+// ------------------------------------------------------------------
+// TPartialFromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TPartialFromMappedResult<
+  R extends TMappedResult,
+  P extends TProperties = TFromMappedResult<R>
+> = (
+  TMappedResult<P>
+)
+// prettier-ignore
+export function PartialFromMappedResult<
+  R extends TMappedResult,
+  P extends TProperties = TFromMappedResult<R>
+>(R: R, options: SchemaOptions): TMappedResult<P> {
+  const P = FromMappedResult(R, options) as unknown as P
+  return MappedResult(P) 
+}
diff --git a/src/type/partial/partial.ts b/src/type/partial/partial.ts
new file mode 100644
index 000000000..d49dad8ce
--- /dev/null
+++ b/src/type/partial/partial.ts
@@ -0,0 +1,114 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Evaluate } from '../helpers/index'
+import type { TMappedResult } from '../mapped/index'
+import { type TReadonlyOptional } from '../readonly-optional/index'
+import { type TOptional, Optional } from '../optional/index'
+import { type TReadonly } from '../readonly/index'
+import { type TRecursive } from '../recursive/index'
+import { type TObject, type TProperties, Object } from '../object/index'
+import { type TIntersect, Intersect } from '../intersect/index'
+import { type TUnion, Union } from '../union/index'
+import { Discard } from '../discard/index'
+import { TransformKind } from '../symbols/index'
+import { CloneType } from '../clone/type'
+
+import { PartialFromMappedResult, type TPartialFromMappedResult } from './partial-from-mapped-result'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/type'
+// ------------------------------------------------------------------
+// FromRest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TFromRest<R, [...Acc, PartialResolve<L>]>
+    : Acc
+)
+// prettier-ignore
+function FromRest<T extends TSchema[]>(T: [...T]): TFromRest<T> {
+  return T.map(L => PartialResolve(L)) as TFromRest<T>
+}
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperties<T extends TProperties> = Evaluate<{
+  [K in keyof T]: 
+    T[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : 
+    T[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : 
+    T[K] extends (TOptional<infer S>) ? TOptional<S> : 
+    TOptional<T[K]>
+}>
+// prettier-ignore
+function FromProperties<T extends TProperties>(T: T) {
+  return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K) => {
+    return { ...Acc, [K]: Optional(T[K]) }
+  }, {} as TProperties)
+}
+// ------------------------------------------------------------------
+// PartialResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+type PartialResolve<T extends TSchema> = (
+  T extends TRecursive<infer S> ? TRecursive<PartialResolve<S>> :
+  T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> :
+  T extends TUnion<infer S> ? TUnion<TFromRest<S>> :
+  T extends TObject<infer S> ? TObject<TFromProperties<S>> :
+  TObject<{}>
+)
+// prettier-ignore
+function PartialResolve<T extends TSchema>(T: T): PartialResolve<T> {
+  return (
+    IsIntersect(T) ? Intersect(FromRest(T.allOf)) :
+    IsUnion(T) ? Union(FromRest(T.anyOf)) :
+    IsObject(T) ? Object(FromProperties(T.properties)) :
+    Object({})
+  ) as PartialResolve<T>
+}
+// ------------------------------------------------------------------
+// TPartial
+// ------------------------------------------------------------------
+export type TPartial<T extends TSchema> = PartialResolve<T>
+
+/** `[Json]` Constructs a type where all properties are optional */
+export function Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>
+/** `[Json]` Constructs a type where all properties are optional */
+export function Partial<T extends TSchema>(T: T, options?: SchemaOptions): TPartial<T>
+/** `[Json]` Constructs a type where all properties are optional */
+export function Partial(T: TSchema, options: SchemaOptions = {}): any {
+  if (IsMappedResult(T)) return PartialFromMappedResult(T, options)
+  const D = Discard(T, [TransformKind, '$id', 'required']) as TSchema
+  const R = CloneType(PartialResolve(T), options)
+  return { ...D, ...R } as any
+}
diff --git a/src/type/patterns/index.ts b/src/type/patterns/index.ts
new file mode 100644
index 000000000..7dbf0a210
--- /dev/null
+++ b/src/type/patterns/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './patterns'
diff --git a/src/type/patterns/patterns.ts b/src/type/patterns/patterns.ts
new file mode 100644
index 000000000..d9b9e8d79
--- /dev/null
+++ b/src/type/patterns/patterns.ts
@@ -0,0 +1,34 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export const PatternBoolean = '(true|false)'
+export const PatternNumber = '(0|[1-9][0-9]*)'
+export const PatternString = '(.*)'
+export const PatternBooleanExact = `^${PatternBoolean}$`
+export const PatternNumberExact = `^${PatternNumber}$`
+export const PatternStringExact = `^${PatternString}$`
diff --git a/src/type/pick/index.ts b/src/type/pick/index.ts
new file mode 100644
index 000000000..1fa9844ab
--- /dev/null
+++ b/src/type/pick/index.ts
@@ -0,0 +1,31 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './pick-from-mapped-key'
+export * from './pick-from-mapped-result'
+export * from './pick'
diff --git a/src/type/pick/pick-from-mapped-key.ts b/src/type/pick/pick-from-mapped-key.ts
new file mode 100644
index 000000000..b5e30fa1e
--- /dev/null
+++ b/src/type/pick/pick-from-mapped-key.ts
@@ -0,0 +1,111 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { TProperties } from '../object/index'
+import { MappedResult, type TMappedResult, type TMappedKey } from '../mapped/index'
+import { Pick, type TPick } from './pick'
+
+// ------------------------------------------------------------------
+// FromPropertyKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromPropertyKey<
+  T extends TSchema,
+  K extends PropertyKey,
+> = {
+    [_ in K]: TPick<T, [K]>
+  }
+// prettier-ignore
+function FromPropertyKey<
+  T extends TSchema,
+  K extends PropertyKey,
+>(T: T, K: K, options: SchemaOptions): TFromPropertyKey<T, K> {
+  return {
+    [K]: Pick(T, [K], options)
+  } as TFromPropertyKey<T, K>
+}
+// ------------------------------------------------------------------
+// FromPropertyKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromPropertyKeys<
+  T extends TSchema,
+  K extends PropertyKey[],
+  Acc extends TProperties = {}
+> = (
+  K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]]
+    ? TFromPropertyKeys<T, RK, Acc & TFromPropertyKey<T, LK>>
+    : Acc
+)
+// prettier-ignore
+function FromPropertyKeys<
+  T extends TSchema,
+  K extends PropertyKey[]
+>(T: T, K: [...K], options: SchemaOptions): TFromPropertyKeys<T, K> {
+  return K.reduce((Acc, LK) => {
+    return { ...Acc, ...FromPropertyKey(T, LK, options) }
+  }, {} as TProperties) as TFromPropertyKeys<T, K>
+}
+// ------------------------------------------------------------------
+// FromMappedKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromMappedKey<
+  T extends TSchema,
+  K extends TMappedKey,
+> = (
+  TFromPropertyKeys<T, K['keys']>
+)
+// prettier-ignore
+function FromMappedKey<
+  T extends TSchema,
+  K extends TMappedKey,
+>(T: T, K: K, options: SchemaOptions): TFromMappedKey<T, K> {
+  return FromPropertyKeys(T, K.keys, options) as TFromMappedKey<T, K>
+}
+// ------------------------------------------------------------------
+// PickFromMappedKey
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TPickFromMappedKey<
+  T extends TSchema,
+  K extends TMappedKey,
+  P extends TProperties = TFromMappedKey<T, K>
+> = (
+  TMappedResult<P>
+)
+// prettier-ignore
+export function PickFromMappedKey<
+  T extends TSchema,
+  K extends TMappedKey,
+  P extends TProperties = TFromMappedKey<T, K>
+>(T: T, K: K, options: SchemaOptions): TMappedResult<P> {
+  const P = FromMappedKey(T, K, options) as unknown as P
+  return MappedResult(P) 
+}
diff --git a/src/type/pick/pick-from-mapped-result.ts b/src/type/pick/pick-from-mapped-result.ts
new file mode 100644
index 000000000..4da4a6108
--- /dev/null
+++ b/src/type/pick/pick-from-mapped-result.ts
@@ -0,0 +1,89 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { SchemaOptions } from '../schema/index'
+import type { TProperties } from '../object/index'
+import { MappedResult, type TMappedResult } from '../mapped/index'
+import { Pick, type TPick } from './pick'
+
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperties<
+  P extends TProperties,
+  K extends PropertyKey[],
+> = (
+  { [K2 in keyof P]: TPick<P[K2], K> }   
+)
+// prettier-ignore
+function FromProperties<
+  P extends TProperties,
+  K extends PropertyKey[],
+>(P: P, K: [...K], options: SchemaOptions): TFromProperties<P, K> {
+  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+    return {...Acc, [K2]: Pick(P[K2], K, options) }
+  }, {}) as TFromProperties<P, K>
+}
+// ------------------------------------------------------------------
+// FromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromMappedResult<
+  R extends TMappedResult,
+  K extends PropertyKey[],
+> = (
+  TFromProperties<R['properties'], K>
+)
+// prettier-ignore
+function FromMappedResult<
+  R extends TMappedResult,
+  K extends PropertyKey[]
+>(R: R, K: [...K], options: SchemaOptions): TFromMappedResult<R, K> {
+  return FromProperties(R.properties, K, options) as TFromMappedResult<R, K>
+}
+// ------------------------------------------------------------------
+// PickFromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TPickFromMappedResult<
+  T extends TMappedResult,
+  K extends PropertyKey[],
+  P extends TProperties = TFromMappedResult<T, K>
+> = (
+  TMappedResult<P>
+)
+// prettier-ignore
+export function PickFromMappedResult<
+  R extends TMappedResult,
+  K extends PropertyKey[],
+  P extends TProperties = TFromMappedResult<R, K>
+>(R: R, K: [...K], options: SchemaOptions): TMappedResult<P> {
+  const P = FromMappedResult(R, K, options) as unknown as P
+  return MappedResult(P) 
+}
diff --git a/src/type/pick/pick.ts b/src/type/pick/pick.ts
new file mode 100644
index 000000000..336d47585
--- /dev/null
+++ b/src/type/pick/pick.ts
@@ -0,0 +1,122 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { TupleToUnion, Evaluate } from '../helpers/index'
+import { type TRecursive } from '../recursive/index'
+import { type TIntersect, Intersect } from '../intersect/index'
+import { type TUnion, Union } from '../union/index'
+import { type TObject, type TProperties, Object } from '../object/index'
+import type { TMappedKey, TMappedResult } from '../mapped/index'
+import { IndexPropertyKeys, type TIndexPropertyKeys } from '../indexed/index'
+import { Discard } from '../discard/index'
+import { TransformKind } from '../symbols/index'
+import { CloneType } from '../clone/type'
+import { PickFromMappedKey, type TPickFromMappedKey } from './pick-from-mapped-key'
+import { PickFromMappedResult, type TPickFromMappedResult } from './pick-from-mapped-result'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsMappedKey, IsMappedResult, IsIntersect, IsUnion, IsObject, IsSchema } from '../guard/type'
+// ------------------------------------------------------------------
+// FromIntersect
+// ------------------------------------------------------------------
+// prettier-ignore
+type FromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = 
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? FromIntersect<R, K, [...Acc, PickResolve<L, K>]>
+    : Acc
+function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K) {
+  return T.map((T) => PickResolve(T, K)) as FromIntersect<T, K>
+}
+// ------------------------------------------------------------------
+// FromUnion
+// ------------------------------------------------------------------
+// prettier-ignore
+type FromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = 
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? FromUnion<R, K, [...Acc, PickResolve<L, K>]>
+    : Acc
+// prettier-ignore
+function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K) {
+  return T.map((T) => PickResolve(T, K)) as FromUnion<T, K>
+}
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type FromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Pick<T, I & keyof T>>
+// prettier-ignore
+function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K) {
+  return K.reduce((Acc, K) => {
+    return K in T ? { ...Acc, [K]: T[K as keyof T] } : Acc
+  }, {})
+}
+// ------------------------------------------------------------------
+// PickResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+export type PickResolve<T extends TProperties, K extends PropertyKey[]> = 
+  T extends TRecursive<infer S> ? TRecursive<PickResolve<S, K>> : 
+  T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : 
+  T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : 
+  T extends TObject<infer S> ? TObject<FromProperties<S, K>> : 
+  TObject<{}>
+// prettier-ignore
+export function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): PickResolve<T, K> {
+  return (
+    IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) : 
+    IsUnion(T) ? Union(FromUnion(T.anyOf, K)) : 
+    IsObject(T) ? Object(FromProperties(T.properties, K)) : 
+    Object({})
+  ) as PickResolve<T, K>
+}
+// ------------------------------------------------------------------
+// TPick
+// ------------------------------------------------------------------
+export type TPick<T extends TSchema, K extends PropertyKey[]> = PickResolve<T, K>
+
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export function Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export function Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TPickFromMappedKey<T, K>
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export function Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export function Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>
+export function Pick(T: TSchema, K: any, options: SchemaOptions = {}): any {
+  // mapped
+  if (IsMappedKey(K)) return PickFromMappedKey(T, K, options)
+  if (IsMappedResult(T)) return PickFromMappedResult(T, K, options)
+  // non-mapped
+  const I = IsSchema(K) ? IndexPropertyKeys(K) : (K as string[])
+  const D = Discard(T, [TransformKind, '$id', 'required']) as TSchema
+  const R = CloneType(PickResolve(T, I), options)
+  return { ...D, ...R }
+}
diff --git a/src/type/promise/index.ts b/src/type/promise/index.ts
new file mode 100644
index 000000000..55150952e
--- /dev/null
+++ b/src/type/promise/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './promise'
diff --git a/src/type/promise/promise.ts b/src/type/promise/promise.ts
new file mode 100644
index 000000000..48b99d0ce
--- /dev/null
+++ b/src/type/promise/promise.ts
@@ -0,0 +1,48 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Static } from '../static/index'
+import { CloneType } from '../clone/type'
+import { Kind } from '../symbols/index'
+
+export interface TPromise<T extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'Promise'
+  static: Promise<Static<T, this['params']>>
+  type: 'Promise'
+  item: TSchema
+}
+/** `[JavaScript]` Creates a Promise type */
+export function Promise<T extends TSchema>(item: T, options: SchemaOptions = {}): TPromise<T> {
+  return {
+    ...options,
+    [Kind]: 'Promise',
+    type: 'Promise',
+    item: CloneType(item),
+  } as unknown as TPromise<T>
+}
diff --git a/src/type/readonly-optional/index.ts b/src/type/readonly-optional/index.ts
new file mode 100644
index 000000000..3e44a84c0
--- /dev/null
+++ b/src/type/readonly-optional/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './readonly-optional'
diff --git a/src/type/readonly-optional/readonly-optional.ts b/src/type/readonly-optional/readonly-optional.ts
new file mode 100644
index 000000000..788ede112
--- /dev/null
+++ b/src/type/readonly-optional/readonly-optional.ts
@@ -0,0 +1,38 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import { type TReadonly, Readonly } from '../readonly/index'
+import { type TOptional, Optional } from '../optional/index'
+
+export type TReadonlyOptional<T extends TSchema> = TOptional<T> & TReadonly<T>
+
+/** `[Json]` Creates a Readonly and Optional property */
+export function ReadonlyOptional<T extends TSchema>(schema: T): TReadonly<TOptional<T>> {
+  return Readonly(Optional(schema)) as TReadonly<TOptional<T>>
+}
diff --git a/src/type/readonly/index.ts b/src/type/readonly/index.ts
new file mode 100644
index 000000000..f39c08474
--- /dev/null
+++ b/src/type/readonly/index.ts
@@ -0,0 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './readonly-from-mapped-result'
+export * from './readonly'
diff --git a/src/type/readonly/readonly-from-mapped-result.ts b/src/type/readonly/readonly-from-mapped-result.ts
new file mode 100644
index 000000000..9f303bb40
--- /dev/null
+++ b/src/type/readonly/readonly-from-mapped-result.ts
@@ -0,0 +1,88 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TProperties } from '../object/index'
+import { MappedResult, type TMappedResult } from '../mapped/index'
+import { Readonly, type TReadonlyWithFlag } from './readonly'
+
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperties<
+  P extends TProperties,
+  F extends boolean,
+> = (
+  { [K2 in keyof P]: TReadonlyWithFlag<P[K2], F> }   
+)
+// prettier-ignore
+function FromProperties<
+  P extends TProperties,
+  F extends boolean,
+>(K: P, F: F): TFromProperties<P, F> {
+  return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+    return {...Acc, [K2]: Readonly(K[K2], F) }
+  }, {}) as TFromProperties<P, F>
+}
+// ------------------------------------------------------------------
+// FromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromMappedResult<
+  R extends TMappedResult,
+  F extends boolean,
+> = (
+    TFromProperties<R['properties'], F>
+  )
+// prettier-ignore
+function FromMappedResult<
+  R extends TMappedResult,
+  F extends boolean,
+>(R: R, F: F): TFromMappedResult<R, F> {
+  return FromProperties(R.properties, F) as TFromMappedResult<R, F>
+}
+// ------------------------------------------------------------------
+// ReadonlyFromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TReadonlyFromMappedResult<
+  R extends TMappedResult,
+  F extends boolean,
+  P extends TProperties = TFromMappedResult<R, F>
+> = (
+  TMappedResult<P>
+)
+// prettier-ignore
+export function ReadonlyFromMappedResult<
+  R extends TMappedResult,
+  F extends boolean,
+  P extends TProperties = TFromMappedResult<R, F>
+>(R: R, F: F): TMappedResult<P> {
+  const P = FromMappedResult(R, F) as unknown as P
+  return MappedResult(P) 
+}
diff --git a/src/type/readonly/readonly.ts b/src/type/readonly/readonly.ts
new file mode 100644
index 000000000..c5bc936c9
--- /dev/null
+++ b/src/type/readonly/readonly.ts
@@ -0,0 +1,82 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import type { Ensure } from '../helpers/index'
+import { ReadonlyKind } from '../symbols/index'
+import { CloneType } from '../clone/type'
+import { Discard } from '../discard/index'
+import type { TMappedResult } from '../mapped/index'
+
+import { ReadonlyFromMappedResult, type TReadonlyFromMappedResult } from './readonly-from-mapped-result'
+import { IsMappedResult } from '../guard/type'
+// ------------------------------------------------------------------
+// RemoveReadonly
+// ------------------------------------------------------------------
+type TRemoveReadonly<T extends TSchema> = T extends TReadonly<infer S> ? S : T
+function RemoveReadonly<T extends TSchema>(schema: T) {
+  return Discard(CloneType(schema), [ReadonlyKind])
+}
+// ------------------------------------------------------------------
+// AddReadonly
+// ------------------------------------------------------------------
+type TAddReadonly<T extends TSchema> = T extends TReadonly<infer S> ? TReadonly<S> : Ensure<TReadonly<T>>
+function AddReadonly<T extends TSchema>(schema: T) {
+  return { ...CloneType(schema), [ReadonlyKind]: 'Readonly' }
+}
+// prettier-ignore
+export type TReadonlyWithFlag<T extends TSchema, F extends boolean> = 
+  F extends false 
+    ? TRemoveReadonly<T> 
+    : TAddReadonly<T>
+// prettier-ignore
+function ReadonlyWithFlag<T extends TSchema, F extends boolean>(schema: T, F: F) {
+  return (
+    F === false
+      ? RemoveReadonly(schema)
+      : AddReadonly(schema)
+  )
+}
+// ------------------------------------------------------------------
+// TReadonly
+// ------------------------------------------------------------------
+export type TReadonly<T extends TSchema> = T & { [ReadonlyKind]: 'Readonly' }
+
+/** `[Json]` Creates a Readonly property */
+export function Readonly<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TReadonlyFromMappedResult<T, F>
+/** `[Json]` Creates a Readonly property */
+export function Readonly<T extends TSchema, F extends boolean>(schema: T, enable: F): TReadonlyWithFlag<T, F>
+/** `[Json]` Creates a Readonly property */
+export function Readonly<T extends TMappedResult>(schema: T): TReadonlyFromMappedResult<T, true>
+/** `[Json]` Creates a Readonly property */
+export function Readonly<T extends TSchema>(schema: T): TReadonlyWithFlag<T, true>
+/** `[Json]` Creates a Readonly property */
+export function Readonly(schema: TSchema, enable?: boolean): any {
+  const F = enable ?? true
+  return IsMappedResult(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F)
+}
diff --git a/src/type/record/index.ts b/src/type/record/index.ts
new file mode 100644
index 000000000..10eb1ceb9
--- /dev/null
+++ b/src/type/record/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './record'
diff --git a/src/type/record/record.ts b/src/type/record/record.ts
new file mode 100644
index 000000000..ec724bd30
--- /dev/null
+++ b/src/type/record/record.ts
@@ -0,0 +1,224 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import type { Static } from '../static/index'
+import type { Evaluate, Ensure, Assert } from '../helpers/index'
+import { Object, type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index'
+import { type TLiteral, type TLiteralValue } from '../literal/index'
+import { Never, type TNever } from '../never/index'
+import { Union, type TUnion } from '../union/index'
+import { type TRegExp } from '../regexp/index'
+import { type TString } from '../string/index'
+import { type TInteger } from '../integer/index'
+import { type TNumber } from '../number/index'
+import { type TEnum } from '../enum/index'
+
+import { IsTemplateLiteralFinite, TIsTemplateLiteralFinite, type TTemplateLiteral } from '../template-literal/index'
+import { PatternStringExact, PatternNumberExact } from '../patterns/index'
+import { IndexPropertyKeys } from '../indexed/index'
+import { Kind, Hint } from '../symbols/index'
+import { CloneType } from '../clone/type'
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsUndefined } from '../guard/value'
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsInteger, IsLiteral, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion } from '../guard/type'
+// ------------------------------------------------------------------
+// RecordCreateFromPattern
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordCreateFromPattern(pattern: string, T: TSchema, options: ObjectOptions): TRecord<TSchema, TSchema> {
+  return { 
+    ...options, 
+    [Kind]: 'Record', 
+    type: 'object', 
+    patternProperties: { [pattern]: CloneType(T) } 
+  } as unknown as TRecord<TSchema, TSchema> 
+}
+// ------------------------------------------------------------------
+// RecordCreateFromKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordCreateFromKeys(K: string[], T: TSchema, options: ObjectOptions): TObject<TProperties> {
+  const P = K.reduce((Acc, K) => ({ ...Acc, [K]: CloneType(T) }), {} as TProperties)
+  return Object(P, { ...options, [Hint]: 'Record' })
+}
+// ------------------------------------------------------------------
+// FromTemplateLiteralKey (Fast Inference)
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>
+// prettier-ignore
+type TFromTemplateLiteralKeyFinite<K extends TTemplateLiteral, T extends TSchema, I extends string = Static<K>> = (
+  Ensure<TObject<Evaluate<{ [_ in I]: T }>>>
+)
+// prettier-ignore
+type TFromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = TIsTemplateLiteralFinite<K> extends false
+  ? TFromTemplateLiteralKeyInfinite<K, T>
+  : TFromTemplateLiteralKeyFinite<K, T>
+// prettier-ignore
+function FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromTemplateLiteralKey<K, T> {
+  return (
+    IsTemplateLiteralFinite(K)
+      ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options)
+      : RecordCreateFromPattern(K.pattern, T, options)
+  ) as TFromTemplateLiteralKey<K, T>
+}
+// ------------------------------------------------------------------
+// FromEnumKey (Special Case)
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromEnumKey<K extends Record<string, string | number>, T extends TSchema> = Ensure<TObject<{ [_ in K[keyof K]]: T }>>
+// ------------------------------------------------------------------
+// FromUnionKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromUnionKeyLiteralString<K extends TLiteral<string>, T extends TSchema> = { [_ in K['const']]: T }
+// prettier-ignore
+type TFromUnionKeyLiteralNumber<K extends TLiteral<number>, T extends TSchema> = { [_ in K['const']]: T }
+// prettier-ignore
+type TFromUnionKeyRest<K extends TSchema[], T extends TSchema> = 
+  K extends [infer L extends TSchema, ...infer R extends TSchema[]] ? (
+    L extends TUnion<infer S> ? TFromUnionKeyRest<S, T> & TFromUnionKeyRest<R, T> :
+    L extends TLiteral<string> ? TFromUnionKeyLiteralString<L, T> & TFromUnionKeyRest<R, T> :
+    L extends TLiteral<number> ? TFromUnionKeyLiteralNumber<L, T> & TFromUnionKeyRest<R, T> :
+  {}) : {}
+// prettier-ignore
+type TFromUnionKey<K extends TSchema[], T extends TSchema, P extends TProperties = TFromUnionKeyRest<K, T>> = (
+  Ensure<TObject<Evaluate<P>>>
+)
+// prettier-ignore
+function FromUnionKey<K extends TSchema[], T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromUnionKey<K, T> {
+  return RecordCreateFromKeys(IndexPropertyKeys(Union(K)), T, options) as  TFromUnionKey<K, T>
+}
+// ------------------------------------------------------------------
+// FromLiteralKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromLiteralKey<K extends TLiteralValue, T extends TSchema> = (
+  Ensure<TObject<{ [_ in Assert<K, PropertyKey>]: T }>>
+)
+// prettier-ignore
+function FromLiteralKey<K extends TLiteralValue, T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromLiteralKey<K, T> {
+  return RecordCreateFromKeys([(K as string).toString()], T, options) as TFromLiteralKey<K, T>
+}
+// ------------------------------------------------------------------
+// TFromRegExpKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRegExpKey<_ extends TRegExp, T extends TSchema> = (
+  Ensure<TRecord<TRegExp, T>>
+)
+// prettier-ignore
+function FromRegExpKey<K extends TRegExp, T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromRegExpKey<K, T> {
+  return RecordCreateFromPattern(K.source, T, options) as TFromRegExpKey<K, T>
+}
+// ------------------------------------------------------------------
+// FromStringKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromStringKey<_ extends TString, T extends TSchema> = (
+  Ensure<TRecord<TString, T>>
+)
+// prettier-ignore
+function FromStringKey<K extends TString, T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromStringKey<K, T> {
+  const pattern = IsUndefined(K.pattern) ? PatternStringExact : K.pattern
+  return RecordCreateFromPattern(pattern, T, options) as TFromStringKey<K, T>
+}
+// ------------------------------------------------------------------
+// FromIntegerKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromIntegerKey<_ extends TSchema, T extends TSchema> = (
+  Ensure<TRecord<TNumber, T>>
+)
+// prettier-ignore
+function FromIntegerKey<K extends TInteger, T extends TSchema>(_: K, T: T, options: ObjectOptions): TFromIntegerKey<K, T> {
+  return RecordCreateFromPattern(PatternNumberExact, T, options) as TFromIntegerKey<K, T>
+}
+// ------------------------------------------------------------------
+// FromNumberKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromNumberKey<_ extends TSchema, T extends TSchema> = (
+  Ensure<TRecord<TNumber, T>>
+)
+// prettier-ignore
+function FromNumberKey<K extends TNumber, T extends TSchema>(_: K, T: T, options: ObjectOptions): TFromNumberKey<K, T> {
+  return RecordCreateFromPattern(PatternNumberExact, T, options) as TFromNumberKey<K, T>
+}
+// ------------------------------------------------------------------
+// TRecord
+// ------------------------------------------------------------------
+// prettier-ignore
+type RecordStatic<K extends TSchema, T extends TSchema, P extends unknown[]> = (
+  Record<Assert<Static<K>, PropertyKey>, Static<T, P>>
+)
+// prettier-ignore
+export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'Record'
+  static: RecordStatic<K, T, this['params']>
+  type: 'object'
+  patternProperties: { [pattern: string]: T }
+  additionalProperties: TAdditionalProperties
+}
+// ------------------------------------------------------------------
+// TRecordOrObject
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TRecordOrObject<K extends TSchema, T extends TSchema> =
+  K extends TTemplateLiteral ? TFromTemplateLiteralKey<K, T> :  
+  K extends TEnum<infer S> ? TFromEnumKey<S, T> : // (Special: Ensure resolve Enum before Union)
+  K extends TUnion<infer S> ? TFromUnionKey<S, T> :
+  K extends TLiteral<infer S> ? TFromLiteralKey<S, T> :
+  K extends TInteger ? TFromIntegerKey<K, T> :
+  K extends TNumber ? TFromNumberKey<K, T> :
+  K extends TRegExp ? TFromRegExpKey<K, T> :
+  K extends TString ? TFromStringKey<K, T> :
+  TNever
+// ------------------------------------------------------------------
+// TRecordOrObject
+// ------------------------------------------------------------------
+/** `[Json]` Creates a Record type */
+export function Record<K extends TSchema, T extends TSchema>(K: K, T: T, options: ObjectOptions = {}): TRecordOrObject<K, T> {
+  // prettier-ignore
+  return (
+    IsUnion(K) ? FromUnionKey(K.anyOf, T, options) :
+    IsTemplateLiteral(K) ? FromTemplateLiteralKey(K, T, options) :
+    IsLiteral(K) ? FromLiteralKey(K.const, T, options) :
+    IsInteger(K) ? FromIntegerKey(K, T, options) :
+    IsNumber(K) ? FromNumberKey(K, T, options) :
+    IsRegExp(K) ? FromRegExpKey(K, T, options) :
+    IsString(K) ? FromStringKey(K, T, options) :
+    Never(options)
+  ) as TRecordOrObject<K, T>
+}
diff --git a/src/type/recursive/index.ts b/src/type/recursive/index.ts
new file mode 100644
index 000000000..9bb19d9f4
--- /dev/null
+++ b/src/type/recursive/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './recursive'
diff --git a/src/type/recursive/recursive.ts b/src/type/recursive/recursive.ts
new file mode 100644
index 000000000..cff19af46
--- /dev/null
+++ b/src/type/recursive/recursive.ts
@@ -0,0 +1,63 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { CloneType } from '../clone/type'
+import { IsUndefined } from '../guard/value'
+import { Kind, Hint } from '../symbols/index'
+import { Static } from '../static/index'
+
+// ------------------------------------------------------------------
+// TThis
+// ------------------------------------------------------------------
+export interface TThis extends TSchema {
+  [Kind]: 'This'
+  static: this['params'][0]
+  $ref: string
+}
+// ------------------------------------------------------------------
+// RecursiveStatic
+// ------------------------------------------------------------------
+type RecursiveStatic<T extends TSchema> = Static<T, [RecursiveStatic<T>]>
+// ------------------------------------------------------------------
+// TRecursive
+// ------------------------------------------------------------------
+export interface TRecursive<T extends TSchema> extends TSchema {
+  [Hint]: 'Recursive'
+  static: RecursiveStatic<T>
+}
+// Auto Tracked For Recursive Types without ID's
+let Ordinal = 0
+/** `[Json]` Creates a Recursive type */
+export function Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options: SchemaOptions = {}): TRecursive<T> {
+  if (IsUndefined(options.$id)) (options as any).$id = `T${Ordinal++}`
+  const thisType = callback({ [Kind]: 'This', $ref: `${options.$id}` } as any)
+  thisType.$id = options.$id
+  // prettier-ignore
+  return CloneType({ ...options, [Hint]: 'Recursive', ...thisType }) as unknown as TRecursive<T>
+}
diff --git a/src/type/ref/index.ts b/src/type/ref/index.ts
new file mode 100644
index 000000000..1db9fa4e0
--- /dev/null
+++ b/src/type/ref/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './ref'
diff --git a/src/type/ref/ref.ts b/src/type/ref/ref.ts
new file mode 100644
index 000000000..1df55fe2d
--- /dev/null
+++ b/src/type/ref/ref.ts
@@ -0,0 +1,57 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Static } from '../static/index'
+import { Kind } from '../symbols/index'
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsString, IsUndefined } from '../guard/value'
+// ------------------------------------------------------------------
+// TRef
+// ------------------------------------------------------------------
+export interface TRef<T extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'Ref'
+  static: Static<T, this['params']>
+  $ref: string
+}
+/** `[Json]` Creates a Ref type. The referenced type must contain a $id */
+export function Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>
+/** `[Json]` Creates a Ref type. */
+export function Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>
+/** `[Json]` Creates a Ref type. */
+export function Ref(unresolved: TSchema | string, options: SchemaOptions = {}) {
+  if (IsString(unresolved)) return { ...options, [Kind]: 'Ref', $ref: unresolved }
+  if (IsUndefined(unresolved.$id)) throw new Error('Reference target type must specify an $id')
+  return {
+    ...options,
+    [Kind]: 'Ref',
+    $ref: unresolved.$id!,
+  }
+}
diff --git a/src/type/regexp/index.ts b/src/type/regexp/index.ts
new file mode 100644
index 000000000..00fab30b4
--- /dev/null
+++ b/src/type/regexp/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './regexp'
diff --git a/src/type/regexp/regexp.ts b/src/type/regexp/regexp.ts
new file mode 100644
index 000000000..3029d4240
--- /dev/null
+++ b/src/type/regexp/regexp.ts
@@ -0,0 +1,50 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { SchemaOptions } from '../schema/index'
+import type { TSchema } from '../schema/index'
+import { IsString } from '../guard/value'
+import { Kind } from '../symbols/index'
+
+export interface TRegExp extends TSchema {
+  [Kind]: 'RegExp'
+  static: `${string}`
+  type: 'RegExp'
+  source: string
+  flags: string
+}
+
+/** `[JavaScript]` Creates a RegExp type */
+export function RegExp(pattern: string, options?: SchemaOptions): TRegExp
+/** `[JavaScript]` Creates a RegExp type */
+export function RegExp(regex: RegExp, options?: SchemaOptions): TRegExp
+/** `[JavaScript]` Creates a RegExp type */
+export function RegExp(unresolved: RegExp | string, options: SchemaOptions = {}) {
+  const expr = IsString(unresolved) ? new globalThis.RegExp(unresolved) : unresolved
+  return { ...options, [Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags } as never
+}
diff --git a/src/type/registry/format.ts b/src/type/registry/format.ts
new file mode 100644
index 000000000..ebcf3d74a
--- /dev/null
+++ b/src/type/registry/format.ts
@@ -0,0 +1,55 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export type FormatRegistryValidationFunction = (value: string) => boolean
+/** A registry for user defined string formats */
+const map = new Map<string, FormatRegistryValidationFunction>()
+/** Returns the entries in this registry */
+export function Entries() {
+  return new Map(map)
+}
+/** Clears all user defined string formats */
+export function Clear() {
+  return map.clear()
+}
+/** Deletes a registered format */
+export function Delete(format: string) {
+  return map.delete(format)
+}
+/** Returns true if the user defined string format exists */
+export function Has(format: string) {
+  return map.has(format)
+}
+/** Sets a validation function for a user defined string format */
+export function Set(format: string, func: FormatRegistryValidationFunction) {
+  map.set(format, func)
+}
+/** Gets a validation function for a user defined string format */
+export function Get(format: string) {
+  return map.get(format)
+}
diff --git a/src/type/registry/index.ts b/src/type/registry/index.ts
new file mode 100644
index 000000000..a0fb0e043
--- /dev/null
+++ b/src/type/registry/index.ts
@@ -0,0 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * as FormatRegistry from './format'
+export * as TypeRegistry from './type'
diff --git a/src/type/registry/type.ts b/src/type/registry/type.ts
new file mode 100644
index 000000000..78e313b4a
--- /dev/null
+++ b/src/type/registry/type.ts
@@ -0,0 +1,56 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export type TypeRegistryValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean
+/** A registry for user defined types */
+
+const map = new Map<string, TypeRegistryValidationFunction<any>>()
+/** Returns the entries in this registry */
+export function Entries() {
+  return new Map(map)
+}
+/** Clears all user defined types */
+export function Clear() {
+  return map.clear()
+}
+/** Deletes a registered type */
+export function Delete(kind: string) {
+  return map.delete(kind)
+}
+/** Returns true if this registry contains this kind */
+export function Has(kind: string) {
+  return map.has(kind)
+}
+/** Sets a validation function for a user defined type */
+export function Set<TSchema = unknown>(kind: string, func: TypeRegistryValidationFunction<TSchema>) {
+  map.set(kind, func)
+}
+/** Gets a custom validation function for a user defined type */
+export function Get(kind: string) {
+  return map.get(kind)
+}
diff --git a/src/type/required/index.ts b/src/type/required/index.ts
new file mode 100644
index 000000000..428fd821c
--- /dev/null
+++ b/src/type/required/index.ts
@@ -0,0 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './required-from-mapped-result'
+export * from './required'
diff --git a/src/type/required/required-from-mapped-result.ts b/src/type/required/required-from-mapped-result.ts
new file mode 100644
index 000000000..2f6da2807
--- /dev/null
+++ b/src/type/required/required-from-mapped-result.ts
@@ -0,0 +1,83 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { SchemaOptions } from '../schema/index'
+import type { TProperties } from '../object/index'
+import { MappedResult, type TMappedResult } from '../mapped/index'
+import { Required, type TRequired } from './required'
+
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperties<
+  P extends TProperties
+> = (
+  { [K2 in keyof P]: TRequired<P[K2]> }   
+)
+// prettier-ignore
+function FromProperties<
+  P extends TProperties
+>(P: P, options: SchemaOptions): TFromProperties<P> {
+  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+    return {...Acc, [K2]: Required(P[K2], options) }
+  }, {}) as TFromProperties<P>
+}
+// ------------------------------------------------------------------
+// FromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromMappedResult<
+  R extends TMappedResult
+> = (
+  TFromProperties<R['properties']>
+)
+// prettier-ignore
+function FromMappedResult<
+  R extends TMappedResult
+>(R: R, options: SchemaOptions): TFromMappedResult<R> {
+  return FromProperties(R.properties, options) as TFromMappedResult<R>
+}
+// ------------------------------------------------------------------
+// TRequiredFromMappedResult
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TRequiredFromMappedResult<
+  R extends TMappedResult,
+  P extends TProperties = TFromMappedResult<R>
+> = (
+  TMappedResult<P>
+)
+// prettier-ignore
+export function RequiredFromMappedResult<
+  R extends TMappedResult,
+  P extends TProperties = TFromMappedResult<R>
+>(R: R, options: SchemaOptions): TMappedResult<P> {
+  const P = FromMappedResult(R, options) as unknown as P
+  return MappedResult(P) 
+}
diff --git a/src/type/required/required.ts b/src/type/required/required.ts
new file mode 100644
index 000000000..e26e8f857
--- /dev/null
+++ b/src/type/required/required.ts
@@ -0,0 +1,118 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Evaluate } from '../helpers/index'
+import type { TMappedResult } from '../mapped/index'
+import { type TReadonlyOptional } from '../readonly-optional/index'
+import { type TOptional } from '../optional/index'
+import { type TReadonly } from '../readonly/index'
+import { type TRecursive } from '../recursive/index'
+import { type TIntersect, Intersect } from '../intersect/index'
+import { type TUnion, Union } from '../union/index'
+import { type TObject, type TProperties, Object } from '../object/index'
+
+import { OptionalKind, TransformKind } from '../symbols/index'
+import { CloneType } from '../clone/type'
+import { Discard } from '../discard/index'
+
+import { RequiredFromMappedResult, type TRequiredFromMappedResult } from './required-from-mapped-result'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/type'
+// ------------------------------------------------------------------
+// FromRest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TFromRest<R, [...Acc, TRequiredResolve<L>]>
+    : Acc
+)
+// prettier-ignore
+function FromRest<T extends TSchema[]>(T: [...T]) : TFromRest<T> {
+  return T.map(L => RequiredResolve(L)) as TFromRest<T>
+}
+// ------------------------------------------------------------------
+// FromProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperties<T extends TProperties> = Evaluate<{
+  [K in keyof T]:
+    T[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> :
+    T[K] extends (TReadonly<infer S>) ? TReadonly<S> :
+    T[K] extends (TOptional<infer S>) ? S :
+    T[K]
+}>
+// prettier-ignore
+function FromProperties<T extends TProperties>(T: T) {
+  return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K) => {
+    return { ...Acc, [K]: Discard(T[K], [OptionalKind]) as TSchema }
+  }, {} as TProperties)
+}
+// ------------------------------------------------------------------
+// RequiredResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+type TRequiredResolve<T extends TSchema> = (
+  T extends TRecursive<infer S> ? TRecursive<TRequiredResolve<S>> :
+  T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> :
+  T extends TUnion<infer S> ? TUnion<TFromRest<S>> :
+  T extends TObject<infer S> ? TObject<TFromProperties<S>> :
+  TObject<{}>
+)
+// prettier-ignore
+function RequiredResolve<T extends TSchema>(T: T): TRequiredResolve<T> {
+  return (
+    IsIntersect(T) ? Intersect(FromRest(T.allOf)) :
+    IsUnion(T) ?  Union(FromRest(T.anyOf)) :
+    IsObject(T) ? Object(FromProperties(T.properties)) :
+    Object({})
+  ) as TRequiredResolve<T>
+}
+// ------------------------------------------------------------------
+// TRequired
+// ------------------------------------------------------------------
+export type TRequired<T extends TSchema> = TRequiredResolve<T>
+
+/** `[Json]` Constructs a type where all properties are required */
+export function Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>
+/** `[Json]` Constructs a type where all properties are required */
+export function Required<T extends TSchema>(T: T, options?: SchemaOptions): TRequired<T>
+/** `[Json]` Constructs a type where all properties are required */
+export function Required<T extends TSchema>(T: T, options: SchemaOptions = {}) {
+  if (IsMappedResult(T)) {
+    return RequiredFromMappedResult(T, options)
+  } else {
+    const D = Discard(T, [TransformKind, '$id', 'required']) as TSchema
+    const R = CloneType(RequiredResolve(T) as any, options)
+    return { ...D, ...R }
+  }
+}
diff --git a/src/type/rest/index.ts b/src/type/rest/index.ts
new file mode 100644
index 000000000..b1442f480
--- /dev/null
+++ b/src/type/rest/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './rest'
diff --git a/src/type/rest/rest.ts b/src/type/rest/rest.ts
new file mode 100644
index 000000000..8ca450780
--- /dev/null
+++ b/src/type/rest/rest.ts
@@ -0,0 +1,65 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import type { TIntersect } from '../intersect/index'
+import type { TUnion } from '../union/index'
+import type { TTuple } from '../tuple/index'
+import { CloneRest } from '../clone/type'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsIntersect, IsUnion, IsTuple } from '../guard/type'
+// ------------------------------------------------------------------
+// RestResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+type TRestResolve<T extends TSchema> = 
+  T extends TIntersect<infer S> ? [...S] : 
+  T extends TUnion<infer S> ? [...S] : 
+  T extends TTuple<infer S> ? [...S] : 
+  []
+// prettier-ignore
+function RestResolve<T extends TSchema>(T: T) {
+  return (
+    IsIntersect(T) ? [...T.allOf] : 
+    IsUnion(T) ? [...T.anyOf] : 
+    IsTuple(T) ? [...(T.items ?? [])] : 
+    []
+  ) as TRestResolve<T>
+}
+// ------------------------------------------------------------------
+// TRest
+// ------------------------------------------------------------------
+export type TRest<T extends TSchema> = TRestResolve<T>
+
+/** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
+export function Rest<T extends TSchema>(T: T): TRest<T> {
+  return CloneRest(RestResolve(T))
+}
diff --git a/src/type/return-type/index.ts b/src/type/return-type/index.ts
new file mode 100644
index 000000000..610d3adc0
--- /dev/null
+++ b/src/type/return-type/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './return-type'
diff --git a/src/type/return-type/return-type.ts b/src/type/return-type/return-type.ts
new file mode 100644
index 000000000..fd31f8d59
--- /dev/null
+++ b/src/type/return-type/return-type.ts
@@ -0,0 +1,38 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { SchemaOptions } from '../schema/index'
+import type { TFunction } from '../function/index'
+import { CloneType } from '../clone/type'
+
+export type TReturnType<T extends TFunction> = T['returns']
+
+/** `[JavaScript]` Extracts the ReturnType from the given Function type */
+export function ReturnType<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TReturnType<T> {
+  return CloneType(schema.returns, options)
+}
diff --git a/src/type/schema/anyschema.ts b/src/type/schema/anyschema.ts
new file mode 100644
index 000000000..44fa18e5f
--- /dev/null
+++ b/src/type/schema/anyschema.ts
@@ -0,0 +1,97 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+// ------------------------------------------------------------------
+// Type: Module
+// ------------------------------------------------------------------
+import type { TAny } from '../any/index'
+import type { TArray } from '../array/index'
+import type { TAsyncIterator } from '../async-iterator/index'
+import type { TBigInt } from '../bigint/index'
+import type { TBoolean } from '../boolean/index'
+import type { TConstructor } from '../constructor/index'
+import type { TDate } from '../date/index'
+import type { TEnum } from '../enum/index'
+import type { TFunction } from '../function/index'
+import type { TInteger } from '../integer/index'
+import type { TIntersect } from '../intersect/index'
+import type { TIterator } from '../iterator/index'
+import type { TLiteral } from '../literal/index'
+import type { TNot } from '../not/index'
+import type { TNull } from '../null/index'
+import type { TNumber } from '../number/index'
+import type { TObject } from '../object/index'
+import type { TPromise } from '../promise/index'
+import type { TRecord } from '../record/index'
+import type { TThis } from '../recursive/index'
+import type { TRef } from '../ref/index'
+import type { TRegExp } from '../regexp/index'
+import type { TString } from '../string/index'
+import type { TSymbol } from '../symbol/index'
+import type { TTemplateLiteral } from '../template-literal/index'
+import type { TTuple } from '../tuple/index'
+import type { TUint8Array } from '../uint8array/index'
+import type { TUndefined } from '../undefined/index'
+import type { TUnion } from '../union/index'
+import type { TUnknown } from '../unknown/index'
+import type { TVoid } from '../void/index'
+import type { TSchema } from './schema'
+
+export type TAnySchema =
+  | TSchema
+  | TAny
+  | TArray
+  | TAsyncIterator
+  | TBigInt
+  | TBoolean
+  | TConstructor
+  | TDate
+  | TEnum
+  | TFunction
+  | TInteger
+  | TIntersect
+  | TIterator
+  | TLiteral
+  | TNot
+  | TNull
+  | TNumber
+  | TObject
+  | TPromise
+  | TRecord
+  | TRef
+  | TRegExp
+  | TString
+  | TSymbol
+  | TTemplateLiteral
+  | TThis
+  | TTuple
+  | TUndefined
+  | TUnion
+  | TUint8Array
+  | TUnknown
+  | TVoid
diff --git a/src/type/schema/index.ts b/src/type/schema/index.ts
new file mode 100644
index 000000000..bfd714bb5
--- /dev/null
+++ b/src/type/schema/index.ts
@@ -0,0 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './anyschema'
+export * from './schema'
diff --git a/src/type/schema/schema.ts b/src/type/schema/schema.ts
new file mode 100644
index 000000000..287088f98
--- /dev/null
+++ b/src/type/schema/schema.ts
@@ -0,0 +1,58 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Kind, Hint, ReadonlyKind, OptionalKind } from '../symbols/index'
+
+export interface SchemaOptions {
+  $schema?: string
+  /** Id for this schema */
+  $id?: string
+  /** Title of this schema */
+  title?: string
+  /** Description of this schema */
+  description?: string
+  /** Default value for this schema */
+  default?: any
+  /** Example values matching this schema */
+  examples?: any
+  /** Optional annotation for readOnly */
+  readOnly?: boolean
+  /** Optional annotation for writeOnly */
+  writeOnly?: boolean
+  [prop: string]: any
+}
+export interface TKind {
+  [Kind]: string
+}
+export interface TSchema extends TKind, SchemaOptions {
+  [ReadonlyKind]?: string
+  [OptionalKind]?: string
+  [Hint]?: string
+  params: unknown[]
+  static: unknown
+}
diff --git a/src/type/sets/index.ts b/src/type/sets/index.ts
new file mode 100644
index 000000000..e672ba02e
--- /dev/null
+++ b/src/type/sets/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './set'
diff --git a/src/type/sets/set.ts b/src/type/sets/set.ts
new file mode 100644
index 000000000..c478204ff
--- /dev/null
+++ b/src/type/sets/set.ts
@@ -0,0 +1,147 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+// ------------------------------------------------------------------
+// SetIncludes
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TSetIncludes<T extends PropertyKey[], S extends PropertyKey> = (
+  T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+    ? S extends L 
+      ? true 
+      : TSetIncludes<R, S>
+    : false
+)
+/** Returns true if element S is in the set of T */
+// prettier-ignore
+export function SetIncludes<T extends PropertyKey[], S extends PropertyKey>(T: [...T], S: S): TSetIncludes<T, S> {
+  return T.includes(S) as TSetIncludes<T, S>
+}
+// ------------------------------------------------------------------
+// SetIsSubset
+// ------------------------------------------------------------------
+// prettier-ignore
+export type SetIsSubset<T extends PropertyKey[], S extends PropertyKey[]> = (
+  T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+    ? TSetIncludes<S, L> extends true
+      ? SetIsSubset<R, S>
+      : false
+    : true
+)
+/** Returns true if T is a subset of S */
+export function SetIsSubset<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): SetIsSubset<T, S> {
+  return T.every((L) => SetIncludes(S, L)) as SetIsSubset<T, S>
+}
+// ------------------------------------------------------------------
+// SetDistinct
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TSetDistinct<T extends PropertyKey[], Acc extends PropertyKey[] = []> =
+  T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+    ? TSetIncludes<Acc, L> extends false
+      ? TSetDistinct<R, [...Acc, L]>
+      : TSetDistinct<R, [...Acc]>
+    : Acc
+/** Returns a distinct set of elements */
+export function SetDistinct<T extends PropertyKey[]>(T: [...T]): TSetDistinct<T> {
+  return [...new Set(T)] as TSetDistinct<T>
+}
+// ------------------------------------------------------------------
+// SetIntersect
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TSetIntersect<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (
+  T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+    ? TSetIncludes<S, L> extends true
+      ? TSetIntersect<R, S, [L, ...Acc]>
+      : TSetIntersect<R, S, [...Acc]>
+    : Acc
+)
+/** Returns the Intersect of the given sets */
+export function SetIntersect<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetIntersect<T, S> {
+  return T.filter((L) => S.includes(L)) as TSetIntersect<T, S>
+}
+// ------------------------------------------------------------------
+// SetUnion
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TSetUnion<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = S> = (
+  T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+    ? TSetUnion<R, S, [...Acc, L]>
+    : Acc
+)
+/** Returns the Union of the given sets */
+export function SetUnion<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetUnion<T, S> {
+  return [...T, ...S] as never
+}
+// ------------------------------------------------------------------
+// SetComplement
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TSetComplement<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (
+  T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+    ? TSetIncludes<S, L> extends true
+      ? TSetComplement<R, S, [...Acc]>
+      : TSetComplement<R, S, [...Acc, L]>
+    : Acc
+)
+/** Returns the Complement by omitting elements in T that are in S */
+// prettier-ignore
+export function SetComplement<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetComplement<T, S> {
+  return T.filter(L => !S.includes(L)) as TSetComplement<T, S>
+}
+// ------------------------------------------------------------------
+// SetIntersectMany
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TSetIntersectMany<T extends PropertyKey[][], Acc extends PropertyKey[] = []> = (
+  T extends [infer L extends PropertyKey[]] ? L :
+  T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]]
+    ? TSetIntersectMany<R, TSetIntersect<Acc, L>>
+    : Acc
+)
+/** Returns the Intersect of multiple sets */
+// prettier-ignore
+export function SetIntersectMany<T extends PropertyKey[][]>(T: [...T]): TSetIntersectMany<T> {
+  return (
+    T.length === 1 ? T[0] : T.reduce((Acc, L) => [...SetIntersect(Acc, L)], [])
+  ) as TSetIntersectMany<T>
+}
+// ------------------------------------------------------------------
+// SetUnionMany
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TSetUnionMany<T extends PropertyKey[][], Acc extends PropertyKey[] = []> = (
+  T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]]
+    ? TSetUnionMany<R, TSetUnion<Acc, L>>
+    : Acc
+)
+/** Returns the Union of multiple sets */
+export function SetUnionMany<T extends PropertyKey[][]>(T: [...T]): TSetUnionMany<T> {
+  return T.reduce((Acc, L) => [...Acc, ...L], [] as PropertyKey[]) as TSetUnionMany<T>
+}
diff --git a/src/type/static/index.ts b/src/type/static/index.ts
new file mode 100644
index 000000000..8f4f0c9dc
--- /dev/null
+++ b/src/type/static/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './static'
diff --git a/src/type/static/static.ts b/src/type/static/static.ts
new file mode 100644
index 000000000..e38b3765f
--- /dev/null
+++ b/src/type/static/static.ts
@@ -0,0 +1,93 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { Evaluate } from '../helpers/index'
+import type { TOptional } from '../optional/index'
+import type { TReadonly } from '../readonly/index'
+import type { TArray } from '../array/index'
+import type { TAsyncIterator } from '../async-iterator/index'
+import type { TConstructor } from '../constructor/index'
+import type { TEnum } from '../enum/index'
+import type { TFunction } from '../function/index'
+import type { TIntersect } from '../intersect/index'
+import type { TIterator } from '../iterator/index'
+import type { TNot } from '../not/index'
+import type { TObject, TProperties } from '../object/index'
+import type { TPromise } from '../promise/index'
+import type { TRecursive } from '../recursive/index'
+import type { TRecord } from '../record/index'
+import type { TRef } from '../ref/index'
+import type { TTuple } from '../tuple/index'
+import type { TUnion } from '../union/index'
+import type { TUnsafe } from '../unsafe/index'
+import type { TSchema } from '../schema/index'
+import type { TTransform } from '../transform/index'
+
+// ------------------------------------------------------------------
+// DecodeType
+// ------------------------------------------------------------------
+// prettier-ignore
+export type DecodeProperties<T extends TProperties> = {
+  [K in keyof T]: DecodeType<T[K]>
+}
+// prettier-ignore
+export type DecodeRest<T extends TSchema[], Acc extends TSchema[] = []> = 
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? DecodeRest<R, [...Acc, DecodeType<L>]>
+    : Acc
+// prettier-ignore
+export type DecodeType<T extends TSchema> = (
+  T extends TOptional<infer S extends TSchema> ? TOptional<DecodeType<S>> :
+  T extends TReadonly<infer S extends TSchema> ? TReadonly<DecodeType<S>> :
+  T extends TTransform<infer _, infer R> ? TUnsafe<R> :
+  T extends TArray<infer S extends TSchema> ? TArray<DecodeType<S>> :
+  T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> :
+  T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<DecodeRest<P>, DecodeType<R>> :
+  T extends TEnum<infer S> ? TEnum<S> : // intercept for union. interior non decodable
+  T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<DecodeRest<P>, DecodeType<R>> :
+  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<DecodeRest<S>> :
+  T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> :
+  T extends TNot<infer S extends TSchema> ? TNot<DecodeType<S>> :
+  T extends TObject<infer S> ? TObject<Evaluate<DecodeProperties<S>>> :
+  T extends TPromise<infer S extends TSchema> ? TPromise<DecodeType<S>> :
+  T extends TRecord<infer K, infer S> ? TRecord<K, DecodeType<S>> :
+  T extends TRecursive<infer S extends TSchema> ? TRecursive<DecodeType<S>> :
+  T extends TRef<infer S extends TSchema> ? TRef<DecodeType<S>> :
+  T extends TTuple<infer S extends TSchema[]> ? TTuple<DecodeRest<S>> :
+  T extends TUnion<infer S extends TSchema[]> ? TUnion<DecodeRest<S>> :
+  T
+)
+// ------------------------------------------------------------------
+// Static
+// ------------------------------------------------------------------
+/** Creates an decoded static type from a TypeBox type */
+export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<DecodeType<T>, P>
+/** Creates an encoded static type from a TypeBox type */
+export type StaticEncode<T extends TSchema, P extends unknown[] = []> = Static<T, P>
+/** Creates a static type from a TypeBox type */
+export type Static<T extends TSchema, P extends unknown[] = []> = (T & { params: P })['static']
diff --git a/src/type/strict/index.ts b/src/type/strict/index.ts
new file mode 100644
index 000000000..caf80eab1
--- /dev/null
+++ b/src/type/strict/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './strict'
diff --git a/src/type/strict/strict.ts b/src/type/strict/strict.ts
new file mode 100644
index 000000000..de47e425b
--- /dev/null
+++ b/src/type/strict/strict.ts
@@ -0,0 +1,34 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+
+/** `[Json]` Omits compositing symbols from this schema. */
+export function Strict<T extends TSchema>(schema: T): T {
+  return JSON.parse(JSON.stringify(schema))
+}
diff --git a/src/type/string/index.ts b/src/type/string/index.ts
new file mode 100644
index 000000000..1c188b4fd
--- /dev/null
+++ b/src/type/string/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './string'
diff --git a/src/type/string/string.ts b/src/type/string/string.ts
new file mode 100644
index 000000000..5bcda7176
--- /dev/null
+++ b/src/type/string/string.ts
@@ -0,0 +1,86 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TSchema, SchemaOptions } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+// ------------------------------------------------------------------
+// TString
+// ------------------------------------------------------------------
+export type StringFormatOption =
+  | 'date-time'
+  | 'time'
+  | 'date'
+  | 'email'
+  | 'idn-email'
+  | 'hostname'
+  | 'idn-hostname'
+  | 'ipv4'
+  | 'ipv6'
+  | 'uri'
+  | 'uri-reference'
+  | 'iri'
+  | 'uuid'
+  | 'iri-reference'
+  | 'uri-template'
+  | 'json-pointer'
+  | 'relative-json-pointer'
+  | 'regex'
+  | ({} & string)
+// prettier-ignore
+export type StringContentEncodingOption =
+  | '7bit'
+  | '8bit'
+  | 'binary'
+  | 'quoted-printable'
+  | 'base64'
+  | ({} & string)
+export interface StringOptions extends SchemaOptions {
+  /** The maximum string length */
+  maxLength?: number
+  /** The minimum string length */
+  minLength?: number
+  /** A regular expression pattern this string should match */
+  pattern?: string
+  /** A format this string should match */
+  format?: StringFormatOption
+  /** The content encoding for this string */
+  contentEncoding?: StringContentEncodingOption
+  /** The content media type for this string */
+  contentMediaType?: string
+}
+export interface TString extends TSchema, StringOptions {
+  [Kind]: 'String'
+  static: string
+  type: 'string'
+}
+
+/** `[Json]` Creates a String type */
+export function String(options: StringOptions = {}): TString {
+  return { ...options, [Kind]: 'String', type: 'string' } as unknown as TString
+}
diff --git a/src/type/symbol/index.ts b/src/type/symbol/index.ts
new file mode 100644
index 000000000..abd306265
--- /dev/null
+++ b/src/type/symbol/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './symbol'
diff --git a/src/type/symbol/symbol.ts b/src/type/symbol/symbol.ts
new file mode 100644
index 000000000..4c5adc9ab
--- /dev/null
+++ b/src/type/symbol/symbol.ts
@@ -0,0 +1,41 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TSchema, SchemaOptions } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+export type TSymbolValue = string | number | undefined
+export interface TSymbol extends TSchema, SchemaOptions {
+  [Kind]: 'Symbol'
+  static: symbol
+  type: 'symbol'
+}
+/** `[JavaScript]` Creates a Symbol type */
+export function Symbol(options?: SchemaOptions): TSymbol {
+  return { ...options, [Kind]: 'Symbol', type: 'symbol' } as unknown as TSymbol
+}
diff --git a/src/type/symbols/index.ts b/src/type/symbols/index.ts
new file mode 100644
index 000000000..bac16a322
--- /dev/null
+++ b/src/type/symbols/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './symbols'
diff --git a/src/type/symbols/symbols.ts b/src/type/symbols/symbols.ts
new file mode 100644
index 000000000..dbb90a99a
--- /dev/null
+++ b/src/type/symbols/symbols.ts
@@ -0,0 +1,38 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+/** Symbol key applied to transform types */
+export const TransformKind = Symbol.for('TypeBox.Transform')
+/** Symbol key applied to readonly types */
+export const ReadonlyKind = Symbol.for('TypeBox.Readonly')
+/** Symbol key applied to optional types */
+export const OptionalKind = Symbol.for('TypeBox.Optional')
+/** Symbol key applied to types */
+export const Hint = Symbol.for('TypeBox.Hint')
+/** Symbol key applied to types */
+export const Kind = Symbol.for('TypeBox.Kind')
diff --git a/src/type/template-literal/finite.ts b/src/type/template-literal/finite.ts
new file mode 100644
index 000000000..43a03ac33
--- /dev/null
+++ b/src/type/template-literal/finite.ts
@@ -0,0 +1,119 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TemplateLiteralParseExact } from './parse'
+import { TypeBoxError } from '../error/index'
+import type { TTemplateLiteral, TTemplateLiteralKind } from './index'
+import type { TUnion } from '../union/index'
+import type { TString } from '../string/index'
+import type { TBoolean } from '../boolean/index'
+import type { TNumber } from '../number/index'
+import type { TInteger } from '../integer/index'
+import type { TBigInt } from '../bigint/index'
+import type { TLiteral } from '../literal/index'
+import type { Expression } from './parse'
+
+// ------------------------------------------------------------------
+// TemplateLiteralFiniteError
+// ------------------------------------------------------------------
+export class TemplateLiteralFiniteError extends TypeBoxError {}
+
+// ------------------------------------------------------------------
+// IsTemplateLiteralFiniteCheck
+// ------------------------------------------------------------------
+// prettier-ignore
+function IsNumberExpression(expression: Expression): boolean {
+  return (
+    expression.type === 'or' &&
+    expression.expr.length === 2 &&
+    expression.expr[0].type === 'const' &&
+    expression.expr[0].const === '0' &&
+    expression.expr[1].type === 'const' &&
+    expression.expr[1].const === '[1-9][0-9]*'
+  )
+}
+// prettier-ignore
+function IsBooleanExpression(expression: Expression): boolean {
+  return (
+    expression.type === 'or' &&
+    expression.expr.length === 2 &&
+    expression.expr[0].type === 'const' &&
+    expression.expr[0].const === 'true' &&
+    expression.expr[1].type === 'const' &&
+    expression.expr[1].const === 'false'
+  )
+}
+// prettier-ignore
+function IsStringExpression(expression: Expression) {
+  return expression.type === 'const' && expression.const === '.*'
+}
+// prettier-ignore
+type TFromTemplateLiteralKind<T> =
+  T extends TTemplateLiteral<infer U extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<U> :
+  T extends TUnion<infer U extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<U> :
+  T extends TString ? false :
+  T extends TNumber ? false :
+  T extends TInteger ? false :
+  T extends TBigInt ? false :
+  T extends TBoolean ? true :
+  T extends TLiteral ? true :
+  false
+// prettier-ignore
+type TFromTemplateLiteralKinds<T extends TTemplateLiteralKind[]> =
+  T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] 
+    ? TFromTemplateLiteralKind<L> extends false 
+      ? false 
+      : TFromTemplateLiteralKinds<R> :
+  true
+// ------------------------------------------------------------------
+// IsTemplateLiteralExpressionFinite
+// ------------------------------------------------------------------
+// prettier-ignore
+export function IsTemplateLiteralExpressionFinite(expression: Expression): boolean {
+  return (
+    IsNumberExpression(expression) || IsStringExpression(expression) ? false :
+    IsBooleanExpression(expression) ? true :
+    (expression.type === 'and') ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) :
+    (expression.type === 'or') ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) :
+    (expression.type === 'const') ? true :
+    (() => { throw new TemplateLiteralFiniteError(`Unknown expression type`) })()
+  )
+}
+// ------------------------------------------------------------------
+// TIsTemplateLiteralFinite
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TIsTemplateLiteralFinite<T> = 
+  T extends TTemplateLiteral<infer U> 
+    ? TFromTemplateLiteralKinds<U>
+    : false
+/** Returns true if this TemplateLiteral resolves to a finite set of values */
+export function IsTemplateLiteralFinite<T extends TTemplateLiteral>(schema: T) {
+  const expression = TemplateLiteralParseExact(schema.pattern)
+  return IsTemplateLiteralExpressionFinite(expression)
+}
diff --git a/src/type/template-literal/generate.ts b/src/type/template-literal/generate.ts
new file mode 100644
index 000000000..671dd40e2
--- /dev/null
+++ b/src/type/template-literal/generate.ts
@@ -0,0 +1,148 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { IsTemplateLiteralExpressionFinite, TIsTemplateLiteralFinite } from './finite'
+import { TemplateLiteralParseExact } from './parse'
+import { TypeBoxError } from '../error/index'
+
+import type { Assert } from '../helpers/index'
+import type { TBoolean } from '../boolean/index'
+import type { TTemplateLiteral, TTemplateLiteralKind } from './index'
+import type { TLiteral, TLiteralValue } from '../literal/index'
+import type { Expression, ExpressionAnd, ExpressionOr, ExpressionConst } from './parse'
+import type { TUnion } from '../union/index'
+
+// ------------------------------------------------------------------
+// TemplateLiteralGenerateError
+// ------------------------------------------------------------------
+export class TemplateLiteralGenerateError extends TypeBoxError {}
+// ------------------------------------------------------------------
+// StringReducers
+// ------------------------------------------------------------------
+// StringReduceUnary<"A", ["B", "C"]> -> ["AB", "AC"]
+// prettier-ignore
+type TStringReduceUnary<L extends string, R extends string[], Acc extends string[] = []> = 
+  R extends [infer A extends string, ...infer B extends string[]] 
+    ? TStringReduceUnary<L, B, [...Acc, `${L}${A}`]>
+    : Acc
+// StringReduceBinary<['A', 'B'], ['C', 'D']> -> ["AC", "AD", "BC", "BD"]
+// prettier-ignore
+type TStringReduceBinary<L extends string[], R extends string[], Acc extends string[] = []> = 
+  L extends [infer A extends string, ...infer B extends string[]]
+    ? TStringReduceBinary<B, R, [...Acc, ...TStringReduceUnary<A, R>]>
+    : Acc
+// StringReduceMany<[['A', 'B'], ['C', 'D'], ['E']]> -> [["ACE", "ADE", "BCE", "BDE"]]
+// prettier-ignore
+type TStringReduceMany<T extends string[][]> = // consider optimizing
+  T extends [infer L extends string[], infer R extends string[], ...infer Rest extends string[][]] 
+    ? TStringReduceMany<[TStringReduceBinary<L, R>, ...Rest]> 
+    : T
+// Reduce<[['A', 'B'], ['C', 'D'], ['E']]> -> ["ACE", "ADE", "BCE", "BDE"]
+// prettier-ignore
+type TStringReduce<T extends string[][], O = TStringReduceMany<T>> = 
+  0 extends keyof O
+    ? Assert<O[0], string[]>
+    : []
+// ------------------------------------------------------------------
+// FromTemplateLiteralUnionKinds
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromTemplateLiteralUnionKinds<T extends TTemplateLiteralKind[]> = 
+  T extends [infer L extends TLiteral, ...infer R extends TLiteral[]]
+    ? [`${L['const']}`, ...TFromTemplateLiteralUnionKinds<R>]
+    : []
+// ------------------------------------------------------------------
+// FromTemplateLiteralKinds
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromTemplateLiteralKinds<T extends TTemplateLiteralKind[], Acc extends TLiteralValue[][] = []> = 
+  T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]]
+    ? (
+     L extends TLiteral<infer S extends TLiteralValue> ? TFromTemplateLiteralKinds<R, [...Acc, [S]]> : 
+     L extends TUnion<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<R, [...Acc, TFromTemplateLiteralUnionKinds<S>]> : 
+     L extends TBoolean ? TFromTemplateLiteralKinds<R, [...Acc, ['true', 'false']]> : 
+     Acc
+  ) : Acc
+// ------------------------------------------------------------------
+// TemplateLiteralExpressionGenerate
+// ------------------------------------------------------------------
+// prettier-ignore
+function* GenerateReduce(buffer: string[][]): IterableIterator<string> {
+  if (buffer.length === 1) return yield* buffer[0]
+  for (const left of buffer[0]) {
+    for (const right of GenerateReduce(buffer.slice(1))) {
+      yield `${left}${right}`
+    }
+  }
+}
+// prettier-ignore
+function* GenerateAnd(expression: ExpressionAnd): IterableIterator<string> {
+  return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]))
+}
+// prettier-ignore
+function* GenerateOr(expression: ExpressionOr): IterableIterator<string> {
+  for (const expr of expression.expr) yield* TemplateLiteralExpressionGenerate(expr)
+}
+// prettier-ignore
+function* GenerateConst(expression: ExpressionConst): IterableIterator<string> {
+  return yield expression.const
+}
+export function* TemplateLiteralExpressionGenerate(expression: Expression): IterableIterator<string> {
+  return expression.type === 'and'
+    ? yield* GenerateAnd(expression)
+    : expression.type === 'or'
+    ? yield* GenerateOr(expression)
+    : expression.type === 'const'
+    ? yield* GenerateConst(expression)
+    : (() => {
+        throw new TemplateLiteralGenerateError('Unknown expression')
+      })()
+}
+// ------------------------------------------------------------------
+// TTemplateLiteralGenerate
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TTemplateLiteralGenerate<T extends TTemplateLiteral, F = TIsTemplateLiteralFinite<T>> =
+  F extends true
+    ? (
+    T extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]>
+      ? TFromTemplateLiteralKinds<S> extends infer R extends string[][]
+        ? TStringReduce<R>
+        : []
+      : []
+  ) : []
+/** Generates a tuple of strings from the given TemplateLiteral. Returns an empty tuple if infinite. */
+export function TemplateLiteralGenerate<T extends TTemplateLiteral>(schema: T): TTemplateLiteralGenerate<T> {
+  const expression = TemplateLiteralParseExact(schema.pattern)
+  // prettier-ignore
+  return (
+    IsTemplateLiteralExpressionFinite(expression)
+     ? [...TemplateLiteralExpressionGenerate(expression)]
+     : []
+  ) as TTemplateLiteralGenerate<T>
+}
diff --git a/src/type/template-literal/index.ts b/src/type/template-literal/index.ts
new file mode 100644
index 000000000..17ae27505
--- /dev/null
+++ b/src/type/template-literal/index.ts
@@ -0,0 +1,35 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './finite'
+export * from './generate'
+export * from './syntax'
+export * from './parse'
+export * from './pattern'
+export * from './union'
+export * from './template-literal'
diff --git a/src/type/template-literal/parse.ts b/src/type/template-literal/parse.ts
new file mode 100644
index 000000000..f856a1eac
--- /dev/null
+++ b/src/type/template-literal/parse.ts
@@ -0,0 +1,167 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TypeBoxError } from '../error/index'
+
+// ------------------------------------------------------------------
+// TemplateLiteralParserError
+// ------------------------------------------------------------------
+export class TemplateLiteralParserError extends TypeBoxError {}
+// ------------------------------------------------------------------
+// TemplateLiteralParse
+// ------------------------------------------------------------------
+// prettier-ignore
+export type Expression = ExpressionAnd | ExpressionOr | ExpressionConst
+export type ExpressionConst = { type: 'const'; const: string }
+export type ExpressionAnd = { type: 'and'; expr: Expression[] }
+export type ExpressionOr = { type: 'or'; expr: Expression[] }
+// prettier-ignore
+function IsNonEscaped(pattern: string, index: number, char: string) {
+  return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92
+}
+// prettier-ignore
+function IsOpenParen(pattern: string, index: number) {
+  return IsNonEscaped(pattern, index, '(')
+}
+// prettier-ignore
+function IsCloseParen(pattern: string, index: number) {
+  return IsNonEscaped(pattern, index, ')')
+}
+// prettier-ignore
+function IsSeparator(pattern: string, index: number) {
+  return IsNonEscaped(pattern, index, '|')
+}
+// prettier-ignore
+function IsGroup(pattern: string) {
+  if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1))) return false
+  let count = 0
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index)) count += 1
+    if (IsCloseParen(pattern, index)) count -= 1
+    if (count === 0 && index !== pattern.length - 1) return false
+  }
+  return true
+}
+// prettier-ignore
+function InGroup(pattern: string) {
+  return pattern.slice(1, pattern.length - 1)
+}
+// prettier-ignore
+function IsPrecedenceOr(pattern: string) {
+  let count = 0
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index)) count += 1
+    if (IsCloseParen(pattern, index)) count -= 1
+    if (IsSeparator(pattern, index) && count === 0) return true
+  }
+  return false
+}
+// prettier-ignore
+function IsPrecedenceAnd(pattern: string) {
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index)) return true
+  }
+  return false
+}
+// prettier-ignore
+function Or(pattern: string): Expression {
+  let [count, start] = [0, 0]
+  const expressions: Expression[] = []
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index)) count += 1
+    if (IsCloseParen(pattern, index)) count -= 1
+    if (IsSeparator(pattern, index) && count === 0) {
+      const range = pattern.slice(start, index)
+      if (range.length > 0) expressions.push(TemplateLiteralParse(range))
+      start = index + 1
+    }
+  }
+  const range = pattern.slice(start)
+  if (range.length > 0) expressions.push(TemplateLiteralParse(range))
+  if (expressions.length === 0) return { type: 'const', const: '' }
+  if (expressions.length === 1) return expressions[0]
+  return { type: 'or', expr: expressions }
+}
+// prettier-ignore
+function And(pattern: string): Expression {
+  function Group(value: string, index: number): [number, number] {
+    if (!IsOpenParen(value, index)) throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`)
+    let count = 0
+    for (let scan = index; scan < value.length; scan++) {
+      if (IsOpenParen(value, scan)) count += 1
+      if (IsCloseParen(value, scan)) count -= 1
+      if (count === 0) return [index, scan]
+    }
+    throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`)
+  }
+  function Range(pattern: string, index: number): [number, number] {
+    for (let scan = index; scan < pattern.length; scan++) {
+      if (IsOpenParen(pattern, scan)) return [index, scan]
+    }
+    return [index, pattern.length]
+  }
+  const expressions: Expression[] = []
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index)) {
+      const [start, end] = Group(pattern, index)
+      const range = pattern.slice(start, end + 1)
+      expressions.push(TemplateLiteralParse(range))
+      index = end
+    } else {
+      const [start, end] = Range(pattern, index)
+      const range = pattern.slice(start, end)
+      if (range.length > 0) expressions.push(TemplateLiteralParse(range))
+      index = end - 1
+    }
+  }
+  return (
+    (expressions.length === 0) ? { type: 'const', const: '' } :
+    (expressions.length === 1) ? expressions[0] :
+    { type: 'and', expr: expressions }
+  )
+}
+// ------------------------------------------------------------------
+// TemplateLiteralParse
+// ------------------------------------------------------------------
+/** Parses a pattern and returns an expression tree */
+export function TemplateLiteralParse(pattern: string): Expression {
+  // prettier-ignore
+  return (
+    IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
+    IsPrecedenceOr(pattern) ? Or(pattern) :
+    IsPrecedenceAnd(pattern) ? And(pattern) :
+    { type: 'const', const: pattern }
+  )
+}
+// ------------------------------------------------------------------
+// TemplateLiteralParseExact
+// ------------------------------------------------------------------
+/** Parses a pattern and strips forward and trailing ^ and $ */
+export function TemplateLiteralParseExact(pattern: string): Expression {
+  return TemplateLiteralParse(pattern.slice(1, pattern.length - 1))
+}
diff --git a/src/type/template-literal/pattern.ts b/src/type/template-literal/pattern.ts
new file mode 100644
index 000000000..6af7e3f9d
--- /dev/null
+++ b/src/type/template-literal/pattern.ts
@@ -0,0 +1,77 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import type { TTemplateLiteralKind } from './index'
+import { PatternNumber, PatternString, PatternBoolean } from '../patterns/index'
+import { Kind } from '../symbols/index'
+import { TypeBoxError } from '../error/index'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+import {
+  IsTemplateLiteral,
+  IsUnion,
+  IsNumber,
+  IsInteger,
+  IsBigInt,
+  IsString,
+  IsLiteral,
+  IsBoolean
+} from '../guard/type'
+
+// ------------------------------------------------------------------
+// TemplateLiteralPatternError
+// ------------------------------------------------------------------
+export class TemplateLiteralPatternError extends TypeBoxError {}
+
+// ------------------------------------------------------------------
+// TemplateLiteralPattern
+// ------------------------------------------------------------------
+function Escape(value: string) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+// prettier-ignore
+function Visit(schema: TSchema, acc: string): string {
+  return (
+    IsTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) : 
+    IsUnion(schema) ? `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})` : 
+    IsNumber(schema) ? `${acc}${PatternNumber}` : 
+    IsInteger(schema) ? `${acc}${PatternNumber}` : 
+    IsBigInt(schema) ? `${acc}${PatternNumber}` : 
+    IsString(schema) ? `${acc}${PatternString}` : 
+    IsLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` : 
+    IsBoolean(schema) ? `${acc}${PatternBoolean}` : 
+    (() => { throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`) })()
+  )
+}
+export function TemplateLiteralPattern(kinds: TTemplateLiteralKind[]): string {
+  return `^${kinds.map((schema) => Visit(schema, '')).join('')}\$`
+}
diff --git a/src/type/template-literal/syntax.ts b/src/type/template-literal/syntax.ts
new file mode 100644
index 000000000..f70df69f8
--- /dev/null
+++ b/src/type/template-literal/syntax.ts
@@ -0,0 +1,117 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { Assert, Trim } from '../helpers/index'
+import type { TTemplateLiteral, TTemplateLiteralKind } from './index'
+import { Literal, type TLiteral } from '../literal/index'
+import { Boolean, type TBoolean } from '../boolean/index'
+import { BigInt, type TBigInt } from '../bigint/index'
+import { Number, type TNumber } from '../number/index'
+import { String, type TString } from '../string/index'
+import { UnionEvaluated, type TUnionEvaluated } from '../union/index'
+import { Never } from '../never/index'
+
+// ------------------------------------------------------------------
+// SyntaxParsers
+// ------------------------------------------------------------------
+// prettier-ignore
+function* FromUnion(syntax: string): IterableIterator<TTemplateLiteralKind> {
+  const trim = syntax.trim().replace(/"|'/g, '')
+  return (
+    trim === 'boolean' ? yield Boolean() :
+    trim === 'number' ? yield Number() :
+    trim === 'bigint' ? yield BigInt() :
+    trim === 'string' ? yield String() :
+    yield (() => {
+      const literals = trim.split('|').map((literal) => Literal(literal.trim()))
+      return (
+        literals.length === 0 ? Never() :
+        literals.length === 1 ? literals[0] :
+        UnionEvaluated(literals)
+      )
+    })()
+  )
+}
+// prettier-ignore
+function* FromTerminal(syntax: string): IterableIterator<TTemplateLiteralKind> {
+  if (syntax[1] !== '{') {
+    const L = Literal('$')
+    const R = FromSyntax(syntax.slice(1))
+    return yield* [L, ...R]
+  }
+  for (let i = 2; i < syntax.length; i++) {
+    if (syntax[i] === '}') {
+      const L = FromUnion(syntax.slice(2, i))
+      const R = FromSyntax(syntax.slice(i + 1))
+      return yield* [...L, ...R]
+    }
+  }
+  yield Literal(syntax)
+}
+// prettier-ignore
+function* FromSyntax(syntax: string): IterableIterator<TTemplateLiteralKind> {
+  for (let i = 0; i < syntax.length; i++) {
+    if (syntax[i] === '$') {
+      const L = Literal(syntax.slice(0, i))
+      const R = FromTerminal(syntax.slice(i))
+      return yield* [L, ...R]
+    }
+  }
+  yield Literal(syntax)
+}
+// prettier-ignore
+type FromUnionLiteral<T extends string> =
+  T extends `${infer L}|${infer R}` ? [TLiteral<Trim<L>>, ...FromUnionLiteral<R>] :
+  T extends `${infer L}` ? [TLiteral<Trim<L>>] :
+  []
+type FromUnion<T extends string> = TUnionEvaluated<FromUnionLiteral<T>>
+// prettier-ignore
+type FromTerminal<T extends string> =
+  T extends 'boolean' ? TBoolean :
+  T extends 'bigint' ? TBigInt :
+  T extends 'number' ? TNumber :
+  T extends 'string' ? TString :
+  FromUnion<T>
+// prettier-ignore
+type FromString<T extends string> =
+  T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] :
+  T extends `${infer L}$${infer R}` ? [TLiteral<L>, ...FromString<R>] :
+  T extends `${infer L}` ? [TLiteral<L>] :
+  []
+
+// ------------------------------------------------------------------
+// TTemplateLiteralSyntax
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TTemplateLiteralSyntax<T extends string> = (
+  TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>
+)
+/** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
+export function TemplateLiteralSyntax(syntax: string): TTemplateLiteralKind[] {
+  return [...FromSyntax(syntax)]
+}
diff --git a/src/type/template-literal/template-literal.ts b/src/type/template-literal/template-literal.ts
new file mode 100644
index 000000000..c3436b8f2
--- /dev/null
+++ b/src/type/template-literal/template-literal.ts
@@ -0,0 +1,102 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Assert } from '../helpers/index'
+import type { TUnion } from '../union/index'
+import type { TLiteral } from '../literal/index'
+import type { TInteger } from '../integer/index'
+import type { TNumber } from '../number/index'
+import type { TBigInt } from '../bigint/index'
+import type { TString } from '../string/index'
+import type { TBoolean } from '../boolean/index'
+import type { TNever } from '../never/index'
+import type { Static } from '../static/index'
+
+import { TemplateLiteralSyntax, type TTemplateLiteralSyntax } from './syntax'
+import { TemplateLiteralPattern } from './pattern'
+import { EmptyString } from '../helpers/index'
+import { IsString } from '../guard/value'
+import { Kind } from '../symbols/index'
+
+// ------------------------------------------------------------------
+// TemplateLiteralStaticKind
+// ------------------------------------------------------------------
+// prettier-ignore
+type TemplateLiteralStaticKind<T, Acc extends string> =
+  T extends TUnion<infer U> ? { [K in keyof U]: TemplateLiteralStatic<Assert<[U[K]], TTemplateLiteralKind[]>, Acc> }[number] :
+  T extends TTemplateLiteral ? `${Static<T>}` :
+  T extends TLiteral<infer U> ? `${U}` :
+  T extends TString ? `${string}` :
+  T extends TNumber ? `${number}` :
+  T extends TBigInt ? `${bigint}` :
+  T extends TBoolean ? `${boolean}` :
+  never
+// ------------------------------------------------------------------
+// TemplateLiteralStatic
+// ------------------------------------------------------------------
+// prettier-ignore
+type TemplateLiteralStatic<T extends TTemplateLiteralKind[], Acc extends string> =
+  T extends [infer L, ...infer R] ? `${TemplateLiteralStaticKind<L, Acc>}${TemplateLiteralStatic<Assert<R, TTemplateLiteralKind[]>, Acc>}` :
+  Acc
+// ------------------------------------------------------------------
+// TTemplateLiteralKind
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TTemplateLiteralKind =
+  | TTemplateLiteral
+  | TUnion
+  | TLiteral
+  | TInteger
+  | TNumber
+  | TBigInt
+  | TString
+  | TBoolean
+  | TNever
+// ------------------------------------------------------------------
+// TTemplateLiteral
+// ------------------------------------------------------------------
+// prettier-ignore
+export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
+  [Kind]: 'TemplateLiteral'
+  static: TemplateLiteralStatic<T, EmptyString>
+  type: 'string'
+  pattern: string // todo: it may be possible to infer this pattern
+}
+/** `[Json]` Creates a TemplateLiteral type from template dsl string */
+export function TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TTemplateLiteralSyntax<T>
+/** `[Json]` Creates a TemplateLiteral type */
+export function TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>
+/** `[Json]` Creates a TemplateLiteral type */
+// prettier-ignore
+export function TemplateLiteral(unresolved: TTemplateLiteralKind[] | string, options: SchemaOptions = {}) {
+  const pattern = IsString(unresolved) 
+    ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved)) 
+    : TemplateLiteralPattern(unresolved as TTemplateLiteralKind[])
+  return { ...options, [Kind]: 'TemplateLiteral', type: 'string', pattern }
+}
diff --git a/src/type/template-literal/union.ts b/src/type/template-literal/union.ts
new file mode 100644
index 000000000..9de4dbc83
--- /dev/null
+++ b/src/type/template-literal/union.ts
@@ -0,0 +1,44 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TTemplateLiteral } from './template-literal'
+import { Union, type TUnion } from '../union/index'
+import { Literal, type TLiteral } from '../literal/index'
+import { type TString } from '../string/index'
+import { type TNever } from '../never/index'
+import { TemplateLiteralGenerate } from './generate'
+
+// ------------------------------------------------------------------
+// TemplateLiteralToUnion
+// ------------------------------------------------------------------
+/** Returns a Union from the given TemplateLiteral */
+export function TemplateLiteralToUnion(schema: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]> {
+  const R = TemplateLiteralGenerate(schema) as string[]
+  const L = R.map((S) => Literal(S))
+  return Union(L)
+}
diff --git a/src/type/transform/index.ts b/src/type/transform/index.ts
new file mode 100644
index 000000000..4e6ab0218
--- /dev/null
+++ b/src/type/transform/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './transform'
diff --git a/src/type/transform/transform.ts b/src/type/transform/transform.ts
new file mode 100644
index 000000000..cb7099544
--- /dev/null
+++ b/src/type/transform/transform.ts
@@ -0,0 +1,88 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import type { Static, StaticDecode } from '../static/index'
+import { TransformKind } from '../symbols/index'
+import { CloneType } from '../clone/type'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsTransform } from '../guard/type'
+
+// ------------------------------------------------------------------
+// TransformBuilders
+// ------------------------------------------------------------------
+export class TransformDecodeBuilder<T extends TSchema> {
+  constructor(private readonly schema: T) {}
+  public Decode<U extends unknown, D extends TransformFunction<StaticDecode<T>, U>>(decode: D): TransformEncodeBuilder<T, D> {
+    return new TransformEncodeBuilder(this.schema, decode)
+  }
+}
+// prettier-ignore
+export class TransformEncodeBuilder<T extends TSchema, D extends TransformFunction> {
+  constructor(private readonly schema: T, private readonly decode: D) { }
+  private EncodeTransform<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E, schema: TTransform) {
+    const Encode = (value: unknown) => schema[TransformKind as any].Encode(encode(value as any))
+    const Decode = (value: unknown) => this.decode(schema[TransformKind as any].Decode(value))
+    const Codec = { Encode: Encode, Decode: Decode }
+    return { ...schema, [TransformKind]: Codec }
+  }
+  private EncodeSchema<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E, schema: TSchema) {
+    const Codec = { Decode: this.decode, Encode: encode }
+    return { ...schema as TSchema, [TransformKind]: Codec }
+  }
+  public Encode<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E): TTransform<T, ReturnType<D>> {
+    const schema = CloneType(this.schema)
+    return (
+      IsTransform(schema) ? this.EncodeTransform(encode, schema): this.EncodeSchema(encode, schema)
+    ) as unknown as TTransform<T, ReturnType<D>>
+  }
+}
+// ------------------------------------------------------------------
+// TransformStatic
+// ------------------------------------------------------------------
+type TransformStatic<T extends TSchema, P extends unknown[] = []> = T extends TTransform<infer _, infer S> ? S : Static<T, P>
+// ------------------------------------------------------------------
+// TTransform
+// ------------------------------------------------------------------
+export type TransformFunction<T = any, U = any> = (value: T) => U
+export interface TransformOptions<I extends TSchema = TSchema, O extends unknown = unknown> {
+  Decode: TransformFunction<StaticDecode<I>, O>
+  Encode: TransformFunction<O, StaticDecode<I>>
+}
+export interface TTransform<I extends TSchema = TSchema, O extends unknown = unknown> extends TSchema {
+  static: TransformStatic<I, this['params']>
+  [TransformKind]: TransformOptions<I, O>
+  [key: string]: any
+}
+/** `[Json]` Creates a Transform type */
+export function Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I> {
+  return new TransformDecodeBuilder(schema)
+}
diff --git a/src/type/tuple/index.ts b/src/type/tuple/index.ts
new file mode 100644
index 000000000..c1eb788d2
--- /dev/null
+++ b/src/type/tuple/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './tuple'
diff --git a/src/type/tuple/tuple.ts b/src/type/tuple/tuple.ts
new file mode 100644
index 000000000..32119f78d
--- /dev/null
+++ b/src/type/tuple/tuple.ts
@@ -0,0 +1,64 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import type { Static } from '../static/index'
+import { CloneRest } from '../clone/type'
+import { Kind } from '../symbols/index'
+
+// ------------------------------------------------------------------
+// TupleStatic
+// ------------------------------------------------------------------
+// prettier-ignore
+type TupleStatic<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = 
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]] 
+    ? TupleStatic<R, P, [...Acc, Static<L, P>]>
+    : Acc
+// ------------------------------------------------------------------
+// TTuple
+// ------------------------------------------------------------------
+export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
+  [Kind]: 'Tuple'
+  static: TupleStatic<T, this['params']>
+  type: 'array'
+  items?: T
+  additionalItems?: false
+  minItems: number
+  maxItems: number
+}
+/** `[Json]` Creates a Tuple type */
+export function Tuple<T extends TSchema[]>(items: [...T], options: SchemaOptions = {}): TTuple<T> {
+  // return TupleResolver.Resolve(T)
+  const [additionalItems, minItems, maxItems] = [false, items.length, items.length]
+  // prettier-ignore
+  return (
+    items.length > 0 ?
+      { ...options, [Kind]: 'Tuple', type: 'array', items: CloneRest(items), additionalItems, minItems, maxItems } :
+      { ...options, [Kind]: 'Tuple', type: 'array', minItems, maxItems }
+  ) as unknown as TTuple<T>
+}
diff --git a/src/type/type/index.ts b/src/type/type/index.ts
new file mode 100644
index 000000000..081b459d1
--- /dev/null
+++ b/src/type/type/index.ts
@@ -0,0 +1,43 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+// ------------------------------------------------------------------
+// JsonTypeBuilder
+// ------------------------------------------------------------------
+export { JsonTypeBuilder } from './json'
+
+// ------------------------------------------------------------------
+// JavaScriptTypeBuilder
+// ------------------------------------------------------------------
+import * as TypeBuilder from './type'
+import { JavaScriptTypeBuilder } from './javascript'
+
+/** JavaScript Type Builder with Static Resolution for TypeScript */
+const Type = TypeBuilder as InstanceType<typeof JavaScriptTypeBuilder>
+export { JavaScriptTypeBuilder }
+export { Type }
diff --git a/src/type/type/javascript.ts b/src/type/type/javascript.ts
new file mode 100644
index 000000000..7975887fd
--- /dev/null
+++ b/src/type/type/javascript.ts
@@ -0,0 +1,123 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { JsonTypeBuilder } from './json'
+import { AsyncIterator, type TAsyncIterator } from '../async-iterator/index'
+import { Awaited, type TAwaited } from '../awaited/index'
+import { BigInt, type TBigInt, type BigIntOptions } from '../bigint/index'
+import { Constructor, type TConstructor } from '../constructor/index'
+import { ConstructorParameters, type TConstructorParameters } from '../constructor-parameters/index'
+import { Date, type TDate, type DateOptions } from '../date/index'
+import { Function as FunctionType, type TFunction } from '../function/index'
+import { InstanceType, type TInstanceType } from '../instance-type/index'
+import { Iterator, type TIterator } from '../iterator/index'
+import { Parameters, type TParameters } from '../parameters/index'
+import { Promise, type TPromise } from '../promise/index'
+import { RegExp, type TRegExp } from '../regexp/index'
+import { ReturnType, type TReturnType } from '../return-type/index'
+import { type TSchema, type SchemaOptions } from '../schema/index'
+import { Symbol, type TSymbol } from '../symbol/index'
+import { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from '../uint8array/index'
+import { Undefined, type TUndefined } from '../undefined/index'
+import { Void, type TVoid } from '../void/index'
+
+/** JavaScript Type Builder with Static Resolution for TypeScript */
+export class JavaScriptTypeBuilder extends JsonTypeBuilder {
+  /** `[JavaScript]` Creates a AsyncIterator type */
+  public AsyncIterator<T extends TSchema>(items: T, options: SchemaOptions = {}): TAsyncIterator<T> {
+    return AsyncIterator(items, options)
+  }
+  /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
+  public Awaited<T extends TSchema>(schema: T, options: SchemaOptions = {}): TAwaited<T> {
+    return Awaited(schema, options)
+  }
+  /** `[JavaScript]` Creates a BigInt type */
+  public BigInt(options: BigIntOptions = {}): TBigInt {
+    return BigInt(options)
+  }
+  /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
+  public ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options: SchemaOptions = {}): TConstructorParameters<T> {
+    return ConstructorParameters(schema, options)
+  }
+  /** `[JavaScript]` Creates a Constructor type */
+  public Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U> {
+    return Constructor(parameters, returns, options)
+  }
+  /** `[JavaScript]` Creates a Date type */
+  public Date(options: DateOptions = {}): TDate {
+    return Date(options)
+  }
+  /** `[JavaScript]` Creates a Function type */
+  public Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U> {
+    return FunctionType(parameters, returns, options)
+  }
+  /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
+  public InstanceType<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TInstanceType<T> {
+    return InstanceType(schema, options)
+  }
+  /** `[JavaScript]` Creates an Iterator type */
+  public Iterator<T extends TSchema>(items: T, options: SchemaOptions = {}): TIterator<T> {
+    return Iterator(items, options)
+  }
+  /** `[JavaScript]` Extracts the Parameters from the given Function type */
+  public Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options: SchemaOptions = {}): TParameters<T> {
+    return Parameters(schema, options)
+  }
+  /** `[JavaScript]` Creates a Promise type */
+  public Promise<T extends TSchema>(item: T, options: SchemaOptions = {}): TPromise<T> {
+    return Promise(item, options)
+  }
+  /** `[JavaScript]` Creates a RegExp type */
+  public RegExp(pattern: string, options?: SchemaOptions): TRegExp
+  /** `[JavaScript]` Creates a RegExp type */
+  public RegExp(regex: RegExp, options?: SchemaOptions): TRegExp
+  /** `[JavaScript]` Creates a RegExp type */
+  public RegExp(unresolved: string | RegExp, options: SchemaOptions = {}) {
+    return RegExp(unresolved as any, options)
+  }
+  /** `[JavaScript]` Extracts the ReturnType from the given Function type */
+  public ReturnType<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TReturnType<T> {
+    return ReturnType(schema, options)
+  }
+  /** `[JavaScript]` Creates a Symbol type */
+  public Symbol(options?: SchemaOptions): TSymbol {
+    return Symbol(options)
+  }
+  /** `[JavaScript]` Creates a Undefined type */
+  public Undefined(options: SchemaOptions = {}): TUndefined {
+    return Undefined(options)
+  }
+  /** `[JavaScript]` Creates a Uint8Array type */
+  public Uint8Array(options: Uint8ArrayOptions = {}): TUint8Array {
+    return Uint8Array(options)
+  }
+  /** `[JavaScript]` Creates a Void type */
+  public Void(options: SchemaOptions = {}): TVoid {
+    return Void(options)
+  }
+}
diff --git a/src/type/type/json.ts b/src/type/type/json.ts
new file mode 100644
index 000000000..d4e6214f6
--- /dev/null
+++ b/src/type/type/json.ts
@@ -0,0 +1,338 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Any, type TAny } from '../any/index'
+import { Array, type TArray, type ArrayOptions } from '../array/index'
+import { Boolean, type TBoolean } from '../boolean/index'
+import { Composite, type TComposite } from '../composite/index'
+import { Const, type TConst } from '../const/index'
+import { Deref, type TDeref } from '../deref/index'
+import { Enum, type TEnum, type TEnumKey, type TEnumValue } from '../enum/index'
+import { Exclude, type TExclude, type TExcludeFromMappedResult } from '../exclude/index'
+import { Extends, type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index'
+import { Extract, type TExtract, type TExtractFromMappedResult } from '../extract/index'
+import { Index, TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult } from '../indexed/index'
+import { Integer, type IntegerOptions, type TInteger } from '../integer/index'
+import { Intersect, type IntersectOptions } from '../intersect/index'
+import { Capitalize, Uncapitalize, Lowercase, Uppercase, type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index'
+import { KeyOf, type TKeyOf, type TKeyOfFromMappedResult } from '../keyof/index'
+import { Literal, type TLiteral, type TLiteralValue } from '../literal/index'
+import { Mapped, type TMappedFunction, type TMapped, type TMappedResult } from '../mapped/index'
+import { Never, type TNever } from '../never/index'
+import { Not, type TNot } from '../not/index'
+import { Null, type TNull } from '../null/index'
+import { type TMappedKey } from '../mapped/index'
+import { Number, type TNumber, type NumberOptions } from '../number/index'
+import { Object, type TObject, type TProperties, type ObjectOptions } from '../object/index'
+import { Omit, type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from '../omit/index'
+import { Optional, type TOptionalWithFlag, type TOptionalFromMappedResult } from '../optional/index'
+import { Partial, type TPartial, type TPartialFromMappedResult } from '../partial/index'
+import { Pick, type TPick, type TPickFromMappedKey, type TPickFromMappedResult } from '../pick/index'
+import { Readonly, type TReadonlyWithFlag, type TReadonlyFromMappedResult } from '../readonly/index'
+import { ReadonlyOptional, type TReadonlyOptional } from '../readonly-optional/index'
+import { Record, type TRecordOrObject } from '../record/index'
+import { Recursive, type TRecursive, type TThis } from '../recursive/index'
+import { Ref, type TRef } from '../ref/index'
+import { Required, type TRequired, type TRequiredFromMappedResult } from '../required/index'
+import { Rest, type TRest } from '../rest/index'
+import { type TSchema, type SchemaOptions } from '../schema/index'
+import { Strict } from '../strict/index'
+import { String, type TString, type StringOptions } from '../string/index'
+import { TemplateLiteral, type TTemplateLiteral, type TTemplateLiteralKind, type TTemplateLiteralSyntax } from '../template-literal/index'
+import { Transform, TransformDecodeBuilder } from '../transform/index'
+import { Tuple, type TTuple } from '../tuple/index'
+import { Union } from '../union/index'
+import { Unknown, type TUnknown } from '../unknown/index'
+import { Unsafe, type TUnsafe, type UnsafeOptions } from '../unsafe/index'
+
+/** Json Type Builder with Static Resolution for TypeScript */
+export class JsonTypeBuilder {
+  // ------------------------------------------------------------------------
+  // Strict
+  // ------------------------------------------------------------------------
+  /** `[Json]` Omits compositing symbols from this schema */
+  public Strict<T extends TSchema>(schema: T): T {
+    return Strict(schema)
+  }
+  // ------------------------------------------------------------------------
+  // Modifiers
+  // ------------------------------------------------------------------------
+  /** `[Json]` Creates a Readonly and Optional property */
+  public ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T> {
+    return ReadonlyOptional(schema)
+  }
+  /** `[Json]` Creates a Readonly property */
+  public Readonly<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TReadonlyFromMappedResult<T, F>
+  /** `[Json]` Creates a Readonly property */
+  public Readonly<T extends TSchema, F extends boolean>(schema: T, enable: F): TReadonlyWithFlag<T, F>
+  /** `[Json]` Creates a Optional property */
+  public Readonly<T extends TMappedResult>(schema: T): TReadonlyFromMappedResult<T, true>
+  /** `[Json]` Creates a Readonly property */
+  public Readonly<T extends TSchema>(schema: T): TReadonlyWithFlag<T, true>
+  /** `[Json]` Creates a Readonly property */
+  public Readonly(schema: TSchema, enable?: boolean): any {
+    return Readonly(schema, enable ?? true)
+  }
+  /** `[Json]` Creates a Optional property */
+  public Optional<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TOptionalFromMappedResult<T, F>
+  /** `[Json]` Creates a Optional property */
+  public Optional<T extends TSchema, F extends boolean>(schema: T, enable: F): TOptionalWithFlag<T, F>
+  /** `[Json]` Creates a Optional property */
+  public Optional<T extends TMappedResult>(schema: T): TOptionalFromMappedResult<T, true>
+  /** `[Json]` Creates a Optional property */
+  public Optional<T extends TSchema>(schema: T): TOptionalWithFlag<T, true>
+  /** `[Json]` Creates a Optional property */
+  public Optional(schema: TSchema, enable?: boolean): any {
+    return Optional(schema, enable ?? true)
+  }
+  // ------------------------------------------------------------------------
+  // Types
+  // ------------------------------------------------------------------------
+  /** `[Json]` Creates an Any type */
+  public Any(options: SchemaOptions = {}): TAny {
+    return Any(options)
+  }
+  /** `[Json]` Creates an Array type */
+  public Array<T extends TSchema>(schema: T, options: ArrayOptions = {}): TArray<T> {
+    return Array(schema, options)
+  }
+  /** `[Json]` Creates a Boolean type */
+  public Boolean(options: SchemaOptions = {}): TBoolean {
+    return Boolean(options)
+  }
+  /** `[Json]` Intrinsic function to Capitalize LiteralString types */
+  public Capitalize<T extends TSchema>(schema: T, options: SchemaOptions = {}): TCapitalize<T> {
+    return Capitalize(schema, options)
+  }
+  /** `[Json]` Creates a Composite object type */
+  public Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T> {
+    return Composite(objects, options) as any // (error) TS 5.4.0-dev - review TComposite implementation
+  }
+  /** `[JavaScript]` Creates a readonly const type from the given value. */
+  public Const</* const (not supported in 4.0) */ T>(value: T, options: SchemaOptions = {}): TConst<T> {
+    return Const(value, options)
+  }
+  /** `[Json]` Creates a dereferenced type */
+  public Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T> {
+    return Deref(schema, references)
+  }
+  /** `[Json]` Creates a Enum type */
+  public Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options: SchemaOptions = {}): TEnum<T> {
+    return Enum(item, options)
+  }
+  /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+  public Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>
+  /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+  public Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>
+  /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+  public Exclude(unionType: TSchema, excludedMembers: TSchema, options: SchemaOptions = {}): any {
+    return Exclude(unionType, excludedMembers, options)
+  }
+  /** `[Json]` Creates a Conditional type */
+  public Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedResult<L, R, T, F>
+  /** `[Json]` Creates a Conditional type */
+  public Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedKey<L, R, T, F>
+  /** `[Json]` Creates a Conditional type */
+  public Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>
+  /** `[Json]` Creates a Conditional type */
+  public Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options: SchemaOptions = {}) {
+    return Extends(L, R, T, F, options)
+  }
+  /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+  public Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>
+  /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+  public Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>
+  /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+  public Extract(type: TSchema, union: TSchema, options: SchemaOptions = {}): any {
+    return Extract(type, union, options)
+  }
+  /** `[Json]` Returns an Indexed property type for the given keys */
+  public Index<T extends TSchema, K extends TMappedResult>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedResult<T, K>
+  /** `[Json]` Returns an Indexed property type for the given keys */
+  public Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>
+  /** `[Json]` Returns an Indexed property type for the given keys */
+  public Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>
+  /** `[Json]` Returns an Indexed property type for the given keys */
+  public Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>
+  /** `[Json]` Returns an Indexed property type for the given keys */
+  public Index(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
+    return Index(schema, unresolved, options)
+  }
+  /** `[Json]` Creates an Integer type */
+  public Integer(options: IntegerOptions = {}): TInteger {
+    return Integer(options)
+  }
+  /** `[Json]` Creates an Intersect type */
+  public Intersect<T extends TSchema[]>(T: [...T], options: IntersectOptions = {}): Intersect<T> {
+    return Intersect(T, options)
+  }
+  /** `[Json]` Creates a KeyOf type */
+  public KeyOf<T extends TMappedResult>(schema: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>
+  /** `[Json]` Creates a KeyOf type */
+  public KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>
+  /** `[Json]` Creates a KeyOf type */
+  public KeyOf(schema: TSchema, options: SchemaOptions = {}): any {
+    return KeyOf(schema, options)
+  }
+  /** `[Json]` Creates a Literal type */
+  public Literal<T extends TLiteralValue>(value: T, options: SchemaOptions = {}): TLiteral<T> {
+    return Literal(value, options)
+  }
+  /** `[Json]` Intrinsic function to Lowercase LiteralString types */
+  public Lowercase<T extends TSchema>(schema: T, options: SchemaOptions = {}): TLowercase<T> {
+    return Lowercase(schema, options)
+  }
+  /** `[Json]` Creates a Mapped object type */
+  public Mapped<K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>, F extends TMappedFunction<I> = TMappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R
+  /** `[Json]` Creates a Mapped object type */
+  public Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = TMappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R
+  /** `[Json]` Creates a Mapped object type */
+  public Mapped(key: any, map: TMappedFunction<any>, options: ObjectOptions = {}): any {
+    return Mapped(key, map, options)
+  }
+  /** `[Json]` Creates a Never type */
+  public Never(options: SchemaOptions = {}): TNever {
+    return Never(options)
+  }
+  /** `[Json]` Creates a Not type */
+  public Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T> {
+    return Not(schema, options)
+  }
+  /** `[Json]` Creates a Null type */
+  public Null(options: SchemaOptions = {}): TNull {
+    return Null(options)
+  }
+  /** `[Json]` Creates a Number type */
+  public Number(options: NumberOptions = {}): TNumber {
+    return Number(options)
+  }
+  /** `[Json]` Creates an Object type */
+  public Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
+    return Object(properties, options)
+  }
+  /** `[Json]` Constructs a type whose keys are omitted from the given type */
+  public Omit<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TOmitFromMappedResult<T, K>
+  /** `[Json]` Constructs a type whose keys are omitted from the given type */
+  public Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitFromMappedKey<T, K>
+  /** `[Json]` Constructs a type whose keys are omitted from the given type */
+  public Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>
+  /** `[Json]` Constructs a type whose keys are omitted from the given type */
+  public Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>
+  /** `[Json]` Constructs a type whose keys are omitted from the given type */
+  public Omit(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
+    return Omit(schema, unresolved, options)
+  }
+  /** `[Json]` Constructs a type where all properties are optional */
+  public Partial<T extends TMappedResult>(T: T, options?: ObjectOptions): TPartialFromMappedResult<T>
+  /** `[Json]` Constructs a type where all properties are optional */
+  public Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>
+  /** `[Json]` Constructs a type where all properties are optional */
+  public Partial(schema: TSchema, options: ObjectOptions = {}): any {
+    return Partial(schema, options)
+  }
+  /** `[Json]` Constructs a type whose keys are picked from the given type */
+  public Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K]): TPickFromMappedResult<T, K>
+  /** `[Json]` Constructs a type whose keys are picked from the given type */
+  public Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickFromMappedKey<T, K>
+  /** `[Json]` Constructs a type whose keys are picked from the given type */
+  public Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>
+  /** `[Json]` Constructs a type whose keys are picked from the given type */
+  public Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>
+  /** `[Json]` Constructs a type whose keys are picked from the given type */
+  public Pick(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
+    return Pick(schema, unresolved, options)
+  }
+  /** `[Json]` Creates a Record type */
+  public Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options: ObjectOptions = {}): TRecordOrObject<K, T> {
+    return Record(key, schema)
+  }
+  /** `[Json]` Creates a Recursive type */
+  public Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options: SchemaOptions = {}): TRecursive<T> {
+    return Recursive(callback, options)
+  }
+  /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
+  public Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>
+  /** `[Json]` Creates a Ref type. */
+  public Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>
+  /** `[Json]` Creates a Ref type. */
+  public Ref(unresolved: TSchema | string, options: SchemaOptions = {}) {
+    return Ref(unresolved as any, options)
+  }
+  /** `[Json]` Constructs a type where all properties are required */
+  public Required<T extends TMappedResult>(T: T, options?: ObjectOptions): TRequiredFromMappedResult<T>
+  /** `[Json]` Constructs a type where all properties are required */
+  public Required<T extends TSchema>(schema: T, options?: ObjectOptions): TRequired<T>
+  /** `[Json]` Constructs a type where all properties are required */
+  public Required(schema: TSchema, options: ObjectOptions = {}): any {
+    return Required(schema, options)
+  }
+  /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
+  public Rest<T extends TSchema>(schema: T): TRest<T> {
+    return Rest(schema)
+  }
+  /** `[Json]` Creates a String type */
+  public String(options: StringOptions = {}): TString {
+    return String(options)
+  }
+  /** `[Json]` Creates a TemplateLiteral type from template dsl string */
+  public TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TTemplateLiteralSyntax<T>
+  /** `[Json]` Creates a TemplateLiteral type */
+  public TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>
+  /** `[Json]` Creates a TemplateLiteral type */
+  public TemplateLiteral(unresolved: TTemplateLiteralKind[] | string, options: SchemaOptions = {}) {
+    return TemplateLiteral(unresolved as any, options)
+  }
+  /** `[Json]` Creates a Transform type */
+  public Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I> {
+    return Transform(schema)
+  }
+  /** `[Json]` Creates a Tuple type */
+  public Tuple<T extends TSchema[]>(items: [...T], options: SchemaOptions = {}): TTuple<T> {
+    return Tuple(items, options)
+  }
+  /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
+  public Uncapitalize<T extends TSchema>(schema: T, options: SchemaOptions = {}): TUncapitalize<T> {
+    return Uncapitalize(schema, options)
+  }
+  /** `[Json]` Creates a Union type */
+  public Union<T extends TSchema[]>(schemas: [...T], options: SchemaOptions = {}): Union<T> {
+    return Union(schemas, options)
+  }
+  /** `[Json]` Creates an Unknown type */
+  public Unknown(options: SchemaOptions = {}): TUnknown {
+    return Unknown(options)
+  }
+  /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
+  public Unsafe<T>(options: UnsafeOptions = {}): TUnsafe<T> {
+    return Unsafe(options)
+  }
+  /** `[Json]` Intrinsic function to Uppercase LiteralString types */
+  public Uppercase<T extends TSchema>(schema: T, options: SchemaOptions = {}): TUppercase<T> {
+    return Uppercase(schema, options)
+  }
+}
diff --git a/src/type/type/type.ts b/src/type/type/type.ts
new file mode 100644
index 000000000..53f275419
--- /dev/null
+++ b/src/type/type/type.ts
@@ -0,0 +1,89 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+// ------------------------------------------------------------------
+// Type: Module
+// ------------------------------------------------------------------
+export { Any } from '../any/index'
+export { Array } from '../array/index'
+export { AsyncIterator } from '../async-iterator/index'
+export { Awaited } from '../awaited/index'
+export { BigInt } from '../bigint/index'
+export { Boolean } from '../boolean/index'
+export { Composite } from '../composite/index'
+export { Const } from '../const/index'
+export { Constructor } from '../constructor/index'
+export { ConstructorParameters } from '../constructor-parameters/index'
+export { Date } from '../date/index'
+export { Deref } from '../deref/index'
+export { Enum } from '../enum/index'
+export { Exclude } from '../exclude/index'
+export { Extends } from '../extends/index'
+export { Extract } from '../extract/index'
+export { Function } from '../function/index'
+export { Index } from '../indexed/index'
+export { InstanceType } from '../instance-type/index'
+export { Integer } from '../integer/index'
+export { Intersect } from '../intersect/index'
+export { Capitalize, Uncapitalize, Lowercase, Uppercase } from '../intrinsic/index'
+export { Iterator } from '../iterator/index'
+export { KeyOf } from '../keyof/index'
+export { Literal } from '../literal/index'
+export { Mapped } from '../mapped/index'
+export { Never } from '../never/index'
+export { Not } from '../not/index'
+export { Null } from '../null/index'
+export { Number } from '../number/index'
+export { Object } from '../object/index'
+export { Omit } from '../omit/index'
+export { Optional } from '../optional/index'
+export { Parameters } from '../parameters/index'
+export { Partial } from '../partial/index'
+export { Pick } from '../pick/index'
+export { Promise } from '../promise/index'
+export { Readonly } from '../readonly/index'
+export { ReadonlyOptional } from '../readonly-optional/index'
+export { Record } from '../record/index'
+export { Recursive } from '../recursive/index'
+export { Ref } from '../ref/index'
+export { RegExp } from '../regexp/index'
+export { Required } from '../required/index'
+export { Rest } from '../rest/index'
+export { ReturnType } from '../return-type/index'
+export { Strict } from '../strict/index'
+export { String } from '../string/index'
+export { Symbol } from '../symbol/index'
+export { TemplateLiteral } from '../template-literal/index'
+export { Transform } from '../transform/index'
+export { Tuple } from '../tuple/index'
+export { Uint8Array } from '../uint8array/index'
+export { Undefined } from '../undefined/index'
+export { Union } from '../union/index'
+export { Unknown } from '../unknown/index'
+export { Unsafe } from '../unsafe/index'
+export { Void } from '../void/index'
diff --git a/src/type/uint8array/index.ts b/src/type/uint8array/index.ts
new file mode 100644
index 000000000..4c2296a42
--- /dev/null
+++ b/src/type/uint8array/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './uint8array'
diff --git a/src/type/uint8array/uint8array.ts b/src/type/uint8array/uint8array.ts
new file mode 100644
index 000000000..1c1732ced
--- /dev/null
+++ b/src/type/uint8array/uint8array.ts
@@ -0,0 +1,44 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+export interface Uint8ArrayOptions extends SchemaOptions {
+  maxByteLength?: number
+  minByteLength?: number
+}
+export interface TUint8Array extends TSchema, Uint8ArrayOptions {
+  [Kind]: 'Uint8Array'
+  static: Uint8Array
+  type: 'uint8array'
+}
+/** `[JavaScript]` Creates a Uint8Array type */
+export function Uint8Array(options: Uint8ArrayOptions = {}): TUint8Array {
+  return { ...options, [Kind]: 'Uint8Array', type: 'Uint8Array' } as unknown as TUint8Array
+}
diff --git a/src/type/undefined/index.ts b/src/type/undefined/index.ts
new file mode 100644
index 000000000..cbc1c28e3
--- /dev/null
+++ b/src/type/undefined/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './undefined'
diff --git a/src/type/undefined/undefined.ts b/src/type/undefined/undefined.ts
new file mode 100644
index 000000000..a069fe06f
--- /dev/null
+++ b/src/type/undefined/undefined.ts
@@ -0,0 +1,40 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+export interface TUndefined extends TSchema {
+  [Kind]: 'Undefined'
+  static: undefined
+  type: 'undefined'
+}
+/** `[JavaScript]` Creates a Undefined type */
+export function Undefined(options: SchemaOptions = {}): TUndefined {
+  return { ...options, [Kind]: 'Undefined', type: 'undefined' } as unknown as TUndefined
+}
diff --git a/src/type/union/index.ts b/src/type/union/index.ts
new file mode 100644
index 000000000..17dd10d72
--- /dev/null
+++ b/src/type/union/index.ts
@@ -0,0 +1,31 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './union-evaluated'
+export * from './union-type'
+export * from './union'
diff --git a/src/type/union/union-create.ts b/src/type/union/union-create.ts
new file mode 100644
index 000000000..c2f261933
--- /dev/null
+++ b/src/type/union/union-create.ts
@@ -0,0 +1,36 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { CloneRest } from '../clone/type'
+import { TUnion } from './union-type'
+import { Kind } from '../symbols/index'
+
+export function UnionCreate<T extends TSchema[]>(T: [...T], options: SchemaOptions): TUnion<T> {
+  return { ...options, [Kind]: 'Union', anyOf: CloneRest(T) } as unknown as TUnion<T>
+}
diff --git a/src/type/union/union-evaluated.ts b/src/type/union/union-evaluated.ts
new file mode 100644
index 000000000..248d4e600
--- /dev/null
+++ b/src/type/union/union-evaluated.ts
@@ -0,0 +1,122 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { SchemaOptions, TSchema } from '../schema/index'
+import { OptionalKind } from '../symbols/index'
+import { CloneType } from '../clone/type'
+import { Discard } from '../discard/index'
+import { Never, type TNever } from '../never/index'
+import { Optional, type TOptional } from '../optional/index'
+import type { TReadonly } from '../readonly/index'
+import type { TUnion } from './union-type'
+import { UnionCreate } from './union-create'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsOptional } from '../guard/type'
+// ------------------------------------------------------------------
+// IsUnionOptional
+// ------------------------------------------------------------------
+// prettier-ignore
+type TIsUnionOptional<T extends TSchema[]> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? 
+    L extends TOptional<TSchema> 
+      ? true 
+      : TIsUnionOptional<R> 
+    : false
+)
+// prettier-ignore
+function IsUnionOptional<T extends TSchema[]>(T: T): TIsUnionOptional<T> {
+  return T.some(L => IsOptional(L)) as TIsUnionOptional<T>
+}
+// ------------------------------------------------------------------
+// RemoveOptionalFromRest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TRemoveOptionalFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? L extends TOptional<infer S extends TSchema>
+      ? TRemoveOptionalFromRest<R, [...Acc, TRemoveOptionalFromType<S>]>
+      : TRemoveOptionalFromRest<R, [...Acc, L]>
+    : Acc
+)
+// prettier-ignore
+function RemoveOptionalFromRest<T extends TSchema[]>(T: T): TRemoveOptionalFromRest<T> {
+  return T.map(L => IsOptional(L) ? RemoveOptionalFromType(L) : L) as TRemoveOptionalFromRest<T>
+}
+// ------------------------------------------------------------------
+// RemoveOptionalFromType
+// ------------------------------------------------------------------
+// prettier-ignore
+type TRemoveOptionalFromType<T extends TSchema> = (
+  T extends TReadonly<infer S extends TSchema> ? TReadonly<TRemoveOptionalFromType<S>> :
+  T extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromType<S> :
+  T
+)
+// prettier-ignore
+function RemoveOptionalFromType<T extends TSchema>(T: T): TRemoveOptionalFromType<T> {
+  return (
+    Discard(T, [OptionalKind])
+  ) as TRemoveOptionalFromType<T>
+}
+// ------------------------------------------------------------------
+// ResolveUnion
+// ------------------------------------------------------------------
+// prettier-ignore
+type TResolveUnion<T extends TSchema[], R extends TSchema[] = TRemoveOptionalFromRest<T>> = (
+  TIsUnionOptional<T> extends true 
+    ? TOptional<TUnion<R>> 
+    : TUnion<R>
+)
+// prettier-ignore
+function ResolveUnion<T extends TSchema[]>(T: T, options: SchemaOptions): TResolveUnion<T> {
+  return (
+    IsUnionOptional(T)
+      ? Optional(UnionCreate(RemoveOptionalFromRest(T) as TSchema[], options))
+      : UnionCreate(RemoveOptionalFromRest(T) as TSchema[], options)
+  ) as TResolveUnion<T>
+}
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TUnionEvaluated<T extends TSchema[]> = (
+  T extends [] ? TNever :
+  T extends [TSchema] ? T[0] :
+  TResolveUnion<T>
+)
+/** `[Json]` Creates an evaluated Union type */
+export function UnionEvaluated<T extends TSchema[], R = TUnionEvaluated<T>>(T: [...T], options: SchemaOptions = {}): R {
+  // prettier-ignore
+  return (
+    T.length === 0 ? Never(options) :
+    T.length === 1 ? CloneType(T[0], options) :
+    ResolveUnion(T, options)
+  ) as R
+}
diff --git a/src/type/union/union-type.ts b/src/type/union/union-type.ts
new file mode 100644
index 000000000..6eb5ba4d3
--- /dev/null
+++ b/src/type/union/union-type.ts
@@ -0,0 +1,48 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import type { Static } from '../static/index'
+import { Kind } from '../symbols/index'
+
+// ------------------------------------------------------------------
+// UnionStatic
+// ------------------------------------------------------------------
+// prettier-ignore
+type UnionStatic<T extends TSchema[], P extends unknown[]> = {
+  [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never 
+}[number]
+
+// ------------------------------------------------------------------
+// TUnion
+// ------------------------------------------------------------------
+export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
+  [Kind]: 'Union'
+  static: UnionStatic<T, this['params']>
+  anyOf: T
+}
diff --git a/src/type/union/union.ts b/src/type/union/union.ts
new file mode 100644
index 000000000..5c5265e97
--- /dev/null
+++ b/src/type/union/union.ts
@@ -0,0 +1,49 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { type TNever, Never } from '../never/index'
+import type { TUnion } from './union-type'
+import { CloneType } from '../clone/type'
+import { UnionCreate } from './union-create'
+
+// prettier-ignore
+export type Union<T extends TSchema[]> = (
+  T extends [] ? TNever :
+  T extends [TSchema] ? T[0] :
+  TUnion<T>
+)
+/** `[Json]` Creates a Union type */
+export function Union<T extends TSchema[]>(T: [...T], options: SchemaOptions = {}): Union<T> {
+  // prettier-ignore
+  return (
+    T.length === 0 ? Never(options) :
+    T.length === 1 ? CloneType(T[0], options) :
+    UnionCreate(T, options)
+  ) as Union<T>
+}
diff --git a/src/type/unknown/index.ts b/src/type/unknown/index.ts
new file mode 100644
index 000000000..7d9c7e293
--- /dev/null
+++ b/src/type/unknown/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './unknown'
diff --git a/src/type/unknown/unknown.ts b/src/type/unknown/unknown.ts
new file mode 100644
index 000000000..f5a0d9a3d
--- /dev/null
+++ b/src/type/unknown/unknown.ts
@@ -0,0 +1,42 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+export interface TUnknown extends TSchema {
+  [Kind]: 'Unknown'
+  static: unknown
+}
+/** `[Json]` Creates an Unknown type */
+export function Unknown(options: SchemaOptions = {}): TUnknown {
+  return {
+    ...options,
+    [Kind]: 'Unknown',
+  } as unknown as TUnknown
+}
diff --git a/src/type/unsafe/index.ts b/src/type/unsafe/index.ts
new file mode 100644
index 000000000..78141b392
--- /dev/null
+++ b/src/type/unsafe/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './unsafe'
diff --git a/src/type/unsafe/unsafe.ts b/src/type/unsafe/unsafe.ts
new file mode 100644
index 000000000..26fb987af
--- /dev/null
+++ b/src/type/unsafe/unsafe.ts
@@ -0,0 +1,45 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+export interface UnsafeOptions extends SchemaOptions {
+  [Kind]?: string
+}
+export interface TUnsafe<T> extends TSchema {
+  [Kind]: string
+  static: T
+}
+/** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
+export function Unsafe<T>(options: UnsafeOptions = {}): TUnsafe<T> {
+  return {
+    ...options,
+    [Kind]: options[Kind] ?? 'Unsafe',
+  } as unknown as TUnsafe<T>
+}
diff --git a/src/type/void/index.ts b/src/type/void/index.ts
new file mode 100644
index 000000000..3b9bf5199
--- /dev/null
+++ b/src/type/void/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './void'
diff --git a/src/type/void/void.ts b/src/type/void/void.ts
new file mode 100644
index 000000000..867f33f47
--- /dev/null
+++ b/src/type/void/void.ts
@@ -0,0 +1,44 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+export interface TVoid extends TSchema {
+  [Kind]: 'Void'
+  static: void
+  type: 'void'
+}
+/** `[JavaScript]` Creates a Void type */
+export function Void(options: SchemaOptions = {}): TVoid {
+  return {
+    ...options,
+    [Kind]: 'Void',
+    type: 'void',
+  } as unknown as TVoid
+}
diff --git a/src/typebox.ts b/src/typebox.ts
deleted file mode 100644
index 57e8cb27b..000000000
--- a/src/typebox.ts
+++ /dev/null
@@ -1,3410 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-// --------------------------------------------------------------------------
-// Symbols
-// --------------------------------------------------------------------------
-export const Transform = Symbol.for('TypeBox.Transform')
-export const Readonly = Symbol.for('TypeBox.Readonly')
-export const Optional = Symbol.for('TypeBox.Optional')
-export const Hint = Symbol.for('TypeBox.Hint')
-export const Kind = Symbol.for('TypeBox.Kind')
-// --------------------------------------------------------------------------
-// Patterns
-// --------------------------------------------------------------------------
-export const PatternBoolean = '(true|false)'
-export const PatternNumber = '(0|[1-9][0-9]*)'
-export const PatternString = '(.*)'
-export const PatternBooleanExact = `^${PatternBoolean}$`
-export const PatternNumberExact = `^${PatternNumber}$`
-export const PatternStringExact = `^${PatternString}$`
-// --------------------------------------------------------------------------
-// Helpers
-// --------------------------------------------------------------------------
-export type TupleToIntersect<T extends any[]> = T extends [infer I] ? I : T extends [infer I, ...infer R] ? I & TupleToIntersect<R> : never
-export type TupleToUnion<T extends any[]> = { [K in keyof T]: T[K] }[number]
-export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never
-export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never
-export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L]
-export type Discard<T extends unknown[], D extends unknown> = T extends [infer L, ...infer R] ? (L extends D ? Discard<R, D> : [L, ...Discard<R, D>]) : []
-export type Flat<T> = T extends [] ? [] : T extends [infer L] ? [...Flat<L>] : T extends [infer L, ...infer R] ? [...Flat<L>, ...Flat<R>] : [T]
-export type Trim<T> = T extends `${' '}${infer U}` ? Trim<U> : T extends `${infer U}${' '}` ? Trim<U> : T
-export type Assert<T, E> = T extends E ? T : never
-export type Evaluate<T> = T extends infer O ? { [K in keyof O]: O[K] } : never
-export type Ensure<T> = T extends infer U ? U : never
-// --------------------------------------------------------------------------
-// Type Assertions
-// --------------------------------------------------------------------------
-export type AssertProperties<T> = T extends TProperties ? T : TProperties
-export type AssertRest<T, E extends TSchema[] = TSchema[]> = T extends E ? T : []
-export type AssertType<T, E extends TSchema = TSchema> = T extends E ? T : TNever
-// --------------------------------------------------------------------------
-// Modifiers
-// --------------------------------------------------------------------------
-export type TReadonlyOptional<T extends TSchema> = TOptional<T> & TReadonly<T>
-export type TReadonly<T extends TSchema> = T & { [Readonly]: 'Readonly' }
-export type TOptional<T extends TSchema> = T & { [Optional]: 'Optional' }
-// --------------------------------------------------------------------------
-// Readonly Unwrap
-// --------------------------------------------------------------------------
-// prettier-ignore
-export type ReadonlyUnwrapType<T extends TSchema> =
-  T extends TReadonly<infer S> ? ReadonlyUnwrapType<S> : 
-  T extends TOptional<infer S> ? TOptional<ReadonlyUnwrapType<S>> :
-  T
-// prettier-ignore
-export type ReadonlyUnwrapRest<T extends TSchema[]> = T extends [infer L, ...infer R]
-  ? L extends TReadonly<infer S>
-    ? [ReadonlyUnwrapType<AssertType<S>>, ...ReadonlyUnwrapRest<AssertRest<R>>] 
-    : [L, ...ReadonlyUnwrapRest<AssertRest<R>>]
-  :  []
-// --------------------------------------------------------------------------
-// Optional Unwrap
-// --------------------------------------------------------------------------
-// prettier-ignore
-export type OptionalUnwrapType<T extends TSchema> =
-  T extends TReadonly<infer S> ? TReadonly<OptionalUnwrapType<S>> :
-  T extends TOptional<infer S> ? OptionalUnwrapType<S> : 
-  T
-// prettier-ignore
-export type OptionalUnwrapRest<T extends TSchema[]> = T extends [infer L, ...infer R]
-  ? L extends TOptional<infer S>
-    ? [OptionalUnwrapType<AssertType<S>>, ...OptionalUnwrapRest<AssertRest<R>>] 
-    : [L, ...OptionalUnwrapRest<AssertRest<R>>]
-  :  []
-// --------------------------------------------------------------------------
-// IntersectType
-// --------------------------------------------------------------------------
-// prettier-ignore
-export type IntersectOptional<T extends TSchema[]> = T extends [infer L, ...infer R] 
-  ? L extends TOptional<AssertType<L>> 
-    ? IntersectOptional<AssertRest<R>> 
-    : false
-  : true
-// prettier-ignore
-export type IntersectResolve<T extends TSchema[], U = OptionalUnwrapRest<AssertRest<T>>> = IntersectOptional<AssertRest<T>> extends true
-  ? TOptional<TIntersect<AssertRest<U>>>
-  : TIntersect<AssertRest<U>>
-// prettier-ignore
-export type IntersectType<T extends TSchema[]> = 
-    T extends [] ? TNever : 
-    T extends [TSchema] ? AssertType<T[0]> : 
-    IntersectResolve<T>
-// --------------------------------------------------------------------------
-// UnionType
-// --------------------------------------------------------------------------
-// prettier-ignore
-export type UnionOptional<T extends TSchema[]> = T extends [infer L, ...infer R]
-  ? L extends (TOptional<AssertType<L>>)
-    ? true 
-    : UnionOptional<AssertRest<R>> 
-  : false
-// prettier-ignore
-export type UnionResolve<T extends TSchema[], U = OptionalUnwrapRest<AssertRest<T>>> = UnionOptional<AssertRest<T>> extends true
-  ? TOptional<TUnion<AssertRest<U>>>
-  : TUnion<AssertRest<U>>
-// prettier-ignore
-export type UnionType<T extends TSchema[]> = 
-  T extends [] ? TNever : 
-  T extends [TSchema] ? AssertType<T[0]> : 
-  UnionResolve<T>
-// --------------------------------------------------------------------------
-// TSchema
-// --------------------------------------------------------------------------
-export interface SchemaOptions {
-  $schema?: string
-  /** Id for this schema */
-  $id?: string
-  /** Title of this schema */
-  title?: string
-  /** Description of this schema */
-  description?: string
-  /** Default value for this schema */
-  default?: any
-  /** Example values matching this schema */
-  examples?: any
-  /** Optional annotation for readOnly */
-  readOnly?: boolean
-  /** Optional annotation for writeOnly */
-  writeOnly?: boolean
-  [prop: string]: any
-}
-export interface TKind {
-  [Kind]: string
-}
-export interface TSchema extends SchemaOptions, TKind {
-  [Readonly]?: string
-  [Optional]?: string
-  [Hint]?: string
-  params: unknown[]
-  static: unknown
-}
-// --------------------------------------------------------------------------
-// TAnySchema
-// --------------------------------------------------------------------------
-export type TAnySchema =
-  | TSchema
-  | TAny
-  | TArray
-  | TAsyncIterator
-  | TBigInt
-  | TBoolean
-  | TConstructor
-  | TDate
-  | TEnum
-  | TFunction
-  | TInteger
-  | TIntersect
-  | TIterator
-  | TLiteral
-  | TNot
-  | TNull
-  | TNumber
-  | TObject
-  | TPromise
-  | TRecord
-  | TRef
-  | TString
-  | TSymbol
-  | TTemplateLiteral
-  | TThis
-  | TTuple
-  | TUndefined
-  | TUnion
-  | TUint8Array
-  | TUnknown
-  | TVoid
-// --------------------------------------------------------------------------
-// TNumeric
-// --------------------------------------------------------------------------
-export interface NumericOptions<N extends number | bigint> extends SchemaOptions {
-  exclusiveMaximum?: N
-  exclusiveMinimum?: N
-  maximum?: N
-  minimum?: N
-  multipleOf?: N
-}
-// --------------------------------------------------------------------------
-// TAny
-// --------------------------------------------------------------------------
-export interface TAny extends TSchema {
-  [Kind]: 'Any'
-  static: any
-}
-// --------------------------------------------------------------------------
-// TArray
-// --------------------------------------------------------------------------
-export interface ArrayOptions extends SchemaOptions {
-  /** The minimum number of items in this array */
-  minItems?: number
-  /** The maximum number of items in this array */
-  maxItems?: number
-  /** Should this schema contain unique items */
-  uniqueItems?: boolean
-  /** A schema for which some elements should match */
-  contains?: TSchema
-  /** A minimum number of contains schema matches */
-  minContains?: number
-  /** A maximum number of contains schema matches */
-  maxContains?: number
-}
-export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
-  [Kind]: 'Array'
-  static: Static<T, this['params']>[]
-  type: 'array'
-  items: T
-}
-// --------------------------------------------------------------------------
-// TAsyncIterator
-// --------------------------------------------------------------------------
-export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
-  [Kind]: 'AsyncIterator'
-  static: AsyncIterableIterator<Static<T, this['params']>>
-  type: 'AsyncIterator'
-  items: T
-}
-// -------------------------------------------------------------------------------
-// TAwaited
-// -------------------------------------------------------------------------------
-// prettier-ignore
-export type TAwaitedRest<T extends TSchema[]> = T extends [infer L, ...infer R]
-  ? [TAwaited<AssertType<L>>, ...TAwaitedRest<AssertRest<R>>]
-  : []
-// prettier-ignore
-export type TAwaited<T extends TSchema> = 
-  T extends TIntersect<infer S> ? TIntersect<TAwaitedRest<S>> :
-  T extends TUnion<infer S>     ? TUnion<TAwaitedRest<S>> :
-  T extends TPromise<infer S>   ? TAwaited<S> :
-  T
-// --------------------------------------------------------------------------
-// TBigInt
-// --------------------------------------------------------------------------
-export interface TBigInt extends TSchema, NumericOptions<bigint> {
-  [Kind]: 'BigInt'
-  static: bigint
-  type: 'bigint'
-}
-// --------------------------------------------------------------------------
-// TBoolean
-// --------------------------------------------------------------------------
-export interface TBoolean extends TSchema {
-  [Kind]: 'Boolean'
-  static: boolean
-  type: 'boolean'
-}
-// --------------------------------------------------------------------------
-// TConstructorParameters
-// --------------------------------------------------------------------------
-export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = Ensure<TTuple<T['parameters']>>
-// --------------------------------------------------------------------------
-// TInstanceType
-// --------------------------------------------------------------------------
-export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns']
-// --------------------------------------------------------------------------
-// TComposite
-// --------------------------------------------------------------------------
-// prettier-ignore
-export type TCompositeKeys<T extends TObject[]> = T extends [infer L, ...infer R] 
-  ? keyof Assert<L, TObject>['properties'] | TCompositeKeys<Assert<R, TObject[]>>
-  : never
-// prettier-ignore
-export type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[]> = K extends [infer L, ...infer R] 
-  ? { [_ in Assert<L, string>]: TIndexType<T, Assert<L, string>> } & TCompositeIndex<T, Assert<R, string[]>> 
-  : {}
-// prettier-ignore
-export type TCompositeReduce<T extends TObject[]> = UnionToTuple<TCompositeKeys<T>> extends infer K 
-  ? Evaluate<TCompositeIndex<TIntersect<T>, Assert<K, string[]>>> 
-  : {} //                    ^ indexed via intersection of T
-// prettier-ignore
-export type TComposite<T extends TObject[]> = TIntersect<T> extends TIntersect 
-  ? TObject<TCompositeReduce<T>>
-  : TObject<{}>
-// --------------------------------------------------------------------------
-// TConstructor
-// --------------------------------------------------------------------------
-export type TConstructorReturnTypeResolve<T extends TSchema, P extends unknown[]> = Static<T, P>
-export type TConstructorParametersResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TFunctionParametersResolve<R, P>] : []
-export type TConstructorResolve<T extends TSchema[], U extends TSchema, P extends unknown[]> = Ensure<new (...param: TConstructorParametersResolve<T, P>) => TConstructorReturnTypeResolve<U, P>>
-export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
-  [Kind]: 'Constructor'
-  static: TConstructorResolve<T, U, this['params']>
-  type: 'Constructor'
-  parameters: T
-  returns: U
-}
-// --------------------------------------------------------------------------
-// TDate
-// --------------------------------------------------------------------------
-export interface DateOptions extends SchemaOptions {
-  /** The exclusive maximum timestamp value */
-  exclusiveMaximumTimestamp?: number
-  /** The exclusive minimum timestamp value */
-  exclusiveMinimumTimestamp?: number
-  /** The maximum timestamp value */
-  maximumTimestamp?: number
-  /** The minimum timestamp value */
-  minimumTimestamp?: number
-  /** The multiple of timestamp value */
-  multipleOfTimestamp?: number
-}
-export interface TDate extends TSchema, DateOptions {
-  [Kind]: 'Date'
-  static: Date
-  type: 'date'
-}
-// --------------------------------------------------------------------------
-// TEnum
-// --------------------------------------------------------------------------
-export type TEnumRecord = Record<TEnumKey, TEnumValue>
-export type TEnumValue = string | number
-export type TEnumKey = string
-export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
-  [Kind]: 'Union'
-  [Hint]: 'Enum'
-  static: T[keyof T]
-  anyOf: TLiteral<T[keyof T]>[]
-}
-// --------------------------------------------------------------------------
-// TExtends
-// --------------------------------------------------------------------------
-// prettier-ignore
-export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = 
-  (Static<L> extends Static<R> ? T : U) extends infer O ? 
-    UnionToTuple<O> extends [infer X, infer Y] ? TUnion<[AssertType<X>, AssertType<Y>]> : AssertType<O>
-  : never
-// --------------------------------------------------------------------------
-// TExclude
-// --------------------------------------------------------------------------
-export type TExcludeTemplateLiteralResult<T extends string> = UnionType<AssertRest<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
-export type TExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Exclude<Static<T>, Static<U>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never
-// prettier-ignore
-export type TExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
-  [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? never : T[K]
-}[number]>> extends infer R ? UnionType<AssertRest<R>> : never
-// prettier-ignore
-export type TExclude<T extends TSchema, U extends TSchema> = 
-  T extends TTemplateLiteral ? TExcludeTemplateLiteral<T, U> : 
-  T extends TUnion<infer S> ? TExcludeArray<S, U> : 
-  T extends U ? TNever : T
-// --------------------------------------------------------------------------
-// TExtract
-// --------------------------------------------------------------------------
-export type TExtractTemplateLiteralResult<T extends string> = UnionType<AssertRest<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
-export type TExtractTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? TExtractTemplateLiteralResult<Assert<S, string>> : never
-// prettier-ignore
-export type TExtractArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<
-  {[K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? T[K] : never
-}[number]>> extends infer R ? UnionType<AssertRest<R>> : never
-// prettier-ignore
-export type TExtract<T extends TSchema, U extends TSchema> = 
-  T extends TTemplateLiteral ? TExtractTemplateLiteral<T, U> : 
-  T extends TUnion<infer S> ? TExtractArray<S, U> : 
-  T extends U ? T : T
-// --------------------------------------------------------------------------
-// TFunction
-// --------------------------------------------------------------------------
-export type TFunctionReturnTypeResolve<T extends TSchema, P extends unknown[]> = Static<T, P>
-export type TFunctionParametersResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TFunctionParametersResolve<R, P>] : []
-export type TFunctionResolve<T extends TSchema[], U extends TSchema, P extends unknown[]> = Ensure<(...param: TFunctionParametersResolve<T, P>) => TFunctionReturnTypeResolve<U, P>>
-export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
-  [Kind]: 'Function'
-  static: TFunctionResolve<T, U, this['params']>
-  type: 'Function'
-  parameters: T
-  returns: U
-}
-// --------------------------------------------------------------------------
-// TIndex
-// --------------------------------------------------------------------------
-export type TIndexRest<T extends TSchema[], K extends TPropertyKey> = T extends [infer L, ...infer R] ? [TIndexType<AssertType<L>, K>, ...TIndexRest<AssertRest<R>, K>] : []
-export type TIndexProperty<T extends TProperties, K extends TPropertyKey> = K extends keyof T ? [T[K]] : []
-export type TIndexTuple<T extends TSchema[], K extends TPropertyKey> = K extends keyof T ? [T[K]] : []
-// prettier-ignore
-export type TIndexType<T extends TSchema, K extends TPropertyKey> =
-  T extends TRecursive<infer S> ? TIndexType<S, K> :
-  T extends TIntersect<infer S> ? IntersectType<AssertRest<Discard<Flat<TIndexRest<S, K>>, TNever>>> :
-  T extends TUnion<infer S>     ? UnionType<AssertRest<Flat<TIndexRest<S, K>>>> :
-  T extends TObject<infer S>    ? UnionType<AssertRest<Flat<TIndexProperty<S, K>>>> :
-  T extends TTuple<infer S>     ? UnionType<AssertRest<Flat<TIndexTuple<S, K>>>> :
-  []
-// prettier-ignore
-export type TIndexRestMany<T extends TSchema, K extends TPropertyKey[]> = 
- K extends [infer L, ...infer R] ? [TIndexType<T, Assert<L, TPropertyKey>>, ...TIndexRestMany<T, Assert<R, TPropertyKey[]>>] :
- []
-// prettier-ignore
-export type TIndex<T extends TSchema, K extends TPropertyKey[]> =
-  T extends TRecursive<infer S> ? TIndex<S, K> :
-  T extends TIntersect ? UnionType<Flat<TIndexRestMany<T, K>>> :
-  T extends TUnion     ? UnionType<Flat<TIndexRestMany<T, K>>> :
-  T extends TObject    ? UnionType<Flat<TIndexRestMany<T, K>>> :
-  T extends TTuple     ? UnionType<Flat<TIndexRestMany<T, K>>> :
-  TNever
-// --------------------------------------------------------------------------
-// TIntrinsic
-// --------------------------------------------------------------------------
-export type TIntrinsicMode = 'Uppercase' | 'Lowercase' | 'Capitalize' | 'Uncapitalize'
-// prettier-ignore
-export type TIntrinsicTemplateLiteral<T extends TTemplateLiteralKind[], M extends TIntrinsicMode> =
-  M extends ('Lowercase' | 'Uppercase')     ? T extends [infer L, ...infer R] ? [TIntrinsic<AssertType<L>, M>, ...TIntrinsicTemplateLiteral<AssertRest<R>, M>] : T :  
-  M extends ('Capitalize' | 'Uncapitalize') ? T extends [infer L, ...infer R] ? [TIntrinsic<AssertType<L>, M>, ...R] : T :  
-  T
-// prettier-ignore
-export type TIntrinsicLiteral<T, M extends TIntrinsicMode> = 
-  T extends string ? 
-    M extends 'Uncapitalize' ? Uncapitalize<T> :  
-    M extends 'Capitalize' ? Capitalize<T> :
-    M extends 'Uppercase' ? Uppercase<T> :
-    M extends 'Lowercase' ? Lowercase<T> :
-    string
-  : T
-// prettier-ignore
-export type TIntrinsicRest<T extends TSchema[], M extends TIntrinsicMode> = T extends [infer L, ...infer R]
-  ? [TIntrinsic<AssertType<L>, M>, ...TIntrinsicRest<AssertRest<R>, M>]
-  : []
-// prettier-ignore
-export type TIntrinsic<T extends TSchema, M extends TIntrinsicMode> =
-  T extends TTemplateLiteral<infer S> ? TTemplateLiteral<TIntrinsicTemplateLiteral<S, M>> :
-  T extends TUnion<infer S> ? TUnion<TIntrinsicRest<S, M>> :
-  T extends TLiteral<infer S> ? TLiteral<TIntrinsicLiteral<S, M>> :
-  T
-// --------------------------------------------------------------------------
-// TInteger
-// --------------------------------------------------------------------------
-export interface TInteger extends TSchema, NumericOptions<number> {
-  [Kind]: 'Integer'
-  static: number
-  type: 'integer'
-}
-// --------------------------------------------------------------------------
-// TIntersect
-// --------------------------------------------------------------------------
-export type TUnevaluatedProperties = undefined | TSchema | boolean
-export interface IntersectOptions extends SchemaOptions {
-  unevaluatedProperties?: TUnevaluatedProperties
-}
-export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
-  [Kind]: 'Intersect'
-  static: TupleToIntersect<{ [K in keyof T]: Static<AssertType<T[K]>, this['params']> }>
-  type?: 'object'
-  allOf: [...T]
-}
-// --------------------------------------------------------------------------
-// TIterator
-// --------------------------------------------------------------------------
-export interface TIterator<T extends TSchema = TSchema> extends TSchema {
-  [Kind]: 'Iterator'
-  static: IterableIterator<Static<T, this['params']>>
-  type: 'Iterator'
-  items: T
-}
-// --------------------------------------------------------------------------
-// TKeyOf
-// --------------------------------------------------------------------------
-// prettier-ignore
-export type TKeyOfProperties<T extends TSchema> = Discard<Static<T> extends infer S
-  ? UnionToTuple<{[K in keyof S]: TLiteral<Assert<K, TLiteralValue>>}[keyof S]>
-  : [], undefined> // note: optional properties produce undefined types in tuple result. discard.
-// prettier-ignore
-export type TKeyOfIndicesArray<T extends TSchema[]> = UnionToTuple<keyof T & `${number}`>
-// prettier-ignore
-export type TKeyOfIndices<T extends TSchema[]> = AssertRest<TKeyOfIndicesArray<T> extends infer R ? {
-  [K in keyof R] : TLiteral<Assert<R[K], TLiteralValue>>
-}: []>
-// prettier-ignore
-export type TKeyOf<T extends TSchema = TSchema> = (
-  T extends TRecursive<infer S> ? TKeyOfProperties<S> :
-  T extends TIntersect          ? TKeyOfProperties<T> :
-  T extends TUnion              ? TKeyOfProperties<T> :
-  T extends TObject             ? TKeyOfProperties<T> :
-  T extends TTuple<infer K>     ? TKeyOfIndices<K> :
-  T extends TArray              ? [TNumber] :
-  T extends TRecord<infer K>    ? [K] :
-  []
-) extends infer R ? UnionType<AssertRest<R>> : never
-// --------------------------------------------------------------------------
-// TLiteral
-// --------------------------------------------------------------------------
-export type TLiteralValue = boolean | number | string // | bigint - supported but variant disable due to potential numeric type conflicts
-export type TLiteralBoolean = TLiteral<boolean>
-export type TLiteralNumber = TLiteral<number>
-export type TLiteralString = TLiteral<string>
-export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
-  [Kind]: 'Literal'
-  static: T
-  const: T
-}
-// --------------------------------------------------------------------------
-// TNever
-// --------------------------------------------------------------------------
-export interface TNever extends TSchema {
-  [Kind]: 'Never'
-  static: never
-  not: {}
-}
-// --------------------------------------------------------------------------
-// TNot
-// --------------------------------------------------------------------------
-export interface TNot<T extends TSchema = TSchema> extends TSchema {
-  [Kind]: 'Not'
-  static: T extends TNot<infer U> ? Static<U> : unknown
-  not: T
-}
-// --------------------------------------------------------------------------
-// TNull
-// --------------------------------------------------------------------------
-export interface TNull extends TSchema {
-  [Kind]: 'Null'
-  static: null
-  type: 'null'
-}
-// --------------------------------------------------------------------------
-// TNumber
-// --------------------------------------------------------------------------
-export interface TNumber extends TSchema, NumericOptions<number> {
-  [Kind]: 'Number'
-  static: number
-  type: 'number'
-}
-// --------------------------------------------------------------------------
-// TObject
-// --------------------------------------------------------------------------
-export type ReadonlyOptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never }[keyof T]
-export type ReadonlyPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? never : K) : never }[keyof T]
-export type OptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : K) : never }[keyof T]
-export type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>
-// prettier-ignore
-export type PropertiesReducer<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(
-  Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> &
-  Readonly<Pick<R, ReadonlyPropertyKeys<T>>> &
-  Partial<Pick<R, OptionalPropertyKeys<T>>> &
-  Required<Pick<R, RequiredPropertyKeys<T>>>
-)>
-// prettier-ignore
-export type PropertiesReduce<T extends TProperties, P extends unknown[]> = PropertiesReducer<T, {
-  [K in keyof T]: Static<T[K], P>
-}>
-export type TPropertyKey = string | number
-export type TProperties = Record<TPropertyKey, TSchema>
-export type ObjectProperties<T> = T extends TObject<infer U> ? U : never
-export type ObjectPropertyKeys<T> = T extends TObject<infer U> ? keyof U : never
-export type TAdditionalProperties = undefined | TSchema | boolean
-export interface ObjectOptions extends SchemaOptions {
-  /** Additional property constraints for this object */
-  additionalProperties?: TAdditionalProperties
-  /** The minimum number of properties allowed on this object */
-  minProperties?: number
-  /** The maximum number of properties allowed on this object */
-  maxProperties?: number
-}
-export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
-  [Kind]: 'Object'
-  static: PropertiesReduce<T, this['params']>
-  additionalProperties?: TAdditionalProperties
-  type: 'object'
-  properties: T
-  required?: string[]
-}
-// --------------------------------------------------------------------------
-// TOmit
-// --------------------------------------------------------------------------
-export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<AssertProperties<Omit<T, K>>>
-export type TOmitRest<T extends TSchema[], K extends keyof any> = AssertRest<{ [K2 in keyof T]: TOmit<AssertType<T[K2]>, K> }>
-// prettier-ignore
-export type TOmit<T extends TSchema = TSchema, K extends keyof any = keyof any> = 
-  T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> :
-  T extends TIntersect<infer S> ? TIntersect<TOmitRest<S, K>> : 
-  T extends TUnion<infer S> ? TUnion<TOmitRest<S, K>> : 
-  T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : 
-  T
-// --------------------------------------------------------------------------
-// TParameters
-// --------------------------------------------------------------------------
-export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>
-// --------------------------------------------------------------------------
-// TPartial
-// --------------------------------------------------------------------------
-export type TPartialObjectArray<T extends TObject[]> = AssertRest<{ [K in keyof T]: TPartial<AssertType<T[K], TObject>> }, TObject[]>
-export type TPartialRest<T extends TSchema[]> = AssertRest<{ [K in keyof T]: TPartial<AssertType<T[K]>> }>
-// prettier-ignore
-export type TPartialProperties<T extends TProperties> = Evaluate<AssertProperties<{
-  [K in keyof T]: 
-    T[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : 
-    T[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : 
-    T[K] extends (TOptional<infer S>) ? TOptional<S> : 
-    TOptional<T[K]>
-}>>
-// prettier-ignore
-export type TPartial<T extends TSchema> =  
-  T extends TRecursive<infer S> ? TRecursive<TPartial<S>> :   
-  T extends TIntersect<infer S> ? TIntersect<TPartialRest<S>> : 
-  T extends TUnion<infer S>     ? TUnion<TPartialRest<S>> : 
-  T extends TObject<infer S>    ? TObject<TPartialProperties<S>> : 
-  T
-// --------------------------------------------------------------------------
-// TPick
-// --------------------------------------------------------------------------
-// Note the key K will overlap for varying TProperties gathered via recursive union and intersect traversal. Because of this,
-// we need to extract only keys assignable to T on K2. This behavior is only required for Pick only.
-// prettier-ignore
-export type TPickProperties<T extends TProperties, K extends keyof any> = 
-  Pick<T, Assert<Extract<K, keyof T>, keyof T>> extends infer R ? ({
-    [K in keyof R]: AssertType<R[K]> extends TSchema ? R[K] : never
-  }): never
-export type TPickRest<T extends TSchema[], K extends keyof any> = { [K2 in keyof T]: TPick<AssertType<T[K2]>, K> }
-// prettier-ignore
-export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any> = 
-  T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> :
-  T extends TIntersect<infer S> ? TIntersect<TPickRest<S, K>> : 
-  T extends TUnion<infer S> ? TUnion<TPickRest<S, K>> : 
-  T extends TObject<infer S> ? TObject<TPickProperties<S, K>> :
-  T
-// --------------------------------------------------------------------------
-// TPromise
-// --------------------------------------------------------------------------
-export interface TPromise<T extends TSchema = TSchema> extends TSchema {
-  [Kind]: 'Promise'
-  static: Promise<Static<T, this['params']>>
-  type: 'Promise'
-  item: TSchema
-}
-// --------------------------------------------------------------------------
-// TRecord
-// --------------------------------------------------------------------------
-export type TRecordFromUnionLiteralString<K extends TLiteralString, T extends TSchema> = { [_ in K['const']]: T }
-export type TRecordFromUnionLiteralNumber<K extends TLiteralNumber, T extends TSchema> = { [_ in K['const']]: T }
-// prettier-ignore
-export type TRecordFromEnumKey<K extends Record<string, string | number>, T extends TSchema> = Ensure<TObject<{ [_ in K[keyof K]]: T }>>
-// prettier-ignore
-export type TRecordFromUnionRest<K extends TSchema[], T extends TSchema> = K extends [infer L, ...infer R] ? (
-  L extends TUnion<infer S> ? TRecordFromUnionRest<S, T> & TRecordFromUnionRest<AssertRest<R>, T> :
-  L extends TLiteralString ? TRecordFromUnionLiteralString<L, T> & TRecordFromUnionRest<AssertRest<R>, T> :
-  L extends TLiteralNumber ? TRecordFromUnionLiteralNumber<L, T> & TRecordFromUnionRest<AssertRest<R>, T> :
-{}) : {}
-export type TRecordFromUnion<K extends TSchema[], T extends TSchema> = Ensure<TObject<AssertProperties<Evaluate<TRecordFromUnionRest<K, T>>>>>
-export type TRecordFromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>
-export type TRecordFromTemplateLiteralKeyFinite<K extends TTemplateLiteral, T extends TSchema, I = Static<K>> = Ensure<TObject<Evaluate<{ [_ in Assert<I, string>]: T }>>>
-// prettier-ignore
-export type TRecordFromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends false 
-  ? TRecordFromTemplateLiteralKeyInfinite<K, T> 
-  : TRecordFromTemplateLiteralKeyFinite<K, T>
-export type TRecordFromLiteralStringKey<K extends TLiteralString, T extends TSchema> = Ensure<TObject<{ [_ in K['const']]: T }>>
-export type TRecordFromLiteralNumberKey<K extends TLiteralNumber, T extends TSchema> = Ensure<TObject<{ [_ in K['const']]: T }>>
-export type TRecordFromStringKey<K extends TString, T extends TSchema> = Ensure<TRecord<K, T>>
-export type TRecordFromNumberKey<K extends TNumber, T extends TSchema> = Ensure<TRecord<K, T>>
-export type TRecordFromIntegerKey<K extends TInteger, T extends TSchema> = Ensure<TRecord<K, T>>
-// prettier-ignore
-export type TRecordResolve<K extends TSchema, T extends TSchema> = 
-  K extends TEnum<infer S> ? TRecordFromEnumKey<S, T> : // Enum before Union (intercept Hint)
-  K extends TUnion<infer S> ? TRecordFromUnion<S, T> :
-  K extends TTemplateLiteral ? TRecordFromTemplateLiteralKey<K, T> :
-  K extends TLiteralString ? TRecordFromLiteralStringKey<K, T> :
-  K extends TLiteralNumber ? TRecordFromLiteralNumberKey<K, T> :
-  K extends TString ? TRecordFromStringKey<K, T> :
-  K extends TNumber ? TRecordFromNumberKey<K, T> :
-  K extends TInteger ? TRecordFromIntegerKey<K, T> :
-  TNever
-export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
-  [Kind]: 'Record'
-  static: Record<Assert<Static<K>, string | number>, Static<T, this['params']>>
-  type: 'object'
-  patternProperties: { [pattern: string]: T }
-  additionalProperties: TAdditionalProperties
-}
-// --------------------------------------------------------------------------
-// TRecursive
-// --------------------------------------------------------------------------
-export interface TThis extends TSchema {
-  [Kind]: 'This'
-  static: this['params'][0]
-  $ref: string
-}
-export type TRecursiveReduce<T extends TSchema> = Static<T, [TRecursiveReduce<T>]>
-export interface TRecursive<T extends TSchema> extends TSchema {
-  [Hint]: 'Recursive'
-  static: TRecursiveReduce<T>
-}
-// --------------------------------------------------------------------------
-// TRef
-// --------------------------------------------------------------------------
-export interface TRef<T extends TSchema = TSchema> extends TSchema {
-  [Kind]: 'Ref'
-  static: Static<T, this['params']>
-  $ref: string
-}
-// --------------------------------------------------------------------------
-// TRest
-// --------------------------------------------------------------------------
-export type TRest<T extends TSchema> = T extends TIntersect<infer R> ? R : T extends TUnion<infer R> ? R : T extends TTuple<infer R> ? R : []
-// --------------------------------------------------------------------------
-// TReturnType
-// --------------------------------------------------------------------------
-export type TReturnType<T extends TFunction> = T['returns']
-// --------------------------------------------------------------------------
-// TRequired
-// --------------------------------------------------------------------------
-export type TRequiredRest<T extends TSchema[]> = AssertRest<{ [K in keyof T]: TRequired<AssertType<T[K]>> }>
-// prettier-ignore
-export type TRequiredProperties<T extends TProperties> = Evaluate<AssertProperties<{
-  [K in keyof T]: 
-    T[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> : 
-    T[K] extends (TReadonly<infer S>) ? TReadonly<S> : 
-    T[K] extends (TOptional<infer S>) ? S : 
-    T[K]
-}>>
-// prettier-ignore
-export type TRequired<T extends TSchema> = 
-  T extends TRecursive<infer S> ? TRecursive<TRequired<S>> :   
-  T extends TIntersect<infer S> ? TIntersect<TRequiredRest<S>> : 
-  T extends TUnion<infer S>     ? TUnion<TRequiredRest<S>> : 
-  T extends TObject<infer S>    ? TObject<TRequiredProperties<S>> : 
-  T
-// --------------------------------------------------------------------------
-// TString
-// --------------------------------------------------------------------------
-export type StringFormatOption =
-  | 'date-time'
-  | 'time'
-  | 'date'
-  | 'email'
-  | 'idn-email'
-  | 'hostname'
-  | 'idn-hostname'
-  | 'ipv4'
-  | 'ipv6'
-  | 'uri'
-  | 'uri-reference'
-  | 'iri'
-  | 'uuid'
-  | 'iri-reference'
-  | 'uri-template'
-  | 'json-pointer'
-  | 'relative-json-pointer'
-  | 'regex'
-  | ({} & string)
-// prettier-ignore
-export type StringContentEncodingOption = 
-  | '7bit' 
-  | '8bit' 
-  | 'binary' 
-  | 'quoted-printable' 
-  | 'base64' 
-  | ({} & string)
-export interface StringOptions extends SchemaOptions {
-  /** The maximum string length */
-  maxLength?: number
-  /** The minimum string length */
-  minLength?: number
-  /** A regular expression pattern this string should match */
-  pattern?: string
-  /** A format this string should match */
-  format?: StringFormatOption
-  /** The content encoding for this string */
-  contentEncoding?: StringContentEncodingOption
-  /** The content media type for this string */
-  contentMediaType?: string
-}
-export interface TString extends TSchema, StringOptions {
-  [Kind]: 'String'
-  static: string
-  type: 'string'
-}
-// --------------------------------------------------------------------------
-// TSymbol
-// --------------------------------------------------------------------------
-export type SymbolValue = string | number | undefined
-export interface TSymbol extends TSchema, SchemaOptions {
-  [Kind]: 'Symbol'
-  static: symbol
-  type: 'symbol'
-}
-// -------------------------------------------------------------------------
-// TTemplateLiteralParserDsl
-// -------------------------------------------------------------------------
-// prettier-ignore
-export type TTemplateLiteralDslParserUnionLiteral<T extends string> = 
-  T extends `${infer L}|${infer R}` ? [TLiteral<Trim<L>>, ...TTemplateLiteralDslParserUnionLiteral<R>] : 
-  T extends `${infer L}` ? [TLiteral<Trim<L>>] : 
-  []
-export type TTemplateLiteralDslParserUnion<T extends string> = UnionType<TTemplateLiteralDslParserUnionLiteral<T>>
-// prettier-ignore
-export type TTemplateLiteralDslParserTerminal<T extends string> = 
-  T extends 'boolean' ? TBoolean :  
-  T extends 'bigint' ? TBigInt :  
-  T extends 'number' ? TNumber :
-  T extends 'string' ? TString :
-  TTemplateLiteralDslParserUnion<T>
-// prettier-ignore
-export type TTemplateLiteralDslParserTemplate<T extends string> = 
-  T extends `{${infer L}}${infer R}` ? [TTemplateLiteralDslParserTerminal<L>, ...TTemplateLiteralDslParserTemplate<R>] :
-  T extends `${infer L}$${infer R}`  ? [TLiteral<L>, ...TTemplateLiteralDslParserTemplate<R>] :
-  T extends `${infer L}`             ? [TLiteral<L>] : 
-  []
-export type TTemplateLiteralDslParser<T extends string> = Ensure<TTemplateLiteral<Assert<TTemplateLiteralDslParserTemplate<T>, TTemplateLiteralKind[]>>>
-// --------------------------------------------------------------------------
-// TTemplateLiteral
-// --------------------------------------------------------------------------
-// prettier-ignore
-export type IsTemplateLiteralFiniteCheck<T> =
-  T extends TTemplateLiteral<infer U> ? IsTemplateLiteralFiniteArray<Assert<U, TTemplateLiteralKind[]>> :    
-  T extends TUnion<infer U> ? IsTemplateLiteralFiniteArray<Assert<U, TTemplateLiteralKind[]>> :    
-  T extends TString ? false :
-  T extends TBoolean ? false :
-  T extends TNumber ? false :
-  T extends TInteger ? false :
-  T extends TBigInt ? false :
-  T extends TLiteral ? true  : 
-  false
-// prettier-ignore
-export type IsTemplateLiteralFiniteArray<T extends TTemplateLiteralKind[]> = 
-  T extends [infer L, ...infer R] ? IsTemplateLiteralFiniteCheck<L> extends false ? false : IsTemplateLiteralFiniteArray<Assert<R, TTemplateLiteralKind[]>> :
-  true
-export type IsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? IsTemplateLiteralFiniteArray<U> : false
-export type TTemplateLiteralKind = TUnion | TLiteral | TInteger | TTemplateLiteral | TNumber | TBigInt | TString | TBoolean | TNever
-// prettier-ignore
-export type TTemplateLiteralConst<T, Acc extends string> = 
-  T extends TUnion<infer U> ? { [K in keyof U]: TTemplateLiteralUnion<Assert<[U[K]], TTemplateLiteralKind[]>, Acc> }[number] :
-  T extends TTemplateLiteral ? `${Static<T>}` : 
-  T extends TLiteral<infer U> ? `${U}` :
-  T extends TString ? `${string}` : 
-  T extends TNumber ? `${number}` : 
-  T extends TBigInt ? `${bigint}` : 
-  T extends TBoolean ? `${boolean}` :
-  never
-// prettier-ignore
-export type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string> = 
-  T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` :
-  Acc
-export type TTemplateLiteralKeyRest<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, TPropertyKey[]>
-export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
-  [Kind]: 'TemplateLiteral'
-  static: TTemplateLiteralUnion<T, ''>
-  type: 'string'
-  pattern: string // todo: it may be possible to infer this pattern
-}
-// --------------------------------------------------------------------------
-// TTransform
-// --------------------------------------------------------------------------
-// prettier-ignore
-export type DecodeProperties<T extends TProperties> = {
-  [K in keyof T]: DecodeType<T[K]>
-}
-// prettier-ignore
-export type DecodeRest<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-  ? [DecodeType<L>, ...DecodeRest<R>]
-  : []
-// prettier-ignore
-export type DecodeType<T extends TSchema> = (
-  T extends TOptional<infer S extends TSchema> ? TOptional<DecodeType<S>> :
-  T extends TReadonly<infer S extends TSchema> ? TReadonly<DecodeType<S>> :
-  T extends TTransform<infer _, infer R> ? TUnsafe<R> :
-  T extends TArray<infer S extends TSchema> ? TArray<DecodeType<S>> :
-  T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> :
-  T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<DecodeRest<P>, DecodeType<R>> :
-  T extends TEnum<infer S> ? TEnum<S> : // intercept for union. interior non decodable
-  T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<DecodeRest<P>, DecodeType<R>> :
-  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<DecodeRest<S>> :
-  T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> :
-  T extends TNot<infer S extends TSchema> ? TNot<DecodeType<S>> :
-  T extends TObject<infer S> ? TObject<Evaluate<DecodeProperties<S>>> :
-  T extends TPromise<infer S extends TSchema> ? TPromise<DecodeType<S>> :
-  T extends TRecord<infer K, infer S> ? TRecord<K, DecodeType<S>> :
-  T extends TRecursive<infer S extends TSchema> ? TRecursive<DecodeType<S>> :
-  T extends TRef<infer S extends TSchema> ? TRef<DecodeType<S>> :
-  T extends TTuple<infer S extends TSchema[]> ? TTuple<DecodeRest<S>> :
-  T extends TUnion<infer S extends TSchema[]> ? TUnion<DecodeRest<S>> :
-  T
-)
-export type TransformFunction<T = any, U = any> = (value: T) => U
-export interface TransformOptions<I extends TSchema = TSchema, O extends unknown = unknown> {
-  Decode: TransformFunction<StaticDecode<I>, O>
-  Encode: TransformFunction<O, StaticDecode<I>>
-}
-export type TTransformResolve<T extends TSchema, P extends unknown[] = []> = T extends TTransform<infer _, infer S> ? S : Static<T, P>
-export interface TTransform<I extends TSchema = TSchema, O extends unknown = unknown> extends TSchema {
-  static: TTransformResolve<I, this['params']>
-  [Transform]: TransformOptions<I, O>
-  [key: string]: any
-}
-// --------------------------------------------------------------------------
-// TTuple
-// --------------------------------------------------------------------------
-export type TTupleRest<T extends TSchema[], P extends unknown[]> = T extends [infer L, ...infer R] ? [Static<AssertType<L>, P>, ...TTupleRest<AssertRest<R>, P>] : []
-export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
-  [Kind]: 'Tuple'
-  static: TTupleRest<T, this['params']>
-  type: 'array'
-  items?: T
-  additionalItems?: false
-  minItems: number
-  maxItems: number
-}
-// --------------------------------------------------------------------------
-// TUndefined
-// --------------------------------------------------------------------------
-export interface TUndefined extends TSchema {
-  [Kind]: 'Undefined'
-  static: undefined
-  type: 'undefined'
-}
-// --------------------------------------------------------------------------
-// TUnionLiteral
-// --------------------------------------------------------------------------
-// prettier-ignore
-export type TLiteralUnionReduce<T extends TLiteral<string | number>[]> = 
-  T extends [infer L, ...infer R] ? [Assert<L, TLiteral<string | number>>['const'], ...TLiteralUnionReduce<Assert<R, TLiteral<string | number>[]>>] : 
-  []
-// prettier-ignore
-export type TUnionLiteralKeyRest<T extends TUnion<TLiteral<string | number>[]>> = 
-  T extends TUnion<infer S> ? TLiteralUnionReduce<Assert<S, TLiteral<string | number>[]>> : 
-  []
-// --------------------------------------------------------------------------
-// TUnion
-// --------------------------------------------------------------------------
-// prettier-ignore
-export type TUnionTemplateLiteral<T extends TTemplateLiteral, S extends string = Static<T>> = Ensure<UnionType<Assert<UnionToTuple<{[K in S]: TLiteral<K>}[S]>,TLiteral[]>>>
-export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
-  [Kind]: 'Union'
-  static: { [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : never }[number]
-  anyOf: T
-}
-// --------------------------------------------------------------------------
-// TUint8Array
-// --------------------------------------------------------------------------
-export interface Uint8ArrayOptions extends SchemaOptions {
-  maxByteLength?: number
-  minByteLength?: number
-}
-export interface TUint8Array extends TSchema, Uint8ArrayOptions {
-  [Kind]: 'Uint8Array'
-  static: Uint8Array
-  type: 'uint8array'
-}
-// --------------------------------------------------------------------------
-// TUnknown
-// --------------------------------------------------------------------------
-export interface TUnknown extends TSchema {
-  [Kind]: 'Unknown'
-  static: unknown
-}
-// --------------------------------------------------------------------------
-// TUnsafe
-// --------------------------------------------------------------------------
-export interface UnsafeOptions extends SchemaOptions {
-  [Kind]?: string
-}
-export interface TUnsafe<T> extends TSchema {
-  [Kind]: string
-  static: T
-}
-// --------------------------------------------------------------------------
-// TVoid
-// --------------------------------------------------------------------------
-export interface TVoid extends TSchema {
-  [Kind]: 'Void'
-  static: void
-  type: 'void'
-}
-// --------------------------------------------------------------------------
-// Static<T>
-// --------------------------------------------------------------------------
-/** Creates an decoded static type from a TypeBox type */
-export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<DecodeType<T>, P>
-/** Creates an encoded static type from a TypeBox type */
-export type StaticEncode<T extends TSchema, P extends unknown[] = []> = Static<T, P>
-/** Creates a static type from a TypeBox type */
-export type Static<T extends TSchema, P extends unknown[] = []> = (T & { params: P })['static']
-// --------------------------------------------------------------------------
-// TypeRegistry
-// --------------------------------------------------------------------------
-export type TypeRegistryValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean
-/** A registry for user defined types */
-export namespace TypeRegistry {
-  const map = new Map<string, TypeRegistryValidationFunction<any>>()
-  /** Returns the entries in this registry */
-  export function Entries() {
-    return new Map(map)
-  }
-  /** Clears all user defined types */
-  export function Clear() {
-    return map.clear()
-  }
-  /** Deletes a registered type */
-  export function Delete(kind: string) {
-    return map.delete(kind)
-  }
-  /** Returns true if this registry contains this kind */
-  export function Has(kind: string) {
-    return map.has(kind)
-  }
-  /** Sets a validation function for a user defined type */
-  export function Set<TSchema = unknown>(kind: string, func: TypeRegistryValidationFunction<TSchema>) {
-    map.set(kind, func)
-  }
-  /** Gets a custom validation function for a user defined type */
-  export function Get(kind: string) {
-    return map.get(kind)
-  }
-}
-// --------------------------------------------------------------------------
-// TypeBoxError
-// --------------------------------------------------------------------------
-export class TypeBoxError extends Error {
-  constructor(message: string) {
-    super(message)
-  }
-}
-// --------------------------------------------------------------------------
-// TypeRegistry
-// --------------------------------------------------------------------------
-export type FormatRegistryValidationFunction = (value: string) => boolean
-/** A registry for user defined string formats */
-export namespace FormatRegistry {
-  const map = new Map<string, FormatRegistryValidationFunction>()
-  /** Returns the entries in this registry */
-  export function Entries() {
-    return new Map(map)
-  }
-  /** Clears all user defined string formats */
-  export function Clear() {
-    return map.clear()
-  }
-  /** Deletes a registered format */
-  export function Delete(format: string) {
-    return map.delete(format)
-  }
-  /** Returns true if the user defined string format exists */
-  export function Has(format: string) {
-    return map.has(format)
-  }
-  /** Sets a validation function for a user defined string format */
-  export function Set(format: string, func: FormatRegistryValidationFunction) {
-    map.set(format, func)
-  }
-  /** Gets a validation function for a user defined string format */
-  export function Get(format: string) {
-    return map.get(format)
-  }
-}
-// --------------------------------------------------------------------------
-// ValueGuard
-// --------------------------------------------------------------------------
-/** Provides functions to type guard raw JavaScript values */
-export namespace ValueGuard {
-  /** Returns true if this value is an array */
-  export function IsArray(value: unknown): value is unknown[] {
-    return Array.isArray(value)
-  }
-  /** Returns true if this value is bigint */
-  export function IsBigInt(value: unknown): value is bigint {
-    return typeof value === 'bigint'
-  }
-  /** Returns true if this value is a boolean */
-  export function IsBoolean(value: unknown): value is boolean {
-    return typeof value === 'boolean'
-  }
-  /** Returns true if this value is a Date object */
-  export function IsDate(value: unknown): value is Date {
-    return value instanceof globalThis.Date
-  }
-  /** Returns true if this value is null */
-  export function IsNull(value: unknown): value is null {
-    return value === null
-  }
-  /** Returns true if this value is number */
-  export function IsNumber(value: unknown): value is number {
-    return typeof value === 'number'
-  }
-  /** Returns true if this value is an object */
-  export function IsObject(value: unknown): value is Record<PropertyKey, unknown> {
-    return typeof value === 'object' && value !== null
-  }
-  /** Returns true if this value is string */
-  export function IsString(value: unknown): value is string {
-    return typeof value === 'string'
-  }
-  /** Returns true if this value is a Uint8Array */
-  export function IsUint8Array(value: unknown): value is Uint8Array {
-    return value instanceof globalThis.Uint8Array
-  }
-  /** Returns true if this value is undefined */
-  export function IsUndefined(value: unknown): value is undefined {
-    return value === undefined
-  }
-}
-// --------------------------------------------------------------------------
-// TypeGuard
-// --------------------------------------------------------------------------
-export class TypeGuardUnknownTypeError extends TypeBoxError {}
-/** Provides functions to test if JavaScript values are TypeBox types */
-export namespace TypeGuard {
-  function IsPattern(value: unknown): value is string {
-    try {
-      new RegExp(value as string)
-      return true
-    } catch {
-      return false
-    }
-  }
-  function IsControlCharacterFree(value: unknown): value is string {
-    if (!ValueGuard.IsString(value)) return false
-    for (let i = 0; i < value.length; i++) {
-      const code = value.charCodeAt(i)
-      if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
-        return false
-      }
-    }
-    return true
-  }
-  function IsAdditionalProperties(value: unknown): value is TAdditionalProperties {
-    return IsOptionalBoolean(value) || TSchema(value)
-  }
-  function IsOptionalBigInt(value: unknown): value is bigint | undefined {
-    return ValueGuard.IsUndefined(value) || ValueGuard.IsBigInt(value)
-  }
-  function IsOptionalNumber(value: unknown): value is number | undefined {
-    return ValueGuard.IsUndefined(value) || ValueGuard.IsNumber(value)
-  }
-  function IsOptionalBoolean(value: unknown): value is boolean | undefined {
-    return ValueGuard.IsUndefined(value) || ValueGuard.IsBoolean(value)
-  }
-  function IsOptionalString(value: unknown): value is string | undefined {
-    return ValueGuard.IsUndefined(value) || ValueGuard.IsString(value)
-  }
-  function IsOptionalPattern(value: unknown): value is string | undefined {
-    return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value) && IsPattern(value))
-  }
-  function IsOptionalFormat(value: unknown): value is string | undefined {
-    return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value))
-  }
-  function IsOptionalSchema(value: unknown): value is boolean | undefined {
-    return ValueGuard.IsUndefined(value) || TSchema(value)
-  }
-  // ----------------------------------------------------------------
-  // Types
-  // ----------------------------------------------------------------
-  /** Returns true if the given value is TAny */
-  export function TAny(schema: unknown): schema is TAny {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Any') &&
-      IsOptionalString(schema.$id)
-    )
-  }
-  /** Returns true if the given value is TArray */
-  export function TArray(schema: unknown): schema is TArray {
-    return (
-      TKindOf(schema, 'Array') &&
-      schema.type === 'array' &&
-      IsOptionalString(schema.$id) &&
-      TSchema(schema.items) &&
-      IsOptionalNumber(schema.minItems) &&
-      IsOptionalNumber(schema.maxItems) &&
-      IsOptionalBoolean(schema.uniqueItems) &&
-      IsOptionalSchema(schema.contains) &&
-      IsOptionalNumber(schema.minContains) &&
-      IsOptionalNumber(schema.maxContains)
-    )
-  }
-  /** Returns true if the given value is TAsyncIterator */
-  export function TAsyncIterator(schema: unknown): schema is TAsyncIterator {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'AsyncIterator') && 
-      schema.type === 'AsyncIterator' &&
-      IsOptionalString(schema.$id) &&
-      TSchema(schema.items)
-    )
-  }
-  /** Returns true if the given value is TBigInt */
-  export function TBigInt(schema: unknown): schema is TBigInt {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'BigInt') && 
-      schema.type === 'bigint' &&
-      IsOptionalString(schema.$id) &&
-      IsOptionalBigInt(schema.exclusiveMaximum) &&
-      IsOptionalBigInt(schema.exclusiveMinimum) &&
-      IsOptionalBigInt(schema.maximum) &&
-      IsOptionalBigInt(schema.minimum) &&
-      IsOptionalBigInt(schema.multipleOf) 
-    )
-  }
-  /** Returns true if the given value is TBoolean */
-  export function TBoolean(schema: unknown): schema is TBoolean {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Boolean') && 
-      schema.type === 'boolean' && 
-      IsOptionalString(schema.$id)
-    )
-  }
-  /** Returns true if the given value is TConstructor */
-  export function TConstructor(schema: unknown): schema is TConstructor {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Constructor') && 
-      schema.type === 'Constructor' &&
-      IsOptionalString(schema.$id) && 
-      ValueGuard.IsArray(schema.parameters) &&
-      schema.parameters.every(schema => TSchema(schema)) &&
-      TSchema(schema.returns)
-    )
-  }
-  /** Returns true if the given value is TDate */
-  export function TDate(schema: unknown): schema is TDate {
-    return (
-      TKindOf(schema, 'Date') &&
-      schema.type === 'Date' &&
-      IsOptionalString(schema.$id) &&
-      IsOptionalNumber(schema.exclusiveMaximumTimestamp) &&
-      IsOptionalNumber(schema.exclusiveMinimumTimestamp) &&
-      IsOptionalNumber(schema.maximumTimestamp) &&
-      IsOptionalNumber(schema.minimumTimestamp) &&
-      IsOptionalNumber(schema.multipleOfTimestamp)
-    )
-  }
-  /** Returns true if the given value is TFunction */
-  export function TFunction(schema: unknown): schema is TFunction {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Function') &&
-      schema.type === 'Function' &&
-      IsOptionalString(schema.$id) && 
-      ValueGuard.IsArray(schema.parameters) && 
-      schema.parameters.every(schema => TSchema(schema)) &&
-      TSchema(schema.returns)
-    )
-  }
-  /** Returns true if the given value is TInteger */
-  export function TInteger(schema: unknown): schema is TInteger {
-    return (
-      TKindOf(schema, 'Integer') &&
-      schema.type === 'integer' &&
-      IsOptionalString(schema.$id) &&
-      IsOptionalNumber(schema.exclusiveMaximum) &&
-      IsOptionalNumber(schema.exclusiveMinimum) &&
-      IsOptionalNumber(schema.maximum) &&
-      IsOptionalNumber(schema.minimum) &&
-      IsOptionalNumber(schema.multipleOf)
-    )
-  }
-  /** Returns true if the given value is TIntersect */
-  export function TIntersect(schema: unknown): schema is TIntersect {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Intersect') &&
-      (ValueGuard.IsString(schema.type) && schema.type !== 'object' ? false : true) &&
-      ValueGuard.IsArray(schema.allOf) && 
-      schema.allOf.every(schema => TSchema(schema) && !TTransform(schema)) &&
-      IsOptionalString(schema.type) &&
-      (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) &&
-      IsOptionalString(schema.$id)
-    )
-  }
-  /** Returns true if the given value is TIterator */
-  export function TIterator(schema: unknown): schema is TIterator {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Iterator') &&
-      schema.type === 'Iterator' &&
-      IsOptionalString(schema.$id) &&
-      TSchema(schema.items)
-    )
-  }
-  /** Returns true if the given value is a TKind with the given name. */
-  export function TKindOf<T extends string>(schema: unknown, kind: T): schema is Record<PropertyKey, unknown> & { [Kind]: T } {
-    return TKind(schema) && schema[Kind] === kind
-  }
-  /** Returns true if the given value is TKind */
-  export function TKind(schema: unknown): schema is Record<PropertyKey, unknown> & { [Kind]: string } {
-    return ValueGuard.IsObject(schema) && Kind in schema && ValueGuard.IsString(schema[Kind])
-  }
-  /** Returns true if the given value is TLiteral<string> */
-  export function TLiteralString(schema: unknown): schema is TLiteral<string> {
-    return TLiteral(schema) && ValueGuard.IsString(schema.const)
-  }
-  /** Returns true if the given value is TLiteral<number> */
-  export function TLiteralNumber(schema: unknown): schema is TLiteral<number> {
-    return TLiteral(schema) && ValueGuard.IsNumber(schema.const)
-  }
-  /** Returns true if the given value is TLiteral<boolean> */
-  export function TLiteralBoolean(schema: unknown): schema is TLiteral<boolean> {
-    return TLiteral(schema) && ValueGuard.IsBoolean(schema.const)
-  }
-  /** Returns true if the given value is TLiteral */
-  export function TLiteral(schema: unknown): schema is TLiteral {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Literal') &&
-      IsOptionalString(schema.$id) && (
-        ValueGuard.IsBoolean(schema.const) ||
-        ValueGuard.IsNumber(schema.const) ||
-        ValueGuard.IsString(schema.const)
-      )
-    )
-  }
-  /** Returns true if the given value is TNever */
-  export function TNever(schema: unknown): schema is TNever {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Never') &&
-      ValueGuard.IsObject(schema.not) && 
-      Object.getOwnPropertyNames(schema.not).length === 0
-    )
-  }
-  /** Returns true if the given value is TNot */
-  export function TNot(schema: unknown): schema is TNot {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Not') &&
-      TSchema(schema.not) 
-    )
-  }
-  /** Returns true if the given value is TNull */
-  export function TNull(schema: unknown): schema is TNull {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Null') &&
-      schema.type === 'null' && 
-      IsOptionalString(schema.$id)
-    )
-  }
-  /** Returns true if the given value is TNumber */
-  export function TNumber(schema: unknown): schema is TNumber {
-    return (
-      TKindOf(schema, 'Number') &&
-      schema.type === 'number' &&
-      IsOptionalString(schema.$id) &&
-      IsOptionalNumber(schema.exclusiveMaximum) &&
-      IsOptionalNumber(schema.exclusiveMinimum) &&
-      IsOptionalNumber(schema.maximum) &&
-      IsOptionalNumber(schema.minimum) &&
-      IsOptionalNumber(schema.multipleOf)
-    )
-  }
-  /** Returns true if the given value is TObject */
-  export function TObject(schema: unknown): schema is TObject {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Object') &&
-      schema.type === 'object' &&
-      IsOptionalString(schema.$id) &&
-      ValueGuard.IsObject(schema.properties) &&
-      IsAdditionalProperties(schema.additionalProperties) &&
-      IsOptionalNumber(schema.minProperties) &&
-      IsOptionalNumber(schema.maxProperties) &&
-      Object.entries(schema.properties).every(([key, schema]) => IsControlCharacterFree(key) && TSchema(schema))
-    )
-  }
-  /** Returns true if the given value is TPromise */
-  export function TPromise(schema: unknown): schema is TPromise {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Promise') &&
-      schema.type === 'Promise' &&
-      IsOptionalString(schema.$id) && 
-      TSchema(schema.item)
-    )
-  }
-  /** Returns true if the given value is TRecord */
-  export function TRecord(schema: unknown): schema is TRecord {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Record') &&
-      schema.type === 'object' && 
-      IsOptionalString(schema.$id) && 
-      IsAdditionalProperties(schema.additionalProperties) &&
-      ValueGuard.IsObject(schema.patternProperties) &&
-      ((schema: Record<PropertyKey, unknown>) => {
-        const keys = Object.getOwnPropertyNames(schema.patternProperties)
-        return (
-          keys.length === 1 &&
-          IsPattern(keys[0]) &&
-          ValueGuard.IsObject(schema.patternProperties) &&
-          TSchema(schema.patternProperties[keys[0]])
-        )
-      })(schema)
-    )
-  }
-  /** Returns true if this value is TRecursive */
-  export function TRecursive(schema: unknown): schema is { [Hint]: 'Recursive' } {
-    return ValueGuard.IsObject(schema) && Hint in schema && schema[Hint] === 'Recursive'
-  }
-  /** Returns true if the given value is TRef */
-  export function TRef(schema: unknown): schema is TRef {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Ref') &&
-      IsOptionalString(schema.$id) && 
-      ValueGuard.IsString(schema.$ref)
-    )
-  }
-  /** Returns true if the given value is TString */
-  export function TString(schema: unknown): schema is TString {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'String') && 
-      schema.type === 'string' && 
-      IsOptionalString(schema.$id) && 
-      IsOptionalNumber(schema.minLength) && 
-      IsOptionalNumber(schema.maxLength) && 
-      IsOptionalPattern(schema.pattern) && 
-      IsOptionalFormat(schema.format)
-    )
-  }
-  /** Returns true if the given value is TSymbol */
-  export function TSymbol(schema: unknown): schema is TSymbol {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Symbol') &&
-      schema.type === 'symbol' &&
-      IsOptionalString(schema.$id)
-    )
-  }
-  /** Returns true if the given value is TTemplateLiteral */
-  export function TTemplateLiteral(schema: unknown): schema is TTemplateLiteral {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'TemplateLiteral') &&
-      schema.type === 'string' &&
-      ValueGuard.IsString(schema.pattern) &&
-      schema.pattern[0] === '^' &&
-      schema.pattern[schema.pattern.length - 1] === '$'
-    )
-  }
-  /** Returns true if the given value is TThis */
-  export function TThis(schema: unknown): schema is TThis {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'This') &&
-      IsOptionalString(schema.$id) && 
-      ValueGuard.IsString(schema.$ref)
-    )
-  }
-  /** Returns true of this value is TTransform */
-  export function TTransform(schema: unknown): schema is { [Transform]: TransformOptions } {
-    return ValueGuard.IsObject(schema) && Transform in schema
-  }
-  /** Returns true if the given value is TTuple */
-  export function TTuple(schema: unknown): schema is TTuple {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Tuple') &&
-      schema.type === 'array' && 
-      IsOptionalString(schema.$id) && 
-      ValueGuard.IsNumber(schema.minItems) && 
-      ValueGuard.IsNumber(schema.maxItems) && 
-      schema.minItems === schema.maxItems &&
-      (( // empty
-        ValueGuard.IsUndefined(schema.items) &&
-        ValueGuard.IsUndefined(schema.additionalItems) &&
-        schema.minItems === 0
-      ) || (
-        ValueGuard.IsArray(schema.items) && 
-        schema.items.every(schema => TSchema(schema))
-      ))
-    )
-  }
-  /** Returns true if the given value is TUndefined */
-  export function TUndefined(schema: unknown): schema is TUndefined {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Undefined') &&
-      schema.type === 'undefined' &&
-      IsOptionalString(schema.$id)
-    )
-  }
-  /** Returns true if the given value is TUnion<Literal<string | number>[]> */
-  export function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral[]> {
-    return TUnion(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema))
-  }
-  /** Returns true if the given value is TUnion */
-  export function TUnion(schema: unknown): schema is TUnion {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Union') &&
-      IsOptionalString(schema.$id) &&
-      ValueGuard.IsObject(schema) &&
-      ValueGuard.IsArray(schema.anyOf) &&
-      schema.anyOf.every(schema => TSchema(schema))
-    )
-  }
-  /** Returns true if the given value is TUint8Array */
-  export function TUint8Array(schema: unknown): schema is TUint8Array {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Uint8Array') &&
-      schema.type === 'Uint8Array' && 
-      IsOptionalString(schema.$id) && 
-      IsOptionalNumber(schema.minByteLength) && 
-      IsOptionalNumber(schema.maxByteLength)
-    )
-  }
-  /** Returns true if the given value is TUnknown */
-  export function TUnknown(schema: unknown): schema is TUnknown {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Unknown') &&
-      IsOptionalString(schema.$id)
-    )
-  }
-  /** Returns true if the given value is a raw TUnsafe */
-  export function TUnsafe(schema: unknown): schema is TUnsafe<unknown> {
-    return TKindOf(schema, 'Unsafe')
-  }
-  /** Returns true if the given value is TVoid */
-  export function TVoid(schema: unknown): schema is TVoid {
-    // prettier-ignore
-    return (
-      TKindOf(schema, 'Void') &&
-      schema.type === 'void' &&
-      IsOptionalString(schema.$id)
-    )
-  }
-  /** Returns true if this value has a Readonly symbol */
-  export function TReadonly<T extends TSchema>(schema: T): schema is TReadonly<T> {
-    return ValueGuard.IsObject(schema) && schema[Readonly] === 'Readonly'
-  }
-  /** Returns true if this value has a Optional symbol */
-  export function TOptional<T extends TSchema>(schema: T): schema is TOptional<T> {
-    return ValueGuard.IsObject(schema) && schema[Optional] === 'Optional'
-  }
-  /** Returns true if the given value is TSchema */
-  export function TSchema(schema: unknown): schema is TSchema {
-    // prettier-ignore
-    return (
-      ValueGuard.IsObject(schema)
-    ) && (
-      TAny(schema) ||
-      TArray(schema) ||
-      TBoolean(schema) ||
-      TBigInt(schema) ||
-      TAsyncIterator(schema) ||
-      TConstructor(schema) ||
-      TDate(schema) ||
-      TFunction(schema) ||
-      TInteger(schema) ||
-      TIntersect(schema) ||
-      TIterator(schema) ||
-      TLiteral(schema) ||
-      TNever(schema) ||
-      TNot(schema) ||
-      TNull(schema) ||
-      TNumber(schema) ||
-      TObject(schema) ||
-      TPromise(schema) ||
-      TRecord(schema) ||
-      TRef(schema) ||
-      TString(schema) ||
-      TSymbol(schema) ||
-      TTemplateLiteral(schema) ||
-      TThis(schema) ||
-      TTuple(schema) ||
-      TUndefined(schema) ||
-      TUnion(schema) ||
-      TUint8Array(schema) ||
-      TUnknown(schema) ||
-      TUnsafe(schema) ||
-      TVoid(schema) ||
-      (TKind(schema) && TypeRegistry.Has(schema[Kind] as any))
-    )
-  }
-}
-// --------------------------------------------------------------------------
-// ExtendsUndefined
-// --------------------------------------------------------------------------
-/** Fast undefined check used for properties of type undefined */
-export namespace ExtendsUndefined {
-  export function Check(schema: TSchema): boolean {
-    return schema[Kind] === 'Intersect'
-      ? (schema as TIntersect).allOf.every((schema) => Check(schema))
-      : schema[Kind] === 'Union'
-      ? (schema as TUnion).anyOf.some((schema) => Check(schema))
-      : schema[Kind] === 'Undefined'
-      ? true
-      : schema[Kind] === 'Not'
-      ? !Check(schema.not)
-      : false
-  }
-}
-// --------------------------------------------------------------------------
-// TypeExtends
-// --------------------------------------------------------------------------
-export class TypeExtendsError extends TypeBoxError {}
-export enum TypeExtendsResult {
-  Union,
-  True,
-  False,
-}
-export namespace TypeExtends {
-  // --------------------------------------------------------------------------
-  // IntoBooleanResult
-  // --------------------------------------------------------------------------
-  function IntoBooleanResult(result: TypeExtendsResult) {
-    return result === TypeExtendsResult.False ? result : TypeExtendsResult.True
-  }
-  // --------------------------------------------------------------------------
-  // Throw
-  // --------------------------------------------------------------------------
-  function Throw(message: string): never {
-    throw new TypeExtendsError(message)
-  }
-  // --------------------------------------------------------------------------
-  // StructuralRight
-  // --------------------------------------------------------------------------
-  function IsStructuralRight(right: TSchema): boolean {
-    // prettier-ignore
-    return (
-      TypeGuard.TNever(right) || 
-      TypeGuard.TIntersect(right) || 
-      TypeGuard.TUnion(right) || 
-      TypeGuard.TUnknown(right) || 
-      TypeGuard.TAny(right)
-    )
-  }
-  function StructuralRight(left: TSchema, right: TSchema) {
-    // prettier-ignore
-    return (
-      TypeGuard.TNever(right) ? TNeverRight(left, right) :
-      TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
-      TypeGuard.TUnion(right) ? TUnionRight(left, right) :
-      TypeGuard.TUnknown(right) ? TUnknownRight(left, right) :
-      TypeGuard.TAny(right) ? TAnyRight(left, right) :
-      Throw('StructuralRight')
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Any
-  // --------------------------------------------------------------------------
-  function TAnyRight(left: TSchema, right: TAny) {
-    return TypeExtendsResult.True
-  }
-  function TAny(left: TAny, right: TSchema) {
-    // prettier-ignore
-    return (
-      TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
-      (TypeGuard.TUnion(right) && right.anyOf.some((schema) => TypeGuard.TAny(schema) || TypeGuard.TUnknown(schema))) ? TypeExtendsResult.True :
-      TypeGuard.TUnion(right) ? TypeExtendsResult.Union  :
-      TypeGuard.TUnknown(right) ? TypeExtendsResult.True :
-      TypeGuard.TAny(right) ? TypeExtendsResult.True :
-      TypeExtendsResult.Union
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Array
-  // --------------------------------------------------------------------------
-  function TArrayRight(left: TSchema, right: TArray) {
-    // prettier-ignore
-    return (
-      TypeGuard.TUnknown(left) ? TypeExtendsResult.False :
-      TypeGuard.TAny(left) ?TypeExtendsResult.Union :
-      TypeGuard.TNever(left) ? TypeExtendsResult.True :
-      TypeExtendsResult.False
-    )
-  }
-  function TArray(left: TArray, right: TSchema) {
-    // prettier-ignore
-    return (
-      TypeGuard.TObject(right) && IsObjectArrayLike(right) ? TypeExtendsResult.True :
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      !TypeGuard.TArray(right) ? TypeExtendsResult.False :
-      IntoBooleanResult(Visit(left.items, right.items))
-    )
-  }
-  // --------------------------------------------------------------------------
-  // AsyncIterator
-  // --------------------------------------------------------------------------
-  function TAsyncIterator(left: TAsyncIterator, right: TSchema) {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      !TypeGuard.TAsyncIterator(right) ? TypeExtendsResult.False :
-      IntoBooleanResult(Visit(left.items, right.items))
-    )
-  }
-  // --------------------------------------------------------------------------
-  // BigInt
-  // --------------------------------------------------------------------------
-  function TBigInt(left: TBigInt, right: TSchema): TypeExtendsResult {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TObject(right) ? TObjectRight(left, right) :
-      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
-      TypeGuard.TBigInt(right) ? TypeExtendsResult.True : 
-      TypeExtendsResult.False
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Boolean
-  // --------------------------------------------------------------------------
-  function TBooleanRight(left: TSchema, right: TBoolean) {
-    return TypeGuard.TLiteral(left) && ValueGuard.IsBoolean(left.const) ? TypeExtendsResult.True : TypeGuard.TBoolean(left) ? TypeExtendsResult.True : TypeExtendsResult.False
-  }
-  function TBoolean(left: TBoolean, right: TSchema): TypeExtendsResult {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TObject(right) ? TObjectRight(left, right) :
-      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
-      TypeGuard.TBoolean(right) ? TypeExtendsResult.True : 
-      TypeExtendsResult.False
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Constructor
-  // --------------------------------------------------------------------------
-  function TConstructor(left: TConstructor, right: TSchema) {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TObject(right) ? TObjectRight(left, right) :
-      !TypeGuard.TConstructor(right) ? TypeExtendsResult.False :
-      left.parameters.length > right.parameters.length ? TypeExtendsResult.False :
-      (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) ? TypeExtendsResult.False :
-      IntoBooleanResult(Visit(left.returns, right.returns))
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Date
-  // --------------------------------------------------------------------------
-  function TDate(left: TDate, right: TSchema) {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TObject(right) ? TObjectRight(left, right) :
-      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
-      TypeGuard.TDate(right) ? TypeExtendsResult.True : 
-      TypeExtendsResult.False
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Function
-  // --------------------------------------------------------------------------
-  function TFunction(left: TFunction, right: TSchema) {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TObject(right) ? TObjectRight(left, right) :
-      !TypeGuard.TFunction(right) ? TypeExtendsResult.False :
-      left.parameters.length > right.parameters.length ? TypeExtendsResult.False :
-      (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) ? TypeExtendsResult.False :
-      IntoBooleanResult(Visit(left.returns, right.returns))
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Integer
-  // --------------------------------------------------------------------------
-  function TIntegerRight(left: TSchema, right: TInteger) {
-    // prettier-ignore
-    return (
-      TypeGuard.TLiteral(left) && ValueGuard.IsNumber(left.const) ? TypeExtendsResult.True :
-      TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : 
-      TypeExtendsResult.False
-    )
-  }
-  function TInteger(left: TInteger, right: TSchema): TypeExtendsResult {
-    // prettier-ignore
-    return (
-      TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : 
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TObject(right) ? TObjectRight(left, right) :
-      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
-      TypeExtendsResult.False
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Intersect
-  // --------------------------------------------------------------------------
-  function TIntersectRight(left: TSchema, right: TIntersect): TypeExtendsResult {
-    // prettier-ignore
-    return right.allOf.every((schema) => Visit(left, schema) === TypeExtendsResult.True) 
-      ? TypeExtendsResult.True 
-      : TypeExtendsResult.False
-  }
-  function TIntersect(left: TIntersect, right: TSchema) {
-    // prettier-ignore
-    return left.allOf.some((schema) => Visit(schema, right) === TypeExtendsResult.True) 
-      ? TypeExtendsResult.True 
-      : TypeExtendsResult.False
-  }
-  // --------------------------------------------------------------------------
-  // Iterator
-  // --------------------------------------------------------------------------
-  function TIterator(left: TIterator, right: TSchema) {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      !TypeGuard.TIterator(right) ? TypeExtendsResult.False :
-      IntoBooleanResult(Visit(left.items, right.items))
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Literal
-  // --------------------------------------------------------------------------
-  function TLiteral(left: TLiteral, right: TSchema): TypeExtendsResult {
-    // prettier-ignore
-    return (
-      TypeGuard.TLiteral(right) && right.const === left.const ? TypeExtendsResult.True : 
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TObject(right) ? TObjectRight(left, right) :
-      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
-      TypeGuard.TString(right) ? TStringRight(left, right) :
-      TypeGuard.TNumber(right) ? TNumberRight(left, right) :
-      TypeGuard.TInteger(right) ? TIntegerRight(left, right) :
-      TypeGuard.TBoolean(right) ? TBooleanRight(left, right) :
-      TypeExtendsResult.False
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Never
-  // --------------------------------------------------------------------------
-  function TNeverRight(left: TSchema, right: TNever) {
-    return TypeExtendsResult.False
-  }
-  function TNever(left: TNever, right: TSchema) {
-    return TypeExtendsResult.True
-  }
-  // --------------------------------------------------------------------------
-  // Not
-  // --------------------------------------------------------------------------
-  function UnwrapTNot<T extends TNot>(schema: T): TUnknown | TNot['not'] {
-    let [current, depth]: [TSchema, number] = [schema, 0]
-    while (true) {
-      if (!TypeGuard.TNot(current)) break
-      current = current.not
-      depth += 1
-    }
-    return depth % 2 === 0 ? current : Type.Unknown()
-  }
-  function TNot(left: TSchema, right: TSchema) {
-    // TypeScript has no concept of negated types, and attempts to correctly check the negated
-    // type at runtime would put TypeBox at odds with TypeScripts ability to statically infer
-    // the type. Instead we unwrap to either unknown or T and continue evaluating.
-    // prettier-ignore
-    return (
-      TypeGuard.TNot(left) ? Visit(UnwrapTNot(left), right) :
-      TypeGuard.TNot(right) ? Visit(left, UnwrapTNot(right)) :
-      Throw('Invalid fallthrough for Not')
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Null
-  // --------------------------------------------------------------------------
-  function TNull(left: TNull, right: TSchema) {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TObject(right) ? TObjectRight(left, right) :
-      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
-      TypeGuard.TNull(right) ? TypeExtendsResult.True : 
-      TypeExtendsResult.False
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Number
-  // --------------------------------------------------------------------------
-  function TNumberRight(left: TSchema, right: TNumber) {
-    // prettier-ignore
-    return (
-      TypeGuard.TLiteralNumber(left) ? TypeExtendsResult.True :
-      TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : 
-      TypeExtendsResult.False
-    )
-  }
-  function TNumber(left: TNumber, right: TSchema): TypeExtendsResult {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TObject(right) ? TObjectRight(left, right) :
-      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
-      TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : 
-      TypeExtendsResult.False
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Object
-  // --------------------------------------------------------------------------
-  function IsObjectPropertyCount(schema: TObject, count: number) {
-    return Object.getOwnPropertyNames(schema.properties).length === count
-  }
-  function IsObjectStringLike(schema: TObject) {
-    return IsObjectArrayLike(schema)
-  }
-  function IsObjectSymbolLike(schema: TObject) {
-    // prettier-ignore
-    return IsObjectPropertyCount(schema, 0) || (
-      IsObjectPropertyCount(schema, 1) && 'description' in schema.properties && TypeGuard.TUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && ((
-        TypeGuard.TString(schema.properties.description.anyOf[0]) &&
-        TypeGuard.TUndefined(schema.properties.description.anyOf[1])
-      ) || (
-        TypeGuard.TString(schema.properties.description.anyOf[1]) &&
-        TypeGuard.TUndefined(schema.properties.description.anyOf[0])
-      ))
-    )
-  }
-  function IsObjectNumberLike(schema: TObject) {
-    return IsObjectPropertyCount(schema, 0)
-  }
-  function IsObjectBooleanLike(schema: TObject) {
-    return IsObjectPropertyCount(schema, 0)
-  }
-  function IsObjectBigIntLike(schema: TObject) {
-    return IsObjectPropertyCount(schema, 0)
-  }
-  function IsObjectDateLike(schema: TObject) {
-    return IsObjectPropertyCount(schema, 0)
-  }
-  function IsObjectUint8ArrayLike(schema: TObject) {
-    return IsObjectArrayLike(schema)
-  }
-  function IsObjectFunctionLike(schema: TObject) {
-    const length = Type.Number()
-    return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'length' in schema.properties && IntoBooleanResult(Visit(schema.properties['length'], length)) === TypeExtendsResult.True)
-  }
-  function IsObjectConstructorLike(schema: TObject) {
-    return IsObjectPropertyCount(schema, 0)
-  }
-  function IsObjectArrayLike(schema: TObject) {
-    const length = Type.Number()
-    return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'length' in schema.properties && IntoBooleanResult(Visit(schema.properties['length'], length)) === TypeExtendsResult.True)
-  }
-  function IsObjectPromiseLike(schema: TObject) {
-    const then = Type.Function([Type.Any()], Type.Any())
-    return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'then' in schema.properties && IntoBooleanResult(Visit(schema.properties['then'], then)) === TypeExtendsResult.True)
-  }
-  // --------------------------------------------------------------------------
-  // Property
-  // --------------------------------------------------------------------------
-  function Property(left: TSchema, right: TSchema) {
-    // prettier-ignore
-    return (
-      Visit(left, right) === TypeExtendsResult.False ? TypeExtendsResult.False :
-      TypeGuard.TOptional(left) && !TypeGuard.TOptional(right) ? TypeExtendsResult.False :
-      TypeExtendsResult.True
-    )
-  }
-  function TObjectRight(left: TSchema, right: TObject) {
-    // prettier-ignore
-    return (
-      TypeGuard.TUnknown(left) ? TypeExtendsResult.False :
-      TypeGuard.TAny(left) ? TypeExtendsResult.Union : (
-        TypeGuard.TNever(left) ||
-        (TypeGuard.TLiteralString(left) && IsObjectStringLike(right)) ||
-        (TypeGuard.TLiteralNumber(left) && IsObjectNumberLike(right)) ||
-        (TypeGuard.TLiteralBoolean(left) && IsObjectBooleanLike(right)) ||
-        (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right)) ||
-        (TypeGuard.TBigInt(left) && IsObjectBigIntLike(right)) ||
-        (TypeGuard.TString(left) && IsObjectStringLike(right)) ||
-        (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right)) ||
-        (TypeGuard.TNumber(left) && IsObjectNumberLike(right)) ||
-        (TypeGuard.TInteger(left) && IsObjectNumberLike(right)) ||
-        (TypeGuard.TBoolean(left) && IsObjectBooleanLike(right)) ||
-        (TypeGuard.TUint8Array(left) && IsObjectUint8ArrayLike(right)) ||
-        (TypeGuard.TDate(left) && IsObjectDateLike(right)) ||
-        (TypeGuard.TConstructor(left) && IsObjectConstructorLike(right)) ||
-        (TypeGuard.TFunction(left) && IsObjectFunctionLike(right)) 
-      ) ? TypeExtendsResult.True :
-      (TypeGuard.TRecord(left) && TypeGuard.TString(RecordKey(left))) ? (() => {
-        // When expressing a Record with literal key values, the Record is converted into a Object with
-        // the Hint assigned as `Record`. This is used to invert the extends logic.
-        return right[Hint] === 'Record' ? TypeExtendsResult.True : TypeExtendsResult.False
-      })() :
-      (TypeGuard.TRecord(left) && TypeGuard.TNumber(RecordKey(left))) ? (() => {
-        return IsObjectPropertyCount(right, 0) 
-          ? TypeExtendsResult.True 
-          : TypeExtendsResult.False
-      })() :
-      TypeExtendsResult.False
-    )
-  }
-  function TObject(left: TObject, right: TSchema) {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
-      !TypeGuard.TObject(right) ? TypeExtendsResult.False :
-      (() => {
-        for (const key of Object.getOwnPropertyNames(right.properties)) {
-          if (!(key in left.properties) && !TypeGuard.TOptional(right.properties[key])) {
-            return TypeExtendsResult.False
-          }
-          if(TypeGuard.TOptional(right.properties[key])) {
-            return TypeExtendsResult.True
-          }
-          if (Property(left.properties[key], right.properties[key]) === TypeExtendsResult.False) {
-            return TypeExtendsResult.False
-          }
-        }
-        return TypeExtendsResult.True
-      })()
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Promise
-  // --------------------------------------------------------------------------
-  function TPromise(left: TPromise, right: TSchema) {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TObject(right) && IsObjectPromiseLike(right) ? TypeExtendsResult.True :
-      !TypeGuard.TPromise(right) ? TypeExtendsResult.False :
-      IntoBooleanResult(Visit(left.item, right.item))
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Record
-  // --------------------------------------------------------------------------
-  function RecordKey(schema: TRecord) {
-    // prettier-ignore
-    return (
-      PatternNumberExact in schema.patternProperties ? Type.Number() :
-      PatternStringExact in schema.patternProperties ? Type.String() :
-      Throw('Unknown record key pattern')
-    )
-  }
-  function RecordValue(schema: TRecord) {
-    // prettier-ignore
-    return (
-      PatternNumberExact in schema.patternProperties ? schema.patternProperties[PatternNumberExact] :
-      PatternStringExact in schema.patternProperties ? schema.patternProperties[PatternStringExact] :
-      Throw('Unable to get record value schema')
-    )
-  }
-  function TRecordRight(left: TSchema, right: TRecord) {
-    const [Key, Value] = [RecordKey(right), RecordValue(right)]
-    // prettier-ignore
-    return (
-      (TypeGuard.TLiteralString(left) && TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === TypeExtendsResult.True) ? TypeExtendsResult.True :
-      TypeGuard.TUint8Array(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) :
-      TypeGuard.TString(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) :
-      TypeGuard.TArray(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) :
-      TypeGuard.TObject(left) ? (() => {
-        for (const key of Object.getOwnPropertyNames(left.properties)) {
-          if (Property(Value, left.properties[key]) === TypeExtendsResult.False) {
-            return TypeExtendsResult.False
-          }
-        }
-        return TypeExtendsResult.True
-      })() : 
-      TypeExtendsResult.False
-    )
-  }
-  function TRecord(left: TRecord, right: TSchema) {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TObject(right) ? TObjectRight(left, right) :
-      !TypeGuard.TRecord(right) ? TypeExtendsResult.False :
-      Visit(RecordValue(left), RecordValue(right))
-    )
-  }
-  // --------------------------------------------------------------------------
-  // String
-  // --------------------------------------------------------------------------
-  function TStringRight(left: TSchema, right: TString) {
-    // prettier-ignore
-    return (
-      TypeGuard.TLiteral(left) && ValueGuard.IsString(left.const) ? TypeExtendsResult.True :
-      TypeGuard.TString(left) ? TypeExtendsResult.True : 
-      TypeExtendsResult.False
-    )
-  }
-  function TString(left: TString, right: TSchema): TypeExtendsResult {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TObject(right) ? TObjectRight(left, right) :
-      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
-      TypeGuard.TString(right) ? TypeExtendsResult.True : 
-      TypeExtendsResult.False
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Symbol
-  // --------------------------------------------------------------------------
-  function TSymbol(left: TSymbol, right: TSchema): TypeExtendsResult {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TObject(right) ? TObjectRight(left, right) :
-      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
-      TypeGuard.TSymbol(right) ? TypeExtendsResult.True : 
-      TypeExtendsResult.False
-    )
-  }
-  // --------------------------------------------------------------------------
-  // TemplateLiteral
-  // --------------------------------------------------------------------------
-  function TTemplateLiteral(left: TSchema, right: TSchema) {
-    // TemplateLiteral types are resolved to either unions for finite expressions or string
-    // for infinite expressions. Here we call to TemplateLiteralResolver to resolve for
-    // either type and continue evaluating.
-    // prettier-ignore
-    return (
-      TypeGuard.TTemplateLiteral(left) ? Visit(TemplateLiteralResolver.Resolve(left), right) :
-      TypeGuard.TTemplateLiteral(right) ? Visit(left, TemplateLiteralResolver.Resolve(right)) :
-      Throw('Invalid fallthrough for TemplateLiteral')
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Tuple
-  // --------------------------------------------------------------------------
-  function IsArrayOfTuple(left: TTuple, right: TSchema) {
-    // prettier-ignore
-    return (
-      TypeGuard.TArray(right) && 
-      left.items !== undefined && 
-      left.items.every((schema) => Visit(schema, right.items) === TypeExtendsResult.True)
-    )
-  }
-  function TTupleRight(left: TSchema, right: TTuple) {
-    // prettier-ignore
-    return (
-      TypeGuard.TNever(left) ? TypeExtendsResult.True :
-      TypeGuard.TUnknown(left) ? TypeExtendsResult.False :
-      TypeGuard.TAny(left) ? TypeExtendsResult.Union :
-      TypeExtendsResult.False
-    )
-  }
-  function TTuple(left: TTuple, right: TSchema): TypeExtendsResult {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TObject(right) && IsObjectArrayLike(right) ? TypeExtendsResult.True :
-      TypeGuard.TArray(right) && IsArrayOfTuple(left, right) ? TypeExtendsResult.True :
-      !TypeGuard.TTuple(right) ? TypeExtendsResult.False :
-      (ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items)) || (!ValueGuard.IsUndefined(left.items) && ValueGuard.IsUndefined(right.items)) ? TypeExtendsResult.False :
-      (ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items)) ? TypeExtendsResult.True :
-      left.items!.every((schema, index) => Visit(schema, right.items![index]) === TypeExtendsResult.True) ? TypeExtendsResult.True : 
-      TypeExtendsResult.False
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Uint8Array
-  // --------------------------------------------------------------------------
-  function TUint8Array(left: TUint8Array, right: TSchema) {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TObject(right) ? TObjectRight(left, right) :
-      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
-      TypeGuard.TUint8Array(right) ? TypeExtendsResult.True : 
-      TypeExtendsResult.False
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Undefined
-  // --------------------------------------------------------------------------
-  function TUndefined(left: TUndefined, right: TSchema) {
-    // prettier-ignore
-    return (
-      IsStructuralRight(right) ? StructuralRight(left, right) :
-      TypeGuard.TObject(right) ? TObjectRight(left, right) :
-      TypeGuard.TRecord(right) ? TRecordRight(left, right) :
-      TypeGuard.TVoid(right) ? VoidRight(left, right) :
-      TypeGuard.TUndefined(right) ? TypeExtendsResult.True : 
-      TypeExtendsResult.False
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Union
-  // --------------------------------------------------------------------------
-  function TUnionRight(left: TSchema, right: TUnion): TypeExtendsResult {
-    // prettier-ignore
-    return right.anyOf.some((schema) => Visit(left, schema) === TypeExtendsResult.True) 
-      ? TypeExtendsResult.True 
-      : TypeExtendsResult.False
-  }
-  function TUnion(left: TUnion, right: TSchema): TypeExtendsResult {
-    // prettier-ignore
-    return left.anyOf.every((schema) => Visit(schema, right) === TypeExtendsResult.True) 
-      ? TypeExtendsResult.True 
-      : TypeExtendsResult.False
-  }
-  // --------------------------------------------------------------------------
-  // Unknown
-  // --------------------------------------------------------------------------
-  function TUnknownRight(left: TSchema, right: TUnknown) {
-    return TypeExtendsResult.True
-  }
-  function TUnknown(left: TUnknown, right: TSchema) {
-    // prettier-ignore
-    return (
-      TypeGuard.TNever(right) ? TNeverRight(left, right) :
-      TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
-      TypeGuard.TUnion(right) ? TUnionRight(left, right) :
-      TypeGuard.TAny(right) ? TAnyRight(left, right) :
-      TypeGuard.TString(right) ? TStringRight(left, right) :
-      TypeGuard.TNumber(right) ? TNumberRight(left, right) :
-      TypeGuard.TInteger(right) ? TIntegerRight(left, right) :
-      TypeGuard.TBoolean(right) ? TBooleanRight(left, right) :
-      TypeGuard.TArray(right) ? TArrayRight(left, right) :
-      TypeGuard.TTuple(right) ? TTupleRight(left, right) :
-      TypeGuard.TObject(right) ? TObjectRight(left, right) :
-      TypeGuard.TUnknown(right) ? TypeExtendsResult.True : 
-      TypeExtendsResult.False
-    )
-  }
-  // --------------------------------------------------------------------------
-  // Void
-  // --------------------------------------------------------------------------
-  function VoidRight(left: TSchema, right: TVoid) {
-    // prettier-ignore
-    return TypeGuard.TUndefined(left) ? TypeExtendsResult.True :
-      TypeGuard.TUndefined(left) ? TypeExtendsResult.True : 
-      TypeExtendsResult.False
-  }
-  function TVoid(left: TVoid, right: TSchema) {
-    // prettier-ignore
-    return TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
-      TypeGuard.TUnion(right) ? TUnionRight(left, right) :
-      TypeGuard.TUnknown(right) ? TUnknownRight(left, right) :
-      TypeGuard.TAny(right) ? TAnyRight(left, right) :
-      TypeGuard.TObject(right) ? TObjectRight(left, right) :
-      TypeGuard.TVoid(right) ? TypeExtendsResult.True : 
-      TypeExtendsResult.False
-  }
-  function Visit(left: TSchema, right: TSchema): TypeExtendsResult {
-    // prettier-ignore
-    return (
-      // resolvable
-      (TypeGuard.TTemplateLiteral(left) || TypeGuard.TTemplateLiteral(right)) ? TTemplateLiteral(left, right) :
-      (TypeGuard.TNot(left) || TypeGuard.TNot(right)) ? TNot(left, right) :
-      // standard
-      TypeGuard.TAny(left) ? TAny(left, right) :
-      TypeGuard.TArray(left) ? TArray(left, right) :
-      TypeGuard.TBigInt(left) ? TBigInt(left, right) :
-      TypeGuard.TBoolean(left) ? TBoolean(left, right) :
-      TypeGuard.TAsyncIterator(left) ? TAsyncIterator(left, right) :
-      TypeGuard.TConstructor(left) ? TConstructor(left, right) :
-      TypeGuard.TDate(left) ? TDate(left, right) :
-      TypeGuard.TFunction(left) ? TFunction(left, right) :
-      TypeGuard.TInteger(left) ? TInteger(left, right) :
-      TypeGuard.TIntersect(left) ? TIntersect(left, right) :
-      TypeGuard.TIterator(left) ? TIterator(left, right) :
-      TypeGuard.TLiteral(left) ? TLiteral(left, right) :
-      TypeGuard.TNever(left) ? TNever(left, right) :
-      TypeGuard.TNull(left) ? TNull(left, right) :
-      TypeGuard.TNumber(left) ? TNumber(left, right) :
-      TypeGuard.TObject(left) ? TObject(left, right) :
-      TypeGuard.TRecord(left) ? TRecord(left, right) :
-      TypeGuard.TString(left) ? TString(left, right) :
-      TypeGuard.TSymbol(left) ? TSymbol(left, right) :
-      TypeGuard.TTuple(left) ? TTuple(left, right) :
-      TypeGuard.TPromise(left) ? TPromise(left, right) :
-      TypeGuard.TUint8Array(left) ? TUint8Array(left, right) :
-      TypeGuard.TUndefined(left) ? TUndefined(left, right) :
-      TypeGuard.TUnion(left) ? TUnion(left, right) :
-      TypeGuard.TUnknown(left) ? TUnknown(left, right) :
-      TypeGuard.TVoid(left) ? TVoid(left, right) :
-      Throw(`Unknown left type operand '${left[Kind]}'`)
-    )
-  }
-  export function Extends(left: TSchema, right: TSchema): TypeExtendsResult {
-    return Visit(left, right)
-  }
-}
-// --------------------------------------------------------------------------
-// TypeClone
-// --------------------------------------------------------------------------
-/** Specialized Clone for Types */
-export namespace TypeClone {
-  function ArrayType(value: unknown[]) {
-    return (value as any).map((value: unknown) => Visit(value as any))
-  }
-  function DateType(value: Date) {
-    return new Date(value.getTime())
-  }
-  function Uint8ArrayType(value: Uint8Array) {
-    return new Uint8Array(value)
-  }
-  function ObjectType(value: Record<keyof any, unknown>) {
-    const clonedProperties = Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {})
-    const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key as any]) }), {})
-    return { ...clonedProperties, ...clonedSymbols }
-  }
-  function Visit(value: unknown): any {
-    // prettier-ignore
-    return (
-      ValueGuard.IsArray(value) ? ArrayType(value) :
-      ValueGuard.IsDate(value) ? DateType(value) : 
-      ValueGuard.IsUint8Array(value) ? Uint8ArrayType(value) :
-      ValueGuard.IsObject(value) ? ObjectType(value) :
-      value
-    )
-  }
-  /** Clones a Rest */
-  export function Rest<T extends TSchema[]>(schemas: [...T]): T {
-    return schemas.map((schema) => Type(schema)) as T
-  }
-  /** Clones a Type */
-  export function Type<T extends TSchema>(schema: T, options: SchemaOptions = {}): T {
-    return { ...Visit(schema), ...options }
-  }
-}
-// --------------------------------------------------------------------------
-// IndexedAccessor
-// --------------------------------------------------------------------------
-export namespace IndexedAccessor {
-  function OptionalUnwrap(schema: TSchema[]): TSchema[] {
-    return schema.map((schema) => {
-      const { [Optional]: _, ...clone } = TypeClone.Type(schema)
-      return clone
-    })
-  }
-  function IsIntersectOptional(schema: TSchema[]): boolean {
-    return schema.every((schema) => TypeGuard.TOptional(schema))
-  }
-  function IsUnionOptional(schema: TSchema[]): boolean {
-    return schema.some((schema) => TypeGuard.TOptional(schema))
-  }
-  function ResolveIntersect(schema: TIntersect): TSchema {
-    return IsIntersectOptional(schema.allOf) ? Type.Optional(Type.Intersect(OptionalUnwrap(schema.allOf))) : schema
-  }
-  function ResolveUnion(schema: TUnion): TSchema {
-    return IsUnionOptional(schema.anyOf) ? Type.Optional(Type.Union(OptionalUnwrap(schema.anyOf))) : schema
-  }
-  function ResolveOptional(schema: TSchema) {
-    // prettier-ignore
-    return schema[Kind] === 'Intersect' ? ResolveIntersect(schema as TIntersect) :
-      schema[Kind] === 'Union' ? ResolveUnion(schema as TUnion) :
-      schema
-  }
-  function TIntersect(schema: TIntersect, key: string): TSchema {
-    const resolved = schema.allOf.reduce((acc, schema) => {
-      const indexed = Visit(schema, key)
-      return indexed[Kind] === 'Never' ? acc : [...acc, indexed]
-    }, [] as TSchema[])
-    return ResolveOptional(Type.Intersect(resolved))
-  }
-  function TUnion(schema: TUnion, key: string): TSchema {
-    const resolved = schema.anyOf.map((schema) => Visit(schema, key))
-    return ResolveOptional(Type.Union(resolved))
-  }
-  function TObject(schema: TObject, key: string): TSchema {
-    const property = schema.properties[key]
-    return ValueGuard.IsUndefined(property) ? Type.Never() : Type.Union([property])
-  }
-  function TTuple(schema: TTuple, key: string): TSchema {
-    const items = schema.items
-    if (ValueGuard.IsUndefined(items)) return Type.Never()
-    const element = items[key as any as number] //
-    if (ValueGuard.IsUndefined(element)) return Type.Never()
-    return element
-  }
-  function Visit(schema: TSchema, key: string): TSchema {
-    // prettier-ignore
-    return schema[Kind] === 'Intersect' ? TIntersect(schema as TIntersect, key) :
-      schema[Kind] === 'Union' ? TUnion(schema as TUnion, key) :
-      schema[Kind] === 'Object' ? TObject(schema as TObject, key) :
-      schema[Kind] === 'Tuple' ? TTuple(schema as TTuple, key) :
-      Type.Never()
-  }
-  export function Resolve(schema: TSchema, keys: TPropertyKey[], options: SchemaOptions = {}): TSchema {
-    const resolved = keys.map((key) => Visit(schema, key.toString()))
-    return ResolveOptional(Type.Union(resolved, options))
-  }
-}
-// --------------------------------------------------------------------------
-// Intrinsic
-// --------------------------------------------------------------------------
-export namespace Intrinsic {
-  function Uncapitalize(value: string): string {
-    const [first, rest] = [value.slice(0, 1), value.slice(1)]
-    return `${first.toLowerCase()}${rest}`
-  }
-  function Capitalize(value: string): string {
-    const [first, rest] = [value.slice(0, 1), value.slice(1)]
-    return `${first.toUpperCase()}${rest}`
-  }
-  function Uppercase(value: string): string {
-    return value.toUpperCase()
-  }
-  function Lowercase(value: string): string {
-    return value.toLowerCase()
-  }
-  function IntrinsicTemplateLiteral(schema: TTemplateLiteral, mode: TIntrinsicMode) {
-    // note: template literals require special runtime handling as they are encoded in string patterns.
-    // This diverges from the mapped type which would otherwise map on the template literal kind.
-    const expression = TemplateLiteralParser.ParseExact(schema.pattern)
-    const finite = TemplateLiteralFinite.Check(expression)
-    if (!finite) return { ...schema, pattern: IntrinsicLiteral(schema.pattern, mode) } as any
-    const strings = [...TemplateLiteralGenerator.Generate(expression)]
-    const literals = strings.map((value) => Type.Literal(value))
-    const mapped = IntrinsicRest(literals as any, mode)
-    const union = Type.Union(mapped)
-    return Type.TemplateLiteral([union])
-  }
-  function IntrinsicLiteral(value: TLiteralValue, mode: TIntrinsicMode) {
-    // prettier-ignore
-    return typeof value === 'string' ? (
-      mode === 'Uncapitalize' ? Uncapitalize(value) :
-      mode === 'Capitalize' ? Capitalize(value) : 
-      mode === 'Uppercase' ? Uppercase(value) : 
-      mode === 'Lowercase' ? Lowercase(value) : 
-    value) : value.toString()
-  }
-  function IntrinsicRest(schema: TSchema[], mode: TIntrinsicMode): TSchema[] {
-    if (schema.length === 0) return []
-    const [L, ...R] = schema
-    return [Map(L, mode), ...IntrinsicRest(R, mode)]
-  }
-  function Visit(schema: TSchema, mode: TIntrinsicMode) {
-    // prettier-ignore
-    return TypeGuard.TTemplateLiteral(schema) ?  IntrinsicTemplateLiteral(schema, mode) :
-      TypeGuard.TUnion(schema) ? Type.Union(IntrinsicRest(schema.anyOf, mode)) :
-      TypeGuard.TLiteral(schema) ? Type.Literal(IntrinsicLiteral(schema.const, mode)) :
-      schema
-  }
-  /** Applies an intrinsic string manipulation to the given type. */
-  export function Map<T extends TSchema, M extends TIntrinsicMode>(schema: T, mode: M): TIntrinsic<T, M> {
-    return Visit(schema, mode)
-  }
-}
-// --------------------------------------------------------------------------
-// ObjectMap
-// --------------------------------------------------------------------------
-export namespace ObjectMap {
-  function TIntersect(schema: TIntersect, callback: (object: TObject) => TObject) {
-    // prettier-ignore
-    return Type.Intersect(schema.allOf.map((inner) => Visit(inner, callback)), { ...schema })
-  }
-  function TUnion(schema: TUnion, callback: (object: TObject) => TObject) {
-    // prettier-ignore
-    return Type.Union(schema.anyOf.map((inner) => Visit(inner, callback)), { ...schema })
-  }
-  function TObject(schema: TObject, callback: (object: TObject) => TObject) {
-    return callback(schema)
-  }
-  function Visit(schema: TSchema, callback: (object: TObject) => TObject): TSchema {
-    // There are cases where users need to map objects with unregistered kinds. Using a TypeGuard here would
-    // prevent sub schema mapping as unregistered kinds will not pass TSchema checks. This is notable in the
-    // case of TObject where unregistered property kinds cause the TObject check to fail. As mapping is only
-    // used for composition, we use explicit checks instead.
-    // prettier-ignore
-    return (
-      schema[Kind] === 'Intersect' ? TIntersect(schema as TIntersect, callback) : 
-      schema[Kind] === 'Union' ? TUnion(schema as TUnion, callback) : 
-      schema[Kind] === 'Object' ? TObject(schema as TObject, callback) : 
-      schema
-    )
-  }
-  export function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T {
-    return { ...Visit(TypeClone.Type(schema), callback), ...options } as unknown as T
-  }
-}
-// --------------------------------------------------------------------------
-// KeyResolver
-// --------------------------------------------------------------------------
-export interface KeyResolverOptions {
-  includePatterns: boolean
-}
-export namespace KeyResolver {
-  function UnwrapPattern(key: string) {
-    return key[0] === '^' && key[key.length - 1] === '$' ? key.slice(1, key.length - 1) : key
-  }
-  function TIntersect(schema: TIntersect, options: KeyResolverOptions): string[] {
-    return schema.allOf.reduce((acc, schema) => [...acc, ...Visit(schema, options)], [] as string[])
-  }
-  function TUnion(schema: TUnion, options: KeyResolverOptions): string[] {
-    const sets = schema.anyOf.map((inner) => Visit(inner, options))
-    return [...sets.reduce((set, outer) => outer.map((key) => (sets.every((inner) => inner.includes(key)) ? set.add(key) : set))[0], new Set<string>())]
-  }
-  function TObject(schema: TObject, options: KeyResolverOptions): string[] {
-    return Object.getOwnPropertyNames(schema.properties)
-  }
-  function TRecord(schema: TRecord, options: KeyResolverOptions): string[] {
-    return options.includePatterns ? Object.getOwnPropertyNames(schema.patternProperties) : []
-  }
-  function Visit(schema: TSchema, options: KeyResolverOptions): string[] {
-    // prettier-ignore
-    return (
-      TypeGuard.TIntersect(schema) ? TIntersect(schema, options) :
-      TypeGuard.TUnion(schema) ? TUnion(schema, options) :
-      TypeGuard.TObject(schema) ? TObject(schema, options) :
-      TypeGuard.TRecord(schema) ? TRecord(schema, options) : 
-      []
-    )
-  }
-  /** Resolves an array of keys in this schema */
-  export function ResolveKeys(schema: TSchema, options: KeyResolverOptions): string[] {
-    return [...new Set(Visit(schema, options))]
-  }
-  /** Resolves a regular expression pattern matching all keys in this schema */
-  export function ResolvePattern(schema: TSchema): string {
-    const keys = ResolveKeys(schema, { includePatterns: true })
-    const pattern = keys.map((key) => `(${UnwrapPattern(key)})`)
-    return `^(${pattern.join('|')})$`
-  }
-}
-// --------------------------------------------------------------------------
-// KeyArrayResolver
-// --------------------------------------------------------------------------
-export class KeyArrayResolverError extends TypeBoxError {}
-export namespace KeyArrayResolver {
-  /** Resolves an array of string[] keys from the given schema or array type. */
-  export function Resolve(schema: TSchema | string[]): string[] {
-    // prettier-ignore
-    return Array.isArray(schema) ? schema :
-      TypeGuard.TUnionLiteral(schema) ? schema.anyOf.map((schema) => schema.const.toString()) :
-      TypeGuard.TLiteral(schema) ? [schema.const as string] :
-      TypeGuard.TTemplateLiteral(schema) ? (() => {
-        const expression = TemplateLiteralParser.ParseExact(schema.pattern)
-        if (!TemplateLiteralFinite.Check(expression)) throw new KeyArrayResolverError('Cannot resolve keys from infinite template expression')
-        return [...TemplateLiteralGenerator.Generate(expression)]
-      })() : []
-  }
-}
-// --------------------------------------------------------------------------
-// UnionResolver
-// --------------------------------------------------------------------------
-export namespace UnionResolver {
-  function* TUnion(union: TUnion): IterableIterator<TSchema> {
-    for (const schema of union.anyOf) {
-      if (schema[Kind] === 'Union') {
-        yield* TUnion(schema as TUnion)
-      } else {
-        yield schema
-      }
-    }
-  }
-  /** Returns a resolved union with interior unions flattened */
-  export function Resolve(union: TUnion): TUnion {
-    return Type.Union([...TUnion(union)], { ...union })
-  }
-}
-// --------------------------------------------------------------------------
-// TemplateLiteralPattern
-// --------------------------------------------------------------------------
-export class TemplateLiteralPatternError extends TypeBoxError {}
-export namespace TemplateLiteralPattern {
-  function Throw(message: string): never {
-    throw new TemplateLiteralPatternError(message)
-  }
-  function Escape(value: string) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-  }
-  function Visit(schema: TSchema, acc: string): string {
-    // prettier-ignore
-    return (
-      TypeGuard.TTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
-      TypeGuard.TUnion(schema) ? `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})` :
-      TypeGuard.TNumber(schema) ? `${acc}${PatternNumber}` :
-      TypeGuard.TInteger(schema) ? `${acc}${PatternNumber}` :
-      TypeGuard.TBigInt(schema) ? `${acc}${PatternNumber}` :
-      TypeGuard.TString(schema) ? `${acc}${PatternString}` :
-      TypeGuard.TLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` :
-      TypeGuard.TBoolean(schema) ? `${acc}${PatternBoolean}` :
-      Throw(`Unexpected Kind '${schema[Kind]}'`)
-    )
-  }
-  export function Create(kinds: TTemplateLiteralKind[]): string {
-    return `^${kinds.map((schema) => Visit(schema, '')).join('')}\$`
-  }
-}
-// --------------------------------------------------------------------------------------
-// TemplateLiteralResolver
-// --------------------------------------------------------------------------------------
-export namespace TemplateLiteralResolver {
-  /** Resolves a template literal as a TUnion */
-  export function Resolve(template: TTemplateLiteral): TString | TUnion | TLiteral {
-    const expression = TemplateLiteralParser.ParseExact(template.pattern)
-    if (!TemplateLiteralFinite.Check(expression)) return Type.String()
-    const literals = [...TemplateLiteralGenerator.Generate(expression)].map((value) => Type.Literal(value))
-    return Type.Union(literals)
-  }
-}
-// --------------------------------------------------------------------------------------
-// TemplateLiteralParser
-// --------------------------------------------------------------------------------------
-export class TemplateLiteralParserError extends TypeBoxError {}
-export namespace TemplateLiteralParser {
-  export type Expression = And | Or | Const
-  export type Const = { type: 'const'; const: string }
-  export type And = { type: 'and'; expr: Expression[] }
-  export type Or = { type: 'or'; expr: Expression[] }
-  function IsNonEscaped(pattern: string, index: number, char: string) {
-    return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92
-  }
-  function IsOpenParen(pattern: string, index: number) {
-    return IsNonEscaped(pattern, index, '(')
-  }
-  function IsCloseParen(pattern: string, index: number) {
-    return IsNonEscaped(pattern, index, ')')
-  }
-  function IsSeparator(pattern: string, index: number) {
-    return IsNonEscaped(pattern, index, '|')
-  }
-  function IsGroup(pattern: string) {
-    if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1))) return false
-    let count = 0
-    for (let index = 0; index < pattern.length; index++) {
-      if (IsOpenParen(pattern, index)) count += 1
-      if (IsCloseParen(pattern, index)) count -= 1
-      if (count === 0 && index !== pattern.length - 1) return false
-    }
-    return true
-  }
-  function InGroup(pattern: string) {
-    return pattern.slice(1, pattern.length - 1)
-  }
-  function IsPrecedenceOr(pattern: string) {
-    let count = 0
-    for (let index = 0; index < pattern.length; index++) {
-      if (IsOpenParen(pattern, index)) count += 1
-      if (IsCloseParen(pattern, index)) count -= 1
-      if (IsSeparator(pattern, index) && count === 0) return true
-    }
-    return false
-  }
-  function IsPrecedenceAnd(pattern: string) {
-    for (let index = 0; index < pattern.length; index++) {
-      if (IsOpenParen(pattern, index)) return true
-    }
-    return false
-  }
-  function Or(pattern: string): Expression {
-    let [count, start] = [0, 0]
-    const expressions: Expression[] = []
-    for (let index = 0; index < pattern.length; index++) {
-      if (IsOpenParen(pattern, index)) count += 1
-      if (IsCloseParen(pattern, index)) count -= 1
-      if (IsSeparator(pattern, index) && count === 0) {
-        const range = pattern.slice(start, index)
-        if (range.length > 0) expressions.push(Parse(range))
-        start = index + 1
-      }
-    }
-    const range = pattern.slice(start)
-    if (range.length > 0) expressions.push(Parse(range))
-    if (expressions.length === 0) return { type: 'const', const: '' }
-    if (expressions.length === 1) return expressions[0]
-    return { type: 'or', expr: expressions }
-  }
-  function And(pattern: string): Expression {
-    function Group(value: string, index: number): [number, number] {
-      if (!IsOpenParen(value, index)) throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`)
-      let count = 0
-      for (let scan = index; scan < value.length; scan++) {
-        if (IsOpenParen(value, scan)) count += 1
-        if (IsCloseParen(value, scan)) count -= 1
-        if (count === 0) return [index, scan]
-      }
-      throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`)
-    }
-    function Range(pattern: string, index: number): [number, number] {
-      for (let scan = index; scan < pattern.length; scan++) {
-        if (IsOpenParen(pattern, scan)) return [index, scan]
-      }
-      return [index, pattern.length]
-    }
-    const expressions: Expression[] = []
-    for (let index = 0; index < pattern.length; index++) {
-      if (IsOpenParen(pattern, index)) {
-        const [start, end] = Group(pattern, index)
-        const range = pattern.slice(start, end + 1)
-        expressions.push(Parse(range))
-        index = end
-      } else {
-        const [start, end] = Range(pattern, index)
-        const range = pattern.slice(start, end)
-        if (range.length > 0) expressions.push(Parse(range))
-        index = end - 1
-      }
-    }
-    // prettier-ignore
-    return (expressions.length === 0) ? { type: 'const', const: '' } :
-      (expressions.length === 1) ? expressions[0] :
-      { type: 'and', expr: expressions }
-  }
-  /** Parses a pattern and returns an expression tree */
-  export function Parse(pattern: string): Expression {
-    // prettier-ignore
-    return IsGroup(pattern) ? Parse(InGroup(pattern)) :
-      IsPrecedenceOr(pattern) ? Or(pattern) :
-      IsPrecedenceAnd(pattern) ? And(pattern) :
-      { type: 'const', const: pattern }
-  }
-  /** Parses a pattern and strips forward and trailing ^ and $ */
-  export function ParseExact(pattern: string): Expression {
-    return Parse(pattern.slice(1, pattern.length - 1))
-  }
-}
-// --------------------------------------------------------------------------------------
-// TemplateLiteralFinite
-// --------------------------------------------------------------------------------------
-export class TemplateLiteralFiniteError extends TypeBoxError {}
-export namespace TemplateLiteralFinite {
-  function Throw(message: string): never {
-    throw new TemplateLiteralFiniteError(message)
-  }
-  function IsNumber(expression: TemplateLiteralParser.Expression): boolean {
-    // prettier-ignore
-    return (
-      expression.type === 'or' && 
-      expression.expr.length === 2 && 
-      expression.expr[0].type === 'const' && 
-      expression.expr[0].const === '0' && 
-      expression.expr[1].type === 'const' && 
-      expression.expr[1].const === '[1-9][0-9]*'
-    )
-  }
-  function IsBoolean(expression: TemplateLiteralParser.Expression): boolean {
-    // prettier-ignore
-    return (
-      expression.type === 'or' && 
-      expression.expr.length === 2 && 
-      expression.expr[0].type === 'const' && 
-      expression.expr[0].const === 'true' && 
-      expression.expr[1].type === 'const' && 
-      expression.expr[1].const === 'false'
-    )
-  }
-  function IsString(expression: TemplateLiteralParser.Expression) {
-    return expression.type === 'const' && expression.const === '.*'
-  }
-  export function Check(expression: TemplateLiteralParser.Expression): boolean {
-    // prettier-ignore
-    return IsBoolean(expression) ? true :
-      IsNumber(expression) || IsString(expression) ? false :
-      (expression.type === 'and') ? expression.expr.every((expr) => Check(expr)) :
-      (expression.type === 'or') ? expression.expr.every((expr) => Check(expr)) :
-      (expression.type === 'const') ? true :
-      Throw(`Unknown expression type`)
-  }
-}
-// --------------------------------------------------------------------------------------
-// TemplateLiteralGenerator
-// --------------------------------------------------------------------------------------
-export class TemplateLiteralGeneratorError extends TypeBoxError {}
-export namespace TemplateLiteralGenerator {
-  function* Reduce(buffer: string[][]): IterableIterator<string> {
-    if (buffer.length === 1) return yield* buffer[0]
-    for (const left of buffer[0]) {
-      for (const right of Reduce(buffer.slice(1))) {
-        yield `${left}${right}`
-      }
-    }
-  }
-  function* And(expression: TemplateLiteralParser.And): IterableIterator<string> {
-    return yield* Reduce(expression.expr.map((expr) => [...Generate(expr)]))
-  }
-  function* Or(expression: TemplateLiteralParser.Or): IterableIterator<string> {
-    for (const expr of expression.expr) yield* Generate(expr)
-  }
-  function* Const(expression: TemplateLiteralParser.Const): IterableIterator<string> {
-    return yield expression.const
-  }
-  export function* Generate(expression: TemplateLiteralParser.Expression): IterableIterator<string> {
-    // prettier-ignore
-    return (
-      expression.type === 'and' ? yield* And(expression) :
-      expression.type === 'or' ? yield* Or(expression) :
-      expression.type === 'const' ? yield* Const(expression) :
-      (() => { throw new TemplateLiteralGeneratorError('Unknown expression') })()
-    )
-  }
-}
-// ---------------------------------------------------------------------
-// TemplateLiteralDslParser
-// ---------------------------------------------------------------------
-export namespace TemplateLiteralDslParser {
-  function* ParseUnion(template: string): IterableIterator<TTemplateLiteralKind> {
-    const trim = template.trim().replace(/"|'/g, '')
-    // prettier-ignore
-    return (
-      trim === 'boolean' ? yield Type.Boolean() :
-      trim === 'number' ? yield Type.Number() :
-      trim === 'bigint' ? yield Type.BigInt() :
-      trim === 'string' ? yield Type.String() :
-      yield (() => {
-        const literals = trim.split('|').map((literal) => Type.Literal(literal.trim()))
-        return (
-          literals.length === 0 ? Type.Never() : 
-          literals.length === 1 ? literals[0] : 
-          Type.Union(literals)
-        )
-      })()
-    )
-  }
-  function* ParseTerminal(template: string): IterableIterator<TTemplateLiteralKind> {
-    if (template[1] !== '{') {
-      const L = Type.Literal('$')
-      const R = ParseLiteral(template.slice(1))
-      return yield* [L, ...R]
-    }
-    for (let i = 2; i < template.length; i++) {
-      if (template[i] === '}') {
-        const L = ParseUnion(template.slice(2, i))
-        const R = ParseLiteral(template.slice(i + 1))
-        return yield* [...L, ...R]
-      }
-    }
-    yield Type.Literal(template)
-  }
-  function* ParseLiteral(template: string): IterableIterator<TTemplateLiteralKind> {
-    for (let i = 0; i < template.length; i++) {
-      if (template[i] === '$') {
-        const L = Type.Literal(template.slice(0, i))
-        const R = ParseTerminal(template.slice(i))
-        return yield* [L, ...R]
-      }
-    }
-    yield Type.Literal(template)
-  }
-  export function Parse(template_dsl: string): TTemplateLiteralKind[] {
-    return [...ParseLiteral(template_dsl)]
-  }
-}
-// ---------------------------------------------------------------------
-// TransformBuilder
-// ---------------------------------------------------------------------
-export class TransformDecodeBuilder<T extends TSchema> {
-  constructor(private readonly schema: T) {}
-  public Decode<U extends unknown, D extends TransformFunction<StaticDecode<T>, U>>(decode: D): TransformEncodeBuilder<T, D> {
-    return new TransformEncodeBuilder(this.schema, decode)
-  }
-}
-export class TransformEncodeBuilder<T extends TSchema, D extends TransformFunction> {
-  constructor(private readonly schema: T, private readonly decode: D) {}
-  public Encode<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E): TTransform<T, ReturnType<D>> {
-    const schema = TypeClone.Type(this.schema)
-    // prettier-ignore
-    return (
-      TypeGuard.TTransform(schema) ? (() => {
-        const Encode = (value: unknown) => schema[Transform].Encode(encode(value as any))
-        const Decode = (value: unknown) => this.decode(schema[Transform].Decode(value))
-        const Codec = { Encode: Encode, Decode: Decode }
-        return { ...schema, [Transform]: Codec }
-      })() : (() => {
-        const Codec = { Decode: this.decode, Encode: encode }
-        return { ...schema, [Transform]: Codec }
-      })()
-    ) as TTransform<T, ReturnType<D>>
-  }
-}
-// --------------------------------------------------------------------------
-// TypeOrdinal: Used for auto $id generation
-// --------------------------------------------------------------------------
-let TypeOrdinal = 0
-// --------------------------------------------------------------------------
-// TypeBuilder
-// --------------------------------------------------------------------------
-export class TypeBuilderError extends TypeBoxError {}
-export class TypeBuilder {
-  /** `[Internal]` Creates a schema without `static` and `params` types */
-  protected Create<T>(schema: Omit<T, 'static' | 'params'>): T {
-    return schema as any
-  }
-  /** `[Internal]` Throws a TypeBuilder error with the given message */
-  protected Throw(message: string): never {
-    throw new TypeBuilderError(message)
-  }
-  /** `[Internal]` Discards property keys from the given record type */
-  protected Discard(record: Record<PropertyKey, any>, keys: PropertyKey[]) {
-    return keys.reduce((acc, key) => {
-      const { [key as any]: _, ...rest } = acc
-      return rest
-    }, record) as any
-  }
-  /** `[Json]` Omits compositing symbols from this schema */
-  public Strict<T extends TSchema>(schema: T): T {
-    return JSON.parse(JSON.stringify(schema))
-  }
-}
-// --------------------------------------------------------------------------
-// JsonTypeBuilder
-// --------------------------------------------------------------------------
-export class JsonTypeBuilder extends TypeBuilder {
-  // ------------------------------------------------------------------------
-  // Modifiers
-  // ------------------------------------------------------------------------
-  /** `[Json]` Creates a Readonly and Optional property */
-  public ReadonlyOptional<T extends TSchema>(schema: T): TReadonly<TOptional<T>> {
-    return this.Readonly(this.Optional(schema))
-  }
-  /** `[Json]` Creates a Readonly property */
-  public Readonly<T extends TSchema>(schema: T): TReadonly<T> {
-    return { ...TypeClone.Type(schema), [Readonly]: 'Readonly' }
-  }
-  /** `[Json]` Creates an Optional property */
-  public Optional<T extends TSchema>(schema: T): TOptional<T> {
-    return { ...TypeClone.Type(schema), [Optional]: 'Optional' }
-  }
-  // ------------------------------------------------------------------------
-  // Types
-  // ------------------------------------------------------------------------
-  /** `[Json]` Creates an Any type */
-  public Any(options: SchemaOptions = {}): TAny {
-    return this.Create({ ...options, [Kind]: 'Any' })
-  }
-  /** `[Json]` Creates an Array type */
-  public Array<T extends TSchema>(schema: T, options: ArrayOptions = {}): TArray<T> {
-    return this.Create({ ...options, [Kind]: 'Array', type: 'array', items: TypeClone.Type(schema) })
-  }
-  /** `[Json]` Creates a Boolean type */
-  public Boolean(options: SchemaOptions = {}): TBoolean {
-    return this.Create({ ...options, [Kind]: 'Boolean', type: 'boolean' })
-  }
-  /** `[Json]` Intrinsic function to Capitalize LiteralString types */
-  public Capitalize<T extends TSchema>(schema: T, options: SchemaOptions = {}): TIntrinsic<T, 'Capitalize'> {
-    return { ...Intrinsic.Map(TypeClone.Type(schema), 'Capitalize'), ...options }
-  }
-  /** `[Json]` Creates a Composite object type */
-  public Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T> {
-    const intersect: any = Type.Intersect(objects, {})
-    const keys = KeyResolver.ResolveKeys(intersect, { includePatterns: false })
-    const properties = keys.reduce((acc, key) => ({ ...acc, [key]: Type.Index(intersect, [key]) }), {} as TProperties)
-    return Type.Object(properties, options) as TComposite<T>
-  }
-  /** `[Json]` Creates a Enum type */
-  public Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options: SchemaOptions = {}): TEnum<T> {
-    if (ValueGuard.IsUndefined(item)) return this.Throw('Enum undefined or empty')
-    // prettier-ignore
-    const values1 = Object.getOwnPropertyNames(item).filter((key) => isNaN(key as any)).map((key) => item[key]) as T[keyof T][]
-    const values2 = [...new Set(values1)]
-    const anyOf = values2.map((value) => Type.Literal(value))
-    return this.Union(anyOf, { ...options, [Hint]: 'Enum' }) as TEnum<T>
-  }
-  /** `[Json]` Creates a Conditional type */
-  public Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options: SchemaOptions = {}): TExtends<L, R, T, U> {
-    switch (TypeExtends.Extends(left, right)) {
-      case TypeExtendsResult.Union:
-        return this.Union([TypeClone.Type(trueType, options), TypeClone.Type(falseType, options)]) as any as TExtends<L, R, T, U>
-      case TypeExtendsResult.True:
-        return TypeClone.Type(trueType, options) as unknown as TExtends<L, R, T, U>
-      case TypeExtendsResult.False:
-        return TypeClone.Type(falseType, options) as unknown as TExtends<L, R, T, U>
-    }
-  }
-  /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-  public Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options: SchemaOptions = {}): TExclude<L, R> {
-    // prettier-ignore
-    return (
-      TypeGuard.TTemplateLiteral(unionType) ? this.Exclude(TemplateLiteralResolver.Resolve(unionType), excludedMembers, options) :
-      TypeGuard.TTemplateLiteral(excludedMembers) ? this.Exclude(unionType, TemplateLiteralResolver.Resolve(excludedMembers), options) :
-      TypeGuard.TUnion(unionType) ? (() => {
-        const narrowed = unionType.anyOf.filter((inner) => TypeExtends.Extends(inner, excludedMembers) === TypeExtendsResult.False)
-        return (narrowed.length === 1 ? TypeClone.Type(narrowed[0], options) : this.Union(narrowed, options)) as TExclude<L, R>
-      })() :
-      TypeExtends.Extends(unionType, excludedMembers) !== TypeExtendsResult.False ? this.Never(options) : 
-      TypeClone.Type(unionType, options)
-    ) as TExclude<L, R>
-  }
-  /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-  public Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options: SchemaOptions = {}): TExtract<L, R> {
-    // prettier-ignore
-    return (
-      TypeGuard.TTemplateLiteral(type) ? this.Extract(TemplateLiteralResolver.Resolve(type), union, options) :
-      TypeGuard.TTemplateLiteral(union) ? this.Extract(type, TemplateLiteralResolver.Resolve(union), options) :
-      TypeGuard.TUnion(type) ? (() => {
-        const narrowed = type.anyOf.filter((inner) => TypeExtends.Extends(inner, union) !== TypeExtendsResult.False)
-        return (narrowed.length === 1 ? TypeClone.Type(narrowed[0], options) : this.Union(narrowed, options))
-      })() :
-      TypeExtends.Extends(type, union) !== TypeExtendsResult.False ? TypeClone.Type(type, options) : 
-      this.Never(options)
-    ) as TExtract<L, R>
-  }
-  /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TArray, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): AssertType<T['items']>
-  /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TTuple, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, TPropertyKey[]>>
-  /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TTuple, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): UnionType<AssertRest<T['items']>>
-  /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyRest<K>>
-  /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TSchema, K extends TLiteral<TPropertyKey>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, [K['const']]>
-  /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, TPropertyKey[]>>
-  /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TSchema, K extends TUnion<TLiteral<TPropertyKey>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TUnionLiteralKeyRest<K>>
-  /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TSchema, K extends TSchema>(schema: T, key: K, options?: SchemaOptions): TSchema
-  /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
-    // prettier-ignore
-    return (
-      TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved) ? (() => {
-        return TypeClone.Type(schema.items, options)
-      })() : 
-      TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved) ? (() => {
-        const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items
-        const cloned = items.map((schema) => TypeClone.Type(schema))
-        return this.Union(cloned, options)
-      })() : (() => {
-        const keys = KeyArrayResolver.Resolve(unresolved)
-        const clone = TypeClone.Type(schema)
-        return IndexedAccessor.Resolve(clone, keys, options)
-      })()
-    )
-  }
-  /** `[Json]` Creates an Integer type */
-  public Integer(options: NumericOptions<number> = {}): TInteger {
-    return this.Create({ ...options, [Kind]: 'Integer', type: 'integer' })
-  }
-  /** `[Json]` Creates an Intersect type */
-  public Intersect(allOf: [], options?: SchemaOptions): TNever
-  /** `[Json]` Creates an Intersect type */
-  public Intersect<T extends [TSchema]>(allOf: [...T], options?: SchemaOptions): T[0]
-  /** `[Json]` Creates an Intersect type */
-  public Intersect<T extends TSchema[]>(allOf: [...T], options?: IntersectOptions): TIntersect<T>
-  /** `[Json]` Creates an Intersect type */
-  public Intersect(allOf: TSchema[], options: IntersectOptions = {}) {
-    if (allOf.length === 0) return Type.Never()
-    if (allOf.length === 1) return TypeClone.Type(allOf[0], options)
-    if (allOf.some((schema) => TypeGuard.TTransform(schema))) this.Throw('Cannot intersect transform types')
-    const objects = allOf.every((schema) => TypeGuard.TObject(schema))
-    const cloned = TypeClone.Rest(allOf)
-    // prettier-ignore
-    const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties) 
-      ? { unevaluatedProperties: TypeClone.Type(options.unevaluatedProperties) } 
-      : {}
-    return options.unevaluatedProperties === false || TypeGuard.TSchema(options.unevaluatedProperties) || objects
-      ? this.Create({ ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: cloned })
-      : this.Create({ ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: cloned })
-  }
-  /** `[Json]` Creates a KeyOf type */
-  public KeyOf<T extends TSchema>(schema: T, options: SchemaOptions = {}): TKeyOf<T> {
-    // prettier-ignore
-    return (
-      TypeGuard.TRecord(schema) ? (() => {
-        const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
-        return (
-          pattern === PatternNumberExact ? this.Number(options) :
-          pattern === PatternStringExact ? this.String(options) :
-          this.Throw('Unable to resolve key type from Record key pattern')
-        )
-      })() :
-      TypeGuard.TTuple(schema) ? (() => {
-        const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items
-        const literals = items.map((_, index) => Type.Literal(index.toString()))
-        return this.Union(literals, options)
-      })() : 
-      TypeGuard.TArray(schema) ? (() => {
-        return this.Number(options)
-      })() : (() => {
-        const keys = KeyResolver.ResolveKeys(schema, { includePatterns: false })
-        if (keys.length === 0) return this.Never(options) as TKeyOf<T>
-        const literals = keys.map((key) => this.Literal(key))
-        return this.Union(literals, options)
-      })()
-    ) as unknown as TKeyOf<T>
-  }
-  /** `[Json]` Creates a Literal type */
-  public Literal<T extends TLiteralValue>(value: T, options: SchemaOptions = {}): TLiteral<T> {
-    return this.Create({ ...options, [Kind]: 'Literal', const: value, type: typeof value as 'string' | 'number' | 'boolean' })
-  }
-  /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-  public Lowercase<T extends TSchema>(schema: T, options: SchemaOptions = {}): TIntrinsic<T, 'Lowercase'> {
-    return { ...Intrinsic.Map(TypeClone.Type(schema), 'Lowercase'), ...options }
-  }
-  /** `[Json]` Creates a Never type */
-  public Never(options: SchemaOptions = {}): TNever {
-    return this.Create({ ...options, [Kind]: 'Never', not: {} })
-  }
-  /** `[Json]` Creates a Not type */
-  public Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T> {
-    return this.Create({ ...options, [Kind]: 'Not', not: TypeClone.Type(schema) })
-  }
-  /** `[Json]` Creates a Null type */
-  public Null(options: SchemaOptions = {}): TNull {
-    return this.Create({ ...options, [Kind]: 'Null', type: 'null' })
-  }
-  /** `[Json]` Creates a Number type */
-  public Number(options: NumericOptions<number> = {}): TNumber {
-    return this.Create({ ...options, [Kind]: 'Number', type: 'number' })
-  }
-  /** `[Json]` Creates an Object type */
-  public Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
-    const propertyKeys = Object.getOwnPropertyNames(properties)
-    const optionalKeys = propertyKeys.filter((key) => TypeGuard.TOptional(properties[key]))
-    const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name))
-    const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Type(options.additionalProperties) } : {}
-    const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Type(properties[key]) }), {} as TProperties)
-    return requiredKeys.length > 0
-      ? this.Create({ ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys })
-      : this.Create({ ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties })
-  }
-  /** `[Json]` Constructs a type whose keys are omitted from the given type */
-  public Omit<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TOmit<T, K[number]>
-  /** `[Json]` Constructs a type whose keys are omitted from the given type */
-  public Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionLiteralKeyRest<K>[number]>
-  /** `[Json]` Constructs a type whose keys are omitted from the given type */
-  public Omit<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TOmit<T, K['const']>
-  /** `[Json]` Constructs a type whose keys are omitted from the given type */
-  public Omit<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TOmit<T, TTemplateLiteralKeyRest<K>[number]>
-  /** `[Json]` Constructs a type whose keys are omitted from the given type */
-  public Omit<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TOmit<T, never>
-  /** `[Json]` Constructs a type whose keys are omitted from the given type */
-  public Omit(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
-    const keys = KeyArrayResolver.Resolve(unresolved)
-    // prettier-ignore
-    return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ['$id', Transform]), (object) => {
-      if (ValueGuard.IsArray(object.required)) {
-        object.required = object.required.filter((key: string) => !keys.includes(key as any))
-        if (object.required.length === 0) delete object.required
-      }
-      for (const key of Object.getOwnPropertyNames(object.properties)) {
-        if (keys.includes(key as any)) delete object.properties[key]
-      }
-      return this.Create(object)
-    }, options)
-  }
-  /** `[Json]` Constructs a type where all properties are optional */
-  public Partial<T extends TSchema>(schema: T, options: ObjectOptions = {}): TPartial<T> {
-    // prettier-ignore
-    return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ['$id', Transform]), (object) => {
-      const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
-        return { ...acc, [key]: this.Optional(object.properties[key]) }
-      }, {} as TProperties)
-      return this.Object(properties, this.Discard(object, ['required']) /* object used as options to retain other constraints */)
-    }, options)
-  }
-  /** `[Json]` Constructs a type whose keys are picked from the given type */
-  public Pick<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TPick<T, K[number]>
-  /** `[Json]` Constructs a type whose keys are picked from the given type */
-  public Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionLiteralKeyRest<K>[number]>
-  /** `[Json]` Constructs a type whose keys are picked from the given type */
-  public Pick<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TPick<T, K['const']>
-  /** `[Json]` Constructs a type whose keys are picked from the given type */
-  public Pick<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TPick<T, TTemplateLiteralKeyRest<K>[number]>
-  /** `[Json]` Constructs a type whose keys are picked from the given type */
-  public Pick<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TPick<T, never>
-  /** `[Json]` Constructs a type whose keys are picked from the given type */
-  public Pick(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
-    const keys = KeyArrayResolver.Resolve(unresolved)
-    // prettier-ignore
-    return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ['$id', Transform]), (object) => {
-      if (ValueGuard.IsArray(object.required)) {
-        object.required = object.required.filter((key: any) => keys.includes(key))
-        if (object.required.length === 0) delete object.required
-      }
-      for (const key of Object.getOwnPropertyNames(object.properties)) {
-        if (!keys.includes(key as any)) delete object.properties[key]
-      }
-      return this.Create(object)
-    }, options)
-  }
-  /** `[Json]` Creates a Record type */
-  public Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options: ObjectOptions = {}): TRecordResolve<K, T> {
-    // prettier-ignore
-    return (
-      TypeGuard.TTemplateLiteral(key) ? (() => {
-        const expression = TemplateLiteralParser.ParseExact(key.pattern)
-        // prettier-ignore
-        return TemplateLiteralFinite.Check(expression)
-          ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Type(schema) }), {} as TProperties), options))
-          : this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Type(schema) }})
-      })() :
-      TypeGuard.TUnion(key) ? (() => {
-        const union = UnionResolver.Resolve(key)
-        if (TypeGuard.TUnionLiteral(union)) {
-          const properties = union.anyOf.reduce((acc: any, literal: any) => ({ ...acc, [literal.const]: TypeClone.Type(schema) }), {} as TProperties)
-          return this.Object(properties, { ...options, [Hint]: 'Record' })
-        } else this.Throw('Record key of type union contains non-literal types')
-      })() : 
-      TypeGuard.TLiteral(key) ? (() => {
-        // prettier-ignore
-        return (ValueGuard.IsString(key.const) || ValueGuard.IsNumber(key.const))
-        ? this.Object({ [key.const]: TypeClone.Type(schema) }, options)
-        : this.Throw('Record key of type literal is not of type string or number')
-      })() : 
-      TypeGuard.TInteger(key) || TypeGuard.TNumber(key) ? (() => {
-        return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [PatternNumberExact]: TypeClone.Type(schema) } })
-      })() : 
-      TypeGuard.TString(key) ? (() => {
-        const pattern = ValueGuard.IsUndefined(key.pattern) ? PatternStringExact : key.pattern
-        return this.Create<any>({ ...options, [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Type(schema) } })
-      })() : 
-      this.Never()
-    )
-  }
-  /** `[Json]` Creates a Recursive type */
-  public Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options: SchemaOptions = {}): TRecursive<T> {
-    if (ValueGuard.IsUndefined(options.$id)) (options as any).$id = `T${TypeOrdinal++}`
-    const thisType = callback({ [Kind]: 'This', $ref: `${options.$id}` } as any)
-    thisType.$id = options.$id
-    return this.Create({ ...options, [Hint]: 'Recursive', ...thisType } as any)
-  }
-  /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
-  public Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>
-  /** `[Json]` Creates a Ref type. */
-  public Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>
-  /** `[Json]` Creates a Ref type. */
-  public Ref(unresolved: TSchema | string, options: SchemaOptions = {}) {
-    if (ValueGuard.IsString(unresolved)) return this.Create({ ...options, [Kind]: 'Ref', $ref: unresolved })
-    if (ValueGuard.IsUndefined(unresolved.$id)) this.Throw('Reference target type must specify an $id')
-    return this.Create({ ...options, [Kind]: 'Ref', $ref: unresolved.$id! })
-  }
-  /** `[Json]` Constructs a type where all properties are required */
-  public Required<T extends TSchema>(schema: T, options: SchemaOptions = {}): TRequired<T> {
-    // prettier-ignore
-    return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ['$id', Transform]), (object) => {
-      const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
-        return { ...acc, [key]: this.Discard(object.properties[key], [Optional]) as TSchema }
-      }, {} as TProperties)
-      return this.Object(properties, object /* object used as options to retain other constraints  */)
-    }, options)
-  }
-  /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
-  public Rest<T extends TSchema>(schema: T): TRest<T> {
-    return (
-      TypeGuard.TTuple(schema) && !ValueGuard.IsUndefined(schema.items) ? TypeClone.Rest(schema.items) : TypeGuard.TIntersect(schema) ? TypeClone.Rest(schema.allOf) : TypeGuard.TUnion(schema) ? TypeClone.Rest(schema.anyOf) : []
-    ) as TRest<T>
-  }
-  /** `[Json]` Creates a String type */
-  public String(options: StringOptions = {}): TString {
-    return this.Create({ ...options, [Kind]: 'String', type: 'string' })
-  }
-  /** `[Json]` Creates a TemplateLiteral type from template dsl string */
-  public TemplateLiteral<T extends string>(templateDsl: T, options?: SchemaOptions): TTemplateLiteralDslParser<T>
-  /** `[Json]` Creates a TemplateLiteral type */
-  public TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>
-  /** `[Json]` Creates a TemplateLiteral type */
-  public TemplateLiteral(unresolved: unknown, options: SchemaOptions = {}) {
-    // prettier-ignore
-    const pattern = ValueGuard.IsString(unresolved)
-      ? TemplateLiteralPattern.Create(TemplateLiteralDslParser.Parse(unresolved))
-      : TemplateLiteralPattern.Create(unresolved as TTemplateLiteralKind[])
-    return this.Create({ ...options, [Kind]: 'TemplateLiteral', type: 'string', pattern })
-  }
-  /** `[Json]` Creates a Transform type */
-  public Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I> {
-    return new TransformDecodeBuilder(schema)
-  }
-  /** `[Json]` Creates a Tuple type */
-  public Tuple<T extends TSchema[]>(items: [...T], options: SchemaOptions = {}): TTuple<T> {
-    const [additionalItems, minItems, maxItems] = [false, items.length, items.length]
-    const clonedItems = TypeClone.Rest(items)
-    // prettier-ignore
-    const schema = (items.length > 0 ? 
-      { ...options, [Kind]: 'Tuple', type: 'array', items: clonedItems, additionalItems, minItems, maxItems } : 
-      { ...options, [Kind]: 'Tuple', type: 'array', minItems, maxItems }) as any
-    return this.Create(schema)
-  }
-  /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-  public Uncapitalize<T extends TSchema>(schema: T, options: SchemaOptions = {}): TIntrinsic<T, 'Uncapitalize'> {
-    return { ...Intrinsic.Map(TypeClone.Type(schema), 'Uncapitalize'), ...options }
-  }
-  /** `[Json]` Creates a Union type */
-  public Union(anyOf: [], options?: SchemaOptions): TNever
-  /** `[Json]` Creates a Union type */
-  public Union<T extends [TSchema]>(anyOf: [...T], options?: SchemaOptions): T[0]
-  /** `[Json]` Creates a Union type */
-  public Union<T extends TSchema[]>(anyOf: [...T], options?: SchemaOptions): TUnion<T>
-  /** `[Json-Experimental]` Converts a TemplateLiteral into a Union */
-  public Union<T extends TTemplateLiteral>(template: T): TUnionTemplateLiteral<T>
-  /** `[Json]` Creates a Union type */
-  public Union(union: TSchema[] | TTemplateLiteral, options: SchemaOptions = {}) {
-    // prettier-ignore
-    return TypeGuard.TTemplateLiteral(union) 
-      ? TemplateLiteralResolver.Resolve(union)
-      : (() => {
-        const anyOf = union
-        if (anyOf.length === 0) return this.Never(options)
-        if (anyOf.length === 1) return this.Create(TypeClone.Type(anyOf[0], options))
-        const clonedAnyOf = TypeClone.Rest(anyOf)
-        return this.Create({ ...options, [Kind]: 'Union', anyOf: clonedAnyOf })
-      })()
-  }
-  /** `[Json]` Creates an Unknown type */
-  public Unknown(options: SchemaOptions = {}): TUnknown {
-    return this.Create({ ...options, [Kind]: 'Unknown' })
-  }
-  /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
-  public Unsafe<T>(options: UnsafeOptions = {}): TUnsafe<T> {
-    return this.Create({ ...options, [Kind]: options[Kind] || 'Unsafe' })
-  }
-  /** `[Json]` Intrinsic function to Uppercase LiteralString types */
-  public Uppercase<T extends TSchema>(schema: T, options: SchemaOptions = {}): TIntrinsic<T, 'Uppercase'> {
-    return { ...Intrinsic.Map(TypeClone.Type(schema), 'Uppercase'), ...options }
-  }
-}
-// --------------------------------------------------------------------------
-// JavaScriptTypeBuilder
-// --------------------------------------------------------------------------
-export class JavaScriptTypeBuilder extends JsonTypeBuilder {
-  /** `[JavaScript]` Creates a AsyncIterator type */
-  public AsyncIterator<T extends TSchema>(items: T, options: SchemaOptions = {}): TAsyncIterator<T> {
-    return this.Create({ ...options, [Kind]: 'AsyncIterator', type: 'AsyncIterator', items: TypeClone.Type(items) })
-  }
-  /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-  public Awaited<T extends TSchema>(schema: T, options: SchemaOptions = {}): TAwaited<T> {
-    // prettier-ignore
-    const Unwrap = (rest: TSchema[]): TSchema[] => rest.length > 0 ? (() => {
-      const [L, ...R] = rest
-      return [this.Awaited(L), ...Unwrap(R)]
-    })() : rest
-    // prettier-ignore
-    return (
-      TypeGuard.TIntersect(schema) ? Type.Intersect(Unwrap(schema.allOf)) : 
-      TypeGuard.TUnion(schema) ? Type.Union(Unwrap(schema.anyOf)) :
-      TypeGuard.TPromise(schema) ? this.Awaited(schema.item) : 
-      TypeClone.Type(schema, options)
-    ) as TAwaited<T>
-  }
-  /** `[JavaScript]` Creates a BigInt type */
-  public BigInt(options: NumericOptions<bigint> = {}): TBigInt {
-    return this.Create({ ...options, [Kind]: 'BigInt', type: 'bigint' })
-  }
-  /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-  public ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options: SchemaOptions = {}): TConstructorParameters<T> {
-    return this.Tuple([...schema.parameters], { ...options })
-  }
-  /** `[JavaScript]` Creates a Constructor type */
-  public Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U> {
-    const [clonedParameters, clonedReturns] = [TypeClone.Rest(parameters), TypeClone.Type(returns)]
-    return this.Create({ ...options, [Kind]: 'Constructor', type: 'Constructor', parameters: clonedParameters, returns: clonedReturns })
-  }
-  /** `[JavaScript]` Creates a Date type */
-  public Date(options: DateOptions = {}): TDate {
-    return this.Create({ ...options, [Kind]: 'Date', type: 'Date' })
-  }
-  /** `[JavaScript]` Creates a Function type */
-  public Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U> {
-    const [clonedParameters, clonedReturns] = [TypeClone.Rest(parameters), TypeClone.Type(returns)]
-    return this.Create({ ...options, [Kind]: 'Function', type: 'Function', parameters: clonedParameters, returns: clonedReturns })
-  }
-  /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-  public InstanceType<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TInstanceType<T> {
-    return TypeClone.Type(schema.returns, options)
-  }
-  /** `[JavaScript]` Creates an Iterator type */
-  public Iterator<T extends TSchema>(items: T, options: SchemaOptions = {}): TIterator<T> {
-    return this.Create({ ...options, [Kind]: 'Iterator', type: 'Iterator', items: TypeClone.Type(items) })
-  }
-  /** `[JavaScript]` Extracts the Parameters from the given Function type */
-  public Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options: SchemaOptions = {}): TParameters<T> {
-    return this.Tuple(schema.parameters, { ...options })
-  }
-  /** `[JavaScript]` Creates a Promise type */
-  public Promise<T extends TSchema>(item: T, options: SchemaOptions = {}): TPromise<T> {
-    return this.Create({ ...options, [Kind]: 'Promise', type: 'Promise', item: TypeClone.Type(item) })
-  }
-  /** `[JavaScript]` Creates a String type from a Regular Expression pattern */
-  public RegExp(pattern: string, options?: SchemaOptions): TString
-  /** `[JavaScript]` Creates a String type from a Regular Expression */
-  public RegExp(regex: RegExp, options?: SchemaOptions): TString
-  /** `[Extended]` Creates a String type */
-  public RegExp(unresolved: string | RegExp, options: SchemaOptions = {}) {
-    const pattern = ValueGuard.IsString(unresolved) ? unresolved : unresolved.source
-    return this.Create({ ...options, [Kind]: 'String', type: 'string', pattern })
-  }
-  /**
-   * @deprecated Use `Type.RegExp`
-   */
-  public RegEx(regex: RegExp, options: SchemaOptions = {}): TString {
-    return this.RegExp(regex, options)
-  }
-  /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-  public ReturnType<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TReturnType<T> {
-    return TypeClone.Type(schema.returns, options)
-  }
-  /** `[JavaScript]` Creates a Symbol type */
-  public Symbol(options?: SchemaOptions): TSymbol {
-    return this.Create({ ...options, [Kind]: 'Symbol', type: 'symbol' })
-  }
-  /** `[JavaScript]` Creates a Undefined type */
-  public Undefined(options: SchemaOptions = {}): TUndefined {
-    return this.Create({ ...options, [Kind]: 'Undefined', type: 'undefined' })
-  }
-  /** `[JavaScript]` Creates a Uint8Array type */
-  public Uint8Array(options: Uint8ArrayOptions = {}): TUint8Array {
-    return this.Create({ ...options, [Kind]: 'Uint8Array', type: 'Uint8Array' })
-  }
-  /** `[JavaScript]` Creates a Void type */
-  public Void(options: SchemaOptions = {}): TVoid {
-    return this.Create({ ...options, [Kind]: 'Void', type: 'void' })
-  }
-}
-/** Json Type Builder with Static Resolution for TypeScript */
-export const JsonType = new JsonTypeBuilder()
-/** JavaScript Type Builder with Static Resolution for TypeScript */
-export const Type = new JavaScriptTypeBuilder()
diff --git a/src/value/cast.ts b/src/value/cast/cast.ts
similarity index 51%
rename from src/value/cast.ts
rename to src/value/cast/cast.ts
index 16e3ec9cf..8ac9e79df 100644
--- a/src/value/cast.ts
+++ b/src/value/cast/cast.ts
@@ -26,93 +26,92 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsPlainObject, IsArray, IsString, IsNumber, IsNull } from './guard'
-import { Create } from './create'
-import { Check } from './check'
-import { Clone } from './clone'
-import { Deref } from './deref'
-import * as Types from '../typebox'
+import { IsPlainObject, IsArray, IsString, IsNumber, IsNull } from '../guard/index'
+import { TypeBoxError } from '../../type/error/index'
+import { Kind } from '../../type/symbols/index'
+import { Create } from '../create/index'
+import { Check } from '../check/index'
+import { Clone } from '../clone/index'
+import { Deref } from '../deref/index'
 
-// --------------------------------------------------------------------------
+import type { TSchema } from '../../type/schema/index'
+import type { Static } from '../../type/static/index'
+import type { TArray } from '../../type/array/index'
+import type { TConstructor } from '../../type/constructor/index'
+import type { TIntersect } from '../../type/intersect/index'
+import type { TObject } from '../../type/object/index'
+import type { TRecord } from '../../type/record/index'
+import type { TRef } from '../../type/ref/index'
+import type { TThis } from '../../type/recursive/index'
+import type { TTuple } from '../../type/tuple/index'
+import type { TUnion } from '../../type/union/index'
+import type { TNever } from '../../type/never/index'
+
+// ------------------------------------------------------------------
 // Errors
-// --------------------------------------------------------------------------
-export class ValueCastArrayUniqueItemsTypeError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema, public readonly value: unknown) {
-    super('Array cast produced invalid data due to uniqueItems constraint')
-  }
-}
-export class ValueCastNeverTypeError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema) {
-    super('Never types cannot be cast')
-  }
-}
-export class ValueCastRecursiveTypeError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema) {
-    super('Cannot cast recursive schemas')
+// ------------------------------------------------------------------
+export class ValueCastError extends TypeBoxError {
+  constructor(public readonly schema: TSchema, message: string) {
+    super(message)
   }
 }
-export class ValueCastUnknownTypeError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema) {
-    super('Unknown type')
+// ------------------------------------------------------------------
+// The following will score a schema against a value. For objects,
+// the score is the tally of points awarded for each property of
+// the value. Property points are (1.0 / propertyCount) to prevent
+// large property counts biasing results. Properties that match
+// literal values are maximally awarded as literals are typically
+// used as union discriminator fields.
+// ------------------------------------------------------------------
+function ScoreUnion(schema: TSchema, references: TSchema[], value: any): number {
+  if (schema[Kind] === 'Object' && typeof value === 'object' && !IsNull(value)) {
+    const object = schema as TObject
+    const keys = Object.getOwnPropertyNames(value)
+    const entries = Object.entries(object.properties)
+    const [point, max] = [1 / entries.length, entries.length]
+    return entries.reduce((acc, [key, schema]) => {
+      const literal = schema[Kind] === 'Literal' && schema.const === value[key] ? max : 0
+      const checks = Check(schema, references, value[key]) ? point : 0
+      const exists = keys.includes(key) ? point : 0
+      return acc + (literal + checks + exists)
+    }, 0)
+  } else {
+    return Check(schema, references, value) ? 1 : 0
   }
 }
-// --------------------------------------------------------------------------
-// The following will score a schema against a value. For objects, the score
-// is the tally of points awarded for each property of the value. Property
-// points are (1.0 / propertyCount) to prevent large property counts biasing
-// results. Properties that match literal values are maximally awarded as
-// literals are typically used as union discriminator fields.
-// --------------------------------------------------------------------------
-namespace UnionCastCreate {
-  function Score(schema: Types.TSchema, references: Types.TSchema[], value: any): number {
-    if (schema[Types.Kind] === 'Object' && typeof value === 'object' && !IsNull(value)) {
-      const object = schema as Types.TObject
-      const keys = Object.getOwnPropertyNames(value)
-      const entries = Object.entries(object.properties)
-      const [point, max] = [1 / entries.length, entries.length]
-      return entries.reduce((acc, [key, schema]) => {
-        const literal = schema[Types.Kind] === 'Literal' && schema.const === value[key] ? max : 0
-        const checks = Check(schema, references, value[key]) ? point : 0
-        const exists = keys.includes(key) ? point : 0
-        return acc + (literal + checks + exists)
-      }, 0)
-    } else {
-      return Check(schema, references, value) ? 1 : 0
+function SelectUnion(union: TUnion, references: TSchema[], value: any): TSchema {
+  let [select, best] = [union.anyOf[0], 0]
+  for (const schema of union.anyOf) {
+    const score = ScoreUnion(schema, references, value)
+    if (score > best) {
+      select = schema
+      best = score
     }
   }
-  function Select(union: Types.TUnion, references: Types.TSchema[], value: any): Types.TSchema {
-    let [select, best] = [union.anyOf[0], 0]
-    for (const schema of union.anyOf) {
-      const score = Score(schema, references, value)
-      if (score > best) {
-        select = schema
-        best = score
-      }
-    }
-    return select
-  }
-  export function Create(union: Types.TUnion, references: Types.TSchema[], value: any) {
-    if ('default' in union) {
-      return union.default
-    } else {
-      const schema = Select(union, references, value)
-      return Cast(schema, references, value)
-    }
+  return select
+}
+function CastUnion(union: TUnion, references: TSchema[], value: any) {
+  if ('default' in union) {
+    return union.default
+  } else {
+    const schema = SelectUnion(union, references, value)
+    return Cast(schema, references, value)
   }
 }
-// --------------------------------------------------------------------------
+
+// ------------------------------------------------------------------
 // Default
-// --------------------------------------------------------------------------
-export function DefaultClone(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
+// ------------------------------------------------------------------
+function DefaultClone(schema: TSchema, references: TSchema[], value: any): any {
   return Check(schema, references, value) ? Clone(value) : Create(schema, references)
 }
-export function Default(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
+function Default(schema: TSchema, references: TSchema[], value: any): any {
   return Check(schema, references, value) ? value : Create(schema, references)
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Cast
-// --------------------------------------------------------------------------
-function TArray(schema: Types.TArray, references: Types.TSchema[], value: any): any {
+// ------------------------------------------------------------------
+function FromArray(schema: TArray, references: TSchema[], value: any): any {
   if (Check(schema, references, value)) return Clone(value)
   const created = IsArray(value) ? Clone(value) : Create(schema, references)
   const minimum = IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...Array.from({ length: schema.minItems - created.length }, () => null)] : created
@@ -120,28 +119,28 @@ function TArray(schema: Types.TArray, references: Types.TSchema[], value: any):
   const casted = maximum.map((value: unknown) => Visit(schema.items, references, value))
   if (schema.uniqueItems !== true) return casted
   const unique = [...new Set(casted)]
-  if (!Check(schema, references, unique)) throw new ValueCastArrayUniqueItemsTypeError(schema, unique)
+  if (!Check(schema, references, unique)) throw new ValueCastError(schema, 'Array cast produced invalid data due to uniqueItems constraint')
   return unique
 }
-function TConstructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): any {
+function FromConstructor(schema: TConstructor, references: TSchema[], value: any): any {
   if (Check(schema, references, value)) return Create(schema, references)
   const required = new Set(schema.returns.required || [])
   const result = function () {}
   for (const [key, property] of Object.entries(schema.returns.properties)) {
     if (!required.has(key) && value.prototype[key] === undefined) continue
-    result.prototype[key] = Visit(property as Types.TSchema, references, value.prototype[key])
+    result.prototype[key] = Visit(property as TSchema, references, value.prototype[key])
   }
   return result
 }
-function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any): any {
+function FromIntersect(schema: TIntersect, references: TSchema[], value: any): any {
   const created = Create(schema, references)
   const mapped = IsPlainObject(created) && IsPlainObject(value) ? { ...(created as any), ...value } : value
   return Check(schema, references, mapped) ? mapped : Create(schema, references)
 }
-function TNever(schema: Types.TNever, references: Types.TSchema[], value: any): any {
-  throw new ValueCastNeverTypeError(schema)
+function FromNever(schema: TNever, references: TSchema[], value: any): any {
+  throw new ValueCastError(schema, 'Never types cannot be cast')
 }
-function TObject(schema: Types.TObject, references: Types.TSchema[], value: any): any {
+function FromObject(schema: TObject, references: TSchema[], value: any): any {
   if (Check(schema, references, value)) return value
   if (value === null || typeof value !== 'object') return Create(schema, references)
   const required = new Set(schema.required || [])
@@ -160,7 +159,7 @@ function TObject(schema: Types.TObject, references: Types.TSchema[], value: any)
   }
   return result
 }
-function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): any {
+function FromRecord(schema: TRecord, references: TSchema[], value: any): any {
   if (Check(schema, references, value)) return Clone(value)
   if (value === null || typeof value !== 'object' || Array.isArray(value) || value instanceof Date) return Create(schema, references)
   const subschemaPropertyName = Object.getOwnPropertyNames(schema.patternProperties)[0]
@@ -171,88 +170,69 @@ function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], v
   }
   return result
 }
-function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any): any {
+function FromRef(schema: TRef, references: TSchema[], value: any): any {
   return Visit(Deref(schema, references), references, value)
 }
-function TThis(schema: Types.TThis, references: Types.TSchema[], value: any): any {
+function FromThis(schema: TThis, references: TSchema[], value: any): any {
   return Visit(Deref(schema, references), references, value)
 }
-function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): any {
+function FromTuple(schema: TTuple, references: TSchema[], value: any): any {
   if (Check(schema, references, value)) return Clone(value)
   if (!IsArray(value)) return Create(schema, references)
   if (schema.items === undefined) return []
   return schema.items.map((schema, index) => Visit(schema, references, value[index]))
 }
-function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any): any {
-  return Check(schema, references, value) ? Clone(value) : UnionCastCreate.Create(schema, references, value)
+function FromUnion(schema: TUnion, references: TSchema[], value: any): any {
+  return Check(schema, references, value) ? Clone(value) : CastUnion(schema, references, value)
 }
-function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
+function Visit(schema: TSchema, references: TSchema[], value: any): any {
   const references_ = IsString(schema.$id) ? [...references, schema] : references
   const schema_ = schema as any
-  switch (schema[Types.Kind]) {
-    // ------------------------------------------------------
+  switch (schema[Kind]) {
+    // --------------------------------------------------------------
     // Structural
-    // ------------------------------------------------------
+    // --------------------------------------------------------------
     case 'Array':
-      return TArray(schema_, references_, value)
+      return FromArray(schema_, references_, value)
     case 'Constructor':
-      return TConstructor(schema_, references_, value)
+      return FromConstructor(schema_, references_, value)
     case 'Intersect':
-      return TIntersect(schema_, references_, value)
+      return FromIntersect(schema_, references_, value)
     case 'Never':
-      return TNever(schema_, references_, value)
+      return FromNever(schema_, references_, value)
     case 'Object':
-      return TObject(schema_, references_, value)
+      return FromObject(schema_, references_, value)
     case 'Record':
-      return TRecord(schema_, references_, value)
+      return FromRecord(schema_, references_, value)
     case 'Ref':
-      return TRef(schema_, references_, value)
+      return FromRef(schema_, references_, value)
     case 'This':
-      return TThis(schema_, references_, value)
+      return FromThis(schema_, references_, value)
     case 'Tuple':
-      return TTuple(schema_, references_, value)
+      return FromTuple(schema_, references_, value)
     case 'Union':
-      return TUnion(schema_, references_, value)
-    // ------------------------------------------------------
+      return FromUnion(schema_, references_, value)
+    // --------------------------------------------------------------
     // DefaultClone
-    // ------------------------------------------------------
+    // --------------------------------------------------------------
     case 'Date':
     case 'Symbol':
     case 'Uint8Array':
       return DefaultClone(schema, references, value)
-    // ------------------------------------------------------
+    // --------------------------------------------------------------
     // Default
-    // ------------------------------------------------------
-    case 'Any':
-    case 'AsyncIterator':
-    case 'BigInt':
-    case 'Boolean':
-    case 'Function':
-    case 'Integer':
-    case 'Iterator':
-    case 'Literal':
-    case 'Not':
-    case 'Null':
-    case 'Number':
-    case 'Promise':
-    case 'String':
-    case 'TemplateLiteral':
-    case 'Undefined':
-    case 'Unknown':
-    case 'Void':
-      return Default(schema_, references_, value)
+    // --------------------------------------------------------------
     default:
-      if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueCastUnknownTypeError(schema_)
       return Default(schema_, references_, value)
   }
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Cast
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 /** Casts a value into a given type and references. The return value will retain as much information of the original value as possible. */
-export function Cast<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): Types.Static<T>
+export function Cast<T extends TSchema>(schema: T, references: TSchema[], value: unknown): Static<T>
 /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
-export function Cast<T extends Types.TSchema>(schema: T, value: unknown): Types.Static<T>
+export function Cast<T extends TSchema>(schema: T, value: unknown): Static<T>
 /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
 export function Cast(...args: any[]) {
   return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1])
diff --git a/src/value/cast/index.ts b/src/value/cast/index.ts
new file mode 100644
index 000000000..5d403f74a
--- /dev/null
+++ b/src/value/cast/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './cast'
diff --git a/src/value/check.ts b/src/value/check/check.ts
similarity index 58%
rename from src/value/check.ts
rename to src/value/check/check.ts
index 7e987708c..c2cd892db 100644
--- a/src/value/check.ts
+++ b/src/value/check/check.ts
@@ -26,39 +26,84 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsArray, IsUint8Array, IsDate, IsPromise, IsFunction, IsAsyncIterator, IsIterator, IsBoolean, IsNumber, IsBigInt, IsString, IsSymbol, IsInteger, IsNull, IsUndefined } from './guard'
-import { TypeSystemPolicy } from '../system/index'
-import { Deref } from './deref'
-import { Hash } from './hash'
-import * as Types from '../typebox'
+import { TypeSystemPolicy } from '../../system/index'
+import { Deref } from '../deref/index'
+import { Hash } from '../hash/index'
+import { Kind } from '../../type/symbols/index'
+import { KeyOfPattern } from '../../type/keyof/index'
+import { ExtendsUndefinedCheck } from '../../type/extends/index'
+import { TypeRegistry, FormatRegistry } from '../../type/registry/index'
+import { TypeBoxError } from '../../type/error/index'
 
-// --------------------------------------------------------------------------
+import type { TSchema } from '../../type/schema/index'
+import type { TAsyncIterator } from '../../type/async-iterator/index'
+import type { TAny } from '../../type/any/index'
+import type { TArray } from '../../type/array/index'
+import type { TBigInt } from '../../type/bigint/index'
+import type { TBoolean } from '../../type/boolean/index'
+import type { TDate } from '../../type/date/index'
+import type { TConstructor } from '../../type/constructor/index'
+import type { TFunction } from '../../type/function/index'
+import type { TInteger } from '../../type/integer/index'
+import type { TIntersect } from '../../type/intersect/index'
+import type { TIterator } from '../../type/iterator/index'
+import type { TLiteral } from '../../type/literal/index'
+import { Never, type TNever } from '../../type/never/index'
+import type { TNot } from '../../type/not/index'
+import type { TNull } from '../../type/null/index'
+import type { TNumber } from '../../type/number/index'
+import type { TObject } from '../../type/object/index'
+import type { TPromise } from '../../type/promise/index'
+import type { TRecord } from '../../type/record/index'
+import type { TRef } from '../../type/ref/index'
+import type { TRegExp } from '../../type/regexp/index'
+import type { TTemplateLiteral } from '../../type/template-literal/index'
+import type { TThis } from '../../type/recursive/index'
+import type { TTuple } from '../../type/tuple/index'
+import type { TUnion } from '../../type/union/index'
+import type { TUnknown } from '../../type/unknown/index'
+import type { Static } from '../../type/static/index'
+import type { TString } from '../../type/string/index'
+import type { TSymbol } from '../../type/symbol/index'
+import type { TUndefined } from '../../type/undefined/index'
+import type { TUint8Array } from '../../type/uint8array/index'
+import type { TVoid } from '../../type/void/index'
+
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsArray, IsUint8Array, IsDate, IsPromise, IsFunction, IsAsyncIterator, IsIterator, IsBoolean, IsNumber, IsBigInt, IsString, IsSymbol, IsInteger, IsNull, IsUndefined } from '../guard/index'
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsSchema } from '../../type/guard/type'
+// ------------------------------------------------------------------
 // Errors
-// --------------------------------------------------------------------------
-export class ValueCheckUnknownTypeError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema) {
+// ------------------------------------------------------------------
+export class ValueCheckUnknownTypeError extends TypeBoxError {
+  constructor(public readonly schema: TSchema) {
     super(`Unknown type`)
   }
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // TypeGuards
-// --------------------------------------------------------------------------
-function IsAnyOrUnknown(schema: Types.TSchema) {
-  return schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown'
+// ------------------------------------------------------------------
+function IsAnyOrUnknown(schema: TSchema) {
+  return schema[Kind] === 'Any' || schema[Kind] === 'Unknown'
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Guards
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function IsDefined<T>(value: unknown): value is T {
   return value !== undefined
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Types
-// --------------------------------------------------------------------------
-function TAny(schema: Types.TAny, references: Types.TSchema[], value: any): boolean {
+// ------------------------------------------------------------------
+function FromAny(schema: TAny, references: TSchema[], value: any): boolean {
   return true
 }
-function TArray(schema: Types.TArray, references: Types.TSchema[], value: any): boolean {
+function FromArray(schema: TArray, references: TSchema[], value: any): boolean {
   if (!IsArray(value)) return false
   if (IsDefined<number>(schema.minItems) && !(value.length >= schema.minItems)) {
     return false
@@ -77,7 +122,7 @@ function TArray(schema: Types.TArray, references: Types.TSchema[], value: any):
   if (!(IsDefined(schema.contains) || IsNumber(schema.minContains) || IsNumber(schema.maxContains))) {
     return true // exit
   }
-  const containsSchema = IsDefined<Types.TSchema>(schema.contains) ? schema.contains : Types.Type.Never()
+  const containsSchema = IsDefined<TSchema>(schema.contains) ? schema.contains : Never()
   const containsCount = value.reduce((acc: number, value) => (Visit(containsSchema, references, value) ? acc + 1 : acc), 0)
   if (containsCount === 0) {
     return false
@@ -90,10 +135,10 @@ function TArray(schema: Types.TArray, references: Types.TSchema[], value: any):
   }
   return true
 }
-function TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[], value: any): boolean {
+function FromAsyncIterator(schema: TAsyncIterator, references: TSchema[], value: any): boolean {
   return IsAsyncIterator(value)
 }
-function TBigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any): boolean {
+function FromBigInt(schema: TBigInt, references: TSchema[], value: any): boolean {
   if (!IsBigInt(value)) return false
   if (IsDefined<bigint>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
     return false
@@ -112,13 +157,13 @@ function TBigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any)
   }
   return true
 }
-function TBoolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): boolean {
+function FromBoolean(schema: TBoolean, references: TSchema[], value: any): boolean {
   return IsBoolean(value)
 }
-function TConstructor(schema: Types.TConstructor, references: Types.TSchema[], value: any): boolean {
+function FromConstructor(schema: TConstructor, references: TSchema[], value: any): boolean {
   return Visit(schema.returns, references, value.prototype)
 }
-function TDate(schema: Types.TDate, references: Types.TSchema[], value: any): boolean {
+function FromDate(schema: TDate, references: TSchema[], value: any): boolean {
   if (!IsDate(value)) return false
   if (IsDefined<number>(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
     return false
@@ -137,10 +182,10 @@ function TDate(schema: Types.TDate, references: Types.TSchema[], value: any): bo
   }
   return true
 }
-function TFunction(schema: Types.TFunction, references: Types.TSchema[], value: any): boolean {
+function FromFunction(schema: TFunction, references: TSchema[], value: any): boolean {
   return IsFunction(value)
 }
-function TInteger(schema: Types.TInteger, references: Types.TSchema[], value: any): boolean {
+function FromInteger(schema: TInteger, references: TSchema[], value: any): boolean {
   if (!IsInteger(value)) {
     return false
   }
@@ -161,36 +206,36 @@ function TInteger(schema: Types.TInteger, references: Types.TSchema[], value: an
   }
   return true
 }
-function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any): boolean {
+function FromIntersect(schema: TIntersect, references: TSchema[], value: any): boolean {
   const check1 = schema.allOf.every((schema) => Visit(schema, references, value))
   if (schema.unevaluatedProperties === false) {
-    const keyPattern = new RegExp(Types.KeyResolver.ResolvePattern(schema))
+    const keyPattern = new RegExp(KeyOfPattern(schema))
     const check2 = Object.getOwnPropertyNames(value).every((key) => keyPattern.test(key))
     return check1 && check2
-  } else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
-    const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema))
-    const check2 = Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key) || Visit(schema.unevaluatedProperties as Types.TSchema, references, value[key]))
+  } else if (IsSchema(schema.unevaluatedProperties)) {
+    const keyCheck = new RegExp(KeyOfPattern(schema))
+    const check2 = Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key) || Visit(schema.unevaluatedProperties as TSchema, references, value[key]))
     return check1 && check2
   } else {
     return check1
   }
 }
-function TIterator(schema: Types.TIterator, references: Types.TSchema[], value: any): boolean {
+function FromIterator(schema: TIterator, references: TSchema[], value: any): boolean {
   return IsIterator(value)
 }
-function TLiteral(schema: Types.TLiteral, references: Types.TSchema[], value: any): boolean {
+function FromLiteral(schema: TLiteral, references: TSchema[], value: any): boolean {
   return value === schema.const
 }
-function TNever(schema: Types.TNever, references: Types.TSchema[], value: any): boolean {
+function FromNever(schema: TNever, references: TSchema[], value: any): boolean {
   return false
 }
-function TNot(schema: Types.TNot, references: Types.TSchema[], value: any): boolean {
+function FromNot(schema: TNot, references: TSchema[], value: any): boolean {
   return !Visit(schema.not, references, value)
 }
-function TNull(schema: Types.TNull, references: Types.TSchema[], value: any): boolean {
+function FromNull(schema: TNull, references: TSchema[], value: any): boolean {
   return IsNull(value)
 }
-function TNumber(schema: Types.TNumber, references: Types.TSchema[], value: any): boolean {
+function FromNumber(schema: TNumber, references: TSchema[], value: any): boolean {
   if (!TypeSystemPolicy.IsNumberLike(value)) return false
   if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
     return false
@@ -209,7 +254,7 @@ function TNumber(schema: Types.TNumber, references: Types.TSchema[], value: any)
   }
   return true
 }
-function TObject(schema: Types.TObject, references: Types.TSchema[], value: any): boolean {
+function FromObject(schema: TObject, references: TSchema[], value: any): boolean {
   if (!TypeSystemPolicy.IsObjectLike(value)) return false
   if (IsDefined<number>(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
     return false
@@ -224,7 +269,7 @@ function TObject(schema: Types.TObject, references: Types.TSchema[], value: any)
       if (!Visit(property, references, value[knownKey])) {
         return false
       }
-      if ((Types.ExtendsUndefined.Check(property) || IsAnyOrUnknown(property)) && !(knownKey in value)) {
+      if ((ExtendsUndefinedCheck(property) || IsAnyOrUnknown(property)) && !(knownKey in value)) {
         return false
       }
     } else {
@@ -243,15 +288,15 @@ function TObject(schema: Types.TObject, references: Types.TSchema[], value: any)
     }
   } else if (typeof schema.additionalProperties === 'object') {
     const valueKeys = Object.getOwnPropertyNames(value)
-    return valueKeys.every((key) => knownKeys.includes(key) || Visit(schema.additionalProperties as Types.TSchema, references, value[key]))
+    return valueKeys.every((key) => knownKeys.includes(key) || Visit(schema.additionalProperties as TSchema, references, value[key]))
   } else {
     return true
   }
 }
-function TPromise(schema: Types.TPromise<any>, references: Types.TSchema[], value: any): boolean {
+function FromPromise(schema: TPromise, references: TSchema[], value: any): boolean {
   return IsPromise(value)
 }
-function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): boolean {
+function FromRecord(schema: TRecord, references: TSchema[], value: any): boolean {
   if (!TypeSystemPolicy.IsRecordLike(value)) {
     return false
   }
@@ -269,7 +314,7 @@ function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], v
   })
   // prettier-ignore
   const check2 = typeof schema.additionalProperties === 'object' ? Object.entries(value).every(([key, value]) => {
-    return (!regex.test(key)) ? Visit(schema.additionalProperties as Types.TSchema, references, value) : true
+    return (!regex.test(key)) ? Visit(schema.additionalProperties as TSchema, references, value) : true
   }) : true
   const check3 =
     schema.additionalProperties === false
@@ -279,10 +324,14 @@ function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], v
       : true
   return check1 && check2 && check3
 }
-function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any): boolean {
+function FromRef(schema: TRef, references: TSchema[], value: any): boolean {
   return Visit(Deref(schema, references), references, value)
 }
-function TString(schema: Types.TString, references: Types.TSchema[], value: any): boolean {
+function FromRegExp(schema: TRegExp, references: TSchema[], value: any): boolean {
+  const regex = new RegExp(schema.source, schema.flags)
+  return regex.test(value)
+}
+function FromString(schema: TString, references: TSchema[], value: any): boolean {
   if (!IsString(value)) {
     return false
   }
@@ -297,22 +346,22 @@ function TString(schema: Types.TString, references: Types.TSchema[], value: any)
     if (!regex.test(value)) return false
   }
   if (IsDefined<string>(schema.format)) {
-    if (!Types.FormatRegistry.Has(schema.format)) return false
-    const func = Types.FormatRegistry.Get(schema.format)!
+    if (!FormatRegistry.Has(schema.format)) return false
+    const func = FormatRegistry.Get(schema.format)!
     return func(value)
   }
   return true
 }
-function TSymbol(schema: Types.TSymbol, references: Types.TSchema[], value: any): boolean {
+function FromSymbol(schema: TSymbol, references: TSchema[], value: any): boolean {
   return IsSymbol(value)
 }
-function TTemplateLiteral(schema: Types.TTemplateLiteralKind, references: Types.TSchema[], value: any): boolean {
+function FromTemplateLiteral(schema: TTemplateLiteral, references: TSchema[], value: any): boolean {
   return IsString(value) && new RegExp(schema.pattern).test(value)
 }
-function TThis(schema: Types.TThis, references: Types.TSchema[], value: any): boolean {
+function FromThis(schema: TThis, references: TSchema[], value: any): boolean {
   return Visit(Deref(schema, references), references, value)
 }
-function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): boolean {
+function FromTuple(schema: TTuple<any[]>, references: TSchema[], value: any): boolean {
   if (!IsArray(value)) {
     return false
   }
@@ -330,13 +379,13 @@ function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value:
   }
   return true
 }
-function TUndefined(schema: Types.TUndefined, references: Types.TSchema[], value: any): boolean {
+function FromUndefined(schema: TUndefined, references: TSchema[], value: any): boolean {
   return IsUndefined(value)
 }
-function TUnion(schema: Types.TUnion<any[]>, references: Types.TSchema[], value: any): boolean {
+function FromUnion(schema: TUnion, references: TSchema[], value: any): boolean {
   return schema.anyOf.some((inner) => Visit(inner, references, value))
 }
-function TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], value: any): boolean {
+function FromUint8Array(schema: TUint8Array, references: TSchema[], value: any): boolean {
   if (!IsUint8Array(value)) {
     return false
   }
@@ -348,93 +397,95 @@ function TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[], val
   }
   return true
 }
-function TUnknown(schema: Types.TUnknown, references: Types.TSchema[], value: any): boolean {
+function FromUnknown(schema: TUnknown, references: TSchema[], value: any): boolean {
   return true
 }
-function TVoid(schema: Types.TVoid, references: Types.TSchema[], value: any): boolean {
+function FromVoid(schema: TVoid, references: TSchema[], value: any): boolean {
   return TypeSystemPolicy.IsVoidLike(value)
 }
-function TKind(schema: Types.TSchema, references: Types.TSchema[], value: unknown): boolean {
-  if (!Types.TypeRegistry.Has(schema[Types.Kind])) return false
-  const func = Types.TypeRegistry.Get(schema[Types.Kind])!
+function FromKind(schema: TSchema, references: TSchema[], value: unknown): boolean {
+  if (!TypeRegistry.Has(schema[Kind])) return false
+  const func = TypeRegistry.Get(schema[Kind])!
   return func(schema, value)
 }
-function Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): boolean {
+function Visit<T extends TSchema>(schema: T, references: TSchema[], value: any): boolean {
   const references_ = IsDefined<string>(schema.$id) ? [...references, schema] : references
   const schema_ = schema as any
-  switch (schema_[Types.Kind]) {
+  switch (schema_[Kind]) {
     case 'Any':
-      return TAny(schema_, references_, value)
+      return FromAny(schema_, references_, value)
     case 'Array':
-      return TArray(schema_, references_, value)
+      return FromArray(schema_, references_, value)
     case 'AsyncIterator':
-      return TAsyncIterator(schema_, references_, value)
+      return FromAsyncIterator(schema_, references_, value)
     case 'BigInt':
-      return TBigInt(schema_, references_, value)
+      return FromBigInt(schema_, references_, value)
     case 'Boolean':
-      return TBoolean(schema_, references_, value)
+      return FromBoolean(schema_, references_, value)
     case 'Constructor':
-      return TConstructor(schema_, references_, value)
+      return FromConstructor(schema_, references_, value)
     case 'Date':
-      return TDate(schema_, references_, value)
+      return FromDate(schema_, references_, value)
     case 'Function':
-      return TFunction(schema_, references_, value)
+      return FromFunction(schema_, references_, value)
     case 'Integer':
-      return TInteger(schema_, references_, value)
+      return FromInteger(schema_, references_, value)
     case 'Intersect':
-      return TIntersect(schema_, references_, value)
+      return FromIntersect(schema_, references_, value)
     case 'Iterator':
-      return TIterator(schema_, references_, value)
+      return FromIterator(schema_, references_, value)
     case 'Literal':
-      return TLiteral(schema_, references_, value)
+      return FromLiteral(schema_, references_, value)
     case 'Never':
-      return TNever(schema_, references_, value)
+      return FromNever(schema_, references_, value)
     case 'Not':
-      return TNot(schema_, references_, value)
+      return FromNot(schema_, references_, value)
     case 'Null':
-      return TNull(schema_, references_, value)
+      return FromNull(schema_, references_, value)
     case 'Number':
-      return TNumber(schema_, references_, value)
+      return FromNumber(schema_, references_, value)
     case 'Object':
-      return TObject(schema_, references_, value)
+      return FromObject(schema_, references_, value)
     case 'Promise':
-      return TPromise(schema_, references_, value)
+      return FromPromise(schema_, references_, value)
     case 'Record':
-      return TRecord(schema_, references_, value)
+      return FromRecord(schema_, references_, value)
     case 'Ref':
-      return TRef(schema_, references_, value)
+      return FromRef(schema_, references_, value)
+    case 'RegExp':
+      return FromRegExp(schema_, references_, value)
     case 'String':
-      return TString(schema_, references_, value)
+      return FromString(schema_, references_, value)
     case 'Symbol':
-      return TSymbol(schema_, references_, value)
+      return FromSymbol(schema_, references_, value)
     case 'TemplateLiteral':
-      return TTemplateLiteral(schema_, references_, value)
+      return FromTemplateLiteral(schema_, references_, value)
     case 'This':
-      return TThis(schema_, references_, value)
+      return FromThis(schema_, references_, value)
     case 'Tuple':
-      return TTuple(schema_, references_, value)
+      return FromTuple(schema_, references_, value)
     case 'Undefined':
-      return TUndefined(schema_, references_, value)
+      return FromUndefined(schema_, references_, value)
     case 'Union':
-      return TUnion(schema_, references_, value)
+      return FromUnion(schema_, references_, value)
     case 'Uint8Array':
-      return TUint8Array(schema_, references_, value)
+      return FromUint8Array(schema_, references_, value)
     case 'Unknown':
-      return TUnknown(schema_, references_, value)
+      return FromUnknown(schema_, references_, value)
     case 'Void':
-      return TVoid(schema_, references_, value)
+      return FromVoid(schema_, references_, value)
     default:
-      if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueCheckUnknownTypeError(schema_)
-      return TKind(schema_, references_, value)
+      if (!TypeRegistry.Has(schema_[Kind])) throw new ValueCheckUnknownTypeError(schema_)
+      return FromKind(schema_, references_, value)
   }
 }
 // --------------------------------------------------------------------------
 // Check
 // --------------------------------------------------------------------------
 /** Returns true if the value matches the given type. */
-export function Check<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): value is Types.Static<T>
+export function Check<T extends TSchema>(schema: T, references: TSchema[], value: unknown): value is Static<T>
 /** Returns true if the value matches the given type. */
-export function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>
+export function Check<T extends TSchema>(schema: T, value: unknown): value is Static<T>
 /** Returns true if the value matches the given type. */
 export function Check(...args: any[]) {
   return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1])
diff --git a/src/value/check/index.ts b/src/value/check/index.ts
new file mode 100644
index 000000000..e318a6581
--- /dev/null
+++ b/src/value/check/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './check'
diff --git a/src/value/clean/clean.ts b/src/value/clean/clean.ts
new file mode 100644
index 000000000..29c52d32d
--- /dev/null
+++ b/src/value/clean/clean.ts
@@ -0,0 +1,184 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { KeyOfPropertyKeys } from '../../type/keyof/index'
+import { Check } from '../check/index'
+import { Clone } from '../clone/index'
+import { Deref } from '../deref/index'
+import { Kind } from '../../type/symbols/index'
+
+import type { TSchema } from '../../type/schema/index'
+import type { TArray } from '../../type/array/index'
+import type { TIntersect } from '../../type/intersect/index'
+import type { TObject } from '../../type/object/index'
+import type { TRecord } from '../../type/record/index'
+import type { TRef } from '../../type/ref/index'
+import type { TThis } from '../../type/recursive/index'
+import type { TTuple } from '../../type/tuple/index'
+import type { TUnion } from '../../type/union/index'
+
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+import { 
+  IsString, 
+  IsObject, 
+  IsArray, 
+  IsUndefined 
+} from '../guard/index'
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+import { 
+  IsSchema
+} from '../../type/guard/type'
+// ------------------------------------------------------------------
+// IsCheckable
+// ------------------------------------------------------------------
+function IsCheckable(schema: unknown): boolean {
+  return IsSchema(schema) && schema[Kind] !== 'Unsafe'
+}
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+function FromArray(schema: TArray, references: TSchema[], value: unknown): any {
+  if (!IsArray(value)) return value
+  return value.map((value) => Visit(schema.items, references, value))
+}
+function FromIntersect(schema: TIntersect, references: TSchema[], value: unknown): any {
+  const unevaluatedProperties = schema.unevaluatedProperties as TSchema
+  const intersections = schema.allOf.map((schema) => Visit(schema, references, Clone(value)))
+  const composite = intersections.reduce((acc: any, value: any) => (IsObject(value) ? { ...acc, ...value } : value), {})
+  if (!IsObject(value) || !IsObject(composite) || !IsSchema(unevaluatedProperties)) return composite
+  const knownkeys = KeyOfPropertyKeys(schema) as string[]
+  for (const key of Object.getOwnPropertyNames(value)) {
+    if (knownkeys.includes(key)) continue
+    if (Check(unevaluatedProperties, references, value[key])) {
+      composite[key] = Visit(unevaluatedProperties, references, value[key])
+    }
+  }
+  return composite
+}
+function FromObject(schema: TObject, references: TSchema[], value: unknown): any {
+  if (!IsObject(value) || IsArray(value)) return value // Check IsArray for AllowArrayObject configuration
+  const additionalProperties = schema.additionalProperties as TSchema
+  for (const key of Object.getOwnPropertyNames(value)) {
+    if (key in schema.properties) {
+      value[key] = Visit(schema.properties[key], references, value[key])
+      continue
+    }
+    if (IsSchema(additionalProperties) && Check(additionalProperties, references, value[key])) {
+      value[key] = Visit(additionalProperties, references, value[key])
+      continue
+    }
+    delete value[key]
+  }
+  return value
+}
+function FromRecord(schema: TRecord, references: TSchema[], value: unknown): any {
+  if (!IsObject(value)) return value
+  const additionalProperties = schema.additionalProperties as TSchema
+  const propertyKeys = Object.keys(value)
+  const [propertyKey, propertySchema] = Object.entries(schema.patternProperties)[0]
+  const propertyKeyTest = new RegExp(propertyKey)
+  for (const key of propertyKeys) {
+    if (propertyKeyTest.test(key)) {
+      value[key] = Visit(propertySchema, references, value[key])
+      continue
+    }
+    if (IsSchema(additionalProperties) && Check(additionalProperties, references, value[key])) {
+      value[key] = Visit(additionalProperties, references, value[key])
+      continue
+    }
+    delete value[key]
+  }
+  return value
+}
+function FromRef(schema: TRef, references: TSchema[], value: unknown): any {
+  return Visit(Deref(schema, references), references, value)
+}
+function FromThis(schema: TThis, references: TSchema[], value: unknown): any {
+  return Visit(Deref(schema, references), references, value)
+}
+function FromTuple(schema: TTuple, references: TSchema[], value: unknown): any {
+  if (!IsArray(value)) return value
+  if (IsUndefined(schema.items)) return []
+  const length = Math.min(value.length, schema.items.length)
+  for (let i = 0; i < length; i++) {
+    value[i] = Visit(schema.items[i], references, value[i])
+  }
+  // prettier-ignore
+  return value.length > length 
+    ? value.slice(0, length) 
+    : value
+}
+function FromUnion(schema: TUnion, references: TSchema[], value: unknown): any {
+  for (const inner of schema.anyOf) {
+    if (IsCheckable(inner) && Check(inner, value)) {
+      return Visit(inner, references, value)
+    }
+  }
+  return value
+}
+function Visit(schema: TSchema, references: TSchema[], value: unknown): unknown {
+  const references_ = IsString(schema.$id) ? [...references, schema] : references
+  const schema_ = schema as any
+  switch (schema_[Kind]) {
+    case 'Array':
+      return FromArray(schema_, references_, value)
+    case 'Intersect':
+      return FromIntersect(schema_, references_, value)
+    case 'Object':
+      return FromObject(schema_, references_, value)
+    case 'Record':
+      return FromRecord(schema_, references_, value)
+    case 'Ref':
+      return FromRef(schema_, references_, value)
+    case 'This':
+      return FromThis(schema_, references_, value)
+    case 'Tuple':
+      return FromTuple(schema_, references_, value)
+    case 'Union':
+      return FromUnion(schema_, references_, value)
+    default:
+      return value
+  }
+}
+// ------------------------------------------------------------------
+// Clean
+// ------------------------------------------------------------------
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
+export function Clean<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
+export function Clean<T extends TSchema>(schema: T): unknown
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
+export function Clean(...args: any[]) {
+  return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1])
+}
diff --git a/src/value/clean/index.ts b/src/value/clean/index.ts
new file mode 100644
index 000000000..4e55b279e
--- /dev/null
+++ b/src/value/clean/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './clean'
diff --git a/src/value/clone.ts b/src/value/clone/clone.ts
similarity index 92%
rename from src/value/clone.ts
rename to src/value/clone/clone.ts
index a2e2d1f30..4c337929b 100644
--- a/src/value/clone.ts
+++ b/src/value/clone/clone.ts
@@ -26,12 +26,15 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsArray, IsDate, IsPlainObject, IsTypedArray, IsValueType } from './guard'
-import type { ObjectType, ArrayType, TypedArrayType, ValueType } from './guard'
+import type { ObjectType, ArrayType, TypedArrayType, ValueType } from '../guard/index'
 
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsArray, IsDate, IsPlainObject, IsTypedArray, IsValueType } from '../guard/index'
+// ------------------------------------------------------------------
 // Clonable
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function ObjectType(value: ObjectType): any {
   const keys = [...Object.getOwnPropertyNames(value), ...Object.getOwnPropertySymbols(value)]
   return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {})
@@ -48,9 +51,9 @@ function DateType(value: Date): any {
 function ValueType(value: ValueType): any {
   return value
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Clone
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 /** Returns a clone of the given value */
 export function Clone<T extends unknown>(value: T): T {
   if (IsArray(value)) return ArrayType(value)
diff --git a/src/value/clone/index.ts b/src/value/clone/index.ts
new file mode 100644
index 000000000..4294f9957
--- /dev/null
+++ b/src/value/clone/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './clone'
diff --git a/src/value/convert.ts b/src/value/convert/convert.ts
similarity index 53%
rename from src/value/convert.ts
rename to src/value/convert/convert.ts
index 60ba2e1f3..8a0de37b2 100644
--- a/src/value/convert.ts
+++ b/src/value/convert/convert.ts
@@ -26,23 +26,41 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsArray, IsObject, IsDate, IsUndefined, IsString, IsNumber, IsBoolean, IsBigInt, IsSymbol } from './guard'
-import { Clone } from './clone'
-import { Check } from './check'
-import { Deref } from './deref'
-import * as Types from '../typebox'
+import { Clone } from '../clone/index'
+import { Check } from '../check/index'
+import { Deref } from '../deref/index'
 
-// --------------------------------------------------------------------------
-// Errors
-// --------------------------------------------------------------------------
-export class ValueConvertUnknownTypeError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema) {
-    super('Unknown type')
-  }
-}
-// --------------------------------------------------------------------------
+import { IsObject as IsObjectType } from '../../type/guard/type'
+import { Kind } from '../../type/symbols/index'
+import { Composite } from '../../type/composite/index'
+
+import type { TSchema } from '../../type/schema/index'
+import type { TArray } from '../../type/array/index'
+import type { TBigInt } from '../../type/bigint/index'
+import type { TBoolean } from '../../type/boolean/index'
+import type { TDate } from '../../type/date/index'
+import type { TInteger } from '../../type/integer/index'
+import type { TIntersect } from '../../type/intersect/index'
+import type { TLiteral } from '../../type/literal/index'
+import type { TNull } from '../../type/null/index'
+import type { TNumber } from '../../type/number/index'
+import type { TObject } from '../../type/object/index'
+import type { TRecord } from '../../type/record/index'
+import type { TRef } from '../../type/ref/index'
+import type { TThis } from '../../type/recursive/index'
+import type { TTuple } from '../../type/tuple/index'
+import type { TUnion } from '../../type/union/index'
+import type { TString } from '../../type/string/index'
+import type { TSymbol } from '../../type/symbol/index'
+import type { TUndefined } from '../../type/undefined/index'
+
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsArray, IsObject, IsDate, IsUndefined, IsString, IsNumber, IsBoolean, IsBigInt, IsSymbol } from '../guard/index'
+// ------------------------------------------------------------------
 // Conversions
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function IsStringNumeric(value: unknown): value is string {
   return IsString(value) && !isNaN(value as any) && !isNaN(parseFloat(value))
 }
@@ -70,9 +88,9 @@ function IsDateTimeStringWithoutTimeZone(value: unknown): value is string {
 function IsDateString(value: unknown): value is string {
   return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value)
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Convert
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function TryConvertLiteralString(value: unknown, target: string) {
   const conversion = TryConvertString(value)
   return conversion === target ? conversion : value
@@ -85,16 +103,14 @@ function TryConvertLiteralBoolean(value: unknown, target: boolean) {
   const conversion = TryConvertBoolean(value)
   return conversion === target ? conversion : value
 }
-function TryConvertLiteral(schema: Types.TLiteral, value: unknown) {
-  if (typeof schema.const === 'string') {
-    return TryConvertLiteralString(value, schema.const)
-  } else if (typeof schema.const === 'number') {
-    return TryConvertLiteralNumber(value, schema.const)
-  } else if (typeof schema.const === 'boolean') {
-    return TryConvertLiteralBoolean(value, schema.const)
-  } else {
-    return Clone(value)
-  }
+// prettier-ignore
+function TryConvertLiteral(schema: TLiteral, value: unknown) {
+  return (
+    IsString(schema.const) ? TryConvertLiteralString(value, schema.const) :
+    IsNumber(schema.const) ? TryConvertLiteralNumber(value, schema.const) :
+    IsBoolean(schema.const) ? TryConvertLiteralBoolean(value, schema.const) :
+    Clone(value)
+  )
 }
 function TryConvertBoolean(value: unknown) {
   return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value
@@ -117,85 +133,82 @@ function TryConvertNull(value: unknown) {
 function TryConvertUndefined(value: unknown) {
   return IsString(value) && value === 'undefined' ? undefined : value
 }
+// ------------------------------------------------------------------
+// note: this function may return an invalid dates for the regex
+// tests above. Invalid dates will however be checked during the
+// casting function and will return a epoch date if invalid.
+// Consider better string parsing for the iso dates in future
+// revisions.
+// ------------------------------------------------------------------
+// prettier-ignore
 function TryConvertDate(value: unknown) {
-  // --------------------------------------------------------------------------
-  // note: this function may return an invalid dates for the regex tests
-  // above. Invalid dates will however be checked during the casting function
-  // and will return a epoch date if invalid. Consider better string parsing
-  // for the iso dates in future revisions.
-  // --------------------------------------------------------------------------
-  return IsDate(value)
-    ? value
-    : IsNumber(value)
-    ? new Date(value)
-    : IsValueTrue(value)
-    ? new Date(1)
-    : IsValueFalse(value)
-    ? new Date(0)
-    : IsStringNumeric(value)
-    ? new Date(parseInt(value))
-    : IsTimeStringWithoutTimeZone(value)
-    ? new Date(`1970-01-01T${value}.000Z`)
-    : IsTimeStringWithTimeZone(value)
-    ? new Date(`1970-01-01T${value}`)
-    : IsDateTimeStringWithoutTimeZone(value)
-    ? new Date(`${value}.000Z`)
-    : IsDateTimeStringWithTimeZone(value)
-    ? new Date(value)
-    : IsDateString(value)
-    ? new Date(`${value}T00:00:00.000Z`)
-    : value
-}
-// --------------------------------------------------------------------------
+  return (
+    IsDate(value) ? value : 
+    IsNumber(value) ? new Date(value) : 
+    IsValueTrue(value) ? new Date(1) : 
+    IsValueFalse(value) ? new Date(0) : 
+    IsStringNumeric(value) ? new Date(parseInt(value)) : 
+    IsTimeStringWithoutTimeZone(value) ? new Date(`1970-01-01T${value}.000Z`) : 
+    IsTimeStringWithTimeZone(value) ? new Date(`1970-01-01T${value}`) : 
+    IsDateTimeStringWithoutTimeZone(value) ? new Date(`${value}.000Z`) : 
+    IsDateTimeStringWithTimeZone(value) ? new Date(value) : 
+    IsDateString(value) ? new Date(`${value}T00:00:00.000Z`) : 
+    value
+  )
+}
+// ------------------------------------------------------------------
 // Default
-// --------------------------------------------------------------------------
-export function Default(value: any) {
+// ------------------------------------------------------------------
+function Default(value: any) {
   return value
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Convert
-// --------------------------------------------------------------------------
-function TArray(schema: Types.TArray, references: Types.TSchema[], value: any): any {
+// ------------------------------------------------------------------
+function FromArray(schema: TArray, references: TSchema[], value: any): any {
   if (IsArray(value)) {
     return value.map((value) => Visit(schema.items, references, value))
   }
   return value
 }
-function TBigInt(schema: Types.TBigInt, references: Types.TSchema[], value: any): unknown {
+function FromBigInt(schema: TBigInt, references: TSchema[], value: any): unknown {
   return TryConvertBigInt(value)
 }
-function TBoolean(schema: Types.TBoolean, references: Types.TSchema[], value: any): unknown {
+function FromBoolean(schema: TBoolean, references: TSchema[], value: any): unknown {
   return TryConvertBoolean(value)
 }
-function TDate(schema: Types.TDate, references: Types.TSchema[], value: any): unknown {
+function FromDate(schema: TDate, references: TSchema[], value: any): unknown {
   return TryConvertDate(value)
 }
-function TInteger(schema: Types.TInteger, references: Types.TSchema[], value: any): unknown {
+function FromInteger(schema: TInteger, references: TSchema[], value: any): unknown {
   return TryConvertInteger(value)
 }
-function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any): unknown {
-  // prettier-ignore
-  return (schema.allOf.every(schema => Types.TypeGuard.TObject(schema)))
-    ? Visit(Types.Type.Composite(schema.allOf as Types.TObject[]), references, value)
-    : Visit(schema.allOf[0], references, value)
+// prettier-ignore
+function FromIntersect(schema: TIntersect, references: TSchema[], value: any): unknown {
+  const allObjects = schema.allOf.every(schema => IsObjectType(schema))
+  if(allObjects) return Visit(Composite(schema.allOf as TObject[]), references, value)
+  return Visit(schema.allOf[0], references, value) // todo: fix this
 }
-function TLiteral(schema: Types.TLiteral, references: Types.TSchema[], value: any): unknown {
+function FromLiteral(schema: TLiteral, references: TSchema[], value: any): unknown {
   return TryConvertLiteral(schema, value)
 }
-function TNull(schema: Types.TNull, references: Types.TSchema[], value: any): unknown {
+function FromNull(schema: TNull, references: TSchema[], value: any): unknown {
   return TryConvertNull(value)
 }
-function TNumber(schema: Types.TNumber, references: Types.TSchema[], value: any): unknown {
+function FromNumber(schema: TNumber, references: TSchema[], value: any): unknown {
   return TryConvertNumber(value)
 }
-function TObject(schema: Types.TObject, references: Types.TSchema[], value: any): unknown {
-  if (IsObject(value))
-    return Object.getOwnPropertyNames(schema.properties).reduce((acc, key) => {
-      return value[key] !== undefined ? { ...acc, [key]: Visit(schema.properties[key], references, value[key]) } : { ...acc }
-    }, value)
-  return value
-}
-function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any): unknown {
+// prettier-ignore
+function FromObject(schema: TObject, references: TSchema[], value: any): unknown {
+  const isConvertable = IsObject(value)
+  if(!isConvertable) return value
+  return Object.getOwnPropertyNames(schema.properties).reduce((value, key) => {
+    return !IsUndefined(value[key])
+      ? ({ ...value, [key]: Visit(schema.properties[key], references, value[key]) })
+      : ({ ...value })
+  }, value) 
+}
+function FromRecord(schema: TRecord, references: TSchema[], value: any): unknown {
   const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0]
   const property = schema.patternProperties[propertyKey]
   const result = {} as Record<string, unknown>
@@ -204,30 +217,32 @@ function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], v
   }
   return result
 }
-function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any): unknown {
+function FromRef(schema: TRef, references: TSchema[], value: any): unknown {
   return Visit(Deref(schema, references), references, value)
 }
-function TString(schema: Types.TString, references: Types.TSchema[], value: any): unknown {
+function FromString(schema: TString, references: TSchema[], value: any): unknown {
   return TryConvertString(value)
 }
-function TSymbol(schema: Types.TSymbol, references: Types.TSchema[], value: any): unknown {
+function FromSymbol(schema: TSymbol, references: TSchema[], value: any): unknown {
   return IsString(value) || IsNumber(value) ? Symbol(value) : value
 }
-function TThis(schema: Types.TThis, references: Types.TSchema[], value: any): unknown {
+function FromThis(schema: TThis, references: TSchema[], value: any): unknown {
   return Visit(Deref(schema, references), references, value)
 }
-function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[], value: any): unknown {
-  if (IsArray(value) && !IsUndefined(schema.items)) {
-    return value.map((value, index) => {
-      return index < schema.items!.length ? Visit(schema.items![index], references, value) : value
-    })
-  }
-  return value
-}
-function TUndefined(schema: Types.TUndefined, references: Types.TSchema[], value: any): unknown {
+// prettier-ignore
+function FromTuple(schema: TTuple, references: TSchema[], value: any): unknown {
+  const isConvertable = IsArray(value) && !IsUndefined(schema.items)
+  if(!isConvertable) return value
+  return value.map((value, index) => {
+    return (index < schema.items!.length)
+      ? Visit(schema.items![index], references, value) 
+      : value
+  }) 
+}
+function FromUndefined(schema: TUndefined, references: TSchema[], value: any): unknown {
   return TryConvertUndefined(value)
 }
-function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any): unknown {
+function FromUnion(schema: TUnion, references: TSchema[], value: any): unknown {
   for (const subschema of schema.anyOf) {
     const converted = Visit(subschema, references, value)
     if (Check(subschema, references, converted)) {
@@ -236,77 +251,61 @@ function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any):
   }
   return value
 }
-function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown {
+function Visit(schema: TSchema, references: TSchema[], value: any): unknown {
   const references_ = IsString(schema.$id) ? [...references, schema] : references
   const schema_ = schema as any
-  switch (schema[Types.Kind]) {
-    // ------------------------------------------------------
-    // Structural
-    // ------------------------------------------------------
+  switch (schema[Kind]) {
     case 'Array':
-      return TArray(schema_, references_, value)
+      return FromArray(schema_, references_, value)
     case 'BigInt':
-      return TBigInt(schema_, references_, value)
+      return FromBigInt(schema_, references_, value)
     case 'Boolean':
-      return TBoolean(schema_, references_, value)
+      return FromBoolean(schema_, references_, value)
     case 'Date':
-      return TDate(schema_, references_, value)
+      return FromDate(schema_, references_, value)
     case 'Integer':
-      return TInteger(schema_, references_, value)
+      return FromInteger(schema_, references_, value)
     case 'Intersect':
-      return TIntersect(schema_, references_, value)
+      return FromIntersect(schema_, references_, value)
     case 'Literal':
-      return TLiteral(schema_, references_, value)
+      return FromLiteral(schema_, references_, value)
     case 'Null':
-      return TNull(schema_, references_, value)
+      return FromNull(schema_, references_, value)
     case 'Number':
-      return TNumber(schema_, references_, value)
+      return FromNumber(schema_, references_, value)
     case 'Object':
-      return TObject(schema_, references_, value)
+      return FromObject(schema_, references_, value)
     case 'Record':
-      return TRecord(schema_, references_, value)
+      return FromRecord(schema_, references_, value)
     case 'Ref':
-      return TRef(schema_, references_, value)
+      return FromRef(schema_, references_, value)
     case 'String':
-      return TString(schema_, references_, value)
+      return FromString(schema_, references_, value)
     case 'Symbol':
-      return TSymbol(schema_, references_, value)
+      return FromSymbol(schema_, references_, value)
     case 'This':
-      return TThis(schema_, references_, value)
+      return FromThis(schema_, references_, value)
     case 'Tuple':
-      return TTuple(schema_, references_, value)
+      return FromTuple(schema_, references_, value)
     case 'Undefined':
-      return TUndefined(schema_, references_, value)
+      return FromUndefined(schema_, references_, value)
     case 'Union':
-      return TUnion(schema_, references_, value)
-    // ------------------------------------------------------
-    // Default
-    // ------------------------------------------------------
-    case 'Any':
-    case 'AsyncIterator':
-    case 'Constructor':
-    case 'Function':
-    case 'Iterator':
-    case 'Never':
-    case 'Promise':
-    case 'TemplateLiteral':
-    case 'Uint8Array':
-    case 'Unknown':
-    case 'Void':
-      return Default(value)
+      return FromUnion(schema_, references_, value)
     default:
-      if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueConvertUnknownTypeError(schema_)
       return Default(value)
   }
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Convert
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
-export function Convert<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): unknown
+export function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
-export function Convert<T extends Types.TSchema>(schema: T, value: unknown): unknown
+export function Convert<T extends TSchema>(schema: T, value: unknown): unknown
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+// prettier-ignore
 export function Convert(...args: any[]) {
-  return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1])
+  return args.length === 3 
+    ? Visit(args[0], args[1], args[2]) 
+    : Visit(args[0], [], args[1])
 }
diff --git a/src/value/convert/index.ts b/src/value/convert/index.ts
new file mode 100644
index 000000000..0e642e6ac
--- /dev/null
+++ b/src/value/convert/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './convert'
diff --git a/src/value/create.ts b/src/value/create/create.ts
similarity index 52%
rename from src/value/create.ts
rename to src/value/create/create.ts
index b36b42f41..b632947bd 100644
--- a/src/value/create.ts
+++ b/src/value/create/create.ts
@@ -26,59 +26,72 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { HasPropertyKey, IsString } from './guard'
-import { Check } from './check'
-import { Deref } from './deref'
-import * as Types from '../typebox'
+import { HasPropertyKey, IsString } from '../guard/index'
+import { Check } from '../check/index'
+import { Deref } from '../deref/index'
+import { TemplateLiteralGenerate, IsTemplateLiteralFinite } from '../../type/template-literal/index'
+import { PatternStringExact, PatternNumberExact } from '../../type/patterns/index'
+import { TypeRegistry } from '../../type/registry/index'
+import { Kind } from '../../type/symbols/index'
+import { TypeBoxError } from '../../type/error/index'
 
-// --------------------------------------------------------------------------
+import type { TSchema } from '../../type/schema/index'
+import type { TAsyncIterator } from '../../type/async-iterator/index'
+import type { TAny } from '../../type/any/index'
+import type { TArray } from '../../type/array/index'
+import type { TBigInt } from '../../type/bigint/index'
+import type { TBoolean } from '../../type/boolean/index'
+import type { TDate } from '../../type/date/index'
+import type { TConstructor } from '../../type/constructor/index'
+import type { TFunction } from '../../type/function/index'
+import type { TInteger } from '../../type/integer/index'
+import type { TIntersect } from '../../type/intersect/index'
+import type { TIterator } from '../../type/iterator/index'
+import type { TLiteral } from '../../type/literal/index'
+import type { TNever } from '../../type/never/index'
+import type { TNot } from '../../type/not/index'
+import type { TNull } from '../../type/null/index'
+import type { TNumber } from '../../type/number/index'
+import type { TObject } from '../../type/object/index'
+import type { TPromise } from '../../type/promise/index'
+import type { TRecord } from '../../type/record/index'
+import type { TRef } from '../../type/ref/index'
+import type { TRegExp } from '../../type/regexp/index'
+import type { TTemplateLiteral } from '../../type/template-literal/index'
+import type { TThis } from '../../type/recursive/index'
+import type { TTuple } from '../../type/tuple/index'
+import type { TUnion } from '../../type/union/index'
+import type { TUnknown } from '../../type/unknown/index'
+import type { Static } from '../../type/static/index'
+import type { TString } from '../../type/string/index'
+import type { TSymbol } from '../../type/symbol/index'
+import type { TUndefined } from '../../type/undefined/index'
+import type { TUint8Array } from '../../type/uint8array/index'
+import type { TVoid } from '../../type/void/index'
+
+// ------------------------------------------------------------------
 // Errors
-// --------------------------------------------------------------------------
-export class ValueCreateUnknownTypeError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema) {
-    super('Unknown type')
-  }
-}
-export class ValueCreateNeverTypeError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema) {
-    super('Never types cannot be created')
-  }
-}
-export class ValueCreateNotTypeError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema) {
-    super('Not types must have a default value')
-  }
-}
-export class ValueCreateIntersectTypeError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema) {
-    super('Intersect produced invalid value. Consider using a default value.')
-  }
-}
-export class ValueCreateTempateLiteralTypeError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema) {
-    super('Can only create template literal values from patterns that produce finite sequences. Consider using a default value.')
-  }
-}
-export class ValueCreateRecursiveInstantiationError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema, public readonly recursiveMaxDepth: number) {
-    super('Value cannot be created as recursive type may produce value of infinite size. Consider using a default.')
+// ------------------------------------------------------------------
+export class ValueCreateError extends TypeBoxError {
+  constructor(public readonly schema: TSchema, message: string) {
+    super(message)
   }
 }
-// --------------------------------------------------------------------------
-// Types
-// --------------------------------------------------------------------------
-function TAny(schema: Types.TAny, references: Types.TSchema[]): any {
+// ------------------------------------------------------------------
+// Create
+// ------------------------------------------------------------------
+function FromAny(schema: TAny, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return {}
   }
 }
-function TArray(schema: Types.TArray, references: Types.TSchema[]): any {
+function FromArray(schema: TArray, references: TSchema[]): any {
   if (schema.uniqueItems === true && !HasPropertyKey(schema, 'default')) {
-    throw new Error('ValueCreate.Array: Array with the uniqueItems constraint requires a default value')
+    throw new ValueCreateError(schema, 'Array with the uniqueItems constraint requires a default value')
   } else if ('contains' in schema && !HasPropertyKey(schema, 'default')) {
-    throw new Error('ValueCreate.Array: Array with the contains constraint requires a default value')
+    throw new ValueCreateError(schema, 'Array with the contains constraint requires a default value')
   } else if ('default' in schema) {
     return schema.default
   } else if (schema.minItems !== undefined) {
@@ -89,28 +102,28 @@ function TArray(schema: Types.TArray, references: Types.TSchema[]): any {
     return []
   }
 }
-function TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[]) {
+function FromAsyncIterator(schema: TAsyncIterator, references: TSchema[]) {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return (async function* () {})()
   }
 }
-function TBigInt(schema: Types.TBigInt, references: Types.TSchema[]): any {
+function FromBigInt(schema: TBigInt, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return BigInt(0)
   }
 }
-function TBoolean(schema: Types.TBoolean, references: Types.TSchema[]): any {
+function FromBoolean(schema: TBoolean, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return false
   }
 }
-function TConstructor(schema: Types.TConstructor, references: Types.TSchema[]): any {
+function FromConstructor(schema: TConstructor, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
@@ -129,7 +142,7 @@ function TConstructor(schema: Types.TConstructor, references: Types.TSchema[]):
     }
   }
 }
-function TDate(schema: Types.TDate, references: Types.TSchema[]): any {
+function FromDate(schema: TDate, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else if (schema.minimumTimestamp !== undefined) {
@@ -138,14 +151,14 @@ function TDate(schema: Types.TDate, references: Types.TSchema[]): any {
     return new Date()
   }
 }
-function TFunction(schema: Types.TFunction, references: Types.TSchema[]): any {
+function FromFunction(schema: TFunction, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return () => Visit(schema.returns, references)
   }
 }
-function TInteger(schema: Types.TInteger, references: Types.TSchema[]): any {
+function FromInteger(schema: TInteger, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else if (schema.minimum !== undefined) {
@@ -154,53 +167,61 @@ function TInteger(schema: Types.TInteger, references: Types.TSchema[]): any {
     return 0
   }
 }
-function TIntersect(schema: Types.TIntersect, references: Types.TSchema[]): any {
+function FromIntersect(schema: TIntersect, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
-    // Note: The best we can do here is attempt to instance each sub type and apply through object assign. For non-object
-    // sub types, we just escape the assignment and just return the value. In the latter case, this is typically going to
+    // --------------------------------------------------------------
+    // Note: The best we can do here is attempt to instance each
+    // sub type and apply through object assign. For non-object
+    // sub types, we just escape the assignment and just return
+    // the value. In the latter case, this is typically going to
     // be a consequence of an illogical intersection.
+    // --------------------------------------------------------------
     const value = schema.allOf.reduce((acc, schema) => {
       const next = Visit(schema, references) as any
       return typeof next === 'object' ? { ...acc, ...next } : next
     }, {})
-    if (!Check(schema, references, value)) throw new ValueCreateIntersectTypeError(schema)
+    if (!Check(schema, references, value)) throw new ValueCreateError(schema, 'Intersect produced invalid value. Consider using a default value.')
     return value
   }
 }
-function TIterator(schema: Types.TIterator, references: Types.TSchema[]) {
+function FromIterator(schema: TIterator, references: TSchema[]) {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return (function* () {})()
   }
 }
-function TLiteral(schema: Types.TLiteral, references: Types.TSchema[]): any {
+function FromLiteral(schema: TLiteral, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return schema.const
   }
 }
-function TNever(schema: Types.TNever, references: Types.TSchema[]): any {
-  throw new ValueCreateNeverTypeError(schema)
+function FromNever(schema: TNever, references: TSchema[]): any {
+  if (HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    throw new ValueCreateError(schema, 'Never types cannot be created. Consider using a default value.')
+  }
 }
-function TNot(schema: Types.TNot, references: Types.TSchema[]): any {
+function FromNot(schema: TNot, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
-    throw new ValueCreateNotTypeError(schema)
+    throw new ValueCreateError(schema, 'Not types must have a default value')
   }
 }
-function TNull(schema: Types.TNull, references: Types.TSchema[]): any {
+function FromNull(schema: TNull, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return null
   }
 }
-function TNumber(schema: Types.TNumber, references: Types.TSchema[]): any {
+function FromNumber(schema: TNumber, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else if (schema.minimum !== undefined) {
@@ -209,7 +230,7 @@ function TNumber(schema: Types.TNumber, references: Types.TSchema[]): any {
     return 0
   }
 }
-function TObject(schema: Types.TObject, references: Types.TSchema[]): any {
+function FromObject(schema: TObject, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
@@ -222,18 +243,18 @@ function TObject(schema: Types.TObject, references: Types.TSchema[]): any {
     )
   }
 }
-function TPromise(schema: Types.TPromise<any>, references: Types.TSchema[]): any {
+function FromPromise(schema: TPromise, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return Promise.resolve(Visit(schema.item, references))
   }
 }
-function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[]): any {
+function FromRecord(schema: TRecord, references: TSchema[]): any {
   const [keyPattern, valueSchema] = Object.entries(schema.patternProperties)[0]
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
-  } else if (!(keyPattern === Types.PatternStringExact || keyPattern === Types.PatternNumberExact)) {
+  } else if (!(keyPattern === PatternStringExact || keyPattern === PatternNumberExact)) {
     const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|')
     return propertyKeys.reduce((acc, key) => {
       return { ...acc, [key]: Visit(valueSchema, references) }
@@ -242,23 +263,30 @@ function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[]):
     return {}
   }
 }
-function TRef(schema: Types.TRef<any>, references: Types.TSchema[]): any {
+function FromRef(schema: TRef, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return Visit(Deref(schema, references), references)
   }
 }
-function TString(schema: Types.TString, references: Types.TSchema[]): any {
+function FromRegExp(schema: TRegExp, references: TSchema[]): any {
+  if (HasPropertyKey(schema, 'default')) {
+    return schema.default
+  } else {
+    throw new ValueCreateError(schema, 'RegExp types cannot be created. Consider using a default value.')
+  }
+}
+function FromString(schema: TString, references: TSchema[]): any {
   if (schema.pattern !== undefined) {
     if (!HasPropertyKey(schema, 'default')) {
-      throw new Error('ValueCreate.String: String types with patterns must specify a default value')
+      throw new ValueCreateError(schema, 'String types with patterns must specify a default value')
     } else {
       return schema.default
     }
   } else if (schema.format !== undefined) {
     if (!HasPropertyKey(schema, 'default')) {
-      throw new Error('ValueCreate.String: String types with formats must specify a default value')
+      throw new ValueCreateError(schema, 'String types with formats must specify a default value')
     } else {
       return schema.default
     }
@@ -266,15 +294,14 @@ function TString(schema: Types.TString, references: Types.TSchema[]): any {
     if (HasPropertyKey(schema, 'default')) {
       return schema.default
     } else if (schema.minLength !== undefined) {
-      return Array.from({ length: schema.minLength })
-        .map(() => '.')
-        .join('')
+      // prettier-ignore
+      return Array.from({ length: schema.minLength }).map(() => ' ').join('')
     } else {
       return ''
     }
   }
 }
-function TSymbol(schema: Types.TString, references: Types.TSchema[]): any {
+function FromSymbol(schema: TSymbol, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else if ('value' in schema) {
@@ -283,24 +310,23 @@ function TSymbol(schema: Types.TString, references: Types.TSchema[]): any {
     return Symbol()
   }
 }
-function TTemplateLiteral(schema: Types.TTemplateLiteral, references: Types.TSchema[]) {
+function FromTemplateLiteral(schema: TTemplateLiteral, references: TSchema[]) {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   }
-  const expression = Types.TemplateLiteralParser.ParseExact(schema.pattern)
-  if (!Types.TemplateLiteralFinite.Check(expression)) throw new ValueCreateTempateLiteralTypeError(schema)
-  const sequence = Types.TemplateLiteralGenerator.Generate(expression)
-  return sequence.next().value
+  if (!IsTemplateLiteralFinite(schema)) throw new ValueCreateError(schema, 'Can only create template literals that produce a finite variants. Consider using a default value.')
+  const generated = TemplateLiteralGenerate(schema) as string[]
+  return generated[0]
 }
-function TThis(schema: Types.TThis, references: Types.TSchema[]): any {
-  if (recursiveDepth++ > recursiveMaxDepth) throw new ValueCreateRecursiveInstantiationError(schema, recursiveMaxDepth)
+function FromThis(schema: TThis, references: TSchema[]): any {
+  if (recursiveDepth++ > recursiveMaxDepth) throw new ValueCreateError(schema, 'Cannot create recursive type as it appears possibly infinite. Consider using a default.')
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return Visit(Deref(schema, references), references)
   }
 }
-function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[]): any {
+function FromTuple(schema: TTuple, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   }
@@ -310,14 +336,14 @@ function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[]): any {
     return Array.from({ length: schema.minItems }).map((_, index) => Visit((schema.items as any[])[index], references))
   }
 }
-function TUndefined(schema: Types.TUndefined, references: Types.TSchema[]): any {
+function FromUndefined(schema: TUndefined, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return undefined
   }
 }
-function TUnion(schema: Types.TUnion<any[]>, references: Types.TSchema[]): any {
+function FromUnion(schema: TUnion, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else if (schema.anyOf.length === 0) {
@@ -326,7 +352,7 @@ function TUnion(schema: Types.TUnion<any[]>, references: Types.TSchema[]): any {
     return Visit(schema.anyOf[0], references)
   }
 }
-function TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[]): any {
+function FromUint8Array(schema: TUint8Array, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else if (schema.minByteLength !== undefined) {
@@ -335,108 +361,110 @@ function TUint8Array(schema: Types.TUint8Array, references: Types.TSchema[]): an
     return new Uint8Array(0)
   }
 }
-function TUnknown(schema: Types.TUnknown, references: Types.TSchema[]): any {
+function FromUnknown(schema: TUnknown, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return {}
   }
 }
-function TVoid(schema: Types.TVoid, references: Types.TSchema[]): any {
+function FromVoid(schema: TVoid, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     return void 0
   }
 }
-function TKind(schema: Types.TSchema, references: Types.TSchema[]): any {
+function FromKind(schema: TSchema, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return schema.default
   } else {
     throw new Error('User defined types must specify a default value')
   }
 }
-function Visit(schema: Types.TSchema, references: Types.TSchema[]): unknown {
+function Visit(schema: TSchema, references: TSchema[]): unknown {
   const references_ = IsString(schema.$id) ? [...references, schema] : references
   const schema_ = schema as any
-  switch (schema_[Types.Kind]) {
+  switch (schema_[Kind]) {
     case 'Any':
-      return TAny(schema_, references_)
+      return FromAny(schema_, references_)
     case 'Array':
-      return TArray(schema_, references_)
+      return FromArray(schema_, references_)
     case 'AsyncIterator':
-      return TAsyncIterator(schema_, references_)
+      return FromAsyncIterator(schema_, references_)
     case 'BigInt':
-      return TBigInt(schema_, references_)
+      return FromBigInt(schema_, references_)
     case 'Boolean':
-      return TBoolean(schema_, references_)
+      return FromBoolean(schema_, references_)
     case 'Constructor':
-      return TConstructor(schema_, references_)
+      return FromConstructor(schema_, references_)
     case 'Date':
-      return TDate(schema_, references_)
+      return FromDate(schema_, references_)
     case 'Function':
-      return TFunction(schema_, references_)
+      return FromFunction(schema_, references_)
     case 'Integer':
-      return TInteger(schema_, references_)
+      return FromInteger(schema_, references_)
     case 'Intersect':
-      return TIntersect(schema_, references_)
+      return FromIntersect(schema_, references_)
     case 'Iterator':
-      return TIterator(schema_, references_)
+      return FromIterator(schema_, references_)
     case 'Literal':
-      return TLiteral(schema_, references_)
+      return FromLiteral(schema_, references_)
     case 'Never':
-      return TNever(schema_, references_)
+      return FromNever(schema_, references_)
     case 'Not':
-      return TNot(schema_, references_)
+      return FromNot(schema_, references_)
     case 'Null':
-      return TNull(schema_, references_)
+      return FromNull(schema_, references_)
     case 'Number':
-      return TNumber(schema_, references_)
+      return FromNumber(schema_, references_)
     case 'Object':
-      return TObject(schema_, references_)
+      return FromObject(schema_, references_)
     case 'Promise':
-      return TPromise(schema_, references_)
+      return FromPromise(schema_, references_)
     case 'Record':
-      return TRecord(schema_, references_)
+      return FromRecord(schema_, references_)
     case 'Ref':
-      return TRef(schema_, references_)
+      return FromRef(schema_, references_)
+    case 'RegExp':
+      return FromRegExp(schema_, references_)
     case 'String':
-      return TString(schema_, references_)
+      return FromString(schema_, references_)
     case 'Symbol':
-      return TSymbol(schema_, references_)
+      return FromSymbol(schema_, references_)
     case 'TemplateLiteral':
-      return TTemplateLiteral(schema_, references_)
+      return FromTemplateLiteral(schema_, references_)
     case 'This':
-      return TThis(schema_, references_)
+      return FromThis(schema_, references_)
     case 'Tuple':
-      return TTuple(schema_, references_)
+      return FromTuple(schema_, references_)
     case 'Undefined':
-      return TUndefined(schema_, references_)
+      return FromUndefined(schema_, references_)
     case 'Union':
-      return TUnion(schema_, references_)
+      return FromUnion(schema_, references_)
     case 'Uint8Array':
-      return TUint8Array(schema_, references_)
+      return FromUint8Array(schema_, references_)
     case 'Unknown':
-      return TUnknown(schema_, references_)
+      return FromUnknown(schema_, references_)
     case 'Void':
-      return TVoid(schema_, references_)
+      return FromVoid(schema_, references_)
     default:
-      if (!Types.TypeRegistry.Has(schema_[Types.Kind])) throw new ValueCreateUnknownTypeError(schema_)
-      return TKind(schema_, references_)
+      if (!TypeRegistry.Has(schema_[Kind])) throw new ValueCreateError(schema_, 'Unknown type')
+      return FromKind(schema_, references_)
   }
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // State
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 const recursiveMaxDepth = 512
 let recursiveDepth = 0
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Create
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 /** Creates a value from the given schema and references */
-export function Create<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T>
+export function Create<T extends TSchema>(schema: T, references: TSchema[]): Static<T>
 /** Creates a value from the given schema */
-export function Create<T extends Types.TSchema>(schema: T): Types.Static<T>
+export function Create<T extends TSchema>(schema: T): Static<T>
 /** Creates a value from the given schema */
 export function Create(...args: any[]) {
   recursiveDepth = 0
diff --git a/src/value/create/index.ts b/src/value/create/index.ts
new file mode 100644
index 000000000..62543e72b
--- /dev/null
+++ b/src/value/create/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './create'
diff --git a/src/value/default/default.ts b/src/value/default/default.ts
new file mode 100644
index 000000000..6a310d259
--- /dev/null
+++ b/src/value/default/default.ts
@@ -0,0 +1,185 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Check } from '../check/index'
+import { Deref } from '../deref/index'
+import { Kind } from '../../type/symbols/index'
+
+import type { TSchema } from '../../type/schema/index'
+import type { TArray } from '../../type/array/index'
+import type { TIntersect } from '../../type/intersect/index'
+import type { TObject } from '../../type/object/index'
+import type { TRecord } from '../../type/record/index'
+import type { TRef } from '../../type/ref/index'
+import type { TThis } from '../../type/recursive/index'
+import type { TTuple } from '../../type/tuple/index'
+import type { TUnion } from '../../type/union/index'
+
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsString, IsObject, IsArray, IsUndefined } from '../guard/index'
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsSchema } from '../../type/guard/type'
+// ------------------------------------------------------------------
+// ValueOrDefault
+// ------------------------------------------------------------------
+function ValueOrDefault(schema: TSchema, value: unknown) {
+  return !(value === undefined) || !('default' in schema) ? value : schema.default
+}
+// ------------------------------------------------------------------
+// IsCheckable
+// ------------------------------------------------------------------
+function IsCheckable(schema: unknown): boolean {
+  return IsSchema(schema) && schema[Kind] !== 'Unsafe'
+}
+// ------------------------------------------------------------------
+// IsDefaultSchema
+// ------------------------------------------------------------------
+function IsDefaultSchema(value: unknown): value is TSchema {
+  return IsSchema(value) && 'default' in value
+}
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+function FromArray(schema: TArray, references: TSchema[], value: unknown): any {
+  const defaulted = ValueOrDefault(schema, value)
+  if (!IsArray(defaulted)) return defaulted
+  for (let i = 0; i < defaulted.length; i++) {
+    defaulted[i] = Visit(schema.items, references, defaulted[i])
+  }
+  return defaulted
+}
+function FromIntersect(schema: TIntersect, references: TSchema[], value: unknown): any {
+  const defaulted = ValueOrDefault(schema, value)
+  return schema.allOf.reduce((acc, schema) => {
+    const next = Visit(schema, references, defaulted)
+    return IsObject(next) ? { ...acc, ...next } : next
+  }, {})
+}
+function FromObject(schema: TObject, references: TSchema[], value: unknown): any {
+  const defaulted = ValueOrDefault(schema, value)
+  if (!IsObject(defaulted)) return defaulted
+  const additionalPropertiesSchema = schema.additionalProperties as TSchema
+  const knownPropertyKeys = Object.getOwnPropertyNames(schema.properties)
+  // properties
+  for (const key of knownPropertyKeys) {
+    if (!IsDefaultSchema(schema.properties[key])) continue
+    defaulted[key] = Visit(schema.properties[key], references, defaulted[key])
+  }
+  // return if not additional properties
+  if (!IsDefaultSchema(additionalPropertiesSchema)) return defaulted
+  // additional properties
+  for (const key of Object.getOwnPropertyNames(defaulted)) {
+    if (knownPropertyKeys.includes(key)) continue
+    defaulted[key] = Visit(additionalPropertiesSchema, references, defaulted[key])
+  }
+  return defaulted
+}
+function FromRecord(schema: TRecord, references: TSchema[], value: unknown): any {
+  const defaulted = ValueOrDefault(schema, value)
+  if (!IsObject(defaulted)) return defaulted
+  const additionalPropertiesSchema = schema.additionalProperties as TSchema
+  const [propertyKeyPattern, propertySchema] = Object.entries(schema.patternProperties)[0]
+  const knownPropertyKey = new RegExp(propertyKeyPattern)
+  // properties
+  for (const key of Object.getOwnPropertyNames(defaulted)) {
+    if (!(knownPropertyKey.test(key) && IsDefaultSchema(propertySchema))) continue
+    defaulted[key] = Visit(propertySchema, references, defaulted[key])
+  }
+  // return if not additional properties
+  if (!IsDefaultSchema(additionalPropertiesSchema)) return defaulted
+  // additional properties
+  for (const key of Object.getOwnPropertyNames(defaulted)) {
+    if (knownPropertyKey.test(key)) continue
+    defaulted[key] = Visit(additionalPropertiesSchema, references, defaulted[key])
+  }
+  return defaulted
+}
+function FromRef(schema: TRef, references: TSchema[], value: unknown): any {
+  return Visit(Deref(schema, references), references, ValueOrDefault(schema, value))
+}
+function FromThis(schema: TThis, references: TSchema[], value: unknown): any {
+  return Visit(Deref(schema, references), references, value)
+}
+function FromTuple(schema: TTuple, references: TSchema[], value: unknown): any {
+  const defaulted = ValueOrDefault(schema, value)
+  if (!IsArray(defaulted) || IsUndefined(schema.items)) return defaulted
+  const [items, max] = [schema.items!, Math.max(schema.items!.length, defaulted.length)]
+  for (let i = 0; i < max; i++) {
+    if (i < items.length) defaulted[i] = Visit(items[i], references, defaulted[i])
+  }
+  return defaulted
+}
+function FromUnion(schema: TUnion, references: TSchema[], value: unknown): any {
+  const defaulted = ValueOrDefault(schema, value)
+  for (const inner of schema.anyOf) {
+    const result = Visit(inner, references, defaulted)
+    if (IsCheckable(inner) && Check(inner, result)) {
+      return result
+    }
+  }
+  return defaulted
+}
+function Visit(schema: TSchema, references: TSchema[], value: unknown): any {
+  const references_ = IsString(schema.$id) ? [...references, schema] : references
+  const schema_ = schema as any
+  switch (schema_[Kind]) {
+    case 'Array':
+      return FromArray(schema_, references_, value)
+    case 'Intersect':
+      return FromIntersect(schema_, references_, value)
+    case 'Object':
+      return FromObject(schema_, references_, value)
+    case 'Record':
+      return FromRecord(schema_, references_, value)
+    case 'Ref':
+      return FromRef(schema_, references_, value)
+    case 'This':
+      return FromThis(schema_, references_, value)
+    case 'Tuple':
+      return FromTuple(schema_, references_, value)
+    case 'Union':
+      return FromUnion(schema_, references_, value)
+    default:
+      return ValueOrDefault(schema_, value)
+  }
+}
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
+export function Default<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
+export function Default<T extends TSchema>(schema: T, value: unknown): unknown
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
+export function Default(...args: any[]) {
+  return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1])
+}
diff --git a/src/value/default/index.ts b/src/value/default/index.ts
new file mode 100644
index 000000000..fb74557fd
--- /dev/null
+++ b/src/value/default/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './default'
diff --git a/src/value/delta.ts b/src/value/delta/delta.ts
similarity index 71%
rename from src/value/delta.ts
rename to src/value/delta/delta.ts
index 5a2092dc0..d7ae9fa89 100644
--- a/src/value/delta.ts
+++ b/src/value/delta/delta.ts
@@ -26,50 +26,57 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsPlainObject, IsArray, IsTypedArray, IsValueType, IsSymbol, IsUndefined } from './guard'
-import type { ObjectType, ArrayType, TypedArrayType, ValueType } from './guard'
-import { Type, Static } from '../typebox'
-import { ValuePointer } from './pointer'
-import { Clone } from './clone'
+import { IsPlainObject, IsArray, IsTypedArray, IsValueType, IsSymbol, IsUndefined } from '../guard/index'
+import type { ObjectType, ArrayType, TypedArrayType, ValueType } from '../guard/index'
+import type { Static } from '../../type/static/index'
+import { ValuePointer } from '../pointer/index'
+import { Clone } from '../clone/index'
+import { TypeBoxError } from '../../type/error/index'
 
-// --------------------------------------------------------------------------
+import { Literal as CreateLiteral } from '../../type/literal/index'
+import { Object as CreateObject } from '../../type/object/index'
+import { String as CreateString } from '../../type/string/index'
+import { Unknown as CreateUnknown } from '../../type/unknown/index'
+import { Union as CreateUnion } from '../../type/union/index'
+
+// ------------------------------------------------------------------
 // Commands
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 export type Insert = Static<typeof Insert>
-export const Insert = Type.Object({
-  type: Type.Literal('insert'),
-  path: Type.String(),
-  value: Type.Unknown(),
+export const Insert = CreateObject({
+  type: CreateLiteral('insert'),
+  path: CreateString(),
+  value: CreateUnknown(),
 })
 export type Update = Static<typeof Update>
-export const Update = Type.Object({
-  type: Type.Literal('update'),
-  path: Type.String(),
-  value: Type.Unknown(),
+export const Update = CreateObject({
+  type: CreateLiteral('update'),
+  path: CreateString(),
+  value: CreateUnknown(),
 })
 export type Delete = Static<typeof Delete>
-export const Delete = Type.Object({
-  type: Type.Literal('delete'),
-  path: Type.String(),
+export const Delete = CreateObject({
+  type: CreateLiteral('delete'),
+  path: CreateString(),
 })
 export type Edit = Static<typeof Edit>
-export const Edit = Type.Union([Insert, Update, Delete])
-// --------------------------------------------------------------------------
+export const Edit = CreateUnion([Insert, Update, Delete])
+// ------------------------------------------------------------------
 // Errors
-// --------------------------------------------------------------------------
-export class ValueDeltaObjectWithSymbolKeyError extends Error {
-  constructor(public readonly key: unknown) {
-    super('Cannot diff objects with symbol keys')
+// ------------------------------------------------------------------
+export class ValueDeltaError extends TypeBoxError {
+  constructor(public readonly value: unknown, message: string) {
+    super(message)
   }
 }
-export class ValueDeltaUnableToDiffUnknownValue extends Error {
+export class ValueDeltaSymbolError extends ValueDeltaError {
   constructor(public readonly value: unknown) {
-    super('Unable to create diff edits for unknown value')
+    super(value, 'Cannot diff objects with symbol keys')
   }
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Command Factory
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function CreateUpdate(path: string, value: unknown): Edit {
   return { type: 'update', path, value }
 }
@@ -79,29 +86,29 @@ function CreateInsert(path: string, value: unknown): Edit {
 function CreateDelete(path: string): Edit {
   return { type: 'delete', path }
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Diffing Generators
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function* ObjectType(path: string, current: ObjectType, next: unknown): IterableIterator<Edit> {
   if (!IsPlainObject(next)) return yield CreateUpdate(path, next)
-  const currentKeys = [...Object.keys(current), ...Object.getOwnPropertySymbols(current)]
-  const nextKeys = [...Object.keys(next), ...Object.getOwnPropertySymbols(next)]
+  const currentKeys = [...globalThis.Object.keys(current), ...globalThis.Object.getOwnPropertySymbols(current)]
+  const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)]
   for (const key of currentKeys) {
-    if (IsSymbol(key)) throw new ValueDeltaObjectWithSymbolKeyError(key)
-    if (IsUndefined(next[key]) && nextKeys.includes(key)) yield CreateUpdate(`${path}/${String(key)}`, undefined)
+    if (IsSymbol(key)) throw new ValueDeltaSymbolError(key)
+    if (IsUndefined(next[key]) && nextKeys.includes(key)) yield CreateUpdate(`${path}/${globalThis.String(key)}`, undefined)
   }
   for (const key of nextKeys) {
     if (IsUndefined(current[key]) || IsUndefined(next[key])) continue
-    if (IsSymbol(key)) throw new ValueDeltaObjectWithSymbolKeyError(key)
-    yield* Visit(`${path}/${String(key)}`, current[key], next[key])
+    if (IsSymbol(key)) throw new ValueDeltaSymbolError(key)
+    yield* Visit(`${path}/${globalThis.String(key)}`, current[key], next[key])
   }
   for (const key of nextKeys) {
-    if (IsSymbol(key)) throw new ValueDeltaObjectWithSymbolKeyError(key)
-    if (IsUndefined(current[key])) yield CreateInsert(`${path}/${String(key)}`, next[key])
+    if (IsSymbol(key)) throw new ValueDeltaSymbolError(key)
+    if (IsUndefined(current[key])) yield CreateInsert(`${path}/${globalThis.String(key)}`, next[key])
   }
   for (const key of currentKeys.reverse()) {
-    if (IsSymbol(key)) throw new ValueDeltaObjectWithSymbolKeyError(key)
-    if (IsUndefined(next[key]) && !nextKeys.includes(key)) yield CreateDelete(`${path}/${String(key)}`)
+    if (IsSymbol(key)) throw new ValueDeltaSymbolError(key)
+    if (IsUndefined(next[key]) && !nextKeys.includes(key)) yield CreateDelete(`${path}/${globalThis.String(key)}`)
   }
 }
 function* ArrayType(path: string, current: ArrayType, next: unknown): IterableIterator<Edit> {
@@ -119,7 +126,7 @@ function* ArrayType(path: string, current: ArrayType, next: unknown): IterableIt
   }
 }
 function* TypedArrayType(path: string, current: TypedArrayType, next: unknown): IterableIterator<Edit> {
-  if (!IsTypedArray(next) || current.length !== next.length || Object.getPrototypeOf(current).constructor.name !== Object.getPrototypeOf(next).constructor.name) return yield CreateUpdate(path, next)
+  if (!IsTypedArray(next) || current.length !== next.length || globalThis.Object.getPrototypeOf(current).constructor.name !== globalThis.Object.getPrototypeOf(next).constructor.name) return yield CreateUpdate(path, next)
   for (let i = 0; i < Math.min(current.length, next.length); i++) {
     yield* Visit(`${path}/${i}`, current[i], next[i])
   }
@@ -133,17 +140,17 @@ function* Visit(path: string, current: unknown, next: unknown): IterableIterator
   if (IsArray(current)) return yield* ArrayType(path, current, next)
   if (IsTypedArray(current)) return yield* TypedArrayType(path, current, next)
   if (IsValueType(current)) return yield* ValueType(path, current, next)
-  throw new ValueDeltaUnableToDiffUnknownValue(current)
+  throw new ValueDeltaError(current, 'Unable to create diff edits for unknown value')
 }
-// ---------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Diff
-// ---------------------------------------------------------------------
+// ------------------------------------------------------------------
 export function Diff(current: unknown, next: unknown): Edit[] {
   return [...Visit('', current, next)]
 }
-// ---------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Patch
-// ---------------------------------------------------------------------
+// ------------------------------------------------------------------
 function IsRootUpdate(edits: Edit[]): edits is [Update] {
   return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update'
 }
diff --git a/src/value/delta/index.ts b/src/value/delta/index.ts
new file mode 100644
index 000000000..3eca3782f
--- /dev/null
+++ b/src/value/delta/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './delta'
diff --git a/src/value/deref.ts b/src/value/deref/deref.ts
similarity index 89%
rename from src/value/deref.ts
rename to src/value/deref/deref.ts
index cf9ebd798..e7c0926af 100644
--- a/src/value/deref.ts
+++ b/src/value/deref/deref.ts
@@ -26,7 +26,10 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { TypeBoxError, TSchema, TRef, TThis } from '../typebox'
+import type { TSchema } from '../../type/schema/index'
+import type { TRef } from '../../type/ref/index'
+import type { TThis } from '../../type/recursive/index'
+import { TypeBoxError } from '../../type/error/index'
 
 export class TypeDereferenceError extends TypeBoxError {
   constructor(public readonly schema: TRef | TThis) {
diff --git a/src/value/deref/index.ts b/src/value/deref/index.ts
new file mode 100644
index 000000000..d0bf7e45b
--- /dev/null
+++ b/src/value/deref/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './deref'
diff --git a/src/value/equal.ts b/src/value/equal/equal.ts
similarity index 97%
rename from src/value/equal.ts
rename to src/value/equal/equal.ts
index 558d96f8b..264093959 100644
--- a/src/value/equal.ts
+++ b/src/value/equal/equal.ts
@@ -26,12 +26,12 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsPlainObject, IsDate, IsArray, IsTypedArray, IsValueType } from './guard'
-import type { ObjectType, ArrayType, TypedArrayType, ValueType } from './guard'
+import { IsPlainObject, IsDate, IsArray, IsTypedArray, IsValueType } from '../guard/index'
+import type { ObjectType, ArrayType, TypedArrayType, ValueType } from '../guard/index'
 
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Equality Checks
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function ObjectType(left: ObjectType, right: unknown): boolean {
   if (!IsPlainObject(right)) return false
   const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)]
@@ -53,9 +53,9 @@ function TypedArrayType(left: TypedArrayType, right: unknown): any {
 function ValueType(left: ValueType, right: unknown): any {
   return left === right
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Equal
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 /** Returns true if the left value deep-equals the right */
 export function Equal<T>(left: T, right: unknown): right is T {
   if (IsPlainObject(left)) return ObjectType(left, right)
diff --git a/src/value/equal/index.ts b/src/value/equal/index.ts
new file mode 100644
index 000000000..cf0e42f72
--- /dev/null
+++ b/src/value/equal/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './equal'
diff --git a/src/value/guard.ts b/src/value/guard/guard.ts
similarity index 99%
rename from src/value/guard.ts
rename to src/value/guard/guard.ts
index 5d5bb17ec..92aa187dd 100644
--- a/src/value/guard.ts
+++ b/src/value/guard/guard.ts
@@ -26,9 +26,9 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Types
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 export type ObjectType = Record<PropertyKey, unknown>
 export type ArrayType = unknown[]
 export type ValueType = null | undefined | symbol | bigint | number | boolean | string
diff --git a/src/value/guard/index.ts b/src/value/guard/index.ts
new file mode 100644
index 000000000..36d7e3fa8
--- /dev/null
+++ b/src/value/guard/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './guard'
diff --git a/src/value/hash.ts b/src/value/hash/hash.ts
similarity index 95%
rename from src/value/hash.ts
rename to src/value/hash/hash.ts
index cd8935ead..6964af0f5 100644
--- a/src/value/hash.ts
+++ b/src/value/hash/hash.ts
@@ -26,20 +26,21 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsPlainObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from './guard'
+import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsPlainObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index'
+import { TypeBoxError } from '../../type/error/index'
 
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Errors
-// --------------------------------------------------------------------------
-export class ValueHashError extends Error {
+// ------------------------------------------------------------------
+export class ValueHashError extends TypeBoxError {
   constructor(public readonly value: unknown) {
     super(`Unable to hash value`)
   }
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // ByteMarker
-// --------------------------------------------------------------------------
-export enum ByteMarker {
+// ------------------------------------------------------------------
+enum ByteMarker {
   Undefined,
   Null,
   Boolean,
@@ -52,27 +53,27 @@ export enum ByteMarker {
   Symbol,
   BigInt,
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // State
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 let Accumulator = BigInt('14695981039346656037')
 const [Prime, Size] = [BigInt('1099511628211'), BigInt('2') ** BigInt('64')]
 const Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i))
 const F64 = new Float64Array(1)
 const F64In = new DataView(F64.buffer)
 const F64Out = new Uint8Array(F64.buffer)
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // NumberToBytes
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function* NumberToBytes(value: number): IterableIterator<number> {
   const byteCount = value === 0 ? 1 : Math.ceil(Math.floor(Math.log2(value) + 1) / 8)
   for (let i = 0; i < byteCount; i++) {
     yield (value >> (8 * (byteCount - 1 - i))) & 0xff
   }
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Hashing Functions
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function ArrayType(value: Array<unknown>) {
   FNV1A64(ByteMarker.Array)
   for (const item of value) {
@@ -150,9 +151,9 @@ function FNV1A64(byte: number) {
   Accumulator = Accumulator ^ Bytes[byte]
   Accumulator = (Accumulator * Prime) % Size
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Hash
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 /** Creates a FNV1A-64 non cryptographic hash of the given value */
 export function Hash(value: unknown) {
   Accumulator = BigInt('14695981039346656037')
diff --git a/src/value/hash/index.ts b/src/value/hash/index.ts
new file mode 100644
index 000000000..a2607845e
--- /dev/null
+++ b/src/value/hash/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './hash'
diff --git a/src/value/index.ts b/src/value/index.ts
index e8beb3bbd..eecc44779 100644
--- a/src/value/index.ts
+++ b/src/value/index.ts
@@ -26,8 +26,56 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+// ------------------------------------------------------------------
+// Value Errors (re-export)
+// ------------------------------------------------------------------
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index'
-export { Edit, Insert, Update, Delete } from './delta'
-export { Mutable } from './mutate'
-export { ValuePointer } from './pointer'
-export { Value } from './value'
+// ------------------------------------------------------------------
+// Value Operators
+// ------------------------------------------------------------------
+export { Cast, ValueCastError } from './cast/index'
+export { Check } from './check/index'
+export { Clean } from './clean/index'
+export { Clone } from './clone/index'
+export { Convert } from './convert/index'
+export { Create, ValueCreateError } from './create/index'
+export { Default } from './default/index'
+export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaError } from './delta/index'
+export { Equal } from './equal/index'
+export { Hash, ValueHashError } from './hash/index'
+export { Mutate, ValueMutateError, type Mutable } from './mutate/index'
+export { ValuePointer } from './pointer/index'
+export { TransformDecode, TransformEncode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index'
+// ------------------------------------------------------------------
+// Value Guards
+// ------------------------------------------------------------------
+export {
+  ArrayType,
+  HasPropertyKey,
+  IsArray,
+  IsAsyncIterator,
+  IsBigInt,
+  IsBoolean,
+  IsDate,
+  IsFunction,
+  IsInteger,
+  IsIterator,
+  IsNull,
+  IsNumber,
+  IsObject,
+  IsPlainObject,
+  IsPromise,
+  IsString,
+  IsSymbol,
+  IsTypedArray,
+  IsUint8Array,
+  IsUndefined,
+  IsValueType,
+  type ObjectType,
+  type TypedArrayType,
+  type ValueType,
+} from './guard/index'
+// ------------------------------------------------------------------
+// Value Namespace
+// ------------------------------------------------------------------
+export { Value } from './value/index'
diff --git a/src/value/mutate/index.ts b/src/value/mutate/index.ts
new file mode 100644
index 000000000..cf8bd9248
--- /dev/null
+++ b/src/value/mutate/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './mutate'
diff --git a/src/value/mutate.ts b/src/value/mutate/mutate.ts
similarity index 85%
rename from src/value/mutate.ts
rename to src/value/mutate/mutate.ts
index 42d563c4a..670a02e5d 100644
--- a/src/value/mutate.ts
+++ b/src/value/mutate/mutate.ts
@@ -26,26 +26,22 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsPlainObject, IsArray, IsTypedArray, IsValueType, type TypedArrayType } from './guard'
-import { ValuePointer } from './pointer'
-import { Clone } from './clone'
+import { IsPlainObject, IsArray, IsTypedArray, IsValueType, type TypedArrayType } from '../guard/index'
+import { ValuePointer } from '../pointer/index'
+import { Clone } from '../clone/index'
+import { TypeBoxError } from '../../type/error/index'
 
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Errors
-// --------------------------------------------------------------------------
-export class ValueMutateTypeMismatchError extends Error {
-  constructor() {
-    super('Cannot assign due type mismatch of assignable values')
+// ------------------------------------------------------------------
+export class ValueMutateError extends TypeBoxError {
+  constructor(message: string) {
+    super(message)
   }
 }
-export class ValueMutateInvalidRootMutationError extends Error {
-  constructor() {
-    super('Only object and array types can be mutated at the root level')
-  }
-}
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Mutators
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 export type Mutable = { [key: string]: unknown } | unknown[]
 function ObjectType(root: Mutable, path: string, current: unknown, next: Record<string, unknown>) {
   if (!IsPlainObject(current)) {
@@ -97,9 +93,9 @@ function Visit(root: Mutable, path: string, current: unknown, next: unknown) {
   if (IsPlainObject(next)) return ObjectType(root, path, current, next)
   if (IsValueType(next)) return ValueType(root, path, current, next)
 }
-// --------------------------------------------------------------------------
-// Mutate
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
+// IsNonMutableValue
+// ------------------------------------------------------------------
 function IsNonMutableValue(value: unknown): value is Mutable {
   return IsTypedArray(value) || IsValueType(value)
 }
@@ -110,12 +106,12 @@ function IsMismatchedValue(current: unknown, next: unknown) {
     (IsArray(current) && IsPlainObject(next))
   )
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Mutate
-// --------------------------------------------------------------------------
-/** Performs a deep mutable value assignment while retaining internal references */
+// ------------------------------------------------------------------
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
 export function Mutate(current: Mutable, next: Mutable): void {
-  if (IsNonMutableValue(current) || IsNonMutableValue(next)) throw new ValueMutateInvalidRootMutationError()
-  if (IsMismatchedValue(current, next)) throw new ValueMutateTypeMismatchError()
+  if (IsNonMutableValue(current) || IsNonMutableValue(next)) throw new ValueMutateError('Only object and array types can be mutated at the root level')
+  if (IsMismatchedValue(current, next)) throw new ValueMutateError('Cannot assign due type mismatch of assignable values')
   Visit(current, '', current, next)
 }
diff --git a/src/value/pointer.ts b/src/value/pointer.ts
deleted file mode 100644
index 995ce8129..000000000
--- a/src/value/pointer.ts
+++ /dev/null
@@ -1,121 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-// --------------------------------------------------------------------------
-// Errors
-// --------------------------------------------------------------------------
-export class ValuePointerRootSetError extends Error {
-  constructor(public readonly value: unknown, public readonly path: string, public readonly update: unknown) {
-    super('Cannot set root value')
-  }
-}
-export class ValuePointerRootDeleteError extends Error {
-  constructor(public readonly value: unknown, public readonly path: string) {
-    super('Cannot delete root value')
-  }
-}
-// --------------------------------------------------------------------------
-// ValuePointer
-// --------------------------------------------------------------------------
-/** Provides functionality to update values through RFC6901 string pointers */
-export namespace ValuePointer {
-  function Escape(component: string) {
-    return component.indexOf('~') === -1 ? component : component.replace(/~1/g, '/').replace(/~0/g, '~')
-  }
-  /** Formats the given pointer into navigable key components */
-  export function* Format(pointer: string): IterableIterator<string> {
-    if (pointer === '') return
-    let [start, end] = [0, 0]
-    for (let i = 0; i < pointer.length; i++) {
-      const char = pointer.charAt(i)
-      if (char === '/') {
-        if (i === 0) {
-          start = i + 1
-        } else {
-          end = i
-          yield Escape(pointer.slice(start, end))
-          start = i + 1
-        }
-      } else {
-        end = i
-      }
-    }
-    yield Escape(pointer.slice(start))
-  }
-  /** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
-  export function Set(value: any, pointer: string, update: unknown): void {
-    if (pointer === '') throw new ValuePointerRootSetError(value, pointer, update)
-    let [owner, next, key] = [null as any, value, '']
-    for (const component of Format(pointer)) {
-      if (next[component] === undefined) next[component] = {}
-      owner = next
-      next = next[component]
-      key = component
-    }
-    owner[key] = update
-  }
-  /** Deletes a value at the given pointer */
-  export function Delete(value: any, pointer: string): void {
-    if (pointer === '') throw new ValuePointerRootDeleteError(value, pointer)
-    let [owner, next, key] = [null as any, value as any, '']
-    for (const component of Format(pointer)) {
-      if (next[component] === undefined || next[component] === null) return
-      owner = next
-      next = next[component]
-      key = component
-    }
-    if (Array.isArray(owner)) {
-      const index = parseInt(key)
-      owner.splice(index, 1)
-    } else {
-      delete owner[key]
-    }
-  }
-  /** Returns true if a value exists at the given pointer */
-  export function Has(value: any, pointer: string): boolean {
-    if (pointer === '') return true
-    let [owner, next, key] = [null as any, value as any, '']
-    for (const component of Format(pointer)) {
-      if (next[component] === undefined) return false
-      owner = next
-      next = next[component]
-      key = component
-    }
-    return Object.getOwnPropertyNames(owner).includes(key)
-  }
-  /** Gets the value at the given pointer */
-  export function Get(value: any, pointer: string): any {
-    if (pointer === '') return value
-    let current = value
-    for (const component of Format(pointer)) {
-      if (current[component] === undefined) return undefined
-      current = current[component]
-    }
-    return current
-  }
-}
diff --git a/src/value/pointer/index.ts b/src/value/pointer/index.ts
new file mode 100644
index 000000000..d4071966d
--- /dev/null
+++ b/src/value/pointer/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * as ValuePointer from './pointer'
diff --git a/src/value/pointer/pointer.ts b/src/value/pointer/pointer.ts
new file mode 100644
index 000000000..e0c463927
--- /dev/null
+++ b/src/value/pointer/pointer.ts
@@ -0,0 +1,127 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TypeBoxError } from '../../type/error/index'
+
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+export class ValuePointerRootSetError extends TypeBoxError {
+  constructor(public readonly value: unknown, public readonly path: string, public readonly update: unknown) {
+    super('Cannot set root value')
+  }
+}
+export class ValuePointerRootDeleteError extends TypeBoxError {
+  constructor(public readonly value: unknown, public readonly path: string) {
+    super('Cannot delete root value')
+  }
+}
+// ------------------------------------------------------------------
+// ValuePointer
+// ------------------------------------------------------------------
+/** Provides functionality to update values through RFC6901 string pointers */
+// prettier-ignore
+function Escape(component: string) {
+  return component.indexOf('~') === -1 ? component : component.replace(/~1/g, '/').replace(/~0/g, '~')
+}
+/** Formats the given pointer into navigable key components */
+// prettier-ignore
+export function* Format(pointer: string): IterableIterator<string> {
+  if (pointer === '') return
+  let [start, end] = [0, 0]
+  for (let i = 0; i < pointer.length; i++) {
+    const char = pointer.charAt(i)
+    if (char === '/') {
+      if (i === 0) {
+        start = i + 1
+      } else {
+        end = i
+        yield Escape(pointer.slice(start, end))
+        start = i + 1
+      }
+    } else {
+      end = i
+    }
+  }
+  yield Escape(pointer.slice(start))
+}
+/** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
+// prettier-ignore
+export function Set(value: any, pointer: string, update: unknown): void {
+  if (pointer === '') throw new ValuePointerRootSetError(value, pointer, update)
+  let [owner, next, key] = [null as any, value, '']
+  for (const component of Format(pointer)) {
+    if (next[component] === undefined) next[component] = {}
+    owner = next
+    next = next[component]
+    key = component
+  }
+  owner[key] = update
+}
+/** Deletes a value at the given pointer */
+// prettier-ignore
+export function Delete(value: any, pointer: string): void {
+  if (pointer === '') throw new ValuePointerRootDeleteError(value, pointer)
+  let [owner, next, key] = [null as any, value as any, '']
+  for (const component of Format(pointer)) {
+    if (next[component] === undefined || next[component] === null) return
+    owner = next
+    next = next[component]
+    key = component
+  }
+  if (Array.isArray(owner)) {
+    const index = parseInt(key)
+    owner.splice(index, 1)
+  } else {
+    delete owner[key]
+  }
+}
+/** Returns true if a value exists at the given pointer */
+// prettier-ignore
+export function Has(value: any, pointer: string): boolean {
+  if (pointer === '') return true
+  let [owner, next, key] = [null as any, value as any, '']
+  for (const component of Format(pointer)) {
+    if (next[component] === undefined) return false
+    owner = next
+    next = next[component]
+    key = component
+  }
+  return Object.getOwnPropertyNames(owner).includes(key)
+}
+/** Gets the value at the given pointer */
+// prettier-ignore
+export function Get(value: any, pointer: string): any {
+  if (pointer === '') return value
+  let current = value
+  for (const component of Format(pointer)) {
+    if (current[component] === undefined) return undefined
+    current = current[component]
+  }
+  return current
+}
diff --git a/src/value/transform.ts b/src/value/transform.ts
deleted file mode 100644
index bb377f9a1..000000000
--- a/src/value/transform.ts
+++ /dev/null
@@ -1,439 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { IsString, IsPlainObject, IsArray, IsValueType, IsUndefined } from './guard'
-import { ValueError } from '../errors/errors'
-import { Deref } from './deref'
-import { Check } from './check'
-import * as Types from '../typebox'
-
-// -------------------------------------------------------------------------
-// Errors
-// -------------------------------------------------------------------------
-export class TransformDecodeCheckError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema, public readonly value: unknown, public readonly error: ValueError) {
-    super(`Unable to decode due to invalid value`)
-  }
-}
-export class TransformEncodeCheckError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema, public readonly value: unknown, public readonly error: ValueError) {
-    super(`Unable to encode due to invalid value`)
-  }
-}
-export class TransformDecodeError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema, public readonly value: unknown, error: any) {
-    super(`${error instanceof Error ? error.message : 'Unknown error'}`)
-  }
-}
-export class TransformEncodeError extends Types.TypeBoxError {
-  constructor(public readonly schema: Types.TSchema, public readonly value: unknown, error: any) {
-    super(`${error instanceof Error ? error.message : 'Unknown error'}`)
-  }
-}
-// ------------------------------------------------------------------
-// HasTransform
-// ------------------------------------------------------------------
-/** Recursively checks a schema for transform codecs */
-export namespace HasTransform {
-  function TArray(schema: Types.TArray, references: Types.TSchema[]): boolean {
-    return Types.TypeGuard.TTransform(schema) || Visit(schema.items, references)
-  }
-  function TAsyncIterator(schema: Types.TAsyncIterator, references: Types.TSchema[]): boolean {
-    return Types.TypeGuard.TTransform(schema) || Visit(schema.items, references)
-  }
-  function TConstructor(schema: Types.TConstructor, references: Types.TSchema[]) {
-    return Types.TypeGuard.TTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references))
-  }
-  function TFunction(schema: Types.TFunction, references: Types.TSchema[]) {
-    return Types.TypeGuard.TTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references))
-  }
-  function TIntersect(schema: Types.TIntersect, references: Types.TSchema[]) {
-    return Types.TypeGuard.TTransform(schema) || Types.TypeGuard.TTransform(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references))
-  }
-  function TIterator(schema: Types.TIterator, references: Types.TSchema[]) {
-    return Types.TypeGuard.TTransform(schema) || Visit(schema.items, references)
-  }
-  function TNot(schema: Types.TNot, references: Types.TSchema[]) {
-    return Types.TypeGuard.TTransform(schema) || Visit(schema.not, references)
-  }
-  function TObject(schema: Types.TObject, references: Types.TSchema[]) {
-    // prettier-ignore
-    return (Types.TypeGuard.TTransform(schema) || Object.values(schema.properties).some((schema) => Visit(schema, references)) || Types.TypeGuard.TSchema(schema.additionalProperties) && Visit(schema.additionalProperties, references)
-    )
-  }
-  function TPromise(schema: Types.TPromise, references: Types.TSchema[]) {
-    return Types.TypeGuard.TTransform(schema) || Visit(schema.item, references)
-  }
-  function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[]) {
-    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
-    const property = schema.patternProperties[pattern]
-    return Types.TypeGuard.TTransform(schema) || Visit(property, references) || (Types.TypeGuard.TSchema(schema.additionalProperties) && Types.TypeGuard.TTransform(schema.additionalProperties))
-  }
-  function TRef(schema: Types.TRef<any>, references: Types.TSchema[]) {
-    if (Types.TypeGuard.TTransform(schema)) return true
-    return Visit(Deref(schema, references), references)
-  }
-  function TThis(schema: Types.TThis, references: Types.TSchema[]) {
-    if (Types.TypeGuard.TTransform(schema)) return true
-    return Visit(Deref(schema, references), references)
-  }
-  function TTuple(schema: Types.TTuple<any[]>, references: Types.TSchema[]) {
-    return Types.TypeGuard.TTransform(schema) || (!IsUndefined(schema.items) && schema.items.some((schema) => Visit(schema, references)))
-  }
-  function TUnion(schema: Types.TUnion, references: Types.TSchema[]) {
-    return Types.TypeGuard.TTransform(schema) || schema.anyOf.some((schema) => Visit(schema, references))
-  }
-  function Visit(schema: Types.TSchema, references: Types.TSchema[]): boolean {
-    const references_ = IsString(schema.$id) ? [...references, schema] : references
-    const schema_ = schema as any
-    if (schema.$id && visited.has(schema.$id)) return false
-    if (schema.$id) visited.add(schema.$id)
-    switch (schema[Types.Kind]) {
-      case 'Array':
-        return TArray(schema_, references_)
-      case 'AsyncIterator':
-        return TAsyncIterator(schema_, references_)
-      case 'Constructor':
-        return TConstructor(schema_, references_)
-      case 'Function':
-        return TFunction(schema_, references_)
-      case 'Intersect':
-        return TIntersect(schema_, references_)
-      case 'Iterator':
-        return TIterator(schema_, references_)
-      case 'Not':
-        return TNot(schema_, references_)
-      case 'Object':
-        return TObject(schema_, references_)
-      case 'Promise':
-        return TPromise(schema_, references_)
-      case 'Record':
-        return TRecord(schema_, references_)
-      case 'Ref':
-        return TRef(schema_, references_)
-      case 'This':
-        return TThis(schema_, references_)
-      case 'Tuple':
-        return TTuple(schema_, references_)
-      case 'Union':
-        return TUnion(schema_, references_)
-      default:
-        return Types.TypeGuard.TTransform(schema)
-    }
-  }
-  const visited = new Set<string>()
-  /** Returns true if this schema contains a transform codec */
-  export function Has(schema: Types.TSchema, references: Types.TSchema[]): boolean {
-    visited.clear()
-    return Visit(schema, references)
-  }
-}
-// ------------------------------------------------------------------
-// DecodeTransform
-// ------------------------------------------------------------------
-/** Decodes a value using transform decoders if available. Does not ensure correct results. */
-export namespace DecodeTransform {
-  function Default(schema: Types.TSchema, value: any) {
-    try {
-      return Types.TypeGuard.TTransform(schema) ? schema[Types.Transform].Decode(value) : value
-    } catch (error) {
-      throw new TransformDecodeError(schema, value, error)
-    }
-  }
-  // prettier-ignore
-  function TArray(schema: Types.TArray, references: Types.TSchema[], value: any): any {
-    return (IsArray(value))
-      ? Default(schema, value.map((value: any) => Visit(schema.items, references, value)))
-      : Default(schema, value)
-  }
-  // prettier-ignore
-  function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any) {
-    if (!IsPlainObject(value) || IsValueType(value)) return Default(schema, value)
-    const knownKeys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false })
-    const knownProperties = knownKeys.reduce((value, key) => {
-      return (key in value)
-        ? { ...value, [key]: Visit(Types.IndexedAccessor.Resolve(schema, [key]), references, value[key]) }
-        : value
-    }, value)
-    if (!Types.TypeGuard.TTransform(schema.unevaluatedProperties)) {
-      return Default(schema, knownProperties)
-    }
-    const unknownKeys = Object.getOwnPropertyNames(knownProperties)
-    const unevaluatedProperties = schema.unevaluatedProperties as Types.TSchema
-    const unknownProperties = unknownKeys.reduce((value, key) => {
-      return !knownKeys.includes(key)
-        ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }
-        : value
-    }, knownProperties)
-    return Default(schema, unknownProperties)
-  }
-  function TNot(schema: Types.TNot, references: Types.TSchema[], value: any) {
-    return Default(schema, Visit(schema.not, references, value))
-  }
-  // prettier-ignore
-  function TObject(schema: Types.TObject, references: Types.TSchema[], value: any) {
-    if (!IsPlainObject(value)) return Default(schema, value)
-    const knownKeys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false })
-    const knownProperties = knownKeys.reduce((value, key) => {
-      return (key in value) 
-        ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }  
-        : value
-    }, value)
-    if (!Types.TypeGuard.TSchema(schema.additionalProperties)) {
-      return Default(schema, knownProperties)
-    }
-    const unknownKeys = Object.getOwnPropertyNames(knownProperties)
-    const additionalProperties = schema.additionalProperties as Types.TSchema
-    const unknownProperties = unknownKeys.reduce((value, key) => {
-      return !knownKeys.includes(key)
-      ? { ...value, [key]: Default(additionalProperties, value[key]) }
-      : value
-    }, knownProperties)
-    return Default(schema, unknownProperties)
-  }
-  // prettier-ignore
-  function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any) {
-    if (!IsPlainObject(value)) return Default(schema, value)
-    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
-    const knownKeys = new RegExp(pattern)
-    const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
-      return knownKeys.test(key) 
-        ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
-        : value
-    }, value)
-    if (!Types.TypeGuard.TSchema(schema.additionalProperties)) {
-      return Default(schema, knownProperties)
-    }
-    const unknownKeys = Object.getOwnPropertyNames(knownProperties)
-    const additionalProperties = schema.additionalProperties as Types.TSchema
-    const unknownProperties = unknownKeys.reduce((value, key) => {
-      return !knownKeys.test(key)
-      ? { ...value, [key]: Default(additionalProperties, value[key]) }
-      : value
-    }, knownProperties)
-    return Default(schema, unknownProperties)
-  }
-  function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any) {
-    const target = Deref(schema, references)
-    return Default(schema, Visit(target, references, value))
-  }
-  function TThis(schema: Types.TThis, references: Types.TSchema[], value: any) {
-    const target = Deref(schema, references)
-    return Default(schema, Visit(target, references, value))
-  }
-  // prettier-ignore
-  function TTuple(schema: Types.TTuple, references: Types.TSchema[], value: any) {
-    return (IsArray(value) && IsArray(schema.items))
-      ? Default(schema, schema.items.map((schema, index) => Visit(schema, references, value[index])))
-      : Default(schema, value)
-  }
-  function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any) {
-    const defaulted = Default(schema, value)
-    for (const subschema of schema.anyOf) {
-      if (!Check(subschema, references, defaulted)) continue
-      return Visit(subschema, references, defaulted)
-    }
-    return defaulted
-  }
-  function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
-    const references_ = typeof schema.$id === 'string' ? [...references, schema] : references
-    const schema_ = schema as any
-    switch (schema[Types.Kind]) {
-      case 'Array':
-        return TArray(schema_, references_, value)
-      case 'Intersect':
-        return TIntersect(schema_, references_, value)
-      case 'Not':
-        return TNot(schema_, references_, value)
-      case 'Object':
-        return TObject(schema_, references_, value)
-      case 'Record':
-        return TRecord(schema_, references_, value)
-      case 'Ref':
-        return TRef(schema_, references_, value)
-      case 'Symbol':
-        return Default(schema_, value)
-      case 'This':
-        return TThis(schema_, references_, value)
-      case 'Tuple':
-        return TTuple(schema_, references_, value)
-      case 'Union':
-        return TUnion(schema_, references_, value)
-      default:
-        return Default(schema_, value)
-    }
-  }
-  export function Decode(schema: Types.TSchema, references: Types.TSchema[], value: unknown): unknown {
-    return Visit(schema, references, value)
-  }
-}
-// ------------------------------------------------------------------
-// DecodeTransform
-// ------------------------------------------------------------------
-/** Encodes a value using transform encoders if available. Does not ensure correct results. */
-export namespace EncodeTransform {
-  function Default(schema: Types.TSchema, value: any) {
-    try {
-      return Types.TypeGuard.TTransform(schema) ? schema[Types.Transform].Encode(value) : value
-    } catch (error) {
-      throw new TransformEncodeError(schema, value, error)
-    }
-  }
-  // prettier-ignore
-  function TArray(schema: Types.TArray, references: Types.TSchema[], value: any): any {
-    const defaulted = Default(schema, value)
-    return IsArray(defaulted)
-      ? defaulted.map((value: any) => Visit(schema.items, references, value))
-      : defaulted
-  }
-  // prettier-ignore
-  function TIntersect(schema: Types.TIntersect, references: Types.TSchema[], value: any) {
-    const defaulted = Default(schema, value)
-    if (!IsPlainObject(value) || IsValueType(value)) return defaulted
-    const knownKeys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false })
-    const knownProperties = knownKeys.reduce((value, key) => {
-      return key in defaulted 
-        ? { ...value, [key]: Visit(Types.IndexedAccessor.Resolve(schema, [key]), references, value[key]) } 
-        : value
-    }, defaulted)
-    if (!Types.TypeGuard.TTransform(schema.unevaluatedProperties)) {
-      return Default(schema, knownProperties)
-    }
-    const unknownKeys = Object.getOwnPropertyNames(knownProperties)
-    const unevaluatedProperties = schema.unevaluatedProperties as Types.TSchema
-    return unknownKeys.reduce((value, key) => {
-      return !knownKeys.includes(key) 
-        ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }  
-        : value
-    }, knownProperties)
-  }
-  function TNot(schema: Types.TNot, references: Types.TSchema[], value: any) {
-    return Default(schema.not, Default(schema, value))
-  }
-  // prettier-ignore
-  function TObject(schema: Types.TObject, references: Types.TSchema[], value: any) {
-    const defaulted = Default(schema, value)
-    if (!IsPlainObject(value)) return defaulted
-    const knownKeys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false })
-    const knownProperties = knownKeys.reduce((value, key) => {
-      return key in value 
-        ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) } 
-        : value
-    }, defaulted)
-    if (!Types.TypeGuard.TSchema(schema.additionalProperties)) {
-      return knownProperties
-    }
-    const unknownKeys = Object.getOwnPropertyNames(knownProperties)
-    const additionalProperties = schema.additionalProperties as Types.TSchema
-    return unknownKeys.reduce((value, key) => {
-      return !knownKeys.includes(key) 
-        ? { ...value, [key]: Default(additionalProperties, value[key]) }  
-        : value
-    }, knownProperties)
-  }
-  // prettier-ignore
-  function TRecord(schema: Types.TRecord<any, any>, references: Types.TSchema[], value: any) {
-    const defaulted = Default(schema, value) as Record<any, any>
-    if (!IsPlainObject(value)) return defaulted
-    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
-    const knownKeys = new RegExp(pattern)
-    const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
-      return knownKeys.test(key) 
-        ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
-        : value
-    }, defaulted)
-    if (!Types.TypeGuard.TSchema(schema.additionalProperties)) {
-      return Default(schema, knownProperties)
-    }
-    const unknownKeys = Object.getOwnPropertyNames(knownProperties)
-    const additionalProperties = schema.additionalProperties as Types.TSchema
-    return unknownKeys.reduce((value, key) => {
-      return !knownKeys.test(key) 
-        ? { ...value, [key]: Default(additionalProperties, value[key]) }  
-        : value
-    }, knownProperties)
-  }
-  function TRef(schema: Types.TRef<any>, references: Types.TSchema[], value: any) {
-    const target = Deref(schema, references)
-    const resolved = Visit(target, references, value)
-    return Default(schema, resolved)
-  }
-  function TThis(schema: Types.TThis, references: Types.TSchema[], value: any) {
-    const target = Deref(schema, references)
-    const resolved = Visit(target, references, value)
-    return Default(schema, resolved)
-  }
-  function TTuple(schema: Types.TTuple, references: Types.TSchema[], value: any) {
-    const value1 = Default(schema, value)
-    return IsArray(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, value1[index])) : []
-  }
-  function TUnion(schema: Types.TUnion, references: Types.TSchema[], value: any) {
-    // test value against union variants
-    for (const subschema of schema.anyOf) {
-      if (!Check(subschema, references, value)) continue
-      const value1 = Visit(subschema, references, value)
-      return Default(schema, value1)
-    }
-    // test transformed value against union variants
-    for (const subschema of schema.anyOf) {
-      const value1 = Visit(subschema, references, value)
-      if (!Check(schema, references, value1)) continue
-      return Default(schema, value1)
-    }
-    return Default(schema, value)
-  }
-  function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any {
-    const references_ = typeof schema.$id === 'string' ? [...references, schema] : references
-    const schema_ = schema as any
-    switch (schema[Types.Kind]) {
-      case 'Array':
-        return TArray(schema_, references_, value)
-      case 'Intersect':
-        return TIntersect(schema_, references_, value)
-      case 'Not':
-        return TNot(schema_, references_, value)
-      case 'Object':
-        return TObject(schema_, references_, value)
-      case 'Record':
-        return TRecord(schema_, references_, value)
-      case 'Ref':
-        return TRef(schema_, references_, value)
-      case 'This':
-        return TThis(schema_, references_, value)
-      case 'Tuple':
-        return TTuple(schema_, references_, value)
-      case 'Union':
-        return TUnion(schema_, references_, value)
-      default:
-        return Default(schema_, value)
-    }
-  }
-  export function Encode(schema: Types.TSchema, references: Types.TSchema[], value: unknown): unknown {
-    return Visit(schema, references, value)
-  }
-}
diff --git a/src/value/transform/decode.ts b/src/value/transform/decode.ts
new file mode 100644
index 000000000..8908c9d9a
--- /dev/null
+++ b/src/value/transform/decode.ts
@@ -0,0 +1,216 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Kind, TransformKind } from '../../type/symbols/index'
+import { TypeBoxError } from '../../type/error/index'
+import { ValueError } from '../../errors/index'
+import { KeyOfPropertyKeys } from '../../type/keyof/index'
+import { Index } from '../../type/indexed/index'
+import { Deref } from '../deref/index'
+import { Check } from '../check/index'
+
+import type { TSchema } from '../../type/schema/index'
+import type { TArray } from '../../type/array/index'
+import type { TIntersect } from '../../type/intersect/index'
+import type { TNot } from '../../type/not/index'
+import type { TObject } from '../../type/object/index'
+import type { TRecord } from '../../type/record/index'
+import type { TRef } from '../../type/ref/index'
+import type { TThis } from '../../type/recursive/index'
+import type { TTuple } from '../../type/tuple/index'
+import type { TUnion } from '../../type/union/index'
+
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsPlainObject, IsArray, IsValueType } from '../guard/index'
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsTransform, IsSchema } from '../../type/guard/type'
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+// thrown externally
+export class TransformDecodeCheckError extends TypeBoxError {
+  constructor(public readonly schema: TSchema, public readonly value: unknown, public readonly error: ValueError) {
+    super(`Unable to decode due to invalid value`)
+  }
+}
+export class TransformDecodeError extends TypeBoxError {
+  constructor(public readonly schema: TSchema, public readonly value: unknown, error: any) {
+    super(`${error instanceof Error ? error.message : 'Unknown error'}`)
+  }
+}
+// ------------------------------------------------------------------
+// Decode
+// ------------------------------------------------------------------
+// prettier-ignore
+function Default(schema: TSchema, value: any) {
+  try {
+    return IsTransform(schema) ? schema[TransformKind].Decode(value) : value
+  } catch (error) {
+    throw new TransformDecodeError(schema, value, error)
+  }
+}
+// prettier-ignore
+function FromArray(schema: TArray, references: TSchema[], value: any): any {
+  return (IsArray(value))
+    ? Default(schema, value.map((value: any) => Visit(schema.items, references, value)))
+    : Default(schema, value)
+}
+// prettier-ignore
+function FromIntersect(schema: TIntersect, references: TSchema[], value: any) {
+  if (!IsPlainObject(value) || IsValueType(value)) return Default(schema, value)
+  const knownKeys = KeyOfPropertyKeys(schema) as string[]
+  const knownProperties = knownKeys.reduce((value, key) => {
+    return (key in value)
+      ? { ...value, [key]: Visit(Index(schema, [key]), references, value[key]) }
+      : value
+  }, value)
+  if (!IsTransform(schema.unevaluatedProperties)) {
+    return Default(schema, knownProperties)
+  }
+  const unknownKeys = Object.getOwnPropertyNames(knownProperties)
+  const unevaluatedProperties = schema.unevaluatedProperties as TSchema
+  const unknownProperties = unknownKeys.reduce((value, key) => {
+    return !knownKeys.includes(key)
+      ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }
+      : value
+  }, knownProperties)
+  return Default(schema, unknownProperties)
+}
+function FromNot(schema: TNot, references: TSchema[], value: any) {
+  return Default(schema, Visit(schema.not, references, value))
+}
+// prettier-ignore
+function FromObject(schema: TObject, references: TSchema[], value: any) {
+  if (!IsPlainObject(value)) return Default(schema, value)
+  const knownKeys = KeyOfPropertyKeys(schema)
+  const knownProperties = knownKeys.reduce((value, key) => {
+    return (key in value) 
+      ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }  
+      : value
+  }, value)
+  if (!IsSchema(schema.additionalProperties)) {
+    return Default(schema, knownProperties)
+  }
+  const unknownKeys = Object.getOwnPropertyNames(knownProperties)
+  const additionalProperties = schema.additionalProperties as TSchema
+  const unknownProperties = unknownKeys.reduce((value, key) => {
+    return !knownKeys.includes(key)
+    ? { ...value, [key]: Default(additionalProperties, value[key]) }
+    : value
+  }, knownProperties)
+  return Default(schema, unknownProperties)
+}
+// prettier-ignore
+function FromRecord(schema: TRecord, references: TSchema[], value: any) {
+  if (!IsPlainObject(value)) return Default(schema, value)
+  const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
+  const knownKeys = new RegExp(pattern)
+  const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
+    return knownKeys.test(key) 
+      ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
+      : value
+  }, value)
+  if (!IsSchema(schema.additionalProperties)) {
+    return Default(schema, knownProperties)
+  }
+  const unknownKeys = Object.getOwnPropertyNames(knownProperties)
+  const additionalProperties = schema.additionalProperties as TSchema
+  const unknownProperties = unknownKeys.reduce((value, key) => {
+    return !knownKeys.test(key)
+    ? { ...value, [key]: Default(additionalProperties, value[key]) }
+    : value
+  }, knownProperties)
+  return Default(schema, unknownProperties)
+}
+// prettier-ignore
+function FromRef(schema: TRef, references: TSchema[], value: any) {
+  const target = Deref(schema, references)
+  return Default(schema, Visit(target, references, value))
+}
+// prettier-ignore
+function FromThis(schema: TThis, references: TSchema[], value: any) {
+  const target = Deref(schema, references)
+  return Default(schema, Visit(target, references, value))
+}
+// prettier-ignore
+function FromTuple(schema: TTuple, references: TSchema[], value: any) {
+  return (IsArray(value) && IsArray(schema.items))
+    ? Default(schema, schema.items.map((schema, index) => Visit(schema, references, value[index])))
+    : Default(schema, value)
+}
+// prettier-ignore
+function FromUnion(schema: TUnion, references: TSchema[], value: any) {
+  for (const subschema of schema.anyOf) {
+    if (!Check(subschema, references, value)) continue
+    // note: ensure interior is decoded first
+    const decoded = Visit(subschema, references, value)
+    return Default(schema, decoded)
+  }
+  return Default(schema, value)
+}
+// prettier-ignore
+function Visit(schema: TSchema, references: TSchema[], value: any): any {
+  const references_ = typeof schema.$id === 'string' ? [...references, schema] : references
+  const schema_ = schema as any
+  switch (schema[Kind]) {
+    case 'Array':
+      return FromArray(schema_, references_, value)
+    case 'Intersect':
+      return FromIntersect(schema_, references_, value)
+    case 'Not':
+      return FromNot(schema_, references_, value)
+    case 'Object':
+      return FromObject(schema_, references_, value)
+    case 'Record':
+      return FromRecord(schema_, references_, value)
+    case 'Ref':
+      return FromRef(schema_, references_, value)
+    case 'Symbol':
+      return Default(schema_, value)
+    case 'This':
+      return FromThis(schema_, references_, value)
+    case 'Tuple':
+      return FromTuple(schema_, references_, value)
+    case 'Union':
+      return FromUnion(schema_, references_, value)
+    default:
+      return Default(schema_, value)
+  }
+}
+/**
+ * `[Internal]` Decodes the value and returns the result. This function requires that
+ * the caller `Check` the value before use. Passing unchecked values may result in
+ * undefined behavior. Refer to the `Value.Decode()` for implementation details.
+ */
+export function TransformDecode(schema: TSchema, references: TSchema[], value: unknown): unknown {
+  return Visit(schema, references, value)
+}
diff --git a/src/value/transform/encode.ts b/src/value/transform/encode.ts
new file mode 100644
index 000000000..e91057e94
--- /dev/null
+++ b/src/value/transform/encode.ts
@@ -0,0 +1,223 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Kind, TransformKind } from '../../type/symbols/index'
+import { TypeBoxError } from '../../type/error/index'
+import { ValueError } from '../../errors/index'
+import { KeyOfPropertyKeys } from '../../type/keyof/index'
+import { Index } from '../../type/indexed/index'
+import { Deref } from '../deref/index'
+import { Check } from '../check/index'
+
+import type { TSchema } from '../../type/schema/index'
+import type { TArray } from '../../type/array/index'
+import type { TIntersect } from '../../type/intersect/index'
+import type { TNot } from '../../type/not/index'
+import type { TObject } from '../../type/object/index'
+import type { TRecord } from '../../type/record/index'
+import type { TRef } from '../../type/ref/index'
+import type { TThis } from '../../type/recursive/index'
+import type { TTuple } from '../../type/tuple/index'
+import type { TUnion } from '../../type/union/index'
+
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsPlainObject, IsArray, IsValueType } from '../guard/index'
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsTransform, IsSchema } from '../../type/guard/type'
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+export class TransformEncodeCheckError extends TypeBoxError {
+  constructor(public readonly schema: TSchema, public readonly value: unknown, public readonly error: ValueError) {
+    super(`Unable to encode due to invalid value`)
+  }
+}
+export class TransformEncodeError extends TypeBoxError {
+  constructor(public readonly schema: TSchema, public readonly value: unknown, error: any) {
+    super(`${error instanceof Error ? error.message : 'Unknown error'}`)
+  }
+}
+// ------------------------------------------------------------------
+// Encode
+// ------------------------------------------------------------------
+// prettier-ignore
+function Default(schema: TSchema, value: any) {
+  try {
+    return IsTransform(schema) ? schema[TransformKind].Encode(value) : value
+  } catch (error) {
+    throw new TransformEncodeError(schema, value, error)
+  }
+}
+// prettier-ignore
+function FromArray(schema: TArray, references: TSchema[], value: any): any {
+  const defaulted = Default(schema, value)
+  return IsArray(defaulted)
+    ? defaulted.map((value: any) => Visit(schema.items, references, value))
+    : defaulted
+}
+// prettier-ignore
+function FromIntersect(schema: TIntersect, references: TSchema[], value: any) {
+  const defaulted = Default(schema, value)
+  if (!IsPlainObject(value) || IsValueType(value)) return defaulted
+  const knownKeys = KeyOfPropertyKeys(schema) as string[]
+  const knownProperties = knownKeys.reduce((value, key) => {
+    return key in defaulted 
+      ? { ...value, [key]: Visit(Index(schema, [key]), references, value[key]) } 
+      : value
+  }, defaulted)
+  if (!IsTransform(schema.unevaluatedProperties)) {
+    return Default(schema, knownProperties)
+  }
+  const unknownKeys = Object.getOwnPropertyNames(knownProperties)
+  const unevaluatedProperties = schema.unevaluatedProperties as TSchema
+  return unknownKeys.reduce((value, key) => {
+    return !knownKeys.includes(key) 
+      ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }  
+      : value
+  }, knownProperties)
+}
+// prettier-ignore
+function FromNot(schema: TNot, references: TSchema[], value: any) {
+  return Default(schema.not, Default(schema, value))
+}
+// prettier-ignore
+function FromObject(schema: TObject, references: TSchema[], value: any) {
+  const defaulted = Default(schema, value)
+  if (!IsPlainObject(value)) return defaulted
+  const knownKeys = KeyOfPropertyKeys(schema) as string[]
+  const knownProperties = knownKeys.reduce((value, key) => {
+    return key in value 
+      ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) } 
+      : value
+  }, defaulted)
+  if (!IsSchema(schema.additionalProperties)) {
+    return knownProperties
+  }
+  const unknownKeys = Object.getOwnPropertyNames(knownProperties)
+  const additionalProperties = schema.additionalProperties as TSchema
+  return unknownKeys.reduce((value, key) => {
+    return !knownKeys.includes(key) 
+      ? { ...value, [key]: Default(additionalProperties, value[key]) }  
+      : value
+  }, knownProperties)
+}
+// prettier-ignore
+function FromRecord(schema: TRecord, references: TSchema[], value: any) {
+  const defaulted = Default(schema, value) as Record<PropertyKey, unknown>
+  if (!IsPlainObject(value)) return defaulted
+  const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
+  const knownKeys = new RegExp(pattern)
+  const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
+    return knownKeys.test(key) 
+      ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
+      : value
+  }, defaulted)
+  if (!IsSchema(schema.additionalProperties)) {
+    return Default(schema, knownProperties)
+  }
+  const unknownKeys = Object.getOwnPropertyNames(knownProperties)
+  const additionalProperties = schema.additionalProperties as TSchema
+  return unknownKeys.reduce((value, key) => {
+    return !knownKeys.test(key) 
+      ? { ...value, [key]: Default(additionalProperties, value[key]) }  
+      : value
+  }, knownProperties)
+}
+// prettier-ignore
+function FromRef(schema: TRef, references: TSchema[], value: any) {
+  const target = Deref(schema, references)
+  const resolved = Visit(target, references, value)
+  return Default(schema, resolved)
+}
+// prettier-ignore
+function FromThis(schema: TThis, references: TSchema[], value: any) {
+  const target = Deref(schema, references)
+  const resolved = Visit(target, references, value)
+  return Default(schema, resolved)
+}
+// prettier-ignore
+function FromTuple(schema: TTuple, references: TSchema[], value: any) {
+  const value1 = Default(schema, value)
+  return IsArray(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, value1[index])) : []
+}
+// prettier-ignore
+function FromUnion(schema: TUnion, references: TSchema[], value: any) {
+  // test value against union variants
+  for (const subschema of schema.anyOf) {
+    if (!Check(subschema, references, value)) continue
+    const value1 = Visit(subschema, references, value)
+    return Default(schema, value1)
+  }
+  // test transformed value against union variants
+  for (const subschema of schema.anyOf) {
+    const value1 = Visit(subschema, references, value)
+    if (!Check(schema, references, value1)) continue
+    return Default(schema, value1)
+  }
+  return Default(schema, value)
+}
+// prettier-ignore
+function Visit(schema: TSchema, references: TSchema[], value: any): any {
+  const references_ = typeof schema.$id === 'string' ? [...references, schema] : references
+  const schema_ = schema as any
+  switch (schema[Kind]) {
+    case 'Array':
+      return FromArray(schema_, references_, value)
+    case 'Intersect':
+      return FromIntersect(schema_, references_, value)
+    case 'Not':
+      return FromNot(schema_, references_, value)
+    case 'Object':
+      return FromObject(schema_, references_, value)
+    case 'Record':
+      return FromRecord(schema_, references_, value)
+    case 'Ref':
+      return FromRef(schema_, references_, value)
+    case 'This':
+      return FromThis(schema_, references_, value)
+    case 'Tuple':
+      return FromTuple(schema_, references_, value)
+    case 'Union':
+      return FromUnion(schema_, references_, value)
+    default:
+      return Default(schema_, value)
+  }
+}
+/**
+ * `[Internal]` Encodes the value and returns the result. This function expects the
+ * caller to pass a statically checked value. This function does not check the encoded
+ * result, meaning the result should be passed to `Check` before use. Refer to the
+ * `Value.Encode()` function for implementation details.
+ */
+export function TransformEncode(schema: TSchema, references: TSchema[], value: unknown): unknown {
+  return Visit(schema, references, value)
+}
diff --git a/src/value/transform/has.ts b/src/value/transform/has.ts
new file mode 100644
index 000000000..437fad1d6
--- /dev/null
+++ b/src/value/transform/has.ts
@@ -0,0 +1,167 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Deref } from '../deref/index'
+import { Kind } from '../../type/symbols/index'
+
+import type { TSchema } from '../../type/schema/index'
+import type { TArray } from '../../type/array/index'
+import type { TAsyncIterator } from '../../type/async-iterator/index'
+import type { TConstructor } from '../../type/constructor/index'
+import type { TFunction } from '../../type/function/index'
+import type { TIntersect } from '../../type/intersect/index'
+import type { TIterator } from '../../type/iterator/index'
+import type { TNot } from '../../type/not/index'
+import type { TObject } from '../../type/object/index'
+import type { TPromise } from '../../type/promise/index'
+import type { TRecord } from '../../type/record/index'
+import type { TRef } from '../../type/ref/index'
+import type { TThis } from '../../type/recursive/index'
+import type { TTuple } from '../../type/tuple/index'
+import type { TUnion } from '../../type/union/index'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsTransform, IsSchema } from '../../type/guard/type'
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsString, IsUndefined } from '../guard/index'
+
+// prettier-ignore
+function FromArray(schema: TArray, references: TSchema[]): boolean {
+  return IsTransform(schema) || Visit(schema.items, references)
+}
+// prettier-ignore
+function FromAsyncIterator(schema: TAsyncIterator, references: TSchema[]): boolean {
+  return IsTransform(schema) || Visit(schema.items, references)
+}
+// prettier-ignore
+function FromConstructor(schema: TConstructor, references: TSchema[]) {
+  return IsTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references))
+}
+// prettier-ignore
+function FromFunction(schema: TFunction, references: TSchema[]) {
+  return IsTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references))
+}
+// prettier-ignore
+function FromIntersect(schema: TIntersect, references: TSchema[]) {
+  return IsTransform(schema) || IsTransform(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references))
+}
+// prettier-ignore
+function FromIterator(schema: TIterator, references: TSchema[]) {
+  return IsTransform(schema) || Visit(schema.items, references)
+}
+// prettier-ignore
+function FromNot(schema: TNot, references: TSchema[]) {
+  return IsTransform(schema) || Visit(schema.not, references)
+}
+// prettier-ignore
+function FromObject(schema: TObject, references: TSchema[]) {
+  return (
+    IsTransform(schema) || 
+    Object.values(schema.properties).some((schema) => Visit(schema, references)) || 
+    (
+      IsSchema(schema.additionalProperties) && Visit(schema.additionalProperties, references)
+    )
+  )
+}
+// prettier-ignore
+function FromPromise(schema: TPromise, references: TSchema[]) {
+  return IsTransform(schema) || Visit(schema.item, references)
+}
+// prettier-ignore
+function FromRecord(schema: TRecord, references: TSchema[]) {
+  const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
+  const property = schema.patternProperties[pattern]
+  return IsTransform(schema) || Visit(property, references) || (IsSchema(schema.additionalProperties) && IsTransform(schema.additionalProperties))
+}
+// prettier-ignore
+function FromRef(schema: TRef, references: TSchema[]) {
+  if (IsTransform(schema)) return true
+  return Visit(Deref(schema, references), references)
+}
+// prettier-ignore
+function FromThis(schema: TThis, references: TSchema[]) {
+  if (IsTransform(schema)) return true
+  return Visit(Deref(schema, references), references)
+}
+// prettier-ignore
+function FromTuple(schema: TTuple, references: TSchema[]) {
+  return IsTransform(schema) || (!IsUndefined(schema.items) && schema.items.some((schema) => Visit(schema, references)))
+}
+// prettier-ignore
+function FromUnion(schema: TUnion, references: TSchema[]) {
+  return IsTransform(schema) || schema.anyOf.some((schema) => Visit(schema, references))
+}
+// prettier-ignore
+function Visit(schema: TSchema, references: TSchema[]): boolean {
+  const references_ = IsString(schema.$id) ? [...references, schema] : references
+  const schema_ = schema as any
+  if (schema.$id && visited.has(schema.$id)) return false
+  if (schema.$id) visited.add(schema.$id)
+  switch (schema[Kind]) {
+    case 'Array':
+      return FromArray(schema_, references_)
+    case 'AsyncIterator':
+      return FromAsyncIterator(schema_, references_)
+    case 'Constructor':
+      return FromConstructor(schema_, references_)
+    case 'Function':
+      return FromFunction(schema_, references_)
+    case 'Intersect':
+      return FromIntersect(schema_, references_)
+    case 'Iterator':
+      return FromIterator(schema_, references_)
+    case 'Not':
+      return FromNot(schema_, references_)
+    case 'Object':
+      return FromObject(schema_, references_)
+    case 'Promise':
+      return FromPromise(schema_, references_)
+    case 'Record':
+      return FromRecord(schema_, references_)
+    case 'Ref':
+      return FromRef(schema_, references_)
+    case 'This':
+      return FromThis(schema_, references_)
+    case 'Tuple':
+      return FromTuple(schema_, references_)
+    case 'Union':
+      return FromUnion(schema_, references_)
+    default:
+      return IsTransform(schema)
+  }
+}
+const visited = new Set<string>()
+/** Returns true if this schema contains a transform codec */
+export function HasTransform(schema: TSchema, references: TSchema[]): boolean {
+  visited.clear()
+  return Visit(schema, references)
+}
diff --git a/src/value/transform/index.ts b/src/value/transform/index.ts
new file mode 100644
index 000000000..f821f6d29
--- /dev/null
+++ b/src/value/transform/index.ts
@@ -0,0 +1,31 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './decode'
+export * from './encode'
+export * from './has'
diff --git a/src/value/value.ts b/src/value/value.ts
deleted file mode 100644
index 9cf27168b..000000000
--- a/src/value/value.ts
+++ /dev/null
@@ -1,129 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import * as ValueErrors from '../errors/index'
-import * as ValueMutate from './mutate'
-import * as ValueHash from './hash'
-import * as ValueEqual from './equal'
-import * as ValueCast from './cast'
-import * as ValueClone from './clone'
-import * as ValueConvert from './convert'
-import * as ValueCreate from './create'
-import * as ValueCheck from './check'
-import * as ValueDelta from './delta'
-import * as ValueTransform from './transform'
-import * as Types from '../typebox'
-
-/** Functions to perform structural operations on JavaScript values */
-export namespace Value {
-  /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
-  export function Cast<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): Types.Static<T>
-  /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
-  export function Cast<T extends Types.TSchema>(schema: T, value: unknown): Types.Static<T>
-  /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
-  export function Cast(...args: any[]) {
-    return ValueCast.Cast.apply(ValueCast, args as any)
-  }
-  /** Creates a value from the given type and references */
-  export function Create<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T>
-  /** Creates a value from the given type */
-  export function Create<T extends Types.TSchema>(schema: T): Types.Static<T>
-  /** Creates a value from the given type */
-  export function Create(...args: any[]) {
-    return ValueCreate.Create.apply(ValueCreate, args as any)
-  }
-  /** Returns true if the value matches the given type and references */
-  export function Check<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): value is Types.Static<T>
-  /** Returns true if the value matches the given type */
-  export function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>
-  /** Returns true if the value matches the given type */
-  export function Check(...args: any[]) {
-    return ValueCheck.Check.apply(ValueCheck, args as any)
-  }
-  /** Converts any type mismatched values to their target type if a reasonable conversion is possible */
-  export function Convert<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): unknown
-  /** Converts any type mismatched values to their target type if a reasonable conversion is possibl. */
-  export function Convert<T extends Types.TSchema>(schema: T, value: unknown): unknown
-  /** Converts any type mismatched values to their target type if a reasonable conversion is possible */
-  export function Convert(...args: any[]) {
-    return ValueConvert.Convert.apply(ValueConvert, args as any)
-  }
-  /** Returns a structural clone of the given value */
-  export function Clone<T>(value: T): T {
-    return ValueClone.Clone(value)
-  }
-  /** Decodes a value or throws if error */
-  export function Decode<T extends Types.TSchema, R = Types.StaticDecode<T>>(schema: T, references: Types.TSchema[], value: unknown): R
-  /** Decodes a value or throws if error */
-  export function Decode<T extends Types.TSchema, R = Types.StaticDecode<T>>(schema: T, value: unknown): R
-  /** Decodes a value or throws if error */
-  export function Decode(...args: any[]) {
-    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
-    if (!Check(schema, references, value)) throw new ValueTransform.TransformDecodeCheckError(schema, value, Errors(schema, references, value).First()!)
-    return ValueTransform.DecodeTransform.Decode(schema, references, value)
-  }
-  /** Encodes a value or throws if error */
-  export function Encode<T extends Types.TSchema, R = Types.StaticEncode<T>>(schema: T, references: Types.TSchema[], value: unknown): R
-  /** Encodes a value or throws if error */
-  export function Encode<T extends Types.TSchema, R = Types.StaticEncode<T>>(schema: T, value: unknown): R
-  /** Encodes a value or throws if error */
-  export function Encode(...args: any[]) {
-    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
-    const encoded = ValueTransform.EncodeTransform.Encode(schema, references, value)
-    if (!Check(schema, references, encoded)) throw new ValueTransform.TransformEncodeCheckError(schema, value, Errors(schema, references, value).First()!)
-    return encoded
-  }
-  /** Returns an iterator for each error in this value. */
-  export function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): ValueErrors.ValueErrorIterator
-  /** Returns an iterator for each error in this value. */
-  export function Errors<T extends Types.TSchema>(schema: T, value: unknown): ValueErrors.ValueErrorIterator
-  /** Returns an iterator for each error in this value. */
-  export function Errors(...args: any[]) {
-    return ValueErrors.Errors.apply(ValueErrors, args as any)
-  }
-  /** Returns true if left and right values are structurally equal */
-  export function Equal<T>(left: T, right: unknown): right is T {
-    return ValueEqual.Equal(left, right)
-  }
-  /** Returns edits to transform the current value into the next value */
-  export function Diff(current: unknown, next: unknown): ValueDelta.Edit[] {
-    return ValueDelta.Diff(current, next)
-  }
-  /** Returns a FNV1A-64 non cryptographic hash of the given value */
-  export function Hash(value: unknown): bigint {
-    return ValueHash.Hash(value)
-  }
-  /** Returns a new value with edits applied to the given value */
-  export function Patch<T = any>(current: unknown, edits: ValueDelta.Edit[]): T {
-    return ValueDelta.Patch(current, edits) as T
-  }
-  /** Performs a deep mutable value assignment while retaining internal references. */
-  export function Mutate(current: ValueMutate.Mutable, next: ValueMutate.Mutable): void {
-    ValueMutate.Mutate(current, next)
-  }
-}
diff --git a/src/value/value/index.ts b/src/value/value/index.ts
new file mode 100644
index 000000000..3af158d90
--- /dev/null
+++ b/src/value/value/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * as Value from './value'
diff --git a/src/value/value/value.ts b/src/value/value/value.ts
new file mode 100644
index 000000000..6be317787
--- /dev/null
+++ b/src/value/value/value.ts
@@ -0,0 +1,146 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TransformDecode, TransformEncode, TransformDecodeCheckError, TransformEncodeCheckError } from '../transform/index'
+import { Mutate as MutateValue, type Mutable } from '../mutate/index'
+import { Hash as HashValue } from '../hash/index'
+import { Equal as EqualValue } from '../equal/index'
+import { Cast as CastValue } from '../cast/index'
+import { Clone as CloneValue } from '../clone/index'
+import { Convert as ConvertValue } from '../convert/index'
+import { Create as CreateValue } from '../create/index'
+import { Clean as CleanValue } from '../clean/index'
+import { Check as CheckValue } from '../check/index'
+import { Default as DefaultValue } from '../default/index'
+import { Diff as DiffValue, Patch as PatchValue, Edit } from '../delta/index'
+import { Errors as ValueErrors, ValueErrorIterator } from '../../errors/index'
+
+import type { TSchema } from '../../type/schema/index'
+import type { Static, StaticDecode, StaticEncode } from '../../type/static/index'
+
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
+export function Cast<T extends TSchema>(schema: T, references: TSchema[], value: unknown): Static<T>
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
+export function Cast<T extends TSchema>(schema: T, value: unknown): Static<T>
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
+export function Cast(...args: any[]) {
+  return CastValue.apply(CastValue, args as any)
+}
+/** Creates a value from the given type and references */
+export function Create<T extends TSchema>(schema: T, references: TSchema[]): Static<T>
+/** Creates a value from the given type */
+export function Create<T extends TSchema>(schema: T): Static<T>
+/** Creates a value from the given type */
+export function Create(...args: any[]) {
+  return CreateValue.apply(CreateValue, args as any)
+}
+/** Returns true if the value matches the given type and references */
+export function Check<T extends TSchema>(schema: T, references: TSchema[], value: unknown): value is Static<T>
+/** Returns true if the value matches the given type */
+export function Check<T extends TSchema>(schema: T, value: unknown): value is Static<T>
+/** Returns true if the value matches the given type */
+export function Check(...args: any[]) {
+  return CheckValue.apply(CheckValue, args as any)
+}
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
+export function Clean<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
+export function Clean<T extends TSchema>(schema: T, value: unknown): unknown
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
+export function Clean(...args: any[]) {
+  return CleanValue.apply(CleanValue, args as any)
+}
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible */
+export function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown
+/** Converts any type mismatched values to their target type if a reasonable conversion is possibl. */
+export function Convert<T extends TSchema>(schema: T, value: unknown): unknown
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible */
+export function Convert(...args: any[]) {
+  return ConvertValue.apply(ConvertValue, args as any)
+}
+/** Returns a structural clone of the given value */
+export function Clone<T>(value: T): T {
+  return CloneValue(value)
+}
+/** Decodes a value or throws if error */
+export function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R
+/** Decodes a value or throws if error */
+export function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R
+/** Decodes a value or throws if error */
+export function Decode(...args: any[]) {
+  const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
+  if (!Check(schema, references, value)) throw new TransformDecodeCheckError(schema, value, Errors(schema, references, value).First()!)
+  return TransformDecode(schema, references, value)
+}
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
+export function Default<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
+export function Default<T extends TSchema>(schema: T, value: unknown): unknown
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
+export function Default(...args: any[]) {
+  return DefaultValue.apply(DefaultValue, args as any)
+}
+/** Encodes a value or throws if error */
+export function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, references: TSchema[], value: unknown): R
+/** Encodes a value or throws if error */
+export function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, value: unknown): R
+/** Encodes a value or throws if error */
+export function Encode(...args: any[]) {
+  const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
+  const encoded = TransformEncode(schema, references, value)
+  if (!Check(schema, references, encoded)) throw new TransformEncodeCheckError(schema, value, Errors(schema, references, value).First()!)
+  return encoded
+}
+/** Returns an iterator for each error in this value. */
+export function Errors<T extends TSchema>(schema: T, references: TSchema[], value: unknown): ValueErrorIterator
+/** Returns an iterator for each error in this value. */
+export function Errors<T extends TSchema>(schema: T, value: unknown): ValueErrorIterator
+/** Returns an iterator for each error in this value. */
+export function Errors(...args: any[]) {
+  return ValueErrors.apply(ValueErrors, args as any)
+}
+/** Returns true if left and right values are structurally equal */
+export function Equal<T>(left: T, right: unknown): right is T {
+  return EqualValue(left, right)
+}
+/** Returns edits to transform the current value into the next value */
+export function Diff(current: unknown, next: unknown): Edit[] {
+  return DiffValue(current, next)
+}
+/** Returns a FNV1A-64 non cryptographic hash of the given value */
+export function Hash(value: unknown): bigint {
+  return HashValue(value)
+}
+/** Returns a new value with edits applied to the given value */
+export function Patch<T = any>(current: unknown, edits: Edit[]): T {
+  return PatchValue(current, edits) as T
+}
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references. */
+export function Mutate(current: Mutable, next: Mutable): void {
+  MutateValue(current, next)
+}
diff --git a/benchmark/compression/index.ts b/task/benchmark/compression/index.ts
similarity index 71%
rename from benchmark/compression/index.ts
rename to task/benchmark/compression/index.ts
index 521031315..546145c70 100644
--- a/benchmark/compression/index.ts
+++ b/task/benchmark/compression/index.ts
@@ -3,9 +3,9 @@ import { statSync, readdirSync } from 'fs'
 import { basename, extname } from 'path'
 
 export async function measure(test: string) {
-  await shell(`hammer build benchmark/compression/module/${test}.ts --dist target/benchmark/compression`)
+  await shell(`hammer build task/benchmark/compression/module/${test}.ts --dist target/benchmark/compression`)
   const compiled = statSync(`target/benchmark/compression/${test}.js`)
-  await shell(`hammer build benchmark/compression/module/${test}.ts --dist target/benchmark/compression --minify`)
+  await shell(`hammer build task/benchmark/compression/module/${test}.ts --dist target/benchmark/compression --minify`)
   const minified = statSync(`target/benchmark/compression/${test}.js`)
   return {
     test: test.padEnd(20),
@@ -16,7 +16,7 @@ export async function measure(test: string) {
 }
 
 export async function compression() {
-  const tests = readdirSync('benchmark/compression/module').map((name) => basename(name, extname(name)))
+  const tests = readdirSync('task/benchmark/compression/module').map((name) => basename(name, extname(name)))
   const results = await Promise.all(tests.map((test) => measure(test)))
   const present = results.reduce((acc, c) => {
     return { ...acc, [c.test.replace(/-/g, '/')]: { Compiled: c.compiled, Minified: c.minified, Compression: `${c.ratio.toFixed(2)} x` } }
diff --git a/benchmark/compression/module/typebox-compiler.ts b/task/benchmark/compression/module/typebox-compiler.ts
similarity index 100%
rename from benchmark/compression/module/typebox-compiler.ts
rename to task/benchmark/compression/module/typebox-compiler.ts
diff --git a/benchmark/compression/module/typebox-errors.ts b/task/benchmark/compression/module/typebox-errors.ts
similarity index 100%
rename from benchmark/compression/module/typebox-errors.ts
rename to task/benchmark/compression/module/typebox-errors.ts
diff --git a/benchmark/compression/module/typebox-system.ts b/task/benchmark/compression/module/typebox-system.ts
similarity index 100%
rename from benchmark/compression/module/typebox-system.ts
rename to task/benchmark/compression/module/typebox-system.ts
diff --git a/benchmark/compression/module/typebox-value.ts b/task/benchmark/compression/module/typebox-value.ts
similarity index 100%
rename from benchmark/compression/module/typebox-value.ts
rename to task/benchmark/compression/module/typebox-value.ts
diff --git a/benchmark/compression/module/typebox.ts b/task/benchmark/compression/module/typebox.ts
similarity index 100%
rename from benchmark/compression/module/typebox.ts
rename to task/benchmark/compression/module/typebox.ts
diff --git a/benchmark/index.ts b/task/benchmark/index.ts
similarity index 100%
rename from benchmark/index.ts
rename to task/benchmark/index.ts
diff --git a/task/benchmark/measurement/index.ts b/task/benchmark/measurement/index.ts
new file mode 100644
index 000000000..5976be49d
--- /dev/null
+++ b/task/benchmark/measurement/index.ts
@@ -0,0 +1,5 @@
+import { shell } from '@sinclair/hammer'
+
+export async function measurement() {
+  await shell(`hammer run task/benchmark/measurement/module/index.ts --dist target/benchmark/measurement`)
+}
diff --git a/benchmark/measurement/module/benchmark.ts b/task/benchmark/measurement/module/benchmark.ts
similarity index 100%
rename from benchmark/measurement/module/benchmark.ts
rename to task/benchmark/measurement/module/benchmark.ts
diff --git a/benchmark/measurement/module/cases.ts b/task/benchmark/measurement/module/cases.ts
similarity index 97%
rename from benchmark/measurement/module/cases.ts
rename to task/benchmark/measurement/module/cases.ts
index 8325c80ba..fe2ff6a20 100644
--- a/benchmark/measurement/module/cases.ts
+++ b/task/benchmark/measurement/module/cases.ts
@@ -11,7 +11,7 @@ export namespace Cases {
 
   export const Primitive_String = Type.String()
 
-  export const Primitive_String_Pattern = Type.RegExp(/foo/, { default: 'foo' })
+  export const Primitive_String_Pattern = Type.String({ pattern: 'foo', default: 'foo' })
 
   export const Primitive_Boolean = Type.Boolean()
 
diff --git a/benchmark/measurement/module/check.ts b/task/benchmark/measurement/module/check.ts
similarity index 93%
rename from benchmark/measurement/module/check.ts
rename to task/benchmark/measurement/module/check.ts
index a6e2e4324..99d3ced51 100644
--- a/benchmark/measurement/module/check.ts
+++ b/task/benchmark/measurement/module/check.ts
@@ -34,7 +34,7 @@ export namespace CheckBenchmark {
 
   export function* Execute() {
     for (const [type, schema] of Object.entries(Cases)) {
-      if (!TypeGuard.TSchema(schema)) throw Error('Invalid TypeBox schema')
+      if (!TypeGuard.IsSchema(schema)) throw Error('Invalid TypeBox schema')
       yield Measure(type, schema)
     }
   }
diff --git a/benchmark/measurement/module/compile.ts b/task/benchmark/measurement/module/compile.ts
similarity index 95%
rename from benchmark/measurement/module/compile.ts
rename to task/benchmark/measurement/module/compile.ts
index 98b61c006..ee0ade89c 100644
--- a/benchmark/measurement/module/compile.ts
+++ b/task/benchmark/measurement/module/compile.ts
@@ -21,7 +21,7 @@ export namespace CompileBenchmark {
 
   export function* Execute() {
     for (const [type, schema] of Object.entries(Cases)) {
-      if (!TypeGuard.TSchema(schema)) throw Error('Invalid TypeBox schema')
+      if (!TypeGuard.IsSchema(schema)) throw Error('Invalid TypeBox schema')
       // -------------------------------------------------------------------------------
       // Note: it is not possible to benchmark recursive schemas as ajv will cache and
       // track duplicate $id (resulting in compile error). It is not possible to ammend
diff --git a/benchmark/measurement/module/index.ts b/task/benchmark/measurement/module/index.ts
similarity index 100%
rename from benchmark/measurement/module/index.ts
rename to task/benchmark/measurement/module/index.ts
diff --git a/benchmark/measurement/module/result.ts b/task/benchmark/measurement/module/result.ts
similarity index 100%
rename from benchmark/measurement/module/result.ts
rename to task/benchmark/measurement/module/result.ts
diff --git a/task/build/common/remove-notices.ts b/task/build/common/remove-notices.ts
new file mode 100644
index 000000000..15c9688eb
--- /dev/null
+++ b/task/build/common/remove-notices.ts
@@ -0,0 +1,82 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Path from 'node:path'
+import * as Fs from 'node:fs'
+
+// ----------------------------------------------------------------------
+// Remove Module Level MIT Notice on Package Distribution
+//
+// The MIT copyright notice the unnecessarily increases the distribution
+// size of the package, this code removes it. The MIT license is available
+// in the package root.
+//
+// ----------------------------------------------------------------------
+// prettier-ignore
+function escape(content: string) {
+  return content.split('').map((c) => `\\${c}`).join('')
+}
+// prettier-ignore
+function removeNotice(content: string): string {
+  const open = escape('/*--------------------------------------------------------------------------')
+  const close = escape('---------------------------------------------------------------------------*/')
+  const critera = 'Permission is hereby granted, free of charge'
+  const pattern = new RegExp(`${open}[\\s\\S]*?${close}`, 'gm')
+  while (true) {
+    const match = pattern.exec(content)
+    if (match === null) return content.trimStart()
+    if (!match[0].includes(critera)) continue
+    content = content.replace(match[0], '')
+  }
+}
+// ------------------------------------------------------------------
+// Directory Enumeration
+// ------------------------------------------------------------------
+// prettier-ignore
+function processFile(sourcePath: string) {
+  const sourceContent = Fs.readFileSync(sourcePath, 'utf-8')
+  const targetContent = removeNotice(sourceContent)
+  Fs.writeFileSync(sourcePath, targetContent)
+}
+// prettier-ignore
+function processSourcePath(sourcePath: string) {
+  const stat = Fs.statSync(sourcePath)
+  if(stat.isDirectory()) return readDirectory(sourcePath)
+  if(stat.isFile()) return processFile(sourcePath)
+}
+// prettier-ignore
+function readDirectory(sourceDirectory: string) {
+  for(const entry of Fs.readdirSync(sourceDirectory)) {
+    const sourcePath = Path.join(sourceDirectory, entry)
+    processSourcePath(sourcePath)
+  }
+}
+/** Removes the MIT copyright notices from each source file in the given directory */
+export function removeNotices(sourceDirectory: string) {
+  readDirectory(sourceDirectory)
+}
diff --git a/task/build/import/build.ts b/task/build/import/build.ts
new file mode 100644
index 000000000..5a423c1cc
--- /dev/null
+++ b/task/build/import/build.ts
@@ -0,0 +1,40 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { removeNotices } from '../common/remove-notices'
+import { convertToEsm } from './convert-to-esm'
+import { compile } from './compile'
+
+/** Builds the ESM version of this package */
+export async function build(target: string) {
+  console.log('building...import')
+  const buildTarget = `${target}/build/import`
+  await compile(buildTarget)
+  await convertToEsm(buildTarget)
+  await removeNotices(buildTarget)
+}
diff --git a/task/build/import/compile.ts b/task/build/import/compile.ts
new file mode 100644
index 000000000..05a0a10b8
--- /dev/null
+++ b/task/build/import/compile.ts
@@ -0,0 +1,40 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+declare function shell(command: string): Promise<void>
+
+// prettier-ignore
+export async function compile(target: string) {
+  const options = [
+    `--outDir ${target}`,
+    '--target ESNext',
+    '--module ESNext',
+    '--declaration',
+  ].join(' ')
+  await shell(`tsc -p ./src/tsconfig.json ${options}`)
+}
diff --git a/task/build/import/convert-to-esm.ts b/task/build/import/convert-to-esm.ts
new file mode 100644
index 000000000..1db93a61f
--- /dev/null
+++ b/task/build/import/convert-to-esm.ts
@@ -0,0 +1,110 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Path from 'node:path'
+import * as Fs from 'node:fs'
+
+// ------------------------------------------------------------------
+// Specifier Rewrite
+// ------------------------------------------------------------------
+
+// prettier-ignore
+function replaceInlineImportSpecifiers(content: string): string {
+  const pattern = /import\((.*?)\)/g
+  while (true) {
+    const match = pattern.exec(content)
+    if (match === null) return content
+    const captured = match[1]
+    if(captured.includes('.mjs')) continue
+    const specifier = captured.slice(1, captured.length - 1)
+    content = content.replace(captured, `"${specifier}.mjs"`)
+  }
+}
+// prettier-ignore
+function replaceExportSpecifiers(content: string): string {
+  const pattern = /(export|import)(.*) from ('(.*)');/g
+  while(true) {
+    const match = pattern.exec(content)
+    if(match === null) return content
+    const captured = match[3]
+    const specifier = captured.slice(1, captured.length - 1)
+    content = content.replace(captured, `'${specifier}.mjs'`)
+  }
+}
+function replaceSpecifiers(content: string): string {
+  const pass1 = replaceExportSpecifiers(content)
+  const pass2 = replaceInlineImportSpecifiers(pass1)
+  return pass2
+}
+
+// ------------------------------------------------------------------
+// ConvertToEsm
+// ------------------------------------------------------------------
+// prettier-ignore
+function shouldProcess(sourcePath: string) {
+  const extname = Path.extname(sourcePath)
+  return ['.js', '.ts'].includes(extname)
+}
+// prettier-ignore
+function newExtension(extname: string) {
+  return (
+    extname === '.js' ? '.mjs' : 
+    extname === '.ts' ? '.mts' : 
+    extname
+  )
+}
+// prettier-ignore
+function processFile(sourcePath: string) {
+  if(!shouldProcess(sourcePath)) return
+  const extname = Path.extname(sourcePath)
+  const dirname = Path.dirname(sourcePath)
+  const basename = Path.basename(sourcePath, extname)
+  const new_extname = newExtension(extname)
+  const sourceContent = Fs.readFileSync(sourcePath, 'utf-8')
+  const targetContent = replaceSpecifiers(sourceContent)
+  const targetPath = `${Path.join(dirname, basename)}${new_extname}`
+  Fs.writeFileSync(sourcePath, targetContent)
+  Fs.renameSync(sourcePath, targetPath)
+}
+// prettier-ignore
+function processSourcePath(sourcePath: string) {
+  const stat = Fs.statSync(sourcePath)
+  if(stat.isDirectory()) return readDirectory(sourcePath)
+  if(stat.isFile()) return processFile(sourcePath)
+}
+// prettier-ignore
+function readDirectory(sourceDirectory: string) {
+  for(const entry of Fs.readdirSync(sourceDirectory)) {
+    const sourcePath = Path.join(sourceDirectory, entry)
+    processSourcePath(sourcePath)
+  }
+}
+/** Converts the JavaScript and TypeScript declaration modules in the given source directory to use .mjs extensions */
+export function convertToEsm(sourceDirectory: string) {
+  readDirectory(sourceDirectory)
+}
diff --git a/task/build/index.ts b/task/build/index.ts
new file mode 100644
index 000000000..fd7cf77da
--- /dev/null
+++ b/task/build/index.ts
@@ -0,0 +1,31 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * as Import from './import/build'
+export * as Require from './require/build'
+export * as Redirect from './redirect/build'
diff --git a/task/build/redirect/build.ts b/task/build/redirect/build.ts
new file mode 100644
index 000000000..9d34cc8cb
--- /dev/null
+++ b/task/build/redirect/build.ts
@@ -0,0 +1,38 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { createPackageJson } from './create-package-json'
+import { createRedirectPaths } from './create-redirect-paths'
+
+/** Builds package.json and redirect directories */
+export async function build(target: string) {
+  console.log('building...redirect')
+  const submodules = ['compiler', 'errors', 'system', 'type', 'value']
+  await createPackageJson(target, submodules)
+  await createRedirectPaths(target, submodules)
+}
diff --git a/task/build/redirect/create-package-json.ts b/task/build/redirect/create-package-json.ts
new file mode 100644
index 000000000..5b36ce927
--- /dev/null
+++ b/task/build/redirect/create-package-json.ts
@@ -0,0 +1,96 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Fs from 'node:fs'
+import * as Path from 'node:path'
+
+// prettier-ignore
+export function createPackageJson(target: string, submodules: string[]) {
+  const content = JSON.stringify(resolvePackageJson(submodules), null, 2)
+  const targetPath = Path.join(target, 'package.json')
+  const targetDir = Path.dirname(targetPath)
+  Fs.mkdirSync(targetDir, { recursive: true })
+  Fs.writeFileSync(targetPath, content, 'utf-8')
+}
+// prettier-ignore
+function resolvePackageJson(submodules: string[]) {
+  return {
+    ...resolveMetadata(),
+    ...resolveExports(submodules)
+  }
+}
+// prettier-ignore
+function resolveSubmoduleExports(submodule: string) {
+  return {
+    require: {
+      default: `./build/require/${submodule}/index.js`,
+      types: `./build/require/${submodule}/index.d.ts`
+    },
+    import: {
+      default: `./build/import/${submodule}/index.mjs`,
+      types: `./build/import/${submodule}/index.d.mts`,
+    }
+  }
+}
+// prettier-ignore
+function resolveExports(submodules: string[]) {
+  const exports = submodules.reduce((acc, submodule) => {
+    return { ...acc, [`./${submodule}`]: resolveSubmoduleExports(submodule) }
+  }, {
+    // ... and root module
+    ".": {
+      "require": {
+        "default": "./build/require/index.js",
+        "types": "./build/require/index.d.ts"
+      },
+      "import": {
+        "default": "./build/import/index.mjs",
+        "types": "./build/import/index.d.mts"
+      }
+    }
+  })
+  return { exports }
+}
+// prettier-ignore
+function resolveMetadata() {
+  const packagePath = Path.join(process.cwd(), 'package.json')
+  const packageJson = JSON.parse(Fs.readFileSync(packagePath, 'utf-8'))
+  return {
+    name: packageJson.name,
+    version: packageJson.version,
+    description: packageJson.description,
+    keywords: packageJson.keywords,
+    author: packageJson.author,
+    license: packageJson.license,
+    repository: packageJson.repository,
+    scripts: { test: 'echo test' }, // flagged by socket.dev
+    module: "./build/import/index.mjs",
+    types: "./build/require/index.d.ts",
+    main: "./build/require/index.js"
+  }
+}
diff --git a/task/build/redirect/create-redirect-paths.ts b/task/build/redirect/create-redirect-paths.ts
new file mode 100644
index 000000000..66549ed3b
--- /dev/null
+++ b/task/build/redirect/create-redirect-paths.ts
@@ -0,0 +1,51 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Fs from 'node:fs'
+
+// --------------------------------------------------------------------------------------------------------------------------
+// Builds redirect directories for earlier versions of Node. Note that TypeScript will use these directories to
+// resolve types when tsconfig.json is configured for `moduleResolution: 'node'`. This approach is referred to as
+// `package-json-redirect` and enables correct type resolution in lieu of a correct end user configuration.
+//
+// https://github.com/andrewbranch/example-subpath-exports-ts-compat/tree/main/examples/node_modules/package-json-redirects
+// --------------------------------------------------------------------------------------------------------------------------
+
+// prettier-ignore
+export function createRedirectPaths(target: string, submodules: string[]) {
+  submodules.forEach((submodule) => writeRedirect(target, submodule))
+}
+
+// prettier-ignore
+function writeRedirect(target: string, submodule: string) {
+  Fs.mkdirSync(`${target}/${submodule}`, { recursive: true })
+  Fs.writeFileSync(`${target}/${submodule}/package.json`,JSON.stringify({
+    main: `../build/require/${submodule}/index.js`,
+    types: `../build/require/${submodule}/index.d.ts`,
+  }, null, 2))
+}
diff --git a/task/build/require/build.ts b/task/build/require/build.ts
new file mode 100644
index 000000000..a3305a146
--- /dev/null
+++ b/task/build/require/build.ts
@@ -0,0 +1,38 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { removeNotices } from '../common/remove-notices'
+import { compile } from './compile'
+
+/** Builds the CommonJS version of this package */
+export async function build(target: string) {
+  console.log('building...require')
+  const buildTarget = `${target}/build/require`
+  await compile(buildTarget)
+  await removeNotices(buildTarget)
+}
diff --git a/task/build/require/compile.ts b/task/build/require/compile.ts
new file mode 100644
index 000000000..f033f2228
--- /dev/null
+++ b/task/build/require/compile.ts
@@ -0,0 +1,40 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+declare function shell(command: string): Promise<void>
+
+// prettier-ignore
+export async function compile(target: string) {
+  const options = [
+    `--outDir ${target}`,
+    '--target ES2020',
+    '--module CommonJS',
+    '--declaration',
+  ].join(' ')
+  await shell(`tsc -p ./src/tsconfig.json ${options}`)
+}
diff --git a/test/runtime/assert/assert.ts b/test/runtime/assert/assert.ts
index 2e9a92944..315eec216 100644
--- a/test/runtime/assert/assert.ts
+++ b/test/runtime/assert/assert.ts
@@ -1,6 +1,10 @@
 import * as assert from 'assert'
 
 export namespace Assert {
+  export function HasProperty<K extends PropertyKey>(value: unknown, key: K): asserts value is Record<K, unknown> {
+    if (typeof value === 'object' && value !== null && key in value) return
+    throw new Error(`Expected value to have property '${key as string}'`)
+  }
   export function IsTrue(value: boolean): asserts value is true {
     return assert.strictEqual(value, true)
   }
@@ -46,7 +50,7 @@ export namespace Assert {
     if (value instanceof constructor) return
     throw Error(`Value is not instance of ${constructor}`)
   }
-  export function IsTypeOf(value: any, type: any) {
+  export function IsTypeOf<T extends 'string' | 'boolean' | 'number' | 'bigint' | 'symbol' | 'object' | 'function'>(value: any, type: T) {
     if (typeof value === type) return
     throw Error(`Value is not typeof ${type}`)
   }
diff --git a/test/runtime/compiler-ajv/const.ts b/test/runtime/compiler-ajv/const.ts
new file mode 100644
index 000000000..21705e276
--- /dev/null
+++ b/test/runtime/compiler-ajv/const.ts
@@ -0,0 +1,39 @@
+import { Type } from '@sinclair/typebox'
+import { Ok } from './validate'
+
+describe('compiler-ajv/Const', () => {
+  it('Should validate 1', () => {
+    const T = Type.Const(1)
+    Ok(T, 1)
+  })
+  it('Should validate 2', () => {
+    const T = Type.Const('hello')
+    Ok(T, 'hello')
+  })
+  it('Should validate 3', () => {
+    const T = Type.Const(true)
+    Ok(T, true)
+  })
+  it('Should validate 4', () => {
+    const T = Type.Const({ x: 1, y: 2 })
+    Ok(T, { x: 1, y: 2 })
+  })
+  it('Should validate 5', () => {
+    const T = Type.Const([1, 2, 3])
+    Ok(T, [1, 2, 3])
+  })
+  it('Should validate 6', () => {
+    const T = Type.Const([1, true, 'hello'])
+    Ok(T, [1, true, 'hello'])
+  })
+  it('Should validate 7', () => {
+    const T = Type.Const({
+      x: [1, 2, 3, 4],
+      y: { x: 1, y: 2, z: 3 },
+    })
+    Ok(T, {
+      x: [1, 2, 3, 4],
+      y: { x: 1, y: 2, z: 3 },
+    })
+  })
+})
diff --git a/test/runtime/compiler-ajv/index.ts b/test/runtime/compiler-ajv/index.ts
index 0c6e11f6a..ae974b96d 100644
--- a/test/runtime/compiler-ajv/index.ts
+++ b/test/runtime/compiler-ajv/index.ts
@@ -2,6 +2,7 @@ import './any'
 import './array'
 import './boolean'
 import './composite'
+import './const'
 import './date'
 import './enum'
 import './integer'
@@ -22,8 +23,8 @@ import './readonly'
 import './recursive'
 import './record'
 import './ref'
-import './regexp'
 import './required'
+import './string-pattern'
 import './string'
 import './template-literal'
 import './tuple'
diff --git a/test/runtime/compiler-ajv/partial.ts b/test/runtime/compiler-ajv/partial.ts
index 5e56d704a..5be5691a3 100644
--- a/test/runtime/compiler-ajv/partial.ts
+++ b/test/runtime/compiler-ajv/partial.ts
@@ -1,4 +1,4 @@
-import { Type, Readonly, Optional } from '@sinclair/typebox'
+import { Type, ReadonlyKind, OptionalKind } from '@sinclair/typebox'
 import { Ok } from './validate'
 import { Assert } from '../assert'
 
@@ -29,12 +29,12 @@ describe('compiler-ajv/Partial', () => {
       { additionalProperties: false },
     )
     const T = Type.Partial(A)
-    Assert.IsEqual(T.properties.x[Readonly], 'Readonly')
-    Assert.IsEqual(T.properties.x[Optional], 'Optional')
-    Assert.IsEqual(T.properties.y[Readonly], 'Readonly')
-    Assert.IsEqual(T.properties.y[Optional], 'Optional')
-    Assert.IsEqual(T.properties.z[Optional], 'Optional')
-    Assert.IsEqual(T.properties.w[Optional], 'Optional')
+    Assert.IsEqual(T.properties.x[ReadonlyKind], 'Readonly')
+    Assert.IsEqual(T.properties.x[OptionalKind], 'Optional')
+    Assert.IsEqual(T.properties.y[ReadonlyKind], 'Readonly')
+    Assert.IsEqual(T.properties.y[OptionalKind], 'Optional')
+    Assert.IsEqual(T.properties.z[OptionalKind], 'Optional')
+    Assert.IsEqual(T.properties.w[OptionalKind], 'Optional')
   })
   it('Should inherit options from the source object', () => {
     const A = Type.Object(
diff --git a/test/runtime/compiler-ajv/required.ts b/test/runtime/compiler-ajv/required.ts
index 7df4b1875..73820cfb1 100644
--- a/test/runtime/compiler-ajv/required.ts
+++ b/test/runtime/compiler-ajv/required.ts
@@ -1,4 +1,4 @@
-import { Type, Readonly, Optional } from '@sinclair/typebox'
+import { Type, ReadonlyKind, OptionalKind } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 import { Assert } from '../assert'
 
@@ -26,10 +26,10 @@ describe('compiler-ajv/Required', () => {
       w: Type.Number(),
     })
     const T = Type.Required(A)
-    Assert.IsEqual(T.properties.x[Readonly], 'Readonly')
-    Assert.IsEqual(T.properties.y[Readonly], 'Readonly')
-    Assert.IsEqual(T.properties.z[Optional], undefined)
-    Assert.IsEqual(T.properties.w[Optional], undefined)
+    Assert.IsEqual(T.properties.x[ReadonlyKind], 'Readonly')
+    Assert.IsEqual(T.properties.y[ReadonlyKind], 'Readonly')
+    Assert.IsEqual(T.properties.z[OptionalKind], undefined)
+    Assert.IsEqual(T.properties.w[OptionalKind], undefined)
   })
   it('Should inherit options from the source object', () => {
     const A = Type.Object(
diff --git a/test/runtime/compiler-ajv/string-pattern.ts b/test/runtime/compiler-ajv/string-pattern.ts
new file mode 100644
index 000000000..71419b1dc
--- /dev/null
+++ b/test/runtime/compiler-ajv/string-pattern.ts
@@ -0,0 +1,65 @@
+import { Type } from '@sinclair/typebox'
+import { Ok, Fail } from './validate'
+
+describe('compiler-ajv/StringPattern', () => {
+  //-----------------------------------------------------
+  // Regular Expression
+  //-----------------------------------------------------
+  it('Should validate regular expression 1', () => {
+    const T = Type.String({ pattern: /[012345]/.source })
+    Ok(T, '0')
+    Ok(T, '1')
+    Ok(T, '2')
+    Ok(T, '3')
+    Ok(T, '4')
+    Ok(T, '5')
+  })
+  it('Should validate regular expression 2', () => {
+    const T = Type.String({ pattern: /true|false/.source })
+    Ok(T, 'true')
+    Ok(T, 'true')
+    Ok(T, 'true')
+    Ok(T, 'false')
+    Ok(T, 'false')
+    Ok(T, 'false')
+    Fail(T, '6')
+  })
+  it('Should validate regular expression 3', () => {
+    const T = Type.String({ pattern: /true|false/.source })
+    Fail(T, 'unknown')
+  })
+  it('Should validate regular expression 4', () => {
+    const T = Type.String({ pattern: /[\d]{5}/.source })
+    Ok(T, '12345')
+  })
+  //-----------------------------------------------------
+  // Regular Pattern
+  //-----------------------------------------------------
+  it('Should validate pattern 1', () => {
+    const T = Type.String({ pattern: '[012345]' })
+    Ok(T, '0')
+    Ok(T, '1')
+    Ok(T, '2')
+    Ok(T, '3')
+    Ok(T, '4')
+    Ok(T, '5')
+  })
+  it('Should validate pattern 2', () => {
+    const T = Type.String({ pattern: 'true|false' })
+    Ok(T, 'true')
+    Ok(T, 'true')
+    Ok(T, 'true')
+    Ok(T, 'false')
+    Ok(T, 'false')
+    Ok(T, 'false')
+    Fail(T, '6')
+  })
+  it('Should validate pattern 3', () => {
+    const T = Type.String({ pattern: 'true|false' })
+    Fail(T, 'unknown')
+  })
+  it('Should validate pattern 4', () => {
+    const T = Type.String({ pattern: '[\\d]{5}' })
+    Ok(T, '12345')
+  })
+})
diff --git a/test/runtime/compiler-ajv/validate.ts b/test/runtime/compiler-ajv/validate.ts
index 12648225b..baf279db8 100644
--- a/test/runtime/compiler-ajv/validate.ts
+++ b/test/runtime/compiler-ajv/validate.ts
@@ -8,19 +8,19 @@ import Ajv, { AnySchema } from 'ajv/dist/2019'
 function schemaOf(schemaOf: string, value: unknown, schema: unknown) {
   switch (schemaOf) {
     case 'Constructor':
-      return TypeGuard.TConstructor(schema) && Value.Check(schema, value)
+      return TypeGuard.IsConstructor(schema) && Value.Check(schema, value)
     case 'Function':
-      return TypeGuard.TFunction(schema) && Value.Check(schema, value)
+      return TypeGuard.IsFunction(schema) && Value.Check(schema, value)
     case 'Date':
-      return TypeGuard.TDate(schema) && Value.Check(schema, value)
+      return TypeGuard.IsDate(schema) && Value.Check(schema, value)
     case 'Promise':
-      return TypeGuard.TPromise(schema) && Value.Check(schema, value)
+      return TypeGuard.IsPromise(schema) && Value.Check(schema, value)
     case 'Uint8Array':
-      return TypeGuard.TUint8Array(schema) && Value.Check(schema, value)
+      return TypeGuard.IsUint8Array(schema) && Value.Check(schema, value)
     case 'Undefined':
-      return TypeGuard.TUndefined(schema) && Value.Check(schema, value)
+      return TypeGuard.IsUndefined(schema) && Value.Check(schema, value)
     case 'Void':
-      return TypeGuard.TVoid(schema) && Value.Check(schema, value)
+      return TypeGuard.IsVoid(schema) && Value.Check(schema, value)
     default:
       return false
   }
diff --git a/test/runtime/compiler/const.ts b/test/runtime/compiler/const.ts
new file mode 100644
index 000000000..a8526757e
--- /dev/null
+++ b/test/runtime/compiler/const.ts
@@ -0,0 +1,39 @@
+import { Type } from '@sinclair/typebox'
+import { Ok } from './validate'
+
+describe('compiler/Const', () => {
+  it('Should validate 1', () => {
+    const T = Type.Const(1)
+    Ok(T, 1)
+  })
+  it('Should validate 2', () => {
+    const T = Type.Const('hello')
+    Ok(T, 'hello')
+  })
+  it('Should validate 3', () => {
+    const T = Type.Const(true)
+    Ok(T, true)
+  })
+  it('Should validate 4', () => {
+    const T = Type.Const({ x: 1, y: 2 })
+    Ok(T, { x: 1, y: 2 })
+  })
+  it('Should validate 5', () => {
+    const T = Type.Const([1, 2, 3])
+    Ok(T, [1, 2, 3])
+  })
+  it('Should validate 6', () => {
+    const T = Type.Const([1, true, 'hello'])
+    Ok(T, [1, true, 'hello'])
+  })
+  it('Should validate 7', () => {
+    const T = Type.Const({
+      x: [1, 2, 3, 4],
+      y: { x: 1, y: 2, z: 3 },
+    })
+    Ok(T, {
+      x: [1, 2, 3, 4],
+      y: { x: 1, y: 2, z: 3 },
+    })
+  })
+})
diff --git a/test/runtime/compiler/index.ts b/test/runtime/compiler/index.ts
index db87a1e15..487c94a60 100644
--- a/test/runtime/compiler/index.ts
+++ b/test/runtime/compiler/index.ts
@@ -4,6 +4,7 @@ import './async-iterator'
 import './bigint'
 import './boolean'
 import './composite'
+import './const'
 import './constructor'
 import './date'
 import './unicode'
@@ -31,6 +32,7 @@ import './record'
 import './ref'
 import './regexp'
 import './required'
+import './string-pattern'
 import './string'
 import './symbol'
 import './template-literal'
diff --git a/test/runtime/compiler/partial.ts b/test/runtime/compiler/partial.ts
index 870e6979b..74b71aa60 100644
--- a/test/runtime/compiler/partial.ts
+++ b/test/runtime/compiler/partial.ts
@@ -1,5 +1,5 @@
 import { TypeSystem } from '@sinclair/typebox/system'
-import { Type, Kind, Optional, Readonly } from '@sinclair/typebox'
+import { Type, OptionalKind, ReadonlyKind } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
@@ -30,12 +30,12 @@ describe('compiler/Partial', () => {
       { additionalProperties: false },
     )
     const T = Type.Partial(A)
-    strictEqual(T.properties.x[Readonly], 'Readonly')
-    strictEqual(T.properties.x[Optional], 'Optional')
-    strictEqual(T.properties.y[Readonly], 'Readonly')
-    strictEqual(T.properties.y[Optional], 'Optional')
-    strictEqual(T.properties.z[Optional], 'Optional')
-    strictEqual(T.properties.w[Optional], 'Optional')
+    strictEqual(T.properties.x[ReadonlyKind], 'Readonly')
+    strictEqual(T.properties.x[OptionalKind], 'Optional')
+    strictEqual(T.properties.y[ReadonlyKind], 'Readonly')
+    strictEqual(T.properties.y[OptionalKind], 'Optional')
+    strictEqual(T.properties.z[OptionalKind], 'Optional')
+    strictEqual(T.properties.w[OptionalKind], 'Optional')
   })
   it('Should inherit options from the source object', () => {
     const A = Type.Object(
diff --git a/test/runtime/compiler/regexp.ts b/test/runtime/compiler/regexp.ts
index 8d5d9ea39..5a9bf09b8 100644
--- a/test/runtime/compiler/regexp.ts
+++ b/test/runtime/compiler/regexp.ts
@@ -2,64 +2,15 @@ import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
 describe('compiler/RegExp', () => {
-  //-----------------------------------------------------
-  // Regular Expression
-  //-----------------------------------------------------
   it('Should validate regular expression 1', () => {
-    const T = Type.RegExp(/[012345]/)
-    Ok(T, '0')
-    Ok(T, '1')
-    Ok(T, '2')
-    Ok(T, '3')
-    Ok(T, '4')
-    Ok(T, '5')
+    const T = Type.RegExp(/foo/i)
+    Ok(T, 'foo')
+    Ok(T, 'Foo')
+    Ok(T, 'fOO')
+    Fail(T, 'bar')
   })
   it('Should validate regular expression 2', () => {
-    const T = Type.RegExp(/true|false/)
-    Ok(T, 'true')
-    Ok(T, 'true')
-    Ok(T, 'true')
-    Ok(T, 'false')
-    Ok(T, 'false')
-    Ok(T, 'false')
-    Fail(T, '6')
-  })
-  it('Should validate regular expression 3', () => {
-    const T = Type.RegExp(/true|false/)
-    Fail(T, 'unknown')
-  })
-  it('Should validate regular expression 4', () => {
-    const T = Type.RegExp(/[\d]{5}/)
-    Ok(T, '12345')
-  })
-  //-----------------------------------------------------
-  // Regular Pattern
-  //-----------------------------------------------------
-  it('Should validate pattern 1', () => {
-    const T = Type.RegExp('[012345]')
-    Ok(T, '0')
-    Ok(T, '1')
-    Ok(T, '2')
-    Ok(T, '3')
-    Ok(T, '4')
-    Ok(T, '5')
-  })
-  it('Should validate pattern 2', () => {
-    const T = Type.RegExp('true|false')
-    Ok(T, 'true')
-    Ok(T, 'true')
-    Ok(T, 'true')
-    Ok(T, 'false')
-    Ok(T, 'false')
-    Ok(T, 'false')
-    Fail(T, '6')
-  })
-  it('Should validate pattern 3', () => {
-    const T = Type.RegExp('true|false')
-    Fail(T, 'unknown')
-  })
-  it('Should validate pattern 4', () => {
-    const T = Type.RegExp('[\\d]{5}')
-    Ok(T, '12345')
+    const T = Type.RegExp(/<a?:.+?:\d{18}>|\p{Extended_Pictographic}/gu)
+    Ok(T, '♥️♦️♠️♣️')
   })
 })
diff --git a/test/runtime/compiler/required.ts b/test/runtime/compiler/required.ts
index 14ca1bf5f..fb071fecc 100644
--- a/test/runtime/compiler/required.ts
+++ b/test/runtime/compiler/required.ts
@@ -1,4 +1,4 @@
-import { Type, Readonly, Optional } from '@sinclair/typebox'
+import { Type, ReadonlyKind, OptionalKind } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 import { strictEqual } from 'assert'
 
@@ -26,10 +26,10 @@ describe('compiler/Required', () => {
       w: Type.Number(),
     })
     const T = Type.Required(A)
-    strictEqual(T.properties.x[Readonly], 'Readonly')
-    strictEqual(T.properties.y[Readonly], 'Readonly')
-    strictEqual(T.properties.z[Optional], undefined)
-    strictEqual(T.properties.w[Optional], undefined)
+    strictEqual(T.properties.x[ReadonlyKind], 'Readonly')
+    strictEqual(T.properties.y[ReadonlyKind], 'Readonly')
+    strictEqual(T.properties.z[OptionalKind], undefined)
+    strictEqual(T.properties.w[OptionalKind], undefined)
   })
   it('Should inherit options from the source object', () => {
     const A = Type.Object(
diff --git a/test/runtime/compiler-ajv/regexp.ts b/test/runtime/compiler/string-pattern.ts
similarity index 72%
rename from test/runtime/compiler-ajv/regexp.ts
rename to test/runtime/compiler/string-pattern.ts
index dcfae6e8d..6ee16cbb0 100644
--- a/test/runtime/compiler-ajv/regexp.ts
+++ b/test/runtime/compiler/string-pattern.ts
@@ -1,12 +1,12 @@
 import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
-describe('compiler-ajv/RegExp', () => {
+describe('compiler/StringPattern', () => {
   //-----------------------------------------------------
   // Regular Expression
   //-----------------------------------------------------
   it('Should validate regular expression 1', () => {
-    const T = Type.RegExp(/[012345]/)
+    const T = Type.String({ pattern: /[012345]/.source })
     Ok(T, '0')
     Ok(T, '1')
     Ok(T, '2')
@@ -15,7 +15,7 @@ describe('compiler-ajv/RegExp', () => {
     Ok(T, '5')
   })
   it('Should validate regular expression 2', () => {
-    const T = Type.RegExp(/true|false/)
+    const T = Type.String({ pattern: /true|false/.source })
     Ok(T, 'true')
     Ok(T, 'true')
     Ok(T, 'true')
@@ -25,18 +25,18 @@ describe('compiler-ajv/RegExp', () => {
     Fail(T, '6')
   })
   it('Should validate regular expression 3', () => {
-    const T = Type.RegExp(/true|false/)
+    const T = Type.String({ pattern: /true|false/.source })
     Fail(T, 'unknown')
   })
   it('Should validate regular expression 4', () => {
-    const T = Type.RegExp(/[\d]{5}/)
+    const T = Type.String({ pattern: /[\d]{5}/.source })
     Ok(T, '12345')
   })
   //-----------------------------------------------------
   // Regular Pattern
   //-----------------------------------------------------
   it('Should validate pattern 1', () => {
-    const T = Type.RegExp('[012345]')
+    const T = Type.String({ pattern: '[012345]' })
     Ok(T, '0')
     Ok(T, '1')
     Ok(T, '2')
@@ -45,7 +45,7 @@ describe('compiler-ajv/RegExp', () => {
     Ok(T, '5')
   })
   it('Should validate pattern 2', () => {
-    const T = Type.RegExp('true|false')
+    const T = Type.String({ pattern: 'true|false' })
     Ok(T, 'true')
     Ok(T, 'true')
     Ok(T, 'true')
@@ -55,11 +55,11 @@ describe('compiler-ajv/RegExp', () => {
     Fail(T, '6')
   })
   it('Should validate pattern 3', () => {
-    const T = Type.RegExp('true|false')
+    const T = Type.String({ pattern: 'true|false' })
     Fail(T, 'unknown')
   })
   it('Should validate pattern 4', () => {
-    const T = Type.RegExp('[\\d]{5}')
+    const T = Type.String({ pattern: '[\\d]{5}' })
     Ok(T, '12345')
   })
 })
diff --git a/test/runtime/errors/types/index.ts b/test/runtime/errors/types/index.ts
index 44730ba30..3329f6b54 100644
--- a/test/runtime/errors/types/index.ts
+++ b/test/runtime/errors/types/index.ts
@@ -48,6 +48,7 @@ import './object-required-property'
 import './object'
 import './promise'
 import './record-pointer-property'
+import './regexp'
 import './string-format-unknown'
 import './string-format'
 import './string-max-length'
diff --git a/test/runtime/errors/types/regexp.ts b/test/runtime/errors/types/regexp.ts
new file mode 100644
index 000000000..e6f1c69b8
--- /dev/null
+++ b/test/runtime/errors/types/regexp.ts
@@ -0,0 +1,17 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/RegExp', () => {
+  const T = Type.RegExp(/123/)
+  it('Should pass 0', () => {
+    const R = Resolve(T, '123')
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, '321')
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.RegExp)
+  })
+})
diff --git a/test/runtime/type/extends/any.ts b/test/runtime/type/extends/any.ts
index 3dd3e83ee..6373c9ae0 100644
--- a/test/runtime/type/extends/any.ts
+++ b/test/runtime/type/extends/any.ts
@@ -1,96 +1,95 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Any', () => {
   it('Should extend Any', () => {
     type T = any extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Any(), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = any extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Any(), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = any extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.String())
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Boolean', () => {
     type T = any extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Number', () => {
     type T = any extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Integer', () => {
     type T = any extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Array 1', () => {
     type T = any extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Array 2', () => {
     type T = any extends Array<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Array(Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Array(Type.String()))
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Tuple', () => {
     type T = any extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Object 1', () => {
     type T = any extends object ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Object 2', () => {
     type T = any extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Object 3', () => {
     type T = any extends { a: number } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Object({ a: Type.Number() }))
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Object({ a: Type.Number() }))
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Union 1', () => {
     type T = any extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Union 2', () => {
     type T = any extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Any(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Any(), Type.Union([Type.Any(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = any extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Undefined', () => {
     type T = any extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Void', () => {
     type T = any extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Date', () => {
     type T = any extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
 })
diff --git a/test/runtime/type/extends/array.ts b/test/runtime/type/extends/array.ts
index b734bc8ab..2e468c80c 100644
--- a/test/runtime/type/extends/array.ts
+++ b/test/runtime/type/extends/array.ts
@@ -1,5 +1,4 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Array', () => {
@@ -8,258 +7,258 @@ describe('type/extends/Array', () => {
   // ----------------------------------------------
   it('Should extend Array Varying 1', () => {
     type T = Array<any> extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Array Varying 2', () => {
     type T = Array<string> extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Array Varying 3', () => {
     type T = Array<any> extends Array<string> ? 1 : 2 // 1
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Array(Type.String()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Array Varying 4', () => {
     type T = Array<number> extends Array<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Number()), Type.Array(Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.Number()), Type.Array(Type.String()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   // ----------------------------------------------
   // Any
   // ----------------------------------------------
   it('Should extend Any', () => {
     type T = Array<any> extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = Array<any> extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = Array<any> extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = Array<any> extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = Array<any> extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = Array<any> extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = Array<any> extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Array 2', () => {
     type T = Array<string> extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Array 3', () => {
     type T = Array<any> extends Array<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Tuple', () => {
     type T = Array<any> extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = Array<any> extends object ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = Array<any> extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 3', () => {
     type T = Array<any> extends { a: number } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({ a: Type.Number() }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Object({ a: Type.Number() }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 4', () => {
     type T = Array<any> extends { length: '1' } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({ length: Type.Literal('1') }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Object({ length: Type.Literal('1') }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 5', () => {
     type T = Array<any> extends { length: number } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Object({ length: Type.Number() }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Object({ length: Type.Number() }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 1', () => {
     type T = Array<any> extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = Array<any> extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = Array<any> extends any | Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = Array<string> extends any | Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 5', () => {
     type T = Array<any> extends any | Array<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Array(Type.String())]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Union([Type.Any(), Type.Array(Type.String())]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = Array<any> extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = Array<any> extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.Any()), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.Any()), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   // ----------------------------------------------
   // Constrained
   // ----------------------------------------------
   it('Should extend constrained Any', () => {
     type T = Array<string> extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained Unknown', () => {
     type T = Array<string> extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained String', () => {
     type T = Array<string> extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Boolean', () => {
     type T = Array<string> extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Number', () => {
     type T = Array<string> extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Integer', () => {
     type T = Array<string> extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Array 1', () => {
     type T = Array<string> extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained Array 2', () => {
     type T = Array<string> extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained Array 3', () => {
     type T = Array<string> extends Array<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained Tuple', () => {
     type T = Array<string> extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Object 1', () => {
     type T = Array<string> extends object ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained Object 2', () => {
     type T = Array<string> extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained Object 3', () => {
     type T = Array<string> extends { a: number } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({ a: Type.Number() }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Object({ a: Type.Number() }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Object 4', () => {
     type T = Array<string> extends { length: '1' } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({ length: Type.Literal('1') }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Object({ length: Type.Literal('1') }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Object 5', () => {
     type T = Array<string> extends { length: number } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Object({ length: Type.Number() }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Object({ length: Type.Number() }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained Union 1', () => {
     type T = Array<string> extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Null(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Union([Type.Null(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Union 2', () => {
     type T = Array<string> extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Union([Type.Any(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained Union 3', () => {
     type T = Array<string> extends any | Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained Union 4', () => {
     type T = Array<string> extends any | Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained Union 5', () => {
     type T = Array<string> extends any | Array<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.String())]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Union([Type.Any(), Type.Array(Type.String())]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained Null', () => {
     type T = Array<string> extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Undefined', () => {
     type T = Array<string> extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Void', () => {
     type T = Array<string> extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = Array<string> extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Array(Type.String()), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Array(Type.String()), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/async-iterator.ts b/test/runtime/type/extends/async-iterator.ts
index 4eba4c020..9cc5392a8 100644
--- a/test/runtime/type/extends/async-iterator.ts
+++ b/test/runtime/type/extends/async-iterator.ts
@@ -1,5 +1,4 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/AsyncIterator', () => {
@@ -8,65 +7,65 @@ describe('type/extends/AsyncIterator', () => {
   // ----------------------------------------------
   it('Should extend AsyncIterator 1', () => {
     type T = AsyncIterableIterator<any> extends AsyncIterableIterator<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.AsyncIterator(Type.Any()), Type.AsyncIterator(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.AsyncIterator(Type.Any()), Type.AsyncIterator(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend AsyncIterator 2', () => {
     type T = AsyncIterableIterator<string> extends AsyncIterableIterator<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.AsyncIterator(Type.String()), Type.AsyncIterator(Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.AsyncIterator(Type.String()), Type.AsyncIterator(Type.String()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend AsyncIterator 3', () => {
     type T = AsyncIterableIterator<'hello'> extends AsyncIterableIterator<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.AsyncIterator(Type.Literal('hello')), Type.AsyncIterator(Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.AsyncIterator(Type.Literal('hello')), Type.AsyncIterator(Type.String()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend AsyncIterator 4', () => {
     type T = AsyncIterableIterator<string> extends AsyncIterableIterator<'hello'> ? 1 : 2
-    const R = TypeExtends.Extends(Type.AsyncIterator(Type.String()), Type.AsyncIterator(Type.Literal('hello')))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.AsyncIterator(Type.String()), Type.AsyncIterator(Type.Literal('hello')))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend AsyncIterator 5', () => {
     type T = AsyncIterableIterator<string> extends AsyncIterableIterator<'hello' | number> ? 1 : 2
-    const R = TypeExtends.Extends(Type.AsyncIterator(Type.String()), Type.AsyncIterator(Type.Union([Type.Literal('hello'), Type.Number()])))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.AsyncIterator(Type.String()), Type.AsyncIterator(Type.Union([Type.Literal('hello'), Type.Number()])))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend AsyncIterator 6', () => {
     type T = AsyncIterableIterator<'hello' | number> extends AsyncIterableIterator<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.AsyncIterator(Type.Union([Type.Literal('hello'), Type.Number()])), Type.AsyncIterator(Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.AsyncIterator(Type.Union([Type.Literal('hello'), Type.Number()])), Type.AsyncIterator(Type.String()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   // --------------------------------------------------------------------
   // Structural
   // --------------------------------------------------------------------
   it('Should extends Any 1', () => {
     type T = AsyncIterableIterator<number> extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.AsyncIterator(Type.Number()), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.AsyncIterator(Type.Number()), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extends Any 2', () => {
     type T = any extends AsyncIterableIterator<number> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.AsyncIterator(Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.AsyncIterator(Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extends Unknown 1', () => {
     type T = AsyncIterableIterator<number> extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.AsyncIterator(Type.Number()), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.AsyncIterator(Type.Number()), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extends Unknown 2', () => {
     type T = unknown extends AsyncIterableIterator<number> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.AsyncIterator(Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.AsyncIterator(Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extends Never 1', () => {
     type T = AsyncIterableIterator<number> extends never ? 1 : 2
-    const R = TypeExtends.Extends(Type.AsyncIterator(Type.Number()), Type.Never())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.AsyncIterator(Type.Number()), Type.Never())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extends Never 2', () => {
     type T = never extends AsyncIterableIterator<number> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Never(), Type.AsyncIterator(Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Never(), Type.AsyncIterator(Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
 })
diff --git a/test/runtime/type/extends/bigint.ts b/test/runtime/type/extends/bigint.ts
index 5346cfa39..f965eab3d 100644
--- a/test/runtime/type/extends/bigint.ts
+++ b/test/runtime/type/extends/bigint.ts
@@ -1,101 +1,100 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/BigInt', () => {
   it('Should extend Any', () => {
     type T = bigint extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.BigInt(), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = bigint extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.BigInt(), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = bigint extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.BigInt(), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = bigint extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.BigInt(), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = bigint extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.BigInt(), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = bigint extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.BigInt(), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = bigint extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.BigInt(), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = bigint extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.BigInt(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = bigint extends Record<number, any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Record(Type.Number(), Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.BigInt(), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = bigint extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.BigInt(), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = bigint extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Object({ a: Type.Literal(10) }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.BigInt(), Type.Object({ a: Type.Literal(10) }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = bigint extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.BigInt(), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = bigint extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.BigInt(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = bigint extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.BigInt(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 4', () => {
     type T = bigint extends boolean | bigint ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Union([Type.Boolean(), Type.BigInt()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.BigInt(), Type.Union([Type.Boolean(), Type.BigInt()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = bigint extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.BigInt(), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = bigint extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.BigInt(), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = bigint extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.BigInt(), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = bigint extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.BigInt(), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.BigInt(), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/boolean.ts b/test/runtime/type/extends/boolean.ts
index 1d56e21eb..6e336f331 100644
--- a/test/runtime/type/extends/boolean.ts
+++ b/test/runtime/type/extends/boolean.ts
@@ -1,91 +1,90 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Boolean', () => {
   it('Should extend Any', () => {
     type T = boolean extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Boolean(), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Boolean(), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = boolean extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Boolean(), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Boolean(), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = boolean extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Boolean(), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Boolean(), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Number', () => {
     type T = boolean extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Boolean(), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Boolean(), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = boolean extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Boolean(), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Boolean(), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = boolean extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Boolean(), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Boolean(), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = boolean extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Boolean(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Boolean(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = boolean extends Record<number, any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Record(Type.Number(), Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Number(), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = boolean extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Boolean(), Type.Object({}, { additionalProperties: false }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Boolean(), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = boolean extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Boolean(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Boolean(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = boolean extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Boolean(), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Boolean(), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = boolean extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Boolean(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Boolean(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = boolean extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Boolean(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Boolean(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = boolean extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Boolean(), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Boolean(), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = boolean extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Boolean(), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Boolean(), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = boolean extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Boolean(), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Boolean(), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = boolean extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Boolean(), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Boolean(), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/constructor.ts b/test/runtime/type/extends/constructor.ts
index f5b6151d9..a590c842f 100644
--- a/test/runtime/type/extends/constructor.ts
+++ b/test/runtime/type/extends/constructor.ts
@@ -1,211 +1,210 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Constructor', () => {
   it('Should extend Function', () => {
     type T = (new () => number) extends () => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Function([], Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Function([], Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Constructor 1', () => {
     type T = (new () => number) extends new () => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Constructor 2', () => {
     type T = (new () => any) extends new () => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Constructor 3', () => {
     type T = (new () => number) extends new () => any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Constructor 4', () => {
     type T = (new (a: number) => number) extends new () => any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([], Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([], Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Constructor 5', () => {
     type T = (new (a: number | string) => number) extends new (a: number) => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([Type.Union([Type.Number(), Type.String()])], Type.Number()), Type.Constructor([Type.Number()], Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([Type.Union([Type.Number(), Type.String()])], Type.Number()), Type.Constructor([Type.Number()], Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Constructor 6', () => {
     type T = (new (a: number) => number) extends new (a: number | string) => any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([Type.Union([Type.Number(), Type.String()])], Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([Type.Union([Type.Number(), Type.String()])], Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Constructor 7', () => {
     type T = (new (a: number, b: number) => number) extends new (a: number) => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([Type.Number(), Type.Number()], Type.Number()), Type.Constructor([Type.Number()], Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([Type.Number(), Type.Number()], Type.Number()), Type.Constructor([Type.Number()], Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Constructor 8', () => {
     type T = (new (a: number) => number) extends new (a: number, b: number) => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([Type.Number(), Type.Number()], Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([Type.Number()], Type.Number()), Type.Constructor([Type.Number(), Type.Number()], Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Constructor 9', () => {
     type T = (new () => number) extends new () => any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Constructor([], Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Constructor 9', () => {
     type T = (new () => any) extends new () => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([], Type.Any()), Type.Constructor([], Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Constructor 10', () => {
     type T = (new () => Array<any>) extends new () => object ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Array(Type.Any())), Type.Constructor([], Type.Object({})))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([], Type.Array(Type.Any())), Type.Constructor([], Type.Object({})))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Constructor 11', () => {
     type T = (new () => Array<string>) extends new () => object ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Array(Type.String())), Type.Constructor([], Type.Object({})))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([], Type.Array(Type.String())), Type.Constructor([], Type.Object({})))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Constructor 12', () => {
     type T = (new () => object) extends new () => Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Object({})), Type.Constructor([], Type.Array(Type.Any())))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Object({})), Type.Constructor([], Type.Array(Type.Any())))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Constructor 13', () => {
     type T = (new (a: unknown) => number) extends new (a: any) => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([Type.Unknown()], Type.Number({})), Type.Constructor([Type.Any()], Type.Number({})))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([Type.Unknown()], Type.Number({})), Type.Constructor([Type.Any()], Type.Number({})))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Constructor 14', () => {
     type T = (new (a: any) => number) extends new (a: unknown) => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([Type.Any()], Type.Number({})), Type.Constructor([Type.Unknown()], Type.Number({})))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([Type.Any()], Type.Number({})), Type.Constructor([Type.Unknown()], Type.Number({})))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Constructor 15', () => {
     type T = (new () => any) extends new () => unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Any({})), Type.Constructor([], Type.Unknown({})))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([], Type.Any({})), Type.Constructor([], Type.Unknown({})))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Constructor 16', () => {
     type T = (new () => unknown) extends new () => any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Unknown({})), Type.Constructor([], Type.Any({})))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([], Type.Unknown({})), Type.Constructor([], Type.Any({})))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Any', () => {
     type T = (new () => number) extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = (new () => number) extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = (new () => number) extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = (new () => number) extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = (new () => number) extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = (new () => number) extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = (new () => number) extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 3', () => {
     type T = (new () => number) extends Array<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = (new () => number) extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = (() => number) extends Record<number, any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Record(Type.Number(), Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = (new () => number) extends object ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = (new () => number) extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 3', () => {
     type T = (new () => number) extends { a: number } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({ a: Type.Number() }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Object({ a: Type.Number() }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 4', () => {
     type T = (new () => number) extends { length: '1' } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Object({ length: Type.Literal('1') }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Object({ length: Type.Literal('1') }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = (new () => number) extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Null(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Union([Type.Null(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = (new () => number) extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = (new () => number) extends any | Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = (new () => number) extends any | Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 5', () => {
     type T = (new () => number) extends any | Array<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.String())]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.String())]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = (new () => number) extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = (new () => number) extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = (new () => number) extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = (new () => number) extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/date.ts b/test/runtime/type/extends/date.ts
index 04df6c661..2bcfa8864 100644
--- a/test/runtime/type/extends/date.ts
+++ b/test/runtime/type/extends/date.ts
@@ -1,96 +1,95 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Date', () => {
   it('Should extend Any', () => {
     type T = Date extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Date(), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = Date extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Date(), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = Date extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Date(), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = Date extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Date(), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = Date extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Date(), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = Date extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Date(), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = Date extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Date(), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = Date extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Date(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = Date extends Record<number, any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Record(Type.Number(), Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Date(), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = Date extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Date(), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = Date extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Date(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = Date extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Date(), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = Date extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Date(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = Date extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Date(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = Date extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Date(), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = Date extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Date(), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = Date extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Date(), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = Date extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Date(), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Date(), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
 })
diff --git a/test/runtime/type/extends/function.ts b/test/runtime/type/extends/function.ts
index 0b334087d..e889555a3 100644
--- a/test/runtime/type/extends/function.ts
+++ b/test/runtime/type/extends/function.ts
@@ -1,211 +1,210 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Function', () => {
   it('Should extend Constructor 1', () => {
     type T = (() => number) extends new () => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Constructor([], Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Constructor([], Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Function 1', () => {
     type T = (() => number) extends () => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Function([], Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Function([], Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Function 2', () => {
     type T = (() => any) extends () => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Function 3', () => {
     type T = (() => number) extends () => any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Function 4', () => {
     type T = ((a: number) => number) extends () => any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([Type.Number()], Type.Number()), Type.Function([], Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([Type.Number()], Type.Number()), Type.Function([], Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Function 5', () => {
     type T = ((a: number | string) => number) extends (a: number) => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([Type.Union([Type.Number(), Type.String()])], Type.Number()), Type.Function([Type.Number()], Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([Type.Union([Type.Number(), Type.String()])], Type.Number()), Type.Function([Type.Number()], Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Function 6', () => {
     type T = ((a: number) => number) extends (a: number | string) => any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([Type.Number()], Type.Number()), Type.Function([Type.Union([Type.Number(), Type.String()])], Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([Type.Number()], Type.Number()), Type.Function([Type.Union([Type.Number(), Type.String()])], Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Function 7', () => {
     type T = ((a: number, b: number) => number) extends (a: number) => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([Type.Number(), Type.Number()], Type.Number()), Type.Function([Type.Number()], Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([Type.Number(), Type.Number()], Type.Number()), Type.Function([Type.Number()], Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Function 8', () => {
     type T = ((a: number) => number) extends (a: number, b: number) => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([Type.Number()], Type.Number()), Type.Function([Type.Number(), Type.Number()], Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([Type.Number()], Type.Number()), Type.Function([Type.Number(), Type.Number()], Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Function 9', () => {
     type T = (() => number) extends () => any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Function([], Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Function([], Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Function 9', () => {
     type T = (() => any) extends () => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Any()), Type.Function([], Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Function 10', () => {
     type T = (() => Array<any>) extends () => object ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Array(Type.Any())), Type.Function([], Type.Object({})))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Array(Type.Any())), Type.Function([], Type.Object({})))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Function 11', () => {
     type T = (() => Array<string>) extends () => object ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Array(Type.String())), Type.Function([], Type.Object({})))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Array(Type.String())), Type.Function([], Type.Object({})))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Function 12', () => {
     type T = (() => object) extends () => Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Object({})), Type.Function([], Type.Array(Type.Any())))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([], Type.Object({})), Type.Function([], Type.Array(Type.Any())))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Function 13', () => {
     type T = ((a: unknown) => number) extends (a: any) => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([Type.Unknown()], Type.Number({})), Type.Function([Type.Any()], Type.Number({})))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([Type.Unknown()], Type.Number({})), Type.Function([Type.Any()], Type.Number({})))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Function 14', () => {
     type T = ((a: any) => number) extends (a: unknown) => number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([Type.Any()], Type.Number({})), Type.Function([Type.Unknown()], Type.Number({})))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([Type.Any()], Type.Number({})), Type.Function([Type.Unknown()], Type.Number({})))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Function 15', () => {
     type T = (() => any) extends () => unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Any({})), Type.Function([], Type.Unknown({})))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Any({})), Type.Function([], Type.Unknown({})))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Function 16', () => {
     type T = (() => unknown) extends () => any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Unknown({})), Type.Function([], Type.Any({})))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Unknown({})), Type.Function([], Type.Any({})))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Any', () => {
     type T = (() => number) extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = (() => number) extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = (() => number) extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = (() => number) extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = (() => number) extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = (() => number) extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = (() => number) extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 3', () => {
     type T = (() => number) extends Array<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = (() => number) extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = (() => number) extends Record<number, any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Record(Type.Number(), Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = (() => number) extends object ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = (() => number) extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 3', () => {
     type T = (() => number) extends { a: number } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({ a: Type.Number() }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Object({ a: Type.Number() }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 4', () => {
     type T = (() => number) extends { length: '1' } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({ length: Type.Literal('1') }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Object({ length: Type.Literal('1') }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 5', () => {
     type T = (() => number) extends { length: number } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Object({ length: Type.Number() }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Object({ length: Type.Number() }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 1', () => {
     type T = (() => number) extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Null(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Union([Type.Null(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = (() => number) extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = (() => number) extends any | Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = (() => number) extends any | Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.Any())]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 5', () => {
     type T = (() => number) extends any | Array<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.String())]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Union([Type.Any(), Type.Array(Type.String())]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = (() => number) extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = (() => number) extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Function([], Type.Number()), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Function([], Type.Number()), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = (() => number) extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Constructor([], Type.Number()), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Constructor([], Type.Number()), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/index.ts b/test/runtime/type/extends/index.ts
index c826cc0fe..033113275 100644
--- a/test/runtime/type/extends/index.ts
+++ b/test/runtime/type/extends/index.ts
@@ -15,6 +15,7 @@ import './number'
 import './object'
 import './promise'
 import './record'
+import './regexp'
 import './string'
 import './symbol'
 import './template-literal'
diff --git a/test/runtime/type/extends/integer.ts b/test/runtime/type/extends/integer.ts
index 1c5d00995..6abd57529 100644
--- a/test/runtime/type/extends/integer.ts
+++ b/test/runtime/type/extends/integer.ts
@@ -1,96 +1,95 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Integer', () => {
   it('Should extend Any', () => {
     type T = number extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Integer(), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = number extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Integer(), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = number extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Integer(), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = number extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Integer(), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = number extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Integer(), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Integer', () => {
     type T = number extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Integer(), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Array', () => {
     type T = number extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Integer(), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = number extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Integer(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = number extends Record<number, any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.Record(Type.Number(), Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Integer(), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = number extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Integer(), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = number extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.Object({ a: Type.Literal(10) }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Integer(), Type.Object({ a: Type.Literal(10) }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = number extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Integer(), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Integer(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Integer(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = number extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Integer(), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = number extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Integer(), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = number extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Integer(), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Integer(), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = number extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Number(), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/iterator.ts b/test/runtime/type/extends/iterator.ts
index 1cf5b6bfd..d685dfab1 100644
--- a/test/runtime/type/extends/iterator.ts
+++ b/test/runtime/type/extends/iterator.ts
@@ -1,5 +1,4 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Iterator', () => {
@@ -8,65 +7,65 @@ describe('type/extends/Iterator', () => {
   // ----------------------------------------------
   it('Should extend Iterator 1', () => {
     type T = IterableIterator<any> extends IterableIterator<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Iterator(Type.Any()), Type.Iterator(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Iterator(Type.Any()), Type.Iterator(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Iterator 2', () => {
     type T = IterableIterator<string> extends IterableIterator<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Iterator(Type.String()), Type.Iterator(Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Iterator(Type.String()), Type.Iterator(Type.String()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Iterator 3', () => {
     type T = IterableIterator<'hello'> extends IterableIterator<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Iterator(Type.Literal('hello')), Type.Iterator(Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Iterator(Type.Literal('hello')), Type.Iterator(Type.String()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Iterator 4', () => {
     type T = IterableIterator<string> extends IterableIterator<'hello'> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Iterator(Type.String()), Type.Iterator(Type.Literal('hello')))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Iterator(Type.String()), Type.Iterator(Type.Literal('hello')))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Iterator 5', () => {
     type T = IterableIterator<string> extends IterableIterator<'hello' | number> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Iterator(Type.String()), Type.Iterator(Type.Union([Type.Literal('hello'), Type.Number()])))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Iterator(Type.String()), Type.Iterator(Type.Union([Type.Literal('hello'), Type.Number()])))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Iterator 6', () => {
     type T = IterableIterator<'hello' | number> extends IterableIterator<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Iterator(Type.Union([Type.Literal('hello'), Type.Number()])), Type.Iterator(Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Iterator(Type.Union([Type.Literal('hello'), Type.Number()])), Type.Iterator(Type.String()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   // --------------------------------------------------------------------
   // Structural
   // --------------------------------------------------------------------
   it('Should extends Any 1', () => {
     type T = IterableIterator<number> extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Iterator(Type.Number()), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Iterator(Type.Number()), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extends Any 2', () => {
     type T = any extends IterableIterator<number> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Iterator(Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Iterator(Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extends Unknown 1', () => {
     type T = IterableIterator<number> extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Iterator(Type.Number()), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Iterator(Type.Number()), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extends Unknown 2', () => {
     type T = unknown extends IterableIterator<number> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Iterator(Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.Iterator(Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extends Never 1', () => {
     type T = IterableIterator<number> extends never ? 1 : 2
-    const R = TypeExtends.Extends(Type.Iterator(Type.Number()), Type.Never())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Iterator(Type.Number()), Type.Never())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extends Never 2', () => {
     type T = never extends IterableIterator<number> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Never(), Type.Iterator(Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Never(), Type.Iterator(Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
 })
diff --git a/test/runtime/type/extends/literal.ts b/test/runtime/type/extends/literal.ts
index 7c23890fc..ca2c952b6 100644
--- a/test/runtime/type/extends/literal.ts
+++ b/test/runtime/type/extends/literal.ts
@@ -1,5 +1,4 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Literal', () => {
@@ -8,258 +7,258 @@ describe('type/extends/Literal', () => {
   // -------------------------------------------------------------------
   it('Should extend Any (String)', () => {
     type T = 'hello' extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal('hello'), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown (String)', () => {
     type T = 'hello' extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal('hello'), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String (String)', () => {
     type T = 'hello' extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal('hello'), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal('hello'), Type.String())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Boolean (String)', () => {
     type T = 'hello' extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal('hello'), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number (String)', () => {
     type T = 'hello' extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal('hello'), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer (String)', () => {
     type T = 'hello' extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal('hello'), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array (String)', () => {
     type T = 'hello' extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal('hello'), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple (String)', () => {
     type T = 'hello' extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal('hello'), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1 (String)', () => {
     type T = 'hello' extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Object({}, { additionalProperties: false }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal('hello'), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2 (String)', () => {
     type T = 'hello' extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal('hello'), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1 (String)', () => {
     type T = 'hello' extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal('hello'), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 2 (String)', () => {
     type T = 'hello' extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal('hello'), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3 (String)', () => {
     type T = 'hello' extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal('hello'), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Null (String)', () => {
     type T = 'hello' extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal('hello'), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined (String)', () => {
     type T = 'hello' extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal('hello'), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   // -------------------------------------------------------------------
   // Number Literal
   // -------------------------------------------------------------------
   it('Should extend Any (Number)', () => {
     type T = 10 extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(10), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal(10), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown (Number)', () => {
     type T = 10 extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(10), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal(10), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String (Number)', () => {
     type T = 10 extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(10), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(10), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean (Number)', () => {
     type T = 10 extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(10), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(10), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number (Number)', () => {
     type T = 10 extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(10), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal(10), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Integer (Number)', () => {
     type T = 10 extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(10), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal(10), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Array (Number)', () => {
     type T = 10 extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(10), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(10), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple (Number)', () => {
     type T = 10 extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(10), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(10), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1 (Number)', () => {
     type T = 10 extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(10), Type.Object({}, { additionalProperties: false }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal(10), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2 (Number)', () => {
     type T = 10 extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(10), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(10), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1 (Number)', () => {
     type T = 10 extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(10), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal(10), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 2 (Number)', () => {
     type T = 10 extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(10), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal(10), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3 (Number)', () => {
     type T = 10 extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(10), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal(10), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Null (Number)', () => {
     type T = 10 extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(10), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(10), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined (Number)', () => {
     type T = 10 extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(10), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(10), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   // -------------------------------------------------------------------
   // Boolean Literal
   // -------------------------------------------------------------------
   it('Should extend Any (Boolean)', () => {
     type T = true extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal(true), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown (Boolean)', () => {
     type T = true extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal(true), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String (Boolean)', () => {
     type T = true extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(true), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean (Boolean)', () => {
     type T = true extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal(true), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Number (Boolean)', () => {
     type T = true extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(true), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer (Boolean)', () => {
     type T = true extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(true), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array (Boolean)', () => {
     type T = true extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(true), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple (Boolean)', () => {
     type T = true extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(true), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record 1', () => {
     type T = 'hello' extends Record<number, any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal('hello'), Type.Record(Type.Number(), Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal('hello'), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 2', () => {
     type T = 10 extends Record<number, any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(10), Type.Record(Type.Number(), Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(10), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record 3', () => {
     type T = true extends Record<number, any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Record(Type.Number(), Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(true), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1 (Boolean)', () => {
     type T = true extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Object({}, { additionalProperties: false }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal(true), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2 (Boolean)', () => {
     type T = true extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(true), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1 (Boolean)', () => {
     type T = true extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(true), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2 (Boolean)', () => {
     type T = true extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal(true), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3 (Boolean)', () => {
     type T = true extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Literal(true), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Null (Boolean)', () => {
     type T = true extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(true), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined (Boolean)', () => {
     type T = true extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(true), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = true extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(true), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = true extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Literal(true), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Literal(true), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/not.ts b/test/runtime/type/extends/not.ts
index 53f8d1e40..fd3a97ab8 100644
--- a/test/runtime/type/extends/not.ts
+++ b/test/runtime/type/extends/not.ts
@@ -1,5 +1,4 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 // ---------------------------------------------------------------------------
@@ -18,8 +17,8 @@ describe('type/extends/Not', () => {
   it('Should extend with unknown assignability check', () => {
     const A = Type.Number()
     const B = Type.Not(Type.Number())
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True) // we would expect false
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True) // we would expect false
   })
   // ---------------------------------------------------------------------------
   // Nested
@@ -31,17 +30,17 @@ describe('type/extends/Not', () => {
     const T4 = Type.Not(T3)
     const T5 = Type.Not(T4)
 
-    const R1 = TypeExtends.Extends(T1, Type.String())
-    const R2 = TypeExtends.Extends(T2, Type.String())
-    const R3 = TypeExtends.Extends(T3, Type.String())
-    const R4 = TypeExtends.Extends(T4, Type.String())
-    const R5 = TypeExtends.Extends(T5, Type.String())
+    const R1 = ExtendsCheck(T1, Type.String())
+    const R2 = ExtendsCheck(T2, Type.String())
+    const R3 = ExtendsCheck(T3, Type.String())
+    const R4 = ExtendsCheck(T4, Type.String())
+    const R5 = ExtendsCheck(T5, Type.String())
 
-    Assert.IsEqual(R1, TypeExtendsResult.True)
-    Assert.IsEqual(R2, TypeExtendsResult.False)
-    Assert.IsEqual(R3, TypeExtendsResult.True)
-    Assert.IsEqual(R4, TypeExtendsResult.False)
-    Assert.IsEqual(R5, TypeExtendsResult.True)
+    Assert.IsEqual(R1, ExtendsResult.True)
+    Assert.IsEqual(R2, ExtendsResult.False)
+    Assert.IsEqual(R3, ExtendsResult.True)
+    Assert.IsEqual(R4, ExtendsResult.False)
+    Assert.IsEqual(R5, ExtendsResult.True)
   })
 
   // ---------------------------------------------------------------------------
@@ -49,97 +48,97 @@ describe('type/extends/Not', () => {
   // ---------------------------------------------------------------------------
   it('Should extend Any', () => {
     type T = unknown extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = unknown extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = unknown extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = unknown extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = unknown extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = unknown extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = unknown extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = unknown extends Array<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Array(Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Array(Type.String()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = unknown extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = unknown extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = unknown extends { a: number } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Object({ a: Type.Number() }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Object({ a: Type.Number() }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = unknown extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = unknown extends any | number ? 1 : 2 // 1
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Union([Type.Any(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Union([Type.Any(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = unknown extends unknown | number ? 1 : 2 // 1
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Union([Type.Unknown(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = unknown extends unknown | any ? 1 : 2 // 1
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Union([Type.Unknown(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = unknown extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = unknown extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = unknown extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = unknown extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Not(Type.Number()), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Not(Type.Number()), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/null.ts b/test/runtime/type/extends/null.ts
index 702e16271..157d7d264 100644
--- a/test/runtime/type/extends/null.ts
+++ b/test/runtime/type/extends/null.ts
@@ -1,101 +1,100 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Null', () => {
   it('Should extend Any', () => {
     type T = null extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Null(), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = null extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Null(), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = null extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Null(), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = null extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Null(), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = null extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Null(), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = null extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Null(), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = null extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Null(), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = null extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Null(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = null extends Record<number, any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Record(Type.Number(), Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Null(), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = null extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Object({}, { additionalProperties: false }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Null(), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = null extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Null(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = null extends object ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Null(), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = null extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Null(), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = null extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Null(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = null extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Null(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = null extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Null(), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Undefined', () => {
     type T = null extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Null(), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = null extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Null(), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = null extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Null(), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Null(), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/number.ts b/test/runtime/type/extends/number.ts
index aa647eca6..ce9c4189d 100644
--- a/test/runtime/type/extends/number.ts
+++ b/test/runtime/type/extends/number.ts
@@ -1,96 +1,95 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Number', () => {
   it('Should extend Any', () => {
     type T = number extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Number(), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = number extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Number(), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = number extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Number(), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = number extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Number(), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = number extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Number(), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Integer', () => {
     type T = number extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Number(), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Array', () => {
     type T = number extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Number(), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = number extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Number(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = number extends Record<number, any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Record(Type.Number(), Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Number(), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = number extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Object({}, { additionalProperties: false }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Number(), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = number extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Number(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = number extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Number(), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = number extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Number(), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = number extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Number(), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = number extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Number(), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = number extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Number(), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/object.ts b/test/runtime/type/extends/object.ts
index 8bc3a6e63..76e405818 100644
--- a/test/runtime/type/extends/object.ts
+++ b/test/runtime/type/extends/object.ts
@@ -1,5 +1,4 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Object', () => {
@@ -10,43 +9,43 @@ describe('type/extends/Object', () => {
     type T = { x: number; y: number } extends { x: number } ? 1 : 2
     const A = Type.Object({ x: Type.Number(), y: Type.Number() })
     const B = Type.Object({ x: Type.Number() })
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = { x: number } extends { x: number; y: number } ? 1 : 2
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ x: Type.Number(), y: Type.Number() })
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = { x: number; y: string } extends { x: number } ? 1 : 2
     const A = Type.Object({ x: Type.Number(), y: Type.String() })
     const B = Type.Object({ x: Type.Number() })
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 4', () => {
     type T = { x: number } extends { x: number; y: string } ? 1 : 2
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ x: Type.Number(), y: Type.String() })
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 5', () => {
     type T = { x: number | string } extends { x: number } ? 1 : 2
     const A = Type.Object({ x: Type.Union([Type.Number(), Type.String()]) })
     const B = Type.Object({ x: Type.Number() })
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 6', () => {
     type T = { x: number } extends { x: number | string } ? 1 : 2
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Object({ x: Type.Union([Type.Number(), Type.String()]) })
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   // ----------------------------------------------------------
   // Record
@@ -55,124 +54,124 @@ describe('type/extends/Object', () => {
     type T = { a: number; b: number } extends Record<string, number> ? 1 : 2
     const A = Type.Object({ a: Type.Number(), b: Type.Number() })
     const B = Type.Record(Type.String(), Type.Number())
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 3', () => {
     type T = { a: number; b: number } extends Record<number, number> ? 1 : 2
     const A = Type.Object({ a: Type.Number(), b: Type.Number() })
     const B = Type.Record(Type.Number(), Type.Number())
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 4', () => {
     type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Object({ a: Type.Number(), b: Type.Number() })
     const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 5', () => {
     type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Object({ a: Type.Number(), b: Type.Number() })
     const B = Type.Record(Type.String(), Type.Number())
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 6', () => {
     type T = { a: number; b: number } extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Object({ a: Type.Number(), b: Type.Number() })
     const B = Type.Record(Type.Number(), Type.Number())
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   // ----------------------------------------------------------
   // Standard
   // ----------------------------------------------------------
   it('Should extend Any', () => {
     type T = { a: number } extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = { a: number } extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = { a: number } extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = { a: number } extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = { a: number } extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = { a: number } extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = { a: number } extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = { a: number } extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Object({}, { additionalProperties: false }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = { a: number } extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Object({ a: Type.Literal(10) }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.Object({ a: Type.Literal(10) }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = { a: number } extends object ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 1', () => {
     type T = { a: number } extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Union([Type.Null(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.Union([Type.Null(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = { a: number } extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = { a: number } extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = { a: number } extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = { a: number } extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = { a: number } extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = { a: number } extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Object({ a: Type.Number() }), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Object({ a: Type.Number() }), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   // ----------------------------------------------------------------
   // Optional
@@ -180,14 +179,14 @@ describe('type/extends/Object', () => {
   it('Should extend optional 1', () => {
     const A = Type.Object({ a: Type.Number() })
     const B = Type.Object({ a: Type.Optional(Type.Number()) })
-    const C = TypeExtends.Extends(A, B)
-    Assert.IsEqual(C, TypeExtendsResult.True)
+    const C = ExtendsCheck(A, B)
+    Assert.IsEqual(C, ExtendsResult.True)
   })
   it('Should extend optional 2', () => {
     const A = Type.Object({ a: Type.Number() })
     const B = Type.Object({ a: Type.Optional(Type.Number()) })
-    const C = TypeExtends.Extends(B, A)
-    Assert.IsEqual(C, TypeExtendsResult.False)
+    const C = ExtendsCheck(B, A)
+    Assert.IsEqual(C, ExtendsResult.False)
   })
   it('Should extend optional 3', () => {
     const A = Type.Object({
@@ -198,8 +197,8 @@ describe('type/extends/Object', () => {
       y: Type.Number(),
       z: Type.Number(),
     })
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend optional 4', () => {
     const A = Type.Object({
@@ -210,8 +209,8 @@ describe('type/extends/Object', () => {
       y: Type.Number(),
       z: Type.Number(),
     })
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend optional 5', () => {
     const A = Type.Object({
@@ -222,7 +221,7 @@ describe('type/extends/Object', () => {
       y: Type.Number(),
       z: Type.Optional(Type.Number()),
     })
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
 })
diff --git a/test/runtime/type/extends/promise.ts b/test/runtime/type/extends/promise.ts
index 843786a64..2313c8738 100644
--- a/test/runtime/type/extends/promise.ts
+++ b/test/runtime/type/extends/promise.ts
@@ -1,5 +1,4 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Promise', () => {
@@ -8,203 +7,203 @@ describe('type/extends/Promise', () => {
   // ----------------------------------------------
   it('Should extend Promise Varying 1', () => {
     type T = Promise<any> extends Promise<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Promise(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Promise(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Promise Varying 2', () => {
     type T = Promise<string> extends Promise<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.String()), Type.Promise(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Promise(Type.String()), Type.Promise(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Promise Varying 3', () => {
     type T = Promise<any> extends Promise<string> ? 1 : 2 // 1
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Promise(Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Promise(Type.String()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Promise Varying 4', () => {
     type T = Promise<number> extends Promise<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Promise(Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Promise(Type.String()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   // ----------------------------------------------
   // Any
   // ----------------------------------------------
   it('Should extend Any', () => {
     type T = Promise<any> extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = Promise<any> extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = Promise<any> extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = Promise<any> extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = Promise<any> extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = Promise<any> extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = Promise<any> extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = Promise<any> extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = Promise<any> extends Record<number, any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Record(Type.Number(), Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = Promise<any> extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Object({}, { additionalProperties: false }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = Promise<any> extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = Promise<any> extends object ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 1', () => {
     type T = Promise<any> extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = Promise<any> extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = Promise<any> extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = Promise<any> extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = Promise<any> extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   // ----------------------------------------------
   // Constrained
   // ----------------------------------------------
   it('Should extend constrained Any', () => {
     type T = Promise<number> extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained Unknown', () => {
     type T = Promise<number> extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained String', () => {
     type T = Promise<number> extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Boolean', () => {
     type T = Promise<number> extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Number', () => {
     type T = Promise<number> extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Any()), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Any()), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Integer', () => {
     type T = Promise<number> extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Array', () => {
     type T = Promise<number> extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Tuple', () => {
     type T = Promise<number> extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Object 1', () => {
     type T = Promise<number> extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Object({}, { additionalProperties: false }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained Object 2', () => {
     type T = Promise<number> extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Object 3', () => {
     type T = Promise<number> extends object ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained Union 1', () => {
     type T = Promise<number> extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Union 2', () => {
     type T = Promise<number> extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend constrained Union 2', () => {
     type T = Promise<number> extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Null', () => {
     type T = Promise<number> extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend constrained Undefined', () => {
     type T = Promise<number> extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = Promise<number> extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = Promise<number> extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Promise(Type.Number()), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Promise(Type.Number()), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/record.ts b/test/runtime/type/extends/record.ts
index 7ac3301c2..905a96fcf 100644
--- a/test/runtime/type/extends/record.ts
+++ b/test/runtime/type/extends/record.ts
@@ -1,5 +1,4 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Record', () => {
@@ -7,194 +6,194 @@ describe('type/extends/Record', () => {
     type T = Record<'a' | 'b', number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 2', () => {
     type T = Record<string, number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record 3', () => {
     type T = Record<number, number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record 4', () => {
     type T = Record<'a' | 'b', number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 5', () => {
     type T = Record<'a' | 'b', number> extends { a: number; b: number } ? 1 : 2
     const A = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
     const B = Type.Object({ a: Type.Number(), b: Type.Number() })
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 6', () => {
     type T = Record<string, number> extends Record<'a' | 'b', number> ? true : false
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 7', () => {
     type T = Record<string, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Record(Type.String(), Type.Number())
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 8', () => {
     type T = Record<string, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Record(Type.Number(), Type.Number())
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 9', () => {
     type T = Record<number, number> extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
     const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record 10', () => {
     type T = Record<number, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
     const B = Type.Record(Type.String(), Type.Number())
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 11', () => {
     type T = Record<number, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.Number(), Type.Number())
     const B = Type.Record(Type.Number(), Type.Number())
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   // -----
   it('Should extend Record 12', () => {
     type T = Record<string, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.String(), Type.Number())
     const B = Type.Record(Type.Integer(), Type.Number())
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 13', () => {
     type T = Record<number, number> extends Record<'a' | 'b', number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
     const B = Type.Record(Type.Union([Type.Literal('a'), Type.Literal('b')]), Type.Number())
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record 14', () => {
     type T = Record<number, number> extends Record<string, number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
     const B = Type.Record(Type.String(), Type.Number())
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 15', () => {
     type T = Record<number, number> extends Record<number, number> ? 1 : 2
     const A = Type.Record(Type.Integer(), Type.Number())
     const B = Type.Record(Type.Integer(), Type.Number())
-    const R = TypeExtends.Extends(A, B)
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(A, B)
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   // -------------------------------------------------------------------
   // Standard
   // -------------------------------------------------------------------
   it('Should extend Any', () => {
     type T = Record<number, number> extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = Record<number, number> extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = Record<number, number> extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = Record<number, number> extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = Record<number, number> extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = Record<number, number> extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = Record<number, number> extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = Record<number, number> extends Array<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.Array(Type.String()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = Record<number, number> extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = Record<number, number> extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 3', () => {
     type T = Record<number, number> extends { a: number } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Object({ a: Type.Number() }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.Object({ a: Type.Number() }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = Record<number, number> extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = Record<number, number> extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Any(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.Union([Type.Any(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = Record<number, number> extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = Record<number, number> extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = Record<number, number> extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = Record<number, number> extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Record(Type.Number(), Type.Number()), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Record(Type.Number(), Type.Number()), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/regexp.ts b/test/runtime/type/extends/regexp.ts
new file mode 100644
index 000000000..2298acd23
--- /dev/null
+++ b/test/runtime/type/extends/regexp.ts
@@ -0,0 +1,113 @@
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+// ------------------------------------------------------------------
+// Note: RegExp infers as type String
+// ------------------------------------------------------------------
+describe('type/extends/RegExp', () => {
+  it('Should extend Any', () => {
+    type T = string extends any ? 1 : 2
+    const R = ExtendsCheck(Type.RegExp(/xyz/), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
+  })
+  it('Should extend Unknown', () => {
+    type T = string extends unknown ? 1 : 2
+    const R = ExtendsCheck(Type.RegExp(/xyz/), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
+  })
+  it('Should extend String', () => {
+    type T = string extends string ? 1 : 2
+    const R = ExtendsCheck(Type.RegExp(/xyz/), Type.RegExp(/xyz/))
+    Assert.IsEqual(R, ExtendsResult.True)
+  })
+  it('Should extend Boolean', () => {
+    type T = string extends boolean ? 1 : 2
+    const R = ExtendsCheck(Type.RegExp(/xyz/), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
+  })
+  it('Should extend Number', () => {
+    type T = string extends number ? 1 : 2
+    const R = ExtendsCheck(Type.RegExp(/xyz/), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
+  })
+  it('Should extend Integer', () => {
+    type T = string extends number ? 1 : 2
+    const R = ExtendsCheck(Type.RegExp(/xyz/), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
+  })
+  it('Should extend Array', () => {
+    type T = string extends Array<any> ? 1 : 2
+    const R = ExtendsCheck(Type.RegExp(/xyz/), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
+  })
+  it('Should extend Tuple', () => {
+    type T = string extends [number, number] ? 1 : 2
+    const R = ExtendsCheck(Type.RegExp(/xyz/), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
+  })
+  it('Should extend Record 1', () => {
+    type T = string extends Record<number, any> ? 1 : 2
+    const R = ExtendsCheck(Type.RegExp(/xyz/), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
+  })
+  it('Should extend Record 2', () => {
+    type T = string extends Record<number, unknown> ? 1 : 2
+    const R = ExtendsCheck(Type.RegExp(/xyz/), Type.Record(Type.Number(), Type.Unknown()))
+    Assert.IsEqual(R, ExtendsResult.True)
+  })
+  it('Should extend Record 3', () => {
+    type T = string extends Record<number, string> ? 1 : 2
+    const R = ExtendsCheck(Type.RegExp(/xyz/), Type.Record(Type.Number(), Type.RegExp(/xyz/)))
+    Assert.IsEqual(R, ExtendsResult.True)
+  })
+  it('Should extend Record 4', () => {
+    type T = string extends Record<number, number> ? 1 : 2
+    const R = ExtendsCheck(Type.RegExp(/xyz/), Type.Record(Type.Number(), Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.False)
+  })
+  it('Should extend Object 1', () => {
+    type T = string extends {} ? 1 : 2
+    const R = ExtendsCheck(Type.RegExp(/xyz/), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.True)
+  })
+  it('Should extend Object 2', () => {
+    type T = string extends { a: 10 } ? 1 : 2
+    const R = ExtendsCheck(Type.RegExp(/xyz/), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
+  })
+  it('Should extend Union 1', () => {
+    type T = number extends number | string ? 1 : 2
+    const R = ExtendsCheck(Type.Number(), Type.Union([Type.Number(), Type.RegExp(/xyz/)]))
+    Assert.IsEqual(R, ExtendsResult.True)
+  })
+  it('Should extend Union 2', () => {
+    type T = number extends any | number ? 1 : 2
+    const R = ExtendsCheck(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
+  })
+  it('Should extend Union 3', () => {
+    type T = number extends boolean | number ? 1 : 2
+    const R = ExtendsCheck(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
+  })
+  it('Should extend Null', () => {
+    type T = number extends null ? 1 : 2
+    const R = ExtendsCheck(Type.Number(), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
+  })
+  it('Should extend Undefined', () => {
+    type T = number extends undefined ? 1 : 2
+    const R = ExtendsCheck(Type.Number(), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
+  })
+  it('Should extend Void', () => {
+    type T = number extends void ? 1 : 2
+    const R = ExtendsCheck(Type.Number(), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
+  })
+  it('Should extend Date', () => {
+    type T = number extends Date ? 1 : 2
+    const R = ExtendsCheck(Type.Number(), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
+  })
+})
diff --git a/test/runtime/type/extends/string.ts b/test/runtime/type/extends/string.ts
index 0dd95ecbe..cdb3e216c 100644
--- a/test/runtime/type/extends/string.ts
+++ b/test/runtime/type/extends/string.ts
@@ -1,111 +1,110 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/String', () => {
   it('Should extend Any', () => {
     type T = string extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.String(), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = string extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.String(), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = string extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.String(), Type.String())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Boolean', () => {
     type T = string extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.String(), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = string extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.String(), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = string extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.String(), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = string extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.String(), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = string extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.String(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record 1', () => {
     type T = string extends Record<number, any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.String(), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 2', () => {
     type T = string extends Record<number, unknown> ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Unknown()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.String(), Type.Record(Type.Number(), Type.Unknown()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 3', () => {
     type T = string extends Record<number, string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.String(), Type.Record(Type.Number(), Type.String()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 4', () => {
     type T = string extends Record<number, number> ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.String(), Type.Record(Type.Number(), Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = string extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Object({}, { additionalProperties: false }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.String(), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = string extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.String(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = number extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Number(), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Number(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = number extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Number(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = number extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Number(), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = number extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Number(), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = number extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Number(), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = number extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Number(), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Number(), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/symbol.ts b/test/runtime/type/extends/symbol.ts
index 03dc7aaf0..9412f4fc8 100644
--- a/test/runtime/type/extends/symbol.ts
+++ b/test/runtime/type/extends/symbol.ts
@@ -1,106 +1,105 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Symbol', () => {
   it('Should extend Any', () => {
     type T = symbol extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Symbol(), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = symbol extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Symbol(), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = symbol extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Symbol(), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = symbol extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Symbol(), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = symbol extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Symbol(), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = symbol extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Symbol(), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = symbol extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Symbol(), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = symbol extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Symbol(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = symbol extends Record<number, any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Record(Type.Number(), Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Symbol(), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = symbol extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Symbol(), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = symbol extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Object({ a: Type.Literal(10) }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Symbol(), Type.Object({ a: Type.Literal(10) }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = symbol extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Symbol(), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = symbol extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Symbol(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = symbol extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Symbol(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 4', () => {
     type T = symbol extends boolean | symbol ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Union([Type.Boolean(), Type.Symbol()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Symbol(), Type.Union([Type.Boolean(), Type.Symbol()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = symbol extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Symbol(), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = symbol extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Symbol(), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = symbol extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Symbol(), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = symbol extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Symbol(), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Symbol', () => {
     type T = symbol extends symbol ? 1 : 2
-    const R = TypeExtends.Extends(Type.Symbol(), Type.Symbol())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Symbol(), Type.Symbol())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
 })
diff --git a/test/runtime/type/extends/template-literal.ts b/test/runtime/type/extends/template-literal.ts
index 3dd6ff3d2..1e8aeab12 100644
--- a/test/runtime/type/extends/template-literal.ts
+++ b/test/runtime/type/extends/template-literal.ts
@@ -1,5 +1,4 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/TemplateLiteral', () => {
@@ -8,155 +7,155 @@ describe('type/extends/TemplateLiteral', () => {
   // -------------------------------------------------------------------
   it('Should extend Any (hello)', () => {
     type T = 'hello' extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Literal('hello')]), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown (hello)', () => {
     type T = 'hello' extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Literal('hello')]), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String (hello)', () => {
     type T = 'hello' extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Literal('hello')]), Type.String())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Boolean (hello)', () => {
     type T = 'hello' extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Literal('hello')]), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number (hello)', () => {
     type T = 'hello' extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Literal('hello')]), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer (hello)', () => {
     type T = 'hello' extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Literal('hello')]), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array (hello)', () => {
     type T = 'hello' extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Literal('hello')]), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple (hello)', () => {
     type T = 'hello' extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Literal('hello')]), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1 (hello)', () => {
     type T = 'hello' extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Object({}, { additionalProperties: false }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Literal('hello')]), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2 (hello)', () => {
     type T = 'hello' extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Literal('hello')]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1 (hello)', () => {
     type T = 'hello' extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Literal('hello')]), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 2 (hello)', () => {
     type T = 'hello' extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Literal('hello')]), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3 (hello)', () => {
     type T = 'hello' extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Literal('hello')]), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Null (hello)', () => {
     type T = 'hello' extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Literal('hello')]), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined (hello)', () => {
     type T = 'hello' extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Literal('hello')]), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Literal('hello')]), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   // -------------------------------------------------------------------
   // String Literal 'hello' | 'world'
   // -------------------------------------------------------------------
   it('Should extend Any (hello | world)', () => {
     type T = 'hello' | 'world' extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown (hello | world)', () => {
     type T = 'hello' | 'world' extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String (hello | world)', () => {
     type T = 'hello' | 'world' extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.String())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Boolean (hello | world)', () => {
     type T = 'hello' | 'world' extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number (hello | world)', () => {
     type T = 'hello' | 'world' extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer (hello | world)', () => {
     type T = 'hello' | 'world' extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array (hello | world)', () => {
     type T = 'hello' | 'world' extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple (hello | world)', () => {
     type T = 'hello' | 'world' extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1 (hello | world)', () => {
     type T = 'hello' | 'world' extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Object({}, { additionalProperties: false }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2 (hello | world)', () => {
     type T = 'hello' | 'world' extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1 (hello | world)', () => {
     type T = 'hello' | 'world' extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 2 (hello | world)', () => {
     type T = 'hello' | 'world' extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3 (hello | world)', () => {
     type T = 'hello' | 'world' extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Null (hello | world)', () => {
     type T = 'hello' | 'world' extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined (hello | world)', () => {
     type T = 'hello' | 'world' extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.TemplateLiteral([Type.Union([Type.Literal('hello'), Type.Literal('world')])]), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/tuple.ts b/test/runtime/type/extends/tuple.ts
index b297655ab..99bc36033 100644
--- a/test/runtime/type/extends/tuple.ts
+++ b/test/runtime/type/extends/tuple.ts
@@ -1,161 +1,160 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Tuple', () => {
   it('Should extend Any', () => {
     type T = [string, number] extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = [string, number] extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = [string, number] extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = [string, number] extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = [string, number] extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = [string, number] extends Array<any> ? 1 : 2 // 1
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Array 2', () => {
     type T = [string, number] extends Array<string> ? 1 : 2 // 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.String()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 3', () => {
     type T = [string, number] extends Array<string | number> ? 1 : 2 // 1
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Union([Type.String(), Type.Number()])))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Union([Type.String(), Type.Number()])))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Array 4', () => {
     type T = [string, number] extends Array<string | number | boolean> ? 1 : 2 // 1
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Union([Type.String(), Type.Number(), Type.Boolean()])))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Array(Type.Union([Type.String(), Type.Number(), Type.Boolean()])))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Tuple 1', () => {
     type T = [string, number] extends [string, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Tuple 2', () => {
     type T = [string, number] extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple 3', () => {
     type T = [string, any] extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Any()]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Any()]), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple 4', () => {
     type T = [string, number] extends [string, any] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Any()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Any()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Tuple 5', () => {
     type T = [string, unknown] extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Unknown()]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Unknown()]), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple 6', () => {
     type T = [string, number] extends [string, unknown] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Unknown()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([Type.String(), Type.Unknown()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Tuple 7', () => {
     type T = [] extends [string, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([]), Type.Tuple([Type.String(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([]), Type.Tuple([Type.String(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple 8', () => {
     type T = [string, number] extends [] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Tuple([]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record 1', () => {
     type T = [string, number] extends Record<number, any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.String(), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 2', () => {
     type T = [string, number] extends Record<number, unknown> ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Unknown()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.String(), Type.Record(Type.Number(), Type.Unknown()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 3', () => {
     type T = [string, number] extends Record<number, string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.String(), Type.Record(Type.Number(), Type.String()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Record 4', () => {
     type T = [string, number] extends Record<number, number> ? 1 : 2
-    const R = TypeExtends.Extends(Type.String(), Type.Record(Type.Number(), Type.Number()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.String(), Type.Record(Type.Number(), Type.Number()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = [string, number] extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Object({}, { additionalProperties: false }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = [string, number] extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = [string, number] extends object ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 1', () => {
     type T = [string, number] extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = [string, number] extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = [string, number] extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = [string, number] extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = [string, number] extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = [string, number] extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = [string, number] extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Tuple([Type.String(), Type.Number()]), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Tuple([Type.String(), Type.Number()]), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/uint8array.ts b/test/runtime/type/extends/uint8array.ts
index 828163dd1..0128fb0cb 100644
--- a/test/runtime/type/extends/uint8array.ts
+++ b/test/runtime/type/extends/uint8array.ts
@@ -1,96 +1,95 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Uint8Array', () => {
   it('Should extend Any', () => {
     type T = Uint8Array extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = Uint8Array extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = Uint8Array extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = Uint8Array extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = Uint8Array extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = Uint8Array extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = Uint8Array extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = Uint8Array extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Record', () => {
     type T = Uint8Array extends Record<number, any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Record(Type.Number(), Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Record(Type.Number(), Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 1', () => {
     type T = Uint8Array extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Object({}, { additionalProperties: false }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = Uint8Array extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = Uint8Array extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = Uint8Array extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = Uint8Array extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = Uint8Array extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = Uint8Array extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = Uint8Array extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = Uint8Array extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Uint8Array(), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Uint8Array(), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/undefined.ts b/test/runtime/type/extends/undefined.ts
index 664126124..4996a1054 100644
--- a/test/runtime/type/extends/undefined.ts
+++ b/test/runtime/type/extends/undefined.ts
@@ -1,91 +1,90 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Undefined', () => {
   it('Should extend Any', () => {
     type T = undefined extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Undefined(), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = undefined extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Undefined(), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = undefined extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Undefined(), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = undefined extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Undefined(), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = undefined extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Undefined(), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = undefined extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Undefined(), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = undefined extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Undefined(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = undefined extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.Object({}, { additionalProperties: false }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Undefined(), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = undefined extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Undefined(), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = undefined extends object ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Undefined(), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = undefined extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Undefined(), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = undefined extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Undefined(), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = undefined extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Undefined(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = undefined extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Undefined(), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = undefined extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Undefined(), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Void', () => {
     type T = undefined extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Undefined(), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Date', () => {
     type T = undefined extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Undefined(), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Undefined(), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/union.ts b/test/runtime/type/extends/union.ts
index e9eb05cef..39783cff9 100644
--- a/test/runtime/type/extends/union.ts
+++ b/test/runtime/type/extends/union.ts
@@ -1,136 +1,135 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Union', () => {
   it('Should extend Any', () => {
     type T = number | string extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = number | string extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = number | string extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = number | string extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = number | string extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array', () => {
     type T = number | string extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = number | string extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = number | string extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Object({}, { additionalProperties: false }))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.Object({}, { additionalProperties: false }))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Object 2', () => {
     type T = number | string extends { a: 10 } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.Object({ a: Type.Literal(10) }, { additionalProperties: true }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = number | string extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 2', () => {
     type T = number | string extends any | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Any(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Any(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = number | string extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 4', () => {
     type T = any | boolean extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Union 5', () => {
     type T = any | string extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Union 6', () => {
     type T = any | {} extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Union 7', () => {
     type T = any extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.Union)
+    const R = ExtendsCheck(Type.Any(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.Union)
   })
   it('Should extend Union 8', () => {
     type T = unknown | string extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Unknown(), Type.String()]), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.Unknown(), Type.String()]), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 9', () => {
     type T = unknown extends boolean | number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Boolean(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.Union([Type.Boolean(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Null', () => {
     type T = number | string extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = number | string extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = number | string extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void 2', () => {
     type T = number | string | void extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = number | string | void extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Number(), Type.String()]), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.Number(), Type.String()]), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date 2', () => {
     type T = Date | number | string | void extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Date(), Type.Number(), Type.String()]), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.Date(), Type.Number(), Type.String()]), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend BigInt', () => {
     type T = bigint | number | string | void extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.BigInt(), Type.Number(), Type.String()]), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.BigInt(), Type.Number(), Type.String()]), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Symbol', () => {
     type T = symbol | number | string | void extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Union([Type.Symbol(), Type.Number(), Type.String()]), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Union([Type.Symbol(), Type.Number(), Type.String()]), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/unknown.ts b/test/runtime/type/extends/unknown.ts
index 85dbf8654..7622dbfdd 100644
--- a/test/runtime/type/extends/unknown.ts
+++ b/test/runtime/type/extends/unknown.ts
@@ -1,101 +1,100 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Unknown', () => {
   it('Should extend Any', () => {
     type T = unknown extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Unknown(), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = unknown extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Unknown(), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = unknown extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = unknown extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = unknown extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = unknown extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = unknown extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = unknown extends Array<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Array(Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.Array(Type.String()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = unknown extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = unknown extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = unknown extends { a: number } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Object({ a: Type.Number() }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.Object({ a: Type.Number() }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = unknown extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = unknown extends any | number ? 1 : 2 // 1
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Any(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Unknown(), Type.Union([Type.Any(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = unknown extends unknown | number ? 1 : 2 // 1
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Unknown(), Type.Union([Type.Unknown(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = unknown extends unknown | any ? 1 : 2 // 1
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Unknown(), Type.Union([Type.Unknown(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = unknown extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = unknown extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = unknown extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Date', () => {
     type T = unknown extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Unknown(), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Unknown(), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/extends/void.ts b/test/runtime/type/extends/void.ts
index 106e1759e..48efc644e 100644
--- a/test/runtime/type/extends/void.ts
+++ b/test/runtime/type/extends/void.ts
@@ -1,106 +1,105 @@
-import { TypeExtends, TypeExtendsResult } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, ExtendsCheck, ExtendsResult } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/extends/Void', () => {
   it('Should extend Any', () => {
     type T = void extends any ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.Any())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Void(), Type.Any())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Unknown', () => {
     type T = void extends unknown ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.Unknown())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Void(), Type.Unknown())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend String', () => {
     type T = void extends string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.String())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Void(), Type.String())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Boolean', () => {
     type T = void extends boolean ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.Boolean())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Void(), Type.Boolean())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Number', () => {
     type T = void extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.Number())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Void(), Type.Number())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Integer', () => {
     type T = void extends number ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.Integer())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Void(), Type.Integer())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 1', () => {
     type T = void extends Array<any> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.Array(Type.Any()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Void(), Type.Array(Type.Any()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Array 2', () => {
     type T = void extends Array<string> ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.Array(Type.String()))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Void(), Type.Array(Type.String()))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Tuple', () => {
     type T = void extends [number, number] ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.Tuple([Type.Number(), Type.Number()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Void(), Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 1', () => {
     type T = void extends object ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Void(), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 2', () => {
     type T = void extends {} ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.Object({}))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Void(), Type.Object({}))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Object 3', () => {
     type T = void extends { a: number } ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.Object({ a: Type.Number() }))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Void(), Type.Object({ a: Type.Number() }))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 1', () => {
     type T = void extends number | string ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Number(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Void(), Type.Union([Type.Number(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Union 2', () => {
     type T = void extends any | number ? 1 : 2 // 1
-    const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Any(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Void(), Type.Union([Type.Any(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 3', () => {
     type T = void extends unknown | number ? 1 : 2 // 1
-    const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Void(), Type.Union([Type.Unknown(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Union 4', () => {
     type T = void extends unknown | any ? 1 : 2 // 1
-    const R = TypeExtends.Extends(Type.Void(), Type.Union([Type.Unknown(), Type.String()]))
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Void(), Type.Union([Type.Unknown(), Type.String()]))
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Null', () => {
     type T = void extends null ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.Null())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Void(), Type.Null())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Undefined', () => {
     type T = void extends undefined ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.Undefined())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Void(), Type.Undefined())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
   it('Should extend Void', () => {
     type T = void extends void ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.Void())
-    Assert.IsEqual(R, TypeExtendsResult.True)
+    const R = ExtendsCheck(Type.Void(), Type.Void())
+    Assert.IsEqual(R, ExtendsResult.True)
   })
   it('Should extend Date', () => {
     type T = void extends Date ? 1 : 2
-    const R = TypeExtends.Extends(Type.Void(), Type.Date())
-    Assert.IsEqual(R, TypeExtendsResult.False)
+    const R = ExtendsCheck(Type.Void(), Type.Date())
+    Assert.IsEqual(R, ExtendsResult.False)
   })
 })
diff --git a/test/runtime/type/guard/any.ts b/test/runtime/type/guard/any.ts
index bb35ccc03..ecc4cc92b 100644
--- a/test/runtime/type/guard/any.ts
+++ b/test/runtime/type/guard/any.ts
@@ -4,16 +4,16 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TAny', () => {
   it('Should guard for TAny', () => {
-    const R = TypeGuard.TAny(Type.Any())
+    const R = TypeGuard.IsAny(Type.Any())
     Assert.IsTrue(R)
   })
   it('Should not guard for TAny', () => {
-    const R = TypeGuard.TAny(null)
+    const R = TypeGuard.IsAny(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TAny with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TAny(Type.Any({ $id: 1 }))
+    const R = TypeGuard.IsAny(Type.Any({ $id: 1 }))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/array.ts b/test/runtime/type/guard/array.ts
index 95b0063aa..12f0a9e20 100644
--- a/test/runtime/type/guard/array.ts
+++ b/test/runtime/type/guard/array.ts
@@ -4,15 +4,15 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TArray', () => {
   it('Should guard for TArray', () => {
-    const R = TypeGuard.TArray(Type.Array(Type.Number()))
+    const R = TypeGuard.IsArray(Type.Array(Type.Number()))
     Assert.IsTrue(R)
   })
   it('Should not guard for TArray', () => {
-    const R = TypeGuard.TArray(null)
+    const R = TypeGuard.IsArray(null)
     Assert.IsFalse(R)
   })
   it('Should guard for nested object TArray', () => {
-    const R = TypeGuard.TArray(
+    const R = TypeGuard.IsArray(
       Type.Array(
         Type.Object({
           x: Type.Number(),
@@ -23,7 +23,7 @@ describe('type/guard/TArray', () => {
     Assert.IsTrue(R)
   })
   it('Should not guard for nested object TArray', () => {
-    const R = TypeGuard.TArray(
+    const R = TypeGuard.IsArray(
       Type.Array(
         Type.Object({
           x: Type.Number(),
@@ -35,22 +35,22 @@ describe('type/guard/TArray', () => {
   })
   it('Should not guard for TArray with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TArray(Type.Array(Type.Number(), { $id: 1 }))
+    const R = TypeGuard.IsArray(Type.Array(Type.Number(), { $id: 1 }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TArray with invalid minItems', () => {
     // @ts-ignore
-    const R = TypeGuard.TArray(Type.Array(Type.String(), { minItems: '1' }))
+    const R = TypeGuard.IsArray(Type.Array(Type.String(), { minItems: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TArray with invalid maxItems', () => {
     // @ts-ignore
-    const R = TypeGuard.TArray(Type.Array(Type.String(), { maxItems: '1' }))
+    const R = TypeGuard.IsArray(Type.Array(Type.String(), { maxItems: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TArray with invalid uniqueItems', () => {
     // @ts-ignore
-    const R = TypeGuard.TArray(Type.Array(Type.String(), { uniqueItems: '1' }))
+    const R = TypeGuard.IsArray(Type.Array(Type.String(), { uniqueItems: '1' }))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/async-iterator.ts b/test/runtime/type/guard/async-iterator.ts
index 8b3567e5b..55a52da32 100644
--- a/test/runtime/type/guard/async-iterator.ts
+++ b/test/runtime/type/guard/async-iterator.ts
@@ -5,18 +5,18 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TAsyncIterator', () => {
   it('Should guard for TAsyncIterator', () => {
     const T = Type.AsyncIterator(Type.Any())
-    const R = TypeGuard.TAsyncIterator(T)
+    const R = TypeGuard.IsAsyncIterator(T)
     Assert.IsTrue(R)
   })
   it('Should not guard for TAsyncIterator', () => {
     const T = null
-    const R = TypeGuard.TAsyncIterator(T)
+    const R = TypeGuard.IsAsyncIterator(T)
     Assert.IsFalse(R)
   })
   it('Should not guard for TAsyncIterator with invalid $id', () => {
     //@ts-ignore
     const T = Type.AsyncIterator(Type.Any(), { $id: 1 })
-    const R = TypeGuard.TAsyncIterator(T)
+    const R = TypeGuard.IsAsyncIterator(T)
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/awaited.ts b/test/runtime/type/guard/awaited.ts
index ef535a9ef..7515107a7 100644
--- a/test/runtime/type/guard/awaited.ts
+++ b/test/runtime/type/guard/awaited.ts
@@ -5,37 +5,37 @@ import { Assert } from '../../assert/index'
 describe('type/guard/Awaited', () => {
   it('Should guard for Awaited 1', () => {
     const T = Type.Awaited(Type.String())
-    const R = TypeGuard.TString(T)
+    const R = TypeGuard.IsString(T)
     Assert.IsTrue(R)
   })
   it('Should guard for Awaited 2', () => {
     const T = Type.Awaited(Type.Promise(Type.String()))
-    const R = TypeGuard.TString(T)
+    const R = TypeGuard.IsString(T)
     Assert.IsTrue(R)
   })
   it('Should guard for Awaited 3', () => {
     const T = Type.Awaited(Type.Awaited(Type.Promise(Type.String())))
-    const R = TypeGuard.TString(T)
+    const R = TypeGuard.IsString(T)
     Assert.IsTrue(R)
   })
   it('Should guard for Awaited 4', () => {
     const T = Type.Awaited(Type.Union([Type.Promise(Type.Promise(Type.String()))]))
-    Assert.IsTrue(TypeGuard.TString(T))
+    Assert.IsTrue(TypeGuard.IsString(T))
   })
   it('Should guard for Awaited 5', () => {
     const T = Type.Awaited(Type.Union([Type.Promise(Type.Promise(Type.String())), Type.Number()]))
-    Assert.IsTrue(TypeGuard.TUnion(T))
-    Assert.IsTrue(TypeGuard.TString(T.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TNumber(T.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(T))
+    Assert.IsTrue(TypeGuard.IsString(T.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsNumber(T.anyOf[1]))
   })
   it('Should guard for Awaited 6', () => {
     const T = Type.Awaited(Type.Intersect([Type.Promise(Type.Promise(Type.String()))]))
-    Assert.IsTrue(TypeGuard.TString(T))
+    Assert.IsTrue(TypeGuard.IsString(T))
   })
   it('Should guard for Awaited 7', () => {
     const T = Type.Awaited(Type.Intersect([Type.Promise(Type.Promise(Type.String())), Type.Number()]))
-    Assert.IsTrue(TypeGuard.TIntersect(T))
-    Assert.IsTrue(TypeGuard.TString(T.allOf[0]))
-    Assert.IsTrue(TypeGuard.TNumber(T.allOf[1]))
+    Assert.IsTrue(TypeGuard.IsIntersect(T))
+    Assert.IsTrue(TypeGuard.IsString(T.allOf[0]))
+    Assert.IsTrue(TypeGuard.IsNumber(T.allOf[1]))
   })
 })
diff --git a/test/runtime/type/guard/bigint.ts b/test/runtime/type/guard/bigint.ts
index bc16722a0..ae7edab9f 100644
--- a/test/runtime/type/guard/bigint.ts
+++ b/test/runtime/type/guard/bigint.ts
@@ -4,16 +4,16 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TBigInt', () => {
   it('Should guard for TBigInt', () => {
-    const R = TypeGuard.TBigInt(Type.BigInt())
+    const R = TypeGuard.IsBigInt(Type.BigInt())
     Assert.IsTrue(R)
   })
   it('Should not guard for TBigInt', () => {
-    const R = TypeGuard.TBigInt(null)
+    const R = TypeGuard.IsBigInt(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for BigInt with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TBigInt(Type.BigInt({ $id: 1 }))
+    const R = TypeGuard.IsBigInt(Type.BigInt({ $id: 1 }))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/boolean.ts b/test/runtime/type/guard/boolean.ts
index ecc50b90d..e74af2e16 100644
--- a/test/runtime/type/guard/boolean.ts
+++ b/test/runtime/type/guard/boolean.ts
@@ -4,16 +4,16 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TBoolean', () => {
   it('Should guard for TBoolean', () => {
-    const R = TypeGuard.TBoolean(Type.Boolean())
+    const R = TypeGuard.IsBoolean(Type.Boolean())
     Assert.IsTrue(R)
   })
   it('Should not guard for TBoolean', () => {
-    const R = TypeGuard.TBoolean(null)
+    const R = TypeGuard.IsBoolean(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TBoolean with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TBoolean(Type.Boolean({ $id: 1 }))
+    const R = TypeGuard.IsBoolean(Type.Boolean({ $id: 1 }))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/capitalize.ts b/test/runtime/type/guard/capitalize.ts
index 33ed2e9a8..def31e727 100644
--- a/test/runtime/type/guard/capitalize.ts
+++ b/test/runtime/type/guard/capitalize.ts
@@ -4,30 +4,30 @@ import { Assert } from '../../assert/index'
 describe('type/guard/Capitalize', () => {
   it('Should guard for Capitalize 1', () => {
     const T = Type.Capitalize(Type.Literal('hello'), { $id: 'hello', foo: 1 })
-    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
     Assert.IsEqual(T.const, 'Hello')
     Assert.IsEqual(T.$id, 'hello')
     Assert.IsEqual(T.foo, 1)
   })
   it('Should guard for Capitalize 2', () => {
     const T = Type.Capitalize(Type.Literal('hello'))
-    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
     Assert.IsEqual(T.const, 'Hello')
   })
   it('Should guard for Capitalize 3', () => {
     const T = Type.Capitalize(Type.Union([Type.Literal('hello'), Type.Literal('world')]))
-    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsEqual(T.anyOf[0].const, 'Hello')
     Assert.IsEqual(T.anyOf[1].const, 'World')
   })
   it('Should guard for Capitalize 4', () => {
     const T = Type.Capitalize(Type.TemplateLiteral('hello${0|1}'))
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(Hello0|Hello1)$')
   })
   it('Should guard for Capitalize 5', () => {
     const T = Type.Capitalize(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(0), Type.Literal(1)])]))
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(Hello0|Hello1)$')
   })
 })
diff --git a/test/runtime/type/guard/composite.ts b/test/runtime/type/guard/composite.ts
index 7d4fc1f4b..e8a3f21ac 100644
--- a/test/runtime/type/guard/composite.ts
+++ b/test/runtime/type/guard/composite.ts
@@ -5,20 +5,20 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TComposite', () => {
   it('Should guard for distinct properties', () => {
     const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.x))
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.y))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
   })
   it('Should guard for overlapping properties', () => {
     const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.Number() })])
-    Assert.IsTrue(TypeGuard.TIntersect(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsIntersect(T.properties.x))
     // @ts-ignore
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.x.allOf[0]))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.x.allOf[0]))
     // @ts-ignore
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.x.allOf[1]))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.x.allOf[1]))
   })
   it('Should not produce optional property if all properties are not optional', () => {
     const T = Type.Composite([Type.Object({ x: Type.Optional(Type.Number()) }), Type.Object({ x: Type.Number() })])
-    Assert.IsFalse(TypeGuard.TOptional(T.properties.x))
+    Assert.IsFalse(TypeGuard.IsOptional(T.properties.x))
   })
   // Note for: https://github.com/sinclairzx81/typebox/issues/419
   // Determining if a composite property is optional requires a deep check for all properties gathered during a indexed access
@@ -33,7 +33,7 @@ describe('type/guard/TComposite', () => {
       Type.Object({ x: Type.Optional(Type.Number()) }), 
       Type.Object({ x: Type.Optional(Type.Number()) })
     ])
-    Assert.IsTrue(TypeGuard.TOptional(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsOptional(T.properties.x))
     Assert.IsEqual(T.required, undefined)
   })
   it('Should produce required property if some composited properties are not optional', () => {
@@ -42,7 +42,7 @@ describe('type/guard/TComposite', () => {
       Type.Object({ x: Type.Optional(Type.Number()) }), 
       Type.Object({ x: Type.Number() })
     ])
-    Assert.IsFalse(TypeGuard.TOptional(T.properties.x))
+    Assert.IsFalse(TypeGuard.IsOptional(T.properties.x))
     Assert.IsTrue(T.required!.includes('x'))
   })
   it('Should preserve single optional property', () => {
@@ -50,7 +50,7 @@ describe('type/guard/TComposite', () => {
     const T = Type.Composite([
       Type.Object({ x: Type.Optional(Type.Number()) }), 
     ])
-    Assert.IsTrue(TypeGuard.TOptional(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsOptional(T.properties.x))
     Assert.IsEqual(T.required, undefined)
   })
 })
diff --git a/test/runtime/type/guard/const.ts b/test/runtime/type/guard/const.ts
new file mode 100644
index 000000000..0e5ad4288
--- /dev/null
+++ b/test/runtime/type/guard/const.ts
@@ -0,0 +1,124 @@
+import { TypeGuard, ValueGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TConstT', () => {
+  // ----------------------------------------------------------------
+  // Identity Types
+  // ----------------------------------------------------------------
+  it('Should guard for TConst 1', () => {
+    const T = Type.Const(undefined)
+    Assert.IsFalse(TypeGuard.IsReadonly(T))
+    Assert.IsTrue(TypeGuard.IsUndefined(T))
+  })
+  it('Should guard for TConst 2', () => {
+    const T = Type.Const(null)
+    Assert.IsFalse(TypeGuard.IsReadonly(T))
+    Assert.IsTrue(TypeGuard.IsNull(T))
+  })
+  it('Should guard for TConst 3', () => {
+    const T = Type.Const(Symbol())
+    Assert.IsFalse(TypeGuard.IsReadonly(T))
+    Assert.IsTrue(TypeGuard.IsSymbol(T))
+  })
+  it('Should guard for TConst 4', () => {
+    const T = Type.Const(1 as const)
+    Assert.IsFalse(TypeGuard.IsReadonly(T))
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
+    Assert.IsEqual(T.const, 1)
+  })
+  it('Should guard for TConst 5', () => {
+    const T = Type.Const('hello' as const)
+    Assert.IsFalse(TypeGuard.IsReadonly(T))
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
+    Assert.IsEqual(T.const, 'hello')
+  })
+  it('Should guard for TConst 6', () => {
+    const T = Type.Const(true as const)
+    Assert.IsFalse(TypeGuard.IsReadonly(T))
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
+    Assert.IsEqual(T.const, true)
+  })
+  // ----------------------------------------------------------------
+  // Complex Types
+  // ----------------------------------------------------------------
+  it('Should guard for TConst 7', () => {
+    const T = Type.Const(100n as const)
+    Assert.IsFalse(TypeGuard.IsReadonly(T))
+    // TS disparity because TLiteral does not support Bigint
+    Assert.IsTrue(TypeGuard.IsBigInt(T))
+  })
+  it('Should guard for TConst 8', () => {
+    const T = Type.Const(new Date())
+    Assert.IsFalse(TypeGuard.IsReadonly(T))
+    Assert.IsTrue(TypeGuard.IsDate(T))
+  })
+  it('Should guard for TConst 9', () => {
+    const T = Type.Const(new Uint8Array())
+    Assert.IsFalse(TypeGuard.IsReadonly(T))
+    Assert.IsTrue(TypeGuard.IsUint8Array(T))
+  })
+  it('Should guard for TConst 10', () => {
+    const T = Type.Const(function () {})
+    Assert.IsFalse(TypeGuard.IsReadonly(T))
+    Assert.IsTrue(TypeGuard.IsFunction(T))
+    Assert.IsTrue(T.parameters.length === 0)
+    Assert.IsTrue(TypeGuard.IsUnknown(T.returns))
+  })
+  it('Should guard for TConst 11', () => {
+    const T = Type.Const(new (class {})())
+    Assert.IsFalse(TypeGuard.IsReadonly(T))
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    // Object types that are neither Date or Uint8Array evaluate as empty objects
+    Assert.IsEqual(T.properties, {})
+  })
+  it('Should guard for TConst 12', () => {
+    const T = Type.Const((function* (): any {})())
+    const R = ValueGuard.IsIterator((function* (): any {})())
+    Assert.IsFalse(TypeGuard.IsReadonly(T))
+    Assert.IsTrue(TypeGuard.IsAny(T))
+  })
+  it('Should guard for TConst 13', () => {
+    const T = Type.Const((async function* (): any {})())
+    const R = ValueGuard.IsAsyncIterator((function* (): any {})())
+    Assert.IsFalse(TypeGuard.IsReadonly(T))
+    Assert.IsTrue(TypeGuard.IsAny(T))
+  })
+  it('Should guard for TConst 14', () => {
+    const T = Type.Const({
+      x: 1,
+      y: {
+        z: 2,
+      },
+    } as const)
+    // root
+    Assert.IsFalse(TypeGuard.IsReadonly(T))
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    // x
+    Assert.IsTrue(TypeGuard.IsLiteral(T.properties.x))
+    Assert.IsEqual(T.properties.x.const, 1)
+    // y
+    Assert.IsTrue(TypeGuard.IsReadonly(T.properties.y))
+    Assert.IsTrue(TypeGuard.IsObject(T.properties.y))
+    // y.z
+    Assert.IsTrue(TypeGuard.IsReadonly(T.properties.y.properties.z))
+    Assert.IsTrue(TypeGuard.IsLiteral(T.properties.y.properties.z))
+    Assert.IsEqual(T.properties.y.properties.z.const, 2)
+  })
+  it('Should guard for TConst 15', () => {
+    const T = Type.Const([1, 2, 3] as const)
+    // root (arrays are always readonly as root)
+    Assert.IsTrue(TypeGuard.IsReadonly(T))
+    Assert.IsTrue(TypeGuard.IsTuple(T))
+    Assert.IsTrue(T.items?.length === 3)
+    // 0
+    Assert.IsFalse(TypeGuard.IsReadonly(T.items![0]))
+    Assert.IsTrue(TypeGuard.IsLiteral(T.items![0]))
+    // 1
+    Assert.IsFalse(TypeGuard.IsReadonly(T.items![1]))
+    Assert.IsTrue(TypeGuard.IsLiteral(T.items![1]))
+    // 2
+    Assert.IsFalse(TypeGuard.IsReadonly(T.items![2]))
+    Assert.IsTrue(TypeGuard.IsLiteral(T.items![2]))
+  })
+})
diff --git a/test/runtime/type/guard/constructor.ts b/test/runtime/type/guard/constructor.ts
index 967d04c1b..bcbb78aa6 100644
--- a/test/runtime/type/guard/constructor.ts
+++ b/test/runtime/type/guard/constructor.ts
@@ -4,32 +4,32 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TConstructor', () => {
   it('Should guard for TConstructor', () => {
-    const R = TypeGuard.TConstructor(Type.Constructor([], Type.Number()))
+    const R = TypeGuard.IsConstructor(Type.Constructor([], Type.Number()))
     Assert.IsTrue(R)
   })
   it('Should not guard for TConstructor', () => {
-    const R = TypeGuard.TConstructor(null)
+    const R = TypeGuard.IsConstructor(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TConstructor with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TConstructor(Type.Constructor([], Type.Number(), { $id: 1 }))
+    const R = TypeGuard.IsConstructor(Type.Constructor([], Type.Number(), { $id: 1 }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TConstructor with invalid Params', () => {
-    const R = TypeGuard.TConstructor(Type.Constructor([{} as any, {} as any], Type.Number()))
+    const R = TypeGuard.IsConstructor(Type.Constructor([{} as any, {} as any], Type.Number()))
     Assert.IsFalse(R)
   })
   it('Should not guard for TConstructor with invalid Return', () => {
-    const R = TypeGuard.TConstructor(Type.Constructor([], {} as any))
+    const R = TypeGuard.IsConstructor(Type.Constructor([], {} as any))
     Assert.IsFalse(R)
   })
   it('Should guard for TConstructor with empty Rest Tuple', () => {
-    const R = TypeGuard.TConstructor(Type.Constructor(Type.Rest(Type.Tuple([])), Type.Number()))
+    const R = TypeGuard.IsConstructor(Type.Constructor(Type.Rest(Type.Tuple([])), Type.Number()))
     Assert.IsTrue(R)
   })
   it('Should guard for TConstructor with Rest Tuple', () => {
-    const R = TypeGuard.TConstructor(Type.Constructor(Type.Rest(Type.Tuple([Type.Number(), Type.String()])), Type.Number()))
+    const R = TypeGuard.IsConstructor(Type.Constructor(Type.Rest(Type.Tuple([Type.Number(), Type.String()])), Type.Number()))
     Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/guard/date.ts b/test/runtime/type/guard/date.ts
index a9534a4ab..fdfc720e2 100644
--- a/test/runtime/type/guard/date.ts
+++ b/test/runtime/type/guard/date.ts
@@ -4,41 +4,41 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TDate', () => {
   it('Should guard for TDate', () => {
-    const R = TypeGuard.TDate(Type.Date())
+    const R = TypeGuard.IsDate(Type.Date())
     Assert.IsTrue(R)
   })
   it('Should not guard for TDate', () => {
-    const R = TypeGuard.TDate(null)
+    const R = TypeGuard.IsDate(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TDate with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TDate(Type.Date({ $id: 1 }))
+    const R = TypeGuard.IsDate(Type.Date({ $id: 1 }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TDate with invalid exclusiveMaximumTimestamp', () => {
     // @ts-ignore
-    const R = TypeGuard.TDate(Type.Date({ exclusiveMaximumTimestamp: '1' }))
+    const R = TypeGuard.IsDate(Type.Date({ exclusiveMaximumTimestamp: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TDate with invalid exclusiveMinimumTimestamp', () => {
     // @ts-ignore
-    const R = TypeGuard.TDate(Type.Date({ exclusiveMinimumTimestamp: '1' }))
+    const R = TypeGuard.IsDate(Type.Date({ exclusiveMinimumTimestamp: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TDate with invalid maximumTimestamp', () => {
     // @ts-ignore
-    const R = TypeGuard.TDate(Type.Date({ maximumTimestamp: '1' }))
+    const R = TypeGuard.IsDate(Type.Date({ maximumTimestamp: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TDate with invalid minimumTimestamp', () => {
     // @ts-ignore
-    const R = TypeGuard.TDate(Type.Date({ minimumTimestamp: '1' }))
+    const R = TypeGuard.IsDate(Type.Date({ minimumTimestamp: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TDate with invalid multipleOfTimestamp', () => {
     // @ts-ignore
-    const R = TypeGuard.TDate(Type.Date({ multipleOfTimestamp: '1' }))
+    const R = TypeGuard.IsDate(Type.Date({ multipleOfTimestamp: '1' }))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/deref.ts b/test/runtime/type/guard/deref.ts
new file mode 100644
index 000000000..eedd3a652
--- /dev/null
+++ b/test/runtime/type/guard/deref.ts
@@ -0,0 +1,110 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TDeref', () => {
+  it('Should should deref 1', () => {
+    const T = Type.String({ $id: 'T' })
+    const R = Type.Ref(T)
+    const D = Type.Deref(R, [T])
+    Assert.IsTrue(TypeGuard.IsString(D))
+    Assert.IsFalse('$id' in D)
+  })
+  it('Should should deref 2', () => {
+    const T = Type.String({ $id: 'T' })
+    const R = Type.Ref(T)
+    const O = Type.Object({
+      x: R,
+      y: R,
+    })
+    const D = Type.Deref(O, [T])
+    Assert.IsTrue(TypeGuard.IsObject(D))
+    Assert.IsTrue(TypeGuard.IsString(D.properties.x))
+    Assert.IsTrue(TypeGuard.IsString(D.properties.y))
+    Assert.IsFalse('$id' in D.properties.x)
+    Assert.IsFalse('$id' in D.properties.y)
+  })
+  it('Should should deref 3', () => {
+    const T = Type.String({ $id: 'T' })
+    const R = Type.Ref(T)
+    const O = Type.Array(R)
+    const D = Type.Deref(O, [T])
+    Assert.IsTrue(TypeGuard.IsArray(D))
+    Assert.IsTrue(TypeGuard.IsString(D.items))
+    Assert.IsFalse('$id' in D.items)
+  })
+  it('Should should deref 4', () => {
+    const T = Type.String({ $id: 'T' })
+    const R = Type.Ref(T)
+    const O = Type.AsyncIterator(R)
+    const D = Type.Deref(O, [T])
+    Assert.IsTrue(TypeGuard.IsAsyncIterator(D))
+    Assert.IsTrue(TypeGuard.IsString(D.items))
+    Assert.IsFalse('$id' in D.items)
+  })
+  it('Should should deref 5', () => {
+    const T = Type.String({ $id: 'T' })
+    const R = Type.Ref(T)
+    const O = Type.Iterator(R)
+    const D = Type.Deref(O, [T])
+    Assert.IsTrue(TypeGuard.IsIterator(D))
+    Assert.IsTrue(TypeGuard.IsString(D.items))
+    Assert.IsFalse('$id' in D.items)
+  })
+  it('Should should deref 6', () => {
+    const T = Type.String({ $id: 'T' })
+    const R = Type.Ref(T)
+    const O = Type.Function([R], R)
+    const D = Type.Deref(O, [T])
+    Assert.IsTrue(TypeGuard.IsFunction(D))
+    Assert.IsTrue(TypeGuard.IsString(D.parameters[0]))
+    Assert.IsTrue(TypeGuard.IsString(D.returns))
+    Assert.IsFalse('$id' in D.parameters[0])
+    Assert.IsFalse('$id' in D.returns)
+  })
+  it('Should should deref 7', () => {
+    const T = Type.String({ $id: 'T' })
+    const R = Type.Ref(T)
+    const O = Type.Constructor([R], R)
+    const D = Type.Deref(O, [T])
+    Assert.IsTrue(TypeGuard.IsConstructor(D))
+    Assert.IsTrue(TypeGuard.IsString(D.parameters[0]))
+    Assert.IsTrue(TypeGuard.IsString(D.returns))
+    Assert.IsFalse('$id' in D.parameters[0])
+    Assert.IsFalse('$id' in D.returns)
+  })
+  it('Should should deref 8', () => {
+    const T = Type.String({ $id: 'T' })
+    const R = Type.Ref(T)
+    const O = Type.Promise(R)
+    const D = Type.Deref(O, [T])
+    Assert.IsTrue(TypeGuard.IsPromise(D))
+    Assert.IsTrue(TypeGuard.IsString(D.item))
+    Assert.IsFalse('$id' in D.item)
+  })
+  it('Should should deref 9', () => {
+    const T = Type.String({ $id: 'T' })
+    const R1 = Type.Ref(T, { $id: 'R1' })
+    const R2 = Type.Ref(R1, { $id: 'R2' })
+    const R3 = Type.Ref(R2, { $id: 'R3' })
+    const R4 = Type.Ref(R3, { $id: 'R4' })
+    const R5 = Type.Ref(R4, { $id: 'R5' })
+    const R6 = Type.Ref(R5, { $id: 'R6' })
+    const O = Type.Array(R6)
+    const D = Type.Deref(O, [R6, R5, R4, R3, R2, R1, T])
+    Assert.IsTrue(TypeGuard.IsArray(D))
+    Assert.IsTrue(TypeGuard.IsString(D.items))
+    Assert.IsFalse('$id' in D.items)
+  })
+  it('Should should deref 10', () => {
+    const T = Type.String({ $id: 'T' })
+    const R1 = Type.Ref(T, { $id: 'R1' })
+    const R2 = Type.Ref(R1, { $id: 'R2' })
+    const R3 = Type.Ref(R2, { $id: 'R3' })
+    const R4 = Type.Ref(R3, { $id: 'R4' })
+    const R5 = Type.Ref(R4, { $id: 'R5' })
+    const R6 = Type.Ref(R5, { $id: 'R6' })
+    const O = Type.Array(R6)
+    Assert.Throws(() => Type.Deref(O, [R6, R5, R4, R3, R2, R1])) // Omit T
+  })
+})
diff --git a/test/runtime/type/guard/enum.ts b/test/runtime/type/guard/enum.ts
index fd4ee99e1..dc092e838 100644
--- a/test/runtime/type/guard/enum.ts
+++ b/test/runtime/type/guard/enum.ts
@@ -35,12 +35,12 @@ describe('type/guard/TEnum', () => {
   // ----------------------------------------------------------------
   it('Should guard for Empty 1', () => {
     const T = Type.Enum({})
-    Assert.IsTrue(TypeGuard.TNever(T))
+    Assert.IsTrue(TypeGuard.IsNever(T))
   })
   it('Should guard for Empty 2', () => {
     enum E {}
     const T = Type.Enum(E)
-    Assert.IsTrue(TypeGuard.TNever(T))
+    Assert.IsTrue(TypeGuard.IsNever(T))
   })
 
   // ----------------------------------------------------------------
@@ -49,14 +49,14 @@ describe('type/guard/TEnum', () => {
   it('Should guard for TEnum Enum 0', () => {
     enum E {}
     const T = Type.Enum(E)
-    Assert.IsTrue(TypeGuard.TNever(T))
+    Assert.IsTrue(TypeGuard.IsNever(T))
   })
   it('Should guard for TEnum Enum 1', () => {
     enum E {
       A,
     }
     const T = Type.Enum(E)
-    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
     Assert.IsEqual(T.const, E.A)
   })
   it('Should guard for TEnum Enum 2', () => {
@@ -66,7 +66,7 @@ describe('type/guard/TEnum', () => {
       C = 3,
     }
     const T = Type.Enum(E)
-    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsEqual(T.anyOf[0].const, E.A)
     Assert.IsEqual(T.anyOf[1].const, E.B)
     Assert.IsEqual(T.anyOf[2].const, E.C)
@@ -78,7 +78,7 @@ describe('type/guard/TEnum', () => {
       C = 'Z',
     }
     const T = Type.Enum(E)
-    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsEqual(T.anyOf[0].const, E.A)
     Assert.IsEqual(T.anyOf[1].const, E.B)
     Assert.IsEqual(T.anyOf[2].const, E.C)
@@ -90,7 +90,7 @@ describe('type/guard/TEnum', () => {
       C = 'X',
     }
     const T = Type.Enum(E)
-    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsEqual(T.anyOf[0].const, E.A)
     Assert.IsEqual(T.anyOf[1].const, E.B)
     Assert.IsEqual(T.anyOf.length, 2)
@@ -100,11 +100,11 @@ describe('type/guard/TEnum', () => {
   // ----------------------------------------------------------------
   it('Should guard for TEnum Object Literal 0', () => {
     const T = Type.Enum({})
-    Assert.IsTrue(TypeGuard.TNever(T))
+    Assert.IsTrue(TypeGuard.IsNever(T))
   })
   it('Should guard for TEnum Object Literal 1', () => {
     const T = Type.Enum({ A: 1 })
-    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
     Assert.IsEqual(T.const, 1)
   })
   it('Should guard for TEnum Object Literal 2', () => {
@@ -113,7 +113,7 @@ describe('type/guard/TEnum', () => {
       B: 2,
       C: 3,
     })
-    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsEqual(T.anyOf[0].const, 1)
     Assert.IsEqual(T.anyOf[1].const, 2)
     Assert.IsEqual(T.anyOf[2].const, 3)
@@ -124,7 +124,7 @@ describe('type/guard/TEnum', () => {
       B: 'Y',
       C: 'Z',
     })
-    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsEqual(T.anyOf[0].const, 'X')
     Assert.IsEqual(T.anyOf[1].const, 'Y')
     Assert.IsEqual(T.anyOf[2].const, 'Z')
@@ -135,7 +135,7 @@ describe('type/guard/TEnum', () => {
       B: 'Y',
       C: 'X',
     })
-    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsEqual(T.anyOf[0].const, 'X')
     Assert.IsEqual(T.anyOf[1].const, 'Y')
     Assert.IsEqual(T.anyOf.length, 2)
diff --git a/test/runtime/type/guard/exclude.ts b/test/runtime/type/guard/exclude.ts
index fe4f06ded..78fbdfe32 100644
--- a/test/runtime/type/guard/exclude.ts
+++ b/test/runtime/type/guard/exclude.ts
@@ -5,21 +5,21 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TExclude', () => {
   it('Should extract string from number', () => {
     const T = Type.Exclude(Type.String(), Type.Number())
-    Assert.IsTrue(TypeGuard.TString(T))
+    Assert.IsTrue(TypeGuard.IsString(T))
   })
   it('Should extract string from string', () => {
     const T = Type.Exclude(Type.String(), Type.String())
-    Assert.IsTrue(TypeGuard.TNever(T))
+    Assert.IsTrue(TypeGuard.IsNever(T))
   })
   it('Should extract string | number | boolean from string', () => {
     const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
-    Assert.IsTrue(TypeGuard.TUnion(T))
-    Assert.IsTrue(TypeGuard.TNumber(T.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TBoolean(T.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsBoolean(T.anyOf[1]))
   })
   it('Should extract string | number | boolean from string | boolean', () => {
     const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Boolean()]))
-    Assert.IsTrue(TypeGuard.TNumber(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T))
   })
   // ------------------------------------------------------------------------
   // TemplateLiteral | TemplateLiteral
@@ -28,7 +28,7 @@ describe('type/guard/TExclude', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const T = Type.Exclude(A, B)
-    Assert.IsTrue(TypeGuard.TNever(T))
+    Assert.IsTrue(TypeGuard.IsNever(T))
   })
   it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
@@ -50,7 +50,7 @@ describe('type/guard/TExclude', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const T = Type.Exclude(A, B)
-    Assert.IsTrue(TypeGuard.TNever(T))
+    Assert.IsTrue(TypeGuard.IsNever(T))
   })
   it('Should extract TemplateLiteral | Union 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
@@ -72,7 +72,7 @@ describe('type/guard/TExclude', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const T = Type.Exclude(A, B)
-    Assert.IsTrue(TypeGuard.TNever(T))
+    Assert.IsTrue(TypeGuard.IsNever(T))
   })
   it('Should extract Union | TemplateLiteral 1', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
diff --git a/test/runtime/type/guard/extract.ts b/test/runtime/type/guard/extract.ts
index 9fe5f35ea..b3524d1e0 100644
--- a/test/runtime/type/guard/extract.ts
+++ b/test/runtime/type/guard/extract.ts
@@ -5,21 +5,21 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TExtract', () => {
   it('Should extract string from number', () => {
     const T = Type.Extract(Type.String(), Type.Number())
-    Assert.IsTrue(TypeGuard.TNever(T))
+    Assert.IsTrue(TypeGuard.IsNever(T))
   })
   it('Should extract string from string', () => {
     const T = Type.Extract(Type.String(), Type.String())
-    Assert.IsTrue(TypeGuard.TString(T))
+    Assert.IsTrue(TypeGuard.IsString(T))
   })
   it('Should extract string | number | boolean from string', () => {
     const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
-    Assert.IsTrue(TypeGuard.TString(T))
+    Assert.IsTrue(TypeGuard.IsString(T))
   })
   it('Should extract string | number | boolean from string | boolean', () => {
     const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Boolean()]))
-    Assert.IsTrue(TypeGuard.TUnion(T))
-    Assert.IsTrue(TypeGuard.TString(T.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TBoolean(T.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(T))
+    Assert.IsTrue(TypeGuard.IsString(T.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsBoolean(T.anyOf[1]))
   })
   // ------------------------------------------------------------------------
   // TemplateLiteral | TemplateLiteral
diff --git a/test/runtime/type/guard/function.ts b/test/runtime/type/guard/function.ts
index 79e66ba6f..400c83004 100644
--- a/test/runtime/type/guard/function.ts
+++ b/test/runtime/type/guard/function.ts
@@ -4,32 +4,32 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TFunction', () => {
   it('Should guard for TFunction', () => {
-    const R = TypeGuard.TFunction(Type.Function([], Type.Number()))
+    const R = TypeGuard.IsFunction(Type.Function([], Type.Number()))
     Assert.IsTrue(R)
   })
   it('Should not guard for TFunction', () => {
-    const R = TypeGuard.TFunction(null)
+    const R = TypeGuard.IsFunction(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TFunction with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TFunction(Type.Function([], Type.Number(), { $id: 1 }))
+    const R = TypeGuard.IsFunction(Type.Function([], Type.Number(), { $id: 1 }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TFunction with invalid Params', () => {
-    const R = TypeGuard.TFunction(Type.Function([{} as any, {} as any], Type.Number()))
+    const R = TypeGuard.IsFunction(Type.Function([{} as any, {} as any], Type.Number()))
     Assert.IsFalse(R)
   })
   it('Should not guard for TFunction with invalid Return', () => {
-    const R = TypeGuard.TFunction(Type.Function([], {} as any))
+    const R = TypeGuard.IsFunction(Type.Function([], {} as any))
     Assert.IsFalse(R)
   })
   it('Should guard for TFunction with empty Rest Tuple', () => {
-    const R = TypeGuard.TFunction(Type.Function(Type.Rest(Type.Tuple([])), Type.Number()))
+    const R = TypeGuard.IsFunction(Type.Function(Type.Rest(Type.Tuple([])), Type.Number()))
     Assert.IsTrue(R)
   })
   it('Should guard for TFunction with Rest Tuple', () => {
-    const R = TypeGuard.TFunction(Type.Function(Type.Rest(Type.Tuple([Type.Number(), Type.String()])), Type.Number()))
+    const R = TypeGuard.IsFunction(Type.Function(Type.Rest(Type.Tuple([Type.Number(), Type.String()])), Type.Number()))
     Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/guard/index.ts b/test/runtime/type/guard/index.ts
index 3533d6d53..271b53f88 100644
--- a/test/runtime/type/guard/index.ts
+++ b/test/runtime/type/guard/index.ts
@@ -6,8 +6,10 @@ import './bigint'
 import './boolean'
 import './capitalize'
 import './composite'
+import './const'
 import './constructor'
 import './date'
+import './deref'
 import './enum'
 import './exclude'
 import './extract'
@@ -20,6 +22,7 @@ import './keyof'
 import './kind'
 import './literal'
 import './lowercase'
+import './mapped'
 import './not'
 import './null'
 import './number'
@@ -31,6 +34,7 @@ import './promise'
 import './record'
 import './recursive'
 import './ref'
+import './regexp'
 import './required'
 import './rest'
 import './string'
diff --git a/test/runtime/type/guard/indexed.ts b/test/runtime/type/guard/indexed.ts
index 2a680f843..0e29896a9 100644
--- a/test/runtime/type/guard/indexed.ts
+++ b/test/runtime/type/guard/indexed.ts
@@ -9,7 +9,7 @@ describe('type/guard/TIndex', () => {
       y: Type.String(),
     })
     const I = Type.Index(T, ['x'])
-    Assert.IsTrue(TypeGuard.TNumber(I))
+    Assert.IsTrue(TypeGuard.IsNumber(I))
   })
   it('Should Index 2', () => {
     const T = Type.Object({
@@ -17,9 +17,9 @@ describe('type/guard/TIndex', () => {
       y: Type.String(),
     })
     const I = Type.Index(T, ['x', 'y'])
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[1]))
   })
   it('Should Index 3', () => {
     const T = Type.Object({
@@ -27,9 +27,9 @@ describe('type/guard/TIndex', () => {
       y: Type.String(),
     })
     const I = Type.Index(T, Type.KeyOf(T))
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[1]))
   })
   it('Should Index 4', () => {
     const T = Type.Object({
@@ -37,59 +37,59 @@ describe('type/guard/TIndex', () => {
       ac: Type.String(),
     })
     const I = Type.Index(T, Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])]))
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[1]))
   })
   it('Should Index 5', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.String() })])
     const I = Type.Index(T, ['x', 'y'])
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[1]))
   })
   it('Should Index 6', () => {
     const T = Type.Union([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.String() })])
     const I = Type.Index(T, ['x'])
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[1]))
   })
   it('Should Index 7', () => {
     const T = Type.Array(Type.Null())
     const I = Type.Index(T, Type.Number())
-    Assert.IsTrue(TypeGuard.TNull(I))
+    Assert.IsTrue(TypeGuard.IsNull(I))
   })
   it('Should Index 6', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [0])
-    Assert.IsTrue(TypeGuard.TLiteralString(I))
+    Assert.IsTrue(TypeGuard.IsLiteralString(I))
     Assert.IsEqual(I.const, 'hello')
   })
   it('Should Index 8', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [1])
-    Assert.IsTrue(TypeGuard.TLiteralString(I))
+    Assert.IsTrue(TypeGuard.IsLiteralString(I))
     Assert.IsEqual(I.const, 'world')
   })
   it('Should Index 9', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [0, 1])
-    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
     Assert.IsEqual(I.anyOf[0].const, 'hello')
     Assert.IsEqual(I.anyOf[1].const, 'world')
   })
   it('Should Index 10', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [1, 0])
-    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
     Assert.IsEqual(I.anyOf[0].const, 'world')
     Assert.IsEqual(I.anyOf[1].const, 'hello')
   })
   it('Should Index 11', () => {
     const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
     const I = Type.Index(T, [0, 0, 0, 1])
-    Assert.IsTrue(TypeGuard.TUnion(I))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
     Assert.IsEqual(I.anyOf[0].const, 'hello')
     Assert.IsEqual(I.anyOf[1].const, 'hello')
     Assert.IsEqual(I.anyOf[2].const, 'hello')
@@ -98,47 +98,47 @@ describe('type/guard/TIndex', () => {
   it('Should Index 12', () => {
     const T = Type.Tuple([Type.String(), Type.Boolean()])
     const I = Type.Index(T, Type.Number())
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TBoolean(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsBoolean(I.anyOf[1]))
   })
   it('Should Index 13', () => {
     const T = Type.Tuple([Type.String()])
     const I = Type.Index(T, Type.Number())
-    Assert.IsTrue(TypeGuard.TString(I))
+    Assert.IsTrue(TypeGuard.IsString(I))
   })
   it('Should Index 14', () => {
     const T = Type.Tuple([])
     const I = Type.Index(T, Type.Number())
-    Assert.IsTrue(TypeGuard.TNever(I))
+    Assert.IsTrue(TypeGuard.IsNever(I))
   })
   it('Should Index 15', () => {
     const T = Type.Object({
       0: Type.Number(),
     })
     const I = Type.Index(T, Type.Literal(0))
-    Assert.IsTrue(TypeGuard.TNumber(I))
+    Assert.IsTrue(TypeGuard.IsNumber(I))
   })
   it('Should Index 16', () => {
     const T = Type.Object({
       0: Type.Number(),
     })
     const I = Type.Index(T, Type.Literal('0'))
-    Assert.IsTrue(TypeGuard.TNumber(I))
+    Assert.IsTrue(TypeGuard.IsNumber(I))
   })
   it('Should Index 17', () => {
     const T = Type.Object({
       '0': Type.Number(),
     })
     const I = Type.Index(T, Type.Literal(0))
-    Assert.IsTrue(TypeGuard.TNumber(I))
+    Assert.IsTrue(TypeGuard.IsNumber(I))
   })
   it('Should Index 18', () => {
     const T = Type.Object({
       '0': Type.Number(),
     })
     const I = Type.Index(T, Type.Literal('0'))
-    Assert.IsTrue(TypeGuard.TNumber(I))
+    Assert.IsTrue(TypeGuard.IsNumber(I))
   })
   it('Should Index 19', () => {
     const T = Type.Object({
@@ -147,9 +147,9 @@ describe('type/guard/TIndex', () => {
       2: Type.Boolean(),
     })
     const I = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal(2)]))
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TBoolean(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsBoolean(I.anyOf[1]))
   })
   it('Should Index 20', () => {
     const T = Type.Object({
@@ -158,7 +158,7 @@ describe('type/guard/TIndex', () => {
       2: Type.Boolean(),
     })
     const I = Type.Index(T, Type.BigInt())
-    Assert.IsTrue(TypeGuard.TNever(I))
+    Assert.IsTrue(TypeGuard.IsNever(I))
   })
   it('Should Index 21', () => {
     const T = Type.Object({
@@ -167,7 +167,7 @@ describe('type/guard/TIndex', () => {
       2: Type.Boolean(),
     })
     const I = Type.Index(T, Type.Object({}))
-    Assert.IsTrue(TypeGuard.TNever(I))
+    Assert.IsTrue(TypeGuard.IsNever(I))
   })
   it('Should Index 22', () => {
     const A = Type.Object({ x: Type.Literal('A') })
@@ -176,11 +176,11 @@ describe('type/guard/TIndex', () => {
     const D = Type.Object({ x: Type.Literal('D') })
     const T = Type.Intersect([A, B, C, D])
     const I = Type.Index(T, ['x'])
-    Assert.IsTrue(TypeGuard.TIntersect(I))
-    Assert.IsTrue(TypeGuard.TLiteral(I.allOf[0]))
-    Assert.IsTrue(TypeGuard.TLiteral(I.allOf[1]))
-    Assert.IsTrue(TypeGuard.TLiteral(I.allOf[2]))
-    Assert.IsTrue(TypeGuard.TLiteral(I.allOf[3]))
+    Assert.IsTrue(TypeGuard.IsIntersect(I))
+    Assert.IsTrue(TypeGuard.IsLiteral(I.allOf[0]))
+    Assert.IsTrue(TypeGuard.IsLiteral(I.allOf[1]))
+    Assert.IsTrue(TypeGuard.IsLiteral(I.allOf[2]))
+    Assert.IsTrue(TypeGuard.IsLiteral(I.allOf[3]))
   })
   it('Should Index 23', () => {
     const A = Type.Object({ x: Type.Literal('A') })
@@ -189,11 +189,11 @@ describe('type/guard/TIndex', () => {
     const D = Type.Object({ x: Type.Literal('D') })
     const T = Type.Union([A, B, C, D])
     const I = Type.Index(T, ['x'])
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TLiteral(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TLiteral(I.anyOf[1]))
-    Assert.IsTrue(TypeGuard.TLiteral(I.anyOf[2]))
-    Assert.IsTrue(TypeGuard.TLiteral(I.anyOf[3]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsLiteral(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsLiteral(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsLiteral(I.anyOf[2]))
+    Assert.IsTrue(TypeGuard.IsLiteral(I.anyOf[3]))
   })
   it('Should Index 24', () => {
     const A = Type.Object({ x: Type.Literal('A'), y: Type.Number() })
@@ -202,9 +202,9 @@ describe('type/guard/TIndex', () => {
     const D = Type.Object({ x: Type.Literal('D') })
     const T = Type.Intersect([A, B, C, D])
     const I = Type.Index(T, ['x', 'y'])
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TIntersect(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsIntersect(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[1]))
   })
   it('Should Index 25', () => {
     const A = Type.Object({ x: Type.Literal('A'), y: Type.Number() })
@@ -213,11 +213,11 @@ describe('type/guard/TIndex', () => {
     const D = Type.Object({ x: Type.Literal('D') })
     const T = Type.Intersect([A, B, C, D])
     const I = Type.Index(T, ['x', 'y'])
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TIntersect(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TIntersect(I.anyOf[1]))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1].allOf[0]))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[1].allOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsIntersect(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsIntersect(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[1].allOf[0]))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[1].allOf[1]))
   })
   it('Should Index 26', () => {
     const T = Type.Recursive((This) =>
@@ -228,10 +228,10 @@ describe('type/guard/TIndex', () => {
       }),
     )
     const I = Type.Index(T, ['x', 'y', 'z'])
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
-    Assert.IsTrue(TypeGuard.TThis(I.anyOf[2]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsThis(I.anyOf[2]))
   })
   it('Should Index 27', () => {
     const T = Type.Object({
@@ -239,9 +239,9 @@ describe('type/guard/TIndex', () => {
       1: Type.Number(),
     })
     const I = Type.Index(T, [0, 1])
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[1]))
   })
   it('Should Index 28', () => {
     const T = Type.Object({
@@ -249,9 +249,9 @@ describe('type/guard/TIndex', () => {
       '1': Type.Number(),
     })
     const I = Type.Index(T, [0, '1'])
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[1]))
   })
   it('Should Index 29', () => {
     const T = Type.Object({
@@ -259,9 +259,9 @@ describe('type/guard/TIndex', () => {
       '1': Type.Number(),
     })
     const I = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal('1')]))
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[1]))
   })
   it('Should Index 30', () => {
     const T = Type.Object({
@@ -269,9 +269,9 @@ describe('type/guard/TIndex', () => {
       '1': Type.Number(),
     })
     const I = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal(1)]))
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[1]))
     // Note: Expect TNever for anyOf[1] but permit for TNumber due to IndexedAccess
     // Resolve() which currently cannot differentiate between string and numeric keys
     // on the object. This may be resolvable in later revisions, but test for this
@@ -286,8 +286,8 @@ describe('type/guard/TIndex', () => {
       y: Type.Number(),
     })
     const I = Type.Index(T, ['x'])
-    Assert.IsTrue(TypeGuard.TOptional(I))
-    Assert.IsTrue(TypeGuard.TString(I))
+    Assert.IsTrue(TypeGuard.IsOptional(I))
+    Assert.IsTrue(TypeGuard.IsString(I))
   })
   it('Should Index 32', () => {
     const T = Type.Object({
@@ -295,8 +295,8 @@ describe('type/guard/TIndex', () => {
       y: Type.Number(),
     })
     const I = Type.Index(T, ['y'])
-    Assert.IsFalse(TypeGuard.TOptional(I))
-    Assert.IsTrue(TypeGuard.TNumber(I))
+    Assert.IsFalse(TypeGuard.IsOptional(I))
+    Assert.IsTrue(TypeGuard.IsNumber(I))
   })
   it('Should Index 33', () => {
     const T = Type.Object({
@@ -304,15 +304,24 @@ describe('type/guard/TIndex', () => {
       y: Type.Number(),
     })
     const I = Type.Index(T, ['x', 'y'])
-    Assert.IsTrue(TypeGuard.TOptional(I))
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsOptional(I))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[1]))
   })
   it('Should Index 34', () => {
     const T = Type.String()
-    // @ts-ignore
     const I = Type.Index(T, ['x'])
-    Assert.IsTrue(TypeGuard.TNever(I))
+    Assert.IsTrue(TypeGuard.IsNever(I))
+  })
+  it('Should Index 35', () => {
+    const T = Type.Array(Type.String())
+    const I = Type.Index(T, Type.Number())
+    Assert.IsTrue(TypeGuard.IsString(I))
+  })
+  it('Should Index 36', () => {
+    const T = Type.Array(Type.String())
+    const I = Type.Index(T, ['[number]'])
+    Assert.IsTrue(TypeGuard.IsString(I))
   })
 })
diff --git a/test/runtime/type/guard/integer.ts b/test/runtime/type/guard/integer.ts
index 849aabdca..42a8c6120 100644
--- a/test/runtime/type/guard/integer.ts
+++ b/test/runtime/type/guard/integer.ts
@@ -4,41 +4,41 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TInteger', () => {
   it('Should guard for TInteger', () => {
-    const R = TypeGuard.TInteger(Type.Integer())
+    const R = TypeGuard.IsInteger(Type.Integer())
     Assert.IsTrue(R)
   })
   it('Should not guard for TInteger', () => {
-    const R = TypeGuard.TInteger(null)
+    const R = TypeGuard.IsInteger(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TInteger with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TInteger(Type.Integer({ $id: 1 }))
+    const R = TypeGuard.IsInteger(Type.Integer({ $id: 1 }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TInteger with invalid multipleOf', () => {
     // @ts-ignore
-    const R = TypeGuard.TInteger(Type.Integer({ multipleOf: '1' }))
+    const R = TypeGuard.IsInteger(Type.Integer({ multipleOf: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TInteger with invalid minimum', () => {
     // @ts-ignore
-    const R = TypeGuard.TInteger(Type.Integer({ minimum: '1' }))
+    const R = TypeGuard.IsInteger(Type.Integer({ minimum: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TInteger with invalid maximum', () => {
     // @ts-ignore
-    const R = TypeGuard.TInteger(Type.Integer({ maximum: '1' }))
+    const R = TypeGuard.IsInteger(Type.Integer({ maximum: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TInteger with invalid exclusiveMinimum', () => {
     // @ts-ignore
-    const R = TypeGuard.TInteger(Type.Integer({ exclusiveMinimum: '1' }))
+    const R = TypeGuard.IsInteger(Type.Integer({ exclusiveMinimum: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TInteger with invalid exclusiveMaximum', () => {
     // @ts-ignore
-    const R = TypeGuard.TInteger(Type.Integer({ exclusiveMaximum: '1' }))
+    const R = TypeGuard.IsInteger(Type.Integer({ exclusiveMaximum: '1' }))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/intersect.ts b/test/runtime/type/guard/intersect.ts
index 25c069c7b..ab2b58466 100644
--- a/test/runtime/type/guard/intersect.ts
+++ b/test/runtime/type/guard/intersect.ts
@@ -4,7 +4,7 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TIntersect', () => {
   it('Should guard for TIntersect', () => {
-    const R = TypeGuard.TIntersect(
+    const R = TypeGuard.IsIntersect(
       Type.Intersect([
         Type.Object({
           x: Type.Number(),
@@ -17,7 +17,7 @@ describe('type/guard/TIntersect', () => {
     Assert.IsTrue(R)
   })
   it('Should not guard for TIntersect', () => {
-    const R = TypeGuard.TIntersect(
+    const R = TypeGuard.IsIntersect(
       Type.Union([
         Type.Object({
           x: Type.Number(),
diff --git a/test/runtime/type/guard/iterator.ts b/test/runtime/type/guard/iterator.ts
index b0dd08c4a..df549edd1 100644
--- a/test/runtime/type/guard/iterator.ts
+++ b/test/runtime/type/guard/iterator.ts
@@ -5,18 +5,18 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TIterator', () => {
   it('Should guard for TIterator', () => {
     const T = Type.Iterator(Type.Any())
-    const R = TypeGuard.TIterator(T)
+    const R = TypeGuard.IsIterator(T)
     Assert.IsTrue(R)
   })
   it('Should not guard for TIterator', () => {
     const T = null
-    const R = TypeGuard.TIterator(T)
+    const R = TypeGuard.IsIterator(T)
     Assert.IsFalse(R)
   })
   it('Should not guard for TIterator with invalid $id', () => {
     //@ts-ignore
     const T = Type.Iterator(Type.Any(), { $id: 1 })
-    const R = TypeGuard.TIterator(T)
+    const R = TypeGuard.IsIterator(T)
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/keyof.ts b/test/runtime/type/guard/keyof.ts
index d8b24ad74..1b066c4ed 100644
--- a/test/runtime/type/guard/keyof.ts
+++ b/test/runtime/type/guard/keyof.ts
@@ -9,9 +9,9 @@ describe('type/guard/TKeyOf', () => {
       y: Type.Number(),
     })
     const K = Type.KeyOf(T)
-    Assert.IsTrue(TypeGuard.TUnion(K))
-    Assert.IsTrue(TypeGuard.TLiteral(K.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TLiteral(K.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(K))
+    Assert.IsTrue(TypeGuard.IsLiteral(K.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsLiteral(K.anyOf[1]))
   })
   it('Should KeyOf 2', () => {
     const T = Type.Recursive((Self) =>
@@ -21,9 +21,9 @@ describe('type/guard/TKeyOf', () => {
       }),
     )
     const K = Type.KeyOf(T)
-    Assert.IsTrue(TypeGuard.TUnion(K))
-    Assert.IsTrue(TypeGuard.TLiteral(K.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TLiteral(K.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(K))
+    Assert.IsTrue(TypeGuard.IsLiteral(K.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsLiteral(K.anyOf[1]))
   })
   it('Should KeyOf 3', () => {
     const T = Type.Intersect([
@@ -35,9 +35,9 @@ describe('type/guard/TKeyOf', () => {
       }),
     ])
     const K = Type.KeyOf(T)
-    Assert.IsTrue(TypeGuard.TUnion(K))
-    Assert.IsTrue(TypeGuard.TLiteral(K.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TLiteral(K.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(K))
+    Assert.IsTrue(TypeGuard.IsLiteral(K.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsLiteral(K.anyOf[1]))
   })
   it('Should KeyOf 4', () => {
     const T = Type.Union([
@@ -49,27 +49,27 @@ describe('type/guard/TKeyOf', () => {
       }),
     ])
     const K = Type.KeyOf(T)
-    Assert.IsTrue(TypeGuard.TNever(K))
+    Assert.IsTrue(TypeGuard.IsNever(K))
   })
   it('Should KeyOf 5', () => {
     const T = Type.Null()
     const K = Type.KeyOf(T)
-    Assert.IsTrue(TypeGuard.TNever(K))
+    Assert.IsTrue(TypeGuard.IsNever(K))
   })
   it('Should KeyOf 6', () => {
     const T = Type.Array(Type.Number())
     const K = Type.KeyOf(T)
-    Assert.IsTrue(TypeGuard.TNumber(K))
+    Assert.IsTrue(TypeGuard.IsNumber(K))
   })
   it('Should KeyOf 7', () => {
     const T = Type.Tuple([])
     const K = Type.KeyOf(T)
-    Assert.IsTrue(TypeGuard.TNever(K))
+    Assert.IsTrue(TypeGuard.IsNever(K))
   })
   it('Should KeyOf 8', () => {
     const T = Type.Tuple([Type.Number(), Type.Null()])
     const K = Type.KeyOf(T)
-    Assert.IsTrue(TypeGuard.TUnion(K))
+    Assert.IsTrue(TypeGuard.IsUnion(K))
     Assert.IsEqual(K.anyOf[0].const, '0')
     Assert.IsEqual(K.anyOf[1].const, '1')
   })
diff --git a/test/runtime/type/guard/kind.ts b/test/runtime/type/guard/kind.ts
index 52c87f883..26006958f 100644
--- a/test/runtime/type/guard/kind.ts
+++ b/test/runtime/type/guard/kind.ts
@@ -4,10 +4,10 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TKind', () => {
   it('Should guard 1', () => {
     const T = { [Kind]: 'Kind' }
-    Assert.IsTrue(TypeGuard.TKind(T))
+    Assert.IsTrue(TypeGuard.IsKind(T))
   })
   it('Should guard 2', () => {
     const T = {}
-    Assert.IsFalse(TypeGuard.TKind(T))
+    Assert.IsFalse(TypeGuard.IsKind(T))
   })
 })
diff --git a/test/runtime/type/guard/literal.ts b/test/runtime/type/guard/literal.ts
index b982a5e7e..c1e6b21f5 100644
--- a/test/runtime/type/guard/literal.ts
+++ b/test/runtime/type/guard/literal.ts
@@ -4,29 +4,29 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TLiteral', () => {
   it('Should guard for TLiteral of String', () => {
-    const R = TypeGuard.TLiteral(Type.Literal('hello'))
+    const R = TypeGuard.IsLiteral(Type.Literal('hello'))
     Assert.IsTrue(R)
   })
   it('Should guard for TLiteral of Number', () => {
-    const R = TypeGuard.TLiteral(Type.Literal(42))
+    const R = TypeGuard.IsLiteral(Type.Literal(42))
     Assert.IsTrue(R)
   })
   it('Should guard for TLiteral of Boolean', () => {
-    const R = TypeGuard.TLiteral(Type.Literal(true))
+    const R = TypeGuard.IsLiteral(Type.Literal(true))
     Assert.IsTrue(R)
   })
   it('Should not guard for TLiteral of Null', () => {
     // @ts-ignore
-    const R = TypeGuard.TLiteral(Type.Literal(null))
+    const R = TypeGuard.IsLiteral(Type.Literal(null))
     Assert.IsFalse(R)
   })
   it('Should not guard for TLiteral', () => {
-    const R = TypeGuard.TLiteral(null)
+    const R = TypeGuard.IsLiteral(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TLiteral with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TLiteral(Type.Literal(42, { $id: 1 }))
+    const R = TypeGuard.IsLiteral(Type.Literal(42, { $id: 1 }))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/lowercase.ts b/test/runtime/type/guard/lowercase.ts
index 5a07e5d41..be9e797cd 100644
--- a/test/runtime/type/guard/lowercase.ts
+++ b/test/runtime/type/guard/lowercase.ts
@@ -4,30 +4,30 @@ import { Assert } from '../../assert/index'
 describe('type/guard/Lowercase', () => {
   it('Should guard for Lowercase 1', () => {
     const T = Type.Lowercase(Type.Literal('HELLO'), { $id: 'hello', foo: 1 })
-    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
     Assert.IsEqual(T.const, 'hello')
     Assert.IsEqual(T.$id, 'hello')
     Assert.IsEqual(T.foo, 1)
   })
   it('Should guard for Lowercase 2', () => {
     const T = Type.Lowercase(Type.Literal('HELLO'))
-    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
     Assert.IsEqual(T.const, 'hello')
   })
   it('Should guard for Lowercase 3', () => {
     const T = Type.Lowercase(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD')]))
-    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsEqual(T.anyOf[0].const, 'hello')
     Assert.IsEqual(T.anyOf[1].const, 'world')
   })
   it('Should guard for Lowercase 4', () => {
     const T = Type.Lowercase(Type.TemplateLiteral('HELLO${0|1}'))
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(hello0|hello1)$')
   })
   it('Should guard for Lowercase 5', () => {
     const T = Type.Lowercase(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(0), Type.Literal(1)])]))
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(hello0|hello1)$')
   })
 })
diff --git a/test/runtime/type/guard/mapped.ts b/test/runtime/type/guard/mapped.ts
new file mode 100644
index 000000000..1ab3daf9f
--- /dev/null
+++ b/test/runtime/type/guard/mapped.ts
@@ -0,0 +1,609 @@
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+// prettier-ignore
+describe('type/guard/Mapped', () => {
+  it('Should guard mapped 1', () => {
+    const T = Type.Mapped(Type.Union([
+      Type.Literal('x'),
+      Type.Literal('y'),
+      Type.Literal('z'),
+    ]), _ => Type.Number(), { custom: 1 })
+    Assert.IsEqual(T, Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number()
+    }, { custom: 1 }))
+  })
+  it('Should guard mapped 2', () => {
+    const T = Type.Mapped(Type.Union([
+      Type.Literal('x'),
+      Type.Literal('y'),
+      Type.Literal('z'),
+    ]), _ => Type.Number())
+    Assert.IsEqual(T, Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number()
+    }))
+  })
+  it('Should guard mapped 3', () => {
+    const T = Type.Mapped(Type.Union([
+      Type.Literal('x'),
+      Type.Literal('y'),
+      Type.Literal('z'),
+    ]), K => K)
+    Assert.IsEqual(T, Type.Object({
+      x: Type.Literal('x'),
+      y: Type.Literal('y'),
+      z: Type.Literal('z'),
+    }))
+  })
+  it('Should guard mapped 4', () => {
+    const T = Type.Mapped(Type.TemplateLiteral('${0|1}${0|1}'), K => Type.Number())
+    Assert.IsEqual(T, Type.Object({
+      '00': Type.Number(),
+      '01': Type.Number(),
+      '10': Type.Number(),
+      '11': Type.Number(),
+    }))
+  })
+  it('Should guard mapped 5', () => {
+    const T = Type.Mapped(Type.TemplateLiteral('${a|b}'), X => 
+      Type.Mapped(Type.TemplateLiteral('${c|d}'), Y => 
+        Type.Mapped(Type.TemplateLiteral('${e|f}'), Z =>
+          Type.Tuple([X, Y, Z])
+        )
+      )
+    )
+    Assert.IsEqual(T, Type.Object({
+      a: Type.Object({
+        c: Type.Object({
+          e: Type.Tuple([Type.Literal("a"), Type.Literal("c"), Type.Literal("e")]),
+          f: Type.Tuple([Type.Literal("a"), Type.Literal("c"), Type.Literal("f")])
+        }),
+        d: Type.Object({
+          e: Type.Tuple([Type.Literal("a"), Type.Literal("d"), Type.Literal("e")]),
+          f: Type.Tuple([Type.Literal("a"), Type.Literal("d"), Type.Literal("f")])
+        }),
+      }),
+      b: Type.Object({
+        c: Type.Object({
+          e: Type.Tuple([Type.Literal("b"), Type.Literal("c"), Type.Literal("e")]),
+          f: Type.Tuple([Type.Literal("b"), Type.Literal("c"), Type.Literal("f")])
+        }),
+        d: Type.Object({
+          e: Type.Tuple([Type.Literal("b"), Type.Literal("d"), Type.Literal("e")]),
+          f: Type.Tuple([Type.Literal("b"), Type.Literal("d"), Type.Literal("f")])
+        }),
+      }),
+    }))
+  })
+  it('Should guard mapped 6', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+      z: Type.Boolean()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => K)
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Literal('x'),
+      y: Type.Literal('y'),
+      z: Type.Literal('z')
+    }))
+  })
+  it('Should guard mapped 7', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+      z: Type.Boolean()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Index(T, K))
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+      z: Type.Boolean()
+    }))
+  })
+  it('Should guard mapped 8', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+      z: Type.Boolean()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Index(T, K, { custom: 1 }))
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Number({ custom: 1 }),
+      y: Type.String({ custom: 1 }),
+      z: Type.Boolean({ custom: 1 })
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Extract
+  // ----------------------------------------------------------------
+  it('Should guard mapped 9', () => {
+    const T = Type.Object({
+      x: Type.Union([Type.String(), Type.Number(), Type.Boolean()])
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return Type.Extract(Type.Index(T, K), Type.String())
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.String()
+    }))
+  })
+  it('Should guard mapped 10', () => {
+    const T = Type.Object({
+      x: Type.Union([Type.String(), Type.Number(), Type.Boolean()])
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return Type.Extract(Type.Index(T, K), Type.Union([
+        Type.String(),
+        Type.Number()
+      ]))
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Union([Type.String(), Type.Number()])
+    }))
+  })
+  it('Should guard mapped 11', () => {
+    const T = Type.Object({
+      x: Type.Union([Type.String(), Type.Number(), Type.Boolean()])
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return Type.Extract(Type.Index(T, K), Type.Null())
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Never()
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Extends
+  // ----------------------------------------------------------------
+  it('Should guard mapped 12', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+      z: Type.Boolean()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return ( 
+        Type.Extends(K, Type.Literal('x'), Type.Literal(1), 
+        Type.Extends(K, Type.Literal('y'), Type.Literal(2), 
+        Type.Extends(K, Type.Literal('z'), Type.Literal(3), Type.Never())))
+      )
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Literal(1),
+      y: Type.Literal(2),
+      z: Type.Literal(3),
+    }))
+  })
+  it('Should guard mapped 13', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+      z: Type.Boolean()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return ( 
+        Type.Extends(Type.Index(T, K), Type.Number(), Type.Literal(3), 
+        Type.Extends(Type.Index(T, K), Type.String(), Type.Literal(2), 
+        Type.Extends(Type.Index(T, K), Type.Boolean(), Type.Literal(1), Type.Never())))
+      )
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Literal(3),
+      y: Type.Literal(2),
+      z: Type.Literal(1),
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Exclude
+  // ----------------------------------------------------------------
+  it('Should guard mapped 14', () => {
+    const T = Type.Object({
+      x: Type.Union([Type.String(), Type.Number(), Type.Boolean()])
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return Type.Exclude(Type.Index(T, K), Type.String())
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Union([Type.Number(), Type.Boolean()])
+    }))
+  })
+  it('Should guard mapped 15', () => {
+    const T = Type.Object({
+      x: Type.Union([Type.String(), Type.Number(), Type.Boolean()])
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return Type.Exclude(Type.Index(T, K), Type.Union([
+        Type.String(),
+        Type.Number()
+      ]))
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Boolean()
+    }))
+  })
+  it('Should guard mapped 16', () => {
+    const T = Type.Object({
+      x: Type.Union([Type.String(), Type.Number(), Type.Boolean()])
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return Type.Exclude(Type.Index(T, K), Type.Null())
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Union([Type.String(), Type.Number(), Type.Boolean()])
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Non-Evaluated
+  // ----------------------------------------------------------------
+  it('Should guard mapped 17', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Array(Type.Index(T, K)))
+    Assert.IsEqual(M, Type.Object({ x: Type.Array(Type.Number()) }))
+  })
+  it('Should guard mapped 18', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Promise(Type.Index(T, K)))
+    Assert.IsEqual(M, Type.Object({ x: Type.Promise(Type.Number()) }))
+  })
+  it('Should guard mapped 19', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Function([Type.Index(T, K)], Type.Index(T, K)))
+    Assert.IsEqual(M, Type.Object({ x: Type.Function([Type.Number()], Type.Number())}))
+  })
+  it('Should guard mapped 20', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Tuple([Type.Index(T, K), Type.Index(T, K)]))
+    Assert.IsEqual(M, Type.Object({ x: Type.Tuple([Type.Number(), Type.Number()]) }))
+  })
+  it('Should guard mapped 21', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Union([Type.Index(T, K), Type.Index(T, K)]))
+    Assert.IsEqual(M, Type.Object({ x: Type.Union([Type.Number(), Type.Number()]) }))
+  })
+  it('Should guard mapped 22', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Intersect([Type.Index(T, K), Type.Index(T, K)]))
+    Assert.IsEqual(M, Type.Object({ x: Type.Intersect([Type.Number(), Type.Number()]) }))
+  })
+  // ----------------------------------------------------------------
+  // Numeric Keys
+  // ----------------------------------------------------------------
+  it('Should guard mapped 23', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+      1: Type.Number(),
+      2: Type.Number()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => K)
+    Assert.IsEqual(M, Type.Object({
+      0: Type.Literal('0'),
+      1: Type.Literal('1'),
+      2: Type.Literal('2'),
+    }))
+  })
+  it('Should guard mapped 24', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+      1: Type.Number(),
+      2: Type.Number()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Index(T, K))
+    Assert.IsEqual(M, Type.Object({
+      0: Type.Number(),
+      1: Type.Number(),
+      2: Type.Number(),
+    }))
+  })
+  it('Should guard mapped 25', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+      1: Type.Number(),
+      2: Type.Number()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.String())
+    Assert.IsEqual(M, Type.Object({
+      0: Type.String(),
+      1: Type.String(),
+      2: Type.String(),
+    }))
+  })
+  it('Should guard mapped 26', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+      1: Type.Number(),
+      2: Type.Number()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Extends(K, Type.Literal('1'), Type.String(), Type.Number()))
+    Assert.IsEqual(M, Type.Object({
+      0: Type.Number(),
+      1: Type.String(),
+      2: Type.Number(),
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Modifiers: Optional
+  // ----------------------------------------------------------------
+  it('Should guard mapped 27', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.Number()),
+      y: Type.Number()
+    })
+    // subtractive
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Optional(Type.Index(T, K), false))
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Number(),
+      y: Type.Number()
+    }))
+  })
+  it('Should guard mapped 28', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.Number()),
+      y: Type.Number()
+    })
+    // additive
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Optional(Type.Index(T, K), true))
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Optional(Type.Number()),
+      y: Type.Optional(Type.Number())
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Modifiers: Readonly
+  // ----------------------------------------------------------------
+  it('Should guard mapped 27', () => {
+    const T = Type.Object({
+      x: Type.Readonly(Type.Number()),
+      y: Type.Number()
+    })
+    // subtractive
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Readonly(Type.Index(T, K), false))
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Number(),
+      y: Type.Number()
+    }))
+  })
+  it('Should guard mapped 28', () => {
+    const T = Type.Object({
+      x: Type.Readonly(Type.Number()),
+      y: Type.Number()
+    })
+    // additive
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Readonly(Type.Index(T, K), true))
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Readonly(Type.Number()),
+      y: Type.Readonly(Type.Number())
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Finite Boolean
+  // ----------------------------------------------------------------
+  it('Should guard mapped 29', () => {
+    const T = Type.TemplateLiteral('${boolean}')
+    const M = Type.Mapped(T, K => K)
+    Assert.IsEqual(M, Type.Object({
+      true: Type.Literal('true'),
+      false: Type.Literal('false'),
+    }))
+  })
+  it('Should guard mapped 30', () => {
+    const T = Type.TemplateLiteral('${0|1}${boolean}')
+    const M = Type.Mapped(T, K => K) 
+    Assert.IsEqual(M, Type.Object({
+      '0true':  Type.Literal('0true'),
+      '0false':  Type.Literal('0false'),
+      '1true':  Type.Literal('1true'),
+      '1false':  Type.Literal('1false'),
+    }))
+  })
+  it('Should guard mapped 31', () => {
+    const T = Type.TemplateLiteral('${boolean}${0|1}')
+    const M = Type.Mapped(T, K => K) 
+    Assert.IsEqual(M, Type.Object({
+      'true0':  Type.Literal('true0'),
+      'true1':  Type.Literal('true1'),
+      'false0':  Type.Literal('false0'),
+      'false1':  Type.Literal('false1'),
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Numeric Mapping
+  // ----------------------------------------------------------------
+  it('Should guard mapped 32', () => {
+    const T = Type.TemplateLiteral([
+      Type.Union([Type.Literal(0), Type.Literal(1)]),
+      Type.Union([Type.Literal(0), Type.Literal(1)]),
+    ])
+    const M = Type.Mapped(T, (K) => K)
+    Assert.IsEqual(M, Type.Object({
+      '00':  Type.Literal('00'),
+      '01':  Type.Literal('01'),
+      '10':  Type.Literal('10'),
+      '11':  Type.Literal('11'),
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Indexed Key Remap
+  // ----------------------------------------------------------------
+  it('Should guard mapped 33', () => {
+    const T = Type.Object({
+      hello: Type.Number(),
+      world: Type.String(),
+    })
+    const M = Type.Mapped(Type.Uppercase(Type.KeyOf(T)), (K) => {
+      return Type.Index(T, Type.Lowercase(K))
+    })
+    Assert.IsEqual(M, Type.Object({
+      HELLO: Type.Number(),
+      WORLD: Type.String()
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Partial
+  // ----------------------------------------------------------------
+  it('Should guard mapped 34', () => {
+    const T = Type.Object({
+      x: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      y: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+    })
+    const M = Type.Mapped(Type.KeyOf(T), (K) => {
+      return Type.Partial(Type.Index(T, K))
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Partial(Type.Object({
+        x: Type.Optional(Type.Number()),
+        y: Type.Optional(Type.Number()),
+      })),
+      y: Type.Partial(Type.Object({
+        x: Type.Optional(Type.Number()),
+        y: Type.Optional(Type.Number()),
+      })),
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Required
+  // ----------------------------------------------------------------
+  it('Should guard mapped 35', () => {
+    const T = Type.Object({
+      x: Type.Partial(Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      })),
+      y: Type.Partial(Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      })),
+    })
+    const M = Type.Mapped(Type.KeyOf(T), (K) => {
+      return Type.Required(Type.Index(T, K))
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      y: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+    }))
+  })
+  // ------------------------------------------------------------------
+  // Pick With Key
+  // ------------------------------------------------------------------
+  it('Should guard mapped 36', () => {
+    const T = Type.Object({
+      x: Type.Object({
+        x: Type.Number(),
+        y: Type.Number()
+      }),
+      y: Type.Object({
+        x: Type.Number(),
+        y: Type.Number()
+      })
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return Type.Pick(T, K)
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Object({
+        x: Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        })
+      }),
+      y: Type.Object({
+        y: Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        })
+      }),
+    }))
+  })
+  // ------------------------------------------------------------------
+  // Pick With Result
+  // ------------------------------------------------------------------
+  it('Should guard mapped 37', () => {
+    const T = Type.Object({
+      x: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      y: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+    })
+    const M = Type.Mapped(Type.KeyOf(T), (K) => {
+      return Type.Pick(Type.Index(T, K), ['x'])
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Object({ x: Type.Number() }),
+      y: Type.Object({ x: Type.Number() })
+    }))
+  })
+  // ------------------------------------------------------------------
+  // Omit With Key
+  // ------------------------------------------------------------------
+  it('Should guard mapped 36', () => {
+    const T = Type.Object({
+      x: Type.Object({
+        x: Type.Number(),
+        y: Type.Number()
+      }),
+      y: Type.Object({
+        x: Type.Number(),
+        y: Type.Number()
+      })
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return Type.Omit(T, K)
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Object({
+        y: Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        })
+      }),
+      y: Type.Object({
+        x: Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        })
+      }),
+    }))
+  })
+  // ------------------------------------------------------------------
+  // Omit With Result
+  // ------------------------------------------------------------------
+  it('Should guard mapped 37', () => {
+    const T = Type.Object({
+      x: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      y: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+    })
+    const M = Type.Mapped(Type.KeyOf(T), (K) => {
+      return Type.Omit(Type.Index(T, K), ['x'])
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Object({ y: Type.Number() }),
+      y: Type.Object({ y: Type.Number() })
+    }))
+  })
+})
diff --git a/test/runtime/type/guard/not.ts b/test/runtime/type/guard/not.ts
index 71e5695e4..b21cb5d7c 100644
--- a/test/runtime/type/guard/not.ts
+++ b/test/runtime/type/guard/not.ts
@@ -4,16 +4,16 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TNot', () => {
   it('Should guard for TNot', () => {
-    const R = TypeGuard.TNot(Type.Not(Type.String()))
+    const R = TypeGuard.IsNot(Type.Not(Type.String()))
     Assert.IsTrue(R)
   })
   it('Should not guard for TNot 1', () => {
-    const R = TypeGuard.TNot(Type.Not(null as any))
+    const R = TypeGuard.IsNot(Type.Not(null as any))
     Assert.IsFalse(R)
   })
   it('Should not guard for TNot with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TNot(Type.Not(Type.String()), { $id: 1 })
+    const R = TypeGuard.IsNot(Type.Not(Type.String()), { $id: 1 })
     Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/guard/null.ts b/test/runtime/type/guard/null.ts
index dbeca23ae..0ab379276 100644
--- a/test/runtime/type/guard/null.ts
+++ b/test/runtime/type/guard/null.ts
@@ -4,16 +4,16 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TNull', () => {
   it('Should guard for TNull', () => {
-    const R = TypeGuard.TNull(Type.Null())
+    const R = TypeGuard.IsNull(Type.Null())
     Assert.IsTrue(R)
   })
   it('Should not guard for TNull', () => {
-    const R = TypeGuard.TNull(null)
+    const R = TypeGuard.IsNull(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TNull with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TNull(Type.Null({ $id: 1 }))
+    const R = TypeGuard.IsNull(Type.Null({ $id: 1 }))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/number.ts b/test/runtime/type/guard/number.ts
index 02b911665..02ba9d6a7 100644
--- a/test/runtime/type/guard/number.ts
+++ b/test/runtime/type/guard/number.ts
@@ -4,41 +4,41 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TNumber', () => {
   it('Should guard for TNumber', () => {
-    const R = TypeGuard.TNumber(Type.Number())
+    const R = TypeGuard.IsNumber(Type.Number())
     Assert.IsTrue(R)
   })
   it('Should not guard for TNumber', () => {
-    const R = TypeGuard.TNumber(null)
+    const R = TypeGuard.IsNumber(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TNumber with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TNumber(Type.Number({ $id: 1 }))
+    const R = TypeGuard.IsNumber(Type.Number({ $id: 1 }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TNumber with invalid multipleOf', () => {
     // @ts-ignore
-    const R = TypeGuard.TNumber(Type.Number({ multipleOf: '1' }))
+    const R = TypeGuard.IsNumber(Type.Number({ multipleOf: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TNumber with invalid minimum', () => {
     // @ts-ignore
-    const R = TypeGuard.TNumber(Type.Number({ minimum: '1' }))
+    const R = TypeGuard.IsNumber(Type.Number({ minimum: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TNumber with invalid maximum', () => {
     // @ts-ignore
-    const R = TypeGuard.TNumber(Type.Number({ maximum: '1' }))
+    const R = TypeGuard.IsNumber(Type.Number({ maximum: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TNumber with invalid exclusiveMinimum', () => {
     // @ts-ignore
-    const R = TypeGuard.TNumber(Type.Number({ exclusiveMinimum: '1' }))
+    const R = TypeGuard.IsNumber(Type.Number({ exclusiveMinimum: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TNumber with invalid exclusiveMaximum', () => {
     // @ts-ignore
-    const R = TypeGuard.TNumber(Type.Number({ exclusiveMaximum: '1' }))
+    const R = TypeGuard.IsNumber(Type.Number({ exclusiveMaximum: '1' }))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/object.ts b/test/runtime/type/guard/object.ts
index 4f7cfcddf..ff5b2f0e2 100644
--- a/test/runtime/type/guard/object.ts
+++ b/test/runtime/type/guard/object.ts
@@ -4,7 +4,7 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TObject', () => {
   it('Should guard for TObject', () => {
-    const R = TypeGuard.TObject(
+    const R = TypeGuard.IsObject(
       Type.Object({
         x: Type.Number(),
         y: Type.Number(),
@@ -13,11 +13,11 @@ describe('type/guard/TObject', () => {
     Assert.IsTrue(R)
   })
   it('Should not guard for TObject', () => {
-    const R = TypeGuard.TObject(null)
+    const R = TypeGuard.IsObject(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TObject with escape characters in property key', () => {
-    const R = TypeGuard.TObject(
+    const R = TypeGuard.IsObject(
       Type.Object({
         'hello\nworld': Type.Number(),
       }),
@@ -25,7 +25,7 @@ describe('type/guard/TObject', () => {
     Assert.IsFalse(R)
   })
   it('Should not guard for TObject with invalid property values', () => {
-    const R = TypeGuard.TObject(
+    const R = TypeGuard.IsObject(
       Type.Object({
         x: Type.Number(),
         y: {} as any,
@@ -34,7 +34,7 @@ describe('type/guard/TObject', () => {
     Assert.IsFalse(R)
   })
   it('Should not guard for TObject with invalid additionalProperties', () => {
-    const R = TypeGuard.TObject(
+    const R = TypeGuard.IsObject(
       Type.Object(
         {
           x: Type.Number(),
@@ -48,7 +48,7 @@ describe('type/guard/TObject', () => {
     Assert.IsFalse(R)
   })
   it('Should not guard for TObject with invalid $id', () => {
-    const R = TypeGuard.TObject(
+    const R = TypeGuard.IsObject(
       Type.Object(
         {
           x: Type.Number(),
@@ -62,7 +62,7 @@ describe('type/guard/TObject', () => {
     Assert.IsFalse(R)
   })
   it('Should not guard for TObject with invalid minProperties', () => {
-    const R = TypeGuard.TObject(
+    const R = TypeGuard.IsObject(
       Type.Object(
         {
           x: Type.Number(),
@@ -76,7 +76,7 @@ describe('type/guard/TObject', () => {
     Assert.IsFalse(R)
   })
   it('Should not guard for TObject with invalid maxProperties', () => {
-    const R = TypeGuard.TObject(
+    const R = TypeGuard.IsObject(
       Type.Object(
         {
           x: Type.Number(),
@@ -90,7 +90,7 @@ describe('type/guard/TObject', () => {
     Assert.IsFalse(R)
   })
   it('Should guard for TObject with invalid additional properties', () => {
-    const R = TypeGuard.TObject(
+    const R = TypeGuard.IsObject(
       Type.Object(
         {
           x: Type.Number(),
@@ -105,7 +105,7 @@ describe('type/guard/TObject', () => {
     Assert.IsFalse(R)
   })
   it('Should not guard for TObject with valid additional properties schema', () => {
-    const R = TypeGuard.TObject(
+    const R = TypeGuard.IsObject(
       Type.Object(
         {
           x: Type.Number(),
diff --git a/test/runtime/type/guard/omit.ts b/test/runtime/type/guard/omit.ts
index 7b19d146c..c449cc7e6 100644
--- a/test/runtime/type/guard/omit.ts
+++ b/test/runtime/type/guard/omit.ts
@@ -1,4 +1,4 @@
-import { TypeGuard, Type, Kind, Transform } from '@sinclair/typebox'
+import { TypeGuard, Type, Kind, TransformKind } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/TOmit', () => {
@@ -24,7 +24,7 @@ describe('type/guard/TOmit', () => {
       }),
       ['x'],
     )
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.y))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
     Assert.IsEqual(T.required, ['y'])
   })
   it('Should Omit 2', () => {
@@ -35,7 +35,7 @@ describe('type/guard/TOmit', () => {
       }),
       ['x'],
     )
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.y))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
     Assert.IsEqual(T.required, undefined)
   })
   it('Should Omit 3', () => {
@@ -47,13 +47,13 @@ describe('type/guard/TOmit', () => {
       }),
       L,
     )
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.y))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
     Assert.IsEqual(T.required, ['y'])
   })
   it('Should Omit 4', () => {
     const L = Type.Literal('x')
     const T = Type.Omit(Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })]), L)
-    Assert.IsEqual(TypeGuard.TNumber(T.allOf[1].properties.y), true)
+    Assert.IsEqual(TypeGuard.IsNumber(T.allOf[1].properties.y), true)
     // @ts-ignore
     Assert.IsEqual(T.allOf[1].properties.x, undefined)
   })
@@ -99,7 +99,7 @@ describe('type/guard/TOmit', () => {
       }),
       L,
     )
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.ad))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.ad))
     Assert.IsEqual(T.required, ['ad'])
   })
   // ----------------------------------------------------------------
@@ -124,6 +124,6 @@ describe('type/guard/TOmit', () => {
       .Decode((value) => value)
       .Encode((value) => value)
     const R = Type.Omit(S, ['x'])
-    Assert.IsFalse(Transform in R)
+    Assert.IsFalse(TransformKind in R)
   })
 })
diff --git a/test/runtime/type/guard/partial.ts b/test/runtime/type/guard/partial.ts
index cd248bb31..6c419f451 100644
--- a/test/runtime/type/guard/partial.ts
+++ b/test/runtime/type/guard/partial.ts
@@ -1,10 +1,10 @@
-import { TypeGuard, TypeRegistry, Type, Kind, Transform } from '@sinclair/typebox'
+import { TypeGuard, TypeRegistry, Type, Kind, TransformKind } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/TPartial', () => {
   it('Should produce a valid TSchema', () => {
     const T = Type.Partial(Type.Object({ x: Type.Number() }))
-    Assert.IsTrue(TypeGuard.TSchema(T))
+    Assert.IsTrue(TypeGuard.IsSchema(T))
   })
   // -------------------------------------------------------------------------
   // case: https://github.com/sinclairzx81/typebox/issues/364
@@ -62,6 +62,6 @@ describe('type/guard/TPartial', () => {
       .Decode((value) => value)
       .Encode((value) => value)
     const R = Type.Partial(S)
-    Assert.IsFalse(Transform in R)
+    Assert.IsFalse(TransformKind in R)
   })
 })
diff --git a/test/runtime/type/guard/pick.ts b/test/runtime/type/guard/pick.ts
index 0fcd90573..7b53d4da9 100644
--- a/test/runtime/type/guard/pick.ts
+++ b/test/runtime/type/guard/pick.ts
@@ -1,4 +1,4 @@
-import { TypeGuard, Type, Kind, Transform } from '@sinclair/typebox'
+import { TypeGuard, Type, Kind, TransformKind } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/TPick', () => {
@@ -30,7 +30,7 @@ describe('type/guard/TPick', () => {
       }),
       ['x'],
     )
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.x))
     Assert.IsEqual(T.required, ['x'])
   })
   it('Should Pick 2', () => {
@@ -41,7 +41,7 @@ describe('type/guard/TPick', () => {
       }),
       ['x'],
     )
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.x))
     Assert.IsEqual(T.required, undefined)
   })
   it('Should Pick 3', () => {
@@ -53,14 +53,14 @@ describe('type/guard/TPick', () => {
       }),
       L,
     )
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.x))
     Assert.IsEqual(T.required, ['x'])
   })
   it('Should Pick 4', () => {
     const L = Type.Literal('x')
     const T = Type.Pick(Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })]), L)
 
-    Assert.IsTrue(TypeGuard.TNumber(T.allOf[0].properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.allOf[0].properties.x))
     // @ts-ignore
     Assert.IsEqual(T.allOf[1].properties.y, undefined)
   })
@@ -73,8 +73,8 @@ describe('type/guard/TPick', () => {
       }),
       L,
     )
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.x))
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.y))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
     Assert.IsEqual(T.required, ['x', 'y'])
   })
   it('Should Pick 6', () => {
@@ -86,8 +86,8 @@ describe('type/guard/TPick', () => {
       }),
       L,
     )
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.x))
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.y))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
     Assert.IsEqual(T.required, ['x', 'y'])
   })
   it('Should Pick 7', () => {
@@ -100,8 +100,8 @@ describe('type/guard/TPick', () => {
       }),
       L,
     )
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.ab))
-    Assert.IsTrue(TypeGuard.TNumber(T.properties.ac))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.ab))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.ac))
     Assert.IsEqual(T.required, ['ab', 'ac'])
   })
   // ----------------------------------------------------------------
@@ -126,6 +126,6 @@ describe('type/guard/TPick', () => {
       .Decode((value) => value)
       .Encode((value) => value)
     const R = Type.Pick(S, ['x'])
-    Assert.IsFalse(Transform in R)
+    Assert.IsFalse(TransformKind in R)
   })
 })
diff --git a/test/runtime/type/guard/promise.ts b/test/runtime/type/guard/promise.ts
index f00ecc78a..7fab077b8 100644
--- a/test/runtime/type/guard/promise.ts
+++ b/test/runtime/type/guard/promise.ts
@@ -4,20 +4,20 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TPromise', () => {
   it('Should guard for TPromise', () => {
-    const R = TypeGuard.TPromise(Type.Promise(Type.Number()))
+    const R = TypeGuard.IsPromise(Type.Promise(Type.Number()))
     Assert.IsTrue(R)
   })
   it('Should not guard for TPromise', () => {
-    const R = TypeGuard.TPromise(null)
+    const R = TypeGuard.IsPromise(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TPromise with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TPromise(Type.Promise(Type.Number(), { $id: 1 }))
+    const R = TypeGuard.IsPromise(Type.Promise(Type.Number(), { $id: 1 }))
     Assert.IsFalse(R)
   })
   it('Should guard for TPromise with nested TObject', () => {
-    const R = TypeGuard.TPromise(
+    const R = TypeGuard.IsPromise(
       Type.Promise(
         Type.Object({
           x: Type.Number(),
@@ -28,7 +28,7 @@ describe('type/guard/TPromise', () => {
     Assert.IsTrue(R)
   })
   it('Should not guard for TPromise with nested TObject', () => {
-    const R = TypeGuard.TPromise(
+    const R = TypeGuard.IsPromise(
       Type.Promise(
         Type.Object({
           x: Type.Number(),
diff --git a/test/runtime/type/guard/record.ts b/test/runtime/type/guard/record.ts
index 987d8bd84..89ec3dfae 100644
--- a/test/runtime/type/guard/record.ts
+++ b/test/runtime/type/guard/record.ts
@@ -8,73 +8,73 @@ describe('type/guard/TRecord', () => {
   // -------------------------------------------------------------
   it('Should guard overload 1', () => {
     const T = Type.Record(Type.Union([Type.Literal('A'), Type.Literal('B')]), Type.String(), { extra: 1 })
-    Assert.IsTrue(TypeGuard.TObject(T))
-    Assert.IsTrue(TypeGuard.TString(T.properties.A))
-    Assert.IsTrue(TypeGuard.TString(T.properties.B))
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.A))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.B))
     Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 2', () => {
     const T = Type.Record(Type.Union([Type.Literal('A')]), Type.String(), { extra: 1 }) // unwrap as literal
-    Assert.IsTrue(TypeGuard.TObject(T))
-    Assert.IsTrue(TypeGuard.TString(T.properties.A))
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.A))
     Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 3', () => {
     // @ts-ignore
     const T = Type.Record(Type.Union([]), Type.String(), { extra: 1 })
-    Assert.IsTrue(TypeGuard.TNever(T))
+    Assert.IsTrue(TypeGuard.IsNever(T))
   })
   it('Should guard overload 4', () => {
     // @ts-ignore
     const T = Type.Record(Type.BigInt(), Type.String(), { extra: 1 })
-    Assert.IsTrue(TypeGuard.TNever(T))
+    Assert.IsTrue(TypeGuard.IsNever(T))
   })
   it('Should guard overload 5', () => {
     const T = Type.Record(Type.Literal('A'), Type.String(), { extra: 1 })
-    Assert.IsTrue(TypeGuard.TObject(T))
-    Assert.IsTrue(TypeGuard.TString(T.properties.A))
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.A))
     Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 6', () => {
     const L = Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal('A'), Type.Literal('B')])])
     const T = Type.Record(L, Type.String(), { extra: 1 })
-    Assert.IsTrue(TypeGuard.TObject(T))
-    Assert.IsTrue(TypeGuard.TString(T.properties.helloA))
-    Assert.IsTrue(TypeGuard.TString(T.properties.helloB))
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.helloA))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.helloB))
     Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 7', () => {
     const T = Type.Record(Type.Number(), Type.String(), { extra: 1 })
-    Assert.IsTrue(TypeGuard.TRecord(T))
-    Assert.IsTrue(TypeGuard.TString(T.patternProperties[PatternNumberExact]))
+    Assert.IsTrue(TypeGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsString(T.patternProperties[PatternNumberExact]))
     Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 8', () => {
     const T = Type.Record(Type.Integer(), Type.String(), { extra: 1 })
-    Assert.IsTrue(TypeGuard.TRecord(T))
-    Assert.IsTrue(TypeGuard.TString(T.patternProperties[PatternNumberExact]))
+    Assert.IsTrue(TypeGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsString(T.patternProperties[PatternNumberExact]))
     Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 9', () => {
     const T = Type.Record(Type.String(), Type.String(), { extra: 1 })
-    Assert.IsTrue(TypeGuard.TRecord(T))
-    Assert.IsTrue(TypeGuard.TString(T.patternProperties[PatternStringExact]))
+    Assert.IsTrue(TypeGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsString(T.patternProperties[PatternStringExact]))
     Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 10', () => {
     const L = Type.TemplateLiteral([Type.String(), Type.Literal('_foo')])
     const T = Type.Record(L, Type.String(), { extra: 1 })
-    Assert.IsTrue(TypeGuard.TRecord(T))
-    Assert.IsTrue(TypeGuard.TString(T.patternProperties[`^${PatternString}_foo$`]))
+    Assert.IsTrue(TypeGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsString(T.patternProperties[`^${PatternString}_foo$`]))
     Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 11', () => {
     const L = Type.Union([Type.Literal('A'), Type.Union([Type.Literal('B'), Type.Literal('C')])])
     const T = Type.Record(L, Type.String())
-    Assert.IsTrue(TypeGuard.TObject(T))
-    Assert.IsTrue(TypeGuard.TString(T.properties.A))
-    Assert.IsTrue(TypeGuard.TString(T.properties.B))
-    Assert.IsTrue(TypeGuard.TString(T.properties.C))
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.A))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.B))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.C))
   })
   it('Should guard overload 12', () => {
     enum E {
@@ -84,20 +84,20 @@ describe('type/guard/TRecord', () => {
     }
     const T = Type.Enum(E)
     const R = Type.Record(T, Type.Null())
-    Assert.IsTrue(TypeGuard.TObject(R))
-    Assert.IsTrue(TypeGuard.TNull(R.properties.X))
-    Assert.IsTrue(TypeGuard.TNull(R.properties.Y))
-    Assert.IsTrue(TypeGuard.TNull(R.properties.Z))
+    Assert.IsTrue(TypeGuard.IsObject(R))
+    Assert.IsTrue(TypeGuard.IsNull(R.properties.X))
+    Assert.IsTrue(TypeGuard.IsNull(R.properties.Y))
+    Assert.IsTrue(TypeGuard.IsNull(R.properties.Z))
   })
   // -------------------------------------------------------------
   // Variants
   // -------------------------------------------------------------
   it('Should guard for TRecord', () => {
-    const R = TypeGuard.TRecord(Type.Record(Type.String(), Type.Number()))
+    const R = TypeGuard.IsRecord(Type.Record(Type.String(), Type.Number()))
     Assert.IsTrue(R)
   })
   it('Should guard for TRecord with TObject value', () => {
-    const R = TypeGuard.TRecord(
+    const R = TypeGuard.IsRecord(
       Type.Record(
         Type.String(),
         Type.Object({
@@ -109,16 +109,16 @@ describe('type/guard/TRecord', () => {
     Assert.IsTrue(R)
   })
   it('Should not guard for TRecord', () => {
-    const R = TypeGuard.TRecord(null)
+    const R = TypeGuard.IsRecord(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TRecord with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TRecord(Type.Record(Type.String(), Type.Number(), { $id: 1 }))
+    const R = TypeGuard.IsRecord(Type.Record(Type.String(), Type.Number(), { $id: 1 }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TRecord with TObject value with invalid Property', () => {
-    const R = TypeGuard.TRecord(
+    const R = TypeGuard.IsRecord(
       Type.Record(
         Type.String(),
         Type.Object({
@@ -131,12 +131,12 @@ describe('type/guard/TRecord', () => {
   })
   it('Normalize: Should should normalize to TObject for single literal union value', () => {
     const K = Type.Union([Type.Literal('ok')])
-    const R = TypeGuard.TObject(Type.Record(K, Type.Number()))
+    const R = TypeGuard.IsObject(Type.Record(K, Type.Number()))
     Assert.IsTrue(R)
   })
   it('Normalize: Should should normalize to TObject for multi literal union value', () => {
     const K = Type.Union([Type.Literal('A'), Type.Literal('B')])
-    const R = TypeGuard.TObject(Type.Record(K, Type.Number()))
+    const R = TypeGuard.IsObject(Type.Record(K, Type.Number()))
     Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/guard/recursive.ts b/test/runtime/type/guard/recursive.ts
index 8585e17b1..57c6fe775 100644
--- a/test/runtime/type/guard/recursive.ts
+++ b/test/runtime/type/guard/recursive.ts
@@ -5,12 +5,12 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TRecursive', () => {
   it('Should guard 1', () => {
     const T = Type.Recursive((This) => Type.Object({ nodes: This }))
-    Assert.IsTrue(TypeGuard.TRecursive(T))
-    Assert.IsTrue(TypeGuard.TObject(T))
+    Assert.IsTrue(TypeGuard.IsRecursive(T))
+    Assert.IsTrue(TypeGuard.IsObject(T))
   })
   it('Should guard 2', () => {
     const T = Type.Recursive((This) => Type.Tuple([This]))
-    Assert.IsTrue(TypeGuard.TRecursive(T))
-    Assert.IsTrue(TypeGuard.TTuple(T))
+    Assert.IsTrue(TypeGuard.IsRecursive(T))
+    Assert.IsTrue(TypeGuard.IsTuple(T))
   })
 })
diff --git a/test/runtime/type/guard/ref.ts b/test/runtime/type/guard/ref.ts
index 83682d29d..e2b5a74b8 100644
--- a/test/runtime/type/guard/ref.ts
+++ b/test/runtime/type/guard/ref.ts
@@ -5,11 +5,11 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TRef', () => {
   it('Should guard for TRef', () => {
     const T = Type.Number({ $id: 'T' })
-    const R = TypeGuard.TRef(Type.Ref(T))
+    const R = TypeGuard.IsRef(Type.Ref(T))
     Assert.IsTrue(R)
   })
   it('Should not guard for TRef', () => {
-    const R = TypeGuard.TRef(null)
+    const R = TypeGuard.IsRef(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TRef with invalid $ref', () => {
@@ -17,7 +17,7 @@ describe('type/guard/TRef', () => {
     const S = Type.Ref(T)
     // @ts-ignore
     S.$ref = 1
-    const R = TypeGuard.TRef(S)
+    const R = TypeGuard.IsRef(S)
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/regexp.ts b/test/runtime/type/guard/regexp.ts
new file mode 100644
index 000000000..845c1753d
--- /dev/null
+++ b/test/runtime/type/guard/regexp.ts
@@ -0,0 +1,23 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/guard/TRegExp', () => {
+  it('Should guard for TRegExp 1', () => {
+    const T = Type.RegExp(/foo/, { $id: 'T' })
+    Assert.IsTrue(TypeGuard.IsSchema(T))
+  })
+  it('Should guard for TRegExp 1', () => {
+    const T = Type.RegExp(/foo/, { $id: 'T' })
+    Assert.IsTrue(TypeGuard.IsRegExp(T))
+  })
+  it('Should guard for TRegExp 2', () => {
+    const T = Type.RegExp('foo', { $id: 'T' })
+    Assert.IsTrue(TypeGuard.IsRegExp(T))
+  })
+  it('Should not guard for TRegExp 1', () => {
+    // @ts-ignore
+    const T = Type.RegExp('foo', { $id: 1 })
+    Assert.IsFalse(TypeGuard.IsRegExp(T))
+  })
+})
diff --git a/test/runtime/type/guard/required.ts b/test/runtime/type/guard/required.ts
index 5af8134d5..e4315e912 100644
--- a/test/runtime/type/guard/required.ts
+++ b/test/runtime/type/guard/required.ts
@@ -1,10 +1,10 @@
-import { TypeGuard, TypeRegistry, Type, Kind, Transform } from '@sinclair/typebox'
+import { TypeGuard, TypeRegistry, Type, Kind, TransformKind } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/TRequired', () => {
   it('Should produce a valid TSchema', () => {
     const T = Type.Required(Type.Object({ x: Type.Number() }))
-    Assert.IsTrue(TypeGuard.TSchema(T))
+    Assert.IsTrue(TypeGuard.IsSchema(T))
   })
   it('Should support TUnsafe required properties with no Kind', () => {
     const T = Type.Required(Type.Object({ x: Type.Optional(Type.Unsafe({ x: 1 })) }))
@@ -59,6 +59,6 @@ describe('type/guard/TRequired', () => {
       .Decode((value) => value)
       .Encode((value) => value)
     const R = Type.Required(S)
-    Assert.IsFalse(Transform in R)
+    Assert.IsFalse(TransformKind in R)
   })
 })
diff --git a/test/runtime/type/guard/rest.ts b/test/runtime/type/guard/rest.ts
index 4c22803d5..dc018d6e7 100644
--- a/test/runtime/type/guard/rest.ts
+++ b/test/runtime/type/guard/rest.ts
@@ -6,29 +6,29 @@ describe('type/guard/TRest', () => {
     // union never
     const A = Type.String()
     const B = Type.Union(Type.Rest(A))
-    Assert.IsTrue(TypeGuard.TNever(B))
+    Assert.IsTrue(TypeGuard.IsNever(B))
   })
   it('Should guard 2', () => {
     // intersect never
     const A = Type.String()
     const B = Type.Intersect(Type.Rest(A))
-    Assert.IsTrue(TypeGuard.TNever(B))
+    Assert.IsTrue(TypeGuard.IsNever(B))
   })
   it('Should guard 3', () => {
     // tuple
     const A = Type.Tuple([Type.Number(), Type.String()])
     const B = Type.Union(Type.Rest(A))
-    Assert.IsTrue(TypeGuard.TUnion(B))
+    Assert.IsTrue(TypeGuard.IsUnion(B))
     Assert.IsEqual(B.anyOf.length, 2)
-    Assert.IsTrue(TypeGuard.TNumber(B.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TString(B.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsNumber(B.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsString(B.anyOf[1]))
   })
   it('Should guard 4', () => {
     // tuple spread
     const A = Type.Tuple([Type.Literal(1), Type.Literal(2)])
     const B = Type.Tuple([Type.Literal(3), Type.Literal(4)])
     const C = Type.Tuple([...Type.Rest(A), ...Type.Rest(B)])
-    Assert.IsTrue(TypeGuard.TTuple(C))
+    Assert.IsTrue(TypeGuard.IsTuple(C))
     Assert.IsEqual(C.items!.length, 4)
     Assert.IsEqual(C.items![0].const, 1)
     Assert.IsEqual(C.items![1].const, 2)
@@ -41,10 +41,10 @@ describe('type/guard/TRest', () => {
     const B = Type.Object({ y: Type.String() })
     const C = Type.Union([A, B])
     const D = Type.Intersect(Type.Rest(C))
-    Assert.IsTrue(TypeGuard.TIntersect(D))
+    Assert.IsTrue(TypeGuard.IsIntersect(D))
     Assert.IsEqual(D.allOf.length, 2)
-    Assert.IsTrue(TypeGuard.TObject(D.allOf[0]))
-    Assert.IsTrue(TypeGuard.TObject(D.allOf[1]))
+    Assert.IsTrue(TypeGuard.IsObject(D.allOf[0]))
+    Assert.IsTrue(TypeGuard.IsObject(D.allOf[1]))
   })
   it('Should guard 6', () => {
     // intersect to composite
@@ -52,8 +52,8 @@ describe('type/guard/TRest', () => {
     const B = Type.Object({ y: Type.String() })
     const C = Type.Intersect([A, B])
     const D = Type.Composite(Type.Rest(C))
-    Assert.IsTrue(TypeGuard.TObject(D))
-    Assert.IsTrue(TypeGuard.TNumber(D.properties.x))
-    Assert.IsTrue(TypeGuard.TString(D.properties.y))
+    Assert.IsTrue(TypeGuard.IsObject(D))
+    Assert.IsTrue(TypeGuard.IsNumber(D.properties.x))
+    Assert.IsTrue(TypeGuard.IsString(D.properties.y))
   })
 })
diff --git a/test/runtime/type/guard/string.ts b/test/runtime/type/guard/string.ts
index 50205a1da..5eb862683 100644
--- a/test/runtime/type/guard/string.ts
+++ b/test/runtime/type/guard/string.ts
@@ -4,31 +4,31 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TString', () => {
   it('Should guard for TString', () => {
-    const R = TypeGuard.TString(Type.String())
+    const R = TypeGuard.IsString(Type.String())
     Assert.IsTrue(R)
   })
   it('Should not guard for TString', () => {
-    const R = TypeGuard.TString(null)
+    const R = TypeGuard.IsString(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TString with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TString(Type.String({ $id: 1 }))
+    const R = TypeGuard.IsString(Type.String({ $id: 1 }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TString with invalid minLength', () => {
     // @ts-ignore
-    const R = TypeGuard.TString(Type.String({ minLength: '1' }))
+    const R = TypeGuard.IsString(Type.String({ minLength: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TString with invalid maxLength', () => {
     // @ts-ignore
-    const R = TypeGuard.TString(Type.String({ maxLength: '1' }))
+    const R = TypeGuard.IsString(Type.String({ maxLength: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TString with invalid pattern', () => {
     // @ts-ignore
-    const R = TypeGuard.TString(Type.String({ pattern: 1 }))
+    const R = TypeGuard.IsString(Type.String({ pattern: 1 }))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/symbol.ts b/test/runtime/type/guard/symbol.ts
index 28041bfe2..8723b2151 100644
--- a/test/runtime/type/guard/symbol.ts
+++ b/test/runtime/type/guard/symbol.ts
@@ -4,16 +4,16 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TSymbol', () => {
   it('Should guard for TSymbol', () => {
-    const R = TypeGuard.TSymbol(Type.Symbol())
+    const R = TypeGuard.IsSymbol(Type.Symbol())
     Assert.IsTrue(R)
   })
   it('Should not guard for TSymbol', () => {
-    const R = TypeGuard.TSymbol(null)
+    const R = TypeGuard.IsSymbol(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TSymbol with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TSymbol(Type.Symbol({ $id: 1 }))
+    const R = TypeGuard.IsSymbol(Type.Symbol({ $id: 1 }))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/template-literal.ts b/test/runtime/type/guard/template-literal.ts
index 7637133c6..b24518e08 100644
--- a/test/runtime/type/guard/template-literal.ts
+++ b/test/runtime/type/guard/template-literal.ts
@@ -4,44 +4,44 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TTemplateLiteral', () => {
   it('Should guard for empty TemplateLiteral', () => {
-    const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([]))
+    const R = TypeGuard.IsTemplateLiteral(Type.TemplateLiteral([]))
     Assert.IsTrue(R)
   })
   it('Should guard for TSchema', () => {
-    const R = TypeGuard.TSchema(Type.TemplateLiteral([]))
+    const R = TypeGuard.IsSchema(Type.TemplateLiteral([]))
     Assert.IsTrue(R)
   })
   it('Should guard for TemplateLiteral (TTemplateLiteral)', () => {
     const T = Type.TemplateLiteral([Type.Literal('hello')])
-    const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([T, Type.Literal('world')]))
+    const R = TypeGuard.IsTemplateLiteral(Type.TemplateLiteral([T, Type.Literal('world')]))
     Assert.IsTrue(R)
   })
   it('Should guard for TemplateLiteral (TLiteral)', () => {
-    const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([Type.Literal('hello')]))
+    const R = TypeGuard.IsTemplateLiteral(Type.TemplateLiteral([Type.Literal('hello')]))
     Assert.IsTrue(R)
   })
   it('Should guard for TemplateLiteral (TString)', () => {
-    const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([Type.String()]))
+    const R = TypeGuard.IsTemplateLiteral(Type.TemplateLiteral([Type.String()]))
     Assert.IsTrue(R)
   })
   it('Should guard for TemplateLiteral (TNumber)', () => {
-    const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([Type.Number()]))
+    const R = TypeGuard.IsTemplateLiteral(Type.TemplateLiteral([Type.Number()]))
     Assert.IsTrue(R)
   })
   it('Should guard for TemplateLiteral (TBoolean)', () => {
-    const R = TypeGuard.TTemplateLiteral(Type.TemplateLiteral([Type.Boolean()]))
+    const R = TypeGuard.IsTemplateLiteral(Type.TemplateLiteral([Type.Boolean()]))
     Assert.IsTrue(R)
   })
   it('Should not guard for missing ^ expression prefix', () => {
     const T = Type.TemplateLiteral([Type.Literal('hello')])
     // @ts-ignore
     T.pattern = T.pattern.slice(1)
-    Assert.IsFalse(TypeGuard.TTemplateLiteral(T))
+    Assert.IsFalse(TypeGuard.IsTemplateLiteral(T))
   })
   it('Should not guard for missing $ expression postfix', () => {
     const T = Type.TemplateLiteral([Type.Literal('hello')])
     // @ts-ignore
     T.pattern = T.pattern.slice(0, T.pattern.length - 1)
-    Assert.IsFalse(TypeGuard.TTemplateLiteral(T))
+    Assert.IsFalse(TypeGuard.IsTemplateLiteral(T))
   })
 })
diff --git a/test/runtime/type/guard/this.ts b/test/runtime/type/guard/this.ts
index 93508d53c..8ca3a7e0d 100644
--- a/test/runtime/type/guard/this.ts
+++ b/test/runtime/type/guard/this.ts
@@ -5,7 +5,7 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TThis', () => {
   it('Should guard for TThis', () => {
     Type.Recursive((This) => {
-      const R = TypeGuard.TThis(This)
+      const R = TypeGuard.IsThis(This)
       Assert.IsTrue(R)
       return Type.Object({ nodes: Type.Array(This) })
     })
@@ -14,7 +14,7 @@ describe('type/guard/TThis', () => {
     Type.Recursive((This) => {
       // @ts-ignore
       This.$ref = 1
-      const R = TypeGuard.TThis(This)
+      const R = TypeGuard.IsThis(This)
       Assert.IsFalse(R)
       return Type.Object({ nodes: Type.Array(This) })
     })
diff --git a/test/runtime/type/guard/tuple.ts b/test/runtime/type/guard/tuple.ts
index 9326c23d2..31a15c280 100644
--- a/test/runtime/type/guard/tuple.ts
+++ b/test/runtime/type/guard/tuple.ts
@@ -4,20 +4,20 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TTuple', () => {
   it('Should guard for TTuple', () => {
-    const R = TypeGuard.TTuple(Type.Tuple([Type.Number(), Type.Number()]))
+    const R = TypeGuard.IsTuple(Type.Tuple([Type.Number(), Type.Number()]))
     Assert.IsTrue(R)
   })
   it('Should not guard for TTuple', () => {
-    const R = TypeGuard.TTuple(null)
+    const R = TypeGuard.IsTuple(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TTuple with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TTuple(Type.Tuple([Type.Number(), Type.Number()], { $id: 1 }))
+    const R = TypeGuard.IsTuple(Type.Tuple([Type.Number(), Type.Number()], { $id: 1 }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TTuple with invalid Items', () => {
-    const R = TypeGuard.TTuple(Type.Tuple([Type.Number(), {} as any]))
+    const R = TypeGuard.IsTuple(Type.Tuple([Type.Number(), {} as any]))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/uint8array.ts b/test/runtime/type/guard/uint8array.ts
index cc058d8b3..de668fd9f 100644
--- a/test/runtime/type/guard/uint8array.ts
+++ b/test/runtime/type/guard/uint8array.ts
@@ -4,26 +4,26 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TUint8Array', () => {
   it('Should guard for TUint8Array', () => {
-    const R = TypeGuard.TUint8Array(Type.Uint8Array())
+    const R = TypeGuard.IsUint8Array(Type.Uint8Array())
     Assert.IsTrue(R)
   })
   it('Should not guard for TUint8Array', () => {
-    const R = TypeGuard.TUint8Array(null)
+    const R = TypeGuard.IsUint8Array(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TUint8Array with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TUint8Array(Type.Uint8Array({ $id: 1 }))
+    const R = TypeGuard.IsUint8Array(Type.Uint8Array({ $id: 1 }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TUint8Array with invalid minByteLength', () => {
     // @ts-ignore
-    const R = TypeGuard.TUint8Array(Type.Uint8Array({ minByteLength: '1' }))
+    const R = TypeGuard.IsUint8Array(Type.Uint8Array({ minByteLength: '1' }))
     Assert.IsFalse(R)
   })
   it('Should not guard for TUint8Array with invalid maxByteLength', () => {
     // @ts-ignore
-    const R = TypeGuard.TUint8Array(Type.Uint8Array({ maxByteLength: '1' }))
+    const R = TypeGuard.IsUint8Array(Type.Uint8Array({ maxByteLength: '1' }))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/uncapitalize.ts b/test/runtime/type/guard/uncapitalize.ts
index d54b4e584..ff412676a 100644
--- a/test/runtime/type/guard/uncapitalize.ts
+++ b/test/runtime/type/guard/uncapitalize.ts
@@ -4,30 +4,30 @@ import { Assert } from '../../assert/index'
 describe('type/guard/Uncapitalize', () => {
   it('Should guard for Uncapitalize 1', () => {
     const T = Type.Uncapitalize(Type.Literal('HELLO'), { $id: 'hello', foo: 1 })
-    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
     Assert.IsEqual(T.const, 'hELLO')
     Assert.IsEqual(T.$id, 'hello')
     Assert.IsEqual(T.foo, 1)
   })
   it('Should guard for Uncapitalize 2', () => {
     const T = Type.Uncapitalize(Type.Literal('HELLO'))
-    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
     Assert.IsEqual(T.const, 'hELLO')
   })
   it('Should guard for Uncapitalize 3', () => {
     const T = Type.Uncapitalize(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD')]))
-    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsEqual(T.anyOf[0].const, 'hELLO')
     Assert.IsEqual(T.anyOf[1].const, 'wORLD')
   })
   it('Should guard for Uncapitalize 4', () => {
     const T = Type.Uncapitalize(Type.TemplateLiteral('HELLO${0|1}'))
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(hELLO0|hELLO1)$')
   })
   it('Should guard for Uncapitalize 5', () => {
     const T = Type.Uncapitalize(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(0), Type.Literal(1)])]))
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(hELLO0|hELLO1)$')
   })
 })
diff --git a/test/runtime/type/guard/undefined.ts b/test/runtime/type/guard/undefined.ts
index 8393bff76..a6389f4e6 100644
--- a/test/runtime/type/guard/undefined.ts
+++ b/test/runtime/type/guard/undefined.ts
@@ -4,16 +4,16 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TUndefined', () => {
   it('Should guard for TUndefined', () => {
-    const R = TypeGuard.TUndefined(Type.Undefined())
+    const R = TypeGuard.IsUndefined(Type.Undefined())
     Assert.IsTrue(R)
   })
   it('Should not guard for TUndefined', () => {
-    const R = TypeGuard.TUndefined(null)
+    const R = TypeGuard.IsUndefined(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TUndefined with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TUndefined(Type.Undefined({ $id: 1 }))
+    const R = TypeGuard.IsUndefined(Type.Undefined({ $id: 1 }))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/union.ts b/test/runtime/type/guard/union.ts
index 62b485e40..edcf34043 100644
--- a/test/runtime/type/guard/union.ts
+++ b/test/runtime/type/guard/union.ts
@@ -1,10 +1,10 @@
-import { TypeGuard } from '@sinclair/typebox'
+import { TSchema, TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/TUnion', () => {
   it('Should guard for TUnion', () => {
-    const R = TypeGuard.TUnion(
+    const R = TypeGuard.IsUnion(
       Type.Union([
         Type.Object({
           x: Type.Number(),
@@ -17,11 +17,11 @@ describe('type/guard/TUnion', () => {
     Assert.IsTrue(R)
   })
   it('Should not guard for TUnion', () => {
-    const R = TypeGuard.TUnion(null)
+    const R = TypeGuard.IsUnion(null)
     Assert.IsFalse(R)
   })
   it('Should guard for TUnion with invalid $id', () => {
-    const R = TypeGuard.TUnion(
+    const R = TypeGuard.IsUnion(
       // @ts-ignore
       Type.Union(
         [
@@ -41,18 +41,18 @@ describe('type/guard/TUnion', () => {
     Assert.IsFalse(R)
   })
   it('Should not guard for TUnion with invalid variant', () => {
-    const R = TypeGuard.TUnion(
+    const R = TypeGuard.IsUnion(
       Type.Union([
         Type.Object({
           x: Type.Number(),
         }),
-        {} as any,
+        {} as TSchema,
       ]),
     )
     Assert.IsFalse(R)
   })
   it('Should not guard for TUnion with invalid object variant', () => {
-    const R = TypeGuard.TUnion(
+    const R = TypeGuard.IsUnion(
       Type.Union([
         Type.Object({
           x: Type.Number(),
@@ -66,19 +66,19 @@ describe('type/guard/TUnion', () => {
   })
   it('Transform: Should transform to never for zero length union', () => {
     const T = Type.Union([])
-    const R = TypeGuard.TNever(T)
+    const R = TypeGuard.IsNever(T)
     Assert.IsTrue(R)
   })
   it('Transform: Should unwrap union type for array of length === 1', () => {
     const T = Type.Union([Type.String()])
-    const R = TypeGuard.TString(T)
+    const R = TypeGuard.IsString(T)
     Assert.IsTrue(R)
   })
   it('Transform: Should retain union if array length > 1', () => {
     const T = Type.Union([Type.String(), Type.Number()])
-    const R1 = TypeGuard.TUnion(T)
-    const R2 = TypeGuard.TString(T.anyOf[0])
-    const R3 = TypeGuard.TNumber(T.anyOf[1])
+    const R1 = TypeGuard.IsUnion(T)
+    const R2 = TypeGuard.IsString(T.anyOf[0])
+    const R3 = TypeGuard.IsNumber(T.anyOf[1])
     Assert.IsTrue(R1)
     Assert.IsTrue(R2)
     Assert.IsTrue(R3)
diff --git a/test/runtime/type/guard/unknown.ts b/test/runtime/type/guard/unknown.ts
index bd5cfcd03..cc488fd74 100644
--- a/test/runtime/type/guard/unknown.ts
+++ b/test/runtime/type/guard/unknown.ts
@@ -4,16 +4,16 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TUnknown', () => {
   it('Should guard for TUnknown', () => {
-    const R = TypeGuard.TUnknown(Type.Unknown())
+    const R = TypeGuard.IsUnknown(Type.Unknown())
     Assert.IsTrue(R)
   })
   it('Should not guard for TUnknown', () => {
-    const R = TypeGuard.TUnknown(null)
+    const R = TypeGuard.IsUnknown(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TUnknown with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TUnknown(Type.Unknown({ $id: 1 }))
+    const R = TypeGuard.IsUnknown(Type.Unknown({ $id: 1 }))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/unsafe.ts b/test/runtime/type/guard/unsafe.ts
index f43a2d78d..5691abea8 100644
--- a/test/runtime/type/guard/unsafe.ts
+++ b/test/runtime/type/guard/unsafe.ts
@@ -5,29 +5,29 @@ import { Assert } from '../../assert/index'
 describe('type/guard/TUnsafe', () => {
   it('Should guard raw TUnsafe', () => {
     const T = Type.Unsafe({ x: 1 })
-    const R = TypeGuard.TUnsafe(T)
+    const R = TypeGuard.IsUnsafe(T)
     Assert.IsTrue(R)
   })
   it('Should guard raw TUnsafe as TSchema', () => {
     const T = Type.Unsafe({ x: 1 })
-    const R = TypeGuard.TSchema(T)
+    const R = TypeGuard.IsSchema(T)
     Assert.IsTrue(R)
   })
   it('Should guard override TUnsafe as TSchema when registered', () => {
     TypeRegistry.Set('UnsafeType', () => true)
     const T = Type.Unsafe({ [Kind]: 'UnsafeType' })
-    const R = TypeGuard.TSchema(T)
+    const R = TypeGuard.IsSchema(T)
     Assert.IsTrue(R)
     TypeRegistry.Delete('UnsafeType')
   })
   it('Should not guard TUnsafe with unregistered kind', () => {
     const T = Type.Unsafe({ [Kind]: 'UnsafeType' })
-    const R = TypeGuard.TUnsafe(T)
+    const R = TypeGuard.IsUnsafe(T)
     Assert.IsFalse(R)
   })
   it('Should not guard for TString', () => {
     const T = Type.String()
-    const R = TypeGuard.TUnsafe(T)
+    const R = TypeGuard.IsUnsafe(T)
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/guard/uppercase.ts b/test/runtime/type/guard/uppercase.ts
index 602ddf400..539a93755 100644
--- a/test/runtime/type/guard/uppercase.ts
+++ b/test/runtime/type/guard/uppercase.ts
@@ -4,30 +4,30 @@ import { Assert } from '../../assert/index'
 describe('type/guard/Uppercase', () => {
   it('Should guard for Uppercase 1', () => {
     const T = Type.Uppercase(Type.Literal('hello'), { $id: 'hello', foo: 1 })
-    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
     Assert.IsEqual(T.const, 'HELLO')
     Assert.IsEqual(T.$id, 'hello')
     Assert.IsEqual(T.foo, 1)
   })
   it('Should guard for Uppercase 2', () => {
     const T = Type.Uppercase(Type.Literal('hello'))
-    Assert.IsTrue(TypeGuard.TLiteral(T))
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
     Assert.IsEqual(T.const, 'HELLO')
   })
   it('Should guard for Uppercase 3', () => {
     const T = Type.Uppercase(Type.Union([Type.Literal('hello'), Type.Literal('world')]))
-    Assert.IsTrue(TypeGuard.TUnion(T))
+    Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsEqual(T.anyOf[0].const, 'HELLO')
     Assert.IsEqual(T.anyOf[1].const, 'WORLD')
   })
   it('Should guard for Uppercase 4', () => {
     const T = Type.Uppercase(Type.TemplateLiteral('hello${0|1}'))
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(HELLO0|HELLO1)$')
   })
   it('Should guard for Uppercase 5', () => {
     const T = Type.Uppercase(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(0), Type.Literal(1)])]))
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(HELLO0|HELLO1)$')
   })
 })
diff --git a/test/runtime/type/guard/void.ts b/test/runtime/type/guard/void.ts
index fb60e97a7..9c1f52beb 100644
--- a/test/runtime/type/guard/void.ts
+++ b/test/runtime/type/guard/void.ts
@@ -4,16 +4,16 @@ import { Assert } from '../../assert/index'
 
 describe('type/guard/TVoid', () => {
   it('Should guard for TVoid', () => {
-    const R = TypeGuard.TVoid(Type.Void())
+    const R = TypeGuard.IsVoid(Type.Void())
     Assert.IsTrue(R)
   })
   it('Should not guard for TVoid', () => {
-    const R = TypeGuard.TVoid(null)
+    const R = TypeGuard.IsVoid(null)
     Assert.IsFalse(R)
   })
   it('Should not guard for TVoid with invalid $id', () => {
     // @ts-ignore
-    const R = TypeGuard.TVoid(Type.Void({ $id: 1 }))
+    const R = TypeGuard.IsVoid(Type.Void({ $id: 1 }))
     Assert.IsFalse(R)
   })
 })
diff --git a/test/runtime/type/index.ts b/test/runtime/type/index.ts
index bc394a539..f5cfcd709 100644
--- a/test/runtime/type/index.ts
+++ b/test/runtime/type/index.ts
@@ -4,5 +4,5 @@ import './guard/index'
 import './intrinsic/index'
 import './normalize/index'
 import './registry/index'
-import './template/index'
+import './template-literal/index'
 import './value/index'
diff --git a/test/runtime/type/intrinsic/intrinsic.ts b/test/runtime/type/intrinsic/intrinsic.ts
index 3ff191aee..a6a18f34e 100644
--- a/test/runtime/type/intrinsic/intrinsic.ts
+++ b/test/runtime/type/intrinsic/intrinsic.ts
@@ -1,27 +1,28 @@
-import { TypeGuard, Intrinsic } from '@sinclair/typebox'
+import { TypeGuard } from '@sinclair/typebox'
+import { Intrinsic } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/intrinsic/Map', () => {
+describe('type/intrinsic/Intrinsic', () => {
   // ----------------------------------------------------
   // Passthrough
   // ----------------------------------------------------
   it('Should passthrough 1', () => {
-    const T = Intrinsic.Map(Type.String(), 'Capitalize')
-    Assert.IsTrue(TypeGuard.TString(T))
+    const T = Intrinsic(Type.String(), 'Capitalize')
+    Assert.IsTrue(TypeGuard.IsString(T))
   })
   it('Should passthrough 2', () => {
-    const T = Intrinsic.Map(Type.Number(), 'Capitalize')
-    Assert.IsTrue(TypeGuard.TNumber(T))
+    const T = Intrinsic(Type.Number(), 'Capitalize')
+    Assert.IsTrue(TypeGuard.IsNumber(T))
   })
   it('Should passthrough 3', () => {
-    const T = Intrinsic.Map(
+    const T = Intrinsic(
       Type.Object({
         x: Type.Number(),
       }),
       'Capitalize',
     )
-    Assert.IsTrue(TypeGuard.TObject(T))
+    Assert.IsTrue(TypeGuard.IsObject(T))
   })
   // ----------------------------------------------------
   // Partial Passthrough
@@ -30,59 +31,59 @@ describe('type/intrinsic/Map', () => {
     const A = Type.Object({ x: Type.Number() })
     const B = Type.Literal('hello')
     const U = Type.Union([A, B])
-    const T = Intrinsic.Map(U, 'Capitalize')
-    Assert.IsTrue(TypeGuard.TUnion(T))
-    Assert.IsTrue(TypeGuard.TObject(T.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TLiteral(T.anyOf[1]))
+    const T = Intrinsic(U, 'Capitalize')
+    Assert.IsTrue(TypeGuard.IsUnion(T))
+    Assert.IsTrue(TypeGuard.IsObject(T.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsLiteral(T.anyOf[1]))
     Assert.IsEqual(T.anyOf[1].const, 'Hello')
   })
   // ----------------------------------------------------
   // Mode: Literal
   // ----------------------------------------------------
   it('Should map literal: Capitalize', () => {
-    const T = Intrinsic.Map(Type.Literal('hello'), 'Capitalize')
-    Assert.IsTrue(TypeGuard.TLiteral(T))
+    const T = Intrinsic(Type.Literal('hello'), 'Capitalize')
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
     Assert.IsEqual(T.const, 'Hello')
   })
   it('Should map literal: Uncapitalize', () => {
-    const T = Intrinsic.Map(Type.Literal('HELLO'), 'Uncapitalize')
-    Assert.IsTrue(TypeGuard.TLiteral(T))
+    const T = Intrinsic(Type.Literal('HELLO'), 'Uncapitalize')
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
     Assert.IsEqual(T.const, 'hELLO')
   })
   it('Should map literal: Uppercase', () => {
-    const T = Intrinsic.Map(Type.Literal('hello'), 'Uppercase')
-    Assert.IsTrue(TypeGuard.TLiteral(T))
+    const T = Intrinsic(Type.Literal('hello'), 'Uppercase')
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
     Assert.IsEqual(T.const, 'HELLO')
   })
   it('Should map literal: Lowercase', () => {
-    const T = Intrinsic.Map(Type.Literal('HELLO'), 'Lowercase')
-    Assert.IsTrue(TypeGuard.TLiteral(T))
+    const T = Intrinsic(Type.Literal('HELLO'), 'Lowercase')
+    Assert.IsTrue(TypeGuard.IsLiteral(T))
     Assert.IsEqual(T.const, 'hello')
   })
   // ----------------------------------------------------
   // Mode: Literal Union
   // ----------------------------------------------------
   it('Should map literal union: Capitalize', () => {
-    const T = Intrinsic.Map(Type.Union([Type.Literal('hello'), Type.Literal('world')]), 'Capitalize')
-    Assert.IsTrue(TypeGuard.TUnion(T))
+    const T = Intrinsic(Type.Union([Type.Literal('hello'), Type.Literal('world')]), 'Capitalize')
+    Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsEqual(T.anyOf[0].const, 'Hello')
     Assert.IsEqual(T.anyOf[1].const, 'World')
   })
   it('Should map literal union: Uncapitalize', () => {
-    const T = Intrinsic.Map(Type.Union([Type.Literal('Hello'), Type.Literal('World')]), 'Uncapitalize')
-    Assert.IsTrue(TypeGuard.TUnion(T))
+    const T = Intrinsic(Type.Union([Type.Literal('Hello'), Type.Literal('World')]), 'Uncapitalize')
+    Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsEqual(T.anyOf[0].const, 'hello')
     Assert.IsEqual(T.anyOf[1].const, 'world')
   })
   it('Should map literal union: Uppercase', () => {
-    const T = Intrinsic.Map(Type.Union([Type.Literal('hello'), Type.Literal('world')]), 'Uppercase')
-    Assert.IsTrue(TypeGuard.TUnion(T))
+    const T = Intrinsic(Type.Union([Type.Literal('hello'), Type.Literal('world')]), 'Uppercase')
+    Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsEqual(T.anyOf[0].const, 'HELLO')
     Assert.IsEqual(T.anyOf[1].const, 'WORLD')
   })
   it('Should map literal union: Lowercase', () => {
-    const T = Intrinsic.Map(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD')]), 'Lowercase')
-    Assert.IsTrue(TypeGuard.TUnion(T))
+    const T = Intrinsic(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD')]), 'Lowercase')
+    Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsEqual(T.anyOf[0].const, 'hello')
     Assert.IsEqual(T.anyOf[1].const, 'world')
   })
@@ -90,74 +91,74 @@ describe('type/intrinsic/Map', () => {
   // Mode: TemplateLiteral
   // ----------------------------------------------------
   it('Should map template literal: Capitalize', () => {
-    const T = Intrinsic.Map(Type.TemplateLiteral('hello${1|2}world'), 'Capitalize')
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    const T = Intrinsic(Type.TemplateLiteral('hello${1|2}world'), 'Capitalize')
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(Hello1world|Hello2world)$')
   })
   it('Should map template literal: Uncapitalize', () => {
-    const T = Intrinsic.Map(Type.TemplateLiteral('HELLO${1|2}WORLD'), 'Uncapitalize')
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    const T = Intrinsic(Type.TemplateLiteral('HELLO${1|2}WORLD'), 'Uncapitalize')
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(hELLO1WORLD|hELLO2WORLD)$')
   })
   it('Should map template literal: Uppercase', () => {
-    const T = Intrinsic.Map(Type.TemplateLiteral('hello${1|2}world'), 'Uppercase')
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    const T = Intrinsic(Type.TemplateLiteral('hello${1|2}world'), 'Uppercase')
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(HELLO1WORLD|HELLO2WORLD)$')
   })
   it('Should map template literal: Lowercase', () => {
-    const T = Intrinsic.Map(Type.TemplateLiteral('HELLO${1|2}WORLD'), 'Lowercase')
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    const T = Intrinsic(Type.TemplateLiteral('HELLO${1|2}WORLD'), 'Lowercase')
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(hello1world|hello2world)$')
   })
   // ----------------------------------------------------
   // Mode: TemplateLiteral Numeric
   // ----------------------------------------------------
   it('Should map template literal numeric: Capitalize', () => {
-    const T = Intrinsic.Map(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(1), Type.Literal(2)])]), 'Capitalize')
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    const T = Intrinsic(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(1), Type.Literal(2)])]), 'Capitalize')
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(Hello1|Hello2)$')
   })
   it('Should map template literal numeric: Uncapitalize', () => {
-    const T = Intrinsic.Map(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(1), Type.Literal(2)])]), 'Uncapitalize')
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    const T = Intrinsic(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(1), Type.Literal(2)])]), 'Uncapitalize')
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(hELLO1|hELLO2)$')
   })
   it('Should map template literal numeric: Uppercase', () => {
-    const T = Intrinsic.Map(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(1), Type.Literal(2)])]), 'Uppercase')
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    const T = Intrinsic(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(1), Type.Literal(2)])]), 'Uppercase')
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(HELLO1|HELLO2)$')
   })
   it('Should map template literal numeric: Lowercase', () => {
-    const T = Intrinsic.Map(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(1), Type.Literal(2)])]), 'Lowercase')
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    const T = Intrinsic(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(1), Type.Literal(2)])]), 'Lowercase')
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(hello1|hello2)$')
   })
   // ----------------------------------------------------
   // Mode: TemplateLiteral Patterns
   // ----------------------------------------------------
   it('Should map template literal patterns 1', () => {
-    const T = Intrinsic.Map(Type.TemplateLiteral('HELLO${string}WORLD'), 'Lowercase')
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    const T = Intrinsic(Type.TemplateLiteral('HELLO${string}WORLD'), 'Lowercase')
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^hello(.*)world$')
   })
   it('Should map template literal patterns 2', () => {
-    const T = Intrinsic.Map(Type.TemplateLiteral('HELLO${number}WORLD'), 'Lowercase')
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    const T = Intrinsic(Type.TemplateLiteral('HELLO${number}WORLD'), 'Lowercase')
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^hello(0|[1-9][0-9]*)world$')
   })
   it('Should map template literal patterns 3', () => {
-    const T = Intrinsic.Map(Type.TemplateLiteral('${number}${string}'), 'Lowercase')
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    const T = Intrinsic(Type.TemplateLiteral('${number}${string}'), 'Lowercase')
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(0|[1-9][0-9]*)(.*)$')
   })
   it('Should map template literal patterns 3', () => {
-    const T = Intrinsic.Map(Type.TemplateLiteral('${number}HELLO${string}'), 'Lowercase')
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    const T = Intrinsic(Type.TemplateLiteral('${number}HELLO${string}'), 'Lowercase')
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(0|[1-9][0-9]*)hello(.*)$')
   })
   it('Should map template literal patterns 3', () => {
-    const T = Intrinsic.Map(Type.TemplateLiteral('${string|number}HELLO'), 'Lowercase')
-    Assert.IsTrue(TypeGuard.TTemplateLiteral(T))
+    const T = Intrinsic(Type.TemplateLiteral('${string|number}HELLO'), 'Lowercase')
+    Assert.IsTrue(TypeGuard.IsTemplateLiteral(T))
     Assert.IsEqual(T.pattern, '^(stringhello|numberhello)$')
   })
 })
diff --git a/test/runtime/type/normalize/exclude.ts b/test/runtime/type/normalize/exclude.ts
index 908f16145..53fad9c4d 100644
--- a/test/runtime/type/normalize/exclude.ts
+++ b/test/runtime/type/normalize/exclude.ts
@@ -5,17 +5,17 @@ import { Assert } from '../../assert/index'
 describe('type/normalize/Exclude', () => {
   it('Normalize 1', () => {
     const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
-    const R = TypeGuard.TUnion(T)
+    const R = TypeGuard.IsUnion(T)
     Assert.IsTrue(R)
   })
   it('Normalize 2', () => {
     const T = Type.Exclude(Type.Union([Type.String(), Type.Number()]), Type.String())
-    const R = TypeGuard.TNumber(T)
+    const R = TypeGuard.IsNumber(T)
     Assert.IsTrue(R)
   })
   it('Normalize 3', () => {
     const T = Type.Exclude(Type.Union([Type.String()]), Type.String())
-    const R = TypeGuard.TNever(T)
+    const R = TypeGuard.IsNever(T)
     Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/normalize/extract.ts b/test/runtime/type/normalize/extract.ts
index e1dc98195..196ee0f4a 100644
--- a/test/runtime/type/normalize/extract.ts
+++ b/test/runtime/type/normalize/extract.ts
@@ -5,27 +5,27 @@ import { Assert } from '../../assert/index'
 describe('type/normalize/Extract', () => {
   it('Normalize 1', () => {
     const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Number()]))
-    const R = TypeGuard.TUnion(T)
+    const R = TypeGuard.IsUnion(T)
     Assert.IsTrue(R)
   })
   it('Normalize 2', () => {
     const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
-    const R = TypeGuard.TString(T)
+    const R = TypeGuard.IsString(T)
     Assert.IsTrue(R)
   })
   it('Normalize 3', () => {
     const T = Type.Extract(Type.Union([Type.String(), Type.Number()]), Type.String())
-    const R = TypeGuard.TString(T)
+    const R = TypeGuard.IsString(T)
     Assert.IsTrue(R)
   })
   it('Normalize 4', () => {
     const T = Type.Extract(Type.Union([Type.String()]), Type.String())
-    const R = TypeGuard.TString(T)
+    const R = TypeGuard.IsString(T)
     Assert.IsTrue(R)
   })
   it('Normalize 5', () => {
     const T = Type.Extract(Type.Union([]), Type.String())
-    const R = TypeGuard.TNever(T)
+    const R = TypeGuard.IsNever(T)
     Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/normalize/indexed.ts b/test/runtime/type/normalize/indexed.ts
index c149c66ae..543f9b580 100644
--- a/test/runtime/type/normalize/indexed.ts
+++ b/test/runtime/type/normalize/indexed.ts
@@ -9,7 +9,7 @@ describe('type/normalize/Index', () => {
   it('Normalize Array 1', () => {
     const T = Type.Array(Type.String())
     const I = Type.Index(T, Type.Number())
-    Assert.IsTrue(TypeGuard.TString(I))
+    Assert.IsTrue(TypeGuard.IsString(I))
   })
   // ---------------------------------------------------------
   // Tuple
@@ -17,33 +17,33 @@ describe('type/normalize/Index', () => {
   it('Normalize Tuple 1', () => {
     const T = Type.Tuple([Type.String(), Type.Number()])
     const I = Type.Index(T, Type.Number())
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[1]))
   })
   it('Normalize Tuple 2', () => {
     const T = Type.Tuple([Type.String(), Type.Number()])
     const I = Type.Index(T, [0, 1])
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[1]))
   })
   it('Normalize Tuple 3', () => {
     const T = Type.Tuple([Type.String(), Type.Number()])
     const I = Type.Index(T, ['0', '1'])
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TNumber(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsNumber(I.anyOf[1]))
   })
   it('Normalize Tuple 4', () => {
     const T = Type.Tuple([Type.String(), Type.Number()])
     const I = Type.Index(T, ['0'])
-    Assert.IsTrue(TypeGuard.TString(I))
+    Assert.IsTrue(TypeGuard.IsString(I))
   })
   it('Normalize Tuple 5', () => {
     const T = Type.Tuple([Type.String(), Type.Number()])
     const I = Type.Index(T, ['1'])
-    Assert.IsTrue(TypeGuard.TNumber(I))
+    Assert.IsTrue(TypeGuard.IsNumber(I))
   })
   // ---------------------------------------------------------
   // Intersect
@@ -51,47 +51,47 @@ describe('type/normalize/Index', () => {
   it('Normalize Intersect 1', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Optional(Type.String()) }), Type.Object({ x: Type.Optional(Type.String()) })])
     const I = Type.Index(T, ['x'])
-    Assert.IsTrue(TypeGuard.TOptional(I))
-    Assert.IsTrue(TypeGuard.TIntersect(I))
-    Assert.IsTrue(TypeGuard.TString(I.allOf[0]))
-    Assert.IsTrue(TypeGuard.TString(I.allOf[1]))
+    Assert.IsTrue(TypeGuard.IsOptional(I))
+    Assert.IsTrue(TypeGuard.IsIntersect(I))
+    Assert.IsTrue(TypeGuard.IsString(I.allOf[0]))
+    Assert.IsTrue(TypeGuard.IsString(I.allOf[1]))
   })
   it('Normalize Intersect 2', () => {
     const T = Type.Intersect([Type.Object({ x: Type.Optional(Type.String()) }), Type.Object({ x: Type.String() })])
     const I = Type.Index(T, ['x'])
-    Assert.IsFalse(TypeGuard.TOptional(I))
-    Assert.IsTrue(TypeGuard.TIntersect(I))
-    Assert.IsTrue(TypeGuard.TString(I.allOf[0]))
-    Assert.IsTrue(TypeGuard.TString(I.allOf[1]))
+    Assert.IsFalse(TypeGuard.IsOptional(I))
+    Assert.IsTrue(TypeGuard.IsIntersect(I))
+    Assert.IsTrue(TypeGuard.IsString(I.allOf[0]))
+    Assert.IsTrue(TypeGuard.IsString(I.allOf[1]))
   })
   it('Normalize Intersect 3', () => {
     const T = Type.Intersect([Type.Object({ x: Type.String() }), Type.Object({ x: Type.String() })])
     const I = Type.Index(T, ['x'])
-    Assert.IsFalse(TypeGuard.TOptional(I))
-    Assert.IsTrue(TypeGuard.TIntersect(I))
-    Assert.IsTrue(TypeGuard.TString(I.allOf[0]))
-    Assert.IsTrue(TypeGuard.TString(I.allOf[1]))
+    Assert.IsFalse(TypeGuard.IsOptional(I))
+    Assert.IsTrue(TypeGuard.IsIntersect(I))
+    Assert.IsTrue(TypeGuard.IsString(I.allOf[0]))
+    Assert.IsTrue(TypeGuard.IsString(I.allOf[1]))
   })
   it('Normalize Intersect 4', () => {
     const T = Type.Intersect([Type.Object({ x: Type.String() })])
     const I = Type.Index(T, ['x'])
-    Assert.IsTrue(TypeGuard.TString(I))
+    Assert.IsTrue(TypeGuard.IsString(I))
   })
   it('Normalize Intersect 5', () => {
     const T = Type.Intersect([Type.Object({ x: Type.String() }), Type.Object({ y: Type.String() })])
     const I = Type.Index(T, ['x', 'y'])
-    Assert.IsFalse(TypeGuard.TOptional(I))
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
+    Assert.IsFalse(TypeGuard.IsOptional(I))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[1]))
   })
   it('Normalize Intersect 6', () => {
     const T = Type.Recursive(() => Type.Intersect([Type.Object({ x: Type.String() }), Type.Object({ y: Type.String() })]))
     const I = Type.Index(T, ['x', 'y'])
-    Assert.IsFalse(TypeGuard.TOptional(I))
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
+    Assert.IsFalse(TypeGuard.IsOptional(I))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[1]))
   })
   // ---------------------------------------------------------
   // Union
@@ -99,42 +99,42 @@ describe('type/normalize/Index', () => {
   it('Normalize Union 1', () => {
     const T = Type.Union([Type.Object({ x: Type.Optional(Type.String()) }), Type.Object({ x: Type.Optional(Type.String()) })])
     const I = Type.Index(T, ['x'])
-    Assert.IsTrue(TypeGuard.TOptional(I))
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsOptional(I))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[1]))
   })
   it('Normalize Union 2', () => {
     const T = Type.Union([Type.Object({ x: Type.Optional(Type.String()) }), Type.Object({ x: Type.String() })])
     const I = Type.Index(T, ['x'])
-    Assert.IsTrue(TypeGuard.TOptional(I))
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsOptional(I))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[1]))
   })
   it('Normalize Union 3', () => {
     const T = Type.Union([Type.Object({ x: Type.String() }), Type.Object({ x: Type.String() })])
     const I = Type.Index(T, ['x'])
-    Assert.IsFalse(TypeGuard.TOptional(I))
-    Assert.IsTrue(TypeGuard.TUnion(I))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[0]))
-    Assert.IsTrue(TypeGuard.TString(I.anyOf[1]))
+    Assert.IsFalse(TypeGuard.IsOptional(I))
+    Assert.IsTrue(TypeGuard.IsUnion(I))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsString(I.anyOf[1]))
   })
   it('Normalize Union 4', () => {
     const T = Type.Union([Type.Object({ x: Type.String() })])
     const I = Type.Index(T, ['x'])
-    Assert.IsTrue(TypeGuard.TString(I))
+    Assert.IsTrue(TypeGuard.IsString(I))
   })
   it('Normalize Union 5', () => {
     const T = Type.Union([Type.Object({ x: Type.String() }), Type.Object({ y: Type.String() })])
     // @ts-ignore
     const I = Type.Index(T, ['x', 'y'])
-    Assert.IsFalse(TypeGuard.TNever(I))
+    Assert.IsFalse(TypeGuard.IsNever(I))
   })
   it('Normalize Union 6', () => {
     const T = Type.Recursive(() => Type.Union([Type.Object({ x: Type.String() }), Type.Object({ y: Type.String() })]))
     // @ts-ignore
     const I = Type.Index(T, ['x', 'y'])
-    Assert.IsFalse(TypeGuard.TNever(I))
+    Assert.IsFalse(TypeGuard.IsNever(I))
   })
 })
diff --git a/test/runtime/type/normalize/intersect.ts b/test/runtime/type/normalize/intersect.ts
index 34837db79..cf73898a8 100644
--- a/test/runtime/type/normalize/intersect.ts
+++ b/test/runtime/type/normalize/intersect.ts
@@ -5,17 +5,17 @@ import { Assert } from '../../assert/index'
 describe('type/normalize/Intersect', () => {
   it('Normalize 1', () => {
     const T = Type.Intersect([Type.Number(), Type.String()])
-    const R = TypeGuard.TIntersect(T)
+    const R = TypeGuard.IsIntersect(T)
     Assert.IsTrue(R)
   })
   it('Normalize 2', () => {
     const T = Type.Intersect([Type.Number()])
-    const R = TypeGuard.TNumber(T)
+    const R = TypeGuard.IsNumber(T)
     Assert.IsTrue(R)
   })
   it('Normalize 3', () => {
     const T = Type.Intersect([])
-    const R = TypeGuard.TNever(T)
+    const R = TypeGuard.IsNever(T)
     Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/normalize/record.ts b/test/runtime/type/normalize/record.ts
index 9f419429d..ef463f5ce 100644
--- a/test/runtime/type/normalize/record.ts
+++ b/test/runtime/type/normalize/record.ts
@@ -6,7 +6,7 @@ describe('type/normalize/Record', () => {
   it('Normalize 1', () => {
     const K = Type.Union([Type.Literal('A'), Type.Literal('B')])
     const T = Type.Record(K, Type.String())
-    const R = TypeGuard.TObject(T)
+    const R = TypeGuard.IsObject(T)
     Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/normalize/union.ts b/test/runtime/type/normalize/union.ts
index 3c5d468a4..2ab700fb0 100644
--- a/test/runtime/type/normalize/union.ts
+++ b/test/runtime/type/normalize/union.ts
@@ -5,17 +5,17 @@ import { Assert } from '../../assert/index'
 describe('type/normalize/Union', () => {
   it('Normalize 1', () => {
     const T = Type.Union([Type.Number(), Type.String()])
-    const R = TypeGuard.TUnion(T)
+    const R = TypeGuard.IsUnion(T)
     Assert.IsTrue(R)
   })
   it('Normalize 2', () => {
     const T = Type.Union([Type.Number()])
-    const R = TypeGuard.TNumber(T)
+    const R = TypeGuard.IsNumber(T)
     Assert.IsTrue(R)
   })
   it('Normalize 3', () => {
     const T = Type.Union([])
-    const R = TypeGuard.TNever(T)
+    const R = TypeGuard.IsNever(T)
     Assert.IsTrue(R)
   })
 })
diff --git a/test/runtime/type/template-literal/finite.ts b/test/runtime/type/template-literal/finite.ts
new file mode 100644
index 000000000..a6a97efa3
--- /dev/null
+++ b/test/runtime/type/template-literal/finite.ts
@@ -0,0 +1,71 @@
+import { TemplateLiteralParse, IsTemplateLiteralExpressionFinite, PatternString, PatternBoolean, PatternNumber } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/template-literal/IsTemplateLiteralExpressionFinite', () => {
+  // ---------------------------------------------------------------
+  // Finite
+  // ---------------------------------------------------------------
+  it('Finite 1', () => {
+    const E = TemplateLiteralParse(`A`)
+    const R = IsTemplateLiteralExpressionFinite(E)
+    Assert.IsTrue(R)
+  })
+  it('Finite 2', () => {
+    const E = TemplateLiteralParse(`A|B`)
+    const R = IsTemplateLiteralExpressionFinite(E)
+    Assert.IsTrue(R)
+  })
+  it('Finite 3', () => {
+    const E = TemplateLiteralParse(`A(B|C)`)
+    const R = IsTemplateLiteralExpressionFinite(E)
+    Assert.IsTrue(R)
+  })
+  it('Finite 4', () => {
+    const E = TemplateLiteralParse(`${PatternBoolean}`)
+    const R = IsTemplateLiteralExpressionFinite(E)
+    Assert.IsTrue(R)
+  })
+  it('Finite 5', () => {
+    const E = TemplateLiteralParse(`\\.\\*`)
+    const R = IsTemplateLiteralExpressionFinite(E)
+    Assert.IsTrue(R)
+  })
+  // ---------------------------------------------------------------
+  // Infinite
+  // ---------------------------------------------------------------
+  it('Infinite 1', () => {
+    const E = TemplateLiteralParse(`${PatternString}`)
+    const R = IsTemplateLiteralExpressionFinite(E)
+    Assert.IsFalse(R)
+  })
+  it('Infinite 2', () => {
+    const E = TemplateLiteralParse(`${PatternNumber}`)
+    const R = IsTemplateLiteralExpressionFinite(E)
+    Assert.IsFalse(R)
+  })
+  it('Infinite 3', () => {
+    const E = TemplateLiteralParse(`A|${PatternString}`)
+    const R = IsTemplateLiteralExpressionFinite(E)
+    Assert.IsFalse(R)
+  })
+  it('Infinite 4', () => {
+    const E = TemplateLiteralParse(`A|${PatternNumber}`)
+    const R = IsTemplateLiteralExpressionFinite(E)
+    Assert.IsFalse(R)
+  })
+  it('Infinite 5', () => {
+    const E = TemplateLiteralParse(`A(${PatternString})`)
+    const R = IsTemplateLiteralExpressionFinite(E)
+    Assert.IsFalse(R)
+  })
+  it('Infinite 6', () => {
+    const E = TemplateLiteralParse(`A(${PatternNumber})`)
+    const R = IsTemplateLiteralExpressionFinite(E)
+    Assert.IsFalse(R)
+  })
+  it('Infinite 7', () => {
+    const E = TemplateLiteralParse(`${PatternString}_foo`)
+    const R = IsTemplateLiteralExpressionFinite(E)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/template-literal/generate.ts b/test/runtime/type/template-literal/generate.ts
new file mode 100644
index 000000000..2178571bc
--- /dev/null
+++ b/test/runtime/type/template-literal/generate.ts
@@ -0,0 +1,199 @@
+import { TemplateLiteralParse, TemplateLiteralExpressionGenerate } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/template-literal/TemplateLiteralExpressionGenerate', () => {
+  // ---------------------------------------------------------------
+  // Exact (No Default Unwrap)
+  // ---------------------------------------------------------------
+  it('Exact 1', () => {
+    const E = TemplateLiteralParse('^$')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['^$'])
+  })
+  it('Exact 2', () => {
+    const E = TemplateLiteralParse('^A$')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['^A$'])
+  })
+  // ---------------------------------------------------------------
+  // Patterns
+  // ---------------------------------------------------------------
+  it('Pattern 1', () => {
+    const E = TemplateLiteralParse('(true|false)')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['true', 'false'])
+  })
+  it('Pattern 2', () => {
+    const E = TemplateLiteralParse('(0|[1-9][0-9]*)')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['0', '[1-9][0-9]*'])
+  })
+  it('Pattern 3', () => {
+    const E = TemplateLiteralParse('.*')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['.*'])
+  })
+  // ---------------------------------------------------------------
+  // Expression
+  // ---------------------------------------------------------------
+  it('Expression 1', () => {
+    const E = TemplateLiteralParse(')')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, [')'])
+  })
+  it('Expression 2', () => {
+    const E = TemplateLiteralParse('\\)')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['\\)'])
+  })
+  it('Expression 3', () => {
+    const E = TemplateLiteralParse('\\(')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['\\('])
+  })
+  it('Expression 4', () => {
+    const E = TemplateLiteralParse('')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, [''])
+  })
+  it('Expression 5', () => {
+    const E = TemplateLiteralParse('\\')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['\\'])
+  })
+  it('Expression 6', () => {
+    const E = TemplateLiteralParse('()')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, [''])
+  })
+  it('Expression 7', () => {
+    const E = TemplateLiteralParse('(a)')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['a'])
+  })
+  it('Expression 8', () => {
+    const E = TemplateLiteralParse('()))')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['))'])
+  })
+  it('Expression 9', () => {
+    const E = TemplateLiteralParse('())')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, [')'])
+  })
+  it('Expression 10', () => {
+    const E = TemplateLiteralParse('A|B')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['A', 'B'])
+  })
+  it('Expression 11', () => {
+    const E = TemplateLiteralParse('A|(B)')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['A', 'B'])
+  })
+  it('Expression 12', () => {
+    const E = TemplateLiteralParse('A(B)')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['AB'])
+  })
+  it('Expression 13', () => {
+    const E = TemplateLiteralParse('(A)B')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['AB'])
+  })
+  it('Expression 14', () => {
+    const E = TemplateLiteralParse('(A)|B')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['A', 'B'])
+  })
+  it('Expression 15', () => {
+    const E = TemplateLiteralParse('|')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, [''])
+  })
+  it('Expression 16', () => {
+    const E = TemplateLiteralParse('||')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, [''])
+  })
+  it('Expression 17', () => {
+    const E = TemplateLiteralParse('||A')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['A'])
+  })
+  it('Expression 18', () => {
+    const E = TemplateLiteralParse('A||')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['A'])
+  })
+  it('Expression 19', () => {
+    const E = TemplateLiteralParse('A||B')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['A', 'B'])
+  })
+  it('Expression 20', () => {
+    const E = TemplateLiteralParse('A|()|B')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['A', '', 'B'])
+  })
+  it('Expression 21', () => {
+    const E = TemplateLiteralParse('A|(|)|B')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['A', '', 'B'])
+  })
+  it('Expression 22', () => {
+    const E = TemplateLiteralParse('A|(||)|B')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['A', '', 'B'])
+  })
+  it('Expression 23', () => {
+    const E = TemplateLiteralParse('|A(||)B|')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['AB'])
+  })
+  it('Expression 24', () => {
+    const E = TemplateLiteralParse('A(B)(C)')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['ABC'])
+  })
+  it('Expression 25', () => {
+    const E = TemplateLiteralParse('A(B)|(C)')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['AB', 'C'])
+  })
+  it('Expression 26', () => {
+    const E = TemplateLiteralParse('A(B|C)')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['AB', 'AC'])
+  })
+  it('Expression 27', () => {
+    const E = TemplateLiteralParse('A|(B|C)')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['A', 'B', 'C'])
+  })
+  it('Expression 28', () => {
+    const E = TemplateLiteralParse('((A)B)C')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['ABC'])
+  })
+  it('Expression 29', () => {
+    const E = TemplateLiteralParse('(0|1)(0|1)')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['00', '01', '10', '11'])
+  })
+  it('Expression 30', () => {
+    const E = TemplateLiteralParse('(0|1)|(0|1)')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['0', '1', '0', '1'])
+  })
+  it('Expression 31', () => {
+    const E = TemplateLiteralParse('(0|(1|0)|1)')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['0', '1', '0', '1'])
+  })
+  it('Expression 32', () => {
+    const E = TemplateLiteralParse('(0(1|0)1)')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['011', '001'])
+  })
+})
diff --git a/test/runtime/type/template/index.ts b/test/runtime/type/template-literal/index.ts
similarity index 76%
rename from test/runtime/type/template/index.ts
rename to test/runtime/type/template-literal/index.ts
index 032be5db6..483e67965 100644
--- a/test/runtime/type/template/index.ts
+++ b/test/runtime/type/template-literal/index.ts
@@ -1,4 +1,4 @@
 import './finite'
 import './generate'
-import './parser'
+import './parse'
 import './pattern'
diff --git a/test/runtime/type/template/parser.ts b/test/runtime/type/template-literal/parse.ts
similarity index 82%
rename from test/runtime/type/template/parser.ts
rename to test/runtime/type/template-literal/parse.ts
index 5ab50afbf..57db98fc6 100644
--- a/test/runtime/type/template/parser.ts
+++ b/test/runtime/type/template-literal/parse.ts
@@ -1,28 +1,28 @@
-import { TemplateLiteralParser } from '@sinclair/typebox'
+import { TemplateLiteralParse } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/templateliteral/TemplateLiteralParser', () => {
+describe('type/template-literal/TemplateLiteralParser', () => {
   // ---------------------------------------------------------------
   // Throws
   // ---------------------------------------------------------------
   it('Throw 1', () => {
-    Assert.Throws(() => TemplateLiteralParser.Parse('('))
+    Assert.Throws(() => TemplateLiteralParse('('))
   })
   it('Throw 2', () => {
-    Assert.Throws(() => TemplateLiteralParser.Parse('('))
+    Assert.Throws(() => TemplateLiteralParse('('))
   })
   // ---------------------------------------------------------------
   // Exact (No Default Unwrap)
   // ---------------------------------------------------------------
   it('Exact 1', () => {
-    const E = TemplateLiteralParser.Parse('^$')
+    const E = TemplateLiteralParse('^$')
     Assert.IsEqual(E, {
       type: 'const',
       const: '^$',
     })
   })
   it('Exact 2', () => {
-    const E = TemplateLiteralParser.Parse('^A$')
+    const E = TemplateLiteralParse('^A$')
     Assert.IsEqual(E, {
       type: 'const',
       const: '^A$',
@@ -32,7 +32,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
   // Patterns
   // ---------------------------------------------------------------
   it('Pattern 1', () => {
-    const E = TemplateLiteralParser.Parse('(true|false)')
+    const E = TemplateLiteralParse('(true|false)')
     Assert.IsEqual(E, {
       type: 'or',
       expr: [
@@ -48,7 +48,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Pattern 2', () => {
-    const E = TemplateLiteralParser.Parse('(0|[1-9][0-9]*)')
+    const E = TemplateLiteralParse('(0|[1-9][0-9]*)')
     Assert.IsEqual(E, {
       type: 'or',
       expr: [
@@ -64,7 +64,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Pattern 3', () => {
-    const E = TemplateLiteralParser.Parse('.*')
+    const E = TemplateLiteralParse('.*')
     Assert.IsEqual(E, {
       type: 'const',
       const: '.*',
@@ -74,56 +74,56 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
   // Expression
   // ---------------------------------------------------------------
   it('Expression 1', () => {
-    const E = TemplateLiteralParser.Parse(')')
+    const E = TemplateLiteralParse(')')
     Assert.IsEqual(E, {
       type: 'const',
       const: ')',
     })
   })
   it('Expression 2', () => {
-    const E = TemplateLiteralParser.Parse('\\)')
+    const E = TemplateLiteralParse('\\)')
     Assert.IsEqual(E, {
       type: 'const',
       const: '\\)',
     })
   })
   it('Expression 3', () => {
-    const E = TemplateLiteralParser.Parse('\\(')
+    const E = TemplateLiteralParse('\\(')
     Assert.IsEqual(E, {
       type: 'const',
       const: '\\(',
     })
   })
   it('Expression 4', () => {
-    const E = TemplateLiteralParser.Parse('')
+    const E = TemplateLiteralParse('')
     Assert.IsEqual(E, {
       type: 'const',
       const: '',
     })
   })
   it('Expression 5', () => {
-    const E = TemplateLiteralParser.Parse('\\')
+    const E = TemplateLiteralParse('\\')
     Assert.IsEqual(E, {
       type: 'const',
       const: '\\',
     })
   })
   it('Expression 6', () => {
-    const E = TemplateLiteralParser.Parse('()')
+    const E = TemplateLiteralParse('()')
     Assert.IsEqual(E, {
       type: 'const',
       const: '',
     })
   })
   it('Expression 7', () => {
-    const E = TemplateLiteralParser.Parse('(a)')
+    const E = TemplateLiteralParse('(a)')
     Assert.IsEqual(E, {
       type: 'const',
       const: 'a',
     })
   })
   it('Expression 8', () => {
-    const E = TemplateLiteralParser.Parse('()))')
+    const E = TemplateLiteralParse('()))')
     Assert.IsEqual(E, {
       type: 'and',
       expr: [
@@ -139,7 +139,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 9', () => {
-    const E = TemplateLiteralParser.Parse('())')
+    const E = TemplateLiteralParse('())')
     Assert.IsEqual(E, {
       type: 'and',
       expr: [
@@ -155,7 +155,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 10', () => {
-    const E = TemplateLiteralParser.Parse('A|B')
+    const E = TemplateLiteralParse('A|B')
     Assert.IsEqual(E, {
       type: 'or',
       expr: [
@@ -171,7 +171,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 11', () => {
-    const E = TemplateLiteralParser.Parse('A|(B)')
+    const E = TemplateLiteralParse('A|(B)')
     Assert.IsEqual(E, {
       type: 'or',
       expr: [
@@ -187,7 +187,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 12', () => {
-    const E = TemplateLiteralParser.Parse('A(B)')
+    const E = TemplateLiteralParse('A(B)')
     Assert.IsEqual(E, {
       type: 'and',
       expr: [
@@ -203,7 +203,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 13', () => {
-    const E = TemplateLiteralParser.Parse('(A)B')
+    const E = TemplateLiteralParse('(A)B')
     Assert.IsEqual(E, {
       type: 'and',
       expr: [
@@ -219,7 +219,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 14', () => {
-    const E = TemplateLiteralParser.Parse('(A)|B')
+    const E = TemplateLiteralParse('(A)|B')
     Assert.IsEqual(E, {
       type: 'or',
       expr: [
@@ -235,35 +235,35 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 15', () => {
-    const E = TemplateLiteralParser.Parse('|')
+    const E = TemplateLiteralParse('|')
     Assert.IsEqual(E, {
       type: 'const',
       const: '',
     })
   })
   it('Expression 16', () => {
-    const E = TemplateLiteralParser.Parse('||')
+    const E = TemplateLiteralParse('||')
     Assert.IsEqual(E, {
       type: 'const',
       const: '',
     })
   })
   it('Expression 17', () => {
-    const E = TemplateLiteralParser.Parse('||A')
+    const E = TemplateLiteralParse('||A')
     Assert.IsEqual(E, {
       type: 'const',
       const: 'A',
     })
   })
   it('Expression 18', () => {
-    const E = TemplateLiteralParser.Parse('A||')
+    const E = TemplateLiteralParse('A||')
     Assert.IsEqual(E, {
       type: 'const',
       const: 'A',
     })
   })
   it('Expression 19', () => {
-    const E = TemplateLiteralParser.Parse('A||B')
+    const E = TemplateLiteralParse('A||B')
     Assert.IsEqual(E, {
       type: 'or',
       expr: [
@@ -279,7 +279,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 20', () => {
-    const E = TemplateLiteralParser.Parse('A|()|B')
+    const E = TemplateLiteralParse('A|()|B')
     Assert.IsEqual(E, {
       type: 'or',
       expr: [
@@ -299,7 +299,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 21', () => {
-    const E = TemplateLiteralParser.Parse('A|(|)|B')
+    const E = TemplateLiteralParse('A|(|)|B')
     Assert.IsEqual(E, {
       type: 'or',
       expr: [
@@ -319,7 +319,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 22', () => {
-    const E = TemplateLiteralParser.Parse('A|(||)|B')
+    const E = TemplateLiteralParse('A|(||)|B')
     Assert.IsEqual(E, {
       type: 'or',
       expr: [
@@ -339,7 +339,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 23', () => {
-    const E = TemplateLiteralParser.Parse('|A(||)B|')
+    const E = TemplateLiteralParse('|A(||)B|')
     Assert.IsEqual(E, {
       type: 'and',
       expr: [
@@ -359,7 +359,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 24', () => {
-    const E = TemplateLiteralParser.Parse('A(B)(C)')
+    const E = TemplateLiteralParse('A(B)(C)')
     Assert.IsEqual(E, {
       type: 'and',
       expr: [
@@ -379,7 +379,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 25', () => {
-    const E = TemplateLiteralParser.Parse('A(B)|(C)')
+    const E = TemplateLiteralParse('A(B)|(C)')
     Assert.IsEqual(E, {
       type: 'or',
       expr: [
@@ -404,7 +404,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 26', () => {
-    const E = TemplateLiteralParser.Parse('A(B|C)')
+    const E = TemplateLiteralParse('A(B|C)')
     Assert.IsEqual(E, {
       type: 'and',
       expr: [
@@ -429,7 +429,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 27', () => {
-    const E = TemplateLiteralParser.Parse('A|(B|C)')
+    const E = TemplateLiteralParse('A|(B|C)')
     Assert.IsEqual(E, {
       type: 'or',
       expr: [
@@ -454,7 +454,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 28', () => {
-    const E = TemplateLiteralParser.Parse('((A)B)C')
+    const E = TemplateLiteralParse('((A)B)C')
     Assert.IsEqual(E, {
       type: 'and',
       expr: [
@@ -479,7 +479,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 29', () => {
-    const E = TemplateLiteralParser.Parse('(0|1)(0|1)')
+    const E = TemplateLiteralParse('(0|1)(0|1)')
     Assert.IsEqual(E, {
       type: 'and',
       expr: [
@@ -513,7 +513,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 30', () => {
-    const E = TemplateLiteralParser.Parse('(0|1)|(0|1)')
+    const E = TemplateLiteralParse('(0|1)|(0|1)')
     Assert.IsEqual(E, {
       type: 'or',
       expr: [
@@ -547,7 +547,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 31', () => {
-    const E = TemplateLiteralParser.Parse('(0|(1|0)|1)')
+    const E = TemplateLiteralParse('(0|(1|0)|1)')
     Assert.IsEqual(E, {
       type: 'or',
       expr: [
@@ -576,7 +576,7 @@ describe('type/templateliteral/TemplateLiteralParser', () => {
     })
   })
   it('Expression 32', () => {
-    const E = TemplateLiteralParser.Parse('(0(1|0)1)')
+    const E = TemplateLiteralParse('(0(1|0)1)')
     Assert.IsEqual(E, {
       type: 'and',
       expr: [
diff --git a/test/runtime/type/template/pattern.ts b/test/runtime/type/template-literal/pattern.ts
similarity index 98%
rename from test/runtime/type/template/pattern.ts
rename to test/runtime/type/template-literal/pattern.ts
index 6fdf85ca7..1a8b13fa8 100644
--- a/test/runtime/type/template/pattern.ts
+++ b/test/runtime/type/template-literal/pattern.ts
@@ -1,7 +1,7 @@
 import { Type, TTemplateLiteral, PatternNumber, PatternString, PatternBoolean } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
-describe('type/templateliteral/TemplateLiteralPattern', () => {
+describe('type/template-literal/TemplateLiteralPattern', () => {
   const Equal = (template: TTemplateLiteral, expect: string) => {
     const pattern = template.pattern.slice(1, template.pattern.length - 1)
     Assert.IsEqual(pattern, expect)
diff --git a/test/runtime/type/template/finite.ts b/test/runtime/type/template/finite.ts
deleted file mode 100644
index 53028dff9..000000000
--- a/test/runtime/type/template/finite.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-import { PatternString, PatternBoolean, PatternNumber, TemplateLiteralParser, TemplateLiteralFinite } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
-
-describe('type/templateliteral/TemplateLiteralFinite', () => {
-  // ---------------------------------------------------------------
-  // Finite
-  // ---------------------------------------------------------------
-  it('Finite 1', () => {
-    const E = TemplateLiteralParser.Parse(`A`)
-    const R = TemplateLiteralFinite.Check(E)
-    Assert.IsTrue(R)
-  })
-  it('Finite 2', () => {
-    const E = TemplateLiteralParser.Parse(`A|B`)
-    const R = TemplateLiteralFinite.Check(E)
-    Assert.IsTrue(R)
-  })
-  it('Finite 3', () => {
-    const E = TemplateLiteralParser.Parse(`A(B|C)`)
-    const R = TemplateLiteralFinite.Check(E)
-    Assert.IsTrue(R)
-  })
-  it('Finite 4', () => {
-    const E = TemplateLiteralParser.Parse(`${PatternBoolean}`)
-    const R = TemplateLiteralFinite.Check(E)
-    Assert.IsTrue(R)
-  })
-  it('Finite 5', () => {
-    const E = TemplateLiteralParser.Parse(`\\.\\*`)
-    const R = TemplateLiteralFinite.Check(E)
-    Assert.IsTrue(R)
-  })
-  // ---------------------------------------------------------------
-  // Infinite
-  // ---------------------------------------------------------------
-  it('Infinite 1', () => {
-    const E = TemplateLiteralParser.Parse(`${PatternString}`)
-    const R = TemplateLiteralFinite.Check(E)
-    Assert.IsFalse(R)
-  })
-  it('Infinite 2', () => {
-    const E = TemplateLiteralParser.Parse(`${PatternNumber}`)
-    const R = TemplateLiteralFinite.Check(E)
-    Assert.IsFalse(R)
-  })
-  it('Infinite 3', () => {
-    const E = TemplateLiteralParser.Parse(`A|${PatternString}`)
-    const R = TemplateLiteralFinite.Check(E)
-    Assert.IsFalse(R)
-  })
-  it('Infinite 4', () => {
-    const E = TemplateLiteralParser.Parse(`A|${PatternNumber}`)
-    const R = TemplateLiteralFinite.Check(E)
-    Assert.IsFalse(R)
-  })
-  it('Infinite 5', () => {
-    const E = TemplateLiteralParser.Parse(`A(${PatternString})`)
-    const R = TemplateLiteralFinite.Check(E)
-    Assert.IsFalse(R)
-  })
-  it('Infinite 6', () => {
-    const E = TemplateLiteralParser.Parse(`A(${PatternNumber})`)
-    const R = TemplateLiteralFinite.Check(E)
-    Assert.IsFalse(R)
-  })
-  it('Infinite 7', () => {
-    const E = TemplateLiteralParser.Parse(`${PatternString}_foo`)
-    const R = TemplateLiteralFinite.Check(E)
-    Assert.IsFalse(R)
-  })
-})
diff --git a/test/runtime/type/template/generate.ts b/test/runtime/type/template/generate.ts
deleted file mode 100644
index 73aa9cfc3..000000000
--- a/test/runtime/type/template/generate.ts
+++ /dev/null
@@ -1,199 +0,0 @@
-import { TemplateLiteralParser, TemplateLiteralGenerator } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
-
-describe('type/templateliteral/TemplateLiteralGenerator', () => {
-  // ---------------------------------------------------------------
-  // Exact (No Default Unwrap)
-  // ---------------------------------------------------------------
-  it('Exact 1', () => {
-    const E = TemplateLiteralParser.Parse('^$')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['^$'])
-  })
-  it('Exact 2', () => {
-    const E = TemplateLiteralParser.Parse('^A$')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['^A$'])
-  })
-  // ---------------------------------------------------------------
-  // Patterns
-  // ---------------------------------------------------------------
-  it('Pattern 1', () => {
-    const E = TemplateLiteralParser.Parse('(true|false)')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['true', 'false'])
-  })
-  it('Pattern 2', () => {
-    const E = TemplateLiteralParser.Parse('(0|[1-9][0-9]*)')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['0', '[1-9][0-9]*'])
-  })
-  it('Pattern 3', () => {
-    const E = TemplateLiteralParser.Parse('.*')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['.*'])
-  })
-  // ---------------------------------------------------------------
-  // Expression
-  // ---------------------------------------------------------------
-  it('Expression 1', () => {
-    const E = TemplateLiteralParser.Parse(')')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, [')'])
-  })
-  it('Expression 2', () => {
-    const E = TemplateLiteralParser.Parse('\\)')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['\\)'])
-  })
-  it('Expression 3', () => {
-    const E = TemplateLiteralParser.Parse('\\(')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['\\('])
-  })
-  it('Expression 4', () => {
-    const E = TemplateLiteralParser.Parse('')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, [''])
-  })
-  it('Expression 5', () => {
-    const E = TemplateLiteralParser.Parse('\\')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['\\'])
-  })
-  it('Expression 6', () => {
-    const E = TemplateLiteralParser.Parse('()')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, [''])
-  })
-  it('Expression 7', () => {
-    const E = TemplateLiteralParser.Parse('(a)')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['a'])
-  })
-  it('Expression 8', () => {
-    const E = TemplateLiteralParser.Parse('()))')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['))'])
-  })
-  it('Expression 9', () => {
-    const E = TemplateLiteralParser.Parse('())')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, [')'])
-  })
-  it('Expression 10', () => {
-    const E = TemplateLiteralParser.Parse('A|B')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['A', 'B'])
-  })
-  it('Expression 11', () => {
-    const E = TemplateLiteralParser.Parse('A|(B)')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['A', 'B'])
-  })
-  it('Expression 12', () => {
-    const E = TemplateLiteralParser.Parse('A(B)')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['AB'])
-  })
-  it('Expression 13', () => {
-    const E = TemplateLiteralParser.Parse('(A)B')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['AB'])
-  })
-  it('Expression 14', () => {
-    const E = TemplateLiteralParser.Parse('(A)|B')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['A', 'B'])
-  })
-  it('Expression 15', () => {
-    const E = TemplateLiteralParser.Parse('|')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, [''])
-  })
-  it('Expression 16', () => {
-    const E = TemplateLiteralParser.Parse('||')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, [''])
-  })
-  it('Expression 17', () => {
-    const E = TemplateLiteralParser.Parse('||A')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['A'])
-  })
-  it('Expression 18', () => {
-    const E = TemplateLiteralParser.Parse('A||')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['A'])
-  })
-  it('Expression 19', () => {
-    const E = TemplateLiteralParser.Parse('A||B')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['A', 'B'])
-  })
-  it('Expression 20', () => {
-    const E = TemplateLiteralParser.Parse('A|()|B')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['A', '', 'B'])
-  })
-  it('Expression 21', () => {
-    const E = TemplateLiteralParser.Parse('A|(|)|B')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['A', '', 'B'])
-  })
-  it('Expression 22', () => {
-    const E = TemplateLiteralParser.Parse('A|(||)|B')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['A', '', 'B'])
-  })
-  it('Expression 23', () => {
-    const E = TemplateLiteralParser.Parse('|A(||)B|')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['AB'])
-  })
-  it('Expression 24', () => {
-    const E = TemplateLiteralParser.Parse('A(B)(C)')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['ABC'])
-  })
-  it('Expression 25', () => {
-    const E = TemplateLiteralParser.Parse('A(B)|(C)')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['AB', 'C'])
-  })
-  it('Expression 26', () => {
-    const E = TemplateLiteralParser.Parse('A(B|C)')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['AB', 'AC'])
-  })
-  it('Expression 27', () => {
-    const E = TemplateLiteralParser.Parse('A|(B|C)')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['A', 'B', 'C'])
-  })
-  it('Expression 28', () => {
-    const E = TemplateLiteralParser.Parse('((A)B)C')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['ABC'])
-  })
-  it('Expression 29', () => {
-    const E = TemplateLiteralParser.Parse('(0|1)(0|1)')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['00', '01', '10', '11'])
-  })
-  it('Expression 30', () => {
-    const E = TemplateLiteralParser.Parse('(0|1)|(0|1)')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['0', '1', '0', '1'])
-  })
-  it('Expression 31', () => {
-    const E = TemplateLiteralParser.Parse('(0|(1|0)|1)')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['0', '1', '0', '1'])
-  })
-  it('Expression 32', () => {
-    const E = TemplateLiteralParser.Parse('(0(1|0)1)')
-    const R = [...TemplateLiteralGenerator.Generate(E)]
-    Assert.IsEqual(R, ['011', '001'])
-  })
-})
diff --git a/test/runtime/type/value/guard.ts b/test/runtime/type/value/guard.ts
index 51652350b..d68d18952 100644
--- a/test/runtime/type/value/guard.ts
+++ b/test/runtime/type/value/guard.ts
@@ -2,6 +2,17 @@ import { Assert } from '../../assert/index'
 import { ValueGuard } from '@sinclair/typebox'
 
 describe('type/ValueGuard', () => {
+  // -----------------------------------------------------
+  // IsSymbol
+  // -----------------------------------------------------
+  it('Should guard symbol 1', () => {
+    const R = ValueGuard.IsSymbol(Symbol())
+    Assert.IsTrue(R)
+  })
+  it('Should guard symbol 2', () => {
+    const R = ValueGuard.IsSymbol({})
+    Assert.IsFalse(R)
+  })
   // -----------------------------------------------------
   // IsNull
   // -----------------------------------------------------
@@ -106,4 +117,71 @@ describe('type/ValueGuard', () => {
     const R = ValueGuard.IsArray({})
     Assert.IsFalse(R)
   })
+  // -----------------------------------------------------
+  // IsFunction
+  // -----------------------------------------------------
+  it('Should guard function 1', () => {
+    const R = ValueGuard.IsFunction(function () {})
+    Assert.IsTrue(R)
+  })
+  it('Should guard function 2', () => {
+    const R = ValueGuard.IsFunction({})
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsAsyncIterator
+  // -----------------------------------------------------
+  it('Should guard async iterator 1', () => {
+    const R = ValueGuard.IsAsyncIterator((async function* (): any {})())
+    Assert.IsTrue(R)
+  })
+  it('Should guard async iterator 2', () => {
+    const R = ValueGuard.IsAsyncIterator((function* (): any {})())
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsAsyncIterator
+  // -----------------------------------------------------
+  it('Should guard iterator 1', () => {
+    const R = ValueGuard.IsIterator((function* (): any {})())
+    Assert.IsTrue(R)
+  })
+  it('Should guard iterator 2', () => {
+    const R = ValueGuard.IsIterator((async function* (): any {})())
+    Assert.IsFalse(R)
+  })
+  it('Should guard iterator 3', () => {
+    const R = ValueGuard.IsIterator([])
+    Assert.IsFalse(R)
+  })
+  it('Should guard iterator 4', () => {
+    const R = ValueGuard.IsIterator(new Uint8Array())
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // Date
+  // -----------------------------------------------------
+  it('Should guard date 1', () => {
+    const R = ValueGuard.IsDate(new Date())
+    Assert.IsTrue(R)
+  })
+  it('Should guard date 2', () => {
+    const R = ValueGuard.IsDate({})
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // Date
+  // -----------------------------------------------------
+  it('Should guard uint8array 1', () => {
+    const R = ValueGuard.IsUint8Array(new Uint8Array())
+    Assert.IsTrue(R)
+  })
+  it('Should guard uint8array 2', () => {
+    const R = ValueGuard.IsUint8Array({})
+    Assert.IsFalse(R)
+  })
+  it('Should guard uint8array 2', () => {
+    const R = ValueGuard.IsUint8Array([])
+    Assert.IsFalse(R)
+  })
 })
diff --git a/test/runtime/value/cast/regexp.ts b/test/runtime/value/cast/regexp.ts
index 6b4e05950..6c036fa9a 100644
--- a/test/runtime/value/cast/regexp.ts
+++ b/test/runtime/value/cast/regexp.ts
@@ -50,4 +50,11 @@ describe('value/cast/RegExp', () => {
     const result = Value.Cast(T, value)
     Assert.IsEqual(result, value)
   })
+  // ----------------------------------------------------------------
+  // Throw
+  // ----------------------------------------------------------------
+  it('Should throw with no default', () => {
+    const T = Type.RegExp(/foo/)
+    Assert.Throws(() => Value.Cast(T, null))
+  })
 })
diff --git a/test/runtime/value/check/const.ts b/test/runtime/value/check/const.ts
new file mode 100644
index 000000000..4b3db9f44
--- /dev/null
+++ b/test/runtime/value/check/const.ts
@@ -0,0 +1,42 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Const', () => {
+  it('Should validate 1', () => {
+    const T = Type.Const(1)
+    Assert.IsTrue(Value.Check(T, 1))
+  })
+  it('Should validate 2', () => {
+    const T = Type.Const('hello')
+    Assert.IsTrue(Value.Check(T, 'hello'))
+  })
+  it('Should validate 3', () => {
+    const T = Type.Const(true)
+    Assert.IsTrue(Value.Check(T, true))
+  })
+  it('Should validate 4', () => {
+    const T = Type.Const({ x: 1, y: 2 })
+    Assert.IsTrue(Value.Check(T, { x: 1, y: 2 }))
+  })
+  it('Should validate 5', () => {
+    const T = Type.Const([1, 2, 3])
+    Assert.IsTrue(Value.Check(T, [1, 2, 3]))
+  })
+  it('Should validate 6', () => {
+    const T = Type.Const([1, true, 'hello'])
+    Assert.IsTrue(Value.Check(T, [1, true, 'hello']))
+  })
+  it('Should validate 7', () => {
+    const T = Type.Const({
+      x: [1, 2, 3, 4],
+      y: { x: 1, y: 2, z: 3 },
+    })
+    Assert.IsTrue(
+      Value.Check(T, {
+        x: [1, 2, 3, 4],
+        y: { x: 1, y: 2, z: 3 },
+      }),
+    )
+  })
+})
diff --git a/test/runtime/value/check/index.ts b/test/runtime/value/check/index.ts
index 7b51cf3bf..9012725f2 100644
--- a/test/runtime/value/check/index.ts
+++ b/test/runtime/value/check/index.ts
@@ -4,6 +4,7 @@ import './async-iterator'
 import './bigint'
 import './boolean'
 import './composite'
+import './const'
 import './constructor'
 import './date'
 import './enum'
diff --git a/test/runtime/value/clean/any.ts b/test/runtime/value/clean/any.ts
new file mode 100644
index 000000000..9a49a2562
--- /dev/null
+++ b/test/runtime/value/clean/any.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Any', () => {
+  it('Should clean 1', () => {
+    const T = Type.Any()
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/array.ts b/test/runtime/value/clean/array.ts
new file mode 100644
index 000000000..6e8a21844
--- /dev/null
+++ b/test/runtime/value/clean/array.ts
@@ -0,0 +1,21 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Array', () => {
+  it('Should clean 1', () => {
+    const T = Type.Any()
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean 2', () => {
+    const T = Type.Array(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+    )
+    const R = Value.Clean(T, [undefined, null, { x: 1 }, { x: 1, y: 2 }, { x: 1, y: 2, z: 3 }])
+    Assert.IsEqual(R, [undefined, null, { x: 1 }, { x: 1, y: 2 }, { x: 1, y: 2 }])
+  })
+})
diff --git a/test/runtime/value/clean/async-iterator.ts b/test/runtime/value/clean/async-iterator.ts
new file mode 100644
index 000000000..a067233b3
--- /dev/null
+++ b/test/runtime/value/clean/async-iterator.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/AsyncIterator', () => {
+  it('Should clean 1', () => {
+    const T = Type.AsyncIterator(Type.Number())
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/bigint.ts b/test/runtime/value/clean/bigint.ts
new file mode 100644
index 000000000..cdd77d4de
--- /dev/null
+++ b/test/runtime/value/clean/bigint.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/BigInt', () => {
+  it('Should clean 1', () => {
+    const T = Type.BigInt()
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/boolean.ts b/test/runtime/value/clean/boolean.ts
new file mode 100644
index 000000000..7697d25c3
--- /dev/null
+++ b/test/runtime/value/clean/boolean.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Boolean', () => {
+  it('Should clean 1', () => {
+    const T = Type.Boolean()
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/composite.ts b/test/runtime/value/clean/composite.ts
new file mode 100644
index 000000000..035f335a9
--- /dev/null
+++ b/test/runtime/value/clean/composite.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Composite', () => {
+  it('Should clean 1', () => {
+    const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/constructor.ts b/test/runtime/value/clean/constructor.ts
new file mode 100644
index 000000000..4a4be492c
--- /dev/null
+++ b/test/runtime/value/clean/constructor.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Constructor', () => {
+  it('Should clean 1', () => {
+    const T = Type.Constructor([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })], Type.Object({ z: Type.Number() }))
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/date.ts b/test/runtime/value/clean/date.ts
new file mode 100644
index 000000000..8f777e4c3
--- /dev/null
+++ b/test/runtime/value/clean/date.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Date', () => {
+  it('Should clean 1', () => {
+    const T = Type.Date()
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/enum.ts b/test/runtime/value/clean/enum.ts
new file mode 100644
index 000000000..88902047b
--- /dev/null
+++ b/test/runtime/value/clean/enum.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Enum', () => {
+  it('Should clean 1', () => {
+    const T = Type.Enum({ x: 1, y: 2 })
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/function.ts b/test/runtime/value/clean/function.ts
new file mode 100644
index 000000000..2bc5a4ee5
--- /dev/null
+++ b/test/runtime/value/clean/function.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Function', () => {
+  it('Should clean 1', () => {
+    const T = Type.Function([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })], Type.Object({ z: Type.Number() }))
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/index.ts b/test/runtime/value/clean/index.ts
new file mode 100644
index 000000000..b290dd224
--- /dev/null
+++ b/test/runtime/value/clean/index.ts
@@ -0,0 +1,34 @@
+import './any'
+import './array'
+import './async-iterator'
+import './bigint'
+import './boolean'
+import './composite'
+import './constructor'
+import './date'
+import './enum'
+import './function'
+import './integer'
+import './intersect'
+import './iterator'
+import './keyof'
+import './kind'
+import './literal'
+import './never'
+import './not'
+import './null'
+import './object'
+import './promise'
+import './record'
+import './recursive'
+import './ref'
+import './regexp'
+import './string'
+import './symbol'
+import './template-literal'
+import './tuple'
+import './uint8array'
+import './undefined'
+import './union'
+import './unknown'
+import './void'
diff --git a/test/runtime/value/clean/integer.ts b/test/runtime/value/clean/integer.ts
new file mode 100644
index 000000000..ff377049c
--- /dev/null
+++ b/test/runtime/value/clean/integer.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Integer', () => {
+  it('Should clean 1', () => {
+    const T = Type.Integer()
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/intersect.ts b/test/runtime/value/clean/intersect.ts
new file mode 100644
index 000000000..14f5d5221
--- /dev/null
+++ b/test/runtime/value/clean/intersect.ts
@@ -0,0 +1,346 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+// prettier-ignore
+describe('value/clean/Intersect', () => {
+  // ----------------------------------------------------------------
+  // Intersect
+  // ----------------------------------------------------------------
+  it('Should clean 1', () => {
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() })
+    ])
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean 2', () => {
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() })
+    ])
+    const R = Value.Clean(T, {})
+    Assert.IsEqual(R, {})
+  })
+  it('Should clean 3', () => {
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() })
+    ])
+    const R = Value.Clean(T, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should clean 4', () => {
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() })
+    ])
+    const R = Value.Clean(T, { x: 1, y: 2, z: 3 })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  // ----------------------------------------------------------------
+  // Intersect Discard
+  // ----------------------------------------------------------------
+  it('Should clean discard 1', () => {
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() })
+    ])
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean discard  2', () => {
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() })
+    ])
+    const R = Value.Clean(T, { u: null })
+    Assert.IsEqual(R, {})
+  })
+  it('Should clean discard 3', () => {
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() })
+    ])
+    const R = Value.Clean(T, { u: null, x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should clean discard 4', () => {
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() })
+    ])
+    const R = Value.Clean(T, { u: null, x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  // ----------------------------------------------------------------
+  // Intersect Deep
+  // ----------------------------------------------------------------
+  it('Should clear intersect deep 1', () => {
+    const T = Type.Intersect([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() }),
+        Type.Object({ w: Type.Number() })
+      ])
+    ])
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clear intersect deep 2', () => {
+    const T = Type.Intersect([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() }),
+        Type.Object({ w: Type.Number() })
+      ])
+    ])
+    const R = Value.Clean(T, {})
+    Assert.IsEqual(R, {})
+  })
+  it('Should clear intersect deep 3', () => {
+    const T = Type.Intersect([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() }),
+        Type.Object({ w: Type.Number() })
+      ])
+    ])
+    const R = Value.Clean(T, { x: 1 })
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should clear intersect deep 4', () => {
+    const T = Type.Intersect([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() }),
+        Type.Object({ w: Type.Number() })
+      ])
+    ])
+    const R = Value.Clean(T, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should clear intersect deep 5', () => {
+    const T = Type.Intersect([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() }),
+        Type.Object({ w: Type.Number() })
+      ])
+    ])
+    const R = Value.Clean(T, { x: 1, y: 2, z: 3 })
+    Assert.IsEqual(R, { x: 1, y: 2, z: 3 })
+  })
+  it('Should clear intersect deep 6', () => {
+    const T = Type.Intersect([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() }),
+        Type.Object({ w: Type.Number() })
+      ])
+    ])
+    const R = Value.Clean(T, { x: 1, y: 2, z: 3, w: 3 })
+    Assert.IsEqual(R, { x: 1, y: 2, z: 3, w: 3 })
+  })
+  it('Should clear intersect deep 7', () => {
+    const T = Type.Intersect([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() }),
+        Type.Object({ w: Type.Number() })
+      ])
+    ])
+    const R = Value.Clean(T, { x: 1, y: 2, z: 3, w: 3 })
+    Assert.IsEqual(R, { x: 1, y: 2, z: 3, w: 3 })
+  })
+  // ----------------------------------------------------------------
+  // Intersect Deep Discard
+  // ----------------------------------------------------------------
+  it('Should clear intersect discard deep 1', () => {
+    const T = Type.Intersect([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() }),
+        Type.Object({ w: Type.Number() })
+      ])
+    ])
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clear intersect discard deep 2', () => {
+    const T = Type.Intersect([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() }),
+        Type.Object({ w: Type.Number() })
+      ])
+    ])
+    const R = Value.Clean(T, { u: null })
+    Assert.IsEqual(R, {})
+  })
+  it('Should clear intersect discard deep 3', () => {
+    const T = Type.Intersect([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() }),
+        Type.Object({ w: Type.Number() })
+      ])
+    ])
+    const R = Value.Clean(T, { u: null, x: 1 })
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should clear intersect discard deep 4', () => {
+    const T = Type.Intersect([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() }),
+        Type.Object({ w: Type.Number() })
+      ])
+    ])
+    const R = Value.Clean(T, { u: null, x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should clear intersect discard deep 5', () => {
+    const T = Type.Intersect([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() }),
+        Type.Object({ w: Type.Number() })
+      ])
+    ])
+    const R = Value.Clean(T, { u: null, x: 1, y: 2, z: 3 })
+    Assert.IsEqual(R, { x: 1, y: 2, z: 3 })
+  })
+  it('Should clear intersect discard deep 6', () => {
+    const T = Type.Intersect([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() }),
+        Type.Object({ w: Type.Number() })
+      ])
+    ])
+    const R = Value.Clean(T, { u: null, x: 1, y: 2, z: 3, w: 3 })
+    Assert.IsEqual(R, { x: 1, y: 2, z: 3, w: 3 })
+  })
+  it('Should clear intersect discard deep 7', () => {
+    const T = Type.Intersect([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() }),
+        Type.Object({ w: Type.Number() })
+      ])
+    ])
+    const R = Value.Clean(T, { u: null, x: 1, y: 2, z: 3, w: 3, a: 1 })
+    Assert.IsEqual(R, { x: 1, y: 2, z: 3, w: 3 })
+  })
+  // ----------------------------------------------------------------
+  // Intersect Invalid
+  // ----------------------------------------------------------------
+  it('Should clean intersect invalid 1', () => {
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.String() })
+    ])
+    const R = Value.Clean(T, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: 2 }) // types are ignored
+  })
+  // ----------------------------------------------------------------
+  // Intersect Unevaluted Properties
+  // ----------------------------------------------------------------
+  it('Should clean intersect unevaluated properties 1', () => {
+    const T = Type.Intersect([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.String() })
+    ], {
+      unevaluatedProperties: Type.String()
+    })
+    const R = Value.Clean(T, { x: 1, y: 2, a: 1, b: '' })
+    Assert.IsEqual(R, { x: 1, y: 2, b: '' })
+  })
+  // ----------------------------------------------------------------
+  // Intersect Illogical
+  // ----------------------------------------------------------------
+  it('Should clean illogical 1', () => {
+    const T = Type.Intersect([
+      Type.Number(),
+      Type.Object({ x: Type.Number() })
+    ])
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean illogical 2', () => {
+    const T = Type.Intersect([
+      Type.Number(),
+      Type.Object({ x: Type.Number() })
+    ])
+    const R = Value.Clean(T, 1)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should clean illogical 3', () => {
+    const T = Type.Intersect([
+      Type.Number(),
+      Type.Object({ x: Type.Number() })
+    ])
+    const R = Value.Clean(T, {})
+    Assert.IsEqual(R, {})
+  })
+  it('Should clean illogical 4', () => {
+    const T = Type.Intersect([
+      Type.Number(),
+      Type.Object({ x: Type.Number() })
+    ])
+    const R = Value.Clean(T, { x: 1 })
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should clean illogical 5', () => {
+    const T = Type.Intersect([
+      Type.Number(),
+      Type.Object({ x: Type.Number() }),
+    ])
+    const R = Value.Clean(T, { u: null, x: 1 })
+    Assert.IsEqual(R, { u: null, x: 1 }) // u retained from Number
+  })
+})
diff --git a/test/runtime/value/clean/iterator.ts b/test/runtime/value/clean/iterator.ts
new file mode 100644
index 000000000..ec19feb07
--- /dev/null
+++ b/test/runtime/value/clean/iterator.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Iterator', () => {
+  it('Should clean 1', () => {
+    const T = Type.Iterator(Type.String())
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/keyof.ts b/test/runtime/value/clean/keyof.ts
new file mode 100644
index 000000000..911912992
--- /dev/null
+++ b/test/runtime/value/clean/keyof.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/KeyOf', () => {
+  it('Should clean 1', () => {
+    const T = Type.KeyOf(Type.Object({ x: Type.Number(), y: Type.Number() }))
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/kind.ts b/test/runtime/value/clean/kind.ts
new file mode 100644
index 000000000..8a4b836d5
--- /dev/null
+++ b/test/runtime/value/clean/kind.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type, Kind } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Kind', () => {
+  it('Should clean 1', () => {
+    const T = Type.Unsafe({ [Kind]: 'Unknown' })
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/literal.ts b/test/runtime/value/clean/literal.ts
new file mode 100644
index 000000000..bf424b784
--- /dev/null
+++ b/test/runtime/value/clean/literal.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Literal', () => {
+  it('Should clean 1', () => {
+    const T = Type.Literal(1)
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/never.ts b/test/runtime/value/clean/never.ts
new file mode 100644
index 000000000..2945598e4
--- /dev/null
+++ b/test/runtime/value/clean/never.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Never', () => {
+  it('Should clean 1', () => {
+    const T = Type.Never()
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/not.ts b/test/runtime/value/clean/not.ts
new file mode 100644
index 000000000..cb60a05d0
--- /dev/null
+++ b/test/runtime/value/clean/not.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Not', () => {
+  it('Should clean 1', () => {
+    const T = Type.Not(Type.Any())
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/null.ts b/test/runtime/value/clean/null.ts
new file mode 100644
index 000000000..a52d81a4d
--- /dev/null
+++ b/test/runtime/value/clean/null.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Null', () => {
+  it('Should clean 1', () => {
+    const T = Type.Null()
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/number.ts b/test/runtime/value/clean/number.ts
new file mode 100644
index 000000000..aafd93083
--- /dev/null
+++ b/test/runtime/value/clean/number.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Number', () => {
+  it('Should clean 1', () => {
+    const T = Type.Number()
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/object.ts b/test/runtime/value/clean/object.ts
new file mode 100644
index 000000000..805665a7e
--- /dev/null
+++ b/test/runtime/value/clean/object.ts
@@ -0,0 +1,178 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Object', () => {
+  // ----------------------------------------------------------------
+  // Clean
+  // ----------------------------------------------------------------
+  it('Should clean 1', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean 2', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const R = Value.Clean(T, {})
+    Assert.IsEqual(R, {})
+  })
+  it('Should clean 3', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const R = Value.Clean(T, { x: 1 })
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should clean 4', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const R = Value.Clean(T, { x: null })
+    Assert.IsEqual(R, { x: null })
+  })
+  // ----------------------------------------------------------------
+  // Nested
+  // ----------------------------------------------------------------
+  it('Should clean nested 1', () => {
+    const T = Type.Object({
+      x: Type.Object({
+        y: Type.Number(),
+      }),
+    })
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean nested 2', () => {
+    const T = Type.Object({
+      x: Type.Object({
+        y: Type.Number(),
+      }),
+    })
+    const R = Value.Clean(T, {})
+    Assert.IsEqual(R, {})
+  })
+  it('Should clean nested 3', () => {
+    const T = Type.Object({
+      x: Type.Object({
+        y: Type.Number(),
+      }),
+    })
+    const R = Value.Clean(T, { x: null })
+    Assert.IsEqual(R, { x: null })
+  })
+  it('Should clean nested 4', () => {
+    const T = Type.Object({
+      x: Type.Object({
+        y: Type.Number(),
+      }),
+    })
+    const R = Value.Clean(T, { x: { y: null } })
+    Assert.IsEqual(R, { x: { y: null } })
+  })
+  // ----------------------------------------------------------------
+  // Additional Properties
+  // ----------------------------------------------------------------
+  it('Should clean additional properties 1', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.String(),
+      },
+    )
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean additional properties 2', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.String(),
+      },
+    )
+    const R = Value.Clean(T, {})
+    Assert.IsEqual(R, {})
+  })
+  it('Should clean additional properties 3', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.String(),
+      },
+    )
+    const R = Value.Clean(T, { x: 1 })
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should clean additional properties 4', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.String(),
+      },
+    )
+    const R = Value.Clean(T, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  // ----------------------------------------------------------------
+  // Additional Properties Discard
+  // ----------------------------------------------------------------
+  it('Should clean additional properties discard 1', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.String(),
+      },
+    )
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean additional properties discard 2', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.String(),
+      },
+    )
+    const R = Value.Clean(T, { k: '', d: null })
+    Assert.IsEqual(R, { k: '' })
+  })
+  it('Should clean additional properties discard 3', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.String(),
+      },
+    )
+    const R = Value.Clean(T, { k: '', d: null, x: 1 })
+    Assert.IsEqual(R, { k: '', x: 1 })
+  })
+  it('Should clean additional properties discard 4', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      {
+        additionalProperties: Type.String(),
+      },
+    )
+    const R = Value.Clean(T, { k: '', d: null, x: 1, y: 2 })
+    Assert.IsEqual(R, { k: '', x: 1, y: 2 })
+  })
+})
diff --git a/test/runtime/value/clean/promise.ts b/test/runtime/value/clean/promise.ts
new file mode 100644
index 000000000..0d2d7e4ff
--- /dev/null
+++ b/test/runtime/value/clean/promise.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Promise', () => {
+  it('Should clean 1', () => {
+    const T = Type.Promise(Type.Any())
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/record.ts b/test/runtime/value/clean/record.ts
new file mode 100644
index 000000000..6ef341c15
--- /dev/null
+++ b/test/runtime/value/clean/record.ts
@@ -0,0 +1,114 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Record', () => {
+  // ----------------------------------------------------------------
+  // Clean
+  // ----------------------------------------------------------------
+  it('Should clean 1', () => {
+    const T = Type.Record(Type.Number(), Type.String())
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean 2', () => {
+    const T = Type.Record(Type.Number(), Type.String())
+    const R = Value.Clean(T, {})
+    Assert.IsEqual(R, {})
+  })
+  it('Should clean 3', () => {
+    const T = Type.Record(Type.Number(), Type.String())
+    const R = Value.Clean(T, { 0: null })
+    Assert.IsEqual(R, { 0: null })
+  })
+  // ----------------------------------------------------------------
+  // Clean Discard
+  // ----------------------------------------------------------------
+  it('Should clean discard 1', () => {
+    const T = Type.Record(Type.Number(), Type.String())
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean discard 2', () => {
+    const T = Type.Record(Type.Number(), Type.String())
+    const R = Value.Clean(T, { a: 1 })
+    Assert.IsEqual(R, {})
+  })
+  it('Should clean discard 3', () => {
+    const T = Type.Record(Type.Number(), Type.String())
+    const R = Value.Clean(T, { a: 1, 0: null })
+    Assert.IsEqual(R, { 0: null })
+  })
+  // ----------------------------------------------------------------
+  // Additional Properties
+  // ----------------------------------------------------------------
+  it('Should clean additional properties 1', () => {
+    const T = Type.Record(Type.Number(), Type.String(), {
+      additionalProperties: Type.Boolean(),
+    })
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean additional properties 2', () => {
+    const T = Type.Record(Type.Number(), Type.String(), {
+      additionalProperties: Type.Boolean(),
+    })
+    const R = Value.Clean(T, {})
+    Assert.IsEqual(R, {})
+  })
+  it('Should clean additional properties 3', () => {
+    const T = Type.Record(Type.Number(), Type.String(), {
+      additionalProperties: Type.Boolean(),
+    })
+    const R = Value.Clean(T, { 0: null })
+    Assert.IsEqual(R, { 0: null })
+  })
+  // ----------------------------------------------------------------
+  // Additional Properties Discard
+  // ----------------------------------------------------------------
+  it('Should clean additional properties discard 1', () => {
+    const T = Type.Record(Type.Number(), Type.String(), {
+      additionalProperties: Type.Boolean(),
+    })
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean additional properties discard 2', () => {
+    const T = Type.Record(Type.Number(), Type.String(), {
+      additionalProperties: Type.Boolean(),
+    })
+    const R = Value.Clean(T, { a: null })
+    Assert.IsEqual(R, {})
+  })
+  it('Should clean additional properties discard 3', () => {
+    const T = Type.Record(Type.Number(), Type.String(), {
+      additionalProperties: Type.Boolean(),
+    })
+    const R = Value.Clean(T, { a: null, 0: null })
+    Assert.IsEqual(R, { 0: null })
+  })
+  // ----------------------------------------------------------------
+  // Additional Properties Keep
+  // ----------------------------------------------------------------
+  it('Should clean additional properties keep 1', () => {
+    const T = Type.Record(Type.Number(), Type.String(), {
+      additionalProperties: Type.Boolean(),
+    })
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean additional properties keep 2', () => {
+    const T = Type.Record(Type.Number(), Type.String(), {
+      additionalProperties: Type.Boolean(),
+    })
+    const R = Value.Clean(T, { a: true })
+    Assert.IsEqual(R, { a: true })
+  })
+  it('Should clean additional properties keep 3', () => {
+    const T = Type.Record(Type.Number(), Type.String(), {
+      additionalProperties: Type.Boolean(),
+    })
+    const R = Value.Clean(T, { a: true, 0: null })
+    Assert.IsEqual(R, { a: true, 0: null })
+  })
+})
diff --git a/test/runtime/value/clean/recursive.ts b/test/runtime/value/clean/recursive.ts
new file mode 100644
index 000000000..1a6bb6e82
--- /dev/null
+++ b/test/runtime/value/clean/recursive.ts
@@ -0,0 +1,112 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Recursive', () => {
+  // ----------------------------------------------------------------
+  // Clean
+  // ----------------------------------------------------------------
+  it('Should clean 1', () => {
+    const T = Type.Recursive((This) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(This),
+      }),
+    )
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean 2', () => {
+    const T = Type.Recursive((This) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(This),
+      }),
+    )
+    const R = Value.Clean(T, { id: null })
+    Assert.IsEqual(R, { id: null })
+  })
+  it('Should clean 3', () => {
+    const T = Type.Recursive((This) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(This),
+      }),
+    )
+    const R = Value.Clean(T, { id: null, nodes: null })
+    Assert.IsEqual(R, { id: null, nodes: null })
+  })
+  it('Should clean 4', () => {
+    const T = Type.Recursive((This) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(This),
+      }),
+    )
+    const R = Value.Clean(T, { id: null, nodes: [] })
+    Assert.IsEqual(R, { id: null, nodes: [] })
+  })
+  it('Should clean 5', () => {
+    const T = Type.Recursive((This) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(This),
+      }),
+    )
+    const R = Value.Clean(T, { id: null, nodes: [{ id: null }] })
+    Assert.IsEqual(R, { id: null, nodes: [{ id: null }] })
+  })
+  // ----------------------------------------------------------------
+  // Clean Discard
+  // ----------------------------------------------------------------
+  it('Should clean discard 1', () => {
+    const T = Type.Recursive((This) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(This),
+      }),
+    )
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean discard 2', () => {
+    const T = Type.Recursive((This) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(This),
+      }),
+    )
+    const R = Value.Clean(T, { u: null, id: null })
+    Assert.IsEqual(R, { id: null })
+  })
+  it('Should clean discard 3', () => {
+    const T = Type.Recursive((This) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(This),
+      }),
+    )
+    const R = Value.Clean(T, { u: null, id: null, nodes: null })
+    Assert.IsEqual(R, { id: null, nodes: null })
+  })
+  it('Should clean discard 4', () => {
+    const T = Type.Recursive((This) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(This),
+      }),
+    )
+    const R = Value.Clean(T, { u: null, id: null, nodes: [] })
+    Assert.IsEqual(R, { id: null, nodes: [] })
+  })
+  it('Should clean discard 5', () => {
+    const T = Type.Recursive((This) =>
+      Type.Object({
+        id: Type.String(),
+        nodes: Type.Array(This),
+      }),
+    )
+    const R = Value.Clean(T, { u: null, id: null, nodes: [{ u: null, id: null }] })
+    Assert.IsEqual(R, { id: null, nodes: [{ id: null }] })
+  })
+})
diff --git a/test/runtime/value/clean/ref.ts b/test/runtime/value/clean/ref.ts
new file mode 100644
index 000000000..b06556159
--- /dev/null
+++ b/test/runtime/value/clean/ref.ts
@@ -0,0 +1,78 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Ref', () => {
+  // ----------------------------------------------------------------
+  // Clean
+  // ----------------------------------------------------------------
+  it('Should clean 1', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+      },
+      { $id: 'A' },
+    )
+    const T = Type.Ref('A')
+    const R = Value.Clean(T, [A], null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean 2', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+      },
+      { $id: 'A' },
+    )
+    const T = Type.Ref('A')
+    const R = Value.Clean(T, [A], {})
+    Assert.IsEqual(R, {})
+  })
+  it('Should clean 3', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+      },
+      { $id: 'A' },
+    )
+    const T = Type.Ref('A')
+    const R = Value.Clean(T, [A], { x: null })
+    Assert.IsEqual(R, { x: null })
+  })
+  // ----------------------------------------------------------------
+  // Clean Discard
+  // ----------------------------------------------------------------
+  it('Should clean discard 1', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+      },
+      { $id: 'A' },
+    )
+    const T = Type.Ref('A')
+    const R = Value.Clean(T, [A], null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean discard 2', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+      },
+      { $id: 'A' },
+    )
+    const T = Type.Ref('A')
+    const R = Value.Clean(T, [A], { a: null })
+    Assert.IsEqual(R, {})
+  })
+  it('Should clean discard 3', () => {
+    const A = Type.Object(
+      {
+        x: Type.Number(),
+      },
+      { $id: 'A' },
+    )
+    const T = Type.Ref('A')
+    const R = Value.Clean(T, [A], { a: null, x: null })
+    Assert.IsEqual(R, { x: null })
+  })
+})
diff --git a/test/runtime/value/clean/regexp.ts b/test/runtime/value/clean/regexp.ts
new file mode 100644
index 000000000..6b1d57421
--- /dev/null
+++ b/test/runtime/value/clean/regexp.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/RegExp', () => {
+  it('Should clean 1', () => {
+    const T = Type.RegExp('')
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/string.ts b/test/runtime/value/clean/string.ts
new file mode 100644
index 000000000..aa5d75727
--- /dev/null
+++ b/test/runtime/value/clean/string.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/String', () => {
+  it('Should clean 1', () => {
+    const T = Type.String()
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/symbol.ts b/test/runtime/value/clean/symbol.ts
new file mode 100644
index 000000000..62047d28e
--- /dev/null
+++ b/test/runtime/value/clean/symbol.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Symbol', () => {
+  it('Should clean 1', () => {
+    const T = Type.Symbol()
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/template-literal.ts b/test/runtime/value/clean/template-literal.ts
new file mode 100644
index 000000000..f76730548
--- /dev/null
+++ b/test/runtime/value/clean/template-literal.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/TemplateLiteral', () => {
+  it('Should clean 1', () => {
+    const T = Type.TemplateLiteral('')
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/tuple.ts b/test/runtime/value/clean/tuple.ts
new file mode 100644
index 000000000..81618f0f9
--- /dev/null
+++ b/test/runtime/value/clean/tuple.ts
@@ -0,0 +1,110 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Tuple', () => {
+  // ----------------------------------------------------------------
+  // Clean
+  // ----------------------------------------------------------------
+  it('Should clean 1', () => {
+    const T = Type.Tuple([Type.Number(), Type.Number()])
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean 2', () => {
+    const T = Type.Tuple([Type.Number(), Type.Number()])
+    const R = Value.Clean(T, [])
+    Assert.IsEqual(R, [])
+  })
+  it('Should clean 3', () => {
+    const T = Type.Tuple([Type.Number(), Type.Number()])
+    const R = Value.Clean(T, [1, 2])
+    Assert.IsEqual(R, [1, 2])
+  })
+  it('Should clean 4', () => {
+    const T = Type.Tuple([Type.Number(), Type.Number()])
+    const R = Value.Clean(T, [1, 2, 3])
+    Assert.IsEqual(R, [1, 2])
+  })
+  // ----------------------------------------------------------------
+  // Clean Deep
+  // ----------------------------------------------------------------
+  it('Should clean deep 1', () => {
+    const T = Type.Tuple([
+      Type.Number(),
+      Type.Object({
+        x: Type.Number(),
+      }),
+    ])
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean deep 2', () => {
+    const T = Type.Tuple([
+      Type.Number(),
+      Type.Object({
+        x: Type.Number(),
+      }),
+    ])
+    const R = Value.Clean(T, [])
+    Assert.IsEqual(R, [])
+  })
+  it('Should clean deep 3', () => {
+    const T = Type.Tuple([
+      Type.Number(),
+      Type.Object({
+        x: Type.Number(),
+      }),
+    ])
+    const R = Value.Clean(T, [1])
+    Assert.IsEqual(R, [1])
+  })
+  it('Should clean deep 4', () => {
+    const T = Type.Tuple([
+      Type.Number(),
+      Type.Object({
+        x: Type.Number(),
+      }),
+    ])
+    const R = Value.Clean(T, [1, null])
+    Assert.IsEqual(R, [1, null])
+  })
+  it('Should clean deep 5', () => {
+    const T = Type.Tuple([
+      Type.Number(),
+      Type.Object({
+        x: Type.Number(),
+      }),
+    ])
+    const R = Value.Clean(T, [1, { x: null }])
+    Assert.IsEqual(R, [1, { x: null }])
+  })
+  it('Should clean deep 6', () => {
+    const T = Type.Tuple([
+      Type.Number(),
+      Type.Object({
+        x: Type.Number(),
+      }),
+    ])
+    const R = Value.Clean(T, [1, { u: null, x: null }])
+    Assert.IsEqual(R, [1, { x: null }])
+  })
+  // ----------------------------------------------------------------
+  // Clean Empty
+  // ----------------------------------------------------------------
+  it('Should clean empty 1', () => {
+    const T = Type.Tuple([])
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean empty 2', () => {
+    const T = Type.Tuple([])
+    const R = Value.Clean(T, [])
+    Assert.IsEqual(R, [])
+  })
+  it('Should clean empty 3', () => {
+    const T = Type.Tuple([])
+    const R = Value.Clean(T, [1])
+    Assert.IsEqual(R, [])
+  })
+})
diff --git a/test/runtime/value/clean/uint8array.ts b/test/runtime/value/clean/uint8array.ts
new file mode 100644
index 000000000..732eb5b71
--- /dev/null
+++ b/test/runtime/value/clean/uint8array.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Uint8Array', () => {
+  it('Should clean 1', () => {
+    const T = Type.Uint8Array()
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/undefined.ts b/test/runtime/value/clean/undefined.ts
new file mode 100644
index 000000000..4b590c41b
--- /dev/null
+++ b/test/runtime/value/clean/undefined.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Undefined', () => {
+  it('Should clean 1', () => {
+    const T = Type.Undefined()
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/union.ts b/test/runtime/value/clean/union.ts
new file mode 100644
index 000000000..443e3d651
--- /dev/null
+++ b/test/runtime/value/clean/union.ts
@@ -0,0 +1,134 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Union', () => {
+  // ----------------------------------------------------------------
+  // Clean
+  // ----------------------------------------------------------------
+  it('Should clean 1', () => {
+    const T = Type.Union([Type.Number(), Type.Boolean()])
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean 2', () => {
+    const T = Type.Union([Type.Number(), Type.Boolean()])
+    const R = Value.Clean(T, 1)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should clean 2', () => {
+    const T = Type.Union([Type.Number(), Type.Boolean()])
+    const R = Value.Clean(T, true)
+    Assert.IsEqual(R, true)
+  })
+  // ----------------------------------------------------------------
+  // Clean Select
+  // ----------------------------------------------------------------
+  it('Should clean select 1', () => {
+    const X = Type.Object({ x: Type.Number() })
+    const Y = Type.Object({ y: Type.Number() })
+    const T = Type.Union([X, Y])
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean select 2', () => {
+    const X = Type.Object({ x: Type.Number() })
+    const Y = Type.Object({ y: Type.Number() })
+    const T = Type.Union([X, Y])
+    const R = Value.Clean(T, {})
+    Assert.IsEqual(R, {})
+  })
+  it('Should clean select 3', () => {
+    const X = Type.Object({ x: Type.Number() })
+    const Y = Type.Object({ y: Type.Number() })
+    const T = Type.Union([X, Y])
+    const R = Value.Clean(T, { x: null })
+    Assert.IsEqual(R, { x: null })
+  })
+  it('Should clean select 4', () => {
+    const X = Type.Object({ x: Type.Number() })
+    const Y = Type.Object({ y: Type.Number() })
+    const T = Type.Union([X, Y])
+    const R = Value.Clean(T, { y: null })
+    Assert.IsEqual(R, { y: null })
+  })
+  // ----------------------------------------------------------------
+  // Clean Select Discard
+  // ----------------------------------------------------------------
+  it('Should clean select discard 1', () => {
+    const X = Type.Object({ x: Type.Number() })
+    const Y = Type.Object({ y: Type.Number() })
+    const T = Type.Union([X, Y])
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean select discard 2', () => {
+    const X = Type.Object({ x: Type.Number() })
+    const Y = Type.Object({ y: Type.Number() })
+    const T = Type.Union([X, Y])
+    const R = Value.Clean(T, { u: null })
+    Assert.IsEqual(R, { u: null }) // no match
+  })
+  it('Should clean select discard 3', () => {
+    const X = Type.Object({ x: Type.Number() })
+    const Y = Type.Object({ y: Type.Number() })
+    const T = Type.Union([X, Y])
+    const R = Value.Clean(T, { u: null, x: 1 })
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should clean select discard 4', () => {
+    const X = Type.Object({ x: Type.Number() })
+    const Y = Type.Object({ y: Type.Number() })
+    const T = Type.Union([X, Y])
+    const R = Value.Clean(T, { u: null, y: 1 })
+    Assert.IsEqual(R, { y: 1 })
+  })
+  // ----------------------------------------------------------------
+  // Clean Select Retain
+  // ----------------------------------------------------------------
+  it('Should clean select retain 1', () => {
+    const X = Type.Object({ x: Type.Number() }, { additionalProperties: Type.Null() })
+    const Y = Type.Object({ y: Type.Number() }, { additionalProperties: Type.Null() })
+    const T = Type.Union([X, Y])
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean select retain 2', () => {
+    const X = Type.Object({ x: Type.Number() }, { additionalProperties: Type.Null() })
+    const Y = Type.Object({ y: Type.Number() }, { additionalProperties: Type.Null() })
+    const T = Type.Union([X, Y])
+    const R = Value.Clean(T, { u: null })
+    Assert.IsEqual(R, { u: null })
+  })
+  it('Should clean select retain 3', () => {
+    const X = Type.Object({ x: Type.Number() }, { additionalProperties: Type.Null() })
+    const Y = Type.Object({ y: Type.Number() }, { additionalProperties: Type.Null() })
+    const T = Type.Union([X, Y])
+    const R = Value.Clean(T, { u: null, x: 1 })
+    Assert.IsEqual(R, { u: null, x: 1 })
+  })
+  it('Should clean select retain 4', () => {
+    const X = Type.Object({ x: Type.Number() }, { additionalProperties: Type.Null() })
+    const Y = Type.Object({ y: Type.Number() }, { additionalProperties: Type.Null() })
+    const T = Type.Union([X, Y])
+    const R = Value.Clean(T, { u: null, y: 1 })
+    Assert.IsEqual(R, { u: null, y: 1 })
+  })
+  // ----------------------------------------------------------------
+  // Clean Select First and Discard
+  // ----------------------------------------------------------------
+  it('Should clean select first and discard 1', () => {
+    const X = Type.Object({ x: Type.Number() })
+    const Y = Type.Object({ y: Type.Number() }, { additionalProperties: Type.Null() })
+    const T = Type.Union([X, Y])
+    const R = Value.Clean(T, { u: null, x: 1 })
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should clean select first and discard 2', () => {
+    const X = Type.Object({ x: Type.Number() })
+    const Y = Type.Object({ y: Type.Number() }, { additionalProperties: Type.Null() })
+    const T = Type.Union([X, Y])
+    const R = Value.Clean(T, { u: null, y: 1 })
+    Assert.IsEqual(R, { u: null, y: 1 })
+  })
+})
diff --git a/test/runtime/value/clean/unknown.ts b/test/runtime/value/clean/unknown.ts
new file mode 100644
index 000000000..edba3ebfc
--- /dev/null
+++ b/test/runtime/value/clean/unknown.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Unknown', () => {
+  it('Should clean 1', () => {
+    const T = Type.Unknown()
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/clean/void.ts b/test/runtime/value/clean/void.ts
new file mode 100644
index 000000000..cd4c20db0
--- /dev/null
+++ b/test/runtime/value/clean/void.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Void', () => {
+  it('Should clean 1', () => {
+    const T = Type.Void()
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/create/regexp.ts b/test/runtime/value/create/regexp.ts
index f1415fd6a..cc424393c 100644
--- a/test/runtime/value/create/regexp.ts
+++ b/test/runtime/value/create/regexp.ts
@@ -13,4 +13,11 @@ describe('value/create/RegEx', () => {
     const T = Type.RegExp(/foo/, { default: 'foo' })
     Assert.IsEqual(Value.Create(T), 'foo')
   })
+  // ----------------------------------------------------------------
+  // Throw
+  // ----------------------------------------------------------------
+  it('Should throw with no default', () => {
+    const T = Type.RegExp(/foo/)
+    Assert.Throws(() => Value.Create(T))
+  })
 })
diff --git a/test/runtime/value/default/any.ts b/test/runtime/value/default/any.ts
new file mode 100644
index 000000000..15b12e979
--- /dev/null
+++ b/test/runtime/value/default/any.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Any', () => {
+  it('Should use default', () => {
+    const T = Type.Any({ default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Any({ default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/array.ts b/test/runtime/value/default/array.ts
new file mode 100644
index 000000000..be385e603
--- /dev/null
+++ b/test/runtime/value/default/array.ts
@@ -0,0 +1,24 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Array', () => {
+  it('Should use default', () => {
+    const T = Type.Array(Type.Number(), { default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Array(Type.Number(), { default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+  // ----------------------------------------------------------------
+  // Elements
+  // ----------------------------------------------------------------
+  it('Should use default on elements', () => {
+    const T = Type.Array(Type.Number({ default: 2 }))
+    const R = Value.Default(T, [1, undefined, 3])
+    Assert.IsEqual(R, [1, 2, 3])
+  })
+})
diff --git a/test/runtime/value/default/async-iterator.ts b/test/runtime/value/default/async-iterator.ts
new file mode 100644
index 000000000..dd26f579c
--- /dev/null
+++ b/test/runtime/value/default/async-iterator.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/AsyncIterator', () => {
+  it('Should use default', () => {
+    const T = Type.AsyncIterator(Type.Number(), { default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.AsyncIterator(Type.Number(), { default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/bigint.ts b/test/runtime/value/default/bigint.ts
new file mode 100644
index 000000000..b7e8aa710
--- /dev/null
+++ b/test/runtime/value/default/bigint.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/BigInt', () => {
+  it('Should use default', () => {
+    const T = Type.BigInt({ default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.BigInt({ default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/boolean.ts b/test/runtime/value/default/boolean.ts
new file mode 100644
index 000000000..ee05bb06b
--- /dev/null
+++ b/test/runtime/value/default/boolean.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Boolean', () => {
+  it('Should use default', () => {
+    const T = Type.Boolean({ default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Boolean({ default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/composite.ts b/test/runtime/value/default/composite.ts
new file mode 100644
index 000000000..8a73e4106
--- /dev/null
+++ b/test/runtime/value/default/composite.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Composite', () => {
+  it('Should use default', () => {
+    const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })], { default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })], { default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/constructor.ts b/test/runtime/value/default/constructor.ts
new file mode 100644
index 000000000..76cb2343f
--- /dev/null
+++ b/test/runtime/value/default/constructor.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Constructor', () => {
+  it('Should use default', () => {
+    const T = Type.Constructor([], Type.Number(), { default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Constructor([], Type.Number(), { default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/date.ts b/test/runtime/value/default/date.ts
new file mode 100644
index 000000000..2522cf20d
--- /dev/null
+++ b/test/runtime/value/default/date.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Date', () => {
+  it('Should use default', () => {
+    const T = Type.Date({ default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Date({ default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/enum.ts b/test/runtime/value/default/enum.ts
new file mode 100644
index 000000000..ae6f9ece2
--- /dev/null
+++ b/test/runtime/value/default/enum.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Enum', () => {
+  it('Should use default', () => {
+    const T = Type.Enum({}, { default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Enum({}, { default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/function.ts b/test/runtime/value/default/function.ts
new file mode 100644
index 000000000..959c28284
--- /dev/null
+++ b/test/runtime/value/default/function.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Function', () => {
+  it('Should use default', () => {
+    const T = Type.Function([], Type.Number(), { default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Function([], Type.Number(), { default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/index.ts b/test/runtime/value/default/index.ts
new file mode 100644
index 000000000..7395f9fce
--- /dev/null
+++ b/test/runtime/value/default/index.ts
@@ -0,0 +1,35 @@
+import './any'
+import './array'
+import './async-iterator'
+import './bigint'
+import './boolean'
+import './composite'
+import './constructor'
+import './date'
+import './enum'
+import './function'
+import './integer'
+import './intersect'
+import './iterator'
+import './keyof'
+import './kind'
+import './literal'
+import './never'
+import './not'
+import './null'
+import './number'
+import './object'
+import './promise'
+import './record'
+import './recursive'
+import './ref'
+import './regexp'
+import './string'
+import './symbol'
+import './template-literal'
+import './tuple'
+import './uint8array'
+import './undefined'
+import './union'
+import './unknown'
+import './void'
diff --git a/test/runtime/value/default/integer.ts b/test/runtime/value/default/integer.ts
new file mode 100644
index 000000000..c0ce64b4a
--- /dev/null
+++ b/test/runtime/value/default/integer.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Integer', () => {
+  it('Should use default', () => {
+    const T = Type.Integer({ default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Integer({ default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/intersect.ts b/test/runtime/value/default/intersect.ts
new file mode 100644
index 000000000..0e72b3e6e
--- /dev/null
+++ b/test/runtime/value/default/intersect.ts
@@ -0,0 +1,106 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Intersect', () => {
+  it('Should use default', () => {
+    const T = Type.Intersect([Type.Number(), Type.String()], { default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Intersect([Type.Number(), Type.String()], { default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+  // ----------------------------------------------------------------
+  // Intersected
+  // ----------------------------------------------------------------
+  it('Should use default intersected 1', () => {
+    const A = Type.Object({
+      a: Type.Number({ default: 1 }),
+    })
+    const B = Type.Object({
+      b: Type.Number({ default: 2 }),
+    })
+    const T = Type.Intersect([A, B])
+    const R = Value.Default(T, {})
+    Assert.IsEqual(R, { a: 1, b: 2 })
+  })
+  it('Should use default intersected 2', () => {
+    const A = Type.Object({
+      a: Type.Number(),
+    })
+    const B = Type.Object({
+      b: Type.Number(),
+    })
+    const T = Type.Intersect([A, B])
+    const R = Value.Default(T, {})
+    Assert.IsEqual(R, {})
+  })
+  it('Should use default intersected 3', () => {
+    const A = Type.Object({
+      a: Type.Number({ default: 1 }),
+    })
+    const B = Type.Object({
+      b: Type.Number({ default: 2 }),
+    })
+    const T = Type.Intersect([A, B])
+    const R = Value.Default(T, { a: 3 })
+    Assert.IsEqual(R, { a: 3, b: 2 })
+  })
+  it('Should use default intersected 4', () => {
+    const A = Type.Object({
+      a: Type.Number({ default: 1 }),
+    })
+    const B = Type.Object({
+      b: Type.Number({ default: 2 }),
+    })
+    const T = Type.Intersect([A, B])
+    const R = Value.Default(T, { a: 4, b: 5 })
+    Assert.IsEqual(R, { a: 4, b: 5 })
+  })
+  it('Should use default intersected 5', () => {
+    const A = Type.Object({
+      a: Type.Number({ default: 1 }),
+    })
+    const B = Type.Number({ default: 2 })
+    const T = Type.Intersect([A, B])
+    const R = Value.Default(T, {})
+    Assert.IsEqual(R, { a: 1 })
+  })
+  it('Should use default intersected 6', () => {
+    const A = Type.Number({ default: 2 })
+    const B = Type.Object({
+      a: Type.Number({ default: 1 }),
+    })
+    const T = Type.Intersect([A, B])
+    const R = Value.Default(T, {})
+    Assert.IsEqual(R, { a: 1 })
+  })
+  // ----------------------------------------------------------------
+  // Intersected Deep
+  // ----------------------------------------------------------------
+  it('Should use default intersected deep 1', () => {
+    const A = Type.Object({ a: Type.Number({ default: 1 }) })
+    const B = Type.Object({ b: Type.Number({ default: 2 }) })
+    const C = Type.Object({ c: Type.Number({ default: 3 }) })
+    const D = Type.Object({ d: Type.Number({ default: 4 }) })
+    const T1 = Type.Intersect([A, B])
+    const T2 = Type.Intersect([C, D])
+    const T = Type.Intersect([T1, T2])
+    const R = Value.Default(T, {})
+    Assert.IsEqual(R, { a: 1, b: 2, c: 3, d: 4 })
+  })
+  it('Should use default intersected deep 2', () => {
+    const A = Type.Object({ a: Type.Number({}) })
+    const B = Type.Object({ b: Type.Number({}) })
+    const C = Type.Object({ c: Type.Number({}) })
+    const D = Type.Object({ d: Type.Number({}) })
+    const T1 = Type.Intersect([A, B])
+    const T2 = Type.Intersect([C, D])
+    const T = Type.Intersect([T1, T2])
+    const R = Value.Default(T, {})
+    Assert.IsEqual(R, {})
+  })
+})
diff --git a/test/runtime/value/default/iterator.ts b/test/runtime/value/default/iterator.ts
new file mode 100644
index 000000000..d49b7f296
--- /dev/null
+++ b/test/runtime/value/default/iterator.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Iterator', () => {
+  it('Should use default', () => {
+    const T = Type.Iterator(Type.Number(), { default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Iterator(Type.Number(), { default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/keyof.ts b/test/runtime/value/default/keyof.ts
new file mode 100644
index 000000000..2cb0bb26b
--- /dev/null
+++ b/test/runtime/value/default/keyof.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/KeyOf', () => {
+  it('Should use default', () => {
+    const T = Type.KeyOf(Type.Object({ x: Type.Number() }), { default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.KeyOf(Type.Object({ x: Type.Number() }), { default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/kind.ts b/test/runtime/value/default/kind.ts
new file mode 100644
index 000000000..1f8a96fcc
--- /dev/null
+++ b/test/runtime/value/default/kind.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type, Kind } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Kind', () => {
+  it('Should use default', () => {
+    const T = Type.Unsafe({ [Kind]: 'Unknown', default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Unsafe({ [Kind]: 'Unknown', default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/literal.ts b/test/runtime/value/default/literal.ts
new file mode 100644
index 000000000..fa01d55b9
--- /dev/null
+++ b/test/runtime/value/default/literal.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Literal', () => {
+  it('Should use default', () => {
+    const T = Type.Literal('foo', { default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Literal('foo', { default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/never.ts b/test/runtime/value/default/never.ts
new file mode 100644
index 000000000..a39542739
--- /dev/null
+++ b/test/runtime/value/default/never.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Never', () => {
+  it('Should use default', () => {
+    const T = Type.Never({ default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Never({ default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/not.ts b/test/runtime/value/default/not.ts
new file mode 100644
index 000000000..148756d5b
--- /dev/null
+++ b/test/runtime/value/default/not.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Not', () => {
+  it('Should use default', () => {
+    const T = Type.Not(Type.String(), { default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Not(Type.String(), { default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/null.ts b/test/runtime/value/default/null.ts
new file mode 100644
index 000000000..9246fe893
--- /dev/null
+++ b/test/runtime/value/default/null.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Null', () => {
+  it('Should use default', () => {
+    const T = Type.Null({ default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Null({ default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/number.ts b/test/runtime/value/default/number.ts
new file mode 100644
index 000000000..6dcaa7035
--- /dev/null
+++ b/test/runtime/value/default/number.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Number', () => {
+  it('Should use default', () => {
+    const T = Type.Number({ default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Number({ default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/object.ts b/test/runtime/value/default/object.ts
new file mode 100644
index 000000000..ab4dda473
--- /dev/null
+++ b/test/runtime/value/default/object.ts
@@ -0,0 +1,180 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Object', () => {
+  it('Should use default', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      { default: 1 },
+    )
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+        y: Type.Number(),
+      },
+      { default: 1 },
+    )
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+  // ----------------------------------------------------------------
+  // Construction
+  // ----------------------------------------------------------------
+  it('Should should fully construct object 1', () => {
+    const T = Type.Object(
+      {
+        x: Type.Object(
+          {
+            x: Type.Number({ default: 1 }),
+            y: Type.Number({ default: 2 }),
+          },
+          { default: {} },
+        ),
+        y: Type.Object(
+          {
+            x: Type.Number({ default: 3 }),
+            y: Type.Number({ default: 4 }),
+          },
+          { default: {} },
+        ),
+      },
+      { default: {} },
+    )
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, { x: { x: 1, y: 2 }, y: { x: 3, y: 4 } })
+  })
+  it('Should should fully construct object 2', () => {
+    const T = Type.Object(
+      {
+        x: Type.Object(
+          {
+            x: Type.Number({ default: 1 }),
+            y: Type.Number({ default: 2 }),
+          },
+          { default: {} },
+        ),
+        y: Type.Object(
+          {
+            x: Type.Number({ default: 3 }),
+            y: Type.Number({ default: 4 }),
+          },
+          { default: {} },
+        ),
+      },
+      { default: {} },
+    )
+    const R = Value.Default(T, { x: null })
+    Assert.IsEqual(R, { x: null, y: { x: 3, y: 4 } })
+  })
+  it('Should should fully construct object 3', () => {
+    const T = Type.Object(
+      {
+        x: Type.Object(
+          {
+            x: Type.Number({ default: 1 }),
+            y: Type.Number({ default: 2 }),
+          },
+          { default: {} },
+        ),
+        y: Type.Object(
+          {
+            x: Type.Number({ default: 3 }),
+            y: Type.Number({ default: 4 }),
+          },
+          { default: {} },
+        ),
+      },
+      { default: {} },
+    )
+    const R = Value.Default(T, { x: { x: null, y: null } })
+    Assert.IsEqual(R, { x: { x: null, y: null }, y: { x: 3, y: 4 } })
+  })
+  // ----------------------------------------------------------------
+  // Properties
+  // ----------------------------------------------------------------
+  it('Should use property defaults 1', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number({ default: 1 }),
+        y: Type.Number({ default: 2 }),
+      },
+      { default: 1 },
+    )
+    const R = Value.Default(T, {})
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should use property defaults 2', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    })
+    const R = Value.Default(T, {})
+    Assert.IsEqual(R, {})
+  })
+  it('Should use property defaults 3', () => {
+    const T = Type.Object({
+      x: Type.Number({ default: 1 }),
+      y: Type.Number(),
+    })
+    const R = Value.Default(T, {})
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should use property defaults 4', () => {
+    const T = Type.Object({
+      x: Type.Number({ default: 1 }),
+      y: Type.Number(),
+    })
+    const R = Value.Default(T, { x: 3 })
+    Assert.IsEqual(R, { x: 3 })
+  })
+  // ----------------------------------------------------------------
+  // AdditionalProperties
+  // ----------------------------------------------------------------
+  it('Should use additional property defaults 1', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number({ default: 1 }),
+        y: Type.Number({ default: 2 }),
+      },
+      {
+        additionalProperties: Type.Number({ default: 3 }),
+      },
+    )
+    const R = Value.Default(T, {})
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should use additional property defaults 2', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number({ default: 1 }),
+        y: Type.Number({ default: 2 }),
+      },
+      {
+        additionalProperties: Type.Number({ default: 3 }),
+      },
+    )
+    const R = Value.Default(T, { x: null, y: null, z: undefined })
+    Assert.IsEqual(R, { x: null, y: null, z: 3 })
+  })
+  it('Should use additional property defaults 3', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number({ default: 1 }),
+        y: Type.Number({ default: 2 }),
+      },
+      {
+        additionalProperties: Type.Number(),
+      },
+    )
+    const R = Value.Default(T, { x: null, y: null, z: undefined })
+    Assert.IsEqual(R, { x: null, y: null, z: undefined })
+  })
+})
diff --git a/test/runtime/value/default/promise.ts b/test/runtime/value/default/promise.ts
new file mode 100644
index 000000000..659e052cb
--- /dev/null
+++ b/test/runtime/value/default/promise.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Promise', () => {
+  it('Should use default', () => {
+    const T = Type.Any({ default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Any({ default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/record.ts b/test/runtime/value/default/record.ts
new file mode 100644
index 000000000..4b300ddc2
--- /dev/null
+++ b/test/runtime/value/default/record.ts
@@ -0,0 +1,66 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Record', () => {
+  it('Should use default', () => {
+    const T = Type.Record(Type.String(), Type.Number(), { default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Record(Type.String(), Type.Number(), { default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+  // // ----------------------------------------------------------------
+  // // Properties
+  // // ----------------------------------------------------------------
+  it('Should use property defaults 1', () => {
+    const T = Type.Record(Type.Number(), Type.Number({ default: 1 }))
+    const R = Value.Default(T, { 0: undefined })
+    Assert.IsEqual(R, { 0: 1 })
+  })
+  it('Should use property defaults 2', () => {
+    const T = Type.Record(Type.Number(), Type.Number({ default: 1 }))
+    const R = Value.Default(T, { 0: null })
+    Assert.IsEqual(R, { 0: null })
+  })
+  it('Should use property defaults 3', () => {
+    const T = Type.Record(Type.Number(), Type.Number({ default: 1 }))
+    const R = Value.Default(T, { a: undefined })
+    Assert.IsEqual(R, { a: undefined })
+  })
+  it('Should use property defaults 4', () => {
+    const T = Type.Record(Type.Number(), Type.Number({ default: 1 }))
+    const R = Value.Default(T, { 0: undefined })
+    Assert.IsEqual(R, { 0: 1 })
+  })
+  it('Should use property defaults 5', () => {
+    const T = Type.Record(Type.Number(), Type.Number())
+    const R = Value.Default(T, { 0: undefined })
+    Assert.IsEqual(R, { 0: undefined })
+  })
+  it('Should use property defaults 6', () => {
+    const T = Type.Record(Type.Number(), Type.Number({ default: 1 }))
+    const R = Value.Default(T, {})
+    Assert.IsEqual(R, {})
+  })
+  // ----------------------------------------------------------------
+  // Additional Properties
+  // ----------------------------------------------------------------
+  it('Should use additional property defaults 1', () => {
+    const T = Type.Record(Type.Number(), Type.Number({ default: 1 }), {
+      additionalProperties: Type.Number({ default: 3 }),
+    })
+    const R = Value.Default(T, { 0: undefined, a: undefined })
+    Assert.IsEqual(R, { 0: 1, a: 3 })
+  })
+  it('Should use additional property defaults 2', () => {
+    const T = Type.Record(Type.Number(), Type.Number({ default: 1 }), {
+      additionalProperties: Type.Number(),
+    })
+    const R = Value.Default(T, { 0: undefined, a: undefined })
+    Assert.IsEqual(R, { 0: 1, a: undefined })
+  })
+})
diff --git a/test/runtime/value/default/recursive.ts b/test/runtime/value/default/recursive.ts
new file mode 100644
index 000000000..417727bda
--- /dev/null
+++ b/test/runtime/value/default/recursive.ts
@@ -0,0 +1,58 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+// prettier-ignore
+describe('value/default/Recursive', () => {
+  it('Should use default', () => {
+    const T = Type.Recursive((This) => Type.Object({
+      nodes: Type.Array(This)
+    }, { default: 1 }))
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Recursive((This) => Type.Object({
+      nodes: Type.Array(This)
+    }, { default: 1 }))
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+  // ----------------------------------------------------------------
+  // Recursive
+  // ----------------------------------------------------------------
+  it('Should use default recursive values', () => {
+    const T = Type.Recursive((This) => Type.Object({
+      id: Type.String({ default: 1 }),
+      nodes: Type.Array(This, { default: [] }) // need this
+    }))
+    const R = Value.Default(T, {
+      nodes: [{
+        nodes: [{
+          nodes: [{ id: null }]
+        }, {
+          nodes: [{ id: null }]
+        }]
+      }]
+    })
+    Assert.IsEqual(R, {
+      nodes: [{
+        nodes: [{
+          nodes: [{
+            id: null,
+            nodes: []
+          }],
+          id: 1
+        }, {
+          nodes: [{
+            id: null,
+            nodes: []
+          }],
+          id: 1
+        }],
+        id: 1
+      }],
+      id: 1
+    })
+  })
+})
diff --git a/test/runtime/value/default/ref.ts b/test/runtime/value/default/ref.ts
new file mode 100644
index 000000000..634059573
--- /dev/null
+++ b/test/runtime/value/default/ref.ts
@@ -0,0 +1,33 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Ref', () => {
+  it('Should use default', () => {
+    const A = Type.String({ $id: 'A' })
+    const T = Type.Ref('A', { default: 1 })
+    const R = Value.Default(T, [A], undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const A = Type.String({ $id: 'A' })
+    const T = Type.Ref('A', { default: 1 })
+    const R = Value.Default(T, [A], null)
+    Assert.IsEqual(R, null)
+  })
+  // ----------------------------------------------------------------
+  // Foreign
+  // ----------------------------------------------------------------
+  it('Should use default on foreign value', () => {
+    const A = Type.String({ $id: 'A', default: 1 })
+    const T = Type.Ref('A')
+    const R = Value.Default(T, [A], undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value on foreign value', () => {
+    const A = Type.String({ $id: 'A', default: 1 })
+    const T = Type.Ref('A')
+    const R = Value.Default(T, [A], null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/regexp.ts b/test/runtime/value/default/regexp.ts
new file mode 100644
index 000000000..9c32c7ab2
--- /dev/null
+++ b/test/runtime/value/default/regexp.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/RegExp', () => {
+  it('Should use default', () => {
+    const T = Type.RegExp('', { default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.RegExp('', { default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/string.ts b/test/runtime/value/default/string.ts
new file mode 100644
index 000000000..af833332e
--- /dev/null
+++ b/test/runtime/value/default/string.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/String', () => {
+  it('Should use default', () => {
+    const T = Type.String({ default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.String({ default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/symbol.ts b/test/runtime/value/default/symbol.ts
new file mode 100644
index 000000000..d593fb7b8
--- /dev/null
+++ b/test/runtime/value/default/symbol.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Symbol', () => {
+  it('Should use default', () => {
+    const T = Type.Symbol({ default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Symbol({ default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/template-literal.ts b/test/runtime/value/default/template-literal.ts
new file mode 100644
index 000000000..2dd6b7e83
--- /dev/null
+++ b/test/runtime/value/default/template-literal.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/TemplateLiteral', () => {
+  it('Should use default', () => {
+    const T = Type.TemplateLiteral('hello', { default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.TemplateLiteral('hello', { default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/tuple.ts b/test/runtime/value/default/tuple.ts
new file mode 100644
index 000000000..c7acdc99b
--- /dev/null
+++ b/test/runtime/value/default/tuple.ts
@@ -0,0 +1,44 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Tuple', () => {
+  it('Should use default', () => {
+    const T = Type.Tuple([Type.Number(), Type.Number()], { default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Tuple([Type.Number(), Type.Number()], { default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+  // ----------------------------------------------------------------
+  // Elements
+  // ----------------------------------------------------------------
+  it('Should use default elements 1', () => {
+    const T = Type.Tuple([Type.Number({ default: 1 }), Type.Number({ default: 2 })], { default: [] })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should use default elements 2', () => {
+    const T = Type.Tuple([Type.Number({ default: 1 }), Type.Number({ default: 2 })], { default: [] })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, [1, 2])
+  })
+  it('Should use default elements 3', () => {
+    const T = Type.Tuple([Type.Number({ default: 1 }), Type.Number({ default: 2 })], { default: [] })
+    const R = Value.Default(T, [4, 5, 6])
+    Assert.IsEqual(R, [4, 5, 6])
+  })
+  it('Should use default elements 4', () => {
+    const T = Type.Tuple([Type.Number({ default: 1 }), Type.Number({ default: 2 })])
+    const R = Value.Default(T, [4, 5, 6])
+    Assert.IsEqual(R, [4, 5, 6])
+  })
+  it('Should use default elements 5', () => {
+    const T = Type.Tuple([Type.Number({ default: 1 }), Type.Number({ default: 2 })])
+    const R = Value.Default(T, [4])
+    Assert.IsEqual(R, [4, 2])
+  })
+})
diff --git a/test/runtime/value/default/uint8array.ts b/test/runtime/value/default/uint8array.ts
new file mode 100644
index 000000000..5c3cfa77d
--- /dev/null
+++ b/test/runtime/value/default/uint8array.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Uint8Array', () => {
+  it('Should use default', () => {
+    const T = Type.Uint8Array({ default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Uint8Array({ default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/undefined.ts b/test/runtime/value/default/undefined.ts
new file mode 100644
index 000000000..d622cd1c6
--- /dev/null
+++ b/test/runtime/value/default/undefined.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Undefined', () => {
+  it('Should use default', () => {
+    const T = Type.Undefined({ default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Undefined({ default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/union.ts b/test/runtime/value/default/union.ts
new file mode 100644
index 000000000..56b572caf
--- /dev/null
+++ b/test/runtime/value/default/union.ts
@@ -0,0 +1,110 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Union', () => {
+  it('Should use default', () => {
+    const T = Type.Union([Type.Number(), Type.String()], { default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Union([Type.Number(), Type.String()], { default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+  // ----------------------------------------------------------------
+  // Interior
+  // ----------------------------------------------------------------
+  it('Should default interior 1', () => {
+    const T = Type.Union([
+      Type.Object({
+        x: Type.Number({ default: 1 }),
+        y: Type.Number({ default: 2 }),
+      }),
+      Type.String({ default: 'hello' }),
+    ])
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should default interior 2', () => {
+    const T = Type.Union([
+      Type.Object({
+        x: Type.Number({ default: 1 }),
+        y: Type.Number({ default: 2 }),
+      }),
+      Type.String({ default: 'hello' }),
+    ])
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 'hello')
+  })
+  it('Should default interior 3', () => {
+    const T = Type.Union([
+      Type.Object({
+        x: Type.Number({ default: 1 }),
+        y: Type.Number({ default: 2 }),
+      }),
+      Type.String({ default: 'hello' }),
+    ])
+    const R = Value.Default(T, 'world')
+    Assert.IsEqual(R, 'world')
+  })
+  it('Should default interior 4', () => {
+    const T = Type.Union([
+      Type.Object({
+        x: Type.Number({ default: 1 }),
+        y: Type.Number({ default: 2 }),
+      }),
+      Type.String({ default: 'hello' }),
+    ])
+    const R = Value.Default(T, {})
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should default interior 5', () => {
+    const T = Type.Union([
+      Type.Object({
+        x: Type.Number({ default: 1 }),
+        y: Type.Number({ default: 2 }),
+      }),
+      Type.String({ default: 'hello' }),
+    ])
+    const R = Value.Default(T, { x: 3 })
+    Assert.IsEqual(R, { x: 3, y: 2 })
+  })
+  it('Should default interior 6', () => {
+    const T = Type.Union([
+      Type.Object({
+        x: Type.Number({ default: 1 }),
+        y: Type.Number({ default: 2 }),
+      }),
+      Type.String({ default: 'hello' }),
+    ])
+    const R = Value.Default(T, { x: 3, y: 4 })
+    Assert.IsEqual(R, { x: 3, y: 4 })
+  })
+  // ----------------------------------------------------------------
+  // Interior Unsafe
+  // ----------------------------------------------------------------
+  it('Should default interior unsafe 1', () => {
+    const T = Type.Union([
+      Type.Object({
+        x: Type.Number({ default: 1 }),
+        y: Type.Number({ default: 2 }),
+      }),
+      Type.Unsafe({ default: 'hello' }),
+    ])
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, undefined)
+  })
+  it('Should default interior unsafe 2', () => {
+    const T = Type.Union([
+      Type.Object({
+        x: Type.Number({ default: 1 }),
+        y: Type.Number({ default: 2 }),
+      }),
+      Type.Unsafe({ default: 'hello' }),
+    ])
+    const R = Value.Default(T, 'world')
+    Assert.IsEqual(R, 'world')
+  })
+})
diff --git a/test/runtime/value/default/unknown.ts b/test/runtime/value/default/unknown.ts
new file mode 100644
index 000000000..97236570d
--- /dev/null
+++ b/test/runtime/value/default/unknown.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Unknown', () => {
+  it('Should use default', () => {
+    const T = Type.Unknown({ default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Unknown({ default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/default/void.ts b/test/runtime/value/default/void.ts
new file mode 100644
index 000000000..03d03c1e3
--- /dev/null
+++ b/test/runtime/value/default/void.ts
@@ -0,0 +1,16 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Void', () => {
+  it('Should use default', () => {
+    const T = Type.Void({ default: 1 })
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Void({ default: 1 })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+})
diff --git a/test/runtime/value/guard/guard.ts b/test/runtime/value/guard/guard.ts
index d51511184..ee8d3839f 100644
--- a/test/runtime/value/guard/guard.ts
+++ b/test/runtime/value/guard/guard.ts
@@ -1,5 +1,5 @@
 import { Assert } from '../../assert/index'
-import * as ValueGuard from '@sinclair/typebox/value/guard'
+import * as ValueGuard from '@sinclair/typebox/value'
 
 describe('value/guard/ValueGuard', () => {
   // -----------------------------------------------------
diff --git a/test/runtime/value/hash/hash.ts b/test/runtime/value/hash/hash.ts
index 8d06d509f..aceb06480 100644
--- a/test/runtime/value/hash/hash.ts
+++ b/test/runtime/value/hash/hash.ts
@@ -1,122 +1,122 @@
-import * as ValueHash from '@sinclair/typebox/value/hash'
+import { Hash } from '@sinclair/typebox/value'
 import { Assert } from '../../assert/index'
 
 describe('value/hash/Hash', () => {
   it('Should hash number', () => {
-    Assert.IsEqual('bigint', typeof ValueHash.Hash(1))
-    const A = ValueHash.Hash(1)
-    const B = ValueHash.Hash(2)
+    Assert.IsEqual('bigint', typeof Hash(1))
+    const A = Hash(1)
+    const B = Hash(2)
     Assert.NotEqual(A, B)
   })
   it('Should hash string', () => {
-    Assert.IsEqual('bigint', typeof ValueHash.Hash('hello'))
-    const A = ValueHash.Hash('hello')
-    const B = ValueHash.Hash('world')
+    Assert.IsEqual('bigint', typeof Hash('hello'))
+    const A = Hash('hello')
+    const B = Hash('world')
     Assert.NotEqual(A, B)
   })
   it('Should hash boolean', () => {
-    Assert.IsEqual('bigint', typeof ValueHash.Hash(true))
-    Assert.IsEqual('bigint', typeof ValueHash.Hash(false))
-    const A = ValueHash.Hash(true)
-    const B = ValueHash.Hash(false)
+    Assert.IsEqual('bigint', typeof Hash(true))
+    Assert.IsEqual('bigint', typeof Hash(false))
+    const A = Hash(true)
+    const B = Hash(false)
     Assert.NotEqual(A, B)
   })
   it('Should hash null', () => {
-    Assert.IsEqual('bigint', typeof ValueHash.Hash(null))
-    const A = ValueHash.Hash(null)
-    const B = ValueHash.Hash(undefined)
+    Assert.IsEqual('bigint', typeof Hash(null))
+    const A = Hash(null)
+    const B = Hash(undefined)
     Assert.NotEqual(A, B)
   })
   it('Should hash array', () => {
-    Assert.IsEqual('bigint', typeof ValueHash.Hash([0, 1, 2, 3]))
-    const A = ValueHash.Hash([0, 1, 2, 3])
-    const B = ValueHash.Hash([0, 2, 2, 3])
+    Assert.IsEqual('bigint', typeof Hash([0, 1, 2, 3]))
+    const A = Hash([0, 1, 2, 3])
+    const B = Hash([0, 2, 2, 3])
     Assert.NotEqual(A, B)
   })
   it('Should hash object 1', () => {
     // prettier-ignore
-    Assert.IsEqual('bigint', typeof ValueHash.Hash({ x: 1, y: 2 }))
-    const A = ValueHash.Hash({ x: 1, y: 2 })
-    const B = ValueHash.Hash({ x: 2, y: 2 })
+    Assert.IsEqual('bigint', typeof Hash({ x: 1, y: 2 }))
+    const A = Hash({ x: 1, y: 2 })
+    const B = Hash({ x: 2, y: 2 })
     Assert.NotEqual(A, B)
   })
   it('Should hash object 2', () => {
-    const A = ValueHash.Hash({ x: 1, y: [1, 2] })
-    const B = ValueHash.Hash({ x: 1, y: [1, 3] })
+    const A = Hash({ x: 1, y: [1, 2] })
+    const B = Hash({ x: 1, y: [1, 3] })
     Assert.NotEqual(A, B)
   })
   it('Should hash object 3', () => {
-    const A = ValueHash.Hash({ x: 1, y: undefined })
-    const B = ValueHash.Hash({ x: 1 })
+    const A = Hash({ x: 1, y: undefined })
+    const B = Hash({ x: 1 })
     Assert.NotEqual(A, B)
   })
   it('Should hash object 4', () => {
-    const A = ValueHash.Hash({ x: 1, y: new Uint8Array([0, 1, 2]) })
-    const B = ValueHash.Hash({ x: 1, y: [0, 1, 2] })
+    const A = Hash({ x: 1, y: new Uint8Array([0, 1, 2]) })
+    const B = Hash({ x: 1, y: [0, 1, 2] })
     Assert.NotEqual(A, B)
   })
   it('Should hash object 5', () => {
-    const A = ValueHash.Hash({ x: 1, y: undefined })
-    const B = ValueHash.Hash({ x: 2, y: undefined })
+    const A = Hash({ x: 1, y: undefined })
+    const B = Hash({ x: 2, y: undefined })
     Assert.NotEqual(A, B)
   })
   it('Should hash Date', () => {
-    Assert.IsEqual('bigint', typeof ValueHash.Hash(new Date()))
-    const A = ValueHash.Hash(new Date(1))
-    const B = ValueHash.Hash(new Date(2))
+    Assert.IsEqual('bigint', typeof Hash(new Date()))
+    const A = Hash(new Date(1))
+    const B = Hash(new Date(2))
     Assert.NotEqual(A, B)
   })
   it('Should hash Uint8Array', () => {
-    Assert.IsEqual('bigint', typeof ValueHash.Hash(new Uint8Array([0, 1, 2, 3])))
-    const A = ValueHash.Hash(new Uint8Array([0, 1, 2, 3]))
-    const B = ValueHash.Hash(new Uint8Array([0, 2, 2, 3]))
+    Assert.IsEqual('bigint', typeof Hash(new Uint8Array([0, 1, 2, 3])))
+    const A = Hash(new Uint8Array([0, 1, 2, 3]))
+    const B = Hash(new Uint8Array([0, 2, 2, 3]))
     Assert.NotEqual(A, B)
   })
   it('Should hash undefined', () => {
-    Assert.IsEqual('bigint', typeof ValueHash.Hash(undefined))
-    const A = ValueHash.Hash(undefined)
-    const B = ValueHash.Hash(null)
+    Assert.IsEqual('bigint', typeof Hash(undefined))
+    const A = Hash(undefined)
+    const B = Hash(null)
     Assert.NotEqual(A, B)
   })
   it('Should hash symbol 1', () => {
-    Assert.IsEqual('bigint', typeof ValueHash.Hash(Symbol()))
-    const A = ValueHash.Hash(Symbol(1))
-    const B = ValueHash.Hash(Symbol())
+    Assert.IsEqual('bigint', typeof Hash(Symbol()))
+    const A = Hash(Symbol(1))
+    const B = Hash(Symbol())
     Assert.NotEqual(A, B)
   })
   it('Should hash symbol 2', () => {
-    Assert.IsEqual('bigint', typeof ValueHash.Hash(Symbol()))
-    const A = ValueHash.Hash(Symbol(1))
-    const B = ValueHash.Hash(Symbol(2))
+    Assert.IsEqual('bigint', typeof Hash(Symbol()))
+    const A = Hash(Symbol(1))
+    const B = Hash(Symbol(2))
     Assert.NotEqual(A, B)
   })
   it('Should hash symbol 2', () => {
-    Assert.IsEqual('bigint', typeof ValueHash.Hash(Symbol()))
-    const A = ValueHash.Hash(Symbol(1))
-    const B = ValueHash.Hash(Symbol(1))
+    Assert.IsEqual('bigint', typeof Hash(Symbol()))
+    const A = Hash(Symbol(1))
+    const B = Hash(Symbol(1))
     Assert.IsEqual(A, B)
   })
   it('Should hash bigint 1', () => {
-    Assert.IsEqual('bigint', typeof ValueHash.Hash(BigInt(1)))
-    const A = ValueHash.Hash(BigInt(1))
-    const B = ValueHash.Hash(BigInt(2))
+    Assert.IsEqual('bigint', typeof Hash(BigInt(1)))
+    const A = Hash(BigInt(1))
+    const B = Hash(BigInt(2))
     Assert.NotEqual(A, B)
   })
   it('Should hash bigint 2', () => {
-    Assert.IsEqual('bigint', typeof ValueHash.Hash(BigInt(1)))
-    const A = ValueHash.Hash(BigInt(1))
-    const B = ValueHash.Hash(BigInt(1))
+    Assert.IsEqual('bigint', typeof Hash(BigInt(1)))
+    const A = Hash(BigInt(1))
+    const B = Hash(BigInt(1))
     Assert.IsEqual(A, B)
   })
   // ----------------------------------------------------------------
   // Unicode
   // ----------------------------------------------------------------
   it('Should hash unicode 1 (retain single byte hash)', () => {
-    const hash = ValueHash.Hash('a')
+    const hash = Hash('a')
     Assert.IsEqual(hash, 586962220959696054n)
   })
   it('Should hash unicode 2', () => {
-    const hash = ValueHash.Hash('안녕 세계')
+    const hash = Hash('안녕 세계')
     Assert.IsEqual(hash, 11219208047802711777n)
   })
 })
diff --git a/test/runtime/value/index.ts b/test/runtime/value/index.ts
index de126d75d..4e6ce996e 100644
--- a/test/runtime/value/index.ts
+++ b/test/runtime/value/index.ts
@@ -1,8 +1,10 @@
 import './cast'
 import './check'
+import './clean'
 import './clone'
 import './convert'
 import './create'
+import './default'
 import './delta'
 import './equal'
 import './guard'
diff --git a/test/runtime/value/transform/_encoder.ts b/test/runtime/value/transform/_encoder.ts
index 06d82410b..22a2b1d1d 100644
--- a/test/runtime/value/transform/_encoder.ts
+++ b/test/runtime/value/transform/_encoder.ts
@@ -1,4 +1,4 @@
-import { IsAsyncIterator, IsIterator, IsFunction, IsSymbol, IsDate } from '@sinclair/typebox/value/guard'
+import { IsAsyncIterator, IsIterator, IsFunction, IsSymbol, IsDate } from '@sinclair/typebox/value'
 import { TSchema, StaticDecode, StaticEncode } from '@sinclair/typebox'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 import { Value } from '@sinclair/typebox/value'
diff --git a/test/runtime/value/transform/union.ts b/test/runtime/value/transform/union.ts
index 93eeff81c..43152417f 100644
--- a/test/runtime/value/transform/union.ts
+++ b/test/runtime/value/transform/union.ts
@@ -1,7 +1,6 @@
 import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
-import { Value } from '@sinclair/typebox/value'
-import { Type, TSchema } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
 
 describe('value/transform/Union', () => {
   // --------------------------------------------------------
@@ -199,4 +198,44 @@ describe('value/transform/Union', () => {
   it('Should throw on interior union encode', () => {
     Assert.Throws(() => Encoder.Encode(T52, 1))
   })
+  // prettier-ignore
+  { // https://github.com/sinclairzx81/typebox/issues/676
+    // interior-type
+    const S = Type.Transform(Type.String())
+    .Decode((value: string) => new globalThis.Date(value))
+    .Encode((value: Date) => value.toISOString())
+    // union-type
+    const U = Type.Union([
+      Type.Object({ date: S }), 
+      Type.Number()
+    ])
+    // expect date on decode
+    const T1 = Type.Transform(U)
+      .Decode((value) => { 
+        Assert.IsTypeOf(value, 'object')
+        Assert.HasProperty(value, 'date')
+        Assert.IsInstanceOf(value.date, globalThis.Date); 
+        return value 
+      })
+      .Encode((value) => value)
+    // expect number on decode
+    const T2 = Type.Transform(U)
+      .Decode((value) => { 
+        Assert.IsTypeOf(value, 'number')
+        return value 
+      })
+      .Encode((value) => value)
+    
+    it('Should decode interior union 1', () => {
+      const R = Encoder.Decode(T1, { date: new globalThis.Date().toISOString() })
+      Assert.IsTypeOf(R, 'object')
+      Assert.HasProperty(R, 'date')
+      Assert.IsInstanceOf(R.date, globalThis.Date); 
+    })
+    it('Should decode interior union 2', () => {
+      const R = Encoder.Decode(T2, 123)
+      Assert.IsTypeOf(R, 'number')
+      Assert.IsEqual(R, 123)
+    })
+  }
 })
diff --git a/test/static/assert.ts b/test/static/assert.ts
index 9a10c8c07..862731dbf 100644
--- a/test/static/assert.ts
+++ b/test/static/assert.ts
@@ -27,22 +27,24 @@ export type CircularHelper<T, U> = [T] extends U ? T : Expected<T>
 // See https://github.com/Microsoft/TypeScript/issues/27024
 export type ConstrainEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? T : Expected<T>
 export type ConstraintMutuallyExtend<T, U> = CircularHelper<T, [U]>
+
+// Circular Error on TS 5.4.0
 // If U is never, there's nothing we can do
-export type ComplexConstraint<T, U> = If<
-  // If U is any, we can't use Expect<T> or it would satisfy the constraint
-  And<Not<IsAny<T>>, IsAny<U>>,
-  never,
-  If<
-    Or<
-      // If they are both any we are happy
-      And<IsAny<T>, IsAny<U>>,
-      // If T extends U, but not because it's any, we are happy
-      And<Extends<T, U>, Not<IsAny<T>>>
-    >,
-    T,
-    Expected<T>
-  >
->
+// export type ComplexConstraint<T, U> = If<
+//   // If U is any, we can't use Expect<T> or it would satisfy the constraint
+//   And<Not<IsAny<T>>, IsAny<U>>,
+//   never,
+//   If<
+//     Or<
+//       // If they are both any we are happy
+//       And<IsAny<T>, IsAny<U>>,
+//       // If T extends U, but not because it's any, we are happy
+//       And<Extends<T, U>, Not<IsAny<T>>>
+//     >,
+//     T,
+//     Expected<T>
+//   >
+// >
 // ------------------------------------------------------------------
 // Expect
 // ------------------------------------------------------------------
@@ -50,9 +52,12 @@ export type ExpectResult<T extends TSchema> = If<
   IsNever<Static<T>>,
   { ToStaticNever(): void },
   {
-    ToStatic<U extends ComplexConstraint<Static<T>, U>>(): void
-    ToStaticDecode<U extends ComplexConstraint<StaticDecode<T>, U>>(): void
-    ToStaticEncode<U extends ComplexConstraint<StaticEncode<T>, U>>(): void
+    ToStatic<U extends ConstraintMutuallyExtend<Static<T>, U>>(): void
+    ToStaticDecode<U extends ConstraintMutuallyExtend<StaticDecode<T>, U>>(): void
+    ToStaticEncode<U extends ConstraintMutuallyExtend<StaticEncode<T>, U>>(): void
+    // ToStatic<U extends Static<T>>(): void
+    // ToStaticDecode<U extends StaticDecode<T>>(): void
+    // ToStaticEncode<U extends StaticEncode<T>>(): void
   }
 >
 export function Expect<T extends TSchema>(schema: T) {
diff --git a/test/static/const.ts b/test/static/const.ts
new file mode 100644
index 000000000..d81d0fed7
--- /dev/null
+++ b/test/static/const.ts
@@ -0,0 +1,41 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+// ------------------------------------------------------------------
+// Identity Types
+// ------------------------------------------------------------------
+// prettier-ignore
+Expect(Type.Const(undefined)).ToStatic<undefined>()
+// prettier-ignore
+Expect(Type.Const(null)).ToStatic<null>()
+// prettier-ignore
+Expect(Type.Const(Symbol())).ToStatic<symbol>()
+// prettier-ignore
+Expect(Type.Const(1 as const)).ToStatic<1>()
+// prettier-ignore
+Expect(Type.Const('hello' as const)).ToStatic<'hello'>()
+// prettier-ignore
+Expect(Type.Const(true as const)).ToStatic<true>()
+
+// ------------------------------------------------------------------
+// Complex Types
+// ------------------------------------------------------------------
+// prettier-ignore
+Expect(Type.Const(100n)).ToStatic<bigint>()
+// prettier-ignore
+Expect(Type.Const(new Date())).ToStatic<Date>()
+// prettier-ignore
+Expect(Type.Const(new Uint8Array())).ToStatic<Uint8Array>()
+// prettier-ignore
+Expect(Type.Const(function () {})).ToStatic<() => unknown>()
+// prettier-ignore
+Expect(Type.Const((function *(): any {})())).ToStatic<any>()
+// prettier-ignore
+Expect(Type.Const((async function *(): any {})())).ToStatic<any>()
+// todo: remove when dropping TS 4.0
+// prettier-ignore
+Expect(Type.Const({ x: 1, y: { z: 2 } })).ToStatic<{ readonly x: number, readonly y: { readonly z: number }}>()
+// prettier-ignore
+Expect(Type.Const({ x: 1, y: { z: 2 } } as const)).ToStatic<{ readonly x: 1, readonly y: { readonly z: 2 }}>()
+// prettier-ignore
+Expect(Type.Const([1, 2, 3] as const)).ToStatic<[1, 2, 3]>()
diff --git a/test/static/deref.ts b/test/static/deref.ts
new file mode 100644
index 000000000..4df0737ef
--- /dev/null
+++ b/test/static/deref.ts
@@ -0,0 +1,56 @@
+import { Expect } from './assert'
+import { Type, TRef, TObject, TNumber } from '@sinclair/typebox'
+
+// prettier-ignore
+const Vector: TObject<{
+  x: TNumber;
+  y: TNumber;
+}> = Type.Object({
+  x: Type.Number(),
+  y: Type.Number(),
+}, { $id: 'Vector' })
+
+// prettier-ignore
+const VectorRef: TRef<TObject<{
+  x: TNumber;
+  y: TNumber;
+}>> = Type.Ref(Vector)
+
+// prettier-ignore
+const Vertex: TObject<{
+  position: TRef<TObject<{
+      x: TNumber;
+      y: TNumber;
+  }>>;
+  texcoord: TRef<TObject<{
+      x: TNumber;
+      y: TNumber;
+  }>>;
+}> = Type.Object({
+  position: VectorRef,
+  texcoord: VectorRef,
+})
+
+// prettier-ignore
+const VertexDeref: TObject<{
+  position: TObject<{
+      x: TNumber;
+      y: TNumber;
+  }>;
+  texcoord: TObject<{
+      x: TNumber;
+      y: TNumber;
+  }>;
+}> = Type.Deref(Vertex, [Vector])
+
+// prettier-ignore
+Expect(VertexDeref).ToStatic<{
+  position: {
+      x: number;
+      y: number;
+  };
+  texcoord: {
+      x: number;
+      y: number;
+  };
+}>
diff --git a/test/static/index.ts b/test/static/index.ts
index 911f5ec19..df90d857c 100644
--- a/test/static/index.ts
+++ b/test/static/index.ts
@@ -6,9 +6,11 @@ import './bigint'
 import './boolean'
 import './capitalize'
 import './composite'
+import './const'
 import './constructor-parameters'
 import './constructor'
 import './date'
+import './deref'
 import './enum'
 import './extract'
 import './exclude'
@@ -20,6 +22,7 @@ import './iterator'
 import './keyof'
 import './literal'
 import './lowercase'
+import './mapped'
 import './modifier'
 import './namespace'
 import './never'
diff --git a/test/static/indexed.ts b/test/static/indexed.ts
index a33af5130..fe5875b7b 100644
--- a/test/static/indexed.ts
+++ b/test/static/indexed.ts
@@ -54,13 +54,13 @@ import { Type, Static } from '@sinclair/typebox'
   const A = Type.Object({})
   const R = Type.Index(A, Type.BigInt()) // Support Overload
   type O = Static<typeof R>
-  Expect(R).ToStatic<unknown>()
+  Expect(R).ToStaticNever()
 }
 {
   const A = Type.Array(Type.Number())
   const R = Type.Index(A, Type.BigInt()) // Support Overload
   type O = Static<typeof R>
-  Expect(R).ToStatic<unknown>()
+  Expect(R).ToStaticNever()
 }
 // ------------------------------------------------------------------
 // Intersections
@@ -174,6 +174,9 @@ import { Type, Static } from '@sinclair/typebox'
   const D = Type.Object({ x: Type.String() })
   const I = Type.Intersect([Type.Intersect([A, B]), Type.Intersect([C, D])])
   const R = Type.Index(I, ['x', 'y'])
+
+  // TUnion<[TIntersect<[TIntersect<[TString, TNumber]>, TIntersect<[TString, TString]>]>, TIntersect<[TIntersect<[TLiteral<...>, TNumber]>, TNumber]>]>
+  // TUnion<[TUnion<[TString, TNumber, TString, TString]>, TUnion<[TLiteral<1>, TNumber, TNumber]>]>
   type O = Static<typeof R>
   Expect(R).ToStatic<1>()
 }
@@ -191,6 +194,10 @@ import { Type, Static } from '@sinclair/typebox'
   const D = Type.Object({ x: Type.String() })
   const I = Type.Intersect([Type.Union([A, B]), Type.Intersect([C, D])])
   const R = Type.Index(I, ['x', 'y'])
+
+  // TUnion<[TIntersect<[TUnion<[TString, TNumber]>, TIntersect<[TString, TIntersect<[TString, TIntersect<[]>]>, TIntersect<[]>]>]>, TIntersect<...>]>
+  // TUnion<[TIntersect<[TUnion<[TString, TNumber]>, TIntersect<[TString, TString]>]>, TIntersect<[TUnion<[TLiteral<1>, TNumber]>, TNumber]>]>
+  // TUnion<[TIntersect<[TUnion<[TString, TNumber]>, TString, TString]>, TIntersect<[TUnion<[TLiteral<1>, TNumber]>, TNumber]>]>
   type O = Static<typeof R>
   Expect(R).ToStatic<number | string>()
 }
@@ -207,7 +214,7 @@ import { Type, Static } from '@sinclair/typebox'
   const C = Type.Object({ x: Type.Literal('C'), y: Type.Number() })
   const D = Type.Object({ x: Type.Literal('D') })
   const I = Type.Union([A, B, C, D])
-  const R = Type.Index(I, Type.Union([Type.Literal('x')]))
+  const R = Type.Index(I, ['x'])
   type O = Static<typeof R>
   Expect(R).ToStatic<'A' | 'B' | 'C' | 'D'>()
 }
@@ -243,7 +250,7 @@ import { Type, Static } from '@sinclair/typebox'
 }
 {
   const T = Type.Object({
-    0: Type.Number(),
+    '0': Type.Number(),
     '1': Type.String(),
   })
   const R = Type.Index(T, Type.KeyOf(T))
@@ -257,3 +264,13 @@ import { Type, Static } from '@sinclair/typebox'
   })
   Expect(R).ToStatic<{ x: number | string }>()
 }
+{
+  const T = Type.Array(Type.String())
+  const I = Type.Index(T, Type.Number())
+  Expect(I).ToStatic<string>()
+}
+{
+  const T = Type.Array(Type.String())
+  const I = Type.Index(T, ['[number]'])
+  Expect(I).ToStatic<string>()
+}
diff --git a/test/static/mapped.ts b/test/static/mapped.ts
new file mode 100644
index 000000000..9f29b5716
--- /dev/null
+++ b/test/static/mapped.ts
@@ -0,0 +1,404 @@
+import { Expect } from './assert'
+import { Static, Type } from '@sinclair/typebox'
+
+// prettier-ignore
+{ // Generative
+  const A = Type.Mapped(Type.Union([
+    Type.Literal('x'),
+    Type.Literal('y'),
+    Type.Literal('z'),
+  ]), K => Type.Number())
+  Expect(A).ToStatic<{
+    x: number,
+    y: number,
+    z: number
+  }>
+  const B = Type.Mapped(Type.TemplateLiteral('${0|1}${0|1}'), K => Type.Number())
+  Expect(B).ToStatic<{
+    '00': number,
+    '01': number,
+    '10': number,
+    '11': number,
+  }>
+}
+// prettier-ignore
+{ // Generative Nested
+const T = Type.Mapped(Type.TemplateLiteral('${a|b}'), X => 
+  Type.Mapped(Type.TemplateLiteral('${c|d}'), Y => 
+    Type.Mapped(Type.TemplateLiteral('${e|f}'), Z =>
+      Type.Tuple([X, Y, Z])
+    )
+  )
+)
+type E = {
+  [X in `${'a' | 'b'}`]: {
+    [Y in `${'c' | 'd'}`]: {
+      [Z in `${'e' | 'f'}`]: [X, Y, Z]
+    }
+  }
+}
+Expect(T).ToStatic<E> // ok
+}
+// prettier-ignore
+{ // Identity
+  const T = Type.Object({
+    x: Type.Number(),
+    y: Type.String(),
+    z: Type.Boolean()
+  })
+
+  const A = Type.Mapped(Type.KeyOf(T), K => K)
+  Expect(A).ToStatic<{
+    x: 'x',
+    y: 'y',
+    z: 'z'
+  }>()
+
+  const B = Type.Mapped(Type.KeyOf(T), K => Type.Index(T, K))
+  Expect(B).ToStatic<{
+    x: number,
+    y: string,
+    z: boolean
+  }>()
+}
+// prettier-ignore
+{ // Extract
+  const T = Type.Object({
+    x: Type.Union([Type.String(), Type.Number(), Type.Boolean()])
+  })
+  const A = Type.Mapped(Type.KeyOf(T), K => {
+    return Type.Extract(Type.Index(T, K), Type.String())
+  })
+  Expect(A).ToStatic<{
+    x: string
+  }>
+  const B = Type.Mapped(Type.KeyOf(T), K => {
+    return Type.Extract(Type.Index(T, K), Type.Union([
+      Type.String(),
+      Type.Number()
+    ]))
+  })
+  Expect(B).ToStatic<{
+    x: string | number
+  }>
+  const C = Type.Mapped(Type.KeyOf(T), K => {
+    return Type.Extract(Type.Index(T, K), Type.Null())
+  })
+  Expect(C).ToStatic<{ 
+    x: never 
+  }>
+}
+// prettier-ignore
+{ // Numeric Keys
+  const T = Type.Object({
+    0: Type.Number(),
+    1: Type.Number(),
+    2: Type.Number()
+  })
+  const A = Type.Mapped(Type.KeyOf(T), K => Type.Index(T, K))
+  Expect(A).ToStatic<{
+    0: number,
+    1: number,
+    2: number
+  }>
+}
+// prettier-ignore
+{ // Extends
+  const T = Type.Object({
+    x: Type.Number(),
+    y: Type.String(),
+    z: Type.Boolean()
+  })
+  const A = Type.Mapped(Type.KeyOf(T), K => {
+    return ( 
+      Type.Extends(K, Type.Literal('x'), Type.Literal(1), 
+      Type.Extends(K, Type.Literal('y'), Type.Literal(2), 
+      Type.Extends(K, Type.Literal('z'), Type.Literal(3), Type.Never())))
+    )
+  })
+  Expect(A).ToStatic<{
+    x: 1,
+    y: 2,
+    z: 3
+  }>
+  const B = Type.Mapped(Type.KeyOf(T), K => {
+    return ( 
+      Type.Extends(Type.Index(T, K), Type.Number(), Type.Literal(3), 
+      Type.Extends(Type.Index(T, K), Type.String(), Type.Literal(2), 
+      Type.Extends(Type.Index(T, K), Type.Boolean(), Type.Literal(1), Type.Never())))
+    )
+  })
+  Expect(B).ToStatic<{
+    x: 3,
+    y: 2,
+    z: 1
+  }>
+}
+// prettier-ignore
+{ // Exclude
+  const T = Type.Object({
+    x: Type.Union([Type.String(), Type.Number(), Type.Boolean()])
+  })
+  const A = Type.Mapped(Type.KeyOf(T), K => {
+    return Type.Exclude(Type.Index(T, K), Type.String())
+  })
+  Expect(A).ToStatic<{
+    x: number | boolean
+  }>
+  const B = Type.Mapped(Type.KeyOf(T), K => {
+    return Type.Exclude(Type.Index(T, K), Type.Union([
+      Type.String(),
+      Type.Number()
+    ]))
+  })
+  Expect(B).ToStatic<{
+    x: boolean
+  }>
+  const C = Type.Mapped(Type.KeyOf(T), K => {
+    return Type.Exclude(Type.Index(T, K), Type.Null())
+  })
+  Expect(C).ToStatic<{ 
+    x: string | number | boolean 
+  }>
+}
+// prettier-ignore
+{ // Non-Evaluated Indexed
+  const T = Type.Object({
+    x: Type.Number()
+  })
+  const A = Type.Mapped(Type.KeyOf(T), K => Type.Array(Type.Index(T, K)))
+  Expect(A).ToStatic<{ x: number[] }>
+
+  const B = Type.Mapped(Type.KeyOf(T), K => Type.Promise(Type.Index(T, K)))
+  Expect(B).ToStatic<{ x: Promise<number> }>
+
+  const C = Type.Mapped(Type.KeyOf(T), K => Type.Function([Type.Index(T, K)], Type.Index(T, K)))
+  Expect(C).ToStatic<{ x: (x: number) => number }>
+
+  const D = Type.Mapped(Type.KeyOf(T), K => Type.Tuple([Type.Index(T, K), Type.Index(T, K)]))
+  Expect(D).ToStatic<{ x: [number, number] }>
+
+  const E = Type.Mapped(Type.KeyOf(T), K => Type.Union([Type.Index(T, K)]))
+  Expect(E).ToStatic<{ x: number }>
+
+  const F = Type.Mapped(Type.KeyOf(T), K => Type.Intersect([Type.Index(T, K)]))
+  Expect(F).ToStatic<{ x: number }>
+}
+// prettier-ignore
+{ // Modifiers
+  const T = Type.Object({
+    x: Type.Optional(Type.Number()),
+    y: Type.Number()
+  })
+  // Additive
+  const A = Type.Mapped(Type.KeyOf(T), K => Type.Optional(Type.Index(T, K), true))
+  Expect(A).ToStatic<{ x?: number, y?: number}>()
+  // Subtractive
+  const S = Type.Mapped(Type.KeyOf(T), K => Type.Optional(Type.Index(T, K), false))
+  Expect(S).ToStatic<{ x: number, y: number}>()
+}
+// prettier-ignore
+{ // Modifiers
+  const T = Type.Object({
+    x: Type.Readonly(Type.Number()),
+    y: Type.Number()
+  })
+  // Additive
+  const A = Type.Mapped(Type.KeyOf(T), K => Type.Readonly(Type.Index(T, K), true))
+  Expect(A).ToStatic<{ readonly x: number, readonly y: number}>()
+  // Subtractive
+  const S = Type.Mapped(Type.KeyOf(T), K => Type.Readonly(Type.Index(T, K), false))
+  Expect(S).ToStatic<{ x: number, y: number}>()
+}
+// ------------------------------------------------------------------
+// Finite Boolean
+// ------------------------------------------------------------------
+{
+  const T = Type.TemplateLiteral('${boolean}')
+  const M = Type.Mapped(T, (K) => K)
+  Expect(M).ToStatic<{
+    true: 'true'
+    false: 'false'
+  }>
+}
+{
+  const T = Type.TemplateLiteral('${0|1}${boolean}')
+  const M = Type.Mapped(T, (K) => K)
+  Expect(M).ToStatic<{
+    '0true': '0true'
+    '0false': '0false'
+    '1true': '1true'
+    '1false': '1false'
+  }>
+}
+{
+  const T = Type.TemplateLiteral('${boolean}${0|1}')
+  const M = Type.Mapped(T, (K) => K)
+  Expect(M).ToStatic<{
+    true0: 'true0'
+    false0: 'false0'
+    true1: 'true1'
+    false1: 'false1'
+  }>
+}
+{
+  const T = Type.TemplateLiteral([Type.Union([Type.Literal(0), Type.Literal(1)]), Type.Union([Type.Literal(0), Type.Literal(1)])])
+  const M = Type.Mapped(T, (K) => K)
+  Expect(M).ToStatic<{
+    '00': '00'
+    '01': '01'
+    '10': '10'
+    '11': '11'
+  }>
+}
+{
+  const T = Type.Object({
+    hello: Type.Number(),
+    world: Type.String(),
+  })
+  const M = Type.Mapped(Type.Uppercase(Type.KeyOf(T)), (K) => {
+    return Type.Index(T, Type.Lowercase(K))
+  })
+  Expect(M).ToStatic<{
+    HELLO: number
+    WORLD: string
+  }>
+}
+// ------------------------------------------------------------------
+// Interior Partial
+// ------------------------------------------------------------------
+{
+  const T = Type.Object({
+    x: Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    }),
+    y: Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    }),
+  })
+  const M = Type.Mapped(Type.KeyOf(T), (K) => {
+    return Type.Partial(Type.Index(T, K))
+  })
+  Expect(M).ToStatic<{
+    x: { x?: number; y?: number }
+    y: { x?: number; y?: number }
+  }>
+}
+// ------------------------------------------------------------------
+// Interior Required
+// ------------------------------------------------------------------
+{
+  const T = Type.Object({
+    x: Type.Partial(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+    ),
+    y: Type.Partial(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+    ),
+  })
+  const M = Type.Mapped(Type.KeyOf(T), (K) => {
+    return Type.Required(Type.Index(T, K))
+  })
+  Expect(M).ToStatic<{
+    x: { x: number; y: number }
+    y: { x: number; y: number }
+  }>
+}
+// ------------------------------------------------------------------
+// Pick With Key
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const T = Type.Object({
+    x: Type.Object({
+      x: Type.Number(),
+      y: Type.Number()
+    }),
+    y: Type.Object({
+      x: Type.Number(),
+      y: Type.Number()
+    })
+  })
+  const M = Type.Mapped(Type.KeyOf(T), K => {
+    return Type.Pick(T, K)
+  })
+  Expect(M).ToStatic<{
+    x: { x: { x: number; y: number; }; };
+    y: { y: { x: number; y: number; }; };
+  }>
+}
+// ------------------------------------------------------------------
+// Pick With Result
+// ------------------------------------------------------------------
+{
+  const T = Type.Object({
+    x: Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    }),
+    y: Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    }),
+  })
+  const M = Type.Mapped(Type.KeyOf(T), (K) => {
+    return Type.Pick(Type.Index(T, K), ['x'])
+  })
+  Expect(M).ToStatic<{
+    x: { x: number }
+    y: { x: number }
+  }>
+}
+// ------------------------------------------------------------------
+// Omit With Key
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const T = Type.Object({
+    x: Type.Object({
+      x: Type.Number(),
+      y: Type.Number()
+    }),
+    y: Type.Object({
+      x: Type.Number(),
+      y: Type.Number()
+    })
+  })
+  const M = Type.Mapped(Type.KeyOf(T), K => {
+    return Type.Omit(T, K)
+  })
+  Expect(M).ToStatic<{
+    x: { y: { x: number; y: number; }; };
+    y: { x: { x: number; y: number; }; };
+  }>
+}
+// ------------------------------------------------------------------
+// Omit With Result
+// ------------------------------------------------------------------
+{
+  const T = Type.Object({
+    x: Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    }),
+    y: Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    }),
+  })
+  const M = Type.Mapped(Type.KeyOf(T), (K) => {
+    return Type.Omit(Type.Index(T, K), ['x'])
+  })
+  Expect(M).ToStatic<{
+    x: { y: number }
+    y: { y: number }
+  }>
+}
diff --git a/test/static/optional.ts b/test/static/optional.ts
index b3342692a..619930dc5 100644
--- a/test/static/optional.ts
+++ b/test/static/optional.ts
@@ -5,10 +5,45 @@ import { Type, Static } from '@sinclair/typebox'
   const T = Type.Object({
     A: Type.Optional(Type.String()),
   })
+  type T = Static<typeof T>
+
+  Expect(T).ToStatic<{
+    A?: string
+  }>()
+}
+// Noop
+// prettier-ignore
+{
+  const T = Type.Object({
+    A: Type.Optional(Type.String(), false),
+  })
+  type T = Static<typeof T>
 
+  Expect(T).ToStatic<{
+    A: string
+  }>()
+}
+// Additive
+// prettier-ignore
+{
+  const T = Type.Object({
+    A: Type.Optional(Type.String(), true),
+  })
   type T = Static<typeof T>
 
   Expect(T).ToStatic<{
     A?: string
   }>()
 }
+// Subtractive
+// prettier-ignore
+{
+  const T = Type.Object({
+    A: Type.Optional(Type.Optional(Type.String()), false)
+  })
+  type T = Static<typeof T>
+
+  Expect(T).ToStatic<{
+    A: string
+  }>()
+}
diff --git a/test/static/readonly.ts b/test/static/readonly.ts
index 4d1668346..1d6224fc5 100644
--- a/test/static/readonly.ts
+++ b/test/static/readonly.ts
@@ -12,3 +12,39 @@ import { Type, Static } from '@sinclair/typebox'
     readonly A: string
   }>()
 }
+// Noop
+// prettier-ignore
+{
+  const T = Type.Object({
+    A: Type.Readonly(Type.String(), false),
+  })
+  type T = Static<typeof T>
+
+  Expect(T).ToStatic<{
+    A: string
+  }>()
+}
+// Additive
+// prettier-ignore
+{
+  const T = Type.Object({
+    A: Type.Readonly(Type.String(), true),
+  })
+  type T = Static<typeof T>
+
+  Expect(T).ToStatic<{
+    readonly A: string
+  }>()
+}
+// Subtractive
+// prettier-ignore
+{
+  const T = Type.Object({
+    A: Type.Readonly(Type.Readonly(Type.String()), false)
+  })
+  type T = Static<typeof T>
+
+  Expect(T).ToStatic<{
+    A: string
+  }>()
+}
diff --git a/test/static/record.ts b/test/static/record.ts
index e21356595..e284ce053 100644
--- a/test/static/record.ts
+++ b/test/static/record.ts
@@ -20,7 +20,6 @@ import { Type, Static } from '@sinclair/typebox'
   const K = Type.Number()
   const T = Type.Record(K, Type.Number())
   type T = Static<typeof T>
-  Expect(T).ToStatic<Record<string, number>>()
   Expect(T).ToStatic<Record<number, number>>()
 }
 {
@@ -174,5 +173,5 @@ import { Type, Static } from '@sinclair/typebox'
   // expect T to support named properties
   enum E {}
   const T = Type.Record(Type.Enum(E), Type.Number())
-  Expect(T).ToStatic<{}>
+  Expect(T).ToStatic<{ [x: string]: number }>
 }
diff --git a/test/static/template-literal.ts b/test/static/template-literal.ts
index f0ec8444e..670b0b694 100644
--- a/test/static/template-literal.ts
+++ b/test/static/template-literal.ts
@@ -27,6 +27,13 @@ import { Type } from '@sinclair/typebox'
   const T = Type.TemplateLiteral([Type.Literal('hello'), A])
   Expect(T).ToStatic<'hello1' | 'hello2'>()
 }
+{
+  // TemplateLiteral Composition
+  const A = Type.TemplateLiteral('${A|B}')
+  const B = Type.TemplateLiteral('${C|D}')
+  const T = Type.TemplateLiteral([A, B])
+  Expect(T).ToStatic<'AC' | 'AD' | 'BC' | 'BD'>()
+}
 {
   // String
   const T = Type.TemplateLiteral([Type.String()])
diff --git a/test/static/transform.ts b/test/static/transform.ts
index 917628a67..1f4176289 100644
--- a/test/static/transform.ts
+++ b/test/static/transform.ts
@@ -215,12 +215,12 @@ import { Expect } from './assert'
   // should decode within generic function context
   // https://github.com/sinclairzx81/typebox/issues/554
   // prettier-ignore
-  const ArrayOrSingle = <T extends TSchema>(schema: T) =>
-    Type.Transform(Type.Union([schema, Type.Array(schema)]))
-      .Decode((value) => (Array.isArray(value) ? value : [value]))
-      .Encode((value) => (value.length === 1 ? value[0] : value) as Static<T>[]);
-  const T = ArrayOrSingle(Type.String())
-  Expect(T).ToStaticDecode<string[]>()
+  // const ArrayOrSingle = <T extends TSchema>(schema: T) =>
+  //   Type.Transform(Type.Union([schema, Type.Array(schema)])[0])
+  //     .Decode((value) => (Array.isArray(value) ? value : [value]))
+  //     .Encode((value) => (value.length === 1 ? value[0] : value) as Static<T>[]);
+  // const T = ArrayOrSingle(Type.String())
+  // Expect(T).ToStaticDecode<string[]>()
 }
 {
   // should correctly decode record keys
diff --git a/test/static/union.ts b/test/static/union.ts
index 9c9895ee0..3decc9e08 100644
--- a/test/static/union.ts
+++ b/test/static/union.ts
@@ -71,3 +71,36 @@ import { Type, Static } from '@sinclair/typebox'
   const T = Type.Union([])
   Expect(T).ToStaticNever()
 }
+// prettier-ignore
+{ // Scalable Union
+  const X = Type.Object({ x: Type.Number() })
+  const Y = Type.Object({ y: Type.Number() })
+  const Z = Type.Object({ z: Type.Number() })
+  const W = Type.Object({ w: Type.Number() })
+
+  const T = Type.Union([
+    X, Y, Z, W, X, Y, Z, W,
+    X, Y, Z, W, X, Y, Z, W,
+    X, Y, Z, W, X, Y, Z, W,
+    X, Y, Z, W, X, Y, Z, W,
+    X, Y, Z, W, X, Y, Z, W,
+    X, Y, Z, W, X, Y, Z, W,
+    X, Y, Z, W, X, Y, Z, W,
+    X, Y, Z, W, X, Y, Z, W,
+
+    X, Y, Z, W, X, Y, Z, W,
+    X, Y, Z, W, X, Y, Z, W,
+    X, Y, Z, W, X, Y, Z, W,
+    X, Y, Z, W, X, Y, Z, W,
+    X, Y, Z, W, X, Y, Z, W,
+    X, Y, Z, W, X, Y, Z, W,
+    X, Y, Z, W, X, Y, Z, W,
+    X, Y, Z, W, X, Y, Z, W,
+  ])
+  Expect(T).ToStatic<
+    { x: number } | 
+    { y: number } | 
+    { z: number } | 
+    { w: number }
+  >()
+}
diff --git a/tsconfig.json b/tsconfig.json
index ec148af39..6a47a31ec 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,63 +1,17 @@
 {
   "compilerOptions": {
     "strict": true,
-    "target": "ES2020",
-    "module": "CommonJS",
-    "moduleResolution": "node",
-    "declaration": true,
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Node",
     "baseUrl": ".",
     "paths": {
-      "@sinclair/typebox/compiler": [
-        "src/compiler/index.ts"
-      ],
-      "@sinclair/typebox/errors": [
-        "src/errors/index.ts"
-      ],
-      "@sinclair/typebox/system": [
-        "src/system/index.ts"
-      ],
-      "@sinclair/typebox/value/cast": [
-        "src/value/cast.ts"
-      ],
-      "@sinclair/typebox/value/check": [
-        "src/value/check.ts"
-      ],
-      "@sinclair/typebox/value/clone": [
-        "src/value/clone.ts"
-      ],
-      "@sinclair/typebox/value/convert": [
-        "src/value/convert.ts"
-      ],
-      "@sinclair/typebox/value/create": [
-        "src/value/create.ts"
-      ],
-      "@sinclair/typebox/value/delta": [
-        "src/value/delta.ts"
-      ],
-      "@sinclair/typebox/value/equal": [
-        "src/value/equal.ts"
-      ],
-      "@sinclair/typebox/value/guard": [
-        "src/value/guard.ts"
-      ],
-      "@sinclair/typebox/value/hash": [
-        "src/value/hash.ts"
-      ],
-      "@sinclair/typebox/value/mutate": [
-        "src/value/mutate.ts"
-      ],
-      "@sinclair/typebox/value/pointer": [
-        "src/value/pointer.ts"
-      ],
-      "@sinclair/typebox/value/transform": [
-        "src/value/transform/index.ts"
-      ],
-      "@sinclair/typebox/value": [
-        "src/value/index.ts"
-      ],
-      "@sinclair/typebox": [
-        "src/typebox.ts"
-      ],
+      "@sinclair/typebox/compiler": ["src/compiler/index.ts"],
+      "@sinclair/typebox/errors": ["src/errors/index.ts"],
+      "@sinclair/typebox/system": ["src/system/index.ts"],
+      "@sinclair/typebox/type": ["src/type/index.ts"],
+      "@sinclair/typebox/value": ["src/value/index.ts"],
+      "@sinclair/typebox": ["src/index.ts"],
     }
   }
 }
\ No newline at end of file

From ca4d771b87ee1f8e953036c95a21da7150786d3e Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 23 Dec 2023 13:42:12 +0900
Subject: [PATCH 217/369] Revision 0.32.1 (#701)

* Ensure Package Specifies Default Import as Last Key

* TypeScript 5.3.3
---
 package-lock.json                          | 39 +++++++++++++++++-----
 package.json                               |  4 +--
 task/build/redirect/create-package-json.ts | 14 ++++----
 3 files changed, 40 insertions(+), 17 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 6ce4d3fae..f5cea1b24 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.0",
+  "version": "0.32.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.0",
+      "version": "0.32.1",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
@@ -17,7 +17,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^9.2.2",
         "prettier": "^2.7.1",
-        "typescript": "^5.3.2"
+        "typescript": "^5.3.3"
       }
     },
     "node_modules/@andrewbranch/untar.js": {
@@ -63,6 +63,19 @@
         "node": ">=18"
       }
     },
+    "node_modules/@arethetypeswrong/core/node_modules/typescript": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.2.tgz",
+      "integrity": "sha512-6l+RyNy7oAHDfxC4FzSJcz9vnjTKxrLpDG5M2Vu4SHRVNg6xzqZp6LYSR9zjqQTu8DU/f5xwxUdADOkbrIX2gQ==",
+      "dev": true,
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
     "node_modules/@colors/colors": {
       "version": "1.5.0",
       "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.5.0.tgz",
@@ -1631,9 +1644,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.2.tgz",
-      "integrity": "sha512-6l+RyNy7oAHDfxC4FzSJcz9vnjTKxrLpDG5M2Vu4SHRVNg6xzqZp6LYSR9zjqQTu8DU/f5xwxUdADOkbrIX2gQ==",
+      "version": "5.3.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.3.tgz",
+      "integrity": "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -1826,6 +1839,14 @@
         "semver": "^7.5.4",
         "typescript": "5.3.2",
         "validate-npm-package-name": "^5.0.0"
+      },
+      "dependencies": {
+        "typescript": {
+          "version": "5.3.2",
+          "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.2.tgz",
+          "integrity": "sha512-6l+RyNy7oAHDfxC4FzSJcz9vnjTKxrLpDG5M2Vu4SHRVNg6xzqZp6LYSR9zjqQTu8DU/f5xwxUdADOkbrIX2gQ==",
+          "dev": true
+        }
       }
     },
     "@colors/colors": {
@@ -2853,9 +2874,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.2.tgz",
-      "integrity": "sha512-6l+RyNy7oAHDfxC4FzSJcz9vnjTKxrLpDG5M2Vu4SHRVNg6xzqZp6LYSR9zjqQTu8DU/f5xwxUdADOkbrIX2gQ==",
+      "version": "5.3.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.3.tgz",
+      "integrity": "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==",
       "dev": true
     },
     "undici-types": {
diff --git a/package.json b/package.json
index 342d3bc79..2f9b49118 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.0",
+  "version": "0.32.1",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -37,6 +37,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^5.3.2"
+    "typescript": "^5.3.3"
   }
 }
diff --git a/task/build/redirect/create-package-json.ts b/task/build/redirect/create-package-json.ts
index 5b36ce927..068041c5a 100644
--- a/task/build/redirect/create-package-json.ts
+++ b/task/build/redirect/create-package-json.ts
@@ -48,12 +48,13 @@ function resolvePackageJson(submodules: string[]) {
 function resolveSubmoduleExports(submodule: string) {
   return {
     require: {
+      types: `./build/require/${submodule}/index.d.ts`,
       default: `./build/require/${submodule}/index.js`,
-      types: `./build/require/${submodule}/index.d.ts`
     },
     import: {
-      default: `./build/import/${submodule}/index.mjs`,
       types: `./build/import/${submodule}/index.d.mts`,
+      default: `./build/import/${submodule}/index.mjs`,
+      
     }
   }
 }
@@ -65,12 +66,13 @@ function resolveExports(submodules: string[]) {
     // ... and root module
     ".": {
       "require": {
+        "types": "./build/require/index.d.ts",
         "default": "./build/require/index.js",
-        "types": "./build/require/index.d.ts"
+        
       },
       "import": {
+        "types": "./build/import/index.d.mts",
         "default": "./build/import/index.mjs",
-        "types": "./build/import/index.d.mts"
       }
     }
   })
@@ -89,8 +91,8 @@ function resolveMetadata() {
     license: packageJson.license,
     repository: packageJson.repository,
     scripts: { test: 'echo test' }, // flagged by socket.dev
-    module: "./build/import/index.mjs",
     types: "./build/require/index.d.ts",
-    main: "./build/require/index.js"
+    main: "./build/require/index.js",
+    module: "./build/import/index.mjs",
   }
 }

From d0c9840157896888119a85cd7b87a4838a26f3b3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=BDiga=20Strgar?= <ZigaStrgar@users.noreply.github.com>
Date: Sun, 24 Dec 2023 13:06:59 +0100
Subject: [PATCH 218/369] Export TLiteralValue (#702)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Žiga Strgar <ziga.strgar@gmail.com>
---
 src/index.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/index.ts b/src/index.ts
index 6c243906b..fbf63ae51 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -63,7 +63,7 @@ export { Intersect, IntersectEvaluated, type TIntersect, type TIntersectEvaluate
 export { Iterator, type TIterator } from './type/iterator/index'
 export { Intrinsic, IntrinsicFromMappedKey, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index'
 export { KeyOf, type TKeyOf, type KeyOfFromMappedResult, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index'
-export { Literal, type TLiteral } from './type/literal/index'
+export { Literal, type TLiteral, type TLiteralValue } from './type/literal/index'
 export { Mapped, MappedKey, MappedResult, type TMapped, type TMappedKey, type TMappedResult, type TMappedFunction } from './type/mapped/index'
 export { Never, type TNever } from './type/never/index'
 export { Not, type TNot } from './type/not/index'

From 64c1e16d924d448a535693869fcc313bb96e3713 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sun, 24 Dec 2023 21:14:02 +0900
Subject: [PATCH 219/369] Revision 0.32.2

---
 package-lock.json | 4 ++--
 package.json      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index f5cea1b24..4c2d79a0a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.1",
+  "version": "0.32.2",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.1",
+      "version": "0.32.2",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 2f9b49118..73e35ab0d 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.1",
+  "version": "0.32.2",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

From 483040c3bfd69041715cce066ed015c4b1efa45d Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 25 Dec 2023 00:09:12 +0900
Subject: [PATCH 220/369] Revision 0.32.3 (#703)

* Evaluate Inferred Record Type

* Version
---
 package-lock.json         | 4 ++--
 package.json              | 2 +-
 src/type/record/record.ts | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 4c2d79a0a..1b0be7a86 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.2",
+  "version": "0.32.3",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.2",
+      "version": "0.32.3",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 73e35ab0d..5c4cd123d 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.2",
+  "version": "0.32.3",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/record/record.ts b/src/type/record/record.ts
index ec724bd30..042d4b5d6 100644
--- a/src/type/record/record.ts
+++ b/src/type/record/record.ts
@@ -181,7 +181,7 @@ function FromNumberKey<K extends TNumber, T extends TSchema>(_: K, T: T, options
 // ------------------------------------------------------------------
 // prettier-ignore
 type RecordStatic<K extends TSchema, T extends TSchema, P extends unknown[]> = (
-  Record<Assert<Static<K>, PropertyKey>, Static<T, P>>
+  Evaluate<Record<Assert<Static<K>, PropertyKey>, Static<T, P>>>
 )
 // prettier-ignore
 export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {

From 0a988cdb6c6422b78a05c5cca1dd1315faa35110 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 29 Dec 2023 12:39:52 +0900
Subject: [PATCH 221/369] Revision 0.32.4 (#708)

* Export ErrorFunctionParameter

* Revision
---
 package-lock.json   | 4 ++--
 package.json        | 2 +-
 src/errors/index.ts | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 1b0be7a86..4c2b4a5e4 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.3",
+  "version": "0.32.4",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.3",
+      "version": "0.32.4",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 5c4cd123d..6f84b9e31 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.3",
+  "version": "0.32.4",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/errors/index.ts b/src/errors/index.ts
index b5a10ef10..2c0c08936 100644
--- a/src/errors/index.ts
+++ b/src/errors/index.ts
@@ -27,4 +27,4 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 export { Errors, ValueError, ValueErrorIterator, ValueErrorType, ValueErrorsUnknownTypeError } from './errors'
-export { DefaultErrorFunction, GetErrorFunction, SetErrorFunction, type ErrorFunction } from './function'
+export { DefaultErrorFunction, GetErrorFunction, SetErrorFunction, type ErrorFunction, type ErrorFunctionParameter } from './function'

From 01ea89e324eb6d100a237cfeafdf2b2d37d709e3 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 5 Jan 2024 12:34:07 +0900
Subject: [PATCH 222/369] Resolve Overload for Value Clean (#717)

---
 src/value/clean/clean.ts     |  4 ++--
 src/value/convert/convert.ts |  4 ++--
 src/value/default/default.ts |  4 ++--
 src/value/value/value.ts     | 12 ++++++------
 4 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/value/clean/clean.ts b/src/value/clean/clean.ts
index 29c52d32d..0d0f20fa7 100644
--- a/src/value/clean/clean.ts
+++ b/src/value/clean/clean.ts
@@ -175,9 +175,9 @@ function Visit(schema: TSchema, references: TSchema[], value: unknown): unknown
 // Clean
 // ------------------------------------------------------------------
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export function Clean<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown
+export function Clean(schema: TSchema, references: TSchema[], value: unknown): unknown
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export function Clean<T extends TSchema>(schema: T): unknown
+export function Clean(schema: TSchema, value: unknown): unknown
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
 export function Clean(...args: any[]) {
   return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1])
diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index 8a0de37b2..4360e4fbb 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -299,9 +299,9 @@ function Visit(schema: TSchema, references: TSchema[], value: any): unknown {
 // Convert
 // ------------------------------------------------------------------
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
-export function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown
+export function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
-export function Convert<T extends TSchema>(schema: T, value: unknown): unknown
+export function Convert(schema: TSchema, value: unknown): unknown
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 // prettier-ignore
 export function Convert(...args: any[]) {
diff --git a/src/value/default/default.ts b/src/value/default/default.ts
index 6a310d259..a089f7600 100644
--- a/src/value/default/default.ts
+++ b/src/value/default/default.ts
@@ -176,9 +176,9 @@ function Visit(schema: TSchema, references: TSchema[], value: unknown): any {
 // Default
 // ------------------------------------------------------------------
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export function Default<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown
+export function Default(schema: TSchema, references: TSchema[], value: unknown): unknown
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export function Default<T extends TSchema>(schema: T, value: unknown): unknown
+export function Default(schema: TSchema, value: unknown): unknown
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export function Default(...args: any[]) {
   return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1])
diff --git a/src/value/value/value.ts b/src/value/value/value.ts
index 6be317787..62a0f04d1 100644
--- a/src/value/value/value.ts
+++ b/src/value/value/value.ts
@@ -68,17 +68,17 @@ export function Check(...args: any[]) {
   return CheckValue.apply(CheckValue, args as any)
 }
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export function Clean<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown
+export function Clean(schema: TSchema, references: TSchema[], value: unknown): unknown
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export function Clean<T extends TSchema>(schema: T, value: unknown): unknown
+export function Clean(schema: TSchema, value: unknown): unknown
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
 export function Clean(...args: any[]) {
   return CleanValue.apply(CleanValue, args as any)
 }
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible */
-export function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown
+export function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown
 /** Converts any type mismatched values to their target type if a reasonable conversion is possibl. */
-export function Convert<T extends TSchema>(schema: T, value: unknown): unknown
+export function Convert(schema: TSchema, value: unknown): unknown
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible */
 export function Convert(...args: any[]) {
   return ConvertValue.apply(ConvertValue, args as any)
@@ -98,9 +98,9 @@ export function Decode(...args: any[]) {
   return TransformDecode(schema, references, value)
 }
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export function Default<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown
+export function Default(schema: TSchema, references: TSchema[], value: unknown): unknown
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export function Default<T extends TSchema>(schema: T, value: unknown): unknown
+export function Default(schema: TSchema, value: unknown): unknown
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export function Default(...args: any[]) {
   return DefaultValue.apply(DefaultValue, args as any)

From 767ff8726ef87eb6340565934e4dec365e1f8003 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 5 Jan 2024 12:47:20 +0900
Subject: [PATCH 223/369] Revision 0.32.5 (#718)

---
 example/annotation/annotation.ts                          | 2 +-
 example/collections/array.ts                              | 2 +-
 example/collections/index.ts                              | 2 +-
 example/collections/map.ts                                | 2 +-
 example/collections/set.ts                                | 2 +-
 example/formats/index.ts                                  | 2 +-
 example/prototypes/evaluate.ts                            | 2 +-
 example/prototypes/index.ts                               | 2 +-
 example/prototypes/partial-deep.ts                        | 2 +-
 example/prototypes/union-enum.ts                          | 2 +-
 example/prototypes/union-oneof.ts                         | 2 +-
 example/typedef/index.ts                                  | 2 +-
 example/typedef/typedef.ts                                | 2 +-
 license                                                   | 2 +-
 package-lock.json                                         | 4 ++--
 package.json                                              | 2 +-
 src/compiler/compiler.ts                                  | 2 +-
 src/compiler/index.ts                                     | 2 +-
 src/errors/errors.ts                                      | 2 +-
 src/errors/function.ts                                    | 2 +-
 src/errors/index.ts                                       | 2 +-
 src/index.ts                                              | 2 +-
 src/system/index.ts                                       | 2 +-
 src/system/policy.ts                                      | 2 +-
 src/system/system.ts                                      | 2 +-
 src/type/any/any.ts                                       | 2 +-
 src/type/any/index.ts                                     | 2 +-
 src/type/array/array.ts                                   | 2 +-
 src/type/array/index.ts                                   | 2 +-
 src/type/async-iterator/async-iterator.ts                 | 2 +-
 src/type/async-iterator/index.ts                          | 2 +-
 src/type/awaited/awaited.ts                               | 2 +-
 src/type/awaited/index.ts                                 | 2 +-
 src/type/bigint/bigint.ts                                 | 2 +-
 src/type/bigint/index.ts                                  | 2 +-
 src/type/boolean/boolean.ts                               | 2 +-
 src/type/boolean/index.ts                                 | 2 +-
 src/type/clone/index.ts                                   | 2 +-
 src/type/clone/type.ts                                    | 2 +-
 src/type/clone/value.ts                                   | 2 +-
 src/type/composite/composite.ts                           | 2 +-
 src/type/composite/index.ts                               | 2 +-
 src/type/const/const.ts                                   | 2 +-
 src/type/const/index.ts                                   | 2 +-
 src/type/constructor-parameters/constructor-parameters.ts | 2 +-
 src/type/constructor-parameters/index.ts                  | 2 +-
 src/type/constructor/constructor.ts                       | 2 +-
 src/type/constructor/index.ts                             | 2 +-
 src/type/date/date.ts                                     | 2 +-
 src/type/date/index.ts                                    | 2 +-
 src/type/deref/deref.ts                                   | 2 +-
 src/type/deref/index.ts                                   | 2 +-
 src/type/discard/discard.ts                               | 2 +-
 src/type/discard/index.ts                                 | 2 +-
 src/type/enum/enum.ts                                     | 2 +-
 src/type/enum/index.ts                                    | 2 +-
 src/type/error/error.ts                                   | 2 +-
 src/type/error/index.ts                                   | 2 +-
 src/type/exclude/exclude-from-mapped-result.ts            | 2 +-
 src/type/exclude/exclude.ts                               | 2 +-
 src/type/exclude/index.ts                                 | 2 +-
 src/type/extends/extends-check.ts                         | 2 +-
 src/type/extends/extends-from-mapped-key.ts               | 2 +-
 src/type/extends/extends-from-mapped-result.ts            | 2 +-
 src/type/extends/extends-undefined.ts                     | 2 +-
 src/type/extends/extends.ts                               | 2 +-
 src/type/extends/index.ts                                 | 2 +-
 src/type/extract/extract-from-mapped-result.ts            | 2 +-
 src/type/extract/extract.ts                               | 2 +-
 src/type/extract/index.ts                                 | 2 +-
 src/type/function/function.ts                             | 2 +-
 src/type/function/index.ts                                | 2 +-
 src/type/guard/index.ts                                   | 2 +-
 src/type/guard/type.ts                                    | 2 +-
 src/type/guard/value.ts                                   | 2 +-
 src/type/helpers/helpers.ts                               | 2 +-
 src/type/helpers/index.ts                                 | 2 +-
 src/type/index.ts                                         | 2 +-
 src/type/indexed/index.ts                                 | 2 +-
 src/type/indexed/indexed-from-mapped-key.ts               | 2 +-
 src/type/indexed/indexed-from-mapped-result.ts            | 2 +-
 src/type/indexed/indexed-property-keys.ts                 | 2 +-
 src/type/indexed/indexed.ts                               | 2 +-
 src/type/instance-type/index.ts                           | 2 +-
 src/type/instance-type/instance-type.ts                   | 2 +-
 src/type/integer/index.ts                                 | 2 +-
 src/type/integer/integer.ts                               | 2 +-
 src/type/intersect/index.ts                               | 2 +-
 src/type/intersect/intersect-create.ts                    | 2 +-
 src/type/intersect/intersect-evaluated.ts                 | 2 +-
 src/type/intersect/intersect-type.ts                      | 2 +-
 src/type/intersect/intersect.ts                           | 2 +-
 src/type/intrinsic/capitalize.ts                          | 2 +-
 src/type/intrinsic/index.ts                               | 2 +-
 src/type/intrinsic/intrinsic-from-mapped-key.ts           | 2 +-
 src/type/intrinsic/intrinsic.ts                           | 2 +-
 src/type/intrinsic/lowercase.ts                           | 2 +-
 src/type/intrinsic/uncapitalize.ts                        | 2 +-
 src/type/intrinsic/uppercase.ts                           | 2 +-
 src/type/iterator/index.ts                                | 2 +-
 src/type/iterator/iterator.ts                             | 2 +-
 src/type/keyof/index.ts                                   | 2 +-
 src/type/keyof/keyof-from-mapped-result.ts                | 2 +-
 src/type/keyof/keyof-property-keys.ts                     | 2 +-
 src/type/keyof/keyof.ts                                   | 2 +-
 src/type/literal/index.ts                                 | 2 +-
 src/type/literal/literal.ts                               | 2 +-
 src/type/mapped/index.ts                                  | 2 +-
 src/type/mapped/mapped-key.ts                             | 2 +-
 src/type/mapped/mapped-result.ts                          | 2 +-
 src/type/mapped/mapped.ts                                 | 2 +-
 src/type/never/index.ts                                   | 2 +-
 src/type/never/never.ts                                   | 2 +-
 src/type/not/index.ts                                     | 2 +-
 src/type/not/not.ts                                       | 2 +-
 src/type/null/index.ts                                    | 2 +-
 src/type/null/null.ts                                     | 2 +-
 src/type/number/index.ts                                  | 2 +-
 src/type/number/number.ts                                 | 2 +-
 src/type/object/index.ts                                  | 2 +-
 src/type/object/object.ts                                 | 2 +-
 src/type/omit/index.ts                                    | 2 +-
 src/type/omit/omit-from-mapped-key.ts                     | 2 +-
 src/type/omit/omit-from-mapped-result.ts                  | 2 +-
 src/type/omit/omit.ts                                     | 2 +-
 src/type/optional/index.ts                                | 2 +-
 src/type/optional/optional-from-mapped-result.ts          | 2 +-
 src/type/optional/optional.ts                             | 2 +-
 src/type/parameters/index.ts                              | 2 +-
 src/type/parameters/parameters.ts                         | 2 +-
 src/type/partial/index.ts                                 | 2 +-
 src/type/partial/partial-from-mapped-result.ts            | 2 +-
 src/type/partial/partial.ts                               | 2 +-
 src/type/patterns/index.ts                                | 2 +-
 src/type/patterns/patterns.ts                             | 2 +-
 src/type/pick/index.ts                                    | 2 +-
 src/type/pick/pick-from-mapped-key.ts                     | 2 +-
 src/type/pick/pick-from-mapped-result.ts                  | 2 +-
 src/type/pick/pick.ts                                     | 2 +-
 src/type/promise/index.ts                                 | 2 +-
 src/type/promise/promise.ts                               | 2 +-
 src/type/readonly-optional/index.ts                       | 2 +-
 src/type/readonly-optional/readonly-optional.ts           | 2 +-
 src/type/readonly/index.ts                                | 2 +-
 src/type/readonly/readonly-from-mapped-result.ts          | 2 +-
 src/type/readonly/readonly.ts                             | 2 +-
 src/type/record/index.ts                                  | 2 +-
 src/type/record/record.ts                                 | 2 +-
 src/type/recursive/index.ts                               | 2 +-
 src/type/recursive/recursive.ts                           | 2 +-
 src/type/ref/index.ts                                     | 2 +-
 src/type/ref/ref.ts                                       | 2 +-
 src/type/regexp/index.ts                                  | 2 +-
 src/type/regexp/regexp.ts                                 | 2 +-
 src/type/registry/format.ts                               | 2 +-
 src/type/registry/index.ts                                | 2 +-
 src/type/registry/type.ts                                 | 2 +-
 src/type/required/index.ts                                | 2 +-
 src/type/required/required-from-mapped-result.ts          | 2 +-
 src/type/required/required.ts                             | 2 +-
 src/type/rest/index.ts                                    | 2 +-
 src/type/rest/rest.ts                                     | 2 +-
 src/type/return-type/index.ts                             | 2 +-
 src/type/return-type/return-type.ts                       | 2 +-
 src/type/schema/anyschema.ts                              | 2 +-
 src/type/schema/index.ts                                  | 2 +-
 src/type/schema/schema.ts                                 | 2 +-
 src/type/sets/index.ts                                    | 2 +-
 src/type/sets/set.ts                                      | 2 +-
 src/type/static/index.ts                                  | 2 +-
 src/type/static/static.ts                                 | 2 +-
 src/type/strict/index.ts                                  | 2 +-
 src/type/strict/strict.ts                                 | 2 +-
 src/type/string/index.ts                                  | 2 +-
 src/type/string/string.ts                                 | 2 +-
 src/type/symbol/index.ts                                  | 2 +-
 src/type/symbol/symbol.ts                                 | 2 +-
 src/type/symbols/index.ts                                 | 2 +-
 src/type/symbols/symbols.ts                               | 2 +-
 src/type/template-literal/finite.ts                       | 2 +-
 src/type/template-literal/generate.ts                     | 2 +-
 src/type/template-literal/index.ts                        | 2 +-
 src/type/template-literal/parse.ts                        | 2 +-
 src/type/template-literal/pattern.ts                      | 2 +-
 src/type/template-literal/syntax.ts                       | 2 +-
 src/type/template-literal/template-literal.ts             | 2 +-
 src/type/template-literal/union.ts                        | 2 +-
 src/type/transform/index.ts                               | 2 +-
 src/type/transform/transform.ts                           | 2 +-
 src/type/tuple/index.ts                                   | 2 +-
 src/type/tuple/tuple.ts                                   | 2 +-
 src/type/type/index.ts                                    | 2 +-
 src/type/type/javascript.ts                               | 2 +-
 src/type/type/json.ts                                     | 2 +-
 src/type/type/type.ts                                     | 2 +-
 src/type/uint8array/index.ts                              | 2 +-
 src/type/uint8array/uint8array.ts                         | 2 +-
 src/type/undefined/index.ts                               | 2 +-
 src/type/undefined/undefined.ts                           | 2 +-
 src/type/union/index.ts                                   | 2 +-
 src/type/union/union-create.ts                            | 2 +-
 src/type/union/union-evaluated.ts                         | 2 +-
 src/type/union/union-type.ts                              | 2 +-
 src/type/union/union.ts                                   | 2 +-
 src/type/unknown/index.ts                                 | 2 +-
 src/type/unknown/unknown.ts                               | 2 +-
 src/type/unsafe/index.ts                                  | 2 +-
 src/type/unsafe/unsafe.ts                                 | 2 +-
 src/type/void/index.ts                                    | 2 +-
 src/type/void/void.ts                                     | 2 +-
 src/value/cast/cast.ts                                    | 2 +-
 src/value/cast/index.ts                                   | 2 +-
 src/value/check/check.ts                                  | 2 +-
 src/value/check/index.ts                                  | 2 +-
 src/value/clean/clean.ts                                  | 2 +-
 src/value/clean/index.ts                                  | 2 +-
 src/value/clone/clone.ts                                  | 2 +-
 src/value/clone/index.ts                                  | 2 +-
 src/value/convert/convert.ts                              | 2 +-
 src/value/convert/index.ts                                | 2 +-
 src/value/create/create.ts                                | 2 +-
 src/value/create/index.ts                                 | 2 +-
 src/value/default/default.ts                              | 2 +-
 src/value/default/index.ts                                | 2 +-
 src/value/delta/delta.ts                                  | 2 +-
 src/value/delta/index.ts                                  | 2 +-
 src/value/deref/deref.ts                                  | 2 +-
 src/value/deref/index.ts                                  | 2 +-
 src/value/equal/equal.ts                                  | 2 +-
 src/value/equal/index.ts                                  | 2 +-
 src/value/guard/guard.ts                                  | 2 +-
 src/value/guard/index.ts                                  | 2 +-
 src/value/hash/hash.ts                                    | 2 +-
 src/value/hash/index.ts                                   | 2 +-
 src/value/index.ts                                        | 2 +-
 src/value/mutate/index.ts                                 | 2 +-
 src/value/mutate/mutate.ts                                | 2 +-
 src/value/pointer/index.ts                                | 2 +-
 src/value/pointer/pointer.ts                              | 2 +-
 src/value/transform/decode.ts                             | 2 +-
 src/value/transform/encode.ts                             | 2 +-
 src/value/transform/has.ts                                | 2 +-
 src/value/transform/index.ts                              | 2 +-
 src/value/value/index.ts                                  | 2 +-
 src/value/value/value.ts                                  | 2 +-
 task/build/common/remove-notices.ts                       | 2 +-
 task/build/import/build.ts                                | 2 +-
 task/build/import/compile.ts                              | 2 +-
 task/build/import/convert-to-esm.ts                       | 2 +-
 task/build/index.ts                                       | 2 +-
 task/build/redirect/build.ts                              | 2 +-
 task/build/redirect/create-package-json.ts                | 2 +-
 task/build/redirect/create-redirect-paths.ts              | 2 +-
 task/build/require/build.ts                               | 2 +-
 task/build/require/compile.ts                             | 2 +-
 255 files changed, 256 insertions(+), 256 deletions(-)

diff --git a/example/annotation/annotation.ts b/example/annotation/annotation.ts
index 26bebaf0d..9e38f70b6 100644
--- a/example/annotation/annotation.ts
+++ b/example/annotation/annotation.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/collections/array.ts b/example/collections/array.ts
index 90f5d73b4..be13f9284 100644
--- a/example/collections/array.ts
+++ b/example/collections/array.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/collections/index.ts b/example/collections/index.ts
index 49183354a..6069c8c37 100644
--- a/example/collections/index.ts
+++ b/example/collections/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/collections/map.ts b/example/collections/map.ts
index 796140fe6..47957795b 100644
--- a/example/collections/map.ts
+++ b/example/collections/map.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/collections/set.ts b/example/collections/set.ts
index 8cf312a3e..730583ae3 100644
--- a/example/collections/set.ts
+++ b/example/collections/set.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/formats/index.ts b/example/formats/index.ts
index 0b20821fe..2ac3f6f51 100644
--- a/example/formats/index.ts
+++ b/example/formats/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/prototypes/evaluate.ts b/example/prototypes/evaluate.ts
index 530972fa7..460d86773 100644
--- a/example/prototypes/evaluate.ts
+++ b/example/prototypes/evaluate.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/prototypes/index.ts b/example/prototypes/index.ts
index 4a70931c8..c0011265b 100644
--- a/example/prototypes/index.ts
+++ b/example/prototypes/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/prototypes/partial-deep.ts b/example/prototypes/partial-deep.ts
index c0896186c..7ee36f445 100644
--- a/example/prototypes/partial-deep.ts
+++ b/example/prototypes/partial-deep.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/prototypes/union-enum.ts b/example/prototypes/union-enum.ts
index ee55d202c..91c768c52 100644
--- a/example/prototypes/union-enum.ts
+++ b/example/prototypes/union-enum.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/prototypes/union-oneof.ts b/example/prototypes/union-oneof.ts
index 5129d457a..818d3e457 100644
--- a/example/prototypes/union-oneof.ts
+++ b/example/prototypes/union-oneof.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/typedef/index.ts b/example/typedef/index.ts
index 495e365c3..a23b035fe 100644
--- a/example/typedef/index.ts
+++ b/example/typedef/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/typedef/typedef.ts b/example/typedef/typedef.ts
index 233ac5c7c..7a86b77d7 100644
--- a/example/typedef/typedef.ts
+++ b/example/typedef/typedef.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/license b/license
index 971ec5da8..7c58af806 100644
--- a/license
+++ b/license
@@ -4,7 +4,7 @@ Json Schema Type Builder with Static Type Resolution for TypeScript
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/package-lock.json b/package-lock.json
index 4c2b4a5e4..78a0102ed 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.4",
+  "version": "0.32.5",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.4",
+      "version": "0.32.5",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 6f84b9e31..930e2f331 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.4",
+  "version": "0.32.5",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 7f7368c19..e05257958 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/compiler/index.ts b/src/compiler/index.ts
index 48b4c10e8..b732cb855 100644
--- a/src/compiler/index.ts
+++ b/src/compiler/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index c84ebab9e..7bd658f3e 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/errors/function.ts b/src/errors/function.ts
index bba4ff53b..8bb1605dd 100644
--- a/src/errors/function.ts
+++ b/src/errors/function.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/errors/index.ts b/src/errors/index.ts
index 2c0c08936..6fc0d608a 100644
--- a/src/errors/index.ts
+++ b/src/errors/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/index.ts b/src/index.ts
index fbf63ae51..779964fef 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/system/index.ts b/src/system/index.ts
index fe79f6d08..7ed15c5dc 100644
--- a/src/system/index.ts
+++ b/src/system/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/system/policy.ts b/src/system/policy.ts
index 04c4a4ec2..e2d1a08e7 100644
--- a/src/system/policy.ts
+++ b/src/system/policy.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/system/system.ts b/src/system/system.ts
index 0c1535b05..2715ee4e6 100644
--- a/src/system/system.ts
+++ b/src/system/system.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/any/any.ts b/src/type/any/any.ts
index e462db9f5..6916cef60 100644
--- a/src/type/any/any.ts
+++ b/src/type/any/any.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/any/index.ts b/src/type/any/index.ts
index 29688e122..fe7f59848 100644
--- a/src/type/any/index.ts
+++ b/src/type/any/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/array/array.ts b/src/type/array/array.ts
index 1165e6268..09ca326ae 100644
--- a/src/type/array/array.ts
+++ b/src/type/array/array.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/array/index.ts b/src/type/array/index.ts
index ae02b63c0..d19c2e2be 100644
--- a/src/type/array/index.ts
+++ b/src/type/array/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/async-iterator/async-iterator.ts b/src/type/async-iterator/async-iterator.ts
index 9ee5f8755..5861f9625 100644
--- a/src/type/async-iterator/async-iterator.ts
+++ b/src/type/async-iterator/async-iterator.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/async-iterator/index.ts b/src/type/async-iterator/index.ts
index d6bc7cb22..9a61d47dc 100644
--- a/src/type/async-iterator/index.ts
+++ b/src/type/async-iterator/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/awaited/awaited.ts b/src/type/awaited/awaited.ts
index 8eec616c4..7a17df3af 100644
--- a/src/type/awaited/awaited.ts
+++ b/src/type/awaited/awaited.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/awaited/index.ts b/src/type/awaited/index.ts
index 26a23a571..186c08da5 100644
--- a/src/type/awaited/index.ts
+++ b/src/type/awaited/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/bigint/bigint.ts b/src/type/bigint/bigint.ts
index 53b0fb28d..eb0ca248e 100644
--- a/src/type/bigint/bigint.ts
+++ b/src/type/bigint/bigint.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/bigint/index.ts b/src/type/bigint/index.ts
index ce8f4fbf9..8d4c4b5d6 100644
--- a/src/type/bigint/index.ts
+++ b/src/type/bigint/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/boolean/boolean.ts b/src/type/boolean/boolean.ts
index 7d3fe1aed..68a2c26a5 100644
--- a/src/type/boolean/boolean.ts
+++ b/src/type/boolean/boolean.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/boolean/index.ts b/src/type/boolean/index.ts
index aad153cb3..4de112e06 100644
--- a/src/type/boolean/index.ts
+++ b/src/type/boolean/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/clone/index.ts b/src/type/clone/index.ts
index 44bd8cb28..4ac4e6f01 100644
--- a/src/type/clone/index.ts
+++ b/src/type/clone/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/clone/type.ts b/src/type/clone/type.ts
index 08d1c3f43..f6c3dd54e 100644
--- a/src/type/clone/type.ts
+++ b/src/type/clone/type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/clone/value.ts b/src/type/clone/value.ts
index 03e880482..548cef442 100644
--- a/src/type/clone/value.ts
+++ b/src/type/clone/value.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/composite/composite.ts b/src/type/composite/composite.ts
index 0bfe80434..ae994017f 100644
--- a/src/type/composite/composite.ts
+++ b/src/type/composite/composite.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/composite/index.ts b/src/type/composite/index.ts
index 2fe294b71..141f3e337 100644
--- a/src/type/composite/index.ts
+++ b/src/type/composite/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/const/const.ts b/src/type/const/const.ts
index b3ce2ac58..ce13dc352 100644
--- a/src/type/const/const.ts
+++ b/src/type/const/const.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/const/index.ts b/src/type/const/index.ts
index f13d0f549..90b0ba9ca 100644
--- a/src/type/const/index.ts
+++ b/src/type/const/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/constructor-parameters/constructor-parameters.ts b/src/type/constructor-parameters/constructor-parameters.ts
index e2cb70e19..9b00791ab 100644
--- a/src/type/constructor-parameters/constructor-parameters.ts
+++ b/src/type/constructor-parameters/constructor-parameters.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/constructor-parameters/index.ts b/src/type/constructor-parameters/index.ts
index 23f9c265b..dbc9c6c0a 100644
--- a/src/type/constructor-parameters/index.ts
+++ b/src/type/constructor-parameters/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/constructor/constructor.ts b/src/type/constructor/constructor.ts
index c4e37e8fc..948d0aab6 100644
--- a/src/type/constructor/constructor.ts
+++ b/src/type/constructor/constructor.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/constructor/index.ts b/src/type/constructor/index.ts
index 8e75965f7..3269a4e78 100644
--- a/src/type/constructor/index.ts
+++ b/src/type/constructor/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/date/date.ts b/src/type/date/date.ts
index 9e45ec214..3a7534217 100644
--- a/src/type/date/date.ts
+++ b/src/type/date/date.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/date/index.ts b/src/type/date/index.ts
index 932ee5def..d73b06d48 100644
--- a/src/type/date/index.ts
+++ b/src/type/date/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/deref/deref.ts b/src/type/deref/deref.ts
index 84fa78421..2be22d90d 100644
--- a/src/type/deref/deref.ts
+++ b/src/type/deref/deref.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/deref/index.ts b/src/type/deref/index.ts
index 496b4d6f0..28c03fc50 100644
--- a/src/type/deref/index.ts
+++ b/src/type/deref/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/discard/discard.ts b/src/type/discard/discard.ts
index f531f4d49..9e4b98dc3 100644
--- a/src/type/discard/discard.ts
+++ b/src/type/discard/discard.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/discard/index.ts b/src/type/discard/index.ts
index 43fb9af56..54c7051b2 100644
--- a/src/type/discard/index.ts
+++ b/src/type/discard/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/enum/enum.ts b/src/type/enum/enum.ts
index 4a92aeed2..2406cc027 100644
--- a/src/type/enum/enum.ts
+++ b/src/type/enum/enum.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/enum/index.ts b/src/type/enum/index.ts
index d5dfd4a6f..a77209132 100644
--- a/src/type/enum/index.ts
+++ b/src/type/enum/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/error/error.ts b/src/type/error/error.ts
index 652352632..f72140b3d 100644
--- a/src/type/error/error.ts
+++ b/src/type/error/error.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/error/index.ts b/src/type/error/index.ts
index 277d5e011..4cf885dad 100644
--- a/src/type/error/index.ts
+++ b/src/type/error/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/exclude/exclude-from-mapped-result.ts b/src/type/exclude/exclude-from-mapped-result.ts
index 858bbfd9b..a8934686f 100644
--- a/src/type/exclude/exclude-from-mapped-result.ts
+++ b/src/type/exclude/exclude-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/exclude/exclude.ts b/src/type/exclude/exclude.ts
index 751e9e154..e69ef1b9a 100644
--- a/src/type/exclude/exclude.ts
+++ b/src/type/exclude/exclude.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/exclude/index.ts b/src/type/exclude/index.ts
index b83e080b5..335e87a04 100644
--- a/src/type/exclude/index.ts
+++ b/src/type/exclude/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extends/extends-check.ts b/src/type/extends/extends-check.ts
index d726d91ea..dc461eff4 100644
--- a/src/type/extends/extends-check.ts
+++ b/src/type/extends/extends-check.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extends/extends-from-mapped-key.ts b/src/type/extends/extends-from-mapped-key.ts
index acc955ee5..7e3620ff2 100644
--- a/src/type/extends/extends-from-mapped-key.ts
+++ b/src/type/extends/extends-from-mapped-key.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extends/extends-from-mapped-result.ts b/src/type/extends/extends-from-mapped-result.ts
index d34c5dc80..c202aa356 100644
--- a/src/type/extends/extends-from-mapped-result.ts
+++ b/src/type/extends/extends-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extends/extends-undefined.ts b/src/type/extends/extends-undefined.ts
index f6c275c6a..23c51776d 100644
--- a/src/type/extends/extends-undefined.ts
+++ b/src/type/extends/extends-undefined.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extends/extends.ts b/src/type/extends/extends.ts
index e91a9d629..53049c4d5 100644
--- a/src/type/extends/extends.ts
+++ b/src/type/extends/extends.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extends/index.ts b/src/type/extends/index.ts
index 330381d55..aa0bc3d6c 100644
--- a/src/type/extends/index.ts
+++ b/src/type/extends/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extract/extract-from-mapped-result.ts b/src/type/extract/extract-from-mapped-result.ts
index 96191929c..c21ed3567 100644
--- a/src/type/extract/extract-from-mapped-result.ts
+++ b/src/type/extract/extract-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extract/extract.ts b/src/type/extract/extract.ts
index 2ef499831..7e6dc05f9 100644
--- a/src/type/extract/extract.ts
+++ b/src/type/extract/extract.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extract/index.ts b/src/type/extract/index.ts
index 3fd310772..baa79009e 100644
--- a/src/type/extract/index.ts
+++ b/src/type/extract/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/function/function.ts b/src/type/function/function.ts
index 7c97429a4..6f594dfb3 100644
--- a/src/type/function/function.ts
+++ b/src/type/function/function.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/function/index.ts b/src/type/function/index.ts
index 3399c7270..21b4ad556 100644
--- a/src/type/function/index.ts
+++ b/src/type/function/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/guard/index.ts b/src/type/guard/index.ts
index 2e7cc05ad..a8f31501a 100644
--- a/src/type/guard/index.ts
+++ b/src/type/guard/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/guard/type.ts b/src/type/guard/type.ts
index 9794a4fcb..98eada8ce 100644
--- a/src/type/guard/type.ts
+++ b/src/type/guard/type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/guard/value.ts b/src/type/guard/value.ts
index e09fb9bbc..c3ecc85fe 100644
--- a/src/type/guard/value.ts
+++ b/src/type/guard/value.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/helpers/helpers.ts b/src/type/helpers/helpers.ts
index 84263c6d5..c241ef343 100644
--- a/src/type/helpers/helpers.ts
+++ b/src/type/helpers/helpers.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/helpers/index.ts b/src/type/helpers/index.ts
index 4d6559c8a..8e6b80464 100644
--- a/src/type/helpers/index.ts
+++ b/src/type/helpers/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/index.ts b/src/type/index.ts
index d47dbf308..b69a1fa72 100644
--- a/src/type/index.ts
+++ b/src/type/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/indexed/index.ts b/src/type/indexed/index.ts
index bdd973af4..ed02a2814 100644
--- a/src/type/indexed/index.ts
+++ b/src/type/indexed/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/indexed/indexed-from-mapped-key.ts b/src/type/indexed/indexed-from-mapped-key.ts
index 5b1567c49..76dc90e70 100644
--- a/src/type/indexed/indexed-from-mapped-key.ts
+++ b/src/type/indexed/indexed-from-mapped-key.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/indexed/indexed-from-mapped-result.ts b/src/type/indexed/indexed-from-mapped-result.ts
index f685717ca..ce4745886 100644
--- a/src/type/indexed/indexed-from-mapped-result.ts
+++ b/src/type/indexed/indexed-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/indexed/indexed-property-keys.ts b/src/type/indexed/indexed-property-keys.ts
index 58f689811..48a45cd92 100644
--- a/src/type/indexed/indexed-property-keys.ts
+++ b/src/type/indexed/indexed-property-keys.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/indexed/indexed.ts b/src/type/indexed/indexed.ts
index bea542a69..7b6e4dcf3 100644
--- a/src/type/indexed/indexed.ts
+++ b/src/type/indexed/indexed.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/instance-type/index.ts b/src/type/instance-type/index.ts
index aa85b717a..a16ba2e50 100644
--- a/src/type/instance-type/index.ts
+++ b/src/type/instance-type/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/instance-type/instance-type.ts b/src/type/instance-type/instance-type.ts
index f26503419..358ff7040 100644
--- a/src/type/instance-type/instance-type.ts
+++ b/src/type/instance-type/instance-type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/integer/index.ts b/src/type/integer/index.ts
index 73513ebc8..82c3e2cce 100644
--- a/src/type/integer/index.ts
+++ b/src/type/integer/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/integer/integer.ts b/src/type/integer/integer.ts
index 23ed802af..e74ec75ea 100644
--- a/src/type/integer/integer.ts
+++ b/src/type/integer/integer.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intersect/index.ts b/src/type/intersect/index.ts
index c2f3d3ba4..e9ec6eaea 100644
--- a/src/type/intersect/index.ts
+++ b/src/type/intersect/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intersect/intersect-create.ts b/src/type/intersect/intersect-create.ts
index 815c27e9a..eb179e770 100644
--- a/src/type/intersect/intersect-create.ts
+++ b/src/type/intersect/intersect-create.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intersect/intersect-evaluated.ts b/src/type/intersect/intersect-evaluated.ts
index 5f6f25ba4..2647e1b0d 100644
--- a/src/type/intersect/intersect-evaluated.ts
+++ b/src/type/intersect/intersect-evaluated.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intersect/intersect-type.ts b/src/type/intersect/intersect-type.ts
index 991c3674e..1b1f6a5de 100644
--- a/src/type/intersect/intersect-type.ts
+++ b/src/type/intersect/intersect-type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intersect/intersect.ts b/src/type/intersect/intersect.ts
index b06c1dd80..e677da624 100644
--- a/src/type/intersect/intersect.ts
+++ b/src/type/intersect/intersect.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intrinsic/capitalize.ts b/src/type/intrinsic/capitalize.ts
index 0bb053da8..48acdc23d 100644
--- a/src/type/intrinsic/capitalize.ts
+++ b/src/type/intrinsic/capitalize.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intrinsic/index.ts b/src/type/intrinsic/index.ts
index d5c9aedc3..8a67cea42 100644
--- a/src/type/intrinsic/index.ts
+++ b/src/type/intrinsic/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intrinsic/intrinsic-from-mapped-key.ts b/src/type/intrinsic/intrinsic-from-mapped-key.ts
index b1c1b5f3d..cd370ac1d 100644
--- a/src/type/intrinsic/intrinsic-from-mapped-key.ts
+++ b/src/type/intrinsic/intrinsic-from-mapped-key.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intrinsic/intrinsic.ts b/src/type/intrinsic/intrinsic.ts
index 5080aa60f..5d4442494 100644
--- a/src/type/intrinsic/intrinsic.ts
+++ b/src/type/intrinsic/intrinsic.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intrinsic/lowercase.ts b/src/type/intrinsic/lowercase.ts
index 835d39b4f..745c4ff22 100644
--- a/src/type/intrinsic/lowercase.ts
+++ b/src/type/intrinsic/lowercase.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intrinsic/uncapitalize.ts b/src/type/intrinsic/uncapitalize.ts
index d69502253..3024f9672 100644
--- a/src/type/intrinsic/uncapitalize.ts
+++ b/src/type/intrinsic/uncapitalize.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intrinsic/uppercase.ts b/src/type/intrinsic/uppercase.ts
index 52ee4fa67..bde519cc6 100644
--- a/src/type/intrinsic/uppercase.ts
+++ b/src/type/intrinsic/uppercase.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/iterator/index.ts b/src/type/iterator/index.ts
index 8c41f54e3..1a6c6fd01 100644
--- a/src/type/iterator/index.ts
+++ b/src/type/iterator/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/iterator/iterator.ts b/src/type/iterator/iterator.ts
index 74a37a236..e89816fa7 100644
--- a/src/type/iterator/iterator.ts
+++ b/src/type/iterator/iterator.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/keyof/index.ts b/src/type/keyof/index.ts
index 03a32c098..ecaa5e169 100644
--- a/src/type/keyof/index.ts
+++ b/src/type/keyof/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/keyof/keyof-from-mapped-result.ts b/src/type/keyof/keyof-from-mapped-result.ts
index 97709295c..8e10c66aa 100644
--- a/src/type/keyof/keyof-from-mapped-result.ts
+++ b/src/type/keyof/keyof-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/keyof/keyof-property-keys.ts b/src/type/keyof/keyof-property-keys.ts
index 63cb1a49e..34a16956a 100644
--- a/src/type/keyof/keyof-property-keys.ts
+++ b/src/type/keyof/keyof-property-keys.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/keyof/keyof.ts b/src/type/keyof/keyof.ts
index 1c6192136..5fcd4e51f 100644
--- a/src/type/keyof/keyof.ts
+++ b/src/type/keyof/keyof.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/literal/index.ts b/src/type/literal/index.ts
index d4cb53ef2..a3102cc94 100644
--- a/src/type/literal/index.ts
+++ b/src/type/literal/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/literal/literal.ts b/src/type/literal/literal.ts
index 8754ffd7c..fe3c7b64b 100644
--- a/src/type/literal/literal.ts
+++ b/src/type/literal/literal.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/mapped/index.ts b/src/type/mapped/index.ts
index 5e1f19bb1..9999cfd84 100644
--- a/src/type/mapped/index.ts
+++ b/src/type/mapped/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/mapped/mapped-key.ts b/src/type/mapped/mapped-key.ts
index 24ad79526..d7eba3634 100644
--- a/src/type/mapped/mapped-key.ts
+++ b/src/type/mapped/mapped-key.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/mapped/mapped-result.ts b/src/type/mapped/mapped-result.ts
index 84908ea3b..d2aade75c 100644
--- a/src/type/mapped/mapped-result.ts
+++ b/src/type/mapped/mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/mapped/mapped.ts b/src/type/mapped/mapped.ts
index 49ab254e7..0c6588b8b 100644
--- a/src/type/mapped/mapped.ts
+++ b/src/type/mapped/mapped.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/never/index.ts b/src/type/never/index.ts
index 913504405..d8937194f 100644
--- a/src/type/never/index.ts
+++ b/src/type/never/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/never/never.ts b/src/type/never/never.ts
index 7fc22f7fe..d3113d216 100644
--- a/src/type/never/never.ts
+++ b/src/type/never/never.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/not/index.ts b/src/type/not/index.ts
index 49cf9dca8..34f540ae0 100644
--- a/src/type/not/index.ts
+++ b/src/type/not/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/not/not.ts b/src/type/not/not.ts
index df0a93a74..d01ac2b3a 100644
--- a/src/type/not/not.ts
+++ b/src/type/not/not.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/null/index.ts b/src/type/null/index.ts
index 281bef4f4..fe04d45b7 100644
--- a/src/type/null/index.ts
+++ b/src/type/null/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/null/null.ts b/src/type/null/null.ts
index 6dad0c7d8..09142d299 100644
--- a/src/type/null/null.ts
+++ b/src/type/null/null.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/number/index.ts b/src/type/number/index.ts
index c43f623c7..2cb1382f0 100644
--- a/src/type/number/index.ts
+++ b/src/type/number/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/number/number.ts b/src/type/number/number.ts
index 1ae3ed8fd..573eb403a 100644
--- a/src/type/number/number.ts
+++ b/src/type/number/number.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/object/index.ts b/src/type/object/index.ts
index 5bebd5824..ac0958f80 100644
--- a/src/type/object/index.ts
+++ b/src/type/object/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/object/object.ts b/src/type/object/object.ts
index a68c53f9e..ed705aa6e 100644
--- a/src/type/object/object.ts
+++ b/src/type/object/object.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/omit/index.ts b/src/type/omit/index.ts
index c5e44415a..fc10b7329 100644
--- a/src/type/omit/index.ts
+++ b/src/type/omit/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/omit/omit-from-mapped-key.ts b/src/type/omit/omit-from-mapped-key.ts
index efac50d8f..041101a9e 100644
--- a/src/type/omit/omit-from-mapped-key.ts
+++ b/src/type/omit/omit-from-mapped-key.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/omit/omit-from-mapped-result.ts b/src/type/omit/omit-from-mapped-result.ts
index c6dd8b9a7..d08f83f05 100644
--- a/src/type/omit/omit-from-mapped-result.ts
+++ b/src/type/omit/omit-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/omit/omit.ts b/src/type/omit/omit.ts
index e0afd1060..5de3f15f6 100644
--- a/src/type/omit/omit.ts
+++ b/src/type/omit/omit.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/optional/index.ts b/src/type/optional/index.ts
index b861f8e73..ef2545c59 100644
--- a/src/type/optional/index.ts
+++ b/src/type/optional/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/optional/optional-from-mapped-result.ts b/src/type/optional/optional-from-mapped-result.ts
index 28ad4eaf6..813349da4 100644
--- a/src/type/optional/optional-from-mapped-result.ts
+++ b/src/type/optional/optional-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/optional/optional.ts b/src/type/optional/optional.ts
index 867117b4d..70703f101 100644
--- a/src/type/optional/optional.ts
+++ b/src/type/optional/optional.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/parameters/index.ts b/src/type/parameters/index.ts
index 195fafbb0..fc04a3a98 100644
--- a/src/type/parameters/index.ts
+++ b/src/type/parameters/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/parameters/parameters.ts b/src/type/parameters/parameters.ts
index e2d4bb2f0..6e5bcbe5d 100644
--- a/src/type/parameters/parameters.ts
+++ b/src/type/parameters/parameters.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/partial/index.ts b/src/type/partial/index.ts
index af7c8ba58..953dfdbbb 100644
--- a/src/type/partial/index.ts
+++ b/src/type/partial/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/partial/partial-from-mapped-result.ts b/src/type/partial/partial-from-mapped-result.ts
index 23fb89d14..2681232e3 100644
--- a/src/type/partial/partial-from-mapped-result.ts
+++ b/src/type/partial/partial-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/partial/partial.ts b/src/type/partial/partial.ts
index d49dad8ce..b46ee4af9 100644
--- a/src/type/partial/partial.ts
+++ b/src/type/partial/partial.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/patterns/index.ts b/src/type/patterns/index.ts
index 7dbf0a210..240e6e9ca 100644
--- a/src/type/patterns/index.ts
+++ b/src/type/patterns/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/patterns/patterns.ts b/src/type/patterns/patterns.ts
index d9b9e8d79..016d60424 100644
--- a/src/type/patterns/patterns.ts
+++ b/src/type/patterns/patterns.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/pick/index.ts b/src/type/pick/index.ts
index 1fa9844ab..ac52efa52 100644
--- a/src/type/pick/index.ts
+++ b/src/type/pick/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/pick/pick-from-mapped-key.ts b/src/type/pick/pick-from-mapped-key.ts
index b5e30fa1e..963ba8557 100644
--- a/src/type/pick/pick-from-mapped-key.ts
+++ b/src/type/pick/pick-from-mapped-key.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/pick/pick-from-mapped-result.ts b/src/type/pick/pick-from-mapped-result.ts
index 4da4a6108..4238fd3dc 100644
--- a/src/type/pick/pick-from-mapped-result.ts
+++ b/src/type/pick/pick-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/pick/pick.ts b/src/type/pick/pick.ts
index 336d47585..b746bf13b 100644
--- a/src/type/pick/pick.ts
+++ b/src/type/pick/pick.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/promise/index.ts b/src/type/promise/index.ts
index 55150952e..ee5555e88 100644
--- a/src/type/promise/index.ts
+++ b/src/type/promise/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/promise/promise.ts b/src/type/promise/promise.ts
index 48b99d0ce..bebb00171 100644
--- a/src/type/promise/promise.ts
+++ b/src/type/promise/promise.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/readonly-optional/index.ts b/src/type/readonly-optional/index.ts
index 3e44a84c0..594463f54 100644
--- a/src/type/readonly-optional/index.ts
+++ b/src/type/readonly-optional/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/readonly-optional/readonly-optional.ts b/src/type/readonly-optional/readonly-optional.ts
index 788ede112..d32212777 100644
--- a/src/type/readonly-optional/readonly-optional.ts
+++ b/src/type/readonly-optional/readonly-optional.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/readonly/index.ts b/src/type/readonly/index.ts
index f39c08474..c21de9d35 100644
--- a/src/type/readonly/index.ts
+++ b/src/type/readonly/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/readonly/readonly-from-mapped-result.ts b/src/type/readonly/readonly-from-mapped-result.ts
index 9f303bb40..29857793b 100644
--- a/src/type/readonly/readonly-from-mapped-result.ts
+++ b/src/type/readonly/readonly-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/readonly/readonly.ts b/src/type/readonly/readonly.ts
index c5bc936c9..594170fff 100644
--- a/src/type/readonly/readonly.ts
+++ b/src/type/readonly/readonly.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/record/index.ts b/src/type/record/index.ts
index 10eb1ceb9..6b0a78848 100644
--- a/src/type/record/index.ts
+++ b/src/type/record/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/record/record.ts b/src/type/record/record.ts
index 042d4b5d6..53c4011d0 100644
--- a/src/type/record/record.ts
+++ b/src/type/record/record.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/recursive/index.ts b/src/type/recursive/index.ts
index 9bb19d9f4..f23634a44 100644
--- a/src/type/recursive/index.ts
+++ b/src/type/recursive/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/recursive/recursive.ts b/src/type/recursive/recursive.ts
index cff19af46..d1e14e264 100644
--- a/src/type/recursive/recursive.ts
+++ b/src/type/recursive/recursive.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/ref/index.ts b/src/type/ref/index.ts
index 1db9fa4e0..606ede084 100644
--- a/src/type/ref/index.ts
+++ b/src/type/ref/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/ref/ref.ts b/src/type/ref/ref.ts
index 1df55fe2d..97fffe26f 100644
--- a/src/type/ref/ref.ts
+++ b/src/type/ref/ref.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/regexp/index.ts b/src/type/regexp/index.ts
index 00fab30b4..578ac9777 100644
--- a/src/type/regexp/index.ts
+++ b/src/type/regexp/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/regexp/regexp.ts b/src/type/regexp/regexp.ts
index 3029d4240..f43257710 100644
--- a/src/type/regexp/regexp.ts
+++ b/src/type/regexp/regexp.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/registry/format.ts b/src/type/registry/format.ts
index ebcf3d74a..99b893bbe 100644
--- a/src/type/registry/format.ts
+++ b/src/type/registry/format.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/registry/index.ts b/src/type/registry/index.ts
index a0fb0e043..f16716fd9 100644
--- a/src/type/registry/index.ts
+++ b/src/type/registry/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/registry/type.ts b/src/type/registry/type.ts
index 78e313b4a..35078a856 100644
--- a/src/type/registry/type.ts
+++ b/src/type/registry/type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/required/index.ts b/src/type/required/index.ts
index 428fd821c..e6d6901ff 100644
--- a/src/type/required/index.ts
+++ b/src/type/required/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/required/required-from-mapped-result.ts b/src/type/required/required-from-mapped-result.ts
index 2f6da2807..b73554f1d 100644
--- a/src/type/required/required-from-mapped-result.ts
+++ b/src/type/required/required-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/required/required.ts b/src/type/required/required.ts
index e26e8f857..1066289b3 100644
--- a/src/type/required/required.ts
+++ b/src/type/required/required.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/rest/index.ts b/src/type/rest/index.ts
index b1442f480..e62da1430 100644
--- a/src/type/rest/index.ts
+++ b/src/type/rest/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/rest/rest.ts b/src/type/rest/rest.ts
index 8ca450780..e12d787b8 100644
--- a/src/type/rest/rest.ts
+++ b/src/type/rest/rest.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/return-type/index.ts b/src/type/return-type/index.ts
index 610d3adc0..799891a64 100644
--- a/src/type/return-type/index.ts
+++ b/src/type/return-type/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/return-type/return-type.ts b/src/type/return-type/return-type.ts
index fd31f8d59..f3f843355 100644
--- a/src/type/return-type/return-type.ts
+++ b/src/type/return-type/return-type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/schema/anyschema.ts b/src/type/schema/anyschema.ts
index 44fa18e5f..908295fc1 100644
--- a/src/type/schema/anyschema.ts
+++ b/src/type/schema/anyschema.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/schema/index.ts b/src/type/schema/index.ts
index bfd714bb5..d3ce4acee 100644
--- a/src/type/schema/index.ts
+++ b/src/type/schema/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/schema/schema.ts b/src/type/schema/schema.ts
index 287088f98..6cba033d7 100644
--- a/src/type/schema/schema.ts
+++ b/src/type/schema/schema.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/sets/index.ts b/src/type/sets/index.ts
index e672ba02e..c793d0851 100644
--- a/src/type/sets/index.ts
+++ b/src/type/sets/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/sets/set.ts b/src/type/sets/set.ts
index c478204ff..f2456a728 100644
--- a/src/type/sets/set.ts
+++ b/src/type/sets/set.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/static/index.ts b/src/type/static/index.ts
index 8f4f0c9dc..94f485cd1 100644
--- a/src/type/static/index.ts
+++ b/src/type/static/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/static/static.ts b/src/type/static/static.ts
index e38b3765f..25a9083d1 100644
--- a/src/type/static/static.ts
+++ b/src/type/static/static.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/strict/index.ts b/src/type/strict/index.ts
index caf80eab1..24555f714 100644
--- a/src/type/strict/index.ts
+++ b/src/type/strict/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/strict/strict.ts b/src/type/strict/strict.ts
index de47e425b..ddcf88836 100644
--- a/src/type/strict/strict.ts
+++ b/src/type/strict/strict.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/string/index.ts b/src/type/string/index.ts
index 1c188b4fd..a21b1efbe 100644
--- a/src/type/string/index.ts
+++ b/src/type/string/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/string/string.ts b/src/type/string/string.ts
index 5bcda7176..77d1c10ee 100644
--- a/src/type/string/string.ts
+++ b/src/type/string/string.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/symbol/index.ts b/src/type/symbol/index.ts
index abd306265..0ba6f5542 100644
--- a/src/type/symbol/index.ts
+++ b/src/type/symbol/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/symbol/symbol.ts b/src/type/symbol/symbol.ts
index 4c5adc9ab..02712500c 100644
--- a/src/type/symbol/symbol.ts
+++ b/src/type/symbol/symbol.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/symbols/index.ts b/src/type/symbols/index.ts
index bac16a322..7ee40afb8 100644
--- a/src/type/symbols/index.ts
+++ b/src/type/symbols/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/symbols/symbols.ts b/src/type/symbols/symbols.ts
index dbb90a99a..11530fedb 100644
--- a/src/type/symbols/symbols.ts
+++ b/src/type/symbols/symbols.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/template-literal/finite.ts b/src/type/template-literal/finite.ts
index 43a03ac33..194e15f93 100644
--- a/src/type/template-literal/finite.ts
+++ b/src/type/template-literal/finite.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/template-literal/generate.ts b/src/type/template-literal/generate.ts
index 671dd40e2..23a56790b 100644
--- a/src/type/template-literal/generate.ts
+++ b/src/type/template-literal/generate.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/template-literal/index.ts b/src/type/template-literal/index.ts
index 17ae27505..8f6a05c3e 100644
--- a/src/type/template-literal/index.ts
+++ b/src/type/template-literal/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/template-literal/parse.ts b/src/type/template-literal/parse.ts
index f856a1eac..7a2730f44 100644
--- a/src/type/template-literal/parse.ts
+++ b/src/type/template-literal/parse.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/template-literal/pattern.ts b/src/type/template-literal/pattern.ts
index 6af7e3f9d..099ee1b5f 100644
--- a/src/type/template-literal/pattern.ts
+++ b/src/type/template-literal/pattern.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/template-literal/syntax.ts b/src/type/template-literal/syntax.ts
index f70df69f8..1250ee651 100644
--- a/src/type/template-literal/syntax.ts
+++ b/src/type/template-literal/syntax.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/template-literal/template-literal.ts b/src/type/template-literal/template-literal.ts
index c3436b8f2..2003e68a2 100644
--- a/src/type/template-literal/template-literal.ts
+++ b/src/type/template-literal/template-literal.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/template-literal/union.ts b/src/type/template-literal/union.ts
index 9de4dbc83..a5a1f9240 100644
--- a/src/type/template-literal/union.ts
+++ b/src/type/template-literal/union.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/transform/index.ts b/src/type/transform/index.ts
index 4e6ab0218..949f78cfe 100644
--- a/src/type/transform/index.ts
+++ b/src/type/transform/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/transform/transform.ts b/src/type/transform/transform.ts
index cb7099544..bdd575e5b 100644
--- a/src/type/transform/transform.ts
+++ b/src/type/transform/transform.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/tuple/index.ts b/src/type/tuple/index.ts
index c1eb788d2..54d2b14ab 100644
--- a/src/type/tuple/index.ts
+++ b/src/type/tuple/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/tuple/tuple.ts b/src/type/tuple/tuple.ts
index 32119f78d..bd4f8400f 100644
--- a/src/type/tuple/tuple.ts
+++ b/src/type/tuple/tuple.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/type/index.ts b/src/type/type/index.ts
index 081b459d1..dbe0febc8 100644
--- a/src/type/type/index.ts
+++ b/src/type/type/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/type/javascript.ts b/src/type/type/javascript.ts
index 7975887fd..a5c170153 100644
--- a/src/type/type/javascript.ts
+++ b/src/type/type/javascript.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/type/json.ts b/src/type/type/json.ts
index d4e6214f6..145d93e5b 100644
--- a/src/type/type/json.ts
+++ b/src/type/type/json.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/type/type.ts b/src/type/type/type.ts
index 53f275419..4f0fc5550 100644
--- a/src/type/type/type.ts
+++ b/src/type/type/type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/uint8array/index.ts b/src/type/uint8array/index.ts
index 4c2296a42..fc3256037 100644
--- a/src/type/uint8array/index.ts
+++ b/src/type/uint8array/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/uint8array/uint8array.ts b/src/type/uint8array/uint8array.ts
index 1c1732ced..fa0fb5501 100644
--- a/src/type/uint8array/uint8array.ts
+++ b/src/type/uint8array/uint8array.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/undefined/index.ts b/src/type/undefined/index.ts
index cbc1c28e3..728a1232d 100644
--- a/src/type/undefined/index.ts
+++ b/src/type/undefined/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/undefined/undefined.ts b/src/type/undefined/undefined.ts
index a069fe06f..69614443a 100644
--- a/src/type/undefined/undefined.ts
+++ b/src/type/undefined/undefined.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/union/index.ts b/src/type/union/index.ts
index 17dd10d72..b49ca2d45 100644
--- a/src/type/union/index.ts
+++ b/src/type/union/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/union/union-create.ts b/src/type/union/union-create.ts
index c2f261933..48df85256 100644
--- a/src/type/union/union-create.ts
+++ b/src/type/union/union-create.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/union/union-evaluated.ts b/src/type/union/union-evaluated.ts
index 248d4e600..5bac5539f 100644
--- a/src/type/union/union-evaluated.ts
+++ b/src/type/union/union-evaluated.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/union/union-type.ts b/src/type/union/union-type.ts
index 6eb5ba4d3..68f0cb19e 100644
--- a/src/type/union/union-type.ts
+++ b/src/type/union/union-type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/union/union.ts b/src/type/union/union.ts
index 5c5265e97..2024ad8bb 100644
--- a/src/type/union/union.ts
+++ b/src/type/union/union.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/unknown/index.ts b/src/type/unknown/index.ts
index 7d9c7e293..80a7b68e7 100644
--- a/src/type/unknown/index.ts
+++ b/src/type/unknown/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/unknown/unknown.ts b/src/type/unknown/unknown.ts
index f5a0d9a3d..974e4ade1 100644
--- a/src/type/unknown/unknown.ts
+++ b/src/type/unknown/unknown.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/unsafe/index.ts b/src/type/unsafe/index.ts
index 78141b392..395fd75bf 100644
--- a/src/type/unsafe/index.ts
+++ b/src/type/unsafe/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/unsafe/unsafe.ts b/src/type/unsafe/unsafe.ts
index 26fb987af..7faf6154a 100644
--- a/src/type/unsafe/unsafe.ts
+++ b/src/type/unsafe/unsafe.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/void/index.ts b/src/type/void/index.ts
index 3b9bf5199..e6bc946ae 100644
--- a/src/type/void/index.ts
+++ b/src/type/void/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/void/void.ts b/src/type/void/void.ts
index 867f33f47..4cf4ae501 100644
--- a/src/type/void/void.ts
+++ b/src/type/void/void.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/cast/cast.ts b/src/value/cast/cast.ts
index 8ac9e79df..afe8bd74f 100644
--- a/src/value/cast/cast.ts
+++ b/src/value/cast/cast.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/cast/index.ts b/src/value/cast/index.ts
index 5d403f74a..575c46a49 100644
--- a/src/value/cast/index.ts
+++ b/src/value/cast/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/check/check.ts b/src/value/check/check.ts
index c2cd892db..e05fee2d7 100644
--- a/src/value/check/check.ts
+++ b/src/value/check/check.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/check/index.ts b/src/value/check/index.ts
index e318a6581..04975a6ba 100644
--- a/src/value/check/index.ts
+++ b/src/value/check/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/clean/clean.ts b/src/value/clean/clean.ts
index 0d0f20fa7..7f48119b7 100644
--- a/src/value/clean/clean.ts
+++ b/src/value/clean/clean.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/clean/index.ts b/src/value/clean/index.ts
index 4e55b279e..81d0b0910 100644
--- a/src/value/clean/index.ts
+++ b/src/value/clean/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/clone/clone.ts b/src/value/clone/clone.ts
index 4c337929b..7f748cbba 100644
--- a/src/value/clone/clone.ts
+++ b/src/value/clone/clone.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/clone/index.ts b/src/value/clone/index.ts
index 4294f9957..22d2dd12b 100644
--- a/src/value/clone/index.ts
+++ b/src/value/clone/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index 4360e4fbb..35afea3c8 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/convert/index.ts b/src/value/convert/index.ts
index 0e642e6ac..3a88a32f7 100644
--- a/src/value/convert/index.ts
+++ b/src/value/convert/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/create/create.ts b/src/value/create/create.ts
index b632947bd..697a37234 100644
--- a/src/value/create/create.ts
+++ b/src/value/create/create.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/create/index.ts b/src/value/create/index.ts
index 62543e72b..706ec0023 100644
--- a/src/value/create/index.ts
+++ b/src/value/create/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/default/default.ts b/src/value/default/default.ts
index a089f7600..afeea9cd2 100644
--- a/src/value/default/default.ts
+++ b/src/value/default/default.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/default/index.ts b/src/value/default/index.ts
index fb74557fd..62ca5b16f 100644
--- a/src/value/default/index.ts
+++ b/src/value/default/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/delta/delta.ts b/src/value/delta/delta.ts
index d7ae9fa89..616d5e949 100644
--- a/src/value/delta/delta.ts
+++ b/src/value/delta/delta.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/delta/index.ts b/src/value/delta/index.ts
index 3eca3782f..0ea44bee9 100644
--- a/src/value/delta/index.ts
+++ b/src/value/delta/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/deref/deref.ts b/src/value/deref/deref.ts
index e7c0926af..c51fc23f7 100644
--- a/src/value/deref/deref.ts
+++ b/src/value/deref/deref.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/deref/index.ts b/src/value/deref/index.ts
index d0bf7e45b..99003df72 100644
--- a/src/value/deref/index.ts
+++ b/src/value/deref/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/equal/equal.ts b/src/value/equal/equal.ts
index 264093959..fdfca521e 100644
--- a/src/value/equal/equal.ts
+++ b/src/value/equal/equal.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/equal/index.ts b/src/value/equal/index.ts
index cf0e42f72..7a4ad2de7 100644
--- a/src/value/equal/index.ts
+++ b/src/value/equal/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/guard/guard.ts b/src/value/guard/guard.ts
index 92aa187dd..83a3c1b66 100644
--- a/src/value/guard/guard.ts
+++ b/src/value/guard/guard.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/guard/index.ts b/src/value/guard/index.ts
index 36d7e3fa8..439925ae1 100644
--- a/src/value/guard/index.ts
+++ b/src/value/guard/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/hash/hash.ts b/src/value/hash/hash.ts
index 6964af0f5..c87e102bc 100644
--- a/src/value/hash/hash.ts
+++ b/src/value/hash/hash.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/hash/index.ts b/src/value/hash/index.ts
index a2607845e..8f83cb1ac 100644
--- a/src/value/hash/index.ts
+++ b/src/value/hash/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/index.ts b/src/value/index.ts
index eecc44779..8b17d674f 100644
--- a/src/value/index.ts
+++ b/src/value/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/mutate/index.ts b/src/value/mutate/index.ts
index cf8bd9248..ef0e67394 100644
--- a/src/value/mutate/index.ts
+++ b/src/value/mutate/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/mutate/mutate.ts b/src/value/mutate/mutate.ts
index 670a02e5d..b8e5c61ca 100644
--- a/src/value/mutate/mutate.ts
+++ b/src/value/mutate/mutate.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/pointer/index.ts b/src/value/pointer/index.ts
index d4071966d..c64016d47 100644
--- a/src/value/pointer/index.ts
+++ b/src/value/pointer/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/pointer/pointer.ts b/src/value/pointer/pointer.ts
index e0c463927..6b8d7aa6f 100644
--- a/src/value/pointer/pointer.ts
+++ b/src/value/pointer/pointer.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/transform/decode.ts b/src/value/transform/decode.ts
index 8908c9d9a..9580e7663 100644
--- a/src/value/transform/decode.ts
+++ b/src/value/transform/decode.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/transform/encode.ts b/src/value/transform/encode.ts
index e91057e94..35d724811 100644
--- a/src/value/transform/encode.ts
+++ b/src/value/transform/encode.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/transform/has.ts b/src/value/transform/has.ts
index 437fad1d6..9aff3d25e 100644
--- a/src/value/transform/has.ts
+++ b/src/value/transform/has.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/transform/index.ts b/src/value/transform/index.ts
index f821f6d29..e3bd75d2a 100644
--- a/src/value/transform/index.ts
+++ b/src/value/transform/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/value/index.ts b/src/value/value/index.ts
index 3af158d90..eabf61e7b 100644
--- a/src/value/value/index.ts
+++ b/src/value/value/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/value/value.ts b/src/value/value/value.ts
index 62a0f04d1..6b5febc8b 100644
--- a/src/value/value/value.ts
+++ b/src/value/value/value.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/common/remove-notices.ts b/task/build/common/remove-notices.ts
index 15c9688eb..96b4dfb2d 100644
--- a/task/build/common/remove-notices.ts
+++ b/task/build/common/remove-notices.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/import/build.ts b/task/build/import/build.ts
index 5a423c1cc..bb2637876 100644
--- a/task/build/import/build.ts
+++ b/task/build/import/build.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/import/compile.ts b/task/build/import/compile.ts
index 05a0a10b8..e8beb64a5 100644
--- a/task/build/import/compile.ts
+++ b/task/build/import/compile.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/import/convert-to-esm.ts b/task/build/import/convert-to-esm.ts
index 1db93a61f..9878a4fe6 100644
--- a/task/build/import/convert-to-esm.ts
+++ b/task/build/import/convert-to-esm.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/index.ts b/task/build/index.ts
index fd7cf77da..948330f61 100644
--- a/task/build/index.ts
+++ b/task/build/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/redirect/build.ts b/task/build/redirect/build.ts
index 9d34cc8cb..f3eba27d7 100644
--- a/task/build/redirect/build.ts
+++ b/task/build/redirect/build.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/redirect/create-package-json.ts b/task/build/redirect/create-package-json.ts
index 068041c5a..d25cc61c4 100644
--- a/task/build/redirect/create-package-json.ts
+++ b/task/build/redirect/create-package-json.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/redirect/create-redirect-paths.ts b/task/build/redirect/create-redirect-paths.ts
index 66549ed3b..3915b08e5 100644
--- a/task/build/redirect/create-redirect-paths.ts
+++ b/task/build/redirect/create-redirect-paths.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/require/build.ts b/task/build/require/build.ts
index a3305a146..52bba8179 100644
--- a/task/build/require/build.ts
+++ b/task/build/require/build.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/require/compile.ts b/task/build/require/compile.ts
index f033f2228..bd089ec21 100644
--- a/task/build/require/compile.ts
+++ b/task/build/require/compile.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

From 4c0b764cf92e51413e71bc054618dab2bf349096 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 10 Jan 2024 11:25:14 +0900
Subject: [PATCH 224/369] Revision 0.32.6 (#724)

* Export TTemplateLiteralSyntax Infrastructure

* Export TDecodeType, TDecodeRest and TDecodeProperties

* Normalize Mapped Types, Drop TCompositeResolve

* Export KeyOf Infrastructure

* Export Awaited, Exclude, Extract, Pick, Omit and Mapped ReturnType
---
 package-lock.json                             |  4 +-
 package.json                                  |  2 +-
 src/index.ts                                  | 18 ++---
 src/type/awaited/awaited.ts                   | 22 +++----
 src/type/composite/composite.ts               | 23 +++----
 src/type/exclude/exclude.ts                   | 65 ++++++++-----------
 src/type/extract/extract.ts                   | 65 ++++++++-----------
 src/type/indexed/indexed-from-mapped-key.ts   |  4 +-
 src/type/keyof/keyof-from-mapped-result.ts    |  5 +-
 src/type/keyof/keyof.ts                       | 14 ++--
 src/type/mapped/mapped.ts                     | 14 ++--
 src/type/omit/omit-from-mapped-result.ts      |  5 +-
 .../partial/partial-from-mapped-result.ts     |  5 +-
 src/type/pick/pick-from-mapped-result.ts      |  5 +-
 src/type/pick/pick.ts                         | 14 ++--
 .../required/required-from-mapped-result.ts   |  5 +-
 src/type/static/static.ts                     | 44 ++++++-------
 test/runtime/type/guard/exclude.ts            | 32 +++++----
 test/runtime/type/guard/extract.ts            |  6 ++
 test/static/extract.ts                        |  2 +-
 20 files changed, 175 insertions(+), 179 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 78a0102ed..154b955ce 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.5",
+  "version": "0.32.6",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.5",
+      "version": "0.32.6",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 930e2f331..afe9e95fc 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.5",
+  "version": "0.32.6",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/index.ts b/src/index.ts
index 779964fef..4f582c5ca 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -41,7 +41,7 @@ export { TypeBoxError } from './type/error/index'
 export { Any, type TAny } from './type/any/index'
 export { Array, type TArray, type ArrayOptions } from './type/array/index'
 export { AsyncIterator, type TAsyncIterator } from './type/async-iterator/index'
-export { Awaited, type TAwaited } from './type/awaited/index'
+export { Awaited, type TAwaited, type TAwaitedResolve } from './type/awaited/index'
 export { BigInt, type TBigInt, type BigIntOptions } from './type/bigint/index'
 export { Boolean, type TBoolean } from './type/boolean/index'
 export { Composite, type TComposite } from './type/composite/index'
@@ -52,7 +52,7 @@ export { Date, type TDate, type DateOptions } from './type/date/index'
 export { Deref, type TDeref } from './type/deref/index'
 export { Enum, type TEnum } from './type/enum/index'
 export { Exclude, type TExclude, type TExcludeFromMappedResult } from './type/exclude/index'
-export { Extends, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './type/extends/index'
+export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey } from './type/extends/index'
 export { Extract, type TExtract, type TExtractFromMappedResult } from './type/extract/index'
 export { Function, type TFunction } from './type/function/index'
 export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index'
@@ -62,23 +62,23 @@ export { Integer, type TInteger, type IntegerOptions } from './type/integer/inde
 export { Intersect, IntersectEvaluated, type TIntersect, type TIntersectEvaluated, type IntersectOptions } from './type/intersect/index'
 export { Iterator, type TIterator } from './type/iterator/index'
 export { Intrinsic, IntrinsicFromMappedKey, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index'
-export { KeyOf, type TKeyOf, type KeyOfFromMappedResult, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index'
+export { KeyOf, KeyOfPropertyKeys, KeyOfPropertyKeysToRest, KeyOfFromMappedResult, KeyOfPattern, type TKeyOf, type TKeyOfPropertyKeys, type TKeyOfPropertyKeysToRest, type TKeyOfFromMappedResult } from './type/keyof/index'
 export { Literal, type TLiteral, type TLiteralValue } from './type/literal/index'
-export { Mapped, MappedKey, MappedResult, type TMapped, type TMappedKey, type TMappedResult, type TMappedFunction } from './type/mapped/index'
+export { Mapped, MappedKey, MappedResult, MappedFunctionReturnType, type TMapped, type TMappedKey, type TMappedResult, type TMappedFunction, type TMappedFunctionReturnType } from './type/mapped/index'
 export { Never, type TNever } from './type/never/index'
 export { Not, type TNot } from './type/not/index'
 export { Null, type TNull } from './type/null/index'
 export { Number, type TNumber, type NumberOptions } from './type/number/index'
 export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index'
-export { Omit, type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from './type/omit/index'
+export { Omit, type TOmit, type TOmitResolve, type TOmitFromMappedKey, type TOmitFromMappedResult } from './type/omit/index'
 export { Optional, OptionalFromMappedResult, type TOptional, type TOptionalWithFlag, type TOptionalFromMappedResult } from './type/optional/index'
 export { Parameters, type TParameters } from './type/parameters/index'
 export { Partial, PartialFromMappedResult, type TPartial, type TPartialFromMappedResult } from './type/partial/index'
-export { Pick, type TPick, type TPickFromMappedKey, type TPickFromMappedResult } from './type/pick/index'
+export { Pick, type TPick, type TPickResolve, type TPickFromMappedKey, type TPickFromMappedResult } from './type/pick/index'
 export { Promise, type TPromise } from './type/promise/index'
 export { Readonly, ReadonlyFromMappedResult, type TReadonly, type TReadonlyWithFlag, type TReadonlyFromMappedResult } from './type/readonly/index'
 export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index'
-export { Record, type TRecord } from './type/record/index'
+export { Record, type TRecord, type TRecordOrObject } from './type/record/index'
 export { Recursive, type TRecursive, type TThis } from './type/recursive/index'
 export { Ref, type TRef } from './type/ref/index'
 export { RegExp, type TRegExp } from './type/regexp/index'
@@ -86,7 +86,7 @@ export { Required, type TRequired, type TRequiredFromMappedResult } from './type
 export { Rest, type TRest } from './type/rest/index'
 export { ReturnType, type TReturnType } from './type/return-type/index'
 export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from './type/schema/index'
-export { type Static, type StaticDecode, type StaticEncode } from './type/static/index'
+export { type Static, type StaticDecode, type StaticEncode, type TDecodeType, type TDecodeRest, type TDecodeProperties } from './type/static/index'
 export { Strict } from './type/strict/index'
 export { String, type TString, type StringOptions, type StringFormatOption, type StringContentEncodingOption } from './type/string/index'
 export { Symbol, type TSymbol, type TSymbolValue as SymbolValue } from './type/symbol/index'
@@ -98,6 +98,8 @@ export {
   TemplateLiteralParseExact,
   TemplateLiteralGenerate,
   TemplateLiteralExpressionGenerate,
+  TemplateLiteralSyntax,
+  type TTemplateLiteralSyntax,
   type TTemplateLiteral,
   type TIsTemplateLiteralFinite,
   type TTemplateLiteralGenerate,
diff --git a/src/type/awaited/awaited.ts b/src/type/awaited/awaited.ts
index 7a17df3af..c782487fe 100644
--- a/src/type/awaited/awaited.ts
+++ b/src/type/awaited/awaited.ts
@@ -42,11 +42,11 @@ import { IsIntersect, IsUnion, IsPromise } from '../guard/type'
 // prettier-ignore
 type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> =
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TFromRest<R, [...Acc, TFromSchema<L>]>
+    ? TFromRest<R, [...Acc, TAwaitedResolve<L>]>
     : Acc
 // prettier-ignore
 function FromRest<T extends TSchema[]>(T: [...T]) : TFromRest<T> {
-  return T.map(L => FromSchema(L)) as TFromRest<T>
+  return T.map(L => AwaitedResolve(L)) as TFromRest<T>
 }
 // ----------------------------------------------------------------
 // FromIntersect
@@ -69,37 +69,37 @@ function FromUnion<T extends TSchema[]>(T: [...T]): TFromUnion<T> {
 // ----------------------------------------------------------------
 // Promise
 // ----------------------------------------------------------------
-type TFromPromise<T extends TSchema> = TFromSchema<T>
+type TFromPromise<T extends TSchema> = TAwaitedResolve<T>
 // prettier-ignore
 function FromPromise<T extends TSchema>(T: T): TFromPromise<T> {
-  return FromSchema(T) as TFromPromise<T>
+  return AwaitedResolve(T) as TFromPromise<T>
 }
 // ----------------------------------------------------------------
 // FromSchema
 // ----------------------------------------------------------------
 // prettier-ignore
-type TFromSchema<T extends TSchema> =
+export type TAwaitedResolve<T extends TSchema> =
   T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> :
   T extends TUnion<infer S> ? TUnion<TFromRest<S>> :
-  T extends TPromise<infer S> ? TFromSchema<S> :
+  T extends TPromise<infer S> ? TAwaitedResolve<S> :
   T
 // prettier-ignore
-function FromSchema<T extends TSchema>(T: T): TFromSchema<T> {
+export function AwaitedResolve<T extends TSchema>(T: T): TAwaitedResolve<T> {
   return (
     IsIntersect(T) ? FromIntersect(T.allOf) :
     IsUnion(T) ? FromUnion(T.anyOf) :
     IsPromise(T) ? FromPromise(T.item) :
     T
-  ) as TFromSchema<T>
+  ) as TAwaitedResolve<T>
 }
 // ------------------------------------------------------------------
 // TAwaited
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TAwaited<T extends TSchema> = (
-  TFromSchema<T>
+  TAwaitedResolve<T>
 )
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-export function Awaited<T extends TSchema>(T: T, options: SchemaOptions = {}): TFromSchema<T> {
-  return CloneType(FromSchema(T), options)
+export function Awaited<T extends TSchema>(T: T, options: SchemaOptions = {}): TAwaitedResolve<T> {
+  return CloneType(AwaitedResolve(T), options)
 }
diff --git a/src/type/composite/composite.ts b/src/type/composite/composite.ts
index ae994017f..b4dc847fa 100644
--- a/src/type/composite/composite.ts
+++ b/src/type/composite/composite.ts
@@ -27,12 +27,11 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import type { TSchema } from '../schema/index'
-import type { UnionToTuple, Assert, Evaluate } from '../helpers/index'
+import type { UnionToTuple, Assert, Ensure, Evaluate } from '../helpers/index'
 import { Object, type TObject, type TProperties, type ObjectOptions } from '../object/index'
 import { Intersect, type TIntersect } from '../intersect/index'
 import { Index, type TIndex } from '../indexed/index'
 import { KeyOfPropertyKeys } from '../keyof/index'
-import { CloneType } from '../clone/type'
 
 // ------------------------------------------------------------------
 // TCompositeKeys
@@ -54,22 +53,18 @@ type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[], Acc ex
 type TCompositeReduce<T extends TObject[]> = UnionToTuple<TCompositeKeys<T>> extends infer K
   ? Evaluate<TCompositeIndex<TIntersect<T>, Assert<K, string[]>>>
   : {} //                    ^ indexed via intersection of T
-// prettier-ignore
-type TCompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect
-  ? TObject<TCompositeReduce<T>>
-  : TObject<{}>
-function CompositeResolve<T extends TObject[]>(T: [...T]): TCompositeResolve<T> {
-  const intersect: TSchema = Intersect(T, {})
-  const keys = KeyOfPropertyKeys(intersect) as string[]
-  const properties = keys.reduce((acc, key) => ({ ...acc, [key]: Index(intersect, [key]) }), {} as TProperties)
-  return Object(properties) as TCompositeResolve<T>
-}
 // ------------------------------------------------------------------
 // TComposite
 // ------------------------------------------------------------------
-export type TComposite<T extends TObject[]> = TCompositeResolve<T>
+// prettier-ignore
+export type TComposite<T extends TObject[]> = TIntersect<T> extends TIntersect
+  ? Ensure<TObject<TCompositeReduce<T>>>
+  : Ensure<TObject<{}>>
 
 /** `[Json]` Creates a Composite object type */
 export function Composite<T extends TObject[]>(T: [...T], options?: ObjectOptions): TComposite<T> {
-  return CloneType(CompositeResolve(T) as TObject, options) as TComposite<T>
+  const intersect: TSchema = Intersect(T, {})
+  const keys = KeyOfPropertyKeys(intersect) as string[]
+  const properties = keys.reduce((acc, key) => ({ ...acc, [key]: Index(intersect, [key]) }), {} as TProperties)
+  return Object(properties, options) as TComposite<T>
 }
diff --git a/src/type/exclude/exclude.ts b/src/type/exclude/exclude.ts
index e69ef1b9a..d82bdf33a 100644
--- a/src/type/exclude/exclude.ts
+++ b/src/type/exclude/exclude.ts
@@ -44,53 +44,44 @@ import { ExcludeFromMappedResult, type TExcludeFromMappedResult } from './exclud
 // ------------------------------------------------------------------
 import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/type'
 // ------------------------------------------------------------------
-// ExcludeResolve
+// ExcludeTemplateLiteral
 // ------------------------------------------------------------------
 // prettier-ignore
 type TExcludeTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
 // prettier-ignore
-type TExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = (
-  Exclude<Static<T>, Static<U>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never
+type TExcludeTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = (
+  Exclude<Static<L>, Static<R>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never
 )
+// ------------------------------------------------------------------
+// ExcludeRest
+// ------------------------------------------------------------------
 // prettier-ignore
-type TExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
-  [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? never : T[K]
+type TExcludeRest<L extends TSchema[], R extends TSchema> = AssertRest<UnionToTuple<{
+  [K in keyof L]: Static<AssertType<L[K]>> extends Static<R> ? never : L[K]
 }[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never
-// prettier-ignore
-type TExcludeResolve<T extends TSchema, U extends TSchema> =
-  T extends TTemplateLiteral ? TExcludeTemplateLiteral<T, U> :
-  T extends TUnion<infer S> ? TExcludeArray<S, U> :
-  T extends U 
-    ? TNever 
-    : T
-// prettier-ignore
-function ExcludeResolve<L extends TSchema, R extends TSchema>(L: L, R: R): TExcludeResolve<L, R> {
-  return (
-    IsTemplateLiteral(L) ? ExcludeResolve(TemplateLiteralToUnion(L), R) :
-    IsTemplateLiteral(R) ? ExcludeResolve(L, TemplateLiteralToUnion(R)) :
-    IsUnion(L) ? (() => {
-      const narrowed = L.anyOf.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False)
-      return (narrowed.length === 1 ? narrowed[0] : Union(narrowed))
-    })() :
-    ExtendsCheck(L, R) !== ExtendsResult.False ? Never() :
-    L
-  ) as TExcludeResolve<L, R>
+
+function ExcludeRest<L extends TSchema[], R extends TSchema>(L: [...L], R: R) {
+  const excluded = L.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False)
+  return excluded.length === 1 ? excluded[0] : Union(excluded)
 }
 // ------------------------------------------------------------------
 // TExclude
 // ------------------------------------------------------------------
-export type TExclude<T extends TSchema, U extends TSchema> = TExcludeResolve<T, U>
-
-/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-export function Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>
-/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-export function Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>
+// prettier-ignore
+export type TExclude<L extends TSchema, R extends TSchema> = (
+  L extends TMappedResult<L> ? TExcludeFromMappedResult<L, R> :
+  L extends TTemplateLiteral ? TExcludeTemplateLiteral<L, R> :
+  L extends TUnion<infer S> ? TExcludeRest<S, R> :
+  L extends R ? TNever : L
+)
 /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-export function Exclude(unionType: TSchema, excludedMembers: TSchema, options: SchemaOptions = {}) {
-  if (IsMappedResult(unionType)) {
-    return ExcludeFromMappedResult(unionType, excludedMembers, options)
-  } else {
-    const E = ExcludeResolve(unionType, excludedMembers) as any
-    return CloneType(E, options)
-  }
+export function Exclude<L extends TSchema, R extends TSchema>(L: L, R: R, options: SchemaOptions = {}): TExclude<L, R> {
+  // prettier-ignore
+  return CloneType((
+    IsMappedResult(L) ? ExcludeFromMappedResult(L, R, options) :
+    IsTemplateLiteral(L) ? Exclude(TemplateLiteralToUnion(L), R) :
+    IsTemplateLiteral(R) ? Exclude(L, TemplateLiteralToUnion(R)) :
+    IsUnion(L) ? ExcludeRest(L.anyOf, R) :
+    ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L
+  ), options) as never
 }
diff --git a/src/type/extract/extract.ts b/src/type/extract/extract.ts
index 7e6dc05f9..a1f6f4d54 100644
--- a/src/type/extract/extract.ts
+++ b/src/type/extract/extract.ts
@@ -33,7 +33,7 @@ import { TemplateLiteralToUnion, type TTemplateLiteral } from '../template-liter
 import { type TLiteral } from '../literal/index'
 import { Union, type TUnion } from '../union/index'
 import { type Static } from '../static/index'
-import { Never } from '../never/index'
+import { Never, type TNever } from '../never/index'
 import { type TUnionEvaluated } from '../union/index'
 import { ExtendsCheck, ExtendsResult } from '../extends/index'
 import { CloneType } from '../clone/type'
@@ -44,51 +44,42 @@ import { ExtractFromMappedResult, type TExtractFromMappedResult } from './extrac
 // ------------------------------------------------------------------
 import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/type'
 // ------------------------------------------------------------------
-// ExtractResolve
+// ExtractTemplateLiteral
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
+type TExtractTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
 // prettier-ignore
-type TFromTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? TFromTemplateLiteralResult<Assert<S, string>> : never
+type TExtractTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = Extract<Static<L>, Static<R>> extends infer S ? TExtractTemplateLiteralResult<Assert<S, string>> : never
+// ------------------------------------------------------------------
+// ExtractRest
+// ------------------------------------------------------------------
 // prettier-ignore
-type TFromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<
-  { [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? T[K] : never
+type TExtractRest<L extends TSchema[], R extends TSchema> = AssertRest<UnionToTuple<
+  { [K in keyof L]: Static<AssertType<L[K]>> extends Static<R> ? L[K] : never
 }[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never
-// prettier-ignore
-type TExtractResolve<T extends TSchema, U extends TSchema> = (
-  T extends TTemplateLiteral ? TFromTemplateLiteral<T, U> :
-  T extends TUnion<infer S> ? TFromArray<S, U> :
-  T
-)
-// prettier-ignore
-function ExtractResolve<L extends TSchema, R extends TSchema>(L: L, R: R): TExtractResolve<L, R> {
-  return (
-    IsTemplateLiteral(L)  ? ExtractResolve(TemplateLiteralToUnion(L), R) :
-    IsTemplateLiteral(R) ? ExtractResolve(L, TemplateLiteralToUnion(R) as any) :
-    IsUnion(L) ? (() => {
-      const narrowed = L.anyOf.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False)
-      return (narrowed.length === 1 ? narrowed[0] : Union(narrowed))
-    })() :
-      ExtendsCheck(L, R) !== ExtendsResult.False ? L :
-      Never()
-  ) as TExtractResolve<L, R>
+
+function ExtractRest<L extends TSchema[], R extends TSchema>(L: [...L], R: R) {
+  const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False)
+  return extracted.length === 1 ? extracted[0] : Union(extracted)
 }
 // ------------------------------------------------------------------
 // TExtract
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TExtract<T extends TSchema, U extends TSchema> = TExtractResolve<T, U>
-
-/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-export function Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>
-/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-export function Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>
+export type TExtract<L extends TSchema, U extends TSchema> = (
+  L extends TMappedResult ? TExtractFromMappedResult<L, U> :
+  L extends TTemplateLiteral ? TExtractTemplateLiteral<L, U> :
+  L extends TUnion<infer S> ? TExtractRest<S, U> :
+  L extends U ? L : TNever
+)
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-export function Extract(type: TSchema, union: TSchema, options: SchemaOptions = {}) {
-  if (IsMappedResult(type)) {
-    return ExtractFromMappedResult(type, union, options)
-  } else {
-    const E = ExtractResolve(type, union)
-    return CloneType(E, options)
-  }
+export function Extract<L extends TSchema, R extends TSchema>(L: L, R: R, options: SchemaOptions = {}): TExtract<L, R> {
+  // prettier-ignore
+  return CloneType((
+    IsMappedResult(L) ? ExtractFromMappedResult(L, R, options) :
+    IsTemplateLiteral(L) ? Extract(TemplateLiteralToUnion(L), R) :
+    IsTemplateLiteral(R) ? Extract(L, TemplateLiteralToUnion(R) as any) :
+    IsUnion(L) ? ExtractRest(L.anyOf, R) :
+    ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never()
+  ), options) as never
 }
diff --git a/src/type/indexed/indexed-from-mapped-key.ts b/src/type/indexed/indexed-from-mapped-key.ts
index 76dc90e70..d32a11056 100644
--- a/src/type/indexed/indexed-from-mapped-key.ts
+++ b/src/type/indexed/indexed-from-mapped-key.ts
@@ -27,7 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import type { TSchema, SchemaOptions } from '../schema/index'
-import type { Evaluate } from '../helpers/index'
+import type { Ensure, Evaluate } from '../helpers/index'
 import type { TProperties } from '../object/index'
 import { Index, type TIndex } from './indexed'
 import { MappedResult, type TMappedResult, type TMappedKey } from '../mapped/index'
@@ -90,7 +90,7 @@ export type TIndexFromMappedKey<
   K extends TMappedKey, 
   P extends TProperties = TMappedIndexProperties<T, K>
 > = (
-  TMappedResult<P>
+  Ensure<TMappedResult<P>>
 )
 // prettier-ignore
 export function IndexFromMappedKey<
diff --git a/src/type/keyof/keyof-from-mapped-result.ts b/src/type/keyof/keyof-from-mapped-result.ts
index 8e10c66aa..d7edcd9ef 100644
--- a/src/type/keyof/keyof-from-mapped-result.ts
+++ b/src/type/keyof/keyof-from-mapped-result.ts
@@ -27,6 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import type { SchemaOptions } from '../schema/index'
+import type { Ensure, Evaluate } from '../helpers/index'
 import type { TProperties } from '../object/index'
 import { MappedResult, type TMappedResult } from '../mapped/index'
 import { KeyOf, type TKeyOf } from './keyof'
@@ -55,7 +56,7 @@ function FromProperties<
 type TFromMappedResult<
   R extends TMappedResult
 > = (
-  TFromProperties<R['properties']>
+  Evaluate<TFromProperties<R['properties']>>
 )
 // prettier-ignore
 function FromMappedResult<
@@ -71,7 +72,7 @@ export type TKeyOfFromMappedResult<
   R extends TMappedResult,
   P extends TProperties = TFromMappedResult<R>
 > = (
-  TMappedResult<P>
+  Ensure<TMappedResult<P>>
 )
 // prettier-ignore
 export function KeyOfFromMappedResult<
diff --git a/src/type/keyof/keyof.ts b/src/type/keyof/keyof.ts
index 5fcd4e51f..8e3b8fcde 100644
--- a/src/type/keyof/keyof.ts
+++ b/src/type/keyof/keyof.ts
@@ -45,16 +45,16 @@ import { IsMappedResult } from '../guard/type'
 // FromPropertyKeys
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromPropertyKeys<T extends PropertyKey[], Acc extends TSchema[] = []> = (
+export type TKeyOfPropertyKeysToRest<T extends PropertyKey[], Acc extends TSchema[] = []> = (
   T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
     ? L extends '[number]'
-      ? TFromPropertyKeys<R, [...Acc, TNumber]>
-      : TFromPropertyKeys<R, [...Acc, TLiteral<Assert<L, TLiteralValue>>]>
+      ? TKeyOfPropertyKeysToRest<R, [...Acc, TNumber]>
+      : TKeyOfPropertyKeysToRest<R, [...Acc, TLiteral<Assert<L, TLiteralValue>>]>
     : Acc
 )
 // prettier-ignore
-function FromPropertyKeys<T extends PropertyKey[]>(T: [...T]): TFromPropertyKeys<T> {
-  return T.map(L => L === '[number]' ? Number() : Literal(L as TLiteralValue)) as TFromPropertyKeys<T>
+export function KeyOfPropertyKeysToRest<T extends PropertyKey[]>(T: [...T]): TKeyOfPropertyKeysToRest<T> {
+  return T.map(L => L === '[number]' ? Number() : Literal(L as TLiteralValue)) as TKeyOfPropertyKeysToRest<T>
 }
 // ------------------------------------------------------------------
 // KeyOfTypeResolve
@@ -63,7 +63,7 @@ function FromPropertyKeys<T extends PropertyKey[]>(T: [...T]): TFromPropertyKeys
 export type TKeyOf<
   T extends TSchema, 
   K extends PropertyKey[] = TKeyOfPropertyKeys<T>,
-  S extends TSchema[] = TFromPropertyKeys<K>,
+  S extends TSchema[] = TKeyOfPropertyKeysToRest<K>,
   U = TUnionEvaluated<S>
 > = (
   Ensure<U>
@@ -78,7 +78,7 @@ export function KeyOf(T: TSchema, options: SchemaOptions = {}): any {
     return KeyOfFromMappedResult(T, options)
   } else {
     const K = KeyOfPropertyKeys(T)
-    const S = FromPropertyKeys(K)
+    const S = KeyOfPropertyKeysToRest(K)
     const U = UnionEvaluated(S)
     return CloneType(U, options)
   }
diff --git a/src/type/mapped/mapped.ts b/src/type/mapped/mapped.ts
index 0c6588b8b..6ab806bd0 100644
--- a/src/type/mapped/mapped.ts
+++ b/src/type/mapped/mapped.ts
@@ -241,19 +241,19 @@ function FromSchemaType<K extends PropertyKey, T extends TSchema>(K: K, T: T): F
   ) as FromSchemaType<K, T>
 }
 // ------------------------------------------------------------------
-// FromMappedFunctionReturnType
+// MappedFunctionReturnType
 // ------------------------------------------------------------------
 // prettier-ignore
-type FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema, Acc extends TProperties = {}> = (
+export type TMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema, Acc extends TProperties = {}> = (
   K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
-    ? FromMappedFunctionReturnType<R, T, Acc & { [_ in L]: FromSchemaType<L, T> }>
+    ? TMappedFunctionReturnType<R, T, Acc & { [_ in L]: FromSchemaType<L, T> }>
     : Acc
 )
 // prettier-ignore
-function FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T, Acc: TProperties = {}): FromMappedFunctionReturnType<K, T> {
+export function MappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T, Acc: TProperties = {}): TMappedFunctionReturnType<K, T> {
   return K.reduce((Acc, L) => {
     return { ...Acc, [L]: FromSchemaType(L, T) }
-  }, {} as TProperties) as FromMappedFunctionReturnType<K, T>
+  }, {} as TProperties) as TMappedFunctionReturnType<K, T>
 }
 // ------------------------------------------------------------------
 // TMappedFunction
@@ -267,7 +267,7 @@ export type TMappedFunction<K extends PropertyKey[], I = TMappedKey<K>> = (T: I)
 export type TMapped<
   K extends PropertyKey[], 
   F extends TMappedFunction<K>,
-  R extends TProperties = Evaluate<FromMappedFunctionReturnType<K, ReturnType<F>>>, 
+  R extends TProperties = Evaluate<TMappedFunctionReturnType<K, ReturnType<F>>>, 
 > = Ensure<TObject<R>>
 
 /** `[Json]` Creates a Mapped object type */
@@ -278,6 +278,6 @@ export function Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = T
 export function Mapped(key: any, map: Function, options: ObjectOptions = {}) {
   const K = IsSchema(key) ? IndexPropertyKeys(key) : (key as PropertyKey[])
   const RT = map({ [Kind]: 'MappedKey', keys: K } as TMappedKey)
-  const R = FromMappedFunctionReturnType(K, RT)
+  const R = MappedFunctionReturnType(K, RT)
   return CloneType(Object(R), options)
 }
diff --git a/src/type/omit/omit-from-mapped-result.ts b/src/type/omit/omit-from-mapped-result.ts
index d08f83f05..01327fe21 100644
--- a/src/type/omit/omit-from-mapped-result.ts
+++ b/src/type/omit/omit-from-mapped-result.ts
@@ -27,6 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import type { SchemaOptions } from '../schema/index'
+import type { Ensure, Evaluate } from '../helpers/index'
 import type { TProperties } from '../object/index'
 import { MappedResult, type TMappedResult } from '../mapped/index'
 import { Omit, type TOmit } from './omit'
@@ -58,7 +59,7 @@ type TFromMappedResult<
   R extends TMappedResult,
   K extends PropertyKey[],
 > = (
-  TFromProperties<R['properties'], K>
+  Evaluate<TFromProperties<R['properties'], K>>
 )
 // prettier-ignore
 function FromMappedResult<
@@ -76,7 +77,7 @@ export type TOmitFromMappedResult<
   K extends PropertyKey[],
   P extends TProperties = TFromMappedResult<T, K>
 > = (
-  TMappedResult<P>
+  Ensure<TMappedResult<P>>
 )
 // prettier-ignore
 export function OmitFromMappedResult<
diff --git a/src/type/partial/partial-from-mapped-result.ts b/src/type/partial/partial-from-mapped-result.ts
index 2681232e3..00f7338ac 100644
--- a/src/type/partial/partial-from-mapped-result.ts
+++ b/src/type/partial/partial-from-mapped-result.ts
@@ -27,6 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import type { SchemaOptions } from '../schema/index'
+import type { Ensure, Evaluate } from '../helpers/index'
 import type { TProperties } from '../object/index'
 import { MappedResult, type TMappedResult } from '../mapped/index'
 import { Partial, type TPartial } from './partial'
@@ -55,7 +56,7 @@ function FromProperties<
 type TFromMappedResult<
   R extends TMappedResult
 > = (
-  TFromProperties<R['properties']>
+  Evaluate<TFromProperties<R['properties']>>
 )
 // prettier-ignore
 function FromMappedResult<
@@ -71,7 +72,7 @@ export type TPartialFromMappedResult<
   R extends TMappedResult,
   P extends TProperties = TFromMappedResult<R>
 > = (
-  TMappedResult<P>
+  Ensure<TMappedResult<P>>
 )
 // prettier-ignore
 export function PartialFromMappedResult<
diff --git a/src/type/pick/pick-from-mapped-result.ts b/src/type/pick/pick-from-mapped-result.ts
index 4238fd3dc..bfa997a64 100644
--- a/src/type/pick/pick-from-mapped-result.ts
+++ b/src/type/pick/pick-from-mapped-result.ts
@@ -27,6 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import type { SchemaOptions } from '../schema/index'
+import type { Ensure, Evaluate } from '../helpers/index'
 import type { TProperties } from '../object/index'
 import { MappedResult, type TMappedResult } from '../mapped/index'
 import { Pick, type TPick } from './pick'
@@ -58,7 +59,7 @@ type TFromMappedResult<
   R extends TMappedResult,
   K extends PropertyKey[],
 > = (
-  TFromProperties<R['properties'], K>
+  Evaluate<TFromProperties<R['properties'], K>>
 )
 // prettier-ignore
 function FromMappedResult<
@@ -76,7 +77,7 @@ export type TPickFromMappedResult<
   K extends PropertyKey[],
   P extends TProperties = TFromMappedResult<T, K>
 > = (
-  TMappedResult<P>
+  Ensure<TMappedResult<P>>
 )
 // prettier-ignore
 export function PickFromMappedResult<
diff --git a/src/type/pick/pick.ts b/src/type/pick/pick.ts
index b746bf13b..976cba58e 100644
--- a/src/type/pick/pick.ts
+++ b/src/type/pick/pick.ts
@@ -50,7 +50,7 @@ import { IsMappedKey, IsMappedResult, IsIntersect, IsUnion, IsObject, IsSchema }
 // prettier-ignore
 type FromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = 
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? FromIntersect<R, K, [...Acc, PickResolve<L, K>]>
+    ? FromIntersect<R, K, [...Acc, TPickResolve<L, K>]>
     : Acc
 function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K) {
   return T.map((T) => PickResolve(T, K)) as FromIntersect<T, K>
@@ -61,7 +61,7 @@ function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K)
 // prettier-ignore
 type FromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = 
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? FromUnion<R, K, [...Acc, PickResolve<L, K>]>
+    ? FromUnion<R, K, [...Acc, TPickResolve<L, K>]>
     : Acc
 // prettier-ignore
 function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K) {
@@ -82,25 +82,25 @@ function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K:
 // PickResolve
 // ------------------------------------------------------------------
 // prettier-ignore
-export type PickResolve<T extends TProperties, K extends PropertyKey[]> = 
-  T extends TRecursive<infer S> ? TRecursive<PickResolve<S, K>> : 
+export type TPickResolve<T extends TProperties, K extends PropertyKey[]> = 
+  T extends TRecursive<infer S> ? TRecursive<TPickResolve<S, K>> : 
   T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : 
   T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : 
   T extends TObject<infer S> ? TObject<FromProperties<S, K>> : 
   TObject<{}>
 // prettier-ignore
-export function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): PickResolve<T, K> {
+export function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TPickResolve<T, K> {
   return (
     IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) : 
     IsUnion(T) ? Union(FromUnion(T.anyOf, K)) : 
     IsObject(T) ? Object(FromProperties(T.properties, K)) : 
     Object({})
-  ) as PickResolve<T, K>
+  ) as TPickResolve<T, K>
 }
 // ------------------------------------------------------------------
 // TPick
 // ------------------------------------------------------------------
-export type TPick<T extends TSchema, K extends PropertyKey[]> = PickResolve<T, K>
+export type TPick<T extends TSchema, K extends PropertyKey[]> = TPickResolve<T, K>
 
 /** `[Json]` Constructs a type whose keys are picked from the given type */
 export function Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>
diff --git a/src/type/required/required-from-mapped-result.ts b/src/type/required/required-from-mapped-result.ts
index b73554f1d..bcf5780bf 100644
--- a/src/type/required/required-from-mapped-result.ts
+++ b/src/type/required/required-from-mapped-result.ts
@@ -27,6 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import type { SchemaOptions } from '../schema/index'
+import type { Ensure, Evaluate } from '../helpers/index'
 import type { TProperties } from '../object/index'
 import { MappedResult, type TMappedResult } from '../mapped/index'
 import { Required, type TRequired } from './required'
@@ -55,7 +56,7 @@ function FromProperties<
 type TFromMappedResult<
   R extends TMappedResult
 > = (
-  TFromProperties<R['properties']>
+  Evaluate<TFromProperties<R['properties']>>
 )
 // prettier-ignore
 function FromMappedResult<
@@ -71,7 +72,7 @@ export type TRequiredFromMappedResult<
   R extends TMappedResult,
   P extends TProperties = TFromMappedResult<R>
 > = (
-  TMappedResult<P>
+  Ensure<TMappedResult<P>>
 )
 // prettier-ignore
 export function RequiredFromMappedResult<
diff --git a/src/type/static/static.ts b/src/type/static/static.ts
index 25a9083d1..488055c76 100644
--- a/src/type/static/static.ts
+++ b/src/type/static/static.ts
@@ -52,41 +52,41 @@ import type { TTransform } from '../transform/index'
 // DecodeType
 // ------------------------------------------------------------------
 // prettier-ignore
-export type DecodeProperties<T extends TProperties> = {
-  [K in keyof T]: DecodeType<T[K]>
+export type TDecodeProperties<T extends TProperties> = {
+  [K in keyof T]: TDecodeType<T[K]>
 }
 // prettier-ignore
-export type DecodeRest<T extends TSchema[], Acc extends TSchema[] = []> = 
+export type TDecodeRest<T extends TSchema[], Acc extends TSchema[] = []> = 
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? DecodeRest<R, [...Acc, DecodeType<L>]>
+    ? TDecodeRest<R, [...Acc, TDecodeType<L>]>
     : Acc
 // prettier-ignore
-export type DecodeType<T extends TSchema> = (
-  T extends TOptional<infer S extends TSchema> ? TOptional<DecodeType<S>> :
-  T extends TReadonly<infer S extends TSchema> ? TReadonly<DecodeType<S>> :
+export type TDecodeType<T extends TSchema> = (
+  T extends TOptional<infer S extends TSchema> ? TOptional<TDecodeType<S>> :
+  T extends TReadonly<infer S extends TSchema> ? TReadonly<TDecodeType<S>> :
   T extends TTransform<infer _, infer R> ? TUnsafe<R> :
-  T extends TArray<infer S extends TSchema> ? TArray<DecodeType<S>> :
-  T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> :
-  T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<DecodeRest<P>, DecodeType<R>> :
+  T extends TArray<infer S extends TSchema> ? TArray<TDecodeType<S>> :
+  T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<TDecodeType<S>> :
+  T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<TDecodeRest<P>, TDecodeType<R>> :
   T extends TEnum<infer S> ? TEnum<S> : // intercept for union. interior non decodable
-  T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<DecodeRest<P>, DecodeType<R>> :
-  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<DecodeRest<S>> :
-  T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> :
-  T extends TNot<infer S extends TSchema> ? TNot<DecodeType<S>> :
-  T extends TObject<infer S> ? TObject<Evaluate<DecodeProperties<S>>> :
-  T extends TPromise<infer S extends TSchema> ? TPromise<DecodeType<S>> :
-  T extends TRecord<infer K, infer S> ? TRecord<K, DecodeType<S>> :
-  T extends TRecursive<infer S extends TSchema> ? TRecursive<DecodeType<S>> :
-  T extends TRef<infer S extends TSchema> ? TRef<DecodeType<S>> :
-  T extends TTuple<infer S extends TSchema[]> ? TTuple<DecodeRest<S>> :
-  T extends TUnion<infer S extends TSchema[]> ? TUnion<DecodeRest<S>> :
+  T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<TDecodeRest<P>, TDecodeType<R>> :
+  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TDecodeRest<S>> :
+  T extends TIterator<infer S extends TSchema> ? TIterator<TDecodeType<S>> :
+  T extends TNot<infer S extends TSchema> ? TNot<TDecodeType<S>> :
+  T extends TObject<infer S> ? TObject<Evaluate<TDecodeProperties<S>>> :
+  T extends TPromise<infer S extends TSchema> ? TPromise<TDecodeType<S>> :
+  T extends TRecord<infer K, infer S> ? TRecord<K, TDecodeType<S>> :
+  T extends TRecursive<infer S extends TSchema> ? TRecursive<TDecodeType<S>> :
+  T extends TRef<infer S extends TSchema> ? TRef<TDecodeType<S>> :
+  T extends TTuple<infer S extends TSchema[]> ? TTuple<TDecodeRest<S>> :
+  T extends TUnion<infer S extends TSchema[]> ? TUnion<TDecodeRest<S>> :
   T
 )
 // ------------------------------------------------------------------
 // Static
 // ------------------------------------------------------------------
 /** Creates an decoded static type from a TypeBox type */
-export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<DecodeType<T>, P>
+export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<TDecodeType<T>, P>
 /** Creates an encoded static type from a TypeBox type */
 export type StaticEncode<T extends TSchema, P extends unknown[] = []> = Static<T, P>
 /** Creates a static type from a TypeBox type */
diff --git a/test/runtime/type/guard/exclude.ts b/test/runtime/type/guard/exclude.ts
index 78fbdfe32..88366678c 100644
--- a/test/runtime/type/guard/exclude.ts
+++ b/test/runtime/type/guard/exclude.ts
@@ -3,40 +3,40 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('type/guard/TExclude', () => {
-  it('Should extract string from number', () => {
+  it('Should exclude string from number', () => {
     const T = Type.Exclude(Type.String(), Type.Number())
     Assert.IsTrue(TypeGuard.IsString(T))
   })
-  it('Should extract string from string', () => {
+  it('Should exclude string from string', () => {
     const T = Type.Exclude(Type.String(), Type.String())
     Assert.IsTrue(TypeGuard.IsNever(T))
   })
-  it('Should extract string | number | boolean from string', () => {
+  it('Should exclude string | number | boolean from string', () => {
     const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
     Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsTrue(TypeGuard.IsNumber(T.anyOf[0]))
     Assert.IsTrue(TypeGuard.IsBoolean(T.anyOf[1]))
   })
-  it('Should extract string | number | boolean from string | boolean', () => {
+  it('Should exclude string | number | boolean from string | boolean', () => {
     const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Boolean()]))
     Assert.IsTrue(TypeGuard.IsNumber(T))
   })
   // ------------------------------------------------------------------------
   // TemplateLiteral | TemplateLiteral
   // ------------------------------------------------------------------------
-  it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
+  it('Should exclude TemplateLiteral | TemplateLiteral 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const T = Type.Exclude(A, B)
     Assert.IsTrue(TypeGuard.IsNever(T))
   })
-  it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
+  it('Should exclude TemplateLiteral | TemplateLiteral 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
     const T = Type.Exclude(A, B)
     Assert.IsTrue(['C'].includes(T.const))
   })
-  it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
+  it('Should exclude TemplateLiteral | TemplateLiteral 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
     const T = Type.Exclude(A, B)
@@ -46,19 +46,19 @@ describe('type/guard/TExclude', () => {
   // ------------------------------------------------------------------------
   // TemplateLiteral | Union 1
   // ------------------------------------------------------------------------
-  it('Should extract TemplateLiteral | Union 1', () => {
+  it('Should exclude TemplateLiteral | Union 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const T = Type.Exclude(A, B)
     Assert.IsTrue(TypeGuard.IsNever(T))
   })
-  it('Should extract TemplateLiteral | Union 1', () => {
+  it('Should exclude TemplateLiteral | Union 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.Union([Type.Literal('A'), Type.Literal('B')])
     const T = Type.Exclude(A, B)
     Assert.IsTrue(['C'].includes(T.const))
   })
-  it('Should extract TemplateLiteral | Union 1', () => {
+  it('Should exclude TemplateLiteral | Union 1', () => {
     const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const B = Type.Union([Type.Literal('A')])
     const T = Type.Exclude(A, B)
@@ -68,23 +68,29 @@ describe('type/guard/TExclude', () => {
   // ------------------------------------------------------------------------
   // Union | TemplateLiteral 1
   // ------------------------------------------------------------------------
-  it('Should extract Union | TemplateLiteral 1', () => {
+  it('Should exclude Union | TemplateLiteral 1', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
     const T = Type.Exclude(A, B)
     Assert.IsTrue(TypeGuard.IsNever(T))
   })
-  it('Should extract Union | TemplateLiteral 1', () => {
+  it('Should exclude Union | TemplateLiteral 1', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
     const T = Type.Exclude(A, B)
     Assert.IsTrue(['C'].includes(T.const))
   })
-  it('Should extract Union | TemplateLiteral 1', () => {
+  it('Should exclude Union | TemplateLiteral 1', () => {
     const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
     const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
     const T = Type.Exclude(A, B)
     Assert.IsTrue(['C', 'B'].includes(T.anyOf[0].const))
     Assert.IsTrue(['C', 'B'].includes(T.anyOf[1].const))
   })
+  it('Should exclude with options', () => {
+    const A = Type.String()
+    const B = Type.String()
+    const T = Type.Exclude(A, B, { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
 })
diff --git a/test/runtime/type/guard/extract.ts b/test/runtime/type/guard/extract.ts
index b3524d1e0..ffa7d8871 100644
--- a/test/runtime/type/guard/extract.ts
+++ b/test/runtime/type/guard/extract.ts
@@ -93,4 +93,10 @@ describe('type/guard/TExtract', () => {
     const T = Type.Extract(A, B)
     Assert.IsTrue(['A'].includes(T.const))
   })
+  it('Should extract with options', () => {
+    const A = Type.String()
+    const B = Type.String()
+    const T = Type.Extract(A, B, { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
 })
diff --git a/test/static/extract.ts b/test/static/extract.ts
index 4bd3dc833..0ed6a2a96 100644
--- a/test/static/extract.ts
+++ b/test/static/extract.ts
@@ -7,7 +7,7 @@ import { Expect } from './assert'
 }
 {
   const T = Type.Extract(Type.String(), Type.Number())
-  Expect(T).ToStatic<string>()
+  Expect(T).ToStaticNever()
 }
 {
   const T = Type.Extract(Type.Union([Type.Number(), Type.String(), Type.Boolean()]), Type.Number())

From ed234d02a3476177b962ed48e0d209483fbbdfbf Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 10 Jan 2024 12:51:02 +0900
Subject: [PATCH 225/369] Revision 0.32.6 (#725)

* Export Deref Infrastructure

* Remove Resolve type for Deref, Omit, Pick and Awaited

* Export Index Infrastructure

* Readme

* Reorder Template Literal Exports
---
 readme.md                   | 22 +++++++++++-----------
 src/index.ts                | 33 +++++++++++++++++++++++----------
 src/type/awaited/awaited.ts | 26 +++++++++++---------------
 src/type/deref/deref.ts     | 36 +++++++++++++++++-------------------
 src/type/indexed/indexed.ts | 24 ++++++++++++------------
 src/type/omit/omit.ts       | 25 +++++++++++--------------
 src/type/pick/pick.ts       | 26 +++++++++++---------------
 7 files changed, 96 insertions(+), 96 deletions(-)

diff --git a/readme.md b/readme.md
index d6671201b..26fd763b9 100644
--- a/readme.md
+++ b/readme.md
@@ -53,7 +53,7 @@ type T = Static<typeof T>                            // type T = {
 
 TypeBox is a runtime type builder that creates in-memory Json Schema objects that infer as TypeScript types. The schematics produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript and runtime asserted using standard Json Schema validation.
 
-This library is built to be a runtime type system offering similar capabilities to TypeScript's static type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.
+This library is designed to be a runtime type system providing similar capabilities to TypeScript's programmable type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.
 
 License MIT
 
@@ -648,7 +648,7 @@ TypeBox provides an extended type set that can be used to create schematics for
 
 ### Import
 
-Import the Type namespace to bring in TypeBox's full type system. This is recommended for most users.
+Import the Type namespace to bring in the full TypeBox type system. This is recommended for most users.
 
 ```typescript
 import { Type, type Static } from '@sinclair/typebox'
@@ -870,7 +870,7 @@ function test(node: Node) {
 
 ### Template Literal Types
 
-TypeBox supports template literal types with TemplateLiteral. This type can be created using a syntax similar to the TypeScript template literal syntax or composed from exterior types. TypeBox encodes template literals as regular expressions which enables the template to be checked by Json Schema validators. This type also supports regular expression parsing that enables template patterns to be used for generative types. The following shows both TypeScript and TypeBox usage.
+TypeBox supports template literal types with the TemplateLiteral function. This type can be created using a syntax similar to the TypeScript template literal syntax or composed from exterior types. TypeBox encodes template literals as regular expressions which enables the template to be checked by Json Schema validators. This type also supports regular expression parsing that enables template patterns to be used for generative types. The following shows both TypeScript and TypeBox usage.
 
 ```typescript
 // TypeScript
@@ -905,7 +905,7 @@ const R = Type.Record(K, Type.String())              // const R: TObject<{
 
 ### Indexed Access Types
 
-TypeBox supports indexed access types with Index. This type enables uniform access to interior property and element types without having to extract them from the underlying schema representation. This type is supported for Object, Array, Tuple, Union and Intersect types.
+TypeBox supports indexed access types with the Index function. This function enables uniform access to interior property and element types without having to extract them from the underlying schema representation. Index types are supported for Object, Array, Tuple, Union and Intersect types.
 
 ```typescript
 const T = Type.Object({                              // type T = {
@@ -944,7 +944,7 @@ const C = Type.Index(T, Type.KeyOf(T))               // type C = T[keyof T]
 
 ### Mapped Types
 
-TypeBox supports mapped object types with Mapped. This type accepts two arguments, the first is a union type typically derived from KeyOf, the second is a mapping function that receives a mapping key `K` that can be used to index properties of a type. The following implements Partial using mapped types.
+TypeBox supports mapped types with the Mapped function. This function accepts two arguments, the first is a union type typically derived from KeyOf, the second is a mapping function that receives a mapping key `K` that can be used to index properties of a type. The following implements a mapped type that remaps each property to be `T | null`
 
 ```typescript
 const T = Type.Object({                              // type T = {
@@ -953,14 +953,14 @@ const T = Type.Object({                              // type T = {
   z: Type.Boolean()                                  //   z: boolean
 })                                                   // }
 
-const M = Type.Mapped(Type.KeyOf(T), K => {          // type M = { [K in keyof T]?: T[K] }
-  return Type.Optional(Type.Index(T, K))             //
+const M = Type.Mapped(Type.KeyOf(T), K => {          // type M = { [K in keyof T]: T[K] | null }
+  return Type.Union([Type.Index(T, K), Type.Null()]) //
 })                                                   // ... evaluated as
                                                      // 
                                                      // const M: TObject<{
-                                                     //   x: TOptional<TNumber>,
-                                                     //   y: TOptional<TString>,
-                                                     //   z: TOptional<TBoolean>
+                                                     //   x: TUnion<[TNumber, TNull]>,
+                                                     //   y: TUnion<[TString, TNull]>,
+                                                     //   z: TUnion<[TBoolean, TNull]>
                                                      // }>
 ```
 
@@ -968,7 +968,7 @@ const M = Type.Mapped(Type.KeyOf(T), K => {          // type M = { [K in keyof T
 
 ### Conditional Types
 
-TypeBox supports runtime conditional types with Extends. This type performs a structural assignability check against the first (`left`) and second (`right`) arguments and will return either the third (`true`) or fourth (`false`) argument based on the result. The conditional types Exclude and Extract are also supported. The following shows both TypeScript and TypeBox examples of conditional types.
+TypeBox supports runtime conditional types with the Extends function. This function performs a structural assignability check against the first (`left`) and second (`right`) arguments and will return either the third (`true`) or fourth (`false`) argument based on the result. The conditional types Exclude and Extract are also supported. The following shows both TypeScript and TypeBox examples of conditional types.
 
 ```typescript
 // Extends
diff --git a/src/index.ts b/src/index.ts
index 4f582c5ca..b1b6ea791 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -41,7 +41,7 @@ export { TypeBoxError } from './type/error/index'
 export { Any, type TAny } from './type/any/index'
 export { Array, type TArray, type ArrayOptions } from './type/array/index'
 export { AsyncIterator, type TAsyncIterator } from './type/async-iterator/index'
-export { Awaited, type TAwaited, type TAwaitedResolve } from './type/awaited/index'
+export { Awaited, type TAwaited } from './type/awaited/index'
 export { BigInt, type TBigInt, type BigIntOptions } from './type/bigint/index'
 export { Boolean, type TBoolean } from './type/boolean/index'
 export { Composite, type TComposite } from './type/composite/index'
@@ -56,7 +56,20 @@ export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck, type TExte
 export { Extract, type TExtract, type TExtractFromMappedResult } from './type/extract/index'
 export { Function, type TFunction } from './type/function/index'
 export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index'
-export { Index, IndexPropertyKeys, IndexFromMappedKey, IndexFromMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult } from './type/indexed/index'
+export {
+  Index,
+  IndexPropertyKeys,
+  IndexFromPropertyKeys,
+  IndexFromPropertyKey,
+  IndexFromMappedKey,
+  IndexFromMappedResult,
+  type TIndex,
+  type TIndexPropertyKeys,
+  type TIndexFromPropertyKeys,
+  type TIndexFromPropertyKey,
+  type TIndexFromMappedKey,
+  type TIndexFromMappedResult,
+} from './type/indexed/index'
 export { InstanceType, type TInstanceType } from './type/instance-type/index'
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index'
 export { Intersect, IntersectEvaluated, type TIntersect, type TIntersectEvaluated, type IntersectOptions } from './type/intersect/index'
@@ -70,11 +83,11 @@ export { Not, type TNot } from './type/not/index'
 export { Null, type TNull } from './type/null/index'
 export { Number, type TNumber, type NumberOptions } from './type/number/index'
 export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index'
-export { Omit, type TOmit, type TOmitResolve, type TOmitFromMappedKey, type TOmitFromMappedResult } from './type/omit/index'
+export { Omit, type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from './type/omit/index'
 export { Optional, OptionalFromMappedResult, type TOptional, type TOptionalWithFlag, type TOptionalFromMappedResult } from './type/optional/index'
 export { Parameters, type TParameters } from './type/parameters/index'
 export { Partial, PartialFromMappedResult, type TPartial, type TPartialFromMappedResult } from './type/partial/index'
-export { Pick, type TPick, type TPickResolve, type TPickFromMappedKey, type TPickFromMappedResult } from './type/pick/index'
+export { Pick, type TPick, type TPickFromMappedKey, type TPickFromMappedResult } from './type/pick/index'
 export { Promise, type TPromise } from './type/promise/index'
 export { Readonly, ReadonlyFromMappedResult, type TReadonly, type TReadonlyWithFlag, type TReadonlyFromMappedResult } from './type/readonly/index'
 export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index'
@@ -92,18 +105,18 @@ export { String, type TString, type StringOptions, type StringFormatOption, type
 export { Symbol, type TSymbol, type TSymbolValue as SymbolValue } from './type/symbol/index'
 export {
   TemplateLiteral,
-  IsTemplateLiteralFinite,
-  IsTemplateLiteralExpressionFinite,
+  TemplateLiteralSyntax,
+  TemplateLiteralGenerate,
   TemplateLiteralParse,
   TemplateLiteralParseExact,
-  TemplateLiteralGenerate,
+  IsTemplateLiteralFinite,
   TemplateLiteralExpressionGenerate,
-  TemplateLiteralSyntax,
-  type TTemplateLiteralSyntax,
+  IsTemplateLiteralExpressionFinite,
   type TTemplateLiteral,
-  type TIsTemplateLiteralFinite,
+  type TTemplateLiteralSyntax,
   type TTemplateLiteralGenerate,
   type TTemplateLiteralKind,
+  type TIsTemplateLiteralFinite,
 } from './type/template-literal/index'
 export { Transform, TransformDecodeBuilder, TransformEncodeBuilder, type TTransform, type TransformOptions, type TransformFunction } from './type/transform/index'
 export { Tuple, type TTuple } from './type/tuple/index'
diff --git a/src/type/awaited/awaited.ts b/src/type/awaited/awaited.ts
index c782487fe..5c3fbb5a2 100644
--- a/src/type/awaited/awaited.ts
+++ b/src/type/awaited/awaited.ts
@@ -42,7 +42,7 @@ import { IsIntersect, IsUnion, IsPromise } from '../guard/type'
 // prettier-ignore
 type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> =
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TFromRest<R, [...Acc, TAwaitedResolve<L>]>
+    ? TFromRest<R, [...Acc, TAwaited<L>]>
     : Acc
 // prettier-ignore
 function FromRest<T extends TSchema[]>(T: [...T]) : TFromRest<T> {
@@ -69,37 +69,33 @@ function FromUnion<T extends TSchema[]>(T: [...T]): TFromUnion<T> {
 // ----------------------------------------------------------------
 // Promise
 // ----------------------------------------------------------------
-type TFromPromise<T extends TSchema> = TAwaitedResolve<T>
+type TFromPromise<T extends TSchema> = TAwaited<T>
 // prettier-ignore
 function FromPromise<T extends TSchema>(T: T): TFromPromise<T> {
   return AwaitedResolve(T) as TFromPromise<T>
 }
 // ----------------------------------------------------------------
-// FromSchema
+// AwaitedResolve
 // ----------------------------------------------------------------
 // prettier-ignore
-export type TAwaitedResolve<T extends TSchema> =
-  T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> :
-  T extends TUnion<infer S> ? TUnion<TFromRest<S>> :
-  T extends TPromise<infer S> ? TAwaitedResolve<S> :
-  T
-// prettier-ignore
-export function AwaitedResolve<T extends TSchema>(T: T): TAwaitedResolve<T> {
+function AwaitedResolve<T extends TSchema>(T: T): TAwaited<T> {
   return (
     IsIntersect(T) ? FromIntersect(T.allOf) :
     IsUnion(T) ? FromUnion(T.anyOf) :
     IsPromise(T) ? FromPromise(T.item) :
     T
-  ) as TAwaitedResolve<T>
+  ) as TAwaited<T>
 }
 // ------------------------------------------------------------------
 // TAwaited
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TAwaited<T extends TSchema> = (
-  TAwaitedResolve<T>
-)
+export type TAwaited<T extends TSchema> =
+  T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> :
+  T extends TUnion<infer S> ? TUnion<TFromRest<S>> :
+  T extends TPromise<infer S> ? TAwaited<S> :
+  T
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-export function Awaited<T extends TSchema>(T: T, options: SchemaOptions = {}): TAwaitedResolve<T> {
+export function Awaited<T extends TSchema>(T: T, options: SchemaOptions = {}): TAwaited<T> {
   return CloneType(AwaitedResolve(T), options)
 }
diff --git a/src/type/deref/deref.ts b/src/type/deref/deref.ts
index 2be22d90d..117de7564 100644
--- a/src/type/deref/deref.ts
+++ b/src/type/deref/deref.ts
@@ -53,7 +53,7 @@ import { IsConstructor, IsFunction, IsIntersect, IsUnion, IsTuple, IsArray, IsOb
 // prettier-ignore
 export type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-   ? TFromRest<R, [...Acc, DerefResolve<L>]>
+   ? TFromRest<R, [...Acc, TDeref<L>]>
    : Acc
 )
 function FromRest(schema: TSchema[], references: TSchema[]) {
@@ -64,7 +64,7 @@ function FromRest(schema: TSchema[], references: TSchema[]) {
 // ------------------------------------------------------------------
 // prettier-ignore
 type FromProperties<T extends TProperties> = Evaluate<{
-  [K in keyof T]: DerefResolve<T[K]>
+  [K in keyof T]: TDeref<T[K]>
 }>
 // prettier-ignore
 function FromProperties(properties: TProperties, references: TSchema[]) {
@@ -133,21 +133,7 @@ function FromRef(schema: TRef, references: TSchema[]) {
   return Deref(discard, references)
 }
 // prettier-ignore
-export type DerefResolve<T extends TSchema> =
-  T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<S>, DerefResolve<R>> :
-  T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<S>, DerefResolve<R>> :
-  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> :
-  T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> :
-  T extends TTuple<infer S extends TSchema[]> ? TTuple<TFromRest<S>> :
-  T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> :
-  T extends TArray<infer S extends TSchema> ? TArray<DerefResolve<S>> :
-  T extends TPromise<infer S extends TSchema> ? TPromise<DerefResolve<S>> :
-  T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DerefResolve<S>> :
-  T extends TIterator<infer S extends TSchema> ? TIterator<DerefResolve<S>> :
-  T extends TRef<infer S extends TSchema> ? DerefResolve<S> :
-  T
-// prettier-ignore
-export function DerefResolve<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>  {
+function DerefResolve<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>  {
   return (
     IsConstructor(schema) ? FromConstructor(schema, references) :
     IsFunction(schema) ? FromFunction(schema, references) :
@@ -163,11 +149,23 @@ export function DerefResolve<T extends TSchema>(schema: T, references: TSchema[]
     schema
   ) as TDeref<T> 
 }
+// prettier-ignore
+export type TDeref<T extends TSchema> =
+  T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<S>, TDeref<R>> :
+  T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<S>, TDeref<R>> :
+  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> :
+  T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> :
+  T extends TTuple<infer S extends TSchema[]> ? TTuple<TFromRest<S>> :
+  T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> :
+  T extends TArray<infer S extends TSchema> ? TArray<TDeref<S>> :
+  T extends TPromise<infer S extends TSchema> ? TPromise<TDeref<S>> :
+  T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<TDeref<S>> :
+  T extends TIterator<infer S extends TSchema> ? TIterator<TDeref<S>> :
+  T extends TRef<infer S extends TSchema> ? TDeref<S> :
+  T
 // ------------------------------------------------------------------
 // TDeref
 // ------------------------------------------------------------------
-export type TDeref<T extends TSchema> = DerefResolve<T>
-
 /** `[Json]` Creates a dereferenced type */
 export function Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T> {
   return DerefResolve(CloneType(schema), CloneRest(references))
diff --git a/src/type/indexed/indexed.ts b/src/type/indexed/indexed.ts
index 7b6e4dcf3..2589aeaf6 100644
--- a/src/type/indexed/indexed.ts
+++ b/src/type/indexed/indexed.ts
@@ -54,12 +54,12 @@ import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, I
 // prettier-ignore
 type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TFromRest<R, K, [...Acc, Assert<TFromKey<L, K>, TSchema>]>
+    ? TFromRest<R, K, [...Acc, Assert<TIndexFromPropertyKey<L, K>, TSchema>]>
     : Acc
 )
 // prettier-ignore
 function FromRest<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TFromRest<T, K> {
-  return T.map(L => FromKey(L, K)) as TFromRest<T, K>
+  return T.map(L => IndexFromPropertyKey(L, K)) as TFromRest<T, K>
 }
 // ------------------------------------------------------------------
 // FromIntersectRest
@@ -168,8 +168,8 @@ function FromProperty<T extends TProperties, K extends PropertyKey>(T: T, K: K):
 // FromKey
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromKey<T extends TSchema, K extends PropertyKey> = (
-  T extends TRecursive<infer S> ? TFromKey<S, K> :
+export type TIndexFromPropertyKey<T extends TSchema, K extends PropertyKey> = (
+  T extends TRecursive<infer S> ? TIndexFromPropertyKey<S, K> :
   T extends TIntersect<infer S> ? TFromIntersect<S, K> :
   T extends TUnion<infer S> ? TFromUnion<S, K> :
   T extends TTuple<infer S> ? TFromTuple<S, K> :
@@ -178,7 +178,7 @@ type TFromKey<T extends TSchema, K extends PropertyKey> = (
   TNever
 )
 // prettier-ignore
-function FromKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): TFromKey<T, K> {
+export function IndexFromPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): TIndexFromPropertyKey<T, K> {
   return (
     IsIntersect(T) ? FromIntersect(T.allOf, K) :
     IsUnion(T) ? FromUnion(T.anyOf, K) :
@@ -186,32 +186,32 @@ function FromKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): TFromKey
     IsArray(T) ? FromArray(T.items, K) :
     IsObject(T) ? FromProperty(T.properties, K) :
     Never()
-  ) as TFromKey<T, K>
+  ) as TIndexFromPropertyKey<T, K>
 }
 // ------------------------------------------------------------------
 // FromKeys
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromKeys<T extends TSchema, K extends PropertyKey[], Acc extends TSchema[] = []> = (
+export type TIndexFromPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TSchema[] = []> = (
   K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
-    ? TFromKeys<T, R, [...Acc, Assert<TFromKey<T, L>, TSchema>]>
+    ? TIndexFromPropertyKeys<T, R, [...Acc, Assert<TIndexFromPropertyKey<T, L>, TSchema>]>
     : Acc
 )
 // prettier-ignore
-function FromKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TFromKeys<T, K> {
-  return K.map(L => FromKey(T, L)) as TFromKeys<T, K>
+export function IndexFromPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TIndexFromPropertyKeys<T, K> {
+  return K.map(L => IndexFromPropertyKey(T, L)) as TIndexFromPropertyKeys<T, K>
 }
 // ------------------------------------------------------------------
 // FromSchema
 // ------------------------------------------------------------------
 // prettier-ignore
 type FromSchema<T extends TSchema, K extends PropertyKey[]> = (
-  TUnionEvaluated<TFromKeys<T, K>>
+  TUnionEvaluated<TIndexFromPropertyKeys<T, K>>
 )
 // prettier-ignore
 function FromSchema<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromSchema<T, K> {
   return (
-    UnionEvaluated(FromKeys(T, K as PropertyKey[]))
+    UnionEvaluated(IndexFromPropertyKeys(T, K as PropertyKey[]))
   ) as FromSchema<T, K>
 }
 // ------------------------------------------------------------------
diff --git a/src/type/omit/omit.ts b/src/type/omit/omit.ts
index 5de3f15f6..5c5ae73b2 100644
--- a/src/type/omit/omit.ts
+++ b/src/type/omit/omit.ts
@@ -51,7 +51,7 @@ import { IsMappedKey, IsIntersect, IsUnion, IsObject, IsSchema, IsMappedResult }
 // prettier-ignore
 type TFromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]] 
-    ? TFromIntersect<R, K, [...Acc, TOmitResolve<L, K>]>
+    ? TFromIntersect<R, K, [...Acc, TOmit<L, K>]>
     : Acc
 )
 // prettier-ignore
@@ -64,7 +64,7 @@ function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K)
 // prettier-ignore
 type TFromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]] 
-    ? TFromUnion<R, K, [...Acc, TOmitResolve<L, K>]>
+    ? TFromUnion<R, K, [...Acc, TOmit<L, K>]>
     : Acc
 )
 // prettier-ignore
@@ -91,27 +91,24 @@ function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K:
 // OmitResolve
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TOmitResolve<T extends TProperties, K extends PropertyKey[]> = 
-  T extends TRecursive<infer S> ? TRecursive<TOmitResolve<S, K>> : 
-  T extends TIntersect<infer S> ? TIntersect<TFromIntersect<S, K>> : 
-  T extends TUnion<infer S> ? TUnion<TFromUnion<S, K>> : 
-  T extends TObject<infer S> ? TObject<TFromProperties<S, K>> : 
-  TObject<{}>
-// prettier-ignore
-export function OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TOmitResolve<T, K> {
+function OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TOmit<T, K> {
   return (
     IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) : 
     IsUnion(T) ? Union(FromUnion(T.anyOf, K)) : 
     IsObject(T) ? Object(FromProperties(T.properties, K)) : 
     Object({})
-  ) as TOmitResolve<T, K>
+  ) as TOmit<T, K>
 }
+// prettier-ignore
+export type TOmit<T extends TProperties, K extends PropertyKey[]> = 
+  T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> : 
+  T extends TIntersect<infer S> ? TIntersect<TFromIntersect<S, K>> : 
+  T extends TUnion<infer S> ? TUnion<TFromUnion<S, K>> : 
+  T extends TObject<infer S> ? TObject<TFromProperties<S, K>> : 
+  TObject<{}>
 // ------------------------------------------------------------------
 // TOmit
 // ------------------------------------------------------------------
-// prettier-ignore
-export type TOmit<T extends TSchema, K extends PropertyKey[]> = TOmitResolve<T, K>
-
 /** `[Json]` Constructs a type whose keys are omitted from the given type */
 export function Omit<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TOmitFromMappedResult<T, K>
 /** `[Json]` Constructs a type whose keys are omitted from the given type */
diff --git a/src/type/pick/pick.ts b/src/type/pick/pick.ts
index 976cba58e..c35b401ce 100644
--- a/src/type/pick/pick.ts
+++ b/src/type/pick/pick.ts
@@ -50,7 +50,7 @@ import { IsMappedKey, IsMappedResult, IsIntersect, IsUnion, IsObject, IsSchema }
 // prettier-ignore
 type FromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = 
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? FromIntersect<R, K, [...Acc, TPickResolve<L, K>]>
+    ? FromIntersect<R, K, [...Acc, TPick<L, K>]>
     : Acc
 function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K) {
   return T.map((T) => PickResolve(T, K)) as FromIntersect<T, K>
@@ -61,7 +61,7 @@ function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K)
 // prettier-ignore
 type FromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = 
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? FromUnion<R, K, [...Acc, TPickResolve<L, K>]>
+    ? FromUnion<R, K, [...Acc, TPick<L, K>]>
     : Acc
 // prettier-ignore
 function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K) {
@@ -82,25 +82,21 @@ function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K:
 // PickResolve
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TPickResolve<T extends TProperties, K extends PropertyKey[]> = 
-  T extends TRecursive<infer S> ? TRecursive<TPickResolve<S, K>> : 
-  T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : 
-  T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : 
-  T extends TObject<infer S> ? TObject<FromProperties<S, K>> : 
-  TObject<{}>
-// prettier-ignore
-export function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TPickResolve<T, K> {
+function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TPick<T, K> {
   return (
     IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) : 
     IsUnion(T) ? Union(FromUnion(T.anyOf, K)) : 
     IsObject(T) ? Object(FromProperties(T.properties, K)) : 
     Object({})
-  ) as TPickResolve<T, K>
+  ) as TPick<T, K>
 }
-// ------------------------------------------------------------------
-// TPick
-// ------------------------------------------------------------------
-export type TPick<T extends TSchema, K extends PropertyKey[]> = TPickResolve<T, K>
+// prettier-ignore
+export type TPick<T extends TProperties, K extends PropertyKey[]> = 
+  T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> : 
+  T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : 
+  T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : 
+  T extends TObject<infer S> ? TObject<FromProperties<S, K>> : 
+  TObject<{}>
 
 /** `[Json]` Constructs a type whose keys are picked from the given type */
 export function Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>

From 8e1bc047fbfb015004ccdf32f6b1f87718bdab4d Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 10 Jan 2024 20:02:08 +0900
Subject: [PATCH 226/369] Revision 0.32.7 (#727)

- Clone Default Annotation on Assignment
---
 package-lock.json                    |  4 ++--
 package.json                         |  2 +-
 src/value/default/default.ts         |  3 ++-
 test/runtime/value/default/object.ts | 34 +++++++++++++++++++++++++++-
 4 files changed, 38 insertions(+), 5 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 154b955ce..f0b5b839d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.6",
+  "version": "0.32.7",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.6",
+      "version": "0.32.7",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index afe9e95fc..ba8a22890 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.6",
+  "version": "0.32.7",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/default/default.ts b/src/value/default/default.ts
index afeea9cd2..b84ce005f 100644
--- a/src/value/default/default.ts
+++ b/src/value/default/default.ts
@@ -27,6 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { Check } from '../check/index'
+import { Clone } from '../clone/index'
 import { Deref } from '../deref/index'
 import { Kind } from '../../type/symbols/index'
 
@@ -52,7 +53,7 @@ import { IsSchema } from '../../type/guard/type'
 // ValueOrDefault
 // ------------------------------------------------------------------
 function ValueOrDefault(schema: TSchema, value: unknown) {
-  return !(value === undefined) || !('default' in schema) ? value : schema.default
+  return value === undefined && 'default' in schema ? Clone(schema.default) : value
 }
 // ------------------------------------------------------------------
 // IsCheckable
diff --git a/test/runtime/value/default/object.ts b/test/runtime/value/default/object.ts
index ab4dda473..1accf40ee 100644
--- a/test/runtime/value/default/object.ts
+++ b/test/runtime/value/default/object.ts
@@ -1,5 +1,5 @@
 import { Value } from '@sinclair/typebox/value'
-import { Type } from '@sinclair/typebox'
+import { Type, CloneType } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/default/Object', () => {
@@ -177,4 +177,36 @@ describe('value/default/Object', () => {
     const R = Value.Default(T, { x: null, y: null, z: undefined })
     Assert.IsEqual(R, { x: null, y: null, z: undefined })
   })
+  // ----------------------------------------------------------------
+  // Mutation
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/726
+  it('Should retain defaults on operation', () => {
+    const A = Type.Object({
+      a: Type.Object(
+        {
+          b: Type.Array(Type.String(), { default: [] }),
+        },
+        { default: {} },
+      ),
+    })
+    const value = Value.Default(A, {})
+    Assert.IsEqual(value, { a: { b: [] } })
+    Assert.IsEqual(A.properties.a.default, {})
+    Assert.IsEqual(A.properties.a.properties.b.default, [])
+  })
+  // https://github.com/sinclairzx81/typebox/issues/726
+  it('Should retain schematics on operation', () => {
+    const A = Type.Object({
+      a: Type.Object(
+        {
+          b: Type.Array(Type.String(), { default: [] }),
+        },
+        { default: {} },
+      ),
+    })
+    const B = CloneType(A)
+    Value.Default(A, {})
+    Assert.IsEqual(A, B)
+  })
 })

From 7ea295676350b286b23be213936340e95118d92d Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 10 Jan 2024 21:01:39 +0900
Subject: [PATCH 227/369] Revision 0.32.8 (#728)

- Clone Default Annotation on Assignment
---
 package-lock.json                   |  4 +-
 package.json                        |  2 +-
 src/value/cast/cast.ts              |  2 +-
 src/value/create/create.ts          | 77 ++++++++++++++++-------------
 test/runtime/value/create/object.ts | 15 ++++++
 5 files changed, 61 insertions(+), 39 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index f0b5b839d..2fabd94e0 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.7",
+  "version": "0.32.8",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.7",
+      "version": "0.32.8",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index ba8a22890..b291d5ecb 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.7",
+  "version": "0.32.8",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/cast/cast.ts b/src/value/cast/cast.ts
index afe8bd74f..cadbaf72a 100644
--- a/src/value/cast/cast.ts
+++ b/src/value/cast/cast.ts
@@ -92,7 +92,7 @@ function SelectUnion(union: TUnion, references: TSchema[], value: any): TSchema
 }
 function CastUnion(union: TUnion, references: TSchema[], value: any) {
   if ('default' in union) {
-    return union.default
+    return typeof value === 'function' ? union.default : Clone(union.default)
   } else {
     const schema = SelectUnion(union, references, value)
     return Cast(schema, references, value)
diff --git a/src/value/create/create.ts b/src/value/create/create.ts
index 697a37234..2b2ef63ea 100644
--- a/src/value/create/create.ts
+++ b/src/value/create/create.ts
@@ -28,6 +28,7 @@ THE SOFTWARE.
 
 import { HasPropertyKey, IsString } from '../guard/index'
 import { Check } from '../check/index'
+import { Clone } from '../clone/index'
 import { Deref } from '../deref/index'
 import { TemplateLiteralGenerate, IsTemplateLiteralFinite } from '../../type/template-literal/index'
 import { PatternStringExact, PatternNumberExact } from '../../type/patterns/index'
@@ -78,11 +79,17 @@ export class ValueCreateError extends TypeBoxError {
   }
 }
 // ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
+function FromDefault(value: unknown) {
+  return typeof value === 'function' ? value : Clone(value)
+}
+// ------------------------------------------------------------------
 // Create
 // ------------------------------------------------------------------
 function FromAny(schema: TAny, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     return {}
   }
@@ -93,7 +100,7 @@ function FromArray(schema: TArray, references: TSchema[]): any {
   } else if ('contains' in schema && !HasPropertyKey(schema, 'default')) {
     throw new ValueCreateError(schema, 'Array with the contains constraint requires a default value')
   } else if ('default' in schema) {
-    return schema.default
+    return FromDefault(schema.default)
   } else if (schema.minItems !== undefined) {
     return Array.from({ length: schema.minItems }).map((item) => {
       return Visit(schema.items, references)
@@ -104,28 +111,28 @@ function FromArray(schema: TArray, references: TSchema[]): any {
 }
 function FromAsyncIterator(schema: TAsyncIterator, references: TSchema[]) {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     return (async function* () {})()
   }
 }
 function FromBigInt(schema: TBigInt, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     return BigInt(0)
   }
 }
 function FromBoolean(schema: TBoolean, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     return false
   }
 }
 function FromConstructor(schema: TConstructor, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     const value = Visit(schema.returns, references) as any
     if (typeof value === 'object' && !Array.isArray(value)) {
@@ -144,7 +151,7 @@ function FromConstructor(schema: TConstructor, references: TSchema[]): any {
 }
 function FromDate(schema: TDate, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else if (schema.minimumTimestamp !== undefined) {
     return new Date(schema.minimumTimestamp)
   } else {
@@ -153,14 +160,14 @@ function FromDate(schema: TDate, references: TSchema[]): any {
 }
 function FromFunction(schema: TFunction, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     return () => Visit(schema.returns, references)
   }
 }
 function FromInteger(schema: TInteger, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else if (schema.minimum !== undefined) {
     return schema.minimum
   } else {
@@ -169,7 +176,7 @@ function FromInteger(schema: TInteger, references: TSchema[]): any {
 }
 function FromIntersect(schema: TIntersect, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     // --------------------------------------------------------------
     // Note: The best we can do here is attempt to instance each
@@ -188,42 +195,42 @@ function FromIntersect(schema: TIntersect, references: TSchema[]): any {
 }
 function FromIterator(schema: TIterator, references: TSchema[]) {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     return (function* () {})()
   }
 }
 function FromLiteral(schema: TLiteral, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     return schema.const
   }
 }
 function FromNever(schema: TNever, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     throw new ValueCreateError(schema, 'Never types cannot be created. Consider using a default value.')
   }
 }
 function FromNot(schema: TNot, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     throw new ValueCreateError(schema, 'Not types must have a default value')
   }
 }
 function FromNull(schema: TNull, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     return null
   }
 }
 function FromNumber(schema: TNumber, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else if (schema.minimum !== undefined) {
     return schema.minimum
   } else {
@@ -232,11 +239,11 @@ function FromNumber(schema: TNumber, references: TSchema[]): any {
 }
 function FromObject(schema: TObject, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     const required = new Set(schema.required)
     return (
-      schema.default ||
+      FromDefault(schema.default) ||
       Object.entries(schema.properties).reduce((acc, [key, schema]) => {
         return required.has(key) ? { ...acc, [key]: Visit(schema, references) } : { ...acc }
       }, {})
@@ -245,7 +252,7 @@ function FromObject(schema: TObject, references: TSchema[]): any {
 }
 function FromPromise(schema: TPromise, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     return Promise.resolve(Visit(schema.item, references))
   }
@@ -253,7 +260,7 @@ function FromPromise(schema: TPromise, references: TSchema[]): any {
 function FromRecord(schema: TRecord, references: TSchema[]): any {
   const [keyPattern, valueSchema] = Object.entries(schema.patternProperties)[0]
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else if (!(keyPattern === PatternStringExact || keyPattern === PatternNumberExact)) {
     const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|')
     return propertyKeys.reduce((acc, key) => {
@@ -265,14 +272,14 @@ function FromRecord(schema: TRecord, references: TSchema[]): any {
 }
 function FromRef(schema: TRef, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     return Visit(Deref(schema, references), references)
   }
 }
 function FromRegExp(schema: TRegExp, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     throw new ValueCreateError(schema, 'RegExp types cannot be created. Consider using a default value.')
   }
@@ -282,17 +289,17 @@ function FromString(schema: TString, references: TSchema[]): any {
     if (!HasPropertyKey(schema, 'default')) {
       throw new ValueCreateError(schema, 'String types with patterns must specify a default value')
     } else {
-      return schema.default
+      return FromDefault(schema.default)
     }
   } else if (schema.format !== undefined) {
     if (!HasPropertyKey(schema, 'default')) {
       throw new ValueCreateError(schema, 'String types with formats must specify a default value')
     } else {
-      return schema.default
+      return FromDefault(schema.default)
     }
   } else {
     if (HasPropertyKey(schema, 'default')) {
-      return schema.default
+      return FromDefault(schema.default)
     } else if (schema.minLength !== undefined) {
       // prettier-ignore
       return Array.from({ length: schema.minLength }).map(() => ' ').join('')
@@ -303,7 +310,7 @@ function FromString(schema: TString, references: TSchema[]): any {
 }
 function FromSymbol(schema: TSymbol, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else if ('value' in schema) {
     return Symbol.for(schema.value)
   } else {
@@ -312,7 +319,7 @@ function FromSymbol(schema: TSymbol, references: TSchema[]): any {
 }
 function FromTemplateLiteral(schema: TTemplateLiteral, references: TSchema[]) {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   }
   if (!IsTemplateLiteralFinite(schema)) throw new ValueCreateError(schema, 'Can only create template literals that produce a finite variants. Consider using a default value.')
   const generated = TemplateLiteralGenerate(schema) as string[]
@@ -321,14 +328,14 @@ function FromTemplateLiteral(schema: TTemplateLiteral, references: TSchema[]) {
 function FromThis(schema: TThis, references: TSchema[]): any {
   if (recursiveDepth++ > recursiveMaxDepth) throw new ValueCreateError(schema, 'Cannot create recursive type as it appears possibly infinite. Consider using a default.')
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     return Visit(Deref(schema, references), references)
   }
 }
 function FromTuple(schema: TTuple, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   }
   if (schema.items === undefined) {
     return []
@@ -338,14 +345,14 @@ function FromTuple(schema: TTuple, references: TSchema[]): any {
 }
 function FromUndefined(schema: TUndefined, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     return undefined
   }
 }
 function FromUnion(schema: TUnion, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else if (schema.anyOf.length === 0) {
     throw new Error('ValueCreate.Union: Cannot create Union with zero variants')
   } else {
@@ -354,7 +361,7 @@ function FromUnion(schema: TUnion, references: TSchema[]): any {
 }
 function FromUint8Array(schema: TUint8Array, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else if (schema.minByteLength !== undefined) {
     return new Uint8Array(schema.minByteLength)
   } else {
@@ -363,21 +370,21 @@ function FromUint8Array(schema: TUint8Array, references: TSchema[]): any {
 }
 function FromUnknown(schema: TUnknown, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     return {}
   }
 }
 function FromVoid(schema: TVoid, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     return void 0
   }
 }
 function FromKind(schema: TSchema, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
-    return schema.default
+    return FromDefault(schema.default)
   } else {
     throw new Error('User defined types must specify a default value')
   }
diff --git a/test/runtime/value/create/object.ts b/test/runtime/value/create/object.ts
index 0d2ed1cad..e915a142b 100644
--- a/test/runtime/value/create/object.ts
+++ b/test/runtime/value/create/object.ts
@@ -68,4 +68,19 @@ describe('value/create/Object', () => {
       z: 3,
     })
   })
+  // ----------------------------------------------------------------
+  // Mutation
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/726
+  it('Should clone defaults on assignment - no mutation', () => {
+    const T = Type.Object(
+      {
+        x: Type.Number(),
+      },
+      { default: { x: 1 } },
+    )
+    const V = Value.Create(T)
+    V.x = 123
+    Assert.IsEqual(T.default, { x: 1 })
+  })
 })

From 839967d4399ec9a0480e41d4020e1bddd6c838ae Mon Sep 17 00:00:00 2001
From: karanssj4 <karan95raina@gmail.com>
Date: Thu, 11 Jan 2024 19:27:59 +0530
Subject: [PATCH 228/369] Documentation (#730)

- Update readme.md - minor rephrasing
---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 26fd763b9..c25440666 100644
--- a/readme.md
+++ b/readme.md
@@ -1814,4 +1814,4 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 
 ## Contribute
 
-TypeBox is open to community contribution. Please ensure you submit an open issue before submitting your pull request. The TypeBox project preferences open community discussion prior to accepting new features.
+TypeBox is open to community contribution. Please ensure you submit an open issue before submitting your pull request. The TypeBox project prefers open community discussion before accepting new features.

From 9adcb58f22eb77d6c86963bbb680d960f5f271fd Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Fri, 12 Jan 2024 13:28:06 +0900
Subject: [PATCH 229/369] Documentation

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index c25440666..9dc77a5cc 100644
--- a/readme.md
+++ b/readme.md
@@ -53,7 +53,7 @@ type T = Static<typeof T>                            // type T = {
 
 TypeBox is a runtime type builder that creates in-memory Json Schema objects that infer as TypeScript types. The schematics produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript and runtime asserted using standard Json Schema validation.
 
-This library is designed to be a runtime type system providing similar capabilities to TypeScript's programmable type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.
+This library is designed to allow Json Schema to compose with the same flexibility as TypeScript's programmable type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.
 
 License MIT
 

From dcf48f3232a93ea7d8c8224a2ba0a8789e9a8cf7 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 13 Jan 2024 00:01:44 +0900
Subject: [PATCH 230/369] Revision 0.32.9 (#731)

* Optimize Composite

* Set and Composite Tests

* Version
---
 example/typedef/typedef.ts             |   2 +-
 package-lock.json                      |   4 +-
 package.json                           |   2 +-
 src/index.ts                           |  33 ++++-
 src/type/composite/composite.ts        | 101 +++++++++++----
 src/type/helpers/helpers.ts            |   6 +-
 src/type/keyof/keyof-property-keys.ts  |  20 +--
 src/type/sets/set.ts                   |  50 +++++---
 src/type/type/json.ts                  |   4 +-
 test/runtime/compiler-ajv/composite.ts |  17 +++
 test/runtime/compiler/composite.ts     |  17 +++
 test/runtime/type/guard/composite.ts   | 111 +++++++++++++++-
 test/runtime/type/index.ts             |   1 +
 test/runtime/type/sets/index.ts        |   1 +
 test/runtime/type/sets/sets.ts         | 167 +++++++++++++++++++++++++
 test/static/composite.ts               |  59 ++++++++-
 16 files changed, 528 insertions(+), 67 deletions(-)
 create mode 100644 test/runtime/type/sets/index.ts
 create mode 100644 test/runtime/type/sets/sets.ts

diff --git a/example/typedef/typedef.ts b/example/typedef/typedef.ts
index 7a86b77d7..6682e5e38 100644
--- a/example/typedef/typedef.ts
+++ b/example/typedef/typedef.ts
@@ -56,7 +56,7 @@ export interface TBoolean extends Types.TSchema {
 // --------------------------------------------------------------------------
 export type InferUnion<T extends TStruct[], D extends string, Index = string> = 
   T extends [infer L extends TStruct, ...infer R extends TStruct[]]
-    ? Types.Evaluate<{ [_ in D]: Index } & Types.Static<L>> | InferUnion<R, D, Types.Increment<Types.Assert<Index, string>>>
+    ? Types.Evaluate<{ [_ in D]: Index } & Types.Static<L>> | InferUnion<R, D, Types.TIncrement<Types.Assert<Index, string>>>
     : never
 
 export interface TUnion<T extends TStruct[] = TStruct[], D extends string = string> extends Types.TSchema {
diff --git a/package-lock.json b/package-lock.json
index 2fabd94e0..79f26077e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.8",
+  "version": "0.32.9",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.8",
+      "version": "0.32.9",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index b291d5ecb..6a27860cb 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.8",
+  "version": "0.32.9",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/index.ts b/src/index.ts
index b1b6ea791..cfcd03abe 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -34,9 +34,37 @@ export { PatternBoolean, PatternBooleanExact, PatternNumber, PatternNumberExact,
 export { TypeRegistry, FormatRegistry } from './type/registry/index'
 export { TypeGuard, ValueGuard } from './type/guard/index'
 export { CloneType, CloneRest } from './type/clone/type'
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
 export { TypeBoxError } from './type/error/index'
 // ------------------------------------------------------------------
-// Type
+// Sets
+// ------------------------------------------------------------------
+export {
+  SetComplement,
+  SetDistinct,
+  SetIncludes,
+  SetIntersect,
+  SetIntersectMany,
+  SetIsSubset,
+  SetUnion,
+  SetUnionMany,
+  type TSetComplement,
+  type TSetDistinct,
+  type TSetIncludes,
+  type TSetIntersect,
+  type TSetIntersectMany,
+  type TSetIsSubset,
+  type TSetUnion,
+  type TSetUnionMany,
+} from './type/sets/index'
+// ------------------------------------------------------------------
+// Helpers
+// ------------------------------------------------------------------
+export { Increment, type TIncrement, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index'
+// ------------------------------------------------------------------
+// Types
 // ------------------------------------------------------------------
 export { Any, type TAny } from './type/any/index'
 export { Array, type TArray, type ArrayOptions } from './type/array/index'
@@ -55,7 +83,6 @@ export { Exclude, type TExclude, type TExcludeFromMappedResult } from './type/ex
 export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey } from './type/extends/index'
 export { Extract, type TExtract, type TExtractFromMappedResult } from './type/extract/index'
 export { Function, type TFunction } from './type/function/index'
-export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index'
 export {
   Index,
   IndexPropertyKeys,
@@ -102,7 +129,7 @@ export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from '.
 export { type Static, type StaticDecode, type StaticEncode, type TDecodeType, type TDecodeRest, type TDecodeProperties } from './type/static/index'
 export { Strict } from './type/strict/index'
 export { String, type TString, type StringOptions, type StringFormatOption, type StringContentEncodingOption } from './type/string/index'
-export { Symbol, type TSymbol, type TSymbolValue as SymbolValue } from './type/symbol/index'
+export { Symbol, type TSymbol, type TSymbolValue } from './type/symbol/index'
 export {
   TemplateLiteral,
   TemplateLiteralSyntax,
diff --git a/src/type/composite/composite.ts b/src/type/composite/composite.ts
index b4dc847fa..b37ccb613 100644
--- a/src/type/composite/composite.ts
+++ b/src/type/composite/composite.ts
@@ -27,44 +27,95 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import type { TSchema } from '../schema/index'
-import type { UnionToTuple, Assert, Ensure, Evaluate } from '../helpers/index'
+import type { Evaluate } from '../helpers/index'
+import { IntersectEvaluated, type TIntersectEvaluated } from '../intersect/index'
+import { IndexFromPropertyKeys, type TIndexFromPropertyKeys } from '../indexed/index'
+import { KeyOfPropertyKeys, type TKeyOfPropertyKeys } from '../keyof/index'
+import { type TNever } from '../never/index'
 import { Object, type TObject, type TProperties, type ObjectOptions } from '../object/index'
-import { Intersect, type TIntersect } from '../intersect/index'
-import { Index, type TIndex } from '../indexed/index'
-import { KeyOfPropertyKeys } from '../keyof/index'
+import { SetDistinct, TSetDistinct } from '../sets/index'
 
 // ------------------------------------------------------------------
-// TCompositeKeys
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsNever } from '../guard/type'
+// ------------------------------------------------------------------
+// CompositeKeys
 // ------------------------------------------------------------------
 // prettier-ignore
-type TCompositeKeys<T extends TObject[], Acc extends PropertyKey = never> =
-  T extends [infer L extends TObject, ...infer R extends TObject[]]
-    ? TCompositeKeys<R, Acc | keyof L['properties']>
+type TCompositeKeys<T extends TSchema[], Acc extends PropertyKey[] = []> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TCompositeKeys<R, TSetDistinct<[...Acc, ...TKeyOfPropertyKeys<L>]>>
     : Acc
+)
+// prettier-ignore
+function CompositeKeys<T extends TSchema[]>(T: [...T]): TCompositeKeys<T> {
+  return T.reduce((Acc, L) => {
+    return SetDistinct([...Acc, ...KeyOfPropertyKeys(L)]) as never
+  }, []) as never
+}
+// ------------------------------------------------------------------
+// FilterNever
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFilterNever<T extends TSchema[], Acc extends TSchema[] = []> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? L extends TNever 
+      ? Acc 
+      : TFilterNever<R, [...Acc, L]>
+    : Acc
+)
+// prettier-ignore
+function FilterNever<T extends TSchema[]>(T: [...T]): TFilterNever<T> {
+  return T.filter(L => !IsNever(L)) as never
+}
 // ------------------------------------------------------------------
-// TCompositeIndex
+// CompositeProperty
 // ------------------------------------------------------------------
 // prettier-ignore
-type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[], Acc extends TProperties = {}> =
-  K extends [infer L extends string, ...infer R extends string[]]
-    ? TCompositeIndex<T, R, Acc & { [_ in L]: TIndex<T, [L]> }>
+type TCompositeProperty<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+   ? TCompositeProperty<R, K, TFilterNever<[...Acc, ...TIndexFromPropertyKeys<L, [K]>]>>
+   : Acc
+)
+// prettier-ignore
+function CompositeProperty<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TCompositeProperty<T, K> {
+  return T.reduce((Acc, L) => {
+    return FilterNever([...Acc, ...IndexFromPropertyKeys(L, [K])])
+  }, []) as never
+}
+// ------------------------------------------------------------------
+// CompositeProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TCompositeProperties<T extends TSchema[], K extends PropertyKey[], Acc = {}> = (
+  K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+    ? TCompositeProperties<T, R, Acc & { [_ in L]: TIntersectEvaluated<TCompositeProperty<T, L>> }>
     : Acc
+)
 // prettier-ignore
-type TCompositeReduce<T extends TObject[]> = UnionToTuple<TCompositeKeys<T>> extends infer K
-  ? Evaluate<TCompositeIndex<TIntersect<T>, Assert<K, string[]>>>
-  : {} //                    ^ indexed via intersection of T
+function CompositeProperties<T extends TSchema[], K extends PropertyKey[] = []>(T: [...T], K: [...K]): TCompositeProperties<T, K> {
+  return K.reduce((Acc, L) => {
+   return { ...Acc, [L]: IntersectEvaluated(CompositeProperty(T, L)) }
+  }, {}) as never
+}
 // ------------------------------------------------------------------
-// TComposite
+// Composite
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TComposite<T extends TObject[]> = TIntersect<T> extends TIntersect
-  ? Ensure<TObject<TCompositeReduce<T>>>
-  : Ensure<TObject<{}>>
+type TCompositeEvaluate<
+  T extends TSchema[], 
+  K extends PropertyKey[] = TCompositeKeys<T>,
+  P extends TProperties = Evaluate<TCompositeProperties<T, K>>,
+  R extends TObject = TObject<P>
+> = R
+// prettier-ignore
+export type TComposite<T extends TSchema[]> = TCompositeEvaluate<T>
 
-/** `[Json]` Creates a Composite object type */
-export function Composite<T extends TObject[]>(T: [...T], options?: ObjectOptions): TComposite<T> {
-  const intersect: TSchema = Intersect(T, {})
-  const keys = KeyOfPropertyKeys(intersect) as string[]
-  const properties = keys.reduce((acc, key) => ({ ...acc, [key]: Index(intersect, [key]) }), {} as TProperties)
-  return Object(properties, options) as TComposite<T>
+// prettier-ignore
+export function Composite<T extends TSchema[]>(T: [...T], options: ObjectOptions = {}): TComposite<T> {
+  const K = CompositeKeys(T)
+  const P = CompositeProperties(T, K)
+  const R = Object(P, options)
+  return R as TComposite<T>
 }
diff --git a/src/type/helpers/helpers.ts b/src/type/helpers/helpers.ts
index c241ef343..807e10c07 100644
--- a/src/type/helpers/helpers.ts
+++ b/src/type/helpers/helpers.ts
@@ -56,10 +56,10 @@ type IncrementStep<T extends string> = T extends IncrementBase['m']
     : `${IncrementTake<L>}${R}`
   : never
 type IncrementReverse<T extends string> = T extends `${infer L}${infer R}` ? `${IncrementReverse<R>}${L}` : T
-export type Increment<T extends string> = IncrementReverse<IncrementStep<IncrementReverse<T>>>
+export type TIncrement<T extends string> = IncrementReverse<IncrementStep<IncrementReverse<T>>>
 /** Increments the given string value + 1 */
-export function Increment<T extends string>(T: T): Increment<T> {
-  return (parseInt(T) + 1).toString() as Increment<T>
+export function Increment<T extends string>(T: T): TIncrement<T> {
+  return (parseInt(T) + 1).toString() as TIncrement<T>
 }
 // ------------------------------------------------------------------
 // Helper: Type Asserts
diff --git a/src/type/keyof/keyof-property-keys.ts b/src/type/keyof/keyof-property-keys.ts
index 34a16956a..8f7c17e3b 100644
--- a/src/type/keyof/keyof-property-keys.ts
+++ b/src/type/keyof/keyof-property-keys.ts
@@ -27,7 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import type { TSchema } from '../schema/index'
-import { type ZeroString, type UnionToTuple, Increment } from '../helpers/index'
+import { type ZeroString, type UnionToTuple, type TIncrement } from '../helpers/index'
 import type { TRecursive } from '../recursive/index'
 import type { TIntersect } from '../intersect/index'
 import type { TUnion } from '../union/index'
@@ -59,31 +59,31 @@ function FromRest<T extends TSchema[]>(T: [...T]): TFromRest<T> {
 // FromIntersect
 // ------------------------------------------------------------------
 // prettier-ignore
-type FromIntersect<
+type TFromIntersect<
   T extends TSchema[], 
   C extends PropertyKey[][] = TFromRest<T>,
   R extends PropertyKey[] = TSetUnionMany<C>
 > = R
 // prettier-ignore
-function FromIntersect<T extends TSchema[]>(T: [...T]): FromIntersect<T> {
+function FromIntersect<T extends TSchema[]>(T: [...T]): TFromIntersect<T> {
   const C = FromRest(T) as PropertyKey[][]
   const R = SetUnionMany(C)
-  return R as FromIntersect<T>
+  return R as TFromIntersect<T>
 }
 // ------------------------------------------------------------------
 // FromUnion
 // ------------------------------------------------------------------
 // prettier-ignore
-type FromUnion<
+type TFromUnion<
   T extends TSchema[], 
   C extends PropertyKey[][] = TFromRest<T>,
   R extends PropertyKey[] = TSetIntersectMany<C>
 > = R
 // prettier-ignore
-function FromUnion<T extends TSchema[]>(T: [...T]): FromUnion<T> {
+function FromUnion<T extends TSchema[]>(T: [...T]): TFromUnion<T> {
   const C = FromRest(T) as PropertyKey[][]
   const R = SetIntersectMany(C)
-  return R as FromUnion<T>
+  return R as TFromUnion<T>
 }
 // ------------------------------------------------------------------
 // FromTuple
@@ -91,7 +91,7 @@ function FromUnion<T extends TSchema[]>(T: [...T]): FromUnion<T> {
 // prettier-ignore
 type TFromTuple<T extends TSchema[], I extends string = ZeroString, Acc extends PropertyKey[] = []> = 
   T extends [infer _ extends TSchema, ...infer R extends TSchema[]]
-    ? TFromTuple<R, Increment<I>, [...Acc, I]>
+    ? TFromTuple<R, TIncrement<I>, [...Acc, I]>
     : Acc
 // prettier-ignore
 function FromTuple<T extends TSchema[]>(T: [...T]): TFromTuple<T> {
@@ -142,8 +142,8 @@ function FromPatternProperties(patternProperties: Record<PropertyKey, TSchema>):
 // prettier-ignore
 export type TKeyOfPropertyKeys<T extends TSchema> = (
   T extends TRecursive<infer S> ? TKeyOfPropertyKeys<S> :
-  T extends TIntersect<infer S> ? FromIntersect<S> :
-  T extends TUnion<infer S> ? FromUnion<S> :
+  T extends TIntersect<infer S> ? TFromIntersect<S> :
+  T extends TUnion<infer S> ? TFromUnion<S> :
   T extends TTuple<infer S> ? TFromTuple<S> :
   T extends TArray<infer S> ? TFromArray<S> :
   T extends TObject<infer S> ? TFromProperties<S> :
diff --git a/src/type/sets/set.ts b/src/type/sets/set.ts
index f2456a728..70b1e02ee 100644
--- a/src/type/sets/set.ts
+++ b/src/type/sets/set.ts
@@ -37,7 +37,7 @@ export type TSetIncludes<T extends PropertyKey[], S extends PropertyKey> = (
       : TSetIncludes<R, S>
     : false
 )
-/** Returns true if element S is in the set of T */
+/** Returns true if element right is in the set of left */
 // prettier-ignore
 export function SetIncludes<T extends PropertyKey[], S extends PropertyKey>(T: [...T], S: S): TSetIncludes<T, S> {
   return T.includes(S) as TSetIncludes<T, S>
@@ -46,16 +46,16 @@ export function SetIncludes<T extends PropertyKey[], S extends PropertyKey>(T: [
 // SetIsSubset
 // ------------------------------------------------------------------
 // prettier-ignore
-export type SetIsSubset<T extends PropertyKey[], S extends PropertyKey[]> = (
+export type TSetIsSubset<T extends PropertyKey[], S extends PropertyKey[]> = (
   T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
     ? TSetIncludes<S, L> extends true
-      ? SetIsSubset<R, S>
+      ? TSetIsSubset<R, S>
       : false
     : true
 )
-/** Returns true if T is a subset of S */
-export function SetIsSubset<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): SetIsSubset<T, S> {
-  return T.every((L) => SetIncludes(S, L)) as SetIsSubset<T, S>
+/** Returns true if left is a subset of right */
+export function SetIsSubset<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetIsSubset<T, S> {
+  return T.every((L) => SetIncludes(S, L)) as TSetIsSubset<T, S>
 }
 // ------------------------------------------------------------------
 // SetDistinct
@@ -78,7 +78,7 @@ export function SetDistinct<T extends PropertyKey[]>(T: [...T]): TSetDistinct<T>
 export type TSetIntersect<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (
   T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
     ? TSetIncludes<S, L> extends true
-      ? TSetIntersect<R, S, [L, ...Acc]>
+      ? TSetIntersect<R, S, [...Acc, L]>
       : TSetIntersect<R, S, [...Acc]>
     : Acc
 )
@@ -90,14 +90,12 @@ export function SetIntersect<T extends PropertyKey[], S extends PropertyKey[]>(T
 // SetUnion
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TSetUnion<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = S> = (
-  T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
-    ? TSetUnion<R, S, [...Acc, L]>
-    : Acc
+export type TSetUnion<T extends PropertyKey[], S extends PropertyKey[]> = (
+  [...T, ...S]
 )
 /** Returns the Union of the given sets */
 export function SetUnion<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetUnion<T, S> {
-  return [...T, ...S] as never
+  return [...T, ...S]
 }
 // ------------------------------------------------------------------
 // SetComplement
@@ -119,17 +117,35 @@ export function SetComplement<T extends PropertyKey[], S extends PropertyKey[]>(
 // SetIntersectMany
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TSetIntersectMany<T extends PropertyKey[][], Acc extends PropertyKey[] = []> = (
-  T extends [infer L extends PropertyKey[]] ? L :
+type TSetIntersectManyResolve<T extends PropertyKey[][], Acc extends PropertyKey[]> = (
   T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]]
-    ? TSetIntersectMany<R, TSetIntersect<Acc, L>>
+    ? TSetIntersectManyResolve<R, TSetIntersect<Acc, L>>
     : Acc
 )
-/** Returns the Intersect of multiple sets */
+// prettier-ignore
+function SetIntersectManyResolve<T extends PropertyKey[][], Acc extends PropertyKey[]>(T: [...T], Init: Acc): TSetIntersectManyResolve<T, Acc> {
+  return T.reduce((Acc: PropertyKey[], L: PropertyKey[]) => {
+    return SetIntersect(Acc, L)
+  }, Init) as never
+}
+// prettier-ignore
+export type TSetIntersectMany<T extends PropertyKey[][]> = (
+  T extends [infer L extends PropertyKey[]] 
+    ? L 
+    // Use left to initialize the accumulator for resolve
+    : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]]
+      ? TSetIntersectManyResolve<R, L>
+      : []
+)
 // prettier-ignore
 export function SetIntersectMany<T extends PropertyKey[][]>(T: [...T]): TSetIntersectMany<T> {
   return (
-    T.length === 1 ? T[0] : T.reduce((Acc, L) => [...SetIntersect(Acc, L)], [])
+    T.length === 1
+      ? T[0]
+      // Use left to initialize the accumulator for resolve
+      : T.length > 1
+        ? SetIntersectManyResolve(T.slice(1), T[0])
+        : []
   ) as TSetIntersectMany<T>
 }
 // ------------------------------------------------------------------
diff --git a/src/type/type/json.ts b/src/type/type/json.ts
index 145d93e5b..772ff0ee9 100644
--- a/src/type/type/json.ts
+++ b/src/type/type/json.ts
@@ -130,8 +130,8 @@ export class JsonTypeBuilder {
     return Capitalize(schema, options)
   }
   /** `[Json]` Creates a Composite object type */
-  public Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T> {
-    return Composite(objects, options) as any // (error) TS 5.4.0-dev - review TComposite implementation
+  public Composite<T extends TSchema[]>(schemas: [...T], options?: ObjectOptions): TComposite<T> {
+    return Composite(schemas, options) // (error) TS 5.4.0-dev - review TComposite implementation
   }
   /** `[JavaScript]` Creates a readonly const type from the given value. */
   public Const</* const (not supported in 4.0) */ T>(value: T, options: SchemaOptions = {}): TConst<T> {
diff --git a/test/runtime/compiler-ajv/composite.ts b/test/runtime/compiler-ajv/composite.ts
index 41e8a8ac9..3d1d41a62 100644
--- a/test/runtime/compiler-ajv/composite.ts
+++ b/test/runtime/compiler-ajv/composite.ts
@@ -91,4 +91,21 @@ describe('compiler-ajv/Composite', () => {
     const B = Type.Composite([T])
     Assert.IsEqual(A, B)
   })
+  // prettier-ignore
+  it('Should composite intersection', () => {
+    const T = Type.Composite([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ y: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() })
+      ]),
+    ])
+    Ok(T, { x: 1, y: 2, z: 3 })
+    Fail(T, { x: 1, y: 2, z: '3' })
+    Fail(T, { x: 1, y: 2 })
+  })
 })
diff --git a/test/runtime/compiler/composite.ts b/test/runtime/compiler/composite.ts
index 3186c8302..960a1d7f1 100644
--- a/test/runtime/compiler/composite.ts
+++ b/test/runtime/compiler/composite.ts
@@ -81,4 +81,21 @@ describe('compiler/Composite', () => {
     Fail(T, { x: { x: '1' }, y: { x: '' } })
     Fail(T, { x: { x: 1 }, y: { x: 1 } })
   })
+  // prettier-ignore
+  it('Should composite intersection', () => {
+    const T = Type.Composite([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ y: Type.Number() })
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() })
+      ]),
+    ])
+    Ok(T, { x: 1, y: 2, z: 3 })
+    Fail(T, { x: 1, y: 2, z: '3' })
+    Fail(T, { x: 1, y: 2 })
+  })
 })
diff --git a/test/runtime/type/guard/composite.ts b/test/runtime/type/guard/composite.ts
index e8a3f21ac..d3e9557a2 100644
--- a/test/runtime/type/guard/composite.ts
+++ b/test/runtime/type/guard/composite.ts
@@ -36,8 +36,8 @@ describe('type/guard/TComposite', () => {
     Assert.IsTrue(TypeGuard.IsOptional(T.properties.x))
     Assert.IsEqual(T.required, undefined)
   })
+  // prettier-ignore
   it('Should produce required property if some composited properties are not optional', () => {
-    // prettier-ignore
     const T = Type.Composite([
       Type.Object({ x: Type.Optional(Type.Number()) }), 
       Type.Object({ x: Type.Number() })
@@ -45,12 +45,119 @@ describe('type/guard/TComposite', () => {
     Assert.IsFalse(TypeGuard.IsOptional(T.properties.x))
     Assert.IsTrue(T.required!.includes('x'))
   })
+  // prettier-ignore
   it('Should preserve single optional property', () => {
-    // prettier-ignore
     const T = Type.Composite([
       Type.Object({ x: Type.Optional(Type.Number()) }), 
     ])
     Assert.IsTrue(TypeGuard.IsOptional(T.properties.x))
     Assert.IsEqual(T.required, undefined)
   })
+  // ----------------------------------------------------------------
+  // Intersect
+  // ----------------------------------------------------------------
+  // prettier-ignore
+  it('Should composite Intersect 1', () => {
+    const T = Type.Composite([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() }),
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() }),
+      ])
+    ])
+    Assert.IsEqual(T, Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number()
+    }))
+  })
+  // prettier-ignore
+  it('Should composite Intersect 2', () => {
+    const T = Type.Composite([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ x: Type.Number() }),
+      ]),
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+      ])
+    ])
+    Assert.IsEqual(T, Type.Object({
+      x: Type.Intersect([Type.Intersect([Type.Number(), Type.Number()]), Type.Number()])
+    }))
+  })
+  // prettier-ignore
+  it('Should composite Intersect 3', () => {
+    const T = Type.Composite([
+      Type.Number(),
+      Type.Boolean()
+    ])
+    Assert.IsEqual(T, Type.Object({}))
+  })
+  // prettier-ignore
+  it('Should composite Intersect 4', () => {
+    const T = Type.Composite([
+      Type.Number(),
+      Type.Boolean(),
+      Type.Object({ x: Type.String() })
+    ])
+    Assert.IsEqual(T, Type.Object({
+      x: Type.String()
+    }))
+  })
+  // prettier-ignore
+  it('Should composite Intersect 5', () => {
+    const T = Type.Composite([
+      Type.Object({ x: Type.Optional(Type.String()) }),
+      Type.Object({ x: Type.String() })
+    ])
+    Assert.IsEqual(T, Type.Object({
+      x: Type.Intersect([Type.String(), Type.String()])
+    }))
+  })
+  // prettier-ignore
+  it('Should composite Intersect 6', () => {
+    const T = Type.Composite([
+      Type.Object({ x: Type.Optional(Type.String()) }),
+      Type.Object({ x: Type.Optional(Type.String()) })
+    ])
+    Assert.IsEqual(T, Type.Object({
+      x: Type.Optional(Type.Intersect([Type.String(), Type.String()]))
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Union
+  // ----------------------------------------------------------------
+  // prettier-ignore
+  it('Should composite Union 1', () => {
+    const T = Type.Composite([
+      Type.Union([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() }),
+      ]),
+      Type.Union([
+        Type.Object({ z: Type.Number() }),
+      ])
+    ])
+    Assert.IsEqual(T, Type.Object({
+      z: Type.Intersect([Type.Union([Type.Never(), Type.Never()]), Type.Number()])
+    }))
+  })
+  // prettier-ignore
+  it('Should composite Union 2', () => {
+    const T = Type.Composite([
+      Type.Union([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ x: Type.Number() }),
+      ]),
+      Type.Union([
+        Type.Object({ x: Type.Number() }),
+      ])
+    ])
+    Assert.IsEqual(T, Type.Object({
+      x: Type.Intersect([Type.Union([Type.Number(), Type.Number()]), Type.Number()])
+    }))
+  })
 })
diff --git a/test/runtime/type/index.ts b/test/runtime/type/index.ts
index f5cfcd709..d05528481 100644
--- a/test/runtime/type/index.ts
+++ b/test/runtime/type/index.ts
@@ -4,5 +4,6 @@ import './guard/index'
 import './intrinsic/index'
 import './normalize/index'
 import './registry/index'
+import './sets/index'
 import './template-literal/index'
 import './value/index'
diff --git a/test/runtime/type/sets/index.ts b/test/runtime/type/sets/index.ts
new file mode 100644
index 000000000..2b3525728
--- /dev/null
+++ b/test/runtime/type/sets/index.ts
@@ -0,0 +1 @@
+import './sets'
diff --git a/test/runtime/type/sets/sets.ts b/test/runtime/type/sets/sets.ts
new file mode 100644
index 000000000..6bfef3c09
--- /dev/null
+++ b/test/runtime/type/sets/sets.ts
@@ -0,0 +1,167 @@
+import * as Type from '@sinclair/typebox'
+import { Assert } from '../../assert'
+
+describe('type/sets', () => {
+  // ----------------------------------------------------------------
+  // Distinct
+  // ----------------------------------------------------------------
+  it('Should Distinct', () => {
+    const R = Type.SetDistinct([1, 1, 2, 2])
+    Assert.IsEqual(R, [1, 2])
+  })
+  // ----------------------------------------------------------------
+  // Includes
+  // ----------------------------------------------------------------
+  it('Should Includes 1', () => {
+    const R = Type.SetIncludes([1, 2, 3, 4], 1)
+    Assert.IsTrue(R)
+  })
+  it('Should Includes 2', () => {
+    const R = Type.SetIncludes([1, 2, 3, 4], 7)
+    Assert.IsFalse(R)
+  })
+  // ----------------------------------------------------------------
+  // IsSubset
+  // ----------------------------------------------------------------
+  it('Should IsSubset 1', () => {
+    const R = Type.SetIsSubset([1, 2], [1, 2])
+    Assert.IsTrue(R)
+  })
+  it('Should IsSubset 2', () => {
+    const R = Type.SetIsSubset([1, 2], [1, 2, 3])
+    Assert.IsTrue(R)
+  })
+  it('Should IsSubset 3', () => {
+    const R = Type.SetIsSubset([1, 2], [1])
+    Assert.IsFalse(R)
+  })
+  // ----------------------------------------------------------------
+  // Intersect
+  // ----------------------------------------------------------------
+  it('Should Intersect 1', () => {
+    const R = Type.SetIntersect([1, 2], [1, 2])
+    Assert.IsEqual(R, [1, 2])
+  })
+  it('Should Intersect 2', () => {
+    const R = Type.SetIntersect([1], [1, 2])
+    Assert.IsEqual(R, [1])
+  })
+  it('Should Intersect 3', () => {
+    const R = Type.SetIntersect([1, 2], [1])
+    Assert.IsEqual(R, [1])
+  })
+  it('Should Intersect 4', () => {
+    const R = Type.SetIntersect([], [1])
+    Assert.IsEqual(R, [])
+  })
+  it('Should Intersect 5', () => {
+    const R = Type.SetIntersect([1], [])
+    Assert.IsEqual(R, [])
+  })
+  it('Should Intersect 6', () => {
+    const R = Type.SetIntersect([1], [2])
+    Assert.IsEqual(R, [])
+  })
+  // ----------------------------------------------------------------
+  // Union
+  // ----------------------------------------------------------------
+  it('Should Union 1', () => {
+    const R = Type.SetUnion([1, 2], [1, 2])
+    Assert.IsEqual(R, [1, 2, 1, 2])
+  })
+  it('Should Union 2', () => {
+    const R = Type.SetUnion([1], [1, 2])
+    Assert.IsEqual(R, [1, 1, 2])
+  })
+  it('Should Union 3', () => {
+    const R = Type.SetUnion([1, 2], [1])
+    Assert.IsEqual(R, [1, 2, 1])
+  })
+  it('Should Union 4', () => {
+    const R = Type.SetUnion([], [1])
+    Assert.IsEqual(R, [1])
+  })
+  it('Should Union 5', () => {
+    const R = Type.SetUnion([1], [])
+    Assert.IsEqual(R, [1])
+  })
+  // ----------------------------------------------------------------
+  // Complement
+  // ----------------------------------------------------------------
+  it('Should Complement 1', () => {
+    const R = Type.SetComplement([1, 2, 3, 4], [2, 3])
+    Assert.IsEqual(R, [1, 4])
+  })
+  it('Should Complement 2', () => {
+    const R = Type.SetComplement([2, 3], [1, 2, 3, 4])
+    Assert.IsEqual(R, [])
+  })
+  // ----------------------------------------------------------------
+  // IntersectMany
+  // ----------------------------------------------------------------
+  it('Should IntersectMany 1', () => {
+    const R = Type.SetIntersectMany([[1, 2, 3], [1, 2], [1]] as const)
+    Assert.IsEqual(R, [1])
+  })
+  it('Should IntersectMany 2', () => {
+    const R = Type.SetIntersectMany([[1], [1, 2], [1, 2, 3]] as const)
+    Assert.IsEqual(R, [1])
+  })
+  it('Should IntersectMany 3', () => {
+    const R = Type.SetIntersectMany([
+      [1, 2],
+      [1, 2],
+    ] as const)
+    Assert.IsEqual(R, [1, 2])
+  })
+  it('Should IntersectMany 4', () => {
+    const R = Type.SetIntersectMany([[1], [2]] as const)
+    Assert.IsEqual(R, [])
+  })
+  it('Should IntersectMany 5', () => {
+    const R = Type.SetIntersectMany([[1], []] as const)
+    Assert.IsEqual(R, [])
+  })
+  it('Should IntersectMany 6', () => {
+    const R = Type.SetIntersectMany([[], [1]] as const)
+    Assert.IsEqual(R, [])
+  })
+  it('Should IntersectMany 7', () => {
+    const R = Type.SetIntersectMany([[1], [1], [1], [1], []] as const)
+    Assert.IsEqual(R, [])
+  })
+  it('Should IntersectMany 8', () => {
+    const R = Type.SetIntersectMany([[], [1], [1], [1], [1]] as const)
+    Assert.IsEqual(R, [])
+  })
+  // ----------------------------------------------------------------
+  // UnionMany
+  // ----------------------------------------------------------------
+  it('Should UnionMany 1', () => {
+    const R = Type.SetUnionMany([[1, 2, 3], [1, 2], [1]] as const)
+    Assert.IsEqual(R, [1, 2, 3, 1, 2, 1])
+  })
+  it('Should UnionMany 2', () => {
+    const R = Type.SetUnionMany([[1], [1, 2], [1, 2, 3]] as const)
+    Assert.IsEqual(R, [1, 1, 2, 1, 2, 3])
+  })
+  it('Should UnionMany 3', () => {
+    const R = Type.SetUnionMany([
+      [1, 2],
+      [1, 2],
+    ] as const)
+    Assert.IsEqual(R, [1, 2, 1, 2])
+  })
+  it('Should UnionMany 4', () => {
+    const R = Type.SetUnionMany([[1], [2]] as const)
+    Assert.IsEqual(R, [1, 2])
+  })
+  it('Should UnionMany 5', () => {
+    const R = Type.SetUnionMany([[1], []] as const)
+    Assert.IsEqual(R, [1])
+  })
+  it('Should UnionMany 6', () => {
+    const R = Type.SetUnionMany([[], [1]] as const)
+    Assert.IsEqual(R, [1])
+  })
+})
diff --git a/test/static/composite.ts b/test/static/composite.ts
index 70751619e..e2b440f41 100644
--- a/test/static/composite.ts
+++ b/test/static/composite.ts
@@ -1,5 +1,5 @@
 import { Expect } from './assert'
-import { Type, TObject, TIntersect, TNumber, TBoolean } from '@sinclair/typebox'
+import { Type, TOptional, TObject, TIntersect, TNumber, TBoolean } from '@sinclair/typebox'
 
 // ----------------------------------------------------------------------------
 // Overlapping - Non Varying
@@ -127,3 +127,60 @@ import { Type, TObject, TIntersect, TNumber, TBoolean } from '@sinclair/typebox'
     Type.Object({ x: Type.Boolean() })
   ])
 }
+// ------------------------------------------------------------------
+// Intersect
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const T: TObject<{
+    x: TNumber;
+    y: TNumber;
+    z: TNumber;
+  }> = Type.Composite([
+    Type.Intersect([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() }),
+    ]),
+    Type.Intersect([
+      Type.Object({ z: Type.Number() })
+    ])
+  ])
+}
+// prettier-ignore
+{
+  const T: TObject<{
+    x: TIntersect<[TNumber, TNumber]>;
+    y: TIntersect<[TNumber, TNumber]>;
+  }> = Type.Composite([
+    Type.Intersect([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() }),
+    ]),
+    Type.Intersect([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() }),
+    ])
+  ])
+}
+// prettier-ignore
+{
+  const T: TObject<{
+    x: TIntersect<[TNumber, TNumber]>;
+  }> = Type.Composite([
+    Type.Intersect([
+      Type.Object({ x: Type.Optional(Type.Number()) }),
+      Type.Object({ x: Type.Number() }),
+    ])
+  ])
+}
+// prettier-ignore
+{
+  const T: TObject<{
+    x: TOptional<TIntersect<[TNumber, TNumber]>>;
+  }> = Type.Composite([
+    Type.Intersect([
+      Type.Object({ x: Type.Optional(Type.Number()) }),
+      Type.Object({ x: Type.Optional(Type.Number()) }),
+    ])
+  ])
+}

From 0c0da45394e5ecb043a6fc6fee7d24a13bc9e4fa Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 18 Jan 2024 01:58:45 +0900
Subject: [PATCH 231/369] Revision 0.32.10 (#734)

* Export Partial and Required Type Infrastructure

* Version
---
 package-lock.json             |  4 ++--
 package.json                  |  2 +-
 src/type/partial/partial.ts   | 26 ++++++++++++--------------
 src/type/required/required.ts | 25 ++++++++++++-------------
 4 files changed, 27 insertions(+), 30 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 79f26077e..87202da08 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.9",
+  "version": "0.32.10",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.9",
+      "version": "0.32.10",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 6a27860cb..0f1575d2e 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.9",
+  "version": "0.32.10",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/partial/partial.ts b/src/type/partial/partial.ts
index b46ee4af9..961d36f25 100644
--- a/src/type/partial/partial.ts
+++ b/src/type/partial/partial.ts
@@ -52,7 +52,7 @@ import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/type'
 // prettier-ignore
 type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TFromRest<R, [...Acc, PartialResolve<L>]>
+    ? TFromRest<R, [...Acc, TPartial<L>]>
     : Acc
 )
 // prettier-ignore
@@ -80,27 +80,25 @@ function FromProperties<T extends TProperties>(T: T) {
 // PartialResolve
 // ------------------------------------------------------------------
 // prettier-ignore
-type PartialResolve<T extends TSchema> = (
-  T extends TRecursive<infer S> ? TRecursive<PartialResolve<S>> :
-  T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> :
-  T extends TUnion<infer S> ? TUnion<TFromRest<S>> :
-  T extends TObject<infer S> ? TObject<TFromProperties<S>> :
-  TObject<{}>
-)
-// prettier-ignore
-function PartialResolve<T extends TSchema>(T: T): PartialResolve<T> {
+function PartialResolve<T extends TSchema>(T: T): TPartial<T> {
   return (
     IsIntersect(T) ? Intersect(FromRest(T.allOf)) :
     IsUnion(T) ? Union(FromRest(T.anyOf)) :
     IsObject(T) ? Object(FromProperties(T.properties)) :
     Object({})
-  ) as PartialResolve<T>
+  ) as TPartial<T>
 }
 // ------------------------------------------------------------------
 // TPartial
 // ------------------------------------------------------------------
-export type TPartial<T extends TSchema> = PartialResolve<T>
-
+// prettier-ignore
+export type TPartial<T extends TSchema> = (
+  T extends TRecursive<infer S> ? TRecursive<TPartial<S>> :
+  T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> :
+  T extends TUnion<infer S> ? TUnion<TFromRest<S>> :
+  T extends TObject<infer S> ? TObject<TFromProperties<S>> :
+  TObject<{}>
+)
 /** `[Json]` Constructs a type where all properties are optional */
 export function Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>
 /** `[Json]` Constructs a type where all properties are optional */
@@ -110,5 +108,5 @@ export function Partial(T: TSchema, options: SchemaOptions = {}): any {
   if (IsMappedResult(T)) return PartialFromMappedResult(T, options)
   const D = Discard(T, [TransformKind, '$id', 'required']) as TSchema
   const R = CloneType(PartialResolve(T), options)
-  return { ...D, ...R } as any
+  return { ...D, ...R } as never
 }
diff --git a/src/type/required/required.ts b/src/type/required/required.ts
index 1066289b3..56220759b 100644
--- a/src/type/required/required.ts
+++ b/src/type/required/required.ts
@@ -53,7 +53,7 @@ import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/type'
 // prettier-ignore
 type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TFromRest<R, [...Acc, TRequiredResolve<L>]>
+    ? TFromRest<R, [...Acc, TRequired<L>]>
     : Acc
 )
 // prettier-ignore
@@ -80,28 +80,27 @@ function FromProperties<T extends TProperties>(T: T) {
 // ------------------------------------------------------------------
 // RequiredResolve
 // ------------------------------------------------------------------
+
 // prettier-ignore
-type TRequiredResolve<T extends TSchema> = (
-  T extends TRecursive<infer S> ? TRecursive<TRequiredResolve<S>> :
-  T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> :
-  T extends TUnion<infer S> ? TUnion<TFromRest<S>> :
-  T extends TObject<infer S> ? TObject<TFromProperties<S>> :
-  TObject<{}>
-)
-// prettier-ignore
-function RequiredResolve<T extends TSchema>(T: T): TRequiredResolve<T> {
+function RequiredResolve<T extends TSchema>(T: T): TRequired<T> {
   return (
     IsIntersect(T) ? Intersect(FromRest(T.allOf)) :
     IsUnion(T) ?  Union(FromRest(T.anyOf)) :
     IsObject(T) ? Object(FromProperties(T.properties)) :
     Object({})
-  ) as TRequiredResolve<T>
+  ) as TRequired<T>
 }
 // ------------------------------------------------------------------
 // TRequired
 // ------------------------------------------------------------------
-export type TRequired<T extends TSchema> = TRequiredResolve<T>
-
+// prettier-ignore
+export type TRequired<T extends TSchema> = (
+  T extends TRecursive<infer S> ? TRecursive<TRequired<S>> :
+  T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> :
+  T extends TUnion<infer S> ? TUnion<TFromRest<S>> :
+  T extends TObject<infer S> ? TObject<TFromProperties<S>> :
+  TObject<{}>
+)
 /** `[Json]` Constructs a type where all properties are required */
 export function Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>
 /** `[Json]` Constructs a type where all properties are required */

From cc068713a5d6bd060617b01de1f30c3dee6f266d Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 21 Jan 2024 03:23:24 +0900
Subject: [PATCH 232/369] Revision 0.32.11 (#738)

* Optimize Extract and Exclude

* Version
---
 package-lock.json                             |  4 +-
 package.json                                  |  2 +-
 src/index.ts                                  |  6 ++-
 .../exclude/exclude-from-mapped-result.ts     | 14 +++----
 .../exclude/exclude-from-template-literal.ts  | 39 +++++++++++++++++++
 src/type/exclude/exclude.ts                   | 37 ++++++++----------
 src/type/exclude/index.ts                     |  1 +
 .../extract/extract-from-mapped-result.ts     | 14 +++----
 .../extract/extract-from-template-literal.ts  | 39 +++++++++++++++++++
 src/type/extract/extract.ts                   | 34 ++++++++--------
 src/type/extract/index.ts                     |  1 +
 src/type/template-literal/union.ts            | 22 ++++++++---
 src/type/type/json.ts                         |  8 +++-
 test/static/exclude.ts                        | 15 +++++++
 test/static/extract.ts                        | 17 ++++++++
 15 files changed, 188 insertions(+), 65 deletions(-)
 create mode 100644 src/type/exclude/exclude-from-template-literal.ts
 create mode 100644 src/type/extract/extract-from-template-literal.ts

diff --git a/package-lock.json b/package-lock.json
index 87202da08..292708f95 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.10",
+  "version": "0.32.11",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.10",
+      "version": "0.32.11",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 0f1575d2e..26107da3d 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.10",
+  "version": "0.32.11",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/index.ts b/src/index.ts
index cfcd03abe..2108648d5 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -79,9 +79,9 @@ export { ConstructorParameters, type TConstructorParameters } from './type/const
 export { Date, type TDate, type DateOptions } from './type/date/index'
 export { Deref, type TDeref } from './type/deref/index'
 export { Enum, type TEnum } from './type/enum/index'
-export { Exclude, type TExclude, type TExcludeFromMappedResult } from './type/exclude/index'
+export { Exclude, type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from './type/exclude/index'
 export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey } from './type/extends/index'
-export { Extract, type TExtract, type TExtractFromMappedResult } from './type/extract/index'
+export { Extract, type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from './type/extract/index'
 export { Function, type TFunction } from './type/function/index'
 export {
   Index,
@@ -136,6 +136,7 @@ export {
   TemplateLiteralGenerate,
   TemplateLiteralParse,
   TemplateLiteralParseExact,
+  TemplateLiteralToUnion,
   IsTemplateLiteralFinite,
   TemplateLiteralExpressionGenerate,
   IsTemplateLiteralExpressionFinite,
@@ -143,6 +144,7 @@ export {
   type TTemplateLiteralSyntax,
   type TTemplateLiteralGenerate,
   type TTemplateLiteralKind,
+  type TTemplateLiteralToUnion,
   type TIsTemplateLiteralFinite,
 } from './type/template-literal/index'
 export { Transform, TransformDecodeBuilder, TransformEncodeBuilder, type TTransform, type TransformOptions, type TransformFunction } from './type/transform/index'
diff --git a/src/type/exclude/exclude-from-mapped-result.ts b/src/type/exclude/exclude-from-mapped-result.ts
index a8934686f..3fe927fde 100644
--- a/src/type/exclude/exclude-from-mapped-result.ts
+++ b/src/type/exclude/exclude-from-mapped-result.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import type { TSchema, SchemaOptions } from '../schema/index'
+import type { TSchema } from '../schema/index'
 import type { TProperties } from '../object/index'
 import { MappedResult, type TMappedResult } from '../mapped/index'
 import { Exclude, type TExclude } from './exclude'
@@ -45,9 +45,9 @@ type TFromProperties<
 function FromProperties<
   P extends TProperties,
   T extends TSchema
->(P: P, U: T, options: SchemaOptions): TFromProperties<P, T> {
+>(P: P, U: T): TFromProperties<P, T> {
   return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-    return {...Acc, [K2]: Exclude(P[K2], U, options) }
+    return {...Acc, [K2]: Exclude(P[K2], U) }
   }, {}) as TFromProperties<P, T>
 }
 // ------------------------------------------------------------------
@@ -64,8 +64,8 @@ type TFromMappedResult<
 function FromMappedResult<
   R extends TMappedResult,
   T extends TSchema
->(R: R, T: T, options: SchemaOptions): TFromMappedResult<R, T> {
-  return FromProperties(R.properties, T, options) as TFromMappedResult<R, T>
+>(R: R, T: T): TFromMappedResult<R, T> {
+  return FromProperties(R.properties, T) as TFromMappedResult<R, T>
 }
 // ------------------------------------------------------------------
 // ExcludeFromMappedResult
@@ -83,7 +83,7 @@ export function ExcludeFromMappedResult<
   R extends TMappedResult,
   T extends TSchema,
   P extends TProperties = TFromMappedResult<R, T>
->(R: R, T: T, options: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedResult(R, T, options) as unknown as P
+>(R: R, T: T): TMappedResult<P> {
+  const P = FromMappedResult(R, T) as unknown as P
   return MappedResult(P) 
 }
diff --git a/src/type/exclude/exclude-from-template-literal.ts b/src/type/exclude/exclude-from-template-literal.ts
new file mode 100644
index 000000000..707a6c254
--- /dev/null
+++ b/src/type/exclude/exclude-from-template-literal.ts
@@ -0,0 +1,39 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import { TExclude, Exclude } from './exclude'
+import { TemplateLiteralToUnion, type TTemplateLiteral, type TTemplateLiteralToUnion } from '../template-literal/index'
+
+// prettier-ignore
+export type TExcludeFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = (
+  TExclude<TTemplateLiteralToUnion<L>, R>
+)
+export function ExcludeFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema>(L: L, R: R): TExcludeFromTemplateLiteral<L, R> {
+  return Exclude(TemplateLiteralToUnion(L), R) as never
+}
diff --git a/src/type/exclude/exclude.ts b/src/type/exclude/exclude.ts
index d82bdf33a..021caf156 100644
--- a/src/type/exclude/exclude.ts
+++ b/src/type/exclude/exclude.ts
@@ -27,32 +27,23 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import type { TSchema, SchemaOptions } from '../schema/index'
-import type { UnionToTuple, AssertRest, AssertType, Assert } from '../helpers/index'
+import type { UnionToTuple, AssertRest, AssertType } from '../helpers/index'
 import type { TMappedResult } from '../mapped/index'
-import { TemplateLiteralToUnion, type TTemplateLiteral } from '../template-literal/index'
+import { type TTemplateLiteral } from '../template-literal/index'
 import { Union, type TUnion } from '../union/index'
 import { Never, type TNever } from '../never/index'
-import { type TLiteral } from '../literal/index'
 import { type Static } from '../static/index'
 import { type TUnionEvaluated } from '../union/index'
 import { ExtendsCheck, ExtendsResult } from '../extends/index'
 import { CloneType } from '../clone/type'
 import { ExcludeFromMappedResult, type TExcludeFromMappedResult } from './exclude-from-mapped-result'
+import { ExcludeFromTemplateLiteral, type TExcludeFromTemplateLiteral } from './exclude-from-template-literal'
 
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
 import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/type'
 // ------------------------------------------------------------------
-// ExcludeTemplateLiteral
-// ------------------------------------------------------------------
-// prettier-ignore
-type TExcludeTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
-// prettier-ignore
-type TExcludeTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = (
-  Exclude<Static<L>, Static<R>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never
-)
-// ------------------------------------------------------------------
 // ExcludeRest
 // ------------------------------------------------------------------
 // prettier-ignore
@@ -69,19 +60,23 @@ function ExcludeRest<L extends TSchema[], R extends TSchema>(L: [...L], R: R) {
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TExclude<L extends TSchema, R extends TSchema> = (
-  L extends TMappedResult<L> ? TExcludeFromMappedResult<L, R> :
-  L extends TTemplateLiteral ? TExcludeTemplateLiteral<L, R> :
   L extends TUnion<infer S> ? TExcludeRest<S, R> :
   L extends R ? TNever : L
 )
 /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-export function Exclude<L extends TSchema, R extends TSchema>(L: L, R: R, options: SchemaOptions = {}): TExclude<L, R> {
+export function Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+export function Exclude<L extends TTemplateLiteral, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromTemplateLiteral<L, R>
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+export function Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+export function Exclude(L: TSchema, R: TSchema, options: SchemaOptions = {}): any {
+  // overloads
+  if (IsTemplateLiteral(L)) return CloneType(ExcludeFromTemplateLiteral(L, R), options)
+  if (IsMappedResult(L)) return CloneType(ExcludeFromMappedResult(L, R), options)
   // prettier-ignore
-  return CloneType((
-    IsMappedResult(L) ? ExcludeFromMappedResult(L, R, options) :
-    IsTemplateLiteral(L) ? Exclude(TemplateLiteralToUnion(L), R) :
-    IsTemplateLiteral(R) ? Exclude(L, TemplateLiteralToUnion(R)) :
-    IsUnion(L) ? ExcludeRest(L.anyOf, R) :
+  return CloneType(
+    IsUnion(L) ? ExcludeRest(L.anyOf, R) : 
     ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L
-  ), options) as never
+  , options)
 }
diff --git a/src/type/exclude/index.ts b/src/type/exclude/index.ts
index 335e87a04..610ff43a2 100644
--- a/src/type/exclude/index.ts
+++ b/src/type/exclude/index.ts
@@ -27,4 +27,5 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 export * from './exclude-from-mapped-result'
+export * from './exclude-from-template-literal'
 export * from './exclude'
diff --git a/src/type/extract/extract-from-mapped-result.ts b/src/type/extract/extract-from-mapped-result.ts
index c21ed3567..65d244162 100644
--- a/src/type/extract/extract-from-mapped-result.ts
+++ b/src/type/extract/extract-from-mapped-result.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import type { TSchema, SchemaOptions } from '../schema/index'
+import type { TSchema } from '../schema/index'
 import type { TProperties } from '../object/index'
 import { MappedResult, type TMappedResult } from '../mapped/index'
 import { Extract, type TExtract } from './extract'
@@ -45,9 +45,9 @@ type TFromProperties<
 function FromProperties<
   P extends TProperties,
   T extends TSchema
->(P: P, T: T, options: SchemaOptions): TFromProperties<P, T> {
+>(P: P, T: T): TFromProperties<P, T> {
   return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-    return {...Acc, [K2]: Extract(P[K2], T, options) }
+    return {...Acc, [K2]: Extract(P[K2], T) }
   }, {}) as TFromProperties<P, T>
 }
 // ------------------------------------------------------------------
@@ -64,8 +64,8 @@ type TFromMappedResult<
 function FromMappedResult<
   R extends TMappedResult,
   T extends TSchema
->(R: R, T: T, options: SchemaOptions): TFromMappedResult<R, T> {
-  return FromProperties(R.properties, T, options) as TFromMappedResult<R, T>
+>(R: R, T: T): TFromMappedResult<R, T> {
+  return FromProperties(R.properties, T) as TFromMappedResult<R, T>
 }
 // ------------------------------------------------------------------
 // ExtractFromMappedResult
@@ -83,7 +83,7 @@ export function ExtractFromMappedResult<
   R extends TMappedResult,
   T extends TSchema,
   P extends TProperties = TFromMappedResult<R, T>
->(R: R, T: T, options: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedResult(R, T, options) as unknown as P
+>(R: R, T: T): TMappedResult<P> {
+  const P = FromMappedResult(R, T) as unknown as P
   return MappedResult(P) 
 }
diff --git a/src/type/extract/extract-from-template-literal.ts b/src/type/extract/extract-from-template-literal.ts
new file mode 100644
index 000000000..82cc52dd9
--- /dev/null
+++ b/src/type/extract/extract-from-template-literal.ts
@@ -0,0 +1,39 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import { Extract, type TExtract } from './extract'
+import { TemplateLiteralToUnion, type TTemplateLiteral, type TTemplateLiteralToUnion } from '../template-literal/index'
+
+// prettier-ignore
+export type TExtractFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = (
+  TExtract<TTemplateLiteralToUnion<L>, R>
+)
+export function ExtractFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema>(L: L, R: R): TExtractFromTemplateLiteral<L, R> {
+  return Extract(TemplateLiteralToUnion(L), R) as never
+}
diff --git a/src/type/extract/extract.ts b/src/type/extract/extract.ts
index a1f6f4d54..40d7e2d3d 100644
--- a/src/type/extract/extract.ts
+++ b/src/type/extract/extract.ts
@@ -27,29 +27,23 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import type { TSchema, SchemaOptions } from '../schema/index'
-import type { Assert, AssertRest, AssertType, UnionToTuple } from '../helpers/index'
+import type { AssertRest, AssertType, UnionToTuple } from '../helpers/index'
 import type { TMappedResult } from '../mapped/index'
-import { TemplateLiteralToUnion, type TTemplateLiteral } from '../template-literal/index'
-import { type TLiteral } from '../literal/index'
 import { Union, type TUnion } from '../union/index'
 import { type Static } from '../static/index'
 import { Never, type TNever } from '../never/index'
 import { type TUnionEvaluated } from '../union/index'
+import { type TTemplateLiteral } from '../template-literal/index'
 import { ExtendsCheck, ExtendsResult } from '../extends/index'
 import { CloneType } from '../clone/type'
 import { ExtractFromMappedResult, type TExtractFromMappedResult } from './extract-from-mapped-result'
+import { ExtractFromTemplateLiteral, type TExtractFromTemplateLiteral } from './extract-from-template-literal'
 
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
 import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/type'
-// ------------------------------------------------------------------
-// ExtractTemplateLiteral
-// ------------------------------------------------------------------
-// prettier-ignore
-type TExtractTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
-// prettier-ignore
-type TExtractTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = Extract<Static<L>, Static<R>> extends infer S ? TExtractTemplateLiteralResult<Assert<S, string>> : never
+
 // ------------------------------------------------------------------
 // ExtractRest
 // ------------------------------------------------------------------
@@ -67,19 +61,23 @@ function ExtractRest<L extends TSchema[], R extends TSchema>(L: [...L], R: R) {
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TExtract<L extends TSchema, U extends TSchema> = (
-  L extends TMappedResult ? TExtractFromMappedResult<L, U> :
-  L extends TTemplateLiteral ? TExtractTemplateLiteral<L, U> :
   L extends TUnion<infer S> ? TExtractRest<S, U> :
   L extends U ? L : TNever
 )
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-export function Extract<L extends TSchema, R extends TSchema>(L: L, R: R, options: SchemaOptions = {}): TExtract<L, R> {
+export function Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+export function Extract<L extends TTemplateLiteral, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromTemplateLiteral<L, R>
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+export function Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+export function Extract(L: TSchema, R: TSchema, options: SchemaOptions = {}): any {
+  // overloads
+  if (IsTemplateLiteral(L)) return CloneType(ExtractFromTemplateLiteral(L, R), options)
+  if (IsMappedResult(L)) return CloneType(ExtractFromMappedResult(L, R), options)
   // prettier-ignore
-  return CloneType((
-    IsMappedResult(L) ? ExtractFromMappedResult(L, R, options) :
-    IsTemplateLiteral(L) ? Extract(TemplateLiteralToUnion(L), R) :
-    IsTemplateLiteral(R) ? Extract(L, TemplateLiteralToUnion(R) as any) :
+  return CloneType(
     IsUnion(L) ? ExtractRest(L.anyOf, R) :
     ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never()
-  ), options) as never
+  , options)
 }
diff --git a/src/type/extract/index.ts b/src/type/extract/index.ts
index baa79009e..38bc0a813 100644
--- a/src/type/extract/index.ts
+++ b/src/type/extract/index.ts
@@ -27,4 +27,5 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 export * from './extract-from-mapped-result'
+export * from './extract-from-template-literal'
 export * from './extract'
diff --git a/src/type/template-literal/union.ts b/src/type/template-literal/union.ts
index a5a1f9240..dba883805 100644
--- a/src/type/template-literal/union.ts
+++ b/src/type/template-literal/union.ts
@@ -26,19 +26,31 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import type { Static } from '../static/index'
 import type { TTemplateLiteral } from './template-literal'
-import { Union, type TUnion } from '../union/index'
+import type { UnionToTuple } from '../helpers/index'
+import { UnionEvaluated, type TUnionEvaluated } from '../union/index'
 import { Literal, type TLiteral } from '../literal/index'
-import { type TString } from '../string/index'
-import { type TNever } from '../never/index'
 import { TemplateLiteralGenerate } from './generate'
 
 // ------------------------------------------------------------------
 // TemplateLiteralToUnion
 // ------------------------------------------------------------------
+// prettier-ignore
+export type TTemplateLiteralToUnionLiteralArray<T extends string[], Acc extends TLiteral[] = []> = (
+  T extends [infer L extends string, ...infer R extends string[]]
+    ? TTemplateLiteralToUnionLiteralArray<R, [...Acc, TLiteral<L>]>
+    : Acc
+)
+// prettier-ignore
+export type TTemplateLiteralToUnion<
+  T extends TTemplateLiteral,
+  U extends string[] = UnionToTuple<Static<T>>
+> = TUnionEvaluated<TTemplateLiteralToUnionLiteralArray<U>>
+
 /** Returns a Union from the given TemplateLiteral */
-export function TemplateLiteralToUnion(schema: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]> {
+export function TemplateLiteralToUnion<T extends TTemplateLiteral>(schema: TTemplateLiteral): TTemplateLiteralToUnion<T> {
   const R = TemplateLiteralGenerate(schema) as string[]
   const L = R.map((S) => Literal(S))
-  return Union(L)
+  return UnionEvaluated(L)
 }
diff --git a/src/type/type/json.ts b/src/type/type/json.ts
index 772ff0ee9..af79c93a4 100644
--- a/src/type/type/json.ts
+++ b/src/type/type/json.ts
@@ -33,9 +33,9 @@ import { Composite, type TComposite } from '../composite/index'
 import { Const, type TConst } from '../const/index'
 import { Deref, type TDeref } from '../deref/index'
 import { Enum, type TEnum, type TEnumKey, type TEnumValue } from '../enum/index'
-import { Exclude, type TExclude, type TExcludeFromMappedResult } from '../exclude/index'
+import { Exclude, type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from '../exclude/index'
 import { Extends, type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index'
-import { Extract, type TExtract, type TExtractFromMappedResult } from '../extract/index'
+import { Extract, type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from '../extract/index'
 import { Index, TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult } from '../indexed/index'
 import { Integer, type IntegerOptions, type TInteger } from '../integer/index'
 import { Intersect, type IntersectOptions } from '../intersect/index'
@@ -148,6 +148,8 @@ export class JsonTypeBuilder {
   /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
   public Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>
   /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+  public Exclude<L extends TTemplateLiteral, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromTemplateLiteral<L, R>
+  /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
   public Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>
   /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
   public Exclude(unionType: TSchema, excludedMembers: TSchema, options: SchemaOptions = {}): any {
@@ -166,6 +168,8 @@ export class JsonTypeBuilder {
   /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
   public Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>
   /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+  public Extract<L extends TTemplateLiteral, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromTemplateLiteral<L, R>
+  /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
   public Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>
   /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
   public Extract(type: TSchema, union: TSchema, options: SchemaOptions = {}): any {
diff --git a/test/static/exclude.ts b/test/static/exclude.ts
index 14e1a5104..a63c6c2f4 100644
--- a/test/static/exclude.ts
+++ b/test/static/exclude.ts
@@ -82,3 +82,18 @@ import { Expect } from './assert'
   const T = Type.Exclude(A, B)
   Expect(T).ToStatic<'C' | 'B'>()
 }
+// https://github.com/sinclairzx81/typebox/issues/737
+{
+  const U = Type.Union([Type.Literal('A'), Type.Literal('B')])
+  const T = Type.Object({
+    type: Type.Exclude(U, Type.Literal('A')),
+  })
+  Expect(T).ToStatic<{ type: 'B' }>()
+}
+{
+  const U = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+  const T = Type.Object({
+    type: Type.Exclude(U, Type.Literal('A')),
+  })
+  Expect(T).ToStatic<{ type: 'B' | 'C' }>()
+}
diff --git a/test/static/extract.ts b/test/static/extract.ts
index 0ed6a2a96..b9e621e95 100644
--- a/test/static/extract.ts
+++ b/test/static/extract.ts
@@ -81,3 +81,20 @@ import { Expect } from './assert'
   const T = Type.Extract(A, B)
   Expect(T).ToStatic<'A'>()
 }
+// ------------------------------------------------------------------------
+// Nested (Inference Test)
+// ------------------------------------------------------------------------
+{
+  const U = Type.Union([Type.Literal('A'), Type.Literal('B')])
+  const T = Type.Object({
+    type: Type.Extract(U, Type.Literal('A')),
+  })
+  Expect(T).ToStatic<{ type: 'A' }>()
+}
+{
+  const U = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+  const T = Type.Object({
+    type: Type.Extract(U, Type.Union([Type.Literal('A'), Type.Literal('B')])),
+  })
+  Expect(T).ToStatic<{ type: 'A' | 'B' }>()
+}

From 28164b12252a1a6e8b77bd7f27a56fc5fb6312b0 Mon Sep 17 00:00:00 2001
From: Gabriel Halle <youri801@gmail.com>
Date: Sun, 21 Jan 2024 00:18:04 -0500
Subject: [PATCH 233/369] Recursive Fix: Evaluate Record and Array (#735)

* Fix some infinite recursion with static types

* Adds test for #336

* Fix import path

* Rename unused type parameter
---
 src/type/array/array.ts   |  8 +++++---
 src/type/record/record.ts |  2 +-
 test/static/recursive.ts  | 23 ++++++++++++++++++++++-
 3 files changed, 28 insertions(+), 5 deletions(-)

diff --git a/src/type/array/array.ts b/src/type/array/array.ts
index 09ca326ae..912a5ed37 100644
--- a/src/type/array/array.ts
+++ b/src/type/array/array.ts
@@ -26,10 +26,11 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import type { TSchema, SchemaOptions } from '../schema/index'
+import { CloneType } from '../clone/type'
+import { Ensure } from '../helpers/index'
+import type { SchemaOptions, TSchema } from '../schema/index'
 import type { Static } from '../static/index'
 import { Kind } from '../symbols/index'
-import { CloneType } from '../clone/type'
 
 export interface ArrayOptions extends SchemaOptions {
   /** The minimum number of items in this array */
@@ -45,9 +46,10 @@ export interface ArrayOptions extends SchemaOptions {
   /** A maximum number of contains schema matches */
   maxContains?: number
 }
+type ArrayStatic<T extends TSchema, P extends unknown[]> = Ensure<Static<T, P>[]>
 export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
   [Kind]: 'Array'
-  static: Array<Static<T, this['params']>>
+  static: ArrayStatic<T, this['params']>
   type: 'array'
   items: T
 }
diff --git a/src/type/record/record.ts b/src/type/record/record.ts
index 53c4011d0..b4ff98460 100644
--- a/src/type/record/record.ts
+++ b/src/type/record/record.ts
@@ -181,7 +181,7 @@ function FromNumberKey<K extends TNumber, T extends TSchema>(_: K, T: T, options
 // ------------------------------------------------------------------
 // prettier-ignore
 type RecordStatic<K extends TSchema, T extends TSchema, P extends unknown[]> = (
-  Evaluate<Record<Assert<Static<K>, PropertyKey>, Static<T, P>>>
+  Evaluate<{ [_ in Assert<Static<K>, PropertyKey>]: Static<T, P>; }>
 )
 // prettier-ignore
 export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
diff --git a/test/static/recursive.ts b/test/static/recursive.ts
index cfd5a76c5..c1e8bcd26 100644
--- a/test/static/recursive.ts
+++ b/test/static/recursive.ts
@@ -1,5 +1,5 @@
+import { Static, Type } from '@sinclair/typebox'
 import { Expect } from './assert'
-import { Type, Static } from '@sinclair/typebox'
 
 {
   // identity
@@ -78,3 +78,24 @@ import { Type, Static } from '@sinclair/typebox'
     nodes: Static<typeof T>[]
   }>()
 }
+{
+  // issue: https://github.com/sinclairzx81/typebox/issues/336
+  type JSONValue =
+    | string
+    | number
+    | null
+    | boolean
+    | { [x: string]: JSONValue }
+    | JSONValue[]
+  const R = Type.Recursive((Node) =>
+    Type.Union([
+      Type.Null(),
+      Type.String(),
+      Type.Number(),
+      Type.Boolean(),
+      Type.Record(Type.String(), Node),
+      Type.Array(Node),
+    ]),
+  )
+  Expect(R).ToStatic<JSONValue>()
+}

From 22ee96ad0431d3cf612d2b13ba1897eb4da11b4b Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 21 Jan 2024 15:09:01 +0900
Subject: [PATCH 234/369] Revision 0.32.12 (#740)

* Branch

* Record Options | Option Asssignment Tests

* Version
---
 package-lock.json                           |   4 +-
 package.json                                |   2 +-
 src/type/type/json.ts                       |   2 +-
 test/runtime/type/index.ts                  |   1 +
 test/runtime/type/options/assign-builder.ts | 266 ++++++++++++++++++++
 test/runtime/type/options/assign.ts         | 263 +++++++++++++++++++
 test/runtime/type/options/index.ts          |   2 +
 test/static/recursive.ts                    |  31 ++-
 8 files changed, 551 insertions(+), 20 deletions(-)
 create mode 100644 test/runtime/type/options/assign-builder.ts
 create mode 100644 test/runtime/type/options/assign.ts
 create mode 100644 test/runtime/type/options/index.ts

diff --git a/package-lock.json b/package-lock.json
index 292708f95..db5bd313b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.11",
+  "version": "0.32.12",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.11",
+      "version": "0.32.12",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 26107da3d..f54449430 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.11",
+  "version": "0.32.12",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/type/json.ts b/src/type/type/json.ts
index af79c93a4..3d1854005 100644
--- a/src/type/type/json.ts
+++ b/src/type/type/json.ts
@@ -273,7 +273,7 @@ export class JsonTypeBuilder {
   }
   /** `[Json]` Creates a Record type */
   public Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options: ObjectOptions = {}): TRecordOrObject<K, T> {
-    return Record(key, schema)
+    return Record(key, schema, options)
   }
   /** `[Json]` Creates a Recursive type */
   public Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options: SchemaOptions = {}): TRecursive<T> {
diff --git a/test/runtime/type/index.ts b/test/runtime/type/index.ts
index d05528481..120c570f6 100644
--- a/test/runtime/type/index.ts
+++ b/test/runtime/type/index.ts
@@ -3,6 +3,7 @@ import './extends/index'
 import './guard/index'
 import './intrinsic/index'
 import './normalize/index'
+import './options/index'
 import './registry/index'
 import './sets/index'
 import './template-literal/index'
diff --git a/test/runtime/type/options/assign-builder.ts b/test/runtime/type/options/assign-builder.ts
new file mode 100644
index 000000000..f24e04fa3
--- /dev/null
+++ b/test/runtime/type/options/assign-builder.ts
@@ -0,0 +1,266 @@
+import { JavaScriptTypeBuilder } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+const Type = new JavaScriptTypeBuilder()
+
+// TypeBuilder will proxy calls through to the raw function API
+describe('type/options/AssignTypeBuilder', () => {
+  it('Should assign options for Any', () => {
+    const T = Type.Any({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Array', () => {
+    const T = Type.Array(Type.String(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for AsyncIterator', () => {
+    const T = Type.AsyncIterator(Type.String(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Awaited', () => {
+    const T = Type.Awaited(Type.String(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for BigInt', () => {
+    const T = Type.BigInt({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Boolean', () => {
+    const T = Type.Boolean({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Capitalize', () => {
+    const T = Type.Capitalize(Type.Literal('hello'), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Composite', () => {
+    const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Const', () => {
+    const T = Type.Const(1, { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Constructor', () => {
+    const T = Type.Constructor([], Type.Any(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Date', () => {
+    const T = Type.Date({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Enum', () => {
+    const T = Type.Enum({}, { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Exclude', () => {
+    const T = Type.Exclude(Type.Union([Type.Literal(1), Type.Literal(2)]), Type.Literal(2), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Extends', () => {
+    const T = Type.Extends(Type.String(), Type.String(), Type.Number(), Type.Null(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Extract', () => {
+    const T = Type.Extract(Type.Union([Type.Literal(1), Type.Literal(2)]), Type.Literal(2), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Function', () => {
+    const T = Type.Function([], Type.Any(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Integer', () => {
+    const T = Type.Integer({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Intersect 1', () => {
+    const T = Type.Intersect([], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Intersect 2', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.Number() })], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Intersect 3', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Iterator', () => {
+    const T = Type.Iterator(Type.String(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for KeyOf', () => {
+    const T = Type.KeyOf(Type.Object({ x: Type.Number() }), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Literal', () => {
+    const T = Type.Literal(1, { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Lowercase', () => {
+    const T = Type.Lowercase(Type.Literal('hello'), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Mapped 1', () => {
+    const M = Type.Mapped(Type.TemplateLiteral('${1|2|3}'), (K) => K, { foo: 'bar' })
+    Assert.IsEqual(M.foo, 'bar')
+  })
+  it('Should assign options for Mapped 2', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const M = Type.Mapped(Type.KeyOf(T), (K) => Type.Index(T, K), { foo: 'bar' })
+    Assert.IsEqual(M.foo, 'bar')
+  })
+  it('Should assign options for Never', () => {
+    const T = Type.Never({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Not', () => {
+    const T = Type.Not(Type.String(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Null', () => {
+    const T = Type.Null({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Number', () => {
+    const T = Type.Number({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Object', () => {
+    const T = Type.Object(
+      {
+        x: Type.String(),
+      },
+      { foo: 'bar' },
+    )
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Omit', () => {
+    const T = Type.Omit(
+      Type.Object({
+        x: Type.String(),
+        y: Type.String(),
+      }),
+      ['x'],
+      { foo: 'bar' },
+    )
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Partial', () => {
+    const T = Type.Partial(
+      Type.Object({
+        x: Type.String(),
+      }),
+      { foo: 'bar' },
+    )
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Pick', () => {
+    const T = Type.Pick(
+      Type.Object({
+        x: Type.String(),
+        y: Type.String(),
+      }),
+      ['x'],
+      { foo: 'bar' },
+    )
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Record', () => {
+    const T = Type.Record(Type.String(), Type.Number(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Recursive', () => {
+    const T = Type.Recursive(
+      (This) =>
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Array(This),
+        }),
+      { foo: 'bar' },
+    )
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Ref 1', () => {
+    const T = Type.Object({ x: Type.Number() }, { $id: 'T' })
+    const R = Type.Ref(T, { foo: 'bar' })
+    Assert.IsEqual(R.foo, 'bar')
+  })
+  it('Should assign options for Ref 2', () => {
+    const R = Type.Ref('T', { foo: 'bar' })
+    Assert.IsEqual(R.foo, 'bar')
+  })
+  it('Should assign options for RegExp', () => {
+    const R = Type.RegExp(/xyz/, { foo: 'bar' })
+    Assert.IsEqual(R.foo, 'bar')
+  })
+  it('Should assign options for Partial', () => {
+    const T = Type.Required(
+      Type.Object({
+        x: Type.String(),
+      }),
+      { foo: 'bar' },
+    )
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for String', () => {
+    const T = Type.String({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Symbol', () => {
+    const T = Type.Symbol({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for TemplateLiteral 1', () => {
+    const T = Type.TemplateLiteral('hello${1|2|3}', { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for TemplateLiteral 2', () => {
+    const T = Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal('1'), Type.Literal('2'), Type.Literal('3')])], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Tuple 1', () => {
+    const T = Type.Tuple([], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Tuple 2', () => {
+    const T = Type.Tuple([Type.String(), Type.Number()], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Uint8Array', () => {
+    const T = Type.Uint8Array({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Uncapitalize', () => {
+    const T = Type.Uncapitalize(Type.Literal('hello'), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Undefined', () => {
+    const T = Type.Undefined({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Union 1', () => {
+    const T = Type.Union([], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Union 1', () => {
+    const T = Type.Union([Type.String()], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Union 1', () => {
+    const T = Type.Union([Type.String(), Type.Boolean()], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Unknown', () => {
+    const T = Type.Unknown({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Uppercase', () => {
+    const T = Type.Uppercase(Type.Literal('hello'), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Void', () => {
+    const T = Type.Void({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+})
diff --git a/test/runtime/type/options/assign.ts b/test/runtime/type/options/assign.ts
new file mode 100644
index 000000000..274d2f4bb
--- /dev/null
+++ b/test/runtime/type/options/assign.ts
@@ -0,0 +1,263 @@
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('type/options/Assign', () => {
+  it('Should assign options for Any', () => {
+    const T = Type.Any({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Array', () => {
+    const T = Type.Array(Type.String(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for AsyncIterator', () => {
+    const T = Type.AsyncIterator(Type.String(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Awaited', () => {
+    const T = Type.Awaited(Type.String(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for BigInt', () => {
+    const T = Type.BigInt({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Boolean', () => {
+    const T = Type.Boolean({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Capitalize', () => {
+    const T = Type.Capitalize(Type.Literal('hello'), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Composite', () => {
+    const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Const', () => {
+    const T = Type.Const(1, { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Constructor', () => {
+    const T = Type.Constructor([], Type.Any(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Date', () => {
+    const T = Type.Date({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Enum', () => {
+    const T = Type.Enum({}, { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Exclude', () => {
+    const T = Type.Exclude(Type.Union([Type.Literal(1), Type.Literal(2)]), Type.Literal(2), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Extends', () => {
+    const T = Type.Extends(Type.String(), Type.String(), Type.Number(), Type.Null(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Extract', () => {
+    const T = Type.Extract(Type.Union([Type.Literal(1), Type.Literal(2)]), Type.Literal(2), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Function', () => {
+    const T = Type.Function([], Type.Any(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Integer', () => {
+    const T = Type.Integer({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Intersect 1', () => {
+    const T = Type.Intersect([], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Intersect 2', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.Number() })], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Intersect 3', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Iterator', () => {
+    const T = Type.Iterator(Type.String(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for KeyOf', () => {
+    const T = Type.KeyOf(Type.Object({ x: Type.Number() }), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Literal', () => {
+    const T = Type.Literal(1, { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Lowercase', () => {
+    const T = Type.Lowercase(Type.Literal('hello'), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Mapped 1', () => {
+    const M = Type.Mapped(Type.TemplateLiteral('${1|2|3}'), (K) => K, { foo: 'bar' })
+    Assert.IsEqual(M.foo, 'bar')
+  })
+  it('Should assign options for Mapped 2', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const M = Type.Mapped(Type.KeyOf(T), (K) => Type.Index(T, K), { foo: 'bar' })
+    Assert.IsEqual(M.foo, 'bar')
+  })
+  it('Should assign options for Never', () => {
+    const T = Type.Never({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Not', () => {
+    const T = Type.Not(Type.String(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Null', () => {
+    const T = Type.Null({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Number', () => {
+    const T = Type.Number({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Object', () => {
+    const T = Type.Object(
+      {
+        x: Type.String(),
+      },
+      { foo: 'bar' },
+    )
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Omit', () => {
+    const T = Type.Omit(
+      Type.Object({
+        x: Type.String(),
+        y: Type.String(),
+      }),
+      ['x'],
+      { foo: 'bar' },
+    )
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Partial', () => {
+    const T = Type.Partial(
+      Type.Object({
+        x: Type.String(),
+      }),
+      { foo: 'bar' },
+    )
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Pick', () => {
+    const T = Type.Pick(
+      Type.Object({
+        x: Type.String(),
+        y: Type.String(),
+      }),
+      ['x'],
+      { foo: 'bar' },
+    )
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Record', () => {
+    const T = Type.Record(Type.String(), Type.Number(), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Recursive', () => {
+    const T = Type.Recursive(
+      (This) =>
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Array(This),
+        }),
+      { foo: 'bar' },
+    )
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Ref 1', () => {
+    const T = Type.Object({ x: Type.Number() }, { $id: 'T' })
+    const R = Type.Ref(T, { foo: 'bar' })
+    Assert.IsEqual(R.foo, 'bar')
+  })
+  it('Should assign options for Ref 2', () => {
+    const R = Type.Ref('T', { foo: 'bar' })
+    Assert.IsEqual(R.foo, 'bar')
+  })
+  it('Should assign options for RegExp', () => {
+    const R = Type.RegExp(/xyz/, { foo: 'bar' })
+    Assert.IsEqual(R.foo, 'bar')
+  })
+  it('Should assign options for Partial', () => {
+    const T = Type.Required(
+      Type.Object({
+        x: Type.String(),
+      }),
+      { foo: 'bar' },
+    )
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for String', () => {
+    const T = Type.String({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Symbol', () => {
+    const T = Type.Symbol({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for TemplateLiteral 1', () => {
+    const T = Type.TemplateLiteral('hello${1|2|3}', { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for TemplateLiteral 2', () => {
+    const T = Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal('1'), Type.Literal('2'), Type.Literal('3')])], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Tuple 1', () => {
+    const T = Type.Tuple([], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Tuple 2', () => {
+    const T = Type.Tuple([Type.String(), Type.Number()], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Uint8Array', () => {
+    const T = Type.Uint8Array({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Uncapitalize', () => {
+    const T = Type.Uncapitalize(Type.Literal('hello'), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Undefined', () => {
+    const T = Type.Undefined({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Union 1', () => {
+    const T = Type.Union([], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Union 1', () => {
+    const T = Type.Union([Type.String()], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Union 1', () => {
+    const T = Type.Union([Type.String(), Type.Boolean()], { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Unknown', () => {
+    const T = Type.Unknown({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Uppercase', () => {
+    const T = Type.Uppercase(Type.Literal('hello'), { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+  it('Should assign options for Void', () => {
+    const T = Type.Void({ foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+})
diff --git a/test/runtime/type/options/index.ts b/test/runtime/type/options/index.ts
new file mode 100644
index 000000000..2b378f7fd
--- /dev/null
+++ b/test/runtime/type/options/index.ts
@@ -0,0 +1,2 @@
+import './assign-builder'
+import './assign'
diff --git a/test/static/recursive.ts b/test/static/recursive.ts
index c1e8bcd26..3c4cc9aee 100644
--- a/test/static/recursive.ts
+++ b/test/static/recursive.ts
@@ -78,24 +78,23 @@ import { Expect } from './assert'
     nodes: Static<typeof T>[]
   }>()
 }
+// prettier-ignore
 {
   // issue: https://github.com/sinclairzx81/typebox/issues/336
-  type JSONValue =
-    | string
-    | number
-    | null
-    | boolean
-    | { [x: string]: JSONValue }
+  type JSONValue = 
+    | string 
+    | number 
+    | null 
+    | boolean 
+    | { [x: string]: JSONValue } 
     | JSONValue[]
-  const R = Type.Recursive((Node) =>
-    Type.Union([
-      Type.Null(),
-      Type.String(),
-      Type.Number(),
-      Type.Boolean(),
-      Type.Record(Type.String(), Node),
-      Type.Array(Node),
-    ]),
-  )
+  const R = Type.Recursive((Node) => Type.Union([
+    Type.Null(), 
+    Type.String(), 
+    Type.Number(), 
+    Type.Boolean(), 
+    Type.Record(Type.String(), Node), 
+    Type.Array(Node)
+  ]))
   Expect(R).ToStatic<JSONValue>()
 }

From 52c71ed6df7187f6ad93460a548de1bfad9893e8 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 26 Jan 2024 06:50:39 +0900
Subject: [PATCH 235/369] Revision 0.32.13 (#744)

* Add String Length Contraints to RegExp

* Version

* Guard Test
---
 package-lock.json                             |  4 ++--
 package.json                                  |  2 +-
 src/compiler/compiler.ts                      |  2 ++
 src/errors/errors.ts                          |  7 +++++++
 src/index.ts                                  |  2 +-
 src/type/guard/type.ts                        |  4 +++-
 src/type/regexp/regexp.ts                     | 12 +++++++++---
 src/type/type/javascript.ts                   |  8 ++++----
 src/value/check/check.ts                      |  6 ++++++
 test/runtime/compiler/regexp.ts               | 14 ++++++++++++++
 test/runtime/errors/types/index.ts            |  2 ++
 .../runtime/errors/types/regexp-max-length.ts | 19 +++++++++++++++++++
 .../runtime/errors/types/regexp-min-length.ts | 19 +++++++++++++++++++
 test/runtime/type/guard/regexp.ts             | 10 ++++++++++
 test/runtime/value/check/regexp.ts            | 14 ++++++++++++++
 15 files changed, 113 insertions(+), 12 deletions(-)
 create mode 100644 test/runtime/errors/types/regexp-max-length.ts
 create mode 100644 test/runtime/errors/types/regexp-min-length.ts

diff --git a/package-lock.json b/package-lock.json
index db5bd313b..20bbc610d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.12",
+  "version": "0.32.13",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.12",
+      "version": "0.32.13",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index f54449430..ce36002d0 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.12",
+  "version": "0.32.13",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index e05257958..39cb2f4c2 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -391,6 +391,8 @@ export namespace TypeCompiler {
   function* FromRegExp(schema: TRegExp, references: TSchema[], value: string): IterableIterator<string> {
     const variable = CreateVariable(`${new RegExp(schema.source, schema.flags)};`)
     yield `(typeof ${value} === 'string')`
+    if (IsNumber(schema.maxLength)) yield `${value}.length <= ${schema.maxLength}`
+    if (IsNumber(schema.minLength)) yield `${value}.length >= ${schema.minLength}`
     yield `${variable}.test(${value})`
   }
   function* FromString(schema: TString, references: TSchema[], value: string): IterableIterator<string> {
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 7bd658f3e..f81de1a69 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -444,6 +444,13 @@ function* FromRef(schema: TRef, references: TSchema[], path: string, value: any)
   yield* Visit(Deref(schema, references), references, path, value)
 }
 function* FromRegExp(schema: TRegExp, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  if (!IsString(value)) return yield Create(ValueErrorType.String, schema, path, value)
+  if (IsDefined<number>(schema.minLength) && !(value.length >= schema.minLength)) {
+    yield Create(ValueErrorType.StringMinLength, schema, path, value)
+  }
+  if (IsDefined<number>(schema.maxLength) && !(value.length <= schema.maxLength)) {
+    yield Create(ValueErrorType.StringMaxLength, schema, path, value)
+  }
   const regex = new RegExp(schema.source, schema.flags)
   if (!regex.test(value)) {
     return yield Create(ValueErrorType.RegExp, schema, path, value)
diff --git a/src/index.ts b/src/index.ts
index 2108648d5..393709386 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -121,7 +121,7 @@ export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-option
 export { Record, type TRecord, type TRecordOrObject } from './type/record/index'
 export { Recursive, type TRecursive, type TThis } from './type/recursive/index'
 export { Ref, type TRef } from './type/ref/index'
-export { RegExp, type TRegExp } from './type/regexp/index'
+export { RegExp, type TRegExp, type RegExpOptions } from './type/regexp/index'
 export { Required, type TRequired, type TRequiredFromMappedResult } from './type/required/index'
 export { Rest, type TRest } from './type/rest/index'
 export { ReturnType, type TReturnType } from './type/return-type/index'
diff --git a/src/type/guard/type.ts b/src/type/guard/type.ts
index 98eada8ce..5282c5713 100644
--- a/src/type/guard/type.ts
+++ b/src/type/guard/type.ts
@@ -444,7 +444,9 @@ export function IsRegExp(value: unknown): value is TRegExp {
     IsKindOf(value, 'RegExp') &&
     IsOptionalString(value.$id) &&
     ValueGuard.IsString(value.source) &&
-    ValueGuard.IsString(value.flags)
+    ValueGuard.IsString(value.flags) &&
+    IsOptionalNumber(value.maxLength) &&
+    IsOptionalNumber(value.minLength)
   )
 }
 /** Returns true if the given value is TString */
diff --git a/src/type/regexp/regexp.ts b/src/type/regexp/regexp.ts
index f43257710..c4d0030d0 100644
--- a/src/type/regexp/regexp.ts
+++ b/src/type/regexp/regexp.ts
@@ -31,6 +31,12 @@ import type { TSchema } from '../schema/index'
 import { IsString } from '../guard/value'
 import { Kind } from '../symbols/index'
 
+export interface RegExpOptions extends SchemaOptions {
+  /** The maximum length of the string */
+  maxLength?: number
+  /** The minimum length of the string */
+  minLength?: number
+}
 export interface TRegExp extends TSchema {
   [Kind]: 'RegExp'
   static: `${string}`
@@ -40,11 +46,11 @@ export interface TRegExp extends TSchema {
 }
 
 /** `[JavaScript]` Creates a RegExp type */
-export function RegExp(pattern: string, options?: SchemaOptions): TRegExp
+export function RegExp(pattern: string, options?: RegExpOptions): TRegExp
 /** `[JavaScript]` Creates a RegExp type */
-export function RegExp(regex: RegExp, options?: SchemaOptions): TRegExp
+export function RegExp(regex: RegExp, options?: RegExpOptions): TRegExp
 /** `[JavaScript]` Creates a RegExp type */
-export function RegExp(unresolved: RegExp | string, options: SchemaOptions = {}) {
+export function RegExp(unresolved: RegExp | string, options: RegExpOptions = {}) {
   const expr = IsString(unresolved) ? new globalThis.RegExp(unresolved) : unresolved
   return { ...options, [Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags } as never
 }
diff --git a/src/type/type/javascript.ts b/src/type/type/javascript.ts
index a5c170153..ec87ac728 100644
--- a/src/type/type/javascript.ts
+++ b/src/type/type/javascript.ts
@@ -38,7 +38,7 @@ import { InstanceType, type TInstanceType } from '../instance-type/index'
 import { Iterator, type TIterator } from '../iterator/index'
 import { Parameters, type TParameters } from '../parameters/index'
 import { Promise, type TPromise } from '../promise/index'
-import { RegExp, type TRegExp } from '../regexp/index'
+import { RegExp, type TRegExp, RegExpOptions } from '../regexp/index'
 import { ReturnType, type TReturnType } from '../return-type/index'
 import { type TSchema, type SchemaOptions } from '../schema/index'
 import { Symbol, type TSymbol } from '../symbol/index'
@@ -93,11 +93,11 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     return Promise(item, options)
   }
   /** `[JavaScript]` Creates a RegExp type */
-  public RegExp(pattern: string, options?: SchemaOptions): TRegExp
+  public RegExp(pattern: string, options?: RegExpOptions): TRegExp
   /** `[JavaScript]` Creates a RegExp type */
-  public RegExp(regex: RegExp, options?: SchemaOptions): TRegExp
+  public RegExp(regex: RegExp, options?: RegExpOptions): TRegExp
   /** `[JavaScript]` Creates a RegExp type */
-  public RegExp(unresolved: string | RegExp, options: SchemaOptions = {}) {
+  public RegExp(unresolved: string | RegExp, options: RegExpOptions = {}) {
     return RegExp(unresolved as any, options)
   }
   /** `[JavaScript]` Extracts the ReturnType from the given Function type */
diff --git a/src/value/check/check.ts b/src/value/check/check.ts
index e05fee2d7..436c0f047 100644
--- a/src/value/check/check.ts
+++ b/src/value/check/check.ts
@@ -329,6 +329,12 @@ function FromRef(schema: TRef, references: TSchema[], value: any): boolean {
 }
 function FromRegExp(schema: TRegExp, references: TSchema[], value: any): boolean {
   const regex = new RegExp(schema.source, schema.flags)
+  if (IsDefined<number>(schema.minLength)) {
+    if (!(value.length >= schema.minLength)) return false
+  }
+  if (IsDefined<number>(schema.maxLength)) {
+    if (!(value.length <= schema.maxLength)) return false
+  }
   return regex.test(value)
 }
 function FromString(schema: TString, references: TSchema[], value: any): boolean {
diff --git a/test/runtime/compiler/regexp.ts b/test/runtime/compiler/regexp.ts
index 5a9bf09b8..d4dda52e6 100644
--- a/test/runtime/compiler/regexp.ts
+++ b/test/runtime/compiler/regexp.ts
@@ -13,4 +13,18 @@ describe('compiler/RegExp', () => {
     const T = Type.RegExp(/<a?:.+?:\d{18}>|\p{Extended_Pictographic}/gu)
     Ok(T, '♥️♦️♠️♣️')
   })
+  it('Should validate with minLength constraint', () => {
+    const T = Type.RegExp(/(.*)/, {
+      minLength: 3,
+    })
+    Ok(T, 'xxx')
+    Fail(T, 'xx')
+  })
+  it('Should validate with maxLength constraint', () => {
+    const T = Type.RegExp(/(.*)/, {
+      maxLength: 3,
+    })
+    Ok(T, 'xxx')
+    Fail(T, 'xxxx')
+  })
 })
diff --git a/test/runtime/errors/types/index.ts b/test/runtime/errors/types/index.ts
index 3329f6b54..18084a348 100644
--- a/test/runtime/errors/types/index.ts
+++ b/test/runtime/errors/types/index.ts
@@ -48,6 +48,8 @@ import './object-required-property'
 import './object'
 import './promise'
 import './record-pointer-property'
+import './regexp-max-length'
+import './regexp-min-length'
 import './regexp'
 import './string-format-unknown'
 import './string-format'
diff --git a/test/runtime/errors/types/regexp-max-length.ts b/test/runtime/errors/types/regexp-max-length.ts
new file mode 100644
index 000000000..22f8fd7c9
--- /dev/null
+++ b/test/runtime/errors/types/regexp-max-length.ts
@@ -0,0 +1,19 @@
+import { Type, FormatRegistry } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/RegExpMaxLength', () => {
+  const T = Type.RegExp(/(.*)/, {
+    maxLength: 4,
+  })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 'xxxx')
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 'xxxxx')
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.StringMaxLength)
+  })
+})
diff --git a/test/runtime/errors/types/regexp-min-length.ts b/test/runtime/errors/types/regexp-min-length.ts
new file mode 100644
index 000000000..3bd6227bb
--- /dev/null
+++ b/test/runtime/errors/types/regexp-min-length.ts
@@ -0,0 +1,19 @@
+import { Type } from '@sinclair/typebox'
+import { ValueErrorType } from '@sinclair/typebox/errors'
+import { Resolve } from './resolve'
+import { Assert } from '../../assert'
+
+describe('errors/type/RegExpMinLength', () => {
+  const T = Type.RegExp(/(.*)/, {
+    minLength: 4,
+  })
+  it('Should pass 0', () => {
+    const R = Resolve(T, 'xxxx')
+    Assert.IsEqual(R.length, 0)
+  })
+  it('Should pass 1', () => {
+    const R = Resolve(T, 'xxx')
+    Assert.IsEqual(R.length, 1)
+    Assert.IsEqual(R[0].type, ValueErrorType.StringMinLength)
+  })
+})
diff --git a/test/runtime/type/guard/regexp.ts b/test/runtime/type/guard/regexp.ts
index 845c1753d..558329cba 100644
--- a/test/runtime/type/guard/regexp.ts
+++ b/test/runtime/type/guard/regexp.ts
@@ -20,4 +20,14 @@ describe('type/guard/TRegExp', () => {
     const T = Type.RegExp('foo', { $id: 1 })
     Assert.IsFalse(TypeGuard.IsRegExp(T))
   })
+  it('Should guard for RegExp constraint 1', () => {
+    // @ts-ignore
+    const T = Type.RegExp('foo', { maxLength: '1' })
+    Assert.IsFalse(TypeGuard.IsRegExp(T))
+  })
+  it('Should guard for RegExp constraint 2', () => {
+    // @ts-ignore
+    const T = Type.RegExp('foo', { minLength: '1' })
+    Assert.IsFalse(TypeGuard.IsRegExp(T))
+  })
 })
diff --git a/test/runtime/value/check/regexp.ts b/test/runtime/value/check/regexp.ts
index ce843038e..f25958126 100644
--- a/test/runtime/value/check/regexp.ts
+++ b/test/runtime/value/check/regexp.ts
@@ -33,4 +33,18 @@ describe('value/check/RegExp', () => {
     const result = Value.Check(T, value)
     Assert.IsEqual(result, false)
   })
+  it('Should validate with minLength constraint', () => {
+    const T = Type.RegExp(/(.*)/, {
+      minLength: 3,
+    })
+    Assert.IsTrue(Value.Check(T, 'xxx'))
+    Assert.IsFalse(Value.Check(T, 'xx'))
+  })
+  it('Should validate with maxLength constraint', () => {
+    const T = Type.RegExp(/(.*)/, {
+      maxLength: 3,
+    })
+    Assert.IsTrue(Value.Check(T, 'xxx'))
+    Assert.IsFalse(Value.Check(T, 'xxxx'))
+  })
 })

From fd1056b367479c7a9925143641d272b4a238ffad Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 11 Feb 2024 12:16:13 +0900
Subject: [PATCH 236/369] Revision 0.32.14 (#753)

* Simplify Exports

* Version
---
 package-lock.json         |   4 +-
 package.json              |   2 +-
 src/index.ts              | 193 ++++++++++++++------------------------
 src/type/clone/index.ts   |   4 +-
 src/type/const/const.ts   |   4 +-
 src/type/object/object.ts |   2 +-
 6 files changed, 77 insertions(+), 132 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 20bbc610d..afcf1b69a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.13",
+  "version": "0.32.14",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.13",
+      "version": "0.32.14",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index ce36002d0..1ab2c08c5 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.13",
+  "version": "0.32.14",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/index.ts b/src/index.ts
index 393709386..dbbe67127 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -29,133 +29,78 @@ THE SOFTWARE.
 // ------------------------------------------------------------------
 // Infrastructure
 // ------------------------------------------------------------------
-export { Kind, Hint, ReadonlyKind, OptionalKind, TransformKind } from './type/symbols/index'
-export { PatternBoolean, PatternBooleanExact, PatternNumber, PatternNumberExact, PatternString, PatternStringExact } from './type/patterns/index'
-export { TypeRegistry, FormatRegistry } from './type/registry/index'
-export { TypeGuard, ValueGuard } from './type/guard/index'
-export { CloneType, CloneRest } from './type/clone/type'
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export { TypeBoxError } from './type/error/index'
-// ------------------------------------------------------------------
-// Sets
-// ------------------------------------------------------------------
-export {
-  SetComplement,
-  SetDistinct,
-  SetIncludes,
-  SetIntersect,
-  SetIntersectMany,
-  SetIsSubset,
-  SetUnion,
-  SetUnionMany,
-  type TSetComplement,
-  type TSetDistinct,
-  type TSetIncludes,
-  type TSetIntersect,
-  type TSetIntersectMany,
-  type TSetIsSubset,
-  type TSetUnion,
-  type TSetUnionMany,
-} from './type/sets/index'
-// ------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------
-export { Increment, type TIncrement, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index'
+export * from './type/clone/index'
+export * from './type/error/index'
+export * from './type/guard/index'
+export * from './type/helpers/index'
+export * from './type/patterns/index'
+export * from './type/registry/index'
+export * from './type/sets/index'
+export * from './type/symbols/index'
 // ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
-export { Any, type TAny } from './type/any/index'
-export { Array, type TArray, type ArrayOptions } from './type/array/index'
-export { AsyncIterator, type TAsyncIterator } from './type/async-iterator/index'
-export { Awaited, type TAwaited } from './type/awaited/index'
-export { BigInt, type TBigInt, type BigIntOptions } from './type/bigint/index'
-export { Boolean, type TBoolean } from './type/boolean/index'
-export { Composite, type TComposite } from './type/composite/index'
-export { Const, type TConst } from './type/const/index'
-export { Constructor, type TConstructor } from './type/constructor/index'
-export { ConstructorParameters, type TConstructorParameters } from './type/constructor-parameters/index'
-export { Date, type TDate, type DateOptions } from './type/date/index'
-export { Deref, type TDeref } from './type/deref/index'
-export { Enum, type TEnum } from './type/enum/index'
-export { Exclude, type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from './type/exclude/index'
-export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey } from './type/extends/index'
-export { Extract, type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from './type/extract/index'
-export { Function, type TFunction } from './type/function/index'
-export {
-  Index,
-  IndexPropertyKeys,
-  IndexFromPropertyKeys,
-  IndexFromPropertyKey,
-  IndexFromMappedKey,
-  IndexFromMappedResult,
-  type TIndex,
-  type TIndexPropertyKeys,
-  type TIndexFromPropertyKeys,
-  type TIndexFromPropertyKey,
-  type TIndexFromMappedKey,
-  type TIndexFromMappedResult,
-} from './type/indexed/index'
-export { InstanceType, type TInstanceType } from './type/instance-type/index'
-export { Integer, type TInteger, type IntegerOptions } from './type/integer/index'
-export { Intersect, IntersectEvaluated, type TIntersect, type TIntersectEvaluated, type IntersectOptions } from './type/intersect/index'
-export { Iterator, type TIterator } from './type/iterator/index'
-export { Intrinsic, IntrinsicFromMappedKey, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index'
-export { KeyOf, KeyOfPropertyKeys, KeyOfPropertyKeysToRest, KeyOfFromMappedResult, KeyOfPattern, type TKeyOf, type TKeyOfPropertyKeys, type TKeyOfPropertyKeysToRest, type TKeyOfFromMappedResult } from './type/keyof/index'
-export { Literal, type TLiteral, type TLiteralValue } from './type/literal/index'
-export { Mapped, MappedKey, MappedResult, MappedFunctionReturnType, type TMapped, type TMappedKey, type TMappedResult, type TMappedFunction, type TMappedFunctionReturnType } from './type/mapped/index'
-export { Never, type TNever } from './type/never/index'
-export { Not, type TNot } from './type/not/index'
-export { Null, type TNull } from './type/null/index'
-export { Number, type TNumber, type NumberOptions } from './type/number/index'
-export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index'
-export { Omit, type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from './type/omit/index'
-export { Optional, OptionalFromMappedResult, type TOptional, type TOptionalWithFlag, type TOptionalFromMappedResult } from './type/optional/index'
-export { Parameters, type TParameters } from './type/parameters/index'
-export { Partial, PartialFromMappedResult, type TPartial, type TPartialFromMappedResult } from './type/partial/index'
-export { Pick, type TPick, type TPickFromMappedKey, type TPickFromMappedResult } from './type/pick/index'
-export { Promise, type TPromise } from './type/promise/index'
-export { Readonly, ReadonlyFromMappedResult, type TReadonly, type TReadonlyWithFlag, type TReadonlyFromMappedResult } from './type/readonly/index'
-export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index'
-export { Record, type TRecord, type TRecordOrObject } from './type/record/index'
-export { Recursive, type TRecursive, type TThis } from './type/recursive/index'
-export { Ref, type TRef } from './type/ref/index'
-export { RegExp, type TRegExp, type RegExpOptions } from './type/regexp/index'
-export { Required, type TRequired, type TRequiredFromMappedResult } from './type/required/index'
-export { Rest, type TRest } from './type/rest/index'
-export { ReturnType, type TReturnType } from './type/return-type/index'
-export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from './type/schema/index'
-export { type Static, type StaticDecode, type StaticEncode, type TDecodeType, type TDecodeRest, type TDecodeProperties } from './type/static/index'
-export { Strict } from './type/strict/index'
-export { String, type TString, type StringOptions, type StringFormatOption, type StringContentEncodingOption } from './type/string/index'
-export { Symbol, type TSymbol, type TSymbolValue } from './type/symbol/index'
-export {
-  TemplateLiteral,
-  TemplateLiteralSyntax,
-  TemplateLiteralGenerate,
-  TemplateLiteralParse,
-  TemplateLiteralParseExact,
-  TemplateLiteralToUnion,
-  IsTemplateLiteralFinite,
-  TemplateLiteralExpressionGenerate,
-  IsTemplateLiteralExpressionFinite,
-  type TTemplateLiteral,
-  type TTemplateLiteralSyntax,
-  type TTemplateLiteralGenerate,
-  type TTemplateLiteralKind,
-  type TTemplateLiteralToUnion,
-  type TIsTemplateLiteralFinite,
-} from './type/template-literal/index'
-export { Transform, TransformDecodeBuilder, TransformEncodeBuilder, type TTransform, type TransformOptions, type TransformFunction } from './type/transform/index'
-export { Tuple, type TTuple } from './type/tuple/index'
-export { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from './type/uint8array/index'
-export { Undefined, type TUndefined } from './type/undefined/index'
-export { Union, UnionEvaluated, type TUnion, type TUnionEvaluated } from './type/union/index'
-export { Unknown, type TUnknown } from './type/unknown/index'
-export { Unsafe, type TUnsafe } from './type/unsafe/index'
-export { Void, type TVoid } from './type/void/index'
+export * from './type/any/index'
+export * from './type/array/index'
+export * from './type/async-iterator/index'
+export * from './type/awaited/index'
+export * from './type/bigint/index'
+export * from './type/boolean/index'
+export * from './type/composite/index'
+export * from './type/const/index'
+export * from './type/constructor/index'
+export * from './type/constructor-parameters/index'
+export * from './type/date/index'
+export * from './type/deref/index'
+export * from './type/enum/index'
+export * from './type/exclude/index'
+export * from './type/extends/index'
+export * from './type/extract/index'
+export * from './type/function/index'
+export * from './type/indexed/index'
+export * from './type/instance-type/index'
+export * from './type/integer/index'
+export * from './type/intersect/index'
+export * from './type/iterator/index'
+export * from './type/intrinsic/index'
+export * from './type/keyof/index'
+export * from './type/literal/index'
+export * from './type/mapped/index'
+export * from './type/never/index'
+export * from './type/not/index'
+export * from './type/null/index'
+export * from './type/number/index'
+export * from './type/object/index'
+export * from './type/omit/index'
+export * from './type/optional/index'
+export * from './type/parameters/index'
+export * from './type/partial/index'
+export * from './type/pick/index'
+export * from './type/promise/index'
+export * from './type/readonly/index'
+export * from './type/readonly-optional/index'
+export * from './type/record/index'
+export * from './type/recursive/index'
+export * from './type/ref/index'
+export * from './type/regexp/index'
+export * from './type/required/index'
+export * from './type/rest/index'
+export * from './type/return-type/index'
+export * from './type/schema/index'
+export * from './type/static/index'
+export * from './type/strict/index'
+export * from './type/string/index'
+export * from './type/symbol/index'
+export * from './type/template-literal/index'
+export * from './type/transform/index'
+export * from './type/tuple/index'
+export * from './type/uint8array/index'
+export * from './type/undefined/index'
+export * from './type/union/index'
+export * from './type/unknown/index'
+export * from './type/unsafe/index'
+export * from './type/void/index'
 // ------------------------------------------------------------------
 // Namespace
 // ------------------------------------------------------------------
-export { Type, JsonTypeBuilder, JavaScriptTypeBuilder } from './type/type/index'
+export * from './type/type/index'
diff --git a/src/type/clone/index.ts b/src/type/clone/index.ts
index 4ac4e6f01..ee3c7bfec 100644
--- a/src/type/clone/index.ts
+++ b/src/type/clone/index.ts
@@ -26,5 +26,5 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export * as TypeClone from './type'
-export * as ValueClone from './value'
+export * from './type'
+export * from './value'
diff --git a/src/type/const/const.ts b/src/type/const/const.ts
index ce13dc352..3eecebc0b 100644
--- a/src/type/const/const.ts
+++ b/src/type/const/const.ts
@@ -44,7 +44,7 @@ import { Readonly, type TReadonly } from '../readonly/index'
 import { Undefined, type TUndefined } from '../undefined/index'
 import { Uint8Array, type TUint8Array } from '../uint8array/index'
 import { Unknown, type TUnknown } from '../unknown/index'
-import { TypeClone } from '../clone/index'
+import { CloneType } from '../clone/index'
 
 // ------------------------------------------------------------------
 // ValueGuard
@@ -131,5 +131,5 @@ export type TConst<T> = FromValue<T, true>
 
 /** `[JavaScript]` Creates a readonly const type from the given value. */
 export function Const</* const (not supported in 4.0) */ T>(T: T, options: SchemaOptions = {}): TConst<T> {
-  return TypeClone.CloneType(FromValue(T, true), options) as TConst<T>
+  return CloneType(FromValue(T, true), options) as TConst<T>
 }
diff --git a/src/type/object/object.ts b/src/type/object/object.ts
index ed705aa6e..0cda73dfe 100644
--- a/src/type/object/object.ts
+++ b/src/type/object/object.ts
@@ -84,7 +84,7 @@ export interface TObject<T extends TProperties = TProperties> extends TSchema, O
   required?: string[]
 }
 /** `[Json]` Creates an Object type */
-export function _Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
+function _Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
   const propertyKeys = globalThis.Object.getOwnPropertyNames(properties)
   const optionalKeys = propertyKeys.filter((key) => IsOptional(properties[key]))
   const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name))

From 3db65cd0585c56c8ac563dcd094b5ed73fb484bb Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 1 Mar 2024 16:42:52 +0900
Subject: [PATCH 237/369] Revision 0.32.15 (#774)

* Add Additional Guards for Typed Arrays

* Map and Set | Additional Narrow for InstanceObject

* Version
---
 package-lock.json                 |   4 +-
 package.json                      |   2 +-
 src/compiler/index.ts             |   2 +-
 src/errors/index.ts               |   4 +-
 src/system/index.ts               |   4 +-
 src/value/cast/cast.ts            |   4 +-
 src/value/clone/clone.ts          |   4 +-
 src/value/delta/delta.ts          |   6 +-
 src/value/equal/equal.ts          |   6 +-
 src/value/guard/guard.ts          |  83 ++++++--
 src/value/hash/hash.ts            |   4 +-
 src/value/index.ts                |  61 ++----
 src/value/mutate/mutate.ts        |  10 +-
 src/value/transform/decode.ts     |   8 +-
 src/value/transform/encode.ts     |   8 +-
 test/runtime/value/guard/guard.ts | 305 +++++++++++++++++++++++++-----
 16 files changed, 377 insertions(+), 138 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index afcf1b69a..2b11a6af0 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.14",
+  "version": "0.32.15",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.14",
+      "version": "0.32.15",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 1ab2c08c5..32692ddaf 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.14",
+  "version": "0.32.15",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/index.ts b/src/compiler/index.ts
index b732cb855..d1a93e868 100644
--- a/src/compiler/index.ts
+++ b/src/compiler/index.ts
@@ -27,4 +27,4 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index'
-export { TypeCompiler, TypeCheck, type TypeCompilerCodegenOptions, type TypeCompilerLanguageOption, TypeCompilerTypeGuardError, TypeCompilerUnknownTypeError } from './compiler'
+export * from './compiler'
diff --git a/src/errors/index.ts b/src/errors/index.ts
index 6fc0d608a..288d17757 100644
--- a/src/errors/index.ts
+++ b/src/errors/index.ts
@@ -26,5 +26,5 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export { Errors, ValueError, ValueErrorIterator, ValueErrorType, ValueErrorsUnknownTypeError } from './errors'
-export { DefaultErrorFunction, GetErrorFunction, SetErrorFunction, type ErrorFunction, type ErrorFunctionParameter } from './function'
+export * from './errors'
+export * from './function'
diff --git a/src/system/index.ts b/src/system/index.ts
index 7ed15c5dc..70c91ccf2 100644
--- a/src/system/index.ts
+++ b/src/system/index.ts
@@ -26,5 +26,5 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export { TypeSystemPolicy } from './policy'
-export { TypeSystem, TypeSystemDuplicateFormat, TypeSystemDuplicateTypeKind } from './system'
+export * from './policy'
+export * from './system'
diff --git a/src/value/cast/cast.ts b/src/value/cast/cast.ts
index cadbaf72a..999e9379a 100644
--- a/src/value/cast/cast.ts
+++ b/src/value/cast/cast.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsPlainObject, IsArray, IsString, IsNumber, IsNull } from '../guard/index'
+import { IsStandardObject, IsArray, IsString, IsNumber, IsNull } from '../guard/index'
 import { TypeBoxError } from '../../type/error/index'
 import { Kind } from '../../type/symbols/index'
 import { Create } from '../create/index'
@@ -134,7 +134,7 @@ function FromConstructor(schema: TConstructor, references: TSchema[], value: any
 }
 function FromIntersect(schema: TIntersect, references: TSchema[], value: any): any {
   const created = Create(schema, references)
-  const mapped = IsPlainObject(created) && IsPlainObject(value) ? { ...(created as any), ...value } : value
+  const mapped = IsStandardObject(created) && IsStandardObject(value) ? { ...(created as any), ...value } : value
   return Check(schema, references, mapped) ? mapped : Create(schema, references)
 }
 function FromNever(schema: TNever, references: TSchema[], value: any): any {
diff --git a/src/value/clone/clone.ts b/src/value/clone/clone.ts
index 7f748cbba..f9f64f4cd 100644
--- a/src/value/clone/clone.ts
+++ b/src/value/clone/clone.ts
@@ -31,7 +31,7 @@ import type { ObjectType, ArrayType, TypedArrayType, ValueType } from '../guard/
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsArray, IsDate, IsPlainObject, IsTypedArray, IsValueType } from '../guard/index'
+import { IsArray, IsDate, IsStandardObject, IsTypedArray, IsValueType } from '../guard/index'
 // ------------------------------------------------------------------
 // Clonable
 // ------------------------------------------------------------------
@@ -58,7 +58,7 @@ function ValueType(value: ValueType): any {
 export function Clone<T extends unknown>(value: T): T {
   if (IsArray(value)) return ArrayType(value)
   if (IsDate(value)) return DateType(value)
-  if (IsPlainObject(value)) return ObjectType(value)
+  if (IsStandardObject(value)) return ObjectType(value)
   if (IsTypedArray(value)) return TypedArrayType(value)
   if (IsValueType(value)) return ValueType(value)
   throw new Error('ValueClone: Unable to clone value')
diff --git a/src/value/delta/delta.ts b/src/value/delta/delta.ts
index 616d5e949..daf47fa1e 100644
--- a/src/value/delta/delta.ts
+++ b/src/value/delta/delta.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsPlainObject, IsArray, IsTypedArray, IsValueType, IsSymbol, IsUndefined } from '../guard/index'
+import { IsStandardObject, IsArray, IsTypedArray, IsValueType, IsSymbol, IsUndefined } from '../guard/index'
 import type { ObjectType, ArrayType, TypedArrayType, ValueType } from '../guard/index'
 import type { Static } from '../../type/static/index'
 import { ValuePointer } from '../pointer/index'
@@ -90,7 +90,7 @@ function CreateDelete(path: string): Edit {
 // Diffing Generators
 // ------------------------------------------------------------------
 function* ObjectType(path: string, current: ObjectType, next: unknown): IterableIterator<Edit> {
-  if (!IsPlainObject(next)) return yield CreateUpdate(path, next)
+  if (!IsStandardObject(next)) return yield CreateUpdate(path, next)
   const currentKeys = [...globalThis.Object.keys(current), ...globalThis.Object.getOwnPropertySymbols(current)]
   const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)]
   for (const key of currentKeys) {
@@ -136,7 +136,7 @@ function* ValueType(path: string, current: ValueType, next: unknown): IterableIt
   yield CreateUpdate(path, next)
 }
 function* Visit(path: string, current: unknown, next: unknown): IterableIterator<Edit> {
-  if (IsPlainObject(current)) return yield* ObjectType(path, current, next)
+  if (IsStandardObject(current)) return yield* ObjectType(path, current, next)
   if (IsArray(current)) return yield* ArrayType(path, current, next)
   if (IsTypedArray(current)) return yield* TypedArrayType(path, current, next)
   if (IsValueType(current)) return yield* ValueType(path, current, next)
diff --git a/src/value/equal/equal.ts b/src/value/equal/equal.ts
index fdfca521e..ce64ea993 100644
--- a/src/value/equal/equal.ts
+++ b/src/value/equal/equal.ts
@@ -26,14 +26,14 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsPlainObject, IsDate, IsArray, IsTypedArray, IsValueType } from '../guard/index'
+import { IsStandardObject, IsDate, IsArray, IsTypedArray, IsValueType } from '../guard/index'
 import type { ObjectType, ArrayType, TypedArrayType, ValueType } from '../guard/index'
 
 // ------------------------------------------------------------------
 // Equality Checks
 // ------------------------------------------------------------------
 function ObjectType(left: ObjectType, right: unknown): boolean {
-  if (!IsPlainObject(right)) return false
+  if (!IsStandardObject(right)) return false
   const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)]
   const rightKeys = [...Object.keys(right), ...Object.getOwnPropertySymbols(right)]
   if (leftKeys.length !== rightKeys.length) return false
@@ -58,7 +58,7 @@ function ValueType(left: ValueType, right: unknown): any {
 // ------------------------------------------------------------------
 /** Returns true if the left value deep-equals the right */
 export function Equal<T>(left: T, right: unknown): right is T {
-  if (IsPlainObject(left)) return ObjectType(left, right)
+  if (IsStandardObject(left)) return ObjectType(left, right)
   if (IsDate(left)) return DateType(left, right)
   if (IsTypedArray(left)) return TypedArrayType(left, right)
   if (IsArray(left)) return ArrayType(left, right)
diff --git a/src/value/guard/guard.ts b/src/value/guard/guard.ts
index 83a3c1b66..8e45b1bd8 100644
--- a/src/value/guard/guard.ts
+++ b/src/value/guard/guard.ts
@@ -57,24 +57,87 @@ export function IsIterator(value: unknown): value is IterableIterator<any> {
   return IsObject(value) && Symbol.iterator in value
 }
 // --------------------------------------------------------------------------
-// Nominal
+// Object Instances
 // --------------------------------------------------------------------------
-/** Returns true if this value is a typed array */
-export function IsTypedArray(value: unknown): value is TypedArrayType {
-  return ArrayBuffer.isView(value)
+/** Returns true if this value is not an instance of a class */
+export function IsStandardObject(value: unknown): value is ObjectType {
+  return IsObject(value) && !IsArray(value) && IsFunction(value.constructor) && value.constructor.name === 'Object'
+}
+/** Returns true if this value is an instance of a class */
+export function IsInstanceObject(value: unknown): value is ObjectType {
+  return IsObject(value) && !IsArray(value) && IsFunction(value.constructor) && value.constructor.name !== 'Object'
 }
+// --------------------------------------------------------------------------
+// JavaScript
+// --------------------------------------------------------------------------
 /** Returns true if this value is a Promise */
 export function IsPromise(value: unknown): value is Promise<unknown> {
   return value instanceof Promise
 }
-/** Returns true if the value is a Uint8Array */
-export function IsUint8Array(value: unknown): value is Uint8Array {
-  return value instanceof Uint8Array
-}
 /** Returns true if this value is a Date */
 export function IsDate(value: unknown): value is Date {
   return value instanceof Date && Number.isFinite(value.getTime())
 }
+/** Returns true if this value is an instance of Map<K, T> */
+export function IsMap(value: unknown): value is Map<unknown, unknown> {
+  return value instanceof globalThis.Map
+}
+/** Returns true if this value is an instance of Set<T> */
+export function IsSet(value: unknown): value is Set<unknown> {
+  return value instanceof globalThis.Set
+}
+/** Returns true if this value is RegExp */
+export function IsRegExp(value: unknown): value is RegExp {
+  return value instanceof globalThis.RegExp
+}
+/** Returns true if this value is a typed array */
+export function IsTypedArray(value: unknown): value is TypedArrayType {
+  return ArrayBuffer.isView(value)
+}
+/** Returns true if the value is a Int8Array */
+export function IsInt8Array(value: unknown): value is Int8Array {
+  return value instanceof globalThis.Int8Array
+}
+/** Returns true if the value is a Uint8Array */
+export function IsUint8Array(value: unknown): value is Uint8Array {
+  return value instanceof globalThis.Uint8Array
+}
+/** Returns true if the value is a Uint8ClampedArray */
+export function IsUint8ClampedArray(value: unknown): value is Uint8ClampedArray {
+  return value instanceof globalThis.Uint8ClampedArray
+}
+/** Returns true if the value is a Int16Array */
+export function IsInt16Array(value: unknown): value is Int16Array {
+  return value instanceof globalThis.Int16Array
+}
+/** Returns true if the value is a Uint16Array */
+export function IsUint16Array(value: unknown): value is Uint16Array {
+  return value instanceof globalThis.Uint16Array
+}
+/** Returns true if the value is a Int32Array */
+export function IsInt32Array(value: unknown): value is Int32Array {
+  return value instanceof globalThis.Int32Array
+}
+/** Returns true if the value is a Uint32Array */
+export function IsUint32Array(value: unknown): value is Uint32Array {
+  return value instanceof globalThis.Uint32Array
+}
+/** Returns true if the value is a Float32Array */
+export function IsFloat32Array(value: unknown): value is Float32Array {
+  return value instanceof globalThis.Float32Array
+}
+/** Returns true if the value is a Float64Array */
+export function IsFloat64Array(value: unknown): value is Float64Array {
+  return value instanceof globalThis.Float64Array
+}
+/** Returns true if the value is a BigInt64Array */
+export function IsBigInt64Array(value: unknown): value is BigInt64Array {
+  return value instanceof globalThis.BigInt64Array
+}
+/** Returns true if the value is a BigUint64Array */
+export function IsBigUint64Array(value: unknown): value is BigUint64Array {
+  return value instanceof globalThis.BigUint64Array
+}
 // --------------------------------------------------------------------------
 // Standard
 // --------------------------------------------------------------------------
@@ -82,10 +145,6 @@ export function IsDate(value: unknown): value is Date {
 export function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is ObjectType & Record<K, unknown> {
   return key in value
 }
-/** Returns true if this object is not an instance of any other type */
-export function IsPlainObject(value: unknown): value is ObjectType {
-  return IsObject(value) && IsFunction(value.constructor) && value.constructor.name === 'Object'
-}
 /** Returns true of this value is an object type */
 export function IsObject(value: unknown): value is ObjectType {
   return value !== null && typeof value === 'object'
diff --git a/src/value/hash/hash.ts b/src/value/hash/hash.ts
index c87e102bc..beb159d09 100644
--- a/src/value/hash/hash.ts
+++ b/src/value/hash/hash.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsPlainObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index'
+import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsStandardObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index'
 import { TypeBoxError } from '../../type/error/index'
 
 // ------------------------------------------------------------------
@@ -140,7 +140,7 @@ function Visit(value: any) {
   if (IsDate(value)) return DateType(value)
   if (IsNull(value)) return NullType(value)
   if (IsNumber(value)) return NumberType(value)
-  if (IsPlainObject(value)) return ObjectType(value)
+  if (IsStandardObject(value)) return ObjectType(value)
   if (IsString(value)) return StringType(value)
   if (IsSymbol(value)) return SymbolType(value)
   if (IsUint8Array(value)) return Uint8ArrayType(value)
diff --git a/src/value/index.ts b/src/value/index.ts
index 8b17d674f..445581ad3 100644
--- a/src/value/index.ts
+++ b/src/value/index.ts
@@ -27,55 +27,30 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 // ------------------------------------------------------------------
-// Value Errors (re-export)
+// Errors (re-export)
 // ------------------------------------------------------------------
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index'
 // ------------------------------------------------------------------
-// Value Operators
+// Guards
 // ------------------------------------------------------------------
-export { Cast, ValueCastError } from './cast/index'
-export { Check } from './check/index'
-export { Clean } from './clean/index'
-export { Clone } from './clone/index'
-export { Convert } from './convert/index'
-export { Create, ValueCreateError } from './create/index'
-export { Default } from './default/index'
-export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaError } from './delta/index'
-export { Equal } from './equal/index'
-export { Hash, ValueHashError } from './hash/index'
-export { Mutate, ValueMutateError, type Mutable } from './mutate/index'
-export { ValuePointer } from './pointer/index'
-export { TransformDecode, TransformEncode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index'
+export * from './guard/index'
 // ------------------------------------------------------------------
-// Value Guards
+// Operators
 // ------------------------------------------------------------------
-export {
-  ArrayType,
-  HasPropertyKey,
-  IsArray,
-  IsAsyncIterator,
-  IsBigInt,
-  IsBoolean,
-  IsDate,
-  IsFunction,
-  IsInteger,
-  IsIterator,
-  IsNull,
-  IsNumber,
-  IsObject,
-  IsPlainObject,
-  IsPromise,
-  IsString,
-  IsSymbol,
-  IsTypedArray,
-  IsUint8Array,
-  IsUndefined,
-  IsValueType,
-  type ObjectType,
-  type TypedArrayType,
-  type ValueType,
-} from './guard/index'
+export * from './cast/index'
+export * from './check/index'
+export * from './clean/index'
+export * from './clone/index'
+export * from './convert/index'
+export * from './create/index'
+export * from './default/index'
+export * from './delta/index'
+export * from './equal/index'
+export * from './hash/index'
+export * from './mutate/index'
+export * from './pointer/index'
+export * from './transform/index'
 // ------------------------------------------------------------------
-// Value Namespace
+// Namespace
 // ------------------------------------------------------------------
 export { Value } from './value/index'
diff --git a/src/value/mutate/mutate.ts b/src/value/mutate/mutate.ts
index b8e5c61ca..45791bc24 100644
--- a/src/value/mutate/mutate.ts
+++ b/src/value/mutate/mutate.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsPlainObject, IsArray, IsTypedArray, IsValueType, type TypedArrayType } from '../guard/index'
+import { IsStandardObject, IsArray, IsTypedArray, IsValueType, type TypedArrayType } from '../guard/index'
 import { ValuePointer } from '../pointer/index'
 import { Clone } from '../clone/index'
 import { TypeBoxError } from '../../type/error/index'
@@ -44,7 +44,7 @@ export class ValueMutateError extends TypeBoxError {
 // ------------------------------------------------------------------
 export type Mutable = { [key: string]: unknown } | unknown[]
 function ObjectType(root: Mutable, path: string, current: unknown, next: Record<string, unknown>) {
-  if (!IsPlainObject(current)) {
+  if (!IsStandardObject(current)) {
     ValuePointer.Set(root, path, Clone(next))
   } else {
     const currentKeys = Object.keys(current)
@@ -90,7 +90,7 @@ function ValueType(root: Mutable, path: string, current: unknown, next: unknown)
 function Visit(root: Mutable, path: string, current: unknown, next: unknown) {
   if (IsArray(next)) return ArrayType(root, path, current, next)
   if (IsTypedArray(next)) return TypedArrayType(root, path, current, next)
-  if (IsPlainObject(next)) return ObjectType(root, path, current, next)
+  if (IsStandardObject(next)) return ObjectType(root, path, current, next)
   if (IsValueType(next)) return ValueType(root, path, current, next)
 }
 // ------------------------------------------------------------------
@@ -102,8 +102,8 @@ function IsNonMutableValue(value: unknown): value is Mutable {
 function IsMismatchedValue(current: unknown, next: unknown) {
   // prettier-ignore
   return (
-    (IsPlainObject(current) && IsArray(next)) || 
-    (IsArray(current) && IsPlainObject(next))
+    (IsStandardObject(current) && IsArray(next)) || 
+    (IsArray(current) && IsStandardObject(next))
   )
 }
 // ------------------------------------------------------------------
diff --git a/src/value/transform/decode.ts b/src/value/transform/decode.ts
index 9580e7663..3169293ac 100644
--- a/src/value/transform/decode.ts
+++ b/src/value/transform/decode.ts
@@ -48,7 +48,7 @@ import type { TUnion } from '../../type/union/index'
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsPlainObject, IsArray, IsValueType } from '../guard/index'
+import { IsStandardObject, IsArray, IsValueType } from '../guard/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -86,7 +86,7 @@ function FromArray(schema: TArray, references: TSchema[], value: any): any {
 }
 // prettier-ignore
 function FromIntersect(schema: TIntersect, references: TSchema[], value: any) {
-  if (!IsPlainObject(value) || IsValueType(value)) return Default(schema, value)
+  if (!IsStandardObject(value) || IsValueType(value)) return Default(schema, value)
   const knownKeys = KeyOfPropertyKeys(schema) as string[]
   const knownProperties = knownKeys.reduce((value, key) => {
     return (key in value)
@@ -110,7 +110,7 @@ function FromNot(schema: TNot, references: TSchema[], value: any) {
 }
 // prettier-ignore
 function FromObject(schema: TObject, references: TSchema[], value: any) {
-  if (!IsPlainObject(value)) return Default(schema, value)
+  if (!IsStandardObject(value)) return Default(schema, value)
   const knownKeys = KeyOfPropertyKeys(schema)
   const knownProperties = knownKeys.reduce((value, key) => {
     return (key in value) 
@@ -131,7 +131,7 @@ function FromObject(schema: TObject, references: TSchema[], value: any) {
 }
 // prettier-ignore
 function FromRecord(schema: TRecord, references: TSchema[], value: any) {
-  if (!IsPlainObject(value)) return Default(schema, value)
+  if (!IsStandardObject(value)) return Default(schema, value)
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
   const knownKeys = new RegExp(pattern)
   const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
diff --git a/src/value/transform/encode.ts b/src/value/transform/encode.ts
index 35d724811..695a7ea7c 100644
--- a/src/value/transform/encode.ts
+++ b/src/value/transform/encode.ts
@@ -48,7 +48,7 @@ import type { TUnion } from '../../type/union/index'
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsPlainObject, IsArray, IsValueType } from '../guard/index'
+import { IsStandardObject, IsArray, IsValueType } from '../guard/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -87,7 +87,7 @@ function FromArray(schema: TArray, references: TSchema[], value: any): any {
 // prettier-ignore
 function FromIntersect(schema: TIntersect, references: TSchema[], value: any) {
   const defaulted = Default(schema, value)
-  if (!IsPlainObject(value) || IsValueType(value)) return defaulted
+  if (!IsStandardObject(value) || IsValueType(value)) return defaulted
   const knownKeys = KeyOfPropertyKeys(schema) as string[]
   const knownProperties = knownKeys.reduce((value, key) => {
     return key in defaulted 
@@ -112,7 +112,7 @@ function FromNot(schema: TNot, references: TSchema[], value: any) {
 // prettier-ignore
 function FromObject(schema: TObject, references: TSchema[], value: any) {
   const defaulted = Default(schema, value)
-  if (!IsPlainObject(value)) return defaulted
+  if (!IsStandardObject(value)) return defaulted
   const knownKeys = KeyOfPropertyKeys(schema) as string[]
   const knownProperties = knownKeys.reduce((value, key) => {
     return key in value 
@@ -133,7 +133,7 @@ function FromObject(schema: TObject, references: TSchema[], value: any) {
 // prettier-ignore
 function FromRecord(schema: TRecord, references: TSchema[], value: any) {
   const defaulted = Default(schema, value) as Record<PropertyKey, unknown>
-  if (!IsPlainObject(value)) return defaulted
+  if (!IsStandardObject(value)) return defaulted
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
   const knownKeys = new RegExp(pattern)
   const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
diff --git a/test/runtime/value/guard/guard.ts b/test/runtime/value/guard/guard.ts
index ee8d3839f..cd775097c 100644
--- a/test/runtime/value/guard/guard.ts
+++ b/test/runtime/value/guard/guard.ts
@@ -5,118 +5,115 @@ describe('value/guard/ValueGuard', () => {
   // -----------------------------------------------------
   // IsNull
   // -----------------------------------------------------
-  it('Should guard null 1', () => {
+  it('Should guard Null 1', () => {
     const R = ValueGuard.IsNull(null)
     Assert.IsTrue(R)
   })
-  it('Should guard null 2', () => {
+  it('Should guard Null 2', () => {
     const R = ValueGuard.IsNull({})
     Assert.IsFalse(R)
   })
   // -----------------------------------------------------
   // IsUndefined
   // -----------------------------------------------------
-  it('Should guard undefined 1', () => {
+  it('Should guard Undefined 1', () => {
     const R = ValueGuard.IsUndefined(undefined)
     Assert.IsTrue(R)
   })
-  it('Should guard undefined 2', () => {
+  it('Should guard Undefined 2', () => {
     const R = ValueGuard.IsUndefined({})
     Assert.IsFalse(R)
   })
   // -----------------------------------------------------
   // IsBigInt
   // -----------------------------------------------------
-  it('Should guard bigint 1', () => {
+  it('Should guard BigInt 1', () => {
     const R = ValueGuard.IsBigInt(1n)
     Assert.IsTrue(R)
   })
-  it('Should guard bigint 2', () => {
+  it('Should guard BigInt 2', () => {
     const R = ValueGuard.IsBigInt(1)
     Assert.IsFalse(R)
   })
-  it('Should guard bigint 3', () => {
+  it('Should guard BigInt 3', () => {
     const R = ValueGuard.IsBigInt('123')
     Assert.IsFalse(R)
   })
   // -----------------------------------------------------
   // IsNumber
   // -----------------------------------------------------
-  it('Should guard number 1', () => {
+  it('Should guard Number 1', () => {
     const R = ValueGuard.IsNumber(1)
     Assert.IsTrue(R)
   })
-  it('Should guard number 2', () => {
+  it('Should guard Number 2', () => {
     const R = ValueGuard.IsNumber(3.14)
     Assert.IsTrue(R)
   })
-  it('Should guard number 3', () => {
+  it('Should guard Number 3', () => {
     const R = ValueGuard.IsNumber('')
     Assert.IsFalse(R)
   })
-  it('Should guard number 4', () => {
+  it('Should guard Number 4', () => {
     const R = ValueGuard.IsNumber(NaN)
     Assert.IsTrue(R)
   })
   // -----------------------------------------------------
   // IsString
   // -----------------------------------------------------
-  it('Should guard string 1', () => {
+  it('Should guard String 1', () => {
     const R = ValueGuard.IsString('')
     Assert.IsTrue(R)
   })
-  it('Should guard string 2', () => {
+  it('Should guard String 2', () => {
     const R = ValueGuard.IsString(true)
     Assert.IsFalse(R)
   })
   // -----------------------------------------------------
   // IsBoolean
   // -----------------------------------------------------
-  it('Should guard boolean 1', () => {
+  it('Should guard Boolean 1', () => {
     const R = ValueGuard.IsBoolean(true)
     Assert.IsTrue(R)
   })
-  it('Should guard boolean 2', () => {
+  it('Should guard Boolean 2', () => {
     const R = ValueGuard.IsBoolean(1)
     Assert.IsFalse(R)
   })
   // -----------------------------------------------------
   // IsObject
   // -----------------------------------------------------
-  it('Should guard object 1', () => {
+  it('Should guard Object 1', () => {
     const R = ValueGuard.IsObject({})
     Assert.IsTrue(R)
   })
-  it('Should guard object 2', () => {
+  it('Should guard Object 2', () => {
     const R = ValueGuard.IsObject(1)
     Assert.IsFalse(R)
   })
-  it('Should guard object 3', () => {
+  it('Should guard Object 3', () => {
     const R = ValueGuard.IsObject([])
     Assert.IsTrue(R)
   })
   // -----------------------------------------------------
   // IsArray
   // -----------------------------------------------------
-  it('Should guard array 1', () => {
+  it('Should guard Array 1', () => {
     const R = ValueGuard.IsArray([])
     Assert.IsTrue(R)
   })
-  it('Should guard array 2', () => {
+  it('Should guard Array 2', () => {
     const R = ValueGuard.IsArray({})
     Assert.IsFalse(R)
   })
   // -----------------------------------------------------
-  // Specialized (Values Only)
-  // -----------------------------------------------------
-  // -----------------------------------------------------
   // IsAsyncIterator
   // -----------------------------------------------------
-  it('Should guard async iterator 1', () => {
+  it('Should guard AsyncIterator 1', () => {
     const R = ValueGuard.IsAsyncIterator((async function* (): any {})())
     Assert.IsTrue(R)
   })
-  it('Should guard async iterator 2', () => {
+  it('Should guard AsyncIterator 2', () => {
     const R = ValueGuard.IsAsyncIterator((function* (): any {})())
     Assert.IsFalse(R)
   })
@@ -136,119 +133,327 @@ describe('value/guard/ValueGuard', () => {
   // -----------------------------------------------------
   // IsDate
   // -----------------------------------------------------
-  it('Should guard date 1', () => {
+  it('Should guard Date 1', () => {
     const R = ValueGuard.IsDate(new Date())
     Assert.IsTrue(R)
   })
-  it('Should guard date 2', () => {
+  it('Should guard Date 2', () => {
     const R = ValueGuard.IsDate({})
     Assert.IsFalse(R)
   })
   // -----------------------------------------------------
   // IsFunction
   // -----------------------------------------------------
-  it('Should guard function 1', () => {
+  it('Should guard Function 1', () => {
     const R = ValueGuard.IsFunction(function () {})
     Assert.IsTrue(R)
   })
-  it('Should guard function 2', () => {
+  it('Should guard Function 2', () => {
     const R = ValueGuard.IsFunction({})
     Assert.IsFalse(R)
   })
   // -----------------------------------------------------
   // IsInteger
   // -----------------------------------------------------
-  it('Should guard integer 1', () => {
+  it('Should guard Integer 1', () => {
     const R = ValueGuard.IsInteger(1)
     Assert.IsTrue(R)
   })
-  it('Should guard integer 2', () => {
+  it('Should guard Integer 2', () => {
     const R = ValueGuard.IsInteger(3.14)
     Assert.IsFalse(R)
   })
-  it('Should guard integer 3', () => {
+  it('Should guard Integer 3', () => {
     const R = ValueGuard.IsInteger(NaN)
     Assert.IsFalse(R)
   })
   // -----------------------------------------------------
   // IsIterator
   // -----------------------------------------------------
-  it('Should guard iterator 1', () => {
+  it('Should guard Iterator 1', () => {
     const R = ValueGuard.IsIterator((function* () {})())
     Assert.IsTrue(R)
   })
-  it('Should guard iterator 2', () => {
+  it('Should guard Iterator 2', () => {
     const R = ValueGuard.IsIterator({})
     Assert.IsFalse(R)
   })
   // -----------------------------------------------------
-  // IsPlainObject
+  // IsStandardObject
   // -----------------------------------------------------
-  it('Should guard plain object 1', () => {
-    const R = ValueGuard.IsPlainObject({})
+  it('Should guard StandardObject 1', () => {
+    const R = ValueGuard.IsStandardObject({})
     Assert.IsTrue(R)
   })
-  it('Should guard plain object 2', () => {
-    const R = ValueGuard.IsPlainObject(new (class {})())
+  it('Should guard StandardObject 2', () => {
+    const R = ValueGuard.IsStandardObject(1)
+    Assert.IsFalse(R)
+  })
+  it('Should guard StandardObject 3', () => {
+    const R = ValueGuard.IsStandardObject([])
+    Assert.IsFalse(R)
+  })
+  it('Should guard StandardObject 4', () => {
+    const R = ValueGuard.IsStandardObject(new (class {})())
     Assert.IsFalse(R)
   })
   // -----------------------------------------------------
+  // IsInstanceObject
+  // -----------------------------------------------------
+  it('Should guard InstanceObject 1', () => {
+    const R = ValueGuard.IsInstanceObject({})
+    Assert.IsFalse(R)
+  })
+  it('Should guard InstanceObject 2', () => {
+    const R = ValueGuard.IsInstanceObject(1)
+    Assert.IsFalse(R)
+  })
+  it('Should guard InstanceObject 3', () => {
+    const R = ValueGuard.IsInstanceObject([])
+    Assert.IsFalse(R)
+  })
+  it('Should guard InstanceObject 4', () => {
+    const R = ValueGuard.IsInstanceObject(new (class {})())
+    Assert.IsTrue(R)
+  })
+  // -----------------------------------------------------
   // IsPromise
   // -----------------------------------------------------
-  it('Should guard promise 1', () => {
+  it('Should guard Promise 1', () => {
     const R = ValueGuard.IsPromise(Promise.resolve(1))
     Assert.IsTrue(R)
   })
-  it('Should guard promise 2', () => {
+  it('Should guard Promise 2', () => {
     const R = ValueGuard.IsPromise(new (class {})())
     Assert.IsFalse(R)
   })
   // -----------------------------------------------------
   // IsSymbol
   // -----------------------------------------------------
-  it('Should guard symbol 1', () => {
+  it('Should guard Symbol 1', () => {
     const R = ValueGuard.IsSymbol(Symbol(1))
     Assert.IsTrue(R)
   })
-  it('Should guard symbol 2', () => {
+  it('Should guard Symbol 2', () => {
     const R = ValueGuard.IsSymbol(1)
     Assert.IsFalse(R)
   })
   // -----------------------------------------------------
   // IsTypedArray
   // -----------------------------------------------------
-  it('Should guard typed array 1', () => {
+  it('Should guard TypedArray 1', () => {
     const R = ValueGuard.IsTypedArray(new Uint8Array(1))
     Assert.IsTrue(R)
   })
-  it('Should guard typed array 2', () => {
+  it('Should guard TypedArray 2', () => {
     const R = ValueGuard.IsTypedArray(new Float32Array(1))
     Assert.IsTrue(R)
   })
-  it('Should guard typed array 3', () => {
+  it('Should guard TypedArray 3', () => {
     const R = ValueGuard.IsTypedArray(new ArrayBuffer(1))
     Assert.IsFalse(R)
   })
-  it('Should guard typed array 4', () => {
+  it('Should guard TypedArray 4', () => {
     const R = ValueGuard.IsTypedArray(1)
     Assert.IsFalse(R)
   })
   // -----------------------------------------------------
+  // IsInt8Array
+  // -----------------------------------------------------
+  it('Should guard Int8Array 1', () => {
+    const R = ValueGuard.IsInt8Array(new Int8Array(1))
+    Assert.IsTrue(R)
+  })
+  it('Should guard Int8Array 2', () => {
+    const R = ValueGuard.IsInt8Array(new Float32Array(1))
+    Assert.IsFalse(R)
+  })
+  it('Should guard Int8Array 2', () => {
+    const R = ValueGuard.IsInt8Array(1)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
   // IsUint8Array
   // -----------------------------------------------------
-  it('Should guard uint8array 1', () => {
+  it('Should guard Uint8Array 1', () => {
     const R = ValueGuard.IsUint8Array(new Uint8Array(1))
     Assert.IsTrue(R)
   })
-  it('Should guard uint8array 2', () => {
+  it('Should guard Uint8Array 2', () => {
     const R = ValueGuard.IsUint8Array(new Float32Array(1))
     Assert.IsFalse(R)
   })
-  it('Should guard uint8array 2', () => {
+  it('Should guard Uint8Array 2', () => {
     const R = ValueGuard.IsUint8Array(1)
     Assert.IsFalse(R)
   })
   // -----------------------------------------------------
+  // IsUint8ClampedArray
+  // -----------------------------------------------------
+  it('Should guard Uint8ClampedArray 1', () => {
+    const R = ValueGuard.IsUint8ClampedArray(new Uint8ClampedArray(1))
+    Assert.IsTrue(R)
+  })
+  it('Should guard Uint8ClampedArray 2', () => {
+    const R = ValueGuard.IsUint8ClampedArray(new Float32Array(1))
+    Assert.IsFalse(R)
+  })
+  it('Should guard Uint8ClampedArray 2', () => {
+    const R = ValueGuard.IsUint8ClampedArray(1)
+    Assert.IsFalse(R)
+  })
+
+  // -----------------------------------------------------
+  // IsInt16Array
+  // -----------------------------------------------------
+  it('Should guard Int16Array 1', () => {
+    const R = ValueGuard.IsInt16Array(new Int16Array(1))
+    Assert.IsTrue(R)
+  })
+  it('Should guard Int16Array 2', () => {
+    const R = ValueGuard.IsInt16Array(new Float32Array(1))
+    Assert.IsFalse(R)
+  })
+  it('Should guard Int16Array 2', () => {
+    const R = ValueGuard.IsInt16Array(1)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsUint16Array
+  // -----------------------------------------------------
+  it('Should guard Uint16Array 1', () => {
+    const R = ValueGuard.IsUint16Array(new Uint16Array(1))
+    Assert.IsTrue(R)
+  })
+  it('Should guard Uint16Array 2', () => {
+    const R = ValueGuard.IsUint16Array(new Float32Array(1))
+    Assert.IsFalse(R)
+  })
+  it('Should guard Uint16Array 2', () => {
+    const R = ValueGuard.IsUint16Array(1)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsInt32Array
+  // -----------------------------------------------------
+  it('Should guard Int32Array 1', () => {
+    const R = ValueGuard.IsInt32Array(new Int32Array(1))
+    Assert.IsTrue(R)
+  })
+  it('Should guard Int32Array 2', () => {
+    const R = ValueGuard.IsInt32Array(new Float32Array(1))
+    Assert.IsFalse(R)
+  })
+  it('Should guard Int32Array 2', () => {
+    const R = ValueGuard.IsInt32Array(1)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsUint32Array
+  // -----------------------------------------------------
+  it('Should guard Uint32Array 1', () => {
+    const R = ValueGuard.IsUint32Array(new Uint32Array(1))
+    Assert.IsTrue(R)
+  })
+  it('Should guard Uint32Array 2', () => {
+    const R = ValueGuard.IsUint32Array(new Float32Array(1))
+    Assert.IsFalse(R)
+  })
+  it('Should guard Uint32Array 2', () => {
+    const R = ValueGuard.IsUint32Array(1)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsFloat32Array
+  // -----------------------------------------------------
+  it('Should guard Float32Array 1', () => {
+    const R = ValueGuard.IsFloat32Array(new Float32Array(1))
+    Assert.IsTrue(R)
+  })
+  it('Should guard Float32Array 2', () => {
+    const R = ValueGuard.IsFloat32Array(new Float64Array(1))
+    Assert.IsFalse(R)
+  })
+  it('Should guard Float32Array 2', () => {
+    const R = ValueGuard.IsFloat32Array(1)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsFloat64Array
+  // -----------------------------------------------------
+  it('Should guard Float64Array 1', () => {
+    const R = ValueGuard.IsFloat64Array(new Float64Array(1))
+    Assert.IsTrue(R)
+  })
+  it('Should guard Float64Array 2', () => {
+    const R = ValueGuard.IsFloat64Array(new Float32Array(1))
+    Assert.IsFalse(R)
+  })
+  it('Should guard Float64Array 2', () => {
+    const R = ValueGuard.IsFloat64Array(1)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsBigInt64Array
+  // -----------------------------------------------------
+  it('Should guard BigInt64Array 1', () => {
+    const R = ValueGuard.IsBigInt64Array(new BigInt64Array(1))
+    Assert.IsTrue(R)
+  })
+  it('Should guard BigInt64Array 2', () => {
+    const R = ValueGuard.IsBigInt64Array(new Float32Array(1))
+    Assert.IsFalse(R)
+  })
+  it('Should guard BigInt64Array 2', () => {
+    const R = ValueGuard.IsBigInt64Array(1)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsBigUint64Array
+  // -----------------------------------------------------
+  it('Should guard BigUint64Array 1', () => {
+    const R = ValueGuard.IsBigUint64Array(new BigUint64Array(1))
+    Assert.IsTrue(R)
+  })
+  it('Should guard BigUint64Array 2', () => {
+    const R = ValueGuard.IsBigUint64Array(new Float32Array(1))
+    Assert.IsFalse(R)
+  })
+  it('Should guard BigUint64Array 2', () => {
+    const R = ValueGuard.IsBigUint64Array(1)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsMap
+  // -----------------------------------------------------
+  it('Should guard Map 1', () => {
+    const R = ValueGuard.IsMap(new Map())
+    Assert.IsTrue(R)
+  })
+  it('Should guard Map 2', () => {
+    const R = ValueGuard.IsMap(new Float32Array(1))
+    Assert.IsFalse(R)
+  })
+  it('Should guard Map 2', () => {
+    const R = ValueGuard.IsMap(1)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
+  // IsSet
+  // -----------------------------------------------------
+  it('Should guard Set 1', () => {
+    const R = ValueGuard.IsSet(new Set())
+    Assert.IsTrue(R)
+  })
+  it('Should guard Set 2', () => {
+    const R = ValueGuard.IsSet(new Float32Array(1))
+    Assert.IsFalse(R)
+  })
+  it('Should guard Set 2', () => {
+    const R = ValueGuard.IsSet(1)
+    Assert.IsFalse(R)
+  })
+  // -----------------------------------------------------
   // IsValueType
   // -----------------------------------------------------
   it('Should guard value type 1', () => {

From ea0fa093a0857cf227789829893f11ce8380d8bf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andreas=20S=C3=B6derlund?= <ciscoheat@gmail.com>
Date: Thu, 7 Mar 2024 04:40:48 +0100
Subject: [PATCH 238/369] Ecosystem (#775)

- Added form library Superforms
---
 readme.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/readme.md b/readme.md
index 9dc77a5cc..0a246c134 100644
--- a/readme.md
+++ b/readme.md
@@ -1694,6 +1694,7 @@ The following is a list of community packages that offer general tooling, extend
 | [http-wizard](https://github.com/flodlc/http-wizard) | Type safe http client library for Fastify |
 | [openapi-box](https://github.com/geut/openapi-box) | Generate TypeBox types from OpenApi IDL + Http client library |
 | [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from Json Schemas |
+| [sveltekit-superforms](https://github.com/ciscoheat/sveltekit-superforms)  | A comprehensive SvelteKit form library for server and client validation |
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
 | [typebox-form-parser](https://github.com/jtlapp/typebox-form-parser) | Parses form and query data based on TypeBox schemas |
 | [typebox-validators](https://github.com/jtlapp/typebox-validators) | Advanced validators supporting discriminated and heterogeneous unions |

From abe71c68cd7099d05a62aa78088113f021623dbc Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Thu, 7 Mar 2024 14:44:01 +0900
Subject: [PATCH 239/369] TypeScript 5.4.2

---
 hammer.mjs        |  2 +-
 package-lock.json | 14 +++++++-------
 package.json      |  2 +-
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/hammer.mjs b/hammer.mjs
index 661d90a28..1326d2195 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -32,7 +32,7 @@ export async function benchmark() {
 // Test
 // -------------------------------------------------------------------------------
 export async function test_typescript() {
-  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', 'next', 'latest']) {
+  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', 'next', 'latest']) {
     await shell(`npm install typescript@${version} --no-save`)
     await test_static()
   }
diff --git a/package-lock.json b/package-lock.json
index 2b11a6af0..c70b6b36f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -17,7 +17,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^9.2.2",
         "prettier": "^2.7.1",
-        "typescript": "^5.3.3"
+        "typescript": "^5.4.2"
       }
     },
     "node_modules/@andrewbranch/untar.js": {
@@ -1644,9 +1644,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.3.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.3.tgz",
-      "integrity": "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==",
+      "version": "5.4.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.4.2.tgz",
+      "integrity": "sha512-+2/g0Fds1ERlP6JsakQQDXjZdZMM+rqpamFZJEKh4kwTIn3iDkgKtby0CeNd5ATNZ4Ry1ax15TMx0W2V+miizQ==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -2874,9 +2874,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.3.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.3.tgz",
-      "integrity": "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==",
+      "version": "5.4.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.4.2.tgz",
+      "integrity": "sha512-+2/g0Fds1ERlP6JsakQQDXjZdZMM+rqpamFZJEKh4kwTIn3iDkgKtby0CeNd5ATNZ4Ry1ax15TMx0W2V+miizQ==",
       "dev": true
     },
     "undici-types": {
diff --git a/package.json b/package.json
index 32692ddaf..6fa87a159 100644
--- a/package.json
+++ b/package.json
@@ -37,6 +37,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^5.3.3"
+    "typescript": "^5.4.2"
   }
 }

From 9fa2e2801c5f267c2624a5a39cefd7d9e3463bef Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 20 Mar 2024 02:25:53 +0900
Subject: [PATCH 240/369] Revision 0.32.16 (#791)

* Update Indexed Union Evaluation

* Use Reduce Strategy for Union and Intersect Value Conversion

* Add Path to Transform Codec Errors

* Support Control Character Escape in Template Literal Syntax

* Intersect Union Convert Test Case

* Revision 0.32.16
---
 package-lock.json                             |   4 +-
 package.json                                  |   2 +-
 src/type/indexed/indexed.ts                   |  33 ++++-
 src/type/template-literal/parse.ts            |  29 ++++-
 src/type/template-literal/syntax.ts           |   5 +-
 src/value/convert/convert.ts                  |  13 +-
 src/value/transform/decode.ts                 | 117 ++++++++++--------
 src/value/transform/encode.ts                 | 113 +++++++++--------
 src/value/value/value.ts                      |   2 +-
 test/runtime/type/guard/composite.ts          |   8 +-
 test/runtime/type/guard/record.ts             |  14 +++
 .../runtime/type/template-literal/generate.ts |   9 +-
 test/runtime/type/template-literal/parse.ts   |   4 +-
 test/runtime/value/convert/intersect.ts       |  27 ++--
 test/runtime/value/convert/union.ts           |  25 +++-
 test/static/composite.ts                      |  29 ++++-
 test/static/record.ts                         |  14 +++
 test/static/template-literal.ts               |  35 ++++++
 18 files changed, 333 insertions(+), 150 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index c70b6b36f..3804e5462 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.15",
+  "version": "0.32.16",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.15",
+      "version": "0.32.16",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 6fa87a159..e4c6fe9ab 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.15",
+  "version": "0.32.16",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/indexed/indexed.ts b/src/type/indexed/indexed.ts
index 2589aeaf6..f3df37e77 100644
--- a/src/type/indexed/indexed.ts
+++ b/src/type/indexed/indexed.ts
@@ -88,12 +88,41 @@ function FromIntersect<T extends TSchema[], K extends PropertyKey>(T: [...T], K:
 }
 // ------------------------------------------------------------------
 // FromUnionRest
+//
+// The following accept a tuple of indexed key results. When evaluating
+// these results, we check if any result evaluated to TNever. For key
+// indexed unions, a TNever result indicates that the key was not
+// present on the variant. In these cases, we must evaluate the indexed
+// union to TNever (as given by a [] result). This logic aligns to the
+// following behaviour.
+//
+// Non-Overlapping Union
+//
+// type A = { a: string }
+// type B = { b: string }
+// type C = (A | B) & { a: number } // C is { a: number }
+//
+// Overlapping Union
+//
+// type A = { a: string }
+// type B = { a: string }
+// type C = (A | B) & { a: number } // C is { a: never }
+//
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromUnionRest<T extends TSchema[]> = T
+type TFromUnionRest<T extends TSchema[], Acc extends TSchema[] = []> = 
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? L extends TNever 
+      ? []
+      : TFromUnionRest<R, [L, ...Acc]>
+    : Acc
 // prettier-ignore
 function FromUnionRest<T extends TSchema[]>(T: [...T]): TFromUnionRest<T> {
-  return T as never // review this
+  return (
+    T.some(L => IsNever(L)) 
+      ? [] 
+      : T 
+  ) as never
 }
 // ------------------------------------------------------------------
 // FromUnion
diff --git a/src/type/template-literal/parse.ts b/src/type/template-literal/parse.ts
index 7a2730f44..6a36c013e 100644
--- a/src/type/template-literal/parse.ts
+++ b/src/type/template-literal/parse.ts
@@ -40,23 +40,42 @@ export type Expression = ExpressionAnd | ExpressionOr | ExpressionConst
 export type ExpressionConst = { type: 'const'; const: string }
 export type ExpressionAnd = { type: 'and'; expr: Expression[] }
 export type ExpressionOr = { type: 'or'; expr: Expression[] }
+// -------------------------------------------------------------------
+// Unescape
+//
+// Unescape for these control characters specifically. Note that this
+// function is only called on non union group content, and where we
+// still want to allow the user to embed control characters in that
+// content. For review.
+// -------------------------------------------------------------------
 // prettier-ignore
+function Unescape(pattern: string) {
+  return pattern
+    .replace(/\\\$/g, '$')
+    .replace(/\\\*/g, '*')
+    .replace(/\\\^/g, '^')
+    .replace(/\\\|/g, '|')
+    .replace(/\\\(/g, '(')
+    .replace(/\\\)/g, ')')
+}
+// -------------------------------------------------------------------
+// Control Characters
+// -------------------------------------------------------------------
 function IsNonEscaped(pattern: string, index: number, char: string) {
   return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92
 }
-// prettier-ignore
 function IsOpenParen(pattern: string, index: number) {
   return IsNonEscaped(pattern, index, '(')
 }
-// prettier-ignore
 function IsCloseParen(pattern: string, index: number) {
   return IsNonEscaped(pattern, index, ')')
 }
-// prettier-ignore
 function IsSeparator(pattern: string, index: number) {
   return IsNonEscaped(pattern, index, '|')
 }
-// prettier-ignore
+// -------------------------------------------------------------------
+// Control Groups
+// -------------------------------------------------------------------
 function IsGroup(pattern: string) {
   if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1))) return false
   let count = 0
@@ -155,7 +174,7 @@ export function TemplateLiteralParse(pattern: string): Expression {
     IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
     IsPrecedenceOr(pattern) ? Or(pattern) :
     IsPrecedenceAnd(pattern) ? And(pattern) :
-    { type: 'const', const: pattern }
+    { type: 'const', const: Unescape(pattern) }
   )
 }
 // ------------------------------------------------------------------
diff --git a/src/type/template-literal/syntax.ts b/src/type/template-literal/syntax.ts
index 1250ee651..3352b10b6 100644
--- a/src/type/template-literal/syntax.ts
+++ b/src/type/template-literal/syntax.ts
@@ -100,7 +100,10 @@ type FromTerminal<T extends string> =
 // prettier-ignore
 type FromString<T extends string> =
   T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] :
-  T extends `${infer L}$${infer R}` ? [TLiteral<L>, ...FromString<R>] :
+  // note: to correctly handle $ characters encoded in the sequence, we need to
+  // lookahead and test against opening and closing union groups.
+  T extends `${infer L}$\{${infer R1}\}${infer R2}` ? [TLiteral<L>, ...FromString<`{${R1}}`>, ...FromString<R2>] :
+  T extends `${infer L}$\{${infer R1}\}` ? [TLiteral<L>, ...FromString<`{${R1}}`>] :
   T extends `${infer L}` ? [TLiteral<L>] :
   []
 
diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index 35afea3c8..dd0e2d1d2 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -183,11 +183,8 @@ function FromDate(schema: TDate, references: TSchema[], value: any): unknown {
 function FromInteger(schema: TInteger, references: TSchema[], value: any): unknown {
   return TryConvertInteger(value)
 }
-// prettier-ignore
 function FromIntersect(schema: TIntersect, references: TSchema[], value: any): unknown {
-  const allObjects = schema.allOf.every(schema => IsObjectType(schema))
-  if(allObjects) return Visit(Composite(schema.allOf as TObject[]), references, value)
-  return Visit(schema.allOf[0], references, value) // todo: fix this
+  return schema.allOf.reduce((value, schema) => Visit(schema, references, value), value)
 }
 function FromLiteral(schema: TLiteral, references: TSchema[], value: any): unknown {
   return TryConvertLiteral(schema, value)
@@ -243,13 +240,7 @@ function FromUndefined(schema: TUndefined, references: TSchema[], value: any): u
   return TryConvertUndefined(value)
 }
 function FromUnion(schema: TUnion, references: TSchema[], value: any): unknown {
-  for (const subschema of schema.anyOf) {
-    const converted = Visit(subschema, references, value)
-    if (Check(subschema, references, converted)) {
-      return converted
-    }
-  }
-  return value
+  return schema.anyOf.reduce((value, schema) => Visit(schema, references, value), value)
 }
 function Visit(schema: TSchema, references: TSchema[], value: any): unknown {
   const references_ = IsString(schema.$id) ? [...references, schema] : references
diff --git a/src/value/transform/decode.ts b/src/value/transform/decode.ts
index 3169293ac..02982d0fd 100644
--- a/src/value/transform/decode.ts
+++ b/src/value/transform/decode.ts
@@ -57,153 +57,164 @@ import { IsTransform, IsSchema } from '../../type/guard/type'
 // Errors
 // ------------------------------------------------------------------
 // thrown externally
+// prettier-ignore
 export class TransformDecodeCheckError extends TypeBoxError {
-  constructor(public readonly schema: TSchema, public readonly value: unknown, public readonly error: ValueError) {
-    super(`Unable to decode due to invalid value`)
+  constructor(
+    public readonly schema: TSchema, 
+    public readonly value: unknown, 
+    public readonly error: ValueError
+  ) {
+    super(`Unable to decode value as it does not match the expected schema`)
   }
 }
+// prettier-ignore
 export class TransformDecodeError extends TypeBoxError {
-  constructor(public readonly schema: TSchema, public readonly value: unknown, error: any) {
-    super(`${error instanceof Error ? error.message : 'Unknown error'}`)
+  constructor(
+    public readonly schema: TSchema, 
+    public readonly path: string,
+    public readonly value: unknown, 
+    public readonly error: Error, 
+  ) {
+    super(error instanceof Error ? error.message : 'Unknown error')
   }
 }
 // ------------------------------------------------------------------
 // Decode
 // ------------------------------------------------------------------
 // prettier-ignore
-function Default(schema: TSchema, value: any) {
+function Default(schema: TSchema, path: string, value: any) {
   try {
     return IsTransform(schema) ? schema[TransformKind].Decode(value) : value
   } catch (error) {
-    throw new TransformDecodeError(schema, value, error)
+    throw new TransformDecodeError(schema, path, value, error as Error)
   }
 }
 // prettier-ignore
-function FromArray(schema: TArray, references: TSchema[], value: any): any {
+function FromArray(schema: TArray, references: TSchema[], path: string, value: any): any {
   return (IsArray(value))
-    ? Default(schema, value.map((value: any) => Visit(schema.items, references, value)))
-    : Default(schema, value)
+    ? Default(schema, path, value.map((value: any, index) => Visit(schema.items, references, `${path}/${index}`, value)))
+    : Default(schema, path, value)
 }
 // prettier-ignore
-function FromIntersect(schema: TIntersect, references: TSchema[], value: any) {
-  if (!IsStandardObject(value) || IsValueType(value)) return Default(schema, value)
+function FromIntersect(schema: TIntersect, references: TSchema[], path: string, value: any) {
+  if (!IsStandardObject(value) || IsValueType(value)) return Default(schema, path, value)
   const knownKeys = KeyOfPropertyKeys(schema) as string[]
   const knownProperties = knownKeys.reduce((value, key) => {
     return (key in value)
-      ? { ...value, [key]: Visit(Index(schema, [key]), references, value[key]) }
+      ? { ...value, [key]: Visit(Index(schema, [key]), references, `${path}/${key}`, value[key]) }
       : value
   }, value)
   if (!IsTransform(schema.unevaluatedProperties)) {
-    return Default(schema, knownProperties)
+    return Default(schema, path, knownProperties)
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties)
   const unevaluatedProperties = schema.unevaluatedProperties as TSchema
   const unknownProperties = unknownKeys.reduce((value, key) => {
     return !knownKeys.includes(key)
-      ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }
+      ? { ...value, [key]: Default(unevaluatedProperties, `${path}/${key}`, value[key]) }
       : value
   }, knownProperties)
-  return Default(schema, unknownProperties)
+  return Default(schema, path, unknownProperties)
 }
-function FromNot(schema: TNot, references: TSchema[], value: any) {
-  return Default(schema, Visit(schema.not, references, value))
+function FromNot(schema: TNot, references: TSchema[], path: string, value: any) {
+  return Default(schema, path, Visit(schema.not, references, path, value))
 }
 // prettier-ignore
-function FromObject(schema: TObject, references: TSchema[], value: any) {
-  if (!IsStandardObject(value)) return Default(schema, value)
+function FromObject(schema: TObject, references: TSchema[], path: string, value: any) {
+  if (!IsStandardObject(value)) return Default(schema, path, value)
   const knownKeys = KeyOfPropertyKeys(schema)
   const knownProperties = knownKeys.reduce((value, key) => {
     return (key in value) 
-      ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }  
+      ? { ...value, [key]: Visit(schema.properties[key], references, `${path}/${key}`, value[key]) }  
       : value
   }, value)
   if (!IsSchema(schema.additionalProperties)) {
-    return Default(schema, knownProperties)
+    return Default(schema, path, knownProperties)
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties)
   const additionalProperties = schema.additionalProperties as TSchema
   const unknownProperties = unknownKeys.reduce((value, key) => {
     return !knownKeys.includes(key)
-    ? { ...value, [key]: Default(additionalProperties, value[key]) }
+    ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
     : value
   }, knownProperties)
-  return Default(schema, unknownProperties)
+  return Default(schema, path, unknownProperties)
 }
 // prettier-ignore
-function FromRecord(schema: TRecord, references: TSchema[], value: any) {
-  if (!IsStandardObject(value)) return Default(schema, value)
+function FromRecord(schema: TRecord, references: TSchema[], path: string, value: any) {
+  if (!IsStandardObject(value)) return Default(schema, path, value)
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
   const knownKeys = new RegExp(pattern)
   const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
     return knownKeys.test(key) 
-      ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
+      ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, `${path}/${key}`, value[key]) }
       : value
   }, value)
   if (!IsSchema(schema.additionalProperties)) {
-    return Default(schema, knownProperties)
+    return Default(schema, path, knownProperties)
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties)
   const additionalProperties = schema.additionalProperties as TSchema
   const unknownProperties = unknownKeys.reduce((value, key) => {
     return !knownKeys.test(key)
-    ? { ...value, [key]: Default(additionalProperties, value[key]) }
+    ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
     : value
   }, knownProperties)
-  return Default(schema, unknownProperties)
+  return Default(schema, path, unknownProperties)
 }
 // prettier-ignore
-function FromRef(schema: TRef, references: TSchema[], value: any) {
+function FromRef(schema: TRef, references: TSchema[], path: string, value: any) {
   const target = Deref(schema, references)
-  return Default(schema, Visit(target, references, value))
+  return Default(schema, path, Visit(target, references, path, value))
 }
 // prettier-ignore
-function FromThis(schema: TThis, references: TSchema[], value: any) {
+function FromThis(schema: TThis, references: TSchema[], path: string, value: any) {
   const target = Deref(schema, references)
-  return Default(schema, Visit(target, references, value))
+  return Default(schema, path, Visit(target, references, path, value))
 }
 // prettier-ignore
-function FromTuple(schema: TTuple, references: TSchema[], value: any) {
+function FromTuple(schema: TTuple, references: TSchema[], path: string, value: any) {
   return (IsArray(value) && IsArray(schema.items))
-    ? Default(schema, schema.items.map((schema, index) => Visit(schema, references, value[index])))
-    : Default(schema, value)
+    ? Default(schema, path, schema.items.map((schema, index) => Visit(schema, references, `${path}/${index}`, value[index])))
+    : Default(schema, path, value)
 }
 // prettier-ignore
-function FromUnion(schema: TUnion, references: TSchema[], value: any) {
+function FromUnion(schema: TUnion, references: TSchema[], path: string, value: any) {
   for (const subschema of schema.anyOf) {
     if (!Check(subschema, references, value)) continue
     // note: ensure interior is decoded first
-    const decoded = Visit(subschema, references, value)
-    return Default(schema, decoded)
+    const decoded = Visit(subschema, references, path, value)
+    return Default(schema, path, decoded)
   }
-  return Default(schema, value)
+  return Default(schema, path, value)
 }
 // prettier-ignore
-function Visit(schema: TSchema, references: TSchema[], value: any): any {
+function Visit(schema: TSchema, references: TSchema[], path: string, value: any): any {
   const references_ = typeof schema.$id === 'string' ? [...references, schema] : references
   const schema_ = schema as any
   switch (schema[Kind]) {
     case 'Array':
-      return FromArray(schema_, references_, value)
+      return FromArray(schema_, references_, path, value)
     case 'Intersect':
-      return FromIntersect(schema_, references_, value)
+      return FromIntersect(schema_, references_, path, value)
     case 'Not':
-      return FromNot(schema_, references_, value)
+      return FromNot(schema_, references_, path, value)
     case 'Object':
-      return FromObject(schema_, references_, value)
+      return FromObject(schema_, references_, path, value)
     case 'Record':
-      return FromRecord(schema_, references_, value)
+      return FromRecord(schema_, references_, path, value)
     case 'Ref':
-      return FromRef(schema_, references_, value)
+      return FromRef(schema_, references_, path, value)
     case 'Symbol':
-      return Default(schema_, value)
+      return Default(schema_, path, value)
     case 'This':
-      return FromThis(schema_, references_, value)
+      return FromThis(schema_, references_, path, value)
     case 'Tuple':
-      return FromTuple(schema_, references_, value)
+      return FromTuple(schema_, references_, path, value)
     case 'Union':
-      return FromUnion(schema_, references_, value)
+      return FromUnion(schema_, references_, path, value)
     default:
-      return Default(schema_, value)
+      return Default(schema_, path, value)
   }
 }
 /**
@@ -212,5 +223,5 @@ function Visit(schema: TSchema, references: TSchema[], value: any): any {
  * undefined behavior. Refer to the `Value.Decode()` for implementation details.
  */
 export function TransformDecode(schema: TSchema, references: TSchema[], value: unknown): unknown {
-  return Visit(schema, references, value)
+  return Visit(schema, references, '', value)
 }
diff --git a/src/value/transform/encode.ts b/src/value/transform/encode.ts
index 695a7ea7c..2a2b8f465 100644
--- a/src/value/transform/encode.ts
+++ b/src/value/transform/encode.ts
@@ -56,13 +56,24 @@ import { IsTransform, IsSchema } from '../../type/guard/type'
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
+// prettier-ignore
 export class TransformEncodeCheckError extends TypeBoxError {
-  constructor(public readonly schema: TSchema, public readonly value: unknown, public readonly error: ValueError) {
-    super(`Unable to encode due to invalid value`)
+  constructor(
+    public readonly schema: TSchema,
+    public readonly value: unknown, 
+    public readonly error: ValueError
+  ) {
+    super(`The encoded value does not match the expected schema`)
   }
 }
+// prettier-ignore
 export class TransformEncodeError extends TypeBoxError {
-  constructor(public readonly schema: TSchema, public readonly value: unknown, error: any) {
+  constructor(
+    public readonly schema: TSchema, 
+    public readonly path: string,
+    public readonly value: unknown, 
+    public readonly error: Error, 
+  ) {
     super(`${error instanceof Error ? error.message : 'Unknown error'}`)
   }
 }
@@ -70,53 +81,53 @@ export class TransformEncodeError extends TypeBoxError {
 // Encode
 // ------------------------------------------------------------------
 // prettier-ignore
-function Default(schema: TSchema, value: any) {
+function Default(schema: TSchema, path: string, value: any) {
   try {
     return IsTransform(schema) ? schema[TransformKind].Encode(value) : value
   } catch (error) {
-    throw new TransformEncodeError(schema, value, error)
+    throw new TransformEncodeError(schema, path, value, error as Error)
   }
 }
 // prettier-ignore
-function FromArray(schema: TArray, references: TSchema[], value: any): any {
-  const defaulted = Default(schema, value)
+function FromArray(schema: TArray, references: TSchema[], path: string, value: any): any {
+  const defaulted = Default(schema, path, value)
   return IsArray(defaulted)
-    ? defaulted.map((value: any) => Visit(schema.items, references, value))
+    ? defaulted.map((value: any, index) => Visit(schema.items, references, `${path}/${index}`, value))
     : defaulted
 }
 // prettier-ignore
-function FromIntersect(schema: TIntersect, references: TSchema[], value: any) {
-  const defaulted = Default(schema, value)
+function FromIntersect(schema: TIntersect, references: TSchema[], path: string, value: any) {
+  const defaulted = Default(schema, path, value)
   if (!IsStandardObject(value) || IsValueType(value)) return defaulted
   const knownKeys = KeyOfPropertyKeys(schema) as string[]
   const knownProperties = knownKeys.reduce((value, key) => {
     return key in defaulted 
-      ? { ...value, [key]: Visit(Index(schema, [key]), references, value[key]) } 
+      ? { ...value, [key]: Visit(Index(schema, [key]), references, `${path}/${key}`, value[key]) } 
       : value
   }, defaulted)
   if (!IsTransform(schema.unevaluatedProperties)) {
-    return Default(schema, knownProperties)
+    return Default(schema, path, knownProperties)
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties)
   const unevaluatedProperties = schema.unevaluatedProperties as TSchema
   return unknownKeys.reduce((value, key) => {
     return !knownKeys.includes(key) 
-      ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }  
+      ? { ...value, [key]: Default(unevaluatedProperties, `${path}/${key}`, value[key]) }  
       : value
   }, knownProperties)
 }
 // prettier-ignore
-function FromNot(schema: TNot, references: TSchema[], value: any) {
-  return Default(schema.not, Default(schema, value))
+function FromNot(schema: TNot, references: TSchema[], path: string, value: any) {
+  return Default(schema.not, path, Default(schema, path, value))
 }
 // prettier-ignore
-function FromObject(schema: TObject, references: TSchema[], value: any) {
-  const defaulted = Default(schema, value)
+function FromObject(schema: TObject, references: TSchema[], path: string, value: any) {
+  const defaulted = Default(schema, path, value)
   if (!IsStandardObject(value)) return defaulted
   const knownKeys = KeyOfPropertyKeys(schema) as string[]
   const knownProperties = knownKeys.reduce((value, key) => {
     return key in value 
-      ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) } 
+      ? { ...value, [key]: Visit(schema.properties[key], references, `${path}/${key}`, value[key]) } 
       : value
   }, defaulted)
   if (!IsSchema(schema.additionalProperties)) {
@@ -126,90 +137,90 @@ function FromObject(schema: TObject, references: TSchema[], value: any) {
   const additionalProperties = schema.additionalProperties as TSchema
   return unknownKeys.reduce((value, key) => {
     return !knownKeys.includes(key) 
-      ? { ...value, [key]: Default(additionalProperties, value[key]) }  
+      ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }  
       : value
   }, knownProperties)
 }
 // prettier-ignore
-function FromRecord(schema: TRecord, references: TSchema[], value: any) {
-  const defaulted = Default(schema, value) as Record<PropertyKey, unknown>
+function FromRecord(schema: TRecord, references: TSchema[], path: string, value: any) {
+  const defaulted = Default(schema, path, value) as Record<PropertyKey, unknown>
   if (!IsStandardObject(value)) return defaulted
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
   const knownKeys = new RegExp(pattern)
   const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
     return knownKeys.test(key) 
-      ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
+      ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, `${path}/${key}`, value[key]) }
       : value
   }, defaulted)
   if (!IsSchema(schema.additionalProperties)) {
-    return Default(schema, knownProperties)
+    return Default(schema, path, knownProperties)
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties)
   const additionalProperties = schema.additionalProperties as TSchema
   return unknownKeys.reduce((value, key) => {
     return !knownKeys.test(key) 
-      ? { ...value, [key]: Default(additionalProperties, value[key]) }  
+      ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }  
       : value
   }, knownProperties)
 }
 // prettier-ignore
-function FromRef(schema: TRef, references: TSchema[], value: any) {
+function FromRef(schema: TRef, references: TSchema[], path: string, value: any) {
   const target = Deref(schema, references)
-  const resolved = Visit(target, references, value)
-  return Default(schema, resolved)
+  const resolved = Visit(target, references, path, value)
+  return Default(schema, path, resolved)
 }
 // prettier-ignore
-function FromThis(schema: TThis, references: TSchema[], value: any) {
+function FromThis(schema: TThis, references: TSchema[], path: string, value: any) {
   const target = Deref(schema, references)
-  const resolved = Visit(target, references, value)
-  return Default(schema, resolved)
+  const resolved = Visit(target, references, path, value)
+  return Default(schema, path, resolved)
 }
 // prettier-ignore
-function FromTuple(schema: TTuple, references: TSchema[], value: any) {
-  const value1 = Default(schema, value)
-  return IsArray(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, value1[index])) : []
+function FromTuple(schema: TTuple, references: TSchema[], path: string, value: any) {
+  const value1 = Default(schema, path, value)
+  return IsArray(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, `${path}/${index}`, value1[index])) : []
 }
 // prettier-ignore
-function FromUnion(schema: TUnion, references: TSchema[], value: any) {
+function FromUnion(schema: TUnion, references: TSchema[], path: string, value: any) {
   // test value against union variants
   for (const subschema of schema.anyOf) {
     if (!Check(subschema, references, value)) continue
-    const value1 = Visit(subschema, references, value)
-    return Default(schema, value1)
+    const value1 = Visit(subschema, references, path, value)
+    return Default(schema, path, value1)
   }
   // test transformed value against union variants
   for (const subschema of schema.anyOf) {
-    const value1 = Visit(subschema, references, value)
+    const value1 = Visit(subschema, references, path, value)
     if (!Check(schema, references, value1)) continue
-    return Default(schema, value1)
+    return Default(schema, path, value1)
   }
-  return Default(schema, value)
+  return Default(schema, path, value)
 }
 // prettier-ignore
-function Visit(schema: TSchema, references: TSchema[], value: any): any {
+function Visit(schema: TSchema, references: TSchema[], path: string, value: any): any {
   const references_ = typeof schema.$id === 'string' ? [...references, schema] : references
   const schema_ = schema as any
   switch (schema[Kind]) {
     case 'Array':
-      return FromArray(schema_, references_, value)
+      return FromArray(schema_, references_, path, value)
     case 'Intersect':
-      return FromIntersect(schema_, references_, value)
+      return FromIntersect(schema_, references_, path, value)
     case 'Not':
-      return FromNot(schema_, references_, value)
+      return FromNot(schema_, references_, path, value)
     case 'Object':
-      return FromObject(schema_, references_, value)
+      return FromObject(schema_, references_, path, value)
     case 'Record':
-      return FromRecord(schema_, references_, value)
+      return FromRecord(schema_, references_, path, value)
     case 'Ref':
-      return FromRef(schema_, references_, value)
+      return FromRef(schema_, references_, path, value)
     case 'This':
-      return FromThis(schema_, references_, value)
+      return FromThis(schema_, references_, path, value)
     case 'Tuple':
-      return FromTuple(schema_, references_, value)
+      return FromTuple(schema_, references_, path, value)
     case 'Union':
-      return FromUnion(schema_, references_, value)
+      return FromUnion(schema_, references_, path, value)
     default:
-      return Default(schema_, value)
+      return Default(schema_, path, value)
   }
 }
 /**
@@ -219,5 +230,5 @@ function Visit(schema: TSchema, references: TSchema[], value: any): any {
  * `Value.Encode()` function for implementation details.
  */
 export function TransformEncode(schema: TSchema, references: TSchema[], value: unknown): unknown {
-  return Visit(schema, references, value)
+  return Visit(schema, references, '', value)
 }
diff --git a/src/value/value/value.ts b/src/value/value/value.ts
index 6b5febc8b..f64dc18e5 100644
--- a/src/value/value/value.ts
+++ b/src/value/value/value.ts
@@ -113,7 +113,7 @@ export function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, value:
 export function Encode(...args: any[]) {
   const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
   const encoded = TransformEncode(schema, references, value)
-  if (!Check(schema, references, encoded)) throw new TransformEncodeCheckError(schema, value, Errors(schema, references, value).First()!)
+  if (!Check(schema, references, encoded)) throw new TransformEncodeCheckError(schema, encoded, Errors(schema, references, encoded).First()!)
   return encoded
 }
 /** Returns an iterator for each error in this value. */
diff --git a/test/runtime/type/guard/composite.ts b/test/runtime/type/guard/composite.ts
index d3e9557a2..351041bb2 100644
--- a/test/runtime/type/guard/composite.ts
+++ b/test/runtime/type/guard/composite.ts
@@ -130,8 +130,9 @@ describe('type/guard/TComposite', () => {
   // ----------------------------------------------------------------
   // Union
   // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/789
   // prettier-ignore
-  it('Should composite Union 1', () => {
+  it('Should composite Union 1 (non-overlapping)', () => {
     const T = Type.Composite([
       Type.Union([
         Type.Object({ x: Type.Number() }),
@@ -142,11 +143,12 @@ describe('type/guard/TComposite', () => {
       ])
     ])
     Assert.IsEqual(T, Type.Object({
-      z: Type.Intersect([Type.Union([Type.Never(), Type.Never()]), Type.Number()])
+      z: Type.Number()
     }))
   })
+  // https://github.com/sinclairzx81/typebox/issues/789
   // prettier-ignore
-  it('Should composite Union 2', () => {
+  it('Should composite Union 2 (overlapping)', () => {
     const T = Type.Composite([
       Type.Union([
         Type.Object({ x: Type.Number() }),
diff --git a/test/runtime/type/guard/record.ts b/test/runtime/type/guard/record.ts
index 89ec3dfae..f0c11b6f9 100644
--- a/test/runtime/type/guard/record.ts
+++ b/test/runtime/type/guard/record.ts
@@ -139,4 +139,18 @@ describe('type/guard/TRecord', () => {
     const R = TypeGuard.IsObject(Type.Record(K, Type.Number()))
     Assert.IsTrue(R)
   })
+  // ------------------------------------------------------------------
+  // Evaluated: Dollar Sign Escape
+  // https://github.com/sinclairzx81/typebox/issues/794
+  // ------------------------------------------------------------------
+  // prettier-ignore
+  {
+    const K = Type.TemplateLiteral('$prop${A|B|C}') // issue
+    const T = Type.Record(K, Type.String())
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.$propA))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.$propB))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.$propC))
+    Assert.IsEqual(T.required, ['$propA', '$propB', '$propC'])
+  }
 })
diff --git a/test/runtime/type/template-literal/generate.ts b/test/runtime/type/template-literal/generate.ts
index 2178571bc..197754750 100644
--- a/test/runtime/type/template-literal/generate.ts
+++ b/test/runtime/type/template-literal/generate.ts
@@ -44,12 +44,12 @@ describe('type/template-literal/TemplateLiteralExpressionGenerate', () => {
   it('Expression 2', () => {
     const E = TemplateLiteralParse('\\)')
     const R = [...TemplateLiteralExpressionGenerate(E)]
-    Assert.IsEqual(R, ['\\)'])
+    Assert.IsEqual(R, [')'])
   })
   it('Expression 3', () => {
     const E = TemplateLiteralParse('\\(')
     const R = [...TemplateLiteralExpressionGenerate(E)]
-    Assert.IsEqual(R, ['\\('])
+    Assert.IsEqual(R, ['('])
   })
   it('Expression 4', () => {
     const E = TemplateLiteralParse('')
@@ -196,4 +196,9 @@ describe('type/template-literal/TemplateLiteralExpressionGenerate', () => {
     const R = [...TemplateLiteralExpressionGenerate(E)]
     Assert.IsEqual(R, ['011', '001'])
   })
+  it('Expression 33', () => {
+    const E = TemplateLiteralParse('\\$prop(1|2|3)')
+    const R = [...TemplateLiteralExpressionGenerate(E)]
+    Assert.IsEqual(R, ['$prop1', '$prop2', '$prop3'])
+  })
 })
diff --git a/test/runtime/type/template-literal/parse.ts b/test/runtime/type/template-literal/parse.ts
index 57db98fc6..679cb4b21 100644
--- a/test/runtime/type/template-literal/parse.ts
+++ b/test/runtime/type/template-literal/parse.ts
@@ -84,14 +84,14 @@ describe('type/template-literal/TemplateLiteralParser', () => {
     const E = TemplateLiteralParse('\\)')
     Assert.IsEqual(E, {
       type: 'const',
-      const: '\\)',
+      const: ')',
     })
   })
   it('Expression 3', () => {
     const E = TemplateLiteralParse('\\(')
     Assert.IsEqual(E, {
       type: 'const',
-      const: '\\(',
+      const: '(',
     })
   })
   it('Expression 4', () => {
diff --git a/test/runtime/value/convert/intersect.ts b/test/runtime/value/convert/intersect.ts
index 5c2e2bb37..191150a3b 100644
--- a/test/runtime/value/convert/intersect.ts
+++ b/test/runtime/value/convert/intersect.ts
@@ -12,7 +12,10 @@ describe('value/convert/Intersect', () => {
     const R = Value.Convert(T, { x: '1', y: '2' })
     Assert.IsEqual(R, { x: 1, y: 2 })
   })
-  it('Should not convert for non object exclusive intersect', () => {
+  // ----------------------------------------------------------------
+  // Intersection Complex
+  // ----------------------------------------------------------------
+  it('Should complex intersect 1', () => {
     // prettier-ignore
     const T = Type.Intersect([
       Type.Number(),
@@ -20,26 +23,26 @@ describe('value/convert/Intersect', () => {
       Type.Object({ y: Type.Number() })
     ])
     const R = Value.Convert(T, { x: '1', y: '2' })
-    Assert.IsEqual(R, { x: '1', y: '2' })
+    Assert.IsEqual(R, { x: 1, y: 2 })
   })
-  it('Should convert first type for object exclusive intersect 1', () => {
+  it('Should complex intersect 2', () => {
     // prettier-ignore
     const T = Type.Intersect([
-      Type.Number(),
       Type.Object({ x: Type.Number() }),
-      Type.Object({ y: Type.Number() })
+      Type.Object({ y: Type.Number() }),
+      Type.Number(),
     ])
-    const R = Value.Convert(T, '123')
-    Assert.IsEqual(R, 123)
+    const R = Value.Convert(T, { x: '3', y: '4' })
+    Assert.IsEqual(R, { x: 3, y: 4 })
   })
-  it('Should convert first type for object exclusive intersect 2', () => {
+  it('Should complex intersect 3', () => {
     // prettier-ignore
     const T = Type.Intersect([
-      Type.Object({ x: Type.Number() }),
-      Type.Object({ y: Type.Number() }),
       Type.Number(),
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() })
     ])
-    const R = Value.Convert(T, { x: '3', y: '4' })
-    Assert.IsEqual(R, { x: 3, y: '4' })
+    const R = Value.Convert(T, '123')
+    Assert.IsEqual(R, 123)
   })
 })
diff --git a/test/runtime/value/convert/union.ts b/test/runtime/value/convert/union.ts
index 12f731b08..227e76c95 100644
--- a/test/runtime/value/convert/union.ts
+++ b/test/runtime/value/convert/union.ts
@@ -1,4 +1,4 @@
-import { Value } from '@sinclair/typebox/value'
+import { Convert, Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
@@ -14,11 +14,30 @@ describe('value/convert/Union', () => {
     Assert.IsEqual(V2, { x: null })
     Assert.IsEqual(V3, { x: 'hello' })
   })
-  it('Should convert first variant in ambiguous conversion', () => {
+  it('Should convert last variant in ambiguous conversion', () => {
     const T = Type.Object({
       x: Type.Union([Type.Boolean(), Type.Number()]),
     })
     const V1 = Value.Convert(T, { x: '1' })
-    Assert.IsEqual(V1, { x: true })
+    Assert.IsEqual(V1, { x: 1 })
+  })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/787
+  // ----------------------------------------------------------------
+  // prettier-ignore
+  it('Should convert Intersect Union', () => {
+    const T = Type.Intersect([
+      Type.Union([
+        Type.Object({ a: Type.Number() }),
+        Type.Object({ b: Type.Number() }),
+      ]),
+      Type.Object({ c: Type.Number() }),
+    ])
+    const A = Convert(T, { a: '1', c: '2' })
+    const B = Convert(T, { b: '1', c: '2' })
+    const C = Convert(T, { a: '1', b: '2', c: '3' })
+    Assert.IsEqual(A, { a: 1, c: 2 })
+    Assert.IsEqual(B, { b: 1, c: 2 })
+    Assert.IsEqual(C, { a: 1, b: 2, c: 3 })
   })
 })
diff --git a/test/static/composite.ts b/test/static/composite.ts
index e2b440f41..f124f6dbc 100644
--- a/test/static/composite.ts
+++ b/test/static/composite.ts
@@ -1,5 +1,5 @@
 import { Expect } from './assert'
-import { Type, TOptional, TObject, TIntersect, TNumber, TBoolean } from '@sinclair/typebox'
+import { Type, TOptional, TObject, TUnion, TIntersect, TNumber, TString, TBoolean } from '@sinclair/typebox'
 
 // ----------------------------------------------------------------------------
 // Overlapping - Non Varying
@@ -184,3 +184,30 @@ import { Type, TOptional, TObject, TIntersect, TNumber, TBoolean } from '@sincla
     ])
   ])
 }
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const T: TObject<{
+    x: TNumber;
+  }> = Type.Composite([
+    Type.Union([
+      Type.Object({ x: Type.Number() }),
+      Type.Object({ y: Type.Number() })
+    ]),
+    Type.Object({ x: Type.Number() })
+  ])
+}
+// prettier-ignore
+{
+  const T: TObject<{
+    x: TIntersect<[TUnion<[TString, TString]>, TNumber]>;
+  }> = Type.Composite([
+    Type.Union([
+      Type.Object({ x: Type.String() }),
+      Type.Object({ x: Type.String() })
+    ]),
+    Type.Object({ x: Type.Number() })
+  ])
+}
diff --git a/test/static/record.ts b/test/static/record.ts
index e284ce053..da8a0288f 100644
--- a/test/static/record.ts
+++ b/test/static/record.ts
@@ -175,3 +175,17 @@ import { Type, Static } from '@sinclair/typebox'
   const T = Type.Record(Type.Enum(E), Type.Number())
   Expect(T).ToStatic<{ [x: string]: number }>
 }
+// ------------------------------------------------------------------
+// Dollar Sign Escape
+// https://github.com/sinclairzx81/typebox/issues/794
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const K = Type.TemplateLiteral('$prop${A|B|C}') // issue
+  const T = Type.Record(K, Type.String())
+  Expect(T).ToStatic<{
+    '$propA': string,
+    '$propB': string,
+    '$propC': string
+  }>()
+}
diff --git a/test/static/template-literal.ts b/test/static/template-literal.ts
index 670b0b694..773ee1fa1 100644
--- a/test/static/template-literal.ts
+++ b/test/static/template-literal.ts
@@ -77,3 +77,38 @@ import { Type } from '@sinclair/typebox'
   const T = Type.TemplateLiteral([Type.Literal('hello'), A])
   Expect(T).ToStatic<'helloA' | 'helloB'>()
 }
+// ------------------------------------------------------------------
+// Dollar Sign Escape
+// https://github.com/sinclairzx81/typebox/issues/794
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const T = Type.TemplateLiteral('$prop${A|B|C}') // issue
+  Expect(T).ToStatic<'$propA' | '$propB' | '$propC'>()
+}
+// prettier-ignore
+{
+  const T = Type.TemplateLiteral('$prop${A|B|C}x') // trailing
+  Expect(T).ToStatic<'$propAx' | '$propBx' | '$propCx'>()
+}
+// prettier-ignore
+{ 
+  const T = Type.TemplateLiteral('$prop${A|B|C}x}') // non-greedy
+  Expect(T).ToStatic<'$propAx}' | '$propBx}' | '$propCx}'>()
+}
+// prettier-ignore
+{
+  const T = Type.TemplateLiteral('$prop${A|B|C}x}${X|Y}') // distributive - non-greedy
+  Expect(T).ToStatic<
+    '$propAx}X' | '$propBx}X' | '$propCx}X' | 
+    '$propAx}Y' | '$propBx}Y' | '$propCx}Y'
+  >()
+}
+// prettier-ignore
+{ 
+  const T = Type.TemplateLiteral('$prop${A|B|C}x}${X|Y}x') // distributive - non-greedy - trailing
+  Expect(T).ToStatic<
+    '$propAx}Xx' | '$propBx}Xx' | '$propCx}Xx' | 
+    '$propAx}Yx' | '$propBx}Yx' | '$propCx}Yx'
+  >()
+}

From ec27004427a2a669a4e962b5afb7b75bca3d20c3 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 20 Mar 2024 18:45:53 +0900
Subject: [PATCH 241/369] Revision 0.32.17 (#799)

* Detect Any on StaticDecode

* Revision 0.32.17
---
 package-lock.json         |  4 ++--
 package.json              |  2 +-
 src/type/static/static.ts |  3 ++-
 test/static/transform.ts  | 11 +++++++++++
 4 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 3804e5462..5077496c8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.16",
+  "version": "0.32.17",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.16",
+      "version": "0.32.17",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index e4c6fe9ab..6ea8b8b95 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.16",
+  "version": "0.32.17",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/static/static.ts b/src/type/static/static.ts
index 488055c76..7e346b7ac 100644
--- a/src/type/static/static.ts
+++ b/src/type/static/static.ts
@@ -85,8 +85,9 @@ export type TDecodeType<T extends TSchema> = (
 // ------------------------------------------------------------------
 // Static
 // ------------------------------------------------------------------
+export type StaticDecodeIsAny<T> = boolean extends (T extends TSchema ? true : false) ? true : false
 /** Creates an decoded static type from a TypeBox type */
-export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<TDecodeType<T>, P>
+export type StaticDecode<T extends TSchema, P extends unknown[] = []> = StaticDecodeIsAny<T> extends true ? unknown : Static<TDecodeType<T>, P>
 /** Creates an encoded static type from a TypeBox type */
 export type StaticEncode<T extends TSchema, P extends unknown[] = []> = Static<T, P>
 /** Creates a static type from a TypeBox type */
diff --git a/test/static/transform.ts b/test/static/transform.ts
index 1f4176289..2f5e2411f 100644
--- a/test/static/transform.ts
+++ b/test/static/transform.ts
@@ -1,4 +1,7 @@
 import { Type, TSchema, Static, StaticDecode, TObject, TNumber } from '@sinclair/typebox'
+import { TypeCheck } from '@sinclair/typebox/compiler'
+import { Value } from '@sinclair/typebox/value'
+
 import { Expect } from './assert'
 {
   // string > number
@@ -309,3 +312,11 @@ import { Expect } from './assert'
   Expect(T).ToStaticDecode<new (x: Date) => Date>()
   Expect(T).ToStaticEncode<new (x: number) => number>()
 }
+// -------------------------------------------------------------
+// https://github.com/sinclairzx81/typebox/issues/798
+// -------------------------------------------------------------
+{
+  const c1: TypeCheck<any> = {} as any
+  const x1 = c1.Decode({})
+  const x2 = Value.Decode({} as any, {})
+}

From 8a6018dec4ae287edce9f3383a7afd9d787a382e Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 21 Mar 2024 16:47:16 +0900
Subject: [PATCH 242/369] Revision 0.32.18 (#801)

- Explicit Return on TypeSystem Type
---
 package-lock.json    | 4 ++--
 package.json         | 2 +-
 src/system/system.ts | 6 ++++--
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 5077496c8..a651c37c6 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.17",
+  "version": "0.32.18",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.17",
+      "version": "0.32.18",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 6ea8b8b95..a6fbb94b2 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.17",
+  "version": "0.32.18",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/system/system.ts b/src/system/system.ts
index 2715ee4e6..98b3647c6 100644
--- a/src/system/system.ts
+++ b/src/system/system.ts
@@ -27,7 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { TypeRegistry, FormatRegistry } from '../type/registry/index'
-import { Unsafe } from '../type/unsafe/index'
+import { Unsafe, type TUnsafe } from '../type/unsafe/index'
 import { Kind } from '../type/symbols/index'
 import { TypeBoxError } from '../type/error/index'
 
@@ -47,10 +47,12 @@ export class TypeSystemDuplicateFormat extends TypeBoxError {
 // ------------------------------------------------------------------
 // TypeSystem
 // ------------------------------------------------------------------
+export type TypeFactoryFunction<Type, Options = Record<PropertyKey, unknown>> = (options?: Partial<Options>) => TUnsafe<Type>
+
 /** Creates user defined types and formats and provides overrides for value checking behaviours */
 export namespace TypeSystem {
   /** Creates a new type */
-  export function Type<Type, Options = Record<PropertyKey, unknown>>(kind: string, check: (options: Options, value: unknown) => boolean) {
+  export function Type<Type, Options = Record<PropertyKey, unknown>>(kind: string, check: (options: Options, value: unknown) => boolean): TypeFactoryFunction<Type, Options> {
     if (TypeRegistry.Has(kind)) throw new TypeSystemDuplicateTypeKind(kind)
     TypeRegistry.Set(kind, check)
     return (options: Partial<Options> = {}) => Unsafe<Type>({ ...options, [Kind]: kind })

From 9e4c67dd857e106286454e55d9182342c3cfee99 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 23 Mar 2024 08:05:19 +0900
Subject: [PATCH 243/369] Revision 0.32.19 (#805)

* Revert Union Conversion Logic

* Version
---
 package-lock.json                   | 4 ++--
 package.json                        | 2 +-
 src/value/convert/convert.ts        | 7 ++++++-
 test/runtime/value/convert/union.ts | 6 +++---
 4 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index a651c37c6..e5543b702 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.18",
+  "version": "0.32.19",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.18",
+      "version": "0.32.19",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index a6fbb94b2..1ecddd42e 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.18",
+  "version": "0.32.19",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index dd0e2d1d2..a95e8228a 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -240,7 +240,12 @@ function FromUndefined(schema: TUndefined, references: TSchema[], value: any): u
   return TryConvertUndefined(value)
 }
 function FromUnion(schema: TUnion, references: TSchema[], value: any): unknown {
-  return schema.anyOf.reduce((value, schema) => Visit(schema, references, value), value)
+  for (const subschema of schema.anyOf) {
+    const converted = Visit(subschema, references, value)
+    if (!Check(subschema, references, converted)) continue
+    return converted
+  }
+  return value
 }
 function Visit(schema: TSchema, references: TSchema[], value: any): unknown {
   const references_ = IsString(schema.$id) ? [...references, schema] : references
diff --git a/test/runtime/value/convert/union.ts b/test/runtime/value/convert/union.ts
index 227e76c95..ef020b69a 100644
--- a/test/runtime/value/convert/union.ts
+++ b/test/runtime/value/convert/union.ts
@@ -14,12 +14,12 @@ describe('value/convert/Union', () => {
     Assert.IsEqual(V2, { x: null })
     Assert.IsEqual(V3, { x: 'hello' })
   })
-  it('Should convert last variant in ambiguous conversion', () => {
+  it('Should convert first variant in ambiguous conversion', () => {
     const T = Type.Object({
       x: Type.Union([Type.Boolean(), Type.Number()]),
     })
     const V1 = Value.Convert(T, { x: '1' })
-    Assert.IsEqual(V1, { x: 1 })
+    Assert.IsEqual(V1, { x: true })
   })
   // ----------------------------------------------------------------
   // https://github.com/sinclairzx81/typebox/issues/787
@@ -38,6 +38,6 @@ describe('value/convert/Union', () => {
     const C = Convert(T, { a: '1', b: '2', c: '3' })
     Assert.IsEqual(A, { a: 1, c: 2 })
     Assert.IsEqual(B, { b: 1, c: 2 })
-    Assert.IsEqual(C, { a: 1, b: 2, c: 3 })
+    Assert.IsEqual(C, { a: 1, b: '2', c: 3 }) // note: matching on first
   })
 })

From 3735b3425b697ffdf131f25ea2e5c57a05efbdb1 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sat, 23 Mar 2024 17:48:11 +0900
Subject: [PATCH 244/369] Add FromSchema Prototype

---
 example/prototypes/from-schema.ts | 237 ++++++++++++++++++++++++++++++
 example/prototypes/index.ts       |   1 +
 2 files changed, 238 insertions(+)
 create mode 100644 example/prototypes/from-schema.ts

diff --git a/example/prototypes/from-schema.ts b/example/prototypes/from-schema.ts
new file mode 100644
index 000000000..94a4716b2
--- /dev/null
+++ b/example/prototypes/from-schema.ts
@@ -0,0 +1,237 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/prototypes
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Type from '@sinclair/typebox'
+
+// ------------------------------------------------------------------
+// Schematics
+// ------------------------------------------------------------------
+const IsExact = (value: unknown, expect: unknown) => value === expect
+const IsSValue = (value: unknown): value is SValue => Type.ValueGuard.IsString(value) || Type.ValueGuard.IsNumber(value) || Type.ValueGuard.IsBoolean(value)
+const IsSEnum = (value: unknown): value is SEnum => Type.ValueGuard.IsObject(value) && Type.ValueGuard.IsArray(value.enum) && value.enum.every((value) => IsSValue(value))
+const IsSAllOf = (value: unknown): value is SAllOf => Type.ValueGuard.IsObject(value) && Type.ValueGuard.IsArray(value.allOf)
+const IsSAnyOf = (value: unknown): value is SAnyOf => Type.ValueGuard.IsObject(value) && Type.ValueGuard.IsArray(value.anyOf)
+const IsSOneOf = (value: unknown): value is SOneOf => Type.ValueGuard.IsObject(value) && Type.ValueGuard.IsArray(value.oneOf)
+const IsSTuple = (value: unknown): value is STuple => Type.ValueGuard.IsObject(value) && IsExact(value.type, 'array') && Type.ValueGuard.IsArray(value.items)
+const IsSArray = (value: unknown): value is SArray => Type.ValueGuard.IsObject(value) && IsExact(value.type, 'array') && !Type.ValueGuard.IsArray(value.items) && Type.ValueGuard.IsObject(value.items)
+const IsSConst = (value: unknown): value is SConst => Type.ValueGuard.IsObject(value) && Type.ValueGuard.IsObject(value['const'])
+const IsSString = (value: unknown): value is SString => Type.ValueGuard.IsObject(value) && IsExact(value.type, 'string')
+const IsSNumber = (value: unknown): value is SNumber => Type.ValueGuard.IsObject(value) && IsExact(value.type, 'number')
+const IsSInteger = (value: unknown): value is SInteger => Type.ValueGuard.IsObject(value) && IsExact(value.type, 'integer')
+const IsSBoolean = (value: unknown): value is SBoolean => Type.ValueGuard.IsObject(value) && IsExact(value.type, 'boolean')
+const IsSNull = (value: unknown): value is SBoolean => Type.ValueGuard.IsObject(value) && IsExact(value.type, 'null')
+const IsSProperties = (value: unknown): value is SProperties => Type.ValueGuard.IsObject(value)
+// prettier-ignore
+const IsSObject = (value: unknown): value is SObject => Type.ValueGuard.IsObject(value) && IsExact(value.type, 'object') && IsSProperties(value.properties) && (value.required === undefined || Type.ValueGuard.IsArray(value.required) && value.required.every((value: unknown) => Type.ValueGuard.IsString(value)))
+type SValue = string | number | boolean
+type SEnum = Readonly<{ enum: readonly SValue[] }>
+type SAllOf = Readonly<{ allOf: readonly unknown[] }>
+type SAnyOf = Readonly<{ anyOf: readonly unknown[] }>
+type SOneOf = Readonly<{ oneOf: readonly unknown[] }>
+type SProperties = Record<PropertyKey, unknown>
+type SObject = Readonly<{ type: 'object'; properties: SProperties; required?: readonly string[] }>
+type STuple = Readonly<{ type: 'array'; items: readonly unknown[] }>
+type SArray = Readonly<{ type: 'array'; items: unknown }>
+type SConst = Readonly<{ const: SValue }>
+type SString = Readonly<{ type: 'string' }>
+type SNumber = Readonly<{ type: 'number' }>
+type SInteger = Readonly<{ type: 'integer' }>
+type SBoolean = Readonly<{ type: 'boolean' }>
+type SNull = Readonly<{ type: 'null' }>
+// ------------------------------------------------------------------
+// FromRest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRest<T extends readonly unknown[], Acc extends Type.TSchema[] = []> = (
+  T extends readonly [infer L extends unknown, ...infer R extends unknown[]]
+    ? TFromSchema<L> extends infer S extends Type.TSchema
+      ? TFromRest<R, [...Acc, S]>
+      : TFromRest<R, [...Acc]>
+    : Acc
+)
+function FromRest<T extends readonly unknown[]>(T: T): TFromRest<T> {
+  return T.map((L) => FromSchema(L)) as never
+}
+// ------------------------------------------------------------------
+// FromEnumRest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromEnumRest<T extends readonly SValue[], Acc extends Type.TSchema[] = []> = (
+  T extends readonly [infer L extends SValue, ...infer R extends SValue[]]
+    ? TFromEnumRest<R, [...Acc, Type.TLiteral<L>]>
+    : Acc
+)
+function FromEnumRest<T extends readonly SValue[]>(T: T): TFromEnumRest<T> {
+  return T.map((L) => Type.Literal(L)) as never
+}
+// ------------------------------------------------------------------
+// AllOf
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromAllOf<T extends SAllOf> = (
+  TFromRest<T['allOf']> extends infer Rest extends Type.TSchema[]
+    ? Type.TIntersectEvaluated<Rest>
+    : Type.TNever
+)
+function FromAllOf<T extends SAllOf>(T: T): TFromAllOf<T> {
+  return Type.IntersectEvaluated(FromRest(T.allOf), T)
+}
+// ------------------------------------------------------------------
+// AnyOf
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromAnyOf<T extends SAnyOf> = (
+  TFromRest<T['anyOf']> extends infer Rest extends Type.TSchema[]
+    ? Type.TUnionEvaluated<Rest>
+    : Type.TNever
+)
+function FromAnyOf<T extends SAnyOf>(T: T): TFromAnyOf<T> {
+  return Type.UnionEvaluated(FromRest(T.anyOf), T)
+}
+// ------------------------------------------------------------------
+// OneOf
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromOneOf<T extends SOneOf> = (
+  TFromRest<T['oneOf']> extends infer Rest extends Type.TSchema[]
+    ? Type.TUnionEvaluated<Rest>
+    : Type.TNever
+)
+function FromOneOf<T extends SOneOf>(T: T): TFromOneOf<T> {
+  return Type.UnionEvaluated(FromRest(T.oneOf), T)
+}
+// ------------------------------------------------------------------
+// Enum
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromEnum<T extends SEnum> = (
+  TFromEnumRest<T['enum']> extends infer Elements extends Type.TSchema[]
+    ? Type.TUnionEvaluated<Elements>
+    : Type.TNever
+)
+function FromEnum<T extends SEnum>(T: T): TFromEnum<T> {
+  return Type.UnionEvaluated(FromEnumRest(T.enum))
+}
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromTuple<T extends STuple> = (
+  TFromRest<T['items']> extends infer Elements extends Type.TSchema[]
+    ? Type.TTuple<Elements>
+    : Type.TTuple<[]>
+)
+// prettier-ignore
+function FromTuple<T extends STuple>(T: T): TFromTuple<T> {
+  return Type.Tuple(FromRest(T.items), T) as never
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromArray<T extends SArray> = (
+  TFromSchema<T['items']> extends infer Items extends Type.TSchema
+    ? Type.TArray<Items>
+    : Type.TArray<Type.TUnknown>
+)
+// prettier-ignore
+function FromArray<T extends SArray>(T: T): TFromArray<T> {
+  return Type.Array(FromSchema(T.items), T) as never
+}
+// ------------------------------------------------------------------
+// Const
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromConst<T extends SConst> = (
+  Type.Ensure<Type.TLiteral<T['const']>>
+)
+function FromConst<T extends SConst>(T: T) {
+  return Type.Literal(T.const, T)
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+type TFromPropertiesIsOptional<K extends PropertyKey, R extends string | unknown> = unknown extends R ? true : K extends R ? false : true
+// prettier-ignore
+type TFromProperties<T extends SProperties, R extends string | unknown> = Type.Evaluate<{
+  -readonly [K in keyof T]: TFromPropertiesIsOptional<K, R> extends true
+    ? Type.TOptional<TFromSchema<T[K]>>
+    : TFromSchema<T[K]>
+}>
+// prettier-ignore
+type TFromObject<T extends SObject> = (
+  TFromProperties<T['properties'], Exclude<T['required'], undefined>[number]> extends infer Properties extends Type.TProperties
+    ? Type.TObject<Properties>
+    : Type.TObject<{}>
+)
+function FromObject<T extends SObject>(T: T): TFromObject<T> {
+  const properties = globalThis.Object.getOwnPropertyNames(T.properties).reduce((Acc, K) => {
+    return { ...Acc, [K]: T.required && T.required.includes(K) ? FromSchema(T.properties[K]) : Type.Optional(FromSchema(T.properties[K])) }
+  }, {} as Type.TProperties)
+  return Type.Object(properties, T) as never
+}
+// ------------------------------------------------------------------
+// FromSchema
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TFromSchema<T> = (
+  T extends SAllOf ? TFromAllOf<T> :
+  T extends SAnyOf ? TFromAnyOf<T> :
+  T extends SOneOf ? TFromOneOf<T> :
+  T extends SEnum ? TFromEnum<T> :
+  T extends SObject ? TFromObject<T> :
+  T extends STuple ? TFromTuple<T> :
+  T extends SArray ? TFromArray<T> :
+  T extends SConst ? TFromConst<T> :
+  T extends SString ? Type.TString :
+  T extends SNumber ? Type.TNumber :
+  T extends SInteger ? Type.TInteger :
+  T extends SBoolean ? Type.TBoolean :
+  T extends SNull ? Type.TNull :
+  Type.TUnknown
+)
+/** Parses a TypeBox type from raw JsonSchema */
+export function FromSchema<T>(T: T): TFromSchema<T> {
+  // prettier-ignore
+  return (
+    IsSAllOf(T) ? FromAllOf(T) :
+    IsSAnyOf(T) ? FromAnyOf(T) :
+    IsSOneOf(T) ? FromOneOf(T) :
+    IsSEnum(T) ? FromEnum(T) :
+    IsSObject(T) ? FromObject(T) :
+    IsSTuple(T) ? FromTuple(T) :
+    IsSArray(T) ? FromArray(T) :
+    IsSConst(T) ? FromConst(T) :
+    IsSString(T) ? Type.String(T) :
+    IsSNumber(T) ? Type.Number(T) :
+    IsSInteger(T) ? Type.Integer(T) :
+    IsSBoolean(T) ? Type.Boolean(T) :
+    IsSNull(T) ? Type.Null(T) :
+    Type.Unknown(T || {})
+  ) as never
+}
diff --git a/example/prototypes/index.ts b/example/prototypes/index.ts
index c0011265b..c0039fc87 100644
--- a/example/prototypes/index.ts
+++ b/example/prototypes/index.ts
@@ -27,6 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 export * from './evaluate'
+export * from './from-schema'
 export * from './partial-deep'
 export * from './union-enum'
 export * from './union-oneof'

From 480ba12942cf908fab6e2ad16b3276b035ddcb54 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 25 Mar 2024 20:20:30 +0900
Subject: [PATCH 245/369] Revision 0.32.20 (#810)

* Solve TypeScript Compiler Emit Regression

* Version
---
 package-lock.json        | 18 ++++++-------
 package.json             |  4 +--
 src/value/delta/delta.ts | 55 +++++++++++++++++++++++++++-------------
 3 files changed, 49 insertions(+), 28 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index e5543b702..12bd65858 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.19",
+  "version": "0.32.20",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.19",
+      "version": "0.32.20",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
@@ -17,7 +17,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^9.2.2",
         "prettier": "^2.7.1",
-        "typescript": "^5.4.2"
+        "typescript": "^5.4.3"
       }
     },
     "node_modules/@andrewbranch/untar.js": {
@@ -1644,9 +1644,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.4.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.4.2.tgz",
-      "integrity": "sha512-+2/g0Fds1ERlP6JsakQQDXjZdZMM+rqpamFZJEKh4kwTIn3iDkgKtby0CeNd5ATNZ4Ry1ax15TMx0W2V+miizQ==",
+      "version": "5.4.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.4.3.tgz",
+      "integrity": "sha512-KrPd3PKaCLr78MalgiwJnA25Nm8HAmdwN3mYUYZgG/wizIo9EainNVQI9/yDavtVFRN2h3k8uf3GLHuhDMgEHg==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -2874,9 +2874,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.4.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.4.2.tgz",
-      "integrity": "sha512-+2/g0Fds1ERlP6JsakQQDXjZdZMM+rqpamFZJEKh4kwTIn3iDkgKtby0CeNd5ATNZ4Ry1ax15TMx0W2V+miizQ==",
+      "version": "5.4.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.4.3.tgz",
+      "integrity": "sha512-KrPd3PKaCLr78MalgiwJnA25Nm8HAmdwN3mYUYZgG/wizIo9EainNVQI9/yDavtVFRN2h3k8uf3GLHuhDMgEHg==",
       "dev": true
     },
     "undici-types": {
diff --git a/package.json b/package.json
index 1ecddd42e..469dd81f1 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.19",
+  "version": "0.32.20",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -37,6 +37,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^5.4.2"
+    "typescript": "^5.4.3"
   }
 }
diff --git a/src/value/delta/delta.ts b/src/value/delta/delta.ts
index daf47fa1e..bd437acc1 100644
--- a/src/value/delta/delta.ts
+++ b/src/value/delta/delta.ts
@@ -33,34 +33,55 @@ import { ValuePointer } from '../pointer/index'
 import { Clone } from '../clone/index'
 import { TypeBoxError } from '../../type/error/index'
 
-import { Literal as CreateLiteral } from '../../type/literal/index'
-import { Object as CreateObject } from '../../type/object/index'
-import { String as CreateString } from '../../type/string/index'
-import { Unknown as CreateUnknown } from '../../type/unknown/index'
-import { Union as CreateUnion } from '../../type/union/index'
+import { Literal, type TLiteral } from '../../type/literal/index'
+import { Object, type TObject } from '../../type/object/index'
+import { String, type TString } from '../../type/string/index'
+import { Unknown, type TUnknown } from '../../type/unknown/index'
+import { Union, type TUnion } from '../../type/union/index'
 
 // ------------------------------------------------------------------
 // Commands
 // ------------------------------------------------------------------
+
+// Note: A TypeScript 5.4.2 compiler regression resulted in the type
+// import paths being generated incorrectly. We can resolve this by
+// explicitly importing the correct TSchema types above. Note also
+// that the left-side annotations are optional, but since the types
+// are imported we might as well use them. We should check this
+// regression in future. The regression occured between TypeScript
+// versions 5.3.3 -> 5.4.2.
+
 export type Insert = Static<typeof Insert>
-export const Insert = CreateObject({
-  type: CreateLiteral('insert'),
-  path: CreateString(),
-  value: CreateUnknown(),
+export const Insert: TObject<{
+  type: TLiteral<'insert'>
+  path: TString
+  value: TUnknown
+}> = Object({
+  type: Literal('insert'),
+  path: String(),
+  value: Unknown(),
 })
 export type Update = Static<typeof Update>
-export const Update = CreateObject({
-  type: CreateLiteral('update'),
-  path: CreateString(),
-  value: CreateUnknown(),
+export const Update: TObject<{
+  type: TLiteral<'update'>
+  path: TString
+  value: TUnknown
+}> = Object({
+  type: Literal('update'),
+  path: String(),
+  value: Unknown(),
 })
 export type Delete = Static<typeof Delete>
-export const Delete = CreateObject({
-  type: CreateLiteral('delete'),
-  path: CreateString(),
+export const Delete: TObject<{
+  type: TLiteral<'delete'>
+  path: TString
+}> = Object({
+  type: Literal('delete'),
+  path: String(),
 })
 export type Edit = Static<typeof Edit>
-export const Edit = CreateUnion([Insert, Update, Delete])
+export const Edit: TUnion<[typeof Insert, typeof Update, typeof Delete]> = Union([Insert, Update, Delete])
+
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------

From b91c1c1a85af980a76c5c8a3fb599f0066db86f9 Mon Sep 17 00:00:00 2001
From: m1212e <14091540+m1212e@users.noreply.github.com>
Date: Tue, 16 Apr 2024 07:03:54 +0200
Subject: [PATCH 246/369] Ecosystem (#827)

---
 readme.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/readme.md b/readme.md
index 0a246c134..2d72ff4a9 100644
--- a/readme.md
+++ b/readme.md
@@ -1698,6 +1698,7 @@ The following is a list of community packages that offer general tooling, extend
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
 | [typebox-form-parser](https://github.com/jtlapp/typebox-form-parser) | Parses form and query data based on TypeBox schemas |
 | [typebox-validators](https://github.com/jtlapp/typebox-validators) | Advanced validators supporting discriminated and heterogeneous unions |
+| [prismabox](https://github.com/m1212e/prismabox) | Converts a prisma.schema to typebox schemes matching the database models |
 
 <a name='benchmark'></a>
 

From a169893ff7a1d6c42b2b4d3cbee0b3fde346ea68 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 16 Apr 2024 14:06:04 +0900
Subject: [PATCH 247/369] Ecosystem

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 2d72ff4a9..b6fad4d6a 100644
--- a/readme.md
+++ b/readme.md
@@ -1693,12 +1693,12 @@ The following is a list of community packages that offer general tooling, extend
 | [h3-typebox](https://github.com/kevinmarrec/h3-typebox) | Schema validation utilities for h3 using TypeBox & Ajv |
 | [http-wizard](https://github.com/flodlc/http-wizard) | Type safe http client library for Fastify |
 | [openapi-box](https://github.com/geut/openapi-box) | Generate TypeBox types from OpenApi IDL + Http client library |
+| [prismabox](https://github.com/m1212e/prismabox) | Converts a prisma.schema to typebox schema matching the database models |
 | [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from Json Schemas |
 | [sveltekit-superforms](https://github.com/ciscoheat/sveltekit-superforms)  | A comprehensive SvelteKit form library for server and client validation |
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
 | [typebox-form-parser](https://github.com/jtlapp/typebox-form-parser) | Parses form and query data based on TypeBox schemas |
 | [typebox-validators](https://github.com/jtlapp/typebox-validators) | Advanced validators supporting discriminated and heterogeneous unions |
-| [prismabox](https://github.com/m1212e/prismabox) | Converts a prisma.schema to typebox schemes matching the database models |
 
 <a name='benchmark'></a>
 

From 9265f4426c6cce349c4e150782cc03fed81b187f Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 17 Apr 2024 18:44:34 +0900
Subject: [PATCH 248/369] TypeScript 5.4.5

---
 hammer.mjs        |  2 +-
 package-lock.json | 14 +++++++-------
 package.json      |  2 +-
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/hammer.mjs b/hammer.mjs
index 1326d2195..065e0326b 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -32,7 +32,7 @@ export async function benchmark() {
 // Test
 // -------------------------------------------------------------------------------
 export async function test_typescript() {
-  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', 'next', 'latest']) {
+  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', 'next', 'latest']) {
     await shell(`npm install typescript@${version} --no-save`)
     await test_static()
   }
diff --git a/package-lock.json b/package-lock.json
index 12bd65858..9fb943232 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -17,7 +17,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^9.2.2",
         "prettier": "^2.7.1",
-        "typescript": "^5.4.3"
+        "typescript": "^5.4.5"
       }
     },
     "node_modules/@andrewbranch/untar.js": {
@@ -1644,9 +1644,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.4.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.4.3.tgz",
-      "integrity": "sha512-KrPd3PKaCLr78MalgiwJnA25Nm8HAmdwN3mYUYZgG/wizIo9EainNVQI9/yDavtVFRN2h3k8uf3GLHuhDMgEHg==",
+      "version": "5.4.5",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.4.5.tgz",
+      "integrity": "sha512-vcI4UpRgg81oIRUFwR0WSIHKt11nJ7SAVlYNIu+QpqeyXP+gpQJy/Z4+F0aGxSE4MqwjyXvW/TzgkLAx2AGHwQ==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -2874,9 +2874,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.4.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.4.3.tgz",
-      "integrity": "sha512-KrPd3PKaCLr78MalgiwJnA25Nm8HAmdwN3mYUYZgG/wizIo9EainNVQI9/yDavtVFRN2h3k8uf3GLHuhDMgEHg==",
+      "version": "5.4.5",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.4.5.tgz",
+      "integrity": "sha512-vcI4UpRgg81oIRUFwR0WSIHKt11nJ7SAVlYNIu+QpqeyXP+gpQJy/Z4+F0aGxSE4MqwjyXvW/TzgkLAx2AGHwQ==",
       "dev": true
     },
     "undici-types": {
diff --git a/package.json b/package.json
index 469dd81f1..cf71e410e 100644
--- a/package.json
+++ b/package.json
@@ -37,6 +37,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^5.4.3"
+    "typescript": "^5.4.5"
   }
 }

From bcee7b5a0f9b833567f64bc6469e56d378354216 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 19 Apr 2024 17:56:06 +0900
Subject: [PATCH 249/369] Revision 0.32.21 (#836)

* Composite Never Filter Fix | Support Array Conversion

* Version
---
 package-lock.json                   |  4 ++--
 package.json                        |  2 +-
 src/type/composite/composite.ts     | 22 +++++++++++-----------
 src/value/convert/convert.ts        |  9 ++-------
 test/runtime/value/convert/array.ts | 24 ++++++++++++++++++++++++
 5 files changed, 40 insertions(+), 21 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 9fb943232..2dde718ee 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.20",
+  "version": "0.32.21",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.20",
+      "version": "0.32.21",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index cf71e410e..ad32abec6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.20",
+  "version": "0.32.21",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/composite/composite.ts b/src/type/composite/composite.ts
index b37ccb613..8254036ee 100644
--- a/src/type/composite/composite.ts
+++ b/src/type/composite/composite.ts
@@ -45,14 +45,14 @@ import { IsNever } from '../guard/type'
 // prettier-ignore
 type TCompositeKeys<T extends TSchema[], Acc extends PropertyKey[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TCompositeKeys<R, TSetDistinct<[...Acc, ...TKeyOfPropertyKeys<L>]>>
-    : Acc
+    ? TCompositeKeys<R, [...Acc, ...TKeyOfPropertyKeys<L>]>
+    : TSetDistinct<Acc>
 )
 // prettier-ignore
 function CompositeKeys<T extends TSchema[]>(T: [...T]): TCompositeKeys<T> {
-  return T.reduce((Acc, L) => {
-    return SetDistinct([...Acc, ...KeyOfPropertyKeys(L)]) as never
-  }, []) as never
+  return SetDistinct(T.reduce((Acc, L) => {
+    return ([...Acc, ...KeyOfPropertyKeys(L)]) as never
+  }, [])) as never
 }
 // ------------------------------------------------------------------
 // FilterNever
@@ -61,7 +61,7 @@ function CompositeKeys<T extends TSchema[]>(T: [...T]): TCompositeKeys<T> {
 type TFilterNever<T extends TSchema[], Acc extends TSchema[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
     ? L extends TNever 
-      ? Acc 
+      ? TFilterNever<R, [...Acc]> 
       : TFilterNever<R, [...Acc, L]>
     : Acc
 )
@@ -75,14 +75,14 @@ function FilterNever<T extends TSchema[]>(T: [...T]): TFilterNever<T> {
 // prettier-ignore
 type TCompositeProperty<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-   ? TCompositeProperty<R, K, TFilterNever<[...Acc, ...TIndexFromPropertyKeys<L, [K]>]>>
-   : Acc
+   ? TCompositeProperty<R, K, [...Acc, ...TIndexFromPropertyKeys<L, [K]>]>
+   : TFilterNever<Acc>
 )
 // prettier-ignore
 function CompositeProperty<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TCompositeProperty<T, K> {
-  return T.reduce((Acc, L) => {
-    return FilterNever([...Acc, ...IndexFromPropertyKeys(L, [K])])
-  }, []) as never
+  return FilterNever(T.reduce((Acc, L) => {
+    return [...Acc, ...IndexFromPropertyKeys(L, [K])] as never
+  }, [])) as never
 }
 // ------------------------------------------------------------------
 // CompositeProperties
diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index a95e8228a..b17256384 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -29,10 +29,7 @@ THE SOFTWARE.
 import { Clone } from '../clone/index'
 import { Check } from '../check/index'
 import { Deref } from '../deref/index'
-
-import { IsObject as IsObjectType } from '../../type/guard/type'
 import { Kind } from '../../type/symbols/index'
-import { Composite } from '../../type/composite/index'
 
 import type { TSchema } from '../../type/schema/index'
 import type { TArray } from '../../type/array/index'
@@ -166,10 +163,8 @@ function Default(value: any) {
 // Convert
 // ------------------------------------------------------------------
 function FromArray(schema: TArray, references: TSchema[], value: any): any {
-  if (IsArray(value)) {
-    return value.map((value) => Visit(schema.items, references, value))
-  }
-  return value
+  const elements = IsArray(value) ? value : [value]
+  return elements.map((element) => Visit(schema.items, references, element))
 }
 function FromBigInt(schema: TBigInt, references: TSchema[], value: any): unknown {
   return TryConvertBigInt(value)
diff --git a/test/runtime/value/convert/array.ts b/test/runtime/value/convert/array.ts
index c8a040f3d..345a5564a 100644
--- a/test/runtime/value/convert/array.ts
+++ b/test/runtime/value/convert/array.ts
@@ -29,4 +29,28 @@ describe('value/convert/Array', () => {
     Assert.IsEqual(R[5].getTime(), 0)
     Assert.IsEqual(R[6], 'hello')
   })
+  // ----------------------------------------------------------------
+  // Array Coercion
+  // ----------------------------------------------------------------
+  it('Should convert into array (convert interior)', () => {
+    const T = Type.Array(Type.Number())
+    const R = Value.Convert(T, '1')
+    Assert.IsEqual(R, [1])
+  })
+  it('Should convert into array (retain interior)', () => {
+    const T = Type.Array(Type.Number())
+    const R = Value.Convert(T, 'A')
+    Assert.IsEqual(R, ['A'])
+  })
+  it('Should convert into array (object)', () => {
+    const T = Type.Array(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+    )
+    const R = Value.Convert(T, { x: '1', y: true, z: null })
+    Assert.IsEqual(R, [{ x: 1, y: 1, z: null }])
+  })
 })

From 3719b3eaff59fafe077bc47cf8ada4940f9499f2 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 21 Apr 2024 01:28:28 +0900
Subject: [PATCH 250/369] Revision 0.32.22 (#840)

* Support Optional and Readonly Function Arguments

* Version
---
 package-lock.json                   |  4 ++--
 package.json                        |  2 +-
 src/type/constructor/constructor.ts | 25 +++++++++++++++++--------
 src/type/function/function.ts       | 26 ++++++++++++++++++--------
 test/static/constructor.ts          | 20 ++++++++++++++++++++
 test/static/function.ts             | 22 ++++++++++++++++++++++
 6 files changed, 80 insertions(+), 19 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 2dde718ee..5249c5e1c 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.21",
+  "version": "0.32.22",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.21",
+      "version": "0.32.22",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index ad32abec6..0340aa476 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.21",
+  "version": "0.32.22",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/constructor/constructor.ts b/src/type/constructor/constructor.ts
index 948d0aab6..9983862ee 100644
--- a/src/type/constructor/constructor.ts
+++ b/src/type/constructor/constructor.ts
@@ -29,28 +29,37 @@ THE SOFTWARE.
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Static } from '../static/index'
 import type { Ensure } from '../helpers/index'
+import type { TReadonlyOptional } from '../readonly-optional/index'
+import type { TReadonly } from '../readonly/index'
+import type { TOptional } from '../optional/index'
 import { CloneType, CloneRest } from '../clone/type'
 import { Kind } from '../symbols/index'
 
 // ------------------------------------------------------------------
-// TConstructorStatic
+// StaticConstructor
 // ------------------------------------------------------------------
-type ConstructorStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>
+type StaticReturnType<U extends TSchema, P extends unknown[]> = Static<U, P>
 // prettier-ignore
-type ConstructorStaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = 
+type StaticParameter<T extends TSchema, P extends unknown[]> =
+  T extends TReadonlyOptional<T> ? [Readonly<Static<T, P>>?] :
+  T extends TReadonly<T> ? [Readonly<Static<T, P>>] :
+  T extends TOptional<T> ? [Static<T, P>?] :
+  [Static<T, P>]
+// prettier-ignore
+type StaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? ConstructorStaticParameters<R, P, [...Acc, Static<L, P>]>
+    ? StaticParameters<R, P, [...Acc, ...StaticParameter<L, P>]>
     : Acc
-// prettier-ignore
-type ConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (
-  Ensure<new (...param: ConstructorStaticParameters<T, P>) => ConstructorStaticReturnType<U, P>>
 )
+// prettier-ignore
+type StaticConstructor<T extends TSchema[], U extends TSchema, P extends unknown[]> =
+  Ensure<new (...params: StaticParameters<T, P>) => StaticReturnType<U, P>>
 // ------------------------------------------------------------------
 // TConstructor
 // ------------------------------------------------------------------
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Constructor'
-  static: ConstructorStatic<T, U, this['params']>
+  static: StaticConstructor<T, U, this['params']>
   type: 'Constructor'
   parameters: T
   returns: U
diff --git a/src/type/function/function.ts b/src/type/function/function.ts
index 6f594dfb3..340e5ba49 100644
--- a/src/type/function/function.ts
+++ b/src/type/function/function.ts
@@ -29,28 +29,38 @@ THE SOFTWARE.
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Static } from '../static/index'
 import type { Ensure } from '../helpers/index'
+import type { TReadonlyOptional } from '../readonly-optional/index'
+import type { TReadonly } from '../readonly/index'
+import type { TOptional } from '../optional/index'
 import { CloneType, CloneRest } from '../clone/type'
 import { Kind } from '../symbols/index'
 
 // ------------------------------------------------------------------
-// FunctionStatic
+// StaticFunction
 // ------------------------------------------------------------------
-type FunctionStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>
+type StaticReturnType<U extends TSchema, P extends unknown[]> = Static<U, P>
 // prettier-ignore
-type FunctionStaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = 
+type StaticParameter<T extends TSchema, P extends unknown[]> =
+  T extends TReadonlyOptional<T> ? [Readonly<Static<T, P>>?] :
+  T extends TReadonly<T> ? [Readonly<Static<T, P>>] :
+  T extends TOptional<T> ? [Static<T, P>?] :
+  [Static<T, P>]
+// prettier-ignore
+type StaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? FunctionStaticParameters<R, P, [...Acc, Static<L, P>]>
+    ? StaticParameters<R, P, [...Acc, ...StaticParameter<L, P>]>
     : Acc
-// prettier-ignore
-type FunctionStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (
-  Ensure<(...param: FunctionStaticParameters<T, P>) => FunctionStaticReturnType<U, P>>
 )
+// prettier-ignore
+type StaticFunction<T extends TSchema[], U extends TSchema, P extends unknown[]> =
+  Ensure<(...params: StaticParameters<T, P>) => StaticReturnType<U, P>>
+
 // ------------------------------------------------------------------
 // TFunction
 // ------------------------------------------------------------------
 export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Function'
-  static: FunctionStatic<T, U, this['params']>
+  static: StaticFunction<T, U, this['params']>
   type: 'Function'
   parameters: T
   returns: U
diff --git a/test/static/constructor.ts b/test/static/constructor.ts
index c91d398e7..59e435c62 100644
--- a/test/static/constructor.ts
+++ b/test/static/constructor.ts
@@ -13,6 +13,26 @@ import { Type } from '@sinclair/typebox'
   }))
   Expect(T).ToStatic<new (param_0: number, param_1: string) => { method: new (param_0: number, param_1: string) => boolean }>()
 }
+{
+  // readonly-optional
+  const T = Type.Constructor([Type.ReadonlyOptional(Type.Array(Type.Number()))], Type.Number())
+  Expect(T).ToStaticDecode<new (param_0?: readonly number[]) => number>()
+}
+{
+  // readonly
+  const T = Type.Constructor([Type.Readonly(Type.Array(Type.Number()))], Type.Number())
+  Expect(T).ToStaticDecode<new (param_0: readonly number[]) => number>()
+}
+{
+  // optional 1
+  const T = Type.Constructor([Type.Optional(Type.Number())], Type.Number())
+  Expect(T).ToStaticDecode<new (param_0?: number) => number>()
+}
+{
+  // optional 2
+  const T = Type.Constructor([Type.Number(), Type.Optional(Type.Number())], Type.Number())
+  Expect(T).ToStaticDecode<new (param_0: number, param_1?: number) => number>()
+}
 {
   // decode 2
   const S = Type.Transform(Type.Integer())
diff --git a/test/static/function.ts b/test/static/function.ts
index a204187a6..1ae3404aa 100644
--- a/test/static/function.ts
+++ b/test/static/function.ts
@@ -14,6 +14,28 @@ import { Type } from '@sinclair/typebox'
   }))
   Expect(T).ToStatic<(param_0: number, param_1: string) => { method: (param_0: number, param_1: string) => boolean }>()
 }
+{
+  // readonly-optional
+  const T = Type.Function([Type.ReadonlyOptional(Type.Array(Type.Number()))], Type.Number())
+  Expect(T).ToStaticDecode<(param_0?: readonly number[]) => number>()
+}
+{
+  // readonly
+  const T = Type.Function([Type.Readonly(Type.Array(Type.Number()))], Type.Number())
+  Expect(T).ToStaticDecode<(param_0: readonly number[]) => number>()
+}
+{
+  // optional 1
+  const T = Type.Function([Type.Optional(Type.Number())], Type.Number())
+  Expect(T).ToStaticDecode<(param_0?: number) => number>()
+}
+{
+  // optional 2
+  const T = Type.Function([Type.Number(), Type.Optional(Type.Number())], Type.Number())
+  Expect(T).ToStaticDecode<(param_0: number, param_1?: number) => number>()
+}
+const F = Type.Constructor([Type.Readonly(Type.Array(Type.String()))], Type.Number())
+
 {
   // decode 2
   const S = Type.Transform(Type.Integer())

From 2a2b5d9dd0a86be555c164f80013635f2e2419d6 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 24 Apr 2024 16:40:39 +0900
Subject: [PATCH 251/369] Revision 0.32.23 (#847)

* Clean: Ensure References Passed for Union Check

* Rename Inferred Function and Constructor Parameter

* Version
---
 package-lock.json                   |  4 ++--
 package.json                        |  2 +-
 src/type/constructor/constructor.ts |  2 +-
 src/type/function/function.ts       |  2 +-
 src/value/clean/clean.ts            |  2 +-
 test/runtime/value/clean/union.ts   | 23 +++++++++++++++++++++++
 6 files changed, 29 insertions(+), 6 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 5249c5e1c..b822b7549 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.22",
+  "version": "0.32.23",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.22",
+      "version": "0.32.23",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 0340aa476..b2c6b0327 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.22",
+  "version": "0.32.23",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/constructor/constructor.ts b/src/type/constructor/constructor.ts
index 9983862ee..c68ffe992 100644
--- a/src/type/constructor/constructor.ts
+++ b/src/type/constructor/constructor.ts
@@ -53,7 +53,7 @@ type StaticParameters<T extends TSchema[], P extends unknown[], Acc extends unkn
 )
 // prettier-ignore
 type StaticConstructor<T extends TSchema[], U extends TSchema, P extends unknown[]> =
-  Ensure<new (...params: StaticParameters<T, P>) => StaticReturnType<U, P>>
+  Ensure<new (...param: StaticParameters<T, P>) => StaticReturnType<U, P>>
 // ------------------------------------------------------------------
 // TConstructor
 // ------------------------------------------------------------------
diff --git a/src/type/function/function.ts b/src/type/function/function.ts
index 340e5ba49..d86297985 100644
--- a/src/type/function/function.ts
+++ b/src/type/function/function.ts
@@ -53,7 +53,7 @@ type StaticParameters<T extends TSchema[], P extends unknown[], Acc extends unkn
 )
 // prettier-ignore
 type StaticFunction<T extends TSchema[], U extends TSchema, P extends unknown[]> =
-  Ensure<(...params: StaticParameters<T, P>) => StaticReturnType<U, P>>
+  Ensure<(...param: StaticParameters<T, P>) => StaticReturnType<U, P>>
 
 // ------------------------------------------------------------------
 // TFunction
diff --git a/src/value/clean/clean.ts b/src/value/clean/clean.ts
index 7f48119b7..e913b4a67 100644
--- a/src/value/clean/clean.ts
+++ b/src/value/clean/clean.ts
@@ -141,7 +141,7 @@ function FromTuple(schema: TTuple, references: TSchema[], value: unknown): any {
 }
 function FromUnion(schema: TUnion, references: TSchema[], value: unknown): any {
   for (const inner of schema.anyOf) {
-    if (IsCheckable(inner) && Check(inner, value)) {
+    if (IsCheckable(inner) && Check(inner, references, value)) {
       return Visit(inner, references, value)
     }
   }
diff --git a/test/runtime/value/clean/union.ts b/test/runtime/value/clean/union.ts
index 443e3d651..010bd0c72 100644
--- a/test/runtime/value/clean/union.ts
+++ b/test/runtime/value/clean/union.ts
@@ -131,4 +131,27 @@ describe('value/clean/Union', () => {
     const R = Value.Clean(T, { u: null, y: 1 })
     Assert.IsEqual(R, { u: null, y: 1 })
   })
+  // ----------------------------------------------------------------
+  // Union Recursive
+  //
+  // https://github.com/sinclairzx81/typebox/issues/845
+  // ----------------------------------------------------------------
+  it('Should clean recursive with union', () => {
+    const T = Type.Recursive((This) =>
+      Type.Object({
+        id: Type.Number(),
+        parent: Type.Union([This, Type.Null()]),
+      }),
+    )
+    const R = Value.Clean(T, {
+      id: 1,
+      unknown: 1,
+      parent: {
+        id: 2,
+        unknown: 1,
+        parent: null,
+      },
+    })
+    Assert.IsEqual(R, { id: 1, parent: { id: 2, parent: null } })
+  })
 })

From cfc152b720faa863ae5d198d0a5fc8ea314f3864 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 25 Apr 2024 09:46:53 +0900
Subject: [PATCH 252/369] Revision 0.32.24 (#848)

---
 package-lock.json                    |  4 ++--
 package.json                         |  2 +-
 src/value/convert/convert.ts         | 14 ++++++++------
 src/value/value/value.ts             |  6 +++---
 test/runtime/value/convert/object.ts | 10 +++++++++-
 5 files changed, 23 insertions(+), 13 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index b822b7549..c98535528 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.23",
+  "version": "0.32.24",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.23",
+      "version": "0.32.24",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index b2c6b0327..5015e3835 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.23",
+  "version": "0.32.24",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index b17256384..9d8191342 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -54,7 +54,7 @@ import type { TUndefined } from '../../type/undefined/index'
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsArray, IsObject, IsDate, IsUndefined, IsString, IsNumber, IsBoolean, IsBigInt, IsSymbol } from '../guard/index'
+import { IsArray, IsObject, IsDate, IsUndefined, IsString, IsNumber, IsBoolean, IsBigInt, IsSymbol, HasPropertyKey } from '../guard/index'
 // ------------------------------------------------------------------
 // Conversions
 // ------------------------------------------------------------------
@@ -194,11 +194,13 @@ function FromNumber(schema: TNumber, references: TSchema[], value: any): unknown
 function FromObject(schema: TObject, references: TSchema[], value: any): unknown {
   const isConvertable = IsObject(value)
   if(!isConvertable) return value
-  return Object.getOwnPropertyNames(schema.properties).reduce((value, key) => {
-    return !IsUndefined(value[key])
-      ? ({ ...value, [key]: Visit(schema.properties[key], references, value[key]) })
-      : ({ ...value })
-  }, value) 
+  const result: Record<PropertyKey, unknown> = {}
+  for(const key of Object.keys(value)) {
+    result[key] = HasPropertyKey(schema.properties, key)
+      ? Visit(schema.properties[key], references, value[key])
+      : value[key]
+  }
+  return result
 }
 function FromRecord(schema: TRecord, references: TSchema[], value: any): unknown {
   const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0]
diff --git a/src/value/value/value.ts b/src/value/value/value.ts
index f64dc18e5..1228fa827 100644
--- a/src/value/value/value.ts
+++ b/src/value/value/value.ts
@@ -75,11 +75,11 @@ export function Clean(schema: TSchema, value: unknown): unknown
 export function Clean(...args: any[]) {
   return CleanValue.apply(CleanValue, args as any)
 }
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible */
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown
-/** Converts any type mismatched values to their target type if a reasonable conversion is possibl. */
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export function Convert(schema: TSchema, value: unknown): unknown
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible */
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export function Convert(...args: any[]) {
   return ConvertValue.apply(ConvertValue, args as any)
 }
diff --git a/test/runtime/value/convert/object.ts b/test/runtime/value/convert/object.ts
index fa5e4ed70..042c05647 100644
--- a/test/runtime/value/convert/object.ts
+++ b/test/runtime/value/convert/object.ts
@@ -2,9 +2,9 @@ import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
+// prettier-ignore
 describe('value/convert/Object', () => {
   it('Should convert properties', () => {
-    // prettier-ignore
     const T = Type.Object({
       x: Type.Number(),
       y: Type.Boolean(),
@@ -13,4 +13,12 @@ describe('value/convert/Object', () => {
     const R = Value.Convert(T, { x: '42', y: 'true', z: 'hello' })
     Assert.IsEqual(R, { x: 42, y: true, z: 'hello' })
   })
+  it('Should convert known properties', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.Boolean()
+    })
+    const R = Value.Convert(T, { x: '42', y: 'true', z: 'hello' })
+    Assert.IsEqual(R, { x: 42, y: true, z: 'hello' })
+  })
 })

From 130c52083a9ee8d181c8f609ed6898d8ae6d9518 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Thu, 25 Apr 2024 17:12:40 +0900
Subject: [PATCH 253/369] Partial Deep Prototype

---
 example/prototypes/partial-deep.ts | 50 ++++++++++++++++--------------
 1 file changed, 26 insertions(+), 24 deletions(-)

diff --git a/example/prototypes/partial-deep.ts b/example/prototypes/partial-deep.ts
index 7ee36f445..5fc707f80 100644
--- a/example/prototypes/partial-deep.ts
+++ b/example/prototypes/partial-deep.ts
@@ -29,38 +29,40 @@ THE SOFTWARE.
 import { TypeGuard, Type, TSchema, TIntersect, TUnion, TObject, TPartial, TProperties, Evaluate } from '@sinclair/typebox'
 
 // -------------------------------------------------------------------------------------
-// TDeepPartial
+// TPartialDeepProperties
 // -------------------------------------------------------------------------------------
 export type TPartialDeepProperties<T extends TProperties> = {
-  [K in keyof T]: TPartial<T[K]>
+  [K in keyof T]: TPartialDeep<T[K]>
 }
-export type TPartialDeepRest<T extends TSchema[]> = 
+function PartialDeepProperties<T extends TProperties>(properties: T): TPartialDeepProperties<T> {
+  return Object.getOwnPropertyNames(properties).reduce((acc, key) => {
+    return {...acc, [key]: PartialDeep(properties[key])}
+  }, {}) as never
+}
+// -------------------------------------------------------------------------------------
+// TPartialDeepRest
+// -------------------------------------------------------------------------------------
+export type TPartialDeepRest<T extends TSchema[], Acc extends TSchema[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? [TPartial<L>, ...TPartialDeepRest<R>]
-    : []
+    ? TPartialDeepRest<R, [...Acc, TPartialDeep<L>]>
+    : Acc
+)
+function PartialDeepRest<T extends TSchema[]>(rest: [...T]): TPartialDeepRest<T> {
+  return rest.map(schema => PartialDeep(schema)) as never
+}
+// -------------------------------------------------------------------------------------
+// TPartialDeep
+// -------------------------------------------------------------------------------------
 export type TPartialDeep<T extends TSchema> = 
   T extends TIntersect<infer S> ? TIntersect<TPartialDeepRest<S>> :
   T extends TUnion<infer S> ? TUnion<TPartialDeepRest<S>> :
   T extends TObject<infer S> ? TPartial<TObject<Evaluate<TPartialDeepProperties<S>>>> :
   T
-// -------------------------------------------------------------------------------------
-// DeepPartial
-// -------------------------------------------------------------------------------------
-function PartialDeepProperties<T extends TProperties>(properties: T) {
-  return Object.getOwnPropertyNames(properties).reduce((acc, key) => {
-    return {...acc, [key]: Type.Partial(properties[key])}
-  }, {} as TProperties)
-}
-function PartialDeepRest<T extends TSchema[]>(rest: [...T]): TPartialDeepRest<T> {
-  const [L, ...R] = rest
-  return (R.length > 0) ? [Type.Partial(L), ...PartialDeepRest(R)] : [] as any
-}
-/** Maps the given schema as deep partial, making all properties and sub properties optional */
-export function PartialDeep<T extends TSchema>(type: T): TPartialDeep<T> {
+export function PartialDeep<T extends TSchema>(schema: T): TPartialDeep<T> {
   return (
-    TypeGuard.IsIntersect(type) ? Type.Intersect(PartialDeepRest(type.allOf)) :
-    TypeGuard.IsUnion(type) ? Type.Union(PartialDeepRest(type.anyOf)) :
-    TypeGuard.IsObject(type) ? Type.Partial(Type.Object(PartialDeepProperties(type.properties))) :
-    type
-  ) as any
+    TypeGuard.IsIntersect(schema) ? Type.Intersect(PartialDeepRest(schema.allOf)) :
+    TypeGuard.IsUnion(schema) ? Type.Union(PartialDeepRest(schema.anyOf)) :
+    TypeGuard.IsObject(schema) ? Type.Partial(Type.Object(PartialDeepProperties(schema.properties))) :
+    schema
+  ) as never
 }
\ No newline at end of file

From 1ba927ca2265be3385adc8585fd46c8730caecca Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 26 Apr 2024 09:46:04 +0900
Subject: [PATCH 254/369] Revision 0.32.25 (#849)

* Type and Value Optimizations

* Version
---
 example/prototypes/mutual.ts                  |  48 ++
 package-lock.json                             |   4 +-
 package.json                                  |   2 +-
 readme.md                                     |   8 +-
 src/type/any/any.ts                           |   2 +-
 src/type/array/array.ts                       |   2 +-
 src/type/async-iterator/async-iterator.ts     |   2 +-
 src/type/awaited/awaited.ts                   |  12 +-
 src/type/bigint/bigint.ts                     |   2 +-
 src/type/boolean/boolean.ts                   |   2 +-
 src/type/clone/type.ts                        |   2 +-
 src/type/clone/value.ts                       |  11 +-
 src/type/composite/composite.ts               |  25 +-
 src/type/const/const.ts                       |  14 +-
 src/type/constructor/constructor.ts           |   2 +-
 src/type/date/date.ts                         |   2 +-
 src/type/deref/deref.ts                       |  16 +-
 src/type/enum/enum.ts                         |   2 +-
 .../exclude/exclude-from-mapped-result.ts     |  12 +-
 src/type/exclude/exclude.ts                   |   2 +-
 src/type/extends/extends-from-mapped-key.ts   |  10 +-
 .../extends/extends-from-mapped-result.ts     |  12 +-
 src/type/extends/extends.ts                   |   6 +-
 .../extract/extract-from-mapped-result.ts     |  12 +-
 src/type/extract/extract.ts                   |   2 +-
 src/type/function/function.ts                 |   2 +-
 src/type/guard/index.ts                       |   1 +
 src/type/guard/kind.ts                        | 285 ++++++++
 src/type/guard/type.ts                        |   2 +-
 src/type/helpers/helpers.ts                   |   2 +-
 src/type/indexed/indexed-from-mapped-key.ts   |  10 +-
 .../indexed/indexed-from-mapped-result.ts     |  14 +-
 src/type/indexed/indexed-property-keys.ts     |  14 +-
 src/type/indexed/indexed.ts                   |  20 +-
 src/type/integer/integer.ts                   |   2 +-
 src/type/intersect/intersect-create.ts        |   4 +-
 src/type/intersect/intersect-evaluated.ts     |  14 +-
 src/type/intersect/intersect.ts               |   2 +-
 .../intrinsic/intrinsic-from-mapped-key.ts    |  10 +-
 src/type/intrinsic/intrinsic.ts               |   6 +-
 src/type/iterator/iterator.ts                 |   2 +-
 src/type/keyof/keyof-from-mapped-result.ts    |  12 +-
 src/type/keyof/keyof-property-keys.ts         |  18 +-
 src/type/keyof/keyof.ts                       |   4 +-
 src/type/literal/literal.ts                   |   2 +-
 src/type/mapped/mapped-key.ts                 |   2 +-
 src/type/mapped/mapped.ts                     |  53 +-
 src/type/never/never.ts                       |   2 +-
 src/type/not/not.ts                           |   2 +-
 src/type/null/null.ts                         |   2 +-
 src/type/number/number.ts                     |   2 +-
 src/type/object/object.ts                     |  13 +-
 src/type/omit/omit-from-mapped-key.ts         |  10 +-
 src/type/omit/omit-from-mapped-result.ts      |  12 +-
 src/type/omit/omit.ts                         |  16 +-
 .../optional/optional-from-mapped-result.ts   |   8 +-
 src/type/optional/optional.ts                 |   2 +-
 .../partial/partial-from-mapped-result.ts     |  12 +-
 src/type/partial/partial.ts                   |  14 +-
 src/type/pick/pick-from-mapped-key.ts         |  10 +-
 src/type/pick/pick-from-mapped-result.ts      |  12 +-
 src/type/pick/pick.ts                         |  12 +-
 src/type/promise/promise.ts                   |   2 +-
 .../readonly-optional/readonly-optional.ts    |   2 +-
 .../readonly/readonly-from-mapped-result.ts   |  12 +-
 src/type/readonly/readonly.ts                 |   2 +-
 src/type/record/record.ts                     |  25 +-
 src/type/recursive/recursive.ts               |   2 +-
 .../required/required-from-mapped-result.ts   |  12 +-
 src/type/required/required.ts                 |  12 +-
 src/type/rest/rest.ts                         |  10 +-
 src/type/sets/set.ts                          |  16 +-
 src/type/string/string.ts                     |   2 +-
 src/type/symbol/symbol.ts                     |   2 +-
 src/type/template-literal/generate.ts         |   2 +-
 src/type/template-literal/pattern.ts          |  12 +-
 src/type/template-literal/template-literal.ts |   2 +-
 src/type/transform/transform.ts               |   6 +-
 src/type/tuple/tuple.ts                       |   2 +-
 src/type/uint8array/uint8array.ts             |   2 +-
 src/type/undefined/undefined.ts               |   2 +-
 src/type/union/union-create.ts                |   2 +-
 src/type/union/union-evaluated.ts             |  12 +-
 src/type/unknown/unknown.ts                   |   2 +-
 src/type/unsafe/unsafe.ts                     |   2 +-
 src/type/void/void.ts                         |   2 +-
 src/value/clean/clean.ts                      |   2 +-
 src/value/clone/clone.ts                      |  10 +-
 src/value/create/create.ts                    |  18 +-
 src/value/hash/hash.ts                        |   2 +-
 src/value/mutate/mutate.ts                    |   4 +-
 src/value/transform/decode.ts                 |  54 +-
 src/value/transform/encode.ts                 |  57 +-
 test/runtime/type/guard/index.ts              |  55 +-
 test/runtime/type/guard/kind/any.ts           |  14 +
 test/runtime/type/guard/kind/array.ts         |  14 +
 .../runtime/type/guard/kind/async-iterator.ts |  16 +
 test/runtime/type/guard/kind/awaited.ts       |  41 ++
 test/runtime/type/guard/kind/bigint.ts        |  14 +
 test/runtime/type/guard/kind/boolean.ts       |  14 +
 test/runtime/type/guard/kind/capitalize.ts    |  33 +
 test/runtime/type/guard/kind/composite.ts     | 165 +++++
 test/runtime/type/guard/kind/const.ts         | 124 ++++
 test/runtime/type/guard/kind/constructor.ts   |  14 +
 test/runtime/type/guard/kind/date.ts          |  14 +
 test/runtime/type/guard/kind/deref.ts         | 110 ++++
 test/runtime/type/guard/kind/enum.ts          | 143 ++++
 test/runtime/type/guard/kind/exclude.ts       |  96 +++
 test/runtime/type/guard/kind/extract.ts       | 102 +++
 test/runtime/type/guard/kind/function.ts      |  14 +
 test/runtime/type/guard/kind/index.ts         |  52 ++
 test/runtime/type/guard/kind/indexed.ts       | 327 ++++++++++
 test/runtime/type/guard/kind/integer.ts       |  14 +
 test/runtime/type/guard/kind/intersect.ts     |  39 ++
 test/runtime/type/guard/kind/iterator.ts      |  16 +
 test/runtime/type/guard/kind/keyof.ts         |  76 +++
 test/runtime/type/guard/kind/kind.ts          |  13 +
 test/runtime/type/guard/kind/literal.ts       |  18 +
 test/runtime/type/guard/kind/lowercase.ts     |  33 +
 test/runtime/type/guard/{ => kind}/mapped.ts  |   4 +-
 test/runtime/type/guard/kind/not.ts           |  10 +
 test/runtime/type/guard/kind/null.ts          |  14 +
 test/runtime/type/guard/kind/number.ts        |  14 +
 test/runtime/type/guard/kind/object.ts        |  19 +
 test/runtime/type/guard/kind/omit.ts          | 129 ++++
 test/runtime/type/guard/kind/partial.ts       |  67 ++
 test/runtime/type/guard/kind/pick.ts          | 131 ++++
 test/runtime/type/guard/kind/promise.ts       |  14 +
 test/runtime/type/guard/{ => kind}/record.ts  |   4 +-
 test/runtime/type/guard/kind/recursive.ts     |  16 +
 test/runtime/type/guard/kind/ref.ts           |  15 +
 test/runtime/type/guard/kind/regexp.ts        |  18 +
 test/runtime/type/guard/kind/required.ts      |  64 ++
 test/runtime/type/guard/kind/rest.ts          |  59 ++
 test/runtime/type/guard/kind/string.ts        |  14 +
 test/runtime/type/guard/kind/symbol.ts        |  14 +
 .../type/guard/kind/template-literal.ts       |  35 +
 test/runtime/type/guard/kind/this.ts          |  13 +
 test/runtime/type/guard/kind/tuple.ts         |  14 +
 test/runtime/type/guard/kind/uint8array.ts    |  14 +
 test/runtime/type/guard/kind/uncapitalize.ts  |  33 +
 test/runtime/type/guard/kind/undefined.ts     |  14 +
 test/runtime/type/guard/kind/union.ts         |  42 ++
 test/runtime/type/guard/kind/unknown.ts       |  14 +
 test/runtime/type/guard/kind/unsafe.ts        |  33 +
 test/runtime/type/guard/kind/uppercase.ts     |  33 +
 test/runtime/type/guard/kind/void.ts          |  14 +
 test/runtime/type/guard/{ => type}/any.ts     |   4 +-
 test/runtime/type/guard/{ => type}/array.ts   |   4 +-
 .../type/guard/{ => type}/async-iterator.ts   |   4 +-
 test/runtime/type/guard/{ => type}/awaited.ts |   4 +-
 test/runtime/type/guard/{ => type}/bigint.ts  |   4 +-
 test/runtime/type/guard/{ => type}/boolean.ts |   4 +-
 .../type/guard/{ => type}/capitalize.ts       |   4 +-
 .../type/guard/{ => type}/composite.ts        |   4 +-
 test/runtime/type/guard/{ => type}/const.ts   |   4 +-
 .../type/guard/{ => type}/constructor.ts      |   4 +-
 test/runtime/type/guard/{ => type}/date.ts    |   4 +-
 test/runtime/type/guard/{ => type}/deref.ts   |   4 +-
 test/runtime/type/guard/{ => type}/enum.ts    |   4 +-
 test/runtime/type/guard/{ => type}/exclude.ts |   4 +-
 test/runtime/type/guard/{ => type}/extract.ts |   4 +-
 .../runtime/type/guard/{ => type}/function.ts |   4 +-
 test/runtime/type/guard/type/index.ts         |  52 ++
 test/runtime/type/guard/{ => type}/indexed.ts |   4 +-
 test/runtime/type/guard/{ => type}/integer.ts |   4 +-
 .../type/guard/{ => type}/intersect.ts        |   4 +-
 .../runtime/type/guard/{ => type}/iterator.ts |   4 +-
 test/runtime/type/guard/{ => type}/keyof.ts   |   4 +-
 test/runtime/type/guard/{ => type}/kind.ts    |   4 +-
 test/runtime/type/guard/{ => type}/literal.ts |   4 +-
 .../type/guard/{ => type}/lowercase.ts        |   4 +-
 test/runtime/type/guard/type/mapped.ts        | 609 ++++++++++++++++++
 test/runtime/type/guard/{ => type}/not.ts     |   4 +-
 test/runtime/type/guard/{ => type}/null.ts    |   4 +-
 test/runtime/type/guard/{ => type}/number.ts  |   4 +-
 test/runtime/type/guard/{ => type}/object.ts  |   4 +-
 test/runtime/type/guard/{ => type}/omit.ts    |   4 +-
 test/runtime/type/guard/{ => type}/partial.ts |   4 +-
 test/runtime/type/guard/{ => type}/pick.ts    |   4 +-
 test/runtime/type/guard/{ => type}/promise.ts |   4 +-
 test/runtime/type/guard/type/record.ts        | 156 +++++
 .../type/guard/{ => type}/recursive.ts        |   4 +-
 test/runtime/type/guard/{ => type}/ref.ts     |   4 +-
 test/runtime/type/guard/{ => type}/regexp.ts  |   4 +-
 .../runtime/type/guard/{ => type}/required.ts |   4 +-
 test/runtime/type/guard/{ => type}/rest.ts    |   4 +-
 test/runtime/type/guard/{ => type}/string.ts  |   4 +-
 test/runtime/type/guard/{ => type}/symbol.ts  |   4 +-
 .../type/guard/{ => type}/template-literal.ts |   4 +-
 test/runtime/type/guard/{ => type}/this.ts    |   4 +-
 test/runtime/type/guard/{ => type}/tuple.ts   |   4 +-
 .../type/guard/{ => type}/uint8array.ts       |   4 +-
 .../type/guard/{ => type}/uncapitalize.ts     |   4 +-
 .../type/guard/{ => type}/undefined.ts        |   4 +-
 test/runtime/type/guard/{ => type}/union.ts   |   4 +-
 test/runtime/type/guard/{ => type}/unknown.ts |   4 +-
 test/runtime/type/guard/{ => type}/unsafe.ts  |   4 +-
 .../type/guard/{ => type}/uppercase.ts        |   4 +-
 test/runtime/type/guard/{ => type}/void.ts    |   4 +-
 test/runtime/type/{ => guard}/value/guard.ts  |   2 +-
 test/runtime/type/{ => guard}/value/index.ts  |   0
 test/runtime/type/index.ts                    |   1 -
 203 files changed, 4014 insertions(+), 560 deletions(-)
 create mode 100644 example/prototypes/mutual.ts
 create mode 100644 src/type/guard/kind.ts
 create mode 100644 test/runtime/type/guard/kind/any.ts
 create mode 100644 test/runtime/type/guard/kind/array.ts
 create mode 100644 test/runtime/type/guard/kind/async-iterator.ts
 create mode 100644 test/runtime/type/guard/kind/awaited.ts
 create mode 100644 test/runtime/type/guard/kind/bigint.ts
 create mode 100644 test/runtime/type/guard/kind/boolean.ts
 create mode 100644 test/runtime/type/guard/kind/capitalize.ts
 create mode 100644 test/runtime/type/guard/kind/composite.ts
 create mode 100644 test/runtime/type/guard/kind/const.ts
 create mode 100644 test/runtime/type/guard/kind/constructor.ts
 create mode 100644 test/runtime/type/guard/kind/date.ts
 create mode 100644 test/runtime/type/guard/kind/deref.ts
 create mode 100644 test/runtime/type/guard/kind/enum.ts
 create mode 100644 test/runtime/type/guard/kind/exclude.ts
 create mode 100644 test/runtime/type/guard/kind/extract.ts
 create mode 100644 test/runtime/type/guard/kind/function.ts
 create mode 100644 test/runtime/type/guard/kind/index.ts
 create mode 100644 test/runtime/type/guard/kind/indexed.ts
 create mode 100644 test/runtime/type/guard/kind/integer.ts
 create mode 100644 test/runtime/type/guard/kind/intersect.ts
 create mode 100644 test/runtime/type/guard/kind/iterator.ts
 create mode 100644 test/runtime/type/guard/kind/keyof.ts
 create mode 100644 test/runtime/type/guard/kind/kind.ts
 create mode 100644 test/runtime/type/guard/kind/literal.ts
 create mode 100644 test/runtime/type/guard/kind/lowercase.ts
 rename test/runtime/type/guard/{ => kind}/mapped.ts (99%)
 create mode 100644 test/runtime/type/guard/kind/not.ts
 create mode 100644 test/runtime/type/guard/kind/null.ts
 create mode 100644 test/runtime/type/guard/kind/number.ts
 create mode 100644 test/runtime/type/guard/kind/object.ts
 create mode 100644 test/runtime/type/guard/kind/omit.ts
 create mode 100644 test/runtime/type/guard/kind/partial.ts
 create mode 100644 test/runtime/type/guard/kind/pick.ts
 create mode 100644 test/runtime/type/guard/kind/promise.ts
 rename test/runtime/type/guard/{ => kind}/record.ts (98%)
 create mode 100644 test/runtime/type/guard/kind/recursive.ts
 create mode 100644 test/runtime/type/guard/kind/ref.ts
 create mode 100644 test/runtime/type/guard/kind/regexp.ts
 create mode 100644 test/runtime/type/guard/kind/required.ts
 create mode 100644 test/runtime/type/guard/kind/rest.ts
 create mode 100644 test/runtime/type/guard/kind/string.ts
 create mode 100644 test/runtime/type/guard/kind/symbol.ts
 create mode 100644 test/runtime/type/guard/kind/template-literal.ts
 create mode 100644 test/runtime/type/guard/kind/this.ts
 create mode 100644 test/runtime/type/guard/kind/tuple.ts
 create mode 100644 test/runtime/type/guard/kind/uint8array.ts
 create mode 100644 test/runtime/type/guard/kind/uncapitalize.ts
 create mode 100644 test/runtime/type/guard/kind/undefined.ts
 create mode 100644 test/runtime/type/guard/kind/union.ts
 create mode 100644 test/runtime/type/guard/kind/unknown.ts
 create mode 100644 test/runtime/type/guard/kind/unsafe.ts
 create mode 100644 test/runtime/type/guard/kind/uppercase.ts
 create mode 100644 test/runtime/type/guard/kind/void.ts
 rename test/runtime/type/guard/{ => type}/any.ts (84%)
 rename test/runtime/type/guard/{ => type}/array.ts (94%)
 rename test/runtime/type/guard/{ => type}/async-iterator.ts (86%)
 rename test/runtime/type/guard/{ => type}/awaited.ts (94%)
 rename test/runtime/type/guard/{ => type}/bigint.ts (84%)
 rename test/runtime/type/guard/{ => type}/boolean.ts (84%)
 rename test/runtime/type/guard/{ => type}/capitalize.ts (93%)
 rename test/runtime/type/guard/{ => type}/composite.ts (98%)
 rename test/runtime/type/guard/{ => type}/const.ts (98%)
 rename test/runtime/type/guard/{ => type}/constructor.ts (93%)
 rename test/runtime/type/guard/{ => type}/date.ts (94%)
 rename test/runtime/type/guard/{ => type}/deref.ts (97%)
 rename test/runtime/type/guard/{ => type}/enum.ts (97%)
 rename test/runtime/type/guard/{ => type}/exclude.ts (98%)
 rename test/runtime/type/guard/{ => type}/extract.ts (98%)
 rename test/runtime/type/guard/{ => type}/function.ts (93%)
 create mode 100644 test/runtime/type/guard/type/index.ts
 rename test/runtime/type/guard/{ => type}/indexed.ts (99%)
 rename test/runtime/type/guard/{ => type}/integer.ts (94%)
 rename test/runtime/type/guard/{ => type}/intersect.ts (90%)
 rename test/runtime/type/guard/{ => type}/iterator.ts (86%)
 rename test/runtime/type/guard/{ => type}/keyof.ts (95%)
 rename test/runtime/type/guard/{ => type}/kind.ts (75%)
 rename test/runtime/type/guard/{ => type}/literal.ts (91%)
 rename test/runtime/type/guard/{ => type}/lowercase.ts (93%)
 create mode 100644 test/runtime/type/guard/type/mapped.ts
 rename test/runtime/type/guard/{ => type}/not.ts (85%)
 rename test/runtime/type/guard/{ => type}/null.ts (84%)
 rename test/runtime/type/guard/{ => type}/number.ts (94%)
 rename test/runtime/type/guard/{ => type}/object.ts (96%)
 rename test/runtime/type/guard/{ => type}/omit.ts (97%)
 rename test/runtime/type/guard/{ => type}/partial.ts (96%)
 rename test/runtime/type/guard/{ => type}/pick.ts (97%)
 rename test/runtime/type/guard/{ => type}/promise.ts (92%)
 create mode 100644 test/runtime/type/guard/type/record.ts
 rename test/runtime/type/guard/{ => type}/recursive.ts (85%)
 rename test/runtime/type/guard/{ => type}/ref.ts (87%)
 rename test/runtime/type/guard/{ => type}/regexp.ts (92%)
 rename test/runtime/type/guard/{ => type}/required.ts (96%)
 rename test/runtime/type/guard/{ => type}/rest.ts (95%)
 rename test/runtime/type/guard/{ => type}/string.ts (92%)
 rename test/runtime/type/guard/{ => type}/symbol.ts (84%)
 rename test/runtime/type/guard/{ => type}/template-literal.ts (94%)
 rename test/runtime/type/guard/{ => type}/this.ts (86%)
 rename test/runtime/type/guard/{ => type}/tuple.ts (89%)
 rename test/runtime/type/guard/{ => type}/uint8array.ts (91%)
 rename test/runtime/type/guard/{ => type}/uncapitalize.ts (93%)
 rename test/runtime/type/guard/{ => type}/undefined.ts (85%)
 rename test/runtime/type/guard/{ => type}/union.ts (96%)
 rename test/runtime/type/guard/{ => type}/unknown.ts (84%)
 rename test/runtime/type/guard/{ => type}/unsafe.ts (91%)
 rename test/runtime/type/guard/{ => type}/uppercase.ts (93%)
 rename test/runtime/type/guard/{ => type}/void.ts (84%)
 rename test/runtime/type/{ => guard}/value/guard.ts (99%)
 rename test/runtime/type/{ => guard}/value/index.ts (100%)

diff --git a/example/prototypes/mutual.ts b/example/prototypes/mutual.ts
new file mode 100644
index 000000000..c47b7c798
--- /dev/null
+++ b/example/prototypes/mutual.ts
@@ -0,0 +1,48 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/prototypes
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Type, TSchema, Static } from '@sinclair/typebox'
+
+// Mutual Recursive Template
+const __A = <T extends TSchema>(reference: T) => Type.Object({
+  b: Type.Union([reference, Type.Null()])
+}, { additionalProperties: false })
+
+const __B = <T extends TSchema>(reference: T) => Type.Object({
+  a: Type.Union([reference, Type.Null()])
+}, { additionalProperties: false })
+
+// ....
+
+// Mutual Recursive Types
+const A = Type.Recursive((This) => __A(__B(This)))
+const B = Type.Recursive((This) => __B(__A(This)))
+
+type A = Static<typeof A>;
+type B = Static<typeof B>;
+
diff --git a/package-lock.json b/package-lock.json
index c98535528..f8c489aee 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.24",
+  "version": "0.32.25",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.24",
+      "version": "0.32.25",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 5015e3835..300281f8f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.24",
+  "version": "0.32.25",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index b6fad4d6a..86aac5555 100644
--- a/readme.md
+++ b/readme.md
@@ -1804,11 +1804,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '120.6 kb' │ ' 52.9 kb' │  '2.28 x'   │
-│ typebox/errors       │ ' 55.7 kb' │ ' 25.5 kb' │  '2.19 x'   │
+│ typebox/compiler     │ '126.9 kb' │ ' 55.7 kb' │  '2.28 x'   │
+│ typebox/errors       │ ' 46.1 kb' │ ' 20.8 kb' │  '2.22 x'   │
 │ typebox/system       │ '  4.7 kb' │ '  2.0 kb' │  '2.33 x'   │
-│ typebox/value        │ '146.2 kb' │ ' 62.0 kb' │  '2.36 x'   │
-│ typebox              │ ' 91.4 kb' │ ' 37.8 kb' │  '2.42 x'   │
+│ typebox/value        │ '152.2 kb' │ ' 64.5 kb' │  '2.36 x'   │
+│ typebox              │ ' 95.7 kb' │ ' 39.8 kb' │  '2.40 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/type/any/any.ts b/src/type/any/any.ts
index 6916cef60..90eaf93ec 100644
--- a/src/type/any/any.ts
+++ b/src/type/any/any.ts
@@ -36,5 +36,5 @@ export interface TAny extends TSchema {
 
 /** `[Json]` Creates an Any type */
 export function Any(options: SchemaOptions = {}): TAny {
-  return { ...options, [Kind]: 'Any' } as unknown as TAny
+  return { ...options, [Kind]: 'Any' } as never
 }
diff --git a/src/type/array/array.ts b/src/type/array/array.ts
index 912a5ed37..fecf073db 100644
--- a/src/type/array/array.ts
+++ b/src/type/array/array.ts
@@ -60,5 +60,5 @@ export function Array<T extends TSchema>(schema: T, options: ArrayOptions = {}):
     [Kind]: 'Array',
     type: 'array',
     items: CloneType(schema),
-  } as unknown as TArray<T>
+  } as never
 }
diff --git a/src/type/async-iterator/async-iterator.ts b/src/type/async-iterator/async-iterator.ts
index 5861f9625..ee9417421 100644
--- a/src/type/async-iterator/async-iterator.ts
+++ b/src/type/async-iterator/async-iterator.ts
@@ -44,5 +44,5 @@ export function AsyncIterator<T extends TSchema>(items: T, options: SchemaOption
     [Kind]: 'AsyncIterator',
     type: 'AsyncIterator',
     items: CloneType(items),
-  } as unknown as TAsyncIterator<T>
+  } as never
 }
diff --git a/src/type/awaited/awaited.ts b/src/type/awaited/awaited.ts
index 5c3fbb5a2..5318d98ea 100644
--- a/src/type/awaited/awaited.ts
+++ b/src/type/awaited/awaited.ts
@@ -35,7 +35,7 @@ import { CloneType } from '../clone/type'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsIntersect, IsUnion, IsPromise } from '../guard/type'
+import { IsIntersect, IsUnion, IsPromise } from '../guard/kind'
 // ------------------------------------------------------------------
 // FromRest
 // ------------------------------------------------------------------
@@ -46,7 +46,7 @@ type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> =
     : Acc
 // prettier-ignore
 function FromRest<T extends TSchema[]>(T: [...T]) : TFromRest<T> {
-  return T.map(L => AwaitedResolve(L)) as TFromRest<T>
+  return T.map(L => AwaitedResolve(L)) as never
 }
 // ----------------------------------------------------------------
 // FromIntersect
@@ -55,7 +55,7 @@ function FromRest<T extends TSchema[]>(T: [...T]) : TFromRest<T> {
 type TFromIntersect<T extends TSchema[]> = TIntersect<TFromRest<T>>
 // prettier-ignore
 function FromIntersect<T extends TSchema[]>(T: [...T]): TFromIntersect<T> {
-  return Intersect(FromRest(T) as TSchema[]) as unknown as TFromIntersect<T>
+  return Intersect(FromRest(T) as TSchema[]) as never
 }
 // ----------------------------------------------------------------
 // FromUnion
@@ -64,7 +64,7 @@ function FromIntersect<T extends TSchema[]>(T: [...T]): TFromIntersect<T> {
 type TFromUnion<T extends TSchema[]> = TUnion<TFromRest<T>>
 // prettier-ignore
 function FromUnion<T extends TSchema[]>(T: [...T]): TFromUnion<T> {
-  return Union(FromRest(T) as TSchema[]) as unknown as TFromUnion<T>
+  return Union(FromRest(T) as TSchema[]) as never
 }
 // ----------------------------------------------------------------
 // Promise
@@ -72,7 +72,7 @@ function FromUnion<T extends TSchema[]>(T: [...T]): TFromUnion<T> {
 type TFromPromise<T extends TSchema> = TAwaited<T>
 // prettier-ignore
 function FromPromise<T extends TSchema>(T: T): TFromPromise<T> {
-  return AwaitedResolve(T) as TFromPromise<T>
+  return AwaitedResolve(T) as never
 }
 // ----------------------------------------------------------------
 // AwaitedResolve
@@ -84,7 +84,7 @@ function AwaitedResolve<T extends TSchema>(T: T): TAwaited<T> {
     IsUnion(T) ? FromUnion(T.anyOf) :
     IsPromise(T) ? FromPromise(T.item) :
     T
-  ) as TAwaited<T>
+  ) as never
 }
 // ------------------------------------------------------------------
 // TAwaited
diff --git a/src/type/bigint/bigint.ts b/src/type/bigint/bigint.ts
index eb0ca248e..b653a09a2 100644
--- a/src/type/bigint/bigint.ts
+++ b/src/type/bigint/bigint.ts
@@ -47,5 +47,5 @@ export function BigInt(options: BigIntOptions = {}): TBigInt {
     ...options,
     [Kind]: 'BigInt',
     type: 'bigint',
-  } as TBigInt
+  } as never
 }
diff --git a/src/type/boolean/boolean.ts b/src/type/boolean/boolean.ts
index 68a2c26a5..7729a0052 100644
--- a/src/type/boolean/boolean.ts
+++ b/src/type/boolean/boolean.ts
@@ -40,5 +40,5 @@ export function Boolean(options: SchemaOptions = {}): TBoolean {
     ...options,
     [Kind]: 'Boolean',
     type: 'boolean',
-  } as unknown as TBoolean
+  } as never
 }
diff --git a/src/type/clone/type.ts b/src/type/clone/type.ts
index f6c3dd54e..89b17b2ee 100644
--- a/src/type/clone/type.ts
+++ b/src/type/clone/type.ts
@@ -31,7 +31,7 @@ import { Clone } from './value'
 
 /** Clones a Rest */
 export function CloneRest<T extends TSchema[]>(schemas: T): T {
-  return schemas.map((schema) => CloneType(schema)) as T
+  return schemas.map((schema) => CloneType(schema)) as never
 }
 /** Clones a Type */
 export function CloneType<T extends TSchema>(schema: T, options: SchemaOptions = {}): T {
diff --git a/src/type/clone/value.ts b/src/type/clone/value.ts
index 548cef442..0a062cb38 100644
--- a/src/type/clone/value.ts
+++ b/src/type/clone/value.ts
@@ -41,9 +41,14 @@ function RegExpType(value: RegExp) {
   return new RegExp(value.source, value.flags)
 }
 function ObjectType(value: Record<keyof any, unknown>) {
-  const clonedProperties = Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {})
-  const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key as any]) }), {})
-  return { ...clonedProperties, ...clonedSymbols }
+  const result = {} as Record<PropertyKey, unknown>
+  for (const key of Object.getOwnPropertyNames(value)) {
+    result[key] = Visit(value[key])
+  }
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    result[key] = Visit(value[key])
+  }
+  return result
 }
 // prettier-ignore
 function Visit(value: unknown): any {
diff --git a/src/type/composite/composite.ts b/src/type/composite/composite.ts
index 8254036ee..c3a6f8084 100644
--- a/src/type/composite/composite.ts
+++ b/src/type/composite/composite.ts
@@ -38,7 +38,7 @@ import { SetDistinct, TSetDistinct } from '../sets/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsNever } from '../guard/type'
+import { IsNever } from '../guard/kind'
 // ------------------------------------------------------------------
 // CompositeKeys
 // ------------------------------------------------------------------
@@ -50,9 +50,9 @@ type TCompositeKeys<T extends TSchema[], Acc extends PropertyKey[] = []> = (
 )
 // prettier-ignore
 function CompositeKeys<T extends TSchema[]>(T: [...T]): TCompositeKeys<T> {
-  return SetDistinct(T.reduce((Acc, L) => {
-    return ([...Acc, ...KeyOfPropertyKeys(L)]) as never
-  }, [])) as never
+  const Acc = [] as PropertyKey[]
+  for(const L of T) Acc.push(...KeyOfPropertyKeys(L))
+  return SetDistinct(Acc) as never
 }
 // ------------------------------------------------------------------
 // FilterNever
@@ -80,9 +80,9 @@ type TCompositeProperty<T extends TSchema[], K extends PropertyKey, Acc extends
 )
 // prettier-ignore
 function CompositeProperty<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TCompositeProperty<T, K> {
-  return FilterNever(T.reduce((Acc, L) => {
-    return [...Acc, ...IndexFromPropertyKeys(L, [K])] as never
-  }, [])) as never
+  const Acc = [] as TSchema[]
+  for(const L of T) Acc.push(...IndexFromPropertyKeys(L, [K]))
+  return FilterNever(Acc) as never
 }
 // ------------------------------------------------------------------
 // CompositeProperties
@@ -95,9 +95,11 @@ type TCompositeProperties<T extends TSchema[], K extends PropertyKey[], Acc = {}
 )
 // prettier-ignore
 function CompositeProperties<T extends TSchema[], K extends PropertyKey[] = []>(T: [...T], K: [...K]): TCompositeProperties<T, K> {
-  return K.reduce((Acc, L) => {
-   return { ...Acc, [L]: IntersectEvaluated(CompositeProperty(T, L)) }
-  }, {}) as never
+  const Acc = {} as never
+  for(const L of K) {
+    Acc[L] = IntersectEvaluated(CompositeProperty(T, L))
+  }
+  return Acc
 }
 // ------------------------------------------------------------------
 // Composite
@@ -111,11 +113,10 @@ type TCompositeEvaluate<
 > = R
 // prettier-ignore
 export type TComposite<T extends TSchema[]> = TCompositeEvaluate<T>
-
 // prettier-ignore
 export function Composite<T extends TSchema[]>(T: [...T], options: ObjectOptions = {}): TComposite<T> {
   const K = CompositeKeys(T)
   const P = CompositeProperties(T, K)
   const R = Object(P, options)
-  return R as TComposite<T>
+  return R as never
 }
diff --git a/src/type/const/const.ts b/src/type/const/const.ts
index 3eecebc0b..1606b9930 100644
--- a/src/type/const/const.ts
+++ b/src/type/const/const.ts
@@ -60,7 +60,7 @@ type TFromArray<T extends readonly unknown[]> =
     : T
 // prettier-ignore
 function FromArray<T extends readonly unknown[]>(T: [...T]): TFromArray<T> {
-  return T.map(L => FromValue(L, false)) as TFromArray<T>
+  return T.map(L => FromValue(L, false)) as never
 }
 // ------------------------------------------------------------------
 // FromProperties
@@ -73,16 +73,16 @@ type TFromProperties<T extends Record<PropertyKey, unknown>> = {
 }
 // prettier-ignore
 function FromProperties<T extends Record<PropertyKey, unknown>>(value: T): TFromProperties<T> {
-  return globalThis.Object.getOwnPropertyNames(value).reduce((acc, key) => {
-    return { ...acc, [key]: Readonly(FromValue(value[key], false)) }
-  }, {} as TProperties) as unknown as TFromProperties<T>
+  const Acc = {} as TProperties
+  for(const K of globalThis.Object.getOwnPropertyNames(value)) Acc[K] = Readonly(FromValue(value[K], false))
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // ConditionalReadonly - Only applied if not root
 // ------------------------------------------------------------------
 type TConditionalReadonly<T extends TSchema, Root extends boolean> = Root extends true ? T : TReadonly<T>
 function ConditionalReadonly<T extends TSchema, Root extends boolean>(T: T, root: Root): TConditionalReadonly<T, Root> {
-  return (root === true ? T : Readonly(T)) as unknown as TConditionalReadonly<T, Root>
+  return (root === true ? T : Readonly(T)) as never
 }
 // ------------------------------------------------------------------
 // FromValue
@@ -122,7 +122,7 @@ function FromValue<T, Root extends boolean>(value: T, root: Root): FromValue<T,
     IsBoolean(value) ? Literal(value) :
     IsString(value) ? Literal(value) :
     Object({})
-  ) as FromValue<T, Root>
+  ) as never
 }
 // ------------------------------------------------------------------
 // TConst
@@ -131,5 +131,5 @@ export type TConst<T> = FromValue<T, true>
 
 /** `[JavaScript]` Creates a readonly const type from the given value. */
 export function Const</* const (not supported in 4.0) */ T>(T: T, options: SchemaOptions = {}): TConst<T> {
-  return CloneType(FromValue(T, true), options) as TConst<T>
+  return CloneType(FromValue(T, true), options) as never
 }
diff --git a/src/type/constructor/constructor.ts b/src/type/constructor/constructor.ts
index c68ffe992..65f440c32 100644
--- a/src/type/constructor/constructor.ts
+++ b/src/type/constructor/constructor.ts
@@ -72,5 +72,5 @@ export function Constructor<T extends TSchema[], U extends TSchema>(parameters:
     type: 'Constructor',
     parameters: CloneRest(parameters),
     returns: CloneType(returns),
-  } as unknown as TConstructor<T, U>
+  } as never
 }
diff --git a/src/type/date/date.ts b/src/type/date/date.ts
index 3a7534217..192cea310 100644
--- a/src/type/date/date.ts
+++ b/src/type/date/date.ts
@@ -52,5 +52,5 @@ export function Date(options: DateOptions = {}): TDate {
     ...options,
     [Kind]: 'Date',
     type: 'Date',
-  } as unknown as TDate
+  } as never
 }
diff --git a/src/type/deref/deref.ts b/src/type/deref/deref.ts
index 117de7564..76d626a29 100644
--- a/src/type/deref/deref.ts
+++ b/src/type/deref/deref.ts
@@ -46,7 +46,7 @@ import { IsUndefined } from '../guard/value'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsConstructor, IsFunction, IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsPromise, IsAsyncIterator, IsIterator, IsRef } from '../guard/type'
+import { IsConstructor, IsFunction, IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsPromise, IsAsyncIterator, IsIterator, IsRef } from '../guard/kind'
 // ------------------------------------------------------------------
 // FromRest
 // ------------------------------------------------------------------
@@ -56,8 +56,8 @@ export type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (
    ? TFromRest<R, [...Acc, TDeref<L>]>
    : Acc
 )
-function FromRest(schema: TSchema[], references: TSchema[]) {
-  return schema.map((schema) => Deref(schema, references))
+function FromRest<T extends TSchema[]>(schema: [...T], references: TSchema[]): TFromRest<T> {
+  return schema.map((schema) => Deref(schema, references)) as never
 }
 // ------------------------------------------------------------------
 // FromProperties
@@ -68,9 +68,11 @@ type FromProperties<T extends TProperties> = Evaluate<{
 }>
 // prettier-ignore
 function FromProperties(properties: TProperties, references: TSchema[]) {
-  return globalThis.Object.getOwnPropertyNames(properties).reduce((acc, key) => {
-    return {...acc, [key]: Deref(properties[key], references) }
-  }, {} as TProperties)
+  const Acc = {} as TProperties
+  for(const K of globalThis.Object.getOwnPropertyNames(properties)) {
+    Acc[K] = Deref(properties[K], references)
+  }
+  return Acc as never
 }
 // prettier-ignore
 function FromConstructor(schema: TConstructor, references: TSchema[]) {
@@ -147,7 +149,7 @@ function DerefResolve<T extends TSchema>(schema: T, references: TSchema[]): TDer
     IsIterator(schema) ? FromIterator(schema, references) :
     IsRef(schema) ? FromRef(schema, references) :
     schema
-  ) as TDeref<T> 
+  ) as never
 }
 // prettier-ignore
 export type TDeref<T extends TSchema> =
diff --git a/src/type/enum/enum.ts b/src/type/enum/enum.ts
index 2406cc027..08a87b495 100644
--- a/src/type/enum/enum.ts
+++ b/src/type/enum/enum.ts
@@ -54,5 +54,5 @@ export function Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item:
     .map((key) => item[key]) as T[keyof T][]
   const values2 = [...new Set(values1)]
   const anyOf = values2.map((value) => Literal(value))
-  return Union(anyOf, { ...options, [Hint]: 'Enum' }) as unknown as TEnum<T>
+  return Union(anyOf, { ...options, [Hint]: 'Enum' }) as never
 }
diff --git a/src/type/exclude/exclude-from-mapped-result.ts b/src/type/exclude/exclude-from-mapped-result.ts
index 3fe927fde..8985e467e 100644
--- a/src/type/exclude/exclude-from-mapped-result.ts
+++ b/src/type/exclude/exclude-from-mapped-result.ts
@@ -46,9 +46,9 @@ function FromProperties<
   P extends TProperties,
   T extends TSchema
 >(P: P, U: T): TFromProperties<P, T> {
-  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-    return {...Acc, [K2]: Exclude(P[K2], U) }
-  }, {}) as TFromProperties<P, T>
+  const Acc = {} as TProperties
+  for(const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Exclude(P[K2], U)
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult
@@ -65,7 +65,7 @@ function FromMappedResult<
   R extends TMappedResult,
   T extends TSchema
 >(R: R, T: T): TFromMappedResult<R, T> {
-  return FromProperties(R.properties, T) as TFromMappedResult<R, T>
+  return FromProperties(R.properties, T) as never
 }
 // ------------------------------------------------------------------
 // ExcludeFromMappedResult
@@ -84,6 +84,6 @@ export function ExcludeFromMappedResult<
   T extends TSchema,
   P extends TProperties = TFromMappedResult<R, T>
 >(R: R, T: T): TMappedResult<P> {
-  const P = FromMappedResult(R, T) as unknown as P
-  return MappedResult(P) 
+  const P = FromMappedResult(R, T)
+  return MappedResult(P) as never
 }
diff --git a/src/type/exclude/exclude.ts b/src/type/exclude/exclude.ts
index 021caf156..3140a5e10 100644
--- a/src/type/exclude/exclude.ts
+++ b/src/type/exclude/exclude.ts
@@ -42,7 +42,7 @@ import { ExcludeFromTemplateLiteral, type TExcludeFromTemplateLiteral } from './
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/type'
+import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/kind'
 // ------------------------------------------------------------------
 // ExcludeRest
 // ------------------------------------------------------------------
diff --git a/src/type/extends/extends-from-mapped-key.ts b/src/type/extends/extends-from-mapped-key.ts
index 7e3620ff2..ce43b6b60 100644
--- a/src/type/extends/extends-from-mapped-key.ts
+++ b/src/type/extends/extends-from-mapped-key.ts
@@ -54,7 +54,7 @@ function FromPropertyKey<
 >(K: K, U: U, L: L, R: R, options: SchemaOptions): TFromPropertyKey<K, U, L, R> {
   return {
     [K]: Extends(Literal(K as TLiteralValue), U, L, R, options) as any
-  } as TFromPropertyKey<K, U, L, R>
+  } as never
 }
 // ------------------------------------------------------------------
 // FromPropertyKeys
@@ -80,7 +80,7 @@ function FromPropertyKeys<
 >(K: [...K], U: U, L: L, R: R, options: SchemaOptions): TFromPropertyKeys<K, U, L, R> {
   return K.reduce((Acc, LK) => {
     return { ...Acc, ...FromPropertyKey(LK, U, L, R, options) }
-  }, {} as TProperties) as TFromPropertyKeys<K, U, L, R> 
+  }, {} as TProperties) as never
 }
 // ------------------------------------------------------------------
 // FromMappedKey
@@ -101,7 +101,7 @@ function FromMappedKey<
   L extends TSchema,
   R extends TSchema
 >(K: K, U: U, L: L, R: R, options: SchemaOptions): TFromMappedKey<K, U, L, R> {
-  return FromPropertyKeys(K.keys, U, L, R, options) as TFromMappedKey<K, U, L, R>
+  return FromPropertyKeys(K.keys, U, L, R, options) as never
 }
 // ------------------------------------------------------------------
 // ExtendsFromMappedKey
@@ -124,6 +124,6 @@ export function ExtendsFromMappedKey<
   R extends TSchema,
   P extends TProperties = TFromMappedKey<T, U, L, R>
 >(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedKey(T, U, L, R, options) as unknown as P
-  return MappedResult(P) 
+  const P = FromMappedKey(T, U, L, R, options)
+  return MappedResult(P) as never
 }
diff --git a/src/type/extends/extends-from-mapped-result.ts b/src/type/extends/extends-from-mapped-result.ts
index c202aa356..2c857cf9d 100644
--- a/src/type/extends/extends-from-mapped-result.ts
+++ b/src/type/extends/extends-from-mapped-result.ts
@@ -50,9 +50,9 @@ function FromProperties<
   True extends TSchema,
   False extends TSchema
 >(P: P, Right: Right, True: True, False: False, options: SchemaOptions): TFromProperties<P, Right, True, False> {
-  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-    return {...Acc, [K2]: Extends(P[K2], Right, True, False, options) }
-  }, {}) as TFromProperties<P, Right, True, False>
+  const Acc = {} as TProperties
+  for(const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Extends(P[K2], Right, True, False, options)
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult
@@ -73,7 +73,7 @@ function FromMappedResult<
   True extends TSchema,
   False extends TSchema
 >(Left: Left, Right: Right, True: True, False: False, options: SchemaOptions): TFromMappedResult<Left, Right, True, False> {
-  return FromProperties(Left.properties, Right, True, False, options) as TFromMappedResult<Left, Right, True, False>
+  return FromProperties(Left.properties, Right, True, False, options) as never
 }
 // ------------------------------------------------------------------
 // ExtendsFromMappedResult
@@ -96,6 +96,6 @@ export function ExtendsFromMappedResult<
   False extends TSchema,
   P extends TProperties = TFromMappedResult<Left, Right, True, False>
 >(Left: Left, Right: Right, True: True, False: False, options: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedResult(Left, Right, True, False, options) as unknown as P
-  return MappedResult(P) 
+  const P = FromMappedResult(Left, Right, True, False, options)
+  return MappedResult(P) as never
 }
diff --git a/src/type/extends/extends.ts b/src/type/extends/extends.ts
index 53049c4d5..614722a4f 100644
--- a/src/type/extends/extends.ts
+++ b/src/type/extends/extends.ts
@@ -39,7 +39,7 @@ import { ExtendsFromMappedResult, type TExtendsFromMappedResult } from './extend
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedKey, IsMappedResult } from '../guard/type'
+import { IsMappedKey, IsMappedResult } from '../guard/kind'
 
 // prettier-ignore
 type TExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = (
@@ -56,7 +56,7 @@ function ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema,
     R === ExtendsResult.Union ? Union([trueType, falseType]) : 
     R === ExtendsResult.True ? trueType : 
     falseType
-  ) as unknown as TExtendsResolve<L, R, T, U>
+  ) as never
 }
 // ------------------------------------------------------------------
 // TExtends
@@ -76,5 +76,5 @@ export function Extends<L extends TSchema, R extends TSchema, T extends TSchema,
     IsMappedResult(L) ? ExtendsFromMappedResult(L, R, T, F, options) :
     IsMappedKey(L) ? CloneType(ExtendsFromMappedKey(L, R, T, F, options)) :
     CloneType(ExtendsResolve(L, R, T, F), options)
-  ) as TExtends<L, R, T, F>
+  ) as never
 }
diff --git a/src/type/extract/extract-from-mapped-result.ts b/src/type/extract/extract-from-mapped-result.ts
index 65d244162..b49720a37 100644
--- a/src/type/extract/extract-from-mapped-result.ts
+++ b/src/type/extract/extract-from-mapped-result.ts
@@ -46,9 +46,9 @@ function FromProperties<
   P extends TProperties,
   T extends TSchema
 >(P: P, T: T): TFromProperties<P, T> {
-  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-    return {...Acc, [K2]: Extract(P[K2], T) }
-  }, {}) as TFromProperties<P, T>
+  const Acc = {} as TProperties
+  for(const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Extract(P[K2], T)
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult
@@ -65,7 +65,7 @@ function FromMappedResult<
   R extends TMappedResult,
   T extends TSchema
 >(R: R, T: T): TFromMappedResult<R, T> {
-  return FromProperties(R.properties, T) as TFromMappedResult<R, T>
+  return FromProperties(R.properties, T) as never
 }
 // ------------------------------------------------------------------
 // ExtractFromMappedResult
@@ -84,6 +84,6 @@ export function ExtractFromMappedResult<
   T extends TSchema,
   P extends TProperties = TFromMappedResult<R, T>
 >(R: R, T: T): TMappedResult<P> {
-  const P = FromMappedResult(R, T) as unknown as P
-  return MappedResult(P) 
+  const P = FromMappedResult(R, T)
+  return MappedResult(P) as never
 }
diff --git a/src/type/extract/extract.ts b/src/type/extract/extract.ts
index 40d7e2d3d..91c8ca5e2 100644
--- a/src/type/extract/extract.ts
+++ b/src/type/extract/extract.ts
@@ -42,7 +42,7 @@ import { ExtractFromTemplateLiteral, type TExtractFromTemplateLiteral } from './
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/type'
+import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/kind'
 
 // ------------------------------------------------------------------
 // ExtractRest
diff --git a/src/type/function/function.ts b/src/type/function/function.ts
index d86297985..f4333585c 100644
--- a/src/type/function/function.ts
+++ b/src/type/function/function.ts
@@ -73,5 +73,5 @@ export function Function<T extends TSchema[], U extends TSchema>(parameters: [..
     type: 'Function',
     parameters: CloneRest(parameters),
     returns: CloneType(returns),
-  } as unknown as TFunction<T, U>
+  } as never
 }
diff --git a/src/type/guard/index.ts b/src/type/guard/index.ts
index a8f31501a..feeaa6296 100644
--- a/src/type/guard/index.ts
+++ b/src/type/guard/index.ts
@@ -26,5 +26,6 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+export * as KindGuard from './kind'
 export * as TypeGuard from './type'
 export * as ValueGuard from './value'
diff --git a/src/type/guard/kind.ts b/src/type/guard/kind.ts
new file mode 100644
index 000000000..b68f01bca
--- /dev/null
+++ b/src/type/guard/kind.ts
@@ -0,0 +1,285 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as ValueGuard from './value'
+import { Kind, Hint, TransformKind, ReadonlyKind, OptionalKind } from '../symbols/index'
+import { TransformOptions } from '../transform/index'
+import { TTemplateLiteral } from '../template-literal/index'
+import { TArray } from '../array/index'
+import { TBoolean } from '../boolean/index'
+import type { TRecord } from '../record/index'
+import type { TString } from '../string/index'
+import type { TUnion } from '../union/index'
+import type { TAny } from '../any/index'
+import type { TAsyncIterator } from '../async-iterator/index'
+import type { TBigInt } from '../bigint/index'
+import type { TConstructor } from '../constructor/index'
+import type { TFunction } from '../function/index'
+import type { TInteger } from '../integer/index'
+import type { TIntersect } from '../intersect/index'
+import type { TIterator } from '../iterator/index'
+import type { TLiteral } from '../literal/index'
+import type { TMappedKey, TMappedResult } from '../mapped/index'
+import type { TNever } from '../never/index'
+import type { TNot } from '../not/index'
+import type { TNull } from '../null/index'
+import type { TNumber } from '../number/index'
+import type { TObject, TProperties } from '../object/index'
+import type { TOptional } from '../optional/index'
+import type { TPromise } from '../promise/index'
+import type { TReadonly } from '../readonly/index'
+import type { TRef } from '../ref/index'
+import type { TRegExp } from '../regexp/index'
+import type { TSchema } from '../schema/index'
+import type { TSymbol } from '../symbol/index'
+import type { TTuple } from '../tuple/index'
+import type { TUint8Array } from '../uint8array/index'
+import type { TUndefined } from '../undefined/index'
+import type { TUnknown } from '../unknown/index'
+import type { TUnsafe } from '../unsafe/index'
+import type { TVoid } from '../void/index'
+import type { TDate } from '../date/index'
+import type { TThis } from '../recursive/index'
+
+/** `[Kind-Only]` Returns true if this value has a Readonly symbol */
+export function IsReadonly<T extends TSchema>(value: T): value is TReadonly<T> {
+  return ValueGuard.IsObject(value) && value[ReadonlyKind] === 'Readonly'
+}
+/** `[Kind-Only]` Returns true if this value has a Optional symbol */
+export function IsOptional<T extends TSchema>(value: T): value is TOptional<T> {
+  return ValueGuard.IsObject(value) && value[OptionalKind] === 'Optional'
+}
+/** `[Kind-Only]` Returns true if the given value is TAny */
+export function IsAny(value: unknown): value is TAny {
+  return IsKindOf(value, 'Any')
+}
+/** `[Kind-Only]` Returns true if the given value is TArray */
+export function IsArray(value: unknown): value is TArray {
+  return IsKindOf(value, 'Array')
+}
+/** `[Kind-Only]` Returns true if the given value is TAsyncIterator */
+export function IsAsyncIterator(value: unknown): value is TAsyncIterator {
+  return IsKindOf(value, 'AsyncIterator')
+}
+/** `[Kind-Only]` Returns true if the given value is TBigInt */
+export function IsBigInt(value: unknown): value is TBigInt {
+  return IsKindOf(value, 'BigInt')
+}
+/** `[Kind-Only]` Returns true if the given value is TBoolean */
+export function IsBoolean(value: unknown): value is TBoolean {
+  return IsKindOf(value, 'Boolean')
+}
+/** `[Kind-Only]` Returns true if the given value is TConstructor */
+export function IsConstructor(value: unknown): value is TConstructor {
+  return IsKindOf(value, 'Constructor')
+}
+/** `[Kind-Only]` Returns true if the given value is TDate */
+export function IsDate(value: unknown): value is TDate {
+  return IsKindOf(value, 'Date')
+}
+/** `[Kind-Only]` Returns true if the given value is TFunction */
+export function IsFunction(value: unknown): value is TFunction {
+  return IsKindOf(value, 'Function')
+}
+/** `[Kind-Only]` Returns true if the given value is TInteger */
+export function IsInteger(value: unknown): value is TInteger {
+  return IsKindOf(value, 'Integer')
+}
+/** `[Kind-Only]` Returns true if the given schema is TProperties */
+export function IsProperties(value: unknown): value is TProperties {
+  return ValueGuard.IsObject(value)
+}
+/** `[Kind-Only]` Returns true if the given value is TIntersect */
+export function IsIntersect(value: unknown): value is TIntersect {
+  return IsKindOf(value, 'Intersect')
+}
+/** `[Kind-Only]` Returns true if the given value is TIterator */
+export function IsIterator(value: unknown): value is TIterator {
+  return IsKindOf(value, 'Iterator')
+}
+/** `[Kind-Only]` Returns true if the given value is a TKind with the given name. */
+export function IsKindOf<T extends string>(value: unknown, kind: T): value is Record<PropertyKey, unknown> & { [Kind]: T } {
+  return ValueGuard.IsObject(value) && Kind in value && value[Kind] === kind
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteral<string> */
+export function IsLiteralString(value: unknown): value is TLiteral<string> {
+  return IsLiteral(value) && ValueGuard.IsString(value.const)
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteral<number> */
+export function IsLiteralNumber(value: unknown): value is TLiteral<number> {
+  return IsLiteral(value) && ValueGuard.IsNumber(value.const)
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteral<boolean> */
+export function IsLiteralBoolean(value: unknown): value is TLiteral<boolean> {
+  return IsLiteral(value) && ValueGuard.IsBoolean(value.const)
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteral */
+export function IsLiteral(value: unknown): value is TLiteral {
+  return IsKindOf(value, 'Literal')
+}
+/** `[Kind-Only]` Returns true if the given value is a TMappedKey */
+export function IsMappedKey(value: unknown): value is TMappedKey {
+  return IsKindOf(value, 'MappedKey')
+}
+/** `[Kind-Only]` Returns true if the given value is TMappedResult */
+export function IsMappedResult(value: unknown): value is TMappedResult {
+  return IsKindOf(value, 'MappedResult')
+}
+/** `[Kind-Only]` Returns true if the given value is TNever */
+export function IsNever(value: unknown): value is TNever {
+  return IsKindOf(value, 'Never')
+}
+/** `[Kind-Only]` Returns true if the given value is TNot */
+export function IsNot(value: unknown): value is TNot {
+  return IsKindOf(value, 'Not')
+}
+/** `[Kind-Only]` Returns true if the given value is TNull */
+export function IsNull(value: unknown): value is TNull {
+  return IsKindOf(value, 'Null')
+}
+/** `[Kind-Only]` Returns true if the given value is TNumber */
+export function IsNumber(value: unknown): value is TNumber {
+  return IsKindOf(value, 'Number')
+}
+/** `[Kind-Only]` Returns true if the given value is TObject */
+export function IsObject(value: unknown): value is TObject {
+  return IsKindOf(value, 'Object')
+}
+/** `[Kind-Only]` Returns true if the given value is TPromise */
+export function IsPromise(value: unknown): value is TPromise {
+  return IsKindOf(value, 'Promise')
+}
+/** `[Kind-Only]` Returns true if the given value is TRecord */
+export function IsRecord(value: unknown): value is TRecord {
+  return IsKindOf(value, 'Record')
+}
+/** `[Kind-Only]` Returns true if this value is TRecursive */
+export function IsRecursive(value: unknown): value is { [Hint]: 'Recursive' } {
+  return ValueGuard.IsObject(value) && Hint in value && value[Hint] === 'Recursive'
+}
+/** `[Kind-Only]` Returns true if the given value is TRef */
+export function IsRef(value: unknown): value is TRef {
+  return IsKindOf(value, 'Ref')
+}
+/** `[Kind-Only]` Returns true if the given value is TRegExp */
+export function IsRegExp(value: unknown): value is TRegExp {
+  return IsKindOf(value, 'RegExp')
+}
+/** `[Kind-Only]` Returns true if the given value is TString */
+export function IsString(value: unknown): value is TString {
+  return IsKindOf(value, 'String')
+}
+/** `[Kind-Only]` Returns true if the given value is TSymbol */
+export function IsSymbol(value: unknown): value is TSymbol {
+  return IsKindOf(value, 'Symbol')
+}
+/** `[Kind-Only]` Returns true if the given value is TTemplateLiteral */
+export function IsTemplateLiteral(value: unknown): value is TTemplateLiteral {
+  return IsKindOf(value, 'TemplateLiteral')
+}
+/** `[Kind-Only]` Returns true if the given value is TThis */
+export function IsThis(value: unknown): value is TThis {
+  return IsKindOf(value, 'This')
+}
+/** `[Kind-Only]` Returns true of this value is TTransform */
+export function IsTransform(value: unknown): value is { [TransformKind]: TransformOptions } {
+  return ValueGuard.IsObject(value) && TransformKind in value
+}
+/** `[Kind-Only]` Returns true if the given value is TTuple */
+export function IsTuple(value: unknown): value is TTuple {
+  return IsKindOf(value, 'Tuple')
+}
+/** `[Kind-Only]` Returns true if the given value is TUndefined */
+export function IsUndefined(value: unknown): value is TUndefined {
+  return IsKindOf(value, 'Undefined')
+}
+/** `[Kind-Only]` Returns true if the given value is TUnion */
+export function IsUnion(value: unknown): value is TUnion {
+  return IsKindOf(value, 'Union')
+}
+/** `[Kind-Only]` Returns true if the given value is TUint8Array */
+export function IsUint8Array(value: unknown): value is TUint8Array {
+  return IsKindOf(value, 'Uint8Array')
+}
+/** `[Kind-Only]` Returns true if the given value is TUnknown */
+export function IsUnknown(value: unknown): value is TUnknown {
+  return IsKindOf(value, 'Unknown')
+}
+/** `[Kind-Only]` Returns true if the given value is a raw TUnsafe */
+export function IsUnsafe(value: unknown): value is TUnsafe<unknown> {
+  return IsKindOf(value, 'Unsafe')
+}
+/** `[Kind-Only]` Returns true if the given value is TVoid */
+export function IsVoid(value: unknown): value is TVoid {
+  return IsKindOf(value, 'Void')
+}
+/** `[Kind-Only]` Returns true if the given value is TKind */
+export function IsKind(value: unknown): value is Record<PropertyKey, unknown> & { [Kind]: string } {
+  return ValueGuard.IsObject(value) && Kind in value && ValueGuard.IsString(value[Kind])
+}
+/** `[Kind-Only]` Returns true if the given value is TSchema */
+export function IsSchema(value: unknown): value is TSchema {
+  // prettier-ignore
+  return (
+    IsAny(value) ||
+    IsArray(value) ||
+    IsBoolean(value) ||
+    IsBigInt(value) ||
+    IsAsyncIterator(value) ||
+    IsConstructor(value) ||
+    IsDate(value) ||
+    IsFunction(value) ||
+    IsInteger(value) ||
+    IsIntersect(value) ||
+    IsIterator(value) ||
+    IsLiteral(value) ||
+    IsMappedKey(value) ||
+    IsMappedResult(value) ||
+    IsNever(value) ||
+    IsNot(value) ||
+    IsNull(value) ||
+    IsNumber(value) ||
+    IsObject(value) ||
+    IsPromise(value) ||
+    IsRecord(value) ||
+    IsRef(value) ||
+    IsRegExp(value) ||
+    IsString(value) ||
+    IsSymbol(value) ||
+    IsTemplateLiteral(value) ||
+    IsThis(value) ||
+    IsTuple(value) ||
+    IsUndefined(value) ||
+    IsUnion(value) ||
+    IsUint8Array(value) ||
+    IsUnknown(value) ||
+    IsUnsafe(value) ||
+    IsVoid(value) ||
+    IsKind(value)
+  )
+}
diff --git a/src/type/guard/type.ts b/src/type/guard/type.ts
index 5282c5713..f80b24fe7 100644
--- a/src/type/guard/type.ts
+++ b/src/type/guard/type.ts
@@ -472,7 +472,7 @@ export function IsSymbol(value: unknown): value is TSymbol {
   )
 }
 /** Returns true if the given value is TTemplateLiteral */
-export function IsTemplateLiteral(value: unknown): value is TTemplateLiteral<TTemplateLiteralKind[]> {
+export function IsTemplateLiteral(value: unknown): value is TTemplateLiteral {
   // prettier-ignore
   return (
     IsKindOf(value, 'TemplateLiteral') &&
diff --git a/src/type/helpers/helpers.ts b/src/type/helpers/helpers.ts
index 807e10c07..1ab44dc30 100644
--- a/src/type/helpers/helpers.ts
+++ b/src/type/helpers/helpers.ts
@@ -59,7 +59,7 @@ type IncrementReverse<T extends string> = T extends `${infer L}${infer R}` ? `${
 export type TIncrement<T extends string> = IncrementReverse<IncrementStep<IncrementReverse<T>>>
 /** Increments the given string value + 1 */
 export function Increment<T extends string>(T: T): TIncrement<T> {
-  return (parseInt(T) + 1).toString() as TIncrement<T>
+  return (parseInt(T) + 1).toString() as never
 }
 // ------------------------------------------------------------------
 // Helper: Type Asserts
diff --git a/src/type/indexed/indexed-from-mapped-key.ts b/src/type/indexed/indexed-from-mapped-key.ts
index d32a11056..e82b1b5f5 100644
--- a/src/type/indexed/indexed-from-mapped-key.ts
+++ b/src/type/indexed/indexed-from-mapped-key.ts
@@ -47,7 +47,7 @@ function MappedIndexPropertyKey<
   T extends TSchema, 
   K extends PropertyKey
 >(T: T, K: K, options: SchemaOptions): TMappedIndexPropertyKey<T, K> {
-  return { [K]: Index(T, [K], options) } as TMappedIndexPropertyKey<T, K>
+  return { [K]: Index(T, [K], options) } as never
 }
 // ------------------------------------------------------------------
 // MappedIndexPropertyKeys
@@ -65,7 +65,7 @@ function MappedIndexPropertyKeys<
 >(T: T, K: [...K], options: SchemaOptions): TMappedIndexPropertyKeys<T, K> {
   return K.reduce((Acc, L) => {
     return { ...Acc, ...MappedIndexPropertyKey(T, L, options) }
-  }, {} as TProperties) as TMappedIndexPropertyKeys<T, K>
+  }, {} as TProperties) as never
 }
 // ------------------------------------------------------------------
 // MappedIndexProperties
@@ -79,7 +79,7 @@ function MappedIndexProperties<
   T extends TSchema, 
   K extends TMappedKey
 >(T: T, K: K, options: SchemaOptions): TMappedIndexProperties<T, K> {
-  return MappedIndexPropertyKeys(T, K.keys, options) as TMappedIndexProperties<T, K>
+  return MappedIndexPropertyKeys(T, K.keys, options) as never
 }
 // ------------------------------------------------------------------
 // TIndexFromMappedKey
@@ -98,6 +98,6 @@ export function IndexFromMappedKey<
   K extends TMappedKey, 
   P extends TProperties = TMappedIndexProperties<T, K>
 >(T: T, K: K, options: SchemaOptions): TMappedResult<P> {
-  const P = MappedIndexProperties(T, K, options) as unknown as P
-  return MappedResult(P)
+  const P = MappedIndexProperties(T, K, options)
+  return MappedResult(P) as never
 }
diff --git a/src/type/indexed/indexed-from-mapped-result.ts b/src/type/indexed/indexed-from-mapped-result.ts
index ce4745886..f51837c1f 100644
--- a/src/type/indexed/indexed-from-mapped-result.ts
+++ b/src/type/indexed/indexed-from-mapped-result.ts
@@ -47,9 +47,11 @@ function FromProperties<
   T extends TSchema,
   P extends TProperties
 >(T: T, P: P, options: SchemaOptions): TFromProperties<T, P> {
-  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-    return {...Acc, [K2]: Index(T, IndexPropertyKeys(P[K2]), options) }
-  }, {}) as TFromProperties<T, P>
+  const Acc = {} as Record<PropertyKey, TSchema>
+  for(const K2 of Object.getOwnPropertyNames(P)) {
+    Acc[K2] = Index(T, IndexPropertyKeys(P[K2]), options)
+  }
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult
@@ -66,7 +68,7 @@ function FromMappedResult<
   T extends TSchema,
   R extends TMappedResult
 >(T: T, R: R, options: SchemaOptions): TFromMappedResult<T, R> {
-  return FromProperties(T, R.properties, options) as TFromMappedResult<T, R>
+  return FromProperties(T, R.properties, options) as never
 }
 // ------------------------------------------------------------------
 // TIndexFromMappedResult
@@ -85,6 +87,6 @@ export function IndexFromMappedResult<
   R extends TMappedResult,
   P extends TProperties = TFromMappedResult<T, R>
 >(T: T, R: R, options: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedResult(T, R, options) as unknown as P
-  return MappedResult(P) 
+  const P = FromMappedResult(T, R, options)
+  return MappedResult(P) as never
 }
diff --git a/src/type/indexed/indexed-property-keys.ts b/src/type/indexed/indexed-property-keys.ts
index 48a45cd92..dcb60fad7 100644
--- a/src/type/indexed/indexed-property-keys.ts
+++ b/src/type/indexed/indexed-property-keys.ts
@@ -36,7 +36,7 @@ import type { TUnion } from '../union/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsTemplateLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../guard/type'
+import { IsTemplateLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../guard/kind'
 // ------------------------------------------------------------------
 // FromTemplateLiteral
 // ------------------------------------------------------------------
@@ -45,7 +45,7 @@ type TFromTemplateLiteral<T extends TTemplateLiteral, R extends string[] = TTemp
 // prettier-ignore
 function FromTemplateLiteral<T extends TTemplateLiteral>(T: T): TFromTemplateLiteral<T> {
   const R = TemplateLiteralGenerate(T) as string[]
-  return R.map(S => S.toString()) as TFromTemplateLiteral<T>
+  return R.map(S => S.toString()) as never
 }
 // ------------------------------------------------------------------
 // FromUnion
@@ -58,9 +58,9 @@ type TFromUnion<T extends TSchema[], Acc extends string[] = []> = (
 )
 // prettier-ignore
 function FromUnion<T extends TSchema[]>(T: T): TFromUnion<T> {
-  return T.reduce((Acc, L) => {
-    return [...Acc, ...IndexPropertyKeys(L)]
-  }, [] as string[]) as TFromUnion<T>
+  const Acc = [] as string[]
+  for(const L of T) Acc.push(...IndexPropertyKeys(L))
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // FromLiteral
@@ -75,7 +75,7 @@ type TFromLiteral<T extends TLiteralValue> = (
 function FromLiteral<T extends TLiteralValue>(T: T): TFromLiteral<T> {
   return (
     [(T as string).toString()] // TS 5.4 observes TLiteralValue as not having a toString()
-  ) as TFromLiteral<T>
+  ) as never
 }
 // ------------------------------------------------------------------
 // IndexedKeyResolve
@@ -99,5 +99,5 @@ export function IndexPropertyKeys<T extends TSchema>(T: T): TIndexPropertyKeys<T
     IsNumber(T) ? ['[number]'] : 
     IsInteger(T) ? ['[number]'] :
     []
-  ))] as TIndexPropertyKeys<T>
+  ))] as never
 }
diff --git a/src/type/indexed/indexed.ts b/src/type/indexed/indexed.ts
index f3df37e77..f5519e46b 100644
--- a/src/type/indexed/indexed.ts
+++ b/src/type/indexed/indexed.ts
@@ -46,7 +46,7 @@ import { IndexFromMappedResult, type TIndexFromMappedResult } from './indexed-fr
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion } from '../guard/type'
+import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion } from '../guard/kind'
 
 // ------------------------------------------------------------------
 // FromRest
@@ -59,7 +59,7 @@ type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[]
 )
 // prettier-ignore
 function FromRest<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TFromRest<T, K> {
-  return T.map(L => IndexFromPropertyKey(L, K)) as TFromRest<T, K>
+  return T.map(L => IndexFromPropertyKey(L, K)) as never
 }
 // ------------------------------------------------------------------
 // FromIntersectRest
@@ -84,7 +84,7 @@ type TFromIntersect<T extends TSchema[], K extends PropertyKey> = (
 function FromIntersect<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TFromIntersect<T, K> {
   return (
     IntersectEvaluated(FromIntersectRest(FromRest(T as TSchema[], K)))
-  ) as TFromIntersect<T, K>
+  ) as never
 }
 // ------------------------------------------------------------------
 // FromUnionRest
@@ -135,7 +135,7 @@ type TFromUnion<T extends TSchema[], K extends PropertyKey> = (
 function FromUnion<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TFromUnion<T, K> {
   return (
     UnionEvaluated(FromUnionRest(FromRest(T as TSchema[], K)))
-  ) as TFromUnion<T, K>
+  ) as never
 }
 // ------------------------------------------------------------------
 // FromTuple
@@ -152,7 +152,7 @@ function FromTuple<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K):
     K in T ? T[K as number] : 
     K === '[number]' ? UnionEvaluated(T) : 
     Never()
-  ) as TFromTuple<T, K>
+  ) as never
 }
 // ------------------------------------------------------------------
 // FromArray
@@ -169,7 +169,7 @@ function FromArray<T extends TSchema, K extends PropertyKey>(T: T, K: K): TFromA
     K === '[number]' 
       ? T 
       : Never()
-  ) as TFromArray<T, K>
+  ) as never
 }
 // ------------------------------------------------------------------
 // FromProperty
@@ -191,7 +191,7 @@ type TFromProperty<
 )
 // prettier-ignore
 function FromProperty<T extends TProperties, K extends PropertyKey>(T: T, K: K): TFromProperty<T, K> {
-  return (K in T ? T[K as string] : Never()) as TFromProperty<T, K>
+  return (K in T ? T[K as string] : Never()) as never
 }
 // ------------------------------------------------------------------
 // FromKey
@@ -215,7 +215,7 @@ export function IndexFromPropertyKey<T extends TSchema, K extends PropertyKey>(T
     IsArray(T) ? FromArray(T.items, K) :
     IsObject(T) ? FromProperty(T.properties, K) :
     Never()
-  ) as TIndexFromPropertyKey<T, K>
+  ) as never
 }
 // ------------------------------------------------------------------
 // FromKeys
@@ -228,7 +228,7 @@ export type TIndexFromPropertyKeys<T extends TSchema, K extends PropertyKey[], A
 )
 // prettier-ignore
 export function IndexFromPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TIndexFromPropertyKeys<T, K> {
-  return K.map(L => IndexFromPropertyKey(T, L)) as TIndexFromPropertyKeys<T, K>
+  return K.map(L => IndexFromPropertyKey(T, L)) as never
 }
 // ------------------------------------------------------------------
 // FromSchema
@@ -241,7 +241,7 @@ type FromSchema<T extends TSchema, K extends PropertyKey[]> = (
 function FromSchema<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromSchema<T, K> {
   return (
     UnionEvaluated(IndexFromPropertyKeys(T, K as PropertyKey[]))
-  ) as FromSchema<T, K>
+  ) as never
 }
 // ------------------------------------------------------------------
 // TIndex
diff --git a/src/type/integer/integer.ts b/src/type/integer/integer.ts
index e74ec75ea..3146c25cf 100644
--- a/src/type/integer/integer.ts
+++ b/src/type/integer/integer.ts
@@ -47,5 +47,5 @@ export function Integer(options: IntegerOptions = {}): TInteger {
     ...options,
     [Kind]: 'Integer',
     type: 'integer',
-  } as unknown as TInteger
+  } as never
 }
diff --git a/src/type/intersect/intersect-create.ts b/src/type/intersect/intersect-create.ts
index eb179e770..300291aa1 100644
--- a/src/type/intersect/intersect-create.ts
+++ b/src/type/intersect/intersect-create.ts
@@ -34,7 +34,7 @@ import type { TIntersect, IntersectOptions } from './intersect-type'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsObject, IsSchema } from '../guard/type'
+import { IsObject, IsSchema } from '../guard/kind'
 // ------------------------------------------------------------------
 // IntersectCreate
 // ------------------------------------------------------------------
@@ -48,5 +48,5 @@ export function IntersectCreate<T extends TSchema[]>(T: [...T], options: Interse
     (options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects
       ? { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: CloneRest(T) }
       : { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: CloneRest(T) })
-  ) as TIntersect<T>
+  ) as never
 }
diff --git a/src/type/intersect/intersect-evaluated.ts b/src/type/intersect/intersect-evaluated.ts
index 2647e1b0d..f8a5c884e 100644
--- a/src/type/intersect/intersect-evaluated.ts
+++ b/src/type/intersect/intersect-evaluated.ts
@@ -41,11 +41,7 @@ import { IntersectCreate } from './intersect-create'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
-import { 
-  IsOptional,
-  IsTransform,
-} from '../guard/type'
+import { IsOptional, IsTransform } from '../guard/kind'
 
 // ------------------------------------------------------------------
 // IsIntersectOptional
@@ -60,7 +56,7 @@ type TIsIntersectOptional<T extends TSchema[]> = (
 )
 // prettier-ignore
 function IsIntersectOptional<T extends TSchema[]>(T: T): TIsIntersectOptional<T> {
-  return T.every(L => IsOptional(L)) as TIsIntersectOptional<T>
+  return T.every(L => IsOptional(L)) as never
 }
 // ------------------------------------------------------------------
 // RemoveOptionalFromType
@@ -75,7 +71,7 @@ type TRemoveOptionalFromType<T extends TSchema> = (
 function RemoveOptionalFromType<T extends TSchema>(T: T): TRemoveOptionalFromType<T> {
   return (
     Discard(T, [OptionalKind])
-    ) as TRemoveOptionalFromType<T>
+    ) as never
 }
 // ------------------------------------------------------------------
 // RemoveOptionalFromRest
@@ -90,7 +86,7 @@ type TRemoveOptionalFromRest<T extends TSchema[], Acc extends TSchema[] = []> =
 )
 // prettier-ignore
 function RemoveOptionalFromRest<T extends TSchema[]>(T: T): TRemoveOptionalFromRest<T> {
-  return T.map(L => IsOptional(L) ? RemoveOptionalFromType(L) : L) as TRemoveOptionalFromRest<T>
+  return T.map(L => IsOptional(L) ? RemoveOptionalFromType(L) : L) as never
 }
 // ------------------------------------------------------------------
 // ResolveIntersect
@@ -107,7 +103,7 @@ function ResolveIntersect<T extends TSchema[]>(T: [...T], options: SchemaOptions
     IsIntersectOptional(T)
       ? Optional(IntersectCreate(RemoveOptionalFromRest(T) as TSchema[], options))
       : IntersectCreate(RemoveOptionalFromRest(T) as TSchema[], options)
-  ) as unknown as TResolveIntersect<T>
+  ) as never
 }
 // ------------------------------------------------------------------
 // IntersectEvaluated
diff --git a/src/type/intersect/intersect.ts b/src/type/intersect/intersect.ts
index e677da624..5672f4c63 100644
--- a/src/type/intersect/intersect.ts
+++ b/src/type/intersect/intersect.ts
@@ -36,7 +36,7 @@ import { IntersectCreate } from './intersect-create'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsTransform } from '../guard/type'
+import { IsTransform } from '../guard/kind'
 // ------------------------------------------------------------------
 // Intersect
 // ------------------------------------------------------------------
diff --git a/src/type/intrinsic/intrinsic-from-mapped-key.ts b/src/type/intrinsic/intrinsic-from-mapped-key.ts
index cd370ac1d..51ce4c719 100644
--- a/src/type/intrinsic/intrinsic-from-mapped-key.ts
+++ b/src/type/intrinsic/intrinsic-from-mapped-key.ts
@@ -50,7 +50,7 @@ function MappedIntrinsicPropertyKey<
 >(K: K, M: M, options: SchemaOptions): TMappedIntrinsicPropertyKey<K, M> {
   return {
     [K]: Intrinsic(Literal(K as TLiteralValue), M, options)
-  } as TMappedIntrinsicPropertyKey<K, M>
+  } as never
 }
 // ------------------------------------------------------------------
 // MappedIntrinsicPropertyKeys
@@ -72,7 +72,7 @@ function MappedIntrinsicPropertyKeys<
 >(K: [...K], M: M, options: SchemaOptions): TMappedIntrinsicPropertyKeys<K, M> {
   return K.reduce((Acc, L) => {
     return { ...Acc, ...MappedIntrinsicPropertyKey(L, M, options) }
-  }, {} as TProperties) as TMappedIntrinsicPropertyKeys<K, M>
+  }, {} as TProperties) as never
 }
 // ------------------------------------------------------------------
 // MappedIntrinsicProperties
@@ -89,7 +89,7 @@ function MappedIntrinsicProperties<
   K extends TMappedKey,
   M extends IntrinsicMode,
 >(T: K, M: M, options: SchemaOptions): TMappedIntrinsicProperties<K, M> {
-  return MappedIntrinsicPropertyKeys(T['keys'], M, options) as TMappedIntrinsicProperties<K, M>
+  return MappedIntrinsicPropertyKeys(T['keys'], M, options) as never
 }
 // ------------------------------------------------------------------
 // IntrinsicFromMappedKey
@@ -108,6 +108,6 @@ export function IntrinsicFromMappedKey<
   M extends IntrinsicMode,
   P extends TProperties = TMappedIntrinsicProperties<K, M>
 >(T: K, M: M, options: SchemaOptions): TMappedResult<P> {
-  const P = MappedIntrinsicProperties(T, M, options) as unknown as P
-  return MappedResult(P) 
+  const P = MappedIntrinsicProperties(T, M, options)
+  return MappedResult(P) as never
 }
diff --git a/src/type/intrinsic/intrinsic.ts b/src/type/intrinsic/intrinsic.ts
index 5d4442494..2f7e23c6c 100644
--- a/src/type/intrinsic/intrinsic.ts
+++ b/src/type/intrinsic/intrinsic.ts
@@ -36,7 +36,7 @@ import { type TMappedKey } from '../mapped/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedKey, IsTemplateLiteral, IsUnion, IsLiteral } from '../guard/type'
+import { IsMappedKey, IsTemplateLiteral, IsUnion, IsLiteral } from '../guard/kind'
 // ------------------------------------------------------------------
 // Apply
 // ------------------------------------------------------------------
@@ -78,7 +78,7 @@ function FromTemplateLiteral<T extends TTemplateLiteralKind[], M extends Intrins
   const literals = strings.map((value) => Literal(value))
   const mapped = FromRest(literals as any, mode)
   const union = Union(mapped)
-  return TemplateLiteral([union], options) as unknown as TFromTemplateLiteral<T, M>
+  return TemplateLiteral([union], options) as never
 }
 // ------------------------------------------------------------------
 // FromLiteralValue
@@ -115,7 +115,7 @@ type TFromRest<T extends TSchema[], M extends IntrinsicMode, Acc extends TSchema
     : Acc
 // prettier-ignore
 function FromRest<T extends TSchema[], M extends IntrinsicMode>(T: [...T], M: M): TFromRest<T, M> {
-  return T.map(L => Intrinsic(L, M)) as TFromRest<T, M>
+  return T.map(L => Intrinsic(L, M)) as never
 }
 // ------------------------------------------------------------------
 // TIntrinsic
diff --git a/src/type/iterator/iterator.ts b/src/type/iterator/iterator.ts
index e89816fa7..335bae40c 100644
--- a/src/type/iterator/iterator.ts
+++ b/src/type/iterator/iterator.ts
@@ -44,5 +44,5 @@ export function Iterator<T extends TSchema>(items: T, options: SchemaOptions = {
     [Kind]: 'Iterator',
     type: 'Iterator',
     items: CloneType(items),
-  } as unknown as TIterator<T>
+  } as never
 }
diff --git a/src/type/keyof/keyof-from-mapped-result.ts b/src/type/keyof/keyof-from-mapped-result.ts
index d7edcd9ef..1f4f7df33 100644
--- a/src/type/keyof/keyof-from-mapped-result.ts
+++ b/src/type/keyof/keyof-from-mapped-result.ts
@@ -45,9 +45,9 @@ type TFromProperties<
 function FromProperties<
   K extends TProperties
 >(K: K, options: SchemaOptions): TFromProperties<K> {
-  return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-    return {...Acc, [K2]: KeyOf(K[K2], options) }
-  }, {}) as TFromProperties<K>
+  const Acc = {} as TProperties
+  for(const K2 of globalThis.Object.getOwnPropertyNames(K)) Acc[K2] = KeyOf(K[K2], options)
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult
@@ -62,7 +62,7 @@ type TFromMappedResult<
 function FromMappedResult<
   R extends TMappedResult
 >(R: R, options: SchemaOptions): TFromMappedResult<R> {
-  return FromProperties(R.properties, options) as TFromMappedResult<R>
+  return FromProperties(R.properties, options) as never
 }
 // ------------------------------------------------------------------
 // KeyOfFromMappedResult
@@ -79,6 +79,6 @@ export function KeyOfFromMappedResult<
   R extends TMappedResult,
   P extends TProperties = TFromMappedResult<R>
 >(R: R, options: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedResult(R, options) as unknown as P
-  return MappedResult(P) 
+  const P = FromMappedResult(R, options)
+  return MappedResult(P) as never
 }
diff --git a/src/type/keyof/keyof-property-keys.ts b/src/type/keyof/keyof-property-keys.ts
index 8f7c17e3b..28f945bb1 100644
--- a/src/type/keyof/keyof-property-keys.ts
+++ b/src/type/keyof/keyof-property-keys.ts
@@ -39,7 +39,7 @@ import { SetUnionMany, SetIntersectMany, type TSetUnionMany, type TSetIntersectM
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsRecord } from '../guard/type'
+import { IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsRecord } from '../guard/kind'
 // ------------------------------------------------------------------
 // FromRest
 // ------------------------------------------------------------------
@@ -51,9 +51,9 @@ type TFromRest<T extends TSchema[], Acc extends PropertyKey[][] = []> = (
 )
 // prettier-ignore
 function FromRest<T extends TSchema[]>(T: [...T]): TFromRest<T> {
-  return T.reduce((Acc, L) => {
-    return [...Acc, KeyOfPropertyKeys(L)]
-  }, [] as PropertyKey[][]) as TFromRest<T>
+  const Acc = [] as PropertyKey[][]
+  for(const L of T) Acc.push(KeyOfPropertyKeys(L))
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // FromIntersect
@@ -68,7 +68,7 @@ type TFromIntersect<
 function FromIntersect<T extends TSchema[]>(T: [...T]): TFromIntersect<T> {
   const C = FromRest(T) as PropertyKey[][]
   const R = SetUnionMany(C)
-  return R as TFromIntersect<T>
+  return R as never
 }
 // ------------------------------------------------------------------
 // FromUnion
@@ -83,7 +83,7 @@ type TFromUnion<
 function FromUnion<T extends TSchema[]>(T: [...T]): TFromUnion<T> {
   const C = FromRest(T) as PropertyKey[][]
   const R = SetIntersectMany(C)
-  return R as TFromUnion<T>
+  return R as never
 }
 // ------------------------------------------------------------------
 // FromTuple
@@ -95,7 +95,7 @@ type TFromTuple<T extends TSchema[], I extends string = ZeroString, Acc extends
     : Acc
 // prettier-ignore
 function FromTuple<T extends TSchema[]>(T: [...T]): TFromTuple<T> {
-  return T.map((_, I) => I.toString()) as TFromTuple<T>
+  return T.map((_, I) => I.toString()) as never
 }
 // ------------------------------------------------------------------
 // FromArray
@@ -121,7 +121,7 @@ type TFromProperties<T extends TProperties> = (
 function FromProperties<T extends TProperties>(T: T): TFromProperties<T> {
   return (
     globalThis.Object.getOwnPropertyNames(T)
-  ) as TFromProperties<T>
+  ) as never
 }
 // ------------------------------------------------------------------
 // FromPatternProperties
@@ -160,7 +160,7 @@ export function KeyOfPropertyKeys<T extends TSchema>(T: T): TKeyOfPropertyKeys<T
     IsObject(T) ? FromProperties(T.properties) :
     IsRecord(T) ? FromPatternProperties(T.patternProperties) :
     []
-  ) as TKeyOfPropertyKeys<T>
+  ) as never
 }
 // ----------------------------------------------------------------
 // KeyOfPattern
diff --git a/src/type/keyof/keyof.ts b/src/type/keyof/keyof.ts
index 8e3b8fcde..895eaa6e0 100644
--- a/src/type/keyof/keyof.ts
+++ b/src/type/keyof/keyof.ts
@@ -40,7 +40,7 @@ import { KeyOfFromMappedResult, type TKeyOfFromMappedResult } from './keyof-from
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult } from '../guard/type'
+import { IsMappedResult } from '../guard/kind'
 // ------------------------------------------------------------------
 // FromPropertyKeys
 // ------------------------------------------------------------------
@@ -54,7 +54,7 @@ export type TKeyOfPropertyKeysToRest<T extends PropertyKey[], Acc extends TSchem
 )
 // prettier-ignore
 export function KeyOfPropertyKeysToRest<T extends PropertyKey[]>(T: [...T]): TKeyOfPropertyKeysToRest<T> {
-  return T.map(L => L === '[number]' ? Number() : Literal(L as TLiteralValue)) as TKeyOfPropertyKeysToRest<T>
+  return T.map(L => L === '[number]' ? Number() : Literal(L as TLiteralValue)) as never
 }
 // ------------------------------------------------------------------
 // KeyOfTypeResolve
diff --git a/src/type/literal/literal.ts b/src/type/literal/literal.ts
index fe3c7b64b..3091b4dbd 100644
--- a/src/type/literal/literal.ts
+++ b/src/type/literal/literal.ts
@@ -49,5 +49,5 @@ export function Literal<T extends TLiteralValue>(value: T, options: SchemaOption
     [Kind]: 'Literal',
     const: value,
     type: typeof value as 'string' | 'number' | 'boolean',
-  } as unknown as TLiteral<T>
+  } as never
 }
diff --git a/src/type/mapped/mapped-key.ts b/src/type/mapped/mapped-key.ts
index d7eba3634..c3a6f288c 100644
--- a/src/type/mapped/mapped-key.ts
+++ b/src/type/mapped/mapped-key.ts
@@ -39,5 +39,5 @@ export function MappedKey<T extends PropertyKey[]>(T: [...T]): TMappedKey<T> {
   return {
     [Kind]: 'MappedKey',
     keys: T
-  } as unknown as TMappedKey<T> 
+  } as never
 }
diff --git a/src/type/mapped/mapped.ts b/src/type/mapped/mapped.ts
index 6ab806bd0..77c7d37a7 100644
--- a/src/type/mapped/mapped.ts
+++ b/src/type/mapped/mapped.ts
@@ -55,24 +55,7 @@ import type { TMappedKey } from './mapped-key'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
-import {
-  IsArray,
-  IsAsyncIterator,
-  IsConstructor,
-  IsFunction,
-  IsIntersect,
-  IsIterator,
-  IsReadonly,
-  IsMappedResult,
-  IsMappedKey,
-  IsObject,
-  IsOptional,
-  IsPromise,
-  IsSchema,
-  IsTuple,
-  IsUnion,
-} from '../guard/type'
+import { IsArray, IsAsyncIterator, IsConstructor, IsFunction, IsIntersect, IsIterator, IsReadonly, IsMappedResult, IsMappedKey, IsObject, IsOptional, IsPromise, IsSchema, IsTuple, IsUnion } from '../guard/kind'
 // ------------------------------------------------------------------
 // FromMappedResult
 //
@@ -101,7 +84,7 @@ function FromMappedResult<K extends PropertyKey, P extends TProperties>(K: K, P:
     K in P 
       ? FromSchemaType(K, P[K as string])
       : MappedResult(P)
-  ) as TFromMappedResult<K, P>
+  ) as never
 }
 // ------------------------------------------------------------------
 // MappedKeyToKnownMappedResultProperties
@@ -115,7 +98,7 @@ type TMappedKeyToKnownMappedResultProperties<K extends PropertyKey> = {
 }
 // prettier-ignore
 function MappedKeyToKnownMappedResultProperties<K extends PropertyKey>(K: K): TMappedKeyToKnownMappedResultProperties<K> {
-  return { [K]: Literal(K as TLiteralValue) } as TMappedKeyToKnownMappedResultProperties<K>
+  return { [K]: Literal(K as TLiteralValue) } as never
 }
 // ------------------------------------------------------------------
 // MappedKeyToUnknownMappedResultProperties
@@ -133,9 +116,9 @@ type TMappedKeyToUnknownMappedResultProperties<P extends PropertyKey[], Acc exte
 )
 // prettier-ignore
 function MappedKeyToUnknownMappedResultProperties<P extends PropertyKey[]>(P: [...P]): TMappedKeyToUnknownMappedResultProperties<P> {
-  return P.reduce((Acc, L) => {
-    return { ...Acc, [L]: Literal(L as TLiteralValue) }
-  }, {} as TProperties) as TMappedKeyToUnknownMappedResultProperties<P>
+  const Acc = {} as Record<PropertyKey, TSchema>
+  for(const L of P) Acc[L] = Literal(L as TLiteralValue)
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // MappedKeyToMappedResultProperties
@@ -152,7 +135,7 @@ function MappedKeyToMappedResultProperties<K extends PropertyKey, P extends Prop
     SetIncludes(P, K)
       ? MappedKeyToKnownMappedResultProperties(K)
       : MappedKeyToUnknownMappedResultProperties(P)
-  ) as TMappedKeyToMappedResultProperties<K, P>
+  ) as never
 }
 // prettier-ignore
 type TFromMappedKey<
@@ -163,9 +146,9 @@ type TFromMappedKey<
   TFromMappedResult<K, R>
 )
 // prettier-ignore
-function FromMappedKey<K extends PropertyKey, P extends PropertyKey[]>(K: K, P: [...P]) {
+function FromMappedKey<K extends PropertyKey, P extends PropertyKey[]>(K: K, P: [...P]): TFromMappedKey<K, P> {
   const R = MappedKeyToMappedResultProperties(K, P)
-  return FromMappedResult(K, R)
+  return FromMappedResult(K, R) as never
 }
 // ------------------------------------------------------------------
 // FromRest
@@ -178,7 +161,7 @@ type TFromRest<K extends PropertyKey, T extends TSchema[], Acc extends TSchema[]
 )
 // prettier-ignore
 function FromRest<K extends PropertyKey, T extends TSchema[]>(K: K, T: [...T]): TFromRest<K, T> {
-  return T.map(L => FromSchemaType(K, L)) as TFromRest<K, T>
+  return T.map(L => FromSchemaType(K, L)) as never
 }
 // ------------------------------------------------------------------
 // FromProperties
@@ -189,9 +172,9 @@ type FromProperties<K extends PropertyKey, T extends TProperties, R extends TPro
 }>> = R
 // prettier-ignore
 function FromProperties<K extends PropertyKey, T extends TProperties>(K: K, T: T): FromProperties<K, T> {
-  return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K2) => {
-    return { ...Acc, [K2]: FromSchemaType(K, T[K2]) }
-  }, {}) as FromProperties<K, T>
+  const Acc = {} as Record<PropertyKey, TSchema>
+  for(const K2 of globalThis.Object.getOwnPropertyNames(T)) Acc[K2] = FromSchemaType(K, T[K2])
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // FromMappedPropertyKey
@@ -238,7 +221,7 @@ function FromSchemaType<K extends PropertyKey, T extends TSchema>(K: K, T: T): F
     IsArray(T) ? Array(FromSchemaType(K, T.items)) :
     IsPromise(T) ? Promise(FromSchemaType(K, T.item)) :
     T
-  ) as FromSchemaType<K, T>
+  ) as never
 }
 // ------------------------------------------------------------------
 // MappedFunctionReturnType
@@ -250,10 +233,10 @@ export type TMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema
     : Acc
 )
 // prettier-ignore
-export function MappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T, Acc: TProperties = {}): TMappedFunctionReturnType<K, T> {
-  return K.reduce((Acc, L) => {
-    return { ...Acc, [L]: FromSchemaType(L, T) }
-  }, {} as TProperties) as TMappedFunctionReturnType<K, T>
+export function MappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T): TMappedFunctionReturnType<K, T> {
+  const Acc = {} as Record<PropertyKey, TSchema>
+  for(const L of K) Acc[L] = FromSchemaType(L, T)
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // TMappedFunction
diff --git a/src/type/never/never.ts b/src/type/never/never.ts
index d3113d216..d1ff1c234 100644
--- a/src/type/never/never.ts
+++ b/src/type/never/never.ts
@@ -40,5 +40,5 @@ export function Never(options: SchemaOptions = {}): TNever {
     ...options,
     [Kind]: 'Never',
     not: {},
-  } as unknown as TNever
+  } as never
 }
diff --git a/src/type/not/not.ts b/src/type/not/not.ts
index d01ac2b3a..7315fec86 100644
--- a/src/type/not/not.ts
+++ b/src/type/not/not.ts
@@ -42,5 +42,5 @@ export function Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot
     ...options,
     [Kind]: 'Not',
     not: CloneType(schema),
-  } as unknown as TNot<T>
+  } as never
 }
diff --git a/src/type/null/null.ts b/src/type/null/null.ts
index 09142d299..40690048a 100644
--- a/src/type/null/null.ts
+++ b/src/type/null/null.ts
@@ -40,5 +40,5 @@ export function Null(options: SchemaOptions = {}): TNull {
     ...options,
     [Kind]: 'Null',
     type: 'null',
-  } as unknown as TNull
+  } as never
 }
diff --git a/src/type/number/number.ts b/src/type/number/number.ts
index 573eb403a..db7392cd0 100644
--- a/src/type/number/number.ts
+++ b/src/type/number/number.ts
@@ -47,5 +47,5 @@ export function Number(options: NumberOptions = {}): TNumber {
     ...options,
     [Kind]: 'Number',
     type: 'number',
-  } as unknown as TNumber
+  } as never
 }
diff --git a/src/type/object/object.ts b/src/type/object/object.ts
index 0cda73dfe..a9d4ce358 100644
--- a/src/type/object/object.ts
+++ b/src/type/object/object.ts
@@ -37,7 +37,7 @@ import { Kind } from '../symbols/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsOptional, IsSchema } from '../guard/type'
+import { IsOptional, IsSchema } from '../guard/kind'
 
 // ------------------------------------------------------------------
 // ObjectStatic
@@ -89,10 +89,13 @@ function _Object<T extends TProperties>(properties: T, options: ObjectOptions =
   const optionalKeys = propertyKeys.filter((key) => IsOptional(properties[key]))
   const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name))
   const clonedAdditionalProperties = IsSchema(options.additionalProperties) ? { additionalProperties: CloneType(options.additionalProperties) } : {}
-  const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: CloneType(properties[key]) }), {} as TProperties)
-  return (requiredKeys.length > 0
-    ? { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys }
-    : { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties }) as unknown as TObject<T>
+  const clonedProperties = {} as Record<PropertyKey, TSchema>
+  for (const key of propertyKeys) clonedProperties[key] = CloneType(properties[key])
+  return (
+    requiredKeys.length > 0
+      ? { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys }
+      : { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties }
+  ) as never
 }
 
 /** `[Json]` Creates an Object type */
diff --git a/src/type/omit/omit-from-mapped-key.ts b/src/type/omit/omit-from-mapped-key.ts
index 041101a9e..3ca1822dc 100644
--- a/src/type/omit/omit-from-mapped-key.ts
+++ b/src/type/omit/omit-from-mapped-key.ts
@@ -48,7 +48,7 @@ function FromPropertyKey<
 >(T: T, K: K, options: SchemaOptions): TFromPropertyKey<T, K> {
   return {
     [K]: Omit(T, [K], options)
-  } as TFromPropertyKey<T, K>
+  } as never
 }
 // ------------------------------------------------------------------
 // FromPropertyKeys
@@ -70,7 +70,7 @@ function FromPropertyKeys<
 >(T: T, K: [...K], options: SchemaOptions): TFromPropertyKeys<T, K> {
   return K.reduce((Acc, LK) => {
     return { ...Acc, ...FromPropertyKey(T, LK, options) }
-  }, {} as TProperties) as TFromPropertyKeys<T, K>
+  }, {} as TProperties) as never
 }
 // ------------------------------------------------------------------
 // FromMappedKey
@@ -87,7 +87,7 @@ function FromMappedKey<
   T extends TSchema,
   K extends TMappedKey,
 >(T: T, K: K, options: SchemaOptions): TFromMappedKey<T, K> {
-  return FromPropertyKeys(T, K.keys, options) as TFromMappedKey<T, K>
+  return FromPropertyKeys(T, K.keys, options) as never
 }
 // ------------------------------------------------------------------
 // OmitFromMappedKey
@@ -106,6 +106,6 @@ export function OmitFromMappedKey<
   K extends TMappedKey,
   P extends TProperties = TFromMappedKey<T, K>
 >(T: T, K: K, options: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedKey(T, K, options) as unknown as P
-  return MappedResult(P) 
+  const P = FromMappedKey(T, K, options)
+  return MappedResult(P) as never
 }
diff --git a/src/type/omit/omit-from-mapped-result.ts b/src/type/omit/omit-from-mapped-result.ts
index 01327fe21..5f54e4802 100644
--- a/src/type/omit/omit-from-mapped-result.ts
+++ b/src/type/omit/omit-from-mapped-result.ts
@@ -47,9 +47,9 @@ function FromProperties<
   P extends TProperties,
   K extends PropertyKey[],
 >(P: P, K: [...K], options: SchemaOptions): TFromProperties<P, K> {
-  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-    return {...Acc, [K2]: Omit(P[K2], K, options) }
-  }, {}) as TFromProperties<P, K>
+  const Acc = {} as TProperties
+  for(const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Omit(P[K2], K, options)
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult
@@ -66,7 +66,7 @@ function FromMappedResult<
   R extends TMappedResult,
   K extends PropertyKey[]
 >(R: R, K: [...K], options: SchemaOptions): TFromMappedResult<R, K> {
-  return FromProperties(R.properties, K, options) as TFromMappedResult<R, K>
+  return FromProperties(R.properties, K, options) as never
 }
 // ------------------------------------------------------------------
 // TOmitFromMappedResult
@@ -85,6 +85,6 @@ export function OmitFromMappedResult<
   K extends PropertyKey[],
   P extends TProperties = TFromMappedResult<R, K>
 >(R: R, K: [...K], options: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedResult(R, K, options) as unknown as P
-  return MappedResult(P) 
+  const P = FromMappedResult(R, K, options)
+  return MappedResult(P) as never
 }
diff --git a/src/type/omit/omit.ts b/src/type/omit/omit.ts
index 5c5ae73b2..19751fdc4 100644
--- a/src/type/omit/omit.ts
+++ b/src/type/omit/omit.ts
@@ -43,7 +43,7 @@ import { OmitFromMappedResult, type TOmitFromMappedResult } from './omit-from-ma
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedKey, IsIntersect, IsUnion, IsObject, IsSchema, IsMappedResult } from '../guard/type'
+import { IsMappedKey, IsIntersect, IsUnion, IsObject, IsSchema, IsMappedResult } from '../guard/kind'
 
 // ------------------------------------------------------------------
 // FromIntersect
@@ -56,7 +56,7 @@ type TFromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TS
 )
 // prettier-ignore
 function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K) {
-  return T.map((T) => OmitResolve(T, K)) as TFromIntersect<T, K>
+  return T.map((T) => OmitResolve(T, K)) as never
 }
 // ------------------------------------------------------------------
 // FromUnion
@@ -69,23 +69,21 @@ type TFromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchem
 )
 // prettier-ignore
 function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K) {
-  return T.map((T) => OmitResolve(T, K)) as TFromUnion<T, K>
+  return T.map((T) => OmitResolve(T, K)) as never
 }
 // ------------------------------------------------------------------
 // FromProperty
 // ------------------------------------------------------------------
 // prettier-ignore
-function FromProperty<T extends Record<any, any>, K extends PropertyKey>(T: T, K: K) {
+function FromProperty<T extends Record<any, any>, K extends PropertyKey>(T: T, K: K): TProperties {
   const { [K]: _, ...R } = T
-  return R as TProperties
+  return R
 }
 // prettier-ignore
 type TFromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Omit<T, I>>
 // prettier-ignore
 function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K) {
-  return K.reduce((T, K2) => {
-    return FromProperty(T, K2)
-  }, T as TProperties)
+  return K.reduce((T, K2) => FromProperty(T, K2), T as TProperties)
 }
 // ------------------------------------------------------------------
 // OmitResolve
@@ -97,7 +95,7 @@ function OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]
     IsUnion(T) ? Union(FromUnion(T.anyOf, K)) : 
     IsObject(T) ? Object(FromProperties(T.properties, K)) : 
     Object({})
-  ) as TOmit<T, K>
+  ) as never
 }
 // prettier-ignore
 export type TOmit<T extends TProperties, K extends PropertyKey[]> = 
diff --git a/src/type/optional/optional-from-mapped-result.ts b/src/type/optional/optional-from-mapped-result.ts
index 813349da4..b5bb6966a 100644
--- a/src/type/optional/optional-from-mapped-result.ts
+++ b/src/type/optional/optional-from-mapped-result.ts
@@ -45,9 +45,9 @@ function FromProperties<
   P extends TProperties,
   F extends boolean,
 >(P: P, F: F): TFromProperties<P, F> {
-  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-    return {...Acc, [K2]: Optional(P[K2], F) }
-  }, {}) as TFromProperties<P, F>
+  const Acc = {} as TProperties
+  for(const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Optional(P[K2], F)
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult
@@ -64,7 +64,7 @@ function FromMappedResult<
   R extends TMappedResult,
   F extends boolean,
 >(R: R, F: F): TFromMappedResult<R, F> {
-  return FromProperties(R.properties, F) as TFromMappedResult<R, F>
+  return FromProperties(R.properties, F) as never
 }
 // ------------------------------------------------------------------
 // OptionalFromMappedResult
diff --git a/src/type/optional/optional.ts b/src/type/optional/optional.ts
index 70703f101..0ecd8cad4 100644
--- a/src/type/optional/optional.ts
+++ b/src/type/optional/optional.ts
@@ -34,7 +34,7 @@ import { Discard } from '../discard/index'
 import type { TMappedResult } from '../mapped/index'
 
 import { OptionalFromMappedResult, type TOptionalFromMappedResult } from './optional-from-mapped-result'
-import { IsMappedResult } from '../guard/type'
+import { IsMappedResult } from '../guard/kind'
 // ------------------------------------------------------------------
 // RemoveOptional
 // ------------------------------------------------------------------
diff --git a/src/type/partial/partial-from-mapped-result.ts b/src/type/partial/partial-from-mapped-result.ts
index 00f7338ac..466c608ff 100644
--- a/src/type/partial/partial-from-mapped-result.ts
+++ b/src/type/partial/partial-from-mapped-result.ts
@@ -45,9 +45,9 @@ type TFromProperties<
 function FromProperties<
   P extends TProperties
 >(K: P, options: SchemaOptions): TFromProperties<P> {
-  return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-    return {...Acc, [K2]: Partial(K[K2], options) }
-  }, {}) as TFromProperties<P>
+  const Acc = {} as TProperties
+  for(const K2 of globalThis.Object.getOwnPropertyNames(K)) Acc[K2] = Partial(K[K2], options)
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult
@@ -62,7 +62,7 @@ type TFromMappedResult<
 function FromMappedResult<
   R extends TMappedResult
 >(R: R, options: SchemaOptions): TFromMappedResult<R> {
-  return FromProperties(R.properties, options) as TFromMappedResult<R>
+  return FromProperties(R.properties, options) as never
 }
 // ------------------------------------------------------------------
 // TPartialFromMappedResult
@@ -79,6 +79,6 @@ export function PartialFromMappedResult<
   R extends TMappedResult,
   P extends TProperties = TFromMappedResult<R>
 >(R: R, options: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedResult(R, options) as unknown as P
-  return MappedResult(P) 
+  const P = FromMappedResult(R, options)
+  return MappedResult(P) as never
 }
diff --git a/src/type/partial/partial.ts b/src/type/partial/partial.ts
index 961d36f25..27a37b0b7 100644
--- a/src/type/partial/partial.ts
+++ b/src/type/partial/partial.ts
@@ -45,7 +45,7 @@ import { PartialFromMappedResult, type TPartialFromMappedResult } from './partia
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/type'
+import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/kind'
 // ------------------------------------------------------------------
 // FromRest
 // ------------------------------------------------------------------
@@ -57,7 +57,7 @@ type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (
 )
 // prettier-ignore
 function FromRest<T extends TSchema[]>(T: [...T]): TFromRest<T> {
-  return T.map(L => PartialResolve(L)) as TFromRest<T>
+  return T.map(L => PartialResolve(L)) as never
 }
 // ------------------------------------------------------------------
 // FromProperties
@@ -71,10 +71,10 @@ type TFromProperties<T extends TProperties> = Evaluate<{
     TOptional<T[K]>
 }>
 // prettier-ignore
-function FromProperties<T extends TProperties>(T: T) {
-  return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K) => {
-    return { ...Acc, [K]: Optional(T[K]) }
-  }, {} as TProperties)
+function FromProperties<T extends TProperties>(T: T): TFromProperties<T> {
+  const Acc = {} as TProperties
+  for(const K of globalThis.Object.getOwnPropertyNames(T)) Acc[K] = Optional(T[K])
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // PartialResolve
@@ -86,7 +86,7 @@ function PartialResolve<T extends TSchema>(T: T): TPartial<T> {
     IsUnion(T) ? Union(FromRest(T.anyOf)) :
     IsObject(T) ? Object(FromProperties(T.properties)) :
     Object({})
-  ) as TPartial<T>
+  ) as never
 }
 // ------------------------------------------------------------------
 // TPartial
diff --git a/src/type/pick/pick-from-mapped-key.ts b/src/type/pick/pick-from-mapped-key.ts
index 963ba8557..7bd87f09e 100644
--- a/src/type/pick/pick-from-mapped-key.ts
+++ b/src/type/pick/pick-from-mapped-key.ts
@@ -48,7 +48,7 @@ function FromPropertyKey<
 >(T: T, K: K, options: SchemaOptions): TFromPropertyKey<T, K> {
   return {
     [K]: Pick(T, [K], options)
-  } as TFromPropertyKey<T, K>
+  } as never
 }
 // ------------------------------------------------------------------
 // FromPropertyKeys
@@ -70,7 +70,7 @@ function FromPropertyKeys<
 >(T: T, K: [...K], options: SchemaOptions): TFromPropertyKeys<T, K> {
   return K.reduce((Acc, LK) => {
     return { ...Acc, ...FromPropertyKey(T, LK, options) }
-  }, {} as TProperties) as TFromPropertyKeys<T, K>
+  }, {} as TProperties) as never
 }
 // ------------------------------------------------------------------
 // FromMappedKey
@@ -87,7 +87,7 @@ function FromMappedKey<
   T extends TSchema,
   K extends TMappedKey,
 >(T: T, K: K, options: SchemaOptions): TFromMappedKey<T, K> {
-  return FromPropertyKeys(T, K.keys, options) as TFromMappedKey<T, K>
+  return FromPropertyKeys(T, K.keys, options) as never
 }
 // ------------------------------------------------------------------
 // PickFromMappedKey
@@ -106,6 +106,6 @@ export function PickFromMappedKey<
   K extends TMappedKey,
   P extends TProperties = TFromMappedKey<T, K>
 >(T: T, K: K, options: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedKey(T, K, options) as unknown as P
-  return MappedResult(P) 
+  const P = FromMappedKey(T, K, options)
+  return MappedResult(P) as never
 }
diff --git a/src/type/pick/pick-from-mapped-result.ts b/src/type/pick/pick-from-mapped-result.ts
index bfa997a64..43b006457 100644
--- a/src/type/pick/pick-from-mapped-result.ts
+++ b/src/type/pick/pick-from-mapped-result.ts
@@ -47,9 +47,9 @@ function FromProperties<
   P extends TProperties,
   K extends PropertyKey[],
 >(P: P, K: [...K], options: SchemaOptions): TFromProperties<P, K> {
-  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-    return {...Acc, [K2]: Pick(P[K2], K, options) }
-  }, {}) as TFromProperties<P, K>
+  const Acc = {} as TProperties
+  for(const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Pick(P[K2], K, options)
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult
@@ -66,7 +66,7 @@ function FromMappedResult<
   R extends TMappedResult,
   K extends PropertyKey[]
 >(R: R, K: [...K], options: SchemaOptions): TFromMappedResult<R, K> {
-  return FromProperties(R.properties, K, options) as TFromMappedResult<R, K>
+  return FromProperties(R.properties, K, options) as never
 }
 // ------------------------------------------------------------------
 // PickFromMappedResult
@@ -85,6 +85,6 @@ export function PickFromMappedResult<
   K extends PropertyKey[],
   P extends TProperties = TFromMappedResult<R, K>
 >(R: R, K: [...K], options: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedResult(R, K, options) as unknown as P
-  return MappedResult(P) 
+  const P = FromMappedResult(R, K, options)
+  return MappedResult(P) as never
 }
diff --git a/src/type/pick/pick.ts b/src/type/pick/pick.ts
index c35b401ce..60a7b2227 100644
--- a/src/type/pick/pick.ts
+++ b/src/type/pick/pick.ts
@@ -31,7 +31,7 @@ import type { TupleToUnion, Evaluate } from '../helpers/index'
 import { type TRecursive } from '../recursive/index'
 import { type TIntersect, Intersect } from '../intersect/index'
 import { type TUnion, Union } from '../union/index'
-import { type TObject, type TProperties, Object } from '../object/index'
+import { type TObject, type TProperties, type TPropertyKey, Object } from '../object/index'
 import type { TMappedKey, TMappedResult } from '../mapped/index'
 import { IndexPropertyKeys, type TIndexPropertyKeys } from '../indexed/index'
 import { Discard } from '../discard/index'
@@ -43,7 +43,7 @@ import { PickFromMappedResult, type TPickFromMappedResult } from './pick-from-ma
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedKey, IsMappedResult, IsIntersect, IsUnion, IsObject, IsSchema } from '../guard/type'
+import { IsMappedKey, IsMappedResult, IsIntersect, IsUnion, IsObject, IsSchema } from '../guard/kind'
 // ------------------------------------------------------------------
 // FromIntersect
 // ------------------------------------------------------------------
@@ -74,9 +74,9 @@ function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K) {
 type FromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Pick<T, I & keyof T>>
 // prettier-ignore
 function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K) {
-  return K.reduce((Acc, K) => {
-    return K in T ? { ...Acc, [K]: T[K as keyof T] } : Acc
-  }, {})
+  const Acc = {} as TProperties
+  for(const K2 of K) if(K2 in T) Acc[K2 as TPropertyKey] = T[K2 as keyof T]
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // PickResolve
@@ -88,7 +88,7 @@ function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]
     IsUnion(T) ? Union(FromUnion(T.anyOf, K)) : 
     IsObject(T) ? Object(FromProperties(T.properties, K)) : 
     Object({})
-  ) as TPick<T, K>
+  ) as never
 }
 // prettier-ignore
 export type TPick<T extends TProperties, K extends PropertyKey[]> = 
diff --git a/src/type/promise/promise.ts b/src/type/promise/promise.ts
index bebb00171..bd9504194 100644
--- a/src/type/promise/promise.ts
+++ b/src/type/promise/promise.ts
@@ -44,5 +44,5 @@ export function Promise<T extends TSchema>(item: T, options: SchemaOptions = {})
     [Kind]: 'Promise',
     type: 'Promise',
     item: CloneType(item),
-  } as unknown as TPromise<T>
+  } as never
 }
diff --git a/src/type/readonly-optional/readonly-optional.ts b/src/type/readonly-optional/readonly-optional.ts
index d32212777..5520539e8 100644
--- a/src/type/readonly-optional/readonly-optional.ts
+++ b/src/type/readonly-optional/readonly-optional.ts
@@ -34,5 +34,5 @@ export type TReadonlyOptional<T extends TSchema> = TOptional<T> & TReadonly<T>
 
 /** `[Json]` Creates a Readonly and Optional property */
 export function ReadonlyOptional<T extends TSchema>(schema: T): TReadonly<TOptional<T>> {
-  return Readonly(Optional(schema)) as TReadonly<TOptional<T>>
+  return Readonly(Optional(schema)) as never
 }
diff --git a/src/type/readonly/readonly-from-mapped-result.ts b/src/type/readonly/readonly-from-mapped-result.ts
index 29857793b..cd0865aaa 100644
--- a/src/type/readonly/readonly-from-mapped-result.ts
+++ b/src/type/readonly/readonly-from-mapped-result.ts
@@ -45,9 +45,9 @@ function FromProperties<
   P extends TProperties,
   F extends boolean,
 >(K: P, F: F): TFromProperties<P, F> {
-  return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-    return {...Acc, [K2]: Readonly(K[K2], F) }
-  }, {}) as TFromProperties<P, F>
+  const Acc = {} as TProperties
+  for(const K2 of globalThis.Object.getOwnPropertyNames(K)) Acc[K2] = Readonly(K[K2], F)
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult
@@ -64,7 +64,7 @@ function FromMappedResult<
   R extends TMappedResult,
   F extends boolean,
 >(R: R, F: F): TFromMappedResult<R, F> {
-  return FromProperties(R.properties, F) as TFromMappedResult<R, F>
+  return FromProperties(R.properties, F) as never
 }
 // ------------------------------------------------------------------
 // ReadonlyFromMappedResult
@@ -83,6 +83,6 @@ export function ReadonlyFromMappedResult<
   F extends boolean,
   P extends TProperties = TFromMappedResult<R, F>
 >(R: R, F: F): TMappedResult<P> {
-  const P = FromMappedResult(R, F) as unknown as P
-  return MappedResult(P) 
+  const P = FromMappedResult(R, F)
+  return MappedResult(P) as never
 }
diff --git a/src/type/readonly/readonly.ts b/src/type/readonly/readonly.ts
index 594170fff..546caddb7 100644
--- a/src/type/readonly/readonly.ts
+++ b/src/type/readonly/readonly.ts
@@ -34,7 +34,7 @@ import { Discard } from '../discard/index'
 import type { TMappedResult } from '../mapped/index'
 
 import { ReadonlyFromMappedResult, type TReadonlyFromMappedResult } from './readonly-from-mapped-result'
-import { IsMappedResult } from '../guard/type'
+import { IsMappedResult } from '../guard/kind'
 // ------------------------------------------------------------------
 // RemoveReadonly
 // ------------------------------------------------------------------
diff --git a/src/type/record/record.ts b/src/type/record/record.ts
index b4ff98460..e94902712 100644
--- a/src/type/record/record.ts
+++ b/src/type/record/record.ts
@@ -51,7 +51,7 @@ import { IsUndefined } from '../guard/value'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsInteger, IsLiteral, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion } from '../guard/type'
+import { IsInteger, IsLiteral, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion } from '../guard/kind'
 // ------------------------------------------------------------------
 // RecordCreateFromPattern
 // ------------------------------------------------------------------
@@ -62,15 +62,16 @@ function RecordCreateFromPattern(pattern: string, T: TSchema, options: ObjectOpt
     [Kind]: 'Record', 
     type: 'object', 
     patternProperties: { [pattern]: CloneType(T) } 
-  } as unknown as TRecord<TSchema, TSchema> 
+  } as never
 }
 // ------------------------------------------------------------------
 // RecordCreateFromKeys
 // ------------------------------------------------------------------
 // prettier-ignore
 function RecordCreateFromKeys(K: string[], T: TSchema, options: ObjectOptions): TObject<TProperties> {
-  const P = K.reduce((Acc, K) => ({ ...Acc, [K]: CloneType(T) }), {} as TProperties)
-  return Object(P, { ...options, [Hint]: 'Record' })
+  const Acc = {} as TProperties
+  for(const K2 of K) Acc[K2] = CloneType(T)
+  return Object(Acc, { ...options, [Hint]: 'Record' })
 }
 // ------------------------------------------------------------------
 // FromTemplateLiteralKey (Fast Inference)
@@ -91,7 +92,7 @@ function FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema>(K
     IsTemplateLiteralFinite(K)
       ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options)
       : RecordCreateFromPattern(K.pattern, T, options)
-  ) as TFromTemplateLiteralKey<K, T>
+  ) as never
 }
 // ------------------------------------------------------------------
 // FromEnumKey (Special Case)
@@ -118,7 +119,7 @@ type TFromUnionKey<K extends TSchema[], T extends TSchema, P extends TProperties
 )
 // prettier-ignore
 function FromUnionKey<K extends TSchema[], T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromUnionKey<K, T> {
-  return RecordCreateFromKeys(IndexPropertyKeys(Union(K)), T, options) as  TFromUnionKey<K, T>
+  return RecordCreateFromKeys(IndexPropertyKeys(Union(K)), T, options) as never
 }
 // ------------------------------------------------------------------
 // FromLiteralKey
@@ -129,7 +130,7 @@ type TFromLiteralKey<K extends TLiteralValue, T extends TSchema> = (
 )
 // prettier-ignore
 function FromLiteralKey<K extends TLiteralValue, T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromLiteralKey<K, T> {
-  return RecordCreateFromKeys([(K as string).toString()], T, options) as TFromLiteralKey<K, T>
+  return RecordCreateFromKeys([(K as string).toString()], T, options) as never
 }
 // ------------------------------------------------------------------
 // TFromRegExpKey
@@ -140,7 +141,7 @@ type TFromRegExpKey<_ extends TRegExp, T extends TSchema> = (
 )
 // prettier-ignore
 function FromRegExpKey<K extends TRegExp, T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromRegExpKey<K, T> {
-  return RecordCreateFromPattern(K.source, T, options) as TFromRegExpKey<K, T>
+  return RecordCreateFromPattern(K.source, T, options) as never
 }
 // ------------------------------------------------------------------
 // FromStringKey
@@ -152,7 +153,7 @@ type TFromStringKey<_ extends TString, T extends TSchema> = (
 // prettier-ignore
 function FromStringKey<K extends TString, T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromStringKey<K, T> {
   const pattern = IsUndefined(K.pattern) ? PatternStringExact : K.pattern
-  return RecordCreateFromPattern(pattern, T, options) as TFromStringKey<K, T>
+  return RecordCreateFromPattern(pattern, T, options) as never
 }
 // ------------------------------------------------------------------
 // FromIntegerKey
@@ -163,7 +164,7 @@ type TFromIntegerKey<_ extends TSchema, T extends TSchema> = (
 )
 // prettier-ignore
 function FromIntegerKey<K extends TInteger, T extends TSchema>(_: K, T: T, options: ObjectOptions): TFromIntegerKey<K, T> {
-  return RecordCreateFromPattern(PatternNumberExact, T, options) as TFromIntegerKey<K, T>
+  return RecordCreateFromPattern(PatternNumberExact, T, options) as never
 }
 // ------------------------------------------------------------------
 // FromNumberKey
@@ -174,7 +175,7 @@ type TFromNumberKey<_ extends TSchema, T extends TSchema> = (
 )
 // prettier-ignore
 function FromNumberKey<K extends TNumber, T extends TSchema>(_: K, T: T, options: ObjectOptions): TFromNumberKey<K, T> {
-  return RecordCreateFromPattern(PatternNumberExact, T, options) as TFromNumberKey<K, T>
+  return RecordCreateFromPattern(PatternNumberExact, T, options) as never
 }
 // ------------------------------------------------------------------
 // TRecord
@@ -220,5 +221,5 @@ export function Record<K extends TSchema, T extends TSchema>(K: K, T: T, options
     IsRegExp(K) ? FromRegExpKey(K, T, options) :
     IsString(K) ? FromStringKey(K, T, options) :
     Never(options)
-  ) as TRecordOrObject<K, T>
+  ) as never
 }
diff --git a/src/type/recursive/recursive.ts b/src/type/recursive/recursive.ts
index d1e14e264..46d28e98a 100644
--- a/src/type/recursive/recursive.ts
+++ b/src/type/recursive/recursive.ts
@@ -59,5 +59,5 @@ export function Recursive<T extends TSchema>(callback: (thisType: TThis) => T, o
   const thisType = callback({ [Kind]: 'This', $ref: `${options.$id}` } as any)
   thisType.$id = options.$id
   // prettier-ignore
-  return CloneType({ ...options, [Hint]: 'Recursive', ...thisType }) as unknown as TRecursive<T>
+  return CloneType({ ...options, [Hint]: 'Recursive', ...thisType }) as never
 }
diff --git a/src/type/required/required-from-mapped-result.ts b/src/type/required/required-from-mapped-result.ts
index bcf5780bf..1e382ac3d 100644
--- a/src/type/required/required-from-mapped-result.ts
+++ b/src/type/required/required-from-mapped-result.ts
@@ -45,9 +45,9 @@ type TFromProperties<
 function FromProperties<
   P extends TProperties
 >(P: P, options: SchemaOptions): TFromProperties<P> {
-  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-    return {...Acc, [K2]: Required(P[K2], options) }
-  }, {}) as TFromProperties<P>
+  const Acc = {} as TProperties
+  for(const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Required(P[K2], options)
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult
@@ -62,7 +62,7 @@ type TFromMappedResult<
 function FromMappedResult<
   R extends TMappedResult
 >(R: R, options: SchemaOptions): TFromMappedResult<R> {
-  return FromProperties(R.properties, options) as TFromMappedResult<R>
+  return FromProperties(R.properties, options) as never
 }
 // ------------------------------------------------------------------
 // TRequiredFromMappedResult
@@ -79,6 +79,6 @@ export function RequiredFromMappedResult<
   R extends TMappedResult,
   P extends TProperties = TFromMappedResult<R>
 >(R: R, options: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedResult(R, options) as unknown as P
-  return MappedResult(P) 
+  const P = FromMappedResult(R, options)
+  return MappedResult(P) as never
 }
diff --git a/src/type/required/required.ts b/src/type/required/required.ts
index 56220759b..9bbad39c7 100644
--- a/src/type/required/required.ts
+++ b/src/type/required/required.ts
@@ -46,7 +46,7 @@ import { RequiredFromMappedResult, type TRequiredFromMappedResult } from './requ
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/type'
+import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/kind'
 // ------------------------------------------------------------------
 // FromRest
 // ------------------------------------------------------------------
@@ -58,7 +58,7 @@ type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (
 )
 // prettier-ignore
 function FromRest<T extends TSchema[]>(T: [...T]) : TFromRest<T> {
-  return T.map(L => RequiredResolve(L)) as TFromRest<T>
+  return T.map(L => RequiredResolve(L)) as never
 }
 // ------------------------------------------------------------------
 // FromProperties
@@ -73,9 +73,9 @@ type TFromProperties<T extends TProperties> = Evaluate<{
 }>
 // prettier-ignore
 function FromProperties<T extends TProperties>(T: T) {
-  return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K) => {
-    return { ...Acc, [K]: Discard(T[K], [OptionalKind]) as TSchema }
-  }, {} as TProperties)
+  const Acc = {} as TProperties
+  for(const K of globalThis.Object.getOwnPropertyNames(T)) Acc[K] = Discard(T[K], [OptionalKind]) as TSchema
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // RequiredResolve
@@ -88,7 +88,7 @@ function RequiredResolve<T extends TSchema>(T: T): TRequired<T> {
     IsUnion(T) ?  Union(FromRest(T.anyOf)) :
     IsObject(T) ? Object(FromProperties(T.properties)) :
     Object({})
-  ) as TRequired<T>
+  ) as never
 }
 // ------------------------------------------------------------------
 // TRequired
diff --git a/src/type/rest/rest.ts b/src/type/rest/rest.ts
index e12d787b8..86593daac 100644
--- a/src/type/rest/rest.ts
+++ b/src/type/rest/rest.ts
@@ -35,7 +35,7 @@ import { CloneRest } from '../clone/type'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsIntersect, IsUnion, IsTuple } from '../guard/type'
+import { IsIntersect, IsUnion, IsTuple } from '../guard/kind'
 // ------------------------------------------------------------------
 // RestResolve
 // ------------------------------------------------------------------
@@ -48,11 +48,11 @@ type TRestResolve<T extends TSchema> =
 // prettier-ignore
 function RestResolve<T extends TSchema>(T: T) {
   return (
-    IsIntersect(T) ? [...T.allOf] : 
-    IsUnion(T) ? [...T.anyOf] : 
-    IsTuple(T) ? [...(T.items ?? [])] : 
+    IsIntersect(T) ? CloneRest(T.allOf) : 
+    IsUnion(T) ? CloneRest(T.anyOf) : 
+    IsTuple(T) ? CloneRest(T.items ?? []) : 
     []
-  ) as TRestResolve<T>
+  ) as never
 }
 // ------------------------------------------------------------------
 // TRest
diff --git a/src/type/sets/set.ts b/src/type/sets/set.ts
index 70b1e02ee..35b697975 100644
--- a/src/type/sets/set.ts
+++ b/src/type/sets/set.ts
@@ -40,7 +40,7 @@ export type TSetIncludes<T extends PropertyKey[], S extends PropertyKey> = (
 /** Returns true if element right is in the set of left */
 // prettier-ignore
 export function SetIncludes<T extends PropertyKey[], S extends PropertyKey>(T: [...T], S: S): TSetIncludes<T, S> {
-  return T.includes(S) as TSetIncludes<T, S>
+  return T.includes(S) as never
 }
 // ------------------------------------------------------------------
 // SetIsSubset
@@ -55,7 +55,7 @@ export type TSetIsSubset<T extends PropertyKey[], S extends PropertyKey[]> = (
 )
 /** Returns true if left is a subset of right */
 export function SetIsSubset<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetIsSubset<T, S> {
-  return T.every((L) => SetIncludes(S, L)) as TSetIsSubset<T, S>
+  return T.every((L) => SetIncludes(S, L)) as never
 }
 // ------------------------------------------------------------------
 // SetDistinct
@@ -69,7 +69,7 @@ export type TSetDistinct<T extends PropertyKey[], Acc extends PropertyKey[] = []
     : Acc
 /** Returns a distinct set of elements */
 export function SetDistinct<T extends PropertyKey[]>(T: [...T]): TSetDistinct<T> {
-  return [...new Set(T)] as TSetDistinct<T>
+  return [...new Set(T)] as never
 }
 // ------------------------------------------------------------------
 // SetIntersect
@@ -84,7 +84,7 @@ export type TSetIntersect<T extends PropertyKey[], S extends PropertyKey[], Acc
 )
 /** Returns the Intersect of the given sets */
 export function SetIntersect<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetIntersect<T, S> {
-  return T.filter((L) => S.includes(L)) as TSetIntersect<T, S>
+  return T.filter((L) => S.includes(L)) as never
 }
 // ------------------------------------------------------------------
 // SetUnion
@@ -111,7 +111,7 @@ export type TSetComplement<T extends PropertyKey[], S extends PropertyKey[], Acc
 /** Returns the Complement by omitting elements in T that are in S */
 // prettier-ignore
 export function SetComplement<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetComplement<T, S> {
-  return T.filter(L => !S.includes(L)) as TSetComplement<T, S>
+  return T.filter(L => !S.includes(L)) as never
 }
 // ------------------------------------------------------------------
 // SetIntersectMany
@@ -146,7 +146,7 @@ export function SetIntersectMany<T extends PropertyKey[][]>(T: [...T]): TSetInte
       : T.length > 1
         ? SetIntersectManyResolve(T.slice(1), T[0])
         : []
-  ) as TSetIntersectMany<T>
+  ) as never
 }
 // ------------------------------------------------------------------
 // SetUnionMany
@@ -159,5 +159,7 @@ export type TSetUnionMany<T extends PropertyKey[][], Acc extends PropertyKey[] =
 )
 /** Returns the Union of multiple sets */
 export function SetUnionMany<T extends PropertyKey[][]>(T: [...T]): TSetUnionMany<T> {
-  return T.reduce((Acc, L) => [...Acc, ...L], [] as PropertyKey[]) as TSetUnionMany<T>
+  const Acc = [] as PropertyKey[]
+  for (const L of T) Acc.push(...L)
+  return Acc as never
 }
diff --git a/src/type/string/string.ts b/src/type/string/string.ts
index 77d1c10ee..97ee88fc2 100644
--- a/src/type/string/string.ts
+++ b/src/type/string/string.ts
@@ -82,5 +82,5 @@ export interface TString extends TSchema, StringOptions {
 
 /** `[Json]` Creates a String type */
 export function String(options: StringOptions = {}): TString {
-  return { ...options, [Kind]: 'String', type: 'string' } as unknown as TString
+  return { ...options, [Kind]: 'String', type: 'string' } as never
 }
diff --git a/src/type/symbol/symbol.ts b/src/type/symbol/symbol.ts
index 02712500c..f7e86697d 100644
--- a/src/type/symbol/symbol.ts
+++ b/src/type/symbol/symbol.ts
@@ -37,5 +37,5 @@ export interface TSymbol extends TSchema, SchemaOptions {
 }
 /** `[JavaScript]` Creates a Symbol type */
 export function Symbol(options?: SchemaOptions): TSymbol {
-  return { ...options, [Kind]: 'Symbol', type: 'symbol' } as unknown as TSymbol
+  return { ...options, [Kind]: 'Symbol', type: 'symbol' } as never
 }
diff --git a/src/type/template-literal/generate.ts b/src/type/template-literal/generate.ts
index 23a56790b..9bc857fd7 100644
--- a/src/type/template-literal/generate.ts
+++ b/src/type/template-literal/generate.ts
@@ -144,5 +144,5 @@ export function TemplateLiteralGenerate<T extends TTemplateLiteral>(schema: T):
     IsTemplateLiteralExpressionFinite(expression)
      ? [...TemplateLiteralExpressionGenerate(expression)]
      : []
-  ) as TTemplateLiteralGenerate<T>
+  ) as never
 }
diff --git a/src/type/template-literal/pattern.ts b/src/type/template-literal/pattern.ts
index 099ee1b5f..03ab3c76f 100644
--- a/src/type/template-literal/pattern.ts
+++ b/src/type/template-literal/pattern.ts
@@ -35,17 +35,7 @@ import { TypeBoxError } from '../error/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
-import {
-  IsTemplateLiteral,
-  IsUnion,
-  IsNumber,
-  IsInteger,
-  IsBigInt,
-  IsString,
-  IsLiteral,
-  IsBoolean
-} from '../guard/type'
+import { IsTemplateLiteral, IsUnion, IsNumber, IsInteger, IsBigInt, IsString, IsLiteral, IsBoolean } from '../guard/kind'
 
 // ------------------------------------------------------------------
 // TemplateLiteralPatternError
diff --git a/src/type/template-literal/template-literal.ts b/src/type/template-literal/template-literal.ts
index 2003e68a2..8798b3083 100644
--- a/src/type/template-literal/template-literal.ts
+++ b/src/type/template-literal/template-literal.ts
@@ -94,7 +94,7 @@ export function TemplateLiteral<T extends string>(syntax: T, options?: SchemaOpt
 export function TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>
 /** `[Json]` Creates a TemplateLiteral type */
 // prettier-ignore
-export function TemplateLiteral(unresolved: TTemplateLiteralKind[] | string, options: SchemaOptions = {}) {
+export function TemplateLiteral(unresolved: TTemplateLiteralKind[] | string, options: SchemaOptions = {}): any {
   const pattern = IsString(unresolved) 
     ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved)) 
     : TemplateLiteralPattern(unresolved as TTemplateLiteralKind[])
diff --git a/src/type/transform/transform.ts b/src/type/transform/transform.ts
index bdd575e5b..345726c61 100644
--- a/src/type/transform/transform.ts
+++ b/src/type/transform/transform.ts
@@ -34,7 +34,7 @@ import { CloneType } from '../clone/type'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsTransform } from '../guard/type'
+import { IsTransform } from '../guard/kind'
 
 // ------------------------------------------------------------------
 // TransformBuilders
@@ -56,13 +56,13 @@ export class TransformEncodeBuilder<T extends TSchema, D extends TransformFuncti
   }
   private EncodeSchema<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E, schema: TSchema) {
     const Codec = { Decode: this.decode, Encode: encode }
-    return { ...schema as TSchema, [TransformKind]: Codec }
+    return { ...schema, [TransformKind]: Codec }
   }
   public Encode<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E): TTransform<T, ReturnType<D>> {
     const schema = CloneType(this.schema)
     return (
       IsTransform(schema) ? this.EncodeTransform(encode, schema): this.EncodeSchema(encode, schema)
-    ) as unknown as TTransform<T, ReturnType<D>>
+    ) as never
   }
 }
 // ------------------------------------------------------------------
diff --git a/src/type/tuple/tuple.ts b/src/type/tuple/tuple.ts
index bd4f8400f..193b3c840 100644
--- a/src/type/tuple/tuple.ts
+++ b/src/type/tuple/tuple.ts
@@ -60,5 +60,5 @@ export function Tuple<T extends TSchema[]>(items: [...T], options: SchemaOptions
     items.length > 0 ?
       { ...options, [Kind]: 'Tuple', type: 'array', items: CloneRest(items), additionalItems, minItems, maxItems } :
       { ...options, [Kind]: 'Tuple', type: 'array', minItems, maxItems }
-  ) as unknown as TTuple<T>
+  ) as never
 }
diff --git a/src/type/uint8array/uint8array.ts b/src/type/uint8array/uint8array.ts
index fa0fb5501..55458346c 100644
--- a/src/type/uint8array/uint8array.ts
+++ b/src/type/uint8array/uint8array.ts
@@ -40,5 +40,5 @@ export interface TUint8Array extends TSchema, Uint8ArrayOptions {
 }
 /** `[JavaScript]` Creates a Uint8Array type */
 export function Uint8Array(options: Uint8ArrayOptions = {}): TUint8Array {
-  return { ...options, [Kind]: 'Uint8Array', type: 'Uint8Array' } as unknown as TUint8Array
+  return { ...options, [Kind]: 'Uint8Array', type: 'Uint8Array' } as never
 }
diff --git a/src/type/undefined/undefined.ts b/src/type/undefined/undefined.ts
index 69614443a..bbba2b4bf 100644
--- a/src/type/undefined/undefined.ts
+++ b/src/type/undefined/undefined.ts
@@ -36,5 +36,5 @@ export interface TUndefined extends TSchema {
 }
 /** `[JavaScript]` Creates a Undefined type */
 export function Undefined(options: SchemaOptions = {}): TUndefined {
-  return { ...options, [Kind]: 'Undefined', type: 'undefined' } as unknown as TUndefined
+  return { ...options, [Kind]: 'Undefined', type: 'undefined' } as never
 }
diff --git a/src/type/union/union-create.ts b/src/type/union/union-create.ts
index 48df85256..86093fe58 100644
--- a/src/type/union/union-create.ts
+++ b/src/type/union/union-create.ts
@@ -32,5 +32,5 @@ import { TUnion } from './union-type'
 import { Kind } from '../symbols/index'
 
 export function UnionCreate<T extends TSchema[]>(T: [...T], options: SchemaOptions): TUnion<T> {
-  return { ...options, [Kind]: 'Union', anyOf: CloneRest(T) } as unknown as TUnion<T>
+  return { ...options, [Kind]: 'Union', anyOf: CloneRest(T) } as never
 }
diff --git a/src/type/union/union-evaluated.ts b/src/type/union/union-evaluated.ts
index 5bac5539f..afbf4714f 100644
--- a/src/type/union/union-evaluated.ts
+++ b/src/type/union/union-evaluated.ts
@@ -39,7 +39,7 @@ import { UnionCreate } from './union-create'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsOptional } from '../guard/type'
+import { IsOptional } from '../guard/kind'
 // ------------------------------------------------------------------
 // IsUnionOptional
 // ------------------------------------------------------------------
@@ -53,7 +53,7 @@ type TIsUnionOptional<T extends TSchema[]> = (
 )
 // prettier-ignore
 function IsUnionOptional<T extends TSchema[]>(T: T): TIsUnionOptional<T> {
-  return T.some(L => IsOptional(L)) as TIsUnionOptional<T>
+  return T.some(L => IsOptional(L)) as never
 }
 // ------------------------------------------------------------------
 // RemoveOptionalFromRest
@@ -68,7 +68,7 @@ type TRemoveOptionalFromRest<T extends TSchema[], Acc extends TSchema[] = []> =
 )
 // prettier-ignore
 function RemoveOptionalFromRest<T extends TSchema[]>(T: T): TRemoveOptionalFromRest<T> {
-  return T.map(L => IsOptional(L) ? RemoveOptionalFromType(L) : L) as TRemoveOptionalFromRest<T>
+  return T.map(L => IsOptional(L) ? RemoveOptionalFromType(L) : L) as never
 }
 // ------------------------------------------------------------------
 // RemoveOptionalFromType
@@ -83,7 +83,7 @@ type TRemoveOptionalFromType<T extends TSchema> = (
 function RemoveOptionalFromType<T extends TSchema>(T: T): TRemoveOptionalFromType<T> {
   return (
     Discard(T, [OptionalKind])
-  ) as TRemoveOptionalFromType<T>
+  ) as never
 }
 // ------------------------------------------------------------------
 // ResolveUnion
@@ -100,7 +100,7 @@ function ResolveUnion<T extends TSchema[]>(T: T, options: SchemaOptions): TResol
     IsUnionOptional(T)
       ? Optional(UnionCreate(RemoveOptionalFromRest(T) as TSchema[], options))
       : UnionCreate(RemoveOptionalFromRest(T) as TSchema[], options)
-  ) as TResolveUnion<T>
+  ) as never
 }
 // ------------------------------------------------------------------
 // Union
@@ -118,5 +118,5 @@ export function UnionEvaluated<T extends TSchema[], R = TUnionEvaluated<T>>(T: [
     T.length === 0 ? Never(options) :
     T.length === 1 ? CloneType(T[0], options) :
     ResolveUnion(T, options)
-  ) as R
+  ) as never
 }
diff --git a/src/type/unknown/unknown.ts b/src/type/unknown/unknown.ts
index 974e4ade1..28dce27be 100644
--- a/src/type/unknown/unknown.ts
+++ b/src/type/unknown/unknown.ts
@@ -38,5 +38,5 @@ export function Unknown(options: SchemaOptions = {}): TUnknown {
   return {
     ...options,
     [Kind]: 'Unknown',
-  } as unknown as TUnknown
+  } as never
 }
diff --git a/src/type/unsafe/unsafe.ts b/src/type/unsafe/unsafe.ts
index 7faf6154a..f70ec80fc 100644
--- a/src/type/unsafe/unsafe.ts
+++ b/src/type/unsafe/unsafe.ts
@@ -41,5 +41,5 @@ export function Unsafe<T>(options: UnsafeOptions = {}): TUnsafe<T> {
   return {
     ...options,
     [Kind]: options[Kind] ?? 'Unsafe',
-  } as unknown as TUnsafe<T>
+  } as never
 }
diff --git a/src/type/void/void.ts b/src/type/void/void.ts
index 4cf4ae501..c7f704d13 100644
--- a/src/type/void/void.ts
+++ b/src/type/void/void.ts
@@ -40,5 +40,5 @@ export function Void(options: SchemaOptions = {}): TVoid {
     ...options,
     [Kind]: 'Void',
     type: 'void',
-  } as unknown as TVoid
+  } as never
 }
diff --git a/src/value/clean/clean.ts b/src/value/clean/clean.ts
index e913b4a67..589d3170b 100644
--- a/src/value/clean/clean.ts
+++ b/src/value/clean/clean.ts
@@ -105,7 +105,7 @@ function FromObject(schema: TObject, references: TSchema[], value: unknown): any
 function FromRecord(schema: TRecord, references: TSchema[], value: unknown): any {
   if (!IsObject(value)) return value
   const additionalProperties = schema.additionalProperties as TSchema
-  const propertyKeys = Object.keys(value)
+  const propertyKeys = Object.getOwnPropertyNames(value)
   const [propertyKey, propertySchema] = Object.entries(schema.patternProperties)[0]
   const propertyKeyTest = new RegExp(propertyKey)
   for (const key of propertyKeys) {
diff --git a/src/value/clone/clone.ts b/src/value/clone/clone.ts
index f9f64f4cd..3bec35c88 100644
--- a/src/value/clone/clone.ts
+++ b/src/value/clone/clone.ts
@@ -36,8 +36,14 @@ import { IsArray, IsDate, IsStandardObject, IsTypedArray, IsValueType } from '..
 // Clonable
 // ------------------------------------------------------------------
 function ObjectType(value: ObjectType): any {
-  const keys = [...Object.getOwnPropertyNames(value), ...Object.getOwnPropertySymbols(value)]
-  return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {})
+  const Acc = {} as Record<PropertyKey, unknown>
+  for (const key of Object.getOwnPropertyNames(value)) {
+    Acc[key] = Clone(value[key])
+  }
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    Acc[key] = Clone(value[key])
+  }
+  return Acc
 }
 function ArrayType(value: ArrayType): any {
   return value.map((element: any) => Clone(element))
diff --git a/src/value/create/create.ts b/src/value/create/create.ts
index 2b2ef63ea..008105bff 100644
--- a/src/value/create/create.ts
+++ b/src/value/create/create.ts
@@ -242,12 +242,12 @@ function FromObject(schema: TObject, references: TSchema[]): any {
     return FromDefault(schema.default)
   } else {
     const required = new Set(schema.required)
-    return (
-      FromDefault(schema.default) ||
-      Object.entries(schema.properties).reduce((acc, [key, schema]) => {
-        return required.has(key) ? { ...acc, [key]: Visit(schema, references) } : { ...acc }
-      }, {})
-    )
+    const Acc = {} as Record<PropertyKey, unknown>
+    for (const [key, subschema] of Object.entries(schema.properties)) {
+      if (!required.has(key)) continue
+      Acc[key] = Visit(subschema, references)
+    }
+    return Acc
   }
 }
 function FromPromise(schema: TPromise, references: TSchema[]): any {
@@ -263,9 +263,9 @@ function FromRecord(schema: TRecord, references: TSchema[]): any {
     return FromDefault(schema.default)
   } else if (!(keyPattern === PatternStringExact || keyPattern === PatternNumberExact)) {
     const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|')
-    return propertyKeys.reduce((acc, key) => {
-      return { ...acc, [key]: Visit(valueSchema, references) }
-    }, {})
+    const Acc = {} as Record<PropertyKey, unknown>
+    for (const key of propertyKeys) Acc[key] = Visit(valueSchema, references)
+    return Acc
   } else {
     return {}
   }
diff --git a/src/value/hash/hash.ts b/src/value/hash/hash.ts
index beb159d09..faa1f66ea 100644
--- a/src/value/hash/hash.ts
+++ b/src/value/hash/hash.ts
@@ -107,7 +107,7 @@ function NumberType(value: number) {
 }
 function ObjectType(value: Record<string, unknown>) {
   FNV1A64(ByteMarker.Object)
-  for (const key of globalThis.Object.keys(value).sort()) {
+  for (const key of globalThis.Object.getOwnPropertyNames(value).sort()) {
     Visit(key)
     Visit(value[key])
   }
diff --git a/src/value/mutate/mutate.ts b/src/value/mutate/mutate.ts
index 45791bc24..0ae01a6fe 100644
--- a/src/value/mutate/mutate.ts
+++ b/src/value/mutate/mutate.ts
@@ -47,8 +47,8 @@ function ObjectType(root: Mutable, path: string, current: unknown, next: Record<
   if (!IsStandardObject(current)) {
     ValuePointer.Set(root, path, Clone(next))
   } else {
-    const currentKeys = Object.keys(current)
-    const nextKeys = Object.keys(next)
+    const currentKeys = Object.getOwnPropertyNames(current)
+    const nextKeys = Object.getOwnPropertyNames(next)
     for (const currentKey of currentKeys) {
       if (!nextKeys.includes(currentKey)) {
         delete current[currentKey]
diff --git a/src/value/transform/decode.ts b/src/value/transform/decode.ts
index 02982d0fd..00edd6d98 100644
--- a/src/value/transform/decode.ts
+++ b/src/value/transform/decode.ts
@@ -99,21 +99,19 @@ function FromArray(schema: TArray, references: TSchema[], path: string, value: a
 function FromIntersect(schema: TIntersect, references: TSchema[], path: string, value: any) {
   if (!IsStandardObject(value) || IsValueType(value)) return Default(schema, path, value)
   const knownKeys = KeyOfPropertyKeys(schema) as string[]
-  const knownProperties = knownKeys.reduce((value, key) => {
-    return (key in value)
-      ? { ...value, [key]: Visit(Index(schema, [key]), references, `${path}/${key}`, value[key]) }
-      : value
-  }, value)
+  const knownProperties = { ...value } as Record<PropertyKey, unknown>
+  for(const key of knownKeys) if(key in knownProperties) {
+    knownProperties[key] = Visit(Index(schema, [key]), references, `${path}/${key}`, knownProperties[key])
+  }
   if (!IsTransform(schema.unevaluatedProperties)) {
     return Default(schema, path, knownProperties)
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties)
   const unevaluatedProperties = schema.unevaluatedProperties as TSchema
-  const unknownProperties = unknownKeys.reduce((value, key) => {
-    return !knownKeys.includes(key)
-      ? { ...value, [key]: Default(unevaluatedProperties, `${path}/${key}`, value[key]) }
-      : value
-  }, knownProperties)
+  const unknownProperties = { ...knownProperties } as Record<PropertyKey, unknown>
+  for(const key of unknownKeys) if(!knownKeys.includes(key)) {
+    unknownProperties[key] = Default(unevaluatedProperties, `${path}/${key}`, unknownProperties[key])
+  }
   return Default(schema, path, unknownProperties)
 }
 function FromNot(schema: TNot, references: TSchema[], path: string, value: any) {
@@ -123,21 +121,19 @@ function FromNot(schema: TNot, references: TSchema[], path: string, value: any)
 function FromObject(schema: TObject, references: TSchema[], path: string, value: any) {
   if (!IsStandardObject(value)) return Default(schema, path, value)
   const knownKeys = KeyOfPropertyKeys(schema)
-  const knownProperties = knownKeys.reduce((value, key) => {
-    return (key in value) 
-      ? { ...value, [key]: Visit(schema.properties[key], references, `${path}/${key}`, value[key]) }  
-      : value
-  }, value)
+  const knownProperties = { ...value } as Record<PropertyKey, unknown>
+  for(const key of knownKeys) if(key in knownProperties) {
+    knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key])
+  }
   if (!IsSchema(schema.additionalProperties)) {
     return Default(schema, path, knownProperties)
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties)
   const additionalProperties = schema.additionalProperties as TSchema
-  const unknownProperties = unknownKeys.reduce((value, key) => {
-    return !knownKeys.includes(key)
-    ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
-    : value
-  }, knownProperties)
+  const unknownProperties = { ...knownProperties } as Record<PropertyKey, unknown>
+  for(const key of unknownKeys) if(!knownKeys.includes(key)) {
+    unknownProperties[key] = Default(additionalProperties, `${path}/${key}`, unknownProperties[key])
+  }
   return Default(schema, path, unknownProperties)
 }
 // prettier-ignore
@@ -145,21 +141,19 @@ function FromRecord(schema: TRecord, references: TSchema[], path: string, value:
   if (!IsStandardObject(value)) return Default(schema, path, value)
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
   const knownKeys = new RegExp(pattern)
-  const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
-    return knownKeys.test(key) 
-      ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, `${path}/${key}`, value[key]) }
-      : value
-  }, value)
+  const knownProperties = { ...value } as Record<PropertyKey, unknown>
+  for(const key of Object.getOwnPropertyNames(value)) if(knownKeys.test(key)) {
+    knownProperties[key] = Visit(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key])
+  }
   if (!IsSchema(schema.additionalProperties)) {
     return Default(schema, path, knownProperties)
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties)
   const additionalProperties = schema.additionalProperties as TSchema
-  const unknownProperties = unknownKeys.reduce((value, key) => {
-    return !knownKeys.test(key)
-    ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
-    : value
-  }, knownProperties)
+  const unknownProperties = {...knownProperties} as Record<PropertyKey, unknown>
+  for(const key of unknownKeys) if(!knownKeys.test(key)) {
+    unknownProperties[key] = Default(additionalProperties, `${path}/${key}`, unknownProperties[key])
+  }
   return Default(schema, path, unknownProperties)
 }
 // prettier-ignore
diff --git a/src/value/transform/encode.ts b/src/value/transform/encode.ts
index 2a2b8f465..be1a507b9 100644
--- a/src/value/transform/encode.ts
+++ b/src/value/transform/encode.ts
@@ -100,21 +100,20 @@ function FromIntersect(schema: TIntersect, references: TSchema[], path: string,
   const defaulted = Default(schema, path, value)
   if (!IsStandardObject(value) || IsValueType(value)) return defaulted
   const knownKeys = KeyOfPropertyKeys(schema) as string[]
-  const knownProperties = knownKeys.reduce((value, key) => {
-    return key in defaulted 
-      ? { ...value, [key]: Visit(Index(schema, [key]), references, `${path}/${key}`, value[key]) } 
-      : value
-  }, defaulted)
+  const knownProperties = { ...defaulted } as Record<PropertyKey, unknown>
+  for(const key of knownKeys) if(key in knownProperties) {
+    knownProperties[key] = Visit(Index(schema, [key]), references, `${path}/${key}`, knownProperties[key])
+  }
   if (!IsTransform(schema.unevaluatedProperties)) {
     return Default(schema, path, knownProperties)
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties)
   const unevaluatedProperties = schema.unevaluatedProperties as TSchema
-  return unknownKeys.reduce((value, key) => {
-    return !knownKeys.includes(key) 
-      ? { ...value, [key]: Default(unevaluatedProperties, `${path}/${key}`, value[key]) }  
-      : value
-  }, knownProperties)
+  const properties = { ...knownProperties } as Record<PropertyKey, unknown>
+  for(const key of unknownKeys) if(!knownKeys.includes(key)) {
+    properties[key] = Default(unevaluatedProperties, `${path}/${key}`, properties[key])
+  }
+  return properties
 }
 // prettier-ignore
 function FromNot(schema: TNot, references: TSchema[], path: string, value: any) {
@@ -125,21 +124,20 @@ function FromObject(schema: TObject, references: TSchema[], path: string, value:
   const defaulted = Default(schema, path, value)
   if (!IsStandardObject(value)) return defaulted
   const knownKeys = KeyOfPropertyKeys(schema) as string[]
-  const knownProperties = knownKeys.reduce((value, key) => {
-    return key in value 
-      ? { ...value, [key]: Visit(schema.properties[key], references, `${path}/${key}`, value[key]) } 
-      : value
-  }, defaulted)
+  const knownProperties = { ...defaulted } as Record<PropertyKey, unknown>
+  for(const key of knownKeys) if(key in value) {
+    knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key])
+  }
   if (!IsSchema(schema.additionalProperties)) {
     return knownProperties
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties)
   const additionalProperties = schema.additionalProperties as TSchema
-  return unknownKeys.reduce((value, key) => {
-    return !knownKeys.includes(key) 
-      ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }  
-      : value
-  }, knownProperties)
+  const properties = { ...knownProperties } as Record<PropertyKey, unknown>
+  for(const key of unknownKeys) if(!knownKeys.includes(key)) {
+    properties[key] = Default(additionalProperties, `${path}/${key}`, properties[key])
+  }
+  return properties
 }
 // prettier-ignore
 function FromRecord(schema: TRecord, references: TSchema[], path: string, value: any) {
@@ -147,21 +145,20 @@ function FromRecord(schema: TRecord, references: TSchema[], path: string, value:
   if (!IsStandardObject(value)) return defaulted
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
   const knownKeys = new RegExp(pattern)
-  const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
-    return knownKeys.test(key) 
-      ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, `${path}/${key}`, value[key]) }
-      : value
-  }, defaulted)
+  const knownProperties = {...defaulted } as Record<PropertyKey, unknown>
+  for(const key of Object.getOwnPropertyNames(value)) if(knownKeys.test(key)) {
+    knownProperties[key] = Visit(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key])
+  }
   if (!IsSchema(schema.additionalProperties)) {
     return Default(schema, path, knownProperties)
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties)
   const additionalProperties = schema.additionalProperties as TSchema
-  return unknownKeys.reduce((value, key) => {
-    return !knownKeys.test(key) 
-      ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }  
-      : value
-  }, knownProperties)
+  const properties = { ...knownProperties } as Record<PropertyKey, unknown>
+  for(const key of unknownKeys) if(!knownKeys.test(key)) {
+    properties[key] = Default(additionalProperties, `${path}/${key}`, properties[key])
+  }
+  return properties
 }
 // prettier-ignore
 function FromRef(schema: TRef, references: TSchema[], path: string, value: any) {
diff --git a/test/runtime/type/guard/index.ts b/test/runtime/type/guard/index.ts
index 271b53f88..2a6bdd114 100644
--- a/test/runtime/type/guard/index.ts
+++ b/test/runtime/type/guard/index.ts
@@ -1,52 +1,3 @@
-import './any'
-import './array'
-import './async-iterator'
-import './awaited'
-import './bigint'
-import './boolean'
-import './capitalize'
-import './composite'
-import './const'
-import './constructor'
-import './date'
-import './deref'
-import './enum'
-import './exclude'
-import './extract'
-import './function'
-import './indexed'
-import './integer'
-import './intersect'
-import './iterator'
-import './keyof'
-import './kind'
-import './literal'
-import './lowercase'
-import './mapped'
-import './not'
-import './null'
-import './number'
-import './object'
-import './omit'
-import './partial'
-import './pick'
-import './promise'
-import './record'
-import './recursive'
-import './ref'
-import './regexp'
-import './required'
-import './rest'
-import './string'
-import './symbol'
-import './template-literal'
-import './this'
-import './tuple'
-import './uint8array'
-import './uncapitalize'
-import './undefined'
-import './union'
-import './unknown'
-import './unsafe'
-import './uppercase'
-import './void'
+import './type/index'
+import './kind/index'
+import './value/index'
diff --git a/test/runtime/type/guard/kind/any.ts b/test/runtime/type/guard/kind/any.ts
new file mode 100644
index 000000000..87a860a0a
--- /dev/null
+++ b/test/runtime/type/guard/kind/any.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TAny', () => {
+  it('Should guard for TAny', () => {
+    const R = KindGuard.IsAny(Type.Any())
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TAny', () => {
+    const R = KindGuard.IsAny(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/array.ts b/test/runtime/type/guard/kind/array.ts
new file mode 100644
index 000000000..6f7ce4454
--- /dev/null
+++ b/test/runtime/type/guard/kind/array.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TArray', () => {
+  it('Should guard for TArray', () => {
+    const R = KindGuard.IsArray(Type.Array(Type.Number()))
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TArray', () => {
+    const R = KindGuard.IsArray(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/async-iterator.ts b/test/runtime/type/guard/kind/async-iterator.ts
new file mode 100644
index 000000000..3e6d16e8d
--- /dev/null
+++ b/test/runtime/type/guard/kind/async-iterator.ts
@@ -0,0 +1,16 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TAsyncIterator', () => {
+  it('Should guard for TAsyncIterator', () => {
+    const T = Type.AsyncIterator(Type.Any())
+    const R = KindGuard.IsAsyncIterator(T)
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TAsyncIterator', () => {
+    const T = null
+    const R = KindGuard.IsAsyncIterator(T)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/awaited.ts b/test/runtime/type/guard/kind/awaited.ts
new file mode 100644
index 000000000..021c7f62d
--- /dev/null
+++ b/test/runtime/type/guard/kind/awaited.ts
@@ -0,0 +1,41 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/Awaited', () => {
+  it('Should guard for Awaited 1', () => {
+    const T = Type.Awaited(Type.String())
+    const R = KindGuard.IsString(T)
+    Assert.IsTrue(R)
+  })
+  it('Should guard for Awaited 2', () => {
+    const T = Type.Awaited(Type.Promise(Type.String()))
+    const R = KindGuard.IsString(T)
+    Assert.IsTrue(R)
+  })
+  it('Should guard for Awaited 3', () => {
+    const T = Type.Awaited(Type.Awaited(Type.Promise(Type.String())))
+    const R = KindGuard.IsString(T)
+    Assert.IsTrue(R)
+  })
+  it('Should guard for Awaited 4', () => {
+    const T = Type.Awaited(Type.Union([Type.Promise(Type.Promise(Type.String()))]))
+    Assert.IsTrue(KindGuard.IsString(T))
+  })
+  it('Should guard for Awaited 5', () => {
+    const T = Type.Awaited(Type.Union([Type.Promise(Type.Promise(Type.String())), Type.Number()]))
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsTrue(KindGuard.IsString(T.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsNumber(T.anyOf[1]))
+  })
+  it('Should guard for Awaited 6', () => {
+    const T = Type.Awaited(Type.Intersect([Type.Promise(Type.Promise(Type.String()))]))
+    Assert.IsTrue(KindGuard.IsString(T))
+  })
+  it('Should guard for Awaited 7', () => {
+    const T = Type.Awaited(Type.Intersect([Type.Promise(Type.Promise(Type.String())), Type.Number()]))
+    Assert.IsTrue(KindGuard.IsIntersect(T))
+    Assert.IsTrue(KindGuard.IsString(T.allOf[0]))
+    Assert.IsTrue(KindGuard.IsNumber(T.allOf[1]))
+  })
+})
diff --git a/test/runtime/type/guard/kind/bigint.ts b/test/runtime/type/guard/kind/bigint.ts
new file mode 100644
index 000000000..33e89b2be
--- /dev/null
+++ b/test/runtime/type/guard/kind/bigint.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TBigInt', () => {
+  it('Should guard for TBigInt', () => {
+    const R = KindGuard.IsBigInt(Type.BigInt())
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TBigInt', () => {
+    const R = KindGuard.IsBigInt(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/boolean.ts b/test/runtime/type/guard/kind/boolean.ts
new file mode 100644
index 000000000..abdfd262d
--- /dev/null
+++ b/test/runtime/type/guard/kind/boolean.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TBoolean', () => {
+  it('Should guard for TBoolean', () => {
+    const R = KindGuard.IsBoolean(Type.Boolean())
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TBoolean', () => {
+    const R = KindGuard.IsBoolean(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/capitalize.ts b/test/runtime/type/guard/kind/capitalize.ts
new file mode 100644
index 000000000..373937702
--- /dev/null
+++ b/test/runtime/type/guard/kind/capitalize.ts
@@ -0,0 +1,33 @@
+import { KindGuard, Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/Capitalize', () => {
+  it('Should guard for Capitalize 1', () => {
+    const T = Type.Capitalize(Type.Literal('hello'), { $id: 'hello', foo: 1 })
+    Assert.IsTrue(KindGuard.IsLiteral(T))
+    Assert.IsEqual(T.const, 'Hello')
+    Assert.IsEqual(T.$id, 'hello')
+    Assert.IsEqual(T.foo, 1)
+  })
+  it('Should guard for Capitalize 2', () => {
+    const T = Type.Capitalize(Type.Literal('hello'))
+    Assert.IsTrue(KindGuard.IsLiteral(T))
+    Assert.IsEqual(T.const, 'Hello')
+  })
+  it('Should guard for Capitalize 3', () => {
+    const T = Type.Capitalize(Type.Union([Type.Literal('hello'), Type.Literal('world')]))
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'Hello')
+    Assert.IsEqual(T.anyOf[1].const, 'World')
+  })
+  it('Should guard for Capitalize 4', () => {
+    const T = Type.Capitalize(Type.TemplateLiteral('hello${0|1}'))
+    Assert.IsTrue(KindGuard.IsTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(Hello0|Hello1)$')
+  })
+  it('Should guard for Capitalize 5', () => {
+    const T = Type.Capitalize(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(0), Type.Literal(1)])]))
+    Assert.IsTrue(KindGuard.IsTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(Hello0|Hello1)$')
+  })
+})
diff --git a/test/runtime/type/guard/kind/composite.ts b/test/runtime/type/guard/kind/composite.ts
new file mode 100644
index 000000000..bd709667e
--- /dev/null
+++ b/test/runtime/type/guard/kind/composite.ts
@@ -0,0 +1,165 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TComposite', () => {
+  it('Should guard for distinct properties', () => {
+    const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.x))
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.y))
+  })
+  it('Should guard for overlapping properties', () => {
+    const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.Number() })])
+    Assert.IsTrue(KindGuard.IsIntersect(T.properties.x))
+    // @ts-ignore
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.x.allOf[0]))
+    // @ts-ignore
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.x.allOf[1]))
+  })
+  it('Should not produce optional property if all properties are not optional', () => {
+    const T = Type.Composite([Type.Object({ x: Type.Optional(Type.Number()) }), Type.Object({ x: Type.Number() })])
+    Assert.IsFalse(KindGuard.IsOptional(T.properties.x))
+  })
+  // Note for: https://github.com/sinclairzx81/typebox/issues/419
+  // Determining if a composite property is optional requires a deep check for all properties gathered during a indexed access
+  // call. Currently, there isn't a trivial way to perform this check without running into possibly infinite instantiation issues.
+  // The optional check is only specific to overlapping properties. Singular properties will continue to work as expected. The
+  // rule is "if all composite properties for a key are optional, then the composite property is optional". Defer this test and
+  // document as minor breaking change.
+  //
+  it('Should produce optional property if all composited properties are optional', () => {
+    // prettier-ignore
+    const T = Type.Composite([
+      Type.Object({ x: Type.Optional(Type.Number()) }), 
+      Type.Object({ x: Type.Optional(Type.Number()) })
+    ])
+    Assert.IsTrue(KindGuard.IsOptional(T.properties.x))
+    Assert.IsEqual(T.required, undefined)
+  })
+  // prettier-ignore
+  it('Should produce required property if some composited properties are not optional', () => {
+    const T = Type.Composite([
+      Type.Object({ x: Type.Optional(Type.Number()) }), 
+      Type.Object({ x: Type.Number() })
+    ])
+    Assert.IsFalse(KindGuard.IsOptional(T.properties.x))
+    Assert.IsTrue(T.required!.includes('x'))
+  })
+  // prettier-ignore
+  it('Should preserve single optional property', () => {
+    const T = Type.Composite([
+      Type.Object({ x: Type.Optional(Type.Number()) }), 
+    ])
+    Assert.IsTrue(KindGuard.IsOptional(T.properties.x))
+    Assert.IsEqual(T.required, undefined)
+  })
+  // ----------------------------------------------------------------
+  // Intersect
+  // ----------------------------------------------------------------
+  // prettier-ignore
+  it('Should composite Intersect 1', () => {
+    const T = Type.Composite([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() }),
+      ]),
+      Type.Intersect([
+        Type.Object({ z: Type.Number() }),
+      ])
+    ])
+    Assert.IsEqual(T, Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number()
+    }))
+  })
+  // prettier-ignore
+  it('Should composite Intersect 2', () => {
+    const T = Type.Composite([
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ x: Type.Number() }),
+      ]),
+      Type.Intersect([
+        Type.Object({ x: Type.Number() }),
+      ])
+    ])
+    Assert.IsEqual(T, Type.Object({
+      x: Type.Intersect([Type.Intersect([Type.Number(), Type.Number()]), Type.Number()])
+    }))
+  })
+  // prettier-ignore
+  it('Should composite Intersect 3', () => {
+    const T = Type.Composite([
+      Type.Number(),
+      Type.Boolean()
+    ])
+    Assert.IsEqual(T, Type.Object({}))
+  })
+  // prettier-ignore
+  it('Should composite Intersect 4', () => {
+    const T = Type.Composite([
+      Type.Number(),
+      Type.Boolean(),
+      Type.Object({ x: Type.String() })
+    ])
+    Assert.IsEqual(T, Type.Object({
+      x: Type.String()
+    }))
+  })
+  // prettier-ignore
+  it('Should composite Intersect 5', () => {
+    const T = Type.Composite([
+      Type.Object({ x: Type.Optional(Type.String()) }),
+      Type.Object({ x: Type.String() })
+    ])
+    Assert.IsEqual(T, Type.Object({
+      x: Type.Intersect([Type.String(), Type.String()])
+    }))
+  })
+  // prettier-ignore
+  it('Should composite Intersect 6', () => {
+    const T = Type.Composite([
+      Type.Object({ x: Type.Optional(Type.String()) }),
+      Type.Object({ x: Type.Optional(Type.String()) })
+    ])
+    Assert.IsEqual(T, Type.Object({
+      x: Type.Optional(Type.Intersect([Type.String(), Type.String()]))
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Union
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/789
+  // prettier-ignore
+  it('Should composite Union 1 (non-overlapping)', () => {
+    const T = Type.Composite([
+      Type.Union([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ y: Type.Number() }),
+      ]),
+      Type.Union([
+        Type.Object({ z: Type.Number() }),
+      ])
+    ])
+    Assert.IsEqual(T, Type.Object({
+      z: Type.Number()
+    }))
+  })
+  // https://github.com/sinclairzx81/typebox/issues/789
+  // prettier-ignore
+  it('Should composite Union 2 (overlapping)', () => {
+    const T = Type.Composite([
+      Type.Union([
+        Type.Object({ x: Type.Number() }),
+        Type.Object({ x: Type.Number() }),
+      ]),
+      Type.Union([
+        Type.Object({ x: Type.Number() }),
+      ])
+    ])
+    Assert.IsEqual(T, Type.Object({
+      x: Type.Intersect([Type.Union([Type.Number(), Type.Number()]), Type.Number()])
+    }))
+  })
+})
diff --git a/test/runtime/type/guard/kind/const.ts b/test/runtime/type/guard/kind/const.ts
new file mode 100644
index 000000000..cb2115c92
--- /dev/null
+++ b/test/runtime/type/guard/kind/const.ts
@@ -0,0 +1,124 @@
+import { KindGuard, ValueGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TConstT', () => {
+  // ----------------------------------------------------------------
+  // Identity Types
+  // ----------------------------------------------------------------
+  it('Should guard for TConst 1', () => {
+    const T = Type.Const(undefined)
+    Assert.IsFalse(KindGuard.IsReadonly(T))
+    Assert.IsTrue(KindGuard.IsUndefined(T))
+  })
+  it('Should guard for TConst 2', () => {
+    const T = Type.Const(null)
+    Assert.IsFalse(KindGuard.IsReadonly(T))
+    Assert.IsTrue(KindGuard.IsNull(T))
+  })
+  it('Should guard for TConst 3', () => {
+    const T = Type.Const(Symbol())
+    Assert.IsFalse(KindGuard.IsReadonly(T))
+    Assert.IsTrue(KindGuard.IsSymbol(T))
+  })
+  it('Should guard for TConst 4', () => {
+    const T = Type.Const(1 as const)
+    Assert.IsFalse(KindGuard.IsReadonly(T))
+    Assert.IsTrue(KindGuard.IsLiteral(T))
+    Assert.IsEqual(T.const, 1)
+  })
+  it('Should guard for TConst 5', () => {
+    const T = Type.Const('hello' as const)
+    Assert.IsFalse(KindGuard.IsReadonly(T))
+    Assert.IsTrue(KindGuard.IsLiteral(T))
+    Assert.IsEqual(T.const, 'hello')
+  })
+  it('Should guard for TConst 6', () => {
+    const T = Type.Const(true as const)
+    Assert.IsFalse(KindGuard.IsReadonly(T))
+    Assert.IsTrue(KindGuard.IsLiteral(T))
+    Assert.IsEqual(T.const, true)
+  })
+  // ----------------------------------------------------------------
+  // Complex Types
+  // ----------------------------------------------------------------
+  it('Should guard for TConst 7', () => {
+    const T = Type.Const(100n as const)
+    Assert.IsFalse(KindGuard.IsReadonly(T))
+    // TS disparity because TLiteral does not support Bigint
+    Assert.IsTrue(KindGuard.IsBigInt(T))
+  })
+  it('Should guard for TConst 8', () => {
+    const T = Type.Const(new Date())
+    Assert.IsFalse(KindGuard.IsReadonly(T))
+    Assert.IsTrue(KindGuard.IsDate(T))
+  })
+  it('Should guard for TConst 9', () => {
+    const T = Type.Const(new Uint8Array())
+    Assert.IsFalse(KindGuard.IsReadonly(T))
+    Assert.IsTrue(KindGuard.IsUint8Array(T))
+  })
+  it('Should guard for TConst 10', () => {
+    const T = Type.Const(function () {})
+    Assert.IsFalse(KindGuard.IsReadonly(T))
+    Assert.IsTrue(KindGuard.IsFunction(T))
+    Assert.IsTrue(T.parameters.length === 0)
+    Assert.IsTrue(KindGuard.IsUnknown(T.returns))
+  })
+  it('Should guard for TConst 11', () => {
+    const T = Type.Const(new (class {})())
+    Assert.IsFalse(KindGuard.IsReadonly(T))
+    Assert.IsTrue(KindGuard.IsObject(T))
+    // Object types that are neither Date or Uint8Array evaluate as empty objects
+    Assert.IsEqual(T.properties, {})
+  })
+  it('Should guard for TConst 12', () => {
+    const T = Type.Const((function* (): any {})())
+    const R = ValueGuard.IsIterator((function* (): any {})())
+    Assert.IsFalse(KindGuard.IsReadonly(T))
+    Assert.IsTrue(KindGuard.IsAny(T))
+  })
+  it('Should guard for TConst 13', () => {
+    const T = Type.Const((async function* (): any {})())
+    const R = ValueGuard.IsAsyncIterator((function* (): any {})())
+    Assert.IsFalse(KindGuard.IsReadonly(T))
+    Assert.IsTrue(KindGuard.IsAny(T))
+  })
+  it('Should guard for TConst 14', () => {
+    const T = Type.Const({
+      x: 1,
+      y: {
+        z: 2,
+      },
+    } as const)
+    // root
+    Assert.IsFalse(KindGuard.IsReadonly(T))
+    Assert.IsTrue(KindGuard.IsObject(T))
+    // x
+    Assert.IsTrue(KindGuard.IsLiteral(T.properties.x))
+    Assert.IsEqual(T.properties.x.const, 1)
+    // y
+    Assert.IsTrue(KindGuard.IsReadonly(T.properties.y))
+    Assert.IsTrue(KindGuard.IsObject(T.properties.y))
+    // y.z
+    Assert.IsTrue(KindGuard.IsReadonly(T.properties.y.properties.z))
+    Assert.IsTrue(KindGuard.IsLiteral(T.properties.y.properties.z))
+    Assert.IsEqual(T.properties.y.properties.z.const, 2)
+  })
+  it('Should guard for TConst 15', () => {
+    const T = Type.Const([1, 2, 3] as const)
+    // root (arrays are always readonly as root)
+    Assert.IsTrue(KindGuard.IsReadonly(T))
+    Assert.IsTrue(KindGuard.IsTuple(T))
+    Assert.IsTrue(T.items?.length === 3)
+    // 0
+    Assert.IsFalse(KindGuard.IsReadonly(T.items![0]))
+    Assert.IsTrue(KindGuard.IsLiteral(T.items![0]))
+    // 1
+    Assert.IsFalse(KindGuard.IsReadonly(T.items![1]))
+    Assert.IsTrue(KindGuard.IsLiteral(T.items![1]))
+    // 2
+    Assert.IsFalse(KindGuard.IsReadonly(T.items![2]))
+    Assert.IsTrue(KindGuard.IsLiteral(T.items![2]))
+  })
+})
diff --git a/test/runtime/type/guard/kind/constructor.ts b/test/runtime/type/guard/kind/constructor.ts
new file mode 100644
index 000000000..d2146aa7c
--- /dev/null
+++ b/test/runtime/type/guard/kind/constructor.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TConstructor', () => {
+  it('Should guard for TConstructor', () => {
+    const R = KindGuard.IsConstructor(Type.Constructor([], Type.Number()))
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TConstructor', () => {
+    const R = KindGuard.IsConstructor(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/date.ts b/test/runtime/type/guard/kind/date.ts
new file mode 100644
index 000000000..5e2d252a7
--- /dev/null
+++ b/test/runtime/type/guard/kind/date.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TDate', () => {
+  it('Should guard for TDate', () => {
+    const R = KindGuard.IsDate(Type.Date())
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TDate', () => {
+    const R = KindGuard.IsDate(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/deref.ts b/test/runtime/type/guard/kind/deref.ts
new file mode 100644
index 000000000..98e6811d9
--- /dev/null
+++ b/test/runtime/type/guard/kind/deref.ts
@@ -0,0 +1,110 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TDeref', () => {
+  it('Should should deref 1', () => {
+    const T = Type.String({ $id: 'T' })
+    const R = Type.Ref(T)
+    const D = Type.Deref(R, [T])
+    Assert.IsTrue(KindGuard.IsString(D))
+    Assert.IsFalse('$id' in D)
+  })
+  it('Should should deref 2', () => {
+    const T = Type.String({ $id: 'T' })
+    const R = Type.Ref(T)
+    const O = Type.Object({
+      x: R,
+      y: R,
+    })
+    const D = Type.Deref(O, [T])
+    Assert.IsTrue(KindGuard.IsObject(D))
+    Assert.IsTrue(KindGuard.IsString(D.properties.x))
+    Assert.IsTrue(KindGuard.IsString(D.properties.y))
+    Assert.IsFalse('$id' in D.properties.x)
+    Assert.IsFalse('$id' in D.properties.y)
+  })
+  it('Should should deref 3', () => {
+    const T = Type.String({ $id: 'T' })
+    const R = Type.Ref(T)
+    const O = Type.Array(R)
+    const D = Type.Deref(O, [T])
+    Assert.IsTrue(KindGuard.IsArray(D))
+    Assert.IsTrue(KindGuard.IsString(D.items))
+    Assert.IsFalse('$id' in D.items)
+  })
+  it('Should should deref 4', () => {
+    const T = Type.String({ $id: 'T' })
+    const R = Type.Ref(T)
+    const O = Type.AsyncIterator(R)
+    const D = Type.Deref(O, [T])
+    Assert.IsTrue(KindGuard.IsAsyncIterator(D))
+    Assert.IsTrue(KindGuard.IsString(D.items))
+    Assert.IsFalse('$id' in D.items)
+  })
+  it('Should should deref 5', () => {
+    const T = Type.String({ $id: 'T' })
+    const R = Type.Ref(T)
+    const O = Type.Iterator(R)
+    const D = Type.Deref(O, [T])
+    Assert.IsTrue(KindGuard.IsIterator(D))
+    Assert.IsTrue(KindGuard.IsString(D.items))
+    Assert.IsFalse('$id' in D.items)
+  })
+  it('Should should deref 6', () => {
+    const T = Type.String({ $id: 'T' })
+    const R = Type.Ref(T)
+    const O = Type.Function([R], R)
+    const D = Type.Deref(O, [T])
+    Assert.IsTrue(KindGuard.IsFunction(D))
+    Assert.IsTrue(KindGuard.IsString(D.parameters[0]))
+    Assert.IsTrue(KindGuard.IsString(D.returns))
+    Assert.IsFalse('$id' in D.parameters[0])
+    Assert.IsFalse('$id' in D.returns)
+  })
+  it('Should should deref 7', () => {
+    const T = Type.String({ $id: 'T' })
+    const R = Type.Ref(T)
+    const O = Type.Constructor([R], R)
+    const D = Type.Deref(O, [T])
+    Assert.IsTrue(KindGuard.IsConstructor(D))
+    Assert.IsTrue(KindGuard.IsString(D.parameters[0]))
+    Assert.IsTrue(KindGuard.IsString(D.returns))
+    Assert.IsFalse('$id' in D.parameters[0])
+    Assert.IsFalse('$id' in D.returns)
+  })
+  it('Should should deref 8', () => {
+    const T = Type.String({ $id: 'T' })
+    const R = Type.Ref(T)
+    const O = Type.Promise(R)
+    const D = Type.Deref(O, [T])
+    Assert.IsTrue(KindGuard.IsPromise(D))
+    Assert.IsTrue(KindGuard.IsString(D.item))
+    Assert.IsFalse('$id' in D.item)
+  })
+  it('Should should deref 9', () => {
+    const T = Type.String({ $id: 'T' })
+    const R1 = Type.Ref(T, { $id: 'R1' })
+    const R2 = Type.Ref(R1, { $id: 'R2' })
+    const R3 = Type.Ref(R2, { $id: 'R3' })
+    const R4 = Type.Ref(R3, { $id: 'R4' })
+    const R5 = Type.Ref(R4, { $id: 'R5' })
+    const R6 = Type.Ref(R5, { $id: 'R6' })
+    const O = Type.Array(R6)
+    const D = Type.Deref(O, [R6, R5, R4, R3, R2, R1, T])
+    Assert.IsTrue(KindGuard.IsArray(D))
+    Assert.IsTrue(KindGuard.IsString(D.items))
+    Assert.IsFalse('$id' in D.items)
+  })
+  it('Should should deref 10', () => {
+    const T = Type.String({ $id: 'T' })
+    const R1 = Type.Ref(T, { $id: 'R1' })
+    const R2 = Type.Ref(R1, { $id: 'R2' })
+    const R3 = Type.Ref(R2, { $id: 'R3' })
+    const R4 = Type.Ref(R3, { $id: 'R4' })
+    const R5 = Type.Ref(R4, { $id: 'R5' })
+    const R6 = Type.Ref(R5, { $id: 'R6' })
+    const O = Type.Array(R6)
+    Assert.Throws(() => Type.Deref(O, [R6, R5, R4, R3, R2, R1])) // Omit T
+  })
+})
diff --git a/test/runtime/type/guard/kind/enum.ts b/test/runtime/type/guard/kind/enum.ts
new file mode 100644
index 000000000..b47631cfa
--- /dev/null
+++ b/test/runtime/type/guard/kind/enum.ts
@@ -0,0 +1,143 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TEnum', () => {
+  // ----------------------------------------------------------------
+  // Options
+  // ----------------------------------------------------------------
+  it('Should guard for Options 1', () => {
+    const T = Type.Enum({ x: 1 }, { extra: 'hello', $id: 'T' })
+    Assert.IsEqual(T.extra, 'hello')
+    Assert.IsEqual(T.$id, 'T')
+  })
+  it('Should guard for Options 2', () => {
+    enum E {
+      x,
+    }
+    const T = Type.Enum(E, { extra: 'hello', $id: 'T' })
+    Assert.IsEqual(T.extra, 'hello')
+    Assert.IsEqual(T.$id, 'T')
+  })
+  it('Should guard for Options 3', () => {
+    enum E {}
+    const T = Type.Enum(E, { extra: 'hello', $id: 'T' })
+    Assert.IsEqual(T.extra, 'hello')
+    Assert.IsEqual(T.$id, 'T')
+  })
+  it('Should guard for Options 4', () => {
+    const T = Type.Enum({}, { extra: 'hello', $id: 'T' })
+    Assert.IsEqual(T.extra, 'hello')
+    Assert.IsEqual(T.$id, 'T')
+  })
+  // ----------------------------------------------------------------
+  // Empty
+  // ----------------------------------------------------------------
+  it('Should guard for Empty 1', () => {
+    const T = Type.Enum({})
+    Assert.IsTrue(KindGuard.IsNever(T))
+  })
+  it('Should guard for Empty 2', () => {
+    enum E {}
+    const T = Type.Enum(E)
+    Assert.IsTrue(KindGuard.IsNever(T))
+  })
+
+  // ----------------------------------------------------------------
+  // Enum
+  // ----------------------------------------------------------------
+  it('Should guard for TEnum Enum 0', () => {
+    enum E {}
+    const T = Type.Enum(E)
+    Assert.IsTrue(KindGuard.IsNever(T))
+  })
+  it('Should guard for TEnum Enum 1', () => {
+    enum E {
+      A,
+    }
+    const T = Type.Enum(E)
+    Assert.IsTrue(KindGuard.IsLiteral(T))
+    Assert.IsEqual(T.const, E.A)
+  })
+  it('Should guard for TEnum Enum 2', () => {
+    enum E {
+      A = 1,
+      B = 2,
+      C = 3,
+    }
+    const T = Type.Enum(E)
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, E.A)
+    Assert.IsEqual(T.anyOf[1].const, E.B)
+    Assert.IsEqual(T.anyOf[2].const, E.C)
+  })
+  it('Should guard for TEnum Enum 3', () => {
+    enum E {
+      A = 'X',
+      B = 'Y',
+      C = 'Z',
+    }
+    const T = Type.Enum(E)
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, E.A)
+    Assert.IsEqual(T.anyOf[1].const, E.B)
+    Assert.IsEqual(T.anyOf[2].const, E.C)
+  })
+  it('Should guard for TEnum Enum 4', () => {
+    enum E {
+      A = 'X',
+      B = 'Y',
+      C = 'X',
+    }
+    const T = Type.Enum(E)
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, E.A)
+    Assert.IsEqual(T.anyOf[1].const, E.B)
+    Assert.IsEqual(T.anyOf.length, 2)
+  })
+  // ----------------------------------------------------------------
+  // Object Literal
+  // ----------------------------------------------------------------
+  it('Should guard for TEnum Object Literal 0', () => {
+    const T = Type.Enum({})
+    Assert.IsTrue(KindGuard.IsNever(T))
+  })
+  it('Should guard for TEnum Object Literal 1', () => {
+    const T = Type.Enum({ A: 1 })
+    Assert.IsTrue(KindGuard.IsLiteral(T))
+    Assert.IsEqual(T.const, 1)
+  })
+  it('Should guard for TEnum Object Literal 2', () => {
+    const T = Type.Enum({
+      A: 1,
+      B: 2,
+      C: 3,
+    })
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 1)
+    Assert.IsEqual(T.anyOf[1].const, 2)
+    Assert.IsEqual(T.anyOf[2].const, 3)
+  })
+  it('Should guard for TEnum Object Literal 3', () => {
+    const T = Type.Enum({
+      A: 'X',
+      B: 'Y',
+      C: 'Z',
+    })
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'X')
+    Assert.IsEqual(T.anyOf[1].const, 'Y')
+    Assert.IsEqual(T.anyOf[2].const, 'Z')
+  })
+  it('Should guard for TEnum Object Literal 4', () => {
+    const T = Type.Enum({
+      A: 'X',
+      B: 'Y',
+      C: 'X',
+    })
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'X')
+    Assert.IsEqual(T.anyOf[1].const, 'Y')
+    Assert.IsEqual(T.anyOf.length, 2)
+  })
+})
diff --git a/test/runtime/type/guard/kind/exclude.ts b/test/runtime/type/guard/kind/exclude.ts
new file mode 100644
index 000000000..d3a19af16
--- /dev/null
+++ b/test/runtime/type/guard/kind/exclude.ts
@@ -0,0 +1,96 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TExclude', () => {
+  it('Should exclude string from number', () => {
+    const T = Type.Exclude(Type.String(), Type.Number())
+    Assert.IsTrue(KindGuard.IsString(T))
+  })
+  it('Should exclude string from string', () => {
+    const T = Type.Exclude(Type.String(), Type.String())
+    Assert.IsTrue(KindGuard.IsNever(T))
+  })
+  it('Should exclude string | number | boolean from string', () => {
+    const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsTrue(KindGuard.IsNumber(T.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsBoolean(T.anyOf[1]))
+  })
+  it('Should exclude string | number | boolean from string | boolean', () => {
+    const T = Type.Exclude(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Boolean()]))
+    Assert.IsTrue(KindGuard.IsNumber(T))
+  })
+  // ------------------------------------------------------------------------
+  // TemplateLiteral | TemplateLiteral
+  // ------------------------------------------------------------------------
+  it('Should exclude TemplateLiteral | TemplateLiteral 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const T = Type.Exclude(A, B)
+    Assert.IsTrue(KindGuard.IsNever(T))
+  })
+  it('Should exclude TemplateLiteral | TemplateLiteral 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+    const T = Type.Exclude(A, B)
+    Assert.IsTrue(['C'].includes(T.const))
+  })
+  it('Should exclude TemplateLiteral | TemplateLiteral 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
+    const T = Type.Exclude(A, B)
+    Assert.IsTrue(['C', 'B'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['C', 'B'].includes(T.anyOf[1].const))
+  })
+  // ------------------------------------------------------------------------
+  // TemplateLiteral | Union 1
+  // ------------------------------------------------------------------------
+  it('Should exclude TemplateLiteral | Union 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+    const T = Type.Exclude(A, B)
+    Assert.IsTrue(KindGuard.IsNever(T))
+  })
+  it('Should exclude TemplateLiteral | Union 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.Union([Type.Literal('A'), Type.Literal('B')])
+    const T = Type.Exclude(A, B)
+    Assert.IsTrue(['C'].includes(T.const))
+  })
+  it('Should exclude TemplateLiteral | Union 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.Union([Type.Literal('A')])
+    const T = Type.Exclude(A, B)
+    Assert.IsTrue(['C', 'B'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['C', 'B'].includes(T.anyOf[1].const))
+  })
+  // ------------------------------------------------------------------------
+  // Union | TemplateLiteral 1
+  // ------------------------------------------------------------------------
+  it('Should exclude Union | TemplateLiteral 1', () => {
+    const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const T = Type.Exclude(A, B)
+    Assert.IsTrue(KindGuard.IsNever(T))
+  })
+  it('Should exclude Union | TemplateLiteral 1', () => {
+    const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+    const T = Type.Exclude(A, B)
+    Assert.IsTrue(['C'].includes(T.const))
+  })
+  it('Should exclude Union | TemplateLiteral 1', () => {
+    const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
+    const T = Type.Exclude(A, B)
+    Assert.IsTrue(['C', 'B'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['C', 'B'].includes(T.anyOf[1].const))
+  })
+  it('Should exclude with options', () => {
+    const A = Type.String()
+    const B = Type.String()
+    const T = Type.Exclude(A, B, { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+})
diff --git a/test/runtime/type/guard/kind/extract.ts b/test/runtime/type/guard/kind/extract.ts
new file mode 100644
index 000000000..54f406380
--- /dev/null
+++ b/test/runtime/type/guard/kind/extract.ts
@@ -0,0 +1,102 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TExtract', () => {
+  it('Should extract string from number', () => {
+    const T = Type.Extract(Type.String(), Type.Number())
+    Assert.IsTrue(KindGuard.IsNever(T))
+  })
+  it('Should extract string from string', () => {
+    const T = Type.Extract(Type.String(), Type.String())
+    Assert.IsTrue(KindGuard.IsString(T))
+  })
+  it('Should extract string | number | boolean from string', () => {
+    const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.String())
+    Assert.IsTrue(KindGuard.IsString(T))
+  })
+  it('Should extract string | number | boolean from string | boolean', () => {
+    const T = Type.Extract(Type.Union([Type.String(), Type.Number(), Type.Boolean()]), Type.Union([Type.String(), Type.Boolean()]))
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsTrue(KindGuard.IsString(T.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsBoolean(T.anyOf[1]))
+  })
+  // ------------------------------------------------------------------------
+  // TemplateLiteral | TemplateLiteral
+  // ------------------------------------------------------------------------
+  it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const T = Type.Extract(A, B)
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[1].const))
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[2].const))
+  })
+  it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+    const T = Type.Extract(A, B)
+    Assert.IsTrue(['A', 'B'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['A', 'B'].includes(T.anyOf[1].const))
+  })
+  it('Should extract TemplateLiteral | TemplateLiteral 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
+    const T = Type.Extract(A, B)
+    Assert.IsTrue(['A'].includes(T.const))
+  })
+  // ------------------------------------------------------------------------
+  // TemplateLiteral | Union 1
+  // ------------------------------------------------------------------------
+  it('Should extract TemplateLiteral | Union 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+    const T = Type.Extract(A, B)
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[1].const))
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[2].const))
+  })
+  it('Should extract TemplateLiteral | Union 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.Union([Type.Literal('A'), Type.Literal('B')])
+    const T = Type.Extract(A, B)
+    Assert.IsTrue(['A', 'B'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['A', 'B'].includes(T.anyOf[1].const))
+  })
+  it('Should extract TemplateLiteral | Union 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const B = Type.Union([Type.Literal('A')])
+    const T = Type.Extract(A, B)
+    Assert.IsTrue(['A'].includes(T.const))
+  })
+  // ------------------------------------------------------------------------
+  // Union | TemplateLiteral 1
+  // ------------------------------------------------------------------------
+  it('Should extract Union | TemplateLiteral 1', () => {
+    const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])])
+    const T = Type.Extract(A, B)
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[1].const))
+    Assert.IsTrue(['A', 'B', 'C'].includes(T.anyOf[2].const))
+  })
+  it('Should extract Union | TemplateLiteral 1', () => {
+    const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+    const T = Type.Extract(A, B)
+    Assert.IsTrue(['A', 'B'].includes(T.anyOf[0].const))
+    Assert.IsTrue(['A', 'B'].includes(T.anyOf[1].const))
+  })
+  it('Should extract Union | TemplateLiteral 1', () => {
+    const A = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C')])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('A')])])
+    const T = Type.Extract(A, B)
+    Assert.IsTrue(['A'].includes(T.const))
+  })
+  it('Should extract with options', () => {
+    const A = Type.String()
+    const B = Type.String()
+    const T = Type.Extract(A, B, { foo: 'bar' })
+    Assert.IsEqual(T.foo, 'bar')
+  })
+})
diff --git a/test/runtime/type/guard/kind/function.ts b/test/runtime/type/guard/kind/function.ts
new file mode 100644
index 000000000..cf868c71d
--- /dev/null
+++ b/test/runtime/type/guard/kind/function.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TFunction', () => {
+  it('Should guard for TFunction', () => {
+    const R = KindGuard.IsFunction(Type.Function([], Type.Number()))
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TFunction', () => {
+    const R = KindGuard.IsFunction(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/index.ts b/test/runtime/type/guard/kind/index.ts
new file mode 100644
index 000000000..271b53f88
--- /dev/null
+++ b/test/runtime/type/guard/kind/index.ts
@@ -0,0 +1,52 @@
+import './any'
+import './array'
+import './async-iterator'
+import './awaited'
+import './bigint'
+import './boolean'
+import './capitalize'
+import './composite'
+import './const'
+import './constructor'
+import './date'
+import './deref'
+import './enum'
+import './exclude'
+import './extract'
+import './function'
+import './indexed'
+import './integer'
+import './intersect'
+import './iterator'
+import './keyof'
+import './kind'
+import './literal'
+import './lowercase'
+import './mapped'
+import './not'
+import './null'
+import './number'
+import './object'
+import './omit'
+import './partial'
+import './pick'
+import './promise'
+import './record'
+import './recursive'
+import './ref'
+import './regexp'
+import './required'
+import './rest'
+import './string'
+import './symbol'
+import './template-literal'
+import './this'
+import './tuple'
+import './uint8array'
+import './uncapitalize'
+import './undefined'
+import './union'
+import './unknown'
+import './unsafe'
+import './uppercase'
+import './void'
diff --git a/test/runtime/type/guard/kind/indexed.ts b/test/runtime/type/guard/kind/indexed.ts
new file mode 100644
index 000000000..4fc18ad3f
--- /dev/null
+++ b/test/runtime/type/guard/kind/indexed.ts
@@ -0,0 +1,327 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TIndex', () => {
+  it('Should Index 1', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+    })
+    const I = Type.Index(T, ['x'])
+    Assert.IsTrue(KindGuard.IsNumber(I))
+  })
+  it('Should Index 2', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+    })
+    const I = Type.Index(T, ['x', 'y'])
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsTrue(KindGuard.IsNumber(I.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsString(I.anyOf[1]))
+  })
+  it('Should Index 3', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+    })
+    const I = Type.Index(T, Type.KeyOf(T))
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsTrue(KindGuard.IsNumber(I.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsString(I.anyOf[1]))
+  })
+  it('Should Index 4', () => {
+    const T = Type.Object({
+      ab: Type.Number(),
+      ac: Type.String(),
+    })
+    const I = Type.Index(T, Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])]))
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsTrue(KindGuard.IsNumber(I.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsString(I.anyOf[1]))
+  })
+  it('Should Index 5', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.String() })])
+    const I = Type.Index(T, ['x', 'y'])
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsTrue(KindGuard.IsNumber(I.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsString(I.anyOf[1]))
+  })
+  it('Should Index 6', () => {
+    const T = Type.Union([Type.Object({ x: Type.Number() }), Type.Object({ x: Type.String() })])
+    const I = Type.Index(T, ['x'])
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsTrue(KindGuard.IsNumber(I.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsString(I.anyOf[1]))
+  })
+  it('Should Index 7', () => {
+    const T = Type.Array(Type.Null())
+    const I = Type.Index(T, Type.Number())
+    Assert.IsTrue(KindGuard.IsNull(I))
+  })
+  it('Should Index 6', () => {
+    const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
+    const I = Type.Index(T, [0])
+    Assert.IsTrue(KindGuard.IsLiteralString(I))
+    Assert.IsEqual(I.const, 'hello')
+  })
+  it('Should Index 8', () => {
+    const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
+    const I = Type.Index(T, [1])
+    Assert.IsTrue(KindGuard.IsLiteralString(I))
+    Assert.IsEqual(I.const, 'world')
+  })
+  it('Should Index 9', () => {
+    const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
+    const I = Type.Index(T, [0, 1])
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsEqual(I.anyOf[0].const, 'hello')
+    Assert.IsEqual(I.anyOf[1].const, 'world')
+  })
+  it('Should Index 10', () => {
+    const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
+    const I = Type.Index(T, [1, 0])
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsEqual(I.anyOf[0].const, 'world')
+    Assert.IsEqual(I.anyOf[1].const, 'hello')
+  })
+  it('Should Index 11', () => {
+    const T = Type.Tuple([Type.Literal('hello'), Type.Literal('world')])
+    const I = Type.Index(T, [0, 0, 0, 1])
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsEqual(I.anyOf[0].const, 'hello')
+    Assert.IsEqual(I.anyOf[1].const, 'hello')
+    Assert.IsEqual(I.anyOf[2].const, 'hello')
+    Assert.IsEqual(I.anyOf[3].const, 'world')
+  })
+  it('Should Index 12', () => {
+    const T = Type.Tuple([Type.String(), Type.Boolean()])
+    const I = Type.Index(T, Type.Number())
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsTrue(KindGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsBoolean(I.anyOf[1]))
+  })
+  it('Should Index 13', () => {
+    const T = Type.Tuple([Type.String()])
+    const I = Type.Index(T, Type.Number())
+    Assert.IsTrue(KindGuard.IsString(I))
+  })
+  it('Should Index 14', () => {
+    const T = Type.Tuple([])
+    const I = Type.Index(T, Type.Number())
+    Assert.IsTrue(KindGuard.IsNever(I))
+  })
+  it('Should Index 15', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+    })
+    const I = Type.Index(T, Type.Literal(0))
+    Assert.IsTrue(KindGuard.IsNumber(I))
+  })
+  it('Should Index 16', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+    })
+    const I = Type.Index(T, Type.Literal('0'))
+    Assert.IsTrue(KindGuard.IsNumber(I))
+  })
+  it('Should Index 17', () => {
+    const T = Type.Object({
+      '0': Type.Number(),
+    })
+    const I = Type.Index(T, Type.Literal(0))
+    Assert.IsTrue(KindGuard.IsNumber(I))
+  })
+  it('Should Index 18', () => {
+    const T = Type.Object({
+      '0': Type.Number(),
+    })
+    const I = Type.Index(T, Type.Literal('0'))
+    Assert.IsTrue(KindGuard.IsNumber(I))
+  })
+  it('Should Index 19', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+      1: Type.String(),
+      2: Type.Boolean(),
+    })
+    const I = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal(2)]))
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsTrue(KindGuard.IsNumber(I.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsBoolean(I.anyOf[1]))
+  })
+  it('Should Index 20', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+      1: Type.String(),
+      2: Type.Boolean(),
+    })
+    const I = Type.Index(T, Type.BigInt())
+    Assert.IsTrue(KindGuard.IsNever(I))
+  })
+  it('Should Index 21', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+      1: Type.String(),
+      2: Type.Boolean(),
+    })
+    const I = Type.Index(T, Type.Object({}))
+    Assert.IsTrue(KindGuard.IsNever(I))
+  })
+  it('Should Index 22', () => {
+    const A = Type.Object({ x: Type.Literal('A') })
+    const B = Type.Object({ x: Type.Literal('B') })
+    const C = Type.Object({ x: Type.Literal('C') })
+    const D = Type.Object({ x: Type.Literal('D') })
+    const T = Type.Intersect([A, B, C, D])
+    const I = Type.Index(T, ['x'])
+    Assert.IsTrue(KindGuard.IsIntersect(I))
+    Assert.IsTrue(KindGuard.IsLiteral(I.allOf[0]))
+    Assert.IsTrue(KindGuard.IsLiteral(I.allOf[1]))
+    Assert.IsTrue(KindGuard.IsLiteral(I.allOf[2]))
+    Assert.IsTrue(KindGuard.IsLiteral(I.allOf[3]))
+  })
+  it('Should Index 23', () => {
+    const A = Type.Object({ x: Type.Literal('A') })
+    const B = Type.Object({ x: Type.Literal('B') })
+    const C = Type.Object({ x: Type.Literal('C') })
+    const D = Type.Object({ x: Type.Literal('D') })
+    const T = Type.Union([A, B, C, D])
+    const I = Type.Index(T, ['x'])
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsTrue(KindGuard.IsLiteral(I.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsLiteral(I.anyOf[1]))
+    Assert.IsTrue(KindGuard.IsLiteral(I.anyOf[2]))
+    Assert.IsTrue(KindGuard.IsLiteral(I.anyOf[3]))
+  })
+  it('Should Index 24', () => {
+    const A = Type.Object({ x: Type.Literal('A'), y: Type.Number() })
+    const B = Type.Object({ x: Type.Literal('B') })
+    const C = Type.Object({ x: Type.Literal('C') })
+    const D = Type.Object({ x: Type.Literal('D') })
+    const T = Type.Intersect([A, B, C, D])
+    const I = Type.Index(T, ['x', 'y'])
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsTrue(KindGuard.IsIntersect(I.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsNumber(I.anyOf[1]))
+  })
+  it('Should Index 25', () => {
+    const A = Type.Object({ x: Type.Literal('A'), y: Type.Number() })
+    const B = Type.Object({ x: Type.Literal('B'), y: Type.String() })
+    const C = Type.Object({ x: Type.Literal('C') })
+    const D = Type.Object({ x: Type.Literal('D') })
+    const T = Type.Intersect([A, B, C, D])
+    const I = Type.Index(T, ['x', 'y'])
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsTrue(KindGuard.IsIntersect(I.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsIntersect(I.anyOf[1]))
+    Assert.IsTrue(KindGuard.IsNumber(I.anyOf[1].allOf[0]))
+    Assert.IsTrue(KindGuard.IsString(I.anyOf[1].allOf[1]))
+  })
+  it('Should Index 26', () => {
+    const T = Type.Recursive((This) =>
+      Type.Object({
+        x: Type.String(),
+        y: Type.Number(),
+        z: This,
+      }),
+    )
+    const I = Type.Index(T, ['x', 'y', 'z'])
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsTrue(KindGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsNumber(I.anyOf[1]))
+    Assert.IsTrue(KindGuard.IsThis(I.anyOf[2]))
+  })
+  it('Should Index 27', () => {
+    const T = Type.Object({
+      0: Type.String(),
+      1: Type.Number(),
+    })
+    const I = Type.Index(T, [0, 1])
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsTrue(KindGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsNumber(I.anyOf[1]))
+  })
+  it('Should Index 28', () => {
+    const T = Type.Object({
+      0: Type.String(),
+      '1': Type.Number(),
+    })
+    const I = Type.Index(T, [0, '1'])
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsTrue(KindGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsNumber(I.anyOf[1]))
+  })
+  it('Should Index 29', () => {
+    const T = Type.Object({
+      0: Type.String(),
+      '1': Type.Number(),
+    })
+    const I = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal('1')]))
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsTrue(KindGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsNumber(I.anyOf[1]))
+  })
+  it('Should Index 30', () => {
+    const T = Type.Object({
+      0: Type.String(),
+      '1': Type.Number(),
+    })
+    const I = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal(1)]))
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsTrue(KindGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsNumber(I.anyOf[1]))
+    // Note: Expect TNever for anyOf[1] but permit for TNumber due to IndexedAccess
+    // Resolve() which currently cannot differentiate between string and numeric keys
+    // on the object. This may be resolvable in later revisions, but test for this
+    // fall-through to ensure case is documented. For review.
+  })
+  // --------------------------------------------------------
+  // Modifier Optional Indexing
+  // --------------------------------------------------------
+  it('Should Index 31', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.String()),
+      y: Type.Number(),
+    })
+    const I = Type.Index(T, ['x'])
+    Assert.IsTrue(KindGuard.IsOptional(I))
+    Assert.IsTrue(KindGuard.IsString(I))
+  })
+  it('Should Index 32', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.String()),
+      y: Type.Number(),
+    })
+    const I = Type.Index(T, ['y'])
+    Assert.IsFalse(KindGuard.IsOptional(I))
+    Assert.IsTrue(KindGuard.IsNumber(I))
+  })
+  it('Should Index 33', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.String()),
+      y: Type.Number(),
+    })
+    const I = Type.Index(T, ['x', 'y'])
+    Assert.IsTrue(KindGuard.IsOptional(I))
+    Assert.IsTrue(KindGuard.IsUnion(I))
+    Assert.IsTrue(KindGuard.IsString(I.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsNumber(I.anyOf[1]))
+  })
+  it('Should Index 34', () => {
+    const T = Type.String()
+    const I = Type.Index(T, ['x'])
+    Assert.IsTrue(KindGuard.IsNever(I))
+  })
+  it('Should Index 35', () => {
+    const T = Type.Array(Type.String())
+    const I = Type.Index(T, Type.Number())
+    Assert.IsTrue(KindGuard.IsString(I))
+  })
+  it('Should Index 36', () => {
+    const T = Type.Array(Type.String())
+    const I = Type.Index(T, ['[number]'])
+    Assert.IsTrue(KindGuard.IsString(I))
+  })
+})
diff --git a/test/runtime/type/guard/kind/integer.ts b/test/runtime/type/guard/kind/integer.ts
new file mode 100644
index 000000000..a8fce9a9d
--- /dev/null
+++ b/test/runtime/type/guard/kind/integer.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TInteger', () => {
+  it('Should guard for TInteger', () => {
+    const R = KindGuard.IsInteger(Type.Integer())
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TInteger', () => {
+    const R = KindGuard.IsInteger(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/intersect.ts b/test/runtime/type/guard/kind/intersect.ts
new file mode 100644
index 000000000..f1678103f
--- /dev/null
+++ b/test/runtime/type/guard/kind/intersect.ts
@@ -0,0 +1,39 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TIntersect', () => {
+  it('Should guard for TIntersect', () => {
+    const R = KindGuard.IsIntersect(
+      Type.Intersect([
+        Type.Object({
+          x: Type.Number(),
+        }),
+        Type.Object({
+          y: Type.Number(),
+        }),
+      ]),
+    )
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TIntersect', () => {
+    const R = KindGuard.IsIntersect(
+      Type.Union([
+        Type.Object({
+          x: Type.Number(),
+        }),
+        Type.Object({
+          y: Type.Number(),
+        }),
+      ]),
+    )
+    Assert.IsFalse(R)
+  })
+  it('Should throw for intersected transform types', () => {
+    const N = Type.Transform(Type.Number())
+      .Decode((value) => value)
+      .Encode((value) => value)
+
+    Assert.Throws(() => Type.Intersect([N, N]))
+  })
+})
diff --git a/test/runtime/type/guard/kind/iterator.ts b/test/runtime/type/guard/kind/iterator.ts
new file mode 100644
index 000000000..5e650b41c
--- /dev/null
+++ b/test/runtime/type/guard/kind/iterator.ts
@@ -0,0 +1,16 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TIterator', () => {
+  it('Should guard for TIterator', () => {
+    const T = Type.Iterator(Type.Any())
+    const R = KindGuard.IsIterator(T)
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TIterator', () => {
+    const T = null
+    const R = KindGuard.IsIterator(T)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/keyof.ts b/test/runtime/type/guard/kind/keyof.ts
new file mode 100644
index 000000000..5d2867b3a
--- /dev/null
+++ b/test/runtime/type/guard/kind/keyof.ts
@@ -0,0 +1,76 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TKeyOf', () => {
+  it('Should KeyOf 1', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    })
+    const K = Type.KeyOf(T)
+    Assert.IsTrue(KindGuard.IsUnion(K))
+    Assert.IsTrue(KindGuard.IsLiteral(K.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsLiteral(K.anyOf[1]))
+  })
+  it('Should KeyOf 2', () => {
+    const T = Type.Recursive((Self) =>
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Array(Self),
+      }),
+    )
+    const K = Type.KeyOf(T)
+    Assert.IsTrue(KindGuard.IsUnion(K))
+    Assert.IsTrue(KindGuard.IsLiteral(K.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsLiteral(K.anyOf[1]))
+  })
+  it('Should KeyOf 3', () => {
+    const T = Type.Intersect([
+      Type.Object({
+        x: Type.Number(),
+      }),
+      Type.Object({
+        y: Type.Number(),
+      }),
+    ])
+    const K = Type.KeyOf(T)
+    Assert.IsTrue(KindGuard.IsUnion(K))
+    Assert.IsTrue(KindGuard.IsLiteral(K.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsLiteral(K.anyOf[1]))
+  })
+  it('Should KeyOf 4', () => {
+    const T = Type.Union([
+      Type.Object({
+        x: Type.Number(),
+      }),
+      Type.Object({
+        y: Type.Number(),
+      }),
+    ])
+    const K = Type.KeyOf(T)
+    Assert.IsTrue(KindGuard.IsNever(K))
+  })
+  it('Should KeyOf 5', () => {
+    const T = Type.Null()
+    const K = Type.KeyOf(T)
+    Assert.IsTrue(KindGuard.IsNever(K))
+  })
+  it('Should KeyOf 6', () => {
+    const T = Type.Array(Type.Number())
+    const K = Type.KeyOf(T)
+    Assert.IsTrue(KindGuard.IsNumber(K))
+  })
+  it('Should KeyOf 7', () => {
+    const T = Type.Tuple([])
+    const K = Type.KeyOf(T)
+    Assert.IsTrue(KindGuard.IsNever(K))
+  })
+  it('Should KeyOf 8', () => {
+    const T = Type.Tuple([Type.Number(), Type.Null()])
+    const K = Type.KeyOf(T)
+    Assert.IsTrue(KindGuard.IsUnion(K))
+    Assert.IsEqual(K.anyOf[0].const, '0')
+    Assert.IsEqual(K.anyOf[1].const, '1')
+  })
+})
diff --git a/test/runtime/type/guard/kind/kind.ts b/test/runtime/type/guard/kind/kind.ts
new file mode 100644
index 000000000..6ae707a6d
--- /dev/null
+++ b/test/runtime/type/guard/kind/kind.ts
@@ -0,0 +1,13 @@
+import { KindGuard, Kind } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TKind', () => {
+  it('Should guard 1', () => {
+    const T = { [Kind]: 'Kind' }
+    Assert.IsTrue(KindGuard.IsKind(T))
+  })
+  it('Should guard 2', () => {
+    const T = {}
+    Assert.IsFalse(KindGuard.IsKind(T))
+  })
+})
diff --git a/test/runtime/type/guard/kind/literal.ts b/test/runtime/type/guard/kind/literal.ts
new file mode 100644
index 000000000..413bc94b0
--- /dev/null
+++ b/test/runtime/type/guard/kind/literal.ts
@@ -0,0 +1,18 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TLiteral', () => {
+  it('Should guard for TLiteral of String', () => {
+    const R = KindGuard.IsLiteral(Type.Literal('hello'))
+    Assert.IsTrue(R)
+  })
+  it('Should guard for TLiteral of Number', () => {
+    const R = KindGuard.IsLiteral(Type.Literal(42))
+    Assert.IsTrue(R)
+  })
+  it('Should guard for TLiteral of Boolean', () => {
+    const R = KindGuard.IsLiteral(Type.Literal(true))
+    Assert.IsTrue(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/lowercase.ts b/test/runtime/type/guard/kind/lowercase.ts
new file mode 100644
index 000000000..d2ef0ccee
--- /dev/null
+++ b/test/runtime/type/guard/kind/lowercase.ts
@@ -0,0 +1,33 @@
+import { KindGuard, Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/Lowercase', () => {
+  it('Should guard for Lowercase 1', () => {
+    const T = Type.Lowercase(Type.Literal('HELLO'), { $id: 'hello', foo: 1 })
+    Assert.IsTrue(KindGuard.IsLiteral(T))
+    Assert.IsEqual(T.const, 'hello')
+    Assert.IsEqual(T.$id, 'hello')
+    Assert.IsEqual(T.foo, 1)
+  })
+  it('Should guard for Lowercase 2', () => {
+    const T = Type.Lowercase(Type.Literal('HELLO'))
+    Assert.IsTrue(KindGuard.IsLiteral(T))
+    Assert.IsEqual(T.const, 'hello')
+  })
+  it('Should guard for Lowercase 3', () => {
+    const T = Type.Lowercase(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD')]))
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'hello')
+    Assert.IsEqual(T.anyOf[1].const, 'world')
+  })
+  it('Should guard for Lowercase 4', () => {
+    const T = Type.Lowercase(Type.TemplateLiteral('HELLO${0|1}'))
+    Assert.IsTrue(KindGuard.IsTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(hello0|hello1)$')
+  })
+  it('Should guard for Lowercase 5', () => {
+    const T = Type.Lowercase(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(0), Type.Literal(1)])]))
+    Assert.IsTrue(KindGuard.IsTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(hello0|hello1)$')
+  })
+})
diff --git a/test/runtime/type/guard/mapped.ts b/test/runtime/type/guard/kind/mapped.ts
similarity index 99%
rename from test/runtime/type/guard/mapped.ts
rename to test/runtime/type/guard/kind/mapped.ts
index 1ab3daf9f..c4673e126 100644
--- a/test/runtime/type/guard/mapped.ts
+++ b/test/runtime/type/guard/kind/mapped.ts
@@ -1,8 +1,8 @@
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
 // prettier-ignore
-describe('type/guard/Mapped', () => {
+describe('guard/kind/Mapped', () => {
   it('Should guard mapped 1', () => {
     const T = Type.Mapped(Type.Union([
       Type.Literal('x'),
diff --git a/test/runtime/type/guard/kind/not.ts b/test/runtime/type/guard/kind/not.ts
new file mode 100644
index 000000000..a30c2e6dd
--- /dev/null
+++ b/test/runtime/type/guard/kind/not.ts
@@ -0,0 +1,10 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TNot', () => {
+  it('Should guard for TNot', () => {
+    const R = KindGuard.IsNot(Type.Not(Type.String()))
+    Assert.IsTrue(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/null.ts b/test/runtime/type/guard/kind/null.ts
new file mode 100644
index 000000000..81e29b0f3
--- /dev/null
+++ b/test/runtime/type/guard/kind/null.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TNull', () => {
+  it('Should guard for TNull', () => {
+    const R = KindGuard.IsNull(Type.Null())
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TNull', () => {
+    const R = KindGuard.IsNull(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/number.ts b/test/runtime/type/guard/kind/number.ts
new file mode 100644
index 000000000..00a992ba1
--- /dev/null
+++ b/test/runtime/type/guard/kind/number.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TNumber', () => {
+  it('Should guard for TNumber', () => {
+    const R = KindGuard.IsNumber(Type.Number())
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TNumber', () => {
+    const R = KindGuard.IsNumber(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/object.ts b/test/runtime/type/guard/kind/object.ts
new file mode 100644
index 000000000..f0c45189d
--- /dev/null
+++ b/test/runtime/type/guard/kind/object.ts
@@ -0,0 +1,19 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TObject', () => {
+  it('Should guard for TObject', () => {
+    const R = KindGuard.IsObject(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+    )
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TObject', () => {
+    const R = KindGuard.IsObject(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/omit.ts b/test/runtime/type/guard/kind/omit.ts
new file mode 100644
index 000000000..1aba2a82d
--- /dev/null
+++ b/test/runtime/type/guard/kind/omit.ts
@@ -0,0 +1,129 @@
+import { KindGuard, Type, Kind, TransformKind } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TOmit', () => {
+  // -------------------------------------------------------------------------
+  // case: https://github.com/sinclairzx81/typebox/issues/384
+  // -------------------------------------------------------------------------
+  it('Should support TUnsafe omit properties with no Kind', () => {
+    const T = Type.Omit(Type.Object({ x: Type.Unsafe({ x: 1 }), y: Type.Number() }), ['x'])
+    Assert.IsEqual(T.required, ['y'])
+  })
+  it('Should support TUnsafe omit properties with unregistered Kind', () => {
+    const T = Type.Omit(Type.Object({ x: Type.Unsafe({ x: 1, [Kind]: 'UnknownOmitType' }), y: Type.Number() }), ['x'])
+    Assert.IsEqual(T.required, ['y'])
+  })
+  // -------------------------------------------------------------------------
+  // Standard Tests
+  // -------------------------------------------------------------------------
+  it('Should Omit 1', () => {
+    const T = Type.Omit(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      ['x'],
+    )
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.y))
+    Assert.IsEqual(T.required, ['y'])
+  })
+  it('Should Omit 2', () => {
+    const T = Type.Omit(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Optional(Type.Number()),
+      }),
+      ['x'],
+    )
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.y))
+    Assert.IsEqual(T.required, undefined)
+  })
+  it('Should Omit 3', () => {
+    const L = Type.Literal('x')
+    const T = Type.Omit(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      L,
+    )
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.y))
+    Assert.IsEqual(T.required, ['y'])
+  })
+  it('Should Omit 4', () => {
+    const L = Type.Literal('x')
+    const T = Type.Omit(Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })]), L)
+    Assert.IsEqual(KindGuard.IsNumber(T.allOf[1].properties.y), true)
+    // @ts-ignore
+    Assert.IsEqual(T.allOf[1].properties.x, undefined)
+  })
+  it('Should Omit 5', () => {
+    const L = Type.Union([Type.Literal('x'), Type.Literal('y')])
+    const T = Type.Omit(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      L,
+    )
+    // @ts-ignore
+    Assert.IsEqual(T.properties.x, undefined)
+    // @ts-ignore
+    Assert.IsEqual(T.properties.y, undefined)
+    // @ts-ignore
+    Assert.IsEqual(T.required, undefined)
+  })
+  it('Should Omit 6', () => {
+    const L = Type.Union([Type.Literal('x'), Type.Literal('y'), Type.Literal('z')])
+    const T = Type.Omit(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      L,
+    )
+    // @ts-ignore
+    Assert.IsEqual(T.properties.x, undefined)
+    // @ts-ignore
+    Assert.IsEqual(T.properties.y, undefined)
+    // @ts-ignore
+    Assert.IsEqual(T.required, undefined)
+  })
+  it('Should Omit 7', () => {
+    const L = Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])])
+    const T = Type.Omit(
+      Type.Object({
+        ab: Type.Number(),
+        ac: Type.Number(),
+        ad: Type.Number(),
+      }),
+      L,
+    )
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.ad))
+    Assert.IsEqual(T.required, ['ad'])
+  })
+  // ----------------------------------------------------------------
+  // Discard
+  // ----------------------------------------------------------------
+  it('Should override $id', () => {
+    const A = Type.Object({ x: Type.Number() }, { $id: 'A' })
+    const T = Type.Omit(A, ['x'], { $id: 'T' })
+    Assert.IsEqual(T.$id!, 'T')
+  })
+  it('Should discard $id', () => {
+    const A = Type.Object({ x: Type.Number() }, { $id: 'A' })
+    const T = Type.Omit(A, ['x'])
+    Assert.IsFalse('$id' in T)
+  })
+  it('Should discard transform', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+    })
+    const S = Type.Transform(T)
+      .Decode((value) => value)
+      .Encode((value) => value)
+    const R = Type.Omit(S, ['x'])
+    Assert.IsFalse(TransformKind in R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/partial.ts b/test/runtime/type/guard/kind/partial.ts
new file mode 100644
index 000000000..6520da9d8
--- /dev/null
+++ b/test/runtime/type/guard/kind/partial.ts
@@ -0,0 +1,67 @@
+import { KindGuard, TypeRegistry, Type, Kind, TransformKind } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TPartial', () => {
+  it('Should produce a valid TSchema', () => {
+    const T = Type.Partial(Type.Object({ x: Type.Number() }))
+    Assert.IsTrue(KindGuard.IsSchema(T))
+  })
+  // -------------------------------------------------------------------------
+  // case: https://github.com/sinclairzx81/typebox/issues/364
+  // -------------------------------------------------------------------------
+  it('Should support TUnsafe partial properties with no Kind', () => {
+    const T = Type.Partial(Type.Object({ x: Type.Unsafe({ x: 1 }) }))
+    Assert.IsEqual(T.required, undefined)
+  })
+  it('Should support TUnsafe partial properties with unknown Kind', () => {
+    const T = Type.Partial(Type.Object({ x: Type.Unsafe({ [Kind]: 'UnknownPartialType', x: 1 }) }))
+    Assert.IsEqual(T.required, undefined)
+  })
+  it('Should support TUnsafe partial properties with known Kind', () => {
+    TypeRegistry.Set('KnownPartialType', () => true)
+    const T = Type.Partial(Type.Object({ x: Type.Unsafe({ [Kind]: 'KnownPartialType', x: 1 }) }))
+    Assert.IsEqual(T.required, undefined)
+  })
+  it('Should support applying partial to intersect', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const I = Type.Intersect([A, B])
+    const T = Type.Partial(I)
+    Assert.IsEqual(T.allOf.length, 2)
+    Assert.IsEqual(T.allOf[0].required, undefined)
+    Assert.IsEqual(T.allOf[1].required, undefined)
+  })
+  it('Should support applying partial to union', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.Number() })
+    const I = Type.Union([A, B])
+    const T = Type.Partial(I)
+    Assert.IsEqual(T.anyOf.length, 2)
+    Assert.IsEqual(T.anyOf[0].required, undefined)
+    Assert.IsEqual(T.anyOf[1].required, undefined)
+  })
+  // ----------------------------------------------------------------
+  // Discard
+  // ----------------------------------------------------------------
+  it('Should override $id', () => {
+    const A = Type.Object({ x: Type.Number() }, { $id: 'A' })
+    const T = Type.Partial(A, { $id: 'T' })
+    Assert.IsEqual(T.$id!, 'T')
+  })
+  it('Should discard $id', () => {
+    const A = Type.Object({ x: Type.Number() }, { $id: 'A' })
+    const T = Type.Partial(A)
+    Assert.IsFalse('$id' in T)
+  })
+  it('Should discard transform', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+    })
+    const S = Type.Transform(T)
+      .Decode((value) => value)
+      .Encode((value) => value)
+    const R = Type.Partial(S)
+    Assert.IsFalse(TransformKind in R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/pick.ts b/test/runtime/type/guard/kind/pick.ts
new file mode 100644
index 000000000..25bc99e06
--- /dev/null
+++ b/test/runtime/type/guard/kind/pick.ts
@@ -0,0 +1,131 @@
+import { KindGuard, Type, Kind, TransformKind } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TPick', () => {
+  // -------------------------------------------------------------------------
+  // case: https://github.com/sinclairzx81/typebox/issues/384
+  // -------------------------------------------------------------------------
+  it('Should support TUnsafe omit properties with no Kind', () => {
+    const T = Type.Pick(
+      Type.Object({
+        x: Type.Unsafe({ x: 1 }),
+        y: Type.Number(),
+      }),
+      ['x'],
+    )
+    Assert.IsEqual(T.required, ['x'])
+  })
+  it('Should support TUnsafe omit properties with unregistered Kind', () => {
+    const T = Type.Pick(Type.Object({ x: Type.Unsafe({ x: 1, [Kind]: 'UnknownPickType' }), y: Type.Number() }), ['x'])
+    Assert.IsEqual(T.required, ['x'])
+  })
+  // -------------------------------------------------------------------------
+  // Standard Tests
+  // -------------------------------------------------------------------------
+  it('Should Pick 1', () => {
+    const T = Type.Pick(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      ['x'],
+    )
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.x))
+    Assert.IsEqual(T.required, ['x'])
+  })
+  it('Should Pick 2', () => {
+    const T = Type.Pick(
+      Type.Object({
+        x: Type.Optional(Type.Number()),
+        y: Type.Number(),
+      }),
+      ['x'],
+    )
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.x))
+    Assert.IsEqual(T.required, undefined)
+  })
+  it('Should Pick 3', () => {
+    const L = Type.Literal('x')
+    const T = Type.Pick(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      L,
+    )
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.x))
+    Assert.IsEqual(T.required, ['x'])
+  })
+  it('Should Pick 4', () => {
+    const L = Type.Literal('x')
+    const T = Type.Pick(Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })]), L)
+
+    Assert.IsTrue(KindGuard.IsNumber(T.allOf[0].properties.x))
+    // @ts-ignore
+    Assert.IsEqual(T.allOf[1].properties.y, undefined)
+  })
+  it('Should Pick 5', () => {
+    const L = Type.Union([Type.Literal('x'), Type.Literal('y')])
+    const T = Type.Pick(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      L,
+    )
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.x))
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.y))
+    Assert.IsEqual(T.required, ['x', 'y'])
+  })
+  it('Should Pick 6', () => {
+    const L = Type.Union([Type.Literal('x'), Type.Literal('y'), Type.Literal('z')])
+    const T = Type.Pick(
+      Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      L,
+    )
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.x))
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.y))
+    Assert.IsEqual(T.required, ['x', 'y'])
+  })
+  it('Should Pick 7', () => {
+    const L = Type.TemplateLiteral([Type.Literal('a'), Type.Union([Type.Literal('b'), Type.Literal('c')])])
+    const T = Type.Pick(
+      Type.Object({
+        ab: Type.Number(),
+        ac: Type.Number(),
+        ad: Type.Number(),
+      }),
+      L,
+    )
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.ab))
+    Assert.IsTrue(KindGuard.IsNumber(T.properties.ac))
+    Assert.IsEqual(T.required, ['ab', 'ac'])
+  })
+  // ----------------------------------------------------------------
+  // Discard
+  // ----------------------------------------------------------------
+  it('Should override $id', () => {
+    const A = Type.Object({ x: Type.Number() }, { $id: 'A' })
+    const T = Type.Pick(A, ['x'], { $id: 'T' })
+    Assert.IsEqual(T.$id!, 'T')
+  })
+  it('Should discard $id', () => {
+    const A = Type.Object({ x: Type.Number() }, { $id: 'A' })
+    const T = Type.Pick(A, ['x'])
+    Assert.IsFalse('$id' in T)
+  })
+  it('Should discard transform', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+    })
+    const S = Type.Transform(T)
+      .Decode((value) => value)
+      .Encode((value) => value)
+    const R = Type.Pick(S, ['x'])
+    Assert.IsFalse(TransformKind in R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/promise.ts b/test/runtime/type/guard/kind/promise.ts
new file mode 100644
index 000000000..f59c94625
--- /dev/null
+++ b/test/runtime/type/guard/kind/promise.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TPromise', () => {
+  it('Should guard for TPromise', () => {
+    const R = KindGuard.IsPromise(Type.Promise(Type.Number()))
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TPromise', () => {
+    const R = KindGuard.IsPromise(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/record.ts b/test/runtime/type/guard/kind/record.ts
similarity index 98%
rename from test/runtime/type/guard/record.ts
rename to test/runtime/type/guard/kind/record.ts
index f0c11b6f9..12365ee3b 100644
--- a/test/runtime/type/guard/record.ts
+++ b/test/runtime/type/guard/kind/record.ts
@@ -1,8 +1,8 @@
 import { TypeGuard, PatternNumberExact, PatternStringExact, PatternString, PatternNumber } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TRecord', () => {
+describe('guard/kind/TRecord', () => {
   // -------------------------------------------------------------
   // Overloads
   // -------------------------------------------------------------
diff --git a/test/runtime/type/guard/kind/recursive.ts b/test/runtime/type/guard/kind/recursive.ts
new file mode 100644
index 000000000..81f8e41b9
--- /dev/null
+++ b/test/runtime/type/guard/kind/recursive.ts
@@ -0,0 +1,16 @@
+import { KindGuard, PatternNumberExact, PatternStringExact, PatternString, PatternNumber } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TRecursive', () => {
+  it('Should guard 1', () => {
+    const T = Type.Recursive((This) => Type.Object({ nodes: This }))
+    Assert.IsTrue(KindGuard.IsRecursive(T))
+    Assert.IsTrue(KindGuard.IsObject(T))
+  })
+  it('Should guard 2', () => {
+    const T = Type.Recursive((This) => Type.Tuple([This]))
+    Assert.IsTrue(KindGuard.IsRecursive(T))
+    Assert.IsTrue(KindGuard.IsTuple(T))
+  })
+})
diff --git a/test/runtime/type/guard/kind/ref.ts b/test/runtime/type/guard/kind/ref.ts
new file mode 100644
index 000000000..441d412cd
--- /dev/null
+++ b/test/runtime/type/guard/kind/ref.ts
@@ -0,0 +1,15 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TRef', () => {
+  it('Should guard for TRef', () => {
+    const T = Type.Number({ $id: 'T' })
+    const R = KindGuard.IsRef(Type.Ref(T))
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TRef', () => {
+    const R = KindGuard.IsRef(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/regexp.ts b/test/runtime/type/guard/kind/regexp.ts
new file mode 100644
index 000000000..a4f38143a
--- /dev/null
+++ b/test/runtime/type/guard/kind/regexp.ts
@@ -0,0 +1,18 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TRegExp', () => {
+  it('Should guard for TRegExp 1', () => {
+    const T = Type.RegExp(/foo/, { $id: 'T' })
+    Assert.IsTrue(KindGuard.IsSchema(T))
+  })
+  it('Should guard for TRegExp 1', () => {
+    const T = Type.RegExp(/foo/, { $id: 'T' })
+    Assert.IsTrue(KindGuard.IsRegExp(T))
+  })
+  it('Should guard for TRegExp 2', () => {
+    const T = Type.RegExp('foo', { $id: 'T' })
+    Assert.IsTrue(KindGuard.IsRegExp(T))
+  })
+})
diff --git a/test/runtime/type/guard/kind/required.ts b/test/runtime/type/guard/kind/required.ts
new file mode 100644
index 000000000..e795a05e1
--- /dev/null
+++ b/test/runtime/type/guard/kind/required.ts
@@ -0,0 +1,64 @@
+import { KindGuard, TypeRegistry, Type, Kind, TransformKind } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TRequired', () => {
+  it('Should produce a valid TSchema', () => {
+    const T = Type.Required(Type.Object({ x: Type.Number() }))
+    Assert.IsTrue(KindGuard.IsSchema(T))
+  })
+  it('Should support TUnsafe required properties with no Kind', () => {
+    const T = Type.Required(Type.Object({ x: Type.Optional(Type.Unsafe({ x: 1 })) }))
+    Assert.IsEqual(T.required, ['x'])
+  })
+  it('Should support TUnsafe required properties with unknown Kind', () => {
+    const T = Type.Required(Type.Object({ x: Type.Optional(Type.Unsafe({ [Kind]: 'UnknownRequiredType', x: 1 })) }))
+    Assert.IsEqual(T.required, ['x'])
+  })
+  it('Should support TUnsafe required properties with known Kind', () => {
+    TypeRegistry.Set('KnownRequiredType', () => true)
+    const T = Type.Required(Type.Object({ x: Type.Optional(Type.Unsafe({ [Kind]: 'KnownRequiredType', x: 1 })) }))
+    Assert.IsEqual(T.required, ['x'])
+  })
+  it('Should support applying required to intersect', () => {
+    const A = Type.Object({ x: Type.Optional(Type.Number()) })
+    const B = Type.Object({ y: Type.Optional(Type.Number()) })
+    const I = Type.Intersect([A, B])
+    const T = Type.Required(I)
+    Assert.IsEqual(T.allOf.length, 2)
+    Assert.IsEqual(T.allOf[0].required, ['x'])
+    Assert.IsEqual(T.allOf[1].required, ['y'])
+  })
+  it('Should support applying required to union', () => {
+    const A = Type.Object({ x: Type.Optional(Type.Number()) })
+    const B = Type.Object({ y: Type.Optional(Type.Number()) })
+    const I = Type.Union([A, B])
+    const T = Type.Required(I)
+    Assert.IsEqual(T.anyOf.length, 2)
+    Assert.IsEqual(T.anyOf[0].required, ['x'])
+    Assert.IsEqual(T.anyOf[1].required, ['y'])
+  })
+  // ----------------------------------------------------------------
+  // Discard
+  // ----------------------------------------------------------------
+  it('Should override $id', () => {
+    const A = Type.Object({ x: Type.Number() }, { $id: 'A' })
+    const T = Type.Required(A, { $id: 'T' })
+    Assert.IsEqual(T.$id!, 'T')
+  })
+  it('Should discard $id', () => {
+    const A = Type.Object({ x: Type.Number() }, { $id: 'A' })
+    const T = Type.Required(A)
+    Assert.IsFalse('$id' in T)
+  })
+  it('Should discard transform', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+    })
+    const S = Type.Transform(T)
+      .Decode((value) => value)
+      .Encode((value) => value)
+    const R = Type.Required(S)
+    Assert.IsFalse(TransformKind in R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/rest.ts b/test/runtime/type/guard/kind/rest.ts
new file mode 100644
index 000000000..bb63a4702
--- /dev/null
+++ b/test/runtime/type/guard/kind/rest.ts
@@ -0,0 +1,59 @@
+import { Type, KindGuard } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TRest', () => {
+  it('Should guard 1', () => {
+    // union never
+    const A = Type.String()
+    const B = Type.Union(Type.Rest(A))
+    Assert.IsTrue(KindGuard.IsNever(B))
+  })
+  it('Should guard 2', () => {
+    // intersect never
+    const A = Type.String()
+    const B = Type.Intersect(Type.Rest(A))
+    Assert.IsTrue(KindGuard.IsNever(B))
+  })
+  it('Should guard 3', () => {
+    // tuple
+    const A = Type.Tuple([Type.Number(), Type.String()])
+    const B = Type.Union(Type.Rest(A))
+    Assert.IsTrue(KindGuard.IsUnion(B))
+    Assert.IsEqual(B.anyOf.length, 2)
+    Assert.IsTrue(KindGuard.IsNumber(B.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsString(B.anyOf[1]))
+  })
+  it('Should guard 4', () => {
+    // tuple spread
+    const A = Type.Tuple([Type.Literal(1), Type.Literal(2)])
+    const B = Type.Tuple([Type.Literal(3), Type.Literal(4)])
+    const C = Type.Tuple([...Type.Rest(A), ...Type.Rest(B)])
+    Assert.IsTrue(KindGuard.IsTuple(C))
+    Assert.IsEqual(C.items!.length, 4)
+    Assert.IsEqual(C.items![0].const, 1)
+    Assert.IsEqual(C.items![1].const, 2)
+    Assert.IsEqual(C.items![2].const, 3)
+    Assert.IsEqual(C.items![3].const, 4)
+  })
+  it('Should guard 5', () => {
+    // union to intersect
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.String() })
+    const C = Type.Union([A, B])
+    const D = Type.Intersect(Type.Rest(C))
+    Assert.IsTrue(KindGuard.IsIntersect(D))
+    Assert.IsEqual(D.allOf.length, 2)
+    Assert.IsTrue(KindGuard.IsObject(D.allOf[0]))
+    Assert.IsTrue(KindGuard.IsObject(D.allOf[1]))
+  })
+  it('Should guard 6', () => {
+    // intersect to composite
+    const A = Type.Object({ x: Type.Number() })
+    const B = Type.Object({ y: Type.String() })
+    const C = Type.Intersect([A, B])
+    const D = Type.Composite(Type.Rest(C))
+    Assert.IsTrue(KindGuard.IsObject(D))
+    Assert.IsTrue(KindGuard.IsNumber(D.properties.x))
+    Assert.IsTrue(KindGuard.IsString(D.properties.y))
+  })
+})
diff --git a/test/runtime/type/guard/kind/string.ts b/test/runtime/type/guard/kind/string.ts
new file mode 100644
index 000000000..ca9b5917a
--- /dev/null
+++ b/test/runtime/type/guard/kind/string.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TString', () => {
+  it('Should guard for TString', () => {
+    const R = KindGuard.IsString(Type.String())
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TString', () => {
+    const R = KindGuard.IsString(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/symbol.ts b/test/runtime/type/guard/kind/symbol.ts
new file mode 100644
index 000000000..f58924b07
--- /dev/null
+++ b/test/runtime/type/guard/kind/symbol.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TSymbol', () => {
+  it('Should guard for TSymbol', () => {
+    const R = KindGuard.IsSymbol(Type.Symbol())
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TSymbol', () => {
+    const R = KindGuard.IsSymbol(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/template-literal.ts b/test/runtime/type/guard/kind/template-literal.ts
new file mode 100644
index 000000000..9c01c310d
--- /dev/null
+++ b/test/runtime/type/guard/kind/template-literal.ts
@@ -0,0 +1,35 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TTemplateLiteral', () => {
+  it('Should guard for empty TemplateLiteral', () => {
+    const R = KindGuard.IsTemplateLiteral(Type.TemplateLiteral([]))
+    Assert.IsTrue(R)
+  })
+  it('Should guard for TSchema', () => {
+    const R = KindGuard.IsSchema(Type.TemplateLiteral([]))
+    Assert.IsTrue(R)
+  })
+  it('Should guard for TemplateLiteral (TTemplateLiteral)', () => {
+    const T = Type.TemplateLiteral([Type.Literal('hello')])
+    const R = KindGuard.IsTemplateLiteral(Type.TemplateLiteral([T, Type.Literal('world')]))
+    Assert.IsTrue(R)
+  })
+  it('Should guard for TemplateLiteral (TLiteral)', () => {
+    const R = KindGuard.IsTemplateLiteral(Type.TemplateLiteral([Type.Literal('hello')]))
+    Assert.IsTrue(R)
+  })
+  it('Should guard for TemplateLiteral (TString)', () => {
+    const R = KindGuard.IsTemplateLiteral(Type.TemplateLiteral([Type.String()]))
+    Assert.IsTrue(R)
+  })
+  it('Should guard for TemplateLiteral (TNumber)', () => {
+    const R = KindGuard.IsTemplateLiteral(Type.TemplateLiteral([Type.Number()]))
+    Assert.IsTrue(R)
+  })
+  it('Should guard for TemplateLiteral (TBoolean)', () => {
+    const R = KindGuard.IsTemplateLiteral(Type.TemplateLiteral([Type.Boolean()]))
+    Assert.IsTrue(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/this.ts b/test/runtime/type/guard/kind/this.ts
new file mode 100644
index 000000000..ee1cd4dcb
--- /dev/null
+++ b/test/runtime/type/guard/kind/this.ts
@@ -0,0 +1,13 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TThis', () => {
+  it('Should guard for TThis', () => {
+    Type.Recursive((This) => {
+      const R = KindGuard.IsThis(This)
+      Assert.IsTrue(R)
+      return Type.Object({ nodes: Type.Array(This) })
+    })
+  })
+})
diff --git a/test/runtime/type/guard/kind/tuple.ts b/test/runtime/type/guard/kind/tuple.ts
new file mode 100644
index 000000000..289ba57ae
--- /dev/null
+++ b/test/runtime/type/guard/kind/tuple.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TTuple', () => {
+  it('Should guard for TTuple', () => {
+    const R = KindGuard.IsTuple(Type.Tuple([Type.Number(), Type.Number()]))
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TTuple', () => {
+    const R = KindGuard.IsTuple(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/uint8array.ts b/test/runtime/type/guard/kind/uint8array.ts
new file mode 100644
index 000000000..f8af30701
--- /dev/null
+++ b/test/runtime/type/guard/kind/uint8array.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TUint8Array', () => {
+  it('Should guard for TUint8Array', () => {
+    const R = KindGuard.IsUint8Array(Type.Uint8Array())
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TUint8Array', () => {
+    const R = KindGuard.IsUint8Array(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/uncapitalize.ts b/test/runtime/type/guard/kind/uncapitalize.ts
new file mode 100644
index 000000000..65c75b2c4
--- /dev/null
+++ b/test/runtime/type/guard/kind/uncapitalize.ts
@@ -0,0 +1,33 @@
+import { KindGuard, Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/Uncapitalize', () => {
+  it('Should guard for Uncapitalize 1', () => {
+    const T = Type.Uncapitalize(Type.Literal('HELLO'), { $id: 'hello', foo: 1 })
+    Assert.IsTrue(KindGuard.IsLiteral(T))
+    Assert.IsEqual(T.const, 'hELLO')
+    Assert.IsEqual(T.$id, 'hello')
+    Assert.IsEqual(T.foo, 1)
+  })
+  it('Should guard for Uncapitalize 2', () => {
+    const T = Type.Uncapitalize(Type.Literal('HELLO'))
+    Assert.IsTrue(KindGuard.IsLiteral(T))
+    Assert.IsEqual(T.const, 'hELLO')
+  })
+  it('Should guard for Uncapitalize 3', () => {
+    const T = Type.Uncapitalize(Type.Union([Type.Literal('HELLO'), Type.Literal('WORLD')]))
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'hELLO')
+    Assert.IsEqual(T.anyOf[1].const, 'wORLD')
+  })
+  it('Should guard for Uncapitalize 4', () => {
+    const T = Type.Uncapitalize(Type.TemplateLiteral('HELLO${0|1}'))
+    Assert.IsTrue(KindGuard.IsTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(hELLO0|hELLO1)$')
+  })
+  it('Should guard for Uncapitalize 5', () => {
+    const T = Type.Uncapitalize(Type.TemplateLiteral([Type.Literal('HELLO'), Type.Union([Type.Literal(0), Type.Literal(1)])]))
+    Assert.IsTrue(KindGuard.IsTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(hELLO0|hELLO1)$')
+  })
+})
diff --git a/test/runtime/type/guard/kind/undefined.ts b/test/runtime/type/guard/kind/undefined.ts
new file mode 100644
index 000000000..1c7aebbcf
--- /dev/null
+++ b/test/runtime/type/guard/kind/undefined.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TUndefined', () => {
+  it('Should guard for TUndefined', () => {
+    const R = KindGuard.IsUndefined(Type.Undefined())
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TUndefined', () => {
+    const R = KindGuard.IsUndefined(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/union.ts b/test/runtime/type/guard/kind/union.ts
new file mode 100644
index 000000000..03e934fd5
--- /dev/null
+++ b/test/runtime/type/guard/kind/union.ts
@@ -0,0 +1,42 @@
+import { TSchema, KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TUnion', () => {
+  it('Should guard for TUnion', () => {
+    const R = KindGuard.IsUnion(
+      Type.Union([
+        Type.Object({
+          x: Type.Number(),
+        }),
+        Type.Object({
+          y: Type.Number(),
+        }),
+      ]),
+    )
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TUnion', () => {
+    const R = KindGuard.IsUnion(null)
+    Assert.IsFalse(R)
+  })
+  it('Transform: Should transform to never for zero length union', () => {
+    const T = Type.Union([])
+    const R = KindGuard.IsNever(T)
+    Assert.IsTrue(R)
+  })
+  it('Transform: Should unwrap union type for array of length === 1', () => {
+    const T = Type.Union([Type.String()])
+    const R = KindGuard.IsString(T)
+    Assert.IsTrue(R)
+  })
+  it('Transform: Should retain union if array length > 1', () => {
+    const T = Type.Union([Type.String(), Type.Number()])
+    const R1 = KindGuard.IsUnion(T)
+    const R2 = KindGuard.IsString(T.anyOf[0])
+    const R3 = KindGuard.IsNumber(T.anyOf[1])
+    Assert.IsTrue(R1)
+    Assert.IsTrue(R2)
+    Assert.IsTrue(R3)
+  })
+})
diff --git a/test/runtime/type/guard/kind/unknown.ts b/test/runtime/type/guard/kind/unknown.ts
new file mode 100644
index 000000000..066414e69
--- /dev/null
+++ b/test/runtime/type/guard/kind/unknown.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TUnknown', () => {
+  it('Should guard for TUnknown', () => {
+    const R = KindGuard.IsUnknown(Type.Unknown())
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TUnknown', () => {
+    const R = KindGuard.IsUnknown(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/unsafe.ts b/test/runtime/type/guard/kind/unsafe.ts
new file mode 100644
index 000000000..c0f206d7e
--- /dev/null
+++ b/test/runtime/type/guard/kind/unsafe.ts
@@ -0,0 +1,33 @@
+import { Kind, KindGuard, TypeRegistry } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TUnsafe', () => {
+  it('Should guard raw TUnsafe', () => {
+    const T = Type.Unsafe({ x: 1 })
+    const R = KindGuard.IsUnsafe(T)
+    Assert.IsTrue(R)
+  })
+  it('Should guard raw TUnsafe as TSchema', () => {
+    const T = Type.Unsafe({ x: 1 })
+    const R = KindGuard.IsSchema(T)
+    Assert.IsTrue(R)
+  })
+  it('Should guard override TUnsafe as TSchema when registered', () => {
+    TypeRegistry.Set('UnsafeType', () => true)
+    const T = Type.Unsafe({ [Kind]: 'UnsafeType' })
+    const R = KindGuard.IsSchema(T)
+    Assert.IsTrue(R)
+    TypeRegistry.Delete('UnsafeType')
+  })
+  it('Should not guard TUnsafe with unregistered kind', () => {
+    const T = Type.Unsafe({ [Kind]: 'UnsafeType' })
+    const R = KindGuard.IsUnsafe(T)
+    Assert.IsFalse(R)
+  })
+  it('Should not guard for TString', () => {
+    const T = Type.String()
+    const R = KindGuard.IsUnsafe(T)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/uppercase.ts b/test/runtime/type/guard/kind/uppercase.ts
new file mode 100644
index 000000000..fc8a79603
--- /dev/null
+++ b/test/runtime/type/guard/kind/uppercase.ts
@@ -0,0 +1,33 @@
+import { KindGuard, Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/Uppercase', () => {
+  it('Should guard for Uppercase 1', () => {
+    const T = Type.Uppercase(Type.Literal('hello'), { $id: 'hello', foo: 1 })
+    Assert.IsTrue(KindGuard.IsLiteral(T))
+    Assert.IsEqual(T.const, 'HELLO')
+    Assert.IsEqual(T.$id, 'hello')
+    Assert.IsEqual(T.foo, 1)
+  })
+  it('Should guard for Uppercase 2', () => {
+    const T = Type.Uppercase(Type.Literal('hello'))
+    Assert.IsTrue(KindGuard.IsLiteral(T))
+    Assert.IsEqual(T.const, 'HELLO')
+  })
+  it('Should guard for Uppercase 3', () => {
+    const T = Type.Uppercase(Type.Union([Type.Literal('hello'), Type.Literal('world')]))
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsEqual(T.anyOf[0].const, 'HELLO')
+    Assert.IsEqual(T.anyOf[1].const, 'WORLD')
+  })
+  it('Should guard for Uppercase 4', () => {
+    const T = Type.Uppercase(Type.TemplateLiteral('hello${0|1}'))
+    Assert.IsTrue(KindGuard.IsTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(HELLO0|HELLO1)$')
+  })
+  it('Should guard for Uppercase 5', () => {
+    const T = Type.Uppercase(Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal(0), Type.Literal(1)])]))
+    Assert.IsTrue(KindGuard.IsTemplateLiteral(T))
+    Assert.IsEqual(T.pattern, '^(HELLO0|HELLO1)$')
+  })
+})
diff --git a/test/runtime/type/guard/kind/void.ts b/test/runtime/type/guard/kind/void.ts
new file mode 100644
index 000000000..40370e079
--- /dev/null
+++ b/test/runtime/type/guard/kind/void.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TVoid', () => {
+  it('Should guard for TVoid', () => {
+    const R = KindGuard.IsVoid(Type.Void())
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TVoid', () => {
+    const R = KindGuard.IsVoid(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/any.ts b/test/runtime/type/guard/type/any.ts
similarity index 84%
rename from test/runtime/type/guard/any.ts
rename to test/runtime/type/guard/type/any.ts
index ecc4cc92b..6eebd946d 100644
--- a/test/runtime/type/guard/any.ts
+++ b/test/runtime/type/guard/type/any.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TAny', () => {
+describe('guard/type/TAny', () => {
   it('Should guard for TAny', () => {
     const R = TypeGuard.IsAny(Type.Any())
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/array.ts b/test/runtime/type/guard/type/array.ts
similarity index 94%
rename from test/runtime/type/guard/array.ts
rename to test/runtime/type/guard/type/array.ts
index 12f0a9e20..fe1033754 100644
--- a/test/runtime/type/guard/array.ts
+++ b/test/runtime/type/guard/type/array.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TArray', () => {
+describe('guard/type/TArray', () => {
   it('Should guard for TArray', () => {
     const R = TypeGuard.IsArray(Type.Array(Type.Number()))
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/async-iterator.ts b/test/runtime/type/guard/type/async-iterator.ts
similarity index 86%
rename from test/runtime/type/guard/async-iterator.ts
rename to test/runtime/type/guard/type/async-iterator.ts
index 55a52da32..cde73726f 100644
--- a/test/runtime/type/guard/async-iterator.ts
+++ b/test/runtime/type/guard/type/async-iterator.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TAsyncIterator', () => {
+describe('guard/type/TAsyncIterator', () => {
   it('Should guard for TAsyncIterator', () => {
     const T = Type.AsyncIterator(Type.Any())
     const R = TypeGuard.IsAsyncIterator(T)
diff --git a/test/runtime/type/guard/awaited.ts b/test/runtime/type/guard/type/awaited.ts
similarity index 94%
rename from test/runtime/type/guard/awaited.ts
rename to test/runtime/type/guard/type/awaited.ts
index 7515107a7..fbfe4dc09 100644
--- a/test/runtime/type/guard/awaited.ts
+++ b/test/runtime/type/guard/type/awaited.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/Awaited', () => {
+describe('guard/type/Awaited', () => {
   it('Should guard for Awaited 1', () => {
     const T = Type.Awaited(Type.String())
     const R = TypeGuard.IsString(T)
diff --git a/test/runtime/type/guard/bigint.ts b/test/runtime/type/guard/type/bigint.ts
similarity index 84%
rename from test/runtime/type/guard/bigint.ts
rename to test/runtime/type/guard/type/bigint.ts
index ae7edab9f..fa9eb3b7c 100644
--- a/test/runtime/type/guard/bigint.ts
+++ b/test/runtime/type/guard/type/bigint.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TBigInt', () => {
+describe('guard/type/TBigInt', () => {
   it('Should guard for TBigInt', () => {
     const R = TypeGuard.IsBigInt(Type.BigInt())
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/boolean.ts b/test/runtime/type/guard/type/boolean.ts
similarity index 84%
rename from test/runtime/type/guard/boolean.ts
rename to test/runtime/type/guard/type/boolean.ts
index e74af2e16..27c9df1aa 100644
--- a/test/runtime/type/guard/boolean.ts
+++ b/test/runtime/type/guard/type/boolean.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TBoolean', () => {
+describe('guard/type/TBoolean', () => {
   it('Should guard for TBoolean', () => {
     const R = TypeGuard.IsBoolean(Type.Boolean())
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/capitalize.ts b/test/runtime/type/guard/type/capitalize.ts
similarity index 93%
rename from test/runtime/type/guard/capitalize.ts
rename to test/runtime/type/guard/type/capitalize.ts
index def31e727..c34b0849d 100644
--- a/test/runtime/type/guard/capitalize.ts
+++ b/test/runtime/type/guard/type/capitalize.ts
@@ -1,7 +1,7 @@
 import { TypeGuard, Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/Capitalize', () => {
+describe('guard/type/Capitalize', () => {
   it('Should guard for Capitalize 1', () => {
     const T = Type.Capitalize(Type.Literal('hello'), { $id: 'hello', foo: 1 })
     Assert.IsTrue(TypeGuard.IsLiteral(T))
diff --git a/test/runtime/type/guard/composite.ts b/test/runtime/type/guard/type/composite.ts
similarity index 98%
rename from test/runtime/type/guard/composite.ts
rename to test/runtime/type/guard/type/composite.ts
index 351041bb2..1cada8065 100644
--- a/test/runtime/type/guard/composite.ts
+++ b/test/runtime/type/guard/type/composite.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TComposite', () => {
+describe('guard/type/TComposite', () => {
   it('Should guard for distinct properties', () => {
     const T = Type.Composite([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
     Assert.IsTrue(TypeGuard.IsNumber(T.properties.x))
diff --git a/test/runtime/type/guard/const.ts b/test/runtime/type/guard/type/const.ts
similarity index 98%
rename from test/runtime/type/guard/const.ts
rename to test/runtime/type/guard/type/const.ts
index 0e5ad4288..408075c37 100644
--- a/test/runtime/type/guard/const.ts
+++ b/test/runtime/type/guard/type/const.ts
@@ -1,8 +1,8 @@
 import { TypeGuard, ValueGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TConstT', () => {
+describe('guard/type/TConstT', () => {
   // ----------------------------------------------------------------
   // Identity Types
   // ----------------------------------------------------------------
diff --git a/test/runtime/type/guard/constructor.ts b/test/runtime/type/guard/type/constructor.ts
similarity index 93%
rename from test/runtime/type/guard/constructor.ts
rename to test/runtime/type/guard/type/constructor.ts
index bcbb78aa6..9c55370ca 100644
--- a/test/runtime/type/guard/constructor.ts
+++ b/test/runtime/type/guard/type/constructor.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TConstructor', () => {
+describe('guard/type/TConstructor', () => {
   it('Should guard for TConstructor', () => {
     const R = TypeGuard.IsConstructor(Type.Constructor([], Type.Number()))
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/date.ts b/test/runtime/type/guard/type/date.ts
similarity index 94%
rename from test/runtime/type/guard/date.ts
rename to test/runtime/type/guard/type/date.ts
index fdfc720e2..930cc19af 100644
--- a/test/runtime/type/guard/date.ts
+++ b/test/runtime/type/guard/type/date.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TDate', () => {
+describe('guard/type/TDate', () => {
   it('Should guard for TDate', () => {
     const R = TypeGuard.IsDate(Type.Date())
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/deref.ts b/test/runtime/type/guard/type/deref.ts
similarity index 97%
rename from test/runtime/type/guard/deref.ts
rename to test/runtime/type/guard/type/deref.ts
index eedd3a652..64f6d7d61 100644
--- a/test/runtime/type/guard/deref.ts
+++ b/test/runtime/type/guard/type/deref.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TDeref', () => {
+describe('guard/type/TDeref', () => {
   it('Should should deref 1', () => {
     const T = Type.String({ $id: 'T' })
     const R = Type.Ref(T)
diff --git a/test/runtime/type/guard/enum.ts b/test/runtime/type/guard/type/enum.ts
similarity index 97%
rename from test/runtime/type/guard/enum.ts
rename to test/runtime/type/guard/type/enum.ts
index dc092e838..4097c1bee 100644
--- a/test/runtime/type/guard/enum.ts
+++ b/test/runtime/type/guard/type/enum.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TEnum', () => {
+describe('guard/type/TEnum', () => {
   // ----------------------------------------------------------------
   // Options
   // ----------------------------------------------------------------
diff --git a/test/runtime/type/guard/exclude.ts b/test/runtime/type/guard/type/exclude.ts
similarity index 98%
rename from test/runtime/type/guard/exclude.ts
rename to test/runtime/type/guard/type/exclude.ts
index 88366678c..973ab850c 100644
--- a/test/runtime/type/guard/exclude.ts
+++ b/test/runtime/type/guard/type/exclude.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TExclude', () => {
+describe('guard/type/TExclude', () => {
   it('Should exclude string from number', () => {
     const T = Type.Exclude(Type.String(), Type.Number())
     Assert.IsTrue(TypeGuard.IsString(T))
diff --git a/test/runtime/type/guard/extract.ts b/test/runtime/type/guard/type/extract.ts
similarity index 98%
rename from test/runtime/type/guard/extract.ts
rename to test/runtime/type/guard/type/extract.ts
index ffa7d8871..93f7b1fda 100644
--- a/test/runtime/type/guard/extract.ts
+++ b/test/runtime/type/guard/type/extract.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TExtract', () => {
+describe('guard/type/TExtract', () => {
   it('Should extract string from number', () => {
     const T = Type.Extract(Type.String(), Type.Number())
     Assert.IsTrue(TypeGuard.IsNever(T))
diff --git a/test/runtime/type/guard/function.ts b/test/runtime/type/guard/type/function.ts
similarity index 93%
rename from test/runtime/type/guard/function.ts
rename to test/runtime/type/guard/type/function.ts
index 400c83004..81bbfe84c 100644
--- a/test/runtime/type/guard/function.ts
+++ b/test/runtime/type/guard/type/function.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TFunction', () => {
+describe('guard/type/TFunction', () => {
   it('Should guard for TFunction', () => {
     const R = TypeGuard.IsFunction(Type.Function([], Type.Number()))
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/type/index.ts b/test/runtime/type/guard/type/index.ts
new file mode 100644
index 000000000..271b53f88
--- /dev/null
+++ b/test/runtime/type/guard/type/index.ts
@@ -0,0 +1,52 @@
+import './any'
+import './array'
+import './async-iterator'
+import './awaited'
+import './bigint'
+import './boolean'
+import './capitalize'
+import './composite'
+import './const'
+import './constructor'
+import './date'
+import './deref'
+import './enum'
+import './exclude'
+import './extract'
+import './function'
+import './indexed'
+import './integer'
+import './intersect'
+import './iterator'
+import './keyof'
+import './kind'
+import './literal'
+import './lowercase'
+import './mapped'
+import './not'
+import './null'
+import './number'
+import './object'
+import './omit'
+import './partial'
+import './pick'
+import './promise'
+import './record'
+import './recursive'
+import './ref'
+import './regexp'
+import './required'
+import './rest'
+import './string'
+import './symbol'
+import './template-literal'
+import './this'
+import './tuple'
+import './uint8array'
+import './uncapitalize'
+import './undefined'
+import './union'
+import './unknown'
+import './unsafe'
+import './uppercase'
+import './void'
diff --git a/test/runtime/type/guard/indexed.ts b/test/runtime/type/guard/type/indexed.ts
similarity index 99%
rename from test/runtime/type/guard/indexed.ts
rename to test/runtime/type/guard/type/indexed.ts
index 0e29896a9..55225c894 100644
--- a/test/runtime/type/guard/indexed.ts
+++ b/test/runtime/type/guard/type/indexed.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TIndex', () => {
+describe('guard/type/TIndex', () => {
   it('Should Index 1', () => {
     const T = Type.Object({
       x: Type.Number(),
diff --git a/test/runtime/type/guard/integer.ts b/test/runtime/type/guard/type/integer.ts
similarity index 94%
rename from test/runtime/type/guard/integer.ts
rename to test/runtime/type/guard/type/integer.ts
index 42a8c6120..add1f318c 100644
--- a/test/runtime/type/guard/integer.ts
+++ b/test/runtime/type/guard/type/integer.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TInteger', () => {
+describe('guard/type/TInteger', () => {
   it('Should guard for TInteger', () => {
     const R = TypeGuard.IsInteger(Type.Integer())
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/intersect.ts b/test/runtime/type/guard/type/intersect.ts
similarity index 90%
rename from test/runtime/type/guard/intersect.ts
rename to test/runtime/type/guard/type/intersect.ts
index ab2b58466..7b345ef66 100644
--- a/test/runtime/type/guard/intersect.ts
+++ b/test/runtime/type/guard/type/intersect.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TIntersect', () => {
+describe('guard/type/TIntersect', () => {
   it('Should guard for TIntersect', () => {
     const R = TypeGuard.IsIntersect(
       Type.Intersect([
diff --git a/test/runtime/type/guard/iterator.ts b/test/runtime/type/guard/type/iterator.ts
similarity index 86%
rename from test/runtime/type/guard/iterator.ts
rename to test/runtime/type/guard/type/iterator.ts
index df549edd1..74e984c49 100644
--- a/test/runtime/type/guard/iterator.ts
+++ b/test/runtime/type/guard/type/iterator.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TIterator', () => {
+describe('guard/type/TIterator', () => {
   it('Should guard for TIterator', () => {
     const T = Type.Iterator(Type.Any())
     const R = TypeGuard.IsIterator(T)
diff --git a/test/runtime/type/guard/keyof.ts b/test/runtime/type/guard/type/keyof.ts
similarity index 95%
rename from test/runtime/type/guard/keyof.ts
rename to test/runtime/type/guard/type/keyof.ts
index 1b066c4ed..50d95ec5a 100644
--- a/test/runtime/type/guard/keyof.ts
+++ b/test/runtime/type/guard/type/keyof.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TKeyOf', () => {
+describe('guard/type/TKeyOf', () => {
   it('Should KeyOf 1', () => {
     const T = Type.Object({
       x: Type.Number(),
diff --git a/test/runtime/type/guard/kind.ts b/test/runtime/type/guard/type/kind.ts
similarity index 75%
rename from test/runtime/type/guard/kind.ts
rename to test/runtime/type/guard/type/kind.ts
index 26006958f..f0223e8ad 100644
--- a/test/runtime/type/guard/kind.ts
+++ b/test/runtime/type/guard/type/kind.ts
@@ -1,7 +1,7 @@
 import { TypeGuard, Kind } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TKind', () => {
+describe('guard/type/TKind', () => {
   it('Should guard 1', () => {
     const T = { [Kind]: 'Kind' }
     Assert.IsTrue(TypeGuard.IsKind(T))
diff --git a/test/runtime/type/guard/literal.ts b/test/runtime/type/guard/type/literal.ts
similarity index 91%
rename from test/runtime/type/guard/literal.ts
rename to test/runtime/type/guard/type/literal.ts
index c1e6b21f5..fcfe4b74e 100644
--- a/test/runtime/type/guard/literal.ts
+++ b/test/runtime/type/guard/type/literal.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TLiteral', () => {
+describe('guard/type/TLiteral', () => {
   it('Should guard for TLiteral of String', () => {
     const R = TypeGuard.IsLiteral(Type.Literal('hello'))
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/lowercase.ts b/test/runtime/type/guard/type/lowercase.ts
similarity index 93%
rename from test/runtime/type/guard/lowercase.ts
rename to test/runtime/type/guard/type/lowercase.ts
index be9e797cd..f274be4b4 100644
--- a/test/runtime/type/guard/lowercase.ts
+++ b/test/runtime/type/guard/type/lowercase.ts
@@ -1,7 +1,7 @@
 import { TypeGuard, Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/Lowercase', () => {
+describe('guard/type/Lowercase', () => {
   it('Should guard for Lowercase 1', () => {
     const T = Type.Lowercase(Type.Literal('HELLO'), { $id: 'hello', foo: 1 })
     Assert.IsTrue(TypeGuard.IsLiteral(T))
diff --git a/test/runtime/type/guard/type/mapped.ts b/test/runtime/type/guard/type/mapped.ts
new file mode 100644
index 000000000..99eeff52b
--- /dev/null
+++ b/test/runtime/type/guard/type/mapped.ts
@@ -0,0 +1,609 @@
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+// prettier-ignore
+describe('guard/type/Mapped', () => {
+  it('Should guard mapped 1', () => {
+    const T = Type.Mapped(Type.Union([
+      Type.Literal('x'),
+      Type.Literal('y'),
+      Type.Literal('z'),
+    ]), _ => Type.Number(), { custom: 1 })
+    Assert.IsEqual(T, Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number()
+    }, { custom: 1 }))
+  })
+  it('Should guard mapped 2', () => {
+    const T = Type.Mapped(Type.Union([
+      Type.Literal('x'),
+      Type.Literal('y'),
+      Type.Literal('z'),
+    ]), _ => Type.Number())
+    Assert.IsEqual(T, Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number()
+    }))
+  })
+  it('Should guard mapped 3', () => {
+    const T = Type.Mapped(Type.Union([
+      Type.Literal('x'),
+      Type.Literal('y'),
+      Type.Literal('z'),
+    ]), K => K)
+    Assert.IsEqual(T, Type.Object({
+      x: Type.Literal('x'),
+      y: Type.Literal('y'),
+      z: Type.Literal('z'),
+    }))
+  })
+  it('Should guard mapped 4', () => {
+    const T = Type.Mapped(Type.TemplateLiteral('${0|1}${0|1}'), K => Type.Number())
+    Assert.IsEqual(T, Type.Object({
+      '00': Type.Number(),
+      '01': Type.Number(),
+      '10': Type.Number(),
+      '11': Type.Number(),
+    }))
+  })
+  it('Should guard mapped 5', () => {
+    const T = Type.Mapped(Type.TemplateLiteral('${a|b}'), X => 
+      Type.Mapped(Type.TemplateLiteral('${c|d}'), Y => 
+        Type.Mapped(Type.TemplateLiteral('${e|f}'), Z =>
+          Type.Tuple([X, Y, Z])
+        )
+      )
+    )
+    Assert.IsEqual(T, Type.Object({
+      a: Type.Object({
+        c: Type.Object({
+          e: Type.Tuple([Type.Literal("a"), Type.Literal("c"), Type.Literal("e")]),
+          f: Type.Tuple([Type.Literal("a"), Type.Literal("c"), Type.Literal("f")])
+        }),
+        d: Type.Object({
+          e: Type.Tuple([Type.Literal("a"), Type.Literal("d"), Type.Literal("e")]),
+          f: Type.Tuple([Type.Literal("a"), Type.Literal("d"), Type.Literal("f")])
+        }),
+      }),
+      b: Type.Object({
+        c: Type.Object({
+          e: Type.Tuple([Type.Literal("b"), Type.Literal("c"), Type.Literal("e")]),
+          f: Type.Tuple([Type.Literal("b"), Type.Literal("c"), Type.Literal("f")])
+        }),
+        d: Type.Object({
+          e: Type.Tuple([Type.Literal("b"), Type.Literal("d"), Type.Literal("e")]),
+          f: Type.Tuple([Type.Literal("b"), Type.Literal("d"), Type.Literal("f")])
+        }),
+      }),
+    }))
+  })
+  it('Should guard mapped 6', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+      z: Type.Boolean()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => K)
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Literal('x'),
+      y: Type.Literal('y'),
+      z: Type.Literal('z')
+    }))
+  })
+  it('Should guard mapped 7', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+      z: Type.Boolean()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Index(T, K))
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+      z: Type.Boolean()
+    }))
+  })
+  it('Should guard mapped 8', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+      z: Type.Boolean()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Index(T, K, { custom: 1 }))
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Number({ custom: 1 }),
+      y: Type.String({ custom: 1 }),
+      z: Type.Boolean({ custom: 1 })
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Extract
+  // ----------------------------------------------------------------
+  it('Should guard mapped 9', () => {
+    const T = Type.Object({
+      x: Type.Union([Type.String(), Type.Number(), Type.Boolean()])
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return Type.Extract(Type.Index(T, K), Type.String())
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.String()
+    }))
+  })
+  it('Should guard mapped 10', () => {
+    const T = Type.Object({
+      x: Type.Union([Type.String(), Type.Number(), Type.Boolean()])
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return Type.Extract(Type.Index(T, K), Type.Union([
+        Type.String(),
+        Type.Number()
+      ]))
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Union([Type.String(), Type.Number()])
+    }))
+  })
+  it('Should guard mapped 11', () => {
+    const T = Type.Object({
+      x: Type.Union([Type.String(), Type.Number(), Type.Boolean()])
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return Type.Extract(Type.Index(T, K), Type.Null())
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Never()
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Extends
+  // ----------------------------------------------------------------
+  it('Should guard mapped 12', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+      z: Type.Boolean()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return ( 
+        Type.Extends(K, Type.Literal('x'), Type.Literal(1), 
+        Type.Extends(K, Type.Literal('y'), Type.Literal(2), 
+        Type.Extends(K, Type.Literal('z'), Type.Literal(3), Type.Never())))
+      )
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Literal(1),
+      y: Type.Literal(2),
+      z: Type.Literal(3),
+    }))
+  })
+  it('Should guard mapped 13', () => {
+    const T = Type.Object({
+      x: Type.Number(),
+      y: Type.String(),
+      z: Type.Boolean()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return ( 
+        Type.Extends(Type.Index(T, K), Type.Number(), Type.Literal(3), 
+        Type.Extends(Type.Index(T, K), Type.String(), Type.Literal(2), 
+        Type.Extends(Type.Index(T, K), Type.Boolean(), Type.Literal(1), Type.Never())))
+      )
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Literal(3),
+      y: Type.Literal(2),
+      z: Type.Literal(1),
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Exclude
+  // ----------------------------------------------------------------
+  it('Should guard mapped 14', () => {
+    const T = Type.Object({
+      x: Type.Union([Type.String(), Type.Number(), Type.Boolean()])
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return Type.Exclude(Type.Index(T, K), Type.String())
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Union([Type.Number(), Type.Boolean()])
+    }))
+  })
+  it('Should guard mapped 15', () => {
+    const T = Type.Object({
+      x: Type.Union([Type.String(), Type.Number(), Type.Boolean()])
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return Type.Exclude(Type.Index(T, K), Type.Union([
+        Type.String(),
+        Type.Number()
+      ]))
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Boolean()
+    }))
+  })
+  it('Should guard mapped 16', () => {
+    const T = Type.Object({
+      x: Type.Union([Type.String(), Type.Number(), Type.Boolean()])
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return Type.Exclude(Type.Index(T, K), Type.Null())
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Union([Type.String(), Type.Number(), Type.Boolean()])
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Non-Evaluated
+  // ----------------------------------------------------------------
+  it('Should guard mapped 17', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Array(Type.Index(T, K)))
+    Assert.IsEqual(M, Type.Object({ x: Type.Array(Type.Number()) }))
+  })
+  it('Should guard mapped 18', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Promise(Type.Index(T, K)))
+    Assert.IsEqual(M, Type.Object({ x: Type.Promise(Type.Number()) }))
+  })
+  it('Should guard mapped 19', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Function([Type.Index(T, K)], Type.Index(T, K)))
+    Assert.IsEqual(M, Type.Object({ x: Type.Function([Type.Number()], Type.Number())}))
+  })
+  it('Should guard mapped 20', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Tuple([Type.Index(T, K), Type.Index(T, K)]))
+    Assert.IsEqual(M, Type.Object({ x: Type.Tuple([Type.Number(), Type.Number()]) }))
+  })
+  it('Should guard mapped 21', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Union([Type.Index(T, K), Type.Index(T, K)]))
+    Assert.IsEqual(M, Type.Object({ x: Type.Union([Type.Number(), Type.Number()]) }))
+  })
+  it('Should guard mapped 22', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Intersect([Type.Index(T, K), Type.Index(T, K)]))
+    Assert.IsEqual(M, Type.Object({ x: Type.Intersect([Type.Number(), Type.Number()]) }))
+  })
+  // ----------------------------------------------------------------
+  // Numeric Keys
+  // ----------------------------------------------------------------
+  it('Should guard mapped 23', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+      1: Type.Number(),
+      2: Type.Number()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => K)
+    Assert.IsEqual(M, Type.Object({
+      0: Type.Literal('0'),
+      1: Type.Literal('1'),
+      2: Type.Literal('2'),
+    }))
+  })
+  it('Should guard mapped 24', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+      1: Type.Number(),
+      2: Type.Number()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Index(T, K))
+    Assert.IsEqual(M, Type.Object({
+      0: Type.Number(),
+      1: Type.Number(),
+      2: Type.Number(),
+    }))
+  })
+  it('Should guard mapped 25', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+      1: Type.Number(),
+      2: Type.Number()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.String())
+    Assert.IsEqual(M, Type.Object({
+      0: Type.String(),
+      1: Type.String(),
+      2: Type.String(),
+    }))
+  })
+  it('Should guard mapped 26', () => {
+    const T = Type.Object({
+      0: Type.Number(),
+      1: Type.Number(),
+      2: Type.Number()
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Extends(K, Type.Literal('1'), Type.String(), Type.Number()))
+    Assert.IsEqual(M, Type.Object({
+      0: Type.Number(),
+      1: Type.String(),
+      2: Type.Number(),
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Modifiers: Optional
+  // ----------------------------------------------------------------
+  it('Should guard mapped 27', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.Number()),
+      y: Type.Number()
+    })
+    // subtractive
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Optional(Type.Index(T, K), false))
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Number(),
+      y: Type.Number()
+    }))
+  })
+  it('Should guard mapped 28', () => {
+    const T = Type.Object({
+      x: Type.Optional(Type.Number()),
+      y: Type.Number()
+    })
+    // additive
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Optional(Type.Index(T, K), true))
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Optional(Type.Number()),
+      y: Type.Optional(Type.Number())
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Modifiers: Readonly
+  // ----------------------------------------------------------------
+  it('Should guard mapped 27', () => {
+    const T = Type.Object({
+      x: Type.Readonly(Type.Number()),
+      y: Type.Number()
+    })
+    // subtractive
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Readonly(Type.Index(T, K), false))
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Number(),
+      y: Type.Number()
+    }))
+  })
+  it('Should guard mapped 28', () => {
+    const T = Type.Object({
+      x: Type.Readonly(Type.Number()),
+      y: Type.Number()
+    })
+    // additive
+    const M = Type.Mapped(Type.KeyOf(T), K => Type.Readonly(Type.Index(T, K), true))
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Readonly(Type.Number()),
+      y: Type.Readonly(Type.Number())
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Finite Boolean
+  // ----------------------------------------------------------------
+  it('Should guard mapped 29', () => {
+    const T = Type.TemplateLiteral('${boolean}')
+    const M = Type.Mapped(T, K => K)
+    Assert.IsEqual(M, Type.Object({
+      true: Type.Literal('true'),
+      false: Type.Literal('false'),
+    }))
+  })
+  it('Should guard mapped 30', () => {
+    const T = Type.TemplateLiteral('${0|1}${boolean}')
+    const M = Type.Mapped(T, K => K) 
+    Assert.IsEqual(M, Type.Object({
+      '0true':  Type.Literal('0true'),
+      '0false':  Type.Literal('0false'),
+      '1true':  Type.Literal('1true'),
+      '1false':  Type.Literal('1false'),
+    }))
+  })
+  it('Should guard mapped 31', () => {
+    const T = Type.TemplateLiteral('${boolean}${0|1}')
+    const M = Type.Mapped(T, K => K) 
+    Assert.IsEqual(M, Type.Object({
+      'true0':  Type.Literal('true0'),
+      'true1':  Type.Literal('true1'),
+      'false0':  Type.Literal('false0'),
+      'false1':  Type.Literal('false1'),
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Numeric Mapping
+  // ----------------------------------------------------------------
+  it('Should guard mapped 32', () => {
+    const T = Type.TemplateLiteral([
+      Type.Union([Type.Literal(0), Type.Literal(1)]),
+      Type.Union([Type.Literal(0), Type.Literal(1)]),
+    ])
+    const M = Type.Mapped(T, (K) => K)
+    Assert.IsEqual(M, Type.Object({
+      '00':  Type.Literal('00'),
+      '01':  Type.Literal('01'),
+      '10':  Type.Literal('10'),
+      '11':  Type.Literal('11'),
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Indexed Key Remap
+  // ----------------------------------------------------------------
+  it('Should guard mapped 33', () => {
+    const T = Type.Object({
+      hello: Type.Number(),
+      world: Type.String(),
+    })
+    const M = Type.Mapped(Type.Uppercase(Type.KeyOf(T)), (K) => {
+      return Type.Index(T, Type.Lowercase(K))
+    })
+    Assert.IsEqual(M, Type.Object({
+      HELLO: Type.Number(),
+      WORLD: Type.String()
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Partial
+  // ----------------------------------------------------------------
+  it('Should guard mapped 34', () => {
+    const T = Type.Object({
+      x: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      y: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+    })
+    const M = Type.Mapped(Type.KeyOf(T), (K) => {
+      return Type.Partial(Type.Index(T, K))
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Partial(Type.Object({
+        x: Type.Optional(Type.Number()),
+        y: Type.Optional(Type.Number()),
+      })),
+      y: Type.Partial(Type.Object({
+        x: Type.Optional(Type.Number()),
+        y: Type.Optional(Type.Number()),
+      })),
+    }))
+  })
+  // ----------------------------------------------------------------
+  // Required
+  // ----------------------------------------------------------------
+  it('Should guard mapped 35', () => {
+    const T = Type.Object({
+      x: Type.Partial(Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      })),
+      y: Type.Partial(Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      })),
+    })
+    const M = Type.Mapped(Type.KeyOf(T), (K) => {
+      return Type.Required(Type.Index(T, K))
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      y: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+    }))
+  })
+  // ------------------------------------------------------------------
+  // Pick With Key
+  // ------------------------------------------------------------------
+  it('Should guard mapped 36', () => {
+    const T = Type.Object({
+      x: Type.Object({
+        x: Type.Number(),
+        y: Type.Number()
+      }),
+      y: Type.Object({
+        x: Type.Number(),
+        y: Type.Number()
+      })
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return Type.Pick(T, K)
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Object({
+        x: Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        })
+      }),
+      y: Type.Object({
+        y: Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        })
+      }),
+    }))
+  })
+  // ------------------------------------------------------------------
+  // Pick With Result
+  // ------------------------------------------------------------------
+  it('Should guard mapped 37', () => {
+    const T = Type.Object({
+      x: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      y: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+    })
+    const M = Type.Mapped(Type.KeyOf(T), (K) => {
+      return Type.Pick(Type.Index(T, K), ['x'])
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Object({ x: Type.Number() }),
+      y: Type.Object({ x: Type.Number() })
+    }))
+  })
+  // ------------------------------------------------------------------
+  // Omit With Key
+  // ------------------------------------------------------------------
+  it('Should guard mapped 36', () => {
+    const T = Type.Object({
+      x: Type.Object({
+        x: Type.Number(),
+        y: Type.Number()
+      }),
+      y: Type.Object({
+        x: Type.Number(),
+        y: Type.Number()
+      })
+    })
+    const M = Type.Mapped(Type.KeyOf(T), K => {
+      return Type.Omit(T, K)
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Object({
+        y: Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        })
+      }),
+      y: Type.Object({
+        x: Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        })
+      }),
+    }))
+  })
+  // ------------------------------------------------------------------
+  // Omit With Result
+  // ------------------------------------------------------------------
+  it('Should guard mapped 37', () => {
+    const T = Type.Object({
+      x: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+      y: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+    })
+    const M = Type.Mapped(Type.KeyOf(T), (K) => {
+      return Type.Omit(Type.Index(T, K), ['x'])
+    })
+    Assert.IsEqual(M, Type.Object({
+      x: Type.Object({ y: Type.Number() }),
+      y: Type.Object({ y: Type.Number() })
+    }))
+  })
+})
diff --git a/test/runtime/type/guard/not.ts b/test/runtime/type/guard/type/not.ts
similarity index 85%
rename from test/runtime/type/guard/not.ts
rename to test/runtime/type/guard/type/not.ts
index b21cb5d7c..fcfd8b787 100644
--- a/test/runtime/type/guard/not.ts
+++ b/test/runtime/type/guard/type/not.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TNot', () => {
+describe('guard/type/TNot', () => {
   it('Should guard for TNot', () => {
     const R = TypeGuard.IsNot(Type.Not(Type.String()))
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/null.ts b/test/runtime/type/guard/type/null.ts
similarity index 84%
rename from test/runtime/type/guard/null.ts
rename to test/runtime/type/guard/type/null.ts
index 0ab379276..fc2e85fd5 100644
--- a/test/runtime/type/guard/null.ts
+++ b/test/runtime/type/guard/type/null.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TNull', () => {
+describe('guard/type/TNull', () => {
   it('Should guard for TNull', () => {
     const R = TypeGuard.IsNull(Type.Null())
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/number.ts b/test/runtime/type/guard/type/number.ts
similarity index 94%
rename from test/runtime/type/guard/number.ts
rename to test/runtime/type/guard/type/number.ts
index 02ba9d6a7..c4550aeba 100644
--- a/test/runtime/type/guard/number.ts
+++ b/test/runtime/type/guard/type/number.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TNumber', () => {
+describe('guard/type/TNumber', () => {
   it('Should guard for TNumber', () => {
     const R = TypeGuard.IsNumber(Type.Number())
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/object.ts b/test/runtime/type/guard/type/object.ts
similarity index 96%
rename from test/runtime/type/guard/object.ts
rename to test/runtime/type/guard/type/object.ts
index ff5b2f0e2..49368dd36 100644
--- a/test/runtime/type/guard/object.ts
+++ b/test/runtime/type/guard/type/object.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TObject', () => {
+describe('guard/type/TObject', () => {
   it('Should guard for TObject', () => {
     const R = TypeGuard.IsObject(
       Type.Object({
diff --git a/test/runtime/type/guard/omit.ts b/test/runtime/type/guard/type/omit.ts
similarity index 97%
rename from test/runtime/type/guard/omit.ts
rename to test/runtime/type/guard/type/omit.ts
index c449cc7e6..d9c77c686 100644
--- a/test/runtime/type/guard/omit.ts
+++ b/test/runtime/type/guard/type/omit.ts
@@ -1,7 +1,7 @@
 import { TypeGuard, Type, Kind, TransformKind } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TOmit', () => {
+describe('guard/type/TOmit', () => {
   // -------------------------------------------------------------------------
   // case: https://github.com/sinclairzx81/typebox/issues/384
   // -------------------------------------------------------------------------
diff --git a/test/runtime/type/guard/partial.ts b/test/runtime/type/guard/type/partial.ts
similarity index 96%
rename from test/runtime/type/guard/partial.ts
rename to test/runtime/type/guard/type/partial.ts
index 6c419f451..1e5c61512 100644
--- a/test/runtime/type/guard/partial.ts
+++ b/test/runtime/type/guard/type/partial.ts
@@ -1,7 +1,7 @@
 import { TypeGuard, TypeRegistry, Type, Kind, TransformKind } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TPartial', () => {
+describe('guard/type/TPartial', () => {
   it('Should produce a valid TSchema', () => {
     const T = Type.Partial(Type.Object({ x: Type.Number() }))
     Assert.IsTrue(TypeGuard.IsSchema(T))
diff --git a/test/runtime/type/guard/pick.ts b/test/runtime/type/guard/type/pick.ts
similarity index 97%
rename from test/runtime/type/guard/pick.ts
rename to test/runtime/type/guard/type/pick.ts
index 7b53d4da9..e1cf25952 100644
--- a/test/runtime/type/guard/pick.ts
+++ b/test/runtime/type/guard/type/pick.ts
@@ -1,7 +1,7 @@
 import { TypeGuard, Type, Kind, TransformKind } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TPick', () => {
+describe('guard/type/TPick', () => {
   // -------------------------------------------------------------------------
   // case: https://github.com/sinclairzx81/typebox/issues/384
   // -------------------------------------------------------------------------
diff --git a/test/runtime/type/guard/promise.ts b/test/runtime/type/guard/type/promise.ts
similarity index 92%
rename from test/runtime/type/guard/promise.ts
rename to test/runtime/type/guard/type/promise.ts
index 7fab077b8..073dbcf70 100644
--- a/test/runtime/type/guard/promise.ts
+++ b/test/runtime/type/guard/type/promise.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TPromise', () => {
+describe('guard/type/TPromise', () => {
   it('Should guard for TPromise', () => {
     const R = TypeGuard.IsPromise(Type.Promise(Type.Number()))
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/type/record.ts b/test/runtime/type/guard/type/record.ts
new file mode 100644
index 000000000..14729961c
--- /dev/null
+++ b/test/runtime/type/guard/type/record.ts
@@ -0,0 +1,156 @@
+import { TypeGuard, PatternNumberExact, PatternStringExact, PatternString, PatternNumber } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/type/TRecord', () => {
+  // -------------------------------------------------------------
+  // Overloads
+  // -------------------------------------------------------------
+  it('Should guard overload 1', () => {
+    const T = Type.Record(Type.Union([Type.Literal('A'), Type.Literal('B')]), Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.A))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.B))
+    Assert.IsEqual(T.extra, 1)
+  })
+  it('Should guard overload 2', () => {
+    const T = Type.Record(Type.Union([Type.Literal('A')]), Type.String(), { extra: 1 }) // unwrap as literal
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.A))
+    Assert.IsEqual(T.extra, 1)
+  })
+  it('Should guard overload 3', () => {
+    // @ts-ignore
+    const T = Type.Record(Type.Union([]), Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.IsNever(T))
+  })
+  it('Should guard overload 4', () => {
+    // @ts-ignore
+    const T = Type.Record(Type.BigInt(), Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.IsNever(T))
+  })
+  it('Should guard overload 5', () => {
+    const T = Type.Record(Type.Literal('A'), Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.A))
+    Assert.IsEqual(T.extra, 1)
+  })
+  it('Should guard overload 6', () => {
+    const L = Type.TemplateLiteral([Type.Literal('hello'), Type.Union([Type.Literal('A'), Type.Literal('B')])])
+    const T = Type.Record(L, Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.helloA))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.helloB))
+    Assert.IsEqual(T.extra, 1)
+  })
+  it('Should guard overload 7', () => {
+    const T = Type.Record(Type.Number(), Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsString(T.patternProperties[PatternNumberExact]))
+    Assert.IsEqual(T.extra, 1)
+  })
+  it('Should guard overload 8', () => {
+    const T = Type.Record(Type.Integer(), Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsString(T.patternProperties[PatternNumberExact]))
+    Assert.IsEqual(T.extra, 1)
+  })
+  it('Should guard overload 9', () => {
+    const T = Type.Record(Type.String(), Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsString(T.patternProperties[PatternStringExact]))
+    Assert.IsEqual(T.extra, 1)
+  })
+  it('Should guard overload 10', () => {
+    const L = Type.TemplateLiteral([Type.String(), Type.Literal('_foo')])
+    const T = Type.Record(L, Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsString(T.patternProperties[`^${PatternString}_foo$`]))
+    Assert.IsEqual(T.extra, 1)
+  })
+  it('Should guard overload 11', () => {
+    const L = Type.Union([Type.Literal('A'), Type.Union([Type.Literal('B'), Type.Literal('C')])])
+    const T = Type.Record(L, Type.String())
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.A))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.B))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.C))
+  })
+  it('Should guard overload 12', () => {
+    enum E {
+      A = 'X',
+      B = 'Y',
+      C = 'Z',
+    }
+    const T = Type.Enum(E)
+    const R = Type.Record(T, Type.Null())
+    Assert.IsTrue(TypeGuard.IsObject(R))
+    Assert.IsTrue(TypeGuard.IsNull(R.properties.X))
+    Assert.IsTrue(TypeGuard.IsNull(R.properties.Y))
+    Assert.IsTrue(TypeGuard.IsNull(R.properties.Z))
+  })
+  // -------------------------------------------------------------
+  // Variants
+  // -------------------------------------------------------------
+  it('Should guard for TRecord', () => {
+    const R = TypeGuard.IsRecord(Type.Record(Type.String(), Type.Number()))
+    Assert.IsTrue(R)
+  })
+  it('Should guard for TRecord with TObject value', () => {
+    const R = TypeGuard.IsRecord(
+      Type.Record(
+        Type.String(),
+        Type.Object({
+          x: Type.Number(),
+          y: Type.Number(),
+        }),
+      ),
+    )
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TRecord', () => {
+    const R = TypeGuard.IsRecord(null)
+    Assert.IsFalse(R)
+  })
+  it('Should not guard for TRecord with invalid $id', () => {
+    // @ts-ignore
+    const R = TypeGuard.IsRecord(Type.Record(Type.String(), Type.Number(), { $id: 1 }))
+    Assert.IsFalse(R)
+  })
+  it('Should not guard for TRecord with TObject value with invalid Property', () => {
+    const R = TypeGuard.IsRecord(
+      Type.Record(
+        Type.String(),
+        Type.Object({
+          x: Type.Number(),
+          y: {} as any,
+        }),
+      ),
+    )
+    Assert.IsFalse(R)
+  })
+  it('Normalize: Should should normalize to TObject for single literal union value', () => {
+    const K = Type.Union([Type.Literal('ok')])
+    const R = TypeGuard.IsObject(Type.Record(K, Type.Number()))
+    Assert.IsTrue(R)
+  })
+  it('Normalize: Should should normalize to TObject for multi literal union value', () => {
+    const K = Type.Union([Type.Literal('A'), Type.Literal('B')])
+    const R = TypeGuard.IsObject(Type.Record(K, Type.Number()))
+    Assert.IsTrue(R)
+  })
+  // ------------------------------------------------------------------
+  // Evaluated: Dollar Sign Escape
+  // https://github.com/sinclairzx81/typebox/issues/794
+  // ------------------------------------------------------------------
+  // prettier-ignore
+  {
+    const K = Type.TemplateLiteral('$prop${A|B|C}') // issue
+    const T = Type.Record(K, Type.String())
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.$propA))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.$propB))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.$propC))
+    Assert.IsEqual(T.required, ['$propA', '$propB', '$propC'])
+  }
+})
diff --git a/test/runtime/type/guard/recursive.ts b/test/runtime/type/guard/type/recursive.ts
similarity index 85%
rename from test/runtime/type/guard/recursive.ts
rename to test/runtime/type/guard/type/recursive.ts
index 57c6fe775..861b06668 100644
--- a/test/runtime/type/guard/recursive.ts
+++ b/test/runtime/type/guard/type/recursive.ts
@@ -1,8 +1,8 @@
 import { TypeGuard, PatternNumberExact, PatternStringExact, PatternString, PatternNumber } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TRecursive', () => {
+describe('guard/type/TRecursive', () => {
   it('Should guard 1', () => {
     const T = Type.Recursive((This) => Type.Object({ nodes: This }))
     Assert.IsTrue(TypeGuard.IsRecursive(T))
diff --git a/test/runtime/type/guard/ref.ts b/test/runtime/type/guard/type/ref.ts
similarity index 87%
rename from test/runtime/type/guard/ref.ts
rename to test/runtime/type/guard/type/ref.ts
index e2b5a74b8..ab8f109bf 100644
--- a/test/runtime/type/guard/ref.ts
+++ b/test/runtime/type/guard/type/ref.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TRef', () => {
+describe('guard/type/TRef', () => {
   it('Should guard for TRef', () => {
     const T = Type.Number({ $id: 'T' })
     const R = TypeGuard.IsRef(Type.Ref(T))
diff --git a/test/runtime/type/guard/regexp.ts b/test/runtime/type/guard/type/regexp.ts
similarity index 92%
rename from test/runtime/type/guard/regexp.ts
rename to test/runtime/type/guard/type/regexp.ts
index 558329cba..759d39860 100644
--- a/test/runtime/type/guard/regexp.ts
+++ b/test/runtime/type/guard/type/regexp.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TRegExp', () => {
+describe('guard/type/TRegExp', () => {
   it('Should guard for TRegExp 1', () => {
     const T = Type.RegExp(/foo/, { $id: 'T' })
     Assert.IsTrue(TypeGuard.IsSchema(T))
diff --git a/test/runtime/type/guard/required.ts b/test/runtime/type/guard/type/required.ts
similarity index 96%
rename from test/runtime/type/guard/required.ts
rename to test/runtime/type/guard/type/required.ts
index e4315e912..733302b4f 100644
--- a/test/runtime/type/guard/required.ts
+++ b/test/runtime/type/guard/type/required.ts
@@ -1,7 +1,7 @@
 import { TypeGuard, TypeRegistry, Type, Kind, TransformKind } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TRequired', () => {
+describe('guard/type/TRequired', () => {
   it('Should produce a valid TSchema', () => {
     const T = Type.Required(Type.Object({ x: Type.Number() }))
     Assert.IsTrue(TypeGuard.IsSchema(T))
diff --git a/test/runtime/type/guard/rest.ts b/test/runtime/type/guard/type/rest.ts
similarity index 95%
rename from test/runtime/type/guard/rest.ts
rename to test/runtime/type/guard/type/rest.ts
index dc018d6e7..8383c2b2d 100644
--- a/test/runtime/type/guard/rest.ts
+++ b/test/runtime/type/guard/type/rest.ts
@@ -1,7 +1,7 @@
 import { Type, TypeGuard } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TRest', () => {
+describe('guard/type/TRest', () => {
   it('Should guard 1', () => {
     // union never
     const A = Type.String()
diff --git a/test/runtime/type/guard/string.ts b/test/runtime/type/guard/type/string.ts
similarity index 92%
rename from test/runtime/type/guard/string.ts
rename to test/runtime/type/guard/type/string.ts
index 5eb862683..42aae379b 100644
--- a/test/runtime/type/guard/string.ts
+++ b/test/runtime/type/guard/type/string.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TString', () => {
+describe('guard/type/TString', () => {
   it('Should guard for TString', () => {
     const R = TypeGuard.IsString(Type.String())
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/symbol.ts b/test/runtime/type/guard/type/symbol.ts
similarity index 84%
rename from test/runtime/type/guard/symbol.ts
rename to test/runtime/type/guard/type/symbol.ts
index 8723b2151..488e08334 100644
--- a/test/runtime/type/guard/symbol.ts
+++ b/test/runtime/type/guard/type/symbol.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TSymbol', () => {
+describe('guard/type/TSymbol', () => {
   it('Should guard for TSymbol', () => {
     const R = TypeGuard.IsSymbol(Type.Symbol())
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/template-literal.ts b/test/runtime/type/guard/type/template-literal.ts
similarity index 94%
rename from test/runtime/type/guard/template-literal.ts
rename to test/runtime/type/guard/type/template-literal.ts
index b24518e08..7b0f98ce4 100644
--- a/test/runtime/type/guard/template-literal.ts
+++ b/test/runtime/type/guard/type/template-literal.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TTemplateLiteral', () => {
+describe('guard/type/TTemplateLiteral', () => {
   it('Should guard for empty TemplateLiteral', () => {
     const R = TypeGuard.IsTemplateLiteral(Type.TemplateLiteral([]))
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/this.ts b/test/runtime/type/guard/type/this.ts
similarity index 86%
rename from test/runtime/type/guard/this.ts
rename to test/runtime/type/guard/type/this.ts
index 8ca3a7e0d..800018219 100644
--- a/test/runtime/type/guard/this.ts
+++ b/test/runtime/type/guard/type/this.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TThis', () => {
+describe('guard/type/TThis', () => {
   it('Should guard for TThis', () => {
     Type.Recursive((This) => {
       const R = TypeGuard.IsThis(This)
diff --git a/test/runtime/type/guard/tuple.ts b/test/runtime/type/guard/type/tuple.ts
similarity index 89%
rename from test/runtime/type/guard/tuple.ts
rename to test/runtime/type/guard/type/tuple.ts
index 31a15c280..b47ecde3f 100644
--- a/test/runtime/type/guard/tuple.ts
+++ b/test/runtime/type/guard/type/tuple.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TTuple', () => {
+describe('guard/type/TTuple', () => {
   it('Should guard for TTuple', () => {
     const R = TypeGuard.IsTuple(Type.Tuple([Type.Number(), Type.Number()]))
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/uint8array.ts b/test/runtime/type/guard/type/uint8array.ts
similarity index 91%
rename from test/runtime/type/guard/uint8array.ts
rename to test/runtime/type/guard/type/uint8array.ts
index de668fd9f..ae0b88cfd 100644
--- a/test/runtime/type/guard/uint8array.ts
+++ b/test/runtime/type/guard/type/uint8array.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TUint8Array', () => {
+describe('guard/type/TUint8Array', () => {
   it('Should guard for TUint8Array', () => {
     const R = TypeGuard.IsUint8Array(Type.Uint8Array())
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/uncapitalize.ts b/test/runtime/type/guard/type/uncapitalize.ts
similarity index 93%
rename from test/runtime/type/guard/uncapitalize.ts
rename to test/runtime/type/guard/type/uncapitalize.ts
index ff412676a..61a60e908 100644
--- a/test/runtime/type/guard/uncapitalize.ts
+++ b/test/runtime/type/guard/type/uncapitalize.ts
@@ -1,7 +1,7 @@
 import { TypeGuard, Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/Uncapitalize', () => {
+describe('guard/type/Uncapitalize', () => {
   it('Should guard for Uncapitalize 1', () => {
     const T = Type.Uncapitalize(Type.Literal('HELLO'), { $id: 'hello', foo: 1 })
     Assert.IsTrue(TypeGuard.IsLiteral(T))
diff --git a/test/runtime/type/guard/undefined.ts b/test/runtime/type/guard/type/undefined.ts
similarity index 85%
rename from test/runtime/type/guard/undefined.ts
rename to test/runtime/type/guard/type/undefined.ts
index a6389f4e6..ccebb9551 100644
--- a/test/runtime/type/guard/undefined.ts
+++ b/test/runtime/type/guard/type/undefined.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TUndefined', () => {
+describe('guard/type/TUndefined', () => {
   it('Should guard for TUndefined', () => {
     const R = TypeGuard.IsUndefined(Type.Undefined())
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/union.ts b/test/runtime/type/guard/type/union.ts
similarity index 96%
rename from test/runtime/type/guard/union.ts
rename to test/runtime/type/guard/type/union.ts
index edcf34043..fb5ca4462 100644
--- a/test/runtime/type/guard/union.ts
+++ b/test/runtime/type/guard/type/union.ts
@@ -1,8 +1,8 @@
 import { TSchema, TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TUnion', () => {
+describe('guard/type/TUnion', () => {
   it('Should guard for TUnion', () => {
     const R = TypeGuard.IsUnion(
       Type.Union([
diff --git a/test/runtime/type/guard/unknown.ts b/test/runtime/type/guard/type/unknown.ts
similarity index 84%
rename from test/runtime/type/guard/unknown.ts
rename to test/runtime/type/guard/type/unknown.ts
index cc488fd74..7cc9a29ae 100644
--- a/test/runtime/type/guard/unknown.ts
+++ b/test/runtime/type/guard/type/unknown.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TUnknown', () => {
+describe('guard/type/TUnknown', () => {
   it('Should guard for TUnknown', () => {
     const R = TypeGuard.IsUnknown(Type.Unknown())
     Assert.IsTrue(R)
diff --git a/test/runtime/type/guard/unsafe.ts b/test/runtime/type/guard/type/unsafe.ts
similarity index 91%
rename from test/runtime/type/guard/unsafe.ts
rename to test/runtime/type/guard/type/unsafe.ts
index 5691abea8..1b88d9ddc 100644
--- a/test/runtime/type/guard/unsafe.ts
+++ b/test/runtime/type/guard/type/unsafe.ts
@@ -1,8 +1,8 @@
 import { Kind, TypeGuard, TypeRegistry } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TUnsafe', () => {
+describe('guard/type/TUnsafe', () => {
   it('Should guard raw TUnsafe', () => {
     const T = Type.Unsafe({ x: 1 })
     const R = TypeGuard.IsUnsafe(T)
diff --git a/test/runtime/type/guard/uppercase.ts b/test/runtime/type/guard/type/uppercase.ts
similarity index 93%
rename from test/runtime/type/guard/uppercase.ts
rename to test/runtime/type/guard/type/uppercase.ts
index 539a93755..ba10aa46f 100644
--- a/test/runtime/type/guard/uppercase.ts
+++ b/test/runtime/type/guard/type/uppercase.ts
@@ -1,7 +1,7 @@
 import { TypeGuard, Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/Uppercase', () => {
+describe('guard/type/Uppercase', () => {
   it('Should guard for Uppercase 1', () => {
     const T = Type.Uppercase(Type.Literal('hello'), { $id: 'hello', foo: 1 })
     Assert.IsTrue(TypeGuard.IsLiteral(T))
diff --git a/test/runtime/type/guard/void.ts b/test/runtime/type/guard/type/void.ts
similarity index 84%
rename from test/runtime/type/guard/void.ts
rename to test/runtime/type/guard/type/void.ts
index 9c1f52beb..f9320c6c4 100644
--- a/test/runtime/type/guard/void.ts
+++ b/test/runtime/type/guard/type/void.ts
@@ -1,8 +1,8 @@
 import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 
-describe('type/guard/TVoid', () => {
+describe('guard/type/TVoid', () => {
   it('Should guard for TVoid', () => {
     const R = TypeGuard.IsVoid(Type.Void())
     Assert.IsTrue(R)
diff --git a/test/runtime/type/value/guard.ts b/test/runtime/type/guard/value/guard.ts
similarity index 99%
rename from test/runtime/type/value/guard.ts
rename to test/runtime/type/guard/value/guard.ts
index d68d18952..b58df9bea 100644
--- a/test/runtime/type/value/guard.ts
+++ b/test/runtime/type/guard/value/guard.ts
@@ -1,4 +1,4 @@
-import { Assert } from '../../assert/index'
+import { Assert } from '../../../assert/index'
 import { ValueGuard } from '@sinclair/typebox'
 
 describe('type/ValueGuard', () => {
diff --git a/test/runtime/type/value/index.ts b/test/runtime/type/guard/value/index.ts
similarity index 100%
rename from test/runtime/type/value/index.ts
rename to test/runtime/type/guard/value/index.ts
diff --git a/test/runtime/type/index.ts b/test/runtime/type/index.ts
index 120c570f6..2551b5ae8 100644
--- a/test/runtime/type/index.ts
+++ b/test/runtime/type/index.ts
@@ -7,4 +7,3 @@ import './options/index'
 import './registry/index'
 import './sets/index'
 import './template-literal/index'
-import './value/index'

From a670487154724c6e08517a9a1d8bb0d3ede10a3d Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 27 Apr 2024 16:15:28 +0900
Subject: [PATCH 255/369] Revision 0.32.26 (#851)

* Use Optimized Number Check

* Fix Readme Error | Update Overview

* Version
---
 package-lock.json        | 4 ++--
 package.json             | 2 +-
 readme.md                | 8 ++++----
 src/compiler/compiler.ts | 4 ++--
 src/system/policy.ts     | 3 +--
 src/type/guard/type.ts   | 2 +-
 src/value/guard/guard.ts | 2 +-
 7 files changed, 12 insertions(+), 13 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index f8c489aee..a0d06c80b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.25",
+  "version": "0.32.26",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.25",
+      "version": "0.32.26",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 300281f8f..f2162e4e9 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.25",
+  "version": "0.32.26",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 86aac5555..239e894e8 100644
--- a/readme.md
+++ b/readme.md
@@ -53,7 +53,7 @@ type T = Static<typeof T>                            // type T = {
 
 TypeBox is a runtime type builder that creates in-memory Json Schema objects that infer as TypeScript types. The schematics produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript and runtime asserted using standard Json Schema validation.
 
-This library is designed to allow Json Schema to compose with the same flexibility as TypeScript's programmable type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.
+This library is designed to allow Json Schema to compose with a similar flexibility to TypeScript's type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.
 
 License MIT
 
@@ -895,9 +895,9 @@ const K = Type.TemplateLiteral('prop${A|B|C}')       // const K: TTemplateLitera
                                                      // ]>
 
 const R = Type.Record(K, Type.String())              // const R: TObject<{
-                                                     //   hello1: TString,
-                                                     //   hello2: TString,
-                                                     //   hello3: TString,
+                                                     //   propA: TString,
+                                                     //   propB: TString,
+                                                     //   propC: TString,
                                                      // }>
 ```
 
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 39cb2f4c2..8e939f1f7 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -210,7 +210,7 @@ export namespace Policy {
       : `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
   }
   export function IsNumberLike(value: string): string {
-    return !TypeSystemPolicy.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`
+    return TypeSystemPolicy.AllowNaN ? `typeof ${value} === 'number'` : `Number.isFinite(${value})`
   }
   export function IsVoidLike(value: string): string {
     return TypeSystemPolicy.AllowNullVoid ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`
@@ -288,7 +288,7 @@ export namespace TypeCompiler {
     yield `(typeof ${value} === 'function')`
   }
   function* FromInteger(schema: TInteger, references: TSchema[], value: string): IterableIterator<string> {
-    yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`
+    yield `Number.isInteger(${value})`
     if (IsNumber(schema.exclusiveMaximum)) yield `${value} < ${schema.exclusiveMaximum}`
     if (IsNumber(schema.exclusiveMinimum)) yield `${value} > ${schema.exclusiveMinimum}`
     if (IsNumber(schema.maximum)) yield `${value} <= ${schema.maximum}`
diff --git a/src/system/policy.ts b/src/system/policy.ts
index e2d1a08e7..400c74b16 100644
--- a/src/system/policy.ts
+++ b/src/system/policy.ts
@@ -56,8 +56,7 @@ export namespace TypeSystemPolicy {
   }
   /** Asserts this value using the AllowNaN policy */
   export function IsNumberLike(value: unknown): value is number {
-    const isNumber = IsNumber(value)
-    return AllowNaN ? isNumber : isNumber && Number.isFinite(value)
+    return AllowNaN ? IsNumber(value) : Number.isFinite(value)
   }
   /** Asserts this value using the AllowVoidNull policy */
   export function IsVoidLike(value: unknown): value is void {
diff --git a/src/type/guard/type.ts b/src/type/guard/type.ts
index f80b24fe7..b2e9daa9a 100644
--- a/src/type/guard/type.ts
+++ b/src/type/guard/type.ts
@@ -30,7 +30,7 @@ import * as ValueGuard from './value'
 import { Kind, Hint, TransformKind, ReadonlyKind, OptionalKind } from '../symbols/index'
 import { TypeBoxError } from '../error/index'
 import { TransformOptions } from '../transform/index'
-import { TTemplateLiteral, TTemplateLiteralKind } from '../template-literal/index'
+import { TTemplateLiteral } from '../template-literal/index'
 import { TArray } from '../array/index'
 import { TBoolean } from '../boolean/index'
 import type { TRecord } from '../record/index'
diff --git a/src/value/guard/guard.ts b/src/value/guard/guard.ts
index 8e45b1bd8..14c575dca 100644
--- a/src/value/guard/guard.ts
+++ b/src/value/guard/guard.ts
@@ -171,7 +171,7 @@ export function IsNumber(value: unknown): value is number {
 }
 /** Returns true if this value is an integer */
 export function IsInteger(value: unknown): value is number {
-  return IsNumber(value) && Number.isInteger(value)
+  return Number.isInteger(value)
 }
 /** Returns true if this value is bigint */
 export function IsBigInt(value: unknown): value is bigint {

From 135ac79a3db647179f9679ea2bc85b2b5e0a4f09 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 27 Apr 2024 17:54:58 +0900
Subject: [PATCH 256/369] Revision 0.32.26 (#852)

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 239e894e8..6d1aa239b 100644
--- a/readme.md
+++ b/readme.md
@@ -53,7 +53,7 @@ type T = Static<typeof T>                            // type T = {
 
 TypeBox is a runtime type builder that creates in-memory Json Schema objects that infer as TypeScript types. The schematics produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript and runtime asserted using standard Json Schema validation.
 
-This library is designed to allow Json Schema to compose with a similar flexibility to TypeScript's type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.
+This library is designed to allow Json Schema to compose similar to how types compose within TypeScript's type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.
 
 License MIT
 

From 93a32b0bf0ca27d09939a64f84f28ea9a38d09cd Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 28 Apr 2024 19:59:48 +0900
Subject: [PATCH 257/369] Revision 0.32.27 (#854)

* Refactor Build Tooling

* Override esm.sh Bundling Strategy

* Version
---
 hammer.mjs                                    |  6 ++--
 package-lock.json                             |  4 +--
 package.json                                  |  2 +-
 task/build/{require => cjs}/build.ts          |  6 ++--
 task/build/{require => cjs}/compile.ts        |  0
 task/build/{import => esm}/build.ts           |  6 ++--
 task/build/{import => esm}/compile.ts         |  0
 task/build/{import => esm}/convert-to-esm.ts  |  0
 task/build/index.ts                           |  6 ++--
 .../{common => notices}/remove-notices.ts     |  0
 task/build/{redirect => package}/build.ts     |  6 ++--
 .../create-package-json-redirect.ts}          | 19 ++++++-------
 .../create-package-json.ts                    | 28 ++++++++++---------
 13 files changed, 42 insertions(+), 41 deletions(-)
 rename task/build/{require => cjs}/build.ts (91%)
 rename task/build/{require => cjs}/compile.ts (100%)
 rename task/build/{import => esm}/build.ts (91%)
 rename task/build/{import => esm}/compile.ts (100%)
 rename task/build/{import => esm}/convert-to-esm.ts (100%)
 rename task/build/{common => notices}/remove-notices.ts (100%)
 rename task/build/{redirect => package}/build.ts (90%)
 rename task/build/{redirect/create-redirect-paths.ts => package/create-package-json-redirect.ts} (92%)
 rename task/build/{redirect => package}/create-package-json.ts (80%)

diff --git a/hammer.mjs b/hammer.mjs
index 065e0326b..d936b2034 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -60,9 +60,9 @@ export async function build(target = 'target/build') {
   await test()
   await clean()
   await Promise.all([
-    Build.Import.build(target),
-    Build.Require.build(target),
-    Build.Redirect.build(target)
+    Build.Package.build(target),
+    Build.Esm.build(target),
+    Build.Cjs.build(target),
   ])
   await folder(target).add('readme.md')
   await folder(target).add('license')
diff --git a/package-lock.json b/package-lock.json
index a0d06c80b..9e69929a7 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.26",
+  "version": "0.32.27",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.26",
+      "version": "0.32.27",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index f2162e4e9..16ed2818e 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.26",
+  "version": "0.32.27",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/task/build/require/build.ts b/task/build/cjs/build.ts
similarity index 91%
rename from task/build/require/build.ts
rename to task/build/cjs/build.ts
index 52bba8179..65f1c8410 100644
--- a/task/build/require/build.ts
+++ b/task/build/cjs/build.ts
@@ -26,13 +26,13 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { removeNotices } from '../common/remove-notices'
+import { removeNotices } from '../notices/remove-notices'
 import { compile } from './compile'
 
 /** Builds the CommonJS version of this package */
 export async function build(target: string) {
-  console.log('building...require')
-  const buildTarget = `${target}/build/require`
+  console.log('building...cjs')
+  const buildTarget = `${target}/build/cjs`
   await compile(buildTarget)
   await removeNotices(buildTarget)
 }
diff --git a/task/build/require/compile.ts b/task/build/cjs/compile.ts
similarity index 100%
rename from task/build/require/compile.ts
rename to task/build/cjs/compile.ts
diff --git a/task/build/import/build.ts b/task/build/esm/build.ts
similarity index 91%
rename from task/build/import/build.ts
rename to task/build/esm/build.ts
index bb2637876..04a0eb450 100644
--- a/task/build/import/build.ts
+++ b/task/build/esm/build.ts
@@ -26,14 +26,14 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { removeNotices } from '../common/remove-notices'
+import { removeNotices } from '../notices/remove-notices'
 import { convertToEsm } from './convert-to-esm'
 import { compile } from './compile'
 
 /** Builds the ESM version of this package */
 export async function build(target: string) {
-  console.log('building...import')
-  const buildTarget = `${target}/build/import`
+  console.log('building...esm')
+  const buildTarget = `${target}/build/esm`
   await compile(buildTarget)
   await convertToEsm(buildTarget)
   await removeNotices(buildTarget)
diff --git a/task/build/import/compile.ts b/task/build/esm/compile.ts
similarity index 100%
rename from task/build/import/compile.ts
rename to task/build/esm/compile.ts
diff --git a/task/build/import/convert-to-esm.ts b/task/build/esm/convert-to-esm.ts
similarity index 100%
rename from task/build/import/convert-to-esm.ts
rename to task/build/esm/convert-to-esm.ts
diff --git a/task/build/index.ts b/task/build/index.ts
index 948330f61..e55ce6705 100644
--- a/task/build/index.ts
+++ b/task/build/index.ts
@@ -26,6 +26,6 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export * as Import from './import/build'
-export * as Require from './require/build'
-export * as Redirect from './redirect/build'
+export * as Package from './package/build'
+export * as Esm from './esm/build'
+export * as Cjs from './cjs/build'
diff --git a/task/build/common/remove-notices.ts b/task/build/notices/remove-notices.ts
similarity index 100%
rename from task/build/common/remove-notices.ts
rename to task/build/notices/remove-notices.ts
diff --git a/task/build/redirect/build.ts b/task/build/package/build.ts
similarity index 90%
rename from task/build/redirect/build.ts
rename to task/build/package/build.ts
index f3eba27d7..e7975ed73 100644
--- a/task/build/redirect/build.ts
+++ b/task/build/package/build.ts
@@ -26,13 +26,13 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { createPackageJsonRedirect } from './create-package-json-redirect'
 import { createPackageJson } from './create-package-json'
-import { createRedirectPaths } from './create-redirect-paths'
 
 /** Builds package.json and redirect directories */
 export async function build(target: string) {
-  console.log('building...redirect')
+  console.log('building...package.json')
   const submodules = ['compiler', 'errors', 'system', 'type', 'value']
+  await createPackageJsonRedirect(target, submodules)
   await createPackageJson(target, submodules)
-  await createRedirectPaths(target, submodules)
 }
diff --git a/task/build/redirect/create-redirect-paths.ts b/task/build/package/create-package-json-redirect.ts
similarity index 92%
rename from task/build/redirect/create-redirect-paths.ts
rename to task/build/package/create-package-json-redirect.ts
index 3915b08e5..f586763f3 100644
--- a/task/build/redirect/create-redirect-paths.ts
+++ b/task/build/package/create-package-json-redirect.ts
@@ -28,6 +28,14 @@ THE SOFTWARE.
 
 import * as Fs from 'node:fs'
 
+// prettier-ignore
+function writeRedirect(target: string, submodule: string) {
+  Fs.mkdirSync(`${target}/${submodule}`, { recursive: true })
+  Fs.writeFileSync(`${target}/${submodule}/package.json`,JSON.stringify({
+    main: `../build/cjs/${submodule}/index.js`,
+    types: `../build/cjs/${submodule}/index.d.ts`,
+  }, null, 2))
+}
 // --------------------------------------------------------------------------------------------------------------------------
 // Builds redirect directories for earlier versions of Node. Note that TypeScript will use these directories to
 // resolve types when tsconfig.json is configured for `moduleResolution: 'node'`. This approach is referred to as
@@ -37,15 +45,6 @@ import * as Fs from 'node:fs'
 // --------------------------------------------------------------------------------------------------------------------------
 
 // prettier-ignore
-export function createRedirectPaths(target: string, submodules: string[]) {
+export function createPackageJsonRedirect(target: string, submodules: string[]) {
   submodules.forEach((submodule) => writeRedirect(target, submodule))
 }
-
-// prettier-ignore
-function writeRedirect(target: string, submodule: string) {
-  Fs.mkdirSync(`${target}/${submodule}`, { recursive: true })
-  Fs.writeFileSync(`${target}/${submodule}/package.json`,JSON.stringify({
-    main: `../build/require/${submodule}/index.js`,
-    types: `../build/require/${submodule}/index.d.ts`,
-  }, null, 2))
-}
diff --git a/task/build/redirect/create-package-json.ts b/task/build/package/create-package-json.ts
similarity index 80%
rename from task/build/redirect/create-package-json.ts
rename to task/build/package/create-package-json.ts
index d25cc61c4..4113a763c 100644
--- a/task/build/redirect/create-package-json.ts
+++ b/task/build/package/create-package-json.ts
@@ -48,13 +48,12 @@ function resolvePackageJson(submodules: string[]) {
 function resolveSubmoduleExports(submodule: string) {
   return {
     require: {
-      types: `./build/require/${submodule}/index.d.ts`,
-      default: `./build/require/${submodule}/index.js`,
+      types: `./build/cjs/${submodule}/index.d.ts`,
+      default: `./build/cjs/${submodule}/index.js`,
     },
     import: {
-      types: `./build/import/${submodule}/index.d.mts`,
-      default: `./build/import/${submodule}/index.mjs`,
-      
+      types: `./build/esm/${submodule}/index.d.mts`,
+      default: `./build/esm/${submodule}/index.mjs`,
     }
   }
 }
@@ -66,13 +65,13 @@ function resolveExports(submodules: string[]) {
     // ... and root module
     ".": {
       "require": {
-        "types": "./build/require/index.d.ts",
-        "default": "./build/require/index.js",
+        "types": "./build/cjs/index.d.ts",
+        "default": "./build/cjs/index.js",
         
       },
       "import": {
-        "types": "./build/import/index.d.mts",
-        "default": "./build/import/index.mjs",
+        "types": "./build/esm/index.d.mts",
+        "default": "./build/esm/index.mjs",
       }
     }
   })
@@ -90,9 +89,12 @@ function resolveMetadata() {
     author: packageJson.author,
     license: packageJson.license,
     repository: packageJson.repository,
-    scripts: { test: 'echo test' }, // flagged by socket.dev
-    types: "./build/require/index.d.ts",
-    main: "./build/require/index.js",
-    module: "./build/import/index.mjs",
+    // flagged by socket.dev if not present
+    scripts: { test: 'echo test' },
+    // disable auto bundle strategy: see https://github.com/esm-dev/esm.sh#bundling-strategy
+    'esm.sh': { 'bundle': false }, 
+    types: "./build/cjs/index.d.ts",
+    main: "./build/cjs/index.js",
+    module: "./build/esm/index.mjs"
   }
 }

From e21b8746303fc0e3ef738dd1d1382af9927554c9 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 3 May 2024 21:40:44 +0900
Subject: [PATCH 258/369] Revision 0.32.28 (#861)

* Fix Encode Property Check

* Test Case for Nested Transform Encode

* Version
---
 package-lock.json                      |  4 ++--
 package.json                           |  2 +-
 src/value/transform/encode.ts          |  4 ++--
 test/runtime/value/transform/object.ts | 22 ++++++++++++++++++++++
 4 files changed, 27 insertions(+), 5 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 9e69929a7..120d4b5de 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.27",
+  "version": "0.32.28",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.27",
+      "version": "0.32.28",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 16ed2818e..f84806a1b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.27",
+  "version": "0.32.28",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/transform/encode.ts b/src/value/transform/encode.ts
index be1a507b9..80ee98562 100644
--- a/src/value/transform/encode.ts
+++ b/src/value/transform/encode.ts
@@ -122,10 +122,10 @@ function FromNot(schema: TNot, references: TSchema[], path: string, value: any)
 // prettier-ignore
 function FromObject(schema: TObject, references: TSchema[], path: string, value: any) {
   const defaulted = Default(schema, path, value)
-  if (!IsStandardObject(value)) return defaulted
+  if (!IsStandardObject(defaulted)) return defaulted
   const knownKeys = KeyOfPropertyKeys(schema) as string[]
   const knownProperties = { ...defaulted } as Record<PropertyKey, unknown>
-  for(const key of knownKeys) if(key in value) {
+  for(const key of knownKeys) if(key in knownProperties) {
     knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key])
   }
   if (!IsSchema(schema.additionalProperties)) {
diff --git a/test/runtime/value/transform/object.ts b/test/runtime/value/transform/object.ts
index 0a73a998e..db5119127 100644
--- a/test/runtime/value/transform/object.ts
+++ b/test/runtime/value/transform/object.ts
@@ -151,4 +151,26 @@ describe('value/transform/Object', () => {
   it('Should throw on map decode', () => {
     Assert.Throws(() => Encoder.Decode(T5, {}))
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/859
+  // ----------------------------------------------------------------
+  // prettier-ignore
+  it('Should decode for nested transform with renamed property', () => {
+    class User { constructor(public name: string, public createdAt: Date) {} }
+    const TDate = Type.Transform(Type.Number())
+      .Decode(v => new Date(v))
+      .Encode(v => v.getTime())
+    const TUser = Type.Transform(Type.Object({
+      name: Type.String(),
+      created_at: TDate
+    }))
+      .Decode(v => new User(v.name, v.created_at))
+      .Encode(v => ({ name: v.name, created_at: v.createdAt }))
+
+    const D = Value.Decode(TUser, { name: 'name', created_at: 0 })
+    const E = Value.Encode(TUser, D)
+
+    Assert.IsEqual(E.name, 'name')
+    Assert.IsEqual(E.created_at, 0)
+  })
 })

From 7a42aeef5bb989c07bbfc9acdbd9d74b3febed05 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 5 May 2024 05:45:40 +0900
Subject: [PATCH 259/369] Revision 0.32.29 (#862)

* Optimize Intersect Encode and Decode

* Version
---
 package-lock.json                        |  4 +--
 package.json                             |  2 +-
 src/type/keyof/index.ts                  |  1 +
 src/type/keyof/keyof-property-entries.ts | 42 ++++++++++++++++++++++++
 src/value/transform/decode.ts            |  9 ++---
 src/value/transform/encode.ts            |  9 ++---
 src/value/value/value.ts                 |  6 ++--
 7 files changed, 59 insertions(+), 14 deletions(-)
 create mode 100644 src/type/keyof/keyof-property-entries.ts

diff --git a/package-lock.json b/package-lock.json
index 120d4b5de..28bd5810f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.28",
+  "version": "0.32.29",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.28",
+      "version": "0.32.29",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index f84806a1b..e8e4708ef 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.28",
+  "version": "0.32.29",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/keyof/index.ts b/src/type/keyof/index.ts
index ecaa5e169..67512251b 100644
--- a/src/type/keyof/index.ts
+++ b/src/type/keyof/index.ts
@@ -27,5 +27,6 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 export * from './keyof-from-mapped-result'
+export * from './keyof-property-entries'
 export * from './keyof-property-keys'
 export * from './keyof'
diff --git a/src/type/keyof/keyof-property-entries.ts b/src/type/keyof/keyof-property-entries.ts
new file mode 100644
index 000000000..f8eb236f9
--- /dev/null
+++ b/src/type/keyof/keyof-property-entries.ts
@@ -0,0 +1,42 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { IndexFromPropertyKeys } from '../indexed/indexed'
+import { KeyOfPropertyKeys } from './keyof-property-keys'
+import { TSchema } from '../schema/index'
+
+/**
+ * `[Utility]` Resolves an array of keys and schemas from the given schema. This method is faster
+ * than obtaining the keys and resolving each individually via indexing. This method was written
+ * accellerate Intersect and Union encoding.
+ */
+export function KeyOfPropertyEntries(schema: TSchema): [key: string, schema: TSchema][] {
+  const keys = KeyOfPropertyKeys(schema) as string[]
+  const schemas = IndexFromPropertyKeys(schema, keys)
+  return keys.map((_, index) => [keys[index], schemas[index]])
+}
diff --git a/src/value/transform/decode.ts b/src/value/transform/decode.ts
index 00edd6d98..e6ffb9a5a 100644
--- a/src/value/transform/decode.ts
+++ b/src/value/transform/decode.ts
@@ -29,7 +29,7 @@ THE SOFTWARE.
 import { Kind, TransformKind } from '../../type/symbols/index'
 import { TypeBoxError } from '../../type/error/index'
 import { ValueError } from '../../errors/index'
-import { KeyOfPropertyKeys } from '../../type/keyof/index'
+import { KeyOfPropertyKeys, KeyOfPropertyEntries } from '../../type/keyof/index'
 import { Index } from '../../type/indexed/index'
 import { Deref } from '../deref/index'
 import { Check } from '../check/index'
@@ -98,10 +98,11 @@ function FromArray(schema: TArray, references: TSchema[], path: string, value: a
 // prettier-ignore
 function FromIntersect(schema: TIntersect, references: TSchema[], path: string, value: any) {
   if (!IsStandardObject(value) || IsValueType(value)) return Default(schema, path, value)
-  const knownKeys = KeyOfPropertyKeys(schema) as string[]
+  const knownEntries = KeyOfPropertyEntries(schema)
+  const knownKeys = knownEntries.map(entry => entry[0])
   const knownProperties = { ...value } as Record<PropertyKey, unknown>
-  for(const key of knownKeys) if(key in knownProperties) {
-    knownProperties[key] = Visit(Index(schema, [key]), references, `${path}/${key}`, knownProperties[key])
+  for(const [knownKey, knownSchema] of knownEntries) if(knownKey in knownProperties) {
+    knownProperties[knownKey] = Visit(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey])
   }
   if (!IsTransform(schema.unevaluatedProperties)) {
     return Default(schema, path, knownProperties)
diff --git a/src/value/transform/encode.ts b/src/value/transform/encode.ts
index 80ee98562..39a43cf9e 100644
--- a/src/value/transform/encode.ts
+++ b/src/value/transform/encode.ts
@@ -29,7 +29,7 @@ THE SOFTWARE.
 import { Kind, TransformKind } from '../../type/symbols/index'
 import { TypeBoxError } from '../../type/error/index'
 import { ValueError } from '../../errors/index'
-import { KeyOfPropertyKeys } from '../../type/keyof/index'
+import { KeyOfPropertyKeys, KeyOfPropertyEntries } from '../../type/keyof/index'
 import { Index } from '../../type/indexed/index'
 import { Deref } from '../deref/index'
 import { Check } from '../check/index'
@@ -99,10 +99,11 @@ function FromArray(schema: TArray, references: TSchema[], path: string, value: a
 function FromIntersect(schema: TIntersect, references: TSchema[], path: string, value: any) {
   const defaulted = Default(schema, path, value)
   if (!IsStandardObject(value) || IsValueType(value)) return defaulted
-  const knownKeys = KeyOfPropertyKeys(schema) as string[]
+  const knownEntries = KeyOfPropertyEntries(schema)
+  const knownKeys = knownEntries.map(entry => entry[0])
   const knownProperties = { ...defaulted } as Record<PropertyKey, unknown>
-  for(const key of knownKeys) if(key in knownProperties) {
-    knownProperties[key] = Visit(Index(schema, [key]), references, `${path}/${key}`, knownProperties[key])
+  for(const [knownKey, knownSchema] of knownEntries) if(knownKey in knownProperties) {
+    knownProperties[knownKey] = Visit(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey])
   }
   if (!IsTransform(schema.unevaluatedProperties)) {
     return Default(schema, path, knownProperties)
diff --git a/src/value/value/value.ts b/src/value/value/value.ts
index 1228fa827..944d27d60 100644
--- a/src/value/value/value.ts
+++ b/src/value/value/value.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { TransformDecode, TransformEncode, TransformDecodeCheckError, TransformEncodeCheckError } from '../transform/index'
+import { HasTransform, TransformDecode, TransformEncode, TransformDecodeCheckError, TransformEncodeCheckError } from '../transform/index'
 import { Mutate as MutateValue, type Mutable } from '../mutate/index'
 import { Hash as HashValue } from '../hash/index'
 import { Equal as EqualValue } from '../equal/index'
@@ -95,7 +95,7 @@ export function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, value:
 export function Decode(...args: any[]) {
   const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
   if (!Check(schema, references, value)) throw new TransformDecodeCheckError(schema, value, Errors(schema, references, value).First()!)
-  return TransformDecode(schema, references, value)
+  return HasTransform(schema, references) ? TransformDecode(schema, references, value) : value
 }
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export function Default(schema: TSchema, references: TSchema[], value: unknown): unknown
@@ -112,7 +112,7 @@ export function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, value:
 /** Encodes a value or throws if error */
 export function Encode(...args: any[]) {
   const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
-  const encoded = TransformEncode(schema, references, value)
+  const encoded = HasTransform(schema, references) ? TransformEncode(schema, references, value) : value
   if (!Check(schema, references, encoded)) throw new TransformEncodeCheckError(schema, encoded, Errors(schema, references, encoded).First()!)
   return encoded
 }

From 24c8639fbf3449dc540a3994d09e15e7757dd536 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 11 May 2024 18:14:22 +0900
Subject: [PATCH 260/369] Revision 0.32.30 (#868)

* Support Encode Decode for Null Prototype

* Version
---
 package-lock.json                      |  4 ++--
 package.json                           |  2 +-
 src/value/guard/guard.ts               |  2 +-
 test/runtime/value/guard/guard.ts      |  4 ++++
 test/runtime/value/transform/object.ts | 17 ++++++++++++++++-
 5 files changed, 24 insertions(+), 5 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 28bd5810f..ee68e061f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.29",
+  "version": "0.32.30",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.29",
+      "version": "0.32.30",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index e8e4708ef..af3523404 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.29",
+  "version": "0.32.30",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/guard/guard.ts b/src/value/guard/guard.ts
index 14c575dca..942560b78 100644
--- a/src/value/guard/guard.ts
+++ b/src/value/guard/guard.ts
@@ -61,7 +61,7 @@ export function IsIterator(value: unknown): value is IterableIterator<any> {
 // --------------------------------------------------------------------------
 /** Returns true if this value is not an instance of a class */
 export function IsStandardObject(value: unknown): value is ObjectType {
-  return IsObject(value) && !IsArray(value) && IsFunction(value.constructor) && value.constructor.name === 'Object'
+  return IsObject(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)
 }
 /** Returns true if this value is an instance of a class */
 export function IsInstanceObject(value: unknown): value is ObjectType {
diff --git a/test/runtime/value/guard/guard.ts b/test/runtime/value/guard/guard.ts
index cd775097c..88aaec6f2 100644
--- a/test/runtime/value/guard/guard.ts
+++ b/test/runtime/value/guard/guard.ts
@@ -197,6 +197,10 @@ describe('value/guard/ValueGuard', () => {
     const R = ValueGuard.IsStandardObject(new (class {})())
     Assert.IsFalse(R)
   })
+  it('Should guard StandardObject 5', () => {
+    const R = ValueGuard.IsStandardObject(Object.create(null))
+    Assert.IsTrue(R)
+  })
   // -----------------------------------------------------
   // IsInstanceObject
   // -----------------------------------------------------
diff --git a/test/runtime/value/transform/object.ts b/test/runtime/value/transform/object.ts
index db5119127..9425e4de6 100644
--- a/test/runtime/value/transform/object.ts
+++ b/test/runtime/value/transform/object.ts
@@ -3,6 +3,7 @@ import { Assert } from '../../assert'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
 
+// prettier-ignore
 describe('value/transform/Object', () => {
   // --------------------------------------------------------
   // Identity
@@ -154,7 +155,6 @@ describe('value/transform/Object', () => {
   // ----------------------------------------------------------------
   // https://github.com/sinclairzx81/typebox/issues/859
   // ----------------------------------------------------------------
-  // prettier-ignore
   it('Should decode for nested transform with renamed property', () => {
     class User { constructor(public name: string, public createdAt: Date) {} }
     const TDate = Type.Transform(Type.Number())
@@ -173,4 +173,19 @@ describe('value/transform/Object', () => {
     Assert.IsEqual(E.name, 'name')
     Assert.IsEqual(E.created_at, 0)
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/865
+  // ----------------------------------------------------------------
+  it('Should decode for null prototype', () => {
+    const N = Type.Transform(Type.Number())
+      .Decode(value => value.toString())
+      .Encode(value => parseInt(value))
+    const T = Type.Object({ x: N })
+    const A = Object.create(null); A.x = 1
+    const B = Object.create(null); B.x = '1'
+    const D = Value.Decode(T, A)
+    const E = Value.Encode(T, B)
+    Assert.IsEqual(D, { x: '1' })    
+    Assert.IsEqual(E, { x: 1 })
+  })
 })

From 95d5a3e5a86110c4690b470d77e6330e8bcb9e91 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 24 May 2024 13:56:58 +0900
Subject: [PATCH 261/369] Revision 0.32.31 (#881)

* Deref Union Variants on Cast

* Version
---
 package-lock.json                |  4 ++--
 package.json                     |  2 +-
 src/value/cast/cast.ts           |  5 +++--
 src/value/deref/deref.ts         | 15 +++++++++++----
 test/runtime/value/cast/union.ts | 16 ++++++++++++++++
 5 files changed, 33 insertions(+), 9 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index ee68e061f..33b9131a7 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.30",
+  "version": "0.32.31",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.30",
+      "version": "0.32.31",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index af3523404..8ae41d115 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.30",
+  "version": "0.32.31",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/cast/cast.ts b/src/value/cast/cast.ts
index 999e9379a..c3313f7b1 100644
--- a/src/value/cast/cast.ts
+++ b/src/value/cast/cast.ts
@@ -80,8 +80,9 @@ function ScoreUnion(schema: TSchema, references: TSchema[], value: any): number
   }
 }
 function SelectUnion(union: TUnion, references: TSchema[], value: any): TSchema {
-  let [select, best] = [union.anyOf[0], 0]
-  for (const schema of union.anyOf) {
+  const schemas = union.anyOf.map((schema) => Deref(schema, references))
+  let [select, best] = [schemas[0], 0]
+  for (const schema of schemas) {
     const score = ScoreUnion(schema, references, value)
     if (score > best) {
       select = schema
diff --git a/src/value/deref/deref.ts b/src/value/deref/deref.ts
index c51fc23f7..91a77915c 100644
--- a/src/value/deref/deref.ts
+++ b/src/value/deref/deref.ts
@@ -30,15 +30,22 @@ import type { TSchema } from '../../type/schema/index'
 import type { TRef } from '../../type/ref/index'
 import type { TThis } from '../../type/recursive/index'
 import { TypeBoxError } from '../../type/error/index'
+import { Kind } from '../../type/symbols/index'
 
 export class TypeDereferenceError extends TypeBoxError {
   constructor(public readonly schema: TRef | TThis) {
     super(`Unable to dereference schema with $id '${schema.$id}'`)
   }
 }
+function Resolve(schema: TThis | TRef, references: TSchema[]): TSchema {
+  const target = references.find((target) => target.$id === schema.$ref)
+  if (target === undefined) throw new TypeDereferenceError(schema)
+  return Deref(target, references)
+}
 /** Dereferences a schema from the references array or throws if not found */
-export function Deref(schema: TRef | TThis, references: TSchema[]): TSchema {
-  const index = references.findIndex((target) => target.$id === schema.$ref)
-  if (index === -1) throw new TypeDereferenceError(schema)
-  return references[index]
+export function Deref(schema: TSchema, references: TSchema[]): TSchema {
+  // prettier-ignore
+  return (schema[Kind] === 'This' || schema[Kind] === 'Ref') 
+    ? Resolve(schema as never, references)
+    : schema
 }
diff --git a/test/runtime/value/cast/union.ts b/test/runtime/value/cast/union.ts
index 33d77b41d..d9ae73020 100644
--- a/test/runtime/value/cast/union.ts
+++ b/test/runtime/value/cast/union.ts
@@ -145,4 +145,20 @@ describe('value/cast/Union', () => {
       value: 'B',
     })
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/880
+  // ----------------------------------------------------------------
+  // prettier-ignore
+  it('Should dereference union variants', () => {
+    const A = Type.Object({ type: Type.Literal('A') }, { $id: 'A' })
+    const B = Type.Object({ type: Type.Literal('B'), value: Type.Number() }, { $id: 'B' })
+    const RA = Type.Union([A, B])
+    const RB = Type.Union([Type.Ref(A), Type.Ref(B)])
+    // variant 0
+    Assert.IsEqual(Value.Cast(RA, [A, B], { type: 'B' }), { type: 'B', value: 0 })
+    Assert.IsEqual(Value.Cast(RB, [A, B], { type: 'B' }), { type: 'B', value: 0 })
+    // variant 1
+    Assert.IsEqual(Value.Cast(RA, [A, B], { type: 'A' }), { type: 'A' })
+    Assert.IsEqual(Value.Cast(RB, [A, B], { type: 'A' }), { type: 'A' })
+  })
 })

From 7ef8e833d53d12639b0bf606308f6e3e886bff74 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 13 Jun 2024 05:22:25 +0900
Subject: [PATCH 262/369] Revision 0.32.32 (#898)

* Fix Mapped Enum

* Test Case

* Version
---
 package-lock.json         | 293 ++++++++++----------------------------
 package.json              |   4 +-
 src/type/mapped/mapped.ts |  27 ++--
 test/static/mapped.ts     |  13 ++
 4 files changed, 104 insertions(+), 233 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 33b9131a7..aa5289c4c 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.31",
+  "version": "0.32.32",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.31",
+      "version": "0.32.32",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
@@ -15,7 +15,7 @@
         "@types/node": "^20.10.1",
         "ajv": "^8.12.0",
         "ajv-formats": "^2.1.1",
-        "mocha": "^9.2.2",
+        "mocha": "^10.4.0",
         "prettier": "^2.7.1",
         "typescript": "^5.4.5"
       }
@@ -141,12 +141,6 @@
         "undici-types": "~5.26.4"
       }
     },
-    "node_modules/@ungap/promise-all-settled": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/@ungap/promise-all-settled/-/promise-all-settled-1.1.2.tgz",
-      "integrity": "sha512-sL/cEvJWAnClXw0wHk85/2L0G6Sj8UB0Ctc1TEMbKSsmpRosqhwj9gWgFRZSrBr2f9tiXISwNhCPmlfqUqyb9Q==",
-      "dev": true
-    },
     "node_modules/ajv": {
       "version": "8.12.0",
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz",
@@ -269,22 +263,21 @@
       }
     },
     "node_modules/brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
+      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
       "dev": true,
       "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
+        "balanced-match": "^1.0.0"
       }
     },
     "node_modules/braces": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
-      "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
       "dev": true,
       "dependencies": {
-        "fill-range": "^7.0.1"
+        "fill-range": "^7.1.1"
       },
       "engines": {
         "node": ">=8"
@@ -447,16 +440,10 @@
         "node": ">=14"
       }
     },
-    "node_modules/concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
-      "dev": true
-    },
     "node_modules/debug": {
-      "version": "4.3.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.3.tgz",
-      "integrity": "sha512-/zxw5+vh1Tfv+4Qn7a5nsbcJKPaSvCDhojn6FEl9vupwK2VCSDtEiEtqr8DFtzYFOdz63LBkxec7DYuc2jon6Q==",
+      "version": "4.3.4",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
+      "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==",
       "dev": true,
       "dependencies": {
         "ms": "2.1.2"
@@ -912,9 +899,9 @@
       "dev": true
     },
     "node_modules/fill-range": {
-      "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
-      "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
       "dev": true,
       "dependencies": {
         "to-regex-range": "^5.0.1"
@@ -978,20 +965,20 @@
       }
     },
     "node_modules/glob": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz",
-      "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==",
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz",
+      "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
       "dev": true,
       "dependencies": {
         "fs.realpath": "^1.0.0",
         "inflight": "^1.0.4",
         "inherits": "2",
-        "minimatch": "^3.0.4",
-        "once": "^1.3.0",
-        "path-is-absolute": "^1.0.0"
+        "minimatch": "^5.0.1",
+        "once": "^1.3.0"
       },
       "engines": {
-        "node": "*"
+        "node": ">=12"
       },
       "funding": {
         "url": "https://github.com/sponsors/isaacs"
@@ -1009,27 +996,6 @@
         "node": ">= 6"
       }
     },
-    "node_modules/glob/node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/growl": {
-      "version": "1.10.5",
-      "resolved": "https://registry.npmjs.org/growl/-/growl-1.10.5.tgz",
-      "integrity": "sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==",
-      "dev": true,
-      "engines": {
-        "node": ">=4.x"
-      }
-    },
     "node_modules/has-flag": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
@@ -1052,6 +1018,7 @@
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
       "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
       "dev": true,
       "dependencies": {
         "once": "^1.3.0",
@@ -1136,12 +1103,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/isexe": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
-      "dev": true
-    },
     "node_modules/js-yaml": {
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
@@ -1248,58 +1209,50 @@
       }
     },
     "node_modules/minimatch": {
-      "version": "4.2.1",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-4.2.1.tgz",
-      "integrity": "sha512-9Uq1ChtSZO+Mxa/CL1eGizn2vRn3MlLgzhT0Iz8zaY8NdvxvB0d5QdPFmCKf7JKA9Lerx5vRrnwO03jsSfGG9g==",
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.0.1.tgz",
+      "integrity": "sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==",
       "dev": true,
       "dependencies": {
-        "brace-expansion": "^1.1.7"
+        "brace-expansion": "^2.0.1"
       },
       "engines": {
         "node": ">=10"
       }
     },
     "node_modules/mocha": {
-      "version": "9.2.2",
-      "resolved": "https://registry.npmjs.org/mocha/-/mocha-9.2.2.tgz",
-      "integrity": "sha512-L6XC3EdwT6YrIk0yXpavvLkn8h+EU+Y5UcCHKECyMbdUIxyMuZj4bX4U9e1nvnvUUvQVsV2VHQr5zLdcUkhW/g==",
+      "version": "10.4.0",
+      "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.4.0.tgz",
+      "integrity": "sha512-eqhGB8JKapEYcC4ytX/xrzKforgEc3j1pGlAXVy3eRwrtAy5/nIfT1SvgGzfN0XZZxeLq0aQWkOUAmqIJiv+bA==",
       "dev": true,
       "dependencies": {
-        "@ungap/promise-all-settled": "1.1.2",
         "ansi-colors": "4.1.1",
         "browser-stdout": "1.3.1",
         "chokidar": "3.5.3",
-        "debug": "4.3.3",
+        "debug": "4.3.4",
         "diff": "5.0.0",
         "escape-string-regexp": "4.0.0",
         "find-up": "5.0.0",
-        "glob": "7.2.0",
-        "growl": "1.10.5",
+        "glob": "8.1.0",
         "he": "1.2.0",
         "js-yaml": "4.1.0",
         "log-symbols": "4.1.0",
-        "minimatch": "4.2.1",
+        "minimatch": "5.0.1",
         "ms": "2.1.3",
-        "nanoid": "3.3.1",
         "serialize-javascript": "6.0.0",
         "strip-json-comments": "3.1.1",
         "supports-color": "8.1.1",
-        "which": "2.0.2",
-        "workerpool": "6.2.0",
+        "workerpool": "6.2.1",
         "yargs": "16.2.0",
         "yargs-parser": "20.2.4",
         "yargs-unparser": "2.0.0"
       },
       "bin": {
         "_mocha": "bin/_mocha",
-        "mocha": "bin/mocha"
+        "mocha": "bin/mocha.js"
       },
       "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/mochajs"
+        "node": ">= 14.0.0"
       }
     },
     "node_modules/ms": {
@@ -1308,18 +1261,6 @@
       "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
       "dev": true
     },
-    "node_modules/nanoid": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.1.tgz",
-      "integrity": "sha512-n6Vs/3KGyxPQd6uO0eH4Bv0ojGSUvuLlIHtC3Y0kEO23YRge8H9x1GCzLn28YX0H66pMkxuaeESFq4tKISKwdw==",
-      "dev": true,
-      "bin": {
-        "nanoid": "bin/nanoid.cjs"
-      },
-      "engines": {
-        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
-      }
-    },
     "node_modules/node-emoji": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/node-emoji/-/node-emoji-2.1.3.tgz",
@@ -1392,15 +1333,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/path-is-absolute": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
-      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
-      "dev": true,
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
     "node_modules/picomatch": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
@@ -1692,25 +1624,10 @@
         "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
       }
     },
-    "node_modules/which": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
-      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
-      "dev": true,
-      "dependencies": {
-        "isexe": "^2.0.0"
-      },
-      "bin": {
-        "node-which": "bin/node-which"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
     "node_modules/workerpool": {
-      "version": "6.2.0",
-      "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.2.0.tgz",
-      "integrity": "sha512-Rsk5qQHJ9eowMH28Jwhe8HEbmdYDX4lwoMWshiCXugjtHqMD9ZbiqSDLxcsfdqsETPzVUtX5s1Z5kStiIM6l4A==",
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.2.1.tgz",
+      "integrity": "sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==",
       "dev": true
     },
     "node_modules/wrap-ansi": {
@@ -1893,12 +1810,6 @@
         "undici-types": "~5.26.4"
       }
     },
-    "@ungap/promise-all-settled": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/@ungap/promise-all-settled/-/promise-all-settled-1.1.2.tgz",
-      "integrity": "sha512-sL/cEvJWAnClXw0wHk85/2L0G6Sj8UB0Ctc1TEMbKSsmpRosqhwj9gWgFRZSrBr2f9tiXISwNhCPmlfqUqyb9Q==",
-      "dev": true
-    },
     "ajv": {
       "version": "8.12.0",
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz",
@@ -1985,22 +1896,21 @@
       "dev": true
     },
     "brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
+      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
       "dev": true,
       "requires": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
+        "balanced-match": "^1.0.0"
       }
     },
     "braces": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
-      "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
       "dev": true,
       "requires": {
-        "fill-range": "^7.0.1"
+        "fill-range": "^7.1.1"
       }
     },
     "browser-stdout": {
@@ -2119,16 +2029,10 @@
       "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==",
       "dev": true
     },
-    "concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
-      "dev": true
-    },
     "debug": {
-      "version": "4.3.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.3.tgz",
-      "integrity": "sha512-/zxw5+vh1Tfv+4Qn7a5nsbcJKPaSvCDhojn6FEl9vupwK2VCSDtEiEtqr8DFtzYFOdz63LBkxec7DYuc2jon6Q==",
+      "version": "4.3.4",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
+      "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==",
       "dev": true,
       "requires": {
         "ms": "2.1.2"
@@ -2366,9 +2270,9 @@
       "dev": true
     },
     "fill-range": {
-      "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
-      "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
       "dev": true,
       "requires": {
         "to-regex-range": "^5.0.1"
@@ -2410,28 +2314,16 @@
       "dev": true
     },
     "glob": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz",
-      "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==",
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz",
+      "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==",
       "dev": true,
       "requires": {
         "fs.realpath": "^1.0.0",
         "inflight": "^1.0.4",
         "inherits": "2",
-        "minimatch": "^3.0.4",
-        "once": "^1.3.0",
-        "path-is-absolute": "^1.0.0"
-      },
-      "dependencies": {
-        "minimatch": {
-          "version": "3.1.2",
-          "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-          "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-          "dev": true,
-          "requires": {
-            "brace-expansion": "^1.1.7"
-          }
-        }
+        "minimatch": "^5.0.1",
+        "once": "^1.3.0"
       }
     },
     "glob-parent": {
@@ -2443,12 +2335,6 @@
         "is-glob": "^4.0.1"
       }
     },
-    "growl": {
-      "version": "1.10.5",
-      "resolved": "https://registry.npmjs.org/growl/-/growl-1.10.5.tgz",
-      "integrity": "sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==",
-      "dev": true
-    },
     "has-flag": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
@@ -2525,12 +2411,6 @@
       "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==",
       "dev": true
     },
-    "isexe": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
-      "dev": true
-    },
     "js-yaml": {
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
@@ -2603,41 +2483,37 @@
       }
     },
     "minimatch": {
-      "version": "4.2.1",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-4.2.1.tgz",
-      "integrity": "sha512-9Uq1ChtSZO+Mxa/CL1eGizn2vRn3MlLgzhT0Iz8zaY8NdvxvB0d5QdPFmCKf7JKA9Lerx5vRrnwO03jsSfGG9g==",
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.0.1.tgz",
+      "integrity": "sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==",
       "dev": true,
       "requires": {
-        "brace-expansion": "^1.1.7"
+        "brace-expansion": "^2.0.1"
       }
     },
     "mocha": {
-      "version": "9.2.2",
-      "resolved": "https://registry.npmjs.org/mocha/-/mocha-9.2.2.tgz",
-      "integrity": "sha512-L6XC3EdwT6YrIk0yXpavvLkn8h+EU+Y5UcCHKECyMbdUIxyMuZj4bX4U9e1nvnvUUvQVsV2VHQr5zLdcUkhW/g==",
+      "version": "10.4.0",
+      "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.4.0.tgz",
+      "integrity": "sha512-eqhGB8JKapEYcC4ytX/xrzKforgEc3j1pGlAXVy3eRwrtAy5/nIfT1SvgGzfN0XZZxeLq0aQWkOUAmqIJiv+bA==",
       "dev": true,
       "requires": {
-        "@ungap/promise-all-settled": "1.1.2",
         "ansi-colors": "4.1.1",
         "browser-stdout": "1.3.1",
         "chokidar": "3.5.3",
-        "debug": "4.3.3",
+        "debug": "4.3.4",
         "diff": "5.0.0",
         "escape-string-regexp": "4.0.0",
         "find-up": "5.0.0",
-        "glob": "7.2.0",
-        "growl": "1.10.5",
+        "glob": "8.1.0",
         "he": "1.2.0",
         "js-yaml": "4.1.0",
         "log-symbols": "4.1.0",
-        "minimatch": "4.2.1",
+        "minimatch": "5.0.1",
         "ms": "2.1.3",
-        "nanoid": "3.3.1",
         "serialize-javascript": "6.0.0",
         "strip-json-comments": "3.1.1",
         "supports-color": "8.1.1",
-        "which": "2.0.2",
-        "workerpool": "6.2.0",
+        "workerpool": "6.2.1",
         "yargs": "16.2.0",
         "yargs-parser": "20.2.4",
         "yargs-unparser": "2.0.0"
@@ -2649,12 +2525,6 @@
       "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
       "dev": true
     },
-    "nanoid": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.1.tgz",
-      "integrity": "sha512-n6Vs/3KGyxPQd6uO0eH4Bv0ojGSUvuLlIHtC3Y0kEO23YRge8H9x1GCzLn28YX0H66pMkxuaeESFq4tKISKwdw==",
-      "dev": true
-    },
     "node-emoji": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/node-emoji/-/node-emoji-2.1.3.tgz",
@@ -2706,12 +2576,6 @@
       "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
       "dev": true
     },
-    "path-is-absolute": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
-      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
-      "dev": true
-    },
     "picomatch": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
@@ -2909,19 +2773,10 @@
         "builtins": "^5.0.0"
       }
     },
-    "which": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
-      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
-      "dev": true,
-      "requires": {
-        "isexe": "^2.0.0"
-      }
-    },
     "workerpool": {
-      "version": "6.2.0",
-      "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.2.0.tgz",
-      "integrity": "sha512-Rsk5qQHJ9eowMH28Jwhe8HEbmdYDX4lwoMWshiCXugjtHqMD9ZbiqSDLxcsfdqsETPzVUtX5s1Z5kStiIM6l4A==",
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.2.1.tgz",
+      "integrity": "sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==",
       "dev": true
     },
     "wrap-ansi": {
diff --git a/package.json b/package.json
index 8ae41d115..5067d04fc 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.31",
+  "version": "0.32.32",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -35,7 +35,7 @@
     "@types/node": "^20.10.1",
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "mocha": "^9.2.2",
+    "mocha": "^10.4.0",
     "prettier": "^2.7.1",
     "typescript": "^5.4.5"
   }
diff --git a/src/type/mapped/mapped.ts b/src/type/mapped/mapped.ts
index 77c7d37a7..797679b9c 100644
--- a/src/type/mapped/mapped.ts
+++ b/src/type/mapped/mapped.ts
@@ -35,6 +35,7 @@ import { Discard } from '../discard/index'
 import { Array, type TArray } from '../array/index'
 import { AsyncIterator, type TAsyncIterator } from '../async-iterator/index'
 import { Constructor, type TConstructor } from '../constructor/index'
+import { type TEnum, type TEnumRecord } from '../enum/index'
 import { Function as FunctionType, type TFunction } from '../function/index'
 import { IndexPropertyKeys, type TIndexPropertyKeys } from '../indexed/index'
 import { Intersect, type TIntersect } from '../intersect/index'
@@ -182,22 +183,24 @@ function FromProperties<K extends PropertyKey, T extends TProperties>(K: K, T: T
 // prettier-ignore
 type FromSchemaType<K extends PropertyKey, T extends TSchema> = (
   // unevaluated modifier types
-  T extends TReadonly<infer S> ? TReadonly<FromSchemaType<K, S>> :
-  T extends TOptional<infer S> ? TOptional<FromSchemaType<K, S>> :
+  T extends TReadonly<infer S extends TSchema> ? TReadonly<FromSchemaType<K, S>> :
+  T extends TOptional<infer S extends TSchema> ? TOptional<FromSchemaType<K, S>> :
   // unevaluated mapped types
-  T extends TMappedResult<infer P> ? TFromMappedResult<K, P> :
-  T extends TMappedKey<infer P> ? TFromMappedKey<K, P> :
+  T extends TMappedResult<infer P extends TProperties> ? TFromMappedResult<K, P> :
+  T extends TMappedKey<infer P extends PropertyKey[]> ? TFromMappedKey<K, P> :
   // unevaluated types
   T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<K, S>, FromSchemaType<K, R>> :
   T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<K, S>, FromSchemaType<K, R>> :
-  T extends TAsyncIterator<infer S> ? TAsyncIterator<FromSchemaType<K, S>> :
-  T extends TIterator<infer S> ? TIterator<FromSchemaType<K, S>> :
-  T extends TIntersect<infer S> ? TIntersect<TFromRest<K, S>> :
-  T extends TUnion<infer S> ? TUnion<TFromRest<K, S>> :
-  T extends TTuple<infer S> ? TTuple<TFromRest<K, S>> :
-  T extends TObject<infer S> ? TObject<FromProperties<K, S>> :
-  T extends TArray<infer S> ? TArray<FromSchemaType<K, S>> :
-  T extends TPromise<infer S> ? TPromise<FromSchemaType<K, S>> :
+  T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<FromSchemaType<K, S>> :
+  T extends TIterator<infer S extends TSchema> ? TIterator<FromSchemaType<K, S>> :
+  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<K, S>> :
+  // note: special case for enums as these are mapped as union types.
+  T extends TEnum<infer S extends TEnumRecord> ? TEnum<S> :
+  T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<K, S>> :
+  T extends TTuple<infer S extends TSchema[]> ? TTuple<TFromRest<K, S>> :
+  T extends TObject<infer S extends TProperties> ? TObject<FromProperties<K, S>> :
+  T extends TArray<infer S extends TSchema> ? TArray<FromSchemaType<K, S>> :
+  T extends TPromise<infer S extends TSchema> ? TPromise<FromSchemaType<K, S>> :
   T
 )
 // prettier-ignore
diff --git a/test/static/mapped.ts b/test/static/mapped.ts
index 9f29b5716..1b57668b9 100644
--- a/test/static/mapped.ts
+++ b/test/static/mapped.ts
@@ -402,3 +402,16 @@ Expect(T).ToStatic<E> // ok
     y: { y: number }
   }>
 }
+// ------------------------------------------------------------------
+// With Enum
+// issue: https://github.com/sinclairzx81/typebox/issues/897
+// ------------------------------------------------------------------
+{
+  enum E {
+    A,
+    B,
+  }
+  const T = Type.Object({ a: Type.Enum(E) })
+  const M = Type.Mapped(Type.KeyOf(T), (K) => Type.Index(T, K))
+  Expect(M).ToStatic<{ a: E }>
+}

From f065cfc6d1e3e506396e9314e96701d9606c50f8 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 17 Jun 2024 19:42:53 +0900
Subject: [PATCH 263/369] Revision 0.32.33 (#905)

* Use ES2020 Target

* Version
---
 package-lock.json         | 4 ++--
 package.json              | 2 +-
 task/build/esm/compile.ts | 2 +-
 tsconfig.json             | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index aa5289c4c..5fa9b2127 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.32",
+  "version": "0.32.33",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.32",
+      "version": "0.32.33",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 5067d04fc..eeb755cc5 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.32",
+  "version": "0.32.33",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/task/build/esm/compile.ts b/task/build/esm/compile.ts
index e8beb64a5..08e0129e5 100644
--- a/task/build/esm/compile.ts
+++ b/task/build/esm/compile.ts
@@ -32,7 +32,7 @@ declare function shell(command: string): Promise<void>
 export async function compile(target: string) {
   const options = [
     `--outDir ${target}`,
-    '--target ESNext',
+    '--target ES2020',
     '--module ESNext',
     '--declaration',
   ].join(' ')
diff --git a/tsconfig.json b/tsconfig.json
index 6a47a31ec..7ba7f03ed 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     "strict": true,
-    "target": "ESNext",
+    "target": "ES2020",
     "module": "ESNext",
     "moduleResolution": "Node",
     "baseUrl": ".",

From 83e05bb43ca79cb22c9efc27e2e16caf7cb6a0e5 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 22 Jun 2024 16:20:08 +0900
Subject: [PATCH 264/369] Revision 0.32.34 (#914)

* Fix Embedded TemplateLiteral Generation

* TypeScript 5.5.2

* Version
---
 hammer.mjs                                    |  2 +-
 package-lock.json                             | 18 ++++-----
 package.json                                  |  4 +-
 src/type/template-literal/generate.ts         |  1 +
 .../type/guard/type/template-literal.ts       | 37 ++++++++++++++++++-
 test/static/template-literal.ts               | 15 ++++++++
 6 files changed, 64 insertions(+), 13 deletions(-)

diff --git a/hammer.mjs b/hammer.mjs
index d936b2034..ef5d2b894 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -32,7 +32,7 @@ export async function benchmark() {
 // Test
 // -------------------------------------------------------------------------------
 export async function test_typescript() {
-  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', 'next', 'latest']) {
+  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', '5.4.5', 'next', 'latest']) {
     await shell(`npm install typescript@${version} --no-save`)
     await test_static()
   }
diff --git a/package-lock.json b/package-lock.json
index 5fa9b2127..443474f51 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.33",
+  "version": "0.32.34",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.33",
+      "version": "0.32.34",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
@@ -17,7 +17,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^10.4.0",
         "prettier": "^2.7.1",
-        "typescript": "^5.4.5"
+        "typescript": "^5.5.2"
       }
     },
     "node_modules/@andrewbranch/untar.js": {
@@ -1576,9 +1576,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.4.5",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.4.5.tgz",
-      "integrity": "sha512-vcI4UpRgg81oIRUFwR0WSIHKt11nJ7SAVlYNIu+QpqeyXP+gpQJy/Z4+F0aGxSE4MqwjyXvW/TzgkLAx2AGHwQ==",
+      "version": "5.5.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.2.tgz",
+      "integrity": "sha512-NcRtPEOsPFFWjobJEtfihkLCZCXZt/os3zf8nTxjVH3RvTSxjrCamJpbExGvYOF+tFHc3pA65qpdwPbzjohhew==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -2738,9 +2738,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.4.5",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.4.5.tgz",
-      "integrity": "sha512-vcI4UpRgg81oIRUFwR0WSIHKt11nJ7SAVlYNIu+QpqeyXP+gpQJy/Z4+F0aGxSE4MqwjyXvW/TzgkLAx2AGHwQ==",
+      "version": "5.5.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.2.tgz",
+      "integrity": "sha512-NcRtPEOsPFFWjobJEtfihkLCZCXZt/os3zf8nTxjVH3RvTSxjrCamJpbExGvYOF+tFHc3pA65qpdwPbzjohhew==",
       "dev": true
     },
     "undici-types": {
diff --git a/package.json b/package.json
index eeb755cc5..0afff5aa8 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.33",
+  "version": "0.32.34",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -37,6 +37,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^10.4.0",
     "prettier": "^2.7.1",
-    "typescript": "^5.4.5"
+    "typescript": "^5.5.2"
   }
 }
diff --git a/src/type/template-literal/generate.ts b/src/type/template-literal/generate.ts
index 9bc857fd7..22d87a99a 100644
--- a/src/type/template-literal/generate.ts
+++ b/src/type/template-literal/generate.ts
@@ -83,6 +83,7 @@ type TFromTemplateLiteralUnionKinds<T extends TTemplateLiteralKind[]> =
 type TFromTemplateLiteralKinds<T extends TTemplateLiteralKind[], Acc extends TLiteralValue[][] = []> = 
   T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]]
     ? (
+     L extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<[...S, ...R], Acc> : 
      L extends TLiteral<infer S extends TLiteralValue> ? TFromTemplateLiteralKinds<R, [...Acc, [S]]> : 
      L extends TUnion<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<R, [...Acc, TFromTemplateLiteralUnionKinds<S>]> : 
      L extends TBoolean ? TFromTemplateLiteralKinds<R, [...Acc, ['true', 'false']]> : 
diff --git a/test/runtime/type/guard/type/template-literal.ts b/test/runtime/type/guard/type/template-literal.ts
index 7b0f98ce4..63fb736aa 100644
--- a/test/runtime/type/guard/type/template-literal.ts
+++ b/test/runtime/type/guard/type/template-literal.ts
@@ -1,5 +1,5 @@
 import { TypeGuard } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, TemplateLiteralGenerate } from '@sinclair/typebox'
 import { Assert } from '../../../assert/index'
 
 describe('guard/type/TTemplateLiteral', () => {
@@ -44,4 +44,39 @@ describe('guard/type/TTemplateLiteral', () => {
     T.pattern = T.pattern.slice(0, T.pattern.length - 1)
     Assert.IsFalse(TypeGuard.IsTemplateLiteral(T))
   })
+  // ----------------------------------------------------------------
+  // issue: https://github.com/sinclairzx81/typebox/issues/913
+  // ----------------------------------------------------------------
+  it('Should generate embedded template literal 1', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('X'), Type.Literal('Y')])])
+    const L = Type.TemplateLiteral([Type.Literal('KEY'), A, B])
+    const T = TemplateLiteralGenerate(L)
+    Assert.IsEqual(T, ['KEYAX', 'KEYAY', 'KEYBX', 'KEYBY'])
+  })
+  it('Should generate embedded template literal 2', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('X'), Type.Literal('Y')])])
+    const L = Type.TemplateLiteral([A, Type.Literal('KEY'), B])
+    const T = TemplateLiteralGenerate(L)
+    Assert.IsEqual(T, ['AKEYX', 'AKEYY', 'BKEYX', 'BKEYY'])
+  })
+  it('Should generate embedded template literal 3', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('X'), Type.Literal('Y')])])
+    const L = Type.TemplateLiteral([A, B, Type.Literal('KEY')])
+    const T = TemplateLiteralGenerate(L)
+    Assert.IsEqual(T, ['AXKEY', 'AYKEY', 'BXKEY', 'BYKEY'])
+  })
+  it('Should map embedded template literal', () => {
+    const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+    const B = Type.TemplateLiteral([Type.Union([Type.Literal('X'), Type.Literal('Y')])])
+    const L = Type.TemplateLiteral([Type.Literal('KEY'), A, B])
+    const T = Type.Mapped(L, (K) => Type.Null())
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsNull(T.properties.KEYAX))
+    Assert.IsTrue(TypeGuard.IsNull(T.properties.KEYAY))
+    Assert.IsTrue(TypeGuard.IsNull(T.properties.KEYBX))
+    Assert.IsTrue(TypeGuard.IsNull(T.properties.KEYBY))
+  })
 })
diff --git a/test/static/template-literal.ts b/test/static/template-literal.ts
index 773ee1fa1..574d0e949 100644
--- a/test/static/template-literal.ts
+++ b/test/static/template-literal.ts
@@ -112,3 +112,18 @@ import { Type } from '@sinclair/typebox'
     '$propAx}Yx' | '$propBx}Yx' | '$propCx}Yx'
   >()
 }
+// ---------------------------------------------------------------------
+// issue: https://github.com/sinclairzx81/typebox/issues/913
+// ---------------------------------------------------------------------
+{
+  const A = Type.TemplateLiteral([Type.Union([Type.Literal('A'), Type.Literal('B')])])
+  const B = Type.TemplateLiteral([Type.Union([Type.Literal('X'), Type.Literal('Y')])])
+  const L = Type.TemplateLiteral([Type.Literal('KEY'), A, B])
+  const T = Type.Mapped(L, (K) => Type.Null())
+  Expect(T).ToStatic<{
+    KEYAX: null
+    KEYAY: null
+    KEYBX: null
+    KEYBY: null
+  }>()
+}

From e686997fcdfaec286520af7e3adecf685805e2e3 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 23 Jul 2024 03:08:57 +0900
Subject: [PATCH 265/369] Revision 0.32.35 (#932)

* Support Any and Never Record Keys

* Update Require Property Message

* Ensure Record Enumerable on Convert

* TypeScript 5.5.3

* Version
---
 hammer.mjs                             |  2 +-
 package-lock.json                      | 18 ++++----
 package.json                           |  4 +-
 src/errors/function.ts                 |  2 +-
 src/type/patterns/patterns.ts          |  2 +
 src/type/record/record.ts              | 31 +++++++++++++-
 src/value/convert/convert.ts           |  2 +
 test/runtime/compiler-ajv/record.ts    | 52 +++++++++++++++++++++++
 test/runtime/compiler/record.ts        | 52 +++++++++++++++++++++++
 test/runtime/type/guard/kind/record.ts | 26 ++++++++++--
 test/runtime/type/guard/type/record.ts | 28 +++++++++++--
 test/runtime/value/check/record.ts     | 58 ++++++++++++++++++++++++++
 test/runtime/value/convert/record.ts   | 33 +++++++++++++++
 test/static/record.ts                  | 13 ++++++
 14 files changed, 302 insertions(+), 21 deletions(-)

diff --git a/hammer.mjs b/hammer.mjs
index ef5d2b894..20af660ca 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -32,7 +32,7 @@ export async function benchmark() {
 // Test
 // -------------------------------------------------------------------------------
 export async function test_typescript() {
-  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', '5.4.5', 'next', 'latest']) {
+  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', '5.4.5', '5.5.2', 'next', 'latest']) {
     await shell(`npm install typescript@${version} --no-save`)
     await test_static()
   }
diff --git a/package-lock.json b/package-lock.json
index 443474f51..f75983e2a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.34",
+  "version": "0.32.35",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.34",
+      "version": "0.32.35",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
@@ -17,7 +17,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^10.4.0",
         "prettier": "^2.7.1",
-        "typescript": "^5.5.2"
+        "typescript": "^5.5.3"
       }
     },
     "node_modules/@andrewbranch/untar.js": {
@@ -1576,9 +1576,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.5.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.2.tgz",
-      "integrity": "sha512-NcRtPEOsPFFWjobJEtfihkLCZCXZt/os3zf8nTxjVH3RvTSxjrCamJpbExGvYOF+tFHc3pA65qpdwPbzjohhew==",
+      "version": "5.5.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.3.tgz",
+      "integrity": "sha512-/hreyEujaB0w76zKo6717l3L0o/qEUtRgdvUBvlkhoWeOVMjMuHNHk0BRBzikzuGDqNmPQbg5ifMEqsHLiIUcQ==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -2738,9 +2738,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.5.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.2.tgz",
-      "integrity": "sha512-NcRtPEOsPFFWjobJEtfihkLCZCXZt/os3zf8nTxjVH3RvTSxjrCamJpbExGvYOF+tFHc3pA65qpdwPbzjohhew==",
+      "version": "5.5.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.3.tgz",
+      "integrity": "sha512-/hreyEujaB0w76zKo6717l3L0o/qEUtRgdvUBvlkhoWeOVMjMuHNHk0BRBzikzuGDqNmPQbg5ifMEqsHLiIUcQ==",
       "dev": true
     },
     "undici-types": {
diff --git a/package.json b/package.json
index 0afff5aa8..967cc46e0 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.34",
+  "version": "0.32.35",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -37,6 +37,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^10.4.0",
     "prettier": "^2.7.1",
-    "typescript": "^5.5.2"
+    "typescript": "^5.5.3"
   }
 }
diff --git a/src/errors/function.ts b/src/errors/function.ts
index 8bb1605dd..94504c5ad 100644
--- a/src/errors/function.ts
+++ b/src/errors/function.ts
@@ -124,7 +124,7 @@ export function DefaultErrorFunction(error: ErrorFunctionParameter) {
     case ValueErrorType.ObjectMinProperties:
       return `Expected object to have at least ${error.schema.minProperties} properties`
     case ValueErrorType.ObjectRequiredProperty:
-      return 'Required property'
+      return 'Expected required property'
     case ValueErrorType.Promise:
       return 'Expected Promise'
     case ValueErrorType.RegExp:
diff --git a/src/type/patterns/patterns.ts b/src/type/patterns/patterns.ts
index 016d60424..9c9e910a2 100644
--- a/src/type/patterns/patterns.ts
+++ b/src/type/patterns/patterns.ts
@@ -29,6 +29,8 @@ THE SOFTWARE.
 export const PatternBoolean = '(true|false)'
 export const PatternNumber = '(0|[1-9][0-9]*)'
 export const PatternString = '(.*)'
+export const PatternNever = '(?!.*)'
 export const PatternBooleanExact = `^${PatternBoolean}$`
 export const PatternNumberExact = `^${PatternNumber}$`
 export const PatternStringExact = `^${PatternString}$`
+export const PatternNeverExact = `^${PatternNever}$`
diff --git a/src/type/record/record.ts b/src/type/record/record.ts
index e94902712..cc6e9e7b8 100644
--- a/src/type/record/record.ts
+++ b/src/type/record/record.ts
@@ -29,6 +29,7 @@ THE SOFTWARE.
 import type { TSchema } from '../schema/index'
 import type { Static } from '../static/index'
 import type { Evaluate, Ensure, Assert } from '../helpers/index'
+import { type TAny } from '../any/index'
 import { Object, type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index'
 import { type TLiteral, type TLiteralValue } from '../literal/index'
 import { Never, type TNever } from '../never/index'
@@ -40,7 +41,7 @@ import { type TNumber } from '../number/index'
 import { type TEnum } from '../enum/index'
 
 import { IsTemplateLiteralFinite, TIsTemplateLiteralFinite, type TTemplateLiteral } from '../template-literal/index'
-import { PatternStringExact, PatternNumberExact } from '../patterns/index'
+import { PatternStringExact, PatternNumberExact, PatternNeverExact } from '../patterns/index'
 import { IndexPropertyKeys } from '../indexed/index'
 import { Kind, Hint } from '../symbols/index'
 import { CloneType } from '../clone/type'
@@ -51,7 +52,7 @@ import { IsUndefined } from '../guard/value'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsInteger, IsLiteral, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion } from '../guard/kind'
+import { IsInteger, IsLiteral, IsAny, IsNever, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion } from '../guard/kind'
 // ------------------------------------------------------------------
 // RecordCreateFromPattern
 // ------------------------------------------------------------------
@@ -156,6 +157,28 @@ function FromStringKey<K extends TString, T extends TSchema>(K: K, T: T, options
   return RecordCreateFromPattern(pattern, T, options) as never
 }
 // ------------------------------------------------------------------
+// FromAnyKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromAnyKey<_ extends TAny, T extends TSchema> = (
+  Ensure<TRecord<TAny, T>>
+)
+// prettier-ignore
+function FromAnyKey<K extends TAny, T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromAnyKey<K, T> {
+  return RecordCreateFromPattern(PatternStringExact, T, options) as never
+}
+// ------------------------------------------------------------------
+// FromNeverKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromNeverKey<_ extends TNever, T extends TSchema> = (
+  Ensure<TRecord<TNever, T>>
+)
+// prettier-ignore
+function FromNeverKey<K extends TNever, T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromNeverKey<K, T> {
+  return RecordCreateFromPattern(PatternNeverExact, T, options) as never
+}
+// ------------------------------------------------------------------
 // FromIntegerKey
 // ------------------------------------------------------------------
 // prettier-ignore
@@ -205,6 +228,8 @@ export type TRecordOrObject<K extends TSchema, T extends TSchema> =
   K extends TNumber ? TFromNumberKey<K, T> :
   K extends TRegExp ? TFromRegExpKey<K, T> :
   K extends TString ? TFromStringKey<K, T> :
+  K extends TAny ? TFromAnyKey<K, T> :
+  K extends TNever ? TFromNeverKey<K, T> :
   TNever
 // ------------------------------------------------------------------
 // TRecordOrObject
@@ -220,6 +245,8 @@ export function Record<K extends TSchema, T extends TSchema>(K: K, T: T, options
     IsNumber(K) ? FromNumberKey(K, T, options) :
     IsRegExp(K) ? FromRegExpKey(K, T, options) :
     IsString(K) ? FromStringKey(K, T, options) :
+    IsAny(K) ? FromAnyKey(K, T, options) :
+    IsNever(K) ? FromNeverKey(K, T, options) :
     Never(options)
   ) as never
 }
diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index 9d8191342..21d1dbbcc 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -203,6 +203,8 @@ function FromObject(schema: TObject, references: TSchema[], value: any): unknown
   return result
 }
 function FromRecord(schema: TRecord, references: TSchema[], value: any): unknown {
+  const isConvertable = IsObject(value)
+  if (!isConvertable) return value
   const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0]
   const property = schema.patternProperties[propertyKey]
   const result = {} as Record<string, unknown>
diff --git a/test/runtime/compiler-ajv/record.ts b/test/runtime/compiler-ajv/record.ts
index 75b739b9c..0dcba8f8f 100644
--- a/test/runtime/compiler-ajv/record.ts
+++ b/test/runtime/compiler-ajv/record.ts
@@ -238,4 +238,56 @@ describe('compiler-ajv/Record', () => {
       key2: 1,
     })
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/916
+  // ----------------------------------------------------------------
+  it('Should validate for string keys', () => {
+    const T = Type.Record(Type.String(), Type.Null(), {
+      additionalProperties: false,
+    })
+    Ok(T, {
+      a: null,
+      b: null,
+      0: null,
+      1: null,
+    })
+  })
+  it('Should validate for number keys', () => {
+    const T = Type.Record(Type.Number(), Type.Null(), {
+      additionalProperties: false,
+    })
+    Fail(T, {
+      a: null,
+      b: null,
+      0: null,
+      1: null,
+    })
+    Ok(T, {
+      0: null,
+      1: null,
+    })
+  })
+  it('Should validate for any keys', () => {
+    const T = Type.Record(Type.Any(), Type.Null(), {
+      additionalProperties: false,
+    })
+    Ok(T, {
+      a: null,
+      b: null,
+      0: null,
+      1: null,
+    })
+  })
+  it('Should validate for never keys', () => {
+    const T = Type.Record(Type.Never(), Type.Null(), {
+      additionalProperties: false,
+    })
+    Ok(T, {})
+    Fail(T, {
+      a: null,
+      b: null,
+      0: null,
+      1: null,
+    })
+  })
 })
diff --git a/test/runtime/compiler/record.ts b/test/runtime/compiler/record.ts
index 8b7cfbb65..af4417ba8 100644
--- a/test/runtime/compiler/record.ts
+++ b/test/runtime/compiler/record.ts
@@ -269,4 +269,56 @@ describe('compiler/Record', () => {
       key2: 1,
     })
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/916
+  // ----------------------------------------------------------------
+  it('Should validate for string keys', () => {
+    const T = Type.Record(Type.String(), Type.Null(), {
+      additionalProperties: false,
+    })
+    Ok(T, {
+      a: null,
+      b: null,
+      0: null,
+      1: null,
+    })
+  })
+  it('Should validate for number keys', () => {
+    const T = Type.Record(Type.Number(), Type.Null(), {
+      additionalProperties: false,
+    })
+    Fail(T, {
+      a: null,
+      b: null,
+      0: null,
+      1: null,
+    })
+    Ok(T, {
+      0: null,
+      1: null,
+    })
+  })
+  it('Should validate for any keys', () => {
+    const T = Type.Record(Type.Any(), Type.Null(), {
+      additionalProperties: false,
+    })
+    Ok(T, {
+      a: null,
+      b: null,
+      0: null,
+      1: null,
+    })
+  })
+  it('Should validate for never keys', () => {
+    const T = Type.Record(Type.Never(), Type.Null(), {
+      additionalProperties: false,
+    })
+    Ok(T, {})
+    Fail(T, {
+      a: null,
+      b: null,
+      0: null,
+      1: null,
+    })
+  })
 })
diff --git a/test/runtime/type/guard/kind/record.ts b/test/runtime/type/guard/kind/record.ts
index 12365ee3b..85ba4e96e 100644
--- a/test/runtime/type/guard/kind/record.ts
+++ b/test/runtime/type/guard/kind/record.ts
@@ -1,4 +1,4 @@
-import { TypeGuard, PatternNumberExact, PatternStringExact, PatternString, PatternNumber } from '@sinclair/typebox'
+import { TypeGuard, PatternNumberExact, PatternStringExact, PatternString, PatternNeverExact } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../../assert/index'
 
@@ -21,8 +21,11 @@ describe('guard/kind/TRecord', () => {
   })
   it('Should guard overload 3', () => {
     // @ts-ignore
-    const T = Type.Record(Type.Union([]), Type.String(), { extra: 1 })
-    Assert.IsTrue(TypeGuard.IsNever(T))
+    const N = Type.Union([]) // Never
+    const T = Type.Record(N, Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsString(T.patternProperties[PatternNeverExact]))
+    Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 4', () => {
     // @ts-ignore
@@ -89,6 +92,23 @@ describe('guard/kind/TRecord', () => {
     Assert.IsTrue(TypeGuard.IsNull(R.properties.Y))
     Assert.IsTrue(TypeGuard.IsNull(R.properties.Z))
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/916
+  // ----------------------------------------------------------------
+  it('Should guard overload 13', () => {
+    // @ts-ignore
+    const T = Type.Record(Type.Never(), Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsString(T.patternProperties[PatternNeverExact]))
+    Assert.IsEqual(T.extra, 1)
+  })
+  it('Should guard overload 14', () => {
+    // @ts-ignore
+    const T = Type.Record(Type.Any(), Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsString(T.patternProperties[PatternStringExact]))
+    Assert.IsEqual(T.extra, 1)
+  })
   // -------------------------------------------------------------
   // Variants
   // -------------------------------------------------------------
diff --git a/test/runtime/type/guard/type/record.ts b/test/runtime/type/guard/type/record.ts
index 14729961c..38c7d1bc4 100644
--- a/test/runtime/type/guard/type/record.ts
+++ b/test/runtime/type/guard/type/record.ts
@@ -1,4 +1,4 @@
-import { TypeGuard, PatternNumberExact, PatternStringExact, PatternString, PatternNumber } from '@sinclair/typebox'
+import { TypeGuard, PatternNumberExact, PatternStringExact, PatternNeverExact, PatternString, PatternNumber } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../../assert/index'
 
@@ -21,8 +21,11 @@ describe('guard/type/TRecord', () => {
   })
   it('Should guard overload 3', () => {
     // @ts-ignore
-    const T = Type.Record(Type.Union([]), Type.String(), { extra: 1 })
-    Assert.IsTrue(TypeGuard.IsNever(T))
+    const N = Type.Union([]) // Never
+    const T = Type.Record(N, Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsString(T.patternProperties[PatternNeverExact]))
+    Assert.IsEqual(T.extra, 1)
   })
   it('Should guard overload 4', () => {
     // @ts-ignore
@@ -89,6 +92,25 @@ describe('guard/type/TRecord', () => {
     Assert.IsTrue(TypeGuard.IsNull(R.properties.Y))
     Assert.IsTrue(TypeGuard.IsNull(R.properties.Z))
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/916
+  //
+  // Added overload for Any and Never Keys
+  // ----------------------------------------------------------------
+  it('Should guard overload 13', () => {
+    // @ts-ignore
+    const T = Type.Record(Type.Never(), Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsString(T.patternProperties[PatternNeverExact]))
+    Assert.IsEqual(T.extra, 1)
+  })
+  it('Should guard overload 14', () => {
+    // @ts-ignore
+    const T = Type.Record(Type.Any(), Type.String(), { extra: 1 })
+    Assert.IsTrue(TypeGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsString(T.patternProperties[PatternStringExact]))
+    Assert.IsEqual(T.extra, 1)
+  })
   // -------------------------------------------------------------
   // Variants
   // -------------------------------------------------------------
diff --git a/test/runtime/value/check/record.ts b/test/runtime/value/check/record.ts
index 2e4bd7362..c4b9c1fd8 100644
--- a/test/runtime/value/check/record.ts
+++ b/test/runtime/value/check/record.ts
@@ -236,4 +236,62 @@ describe('value/check/Record', () => {
     const R = Value.Check(T, { 1: '', 2: '', x: true })
     Assert.IsEqual(R, true)
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/916
+  // ----------------------------------------------------------------
+  it('Should validate for string keys', () => {
+    const T = Type.Record(Type.String(), Type.Null(), {
+      additionalProperties: false,
+    })
+    const R = Value.Check(T, {
+      a: null,
+      b: null,
+      0: null,
+      1: null,
+    })
+    Assert.IsEqual(R, true)
+  })
+  it('Should validate for number keys', () => {
+    const T = Type.Record(Type.Number(), Type.Null(), {
+      additionalProperties: false,
+    })
+    const R1 = Value.Check(T, {
+      a: null,
+      b: null,
+      0: null,
+      1: null,
+    })
+    const R2 = Value.Check(T, {
+      0: null,
+      1: null,
+    })
+    Assert.IsEqual(R1, false)
+    Assert.IsEqual(R2, true)
+  })
+  it('Should validate for any keys', () => {
+    const T = Type.Record(Type.Any(), Type.Null(), {
+      additionalProperties: false,
+    })
+    const R = Value.Check(T, {
+      a: null,
+      b: null,
+      0: null,
+      1: null,
+    })
+    Assert.IsEqual(R, true)
+  })
+  it('Should validate for never keys', () => {
+    const T = Type.Record(Type.Never(), Type.Null(), {
+      additionalProperties: false,
+    })
+    const R1 = Value.Check(T, {})
+    const R2 = Value.Check(T, {
+      a: null,
+      b: null,
+      0: null,
+      1: null,
+    })
+    Assert.IsEqual(R1, true)
+    Assert.IsEqual(R2, false)
+  })
 })
diff --git a/test/runtime/value/convert/record.ts b/test/runtime/value/convert/record.ts
index 90c24f440..edd3b5a8a 100644
--- a/test/runtime/value/convert/record.ts
+++ b/test/runtime/value/convert/record.ts
@@ -8,4 +8,37 @@ describe('value/convert/Record', () => {
     const V = Value.Convert(T, { x: '42', y: '24', z: 'hello' })
     Assert.IsEqual(V, { x: 42, y: 24, z: 'hello' })
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/930
+  // ----------------------------------------------------------------
+  it('Should convert record union 1', () => {
+    const T = Type.Union([Type.Null(), Type.Record(Type.Number(), Type.Any())])
+    const V = Value.Convert(T, {})
+    Assert.IsEqual(V, {})
+  })
+  it('Should convert record union 2', () => {
+    const T = Type.Union([Type.Record(Type.Number(), Type.Any()), Type.Null()])
+    const V = Value.Convert(T, {})
+    Assert.IsEqual(V, {})
+  })
+  it('Should convert record union 3', () => {
+    const T = Type.Union([Type.Null(), Type.Record(Type.Number(), Type.Any())])
+    const V = Value.Convert(T, null)
+    Assert.IsEqual(V, null)
+  })
+  it('Should convert record union 4', () => {
+    const T = Type.Union([Type.Record(Type.Number(), Type.Any()), Type.Null()])
+    const V = Value.Convert(T, null)
+    Assert.IsEqual(V, null)
+  })
+  it('Should convert record union 5', () => {
+    const T = Type.Union([Type.Null(), Type.Record(Type.Number(), Type.Any())])
+    const V = Value.Convert(T, 'NULL')
+    Assert.IsEqual(V, null)
+  })
+  it('Should convert record union 6', () => {
+    const T = Type.Union([Type.Record(Type.Number(), Type.Any()), Type.Null()])
+    const V = Value.Convert(T, 'NULL')
+    Assert.IsEqual(V, null)
+  })
 })
diff --git a/test/static/record.ts b/test/static/record.ts
index da8a0288f..ab18b06b4 100644
--- a/test/static/record.ts
+++ b/test/static/record.ts
@@ -189,3 +189,16 @@ import { Type, Static } from '@sinclair/typebox'
     '$propC': string
   }>()
 }
+// ------------------------------------------------------------------
+// https://github.com/sinclairzx81/typebox/issues/916
+// ------------------------------------------------------------------
+{
+  const K = Type.Any()
+  const T = Type.Record(K, Type.String())
+  Expect(T).ToStatic<Record<string, string>>()
+}
+{
+  const K = Type.Never()
+  const T = Type.Record(K, Type.String())
+  Expect(T).ToStatic<{}>()
+}

From 333c2a149e2f0fa54c5618297139fbce6e43f95a Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 7 Aug 2024 22:57:57 +0900
Subject: [PATCH 266/369] Revision 0.33.0 (#941)

* Implement Immutable Types

* Update TypeScript

* Support Clone and Freeze Instancing

* Ensure Options Cloned on Mapped Key and Result

* Revision 0.33.0
---
 hammer.mjs                                    |  2 +-
 package-lock.json                             | 18 ++---
 package.json                                  |  4 +-
 src/index.ts                                  |  1 +
 src/system/policy.ts                          | 15 +++-
 src/type/any/any.ts                           |  5 +-
 src/type/array/array.ts                       | 11 +--
 src/type/async-iterator/async-iterator.ts     | 11 +--
 src/type/awaited/awaited.ts                   |  6 +-
 src/type/bigint/bigint.ts                     |  9 +--
 src/type/boolean/boolean.ts                   |  9 +--
 src/type/clone/type.ts                        |  6 +-
 src/type/composite/composite.ts               |  2 +-
 src/type/const/const.ts                       |  6 +-
 .../constructor-parameters.ts                 |  5 +-
 src/type/constructor/constructor.ts           | 10 +--
 src/type/create/immutable.ts                  | 66 +++++++++++++++++
 src/type/create/index.ts                      | 29 ++++++++
 src/type/create/type.ts                       | 45 ++++++++++++
 src/type/date/date.ts                         |  9 +--
 src/type/discard/discard.ts                   |  1 +
 src/type/enum/enum.ts                         |  2 +-
 src/type/exclude/exclude.ts                   |  8 +--
 src/type/extends/extends-from-mapped-key.ts   | 11 +--
 .../extends/extends-from-mapped-result.ts     |  9 +--
 src/type/extends/extends.ts                   |  8 +--
 src/type/extract/extract.ts                   | 16 ++---
 src/type/function/function.ts                 | 10 +--
 src/type/guard/value.ts                       |  3 +
 src/type/indexed/indexed-from-mapped-key.ts   | 11 +--
 .../indexed/indexed-from-mapped-result.ts     |  6 +-
 src/type/indexed/indexed.ts                   | 18 ++---
 src/type/instance-type/instance-type.ts       |  6 +-
 src/type/integer/integer.ts                   |  9 +--
 src/type/intersect/intersect-create.ts        | 14 ++--
 src/type/intersect/intersect-evaluated.ts     |  9 ++-
 src/type/intersect/intersect.ts               | 11 ++-
 .../intrinsic/intrinsic-from-mapped-key.ts    |  7 +-
 src/type/intrinsic/intrinsic.ts               |  8 ++-
 src/type/iterator/iterator.ts                 | 11 +--
 src/type/keyof/keyof-from-mapped-result.ts    | 10 +--
 src/type/keyof/keyof.ts                       |  8 +--
 src/type/literal/literal.ts                   | 17 +++--
 src/type/mapped/mapped-key.ts                 |  5 +-
 src/type/mapped/mapped-result.ts              |  5 +-
 src/type/mapped/mapped.ts                     |  6 +-
 src/type/never/never.ts                       |  9 +--
 src/type/not/not.ts                           | 10 +--
 src/type/null/null.ts                         |  9 +--
 src/type/number/number.ts                     |  9 +--
 src/type/object/object.ts                     | 25 ++++---
 src/type/omit/omit-from-mapped-key.ts         | 11 +--
 src/type/omit/omit-from-mapped-result.ts      |  9 +--
 src/type/omit/omit.ts                         |  8 +--
 src/type/optional/optional.ts                 |  6 +-
 src/type/parameters/parameters.ts             |  5 +-
 .../partial/partial-from-mapped-result.ts     |  9 +--
 src/type/partial/partial.ts                   |  8 +--
 src/type/pick/pick-from-mapped-key.ts         | 11 +--
 src/type/pick/pick-from-mapped-result.ts      |  9 +--
 src/type/pick/pick.ts                         |  8 +--
 src/type/promise/promise.ts                   | 11 +--
 src/type/readonly/readonly.ts                 |  6 +-
 src/type/record/record.ts                     | 11 ++-
 src/type/recursive/recursive.ts               |  5 +-
 src/type/ref/ref.ts                           | 11 ++-
 src/type/regexp/regexp.ts                     |  5 +-
 .../required/required-from-mapped-result.ts   |  6 +-
 src/type/required/required.ts                 | 12 ++--
 src/type/rest/rest.ts                         | 15 ++--
 src/type/return-type/return-type.ts           |  6 +-
 src/type/string/string.ts                     |  5 +-
 src/type/symbol/symbol.ts                     |  3 +-
 src/type/template-literal/template-literal.ts |  5 +-
 src/type/transform/transform.ts               |  6 +-
 src/type/tuple/tuple.ts                       | 14 ++--
 src/type/type/javascript.ts                   | 26 +++----
 src/type/type/json.ts                         | 70 +++++++++----------
 src/type/uint8array/uint8array.ts             |  5 +-
 src/type/undefined/undefined.ts               |  5 +-
 src/type/union/union-create.ts                |  6 +-
 src/type/union/union-evaluated.ts             |  8 +--
 src/type/union/union.ts                       |  6 +-
 src/type/unknown/unknown.ts                   |  8 +--
 src/type/unsafe/unsafe.ts                     |  6 +-
 src/type/void/void.ts                         |  9 +--
 test/runtime/index.ts                         |  7 ++
 test/runtime/type/guard/type/ref.ts           |  4 +-
 .../type/guard/type/template-literal.ts       |  6 +-
 89 files changed, 521 insertions(+), 410 deletions(-)
 create mode 100644 src/type/create/immutable.ts
 create mode 100644 src/type/create/index.ts
 create mode 100644 src/type/create/type.ts

diff --git a/hammer.mjs b/hammer.mjs
index 20af660ca..49faf269b 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -32,7 +32,7 @@ export async function benchmark() {
 // Test
 // -------------------------------------------------------------------------------
 export async function test_typescript() {
-  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', '5.4.5', '5.5.2', 'next', 'latest']) {
+  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', '5.4.5', '5.5.2', '5.5.3', 'next', 'latest']) {
     await shell(`npm install typescript@${version} --no-save`)
     await test_static()
   }
diff --git a/package-lock.json b/package-lock.json
index f75983e2a..4b22daec6 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.35",
+  "version": "0.33.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.35",
+      "version": "0.33.0",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
@@ -17,7 +17,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^10.4.0",
         "prettier": "^2.7.1",
-        "typescript": "^5.5.3"
+        "typescript": "^5.5.4"
       }
     },
     "node_modules/@andrewbranch/untar.js": {
@@ -1576,9 +1576,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.5.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.3.tgz",
-      "integrity": "sha512-/hreyEujaB0w76zKo6717l3L0o/qEUtRgdvUBvlkhoWeOVMjMuHNHk0BRBzikzuGDqNmPQbg5ifMEqsHLiIUcQ==",
+      "version": "5.5.4",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.4.tgz",
+      "integrity": "sha512-Mtq29sKDAEYP7aljRgtPOpTvOfbwRWlS6dPRzwjdE+C0R4brX/GUyhHSecbHMFLNBLcJIPt9nl9yG5TZ1weH+Q==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -2738,9 +2738,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.5.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.3.tgz",
-      "integrity": "sha512-/hreyEujaB0w76zKo6717l3L0o/qEUtRgdvUBvlkhoWeOVMjMuHNHk0BRBzikzuGDqNmPQbg5ifMEqsHLiIUcQ==",
+      "version": "5.5.4",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.4.tgz",
+      "integrity": "sha512-Mtq29sKDAEYP7aljRgtPOpTvOfbwRWlS6dPRzwjdE+C0R4brX/GUyhHSecbHMFLNBLcJIPt9nl9yG5TZ1weH+Q==",
       "dev": true
     },
     "undici-types": {
diff --git a/package.json b/package.json
index 967cc46e0..bfe38dad3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.35",
+  "version": "0.33.0",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -37,6 +37,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^10.4.0",
     "prettier": "^2.7.1",
-    "typescript": "^5.5.3"
+    "typescript": "^5.5.4"
   }
 }
diff --git a/src/index.ts b/src/index.ts
index dbbe67127..b88ad07ea 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -30,6 +30,7 @@ THE SOFTWARE.
 // Infrastructure
 // ------------------------------------------------------------------
 export * from './type/clone/index'
+export * from './type/create/index'
 export * from './type/error/index'
 export * from './type/guard/index'
 export * from './type/helpers/index'
diff --git a/src/system/policy.ts b/src/system/policy.ts
index 400c74b16..93a68f809 100644
--- a/src/system/policy.ts
+++ b/src/system/policy.ts
@@ -30,9 +30,20 @@ import { IsObject, IsArray, IsNumber, IsUndefined } from '../value/guard/index'
 
 export namespace TypeSystemPolicy {
   // ------------------------------------------------------------------
-  // TypeSystemPolicy
+  // TypeSystemPolicy: Instancing
+  // ------------------------------------------------------------------
+  /**
+   * Configures the instantiation behavior of TypeBox types. The `default` option assigns raw JavaScript
+   * references for embedded types, which may cause side effects if type properties are explicitly updated
+   * outside the TypeBox type builder. The `clone` option creates copies of any shared types upon creation,
+   * preventing unintended side effects. The `freeze` option applies `Object.freeze()` to the type, making
+   * it fully readonly and immutable. Implementations should use `default` whenever possible, as it is the
+   * fastest way to instantiate types. The default setting is `default`.
+   */
+  export let InstanceMode: 'default' | 'clone' | 'freeze' = 'default'
+  // ------------------------------------------------------------------
+  // TypeSystemPolicy: Checking
   // ------------------------------------------------------------------
-  /** Shared assertion routines used by the value and errors modules */
   /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
   export let ExactOptionalPropertyTypes: boolean = false
   /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
diff --git a/src/type/any/any.ts b/src/type/any/any.ts
index 90eaf93ec..f5d7d907c 100644
--- a/src/type/any/any.ts
+++ b/src/type/any/any.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/index'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { Kind } from '../symbols/index'
 
@@ -35,6 +36,6 @@ export interface TAny extends TSchema {
 }
 
 /** `[Json]` Creates an Any type */
-export function Any(options: SchemaOptions = {}): TAny {
-  return { ...options, [Kind]: 'Any' } as never
+export function Any(options?: SchemaOptions): TAny {
+  return CreateType({ [Kind]: 'Any' }, options) as never
 }
diff --git a/src/type/array/array.ts b/src/type/array/array.ts
index fecf073db..388ba25d7 100644
--- a/src/type/array/array.ts
+++ b/src/type/array/array.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { CloneType } from '../clone/type'
+import { CreateType } from '../create/type'
 import { Ensure } from '../helpers/index'
 import type { SchemaOptions, TSchema } from '../schema/index'
 import type { Static } from '../static/index'
@@ -54,11 +54,6 @@ export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptio
   items: T
 }
 /** `[Json]` Creates an Array type */
-export function Array<T extends TSchema>(schema: T, options: ArrayOptions = {}): TArray<T> {
-  return {
-    ...options,
-    [Kind]: 'Array',
-    type: 'array',
-    items: CloneType(schema),
-  } as never
+export function Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T> {
+  return CreateType({ [Kind]: 'Array', type: 'array', items }, options) as never
 }
diff --git a/src/type/async-iterator/async-iterator.ts b/src/type/async-iterator/async-iterator.ts
index ee9417421..2a97d73a0 100644
--- a/src/type/async-iterator/async-iterator.ts
+++ b/src/type/async-iterator/async-iterator.ts
@@ -29,7 +29,7 @@ THE SOFTWARE.
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Static } from '../static/index'
 import { Kind } from '../symbols/index'
-import { CloneType } from '../clone/type'
+import { CreateType } from '../create/type'
 
 export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
   [Kind]: 'AsyncIterator'
@@ -38,11 +38,6 @@ export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
   items: T
 }
 /** `[JavaScript]` Creates a AsyncIterator type */
-export function AsyncIterator<T extends TSchema>(items: T, options: SchemaOptions = {}): TAsyncIterator<T> {
-  return {
-    ...options,
-    [Kind]: 'AsyncIterator',
-    type: 'AsyncIterator',
-    items: CloneType(items),
-  } as never
+export function AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T> {
+  return CreateType({ [Kind]: 'AsyncIterator', type: 'AsyncIterator', items }, options) as never
 }
diff --git a/src/type/awaited/awaited.ts b/src/type/awaited/awaited.ts
index 5318d98ea..e129b6a52 100644
--- a/src/type/awaited/awaited.ts
+++ b/src/type/awaited/awaited.ts
@@ -30,7 +30,7 @@ import type { TSchema, SchemaOptions } from '../schema/index'
 import { Intersect, type TIntersect } from '../intersect/index'
 import { Union, type TUnion } from '../union/index'
 import { type TPromise } from '../promise/index'
-import { CloneType } from '../clone/type'
+import { CreateType } from '../create/type'
 
 // ------------------------------------------------------------------
 // TypeGuard
@@ -96,6 +96,6 @@ export type TAwaited<T extends TSchema> =
   T extends TPromise<infer S> ? TAwaited<S> :
   T
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-export function Awaited<T extends TSchema>(T: T, options: SchemaOptions = {}): TAwaited<T> {
-  return CloneType(AwaitedResolve(T), options)
+export function Awaited<T extends TSchema>(T: T, options?: SchemaOptions): TAwaited<T> {
+  return CreateType(AwaitedResolve(T), options) as never
 }
diff --git a/src/type/bigint/bigint.ts b/src/type/bigint/bigint.ts
index b653a09a2..e98491b2a 100644
--- a/src/type/bigint/bigint.ts
+++ b/src/type/bigint/bigint.ts
@@ -28,6 +28,7 @@ THE SOFTWARE.
 
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { Kind } from '../symbols/index'
+import { CreateType } from '../create/index'
 
 export interface BigIntOptions extends SchemaOptions {
   exclusiveMaximum?: bigint
@@ -42,10 +43,6 @@ export interface TBigInt extends TSchema, BigIntOptions {
   type: 'bigint'
 }
 /** `[JavaScript]` Creates a BigInt type */
-export function BigInt(options: BigIntOptions = {}): TBigInt {
-  return {
-    ...options,
-    [Kind]: 'BigInt',
-    type: 'bigint',
-  } as never
+export function BigInt(options?: BigIntOptions): TBigInt {
+  return CreateType({ [Kind]: 'BigInt', type: 'bigint' }, options) as never
 }
diff --git a/src/type/boolean/boolean.ts b/src/type/boolean/boolean.ts
index 7729a0052..acbf44207 100644
--- a/src/type/boolean/boolean.ts
+++ b/src/type/boolean/boolean.ts
@@ -28,6 +28,7 @@ THE SOFTWARE.
 
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { Kind } from '../symbols/index'
+import { CreateType } from '../create/index'
 
 export interface TBoolean extends TSchema {
   [Kind]: 'Boolean'
@@ -35,10 +36,6 @@ export interface TBoolean extends TSchema {
   type: 'boolean'
 }
 /** `[Json]` Creates a Boolean type */
-export function Boolean(options: SchemaOptions = {}): TBoolean {
-  return {
-    ...options,
-    [Kind]: 'Boolean',
-    type: 'boolean',
-  } as never
+export function Boolean(options?: SchemaOptions): TBoolean {
+  return CreateType({ [Kind]: 'Boolean', type: 'boolean' }, options) as never
 }
diff --git a/src/type/clone/type.ts b/src/type/clone/type.ts
index 89b17b2ee..18a10f3ec 100644
--- a/src/type/clone/type.ts
+++ b/src/type/clone/type.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import type { TSchema, SchemaOptions } from '../schema/index'
+import { TSchema, SchemaOptions } from '../schema/index'
 import { Clone } from './value'
 
 /** Clones a Rest */
@@ -34,6 +34,6 @@ export function CloneRest<T extends TSchema[]>(schemas: T): T {
   return schemas.map((schema) => CloneType(schema)) as never
 }
 /** Clones a Type */
-export function CloneType<T extends TSchema>(schema: T, options: SchemaOptions = {}): T {
-  return { ...Clone(schema), ...options }
+export function CloneType<T extends TSchema>(schema: T, options?: SchemaOptions): T {
+  return options === undefined ? Clone(schema) : Clone({ ...options, ...schema })
 }
diff --git a/src/type/composite/composite.ts b/src/type/composite/composite.ts
index c3a6f8084..26b4406b5 100644
--- a/src/type/composite/composite.ts
+++ b/src/type/composite/composite.ts
@@ -114,7 +114,7 @@ type TCompositeEvaluate<
 // prettier-ignore
 export type TComposite<T extends TSchema[]> = TCompositeEvaluate<T>
 // prettier-ignore
-export function Composite<T extends TSchema[]>(T: [...T], options: ObjectOptions = {}): TComposite<T> {
+export function Composite<T extends TSchema[]>(T: [...T], options?: ObjectOptions): TComposite<T> {
   const K = CompositeKeys(T)
   const P = CompositeProperties(T, K)
   const R = Object(P, options)
diff --git a/src/type/const/const.ts b/src/type/const/const.ts
index 1606b9930..fcaa788a3 100644
--- a/src/type/const/const.ts
+++ b/src/type/const/const.ts
@@ -44,7 +44,7 @@ import { Readonly, type TReadonly } from '../readonly/index'
 import { Undefined, type TUndefined } from '../undefined/index'
 import { Uint8Array, type TUint8Array } from '../uint8array/index'
 import { Unknown, type TUnknown } from '../unknown/index'
-import { CloneType } from '../clone/index'
+import { CreateType } from '../create/index'
 
 // ------------------------------------------------------------------
 // ValueGuard
@@ -130,6 +130,6 @@ function FromValue<T, Root extends boolean>(value: T, root: Root): FromValue<T,
 export type TConst<T> = FromValue<T, true>
 
 /** `[JavaScript]` Creates a readonly const type from the given value. */
-export function Const</* const (not supported in 4.0) */ T>(T: T, options: SchemaOptions = {}): TConst<T> {
-  return CloneType(FromValue(T, true), options) as never
+export function Const</* const (not supported in 4.0) */ T>(T: T, options?: SchemaOptions): TConst<T> {
+  return CreateType(FromValue(T, true), options) as never
 }
diff --git a/src/type/constructor-parameters/constructor-parameters.ts b/src/type/constructor-parameters/constructor-parameters.ts
index 9b00791ab..3ce3e0034 100644
--- a/src/type/constructor-parameters/constructor-parameters.ts
+++ b/src/type/constructor-parameters/constructor-parameters.ts
@@ -30,7 +30,6 @@ import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Ensure } from '../helpers/index'
 import type { TConstructor } from '../constructor/index'
 import { Tuple, type TTuple } from '../tuple/index'
-import { CloneRest } from '../clone/type'
 
 // ------------------------------------------------------------------
 // ConstructorParameters
@@ -41,6 +40,6 @@ export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> =
 )
 
 /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-export function ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options: SchemaOptions = {}): TConstructorParameters<T> {
-  return Tuple(CloneRest(schema.parameters), { ...options })
+export function ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TConstructorParameters<T> {
+  return Tuple(schema.parameters, options)
 }
diff --git a/src/type/constructor/constructor.ts b/src/type/constructor/constructor.ts
index 65f440c32..6904b8541 100644
--- a/src/type/constructor/constructor.ts
+++ b/src/type/constructor/constructor.ts
@@ -32,7 +32,7 @@ import type { Ensure } from '../helpers/index'
 import type { TReadonlyOptional } from '../readonly-optional/index'
 import type { TReadonly } from '../readonly/index'
 import type { TOptional } from '../optional/index'
-import { CloneType, CloneRest } from '../clone/type'
+import { CreateType } from '../create/type'
 import { Kind } from '../symbols/index'
 
 // ------------------------------------------------------------------
@@ -66,11 +66,5 @@ export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema
 }
 /** `[JavaScript]` Creates a Constructor type */
 export function Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U> {
-  return {
-    ...options,
-    [Kind]: 'Constructor',
-    type: 'Constructor',
-    parameters: CloneRest(parameters),
-    returns: CloneType(returns),
-  } as never
+  return CreateType({ [Kind]: 'Constructor', type: 'Constructor', parameters, returns }, options) as never
 }
diff --git a/src/type/create/immutable.ts b/src/type/create/immutable.ts
new file mode 100644
index 000000000..92ff32e5d
--- /dev/null
+++ b/src/type/create/immutable.ts
@@ -0,0 +1,66 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as ValueGuard from '../guard/value'
+
+function ImmutableArray(value: unknown[]) {
+  return globalThis.Object.freeze(value as any).map((value: unknown) => Immutable(value as any))
+}
+function ImmutableDate(value: Date) {
+  return value
+}
+function ImmutableUint8Array(value: Uint8Array) {
+  return value
+}
+function ImmutableRegExp(value: RegExp) {
+  return value
+}
+function ImmutableObject(value: Record<keyof any, unknown>) {
+  const result = {} as Record<PropertyKey, unknown>
+  for (const key of Object.getOwnPropertyNames(value)) {
+    result[key] = Immutable(value[key])
+  }
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    result[key] = Immutable(value[key])
+  }
+  return globalThis.Object.freeze(result)
+}
+/** Specialized deep immutable value. Applies freeze recursively to the given value */
+export function Immutable<T>(value: T): T {
+  return ValueGuard.IsArray(value)
+    ? ImmutableArray(value)
+    : ValueGuard.IsDate(value)
+    ? ImmutableDate(value)
+    : ValueGuard.IsUint8Array(value)
+    ? ImmutableUint8Array(value)
+    : ValueGuard.IsRegExp(value)
+    ? ImmutableRegExp(value)
+    : ValueGuard.IsObject(value)
+    ? ImmutableObject(value)
+    : value
+}
diff --git a/src/type/create/index.ts b/src/type/create/index.ts
new file mode 100644
index 000000000..53780a6ef
--- /dev/null
+++ b/src/type/create/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './type'
diff --git a/src/type/create/type.ts b/src/type/create/type.ts
new file mode 100644
index 000000000..4d378a109
--- /dev/null
+++ b/src/type/create/type.ts
@@ -0,0 +1,45 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TypeSystemPolicy } from '../../system/policy'
+import { SchemaOptions } from '../schema/schema'
+import { Immutable } from './immutable'
+import { Clone } from '../clone/value'
+
+/** Creates TypeBox schematics using the configured InstanceMode */
+export function CreateType(schema: Record<any, unknown>, options?: SchemaOptions): unknown {
+  const result = options !== undefined ? Object.assign(options, schema) : schema
+  switch (TypeSystemPolicy.InstanceMode) {
+    case 'freeze':
+      return Immutable(result)
+    case 'clone':
+      return Clone(result)
+    default:
+      return result
+  }
+}
diff --git a/src/type/date/date.ts b/src/type/date/date.ts
index 192cea310..44b9d0d3d 100644
--- a/src/type/date/date.ts
+++ b/src/type/date/date.ts
@@ -28,6 +28,7 @@ THE SOFTWARE.
 
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { Kind } from '../symbols/index'
+import { CreateType } from '../create/type'
 
 export interface DateOptions extends SchemaOptions {
   /** The exclusive maximum timestamp value */
@@ -47,10 +48,6 @@ export interface TDate extends TSchema, DateOptions {
   type: 'date'
 }
 /** `[JavaScript]` Creates a Date type */
-export function Date(options: DateOptions = {}): TDate {
-  return {
-    ...options,
-    [Kind]: 'Date',
-    type: 'Date',
-  } as never
+export function Date(options?: DateOptions): TDate {
+  return CreateType({ [Kind]: 'Date', type: 'Date' }, options) as never
 }
diff --git a/src/type/discard/discard.ts b/src/type/discard/discard.ts
index 9e4b98dc3..cf1688ddd 100644
--- a/src/type/discard/discard.ts
+++ b/src/type/discard/discard.ts
@@ -30,6 +30,7 @@ function DiscardKey(value: Record<PropertyKey, any>, key: PropertyKey) {
   const { [key]: _, ...rest } = value
   return rest
 }
+/** Discards property keys from the given value. This function returns a shallow Clone. */
 export function Discard(value: Record<PropertyKey, any>, keys: PropertyKey[]) {
   return keys.reduce((acc, key) => DiscardKey(acc, key), value)
 }
diff --git a/src/type/enum/enum.ts b/src/type/enum/enum.ts
index 08a87b495..1cd8a5867 100644
--- a/src/type/enum/enum.ts
+++ b/src/type/enum/enum.ts
@@ -47,7 +47,7 @@ export interface TEnum<T extends Record<string, string | number> = Record<string
   anyOf: TLiteral<T[keyof T]>[]
 }
 /** `[Json]` Creates a Enum type */
-export function Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options: SchemaOptions = {}): TEnum<T> {
+export function Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T> {
   if (IsUndefined(item)) throw new Error('Enum undefined or empty')
   const values1 = globalThis.Object.getOwnPropertyNames(item)
     .filter((key) => isNaN(key as any))
diff --git a/src/type/exclude/exclude.ts b/src/type/exclude/exclude.ts
index 3140a5e10..daee3ea1f 100644
--- a/src/type/exclude/exclude.ts
+++ b/src/type/exclude/exclude.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { UnionToTuple, AssertRest, AssertType } from '../helpers/index'
 import type { TMappedResult } from '../mapped/index'
@@ -35,7 +36,6 @@ import { Never, type TNever } from '../never/index'
 import { type Static } from '../static/index'
 import { type TUnionEvaluated } from '../union/index'
 import { ExtendsCheck, ExtendsResult } from '../extends/index'
-import { CloneType } from '../clone/type'
 import { ExcludeFromMappedResult, type TExcludeFromMappedResult } from './exclude-from-mapped-result'
 import { ExcludeFromTemplateLiteral, type TExcludeFromTemplateLiteral } from './exclude-from-template-literal'
 
@@ -72,10 +72,10 @@ export function Exclude<L extends TSchema, R extends TSchema>(unionType: L, excl
 /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
 export function Exclude(L: TSchema, R: TSchema, options: SchemaOptions = {}): any {
   // overloads
-  if (IsTemplateLiteral(L)) return CloneType(ExcludeFromTemplateLiteral(L, R), options)
-  if (IsMappedResult(L)) return CloneType(ExcludeFromMappedResult(L, R), options)
+  if (IsTemplateLiteral(L)) return CreateType(ExcludeFromTemplateLiteral(L, R), options)
+  if (IsMappedResult(L)) return CreateType(ExcludeFromMappedResult(L, R), options)
   // prettier-ignore
-  return CloneType(
+  return CreateType(
     IsUnion(L) ? ExcludeRest(L.anyOf, R) : 
     ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L
   , options)
diff --git a/src/type/extends/extends-from-mapped-key.ts b/src/type/extends/extends-from-mapped-key.ts
index ce43b6b60..506ebc854 100644
--- a/src/type/extends/extends-from-mapped-key.ts
+++ b/src/type/extends/extends-from-mapped-key.ts
@@ -32,6 +32,7 @@ import type { Assert } from '../helpers/index'
 import { MappedResult, type TMappedResult, type TMappedKey } from '../mapped/index'
 import { Literal, type TLiteral, type TLiteralValue } from '../literal/index'
 import { Extends, type TExtends } from './extends'
+import { Clone } from '../clone/value'
 
 // ------------------------------------------------------------------
 // FromPropertyKey
@@ -51,9 +52,9 @@ function FromPropertyKey<
   U extends TSchema,
   L extends TSchema,
   R extends TSchema
->(K: K, U: U, L: L, R: R, options: SchemaOptions): TFromPropertyKey<K, U, L, R> {
+>(K: K, U: U, L: L, R: R, options?: SchemaOptions): TFromPropertyKey<K, U, L, R> {
   return {
-    [K]: Extends(Literal(K as TLiteralValue), U, L, R, options) as any
+    [K]: Extends(Literal(K as TLiteralValue), U, L, R, Clone(options)) as any
   } as never
 }
 // ------------------------------------------------------------------
@@ -77,7 +78,7 @@ function FromPropertyKeys<
   U extends TSchema,
   L extends TSchema,
   R extends TSchema
->(K: [...K], U: U, L: L, R: R, options: SchemaOptions): TFromPropertyKeys<K, U, L, R> {
+>(K: [...K], U: U, L: L, R: R, options?: SchemaOptions): TFromPropertyKeys<K, U, L, R> {
   return K.reduce((Acc, LK) => {
     return { ...Acc, ...FromPropertyKey(LK, U, L, R, options) }
   }, {} as TProperties) as never
@@ -100,7 +101,7 @@ function FromMappedKey<
   U extends TSchema,
   L extends TSchema,
   R extends TSchema
->(K: K, U: U, L: L, R: R, options: SchemaOptions): TFromMappedKey<K, U, L, R> {
+>(K: K, U: U, L: L, R: R, options?: SchemaOptions): TFromMappedKey<K, U, L, R> {
   return FromPropertyKeys(K.keys, U, L, R, options) as never
 }
 // ------------------------------------------------------------------
@@ -123,7 +124,7 @@ export function ExtendsFromMappedKey<
   L extends TSchema,
   R extends TSchema,
   P extends TProperties = TFromMappedKey<T, U, L, R>
->(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P> {
+>(T: T, U: U, L: L, R: R, options?: SchemaOptions): TMappedResult<P> {
   const P = FromMappedKey(T, U, L, R, options)
   return MappedResult(P) as never
 }
diff --git a/src/type/extends/extends-from-mapped-result.ts b/src/type/extends/extends-from-mapped-result.ts
index 2c857cf9d..02a1dc84b 100644
--- a/src/type/extends/extends-from-mapped-result.ts
+++ b/src/type/extends/extends-from-mapped-result.ts
@@ -30,6 +30,7 @@ import type { TSchema, SchemaOptions } from '../schema/index'
 import type { TProperties } from '../object/index'
 import { MappedResult, type TMappedResult } from '../mapped/index'
 import { Extends, type TExtends } from './extends'
+import { Clone } from '../clone/value'
 
 // ------------------------------------------------------------------
 // FromProperties
@@ -49,9 +50,9 @@ function FromProperties<
   Right extends TSchema,
   True extends TSchema,
   False extends TSchema
->(P: P, Right: Right, True: True, False: False, options: SchemaOptions): TFromProperties<P, Right, True, False> {
+>(P: P, Right: Right, True: True, False: False, options?: SchemaOptions): TFromProperties<P, Right, True, False> {
   const Acc = {} as TProperties
-  for(const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Extends(P[K2], Right, True, False, options)
+  for(const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Extends(P[K2], Right, True, False, Clone(options))
   return Acc as never
 }
 // ------------------------------------------------------------------
@@ -72,7 +73,7 @@ function FromMappedResult<
   Right extends TSchema,
   True extends TSchema,
   False extends TSchema
->(Left: Left, Right: Right, True: True, False: False, options: SchemaOptions): TFromMappedResult<Left, Right, True, False> {
+>(Left: Left, Right: Right, True: True, False: False, options?: SchemaOptions): TFromMappedResult<Left, Right, True, False> {
   return FromProperties(Left.properties, Right, True, False, options) as never
 }
 // ------------------------------------------------------------------
@@ -95,7 +96,7 @@ export function ExtendsFromMappedResult<
   True extends TSchema,
   False extends TSchema,
   P extends TProperties = TFromMappedResult<Left, Right, True, False>
->(Left: Left, Right: Right, True: True, False: False, options: SchemaOptions): TMappedResult<P> {
+>(Left: Left, Right: Right, True: True, False: False, options?: SchemaOptions): TMappedResult<P> {
   const P = FromMappedResult(Left, Right, True, False, options)
   return MappedResult(P) as never
 }
diff --git a/src/type/extends/extends.ts b/src/type/extends/extends.ts
index 614722a4f..9048d1eab 100644
--- a/src/type/extends/extends.ts
+++ b/src/type/extends/extends.ts
@@ -26,13 +26,13 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Static } from '../static/index'
 import { type TUnion, Union } from '../union/index'
 import { TMappedKey, TMappedResult } from '../mapped/index'
 import { ExtendsCheck, ExtendsResult } from './extends-check'
 import { UnionToTuple } from '../helpers/index'
-import { CloneType } from '../clone/type'
 import { ExtendsFromMappedKey, type TExtendsFromMappedKey } from './extends-from-mapped-key'
 import { ExtendsFromMappedResult, type TExtendsFromMappedResult } from './extends-from-mapped-result'
 
@@ -70,11 +70,11 @@ export function Extends<L extends TMappedKey, R extends TSchema, T extends TSche
 /** `[Json]` Creates a Conditional type */
 export function Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>
 /** `[Json]` Creates a Conditional type */
-export function Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options: SchemaOptions = {}) {
+export function Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions) {
   // prettier-ignore
   return (
     IsMappedResult(L) ? ExtendsFromMappedResult(L, R, T, F, options) :
-    IsMappedKey(L) ? CloneType(ExtendsFromMappedKey(L, R, T, F, options)) :
-    CloneType(ExtendsResolve(L, R, T, F), options)
+    IsMappedKey(L) ? CreateType(ExtendsFromMappedKey(L, R, T, F, options)) :
+    CreateType(ExtendsResolve(L, R, T, F), options)
   ) as never
 }
diff --git a/src/type/extract/extract.ts b/src/type/extract/extract.ts
index 91c8ca5e2..8c94045b2 100644
--- a/src/type/extract/extract.ts
+++ b/src/type/extract/extract.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { AssertRest, AssertType, UnionToTuple } from '../helpers/index'
 import type { TMappedResult } from '../mapped/index'
@@ -35,7 +36,6 @@ import { Never, type TNever } from '../never/index'
 import { type TUnionEvaluated } from '../union/index'
 import { type TTemplateLiteral } from '../template-literal/index'
 import { ExtendsCheck, ExtendsResult } from '../extends/index'
-import { CloneType } from '../clone/type'
 import { ExtractFromMappedResult, type TExtractFromMappedResult } from './extract-from-mapped-result'
 import { ExtractFromTemplateLiteral, type TExtractFromTemplateLiteral } from './extract-from-template-literal'
 
@@ -50,7 +50,7 @@ import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/kind'
 // prettier-ignore
 type TExtractRest<L extends TSchema[], R extends TSchema> = AssertRest<UnionToTuple<
   { [K in keyof L]: Static<AssertType<L[K]>> extends Static<R> ? L[K] : never
-}[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never
+  }[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never
 
 function ExtractRest<L extends TSchema[], R extends TSchema>(L: [...L], R: R) {
   const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False)
@@ -71,13 +71,13 @@ export function Extract<L extends TTemplateLiteral, R extends TSchema>(type: L,
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
 export function Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-export function Extract(L: TSchema, R: TSchema, options: SchemaOptions = {}): any {
+export function Extract(L: TSchema, R: TSchema, options?: SchemaOptions): never {
   // overloads
-  if (IsTemplateLiteral(L)) return CloneType(ExtractFromTemplateLiteral(L, R), options)
-  if (IsMappedResult(L)) return CloneType(ExtractFromMappedResult(L, R), options)
+  if (IsTemplateLiteral(L)) return CreateType(ExtractFromTemplateLiteral(L, R), options) as never
+  if (IsMappedResult(L)) return CreateType(ExtractFromMappedResult(L, R), options) as never
   // prettier-ignore
-  return CloneType(
+  return CreateType(
     IsUnion(L) ? ExtractRest(L.anyOf, R) :
-    ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never()
-  , options)
+      ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never()
+    , options) as never
 }
diff --git a/src/type/function/function.ts b/src/type/function/function.ts
index f4333585c..150fc7338 100644
--- a/src/type/function/function.ts
+++ b/src/type/function/function.ts
@@ -26,13 +26,13 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Static } from '../static/index'
 import type { Ensure } from '../helpers/index'
 import type { TReadonlyOptional } from '../readonly-optional/index'
 import type { TReadonly } from '../readonly/index'
 import type { TOptional } from '../optional/index'
-import { CloneType, CloneRest } from '../clone/type'
 import { Kind } from '../symbols/index'
 
 // ------------------------------------------------------------------
@@ -67,11 +67,5 @@ export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema =
 }
 /** `[JavaScript]` Creates a Function type */
 export function Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U> {
-  return {
-    ...options,
-    [Kind]: 'Function',
-    type: 'Function',
-    parameters: CloneRest(parameters),
-    returns: CloneType(returns),
-  } as never
+  return CreateType({ [Kind]: 'Function', type: 'Function', parameters, returns }, options) as never
 }
diff --git a/src/type/guard/value.ts b/src/type/guard/value.ts
index c3ecc85fe..e0f63974a 100644
--- a/src/type/guard/value.ts
+++ b/src/type/guard/value.ts
@@ -26,6 +26,9 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+// --------------------------------------------------------------------------
+// Object Instances
+// --------------------------------------------------------------------------
 /** Returns true if this value is an async iterator */
 export function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<unknown> {
   return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value
diff --git a/src/type/indexed/indexed-from-mapped-key.ts b/src/type/indexed/indexed-from-mapped-key.ts
index e82b1b5f5..4251cea89 100644
--- a/src/type/indexed/indexed-from-mapped-key.ts
+++ b/src/type/indexed/indexed-from-mapped-key.ts
@@ -31,6 +31,7 @@ import type { Ensure, Evaluate } from '../helpers/index'
 import type { TProperties } from '../object/index'
 import { Index, type TIndex } from './indexed'
 import { MappedResult, type TMappedResult, type TMappedKey } from '../mapped/index'
+import { Clone } from '../clone/value'
 
 // ------------------------------------------------------------------
 // MappedIndexPropertyKey
@@ -46,8 +47,8 @@ type TMappedIndexPropertyKey<
 function MappedIndexPropertyKey<
   T extends TSchema, 
   K extends PropertyKey
->(T: T, K: K, options: SchemaOptions): TMappedIndexPropertyKey<T, K> {
-  return { [K]: Index(T, [K], options) } as never
+>(T: T, K: K, options?: SchemaOptions): TMappedIndexPropertyKey<T, K> {
+  return { [K]: Index(T, [K], Clone(options)) } as never
 }
 // ------------------------------------------------------------------
 // MappedIndexPropertyKeys
@@ -62,7 +63,7 @@ type TMappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc ex
 function MappedIndexPropertyKeys<
   T extends TSchema, 
   K extends PropertyKey[]
->(T: T, K: [...K], options: SchemaOptions): TMappedIndexPropertyKeys<T, K> {
+>(T: T, K: [...K], options?: SchemaOptions): TMappedIndexPropertyKeys<T, K> {
   return K.reduce((Acc, L) => {
     return { ...Acc, ...MappedIndexPropertyKey(T, L, options) }
   }, {} as TProperties) as never
@@ -78,7 +79,7 @@ type TMappedIndexProperties<T extends TSchema, K extends TMappedKey> = Evaluate<
 function MappedIndexProperties<
   T extends TSchema, 
   K extends TMappedKey
->(T: T, K: K, options: SchemaOptions): TMappedIndexProperties<T, K> {
+>(T: T, K: K, options?: SchemaOptions): TMappedIndexProperties<T, K> {
   return MappedIndexPropertyKeys(T, K.keys, options) as never
 }
 // ------------------------------------------------------------------
@@ -97,7 +98,7 @@ export function IndexFromMappedKey<
   T extends TSchema, 
   K extends TMappedKey, 
   P extends TProperties = TMappedIndexProperties<T, K>
->(T: T, K: K, options: SchemaOptions): TMappedResult<P> {
+>(T: T, K: K, options?: SchemaOptions): TMappedResult<P> {
   const P = MappedIndexProperties(T, K, options)
   return MappedResult(P) as never
 }
diff --git a/src/type/indexed/indexed-from-mapped-result.ts b/src/type/indexed/indexed-from-mapped-result.ts
index f51837c1f..d23fa750d 100644
--- a/src/type/indexed/indexed-from-mapped-result.ts
+++ b/src/type/indexed/indexed-from-mapped-result.ts
@@ -46,7 +46,7 @@ type TFromProperties<
 function FromProperties<
   T extends TSchema,
   P extends TProperties
->(T: T, P: P, options: SchemaOptions): TFromProperties<T, P> {
+>(T: T, P: P, options?: SchemaOptions): TFromProperties<T, P> {
   const Acc = {} as Record<PropertyKey, TSchema>
   for(const K2 of Object.getOwnPropertyNames(P)) {
     Acc[K2] = Index(T, IndexPropertyKeys(P[K2]), options)
@@ -67,7 +67,7 @@ type TFromMappedResult<
 function FromMappedResult<
   T extends TSchema,
   R extends TMappedResult
->(T: T, R: R, options: SchemaOptions): TFromMappedResult<T, R> {
+>(T: T, R: R, options?: SchemaOptions): TFromMappedResult<T, R> {
   return FromProperties(T, R.properties, options) as never
 }
 // ------------------------------------------------------------------
@@ -86,7 +86,7 @@ export function IndexFromMappedResult<
   T extends TSchema,
   R extends TMappedResult,
   P extends TProperties = TFromMappedResult<T, R>
->(T: T, R: R, options: SchemaOptions): TMappedResult<P> {
+>(T: T, R: R, options?: SchemaOptions): TMappedResult<P> {
   const P = FromMappedResult(T, R, options)
   return MappedResult(P) as never
 }
diff --git a/src/type/indexed/indexed.ts b/src/type/indexed/indexed.ts
index f5519e46b..6de947666 100644
--- a/src/type/indexed/indexed.ts
+++ b/src/type/indexed/indexed.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import { type TSchema, SchemaOptions } from '../schema/index'
 import { type TObject, type TProperties } from '../object/index'
 import { type Assert } from '../helpers/index'
@@ -38,7 +39,6 @@ import { type TTuple } from '../tuple/index'
 import { type TArray } from '../array/index'
 import { IntersectEvaluated, type TIntersectEvaluated } from '../intersect/index'
 import { UnionEvaluated, type TUnionEvaluated } from '../union/index'
-import { CloneType } from '../clone/type'
 
 import { IndexPropertyKeys, type TIndexPropertyKeys } from './indexed-property-keys'
 import { IndexFromMappedKey, type TIndexFromMappedKey } from './indexed-from-mapped-key'
@@ -259,12 +259,14 @@ export function Index<T extends TSchema, K extends TSchema, I extends PropertyKe
 /** `[Json]` Returns an Indexed property type for the given keys */
 export function Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>
 /** `[Json]` Returns an Indexed property type for the given keys */
-export function Index(T: TSchema, K: any, options: SchemaOptions = {}): any {
+export function Index(T: TSchema, K: any, options?: SchemaOptions): any {
+  // mapped-types
+  if (IsMappedResult(K)) return IndexFromMappedResult(T, K, options)
+  if (IsMappedKey(K)) return IndexFromMappedKey(T, K, options)
   // prettier-ignore
-  return (
-    IsMappedResult(K) ? CloneType(IndexFromMappedResult(T, K, options)) :
-    IsMappedKey(K) ? CloneType(IndexFromMappedKey(T, K, options)) :
-    IsSchema(K) ? CloneType(FromSchema(T, IndexPropertyKeys(K)), options) :
-    CloneType(FromSchema(T, K as string[]), options)
-  )
+  return CreateType(
+    IsSchema(K) 
+      ? FromSchema(T, IndexPropertyKeys(K)) 
+      : FromSchema(T, K as string[])
+  , options) as never
 }
diff --git a/src/type/instance-type/instance-type.ts b/src/type/instance-type/instance-type.ts
index 358ff7040..853c8da61 100644
--- a/src/type/instance-type/instance-type.ts
+++ b/src/type/instance-type/instance-type.ts
@@ -26,13 +26,13 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { TConstructor } from '../constructor/index'
-import { CloneType } from '../clone/type'
 
 export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns']
 
 /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-export function InstanceType<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TInstanceType<T> {
-  return CloneType(schema.returns, options)
+export function InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T> {
+  return CreateType(schema.returns, options)
 }
diff --git a/src/type/integer/integer.ts b/src/type/integer/integer.ts
index 3146c25cf..8b15618d3 100644
--- a/src/type/integer/integer.ts
+++ b/src/type/integer/integer.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { Kind } from '../symbols/index'
 
@@ -42,10 +43,6 @@ export interface TInteger extends TSchema, IntegerOptions {
   type: 'integer'
 }
 /** `[Json]` Creates an Integer type */
-export function Integer(options: IntegerOptions = {}): TInteger {
-  return {
-    ...options,
-    [Kind]: 'Integer',
-    type: 'integer',
-  } as never
+export function Integer(options?: IntegerOptions): TInteger {
+  return CreateType({ [Kind]: 'Integer', type: 'integer' }, options) as never
 }
diff --git a/src/type/intersect/intersect-create.ts b/src/type/intersect/intersect-create.ts
index 300291aa1..6b38ce830 100644
--- a/src/type/intersect/intersect-create.ts
+++ b/src/type/intersect/intersect-create.ts
@@ -26,9 +26,9 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema } from '../schema/index'
 import { Kind } from '../symbols/index'
-import { CloneType, CloneRest } from '../clone/type'
 import type { TIntersect, IntersectOptions } from './intersect-type'
 
 // ------------------------------------------------------------------
@@ -39,14 +39,14 @@ import { IsObject, IsSchema } from '../guard/kind'
 // IntersectCreate
 // ------------------------------------------------------------------
 // prettier-ignore
-export function IntersectCreate<T extends TSchema[]>(T: [...T], options: IntersectOptions): TIntersect<T> {
+export function IntersectCreate<T extends TSchema[]>(T: [...T], options: IntersectOptions = {}): TIntersect<T> {
   const allObjects = T.every((schema) => IsObject(schema))
   const clonedUnevaluatedProperties = IsSchema(options.unevaluatedProperties) 
-    ? { unevaluatedProperties: CloneType(options.unevaluatedProperties) } 
+    ? { unevaluatedProperties: options.unevaluatedProperties } 
     : {}
-  return (
+  return CreateType(
     (options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects
-      ? { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: CloneRest(T) }
-      : { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: CloneRest(T) })
-  ) as never
+      ? { ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: T }
+      : { ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: T })
+  , options) as never
 }
diff --git a/src/type/intersect/intersect-evaluated.ts b/src/type/intersect/intersect-evaluated.ts
index f8a5c884e..a0c73484b 100644
--- a/src/type/intersect/intersect-evaluated.ts
+++ b/src/type/intersect/intersect-evaluated.ts
@@ -28,9 +28,8 @@ THE SOFTWARE.
 
 import type { SchemaOptions, TSchema } from '../schema/index'
 import { OptionalKind } from '../symbols/index'
-import { CloneType } from '../clone/type'
+import { CreateType } from '../create/type'
 import { Discard } from '../discard/index'
-
 import { Never, type TNever } from '../never/index'
 import { Optional, type TOptional } from '../optional/index'
 import type { TReadonly } from '../readonly/index'
@@ -116,8 +115,8 @@ export type TIntersectEvaluated<T extends TSchema[]> = (
 )
 /** `[Json]` Creates an evaluated Intersect type */
 export function IntersectEvaluated<T extends TSchema[], R = TIntersectEvaluated<T>>(T: [...T], options: IntersectOptions = {}): R {
-  if (T.length === 0) return Never(options) as R
-  if (T.length === 1) return CloneType(T[0], options) as R
+  if (T.length === 0) return Never(options) as never
+  if (T.length === 1) return CreateType(T[0], options) as never
   if (T.some((schema) => IsTransform(schema))) throw new Error('Cannot intersect transform types')
-  return ResolveIntersect(T, options) as R
+  return ResolveIntersect(T, options) as never
 }
diff --git a/src/type/intersect/intersect.ts b/src/type/intersect/intersect.ts
index 5672f4c63..66275057f 100644
--- a/src/type/intersect/intersect.ts
+++ b/src/type/intersect/intersect.ts
@@ -26,10 +26,9 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema } from '../schema/index'
-import { CloneType } from '../clone/type'
 import { Never, type TNever } from '../never/index'
-
 import { TIntersect, IntersectOptions } from './intersect-type'
 import { IntersectCreate } from './intersect-create'
 
@@ -47,9 +46,9 @@ export type Intersect<T extends TSchema[]> = (
   TIntersect<T>
 )
 /** `[Json]` Creates an evaluated Intersect type */
-export function Intersect<T extends TSchema[]>(T: [...T], options: IntersectOptions = {}): Intersect<T> {
-  if (T.length === 0) return Never(options) as Intersect<T>
-  if (T.length === 1) return CloneType(T[0], options) as Intersect<T>
+export function Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T> {
+  if (T.length === 0) return Never(options) as never
+  if (T.length === 1) return CreateType(T[0], options) as never
   if (T.some((schema) => IsTransform(schema))) throw new Error('Cannot intersect transform types')
-  return IntersectCreate(T, options) as Intersect<T>
+  return IntersectCreate(T, options) as never
 }
diff --git a/src/type/intrinsic/intrinsic-from-mapped-key.ts b/src/type/intrinsic/intrinsic-from-mapped-key.ts
index 51ce4c719..16afb241e 100644
--- a/src/type/intrinsic/intrinsic-from-mapped-key.ts
+++ b/src/type/intrinsic/intrinsic-from-mapped-key.ts
@@ -32,6 +32,7 @@ import { Assert } from '../helpers/index'
 import { MappedResult, type TMappedResult, type TMappedKey } from '../mapped/index'
 import { Intrinsic, type TIntrinsic, type IntrinsicMode } from './intrinsic'
 import { Literal, type TLiteral, type TLiteralValue } from '../literal/index'
+import { Clone } from '../clone/value'
 
 // ------------------------------------------------------------------
 // MappedIntrinsicPropertyKey
@@ -49,7 +50,7 @@ function MappedIntrinsicPropertyKey<
   M extends IntrinsicMode,
 >(K: K, M: M, options: SchemaOptions): TMappedIntrinsicPropertyKey<K, M> {
   return {
-    [K]: Intrinsic(Literal(K as TLiteralValue), M, options)
+    [K]: Intrinsic(Literal(K as TLiteralValue), M, Clone(options))
   } as never
 }
 // ------------------------------------------------------------------
@@ -70,9 +71,11 @@ function MappedIntrinsicPropertyKeys<
   K extends PropertyKey[],
   M extends IntrinsicMode
 >(K: [...K], M: M, options: SchemaOptions): TMappedIntrinsicPropertyKeys<K, M> {
-  return K.reduce((Acc, L) => {
+  const result = K.reduce((Acc, L) => {
     return { ...Acc, ...MappedIntrinsicPropertyKey(L, M, options) }
   }, {} as TProperties) as never
+  
+  return result
 }
 // ------------------------------------------------------------------
 // MappedIntrinsicProperties
diff --git a/src/type/intrinsic/intrinsic.ts b/src/type/intrinsic/intrinsic.ts
index 2f7e23c6c..6745597ec 100644
--- a/src/type/intrinsic/intrinsic.ts
+++ b/src/type/intrinsic/intrinsic.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralExpressionFinite, TemplateLiteralExpressionGenerate, type TTemplateLiteral, type TTemplateLiteralKind } from '../template-literal/index'
 import { IntrinsicFromMappedKey, type TIntrinsicFromMappedKey } from './intrinsic-from-mapped-key'
@@ -134,7 +135,7 @@ export function Intrinsic<T extends TMappedKey, M extends IntrinsicMode>(schema:
 /** Applies an intrinsic string manipulation to the given type. */
 export function Intrinsic<T extends TSchema, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsic<T, M>
 /** Applies an intrinsic string manipulation to the given type. */
-export function Intrinsic(schema: TSchema, mode: IntrinsicMode, options: SchemaOptions = {}): any {
+export function Intrinsic(schema: TSchema, mode: IntrinsicMode, options: SchemaOptions = {}): never {
   // prettier-ignore
   return (
     // Intrinsic-Mapped-Inference
@@ -143,6 +144,7 @@ export function Intrinsic(schema: TSchema, mode: IntrinsicMode, options: SchemaO
     IsTemplateLiteral(schema) ? FromTemplateLiteral(schema, mode, schema) :
     IsUnion(schema) ? Union(FromRest(schema.anyOf, mode), options) :
     IsLiteral(schema) ? Literal(FromLiteralValue(schema.const, mode), options) :
-    schema
-  )
+    // Default Type
+    CreateType(schema, options)
+  ) as never
 }
diff --git a/src/type/iterator/iterator.ts b/src/type/iterator/iterator.ts
index 335bae40c..da528a8ae 100644
--- a/src/type/iterator/iterator.ts
+++ b/src/type/iterator/iterator.ts
@@ -26,9 +26,9 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Static } from '../static/index'
-import { CloneType } from '../clone/type'
 import { Kind } from '../symbols/index'
 
 export interface TIterator<T extends TSchema = TSchema> extends TSchema {
@@ -38,11 +38,6 @@ export interface TIterator<T extends TSchema = TSchema> extends TSchema {
   items: T
 }
 /** `[JavaScript]` Creates an Iterator type */
-export function Iterator<T extends TSchema>(items: T, options: SchemaOptions = {}): TIterator<T> {
-  return {
-    ...options,
-    [Kind]: 'Iterator',
-    type: 'Iterator',
-    items: CloneType(items),
-  } as never
+export function Iterator<T extends TSchema>(items: T, options?: SchemaOptions): TIterator<T> {
+  return CreateType({ [Kind]: 'Iterator', type: 'Iterator', items }, options) as never
 }
diff --git a/src/type/keyof/keyof-from-mapped-result.ts b/src/type/keyof/keyof-from-mapped-result.ts
index 1f4f7df33..9991b7c15 100644
--- a/src/type/keyof/keyof-from-mapped-result.ts
+++ b/src/type/keyof/keyof-from-mapped-result.ts
@@ -31,7 +31,7 @@ import type { Ensure, Evaluate } from '../helpers/index'
 import type { TProperties } from '../object/index'
 import { MappedResult, type TMappedResult } from '../mapped/index'
 import { KeyOf, type TKeyOf } from './keyof'
-
+import { Clone } from '../clone/value'
 // ------------------------------------------------------------------
 // FromProperties
 // ------------------------------------------------------------------
@@ -44,9 +44,9 @@ type TFromProperties<
 // prettier-ignore
 function FromProperties<
   K extends TProperties
->(K: K, options: SchemaOptions): TFromProperties<K> {
+>(K: K, options?: SchemaOptions): TFromProperties<K> {
   const Acc = {} as TProperties
-  for(const K2 of globalThis.Object.getOwnPropertyNames(K)) Acc[K2] = KeyOf(K[K2], options)
+  for(const K2 of globalThis.Object.getOwnPropertyNames(K)) Acc[K2] = KeyOf(K[K2], Clone(options))
   return Acc as never
 }
 // ------------------------------------------------------------------
@@ -61,7 +61,7 @@ type TFromMappedResult<
 // prettier-ignore
 function FromMappedResult<
   R extends TMappedResult
->(R: R, options: SchemaOptions): TFromMappedResult<R> {
+>(R: R, options?: SchemaOptions): TFromMappedResult<R> {
   return FromProperties(R.properties, options) as never
 }
 // ------------------------------------------------------------------
@@ -78,7 +78,7 @@ export type TKeyOfFromMappedResult<
 export function KeyOfFromMappedResult<
   R extends TMappedResult,
   P extends TProperties = TFromMappedResult<R>
->(R: R, options: SchemaOptions): TMappedResult<P> {
+>(R: R, options?: SchemaOptions): TMappedResult<P> {
   const P = FromMappedResult(R, options)
   return MappedResult(P) as never
 }
diff --git a/src/type/keyof/keyof.ts b/src/type/keyof/keyof.ts
index 895eaa6e0..2e4c42df6 100644
--- a/src/type/keyof/keyof.ts
+++ b/src/type/keyof/keyof.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema } from '../schema/index'
 import type { Assert, Ensure } from '../helpers/index'
 import type { TMappedResult } from '../mapped/index'
@@ -34,7 +35,6 @@ import { Literal, type TLiteral, type TLiteralValue } from '../literal/index'
 import { Number, type TNumber } from '../number/index'
 import { KeyOfPropertyKeys, type TKeyOfPropertyKeys } from './keyof-property-keys'
 import { UnionEvaluated, type TUnionEvaluated } from '../union/index'
-import { CloneType } from '../clone/type'
 import { KeyOfFromMappedResult, type TKeyOfFromMappedResult } from './keyof-from-mapped-result'
 
 // ------------------------------------------------------------------
@@ -73,13 +73,13 @@ export function KeyOf<T extends TMappedResult>(T: T, options?: SchemaOptions): T
 /** `[Json]` Creates a KeyOf type */
 export function KeyOf<T extends TSchema>(T: T, options?: SchemaOptions): TKeyOf<T>
 /** `[Json]` Creates a KeyOf type */
-export function KeyOf(T: TSchema, options: SchemaOptions = {}): any {
+export function KeyOf(T: TSchema, options?: SchemaOptions): never {
   if (IsMappedResult(T)) {
-    return KeyOfFromMappedResult(T, options)
+    return KeyOfFromMappedResult(T, options) as never
   } else {
     const K = KeyOfPropertyKeys(T)
     const S = KeyOfPropertyKeysToRest(K)
     const U = UnionEvaluated(S)
-    return CloneType(U, options)
+    return CreateType(U, options) as never
   }
 }
diff --git a/src/type/literal/literal.ts b/src/type/literal/literal.ts
index 3091b4dbd..5a17d8959 100644
--- a/src/type/literal/literal.ts
+++ b/src/type/literal/literal.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { Kind } from '../symbols/index'
 
@@ -43,11 +44,13 @@ export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSche
   const: T
 }
 /** `[Json]` Creates a Literal type */
-export function Literal<T extends TLiteralValue>(value: T, options: SchemaOptions = {}): TLiteral<T> {
-  return {
-    ...options,
-    [Kind]: 'Literal',
-    const: value,
-    type: typeof value as 'string' | 'number' | 'boolean',
-  } as never
+export function Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T> {
+  return CreateType(
+    {
+      [Kind]: 'Literal',
+      const: value,
+      type: typeof value as 'string' | 'number' | 'boolean',
+    },
+    options,
+  ) as never
 }
diff --git a/src/type/mapped/mapped-key.ts b/src/type/mapped/mapped-key.ts
index c3a6f288c..42a9a6926 100644
--- a/src/type/mapped/mapped-key.ts
+++ b/src/type/mapped/mapped-key.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema } from '../schema/index'
 import { Kind } from '../symbols/index'
 
@@ -36,8 +37,8 @@ export interface TMappedKey<T extends PropertyKey[] = PropertyKey[]> extends TSc
 }
 // prettier-ignore
 export function MappedKey<T extends PropertyKey[]>(T: [...T]): TMappedKey<T> {
-  return {
+  return CreateType({
     [Kind]: 'MappedKey',
     keys: T
-  } as never
+  }) as never
 }
diff --git a/src/type/mapped/mapped-result.ts b/src/type/mapped/mapped-result.ts
index d2aade75c..7faf21d75 100644
--- a/src/type/mapped/mapped-result.ts
+++ b/src/type/mapped/mapped-result.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema } from '../schema/index'
 import type { TProperties } from '../object/index'
 import { Kind } from '../symbols/index'
@@ -37,8 +38,8 @@ export interface TMappedResult<T extends TProperties = TProperties> extends TSch
 }
 // prettier-ignore
 export function MappedResult<T extends TProperties>(properties: T): TMappedResult<T> {
-  return {
+  return CreateType({
     [Kind]: 'MappedResult',
     properties
-  } as never
+  }) as never
 }
diff --git a/src/type/mapped/mapped.ts b/src/type/mapped/mapped.ts
index 797679b9c..30301a808 100644
--- a/src/type/mapped/mapped.ts
+++ b/src/type/mapped/mapped.ts
@@ -29,7 +29,7 @@ THE SOFTWARE.
 import type { TSchema } from '../schema/index'
 import type { Ensure, Evaluate, Assert } from '../helpers/index'
 import { Kind, OptionalKind, ReadonlyKind } from '../symbols/index'
-import { CloneType } from '../clone/type'
+import { CreateType } from '../create/type'
 import { Discard } from '../discard/index'
 // evaluation types
 import { Array, type TArray } from '../array/index'
@@ -261,9 +261,9 @@ export function Mapped<K extends TSchema, I extends PropertyKey[] = TIndexProper
 /** `[Json]` Creates a Mapped object type */
 export function Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = TMappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R
 /** `[Json]` Creates a Mapped object type */
-export function Mapped(key: any, map: Function, options: ObjectOptions = {}) {
+export function Mapped(key: any, map: Function, options?: ObjectOptions) {
   const K = IsSchema(key) ? IndexPropertyKeys(key) : (key as PropertyKey[])
   const RT = map({ [Kind]: 'MappedKey', keys: K } as TMappedKey)
   const R = MappedFunctionReturnType(K, RT)
-  return CloneType(Object(R), options)
+  return Object(R, options)
 }
diff --git a/src/type/never/never.ts b/src/type/never/never.ts
index d1ff1c234..f2df6451e 100644
--- a/src/type/never/never.ts
+++ b/src/type/never/never.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { Kind } from '../symbols/index'
 
@@ -35,10 +36,6 @@ export interface TNever extends TSchema {
   not: {}
 }
 /** `[Json]` Creates a Never type */
-export function Never(options: SchemaOptions = {}): TNever {
-  return {
-    ...options,
-    [Kind]: 'Never',
-    not: {},
-  } as never
+export function Never(options?: SchemaOptions): TNever {
+  return CreateType({ [Kind]: 'Never', not: {} }, options) as never
 }
diff --git a/src/type/not/not.ts b/src/type/not/not.ts
index 7315fec86..256a3c8eb 100644
--- a/src/type/not/not.ts
+++ b/src/type/not/not.ts
@@ -26,9 +26,9 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Static } from '../static/index'
-import { CloneType } from '../clone/type'
 import { Kind } from '../symbols/index'
 
 export interface TNot<T extends TSchema = TSchema> extends TSchema {
@@ -37,10 +37,6 @@ export interface TNot<T extends TSchema = TSchema> extends TSchema {
   not: T
 }
 /** `[Json]` Creates a Not type */
-export function Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T> {
-  return {
-    ...options,
-    [Kind]: 'Not',
-    not: CloneType(schema),
-  } as never
+export function Not<T extends TSchema>(not: T, options?: SchemaOptions): TNot<T> {
+  return CreateType({ [Kind]: 'Not', not }, options) as never
 }
diff --git a/src/type/null/null.ts b/src/type/null/null.ts
index 40690048a..f953d04ec 100644
--- a/src/type/null/null.ts
+++ b/src/type/null/null.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { Kind } from '../symbols/index'
 
@@ -35,10 +36,6 @@ export interface TNull extends TSchema {
   type: 'null'
 }
 /** `[Json]` Creates a Null type */
-export function Null(options: SchemaOptions = {}): TNull {
-  return {
-    ...options,
-    [Kind]: 'Null',
-    type: 'null',
-  } as never
+export function Null(options?: SchemaOptions): TNull {
+  return CreateType({ [Kind]: 'Null', type: 'null' }, options) as never
 }
diff --git a/src/type/number/number.ts b/src/type/number/number.ts
index db7392cd0..0ef585560 100644
--- a/src/type/number/number.ts
+++ b/src/type/number/number.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { Kind } from '../symbols/index'
 
@@ -42,10 +43,6 @@ export interface TNumber extends TSchema, NumberOptions {
   type: 'number'
 }
 /** `[Json]` Creates a Number type */
-export function Number(options: NumberOptions = {}): TNumber {
-  return {
-    ...options,
-    [Kind]: 'Number',
-    type: 'number',
-  } as never
+export function Number(options?: NumberOptions): TNumber {
+  return CreateType({ [Kind]: 'Number', type: 'number' }, options) as never
 }
diff --git a/src/type/object/object.ts b/src/type/object/object.ts
index a9d4ce358..18d1559b2 100644
--- a/src/type/object/object.ts
+++ b/src/type/object/object.ts
@@ -26,12 +26,12 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Static } from '../static/index'
 import type { Evaluate } from '../helpers/index'
 import type { TReadonly } from '../readonly/index'
 import type { TOptional } from '../optional/index'
-import { CloneType } from '../clone/type'
 import { Kind } from '../symbols/index'
 
 // ------------------------------------------------------------------
@@ -83,19 +83,18 @@ export interface TObject<T extends TProperties = TProperties> extends TSchema, O
   properties: T
   required?: string[]
 }
+function RequiredKeys<T extends TProperties>(properties: T): string[] {
+  const keys: string[] = []
+  for (let key in properties) {
+    if (!IsOptional(properties[key])) keys.push(key)
+  }
+  return keys
+}
 /** `[Json]` Creates an Object type */
-function _Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
-  const propertyKeys = globalThis.Object.getOwnPropertyNames(properties)
-  const optionalKeys = propertyKeys.filter((key) => IsOptional(properties[key]))
-  const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name))
-  const clonedAdditionalProperties = IsSchema(options.additionalProperties) ? { additionalProperties: CloneType(options.additionalProperties) } : {}
-  const clonedProperties = {} as Record<PropertyKey, TSchema>
-  for (const key of propertyKeys) clonedProperties[key] = CloneType(properties[key])
-  return (
-    requiredKeys.length > 0
-      ? { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys }
-      : { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties }
-  ) as never
+function _Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T> {
+  const required = RequiredKeys(properties)
+  const schematic = required.length > 0 ? { [Kind]: 'Object', type: 'object', properties, required } : { [Kind]: 'Object', type: 'object', properties }
+  return CreateType(schematic, options) as never
 }
 
 /** `[Json]` Creates an Object type */
diff --git a/src/type/omit/omit-from-mapped-key.ts b/src/type/omit/omit-from-mapped-key.ts
index 3ca1822dc..5eeb68660 100644
--- a/src/type/omit/omit-from-mapped-key.ts
+++ b/src/type/omit/omit-from-mapped-key.ts
@@ -30,6 +30,7 @@ import type { TSchema, SchemaOptions } from '../schema/index'
 import type { TProperties } from '../object/index'
 import { MappedResult, type TMappedResult, type TMappedKey } from '../mapped/index'
 import { Omit, type TOmit } from './omit'
+import { Clone } from '../clone/value'
 
 // ------------------------------------------------------------------
 // FromPropertyKey
@@ -45,9 +46,9 @@ type TFromPropertyKey<
 function FromPropertyKey<
   T extends TSchema,
   K extends PropertyKey,
->(T: T, K: K, options: SchemaOptions): TFromPropertyKey<T, K> {
+>(T: T, K: K, options?: SchemaOptions): TFromPropertyKey<T, K> {
   return {
-    [K]: Omit(T, [K], options)
+    [K]: Omit(T, [K], Clone(options))
   } as never
 }
 // ------------------------------------------------------------------
@@ -67,7 +68,7 @@ type TFromPropertyKeys<
 function FromPropertyKeys<
   T extends TSchema,
   K extends PropertyKey[]
->(T: T, K: [...K], options: SchemaOptions): TFromPropertyKeys<T, K> {
+>(T: T, K: [...K], options?: SchemaOptions): TFromPropertyKeys<T, K> {
   return K.reduce((Acc, LK) => {
     return { ...Acc, ...FromPropertyKey(T, LK, options) }
   }, {} as TProperties) as never
@@ -86,7 +87,7 @@ type TFromMappedKey<
 function FromMappedKey<
   T extends TSchema,
   K extends TMappedKey,
->(T: T, K: K, options: SchemaOptions): TFromMappedKey<T, K> {
+>(T: T, K: K, options?: SchemaOptions): TFromMappedKey<T, K> {
   return FromPropertyKeys(T, K.keys, options) as never
 }
 // ------------------------------------------------------------------
@@ -105,7 +106,7 @@ export function OmitFromMappedKey<
   T extends TSchema,
   K extends TMappedKey,
   P extends TProperties = TFromMappedKey<T, K>
->(T: T, K: K, options: SchemaOptions): TMappedResult<P> {
+>(T: T, K: K, options?: SchemaOptions): TMappedResult<P> {
   const P = FromMappedKey(T, K, options)
   return MappedResult(P) as never
 }
diff --git a/src/type/omit/omit-from-mapped-result.ts b/src/type/omit/omit-from-mapped-result.ts
index 5f54e4802..205047ea8 100644
--- a/src/type/omit/omit-from-mapped-result.ts
+++ b/src/type/omit/omit-from-mapped-result.ts
@@ -31,6 +31,7 @@ import type { Ensure, Evaluate } from '../helpers/index'
 import type { TProperties } from '../object/index'
 import { MappedResult, type TMappedResult } from '../mapped/index'
 import { Omit, type TOmit } from './omit'
+import { Clone } from '../clone/value'
 
 // ------------------------------------------------------------------
 // FromProperties
@@ -46,9 +47,9 @@ type TFromProperties<
 function FromProperties<
   P extends TProperties,
   K extends PropertyKey[],
->(P: P, K: [...K], options: SchemaOptions): TFromProperties<P, K> {
+>(P: P, K: [...K], options?: SchemaOptions): TFromProperties<P, K> {
   const Acc = {} as TProperties
-  for(const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Omit(P[K2], K, options)
+  for(const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Omit(P[K2], K, Clone(options))
   return Acc as never
 }
 // ------------------------------------------------------------------
@@ -65,7 +66,7 @@ type TFromMappedResult<
 function FromMappedResult<
   R extends TMappedResult,
   K extends PropertyKey[]
->(R: R, K: [...K], options: SchemaOptions): TFromMappedResult<R, K> {
+>(R: R, K: [...K], options?: SchemaOptions): TFromMappedResult<R, K> {
   return FromProperties(R.properties, K, options) as never
 }
 // ------------------------------------------------------------------
@@ -84,7 +85,7 @@ export function OmitFromMappedResult<
   R extends TMappedResult,
   K extends PropertyKey[],
   P extends TProperties = TFromMappedResult<R, K>
->(R: R, K: [...K], options: SchemaOptions): TMappedResult<P> {
+>(R: R, K: [...K], options?: SchemaOptions): TMappedResult<P> {
   const P = FromMappedResult(R, K, options)
   return MappedResult(P) as never
 }
diff --git a/src/type/omit/omit.ts b/src/type/omit/omit.ts
index 19751fdc4..0d959fe25 100644
--- a/src/type/omit/omit.ts
+++ b/src/type/omit/omit.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { TupleToUnion, Evaluate } from '../helpers/index'
 import { type TRecursive } from '../recursive/index'
@@ -36,7 +37,6 @@ import { Object, type TObject, type TProperties } from '../object/index'
 import { IndexPropertyKeys, type TIndexPropertyKeys } from '../indexed/index'
 import { Discard } from '../discard/index'
 import { TransformKind } from '../symbols/index'
-import { CloneType } from '../clone/type'
 import { OmitFromMappedKey, type TOmitFromMappedKey } from './omit-from-mapped-key'
 import { OmitFromMappedResult, type TOmitFromMappedResult } from './omit-from-mapped-result'
 
@@ -115,13 +115,13 @@ export function Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K, option
 export function Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>
 /** `[Json]` Constructs a type whose keys are omitted from the given type */
 export function Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>
-export function Omit(T: TSchema, K: any, options: SchemaOptions = {}): any {
+export function Omit(T: TSchema, K: any, options?: SchemaOptions): any {
   // mapped
   if (IsMappedKey(K)) return OmitFromMappedKey(T, K, options)
   if (IsMappedResult(T)) return OmitFromMappedResult(T, K, options)
   // non-mapped
   const I = IsSchema(K) ? IndexPropertyKeys(K) : (K as string[])
   const D = Discard(T, [TransformKind, '$id', 'required']) as TSchema
-  const R = CloneType(OmitResolve(T, I), options)
-  return { ...D, ...R }
+  const R = OmitResolve(T, I)
+  return CreateType({ ...D, ...R }, options)
 }
diff --git a/src/type/optional/optional.ts b/src/type/optional/optional.ts
index 0ecd8cad4..a481135b7 100644
--- a/src/type/optional/optional.ts
+++ b/src/type/optional/optional.ts
@@ -26,10 +26,10 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema } from '../schema/index'
 import type { Ensure } from '../helpers/index'
 import { OptionalKind } from '../symbols/index'
-import { CloneType } from '../clone/type'
 import { Discard } from '../discard/index'
 import type { TMappedResult } from '../mapped/index'
 
@@ -40,14 +40,14 @@ import { IsMappedResult } from '../guard/kind'
 // ------------------------------------------------------------------
 type TRemoveOptional<T extends TSchema> = T extends TOptional<infer S> ? S : T
 function RemoveOptional<T extends TSchema>(schema: T) {
-  return Discard(CloneType(schema), [OptionalKind])
+  return CreateType(Discard(schema, [OptionalKind]))
 }
 // ------------------------------------------------------------------
 // AddOptional
 // ------------------------------------------------------------------
 type TAddOptional<T extends TSchema> = T extends TOptional<infer S> ? TOptional<S> : Ensure<TOptional<T>>
 function AddOptional<T extends TSchema>(schema: T) {
-  return { ...CloneType(schema), [OptionalKind]: 'Optional' }
+  return CreateType({ ...schema, [OptionalKind]: 'Optional' })
 }
 // prettier-ignore
 export type TOptionalWithFlag<T extends TSchema, F extends boolean> = 
diff --git a/src/type/parameters/parameters.ts b/src/type/parameters/parameters.ts
index 6e5bcbe5d..a7a0daa45 100644
--- a/src/type/parameters/parameters.ts
+++ b/src/type/parameters/parameters.ts
@@ -30,7 +30,6 @@ import type { TSchema, SchemaOptions } from '../schema/index'
 import type { TFunction } from '../function/index'
 import type { Ensure } from '../helpers/index'
 import { Tuple, type TTuple } from '../tuple/index'
-import { CloneRest } from '../clone/type'
 
 // ------------------------------------------------------------------
 // Parameters
@@ -38,6 +37,6 @@ import { CloneRest } from '../clone/type'
 export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>
 
 /** `[JavaScript]` Extracts the Parameters from the given Function type */
-export function Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options: SchemaOptions = {}): TParameters<T> {
-  return Tuple(CloneRest(schema.parameters), { ...options })
+export function Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T> {
+  return Tuple(schema.parameters, options)
 }
diff --git a/src/type/partial/partial-from-mapped-result.ts b/src/type/partial/partial-from-mapped-result.ts
index 466c608ff..af60533b8 100644
--- a/src/type/partial/partial-from-mapped-result.ts
+++ b/src/type/partial/partial-from-mapped-result.ts
@@ -31,6 +31,7 @@ import type { Ensure, Evaluate } from '../helpers/index'
 import type { TProperties } from '../object/index'
 import { MappedResult, type TMappedResult } from '../mapped/index'
 import { Partial, type TPartial } from './partial'
+import { Clone } from '../clone/value'
 
 // ------------------------------------------------------------------
 // FromProperties
@@ -44,9 +45,9 @@ type TFromProperties<
 // prettier-ignore
 function FromProperties<
   P extends TProperties
->(K: P, options: SchemaOptions): TFromProperties<P> {
+>(K: P, options?: SchemaOptions): TFromProperties<P> {
   const Acc = {} as TProperties
-  for(const K2 of globalThis.Object.getOwnPropertyNames(K)) Acc[K2] = Partial(K[K2], options)
+  for(const K2 of globalThis.Object.getOwnPropertyNames(K)) Acc[K2] = Partial(K[K2], Clone(options))
   return Acc as never
 }
 // ------------------------------------------------------------------
@@ -61,7 +62,7 @@ type TFromMappedResult<
 // prettier-ignore
 function FromMappedResult<
   R extends TMappedResult
->(R: R, options: SchemaOptions): TFromMappedResult<R> {
+>(R: R, options?: SchemaOptions): TFromMappedResult<R> {
   return FromProperties(R.properties, options) as never
 }
 // ------------------------------------------------------------------
@@ -78,7 +79,7 @@ export type TPartialFromMappedResult<
 export function PartialFromMappedResult<
   R extends TMappedResult,
   P extends TProperties = TFromMappedResult<R>
->(R: R, options: SchemaOptions): TMappedResult<P> {
+>(R: R, options?: SchemaOptions): TMappedResult<P> {
   const P = FromMappedResult(R, options)
   return MappedResult(P) as never
 }
diff --git a/src/type/partial/partial.ts b/src/type/partial/partial.ts
index 27a37b0b7..a2382b281 100644
--- a/src/type/partial/partial.ts
+++ b/src/type/partial/partial.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Evaluate } from '../helpers/index'
 import type { TMappedResult } from '../mapped/index'
@@ -38,7 +39,6 @@ import { type TIntersect, Intersect } from '../intersect/index'
 import { type TUnion, Union } from '../union/index'
 import { Discard } from '../discard/index'
 import { TransformKind } from '../symbols/index'
-import { CloneType } from '../clone/type'
 
 import { PartialFromMappedResult, type TPartialFromMappedResult } from './partial-from-mapped-result'
 
@@ -104,9 +104,9 @@ export function Partial<T extends TMappedResult>(T: T, options?: SchemaOptions):
 /** `[Json]` Constructs a type where all properties are optional */
 export function Partial<T extends TSchema>(T: T, options?: SchemaOptions): TPartial<T>
 /** `[Json]` Constructs a type where all properties are optional */
-export function Partial(T: TSchema, options: SchemaOptions = {}): any {
+export function Partial(T: TSchema, options?: SchemaOptions): any {
   if (IsMappedResult(T)) return PartialFromMappedResult(T, options)
   const D = Discard(T, [TransformKind, '$id', 'required']) as TSchema
-  const R = CloneType(PartialResolve(T), options)
-  return { ...D, ...R } as never
+  const R = PartialResolve(T)
+  return CreateType({ ...options, ...D, ...R }) as never
 }
diff --git a/src/type/pick/pick-from-mapped-key.ts b/src/type/pick/pick-from-mapped-key.ts
index 7bd87f09e..062e1e527 100644
--- a/src/type/pick/pick-from-mapped-key.ts
+++ b/src/type/pick/pick-from-mapped-key.ts
@@ -30,6 +30,7 @@ import type { TSchema, SchemaOptions } from '../schema/index'
 import type { TProperties } from '../object/index'
 import { MappedResult, type TMappedResult, type TMappedKey } from '../mapped/index'
 import { Pick, type TPick } from './pick'
+import { Clone } from '../clone/value'
 
 // ------------------------------------------------------------------
 // FromPropertyKey
@@ -45,9 +46,9 @@ type TFromPropertyKey<
 function FromPropertyKey<
   T extends TSchema,
   K extends PropertyKey,
->(T: T, K: K, options: SchemaOptions): TFromPropertyKey<T, K> {
+>(T: T, K: K, options?: SchemaOptions): TFromPropertyKey<T, K> {
   return {
-    [K]: Pick(T, [K], options)
+    [K]: Pick(T, [K], Clone(options))
   } as never
 }
 // ------------------------------------------------------------------
@@ -67,7 +68,7 @@ type TFromPropertyKeys<
 function FromPropertyKeys<
   T extends TSchema,
   K extends PropertyKey[]
->(T: T, K: [...K], options: SchemaOptions): TFromPropertyKeys<T, K> {
+>(T: T, K: [...K], options?: SchemaOptions): TFromPropertyKeys<T, K> {
   return K.reduce((Acc, LK) => {
     return { ...Acc, ...FromPropertyKey(T, LK, options) }
   }, {} as TProperties) as never
@@ -86,7 +87,7 @@ type TFromMappedKey<
 function FromMappedKey<
   T extends TSchema,
   K extends TMappedKey,
->(T: T, K: K, options: SchemaOptions): TFromMappedKey<T, K> {
+>(T: T, K: K, options?: SchemaOptions): TFromMappedKey<T, K> {
   return FromPropertyKeys(T, K.keys, options) as never
 }
 // ------------------------------------------------------------------
@@ -105,7 +106,7 @@ export function PickFromMappedKey<
   T extends TSchema,
   K extends TMappedKey,
   P extends TProperties = TFromMappedKey<T, K>
->(T: T, K: K, options: SchemaOptions): TMappedResult<P> {
+>(T: T, K: K, options?: SchemaOptions): TMappedResult<P> {
   const P = FromMappedKey(T, K, options)
   return MappedResult(P) as never
 }
diff --git a/src/type/pick/pick-from-mapped-result.ts b/src/type/pick/pick-from-mapped-result.ts
index 43b006457..3abf5ad17 100644
--- a/src/type/pick/pick-from-mapped-result.ts
+++ b/src/type/pick/pick-from-mapped-result.ts
@@ -31,6 +31,7 @@ import type { Ensure, Evaluate } from '../helpers/index'
 import type { TProperties } from '../object/index'
 import { MappedResult, type TMappedResult } from '../mapped/index'
 import { Pick, type TPick } from './pick'
+import { Clone } from '../clone/value'
 
 // ------------------------------------------------------------------
 // FromProperties
@@ -46,9 +47,9 @@ type TFromProperties<
 function FromProperties<
   P extends TProperties,
   K extends PropertyKey[],
->(P: P, K: [...K], options: SchemaOptions): TFromProperties<P, K> {
+>(P: P, K: [...K], options?: SchemaOptions): TFromProperties<P, K> {
   const Acc = {} as TProperties
-  for(const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Pick(P[K2], K, options)
+  for(const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Pick(P[K2], K, Clone(options))
   return Acc as never
 }
 // ------------------------------------------------------------------
@@ -65,7 +66,7 @@ type TFromMappedResult<
 function FromMappedResult<
   R extends TMappedResult,
   K extends PropertyKey[]
->(R: R, K: [...K], options: SchemaOptions): TFromMappedResult<R, K> {
+>(R: R, K: [...K], options?: SchemaOptions): TFromMappedResult<R, K> {
   return FromProperties(R.properties, K, options) as never
 }
 // ------------------------------------------------------------------
@@ -84,7 +85,7 @@ export function PickFromMappedResult<
   R extends TMappedResult,
   K extends PropertyKey[],
   P extends TProperties = TFromMappedResult<R, K>
->(R: R, K: [...K], options: SchemaOptions): TMappedResult<P> {
+>(R: R, K: [...K], options?: SchemaOptions): TMappedResult<P> {
   const P = FromMappedResult(R, K, options)
   return MappedResult(P) as never
 }
diff --git a/src/type/pick/pick.ts b/src/type/pick/pick.ts
index 60a7b2227..017914046 100644
--- a/src/type/pick/pick.ts
+++ b/src/type/pick/pick.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { TupleToUnion, Evaluate } from '../helpers/index'
 import { type TRecursive } from '../recursive/index'
@@ -36,7 +37,6 @@ import type { TMappedKey, TMappedResult } from '../mapped/index'
 import { IndexPropertyKeys, type TIndexPropertyKeys } from '../indexed/index'
 import { Discard } from '../discard/index'
 import { TransformKind } from '../symbols/index'
-import { CloneType } from '../clone/type'
 import { PickFromMappedKey, type TPickFromMappedKey } from './pick-from-mapped-key'
 import { PickFromMappedResult, type TPickFromMappedResult } from './pick-from-mapped-result'
 
@@ -106,13 +106,13 @@ export function Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K, option
 export function Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>
 /** `[Json]` Constructs a type whose keys are picked from the given type */
 export function Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>
-export function Pick(T: TSchema, K: any, options: SchemaOptions = {}): any {
+export function Pick(T: TSchema, K: any, options?: SchemaOptions): any {
   // mapped
   if (IsMappedKey(K)) return PickFromMappedKey(T, K, options)
   if (IsMappedResult(T)) return PickFromMappedResult(T, K, options)
   // non-mapped
   const I = IsSchema(K) ? IndexPropertyKeys(K) : (K as string[])
   const D = Discard(T, [TransformKind, '$id', 'required']) as TSchema
-  const R = CloneType(PickResolve(T, I), options)
-  return { ...D, ...R }
+  const R = PickResolve(T, I)
+  return CreateType({ ...D, ...R }, options)
 }
diff --git a/src/type/promise/promise.ts b/src/type/promise/promise.ts
index bd9504194..4a2488408 100644
--- a/src/type/promise/promise.ts
+++ b/src/type/promise/promise.ts
@@ -26,9 +26,9 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Static } from '../static/index'
-import { CloneType } from '../clone/type'
 import { Kind } from '../symbols/index'
 
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
@@ -38,11 +38,6 @@ export interface TPromise<T extends TSchema = TSchema> extends TSchema {
   item: TSchema
 }
 /** `[JavaScript]` Creates a Promise type */
-export function Promise<T extends TSchema>(item: T, options: SchemaOptions = {}): TPromise<T> {
-  return {
-    ...options,
-    [Kind]: 'Promise',
-    type: 'Promise',
-    item: CloneType(item),
-  } as never
+export function Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T> {
+  return CreateType({ [Kind]: 'Promise', type: 'Promise', item }, options) as never
 }
diff --git a/src/type/readonly/readonly.ts b/src/type/readonly/readonly.ts
index 546caddb7..47d9ee0da 100644
--- a/src/type/readonly/readonly.ts
+++ b/src/type/readonly/readonly.ts
@@ -26,10 +26,10 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema } from '../schema/index'
 import type { Ensure } from '../helpers/index'
 import { ReadonlyKind } from '../symbols/index'
-import { CloneType } from '../clone/type'
 import { Discard } from '../discard/index'
 import type { TMappedResult } from '../mapped/index'
 
@@ -40,14 +40,14 @@ import { IsMappedResult } from '../guard/kind'
 // ------------------------------------------------------------------
 type TRemoveReadonly<T extends TSchema> = T extends TReadonly<infer S> ? S : T
 function RemoveReadonly<T extends TSchema>(schema: T) {
-  return Discard(CloneType(schema), [ReadonlyKind])
+  return CreateType(Discard(schema, [ReadonlyKind]))
 }
 // ------------------------------------------------------------------
 // AddReadonly
 // ------------------------------------------------------------------
 type TAddReadonly<T extends TSchema> = T extends TReadonly<infer S> ? TReadonly<S> : Ensure<TReadonly<T>>
 function AddReadonly<T extends TSchema>(schema: T) {
-  return { ...CloneType(schema), [ReadonlyKind]: 'Readonly' }
+  return CreateType({ ...schema, [ReadonlyKind]: 'Readonly' })
 }
 // prettier-ignore
 export type TReadonlyWithFlag<T extends TSchema, F extends boolean> = 
diff --git a/src/type/record/record.ts b/src/type/record/record.ts
index cc6e9e7b8..e32ae7a26 100644
--- a/src/type/record/record.ts
+++ b/src/type/record/record.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema } from '../schema/index'
 import type { Static } from '../static/index'
 import type { Evaluate, Ensure, Assert } from '../helpers/index'
@@ -44,7 +45,6 @@ import { IsTemplateLiteralFinite, TIsTemplateLiteralFinite, type TTemplateLitera
 import { PatternStringExact, PatternNumberExact, PatternNeverExact } from '../patterns/index'
 import { IndexPropertyKeys } from '../indexed/index'
 import { Kind, Hint } from '../symbols/index'
-import { CloneType } from '../clone/type'
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -58,12 +58,11 @@ import { IsInteger, IsLiteral, IsAny, IsNever, IsNumber, IsString, IsRegExp, IsT
 // ------------------------------------------------------------------
 // prettier-ignore
 function RecordCreateFromPattern(pattern: string, T: TSchema, options: ObjectOptions): TRecord<TSchema, TSchema> {
-  return { 
-    ...options, 
+  return CreateType({ 
     [Kind]: 'Record', 
     type: 'object', 
-    patternProperties: { [pattern]: CloneType(T) } 
-  } as never
+    patternProperties: { [pattern]: T } 
+  }, options) as never
 }
 // ------------------------------------------------------------------
 // RecordCreateFromKeys
@@ -71,7 +70,7 @@ function RecordCreateFromPattern(pattern: string, T: TSchema, options: ObjectOpt
 // prettier-ignore
 function RecordCreateFromKeys(K: string[], T: TSchema, options: ObjectOptions): TObject<TProperties> {
   const Acc = {} as TProperties
-  for(const K2 of K) Acc[K2] = CloneType(T)
+  for(const K2 of K) Acc[K2] = T
   return Object(Acc, { ...options, [Hint]: 'Record' })
 }
 // ------------------------------------------------------------------
diff --git a/src/type/recursive/recursive.ts b/src/type/recursive/recursive.ts
index 46d28e98a..50df4f320 100644
--- a/src/type/recursive/recursive.ts
+++ b/src/type/recursive/recursive.ts
@@ -28,6 +28,7 @@ THE SOFTWARE.
 
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { CloneType } from '../clone/type'
+import { CreateType } from '../create/type'
 import { IsUndefined } from '../guard/value'
 import { Kind, Hint } from '../symbols/index'
 import { Static } from '../static/index'
@@ -56,8 +57,8 @@ let Ordinal = 0
 /** `[Json]` Creates a Recursive type */
 export function Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options: SchemaOptions = {}): TRecursive<T> {
   if (IsUndefined(options.$id)) (options as any).$id = `T${Ordinal++}`
-  const thisType = callback({ [Kind]: 'This', $ref: `${options.$id}` } as any)
+  const thisType = CloneType(callback({ [Kind]: 'This', $ref: `${options.$id}` } as any))
   thisType.$id = options.$id
   // prettier-ignore
-  return CloneType({ ...options, [Hint]: 'Recursive', ...thisType }) as never
+  return CreateType({ [Hint]: 'Recursive', ...thisType }, options) as never
 }
diff --git a/src/type/ref/ref.ts b/src/type/ref/ref.ts
index 97fffe26f..3edd35b3d 100644
--- a/src/type/ref/ref.ts
+++ b/src/type/ref/ref.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Static } from '../static/index'
 import { Kind } from '../symbols/index'
@@ -46,12 +47,8 @@ export function Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef
 /** `[Json]` Creates a Ref type. */
 export function Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>
 /** `[Json]` Creates a Ref type. */
-export function Ref(unresolved: TSchema | string, options: SchemaOptions = {}) {
-  if (IsString(unresolved)) return { ...options, [Kind]: 'Ref', $ref: unresolved }
+export function Ref(unresolved: TSchema | string, options?: SchemaOptions) {
+  if (IsString(unresolved)) return CreateType({ [Kind]: 'Ref', $ref: unresolved }, options)
   if (IsUndefined(unresolved.$id)) throw new Error('Reference target type must specify an $id')
-  return {
-    ...options,
-    [Kind]: 'Ref',
-    $ref: unresolved.$id!,
-  }
+  return CreateType({ [Kind]: 'Ref', $ref: unresolved.$id! }, options)
 }
diff --git a/src/type/regexp/regexp.ts b/src/type/regexp/regexp.ts
index c4d0030d0..6f005e696 100644
--- a/src/type/regexp/regexp.ts
+++ b/src/type/regexp/regexp.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { SchemaOptions } from '../schema/index'
 import type { TSchema } from '../schema/index'
 import { IsString } from '../guard/value'
@@ -50,7 +51,7 @@ export function RegExp(pattern: string, options?: RegExpOptions): TRegExp
 /** `[JavaScript]` Creates a RegExp type */
 export function RegExp(regex: RegExp, options?: RegExpOptions): TRegExp
 /** `[JavaScript]` Creates a RegExp type */
-export function RegExp(unresolved: RegExp | string, options: RegExpOptions = {}) {
+export function RegExp(unresolved: RegExp | string, options?: RegExpOptions) {
   const expr = IsString(unresolved) ? new globalThis.RegExp(unresolved) : unresolved
-  return { ...options, [Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags } as never
+  return CreateType({ [Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags }, options) as never
 }
diff --git a/src/type/required/required-from-mapped-result.ts b/src/type/required/required-from-mapped-result.ts
index 1e382ac3d..147508846 100644
--- a/src/type/required/required-from-mapped-result.ts
+++ b/src/type/required/required-from-mapped-result.ts
@@ -44,7 +44,7 @@ type TFromProperties<
 // prettier-ignore
 function FromProperties<
   P extends TProperties
->(P: P, options: SchemaOptions): TFromProperties<P> {
+>(P: P, options?: SchemaOptions): TFromProperties<P> {
   const Acc = {} as TProperties
   for(const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Required(P[K2], options)
   return Acc as never
@@ -61,7 +61,7 @@ type TFromMappedResult<
 // prettier-ignore
 function FromMappedResult<
   R extends TMappedResult
->(R: R, options: SchemaOptions): TFromMappedResult<R> {
+>(R: R, options?: SchemaOptions): TFromMappedResult<R> {
   return FromProperties(R.properties, options) as never
 }
 // ------------------------------------------------------------------
@@ -78,7 +78,7 @@ export type TRequiredFromMappedResult<
 export function RequiredFromMappedResult<
   R extends TMappedResult,
   P extends TProperties = TFromMappedResult<R>
->(R: R, options: SchemaOptions): TMappedResult<P> {
+>(R: R, options?: SchemaOptions): TMappedResult<P> {
   const P = FromMappedResult(R, options)
   return MappedResult(P) as never
 }
diff --git a/src/type/required/required.ts b/src/type/required/required.ts
index 9bbad39c7..807fff050 100644
--- a/src/type/required/required.ts
+++ b/src/type/required/required.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Evaluate } from '../helpers/index'
 import type { TMappedResult } from '../mapped/index'
@@ -36,11 +37,8 @@ import { type TRecursive } from '../recursive/index'
 import { type TIntersect, Intersect } from '../intersect/index'
 import { type TUnion, Union } from '../union/index'
 import { type TObject, type TProperties, Object } from '../object/index'
-
 import { OptionalKind, TransformKind } from '../symbols/index'
-import { CloneType } from '../clone/type'
 import { Discard } from '../discard/index'
-
 import { RequiredFromMappedResult, type TRequiredFromMappedResult } from './required-from-mapped-result'
 
 // ------------------------------------------------------------------
@@ -106,12 +104,12 @@ export function Required<T extends TMappedResult>(T: T, options?: SchemaOptions)
 /** `[Json]` Constructs a type where all properties are required */
 export function Required<T extends TSchema>(T: T, options?: SchemaOptions): TRequired<T>
 /** `[Json]` Constructs a type where all properties are required */
-export function Required<T extends TSchema>(T: T, options: SchemaOptions = {}) {
+export function Required<T extends TSchema>(T: T, options?: SchemaOptions): never {
   if (IsMappedResult(T)) {
-    return RequiredFromMappedResult(T, options)
+    return RequiredFromMappedResult(T, options) as never
   } else {
     const D = Discard(T, [TransformKind, '$id', 'required']) as TSchema
-    const R = CloneType(RequiredResolve(T) as any, options)
-    return { ...D, ...R }
+    const R = RequiredResolve(T) as any
+    return CreateType({ ...D, ...R }, options) as never
   }
 }
diff --git a/src/type/rest/rest.ts b/src/type/rest/rest.ts
index 86593daac..d437fa2da 100644
--- a/src/type/rest/rest.ts
+++ b/src/type/rest/rest.ts
@@ -30,7 +30,6 @@ import type { TSchema } from '../schema/index'
 import type { TIntersect } from '../intersect/index'
 import type { TUnion } from '../union/index'
 import type { TTuple } from '../tuple/index'
-import { CloneRest } from '../clone/type'
 
 // ------------------------------------------------------------------
 // TypeGuard
@@ -41,16 +40,16 @@ import { IsIntersect, IsUnion, IsTuple } from '../guard/kind'
 // ------------------------------------------------------------------
 // prettier-ignore
 type TRestResolve<T extends TSchema> = 
-  T extends TIntersect<infer S> ? [...S] : 
-  T extends TUnion<infer S> ? [...S] : 
-  T extends TTuple<infer S> ? [...S] : 
+  T extends TIntersect<infer S extends TSchema[]> ? S : 
+  T extends TUnion<infer S extends TSchema[]> ? S : 
+  T extends TTuple<infer S extends TSchema[]> ? S : 
   []
 // prettier-ignore
 function RestResolve<T extends TSchema>(T: T) {
   return (
-    IsIntersect(T) ? CloneRest(T.allOf) : 
-    IsUnion(T) ? CloneRest(T.anyOf) : 
-    IsTuple(T) ? CloneRest(T.items ?? []) : 
+    IsIntersect(T) ? T.allOf : 
+    IsUnion(T) ? T.anyOf : 
+    IsTuple(T) ? T.items ?? [] : 
     []
   ) as never
 }
@@ -61,5 +60,5 @@ export type TRest<T extends TSchema> = TRestResolve<T>
 
 /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
 export function Rest<T extends TSchema>(T: T): TRest<T> {
-  return CloneRest(RestResolve(T))
+  return RestResolve(T)
 }
diff --git a/src/type/return-type/return-type.ts b/src/type/return-type/return-type.ts
index f3f843355..f868d2fcf 100644
--- a/src/type/return-type/return-type.ts
+++ b/src/type/return-type/return-type.ts
@@ -26,13 +26,13 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { SchemaOptions } from '../schema/index'
 import type { TFunction } from '../function/index'
-import { CloneType } from '../clone/type'
 
 export type TReturnType<T extends TFunction> = T['returns']
 
 /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-export function ReturnType<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TReturnType<T> {
-  return CloneType(schema.returns, options)
+export function ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T> {
+  return CreateType(schema.returns, options) as never
 }
diff --git a/src/type/string/string.ts b/src/type/string/string.ts
index 97ee88fc2..c1d6061b9 100644
--- a/src/type/string/string.ts
+++ b/src/type/string/string.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import { TSchema, SchemaOptions } from '../schema/index'
 import { Kind } from '../symbols/index'
 
@@ -81,6 +82,6 @@ export interface TString extends TSchema, StringOptions {
 }
 
 /** `[Json]` Creates a String type */
-export function String(options: StringOptions = {}): TString {
-  return { ...options, [Kind]: 'String', type: 'string' } as never
+export function String(options?: StringOptions): TString {
+  return CreateType({ [Kind]: 'String', type: 'string' }, options) as never
 }
diff --git a/src/type/symbol/symbol.ts b/src/type/symbol/symbol.ts
index f7e86697d..5a65b23b9 100644
--- a/src/type/symbol/symbol.ts
+++ b/src/type/symbol/symbol.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import { TSchema, SchemaOptions } from '../schema/index'
 import { Kind } from '../symbols/index'
 
@@ -37,5 +38,5 @@ export interface TSymbol extends TSchema, SchemaOptions {
 }
 /** `[JavaScript]` Creates a Symbol type */
 export function Symbol(options?: SchemaOptions): TSymbol {
-  return { ...options, [Kind]: 'Symbol', type: 'symbol' } as never
+  return CreateType({ [Kind]: 'Symbol', type: 'symbol' }, options) as never
 }
diff --git a/src/type/template-literal/template-literal.ts b/src/type/template-literal/template-literal.ts
index 8798b3083..7eadc534d 100644
--- a/src/type/template-literal/template-literal.ts
+++ b/src/type/template-literal/template-literal.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Assert } from '../helpers/index'
 import type { TUnion } from '../union/index'
@@ -94,9 +95,9 @@ export function TemplateLiteral<T extends string>(syntax: T, options?: SchemaOpt
 export function TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>
 /** `[Json]` Creates a TemplateLiteral type */
 // prettier-ignore
-export function TemplateLiteral(unresolved: TTemplateLiteralKind[] | string, options: SchemaOptions = {}): any {
+export function TemplateLiteral(unresolved: TTemplateLiteralKind[] | string, options?: SchemaOptions): any {
   const pattern = IsString(unresolved) 
     ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved)) 
     : TemplateLiteralPattern(unresolved as TTemplateLiteralKind[])
-  return { ...options, [Kind]: 'TemplateLiteral', type: 'string', pattern }
+  return CreateType({ [Kind]: 'TemplateLiteral', type: 'string', pattern }, options)
 }
diff --git a/src/type/transform/transform.ts b/src/type/transform/transform.ts
index 345726c61..eb7c561cd 100644
--- a/src/type/transform/transform.ts
+++ b/src/type/transform/transform.ts
@@ -29,7 +29,6 @@ THE SOFTWARE.
 import type { TSchema } from '../schema/index'
 import type { Static, StaticDecode } from '../static/index'
 import { TransformKind } from '../symbols/index'
-import { CloneType } from '../clone/type'
 
 // ------------------------------------------------------------------
 // TypeGuard
@@ -58,10 +57,9 @@ export class TransformEncodeBuilder<T extends TSchema, D extends TransformFuncti
     const Codec = { Decode: this.decode, Encode: encode }
     return { ...schema, [TransformKind]: Codec }
   }
-  public Encode<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E): TTransform<T, ReturnType<D>> {
-    const schema = CloneType(this.schema)
+  public Encode<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E): TTransform<T, ReturnType<D>> { 
     return (
-      IsTransform(schema) ? this.EncodeTransform(encode, schema): this.EncodeSchema(encode, schema)
+      IsTransform(this.schema) ? this.EncodeTransform(encode, this.schema): this.EncodeSchema(encode, this.schema)
     ) as never
   }
 }
diff --git a/src/type/tuple/tuple.ts b/src/type/tuple/tuple.ts
index 193b3c840..67d564f9d 100644
--- a/src/type/tuple/tuple.ts
+++ b/src/type/tuple/tuple.ts
@@ -26,9 +26,9 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Static } from '../static/index'
-import { CloneRest } from '../clone/type'
 import { Kind } from '../symbols/index'
 
 // ------------------------------------------------------------------
@@ -52,13 +52,11 @@ export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
   maxItems: number
 }
 /** `[Json]` Creates a Tuple type */
-export function Tuple<T extends TSchema[]>(items: [...T], options: SchemaOptions = {}): TTuple<T> {
-  // return TupleResolver.Resolve(T)
-  const [additionalItems, minItems, maxItems] = [false, items.length, items.length]
+export function Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T> {
   // prettier-ignore
-  return (
+  return CreateType(
     items.length > 0 ?
-      { ...options, [Kind]: 'Tuple', type: 'array', items: CloneRest(items), additionalItems, minItems, maxItems } :
-      { ...options, [Kind]: 'Tuple', type: 'array', minItems, maxItems }
-  ) as never
+      { [Kind]: 'Tuple', type: 'array', items, additionalItems: false, minItems: items.length, maxItems: items.length } :
+      { [Kind]: 'Tuple', type: 'array', minItems: items.length, maxItems: items.length },
+  options) as never
 }
diff --git a/src/type/type/javascript.ts b/src/type/type/javascript.ts
index ec87ac728..fad81ea22 100644
--- a/src/type/type/javascript.ts
+++ b/src/type/type/javascript.ts
@@ -49,19 +49,19 @@ import { Void, type TVoid } from '../void/index'
 /** JavaScript Type Builder with Static Resolution for TypeScript */
 export class JavaScriptTypeBuilder extends JsonTypeBuilder {
   /** `[JavaScript]` Creates a AsyncIterator type */
-  public AsyncIterator<T extends TSchema>(items: T, options: SchemaOptions = {}): TAsyncIterator<T> {
+  public AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T> {
     return AsyncIterator(items, options)
   }
   /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-  public Awaited<T extends TSchema>(schema: T, options: SchemaOptions = {}): TAwaited<T> {
+  public Awaited<T extends TSchema>(schema: T, options?: SchemaOptions): TAwaited<T> {
     return Awaited(schema, options)
   }
   /** `[JavaScript]` Creates a BigInt type */
-  public BigInt(options: BigIntOptions = {}): TBigInt {
+  public BigInt(options?: BigIntOptions): TBigInt {
     return BigInt(options)
   }
   /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-  public ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options: SchemaOptions = {}): TConstructorParameters<T> {
+  public ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TConstructorParameters<T> {
     return ConstructorParameters(schema, options)
   }
   /** `[JavaScript]` Creates a Constructor type */
@@ -77,19 +77,19 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     return FunctionType(parameters, returns, options)
   }
   /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-  public InstanceType<T extends TConstructor<any[], any>>(schema: T, options: SchemaOptions = {}): TInstanceType<T> {
+  public InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T> {
     return InstanceType(schema, options)
   }
   /** `[JavaScript]` Creates an Iterator type */
-  public Iterator<T extends TSchema>(items: T, options: SchemaOptions = {}): TIterator<T> {
+  public Iterator<T extends TSchema>(items: T, options?: SchemaOptions): TIterator<T> {
     return Iterator(items, options)
   }
   /** `[JavaScript]` Extracts the Parameters from the given Function type */
-  public Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options: SchemaOptions = {}): TParameters<T> {
+  public Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T> {
     return Parameters(schema, options)
   }
   /** `[JavaScript]` Creates a Promise type */
-  public Promise<T extends TSchema>(item: T, options: SchemaOptions = {}): TPromise<T> {
+  public Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T> {
     return Promise(item, options)
   }
   /** `[JavaScript]` Creates a RegExp type */
@@ -97,11 +97,11 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
   /** `[JavaScript]` Creates a RegExp type */
   public RegExp(regex: RegExp, options?: RegExpOptions): TRegExp
   /** `[JavaScript]` Creates a RegExp type */
-  public RegExp(unresolved: string | RegExp, options: RegExpOptions = {}) {
+  public RegExp(unresolved: string | RegExp, options?: RegExpOptions) {
     return RegExp(unresolved as any, options)
   }
   /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-  public ReturnType<T extends TFunction<any[], any>>(schema: T, options: SchemaOptions = {}): TReturnType<T> {
+  public ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T> {
     return ReturnType(schema, options)
   }
   /** `[JavaScript]` Creates a Symbol type */
@@ -109,15 +109,15 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     return Symbol(options)
   }
   /** `[JavaScript]` Creates a Undefined type */
-  public Undefined(options: SchemaOptions = {}): TUndefined {
+  public Undefined(options?: SchemaOptions): TUndefined {
     return Undefined(options)
   }
   /** `[JavaScript]` Creates a Uint8Array type */
-  public Uint8Array(options: Uint8ArrayOptions = {}): TUint8Array {
+  public Uint8Array(options?: Uint8ArrayOptions): TUint8Array {
     return Uint8Array(options)
   }
   /** `[JavaScript]` Creates a Void type */
-  public Void(options: SchemaOptions = {}): TVoid {
+  public Void(options?: SchemaOptions): TVoid {
     return Void(options)
   }
 }
diff --git a/src/type/type/json.ts b/src/type/type/json.ts
index 3d1854005..f9a1ae741 100644
--- a/src/type/type/json.ts
+++ b/src/type/type/json.ts
@@ -114,19 +114,19 @@ export class JsonTypeBuilder {
   // Types
   // ------------------------------------------------------------------------
   /** `[Json]` Creates an Any type */
-  public Any(options: SchemaOptions = {}): TAny {
+  public Any(options?: SchemaOptions): TAny {
     return Any(options)
   }
   /** `[Json]` Creates an Array type */
-  public Array<T extends TSchema>(schema: T, options: ArrayOptions = {}): TArray<T> {
+  public Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T> {
     return Array(schema, options)
   }
   /** `[Json]` Creates a Boolean type */
-  public Boolean(options: SchemaOptions = {}): TBoolean {
+  public Boolean(options?: SchemaOptions): TBoolean {
     return Boolean(options)
   }
   /** `[Json]` Intrinsic function to Capitalize LiteralString types */
-  public Capitalize<T extends TSchema>(schema: T, options: SchemaOptions = {}): TCapitalize<T> {
+  public Capitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TCapitalize<T> {
     return Capitalize(schema, options)
   }
   /** `[Json]` Creates a Composite object type */
@@ -134,7 +134,7 @@ export class JsonTypeBuilder {
     return Composite(schemas, options) // (error) TS 5.4.0-dev - review TComposite implementation
   }
   /** `[JavaScript]` Creates a readonly const type from the given value. */
-  public Const</* const (not supported in 4.0) */ T>(value: T, options: SchemaOptions = {}): TConst<T> {
+  public Const</* const (not supported in 4.0) */ T>(value: T, options?: SchemaOptions): TConst<T> {
     return Const(value, options)
   }
   /** `[Json]` Creates a dereferenced type */
@@ -142,7 +142,7 @@ export class JsonTypeBuilder {
     return Deref(schema, references)
   }
   /** `[Json]` Creates a Enum type */
-  public Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options: SchemaOptions = {}): TEnum<T> {
+  public Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T> {
     return Enum(item, options)
   }
   /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
@@ -152,7 +152,7 @@ export class JsonTypeBuilder {
   /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
   public Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>
   /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-  public Exclude(unionType: TSchema, excludedMembers: TSchema, options: SchemaOptions = {}): any {
+  public Exclude(unionType: TSchema, excludedMembers: TSchema, options?: SchemaOptions): any {
     return Exclude(unionType, excludedMembers, options)
   }
   /** `[Json]` Creates a Conditional type */
@@ -162,7 +162,7 @@ export class JsonTypeBuilder {
   /** `[Json]` Creates a Conditional type */
   public Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>
   /** `[Json]` Creates a Conditional type */
-  public Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options: SchemaOptions = {}) {
+  public Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions) {
     return Extends(L, R, T, F, options)
   }
   /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
@@ -172,7 +172,7 @@ export class JsonTypeBuilder {
   /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
   public Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>
   /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-  public Extract(type: TSchema, union: TSchema, options: SchemaOptions = {}): any {
+  public Extract(type: TSchema, union: TSchema, options?: SchemaOptions): any {
     return Extract(type, union, options)
   }
   /** `[Json]` Returns an Indexed property type for the given keys */
@@ -184,15 +184,15 @@ export class JsonTypeBuilder {
   /** `[Json]` Returns an Indexed property type for the given keys */
   public Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>
   /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
+  public Index(schema: TSchema, unresolved: any, options?: SchemaOptions): any {
     return Index(schema, unresolved, options)
   }
   /** `[Json]` Creates an Integer type */
-  public Integer(options: IntegerOptions = {}): TInteger {
+  public Integer(options?: IntegerOptions): TInteger {
     return Integer(options)
   }
   /** `[Json]` Creates an Intersect type */
-  public Intersect<T extends TSchema[]>(T: [...T], options: IntersectOptions = {}): Intersect<T> {
+  public Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T> {
     return Intersect(T, options)
   }
   /** `[Json]` Creates a KeyOf type */
@@ -200,15 +200,15 @@ export class JsonTypeBuilder {
   /** `[Json]` Creates a KeyOf type */
   public KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>
   /** `[Json]` Creates a KeyOf type */
-  public KeyOf(schema: TSchema, options: SchemaOptions = {}): any {
+  public KeyOf(schema: TSchema, options?: SchemaOptions): any {
     return KeyOf(schema, options)
   }
   /** `[Json]` Creates a Literal type */
-  public Literal<T extends TLiteralValue>(value: T, options: SchemaOptions = {}): TLiteral<T> {
+  public Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T> {
     return Literal(value, options)
   }
   /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-  public Lowercase<T extends TSchema>(schema: T, options: SchemaOptions = {}): TLowercase<T> {
+  public Lowercase<T extends TSchema>(schema: T, options?: SchemaOptions): TLowercase<T> {
     return Lowercase(schema, options)
   }
   /** `[Json]` Creates a Mapped object type */
@@ -216,11 +216,11 @@ export class JsonTypeBuilder {
   /** `[Json]` Creates a Mapped object type */
   public Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = TMappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R
   /** `[Json]` Creates a Mapped object type */
-  public Mapped(key: any, map: TMappedFunction<any>, options: ObjectOptions = {}): any {
+  public Mapped(key: any, map: TMappedFunction<any>, options?: ObjectOptions): any {
     return Mapped(key, map, options)
   }
   /** `[Json]` Creates a Never type */
-  public Never(options: SchemaOptions = {}): TNever {
+  public Never(options?: SchemaOptions): TNever {
     return Never(options)
   }
   /** `[Json]` Creates a Not type */
@@ -228,15 +228,15 @@ export class JsonTypeBuilder {
     return Not(schema, options)
   }
   /** `[Json]` Creates a Null type */
-  public Null(options: SchemaOptions = {}): TNull {
+  public Null(options?: SchemaOptions): TNull {
     return Null(options)
   }
   /** `[Json]` Creates a Number type */
-  public Number(options: NumberOptions = {}): TNumber {
+  public Number(options?: NumberOptions): TNumber {
     return Number(options)
   }
   /** `[Json]` Creates an Object type */
-  public Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
+  public Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T> {
     return Object(properties, options)
   }
   /** `[Json]` Constructs a type whose keys are omitted from the given type */
@@ -248,7 +248,7 @@ export class JsonTypeBuilder {
   /** `[Json]` Constructs a type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>
   /** `[Json]` Constructs a type whose keys are omitted from the given type */
-  public Omit(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
+  public Omit(schema: TSchema, unresolved: any, options?: SchemaOptions): any {
     return Omit(schema, unresolved, options)
   }
   /** `[Json]` Constructs a type where all properties are optional */
@@ -256,7 +256,7 @@ export class JsonTypeBuilder {
   /** `[Json]` Constructs a type where all properties are optional */
   public Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>
   /** `[Json]` Constructs a type where all properties are optional */
-  public Partial(schema: TSchema, options: ObjectOptions = {}): any {
+  public Partial(schema: TSchema, options?: ObjectOptions): any {
     return Partial(schema, options)
   }
   /** `[Json]` Constructs a type whose keys are picked from the given type */
@@ -268,15 +268,15 @@ export class JsonTypeBuilder {
   /** `[Json]` Constructs a type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>
   /** `[Json]` Constructs a type whose keys are picked from the given type */
-  public Pick(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
+  public Pick(schema: TSchema, unresolved: any, options?: SchemaOptions): any {
     return Pick(schema, unresolved, options)
   }
   /** `[Json]` Creates a Record type */
-  public Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options: ObjectOptions = {}): TRecordOrObject<K, T> {
+  public Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecordOrObject<K, T> {
     return Record(key, schema, options)
   }
   /** `[Json]` Creates a Recursive type */
-  public Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options: SchemaOptions = {}): TRecursive<T> {
+  public Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T> {
     return Recursive(callback, options)
   }
   /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
@@ -284,7 +284,7 @@ export class JsonTypeBuilder {
   /** `[Json]` Creates a Ref type. */
   public Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>
   /** `[Json]` Creates a Ref type. */
-  public Ref(unresolved: TSchema | string, options: SchemaOptions = {}) {
+  public Ref(unresolved: TSchema | string, options?: SchemaOptions) {
     return Ref(unresolved as any, options)
   }
   /** `[Json]` Constructs a type where all properties are required */
@@ -292,7 +292,7 @@ export class JsonTypeBuilder {
   /** `[Json]` Constructs a type where all properties are required */
   public Required<T extends TSchema>(schema: T, options?: ObjectOptions): TRequired<T>
   /** `[Json]` Constructs a type where all properties are required */
-  public Required(schema: TSchema, options: ObjectOptions = {}): any {
+  public Required(schema: TSchema, options?: ObjectOptions): any {
     return Required(schema, options)
   }
   /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
@@ -300,7 +300,7 @@ export class JsonTypeBuilder {
     return Rest(schema)
   }
   /** `[Json]` Creates a String type */
-  public String(options: StringOptions = {}): TString {
+  public String(options?: StringOptions): TString {
     return String(options)
   }
   /** `[Json]` Creates a TemplateLiteral type from template dsl string */
@@ -308,7 +308,7 @@ export class JsonTypeBuilder {
   /** `[Json]` Creates a TemplateLiteral type */
   public TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>
   /** `[Json]` Creates a TemplateLiteral type */
-  public TemplateLiteral(unresolved: TTemplateLiteralKind[] | string, options: SchemaOptions = {}) {
+  public TemplateLiteral(unresolved: TTemplateLiteralKind[] | string, options?: SchemaOptions) {
     return TemplateLiteral(unresolved as any, options)
   }
   /** `[Json]` Creates a Transform type */
@@ -316,27 +316,27 @@ export class JsonTypeBuilder {
     return Transform(schema)
   }
   /** `[Json]` Creates a Tuple type */
-  public Tuple<T extends TSchema[]>(items: [...T], options: SchemaOptions = {}): TTuple<T> {
+  public Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T> {
     return Tuple(items, options)
   }
   /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-  public Uncapitalize<T extends TSchema>(schema: T, options: SchemaOptions = {}): TUncapitalize<T> {
+  public Uncapitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TUncapitalize<T> {
     return Uncapitalize(schema, options)
   }
   /** `[Json]` Creates a Union type */
-  public Union<T extends TSchema[]>(schemas: [...T], options: SchemaOptions = {}): Union<T> {
+  public Union<T extends TSchema[]>(schemas: [...T], options?: SchemaOptions): Union<T> {
     return Union(schemas, options)
   }
   /** `[Json]` Creates an Unknown type */
-  public Unknown(options: SchemaOptions = {}): TUnknown {
+  public Unknown(options?: SchemaOptions): TUnknown {
     return Unknown(options)
   }
   /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
-  public Unsafe<T>(options: UnsafeOptions = {}): TUnsafe<T> {
+  public Unsafe<T>(options?: UnsafeOptions): TUnsafe<T> {
     return Unsafe(options)
   }
   /** `[Json]` Intrinsic function to Uppercase LiteralString types */
-  public Uppercase<T extends TSchema>(schema: T, options: SchemaOptions = {}): TUppercase<T> {
+  public Uppercase<T extends TSchema>(schema: T, options?: SchemaOptions): TUppercase<T> {
     return Uppercase(schema, options)
   }
 }
diff --git a/src/type/uint8array/uint8array.ts b/src/type/uint8array/uint8array.ts
index 55458346c..09c57ab01 100644
--- a/src/type/uint8array/uint8array.ts
+++ b/src/type/uint8array/uint8array.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { Kind } from '../symbols/index'
 
@@ -39,6 +40,6 @@ export interface TUint8Array extends TSchema, Uint8ArrayOptions {
   type: 'uint8array'
 }
 /** `[JavaScript]` Creates a Uint8Array type */
-export function Uint8Array(options: Uint8ArrayOptions = {}): TUint8Array {
-  return { ...options, [Kind]: 'Uint8Array', type: 'Uint8Array' } as never
+export function Uint8Array(options?: Uint8ArrayOptions): TUint8Array {
+  return CreateType({ [Kind]: 'Uint8Array', type: 'Uint8Array' }, options) as never
 }
diff --git a/src/type/undefined/undefined.ts b/src/type/undefined/undefined.ts
index bbba2b4bf..efd2a7649 100644
--- a/src/type/undefined/undefined.ts
+++ b/src/type/undefined/undefined.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { Kind } from '../symbols/index'
 
@@ -35,6 +36,6 @@ export interface TUndefined extends TSchema {
   type: 'undefined'
 }
 /** `[JavaScript]` Creates a Undefined type */
-export function Undefined(options: SchemaOptions = {}): TUndefined {
-  return { ...options, [Kind]: 'Undefined', type: 'undefined' } as never
+export function Undefined(options?: SchemaOptions): TUndefined {
+  return CreateType({ [Kind]: 'Undefined', type: 'undefined' }, options) as never
 }
diff --git a/src/type/union/union-create.ts b/src/type/union/union-create.ts
index 86093fe58..856f1ffc4 100644
--- a/src/type/union/union-create.ts
+++ b/src/type/union/union-create.ts
@@ -27,10 +27,10 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import type { TSchema, SchemaOptions } from '../schema/index'
-import { CloneRest } from '../clone/type'
+import { CreateType } from '../create/type'
 import { TUnion } from './union-type'
 import { Kind } from '../symbols/index'
 
-export function UnionCreate<T extends TSchema[]>(T: [...T], options: SchemaOptions): TUnion<T> {
-  return { ...options, [Kind]: 'Union', anyOf: CloneRest(T) } as never
+export function UnionCreate<T extends TSchema[]>(T: [...T], options?: SchemaOptions): TUnion<T> {
+  return CreateType({ [Kind]: 'Union', anyOf: T }, options) as never
 }
diff --git a/src/type/union/union-evaluated.ts b/src/type/union/union-evaluated.ts
index afbf4714f..9e4004a20 100644
--- a/src/type/union/union-evaluated.ts
+++ b/src/type/union/union-evaluated.ts
@@ -26,9 +26,9 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { SchemaOptions, TSchema } from '../schema/index'
 import { OptionalKind } from '../symbols/index'
-import { CloneType } from '../clone/type'
 import { Discard } from '../discard/index'
 import { Never, type TNever } from '../never/index'
 import { Optional, type TOptional } from '../optional/index'
@@ -95,7 +95,7 @@ type TResolveUnion<T extends TSchema[], R extends TSchema[] = TRemoveOptionalFro
     : TUnion<R>
 )
 // prettier-ignore
-function ResolveUnion<T extends TSchema[]>(T: T, options: SchemaOptions): TResolveUnion<T> {
+function ResolveUnion<T extends TSchema[]>(T: T, options?: SchemaOptions): TResolveUnion<T> {
   return (
     IsUnionOptional(T)
       ? Optional(UnionCreate(RemoveOptionalFromRest(T) as TSchema[], options))
@@ -112,11 +112,11 @@ export type TUnionEvaluated<T extends TSchema[]> = (
   TResolveUnion<T>
 )
 /** `[Json]` Creates an evaluated Union type */
-export function UnionEvaluated<T extends TSchema[], R = TUnionEvaluated<T>>(T: [...T], options: SchemaOptions = {}): R {
+export function UnionEvaluated<T extends TSchema[], R = TUnionEvaluated<T>>(T: [...T], options?: SchemaOptions): R {
   // prettier-ignore
   return (
     T.length === 0 ? Never(options) :
-    T.length === 1 ? CloneType(T[0], options) :
+    T.length === 1 ? CreateType(T[0], options) :
     ResolveUnion(T, options)
   ) as never
 }
diff --git a/src/type/union/union.ts b/src/type/union/union.ts
index 2024ad8bb..a057141c8 100644
--- a/src/type/union/union.ts
+++ b/src/type/union/union.ts
@@ -29,7 +29,7 @@ THE SOFTWARE.
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { type TNever, Never } from '../never/index'
 import type { TUnion } from './union-type'
-import { CloneType } from '../clone/type'
+import { CreateType } from '../create/type'
 import { UnionCreate } from './union-create'
 
 // prettier-ignore
@@ -39,11 +39,11 @@ export type Union<T extends TSchema[]> = (
   TUnion<T>
 )
 /** `[Json]` Creates a Union type */
-export function Union<T extends TSchema[]>(T: [...T], options: SchemaOptions = {}): Union<T> {
+export function Union<T extends TSchema[]>(T: [...T], options?: SchemaOptions): Union<T> {
   // prettier-ignore
   return (
     T.length === 0 ? Never(options) :
-    T.length === 1 ? CloneType(T[0], options) :
+    T.length === 1 ? CreateType(T[0], options) :
     UnionCreate(T, options)
   ) as Union<T>
 }
diff --git a/src/type/unknown/unknown.ts b/src/type/unknown/unknown.ts
index 28dce27be..f91f9613d 100644
--- a/src/type/unknown/unknown.ts
+++ b/src/type/unknown/unknown.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { Kind } from '../symbols/index'
 
@@ -34,9 +35,6 @@ export interface TUnknown extends TSchema {
   static: unknown
 }
 /** `[Json]` Creates an Unknown type */
-export function Unknown(options: SchemaOptions = {}): TUnknown {
-  return {
-    ...options,
-    [Kind]: 'Unknown',
-  } as never
+export function Unknown(options?: SchemaOptions): TUnknown {
+  return CreateType({ [Kind]: 'Unknown' }, options) as never
 }
diff --git a/src/type/unsafe/unsafe.ts b/src/type/unsafe/unsafe.ts
index f70ec80fc..4a52650d8 100644
--- a/src/type/unsafe/unsafe.ts
+++ b/src/type/unsafe/unsafe.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { Kind } from '../symbols/index'
 
@@ -38,8 +39,5 @@ export interface TUnsafe<T> extends TSchema {
 }
 /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
 export function Unsafe<T>(options: UnsafeOptions = {}): TUnsafe<T> {
-  return {
-    ...options,
-    [Kind]: options[Kind] ?? 'Unsafe',
-  } as never
+  return CreateType({ [Kind]: options[Kind] ?? 'Unsafe' }, options) as never
 }
diff --git a/src/type/void/void.ts b/src/type/void/void.ts
index c7f704d13..0672480b9 100644
--- a/src/type/void/void.ts
+++ b/src/type/void/void.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import { Kind } from '../symbols/index'
 
@@ -35,10 +36,6 @@ export interface TVoid extends TSchema {
   type: 'void'
 }
 /** `[JavaScript]` Creates a Void type */
-export function Void(options: SchemaOptions = {}): TVoid {
-  return {
-    ...options,
-    [Kind]: 'Void',
-    type: 'void',
-  } as never
+export function Void(options?: SchemaOptions): TVoid {
+  return CreateType({ [Kind]: 'Void', type: 'void' }, options) as never
 }
diff --git a/test/runtime/index.ts b/test/runtime/index.ts
index fb4f897fd..16011ae88 100644
--- a/test/runtime/index.ts
+++ b/test/runtime/index.ts
@@ -1,3 +1,10 @@
+import { TypeSystemPolicy } from '@sinclair/typebox/system'
+
+// ------------------------------------------------------------------
+// InstanceMode: Freeze (Detect Unintended Side Effects)
+// ------------------------------------------------------------------
+TypeSystemPolicy.InstanceMode = 'default'
+
 import './compiler/index'
 import './compiler-ajv/index'
 import './errors/index'
diff --git a/test/runtime/type/guard/type/ref.ts b/test/runtime/type/guard/type/ref.ts
index ab8f109bf..c864cbd4f 100644
--- a/test/runtime/type/guard/type/ref.ts
+++ b/test/runtime/type/guard/type/ref.ts
@@ -1,5 +1,5 @@
 import { TypeGuard } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, CloneType } from '@sinclair/typebox'
 import { Assert } from '../../../assert/index'
 
 describe('guard/type/TRef', () => {
@@ -14,7 +14,7 @@ describe('guard/type/TRef', () => {
   })
   it('Should not guard for TRef with invalid $ref', () => {
     const T = Type.Number({ $id: 'T' })
-    const S = Type.Ref(T)
+    const S = CloneType(Type.Ref(T))
     // @ts-ignore
     S.$ref = 1
     const R = TypeGuard.IsRef(S)
diff --git a/test/runtime/type/guard/type/template-literal.ts b/test/runtime/type/guard/type/template-literal.ts
index 63fb736aa..f00db33c2 100644
--- a/test/runtime/type/guard/type/template-literal.ts
+++ b/test/runtime/type/guard/type/template-literal.ts
@@ -1,5 +1,5 @@
 import { TypeGuard } from '@sinclair/typebox'
-import { Type, TemplateLiteralGenerate } from '@sinclair/typebox'
+import { Type, CloneType, TemplateLiteralGenerate } from '@sinclair/typebox'
 import { Assert } from '../../../assert/index'
 
 describe('guard/type/TTemplateLiteral', () => {
@@ -33,13 +33,13 @@ describe('guard/type/TTemplateLiteral', () => {
     Assert.IsTrue(R)
   })
   it('Should not guard for missing ^ expression prefix', () => {
-    const T = Type.TemplateLiteral([Type.Literal('hello')])
+    const T = CloneType(Type.TemplateLiteral([Type.Literal('hello')]))
     // @ts-ignore
     T.pattern = T.pattern.slice(1)
     Assert.IsFalse(TypeGuard.IsTemplateLiteral(T))
   })
   it('Should not guard for missing $ expression postfix', () => {
-    const T = Type.TemplateLiteral([Type.Literal('hello')])
+    const T = CloneType(Type.TemplateLiteral([Type.Literal('hello')]))
     // @ts-ignore
     T.pattern = T.pattern.slice(0, T.pattern.length - 1)
     Assert.IsFalse(TypeGuard.IsTemplateLiteral(T))

From b00293ee1c173c78da03824668d68b9a2c769361 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 9 Aug 2024 11:13:27 +0900
Subject: [PATCH 267/369] Revision 0.33.1 (#945)

* Interior Mutation Fix + Tests

* Revision
---
 package-lock.json                           |  4 +--
 package.json                                |  2 +-
 src/type/create/type.ts                     |  2 +-
 src/type/intrinsic/intrinsic.ts             |  3 +-
 test/runtime/index.ts                       |  2 +-
 test/runtime/system/policy/index.ts         |  1 +
 test/runtime/system/policy/instance-mode.ts | 34 +++++++++++++++++++++
 test/runtime/value/check/not.ts             |  9 ++----
 8 files changed, 45 insertions(+), 12 deletions(-)
 create mode 100644 test/runtime/system/policy/instance-mode.ts

diff --git a/package-lock.json b/package-lock.json
index 4b22daec6..06a44d3fd 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.0",
+  "version": "0.33.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.0",
+      "version": "0.33.1",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index bfe38dad3..eb4c3e5bd 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.0",
+  "version": "0.33.1",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/create/type.ts b/src/type/create/type.ts
index 4d378a109..cb8371abd 100644
--- a/src/type/create/type.ts
+++ b/src/type/create/type.ts
@@ -33,7 +33,7 @@ import { Clone } from '../clone/value'
 
 /** Creates TypeBox schematics using the configured InstanceMode */
 export function CreateType(schema: Record<any, unknown>, options?: SchemaOptions): unknown {
-  const result = options !== undefined ? Object.assign(options, schema) : schema
+  const result = options !== undefined ? { ...options, ...schema } : schema
   switch (TypeSystemPolicy.InstanceMode) {
     case 'freeze':
       return Immutable(result)
diff --git a/src/type/intrinsic/intrinsic.ts b/src/type/intrinsic/intrinsic.ts
index 6745597ec..bbb139be6 100644
--- a/src/type/intrinsic/intrinsic.ts
+++ b/src/type/intrinsic/intrinsic.ts
@@ -130,6 +130,7 @@ export type TIntrinsic<T extends TSchema, M extends IntrinsicMode> =
   T extends TUnion<infer S> ? TUnion<TFromRest<S, M>> :
   T extends TLiteral<infer S> ? TLiteral<TFromLiteralValue<S, M>> :
   T
+
 /** Applies an intrinsic string manipulation to the given type. */
 export function Intrinsic<T extends TMappedKey, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsicFromMappedKey<T, M>
 /** Applies an intrinsic string manipulation to the given type. */
@@ -141,7 +142,7 @@ export function Intrinsic(schema: TSchema, mode: IntrinsicMode, options: SchemaO
     // Intrinsic-Mapped-Inference
     IsMappedKey(schema) ? IntrinsicFromMappedKey(schema, mode, options) :
     // Standard-Inference
-    IsTemplateLiteral(schema) ? FromTemplateLiteral(schema, mode, schema) :
+    IsTemplateLiteral(schema) ? FromTemplateLiteral(schema, mode, options) :
     IsUnion(schema) ? Union(FromRest(schema.anyOf, mode), options) :
     IsLiteral(schema) ? Literal(FromLiteralValue(schema.const, mode), options) :
     // Default Type
diff --git a/test/runtime/index.ts b/test/runtime/index.ts
index 16011ae88..15ca57aca 100644
--- a/test/runtime/index.ts
+++ b/test/runtime/index.ts
@@ -3,7 +3,7 @@ import { TypeSystemPolicy } from '@sinclair/typebox/system'
 // ------------------------------------------------------------------
 // InstanceMode: Freeze (Detect Unintended Side Effects)
 // ------------------------------------------------------------------
-TypeSystemPolicy.InstanceMode = 'default'
+TypeSystemPolicy.InstanceMode = 'freeze'
 
 import './compiler/index'
 import './compiler-ajv/index'
diff --git a/test/runtime/system/policy/index.ts b/test/runtime/system/policy/index.ts
index 29bf29666..144b64afe 100644
--- a/test/runtime/system/policy/index.ts
+++ b/test/runtime/system/policy/index.ts
@@ -2,3 +2,4 @@ import './allow-array-object'
 import './allow-nan'
 import './allow-null-void'
 import './exact-optional-property-types'
+import './instance-mode'
diff --git a/test/runtime/system/policy/instance-mode.ts b/test/runtime/system/policy/instance-mode.ts
new file mode 100644
index 000000000..1e400c247
--- /dev/null
+++ b/test/runtime/system/policy/instance-mode.ts
@@ -0,0 +1,34 @@
+import { TypeSystemPolicy } from '@sinclair/typebox/system'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('system/TypeSystemPolicy/InstanceMode', () => {
+  after(() => {
+    TypeSystemPolicy.InstanceMode = 'freeze'
+  })
+  // ---------------------------------------------------------------
+  // Number
+  // ---------------------------------------------------------------
+  it('Should use instance mode default', () => {
+    TypeSystemPolicy.InstanceMode = 'default'
+    const S = Type.String()
+    const T = Type.Array(S)
+    S.$id = 'updated'
+    Assert.IsEqual(T.items.$id, 'updated')
+  })
+  it('Should use instance mode clone', () => {
+    TypeSystemPolicy.InstanceMode = 'clone'
+    const S = Type.String()
+    const T = Type.Array(S)
+    S.$id = 'updated'
+    Assert.IsEqual(T.items.$id, undefined)
+  })
+  it('Should use instance mode freeze', () => {
+    TypeSystemPolicy.InstanceMode = 'freeze'
+    Assert.Throws(() => {
+      const S = Type.String()
+      const T = Type.Array(S)
+      S.$id = 'updated'
+    })
+  })
+})
diff --git a/test/runtime/value/check/not.ts b/test/runtime/value/check/not.ts
index ba5471bf8..866ec401a 100644
--- a/test/runtime/value/check/not.ts
+++ b/test/runtime/value/check/not.ts
@@ -4,7 +4,7 @@ import { Assert } from '../../assert/index'
 
 describe('value/check/Not', () => {
   it('Should validate with not number', () => {
-    const T = Type.Not(Type.Number(), Type.String())
+    const T = Type.Not(Type.Number())
     Assert.IsEqual(Value.Check(T, 1), false)
     Assert.IsEqual(Value.Check(T, 'A'), true)
   })
@@ -14,7 +14,7 @@ describe('value/check/Not', () => {
             Type.Literal('A'),
             Type.Literal('B'),
             Type.Literal('C')
-        ]), Type.String())
+        ]))
     Assert.IsEqual(Value.Check(T, 'A'), false)
     Assert.IsEqual(Value.Check(T, 'B'), false)
     Assert.IsEqual(Value.Check(T, 'C'), false)
@@ -22,10 +22,7 @@ describe('value/check/Not', () => {
   })
   it('Should validate with union right', () => {
     // prettier-ignore
-    const T = Type.Not(Type.Number(), Type.Union([
-            Type.String(),
-            Type.Boolean()
-        ]))
+    const T = Type.Not(Type.Number())
     Assert.IsEqual(Value.Check(T, 1), false)
     Assert.IsEqual(Value.Check(T, 'A'), true)
     Assert.IsEqual(Value.Check(T, true), true)

From c4894642d2049e16adeb70e8e82b9c2ca4bab7fe Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 9 Aug 2024 17:59:50 +0900
Subject: [PATCH 268/369] Revision 0.33.2 (#947)

* Retain Interior Properties on Pick, Omit and Mapped Types

* Version
---
 package-lock.json                    |  4 ++--
 package.json                         |  2 +-
 src/type/mapped/mapped.ts            | 22 +++++++++++---------
 src/type/omit/omit.ts                |  6 ++----
 src/type/pick/pick.ts                |  6 ++----
 test/runtime/type/guard/type/omit.ts | 31 ++++++++++++++++++++++++++++
 test/runtime/type/guard/type/pick.ts | 31 ++++++++++++++++++++++++++++
 7 files changed, 81 insertions(+), 21 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 06a44d3fd..79ede7384 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.1",
+  "version": "0.33.2",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.1",
+      "version": "0.33.2",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index eb4c3e5bd..9f4f29ebd 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.1",
+  "version": "0.33.2",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/mapped/mapped.ts b/src/type/mapped/mapped.ts
index 30301a808..7efdd2139 100644
--- a/src/type/mapped/mapped.ts
+++ b/src/type/mapped/mapped.ts
@@ -205,6 +205,8 @@ type FromSchemaType<K extends PropertyKey, T extends TSchema> = (
 )
 // prettier-ignore
 function FromSchemaType<K extends PropertyKey, T extends TSchema>(K: K, T: T): FromSchemaType<K, T> {
+  // required to retain user defined options for mapped type
+  const options = { ...T }
   return (
     // unevaluated modifier types
     IsOptional(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]) as TSchema)) :
@@ -213,16 +215,16 @@ function FromSchemaType<K extends PropertyKey, T extends TSchema>(K: K, T: T): F
     IsMappedResult(T) ? FromMappedResult(K, T.properties) :
     IsMappedKey(T) ? FromMappedKey(K, T.keys) :
     // unevaluated types
-    IsConstructor(T) ? Constructor(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
-    IsFunction(T) ? FunctionType(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
-    IsAsyncIterator(T) ? AsyncIterator(FromSchemaType(K, T.items)) :
-    IsIterator(T) ? Iterator(FromSchemaType(K, T.items)) :
-    IsIntersect(T) ? Intersect(FromRest(K, T.allOf)) :
-    IsUnion(T) ? Union(FromRest(K, T.anyOf)) :
-    IsTuple(T) ? Tuple(FromRest(K, T.items ?? [])) :
-    IsObject(T) ? Object(FromProperties(K, T.properties)) :
-    IsArray(T) ? Array(FromSchemaType(K, T.items)) :
-    IsPromise(T) ? Promise(FromSchemaType(K, T.item)) :
+    IsConstructor(T) ? Constructor(FromRest(K, T.parameters), FromSchemaType(K, T.returns), options) :
+    IsFunction(T) ? FunctionType(FromRest(K, T.parameters), FromSchemaType(K, T.returns), options) :
+    IsAsyncIterator(T) ? AsyncIterator(FromSchemaType(K, T.items), options) :
+    IsIterator(T) ? Iterator(FromSchemaType(K, T.items), options) :
+    IsIntersect(T) ? Intersect(FromRest(K, T.allOf), options) :
+    IsUnion(T) ? Union(FromRest(K, T.anyOf), options) :
+    IsTuple(T) ? Tuple(FromRest(K, T.items ?? []), options) :
+    IsObject(T) ? Object(FromProperties(K, T.properties), options) :
+    IsArray(T) ? Array(FromSchemaType(K, T.items), options) :
+    IsPromise(T) ? Promise(FromSchemaType(K, T.item), options) :
     T
   ) as never
 }
diff --git a/src/type/omit/omit.ts b/src/type/omit/omit.ts
index 0d959fe25..60de12989 100644
--- a/src/type/omit/omit.ts
+++ b/src/type/omit/omit.ts
@@ -93,7 +93,7 @@ function OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]
   return (
     IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) : 
     IsUnion(T) ? Union(FromUnion(T.anyOf, K)) : 
-    IsObject(T) ? Object(FromProperties(T.properties, K)) : 
+    IsObject(T) ? Object(FromProperties(T.properties, K), Discard(T, [TransformKind, '$id', 'required'])) : 
     Object({})
   ) as never
 }
@@ -121,7 +121,5 @@ export function Omit(T: TSchema, K: any, options?: SchemaOptions): any {
   if (IsMappedResult(T)) return OmitFromMappedResult(T, K, options)
   // non-mapped
   const I = IsSchema(K) ? IndexPropertyKeys(K) : (K as string[])
-  const D = Discard(T, [TransformKind, '$id', 'required']) as TSchema
-  const R = OmitResolve(T, I)
-  return CreateType({ ...D, ...R }, options)
+  return CreateType(OmitResolve(T, I), options)
 }
diff --git a/src/type/pick/pick.ts b/src/type/pick/pick.ts
index 017914046..5340a4674 100644
--- a/src/type/pick/pick.ts
+++ b/src/type/pick/pick.ts
@@ -86,7 +86,7 @@ function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]
   return (
     IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) : 
     IsUnion(T) ? Union(FromUnion(T.anyOf, K)) : 
-    IsObject(T) ? Object(FromProperties(T.properties, K)) : 
+    IsObject(T) ? Object(FromProperties(T.properties, K), Discard(T, [TransformKind, '$id', 'required'])) :
     Object({})
   ) as never
 }
@@ -112,7 +112,5 @@ export function Pick(T: TSchema, K: any, options?: SchemaOptions): any {
   if (IsMappedResult(T)) return PickFromMappedResult(T, K, options)
   // non-mapped
   const I = IsSchema(K) ? IndexPropertyKeys(K) : (K as string[])
-  const D = Discard(T, [TransformKind, '$id', 'required']) as TSchema
-  const R = PickResolve(T, I)
-  return CreateType({ ...D, ...R }, options)
+  return CreateType(PickResolve(T, I), options)
 }
diff --git a/test/runtime/type/guard/type/omit.ts b/test/runtime/type/guard/type/omit.ts
index d9c77c686..dbd7e023c 100644
--- a/test/runtime/type/guard/type/omit.ts
+++ b/test/runtime/type/guard/type/omit.ts
@@ -126,4 +126,35 @@ describe('guard/type/TOmit', () => {
     const R = Type.Omit(S, ['x'])
     Assert.IsFalse(TransformKind in R)
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/944
+  // ----------------------------------------------------------------
+  it('Should retain interior properties 1', () => {
+    const A = Type.Object({ x: Type.Number() }, { additionalProperties: false })
+    const T = Type.Omit(A, ['x'])
+    Assert.IsFalse(T.additionalProperties as boolean)
+  })
+  it('Should retain interior properties 2', () => {
+    const A = Type.Object({ x: Type.Number() }, { additionalProperties: false })
+    const B = Type.Object({ y: Type.Number() }, { additionalProperties: false })
+    const U = Type.Union([A, B])
+    const T = Type.Omit(U, ['x'])
+    Assert.IsFalse(T.anyOf[0].additionalProperties as boolean)
+    Assert.IsFalse(T.anyOf[1].additionalProperties as boolean)
+  })
+  it('Should retain interior properties 3', () => {
+    const A = Type.Object({ x: Type.Number() }, { additionalProperties: false })
+    const B = Type.Object({ y: Type.Number() }, { additionalProperties: false })
+    const U = Type.Intersect([A, B])
+    const T = Type.Omit(U, ['x'])
+    Assert.IsFalse(T.allOf[0].additionalProperties as boolean)
+    Assert.IsFalse(T.allOf[1].additionalProperties as boolean)
+  })
+  it('Should retain interior properties 4', () => {
+    const A = Type.Object({ x: Type.Number(), y: Type.Number() }, { additionalProperties: false })
+    const T = Type.Mapped(Type.TemplateLiteral('${x|y|z}'), (_) => Type.Omit(A, ['x']))
+    Assert.IsFalse(T.properties.x.additionalProperties as boolean)
+    Assert.IsFalse(T.properties.y.additionalProperties as boolean)
+    Assert.IsFalse(T.properties.z.additionalProperties as boolean)
+  })
 })
diff --git a/test/runtime/type/guard/type/pick.ts b/test/runtime/type/guard/type/pick.ts
index e1cf25952..cb3c5edff 100644
--- a/test/runtime/type/guard/type/pick.ts
+++ b/test/runtime/type/guard/type/pick.ts
@@ -128,4 +128,35 @@ describe('guard/type/TPick', () => {
     const R = Type.Pick(S, ['x'])
     Assert.IsFalse(TransformKind in R)
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/944
+  // ----------------------------------------------------------------
+  it('Should retain interior properties 1', () => {
+    const A = Type.Object({ x: Type.Number() }, { additionalProperties: false })
+    const T = Type.Pick(A, ['x'])
+    Assert.IsFalse(T.additionalProperties as boolean)
+  })
+  it('Should retain interior properties 2', () => {
+    const A = Type.Object({ x: Type.Number() }, { additionalProperties: false })
+    const B = Type.Object({ y: Type.Number() }, { additionalProperties: false })
+    const U = Type.Union([A, B])
+    const T = Type.Pick(U, ['x'])
+    Assert.IsFalse(T.anyOf[0].additionalProperties as boolean)
+    Assert.IsFalse(T.anyOf[1].additionalProperties as boolean)
+  })
+  it('Should retain interior properties 3', () => {
+    const A = Type.Object({ x: Type.Number() }, { additionalProperties: false })
+    const B = Type.Object({ y: Type.Number() }, { additionalProperties: false })
+    const U = Type.Intersect([A, B])
+    const T = Type.Pick(U, ['x'])
+    Assert.IsFalse(T.allOf[0].additionalProperties as boolean)
+    Assert.IsFalse(T.allOf[1].additionalProperties as boolean)
+  })
+  it('Should retain interior properties 4', () => {
+    const A = Type.Object({ x: Type.Number(), y: Type.Number() }, { additionalProperties: false })
+    const T = Type.Mapped(Type.TemplateLiteral('${x|y|z}'), (_) => Type.Pick(A, ['x']))
+    Assert.IsFalse(T.properties.x.additionalProperties as boolean)
+    Assert.IsFalse(T.properties.y.additionalProperties as boolean)
+    Assert.IsFalse(T.properties.z.additionalProperties as boolean)
+  })
 })

From a5b03c0b83bb746fb9d4685bc1c2809d49a9e0a1 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 9 Aug 2024 22:29:53 +0900
Subject: [PATCH 269/369] Revision 0.33.3 (#950)

* Reimplement Object Diff

* Version
---
 package-lock.json                 |  4 +--
 package.json                      |  2 +-
 src/value/delta/delta.ts          | 55 ++++++++++++++++++-------------
 test/runtime/value/delta/diff.ts  | 22 +++++++++----
 test/runtime/value/delta/patch.ts | 10 ++++++
 5 files changed, 61 insertions(+), 32 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 79ede7384..e2eb7ab66 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.2",
+  "version": "0.33.3",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.2",
+      "version": "0.33.3",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 9f4f29ebd..07be5d30f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.2",
+  "version": "0.33.3",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/delta/delta.ts b/src/value/delta/delta.ts
index bd437acc1..fd65c57cc 100644
--- a/src/value/delta/delta.ts
+++ b/src/value/delta/delta.ts
@@ -26,11 +26,12 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsStandardObject, IsArray, IsTypedArray, IsValueType, IsSymbol, IsUndefined } from '../guard/index'
+import { HasPropertyKey, IsStandardObject, IsArray, IsTypedArray, IsValueType } from '../guard/index'
 import type { ObjectType, ArrayType, TypedArrayType, ValueType } from '../guard/index'
 import type { Static } from '../../type/static/index'
 import { ValuePointer } from '../pointer/index'
 import { Clone } from '../clone/index'
+import { Equal } from '../equal/equal'
 import { TypeBoxError } from '../../type/error/index'
 
 import { Literal, type TLiteral } from '../../type/literal/index'
@@ -85,16 +86,11 @@ export const Edit: TUnion<[typeof Insert, typeof Update, typeof Delete]> = Union
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValueDeltaError extends TypeBoxError {
+export class ValueDiffError extends TypeBoxError {
   constructor(public readonly value: unknown, message: string) {
     super(message)
   }
 }
-export class ValueDeltaSymbolError extends ValueDeltaError {
-  constructor(public readonly value: unknown) {
-    super(value, 'Cannot diff objects with symbol keys')
-  }
-}
 // ------------------------------------------------------------------
 // Command Factory
 // ------------------------------------------------------------------
@@ -108,28 +104,41 @@ function CreateDelete(path: string): Edit {
   return { type: 'delete', path }
 }
 // ------------------------------------------------------------------
+// AssertDiffable
+// ------------------------------------------------------------------
+function AssertDiffable(value: unknown): asserts value is Record<string | number, unknown> {
+  if (globalThis.Object.getOwnPropertySymbols(value).length > 0) throw new ValueDiffError(value, 'Cannot diff objects with symbols')
+}
+// ------------------------------------------------------------------
 // Diffing Generators
 // ------------------------------------------------------------------
 function* ObjectType(path: string, current: ObjectType, next: unknown): IterableIterator<Edit> {
+  AssertDiffable(current)
+  AssertDiffable(next)
   if (!IsStandardObject(next)) return yield CreateUpdate(path, next)
-  const currentKeys = [...globalThis.Object.keys(current), ...globalThis.Object.getOwnPropertySymbols(current)]
-  const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)]
-  for (const key of currentKeys) {
-    if (IsSymbol(key)) throw new ValueDeltaSymbolError(key)
-    if (IsUndefined(next[key]) && nextKeys.includes(key)) yield CreateUpdate(`${path}/${globalThis.String(key)}`, undefined)
-  }
+  const currentKeys = globalThis.Object.getOwnPropertyNames(current)
+  const nextKeys = globalThis.Object.getOwnPropertyNames(next)
+  // ----------------------------------------------------------------
+  // inserts
+  // ----------------------------------------------------------------
   for (const key of nextKeys) {
-    if (IsUndefined(current[key]) || IsUndefined(next[key])) continue
-    if (IsSymbol(key)) throw new ValueDeltaSymbolError(key)
-    yield* Visit(`${path}/${globalThis.String(key)}`, current[key], next[key])
+    if (HasPropertyKey(current, key)) continue
+    yield CreateInsert(`${path}/${key}`, next[key])
   }
-  for (const key of nextKeys) {
-    if (IsSymbol(key)) throw new ValueDeltaSymbolError(key)
-    if (IsUndefined(current[key])) yield CreateInsert(`${path}/${globalThis.String(key)}`, next[key])
+  // ----------------------------------------------------------------
+  // updates
+  // ----------------------------------------------------------------
+  for (const key of currentKeys) {
+    if (!HasPropertyKey(next, key)) continue
+    if (Equal(current, next)) continue
+    yield* Visit(`${path}/${key}`, current[key], next[key])
   }
-  for (const key of currentKeys.reverse()) {
-    if (IsSymbol(key)) throw new ValueDeltaSymbolError(key)
-    if (IsUndefined(next[key]) && !nextKeys.includes(key)) yield CreateDelete(`${path}/${globalThis.String(key)}`)
+  // ----------------------------------------------------------------
+  // deletes
+  // ----------------------------------------------------------------
+  for (const key of currentKeys) {
+    if (HasPropertyKey(next, key)) continue
+    yield CreateDelete(`${path}/${key}`)
   }
 }
 function* ArrayType(path: string, current: ArrayType, next: unknown): IterableIterator<Edit> {
@@ -161,7 +170,7 @@ function* Visit(path: string, current: unknown, next: unknown): IterableIterator
   if (IsArray(current)) return yield* ArrayType(path, current, next)
   if (IsTypedArray(current)) return yield* TypedArrayType(path, current, next)
   if (IsValueType(current)) return yield* ValueType(path, current, next)
-  throw new ValueDeltaError(current, 'Unable to create diff edits for unknown value')
+  throw new ValueDiffError(current, 'Unable to diff value')
 }
 // ------------------------------------------------------------------
 // Diff
diff --git a/test/runtime/value/delta/diff.ts b/test/runtime/value/delta/diff.ts
index 2943e157f..6be662fcb 100644
--- a/test/runtime/value/delta/diff.ts
+++ b/test/runtime/value/delta/diff.ts
@@ -251,14 +251,14 @@ describe('value/delta/Diff', () => {
     const A = { x: 1, y: 1, z: 1 }
     const B = { a: 2, b: 2, c: 2 }
     const D = Value.Diff(A, B)
-    const E = [Insert('/a', 2), Insert('/b', 2), Insert('/c', 2), Delete('/z'), Delete('/y'), Delete('/x')]
+    const E = [Insert('/a', 2), Insert('/b', 2), Insert('/c', 2), Delete('/x'), Delete('/y'), Delete('/z')]
     Assert.IsEqual(D, E)
   })
-  it('Should diff PROPERTY update, insert and delete order preserved', () => {
+  it('Should diff PROPERTY insert, update, and delete order preserved', () => {
     const A = { x: 1, y: 1, z: 1, w: 1 }
     const B = { a: 2, b: 2, c: 2, w: 2 }
     const D = Value.Diff(A, B)
-    const E = [Update('/w', 2), Insert('/a', 2), Insert('/b', 2), Insert('/c', 2), Delete('/z'), Delete('/y'), Delete('/x')]
+    const E = [Insert('/a', 2), Insert('/b', 2), Insert('/c', 2), Update('/w', 2), Delete('/x'), Delete('/y'), Delete('/z')]
     Assert.IsEqual(D, E)
   })
   // ----------------------------------------------------
@@ -303,7 +303,7 @@ describe('value/delta/Diff', () => {
     const A = { v: { x: 1, y: 1 } }
     const B = { v: { x: 2, w: 2 } }
     const D = Value.Diff(A, B)
-    const E = [Update('/v/x', B.v.x), Insert('/v/w', B.v.w), Delete('/v/y')]
+    const E = [Insert('/v/w', B.v.w), Update('/v/x', B.v.x), Delete('/v/y')]
     Assert.IsEqual(D, E)
   })
   // ----------------------------------------------------
@@ -344,11 +344,11 @@ describe('value/delta/Diff', () => {
     const E = [Delete('/0/v/z')]
     Assert.IsEqual(D, E)
   })
-  it('Should diff NESTED ARRAY update, insert and delete order preserved', () => {
+  it('Should diff NESTED ARRAY insert update and delete order preserved', () => {
     const A = [{ v: { x: 1, y: 1 } }]
     const B = [{ v: { x: 2, w: 2 } }]
     const D = Value.Diff(A, B)
-    const E = [Update('/0/v/x', B[0].v.x), Insert('/0/v/w', B[0].v.w), Delete('/0/v/y')]
+    const E = [Insert('/0/v/w', B[0].v.w), Update('/0/v/x', B[0].v.x), Delete('/0/v/y')]
     Assert.IsEqual(D, E)
   })
   it('Should throw if attempting to diff a current value with symbol key', () => {
@@ -382,4 +382,14 @@ describe('value/delta/Diff', () => {
     const E = [Update('', new Uint8Array([0, 9, 2, 3, 4]))]
     Assert.IsEqual(D, E)
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/937
+  // ----------------------------------------------------------------
+  it('Should generate no diff for undefined properties of current and next', () => {
+    const A = { a: undefined }
+    const B = { a: undefined }
+    const D = Value.Diff(A, B)
+    const E = [] as any
+    Assert.IsEqual(D, E)
+  })
 })
diff --git a/test/runtime/value/delta/patch.ts b/test/runtime/value/delta/patch.ts
index 7e308c42a..2addfe53c 100644
--- a/test/runtime/value/delta/patch.ts
+++ b/test/runtime/value/delta/patch.ts
@@ -411,4 +411,14 @@ describe('value/delta/Patch', () => {
     const P = Value.Patch(A, D)
     Assert.IsEqual(B, P)
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/937
+  // ----------------------------------------------------------------
+  it('Should generate no diff for undefined properties of current and next', () => {
+    const A = { a: undefined }
+    const B = { a: undefined }
+    const D = Value.Diff(A, B)
+    const P = Value.Patch(A, D)
+    Assert.IsEqual(B, P)
+  })
 })

From 92851ea30a361288665ee65fa8e11f43ea3d1f77 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 10 Aug 2024 18:16:09 +0900
Subject: [PATCH 270/369] Revision 0.33.4 (#953)

* Add Assert and Parse Functions

* Documentation

* Version

* Benchmarks
---
 package-lock.json                      |   4 +-
 package.json                           |   2 +-
 readme.md                              | 244 ++++++++++++-------------
 src/compiler/compiler.ts               |   9 +-
 src/value/assert/assert.ts             |  73 ++++++++
 src/value/assert/index.ts              |  29 +++
 src/value/cast/cast.ts                 |   4 +-
 src/value/clean/clean.ts               |  15 +-
 src/value/clone/clone.ts               |  32 ++--
 src/value/convert/convert.ts           |  41 ++---
 src/value/create/create.ts             |   6 +-
 src/value/default/default.ts           |  30 ++-
 src/value/equal/equal.ts               |   6 +-
 src/value/hash/hash.ts                 |   4 +-
 src/value/index.ts                     |   2 +
 src/value/mutate/mutate.ts             |  10 +-
 src/value/parse/index.ts               |  29 +++
 src/value/parse/parse.ts               |  68 +++++++
 src/value/transform/decode.ts          |  14 +-
 src/value/transform/encode.ts          |  16 +-
 src/value/transform/has.ts             |   6 +-
 src/value/value/value.ts               |  42 +++--
 test/runtime/value/assert/assert.ts    |  35 ++++
 test/runtime/value/assert/index.ts     |   1 +
 test/runtime/value/default/union.ts    |  12 +-
 test/runtime/value/index.ts            |   2 +
 test/runtime/value/parse/index.ts      |   1 +
 test/runtime/value/parse/parse.ts      |  90 +++++++++
 test/runtime/value/transform/record.ts |   1 -
 29 files changed, 592 insertions(+), 236 deletions(-)
 create mode 100644 src/value/assert/assert.ts
 create mode 100644 src/value/assert/index.ts
 create mode 100644 src/value/parse/index.ts
 create mode 100644 src/value/parse/parse.ts
 create mode 100644 test/runtime/value/assert/assert.ts
 create mode 100644 test/runtime/value/assert/index.ts
 create mode 100644 test/runtime/value/parse/index.ts
 create mode 100644 test/runtime/value/parse/parse.ts

diff --git a/package-lock.json b/package-lock.json
index e2eb7ab66..01590d97b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.3",
+  "version": "0.33.4",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.3",
+      "version": "0.33.4",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 07be5d30f..04c5b2a29 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.3",
+  "version": "0.33.4",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 6d1aa239b..1fca89253 100644
--- a/readme.md
+++ b/readme.md
@@ -74,13 +74,12 @@ License MIT
   - [Indexed](#types-indexed)
   - [Mapped](#types-mapped)
   - [Conditional](#types-conditional)
-  - [Intrinsic](#types-intrinsic)
   - [Transform](#types-transform)
-  - [Rest](#types-rest)
   - [Guard](#types-guard)
   - [Unsafe](#types-unsafe)
   - [Strict](#types-strict)
 - [Values](#values)
+  - [Assert](#values-assert)
   - [Create](#values-create)
   - [Clone](#values-clone)
   - [Check](#values-check)
@@ -90,6 +89,7 @@ License MIT
   - [Cast](#values-cast)
   - [Decode](#values-decode)
   - [Encode](#values-decode)
+  - [Parse](#values-parse)
   - [Equal](#values-equal)
   - [Hash](#values-hash)
   - [Diff](#values-diff)
@@ -176,19 +176,17 @@ type T = Static<typeof T>                            // type T = {
 
 //--------------------------------------------------------------------------------------------
 //
-// ... then use the type both as Json Schema and as a TypeScript type.
+// ... or use the type to parse JavaScript values.
 //
 //--------------------------------------------------------------------------------------------
 
 import { Value } from '@sinclair/typebox/value'
 
-function receive(value: T) {                         // ... as a Static Type
-
-  if(Value.Check(T, value)) {                        // ... as a Json Schema
-
-    // ok...
-  }
-}
+const R = Value.Parse(T, value)                      // const R: {
+                                                     //   id: string,
+                                                     //   name: string,
+                                                     //   timestamp: number
+                                                     // }
 ```
 
 <a name='types'></a>
@@ -1000,38 +998,6 @@ const C = Type.Exclude(                              // type C = Exclude<1 | 2 |
 )                                                    // ]>
 ```
 
-<a name='types-intrinsic'></a>
-
-### Intrinsic Types
-
-TypeBox supports the TypeScript intrinsic string manipulation types Uppercase, Lowercase, Capitalize and Uncapitalize. These types can be used to remap Literal, Template Literal and Union of Literal types.
-
-```typescript
-// TypeScript
-type A = Capitalize<'hello'>                         // type A = 'Hello'
-
-type B = Capitalize<'hello' | 'world'>               // type C = 'Hello' | 'World'
-
-type C = Capitalize<`hello${1|2|3}`>                 // type B = 'Hello1' | 'Hello2' | 'Hello3'
-
-// TypeBox
-const A = Type.Capitalize(Type.Literal('hello'))     // const A: TLiteral<'Hello'>
-
-const B = Type.Capitalize(Type.Union([               // const B: TUnion<[
-  Type.Literal('hello'),                             //   TLiteral<'Hello'>,
-  Type.Literal('world')                              //   TLiteral<'World'>
-]))                                                  // ]>
-
-const C = Type.Capitalize(                           // const C: TTemplateLiteral<[
-  Type.TemplateLiteral('hello${1|2|3}')              //   TLiteral<'Hello'>,
-)                                                    //   TUnion<[
-                                                     //     TLiteral<'1'>,
-                                                     //     TLiteral<'2'>,
-                                                     //     TLiteral<'3'>
-                                                     //   ]>
-                                                     // ]>
-```
-
 <a name='types-transform'></a>
 
 ### Transform Types
@@ -1061,26 +1027,6 @@ type E = StaticEncode<typeof T>                      // type E = Array<number>
 type T = Static<typeof T>                            // type T = Array<number>
 ```
 
-<a name='types-rest'></a>
-
-### Rest Types
-
-TypeBox provides the Rest type to uniformly extract variadic tuples from Intersect, Union and Tuple types. This type can be useful to remap variadic types into different forms. The following uses Rest to remap a Tuple into a Union.
-
-```typescript
-const T = Type.Tuple([                               // const T: TTuple<[
-  Type.String(),                                     //   TString,
-  Type.Number()                                      //   TNumber
-])                                                   // ]>
-
-const R = Type.Rest(T)                               // const R: [TString, TNumber]
-
-const U = Type.Union(R)                              // const T: TUnion<[
-                                                     //   TString,
-                                                     //   TNumber
-                                                     // ]>
-```
-
 <a name='types-unsafe'></a>
 
 ### Unsafe Types
@@ -1171,6 +1117,18 @@ TypeBox provides an optional Value submodule that can be used to perform structu
 import { Value } from '@sinclair/typebox/value'
 ```
 
+<a name='values-assert'></a>
+
+### Assert
+
+Use the Assert function to assert a value is valid.
+
+```typescript
+let value: unknown = 1
+
+Value.Assert(Type.Number(), value)                   // throws AssertError if invalid
+```
+
 <a name='values-create'></a>
 
 ### Create
@@ -1296,6 +1254,32 @@ const A = Value.Encode(Type.String(), 'hello')        // const A = 'hello'
 const B = Value.Encode(Type.String(), 42)             // throw
 ```
 
+<a name='values-parse'></a>
+
+### Parse
+
+Use the Parse function to parse a value or throw if invalid. This function internally uses Default, Clean, Convert and Decode to make a best effort attempt to parse the value into the expected type. This function should not be used in performance critical code paths.
+
+```typescript
+const T = Type.Object({ x: Type.Number({ default: 0 }), y: Type.Number({ default: 0 }) })
+
+// Default
+
+const A = Value.Parse(T, { })                                 // const A = { x: 0, y: 0 }
+
+// Convert
+
+const B = Value.Parse(T, { x: '1', y: '2' })                  // const B = { x: 1, y: 2 }
+
+// Clean
+
+const C = Value.Parse(T, { x: 1, y: 2, z: 3 })                // const C = { x: 1, y: 2 }
+
+// Assert
+
+const D = Value.Parse(T, undefined)                           // throws AssertError
+```
+
 <a name='values-equal'></a>
 
 ### Equal
@@ -1716,37 +1700,37 @@ This benchmark measures compilation performance for varying types.
 
 ```typescript
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
-│          (index)           │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
+│ (index)                    │ Iterations │ Ajv          │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │    1000    │ '    242 ms' │ '     10 ms' │ '   24.20 x' │
-│ Literal_Number             │    1000    │ '    200 ms' │ '      8 ms' │ '   25.00 x' │
-│ Literal_Boolean            │    1000    │ '    168 ms' │ '      6 ms' │ '   28.00 x' │
-│ Primitive_Number           │    1000    │ '    165 ms' │ '      8 ms' │ '   20.63 x' │
-│ Primitive_String           │    1000    │ '    154 ms' │ '      6 ms' │ '   25.67 x' │
-│ Primitive_String_Pattern   │    1000    │ '    208 ms' │ '     14 ms' │ '   14.86 x' │
-│ Primitive_Boolean          │    1000    │ '    142 ms' │ '      6 ms' │ '   23.67 x' │
-│ Primitive_Null             │    1000    │ '    143 ms' │ '      6 ms' │ '   23.83 x' │
-│ Object_Unconstrained       │    1000    │ '   1217 ms' │ '     31 ms' │ '   39.26 x' │
-│ Object_Constrained         │    1000    │ '   1275 ms' │ '     26 ms' │ '   49.04 x' │
-│ Object_Vector3             │    1000    │ '    405 ms' │ '     12 ms' │ '   33.75 x' │
-│ Object_Box3D               │    1000    │ '   1833 ms' │ '     27 ms' │ '   67.89 x' │
-│ Tuple_Primitive            │    1000    │ '    475 ms' │ '     13 ms' │ '   36.54 x' │
-│ Tuple_Object               │    1000    │ '   1267 ms' │ '     30 ms' │ '   42.23 x' │
-│ Composite_Intersect        │    1000    │ '    604 ms' │ '     18 ms' │ '   33.56 x' │
-│ Composite_Union            │    1000    │ '    545 ms' │ '     20 ms' │ '   27.25 x' │
-│ Math_Vector4               │    1000    │ '    829 ms' │ '     12 ms' │ '   69.08 x' │
-│ Math_Matrix4               │    1000    │ '    405 ms' │ '     10 ms' │ '   40.50 x' │
-│ Array_Primitive_Number     │    1000    │ '    372 ms' │ '     12 ms' │ '   31.00 x' │
-│ Array_Primitive_String     │    1000    │ '    327 ms' │ '      5 ms' │ '   65.40 x' │
-│ Array_Primitive_Boolean    │    1000    │ '    300 ms' │ '      4 ms' │ '   75.00 x' │
-│ Array_Object_Unconstrained │    1000    │ '   1755 ms' │ '     21 ms' │ '   83.57 x' │
-│ Array_Object_Constrained   │    1000    │ '   1516 ms' │ '     20 ms' │ '   75.80 x' │
-│ Array_Tuple_Primitive      │    1000    │ '    825 ms' │ '     14 ms' │ '   58.93 x' │
-│ Array_Tuple_Object         │    1000    │ '   1616 ms' │ '     16 ms' │ '  101.00 x' │
-│ Array_Composite_Intersect  │    1000    │ '    776 ms' │ '     16 ms' │ '   48.50 x' │
-│ Array_Composite_Union      │    1000    │ '    820 ms' │ '     14 ms' │ '   58.57 x' │
-│ Array_Math_Vector4         │    1000    │ '   1166 ms' │ '     15 ms' │ '   77.73 x' │
-│ Array_Math_Matrix4         │    1000    │ '    695 ms' │ '      8 ms' │ '   86.88 x' │
+│ Literal_String             │ 1000       │ '    211 ms' │ '      8 ms' │ '   26.38 x' │
+│ Literal_Number             │ 1000       │ '    185 ms' │ '      5 ms' │ '   37.00 x' │
+│ Literal_Boolean            │ 1000       │ '    195 ms' │ '      4 ms' │ '   48.75 x' │
+│ Primitive_Number           │ 1000       │ '    149 ms' │ '      7 ms' │ '   21.29 x' │
+│ Primitive_String           │ 1000       │ '    135 ms' │ '      5 ms' │ '   27.00 x' │
+│ Primitive_String_Pattern   │ 1000       │ '    193 ms' │ '     10 ms' │ '   19.30 x' │
+│ Primitive_Boolean          │ 1000       │ '    152 ms' │ '      4 ms' │ '   38.00 x' │
+│ Primitive_Null             │ 1000       │ '    147 ms' │ '      4 ms' │ '   36.75 x' │
+│ Object_Unconstrained       │ 1000       │ '   1065 ms' │ '     26 ms' │ '   40.96 x' │
+│ Object_Constrained         │ 1000       │ '   1183 ms' │ '     26 ms' │ '   45.50 x' │
+│ Object_Vector3             │ 1000       │ '    407 ms' │ '      9 ms' │ '   45.22 x' │
+│ Object_Box3D               │ 1000       │ '   1777 ms' │ '     24 ms' │ '   74.04 x' │
+│ Tuple_Primitive            │ 1000       │ '    485 ms' │ '     11 ms' │ '   44.09 x' │
+│ Tuple_Object               │ 1000       │ '   1344 ms' │ '     17 ms' │ '   79.06 x' │
+│ Composite_Intersect        │ 1000       │ '    606 ms' │ '     14 ms' │ '   43.29 x' │
+│ Composite_Union            │ 1000       │ '    522 ms' │ '     17 ms' │ '   30.71 x' │
+│ Math_Vector4               │ 1000       │ '    851 ms' │ '      9 ms' │ '   94.56 x' │
+│ Math_Matrix4               │ 1000       │ '    406 ms' │ '     10 ms' │ '   40.60 x' │
+│ Array_Primitive_Number     │ 1000       │ '    367 ms' │ '      6 ms' │ '   61.17 x' │
+│ Array_Primitive_String     │ 1000       │ '    339 ms' │ '      7 ms' │ '   48.43 x' │
+│ Array_Primitive_Boolean    │ 1000       │ '    325 ms' │ '      5 ms' │ '   65.00 x' │
+│ Array_Object_Unconstrained │ 1000       │ '   1863 ms' │ '     21 ms' │ '   88.71 x' │
+│ Array_Object_Constrained   │ 1000       │ '   1535 ms' │ '     18 ms' │ '   85.28 x' │
+│ Array_Tuple_Primitive      │ 1000       │ '    829 ms' │ '     14 ms' │ '   59.21 x' │
+│ Array_Tuple_Object         │ 1000       │ '   1674 ms' │ '     14 ms' │ '  119.57 x' │
+│ Array_Composite_Intersect  │ 1000       │ '    789 ms' │ '     13 ms' │ '   60.69 x' │
+│ Array_Composite_Union      │ 1000       │ '    822 ms' │ '     15 ms' │ '   54.80 x' │
+│ Array_Math_Vector4         │ 1000       │ '   1129 ms' │ '     14 ms' │ '   80.64 x' │
+│ Array_Math_Matrix4         │ 1000       │ '    673 ms' │ '      9 ms' │ '   74.78 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1758,39 +1742,39 @@ This benchmark measures validation performance for varying types.
 
 ```typescript
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
-│          (index)           │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
+│ (index)                    │ Iterations │ ValueCheck   │ Ajv          │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │  1000000   │ '     18 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
-│ Literal_Number             │  1000000   │ '     16 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
-│ Literal_Boolean            │  1000000   │ '     15 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│ Primitive_Number           │  1000000   │ '     21 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│ Primitive_String           │  1000000   │ '     22 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
-│ Primitive_String_Pattern   │  1000000   │ '    155 ms' │ '     41 ms' │ '     34 ms' │ '    1.21 x' │
-│ Primitive_Boolean          │  1000000   │ '     18 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Primitive_Null             │  1000000   │ '     19 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Object_Unconstrained       │  1000000   │ '   1003 ms' │ '     32 ms' │ '     24 ms' │ '    1.33 x' │
-│ Object_Constrained         │  1000000   │ '   1265 ms' │ '     49 ms' │ '     38 ms' │ '    1.29 x' │
-│ Object_Vector3             │  1000000   │ '    418 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
-│ Object_Box3D               │  1000000   │ '   2035 ms' │ '     56 ms' │ '     49 ms' │ '    1.14 x' │
-│ Object_Recursive           │  1000000   │ '   5243 ms' │ '    326 ms' │ '    157 ms' │ '    2.08 x' │
-│ Tuple_Primitive            │  1000000   │ '    153 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
-│ Tuple_Object               │  1000000   │ '    781 ms' │ '     28 ms' │ '     18 ms' │ '    1.56 x' │
-│ Composite_Intersect        │  1000000   │ '    742 ms' │ '     25 ms' │ '     14 ms' │ '    1.79 x' │
-│ Composite_Union            │  1000000   │ '    558 ms' │ '     24 ms' │ '     13 ms' │ '    1.85 x' │
-│ Math_Vector4               │  1000000   │ '    246 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
-│ Math_Matrix4               │  1000000   │ '   1052 ms' │ '     43 ms' │ '     28 ms' │ '    1.54 x' │
-│ Array_Primitive_Number     │  1000000   │ '    272 ms' │ '     22 ms' │ '     12 ms' │ '    1.83 x' │
-│ Array_Primitive_String     │  1000000   │ '    235 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
-│ Array_Primitive_Boolean    │  1000000   │ '    134 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
-│ Array_Object_Unconstrained │  1000000   │ '   6280 ms' │ '     65 ms' │ '     59 ms' │ '    1.10 x' │
-│ Array_Object_Constrained   │  1000000   │ '   6076 ms' │ '    130 ms' │ '    119 ms' │ '    1.09 x' │
-│ Array_Object_Recursive     │  1000000   │ '  22738 ms' │ '   1730 ms' │ '    635 ms' │ '    2.72 x' │
-│ Array_Tuple_Primitive      │  1000000   │ '    689 ms' │ '     35 ms' │ '     30 ms' │ '    1.17 x' │
-│ Array_Tuple_Object         │  1000000   │ '   3266 ms' │ '     63 ms' │ '     52 ms' │ '    1.21 x' │
-│ Array_Composite_Intersect  │  1000000   │ '   3310 ms' │ '     44 ms' │ '     36 ms' │ '    1.22 x' │
-│ Array_Composite_Union      │  1000000   │ '   2432 ms' │ '     69 ms' │ '     33 ms' │ '    2.09 x' │
-│ Array_Math_Vector4         │  1000000   │ '   1158 ms' │ '     37 ms' │ '     24 ms' │ '    1.54 x' │
-│ Array_Math_Matrix4         │  1000000   │ '   5435 ms' │ '    132 ms' │ '     92 ms' │ '    1.43 x' │
+│ Literal_String             │ 1000000    │ '     17 ms' │ '      5 ms' │ '      5 ms' │ '    1.00 x' │
+│ Literal_Number             │ 1000000    │ '     14 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
+│ Literal_Boolean            │ 1000000    │ '     14 ms' │ '     20 ms' │ '      9 ms' │ '    2.22 x' │
+│ Primitive_Number           │ 1000000    │ '     17 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
+│ Primitive_String           │ 1000000    │ '     17 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
+│ Primitive_String_Pattern   │ 1000000    │ '    172 ms' │ '     46 ms' │ '     41 ms' │ '    1.12 x' │
+│ Primitive_Boolean          │ 1000000    │ '     14 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│ Primitive_Null             │ 1000000    │ '     16 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
+│ Object_Unconstrained       │ 1000000    │ '    437 ms' │ '     28 ms' │ '     14 ms' │ '    2.00 x' │
+│ Object_Constrained         │ 1000000    │ '    653 ms' │ '     46 ms' │ '     37 ms' │ '    1.24 x' │
+│ Object_Vector3             │ 1000000    │ '    201 ms' │ '     22 ms' │ '     12 ms' │ '    1.83 x' │
+│ Object_Box3D               │ 1000000    │ '    961 ms' │ '     37 ms' │ '     19 ms' │ '    1.95 x' │
+│ Object_Recursive           │ 1000000    │ '   3715 ms' │ '    363 ms' │ '    174 ms' │ '    2.09 x' │
+│ Tuple_Primitive            │ 1000000    │ '    107 ms' │ '     23 ms' │ '     11 ms' │ '    2.09 x' │
+│ Tuple_Object               │ 1000000    │ '    375 ms' │ '     28 ms' │ '     15 ms' │ '    1.87 x' │
+│ Composite_Intersect        │ 1000000    │ '    377 ms' │ '     22 ms' │ '     12 ms' │ '    1.83 x' │
+│ Composite_Union            │ 1000000    │ '    337 ms' │ '     30 ms' │ '     17 ms' │ '    1.76 x' │
+│ Math_Vector4               │ 1000000    │ '    137 ms' │ '     23 ms' │ '     11 ms' │ '    2.09 x' │
+│ Math_Matrix4               │ 1000000    │ '    576 ms' │ '     37 ms' │ '     28 ms' │ '    1.32 x' │
+│ Array_Primitive_Number     │ 1000000    │ '    145 ms' │ '     23 ms' │ '     12 ms' │ '    1.92 x' │
+│ Array_Primitive_String     │ 1000000    │ '    152 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
+│ Array_Primitive_Boolean    │ 1000000    │ '    131 ms' │ '     20 ms' │ '     13 ms' │ '    1.54 x' │
+│ Array_Object_Unconstrained │ 1000000    │ '   2821 ms' │ '     62 ms' │ '     45 ms' │ '    1.38 x' │
+│ Array_Object_Constrained   │ 1000000    │ '   2958 ms' │ '    119 ms' │ '    134 ms' │ '    0.89 x' │
+│ Array_Object_Recursive     │ 1000000    │ '  14695 ms' │ '   1621 ms' │ '    635 ms' │ '    2.55 x' │
+│ Array_Tuple_Primitive      │ 1000000    │ '    478 ms' │ '     35 ms' │ '     28 ms' │ '    1.25 x' │
+│ Array_Tuple_Object         │ 1000000    │ '   1623 ms' │ '     63 ms' │ '     48 ms' │ '    1.31 x' │
+│ Array_Composite_Intersect  │ 1000000    │ '   1582 ms' │ '     43 ms' │ '     30 ms' │ '    1.43 x' │
+│ Array_Composite_Union      │ 1000000    │ '   1331 ms' │ '     76 ms' │ '     40 ms' │ '    1.90 x' │
+│ Array_Math_Vector4         │ 1000000    │ '    564 ms' │ '     38 ms' │ '     24 ms' │ '    1.58 x' │
+│ Array_Math_Matrix4         │ 1000000    │ '   2382 ms' │ '    111 ms' │ '     83 ms' │ '    1.34 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1802,13 +1786,13 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 
 ```typescript
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
-│       (index)        │  Compiled  │  Minified  │ Compression │
+│ (index)              │ Compiled   │ Minified   │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '126.9 kb' │ ' 55.7 kb' │  '2.28 x'   │
-│ typebox/errors       │ ' 46.1 kb' │ ' 20.8 kb' │  '2.22 x'   │
-│ typebox/system       │ '  4.7 kb' │ '  2.0 kb' │  '2.33 x'   │
-│ typebox/value        │ '152.2 kb' │ ' 64.5 kb' │  '2.36 x'   │
-│ typebox              │ ' 95.7 kb' │ ' 39.8 kb' │  '2.40 x'   │
+│ typebox/compiler     │ '119.6 kb' │ ' 52.6 kb' │ '2.27 x'    │
+│ typebox/errors       │ ' 48.6 kb' │ ' 21.9 kb' │ '2.22 x'    │
+│ typebox/system       │ '  7.4 kb' │ '  3.2 kb' │ '2.33 x'    │
+│ typebox/value        │ '157.8 kb' │ ' 66.6 kb' │ '2.37 x'    │
+│ typebox              │ ' 98.3 kb' │ ' 40.9 kb' │ '2.40 x'    │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 8e939f1f7..f41203479 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -71,6 +71,7 @@ import type { TSymbol } from '../type/symbol/index'
 import type { TUndefined } from '../type/undefined/index'
 import type { TUint8Array } from '../type/uint8array/index'
 import type { TVoid } from '../type/void/index'
+
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -104,15 +105,15 @@ export class TypeCheck<T extends TSchema> {
     return this.checkFunc(value)
   }
   /** Decodes a value or throws if error */
-  public Decode(value: unknown): StaticDecode<T> {
+  public Decode<R = StaticDecode<T>>(value: unknown): R {
     if (!this.checkFunc(value)) throw new TransformDecodeCheckError(this.schema, value, this.Errors(value).First()!)
-    return this.hasTransform ? TransformDecode(this.schema, this.references, value) : value
+    return (this.hasTransform ? TransformDecode(this.schema, this.references, value) : value) as never
   }
   /** Encodes a value or throws if error */
-  public Encode(value: unknown): StaticEncode<T> {
+  public Encode<R = StaticEncode<T>>(value: unknown): R {
     const encoded = this.hasTransform ? TransformEncode(this.schema, this.references, value) : value
     if (!this.checkFunc(encoded)) throw new TransformEncodeCheckError(this.schema, value, this.Errors(value).First()!)
-    return encoded
+    return encoded as never
   }
 }
 // ------------------------------------------------------------------
diff --git a/src/value/assert/assert.ts b/src/value/assert/assert.ts
new file mode 100644
index 000000000..07a50db10
--- /dev/null
+++ b/src/value/assert/assert.ts
@@ -0,0 +1,73 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Errors, ValueErrorIterator, ValueError } from '../../errors/index'
+import { TypeBoxError } from '../../type/error/error'
+import { TSchema } from '../../type/schema/index'
+import { Static } from '../../type/static/index'
+import { Check } from '../check/check'
+
+// ------------------------------------------------------------------
+// AssertError
+// ------------------------------------------------------------------
+export class AssertError extends TypeBoxError {
+  readonly #iterator: ValueErrorIterator
+  error: ValueError | undefined
+  constructor(iterator: ValueErrorIterator) {
+    const error = iterator.First()
+    super(error === undefined ? 'Invalid Value' : error.message)
+    this.#iterator = iterator
+    this.error = error
+  }
+  /** Returns an iterator for each error in this value. */
+  public Errors(): ValueErrorIterator {
+    return new ValueErrorIterator(this.#Iterator())
+  }
+  *#Iterator(): IterableIterator<ValueError> {
+    if (this.error) yield this.error
+    yield* this.#iterator
+  }
+}
+// ------------------------------------------------------------------
+// AssertValue
+// ------------------------------------------------------------------
+function AssertValue(schema: TSchema, references: TSchema[], value: unknown): unknown {
+  if (Check(schema, references, value)) return
+  throw new AssertError(Errors(schema, references, value))
+}
+// ------------------------------------------------------------------
+// Assert
+// ------------------------------------------------------------------
+/** Asserts a value matches the given type or throws an `AssertError` if invalid */
+export function Assert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): asserts value is Static<T>
+/** Asserts a value matches the given type or throws an `AssertError` if invalid */
+export function Assert<T extends TSchema>(schema: T, value: unknown): asserts value is Static<T>
+/** Asserts a value matches the given type or throws an `AssertError` if invalid */
+export function Assert(...args: any[]): unknown {
+  return args.length === 3 ? AssertValue(args[0], args[1], args[2]) : AssertValue(args[0], [], args[1])
+}
diff --git a/src/value/assert/index.ts b/src/value/assert/index.ts
new file mode 100644
index 000000000..c2b2c88b3
--- /dev/null
+++ b/src/value/assert/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './assert'
diff --git a/src/value/cast/cast.ts b/src/value/cast/cast.ts
index c3313f7b1..78ac75433 100644
--- a/src/value/cast/cast.ts
+++ b/src/value/cast/cast.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsStandardObject, IsArray, IsString, IsNumber, IsNull } from '../guard/index'
+import { IsObject, IsArray, IsString, IsNumber, IsNull } from '../guard/index'
 import { TypeBoxError } from '../../type/error/index'
 import { Kind } from '../../type/symbols/index'
 import { Create } from '../create/index'
@@ -135,7 +135,7 @@ function FromConstructor(schema: TConstructor, references: TSchema[], value: any
 }
 function FromIntersect(schema: TIntersect, references: TSchema[], value: any): any {
   const created = Create(schema, references)
-  const mapped = IsStandardObject(created) && IsStandardObject(value) ? { ...(created as any), ...value } : value
+  const mapped = IsObject(created) && IsObject(value) ? { ...(created as any), ...value } : value
   return Check(schema, references, mapped) ? mapped : Create(schema, references)
 }
 function FromNever(schema: TNever, references: TSchema[], value: any): any {
diff --git a/src/value/clean/clean.ts b/src/value/clean/clean.ts
index 589d3170b..d3be4a79d 100644
--- a/src/value/clean/clean.ts
+++ b/src/value/clean/clean.ts
@@ -47,6 +47,7 @@ import type { TUnion } from '../../type/union/index'
 // ------------------------------------------------------------------
 // prettier-ignore
 import { 
+  HasPropertyKey,
   IsString, 
   IsObject, 
   IsArray, 
@@ -57,13 +58,13 @@ import {
 // ------------------------------------------------------------------
 // prettier-ignore
 import { 
-  IsSchema
-} from '../../type/guard/type'
+  IsKind
+} from '../../type/guard/kind'
 // ------------------------------------------------------------------
 // IsCheckable
 // ------------------------------------------------------------------
 function IsCheckable(schema: unknown): boolean {
-  return IsSchema(schema) && schema[Kind] !== 'Unsafe'
+  return IsKind(schema) && schema[Kind] !== 'Unsafe'
 }
 // ------------------------------------------------------------------
 // Types
@@ -76,7 +77,7 @@ function FromIntersect(schema: TIntersect, references: TSchema[], value: unknown
   const unevaluatedProperties = schema.unevaluatedProperties as TSchema
   const intersections = schema.allOf.map((schema) => Visit(schema, references, Clone(value)))
   const composite = intersections.reduce((acc: any, value: any) => (IsObject(value) ? { ...acc, ...value } : value), {})
-  if (!IsObject(value) || !IsObject(composite) || !IsSchema(unevaluatedProperties)) return composite
+  if (!IsObject(value) || !IsObject(composite) || !IsKind(unevaluatedProperties)) return composite
   const knownkeys = KeyOfPropertyKeys(schema) as string[]
   for (const key of Object.getOwnPropertyNames(value)) {
     if (knownkeys.includes(key)) continue
@@ -90,11 +91,11 @@ function FromObject(schema: TObject, references: TSchema[], value: unknown): any
   if (!IsObject(value) || IsArray(value)) return value // Check IsArray for AllowArrayObject configuration
   const additionalProperties = schema.additionalProperties as TSchema
   for (const key of Object.getOwnPropertyNames(value)) {
-    if (key in schema.properties) {
+    if (HasPropertyKey(schema.properties, key)) {
       value[key] = Visit(schema.properties[key], references, value[key])
       continue
     }
-    if (IsSchema(additionalProperties) && Check(additionalProperties, references, value[key])) {
+    if (IsKind(additionalProperties) && Check(additionalProperties, references, value[key])) {
       value[key] = Visit(additionalProperties, references, value[key])
       continue
     }
@@ -113,7 +114,7 @@ function FromRecord(schema: TRecord, references: TSchema[], value: unknown): any
       value[key] = Visit(propertySchema, references, value[key])
       continue
     }
-    if (IsSchema(additionalProperties) && Check(additionalProperties, references, value[key])) {
+    if (IsKind(additionalProperties) && Check(additionalProperties, references, value[key])) {
       value[key] = Visit(additionalProperties, references, value[key])
       continue
     }
diff --git a/src/value/clone/clone.ts b/src/value/clone/clone.ts
index 3bec35c88..370fdac49 100644
--- a/src/value/clone/clone.ts
+++ b/src/value/clone/clone.ts
@@ -26,16 +26,16 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import type { ObjectType, ArrayType, TypedArrayType, ValueType } from '../guard/index'
+import type { ObjectType as FromObject, ArrayType as FromArray, TypedArrayType, ValueType } from '../guard/index'
 
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsArray, IsDate, IsStandardObject, IsTypedArray, IsValueType } from '../guard/index'
+import { IsArray, IsDate, IsMap, IsSet, IsObject, IsTypedArray, IsValueType } from '../guard/index'
 // ------------------------------------------------------------------
 // Clonable
 // ------------------------------------------------------------------
-function ObjectType(value: ObjectType): any {
+function FromObject(value: FromObject): any {
   const Acc = {} as Record<PropertyKey, unknown>
   for (const key of Object.getOwnPropertyNames(value)) {
     Acc[key] = Clone(value[key])
@@ -45,16 +45,22 @@ function ObjectType(value: ObjectType): any {
   }
   return Acc
 }
-function ArrayType(value: ArrayType): any {
+function FromArray(value: FromArray): any {
   return value.map((element: any) => Clone(element))
 }
-function TypedArrayType(value: TypedArrayType): any {
+function FromTypedArray(value: TypedArrayType): any {
   return value.slice()
 }
-function DateType(value: Date): any {
+function FromMap(value: Map<unknown, unknown>): any {
+  return new Map(Clone([...value.entries()]))
+}
+function FromSet(value: Set<unknown>): any {
+  return new Set(Clone([...value.entries()]))
+}
+function FromDate(value: Date): any {
   return new Date(value.toISOString())
 }
-function ValueType(value: ValueType): any {
+function FromValue(value: ValueType): any {
   return value
 }
 // ------------------------------------------------------------------
@@ -62,10 +68,12 @@ function ValueType(value: ValueType): any {
 // ------------------------------------------------------------------
 /** Returns a clone of the given value */
 export function Clone<T extends unknown>(value: T): T {
-  if (IsArray(value)) return ArrayType(value)
-  if (IsDate(value)) return DateType(value)
-  if (IsStandardObject(value)) return ObjectType(value)
-  if (IsTypedArray(value)) return TypedArrayType(value)
-  if (IsValueType(value)) return ValueType(value)
+  if (IsArray(value)) return FromArray(value)
+  if (IsDate(value)) return FromDate(value)
+  if (IsTypedArray(value)) return FromTypedArray(value)
+  if (IsMap(value)) return FromMap(value)
+  if (IsSet(value)) return FromSet(value)
+  if (IsObject(value)) return FromObject(value)
+  if (IsValueType(value)) return FromValue(value)
   throw new Error('ValueClone: Unable to clone value')
 }
diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index 21d1dbbcc..e493e2444 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -106,7 +106,7 @@ function TryConvertLiteral(schema: TLiteral, value: unknown) {
     IsString(schema.const) ? TryConvertLiteralString(value, schema.const) :
     IsNumber(schema.const) ? TryConvertLiteralNumber(value, schema.const) :
     IsBoolean(schema.const) ? TryConvertLiteralBoolean(value, schema.const) :
-    Clone(value)
+    value
   )
 }
 function TryConvertBoolean(value: unknown) {
@@ -156,7 +156,7 @@ function TryConvertDate(value: unknown) {
 // ------------------------------------------------------------------
 // Default
 // ------------------------------------------------------------------
-function Default(value: any) {
+function Default(value: unknown): unknown {
   return value
 }
 // ------------------------------------------------------------------
@@ -192,26 +192,21 @@ function FromNumber(schema: TNumber, references: TSchema[], value: any): unknown
 }
 // prettier-ignore
 function FromObject(schema: TObject, references: TSchema[], value: any): unknown {
-  const isConvertable = IsObject(value)
-  if(!isConvertable) return value
-  const result: Record<PropertyKey, unknown> = {}
-  for(const key of Object.keys(value)) {
-    result[key] = HasPropertyKey(schema.properties, key)
-      ? Visit(schema.properties[key], references, value[key])
-      : value[key]
+  if(!IsObject(value)) return value
+  for(const key of Object.getOwnPropertyNames(schema.properties)) {
+    value[key] = Visit(schema.properties[key], references, value[key])
   }
-  return result
+  return value
 }
 function FromRecord(schema: TRecord, references: TSchema[], value: any): unknown {
   const isConvertable = IsObject(value)
   if (!isConvertable) return value
   const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0]
   const property = schema.patternProperties[propertyKey]
-  const result = {} as Record<string, unknown>
   for (const [propKey, propValue] of Object.entries(value)) {
-    result[propKey] = Visit(property, references, propValue)
+    value[propKey] = Visit(property, references, propValue)
   }
-  return result
+  return value
 }
 function FromRef(schema: TRef, references: TSchema[], value: any): unknown {
   return Visit(Deref(schema, references), references, value)
@@ -233,21 +228,25 @@ function FromTuple(schema: TTuple, references: TSchema[], value: any): unknown {
     return (index < schema.items!.length)
       ? Visit(schema.items![index], references, value) 
       : value
-  }) 
+  })
 }
 function FromUndefined(schema: TUndefined, references: TSchema[], value: any): unknown {
   return TryConvertUndefined(value)
 }
 function FromUnion(schema: TUnion, references: TSchema[], value: any): unknown {
   for (const subschema of schema.anyOf) {
-    const converted = Visit(subschema, references, value)
+    const converted = Visit(subschema, references, Clone(value))
     if (!Check(subschema, references, converted)) continue
     return converted
   }
   return value
 }
+function AddReference(references: TSchema[], schema: TSchema): TSchema[] {
+  references.push(schema)
+  return references
+}
 function Visit(schema: TSchema, references: TSchema[], value: any): unknown {
-  const references_ = IsString(schema.$id) ? [...references, schema] : references
+  const references_ = IsString(schema.$id) ? AddReference(references, schema) : references
   const schema_ = schema as any
   switch (schema[Kind]) {
     case 'Array':
@@ -293,14 +292,12 @@ function Visit(schema: TSchema, references: TSchema[], value: any): unknown {
 // ------------------------------------------------------------------
 // Convert
 // ------------------------------------------------------------------
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export function Convert(schema: TSchema, value: unknown): unknown
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 // prettier-ignore
 export function Convert(...args: any[]) {
-  return args.length === 3 
-    ? Visit(args[0], args[1], args[2]) 
-    : Visit(args[0], [], args[1])
+  return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1])
 }
diff --git a/src/value/create/create.ts b/src/value/create/create.ts
index 008105bff..b46e83761 100644
--- a/src/value/create/create.ts
+++ b/src/value/create/create.ts
@@ -389,8 +389,12 @@ function FromKind(schema: TSchema, references: TSchema[]): any {
     throw new Error('User defined types must specify a default value')
   }
 }
+function AddReference(references: TSchema[], schema: TSchema): TSchema[] {
+  references.push(schema)
+  return references
+}
 function Visit(schema: TSchema, references: TSchema[]): unknown {
-  const references_ = IsString(schema.$id) ? [...references, schema] : references
+  const references_ = IsString(schema.$id) ? AddReference(references, schema) : references
   const schema_ = schema as any
   switch (schema_[Kind]) {
     case 'Any':
diff --git a/src/value/default/default.ts b/src/value/default/default.ts
index b84ce005f..6c2d64709 100644
--- a/src/value/default/default.ts
+++ b/src/value/default/default.ts
@@ -48,7 +48,7 @@ import { IsString, IsObject, IsArray, IsUndefined } from '../guard/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsSchema } from '../../type/guard/type'
+import { IsKind } from '../../type/guard/kind'
 // ------------------------------------------------------------------
 // ValueOrDefault
 // ------------------------------------------------------------------
@@ -56,16 +56,10 @@ function ValueOrDefault(schema: TSchema, value: unknown) {
   return value === undefined && 'default' in schema ? Clone(schema.default) : value
 }
 // ------------------------------------------------------------------
-// IsCheckable
+// HasDefaultProperty
 // ------------------------------------------------------------------
-function IsCheckable(schema: unknown): boolean {
-  return IsSchema(schema) && schema[Kind] !== 'Unsafe'
-}
-// ------------------------------------------------------------------
-// IsDefaultSchema
-// ------------------------------------------------------------------
-function IsDefaultSchema(value: unknown): value is TSchema {
-  return IsSchema(value) && 'default' in value
+function HasDefaultProperty(schema: unknown): schema is TSchema {
+  return IsKind(schema) && 'default' in schema
 }
 // ------------------------------------------------------------------
 // Types
@@ -92,11 +86,11 @@ function FromObject(schema: TObject, references: TSchema[], value: unknown): any
   const knownPropertyKeys = Object.getOwnPropertyNames(schema.properties)
   // properties
   for (const key of knownPropertyKeys) {
-    if (!IsDefaultSchema(schema.properties[key])) continue
+    if (!HasDefaultProperty(schema.properties[key])) continue
     defaulted[key] = Visit(schema.properties[key], references, defaulted[key])
   }
   // return if not additional properties
-  if (!IsDefaultSchema(additionalPropertiesSchema)) return defaulted
+  if (!HasDefaultProperty(additionalPropertiesSchema)) return defaulted
   // additional properties
   for (const key of Object.getOwnPropertyNames(defaulted)) {
     if (knownPropertyKeys.includes(key)) continue
@@ -112,11 +106,11 @@ function FromRecord(schema: TRecord, references: TSchema[], value: unknown): any
   const knownPropertyKey = new RegExp(propertyKeyPattern)
   // properties
   for (const key of Object.getOwnPropertyNames(defaulted)) {
-    if (!(knownPropertyKey.test(key) && IsDefaultSchema(propertySchema))) continue
+    if (!(knownPropertyKey.test(key) && HasDefaultProperty(propertySchema))) continue
     defaulted[key] = Visit(propertySchema, references, defaulted[key])
   }
   // return if not additional properties
-  if (!IsDefaultSchema(additionalPropertiesSchema)) return defaulted
+  if (!HasDefaultProperty(additionalPropertiesSchema)) return defaulted
   // additional properties
   for (const key of Object.getOwnPropertyNames(defaulted)) {
     if (knownPropertyKey.test(key)) continue
@@ -143,14 +137,18 @@ function FromUnion(schema: TUnion, references: TSchema[], value: unknown): any {
   const defaulted = ValueOrDefault(schema, value)
   for (const inner of schema.anyOf) {
     const result = Visit(inner, references, defaulted)
-    if (IsCheckable(inner) && Check(inner, result)) {
+    if (Check(inner, result)) {
       return result
     }
   }
   return defaulted
 }
+function AddReference(references: TSchema[], schema: TSchema): TSchema[] {
+  references.push(schema)
+  return references
+}
 function Visit(schema: TSchema, references: TSchema[], value: unknown): any {
-  const references_ = IsString(schema.$id) ? [...references, schema] : references
+  const references_ = IsString(schema.$id) ? AddReference(references, schema) : references
   const schema_ = schema as any
   switch (schema_[Kind]) {
     case 'Array':
diff --git a/src/value/equal/equal.ts b/src/value/equal/equal.ts
index ce64ea993..8646fd739 100644
--- a/src/value/equal/equal.ts
+++ b/src/value/equal/equal.ts
@@ -26,14 +26,14 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsStandardObject, IsDate, IsArray, IsTypedArray, IsValueType } from '../guard/index'
+import { IsObject, IsDate, IsArray, IsTypedArray, IsValueType } from '../guard/index'
 import type { ObjectType, ArrayType, TypedArrayType, ValueType } from '../guard/index'
 
 // ------------------------------------------------------------------
 // Equality Checks
 // ------------------------------------------------------------------
 function ObjectType(left: ObjectType, right: unknown): boolean {
-  if (!IsStandardObject(right)) return false
+  if (!IsObject(right)) return false
   const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)]
   const rightKeys = [...Object.keys(right), ...Object.getOwnPropertySymbols(right)]
   if (leftKeys.length !== rightKeys.length) return false
@@ -58,10 +58,10 @@ function ValueType(left: ValueType, right: unknown): any {
 // ------------------------------------------------------------------
 /** Returns true if the left value deep-equals the right */
 export function Equal<T>(left: T, right: unknown): right is T {
-  if (IsStandardObject(left)) return ObjectType(left, right)
   if (IsDate(left)) return DateType(left, right)
   if (IsTypedArray(left)) return TypedArrayType(left, right)
   if (IsArray(left)) return ArrayType(left, right)
+  if (IsObject(left)) return ObjectType(left, right)
   if (IsValueType(left)) return ValueType(left, right)
   throw new Error('ValueEquals: Unable to compare value')
 }
diff --git a/src/value/hash/hash.ts b/src/value/hash/hash.ts
index faa1f66ea..2a173423c 100644
--- a/src/value/hash/hash.ts
+++ b/src/value/hash/hash.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsStandardObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index'
+import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index'
 import { TypeBoxError } from '../../type/error/index'
 
 // ------------------------------------------------------------------
@@ -140,7 +140,7 @@ function Visit(value: any) {
   if (IsDate(value)) return DateType(value)
   if (IsNull(value)) return NullType(value)
   if (IsNumber(value)) return NumberType(value)
-  if (IsStandardObject(value)) return ObjectType(value)
+  if (IsObject(value)) return ObjectType(value)
   if (IsString(value)) return StringType(value)
   if (IsSymbol(value)) return SymbolType(value)
   if (IsUint8Array(value)) return Uint8ArrayType(value)
diff --git a/src/value/index.ts b/src/value/index.ts
index 445581ad3..d422f87ca 100644
--- a/src/value/index.ts
+++ b/src/value/index.ts
@@ -37,6 +37,7 @@ export * from './guard/index'
 // ------------------------------------------------------------------
 // Operators
 // ------------------------------------------------------------------
+export * from './assert/index'
 export * from './cast/index'
 export * from './check/index'
 export * from './clean/index'
@@ -48,6 +49,7 @@ export * from './delta/index'
 export * from './equal/index'
 export * from './hash/index'
 export * from './mutate/index'
+export * from './parse/index'
 export * from './pointer/index'
 export * from './transform/index'
 // ------------------------------------------------------------------
diff --git a/src/value/mutate/mutate.ts b/src/value/mutate/mutate.ts
index 0ae01a6fe..ed35d9cfd 100644
--- a/src/value/mutate/mutate.ts
+++ b/src/value/mutate/mutate.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IsStandardObject, IsArray, IsTypedArray, IsValueType, type TypedArrayType } from '../guard/index'
+import { IsObject, IsArray, IsTypedArray, IsValueType, type TypedArrayType } from '../guard/index'
 import { ValuePointer } from '../pointer/index'
 import { Clone } from '../clone/index'
 import { TypeBoxError } from '../../type/error/index'
@@ -44,7 +44,7 @@ export class ValueMutateError extends TypeBoxError {
 // ------------------------------------------------------------------
 export type Mutable = { [key: string]: unknown } | unknown[]
 function ObjectType(root: Mutable, path: string, current: unknown, next: Record<string, unknown>) {
-  if (!IsStandardObject(current)) {
+  if (!IsObject(current)) {
     ValuePointer.Set(root, path, Clone(next))
   } else {
     const currentKeys = Object.getOwnPropertyNames(current)
@@ -90,7 +90,7 @@ function ValueType(root: Mutable, path: string, current: unknown, next: unknown)
 function Visit(root: Mutable, path: string, current: unknown, next: unknown) {
   if (IsArray(next)) return ArrayType(root, path, current, next)
   if (IsTypedArray(next)) return TypedArrayType(root, path, current, next)
-  if (IsStandardObject(next)) return ObjectType(root, path, current, next)
+  if (IsObject(next)) return ObjectType(root, path, current, next)
   if (IsValueType(next)) return ValueType(root, path, current, next)
 }
 // ------------------------------------------------------------------
@@ -102,8 +102,8 @@ function IsNonMutableValue(value: unknown): value is Mutable {
 function IsMismatchedValue(current: unknown, next: unknown) {
   // prettier-ignore
   return (
-    (IsStandardObject(current) && IsArray(next)) || 
-    (IsArray(current) && IsStandardObject(next))
+    (IsObject(current) && IsArray(next)) || 
+    (IsArray(current) && IsObject(next))
   )
 }
 // ------------------------------------------------------------------
diff --git a/src/value/parse/index.ts b/src/value/parse/index.ts
new file mode 100644
index 000000000..3d329f1ce
--- /dev/null
+++ b/src/value/parse/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './parse'
diff --git a/src/value/parse/parse.ts b/src/value/parse/parse.ts
new file mode 100644
index 000000000..13477a4c9
--- /dev/null
+++ b/src/value/parse/parse.ts
@@ -0,0 +1,68 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TransformDecode, HasTransform } from '../transform/index'
+import { TSchema } from '../../type/schema/index'
+import { StaticDecode } from '../../type/static/index'
+import { Assert } from '../assert/assert'
+import { Default } from '../default/default'
+import { Convert } from '../convert/convert'
+import { Clean } from '../clean/clean'
+import { Clone } from '../clone/index'
+
+// ------------------------------------------------------------------
+// ParseReducer
+// ------------------------------------------------------------------
+type ReducerFunction = (schema: TSchema, references: TSchema[], value: unknown) => unknown
+
+// prettier-ignore
+const ParseReducer: ReducerFunction[] = [
+  (_schema, _references, value) => Clone(value),
+  (schema, references, value) => Default(schema, references, value),
+  (schema, references, value) => Clean(schema, references, value),
+  (schema, references, value) => Convert(schema, references, value),
+  (schema, references, value) => { Assert(schema, references, value); return value },
+  (schema, references, value) => (HasTransform(schema, references) ? TransformDecode(schema, references, value) : value),
+]
+// ------------------------------------------------------------------
+// ParseValue
+// ------------------------------------------------------------------
+function ParseValue<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R {
+  return ParseReducer.reduce((value, reducer) => reducer(schema, references, value), value) as R
+}
+// ------------------------------------------------------------------
+// Parse
+// ------------------------------------------------------------------
+/** Parses a value or throws an `AssertError` if invalid. */
+export function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R
+/** Parses a value or throws an `AssertError` if invalid. */
+export function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R
+/** Parses a value or throws an `AssertError` if invalid. */
+export function Parse(...args: any[]): unknown {
+  return args.length === 3 ? ParseValue(args[0], args[1], args[2]) : ParseValue(args[0], [], args[1])
+}
diff --git a/src/value/transform/decode.ts b/src/value/transform/decode.ts
index e6ffb9a5a..a713c62a5 100644
--- a/src/value/transform/decode.ts
+++ b/src/value/transform/decode.ts
@@ -48,7 +48,7 @@ import type { TUnion } from '../../type/union/index'
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsStandardObject, IsArray, IsValueType } from '../guard/index'
+import { IsObject, IsArray, IsValueType } from '../guard/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -97,7 +97,7 @@ function FromArray(schema: TArray, references: TSchema[], path: string, value: a
 }
 // prettier-ignore
 function FromIntersect(schema: TIntersect, references: TSchema[], path: string, value: any) {
-  if (!IsStandardObject(value) || IsValueType(value)) return Default(schema, path, value)
+  if (!IsObject(value) || IsValueType(value)) return Default(schema, path, value)
   const knownEntries = KeyOfPropertyEntries(schema)
   const knownKeys = knownEntries.map(entry => entry[0])
   const knownProperties = { ...value } as Record<PropertyKey, unknown>
@@ -120,7 +120,7 @@ function FromNot(schema: TNot, references: TSchema[], path: string, value: any)
 }
 // prettier-ignore
 function FromObject(schema: TObject, references: TSchema[], path: string, value: any) {
-  if (!IsStandardObject(value)) return Default(schema, path, value)
+  if (!IsObject(value)) return Default(schema, path, value)
   const knownKeys = KeyOfPropertyKeys(schema)
   const knownProperties = { ...value } as Record<PropertyKey, unknown>
   for(const key of knownKeys) if(key in knownProperties) {
@@ -139,7 +139,7 @@ function FromObject(schema: TObject, references: TSchema[], path: string, value:
 }
 // prettier-ignore
 function FromRecord(schema: TRecord, references: TSchema[], path: string, value: any) {
-  if (!IsStandardObject(value)) return Default(schema, path, value)
+  if (!IsObject(value)) return Default(schema, path, value)
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
   const knownKeys = new RegExp(pattern)
   const knownProperties = { ...value } as Record<PropertyKey, unknown>
@@ -183,9 +183,13 @@ function FromUnion(schema: TUnion, references: TSchema[], path: string, value: a
   }
   return Default(schema, path, value)
 }
+function AddReference(references: TSchema[], schema: TSchema): TSchema[] {
+  references.push(schema)
+  return references
+}
 // prettier-ignore
 function Visit(schema: TSchema, references: TSchema[], path: string, value: any): any {
-  const references_ = typeof schema.$id === 'string' ? [...references, schema] : references
+  const references_ = typeof schema.$id === 'string' ? AddReference(references, schema) : references
   const schema_ = schema as any
   switch (schema[Kind]) {
     case 'Array':
diff --git a/src/value/transform/encode.ts b/src/value/transform/encode.ts
index 39a43cf9e..2d857b7bd 100644
--- a/src/value/transform/encode.ts
+++ b/src/value/transform/encode.ts
@@ -48,7 +48,7 @@ import type { TUnion } from '../../type/union/index'
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsStandardObject, IsArray, IsValueType } from '../guard/index'
+import { IsObject, IsArray, IsValueType } from '../guard/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -98,7 +98,7 @@ function FromArray(schema: TArray, references: TSchema[], path: string, value: a
 // prettier-ignore
 function FromIntersect(schema: TIntersect, references: TSchema[], path: string, value: any) {
   const defaulted = Default(schema, path, value)
-  if (!IsStandardObject(value) || IsValueType(value)) return defaulted
+  if (!IsObject(value) || IsValueType(value)) return defaulted
   const knownEntries = KeyOfPropertyEntries(schema)
   const knownKeys = knownEntries.map(entry => entry[0])
   const knownProperties = { ...defaulted } as Record<PropertyKey, unknown>
@@ -123,7 +123,7 @@ function FromNot(schema: TNot, references: TSchema[], path: string, value: any)
 // prettier-ignore
 function FromObject(schema: TObject, references: TSchema[], path: string, value: any) {
   const defaulted = Default(schema, path, value)
-  if (!IsStandardObject(defaulted)) return defaulted
+  if (!IsObject(defaulted)) return defaulted
   const knownKeys = KeyOfPropertyKeys(schema) as string[]
   const knownProperties = { ...defaulted } as Record<PropertyKey, unknown>
   for(const key of knownKeys) if(key in knownProperties) {
@@ -143,7 +143,7 @@ function FromObject(schema: TObject, references: TSchema[], path: string, value:
 // prettier-ignore
 function FromRecord(schema: TRecord, references: TSchema[], path: string, value: any) {
   const defaulted = Default(schema, path, value) as Record<PropertyKey, unknown>
-  if (!IsStandardObject(value)) return defaulted
+  if (!IsObject(value)) return defaulted
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
   const knownKeys = new RegExp(pattern)
   const knownProperties = {...defaulted } as Record<PropertyKey, unknown>
@@ -151,7 +151,7 @@ function FromRecord(schema: TRecord, references: TSchema[], path: string, value:
     knownProperties[key] = Visit(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key])
   }
   if (!IsSchema(schema.additionalProperties)) {
-    return Default(schema, path, knownProperties)
+    return knownProperties
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties)
   const additionalProperties = schema.additionalProperties as TSchema
@@ -194,9 +194,13 @@ function FromUnion(schema: TUnion, references: TSchema[], path: string, value: a
   }
   return Default(schema, path, value)
 }
+function AddReference(references: TSchema[], schema: TSchema): TSchema[] {
+  references.push(schema)
+  return references
+}
 // prettier-ignore
 function Visit(schema: TSchema, references: TSchema[], path: string, value: any): any {
-  const references_ = typeof schema.$id === 'string' ? [...references, schema] : references
+  const references_ = typeof schema.$id === 'string' ? AddReference(references, schema) : references
   const schema_ = schema as any
   switch (schema[Kind]) {
     case 'Array':
diff --git a/src/value/transform/has.ts b/src/value/transform/has.ts
index 9aff3d25e..27d731554 100644
--- a/src/value/transform/has.ts
+++ b/src/value/transform/has.ts
@@ -120,9 +120,13 @@ function FromTuple(schema: TTuple, references: TSchema[]) {
 function FromUnion(schema: TUnion, references: TSchema[]) {
   return IsTransform(schema) || schema.anyOf.some((schema) => Visit(schema, references))
 }
+function AddReference(references: TSchema[], schema: TSchema): TSchema[] {
+  references.push(schema)
+  return references
+}
 // prettier-ignore
 function Visit(schema: TSchema, references: TSchema[]): boolean {
-  const references_ = IsString(schema.$id) ? [...references, schema] : references
+  const references_ = IsString(schema.$id) ? AddReference(references, schema) : references
   const schema_ = schema as any
   if (schema.$id && visited.has(schema.$id)) return false
   if (schema.$id) visited.add(schema.$id)
diff --git a/src/value/value/value.ts b/src/value/value/value.ts
index 944d27d60..347b14a29 100644
--- a/src/value/value/value.ts
+++ b/src/value/value/value.ts
@@ -27,6 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { HasTransform, TransformDecode, TransformEncode, TransformDecodeCheckError, TransformEncodeCheckError } from '../transform/index'
+import { Assert as AssertValue } from '../assert/index'
 import { Mutate as MutateValue, type Mutable } from '../mutate/index'
 import { Hash as HashValue } from '../hash/index'
 import { Equal as EqualValue } from '../equal/index'
@@ -36,6 +37,7 @@ import { Convert as ConvertValue } from '../convert/index'
 import { Create as CreateValue } from '../create/index'
 import { Clean as CleanValue } from '../clean/index'
 import { Check as CheckValue } from '../check/index'
+import { Parse as ParseValue } from '../parse/index'
 import { Default as DefaultValue } from '../default/index'
 import { Diff as DiffValue, Patch as PatchValue, Edit } from '../delta/index'
 import { Errors as ValueErrors, ValueErrorIterator } from '../../errors/index'
@@ -43,12 +45,20 @@ import { Errors as ValueErrors, ValueErrorIterator } from '../../errors/index'
 import type { TSchema } from '../../type/schema/index'
 import type { Static, StaticDecode, StaticEncode } from '../../type/static/index'
 
+/** Asserts a value matches the given type or throws an `AssertError` if invalid. */
+export function Assert<T extends TSchema, R = Static<T>>(schema: T, references: TSchema[], value: unknown): asserts value is R
+/** Asserts a value matches the given type or throws an `AssertError` if invalid. */
+export function Assert<T extends TSchema, R = Static<T>>(schema: T, value: unknown): asserts value is R
+/** Asserts a value matches the given type or throws an `AssertError` if invalid. */
+export function Assert(...args: any[]): any {
+  return AssertValue.apply(AssertValue, args as any)
+}
 /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
 export function Cast<T extends TSchema>(schema: T, references: TSchema[], value: unknown): Static<T>
 /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
 export function Cast<T extends TSchema>(schema: T, value: unknown): Static<T>
 /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
-export function Cast(...args: any[]) {
+export function Cast(...args: any[]): any {
   return CastValue.apply(CastValue, args as any)
 }
 /** Creates a value from the given type and references */
@@ -56,7 +66,7 @@ export function Create<T extends TSchema>(schema: T, references: TSchema[]): Sta
 /** Creates a value from the given type */
 export function Create<T extends TSchema>(schema: T): Static<T>
 /** Creates a value from the given type */
-export function Create(...args: any[]) {
+export function Create(...args: any[]): any {
   return CreateValue.apply(CreateValue, args as any)
 }
 /** Returns true if the value matches the given type and references */
@@ -64,7 +74,7 @@ export function Check<T extends TSchema>(schema: T, references: TSchema[], value
 /** Returns true if the value matches the given type */
 export function Check<T extends TSchema>(schema: T, value: unknown): value is Static<T>
 /** Returns true if the value matches the given type */
-export function Check(...args: any[]) {
+export function Check(...args: any[]): any {
   return CheckValue.apply(CheckValue, args as any)
 }
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
@@ -72,15 +82,15 @@ export function Clean(schema: TSchema, references: TSchema[], value: unknown): u
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
 export function Clean(schema: TSchema, value: unknown): unknown
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export function Clean(...args: any[]) {
+export function Clean(...args: any[]): any {
   return CleanValue.apply(CleanValue, args as any)
 }
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export function Convert(schema: TSchema, value: unknown): unknown
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
-export function Convert(...args: any[]) {
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+export function Convert(...args: any[]): any {
   return ConvertValue.apply(ConvertValue, args as any)
 }
 /** Returns a structural clone of the given value */
@@ -92,7 +102,7 @@ export function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, refere
 /** Decodes a value or throws if error */
 export function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R
 /** Decodes a value or throws if error */
-export function Decode(...args: any[]) {
+export function Decode(...args: any[]): any {
   const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
   if (!Check(schema, references, value)) throw new TransformDecodeCheckError(schema, value, Errors(schema, references, value).First()!)
   return HasTransform(schema, references) ? TransformDecode(schema, references, value) : value
@@ -102,7 +112,7 @@ export function Default(schema: TSchema, references: TSchema[], value: unknown):
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export function Default(schema: TSchema, value: unknown): unknown
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export function Default(...args: any[]) {
+export function Default(...args: any[]): any {
   return DefaultValue.apply(DefaultValue, args as any)
 }
 /** Encodes a value or throws if error */
@@ -110,18 +120,26 @@ export function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, refere
 /** Encodes a value or throws if error */
 export function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, value: unknown): R
 /** Encodes a value or throws if error */
-export function Encode(...args: any[]) {
+export function Encode(...args: any[]): any {
   const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
   const encoded = HasTransform(schema, references) ? TransformEncode(schema, references, value) : value
   if (!Check(schema, references, encoded)) throw new TransformEncodeCheckError(schema, encoded, Errors(schema, references, encoded).First()!)
   return encoded
 }
+/** Parses a value or throws an `AssertError` if invalid. */
+export function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R
+/** Parses a value or throws an `AssertError` if invalid. */
+export function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R
+/** Parses a value or throws an `AssertError` if invalid. */
+export function Parse(...args: any[]): unknown {
+  return ParseValue.apply(ParseValue, args as any)
+}
 /** Returns an iterator for each error in this value. */
 export function Errors<T extends TSchema>(schema: T, references: TSchema[], value: unknown): ValueErrorIterator
 /** Returns an iterator for each error in this value. */
 export function Errors<T extends TSchema>(schema: T, value: unknown): ValueErrorIterator
 /** Returns an iterator for each error in this value. */
-export function Errors(...args: any[]) {
+export function Errors(...args: any[]): any {
   return ValueErrors.apply(ValueErrors, args as any)
 }
 /** Returns true if left and right values are structurally equal */
diff --git a/test/runtime/value/assert/assert.ts b/test/runtime/value/assert/assert.ts
new file mode 100644
index 000000000..fe3afdce2
--- /dev/null
+++ b/test/runtime/value/assert/assert.ts
@@ -0,0 +1,35 @@
+import { Value, AssertError } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/Assert', () => {
+  it('Should Assert', () => {
+    Assert.Throws(() => Value.Assert(Type.String(), 1))
+  })
+  it('Should throw AssertError', () => {
+    try {
+      Value.Assert(Type.String(), 1)
+    } catch (error) {
+      if (error instanceof AssertError) {
+        return
+      }
+      throw error
+    }
+  })
+  it('Should throw AssertError and produce Iterator', () => {
+    try {
+      Value.Assert(Type.String(), 1)
+    } catch (error) {
+      if (error instanceof AssertError) {
+        const first = error.Errors().First()
+        Assert.HasProperty(first, 'type')
+        Assert.HasProperty(first, 'schema')
+        Assert.HasProperty(first, 'path')
+        Assert.HasProperty(first, 'value')
+        Assert.HasProperty(first, 'message')
+        return
+      }
+      throw error
+    }
+  })
+})
diff --git a/test/runtime/value/assert/index.ts b/test/runtime/value/assert/index.ts
new file mode 100644
index 000000000..f043fc641
--- /dev/null
+++ b/test/runtime/value/assert/index.ts
@@ -0,0 +1 @@
+import './assert'
diff --git a/test/runtime/value/default/union.ts b/test/runtime/value/default/union.ts
index 56b572caf..e9f4e682e 100644
--- a/test/runtime/value/default/union.ts
+++ b/test/runtime/value/default/union.ts
@@ -1,5 +1,5 @@
 import { Value } from '@sinclair/typebox/value'
-import { Type } from '@sinclair/typebox'
+import { Type, Kind, TypeRegistry } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/default/Union', () => {
@@ -86,25 +86,29 @@ describe('value/default/Union', () => {
   // Interior Unsafe
   // ----------------------------------------------------------------
   it('Should default interior unsafe 1', () => {
+    TypeRegistry.Set('DefaultUnsafe', (schema, value) => typeof value === 'string')
     const T = Type.Union([
       Type.Object({
         x: Type.Number({ default: 1 }),
         y: Type.Number({ default: 2 }),
       }),
-      Type.Unsafe({ default: 'hello' }),
+      Type.Unsafe({ [Kind]: 'DefaultUnsafe', default: 'hello' }),
     ])
     const R = Value.Default(T, undefined)
-    Assert.IsEqual(R, undefined)
+    Assert.IsEqual(R, 'hello')
+    TypeRegistry.Delete('DefaultUnsafe')
   })
   it('Should default interior unsafe 2', () => {
+    TypeRegistry.Set('DefaultUnsafe', (schema, value) => typeof value === 'string')
     const T = Type.Union([
       Type.Object({
         x: Type.Number({ default: 1 }),
         y: Type.Number({ default: 2 }),
       }),
-      Type.Unsafe({ default: 'hello' }),
+      Type.Unsafe({ [Kind]: 'DefaultUnsafe', default: 'hello' }),
     ])
     const R = Value.Default(T, 'world')
     Assert.IsEqual(R, 'world')
+    TypeRegistry.Delete('DefaultUnsafe')
   })
 })
diff --git a/test/runtime/value/index.ts b/test/runtime/value/index.ts
index 4e6ce996e..515d5fff8 100644
--- a/test/runtime/value/index.ts
+++ b/test/runtime/value/index.ts
@@ -1,3 +1,4 @@
+import './assert'
 import './cast'
 import './check'
 import './clean'
@@ -10,5 +11,6 @@ import './equal'
 import './guard'
 import './hash'
 import './mutate'
+import './parse'
 import './pointer'
 import './transform'
diff --git a/test/runtime/value/parse/index.ts b/test/runtime/value/parse/index.ts
new file mode 100644
index 000000000..09cc87100
--- /dev/null
+++ b/test/runtime/value/parse/index.ts
@@ -0,0 +1 @@
+import './parse'
diff --git a/test/runtime/value/parse/parse.ts b/test/runtime/value/parse/parse.ts
new file mode 100644
index 000000000..5c8be9dd7
--- /dev/null
+++ b/test/runtime/value/parse/parse.ts
@@ -0,0 +1,90 @@
+import { Value, AssertError } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+// prettier-ignore
+describe('value/Parse', () => {
+  it('Should Parse', () => {
+    const A = Value.Parse(Type.Literal('hello'), 'hello')
+    Assert.IsEqual(A, 'hello')
+  })
+  it('Should not Parse', () => {
+    Assert.Throws(() => Value.Parse(Type.Literal('hello'), 'world'))
+  })
+  it('Should throw AssertError', () => {
+    try {
+      Value.Parse(Type.Literal('hello'), 'world')
+    } catch(error) {
+      if(error instanceof AssertError) {
+        return
+      }
+      throw error
+    }
+  })
+  it('Should throw AssertError and produce Iterator', () => {
+    try {
+      Value.Parse(Type.Literal('hello'), 'world')
+    } catch(error) {
+      if(error instanceof AssertError) {
+        const first = error.Errors().First()
+        Assert.HasProperty(first, 'type')
+        Assert.HasProperty(first, 'schema')
+        Assert.HasProperty(first, 'path')
+        Assert.HasProperty(first, 'value')
+        Assert.HasProperty(first, 'message')
+        return
+      }
+      throw error
+    }
+  })
+  // ----------------------------------------------------------------
+  // Default
+  // ----------------------------------------------------------------
+  it('Should use Default values', () => {
+    const X = Value.Parse(Type.Object({
+      x: Type.Number({ default: 1 }),
+      y: Type.Number({ default: 2 })
+    }), { })
+    Assert.IsEqual(X, { x: 1, y: 2 })
+  })
+  it('Should throw on invalid Default values', () => {
+    Assert.Throws(() => Value.Parse(Type.Object({
+      x: Type.Number({ default: null }),
+      y: Type.Number({ default: null })
+    }), { }))
+  })
+  // ----------------------------------------------------------------
+  // Convert
+  // ----------------------------------------------------------------
+  it('Should Convert value 1', () => {
+    const X = Value.Parse(Type.Object({
+      x: Type.Number(),
+      y: Type.Number()
+    }), { x: '1', y: '2' })
+    Assert.IsEqual(X, { x: 1, y: 2 })
+  })
+  it('Should Convert value 2', () => {
+    const X = Value.Parse(Type.Array(Type.String()), [1, 2, 3, 4])
+    Assert.IsEqual(X, ['1', '2', '3', '4'])
+  })
+  // ----------------------------------------------------------------
+  // Clean
+  // ----------------------------------------------------------------
+  it('Should Clean value', () => {
+    const X = Value.Parse(Type.Object({
+      x: Type.Number(),
+      y: Type.Number()
+    }), { x: 1, y: 2, z: 3 })
+    Assert.IsEqual(X, { x: 1, y: 2 })
+  })
+  // ----------------------------------------------------------------
+  // Decode
+  // ----------------------------------------------------------------
+  it('Should Decode value', () => {
+    const T = Type.Transform(Type.String())
+      .Decode(value => 'hello')
+      .Encode(value => value)
+    const X = Value.Parse(T, 'world')
+    Assert.IsEqual(X, 'hello')
+  })
+})
diff --git a/test/runtime/value/transform/record.ts b/test/runtime/value/transform/record.ts
index a91172dbf..6f53ef552 100644
--- a/test/runtime/value/transform/record.ts
+++ b/test/runtime/value/transform/record.ts
@@ -1,6 +1,5 @@
 import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
-import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
 
 describe('value/transform/Record', () => {

From e36f5658e3a56d8c32a711aa616ec8bb34ca14b4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9s=20Correa=20Casablanca?=
 <castarco@coderspirit.xyz>
Date: Sun, 11 Aug 2024 05:56:24 +0200
Subject: [PATCH 271/369] Ecosystem: Add `nominal-typebox` (#955)

---
 readme.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/readme.md b/readme.md
index 1fca89253..b79458c44 100644
--- a/readme.md
+++ b/readme.md
@@ -1676,6 +1676,7 @@ The following is a list of community packages that offer general tooling, extend
 | [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
 | [h3-typebox](https://github.com/kevinmarrec/h3-typebox) | Schema validation utilities for h3 using TypeBox & Ajv |
 | [http-wizard](https://github.com/flodlc/http-wizard) | Type safe http client library for Fastify |
+| [nominal-typebox](https://github.com/Coder-Spirit/nominal/tree/main/%40coderspirit/nominal-typebox) | Allows devs to integrate nominal types into TypeBox schemas |
 | [openapi-box](https://github.com/geut/openapi-box) | Generate TypeBox types from OpenApi IDL + Http client library |
 | [prismabox](https://github.com/m1212e/prismabox) | Converts a prisma.schema to typebox schema matching the database models |
 | [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from Json Schemas |

From cc5e6c7aca2237a67bf1b4a907904cca5a154ca2 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 14 Aug 2024 14:56:09 +0900
Subject: [PATCH 272/369] Revision 0.33.5 (#959)

* Use ExactOptionalProperty Policy on Decode | Encode

* Version
---
 package-lock.json                      |   4 +-
 package.json                           |   2 +-
 src/system/policy.ts                   |  10 +--
 src/value/convert/convert.ts           |  11 ++-
 src/value/transform/decode.ts          |  19 ++--
 src/value/transform/encode.ts          |  17 +++-
 test/runtime/value/convert/object.ts   |   5 ++
 test/runtime/value/transform/object.ts | 115 ++++++++++++++++++++++++-
 8 files changed, 162 insertions(+), 21 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 01590d97b..b5b0fad33 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.4",
+  "version": "0.33.5",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.4",
+      "version": "0.33.5",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 04c5b2a29..8e8477db3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.4",
+  "version": "0.33.5",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/system/policy.ts b/src/system/policy.ts
index 93a68f809..8501462c5 100644
--- a/src/system/policy.ts
+++ b/src/system/policy.ts
@@ -52,24 +52,24 @@ export namespace TypeSystemPolicy {
   export let AllowNaN: boolean = false
   /** Sets whether `null` should validate for void types. The default is `false` */
   export let AllowNullVoid: boolean = false
-  /** Asserts this value using the ExactOptionalPropertyTypes policy */
+  /** Checks this value using the ExactOptionalPropertyTypes policy */
   export function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string) {
     return ExactOptionalPropertyTypes ? key in value : value[key] !== undefined
   }
-  /** Asserts this value using the AllowArrayObjects policy */
+  /** Checks this value using the AllowArrayObjects policy */
   export function IsObjectLike(value: unknown): value is Record<keyof any, unknown> {
     const isObject = IsObject(value)
     return AllowArrayObject ? isObject : isObject && !IsArray(value)
   }
-  /** Asserts this value as a record using the AllowArrayObjects policy */
+  /** Checks this value as a record using the AllowArrayObjects policy */
   export function IsRecordLike(value: unknown): value is Record<keyof any, unknown> {
     return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array)
   }
-  /** Asserts this value using the AllowNaN policy */
+  /** Checks this value using the AllowNaN policy */
   export function IsNumberLike(value: unknown): value is number {
     return AllowNaN ? IsNumber(value) : Number.isFinite(value)
   }
-  /** Asserts this value using the AllowVoidNull policy */
+  /** Checks this value using the AllowVoidNull policy */
   export function IsVoidLike(value: unknown): value is void {
     const isUndefined = IsUndefined(value)
     return AllowNullVoid ? isUndefined || value === null : isUndefined
diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index e493e2444..5342320ed 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -55,6 +55,12 @@ import type { TUndefined } from '../../type/undefined/index'
 // ValueGuard
 // ------------------------------------------------------------------
 import { IsArray, IsObject, IsDate, IsUndefined, IsString, IsNumber, IsBoolean, IsBigInt, IsSymbol, HasPropertyKey } from '../guard/index'
+
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsOptional } from '../../type/guard/kind'
+
 // ------------------------------------------------------------------
 // Conversions
 // ------------------------------------------------------------------
@@ -193,8 +199,9 @@ function FromNumber(schema: TNumber, references: TSchema[], value: any): unknown
 // prettier-ignore
 function FromObject(schema: TObject, references: TSchema[], value: any): unknown {
   if(!IsObject(value)) return value
-  for(const key of Object.getOwnPropertyNames(schema.properties)) {
-    value[key] = Visit(schema.properties[key], references, value[key])
+  for(const propertyKey of Object.getOwnPropertyNames(schema.properties)) {
+    if(!HasPropertyKey(value, propertyKey)) continue
+    value[propertyKey] = Visit(schema.properties[propertyKey], references, value[propertyKey])
   }
   return value
 }
diff --git a/src/value/transform/decode.ts b/src/value/transform/decode.ts
index a713c62a5..5bac20ecf 100644
--- a/src/value/transform/decode.ts
+++ b/src/value/transform/decode.ts
@@ -26,11 +26,11 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { TypeSystemPolicy } from '../../system/policy'
 import { Kind, TransformKind } from '../../type/symbols/index'
 import { TypeBoxError } from '../../type/error/index'
 import { ValueError } from '../../errors/index'
 import { KeyOfPropertyKeys, KeyOfPropertyEntries } from '../../type/keyof/index'
-import { Index } from '../../type/indexed/index'
 import { Deref } from '../deref/index'
 import { Check } from '../check/index'
 
@@ -48,11 +48,11 @@ import type { TUnion } from '../../type/union/index'
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsObject, IsArray, IsValueType } from '../guard/index'
+import { HasPropertyKey, IsObject, IsArray, IsValueType, IsUndefined as IsUndefinedValue } from '../guard/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsTransform, IsSchema } from '../../type/guard/type'
+import { IsTransform, IsSchema, IsUndefined } from '../../type/guard/type'
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -121,9 +121,18 @@ function FromNot(schema: TNot, references: TSchema[], path: string, value: any)
 // prettier-ignore
 function FromObject(schema: TObject, references: TSchema[], path: string, value: any) {
   if (!IsObject(value)) return Default(schema, path, value)
-  const knownKeys = KeyOfPropertyKeys(schema)
+  const knownKeys = KeyOfPropertyKeys(schema) as string[]
   const knownProperties = { ...value } as Record<PropertyKey, unknown>
-  for(const key of knownKeys) if(key in knownProperties) {
+  for(const key of knownKeys) {
+    if(!HasPropertyKey(knownProperties, key)) continue
+    // if the property value is undefined, but the target is not, nor does it satisfy exact optional 
+    // property policy, then we need to continue. This is a special case for optional property handling 
+    // where a transforms wrapped in a optional modifiers should not run.
+    if(IsUndefinedValue(knownProperties[key]) && (
+      !IsUndefined(schema.properties[key]) ||
+      TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)
+    )) continue
+    // decode property
     knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key])
   }
   if (!IsSchema(schema.additionalProperties)) {
diff --git a/src/value/transform/encode.ts b/src/value/transform/encode.ts
index 2d857b7bd..365f91edd 100644
--- a/src/value/transform/encode.ts
+++ b/src/value/transform/encode.ts
@@ -26,11 +26,11 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { TypeSystemPolicy } from '../../system/policy'
 import { Kind, TransformKind } from '../../type/symbols/index'
 import { TypeBoxError } from '../../type/error/index'
 import { ValueError } from '../../errors/index'
 import { KeyOfPropertyKeys, KeyOfPropertyEntries } from '../../type/keyof/index'
-import { Index } from '../../type/indexed/index'
 import { Deref } from '../deref/index'
 import { Check } from '../check/index'
 
@@ -48,11 +48,11 @@ import type { TUnion } from '../../type/union/index'
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsObject, IsArray, IsValueType } from '../guard/index'
+import { HasPropertyKey, IsObject, IsArray, IsValueType, IsUndefined as IsUndefinedValue } from '../guard/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsTransform, IsSchema } from '../../type/guard/type'
+import { IsTransform, IsSchema, IsUndefined } from '../../type/guard/type'
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -126,7 +126,16 @@ function FromObject(schema: TObject, references: TSchema[], path: string, value:
   if (!IsObject(defaulted)) return defaulted
   const knownKeys = KeyOfPropertyKeys(schema) as string[]
   const knownProperties = { ...defaulted } as Record<PropertyKey, unknown>
-  for(const key of knownKeys) if(key in knownProperties) {
+  for(const key of knownKeys) {
+    if(!HasPropertyKey(knownProperties, key)) continue
+    // if the property value is undefined, but the target is not, nor does it satisfy exact optional 
+    // property policy, then we need to continue. This is a special case for optional property handling 
+    // where a transforms wrapped in a optional modifiers should not run.
+    if(IsUndefinedValue(knownProperties[key]) && (
+      !IsUndefined(schema.properties[key]) ||
+      TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)
+    )) continue
+    // encode property
     knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key])
   }
   if (!IsSchema(schema.additionalProperties)) {
diff --git a/test/runtime/value/convert/object.ts b/test/runtime/value/convert/object.ts
index 042c05647..69a8564be 100644
--- a/test/runtime/value/convert/object.ts
+++ b/test/runtime/value/convert/object.ts
@@ -21,4 +21,9 @@ describe('value/convert/Object', () => {
     const R = Value.Convert(T, { x: '42', y: 'true', z: 'hello' })
     Assert.IsEqual(R, { x: 42, y: true, z: 'hello' })
   })
+  it('Should not convert missing properties', () => {
+    const T = Type.Object({ x: Type.Number() })
+    const R = Value.Convert(T, { })
+    Assert.IsEqual(R, { })
+  })
 })
diff --git a/test/runtime/value/transform/object.ts b/test/runtime/value/transform/object.ts
index 9425e4de6..8580201ef 100644
--- a/test/runtime/value/transform/object.ts
+++ b/test/runtime/value/transform/object.ts
@@ -1,5 +1,7 @@
 import * as Encoder from './_encoder'
 import { Assert } from '../../assert'
+
+import { TypeSystemPolicy } from '@sinclair/typebox/system'
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
 
@@ -156,7 +158,7 @@ describe('value/transform/Object', () => {
   // https://github.com/sinclairzx81/typebox/issues/859
   // ----------------------------------------------------------------
   it('Should decode for nested transform with renamed property', () => {
-    class User { constructor(public name: string, public createdAt: Date) {} }
+    class User { constructor(public name: string, public createdAt: Date) { } }
     const TDate = Type.Transform(Type.Number())
       .Decode(v => new Date(v))
       .Encode(v => v.getTime())
@@ -185,7 +187,116 @@ describe('value/transform/Object', () => {
     const B = Object.create(null); B.x = '1'
     const D = Value.Decode(T, A)
     const E = Value.Encode(T, B)
-    Assert.IsEqual(D, { x: '1' })    
+    Assert.IsEqual(D, { x: '1' })
     Assert.IsEqual(E, { x: 1 })
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/958
+  // ----------------------------------------------------------------
+  it('Should not decode missing optional properties 0', () => {
+    let Invoked = false
+    const S = Type.Transform(Type.RegExp(/foo/))
+      .Decode((value) => { Invoked = true; return value })
+      .Encode((value) => value)
+    const T = Type.Object({ value: Type.Optional(S) })
+    const D = Value.Decode(T, { value: 'foo' })
+    Assert.IsEqual(D, { value: 'foo' })
+    Assert.IsTrue(Invoked)
+  })
+  it('Should not decode missing optional properties 1', () => {
+    let Invoked = false
+    const S = Type.Transform(Type.RegExp(/foo/))
+      .Decode((value) => { Invoked = true; return value })
+      .Encode((value) => value)
+    const T = Type.Object({ value: Type.Optional(S) })
+    const D = Value.Decode(T, {})
+    Assert.IsEqual(D, {})
+    Assert.IsFalse(Invoked)
+  })
+  it('Should not decode missing optional properties 2', () => {
+    let Invoked = false
+    const S = Type.Transform(Type.RegExp(/foo/))
+      .Decode((value) => { Invoked = true; return value })
+      .Encode((value) => value)
+    const T = Type.Object({ value: Type.Optional(S) })
+    const D = Value.Decode(T, { value: undefined })
+    Assert.IsEqual(D, { value: undefined })
+    Assert.IsFalse(Invoked)
+  })
+  it('Should not decode missing optional properties 3 (ExactOptionalPropertyTypes)', () => {
+    let [Invoked, Revert] = [false, TypeSystemPolicy.ExactOptionalPropertyTypes]
+    TypeSystemPolicy.ExactOptionalPropertyTypes = true
+    const S = Type.Transform(Type.RegExp(/foo/))
+      .Decode((value) => { Invoked = true; return value })
+      .Encode((value) => value)
+    const T = Type.Object({ value: Type.Optional(S) })
+    const D = Value.Decode(T, {})
+    Assert.IsEqual(D, {})
+    Assert.IsFalse(Invoked)
+    TypeSystemPolicy.ExactOptionalPropertyTypes = Revert
+  })
+  it('Should not decode missing optional properties 4 (ExactOptionalPropertyTypes)', () => {
+    let [Invoked, Revert] = [false, TypeSystemPolicy.ExactOptionalPropertyTypes]
+    TypeSystemPolicy.ExactOptionalPropertyTypes = true
+    const S = Type.Transform(Type.RegExp(/foo/))
+      .Decode((value) => { Invoked = true; return value })
+      .Encode((value) => value)
+    const T = Type.Object({ value: Type.Optional(S) })
+    Assert.Throws(() => Value.Decode(T, { value: undefined }))
+    Assert.IsFalse(Invoked)
+    TypeSystemPolicy.ExactOptionalPropertyTypes = Revert
+  })
+  it('Should not encode missing optional properties 0', () => {
+    let Invoked = false
+    const S = Type.Transform(Type.RegExp(/foo/))
+      .Decode((value) => value)
+      .Encode((value) => { Invoked = true; return value })
+    const T = Type.Object({ value: Type.Optional(S) })
+    const D = Value.Encode(T, { value: 'foo' })
+    Assert.IsEqual(D, { value: 'foo' })
+    Assert.IsTrue(Invoked)
+  })
+  it('Should not encode missing optional properties 1', () => {
+    let Invoked = false
+    const S = Type.Transform(Type.RegExp(/foo/))
+      .Decode((value) => value)
+      .Encode((value) => { Invoked = true; return value })
+    const T = Type.Object({ value: Type.Optional(S) })
+    const D = Value.Encode(T, {})
+    Assert.IsEqual(D, {})
+    Assert.IsFalse(Invoked)
+  })
+  it('Should not encode missing optional properties 2', () => {
+    let Invoked = false
+    const S = Type.Transform(Type.RegExp(/foo/))
+      .Decode((value) => value)
+      .Encode((value) => { Invoked = true; return value })
+    const T = Type.Object({ value: Type.Optional(S) })
+    const D = Value.Encode(T, { value: undefined })
+    Assert.IsEqual(D, { value: undefined })
+    Assert.IsFalse(Invoked)
+  })
+  it('Should not encode missing optional properties 3 (ExactOptionalPropertyTypes)', () => {
+    let [Invoked, Revert] = [false, TypeSystemPolicy.ExactOptionalPropertyTypes]
+    TypeSystemPolicy.ExactOptionalPropertyTypes = true
+    const S = Type.Transform(Type.RegExp(/foo/))
+      .Decode((value) => value)
+      .Encode((value) => { Invoked = true; return value })
+    const T = Type.Object({ value: Type.Optional(S) })
+    const D = Value.Encode(T, {})
+    Assert.IsEqual(D, {})
+    Assert.IsFalse(Invoked)
+    TypeSystemPolicy.ExactOptionalPropertyTypes = Revert
+  })
+  it('Should not encode missing optional properties 4 (ExactOptionalPropertyTypes)', () => {
+    let [Invoked, Revert] = [false, TypeSystemPolicy.ExactOptionalPropertyTypes]
+    TypeSystemPolicy.ExactOptionalPropertyTypes = true
+    const S = Type.Transform(Type.RegExp(/foo/))
+      .Decode((value) => value)
+      .Encode((value) => { Invoked = true; return value })
+    const T = Type.Object({ value: Type.Optional(S) })
+    Assert.Throws(() => Value.Encode(T, { value: undefined }))
+    Assert.IsFalse(Invoked)
+    TypeSystemPolicy.ExactOptionalPropertyTypes = Revert
+  })
 })

From 6da8b3fbc44844ab0a4d144bc6750e230f838fc2 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 15 Aug 2024 05:15:01 +0900
Subject: [PATCH 273/369] Revision 0.33.6 (#963)

* Traverse Instanced Object Values Inside Default

* Version
---
 package-lock.json                    |  4 ++--
 package.json                         |  2 +-
 src/value/default/default.ts         | 13 ++++++++-----
 test/runtime/value/default/object.ts | 19 +++++++++++++++++++
 4 files changed, 30 insertions(+), 8 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index b5b0fad33..aa7cef85b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.5",
+  "version": "0.33.6",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.5",
+      "version": "0.33.6",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 8e8477db3..299a5e2dd 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.5",
+  "version": "0.33.6",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/default/default.ts b/src/value/default/default.ts
index 6c2d64709..abda4cdd4 100644
--- a/src/value/default/default.ts
+++ b/src/value/default/default.ts
@@ -82,19 +82,22 @@ function FromIntersect(schema: TIntersect, references: TSchema[], value: unknown
 function FromObject(schema: TObject, references: TSchema[], value: unknown): any {
   const defaulted = ValueOrDefault(schema, value)
   if (!IsObject(defaulted)) return defaulted
-  const additionalPropertiesSchema = schema.additionalProperties as TSchema
   const knownPropertyKeys = Object.getOwnPropertyNames(schema.properties)
   // properties
   for (const key of knownPropertyKeys) {
-    if (!HasDefaultProperty(schema.properties[key])) continue
-    defaulted[key] = Visit(schema.properties[key], references, defaulted[key])
+    // note: we need to traverse into the object and test if the return value
+    // yielded a non undefined result. Here we interpret an undefined result as
+    // a non assignable property and continue.
+    const propertyValue = Visit(schema.properties[key], references, defaulted[key])
+    if (IsUndefined(propertyValue)) continue
+    defaulted[key] = propertyValue
   }
   // return if not additional properties
-  if (!HasDefaultProperty(additionalPropertiesSchema)) return defaulted
+  if (!HasDefaultProperty(schema.additionalProperties)) return defaulted
   // additional properties
   for (const key of Object.getOwnPropertyNames(defaulted)) {
     if (knownPropertyKeys.includes(key)) continue
-    defaulted[key] = Visit(additionalPropertiesSchema, references, defaulted[key])
+    defaulted[key] = Visit(schema.additionalProperties, references, defaulted[key])
   }
   return defaulted
 }
diff --git a/test/runtime/value/default/object.ts b/test/runtime/value/default/object.ts
index 1accf40ee..ddfad94a6 100644
--- a/test/runtime/value/default/object.ts
+++ b/test/runtime/value/default/object.ts
@@ -209,4 +209,23 @@ describe('value/default/Object', () => {
     Value.Default(A, {})
     Assert.IsEqual(A, B)
   })
+  // ----------------------------------------------------------------
+  // Traveral: https://github.com/sinclairzx81/typebox/issues/962
+  // ----------------------------------------------------------------
+  it('Should traverse into an object 1 (initialize)', () => {
+    const Child = Type.Object({ a: Type.String({ default: 'x' }) })
+    const Parent = Type.Object({ child: Child })
+    Assert.IsEqual(Value.Default(Child, {}), { a: 'x' })
+    Assert.IsEqual(Value.Default(Parent, { child: {} }), { child: { a: 'x' } })
+  })
+  it('Should traverse into an object 2 (retain)', () => {
+    const Child = Type.Object({ a: Type.String({ default: 'x' }) })
+    const Parent = Type.Object({ child: Child })
+    Assert.IsEqual(Value.Default(Parent, { child: { a: 1 } }), { child: { a: 1 } })
+  })
+  it('Should traverse into an object 3 (ignore on undefined)', () => {
+    const Child = Type.Object({ a: Type.String({ default: 'x' }) })
+    const Parent = Type.Object({ child: Child })
+    Assert.IsEqual(Value.Default(Parent, { child: undefined }), { child: undefined })
+  })
 })

From 8b503f613ac2153d8aae41c4ae2f08650e2e5fc7 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 15 Aug 2024 14:28:12 +0900
Subject: [PATCH 274/369] Revision 0.33.7 (#964)

* Additional Improvements to Object Default

* Version
---
 package-lock.json                    |  4 +--
 package.json                         |  2 +-
 src/value/default/default.ts         | 10 +++---
 test/runtime/value/default/object.ts | 48 ++++++++++++++++++++++------
 4 files changed, 47 insertions(+), 17 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index aa7cef85b..86b31daf8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.6",
+  "version": "0.33.7",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.6",
+      "version": "0.33.7",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 299a5e2dd..aae8d9de3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.6",
+  "version": "0.33.7",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/default/default.ts b/src/value/default/default.ts
index abda4cdd4..27b05f555 100644
--- a/src/value/default/default.ts
+++ b/src/value/default/default.ts
@@ -44,7 +44,7 @@ import type { TUnion } from '../../type/union/index'
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsString, IsObject, IsArray, IsUndefined } from '../guard/index'
+import { IsString, IsObject, IsArray, IsUndefined, HasPropertyKey } from '../guard/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -52,8 +52,9 @@ import { IsKind } from '../../type/guard/kind'
 // ------------------------------------------------------------------
 // ValueOrDefault
 // ------------------------------------------------------------------
-function ValueOrDefault(schema: TSchema, value: unknown) {
-  return value === undefined && 'default' in schema ? Clone(schema.default) : value
+function ValueOrDefault(schema: TSchema, value: unknown): unknown {
+  const clone = HasPropertyKey(schema, 'default') ? Clone(schema.default) : undefined
+  return IsUndefined(value) ? clone : IsObject(value) && IsObject(clone) ? Object.assign(clone, value) : value
 }
 // ------------------------------------------------------------------
 // HasDefaultProperty
@@ -81,6 +82,7 @@ function FromIntersect(schema: TIntersect, references: TSchema[], value: unknown
 }
 function FromObject(schema: TObject, references: TSchema[], value: unknown): any {
   const defaulted = ValueOrDefault(schema, value)
+  // return defaulted
   if (!IsObject(defaulted)) return defaulted
   const knownPropertyKeys = Object.getOwnPropertyNames(schema.properties)
   // properties
@@ -90,7 +92,7 @@ function FromObject(schema: TObject, references: TSchema[], value: unknown): any
     // a non assignable property and continue.
     const propertyValue = Visit(schema.properties[key], references, defaulted[key])
     if (IsUndefined(propertyValue)) continue
-    defaulted[key] = propertyValue
+    defaulted[key] = Visit(schema.properties[key], references, defaulted[key])
   }
   // return if not additional properties
   if (!HasDefaultProperty(schema.additionalProperties)) return defaulted
diff --git a/test/runtime/value/default/object.ts b/test/runtime/value/default/object.ts
index ddfad94a6..86a7df19f 100644
--- a/test/runtime/value/default/object.ts
+++ b/test/runtime/value/default/object.ts
@@ -213,19 +213,47 @@ describe('value/default/Object', () => {
   // Traveral: https://github.com/sinclairzx81/typebox/issues/962
   // ----------------------------------------------------------------
   it('Should traverse into an object 1 (initialize)', () => {
-    const Child = Type.Object({ a: Type.String({ default: 'x' }) })
-    const Parent = Type.Object({ child: Child })
-    Assert.IsEqual(Value.Default(Child, {}), { a: 'x' })
-    Assert.IsEqual(Value.Default(Parent, { child: {} }), { child: { a: 'x' } })
+    const Y = Type.Object({ y: Type.String({ default: 'y' }) })
+    const X = Type.Object({ x: Y })
+    Assert.IsEqual(Value.Default(Y, {}), { y: 'y' })
+    Assert.IsEqual(Value.Default(X, { x: {} }), { x: { y: 'y' } })
   })
   it('Should traverse into an object 2 (retain)', () => {
-    const Child = Type.Object({ a: Type.String({ default: 'x' }) })
-    const Parent = Type.Object({ child: Child })
-    Assert.IsEqual(Value.Default(Parent, { child: { a: 1 } }), { child: { a: 1 } })
+    const Y = Type.Object({ y: Type.String({ default: 'y' }) })
+    const X = Type.Object({ x: Y })
+    Assert.IsEqual(Value.Default(X, { x: { y: 1 } }), { x: { y: 1 } })
   })
   it('Should traverse into an object 3 (ignore on undefined)', () => {
-    const Child = Type.Object({ a: Type.String({ default: 'x' }) })
-    const Parent = Type.Object({ child: Child })
-    Assert.IsEqual(Value.Default(Parent, { child: undefined }), { child: undefined })
+    const Y = Type.Object({ y: Type.String({ default: 'y' }) })
+    const X = Type.Object({ x: Y })
+    Assert.IsEqual(Value.Default(X, { x: undefined }), { x: undefined })
+  })
+  // ----------------------------------------------------------------
+  // Exterior Object Defaults
+  // ----------------------------------------------------------------
+  it('Should default exterior into an object 1', () => {
+    const X = Type.Object({ x: Type.String({ default: 1 }) }, { default: {} })
+    const R = Value.Default(X, undefined)
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should default exterior into an object 2', () => {
+    const X = Type.Object({ x: Type.String({ default: 1 }) }, { default: {} })
+    const R = Value.Default(X, {})
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should default exterior into an object 3', () => {
+    const X = Type.Object({ x: Type.String({ default: 1 }) }, { default: {} })
+    const R = Value.Default(X, { y: 3 })
+    Assert.IsEqual(R, { y: 3, x: 1 })
+  })
+  it('Should default exterior into an object 4', () => {
+    const X = Type.Object({ x: Type.String({ default: 1 }) }, { default: {} })
+    const R = Value.Default(X, { y: 3, x: 7 })
+    Assert.IsEqual(R, { y: 3, x: 7 })
+  })
+  it('Should default exterior into an object 5', () => {
+    const X = Type.Object({ x: Type.String({ default: 1 }) }, { default: {} })
+    const R = Value.Default(X, { x: 2 })
+    Assert.IsEqual(R, { x: 2 })
   })
 })

From 1aee5c0863943369c0fc07e7b9c8744c15f077ba Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 28 Aug 2024 20:28:41 +0900
Subject: [PATCH 275/369] ChangeLog (#973)

* Add Latest ChangeLog for 0.32.0 and 0.33.0
---
 changelog/latest.md | 100 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 100 insertions(+)
 create mode 100644 changelog/latest.md

diff --git a/changelog/latest.md b/changelog/latest.md
new file mode 100644
index 000000000..29fc5f990
--- /dev/null
+++ b/changelog/latest.md
@@ -0,0 +1,100 @@
+### 0.33.0
+
+- [Revision 0.33.7](https://github.com/sinclairzx81/typebox/pull/964) Additional updates to improve Default for enumerable objects.
+- [Revision 0.33.6](https://github.com/sinclairzx81/typebox/pull/963) Add object traversal path for Default. Ensure enumerable objects are traversed.
+- [Revision 0.33.5](https://github.com/sinclairzx81/typebox/pull/959) Provide better support for transforming properties with optional modifiers. 
+- [Revision 0.33.4](https://github.com/sinclairzx81/typebox/pull/953) Add Assert and Parse value functions. Add defacto AssertError type.
+- [Revision 0.33.3](https://github.com/sinclairzx81/typebox/pull/950) Optimize Value Diff algorithm. Update edit sequence to INSERT, UPDATE then DELETE.
+- [Revision 0.33.2](https://github.com/sinclairzx81/typebox/pull/947) Ensure user defined schema options are retained on mapping types, Pick, Omit and Mapped.
+- [Revision 0.33.1](https://github.com/sinclairzx81/typebox/pull/945) Apply mutability fix for Intrinsic and Not schematics (inline with Default)
+- [Revision 0.33.0](https://github.com/sinclairzx81/typebox/pull/941) Add InstanceMode to enable Clone, Freeze and Default schema initialization options. Optimize for Default.
+
+### 0.32.0
+
+- [Revision 0.32.35](https://github.com/sinclairzx81/typebox/pull/914) Support Any for Record keys, Revert error message on required property, Fix order dependency for Union Convert.
+- [Revision 0.32.34](https://github.com/sinclairzx81/typebox/pull/914) Fix template literal generation for template literals embedded within template literals.
+- [Revision 0.32.33](https://github.com/sinclairzx81/typebox/pull/905) Pin ESM compiler target to ES2020. 
+- [Revision 0.32.32](https://github.com/sinclairzx81/typebox/pull/898) Fix for Enum properties when used with Mapped types.
+- [Revision 0.32.31](https://github.com/sinclairzx81/typebox/pull/881) Fix for Cast. Dereference Union variants before scoring.
+- [Revision 0.32.30](https://github.com/sinclairzx81/typebox/pull/868) Support null object prototypes for Encode/Decode.
+- [Revision 0.32.29](https://github.com/sinclairzx81/typebox/pull/862) Key derive optimization to improve Intersect Encode/Decode performance.
+- [Revision 0.32.28](https://github.com/sinclairzx81/typebox/pull/861) Fix for TransformEncode introduced with 0.32.24, 0.32.25 optimizations.
+- [Revision 0.32.27](https://github.com/sinclairzx81/typebox/pull/854) Support for esm.sh and general build tooling updates.
+- [Revision 0.32.26](https://github.com/sinclairzx81/typebox/pull/851) Optimization for number checks, use Number.isFinite(x) over typeof `number`.
+- [Revision 0.32.25](https://github.com/sinclairzx81/typebox/pull/849) Optimizations for type builder to improve schema creation performance for computed types.
+- [Revision 0.32.24](https://github.com/sinclairzx81/typebox/pull/848) Optimizations for Convert to avoid unnecessary object initialization and cloning.
+- [Revision 0.32.22](https://github.com/sinclairzx81/typebox/pull/840) Add Support for Optional and Readonly Function and Constructor Arguments.
+- [Revision 0.32.21](https://github.com/sinclairzx81/typebox/pull/836) Refactor Array Conversion logic. Discard TNever on TComposite.
+- [Revision 0.32.20](https://github.com/sinclairzx81/typebox/pull/810) Fix compiler regression (TS 5.3.3 -> 5.4.2) generating Diff declaration structures.
+- [Revision 0.32.19](https://github.com/sinclairzx81/typebox/pull/805) Revert Union Convert logic added on 0.32.16.
+- [Revision 0.32.18](https://github.com/sinclairzx81/typebox/pull/801) Add explicit return type on TypeSystem.Type.
+- [Revision 0.32.17](https://github.com/sinclairzx81/typebox/pull/799) Detect ambiguous inference for StaticDecode when inferring as any.
+- [Revision 0.32.16](https://github.com/sinclairzx81/typebox/pull/791) Enhance Composite, Mapped, Indexed and Transform types. Intersect and Union Convert updates, Include Path in Validation Error.
+- [Revision 0.32.15](https://github.com/sinclairzx81/typebox/pull/774) Additional internal guards for Type Arrays, Map and Set structures.
+- [Revision 0.32.14](https://github.com/sinclairzx81/typebox/pull/753) Use barrel exports for submodules.
+- [Revision 0.32.13](https://github.com/sinclairzx81/typebox/pull/744) Add minLength and maxLength constraint for RegExp
+- [Revision 0.32.12](https://github.com/sinclairzx81/typebox/pull/740) Fix option assignment on Record types.
+- [Revision 0.32.11](https://github.com/sinclairzx81/typebox/pull/738) Optimize Extract, Exclude. Overloads for Template Literal
+- [Revision 0.32.10](https://github.com/sinclairzx81/typebox/pull/734) Export additional type infrastructure for Partial and Required
+- [Revision 0.32.9](https://github.com/sinclairzx81/typebox/pull/731) Generalize Composite to accept schematics of type TSchema[]
+- [Revision 0.32.8](https://github.com/sinclairzx81/typebox/pull/728) Ensure schema `default` annotation is cloned on Create.
+- [Revision 0.32.7](https://github.com/sinclairzx81/typebox/pull/727) Ensure schema `default` annotation is cloned on Default.
+- [Revision 0.32.6](https://github.com/sinclairzx81/typebox/pull/724) Export additional type infrastructure for mapping types
+- [Revision 0.32.5](https://github.com/sinclairzx81/typebox/pull/718) Update licence year span for 2024
+- [Revision 0.32.4](https://github.com/sinclairzx81/typebox/pull/708) Ensure ErrorFunctionParameter type is exported
+- [Revision 0.32.3](https://github.com/sinclairzx81/typebox/pull/703) Simplify Record Static Type
+- [Revision 0.32.1](https://github.com/sinclairzx81/typebox/pull/701) Specify default exports for Web Pack
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

From ed4c89a9ab0372e4b8f82c88b788380bb290fdbe Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 3 Sep 2024 04:28:33 +0900
Subject: [PATCH 276/369] Revision 0.33.8 (#983)

* Prevent Intersect Transform Encode callback from being called twice

* Make strict the Encode and Decode return type

* Support default annotation being assigned Functions for lazy value initialization on Create

*  Enable Mapping types to override user defined options from source type

* Support Constraint Copy for Pick, Omit (inline with Partial / Required) (Trialing Implementation)

* Flag Strict For Deprecation
---
 changelog/0.32.0.md                      |  39 +++++++++
 changelog/0.33.0.md                      |  26 ++++++
 changelog/latest.md                      | 100 -----------------------
 package-lock.json                        |   4 +-
 package.json                             |   2 +-
 readme.md                                |  30 -------
 src/compiler/compiler.ts                 |   4 +-
 src/type/object/object.ts                |   2 +-
 src/type/omit/omit.ts                    |  38 ++++++---
 src/type/partial/partial.ts              |  35 +++++---
 src/type/pick/pick.ts                    |  36 +++++---
 src/type/required/required.ts            |  30 +++++--
 src/type/strict/strict.ts                |  14 +++-
 src/type/type/json.ts                    |  32 +++++---
 src/type/type/type.ts                    |   2 +-
 src/value/create/create.ts               |   4 +-
 src/value/default/default.ts             |   5 +-
 src/value/transform/encode.ts            |   2 +-
 src/value/value/value.ts                 |   8 +-
 test/runtime/compiler-ajv/pick.ts        |   1 +
 test/runtime/compiler-ajv/required.ts    |   1 +
 test/runtime/compiler/omit.ts            |  19 ++---
 test/runtime/compiler/pick.ts            |  35 ++++----
 test/runtime/compiler/required.ts        |   1 +
 test/runtime/type/guard/type/omit.ts     |   9 ++
 test/runtime/type/guard/type/partial.ts  |   9 ++
 test/runtime/type/guard/type/pick.ts     |   9 ++
 test/runtime/type/guard/type/required.ts |   9 ++
 test/runtime/value/create/_deferred.ts   |  11 +++
 test/runtime/value/create/constructor.ts |  11 +--
 test/runtime/value/create/function.ts    |   2 +-
 test/runtime/value/create/index.ts       |   1 +
 test/runtime/value/default/_deferred.ts  |  11 +++
 test/runtime/value/default/index.ts      |   1 +
 test/static/index.ts                     |   1 -
 test/static/strict.ts                    |  20 -----
 36 files changed, 307 insertions(+), 257 deletions(-)
 create mode 100644 changelog/0.33.0.md
 delete mode 100644 changelog/latest.md
 create mode 100644 test/runtime/value/create/_deferred.ts
 create mode 100644 test/runtime/value/default/_deferred.ts
 delete mode 100644 test/static/strict.ts

diff --git a/changelog/0.32.0.md b/changelog/0.32.0.md
index 83a1bddfc..e2609e3bd 100644
--- a/changelog/0.32.0.md
+++ b/changelog/0.32.0.md
@@ -1,3 +1,42 @@
+
+
+### 0.32.0
+
+- [Revision 0.32.35](https://github.com/sinclairzx81/typebox/pull/914) Support Any for Record keys, Revert error message on required property, Fix order dependency for Union Convert.
+- [Revision 0.32.34](https://github.com/sinclairzx81/typebox/pull/914) Fix template literal generation for template literals embedded within template literals.
+- [Revision 0.32.33](https://github.com/sinclairzx81/typebox/pull/905) Pin ESM compiler target to ES2020. 
+- [Revision 0.32.32](https://github.com/sinclairzx81/typebox/pull/898) Fix for Enum properties when used with Mapped types.
+- [Revision 0.32.31](https://github.com/sinclairzx81/typebox/pull/881) Fix for Cast. Dereference Union variants before scoring.
+- [Revision 0.32.30](https://github.com/sinclairzx81/typebox/pull/868) Support null object prototypes for Encode/Decode.
+- [Revision 0.32.29](https://github.com/sinclairzx81/typebox/pull/862) Key derive optimization to improve Intersect Encode/Decode performance.
+- [Revision 0.32.28](https://github.com/sinclairzx81/typebox/pull/861) Fix for TransformEncode introduced with 0.32.24, 0.32.25 optimizations.
+- [Revision 0.32.27](https://github.com/sinclairzx81/typebox/pull/854) Support for esm.sh and general build tooling updates.
+- [Revision 0.32.26](https://github.com/sinclairzx81/typebox/pull/851) Optimization for number checks, use Number.isFinite(x) over typeof `number`.
+- [Revision 0.32.25](https://github.com/sinclairzx81/typebox/pull/849) Optimizations for type builder to improve schema creation performance for computed types.
+- [Revision 0.32.24](https://github.com/sinclairzx81/typebox/pull/848) Optimizations for Convert to avoid unnecessary object initialization and cloning.
+- [Revision 0.32.22](https://github.com/sinclairzx81/typebox/pull/840) Add Support for Optional and Readonly Function and Constructor Arguments.
+- [Revision 0.32.21](https://github.com/sinclairzx81/typebox/pull/836) Refactor Array Conversion logic. Discard TNever on TComposite.
+- [Revision 0.32.20](https://github.com/sinclairzx81/typebox/pull/810) Fix compiler regression (TS 5.3.3 -> 5.4.2) generating Diff declaration structures.
+- [Revision 0.32.19](https://github.com/sinclairzx81/typebox/pull/805) Revert Union Convert logic added on 0.32.16.
+- [Revision 0.32.18](https://github.com/sinclairzx81/typebox/pull/801) Add explicit return type on TypeSystem.Type.
+- [Revision 0.32.17](https://github.com/sinclairzx81/typebox/pull/799) Detect ambiguous inference for StaticDecode when inferring as any.
+- [Revision 0.32.16](https://github.com/sinclairzx81/typebox/pull/791) Enhance Composite, Mapped, Indexed and Transform types. Intersect and Union Convert updates, Include Path in Validation Error.
+- [Revision 0.32.15](https://github.com/sinclairzx81/typebox/pull/774) Additional internal guards for Type Arrays, Map and Set structures.
+- [Revision 0.32.14](https://github.com/sinclairzx81/typebox/pull/753) Use barrel exports for submodules.
+- [Revision 0.32.13](https://github.com/sinclairzx81/typebox/pull/744) Add minLength and maxLength constraint for RegExp
+- [Revision 0.32.12](https://github.com/sinclairzx81/typebox/pull/740) Fix option assignment on Record types.
+- [Revision 0.32.11](https://github.com/sinclairzx81/typebox/pull/738) Optimize Extract, Exclude. Overloads for Template Literal
+- [Revision 0.32.10](https://github.com/sinclairzx81/typebox/pull/734) Export additional type infrastructure for Partial and Required
+- [Revision 0.32.9](https://github.com/sinclairzx81/typebox/pull/731) Generalize Composite to accept schematics of type TSchema[]
+- [Revision 0.32.8](https://github.com/sinclairzx81/typebox/pull/728) Ensure schema `default` annotation is cloned on Create.
+- [Revision 0.32.7](https://github.com/sinclairzx81/typebox/pull/727) Ensure schema `default` annotation is cloned on Default.
+- [Revision 0.32.6](https://github.com/sinclairzx81/typebox/pull/724) Export additional type infrastructure for mapping types
+- [Revision 0.32.5](https://github.com/sinclairzx81/typebox/pull/718) Update licence year span for 2024
+- [Revision 0.32.4](https://github.com/sinclairzx81/typebox/pull/708) Ensure ErrorFunctionParameter type is exported
+- [Revision 0.32.3](https://github.com/sinclairzx81/typebox/pull/703) Simplify Record Static Type
+- [Revision 0.32.1](https://github.com/sinclairzx81/typebox/pull/701) Specify default exports for Web Pack
+
+
 ## [0.32.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.32.0)
 
 ## Overview
diff --git a/changelog/0.33.0.md b/changelog/0.33.0.md
new file mode 100644
index 000000000..991172793
--- /dev/null
+++ b/changelog/0.33.0.md
@@ -0,0 +1,26 @@
+### 0.33.0
+
+- [Revision 0.33.8](https://github.com/sinclairzx81/typebox/pull/983) 
+  - [982](https://github.com/sinclairzx81/typebox/issues/982) Prevent Intersect Transform Encode callback from being called twice
+  - [974](https://github.com/sinclairzx81/typebox/issues/974) Make strict the Encode and Decode return type
+  - [975](https://github.com/sinclairzx81/typebox/issues/975) Support default annotation being assigned Functions for lazy value initialization on Create
+  - [980](https://github.com/sinclairzx81/typebox/issues/980) Enable Mapping types to override user defined options from source type
+  - [976](https://github.com/sinclairzx81/typebox/issues/976) Support Constraint Copy for Pick, Omit (inline with Partial / Required) (Trialing Implementation)
+  - Flag Strict For Deprecation
+- [Revision 0.33.7](https://github.com/sinclairzx81/typebox/pull/964) 
+  - Additional updates to improve Default for enumerable objects.
+- [Revision 0.33.6](https://github.com/sinclairzx81/typebox/pull/963) 
+  - Add object traversal path for Default. Ensure enumerable objects are traversed.
+- [Revision 0.33.5](https://github.com/sinclairzx81/typebox/pull/959) 
+  - Provide better support for transforming properties with optional modifiers. 
+- [Revision 0.33.4](https://github.com/sinclairzx81/typebox/pull/953) 
+  - Add Assert and Parse value functions. Add defacto AssertError type.
+- [Revision 0.33.3](https://github.com/sinclairzx81/typebox/pull/950) 
+  - Optimize Value Diff algorithm. Update edit sequence to INSERT, UPDATE then DELETE.
+- [Revision 0.33.2](https://github.com/sinclairzx81/typebox/pull/947) 
+  - Ensure user defined schema options are retained on mapping types, Pick, Omit and Mapped.
+- [Revision 0.33.1](https://github.com/sinclairzx81/typebox/pull/945) 
+  - Apply mutability fix for Intrinsic and Not schematics (inline with Default)
+- [Revision 0.33.0](https://github.com/sinclairzx81/typebox/pull/941) 
+  - Add InstanceMode to enable Clone, Freeze and Default schema initialization options. Optimize for Default.
+
diff --git a/changelog/latest.md b/changelog/latest.md
deleted file mode 100644
index 29fc5f990..000000000
--- a/changelog/latest.md
+++ /dev/null
@@ -1,100 +0,0 @@
-### 0.33.0
-
-- [Revision 0.33.7](https://github.com/sinclairzx81/typebox/pull/964) Additional updates to improve Default for enumerable objects.
-- [Revision 0.33.6](https://github.com/sinclairzx81/typebox/pull/963) Add object traversal path for Default. Ensure enumerable objects are traversed.
-- [Revision 0.33.5](https://github.com/sinclairzx81/typebox/pull/959) Provide better support for transforming properties with optional modifiers. 
-- [Revision 0.33.4](https://github.com/sinclairzx81/typebox/pull/953) Add Assert and Parse value functions. Add defacto AssertError type.
-- [Revision 0.33.3](https://github.com/sinclairzx81/typebox/pull/950) Optimize Value Diff algorithm. Update edit sequence to INSERT, UPDATE then DELETE.
-- [Revision 0.33.2](https://github.com/sinclairzx81/typebox/pull/947) Ensure user defined schema options are retained on mapping types, Pick, Omit and Mapped.
-- [Revision 0.33.1](https://github.com/sinclairzx81/typebox/pull/945) Apply mutability fix for Intrinsic and Not schematics (inline with Default)
-- [Revision 0.33.0](https://github.com/sinclairzx81/typebox/pull/941) Add InstanceMode to enable Clone, Freeze and Default schema initialization options. Optimize for Default.
-
-### 0.32.0
-
-- [Revision 0.32.35](https://github.com/sinclairzx81/typebox/pull/914) Support Any for Record keys, Revert error message on required property, Fix order dependency for Union Convert.
-- [Revision 0.32.34](https://github.com/sinclairzx81/typebox/pull/914) Fix template literal generation for template literals embedded within template literals.
-- [Revision 0.32.33](https://github.com/sinclairzx81/typebox/pull/905) Pin ESM compiler target to ES2020. 
-- [Revision 0.32.32](https://github.com/sinclairzx81/typebox/pull/898) Fix for Enum properties when used with Mapped types.
-- [Revision 0.32.31](https://github.com/sinclairzx81/typebox/pull/881) Fix for Cast. Dereference Union variants before scoring.
-- [Revision 0.32.30](https://github.com/sinclairzx81/typebox/pull/868) Support null object prototypes for Encode/Decode.
-- [Revision 0.32.29](https://github.com/sinclairzx81/typebox/pull/862) Key derive optimization to improve Intersect Encode/Decode performance.
-- [Revision 0.32.28](https://github.com/sinclairzx81/typebox/pull/861) Fix for TransformEncode introduced with 0.32.24, 0.32.25 optimizations.
-- [Revision 0.32.27](https://github.com/sinclairzx81/typebox/pull/854) Support for esm.sh and general build tooling updates.
-- [Revision 0.32.26](https://github.com/sinclairzx81/typebox/pull/851) Optimization for number checks, use Number.isFinite(x) over typeof `number`.
-- [Revision 0.32.25](https://github.com/sinclairzx81/typebox/pull/849) Optimizations for type builder to improve schema creation performance for computed types.
-- [Revision 0.32.24](https://github.com/sinclairzx81/typebox/pull/848) Optimizations for Convert to avoid unnecessary object initialization and cloning.
-- [Revision 0.32.22](https://github.com/sinclairzx81/typebox/pull/840) Add Support for Optional and Readonly Function and Constructor Arguments.
-- [Revision 0.32.21](https://github.com/sinclairzx81/typebox/pull/836) Refactor Array Conversion logic. Discard TNever on TComposite.
-- [Revision 0.32.20](https://github.com/sinclairzx81/typebox/pull/810) Fix compiler regression (TS 5.3.3 -> 5.4.2) generating Diff declaration structures.
-- [Revision 0.32.19](https://github.com/sinclairzx81/typebox/pull/805) Revert Union Convert logic added on 0.32.16.
-- [Revision 0.32.18](https://github.com/sinclairzx81/typebox/pull/801) Add explicit return type on TypeSystem.Type.
-- [Revision 0.32.17](https://github.com/sinclairzx81/typebox/pull/799) Detect ambiguous inference for StaticDecode when inferring as any.
-- [Revision 0.32.16](https://github.com/sinclairzx81/typebox/pull/791) Enhance Composite, Mapped, Indexed and Transform types. Intersect and Union Convert updates, Include Path in Validation Error.
-- [Revision 0.32.15](https://github.com/sinclairzx81/typebox/pull/774) Additional internal guards for Type Arrays, Map and Set structures.
-- [Revision 0.32.14](https://github.com/sinclairzx81/typebox/pull/753) Use barrel exports for submodules.
-- [Revision 0.32.13](https://github.com/sinclairzx81/typebox/pull/744) Add minLength and maxLength constraint for RegExp
-- [Revision 0.32.12](https://github.com/sinclairzx81/typebox/pull/740) Fix option assignment on Record types.
-- [Revision 0.32.11](https://github.com/sinclairzx81/typebox/pull/738) Optimize Extract, Exclude. Overloads for Template Literal
-- [Revision 0.32.10](https://github.com/sinclairzx81/typebox/pull/734) Export additional type infrastructure for Partial and Required
-- [Revision 0.32.9](https://github.com/sinclairzx81/typebox/pull/731) Generalize Composite to accept schematics of type TSchema[]
-- [Revision 0.32.8](https://github.com/sinclairzx81/typebox/pull/728) Ensure schema `default` annotation is cloned on Create.
-- [Revision 0.32.7](https://github.com/sinclairzx81/typebox/pull/727) Ensure schema `default` annotation is cloned on Default.
-- [Revision 0.32.6](https://github.com/sinclairzx81/typebox/pull/724) Export additional type infrastructure for mapping types
-- [Revision 0.32.5](https://github.com/sinclairzx81/typebox/pull/718) Update licence year span for 2024
-- [Revision 0.32.4](https://github.com/sinclairzx81/typebox/pull/708) Ensure ErrorFunctionParameter type is exported
-- [Revision 0.32.3](https://github.com/sinclairzx81/typebox/pull/703) Simplify Record Static Type
-- [Revision 0.32.1](https://github.com/sinclairzx81/typebox/pull/701) Specify default exports for Web Pack
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/package-lock.json b/package-lock.json
index 86b31daf8..2bdb89d64 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.7",
+  "version": "0.33.8",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.7",
+      "version": "0.33.8",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index aae8d9de3..2d0f7a39b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.7",
+  "version": "0.33.8",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index b79458c44..ea7d87557 100644
--- a/readme.md
+++ b/readme.md
@@ -77,7 +77,6 @@ License MIT
   - [Transform](#types-transform)
   - [Guard](#types-guard)
   - [Unsafe](#types-unsafe)
-  - [Strict](#types-strict)
 - [Values](#values)
   - [Assert](#values-assert)
   - [Create](#values-create)
@@ -1078,35 +1077,6 @@ if(TypeGuard.IsString(T)) {
 }
 ```
 
-<a name='types-strict'></a>
-
-### Strict
-
-TypeBox types contain various symbol properties that are used for reflection, composition and compilation. These properties are not strictly valid Json Schema; so in some cases it may be desirable to omit them. TypeBox provides a `Strict` function that will omit these properties if necessary.
-
-```typescript
-const T = Type.Object({                              // const T = {
-  name: Type.Optional(Type.String())                 //   [Symbol(TypeBox.Kind)]: 'Object',
-})                                                   //   type: 'object',
-                                                     //   properties: {
-                                                     //     name: {
-                                                     //       type: 'string',
-                                                     //       [Symbol(TypeBox.Kind)]: 'String',
-                                                     //       [Symbol(TypeBox.Optional)]: 'Optional'
-                                                     //     }
-                                                     //   }
-                                                     // }
-
-const U = Type.Strict(T)                             // const U = {
-                                                     //   type: 'object',
-                                                     //   properties: {
-                                                     //     name: {
-                                                     //       type: 'string'
-                                                     //     }
-                                                     //   }
-                                                     // }
-```
-
 <a name='values'></a>
 
 ## Values
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index f41203479..bc1fd8b4d 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -105,12 +105,12 @@ export class TypeCheck<T extends TSchema> {
     return this.checkFunc(value)
   }
   /** Decodes a value or throws if error */
-  public Decode<R = StaticDecode<T>>(value: unknown): R {
+  public Decode<Static = StaticDecode<T>, Result extends Static = Static>(value: unknown): Result {
     if (!this.checkFunc(value)) throw new TransformDecodeCheckError(this.schema, value, this.Errors(value).First()!)
     return (this.hasTransform ? TransformDecode(this.schema, this.references, value) : value) as never
   }
   /** Encodes a value or throws if error */
-  public Encode<R = StaticEncode<T>>(value: unknown): R {
+  public Encode<Static = StaticDecode<T>, Result extends Static = Static>(value: unknown): Result {
     const encoded = this.hasTransform ? TransformEncode(this.schema, this.references, value) : value
     if (!this.checkFunc(encoded)) throw new TransformEncodeCheckError(this.schema, value, this.Errors(value).First()!)
     return encoded as never
diff --git a/src/type/object/object.ts b/src/type/object/object.ts
index 18d1559b2..c8f2bb06f 100644
--- a/src/type/object/object.ts
+++ b/src/type/object/object.ts
@@ -37,7 +37,7 @@ import { Kind } from '../symbols/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsOptional, IsSchema } from '../guard/kind'
+import { IsOptional } from '../guard/kind'
 
 // ------------------------------------------------------------------
 // ObjectStatic
diff --git a/src/type/omit/omit.ts b/src/type/omit/omit.ts
index 60de12989..99a947706 100644
--- a/src/type/omit/omit.ts
+++ b/src/type/omit/omit.ts
@@ -27,19 +27,18 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { CreateType } from '../create/type'
-import type { TSchema, SchemaOptions } from '../schema/index'
-import type { TupleToUnion, Evaluate } from '../helpers/index'
+import { Discard } from '../discard/discard'
+import type { SchemaOptions, TSchema } from '../schema/index'
+import type { TupleToUnion, Evaluate, Ensure } from '../helpers/index'
 import { type TRecursive } from '../recursive/index'
 import type { TMappedKey, TMappedResult } from '../mapped/index'
 import { Intersect, type TIntersect } from '../intersect/index'
 import { Union, type TUnion } from '../union/index'
 import { Object, type TObject, type TProperties } from '../object/index'
 import { IndexPropertyKeys, type TIndexPropertyKeys } from '../indexed/index'
-import { Discard } from '../discard/index'
-import { TransformKind } from '../symbols/index'
 import { OmitFromMappedKey, type TOmitFromMappedKey } from './omit-from-mapped-key'
 import { OmitFromMappedResult, type TOmitFromMappedResult } from './omit-from-mapped-result'
-
+import { TransformKind } from '../symbols/symbols'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -86,6 +85,19 @@ function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K:
   return K.reduce((T, K2) => FromProperty(T, K2), T as TProperties)
 }
 // ------------------------------------------------------------------
+// FromObject
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromObject<T extends TObject, K extends PropertyKey[], Properties extends TProperties = T['properties']> = Ensure<TObject<(
+  TFromProperties<Properties, K>
+)>>
+// prettier-ignore
+function FromObject<T extends TObject, K extends PropertyKey[]>(T: T, K: K): TFromObject<T, K> {
+  const options = Discard(T, [TransformKind, '$id', 'required', 'properties'])
+  const properties = FromProperties(T['properties'], K)
+  return Object(properties, options) as never
+}
+// ------------------------------------------------------------------
 // OmitResolve
 // ------------------------------------------------------------------
 // prettier-ignore
@@ -93,17 +105,18 @@ function OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]
   return (
     IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) : 
     IsUnion(T) ? Union(FromUnion(T.anyOf, K)) : 
-    IsObject(T) ? Object(FromProperties(T.properties, K), Discard(T, [TransformKind, '$id', 'required'])) : 
+    IsObject(T) ? FromObject(T, K) : 
     Object({})
   ) as never
 }
 // prettier-ignore
-export type TOmit<T extends TProperties, K extends PropertyKey[]> = 
-  T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> : 
-  T extends TIntersect<infer S> ? TIntersect<TFromIntersect<S, K>> : 
-  T extends TUnion<infer S> ? TUnion<TFromUnion<S, K>> : 
-  T extends TObject<infer S> ? TObject<TFromProperties<S, K>> : 
+export type TOmit<T extends TProperties, K extends PropertyKey[]> = (
+  T extends TRecursive<infer S extends TSchema> ? TRecursive<TOmit<S, K>> : 
+  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromIntersect<S, K>> : 
+  T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromUnion<S, K>> : 
+  T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>, K> : 
   TObject<{}>
+)
 // ------------------------------------------------------------------
 // TOmit
 // ------------------------------------------------------------------
@@ -121,5 +134,6 @@ export function Omit(T: TSchema, K: any, options?: SchemaOptions): any {
   if (IsMappedResult(T)) return OmitFromMappedResult(T, K, options)
   // non-mapped
   const I = IsSchema(K) ? IndexPropertyKeys(K) : (K as string[])
-  return CreateType(OmitResolve(T, I), options)
+  // special: mapping types require overridable options
+  return CreateType({ ...OmitResolve(T, I), ...options })
 }
diff --git a/src/type/partial/partial.ts b/src/type/partial/partial.ts
index a2382b281..21bd5cf3e 100644
--- a/src/type/partial/partial.ts
+++ b/src/type/partial/partial.ts
@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
-import type { Evaluate } from '../helpers/index'
+import type { Evaluate, Ensure } from '../helpers/index'
 import type { TMappedResult } from '../mapped/index'
 import { type TReadonlyOptional } from '../readonly-optional/index'
 import { type TOptional, Optional } from '../optional/index'
@@ -77,6 +77,19 @@ function FromProperties<T extends TProperties>(T: T): TFromProperties<T> {
   return Acc as never
 }
 // ------------------------------------------------------------------
+// FromObject
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromObject<T extends TObject, Properties extends TProperties = T['properties']> = Ensure<TObject<(
+  TFromProperties<Properties>
+)>>
+// prettier-ignore
+function FromObject<T extends TObject>(T: T): TFromObject<T> {
+  const options = Discard(T, [TransformKind, '$id', 'required', 'properties'])
+  const properties = FromProperties(T['properties'])
+  return Object(properties, options) as never
+}
+// ------------------------------------------------------------------
 // PartialResolve
 // ------------------------------------------------------------------
 // prettier-ignore
@@ -84,7 +97,7 @@ function PartialResolve<T extends TSchema>(T: T): TPartial<T> {
   return (
     IsIntersect(T) ? Intersect(FromRest(T.allOf)) :
     IsUnion(T) ? Union(FromRest(T.anyOf)) :
-    IsObject(T) ? Object(FromProperties(T.properties)) :
+    IsObject(T) ? FromObject(T) :
     Object({})
   ) as never
 }
@@ -93,10 +106,10 @@ function PartialResolve<T extends TSchema>(T: T): TPartial<T> {
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TPartial<T extends TSchema> = (
-  T extends TRecursive<infer S> ? TRecursive<TPartial<S>> :
-  T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> :
-  T extends TUnion<infer S> ? TUnion<TFromRest<S>> :
-  T extends TObject<infer S> ? TObject<TFromProperties<S>> :
+  T extends TRecursive<infer S extends TSchema> ? TRecursive<TPartial<S>> :
+  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> :
+  T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> :
+  T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>> :
   TObject<{}>
 )
 /** `[Json]` Constructs a type where all properties are optional */
@@ -105,8 +118,10 @@ export function Partial<T extends TMappedResult>(T: T, options?: SchemaOptions):
 export function Partial<T extends TSchema>(T: T, options?: SchemaOptions): TPartial<T>
 /** `[Json]` Constructs a type where all properties are optional */
 export function Partial(T: TSchema, options?: SchemaOptions): any {
-  if (IsMappedResult(T)) return PartialFromMappedResult(T, options)
-  const D = Discard(T, [TransformKind, '$id', 'required']) as TSchema
-  const R = PartialResolve(T)
-  return CreateType({ ...options, ...D, ...R }) as never
+  if (IsMappedResult(T)) {
+    return PartialFromMappedResult(T, options)
+  } else {
+    // special: mapping types require overridable options
+    return CreateType({ ...PartialResolve(T), ...options })
+  }
 }
diff --git a/src/type/pick/pick.ts b/src/type/pick/pick.ts
index 5340a4674..bde1e17f0 100644
--- a/src/type/pick/pick.ts
+++ b/src/type/pick/pick.ts
@@ -27,18 +27,18 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { CreateType } from '../create/type'
+import { Discard } from '../discard/discard'
 import type { TSchema, SchemaOptions } from '../schema/index'
-import type { TupleToUnion, Evaluate } from '../helpers/index'
+import type { TupleToUnion, Evaluate, Ensure } from '../helpers/index'
 import { type TRecursive } from '../recursive/index'
 import { type TIntersect, Intersect } from '../intersect/index'
 import { type TUnion, Union } from '../union/index'
 import { type TObject, type TProperties, type TPropertyKey, Object } from '../object/index'
 import type { TMappedKey, TMappedResult } from '../mapped/index'
 import { IndexPropertyKeys, type TIndexPropertyKeys } from '../indexed/index'
-import { Discard } from '../discard/index'
-import { TransformKind } from '../symbols/index'
 import { PickFromMappedKey, type TPickFromMappedKey } from './pick-from-mapped-key'
 import { PickFromMappedResult, type TPickFromMappedResult } from './pick-from-mapped-result'
+import { TransformKind } from '../symbols/symbols'
 
 // ------------------------------------------------------------------
 // TypeGuard
@@ -71,14 +71,27 @@ function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K) {
 // FromProperties
 // ------------------------------------------------------------------
 // prettier-ignore
-type FromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Pick<T, I & keyof T>>
+type TFromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Pick<T, I & keyof T>>
 // prettier-ignore
-function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K) {
+function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K): TFromProperties <T, K> {
   const Acc = {} as TProperties
   for(const K2 of K) if(K2 in T) Acc[K2 as TPropertyKey] = T[K2 as keyof T]
   return Acc as never
 }
 // ------------------------------------------------------------------
+// FromObject
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromObject<T extends TObject, K extends PropertyKey[], Properties extends TProperties = T['properties']> = Ensure<TObject<(
+  TFromProperties<Properties, K>
+)>>
+// prettier-ignore
+function FromObject<T extends TObject, K extends PropertyKey[]>(T: T, K: K): TFromObject<T, K> {
+  const options = Discard(T, [TransformKind, '$id', 'required', 'properties'])
+  const properties = FromProperties(T['properties'], K)
+  return Object(properties, options) as never
+}
+// ------------------------------------------------------------------
 // PickResolve
 // ------------------------------------------------------------------
 // prettier-ignore
@@ -86,16 +99,16 @@ function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]
   return (
     IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) : 
     IsUnion(T) ? Union(FromUnion(T.anyOf, K)) : 
-    IsObject(T) ? Object(FromProperties(T.properties, K), Discard(T, [TransformKind, '$id', 'required'])) :
+    IsObject(T) ? FromObject(T, K) :
     Object({})
   ) as never
 }
 // prettier-ignore
 export type TPick<T extends TProperties, K extends PropertyKey[]> = 
-  T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> : 
-  T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : 
-  T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : 
-  T extends TObject<infer S> ? TObject<FromProperties<S, K>> : 
+  T extends TRecursive<infer S extends TSchema> ? TRecursive<TPick<S, K>> : 
+  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<FromIntersect<S, K>> : 
+  T extends TUnion<infer S  extends TSchema[]> ? TUnion<FromUnion<S, K>> : 
+  T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>, K> : 
   TObject<{}>
 
 /** `[Json]` Constructs a type whose keys are picked from the given type */
@@ -112,5 +125,6 @@ export function Pick(T: TSchema, K: any, options?: SchemaOptions): any {
   if (IsMappedResult(T)) return PickFromMappedResult(T, K, options)
   // non-mapped
   const I = IsSchema(K) ? IndexPropertyKeys(K) : (K as string[])
-  return CreateType(PickResolve(T, I), options)
+  // special: mapping types require overridable options
+  return CreateType({ ...PickResolve(T, I), ...options })
 }
diff --git a/src/type/required/required.ts b/src/type/required/required.ts
index 807fff050..fab0632f2 100644
--- a/src/type/required/required.ts
+++ b/src/type/required/required.ts
@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
-import type { Evaluate } from '../helpers/index'
+import type { Evaluate, Ensure } from '../helpers/index'
 import type { TMappedResult } from '../mapped/index'
 import { type TReadonlyOptional } from '../readonly-optional/index'
 import { type TOptional } from '../optional/index'
@@ -76,6 +76,19 @@ function FromProperties<T extends TProperties>(T: T) {
   return Acc as never
 }
 // ------------------------------------------------------------------
+// FromObject
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromObject<T extends TObject, Properties extends TProperties = T['properties']> = Ensure<TObject<(
+  TFromProperties<Properties>
+)>>
+// prettier-ignore
+function FromObject<T extends TObject>(T: T): TFromObject<T> {
+  const options = Discard(T, [TransformKind, '$id', 'required', 'properties'])
+  const properties = FromProperties(T['properties'])
+  return Object(properties, options) as never
+}
+// ------------------------------------------------------------------
 // RequiredResolve
 // ------------------------------------------------------------------
 
@@ -84,7 +97,7 @@ function RequiredResolve<T extends TSchema>(T: T): TRequired<T> {
   return (
     IsIntersect(T) ? Intersect(FromRest(T.allOf)) :
     IsUnion(T) ?  Union(FromRest(T.anyOf)) :
-    IsObject(T) ? Object(FromProperties(T.properties)) :
+    IsObject(T) ? FromObject(T) :
     Object({})
   ) as never
 }
@@ -93,10 +106,10 @@ function RequiredResolve<T extends TSchema>(T: T): TRequired<T> {
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TRequired<T extends TSchema> = (
-  T extends TRecursive<infer S> ? TRecursive<TRequired<S>> :
-  T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> :
-  T extends TUnion<infer S> ? TUnion<TFromRest<S>> :
-  T extends TObject<infer S> ? TObject<TFromProperties<S>> :
+  T extends TRecursive<infer S extends TSchema> ? TRecursive<TRequired<S>> :
+  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> :
+  T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> :
+  T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>> :
   TObject<{}>
 )
 /** `[Json]` Constructs a type where all properties are required */
@@ -108,8 +121,7 @@ export function Required<T extends TSchema>(T: T, options?: SchemaOptions): neve
   if (IsMappedResult(T)) {
     return RequiredFromMappedResult(T, options) as never
   } else {
-    const D = Discard(T, [TransformKind, '$id', 'required']) as TSchema
-    const R = RequiredResolve(T) as any
-    return CreateType({ ...D, ...R }, options) as never
+    // special: mapping types require overridable options
+    return CreateType({ ...RequiredResolve(T), ...options }) as never
   }
 }
diff --git a/src/type/strict/strict.ts b/src/type/strict/strict.ts
index ddcf88836..96da5a1e1 100644
--- a/src/type/strict/strict.ts
+++ b/src/type/strict/strict.ts
@@ -28,7 +28,17 @@ THE SOFTWARE.
 
 import type { TSchema } from '../schema/index'
 
-/** `[Json]` Omits compositing symbols from this schema. */
-export function Strict<T extends TSchema>(schema: T): T {
+export type TStrict<T extends TSchema> = T
+
+/**
+ * @deprecated `[Json]` Omits compositing symbols from this schema. It is recommended
+ * to use the JSON parse/stringify to remove compositing symbols if needed. This
+ * is how Strict works internally.
+ *
+ * ```typescript
+ * JSON.parse(JSON.stringify(Type.String()))
+ * ```
+ */
+export function Strict<T extends TSchema>(schema: T): TStrict<T> {
   return JSON.parse(JSON.stringify(schema))
 }
diff --git a/src/type/type/json.ts b/src/type/type/json.ts
index f9a1ae741..0650ebc96 100644
--- a/src/type/type/json.ts
+++ b/src/type/type/json.ts
@@ -61,7 +61,7 @@ import { Ref, type TRef } from '../ref/index'
 import { Required, type TRequired, type TRequiredFromMappedResult } from '../required/index'
 import { Rest, type TRest } from '../rest/index'
 import { type TSchema, type SchemaOptions } from '../schema/index'
-import { Strict } from '../strict/index'
+import { Strict, type TStrict } from '../strict/index'
 import { String, type TString, type StringOptions } from '../string/index'
 import { TemplateLiteral, type TTemplateLiteral, type TTemplateLiteralKind, type TTemplateLiteralSyntax } from '../template-literal/index'
 import { Transform, TransformDecodeBuilder } from '../transform/index'
@@ -75,8 +75,16 @@ export class JsonTypeBuilder {
   // ------------------------------------------------------------------------
   // Strict
   // ------------------------------------------------------------------------
-  /** `[Json]` Omits compositing symbols from this schema */
-  public Strict<T extends TSchema>(schema: T): T {
+  /**
+   * @deprecated `[Json]` Omits compositing symbols from this schema. It is recommended
+   * to use the JSON parse/stringify to remove compositing symbols if needed. This
+   * is how Strict works internally.
+   *
+   * ```typescript
+   * JSON.parse(JSON.stringify(Type.String()))
+   * ```
+   */
+  public Strict<T extends TSchema>(schema: T): TStrict<T> {
     return Strict(schema)
   }
   // ------------------------------------------------------------------------
@@ -242,7 +250,7 @@ export class JsonTypeBuilder {
   /** `[Json]` Constructs a type whose keys are omitted from the given type */
   public Omit<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TOmitFromMappedResult<T, K>
   /** `[Json]` Constructs a type whose keys are omitted from the given type */
-  public Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitFromMappedKey<T, K>
+  public Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TOmitFromMappedKey<T, K>
   /** `[Json]` Constructs a type whose keys are omitted from the given type */
   public Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>
   /** `[Json]` Constructs a type whose keys are omitted from the given type */
@@ -252,17 +260,17 @@ export class JsonTypeBuilder {
     return Omit(schema, unresolved, options)
   }
   /** `[Json]` Constructs a type where all properties are optional */
-  public Partial<T extends TMappedResult>(T: T, options?: ObjectOptions): TPartialFromMappedResult<T>
+  public Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>
   /** `[Json]` Constructs a type where all properties are optional */
-  public Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>
+  public Partial<T extends TSchema>(schema: T, options?: SchemaOptions): TPartial<T>
   /** `[Json]` Constructs a type where all properties are optional */
-  public Partial(schema: TSchema, options?: ObjectOptions): any {
+  public Partial(schema: TSchema, options?: SchemaOptions): any {
     return Partial(schema, options)
   }
   /** `[Json]` Constructs a type whose keys are picked from the given type */
-  public Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K]): TPickFromMappedResult<T, K>
+  public Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>
   /** `[Json]` Constructs a type whose keys are picked from the given type */
-  public Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickFromMappedKey<T, K>
+  public Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TPickFromMappedKey<T, K>
   /** `[Json]` Constructs a type whose keys are picked from the given type */
   public Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>
   /** `[Json]` Constructs a type whose keys are picked from the given type */
@@ -288,11 +296,11 @@ export class JsonTypeBuilder {
     return Ref(unresolved as any, options)
   }
   /** `[Json]` Constructs a type where all properties are required */
-  public Required<T extends TMappedResult>(T: T, options?: ObjectOptions): TRequiredFromMappedResult<T>
+  public Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>
   /** `[Json]` Constructs a type where all properties are required */
-  public Required<T extends TSchema>(schema: T, options?: ObjectOptions): TRequired<T>
+  public Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>
   /** `[Json]` Constructs a type where all properties are required */
-  public Required(schema: TSchema, options?: ObjectOptions): any {
+  public Required(schema: TSchema, options?: SchemaOptions): any {
     return Required(schema, options)
   }
   /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
diff --git a/src/type/type/type.ts b/src/type/type/type.ts
index 4f0fc5550..8dd7cc893 100644
--- a/src/type/type/type.ts
+++ b/src/type/type/type.ts
@@ -75,8 +75,8 @@ export { RegExp } from '../regexp/index'
 export { Required } from '../required/index'
 export { Rest } from '../rest/index'
 export { ReturnType } from '../return-type/index'
-export { Strict } from '../strict/index'
 export { String } from '../string/index'
+export { Strict } from '../strict/index'
 export { Symbol } from '../symbol/index'
 export { TemplateLiteral } from '../template-literal/index'
 export { Transform } from '../transform/index'
diff --git a/src/value/create/create.ts b/src/value/create/create.ts
index b46e83761..952c35751 100644
--- a/src/value/create/create.ts
+++ b/src/value/create/create.ts
@@ -70,6 +70,8 @@ import type { TUndefined } from '../../type/undefined/index'
 import type { TUint8Array } from '../../type/uint8array/index'
 import type { TVoid } from '../../type/void/index'
 
+import { IsFunction } from '../guard/guard'
+
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -82,7 +84,7 @@ export class ValueCreateError extends TypeBoxError {
 // Default
 // ------------------------------------------------------------------
 function FromDefault(value: unknown) {
-  return typeof value === 'function' ? value : Clone(value)
+  return IsFunction(value) ? value() : Clone(value)
 }
 // ------------------------------------------------------------------
 // Create
diff --git a/src/value/default/default.ts b/src/value/default/default.ts
index 27b05f555..a29a5a5e7 100644
--- a/src/value/default/default.ts
+++ b/src/value/default/default.ts
@@ -44,7 +44,7 @@ import type { TUnion } from '../../type/union/index'
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsString, IsObject, IsArray, IsUndefined, HasPropertyKey } from '../guard/index'
+import { IsString, IsFunction, IsObject, IsArray, IsUndefined, HasPropertyKey } from '../guard/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -53,7 +53,8 @@ import { IsKind } from '../../type/guard/kind'
 // ValueOrDefault
 // ------------------------------------------------------------------
 function ValueOrDefault(schema: TSchema, value: unknown): unknown {
-  const clone = HasPropertyKey(schema, 'default') ? Clone(schema.default) : undefined
+  const defaultValue = HasPropertyKey(schema, 'default') ? schema.default : undefined
+  const clone = IsFunction(defaultValue) ? defaultValue() : Clone(defaultValue)
   return IsUndefined(value) ? clone : IsObject(value) && IsObject(clone) ? Object.assign(clone, value) : value
 }
 // ------------------------------------------------------------------
diff --git a/src/value/transform/encode.ts b/src/value/transform/encode.ts
index 365f91edd..a39aaa0ea 100644
--- a/src/value/transform/encode.ts
+++ b/src/value/transform/encode.ts
@@ -106,7 +106,7 @@ function FromIntersect(schema: TIntersect, references: TSchema[], path: string,
     knownProperties[knownKey] = Visit(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey])
   }
   if (!IsTransform(schema.unevaluatedProperties)) {
-    return Default(schema, path, knownProperties)
+    return knownProperties
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties)
   const unevaluatedProperties = schema.unevaluatedProperties as TSchema
diff --git a/src/value/value/value.ts b/src/value/value/value.ts
index 347b14a29..9838f89ab 100644
--- a/src/value/value/value.ts
+++ b/src/value/value/value.ts
@@ -98,9 +98,9 @@ export function Clone<T>(value: T): T {
   return CloneValue(value)
 }
 /** Decodes a value or throws if error */
-export function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R
+export function Decode<T extends TSchema, Static = StaticDecode<T>, Result extends Static = Static>(schema: T, references: TSchema[], value: unknown): Result
 /** Decodes a value or throws if error */
-export function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R
+export function Decode<T extends TSchema, Static = StaticDecode<T>, Result extends Static = Static>(schema: T, value: unknown): Result
 /** Decodes a value or throws if error */
 export function Decode(...args: any[]): any {
   const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
@@ -116,9 +116,9 @@ export function Default(...args: any[]): any {
   return DefaultValue.apply(DefaultValue, args as any)
 }
 /** Encodes a value or throws if error */
-export function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, references: TSchema[], value: unknown): R
+export function Encode<T extends TSchema, Static = StaticEncode<T>, Result extends Static = Static>(schema: T, references: TSchema[], value: unknown): Result
 /** Encodes a value or throws if error */
-export function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, value: unknown): R
+export function Encode<T extends TSchema, Static = StaticEncode<T>, Result extends Static = Static>(schema: T, value: unknown): Result
 /** Encodes a value or throws if error */
 export function Encode(...args: any[]): any {
   const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
diff --git a/test/runtime/compiler-ajv/pick.ts b/test/runtime/compiler-ajv/pick.ts
index e9c09c700..c628a1f22 100644
--- a/test/runtime/compiler-ajv/pick.ts
+++ b/test/runtime/compiler-ajv/pick.ts
@@ -52,6 +52,7 @@ describe('compiler-ajv/Pick', () => {
     Assert.IsEqual(A.additionalProperties, false)
     Assert.IsEqual(T.additionalProperties, false)
   })
+
   it('Should pick with keyof object', () => {
     const A = Type.Object({
       x: Type.Number(),
diff --git a/test/runtime/compiler-ajv/required.ts b/test/runtime/compiler-ajv/required.ts
index 73820cfb1..8d1028a27 100644
--- a/test/runtime/compiler-ajv/required.ts
+++ b/test/runtime/compiler-ajv/required.ts
@@ -44,6 +44,7 @@ describe('compiler-ajv/Required', () => {
     Assert.IsEqual(A.additionalPropeties, false)
     Assert.IsEqual(T.additionalPropeties, false)
   })
+
   // it('Should construct new object when targetting reference', () => {
   //   const T = Type.Object({ a: Type.String(), b: Type.String() }, { $id: 'T' })
   //   const R = Type.Ref(T)
diff --git a/test/runtime/compiler/omit.ts b/test/runtime/compiler/omit.ts
index 8ff7b1509..2adf42ed0 100644
--- a/test/runtime/compiler/omit.ts
+++ b/test/runtime/compiler/omit.ts
@@ -28,7 +28,6 @@ describe('compiler/Omit', () => {
     const T = Type.Omit(A, ['z'])
     strictEqual(T.required!.includes('z'), false)
   })
-
   it('Should inherit options from the source object', () => {
     const A = Type.Object(
       {
@@ -42,7 +41,6 @@ describe('compiler/Omit', () => {
     strictEqual(A.additionalProperties, false)
     strictEqual(T.additionalProperties, false)
   })
-
   it('Should omit with keyof object', () => {
     const A = Type.Object({
       x: Type.Number(),
@@ -58,15 +56,14 @@ describe('compiler/Omit', () => {
     Fail(T, { x: 0, y: 0, z: 0 })
   })
   it('Should support Omit of Literal', () => {
-    const A = Type.Object(
-      {
-        x: Type.Number(),
-        y: Type.Number(),
-        z: Type.Number(),
-      },
-      { additionalProperties: false },
-    )
-    const T = Type.Omit(A, Type.Literal('x'))
+    const A = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    const T = Type.Omit(A, Type.Literal('x'), {
+      additionalProperties: false,
+    })
     Ok(T, { y: 1, z: 1 })
     Fail(T, { x: 1, y: 1, z: 1 })
   })
diff --git a/test/runtime/compiler/pick.ts b/test/runtime/compiler/pick.ts
index 227a55b27..59915e257 100644
--- a/test/runtime/compiler/pick.ts
+++ b/test/runtime/compiler/pick.ts
@@ -40,6 +40,7 @@ describe('compiler/Pick', () => {
     strictEqual(A.additionalProperties, false)
     strictEqual(T.additionalProperties, false)
   })
+
   it('Should pick with keyof object', () => {
     const A = Type.Object({
       x: Type.Number(),
@@ -55,28 +56,26 @@ describe('compiler/Pick', () => {
     Fail(T, { x: 0, y: 0, z: 0 })
   })
   it('Should support Pick of Literal', () => {
-    const A = Type.Object(
-      {
-        x: Type.Number(),
-        y: Type.Number(),
-        z: Type.Number(),
-      },
-      { additionalProperties: false },
-    )
-    const T = Type.Pick(A, Type.Literal('x'))
+    const A = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    const T = Type.Pick(A, Type.Literal('x'), {
+      additionalProperties: false,
+    })
     Ok(T, { x: 1 })
     Fail(T, { x: 1, y: 1, z: 1 })
   })
   it('Should support Pick of Never', () => {
-    const A = Type.Object(
-      {
-        x: Type.Number(),
-        y: Type.Number(),
-        z: Type.Number(),
-      },
-      { additionalProperties: false },
-    )
-    const T = Type.Pick(A, Type.Never())
+    const A = Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+      z: Type.Number(),
+    })
+    const T = Type.Pick(A, Type.Never(), {
+      additionalProperties: false,
+    })
     Fail(T, { x: 1, y: 1, z: 1 })
     Ok(T, {})
   })
diff --git a/test/runtime/compiler/required.ts b/test/runtime/compiler/required.ts
index fb071fecc..c94daf975 100644
--- a/test/runtime/compiler/required.ts
+++ b/test/runtime/compiler/required.ts
@@ -44,6 +44,7 @@ describe('compiler/Required', () => {
     strictEqual(A.additionalPropeties, false)
     strictEqual(T.additionalPropeties, false)
   })
+
   // it('Should construct new object when targetting reference', () => {
   //   const T = Type.Object({ a: Type.String(), b: Type.String() }, { $id: 'T' })
   //   const R = Type.Ref(T)
diff --git a/test/runtime/type/guard/type/omit.ts b/test/runtime/type/guard/type/omit.ts
index dbd7e023c..cbfa16109 100644
--- a/test/runtime/type/guard/type/omit.ts
+++ b/test/runtime/type/guard/type/omit.ts
@@ -157,4 +157,13 @@ describe('guard/type/TOmit', () => {
     Assert.IsFalse(T.properties.y.additionalProperties as boolean)
     Assert.IsFalse(T.properties.z.additionalProperties as boolean)
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/980
+  // ----------------------------------------------------------------
+  it('Should override properties in source type', () => {
+    const A = Type.Object({ x: Type.Number() }, { title: 'A' })
+    const B = Type.Omit(A, ['x'], { title: 'B' })
+    Assert.IsEqual(A.title, 'A')
+    Assert.IsEqual(B.title, 'B')
+  })
 })
diff --git a/test/runtime/type/guard/type/partial.ts b/test/runtime/type/guard/type/partial.ts
index 1e5c61512..1fb138d82 100644
--- a/test/runtime/type/guard/type/partial.ts
+++ b/test/runtime/type/guard/type/partial.ts
@@ -64,4 +64,13 @@ describe('guard/type/TPartial', () => {
     const R = Type.Partial(S)
     Assert.IsFalse(TransformKind in R)
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/980
+  // ----------------------------------------------------------------
+  it('Should override properties in source type', () => {
+    const A = Type.Object({ x: Type.Number() }, { title: 'A' })
+    const B = Type.Partial(A, { title: 'B' })
+    Assert.IsEqual(A.title, 'A')
+    Assert.IsEqual(B.title, 'B')
+  })
 })
diff --git a/test/runtime/type/guard/type/pick.ts b/test/runtime/type/guard/type/pick.ts
index cb3c5edff..65153aab7 100644
--- a/test/runtime/type/guard/type/pick.ts
+++ b/test/runtime/type/guard/type/pick.ts
@@ -159,4 +159,13 @@ describe('guard/type/TPick', () => {
     Assert.IsFalse(T.properties.y.additionalProperties as boolean)
     Assert.IsFalse(T.properties.z.additionalProperties as boolean)
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/980
+  // ----------------------------------------------------------------
+  it('Should override properties in source type', () => {
+    const A = Type.Object({ x: Type.Number() }, { title: 'A' })
+    const B = Type.Pick(A, ['x'], { title: 'B' })
+    Assert.IsEqual(A.title, 'A')
+    Assert.IsEqual(B.title, 'B')
+  })
 })
diff --git a/test/runtime/type/guard/type/required.ts b/test/runtime/type/guard/type/required.ts
index 733302b4f..b4baf6dd1 100644
--- a/test/runtime/type/guard/type/required.ts
+++ b/test/runtime/type/guard/type/required.ts
@@ -61,4 +61,13 @@ describe('guard/type/TRequired', () => {
     const R = Type.Required(S)
     Assert.IsFalse(TransformKind in R)
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/980
+  // ----------------------------------------------------------------
+  it('Should override properties in source type', () => {
+    const A = Type.Object({ x: Type.Number() }, { title: 'A' })
+    const B = Type.Required(A, { title: 'B' })
+    Assert.IsEqual(A.title, 'A')
+    Assert.IsEqual(B.title, 'B')
+  })
 })
diff --git a/test/runtime/value/create/_deferred.ts b/test/runtime/value/create/_deferred.ts
new file mode 100644
index 000000000..6b2a86cac
--- /dev/null
+++ b/test/runtime/value/create/_deferred.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Deferred', () => {
+  it('Should use deferred value', () => {
+    const T = Type.Any({ default: () => 1 })
+    const R = Value.Create(T)
+    Assert.IsEqual(R, 1)
+  })
+})
diff --git a/test/runtime/value/create/constructor.ts b/test/runtime/value/create/constructor.ts
index 39c54bdd1..d42dc85c0 100644
--- a/test/runtime/value/create/constructor.ts
+++ b/test/runtime/value/create/constructor.ts
@@ -22,11 +22,12 @@ describe('value/create/Constructor', () => {
         test: Type.Function([], Type.Number({ default: 123 })),
       }),
       {
-        default: class {
-          test() {
-            return 321
-          }
-        },
+        default: () =>
+          class {
+            test() {
+              return 321
+            }
+          },
       },
     )
     const C = Value.Create(T)
diff --git a/test/runtime/value/create/function.ts b/test/runtime/value/create/function.ts
index 0d1c2f1fb..7495bd076 100644
--- a/test/runtime/value/create/function.ts
+++ b/test/runtime/value/create/function.ts
@@ -10,7 +10,7 @@ describe('value/create/Function', () => {
     Assert.IsEqual(R, 123)
   })
   it('Should create default', () => {
-    const T = Type.Function([], Type.Number({ default: 123 }), { default: () => 321 })
+    const T = Type.Function([], Type.Number({ default: 123 }), { default: () => () => 321 })
     const F = Value.Create(T)
     const R = F()
     Assert.IsEqual(R, 321)
diff --git a/test/runtime/value/create/index.ts b/test/runtime/value/create/index.ts
index 7b51cf3bf..222f79342 100644
--- a/test/runtime/value/create/index.ts
+++ b/test/runtime/value/create/index.ts
@@ -1,3 +1,4 @@
+import './_deferred'
 import './any'
 import './array'
 import './async-iterator'
diff --git a/test/runtime/value/default/_deferred.ts b/test/runtime/value/default/_deferred.ts
new file mode 100644
index 000000000..1fc77c567
--- /dev/null
+++ b/test/runtime/value/default/_deferred.ts
@@ -0,0 +1,11 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Deferred', () => {
+  it('Should use deferred value', () => {
+    const T = Type.Any({ default: () => 1 })
+    const R = Value.Default(T, 1)
+    Assert.IsEqual(R, 1)
+  })
+})
diff --git a/test/runtime/value/default/index.ts b/test/runtime/value/default/index.ts
index 7395f9fce..e553311b7 100644
--- a/test/runtime/value/default/index.ts
+++ b/test/runtime/value/default/index.ts
@@ -1,3 +1,4 @@
+import './_deferred'
 import './any'
 import './array'
 import './async-iterator'
diff --git a/test/static/index.ts b/test/static/index.ts
index df90d857c..9012f8682 100644
--- a/test/static/index.ts
+++ b/test/static/index.ts
@@ -44,7 +44,6 @@ import './regexp'
 import './required'
 import './rest'
 import './return-type'
-import './strict'
 import './string'
 import './symbol'
 import './template-literal'
diff --git a/test/static/strict.ts b/test/static/strict.ts
deleted file mode 100644
index a6a0ebcac..000000000
--- a/test/static/strict.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import { Expect } from './assert'
-import { Type, Static } from '@sinclair/typebox'
-
-{
-  const T = Type.Strict(
-    Type.Object({
-      A: Type.String(),
-      B: Type.String(),
-      C: Type.String(),
-    }),
-  )
-
-  type T = Static<typeof T>
-
-  Expect(T).ToStatic<{
-    A: string
-    B: string
-    C: string
-  }>()
-}

From d387b2adb7532d7059d5be9cffe9bb8552d72566 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 3 Sep 2024 07:17:46 +0900
Subject: [PATCH 277/369] Revision 0.33.9 (#984)

* Generate Interior Intersect Errors

* Version

* ChangeLog
---
 changelog/0.33.0.md                    |  3 +-
 package-lock.json                      |  4 +--
 package.json                           |  2 +-
 src/errors/errors.ts                   | 11 +++++---
 test/runtime/errors/types/intersect.ts | 39 +++++++++++++++++++++-----
 5 files changed, 44 insertions(+), 15 deletions(-)

diff --git a/changelog/0.33.0.md b/changelog/0.33.0.md
index 991172793..b098d7e99 100644
--- a/changelog/0.33.0.md
+++ b/changelog/0.33.0.md
@@ -1,5 +1,6 @@
 ### 0.33.0
-
+- [Revision 0.33.9](https://github.com/sinclairzx81/typebox/pull/984)
+  - [887](https://github.com/sinclairzx81/typebox/issues/887) Generate Nested Intersect Errors
 - [Revision 0.33.8](https://github.com/sinclairzx81/typebox/pull/983) 
   - [982](https://github.com/sinclairzx81/typebox/issues/982) Prevent Intersect Transform Encode callback from being called twice
   - [974](https://github.com/sinclairzx81/typebox/issues/974) Make strict the Encode and Decode return type
diff --git a/package-lock.json b/package-lock.json
index 2bdb89d64..9acbb82ae 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.8",
+  "version": "0.33.9",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.8",
+      "version": "0.33.9",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 2d0f7a39b..cdc4759f9 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.8",
+  "version": "0.33.9",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index f81de1a69..edb58a06d 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -312,13 +312,16 @@ function* FromInteger(schema: TInteger, references: TSchema[], path: string, val
   }
 }
 function* FromIntersect(schema: TIntersect, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  let hasError = false
   for (const inner of schema.allOf) {
-    const next = Visit(inner, references, path, value).next()
-    if (!next.done) {
-      yield Create(ValueErrorType.Intersect, schema, path, value)
-      yield next.value
+    for (const error of Visit(inner, references, path, value)) {
+      hasError = true
+      yield error
     }
   }
+  if (hasError) {
+    return yield Create(ValueErrorType.Intersect, schema, path, value)
+  }
   if (schema.unevaluatedProperties === false) {
     const keyCheck = new RegExp(KeyOfPattern(schema))
     for (const valueKey of Object.getOwnPropertyNames(value)) {
diff --git a/test/runtime/errors/types/intersect.ts b/test/runtime/errors/types/intersect.ts
index e45b0dd19..5e1f8f163 100644
--- a/test/runtime/errors/types/intersect.ts
+++ b/test/runtime/errors/types/intersect.ts
@@ -4,21 +4,46 @@ import { Resolve } from './resolve'
 import { Assert } from '../../assert'
 
 describe('errors/type/Intersect', () => {
-  const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
   it('Should pass 0', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
     const R = Resolve(T, { x: 1, y: 1 })
     Assert.IsEqual(R.length, 0)
   })
   it('Should pass 1', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
     const R = Resolve(T, { x: 1 })
-    Assert.IsEqual(R.length, 2)
-    Assert.IsEqual(R[0].type, ValueErrorType.Intersect)
-    Assert.IsEqual(R[1].type, ValueErrorType.ObjectRequiredProperty)
+    Assert.IsEqual(R.length, 3)
+    Assert.IsEqual(R[0].type, ValueErrorType.ObjectRequiredProperty)
+    Assert.IsEqual(R[1].type, ValueErrorType.Number)
+    Assert.IsEqual(R[2].type, ValueErrorType.Intersect)
   })
   it('Should pass 2', () => {
+    const T = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
     const R = Resolve(T, { y: 1 })
-    Assert.IsEqual(R.length, 2)
-    Assert.IsEqual(R[0].type, ValueErrorType.Intersect)
-    Assert.IsEqual(R[1].type, ValueErrorType.ObjectRequiredProperty)
+    Assert.IsEqual(R.length, 3)
+    Assert.IsEqual(R[0].type, ValueErrorType.ObjectRequiredProperty)
+    Assert.IsEqual(R[1].type, ValueErrorType.Number)
+    Assert.IsEqual(R[2].type, ValueErrorType.Intersect)
+  })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/887
+  // ----------------------------------------------------------------
+  it('Should pass 3', () => {
+    const A = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ y: Type.Number() })])
+    const B = Type.Intersect([Type.Object({ x: Type.Number() }), Type.Object({ z: Type.Number() })])
+    const T = Type.Intersect([A, B])
+    const R = Resolve(T, {})
+    Assert.IsEqual(R.length, 11)
+    Assert.IsEqual(R[0].type, ValueErrorType.ObjectRequiredProperty)
+    Assert.IsEqual(R[1].type, ValueErrorType.Number)
+    Assert.IsEqual(R[2].type, ValueErrorType.ObjectRequiredProperty)
+    Assert.IsEqual(R[3].type, ValueErrorType.Number)
+    Assert.IsEqual(R[4].type, ValueErrorType.Intersect)
+    Assert.IsEqual(R[5].type, ValueErrorType.ObjectRequiredProperty)
+    Assert.IsEqual(R[6].type, ValueErrorType.Number)
+    Assert.IsEqual(R[7].type, ValueErrorType.ObjectRequiredProperty)
+    Assert.IsEqual(R[8].type, ValueErrorType.Number)
+    Assert.IsEqual(R[9].type, ValueErrorType.Intersect)
+    Assert.IsEqual(R[10].type, ValueErrorType.Intersect)
   })
 })

From d049293b2302374e747297110f2f897d5b558cfb Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 12 Sep 2024 15:15:18 +0900
Subject: [PATCH 278/369] Revision 0.33.10 (#991)

* Specify Modules with Potential for Side Effects

* Version
---
 package-lock.json                         |  4 ++--
 package.json                              |  2 +-
 task/build/package/create-package-json.ts | 15 ++++++++++++---
 3 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 9acbb82ae..05b92eb87 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.9",
+  "version": "0.33.10",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.9",
+      "version": "0.33.10",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index cdc4759f9..0069f0d80 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.9",
+  "version": "0.33.10",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/task/build/package/create-package-json.ts b/task/build/package/create-package-json.ts
index 4113a763c..3fc0a186e 100644
--- a/task/build/package/create-package-json.ts
+++ b/task/build/package/create-package-json.ts
@@ -91,10 +91,19 @@ function resolveMetadata() {
     repository: packageJson.repository,
     // flagged by socket.dev if not present
     scripts: { test: 'echo test' },
-    // disable auto bundle strategy: see https://github.com/esm-dev/esm.sh#bundling-strategy
-    'esm.sh': { 'bundle': false }, 
     types: "./build/cjs/index.d.ts",
     main: "./build/cjs/index.js",
-    module: "./build/esm/index.mjs"
+    module: "./build/esm/index.mjs",
+    // disable auto bundle strategy: see https://github.com/esm-dev/esm.sh#bundling-strategy
+    'esm.sh': { 'bundle': false }, 
+    // specify modules with potential for side effects
+    'sideEffects': [
+      './build/esm/type/registry/format.mjs',
+      './build/esm/type/registry/type.mjs',
+      './build/esm/type/system/policy.mjs',
+      './build/cjs/type/registry/format.js',
+      './build/cjs/type/registry/type.js',
+      './build/cjs/type/system/policy.js'
+    ]
   }
 }

From a82c224ddcc2efaf0e7a2f681d3327ae243dd432 Mon Sep 17 00:00:00 2001
From: Eric Haynes <ehaynes99@gmail.com>
Date: Sat, 14 Sep 2024 04:05:52 -0400
Subject: [PATCH 279/369] Revision 0.33.11 (#994)

- Avoid mutating if no union value matches (#994)
---
 src/value/default/default.ts        | 3 ++-
 test/runtime/value/default/union.ts | 9 +++++++++
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/value/default/default.ts b/src/value/default/default.ts
index a29a5a5e7..0821d7939 100644
--- a/src/value/default/default.ts
+++ b/src/value/default/default.ts
@@ -142,7 +142,8 @@ function FromTuple(schema: TTuple, references: TSchema[], value: unknown): any {
 function FromUnion(schema: TUnion, references: TSchema[], value: unknown): any {
   const defaulted = ValueOrDefault(schema, value)
   for (const inner of schema.anyOf) {
-    const result = Visit(inner, references, defaulted)
+    const result = Visit(inner, references, Clone(defaulted))
+    
     if (Check(inner, result)) {
       return result
     }
diff --git a/test/runtime/value/default/union.ts b/test/runtime/value/default/union.ts
index e9f4e682e..b7c07ac1f 100644
--- a/test/runtime/value/default/union.ts
+++ b/test/runtime/value/default/union.ts
@@ -82,6 +82,15 @@ describe('value/default/Union', () => {
     const R = Value.Default(T, { x: 3, y: 4 })
     Assert.IsEqual(R, { x: 3, y: 4 })
   })
+  it('Should return the original value if no schemas match', async () => {
+    const T = Type.Union([
+      Type.Tuple([Type.Number(), Type.Number()]),
+      Type.Array(Type.Number()),
+    ])
+    const value = ['hello']
+    const R = Value.Default(T, value)
+    Assert.IsTrue(R === value)
+  })
   // ----------------------------------------------------------------
   // Interior Unsafe
   // ----------------------------------------------------------------

From ddd85e1f78439f9beaa46767f3e85ad0d458410a Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 14 Sep 2024 17:21:12 +0900
Subject: [PATCH 280/369] Revision 0.33.11 (#995)

* Reference Issue on Unit | Formatting

* TypeScript 5.6.2

* Version
---
 hammer.mjs                          |  2 +-
 package-lock.json                   | 18 +++++++++---------
 package.json                        |  4 ++--
 src/value/default/default.ts        |  1 -
 test/runtime/value/default/union.ts | 10 +++++++---
 5 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/hammer.mjs b/hammer.mjs
index 49faf269b..28f7b3d6a 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -32,7 +32,7 @@ export async function benchmark() {
 // Test
 // -------------------------------------------------------------------------------
 export async function test_typescript() {
-  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', '5.4.5', '5.5.2', '5.5.3', 'next', 'latest']) {
+  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', '5.4.5', '5.5.2', '5.5.3', '5.5.4', 'next', 'latest']) {
     await shell(`npm install typescript@${version} --no-save`)
     await test_static()
   }
diff --git a/package-lock.json b/package-lock.json
index 05b92eb87..f084fe304 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.10",
+  "version": "0.33.11",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.10",
+      "version": "0.33.11",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
@@ -17,7 +17,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^10.4.0",
         "prettier": "^2.7.1",
-        "typescript": "^5.5.4"
+        "typescript": "^5.6.2"
       }
     },
     "node_modules/@andrewbranch/untar.js": {
@@ -1576,9 +1576,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.5.4",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.4.tgz",
-      "integrity": "sha512-Mtq29sKDAEYP7aljRgtPOpTvOfbwRWlS6dPRzwjdE+C0R4brX/GUyhHSecbHMFLNBLcJIPt9nl9yG5TZ1weH+Q==",
+      "version": "5.6.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.6.2.tgz",
+      "integrity": "sha512-NW8ByodCSNCwZeghjN3o+JX5OFH0Ojg6sadjEKY4huZ52TqbJTJnDo5+Tw98lSy63NZvi4n+ez5m2u5d4PkZyw==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -2738,9 +2738,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.5.4",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.4.tgz",
-      "integrity": "sha512-Mtq29sKDAEYP7aljRgtPOpTvOfbwRWlS6dPRzwjdE+C0R4brX/GUyhHSecbHMFLNBLcJIPt9nl9yG5TZ1weH+Q==",
+      "version": "5.6.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.6.2.tgz",
+      "integrity": "sha512-NW8ByodCSNCwZeghjN3o+JX5OFH0Ojg6sadjEKY4huZ52TqbJTJnDo5+Tw98lSy63NZvi4n+ez5m2u5d4PkZyw==",
       "dev": true
     },
     "undici-types": {
diff --git a/package.json b/package.json
index 0069f0d80..420747da9 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.10",
+  "version": "0.33.11",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -37,6 +37,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^10.4.0",
     "prettier": "^2.7.1",
-    "typescript": "^5.5.4"
+    "typescript": "^5.6.2"
   }
 }
diff --git a/src/value/default/default.ts b/src/value/default/default.ts
index 0821d7939..d16d9235c 100644
--- a/src/value/default/default.ts
+++ b/src/value/default/default.ts
@@ -143,7 +143,6 @@ function FromUnion(schema: TUnion, references: TSchema[], value: unknown): any {
   const defaulted = ValueOrDefault(schema, value)
   for (const inner of schema.anyOf) {
     const result = Visit(inner, references, Clone(defaulted))
-    
     if (Check(inner, result)) {
       return result
     }
diff --git a/test/runtime/value/default/union.ts b/test/runtime/value/default/union.ts
index b7c07ac1f..15b3512fc 100644
--- a/test/runtime/value/default/union.ts
+++ b/test/runtime/value/default/union.ts
@@ -2,6 +2,7 @@ import { Value } from '@sinclair/typebox/value'
 import { Type, Kind, TypeRegistry } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
+// prettier-ignore
 describe('value/default/Union', () => {
   it('Should use default', () => {
     const T = Type.Union([Type.Number(), Type.String()], { default: 1 })
@@ -82,10 +83,13 @@ describe('value/default/Union', () => {
     const R = Value.Default(T, { x: 3, y: 4 })
     Assert.IsEqual(R, { x: 3, y: 4 })
   })
-  it('Should return the original value if no schemas match', async () => {
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/993
+  // ----------------------------------------------------------------
+  it('Should return the original value if no schemas match (cloned interior variant)', async () => {
     const T = Type.Union([
-      Type.Tuple([Type.Number(), Type.Number()]),
-      Type.Array(Type.Number()),
+      Type.Tuple([Type.Number(), Type.Number()]), 
+      Type.Array(Type.Number())
     ])
     const value = ['hello']
     const R = Value.Default(T, value)

From 928ebd91fc018fbca50b0ce4de48b0ce399503c3 Mon Sep 17 00:00:00 2001
From: Hamish Peebles <hamishpeebles@gmail.com>
Date: Wed, 18 Sep 2024 18:23:59 +0100
Subject: [PATCH 281/369] Revision 0.33.12 (#999)

* Avoid losing precision when converting to bigints

* Use `truncateInteger` rather than `parseInt`

* Simplify
---
 src/value/convert/convert.ts         |  3 ++-
 test/runtime/value/convert/bigint.ts | 20 ++++++++++++++++++++
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index 5342320ed..cddb0cf22 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -119,7 +119,8 @@ function TryConvertBoolean(value: unknown) {
   return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value
 }
 function TryConvertBigInt(value: unknown) {
-  return IsStringNumeric(value) ? BigInt(parseInt(value)) : IsNumber(value) ? BigInt(value | 0) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value
+  const truncateInteger = (value: string) => value.split('.')[0];
+  return IsStringNumeric(value) ? BigInt(truncateInteger(value)) : IsNumber(value) ? BigInt(value | 0) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value
 }
 function TryConvertString(value: unknown) {
   return IsValueToString(value) ? value.toString() : IsSymbol(value) && value.description !== undefined ? value.description.toString() : value
diff --git a/test/runtime/value/convert/bigint.ts b/test/runtime/value/convert/bigint.ts
index c5057ab00..350e7a1f4 100644
--- a/test/runtime/value/convert/bigint.ts
+++ b/test/runtime/value/convert/bigint.ts
@@ -23,6 +23,26 @@ describe('value/convert/BigInt', () => {
     const R = Value.Convert(T, 'false')
     Assert.IsEqual(R, BigInt(0))
   })
+  it('Should convert bigint from string 5', () => {
+    const T = Type.BigInt()
+    const R = Value.Convert(T, '12345678901234567890')
+    Assert.IsEqual(R, BigInt("12345678901234567890"))
+  })
+  it('Should convert bigint from string 6', () => {
+    const T = Type.BigInt()
+    const R = Value.Convert(T, '-12345678901234567890')
+    Assert.IsEqual(R, BigInt("-12345678901234567890"))
+  })
+  it('Should convert bigint from string 7', () => {
+    const T = Type.BigInt()
+    const R = Value.Convert(T, '12345678901234567890.123')
+    Assert.IsEqual(R, BigInt("12345678901234567890"))
+  })
+  it('Should convert bigint from string 8', () => {
+    const T = Type.BigInt()
+    const R = Value.Convert(T, '-12345678901234567890.123')
+    Assert.IsEqual(R, BigInt("-12345678901234567890"))
+  })
   it('Should convert bitint from number 1', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, 1)

From 0ed2071eed41194fb1d333299c85736ef670700c Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 19 Sep 2024 02:39:40 +0900
Subject: [PATCH 282/369] Revision 0.33.12 (#1000)

* Version + Formatting

* ChangeLog
---
 changelog/0.33.0.md                  | 6 ++++++
 package-lock.json                    | 4 ++--
 package.json                         | 2 +-
 src/value/convert/convert.ts         | 2 +-
 test/runtime/value/convert/bigint.ts | 8 ++++----
 5 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/changelog/0.33.0.md b/changelog/0.33.0.md
index b098d7e99..74913d5ec 100644
--- a/changelog/0.33.0.md
+++ b/changelog/0.33.0.md
@@ -1,4 +1,10 @@
 ### 0.33.0
+- [Revision 0.33.12](https://github.com/sinclairzx81/typebox/pull/999) 
+  - [998](https://github.com/sinclairzx81/typebox/issues/998) Avoid losing precision when converting to bigints
+- [Revision 0.33.11](https://github.com/sinclairzx81/typebox/pull/994) 
+  - [993](https://github.com/sinclairzx81/typebox/issues/993) Prevent mutation on union values during Convert
+- [Revision 0.33.10](https://github.com/sinclairzx81/typebox/pull/991) 
+  - [907](https://github.com/sinclairzx81/typebox/issues/907) Add package.json metadata to specify possible side effect modules
 - [Revision 0.33.9](https://github.com/sinclairzx81/typebox/pull/984)
   - [887](https://github.com/sinclairzx81/typebox/issues/887) Generate Nested Intersect Errors
 - [Revision 0.33.8](https://github.com/sinclairzx81/typebox/pull/983) 
diff --git a/package-lock.json b/package-lock.json
index f084fe304..7ee28d5b4 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.11",
+  "version": "0.33.12",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.11",
+      "version": "0.33.12",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 420747da9..062077bbc 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.11",
+  "version": "0.33.12",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index cddb0cf22..46dae1b3f 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -119,7 +119,7 @@ function TryConvertBoolean(value: unknown) {
   return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value
 }
 function TryConvertBigInt(value: unknown) {
-  const truncateInteger = (value: string) => value.split('.')[0];
+  const truncateInteger = (value: string) => value.split('.')[0]
   return IsStringNumeric(value) ? BigInt(truncateInteger(value)) : IsNumber(value) ? BigInt(value | 0) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value
 }
 function TryConvertString(value: unknown) {
diff --git a/test/runtime/value/convert/bigint.ts b/test/runtime/value/convert/bigint.ts
index 350e7a1f4..383e692a6 100644
--- a/test/runtime/value/convert/bigint.ts
+++ b/test/runtime/value/convert/bigint.ts
@@ -26,22 +26,22 @@ describe('value/convert/BigInt', () => {
   it('Should convert bigint from string 5', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, '12345678901234567890')
-    Assert.IsEqual(R, BigInt("12345678901234567890"))
+    Assert.IsEqual(R, BigInt('12345678901234567890'))
   })
   it('Should convert bigint from string 6', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, '-12345678901234567890')
-    Assert.IsEqual(R, BigInt("-12345678901234567890"))
+    Assert.IsEqual(R, BigInt('-12345678901234567890'))
   })
   it('Should convert bigint from string 7', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, '12345678901234567890.123')
-    Assert.IsEqual(R, BigInt("12345678901234567890"))
+    Assert.IsEqual(R, BigInt('12345678901234567890'))
   })
   it('Should convert bigint from string 8', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, '-12345678901234567890.123')
-    Assert.IsEqual(R, BigInt("-12345678901234567890"))
+    Assert.IsEqual(R, BigInt('-12345678901234567890'))
   })
   it('Should convert bitint from number 1', () => {
     const T = Type.BigInt()

From e5d5ec051587510b24fab4e1f8b4146b08ba93a0 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Wed, 2 Oct 2024 22:00:16 +0900
Subject: [PATCH 283/369] Revision 0.33.13 (#1011)

* Correctly Deref Union Variant in Default

* Version

* ChangeLog
---
 changelog/0.33.0.md                     |  2 ++
 package-lock.json                       |  4 +--
 package.json                            |  2 +-
 src/value/convert/convert.ts            |  8 ++----
 src/value/create/create.ts              | 10 ++-----
 src/value/default/default.ts            | 12 +++-----
 src/value/deref/deref.ts                | 14 ++++++++--
 src/value/transform/decode.ts           |  8 ++----
 src/value/transform/encode.ts           |  8 ++----
 src/value/transform/has.ts              | 10 ++-----
 test/runtime/value/default/recursive.ts | 37 ++++++++++++++++++++++++-
 11 files changed, 68 insertions(+), 47 deletions(-)

diff --git a/changelog/0.33.0.md b/changelog/0.33.0.md
index 74913d5ec..71155ab8a 100644
--- a/changelog/0.33.0.md
+++ b/changelog/0.33.0.md
@@ -1,4 +1,6 @@
 ### 0.33.0
+- [Revision 0.33.13](https://github.com/sinclairzx81/typebox/pull/1011)
+  - [1010](https://github.com/sinclairzx81/typebox/pull/1011) Fixes Value.Parse fails with recursive types
 - [Revision 0.33.12](https://github.com/sinclairzx81/typebox/pull/999) 
   - [998](https://github.com/sinclairzx81/typebox/issues/998) Avoid losing precision when converting to bigints
 - [Revision 0.33.11](https://github.com/sinclairzx81/typebox/pull/994) 
diff --git a/package-lock.json b/package-lock.json
index 7ee28d5b4..103ce872d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.12",
+  "version": "0.33.13",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.12",
+      "version": "0.33.13",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 062077bbc..375d8ab30 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.12",
+  "version": "0.33.13",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index 46dae1b3f..92e6c5811 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 import { Clone } from '../clone/index'
 import { Check } from '../check/index'
-import { Deref } from '../deref/index'
+import { Deref, Pushref } from '../deref/index'
 import { Kind } from '../../type/symbols/index'
 
 import type { TSchema } from '../../type/schema/index'
@@ -249,12 +249,8 @@ function FromUnion(schema: TUnion, references: TSchema[], value: any): unknown {
   }
   return value
 }
-function AddReference(references: TSchema[], schema: TSchema): TSchema[] {
-  references.push(schema)
-  return references
-}
 function Visit(schema: TSchema, references: TSchema[], value: any): unknown {
-  const references_ = IsString(schema.$id) ? AddReference(references, schema) : references
+  const references_ = Pushref(schema, references)
   const schema_ = schema as any
   switch (schema[Kind]) {
     case 'Array':
diff --git a/src/value/create/create.ts b/src/value/create/create.ts
index 952c35751..a1c24c578 100644
--- a/src/value/create/create.ts
+++ b/src/value/create/create.ts
@@ -26,10 +26,10 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { HasPropertyKey, IsString } from '../guard/index'
+import { HasPropertyKey } from '../guard/index'
 import { Check } from '../check/index'
 import { Clone } from '../clone/index'
-import { Deref } from '../deref/index'
+import { Deref, Pushref } from '../deref/index'
 import { TemplateLiteralGenerate, IsTemplateLiteralFinite } from '../../type/template-literal/index'
 import { PatternStringExact, PatternNumberExact } from '../../type/patterns/index'
 import { TypeRegistry } from '../../type/registry/index'
@@ -391,12 +391,8 @@ function FromKind(schema: TSchema, references: TSchema[]): any {
     throw new Error('User defined types must specify a default value')
   }
 }
-function AddReference(references: TSchema[], schema: TSchema): TSchema[] {
-  references.push(schema)
-  return references
-}
 function Visit(schema: TSchema, references: TSchema[]): unknown {
-  const references_ = IsString(schema.$id) ? AddReference(references, schema) : references
+  const references_ = Pushref(schema, references)
   const schema_ = schema as any
   switch (schema_[Kind]) {
     case 'Any':
diff --git a/src/value/default/default.ts b/src/value/default/default.ts
index d16d9235c..d12b40338 100644
--- a/src/value/default/default.ts
+++ b/src/value/default/default.ts
@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 import { Check } from '../check/index'
 import { Clone } from '../clone/index'
-import { Deref } from '../deref/index'
+import { Deref, Pushref } from '../deref/index'
 import { Kind } from '../../type/symbols/index'
 
 import type { TSchema } from '../../type/schema/index'
@@ -44,7 +44,7 @@ import type { TUnion } from '../../type/union/index'
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsString, IsFunction, IsObject, IsArray, IsUndefined, HasPropertyKey } from '../guard/index'
+import { IsFunction, IsObject, IsArray, IsUndefined, HasPropertyKey } from '../guard/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -143,18 +143,14 @@ function FromUnion(schema: TUnion, references: TSchema[], value: unknown): any {
   const defaulted = ValueOrDefault(schema, value)
   for (const inner of schema.anyOf) {
     const result = Visit(inner, references, Clone(defaulted))
-    if (Check(inner, result)) {
+    if (Check(inner, references, result)) {
       return result
     }
   }
   return defaulted
 }
-function AddReference(references: TSchema[], schema: TSchema): TSchema[] {
-  references.push(schema)
-  return references
-}
 function Visit(schema: TSchema, references: TSchema[], value: unknown): any {
-  const references_ = IsString(schema.$id) ? AddReference(references, schema) : references
+  const references_ = Pushref(schema, references)
   const schema_ = schema as any
   switch (schema_[Kind]) {
     case 'Array':
diff --git a/src/value/deref/deref.ts b/src/value/deref/deref.ts
index 91a77915c..2f7d594ad 100644
--- a/src/value/deref/deref.ts
+++ b/src/value/deref/deref.ts
@@ -31,10 +31,10 @@ import type { TRef } from '../../type/ref/index'
 import type { TThis } from '../../type/recursive/index'
 import { TypeBoxError } from '../../type/error/index'
 import { Kind } from '../../type/symbols/index'
-
+import { IsString } from '../guard/guard'
 export class TypeDereferenceError extends TypeBoxError {
   constructor(public readonly schema: TRef | TThis) {
-    super(`Unable to dereference schema with $id '${schema.$id}'`)
+    super(`Unable to dereference schema with $id '${schema.$ref}'`)
   }
 }
 function Resolve(schema: TThis | TRef, references: TSchema[]): TSchema {
@@ -42,7 +42,15 @@ function Resolve(schema: TThis | TRef, references: TSchema[]): TSchema {
   if (target === undefined) throw new TypeDereferenceError(schema)
   return Deref(target, references)
 }
-/** Dereferences a schema from the references array or throws if not found */
+
+/** `[Internal]` Pushes a schema onto references if the schema has an $id and does not exist on references */
+export function Pushref(schema: TSchema, references: TSchema[]): TSchema[] {
+  if (!IsString(schema.$id) || references.some((target) => target.$id === schema.$id)) return references
+  references.push(schema)
+  return references
+}
+
+/** `[Internal]` Dereferences a schema from the references array or throws if not found */
 export function Deref(schema: TSchema, references: TSchema[]): TSchema {
   // prettier-ignore
   return (schema[Kind] === 'This' || schema[Kind] === 'Ref') 
diff --git a/src/value/transform/decode.ts b/src/value/transform/decode.ts
index 5bac20ecf..be56d12bc 100644
--- a/src/value/transform/decode.ts
+++ b/src/value/transform/decode.ts
@@ -31,7 +31,7 @@ import { Kind, TransformKind } from '../../type/symbols/index'
 import { TypeBoxError } from '../../type/error/index'
 import { ValueError } from '../../errors/index'
 import { KeyOfPropertyKeys, KeyOfPropertyEntries } from '../../type/keyof/index'
-import { Deref } from '../deref/index'
+import { Deref, Pushref } from '../deref/index'
 import { Check } from '../check/index'
 
 import type { TSchema } from '../../type/schema/index'
@@ -192,13 +192,9 @@ function FromUnion(schema: TUnion, references: TSchema[], path: string, value: a
   }
   return Default(schema, path, value)
 }
-function AddReference(references: TSchema[], schema: TSchema): TSchema[] {
-  references.push(schema)
-  return references
-}
 // prettier-ignore
 function Visit(schema: TSchema, references: TSchema[], path: string, value: any): any {
-  const references_ = typeof schema.$id === 'string' ? AddReference(references, schema) : references
+  const references_ = Pushref(schema, references)
   const schema_ = schema as any
   switch (schema[Kind]) {
     case 'Array':
diff --git a/src/value/transform/encode.ts b/src/value/transform/encode.ts
index a39aaa0ea..cb626f916 100644
--- a/src/value/transform/encode.ts
+++ b/src/value/transform/encode.ts
@@ -31,7 +31,7 @@ import { Kind, TransformKind } from '../../type/symbols/index'
 import { TypeBoxError } from '../../type/error/index'
 import { ValueError } from '../../errors/index'
 import { KeyOfPropertyKeys, KeyOfPropertyEntries } from '../../type/keyof/index'
-import { Deref } from '../deref/index'
+import { Deref, Pushref } from '../deref/index'
 import { Check } from '../check/index'
 
 import type { TSchema } from '../../type/schema/index'
@@ -203,13 +203,9 @@ function FromUnion(schema: TUnion, references: TSchema[], path: string, value: a
   }
   return Default(schema, path, value)
 }
-function AddReference(references: TSchema[], schema: TSchema): TSchema[] {
-  references.push(schema)
-  return references
-}
 // prettier-ignore
 function Visit(schema: TSchema, references: TSchema[], path: string, value: any): any {
-  const references_ = typeof schema.$id === 'string' ? AddReference(references, schema) : references
+  const references_ = Pushref(schema, references)
   const schema_ = schema as any
   switch (schema[Kind]) {
     case 'Array':
diff --git a/src/value/transform/has.ts b/src/value/transform/has.ts
index 27d731554..7481d86a1 100644
--- a/src/value/transform/has.ts
+++ b/src/value/transform/has.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { Deref } from '../deref/index'
+import { Deref, Pushref } from '../deref/index'
 import { Kind } from '../../type/symbols/index'
 
 import type { TSchema } from '../../type/schema/index'
@@ -52,7 +52,7 @@ import { IsTransform, IsSchema } from '../../type/guard/type'
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsString, IsUndefined } from '../guard/index'
+import { IsUndefined } from '../guard/index'
 
 // prettier-ignore
 function FromArray(schema: TArray, references: TSchema[]): boolean {
@@ -120,13 +120,9 @@ function FromTuple(schema: TTuple, references: TSchema[]) {
 function FromUnion(schema: TUnion, references: TSchema[]) {
   return IsTransform(schema) || schema.anyOf.some((schema) => Visit(schema, references))
 }
-function AddReference(references: TSchema[], schema: TSchema): TSchema[] {
-  references.push(schema)
-  return references
-}
 // prettier-ignore
 function Visit(schema: TSchema, references: TSchema[]): boolean {
-  const references_ = IsString(schema.$id) ? AddReference(references, schema) : references
+  const references_ = Pushref(schema, references)
   const schema_ = schema as any
   if (schema.$id && visited.has(schema.$id)) return false
   if (schema.$id) visited.add(schema.$id)
diff --git a/test/runtime/value/default/recursive.ts b/test/runtime/value/default/recursive.ts
index 417727bda..492f92d24 100644
--- a/test/runtime/value/default/recursive.ts
+++ b/test/runtime/value/default/recursive.ts
@@ -1,5 +1,5 @@
 import { Value } from '@sinclair/typebox/value'
-import { Type } from '@sinclair/typebox'
+import { TSchema, Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 // prettier-ignore
@@ -55,4 +55,39 @@ describe('value/default/Recursive', () => {
       id: 1
     })
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/1010
+  // ----------------------------------------------------------------
+  it('Should default Recursive Union', () => {
+    const Binary = <Node extends TSchema>(node: Node) => Type.Object({
+      type: Type.Literal('Binary'),
+      left: node,
+      right: node
+    })
+    const Node = Type.Object({
+      type: Type.Literal('Node'),
+      value: Type.String({ default: 'X' })
+    })
+    const Expr = Type.Recursive(This => Type.Union([Binary(This), Node]))
+    const R = Value.Default(Expr, {
+      type: 'Binary',
+      left: {
+        type: 'Node'
+      },
+      right: {
+        type: 'Node'
+      }
+    })
+    Assert.IsEqual(R, {
+      type: 'Binary',
+      left: {
+        type: 'Node',
+        value: 'X'
+      },
+      right: {
+        type: 'Node',
+        value: 'X'
+      }
+    })
+  })
 })

From 0306823c823930143245e1c62b32a83c0b2b6529 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Thu, 3 Oct 2024 11:47:38 +0900
Subject: [PATCH 284/369] Module Prototype (#1016)

* Add Module Prototype

* Discard Evaluate and Mutual Prototypes

* Update Prototype Readme
---
 example/prototypes/evaluate.ts | 134 --------------------------
 example/prototypes/index.ts    |   2 +-
 example/prototypes/module.ts   | 166 +++++++++++++++++++++++++++++++++
 example/prototypes/mutual.ts   |  48 ----------
 example/prototypes/readme.md   |  70 +++++++-------
 5 files changed, 201 insertions(+), 219 deletions(-)
 delete mode 100644 example/prototypes/evaluate.ts
 create mode 100644 example/prototypes/module.ts
 delete mode 100644 example/prototypes/mutual.ts

diff --git a/example/prototypes/evaluate.ts b/example/prototypes/evaluate.ts
deleted file mode 100644
index 460d86773..000000000
--- a/example/prototypes/evaluate.ts
+++ /dev/null
@@ -1,134 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/prototypes
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import {
-  AssertRest,
-  AssertType,
-  Static,  
-  Type, 
-  TypeGuard, 
-  TSchema,  
-  TObject, 
-  Evaluate, 
-  TArray, 
-  TFunction, 
-  TConstructor, 
-  TPromise, 
-  TIterator, 
-  TAsyncIterator, 
-  TTuple, 
-  TProperties, 
-  TIntersect, 
-  TUnion, 
-  TNever 
-} from '@sinclair/typebox'
-
-// --------------------------------------------------------------------------
-// TEvaluate
-// --------------------------------------------------------------------------
-// prettier-ignore
-export type TEvaluateIntersectType<L extends TSchema, R extends TSchema> = (
-  Static<L> extends Static<R> ? 
-    Static<R> extends Static<L> ? R :
-    Static<L> extends Static<R> ? L :
-    TNever : 
-  Static<R> extends Static<L> ? R : 
-    TNever
-)
-// prettier-ignore
-export type TEvaluateIntersectRest<T extends TSchema[]> = 
-  T extends [infer L, infer R, ...infer Rest] ? TEvaluateIntersectRest<[TEvaluateIntersectType<AssertType<L>, AssertType<R>>, ...AssertRest<Rest>]> : 
-  T
-// prettier-ignore
-export type TEvaluateProperties<T extends TProperties> = Evaluate<{
-  [K in keyof T]: TEvaluate<T[K]>
-}>
-// prettier-ignore
-export type TEvaluateArray<T extends TSchema[]> =  T extends [infer L, ...infer R] ? 
-  [TEvaluate<AssertType<L>>, ...TEvaluateArray<AssertRest<R>>] : 
-  []
-// prettier-ignore
-export type TEvaluate<T extends TSchema> = 
-  T extends TIntersect<infer S>            ? TIntersect<TEvaluateIntersectRest<S>> :
-  T extends TUnion<infer S>                ? TUnion<TEvaluateArray<S>> :
-  T extends TConstructor<infer P, infer R> ? TConstructor<TEvaluateArray<P>, TEvaluate<R>> : 
-  T extends TFunction<infer P, infer R>    ? TFunction<TEvaluateArray<P>, TEvaluate<R>> : 
-  T extends TObject<infer S>               ? TObject<TEvaluateProperties<S>> : 
-  T extends TTuple<infer S>                ? TTuple<TEvaluateArray<S>> :
-  T extends TArray<infer S>                ? TArray<TEvaluate<S>> :
-  T extends TPromise<infer S>              ? TPromise<TEvaluate<S>> :
-  T extends TIterator<infer S>             ? TIterator<TEvaluate<S>> :
-  T extends TAsyncIterator<infer S>        ? TAsyncIterator<TEvaluate<S>> :
-  T
-// --------------------------------------------------------------------------
-// Evaluate
-// --------------------------------------------------------------------------
-// prettier-ignore
-export function EvaluateIntersectType<X extends TSchema, Y extends TSchema>(L: X, R: Y) {
-  return Type.Extends(L, R, 
-    Type.Extends(R, L, R, 
-    Type.Extends(L, R, L, 
-  Type.Never())), 
-    Type.Extends(R, L, R, 
-    Type.Never()))
-}
-// prettier-ignore
-export function EvaluateIntersectRest<T extends TSchema[]>(T: [...T]): TEvaluateIntersectRest<T> {
-  if(T.length >= 2) {
-    const [L, R, ...Rest] = T
-    return EvaluateIntersectRest([EvaluateIntersectType(L, R), ...Rest]) as any
-  } else {
-    return T as any
-  }
-}
-export function EvaluateProperties<T extends TProperties>(properties: T) {
-  return Object.getOwnPropertyNames(properties).reduce((acc, key) => {
-    return { ...acc, [key]: Evaluate(properties[key]) }
-  }, {} as TProperties)
-}
-export function EvaluateArray<T extends TSchema[] | undefined>(rest: T) {
-  if (rest === undefined) return [] // for tuple items
-  return rest.map((schema) => Evaluate(schema))
-}
-// prettier-ignore
-export function Evaluate<T extends TSchema>(schema: T): TEvaluate<T> {
-  return (
-    TypeGuard.IsIntersect(schema)     ? Type.Intersect(EvaluateIntersectRest(schema.allOf)) :
-    TypeGuard.IsUnion(schema)         ? Type.Union(EvaluateArray(schema.anyOf)) :
-    TypeGuard.IsAsyncIterator(schema) ? Type.AsyncIterator(Evaluate(schema.items)) :
-    TypeGuard.IsIterator(schema)      ? Type.Iterator(Evaluate(schema.items)) :
-    TypeGuard.IsObject(schema)        ? Type.Object(EvaluateProperties(schema.properties)) :
-    TypeGuard.IsConstructor(schema)   ? Type.Constructor(EvaluateArray(schema.parameters), Evaluate(schema.returns)) :
-    TypeGuard.IsFunction(schema)      ? Type.Function(EvaluateArray(schema.parameters), Evaluate(schema.returns)) :
-    TypeGuard.IsTuple(schema)         ? Type.Tuple(EvaluateArray(schema.items)) :
-    TypeGuard.IsArray(schema)         ? Type.Promise(Evaluate(schema.items)) :
-    TypeGuard.IsPromise(schema)       ? Type.Promise(Evaluate(schema.item)) :
-    schema 
-  ) as TEvaluate<T>
-}
-
diff --git a/example/prototypes/index.ts b/example/prototypes/index.ts
index c0039fc87..cb81ad0bb 100644
--- a/example/prototypes/index.ts
+++ b/example/prototypes/index.ts
@@ -26,8 +26,8 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export * from './evaluate'
 export * from './from-schema'
+export * from './module'
 export * from './partial-deep'
 export * from './union-enum'
 export * from './union-oneof'
diff --git a/example/prototypes/module.ts b/example/prototypes/module.ts
new file mode 100644
index 000000000..e56dcb2dd
--- /dev/null
+++ b/example/prototypes/module.ts
@@ -0,0 +1,166 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/prototypes
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '@sinclair/typebox'
+import { Check } from '@sinclair/typebox/value'
+// ------------------------------------------------------------------
+// Infer
+// ------------------------------------------------------------------
+// prettier-ignore
+export type InferImport<Properties extends TModuleProperties, Key extends keyof Properties, Module extends TModuleProperties> = (
+  Infer<Properties[Key], Module>
+)
+// prettier-ignore
+export type InferModuleRef<Ref extends string, Module extends TModuleProperties> = (
+  Ref extends keyof Module ? Infer<Module[Ref], Module> : never
+)
+// prettier-ignore
+export type InferObject<Properties extends Types.TProperties, Module extends TModuleProperties> = { 
+  [K in keyof Properties]: Infer<Properties[K], Module> 
+} & {}
+// prettier-ignore
+export type InferConstructor<Parameters extends Types.TSchema[], InstanceType extends Types.TSchema, Module extends TModuleProperties> = Types.Ensure<
+  new (...args: InferTuple<Parameters, Module>) => Infer<InstanceType, Module>
+>
+// prettier-ignore
+export type InferFunction<Parameters extends Types.TSchema[], ReturnType extends Types.TSchema, Module extends TModuleProperties> = Types.Ensure<
+  (...args: InferTuple<Parameters, Module>) => Infer<ReturnType, Module>
+>
+// prettier-ignore
+export type InferTuple<Types extends Types.TSchema[], Module extends TModuleProperties, Result extends unknown[] = []> = (
+  Types extends [infer L extends Types.TSchema, ...infer R extends Types.TSchema[]]
+    ? InferTuple<R, Module, [...Result, Infer<L, Module>]>
+    : Result
+)
+// prettier-ignore
+export type InferIntersect<Types extends Types.TSchema[], Module extends TModuleProperties, Result extends unknown = unknown> = (
+  Types extends [infer L extends Types.TSchema, ...infer R extends Types.TSchema[]]
+    ? InferIntersect<R, Module, Result & Infer<L, Module>>
+    : Result
+)
+// prettier-ignore
+export type InferUnion<Types extends Types.TSchema[], Module extends TModuleProperties, Result extends unknown = never> = (
+  Types extends [infer L extends Types.TSchema, ...infer R extends Types.TSchema[]]
+    ? InferUnion<R, Module, Result | Infer<L, Module>>
+    : Result
+)
+// prettier-ignore
+export type InferArray<Type extends Types.TSchema, Module extends TModuleProperties> = (
+  Types.Ensure<Array<Infer<Type, Module>>>
+)
+// prettier-ignore
+export type InferAsyncIterator<Type extends Types.TSchema, Module extends TModuleProperties> = (
+  Types.Ensure<AsyncIterableIterator<Infer<Type, Module>>>
+)
+// prettier-ignore
+export type InferIterator<Type extends Types.TSchema, Module extends TModuleProperties> = (
+  Types.Ensure<IterableIterator<Infer<Type, Module>>>
+)
+// prettier-ignore
+type Infer<Type extends Types.TSchema, Module extends TModuleProperties = {}> = (
+  Type extends TImport<infer S extends TModuleProperties, infer K extends PropertyKey> ? InferImport<S, K, S> :
+  Type extends TModuleRef<infer S extends string> ? InferModuleRef<S, Module> :
+  Type extends Types.TObject<infer S extends Types.TProperties> ? InferObject<S, Module> :
+  Type extends Types.TConstructor<infer S extends Types.TSchema[], infer R extends Types.TSchema> ? InferConstructor<S, R, Module> :
+  Type extends Types.TFunction<infer S extends Types.TSchema[], infer R extends Types.TSchema> ? InferFunction<S, R, Module> :
+  Type extends Types.TTuple<infer S extends Types.TSchema[]> ? InferTuple<S, Module> :
+  Type extends Types.TIntersect<infer S extends Types.TSchema[]> ? InferIntersect<S, Module> :
+  Type extends Types.TUnion<infer S extends Types.TSchema[]> ? InferUnion<S, Module> :
+  Type extends Types.TArray<infer S extends Types.TSchema> ? InferArray<S, Module> :
+  Type extends Types.TAsyncIterator<infer S extends Types.TSchema> ? InferAsyncIterator<S, Module> :
+  Type extends Types.TIterator<infer S extends Types.TSchema> ? InferIterator<S, Module> :
+  Type extends Types.TTemplateLiteral<infer S extends Types.TTemplateLiteralKind[]> ? Types.Static<Types.TTemplateLiteral<S>> :
+  Type extends Types.TLiteral<infer S extends Types.TLiteralValue> ? S :
+  Type extends Types.TAny ? any :
+  Type extends Types.TBigInt ? bigint :
+  Type extends Types.TBoolean ? boolean :
+  Type extends Types.TDate ? Date :
+  Type extends Types.TInteger ? number :
+  Type extends Types.TNever ? never :
+  Type extends Types.TNumber ? number :
+  Type extends Types.TRegExp ? string :
+  Type extends Types.TString ? string :
+  Type extends Types.TSymbol ? symbol :
+  Type extends Types.TNull ? null :
+  Type extends Types.TUint8Array ? Uint8Array :
+  Type extends Types.TUndefined ? undefined :
+  Type extends Types.TUnknown ? unknown :
+  Type extends Types.TVoid ? void :
+  never
+)
+// ------------------------------------------------------------------
+// ModuleRef
+// ------------------------------------------------------------------
+// prettier-ignore
+export interface TModuleRef<Ref extends string> extends Types.TSchema {
+  [Types.Kind]: 'ModuleRef'
+  $ref: Ref
+}
+// prettier-ignore
+export function ModuleRef<Ref extends string>($ref: Ref): TModuleRef<Ref>  {
+  return Types.Type.Ref($ref) as never
+}
+// ------------------------------------------------------------------
+// Import
+// ------------------------------------------------------------------
+// prettier-ignore
+Types.TypeRegistry.Set('Import', (module: TImport, value: unknown) => {
+  const keys = Object.getOwnPropertyNames(module.$defs)
+  const references = keys.map(key => module.$defs[key as never]) as Types.TSchema[]
+  const schema = module.$defs[module.$ref]
+  return Check(schema, references, value)
+})
+// prettier-ignore
+export type TModuleProperties = Record<PropertyKey, Types.TSchema>
+
+// prettier-ignore
+export interface TImport<Definitions extends TModuleProperties = {}, Key extends keyof Definitions = keyof Definitions> extends Types.TSchema {
+  [Types.Kind]: 'Import'
+  static: InferImport<Definitions, Key, Definitions>
+  $defs: Definitions
+  $ref: Key
+}
+// ------------------------------------------------------------------
+// Module
+// ------------------------------------------------------------------
+// prettier-ignore
+export class ModuleInstance<Properties extends TModuleProperties> {
+  constructor(private readonly properties: Properties) {}
+  public Import<Key extends keyof Properties>(key: Key): TImport<Properties, Key> {
+    const $defs = globalThis.Object.getOwnPropertyNames(this.properties).reduce((Result, Key) => (
+     { ...Result, [Key]: { ...this.properties[Key], $id: Key }}
+    ), {})
+    return { [Types.Kind]: 'Import', $defs, $ref: key } as never
+  }
+}
+export function Module<Properties extends TModuleProperties>(properties: Properties): ModuleInstance<Properties> {
+  return new ModuleInstance(properties)
+}
+
+
+
diff --git a/example/prototypes/mutual.ts b/example/prototypes/mutual.ts
deleted file mode 100644
index c47b7c798..000000000
--- a/example/prototypes/mutual.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/prototypes
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { Type, TSchema, Static } from '@sinclair/typebox'
-
-// Mutual Recursive Template
-const __A = <T extends TSchema>(reference: T) => Type.Object({
-  b: Type.Union([reference, Type.Null()])
-}, { additionalProperties: false })
-
-const __B = <T extends TSchema>(reference: T) => Type.Object({
-  a: Type.Union([reference, Type.Null()])
-}, { additionalProperties: false })
-
-// ....
-
-// Mutual Recursive Types
-const A = Type.Recursive((This) => __A(__B(This)))
-const B = Type.Recursive((This) => __B(__A(This)))
-
-type A = Static<typeof A>;
-type B = Static<typeof B>;
-
diff --git a/example/prototypes/readme.md b/example/prototypes/readme.md
index 77a962c70..7c7c429f2 100644
--- a/example/prototypes/readme.md
+++ b/example/prototypes/readme.md
@@ -1,48 +1,46 @@
 # TypeBox Prototypes
 
-TypeBox prototypes are a set of types that are either under consideration for inclusion into the library, or have been requested by users but cannot be added to the library either due to complexity, using schematics that fall outside the supported TypeBox or should be expressed by users via advanced type composition. 
+TypeBox prototypes are a set of types that are either under consideration for inclusion into the library, or have been requested by users but cannot be added to the library either due to complexity, using schematics that fall outside the supported TypeBox or should be expressed by users via advanced type composition.
 
-Each prototype is written as a standalone module that can be copied into projects and used directly, or integrated into extended type builders.
+## Module, ModuleRef and Import 
 
-## Const
-
-This type will wrap all interior properties as `readonly` leaving the outer type unwrapped. This type is analogous to the `Readonly<T>` TypeScript utility type, but as TypeBox uses this name as a property modifier, the name `Const` is used.
+The Module type as a candidate referencing system for TypeBox. Modules enable deferred cross type referencing and support mutual recursive inference. Module types must be instanced via `M.Import(...)` which constructs a `$def` schematic containing each definition required to validate, and a self referential `$ref` to one of the type being imported.
 
 ```typescript
-import { Const } from './prototypes'
-
-const T = Const(Type.Object({                       // const T: TObject<{
-  x: Type.Number()                                  //   x: Type.Readonly(Type.Number())
-}))                                                 // }>
-
-type T = Static<typeof T>                           // type T = {
-                                                    //   readonly x: number
-                                                    // }
-```
-## Evaluate
-
-This type is an advanced mapping type will evaluate for schema redundancy by reducing evaluating intersection rest arguments. This type detects if intersection would produce illogical `never`, removes duplicates and handles intersection type narrowing. This type is a strong candidate for inclusion into the TypeBox library but is pending an equivalent redundancy check for `union` rest arguments. 
-
-```typescript
-import { Evaluate } from './prototypes'
-
-// Evaluate for Duplicates
-//
-const T = Type.Intersect([ Type.Number(), Type.Number(), Type.Number() ])
+import { Module, ModuleRef } from './prototypes'
 
-const E = Evaluate(T)                               // const E: TNumber
-
-// Evaluate for TNever
-//
-const T = Type.Intersect([ Type.Number(), Type.String() ])
-
-const E = Evaluate(T)                               // const E: TIntersect<[TNumber, TString]>
+// ------------------------------------------------------------------
+// Module, ModuleRef
+// ------------------------------------------------------------------
+const Math = Module({
+  Vector2: Type.Object({
+    x: Type.Number(),
+    y: Type.Number(),
+  }),
+  Vector3: Type.Object({
+    x: Type.Number(),
+    y: Type.Number(),
+    z: Type.Number()
+  }),
+  Vertex: Type.Object({
+    position: ModuleRef('Vector3'),
+    normal: ModuleRef('Vector3'),
+    texcoord: ModuleRef('Vector2')
+  }),
+  Geometry: Type.Object({
+    vertices: Type.Array(ModuleRef('Vertex')),
+    indices: Type.Array(Type.Integer())
+  })
+})
 
-// Evaluate for most narrowed type
-//
-const T = Type.Intersect([ Type.Number(), Type.Literal(1) ])
+// ------------------------------------------------------------------
+// Import
+// -----------------------------------------------------------------
 
-const E = Evaluate(T)                               // const E: TLiteral<1>
+const Vector2 = Math.Import('Vector2')
+const Vector3 = Math.Import('Vector2')
+const Vertex = Math.Import('Vertex')
+const Geometry = Math.Import('Geometry')
 ```
 
 ## PartialDeep

From 9a0309869dc7fbe8b71a23cd04869d318d4d11ce Mon Sep 17 00:00:00 2001
From: Hamish Peebles <hamishpeebles@gmail.com>
Date: Fri, 4 Oct 2024 22:08:04 +0100
Subject: [PATCH 285/369] Fix: Converting Large Numbers to BigInt (#1019)

* Fix converting large numbers to BigInts

* Clarify numeric value

* Add test
---
 src/value/convert/convert.ts         |  2 +-
 test/runtime/value/convert/bigint.ts | 28 ++++++++++++++++++++++++----
 2 files changed, 25 insertions(+), 5 deletions(-)

diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index 92e6c5811..a5ddf7b0a 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -120,7 +120,7 @@ function TryConvertBoolean(value: unknown) {
 }
 function TryConvertBigInt(value: unknown) {
   const truncateInteger = (value: string) => value.split('.')[0]
-  return IsStringNumeric(value) ? BigInt(truncateInteger(value)) : IsNumber(value) ? BigInt(value | 0) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value
+  return IsStringNumeric(value) ? BigInt(truncateInteger(value)) : IsNumber(value) ? BigInt(Math.trunc(value)) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value
 }
 function TryConvertString(value: unknown) {
   return IsValueToString(value) ? value.toString() : IsSymbol(value) && value.description !== undefined ? value.description.toString() : value
diff --git a/test/runtime/value/convert/bigint.ts b/test/runtime/value/convert/bigint.ts
index 383e692a6..02014a86e 100644
--- a/test/runtime/value/convert/bigint.ts
+++ b/test/runtime/value/convert/bigint.ts
@@ -3,7 +3,7 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/convert/BigInt', () => {
-  it('Should convert bitint from string 1', () => {
+  it('Should convert bigint from string 1', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, '1')
     Assert.IsEqual(R, BigInt(1))
@@ -13,7 +13,7 @@ describe('value/convert/BigInt', () => {
     const R = Value.Convert(T, '3.14')
     Assert.IsEqual(R, BigInt(3))
   })
-  it('Should convert bitint from string 3', () => {
+  it('Should convert bigint from string 3', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, 'true')
     Assert.IsEqual(R, BigInt(1))
@@ -43,7 +43,7 @@ describe('value/convert/BigInt', () => {
     const R = Value.Convert(T, '-12345678901234567890.123')
     Assert.IsEqual(R, BigInt('-12345678901234567890'))
   })
-  it('Should convert bitint from number 1', () => {
+  it('Should convert bigint from number 1', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, 1)
     Assert.IsEqual(R, BigInt(1))
@@ -53,7 +53,27 @@ describe('value/convert/BigInt', () => {
     const R = Value.Convert(T, 3.14)
     Assert.IsEqual(R, BigInt(3))
   })
-  it('Should convert bitint from boolean 1', () => {
+  it('Should convert bigint from number 3', () => {
+    const T = Type.BigInt()
+    const R = Value.Convert(T, Math.pow(2, 31))
+    Assert.IsEqual(R, BigInt(2147483648))
+  })
+  it('Should convert bigint from number 4', () => {
+    const T = Type.BigInt()
+    const R = Value.Convert(T, Number.MAX_SAFE_INTEGER)
+    Assert.IsEqual(R, BigInt(9007199254740991))
+  })
+  it('Should convert bigint from number 5', () => {
+    const T = Type.BigInt()
+    const R = Value.Convert(T, 123456789012345.6789)
+    Assert.IsEqual(R, BigInt(123456789012345))
+  })
+  it('Should convert bigint from number 6', () => {
+    const T = Type.BigInt()
+    const R = Value.Convert(T, -123456789012345.6789)
+    Assert.IsEqual(R, BigInt(-123456789012345))
+  })
+  it('Should convert bigint from boolean 1', () => {
     const T = Type.BigInt()
     const R = Value.Convert(T, true)
     Assert.IsEqual(R, BigInt(1))

From 99f4d9c1a182f5ab3f11c9a1493b343ea4c5b188 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Sat, 5 Oct 2024 06:36:40 +0900
Subject: [PATCH 286/369] Revision 0.33.14 (#1022)

* ChangeLog

* Version
---
 changelog/0.33.0.md | 2 ++
 package-lock.json   | 4 ++--
 package.json        | 2 +-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/changelog/0.33.0.md b/changelog/0.33.0.md
index 71155ab8a..62359cffb 100644
--- a/changelog/0.33.0.md
+++ b/changelog/0.33.0.md
@@ -1,4 +1,6 @@
 ### 0.33.0
+- [Revision 0.33.14](https://github.com/sinclairzx81/typebox/pull/1019)
+  - [1019](https://github.com/sinclairzx81/typebox/pull/1019) Converting Large Numbers to BigInt
 - [Revision 0.33.13](https://github.com/sinclairzx81/typebox/pull/1011)
   - [1010](https://github.com/sinclairzx81/typebox/pull/1011) Fixes Value.Parse fails with recursive types
 - [Revision 0.33.12](https://github.com/sinclairzx81/typebox/pull/999) 
diff --git a/package-lock.json b/package-lock.json
index 103ce872d..a5a68959f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.13",
+  "version": "0.33.14",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.13",
+      "version": "0.33.14",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 375d8ab30..0e27a7a75 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.13",
+  "version": "0.33.14",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

From f9134bbadf81f4b9c175ebb8897ea98957e3d4a0 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Mon, 7 Oct 2024 12:08:27 +0900
Subject: [PATCH 287/369] Revision 0.33.15 (#1025)

* Add Resolver for Default Date

* Version

* ChangeLog
---
 changelog/0.33.0.md                |  2 ++
 package-lock.json                  |  4 ++--
 package.json                       |  2 +-
 src/type/guard/value.ts            |  7 +++++++
 src/value/default/default.ts       |  8 +++++++-
 src/value/guard/guard.ts           |  7 +++++--
 test/runtime/value/default/date.ts | 18 ++++++++++++++++++
 7 files changed, 42 insertions(+), 6 deletions(-)

diff --git a/changelog/0.33.0.md b/changelog/0.33.0.md
index 62359cffb..dbdff7da1 100644
--- a/changelog/0.33.0.md
+++ b/changelog/0.33.0.md
@@ -1,4 +1,6 @@
 ### 0.33.0
+- [Revision 0.33.15](https://github.com/sinclairzx81/typebox/pull/1025)
+  - [1024](https://github.com/sinclairzx81/typebox/issues/1024) Fix to correctly resolve default Dates
 - [Revision 0.33.14](https://github.com/sinclairzx81/typebox/pull/1019)
   - [1019](https://github.com/sinclairzx81/typebox/pull/1019) Converting Large Numbers to BigInt
 - [Revision 0.33.13](https://github.com/sinclairzx81/typebox/pull/1011)
diff --git a/package-lock.json b/package-lock.json
index a5a68959f..0971b4634 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.14",
+  "version": "0.33.15",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.14",
+      "version": "0.33.15",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 0e27a7a75..a217221c8 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.14",
+  "version": "0.33.15",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/guard/value.ts b/src/type/guard/value.ts
index e0f63974a..4e4f9d1e2 100644
--- a/src/type/guard/value.ts
+++ b/src/type/guard/value.ts
@@ -26,6 +26,13 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+// --------------------------------------------------------------------------
+// PropertyKey
+// --------------------------------------------------------------------------
+/** Returns true if this value has this property key */
+export function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is Record<PropertyKey, unknown> & { [_ in K]: unknown } {
+  return key in value
+}
 // --------------------------------------------------------------------------
 // Object Instances
 // --------------------------------------------------------------------------
diff --git a/src/value/default/default.ts b/src/value/default/default.ts
index d12b40338..19b4b6496 100644
--- a/src/value/default/default.ts
+++ b/src/value/default/default.ts
@@ -44,7 +44,7 @@ import type { TUnion } from '../../type/union/index'
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsFunction, IsObject, IsArray, IsUndefined, HasPropertyKey } from '../guard/index'
+import { IsArray, IsDate, IsFunction, IsObject, IsUndefined, HasPropertyKey } from '../guard/index'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -74,6 +74,10 @@ function FromArray(schema: TArray, references: TSchema[], value: unknown): any {
   }
   return defaulted
 }
+function FromDate(schema: TArray, references: TSchema[], value: unknown): any {
+  // special case intercept for dates
+  return IsDate(value) ? value : ValueOrDefault(schema, value)
+}
 function FromIntersect(schema: TIntersect, references: TSchema[], value: unknown): any {
   const defaulted = ValueOrDefault(schema, value)
   return schema.allOf.reduce((acc, schema) => {
@@ -155,6 +159,8 @@ function Visit(schema: TSchema, references: TSchema[], value: unknown): any {
   switch (schema_[Kind]) {
     case 'Array':
       return FromArray(schema_, references_, value)
+    case 'Date':
+      return FromDate(schema_, references_, value)
     case 'Intersect':
       return FromIntersect(schema_, references_, value)
     case 'Object':
diff --git a/src/value/guard/guard.ts b/src/value/guard/guard.ts
index 942560b78..8d5fa25d0 100644
--- a/src/value/guard/guard.ts
+++ b/src/value/guard/guard.ts
@@ -139,12 +139,15 @@ export function IsBigUint64Array(value: unknown): value is BigUint64Array {
   return value instanceof globalThis.BigUint64Array
 }
 // --------------------------------------------------------------------------
-// Standard
+// PropertyKey
 // --------------------------------------------------------------------------
 /** Returns true if this value has this property key */
-export function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is ObjectType & Record<K, unknown> {
+export function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is Record<PropertyKey, unknown> & { [_ in K]: unknown } {
   return key in value
 }
+// --------------------------------------------------------------------------
+// Standard
+// --------------------------------------------------------------------------
 /** Returns true of this value is an object type */
 export function IsObject(value: unknown): value is ObjectType {
   return value !== null && typeof value === 'object'
diff --git a/test/runtime/value/default/date.ts b/test/runtime/value/default/date.ts
index 2522cf20d..72b95c0b4 100644
--- a/test/runtime/value/default/date.ts
+++ b/test/runtime/value/default/date.ts
@@ -13,4 +13,22 @@ describe('value/default/Date', () => {
     const R = Value.Default(T, null)
     Assert.IsEqual(R, null)
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/1024
+  // ----------------------------------------------------------------
+  it('Should use value if Date is valid', () => {
+    const T = Type.Date({ default: new Date(1) })
+    const R = Value.Default(T, new Date(2)) as Date
+    Assert.IsEqual(R.getTime(), 2)
+  })
+  it('Should use default if Date is undefined', () => {
+    const T = Type.Date({ default: new Date(1) })
+    const R = Value.Default(T, undefined) as Date
+    Assert.IsEqual(R.getTime(), 1)
+  })
+  it('Should use value if Date is invalid', () => {
+    const T = Type.Date({ default: new Date(1) })
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
 })

From 0f65387f556cbf633c0f28dd8a2f1723b998b24d Mon Sep 17 00:00:00 2001
From: Alec Larson <1925840+aleclarson@users.noreply.github.com>
Date: Thu, 10 Oct 2024 21:11:38 -0400
Subject: [PATCH 288/369] Union ValueError Iterator (#1015)

* feat: attach to ValueError the first error of each Union.anyOf visit

* chore: small tweak

* test: add test

* chore: tweak test

* fix: flatten nested union errors

* feat: expose variant errors as ValueErrorIterator[]

* feat: use a single ValueErrorIterator instance

* update tests

* implement requested changes

* update test

* update ErrorFunctionParameter

* small fix
---
 src/errors/errors.ts               | 25 ++++++++++++++-----------
 src/errors/function.ts             |  4 +++-
 test/runtime/errors/types/union.ts |  4 +++-
 3 files changed, 20 insertions(+), 13 deletions(-)

diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index edb58a06d..44a8b0227 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -34,6 +34,7 @@ import { GetErrorFunction } from './function'
 import { TypeBoxError } from '../type/error/index'
 import { Deref } from '../value/deref/index'
 import { Hash } from '../value/hash/index'
+import { Check } from '../value/check/index'
 import { Kind } from '../type/symbols/index'
 
 import type { TSchema } from '../type/schema/index'
@@ -167,6 +168,7 @@ export interface ValueError {
   path: string
   value: unknown
   message: string
+  errors: ValueErrorIterator[]
 }
 // ------------------------------------------------------------------
 // ValueErrors
@@ -205,8 +207,15 @@ export class ValueErrorIterator {
 // --------------------------------------------------------------------------
 // Create
 // --------------------------------------------------------------------------
-function Create(errorType: ValueErrorType, schema: TSchema, path: string, value: unknown): ValueError {
-  return { type: errorType, schema, path, value, message: GetErrorFunction()({ errorType, path, schema, value }) }
+function Create(errorType: ValueErrorType, schema: TSchema, path: string, value: unknown, errors: ValueErrorIterator[] = []): ValueError {
+  return {
+    type: errorType,
+    schema,
+    path,
+    value,
+    message: GetErrorFunction()({ errorType, path, schema, value, errors }),
+    errors,
+  }
 }
 // --------------------------------------------------------------------------
 // Types
@@ -516,15 +525,9 @@ function* FromUndefined(schema: TUndefined, references: TSchema[], path: string,
   if (!IsUndefined(value)) yield Create(ValueErrorType.Undefined, schema, path, value)
 }
 function* FromUnion(schema: TUnion, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
-  let count = 0
-  for (const subschema of schema.anyOf) {
-    const errors = [...Visit(subschema, references, path, value)]
-    if (errors.length === 0) return // matched
-    count += errors.length
-  }
-  if (count > 0) {
-    yield Create(ValueErrorType.Union, schema, path, value)
-  }
+  if (Check(schema, references, value)) return
+  const errors = schema.anyOf.map((variant) => new ValueErrorIterator(Visit(variant, references, path, value)))
+  yield Create(ValueErrorType.Union, schema, path, value, errors)
 }
 function* FromUint8Array(schema: TUint8Array, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsUint8Array(value)) return yield Create(ValueErrorType.Uint8Array, schema, path, value)
diff --git a/src/errors/function.ts b/src/errors/function.ts
index 94504c5ad..536f3e682 100644
--- a/src/errors/function.ts
+++ b/src/errors/function.ts
@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 import { TSchema } from '../type/schema/index'
 import { Kind } from '../type/symbols/index'
-import { ValueErrorType } from './errors'
+import { ValueErrorIterator, ValueErrorType } from './errors'
 
 /** Creates an error message using en-US as the default locale */
 export function DefaultErrorFunction(error: ErrorFunctionParameter) {
@@ -178,6 +178,8 @@ export type ErrorFunctionParameter = {
   schema: TSchema
   /** The value associated with the error */
   value: unknown
+  /** Interior errors for this error */
+  errors: ValueErrorIterator[]
 }
 export type ErrorFunction = (parameter: ErrorFunctionParameter) => string
 /** Manages error message providers */
diff --git a/test/runtime/errors/types/union.ts b/test/runtime/errors/types/union.ts
index df110ed30..70d1389a3 100644
--- a/test/runtime/errors/types/union.ts
+++ b/test/runtime/errors/types/union.ts
@@ -1,5 +1,5 @@
 import { Type } from '@sinclair/typebox'
-import { ValueErrorType } from '@sinclair/typebox/errors'
+import { ValueErrorIterator, ValueErrorType } from '@sinclair/typebox/errors'
 import { Resolve } from './resolve'
 import { Assert } from '../../assert'
 
@@ -17,5 +17,7 @@ describe('errors/type/Union', () => {
     const R = Resolve(T, true)
     Assert.IsEqual(R.length, 1)
     Assert.IsEqual(R[0].type, ValueErrorType.Union)
+    Assert.IsEqual(R[0].errors[0].First()?.type, ValueErrorType.String)
+    Assert.IsEqual(R[0].errors[1].First()?.type, ValueErrorType.Number)
   })
 })

From 295f8d9e3994f04cd7d76c613da123d89e70c61d Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Fri, 11 Oct 2024 10:40:36 +0900
Subject: [PATCH 289/369] Revision 0.33.16 (#1028)

* Version

* TypeScript 5.6.3
---
 hammer.mjs        |  2 +-
 package-lock.json | 18 +++++++++---------
 package.json      |  4 ++--
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/hammer.mjs b/hammer.mjs
index 28f7b3d6a..82755bffb 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -32,7 +32,7 @@ export async function benchmark() {
 // Test
 // -------------------------------------------------------------------------------
 export async function test_typescript() {
-  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', '5.4.5', '5.5.2', '5.5.3', '5.5.4', 'next', 'latest']) {
+  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', '5.4.5', '5.5.2', '5.5.3', '5.5.4', '5.6.2', 'next', 'latest']) {
     await shell(`npm install typescript@${version} --no-save`)
     await test_static()
   }
diff --git a/package-lock.json b/package-lock.json
index 0971b4634..d61c9a896 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.15",
+  "version": "0.33.16",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.15",
+      "version": "0.33.16",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
@@ -17,7 +17,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^10.4.0",
         "prettier": "^2.7.1",
-        "typescript": "^5.6.2"
+        "typescript": "^5.6.3"
       }
     },
     "node_modules/@andrewbranch/untar.js": {
@@ -1576,9 +1576,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.6.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.6.2.tgz",
-      "integrity": "sha512-NW8ByodCSNCwZeghjN3o+JX5OFH0Ojg6sadjEKY4huZ52TqbJTJnDo5+Tw98lSy63NZvi4n+ez5m2u5d4PkZyw==",
+      "version": "5.6.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.6.3.tgz",
+      "integrity": "sha512-hjcS1mhfuyi4WW8IWtjP7brDrG2cuDZukyrYrSauoXGNgx0S7zceP07adYkJycEr56BOUTNPzbInooiN3fn1qw==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -2738,9 +2738,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.6.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.6.2.tgz",
-      "integrity": "sha512-NW8ByodCSNCwZeghjN3o+JX5OFH0Ojg6sadjEKY4huZ52TqbJTJnDo5+Tw98lSy63NZvi4n+ez5m2u5d4PkZyw==",
+      "version": "5.6.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.6.3.tgz",
+      "integrity": "sha512-hjcS1mhfuyi4WW8IWtjP7brDrG2cuDZukyrYrSauoXGNgx0S7zceP07adYkJycEr56BOUTNPzbInooiN3fn1qw==",
       "dev": true
     },
     "undici-types": {
diff --git a/package.json b/package.json
index a217221c8..0d2987917 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.15",
+  "version": "0.33.16",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -37,6 +37,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^10.4.0",
     "prettier": "^2.7.1",
-    "typescript": "^5.6.2"
+    "typescript": "^5.6.3"
   }
 }

From ac90038ec7002c9045434ad4f9d82ed4ddf8e244 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Thu, 17 Oct 2024 14:19:42 +0900
Subject: [PATCH 290/369] Revision 0.33.17 (#1042)

* Use Constant Initializer on Hash Size

* Version

* ChangeLog
---
 changelog/0.33.0.md    | 4 ++++
 package-lock.json      | 4 ++--
 package.json           | 2 +-
 src/value/hash/hash.ts | 2 +-
 4 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/changelog/0.33.0.md b/changelog/0.33.0.md
index dbdff7da1..e07a964ef 100644
--- a/changelog/0.33.0.md
+++ b/changelog/0.33.0.md
@@ -1,4 +1,8 @@
 ### 0.33.0
+- [Revision 0.33.17](https://github.com/sinclairzx81/typebox/pull/1042)
+  - [1041](https://github.com/sinclairzx81/typebox/issues/1041) Avoid Exponentiation operator on Value.Hash
+- [Revision 0.33.16](https://github.com/sinclairzx81/typebox/pull/1015)
+  - [1015](https://github.com/sinclairzx81/typebox/issues/1015) Add sub error iterators to ValueError
 - [Revision 0.33.15](https://github.com/sinclairzx81/typebox/pull/1025)
   - [1024](https://github.com/sinclairzx81/typebox/issues/1024) Fix to correctly resolve default Dates
 - [Revision 0.33.14](https://github.com/sinclairzx81/typebox/pull/1019)
diff --git a/package-lock.json b/package-lock.json
index d61c9a896..f05528cca 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.16",
+  "version": "0.33.17",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.16",
+      "version": "0.33.17",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 0d2987917..505014947 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.16",
+  "version": "0.33.17",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/hash/hash.ts b/src/value/hash/hash.ts
index 2a173423c..eb86c7c72 100644
--- a/src/value/hash/hash.ts
+++ b/src/value/hash/hash.ts
@@ -57,7 +57,7 @@ enum ByteMarker {
 // State
 // ------------------------------------------------------------------
 let Accumulator = BigInt('14695981039346656037')
-const [Prime, Size] = [BigInt('1099511628211'), BigInt('2') ** BigInt('64')]
+const [Prime, Size] = [BigInt('1099511628211'), BigInt('18446744073709551616' /* 2 ^ 64 */)]
 const Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i))
 const F64 = new Float64Array(1)
 const F64In = new DataView(F64.buffer)

From a0293a7f29a9338c9616a38116cdf00f8ffc8446 Mon Sep 17 00:00:00 2001
From: Hacxy <162423108+hacxy@users.noreply.github.com>
Date: Thu, 31 Oct 2024 21:25:06 +0800
Subject: [PATCH 291/369] Ecosystem (#1050)

* Add json2typebox to ecosystem
---
 readme.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/readme.md b/readme.md
index ea7d87557..9590eeaf6 100644
--- a/readme.md
+++ b/readme.md
@@ -1646,6 +1646,7 @@ The following is a list of community packages that offer general tooling, extend
 | [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
 | [h3-typebox](https://github.com/kevinmarrec/h3-typebox) | Schema validation utilities for h3 using TypeBox & Ajv |
 | [http-wizard](https://github.com/flodlc/http-wizard) | Type safe http client library for Fastify |
+| [json2typebox](https://github.com/hacxy/json2typebox) | Creating TypeBox code from Json Data |
 | [nominal-typebox](https://github.com/Coder-Spirit/nominal/tree/main/%40coderspirit/nominal-typebox) | Allows devs to integrate nominal types into TypeBox schemas |
 | [openapi-box](https://github.com/geut/openapi-box) | Generate TypeBox types from OpenApi IDL + Http client library |
 | [prismabox](https://github.com/m1212e/prismabox) | Converts a prisma.schema to typebox schema matching the database models |

From c086389ec9836513d43fb57ffa53bf2b4b2e24f4 Mon Sep 17 00:00:00 2001
From: Alec Larson <1925840+aleclarson@users.noreply.github.com>
Date: Wed, 6 Nov 2024 05:33:17 -0500
Subject: [PATCH 292/369] Export Decode | Encode Functions (#1052)

---
 src/value/decode/decode.ts |  45 +++++++++++
 src/value/decode/index.ts  |  29 +++++++
 src/value/encode/encode.ts |  46 +++++++++++
 src/value/encode/index.ts  |  29 +++++++
 src/value/index.ts         |   2 +
 src/value/value/value.ts   | 153 +++++--------------------------------
 6 files changed, 168 insertions(+), 136 deletions(-)
 create mode 100644 src/value/decode/decode.ts
 create mode 100644 src/value/decode/index.ts
 create mode 100644 src/value/encode/encode.ts
 create mode 100644 src/value/encode/index.ts

diff --git a/src/value/decode/decode.ts b/src/value/decode/decode.ts
new file mode 100644
index 000000000..c1cc8a248
--- /dev/null
+++ b/src/value/decode/decode.ts
@@ -0,0 +1,45 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { HasTransform, TransformDecode, TransformDecodeCheckError } from '../transform/index'
+import { Check } from '../check/index'
+import { Errors } from '../../errors/index'
+
+import type { TSchema } from '../../type/schema/index'
+import type { StaticDecode } from '../../type/static/index'
+
+/** Decodes a value or throws if error */
+export function Decode<T extends TSchema, Static = StaticDecode<T>, Result extends Static = Static>(schema: T, references: TSchema[], value: unknown): Result
+/** Decodes a value or throws if error */
+export function Decode<T extends TSchema, Static = StaticDecode<T>, Result extends Static = Static>(schema: T, value: unknown): Result
+/** Decodes a value or throws if error */
+export function Decode(...args: any[]): any {
+  const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
+  if (!Check(schema, references, value)) throw new TransformDecodeCheckError(schema, value, Errors(schema, references, value).First()!)
+  return HasTransform(schema, references) ? TransformDecode(schema, references, value) : value
+}
diff --git a/src/value/decode/index.ts b/src/value/decode/index.ts
new file mode 100644
index 000000000..4372c79ae
--- /dev/null
+++ b/src/value/decode/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './decode'
diff --git a/src/value/encode/encode.ts b/src/value/encode/encode.ts
new file mode 100644
index 000000000..357effe66
--- /dev/null
+++ b/src/value/encode/encode.ts
@@ -0,0 +1,46 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { HasTransform, TransformEncode, TransformEncodeCheckError } from '../transform/index'
+import { Check } from '../check/index'
+import { Errors } from '../../errors/index'
+
+import type { TSchema } from '../../type/schema/index'
+import type { StaticEncode } from '../../type/static/index'
+
+/** Encodes a value or throws if error */
+export function Encode<T extends TSchema, Static = StaticEncode<T>, Result extends Static = Static>(schema: T, references: TSchema[], value: unknown): Result
+/** Encodes a value or throws if error */
+export function Encode<T extends TSchema, Static = StaticEncode<T>, Result extends Static = Static>(schema: T, value: unknown): Result
+/** Encodes a value or throws if error */
+export function Encode(...args: any[]): any {
+  const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
+  const encoded = HasTransform(schema, references) ? TransformEncode(schema, references, value) : value
+  if (!Check(schema, references, encoded)) throw new TransformEncodeCheckError(schema, encoded, Errors(schema, references, encoded).First()!)
+  return encoded
+}
diff --git a/src/value/encode/index.ts b/src/value/encode/index.ts
new file mode 100644
index 000000000..4b57d9b32
--- /dev/null
+++ b/src/value/encode/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './encode'
diff --git a/src/value/index.ts b/src/value/index.ts
index d422f87ca..a1b4e46f5 100644
--- a/src/value/index.ts
+++ b/src/value/index.ts
@@ -44,8 +44,10 @@ export * from './clean/index'
 export * from './clone/index'
 export * from './convert/index'
 export * from './create/index'
+export * from './decode/index'
 export * from './default/index'
 export * from './delta/index'
+export * from './encode/index'
 export * from './equal/index'
 export * from './hash/index'
 export * from './mutate/index'
diff --git a/src/value/value/value.ts b/src/value/value/value.ts
index 9838f89ab..ab0e06b3d 100644
--- a/src/value/value/value.ts
+++ b/src/value/value/value.ts
@@ -26,139 +26,20 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { HasTransform, TransformDecode, TransformEncode, TransformDecodeCheckError, TransformEncodeCheckError } from '../transform/index'
-import { Assert as AssertValue } from '../assert/index'
-import { Mutate as MutateValue, type Mutable } from '../mutate/index'
-import { Hash as HashValue } from '../hash/index'
-import { Equal as EqualValue } from '../equal/index'
-import { Cast as CastValue } from '../cast/index'
-import { Clone as CloneValue } from '../clone/index'
-import { Convert as ConvertValue } from '../convert/index'
-import { Create as CreateValue } from '../create/index'
-import { Clean as CleanValue } from '../clean/index'
-import { Check as CheckValue } from '../check/index'
-import { Parse as ParseValue } from '../parse/index'
-import { Default as DefaultValue } from '../default/index'
-import { Diff as DiffValue, Patch as PatchValue, Edit } from '../delta/index'
-import { Errors as ValueErrors, ValueErrorIterator } from '../../errors/index'
-
-import type { TSchema } from '../../type/schema/index'
-import type { Static, StaticDecode, StaticEncode } from '../../type/static/index'
-
-/** Asserts a value matches the given type or throws an `AssertError` if invalid. */
-export function Assert<T extends TSchema, R = Static<T>>(schema: T, references: TSchema[], value: unknown): asserts value is R
-/** Asserts a value matches the given type or throws an `AssertError` if invalid. */
-export function Assert<T extends TSchema, R = Static<T>>(schema: T, value: unknown): asserts value is R
-/** Asserts a value matches the given type or throws an `AssertError` if invalid. */
-export function Assert(...args: any[]): any {
-  return AssertValue.apply(AssertValue, args as any)
-}
-/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
-export function Cast<T extends TSchema>(schema: T, references: TSchema[], value: unknown): Static<T>
-/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
-export function Cast<T extends TSchema>(schema: T, value: unknown): Static<T>
-/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
-export function Cast(...args: any[]): any {
-  return CastValue.apply(CastValue, args as any)
-}
-/** Creates a value from the given type and references */
-export function Create<T extends TSchema>(schema: T, references: TSchema[]): Static<T>
-/** Creates a value from the given type */
-export function Create<T extends TSchema>(schema: T): Static<T>
-/** Creates a value from the given type */
-export function Create(...args: any[]): any {
-  return CreateValue.apply(CreateValue, args as any)
-}
-/** Returns true if the value matches the given type and references */
-export function Check<T extends TSchema>(schema: T, references: TSchema[], value: unknown): value is Static<T>
-/** Returns true if the value matches the given type */
-export function Check<T extends TSchema>(schema: T, value: unknown): value is Static<T>
-/** Returns true if the value matches the given type */
-export function Check(...args: any[]): any {
-  return CheckValue.apply(CheckValue, args as any)
-}
-/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export function Clean(schema: TSchema, references: TSchema[], value: unknown): unknown
-/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export function Clean(schema: TSchema, value: unknown): unknown
-/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export function Clean(...args: any[]): any {
-  return CleanValue.apply(CleanValue, args as any)
-}
-/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
-export function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown
-/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
-export function Convert(schema: TSchema, value: unknown): unknown
-/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
-export function Convert(...args: any[]): any {
-  return ConvertValue.apply(ConvertValue, args as any)
-}
-/** Returns a structural clone of the given value */
-export function Clone<T>(value: T): T {
-  return CloneValue(value)
-}
-/** Decodes a value or throws if error */
-export function Decode<T extends TSchema, Static = StaticDecode<T>, Result extends Static = Static>(schema: T, references: TSchema[], value: unknown): Result
-/** Decodes a value or throws if error */
-export function Decode<T extends TSchema, Static = StaticDecode<T>, Result extends Static = Static>(schema: T, value: unknown): Result
-/** Decodes a value or throws if error */
-export function Decode(...args: any[]): any {
-  const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
-  if (!Check(schema, references, value)) throw new TransformDecodeCheckError(schema, value, Errors(schema, references, value).First()!)
-  return HasTransform(schema, references) ? TransformDecode(schema, references, value) : value
-}
-/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export function Default(schema: TSchema, references: TSchema[], value: unknown): unknown
-/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export function Default(schema: TSchema, value: unknown): unknown
-/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export function Default(...args: any[]): any {
-  return DefaultValue.apply(DefaultValue, args as any)
-}
-/** Encodes a value or throws if error */
-export function Encode<T extends TSchema, Static = StaticEncode<T>, Result extends Static = Static>(schema: T, references: TSchema[], value: unknown): Result
-/** Encodes a value or throws if error */
-export function Encode<T extends TSchema, Static = StaticEncode<T>, Result extends Static = Static>(schema: T, value: unknown): Result
-/** Encodes a value or throws if error */
-export function Encode(...args: any[]): any {
-  const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
-  const encoded = HasTransform(schema, references) ? TransformEncode(schema, references, value) : value
-  if (!Check(schema, references, encoded)) throw new TransformEncodeCheckError(schema, encoded, Errors(schema, references, encoded).First()!)
-  return encoded
-}
-/** Parses a value or throws an `AssertError` if invalid. */
-export function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R
-/** Parses a value or throws an `AssertError` if invalid. */
-export function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R
-/** Parses a value or throws an `AssertError` if invalid. */
-export function Parse(...args: any[]): unknown {
-  return ParseValue.apply(ParseValue, args as any)
-}
-/** Returns an iterator for each error in this value. */
-export function Errors<T extends TSchema>(schema: T, references: TSchema[], value: unknown): ValueErrorIterator
-/** Returns an iterator for each error in this value. */
-export function Errors<T extends TSchema>(schema: T, value: unknown): ValueErrorIterator
-/** Returns an iterator for each error in this value. */
-export function Errors(...args: any[]): any {
-  return ValueErrors.apply(ValueErrors, args as any)
-}
-/** Returns true if left and right values are structurally equal */
-export function Equal<T>(left: T, right: unknown): right is T {
-  return EqualValue(left, right)
-}
-/** Returns edits to transform the current value into the next value */
-export function Diff(current: unknown, next: unknown): Edit[] {
-  return DiffValue(current, next)
-}
-/** Returns a FNV1A-64 non cryptographic hash of the given value */
-export function Hash(value: unknown): bigint {
-  return HashValue(value)
-}
-/** Returns a new value with edits applied to the given value */
-export function Patch<T = any>(current: unknown, edits: Edit[]): T {
-  return PatchValue(current, edits) as T
-}
-/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references. */
-export function Mutate(current: Mutable, next: Mutable): void {
-  MutateValue(current, next)
-}
+export { Errors, ValueErrorIterator } from '../../errors/index'
+
+export { Assert } from '../assert/index'
+export { Cast } from '../cast/index'
+export { Check } from '../check/index'
+export { Clean } from '../clean/index'
+export { Clone } from '../clone/index'
+export { Convert } from '../convert/index'
+export { Create } from '../create/index'
+export { Decode } from '../decode/index'
+export { Default } from '../default/index'
+export { Diff, Patch, Edit } from '../delta/index'
+export { Encode } from '../encode/index'
+export { Equal } from '../equal/index'
+export { Hash } from '../hash/index'
+export { Mutate, type Mutable } from '../mutate/index'
+export { Parse } from '../parse/index'

From 6ed1d9b5329b8c930aa852cb679e24bc1ed665ab Mon Sep 17 00:00:00 2001
From: Norbert Elter <72046715+itsyoboieltr@users.noreply.github.com>
Date: Wed, 6 Nov 2024 14:37:38 +0400
Subject: [PATCH 293/369] Export Object with Var (#1057)

---
 src/type/object/object.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/type/object/object.ts b/src/type/object/object.ts
index c8f2bb06f..965ab8295 100644
--- a/src/type/object/object.ts
+++ b/src/type/object/object.ts
@@ -98,4 +98,4 @@ function _Object<T extends TProperties>(properties: T, options?: ObjectOptions):
 }
 
 /** `[Json]` Creates an Object type */
-export const Object = _Object
+export var Object = _Object

From db54fac2ec6d576d964504d34915e0d629ce6517 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Wed, 6 Nov 2024 20:01:01 +0900
Subject: [PATCH 294/369] Revision 0.33.18 (#1060)

* Version

* ChangeLog
---
 changelog/0.33.0.md | 3 +++
 package-lock.json   | 4 ++--
 package.json        | 2 +-
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/changelog/0.33.0.md b/changelog/0.33.0.md
index e07a964ef..319866840 100644
--- a/changelog/0.33.0.md
+++ b/changelog/0.33.0.md
@@ -1,4 +1,7 @@
 ### 0.33.0
+- [Revision 0.33.18](https://github.com/sinclairzx81/typebox/pull/1060)
+  - [1052](https://github.com/sinclairzx81/typebox/pull/1052) Export the Encode | Decode functions directly. Refactoring on Value submodule.
+  - [1057](https://github.com/sinclairzx81/typebox/pull/1057) Export Object with var declaration to prevent global shadowing. Related Babel [Issue](https://github.com/babel/babel/issues/16943).
 - [Revision 0.33.17](https://github.com/sinclairzx81/typebox/pull/1042)
   - [1041](https://github.com/sinclairzx81/typebox/issues/1041) Avoid Exponentiation operator on Value.Hash
 - [Revision 0.33.16](https://github.com/sinclairzx81/typebox/pull/1015)
diff --git a/package-lock.json b/package-lock.json
index f05528cca..55faa5b00 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.17",
+  "version": "0.33.18",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.17",
+      "version": "0.33.18",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 505014947..4594b1dbb 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.17",
+  "version": "0.33.18",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

From e75af6daf0760af33412c8a55c5f0ba16c514b1d Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Thu, 7 Nov 2024 05:39:29 +0900
Subject: [PATCH 295/369] Revision 0.33.19 (#1061)

* Type Fix for Immutable Function

* Version
---
 changelog/0.33.0.md          |  2 ++
 package-lock.json            |  4 ++--
 package.json                 |  2 +-
 src/type/create/immutable.ts | 23 +++++++++++------------
 4 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/changelog/0.33.0.md b/changelog/0.33.0.md
index 319866840..ce6af4c58 100644
--- a/changelog/0.33.0.md
+++ b/changelog/0.33.0.md
@@ -1,4 +1,6 @@
 ### 0.33.0
+- [Revision 0.33.19](https://github.com/sinclairzx81/typebox/pull/1061)
+  - Preemptive fix for TypeScript 5.8.0-dev (Type Fix for Immutable Function)
 - [Revision 0.33.18](https://github.com/sinclairzx81/typebox/pull/1060)
   - [1052](https://github.com/sinclairzx81/typebox/pull/1052) Export the Encode | Decode functions directly. Refactoring on Value submodule.
   - [1057](https://github.com/sinclairzx81/typebox/pull/1057) Export Object with var declaration to prevent global shadowing. Related Babel [Issue](https://github.com/babel/babel/issues/16943).
diff --git a/package-lock.json b/package-lock.json
index 55faa5b00..8f97ebc7b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.18",
+  "version": "0.33.19",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.18",
+      "version": "0.33.19",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 4594b1dbb..e614d8232 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.18",
+  "version": "0.33.19",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/create/immutable.ts b/src/type/create/immutable.ts
index 92ff32e5d..d2069efe7 100644
--- a/src/type/create/immutable.ts
+++ b/src/type/create/immutable.ts
@@ -50,17 +50,16 @@ function ImmutableObject(value: Record<keyof any, unknown>) {
   }
   return globalThis.Object.freeze(result)
 }
+
 /** Specialized deep immutable value. Applies freeze recursively to the given value */
-export function Immutable<T>(value: T): T {
-  return ValueGuard.IsArray(value)
-    ? ImmutableArray(value)
-    : ValueGuard.IsDate(value)
-    ? ImmutableDate(value)
-    : ValueGuard.IsUint8Array(value)
-    ? ImmutableUint8Array(value)
-    : ValueGuard.IsRegExp(value)
-    ? ImmutableRegExp(value)
-    : ValueGuard.IsObject(value)
-    ? ImmutableObject(value)
-    : value
+// prettier-ignore
+export function Immutable(value: unknown): unknown {
+  return (
+    ValueGuard.IsArray(value) ? ImmutableArray(value) : 
+    ValueGuard.IsDate(value) ? ImmutableDate(value) : 
+    ValueGuard.IsUint8Array(value) ? ImmutableUint8Array(value) : 
+    ValueGuard.IsRegExp(value) ? ImmutableRegExp(value) : 
+    ValueGuard.IsObject(value) ? ImmutableObject(value) : 
+    value
+  )
 }

From 0144c8622c514525754d49ac2f531ae6f39e434c Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Thu, 7 Nov 2024 14:14:06 +0900
Subject: [PATCH 296/369] Revision 0.33.20 (#1062)

* Add Parse Infrastructure

* Version
---
 changelog/0.33.0.md                           |   2 +
 example/index.ts                              |  10 +-
 package-lock.json                             |   4 +-
 package.json                                  |   2 +-
 readme.md                                     |   9 +-
 src/index.ts                                  |   6 +-
 src/parse/index.ts                            |  29 +
 src/parse/parse.ts                            |  54 ++
 src/parse/parsebox/index.ts                   |  30 +
 src/parse/parsebox/runtime/guard.ts           |  96 +++
 src/parse/parsebox/runtime/index.ts           |  33 +
 src/parse/parsebox/runtime/module.ts          |  51 ++
 src/parse/parsebox/runtime/parse.ts           | 141 ++++
 src/parse/parsebox/runtime/token.ts           | 247 ++++++
 src/parse/parsebox/runtime/types.ts           | 169 ++++
 src/parse/parsebox/static/index.ts            |  31 +
 src/parse/parsebox/static/parse.ts            | 119 +++
 src/parse/parsebox/static/token.ts            | 213 +++++
 src/parse/parsebox/static/types.ts            | 100 +++
 src/parse/runtime.ts                          | 678 ++++++++++++++++
 src/parse/static.ts                           | 764 ++++++++++++++++++
 .../compression/module/typebox-parse.ts       |   3 +
 task/build/package/build.ts                   |   2 +-
 test/runtime/index.ts                         |   1 +
 test/runtime/parse/index.ts                   |   1 +
 test/runtime/parse/parse.ts                   | 389 +++++++++
 tsconfig.json                                 |   1 +
 27 files changed, 3175 insertions(+), 10 deletions(-)
 create mode 100644 src/parse/index.ts
 create mode 100644 src/parse/parse.ts
 create mode 100644 src/parse/parsebox/index.ts
 create mode 100644 src/parse/parsebox/runtime/guard.ts
 create mode 100644 src/parse/parsebox/runtime/index.ts
 create mode 100644 src/parse/parsebox/runtime/module.ts
 create mode 100644 src/parse/parsebox/runtime/parse.ts
 create mode 100644 src/parse/parsebox/runtime/token.ts
 create mode 100644 src/parse/parsebox/runtime/types.ts
 create mode 100644 src/parse/parsebox/static/index.ts
 create mode 100644 src/parse/parsebox/static/parse.ts
 create mode 100644 src/parse/parsebox/static/token.ts
 create mode 100644 src/parse/parsebox/static/types.ts
 create mode 100644 src/parse/runtime.ts
 create mode 100644 src/parse/static.ts
 create mode 100644 task/benchmark/compression/module/typebox-parse.ts
 create mode 100644 test/runtime/parse/index.ts
 create mode 100644 test/runtime/parse/parse.ts

diff --git a/changelog/0.33.0.md b/changelog/0.33.0.md
index ce6af4c58..f349e7495 100644
--- a/changelog/0.33.0.md
+++ b/changelog/0.33.0.md
@@ -1,4 +1,6 @@
 ### 0.33.0
+- [Revision 0.33.20](https://github.com/sinclairzx81/typebox/pull/1062)
+  - Add TypeScript Parsing Infrastructure. Add Parse API to top level import.
 - [Revision 0.33.19](https://github.com/sinclairzx81/typebox/pull/1061)
   - Preemptive fix for TypeScript 5.8.0-dev (Type Fix for Immutable Function)
 - [Revision 0.33.18](https://github.com/sinclairzx81/typebox/pull/1060)
diff --git a/example/index.ts b/example/index.ts
index ed52156bd..711d7d03e 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -1,7 +1,7 @@
 import { TypeSystem } from '@sinclair/typebox/system'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 import { Value, ValuePointer } from '@sinclair/typebox/value'
-import { Type, TypeGuard, Kind, Static, TSchema } from '@sinclair/typebox'
+import { Type, Parse, TypeGuard, Kind, Static, TSchema } from '@sinclair/typebox'
 
 // -----------------------------------------------------------
 // Create: Type
@@ -17,6 +17,14 @@ type T = Static<typeof T>
 
 console.log(T)
 
+// -----------------------------------------------------------
+// Parse: Type
+// -----------------------------------------------------------
+
+const S = Parse({ T }, `Partial<T>`)
+
+type S = Static<typeof S>
+
 // -----------------------------------------------------------
 // Create: Value
 // -----------------------------------------------------------
diff --git a/package-lock.json b/package-lock.json
index 8f97ebc7b..fae9cd780 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.19",
+  "version": "0.33.20",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.19",
+      "version": "0.33.20",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index e614d8232..e31bce433 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.19",
+  "version": "0.33.20",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 9590eeaf6..e62b15785 100644
--- a/readme.md
+++ b/readme.md
@@ -1760,11 +1760,12 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │ (index)              │ Compiled   │ Minified   │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '119.6 kb' │ ' 52.6 kb' │ '2.27 x'    │
-│ typebox/errors       │ ' 48.6 kb' │ ' 21.9 kb' │ '2.22 x'    │
+│ typebox/compiler     │ '119.8 kb' │ ' 52.6 kb' │ '2.28 x'    │
+│ typebox/errors       │ ' 74.4 kb' │ ' 33.1 kb' │ '2.25 x'    │
+│ typebox/parse        │ '115.3 kb' │ ' 48.3 kb' │ '2.39 x'    │
 │ typebox/system       │ '  7.4 kb' │ '  3.2 kb' │ '2.33 x'    │
-│ typebox/value        │ '157.8 kb' │ ' 66.6 kb' │ '2.37 x'    │
-│ typebox              │ ' 98.3 kb' │ ' 40.9 kb' │ '2.40 x'    │
+│ typebox/value        │ '157.2 kb' │ ' 66.1 kb' │ '2.38 x'    │
+│ typebox              │ '127.3 kb' │ ' 53.3 kb' │ '2.39 x'    │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/index.ts b/src/index.ts
index b88ad07ea..9f0429d85 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -39,6 +39,10 @@ export * from './type/registry/index'
 export * from './type/sets/index'
 export * from './type/symbols/index'
 // ------------------------------------------------------------------
+// Parse
+// ------------------------------------------------------------------
+export * from './parse/index'
+// ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
 export * from './type/any/index'
@@ -102,6 +106,6 @@ export * from './type/unknown/index'
 export * from './type/unsafe/index'
 export * from './type/void/index'
 // ------------------------------------------------------------------
-// Namespace
+// Type.*
 // ------------------------------------------------------------------
 export * from './type/type/index'
diff --git a/src/parse/index.ts b/src/parse/index.ts
new file mode 100644
index 000000000..d0a1a960c
--- /dev/null
+++ b/src/parse/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './parse'
diff --git a/src/parse/parse.ts b/src/parse/parse.ts
new file mode 100644
index 000000000..ef9928f2e
--- /dev/null
+++ b/src/parse/parse.ts
@@ -0,0 +1,54 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Static } from './parsebox/index'
+import { CreateType } from '../type/create/type'
+import { TSchema, SchemaOptions } from '../type/schema/index'
+import { Module } from './runtime'
+import { Type } from './static'
+
+/** `[Experimental]` Parses a TypeScript type annotation as an inferred TypeBox type */
+export function Parse<Code extends string, Context extends Record<PropertyKey, TSchema> = {}>(context: Context, code: Code, options?: SchemaOptions): Static.Parse<Type, Code, Context>[0]
+/** `[Experimental]` Parses a TypeScript type annotation as an inferred TypeBox type */
+export function Parse<Code extends string>(code: Code, options?: SchemaOptions): Static.Parse<Type, Code, {}>[0]
+/** `[Experimental]` Parses a TypeScript type annotation as an inferred TypeBox type */
+export function Parse(...args: any[]): never {
+  return ParseOnly.apply(null, args as never) as never
+}
+
+/** `[Experimental]` Parses a TypeScript type annotation as TSchema */
+export function ParseOnly<Code extends string, Context extends Record<PropertyKey, TSchema> = {}>(context: Context, code: Code, options?: SchemaOptions): TSchema | undefined
+/** `[Experimental]` Parses a TypeScript type annotation as TSchema */
+export function ParseOnly<Code extends string>(code: Code, options?: SchemaOptions): TSchema | undefined
+/** `[Experimental]` Parses a TypeScript type annotation as TSchema */
+export function ParseOnly(...args: any[]): TSchema | undefined {
+  const withContext = typeof args[0] === 'string' ? false : true
+  const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}]
+  const type = Module.Parse('Type', code, context)[0] as TSchema | undefined
+  return (type !== undefined ? CreateType(type, options) : undefined) as never
+}
diff --git a/src/parse/parsebox/index.ts b/src/parse/parsebox/index.ts
new file mode 100644
index 000000000..ec3432ded
--- /dev/null
+++ b/src/parse/parsebox/index.ts
@@ -0,0 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/parsebox
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * as Runtime from './runtime/index'
+export * as Static from './static/index'
diff --git a/src/parse/parsebox/runtime/guard.ts b/src/parse/parsebox/runtime/guard.ts
new file mode 100644
index 000000000..fa002e473
--- /dev/null
+++ b/src/parse/parsebox/runtime/guard.ts
@@ -0,0 +1,96 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/parsebox
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { IIdent, INumber, IRef, IString, IConst, ITuple, IUnion } from './types'
+
+// ------------------------------------------------------------------
+// Value Guard
+// ------------------------------------------------------------------
+// prettier-ignore
+function HasPropertyKey<Key extends PropertyKey>(value: Record<PropertyKey, unknown>, key: Key): value is Record<PropertyKey, unknown> & { [_ in Key]: unknown } {
+  return key in value
+}
+// prettier-ignore
+function IsObjectValue(value: unknown): value is Record<PropertyKey, unknown> {
+  return typeof value === 'object' && value !== null
+}
+// prettier-ignore
+function IsArrayValue(value: unknown): value is unknown[] {
+  return globalThis.Array.isArray(value)
+}
+// ------------------------------------------------------------------
+// Parser Guard
+// ------------------------------------------------------------------
+/** Returns true if the value is a Tuple Parser */
+// prettier-ignore
+export function IsTuple(value: unknown): value is ITuple {
+  return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Tuple' && HasPropertyKey(value, 'parsers') && IsArrayValue(value.parsers)
+}
+/** Returns true if the value is a Union Parser */
+// prettier-ignore
+export function IsUnion(value: unknown): value is IUnion {
+  return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Union' && HasPropertyKey(value, 'parsers') && IsArrayValue(value.parsers)
+}
+/** Returns true if the value is a Const Parser */
+// prettier-ignore
+export function IsConst(value: unknown): value is IConst {
+  return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Const' && HasPropertyKey(value, 'value') && typeof value.value === 'string'
+}
+/** Returns true if the value is a Ident Parser */
+// prettier-ignore
+export function IsIdent(value: unknown): value is IIdent {
+  return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Ident'
+}
+/** Returns true if the value is a Number Parser */
+// prettier-ignore
+export function IsNumber(value: unknown): value is INumber {
+  return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Number'
+}
+/** Returns true if the value is a Ref Parser */
+// prettier-ignore
+export function IsRef(value: unknown): value is IRef {
+  return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Ref' && HasPropertyKey(value, 'ref') && typeof value.ref === 'string'
+}
+/** Returns true if the value is a String Parser */
+// prettier-ignore
+export function IsString(value: unknown): value is IString {
+  return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'String' && HasPropertyKey(value, 'options') && IsArrayValue(value.options)
+}
+/** Returns true if the value is a Parser */
+// prettier-ignore
+export function IsParser(value: unknown) {
+  return (
+    IsTuple(value) ||
+    IsUnion(value) ||
+    IsConst(value) ||
+    IsIdent(value) ||
+    IsNumber(value) ||
+    IsRef(value) ||
+    IsString(value)
+  )
+}
diff --git a/src/parse/parsebox/runtime/index.ts b/src/parse/parsebox/runtime/index.ts
new file mode 100644
index 000000000..3c15d4624
--- /dev/null
+++ b/src/parse/parsebox/runtime/index.ts
@@ -0,0 +1,33 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/parsebox
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * as Guard from './guard'
+export * as Token from './token'
+export * from './types'
+export * from './module'
+export * from './parse'
diff --git a/src/parse/parsebox/runtime/module.ts b/src/parse/parsebox/runtime/module.ts
new file mode 100644
index 000000000..4384ce4f4
--- /dev/null
+++ b/src/parse/parsebox/runtime/module.ts
@@ -0,0 +1,51 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/parsebox
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from './types'
+import { Parse } from './parse'
+
+// ------------------------------------------------------------------
+// Module
+// ------------------------------------------------------------------
+// prettier-ignore
+export class Module<Properties extends Types.IModuleProperties = Types.IModuleProperties> {
+  constructor(private readonly properties: Properties) { }
+  
+  /** Parses using one of the parsers defined on this instance */
+  public Parse<Key extends keyof Properties>(key: Key, code: string, context: unknown): [] | [Types.StaticParser<Properties[Key]>, string]
+  /** Parses using one of the parsers defined on this instance */
+  public Parse<Key extends keyof Properties>(key: Key, code: string): [] | [Types.StaticParser<Properties[Key]>, string]
+  /** Parses using one of the parsers defined on this instance */
+  public Parse(...args: any[]): never {
+    const [key, code, context] = 
+      args.length === 3 ? [args[0], args[1], args[2]] :
+      args.length === 2 ? [args[0], args[1], undefined] :
+      (() => { throw Error('Invalid parse arguments') })()
+    return Parse(this.properties[key], this.properties, code, context) as never
+  }
+}
diff --git a/src/parse/parsebox/runtime/parse.ts b/src/parse/parsebox/runtime/parse.ts
new file mode 100644
index 000000000..73ecf2f75
--- /dev/null
+++ b/src/parse/parsebox/runtime/parse.ts
@@ -0,0 +1,141 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/parsebox
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Guard from './guard'
+import * as Token from './token'
+import * as Types from './types'
+
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseTuple<Parsers extends Types.IParser[], Properties extends Types.IModuleProperties>(parsers: [...Parsers], properties: Properties, code: string, context: unknown): [] | [unknown[], string] {
+  const buffer = [] as unknown[]
+  let rest = code
+  for(const parser of parsers) {
+    const result = ParseParser(parser, properties, rest, context)
+    if(result.length === 0) return []
+    buffer.push(result[0])
+    rest = result[1]
+  }
+  return [buffer, rest]
+}
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseUnion<Parsers extends Types.IParser[], Properties extends Types.IModuleProperties>(parsers: [...Parsers], properties: Properties, code: string, context: unknown): [] | [unknown, string] {
+  for(const parser of parsers) {
+    const result = ParseParser(parser, properties, code, context)
+    if(result.length === 0) continue 
+    return result
+  }
+  return []
+}
+// ------------------------------------------------------------------
+// Const
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseConst<Value extends string>(value: Value, code: string, context: unknown): [] | [Value, string] {
+  return Token.Const(value, code) as never
+}
+// ------------------------------------------------------------------
+// Ref
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseRef<Ref extends string, Properties extends Types.IModuleProperties>(ref: Ref, properties: Properties, code: string, context: unknown): [] | [string, string] {
+  const parser = properties[ref]
+  if(!Guard.IsParser(parser))  throw Error(`Cannot dereference parser '${ref}'`)
+  return ParseParser(parser, properties, code, context) as never
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseString(options: string[], code: string, _context: unknown): [] | [string, string] {
+  return Token.String(options, code)
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseNumber(code: string, _context: unknown): [] | [string, string] {
+  return Token.Number(code)
+}
+// ------------------------------------------------------------------
+// Ident
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseIdent(code: string, _context: unknown): [] | [string, string] {
+  return Token.Ident(code)
+}
+// ------------------------------------------------------------------
+// Parser
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseParser<Parser extends Types.IParser>(parser: Parser, properties: Types.IModuleProperties, code: string, context: unknown): [] | [Types.StaticParser<Parser>, string] {
+  const result = (
+    Guard.IsTuple(parser) ? ParseTuple(parser.parsers, properties, code, context) :
+    Guard.IsUnion(parser) ? ParseUnion(parser.parsers, properties, code, context) :
+    Guard.IsConst(parser) ? ParseConst(parser.value, code, context) :
+    Guard.IsRef(parser) ? ParseRef(parser.ref, properties, code, context) :
+    Guard.IsString(parser) ? ParseString(parser.options, code, context) :
+    Guard.IsIdent(parser) ? ParseIdent(code, context) :
+    Guard.IsNumber(parser) ? ParseNumber(code, context) :
+    []
+  )
+  return (
+    result.length === 2
+    ? [parser.mapping(result[0], context), result[1]]
+    : result
+  ) as never
+}
+// ------------------------------------------------------------------
+// Parse
+// ------------------------------------------------------------------
+/** Parses content using the given parser */
+// prettier-ignore
+export function Parse<Parser extends Types.IParser>(parser: Parser, properties: Types.IModuleProperties, code: string, context: unknown): [] | [Types.StaticParser<Parser>, string]
+/** Parses content using the given parser */
+// prettier-ignore
+export function Parse<Parser extends Types.IParser>(parser: Parser, properties: Types.IModuleProperties, code: string): [] | [Types.StaticParser<Parser>, string]
+/** Parses content using the given parser */
+// prettier-ignore
+export function Parse<Parser extends Types.IParser>(parser: Parser, code: string, context: unknown): [] | [Types.StaticParser<Parser>, string]
+/** Parses content using the given parser */
+// prettier-ignore
+export function Parse<Parser extends Types.IParser>(parser: Parser, code: string): [] | [Types.StaticParser<Parser>, string]
+/** Parses content using the given parser */
+// prettier-ignore
+export function Parse(...args: any[]): never {
+  const withProperties = typeof args[1] === 'string' ? false : true
+  const [parser, properties, code, context] = withProperties 
+    ? [args[0], args[1], args[2], args[3]]
+    : [args[0], {}, args[1], args[2]]
+  return ParseParser(parser, properties, code, context) as never
+}
diff --git a/src/parse/parsebox/runtime/token.ts b/src/parse/parsebox/runtime/token.ts
new file mode 100644
index 000000000..6ad9f4927
--- /dev/null
+++ b/src/parse/parsebox/runtime/token.ts
@@ -0,0 +1,247 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/parsebox
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+// ------------------------------------------------------------------
+// Chars
+// ------------------------------------------------------------------
+// prettier-ignore
+namespace Chars {
+  /** Returns true if the char code is a whitespace */
+  export function IsWhitespace(value: number): boolean {
+    return value === 32
+  }
+  /** Returns true if the char code is a newline */
+  export function IsNewline(value: number): boolean {
+    return value === 10
+  }
+  /** Returns true if the char code is a alpha  */
+  export function IsAlpha(value: number): boolean {
+    return (
+      (value >= 65 && value <= 90) || // A-Z 
+      (value >= 97 && value <= 122)   // a-z
+    )
+  }
+  /** Returns true if the char code is zero */
+  export function IsZero(value: number): boolean {
+    return value === 48
+  }
+  /** Returns true if the char code is non-zero */
+  export function IsNonZero(value: number): boolean {
+    return value >= 49 && value <= 57
+  }
+  /** Returns true if the char code is a digit */
+  export function IsDigit(value: number): boolean {
+    return (
+      IsNonZero(value) ||
+      IsZero(value)
+    )
+  }
+  /** Returns true if the char code is a dot */
+  export function IsDot(value: number): boolean {
+    return value === 46
+  }
+  /** Returns true if this char code is a underscore */
+  export function IsUnderscore(value: unknown): boolean {
+    return value === 95
+  }
+  /** Returns true if this char code is a dollar sign */
+  export function IsDollarSign(value: unknown): boolean {
+    return value === 36
+  }
+}
+
+// ------------------------------------------------------------------
+// Trim
+// ------------------------------------------------------------------
+// prettier-ignore
+namespace Trim {
+  /** Trims Whitespace and retains Newline, Tabspaces, etc. */
+  export function TrimWhitespaceOnly(code: string): string {
+    for (let i = 0; i < code.length; i++) {
+      if (Chars.IsWhitespace(code.charCodeAt(i))) continue
+      return code.slice(i)
+    }
+    return code
+  }
+  /** Trims Whitespace including Newline, Tabspaces, etc. */
+  export function TrimAll(code: string): string {
+    return code.trimStart()
+  }
+}
+// ------------------------------------------------------------------
+// Const
+// ------------------------------------------------------------------
+/** Checks the value matches the next string  */
+// prettier-ignore
+function NextTokenCheck(value: string, code: string): boolean {
+  if (value.length > code.length) return false
+  for (let i = 0; i < value.length; i++) {
+    if (value.charCodeAt(i) !== code.charCodeAt(i)) return false
+  }
+  return true
+}
+/** Gets the next constant string value or empty if no match */
+// prettier-ignore
+function NextConst(value: string, code: string, ): [] | [string, string] {
+  return NextTokenCheck(value, code)
+    ? [code.slice(0, value.length), code.slice(value.length)]
+    : []
+}
+/** Takes the next constant string value skipping any whitespace */
+// prettier-ignore
+export function Const(value: string, code: string): [] | [string, string] {
+  if(value.length === 0) return ['', code]
+  const char_0 = value.charCodeAt(0)
+  return (
+    Chars.IsNewline(char_0) ? NextConst(value, Trim.TrimWhitespaceOnly(code)) :
+    Chars.IsWhitespace(char_0) ? NextConst(value, code) :
+    NextConst(value, Trim.TrimAll(code))
+  )
+}
+// ------------------------------------------------------------------
+// Ident
+// ------------------------------------------------------------------
+// prettier-ignore
+function IdentIsFirst(char: number) {
+  return (
+    Chars.IsAlpha(char) ||
+    Chars.IsDollarSign(char) ||
+    Chars.IsUnderscore(char)
+  )
+}
+// prettier-ignore
+function IdentIsRest(char: number) {
+  return (
+    Chars.IsAlpha(char) ||
+    Chars.IsDigit(char) ||
+    Chars.IsDollarSign(char) ||
+    Chars.IsUnderscore(char)
+  )
+}
+// prettier-ignore
+function NextIdent(code: string): [] | [string, string] {
+  if (!IdentIsFirst(code.charCodeAt(0))) return []
+  for (let i = 1; i < code.length; i++) {
+    const char = code.charCodeAt(i)
+    if (IdentIsRest(char)) continue
+    const slice = code.slice(0, i)
+    const rest = code.slice(i)
+    return [slice, rest]
+  }
+  return [code, '']
+}
+/** Scans for the next Ident token */
+// prettier-ignore
+export function Ident(code: string): [] | [string, string] {
+  return NextIdent(Trim.TrimAll(code))
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+/** Checks that the next number is not a leading zero */
+// prettier-ignore
+function NumberLeadingZeroCheck(code: string, index: number) {
+  const char_0 = code.charCodeAt(index + 0)
+  const char_1 = code.charCodeAt(index + 1)
+  return (
+    ( 
+      // 1-9
+      Chars.IsNonZero(char_0)
+    ) || ( 
+      // 0
+      Chars.IsZero(char_0) &&
+      !Chars.IsDigit(char_1)
+    )  || ( 
+      // 0.
+      Chars.IsZero(char_0) &&
+      Chars.IsDot(char_1)
+    ) || ( 
+      // .0
+      Chars.IsDot(char_0) &&
+      Chars.IsDigit(char_1)
+    )
+  )
+}
+/** Gets the next number token */
+// prettier-ignore
+function NextNumber(code: string): [] | [string, string] {
+  const negated = code.charAt(0) === '-'
+  const index = negated ? 1 : 0
+  if (!NumberLeadingZeroCheck(code, index)) {
+    return []
+  }
+  const dash = negated ? '-' : ''
+  let hasDot = false
+  for (let i = index; i < code.length; i++) {
+    const char_i = code.charCodeAt(i)
+    if (Chars.IsDigit(char_i)) {
+      continue
+    }
+    if (Chars.IsDot(char_i)) {
+      if (hasDot) {
+        const slice = code.slice(index, i)
+        const rest = code.slice(i)
+        return [`${dash}${slice}`, rest]
+      }
+      hasDot = true
+      continue
+    }
+    const slice = code.slice(index, i)
+    const rest = code.slice(i)
+    return [`${dash}${slice}`, rest]
+  }
+  return [code, '']
+}
+/** Scans for the next number token */
+// prettier-ignore
+export function Number(code: string) {
+  return NextNumber(Trim.TrimAll(code))
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+// prettier-ignore
+function NextString(options: string[], code: string): [] | [string, string] {
+  const first = code.charAt(0)
+  if(!options.includes(first)) return []
+  const quote = first
+  for(let i = 1; i < code.length; i++) {
+    const char = code.charAt(i)
+    if(char === quote) {
+      const slice = code.slice(1, i)
+      const rest = code.slice(i + 1)
+      return [slice, rest]
+    }
+  }
+  return []
+}
+/** Scans the next Literal String value */
+// prettier-ignore
+export function String(options: string[], code: string) {
+  return NextString(options, Trim.TrimAll(code))
+}
diff --git a/src/parse/parsebox/runtime/types.ts b/src/parse/parsebox/runtime/types.ts
new file mode 100644
index 000000000..53dd047d0
--- /dev/null
+++ b/src/parse/parsebox/runtime/types.ts
@@ -0,0 +1,169 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/parsebox
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export type IModuleProperties = Record<PropertyKey, IParser>
+
+// ------------------------------------------------------------------
+// Static
+// ------------------------------------------------------------------
+
+/** Infers the Output Parameter for a Parser */
+export type StaticParser<Parser extends IParser> = Parser extends IParser<infer Output extends unknown> ? Output : unknown
+
+// ------------------------------------------------------------------
+// Mapping
+// ------------------------------------------------------------------
+export type IMapping<Input extends unknown = any, Output extends unknown = unknown> = (input: Input, context: any) => Output
+
+/** Maps input to output. This is the default Mapping */
+export const Identity = (value: unknown) => value
+
+/** Maps the output as the given parameter T */
+export const As =
+  <T>(mapping: T): ((value: unknown) => T) =>
+  (_: unknown) =>
+    mapping
+
+// ------------------------------------------------------------------
+// Parser
+// ------------------------------------------------------------------
+export interface IParser<Output extends unknown = unknown> {
+  type: string
+  mapping: IMapping<any, Output>
+}
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+export type TupleParameter<Parsers extends IParser[], Result extends unknown[] = []> = Parsers extends [infer L extends IParser, ...infer R extends IParser[]] ? TupleParameter<R, [...Result, StaticParser<L>]> : Result
+export interface ITuple<Output extends unknown = unknown> extends IParser<Output> {
+  type: 'Tuple'
+  parsers: IParser[]
+}
+/** Creates a Tuple parser */
+export function Tuple<Parsers extends IParser[], Mapping extends IMapping = IMapping<TupleParameter<Parsers>>>(parsers: [...Parsers], mapping: Mapping): ITuple<ReturnType<Mapping>>
+/** Creates a Tuple parser */
+export function Tuple<Parsers extends IParser[]>(parsers: [...Parsers]): ITuple<TupleParameter<Parsers>>
+export function Tuple(...args: unknown[]): never {
+  const [parsers, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
+  return { type: 'Tuple', parsers, mapping } as never
+}
+
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+export type UnionParameter<Parsers extends IParser[], Result extends unknown = never> = Parsers extends [infer L extends IParser, ...infer R extends IParser[]] ? UnionParameter<R, Result | StaticParser<L>> : Result
+export interface IUnion<Output extends unknown = unknown> extends IParser<Output> {
+  type: 'Union'
+  parsers: IParser[]
+}
+/** Creates a Union parser */
+export function Union<Parsers extends IParser[], Mapping extends IMapping = IMapping<UnionParameter<Parsers>>>(parsers: [...Parsers], mapping: Mapping): IUnion<ReturnType<Mapping>>
+/** Creates a Union parser */
+export function Union<Parsers extends IParser[]>(parsers: [...Parsers]): IUnion<UnionParameter<Parsers>>
+export function Union(...args: unknown[]): never {
+  const [parsers, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
+  return { type: 'Union', parsers, mapping } as never
+}
+
+// ------------------------------------------------------------------
+// Token
+// ------------------------------------------------------------------
+export interface IConst<Output extends unknown = unknown> extends IParser<Output> {
+  type: 'Const'
+  value: string
+}
+/** Creates a Const parser */
+export function Const<Value extends string, Mapping extends IMapping<Value>>(value: Value, mapping: Mapping): IConst<ReturnType<Mapping>>
+/** Creates a Const parser */
+export function Const<Value extends string>(value: Value): IConst<Value>
+export function Const(...args: unknown[]): never {
+  const [value, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
+  return { type: 'Const', value, mapping } as never
+}
+
+// ------------------------------------------------------------------
+// Ref
+// ------------------------------------------------------------------
+export interface IRef<Output extends unknown = unknown> extends IParser<Output> {
+  type: 'Ref'
+  ref: string
+}
+/** Creates a Ref parser */
+export function Ref<Type extends unknown, Mapping extends IMapping<Type>>(ref: string, mapping: Mapping): IRef<ReturnType<Mapping>>
+/** Creates a Ref parser */
+export function Ref<Type extends unknown>(ref: string): IRef<Type>
+export function Ref(...args: unknown[]): never {
+  const [ref, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
+  return { type: 'Ref', ref, mapping } as never
+}
+
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+export interface IString<Output extends unknown = unknown> extends IParser<Output> {
+  type: 'String'
+  options: string[]
+}
+/** Creates a String Parser. Options are an array of permissable quote characters */
+export function String<Mapping extends IMapping<string>>(options: string[], mapping: Mapping): IString<ReturnType<Mapping>>
+/** Creates a String Parser. Options are an array of permissable quote characters */
+export function String(options: string[]): IString<string>
+export function String(...params: unknown[]): never {
+  const [options, mapping] = params.length === 2 ? [params[0], params[1]] : [params[0], Identity]
+  return { type: 'String', options, mapping } as never
+}
+
+// ------------------------------------------------------------------
+// Ident
+// ------------------------------------------------------------------
+export interface IIdent<Output extends unknown = unknown> extends IParser<Output> {
+  type: 'Ident'
+}
+/** Creates an Ident parser */
+export function Ident<Mapping extends IMapping<string>>(mapping: Mapping): IIdent<ReturnType<Mapping>>
+/** Creates an Ident parser */
+export function Ident(): IIdent<string>
+export function Ident(...params: unknown[]): never {
+  const mapping = params.length === 1 ? params[0] : Identity
+  return { type: 'Ident', mapping } as never
+}
+
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+export interface INumber<Output extends unknown = unknown> extends IParser<Output> {
+  type: 'Number'
+}
+/** Creates a Number parser */
+export function Number<Mapping extends IMapping<string>>(mapping: Mapping): INumber<ReturnType<Mapping>>
+/** Creates a Number parser */
+export function Number(): INumber<string>
+export function Number(...params: unknown[]): never {
+  const mapping = params.length === 1 ? params[0] : Identity
+  return { type: 'Number', mapping } as never
+}
diff --git a/src/parse/parsebox/static/index.ts b/src/parse/parsebox/static/index.ts
new file mode 100644
index 000000000..3eb58ee18
--- /dev/null
+++ b/src/parse/parsebox/static/index.ts
@@ -0,0 +1,31 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/parsebox
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * as Token from './token'
+export * from './parse'
+export * from './types'
diff --git a/src/parse/parsebox/static/parse.ts b/src/parse/parsebox/static/parse.ts
new file mode 100644
index 000000000..f4fc12e1e
--- /dev/null
+++ b/src/parse/parsebox/static/parse.ts
@@ -0,0 +1,119 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/parsebox
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Tokens from './token'
+import * as Types from './types'
+
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+type TupleParser<Parsers extends Types.IParser[], Code extends string, Context extends unknown, Result extends unknown[] = []> = (
+  Parsers extends [infer Left extends Types.IParser, ...infer Right extends Types.IParser[]]
+    ? Parse<Left, Code, Context> extends [infer Value extends unknown, infer Rest extends string]
+      ? TupleParser<Right, Rest, Context, [...Result, Value]>
+      : []
+    : [Result, Code]
+)
+
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// prettier-ignore
+type UnionParser<Parsers extends Types.IParser[], Code extends string, Context extends unknown> = (
+  Parsers extends [infer Left extends Types.IParser, ...infer Right extends Types.IParser[]]
+    ? Parse<Left, Code, Context> extends [infer Value extends unknown, infer Rest extends string]
+      ? [Value, Rest]
+      : UnionParser<Right, Code, Context>
+    : []
+)
+
+// ------------------------------------------------------------------
+// Const
+// ------------------------------------------------------------------
+// prettier-ignore
+type ConstParser<Value extends string, Code extends string, _Context extends unknown> = (
+  Tokens.Const<Value, Code> extends [infer Match extends Value, infer Rest extends string]
+    ? [Match, Rest]
+    : []
+)
+
+// ------------------------------------------------------------------
+// Ident
+// ------------------------------------------------------------------
+// prettier-ignore
+type IdentParser<Code extends string, _Context extends unknown> = (
+  Tokens.Ident<Code> extends [infer Match extends string, infer Rest extends string]
+    ? [Match, Rest]
+    : []
+)
+
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+// prettier-ignore
+type NumberParser<Code extends string, _Context extends unknown> = (
+  Tokens.Number<Code> extends [infer Match extends string, infer Rest extends string]
+    ? [Match, Rest]
+    : []
+)
+
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+// prettier-ignore
+type StringParser<Options extends string[], Code extends string, _Context extends unknown> = (
+  Tokens.String<Options, Code> extends [infer Match extends string, infer Rest extends string]
+    ? [Match, Rest]
+    : []
+)
+
+// ------------------------------------------------------------------
+// Parse
+// ------------------------------------------------------------------
+// prettier-ignore
+type ParseCode<Type extends Types.IParser, Code extends string, Context extends unknown = unknown> = (
+  Type extends Types.Union<infer S extends Types.IParser[]> ? UnionParser<S, Code, Context> :
+  Type extends Types.Tuple<infer S extends Types.IParser[]> ? TupleParser<S, Code, Context> :
+  Type extends Types.Const<infer S extends string> ? ConstParser<S, Code, Context> :
+  Type extends Types.String<infer S extends string[]> ? StringParser<S, Code, Context> :
+  Type extends Types.Ident ? IdentParser<Code, Context> :
+  Type extends Types.Number ? NumberParser<Code, Context> :
+  []
+)
+// prettier-ignore
+type ParseMapping<Parser extends Types.IParser, Result extends unknown, Context extends unknown = unknown> = (
+  (Parser['mapping'] & { input: Result, context: Context })['output']
+)
+/** Parses code with the given parser */
+// prettier-ignore
+export type Parse<Type extends Types.IParser, Code extends string, Context extends unknown = unknown> = (
+  ParseCode<Type, Code, Context> extends [infer L extends unknown, infer R extends string]
+    ? [ParseMapping<Type, L, Context>, R]
+    : []
+)
diff --git a/src/parse/parsebox/static/token.ts b/src/parse/parsebox/static/token.ts
new file mode 100644
index 000000000..8bfdf19dd
--- /dev/null
+++ b/src/parse/parsebox/static/token.ts
@@ -0,0 +1,213 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/parsebox
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+// ------------------------------------------------------------------
+// Chars
+// ------------------------------------------------------------------
+// prettier-ignore
+namespace Chars {
+  export type Empty = ''
+  export type Space = ' '
+  export type Newline = '\n'
+  export type Dot = '.'
+  export type Hyphen = '-'
+  export type Digit = [
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
+  ]
+  export type Alpha = [
+    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 
+    'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 
+    'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 
+    'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 
+    'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 
+    'Y', 'Z'
+  ]
+}
+
+// ------------------------------------------------------------------
+// Trim
+// ------------------------------------------------------------------
+// prettier-ignore
+namespace Trim {
+  // ------------------------------------------------------------------
+  // Whitespace Filters
+  // ------------------------------------------------------------------
+  type W9 = `${W8}${W8}` // 512
+  type W8 = `${W7}${W7}` // 256
+  type W7 = `${W6}${W6}` // 128
+  type W6 = `${W5}${W5}` // 64
+  type W5 = `${W4}${W4}` // 32
+  type W4 = `${W3}${W3}` // 16
+  type W3 = `${W2}${W2}` // 8
+  type W2 = `${W1}${W1}` // 4
+  type W1 = `${W0}${W0}` // 2
+  type W0 = ` `          // 1
+  // ------------------------------------------------------------------
+  // TrimWhitespace
+  // ------------------------------------------------------------------
+  /** Trims whitespace only */
+  export type TrimWhitespace<Code extends string> = (
+    Code extends `${W4}${infer Rest extends string}` ? TrimWhitespace<Rest> :
+    Code extends `${W3}${infer Rest extends string}` ? TrimWhitespace<Rest> :
+    Code extends `${W1}${infer Rest extends string}` ? TrimWhitespace<Rest> :
+    Code extends `${W0}${infer Rest extends string}` ? TrimWhitespace<Rest> :
+    Code
+  )
+  // ------------------------------------------------------------------
+  // Trim
+  // ------------------------------------------------------------------
+  /** Trims Whitespace and Newline */
+  export type TrimAll<Code extends string> = (
+    Code extends `${W4}${infer Rest extends string}` ? TrimAll<Rest> :
+    Code extends `${W3}${infer Rest extends string}` ? TrimAll<Rest> :
+    Code extends `${W1}${infer Rest extends string}` ? TrimAll<Rest> :
+    Code extends `${W0}${infer Rest extends string}` ? TrimAll<Rest> :
+    Code extends `${Chars.Newline}${infer Rest extends string}` ? TrimAll<Rest> :
+    Code
+  )
+}
+
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+/** Scans for the next match union */
+// prettier-ignore
+type NextUnion<Variants extends string[], Code extends string> = (
+  Variants extends [infer Variant extends string, ...infer Rest1 extends string[]]
+    ? NextConst<Variant, Code> extends [infer Match extends string, infer Rest2 extends string]
+      ? [Match, Rest2]
+      : NextUnion<Rest1, Code>
+    : []
+)
+
+// ------------------------------------------------------------------
+// Const
+// ------------------------------------------------------------------
+// prettier-ignore
+type NextConst<Value extends string, Code extends string> = (
+  Code extends `${Value}${infer Rest extends string}` 
+    ? [Value, Rest] 
+    : []
+)
+/** Scans for the next constant value */
+// prettier-ignore
+export type Const<Value extends string, Code extends string> = (
+  Value extends '' ? ['', Code] :
+  Value extends `${infer First extends string}${string}`
+    ? (
+      First extends Chars.Newline ? NextConst<Value, Trim.TrimWhitespace<Code>> :
+      First extends Chars.Space ? NextConst<Value, Code> :
+      NextConst<Value, Trim.TrimAll<Code>>
+    ) : never
+)
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+// prettier-ignore
+type NextNumberNegate<Code extends string> = (
+  Code extends `${Chars.Hyphen}${infer Rest extends string}` 
+    ? [Chars.Hyphen, Rest]
+    : [Chars.Empty, Code]
+)
+// prettier-ignore
+type NextNumberZeroCheck<Code extends string> = (
+  Code extends `0${infer Rest}`
+    ? NextUnion<Chars.Digit, Rest> extends [string, string] ? false : true
+    : true
+)
+// prettier-ignore
+type NextNumberScan<Code extends string, HasDecimal extends boolean = false, Result extends string = Chars.Empty> = (
+  NextUnion<[...Chars.Digit, Chars.Dot], Code> extends [infer Char extends string, infer Rest extends string]
+    ? Char extends Chars.Dot
+      ? HasDecimal extends false
+        ? NextNumberScan<Rest, true, `${Result}${Char}`>
+        : [Result, `.${Rest}`]
+      : NextNumberScan<Rest, HasDecimal, `${Result}${Char}`>
+    : [Result, Code]
+)
+// prettier-ignore
+export type NextNumber<Code extends string> = (
+  NextNumberNegate<Code> extends [infer Negate extends string, infer Rest extends string]
+    ? NextNumberZeroCheck<Rest> extends true 
+      ? NextNumberScan<Rest> extends [infer Number extends string, infer Rest2 extends string]
+        ? Number extends Chars.Empty 
+          ? [] 
+          : [`${Negate}${Number}`, Rest2]
+        : []
+      : []
+    : []
+)
+/** Scans for the next literal number */
+export type Number<Code extends string> = NextNumber<Trim.TrimAll<Code>>
+
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+type NextStringQuote<Options extends string[], Code extends string> = NextUnion<Options, Code>
+// prettier-ignore
+type NextStringBody<Code extends string, Quote extends string, Result extends string = Chars.Empty> = (
+  Code extends `${infer Char extends string}${infer Rest extends string}`
+    ? Char extends Quote
+      ? [Result, Rest]
+      : NextStringBody<Rest, Quote, `${Result}${Char}`>
+    : []
+)
+// prettier-ignore
+type NextString<Options extends string[], Code extends string> = (
+  NextStringQuote<Options, Code> extends [infer Quote extends string, infer Rest extends string]
+    ? NextStringBody<Rest, Quote> extends [infer String extends string, infer Rest extends string]
+      ? [String, Rest]
+      : []
+    : []
+)
+/** Scans for the next literal string */
+export type String<Options extends string[], Code extends string> = NextString<Options, Trim.TrimAll<Code>>
+
+// ------------------------------------------------------------------
+// Ident
+// ------------------------------------------------------------------
+type IdentLeft = [...Chars.Alpha, '_', '$'] // permissable first characters
+type IdentRight = [...Chars.Digit, ...IdentLeft] // permissible subsequent characters
+
+// prettier-ignore
+type NextIdentScan<Code extends string, Result extends string = Chars.Empty> = (
+  NextUnion<IdentRight, Code> extends [infer Char extends string, infer Rest extends string]
+    ? NextIdentScan<Rest, `${Result}${Char}`>
+    : [Result, Code]
+)
+// prettier-ignore
+type NextIdent<Code extends string> = (
+  NextUnion<IdentLeft, Code> extends [infer Left extends string, infer Rest1 extends string]
+    ? NextIdentScan<Rest1> extends [infer Right extends string, infer Rest2 extends string]
+      ? [`${Left}${Right}`, Rest2]
+      : []
+    : []
+)
+
+/** Scans for the next Ident */
+export type Ident<Code extends string> = NextIdent<Trim.TrimAll<Code>>
diff --git a/src/parse/parsebox/static/types.ts b/src/parse/parsebox/static/types.ts
new file mode 100644
index 000000000..534125505
--- /dev/null
+++ b/src/parse/parsebox/static/types.ts
@@ -0,0 +1,100 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/parse
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+// ------------------------------------------------------------------
+// Mapping
+// ------------------------------------------------------------------
+export interface IMapping {
+  context: unknown
+  input: unknown
+  output: unknown
+}
+/** Maps input to output. This is the default Mapping */
+export interface Identity extends IMapping {
+  output: this['input']
+}
+/** Maps the output as the given parameter T */
+export interface As<T> extends IMapping {
+  output: T
+}
+// ------------------------------------------------------------------
+// Parser
+// ------------------------------------------------------------------
+/** Base type Parser implemented by all other parsers */
+export interface IParser<Mapping extends IMapping = Identity> {
+  type: string
+  mapping: Mapping
+}
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+/** Creates a Tuple Parser */
+export interface Tuple<Parsers extends IParser[] = [], Mapping extends IMapping = Identity> extends IParser<Mapping> {
+  type: 'Tuple'
+  parsers: [...Parsers]
+}
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+/** Creates a Union Parser */
+export interface Union<Parsers extends IParser[] = [], Mapping extends IMapping = Identity> extends IParser<Mapping> {
+  type: 'Union'
+  parsers: [...Parsers]
+}
+// ------------------------------------------------------------------
+// Const
+// ------------------------------------------------------------------
+/** Creates a Const Parser */
+export interface Const<Value extends string = string, Mapping extends IMapping = Identity> extends IParser<Mapping> {
+  type: 'Const'
+  value: Value
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+/** Creates a String Parser. Options are an array of permissable quote characters */
+export interface String<Options extends string[], Mapping extends IMapping = Identity> extends IParser<Mapping> {
+  type: 'String'
+  quote: Options
+}
+// ------------------------------------------------------------------
+// Ident
+// ------------------------------------------------------------------
+/** Creates an Ident Parser. */
+// prettier-ignore
+export interface Ident<Mapping extends IMapping = Identity> extends IParser<Mapping> {
+  type: 'Ident'
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+/** Creates a Number Parser. */
+// prettier-ignore
+export interface Number<Mapping extends IMapping = Identity> extends IParser<Mapping> {
+  type: 'Number'
+}
diff --git a/src/parse/runtime.ts b/src/parse/runtime.ts
new file mode 100644
index 000000000..de018ed65
--- /dev/null
+++ b/src/parse/runtime.ts
@@ -0,0 +1,678 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Runtime } from './parsebox/index'
+import * as Types from '../type/index'
+
+// ------------------------------------------------------------------
+// Tokens
+// ------------------------------------------------------------------
+const Newline = '\n'
+const LBracket = '['
+const RBracket = ']'
+const LParen = '('
+const RParen = ')'
+const LBrace = '{'
+const RBrace = '}'
+const LAngle = '<'
+const RAngle = '>'
+const Question = '?'
+const Colon = ':'
+const Comma = ','
+const SemiColon = ';'
+const SingleQuote = "'"
+const DoubleQuote = '"'
+const Tilde = '`'
+
+// ------------------------------------------------------------------
+// DestructureRight
+// ------------------------------------------------------------------
+// prettier-ignore
+function DestructureRight<T>(values: T[]): [T[], T | undefined] {
+  return (values.length > 0)
+    ? [values.slice(0, values.length - 1), values[values.length - 1]]
+    : [values, undefined]
+}
+// ------------------------------------------------------------------
+// Reference
+// ------------------------------------------------------------------
+// prettier-ignore
+const Reference = Runtime.Ident((value, context: Record<PropertyKey, Types.TSchema>) => {
+  return value in context ? context[value] : Types.Ref(value)
+})
+
+// ------------------------------------------------------------------
+// Literal
+// ------------------------------------------------------------------
+// prettier-ignore
+const Literal = Runtime.Union([
+  Runtime.Union([Runtime.Const('true'), Runtime.Const('false')], value => Types.Literal(value === 'true')),
+  Runtime.Number(value => Types.Literal(parseFloat(value))),
+  Runtime.String([SingleQuote, DoubleQuote, Tilde], value => Types.Literal(value))
+])
+
+// ------------------------------------------------------------------
+// Keyword
+// ------------------------------------------------------------------
+// prettier-ignore
+const Keyword = Runtime.Union([
+  Runtime.Const('any', Runtime.As(Types.Any())),
+  Runtime.Const('bigint', Runtime.As(Types.BigInt())),
+  Runtime.Const('boolean', Runtime.As(Types.Boolean())),
+  Runtime.Const('integer', Runtime.As(Types.Integer())),
+  Runtime.Const('never', Runtime.As(Types.Never())),
+  Runtime.Const('null', Runtime.As(Types.Null())),
+  Runtime.Const('number', Runtime.As(Types.Number())),
+  Runtime.Const('string', Runtime.As(Types.String())),
+  Runtime.Const('symbol', Runtime.As(Types.Symbol())),
+  Runtime.Const('undefined', Runtime.As(Types.Undefined())),
+  Runtime.Const('unknown', Runtime.As(Types.Unknown())),
+  Runtime.Const('void', Runtime.As(Types.Void())),
+])
+
+// ------------------------------------------------------------------
+// KeyOf
+// ------------------------------------------------------------------
+// prettier-ignore
+const KeyOfMapping = (values: unknown[]) => (
+  values.length > 0
+)
+// prettier-ignore
+const KeyOf = Runtime.Union([
+  Runtime.Tuple([Runtime.Const('keyof')]), Runtime.Tuple([])
+], KeyOfMapping)
+
+// ------------------------------------------------------------------
+// IndexArray
+// ------------------------------------------------------------------
+// prettier-ignore
+const IndexArrayMapping = (values: unknown[]) => (
+  values.length === 4 ? [[values[1]], ...values[3] as unknown[]] :
+  values.length === 3 ? [[], ...values[2] as unknown[]] :
+  []
+)
+// prettier-ignore
+const IndexArray = Runtime.Union([
+  Runtime.Tuple([Runtime.Const(LBracket), Runtime.Ref('Type'), Runtime.Const(RBracket), Runtime.Ref('IndexArray')]),
+  Runtime.Tuple([Runtime.Const(LBracket), Runtime.Const(RBracket), Runtime.Ref('IndexArray')]),
+  Runtime.Tuple([])
+], value => IndexArrayMapping(value))
+
+// ------------------------------------------------------------------
+// Extends
+// ------------------------------------------------------------------
+// prettier-ignore
+const ExtendsMapping = (values: unknown[]) => {
+  return values.length === 6
+    ? [values[1], values[3], values[5]]
+    : []
+}
+// prettier-ignore
+const Extends = Runtime.Union([
+  Runtime.Tuple([Runtime.Const('extends'), Runtime.Ref('Type'), Runtime.Const(Question), Runtime.Ref('Type'), Runtime.Const(Colon), Runtime.Ref('Type')]),
+  Runtime.Tuple([])
+], ExtendsMapping)
+
+// ------------------------------------------------------------------
+// Base
+// ------------------------------------------------------------------
+// prettier-ignore
+const BaseMapping = (values: unknown[]) => {
+  return values.length === 3 ? values[1] : values[0]
+}
+// prettier-ignore
+const Base = Runtime.Union([
+  Runtime.Tuple([
+    Runtime.Const(LParen), 
+    Runtime.Ref('Type'), 
+    Runtime.Const(RParen)
+  ]),
+  Runtime.Tuple([Runtime.Union([
+    Runtime.Ref('Literal'),
+    Runtime.Ref('Keyword'),
+    Runtime.Ref('Object'),
+    Runtime.Ref('Tuple'),
+    Runtime.Ref('Constructor'),
+    Runtime.Ref('Function'),
+    Runtime.Ref('Mapped'),
+    Runtime.Ref('AsyncIterator'),
+    Runtime.Ref('Iterator'),
+    Runtime.Ref('ConstructorParameters'),
+    Runtime.Ref('FunctionParameters'),
+    Runtime.Ref('InstanceType'),
+    Runtime.Ref('ReturnType'),
+    Runtime.Ref('Awaited'),
+    Runtime.Ref('Array'),
+    Runtime.Ref('Record'),
+    Runtime.Ref('Promise'),
+    Runtime.Ref('Partial'),
+    Runtime.Ref('Required'),
+    Runtime.Ref('Pick'),
+    Runtime.Ref('Omit'),
+    Runtime.Ref('Exclude'),
+    Runtime.Ref('Extract'),
+    Runtime.Ref('Uppercase'),
+    Runtime.Ref('Lowercase'),
+    Runtime.Ref('Capitalize'),
+    Runtime.Ref('Uncapitalize'),
+    Runtime.Ref('Date'),
+    Runtime.Ref('Uint8Array'),
+    Runtime.Ref('Reference')
+  ])])
+], BaseMapping)
+
+// ------------------------------------------------------------------
+// Factor
+// ------------------------------------------------------------------
+// prettier-ignore
+const FactorExtends = (Type: Types.TSchema, Extends: Types.TSchema[]) => {
+  return Extends.length === 3
+    ? Types.Extends(Type, Extends[0], Extends[1], Extends[2])
+    : Type
+}
+// prettier-ignore
+const FactorIndexArray = (Type: Types.TSchema, IndexArray: unknown[]): Types.TSchema => {
+  const [Left, Right] = DestructureRight(IndexArray) as [unknown[], Types.TSchema[]]
+  return (
+    !Types.ValueGuard.IsUndefined(Right) ? (
+      Right.length === 1 ? Types.Index(FactorIndexArray(Type, Left), Right[0]) :
+      Right.length === 0 ? Types.Array(FactorIndexArray(Type, Left)) :
+      Types.Never()
+    ) : Type
+  )
+}
+// prettier-ignore
+const FactorMapping = (KeyOf: boolean, Type: Types.TSchema, IndexArray: unknown[], Extends: Types.TSchema[]) => {
+  return KeyOf
+    ? FactorExtends(Types.KeyOf(FactorIndexArray(Type, IndexArray)), Extends)
+    : FactorExtends(FactorIndexArray(Type, IndexArray), Extends)
+}
+// prettier-ignore
+const Factor = Runtime.Tuple([
+  Runtime.Ref<boolean>('KeyOf'), 
+  Runtime.Ref<Types.TSchema>('Base'),
+  Runtime.Ref<unknown[]>('IndexArray'),
+  Runtime.Ref<Types.TSchema[]>('Extends')
+], values => FactorMapping(...values))
+
+// ------------------------------------------------------------------
+// Expr
+// ------------------------------------------------------------------
+// prettier-ignore
+function ExprBinaryMapping(Left: Types.TSchema, Rest: unknown[]): Types.TSchema {
+  return (
+    Rest.length === 3 ? (() => {
+      const [Operator, Right, Next] = Rest as [string, Types.TSchema, unknown[]]
+      const Schema = ExprBinaryMapping(Right, Next)
+      if (Operator === '&') {
+        return Types.TypeGuard.IsIntersect(Schema)
+          ? Types.Intersect([Left, ...Schema.allOf])
+          : Types.Intersect([Left, Schema])
+      }
+      if (Operator === '|') {
+        return Types.TypeGuard.IsUnion(Schema)
+          ? Types.Union([Left, ...Schema.anyOf])
+          : Types.Union([Left, Schema])
+      }
+      throw 1
+    })() : Left
+  )
+}
+// prettier-ignore
+const ExprTermTail = Runtime.Union([
+  Runtime.Tuple([Runtime.Const('&'), Runtime.Ref('Factor'), Runtime.Ref('ExprTermTail')]),
+  Runtime.Tuple([])
+])
+// prettier-ignore
+const ExprTerm = Runtime.Tuple([
+  Runtime.Ref<Types.TSchema>('Factor'), Runtime.Ref<unknown[]>('ExprTermTail')
+], value => ExprBinaryMapping(...value))
+// prettier-ignore
+const ExprTail = Runtime.Union([
+  Runtime.Tuple([Runtime.Const('|'), Runtime.Ref('ExprTerm'), Runtime.Ref('ExprTail')]),
+  Runtime.Tuple([])
+])
+// prettier-ignore
+const Expr = Runtime.Tuple([
+  Runtime.Ref<Types.TSchema>('ExprTerm'), Runtime.Ref<unknown[]>('ExprTail')
+], value => ExprBinaryMapping(...value))
+
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+const Type = Runtime.Ref('Expr')
+
+// ------------------------------------------------------------------
+// Properties
+// ------------------------------------------------------------------
+// prettier-ignore
+const PropertyKey = Runtime.Union([Runtime.Ident(), Runtime.String([SingleQuote, DoubleQuote])])
+// prettier-ignore
+const PropertyReadonly = Runtime.Union([Runtime.Tuple([Runtime.Const('readonly')]), Runtime.Tuple([])], value => value.length > 0)
+// prettier-ignore
+const PropertyOptional = Runtime.Union([Runtime.Tuple([Runtime.Const(Question)]), Runtime.Tuple([])], value => value.length > 0)
+// prettier-ignore
+const PropertyMapping = (Readonly: boolean, Key: string, Optional: boolean, _: typeof Colon, Type: Types.TSchema) => ({
+  [Key]: (
+    Readonly && Optional ? Types.ReadonlyOptional(Type) :
+    Readonly && !Optional ? Types.Readonly(Type) :
+    !Readonly && Optional ? Types.Optional(Type) :
+    Type
+  )
+})
+// prettier-ignore
+const Property = Runtime.Tuple([
+  Runtime.Ref<boolean>('PropertyReadonly'),
+  Runtime.Ref<string>('PropertyKey'),
+  Runtime.Ref<boolean>('PropertyOptional'),
+  Runtime.Const(Colon),
+  Runtime.Ref<Types.TSchema>('Type'),
+], value => PropertyMapping(...value))
+// prettier-ignore
+const PropertyDelimiter = Runtime.Union([
+  Runtime.Tuple([Runtime.Const(Comma), Runtime.Const(Newline)]),
+  Runtime.Tuple([Runtime.Const(SemiColon), Runtime.Const(Newline)]),
+  Runtime.Tuple([Runtime.Const(Comma)]),
+  Runtime.Tuple([Runtime.Const(SemiColon)]),
+  Runtime.Tuple([Runtime.Const(Newline)]),
+])
+// prettier-ignore
+const Properties = Runtime.Union([
+  Runtime.Tuple([Runtime.Ref('Property'), Runtime.Ref('PropertyDelimiter'), Runtime.Ref('Properties')]),
+  Runtime.Tuple([Runtime.Ref('Property'), Runtime.Ref('PropertyDelimiter')]),
+  Runtime.Tuple([Runtime.Ref('Property')]),
+  Runtime.Tuple([])
+], values => (
+  values.length === 3 ? [values[0], ...values[2] as unknown[]] :
+  values.length === 2 ? [values[0]] :
+  values.length === 1 ? [values[0]] :
+  []
+))
+
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+// prettier-ignore
+const ObjectMapping = (values: Record<string, Types.TSchema>[]) => Types.Object(values.reduce((properties, record) => {
+  return { ...properties, ...record }
+}, {} as Types.TProperties))
+// prettier-ignore
+const Object = Runtime.Tuple([
+  Runtime.Const(LBrace),
+  Runtime.Ref<Record<string, Types.TSchema>[]>('Properties'),
+  Runtime.Const(RBrace)
+], values => ObjectMapping(values[1]))
+
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+const Elements = Runtime.Union([
+  Runtime.Tuple([Runtime.Ref('Type'), Runtime.Const(Comma), Runtime.Ref<unknown[]>('Elements')]),
+  Runtime.Tuple([Runtime.Ref('Type'), Runtime.Const(Comma)]),
+  Runtime.Tuple([Runtime.Ref('Type')]),
+  Runtime.Tuple([]),
+], value => (
+  value.length === 3 ? [value[0], ...value[2]] :
+  value.length === 2 ? [value[0]] :
+  value.length === 1 ? [value[0]] :
+  []
+))
+// prettier-ignore
+const Tuple = Runtime.Tuple([
+  Runtime.Const(LBracket),
+  Runtime.Ref<Types.TSchema[]>('Elements'),
+  Runtime.Const(RBracket)
+], value => Types.Tuple(value[1]))
+
+// ------------------------------------------------------------------
+// Parameters
+// ------------------------------------------------------------------
+// prettier-ignore
+const Parameter = Runtime.Tuple([
+  Runtime.Ident(), Runtime.Const(Colon), Runtime.Ref<Types.TSchema>('Type')
+], value => value[2])
+// prettier-ignore
+const Parameters = Runtime.Union([
+  Runtime.Tuple([Runtime.Ref('Parameter'), Runtime.Const(Comma), Runtime.Ref<unknown[]>('Parameters')]),
+  Runtime.Tuple([Runtime.Ref('Parameter'), Runtime.Const(Comma)]),
+  Runtime.Tuple([Runtime.Ref('Parameter')]),
+  Runtime.Tuple([]),
+], value => (
+  value.length === 3 ? [value[0], ...value[2]] :
+  value.length === 2 ? [value[0]] :
+  value.length === 1 ? [value[0]] :
+  []
+))
+// ------------------------------------------------------------------
+// Constructor
+// ------------------------------------------------------------------
+// prettier-ignore
+const Constructor = Runtime.Tuple([
+  Runtime.Const('new'), 
+  Runtime.Const(LParen), 
+  Runtime.Ref<Types.TSchema[]>('Parameters'), 
+  Runtime.Const(RParen), 
+  Runtime.Const('=>'), 
+  Runtime.Ref<Types.TSchema>('Type')
+], value => Types.Constructor(value[2], value[5]))
+// ------------------------------------------------------------------
+// Function
+// ------------------------------------------------------------------
+// prettier-ignore
+const Function = Runtime.Tuple([
+  Runtime.Const(LParen), 
+  Runtime.Ref<Types.TSchema[]>('Parameters'), 
+  Runtime.Const(RParen), 
+  Runtime.Const('=>'), 
+  Runtime.Ref<Types.TSchema>('Type')
+], value => Types.Function(value[1], value[4]))
+// ------------------------------------------------------------------
+// Mapped (requires deferred types)
+// ------------------------------------------------------------------
+// prettier-ignore
+const MappedMapping = (values: unknown[]) => {
+  return Types.Literal('Mapped types not supported')
+}
+// prettier-ignore
+const Mapped = Runtime.Tuple([
+  Runtime.Const(LBrace), Runtime.Const(LBracket), Runtime.Ident(), Runtime.Const('in'), Runtime.Ref<Types.TSchema>('Type'), Runtime.Const(RBracket), Runtime.Const(Colon), Runtime.Ref<Types.TSchema>('Type'), Runtime.Const(RBrace)
+], MappedMapping)
+// ------------------------------------------------------------------
+// AsyncIterator
+// ------------------------------------------------------------------
+// prettier-ignore
+const AsyncIterator = Runtime.Tuple([
+  Runtime.Const('AsyncIterator'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RAngle),
+], value => Types.AsyncIterator(value[2]))
+// ------------------------------------------------------------------
+// Iterator
+// ------------------------------------------------------------------
+// prettier-ignore
+const Iterator = Runtime.Tuple([
+  Runtime.Const('Iterator'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RAngle),
+], value => Types.Iterator(value[2]))
+// ------------------------------------------------------------------
+// ConstructorParameters
+// ------------------------------------------------------------------
+// prettier-ignore
+const ConstructorParameters = Runtime.Tuple([
+  Runtime.Const('ConstructorParameters'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TConstructor>('Type'), 
+  Runtime.Const(RAngle),
+], value => Types.ConstructorParameters(value[2]))
+// ------------------------------------------------------------------
+// Parameters
+// ------------------------------------------------------------------
+// prettier-ignore
+const FunctionParameters = Runtime.Tuple([
+  Runtime.Const('Parameters'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TFunction>('Type'), 
+  Runtime.Const(RAngle),
+], value => Types.Parameters(value[2]))
+// ------------------------------------------------------------------
+// InstanceType
+// ------------------------------------------------------------------
+// prettier-ignore
+const InstanceType = Runtime.Tuple([
+  Runtime.Const('InstanceType'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TConstructor>('Type'), 
+  Runtime.Const(RAngle),
+], value => Types.InstanceType(value[2]))
+// ------------------------------------------------------------------
+// ReturnType
+// ------------------------------------------------------------------
+// prettier-ignore
+const ReturnType = Runtime.Tuple([
+  Runtime.Const('ReturnType'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TFunction>('Type'), 
+  Runtime.Const(RAngle),
+], value => Types.ReturnType(value[2]))
+// ------------------------------------------------------------------
+// Awaited
+// ------------------------------------------------------------------
+// prettier-ignore
+const Awaited = Runtime.Tuple([
+  Runtime.Const('Awaited'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RAngle),
+], value => Types.Awaited(value[2]))
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+// prettier-ignore
+const Array = Runtime.Tuple([
+  Runtime.Const('Array'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RAngle),
+], value => Types.Array(value[2]))
+// ------------------------------------------------------------------
+// Record
+// ------------------------------------------------------------------
+// prettier-ignore
+const Record = Runtime.Tuple([
+  Runtime.Const('Record'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TSchema>('Type'),
+  Runtime.Const(Comma), 
+  Runtime.Ref<Types.TSchema>('Type'),
+  Runtime.Const(RAngle),  
+], value => Types.Record(value[2], value[4]))
+// ------------------------------------------------------------------
+// Promise
+// ------------------------------------------------------------------
+// prettier-ignore
+const Promise = Runtime.Tuple([
+  Runtime.Const('Promise'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RAngle),  
+], value => Types.Promise(value[2]))
+// ------------------------------------------------------------------
+// Partial
+// ------------------------------------------------------------------
+// prettier-ignore
+const Partial = Runtime.Tuple([
+  Runtime.Const('Partial'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RAngle),  
+], value => Types.Partial(value[2]))
+// ------------------------------------------------------------------
+// Required
+// ------------------------------------------------------------------
+// prettier-ignore
+const Required = Runtime.Tuple([
+  Runtime.Const('Required'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RAngle),  
+], value => Types.Required(value[2]))
+// ------------------------------------------------------------------
+// Pick
+// ------------------------------------------------------------------
+// prettier-ignore
+const Pick = Runtime.Tuple([
+  Runtime.Const('Pick'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(Comma), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RAngle),  
+], value => Types.Pick(value[2], value[4]))
+// ------------------------------------------------------------------
+// Omit
+// ------------------------------------------------------------------
+// prettier-ignore
+const Omit = Runtime.Tuple([
+  Runtime.Const('Omit'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(Comma), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RAngle),  
+], value => Types.Omit(value[2], value[4]))
+// ------------------------------------------------------------------
+// Exclude
+// ------------------------------------------------------------------
+// prettier-ignore
+const Exclude = Runtime.Tuple([
+  Runtime.Const('Exclude'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(Comma), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RAngle),  
+], value => Types.Exclude(value[2], value[4]))
+// ------------------------------------------------------------------
+// Extract
+// ------------------------------------------------------------------
+// prettier-ignore
+const Extract = Runtime.Tuple([
+  Runtime.Const('Extract'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(Comma), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RAngle),  
+], value => Types.Extract(value[2], value[4]))
+// ------------------------------------------------------------------
+// Uppercase
+// ------------------------------------------------------------------
+// prettier-ignore
+const Uppercase = Runtime.Tuple([
+  Runtime.Const('Uppercase'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RAngle),  
+], value => Types.Uppercase(value[2]))
+// ------------------------------------------------------------------
+// Lowercase
+// ------------------------------------------------------------------
+// prettier-ignore
+const Lowercase = Runtime.Tuple([
+  Runtime.Const('Lowercase'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RAngle),  
+], value => Types.Lowercase(value[2]))
+// ------------------------------------------------------------------
+// Capitalize
+// ------------------------------------------------------------------
+// prettier-ignore
+const Capitalize = Runtime.Tuple([
+  Runtime.Const('Capitalize'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RAngle),  
+], value => Types.Capitalize(value[2]))
+// ------------------------------------------------------------------
+// Uncapitalize
+// ------------------------------------------------------------------
+// prettier-ignore
+const Uncapitalize = Runtime.Tuple([
+  Runtime.Const('Uncapitalize'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RAngle),  
+], value => Types.Uncapitalize(value[2]))
+// ------------------------------------------------------------------
+// Date
+// ------------------------------------------------------------------
+const Date = Runtime.Const('Date', Runtime.As(Types.Date()))
+// ------------------------------------------------------------------
+// Uint8Array
+// ------------------------------------------------------------------
+const Uint8Array = Runtime.Const('Uint8Array', Runtime.As(Types.Uint8Array()))
+// ------------------------------------------------------------------
+// Module
+// ------------------------------------------------------------------
+// prettier-ignore
+export const Module = new Runtime.Module({
+  Literal,
+  Keyword,
+  KeyOf,
+  IndexArray,
+  Extends,
+  Base,
+  Factor,
+  ExprTermTail,
+  ExprTerm,
+  ExprTail,
+  Expr,
+  Type,
+  PropertyKey,
+  PropertyReadonly,
+  PropertyOptional,
+  Property,
+  PropertyDelimiter,
+  Properties,
+  Object,
+  Elements,
+  Tuple,
+  Parameter,
+  Function,
+  Parameters,
+  Constructor,
+  Mapped,
+  AsyncIterator,
+  Iterator,
+  Awaited,
+  Array,
+  Record,
+  Promise,
+  ConstructorParameters,
+  FunctionParameters,
+  InstanceType,
+  ReturnType,
+  Partial,
+  Required,
+  Pick,
+  Omit,
+  Exclude,
+  Extract,
+  Uppercase,
+  Lowercase,
+  Capitalize,
+  Uncapitalize,
+  Date,
+  Uint8Array,
+  Reference
+})
diff --git a/src/parse/static.ts b/src/parse/static.ts
new file mode 100644
index 000000000..90bec8e33
--- /dev/null
+++ b/src/parse/static.ts
@@ -0,0 +1,764 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Static } from './parsebox/index'
+import * as Types from '../type/index'
+
+// ------------------------------------------------------------------
+// Tokens
+// ------------------------------------------------------------------
+type Newline = '\n'
+type LBracket = '['
+type RBracket = ']'
+type LParen = '('
+type RParen = ')'
+type LBrace = '{'
+type RBrace = '}'
+type LAngle = '<'
+type RAngle = '>'
+type Question = '?'
+type Colon = ':'
+type Comma = ','
+type SemiColon = ';'
+type SingleQuote = "'"
+type DoubleQuote = '"'
+type Tilde = '`'
+
+// ------------------------------------------------------------------
+// Delimit
+//
+// This type is used to perform a partial breadth match for repeated
+// elements in a sequence. It used to mitigate depth+1 traversal for
+// each element which helps prevent reaching instantiation limits. The
+// technique works by infering as wide as possible on the sequence
+// enabling TS to hoist interior matches, but does come at slight
+// inference performance cost. The current (infer=9) is configured
+// to match 64 terminal tuple elements.
+//
+// for the given sequence
+//
+// [a, b, c, d, e, f, g]
+//
+// ------------------------------------------------------------------
+//
+// without breadth mapping (infer=1, depth=6)
+//
+// [infer a,
+//   [infer b,
+//     [infer c,
+//       [infer d,
+//         [infer e,
+//           [infer f,
+//             [infer g,
+//               []]]]]]]]
+//
+// ------------------------------------------------------------------
+//
+// with breadth mapping (infer=4, depth=2)
+//
+// [infer a, infer b, infer c, infer d,
+//   [infer e, infer f, infer g,
+//     []]]
+//
+//
+// ------------------------------------------------------------------
+// prettier-ignore
+interface DelimitTailMapping<_ = unknown> extends Static.IMapping {
+  output: (
+    this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer F, _, infer G, _, infer H, _, infer I, _, infer Rest extends unknown[]] ? [A, B, C, D, E, F, G, H, I, ...Rest] :
+    this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer F, _, infer G, _, infer H, _, infer Rest extends unknown[]] ? [A, B, C, D, E, F, G, H, ...Rest] :
+    this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer F, _, infer G, _, infer Rest extends unknown[]] ? [A, B, C, D, E, F, G, ...Rest] :
+    this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer F, _, infer Rest extends unknown[]] ? [A, B, C, D, E, F, ...Rest] :
+    this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer Rest extends unknown[]] ? [A, B, C, D, E, ...Rest] :
+    this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _,  infer Rest extends unknown[]] ? [A, B, C, D, ...Rest] :
+    this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer Rest extends unknown[]] ? [A, B, C, ...Rest] :
+    this['input'] extends [_, infer A, _, infer B, _, infer Rest extends unknown[]] ? [A, B, ...Rest] :
+    this['input'] extends [_, infer A, _, infer Rest extends unknown[]] ? [A, ...Rest] :
+    this['input'] extends [_, infer Rest extends unknown[]] ? [...Rest] : 
+    this['input'] extends [_] ? [] :
+    []
+  )
+}
+// prettier-ignore
+type DelimitTail<T extends Static.IParser, _ extends Static.IParser> = Static.Union<[
+  Static.Tuple<[_, T, _, T, _, T, _, T, _, T, _, T, _, T, _, T, _, T, _, Delimit<T, _>]>,
+  Static.Tuple<[_, T, _, T, _, T, _, T, _, T, _, T, _, T, _, T, _, Delimit<T, _>]>,
+  Static.Tuple<[_, T, _, T, _, T, _, T, _, T, _, T, _, T, _, Delimit<T, _>]>,
+  Static.Tuple<[_, T, _, T, _, T, _, T, _, T, _, T, _, Delimit<T, _>]>,
+  Static.Tuple<[_, T, _, T, _, T, _, T, _, T, _, Delimit<T, _>]>,
+  Static.Tuple<[_, T, _, T, _, T, _, T, _, Delimit<T, _>]>,
+  Static.Tuple<[_, T, _, T, _, T, _,Delimit<T, _>]>,
+  Static.Tuple<[_, T, _, T, _, Delimit<T, _>]>,
+  Static.Tuple<[_, T, _, Delimit<T, _>]>,
+  Static.Tuple<[_, Delimit<T, _>]>,
+  Static.Tuple<[_]>,
+  Static.Tuple<[]>
+], DelimitTailMapping>
+// prettier-ignore
+interface DelimitMapping extends Static.IMapping {
+  output: (
+    this['input'] extends [infer Element extends unknown, infer Rest extends unknown[]] 
+      ? [Element, ...Rest]
+      : []
+  )
+}
+// prettier-ignore
+type Delimit<Parser extends Static.IParser, Delimiter extends Static.IParser> = (
+  Static.Union<[
+    Static.Tuple<[Parser, DelimitTail<Parser, Delimiter>]>,
+    Static.Tuple<[]>
+  ], DelimitMapping>
+)
+// ------------------------------------------------------------------
+// Reference
+// ------------------------------------------------------------------
+// prettier-ignore
+interface ReferenceMapping extends Static.IMapping {
+  output: this['input'] extends [infer Key extends string]
+    ? Key extends keyof this['context']
+      ? this['context'][Key]
+      : Types.TRef<Types.TUnknown>
+    : never
+}
+type Reference = Static.Tuple<[Static.Ident], ReferenceMapping>
+
+// ------------------------------------------------------------------
+// Literal
+// ------------------------------------------------------------------
+// prettier-ignore
+interface LiteralBooleanMapping extends Static.IMapping {
+  output: this['input'] extends `${infer S extends boolean}` ? Types.TLiteral<S> : never
+}
+// prettier-ignore
+interface LiteralNumberMapping extends Static.IMapping {
+  output: this['input'] extends `${infer S extends number}` ? Types.TLiteral<S> : never
+}
+// prettier-ignore
+interface LiteralStringMapping extends Static.IMapping {
+  output: this['input'] extends `${infer S extends string}` ? Types.TLiteral<S> : never
+}
+// prettier-ignore
+type Literal = Static.Union<[
+  Static.Union<[Static.Const<'true'>, Static.Const<'false'>], LiteralBooleanMapping>,
+  Static.Number<LiteralNumberMapping>,
+  Static.String<[DoubleQuote, SingleQuote, Tilde], LiteralStringMapping>,
+]>
+// ------------------------------------------------------------------
+// Keyword
+// ------------------------------------------------------------------
+// prettier-ignore
+type Keyword = Static.Union<[
+  Static.Const<'any', Static.As<Types.TAny>>,
+  Static.Const<'bigint', Static.As<Types.TBigInt>>,
+  Static.Const<'boolean', Static.As<Types.TBoolean>>,
+  Static.Const<'integer', Static.As<Types.TInteger>>,
+  Static.Const<'never', Static.As<Types.TNever>>,
+  Static.Const<'null', Static.As<Types.TNull>>,
+  Static.Const<'number', Static.As<Types.TNumber>>,
+  Static.Const<'string', Static.As<Types.TString>>,
+  Static.Const<'symbol', Static.As<Types.TSymbol>>,
+  Static.Const<'undefined', Static.As<Types.TUndefined>>,
+  Static.Const<'unknown', Static.As<Types.TUnknown>>,
+  Static.Const<'void', Static.As<Types.TVoid>>,
+]>
+// ------------------------------------------------------------------
+// KeyOf
+// ------------------------------------------------------------------
+// prettier-ignore
+interface KeyOfMapping extends Static.IMapping {
+  output: this['input'] extends [] ? false : true
+}
+// prettier-ignore
+type KeyOf = Static.Union<[
+  Static.Tuple<[Static.Const<'keyof'>]>,
+  Static.Tuple<[]>
+], KeyOfMapping>
+
+// ------------------------------------------------------------------
+// IndexArray
+// ------------------------------------------------------------------
+// prettier-ignore
+interface IndexArrayMapping extends Static.IMapping {
+  output: (
+    this['input'] extends [LBracket, infer Type extends Types.TSchema, RBracket, infer Rest extends unknown[]] ? [[Type], ...Rest] :
+    this['input'] extends [LBracket, RBracket, infer Rest extends unknown[]] ? [[], ...Rest] :
+    []
+  )
+}
+// prettier-ignore
+type IndexArray = Static.Union<[
+  Static.Tuple<[Static.Const<LBracket>, Type, Static.Const<RBracket>, IndexArray]>,
+  Static.Tuple<[Static.Const<LBracket>, Static.Const<RBracket>, IndexArray]>,
+  Static.Tuple<[]>
+], IndexArrayMapping>
+
+// ------------------------------------------------------------------
+// Extends
+// ------------------------------------------------------------------
+// prettier-ignore
+interface ExtendsMapping extends Static.IMapping {
+  output: this['input'] extends ['extends', infer Type extends Types.TSchema, Question, infer True extends Types.TSchema, Colon, infer False extends Types.TSchema]
+    ? [Type, True, False]
+    : []
+}
+// prettier-ignore
+type Extends = Static.Union<[
+  Static.Tuple<[Static.Const<'extends'>, Type, Static.Const<Question>, Type, Static.Const<Colon>, Type]>,
+  Static.Tuple<[]>
+], ExtendsMapping>
+
+// ------------------------------------------------------------------
+// Base
+// ------------------------------------------------------------------
+// prettier-ignore
+interface BaseMapping extends Static.IMapping {
+  output: (
+    this['input'] extends [LParen, infer Type extends Types.TSchema, RParen] ? Type :
+    this['input'] extends [infer Type extends Types.TSchema] ? Type :
+    never
+  )
+}
+// prettier-ignore
+type Base = Static.Union<[
+  Static.Tuple<[
+    Static.Const<LParen>, 
+    Type,
+    Static.Const<RParen>
+  ]>,
+  Static.Tuple<[Static.Union<[
+    Literal,
+    Keyword,
+    Object, 
+    Tuple,
+    Function,
+    Constructor,
+    Mapped,
+    AsyncIterator,
+    Iterator,
+    ConstructorParameters,
+    FunctionParameters,
+    InstanceType,
+    ReturnType,
+    Awaited,
+    Array,
+    Record,
+    Promise,
+    Partial,
+    Required,
+    Pick,
+    Omit,
+    Exclude,
+    Extract,
+    Lowercase,
+    Uppercase,
+    Capitalize,
+    Uncapitalize,
+    Date,
+    Uint8Array,
+    Reference
+  ]>]>
+], BaseMapping>
+// ------------------------------------------------------------------
+// Factor
+// ------------------------------------------------------------------
+// prettier-ignore
+type FactorExtends<Type extends Types.TSchema, Extends extends unknown[]> = (
+  Extends extends [infer Right extends Types.TSchema, infer True extends Types.TSchema, infer False extends Types.TSchema] 
+    ? Types.TExtends<Type, Right, True, False>
+    : Type
+)
+// prettier-ignore
+type FactorIndexArray<Type extends Types.TSchema, IndexArray extends unknown[]> = (
+  IndexArray extends [...infer Left extends unknown[], infer Right extends Types.TSchema[]] ? (
+    Right extends [infer Indexer extends Types.TSchema] ? Types.TIndex<FactorIndexArray<Type, Left>, Types.TIndexPropertyKeys<Indexer>> : 
+    Right extends [] ? Types.TArray<FactorIndexArray<Type, Left>> :
+    Types.TNever
+  ) : Type
+)
+// prettier-ignore
+interface FactorMapping extends Static.IMapping {
+  output: this['input'] extends [infer KeyOf extends boolean, infer Type extends Types.TSchema, infer IndexArray extends unknown[], infer Extends extends unknown[]]
+  ? KeyOf extends true
+    ? FactorExtends<Types.TKeyOf<FactorIndexArray<Type, IndexArray>>, Extends>
+    : FactorExtends<FactorIndexArray<Type, IndexArray>, Extends>
+  : never
+}
+// prettier-ignore
+type Factor = Static.Tuple<[
+  KeyOf, Base, IndexArray, Extends
+], FactorMapping>
+// ------------------------------------------------------------------
+// Expr
+// ------------------------------------------------------------------
+// prettier-ignore
+type ExprBinaryReduce<Left extends Types.TSchema, Rest extends unknown[]> = (
+  Rest extends [infer Operator extends unknown, infer Right extends Types.TSchema, infer Next extends unknown[]] ? (
+    ExprBinaryReduce<Right, Next> extends infer Schema extends Types.TSchema ? (
+      Operator extends '&' ? (
+        Schema extends Types.TIntersect<infer Types extends Types.TSchema[]>
+        ? Types.TIntersect<[Left, ...Types]>
+        : Types.TIntersect<[Left, Schema]>
+      ) :
+      Operator extends '|' ? (
+        Schema extends Types.TUnion<infer Types extends Types.TSchema[]>
+        ? Types.TUnion<[Left, ...Types]>
+        : Types.TUnion<[Left, Schema]>
+      ) : never
+    ) : never
+  ) : Left
+)
+// prettier-ignore
+interface ExprBinaryMapping extends Static.IMapping {
+  output: (
+    this['input'] extends [infer Left extends Types.TSchema, infer Rest extends unknown[]]
+    ? ExprBinaryReduce<Left, Rest>
+    : []
+  )
+}
+// prettier-ignore
+type ExprTermTail = Static.Union<[
+  Static.Tuple<[Static.Const<'&'>, Factor, ExprTermTail]>,
+  Static.Tuple<[]>
+]>
+// prettier-ignore
+type ExprTerm = Static.Tuple<[
+  Factor, ExprTermTail
+], ExprBinaryMapping>
+// prettier-ignore
+type ExprTail = Static.Union<[
+  Static.Tuple<[Static.Const<'|'>, ExprTerm, ExprTail]>,
+  Static.Tuple<[]>
+]>
+// prettier-ignore
+type Expr = Static.Tuple<[
+  ExprTerm, ExprTail
+], ExprBinaryMapping>
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+export type Type = Expr
+// ------------------------------------------------------------------
+// Properties
+// ------------------------------------------------------------------
+// prettier-ignore
+interface PropertyKeyStringMapping extends Static.IMapping {
+  output: this['input']
+}
+type PropertyKeyString = Static.String<[SingleQuote, DoubleQuote], PropertyKeyStringMapping>
+
+type PropertyKey = Static.Union<[Static.Ident, PropertyKeyString]>
+// prettier-ignore
+interface PropertyReadonlyMapping extends Static.IMapping {
+  output: this['input'] extends ['readonly'] ? true : false
+}
+type PropertyReadonly = Static.Union<[Static.Tuple<[Static.Const<'readonly'>]>, Static.Tuple<[]>], PropertyReadonlyMapping>
+// prettier-ignore
+interface PropertyOptionalMapping extends Static.IMapping {
+  output: this['input'] extends [Question] ? true : false
+}
+type PropertyOptional = Static.Union<[Static.Tuple<[Static.Const<Question>]>, Static.Tuple<[]>], PropertyOptionalMapping>
+// prettier-ignore
+interface PropertyMapping extends Static.IMapping {
+  output: this['input'] extends [infer Readonly extends boolean, infer Key extends string, infer Optional extends boolean, string, infer Type extends Types.TSchema]
+  ? { 
+    [_ in Key]: (
+      [Readonly, Optional] extends [true, true] ? Types.TReadonlyOptional<Type> :
+      [Readonly, Optional] extends [true, false] ? Types.TReadonly<Type> :
+      [Readonly, Optional] extends [false, true] ? Types.TOptional<Type> :
+      Type 
+    ) 
+  } : never
+}
+
+type Property = Static.Tuple<[PropertyReadonly, PropertyKey, PropertyOptional, Static.Const<Colon>, Type], PropertyMapping>
+
+type PropertiesEvaluate<T> = { [K in keyof T]: T[K] } & {}
+// prettier-ignore
+type PropertyDelimiter = Static.Union<[
+  Static.Tuple<[Static.Const<Comma>, Static.Const<Newline>]>,
+  Static.Tuple<[Static.Const<SemiColon>, Static.Const<Newline>]>,
+  Static.Tuple<[Static.Const<Comma>]>,
+  Static.Tuple<[Static.Const<SemiColon>]>,
+  Static.Tuple<[Static.Const<Newline>]>,
+]>
+// prettier-ignore
+type PropertiesReduce<PropertiesArray extends Types.TProperties[], Result extends Types.TProperties = {}> = (
+  PropertiesArray extends [infer Left extends Types.TProperties, ...infer Right extends Types.TProperties[]]
+  ? PropertiesReduce<Right, PropertiesEvaluate<Result & Left>>
+  : Result
+)
+// prettier-ignore
+interface PropertiesMapping extends Static.IMapping {
+  output: this['input'] extends Types.TProperties[] ? PropertiesReduce<this['input']> : never
+}
+type Properties = Static.Union<[Delimit<Property, PropertyDelimiter>], PropertiesMapping>
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+// prettier-ignore
+interface ObjectMapping extends Static.IMapping {
+  output: this['input'] extends [unknown, infer Properties extends Types.TProperties, unknown] 
+    ? Types.TObject<Properties> 
+    : never
+}
+// prettier-ignore
+type Object = Static.Tuple<[
+  Static.Const<LBrace>, Properties, Static.Const<RBrace>
+], ObjectMapping>
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+type Elements = Delimit<Type, Static.Const<Comma>>
+// prettier-ignore
+interface TupleMapping extends Static.IMapping {
+  output: this['input'] extends [unknown, infer Elements extends Types.TSchema[], unknown] ? Types.TTuple<Elements> : never
+}
+// prettier-ignore
+type Tuple = Static.Tuple<[
+  Static.Const<LBracket>, Elements, Static.Const<RBracket>
+], TupleMapping>
+// ------------------------------------------------------------------
+// Parameters
+// ------------------------------------------------------------------
+interface ParameterMapping extends Static.IMapping {
+  output: this['input'] extends [string, Colon, infer Type extends Types.TSchema] ? Type : never
+}
+// prettier-ignore
+type Parameter = Static.Tuple<[
+  Static.Ident, Static.Const<Colon>, Type
+], ParameterMapping>
+
+type Parameters = Delimit<Parameter, Static.Const<Comma>>
+// ------------------------------------------------------------------
+// Function
+// ------------------------------------------------------------------
+// prettier-ignore
+interface FunctionMapping extends Static.IMapping {
+  output: this['input'] extends [LParen, infer Parameters extends Types.TSchema[], RParen, '=>', infer ReturnType extends Types.TSchema]
+    ? Types.TFunction<Parameters, ReturnType>
+    : never
+}
+// prettier-ignore
+type Function = Static.Tuple<[
+  Static.Const<LParen>, Parameters, Static.Const<RParen>, Static.Const<'=>'>, Type
+], FunctionMapping>
+// ------------------------------------------------------------------
+// Constructor
+// ------------------------------------------------------------------
+// prettier-ignore
+interface ConstructorMapping extends Static.IMapping {
+  output: this['input'] extends ['new', LParen, infer Parameters extends Types.TSchema[], RParen, '=>', infer InstanceType extends Types.TSchema]
+    ? Types.TConstructor<Parameters, InstanceType>
+    : never
+}
+// prettier-ignore
+type Constructor = Static.Tuple<[
+  Static.Const<'new'>, Static.Const<LParen>, Parameters, Static.Const<RParen>, Static.Const<'=>'>, Type
+], ConstructorMapping>
+// ------------------------------------------------------------------
+// Mapped (requires deferred types)
+// ------------------------------------------------------------------
+// prettier-ignore
+interface MappedMapping extends Static.IMapping {
+  output: this['input'] extends [LBrace, LBracket, infer Key extends string, 'in', infer Right extends Types.TSchema, RBracket, Colon, infer Type extends Types.TSchema, RBrace]
+    ? Types.TLiteral<'Mapped types not supported'>
+    : this['input']
+}
+// prettier-ignore
+type Mapped = Static.Tuple<[
+  Static.Const<LBrace>, Static.Const<LBracket>, Static.Ident, Static.Const<'in'>, Type, Static.Const<RBracket>, Static.Const<Colon>, Type, Static.Const<RBrace>
+], MappedMapping>
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+// prettier-ignore
+interface ArrayMapping extends Static.IMapping {
+  output: this['input'] extends ['Array', LAngle, infer Type extends Types.TSchema, RAngle]
+    ? Types.TArray<Type>
+    : never
+}
+// prettier-ignore
+type Array = Static.Tuple<[
+  Static.Const<'Array'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
+], ArrayMapping>
+// ------------------------------------------------------------------
+// AsyncIterator
+// ------------------------------------------------------------------
+// prettier-ignore
+interface AsyncIteratorMapping extends Static.IMapping {
+  output: this['input'] extends ['AsyncIterator', LAngle, infer Type extends Types.TSchema, RAngle]
+    ? Types.TAsyncIterator<Type>
+    : never
+}
+// prettier-ignore
+type AsyncIterator = Static.Tuple<[
+  Static.Const<'AsyncIterator'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
+], AsyncIteratorMapping>
+// ------------------------------------------------------------------
+// Iterator
+// ------------------------------------------------------------------
+// prettier-ignore
+interface IteratorMapping extends Static.IMapping {
+  output: this['input'] extends ['Iterator', LAngle, infer Type extends Types.TSchema, RAngle]
+    ? Types.TIterator<Type>
+    : never
+}
+// prettier-ignore
+type Iterator = Static.Tuple<[
+  Static.Const<'Iterator'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
+], IteratorMapping>
+
+// ------------------------------------------------------------------
+// ConstructorParameters
+// ------------------------------------------------------------------
+// prettier-ignore
+interface ConstructorParametersMapping extends Static.IMapping {
+  output: this['input'] extends ['ConstructorParameters', LAngle, infer Type extends Types.TConstructor, RAngle]
+    ? Types.TConstructorParameters<Type>
+    : never
+}
+// prettier-ignore
+type ConstructorParameters = Static.Tuple<[
+  Static.Const<'ConstructorParameters'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
+], ConstructorParametersMapping>
+// ------------------------------------------------------------------
+// FunctionParameters
+// ------------------------------------------------------------------
+// prettier-ignore
+interface FunctionParametersMapping extends Static.IMapping {
+  output: this['input'] extends ['Parameters', LAngle, infer Type extends Types.TFunction, RAngle]
+    ? Types.TParameters<Type>
+    : never
+}
+// prettier-ignore
+type FunctionParameters = Static.Tuple<[
+  Static.Const<'Parameters'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
+], FunctionParametersMapping>
+// ------------------------------------------------------------------
+// InstanceType
+// ------------------------------------------------------------------
+// prettier-ignore
+interface InstanceTypeMapping extends Static.IMapping {
+  output: this['input'] extends ['InstanceType', LAngle, infer Type extends Types.TConstructor, RAngle]
+    ? Types.TInstanceType<Type>
+    : never
+}
+// prettier-ignore
+type InstanceType = Static.Tuple<[
+  Static.Const<'InstanceType'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
+], InstanceTypeMapping>
+// ------------------------------------------------------------------
+// ReturnType
+// ------------------------------------------------------------------
+// prettier-ignore
+interface ReturnTypeMapping extends Static.IMapping {
+  output: this['input'] extends ['ReturnType', LAngle, infer Type extends Types.TFunction, RAngle]
+    ? Types.TReturnType<Type>
+    : never
+}
+// prettier-ignore
+type ReturnType = Static.Tuple<[
+  Static.Const<'ReturnType'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
+], ReturnTypeMapping>
+// ------------------------------------------------------------------
+// Awaited
+// ------------------------------------------------------------------
+// prettier-ignore
+interface AwaitedMapping extends Static.IMapping {
+  output: this['input'] extends ['Awaited', LAngle, infer Type extends Types.TSchema, RAngle]
+    ? Types.TAwaited<Type>
+    : never
+}
+// prettier-ignore
+type Awaited = Static.Tuple<[
+  Static.Const<'Awaited'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
+], AwaitedMapping>
+// ------------------------------------------------------------------
+// Promise
+// ------------------------------------------------------------------
+// prettier-ignore
+interface PromiseMapping extends Static.IMapping {
+  output: this['input'] extends ['Promise', LAngle, infer Type extends Types.TSchema, RAngle]
+    ? Types.TPromise<Type>
+    : never
+}
+// prettier-ignore
+type Promise = Static.Tuple<[
+  Static.Const<'Promise'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
+], PromiseMapping>
+// ------------------------------------------------------------------
+// Record
+// ------------------------------------------------------------------
+// prettier-ignore
+interface RecordMapping extends Static.IMapping {
+  output: this['input'] extends ['Record', LAngle, infer Key extends Types.TSchema, Comma, infer Type extends Types.TSchema,  RAngle]
+    ? Types.TRecord<Key, Type>
+    : never
+}
+// prettier-ignore
+type Record = Static.Tuple<[
+  Static.Const<'Record'>, Static.Const<LAngle>, Type, Static.Const<Comma>, Type, Static.Const<RAngle>,
+], RecordMapping>
+// ------------------------------------------------------------------
+// Partial
+// ------------------------------------------------------------------
+// prettier-ignore
+interface PartialMapping extends Static.IMapping {
+  output: this['input'] extends ['Partial', LAngle, infer Type extends Types.TSchema, RAngle]
+    ? Types.TPartial<Type>
+    : never
+}
+// prettier-ignore
+type Partial = Static.Tuple<[
+  Static.Const<'Partial'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
+], PartialMapping>
+// ------------------------------------------------------------------
+// Required
+// ------------------------------------------------------------------
+// prettier-ignore
+interface RequiredMapping extends Static.IMapping {
+  output: this['input'] extends ['Required', LAngle, infer Type extends Types.TSchema, RAngle]
+    ? Types.TPartial<Type>
+    : never
+}
+// prettier-ignore
+type Required = Static.Tuple<[
+  Static.Const<'Required'>,  Static.Const<LAngle>, Type, Static.Const<RAngle>,
+], RequiredMapping>
+// ------------------------------------------------------------------
+// Pick
+// ------------------------------------------------------------------
+// prettier-ignore
+interface PickMapping extends Static.IMapping {
+  output: this['input'] extends ['Pick', LAngle, infer Type extends Types.TSchema, Comma, infer PropertyKey extends Types.TSchema, RAngle]
+    ? Types.TPick<Type, Types.TIndexPropertyKeys<PropertyKey>>
+    : never
+}
+// prettier-ignore
+type Pick = Static.Tuple<[
+  Static.Const<'Pick'>, Static.Const<LAngle>, Type, Static.Const<Comma>, Type, Static.Const<RAngle>,
+], PickMapping>
+// ------------------------------------------------------------------
+// Omit
+// ------------------------------------------------------------------
+// prettier-ignore
+interface OmitMapping extends Static.IMapping {
+  output: this['input'] extends ['Omit', LAngle, infer Type extends Types.TSchema, Comma, infer PropertyKey extends Types.TSchema, RAngle]
+    ? Types.TOmit<Type, Types.TIndexPropertyKeys<PropertyKey>>
+    : never
+}
+// prettier-ignore
+type Omit = Static.Tuple<[
+  Static.Const<'Omit'>, Static.Const<LAngle>, Type, Static.Const<Comma>, Type, Static.Const<RAngle>
+], OmitMapping>
+// ------------------------------------------------------------------
+// Exclude
+// ------------------------------------------------------------------
+// prettier-ignore
+interface ExcludeMapping extends Static.IMapping {
+  output: this['input'] extends ['Exclude', LAngle, infer Type extends Types.TSchema, Comma, infer PropertyKey extends Types.TSchema, RAngle]
+    ? Types.TExclude<Type, PropertyKey>
+    : never
+}
+// prettier-ignore
+type Exclude = Static.Tuple<[
+  Static.Const<'Exclude'>, Static.Const<LAngle>, Type, Static.Const<Comma>, Type, Static.Const<RAngle>
+], ExcludeMapping>
+// ------------------------------------------------------------------
+// Extract
+// ------------------------------------------------------------------
+// prettier-ignore
+interface ExtractMapping extends Static.IMapping {
+  output: this['input'] extends ['Extract', LAngle, infer Type extends Types.TSchema, Comma, infer PropertyKey extends Types.TSchema, RAngle]
+    ? Types.TExtract<Type, PropertyKey>
+    : never
+}
+// prettier-ignore
+type Extract = Static.Tuple<[
+  Static.Const<'Extract'>, Static.Const<LAngle>, Type, Static.Const<Comma>, Type, Static.Const<RAngle>
+], ExtractMapping>
+// ------------------------------------------------------------------
+// Uppercase
+// ------------------------------------------------------------------
+// prettier-ignore
+interface UppercaseMapping extends Static.IMapping {
+  output: this['input'] extends ['Uppercase', LAngle, infer Type extends Types.TSchema, RAngle]
+    ? Types.TUppercase<Type>
+    : never
+}
+// prettier-ignore
+type Uppercase = Static.Tuple<[
+  Static.Const<'Uppercase'>,  Static.Const<LAngle>, Type, Static.Const<RAngle>,
+], UppercaseMapping>
+// ------------------------------------------------------------------
+// Lowercase
+// ------------------------------------------------------------------
+// prettier-ignore
+interface LowercaseMapping extends Static.IMapping {
+  output: this['input'] extends ['Lowercase', LAngle, infer Type extends Types.TSchema, RAngle]
+    ? Types.TLowercase<Type>
+    : never
+}
+// prettier-ignore
+type Lowercase = Static.Tuple<[
+  Static.Const<'Lowercase'>,  Static.Const<LAngle>, Type, Static.Const<RAngle>,
+], LowercaseMapping>
+// ------------------------------------------------------------------
+// Capitalize
+// ------------------------------------------------------------------
+// prettier-ignore
+interface CapitalizeMapping extends Static.IMapping {
+  output: this['input'] extends ['Capitalize', LAngle, infer Type extends Types.TSchema, RAngle]
+    ? Types.TCapitalize<Type>
+    : never
+}
+// prettier-ignore
+type Capitalize = Static.Tuple<[
+  Static.Const<'Capitalize'>,  Static.Const<LAngle>, Type, Static.Const<RAngle>,
+], CapitalizeMapping>
+// ------------------------------------------------------------------
+// Uncapitalize
+// ------------------------------------------------------------------
+// prettier-ignore
+interface UncapitalizeMapping extends Static.IMapping {
+  output: this['input'] extends ['Uncapitalize', LAngle, infer Type extends Types.TSchema, RAngle]
+    ? Types.TUncapitalize<Type>
+    : never
+}
+// prettier-ignore
+type Uncapitalize = Static.Tuple<[
+  Static.Const<'Uncapitalize'>,  Static.Const<LAngle>, Type, Static.Const<RAngle>,
+], UncapitalizeMapping>
+// ------------------------------------------------------------------
+// Date
+// ------------------------------------------------------------------
+type Date = Static.Const<'Date', Static.As<Types.TDate>>
+// ------------------------------------------------------------------
+// Uint8Array
+// ------------------------------------------------------------------
+type Uint8Array = Static.Const<'Uint8Array', Static.As<Types.TUint8Array>>
diff --git a/task/benchmark/compression/module/typebox-parse.ts b/task/benchmark/compression/module/typebox-parse.ts
new file mode 100644
index 000000000..7ba2bf33a
--- /dev/null
+++ b/task/benchmark/compression/module/typebox-parse.ts
@@ -0,0 +1,3 @@
+import * as Parse from '@sinclair/typebox/parse'
+
+console.log(Parse)
diff --git a/task/build/package/build.ts b/task/build/package/build.ts
index e7975ed73..a7fc92f33 100644
--- a/task/build/package/build.ts
+++ b/task/build/package/build.ts
@@ -32,7 +32,7 @@ import { createPackageJson } from './create-package-json'
 /** Builds package.json and redirect directories */
 export async function build(target: string) {
   console.log('building...package.json')
-  const submodules = ['compiler', 'errors', 'system', 'type', 'value']
+  const submodules = ['compiler', 'errors', 'parse', 'system', 'type', 'value']
   await createPackageJsonRedirect(target, submodules)
   await createPackageJson(target, submodules)
 }
diff --git a/test/runtime/index.ts b/test/runtime/index.ts
index 15ca57aca..56b6a3434 100644
--- a/test/runtime/index.ts
+++ b/test/runtime/index.ts
@@ -8,6 +8,7 @@ TypeSystemPolicy.InstanceMode = 'freeze'
 import './compiler/index'
 import './compiler-ajv/index'
 import './errors/index'
+import './parse/index'
 import './system/index'
 import './type/index'
 import './value/index'
diff --git a/test/runtime/parse/index.ts b/test/runtime/parse/index.ts
new file mode 100644
index 000000000..09cc87100
--- /dev/null
+++ b/test/runtime/parse/index.ts
@@ -0,0 +1 @@
+import './parse'
diff --git a/test/runtime/parse/parse.ts b/test/runtime/parse/parse.ts
new file mode 100644
index 000000000..1ac85df70
--- /dev/null
+++ b/test/runtime/parse/parse.ts
@@ -0,0 +1,389 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type, Parse } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+// prettier-ignore
+describe('parse/Parse', () => {
+  it('Should parse Any', () => {
+    const T = Parse(`any`)
+    Assert.IsTrue(TypeGuard.IsAny(T))
+  })
+  it('Should parse Array 1', () => {
+    const T = Parse(`number[]`)
+    Assert.IsTrue(TypeGuard.IsArray(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.items))
+  })
+  it('Should parse Array 2', () => {
+    const T = Parse(`Array<number>`)
+    Assert.IsTrue(TypeGuard.IsArray(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.items))
+  })
+  it('Should parse AsyncIterator', () => {
+    const T = Parse(`AsyncIterator<number>`)
+    Assert.IsTrue(TypeGuard.IsAsyncIterator(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.items))
+  })
+  it('Should parse Awaited', () => {
+    const T = Parse(`Awaited<Promise<number>>`)
+    Assert.IsTrue(TypeGuard.IsNumber(T))
+  })
+  it('Should parse BigInt', () => {
+    const T = Parse(`bigint`)
+    Assert.IsTrue(TypeGuard.IsBigInt(T))
+  })
+  it('Should parse Boolean', () => {
+    const T = Parse(`boolean`)
+    Assert.IsTrue(TypeGuard.IsBoolean(T))
+  })
+  it('Should parse ConstructorParameters', () => {
+    const T = Parse(`ConstructorParameters<new (a: number, b: string) => boolean>`)
+    Assert.IsTrue(TypeGuard.IsTuple(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.items![0]))
+    Assert.IsTrue(TypeGuard.IsString(T.items![1]))
+  })
+  it('Should parse Constructor', () => {
+    const T = Parse(`new (a: number, b: string) => boolean`)
+    Assert.IsTrue(TypeGuard.IsConstructor(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.parameters[0]))
+    Assert.IsTrue(TypeGuard.IsString(T.parameters[1]))
+    Assert.IsTrue(TypeGuard.IsBoolean(T.returns))
+  })
+  it('Should parse Date', () => {
+    const T = Parse(`Date`)
+    Assert.IsTrue(TypeGuard.IsDate(T))
+  })
+  it('Should parse Exclude', () => {
+    const T = Parse(`Exclude<1 | 2 | 3, 1>`)
+    Assert.IsTrue(TypeGuard.IsUnion(T))
+    Assert.IsTrue(T.anyOf[0].const === 2)
+    Assert.IsTrue(T.anyOf[1].const === 3)
+  })
+  it('Should parse Extract', () => {
+    const T = Parse(`Extract<1 | 2 | 3, 1 | 2>`)
+    Assert.IsTrue(TypeGuard.IsUnion(T))
+    // @ts-ignore fix: incorrect union order (result of UnionToTuple, replace with Tuple destructuring)
+    Assert.IsTrue(T.anyOf[0].const === 1)
+    // @ts-ignore fix: incorrect union order (result of UnionToTuple, replace with Tuple destructuring)
+    Assert.IsTrue(T.anyOf[1].const === 2)
+  })
+  it('Should parse Function', () => {
+    const T = Parse(`(a: number, b: string) => boolean`)
+    Assert.IsTrue(TypeGuard.IsFunction(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.parameters[0]))
+    Assert.IsTrue(TypeGuard.IsString(T.parameters[1]))
+    Assert.IsTrue(TypeGuard.IsBoolean(T.returns))
+  })
+  it('Should parse Indexed 1', () => {
+    const T = Parse(`{ x: 1, y: 2, z: 3 }['x']`)
+    Assert.IsTrue(T.const === 1)
+  })
+  it('Should parse Indexed 2', () => {
+    const T = Parse(`{ x: 1, y: 2, z: 3 }['x' | 'y' | 'z']`)
+    Assert.IsTrue(TypeGuard.IsUnion(T))
+    Assert.IsTrue(T.anyOf[0].const === 1)
+    Assert.IsTrue(T.anyOf[1].const === 2)
+    Assert.IsTrue(T.anyOf[2].const === 3)
+  })
+  it('Should parse Indexed 3', () => {
+    const T = Parse(`{ x: 1, y: 2, z: 3 }`)
+    const S = Parse({ T }, `T[keyof T]`)
+    Assert.IsTrue(TypeGuard.IsUnion(S))
+    Assert.IsTrue(S.anyOf[0].const === 1)
+    Assert.IsTrue(S.anyOf[1].const === 2)
+    Assert.IsTrue(S.anyOf[2].const === 3)
+  })
+  it('Should parse Indexed 4', () => {
+    const T = Parse(`['A', 'B', 'C']`)
+    const S = Parse({ T }, `T[number]`)
+    Assert.IsTrue(TypeGuard.IsUnion(S))
+    Assert.IsTrue(S.anyOf[0].const === 'A')
+    Assert.IsTrue(S.anyOf[1].const === 'B')
+    Assert.IsTrue(S.anyOf[2].const === 'C')
+  })
+  it('Should parse Integer', () => {
+    const T = Parse(`integer`)
+    Assert.IsTrue(TypeGuard.IsInteger(T))
+  })
+  it('Should parse Intersect 1', () => {
+    const T = Parse(`1 & 2`)
+    Assert.IsTrue(TypeGuard.IsIntersect(T))
+    Assert.IsTrue(T.allOf[0].const === 1)
+    Assert.IsTrue(T.allOf[1].const === 2)
+  })
+  it('Should parse Intersect 2', () => {
+    const T = Parse(`1 & (2 & 3)`) // expect flatten
+    Assert.IsTrue(TypeGuard.IsIntersect(T))
+    Assert.IsTrue(T.allOf[0].const === 1)
+    Assert.IsTrue(T.allOf[1].const === 2)
+    Assert.IsTrue(T.allOf[2].const === 3)
+  })
+  it('Should parse Intersect 3', () => {
+    const T = Parse(`(1 | 2) & 3`) // operator precedence
+    Assert.IsTrue(TypeGuard.IsIntersect(T))
+    Assert.IsTrue(TypeGuard.IsUnion(T.allOf[0]))
+    Assert.IsTrue(T.allOf[1].const === 3)
+  })
+  it('Should parse InstanceType 1', () => {
+    const T = Parse(`InstanceType<new () => { x: 1, y: 2 }>`)
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(T.properties.x.const === 1)
+    Assert.IsTrue(T.properties.y.const === 2)
+  })
+  it('Should parse InstanceType 2', () => {
+    const T = Parse(`InstanceType<number>`) // generalization issue
+    Assert.IsTrue(T === undefined)
+  })
+  it('Should parse Iterator', () => {
+    const T = Parse(`Iterator<number>`)
+    Assert.IsTrue(TypeGuard.IsIterator(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.items))
+  })
+  it('Should parse KeyOf 1', () => {
+    const T = Parse(`keyof { x: 1, y: 2 }`)
+    Assert.IsTrue(TypeGuard.IsUnion(T))
+    Assert.IsTrue(T.anyOf[0].const === 'x')
+    Assert.IsTrue(T.anyOf[1].const === 'y')
+  })
+  it('Should parse KeyOf 2', () => {
+    const T = Parse(`keyof [0, 1]`)
+    Assert.IsTrue(TypeGuard.IsUnion(T))
+    Assert.IsTrue(T.anyOf[0].const === '0')
+    Assert.IsTrue(T.anyOf[1].const === '1')
+  })
+  it('Should parse KeyOf 3', () => {
+    const T = Parse(`{ x: 1, y: 2 }`)
+    const S = Parse({ T }, `keyof T`)
+    Assert.IsTrue(TypeGuard.IsUnion(S))
+    Assert.IsTrue(S.anyOf[0].const === 'x')
+    Assert.IsTrue(S.anyOf[1].const === 'y')
+  })
+  it('Should parse Literal Boolean 1', () => {
+    const T = Parse(`true`)
+    Assert.IsTrue(T.const === true)
+  })
+  it('Should parse Literal Boolean 2', () => {
+    const T = Parse(`false`)
+    Assert.IsTrue(T.const === false)
+  })
+  it('Should parse Literal Number', () => {
+    const T = Parse(`1`)
+    Assert.IsTrue(T.const === 1)
+  })
+  it('Should parse Literal String', () => {
+    const T = Parse(`'1'`)
+    Assert.IsTrue(T.const === '1')
+  })
+  it('Should parse Mapped (Pending)', () => {
+    const T = Parse(`{ [K in 1 | 2 | 3]: K }`)
+    Assert.IsTrue(T.const === 'Mapped types not supported')
+  })
+  it('Should parse Never', () => {
+    const T = Parse(`never`)
+    Assert.IsTrue(TypeGuard.IsNever(T))
+  })
+  it('Should parse Null', () => {
+    const T = Parse(`null`)
+    Assert.IsTrue(TypeGuard.IsNull(T))
+  })
+  it('Should parse Number', () => {
+    const T = Parse(`number`)
+    Assert.IsTrue(TypeGuard.IsNumber(T))
+  })
+  it('Should parse Object 1', () => {
+    const T = Parse(`{x: boolean, y: number, z: string, }`)
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.z))
+  })
+  it('Should parse Object 2', () => {
+    const T = Parse(`{x: boolean; y: number; z: string; }`)
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.z))
+  })
+  it('Should parse Object 3', () => {
+    const T = Parse(`{
+      x: boolean 
+      y: number
+      z: string
+    }`)
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.z))
+  })
+  it('Should parse Object 4', () => {
+    const T = Parse(`{
+      x: boolean; 
+      y: number; 
+      z: string;
+    }`)
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.z))
+  })
+  it('Should parse Object 5', () => {
+    const T = Parse(`{
+      x: boolean, 
+      y: number,
+      z: string,
+    }`)
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.z))
+  })
+  it('Should parse Omit 1', () => {
+    const T = Parse(`Omit<{ x: boolean, y: number, z: string }, 'z'>`)
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
+    Assert.IsTrue(('z' in T.properties) === false)
+  })
+  it('Should parse Omit 2', () => {
+    const T = Parse(`Omit<{ x: boolean, y: number, z: string }, 'z' | 'y'>`)
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
+    Assert.IsTrue(('y' in T.properties) === false)
+    Assert.IsTrue(('z' in T.properties) === false)
+  })
+  it('Should parse Parameters', () => {
+    const T = Parse(`Parameters<(a: number, b: string) => boolean>`)
+    Assert.IsTrue(TypeGuard.IsTuple(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.items![0]))
+    Assert.IsTrue(TypeGuard.IsString(T.items![1]))
+  })
+  it('Should parse Partial', () => {
+    const T = Parse(`Partial<{ x: boolean, y: number, z: string }>`)
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(('required' in T) === false)
+  })
+  it('Should parse Pick 1', () => {
+    const T = Parse(`Pick<{ x: boolean, y: number, z: string }, 'x' | 'y'>`)
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
+    Assert.IsTrue(('z' in T.properties) === false)
+  })
+  it('Should parse Pick 2', () => {
+    const T = Parse(`Pick<{ x: boolean, y: number, z: string }, 'x'>`)
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
+    Assert.IsTrue(('y' in T.properties) === false)
+    Assert.IsTrue(('z' in T.properties) === false)
+  })
+  it('Should parse Promise', () => {
+    const T = Parse(`Promise<number>`)
+    Assert.IsTrue(TypeGuard.IsPromise(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.item))
+  })
+  it('Should parse ReadonlyOptional', () => {
+    const T = Parse(`{ readonly x?: boolean, readonly y?: number }`)
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsReadonly(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsOptional(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
+    Assert.IsTrue(TypeGuard.IsReadonly(T.properties.y))
+    Assert.IsTrue(TypeGuard.IsOptional(T.properties.y))
+  })
+  it('Should parse Readonly', () => {
+    const T = Parse(`{ readonly x: boolean, readonly y: number }`)
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsReadonly(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
+    Assert.IsTrue(TypeGuard.IsReadonly(T.properties.y))
+  })
+  it('Should parse Record 1', () => {
+    const T = Parse(`Record<string, number>`)
+    Assert.IsTrue(TypeGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.patternProperties['^(.*)$']))
+  })
+  it('Should parse Record 2', () => {
+    const T = Parse(`Record<number, number>`)
+    Assert.IsTrue(TypeGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.patternProperties['^(0|[1-9][0-9]*)$']))
+  })
+  it('Should parse Record 3', () => {
+    const T = Parse(`Record<'x' | 'y', number>`)
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
+  })
+  it('Should parse Recursive', () => {
+    const T = Type.Recursive(This => Parse({ This }, `{ id: string, nodes: This[] }`))
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(TypeGuard.IsString(T.properties.id))
+    Assert.IsTrue(TypeGuard.IsArray(T.properties.nodes))
+    Assert.IsTrue(TypeGuard.IsThis(T.properties.nodes.items))
+  })
+  it('Should parse Ref', () => {
+    const T = Parse('foo')
+    Assert.IsTrue(TypeGuard.IsRef(T))
+    Assert.IsTrue(T.$ref === 'foo')
+  })
+  it('Should parse Required', () => {
+    const T = Parse(`Required<{ x?: boolean, y?: number, z?: string }>`)
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsEqual(T.required, ['x', 'y', 'z'])
+  })
+  it('Should parse ReturnType 1', () => {
+    const T = Parse(`ReturnType<() => { x: 1, y: 2 }>`)
+    Assert.IsTrue(TypeGuard.IsObject(T))
+    Assert.IsTrue(T.properties.x.const === 1)
+    Assert.IsTrue(T.properties.y.const === 2)
+  })
+  it('Should parse ReturnType 2', () => {
+    const T = Parse(`ReturnType<number>`) // generalization issue
+    Assert.IsTrue(T === undefined)
+  })
+  it('Should parse String', () => {
+    const T = Parse(`string`)
+    Assert.IsTrue(TypeGuard.IsString(T))
+  })
+  it('Should parse Symbol', () => {
+    const T = Parse(`symbol`)
+    Assert.IsTrue(TypeGuard.IsSymbol(T))
+  })
+  it('Should parse Tuple', () => {
+    const T = Parse(`[0, 1, 2, 3]`)
+    Assert.IsTrue(TypeGuard.IsTuple(T))
+    Assert.IsTrue(T.items![0].const === 0)
+    Assert.IsTrue(T.items![1].const === 1)
+    Assert.IsTrue(T.items![2].const === 2)
+    Assert.IsTrue(T.items![3].const === 3)
+  })
+  it('Should parse Uint8Array', () => {
+    const T = Parse(`Uint8Array`)
+    Assert.IsTrue(TypeGuard.IsUint8Array(T))
+  })
+  it('Should parse Undefined', () => {
+    const T = Parse(`undefined`)
+    Assert.IsTrue(TypeGuard.IsUndefined(T))
+  })
+  it('Should parse Union 1', () => {
+    const T = Parse(`1 | 2`)
+    Assert.IsTrue(TypeGuard.IsUnion(T))
+    Assert.IsTrue(T.anyOf[0].const === 1)
+    Assert.IsTrue(T.anyOf[1].const === 2)
+  })
+  it('Should parse Union 2', () => {
+    const T = Parse(`1 | (2 | 3)`)
+    Assert.IsTrue(TypeGuard.IsUnion(T))
+    Assert.IsTrue(T.anyOf[0].const === 1)
+    Assert.IsTrue(T.anyOf[1].const === 2)
+    Assert.IsTrue(T.anyOf[2].const === 3)
+  })
+  it('Should parse Unknown', () => {
+    const T = Parse(`unknown`)
+    Assert.IsTrue(TypeGuard.IsUnknown(T))
+  })
+  it('Should parse Void', () => {
+    const T = Parse(`void`)
+    Assert.IsTrue(TypeGuard.IsVoid(T))
+  })
+})
diff --git a/tsconfig.json b/tsconfig.json
index 7ba7f03ed..811eedcdd 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -8,6 +8,7 @@
     "paths": {
       "@sinclair/typebox/compiler": ["src/compiler/index.ts"],
       "@sinclair/typebox/errors": ["src/errors/index.ts"],
+      "@sinclair/typebox/parse": ["src/parse/index.ts"],
       "@sinclair/typebox/system": ["src/system/index.ts"],
       "@sinclair/typebox/type": ["src/type/index.ts"],
       "@sinclair/typebox/value": ["src/value/index.ts"],

From 52ceab98c59543704b07e40607f10a076ec86bea Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Thu, 7 Nov 2024 22:09:57 +0900
Subject: [PATCH 297/369] Revision 0.33.21 (#1064)

* HotFix: 0.33.20 - Object Shadowing on Runtime

* ChangeLog
---
 changelog/0.33.0.md  | 2 ++
 package-lock.json    | 4 ++--
 package.json         | 2 +-
 src/parse/runtime.ts | 4 ++--
 4 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/changelog/0.33.0.md b/changelog/0.33.0.md
index f349e7495..f42f59f27 100644
--- a/changelog/0.33.0.md
+++ b/changelog/0.33.0.md
@@ -1,4 +1,6 @@
 ### 0.33.0
+- [Revision 0.33.21](https://github.com/sinclairzx81/typebox/pull/1064)
+  - [1063](https://github.com/sinclairzx81/typebox/issues/1063) Hotfix to resolve variable shadowing on Object (Parser Runtime)
 - [Revision 0.33.20](https://github.com/sinclairzx81/typebox/pull/1062)
   - Add TypeScript Parsing Infrastructure. Add Parse API to top level import.
 - [Revision 0.33.19](https://github.com/sinclairzx81/typebox/pull/1061)
diff --git a/package-lock.json b/package-lock.json
index fae9cd780..f9c7d9407 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.20",
+  "version": "0.33.21",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.20",
+      "version": "0.33.21",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index e31bce433..4dbbc3ef6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.20",
+  "version": "0.33.21",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/parse/runtime.ts b/src/parse/runtime.ts
index de018ed65..933f93894 100644
--- a/src/parse/runtime.ts
+++ b/src/parse/runtime.ts
@@ -322,7 +322,7 @@ const ObjectMapping = (values: Record<string, Types.TSchema>[]) => Types.Object(
   return { ...properties, ...record }
 }, {} as Types.TProperties))
 // prettier-ignore
-const Object = Runtime.Tuple([
+const _Object = Runtime.Tuple([
   Runtime.Const(LBrace),
   Runtime.Ref<Record<string, Types.TSchema>[]>('Properties'),
   Runtime.Const(RBrace)
@@ -644,7 +644,7 @@ export const Module = new Runtime.Module({
   Property,
   PropertyDelimiter,
   Properties,
-  Object,
+  Object: _Object,
   Elements,
   Tuple,
   Parameter,

From 6cf8596c3a0d456c3718798bb601f21f799de63c Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Sat, 9 Nov 2024 23:09:10 +0900
Subject: [PATCH 298/369] Revision 0.33.22 (#1065)

* Remove Parse from Top Level Import

* Rename Parse submodule to Syntax

* Export Parse Inference Types

* ChangeLog

* Version
---
 changelog/0.33.0.md                           |  2 ++
 example/index.ts                              |  5 ++--
 package-lock.json                             |  4 +--
 package.json                                  |  2 +-
 src/index.ts                                  |  5 +---
 src/{parse => syntax}/index.ts                |  2 +-
 src/{parse => syntax}/parse.ts                | 27 ++++++++++++-------
 src/{parse => syntax}/parsebox/index.ts       |  0
 .../parsebox/runtime/guard.ts                 |  0
 .../parsebox/runtime/index.ts                 |  0
 .../parsebox/runtime/module.ts                |  0
 .../parsebox/runtime/parse.ts                 |  0
 .../parsebox/runtime/token.ts                 |  0
 .../parsebox/runtime/types.ts                 |  0
 .../parsebox/static/index.ts                  |  0
 .../parsebox/static/parse.ts                  |  0
 .../parsebox/static/token.ts                  |  0
 .../parsebox/static/types.ts                  |  0
 src/{parse => syntax}/runtime.ts              |  2 +-
 src/{parse => syntax}/static.ts               |  2 +-
 src/tsconfig.json                             |  2 +-
 task/build/package/build.ts                   |  2 +-
 test/runtime/index.ts                         |  2 +-
 test/runtime/parse/index.ts                   |  1 -
 test/runtime/syntax/index.ts                  |  1 +
 .../{parse/parse.ts => syntax/syntax.ts}      |  3 ++-
 tsconfig.json                                 |  2 +-
 27 files changed, 36 insertions(+), 28 deletions(-)
 rename src/{parse => syntax}/index.ts (98%)
 rename src/{parse => syntax}/parse.ts (59%)
 rename src/{parse => syntax}/parsebox/index.ts (100%)
 rename src/{parse => syntax}/parsebox/runtime/guard.ts (100%)
 rename src/{parse => syntax}/parsebox/runtime/index.ts (100%)
 rename src/{parse => syntax}/parsebox/runtime/module.ts (100%)
 rename src/{parse => syntax}/parsebox/runtime/parse.ts (100%)
 rename src/{parse => syntax}/parsebox/runtime/token.ts (100%)
 rename src/{parse => syntax}/parsebox/runtime/types.ts (100%)
 rename src/{parse => syntax}/parsebox/static/index.ts (100%)
 rename src/{parse => syntax}/parsebox/static/parse.ts (100%)
 rename src/{parse => syntax}/parsebox/static/token.ts (100%)
 rename src/{parse => syntax}/parsebox/static/types.ts (100%)
 rename src/{parse => syntax}/runtime.ts (99%)
 rename src/{parse => syntax}/static.ts (99%)
 delete mode 100644 test/runtime/parse/index.ts
 create mode 100644 test/runtime/syntax/index.ts
 rename test/runtime/{parse/parse.ts => syntax/syntax.ts} (99%)

diff --git a/changelog/0.33.0.md b/changelog/0.33.0.md
index f42f59f27..31140defd 100644
--- a/changelog/0.33.0.md
+++ b/changelog/0.33.0.md
@@ -1,4 +1,6 @@
 ### 0.33.0
+- [Revision 0.33.22](https://github.com/sinclairzx81/typebox/pull/1065)
+  - Rename TypeScript parsing infrastructure from `/parse` to `/syntax`. Remove Parse API from top level import.
 - [Revision 0.33.21](https://github.com/sinclairzx81/typebox/pull/1064)
   - [1063](https://github.com/sinclairzx81/typebox/issues/1063) Hotfix to resolve variable shadowing on Object (Parser Runtime)
 - [Revision 0.33.20](https://github.com/sinclairzx81/typebox/pull/1062)
diff --git a/example/index.ts b/example/index.ts
index 711d7d03e..9d228684a 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -1,7 +1,8 @@
 import { TypeSystem } from '@sinclair/typebox/system'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 import { Value, ValuePointer } from '@sinclair/typebox/value'
-import { Type, Parse, TypeGuard, Kind, Static, TSchema } from '@sinclair/typebox'
+import { Parse, StaticParseAsType } from '@sinclair/typebox/syntax'
+import { Type, TypeGuard, Kind, Static, TSchema } from '@sinclair/typebox'
 
 // -----------------------------------------------------------
 // Create: Type
@@ -21,7 +22,7 @@ console.log(T)
 // Parse: Type
 // -----------------------------------------------------------
 
-const S = Parse({ T }, `Partial<T>`)
+const S = Parse({ T }, `{ x: T, y: T, z: T }`)
 
 type S = Static<typeof S>
 
diff --git a/package-lock.json b/package-lock.json
index f9c7d9407..262945a64 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.21",
+  "version": "0.33.22",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.21",
+      "version": "0.33.22",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 4dbbc3ef6..1a8dff98f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.21",
+  "version": "0.33.22",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/index.ts b/src/index.ts
index 9f0429d85..6a99799a0 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -38,10 +38,7 @@ export * from './type/patterns/index'
 export * from './type/registry/index'
 export * from './type/sets/index'
 export * from './type/symbols/index'
-// ------------------------------------------------------------------
-// Parse
-// ------------------------------------------------------------------
-export * from './parse/index'
+
 // ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
diff --git a/src/parse/index.ts b/src/syntax/index.ts
similarity index 98%
rename from src/parse/index.ts
rename to src/syntax/index.ts
index d0a1a960c..ae2cee724 100644
--- a/src/parse/index.ts
+++ b/src/syntax/index.ts
@@ -1,6 +1,6 @@
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox
+@sinclair/typebox/syntax
 
 The MIT License (MIT)
 
diff --git a/src/parse/parse.ts b/src/syntax/parse.ts
similarity index 59%
rename from src/parse/parse.ts
rename to src/syntax/parse.ts
index ef9928f2e..4605b9cbe 100644
--- a/src/parse/parse.ts
+++ b/src/syntax/parse.ts
@@ -1,6 +1,6 @@
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox
+@sinclair/typebox/syntax
 
 The MIT License (MIT)
 
@@ -29,23 +29,30 @@ THE SOFTWARE.
 import { Static } from './parsebox/index'
 import { CreateType } from '../type/create/type'
 import { TSchema, SchemaOptions } from '../type/schema/index'
+import { StaticDecode } from '../type/static/index'
 import { Module } from './runtime'
 import { Type } from './static'
 
-/** `[Experimental]` Parses a TypeScript type annotation as an inferred TypeBox type */
-export function Parse<Code extends string, Context extends Record<PropertyKey, TSchema> = {}>(context: Context, code: Code, options?: SchemaOptions): Static.Parse<Type, Code, Context>[0]
-/** `[Experimental]` Parses a TypeScript type annotation as an inferred TypeBox type */
-export function Parse<Code extends string>(code: Code, options?: SchemaOptions): Static.Parse<Type, Code, {}>[0]
-/** `[Experimental]` Parses a TypeScript type annotation as an inferred TypeBox type */
+/** `[Experimental]` Infers a TypeBox type from TypeScript syntax. */
+export type StaticParseAsSchema<Context extends Record<PropertyKey, TSchema>, Code extends string> = Static.Parse<Type, Code, Context>[0]
+
+/** `[Experimental]` Infers a TypeScript type from TypeScript syntax. */
+export type StaticParseAsType<Context extends Record<PropertyKey, TSchema>, Code extends string> = StaticParseAsSchema<Context, Code> extends infer Type extends TSchema ? StaticDecode<Type> : undefined
+
+/** `[Experimental]` Parses a TypeBox type from TypeScript syntax. */
+export function Parse<Context extends Record<PropertyKey, TSchema>, Code extends string>(context: Context, code: Code, options?: SchemaOptions): StaticParseAsSchema<Context, Code>
+/** `[Experimental]` Parses a TypeBox type from TypeScript syntax. */
+export function Parse<Code extends string>(code: Code, options?: SchemaOptions): StaticParseAsSchema<{}, Code>
+/** `[Experimental]` Parses a TypeBox type from TypeScript syntax. */
 export function Parse(...args: any[]): never {
   return ParseOnly.apply(null, args as never) as never
 }
 
-/** `[Experimental]` Parses a TypeScript type annotation as TSchema */
-export function ParseOnly<Code extends string, Context extends Record<PropertyKey, TSchema> = {}>(context: Context, code: Code, options?: SchemaOptions): TSchema | undefined
-/** `[Experimental]` Parses a TypeScript type annotation as TSchema */
+/** `[Experimental]` Parses a TypeBox TSchema from TypeScript syntax. This function does not infer the type. */
+export function ParseOnly<Context extends Record<PropertyKey, TSchema>, Code extends string>(context: Context, code: Code, options?: SchemaOptions): TSchema | undefined
+/** `[Experimental]` Parses a TypeBox TSchema from TypeScript syntax */
 export function ParseOnly<Code extends string>(code: Code, options?: SchemaOptions): TSchema | undefined
-/** `[Experimental]` Parses a TypeScript type annotation as TSchema */
+/** `[Experimental]` Parses a TypeBox TSchema from TypeScript syntax. This function does not infer the type. */
 export function ParseOnly(...args: any[]): TSchema | undefined {
   const withContext = typeof args[0] === 'string' ? false : true
   const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}]
diff --git a/src/parse/parsebox/index.ts b/src/syntax/parsebox/index.ts
similarity index 100%
rename from src/parse/parsebox/index.ts
rename to src/syntax/parsebox/index.ts
diff --git a/src/parse/parsebox/runtime/guard.ts b/src/syntax/parsebox/runtime/guard.ts
similarity index 100%
rename from src/parse/parsebox/runtime/guard.ts
rename to src/syntax/parsebox/runtime/guard.ts
diff --git a/src/parse/parsebox/runtime/index.ts b/src/syntax/parsebox/runtime/index.ts
similarity index 100%
rename from src/parse/parsebox/runtime/index.ts
rename to src/syntax/parsebox/runtime/index.ts
diff --git a/src/parse/parsebox/runtime/module.ts b/src/syntax/parsebox/runtime/module.ts
similarity index 100%
rename from src/parse/parsebox/runtime/module.ts
rename to src/syntax/parsebox/runtime/module.ts
diff --git a/src/parse/parsebox/runtime/parse.ts b/src/syntax/parsebox/runtime/parse.ts
similarity index 100%
rename from src/parse/parsebox/runtime/parse.ts
rename to src/syntax/parsebox/runtime/parse.ts
diff --git a/src/parse/parsebox/runtime/token.ts b/src/syntax/parsebox/runtime/token.ts
similarity index 100%
rename from src/parse/parsebox/runtime/token.ts
rename to src/syntax/parsebox/runtime/token.ts
diff --git a/src/parse/parsebox/runtime/types.ts b/src/syntax/parsebox/runtime/types.ts
similarity index 100%
rename from src/parse/parsebox/runtime/types.ts
rename to src/syntax/parsebox/runtime/types.ts
diff --git a/src/parse/parsebox/static/index.ts b/src/syntax/parsebox/static/index.ts
similarity index 100%
rename from src/parse/parsebox/static/index.ts
rename to src/syntax/parsebox/static/index.ts
diff --git a/src/parse/parsebox/static/parse.ts b/src/syntax/parsebox/static/parse.ts
similarity index 100%
rename from src/parse/parsebox/static/parse.ts
rename to src/syntax/parsebox/static/parse.ts
diff --git a/src/parse/parsebox/static/token.ts b/src/syntax/parsebox/static/token.ts
similarity index 100%
rename from src/parse/parsebox/static/token.ts
rename to src/syntax/parsebox/static/token.ts
diff --git a/src/parse/parsebox/static/types.ts b/src/syntax/parsebox/static/types.ts
similarity index 100%
rename from src/parse/parsebox/static/types.ts
rename to src/syntax/parsebox/static/types.ts
diff --git a/src/parse/runtime.ts b/src/syntax/runtime.ts
similarity index 99%
rename from src/parse/runtime.ts
rename to src/syntax/runtime.ts
index 933f93894..0d28dbbf2 100644
--- a/src/parse/runtime.ts
+++ b/src/syntax/runtime.ts
@@ -1,6 +1,6 @@
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox
+@sinclair/typebox/syntax
 
 The MIT License (MIT)
 
diff --git a/src/parse/static.ts b/src/syntax/static.ts
similarity index 99%
rename from src/parse/static.ts
rename to src/syntax/static.ts
index 90bec8e33..ff75dca2e 100644
--- a/src/parse/static.ts
+++ b/src/syntax/static.ts
@@ -1,6 +1,6 @@
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox
+@sinclair/typebox/syntax
 
 The MIT License (MIT)
 
diff --git a/src/tsconfig.json b/src/tsconfig.json
index e53e3ebf1..89a62a897 100644
--- a/src/tsconfig.json
+++ b/src/tsconfig.json
@@ -1,4 +1,4 @@
 {
   "extends": "../tsconfig.json",
-  "files": ["compiler/index.ts", "errors/index.ts", "system/index.ts", "type/index.ts", "value/index.ts", "index.ts"]
+  "files": ["compiler/index.ts", "errors/index.ts", "syntax/index.ts", "system/index.ts", "type/index.ts", "value/index.ts", "index.ts"]
 }
diff --git a/task/build/package/build.ts b/task/build/package/build.ts
index a7fc92f33..0e05ede91 100644
--- a/task/build/package/build.ts
+++ b/task/build/package/build.ts
@@ -32,7 +32,7 @@ import { createPackageJson } from './create-package-json'
 /** Builds package.json and redirect directories */
 export async function build(target: string) {
   console.log('building...package.json')
-  const submodules = ['compiler', 'errors', 'parse', 'system', 'type', 'value']
+  const submodules = ['compiler', 'errors', 'syntax', 'system', 'type', 'value']
   await createPackageJsonRedirect(target, submodules)
   await createPackageJson(target, submodules)
 }
diff --git a/test/runtime/index.ts b/test/runtime/index.ts
index 56b6a3434..ec19724e0 100644
--- a/test/runtime/index.ts
+++ b/test/runtime/index.ts
@@ -8,7 +8,7 @@ TypeSystemPolicy.InstanceMode = 'freeze'
 import './compiler/index'
 import './compiler-ajv/index'
 import './errors/index'
-import './parse/index'
+import './syntax/index'
 import './system/index'
 import './type/index'
 import './value/index'
diff --git a/test/runtime/parse/index.ts b/test/runtime/parse/index.ts
deleted file mode 100644
index 09cc87100..000000000
--- a/test/runtime/parse/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-import './parse'
diff --git a/test/runtime/syntax/index.ts b/test/runtime/syntax/index.ts
new file mode 100644
index 000000000..8d81ae4fb
--- /dev/null
+++ b/test/runtime/syntax/index.ts
@@ -0,0 +1 @@
+import './syntax'
diff --git a/test/runtime/parse/parse.ts b/test/runtime/syntax/syntax.ts
similarity index 99%
rename from test/runtime/parse/parse.ts
rename to test/runtime/syntax/syntax.ts
index 1ac85df70..11e28298d 100644
--- a/test/runtime/parse/parse.ts
+++ b/test/runtime/syntax/syntax.ts
@@ -1,5 +1,6 @@
 import { TypeGuard } from '@sinclair/typebox'
-import { Type, Parse } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Parse } from '@sinclair/typebox/syntax'
 import { Assert } from '../assert/index'
 
 // prettier-ignore
diff --git a/tsconfig.json b/tsconfig.json
index 811eedcdd..34a4b8f21 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -8,7 +8,7 @@
     "paths": {
       "@sinclair/typebox/compiler": ["src/compiler/index.ts"],
       "@sinclair/typebox/errors": ["src/errors/index.ts"],
-      "@sinclair/typebox/parse": ["src/parse/index.ts"],
+      "@sinclair/typebox/syntax": ["src/syntax/index.ts"],
       "@sinclair/typebox/system": ["src/system/index.ts"],
       "@sinclair/typebox/type": ["src/type/index.ts"],
       "@sinclair/typebox/value": ["src/value/index.ts"],

From 46b09f7e83a5e8ced61d910e8635df3838a73657 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sun, 10 Nov 2024 19:05:17 +0900
Subject: [PATCH 299/369] Documentation

---
 readme.md                                           | 4 ++--
 task/benchmark/compression/module/typebox-parse.ts  | 3 ---
 task/benchmark/compression/module/typebox-syntax.ts | 3 +++
 3 files changed, 5 insertions(+), 5 deletions(-)
 delete mode 100644 task/benchmark/compression/module/typebox-parse.ts
 create mode 100644 task/benchmark/compression/module/typebox-syntax.ts

diff --git a/readme.md b/readme.md
index e62b15785..7cfcad304 100644
--- a/readme.md
+++ b/readme.md
@@ -1762,10 +1762,10 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ├──────────────────────┼────────────┼────────────┼─────────────┤
 │ typebox/compiler     │ '119.8 kb' │ ' 52.6 kb' │ '2.28 x'    │
 │ typebox/errors       │ ' 74.4 kb' │ ' 33.1 kb' │ '2.25 x'    │
-│ typebox/parse        │ '115.3 kb' │ ' 48.3 kb' │ '2.39 x'    │
+│ typebox/syntax       │ '115.3 kb' │ ' 48.3 kb' │ '2.39 x'    │
 │ typebox/system       │ '  7.4 kb' │ '  3.2 kb' │ '2.33 x'    │
 │ typebox/value        │ '157.2 kb' │ ' 66.1 kb' │ '2.38 x'    │
-│ typebox              │ '127.3 kb' │ ' 53.3 kb' │ '2.39 x'    │
+│ typebox              │ ' 98.9 kb' │ ' 41.2 kb' │ '2.40 x'    │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/task/benchmark/compression/module/typebox-parse.ts b/task/benchmark/compression/module/typebox-parse.ts
deleted file mode 100644
index 7ba2bf33a..000000000
--- a/task/benchmark/compression/module/typebox-parse.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import * as Parse from '@sinclair/typebox/parse'
-
-console.log(Parse)
diff --git a/task/benchmark/compression/module/typebox-syntax.ts b/task/benchmark/compression/module/typebox-syntax.ts
new file mode 100644
index 000000000..311871c68
--- /dev/null
+++ b/task/benchmark/compression/module/typebox-syntax.ts
@@ -0,0 +1,3 @@
+import * as Syntax from '@sinclair/typebox/syntax'
+
+console.log(Syntax)

From ec510b8a3e6238bfd461fd62533a85565815ab81 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Mon, 11 Nov 2024 14:00:45 +0900
Subject: [PATCH 300/369] Documentation (#1066)

---
 readme.md | 147 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 147 insertions(+)

diff --git a/readme.md b/readme.md
index 7cfcad304..ea74942f9 100644
--- a/readme.md
+++ b/readme.md
@@ -77,6 +77,11 @@ License MIT
   - [Transform](#types-transform)
   - [Guard](#types-guard)
   - [Unsafe](#types-unsafe)
+- [Syntax](#syntax)
+  - [Parse](#syntax-parse)
+  - [Param](#syntax-param)
+  - [Static](#syntax-static)
+  - [Limits](#syntax-limits)
 - [Values](#values)
   - [Assert](#values-assert)
   - [Create](#values-create)
@@ -1077,6 +1082,148 @@ if(TypeGuard.IsString(T)) {
 }
 ```
 
+<a name='syntax'></a>
+
+## Syntax
+
+TypeBox supports parsing TypeScript type annotation syntax directly into TypeBox types, providing an alternative to the Type.* API for type construction. This feature functions at runtime and within the TypeScript type system, enabling types encoded as strings to be inferred as equivalent TypeBox types.
+
+TypeScript syntax parsing is provided as an optional import.
+
+```typescript
+import { Parse } from '@sinclair/typebox/syntax'
+```
+
+<a name='syntax-parse'></a>
+
+### Parse
+
+The Parse function can be used to parse TypeScript code into TypeBox types. The left hand result will be a inferred TypeBox type of TSchema. Invalid syntax will result in an undefined return value.
+
+```typescript
+const A = Parse('string')                           // const A: TString
+
+const B = Parse('[1, 2, 3]')                        // const B: TTuple<[
+                                                    //   TLiteral<1>,
+                                                    //   TLiteral<2>,
+                                                    //   TLiteral<3>
+                                                    // ]>
+
+const C = Parse(`{ x: number, y: number }`)         // const C: TObject<{
+                                                    //   x: TNumber
+                                                    //   y: TNumber
+                                                    // }>
+```
+
+<a name='syntax-param'></a>
+
+### Param
+
+The Parse function accepts an optional context parameter that enables external types to be referenced within the syntax. This can be helpful for reusing types in different contexts.
+
+```typescript
+const T = Type.Object({                             // could be written as: Parse(`{
+  x: Type.Number(),                                 //   x: number,
+  y: Type.Number(),                                 //   y: number,
+  z: Type.Number()                                 //    z: number
+})                                                  // }`)
+
+const A = Parse({ T }, `Partial<T>`)                // const A: TObject<{
+                                                    //   x: TOptional<TNumber>,
+                                                    //   y: TOptional<TNumber>,
+                                                    //   z: TOptional<TNumber>
+                                                    // }>
+
+const B = Parse({ T }, `keyof T`)                   // const B: TUnion<[
+                                                    //   TLiteral<'x'>,
+                                                    //   TLiteral<'y'>,
+                                                    //   TLiteral<'z'>
+                                                    // ]>
+
+const C = Parse({ T }, `T & { w: number }`)         // const C: TObject<{
+                                                    //   x: TNumber,
+                                                    //   y: TNumber,
+                                                    //   z: TNumber,
+                                                    //   w: TNumber
+                                                    // }>
+
+
+```
+
+<a name='syntax-static'></a>
+
+### Static
+
+TypeBox provides two Static types for inferring TypeScript syntax directly from strings.
+
+```typescript
+import { StaticParseAsSchema, StaticParseAsType } from '@sinclair/typebox/syntax' 
+
+// Will infer as a TSchema
+
+type S = StaticParseAsSchema<`{ x: number }`>       // type S: TObject<{
+                                                    //   x: TNumber
+                                                    // }>
+
+// Will infer as a type
+
+type T = StaticParseAsType<`{ x: number }`>         // type T = {
+                                                    //  x: number
+                                                    //                       
+```
+
+
+<a name='syntax-limits'></a>
+
+### Limits
+
+The Parse function works by TypeBox parsing TypeScript syntax within the type system itself. This can place some additional demand on the TypeScript compiler, which may affect language service (LSP) responsiveness when working with especially large or complex types. In particular, very wide structures or deeply nested types may approach TypeScript’s instantiation limits.
+
+```typescript
+// Excessively wide structures will result in instantiation limits exceeding
+const A = Parse(`[
+  0, 1, 2, 3, 4, 5, 6, 7,
+  0, 1, 2, 3, 4, 5, 6, 7,
+  0, 1, 2, 3, 4, 5, 6, 7,
+  0, 1, 2, 3, 4, 5, 6, 7,
+  0, 1, 2, 3, 4, 5, 6, 7,
+  0, 1, 2, 3, 4, 5, 6, 7,
+  0, 1, 2, 3, 4, 5, 6, 7,
+  0, 1, 2, 3, 4, 5, 6, 7,
+]`)
+
+// Excessively nested structures will result in instantiation limits exceeding
+const B = Parse(`{
+  x: {
+    y: {
+      z: {
+        w: 1 <-- Type instantiation is excessively deep and possibly infinite.
+      } 
+    }
+  }  
+}`)
+```
+
+For parsing especially complex types, TypeBox provides the ParseOnly function, which parses strings at runtime and returns a non-inferred TSchema type. ParseOnly allows for arbitrarily complex types without reaching instantiation limits, making it useful for cases where TypeScript types need to be directly converted to Json Schema.
+
+```typescript
+import { ParseOnly } from '@sinclair/typebox/syntax'
+
+// ok: but where A is TSchema | undefined 
+
+const A = ParseOnly(`{
+  x: {
+    y: {
+      z: {
+        w: 1
+      } 
+    }
+  }  
+}`)
+```
+
+Optimizing TypeScript string parsing performance is an ongoing area of research. For more information, see the [ParseBox](https://github.com/sinclairzx81/parsebox) project, which documents TypeBox’s parsing infrastructure and focuses efforts to improve parsing performance.
+
 <a name='values'></a>
 
 ## Values

From 4833af59bc77bc13830ee59fd97eddd8c097af04 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Mon, 11 Nov 2024 16:16:01 +0900
Subject: [PATCH 301/369] Documentation

---
 readme.md | 31 +++++++++++++++++++------------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/readme.md b/readme.md
index ea74942f9..5836c10a8 100644
--- a/readme.md
+++ b/readme.md
@@ -79,7 +79,7 @@ License MIT
   - [Unsafe](#types-unsafe)
 - [Syntax](#syntax)
   - [Parse](#syntax-parse)
-  - [Param](#syntax-param)
+  - [Context](#syntax-context)
   - [Static](#syntax-static)
   - [Limits](#syntax-limits)
 - [Values](#values)
@@ -1100,6 +1100,8 @@ import { Parse } from '@sinclair/typebox/syntax'
 
 The Parse function can be used to parse TypeScript code into TypeBox types. The left hand result will be a inferred TypeBox type of TSchema. Invalid syntax will result in an undefined return value.
 
+[TypeScript Link Here](https://www.typescriptlang.org/play/?moduleResolution=99&module=199#code/JYWwDg9gTgLgBAbzgBQIZQM4FM4F84BmUEIcA5AAIbAB2AxgDarBQD0MAnmFgEYQAerDBxoxU-MgChJdCDQzwAgnAC8KdNgAUZBVFoBzMgEo4ps+YuXLrVnFnylALjgAVAMow9NfdPsK4AEKq6phY2gDaAIwANHAATLEAzAC6xlbpGTZ2cv4Bzi4uAK5gDFgAPOGSGdU1tdVZpi4AMsAwWFCoDGWRAHzRVXWDQ5m2jS1tHV1xfQPDc3MNruPtnWWJPbPzW7VZyRsyOfAAwsFooZoABkj8zjSFIDztsRy3949QeBcm6Vl+x-kAeR4ACssHQYGUEJttjCrIsbq4AHJvdrQ2Ho0yLF5IlFQNEY2FZXD7IA)
+
 ```typescript
 const A = Parse('string')                           // const A: TString
 
@@ -1115,11 +1117,13 @@ const C = Parse(`{ x: number, y: number }`)         // const C: TObject<{
                                                     // }>
 ```
 
-<a name='syntax-param'></a>
+<a name='syntax-context'></a>
+
+### Context
 
-### Param
+The Parse function accepts an optional context parameter that enables external types to be referenced within the syntax.
 
-The Parse function accepts an optional context parameter that enables external types to be referenced within the syntax. This can be helpful for reusing types in different contexts.
+[TypeScript Link Here](https://www.typescriptlang.org/play/?moduleResolution=99&module=199#code/JYWwDg9gTgLgBAbzgBQIZQM4FM4F84BmUEIcA5AAIbAB2AxgDarBQD0MAnmFgEYQAerDBxoxU-MgChQkWIjgAVLjnxES5KrUbM2nbnwmTJdCDQzwFcALyLlAOgDyPAFZY6MABRI4P33-8BgayscCYArgwAJnA8OADuUMAwMFg0cKgYAFwo6NgeAAYIkj782UrcdgByYSCxUB4AlAA0ga1tbcG+pXA0NXVNxXAcZfbVtVj1ze3TM50+wz19EwM+AF4jFWN1jTO7rXNr2b3jUJK4DXuXV-6duPkNRiZm8ACC1jmYWF6KeC35aLBgKgGAAeBQAPnuV06T3McBeZScrncIKK13R1wO3QUDjAMGApmBYK2E3BKwxFNmIXmiLxBJoRIUJKgZMGlPZQWpcHWilx+MJoKZSxZbI5Yp8t3Bj1McIAQu8AXkkJZcH8ANZYDgQAiKKHomEy+CysoAVRo9JBAG1ReKOQcFAAZJITIlkCSs222+1OlJQV0cMgez1i73Ov2gsirQM24MYzoAXSlxkNcAAwgrcl9lb84PlLAAyeRxI7CvB6zmhFOpsoASVEE2wKMtOJcbhgqJjscxXLg2OZAG5O13LgchmUB0Ph7tRzyhSdB1OKZKWi3ke20Yv9T3i4oJ5ut3hwYmjEA)
 
 ```typescript
 const T = Type.Object({                             // could be written as: Parse(`{
@@ -1140,12 +1144,13 @@ const B = Parse({ T }, `keyof T`)                   // const B: TUnion<[
                                                     //   TLiteral<'z'>
                                                     // ]>
 
-const C = Parse({ T }, `T & { w: number }`)         // const C: TObject<{
-                                                    //   x: TNumber,
-                                                    //   y: TNumber,
-                                                    //   z: TNumber,
-                                                    //   w: TNumber
-                                                    // }>
+const C = Parse({ T }, `T & { w: number }`)         // const C: TIntersect<[TObject<{
+                                                    //    x: TNumber;
+                                                    //    y: TNumber;
+                                                    //    z: TNumber;
+                                                    // }>, TObject<{
+                                                    //    w: TNumber;
+                                                    // }>]>
 
 
 ```
@@ -1156,18 +1161,20 @@ const C = Parse({ T }, `T & { w: number }`)         // const C: TObject<{
 
 TypeBox provides two Static types for inferring TypeScript syntax directly from strings.
 
+[TypeScript Link Here](https://www.typescriptlang.org/play/?moduleResolution=99&module=199#code/JYWwDg9gTgLgBAbzgZRgQxsAxgBTVAZwFMBBA5LACyJDQBoV1Nd9iyAVATzCLgF84AMygQQcAOQABAsAB2WADZpgUAPQxuRAEYQAHqoKdZ6XeLgAoc6tVwA6sAUK4cwUShw0BD3HYVqtSw0eFDgAXkYMbDxCUnIqGjQAHgQ+BgADJF0ALjhZAFcQLTd+NIA+OArrOCDeZBz2AHktACsiLBhk8wrunt6+-oHBgaqK7J8AOQKiqC6hufmF3qq+Ussq+0dnWVd3T28awM0fMIjmaLYCLh5k1LgMuDH8wuK+MqWbGuPwhFnFv--3qMck9pr8AeDFiM4EA)
+
 ```typescript
 import { StaticParseAsSchema, StaticParseAsType } from '@sinclair/typebox/syntax' 
 
 // Will infer as a TSchema
 
-type S = StaticParseAsSchema<`{ x: number }`>       // type S: TObject<{
+type S = StaticParseAsSchema<{}, `{ x: number }`>   // type S: TObject<{
                                                     //   x: TNumber
                                                     // }>
 
 // Will infer as a type
 
-type T = StaticParseAsType<`{ x: number }`>         // type T = {
+type T = StaticParseAsType<{}, `{ x: number }`>     // type T = {
                                                     //  x: number
                                                     //                       
 ```

From 4e2158deb238b1fe958b0f78ad9e05f21e45041c Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Mon, 11 Nov 2024 20:06:45 +0900
Subject: [PATCH 302/369] Standard Schema Reference

---
 example/standard/index.ts    | 29 +++++++++++++++
 example/standard/readme.md   | 67 +++++++++++++++++++++++++++++++++++
 example/standard/standard.ts | 68 ++++++++++++++++++++++++++++++++++++
 3 files changed, 164 insertions(+)
 create mode 100644 example/standard/index.ts
 create mode 100644 example/standard/readme.md
 create mode 100644 example/standard/standard.ts

diff --git a/example/standard/index.ts b/example/standard/index.ts
new file mode 100644
index 000000000..331f30aa4
--- /dev/null
+++ b/example/standard/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/standard-schema
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './standard'
\ No newline at end of file
diff --git a/example/standard/readme.md b/example/standard/readme.md
new file mode 100644
index 000000000..343d60616
--- /dev/null
+++ b/example/standard/readme.md
@@ -0,0 +1,67 @@
+### Standard Schema
+
+This example is a reference implementation of [Standard Schema](https://github.com/standard-schema/standard-schema) for TypeBox.
+
+### Overview
+
+This example provides a reference implementation for the Standard Schema specification. Despite the name, this specification is NOT focused on schematics. Rather, it defines a set of common TypeScript interfaces that libraries are expected to implement to be considered "Standard" for framework integration, as defined by the specification's authors.
+
+The TypeBox project has some concerns about the Standard Schema specification, particularly regarding its avoidance to separate concerns between schematics and the logic used to validate those schematics. TypeBox does respect such separation for direct interoperability with industry standard validators as well as to allow intermediate processing of types (Compile). Additionally, augmenting schematics in the way proposed by Standard Schema would render Json Schema invalidated (which is a general concern for interoperability with Json Schema validation infrastructure, such as Ajv).
+
+The Standard Schema specification is currently in its RFC stage. TypeBox advocates for renaming the specification to better reflect its purpose, such as "Common Interface for Type Integration." Additionally, the requirement for type libraries to adopt a common interface for integration warrants review. The reference project link provided below demonstrates an alternative approach that would enable integration of all type libraries (including those not immediately compatible with Standard Schema) to be integrated into frameworks (such as tRPC) without modification to a library's core structure.
+
+[Type Adapters](https://github.com/sinclairzx81/type-adapters)
+
+### Example
+
+The Standard Schema function will augment TypeBox's Json Schema with runtime validation methods. These methods are assigned to the sub property `~standard`. Once a type is augmented, it should no longer be considered valid Json Schema.
+
+```typescript
+import { Type } from '@sinclair/typebox'
+import { StandardSchema } from './standard'
+
+// The Standard Schema function will augment a TypeBox type with runtime validation 
+// logic to validate / parse a value (as mandated by the Standard Schema interfaces). 
+// Calling this function will render the json-schema schematics invalidated, specifically
+// the non-standard keyword `~standard` which ideally should be expressed as a non
+// serializable symbol (Ajv strict)
+
+const A = StandardSchema(Type.Object({     // const A = {
+  x: Type.Number(),                        //   '~standard': { version: 1, vendor: 'TypeBox', validate: [Function: validate] },
+  y: Type.Number(),                        //   type: 'object',
+  z: Type.Number(),                        //   properties: {
+}))                                        //     x: { type: 'number', [Symbol(TypeBox.Kind)]: 'Number' },
+                                           //     y: { type: 'number', [Symbol(TypeBox.Kind)]: 'Number' },
+                                           //     z: { type: 'number', [Symbol(TypeBox.Kind)]: 'Number' }
+                                           //   },
+                                           //   required: [ 'x', 'y', 'z' ],
+                                           //   [Symbol(TypeBox.Kind)]: 'Object'
+                                           // }
+
+const R = A['~standard'].validate({ x: 1, y: 2, z: 3 }) // const R = { value: { x: 1, y: 2, z: 3 }, issues: [] }
+```
+
+### Ajv Strict
+
+Applying Standard Schema to a TypeBox types renders them unusable in Ajv. The issue is due to the `~standard` property being un-assignable as a keyword (due to the leading `~`)
+
+```typescript
+import Ajv from 'ajv'
+
+const ajv = new Ajv().addKeyword('~standard') // cannot be defined as keyword.
+
+const A = StandardSchema(Type.Object({     // const A = {
+  x: Type.Number(),                        //   '~standard': { version: 1, vendor: 'TypeBox', validate: [Function: validate] },
+  y: Type.Number(),                        //   type: 'object',
+  z: Type.Number(),                        //   properties: {
+}))                                        //     x: { type: 'number', [Symbol(TypeBox.Kind)]: 'Number' },
+                                           //     y: { type: 'number', [Symbol(TypeBox.Kind)]: 'Number' },
+                                           //     z: { type: 'number', [Symbol(TypeBox.Kind)]: 'Number' }
+                                           //   },
+                                           //   required: [ 'x', 'y', 'z' ],
+                                           //   [Symbol(TypeBox.Kind)]: 'Object'
+                                           // }
+
+
+ajv.validate(A, { x: 1, y: 2, z: 3 }) // Error: Keyword ~standard has invalid name
+```
diff --git a/example/standard/standard.ts b/example/standard/standard.ts
new file mode 100644
index 000000000..b61dcbba0
--- /dev/null
+++ b/example/standard/standard.ts
@@ -0,0 +1,68 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/standard-schema
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { AssertError, Value, ValueError } from '@sinclair/typebox/value'
+import { TSchema, StaticDecode, CloneType } from '@sinclair/typebox'
+
+// ------------------------------------------------------------------
+// StandardSchema: Common
+// ------------------------------------------------------------------
+interface StandardResult<Output> {
+  value: Output
+  issues: [ValueError[]]
+}
+interface StandardSchema<Input = unknown, Output = Input> {
+  readonly "~standard": StandardSchemaProps<Input, Output>;
+}
+
+interface StandardSchemaProps<Input = unknown, Output = Input> {
+  readonly version: 1;
+  readonly vendor: 'TypeBox';
+  readonly validate: (value: unknown) => StandardResult<Output>;
+  readonly types?: undefined;
+}
+// ------------------------------------------------------------------
+// StandardSchema: TypeBox
+// ------------------------------------------------------------------
+export type TStandardSchema<Input = unknown, Output = Input, Result = Input & StandardSchema<Input, Output>> = Result
+/** 
+ * Augments a Json Schema with runtime validation logic required by StandardSchema. Wrapping a type in this way renders the type
+ * incompatible with the Json Schema specification.
+ */
+export function StandardSchema<Type extends TSchema>(schema: Type, references: TSchema[] = []): TStandardSchema<Type, StaticDecode<Type>> {
+  const validate = (value: unknown) => {
+    try {
+      return { value: Value.Parse(schema, references, value) }
+    } catch (error) {
+      const asserted = error instanceof AssertError ? error : undefined
+      return asserted ? { issues: [...asserted.Errors()] } : { issues: ['Unknown error']}
+    }
+  }
+  const standard = { version: 1, vendor: 'TypeBox', validate }
+  return CloneType(schema, { ['~standard']: standard }) as never
+}
\ No newline at end of file

From 55ae006127a4772d58fa9069f666cd322cdd6ea8 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Wed, 13 Nov 2024 23:56:23 +0900
Subject: [PATCH 303/369] Revision 0.34.0 (#1069)

* Add Module Types

* Add Syntax Types
---
 changelog/0.34.0.md                    | 196 ++++++++++++++++
 example/prototypes/index.ts            |   1 -
 example/prototypes/module.ts           | 166 --------------
 example/prototypes/readme.md           |  40 ----
 package-lock.json                      |   4 +-
 package.json                           |   2 +-
 readme.md                              | 212 ++++++++----------
 src/compiler/compiler.ts               |  18 +-
 src/errors/errors.ts                   |   8 +
 src/index.ts                           |   3 +-
 src/syntax/parse.ts                    |  41 ++--
 src/syntax/runtime.ts                  | 233 +++++++++++++++----
 src/syntax/static.ts                   | 194 +++++++++++++---
 src/type/deref/deref.ts                | 174 --------------
 src/type/guard/kind.ts                 |   5 +
 src/type/guard/type.ts                 |  14 ++
 src/type/index.ts                      |   3 +-
 src/type/{deref => module}/index.ts    |   2 +-
 src/type/module/module.ts              | 189 ++++++++++++++++
 src/type/ref/ref.ts                    |  24 +-
 src/type/static/static.ts              |   2 +-
 src/type/strict/index.ts               |  29 ---
 src/type/strict/strict.ts              |  44 ----
 src/type/type/json.ts                  |  34 +--
 src/type/type/type.ts                  |   3 +-
 src/value/cast/cast.ts                 |  12 +-
 src/value/check/check.ts               |  12 +-
 src/value/clean/clean.ts               |  13 +-
 src/value/convert/convert.ts           |   8 +
 src/value/create/create.ts             |   8 +
 src/value/default/default.ts           |   8 +
 src/value/transform/decode.ts          |  32 ++-
 src/value/transform/encode.ts          |  12 +
 test/runtime/compiler-ajv/index.ts     |   1 +
 test/runtime/compiler-ajv/module.ts    |  78 +++++++
 test/runtime/compiler-ajv/ref.ts       |   6 +-
 test/runtime/compiler/index.ts         |   1 +
 test/runtime/compiler/module.ts        |  78 +++++++
 test/runtime/compiler/ref.ts           |   8 +-
 test/runtime/compiler/unicode.ts       |   2 +-
 test/runtime/syntax/syntax.ts          |  94 +++++++-
 test/runtime/type/guard/kind/deref.ts  | 110 ---------
 test/runtime/type/guard/kind/import.ts |  15 ++
 test/runtime/type/guard/kind/index.ts  |   2 +-
 test/runtime/type/guard/type/deref.ts  | 110 ---------
 test/runtime/type/guard/type/import.ts |  15 ++
 test/runtime/type/guard/type/index.ts  |   2 +-
 test/runtime/type/guard/type/ref.ts    |   4 +-
 test/runtime/value/cast/import.ts      |  51 +++++
 test/runtime/value/cast/index.ts       |   1 +
 test/runtime/value/cast/union.ts       |   2 +-
 test/runtime/value/check/index.ts      |   1 +
 test/runtime/value/check/module.ts     |  80 +++++++
 test/runtime/value/check/ref.ts        |   8 +-
 test/runtime/value/clean/import.ts     | 203 +++++++++++++++++
 test/runtime/value/clean/index.ts      |   1 +
 test/runtime/value/convert/import.ts   |  29 +++
 test/runtime/value/convert/index.ts    |   1 +
 test/runtime/value/create/import.ts    |  98 ++++++++
 test/runtime/value/create/index.ts     |   1 +
 test/runtime/value/create/ref.ts       |   8 +-
 test/runtime/value/default/import.ts   | 299 +++++++++++++++++++++++++
 test/runtime/value/default/index.ts    |   1 +
 test/runtime/value/transform/import.ts | 157 +++++++++++++
 test/runtime/value/transform/index.ts  |   1 +
 test/runtime/value/transform/ref.ts    |   6 +-
 test/static/deref.ts                   |  56 -----
 test/static/ref.ts                     |   4 +-
 68 files changed, 2241 insertions(+), 1039 deletions(-)
 create mode 100644 changelog/0.34.0.md
 delete mode 100644 example/prototypes/module.ts
 delete mode 100644 src/type/deref/deref.ts
 rename src/type/{deref => module}/index.ts (98%)
 create mode 100644 src/type/module/module.ts
 delete mode 100644 src/type/strict/index.ts
 delete mode 100644 src/type/strict/strict.ts
 create mode 100644 test/runtime/compiler-ajv/module.ts
 create mode 100644 test/runtime/compiler/module.ts
 delete mode 100644 test/runtime/type/guard/kind/deref.ts
 create mode 100644 test/runtime/type/guard/kind/import.ts
 delete mode 100644 test/runtime/type/guard/type/deref.ts
 create mode 100644 test/runtime/type/guard/type/import.ts
 create mode 100644 test/runtime/value/cast/import.ts
 create mode 100644 test/runtime/value/check/module.ts
 create mode 100644 test/runtime/value/clean/import.ts
 create mode 100644 test/runtime/value/convert/import.ts
 create mode 100644 test/runtime/value/create/import.ts
 create mode 100644 test/runtime/value/default/import.ts
 create mode 100644 test/runtime/value/transform/import.ts
 delete mode 100644 test/static/deref.ts

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
new file mode 100644
index 000000000..fdc9a75ff
--- /dev/null
+++ b/changelog/0.34.0.md
@@ -0,0 +1,196 @@
+## [0.34.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.34.0)
+
+## Overview
+
+Revision 0.34.0 represents a significant milestone for the TypeBox project. This update changes how TypeBox manages type references (Ref) and introduces a new Module type to support mutual recursion and self-referencing types. Additionally, it includes a new submodule for parsing TypeScript syntax directly into TypeBox types.
+
+Please note that this release includes breaking changes to Ref and some deprecations. These updates require a minor semver revision.
+
+## Contents
+
+- [Enhancements](#Enhancements)
+  - [Module Types](#Module-Types)
+  - [Syntax Types](#Syntax-Types)
+- [Breaking Changes](#Breaking-Changes)
+  - [Ref](#Ref)
+  - [Deref](#Deref)
+  - [Strict](#Strict)
+
+
+<a name="Enhancements"></a>
+
+## Enhancements
+
+Below are the enhancements introduced in Version 0.34.0.
+
+<a name="Module-Type"></a>
+
+### Module Types
+
+Revision 0.34.0 introduces a new type, called Module. Modules are represented as JSON Schema $def schematics, specifically designed to support both mutual and self-recursive types. This addition resolves a longstanding issue in TypeBox, where complex recursive structures often encountered "definition order" problems, making certain recursive structures difficult to represent cleanly. With Modules, you can now define schematics within a Module context, allowing them to be referenced within the type system through a separate inference operation.
+
+```typescript
+// The following creates a circular recursive type.
+
+const Module = Type.Module({
+  A: Type.Object({ 
+    b: Type.Ref('B') // Ref B:
+  }),
+  B: Type.Object({
+    c: Type.Ref('C') // Ref C:
+  }),
+  C: Type.Object({
+    a: Type.Ref('A') // Ref A:
+  }),
+})
+
+// Module types must be imported before use.
+
+const A = Module.Import('A')                     // const A: TImport<{...}, 'A'>
+
+type A = Static<typeof A>                        // type A = { 
+                                                 //   b: {
+                                                 //     c: {
+                                                 //       a: {
+                                                 //         b: ...
+                                                 //       }
+                                                 //     }
+                                                 //   }
+                                                 // }
+```
+
+<a name="Syntax-Types"></a>
+
+### Syntax Types
+
+
+Revision 0.34.0 introduces a new submodule for parsing TypeScript syntax directly into TypeBox types, implemented both at runtime and within the type system. This feature was made possible through the development of a separate project, [ParseBox](https://github.com/sinclairzx81/parsebox) (MIT-licensed), which provides a symmetric runtime and type-level parsing infrastructure.
+
+As of 0.34.0, Syntax Types are available as an opt-in feature, with the parsing infrastructure adding approximately 10kb (minified) to the existing type builder. With further optimizations, this feature may be elevated to a top-level import in future updates to minimize bundling size.
+
+To use Syntax Types, import them from the `@sinclair/typebox/syntax` path.
+
+```typescript
+import { Parse } from '@sinclair/typebox/syntax'
+
+// All primitive types are supported
+
+const A = Parse('string')    // const A: TString
+const B = Parse('number')    // const B: TNumber
+const C = Parse('boolean')   // const C: TBoolean
+
+// ... Multiline parsing is supported (but comments are not)
+
+const T = Parse(`{
+  x: number
+  y: number
+  z: number
+}`)
+
+
+// ... Parametertized parsing is supported
+const O = Parse({ T }, `T & { w: number }`) // const O: TIntersect<[
+                                            //   TObject<{
+                                            //     x: TNumber,
+                                            //     y: TNumber,
+                                            //     z: TNumber,
+                                            //   }>,
+                                            //   TObject<{
+                                            //     w: TNumber
+                                            //   }>
+                                            // ]>
+
+// ... Module parsing is also supported.
+
+const Math = Parse(`module Math {
+  export interface X {
+    x: number
+  }
+  export interface Y {
+    y: number
+  }
+  export interface Z {
+    z: number
+  }
+  export interface Vector extends X, Y, Z {
+    type: 'Vector'
+  }
+}`)
+
+const Vector = Math.Import('Vector')     
+```
+
+Runtime parsing performance should be quite good; however, static parsing performance could be improved. TypeScript will invoke the parser for each property accessed at design time. Ongoing efforts within the ParseBox project aim to optimize string parsing in TypeScript, with additional research underway into type-level caching strategies within the TypeScript compiler. Additional optimizations will be explored over the course of 0.34.x.
+
+<a name="Breaking-Changes"></a>
+
+## Breaking Changes
+
+The following are the breaking changes in Revision 0.34.0.
+
+<a name="Ref"></a>
+
+### Ref
+
+Revision 0.34.0 introduces a breaking change to Ref, modifying its signature to accept only constant string values. Previously, Ref could accept an existing TypeBox type, provided it had an $id assigned.
+
+```typescript
+
+// Revision 0.33.0
+
+const T = Type.String({ $id: 'T' })
+
+const R = Type.Ref(T)
+
+type R = Static<typeof R>      // type R = string
+
+// Revision 0.34.0
+
+const T = Type.String({ $id: 'T' })
+
+const R = Type.Ref('T')
+
+type R = Static<typeof R>      // type R = unknown
+
+```
+
+In Revision 0.34.0, the inferred type for Ref is now unknown. Implementations using the previous version of Ref can switch to Unsafe to type the reference to the target value.
+
+```typescript
+// Revision 0.34.0
+
+const T = Type.String({ $id: 'T' })
+
+const R = Type.Unsafe<Static<typeof T>>(Type.Ref('T'))
+
+type R = Static<typeof R>      // type R = string
+```
+
+<a name="Deref"></a>
+
+### Deref
+
+Revision 0.34.0 removes the Deref type, which was previously used to dereference schematics. Since the Ref signature has changed from TSchema to string, there is no longer a way to resolve reference types accurately. TypeBox may provide a prototype example of this type upon request.
+
+<a name="Strict"></a>
+
+### Strict
+
+Revision 0.34.0 removes the Strict type from the Type Builder, which was deprecated in version 0.33.8. This type was introduced several years ago in response to a change in Ajv that prohibited unknown keywords. At that time, TypeBox used string property keys for `kind` and `modifier`, which required either Ajv configuration or the use of Strict. These properties have since been updated to Symbol properties, resolving the issues with Ajv. However, the Strict type remained due to some use in ecosystem projects, which has since reduced.
+
+For those who still need Strict, the recommended approach is to use the JSON stringify/parse method outlined in the deprecation notice.
+
+```typescript
+/**
+ * @deprecated `[Json]` Omits compositing symbols from this schema. It is recommended
+ * to use the JSON parse/stringify to remove compositing symbols if needed. This
+ * is how Strict works internally.
+ *
+ * ```typescript
+ * JSON.parse(JSON.stringify(Type.String()))
+ * ```
+ */
+export function Strict<T extends TSchema>(schema: T): TStrict<T> {
+  return JSON.parse(JSON.stringify(schema))
+}
+```
\ No newline at end of file
diff --git a/example/prototypes/index.ts b/example/prototypes/index.ts
index cb81ad0bb..179da98fd 100644
--- a/example/prototypes/index.ts
+++ b/example/prototypes/index.ts
@@ -27,7 +27,6 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 export * from './from-schema'
-export * from './module'
 export * from './partial-deep'
 export * from './union-enum'
 export * from './union-oneof'
diff --git a/example/prototypes/module.ts b/example/prototypes/module.ts
deleted file mode 100644
index e56dcb2dd..000000000
--- a/example/prototypes/module.ts
+++ /dev/null
@@ -1,166 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/prototypes
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import * as Types from '@sinclair/typebox'
-import { Check } from '@sinclair/typebox/value'
-// ------------------------------------------------------------------
-// Infer
-// ------------------------------------------------------------------
-// prettier-ignore
-export type InferImport<Properties extends TModuleProperties, Key extends keyof Properties, Module extends TModuleProperties> = (
-  Infer<Properties[Key], Module>
-)
-// prettier-ignore
-export type InferModuleRef<Ref extends string, Module extends TModuleProperties> = (
-  Ref extends keyof Module ? Infer<Module[Ref], Module> : never
-)
-// prettier-ignore
-export type InferObject<Properties extends Types.TProperties, Module extends TModuleProperties> = { 
-  [K in keyof Properties]: Infer<Properties[K], Module> 
-} & {}
-// prettier-ignore
-export type InferConstructor<Parameters extends Types.TSchema[], InstanceType extends Types.TSchema, Module extends TModuleProperties> = Types.Ensure<
-  new (...args: InferTuple<Parameters, Module>) => Infer<InstanceType, Module>
->
-// prettier-ignore
-export type InferFunction<Parameters extends Types.TSchema[], ReturnType extends Types.TSchema, Module extends TModuleProperties> = Types.Ensure<
-  (...args: InferTuple<Parameters, Module>) => Infer<ReturnType, Module>
->
-// prettier-ignore
-export type InferTuple<Types extends Types.TSchema[], Module extends TModuleProperties, Result extends unknown[] = []> = (
-  Types extends [infer L extends Types.TSchema, ...infer R extends Types.TSchema[]]
-    ? InferTuple<R, Module, [...Result, Infer<L, Module>]>
-    : Result
-)
-// prettier-ignore
-export type InferIntersect<Types extends Types.TSchema[], Module extends TModuleProperties, Result extends unknown = unknown> = (
-  Types extends [infer L extends Types.TSchema, ...infer R extends Types.TSchema[]]
-    ? InferIntersect<R, Module, Result & Infer<L, Module>>
-    : Result
-)
-// prettier-ignore
-export type InferUnion<Types extends Types.TSchema[], Module extends TModuleProperties, Result extends unknown = never> = (
-  Types extends [infer L extends Types.TSchema, ...infer R extends Types.TSchema[]]
-    ? InferUnion<R, Module, Result | Infer<L, Module>>
-    : Result
-)
-// prettier-ignore
-export type InferArray<Type extends Types.TSchema, Module extends TModuleProperties> = (
-  Types.Ensure<Array<Infer<Type, Module>>>
-)
-// prettier-ignore
-export type InferAsyncIterator<Type extends Types.TSchema, Module extends TModuleProperties> = (
-  Types.Ensure<AsyncIterableIterator<Infer<Type, Module>>>
-)
-// prettier-ignore
-export type InferIterator<Type extends Types.TSchema, Module extends TModuleProperties> = (
-  Types.Ensure<IterableIterator<Infer<Type, Module>>>
-)
-// prettier-ignore
-type Infer<Type extends Types.TSchema, Module extends TModuleProperties = {}> = (
-  Type extends TImport<infer S extends TModuleProperties, infer K extends PropertyKey> ? InferImport<S, K, S> :
-  Type extends TModuleRef<infer S extends string> ? InferModuleRef<S, Module> :
-  Type extends Types.TObject<infer S extends Types.TProperties> ? InferObject<S, Module> :
-  Type extends Types.TConstructor<infer S extends Types.TSchema[], infer R extends Types.TSchema> ? InferConstructor<S, R, Module> :
-  Type extends Types.TFunction<infer S extends Types.TSchema[], infer R extends Types.TSchema> ? InferFunction<S, R, Module> :
-  Type extends Types.TTuple<infer S extends Types.TSchema[]> ? InferTuple<S, Module> :
-  Type extends Types.TIntersect<infer S extends Types.TSchema[]> ? InferIntersect<S, Module> :
-  Type extends Types.TUnion<infer S extends Types.TSchema[]> ? InferUnion<S, Module> :
-  Type extends Types.TArray<infer S extends Types.TSchema> ? InferArray<S, Module> :
-  Type extends Types.TAsyncIterator<infer S extends Types.TSchema> ? InferAsyncIterator<S, Module> :
-  Type extends Types.TIterator<infer S extends Types.TSchema> ? InferIterator<S, Module> :
-  Type extends Types.TTemplateLiteral<infer S extends Types.TTemplateLiteralKind[]> ? Types.Static<Types.TTemplateLiteral<S>> :
-  Type extends Types.TLiteral<infer S extends Types.TLiteralValue> ? S :
-  Type extends Types.TAny ? any :
-  Type extends Types.TBigInt ? bigint :
-  Type extends Types.TBoolean ? boolean :
-  Type extends Types.TDate ? Date :
-  Type extends Types.TInteger ? number :
-  Type extends Types.TNever ? never :
-  Type extends Types.TNumber ? number :
-  Type extends Types.TRegExp ? string :
-  Type extends Types.TString ? string :
-  Type extends Types.TSymbol ? symbol :
-  Type extends Types.TNull ? null :
-  Type extends Types.TUint8Array ? Uint8Array :
-  Type extends Types.TUndefined ? undefined :
-  Type extends Types.TUnknown ? unknown :
-  Type extends Types.TVoid ? void :
-  never
-)
-// ------------------------------------------------------------------
-// ModuleRef
-// ------------------------------------------------------------------
-// prettier-ignore
-export interface TModuleRef<Ref extends string> extends Types.TSchema {
-  [Types.Kind]: 'ModuleRef'
-  $ref: Ref
-}
-// prettier-ignore
-export function ModuleRef<Ref extends string>($ref: Ref): TModuleRef<Ref>  {
-  return Types.Type.Ref($ref) as never
-}
-// ------------------------------------------------------------------
-// Import
-// ------------------------------------------------------------------
-// prettier-ignore
-Types.TypeRegistry.Set('Import', (module: TImport, value: unknown) => {
-  const keys = Object.getOwnPropertyNames(module.$defs)
-  const references = keys.map(key => module.$defs[key as never]) as Types.TSchema[]
-  const schema = module.$defs[module.$ref]
-  return Check(schema, references, value)
-})
-// prettier-ignore
-export type TModuleProperties = Record<PropertyKey, Types.TSchema>
-
-// prettier-ignore
-export interface TImport<Definitions extends TModuleProperties = {}, Key extends keyof Definitions = keyof Definitions> extends Types.TSchema {
-  [Types.Kind]: 'Import'
-  static: InferImport<Definitions, Key, Definitions>
-  $defs: Definitions
-  $ref: Key
-}
-// ------------------------------------------------------------------
-// Module
-// ------------------------------------------------------------------
-// prettier-ignore
-export class ModuleInstance<Properties extends TModuleProperties> {
-  constructor(private readonly properties: Properties) {}
-  public Import<Key extends keyof Properties>(key: Key): TImport<Properties, Key> {
-    const $defs = globalThis.Object.getOwnPropertyNames(this.properties).reduce((Result, Key) => (
-     { ...Result, [Key]: { ...this.properties[Key], $id: Key }}
-    ), {})
-    return { [Types.Kind]: 'Import', $defs, $ref: key } as never
-  }
-}
-export function Module<Properties extends TModuleProperties>(properties: Properties): ModuleInstance<Properties> {
-  return new ModuleInstance(properties)
-}
-
-
-
diff --git a/example/prototypes/readme.md b/example/prototypes/readme.md
index 7c7c429f2..cd95b34fb 100644
--- a/example/prototypes/readme.md
+++ b/example/prototypes/readme.md
@@ -2,46 +2,6 @@
 
 TypeBox prototypes are a set of types that are either under consideration for inclusion into the library, or have been requested by users but cannot be added to the library either due to complexity, using schematics that fall outside the supported TypeBox or should be expressed by users via advanced type composition.
 
-## Module, ModuleRef and Import 
-
-The Module type as a candidate referencing system for TypeBox. Modules enable deferred cross type referencing and support mutual recursive inference. Module types must be instanced via `M.Import(...)` which constructs a `$def` schematic containing each definition required to validate, and a self referential `$ref` to one of the type being imported.
-
-```typescript
-import { Module, ModuleRef } from './prototypes'
-
-// ------------------------------------------------------------------
-// Module, ModuleRef
-// ------------------------------------------------------------------
-const Math = Module({
-  Vector2: Type.Object({
-    x: Type.Number(),
-    y: Type.Number(),
-  }),
-  Vector3: Type.Object({
-    x: Type.Number(),
-    y: Type.Number(),
-    z: Type.Number()
-  }),
-  Vertex: Type.Object({
-    position: ModuleRef('Vector3'),
-    normal: ModuleRef('Vector3'),
-    texcoord: ModuleRef('Vector2')
-  }),
-  Geometry: Type.Object({
-    vertices: Type.Array(ModuleRef('Vertex')),
-    indices: Type.Array(Type.Integer())
-  })
-})
-
-// ------------------------------------------------------------------
-// Import
-// -----------------------------------------------------------------
-
-const Vector2 = Math.Import('Vector2')
-const Vector3 = Math.Import('Vector2')
-const Vertex = Math.Import('Vertex')
-const Geometry = Math.Import('Geometry')
-```
 
 ## PartialDeep
 
diff --git a/package-lock.json b/package-lock.json
index 262945a64..fbacace2e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.22",
+  "version": "0.34.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.33.22",
+      "version": "0.34.0",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 1a8dff98f..44b16b8e3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.22",
+  "version": "0.34.0",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 5836c10a8..39fd65056 100644
--- a/readme.md
+++ b/readme.md
@@ -68,8 +68,7 @@ License MIT
   - [Options](#types-options)
   - [Properties](#types-properties)
   - [Generics](#types-generics)
-  - [References](#types-references)
-  - [Recursive](#types-recursive)
+  - [Modules](#types-modules)
   - [Template Literal](#types-template-literal)
   - [Indexed](#types-indexed)
   - [Mapped](#types-mapped)
@@ -79,7 +78,9 @@ License MIT
   - [Unsafe](#types-unsafe)
 - [Syntax](#syntax)
   - [Parse](#syntax-parse)
+  - [Compose](#syntax-compose)
   - [Context](#syntax-context)
+  - [Module](#syntax-module)
   - [Static](#syntax-static)
   - [Limits](#syntax-limits)
 - [Values](#values)
@@ -769,103 +770,40 @@ const T = Nullable(Type.String())                    // const T = {
 type T = Static<typeof T>                            // type T = string | null
 ```
 
-<a name='types-references'></a>
+<a name='types-modules'></a>
 
-### Reference Types
+### Module Types
 
-Reference types can be created with Ref. These types infer the same as the target type but only store a named `$ref` to the target type.
+TypeBox Modules are containers for related types. They function as namespaces and enable internal types to reference each other via string references. Modules support both singular and mutually recursive types. They provide a mechanism to create circular types irrespective of the order in which types are defined.
 
 ```typescript
-const Vector = Type.Object({                         // const Vector = {
-  x: Type.Number(),                                  //   type: 'object',
-  y: Type.Number(),                                  //   required: ['x', 'y', 'z'],
-}, { $id: 'Vector' })                                //   properties: {
-                                                     //     x: { type: 'number' },
-                                                     //     y: { type: 'number' }
-                                                     //   },
-                                                     //   $id: 'Vector'
-                                                     // }
-
-const VectorRef = Type.Ref(Vector)                   // const VectorRef = {
-                                                     //   $ref: 'Vector'
-                                                     // }
-
-type VectorRef = Static<typeof VectorRef>            // type VectorRef = {
-                                                     //    x: number,
-                                                     //    y: number
-                                                     // }
-```
-Use Deref to dereference a type. This function will replace any interior reference with the target type.
-```typescript
-const Vertex = Type.Object({                         // const Vertex = {
-  position: VectorRef,                               //   type: 'object',
-  texcoord: VectorRef,                               //   required: ['position', 'texcoord'],
-})                                                   //   properties: {
-                                                     //     position: { $ref: 'Vector' },
-                                                     //     texcoord: { $ref: 'Vector' }
-                                                     //   }
-                                                     // }
-
-const VertexDeref = Type.Deref(Vertex, [Vector])     // const VertexDeref = {
-                                                     //   type: 'object',
-                                                     //   required: ['position', 'texcoord'],
-                                                     //   properties: {
-                                                     //     position: {
-                                                     //       type: 'object',
-                                                     //       required: ['x', 'y', 'z'],
-                                                     //       properties: {
-                                                     //         x: { type: 'number' },
-                                                     //         y: { type: 'number' }
-                                                     //       }
-                                                     //     },
-                                                     //     texcoord: {
-                                                     //       type: 'object',
-                                                     //       required: ['x', 'y', 'z'],
-                                                     //       properties: {
-                                                     //         x: { type: 'number' },
-                                                     //         y: { type: 'number' }
-                                                     //       }
-                                                     //     }
-                                                     //   }
-                                                     // }
-```
-Note that Ref types do not store structural information about the type they're referencing. Because of this, these types cannot be used with some mapping types (such as Partial or Pick). For applications that require mapping on Ref, use Deref to normalize the type first.
-
-<a name='types-recursive'></a>
-
-### Recursive Types
-
-TypeBox supports recursive data structures with Recursive. This type wraps an interior type and provides it a `this` context that allows the type to reference itself. The following creates a recursive type. Singular recursive inference is also supported.
+// The following creates a circular recursive type.
+
+const Module = Type.Module({
+  A: Type.Object({ 
+    b: Type.Ref('B') // Ref B:
+  }),
+  B: Type.Object({
+    c: Type.Ref('C') // Ref C:
+  }),
+  C: Type.Object({
+    a: Type.Ref('A') // Ref A:
+  }),
+})
 
-```typescript
-const Node = Type.Recursive(This => Type.Object({    // const Node = {
-  id: Type.String(),                                 //   $id: 'Node',
-  nodes: Type.Array(This)                            //   type: 'object',
-}), { $id: 'Node' })                                 //   properties: {
-                                                     //     id: {
-                                                     //       type: 'string'
-                                                     //     },
-                                                     //     nodes: {
-                                                     //       type: 'array',
-                                                     //       items: {
-                                                     //         $ref: 'Node'
-                                                     //       }
-                                                     //     }
-                                                     //   },
-                                                     //   required: [
-                                                     //     'id',
-                                                     //     'nodes'
-                                                     //   ]
-                                                     // }
+// Module types must be imported before use.
 
-type Node = Static<typeof Node>                      // type Node = {
-                                                     //   id: string
-                                                     //   nodes: Node[]
-                                                     // }
+const A = Module.Import('A')                     // const A: TImport<{...}, 'A'>
 
-function test(node: Node) {
-  const id = node.nodes[0].nodes[0].id               // id is string
-}
+type A = Static<typeof A>                        // type A = { 
+                                                 //   b: {
+                                                 //     c: {
+                                                 //       a: {
+                                                 //         b: ...
+                                                 //       }
+                                                 //     }
+                                                 //   }
+                                                 // }
 ```
 
 <a name='types-template-literal'></a>
@@ -1084,11 +1022,11 @@ if(TypeGuard.IsString(T)) {
 
 <a name='syntax'></a>
 
-## Syntax
+## Syntax Types
 
-TypeBox supports parsing TypeScript type annotation syntax directly into TypeBox types, providing an alternative to the Type.* API for type construction. This feature functions at runtime and within the TypeScript type system, enabling types encoded as strings to be inferred as equivalent TypeBox types.
+TypeBox provides support for Syntax Types, enabling it to parse TypeScript syntax directly into TypeBox types. Syntax Types serve as a DSL frontend for TypeBox's type builder and are useful for converting existing TypeScript type definitions into Json Schema schematics.
 
-TypeScript syntax parsing is provided as an optional import.
+Syntax Types are provided via optional import.
 
 ```typescript
 import { Parse } from '@sinclair/typebox/syntax'
@@ -1098,9 +1036,7 @@ import { Parse } from '@sinclair/typebox/syntax'
 
 ### Parse
 
-The Parse function can be used to parse TypeScript code into TypeBox types. The left hand result will be a inferred TypeBox type of TSchema. Invalid syntax will result in an undefined return value.
-
-[TypeScript Link Here](https://www.typescriptlang.org/play/?moduleResolution=99&module=199#code/JYWwDg9gTgLgBAbzgBQIZQM4FM4F84BmUEIcA5AAIbAB2AxgDarBQD0MAnmFgEYQAerDBxoxU-MgChJdCDQzwAgnAC8KdNgAUZBVFoBzMgEo4ps+YuXLrVnFnylALjgAVAMow9NfdPsK4AEKq6phY2gDaAIwANHAATLEAzAC6xlbpGTZ2cv4Bzi4uAK5gDFgAPOGSGdU1tdVZpi4AMsAwWFCoDGWRAHzRVXWDQ5m2jS1tHV1xfQPDc3MNruPtnWWJPbPzW7VZyRsyOfAAwsFooZoABkj8zjSFIDztsRy3949QeBcm6Vl+x-kAeR4ACssHQYGUEJttjCrIsbq4AHJvdrQ2Ho0yLF5IlFQNEY2FZXD7IA)
+Use the Parse function to convert a TypeScript string into a TypeBox type. TypeBox will infer the appropriate TSchema type or return undefined if there is a syntax error.
 
 ```typescript
 const A = Parse('string')                           // const A: TString
@@ -1117,64 +1053,96 @@ const C = Parse(`{ x: number, y: number }`)         // const C: TObject<{
                                                     // }>
 ```
 
+
+
+<a name='syntax-compose'></a>
+
+### Compose
+
+Syntax Types are designed to be interchangeable with standard Types.
+
+```typescript
+const T = Type.Object({                             // const T: TObject<{
+  x: Parse('number'),                               //   x: TNumber,
+  y: Parse('number'),                               //   y: TNumber,
+  z: Parse('number')                                //   z: TNumber
+})                                                  // }>
+```
+
+<a name='syntax-module'></a>
+
+### Module
+
+Syntax Types support Module parsing, which is useful for processing multiple TypeScript types. Module parsing supports type alias and interface definitions. Generics are currently unsupported as of 0.34.0.
+
+```typescript
+const Foo = Parse(`module Foo {
+
+  export type A = string
+
+  export type B = number
+
+  export type C = A | B
+
+}`)
+
+const C = Foo.Import('C')                           // const C: TImport<{
+                                                    //   ...
+                                                    // }, 'C'>
+```
+
 <a name='syntax-context'></a>
 
 ### Context
 
-The Parse function accepts an optional context parameter that enables external types to be referenced within the syntax.
-
-[TypeScript Link Here](https://www.typescriptlang.org/play/?moduleResolution=99&module=199#code/JYWwDg9gTgLgBAbzgBQIZQM4FM4F84BmUEIcA5AAIbAB2AxgDarBQD0MAnmFgEYQAerDBxoxU-MgChQkWIjgAVLjnxES5KrUbM2nbnwmTJdCDQzwFcALyLlAOgDyPAFZY6MABRI4P33-8BgayscCYArgwAJnA8OADuUMAwMFg0cKgYAFwo6NgeAAYIkj782UrcdgByYSCxUB4AlAA0ga1tbcG+pXA0NXVNxXAcZfbVtVj1ze3TM50+wz19EwM+AF4jFWN1jTO7rXNr2b3jUJK4DXuXV-6duPkNRiZm8ACC1jmYWF6KeC35aLBgKgGAAeBQAPnuV06T3McBeZScrncIKK13R1wO3QUDjAMGApmBYK2E3BKwxFNmIXmiLxBJoRIUJKgZMGlPZQWpcHWilx+MJoKZSxZbI5Yp8t3Bj1McIAQu8AXkkJZcH8ANZYDgQAiKKHomEy+CysoAVRo9JBAG1ReKOQcFAAZJITIlkCSs222+1OlJQV0cMgez1i73Ov2gsirQM24MYzoAXSlxkNcAAwgrcl9lb84PlLAAyeRxI7CvB6zmhFOpsoASVEE2wKMtOJcbhgqJjscxXLg2OZAG5O13LgchmUB0Ph7tRzyhSdB1OKZKWi3ke20Yv9T3i4oJ5ut3hwYmjEA)
+The Parse function accepts an initial Context argument, allowing external types to be passed into the parser.
 
 ```typescript
 const T = Type.Object({                             // could be written as: Parse(`{
   x: Type.Number(),                                 //   x: number,
   y: Type.Number(),                                 //   y: number,
-  z: Type.Number()                                 //    z: number
+  z: Type.Number()                                  //   z: number
 })                                                  // }`)
 
-const A = Parse({ T }, `Partial<T>`)                // const A: TObject<{
+const A = Parse({ T }, 'Partial<T>')                // const A: TObject<{
                                                     //   x: TOptional<TNumber>,
                                                     //   y: TOptional<TNumber>,
                                                     //   z: TOptional<TNumber>
                                                     // }>
 
-const B = Parse({ T }, `keyof T`)                   // const B: TUnion<[
+const B = Parse({ T }, 'keyof T')                   // const B: TUnion<[
                                                     //   TLiteral<'x'>,
                                                     //   TLiteral<'y'>,
                                                     //   TLiteral<'z'>
                                                     // ]>
 
-const C = Parse({ T }, `T & { w: number }`)         // const C: TIntersect<[TObject<{
+const C = Parse({ T }, 'T & { w: number }')         // const C: TIntersect<[TObject<{
                                                     //    x: TNumber;
                                                     //    y: TNumber;
                                                     //    z: TNumber;
                                                     // }>, TObject<{
                                                     //    w: TNumber;
                                                     // }>]>
-
-
 ```
 
 <a name='syntax-static'></a>
 
 ### Static
 
-TypeBox provides two Static types for inferring TypeScript syntax directly from strings.
-
-[TypeScript Link Here](https://www.typescriptlang.org/play/?moduleResolution=99&module=199#code/JYWwDg9gTgLgBAbzgZRgQxsAxgBTVAZwFMBBA5LACyJDQBoV1Nd9iyAVATzCLgF84AMygQQcAOQABAsAB2WADZpgUAPQxuRAEYQAHqoKdZ6XeLgAoc6tVwA6sAUK4cwUShw0BD3HYVqtSw0eFDgAXkYMbDxCUnIqGjQAHgQ+BgADJF0ALjhZAFcQLTd+NIA+OArrOCDeZBz2AHktACsiLBhk8wrunt6+-oHBgaqK7J8AOQKiqC6hufmF3qq+Ussq+0dnWVd3T28awM0fMIjmaLYCLh5k1LgMuDH8wuK+MqWbGuPwhFnFv--3qMck9pr8AeDFiM4EA)
+Syntax Types provide two Static types for inferring TypeScript syntax from strings.
 
 ```typescript
 import { StaticParseAsSchema, StaticParseAsType } from '@sinclair/typebox/syntax' 
 
 // Will infer as a TSchema
 
-type S = StaticParseAsSchema<{}, `{ x: number }`>   // type S: TObject<{
+type S = StaticParseAsSchema<{}, '{ x: number }'>   // type S: TObject<{
                                                     //   x: TNumber
                                                     // }>
 
 // Will infer as a type
 
-type T = StaticParseAsType<{}, `{ x: number }`>     // type T = {
+type T = StaticParseAsType<{}, '{ x: number }'>     // type T = {
                                                     //  x: number
                                                     //                       
 ```
@@ -1182,9 +1150,9 @@ type T = StaticParseAsType<{}, `{ x: number }`>     // type T = {
 
 <a name='syntax-limits'></a>
 
-### Limits
+### Limitations
 
-The Parse function works by TypeBox parsing TypeScript syntax within the type system itself. This can place some additional demand on the TypeScript compiler, which may affect language service (LSP) responsiveness when working with especially large or complex types. In particular, very wide structures or deeply nested types may approach TypeScript’s instantiation limits.
+Syntax Types work by having TypeBox parse TypeScript syntax within the TypeScript type system. This approach can place some strain on the TypeScript compiler and language service, potentially affecting responsiveness. While TypeBox makes a best-effort attempt to optimize for Syntax Types, users should be mindful of the following structures:
 
 ```typescript
 // Excessively wide structures will result in instantiation limits exceeding
@@ -1211,12 +1179,12 @@ const B = Parse(`{
 }`)
 ```
 
-For parsing especially complex types, TypeBox provides the ParseOnly function, which parses strings at runtime and returns a non-inferred TSchema type. ParseOnly allows for arbitrarily complex types without reaching instantiation limits, making it useful for cases where TypeScript types need to be directly converted to Json Schema.
+In cases where Syntax Types busts through TypeScript instantiation limits, TypeBox offers a fallback ParseOnly function which will Parse the types at runtime, but not infer the type. This function can also be used for parsing non-constant strings.
 
 ```typescript
 import { ParseOnly } from '@sinclair/typebox/syntax'
 
-// ok: but where A is TSchema | undefined 
+// Where A is TSchema | undefined 
 
 const A = ParseOnly(`{
   x: {
@@ -1229,7 +1197,7 @@ const A = ParseOnly(`{
 }`)
 ```
 
-Optimizing TypeScript string parsing performance is an ongoing area of research. For more information, see the [ParseBox](https://github.com/sinclairzx81/parsebox) project, which documents TypeBox’s parsing infrastructure and focuses efforts to improve parsing performance.
+For more information on TypeBox's parsing infrastructure, refer to the [ParseBox](https://github.com/sinclairzx81/parsebox) project.
 
 <a name='values'></a>
 
@@ -1914,12 +1882,12 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │ (index)              │ Compiled   │ Minified   │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '119.8 kb' │ ' 52.6 kb' │ '2.28 x'    │
-│ typebox/errors       │ ' 74.4 kb' │ ' 33.1 kb' │ '2.25 x'    │
-│ typebox/syntax       │ '115.3 kb' │ ' 48.3 kb' │ '2.39 x'    │
+│ typebox/compiler     │ '121.7 kb' │ ' 53.4 kb' │ '2.28 x'    │
+│ typebox/errors       │ ' 75.3 kb' │ ' 33.4 kb' │ '2.25 x'    │
+│ typebox/syntax       │ '120.1 kb' │ ' 50.5 kb' │ '2.38 x'    │
 │ typebox/system       │ '  7.4 kb' │ '  3.2 kb' │ '2.33 x'    │
-│ typebox/value        │ '157.2 kb' │ ' 66.1 kb' │ '2.38 x'    │
-│ typebox              │ ' 98.9 kb' │ ' 41.2 kb' │ '2.40 x'    │
+│ typebox/value        │ '160.3 kb' │ ' 67.4 kb' │ '2.38 x'    │
+│ typebox              │ ' 96.2 kb' │ ' 40.2 kb' │ '2.39 x'    │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index bc1fd8b4d..6e438702b 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -47,6 +47,7 @@ import type { TBoolean } from '../type/boolean/index'
 import type { TDate } from '../type/date/index'
 import type { TConstructor } from '../type/constructor/index'
 import type { TFunction } from '../type/function/index'
+import type { TImport } from '../type/module/index'
 import type { TInteger } from '../type/integer/index'
 import type { TIntersect } from '../type/intersect/index'
 import type { TIterator } from '../type/iterator/index'
@@ -110,7 +111,7 @@ export class TypeCheck<T extends TSchema> {
     return (this.hasTransform ? TransformDecode(this.schema, this.references, value) : value) as never
   }
   /** Encodes a value or throws if error */
-  public Encode<Static = StaticDecode<T>, Result extends Static = Static>(value: unknown): Result {
+  public Encode<Static = StaticEncode<T>, Result extends Static = Static>(value: unknown): Result {
     const encoded = this.hasTransform ? TransformEncode(this.schema, this.references, value) : value
     if (!this.checkFunc(encoded)) throw new TransformEncodeCheckError(this.schema, value, this.Errors(value).First()!)
     return encoded as never
@@ -288,6 +289,11 @@ export namespace TypeCompiler {
   function* FromFunction(schema: TFunction, references: TSchema[], value: string): IterableIterator<string> {
     yield `(typeof ${value} === 'function')`
   }
+  function* FromImport(schema: TImport, references: TSchema[], value: string): IterableIterator<string> {
+    const definitions = globalThis.Object.values(schema.$defs) as TSchema[]
+    const target = schema.$defs[schema.$ref] as TSchema
+    yield* Visit(target, [...references, ...definitions], value)
+  }
   function* FromInteger(schema: TInteger, references: TSchema[], value: string): IterableIterator<string> {
     yield `Number.isInteger(${value})`
     if (IsNumber(schema.exclusiveMaximum)) yield `${value} < ${schema.exclusiveMaximum}`
@@ -385,8 +391,12 @@ export namespace TypeCompiler {
   function* FromRef(schema: TRef, references: TSchema[], value: string): IterableIterator<string> {
     const target = Deref(schema, references)
     // Reference: If we have seen this reference before we can just yield and return the function call.
-    // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
-    if (state.functions.has(schema.$ref)) return yield `${CreateFunctionName(schema.$ref)}(${value})`
+    // If this isn't the case we defer to visit to generate and set the _recursion_end_for_ for subsequent
+    // passes. This operation is very awkward as we are using the functions state to store values to
+    // enable self referential types to terminate. This needs to be refactored.
+    const recursiveEnd = `_recursion_end_for_${schema.$ref}`
+    if (state.functions.has(recursiveEnd)) return yield `${CreateFunctionName(schema.$ref)}(${value})`
+    state.functions.set(recursiveEnd, '') // terminate recursion here by setting the name.
     yield* Visit(target, references, value)
   }
   function* FromRegExp(schema: TRegExp, references: TSchema[], value: string): IterableIterator<string> {
@@ -485,6 +495,8 @@ export namespace TypeCompiler {
         return yield* FromDate(schema_, references_, value)
       case 'Function':
         return yield* FromFunction(schema_, references_, value)
+      case 'Import':
+        return yield* FromImport(schema_, references_, value)
       case 'Integer':
         return yield* FromInteger(schema_, references_, value)
       case 'Intersect':
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 44a8b0227..9bb1f6cd1 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -46,6 +46,7 @@ import type { TBoolean } from '../type/boolean/index'
 import type { TDate } from '../type/date/index'
 import type { TConstructor } from '../type/constructor/index'
 import type { TFunction } from '../type/function/index'
+import type { TImport } from '../type/module/index'
 import type { TInteger } from '../type/integer/index'
 import type { TIntersect } from '../type/intersect/index'
 import type { TIterator } from '../type/iterator/index'
@@ -302,6 +303,11 @@ function* FromDate(schema: TDate, references: TSchema[], path: string, value: an
 function* FromFunction(schema: TFunction, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsFunction(value)) yield Create(ValueErrorType.Function, schema, path, value)
 }
+function* FromImport(schema: TImport, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
+  const definitions = globalThis.Object.values(schema.$defs) as TSchema[]
+  const target = schema.$defs[schema.$ref] as TSchema
+  yield* Visit(target, [...references, ...definitions], path, value)
+}
 function* FromInteger(schema: TInteger, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsInteger(value)) return yield Create(ValueErrorType.Integer, schema, path, value)
   if (IsDefined<number>(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -566,6 +572,8 @@ function* Visit<T extends TSchema>(schema: T, references: TSchema[], path: strin
       return yield* FromDate(schema_, references_, path, value)
     case 'Function':
       return yield* FromFunction(schema_, references_, path, value)
+    case 'Import':
+      return yield* FromImport(schema_, references_, path, value)
     case 'Integer':
       return yield* FromInteger(schema_, references_, path, value)
     case 'Intersect':
diff --git a/src/index.ts b/src/index.ts
index 6a99799a0..90525bd71 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -53,7 +53,6 @@ export * from './type/const/index'
 export * from './type/constructor/index'
 export * from './type/constructor-parameters/index'
 export * from './type/date/index'
-export * from './type/deref/index'
 export * from './type/enum/index'
 export * from './type/exclude/index'
 export * from './type/extends/index'
@@ -67,6 +66,7 @@ export * from './type/iterator/index'
 export * from './type/intrinsic/index'
 export * from './type/keyof/index'
 export * from './type/literal/index'
+export * from './type/module/index'
 export * from './type/mapped/index'
 export * from './type/never/index'
 export * from './type/not/index'
@@ -90,7 +90,6 @@ export * from './type/rest/index'
 export * from './type/return-type/index'
 export * from './type/schema/index'
 export * from './type/static/index'
-export * from './type/strict/index'
 export * from './type/string/index'
 export * from './type/symbol/index'
 export * from './type/template-literal/index'
diff --git a/src/syntax/parse.ts b/src/syntax/parse.ts
index 4605b9cbe..1ec0d41fd 100644
--- a/src/syntax/parse.ts
+++ b/src/syntax/parse.ts
@@ -26,36 +26,35 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import * as Types from '../type/index'
 import { Static } from './parsebox/index'
-import { CreateType } from '../type/create/type'
-import { TSchema, SchemaOptions } from '../type/schema/index'
-import { StaticDecode } from '../type/static/index'
 import { Module } from './runtime'
-import { Type } from './static'
+import { Main } from './static'
 
-/** `[Experimental]` Infers a TypeBox type from TypeScript syntax. */
-export type StaticParseAsSchema<Context extends Record<PropertyKey, TSchema>, Code extends string> = Static.Parse<Type, Code, Context>[0]
+/** `[Syntax]` Infers a TypeBox type from TypeScript syntax. */
+export type StaticParseAsSchema<Context extends Record<PropertyKey, Types.TSchema>, Code extends string> = Static.Parse<Main, Code, Context>[0]
 
-/** `[Experimental]` Infers a TypeScript type from TypeScript syntax. */
-export type StaticParseAsType<Context extends Record<PropertyKey, TSchema>, Code extends string> = StaticParseAsSchema<Context, Code> extends infer Type extends TSchema ? StaticDecode<Type> : undefined
+/** `[Syntax]` Infers a TypeScript type from TypeScript syntax. */
+export type StaticParseAsType<Context extends Record<PropertyKey, Types.TSchema>, Code extends string> = StaticParseAsSchema<Context, Code> extends infer Type extends Types.TSchema ? Types.StaticDecode<Type> : undefined
 
-/** `[Experimental]` Parses a TypeBox type from TypeScript syntax. */
-export function Parse<Context extends Record<PropertyKey, TSchema>, Code extends string>(context: Context, code: Code, options?: SchemaOptions): StaticParseAsSchema<Context, Code>
-/** `[Experimental]` Parses a TypeBox type from TypeScript syntax. */
-export function Parse<Code extends string>(code: Code, options?: SchemaOptions): StaticParseAsSchema<{}, Code>
-/** `[Experimental]` Parses a TypeBox type from TypeScript syntax. */
+/** `[Syntax]` Parses a TypeBox type from TypeScript syntax. */
+export function Parse<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): StaticParseAsSchema<Context, Code>
+/** `[Syntax]` Parses a TypeBox type from TypeScript syntax. */
+export function Parse<Code extends string>(code: Code, options?: Types.SchemaOptions): StaticParseAsSchema<{}, Code>
+/** `[Syntax]` Parses a TypeBox type from TypeScript syntax. */
 export function Parse(...args: any[]): never {
   return ParseOnly.apply(null, args as never) as never
 }
 
-/** `[Experimental]` Parses a TypeBox TSchema from TypeScript syntax. This function does not infer the type. */
-export function ParseOnly<Context extends Record<PropertyKey, TSchema>, Code extends string>(context: Context, code: Code, options?: SchemaOptions): TSchema | undefined
-/** `[Experimental]` Parses a TypeBox TSchema from TypeScript syntax */
-export function ParseOnly<Code extends string>(code: Code, options?: SchemaOptions): TSchema | undefined
-/** `[Experimental]` Parses a TypeBox TSchema from TypeScript syntax. This function does not infer the type. */
-export function ParseOnly(...args: any[]): TSchema | undefined {
+/** `[Syntax]` Parses a TypeBox TSchema from TypeScript syntax. This function does not infer the type. */
+export function ParseOnly<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined
+/** `[Syntax]` Parses a TypeBox TSchema from TypeScript syntax */
+export function ParseOnly<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined
+/** `[Syntax]` Parses a TypeBox TSchema from TypeScript syntax. This function does not infer the type. */
+export function ParseOnly(...args: any[]): Types.TSchema | undefined {
   const withContext = typeof args[0] === 'string' ? false : true
   const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}]
-  const type = Module.Parse('Type', code, context)[0] as TSchema | undefined
-  return (type !== undefined ? CreateType(type, options) : undefined) as never
+  const type = Module.Parse('Main', code, context)[0] as Types.TSchema | undefined
+  // Note: Parsing may return either a ModuleInstance or Type. We only apply options on the Type.
+  return Types.KindGuard.IsSchema(type) ? Types.CloneType(type, options) : type
 }
diff --git a/src/syntax/runtime.ts b/src/syntax/runtime.ts
index 0d28dbbf2..15001ee48 100644
--- a/src/syntax/runtime.ts
+++ b/src/syntax/runtime.ts
@@ -48,6 +48,7 @@ const SemiColon = ';'
 const SingleQuote = "'"
 const DoubleQuote = '"'
 const Tilde = '`'
+const Equals = '='
 
 // ------------------------------------------------------------------
 // DestructureRight
@@ -59,13 +60,140 @@ function DestructureRight<T>(values: T[]): [T[], T | undefined] {
     : [values, undefined]
 }
 // ------------------------------------------------------------------
-// Reference
+// Deref
+// ------------------------------------------------------------------
+const Deref = (context: Types.TProperties, key: string): Types.TSchema => {
+  return key in context ? context[key] : Types.Ref(key)
+}
+// ------------------------------------------------------------------
+// ExportModifier
 // ------------------------------------------------------------------
 // prettier-ignore
-const Reference = Runtime.Ident((value, context: Record<PropertyKey, Types.TSchema>) => {
-  return value in context ? context[value] : Types.Ref(value)
-})
+const ExportModifierMapping = (values: unknown[]) => {
+  return values.length === 1
+}
+// prettier-ignore
+const ExportModifier = Runtime.Union([
+  Runtime.Tuple([Runtime.Const('export')]), Runtime.Tuple([])
+], ExportModifierMapping)
+
+// ------------------------------------------------------------------
+// TypeAliasDeclaration
+// ------------------------------------------------------------------
+// prettier-ignore
+const TypeAliasDeclarationMapping = (_Export: boolean, _Keyword: 'type', Ident: string, _Equals: typeof Equals, Type: Types.TSchema) => {
+  return { [Ident]: Type }
+}
+// prettier-ignore
+const TypeAliasDeclaration = Runtime.Tuple([
+  Runtime.Ref<boolean>('ExportModifier'), 
+  Runtime.Const('type'), 
+  Runtime.Ident(), 
+  Runtime.Const(Equals), 
+  Runtime.Ref<Types.TSchema>('Type')
+], value => TypeAliasDeclarationMapping(...value))
+
+// ------------------------------------------------------------------
+// HeritageList
+// ------------------------------------------------------------------
+// prettier-ignore (note, heritage list should disallow trailing comma)
+const HeritageListDelimiter = Runtime.Union([Runtime.Tuple([Runtime.Const(Comma), Runtime.Const(Newline)]), Runtime.Tuple([Runtime.Const(Comma)])])
+// prettier-ignore
+const HeritageListMapping = (values: string[], context: Types.TProperties): Types.TSchema[] => {
+  return (
+    values.length === 3 ? [Deref(context, values[0]), ...values[2] as never] :
+    values.length === 1 ? [Deref(context, values[0])] :
+    []
+  ) as never
+}
+// prettier-ignore
+const HeritageList = Runtime.Union([
+  Runtime.Tuple([Runtime.Ident(), HeritageListDelimiter, Runtime.Ref('HeritageList')]),
+  Runtime.Tuple([Runtime.Ident()]),
+  Runtime.Tuple([])
+], HeritageListMapping)
+// ------------------------------------------------------------------
+// Heritage
+// ------------------------------------------------------------------
+// prettier-ignore
+const HeritageMapping = (values: unknown[]): unknown[] => {
+  return (values.length === 2 ? values[1] : []) as never
+}
+// prettier-ignore
+const Heritage = Runtime.Union([
+  Runtime.Tuple([Runtime.Const('extends'), Runtime.Ref('HeritageList')]),
+  Runtime.Tuple([])
+], HeritageMapping)
+// ------------------------------------------------------------------
+// InterfaceDeclaration
+// ------------------------------------------------------------------
+// prettier-ignore
+const InterfaceDeclarationMapping = (_0: boolean, _1: 'interface', Ident: string, Heritage: Types.TRef[], _4: typeof LBrace, Properties: Types.TProperties, _6: typeof RBrace) => {
+  return { [Ident]: Types.Intersect([...Heritage, Types.Object(Properties)]) }
+}
+// prettier-ignore
+const InterfaceDeclaration = Runtime.Tuple([
+  Runtime.Ref<boolean>('ExportModifier'), 
+  Runtime.Const('interface'), 
+  Runtime.Ident(), 
+  Runtime.Ref<Types.TRef[]>('Heritage'), 
+  Runtime.Const(LBrace), 
+  Runtime.Ref<Types.TProperties>('Properties'), 
+  Runtime.Const(RBrace), 
+], values => InterfaceDeclarationMapping(...values))
 
+// ------------------------------------------------------------------
+// ModuleType
+// ------------------------------------------------------------------
+// prettier-ignore
+const ModuleType = Runtime.Union([
+  Runtime.Ref('InterfaceDeclaration'),
+  Runtime.Ref('TypeAliasDeclaration')
+])
+// ------------------------------------------------------------------
+// ModuleProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+const ModulePropertiesDelimiter = Runtime.Union([
+  Runtime.Tuple([Runtime.Const(SemiColon), Runtime.Const(Newline)]),
+  Runtime.Tuple([Runtime.Const(SemiColon)]),
+  Runtime.Tuple([Runtime.Const(Newline)]),
+])
+// prettier-ignore
+const ModulePropertiesMapping = (values: unknown[]): Types.TProperties => {
+  return (
+    values.length === 3 ? { ...values[0] as Types.TProperties, ...values[2] as Types.TProperties }:
+    values.length === 1 ? values[0] as Types.TProperties :
+    {} as Types.TProperties
+  )
+}
+// prettier-ignore
+const ModuleProperties = Runtime.Union([
+  Runtime.Tuple([Runtime.Ref<Types.TProperties>('ModuleType'), ModulePropertiesDelimiter, Runtime.Ref<Types.TProperties>('ModuleProperties')]),
+  Runtime.Tuple([Runtime.Ref<Types.TProperties>('ModuleType')]),
+  Runtime.Tuple([]),
+], ModulePropertiesMapping)
+// ------------------------------------------------------------------
+// ModuleDeclaration
+// ------------------------------------------------------------------
+// prettier-ignore
+const ModuleIdentifier = Runtime.Union([
+  Runtime.Tuple([Runtime.Ident()]),
+  Runtime.Tuple([])
+])
+// prettier-ignore
+const ModuleDeclarationMapping = (_1: boolean, _2: 'module', _Ident: string[], _3: typeof LBrace, Properties: Types.TProperties, _5: typeof RBrace) => {
+  return Types.Module(Properties)
+}
+// prettier-ignore
+const ModuleDeclaration = Runtime.Tuple([
+  Runtime.Ref<boolean>('ExportModifier'), Runtime.Const('module'), ModuleIdentifier, Runtime.Const(LBrace), Runtime.Ref<Types.TProperties>('ModuleProperties'), Runtime.Const(RBrace)
+], values => ModuleDeclarationMapping(...values))
+// ------------------------------------------------------------------
+// Reference
+// ------------------------------------------------------------------
+// prettier-ignore
+const Reference = Runtime.Ident((value, context: Types.TProperties) => Deref(context, value))
 // ------------------------------------------------------------------
 // Literal
 // ------------------------------------------------------------------
@@ -75,7 +203,6 @@ const Literal = Runtime.Union([
   Runtime.Number(value => Types.Literal(parseFloat(value))),
   Runtime.String([SingleQuote, DoubleQuote, Tilde], value => Types.Literal(value))
 ])
-
 // ------------------------------------------------------------------
 // Keyword
 // ------------------------------------------------------------------
@@ -94,7 +221,6 @@ const Keyword = Runtime.Union([
   Runtime.Const('unknown', Runtime.As(Types.Unknown())),
   Runtime.Const('void', Runtime.As(Types.Void())),
 ])
-
 // ------------------------------------------------------------------
 // KeyOf
 // ------------------------------------------------------------------
@@ -106,7 +232,6 @@ const KeyOfMapping = (values: unknown[]) => (
 const KeyOf = Runtime.Union([
   Runtime.Tuple([Runtime.Const('keyof')]), Runtime.Tuple([])
 ], KeyOfMapping)
-
 // ------------------------------------------------------------------
 // IndexArray
 // ------------------------------------------------------------------
@@ -137,7 +262,6 @@ const Extends = Runtime.Union([
   Runtime.Tuple([Runtime.Const('extends'), Runtime.Ref('Type'), Runtime.Const(Question), Runtime.Ref('Type'), Runtime.Const(Colon), Runtime.Ref('Type')]),
   Runtime.Tuple([])
 ], ExtendsMapping)
-
 // ------------------------------------------------------------------
 // Base
 // ------------------------------------------------------------------
@@ -219,7 +343,6 @@ const Factor = Runtime.Tuple([
   Runtime.Ref<unknown[]>('IndexArray'),
   Runtime.Ref<Types.TSchema[]>('Extends')
 ], values => FactorMapping(...values))
-
 // ------------------------------------------------------------------
 // Expr
 // ------------------------------------------------------------------
@@ -266,30 +389,26 @@ const Expr = Runtime.Tuple([
 // Type
 // ------------------------------------------------------------------
 const Type = Runtime.Ref('Expr')
-
 // ------------------------------------------------------------------
 // Properties
 // ------------------------------------------------------------------
-// prettier-ignore
 const PropertyKey = Runtime.Union([Runtime.Ident(), Runtime.String([SingleQuote, DoubleQuote])])
+const Readonly = Runtime.Union([Runtime.Tuple([Runtime.Const('readonly')]), Runtime.Tuple([])], (value) => value.length > 0)
+const Optional = Runtime.Union([Runtime.Tuple([Runtime.Const(Question)]), Runtime.Tuple([])], (value) => value.length > 0)
 // prettier-ignore
-const PropertyReadonly = Runtime.Union([Runtime.Tuple([Runtime.Const('readonly')]), Runtime.Tuple([])], value => value.length > 0)
-// prettier-ignore
-const PropertyOptional = Runtime.Union([Runtime.Tuple([Runtime.Const(Question)]), Runtime.Tuple([])], value => value.length > 0)
-// prettier-ignore
-const PropertyMapping = (Readonly: boolean, Key: string, Optional: boolean, _: typeof Colon, Type: Types.TSchema) => ({
+const PropertyMapping = (IsReadonly: boolean, Key: string, IsOptional: boolean, _: typeof Colon, Type: Types.TSchema) => ({
   [Key]: (
-    Readonly && Optional ? Types.ReadonlyOptional(Type) :
-    Readonly && !Optional ? Types.Readonly(Type) :
-    !Readonly && Optional ? Types.Optional(Type) :
+    IsReadonly && IsOptional ? Types.ReadonlyOptional(Type) :
+    IsReadonly && !IsOptional ? Types.Readonly(Type) :
+    !IsReadonly && IsOptional ? Types.Optional(Type) :
     Type
   )
 })
 // prettier-ignore
 const Property = Runtime.Tuple([
-  Runtime.Ref<boolean>('PropertyReadonly'),
+  Runtime.Ref<boolean>('Readonly'),
   Runtime.Ref<string>('PropertyKey'),
-  Runtime.Ref<boolean>('PropertyOptional'),
+  Runtime.Ref<boolean>('Optional'),
   Runtime.Const(Colon),
   Runtime.Ref<Types.TSchema>('Type'),
 ], value => PropertyMapping(...value))
@@ -303,30 +422,27 @@ const PropertyDelimiter = Runtime.Union([
 ])
 // prettier-ignore
 const Properties = Runtime.Union([
-  Runtime.Tuple([Runtime.Ref('Property'), Runtime.Ref('PropertyDelimiter'), Runtime.Ref('Properties')]),
-  Runtime.Tuple([Runtime.Ref('Property'), Runtime.Ref('PropertyDelimiter')]),
-  Runtime.Tuple([Runtime.Ref('Property')]),
+  Runtime.Tuple([Runtime.Ref<Types.TProperties>('Property'), Runtime.Ref('PropertyDelimiter'), Runtime.Ref<Types.TProperties>('Properties')]),
+  Runtime.Tuple([Runtime.Ref<Types.TProperties>('Property'), Runtime.Ref('PropertyDelimiter')]),
+  Runtime.Tuple([Runtime.Ref<Types.TProperties>('Property')]),
   Runtime.Tuple([])
 ], values => (
-  values.length === 3 ? [values[0], ...values[2] as unknown[]] :
-  values.length === 2 ? [values[0]] :
-  values.length === 1 ? [values[0]] :
-  []
+  values.length === 3 ? { ...values[0], ...values[2] } :
+  values.length === 2 ? values[0] :
+  values.length === 1 ? values[0] :
+  {}
 ))
-
 // ------------------------------------------------------------------
 // Object
 // ------------------------------------------------------------------
 // prettier-ignore
-const ObjectMapping = (values: Record<string, Types.TSchema>[]) => Types.Object(values.reduce((properties, record) => {
-  return { ...properties, ...record }
-}, {} as Types.TProperties))
+const ObjectMapping = (_0: typeof LBrace, Properties: Types.TProperties, _2: typeof RBrace) => Types.Object(Properties)
 // prettier-ignore
 const _Object = Runtime.Tuple([
   Runtime.Const(LBrace),
-  Runtime.Ref<Record<string, Types.TSchema>[]>('Properties'),
+  Runtime.Ref<Types.TProperties>('Properties'),
   Runtime.Const(RBrace)
-], values => ObjectMapping(values[1]))
+], values => ObjectMapping(...values))
 
 // ------------------------------------------------------------------
 // Tuple
@@ -401,7 +517,15 @@ const MappedMapping = (values: unknown[]) => {
 }
 // prettier-ignore
 const Mapped = Runtime.Tuple([
-  Runtime.Const(LBrace), Runtime.Const(LBracket), Runtime.Ident(), Runtime.Const('in'), Runtime.Ref<Types.TSchema>('Type'), Runtime.Const(RBracket), Runtime.Const(Colon), Runtime.Ref<Types.TSchema>('Type'), Runtime.Const(RBrace)
+  Runtime.Const(LBrace), 
+  Runtime.Const(LBracket), 
+  Runtime.Ident(), 
+  Runtime.Const('in'), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RBracket), 
+  Runtime.Const(Colon), 
+  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Const(RBrace)
 ], MappedMapping)
 // ------------------------------------------------------------------
 // AsyncIterator
@@ -621,11 +745,37 @@ const Date = Runtime.Const('Date', Runtime.As(Types.Date()))
 // Uint8Array
 // ------------------------------------------------------------------
 const Uint8Array = Runtime.Const('Uint8Array', Runtime.As(Types.Uint8Array()))
+
+// ------------------------------------------------------------------
+// Main
+// ------------------------------------------------------------------
+// prettier-ignore
+const Main = Runtime.Union([
+  ModuleDeclaration,
+  TypeAliasDeclaration,
+  InterfaceDeclaration,
+  Type
+])
 // ------------------------------------------------------------------
 // Module
 // ------------------------------------------------------------------
 // prettier-ignore
 export const Module = new Runtime.Module({
+  // ----------------------------------------------------------------
+  // Modules, Interfaces and Type Aliases
+  // ----------------------------------------------------------------
+  ExportModifier,
+  HeritageList,
+  Heritage,
+  InterfaceDeclaration,
+  TypeAliasDeclaration,
+  ModuleType,
+  ModuleProperties,
+  ModuleDeclaration,
+
+  // ----------------------------------------------------------------
+  // Type Expressions
+  // ----------------------------------------------------------------
   Literal,
   Keyword,
   KeyOf,
@@ -637,10 +787,10 @@ export const Module = new Runtime.Module({
   ExprTerm,
   ExprTail,
   Expr,
-  Type,
+  Type, // Alias for Expr
   PropertyKey,
-  PropertyReadonly,
-  PropertyOptional,
+  Readonly,
+  Optional,
   Property,
   PropertyDelimiter,
   Properties,
@@ -674,5 +824,10 @@ export const Module = new Runtime.Module({
   Uncapitalize,
   Date,
   Uint8Array,
-  Reference
+  Reference,
+
+  // ----------------------------------------------------------------
+  // Main
+  // ----------------------------------------------------------------
+  Main
 })
diff --git a/src/syntax/static.ts b/src/syntax/static.ts
index ff75dca2e..0b30b8ead 100644
--- a/src/syntax/static.ts
+++ b/src/syntax/static.ts
@@ -48,6 +48,7 @@ type SemiColon = ';'
 type SingleQuote = "'"
 type DoubleQuote = '"'
 type Tilde = '`'
+type Equals = '='
 
 // ------------------------------------------------------------------
 // Delimit
@@ -135,18 +136,156 @@ type Delimit<Parser extends Static.IParser, Delimiter extends Static.IParser> =
   ], DelimitMapping>
 )
 // ------------------------------------------------------------------
-// Reference
+// Deref
 // ------------------------------------------------------------------
 // prettier-ignore
-interface ReferenceMapping extends Static.IMapping {
-  output: this['input'] extends [infer Key extends string]
-    ? Key extends keyof this['context']
-      ? this['context'][Key]
-      : Types.TRef<Types.TUnknown>
+type Deref<Context extends Types.TProperties, Ref extends string> = (
+  Ref extends keyof Context ? Context[Ref] : Types.TRef<Ref>
+)
+// ------------------------------------------------------------------
+// ExportModifier
+// ------------------------------------------------------------------
+// prettier-ignore
+interface ExportModifierMapping extends Static.IMapping {
+  output: this['input'] extends [string] ? true : false
+}
+// prettier-ignore
+type ExportModifier = Static.Union<[
+  Static.Tuple<[Static.Const<'export'>]>,
+  Static.Tuple<[]>,
+], ExportModifierMapping>
+
+// ------------------------------------------------------------------
+// TypeAliasDeclaration
+// ------------------------------------------------------------------
+// prettier-ignore
+interface TypeAliasDeclarationMapping extends Static.IMapping {
+  output: this['input'] extends [infer _Export extends boolean, 'type', infer Ident extends string, Equals, infer Type extends Types.TSchema] 
+    ? { [_ in Ident]: Type } 
     : never
 }
-type Reference = Static.Tuple<[Static.Ident], ReferenceMapping>
+// prettier-ignore
+type TypeAliasDeclaration = Static.Tuple<[
+  ExportModifier, Static.Const<'type'>, Static.Ident, Static.Const<Equals>, Type
+], TypeAliasDeclarationMapping>
 
+// ------------------------------------------------------------------
+// HeritageList
+// ------------------------------------------------------------------
+// prettier-ignore (note, heritage list should disallow trailing comma)
+type HeritageListDelimiter = Static.Union<[Static.Tuple<[Static.Const<Comma>, Static.Const<Newline>]>, Static.Tuple<[Static.Const<Comma>]>]>
+// prettier-ignore
+type HeritageListReduce<Values extends string[], Context extends Types.TProperties, Result extends Types.TSchema[] = []> = (
+  Values extends [infer Ref extends string, ...infer Rest extends string[]]
+    ? HeritageListReduce<Rest, Context, [...Result, Deref<Context, Ref>]>
+    : Result
+)
+// prettier-ignore
+interface HeritageListMapping extends Static.IMapping {
+  output: (
+    this['context'] extends Types.TProperties ?
+    this['input'] extends string[] 
+      ? HeritageListReduce<this['input'], this['context']> 
+      : []
+    : []
+  )
+}
+// prettier-ignore
+type HeritageList = Static.Union<[Delimit<Static.Ident, HeritageListDelimiter>], HeritageListMapping>
+// ------------------------------------------------------------------
+// Heritage
+// ------------------------------------------------------------------
+// prettier-ignore
+interface HeritageMapping extends Static.IMapping {
+  output: this['input'] extends ['extends', infer List extends Types.TSchema[]] ? List : []
+}
+// prettier-ignore
+type Heritage = Static.Union<[
+  Static.Tuple<[Static.Const<'extends'>, HeritageList]>,
+  Static.Tuple<[]>
+], HeritageMapping>
+// ------------------------------------------------------------------
+// InterfaceDeclaration
+// ------------------------------------------------------------------
+// prettier-ignore
+interface InterfaceDeclarationMapping extends Static.IMapping {
+  output: this['input'] extends [boolean, 'interface', infer Ident extends string, infer Heritage extends Types.TSchema[], LBrace, infer Properties extends Types.TProperties, RBrace]
+    ? { [_ in Ident]: Types.TIntersectEvaluated<[...Heritage, Types.TObject<Properties>]> }
+    : never
+}
+// prettier-ignore
+type InterfaceDeclaration = Static.Tuple<[
+  ExportModifier,
+  Static.Const<'interface'>, 
+  Static.Ident, 
+  Heritage,
+  Static.Const<LBrace>, 
+  Properties,
+  Static.Const<RBrace>, 
+], InterfaceDeclarationMapping>
+// ------------------------------------------------------------------
+// ModuleType
+// ------------------------------------------------------------------
+// prettier-ignore
+type ModuleType = Static.Union<[
+  InterfaceDeclaration,
+  TypeAliasDeclaration
+]>
+// ------------------------------------------------------------------
+// ModuleProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+type ModulePropertiesDelimiter = Static.Union<[
+  Static.Tuple<[Static.Const<SemiColon>, Static.Const<Newline>]>,
+  Static.Tuple<[Static.Const<SemiColon>]>,
+  Static.Tuple<[Static.Const<Newline>]>,
+]>
+// prettier-ignore
+type ModulePropertiesReduce<Value extends unknown[], Result extends Types.TProperties = {}> = (
+  Value extends [infer ModuleType extends Types.TProperties, unknown[], ...infer Rest extends unknown[]] ? ModulePropertiesReduce<Rest, Result & ModuleType> :
+  Value extends [infer ModuleType extends Types.TProperties] ? ModulePropertiesReduce<[], Result & ModuleType> : 
+  Types.Evaluate<Result>
+)
+// prettier-ignore
+interface ModulePropertiesMapping extends Static.IMapping {
+  output: this['input'] extends unknown[] ? ModulePropertiesReduce<this['input']> : never
+}
+// prettier-ignore
+type ModuleProperties = Static.Union<[
+  Static.Tuple<[ModuleType, ModulePropertiesDelimiter, ModuleProperties]>,
+  Static.Tuple<[ModuleType]>,
+  Static.Tuple<[]>,
+], ModulePropertiesMapping>
+// ------------------------------------------------------------------
+// ModuleDeclaration
+// ------------------------------------------------------------------
+// prettier-ignore
+type ModuleIdentifier = Static.Union<[
+  Static.Tuple<[Static.Ident]>,
+  Static.Tuple<[]>
+]>
+// prettier-ignore
+interface ModuleDeclarationMapping extends Static.IMapping {
+  output: this['input'] extends [boolean, 'module', infer _Ident extends string[], LBrace, infer Properties extends Types.TProperties, RBrace] 
+    ? Types.TModule<Properties> 
+    : never
+}
+// prettier-ignore
+type ModuleDeclaration = Static.Tuple<[
+  ExportModifier, Static.Const<'module'>, ModuleIdentifier, Static.Const<LBrace>, ModuleProperties, Static.Const<RBrace>
+], ModuleDeclarationMapping>
+// ------------------------------------------------------------------
+// Reference
+// ------------------------------------------------------------------
+// prettier-ignore
+interface ReferenceMapping extends Static.IMapping {
+  output: this['context'] extends Types.TProperties
+    ? this['input'] extends string
+      ? Deref<this['context'], this['input']>
+      : never
+    : never  
+}
+type Reference = Static.Ident<ReferenceMapping>
 // ------------------------------------------------------------------
 // Literal
 // ------------------------------------------------------------------
@@ -198,7 +337,6 @@ type KeyOf = Static.Union<[
   Static.Tuple<[Static.Const<'keyof'>]>,
   Static.Tuple<[]>
 ], KeyOfMapping>
-
 // ------------------------------------------------------------------
 // IndexArray
 // ------------------------------------------------------------------
@@ -231,7 +369,6 @@ type Extends = Static.Union<[
   Static.Tuple<[Static.Const<'extends'>, Type, Static.Const<Question>, Type, Static.Const<Colon>, Type]>,
   Static.Tuple<[]>
 ], ExtendsMapping>
-
 // ------------------------------------------------------------------
 // Base
 // ------------------------------------------------------------------
@@ -361,7 +498,7 @@ type Expr = Static.Tuple<[
 // ------------------------------------------------------------------
 // Type
 // ------------------------------------------------------------------
-export type Type = Expr
+type Type = Expr
 // ------------------------------------------------------------------
 // Properties
 // ------------------------------------------------------------------
@@ -370,34 +507,30 @@ interface PropertyKeyStringMapping extends Static.IMapping {
   output: this['input']
 }
 type PropertyKeyString = Static.String<[SingleQuote, DoubleQuote], PropertyKeyStringMapping>
-
 type PropertyKey = Static.Union<[Static.Ident, PropertyKeyString]>
 // prettier-ignore
-interface PropertyReadonlyMapping extends Static.IMapping {
+interface ReadonlyMapping extends Static.IMapping {
   output: this['input'] extends ['readonly'] ? true : false
 }
-type PropertyReadonly = Static.Union<[Static.Tuple<[Static.Const<'readonly'>]>, Static.Tuple<[]>], PropertyReadonlyMapping>
+type Readonly = Static.Union<[Static.Tuple<[Static.Const<'readonly'>]>, Static.Tuple<[]>], ReadonlyMapping>
 // prettier-ignore
-interface PropertyOptionalMapping extends Static.IMapping {
+interface OptionalMapping extends Static.IMapping {
   output: this['input'] extends [Question] ? true : false
 }
-type PropertyOptional = Static.Union<[Static.Tuple<[Static.Const<Question>]>, Static.Tuple<[]>], PropertyOptionalMapping>
+type Optional = Static.Union<[Static.Tuple<[Static.Const<Question>]>, Static.Tuple<[]>], OptionalMapping>
 // prettier-ignore
 interface PropertyMapping extends Static.IMapping {
-  output: this['input'] extends [infer Readonly extends boolean, infer Key extends string, infer Optional extends boolean, string, infer Type extends Types.TSchema]
+  output: this['input'] extends [infer IsReadonly extends boolean, infer Key extends string, infer IsOptional extends boolean, string, infer Type extends Types.TSchema]
   ? { 
     [_ in Key]: (
-      [Readonly, Optional] extends [true, true] ? Types.TReadonlyOptional<Type> :
-      [Readonly, Optional] extends [true, false] ? Types.TReadonly<Type> :
-      [Readonly, Optional] extends [false, true] ? Types.TOptional<Type> :
+      [IsReadonly, IsOptional] extends [true, true] ? Types.TReadonlyOptional<Type> :
+      [IsReadonly, IsOptional] extends [true, false] ? Types.TReadonly<Type> :
+      [IsReadonly, IsOptional] extends [false, true] ? Types.TOptional<Type> :
       Type 
     ) 
   } : never
 }
-
-type Property = Static.Tuple<[PropertyReadonly, PropertyKey, PropertyOptional, Static.Const<Colon>, Type], PropertyMapping>
-
-type PropertiesEvaluate<T> = { [K in keyof T]: T[K] } & {}
+type Property = Static.Tuple<[Readonly, PropertyKey, Optional, Static.Const<Colon>, Type], PropertyMapping>
 // prettier-ignore
 type PropertyDelimiter = Static.Union<[
   Static.Tuple<[Static.Const<Comma>, Static.Const<Newline>]>,
@@ -409,7 +542,7 @@ type PropertyDelimiter = Static.Union<[
 // prettier-ignore
 type PropertiesReduce<PropertiesArray extends Types.TProperties[], Result extends Types.TProperties = {}> = (
   PropertiesArray extends [infer Left extends Types.TProperties, ...infer Right extends Types.TProperties[]]
-  ? PropertiesReduce<Right, PropertiesEvaluate<Result & Left>>
+  ? PropertiesReduce<Right, Types.Evaluate<Result & Left>>
   : Result
 )
 // prettier-ignore
@@ -485,7 +618,7 @@ type Constructor = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface MappedMapping extends Static.IMapping {
-  output: this['input'] extends [LBrace, LBracket, infer Key extends string, 'in', infer Right extends Types.TSchema, RBracket, Colon, infer Type extends Types.TSchema, RBrace]
+  output: this['input'] extends [LBrace, LBracket, infer _Key extends string, 'in', infer _Right extends Types.TSchema, RBracket, Colon, infer Type extends Types.TSchema, RBrace]
     ? Types.TLiteral<'Mapped types not supported'>
     : this['input']
 }
@@ -762,3 +895,14 @@ type Date = Static.Const<'Date', Static.As<Types.TDate>>
 // Uint8Array
 // ------------------------------------------------------------------
 type Uint8Array = Static.Const<'Uint8Array', Static.As<Types.TUint8Array>>
+
+// ------------------------------------------------------------------
+// Main
+// ------------------------------------------------------------------
+// prettier-ignore
+export type Main = Static.Union<[
+  ModuleDeclaration,
+  TypeAliasDeclaration,
+  InterfaceDeclaration,
+  Type
+]>
diff --git a/src/type/deref/deref.ts b/src/type/deref/deref.ts
deleted file mode 100644
index 76d626a29..000000000
--- a/src/type/deref/deref.ts
+++ /dev/null
@@ -1,174 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import type { TSchema } from '../schema/index'
-import type { Evaluate } from '../helpers/index'
-import type { TTuple } from '../tuple/index'
-import type { TIntersect } from '../intersect/index'
-import type { TUnion } from '../union/index'
-import type { TPromise } from '../promise/index'
-import type { TAsyncIterator } from '../async-iterator/index'
-import type { TIterator } from '../iterator/index'
-import type { TArray } from '../array/index'
-import type { TConstructor } from '../constructor/index'
-import type { TFunction } from '../function/index'
-import type { TRef } from '../ref/index'
-import type { TObject, TProperties } from '../object/index'
-import { CloneType, CloneRest } from '../clone/type'
-import { Discard } from '../discard/index'
-import { IsUndefined } from '../guard/value'
-
-// ------------------------------------------------------------------
-// TypeGuard
-// ------------------------------------------------------------------
-import { IsConstructor, IsFunction, IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsPromise, IsAsyncIterator, IsIterator, IsRef } from '../guard/kind'
-// ------------------------------------------------------------------
-// FromRest
-// ------------------------------------------------------------------
-// prettier-ignore
-export type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-   ? TFromRest<R, [...Acc, TDeref<L>]>
-   : Acc
-)
-function FromRest<T extends TSchema[]>(schema: [...T], references: TSchema[]): TFromRest<T> {
-  return schema.map((schema) => Deref(schema, references)) as never
-}
-// ------------------------------------------------------------------
-// FromProperties
-// ------------------------------------------------------------------
-// prettier-ignore
-type FromProperties<T extends TProperties> = Evaluate<{
-  [K in keyof T]: TDeref<T[K]>
-}>
-// prettier-ignore
-function FromProperties(properties: TProperties, references: TSchema[]) {
-  const Acc = {} as TProperties
-  for(const K of globalThis.Object.getOwnPropertyNames(properties)) {
-    Acc[K] = Deref(properties[K], references)
-  }
-  return Acc as never
-}
-// prettier-ignore
-function FromConstructor(schema: TConstructor, references: TSchema[]) {
-  schema.parameters = FromRest(schema.parameters, references)
-  schema.returns = Deref(schema.returns, references)
-  return schema
-}
-// prettier-ignore
-function FromFunction(schema: TFunction, references: TSchema[]) {
-  schema.parameters = FromRest(schema.parameters, references)
-  schema.returns = Deref(schema.returns, references)
-  return schema
-}
-// prettier-ignore
-function FromIntersect(schema: TIntersect, references: TSchema[]) {
-  schema.allOf = FromRest(schema.allOf, references)
-  return schema
-}
-// prettier-ignore
-function FromUnion(schema: TUnion, references: TSchema[]) {
-  schema.anyOf = FromRest(schema.anyOf, references)
-  return schema
-}
-// prettier-ignore
-function FromTuple(schema: TTuple, references: TSchema[]) {
-  if(IsUndefined(schema.items)) return schema
-  schema.items = FromRest(schema.items, references)
-  return schema
-}
-// prettier-ignore
-function FromArray(schema: TArray, references: TSchema[]) {
-  schema.items = Deref(schema.items, references)
-  return schema
-}
-// prettier-ignore
-function FromObject(schema: TObject, references: TSchema[]) {
-  schema.properties = FromProperties(schema.properties, references)
-  return schema
-}
-// prettier-ignore
-function FromPromise(schema: TPromise, references: TSchema[]) {
-  schema.item = Deref(schema.item, references)
-  return schema
-}
-// prettier-ignore
-function FromAsyncIterator(schema: TAsyncIterator, references: TSchema[]) {
-  schema.items = Deref(schema.items, references)
-  return schema
-}
-// prettier-ignore
-function FromIterator(schema: TIterator, references: TSchema[]) {
-  schema.items = Deref(schema.items, references)
-  return schema
-}
-// prettier-ignore
-function FromRef(schema: TRef, references: TSchema[]) {
-  const target = references.find(remote => remote.$id === schema.$ref)
-  if(target === undefined) throw Error(`Unable to dereference schema with $id ${schema.$ref}`)
-  const discard = Discard(target, ['$id']) as TSchema
-  return Deref(discard, references)
-}
-// prettier-ignore
-function DerefResolve<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>  {
-  return (
-    IsConstructor(schema) ? FromConstructor(schema, references) :
-    IsFunction(schema) ? FromFunction(schema, references) :
-    IsIntersect(schema) ? FromIntersect(schema, references) :
-    IsUnion(schema) ? FromUnion(schema, references) :
-    IsTuple(schema) ? FromTuple(schema, references) :
-    IsArray(schema) ? FromArray(schema, references) :
-    IsObject(schema) ? FromObject(schema, references) :
-    IsPromise(schema) ? FromPromise(schema, references) :
-    IsAsyncIterator(schema) ? FromAsyncIterator(schema, references) :
-    IsIterator(schema) ? FromIterator(schema, references) :
-    IsRef(schema) ? FromRef(schema, references) :
-    schema
-  ) as never
-}
-// prettier-ignore
-export type TDeref<T extends TSchema> =
-  T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<S>, TDeref<R>> :
-  T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<S>, TDeref<R>> :
-  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> :
-  T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> :
-  T extends TTuple<infer S extends TSchema[]> ? TTuple<TFromRest<S>> :
-  T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> :
-  T extends TArray<infer S extends TSchema> ? TArray<TDeref<S>> :
-  T extends TPromise<infer S extends TSchema> ? TPromise<TDeref<S>> :
-  T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<TDeref<S>> :
-  T extends TIterator<infer S extends TSchema> ? TIterator<TDeref<S>> :
-  T extends TRef<infer S extends TSchema> ? TDeref<S> :
-  T
-// ------------------------------------------------------------------
-// TDeref
-// ------------------------------------------------------------------
-/** `[Json]` Creates a dereferenced type */
-export function Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T> {
-  return DerefResolve(CloneType(schema), CloneRest(references))
-}
diff --git a/src/type/guard/kind.ts b/src/type/guard/kind.ts
index b68f01bca..2e61a1df9 100644
--- a/src/type/guard/kind.ts
+++ b/src/type/guard/kind.ts
@@ -40,6 +40,7 @@ import type { TAsyncIterator } from '../async-iterator/index'
 import type { TBigInt } from '../bigint/index'
 import type { TConstructor } from '../constructor/index'
 import type { TFunction } from '../function/index'
+import type { TImport } from '../module/index'
 import type { TInteger } from '../integer/index'
 import type { TIntersect } from '../intersect/index'
 import type { TIterator } from '../iterator/index'
@@ -107,6 +108,10 @@ export function IsFunction(value: unknown): value is TFunction {
   return IsKindOf(value, 'Function')
 }
 /** `[Kind-Only]` Returns true if the given value is TInteger */
+export function IsImport(value: unknown): value is TImport {
+  return IsKindOf(value, 'Import')
+}
+/** `[Kind-Only]` Returns true if the given value is TInteger */
 export function IsInteger(value: unknown): value is TInteger {
   return IsKindOf(value, 'Integer')
 }
diff --git a/src/type/guard/type.ts b/src/type/guard/type.ts
index b2e9daa9a..ed8eb54fe 100644
--- a/src/type/guard/type.ts
+++ b/src/type/guard/type.ts
@@ -41,6 +41,7 @@ import type { TAsyncIterator } from '../async-iterator/index'
 import type { TBigInt } from '../bigint/index'
 import type { TConstructor } from '../constructor/index'
 import type { TFunction } from '../function/index'
+import type { TImport } from '../module/index'
 import type { TInteger } from '../integer/index'
 import type { TIntersect } from '../intersect/index'
 import type { TIterator } from '../iterator/index'
@@ -253,6 +254,19 @@ export function IsFunction(value: unknown): value is TFunction {
     IsSchema(value.returns)
   )
 }
+/** Returns true if the given value is TImport */
+export function IsImport(value: unknown): value is TImport {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Import') &&
+    ValueGuard.HasPropertyKey(value, '$defs') &&
+    ValueGuard.IsObject(value.$defs) &&
+    IsProperties(value.$defs) &&
+    ValueGuard.HasPropertyKey(value, '$ref') &&
+    ValueGuard.IsString(value.$ref) &&
+    value.$ref in value.$defs // required
+  )
+}
 /** Returns true if the given value is TInteger */
 export function IsInteger(value: unknown): value is TInteger {
   return (
diff --git a/src/type/index.ts b/src/type/index.ts
index b69a1fa72..d9d5d5076 100644
--- a/src/type/index.ts
+++ b/src/type/index.ts
@@ -38,7 +38,6 @@ export * from './const/index'
 export * from './constructor/index'
 export * from './constructor-parameters/index'
 export * from './date/index'
-export * from './deref/index'
 export * from './discard/index'
 export * from './enum/index'
 export * from './error/index'
@@ -57,6 +56,7 @@ export * from './iterator/index'
 export * from './keyof/index'
 export * from './literal/index'
 export * from './mapped/index'
+export * from './module/index'
 export * from './never/index'
 export * from './not/index'
 export * from './null/index'
@@ -82,7 +82,6 @@ export * from './return-type/index'
 export * from './schema/index'
 export * from './sets/index'
 export * from './static/index'
-export * from './strict/index'
 export * from './string/index'
 export * from './symbol/index'
 export * from './symbols/index'
diff --git a/src/type/deref/index.ts b/src/type/module/index.ts
similarity index 98%
rename from src/type/deref/index.ts
rename to src/type/module/index.ts
index 28c03fc50..ce46d5a0c 100644
--- a/src/type/deref/index.ts
+++ b/src/type/module/index.ts
@@ -26,4 +26,4 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export * from './deref'
+export * from './module'
diff --git a/src/type/module/module.ts b/src/type/module/module.ts
new file mode 100644
index 000000000..3fef83c80
--- /dev/null
+++ b/src/type/module/module.ts
@@ -0,0 +1,189 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Ensure } from '../helpers/index'
+import { CreateType } from '../create/index'
+import { Kind } from '../symbols/index'
+import { SchemaOptions, TSchema } from '../schema/index'
+import { TObject, TProperties } from '../object/index'
+import { TConstructor } from '../constructor/index'
+import { TFunction } from '../function/index'
+import { TTuple } from '../tuple/index'
+import { TIntersect } from '../intersect/index'
+import { TUnion } from '../union/index'
+import { TArray } from '../array/index'
+import { TAsyncIterator } from '../async-iterator/index'
+import { TIterator } from '../iterator/index'
+import { TLiteral, TLiteralValue } from '../literal/index'
+import { TAny } from '../any/index'
+import { TBigInt } from '../bigint/index'
+import { TBoolean } from '../boolean/index'
+import { TDate } from '../date/index'
+import { TInteger } from '../integer/index'
+import { TNever } from '../never/index'
+import { TNumber } from '../number/index'
+import { TNull } from '../null/index'
+import { TRef } from '../ref/index'
+import { TRegExp } from '../regexp/index'
+import { TString } from '../string/index'
+import { TSymbol } from '../symbol/index'
+import { TTemplateLiteral, TTemplateLiteralKind } from '../template-literal/index'
+import { TUint8Array } from '../uint8array/index'
+import { TUndefined } from '../undefined/index'
+import { TUnknown } from '../unknown/index'
+import { TVoid } from '../void/index'
+import { Static } from '../static/index'
+
+// ------------------------------------------------------------------
+// Infer
+// ------------------------------------------------------------------
+// prettier-ignore
+type InferImport<Properties extends TProperties, Key extends keyof Properties, ModuleProperties extends TProperties> = (
+  Infer<Properties[Key], ModuleProperties>
+)
+// prettier-ignore
+type InferRef<Ref extends string, Properties extends TProperties> = (
+  Ref extends keyof Properties ? Infer<Properties[Ref], Properties> : never
+)
+// prettier-ignore
+type InferObject<Properties extends TProperties, ModuleProperties extends TProperties> = { 
+  [K in keyof Properties]: Infer<Properties[K], ModuleProperties> 
+} & {}
+// prettier-ignore
+type InferConstructor<Parameters extends TSchema[], InstanceType extends TSchema, Properties extends TProperties> = Ensure<
+  new (...args: InferTuple<Parameters, Properties>) => Infer<InstanceType, Properties>
+>
+// prettier-ignore
+type InferFunction<Parameters extends TSchema[], ReturnType extends TSchema, Properties extends TProperties> = Ensure<
+  (...args: InferTuple<Parameters, Properties>) => Infer<ReturnType, Properties>
+>
+// prettier-ignore
+type InferTuple<Types extends TSchema[], Properties extends TProperties, Result extends unknown[] = []> = (
+  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? InferTuple<R, Properties, [...Result, Infer<L, Properties>]>
+    : Result
+)
+// prettier-ignore
+type InferIntersect<Types extends TSchema[], Properties extends TProperties, Result extends unknown = unknown> = (
+  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? InferIntersect<R, Properties, Result & Infer<L, Properties>>
+    : Result
+)
+// prettier-ignore
+type InferUnion<Types extends TSchema[], Properties extends TProperties, Result extends unknown = never> = (
+  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? InferUnion<R, Properties, Result | Infer<L, Properties>>
+    : Result
+)
+// prettier-ignore
+type InferArray<Type extends TSchema, Module extends TProperties> = (
+  Ensure<Array<Infer<Type, Module>>>
+)
+// prettier-ignore
+type InferAsyncIterator<Type extends TSchema, Properties extends TProperties> = (
+  Ensure<AsyncIterableIterator<Infer<Type, Properties>>>
+)
+// prettier-ignore
+type InferIterator<Type extends TSchema, Properties extends TProperties> = (
+  Ensure<IterableIterator<Infer<Type, Properties>>>
+)
+// prettier-ignore
+type Infer<Type extends TSchema, Properties extends TProperties = {}> = (
+  Type extends TImport<infer S extends TProperties, infer K extends string> ? InferImport<S, K, S> :
+  Type extends TRef<infer S extends string> ? InferRef<S, Properties> :
+  Type extends TObject<infer S extends TProperties> ? InferObject<S, Properties> :
+  Type extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? InferConstructor<S, R, Properties> :
+  Type extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? InferFunction<S, R, Properties> :
+  Type extends TTuple<infer S extends TSchema[]> ? InferTuple<S, Properties> :
+  Type extends TIntersect<infer S extends TSchema[]> ? InferIntersect<S, Properties> :
+  Type extends TUnion<infer S extends TSchema[]> ? InferUnion<S, Properties> :
+  Type extends TArray<infer S extends TSchema> ? InferArray<S, Properties> :
+  Type extends TAsyncIterator<infer S extends TSchema> ? InferAsyncIterator<S, Properties> :
+  Type extends TIterator<infer S extends TSchema> ? InferIterator<S, Properties> :
+  Type extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? Static<TTemplateLiteral<S>> :
+  Type extends TLiteral<infer S extends TLiteralValue> ? S :
+  Type extends TAny ? any :
+  Type extends TBigInt ? bigint :
+  Type extends TBoolean ? boolean :
+  Type extends TDate ? Date :
+  Type extends TInteger ? number :
+  Type extends TNever ? never :
+  Type extends TNumber ? number :
+  Type extends TRegExp ? string :
+  Type extends TString ? string :
+  Type extends TSymbol ? symbol :
+  Type extends TNull ? null :
+  Type extends TUint8Array ? Uint8Array :
+  Type extends TUndefined ? undefined :
+  Type extends TUnknown ? unknown :
+  Type extends TVoid ? void :
+  never
+)
+// ------------------------------------------------------------------
+// Definitions
+// ------------------------------------------------------------------
+export interface TDefinitions<ModuleProperties extends TProperties> extends TSchema {
+  static: { [K in keyof ModuleProperties]: Static<ModuleProperties[K]> }
+  $defs: ModuleProperties
+}
+// ------------------------------------------------------------------
+// Import
+// ------------------------------------------------------------------
+// prettier-ignore
+export interface TImport<ModuleProperties extends TProperties = {}, Key extends keyof ModuleProperties = keyof ModuleProperties> extends TSchema {
+  [Kind]: 'Import'
+  static: InferImport<ModuleProperties, Key, ModuleProperties>
+  $defs: ModuleProperties
+  $ref: Key
+}
+// ------------------------------------------------------------------
+// Module
+// ------------------------------------------------------------------
+// prettier-ignore
+export class TModule<Properties extends TProperties> {
+  constructor(private readonly $defs: Properties, private readonly options: SchemaOptions = {}) {}
+  
+  /** `[Json]` Returns the Type definitions for this module */
+  public Defs(): TDefinitions<Properties> {
+    return CreateType({ $defs: this.ResolveDefinitionsWithIdentifiers() }, this.options) as never 
+  }
+  /** `[Json]` Imports a Type by Key. */
+  public Import<Key extends keyof Properties>(key: Key, options?: SchemaOptions): TImport<Properties, Key> {
+    return CreateType({ [Kind]: 'Import', $defs: this.ResolveDefinitionsWithIdentifiers(), $ref: key }, options) as never
+  }
+  /** `[Internal]` For each definition, assign an `$id` property. */
+  private ResolveDefinitionsWithIdentifiers() {
+    return globalThis.Object.getOwnPropertyNames(this.$defs).reduce((Result, Key) => (
+      { ...Result, [Key]: { ...this.$defs[Key], $id: Key }}
+    ), {})
+  }
+}
+/** `[Json]` Creates a Type Definition Module. */
+export function Module<Properties extends TProperties>(properties: Properties): TModule<Properties> {
+  return new TModule(properties)
+}
diff --git a/src/type/ref/ref.ts b/src/type/ref/ref.ts
index 3edd35b3d..f61f04fac 100644
--- a/src/type/ref/ref.ts
+++ b/src/type/ref/ref.ts
@@ -26,29 +26,19 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { CreateType } from '../create/type'
 import type { TSchema, SchemaOptions } from '../schema/index'
-import type { Static } from '../static/index'
+import { CreateType } from '../create/type'
 import { Kind } from '../symbols/index'
-// ------------------------------------------------------------------
-// ValueGuard
-// ------------------------------------------------------------------
-import { IsString, IsUndefined } from '../guard/value'
+
 // ------------------------------------------------------------------
 // TRef
 // ------------------------------------------------------------------
-export interface TRef<T extends TSchema = TSchema> extends TSchema {
+export interface TRef<Ref extends string = string> extends TSchema {
   [Kind]: 'Ref'
-  static: Static<T, this['params']>
-  $ref: string
+  static: unknown
+  $ref: Ref
 }
 /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
-export function Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>
-/** `[Json]` Creates a Ref type. */
-export function Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>
-/** `[Json]` Creates a Ref type. */
-export function Ref(unresolved: TSchema | string, options?: SchemaOptions) {
-  if (IsString(unresolved)) return CreateType({ [Kind]: 'Ref', $ref: unresolved }, options)
-  if (IsUndefined(unresolved.$id)) throw new Error('Reference target type must specify an $id')
-  return CreateType({ [Kind]: 'Ref', $ref: unresolved.$id! }, options)
+export function Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref> {
+  return CreateType({ [Kind]: 'Ref', $ref }, options) as never
 }
diff --git a/src/type/static/static.ts b/src/type/static/static.ts
index 7e346b7ac..2ba1f1bdc 100644
--- a/src/type/static/static.ts
+++ b/src/type/static/static.ts
@@ -77,7 +77,7 @@ export type TDecodeType<T extends TSchema> = (
   T extends TPromise<infer S extends TSchema> ? TPromise<TDecodeType<S>> :
   T extends TRecord<infer K, infer S> ? TRecord<K, TDecodeType<S>> :
   T extends TRecursive<infer S extends TSchema> ? TRecursive<TDecodeType<S>> :
-  T extends TRef<infer S extends TSchema> ? TRef<TDecodeType<S>> :
+  T extends TRef<infer S extends string> ? TRef<S> :
   T extends TTuple<infer S extends TSchema[]> ? TTuple<TDecodeRest<S>> :
   T extends TUnion<infer S extends TSchema[]> ? TUnion<TDecodeRest<S>> :
   T
diff --git a/src/type/strict/index.ts b/src/type/strict/index.ts
deleted file mode 100644
index 24555f714..000000000
--- a/src/type/strict/index.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-export * from './strict'
diff --git a/src/type/strict/strict.ts b/src/type/strict/strict.ts
deleted file mode 100644
index 96da5a1e1..000000000
--- a/src/type/strict/strict.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import type { TSchema } from '../schema/index'
-
-export type TStrict<T extends TSchema> = T
-
-/**
- * @deprecated `[Json]` Omits compositing symbols from this schema. It is recommended
- * to use the JSON parse/stringify to remove compositing symbols if needed. This
- * is how Strict works internally.
- *
- * ```typescript
- * JSON.parse(JSON.stringify(Type.String()))
- * ```
- */
-export function Strict<T extends TSchema>(schema: T): TStrict<T> {
-  return JSON.parse(JSON.stringify(schema))
-}
diff --git a/src/type/type/json.ts b/src/type/type/json.ts
index 0650ebc96..7613dc3f4 100644
--- a/src/type/type/json.ts
+++ b/src/type/type/json.ts
@@ -31,7 +31,6 @@ import { Array, type TArray, type ArrayOptions } from '../array/index'
 import { Boolean, type TBoolean } from '../boolean/index'
 import { Composite, type TComposite } from '../composite/index'
 import { Const, type TConst } from '../const/index'
-import { Deref, type TDeref } from '../deref/index'
 import { Enum, type TEnum, type TEnumKey, type TEnumValue } from '../enum/index'
 import { Exclude, type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from '../exclude/index'
 import { Extends, type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index'
@@ -47,6 +46,7 @@ import { Never, type TNever } from '../never/index'
 import { Not, type TNot } from '../not/index'
 import { Null, type TNull } from '../null/index'
 import { type TMappedKey } from '../mapped/index'
+import { Module, TModule } from '../module/index'
 import { Number, type TNumber, type NumberOptions } from '../number/index'
 import { Object, type TObject, type TProperties, type ObjectOptions } from '../object/index'
 import { Omit, type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from '../omit/index'
@@ -61,7 +61,6 @@ import { Ref, type TRef } from '../ref/index'
 import { Required, type TRequired, type TRequiredFromMappedResult } from '../required/index'
 import { Rest, type TRest } from '../rest/index'
 import { type TSchema, type SchemaOptions } from '../schema/index'
-import { Strict, type TStrict } from '../strict/index'
 import { String, type TString, type StringOptions } from '../string/index'
 import { TemplateLiteral, type TTemplateLiteral, type TTemplateLiteralKind, type TTemplateLiteralSyntax } from '../template-literal/index'
 import { Transform, TransformDecodeBuilder } from '../transform/index'
@@ -72,21 +71,6 @@ import { Unsafe, type TUnsafe, type UnsafeOptions } from '../unsafe/index'
 
 /** Json Type Builder with Static Resolution for TypeScript */
 export class JsonTypeBuilder {
-  // ------------------------------------------------------------------------
-  // Strict
-  // ------------------------------------------------------------------------
-  /**
-   * @deprecated `[Json]` Omits compositing symbols from this schema. It is recommended
-   * to use the JSON parse/stringify to remove compositing symbols if needed. This
-   * is how Strict works internally.
-   *
-   * ```typescript
-   * JSON.parse(JSON.stringify(Type.String()))
-   * ```
-   */
-  public Strict<T extends TSchema>(schema: T): TStrict<T> {
-    return Strict(schema)
-  }
   // ------------------------------------------------------------------------
   // Modifiers
   // ------------------------------------------------------------------------
@@ -145,10 +129,6 @@ export class JsonTypeBuilder {
   public Const</* const (not supported in 4.0) */ T>(value: T, options?: SchemaOptions): TConst<T> {
     return Const(value, options)
   }
-  /** `[Json]` Creates a dereferenced type */
-  public Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T> {
-    return Deref(schema, references)
-  }
   /** `[Json]` Creates a Enum type */
   public Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T> {
     return Enum(item, options)
@@ -227,6 +207,10 @@ export class JsonTypeBuilder {
   public Mapped(key: any, map: TMappedFunction<any>, options?: ObjectOptions): any {
     return Mapped(key, map, options)
   }
+  /** `[Json]` Creates a Type Definition Module. */
+  public Module<Properties extends TProperties>(properties: Properties): TModule<Properties> {
+    return Module(properties)
+  }
   /** `[Json]` Creates a Never type */
   public Never(options?: SchemaOptions): TNever {
     return Never(options)
@@ -287,13 +271,9 @@ export class JsonTypeBuilder {
   public Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T> {
     return Recursive(callback, options)
   }
-  /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
-  public Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>
-  /** `[Json]` Creates a Ref type. */
-  public Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>
   /** `[Json]` Creates a Ref type. */
-  public Ref(unresolved: TSchema | string, options?: SchemaOptions) {
-    return Ref(unresolved as any, options)
+  public Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref> {
+    return Ref($ref, options)
   }
   /** `[Json]` Constructs a type where all properties are required */
   public Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>
diff --git a/src/type/type/type.ts b/src/type/type/type.ts
index 8dd7cc893..d00686cc6 100644
--- a/src/type/type/type.ts
+++ b/src/type/type/type.ts
@@ -40,7 +40,6 @@ export { Const } from '../const/index'
 export { Constructor } from '../constructor/index'
 export { ConstructorParameters } from '../constructor-parameters/index'
 export { Date } from '../date/index'
-export { Deref } from '../deref/index'
 export { Enum } from '../enum/index'
 export { Exclude } from '../exclude/index'
 export { Extends } from '../extends/index'
@@ -55,6 +54,7 @@ export { Iterator } from '../iterator/index'
 export { KeyOf } from '../keyof/index'
 export { Literal } from '../literal/index'
 export { Mapped } from '../mapped/index'
+export { Module } from '../module/index'
 export { Never } from '../never/index'
 export { Not } from '../not/index'
 export { Null } from '../null/index'
@@ -76,7 +76,6 @@ export { Required } from '../required/index'
 export { Rest } from '../rest/index'
 export { ReturnType } from '../return-type/index'
 export { String } from '../string/index'
-export { Strict } from '../strict/index'
 export { Symbol } from '../symbol/index'
 export { TemplateLiteral } from '../template-literal/index'
 export { Transform } from '../transform/index'
diff --git a/src/value/cast/cast.ts b/src/value/cast/cast.ts
index 78ac75433..a6f9d9891 100644
--- a/src/value/cast/cast.ts
+++ b/src/value/cast/cast.ts
@@ -32,12 +32,13 @@ import { Kind } from '../../type/symbols/index'
 import { Create } from '../create/index'
 import { Check } from '../check/index'
 import { Clone } from '../clone/index'
-import { Deref } from '../deref/index'
+import { Deref, Pushref } from '../deref/index'
 
 import type { TSchema } from '../../type/schema/index'
 import type { Static } from '../../type/static/index'
 import type { TArray } from '../../type/array/index'
 import type { TConstructor } from '../../type/constructor/index'
+import type { TImport } from '../../type/module/index'
 import type { TIntersect } from '../../type/intersect/index'
 import type { TObject } from '../../type/object/index'
 import type { TRecord } from '../../type/record/index'
@@ -133,6 +134,11 @@ function FromConstructor(schema: TConstructor, references: TSchema[], value: any
   }
   return result
 }
+function FromImport(schema: TImport, references: TSchema[], value: unknown): boolean {
+  const definitions = globalThis.Object.values(schema.$defs) as TSchema[]
+  const target = schema.$defs[schema.$ref] as TSchema
+  return Visit(target, [...references, ...definitions], value)
+}
 function FromIntersect(schema: TIntersect, references: TSchema[], value: any): any {
   const created = Create(schema, references)
   const mapped = IsObject(created) && IsObject(value) ? { ...(created as any), ...value } : value
@@ -187,7 +193,7 @@ function FromUnion(schema: TUnion, references: TSchema[], value: any): any {
   return Check(schema, references, value) ? Clone(value) : CastUnion(schema, references, value)
 }
 function Visit(schema: TSchema, references: TSchema[], value: any): any {
-  const references_ = IsString(schema.$id) ? [...references, schema] : references
+  const references_ = IsString(schema.$id) ? Pushref(schema, references) : references
   const schema_ = schema as any
   switch (schema[Kind]) {
     // --------------------------------------------------------------
@@ -197,6 +203,8 @@ function Visit(schema: TSchema, references: TSchema[], value: any): any {
       return FromArray(schema_, references_, value)
     case 'Constructor':
       return FromConstructor(schema_, references_, value)
+    case 'Import':
+      return FromImport(schema_, references_, value)
     case 'Intersect':
       return FromIntersect(schema_, references_, value)
     case 'Never':
diff --git a/src/value/check/check.ts b/src/value/check/check.ts
index 436c0f047..b1af0dd26 100644
--- a/src/value/check/check.ts
+++ b/src/value/check/check.ts
@@ -27,7 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { TypeSystemPolicy } from '../../system/index'
-import { Deref } from '../deref/index'
+import { Deref, Pushref } from '../deref/index'
 import { Hash } from '../hash/index'
 import { Kind } from '../../type/symbols/index'
 import { KeyOfPattern } from '../../type/keyof/index'
@@ -48,6 +48,7 @@ import type { TInteger } from '../../type/integer/index'
 import type { TIntersect } from '../../type/intersect/index'
 import type { TIterator } from '../../type/iterator/index'
 import type { TLiteral } from '../../type/literal/index'
+import type { TImport } from '../../type/module/index'
 import { Never, type TNever } from '../../type/never/index'
 import type { TNot } from '../../type/not/index'
 import type { TNull } from '../../type/null/index'
@@ -185,6 +186,11 @@ function FromDate(schema: TDate, references: TSchema[], value: any): boolean {
 function FromFunction(schema: TFunction, references: TSchema[], value: any): boolean {
   return IsFunction(value)
 }
+function FromImport(schema: TImport, references: TSchema[], value: any): boolean {
+  const definitions = globalThis.Object.values(schema.$defs) as TSchema[]
+  const target = schema.$defs[schema.$ref] as TSchema
+  return Visit(target, [...references, ...definitions], value)
+}
 function FromInteger(schema: TInteger, references: TSchema[], value: any): boolean {
   if (!IsInteger(value)) {
     return false
@@ -415,7 +421,7 @@ function FromKind(schema: TSchema, references: TSchema[], value: unknown): boole
   return func(schema, value)
 }
 function Visit<T extends TSchema>(schema: T, references: TSchema[], value: any): boolean {
-  const references_ = IsDefined<string>(schema.$id) ? [...references, schema] : references
+  const references_ = IsDefined<string>(schema.$id) ? Pushref(schema, references) : references
   const schema_ = schema as any
   switch (schema_[Kind]) {
     case 'Any':
@@ -434,6 +440,8 @@ function Visit<T extends TSchema>(schema: T, references: TSchema[], value: any):
       return FromDate(schema_, references_, value)
     case 'Function':
       return FromFunction(schema_, references_, value)
+    case 'Import':
+      return FromImport(schema_, references_, value)
     case 'Integer':
       return FromInteger(schema_, references_, value)
     case 'Intersect':
diff --git a/src/value/clean/clean.ts b/src/value/clean/clean.ts
index d3be4a79d..341cf025e 100644
--- a/src/value/clean/clean.ts
+++ b/src/value/clean/clean.ts
@@ -29,11 +29,12 @@ THE SOFTWARE.
 import { KeyOfPropertyKeys } from '../../type/keyof/index'
 import { Check } from '../check/index'
 import { Clone } from '../clone/index'
-import { Deref } from '../deref/index'
+import { Deref, Pushref } from '../deref/index'
 import { Kind } from '../../type/symbols/index'
 
 import type { TSchema } from '../../type/schema/index'
 import type { TArray } from '../../type/array/index'
+import type { TImport } from 'src/type/module/index'
 import type { TIntersect } from '../../type/intersect/index'
 import type { TObject } from '../../type/object/index'
 import type { TRecord } from '../../type/record/index'
@@ -60,6 +61,7 @@ import {
 import { 
   IsKind
 } from '../../type/guard/kind'
+
 // ------------------------------------------------------------------
 // IsCheckable
 // ------------------------------------------------------------------
@@ -73,6 +75,11 @@ function FromArray(schema: TArray, references: TSchema[], value: unknown): any {
   if (!IsArray(value)) return value
   return value.map((value) => Visit(schema.items, references, value))
 }
+function FromImport(schema: TImport, references: TSchema[], value: unknown): any {
+  const definitions = globalThis.Object.values(schema.$defs) as TSchema[]
+  const target = schema.$defs[schema.$ref] as TSchema
+  return Visit(target, [...references, ...definitions], value)
+}
 function FromIntersect(schema: TIntersect, references: TSchema[], value: unknown): any {
   const unevaluatedProperties = schema.unevaluatedProperties as TSchema
   const intersections = schema.allOf.map((schema) => Visit(schema, references, Clone(value)))
@@ -149,11 +156,13 @@ function FromUnion(schema: TUnion, references: TSchema[], value: unknown): any {
   return value
 }
 function Visit(schema: TSchema, references: TSchema[], value: unknown): unknown {
-  const references_ = IsString(schema.$id) ? [...references, schema] : references
+  const references_ = IsString(schema.$id) ? Pushref(schema, references) : references
   const schema_ = schema as any
   switch (schema_[Kind]) {
     case 'Array':
       return FromArray(schema_, references_, value)
+    case 'Import':
+      return FromImport(schema_, references_, value)
     case 'Intersect':
       return FromIntersect(schema_, references_, value)
     case 'Object':
diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index a5ddf7b0a..1cfaa1081 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -38,6 +38,7 @@ import type { TBoolean } from '../../type/boolean/index'
 import type { TDate } from '../../type/date/index'
 import type { TInteger } from '../../type/integer/index'
 import type { TIntersect } from '../../type/intersect/index'
+import type { TImport } from '../../type/module/index'
 import type { TLiteral } from '../../type/literal/index'
 import type { TNull } from '../../type/null/index'
 import type { TNumber } from '../../type/number/index'
@@ -182,6 +183,11 @@ function FromBoolean(schema: TBoolean, references: TSchema[], value: any): unkno
 function FromDate(schema: TDate, references: TSchema[], value: any): unknown {
   return TryConvertDate(value)
 }
+function FromImport(schema: TImport, references: TSchema[], value: unknown): unknown {
+  const definitions = globalThis.Object.values(schema.$defs) as TSchema[]
+  const target = schema.$defs[schema.$ref] as TSchema
+  return Visit(target, [...references, ...definitions], value)
+}
 function FromInteger(schema: TInteger, references: TSchema[], value: any): unknown {
   return TryConvertInteger(value)
 }
@@ -261,6 +267,8 @@ function Visit(schema: TSchema, references: TSchema[], value: any): unknown {
       return FromBoolean(schema_, references_, value)
     case 'Date':
       return FromDate(schema_, references_, value)
+    case 'Import':
+      return FromImport(schema_, references_, value)
     case 'Integer':
       return FromInteger(schema_, references_, value)
     case 'Intersect':
diff --git a/src/value/create/create.ts b/src/value/create/create.ts
index a1c24c578..478aab130 100644
--- a/src/value/create/create.ts
+++ b/src/value/create/create.ts
@@ -45,6 +45,7 @@ import type { TBoolean } from '../../type/boolean/index'
 import type { TDate } from '../../type/date/index'
 import type { TConstructor } from '../../type/constructor/index'
 import type { TFunction } from '../../type/function/index'
+import type { TImport } from '../../type/module/index'
 import type { TInteger } from '../../type/integer/index'
 import type { TIntersect } from '../../type/intersect/index'
 import type { TIterator } from '../../type/iterator/index'
@@ -167,6 +168,11 @@ function FromFunction(schema: TFunction, references: TSchema[]): any {
     return () => Visit(schema.returns, references)
   }
 }
+function FromImport(schema: TImport, references: TSchema[]): any {
+  const definitions = globalThis.Object.values(schema.$defs) as TSchema[]
+  const target = schema.$defs[schema.$ref] as TSchema
+  return Visit(target, [...references, ...definitions])
+}
 function FromInteger(schema: TInteger, references: TSchema[]): any {
   if (HasPropertyKey(schema, 'default')) {
     return FromDefault(schema.default)
@@ -411,6 +417,8 @@ function Visit(schema: TSchema, references: TSchema[]): unknown {
       return FromDate(schema_, references_)
     case 'Function':
       return FromFunction(schema_, references_)
+    case 'Import':
+      return FromImport(schema_, references_)
     case 'Integer':
       return FromInteger(schema_, references_)
     case 'Intersect':
diff --git a/src/value/default/default.ts b/src/value/default/default.ts
index 19b4b6496..30ddbc95b 100644
--- a/src/value/default/default.ts
+++ b/src/value/default/default.ts
@@ -33,6 +33,7 @@ import { Kind } from '../../type/symbols/index'
 
 import type { TSchema } from '../../type/schema/index'
 import type { TArray } from '../../type/array/index'
+import type { TImport } from '../../type/module/index'
 import type { TIntersect } from '../../type/intersect/index'
 import type { TObject } from '../../type/object/index'
 import type { TRecord } from '../../type/record/index'
@@ -78,6 +79,11 @@ function FromDate(schema: TArray, references: TSchema[], value: unknown): any {
   // special case intercept for dates
   return IsDate(value) ? value : ValueOrDefault(schema, value)
 }
+function FromImport(schema: TImport, references: TSchema[], value: unknown): any {
+  const definitions = globalThis.Object.values(schema.$defs) as TSchema[]
+  const target = schema.$defs[schema.$ref] as TSchema
+  return Visit(target, [...references, ...definitions], value)
+}
 function FromIntersect(schema: TIntersect, references: TSchema[], value: unknown): any {
   const defaulted = ValueOrDefault(schema, value)
   return schema.allOf.reduce((acc, schema) => {
@@ -161,6 +167,8 @@ function Visit(schema: TSchema, references: TSchema[], value: unknown): any {
       return FromArray(schema_, references_, value)
     case 'Date':
       return FromDate(schema_, references_, value)
+    case 'Import':
+      return FromImport(schema_, references_, value)
     case 'Intersect':
       return FromIntersect(schema_, references_, value)
     case 'Object':
diff --git a/src/value/transform/decode.ts b/src/value/transform/decode.ts
index be56d12bc..2498058b1 100644
--- a/src/value/transform/decode.ts
+++ b/src/value/transform/decode.ts
@@ -36,6 +36,7 @@ import { Check } from '../check/index'
 
 import type { TSchema } from '../../type/schema/index'
 import type { TArray } from '../../type/array/index'
+import type { TImport } from '../../type/module/index'
 import type { TIntersect } from '../../type/intersect/index'
 import type { TNot } from '../../type/not/index'
 import type { TObject } from '../../type/object/index'
@@ -82,7 +83,7 @@ export class TransformDecodeError extends TypeBoxError {
 // Decode
 // ------------------------------------------------------------------
 // prettier-ignore
-function Default(schema: TSchema, path: string, value: any) {
+function Default(schema: TSchema, path: string, value: any): unknown {
   try {
     return IsTransform(schema) ? schema[TransformKind].Decode(value) : value
   } catch (error) {
@@ -90,13 +91,13 @@ function Default(schema: TSchema, path: string, value: any) {
   }
 }
 // prettier-ignore
-function FromArray(schema: TArray, references: TSchema[], path: string, value: any): any {
+function FromArray(schema: TArray, references: TSchema[], path: string, value: any): unknown {
   return (IsArray(value))
     ? Default(schema, path, value.map((value: any, index) => Visit(schema.items, references, `${path}/${index}`, value)))
     : Default(schema, path, value)
 }
 // prettier-ignore
-function FromIntersect(schema: TIntersect, references: TSchema[], path: string, value: any) {
+function FromIntersect(schema: TIntersect, references: TSchema[], path: string, value: any): unknown {
   if (!IsObject(value) || IsValueType(value)) return Default(schema, path, value)
   const knownEntries = KeyOfPropertyEntries(schema)
   const knownKeys = knownEntries.map(entry => entry[0])
@@ -115,11 +116,20 @@ function FromIntersect(schema: TIntersect, references: TSchema[], path: string,
   }
   return Default(schema, path, unknownProperties)
 }
-function FromNot(schema: TNot, references: TSchema[], path: string, value: any) {
+// prettier-ignore
+function FromImport(schema: TImport, references: TSchema[], path: string, value: unknown): unknown {
+  const definitions = globalThis.Object.values(schema.$defs) as TSchema[]
+  const target = schema.$defs[schema.$ref] as TSchema
+  const transform = schema[TransformKind as never]
+  // Note: we need to re-spec the target as TSchema + [TransformKind]
+  const transformTarget = { [TransformKind]: transform, ...target } as TSchema
+  return Visit(transformTarget as never, [...references, ...definitions], path, value)
+}
+function FromNot(schema: TNot, references: TSchema[], path: string, value: any): unknown {
   return Default(schema, path, Visit(schema.not, references, path, value))
 }
 // prettier-ignore
-function FromObject(schema: TObject, references: TSchema[], path: string, value: any) {
+function FromObject(schema: TObject, references: TSchema[], path: string, value: any): unknown {
   if (!IsObject(value)) return Default(schema, path, value)
   const knownKeys = KeyOfPropertyKeys(schema) as string[]
   const knownProperties = { ...value } as Record<PropertyKey, unknown>
@@ -147,7 +157,7 @@ function FromObject(schema: TObject, references: TSchema[], path: string, value:
   return Default(schema, path, unknownProperties)
 }
 // prettier-ignore
-function FromRecord(schema: TRecord, references: TSchema[], path: string, value: any) {
+function FromRecord(schema: TRecord, references: TSchema[], path: string, value: any): unknown {
   if (!IsObject(value)) return Default(schema, path, value)
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0]
   const knownKeys = new RegExp(pattern)
@@ -167,23 +177,23 @@ function FromRecord(schema: TRecord, references: TSchema[], path: string, value:
   return Default(schema, path, unknownProperties)
 }
 // prettier-ignore
-function FromRef(schema: TRef, references: TSchema[], path: string, value: any) {
+function FromRef(schema: TRef, references: TSchema[], path: string, value: any): unknown {
   const target = Deref(schema, references)
   return Default(schema, path, Visit(target, references, path, value))
 }
 // prettier-ignore
-function FromThis(schema: TThis, references: TSchema[], path: string, value: any) {
+function FromThis(schema: TThis, references: TSchema[], path: string, value: any): unknown {
   const target = Deref(schema, references)
   return Default(schema, path, Visit(target, references, path, value))
 }
 // prettier-ignore
-function FromTuple(schema: TTuple, references: TSchema[], path: string, value: any) {
+function FromTuple(schema: TTuple, references: TSchema[], path: string, value: any): unknown {
   return (IsArray(value) && IsArray(schema.items))
     ? Default(schema, path, schema.items.map((schema, index) => Visit(schema, references, `${path}/${index}`, value[index])))
     : Default(schema, path, value)
 }
 // prettier-ignore
-function FromUnion(schema: TUnion, references: TSchema[], path: string, value: any) {
+function FromUnion(schema: TUnion, references: TSchema[], path: string, value: any): unknown {
   for (const subschema of schema.anyOf) {
     if (!Check(subschema, references, value)) continue
     // note: ensure interior is decoded first
@@ -199,6 +209,8 @@ function Visit(schema: TSchema, references: TSchema[], path: string, value: any)
   switch (schema[Kind]) {
     case 'Array':
       return FromArray(schema_, references_, path, value)
+    case 'Import':
+      return FromImport(schema_, references_, path, value)      
     case 'Intersect':
       return FromIntersect(schema_, references_, path, value)
     case 'Not':
diff --git a/src/value/transform/encode.ts b/src/value/transform/encode.ts
index cb626f916..1f033dc79 100644
--- a/src/value/transform/encode.ts
+++ b/src/value/transform/encode.ts
@@ -36,6 +36,7 @@ import { Check } from '../check/index'
 
 import type { TSchema } from '../../type/schema/index'
 import type { TArray } from '../../type/array/index'
+import type { TImport } from '../../type/module/index'
 import type { TIntersect } from '../../type/intersect/index'
 import type { TNot } from '../../type/not/index'
 import type { TObject } from '../../type/object/index'
@@ -96,6 +97,15 @@ function FromArray(schema: TArray, references: TSchema[], path: string, value: a
     : defaulted
 }
 // prettier-ignore
+function FromImport(schema: TImport, references: TSchema[], path: string, value: unknown): unknown {
+  const definitions = globalThis.Object.values(schema.$defs) as TSchema[]
+  const target = schema.$defs[schema.$ref] as TSchema
+  const transform = schema[TransformKind as never]
+  // Note: we need to re-spec the target as TSchema + [TransformKind]
+  const transformTarget = { [TransformKind]: transform, ...target } as TSchema
+  return Visit(transformTarget as never, [...references, ...definitions], path, value)
+}
+// prettier-ignore
 function FromIntersect(schema: TIntersect, references: TSchema[], path: string, value: any) {
   const defaulted = Default(schema, path, value)
   if (!IsObject(value) || IsValueType(value)) return defaulted
@@ -210,6 +220,8 @@ function Visit(schema: TSchema, references: TSchema[], path: string, value: any)
   switch (schema[Kind]) {
     case 'Array':
       return FromArray(schema_, references_, path, value)
+    case 'Import':
+      return FromImport(schema_, references_, path, value)
     case 'Intersect':
       return FromIntersect(schema_, references_, path, value)
     case 'Not':
diff --git a/test/runtime/compiler-ajv/index.ts b/test/runtime/compiler-ajv/index.ts
index ae974b96d..3963d5c22 100644
--- a/test/runtime/compiler-ajv/index.ts
+++ b/test/runtime/compiler-ajv/index.ts
@@ -9,6 +9,7 @@ import './integer'
 import './intersect'
 import './keyof'
 import './literal'
+import './module'
 import './never'
 import './not'
 import './null'
diff --git a/test/runtime/compiler-ajv/module.ts b/test/runtime/compiler-ajv/module.ts
new file mode 100644
index 000000000..9de6813b7
--- /dev/null
+++ b/test/runtime/compiler-ajv/module.ts
@@ -0,0 +1,78 @@
+import { Type } from '@sinclair/typebox'
+import { Ok, Fail } from './validate'
+
+describe('compiler-ajv/Module', () => {
+  it('Should validate string', () => {
+    const Module = Type.Module({
+      A: Type.String(),
+    })
+    const T = Module.Import('A')
+    Ok(T, 'hello')
+    Fail(T, true)
+  })
+  it('Should validate referenced string', () => {
+    const Module = Type.Module({
+      A: Type.String(),
+      B: Type.Ref('A'),
+    })
+    const T = Module.Import('B')
+    Ok(T, 'hello')
+    Fail(T, true)
+  })
+  it('Should validate self referential', () => {
+    const Module = Type.Module({
+      A: Type.Object({
+        nodes: Type.Array(Type.Ref('A')),
+      }),
+    })
+    const T = Module.Import('A')
+    Ok(T, { nodes: [{ nodes: [{ nodes: [] }, { nodes: [] }] }] })
+    Fail(T, { nodes: [{ nodes: [{ nodes: [] }, { nodes: false }] }] })
+    Fail(T, true)
+  })
+  it('Should validate mutual recursive', () => {
+    const Module = Type.Module({
+      A: Type.Object({
+        b: Type.Ref('B'),
+      }),
+      B: Type.Object({
+        a: Type.Union([Type.Ref('A'), Type.Null()]),
+      }),
+    })
+    const T = Module.Import('A')
+    Ok(T, { b: { a: null } })
+    Ok(T, { b: { a: { b: { a: null } } } })
+    Fail(T, { b: { a: 1 } })
+    Fail(T, { b: { a: { b: { a: 1 } } } })
+    Fail(T, true)
+  })
+  it('Should validate mutual recursive (Array)', () => {
+    const Module = Type.Module({
+      A: Type.Object({
+        b: Type.Ref('B'),
+      }),
+      B: Type.Object({
+        a: Type.Array(Type.Ref('A')),
+      }),
+    })
+    const T = Module.Import('A')
+    Ok(T, { b: { a: [{ b: { a: [] } }] } })
+    Fail(T, { b: { a: [{ b: { a: [null] } }] } })
+    Fail(T, true)
+  })
+  it('Should validate deep referential', () => {
+    const Module = Type.Module({
+      A: Type.Ref('B'),
+      B: Type.Ref('C'),
+      C: Type.Ref('D'),
+      D: Type.Ref('E'),
+      E: Type.Ref('F'),
+      F: Type.Ref('G'),
+      G: Type.Ref('H'),
+      H: Type.Literal('hello'),
+    })
+    const T = Module.Import('A')
+    Ok(T, 'hello')
+    Fail(T, 'world')
+  })
+})
diff --git a/test/runtime/compiler-ajv/ref.ts b/test/runtime/compiler-ajv/ref.ts
index d9bf5c954..564dbc197 100644
--- a/test/runtime/compiler-ajv/ref.ts
+++ b/test/runtime/compiler-ajv/ref.ts
@@ -11,7 +11,7 @@ describe('compiler-ajv/Ref', () => {
       },
       { $id: 'T' },
     )
-    const R = Type.Ref(T)
+    const R = Type.Ref(T.$id!)
     Ok(
       R,
       {
@@ -31,7 +31,7 @@ describe('compiler-ajv/Ref', () => {
       },
       { $id: 'T' },
     )
-    const R = Type.Ref(T)
+    const R = Type.Ref(T.$id!)
     Fail(
       R,
       {
@@ -54,7 +54,7 @@ describe('compiler-ajv/Ref', () => {
         x: Type.Number(),
         y: Type.Number(),
         z: Type.Number(),
-        r: Type.Optional(Type.Ref(R)),
+        r: Type.Optional(Type.Ref(R.$id!)),
       },
       { $id: 'T' },
     )
diff --git a/test/runtime/compiler/index.ts b/test/runtime/compiler/index.ts
index 487c94a60..21decd7fa 100644
--- a/test/runtime/compiler/index.ts
+++ b/test/runtime/compiler/index.ts
@@ -16,6 +16,7 @@ import './iterator'
 import './keyof'
 import './kind'
 import './literal'
+import './module'
 import './never'
 import './not'
 import './null'
diff --git a/test/runtime/compiler/module.ts b/test/runtime/compiler/module.ts
new file mode 100644
index 000000000..02fcb4d45
--- /dev/null
+++ b/test/runtime/compiler/module.ts
@@ -0,0 +1,78 @@
+import { Type } from '@sinclair/typebox'
+import { Ok, Fail } from './validate'
+
+describe('compiler/Module', () => {
+  it('Should validate string', () => {
+    const Module = Type.Module({
+      A: Type.String(),
+    })
+    const T = Module.Import('A')
+    Ok(T, 'hello')
+    Fail(T, true)
+  })
+  it('Should validate referenced string', () => {
+    const Module = Type.Module({
+      A: Type.String(),
+      B: Type.Ref('A'),
+    })
+    const T = Module.Import('B')
+    Ok(T, 'hello')
+    Fail(T, true)
+  })
+  it('Should validate self referential', () => {
+    const Module = Type.Module({
+      A: Type.Object({
+        nodes: Type.Array(Type.Ref('A')),
+      }),
+    })
+    const T = Module.Import('A')
+    Ok(T, { nodes: [{ nodes: [{ nodes: [] }, { nodes: [] }] }] })
+    Fail(T, { nodes: [{ nodes: [{ nodes: [] }, { nodes: false }] }] })
+    Fail(T, true)
+  })
+  it('Should validate mutual recursive', () => {
+    const Module = Type.Module({
+      A: Type.Object({
+        b: Type.Ref('B'),
+      }),
+      B: Type.Object({
+        a: Type.Union([Type.Ref('A'), Type.Null()]),
+      }),
+    })
+    const T = Module.Import('A')
+    Ok(T, { b: { a: null } })
+    Ok(T, { b: { a: { b: { a: null } } } })
+    Fail(T, { b: { a: 1 } })
+    Fail(T, { b: { a: { b: { a: 1 } } } })
+    Fail(T, true)
+  })
+  it('Should validate mutual recursive (Array)', () => {
+    const Module = Type.Module({
+      A: Type.Object({
+        b: Type.Ref('B'),
+      }),
+      B: Type.Object({
+        a: Type.Array(Type.Ref('A')),
+      }),
+    })
+    const T = Module.Import('A')
+    Ok(T, { b: { a: [{ b: { a: [] } }] } })
+    Fail(T, { b: { a: [{ b: { a: [null] } }] } })
+    Fail(T, true)
+  })
+  it('Should validate deep referential', () => {
+    const Module = Type.Module({
+      A: Type.Ref('B'),
+      B: Type.Ref('C'),
+      C: Type.Ref('D'),
+      D: Type.Ref('E'),
+      E: Type.Ref('F'),
+      F: Type.Ref('G'),
+      G: Type.Ref('H'),
+      H: Type.Literal('hello'),
+    })
+    const T = Module.Import('A')
+    Ok(T, 'hello')
+    Fail(T, 'world')
+  })
+})
diff --git a/test/runtime/compiler/ref.ts b/test/runtime/compiler/ref.ts
index 771a7b4f6..1cd002f80 100644
--- a/test/runtime/compiler/ref.ts
+++ b/test/runtime/compiler/ref.ts
@@ -12,7 +12,7 @@ describe('compiler/Ref', () => {
       },
       { $id: Assert.NextId() },
     )
-    const R = Type.Ref(T)
+    const R = Type.Ref(T.$id!)
     Ok(
       R,
       {
@@ -32,7 +32,7 @@ describe('compiler/Ref', () => {
       },
       { $id: Assert.NextId() },
     )
-    const R = Type.Ref(T)
+    const R = Type.Ref(T.$id!)
     Fail(
       R,
       {
@@ -54,7 +54,7 @@ describe('compiler/Ref', () => {
         x: Type.Number(),
         y: Type.Number(),
         z: Type.Number(),
-        r: Type.Optional(Type.Ref(T)),
+        r: Type.Optional(Type.Ref(T.$id!)),
       },
       { $id: 'T' },
     )
@@ -70,7 +70,7 @@ describe('compiler/Ref', () => {
         nodes: Type.Array(Node),
       }),
     )
-    const R = Type.Ref(T)
+    const R = Type.Ref(T.$id!)
     Ok(R, { id: '', nodes: [{ id: '', nodes: [] }] }, [T])
     Fail(R, { id: '', nodes: [{ id: 1, nodes: [] }] }, [T])
   })
diff --git a/test/runtime/compiler/unicode.ts b/test/runtime/compiler/unicode.ts
index 0e3e569d4..f5ef1718f 100644
--- a/test/runtime/compiler/unicode.ts
+++ b/test/runtime/compiler/unicode.ts
@@ -31,7 +31,7 @@ describe('compiler/Unicode', () => {
       },
     )
     const T = Type.Object({
-      vector: Type.Ref(R),
+      vector: Type.Ref(R.$id!),
     })
     Ok(
       T,
diff --git a/test/runtime/syntax/syntax.ts b/test/runtime/syntax/syntax.ts
index 11e28298d..ae7056752 100644
--- a/test/runtime/syntax/syntax.ts
+++ b/test/runtime/syntax/syntax.ts
@@ -1,10 +1,100 @@
 import { TypeGuard } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, TModule } from '@sinclair/typebox'
 import { Parse } from '@sinclair/typebox/syntax'
 import { Assert } from '../assert/index'
 
 // prettier-ignore
-describe('parse/Parse', () => {
+describe('syntax/Parse', () => {
+  // ----------------------------------------------------------------
+  // Type Alias
+  // ----------------------------------------------------------------
+  it('Should parse Type Alias 1', () => {
+    const T = Parse('type A = 1')
+    Assert.IsTrue(TypeGuard.IsLiteral(T.A))
+    Assert.IsTrue(T.A.const === 1)
+  })
+  it('Should parse Type Alias 2', () => {
+    const T = Parse('export type A = 1')
+    Assert.IsTrue(TypeGuard.IsLiteral(T.A))
+    Assert.IsTrue(T.A.const === 1)
+  })
+  // ----------------------------------------------------------------
+  // Interface
+  // ----------------------------------------------------------------
+  it('Should parse Interface 1', () => {
+    const T = Parse('interface A { x: 1 }')
+    Assert.IsTrue(TypeGuard.IsObject(T.A))
+    Assert.IsTrue(TypeGuard.IsLiteral(T.A.properties.x))
+    Assert.IsTrue(T.A.properties.x.const === 1)
+  })
+  it('Should parse Interface 2', () => {
+    const T = Parse('export interface A { x: 1 }')
+    Assert.IsTrue(TypeGuard.IsObject(T.A))
+    Assert.IsTrue(TypeGuard.IsLiteral(T.A.properties.x))
+    Assert.IsTrue(T.A.properties.x.const === 1)
+  })
+  // ----------------------------------------------------------------
+  // Module
+  // ----------------------------------------------------------------
+  it('Should parse Module 1', () => {
+    const T = Parse('module {}')
+    Assert.IsTrue(T instanceof TModule)
+  })
+  it('Should parse Module 2', () => {
+    const T = Parse('export module {}')
+    Assert.IsTrue(T instanceof TModule)
+  })
+  it('Should parse Module 3', () => {
+    const T = Parse('module A {}')
+    Assert.IsTrue(T instanceof TModule)
+  })
+  it('Should parse Module 4', () => {
+    const T = Parse('export module A {}')
+    Assert.IsTrue(T instanceof TModule)
+  })
+  it('Should parse Module 5', () => {
+    const T = Parse(`export module A {
+      export type A = number
+    }`)
+    const A = T.Import('A')
+    Assert.IsTrue(T instanceof TModule)
+    Assert.IsTrue(TypeGuard.IsImport(A))
+    const N = A.$defs[A.$ref]
+    Assert.IsTrue(TypeGuard.IsNumber(N))
+  })
+  it('Should parse Module 6', () => {
+    const T = Parse(`export module A {
+      export interface A { x: number }
+    }`)
+    const A = T.Import('A')
+    Assert.IsTrue(T instanceof TModule)
+    Assert.IsTrue(TypeGuard.IsImport(A))
+    const N = A.$defs[A.$ref]
+    Assert.IsTrue(TypeGuard.IsObject(N))
+    Assert.IsTrue(TypeGuard.IsNumber(N.properties.x))
+  })
+  it('Should parse Module 7', () => {
+    const T = Parse(`export module A {
+      export interface A { x: number }
+      export type B = number
+    }`)
+    // A
+    const A = T.Import('A')
+    Assert.IsTrue(T instanceof TModule)
+    Assert.IsTrue(TypeGuard.IsImport(A))
+    const N1 = A.$defs[A.$ref]
+    Assert.IsTrue(TypeGuard.IsObject(N1))
+    Assert.IsTrue(TypeGuard.IsNumber(N1.properties.x))
+    // B
+    const B = T.Import('B')
+    Assert.IsTrue(T instanceof TModule)
+    Assert.IsTrue(TypeGuard.IsImport(B))
+    const N2 = B.$defs[B.$ref]
+    Assert.IsTrue(TypeGuard.IsNumber(N2))
+  })
+  // ----------------------------------------------------------------
+  // Type Expressions
+  // ----------------------------------------------------------------
   it('Should parse Any', () => {
     const T = Parse(`any`)
     Assert.IsTrue(TypeGuard.IsAny(T))
diff --git a/test/runtime/type/guard/kind/deref.ts b/test/runtime/type/guard/kind/deref.ts
deleted file mode 100644
index 98e6811d9..000000000
--- a/test/runtime/type/guard/kind/deref.ts
+++ /dev/null
@@ -1,110 +0,0 @@
-import { KindGuard } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../../../assert/index'
-
-describe('guard/kind/TDeref', () => {
-  it('Should should deref 1', () => {
-    const T = Type.String({ $id: 'T' })
-    const R = Type.Ref(T)
-    const D = Type.Deref(R, [T])
-    Assert.IsTrue(KindGuard.IsString(D))
-    Assert.IsFalse('$id' in D)
-  })
-  it('Should should deref 2', () => {
-    const T = Type.String({ $id: 'T' })
-    const R = Type.Ref(T)
-    const O = Type.Object({
-      x: R,
-      y: R,
-    })
-    const D = Type.Deref(O, [T])
-    Assert.IsTrue(KindGuard.IsObject(D))
-    Assert.IsTrue(KindGuard.IsString(D.properties.x))
-    Assert.IsTrue(KindGuard.IsString(D.properties.y))
-    Assert.IsFalse('$id' in D.properties.x)
-    Assert.IsFalse('$id' in D.properties.y)
-  })
-  it('Should should deref 3', () => {
-    const T = Type.String({ $id: 'T' })
-    const R = Type.Ref(T)
-    const O = Type.Array(R)
-    const D = Type.Deref(O, [T])
-    Assert.IsTrue(KindGuard.IsArray(D))
-    Assert.IsTrue(KindGuard.IsString(D.items))
-    Assert.IsFalse('$id' in D.items)
-  })
-  it('Should should deref 4', () => {
-    const T = Type.String({ $id: 'T' })
-    const R = Type.Ref(T)
-    const O = Type.AsyncIterator(R)
-    const D = Type.Deref(O, [T])
-    Assert.IsTrue(KindGuard.IsAsyncIterator(D))
-    Assert.IsTrue(KindGuard.IsString(D.items))
-    Assert.IsFalse('$id' in D.items)
-  })
-  it('Should should deref 5', () => {
-    const T = Type.String({ $id: 'T' })
-    const R = Type.Ref(T)
-    const O = Type.Iterator(R)
-    const D = Type.Deref(O, [T])
-    Assert.IsTrue(KindGuard.IsIterator(D))
-    Assert.IsTrue(KindGuard.IsString(D.items))
-    Assert.IsFalse('$id' in D.items)
-  })
-  it('Should should deref 6', () => {
-    const T = Type.String({ $id: 'T' })
-    const R = Type.Ref(T)
-    const O = Type.Function([R], R)
-    const D = Type.Deref(O, [T])
-    Assert.IsTrue(KindGuard.IsFunction(D))
-    Assert.IsTrue(KindGuard.IsString(D.parameters[0]))
-    Assert.IsTrue(KindGuard.IsString(D.returns))
-    Assert.IsFalse('$id' in D.parameters[0])
-    Assert.IsFalse('$id' in D.returns)
-  })
-  it('Should should deref 7', () => {
-    const T = Type.String({ $id: 'T' })
-    const R = Type.Ref(T)
-    const O = Type.Constructor([R], R)
-    const D = Type.Deref(O, [T])
-    Assert.IsTrue(KindGuard.IsConstructor(D))
-    Assert.IsTrue(KindGuard.IsString(D.parameters[0]))
-    Assert.IsTrue(KindGuard.IsString(D.returns))
-    Assert.IsFalse('$id' in D.parameters[0])
-    Assert.IsFalse('$id' in D.returns)
-  })
-  it('Should should deref 8', () => {
-    const T = Type.String({ $id: 'T' })
-    const R = Type.Ref(T)
-    const O = Type.Promise(R)
-    const D = Type.Deref(O, [T])
-    Assert.IsTrue(KindGuard.IsPromise(D))
-    Assert.IsTrue(KindGuard.IsString(D.item))
-    Assert.IsFalse('$id' in D.item)
-  })
-  it('Should should deref 9', () => {
-    const T = Type.String({ $id: 'T' })
-    const R1 = Type.Ref(T, { $id: 'R1' })
-    const R2 = Type.Ref(R1, { $id: 'R2' })
-    const R3 = Type.Ref(R2, { $id: 'R3' })
-    const R4 = Type.Ref(R3, { $id: 'R4' })
-    const R5 = Type.Ref(R4, { $id: 'R5' })
-    const R6 = Type.Ref(R5, { $id: 'R6' })
-    const O = Type.Array(R6)
-    const D = Type.Deref(O, [R6, R5, R4, R3, R2, R1, T])
-    Assert.IsTrue(KindGuard.IsArray(D))
-    Assert.IsTrue(KindGuard.IsString(D.items))
-    Assert.IsFalse('$id' in D.items)
-  })
-  it('Should should deref 10', () => {
-    const T = Type.String({ $id: 'T' })
-    const R1 = Type.Ref(T, { $id: 'R1' })
-    const R2 = Type.Ref(R1, { $id: 'R2' })
-    const R3 = Type.Ref(R2, { $id: 'R3' })
-    const R4 = Type.Ref(R3, { $id: 'R4' })
-    const R5 = Type.Ref(R4, { $id: 'R5' })
-    const R6 = Type.Ref(R5, { $id: 'R6' })
-    const O = Type.Array(R6)
-    Assert.Throws(() => Type.Deref(O, [R6, R5, R4, R3, R2, R1])) // Omit T
-  })
-})
diff --git a/test/runtime/type/guard/kind/import.ts b/test/runtime/type/guard/kind/import.ts
new file mode 100644
index 000000000..ee430ad6d
--- /dev/null
+++ b/test/runtime/type/guard/kind/import.ts
@@ -0,0 +1,15 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/type/TImport', () => {
+  it('Should guard for TImport', () => {
+    const M = Type.Module({
+      A: Type.String(),
+    })
+    const I = M.Import('A')
+    const N = I.$defs[I.$ref]
+    Assert.IsTrue(KindGuard.IsImport(I))
+    Assert.IsTrue(KindGuard.IsString(N))
+  })
+})
diff --git a/test/runtime/type/guard/kind/index.ts b/test/runtime/type/guard/kind/index.ts
index 271b53f88..ec0073daa 100644
--- a/test/runtime/type/guard/kind/index.ts
+++ b/test/runtime/type/guard/kind/index.ts
@@ -9,11 +9,11 @@ import './composite'
 import './const'
 import './constructor'
 import './date'
-import './deref'
 import './enum'
 import './exclude'
 import './extract'
 import './function'
+import './import'
 import './indexed'
 import './integer'
 import './intersect'
diff --git a/test/runtime/type/guard/type/deref.ts b/test/runtime/type/guard/type/deref.ts
deleted file mode 100644
index 64f6d7d61..000000000
--- a/test/runtime/type/guard/type/deref.ts
+++ /dev/null
@@ -1,110 +0,0 @@
-import { TypeGuard } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
-import { Assert } from '../../../assert/index'
-
-describe('guard/type/TDeref', () => {
-  it('Should should deref 1', () => {
-    const T = Type.String({ $id: 'T' })
-    const R = Type.Ref(T)
-    const D = Type.Deref(R, [T])
-    Assert.IsTrue(TypeGuard.IsString(D))
-    Assert.IsFalse('$id' in D)
-  })
-  it('Should should deref 2', () => {
-    const T = Type.String({ $id: 'T' })
-    const R = Type.Ref(T)
-    const O = Type.Object({
-      x: R,
-      y: R,
-    })
-    const D = Type.Deref(O, [T])
-    Assert.IsTrue(TypeGuard.IsObject(D))
-    Assert.IsTrue(TypeGuard.IsString(D.properties.x))
-    Assert.IsTrue(TypeGuard.IsString(D.properties.y))
-    Assert.IsFalse('$id' in D.properties.x)
-    Assert.IsFalse('$id' in D.properties.y)
-  })
-  it('Should should deref 3', () => {
-    const T = Type.String({ $id: 'T' })
-    const R = Type.Ref(T)
-    const O = Type.Array(R)
-    const D = Type.Deref(O, [T])
-    Assert.IsTrue(TypeGuard.IsArray(D))
-    Assert.IsTrue(TypeGuard.IsString(D.items))
-    Assert.IsFalse('$id' in D.items)
-  })
-  it('Should should deref 4', () => {
-    const T = Type.String({ $id: 'T' })
-    const R = Type.Ref(T)
-    const O = Type.AsyncIterator(R)
-    const D = Type.Deref(O, [T])
-    Assert.IsTrue(TypeGuard.IsAsyncIterator(D))
-    Assert.IsTrue(TypeGuard.IsString(D.items))
-    Assert.IsFalse('$id' in D.items)
-  })
-  it('Should should deref 5', () => {
-    const T = Type.String({ $id: 'T' })
-    const R = Type.Ref(T)
-    const O = Type.Iterator(R)
-    const D = Type.Deref(O, [T])
-    Assert.IsTrue(TypeGuard.IsIterator(D))
-    Assert.IsTrue(TypeGuard.IsString(D.items))
-    Assert.IsFalse('$id' in D.items)
-  })
-  it('Should should deref 6', () => {
-    const T = Type.String({ $id: 'T' })
-    const R = Type.Ref(T)
-    const O = Type.Function([R], R)
-    const D = Type.Deref(O, [T])
-    Assert.IsTrue(TypeGuard.IsFunction(D))
-    Assert.IsTrue(TypeGuard.IsString(D.parameters[0]))
-    Assert.IsTrue(TypeGuard.IsString(D.returns))
-    Assert.IsFalse('$id' in D.parameters[0])
-    Assert.IsFalse('$id' in D.returns)
-  })
-  it('Should should deref 7', () => {
-    const T = Type.String({ $id: 'T' })
-    const R = Type.Ref(T)
-    const O = Type.Constructor([R], R)
-    const D = Type.Deref(O, [T])
-    Assert.IsTrue(TypeGuard.IsConstructor(D))
-    Assert.IsTrue(TypeGuard.IsString(D.parameters[0]))
-    Assert.IsTrue(TypeGuard.IsString(D.returns))
-    Assert.IsFalse('$id' in D.parameters[0])
-    Assert.IsFalse('$id' in D.returns)
-  })
-  it('Should should deref 8', () => {
-    const T = Type.String({ $id: 'T' })
-    const R = Type.Ref(T)
-    const O = Type.Promise(R)
-    const D = Type.Deref(O, [T])
-    Assert.IsTrue(TypeGuard.IsPromise(D))
-    Assert.IsTrue(TypeGuard.IsString(D.item))
-    Assert.IsFalse('$id' in D.item)
-  })
-  it('Should should deref 9', () => {
-    const T = Type.String({ $id: 'T' })
-    const R1 = Type.Ref(T, { $id: 'R1' })
-    const R2 = Type.Ref(R1, { $id: 'R2' })
-    const R3 = Type.Ref(R2, { $id: 'R3' })
-    const R4 = Type.Ref(R3, { $id: 'R4' })
-    const R5 = Type.Ref(R4, { $id: 'R5' })
-    const R6 = Type.Ref(R5, { $id: 'R6' })
-    const O = Type.Array(R6)
-    const D = Type.Deref(O, [R6, R5, R4, R3, R2, R1, T])
-    Assert.IsTrue(TypeGuard.IsArray(D))
-    Assert.IsTrue(TypeGuard.IsString(D.items))
-    Assert.IsFalse('$id' in D.items)
-  })
-  it('Should should deref 10', () => {
-    const T = Type.String({ $id: 'T' })
-    const R1 = Type.Ref(T, { $id: 'R1' })
-    const R2 = Type.Ref(R1, { $id: 'R2' })
-    const R3 = Type.Ref(R2, { $id: 'R3' })
-    const R4 = Type.Ref(R3, { $id: 'R4' })
-    const R5 = Type.Ref(R4, { $id: 'R5' })
-    const R6 = Type.Ref(R5, { $id: 'R6' })
-    const O = Type.Array(R6)
-    Assert.Throws(() => Type.Deref(O, [R6, R5, R4, R3, R2, R1])) // Omit T
-  })
-})
diff --git a/test/runtime/type/guard/type/import.ts b/test/runtime/type/guard/type/import.ts
new file mode 100644
index 000000000..fdce650c6
--- /dev/null
+++ b/test/runtime/type/guard/type/import.ts
@@ -0,0 +1,15 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/type/TImport', () => {
+  it('Should guard for TImport', () => {
+    const M = Type.Module({
+      A: Type.String(),
+    })
+    const I = M.Import('A')
+    const N = I.$defs[I.$ref]
+    Assert.IsTrue(TypeGuard.IsImport(I))
+    Assert.IsTrue(TypeGuard.IsString(N))
+  })
+})
diff --git a/test/runtime/type/guard/type/index.ts b/test/runtime/type/guard/type/index.ts
index 271b53f88..ec0073daa 100644
--- a/test/runtime/type/guard/type/index.ts
+++ b/test/runtime/type/guard/type/index.ts
@@ -9,11 +9,11 @@ import './composite'
 import './const'
 import './constructor'
 import './date'
-import './deref'
 import './enum'
 import './exclude'
 import './extract'
 import './function'
+import './import'
 import './indexed'
 import './integer'
 import './intersect'
diff --git a/test/runtime/type/guard/type/ref.ts b/test/runtime/type/guard/type/ref.ts
index c864cbd4f..c11b1a39c 100644
--- a/test/runtime/type/guard/type/ref.ts
+++ b/test/runtime/type/guard/type/ref.ts
@@ -5,7 +5,7 @@ import { Assert } from '../../../assert/index'
 describe('guard/type/TRef', () => {
   it('Should guard for TRef', () => {
     const T = Type.Number({ $id: 'T' })
-    const R = TypeGuard.IsRef(Type.Ref(T))
+    const R = TypeGuard.IsRef(Type.Ref('T'))
     Assert.IsTrue(R)
   })
   it('Should not guard for TRef', () => {
@@ -14,7 +14,7 @@ describe('guard/type/TRef', () => {
   })
   it('Should not guard for TRef with invalid $ref', () => {
     const T = Type.Number({ $id: 'T' })
-    const S = CloneType(Type.Ref(T))
+    const S = CloneType(Type.Ref('T'))
     // @ts-ignore
     S.$ref = 1
     const R = TypeGuard.IsRef(S)
diff --git a/test/runtime/value/cast/import.ts b/test/runtime/value/cast/import.ts
new file mode 100644
index 000000000..56a5a9236
--- /dev/null
+++ b/test/runtime/value/cast/import.ts
@@ -0,0 +1,51 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/cast/Import', () => {
+  const T = Type.Module({
+    A: Type.Number(),
+  }).Import('A')
+
+  const E = 0
+  it('Should upcast from string', () => {
+    const value = 'world'
+    const result = Value.Cast(T, value)
+    Assert.IsEqual(result, E)
+  })
+  it('Should upcast from number', () => {
+    const value = 1
+    const result = Value.Cast(T, value)
+    Assert.IsEqual(result, 1)
+  })
+  it('Should upcast from object', () => {
+    const value = {}
+    const result = Value.Cast(T, value)
+    Assert.IsEqual(result, E)
+  })
+  it('Should upcast from array', () => {
+    const value = [1]
+    const result = Value.Cast(T, value)
+    Assert.IsEqual(result, E)
+  })
+  it('Should upcast from undefined', () => {
+    const value = undefined
+    const result = Value.Cast(T, value)
+    Assert.IsEqual(result, E)
+  })
+  it('Should upcast from null', () => {
+    const value = null
+    const result = Value.Cast(T, value)
+    Assert.IsEqual(result, E)
+  })
+  it('Should upcast from date', () => {
+    const value = new Date(100)
+    const result = Value.Cast(T, value)
+    Assert.IsEqual(result, E)
+  })
+  it('Should preseve', () => {
+    const value = 123
+    const result = Value.Cast(T, value)
+    Assert.IsEqual(result, 123)
+  })
+})
diff --git a/test/runtime/value/cast/index.ts b/test/runtime/value/cast/index.ts
index 911bd9f17..0016139b8 100644
--- a/test/runtime/value/cast/index.ts
+++ b/test/runtime/value/cast/index.ts
@@ -6,6 +6,7 @@ import './boolean'
 import './composite'
 import './date'
 import './enum'
+import './import'
 import './integer'
 import './intersect'
 import './iterator'
diff --git a/test/runtime/value/cast/union.ts b/test/runtime/value/cast/union.ts
index d9ae73020..96b159cdc 100644
--- a/test/runtime/value/cast/union.ts
+++ b/test/runtime/value/cast/union.ts
@@ -153,7 +153,7 @@ describe('value/cast/Union', () => {
     const A = Type.Object({ type: Type.Literal('A') }, { $id: 'A' })
     const B = Type.Object({ type: Type.Literal('B'), value: Type.Number() }, { $id: 'B' })
     const RA = Type.Union([A, B])
-    const RB = Type.Union([Type.Ref(A), Type.Ref(B)])
+    const RB = Type.Union([Type.Ref('A'), Type.Ref('B')])
     // variant 0
     Assert.IsEqual(Value.Cast(RA, [A, B], { type: 'B' }), { type: 'B', value: 0 })
     Assert.IsEqual(Value.Cast(RB, [A, B], { type: 'B' }), { type: 'B', value: 0 })
diff --git a/test/runtime/value/check/index.ts b/test/runtime/value/check/index.ts
index 9012725f2..27bda1e41 100644
--- a/test/runtime/value/check/index.ts
+++ b/test/runtime/value/check/index.ts
@@ -15,6 +15,7 @@ import './iterator'
 import './keyof'
 import './kind'
 import './literal'
+import './module'
 import './never'
 import './not'
 import './null'
diff --git a/test/runtime/value/check/module.ts b/test/runtime/value/check/module.ts
new file mode 100644
index 000000000..3a64267de
--- /dev/null
+++ b/test/runtime/value/check/module.ts
@@ -0,0 +1,80 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert'
+
+describe('value/check/Module', () => {
+  it('Should validate string', () => {
+    const Module = Type.Module({
+      A: Type.String(),
+    })
+    const T = Module.Import('A')
+    Assert.IsTrue(Value.Check(T, 'hello'))
+    Assert.IsFalse(Value.Check(T, true))
+  })
+  it('Should validate referenced string', () => {
+    const Module = Type.Module({
+      A: Type.String(),
+      B: Type.Ref('A'),
+    })
+    const T = Module.Import('B')
+    Assert.IsTrue(Value.Check(T, 'hello'))
+    Assert.IsFalse(Value.Check(T, true))
+  })
+  it('Should validate self referential', () => {
+    const Module = Type.Module({
+      A: Type.Object({
+        nodes: Type.Array(Type.Ref('A')),
+      }),
+    })
+    const T = Module.Import('A')
+    Assert.IsTrue(Value.Check(T, { nodes: [{ nodes: [{ nodes: [] }, { nodes: [] }] }] }))
+    Assert.IsFalse(Value.Check(T, { nodes: [{ nodes: [{ nodes: [] }, { nodes: false }] }] }))
+    Assert.IsFalse(Value.Check(T, true))
+  })
+  it('Should validate mutual recursive', () => {
+    const Module = Type.Module({
+      A: Type.Object({
+        b: Type.Ref('B'),
+      }),
+      B: Type.Object({
+        a: Type.Union([Type.Ref('A'), Type.Null()]),
+      }),
+    })
+    const T = Module.Import('A')
+    Assert.IsTrue(Value.Check(T, { b: { a: null } }))
+    Assert.IsTrue(Value.Check(T, { b: { a: { b: { a: null } } } }))
+
+    Assert.IsFalse(Value.Check(T, { b: { a: 1 } }))
+    Assert.IsFalse(Value.Check(T, { b: { a: { b: { a: 1 } } } }))
+    Assert.IsFalse(Value.Check(T, true))
+  })
+  it('Should validate mutual recursive (Array)', () => {
+    const Module = Type.Module({
+      A: Type.Object({
+        b: Type.Ref('B'),
+      }),
+      B: Type.Object({
+        a: Type.Array(Type.Ref('A')),
+      }),
+    })
+    const T = Module.Import('A')
+    Assert.IsTrue(Value.Check(T, { b: { a: [{ b: { a: [] } }] } }))
+    Assert.IsFalse(Value.Check(T, { b: { a: [{ b: { a: [null] } }] } }))
+    Assert.IsFalse(Value.Check(T, true))
+  })
+  it('Should validate deep referential', () => {
+    const Module = Type.Module({
+      A: Type.Ref('B'),
+      B: Type.Ref('C'),
+      C: Type.Ref('D'),
+      D: Type.Ref('E'),
+      E: Type.Ref('F'),
+      F: Type.Ref('G'),
+      G: Type.Ref('H'),
+      H: Type.Literal('hello'),
+    })
+    const T = Module.Import('A')
+    Assert.IsTrue(Value.Check(T, 'hello'))
+    Assert.IsFalse(Value.Check(T, 'world'))
+  })
+})
diff --git a/test/runtime/value/check/ref.ts b/test/runtime/value/check/ref.ts
index cc541149d..20156eb8d 100644
--- a/test/runtime/value/check/ref.ts
+++ b/test/runtime/value/check/ref.ts
@@ -12,7 +12,7 @@ describe('value/check/Ref', () => {
       },
       { $id: Assert.NextId() },
     )
-    const R = Type.Ref(T)
+    const R = Type.Ref(T.$id!)
     Assert.IsEqual(
       Value.Check(R, [T], {
         x: 1,
@@ -32,7 +32,7 @@ describe('value/check/Ref', () => {
       },
       { $id: Assert.NextId() },
     )
-    const R = Type.Ref(T)
+    const R = Type.Ref(T.$id!)
     Assert.IsEqual(
       Value.Check(R, [T], {
         x: 1,
@@ -55,7 +55,7 @@ describe('value/check/Ref', () => {
         x: Type.Number(),
         y: Type.Number(),
         z: Type.Number(),
-        r: Type.Optional(Type.Ref(T)),
+        r: Type.Optional(Type.Ref(T.$id!)),
       },
       { $id: 'T' },
     )
@@ -76,7 +76,7 @@ describe('value/check/Ref', () => {
         nodes: Type.Array(Node),
       }),
     )
-    const R = Type.Ref(T)
+    const R = Type.Ref(T.$id!)
     Assert.IsEqual(Value.Check(R, [T], { id: '', nodes: [{ id: '', nodes: [] }] }), true)
     Assert.IsEqual(Value.Check(R, [T], { id: '', nodes: [{ id: 1, nodes: [] }] }), false)
   })
diff --git a/test/runtime/value/clean/import.ts b/test/runtime/value/clean/import.ts
new file mode 100644
index 000000000..1ccc7c81d
--- /dev/null
+++ b/test/runtime/value/clean/import.ts
@@ -0,0 +1,203 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/clean/Import', () => {
+  // ----------------------------------------------------------------
+  // Clean
+  // ----------------------------------------------------------------
+  it('Should clean 1', () => {
+    const T = Type.Module({ A: Type.Object({ x: Type.Number() }) }).Import('A')
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean 2', () => {
+    const T = Type.Module({ A: Type.Object({ x: Type.Number() }) }).Import('A')
+    const R = Value.Clean(T, {})
+    Assert.IsEqual(R, {})
+  })
+  it('Should clean 3', () => {
+    const T = Type.Module({ A: Type.Object({ x: Type.Number() }) }).Import('A')
+    const R = Value.Clean(T, { x: 1 })
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should clean 4', () => {
+    const T = Type.Module({ A: Type.Object({ x: Type.Number() }) }).Import('A')
+    const R = Value.Clean(T, { x: null })
+    Assert.IsEqual(R, { x: null })
+  })
+  // ----------------------------------------------------------------
+  // Nested
+  // ----------------------------------------------------------------
+  it('Should clean nested 1', () => {
+    const T = Type.Module({
+      A: Type.Object({
+        x: Type.Object({
+          y: Type.Number(),
+        }),
+      }),
+    }).Import('A')
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean nested 2', () => {
+    const T = Type.Module({
+      A: Type.Object({
+        x: Type.Object({
+          y: Type.Number(),
+        }),
+      }),
+    }).Import('A')
+    const R = Value.Clean(T, {})
+    Assert.IsEqual(R, {})
+  })
+  it('Should clean nested 3', () => {
+    const T = Type.Module({
+      A: Type.Object({
+        x: Type.Object({
+          y: Type.Number(),
+        }),
+      }),
+    }).Import('A')
+
+    const R = Value.Clean(T, { x: null })
+    Assert.IsEqual(R, { x: null })
+  })
+  it('Should clean nested 4', () => {
+    const T = Type.Module({
+      A: Type.Object({
+        x: Type.Object({
+          y: Type.Number(),
+        }),
+      }),
+    }).Import('A')
+    const R = Value.Clean(T, { x: { y: null } })
+    Assert.IsEqual(R, { x: { y: null } })
+  })
+  // ----------------------------------------------------------------
+  // Additional Properties
+  // ----------------------------------------------------------------
+  it('Should clean additional properties 1', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        {
+          additionalProperties: Type.String(),
+        },
+      ),
+    }).Import('A')
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean additional properties 2', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        {
+          additionalProperties: Type.String(),
+        },
+      ),
+    }).Import('A')
+    const R = Value.Clean(T, {})
+    Assert.IsEqual(R, {})
+  })
+  it('Should clean additional properties 3', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        {
+          additionalProperties: Type.String(),
+        },
+      ),
+    }).Import('A')
+    const R = Value.Clean(T, { x: 1 })
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should clean additional properties 4', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        {
+          additionalProperties: Type.String(),
+        },
+      ),
+    }).Import('A')
+    const R = Value.Clean(T, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  // ----------------------------------------------------------------
+  // Additional Properties Discard
+  // ----------------------------------------------------------------
+  it('Should clean additional properties discard 1', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        {
+          additionalProperties: Type.String(),
+        },
+      ),
+    }).Import('A')
+    const R = Value.Clean(T, null)
+    Assert.IsEqual(R, null)
+  })
+  it('Should clean additional properties discard 2', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        {
+          additionalProperties: Type.String(),
+        },
+      ),
+    }).Import('A')
+    const R = Value.Clean(T, { k: '', d: null })
+    Assert.IsEqual(R, { k: '' })
+  })
+  it('Should clean additional properties discard 3', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        {
+          additionalProperties: Type.String(),
+        },
+      ),
+    }).Import('A')
+    const R = Value.Clean(T, { k: '', d: null, x: 1 })
+    Assert.IsEqual(R, { k: '', x: 1 })
+  })
+  it('Should clean additional properties discard 4', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        {
+          additionalProperties: Type.String(),
+        },
+      ),
+    }).Import('A')
+    const R = Value.Clean(T, { k: '', d: null, x: 1, y: 2 })
+    Assert.IsEqual(R, { k: '', x: 1, y: 2 })
+  })
+})
diff --git a/test/runtime/value/clean/index.ts b/test/runtime/value/clean/index.ts
index b290dd224..99af15b9c 100644
--- a/test/runtime/value/clean/index.ts
+++ b/test/runtime/value/clean/index.ts
@@ -8,6 +8,7 @@ import './constructor'
 import './date'
 import './enum'
 import './function'
+import './import'
 import './integer'
 import './intersect'
 import './iterator'
diff --git a/test/runtime/value/convert/import.ts b/test/runtime/value/convert/import.ts
new file mode 100644
index 000000000..f22c506b2
--- /dev/null
+++ b/test/runtime/value/convert/import.ts
@@ -0,0 +1,29 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+// prettier-ignore
+describe('value/convert/Import', () => {
+  it('Should convert properties', () => {
+    const T = Type.Module({ A: Type.Object({
+      x: Type.Number(),
+      y: Type.Boolean(),
+      z: Type.Boolean()
+    })}).Import('A')
+    const R = Value.Convert(T, { x: '42', y: 'true', z: 'hello' })
+    Assert.IsEqual(R, { x: 42, y: true, z: 'hello' })
+  })
+  it('Should convert known properties', () => {
+    const T = Type.Module({ A: Type.Object({
+      x: Type.Number(),
+      y: Type.Boolean()
+    })}).Import('A')
+    const R = Value.Convert(T, { x: '42', y: 'true', z: 'hello' })
+    Assert.IsEqual(R, { x: 42, y: true, z: 'hello' })
+  })
+  it('Should not convert missing properties', () => {
+    const T = Type.Module({ A: Type.Object({ x: Type.Number() }) }).Import('A')
+    const R = Value.Convert(T, { })
+    Assert.IsEqual(R, { })
+  })
+})
diff --git a/test/runtime/value/convert/index.ts b/test/runtime/value/convert/index.ts
index ec3e1b6e8..fe5f47fd7 100644
--- a/test/runtime/value/convert/index.ts
+++ b/test/runtime/value/convert/index.ts
@@ -9,6 +9,7 @@ import './kind'
 import './date'
 import './enum'
 import './function'
+import './import'
 import './integer'
 import './intersect'
 import './iterator'
diff --git a/test/runtime/value/create/import.ts b/test/runtime/value/create/import.ts
new file mode 100644
index 000000000..b07f96dfa
--- /dev/null
+++ b/test/runtime/value/create/import.ts
@@ -0,0 +1,98 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Import', () => {
+  it('Should create value', () => {
+    const T = Type.Module({
+      A: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+      }),
+    }).Import('A')
+    Assert.IsEqual(Value.Create(T), {
+      x: 0,
+      y: 0,
+      z: 0,
+    })
+  })
+  it('Should create value with optional properties', () => {
+    const T = Type.Module({
+      A: Type.Object({
+        x: Type.Optional(Type.Number()),
+        y: Type.Optional(Type.Number()),
+        z: Type.Optional(Type.Number()),
+      }),
+    }).Import('A')
+    Assert.IsEqual(Value.Create(T), {})
+  })
+  it('Should create default with default properties', () => {
+    const T = Type.Module({
+      A: Type.Object({
+        x: Type.Number({ default: 1 }),
+        y: Type.Number({ default: 2 }),
+        z: Type.Number({ default: 3 }),
+      }),
+    }).Import('A')
+    Assert.IsEqual(Value.Create(T), {
+      x: 1,
+      y: 2,
+      z: 3,
+    })
+  })
+  it('Should create nested object', () => {
+    const T = Type.Module({
+      A: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number(),
+        w: Type.Object({
+          x: Type.Number({ default: 7 }),
+          y: Type.Number(),
+          z: Type.Number(),
+        }),
+      }),
+    }).Import('A')
+    Assert.IsEqual(Value.Create(T), {
+      x: 0,
+      y: 0,
+      z: 0,
+      w: { x: 7, y: 0, z: 0 },
+    })
+  })
+  it('Should create with default', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+          z: Type.Number(),
+        },
+        { default: { x: 1, y: 2, z: 3 } },
+      ),
+    }).Import('A')
+    Assert.IsEqual(Value.Create(T), {
+      x: 1,
+      y: 2,
+      z: 3,
+    })
+  })
+  // ----------------------------------------------------------------
+  // Mutation
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/726
+  it('Should clone defaults on assignment - no mutation', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Number(),
+        },
+        { default: { x: 1 } },
+      ),
+    }).Import('A')
+    const V = Value.Create(T)
+    V.x = 123
+    Assert.IsEqual(T.$defs.A.default, { x: 1 })
+  })
+})
diff --git a/test/runtime/value/create/index.ts b/test/runtime/value/create/index.ts
index 222f79342..9962a44f0 100644
--- a/test/runtime/value/create/index.ts
+++ b/test/runtime/value/create/index.ts
@@ -9,6 +9,7 @@ import './constructor'
 import './date'
 import './enum'
 import './function'
+import './import'
 import './integer'
 import './intersect'
 import './iterator'
diff --git a/test/runtime/value/create/ref.ts b/test/runtime/value/create/ref.ts
index ce3d9d155..07142c1a2 100644
--- a/test/runtime/value/create/ref.ts
+++ b/test/runtime/value/create/ref.ts
@@ -12,7 +12,7 @@ describe('value/create/Ref', () => {
       },
       { $id: 'T', default: 'target' },
     )
-    const R = Type.Ref(T)
+    const R = Type.Ref('T')
     Assert.Throws(() => Value.Create(R))
   })
   it('Should create ref default if ref default is defined', () => {
@@ -24,12 +24,12 @@ describe('value/create/Ref', () => {
       },
       { $id: 'T', default: 'target' },
     )
-    const R = Type.Ref(T, { default: 'override' })
+    const R = Type.Ref('T', { default: 'override' })
     Assert.IsEqual(Value.Create(R), 'override') // terminated at R default value
   })
   it('Should dereference remote schema via $ref', () => {
-    const R = Type.Number({ $id: 'S' })
-    const T = Type.Object({ x: Type.Ref(R) })
+    const R = Type.Number({ $id: 'R' })
+    const T = Type.Object({ x: Type.Ref('R') })
     Assert.IsEqual(Value.Create(T, [R]), { x: 0 })
   })
 })
diff --git a/test/runtime/value/default/import.ts b/test/runtime/value/default/import.ts
new file mode 100644
index 000000000..42ae35672
--- /dev/null
+++ b/test/runtime/value/default/import.ts
@@ -0,0 +1,299 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type, CloneType } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/default/Import', () => {
+  it('Should use default', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        { default: 1 },
+      ),
+    }).Import('A')
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, 1)
+  })
+  it('Should use value', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Number(),
+          y: Type.Number(),
+        },
+        { default: 1 },
+      ),
+    }).Import('A')
+    const R = Value.Default(T, null)
+    Assert.IsEqual(R, null)
+  })
+  // ----------------------------------------------------------------
+  // Construction
+  // ----------------------------------------------------------------
+  it('Should should fully construct object 1', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Object(
+            {
+              x: Type.Number({ default: 1 }),
+              y: Type.Number({ default: 2 }),
+            },
+            { default: {} },
+          ),
+          y: Type.Object(
+            {
+              x: Type.Number({ default: 3 }),
+              y: Type.Number({ default: 4 }),
+            },
+            { default: {} },
+          ),
+        },
+        { default: {} },
+      ),
+    }).Import('A')
+    const R = Value.Default(T, undefined)
+    Assert.IsEqual(R, { x: { x: 1, y: 2 }, y: { x: 3, y: 4 } })
+  })
+  it('Should should fully construct object 2', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Object(
+            {
+              x: Type.Number({ default: 1 }),
+              y: Type.Number({ default: 2 }),
+            },
+            { default: {} },
+          ),
+          y: Type.Object(
+            {
+              x: Type.Number({ default: 3 }),
+              y: Type.Number({ default: 4 }),
+            },
+            { default: {} },
+          ),
+        },
+        { default: {} },
+      ),
+    }).Import('A')
+    const R = Value.Default(T, { x: null })
+    Assert.IsEqual(R, { x: null, y: { x: 3, y: 4 } })
+  })
+  it('Should should fully construct object 3', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Object(
+            {
+              x: Type.Number({ default: 1 }),
+              y: Type.Number({ default: 2 }),
+            },
+            { default: {} },
+          ),
+          y: Type.Object(
+            {
+              x: Type.Number({ default: 3 }),
+              y: Type.Number({ default: 4 }),
+            },
+            { default: {} },
+          ),
+        },
+        { default: {} },
+      ),
+    }).Import('A')
+    const R = Value.Default(T, { x: { x: null, y: null } })
+    Assert.IsEqual(R, { x: { x: null, y: null }, y: { x: 3, y: 4 } })
+  })
+  // ----------------------------------------------------------------
+  // Properties
+  // ----------------------------------------------------------------
+  it('Should use property defaults 1', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Number({ default: 1 }),
+          y: Type.Number({ default: 2 }),
+        },
+        { default: 1 },
+      ),
+    }).Import('A')
+    const R = Value.Default(T, {})
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should use property defaults 2', () => {
+    const T = Type.Module({
+      A: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+      }),
+    }).Import('A')
+    const R = Value.Default(T, {})
+    Assert.IsEqual(R, {})
+  })
+  it('Should use property defaults 3', () => {
+    const T = Type.Module({
+      A: Type.Object({
+        x: Type.Number({ default: 1 }),
+        y: Type.Number(),
+      }),
+    }).Import('A')
+    const R = Value.Default(T, {})
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should use property defaults 4', () => {
+    const T = Type.Module({
+      A: Type.Object({
+        x: Type.Number({ default: 1 }),
+        y: Type.Number(),
+      }),
+    }).Import('A')
+    const R = Value.Default(T, { x: 3 })
+    Assert.IsEqual(R, { x: 3 })
+  })
+  // ----------------------------------------------------------------
+  // AdditionalProperties
+  // ----------------------------------------------------------------
+  it('Should use additional property defaults 1', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Number({ default: 1 }),
+          y: Type.Number({ default: 2 }),
+        },
+        {
+          additionalProperties: Type.Number({ default: 3 }),
+        },
+      ),
+    }).Import('A')
+    const R = Value.Default(T, {})
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should use additional property defaults 2', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Number({ default: 1 }),
+          y: Type.Number({ default: 2 }),
+        },
+        {
+          additionalProperties: Type.Number({ default: 3 }),
+        },
+      ),
+    }).Import('A')
+    const R = Value.Default(T, { x: null, y: null, z: undefined })
+    Assert.IsEqual(R, { x: null, y: null, z: 3 })
+  })
+  it('Should use additional property defaults 3', () => {
+    const T = Type.Module({
+      A: Type.Object(
+        {
+          x: Type.Number({ default: 1 }),
+          y: Type.Number({ default: 2 }),
+        },
+        {
+          additionalProperties: Type.Number(),
+        },
+      ),
+    }).Import('A')
+    const R = Value.Default(T, { x: null, y: null, z: undefined })
+    Assert.IsEqual(R, { x: null, y: null, z: undefined })
+  })
+  // ----------------------------------------------------------------
+  // Mutation
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/726
+  it('Should retain defaults on operation', () => {
+    const A = Type.Module({
+      A: Type.Object({
+        a: Type.Object(
+          {
+            b: Type.Array(Type.String(), { default: [] }),
+          },
+          { default: {} },
+        ),
+      }),
+    }).Import('A')
+    const value = Value.Default(A, {})
+    Assert.IsEqual(value, { a: { b: [] } })
+    Assert.IsEqual(A.$defs.A.properties.a.default, {})
+    Assert.IsEqual(A.$defs.A.properties.a.properties.b.default, [])
+  })
+  // https://github.com/sinclairzx81/typebox/issues/726
+  it('Should retain schematics on operation', () => {
+    const A = Type.Module({
+      A: Type.Object({
+        a: Type.Object(
+          {
+            b: Type.Array(Type.String(), { default: [] }),
+          },
+          { default: {} },
+        ),
+      }),
+    }).Import('A')
+    const B = CloneType(A)
+    Value.Default(A, {})
+    Assert.IsEqual(A, B)
+  })
+  // ----------------------------------------------------------------
+  // Traveral: https://github.com/sinclairzx81/typebox/issues/962
+  // ----------------------------------------------------------------
+  it('Should traverse into an object 1 (initialize)', () => {
+    const M = Type.Module({
+      Y: Type.Object({ y: Type.String({ default: 'y' }) }),
+      X: Type.Object({ x: Type.Ref('Y') }),
+    })
+    const Y = M.Import('Y')
+    const X = M.Import('X')
+    Assert.IsEqual(Value.Default(Y, {}), { y: 'y' })
+    Assert.IsEqual(Value.Default(X, { x: {} }), { x: { y: 'y' } })
+  })
+  it('Should traverse into an object 2 (retain)', () => {
+    const M = Type.Module({
+      Y: Type.Object({ y: Type.String({ default: 'y' }) }),
+      X: Type.Object({ x: Type.Ref('Y') }),
+    })
+    const Y = M.Import('Y')
+    const X = M.Import('X')
+    Assert.IsEqual(Value.Default(X, { x: { y: 1 } }), { x: { y: 1 } })
+  })
+  it('Should traverse into an object 3 (ignore on undefined)', () => {
+    const M = Type.Module({
+      Y: Type.Object({ y: Type.String({ default: 'y' }) }),
+      X: Type.Object({ x: Type.Ref('Y') }),
+    })
+    const Y = M.Import('Y')
+    const X = M.Import('X')
+    Assert.IsEqual(Value.Default(X, { x: undefined }), { x: undefined })
+  })
+  // ----------------------------------------------------------------
+  // Exterior Object Defaults
+  // ----------------------------------------------------------------
+  it('Should default exterior into an object 1', () => {
+    const X = Type.Module({ A: Type.Object({ x: Type.String({ default: 1 }) }, { default: {} }) }).Import('A')
+    const R = Value.Default(X, undefined)
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should default exterior into an object 2', () => {
+    const X = Type.Module({ A: Type.Object({ x: Type.String({ default: 1 }) }, { default: {} }) }).Import('A')
+    const R = Value.Default(X, {})
+    Assert.IsEqual(R, { x: 1 })
+  })
+  it('Should default exterior into an object 3', () => {
+    const X = Type.Module({ A: Type.Object({ x: Type.String({ default: 1 }) }, { default: {} }) }).Import('A')
+    const R = Value.Default(X, { y: 3 })
+    Assert.IsEqual(R, { y: 3, x: 1 })
+  })
+  it('Should default exterior into an object 4', () => {
+    const X = Type.Module({ A: Type.Object({ x: Type.String({ default: 1 }) }, { default: {} }) }).Import('A')
+    const R = Value.Default(X, { y: 3, x: 7 })
+    Assert.IsEqual(R, { y: 3, x: 7 })
+  })
+  it('Should default exterior into an object 5', () => {
+    const X = Type.Module({ A: Type.Object({ x: Type.String({ default: 1 }) }, { default: {} }) }).Import('A')
+    const R = Value.Default(X, { x: 2 })
+    Assert.IsEqual(R, { x: 2 })
+  })
+})
diff --git a/test/runtime/value/default/index.ts b/test/runtime/value/default/index.ts
index e553311b7..fd703993c 100644
--- a/test/runtime/value/default/index.ts
+++ b/test/runtime/value/default/index.ts
@@ -9,6 +9,7 @@ import './constructor'
 import './date'
 import './enum'
 import './function'
+import './import'
 import './integer'
 import './intersect'
 import './iterator'
diff --git a/test/runtime/value/transform/import.ts b/test/runtime/value/transform/import.ts
new file mode 100644
index 000000000..a8646dcfc
--- /dev/null
+++ b/test/runtime/value/transform/import.ts
@@ -0,0 +1,157 @@
+import * as Encoder from './_encoder'
+import { Assert } from '../../assert'
+
+import { TypeSystemPolicy } from '@sinclair/typebox/system'
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+
+// prettier-ignore
+describe('value/transform/Import', () => {
+  // --------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------
+  const T0 = Type.Transform(
+    Type.Module({ A: Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    })}).Import('A'),
+  )
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode identity', () => {
+    const R = Encoder.Decode(T0, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should encode identity', () => {
+    const R = Encoder.Encode(T0, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should throw on identity decode', () => {
+    Assert.Throws(() => Encoder.Decode(T0, undefined))
+  })
+  // ----------------------------------------------------------
+  // Object
+  // ----------------------------------------------------------
+  const T1 = Type.Transform(
+    Type.Module({ A: Type.Object({
+      x: Type.Number(),
+      y: Type.Number(),
+    })}).Import('A'),
+  )
+    .Decode((value) => 42)
+    .Encode((value) => ({ x: 1, y: 2 }))
+  it('Should decode mapped', () => {
+    const R = Encoder.Decode(T1, { x: 1, y: 2 })
+    Assert.IsEqual(R, 42)
+  })
+  it('Should encode mapped', () => {
+    const R = Encoder.Encode(T1, null)
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should throw on mapped decode', () => {
+    Assert.Throws(() => Encoder.Decode(T1, undefined))
+  })
+  // ----------------------------------------------------------
+  // Object: Transform Property
+  // ----------------------------------------------------------
+  const N2 = Type.Transform(Type.Module({ A: Type.Integer() }).Import('A'))
+    .Decode((value) => value.toString())
+    .Encode((value) => parseInt(value))
+  const T2 = Type.Object({
+    x: N2,
+    y: N2,
+  })
+  it('Should decode transform property', () => {
+    const R = Encoder.Decode(T2, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: '1', y: '2' })
+  })
+  it('Should encode transform property', () => {
+    const R = Encoder.Encode(T2, { x: '1', y: '2' })
+    Assert.IsEqual(R, { x: 1, y: 2 })
+  })
+  it('Should throw on decode transform property', () => {
+    Assert.Throws(() => Encoder.Decode(T2, undefined))
+  })
+  // ----------------------------------------------------------
+  // Object: Transform Property Nested (Twizzle)
+  // ----------------------------------------------------------
+  const N3 = Type.Transform(Type.Module({ A: Type.Integer() }).Import('A'))
+    .Decode((value) => value.toString())
+    .Encode((value) => parseInt(value))
+  const T3 = Type.Transform(
+    Type.Object({
+      x: N3,
+      y: N3,
+    }),
+  )
+    .Decode((value) => ({ x: value.y, y: value.x }))
+    .Encode((value) => ({ x: value.y, y: value.x }))
+  it('Should decode transform property nested', () => {
+    const R = Encoder.Decode(T3, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: '2', y: '1' })
+  })
+  it('Should encode transform property nested', () => {
+    const R = Encoder.Encode(T3, { x: '1', y: '2' })
+    Assert.IsEqual(R, { x: 2, y: 1 })
+  })
+  it('Should throw on decode transform property nested', () => {
+    Assert.Throws(() => Encoder.Decode(T3, undefined))
+  })
+  // ----------------------------------------------------------
+  // Object Additional Properties
+  // ----------------------------------------------------------
+  const N4 = Type.Transform(Type.Module({ A: Type.Integer() }).Import('A'))
+    .Decode((value) => value.toString())
+    .Encode((value) => parseInt(value))
+  const T4 = Type.Transform(
+    Type.Object(
+      {
+        x: Type.Number(),
+      },
+      {
+        additionalProperties: N4,
+      },
+    ),
+  )
+    .Decode((value) => value)
+    .Encode((value) => value)
+  it('Should decode additional property', () => {
+    const R = Encoder.Decode(T4, { x: 1, y: 2 })
+    Assert.IsEqual(R, { x: 1, y: '2' })
+  })
+  it('Should encode additional property', () => {
+    const R = Encoder.Encode(T4, { x: 1, y: '5' })
+    Assert.IsEqual(R, { x: 1, y: 5 })
+  })
+  it('Should throw on additional property 1', () => {
+    Assert.Throws(() => Encoder.Decode(T4, undefined))
+  })
+  it('Should throw on additional property 2', () => {
+    Assert.Throws(() => Encoder.Decode(T4, { x: 1, y: true }))
+  })
+  // ------------------------------------------------------------
+  // Map
+  // ------------------------------------------------------------
+  const T5 = Type.Transform(Type.Module({ A: Type.Object({ x: Type.String(), y: Type.String() })}).Import('A'))
+    .Decode((value) => new Map(Object.entries(value)))
+    .Encode((value) => Object.fromEntries(value.entries()) as any)
+  it('should decode map', () => {
+    const R = Encoder.Decode(T5, { x: 'hello', y: 'world' })
+    Assert.IsInstanceOf(R, Map)
+    Assert.IsEqual(R.get('x'), 'hello')
+    Assert.IsEqual(R.get('y'), 'world')
+  })
+  it('should encode map', () => {
+    const R = Encoder.Encode(
+      T5,
+      new Map([
+        ['x', 'hello'],
+        ['y', 'world'],
+      ]),
+    )
+    Assert.IsEqual(R, { x: 'hello', y: 'world' })
+  })
+  it('Should throw on map decode', () => {
+    Assert.Throws(() => Encoder.Decode(T5, {}))
+  })
+})
diff --git a/test/runtime/value/transform/index.ts b/test/runtime/value/transform/index.ts
index bc4fb931a..ff005d5f5 100644
--- a/test/runtime/value/transform/index.ts
+++ b/test/runtime/value/transform/index.ts
@@ -8,6 +8,7 @@ import './constructor'
 import './date'
 import './enum'
 import './function'
+import './import'
 import './integer'
 import './intersect'
 import './iterator'
diff --git a/test/runtime/value/transform/ref.ts b/test/runtime/value/transform/ref.ts
index 92d252c29..39113f41b 100644
--- a/test/runtime/value/transform/ref.ts
+++ b/test/runtime/value/transform/ref.ts
@@ -8,7 +8,7 @@ describe('value/transform/Ref', () => {
   // Identity
   // --------------------------------------------------------
   const N0 = Type.Number({ $id: 'N0' })
-  const T0 = Type.Transform(Type.Ref(N0))
+  const T0 = Type.Transform(Type.Ref('N0'))
     .Decode((value) => value)
     .Encode((value) => value)
   it('Should decode mapped', () => {
@@ -26,7 +26,7 @@ describe('value/transform/Ref', () => {
   // Mapped
   // --------------------------------------------------------
   const N1 = Type.Number({ $id: 'N1' })
-  const T1 = Type.Transform(Type.Ref(N1))
+  const T1 = Type.Transform(Type.Unsafe<number>(Type.Ref('N1')))
     .Decode((value) => value + 1)
     .Encode((value) => value - 1)
   it('Should decode mapped', () => {
@@ -46,7 +46,7 @@ describe('value/transform/Ref', () => {
   const N2 = Type.Transform(Type.Number({ $id: 'N2' }))
     .Decode((value) => value + 1)
     .Encode((value) => value - 1)
-  const T2 = Type.Transform(Type.Ref(N2))
+  const T2 = Type.Transform(Type.Unsafe<number>(Type.Ref('N2')))
     .Decode((value) => value + 1)
     .Encode((value) => value - 1)
   it('Should decode mapped remote', () => {
diff --git a/test/static/deref.ts b/test/static/deref.ts
deleted file mode 100644
index 4df0737ef..000000000
--- a/test/static/deref.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import { Expect } from './assert'
-import { Type, TRef, TObject, TNumber } from '@sinclair/typebox'
-
-// prettier-ignore
-const Vector: TObject<{
-  x: TNumber;
-  y: TNumber;
-}> = Type.Object({
-  x: Type.Number(),
-  y: Type.Number(),
-}, { $id: 'Vector' })
-
-// prettier-ignore
-const VectorRef: TRef<TObject<{
-  x: TNumber;
-  y: TNumber;
-}>> = Type.Ref(Vector)
-
-// prettier-ignore
-const Vertex: TObject<{
-  position: TRef<TObject<{
-      x: TNumber;
-      y: TNumber;
-  }>>;
-  texcoord: TRef<TObject<{
-      x: TNumber;
-      y: TNumber;
-  }>>;
-}> = Type.Object({
-  position: VectorRef,
-  texcoord: VectorRef,
-})
-
-// prettier-ignore
-const VertexDeref: TObject<{
-  position: TObject<{
-      x: TNumber;
-      y: TNumber;
-  }>;
-  texcoord: TObject<{
-      x: TNumber;
-      y: TNumber;
-  }>;
-}> = Type.Deref(Vertex, [Vector])
-
-// prettier-ignore
-Expect(VertexDeref).ToStatic<{
-  position: {
-      x: number;
-      y: number;
-  };
-  texcoord: {
-      x: number;
-      y: number;
-  };
-}>
diff --git a/test/static/ref.ts b/test/static/ref.ts
index 47ccd9b29..76aca672b 100644
--- a/test/static/ref.ts
+++ b/test/static/ref.ts
@@ -3,11 +3,11 @@ import { Type, Static } from '@sinclair/typebox'
 
 {
   const T = Type.String({ $id: 'T' })
-  const R = Type.Ref(T)
+  const R = Type.Ref('T')
 
   type T = Static<typeof T>
   type R = Static<typeof R>
 
   Expect(T).ToStatic<string>()
-  Expect(R).ToStatic<string>()
+  Expect(R).ToStatic<unknown>()
 }

From 53c3d7547a0c31fdb67c16896155bdfb48db1b7d Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Thu, 14 Nov 2024 00:38:04 +0900
Subject: [PATCH 304/369] Documentation

---
 readme.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/readme.md b/readme.md
index 39fd65056..3adeae926 100644
--- a/readme.md
+++ b/readme.md
@@ -4,7 +4,7 @@
 
 <p>Json Schema Type Builder with Static Type Resolution for TypeScript</p>
 
-<img src="https://github.com/sinclairzx81/typebox/blob/master/typebox.png?raw=true" />
+<img src="https://raw.githubusercontent.com/sinclairzx81/typebox/refs/heads/master/typebox.png" />
 
 <br />
 <br />
@@ -777,7 +777,8 @@ type T = Static<typeof T>                            // type T = string | null
 TypeBox Modules are containers for related types. They function as namespaces and enable internal types to reference each other via string references. Modules support both singular and mutually recursive types. They provide a mechanism to create circular types irrespective of the order in which types are defined.
 
 ```typescript
-// The following creates a circular recursive type.
+
+// The following creates a Module of circular recursive Types.
 
 const Module = Type.Module({
   A: Type.Object({ 
@@ -791,7 +792,7 @@ const Module = Type.Module({
   }),
 })
 
-// Module types must be imported before use.
+// Module Types must be imported before use.
 
 const A = Module.Import('A')                     // const A: TImport<{...}, 'A'>
 

From 56b760c99eb71dfba4c6b385a27a17c21ca13a1c Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Sun, 17 Nov 2024 05:58:50 +0900
Subject: [PATCH 305/369] Revision 0.34.1 (#1080)

* Implement Computed Deref Types for Import

* ChangeLog
---
 changelog/0.34.0.md                           |   4 +
 package-lock.json                             |   4 +-
 package.json                                  |   2 +-
 readme.md                                     |  42 +-
 src/syntax/runtime.ts                         |   5 +-
 src/syntax/static.ts                          |  10 +-
 src/type/array/array.ts                       |   2 +-
 src/type/awaited/awaited.ts                   |  94 ++--
 src/type/computed/computed.ts                 |  44 ++
 src/type/computed/index.ts                    |  29 ++
 src/type/guard/kind.ts                        |  17 +-
 src/type/guard/type.ts                        |  12 +-
 src/type/indexed/indexed-from-mapped-key.ts   |  63 ++-
 .../indexed/indexed-from-mapped-result.ts     |  55 +--
 src/type/indexed/indexed-property-keys.ts     |  60 +--
 src/type/indexed/indexed.ts                   | 266 +++++++-----
 src/type/intersect/intersect-evaluated.ts     |  74 ++--
 src/type/intersect/intersect.ts               |  18 +-
 src/type/keyof/keyof-from-mapped-result.ts    |  46 +-
 src/type/keyof/keyof-property-keys.ts         |  94 ++--
 src/type/keyof/keyof.ts                       |  86 ++--
 src/type/module/compute.ts                    | 402 ++++++++++++++++++
 src/type/module/infer.ts                      | 162 +++++++
 src/type/module/module.ts                     | 144 +------
 src/type/not/not.ts                           |   4 +-
 src/type/omit/omit-from-mapped-key.ts         |  73 ++--
 src/type/omit/omit-from-mapped-result.ts      |  52 +--
 src/type/omit/omit.ts                         | 163 ++++---
 src/type/partial/partial.ts                   | 100 +++--
 src/type/pick/pick-from-mapped-key.ts         |  71 ++--
 src/type/pick/pick-from-mapped-result.ts      |  52 +--
 src/type/pick/pick.ts                         | 162 ++++---
 src/type/record/record.ts                     |  51 ++-
 src/type/required/required.ts                 | 108 +++--
 src/type/tuple/tuple.ts                       |   8 +-
 src/type/type/javascript.ts                   |  26 +-
 src/type/type/json.ts                         | 146 +++----
 src/type/union/union-evaluated.ts             |  70 +--
 src/type/union/union.ts                       |  10 +-
 src/value/check/check.ts                      |   4 +-
 src/value/transform/decode.ts                 |   4 +-
 src/value/transform/encode.ts                 |   4 +-
 src/value/transform/has.ts                    |   4 +-
 test/runtime/type/guard/kind/import.ts        | 150 ++++++-
 test/runtime/type/guard/type/import.ts        | 148 ++++++-
 test/static/pick.ts                           |   2 +-
 46 files changed, 2075 insertions(+), 1072 deletions(-)
 create mode 100644 src/type/computed/computed.ts
 create mode 100644 src/type/computed/index.ts
 create mode 100644 src/type/module/compute.ts
 create mode 100644 src/type/module/infer.ts

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index fdc9a75ff..e9f754629 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,3 +1,7 @@
+### 0.34.0
+- [Revision 0.34.1](https://github.com/sinclairzx81/typebox/pull/1080)
+  - Implement Computed Type Deref in Modules
+
 ## [0.34.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.34.0)
 
 ## Overview
diff --git a/package-lock.json b/package-lock.json
index fbacace2e..3dab50690 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.0",
+  "version": "0.34.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.0",
+      "version": "0.34.1",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 44b16b8e3..5c9bf671d 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.0",
+  "version": "0.34.1",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 3adeae926..0d3ec1cb1 100644
--- a/readme.md
+++ b/readme.md
@@ -1074,22 +1074,32 @@ const T = Type.Object({                             // const T: TObject<{
 
 ### Module
 
-Syntax Types support Module parsing, which is useful for processing multiple TypeScript types. Module parsing supports type alias and interface definitions. Generics are currently unsupported as of 0.34.0.
+Syntax Types also support Module parsing. This can provide a more terse syntax for creating Module definitions, but comes with an inference performance cost. Module parsing supports interface and type alias definitions. Generics types are currently unsupported. 
 
 ```typescript
-const Foo = Parse(`module Foo {
-
-  export type A = string
-
-  export type B = number
-
-  export type C = A | B
+const Module = Parse(`module {
+  
+  export interface User {
+    id: string
+    name: string
+    email: string
+  }
+ 
+  export type PartialUser = (
+    Pick<User, 'id'> &
+    Partial<Omit<User, 'id'>>
+  )
 
 }`)
 
-const C = Foo.Import('C')                           // const C: TImport<{
-                                                    //   ...
-                                                    // }, 'C'>
+const PartialUser = Module.Import('PartialUser')    // TImport<{...}, 'PartialUser'>
+
+type PartialUser = Static<typeof PartialUser>       // type PartialUser = {
+                                                    //   id: string,
+                                                    // } & {
+                                                    //   name?: string,
+                                                    //   email?: string,
+                                                    // }
 ```
 
 <a name='syntax-context'></a>
@@ -1883,12 +1893,12 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │ (index)              │ Compiled   │ Minified   │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '121.7 kb' │ ' 53.4 kb' │ '2.28 x'    │
-│ typebox/errors       │ ' 75.3 kb' │ ' 33.4 kb' │ '2.25 x'    │
-│ typebox/syntax       │ '120.1 kb' │ ' 50.5 kb' │ '2.38 x'    │
+│ typebox/compiler     │ '122.4 kb' │ ' 53.4 kb' │ '2.29 x'    │
+│ typebox/errors       │ ' 67.6 kb' │ ' 29.6 kb' │ '2.28 x'    │
+│ typebox/syntax       │ '132.9 kb' │ ' 54.2 kb' │ '2.45 x'    │
 │ typebox/system       │ '  7.4 kb' │ '  3.2 kb' │ '2.33 x'    │
-│ typebox/value        │ '160.3 kb' │ ' 67.4 kb' │ '2.38 x'    │
-│ typebox              │ ' 96.2 kb' │ ' 40.2 kb' │ '2.39 x'    │
+│ typebox/value        │ '150.1 kb' │ ' 62.2 kb' │ '2.41 x'    │
+│ typebox              │ '106.8 kb' │ ' 43.2 kb' │ '2.47 x'    │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 
diff --git a/src/syntax/runtime.ts b/src/syntax/runtime.ts
index 15001ee48..82db79005 100644
--- a/src/syntax/runtime.ts
+++ b/src/syntax/runtime.ts
@@ -324,11 +324,12 @@ const FactorIndexArray = (Type: Types.TSchema, IndexArray: unknown[]): Types.TSc
   const [Left, Right] = DestructureRight(IndexArray) as [unknown[], Types.TSchema[]]
   return (
     !Types.ValueGuard.IsUndefined(Right) ? (
-      Right.length === 1 ? Types.Index(FactorIndexArray(Type, Left), Right[0]) :
+      // note: Indexed types require reimplementation to replace `[number]` indexers
+      Right.length === 1 ? Types.Index(FactorIndexArray(Type, Left), Right[0]) as never :
       Right.length === 0 ? Types.Array(FactorIndexArray(Type, Left)) :
       Types.Never()
     ) : Type
-  )
+  ) 
 }
 // prettier-ignore
 const FactorMapping = (KeyOf: boolean, Type: Types.TSchema, IndexArray: unknown[], Extends: Types.TSchema[]) => {
diff --git a/src/syntax/static.ts b/src/syntax/static.ts
index 0b30b8ead..ddd48ea76 100644
--- a/src/syntax/static.ts
+++ b/src/syntax/static.ts
@@ -776,7 +776,7 @@ type Partial = Static.Tuple<[
 // prettier-ignore
 interface RequiredMapping extends Static.IMapping {
   output: this['input'] extends ['Required', LAngle, infer Type extends Types.TSchema, RAngle]
-    ? Types.TPartial<Type>
+    ? Types.TRequired<Type>
     : never
 }
 // prettier-ignore
@@ -788,8 +788,8 @@ type Required = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface PickMapping extends Static.IMapping {
-  output: this['input'] extends ['Pick', LAngle, infer Type extends Types.TSchema, Comma, infer PropertyKey extends Types.TSchema, RAngle]
-    ? Types.TPick<Type, Types.TIndexPropertyKeys<PropertyKey>>
+  output: this['input'] extends ['Pick', LAngle, infer Type extends Types.TSchema, Comma, infer Key extends Types.TSchema, RAngle]
+    ? Types.TPick<Type, Key>
     : never
 }
 // prettier-ignore
@@ -801,8 +801,8 @@ type Pick = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface OmitMapping extends Static.IMapping {
-  output: this['input'] extends ['Omit', LAngle, infer Type extends Types.TSchema, Comma, infer PropertyKey extends Types.TSchema, RAngle]
-    ? Types.TOmit<Type, Types.TIndexPropertyKeys<PropertyKey>>
+  output: this['input'] extends ['Omit', LAngle, infer Type extends Types.TSchema, Comma, infer Key extends Types.TSchema, RAngle]
+    ? Types.TOmit<Type, Key>
     : never
 }
 // prettier-ignore
diff --git a/src/type/array/array.ts b/src/type/array/array.ts
index 388ba25d7..dc29a1858 100644
--- a/src/type/array/array.ts
+++ b/src/type/array/array.ts
@@ -54,6 +54,6 @@ export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptio
   items: T
 }
 /** `[Json]` Creates an Array type */
-export function Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T> {
+export function Array<Type extends TSchema>(items: Type, options?: ArrayOptions): TArray<Type> {
   return CreateType({ [Kind]: 'Array', type: 'array', items }, options) as never
 }
diff --git a/src/type/awaited/awaited.ts b/src/type/awaited/awaited.ts
index e129b6a52..1a849f14e 100644
--- a/src/type/awaited/awaited.ts
+++ b/src/type/awaited/awaited.ts
@@ -26,76 +26,96 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+import { CreateType } from '../create/type'
+import { Ensure } from '../helpers/index'
 import type { TSchema, SchemaOptions } from '../schema/index'
+import { Computed, type TComputed } from '../computed/index'
 import { Intersect, type TIntersect } from '../intersect/index'
 import { Union, type TUnion } from '../union/index'
 import { type TPromise } from '../promise/index'
-import { CreateType } from '../create/type'
+import { Ref, type TRef } from '../ref/index'
 
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsIntersect, IsUnion, IsPromise } from '../guard/kind'
-// ------------------------------------------------------------------
-// FromRest
-// ------------------------------------------------------------------
+import { IsIntersect, IsUnion, IsPromise, IsRef, IsComputed } from '../guard/kind'
+
+// ----------------------------------------------------------------
+// FromComputed
+// ----------------------------------------------------------------
 // prettier-ignore
-type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> =
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TFromRest<R, [...Acc, TAwaited<L>]>
-    : Acc
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<(
+  TComputed<'Awaited', [TComputed<Target, Parameters>]>
+)>
+// prettier-ignore
+function FromComputed<Target extends string, Parameters extends TSchema[]>(target: Target, parameters: Parameters): TFromComputed<Target, Parameters> {
+  return Computed('Awaited', [Computed(target, parameters)]) as never
+}
+// ----------------------------------------------------------------
+// Ref
+// ----------------------------------------------------------------
+type TFromRef<Ref extends string> = Ensure<TComputed<'Awaited', [TRef<Ref>]>>
 // prettier-ignore
-function FromRest<T extends TSchema[]>(T: [...T]) : TFromRest<T> {
-  return T.map(L => AwaitedResolve(L)) as never
+function FromRef<Ref extends string>($ref: Ref): TFromRef<Ref> {
+  return Computed('Awaited', [Ref($ref)]) as never
 }
 // ----------------------------------------------------------------
 // FromIntersect
 // ----------------------------------------------------------------
 // prettier-ignore
-type TFromIntersect<T extends TSchema[]> = TIntersect<TFromRest<T>>
+type TFromIntersect<Types extends TSchema[]> = (
+  TIntersect<TFromRest<Types>>
+)
 // prettier-ignore
-function FromIntersect<T extends TSchema[]>(T: [...T]): TFromIntersect<T> {
-  return Intersect(FromRest(T) as TSchema[]) as never
+function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types> {
+  return Intersect(FromRest(types) as TSchema[]) as never
 }
 // ----------------------------------------------------------------
 // FromUnion
 // ----------------------------------------------------------------
 // prettier-ignore
-type TFromUnion<T extends TSchema[]> = TUnion<TFromRest<T>>
+type TFromUnion<Types extends TSchema[]> = TUnion<TFromRest<Types>>
 // prettier-ignore
-function FromUnion<T extends TSchema[]>(T: [...T]): TFromUnion<T> {
-  return Union(FromRest(T) as TSchema[]) as never
+function FromUnion<Types extends TSchema[]>(types: [...Types]): TFromUnion<Types> {
+  return Union(FromRest(types) as TSchema[]) as never
 }
 // ----------------------------------------------------------------
 // Promise
 // ----------------------------------------------------------------
-type TFromPromise<T extends TSchema> = TAwaited<T>
+type TFromPromise<Type extends TSchema> = TAwaited<Type>
 // prettier-ignore
-function FromPromise<T extends TSchema>(T: T): TFromPromise<T> {
-  return AwaitedResolve(T) as never
+function FromPromise<Type extends TSchema>(type: Type): TFromPromise<Type> {
+  return Awaited(type) as never
 }
-// ----------------------------------------------------------------
-// AwaitedResolve
-// ----------------------------------------------------------------
+// ------------------------------------------------------------------
+// FromRest
+// ------------------------------------------------------------------
 // prettier-ignore
-function AwaitedResolve<T extends TSchema>(T: T): TAwaited<T> {
-  return (
-    IsIntersect(T) ? FromIntersect(T.allOf) :
-    IsUnion(T) ? FromUnion(T.anyOf) :
-    IsPromise(T) ? FromPromise(T.item) :
-    T
-  ) as never
+type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
+    ? TFromRest<Right, [...Result, TAwaited<Left>]>
+    : Result
+)
+// prettier-ignore
+function FromRest<Types extends TSchema[]>(types: [...Types]) : TFromRest<Types> {
+  return types.map(type => Awaited(type)) as never
 }
 // ------------------------------------------------------------------
 // TAwaited
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TAwaited<T extends TSchema> =
-  T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> :
-  T extends TUnion<infer S> ? TUnion<TFromRest<S>> :
-  T extends TPromise<infer S> ? TAwaited<S> :
-  T
+export type TAwaited<Type extends TSchema> = (
+  Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> :
+  Type extends TRef<infer Ref extends string> ? TFromRef<Ref> :
+  Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> :
+  Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> :
+  Type extends TPromise<infer Type extends TSchema> ? TAwaited<Type> :
+  Type
+)
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-export function Awaited<T extends TSchema>(T: T, options?: SchemaOptions): TAwaited<T> {
-  return CreateType(AwaitedResolve(T), options) as never
+export function Awaited<T extends TSchema>(type: T, options?: SchemaOptions): TAwaited<T> {
+  return CreateType(
+    IsComputed(type) ? FromComputed(type.target, type.parameters) : IsIntersect(type) ? FromIntersect(type.allOf) : IsUnion(type) ? FromUnion(type.anyOf) : IsPromise(type) ? FromPromise(type.item) : IsRef(type) ? FromRef(type.$ref) : type,
+    options,
+  ) as never
 }
diff --git a/src/type/computed/computed.ts b/src/type/computed/computed.ts
new file mode 100644
index 000000000..2524dc152
--- /dev/null
+++ b/src/type/computed/computed.ts
@@ -0,0 +1,44 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema, SchemaOptions } from '../schema/index'
+import { CreateType } from '../create/index'
+import { Kind } from '../symbols/symbols'
+
+// ------------------------------------------------------------------
+// Computed
+// ------------------------------------------------------------------
+export interface TComputed<Target extends string = string, Parameters extends TSchema[] = []> extends TSchema {
+  [Kind]: 'Computed'
+  target: Target
+  parameters: Parameters
+}
+/** `[Internal]` Creates a deferred computed type. This type is used exclusively in modules to defer resolution of computable types that contain interior references  */
+export function Computed<Target extends string, Parameters extends TSchema[]>(target: Target, parameters: [...Parameters], options?: SchemaOptions): TComputed<Target, Parameters> {
+  return CreateType({ [Kind]: 'Computed', target, parameters }, options) as never
+}
diff --git a/src/type/computed/index.ts b/src/type/computed/index.ts
new file mode 100644
index 000000000..4d20b1f87
--- /dev/null
+++ b/src/type/computed/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './computed'
diff --git a/src/type/guard/kind.ts b/src/type/guard/kind.ts
index 2e61a1df9..95e14fc2f 100644
--- a/src/type/guard/kind.ts
+++ b/src/type/guard/kind.ts
@@ -29,9 +29,10 @@ THE SOFTWARE.
 import * as ValueGuard from './value'
 import { Kind, Hint, TransformKind, ReadonlyKind, OptionalKind } from '../symbols/index'
 import { TransformOptions } from '../transform/index'
-import { TTemplateLiteral } from '../template-literal/index'
-import { TArray } from '../array/index'
-import { TBoolean } from '../boolean/index'
+import type { TTemplateLiteral } from '../template-literal/index'
+import type { TArray } from '../array/index'
+import type { TBoolean } from '../boolean/index'
+import type { TComputed } from '../computed/index'
 import type { TRecord } from '../record/index'
 import type { TString } from '../string/index'
 import type { TUnion } from '../union/index'
@@ -44,7 +45,7 @@ import type { TImport } from '../module/index'
 import type { TInteger } from '../integer/index'
 import type { TIntersect } from '../intersect/index'
 import type { TIterator } from '../iterator/index'
-import type { TLiteral } from '../literal/index'
+import type { TLiteral, TLiteralValue } from '../literal/index'
 import type { TMappedKey, TMappedResult } from '../mapped/index'
 import type { TNever } from '../never/index'
 import type { TNot } from '../not/index'
@@ -95,6 +96,10 @@ export function IsBigInt(value: unknown): value is TBigInt {
 export function IsBoolean(value: unknown): value is TBoolean {
   return IsKindOf(value, 'Boolean')
 }
+/** `[Kind-Only]` Returns true if the given value is TComputed */
+export function IsComputed(value: unknown): value is TComputed {
+  return IsKindOf(value, 'Computed')
+}
 /** `[Kind-Only]` Returns true if the given value is TConstructor */
 export function IsConstructor(value: unknown): value is TConstructor {
   return IsKindOf(value, 'Constructor')
@@ -143,6 +148,10 @@ export function IsLiteralNumber(value: unknown): value is TLiteral<number> {
 export function IsLiteralBoolean(value: unknown): value is TLiteral<boolean> {
   return IsLiteral(value) && ValueGuard.IsBoolean(value.const)
 }
+/** `[Kind-Only]` Returns true if the given value is TLiteralValue */
+export function IsLiteralValue(value: unknown): value is TLiteralValue {
+  return ValueGuard.IsBoolean(value) || ValueGuard.IsNumber(value) || ValueGuard.IsString(value)
+}
 /** `[Kind-Only]` Returns true if the given value is TLiteral */
 export function IsLiteral(value: unknown): value is TLiteral {
   return IsKindOf(value, 'Literal')
diff --git a/src/type/guard/type.ts b/src/type/guard/type.ts
index ed8eb54fe..b4564bed2 100644
--- a/src/type/guard/type.ts
+++ b/src/type/guard/type.ts
@@ -30,9 +30,10 @@ import * as ValueGuard from './value'
 import { Kind, Hint, TransformKind, ReadonlyKind, OptionalKind } from '../symbols/index'
 import { TypeBoxError } from '../error/index'
 import { TransformOptions } from '../transform/index'
-import { TTemplateLiteral } from '../template-literal/index'
-import { TArray } from '../array/index'
-import { TBoolean } from '../boolean/index'
+import type { TTemplateLiteral } from '../template-literal/index'
+import type { TArray } from '../array/index'
+import type { TBoolean } from '../boolean/index'
+import type { TComputed } from '../computed/index'
 import type { TRecord } from '../record/index'
 import type { TString } from '../string/index'
 import type { TUnion } from '../union/index'
@@ -76,6 +77,7 @@ const KnownTypes = [
   'AsyncIterator',
   'BigInt',
   'Boolean',
+  'Computed',
   'Constructor',
   'Date',
   'Enum',
@@ -217,6 +219,10 @@ export function IsBoolean(value: unknown): value is TBoolean {
     IsOptionalString(value.$id)
   )
 }
+/** Returns true if the given value is TComputed */
+export function IsComputed(value: unknown): value is TComputed {
+  return IsKindOf(value, 'Computed') && IsString(value.target) && ValueGuard.IsArray(value.parameters) && value.parameters.every((schema) => IsSchema(schema))
+}
 /** Returns true if the given value is TConstructor */
 export function IsConstructor(value: unknown): value is TConstructor {
   // prettier-ignore
diff --git a/src/type/indexed/indexed-from-mapped-key.ts b/src/type/indexed/indexed-from-mapped-key.ts
index 4251cea89..b66cf5113 100644
--- a/src/type/indexed/indexed-from-mapped-key.ts
+++ b/src/type/indexed/indexed-from-mapped-key.ts
@@ -37,68 +37,53 @@ import { Clone } from '../clone/value'
 // MappedIndexPropertyKey
 // ------------------------------------------------------------------
 // prettier-ignore
-type TMappedIndexPropertyKey<
-  T extends TSchema, 
-  K extends PropertyKey
-> = {
-  [_ in K]: TIndex<T, [K]>
+type TMappedIndexPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
+  [_ in Key]: TIndex<Type, [Key]>
 }
 // prettier-ignore
-function MappedIndexPropertyKey<
-  T extends TSchema, 
-  K extends PropertyKey
->(T: T, K: K, options?: SchemaOptions): TMappedIndexPropertyKey<T, K> {
-  return { [K]: Index(T, [K], Clone(options)) } as never
+function MappedIndexPropertyKey<Type extends TSchema, Key extends PropertyKey
+>(type: Type, key: Key, options?: SchemaOptions): TMappedIndexPropertyKey<Type, Key> {
+  return { [key]: Index(type, [key], Clone(options)) } as never
 }
 // ------------------------------------------------------------------
 // MappedIndexPropertyKeys
 // ------------------------------------------------------------------
 // prettier-ignore
-type TMappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TProperties = {}> = (
-  K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
-    ? TMappedIndexPropertyKeys<T, R, Acc & TMappedIndexPropertyKey<T, L>>
-    : Acc
+type TMappedIndexPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TProperties = {}> = (
+  PropertyKeys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]]
+    ? TMappedIndexPropertyKeys<Type, Right, Result & TMappedIndexPropertyKey<Type, Left>>
+    : Result
 )
 // prettier-ignore
-function MappedIndexPropertyKeys<
-  T extends TSchema, 
-  K extends PropertyKey[]
->(T: T, K: [...K], options?: SchemaOptions): TMappedIndexPropertyKeys<T, K> {
-  return K.reduce((Acc, L) => {
-    return { ...Acc, ...MappedIndexPropertyKey(T, L, options) }
+function MappedIndexPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TMappedIndexPropertyKeys<Type, PropertyKeys> {
+  return propertyKeys.reduce((result, left) => {
+    return { ...result, ...MappedIndexPropertyKey(type, left, options) }
   }, {} as TProperties) as never
 }
 // ------------------------------------------------------------------
 // MappedIndexProperties
 // ------------------------------------------------------------------
 // prettier-ignore
-type TMappedIndexProperties<T extends TSchema, K extends TMappedKey> = Evaluate<
-  TMappedIndexPropertyKeys<T, K['keys']>
+type TMappedIndexProperties<Type extends TSchema, MappedKey extends TMappedKey> = Evaluate<
+  TMappedIndexPropertyKeys<Type, MappedKey['keys']>
 >
 // prettier-ignore
-function MappedIndexProperties<
-  T extends TSchema, 
-  K extends TMappedKey
->(T: T, K: K, options?: SchemaOptions): TMappedIndexProperties<T, K> {
-  return MappedIndexPropertyKeys(T, K.keys, options) as never
+function MappedIndexProperties<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedIndexProperties<Type, MappedKey> {
+  return MappedIndexPropertyKeys(type, mappedKey.keys, options) as never
 }
 // ------------------------------------------------------------------
 // TIndexFromMappedKey
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TIndexFromMappedKey<
-  T extends TSchema, 
-  K extends TMappedKey, 
-  P extends TProperties = TMappedIndexProperties<T, K>
+export type TIndexFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, 
+  Properties extends TProperties = TMappedIndexProperties<Type, MappedKey>
 > = (
-  Ensure<TMappedResult<P>>
+  Ensure<TMappedResult<Properties>>
 )
 // prettier-ignore
-export function IndexFromMappedKey<
-  T extends TSchema, 
-  K extends TMappedKey, 
-  P extends TProperties = TMappedIndexProperties<T, K>
->(T: T, K: K, options?: SchemaOptions): TMappedResult<P> {
-  const P = MappedIndexProperties(T, K, options)
-  return MappedResult(P) as never
+export function IndexFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, 
+  Properties extends TProperties = TMappedIndexProperties<Type, MappedKey>
+>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedResult<Properties> {
+  const properties = MappedIndexProperties(type, mappedKey, options)
+  return MappedResult(properties) as never
 }
diff --git a/src/type/indexed/indexed-from-mapped-result.ts b/src/type/indexed/indexed-from-mapped-result.ts
index d23fa750d..e2b2b007c 100644
--- a/src/type/indexed/indexed-from-mapped-result.ts
+++ b/src/type/indexed/indexed-from-mapped-result.ts
@@ -36,57 +36,42 @@ import { Index, type TIndex } from './index'
 // FromProperties
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromProperties<
-  T extends TSchema,
-  P extends TProperties
-> = (
-  { [K2 in keyof P]: TIndex<T, TIndexPropertyKeys<P[K2]>> }   
+type TFromProperties<Type extends TSchema, Properties extends TProperties> = (
+  { [K2 in keyof Properties]: TIndex<Type, TIndexPropertyKeys<Properties[K2]>> }   
 )
 // prettier-ignore
-function FromProperties<
-  T extends TSchema,
-  P extends TProperties
->(T: T, P: P, options?: SchemaOptions): TFromProperties<T, P> {
-  const Acc = {} as Record<PropertyKey, TSchema>
-  for(const K2 of Object.getOwnPropertyNames(P)) {
-    Acc[K2] = Index(T, IndexPropertyKeys(P[K2]), options)
+function FromProperties<Type extends TSchema, Properties extends TProperties>(type: Type, properties: Properties, options?: SchemaOptions): TFromProperties<Type, Properties> {
+  const result = {} as Record<PropertyKey, TSchema>
+  for(const K2 of Object.getOwnPropertyNames(properties)) {
+    const keys = IndexPropertyKeys(properties[K2])
+    result[K2] = Index(type, keys, options) as never
   }
-  return Acc as never
+  return result as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromMappedResult<
-  T extends TSchema,
-  R extends TMappedResult
-> = (
-  TFromProperties<T, R['properties']>
+type TFromMappedResult<Type extends TSchema, MappedResult extends TMappedResult> = (
+  TFromProperties<Type, MappedResult['properties']>
 )
 // prettier-ignore
-function FromMappedResult<
-  T extends TSchema,
-  R extends TMappedResult
->(T: T, R: R, options?: SchemaOptions): TFromMappedResult<T, R> {
-  return FromProperties(T, R.properties, options) as never
+function FromMappedResult<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TFromMappedResult<Type, MappedResult> {
+  return FromProperties(type, mappedResult.properties, options) as never
 }
 // ------------------------------------------------------------------
 // TIndexFromMappedResult
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TIndexFromMappedResult<
-  T extends TSchema,
-  R extends TMappedResult,
-  P extends TProperties = TFromMappedResult<T, R>
+export type TIndexFromMappedResult<Type extends TSchema, MappedResult extends TMappedResult,
+  Properties extends TProperties = TFromMappedResult<Type, MappedResult>
 > = (
-  TMappedResult<P>
+  TMappedResult<Properties>
 )
 // prettier-ignore
-export function IndexFromMappedResult<
-  T extends TSchema,
-  R extends TMappedResult,
-  P extends TProperties = TFromMappedResult<T, R>
->(T: T, R: R, options?: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedResult(T, R, options)
-  return MappedResult(P) as never
+export function IndexFromMappedResult<Type extends TSchema, MappedResult extends TMappedResult,
+  Properties extends TProperties = TFromMappedResult<Type, MappedResult>
+>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TMappedResult<Properties> {
+  const properties = FromMappedResult(type, mappedResult, options)
+  return MappedResult(properties) as never
 }
diff --git a/src/type/indexed/indexed-property-keys.ts b/src/type/indexed/indexed-property-keys.ts
index dcb60fad7..ad73541e4 100644
--- a/src/type/indexed/indexed-property-keys.ts
+++ b/src/type/indexed/indexed-property-keys.ts
@@ -41,38 +41,40 @@ import { IsTemplateLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../g
 // FromTemplateLiteral
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromTemplateLiteral<T extends TTemplateLiteral, R extends string[] = TTemplateLiteralGenerate<T>> = (R)
+type TFromTemplateLiteral<TemplateLiteral extends TTemplateLiteral, 
+  Result extends string[] = TTemplateLiteralGenerate<TemplateLiteral>
+> = Result
 // prettier-ignore
-function FromTemplateLiteral<T extends TTemplateLiteral>(T: T): TFromTemplateLiteral<T> {
-  const R = TemplateLiteralGenerate(T) as string[]
-  return R.map(S => S.toString()) as never
+function FromTemplateLiteral<TemplateLiteral extends TTemplateLiteral>(templateLiteral: TemplateLiteral): TFromTemplateLiteral<TemplateLiteral> {
+  const result = TemplateLiteralGenerate(templateLiteral) as string[]
+  return result.map(S => S.toString()) as never
 }
 // ------------------------------------------------------------------
 // FromUnion
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromUnion<T extends TSchema[], Acc extends string[] = []> = (
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]] 
-    ? TFromUnion<R, [...Acc, ...TIndexPropertyKeys<L>]>
-    : Acc
+type TFromUnion<Types extends TSchema[], Result extends string[] = []> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] 
+    ? TFromUnion<Right, [...Result, ...TIndexPropertyKeys<Left>]>
+    : Result
 )
 // prettier-ignore
-function FromUnion<T extends TSchema[]>(T: T): TFromUnion<T> {
-  const Acc = [] as string[]
-  for(const L of T) Acc.push(...IndexPropertyKeys(L))
-  return Acc as never
+function FromUnion<Type extends TSchema[]>(type: Type): TFromUnion<Type> {
+  const result = [] as string[]
+  for(const left of type) result.push(...IndexPropertyKeys(left))
+  return result as never
 }
 // ------------------------------------------------------------------
 // FromLiteral
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromLiteral<T extends TLiteralValue> = (
-  T extends PropertyKey 
-    ? [`${T}`] 
+type TFromLiteral<LiteralValue extends TLiteralValue> = (
+  LiteralValue extends PropertyKey 
+    ? [`${LiteralValue}`] 
     : []
 )
 // prettier-ignore
-function FromLiteral<T extends TLiteralValue>(T: T): TFromLiteral<T> {
+function FromLiteral<LiteralValue extends TLiteralValue>(T: LiteralValue): TFromLiteral<LiteralValue> {
   return (
     [(T as string).toString()] // TS 5.4 observes TLiteralValue as not having a toString()
   ) as never
@@ -81,23 +83,23 @@ function FromLiteral<T extends TLiteralValue>(T: T): TFromLiteral<T> {
 // IndexedKeyResolve
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TIndexPropertyKeys<T extends TSchema> = (
-  T extends TTemplateLiteral  ? TFromTemplateLiteral<T> :
-  T extends TUnion<infer S>   ? TFromUnion<S> :
-  T extends TLiteral<infer S> ? TFromLiteral<S> :
-  T extends TNumber           ? ['[number]'] :  
-  T extends TInteger          ? ['[number]'] :
+export type TIndexPropertyKeys<Type extends TSchema, Result extends PropertyKey[] = (
+  Type extends TTemplateLiteral ? TFromTemplateLiteral<Type> :
+  Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> :
+  Type extends TLiteral<infer LiteralValue extends TLiteralValue> ? TFromLiteral<LiteralValue> :
+  Type extends TNumber ? ['[number]'] :  
+  Type extends TInteger ? ['[number]'] :
   []
-)
+)> = Result
 /** Returns a tuple of PropertyKeys derived from the given TSchema */
 // prettier-ignore
-export function IndexPropertyKeys<T extends TSchema>(T: T): TIndexPropertyKeys<T> {
+export function IndexPropertyKeys<Type extends TSchema>(type: Type): TIndexPropertyKeys<Type> {
   return [...new Set<string>((
-    IsTemplateLiteral(T) ? FromTemplateLiteral(T) :
-    IsUnion(T) ? FromUnion(T.anyOf) :
-    IsLiteral(T) ? FromLiteral(T.const) :
-    IsNumber(T) ? ['[number]'] : 
-    IsInteger(T) ? ['[number]'] :
+    IsTemplateLiteral(type) ? FromTemplateLiteral(type) :
+    IsUnion(type) ? FromUnion(type.anyOf) :
+    IsLiteral(type) ? FromLiteral(type.const) :
+    IsNumber(type) ? ['[number]'] : 
+    IsInteger(type) ? ['[number]'] :
     []
   ))] as never
 }
diff --git a/src/type/indexed/indexed.ts b/src/type/indexed/indexed.ts
index 6de947666..5598b034c 100644
--- a/src/type/indexed/indexed.ts
+++ b/src/type/indexed/indexed.ts
@@ -28,62 +28,93 @@ THE SOFTWARE.
 
 import { CreateType } from '../create/type'
 import { type TSchema, SchemaOptions } from '../schema/index'
+import { Computed, type TComputed } from '../computed/index'
+import { Literal, type TLiteral, type TLiteralValue } from '../literal/index'
 import { type TObject, type TProperties } from '../object/index'
-import { type Assert } from '../helpers/index'
+import { type Ensure, type Assert } from '../helpers/index'
 import { Never, type TNever } from '../never/index'
 import { type TRecursive } from '../recursive/index'
 import { type TIntersect } from '../intersect/index'
 import { TMappedResult, type TMappedKey } from '../mapped/index'
-import { type TUnion } from '../union/index'
+import { Union, type TUnion } from '../union/index'
 import { type TTuple } from '../tuple/index'
 import { type TArray } from '../array/index'
+import { Ref, type TRef } from '../ref/index'
 import { IntersectEvaluated, type TIntersectEvaluated } from '../intersect/index'
 import { UnionEvaluated, type TUnionEvaluated } from '../union/index'
 
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
 import { IndexPropertyKeys, type TIndexPropertyKeys } from './indexed-property-keys'
 import { IndexFromMappedKey, type TIndexFromMappedKey } from './indexed-from-mapped-key'
 import { IndexFromMappedResult, type TIndexFromMappedResult } from './indexed-from-mapped-result'
+
+// ------------------------------------------------------------------
+// KindGuard
 // ------------------------------------------------------------------
-// TypeGuard
+import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion, IsLiteralValue, IsRef, IsComputed } from '../guard/kind'
+import { IsArray as IsArrayValue } from '../guard/value'
+
+// ------------------------------------------------------------------
+// FromComputed
 // ------------------------------------------------------------------
-import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion } from '../guard/kind'
+// prettier-ignore
+// type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<
+//   TComputed<'Partial', [TComputed<Target, Parameters>]>
+// >
+// // prettier-ignore
+// function FromComputed<Target extends string, Parameters extends TSchema[]>(target: Target, parameters: Parameters): TFromComputed<Target, Parameters> {
+//   return Computed('Partial', [Computed(target, parameters)]) as never
+// }
+// // ------------------------------------------------------------------
+// // FromRef
+// // ------------------------------------------------------------------
+// // prettier-ignore
+// type TFromRef<Ref extends string> = Ensure<
+//   TComputed<'Partial', [TRef<Ref>]>
+// >
+// // prettier-ignore
+// function FromRef<Ref extends string>($ref: Ref): TFromRef<Ref> {
+//   return Computed('Partial', [Ref($ref)]) as never
+// }
 
 // ------------------------------------------------------------------
 // FromRest
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (
+type TFromRest<T extends TSchema[], K extends PropertyKey, Result extends TSchema[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TFromRest<R, K, [...Acc, Assert<TIndexFromPropertyKey<L, K>, TSchema>]>
-    : Acc
+    ? TFromRest<R, K, [...Result, Assert<TIndexFromPropertyKey<L, K>, TSchema>]>
+    : Result
 )
 // prettier-ignore
-function FromRest<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TFromRest<T, K> {
-  return T.map(L => IndexFromPropertyKey(L, K)) as never
+function FromRest<Types extends TSchema[], K extends PropertyKey>(types: [...Types], key: K): TFromRest<Types, K> {
+  return types.map(left => IndexFromPropertyKey(left, key)) as never
 }
 // ------------------------------------------------------------------
 // FromIntersectRest
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromIntersectRest<T extends TSchema[], Acc extends TSchema[] = []> = (
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? L extends TNever
-      ? TFromIntersectRest<R, [...Acc]>
-      : TFromIntersectRest<R, [...Acc, L]>
-    : Acc
+type TFromIntersectRest<Types extends TSchema[], Result extends TSchema[] = []> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
+    ? Left extends TNever
+      ? TFromIntersectRest<Right, [...Result]>
+      : TFromIntersectRest<Right, [...Result, Left]>
+    : Result
 )
 // prettier-ignore
-function FromIntersectRest<T extends TSchema[]>(T: [...T]): TFromIntersectRest<T> {
-  return T.filter(L => !IsNever(L)) as never
+function FromIntersectRest<Types extends TSchema[]>(types: [...Types]): TFromIntersectRest<Types> {
+  return types.filter(left => !IsNever(left)) as never
 }
 // prettier-ignore
-type TFromIntersect<T extends TSchema[], K extends PropertyKey> = (
-  TIntersectEvaluated<TFromIntersectRest<TFromRest<T, K>>>
+type TFromIntersect<Types extends TSchema[], Key extends PropertyKey> = (
+  TIntersectEvaluated<TFromIntersectRest<TFromRest<Types, Key>>>
 )
 // prettier-ignore
-function FromIntersect<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TFromIntersect<T, K> {
+function FromIntersect<Types extends TSchema[], Key extends PropertyKey>(types: [...Types], key: Key): TFromIntersect<Types, Key> {
   return (
-    IntersectEvaluated(FromIntersectRest(FromRest(T as TSchema[], K)))
+    IntersectEvaluated(FromIntersectRest(FromRest(types as TSchema[], key)))
   ) as never
 }
 // ------------------------------------------------------------------
@@ -110,47 +141,51 @@ function FromIntersect<T extends TSchema[], K extends PropertyKey>(T: [...T], K:
 //
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromUnionRest<T extends TSchema[], Acc extends TSchema[] = []> = 
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? L extends TNever 
+type TFromUnionRest<Types extends TSchema[], Result extends TSchema[] = []> = 
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
+    ? Left extends TNever 
       ? []
-      : TFromUnionRest<R, [L, ...Acc]>
-    : Acc
+      : TFromUnionRest<Right, [Left, ...Result]>
+    : Result
 // prettier-ignore
-function FromUnionRest<T extends TSchema[]>(T: [...T]): TFromUnionRest<T> {
+function FromUnionRest<Types extends TSchema[]>(types: [...Types]): TFromUnionRest<Types> {
   return (
-    T.some(L => IsNever(L)) 
+    types.some(L => IsNever(L)) 
       ? [] 
-      : T 
+      : types 
   ) as never
 }
 // ------------------------------------------------------------------
 // FromUnion
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromUnion<T extends TSchema[], K extends PropertyKey> = (
-  TUnionEvaluated<TFromUnionRest<TFromRest<T, K>>>
+type TFromUnion<Types extends TSchema[], Key extends PropertyKey> = (
+  TUnionEvaluated<TFromUnionRest<TFromRest<Types, Key>>>
 )
 // prettier-ignore
-function FromUnion<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TFromUnion<T, K> {
+function FromUnion<Types extends TSchema[], Key extends PropertyKey>(types: [...Types], key: Key): TFromUnion<Types, Key> {
   return (
-    UnionEvaluated(FromUnionRest(FromRest(T as TSchema[], K)))
+    UnionEvaluated(FromUnionRest(FromRest(types as TSchema[], key)))
   ) as never
 }
 // ------------------------------------------------------------------
 // FromTuple
 // ------------------------------------------------------------------
+
 // prettier-ignore
-type TFromTuple<T extends TSchema[], K extends PropertyKey> = (
-  K extends keyof T ? T[K] : 
-  K extends '[number]' ? TUnionEvaluated<T> : 
-  TNever
-)
+type TFromTuple<Types extends TSchema[], Key extends PropertyKey, Result extends TSchema = (
+  Key extends '[number]' ? TUnionEvaluated<Types> :
+  Key extends keyof Types
+    ? Types[Key] extends infer Type extends TSchema
+      ? Type
+      : TNever 
+    : TNever
+)> = Result
 // prettier-ignore
-function FromTuple<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TFromTuple<T, K>  {
+function FromTuple<Types extends TSchema[], Key extends PropertyKey>(types: [...Types], key: Key): TFromTuple<Types, Key>  {
   return (
-    K in T ? T[K as number] : 
-    K === '[number]' ? UnionEvaluated(T) : 
+    key === '[number]' ? UnionEvaluated(types) : 
+    key in types ? types[key as number] : 
     Never()
   ) as never
 }
@@ -158,62 +193,54 @@ function FromTuple<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K):
 // FromArray
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromArray<T extends TSchema, K extends PropertyKey> = (
-  K extends '[number]' 
-    ? T 
-    : TNever
+type TFromArray<Type extends TSchema, Key extends PropertyKey> = (
+  Key extends '[number]' ? Type : TNever
 )
 // prettier-ignore
-function FromArray<T extends TSchema, K extends PropertyKey>(T: T, K: K): TFromArray<T, K>  {
-  return (
-    K === '[number]' 
-      ? T 
-      : Never()
-  ) as never
+function FromArray<Type extends TSchema, Key extends PropertyKey>(type: Type, key: Key): TFromArray<Type, Key> {
+  // ... ?
+  return (key === '[number]' ? type : Never()) as never
 }
 // ------------------------------------------------------------------
 // FromProperty
 // ------------------------------------------------------------------
-type AssertPropertyKey<T> = Assert<T, string | number>
+type AssertPropertyKey<T extends unknown> = Assert<T, string | number>
 
 // prettier-ignore
-type TFromProperty<
-  T extends TProperties, 
-  K extends PropertyKey,
-> = (
+type TFromProperty<Properties extends TProperties, Key extends PropertyKey, Result extends TSchema = (
   // evaluate for string keys
-  K extends keyof T 
-    ? T[K] 
+  Key extends keyof Properties 
+    ? Properties[Key] 
     // evaluate for numeric keys
-    : `${AssertPropertyKey<K>}` extends `${AssertPropertyKey<keyof T>}` 
-      ? T[AssertPropertyKey<K>]
+    : `${AssertPropertyKey<Key>}` extends `${AssertPropertyKey<keyof Properties>}` 
+      ? Properties[AssertPropertyKey<Key>]
       : TNever
-)
+)> = Result
 // prettier-ignore
-function FromProperty<T extends TProperties, K extends PropertyKey>(T: T, K: K): TFromProperty<T, K> {
-  return (K in T ? T[K as string] : Never()) as never
+function FromProperty<Properties extends TProperties, Key extends PropertyKey>(properties: Properties, key: Key): TFromProperty<Properties, Key> {
+  return (key in properties ? properties[key as string] : Never()) as never
 }
 // ------------------------------------------------------------------
 // FromKey
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TIndexFromPropertyKey<T extends TSchema, K extends PropertyKey> = (
-  T extends TRecursive<infer S> ? TIndexFromPropertyKey<S, K> :
-  T extends TIntersect<infer S> ? TFromIntersect<S, K> :
-  T extends TUnion<infer S> ? TFromUnion<S, K> :
-  T extends TTuple<infer S> ? TFromTuple<S, K> :
-  T extends TArray<infer S> ? TFromArray<S, K> :
-  T extends TObject<infer S> ? TFromProperty<S, K> :
+export type TIndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = (
+  Type extends TRecursive<infer S extends TSchema> ? TIndexFromPropertyKey<S, Key> :
+  Type extends TIntersect<infer S extends TSchema[]> ? TFromIntersect<S, Key> :
+  Type extends TUnion<infer S extends TSchema[]> ? TFromUnion<S, Key> :
+  Type extends TTuple<infer S extends TSchema[]> ? TFromTuple<S, Key> :
+  Type extends TArray<infer S extends TSchema> ? TFromArray<S, Key> :
+  Type extends TObject<infer S extends TProperties> ? TFromProperty<S, Key> :
   TNever
 )
 // prettier-ignore
-export function IndexFromPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): TIndexFromPropertyKey<T, K> {
+export function IndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey>(type: Type, key: Key): TIndexFromPropertyKey<Type, Key> {
   return (
-    IsIntersect(T) ? FromIntersect(T.allOf, K) :
-    IsUnion(T) ? FromUnion(T.anyOf, K) :
-    IsTuple(T) ? FromTuple(T.items ?? [], K) :
-    IsArray(T) ? FromArray(T.items, K) :
-    IsObject(T) ? FromProperty(T.properties, K) :
+    IsIntersect(type) ? FromIntersect(type.allOf, key) :
+    IsUnion(type) ? FromUnion(type.anyOf, key) :
+    IsTuple(type) ? FromTuple(type.items ?? [], key) :
+    IsArray(type) ? FromArray(type.items, key) :
+    IsObject(type) ? FromProperty(type.properties, key) :
     Never()
   ) as never
 }
@@ -221,52 +248,83 @@ export function IndexFromPropertyKey<T extends TSchema, K extends PropertyKey>(T
 // FromKeys
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TIndexFromPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TSchema[] = []> = (
-  K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
-    ? TIndexFromPropertyKeys<T, R, [...Acc, Assert<TIndexFromPropertyKey<T, L>, TSchema>]>
-    : Acc
+export type TIndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = (
+  PropertyKeys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]]
+    ? TIndexFromPropertyKeys<Type, Right, [...Result, Assert<TIndexFromPropertyKey<Type, Left>, TSchema>]>
+    : Result
 )
 // prettier-ignore
-export function IndexFromPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TIndexFromPropertyKeys<T, K> {
-  return K.map(L => IndexFromPropertyKey(T, L)) as never
+export function IndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): TIndexFromPropertyKeys<Type, PropertyKeys> {
+  return propertyKeys.map(left => IndexFromPropertyKey(type, left)) as never
 }
 // ------------------------------------------------------------------
 // FromSchema
 // ------------------------------------------------------------------
 // prettier-ignore
-type FromSchema<T extends TSchema, K extends PropertyKey[]> = (
-  TUnionEvaluated<TIndexFromPropertyKeys<T, K>>
+type TFromType<Type extends TSchema, PropertyKeys extends PropertyKey[], 
+  Result extends TSchema[] = TIndexFromPropertyKeys<Type, PropertyKeys>,
+> = TUnionEvaluated<Result>
+// prettier-ignore
+function FromType<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): TFromType<Type, PropertyKeys> {
+  const result = IndexFromPropertyKeys(type, propertyKeys as PropertyKey[])
+  return UnionEvaluated(result) as never
+}
+// ------------------------------------------------------------------
+// UnionFromPropertyKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+type TUnionFromPropertyKeys<PropertyKeys extends PropertyKey[], Result extends TLiteral[] = []> = (
+  PropertyKeys extends [infer Key extends PropertyKey, ...infer Rest extends PropertyKey[]]
+    ? Key extends TLiteralValue
+      ? TUnionFromPropertyKeys<Rest, [...Result, TLiteral<Key>]>
+      : TUnionFromPropertyKeys<Rest, [...Result]>
+    : TUnionEvaluated<Result>
 )
 // prettier-ignore
-function FromSchema<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromSchema<T, K> {
-  return (
-    UnionEvaluated(IndexFromPropertyKeys(T, K as PropertyKey[]))
-  ) as never
+function UnionFromPropertyKeys<PropertyKeys extends PropertyKey[]>(propertyKeys: PropertyKeys): TUnionFromPropertyKeys<PropertyKeys> {
+  const result = propertyKeys.reduce((result, key) => IsLiteralValue(key) ? [...result, Literal(key)]: result, [] as TLiteral[])
+  return UnionEvaluated(result) as never
 }
 // ------------------------------------------------------------------
 // TIndex
 // ------------------------------------------------------------------
+// prettier-ignore (do not export this type)
+type TResolvePropertyKeys<Key extends TSchema | PropertyKey[]> = Key extends TSchema ? TIndexPropertyKeys<Key> : Key
+// prettier-ignore (do not export this type)
+type TResolveTypeKey<Key extends TSchema | PropertyKey[]> = Key extends PropertyKey[] ? TUnionFromPropertyKeys<Key> : Key
 // prettier-ignore
-export type TIndex<T extends TSchema, K extends PropertyKey[]> = (
-  FromSchema<T, K>
+export type TIndex<Type extends TSchema, Key extends TSchema | PropertyKey[],
+  IsTypeRef extends boolean = Type extends TRef ? true : false,
+  IsKeyRef extends boolean = Key extends TRef ? true : false,
+> = (
+  Key extends TMappedResult ? TIndexFromMappedResult<Type, Key> :
+  Key extends TMappedKey ? TIndexFromMappedKey<Type, Key> :
+  [IsTypeRef, IsKeyRef] extends [true, true] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> :
+  [IsTypeRef, IsKeyRef] extends [false, true] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> :
+  [IsTypeRef, IsKeyRef] extends [true, false] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> : 
+  TFromType<Type, TResolvePropertyKeys<Key>>
 )
 /** `[Json]` Returns an Indexed property type for the given keys */
-export function Index<T extends TSchema, K extends TMappedResult>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedResult<T, K>
+export function Index<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TIndex<Type, Key>
 /** `[Json]` Returns an Indexed property type for the given keys */
-export function Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>
+export function Index<Type extends TSchema, Key extends TMappedKey>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>
 /** `[Json]` Returns an Indexed property type for the given keys */
-export function Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>
+export function Index<Type extends TSchema, Key extends TMappedResult>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>
 /** `[Json]` Returns an Indexed property type for the given keys */
-export function Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>
+export function Index<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>
 /** `[Json]` Returns an Indexed property type for the given keys */
-export function Index(T: TSchema, K: any, options?: SchemaOptions): any {
-  // mapped-types
-  if (IsMappedResult(K)) return IndexFromMappedResult(T, K, options)
-  if (IsMappedKey(K)) return IndexFromMappedKey(T, K, options)
-  // prettier-ignore
-  return CreateType(
-    IsSchema(K) 
-      ? FromSchema(T, IndexPropertyKeys(K)) 
-      : FromSchema(T, K as string[])
-  , options) as never
+// prettier-ignore
+export function Index(type: any, key: any, options?: SchemaOptions): any {
+  const typeKey: TSchema = IsArrayValue(key) ? UnionFromPropertyKeys(key as PropertyKey[]) : key 
+  const propertyKeys: PropertyKey[] = IsSchema(key) ? IndexPropertyKeys(key) : key
+  const isTypeRef: boolean = IsRef(type)
+  const isKeyRef: boolean = IsRef(key)
+  return (
+    IsMappedResult(key) ? IndexFromMappedResult(type, key, options) :
+    IsMappedKey(key) ? IndexFromMappedKey(type, key, options) :
+    (isTypeRef && isKeyRef) ? Computed('Index', [type, typeKey], options) :
+    (!isTypeRef && isKeyRef) ? Computed('Index', [type, typeKey], options) :
+    (isTypeRef && !isKeyRef) ? Computed('Index', [type, typeKey], options) :
+    CreateType(FromType(type, propertyKeys), options) 
+  ) as never
 }
diff --git a/src/type/intersect/intersect-evaluated.ts b/src/type/intersect/intersect-evaluated.ts
index a0c73484b..637009345 100644
--- a/src/type/intersect/intersect-evaluated.ts
+++ b/src/type/intersect/intersect-evaluated.ts
@@ -46,77 +46,77 @@ import { IsOptional, IsTransform } from '../guard/kind'
 // IsIntersectOptional
 // ------------------------------------------------------------------
 // prettier-ignore
-type TIsIntersectOptional<T extends TSchema[]> = (
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]] 
-    ? L extends TOptional<TSchema> 
-      ? TIsIntersectOptional<R> 
+type TIsIntersectOptional<Types extends TSchema[]> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] 
+    ? Left extends TOptional<TSchema> 
+      ? TIsIntersectOptional<Right> 
       : false 
     : true
 )
 // prettier-ignore
-function IsIntersectOptional<T extends TSchema[]>(T: T): TIsIntersectOptional<T> {
-  return T.every(L => IsOptional(L)) as never
+function IsIntersectOptional<Types extends TSchema[]>(types: [...Types]): TIsIntersectOptional<Types> {
+  return types.every(left => IsOptional(left)) as never
 }
 // ------------------------------------------------------------------
 // RemoveOptionalFromType
 // ------------------------------------------------------------------
 // prettier-ignore
-type TRemoveOptionalFromType<T extends TSchema> = (
-  T extends TReadonly<infer S extends TSchema> ? TReadonly<TRemoveOptionalFromType<S>> :
-  T extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromType<S> :
-  T
+type TRemoveOptionalFromType<Type extends TSchema> = (
+  Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TRemoveOptionalFromType<Type>> :
+  Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromType<Type> :
+  Type
 )
 // prettier-ignore
-function RemoveOptionalFromType<T extends TSchema>(T: T): TRemoveOptionalFromType<T> {
+function RemoveOptionalFromType<Type extends TSchema>(type: Type): TRemoveOptionalFromType<Type> {
   return (
-    Discard(T, [OptionalKind])
+    Discard(type, [OptionalKind])
     ) as never
 }
 // ------------------------------------------------------------------
 // RemoveOptionalFromRest
 // ------------------------------------------------------------------
 // prettier-ignore
-type TRemoveOptionalFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-  ? L extends TOptional<infer S extends TSchema>
-    ? TRemoveOptionalFromRest<R, [...Acc, TRemoveOptionalFromType<S>]>
-    : TRemoveOptionalFromRest<R, [...Acc, L]>
-  : Acc
+type TRemoveOptionalFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
+  ? Left extends TOptional<infer Type extends TSchema>
+    ? TRemoveOptionalFromRest<Right, [...Result, TRemoveOptionalFromType<Type>]>
+    : TRemoveOptionalFromRest<Right, [...Result, Left]>
+  : Result
 )
 // prettier-ignore
-function RemoveOptionalFromRest<T extends TSchema[]>(T: T): TRemoveOptionalFromRest<T> {
-  return T.map(L => IsOptional(L) ? RemoveOptionalFromType(L) : L) as never
+function RemoveOptionalFromRest<Types extends TSchema[]>(types: [...Types]): TRemoveOptionalFromRest<Types> {
+  return types.map(left => IsOptional(left) ? RemoveOptionalFromType(left) : left) as never
 }
 // ------------------------------------------------------------------
 // ResolveIntersect
 // ------------------------------------------------------------------
 // prettier-ignore
-type TResolveIntersect<T extends TSchema[]> = (
-  TIsIntersectOptional<T> extends true 
-    ? TOptional<TIntersect<TRemoveOptionalFromRest<T>>> 
-    : TIntersect<TRemoveOptionalFromRest<T>>
+type TResolveIntersect<Types extends TSchema[]> = (
+  TIsIntersectOptional<Types> extends true 
+    ? TOptional<TIntersect<TRemoveOptionalFromRest<Types>>> 
+    : TIntersect<TRemoveOptionalFromRest<Types>>
 )
 // prettier-ignore
-function ResolveIntersect<T extends TSchema[]>(T: [...T], options: SchemaOptions): TResolveIntersect<T> {
+function ResolveIntersect<Types extends TSchema[]>(types: [...Types], options: SchemaOptions): TResolveIntersect<Types> {
   return (
-    IsIntersectOptional(T)
-      ? Optional(IntersectCreate(RemoveOptionalFromRest(T) as TSchema[], options))
-      : IntersectCreate(RemoveOptionalFromRest(T) as TSchema[], options)
+    IsIntersectOptional(types)
+      ? Optional(IntersectCreate(RemoveOptionalFromRest(types) as TSchema[], options))
+      : IntersectCreate(RemoveOptionalFromRest(types) as TSchema[], options)
   ) as never
 }
 // ------------------------------------------------------------------
 // IntersectEvaluated
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TIntersectEvaluated<T extends TSchema[]> = (
-  T extends [] ? TNever :
-  T extends [TSchema] ? T[0] :
-  TResolveIntersect<T>
+export type TIntersectEvaluated<Types extends TSchema[]> = (
+  Types extends [TSchema] ? Types[0] :
+  Types extends [] ? TNever :
+  TResolveIntersect<Types>
 )
 /** `[Json]` Creates an evaluated Intersect type */
-export function IntersectEvaluated<T extends TSchema[], R = TIntersectEvaluated<T>>(T: [...T], options: IntersectOptions = {}): R {
-  if (T.length === 0) return Never(options) as never
-  if (T.length === 1) return CreateType(T[0], options) as never
-  if (T.some((schema) => IsTransform(schema))) throw new Error('Cannot intersect transform types')
-  return ResolveIntersect(T, options) as never
+export function IntersectEvaluated<Types extends TSchema[], Result extends TSchema = TIntersectEvaluated<Types>>(types: [...Types], options: IntersectOptions = {}): Result {
+  if (types.length === 1) return CreateType(types[0], options) as never
+  if (types.length === 0) return Never(options) as never
+  if (types.some((schema) => IsTransform(schema))) throw new Error('Cannot intersect transform types')
+  return ResolveIntersect(types, options) as never
 }
diff --git a/src/type/intersect/intersect.ts b/src/type/intersect/intersect.ts
index 66275057f..999d3d2af 100644
--- a/src/type/intersect/intersect.ts
+++ b/src/type/intersect/intersect.ts
@@ -40,15 +40,15 @@ import { IsTransform } from '../guard/kind'
 // Intersect
 // ------------------------------------------------------------------
 // prettier-ignore
-export type Intersect<T extends TSchema[]> = (
-  T extends [] ? TNever :
-  T extends [TSchema] ? T[0] :
-  TIntersect<T>
+export type Intersect<Types extends TSchema[]> = (
+  Types extends [TSchema] ? Types[0] :
+  Types extends [] ? TNever :
+  TIntersect<Types>
 )
 /** `[Json]` Creates an evaluated Intersect type */
-export function Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T> {
-  if (T.length === 0) return Never(options) as never
-  if (T.length === 1) return CreateType(T[0], options) as never
-  if (T.some((schema) => IsTransform(schema))) throw new Error('Cannot intersect transform types')
-  return IntersectCreate(T, options) as never
+export function Intersect<Types extends TSchema[]>(types: [...Types], options?: IntersectOptions): Intersect<Types> {
+  if (types.length === 1) return CreateType(types[0], options) as never
+  if (types.length === 0) return Never(options) as never
+  if (types.some((schema) => IsTransform(schema))) throw new Error('Cannot intersect transform types')
+  return IntersectCreate(types, options) as never
 }
diff --git a/src/type/keyof/keyof-from-mapped-result.ts b/src/type/keyof/keyof-from-mapped-result.ts
index 9991b7c15..0be659752 100644
--- a/src/type/keyof/keyof-from-mapped-result.ts
+++ b/src/type/keyof/keyof-from-mapped-result.ts
@@ -30,55 +30,47 @@ import type { SchemaOptions } from '../schema/index'
 import type { Ensure, Evaluate } from '../helpers/index'
 import type { TProperties } from '../object/index'
 import { MappedResult, type TMappedResult } from '../mapped/index'
-import { KeyOf, type TKeyOf } from './keyof'
+import { KeyOf, type TKeyOfFromType } from './keyof'
 import { Clone } from '../clone/value'
 // ------------------------------------------------------------------
 // FromProperties
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromProperties<
-  K extends TProperties
-> = (
-  { [K2 in keyof K]: TKeyOf<K[K2]> }   
+type TFromProperties<Properties extends TProperties> = (
+  { [K2 in keyof Properties]: TKeyOfFromType<Properties[K2]> }   
 )
 // prettier-ignore
-function FromProperties<
-  K extends TProperties
->(K: K, options?: SchemaOptions): TFromProperties<K> {
-  const Acc = {} as TProperties
-  for(const K2 of globalThis.Object.getOwnPropertyNames(K)) Acc[K2] = KeyOf(K[K2], Clone(options))
-  return Acc as never
+function FromProperties<Properties extends TProperties>(properties: Properties, options?: SchemaOptions): TFromProperties<Properties> {
+  const result = {} as TProperties
+  for(const K2 of globalThis.Object.getOwnPropertyNames(properties)) result[K2] = KeyOf(properties[K2], Clone(options))
+  return result as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromMappedResult<
-  R extends TMappedResult
-> = (
-  Evaluate<TFromProperties<R['properties']>>
+type TFromMappedResult<MappedResult extends TMappedResult> = (
+  Evaluate<TFromProperties<MappedResult['properties']>>
 )
 // prettier-ignore
-function FromMappedResult<
-  R extends TMappedResult
->(R: R, options?: SchemaOptions): TFromMappedResult<R> {
-  return FromProperties(R.properties, options) as never
+function FromMappedResult<MappedResult extends TMappedResult>(mappedResult: MappedResult, options?: SchemaOptions): TFromMappedResult<MappedResult> {
+  return FromProperties(mappedResult.properties, options) as never
 }
 // ------------------------------------------------------------------
 // KeyOfFromMappedResult
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TKeyOfFromMappedResult<
-  R extends TMappedResult,
-  P extends TProperties = TFromMappedResult<R>
+  MappedResult extends TMappedResult,
+  Properties extends TProperties = TFromMappedResult<MappedResult>
 > = (
-  Ensure<TMappedResult<P>>
+  Ensure<TMappedResult<Properties>>
 )
 // prettier-ignore
 export function KeyOfFromMappedResult<
-  R extends TMappedResult,
-  P extends TProperties = TFromMappedResult<R>
->(R: R, options?: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedResult(R, options)
-  return MappedResult(P) as never
+  MappedResult extends TMappedResult,
+  Properties extends TProperties = TFromMappedResult<MappedResult>
+>(mappedResult: MappedResult, options?: SchemaOptions): TMappedResult<Properties> {
+  const properties = FromMappedResult(mappedResult, options)
+  return MappedResult(properties) as never
 }
diff --git a/src/type/keyof/keyof-property-keys.ts b/src/type/keyof/keyof-property-keys.ts
index 28f945bb1..25cfd2df3 100644
--- a/src/type/keyof/keyof-property-keys.ts
+++ b/src/type/keyof/keyof-property-keys.ts
@@ -44,58 +44,56 @@ import { IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsRecord } from '../g
 // FromRest
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromRest<T extends TSchema[], Acc extends PropertyKey[][] = []> = (
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TFromRest<R, [...Acc, TKeyOfPropertyKeys<L>]>
-    : Acc
+type TFromRest<Types extends TSchema[], Result extends PropertyKey[][] = []> = (
+  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TFromRest<R, [...Result, TKeyOfPropertyKeys<L>]>
+    : Result
 )
 // prettier-ignore
-function FromRest<T extends TSchema[]>(T: [...T]): TFromRest<T> {
-  const Acc = [] as PropertyKey[][]
-  for(const L of T) Acc.push(KeyOfPropertyKeys(L))
-  return Acc as never
+function FromRest<Types extends TSchema[]>(types: [...Types]): TFromRest<Types> {
+  const result = [] as PropertyKey[][]
+  for(const L of types) result.push(KeyOfPropertyKeys(L))
+  return result as never
 }
 // ------------------------------------------------------------------
 // FromIntersect
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromIntersect<
-  T extends TSchema[], 
-  C extends PropertyKey[][] = TFromRest<T>,
-  R extends PropertyKey[] = TSetUnionMany<C>
-> = R
+type TFromIntersect<Types extends TSchema[], 
+  PropertyKeysArray extends PropertyKey[][] = TFromRest<Types>,
+  PropertyKeys extends PropertyKey[] = TSetUnionMany<PropertyKeysArray>
+> = PropertyKeys
 // prettier-ignore
-function FromIntersect<T extends TSchema[]>(T: [...T]): TFromIntersect<T> {
-  const C = FromRest(T) as PropertyKey[][]
-  const R = SetUnionMany(C)
-  return R as never
+function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types> {
+  const propertyKeysArray = FromRest(types) as PropertyKey[][]
+  const propertyKeys = SetUnionMany(propertyKeysArray)
+  return propertyKeys as never
 }
 // ------------------------------------------------------------------
 // FromUnion
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromUnion<
-  T extends TSchema[], 
-  C extends PropertyKey[][] = TFromRest<T>,
-  R extends PropertyKey[] = TSetIntersectMany<C>
-> = R
+type TFromUnion<Types extends TSchema[], 
+  PropertyKeysArray extends PropertyKey[][] = TFromRest<Types>,
+  PropertyKeys extends PropertyKey[] = TSetIntersectMany<PropertyKeysArray>
+> = PropertyKeys
 // prettier-ignore
-function FromUnion<T extends TSchema[]>(T: [...T]): TFromUnion<T> {
-  const C = FromRest(T) as PropertyKey[][]
-  const R = SetIntersectMany(C)
-  return R as never
+function FromUnion<Types extends TSchema[]>(types: [...Types]): TFromUnion<Types> {
+  const propertyKeysArray = FromRest(types) as PropertyKey[][]
+  const propertyKeys = SetIntersectMany(propertyKeysArray)
+  return propertyKeys as never
 }
 // ------------------------------------------------------------------
 // FromTuple
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromTuple<T extends TSchema[], I extends string = ZeroString, Acc extends PropertyKey[] = []> = 
-  T extends [infer _ extends TSchema, ...infer R extends TSchema[]]
-    ? TFromTuple<R, TIncrement<I>, [...Acc, I]>
+type TFromTuple<Types extends TSchema[], Indexer extends string = ZeroString, Acc extends PropertyKey[] = []> = 
+  Types extends [infer _ extends TSchema, ...infer R extends TSchema[]]
+    ? TFromTuple<R, TIncrement<Indexer>, [...Acc, Indexer]>
     : Acc
 // prettier-ignore
-function FromTuple<T extends TSchema[]>(T: [...T]): TFromTuple<T> {
-  return T.map((_, I) => I.toString()) as never
+function FromTuple<Types extends TSchema[]>(types: [...Types]): TFromTuple<Types> {
+  return types.map((_, indexer) => indexer.toString()) as never
 }
 // ------------------------------------------------------------------
 // FromArray
@@ -114,11 +112,11 @@ function FromArray<_ extends TSchema>(_: _): TFromArray<_> {
 // FromProperties
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromProperties<T extends TProperties> = (
-  UnionToTuple<keyof T>
+type TFromProperties<Properties extends TProperties> = (
+  UnionToTuple<keyof Properties>
 )
 // prettier-ignore
-function FromProperties<T extends TProperties>(T: T): TFromProperties<T> {
+function FromProperties<Properties extends TProperties>(T: Properties): TFromProperties<Properties> {
   return (
     globalThis.Object.getOwnPropertyNames(T)
   ) as never
@@ -140,25 +138,25 @@ function FromPatternProperties(patternProperties: Record<PropertyKey, TSchema>):
 // KeyOfPropertyKeys
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TKeyOfPropertyKeys<T extends TSchema> = (
-  T extends TRecursive<infer S> ? TKeyOfPropertyKeys<S> :
-  T extends TIntersect<infer S> ? TFromIntersect<S> :
-  T extends TUnion<infer S> ? TFromUnion<S> :
-  T extends TTuple<infer S> ? TFromTuple<S> :
-  T extends TArray<infer S> ? TFromArray<S> :
-  T extends TObject<infer S> ? TFromProperties<S> :
+export type TKeyOfPropertyKeys<Type extends TSchema> = (
+  Type extends TRecursive<infer Type extends TSchema> ? TKeyOfPropertyKeys<Type> :
+  Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> :
+  Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> :
+  Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> :
+  Type extends TArray<infer Type extends TSchema> ? TFromArray<Type> :
+  Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Properties> :
   []
 )
 /** Returns a tuple of PropertyKeys derived from the given TSchema. */
 // prettier-ignore
-export function KeyOfPropertyKeys<T extends TSchema>(T: T): TKeyOfPropertyKeys<T> {
+export function KeyOfPropertyKeys<Type extends TSchema>(type: Type): TKeyOfPropertyKeys<Type> {
   return (
-    IsIntersect(T) ? FromIntersect(T.allOf) :
-    IsUnion(T) ? FromUnion(T.anyOf) :
-    IsTuple(T) ? FromTuple(T.items ?? []) :
-    IsArray(T) ? FromArray(T.items) :
-    IsObject(T) ? FromProperties(T.properties) :
-    IsRecord(T) ? FromPatternProperties(T.patternProperties) :
+    IsIntersect(type) ? FromIntersect(type.allOf) :
+    IsUnion(type) ? FromUnion(type.anyOf) :
+    IsTuple(type) ? FromTuple(type.items ?? []) :
+    IsArray(type) ? FromArray(type.items) :
+    IsObject(type) ? FromProperties(type.properties) :
+    IsRecord(type) ? FromPatternProperties(type.patternProperties) :
     []
   ) as never
 }
diff --git a/src/type/keyof/keyof.ts b/src/type/keyof/keyof.ts
index 2e4c42df6..fbd20df62 100644
--- a/src/type/keyof/keyof.ts
+++ b/src/type/keyof/keyof.ts
@@ -33,6 +33,8 @@ import type { TMappedResult } from '../mapped/index'
 import type { SchemaOptions } from '../schema/index'
 import { Literal, type TLiteral, type TLiteralValue } from '../literal/index'
 import { Number, type TNumber } from '../number/index'
+import { Computed, TComputed } from '../computed/index'
+import { Ref, type TRef } from '../ref/index'
 import { KeyOfPropertyKeys, type TKeyOfPropertyKeys } from './keyof-property-keys'
 import { UnionEvaluated, type TUnionEvaluated } from '../union/index'
 import { KeyOfFromMappedResult, type TKeyOfFromMappedResult } from './keyof-from-mapped-result'
@@ -40,46 +42,72 @@ import { KeyOfFromMappedResult, type TKeyOfFromMappedResult } from './keyof-from
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult } from '../guard/kind'
+import { IsMappedResult, IsRef, IsComputed } from '../guard/kind'
+// ------------------------------------------------------------------
+// FromComputed
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<
+  TComputed<'KeyOf', [TComputed<Target, Parameters>]>
+>
+// prettier-ignore
+function FromComputed<Target extends string, Parameters extends TSchema[]>(target: Target, parameters: Parameters): TFromComputed<Target, Parameters> {
+  return Computed('KeyOf', [Computed(target, parameters)]) as never
+}
+// ------------------------------------------------------------------
+// FromRef
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRef<Ref extends string> = Ensure<
+  TComputed<'KeyOf', [TRef<Ref>]>
+>
+// prettier-ignore
+function FromRef<Ref extends string>($ref: Ref): TFromRef<Ref> {
+  return Computed('KeyOf', [Ref($ref)]) as never
+}
+// ------------------------------------------------------------------
+// KeyOfFromType
+// ------------------------------------------------------------------
+// prettier-ignore
+/** `[Internal]` Used by KeyOfFromMappedResult */
+export type TKeyOfFromType<Type extends TSchema, 
+  PropertyKeys extends PropertyKey[] = TKeyOfPropertyKeys<Type>,
+  PropertyKeyTypes extends TSchema[] = TKeyOfPropertyKeysToRest<PropertyKeys>,
+  Result = TUnionEvaluated<PropertyKeyTypes>
+> = Ensure<Result>
+// prettier-ignore
+function KeyOfFromType<Type extends TSchema>(type: Type, options?: SchemaOptions): TKeyOfFromType<Type> {
+  const propertyKeys = KeyOfPropertyKeys(type) as PropertyKey[]
+  const propertyKeyTypes = KeyOfPropertyKeysToRest(propertyKeys)
+  const result = UnionEvaluated(propertyKeyTypes)
+  return CreateType(result, options) as never
+}
 // ------------------------------------------------------------------
 // FromPropertyKeys
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TKeyOfPropertyKeysToRest<T extends PropertyKey[], Acc extends TSchema[] = []> = (
-  T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+export type TKeyOfPropertyKeysToRest<PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = (
+  PropertyKeys extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
     ? L extends '[number]'
-      ? TKeyOfPropertyKeysToRest<R, [...Acc, TNumber]>
-      : TKeyOfPropertyKeysToRest<R, [...Acc, TLiteral<Assert<L, TLiteralValue>>]>
-    : Acc
+      ? TKeyOfPropertyKeysToRest<R, [...Result, TNumber]>
+      : TKeyOfPropertyKeysToRest<R, [...Result, TLiteral<Assert<L, TLiteralValue>>]>
+    : Result
 )
 // prettier-ignore
-export function KeyOfPropertyKeysToRest<T extends PropertyKey[]>(T: [...T]): TKeyOfPropertyKeysToRest<T> {
-  return T.map(L => L === '[number]' ? Number() : Literal(L as TLiteralValue)) as never
+export function KeyOfPropertyKeysToRest<PropertyKeys extends PropertyKey[]>(propertyKeys: [...PropertyKeys]): TKeyOfPropertyKeysToRest<PropertyKeys> {
+  return propertyKeys.map(L => L === '[number]' ? Number() : Literal(L as TLiteralValue)) as never
 }
 // ------------------------------------------------------------------
-// KeyOfTypeResolve
+// TKeyOf
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TKeyOf<
-  T extends TSchema, 
-  K extends PropertyKey[] = TKeyOfPropertyKeys<T>,
-  S extends TSchema[] = TKeyOfPropertyKeysToRest<K>,
-  U = TUnionEvaluated<S>
-> = (
-  Ensure<U>
+export type TKeyOf<Type extends TSchema> = (
+  Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> :
+  Type extends TRef<infer Ref extends string> ? TFromRef<Ref> :
+  Type extends TMappedResult ? TKeyOfFromMappedResult<Type> :
+  TKeyOfFromType<Type>
 )
 /** `[Json]` Creates a KeyOf type */
-export function KeyOf<T extends TMappedResult>(T: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>
-/** `[Json]` Creates a KeyOf type */
-export function KeyOf<T extends TSchema>(T: T, options?: SchemaOptions): TKeyOf<T>
-/** `[Json]` Creates a KeyOf type */
-export function KeyOf(T: TSchema, options?: SchemaOptions): never {
-  if (IsMappedResult(T)) {
-    return KeyOfFromMappedResult(T, options) as never
-  } else {
-    const K = KeyOfPropertyKeys(T)
-    const S = KeyOfPropertyKeysToRest(K)
-    const U = UnionEvaluated(S)
-    return CreateType(U, options) as never
-  }
+export function KeyOf<Type extends TSchema>(type: Type, options?: SchemaOptions): TKeyOf<Type> {
+  return (IsComputed(type) ? FromComputed(type.target, type.parameters) : IsRef(type) ? FromRef(type.$ref) : IsMappedResult(type) ? KeyOfFromMappedResult(type, options) : KeyOfFromType(type, options)) as never
 }
diff --git a/src/type/module/compute.ts b/src/type/module/compute.ts
new file mode 100644
index 000000000..47bf60851
--- /dev/null
+++ b/src/type/module/compute.ts
@@ -0,0 +1,402 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { CreateType } from '../create/index'
+import { Ensure, Evaluate } from '../helpers/index'
+import { type TSchema } from '../schema/index'
+import { Array, type TArray } from '../array/index'
+import { Awaited, type TAwaited } from '../awaited/index'
+import { AsyncIterator, type TAsyncIterator } from '../async-iterator/index'
+import { TComputed } from '../computed/index'
+import { Constructor, type TConstructor } from '../constructor/index'
+import { Index, type TIndex } from '../indexed/index'
+import { Function, type TFunction } from '../function/index'
+import { Intersect, type TIntersect, type TIntersectEvaluated } from '../intersect/index'
+import { Iterator, type TIterator } from '../iterator/index'
+import { KeyOf, type TKeyOf } from '../keyof/index'
+import { Object, type TObject, type TProperties } from '../object/index'
+import { Omit, type TOmit } from '../omit/index'
+import { Pick, type TPick } from '../pick/index'
+import { Never, type TNever } from '../never/index'
+import { Partial, TPartial } from '../partial/index'
+import { Record, type TRecordOrObject } from '../record/index'
+import { type TRef } from '../ref/index'
+import { Required, TRequired } from '../required/index'
+import { Tuple, type TTuple } from '../tuple/index'
+import { Union, type TUnion, type TUnionEvaluated } from '../union/index'
+
+// ------------------------------------------------------------------
+// KindGuard
+// ------------------------------------------------------------------
+import * as KindGuard from '../guard/kind'
+
+// ------------------------------------------------------------------
+// DerefParameters
+//
+// Dereferences TComputed parameters. It is important to note that
+// dereferencing anything other than these parameters may result
+// inference and evaluation problems, potentially resulting in a
+// stack overflow. All open TRef types must be preserved !!!
+//
+// ------------------------------------------------------------------
+// prettier-ignore
+type TDerefParameters<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
+    ? Left extends TRef<infer Key extends string>
+      ? TDerefParameters<ModuleProperties, Right, [...Result, TDeref<ModuleProperties, Key>]>
+      : TDerefParameters<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]>
+    : Result
+)
+// prettier-ignore
+function DerefParameters<ModuleProperties extends TProperties, Types extends TSchema[]>(moduleProperties: ModuleProperties, types: [...Types]): TFromRest<ModuleProperties, Types> {
+  return types.map((type) => {
+    return KindGuard.IsRef(type)
+      ? Deref(moduleProperties, type.$ref)
+      : FromType(moduleProperties, type)
+  }) as never
+}
+// prettier-ignore
+type TDeref<ModuleProperties extends TProperties, Ref extends string, Result extends TSchema = (
+  Ref extends keyof ModuleProperties
+    ? ModuleProperties[Ref] extends TRef<infer Ref2 extends string> 
+      ? TDeref<ModuleProperties, Ref2>
+      : TFromType<ModuleProperties, ModuleProperties[Ref]>
+    : TNever
+)> = Result
+// prettier-ignore
+function Deref<ModuleProperties extends TProperties, Ref extends string>(moduleProperties: ModuleProperties, ref: Ref): TDeref<ModuleProperties, Ref> {
+  return (
+    ref in moduleProperties 
+      ? KindGuard.IsRef(moduleProperties[ref])
+        ? Deref(moduleProperties, moduleProperties[ref].$ref)
+        : FromType(moduleProperties, moduleProperties[ref])
+      : Never()
+  ) as never
+}
+// ------------------------------------------------------------------
+// Awaited
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromAwaited<Parameters extends TSchema[]> = (
+  Parameters extends [infer T0 extends TSchema] ? TAwaited<T0> : never
+)
+// prettier-ignore
+function FromAwaited<Parameters extends TSchema[]>(parameters: Parameters): TFromAwaited<Parameters> {
+  return Awaited(parameters[0]) as never
+}
+// ------------------------------------------------------------------
+// Index
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromIndex<Parameters extends TSchema[]> = (
+  Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TIndex<T0, T1> : never
+)
+// prettier-ignore
+function FromIndex<Parameters extends TSchema[]>(parameters: Parameters): TFromIndex<Parameters> {
+  return Index(parameters[0], parameters[1]) as never
+}
+// ------------------------------------------------------------------
+// KeyOf
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromKeyOf<Parameters extends TSchema[]> = (
+  Parameters extends [infer T0 extends TSchema] ? TKeyOf<T0> : never
+)
+// prettier-ignore
+function FromKeyOf<Parameters extends TSchema[]>(parameters: Parameters): TFromAwaited<Parameters> {
+  return KeyOf(parameters[0]) as never
+}
+// ------------------------------------------------------------------
+// Partial
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromPartial<Parameters extends TSchema[]> = (
+  Parameters extends [infer T0 extends TSchema] ? TPartial<T0> : never
+)
+// prettier-ignore
+function FromPartial<Parameters extends TSchema[]>(parameters: Parameters): TFromPartial<Parameters> {
+  return Partial(parameters[0]) as never
+}
+// ------------------------------------------------------------------
+// Omit
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromOmit<Parameters extends TSchema[]> = (
+  Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TOmit<T0, T1> : never
+)
+// prettier-ignore
+function FromOmit<Parameters extends TSchema[]>(parameters: Parameters): TFromPick<Parameters> {
+  return Omit(parameters[0], parameters[1]) as never
+}
+// ------------------------------------------------------------------
+// Pick
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromPick<Parameters extends TSchema[]> = (
+  Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TPick<T0, T1> : never
+)
+// prettier-ignore
+function FromPick<Parameters extends TSchema[]>(parameters: Parameters): TFromPick<Parameters> {
+  return Pick(parameters[0], parameters[1]) as never
+}
+// ------------------------------------------------------------------
+// Record
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRecord<Parameters extends TSchema[]> = (
+  Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TRecordOrObject<T0, T1> : never
+)
+// prettier-ignore
+function FromRecord<Parameters extends TSchema[]>(parameters: Parameters): TFromPick<Parameters> {
+  return Record(parameters[0], parameters[1]) as never
+}
+// ------------------------------------------------------------------
+// Required
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRequired<Parameters extends TSchema[]> = (
+  Parameters extends [infer T0 extends TSchema] ? TRequired<T0> : never
+)
+// prettier-ignore
+function FromRequired<Parameters extends TSchema[]>(parameters: Parameters): TFromPick<Parameters> {
+  return Required(parameters[0]) as never
+}
+// ------------------------------------------------------------------
+// Computed
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromComputed<ModuleProperties extends TProperties, Target extends string, Parameters extends TSchema[],
+  Dereferenced extends TSchema[] = TDerefParameters<ModuleProperties, Parameters>
+> = (
+  Target extends 'Awaited' ? TFromAwaited<Dereferenced> :
+  Target extends 'Index' ? TFromIndex<Dereferenced> :
+  Target extends 'KeyOf' ? TFromKeyOf<Dereferenced> :
+  Target extends 'Partial' ? TFromPartial<Dereferenced> :
+  Target extends 'Omit' ? TFromOmit<Dereferenced> :
+  Target extends 'Pick' ? TFromPick<Dereferenced> :
+  Target extends 'Record' ? TFromRecord<Dereferenced> :
+  Target extends 'Required' ? TFromRequired<Dereferenced> :
+  TNever
+)
+// prettier-ignore
+function FromComputed<ModuleProperties extends TProperties, Target extends string, Parameters extends TSchema[]>(moduleProperties: ModuleProperties, target: Target, parameters: Parameters): TFromComputed<ModuleProperties, Target, Parameters> {
+  const dereferenced = DerefParameters(moduleProperties, parameters)
+  return (
+    target === 'Awaited' ? FromAwaited(dereferenced) :
+    target === 'Index' ? FromIndex(dereferenced) :
+    target === 'KeyOf' ? FromKeyOf(dereferenced) :
+    target === 'Partial' ? FromPartial(dereferenced) :
+    target === 'Omit' ? FromOmit(dereferenced) :
+    target === 'Pick' ? FromPick(dereferenced) :
+    target === 'Record' ? FromRecord(dereferenced) :
+    target === 'Required' ? FromRequired(dereferenced) :
+    Never()
+  ) as never
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromObject<ModuleProperties extends TProperties, Properties extends TProperties> = Ensure<TObject<Evaluate<{ 
+  [Key in keyof Properties]: TFromType<ModuleProperties, Properties[Key]>
+}>>>
+function FromObject<ModuleProperties extends TProperties, Properties extends TProperties>(moduleProperties: ModuleProperties, properties: Properties): TFromObject<ModuleProperties, Properties> {
+  return Object(
+    globalThis.Object.keys(properties).reduce((result, key) => {
+      return { ...result, [key]: FromType(moduleProperties, properties[key]) as never }
+    }, {} as TProperties),
+  ) as never
+}
+// ------------------------------------------------------------------
+// Constructor
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromConstructor<ModuleProperties extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema> = (
+  TConstructor<TFromRest<ModuleProperties, Parameters>, TFromType<ModuleProperties, InstanceType>>
+)
+// prettier-ignore
+function FromConstructor<ModuleProperties extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema>(
+  moduleProperties: ModuleProperties,
+  parameters: [...Parameters],
+  instanceType: InstanceType,
+): TFromConstructor<ModuleProperties, Parameters, InstanceType> {
+  return Constructor(FromRest(moduleProperties, parameters as never), FromType(moduleProperties, instanceType) as never) as never
+}
+// ------------------------------------------------------------------
+// Function
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromFunction<ModuleProperties extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema> = Ensure<
+  Ensure<TFunction<TFromRest<ModuleProperties, Parameters>, TFromType<ModuleProperties, ReturnType>>>
+>
+// prettier-ignore
+function FromFunction<ModuleProperties extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema>(
+  moduleProperties: ModuleProperties,
+  parameters: [...Parameters],
+  returnType: ReturnType,
+): TFromFunction<ModuleProperties, Parameters, ReturnType> {
+  return Function(FromRest(moduleProperties, parameters as never), FromType(moduleProperties, returnType) as never) as never
+}
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromTuple<ModuleProperties extends TProperties, Types extends TSchema[]> = (
+  Ensure<TTuple<TFromRest<ModuleProperties, Types>>>
+)
+function FromTuple<ModuleProperties extends TProperties, Types extends TSchema[]>(moduleProperties: ModuleProperties, types: [...Types]): TFromTuple<ModuleProperties, Types> {
+  return Tuple(FromRest(moduleProperties, types as never)) as never
+}
+// ------------------------------------------------------------------
+// Intersect
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromIntersect<ModuleProperties extends TProperties, Types extends TSchema[]> = (
+  Ensure<TIntersectEvaluated<TFromRest<ModuleProperties, Types>>>
+)
+function FromIntersect<ModuleProperties extends TProperties, Types extends TSchema[]>(moduleProperties: ModuleProperties, types: [...Types]): TFromIntersect<ModuleProperties, Types> {
+  return Intersect(FromRest(moduleProperties, types as never)) as never
+}
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromUnion<ModuleProperties extends TProperties, Types extends TSchema[]> = (
+  Ensure<TUnionEvaluated<TFromRest<ModuleProperties, Types>>>
+)
+function FromUnion<ModuleProperties extends TProperties, Types extends TSchema[]>(moduleProperties: ModuleProperties, types: [...Types]): TFromUnion<ModuleProperties, Types> {
+  return Union(FromRest(moduleProperties, types as never)) as never
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromArray<ModuleProperties extends TProperties, Type extends TSchema> = (
+  Ensure<TArray<TFromType<ModuleProperties, Type>>>
+)
+function FromArray<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromArray<ModuleProperties, Type> {
+  return Array(FromType(moduleProperties, type))
+}
+// ------------------------------------------------------------------
+// AsyncIterator
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema> = (
+  TAsyncIterator<TFromType<ModuleProperties, Type>>
+)
+function FromAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromAsyncIterator<ModuleProperties, Type> {
+  return AsyncIterator(FromType(moduleProperties, type))
+}
+// ------------------------------------------------------------------
+// Iterator
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromIterator<ModuleProperties extends TProperties, Type extends TSchema> = (
+  TIterator<TFromType<ModuleProperties, Type>>
+)
+function FromIterator<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromIterator<ModuleProperties, Type> {
+  return Iterator(FromType(moduleProperties, type))
+}
+// ------------------------------------------------------------------
+// Rest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRest<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
+    ? TFromRest<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]>
+    : Result
+)
+function FromRest<ModuleProperties extends TProperties, Types extends TSchema[]>(moduleProperties: ModuleProperties, types: [...Types]): TFromRest<ModuleProperties, Types> {
+  return types.map((type) => FromType(moduleProperties, type)) as never
+}
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (
+  Type extends TComputed<infer T extends string, infer S extends TSchema[]> ? TFromComputed<ModuleProperties, T, S> :
+  Type extends TObject<infer S extends TProperties> ? TFromObject<ModuleProperties, S> :
+  Type extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TFromConstructor<ModuleProperties, S, R> :
+  Type extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFromFunction<ModuleProperties, S, R> :
+  Type extends TTuple<infer S extends TSchema[]> ? TFromTuple<ModuleProperties, S> :
+  Type extends TIntersect<infer S extends TSchema[]> ? TFromIntersect<ModuleProperties, S> :
+  Type extends TUnion<infer S extends TSchema[]> ? TFromUnion<ModuleProperties, S> :
+  Type extends TArray<infer S extends TSchema> ? TFromArray<ModuleProperties, S> :
+  Type extends TAsyncIterator<infer S extends TSchema> ? TFromAsyncIterator<ModuleProperties, S> :
+  Type extends TIterator<infer S extends TSchema> ? TFromIterator<ModuleProperties, S> :
+  Type
+)
+// prettier-ignore
+export function FromType<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromType<ModuleProperties, Type> {
+  return (
+    // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
+    // all need re-implementation to remove the PropertyKey[] selector. Reimplementation of these types should
+    // be a priority as there is a potential for the current inference to break on TS compiler changes.
+    KindGuard.IsComputed(type) ? CreateType(FromComputed(moduleProperties, type.target, type.parameters) as never) :
+    KindGuard.IsObject(type) ? CreateType(FromObject(moduleProperties, type.properties), type) :
+    KindGuard.IsConstructor(type) ? CreateType(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
+    KindGuard.IsFunction(type) ? CreateType(FromFunction(moduleProperties, type.parameters, type.returns), type) :
+    KindGuard.IsTuple(type)? CreateType(FromTuple(moduleProperties, type.items || []), type) :
+    KindGuard.IsIntersect(type) ? CreateType(FromIntersect(moduleProperties, type.allOf), type) :
+    KindGuard.IsUnion(type) ? CreateType(FromUnion(moduleProperties, type.anyOf), type) :
+    KindGuard.IsArray(type) ? CreateType(FromArray(moduleProperties, type.items), type) :
+    KindGuard.IsAsyncIterator(type) ? CreateType(FromAsyncIterator(moduleProperties, type.items), type) :
+    KindGuard.IsIterator(type) ? CreateType(FromIterator(moduleProperties, type.items), type) :
+    type
+  ) as never
+}
+// ------------------------------------------------------------------
+// ComputeType
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TComputeType<ModuleProperties extends TProperties, Key extends PropertyKey> = (
+  Key extends keyof ModuleProperties 
+    ? TFromType<ModuleProperties, ModuleProperties[Key]> 
+    : TNever
+)
+// prettier-ignore
+export function ComputeType<ModuleProperties extends TProperties, Key extends PropertyKey>(moduleProperties: ModuleProperties, key: Key): TComputeType<ModuleProperties, Key> {
+  return (
+    key in moduleProperties 
+      ? FromType(moduleProperties, moduleProperties[key as keyof ModuleProperties])
+      : Never()
+  ) as never
+}
+// ------------------------------------------------------------------
+// ComputeModuleProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TComputeModuleProperties<ModuleProperties extends TProperties> = Evaluate<{
+  [Key in keyof ModuleProperties]: TComputeType<ModuleProperties, Key>
+}>
+// prettier-ignore
+export function ComputeModuleProperties<ModuleProperties extends TProperties>(moduleProperties: ModuleProperties): TComputeModuleProperties<ModuleProperties> {
+  return globalThis.Object.getOwnPropertyNames(moduleProperties).reduce((result, key) => {
+    return {...result, [key]: ComputeType(moduleProperties, key) }
+  }, {} as TProperties) as never
+}
diff --git a/src/type/module/infer.ts b/src/type/module/infer.ts
new file mode 100644
index 000000000..082b7f733
--- /dev/null
+++ b/src/type/module/infer.ts
@@ -0,0 +1,162 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Ensure, Evaluate } from '../helpers/index'
+import { TSchema } from '../schema/index'
+import { TArray } from '../array/index'
+import { TAsyncIterator } from '../async-iterator/index'
+import { TConstructor } from '../constructor/index'
+import { TFunction } from '../function/index'
+import { TIntersect } from '../intersect/index'
+import { TIterator } from '../iterator/index'
+import { TObject, TProperties } from '../object/index'
+import { TOptional } from '../optional/index'
+import { TReadonly } from '../readonly/index'
+import { TRef } from '../ref/index'
+import { TTuple } from '../tuple/index'
+import { TUnion } from '../union/index'
+import { Static } from '../static/index'
+
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+// prettier-ignore
+type TInferArray<ModuleProperties extends TProperties, Type extends TSchema> = (
+  Ensure<Array<TInfer<ModuleProperties, Type>>>
+)
+// ------------------------------------------------------------------
+// AsyncIterator
+// ------------------------------------------------------------------
+// prettier-ignore
+type TInferAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema> = (
+  Ensure<AsyncIterableIterator<TInfer<ModuleProperties, Type>>>
+)
+// ------------------------------------------------------------------
+// Constructor
+// ------------------------------------------------------------------
+// prettier-ignore
+type TInferConstructor<ModuleProperties extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema,> = Ensure<
+  new (...args: TInferTuple<ModuleProperties, Parameters>) => TInfer<ModuleProperties, InstanceType>
+>
+// ------------------------------------------------------------------
+// Function
+// ------------------------------------------------------------------
+// prettier-ignore
+type TInferFunction<ModuleProperties extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema> = Ensure<
+  (...args: TInferTuple<ModuleProperties, Parameters>) => TInfer<ModuleProperties, ReturnType>
+>
+// ------------------------------------------------------------------
+// Iterator
+// ------------------------------------------------------------------
+// prettier-ignore
+type TInferIterator<ModuleProperties extends TProperties, Type extends TSchema> = (
+  Ensure<IterableIterator<TInfer<ModuleProperties, Type>>>
+)
+// ------------------------------------------------------------------
+// Intersect
+// ------------------------------------------------------------------
+// prettier-ignore
+type TInferIntersect<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown = unknown> = (
+  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TInferIntersect<ModuleProperties, R, Result & TInfer<ModuleProperties, L>>
+    : Result
+)
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+type ReadonlyOptionalPropertyKeys<Properties extends TProperties> = { [K in keyof Properties]: Properties[K] extends TReadonly<TSchema> ? (Properties[K] extends TOptional<Properties[K]> ? K : never) : never }[keyof Properties]
+type ReadonlyPropertyKeys<Source extends TProperties> = { [K in keyof Source]: Source[K] extends TReadonly<TSchema> ? (Source[K] extends TOptional<Source[K]> ? never : K) : never }[keyof Source]
+type OptionalPropertyKeys<Source extends TProperties> = { [K in keyof Source]: Source[K] extends TOptional<TSchema> ? (Source[K] extends TReadonly<Source[K]> ? never : K) : never }[keyof Source]
+type RequiredPropertyKeys<Source extends TProperties> = keyof Omit<Source, ReadonlyOptionalPropertyKeys<Source> | ReadonlyPropertyKeys<Source> | OptionalPropertyKeys<Source>>
+// prettier-ignore
+type InferPropertiesWithModifiers<Properties extends TProperties, Source extends Record<keyof any, unknown>> = Evaluate<(
+  Readonly<Partial<Pick<Source, ReadonlyOptionalPropertyKeys<Properties>>>> &
+  Readonly<Pick<Source, ReadonlyPropertyKeys<Properties>>> &
+  Partial<Pick<Source, OptionalPropertyKeys<Properties>>> &
+  Required<Pick<Source, RequiredPropertyKeys<Properties>>>
+)>
+// prettier-ignore
+type InferProperties<ModuleProperties extends TProperties, Properties extends TProperties> = InferPropertiesWithModifiers<Properties, {
+  [K in keyof Properties]: TInfer<ModuleProperties, Properties[K]>
+}>
+// prettier-ignore
+type TInferObject<ModuleProperties extends TProperties, Properties extends TProperties> = (
+  InferProperties<ModuleProperties, Properties>
+)
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+type TInferTuple<ModuleProperties extends TProperties, Types extends TSchema[] , Result extends unknown[] = []> = (
+  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TInferTuple<ModuleProperties, R, [...Result, TInfer<ModuleProperties, L>]>
+    : Result
+)
+// ------------------------------------------------------------------
+// Ref
+// ------------------------------------------------------------------
+// prettier-ignore
+type TInferRef<ModuleProperties extends TProperties, Ref extends string> = (
+  Ref extends keyof ModuleProperties ? TInfer<ModuleProperties, ModuleProperties[Ref]> : unknown
+)
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// prettier-ignore
+type TInferUnion<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown = never> = (
+  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TInferUnion<ModuleProperties, R, Result | TInfer<ModuleProperties, L>>
+    : Result
+)
+// ------------------------------------------------------------------
+// Infer
+// ------------------------------------------------------------------
+// prettier-ignore
+type TInfer<ModuleProperties extends TProperties, Type extends TSchema> = (
+  Type extends TArray<infer Type extends TSchema> ? TInferArray<ModuleProperties, Type> :
+  Type extends TAsyncIterator<infer Type extends TSchema> ? TInferAsyncIterator<ModuleProperties, Type> :
+  Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TInferConstructor<ModuleProperties, Parameters, InstanceType> :
+  Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TInferFunction<ModuleProperties, Parameters, ReturnType> :
+  Type extends TIntersect<infer Types extends TSchema[]> ? TInferIntersect<ModuleProperties, Types> :
+  Type extends TIterator<infer Type extends TSchema> ? TInferIterator<ModuleProperties, Type> :
+  Type extends TObject<infer Properties extends TProperties> ? TInferObject<ModuleProperties, Properties> :
+  Type extends TRef<infer Ref extends string> ? TInferRef<ModuleProperties, Ref> :
+  Type extends TTuple<infer Types extends TSchema[]> ? TInferTuple<ModuleProperties, Types> :
+  Type extends TUnion<infer Types extends TSchema[]> ? TInferUnion<ModuleProperties, Types> :
+  Static<Type>
+)
+// ------------------------------------------------------------------
+// InferFromModuleKey
+// ------------------------------------------------------------------
+/** Inference Path for Imports. This type is used to compute TImport `static` */
+// prettier-ignore
+export type TInferFromModuleKey<ModuleProperties extends TProperties, Key extends PropertyKey> = (
+  Key extends keyof ModuleProperties
+    ? TInfer<ModuleProperties, ModuleProperties[Key]>
+    : never
+)
diff --git a/src/type/module/module.ts b/src/type/module/module.ts
index 3fef83c80..a4c2544e9 100644
--- a/src/type/module/module.ts
+++ b/src/type/module/module.ts
@@ -26,124 +26,18 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { Ensure } from '../helpers/index'
 import { CreateType } from '../create/index'
 import { Kind } from '../symbols/index'
 import { SchemaOptions, TSchema } from '../schema/index'
-import { TObject, TProperties } from '../object/index'
-import { TConstructor } from '../constructor/index'
-import { TFunction } from '../function/index'
-import { TTuple } from '../tuple/index'
-import { TIntersect } from '../intersect/index'
-import { TUnion } from '../union/index'
-import { TArray } from '../array/index'
-import { TAsyncIterator } from '../async-iterator/index'
-import { TIterator } from '../iterator/index'
-import { TLiteral, TLiteralValue } from '../literal/index'
-import { TAny } from '../any/index'
-import { TBigInt } from '../bigint/index'
-import { TBoolean } from '../boolean/index'
-import { TDate } from '../date/index'
-import { TInteger } from '../integer/index'
-import { TNever } from '../never/index'
-import { TNumber } from '../number/index'
-import { TNull } from '../null/index'
-import { TRef } from '../ref/index'
-import { TRegExp } from '../regexp/index'
-import { TString } from '../string/index'
-import { TSymbol } from '../symbol/index'
-import { TTemplateLiteral, TTemplateLiteralKind } from '../template-literal/index'
-import { TUint8Array } from '../uint8array/index'
-import { TUndefined } from '../undefined/index'
-import { TUnknown } from '../unknown/index'
-import { TVoid } from '../void/index'
+import { TProperties } from '../object/index'
 import { Static } from '../static/index'
 
 // ------------------------------------------------------------------
-// Infer
+// Module Infrastructure Types
 // ------------------------------------------------------------------
-// prettier-ignore
-type InferImport<Properties extends TProperties, Key extends keyof Properties, ModuleProperties extends TProperties> = (
-  Infer<Properties[Key], ModuleProperties>
-)
-// prettier-ignore
-type InferRef<Ref extends string, Properties extends TProperties> = (
-  Ref extends keyof Properties ? Infer<Properties[Ref], Properties> : never
-)
-// prettier-ignore
-type InferObject<Properties extends TProperties, ModuleProperties extends TProperties> = { 
-  [K in keyof Properties]: Infer<Properties[K], ModuleProperties> 
-} & {}
-// prettier-ignore
-type InferConstructor<Parameters extends TSchema[], InstanceType extends TSchema, Properties extends TProperties> = Ensure<
-  new (...args: InferTuple<Parameters, Properties>) => Infer<InstanceType, Properties>
->
-// prettier-ignore
-type InferFunction<Parameters extends TSchema[], ReturnType extends TSchema, Properties extends TProperties> = Ensure<
-  (...args: InferTuple<Parameters, Properties>) => Infer<ReturnType, Properties>
->
-// prettier-ignore
-type InferTuple<Types extends TSchema[], Properties extends TProperties, Result extends unknown[] = []> = (
-  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? InferTuple<R, Properties, [...Result, Infer<L, Properties>]>
-    : Result
-)
-// prettier-ignore
-type InferIntersect<Types extends TSchema[], Properties extends TProperties, Result extends unknown = unknown> = (
-  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? InferIntersect<R, Properties, Result & Infer<L, Properties>>
-    : Result
-)
-// prettier-ignore
-type InferUnion<Types extends TSchema[], Properties extends TProperties, Result extends unknown = never> = (
-  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? InferUnion<R, Properties, Result | Infer<L, Properties>>
-    : Result
-)
-// prettier-ignore
-type InferArray<Type extends TSchema, Module extends TProperties> = (
-  Ensure<Array<Infer<Type, Module>>>
-)
-// prettier-ignore
-type InferAsyncIterator<Type extends TSchema, Properties extends TProperties> = (
-  Ensure<AsyncIterableIterator<Infer<Type, Properties>>>
-)
-// prettier-ignore
-type InferIterator<Type extends TSchema, Properties extends TProperties> = (
-  Ensure<IterableIterator<Infer<Type, Properties>>>
-)
-// prettier-ignore
-type Infer<Type extends TSchema, Properties extends TProperties = {}> = (
-  Type extends TImport<infer S extends TProperties, infer K extends string> ? InferImport<S, K, S> :
-  Type extends TRef<infer S extends string> ? InferRef<S, Properties> :
-  Type extends TObject<infer S extends TProperties> ? InferObject<S, Properties> :
-  Type extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? InferConstructor<S, R, Properties> :
-  Type extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? InferFunction<S, R, Properties> :
-  Type extends TTuple<infer S extends TSchema[]> ? InferTuple<S, Properties> :
-  Type extends TIntersect<infer S extends TSchema[]> ? InferIntersect<S, Properties> :
-  Type extends TUnion<infer S extends TSchema[]> ? InferUnion<S, Properties> :
-  Type extends TArray<infer S extends TSchema> ? InferArray<S, Properties> :
-  Type extends TAsyncIterator<infer S extends TSchema> ? InferAsyncIterator<S, Properties> :
-  Type extends TIterator<infer S extends TSchema> ? InferIterator<S, Properties> :
-  Type extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? Static<TTemplateLiteral<S>> :
-  Type extends TLiteral<infer S extends TLiteralValue> ? S :
-  Type extends TAny ? any :
-  Type extends TBigInt ? bigint :
-  Type extends TBoolean ? boolean :
-  Type extends TDate ? Date :
-  Type extends TInteger ? number :
-  Type extends TNever ? never :
-  Type extends TNumber ? number :
-  Type extends TRegExp ? string :
-  Type extends TString ? string :
-  Type extends TSymbol ? symbol :
-  Type extends TNull ? null :
-  Type extends TUint8Array ? Uint8Array :
-  Type extends TUndefined ? undefined :
-  Type extends TUnknown ? unknown :
-  Type extends TVoid ? void :
-  never
-)
+import { ComputeModuleProperties, TComputeModuleProperties } from './compute'
+import { TInferFromModuleKey } from './infer'
+
 // ------------------------------------------------------------------
 // Definitions
 // ------------------------------------------------------------------
@@ -157,7 +51,7 @@ export interface TDefinitions<ModuleProperties extends TProperties> extends TSch
 // prettier-ignore
 export interface TImport<ModuleProperties extends TProperties = {}, Key extends keyof ModuleProperties = keyof ModuleProperties> extends TSchema {
   [Kind]: 'Import'
-  static: InferImport<ModuleProperties, Key, ModuleProperties>
+  static: TInferFromModuleKey<ModuleProperties, Key>
   $defs: ModuleProperties
   $ref: Key
 }
@@ -165,22 +59,22 @@ export interface TImport<ModuleProperties extends TProperties = {}, Key extends
 // Module
 // ------------------------------------------------------------------
 // prettier-ignore
-export class TModule<Properties extends TProperties> {
-  constructor(private readonly $defs: Properties, private readonly options: SchemaOptions = {}) {}
-  
-  /** `[Json]` Returns the Type definitions for this module */
-  public Defs(): TDefinitions<Properties> {
-    return CreateType({ $defs: this.ResolveDefinitionsWithIdentifiers() }, this.options) as never 
+export class TModule<ModuleProperties extends TProperties, ComputedModuleProperties extends TProperties = TComputeModuleProperties<ModuleProperties>> {
+  private readonly $defs: ComputedModuleProperties
+  constructor($defs: ModuleProperties) {
+    const computed = ComputeModuleProperties($defs)
+    const identified = this.WithIdentifiers(computed as never)
+    this.$defs = identified as never
   }
   /** `[Json]` Imports a Type by Key. */
-  public Import<Key extends keyof Properties>(key: Key, options?: SchemaOptions): TImport<Properties, Key> {
-    return CreateType({ [Kind]: 'Import', $defs: this.ResolveDefinitionsWithIdentifiers(), $ref: key }, options) as never
+  public Import<Key extends keyof ComputedModuleProperties>(key: Key, options?: SchemaOptions): TImport<ComputedModuleProperties, Key> {
+    return CreateType({ [Kind]: 'Import', $defs: this.$defs, $ref: key }, options) as never
   }
-  /** `[Internal]` For each definition, assign an `$id` property. */
-  private ResolveDefinitionsWithIdentifiers() {
-    return globalThis.Object.getOwnPropertyNames(this.$defs).reduce((Result, Key) => (
-      { ...Result, [Key]: { ...this.$defs[Key], $id: Key }}
-    ), {})
+  // prettier-ignore
+  private WithIdentifiers($defs: ComputedModuleProperties): ComputedModuleProperties {
+    return globalThis.Object.getOwnPropertyNames($defs).reduce((result, key) => {
+      return  { ...result, [key]: { ...$defs[key], $id: key }}
+    }, {}) as never
   }
 }
 /** `[Json]` Creates a Type Definition Module. */
diff --git a/src/type/not/not.ts b/src/type/not/not.ts
index 256a3c8eb..eb283dfdf 100644
--- a/src/type/not/not.ts
+++ b/src/type/not/not.ts
@@ -37,6 +37,6 @@ export interface TNot<T extends TSchema = TSchema> extends TSchema {
   not: T
 }
 /** `[Json]` Creates a Not type */
-export function Not<T extends TSchema>(not: T, options?: SchemaOptions): TNot<T> {
-  return CreateType({ [Kind]: 'Not', not }, options) as never
+export function Not<Type extends TSchema>(type: Type, options?: SchemaOptions): TNot<Type> {
+  return CreateType({ [Kind]: 'Not', not: type }, options) as never
 }
diff --git a/src/type/omit/omit-from-mapped-key.ts b/src/type/omit/omit-from-mapped-key.ts
index 5eeb68660..2a2a4ae94 100644
--- a/src/type/omit/omit-from-mapped-key.ts
+++ b/src/type/omit/omit-from-mapped-key.ts
@@ -36,77 +36,52 @@ import { Clone } from '../clone/value'
 // FromPropertyKey
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromPropertyKey<
-  T extends TSchema,
-  K extends PropertyKey,
-> = {
-    [_ in K]: TOmit<T, [K]>
-  }
+type TFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
+  [_ in Key]: TOmit<Type, [Key]>
+}
 // prettier-ignore
-function FromPropertyKey<
-  T extends TSchema,
-  K extends PropertyKey,
->(T: T, K: K, options?: SchemaOptions): TFromPropertyKey<T, K> {
-  return {
-    [K]: Omit(T, [K], Clone(options))
-  } as never
+function FromPropertyKey<Type extends TSchema, Key extends PropertyKey>(type: Type, key: Key, options?: SchemaOptions): TFromPropertyKey<Type, Key> {
+  return { [key]: Omit(type, [key], Clone(options)) } as never
 }
 // ------------------------------------------------------------------
 // FromPropertyKeys
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromPropertyKeys<
-  T extends TSchema,
-  K extends PropertyKey[],
-  Acc extends TProperties = {}
-> = (
-  K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]]
-    ? TFromPropertyKeys<T, RK, Acc & TFromPropertyKey<T, LK>>
-    : Acc
+type TFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TProperties = {}> = (
+  PropertyKeys extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]]
+    ? TFromPropertyKeys<Type, RK, Result & TFromPropertyKey<Type, LK>>
+    : Result
 )
 // prettier-ignore
-function FromPropertyKeys<
-  T extends TSchema,
-  K extends PropertyKey[]
->(T: T, K: [...K], options?: SchemaOptions): TFromPropertyKeys<T, K> {
-  return K.reduce((Acc, LK) => {
-    return { ...Acc, ...FromPropertyKey(T, LK, options) }
+function FromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TFromPropertyKeys<Type, PropertyKeys> {
+  return propertyKeys.reduce((Acc, LK) => {
+    return { ...Acc, ...FromPropertyKey(type, LK, options) }
   }, {} as TProperties) as never
 }
 // ------------------------------------------------------------------
 // FromMappedKey
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromMappedKey<
-  T extends TSchema,
-  K extends TMappedKey,
-> = (
-  TFromPropertyKeys<T, K['keys']>
+type TFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey> = (
+  TFromPropertyKeys<Type, MappedKey['keys']>
 )
 // prettier-ignore
-function FromMappedKey<
-  T extends TSchema,
-  K extends TMappedKey,
->(T: T, K: K, options?: SchemaOptions): TFromMappedKey<T, K> {
-  return FromPropertyKeys(T, K.keys, options) as never
+function FromMappedKey<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TFromMappedKey<Type, MappedKey> {
+  return FromPropertyKeys(type, mappedKey.keys, options) as never
 }
 // ------------------------------------------------------------------
 // OmitFromMappedKey
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TOmitFromMappedKey<
-  T extends TSchema,
-  K extends TMappedKey,
-  P extends TProperties = TFromMappedKey<T, K>
+export type TOmitFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey,
+  Properties extends TProperties = TFromMappedKey<Type, MappedKey>
 > = (
-  TMappedResult<P>
+  TMappedResult<Properties>
 )
 // prettier-ignore
-export function OmitFromMappedKey<
-  T extends TSchema,
-  K extends TMappedKey,
-  P extends TProperties = TFromMappedKey<T, K>
->(T: T, K: K, options?: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedKey(T, K, options)
-  return MappedResult(P) as never
+export function OmitFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey,
+  Properties extends TProperties = TFromMappedKey<Type, MappedKey>
+>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedResult<Properties> {
+  const properties = FromMappedKey(type, mappedKey, options)
+  return MappedResult(properties) as never
 }
diff --git a/src/type/omit/omit-from-mapped-result.ts b/src/type/omit/omit-from-mapped-result.ts
index 205047ea8..5abac5f60 100644
--- a/src/type/omit/omit-from-mapped-result.ts
+++ b/src/type/omit/omit-from-mapped-result.ts
@@ -37,55 +37,43 @@ import { Clone } from '../clone/value'
 // FromProperties
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromProperties<
-  P extends TProperties,
-  K extends PropertyKey[],
-> = (
-  { [K2 in keyof P]: TOmit<P[K2], K> }   
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = (
+  { [K2 in keyof Properties]: TOmit<Properties[K2], PropertyKeys> }   
 )
 // prettier-ignore
-function FromProperties<
-  P extends TProperties,
-  K extends PropertyKey[],
->(P: P, K: [...K], options?: SchemaOptions): TFromProperties<P, K> {
-  const Acc = {} as TProperties
-  for(const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Omit(P[K2], K, Clone(options))
-  return Acc as never
+function FromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[]>(properties: Properties, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TFromProperties<Properties, PropertyKeys> {
+  const result = {} as TProperties
+  for(const K2 of globalThis.Object.getOwnPropertyNames(properties)) result[K2] = Omit(properties[K2], propertyKeys, Clone(options))
+  return result as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromMappedResult<
-  R extends TMappedResult,
-  K extends PropertyKey[],
-> = (
-  Evaluate<TFromProperties<R['properties'], K>>
+type TFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[]> = (
+  Evaluate<TFromProperties<MappedResult['properties'], PropertyKeys>>
 )
 // prettier-ignore
-function FromMappedResult<
-  R extends TMappedResult,
-  K extends PropertyKey[]
->(R: R, K: [...K], options?: SchemaOptions): TFromMappedResult<R, K> {
-  return FromProperties(R.properties, K, options) as never
+function FromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[]>(mappedResult: MappedResult, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TFromMappedResult<MappedResult, PropertyKeys> {
+  return FromProperties(mappedResult.properties, propertyKeys, options) as never
 }
 // ------------------------------------------------------------------
 // TOmitFromMappedResult
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TOmitFromMappedResult<
-  T extends TMappedResult,
-  K extends PropertyKey[],
-  P extends TProperties = TFromMappedResult<T, K>
+  MappedResult extends TMappedResult,
+  PropertyKeys extends PropertyKey[],
+  Properties extends TProperties = TFromMappedResult<MappedResult, PropertyKeys>
 > = (
-  Ensure<TMappedResult<P>>
+  Ensure<TMappedResult<Properties>>
 )
 // prettier-ignore
 export function OmitFromMappedResult<
-  R extends TMappedResult,
-  K extends PropertyKey[],
-  P extends TProperties = TFromMappedResult<R, K>
->(R: R, K: [...K], options?: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedResult(R, K, options)
-  return MappedResult(P) as never
+  MappedResult extends TMappedResult,
+  PropertyKeys extends PropertyKey[],
+  Properties extends TProperties = TFromMappedResult<MappedResult, PropertyKeys>
+>(mappedResult: MappedResult, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TMappedResult<Properties> {
+  const properties = FromMappedResult(mappedResult, propertyKeys, options)
+  return MappedResult(properties) as never
 }
diff --git a/src/type/omit/omit.ts b/src/type/omit/omit.ts
index 99a947706..d52a8b477 100644
--- a/src/type/omit/omit.ts
+++ b/src/type/omit/omit.ts
@@ -28,112 +28,167 @@ THE SOFTWARE.
 
 import { CreateType } from '../create/type'
 import { Discard } from '../discard/discard'
+import { TransformKind } from '../symbols/symbols'
 import type { SchemaOptions, TSchema } from '../schema/index'
 import type { TupleToUnion, Evaluate, Ensure } from '../helpers/index'
 import { type TRecursive } from '../recursive/index'
 import type { TMappedKey, TMappedResult } from '../mapped/index'
+import { Computed, TComputed } from '../computed/index'
+import { Literal, TLiteral, TLiteralValue } from '../literal/index'
+import { IndexPropertyKeys, type TIndexPropertyKeys } from '../indexed/index'
 import { Intersect, type TIntersect } from '../intersect/index'
 import { Union, type TUnion } from '../union/index'
 import { Object, type TObject, type TProperties } from '../object/index'
-import { IndexPropertyKeys, type TIndexPropertyKeys } from '../indexed/index'
+import { type TRef } from '../ref/index'
+
+// ------------------------------------------------------------------
+// Mapped
+// ------------------------------------------------------------------
 import { OmitFromMappedKey, type TOmitFromMappedKey } from './omit-from-mapped-key'
 import { OmitFromMappedResult, type TOmitFromMappedResult } from './omit-from-mapped-result'
-import { TransformKind } from '../symbols/symbols'
+
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedKey, IsIntersect, IsUnion, IsObject, IsSchema, IsMappedResult } from '../guard/kind'
+import { IsMappedKey, IsIntersect, IsUnion, IsObject, IsSchema, IsMappedResult, IsLiteralValue, IsRef } from '../guard/kind'
+import { IsArray as IsArrayValue } from '../guard/value'
 
 // ------------------------------------------------------------------
 // FromIntersect
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]] 
-    ? TFromIntersect<R, K, [...Acc, TOmit<L, K>]>
-    : Acc
+type TFromIntersect<Types extends TSchema[], PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = (
+  Types extends [infer L extends TSchema, ...infer R extends TSchema[]] 
+    ? TFromIntersect<R, PropertyKeys, [...Result, TOmit<L, PropertyKeys>]>
+    : Result
 )
 // prettier-ignore
-function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K) {
-  return T.map((T) => OmitResolve(T, K)) as never
+function FromIntersect<Types extends TSchema[], PropertyKeys extends PropertyKey[]>(types: Types, propertyKeys: PropertyKeys) {
+  return types.map((type) => OmitResolve(type, propertyKeys)) as never
 }
 // ------------------------------------------------------------------
 // FromUnion
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (
+type TFromUnion<T extends TSchema[], K extends PropertyKey[], Result extends TSchema[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]] 
-    ? TFromUnion<R, K, [...Acc, TOmit<L, K>]>
-    : Acc
+    ? TFromUnion<R, K, [...Result, TOmit<L, K>]>
+    : Result
 )
 // prettier-ignore
-function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K) {
-  return T.map((T) => OmitResolve(T, K)) as never
+function FromUnion<Types extends TSchema[], PropertyKeys extends PropertyKey[]>(types: Types, propertyKeys: PropertyKeys) {
+  return types.map((type) => OmitResolve(type, propertyKeys)) as never
 }
 // ------------------------------------------------------------------
 // FromProperty
 // ------------------------------------------------------------------
 // prettier-ignore
-function FromProperty<T extends Record<any, any>, K extends PropertyKey>(T: T, K: K): TProperties {
-  const { [K]: _, ...R } = T
+function FromProperty<Properties extends TProperties, Key extends PropertyKey>(properties: Properties, key: Key): TProperties {
+  const { [key]: _, ...R } = properties
   return R
 }
 // prettier-ignore
-type TFromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Omit<T, I>>
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[], UnionKey extends PropertyKey = TupleToUnion<PropertyKeys>> = (
+  Evaluate<Omit<Properties, UnionKey>>
+)
 // prettier-ignore
-function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K) {
-  return K.reduce((T, K2) => FromProperty(T, K2), T as TProperties)
+function FromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[]>(properties: Properties, propertyKeys: PropertyKeys) {
+  return propertyKeys.reduce((T, K2) => FromProperty(T, K2), properties as TProperties)
 }
 // ------------------------------------------------------------------
 // FromObject
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromObject<T extends TObject, K extends PropertyKey[], Properties extends TProperties = T['properties']> = Ensure<TObject<(
-  TFromProperties<Properties, K>
+type TFromObject<Type extends TObject, PropertyKeys extends PropertyKey[], Properties extends TProperties = Type['properties']> = Ensure<TObject<(
+  TFromProperties<Properties, PropertyKeys>
 )>>
 // prettier-ignore
-function FromObject<T extends TObject, K extends PropertyKey[]>(T: T, K: K): TFromObject<T, K> {
-  const options = Discard(T, [TransformKind, '$id', 'required', 'properties'])
-  const properties = FromProperties(T['properties'], K)
-  return Object(properties, options) as never
+function FromObject<Properties extends TObject, PropertyKeys extends PropertyKey[]>(properties: Properties, propertyKeys: PropertyKeys): TFromObject<Properties, PropertyKeys> {
+  const options = Discard(properties, [TransformKind, '$id', 'required', 'properties'])
+  const omittedProperties = FromProperties(properties['properties'], propertyKeys)
+  return Object(omittedProperties, options) as never
 }
 // ------------------------------------------------------------------
-// OmitResolve
+// UnionFromPropertyKeys
 // ------------------------------------------------------------------
 // prettier-ignore
-function OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TOmit<T, K> {
-  return (
-    IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) : 
-    IsUnion(T) ? Union(FromUnion(T.anyOf, K)) : 
-    IsObject(T) ? FromObject(T, K) : 
-    Object({})
-  ) as never
+type TUnionFromPropertyKeys<PropertyKeys extends PropertyKey[], Result extends TLiteral[] = []> = (
+  PropertyKeys extends [infer Key extends PropertyKey, ...infer Rest extends PropertyKey[]]
+    ? Key extends TLiteralValue
+      ? TUnionFromPropertyKeys<Rest, [...Result, TLiteral<Key>]>
+      : TUnionFromPropertyKeys<Rest, [...Result]>
+    : TUnion<Result>
+)
+// prettier-ignore
+function UnionFromPropertyKeys<PropertyKeys extends PropertyKey[]>(propertyKeys: PropertyKeys): TUnionFromPropertyKeys<PropertyKeys> {
+  const result = propertyKeys.reduce((result, key) => IsLiteralValue(key) ? [...result, Literal(key)]: result, [] as TLiteral[])
+  return Union(result) as never
 }
+// ------------------------------------------------------------------
+// TOmitResolve
+// ------------------------------------------------------------------
 // prettier-ignore
-export type TOmit<T extends TProperties, K extends PropertyKey[]> = (
-  T extends TRecursive<infer S extends TSchema> ? TRecursive<TOmit<S, K>> : 
-  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromIntersect<S, K>> : 
-  T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromUnion<S, K>> : 
-  T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>, K> : 
+export type TOmitResolve<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = (
+  Properties extends TRecursive<infer Types extends TSchema> ? TRecursive<TOmitResolve<Types, PropertyKeys>> : 
+  Properties extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromIntersect<Types, PropertyKeys>> : 
+  Properties extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromUnion<Types, PropertyKeys>> : 
+  Properties extends TObject<infer Types extends TProperties> ? TFromObject<TObject<Types>, PropertyKeys> : 
   TObject<{}>
 )
+// prettier-ignore
+function OmitResolve<Properties extends TSchema, PropertyKeys extends PropertyKey[]>(properties: Properties, propertyKeys: [...PropertyKeys]): TOmitResolve<Properties, PropertyKeys> {
+  return (
+    IsIntersect(properties) ? Intersect(FromIntersect(properties.allOf, propertyKeys)) : 
+    IsUnion(properties) ? Union(FromUnion(properties.anyOf, propertyKeys)) : 
+    IsObject(properties) ? FromObject(properties, propertyKeys) :
+    Object({})
+  ) as never
+}
 // ------------------------------------------------------------------
 // TOmit
+//
+// This mapping logic is to overly complex because of the decision
+// to use PropertyKey[] as the default selector. The PropertyKey[]
+// did make TMapped types simpler to implement, but a non-TSchema
+// selector makes supporting TComputed awkward as it requires
+// generalization via TSchema. This type should be reimplemented
+// in the next major revision to support TSchema as the primary
+// selector.
+//
 // ------------------------------------------------------------------
-/** `[Json]` Constructs a type whose keys are omitted from the given type */
-export function Omit<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TOmitFromMappedResult<T, K>
-/** `[Json]` Constructs a type whose keys are omitted from the given type */
-export function Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TOmitFromMappedKey<T, K>
-/** `[Json]` Constructs a type whose keys are omitted from the given type */
-export function Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>
-/** `[Json]` Constructs a type whose keys are omitted from the given type */
-export function Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>
-export function Omit(T: TSchema, K: any, options?: SchemaOptions): any {
-  // mapped
-  if (IsMappedKey(K)) return OmitFromMappedKey(T, K, options)
-  if (IsMappedResult(T)) return OmitFromMappedResult(T, K, options)
-  // non-mapped
-  const I = IsSchema(K) ? IndexPropertyKeys(K) : (K as string[])
-  // special: mapping types require overridable options
-  return CreateType({ ...OmitResolve(T, I), ...options })
+// prettier-ignore (do not export this type)
+type TResolvePropertyKeys<Key extends TSchema | PropertyKey[]> = Key extends TSchema ? TIndexPropertyKeys<Key> : Key
+// prettier-ignore (do not export this type)
+type TResolveTypeKey<Key extends TSchema | PropertyKey[]> = Key extends PropertyKey[] ? TUnionFromPropertyKeys<Key> : Key
+// prettier-ignore
+export type TOmit<Type extends TSchema, Key extends TSchema | PropertyKey[],
+  IsTypeRef extends boolean = Type extends TRef ? true : false,
+  IsKeyRef extends boolean = Key extends TRef ? true : false,
+> = (
+  Type extends TMappedResult ? TOmitFromMappedResult<Type, TResolvePropertyKeys<Key>> :
+  Key extends TMappedKey ? TOmitFromMappedKey<Type, Key> :
+  [IsTypeRef, IsKeyRef] extends [true, true] ? TComputed<'Omit', [Type, TResolveTypeKey<Key>]> :
+  [IsTypeRef, IsKeyRef] extends [false, true] ? TComputed<'Omit', [Type, TResolveTypeKey<Key>]> :
+  [IsTypeRef, IsKeyRef] extends [true, false] ? TComputed<'Omit', [Type, TResolveTypeKey<Key>]> :
+  TOmitResolve<Type, TResolvePropertyKeys<Key>>
+)
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export function Omit<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TOmit<Type, Key>
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export function Omit<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TOmit<Type, Key>
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+// prettier-ignore
+export function Omit(type: any, key: any, options?: SchemaOptions): any {
+  const typeKey: TSchema = IsArrayValue(key) ? UnionFromPropertyKeys(key as PropertyKey[]) : key 
+  const propertyKeys: PropertyKey[] = IsSchema(key) ? IndexPropertyKeys(key) : key
+  const isTypeRef: boolean = IsRef(type)
+  const isKeyRef: boolean = IsRef(key)
+  return (
+    IsMappedResult(type) ? OmitFromMappedResult(type, propertyKeys, options) :
+    IsMappedKey(key) ? OmitFromMappedKey(type, key, options) :
+    (isTypeRef && isKeyRef) ? Computed('Omit', [type, typeKey], options) :
+    (!isTypeRef && isKeyRef) ? Computed('Omit', [type, typeKey], options) :
+    (isTypeRef && !isKeyRef) ? Computed('Omit', [type, typeKey], options) :
+    CreateType({ ...OmitResolve(type, propertyKeys), ...options })
+  ) as never
 }
diff --git a/src/type/partial/partial.ts b/src/type/partial/partial.ts
index 21bd5cf3e..3cfb48724 100644
--- a/src/type/partial/partial.ts
+++ b/src/type/partial/partial.ts
@@ -31,73 +31,99 @@ import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Evaluate, Ensure } from '../helpers/index'
 import type { TMappedResult } from '../mapped/index'
 import { type TReadonlyOptional } from '../readonly-optional/index'
+import { type TComputed, Computed } from '../computed/index'
 import { type TOptional, Optional } from '../optional/index'
 import { type TReadonly } from '../readonly/index'
 import { type TRecursive } from '../recursive/index'
 import { type TObject, type TProperties, Object } from '../object/index'
 import { type TIntersect, Intersect } from '../intersect/index'
 import { type TUnion, Union } from '../union/index'
+import { type TRef, Ref } from '../ref/index'
 import { Discard } from '../discard/index'
 import { TransformKind } from '../symbols/index'
-
 import { PartialFromMappedResult, type TPartialFromMappedResult } from './partial-from-mapped-result'
 
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/kind'
+import { IsMappedResult, IsIntersect, IsUnion, IsObject, IsRef, IsComputed } from '../guard/kind'
+
 // ------------------------------------------------------------------
-// FromRest
+// FromComputed
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TFromRest<R, [...Acc, TPartial<L>]>
-    : Acc
-)
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<
+  TComputed<'Partial', [TComputed<Target, Parameters>]>
+>
+// prettier-ignore
+function FromComputed<Target extends string, Parameters extends TSchema[]>(target: Target, parameters: Parameters): TFromComputed<Target, Parameters> {
+  return Computed('Partial', [Computed(target, parameters)]) as never
+}
+// ------------------------------------------------------------------
+// FromRef
+// ------------------------------------------------------------------
 // prettier-ignore
-function FromRest<T extends TSchema[]>(T: [...T]): TFromRest<T> {
-  return T.map(L => PartialResolve(L)) as never
+type TFromRef<Ref extends string> = Ensure<
+  TComputed<'Partial', [TRef<Ref>]>
+>
+// prettier-ignore
+function FromRef<Ref extends string>($ref: Ref): TFromRef<Ref> {
+  return Computed('Partial', [Ref($ref)]) as never
 }
 // ------------------------------------------------------------------
 // FromProperties
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromProperties<T extends TProperties> = Evaluate<{
-  [K in keyof T]: 
-    T[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : 
-    T[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : 
-    T[K] extends (TOptional<infer S>) ? TOptional<S> : 
-    TOptional<T[K]>
+type TFromProperties<Properties extends TProperties> = Evaluate<{
+  [K in keyof Properties]: 
+    Properties[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : 
+    Properties[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : 
+    Properties[K] extends (TOptional<infer S>) ? TOptional<S> : 
+    TOptional<Properties[K]>
 }>
 // prettier-ignore
-function FromProperties<T extends TProperties>(T: T): TFromProperties<T> {
-  const Acc = {} as TProperties
-  for(const K of globalThis.Object.getOwnPropertyNames(T)) Acc[K] = Optional(T[K])
-  return Acc as never
+function FromProperties<Properties extends TProperties>(properties: Properties): TFromProperties<Properties> {
+  const partialProperties = {} as TProperties
+  for(const K of globalThis.Object.getOwnPropertyNames(properties)) partialProperties[K] = Optional(properties[K])
+  return partialProperties as never
 }
 // ------------------------------------------------------------------
 // FromObject
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromObject<T extends TObject, Properties extends TProperties = T['properties']> = Ensure<TObject<(
+type TFromObject<Type extends TObject, Properties extends TProperties = Type['properties']> = Ensure<TObject<(
   TFromProperties<Properties>
 )>>
 // prettier-ignore
-function FromObject<T extends TObject>(T: T): TFromObject<T> {
+function FromObject<Type extends TObject>(T: Type): TFromObject<Type> {
   const options = Discard(T, [TransformKind, '$id', 'required', 'properties'])
   const properties = FromProperties(T['properties'])
   return Object(properties, options) as never
 }
 // ------------------------------------------------------------------
+// FromRest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (
+  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TFromRest<R, [...Result, TPartial<L>]>
+    : Result
+)
+// prettier-ignore
+function FromRest<Types extends TSchema[]>(types: [...Types]): TFromRest<Types> {
+  return types.map(type => PartialResolve(type)) as never
+}
+// ------------------------------------------------------------------
 // PartialResolve
 // ------------------------------------------------------------------
 // prettier-ignore
-function PartialResolve<T extends TSchema>(T: T): TPartial<T> {
+function PartialResolve<Type extends TSchema>(type: Type): TPartial<Type> {
   return (
-    IsIntersect(T) ? Intersect(FromRest(T.allOf)) :
-    IsUnion(T) ? Union(FromRest(T.anyOf)) :
-    IsObject(T) ? FromObject(T) :
+    IsComputed(type) ? FromComputed(type.target, type.parameters) :
+    IsRef(type) ? FromRef(type.$ref) :
+    IsIntersect(type) ? Intersect(FromRest(type.allOf)) :
+    IsUnion(type) ? Union(FromRest(type.anyOf)) :
+    IsObject(type) ? FromObject(type) :
     Object({})
   ) as never
 }
@@ -106,22 +132,24 @@ function PartialResolve<T extends TSchema>(T: T): TPartial<T> {
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TPartial<T extends TSchema> = (
-  T extends TRecursive<infer S extends TSchema> ? TRecursive<TPartial<S>> :
-  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> :
-  T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> :
-  T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>> :
+  T extends TRecursive<infer Type extends TSchema> ? TRecursive<TPartial<Type>> :
+  T extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> :
+  T extends TRef<infer Ref extends string> ? TFromRef<Ref> :
+  T extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> :
+  T extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> :
+  T extends TObject<infer Properties extends TProperties> ? TFromObject<TObject<Properties>> :
   TObject<{}>
 )
 /** `[Json]` Constructs a type where all properties are optional */
-export function Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>
+export function Partial<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TPartialFromMappedResult<MappedResult>
 /** `[Json]` Constructs a type where all properties are optional */
-export function Partial<T extends TSchema>(T: T, options?: SchemaOptions): TPartial<T>
+export function Partial<Type extends TSchema>(type: Type, options?: SchemaOptions): TPartial<Type>
 /** `[Json]` Constructs a type where all properties are optional */
-export function Partial(T: TSchema, options?: SchemaOptions): any {
-  if (IsMappedResult(T)) {
-    return PartialFromMappedResult(T, options)
+export function Partial(type: TSchema, options?: SchemaOptions): any {
+  if (IsMappedResult(type)) {
+    return PartialFromMappedResult(type, options)
   } else {
     // special: mapping types require overridable options
-    return CreateType({ ...PartialResolve(T), ...options })
+    return CreateType({ ...PartialResolve(type), ...options })
   }
 }
diff --git a/src/type/pick/pick-from-mapped-key.ts b/src/type/pick/pick-from-mapped-key.ts
index 062e1e527..86933aa58 100644
--- a/src/type/pick/pick-from-mapped-key.ts
+++ b/src/type/pick/pick-from-mapped-key.ts
@@ -36,77 +36,54 @@ import { Clone } from '../clone/value'
 // FromPropertyKey
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromPropertyKey<
-  T extends TSchema,
-  K extends PropertyKey,
-> = {
-    [_ in K]: TPick<T, [K]>
-  }
+type TFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
+  [_ in Key]: TPick<Type, [Key]>
+}
 // prettier-ignore
-function FromPropertyKey<
-  T extends TSchema,
-  K extends PropertyKey,
->(T: T, K: K, options?: SchemaOptions): TFromPropertyKey<T, K> {
+function FromPropertyKey<Type extends TSchema, Key extends PropertyKey>(type: Type, key: Key, options?: SchemaOptions): TFromPropertyKey<Type, Key> {
   return {
-    [K]: Pick(T, [K], Clone(options))
+    [key]: Pick(type, [key], Clone(options))
   } as never
 }
 // ------------------------------------------------------------------
 // FromPropertyKeys
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromPropertyKeys<
-  T extends TSchema,
-  K extends PropertyKey[],
-  Acc extends TProperties = {}
-> = (
-  K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]]
-    ? TFromPropertyKeys<T, RK, Acc & TFromPropertyKey<T, LK>>
-    : Acc
+type TFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TProperties = {}> = (
+  PropertyKeys extends [infer LeftKey extends PropertyKey, ...infer RightKeys extends PropertyKey[]]
+    ? TFromPropertyKeys<Type, RightKeys, Result & TFromPropertyKey<Type, LeftKey>>
+    : Result
 )
 // prettier-ignore
-function FromPropertyKeys<
-  T extends TSchema,
-  K extends PropertyKey[]
->(T: T, K: [...K], options?: SchemaOptions): TFromPropertyKeys<T, K> {
-  return K.reduce((Acc, LK) => {
-    return { ...Acc, ...FromPropertyKey(T, LK, options) }
+function FromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TFromPropertyKeys<Type, PropertyKeys> {
+  return propertyKeys.reduce((result, leftKey) => {
+    return { ...result, ...FromPropertyKey(type, leftKey, options) }
   }, {} as TProperties) as never
 }
 // ------------------------------------------------------------------
 // FromMappedKey
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromMappedKey<
-  T extends TSchema,
-  K extends TMappedKey,
-> = (
-  TFromPropertyKeys<T, K['keys']>
+type TFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey> = (
+  TFromPropertyKeys<Type, MappedKey['keys']>
 )
 // prettier-ignore
-function FromMappedKey<
-  T extends TSchema,
-  K extends TMappedKey,
->(T: T, K: K, options?: SchemaOptions): TFromMappedKey<T, K> {
-  return FromPropertyKeys(T, K.keys, options) as never
+function FromMappedKey<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TFromMappedKey<Type, MappedKey> {
+  return FromPropertyKeys(type, mappedKey.keys, options) as never
 }
 // ------------------------------------------------------------------
 // PickFromMappedKey
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TPickFromMappedKey<
-  T extends TSchema,
-  K extends TMappedKey,
-  P extends TProperties = TFromMappedKey<T, K>
+export type TPickFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey,
+  Properties extends TProperties = TFromMappedKey<Type, MappedKey>
 > = (
-  TMappedResult<P>
+  TMappedResult<Properties>
 )
 // prettier-ignore
-export function PickFromMappedKey<
-  T extends TSchema,
-  K extends TMappedKey,
-  P extends TProperties = TFromMappedKey<T, K>
->(T: T, K: K, options?: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedKey(T, K, options)
-  return MappedResult(P) as never
+export function PickFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey,
+  Properties extends TProperties = TFromMappedKey<Type, MappedKey>
+>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedResult<Properties> {
+  const properties = FromMappedKey(type, mappedKey, options)
+  return MappedResult(properties) as never
 }
diff --git a/src/type/pick/pick-from-mapped-result.ts b/src/type/pick/pick-from-mapped-result.ts
index 3abf5ad17..7fa74f9c4 100644
--- a/src/type/pick/pick-from-mapped-result.ts
+++ b/src/type/pick/pick-from-mapped-result.ts
@@ -37,55 +37,41 @@ import { Clone } from '../clone/value'
 // FromProperties
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromProperties<
-  P extends TProperties,
-  K extends PropertyKey[],
-> = (
-  { [K2 in keyof P]: TPick<P[K2], K> }   
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = (
+  { [K2 in keyof Properties]: TPick<Properties[K2], PropertyKeys> }   
 )
 // prettier-ignore
-function FromProperties<
-  P extends TProperties,
-  K extends PropertyKey[],
->(P: P, K: [...K], options?: SchemaOptions): TFromProperties<P, K> {
-  const Acc = {} as TProperties
-  for(const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Pick(P[K2], K, Clone(options))
-  return Acc as never
+function FromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[]>(properties: Properties, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TFromProperties<Properties, PropertyKeys> {
+  const result = {} as TProperties
+  for(const K2 of globalThis.Object.getOwnPropertyNames(properties)) result[K2] = Pick(properties[K2], propertyKeys, Clone(options))
+  return result as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromMappedResult<
-  R extends TMappedResult,
-  K extends PropertyKey[],
-> = (
-  Evaluate<TFromProperties<R['properties'], K>>
+type TFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[]> = (
+  Evaluate<TFromProperties<MappedResult['properties'], PropertyKeys>>
 )
 // prettier-ignore
-function FromMappedResult<
-  R extends TMappedResult,
-  K extends PropertyKey[]
->(R: R, K: [...K], options?: SchemaOptions): TFromMappedResult<R, K> {
-  return FromProperties(R.properties, K, options) as never
+function FromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[]>(mappedResult: MappedResult, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TFromMappedResult<MappedResult, PropertyKeys> {
+  return FromProperties(mappedResult.properties, propertyKeys, options) as never
 }
 // ------------------------------------------------------------------
 // PickFromMappedResult
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TPickFromMappedResult<
-  T extends TMappedResult,
-  K extends PropertyKey[],
-  P extends TProperties = TFromMappedResult<T, K>
+export type TPickFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[],
+  Properties extends TProperties = TFromMappedResult<MappedResult, PropertyKeys>
 > = (
-  Ensure<TMappedResult<P>>
+  Ensure<TMappedResult<Properties>>
 )
 // prettier-ignore
 export function PickFromMappedResult<
-  R extends TMappedResult,
-  K extends PropertyKey[],
-  P extends TProperties = TFromMappedResult<R, K>
->(R: R, K: [...K], options?: SchemaOptions): TMappedResult<P> {
-  const P = FromMappedResult(R, K, options)
-  return MappedResult(P) as never
+  MappedResult extends TMappedResult,
+  PropertyKeys extends PropertyKey[],
+  Properties extends TProperties = TFromMappedResult<MappedResult, PropertyKeys>
+>(mappedResult: MappedResult, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TMappedResult<Properties> {
+  const properties = FromMappedResult(mappedResult, propertyKeys, options)
+  return MappedResult(properties) as never
 }
diff --git a/src/type/pick/pick.ts b/src/type/pick/pick.ts
index bde1e17f0..f9b988f46 100644
--- a/src/type/pick/pick.ts
+++ b/src/type/pick/pick.ts
@@ -31,59 +31,70 @@ import { Discard } from '../discard/discard'
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { TupleToUnion, Evaluate, Ensure } from '../helpers/index'
 import { type TRecursive } from '../recursive/index'
-import { type TIntersect, Intersect } from '../intersect/index'
-import { type TUnion, Union } from '../union/index'
-import { type TObject, type TProperties, type TPropertyKey, Object } from '../object/index'
-import type { TMappedKey, TMappedResult } from '../mapped/index'
+import { Computed, type TComputed } from '../computed/index'
+import { Intersect, type TIntersect } from '../intersect/index'
+import { Literal, type TLiteral, type TLiteralValue } from '../literal/index'
+import { Object, type TObject, type TProperties, type TPropertyKey } from '../object/index'
+import { Union, type TUnion } from '../union/index'
+import { type TMappedKey, type TMappedResult } from '../mapped/index'
+import { type TRef } from '../ref/index'
 import { IndexPropertyKeys, type TIndexPropertyKeys } from '../indexed/index'
-import { PickFromMappedKey, type TPickFromMappedKey } from './pick-from-mapped-key'
-import { PickFromMappedResult, type TPickFromMappedResult } from './pick-from-mapped-result'
 import { TransformKind } from '../symbols/symbols'
 
 // ------------------------------------------------------------------
-// TypeGuard
+// Guards
+// ------------------------------------------------------------------
+import { IsMappedKey, IsMappedResult, IsIntersect, IsUnion, IsObject, IsSchema, IsLiteralValue, IsRef } from '../guard/kind'
+import { IsArray as IsArrayValue } from 'src/value/guard'
+
+// ------------------------------------------------------------------
+// Infrastructure
 // ------------------------------------------------------------------
-import { IsMappedKey, IsMappedResult, IsIntersect, IsUnion, IsObject, IsSchema } from '../guard/kind'
+import { PickFromMappedKey, type TPickFromMappedKey } from './pick-from-mapped-key'
+import { PickFromMappedResult, type TPickFromMappedResult } from './pick-from-mapped-result'
+
 // ------------------------------------------------------------------
 // FromIntersect
 // ------------------------------------------------------------------
 // prettier-ignore
-type FromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = 
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? FromIntersect<R, K, [...Acc, TPick<L, K>]>
-    : Acc
-function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K) {
-  return T.map((T) => PickResolve(T, K)) as FromIntersect<T, K>
+type TFromIntersect<Types extends TSchema[], PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = 
+  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TFromIntersect<R, PropertyKeys, [...Result, TPick<L, PropertyKeys>]>
+    : Result
+function FromIntersect<Types extends TSchema[], PropertyKeys extends PropertyKey[]>(types: Types, propertyKeys: PropertyKeys): TFromIntersect<Types, PropertyKeys> {
+  return types.map((type) => PickResolve(type, propertyKeys)) as never
 }
 // ------------------------------------------------------------------
 // FromUnion
 // ------------------------------------------------------------------
 // prettier-ignore
-type FromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = 
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? FromUnion<R, K, [...Acc, TPick<L, K>]>
-    : Acc
+type TFromUnion<Types extends TSchema[], PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = 
+  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TFromUnion<R, PropertyKeys, [...Result, TPick<L, PropertyKeys>]>
+    : Result
 // prettier-ignore
-function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K) {
-  return T.map((T) => PickResolve(T, K)) as FromUnion<T, K>
+function FromUnion<Types extends TSchema[], PropertyKeys extends PropertyKey[]>(types: Types, propertyKeys: PropertyKeys): TFromUnion<Types, PropertyKeys> {
+  return types.map((type) => PickResolve(type, propertyKeys)) as never
 }
 // ------------------------------------------------------------------
 // FromProperties
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Pick<T, I & keyof T>>
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[], UnionKeys extends PropertyKey = TupleToUnion<PropertyKeys>> = (
+  Evaluate<Pick<Properties, UnionKeys & keyof Properties>>
+)
 // prettier-ignore
-function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K): TFromProperties <T, K> {
-  const Acc = {} as TProperties
-  for(const K2 of K) if(K2 in T) Acc[K2 as TPropertyKey] = T[K2 as keyof T]
-  return Acc as never
+function FromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[]>(properties: Properties, propertyKeys: PropertyKeys): TFromProperties <Properties, PropertyKeys> {
+  const result = {} as TProperties
+  for(const K2 of propertyKeys) if(K2 in properties) result[K2 as TPropertyKey] = properties[K2 as keyof Properties]
+  return result as never
 }
 // ------------------------------------------------------------------
 // FromObject
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromObject<T extends TObject, K extends PropertyKey[], Properties extends TProperties = T['properties']> = Ensure<TObject<(
-  TFromProperties<Properties, K>
+type TFromObject<Type extends TObject, Key extends PropertyKey[], Properties extends TProperties = Type['properties']> = Ensure<TObject<(
+  TFromProperties<Properties, Key>
 )>>
 // prettier-ignore
 function FromObject<T extends TObject, K extends PropertyKey[]>(T: T, K: K): TFromObject<T, K> {
@@ -92,39 +103,86 @@ function FromObject<T extends TObject, K extends PropertyKey[]>(T: T, K: K): TFr
   return Object(properties, options) as never
 }
 // ------------------------------------------------------------------
-// PickResolve
+// UnionFromPropertyKeys
 // ------------------------------------------------------------------
 // prettier-ignore
-function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TPick<T, K> {
+type TUnionFromPropertyKeys<PropertyKeys extends PropertyKey[], Result extends TLiteral[] = []> = (
+  PropertyKeys extends [infer Key extends PropertyKey, ...infer Rest extends PropertyKey[]]
+    ? Key extends TLiteralValue
+      ? TUnionFromPropertyKeys<Rest, [...Result, TLiteral<Key>]>
+      : TUnionFromPropertyKeys<Rest, [...Result]>
+    : TUnion<Result>
+)
+// prettier-ignore
+function UnionFromPropertyKeys<PropertyKeys extends PropertyKey[]>(propertyKeys: PropertyKeys): TUnionFromPropertyKeys<PropertyKeys> {
+  const result = propertyKeys.reduce((result, key) => IsLiteralValue(key) ? [...result, Literal(key)]: result, [] as TLiteral[])
+  return Union(result) as never
+}
+// ------------------------------------------------------------------
+// TPickResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TPickResolve<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = (
+  Properties extends TRecursive<infer Types extends TSchema> ? TRecursive<TPickResolve<Types, PropertyKeys>> : 
+  Properties extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromIntersect<Types, PropertyKeys>> : 
+  Properties extends TUnion<infer Types  extends TSchema[]> ? TUnion<TFromUnion<Types, PropertyKeys>> : 
+  Properties extends TObject<infer Types extends TProperties> ? TFromObject<TObject<Types>, PropertyKeys> : 
+  TObject<{}>
+)
+// prettier-ignore
+function PickResolve<Properties extends TSchema, PropertyKeys extends PropertyKey[]>(properties: Properties, propertyKeys: [...PropertyKeys]): TPickResolve<Properties, PropertyKeys> {
   return (
-    IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) : 
-    IsUnion(T) ? Union(FromUnion(T.anyOf, K)) : 
-    IsObject(T) ? FromObject(T, K) :
+    IsIntersect(properties) ? Intersect(FromIntersect(properties.allOf, propertyKeys)) : 
+    IsUnion(properties) ? Union(FromUnion(properties.anyOf, propertyKeys)) : 
+    IsObject(properties) ? FromObject(properties, propertyKeys) :
     Object({})
   ) as never
 }
+// ------------------------------------------------------------------
+// TPick
+//
+// This mapping logic is to overly complex because of the decision
+// to use PropertyKey[] as the default selector. The PropertyKey[]
+// did make TMapped types simpler to implement, but a non-TSchema
+// selector makes supporting TComputed awkward as it requires
+// generalization via TSchema. This type should be reimplemented
+// in the next major revision to support TSchema as the primary
+// selector.
+//
+// ------------------------------------------------------------------
+// prettier-ignore (do not export this type)
+type TResolvePropertyKeys<Key extends TSchema | PropertyKey[]> = Key extends TSchema ? TIndexPropertyKeys<Key> : Key
+// prettier-ignore (do not export this type)
+type TResolveTypeKey<Key extends TSchema | PropertyKey[]> = Key extends PropertyKey[] ? TUnionFromPropertyKeys<Key> : Key
 // prettier-ignore
-export type TPick<T extends TProperties, K extends PropertyKey[]> = 
-  T extends TRecursive<infer S extends TSchema> ? TRecursive<TPick<S, K>> : 
-  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<FromIntersect<S, K>> : 
-  T extends TUnion<infer S  extends TSchema[]> ? TUnion<FromUnion<S, K>> : 
-  T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>, K> : 
-  TObject<{}>
-
-/** `[Json]` Constructs a type whose keys are picked from the given type */
-export function Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>
+export type TPick<Type extends TSchema, Key extends TSchema | PropertyKey[],
+  IsTypeRef extends boolean = Type extends TRef ? true : false,
+  IsKeyRef extends boolean = Key extends TRef ? true : false,
+> = (
+  Type extends TMappedResult ? TPickFromMappedResult<Type, TResolvePropertyKeys<Key>> :
+  Key extends TMappedKey ? TPickFromMappedKey<Type, Key> :
+  [IsTypeRef, IsKeyRef] extends [true, true] ? TComputed<'Pick', [Type, TResolveTypeKey<Key>]> :
+  [IsTypeRef, IsKeyRef] extends [false, true] ? TComputed<'Pick', [Type, TResolveTypeKey<Key>]> :
+  [IsTypeRef, IsKeyRef] extends [true, false] ? TComputed<'Pick', [Type, TResolveTypeKey<Key>]> :
+  TPickResolve<Type, TResolvePropertyKeys<Key>>
+)
 /** `[Json]` Constructs a type whose keys are picked from the given type */
-export function Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TPickFromMappedKey<T, K>
+export function Pick<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TPick<Type, Key>
 /** `[Json]` Constructs a type whose keys are picked from the given type */
-export function Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>
+export function Pick<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TPick<Type, Key>
 /** `[Json]` Constructs a type whose keys are picked from the given type */
-export function Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>
-export function Pick(T: TSchema, K: any, options?: SchemaOptions): any {
-  // mapped
-  if (IsMappedKey(K)) return PickFromMappedKey(T, K, options)
-  if (IsMappedResult(T)) return PickFromMappedResult(T, K, options)
-  // non-mapped
-  const I = IsSchema(K) ? IndexPropertyKeys(K) : (K as string[])
-  // special: mapping types require overridable options
-  return CreateType({ ...PickResolve(T, I), ...options })
+// prettier-ignore
+export function Pick(type: any, key: any, options?: SchemaOptions): any {
+  const typeKey: TSchema = IsArrayValue(key) ? UnionFromPropertyKeys(key as PropertyKey[]) : key 
+  const propertyKeys: PropertyKey[] = IsSchema(key) ? IndexPropertyKeys(key) : key
+  const isTypeRef: boolean = IsRef(type)
+  const isKeyRef: boolean = IsRef(key)
+  return (
+    IsMappedResult(type) ? PickFromMappedResult(type, propertyKeys, options) :
+    IsMappedKey(key) ? PickFromMappedKey(type, key, options) :
+    (isTypeRef && isKeyRef) ? Computed('Pick', [type, typeKey], options) :
+    (!isTypeRef && isKeyRef) ? Computed('Pick', [type, typeKey], options) :
+    (isTypeRef && !isKeyRef) ? Computed('Pick', [type, typeKey], options) :
+    CreateType({ ...PickResolve(type, propertyKeys), ...options })
+  ) as never
 }
diff --git a/src/type/record/record.ts b/src/type/record/record.ts
index e32ae7a26..34a87f74d 100644
--- a/src/type/record/record.ts
+++ b/src/type/record/record.ts
@@ -31,6 +31,7 @@ import type { TSchema } from '../schema/index'
 import type { Static } from '../static/index'
 import type { Evaluate, Ensure, Assert } from '../helpers/index'
 import { type TAny } from '../any/index'
+import { Computed, type TComputed } from '../computed/index'
 import { Object, type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index'
 import { type TLiteral, type TLiteralValue } from '../literal/index'
 import { Never, type TNever } from '../never/index'
@@ -40,6 +41,7 @@ import { type TString } from '../string/index'
 import { type TInteger } from '../integer/index'
 import { type TNumber } from '../number/index'
 import { type TEnum } from '../enum/index'
+import { type TRef } from '../ref/index'
 
 import { IsTemplateLiteralFinite, TIsTemplateLiteralFinite, type TTemplateLiteral } from '../template-literal/index'
 import { PatternStringExact, PatternNumberExact, PatternNeverExact } from '../patterns/index'
@@ -52,7 +54,8 @@ import { IsUndefined } from '../guard/value'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsInteger, IsLiteral, IsAny, IsNever, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion } from '../guard/kind'
+import { IsInteger, IsLiteral, IsAny, IsNever, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion, IsRef, IsComputed } from '../guard/kind'
+
 // ------------------------------------------------------------------
 // RecordCreateFromPattern
 // ------------------------------------------------------------------
@@ -218,34 +221,38 @@ export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchem
 // TRecordOrObject
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TRecordOrObject<K extends TSchema, T extends TSchema> =
-  K extends TTemplateLiteral ? TFromTemplateLiteralKey<K, T> :  
-  K extends TEnum<infer S> ? TFromEnumKey<S, T> : // (Special: Ensure resolve Enum before Union)
-  K extends TUnion<infer S> ? TFromUnionKey<S, T> :
-  K extends TLiteral<infer S> ? TFromLiteralKey<S, T> :
-  K extends TInteger ? TFromIntegerKey<K, T> :
-  K extends TNumber ? TFromNumberKey<K, T> :
-  K extends TRegExp ? TFromRegExpKey<K, T> :
-  K extends TString ? TFromStringKey<K, T> :
-  K extends TAny ? TFromAnyKey<K, T> :
-  K extends TNever ? TFromNeverKey<K, T> :
+export type TRecordOrObject<Key extends TSchema, Type extends TSchema> =
+  Type extends TRef ? TComputed<'Record', [Key, Type]> :
+  Key extends TRef ? TComputed<'Record', [Key, Type]> :
+  Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> :  
+  Key extends TEnum<infer S> ? TFromEnumKey<S, Type> : // (Special: Ensure resolve Enum before Union)
+  Key extends TUnion<infer S> ? TFromUnionKey<S, Type> :
+  Key extends TLiteral<infer S> ? TFromLiteralKey<S, Type> :
+  Key extends TInteger ? TFromIntegerKey<Key, Type> :
+  Key extends TNumber ? TFromNumberKey<Key, Type> :
+  Key extends TRegExp ? TFromRegExpKey<Key, Type> :
+  Key extends TString ? TFromStringKey<Key, Type> :
+  Key extends TAny ? TFromAnyKey<Key, Type> :
+  Key extends TNever ? TFromNeverKey<Key, Type> :
   TNever
 // ------------------------------------------------------------------
 // TRecordOrObject
 // ------------------------------------------------------------------
 /** `[Json]` Creates a Record type */
-export function Record<K extends TSchema, T extends TSchema>(K: K, T: T, options: ObjectOptions = {}): TRecordOrObject<K, T> {
+export function Record<Key extends TSchema, Type extends TSchema>(key: Key, type: Type, options: ObjectOptions = {}): TRecordOrObject<Key, Type> {
   // prettier-ignore
   return (
-    IsUnion(K) ? FromUnionKey(K.anyOf, T, options) :
-    IsTemplateLiteral(K) ? FromTemplateLiteralKey(K, T, options) :
-    IsLiteral(K) ? FromLiteralKey(K.const, T, options) :
-    IsInteger(K) ? FromIntegerKey(K, T, options) :
-    IsNumber(K) ? FromNumberKey(K, T, options) :
-    IsRegExp(K) ? FromRegExpKey(K, T, options) :
-    IsString(K) ? FromStringKey(K, T, options) :
-    IsAny(K) ? FromAnyKey(K, T, options) :
-    IsNever(K) ? FromNeverKey(K, T, options) :
+    IsRef(type) ? Computed('Record', [key, type]) :
+    IsRef(key) ? Computed('Record', [key, type]) :
+    IsUnion(key) ? FromUnionKey(key.anyOf, type, options) :
+    IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) :
+    IsLiteral(key) ? FromLiteralKey(key.const, type, options) :
+    IsInteger(key) ? FromIntegerKey(key, type, options) :
+    IsNumber(key) ? FromNumberKey(key, type, options) :
+    IsRegExp(key) ? FromRegExpKey(key, type, options) :
+    IsString(key) ? FromStringKey(key, type, options) :
+    IsAny(key) ? FromAnyKey(key, type, options) :
+    IsNever(key) ? FromNeverKey(key, type, options) :
     Never(options)
   ) as never
 }
diff --git a/src/type/required/required.ts b/src/type/required/required.ts
index fab0632f2..7ae6a234d 100644
--- a/src/type/required/required.ts
+++ b/src/type/required/required.ts
@@ -31,12 +31,14 @@ import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Evaluate, Ensure } from '../helpers/index'
 import type { TMappedResult } from '../mapped/index'
 import { type TReadonlyOptional } from '../readonly-optional/index'
+import { type TComputed, Computed } from '../computed/index'
 import { type TOptional } from '../optional/index'
 import { type TReadonly } from '../readonly/index'
 import { type TRecursive } from '../recursive/index'
+import { type TObject, type TProperties, Object } from '../object/index'
 import { type TIntersect, Intersect } from '../intersect/index'
 import { type TUnion, Union } from '../union/index'
-import { type TObject, type TProperties, Object } from '../object/index'
+import { type TRef, Ref } from '../ref/index'
 import { OptionalKind, TransformKind } from '../symbols/index'
 import { Discard } from '../discard/index'
 import { RequiredFromMappedResult, type TRequiredFromMappedResult } from './required-from-mapped-result'
@@ -44,60 +46,84 @@ import { RequiredFromMappedResult, type TRequiredFromMappedResult } from './requ
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/kind'
+import { IsMappedResult, IsIntersect, IsUnion, IsObject, IsRef, IsComputed } from '../guard/kind'
+
 // ------------------------------------------------------------------
-// FromRest
+// FromComputed
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TFromRest<R, [...Acc, TRequired<L>]>
-    : Acc
-)
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<
+  TComputed<'Required', [TComputed<Target, Parameters>]>
+>
+// prettier-ignore
+function FromComputed<Target extends string, Parameters extends TSchema[]>(target: Target, parameters: Parameters): TFromComputed<Target, Parameters> {
+  return Computed('Required', [Computed(target, parameters)]) as never
+}
+// ------------------------------------------------------------------
+// FromRef
+// ------------------------------------------------------------------
 // prettier-ignore
-function FromRest<T extends TSchema[]>(T: [...T]) : TFromRest<T> {
-  return T.map(L => RequiredResolve(L)) as never
+type TFromRef<Ref extends string> = Ensure<
+  TComputed<'Required', [TRef<Ref>]>
+>
+// prettier-ignore
+function FromRef<Ref extends string>($ref: Ref): TFromRef<Ref> {
+  return Computed('Required', [Ref($ref)]) as never
 }
 // ------------------------------------------------------------------
 // FromProperties
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromProperties<T extends TProperties> = Evaluate<{
-  [K in keyof T]:
-    T[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> :
-    T[K] extends (TReadonly<infer S>) ? TReadonly<S> :
-    T[K] extends (TOptional<infer S>) ? S :
-    T[K]
+type TFromProperties<Properties extends TProperties> = Evaluate<{
+  [K in keyof Properties]:
+    Properties[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> :
+    Properties[K] extends (TReadonly<infer S>) ? TReadonly<S> :
+    Properties[K] extends (TOptional<infer S>) ? S :
+    Properties[K]
 }>
 // prettier-ignore
-function FromProperties<T extends TProperties>(T: T) {
-  const Acc = {} as TProperties
-  for(const K of globalThis.Object.getOwnPropertyNames(T)) Acc[K] = Discard(T[K], [OptionalKind]) as TSchema
-  return Acc as never
+function FromProperties<Properties extends TProperties>(properties: Properties) {
+  const requiredProperties = {} as TProperties
+  for(const K of globalThis.Object.getOwnPropertyNames(properties)) requiredProperties[K] = Discard(properties[K], [OptionalKind]) as TSchema
+  return requiredProperties as never
 }
 // ------------------------------------------------------------------
 // FromObject
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromObject<T extends TObject, Properties extends TProperties = T['properties']> = Ensure<TObject<(
+type TFromObject<Type extends TObject, Properties extends TProperties = Type['properties']> = Ensure<TObject<(
   TFromProperties<Properties>
 )>>
 // prettier-ignore
-function FromObject<T extends TObject>(T: T): TFromObject<T> {
-  const options = Discard(T, [TransformKind, '$id', 'required', 'properties'])
-  const properties = FromProperties(T['properties'])
+function FromObject<Type extends TObject>(type: Type): TFromObject<Type> {
+  const options = Discard(type, [TransformKind, '$id', 'required', 'properties'])
+  const properties = FromProperties(type['properties'])
   return Object(properties, options) as never
 }
 // ------------------------------------------------------------------
+// FromRest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (
+  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TFromRest<R, [...Result, TRequired<L>]>
+    : Result
+)
+// prettier-ignore
+function FromRest<Types extends TSchema[]>(types: [...Types]) : TFromRest<Types> {
+  return types.map(type => RequiredResolve(type)) as never
+}
+// ------------------------------------------------------------------
 // RequiredResolve
 // ------------------------------------------------------------------
-
 // prettier-ignore
-function RequiredResolve<T extends TSchema>(T: T): TRequired<T> {
+function RequiredResolve<Type extends TSchema>(type: Type): TRequired<Type> {
   return (
-    IsIntersect(T) ? Intersect(FromRest(T.allOf)) :
-    IsUnion(T) ?  Union(FromRest(T.anyOf)) :
-    IsObject(T) ? FromObject(T) :
+    IsComputed(type) ? FromComputed(type.target, type.parameters) :
+    IsRef(type) ? FromRef(type.$ref) :
+    IsIntersect(type) ? Intersect(FromRest(type.allOf)) :
+    IsUnion(type) ?  Union(FromRest(type.anyOf)) :
+    IsObject(type) ? FromObject(type) :
     Object({})
   ) as never
 }
@@ -105,23 +131,25 @@ function RequiredResolve<T extends TSchema>(T: T): TRequired<T> {
 // TRequired
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TRequired<T extends TSchema> = (
-  T extends TRecursive<infer S extends TSchema> ? TRecursive<TRequired<S>> :
-  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> :
-  T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> :
-  T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>> :
+export type TRequired<Type extends TSchema> = (
+  Type extends TRecursive<infer Type extends TSchema> ? TRecursive<TRequired<Type>> :
+  Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> :
+  Type extends TRef<infer Ref extends string> ? TFromRef<Ref> :
+  Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> :
+  Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> :
+  Type extends TObject<infer Properties extends TProperties> ? TFromObject<TObject<Properties>> :
   TObject<{}>
 )
 /** `[Json]` Constructs a type where all properties are required */
-export function Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>
+export function Required<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>
 /** `[Json]` Constructs a type where all properties are required */
-export function Required<T extends TSchema>(T: T, options?: SchemaOptions): TRequired<T>
+export function Required<Type extends TSchema>(type: Type, options?: SchemaOptions): TRequired<Type>
 /** `[Json]` Constructs a type where all properties are required */
-export function Required<T extends TSchema>(T: T, options?: SchemaOptions): never {
-  if (IsMappedResult(T)) {
-    return RequiredFromMappedResult(T, options) as never
+export function Required<Type extends TSchema>(type: Type, options?: SchemaOptions): never {
+  if (IsMappedResult(type)) {
+    return RequiredFromMappedResult(type, options) as never
   } else {
     // special: mapping types require overridable options
-    return CreateType({ ...RequiredResolve(T), ...options }) as never
+    return CreateType({ ...RequiredResolve(type), ...options }) as never
   }
 }
diff --git a/src/type/tuple/tuple.ts b/src/type/tuple/tuple.ts
index 67d564f9d..80b092c79 100644
--- a/src/type/tuple/tuple.ts
+++ b/src/type/tuple/tuple.ts
@@ -52,11 +52,11 @@ export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
   maxItems: number
 }
 /** `[Json]` Creates a Tuple type */
-export function Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T> {
+export function Tuple<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): TTuple<Types> {
   // prettier-ignore
   return CreateType(
-    items.length > 0 ?
-      { [Kind]: 'Tuple', type: 'array', items, additionalItems: false, minItems: items.length, maxItems: items.length } :
-      { [Kind]: 'Tuple', type: 'array', minItems: items.length, maxItems: items.length },
+    types.length > 0 ?
+      { [Kind]: 'Tuple', type: 'array', items: types, additionalItems: false, minItems: types.length, maxItems: types.length } :
+      { [Kind]: 'Tuple', type: 'array', minItems: types.length, maxItems: types.length },
   options) as never
 }
diff --git a/src/type/type/javascript.ts b/src/type/type/javascript.ts
index fad81ea22..101231eb2 100644
--- a/src/type/type/javascript.ts
+++ b/src/type/type/javascript.ts
@@ -49,11 +49,11 @@ import { Void, type TVoid } from '../void/index'
 /** JavaScript Type Builder with Static Resolution for TypeScript */
 export class JavaScriptTypeBuilder extends JsonTypeBuilder {
   /** `[JavaScript]` Creates a AsyncIterator type */
-  public AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T> {
+  public AsyncIterator<Type extends TSchema>(items: Type, options?: SchemaOptions): TAsyncIterator<Type> {
     return AsyncIterator(items, options)
   }
   /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-  public Awaited<T extends TSchema>(schema: T, options?: SchemaOptions): TAwaited<T> {
+  public Awaited<Type extends TSchema>(schema: Type, options?: SchemaOptions): TAwaited<Type> {
     return Awaited(schema, options)
   }
   /** `[JavaScript]` Creates a BigInt type */
@@ -61,35 +61,35 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     return BigInt(options)
   }
   /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-  public ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TConstructorParameters<T> {
+  public ConstructorParameters<Type extends TConstructor>(schema: Type, options?: SchemaOptions): TConstructorParameters<Type> {
     return ConstructorParameters(schema, options)
   }
   /** `[JavaScript]` Creates a Constructor type */
-  public Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U> {
-    return Constructor(parameters, returns, options)
+  public Constructor<Parameters extends TSchema[], InstanceType extends TSchema>(parameters: [...Parameters], instanceType: InstanceType, options?: SchemaOptions): TConstructor<Parameters, InstanceType> {
+    return Constructor(parameters, instanceType, options)
   }
   /** `[JavaScript]` Creates a Date type */
   public Date(options: DateOptions = {}): TDate {
     return Date(options)
   }
   /** `[JavaScript]` Creates a Function type */
-  public Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U> {
-    return FunctionType(parameters, returns, options)
+  public Function<Parameters extends TSchema[], ReturnType extends TSchema>(parameters: [...Parameters], returnType: ReturnType, options?: SchemaOptions): TFunction<Parameters, ReturnType> {
+    return FunctionType(parameters, returnType, options)
   }
   /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-  public InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T> {
+  public InstanceType<Type extends TConstructor>(schema: Type, options?: SchemaOptions): TInstanceType<Type> {
     return InstanceType(schema, options)
   }
   /** `[JavaScript]` Creates an Iterator type */
-  public Iterator<T extends TSchema>(items: T, options?: SchemaOptions): TIterator<T> {
+  public Iterator<Type extends TSchema>(items: Type, options?: SchemaOptions): TIterator<Type> {
     return Iterator(items, options)
   }
   /** `[JavaScript]` Extracts the Parameters from the given Function type */
-  public Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T> {
+  public Parameters<Type extends TFunction>(schema: Type, options?: SchemaOptions): TParameters<Type> {
     return Parameters(schema, options)
   }
   /** `[JavaScript]` Creates a Promise type */
-  public Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T> {
+  public Promise<Type extends TSchema>(item: Type, options?: SchemaOptions): TPromise<Type> {
     return Promise(item, options)
   }
   /** `[JavaScript]` Creates a RegExp type */
@@ -101,8 +101,8 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     return RegExp(unresolved as any, options)
   }
   /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-  public ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T> {
-    return ReturnType(schema, options)
+  public ReturnType<Type extends TFunction>(type: Type, options?: SchemaOptions): TReturnType<Type> {
+    return ReturnType(type, options)
   }
   /** `[JavaScript]` Creates a Symbol type */
   public Symbol(options?: SchemaOptions): TSymbol {
diff --git a/src/type/type/json.ts b/src/type/type/json.ts
index 7613dc3f4..acc91ce1f 100644
--- a/src/type/type/json.ts
+++ b/src/type/type/json.ts
@@ -39,7 +39,7 @@ import { Index, TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type
 import { Integer, type IntegerOptions, type TInteger } from '../integer/index'
 import { Intersect, type IntersectOptions } from '../intersect/index'
 import { Capitalize, Uncapitalize, Lowercase, Uppercase, type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index'
-import { KeyOf, type TKeyOf, type TKeyOfFromMappedResult } from '../keyof/index'
+import { KeyOf, type TKeyOf } from '../keyof/index'
 import { Literal, type TLiteral, type TLiteralValue } from '../literal/index'
 import { Mapped, type TMappedFunction, type TMapped, type TMappedResult } from '../mapped/index'
 import { Never, type TNever } from '../never/index'
@@ -49,10 +49,10 @@ import { type TMappedKey } from '../mapped/index'
 import { Module, TModule } from '../module/index'
 import { Number, type TNumber, type NumberOptions } from '../number/index'
 import { Object, type TObject, type TProperties, type ObjectOptions } from '../object/index'
-import { Omit, type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from '../omit/index'
+import { Omit, type TOmit } from '../omit/index'
 import { Optional, type TOptionalWithFlag, type TOptionalFromMappedResult } from '../optional/index'
 import { Partial, type TPartial, type TPartialFromMappedResult } from '../partial/index'
-import { Pick, type TPick, type TPickFromMappedKey, type TPickFromMappedResult } from '../pick/index'
+import { Pick, type TPick } from '../pick/index'
 import { Readonly, type TReadonlyWithFlag, type TReadonlyFromMappedResult } from '../readonly/index'
 import { ReadonlyOptional, type TReadonlyOptional } from '../readonly-optional/index'
 import { Record, type TRecordOrObject } from '../record/index'
@@ -75,32 +75,32 @@ export class JsonTypeBuilder {
   // Modifiers
   // ------------------------------------------------------------------------
   /** `[Json]` Creates a Readonly and Optional property */
-  public ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T> {
-    return ReadonlyOptional(schema)
+  public ReadonlyOptional<Type extends TSchema>(type: Type): TReadonlyOptional<Type> {
+    return ReadonlyOptional(type)
   }
   /** `[Json]` Creates a Readonly property */
-  public Readonly<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TReadonlyFromMappedResult<T, F>
+  public Readonly<Type extends TMappedResult, Flag extends boolean>(type: Type, enable: Flag): TReadonlyFromMappedResult<Type, Flag>
   /** `[Json]` Creates a Readonly property */
-  public Readonly<T extends TSchema, F extends boolean>(schema: T, enable: F): TReadonlyWithFlag<T, F>
+  public Readonly<Type extends TSchema, Flag extends boolean>(type: Type, enable: Flag): TReadonlyWithFlag<Type, Flag>
   /** `[Json]` Creates a Optional property */
-  public Readonly<T extends TMappedResult>(schema: T): TReadonlyFromMappedResult<T, true>
+  public Readonly<Type extends TMappedResult>(type: Type): TReadonlyFromMappedResult<Type, true>
   /** `[Json]` Creates a Readonly property */
-  public Readonly<T extends TSchema>(schema: T): TReadonlyWithFlag<T, true>
+  public Readonly<Type extends TSchema>(type: Type): TReadonlyWithFlag<Type, true>
   /** `[Json]` Creates a Readonly property */
-  public Readonly(schema: TSchema, enable?: boolean): any {
-    return Readonly(schema, enable ?? true)
+  public Readonly(type: TSchema, enable?: boolean): any {
+    return Readonly(type, enable ?? true)
   }
   /** `[Json]` Creates a Optional property */
-  public Optional<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TOptionalFromMappedResult<T, F>
+  public Optional<Type extends TMappedResult, Flag extends boolean>(type: Type, enable: Flag): TOptionalFromMappedResult<Type, Flag>
   /** `[Json]` Creates a Optional property */
-  public Optional<T extends TSchema, F extends boolean>(schema: T, enable: F): TOptionalWithFlag<T, F>
+  public Optional<Type extends TSchema, Flag extends boolean>(type: Type, enable: Flag): TOptionalWithFlag<Type, Flag>
   /** `[Json]` Creates a Optional property */
-  public Optional<T extends TMappedResult>(schema: T): TOptionalFromMappedResult<T, true>
+  public Optional<Type extends TMappedResult>(type: Type): TOptionalFromMappedResult<Type, true>
   /** `[Json]` Creates a Optional property */
-  public Optional<T extends TSchema>(schema: T): TOptionalWithFlag<T, true>
+  public Optional<Type extends TSchema>(type: Type): TOptionalWithFlag<Type, true>
   /** `[Json]` Creates a Optional property */
-  public Optional(schema: TSchema, enable?: boolean): any {
-    return Optional(schema, enable ?? true)
+  public Optional(type: TSchema, enable?: boolean): any {
+    return Optional(type, enable ?? true)
   }
   // ------------------------------------------------------------------------
   // Types
@@ -110,8 +110,8 @@ export class JsonTypeBuilder {
     return Any(options)
   }
   /** `[Json]` Creates an Array type */
-  public Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T> {
-    return Array(schema, options)
+  public Array<Type extends TSchema>(items: Type, options?: ArrayOptions): TArray<Type> {
+    return Array(items, options)
   }
   /** `[Json]` Creates a Boolean type */
   public Boolean(options?: SchemaOptions): TBoolean {
@@ -164,40 +164,36 @@ export class JsonTypeBuilder {
     return Extract(type, union, options)
   }
   /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TSchema, K extends TMappedResult>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedResult<T, K>
+  public Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, key: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>
   /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>
+  public Index<Type extends TSchema, Key extends TMappedKey>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>
   /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>
+  public Index<Type extends TSchema, Key extends TMappedResult>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>
   /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>
+  public Index<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>
   /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index(schema: TSchema, unresolved: any, options?: SchemaOptions): any {
-    return Index(schema, unresolved, options)
+  public Index(type: TSchema, key: any, options?: SchemaOptions): any {
+    return Index(type, key, options)
   }
   /** `[Json]` Creates an Integer type */
   public Integer(options?: IntegerOptions): TInteger {
     return Integer(options)
   }
   /** `[Json]` Creates an Intersect type */
-  public Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T> {
-    return Intersect(T, options)
+  public Intersect<Types extends TSchema[]>(types: [...Types], options?: IntersectOptions): Intersect<Types> {
+    return Intersect(types, options)
   }
   /** `[Json]` Creates a KeyOf type */
-  public KeyOf<T extends TMappedResult>(schema: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>
-  /** `[Json]` Creates a KeyOf type */
-  public KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>
-  /** `[Json]` Creates a KeyOf type */
-  public KeyOf(schema: TSchema, options?: SchemaOptions): any {
-    return KeyOf(schema, options)
+  public KeyOf<Type extends TSchema>(type: Type, options?: SchemaOptions): TKeyOf<Type> {
+    return KeyOf(type, options) as never
   }
   /** `[Json]` Creates a Literal type */
-  public Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T> {
-    return Literal(value, options)
+  public Literal<LiteralValue extends TLiteralValue>(literalValue: LiteralValue, options?: SchemaOptions): TLiteral<LiteralValue> {
+    return Literal(literalValue, options)
   }
   /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-  public Lowercase<T extends TSchema>(schema: T, options?: SchemaOptions): TLowercase<T> {
-    return Lowercase(schema, options)
+  public Lowercase<Type extends TSchema>(type: Type, options?: SchemaOptions): TLowercase<Type> {
+    return Lowercase(type, options)
   }
   /** `[Json]` Creates a Mapped object type */
   public Mapped<K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>, F extends TMappedFunction<I> = TMappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R
@@ -216,8 +212,8 @@ export class JsonTypeBuilder {
     return Never(options)
   }
   /** `[Json]` Creates a Not type */
-  public Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T> {
-    return Not(schema, options)
+  public Not<T extends TSchema>(type: T, options?: SchemaOptions): TNot<T> {
+    return Not(type, options)
   }
   /** `[Json]` Creates a Null type */
   public Null(options?: SchemaOptions): TNull {
@@ -231,41 +227,33 @@ export class JsonTypeBuilder {
   public Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T> {
     return Object(properties, options)
   }
+  /** `[Json]` Constructs a type whose keys are picked from the given type */
+  public Omit<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TOmit<Type, Key>
+  /** `[Json]` Constructs a type whose keys are picked from the given type */
+  public Omit<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TOmit<Type, Key>
   /** `[Json]` Constructs a type whose keys are omitted from the given type */
-  public Omit<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TOmitFromMappedResult<T, K>
-  /** `[Json]` Constructs a type whose keys are omitted from the given type */
-  public Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TOmitFromMappedKey<T, K>
-  /** `[Json]` Constructs a type whose keys are omitted from the given type */
-  public Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>
-  /** `[Json]` Constructs a type whose keys are omitted from the given type */
-  public Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>
-  /** `[Json]` Constructs a type whose keys are omitted from the given type */
-  public Omit(schema: TSchema, unresolved: any, options?: SchemaOptions): any {
-    return Omit(schema, unresolved, options)
+  public Omit(schema: TSchema, selector: any, options?: SchemaOptions): any {
+    return Omit(schema, selector, options)
   }
   /** `[Json]` Constructs a type where all properties are optional */
-  public Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>
+  public Partial<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TPartialFromMappedResult<MappedResult>
   /** `[Json]` Constructs a type where all properties are optional */
-  public Partial<T extends TSchema>(schema: T, options?: SchemaOptions): TPartial<T>
+  public Partial<Type extends TSchema>(type: Type, options?: SchemaOptions): TPartial<Type>
   /** `[Json]` Constructs a type where all properties are optional */
-  public Partial(schema: TSchema, options?: SchemaOptions): any {
-    return Partial(schema, options)
+  public Partial(type: TSchema, options?: SchemaOptions): any {
+    return Partial(type, options)
   }
   /** `[Json]` Constructs a type whose keys are picked from the given type */
-  public Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>
-  /** `[Json]` Constructs a type whose keys are picked from the given type */
-  public Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TPickFromMappedKey<T, K>
-  /** `[Json]` Constructs a type whose keys are picked from the given type */
-  public Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>
+  public Pick<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TPick<Type, Key>
   /** `[Json]` Constructs a type whose keys are picked from the given type */
-  public Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>
+  public Pick<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TPick<Type, Key>
   /** `[Json]` Constructs a type whose keys are picked from the given type */
-  public Pick(schema: TSchema, unresolved: any, options?: SchemaOptions): any {
-    return Pick(schema, unresolved, options)
+  public Pick(type: any, key: any, options?: SchemaOptions): any {
+    return Pick(type, key, options)
   }
   /** `[Json]` Creates a Record type */
-  public Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecordOrObject<K, T> {
-    return Record(key, schema, options)
+  public Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: ObjectOptions): TRecordOrObject<Key, Value> {
+    return Record(key, value, options)
   }
   /** `[Json]` Creates a Recursive type */
   public Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T> {
@@ -276,44 +264,44 @@ export class JsonTypeBuilder {
     return Ref($ref, options)
   }
   /** `[Json]` Constructs a type where all properties are required */
-  public Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>
+  public Required<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>
   /** `[Json]` Constructs a type where all properties are required */
-  public Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>
+  public Required<Type extends TSchema>(type: Type, options?: SchemaOptions): TRequired<Type>
   /** `[Json]` Constructs a type where all properties are required */
-  public Required(schema: TSchema, options?: SchemaOptions): any {
-    return Required(schema, options)
+  public Required(type: TSchema, options?: SchemaOptions): any {
+    return Required(type, options)
   }
   /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
-  public Rest<T extends TSchema>(schema: T): TRest<T> {
-    return Rest(schema)
+  public Rest<Type extends TSchema>(type: Type): TRest<Type> {
+    return Rest(type)
   }
   /** `[Json]` Creates a String type */
   public String(options?: StringOptions): TString {
     return String(options)
   }
   /** `[Json]` Creates a TemplateLiteral type from template dsl string */
-  public TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TTemplateLiteralSyntax<T>
+  public TemplateLiteral<Syntax extends string>(syntax: Syntax, options?: SchemaOptions): TTemplateLiteralSyntax<Syntax>
   /** `[Json]` Creates a TemplateLiteral type */
-  public TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>
+  public TemplateLiteral<Kinds extends TTemplateLiteralKind[]>(kinds: [...Kinds], options?: SchemaOptions): TTemplateLiteral<Kinds>
   /** `[Json]` Creates a TemplateLiteral type */
   public TemplateLiteral(unresolved: TTemplateLiteralKind[] | string, options?: SchemaOptions) {
     return TemplateLiteral(unresolved as any, options)
   }
   /** `[Json]` Creates a Transform type */
-  public Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I> {
-    return Transform(schema)
+  public Transform<Type extends TSchema>(type: Type): TransformDecodeBuilder<Type> {
+    return Transform(type)
   }
   /** `[Json]` Creates a Tuple type */
-  public Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T> {
-    return Tuple(items, options)
+  public Tuple<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): TTuple<Types> {
+    return Tuple(types, options)
   }
   /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-  public Uncapitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TUncapitalize<T> {
-    return Uncapitalize(schema, options)
+  public Uncapitalize<Type extends TSchema>(type: Type, options?: SchemaOptions): TUncapitalize<Type> {
+    return Uncapitalize(type, options)
   }
   /** `[Json]` Creates a Union type */
-  public Union<T extends TSchema[]>(schemas: [...T], options?: SchemaOptions): Union<T> {
-    return Union(schemas, options)
+  public Union<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): Union<Types> {
+    return Union(types, options)
   }
   /** `[Json]` Creates an Unknown type */
   public Unknown(options?: SchemaOptions): TUnknown {
diff --git a/src/type/union/union-evaluated.ts b/src/type/union/union-evaluated.ts
index 9e4004a20..8ba1eb21b 100644
--- a/src/type/union/union-evaluated.ts
+++ b/src/type/union/union-evaluated.ts
@@ -44,43 +44,43 @@ import { IsOptional } from '../guard/kind'
 // IsUnionOptional
 // ------------------------------------------------------------------
 // prettier-ignore
-type TIsUnionOptional<T extends TSchema[]> = (
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? 
-    L extends TOptional<TSchema> 
+type TIsUnionOptional<Types extends TSchema[]> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? 
+    Left extends TOptional<TSchema> 
       ? true 
-      : TIsUnionOptional<R> 
+      : TIsUnionOptional<Right> 
     : false
 )
 // prettier-ignore
-function IsUnionOptional<T extends TSchema[]>(T: T): TIsUnionOptional<T> {
-  return T.some(L => IsOptional(L)) as never
+function IsUnionOptional<Types extends TSchema[]>(types: Types): TIsUnionOptional<Types> {
+  return types.some(type => IsOptional(type)) as never
 }
 // ------------------------------------------------------------------
 // RemoveOptionalFromRest
 // ------------------------------------------------------------------
 // prettier-ignore
-type TRemoveOptionalFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? L extends TOptional<infer S extends TSchema>
-      ? TRemoveOptionalFromRest<R, [...Acc, TRemoveOptionalFromType<S>]>
-      : TRemoveOptionalFromRest<R, [...Acc, L]>
-    : Acc
+type TRemoveOptionalFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
+    ? Left extends TOptional<infer S extends TSchema>
+      ? TRemoveOptionalFromRest<Right, [...Result, TRemoveOptionalFromType<S>]>
+      : TRemoveOptionalFromRest<Right, [...Result, Left]>
+    : Result
 )
 // prettier-ignore
-function RemoveOptionalFromRest<T extends TSchema[]>(T: T): TRemoveOptionalFromRest<T> {
-  return T.map(L => IsOptional(L) ? RemoveOptionalFromType(L) : L) as never
+function RemoveOptionalFromRest<Types extends TSchema[]>(types: Types): TRemoveOptionalFromRest<Types> {
+  return types.map(left => IsOptional(left) ? RemoveOptionalFromType(left) : left) as never
 }
 // ------------------------------------------------------------------
 // RemoveOptionalFromType
 // ------------------------------------------------------------------
 // prettier-ignore
-type TRemoveOptionalFromType<T extends TSchema> = (
-  T extends TReadonly<infer S extends TSchema> ? TReadonly<TRemoveOptionalFromType<S>> :
-  T extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromType<S> :
-  T
+type TRemoveOptionalFromType<Type extends TSchema> = (
+  Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TRemoveOptionalFromType<Type>> :
+  Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromType<Type> :
+  Type
 )
 // prettier-ignore
-function RemoveOptionalFromType<T extends TSchema>(T: T): TRemoveOptionalFromType<T> {
+function RemoveOptionalFromType<Type extends TSchema>(T: Type): TRemoveOptionalFromType<Type> {
   return (
     Discard(T, [OptionalKind])
   ) as never
@@ -89,34 +89,38 @@ function RemoveOptionalFromType<T extends TSchema>(T: T): TRemoveOptionalFromTyp
 // ResolveUnion
 // ------------------------------------------------------------------
 // prettier-ignore
-type TResolveUnion<T extends TSchema[], R extends TSchema[] = TRemoveOptionalFromRest<T>> = (
-  TIsUnionOptional<T> extends true 
-    ? TOptional<TUnion<R>> 
-    : TUnion<R>
+type TResolveUnion<Types extends TSchema[], 
+  Result extends TSchema[] = TRemoveOptionalFromRest<Types>,
+  IsOptional extends boolean = TIsUnionOptional<Types>
+> = (
+  IsOptional extends true 
+    ? TOptional<TUnion<Result>> 
+    : TUnion<Result>
 )
 // prettier-ignore
-function ResolveUnion<T extends TSchema[]>(T: T, options?: SchemaOptions): TResolveUnion<T> {
+function ResolveUnion<Types extends TSchema[]>(types: Types, options?: SchemaOptions): TResolveUnion<Types> {
+  const isOptional = IsUnionOptional(types)
   return (
-    IsUnionOptional(T)
-      ? Optional(UnionCreate(RemoveOptionalFromRest(T) as TSchema[], options))
-      : UnionCreate(RemoveOptionalFromRest(T) as TSchema[], options)
+    isOptional
+      ? Optional(UnionCreate(RemoveOptionalFromRest(types) as TSchema[], options))
+      : UnionCreate(RemoveOptionalFromRest(types) as TSchema[], options)
   ) as never
 }
 // ------------------------------------------------------------------
 // Union
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TUnionEvaluated<T extends TSchema[]> = (
-  T extends [] ? TNever :
-  T extends [TSchema] ? T[0] :
-  TResolveUnion<T>
+export type TUnionEvaluated<Types extends TSchema[]> = (
+  Types extends [TSchema] ? Types[0] :
+  Types extends [] ? TNever :
+  TResolveUnion<Types>
 )
 /** `[Json]` Creates an evaluated Union type */
-export function UnionEvaluated<T extends TSchema[], R = TUnionEvaluated<T>>(T: [...T], options?: SchemaOptions): R {
+export function UnionEvaluated<Types extends TSchema[], Result = TUnionEvaluated<Types>>(T: [...Types], options?: SchemaOptions): Result {
   // prettier-ignore
   return (
-    T.length === 0 ? Never(options) :
     T.length === 1 ? CreateType(T[0], options) :
+    T.length === 0 ? Never(options) :
     ResolveUnion(T, options)
   ) as never
 }
diff --git a/src/type/union/union.ts b/src/type/union/union.ts
index a057141c8..bacffbd19 100644
--- a/src/type/union/union.ts
+++ b/src/type/union/union.ts
@@ -39,11 +39,11 @@ export type Union<T extends TSchema[]> = (
   TUnion<T>
 )
 /** `[Json]` Creates a Union type */
-export function Union<T extends TSchema[]>(T: [...T], options?: SchemaOptions): Union<T> {
+export function Union<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): Union<Types> {
   // prettier-ignore
   return (
-    T.length === 0 ? Never(options) :
-    T.length === 1 ? CreateType(T[0], options) :
-    UnionCreate(T, options)
-  ) as Union<T>
+    types.length === 0 ? Never(options) :
+    types.length === 1 ? CreateType(types[0], options) :
+    UnionCreate(types, options)
+  ) as Union<Types>
 }
diff --git a/src/value/check/check.ts b/src/value/check/check.ts
index b1af0dd26..c5244e22a 100644
--- a/src/value/check/check.ts
+++ b/src/value/check/check.ts
@@ -75,9 +75,9 @@ import type { TVoid } from '../../type/void/index'
 // ------------------------------------------------------------------
 import { IsArray, IsUint8Array, IsDate, IsPromise, IsFunction, IsAsyncIterator, IsIterator, IsBoolean, IsNumber, IsBigInt, IsString, IsSymbol, IsInteger, IsNull, IsUndefined } from '../guard/index'
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
-import { IsSchema } from '../../type/guard/type'
+import { IsSchema } from '../../type/guard/kind'
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
diff --git a/src/value/transform/decode.ts b/src/value/transform/decode.ts
index 2498058b1..013b0abd1 100644
--- a/src/value/transform/decode.ts
+++ b/src/value/transform/decode.ts
@@ -51,9 +51,9 @@ import type { TUnion } from '../../type/union/index'
 // ------------------------------------------------------------------
 import { HasPropertyKey, IsObject, IsArray, IsValueType, IsUndefined as IsUndefinedValue } from '../guard/index'
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
-import { IsTransform, IsSchema, IsUndefined } from '../../type/guard/type'
+import { IsTransform, IsSchema, IsUndefined } from '../../type/guard/kind'
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
diff --git a/src/value/transform/encode.ts b/src/value/transform/encode.ts
index 1f033dc79..3ac8c54c8 100644
--- a/src/value/transform/encode.ts
+++ b/src/value/transform/encode.ts
@@ -51,9 +51,9 @@ import type { TUnion } from '../../type/union/index'
 // ------------------------------------------------------------------
 import { HasPropertyKey, IsObject, IsArray, IsValueType, IsUndefined as IsUndefinedValue } from '../guard/index'
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
-import { IsTransform, IsSchema, IsUndefined } from '../../type/guard/type'
+import { IsTransform, IsSchema, IsUndefined } from '../../type/guard/kind'
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
diff --git a/src/value/transform/has.ts b/src/value/transform/has.ts
index 7481d86a1..5a0d785c3 100644
--- a/src/value/transform/has.ts
+++ b/src/value/transform/has.ts
@@ -46,9 +46,9 @@ import type { TTuple } from '../../type/tuple/index'
 import type { TUnion } from '../../type/union/index'
 
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
-import { IsTransform, IsSchema } from '../../type/guard/type'
+import { IsTransform, IsSchema } from '../../type/guard/kind'
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
diff --git a/test/runtime/type/guard/kind/import.ts b/test/runtime/type/guard/kind/import.ts
index ee430ad6d..5feb06523 100644
--- a/test/runtime/type/guard/kind/import.ts
+++ b/test/runtime/type/guard/kind/import.ts
@@ -2,14 +2,154 @@ import { KindGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../../assert/index'
 
-describe('guard/type/TImport', () => {
+describe('guard/kind/TImport', () => {
   it('Should guard for TImport', () => {
-    const M = Type.Module({
+    const Module = Type.Module({
       A: Type.String(),
     })
-    const I = M.Import('A')
-    const N = I.$defs[I.$ref]
-    Assert.IsTrue(KindGuard.IsImport(I))
+    const A = Module.Import('A')
+    const N = A.$defs[A.$ref]
+    Assert.IsTrue(KindGuard.IsImport(A))
     Assert.IsTrue(KindGuard.IsString(N))
   })
+  // ----------------------------------------------------------------
+  // Computed: Awaited
+  // ----------------------------------------------------------------
+  it('Should compute for Awaited', () => {
+    const Module = Type.Module({
+      T: Type.Promise(Type.String()),
+      R: Type.Awaited(Type.Ref('T')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(KindGuard.IsString(T.$defs['R']))
+  })
+  // ----------------------------------------------------------------
+  // Computed: Index (Note: Pending Reimplementation of Index)
+  // ----------------------------------------------------------------
+  it('Should compute for Index 2', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number(), y: Type.String() }),
+      I: Type.Literal('x'),
+      R: Type.Index(Type.Ref('T'), Type.Ref('I')) as never, // fail
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(KindGuard.IsNumber(T.$defs['R']))
+  })
+  // ----------------------------------------------------------------
+  // Computed: Omit
+  // ----------------------------------------------------------------
+  it('Should compute for Omit 1', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number(), y: Type.Number() }),
+      R: Type.Omit(Type.Ref('T'), Type.Literal('x')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(KindGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(KindGuard.IsNumber(T.$defs['R'].properties.y))
+    // @ts-ignore
+    Assert.IsTrue(T.$defs['R'].properties.x === undefined)
+  })
+  it('Should compute for Omit 2', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number(), y: Type.Number() }),
+      K: Type.Literal('x'),
+      R: Type.Omit(Type.Ref('T'), Type.Ref('K')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(KindGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(KindGuard.IsNumber(T.$defs['R'].properties.y))
+    // @ts-ignore
+    Assert.IsTrue(T.$defs['R'].properties.x === undefined)
+  })
+  // ----------------------------------------------------------------
+  // Computed: Partial
+  // ----------------------------------------------------------------
+  it('Should compute for Partial', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number() }),
+      R: Type.Partial(Type.Ref('T')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(KindGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(KindGuard.IsNumber(T.$defs['R'].properties.x))
+    Assert.IsTrue(KindGuard.IsOptional(T.$defs['R'].properties.x))
+  })
+  // ----------------------------------------------------------------
+  // Computed: Pick
+  // ----------------------------------------------------------------
+  it('Should compute for Pick 1', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number(), y: Type.Number() }),
+      R: Type.Pick(Type.Ref('T'), Type.Literal('x')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(KindGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(KindGuard.IsNumber(T.$defs['R'].properties.x))
+    // @ts-ignore
+    Assert.IsTrue(T.$defs['R'].properties.y === undefined)
+  })
+  it('Should compute for Pick 2', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number(), y: Type.Number() }),
+      K: Type.Literal('x'),
+      R: Type.Pick(Type.Ref('T'), Type.Ref('K')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(KindGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(KindGuard.IsNumber(T.$defs['R'].properties.x))
+    // @ts-ignore
+    Assert.IsTrue(T.$defs['R'].properties.y === undefined)
+  })
+  // ----------------------------------------------------------------
+  // Computed: Record
+  // ----------------------------------------------------------------
+  it('Should compute for Record 1', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number(), y: Type.String() }),
+      R: Type.Record(Type.String(), Type.Ref('T')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(KindGuard.IsRecord(T.$defs['R']))
+    Assert.IsTrue(KindGuard.IsNumber(T.$defs['R'].patternProperties['^(.*)$'].properties.x))
+    Assert.IsTrue(KindGuard.IsString(T.$defs['R'].patternProperties['^(.*)$'].properties.y))
+  })
+  it('Should compute for Record 2', () => {
+    const Module = Type.Module({
+      T: Type.Number(),
+      K: Type.Union([Type.Literal('x'), Type.Literal('y')]),
+      R: Type.Record(Type.Ref('K'), Type.Ref('T')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(KindGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(KindGuard.IsNumber(T.$defs['R'].properties.x))
+    Assert.IsTrue(KindGuard.IsNumber(T.$defs['R'].properties.x))
+  })
+  // ----------------------------------------------------------------
+  // Computed: Required
+  // ----------------------------------------------------------------
+  it('Should compute for Required', () => {
+    const Module = Type.Module({
+      T: Type.Partial(Type.Object({ x: Type.Number() })),
+      R: Type.Required(Type.Ref('T')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(KindGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(KindGuard.IsNumber(T.$defs['R'].properties.x))
+    Assert.IsFalse(KindGuard.IsOptional(T.$defs['R'].properties.x))
+  })
+  // ----------------------------------------------------------------
+  // Computed: KeyOf
+  // ----------------------------------------------------------------
+  it('Should compute for KeyOf', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number(), y: Type.String() }),
+      R: Type.KeyOf(Type.Ref('T')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(KindGuard.IsUnion(T.$defs['R']))
+    Assert.IsTrue(KindGuard.IsLiteral(T.$defs['R'].anyOf[0]))
+    Assert.IsTrue(KindGuard.IsLiteral(T.$defs['R'].anyOf[1]))
+    Assert.IsTrue(T.$defs['R'].anyOf[0].const === 'x')
+    Assert.IsTrue(T.$defs['R'].anyOf[1].const === 'y')
+  })
 })
diff --git a/test/runtime/type/guard/type/import.ts b/test/runtime/type/guard/type/import.ts
index fdce650c6..f38124320 100644
--- a/test/runtime/type/guard/type/import.ts
+++ b/test/runtime/type/guard/type/import.ts
@@ -4,12 +4,152 @@ import { Assert } from '../../../assert/index'
 
 describe('guard/type/TImport', () => {
   it('Should guard for TImport', () => {
-    const M = Type.Module({
+    const Module = Type.Module({
       A: Type.String(),
     })
-    const I = M.Import('A')
-    const N = I.$defs[I.$ref]
-    Assert.IsTrue(TypeGuard.IsImport(I))
+    const A = Module.Import('A')
+    const N = A.$defs[A.$ref]
+    Assert.IsTrue(TypeGuard.IsImport(A))
     Assert.IsTrue(TypeGuard.IsString(N))
   })
+  // ----------------------------------------------------------------
+  // Computed: Awaited
+  // ----------------------------------------------------------------
+  it('Should compute for Awaited', () => {
+    const Module = Type.Module({
+      T: Type.Promise(Type.String()),
+      R: Type.Awaited(Type.Ref('T')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(TypeGuard.IsString(T.$defs['R']))
+  })
+  // ----------------------------------------------------------------
+  // Computed: Index (Note: Pending Reimplementation of Index)
+  // ----------------------------------------------------------------
+  it('Should compute for Index 2', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number(), y: Type.String() }),
+      I: Type.Literal('x'),
+      R: Type.Index(Type.Ref('T'), Type.Ref('I')) as never, // fail
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R']))
+  })
+  // ----------------------------------------------------------------
+  // Computed: Omit
+  // ----------------------------------------------------------------
+  it('Should compute for Omit 1', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number(), y: Type.Number() }),
+      R: Type.Omit(Type.Ref('T'), Type.Literal('x')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(TypeGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R'].properties.y))
+    // @ts-ignore
+    Assert.IsTrue(T.$defs['R'].properties.x === undefined)
+  })
+  it('Should compute for Omit 2', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number(), y: Type.Number() }),
+      K: Type.Literal('x'),
+      R: Type.Omit(Type.Ref('T'), Type.Ref('K')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(TypeGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R'].properties.y))
+    // @ts-ignore
+    Assert.IsTrue(T.$defs['R'].properties.x === undefined)
+  })
+  // ----------------------------------------------------------------
+  // Computed: Partial
+  // ----------------------------------------------------------------
+  it('Should compute for Partial', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number() }),
+      R: Type.Partial(Type.Ref('T')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(TypeGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R'].properties.x))
+    Assert.IsTrue(TypeGuard.IsOptional(T.$defs['R'].properties.x))
+  })
+  // ----------------------------------------------------------------
+  // Computed: Pick
+  // ----------------------------------------------------------------
+  it('Should compute for Pick 1', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number(), y: Type.Number() }),
+      R: Type.Pick(Type.Ref('T'), Type.Literal('x')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(TypeGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R'].properties.x))
+    // @ts-ignore
+    Assert.IsTrue(T.$defs['R'].properties.y === undefined)
+  })
+  it('Should compute for Pick 2', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number(), y: Type.Number() }),
+      K: Type.Literal('x'),
+      R: Type.Pick(Type.Ref('T'), Type.Ref('K')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(TypeGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R'].properties.x))
+    // @ts-ignore
+    Assert.IsTrue(T.$defs['R'].properties.y === undefined)
+  })
+  // ----------------------------------------------------------------
+  // Computed: Record
+  // ----------------------------------------------------------------
+  it('Should compute for Record 1', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number(), y: Type.String() }),
+      R: Type.Record(Type.String(), Type.Ref('T')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(TypeGuard.IsRecord(T.$defs['R']))
+    Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R'].patternProperties['^(.*)$'].properties.x))
+    Assert.IsTrue(TypeGuard.IsString(T.$defs['R'].patternProperties['^(.*)$'].properties.y))
+  })
+  it('Should compute for Record 2', () => {
+    const Module = Type.Module({
+      T: Type.Number(),
+      K: Type.Union([Type.Literal('x'), Type.Literal('y')]),
+      R: Type.Record(Type.Ref('K'), Type.Ref('T')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(TypeGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R'].properties.x))
+    Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R'].properties.x))
+  })
+  // ----------------------------------------------------------------
+  // Computed: Required
+  // ----------------------------------------------------------------
+  it('Should compute for Required', () => {
+    const Module = Type.Module({
+      T: Type.Partial(Type.Object({ x: Type.Number() })),
+      R: Type.Required(Type.Ref('T')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(TypeGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R'].properties.x))
+    Assert.IsFalse(TypeGuard.IsOptional(T.$defs['R'].properties.x))
+  })
+  // ----------------------------------------------------------------
+  // Computed: KeyOf
+  // ----------------------------------------------------------------
+  it('Should compute for KeyOf', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number(), y: Type.String() }),
+      R: Type.KeyOf(Type.Ref('T')),
+    })
+    const T = Module.Import('R')
+    Assert.IsTrue(TypeGuard.IsUnion(T.$defs['R']))
+    Assert.IsTrue(TypeGuard.IsLiteral(T.$defs['R'].anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsLiteral(T.$defs['R'].anyOf[1]))
+    Assert.IsTrue(T.$defs['R'].anyOf[0].const === 'x')
+    Assert.IsTrue(T.$defs['R'].anyOf[1].const === 'y')
+  })
 })
diff --git a/test/static/pick.ts b/test/static/pick.ts
index de29ba4bb..895cdefac 100644
--- a/test/static/pick.ts
+++ b/test/static/pick.ts
@@ -27,7 +27,7 @@ import { Type, Static } from '@sinclair/typebox'
 
   const keys = ['A', 'B'] as const
 
-  const T = Type.Pick(A, keys)
+  const T = Type.Pick(A, ['A', 'B'])
 
   type T = Static<typeof T>
 

From b9cc4cdc5e54648c3400314462ea0585a509dfd3 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Sun, 17 Nov 2024 09:34:07 +0900
Subject: [PATCH 306/369] Revision 0.34.2 (#1082)

* Fix Import Path

* Version

* ChangeLog
---
 changelog/0.34.0.md      | 2 ++
 package-lock.json        | 4 ++--
 package.json             | 2 +-
 src/type/pick/pick.ts    | 2 +-
 src/value/clean/clean.ts | 2 +-
 5 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index e9f754629..8ac95c625 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,6 +1,8 @@
 ### 0.34.0
 - [Revision 0.34.1](https://github.com/sinclairzx81/typebox/pull/1080)
   - Implement Computed Type Deref in Modules
+- [Revision 0.34.2](https://github.com/sinclairzx81/typebox/pull/1082)
+  - Resolve import pathing issue introduced on 0.34.1
 
 ## [0.34.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.34.0)
 
diff --git a/package-lock.json b/package-lock.json
index 3dab50690..90dad4af4 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.1",
+  "version": "0.34.2",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.1",
+      "version": "0.34.2",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 5c9bf671d..f3ec946e4 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.1",
+  "version": "0.34.2",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/pick/pick.ts b/src/type/pick/pick.ts
index f9b988f46..fc690845f 100644
--- a/src/type/pick/pick.ts
+++ b/src/type/pick/pick.ts
@@ -45,7 +45,7 @@ import { TransformKind } from '../symbols/symbols'
 // Guards
 // ------------------------------------------------------------------
 import { IsMappedKey, IsMappedResult, IsIntersect, IsUnion, IsObject, IsSchema, IsLiteralValue, IsRef } from '../guard/kind'
-import { IsArray as IsArrayValue } from 'src/value/guard'
+import { IsArray as IsArrayValue } from '../guard/value'
 
 // ------------------------------------------------------------------
 // Infrastructure
diff --git a/src/value/clean/clean.ts b/src/value/clean/clean.ts
index 341cf025e..41e7f4edb 100644
--- a/src/value/clean/clean.ts
+++ b/src/value/clean/clean.ts
@@ -34,7 +34,7 @@ import { Kind } from '../../type/symbols/index'
 
 import type { TSchema } from '../../type/schema/index'
 import type { TArray } from '../../type/array/index'
-import type { TImport } from 'src/type/module/index'
+import type { TImport } from '../../type/module/index'
 import type { TIntersect } from '../../type/intersect/index'
 import type { TObject } from '../../type/object/index'
 import type { TRecord } from '../../type/record/index'

From 199274271bf626965b681898041ada6d1d7fc498 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Mon, 18 Nov 2024 01:59:25 +0900
Subject: [PATCH 307/369] Revision 0.34.3 (#1083)

* Retain Array on Value Default

* Version

* ChangeLog
---
 changelog/0.34.0.md                 |  7 +++++--
 package-lock.json                   |  4 ++--
 package.json                        |  2 +-
 src/value/default/default.ts        |  8 ++++++++
 test/runtime/value/default/array.ts | 26 ++++++++++++++++++++++++++
 5 files changed, 42 insertions(+), 5 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 8ac95c625..147528f62 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,8 +1,11 @@
 ### 0.34.0
-- [Revision 0.34.1](https://github.com/sinclairzx81/typebox/pull/1080)
-  - Implement Computed Type Deref in Modules
+
+- [Revision 0.34.3](https://github.com/sinclairzx81/typebox/pull/1083)
+  - Retain Array Elements on Value Default
 - [Revision 0.34.2](https://github.com/sinclairzx81/typebox/pull/1082)
   - Resolve import pathing issue introduced on 0.34.1
+- [Revision 0.34.1](https://github.com/sinclairzx81/typebox/pull/1080)
+  - Implement Computed Type Deref in Modules
 
 ## [0.34.0](https://www.npmjs.com/package/@sinclair/typebox/v/0.34.0)
 
diff --git a/package-lock.json b/package-lock.json
index 90dad4af4..0f1d07436 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.2",
+  "version": "0.34.3",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.2",
+      "version": "0.34.3",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index f3ec946e4..b9148e246 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.2",
+  "version": "0.34.3",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/default/default.ts b/src/value/default/default.ts
index 30ddbc95b..e77cd0188 100644
--- a/src/value/default/default.ts
+++ b/src/value/default/default.ts
@@ -68,6 +68,14 @@ function HasDefaultProperty(schema: unknown): schema is TSchema {
 // Types
 // ------------------------------------------------------------------
 function FromArray(schema: TArray, references: TSchema[], value: unknown): any {
+  // if the value is an array, we attempt to initialize it's elements
+  if (IsArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      value[i] = Visit(schema.items, references, value[i])
+    }
+    return value
+  }
+  // ... otherwise use default initialization
   const defaulted = ValueOrDefault(schema, value)
   if (!IsArray(defaulted)) return defaulted
   for (let i = 0; i < defaulted.length; i++) {
diff --git a/test/runtime/value/default/array.ts b/test/runtime/value/default/array.ts
index be385e603..602f6562c 100644
--- a/test/runtime/value/default/array.ts
+++ b/test/runtime/value/default/array.ts
@@ -21,4 +21,30 @@ describe('value/default/Array', () => {
     const R = Value.Default(T, [1, undefined, 3])
     Assert.IsEqual(R, [1, 2, 3])
   })
+  // ----------------------------------------------------------------
+  // Elements
+  // ----------------------------------------------------------------
+  it('Should should retain array and only initialize undefined elements', () => {
+    const T = Type.Array(Type.Literal('hello', { default: 'hello' }))
+    const R = Value.Default(T, [1, undefined, 3])
+    Assert.IsEqual(R, [1, 'hello', 3])
+  })
+  // ----------------------------------------------------------------
+  // https://github.com/ubiquity-os-marketplace/command-start-stop/pull/86
+  // ----------------------------------------------------------------
+  it('Should retain arrays 1', () => {
+    const U = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C'), Type.Literal('D')], { default: 'A' })
+    const T = Type.Array(U, { default: ['A', 'B', 'C', 'D'], uniqueItems: true })
+    Assert.IsEqual(Value.Default(T, undefined), ['A', 'B', 'C', 'D'])
+    Assert.IsEqual(Value.Default(T, []), [])
+    Assert.IsEqual(Value.Default(T, ['A']), ['A'])
+    // initialize undefined element
+    Assert.IsEqual(Value.Default(T, [undefined, 'B', 'C', 'D']), ['A', 'B', 'C', 'D'])
+  })
+  it('Should retain arrays 2', () => {
+    const U = Type.Union([Type.Literal('A'), Type.Literal('B'), Type.Literal('C'), Type.Literal('D')], { default: 'A' })
+    // undefined first element initialized by union default
+    const T = Type.Array(U, { default: [undefined, 'B', 'C', 'D'], uniqueItems: true })
+    Assert.IsEqual(Value.Default(T, undefined), ['A', 'B', 'C', 'D'])
+  })
 })

From ab4f0db84fe6f49c91e8ee348aa0c8f83398efef Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Mon, 18 Nov 2024 14:02:38 +0900
Subject: [PATCH 308/369] Documentation

---
 readme.md | 70 +++++++++++++++++++++++++++++++------------------------
 1 file changed, 39 insertions(+), 31 deletions(-)

diff --git a/readme.md b/readme.md
index 0d3ec1cb1..8b1eeb35a 100644
--- a/readme.md
+++ b/readme.md
@@ -774,39 +774,47 @@ type T = Static<typeof T>                            // type T = string | null
 
 ### Module Types
 
-TypeBox Modules are containers for related types. They function as namespaces and enable internal types to reference each other via string references. Modules support both singular and mutually recursive types. They provide a mechanism to create circular types irrespective of the order in which types are defined.
+TypeBox Modules are containers for related types. They provide a referential namespace, enabling types to reference one another via string identifiers. Modules support both singular and mutually recursive referencing within the context of a module, as well as referential computed types (such as Partial + Ref). All Module types must be imported before use. TypeBox represents an imported type with the `$defs` Json Schema keyword. 
 
-```typescript
+#### Usage
+
+The following creates a Module with User and PartialUser types. Note that the PartialUser type is specified as a Partial + Ref to the User type. It is not possible to perform a Partial operation directly on a reference, so TypeBox will return a TComputed type that defers the Partial operation until all types are resolved. The TComputed type is evaluated when calling Import on the Module.
 
-// The following creates a Module of circular recursive Types.
+```typescript
+// Module with PartialUser and User types
 
 const Module = Type.Module({
-  A: Type.Object({ 
-    b: Type.Ref('B') // Ref B:
-  }),
-  B: Type.Object({
-    c: Type.Ref('C') // Ref C:
-  }),
-  C: Type.Object({
-    a: Type.Ref('A') // Ref A:
-  }),
+
+  PartialUser: Type.Partial(Type.Ref('User')),  // TComputed<'Partial', [TRef<'User'>]>
+
+  User: Type.Object({                           // TObject<{
+    id: Type.String(),                          //   user: TString,
+    name: Type.String(),                        //   name: TString,
+    email: Type.String()                        //   email: TString
+  }),                                           // }>
+  
 })
 
-// Module Types must be imported before use.
+// Types must be imported before use.
 
-const A = Module.Import('A')                     // const A: TImport<{...}, 'A'>
+const User = Module.Import('User')               // const User: TImport<{...}, 'User'>
 
-type A = Static<typeof A>                        // type A = { 
-                                                 //   b: {
-                                                 //     c: {
-                                                 //       a: {
-                                                 //         b: ...
-                                                 //       }
-                                                 //     }
-                                                 //   }
+type User = Static<typeof User>                  // type User = { 
+                                                 //   id: string,
+                                                 //   name: string,
+                                                 //   email: string
+                                                 // }
+
+const PartialUser = Module.Import('PartialUser') // const PartialUser: TImport<{...}, 'PartialUser'>
+
+type PartialUser = Static<typeof PartialUser>    // type PartialUser = { 
+                                                 //   id?: string,
+                                                 //   name?: string,
+                                                 //   email?: string
                                                  // }
 ```
 
+
 <a name='types-template-literal'></a>
 
 ### Template Literal Types
@@ -1025,7 +1033,7 @@ if(TypeGuard.IsString(T)) {
 
 ## Syntax Types
 
-TypeBox provides support for Syntax Types, enabling it to parse TypeScript syntax directly into TypeBox types. Syntax Types serve as a DSL frontend for TypeBox's type builder and are useful for converting existing TypeScript type definitions into Json Schema schematics.
+TypeBox provides support for parsing TypeScript syntax directly into TypeBox Json Schema schematics. Syntax Types offer a string based DSL frontend to TypeBox's Type Builder system and can be useful for converting existing TypeScript type definitions into Json Schema schematics without reimplementation via the Type Builder.
 
 Syntax Types are provided via optional import.
 
@@ -1106,14 +1114,14 @@ type PartialUser = Static<typeof PartialUser>       // type PartialUser = {
 
 ### Context
 
-The Parse function accepts an initial Context argument, allowing external types to be passed into the parser.
+The Parse function takes an optional leading Context object that contains external types. This Context allows the syntax to reference these external types using the property identifiers provided by the Context. The following passes the external type `T` to Parse.
 
 ```typescript
-const T = Type.Object({                             // could be written as: Parse(`{
-  x: Type.Number(),                                 //   x: number,
-  y: Type.Number(),                                 //   y: number,
-  z: Type.Number()                                  //   z: number
-})                                                  // }`)
+const T = Type.Object({                             // const T: TObject<{
+  x: Type.Number(),                                 //   x: TNumber,
+  y: Type.Number(),                                 //   y: TNumber,
+  z: Type.Number()                                  //   z: TNumber
+})                                                  // }>
 
 const A = Parse({ T }, 'Partial<T>')                // const A: TObject<{
                                                     //   x: TOptional<TNumber>,
@@ -1140,7 +1148,7 @@ const C = Parse({ T }, 'T & { w: number }')         // const C: TIntersect<[TObj
 
 ### Static
 
-Syntax Types provide two Static types for inferring TypeScript syntax from strings.
+Syntax Types provide two Static types for inferring TypeScript types and TypeBox schematics from strings.
 
 ```typescript
 import { StaticParseAsSchema, StaticParseAsType } from '@sinclair/typebox/syntax' 
@@ -1190,7 +1198,7 @@ const B = Parse(`{
 }`)
 ```
 
-In cases where Syntax Types busts through TypeScript instantiation limits, TypeBox offers a fallback ParseOnly function which will Parse the types at runtime, but not infer the type. This function can also be used for parsing non-constant strings.
+In cases where Syntax Types exceed TypeScript's instantiation limits, TypeBox offers a fallback ParseOnly function, which will only parse but not infer. This function can also be used to parse types where the syntax is statically unknown to TypeScript (for example, when loading types from disk).
 
 ```typescript
 import { ParseOnly } from '@sinclair/typebox/syntax'

From cc5f2a3cbef835ff528a9cf5361000fdc2e1f6c5 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Tue, 19 Nov 2024 14:03:48 +0900
Subject: [PATCH 309/369] Revision 0.34.4 (#1085)

* Module Dereference Path for TEnum

* Version

* ChangeLog
---
 changelog/0.34.0.md        |  2 ++
 package-lock.json          |  4 ++--
 package.json               |  2 +-
 src/type/module/compute.ts | 32 ++++++++++++++++--------------
 src/type/module/infer.ts   |  2 ++
 test/static/import.ts      | 40 ++++++++++++++++++++++++++++++++++++++
 test/static/index.ts       |  1 +
 7 files changed, 65 insertions(+), 18 deletions(-)
 create mode 100644 test/static/import.ts

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 147528f62..ce9473447 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,5 +1,7 @@
 ### 0.34.0
 
+- [Revision 0.34.4](https://github.com/sinclairzx81/typebox/pull/1085)
+  - Inference Path for Enum within Modules
 - [Revision 0.34.3](https://github.com/sinclairzx81/typebox/pull/1083)
   - Retain Array Elements on Value Default
 - [Revision 0.34.2](https://github.com/sinclairzx81/typebox/pull/1082)
diff --git a/package-lock.json b/package-lock.json
index 0f1d07436..c6ab24477 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.3",
+  "version": "0.34.4",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.3",
+      "version": "0.34.4",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index b9148e246..98ac92bda 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.3",
+  "version": "0.34.4",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/module/compute.ts b/src/type/module/compute.ts
index 47bf60851..1e9bca28d 100644
--- a/src/type/module/compute.ts
+++ b/src/type/module/compute.ts
@@ -35,6 +35,7 @@ import { AsyncIterator, type TAsyncIterator } from '../async-iterator/index'
 import { TComputed } from '../computed/index'
 import { Constructor, type TConstructor } from '../constructor/index'
 import { Index, type TIndex } from '../indexed/index'
+import { TEnum, TEnumRecord } from '../enum/index'
 import { Function, type TFunction } from '../function/index'
 import { Intersect, type TIntersect, type TIntersectEvaluated } from '../intersect/index'
 import { Iterator, type TIterator } from '../iterator/index'
@@ -339,34 +340,35 @@ function FromRest<ModuleProperties extends TProperties, Types extends TSchema[]>
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (
-  Type extends TComputed<infer T extends string, infer S extends TSchema[]> ? TFromComputed<ModuleProperties, T, S> :
-  Type extends TObject<infer S extends TProperties> ? TFromObject<ModuleProperties, S> :
-  Type extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TFromConstructor<ModuleProperties, S, R> :
-  Type extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFromFunction<ModuleProperties, S, R> :
-  Type extends TTuple<infer S extends TSchema[]> ? TFromTuple<ModuleProperties, S> :
-  Type extends TIntersect<infer S extends TSchema[]> ? TFromIntersect<ModuleProperties, S> :
-  Type extends TUnion<infer S extends TSchema[]> ? TFromUnion<ModuleProperties, S> :
-  Type extends TArray<infer S extends TSchema> ? TFromArray<ModuleProperties, S> :
-  Type extends TAsyncIterator<infer S extends TSchema> ? TFromAsyncIterator<ModuleProperties, S> :
-  Type extends TIterator<infer S extends TSchema> ? TFromIterator<ModuleProperties, S> :
+  Type extends TArray<infer Type extends TSchema> ? TFromArray<ModuleProperties, Type> :
+  Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<ModuleProperties, Type> :
+  Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<ModuleProperties, Target, Parameters> :
+  Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<ModuleProperties, Parameters, InstanceType> :
+  Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<ModuleProperties, Parameters, ReturnType> :
+  Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<ModuleProperties, Types> :
+  Type extends TIterator<infer Type extends TSchema> ? TFromIterator<ModuleProperties, Type> :
+  Type extends TObject<infer Properties extends TProperties> ? TFromObject<ModuleProperties, Properties> :
+  Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<ModuleProperties, Types> :
+  Type extends TEnum<infer _ extends TEnumRecord> ? Type : // intercept enum before union
+  Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<ModuleProperties, Types> :
   Type
 )
 // prettier-ignore
 export function FromType<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromType<ModuleProperties, Type> {
   return (
+    KindGuard.IsArray(type) ? CreateType(FromArray(moduleProperties, type.items), type) :
+    KindGuard.IsAsyncIterator(type) ? CreateType(FromAsyncIterator(moduleProperties, type.items), type) :
     // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
     // all need re-implementation to remove the PropertyKey[] selector. Reimplementation of these types should
     // be a priority as there is a potential for the current inference to break on TS compiler changes.
     KindGuard.IsComputed(type) ? CreateType(FromComputed(moduleProperties, type.target, type.parameters) as never) :
-    KindGuard.IsObject(type) ? CreateType(FromObject(moduleProperties, type.properties), type) :
     KindGuard.IsConstructor(type) ? CreateType(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
     KindGuard.IsFunction(type) ? CreateType(FromFunction(moduleProperties, type.parameters, type.returns), type) :
-    KindGuard.IsTuple(type)? CreateType(FromTuple(moduleProperties, type.items || []), type) :
     KindGuard.IsIntersect(type) ? CreateType(FromIntersect(moduleProperties, type.allOf), type) :
-    KindGuard.IsUnion(type) ? CreateType(FromUnion(moduleProperties, type.anyOf), type) :
-    KindGuard.IsArray(type) ? CreateType(FromArray(moduleProperties, type.items), type) :
-    KindGuard.IsAsyncIterator(type) ? CreateType(FromAsyncIterator(moduleProperties, type.items), type) :
     KindGuard.IsIterator(type) ? CreateType(FromIterator(moduleProperties, type.items), type) :
+    KindGuard.IsObject(type) ? CreateType(FromObject(moduleProperties, type.properties), type) :
+    KindGuard.IsTuple(type)? CreateType(FromTuple(moduleProperties, type.items || []), type) :
+    KindGuard.IsUnion(type) ? CreateType(FromUnion(moduleProperties, type.anyOf), type) :
     type
   ) as never
 }
diff --git a/src/type/module/infer.ts b/src/type/module/infer.ts
index 082b7f733..c71689f6a 100644
--- a/src/type/module/infer.ts
+++ b/src/type/module/infer.ts
@@ -31,6 +31,7 @@ import { TSchema } from '../schema/index'
 import { TArray } from '../array/index'
 import { TAsyncIterator } from '../async-iterator/index'
 import { TConstructor } from '../constructor/index'
+import { TEnum, TEnumRecord } from '../enum/index'
 import { TFunction } from '../function/index'
 import { TIntersect } from '../intersect/index'
 import { TIterator } from '../iterator/index'
@@ -147,6 +148,7 @@ type TInfer<ModuleProperties extends TProperties, Type extends TSchema> = (
   Type extends TObject<infer Properties extends TProperties> ? TInferObject<ModuleProperties, Properties> :
   Type extends TRef<infer Ref extends string> ? TInferRef<ModuleProperties, Ref> :
   Type extends TTuple<infer Types extends TSchema[]> ? TInferTuple<ModuleProperties, Types> :
+  Type extends TEnum<infer _ extends TEnumRecord> ? Static<Type> : // intercept enum before union
   Type extends TUnion<infer Types extends TSchema[]> ? TInferUnion<ModuleProperties, Types> :
   Static<Type>
 )
diff --git a/test/static/import.ts b/test/static/import.ts
new file mode 100644
index 000000000..bab132f11
--- /dev/null
+++ b/test/static/import.ts
@@ -0,0 +1,40 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+// ------------------------------------------------------------------
+// Enum 1
+// ------------------------------------------------------------------
+{
+  enum Enum {
+    A,
+    B,
+  }
+
+  const T = Type.Module({
+    T: Type.Object({
+      value: Type.Enum(Enum),
+    }),
+  }).Import('T')
+
+  Expect(T).ToStatic<{
+    value: Enum
+  }>()
+}
+
+// ------------------------------------------------------------------
+// Enum 2
+// ------------------------------------------------------------------
+{
+  const T = Type.Module({
+    T: Type.Object({
+      value: Type.Enum({
+        x: 1,
+        y: 2,
+      }),
+    }),
+  }).Import('T')
+
+  Expect(T).ToStatic<{
+    value: 1 | 2
+  }>()
+}
diff --git a/test/static/index.ts b/test/static/index.ts
index 9012f8682..c6af9e754 100644
--- a/test/static/index.ts
+++ b/test/static/index.ts
@@ -15,6 +15,7 @@ import './enum'
 import './extract'
 import './exclude'
 import './function'
+import './import'
 import './indexed'
 import './instance-type'
 import './intersect'

From 3bd7217f8645f479c51a8f03b81c9c3b65e24331 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Wed, 20 Nov 2024 15:27:46 +0900
Subject: [PATCH 310/369] Revision 0.34.5 (#1088)

* Record Types are not TCompute for TRef Value Type

* Apply Options to Import Target

* ChangeLog

* Version
---
 changelog/0.34.0.md                      |   3 +-
 package-lock.json                        |   4 +-
 package.json                             |   2 +-
 src/type/module/infer.ts                 |  20 ++-
 src/type/module/module.ts                |   3 +-
 src/type/record/record.ts                | 156 +++++++++++------------
 test/runtime/type/guard/kind/computed.ts |  28 ++++
 test/runtime/type/guard/kind/import.ts   |  42 +++++-
 test/runtime/type/guard/kind/index.ts    |   1 +
 test/runtime/type/guard/type/computed.ts |  28 ++++
 test/runtime/type/guard/type/import.ts   |  44 ++++++-
 test/runtime/type/guard/type/index.ts    |   1 +
 test/static/import.ts                    |  65 +++++++++-
 13 files changed, 304 insertions(+), 93 deletions(-)
 create mode 100644 test/runtime/type/guard/kind/computed.ts
 create mode 100644 test/runtime/type/guard/type/computed.ts

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index ce9473447..a43929440 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,5 +1,6 @@
 ### 0.34.0
-
+- [Revision 0.34.5](https://github.com/sinclairzx81/typebox/pull/1088)
+  - Record Types no longer TCompute for TRef Value Type (Modules)
 - [Revision 0.34.4](https://github.com/sinclairzx81/typebox/pull/1085)
   - Inference Path for Enum within Modules
 - [Revision 0.34.3](https://github.com/sinclairzx81/typebox/pull/1083)
diff --git a/package-lock.json b/package-lock.json
index c6ab24477..61ab83569 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.4",
+  "version": "0.34.5",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.4",
+      "version": "0.34.5",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 98ac92bda..f061e7736 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.4",
+  "version": "0.34.5",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/module/infer.ts b/src/type/module/infer.ts
index c71689f6a..65ca8fd13 100644
--- a/src/type/module/infer.ts
+++ b/src/type/module/infer.ts
@@ -37,6 +37,7 @@ import { TIntersect } from '../intersect/index'
 import { TIterator } from '../iterator/index'
 import { TObject, TProperties } from '../object/index'
 import { TOptional } from '../optional/index'
+import { TRecord } from '../record/index'
 import { TReadonly } from '../readonly/index'
 import { TRef } from '../ref/index'
 import { TTuple } from '../tuple/index'
@@ -83,16 +84,16 @@ type TInferIterator<ModuleProperties extends TProperties, Type extends TSchema>
 // ------------------------------------------------------------------
 // prettier-ignore
 type TInferIntersect<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown = unknown> = (
-  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TInferIntersect<ModuleProperties, R, Result & TInfer<ModuleProperties, L>>
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
+    ? TInferIntersect<ModuleProperties, Right, Result & TInfer<ModuleProperties, Left>>
     : Result
 )
 // ------------------------------------------------------------------
 // Object
 // ------------------------------------------------------------------
-type ReadonlyOptionalPropertyKeys<Properties extends TProperties> = { [K in keyof Properties]: Properties[K] extends TReadonly<TSchema> ? (Properties[K] extends TOptional<Properties[K]> ? K : never) : never }[keyof Properties]
-type ReadonlyPropertyKeys<Source extends TProperties> = { [K in keyof Source]: Source[K] extends TReadonly<TSchema> ? (Source[K] extends TOptional<Source[K]> ? never : K) : never }[keyof Source]
-type OptionalPropertyKeys<Source extends TProperties> = { [K in keyof Source]: Source[K] extends TOptional<TSchema> ? (Source[K] extends TReadonly<Source[K]> ? never : K) : never }[keyof Source]
+type ReadonlyOptionalPropertyKeys<Properties extends TProperties> = { [Key in keyof Properties]: Properties[Key] extends TReadonly<TSchema> ? (Properties[Key] extends TOptional<Properties[Key]> ? Key : never) : never }[keyof Properties]
+type ReadonlyPropertyKeys<Source extends TProperties> = { [Key in keyof Source]: Source[Key] extends TReadonly<TSchema> ? (Source[Key] extends TOptional<Source[Key]> ? never : Key) : never }[keyof Source]
+type OptionalPropertyKeys<Source extends TProperties> = { [Key in keyof Source]: Source[Key] extends TOptional<TSchema> ? (Source[Key] extends TReadonly<Source[Key]> ? never : Key) : never }[keyof Source]
 type RequiredPropertyKeys<Source extends TProperties> = keyof Omit<Source, ReadonlyOptionalPropertyKeys<Source> | ReadonlyPropertyKeys<Source> | OptionalPropertyKeys<Source>>
 // prettier-ignore
 type InferPropertiesWithModifiers<Properties extends TProperties, Source extends Record<keyof any, unknown>> = Evaluate<(
@@ -119,6 +120,14 @@ type TInferTuple<ModuleProperties extends TProperties, Types extends TSchema[] ,
     : Result
 )
 // ------------------------------------------------------------------
+// Record
+// ------------------------------------------------------------------
+// prettier-ignore
+type TInferRecord<ModuleProperties extends TProperties, Key extends TSchema, Type extends TSchema,
+  InferredKey extends PropertyKey = TInfer<ModuleProperties, Key> extends infer Key extends PropertyKey ? Key : never,
+  InferedType extends unknown = TInfer<ModuleProperties, Type>,
+> = Record<InferredKey, InferedType>
+// ------------------------------------------------------------------
 // Ref
 // ------------------------------------------------------------------
 // prettier-ignore
@@ -146,6 +155,7 @@ type TInfer<ModuleProperties extends TProperties, Type extends TSchema> = (
   Type extends TIntersect<infer Types extends TSchema[]> ? TInferIntersect<ModuleProperties, Types> :
   Type extends TIterator<infer Type extends TSchema> ? TInferIterator<ModuleProperties, Type> :
   Type extends TObject<infer Properties extends TProperties> ? TInferObject<ModuleProperties, Properties> :
+  Type extends TRecord<infer Key extends TSchema, infer Type extends TSchema> ? TInferRecord<ModuleProperties, Key, Type> :
   Type extends TRef<infer Ref extends string> ? TInferRef<ModuleProperties, Ref> :
   Type extends TTuple<infer Types extends TSchema[]> ? TInferTuple<ModuleProperties, Types> :
   Type extends TEnum<infer _ extends TEnumRecord> ? Static<Type> : // intercept enum before union
diff --git a/src/type/module/module.ts b/src/type/module/module.ts
index a4c2544e9..276332c3f 100644
--- a/src/type/module/module.ts
+++ b/src/type/module/module.ts
@@ -68,7 +68,8 @@ export class TModule<ModuleProperties extends TProperties, ComputedModulePropert
   }
   /** `[Json]` Imports a Type by Key. */
   public Import<Key extends keyof ComputedModuleProperties>(key: Key, options?: SchemaOptions): TImport<ComputedModuleProperties, Key> {
-    return CreateType({ [Kind]: 'Import', $defs: this.$defs, $ref: key }, options) as never
+    const $defs = { ...this.$defs, [key]: CreateType(this.$defs[key], options) }
+    return CreateType({ [Kind]: 'Import', $defs, $ref: key }) as never
   }
   // prettier-ignore
   private WithIdentifiers($defs: ComputedModuleProperties): ComputedModuleProperties {
diff --git a/src/type/record/record.ts b/src/type/record/record.ts
index 34a87f74d..782269644 100644
--- a/src/type/record/record.ts
+++ b/src/type/record/record.ts
@@ -27,26 +27,27 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { CreateType } from '../create/type'
+import { Kind, Hint } from '../symbols/index'
 import type { TSchema } from '../schema/index'
 import type { Static } from '../static/index'
 import type { Evaluate, Ensure, Assert } from '../helpers/index'
 import { type TAny } from '../any/index'
-import { Computed, type TComputed } from '../computed/index'
-import { Object, type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index'
+import { type TComputed, Computed } from '../computed/index'
+import { type TEnumRecord, type TEnum } from '../enum/index'
+import { type TInteger } from '../integer/index'
 import { type TLiteral, type TLiteralValue } from '../literal/index'
-import { Never, type TNever } from '../never/index'
-import { Union, type TUnion } from '../union/index'
+import { type TNever, Never } from '../never/index'
+import { type TNumber } from '../number/index'
+import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions, Object } from '../object/index'
+import { type TRef, Ref } from '../ref/index'
 import { type TRegExp } from '../regexp/index'
 import { type TString } from '../string/index'
-import { type TInteger } from '../integer/index'
-import { type TNumber } from '../number/index'
-import { type TEnum } from '../enum/index'
-import { type TRef } from '../ref/index'
+import { type TUnion, Union } from '../union/index'
 
 import { IsTemplateLiteralFinite, TIsTemplateLiteralFinite, type TTemplateLiteral } from '../template-literal/index'
 import { PatternStringExact, PatternNumberExact, PatternNeverExact } from '../patterns/index'
 import { IndexPropertyKeys } from '../indexed/index'
-import { Kind, Hint } from '../symbols/index'
+
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -61,36 +62,32 @@ import { IsInteger, IsLiteral, IsAny, IsNever, IsNumber, IsString, IsRegExp, IsT
 // ------------------------------------------------------------------
 // prettier-ignore
 function RecordCreateFromPattern(pattern: string, T: TSchema, options: ObjectOptions): TRecord<TSchema, TSchema> {
-  return CreateType({ 
-    [Kind]: 'Record', 
-    type: 'object', 
-    patternProperties: { [pattern]: T } 
-  }, options) as never
+  return CreateType({ [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: T } }, options) as never
 }
 // ------------------------------------------------------------------
 // RecordCreateFromKeys
 // ------------------------------------------------------------------
 // prettier-ignore
 function RecordCreateFromKeys(K: string[], T: TSchema, options: ObjectOptions): TObject<TProperties> {
-  const Acc = {} as TProperties
-  for(const K2 of K) Acc[K2] = T
-  return Object(Acc, { ...options, [Hint]: 'Record' })
+  const result = {} as TProperties
+  for(const K2 of K) result[K2] = T
+  return Object(result, { ...options, [Hint]: 'Record' })
 }
 // ------------------------------------------------------------------
 // FromTemplateLiteralKey (Fast Inference)
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>
+type TFromTemplateLiteralKeyInfinite<Key extends TTemplateLiteral, Type extends TSchema> = Ensure<TRecord<Key, Type>>
 // prettier-ignore
-type TFromTemplateLiteralKeyFinite<K extends TTemplateLiteral, T extends TSchema, I extends string = Static<K>> = (
-  Ensure<TObject<Evaluate<{ [_ in I]: T }>>>
+type TFromTemplateLiteralKeyFinite<Key extends TTemplateLiteral, Type extends TSchema, I extends string = Static<Key>> = (
+  Ensure<TObject<Evaluate<{ [_ in I]: Type }>>>
 )
 // prettier-ignore
-type TFromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = TIsTemplateLiteralFinite<K> extends false
-  ? TFromTemplateLiteralKeyInfinite<K, T>
-  : TFromTemplateLiteralKeyFinite<K, T>
+type TFromTemplateLiteralKey<Key extends TTemplateLiteral, Type extends TSchema> = TIsTemplateLiteralFinite<Key> extends false
+  ? TFromTemplateLiteralKeyInfinite<Key, Type>
+  : TFromTemplateLiteralKeyFinite<Key, Type>
 // prettier-ignore
-function FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromTemplateLiteralKey<K, T> {
+function FromTemplateLiteralKey<Key extends TTemplateLiteral, Type extends TSchema>(K: Key, T: Type, options: ObjectOptions): TFromTemplateLiteralKey<Key, Type> {
   return (
     IsTemplateLiteralFinite(K)
       ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options)
@@ -101,140 +98,142 @@ function FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema>(K
 // FromEnumKey (Special Case)
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromEnumKey<K extends Record<string, string | number>, T extends TSchema> = Ensure<TObject<{ [_ in K[keyof K]]: T }>>
+type TFromEnumKey<Key extends Record<string, string | number>, Type extends TSchema> = Ensure<TObject<{ [_ in Key[keyof Key]]: Type }>>
 // ------------------------------------------------------------------
 // FromUnionKey
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromUnionKeyLiteralString<K extends TLiteral<string>, T extends TSchema> = { [_ in K['const']]: T }
+type TFromUnionKeyLiteralString<Key extends TLiteral<string>, Type extends TSchema> = { [_ in Key['const']]: Type }
 // prettier-ignore
-type TFromUnionKeyLiteralNumber<K extends TLiteral<number>, T extends TSchema> = { [_ in K['const']]: T }
+type TFromUnionKeyLiteralNumber<Key extends TLiteral<number>, Type extends TSchema> = { [_ in Key['const']]: Type }
 // prettier-ignore
-type TFromUnionKeyRest<K extends TSchema[], T extends TSchema> = 
-  K extends [infer L extends TSchema, ...infer R extends TSchema[]] ? (
-    L extends TUnion<infer S> ? TFromUnionKeyRest<S, T> & TFromUnionKeyRest<R, T> :
-    L extends TLiteral<string> ? TFromUnionKeyLiteralString<L, T> & TFromUnionKeyRest<R, T> :
-    L extends TLiteral<number> ? TFromUnionKeyLiteralNumber<L, T> & TFromUnionKeyRest<R, T> :
+type TFromUnionKeyRest<Keys extends TSchema[], Type extends TSchema> = 
+  Keys extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? (
+    Left extends TUnion<infer Types extends TSchema[]> ? TFromUnionKeyRest<Types, Type> & TFromUnionKeyRest<Right, Type> :
+    Left extends TLiteral<string> ? TFromUnionKeyLiteralString<Left, Type> & TFromUnionKeyRest<Right, Type> :
+    Left extends TLiteral<number> ? TFromUnionKeyLiteralNumber<Left, Type> & TFromUnionKeyRest<Right, Type> :
   {}) : {}
 // prettier-ignore
-type TFromUnionKey<K extends TSchema[], T extends TSchema, P extends TProperties = TFromUnionKeyRest<K, T>> = (
+type TFromUnionKey<Key extends TSchema[], Type extends TSchema, P extends TProperties = TFromUnionKeyRest<Key, Type>> = (
   Ensure<TObject<Evaluate<P>>>
 )
 // prettier-ignore
-function FromUnionKey<K extends TSchema[], T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromUnionKey<K, T> {
-  return RecordCreateFromKeys(IndexPropertyKeys(Union(K)), T, options) as never
+function FromUnionKey<Key extends TSchema[], Type extends TSchema>(key: Key, type: Type, options: ObjectOptions): TFromUnionKey<Key, Type> {
+  return RecordCreateFromKeys(IndexPropertyKeys(Union(key)), type, options) as never
 }
 // ------------------------------------------------------------------
 // FromLiteralKey
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromLiteralKey<K extends TLiteralValue, T extends TSchema> = (
-  Ensure<TObject<{ [_ in Assert<K, PropertyKey>]: T }>>
+type TFromLiteralKey<Key extends TLiteralValue, Type extends TSchema> = (
+  Ensure<TObject<{ [_ in Assert<Key, PropertyKey>]: Type }>>
 )
 // prettier-ignore
-function FromLiteralKey<K extends TLiteralValue, T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromLiteralKey<K, T> {
-  return RecordCreateFromKeys([(K as string).toString()], T, options) as never
+function FromLiteralKey<Key extends TLiteralValue, Type extends TSchema>(key: Key, type: Type, options: ObjectOptions): TFromLiteralKey<Key, Type> {
+  return RecordCreateFromKeys([(key as string).toString()], type, options) as never
 }
 // ------------------------------------------------------------------
 // TFromRegExpKey
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromRegExpKey<_ extends TRegExp, T extends TSchema> = (
-  Ensure<TRecord<TRegExp, T>>
+type TFromRegExpKey<_Key extends TRegExp, Type extends TSchema> = (
+  Ensure<TRecord<TRegExp, Type>>
 )
 // prettier-ignore
-function FromRegExpKey<K extends TRegExp, T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromRegExpKey<K, T> {
-  return RecordCreateFromPattern(K.source, T, options) as never
+function FromRegExpKey<Key extends TRegExp, Type extends TSchema>(key: Key, type: Type, options: ObjectOptions): TFromRegExpKey<Key, Type> {
+  return RecordCreateFromPattern(key.source, type, options) as never
 }
 // ------------------------------------------------------------------
 // FromStringKey
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromStringKey<_ extends TString, T extends TSchema> = (
-  Ensure<TRecord<TString, T>>
+type TFromStringKey<_Key extends TString, Type extends TSchema> = (
+  Ensure<TRecord<TString, Type>>
 )
 // prettier-ignore
-function FromStringKey<K extends TString, T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromStringKey<K, T> {
-  const pattern = IsUndefined(K.pattern) ? PatternStringExact : K.pattern
-  return RecordCreateFromPattern(pattern, T, options) as never
+function FromStringKey<Key extends TString, Type extends TSchema>(key: Key, type: Type, options: ObjectOptions): TFromStringKey<Key, Type> {
+  const pattern = IsUndefined(key.pattern) ? PatternStringExact : key.pattern
+  return RecordCreateFromPattern(pattern, type, options) as never
 }
 // ------------------------------------------------------------------
 // FromAnyKey
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromAnyKey<_ extends TAny, T extends TSchema> = (
-  Ensure<TRecord<TAny, T>>
+type TFromAnyKey<_Key extends TAny, Type extends TSchema> = (
+  Ensure<TRecord<TAny, Type>>
 )
 // prettier-ignore
-function FromAnyKey<K extends TAny, T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromAnyKey<K, T> {
-  return RecordCreateFromPattern(PatternStringExact, T, options) as never
+function FromAnyKey<Key extends TAny, Type extends TSchema>(_: Key, type: Type, options: ObjectOptions): TFromAnyKey<Key, Type> {
+  return RecordCreateFromPattern(PatternStringExact, type, options) as never
 }
 // ------------------------------------------------------------------
 // FromNeverKey
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromNeverKey<_ extends TNever, T extends TSchema> = (
-  Ensure<TRecord<TNever, T>>
+type TFromNeverKey<_Key extends TNever, Type extends TSchema> = (
+  Ensure<TRecord<TNever, Type>>
 )
 // prettier-ignore
-function FromNeverKey<K extends TNever, T extends TSchema>(K: K, T: T, options: ObjectOptions): TFromNeverKey<K, T> {
-  return RecordCreateFromPattern(PatternNeverExact, T, options) as never
+function FromNeverKey<Key extends TNever, Type extends TSchema>(_key: Key, type: Type, options: ObjectOptions): TFromNeverKey<Key, Type> {
+  return RecordCreateFromPattern(PatternNeverExact, type, options) as never
 }
 // ------------------------------------------------------------------
 // FromIntegerKey
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromIntegerKey<_ extends TSchema, T extends TSchema> = (
-  Ensure<TRecord<TNumber, T>>
+type TFromIntegerKey<_Key extends TSchema, Type extends TSchema> = (
+  Ensure<TRecord<TNumber, Type>>
 )
 // prettier-ignore
-function FromIntegerKey<K extends TInteger, T extends TSchema>(_: K, T: T, options: ObjectOptions): TFromIntegerKey<K, T> {
-  return RecordCreateFromPattern(PatternNumberExact, T, options) as never
+function FromIntegerKey<Key extends TInteger, Type extends TSchema>(_key: Key, type: Type, options: ObjectOptions): TFromIntegerKey<Key, Type> {
+  return RecordCreateFromPattern(PatternNumberExact, type, options) as never
 }
 // ------------------------------------------------------------------
 // FromNumberKey
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromNumberKey<_ extends TSchema, T extends TSchema> = (
-  Ensure<TRecord<TNumber, T>>
+type TFromNumberKey<_Key extends TSchema, Type extends TSchema> = (
+  Ensure<TRecord<TNumber, Type>>
 )
 // prettier-ignore
-function FromNumberKey<K extends TNumber, T extends TSchema>(_: K, T: T, options: ObjectOptions): TFromNumberKey<K, T> {
-  return RecordCreateFromPattern(PatternNumberExact, T, options) as never
+function FromNumberKey<Key extends TNumber, Type extends TSchema>(_: Key, type: Type, options: ObjectOptions): TFromNumberKey<Key, Type> {
+  return RecordCreateFromPattern(PatternNumberExact, type, options) as never
 }
 // ------------------------------------------------------------------
 // TRecord
 // ------------------------------------------------------------------
 // prettier-ignore
-type RecordStatic<K extends TSchema, T extends TSchema, P extends unknown[]> = (
-  Evaluate<{ [_ in Assert<Static<K>, PropertyKey>]: Static<T, P>; }>
+type RecordStatic<Key extends TSchema, Type extends TSchema, P extends unknown[]> = (
+  Evaluate<{ [_ in Assert<Static<Key>, PropertyKey>]: Static<Type, P>; }>
 )
 // prettier-ignore
-export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
+export interface TRecord<Key extends TSchema = TSchema, Type extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Record'
-  static: RecordStatic<K, T, this['params']>
+  static: RecordStatic<Key, Type, this['params']>
   type: 'object'
-  patternProperties: { [pattern: string]: T }
+  patternProperties: { [pattern: string]: Type }
   additionalProperties: TAdditionalProperties
 }
 // ------------------------------------------------------------------
 // TRecordOrObject
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TRecordOrObject<Key extends TSchema, Type extends TSchema> =
-  Type extends TRef ? TComputed<'Record', [Key, Type]> :
-  Key extends TRef ? TComputed<'Record', [Key, Type]> :
+export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = (
+  Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [Key, TComputed<Target, Parameters>]> :
+  Key extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [TComputed<Target, Parameters>, Type]> :
+  Key extends TRef<infer Ref extends string> ? TComputed<'Record', [TRef<Ref>, Type]> :
   Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> :  
-  Key extends TEnum<infer S> ? TFromEnumKey<S, Type> : // (Special: Ensure resolve Enum before Union)
-  Key extends TUnion<infer S> ? TFromUnionKey<S, Type> :
-  Key extends TLiteral<infer S> ? TFromLiteralKey<S, Type> :
+  Key extends TEnum<infer Enum extends TEnumRecord> ? TFromEnumKey<Enum, Type> : // (Special: Ensure resolve Enum before Union)
+  Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Type> :
+  Key extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteralKey<Value, Type> :
   Key extends TInteger ? TFromIntegerKey<Key, Type> :
   Key extends TNumber ? TFromNumberKey<Key, Type> :
   Key extends TRegExp ? TFromRegExpKey<Key, Type> :
   Key extends TString ? TFromStringKey<Key, Type> :
   Key extends TAny ? TFromAnyKey<Key, Type> :
   Key extends TNever ? TFromNeverKey<Key, Type> :
-  TNever
+  Key
+)
 // ------------------------------------------------------------------
 // TRecordOrObject
 // ------------------------------------------------------------------
@@ -242,8 +241,9 @@ export type TRecordOrObject<Key extends TSchema, Type extends TSchema> =
 export function Record<Key extends TSchema, Type extends TSchema>(key: Key, type: Type, options: ObjectOptions = {}): TRecordOrObject<Key, Type> {
   // prettier-ignore
   return (
-    IsRef(type) ? Computed('Record', [key, type]) :
-    IsRef(key) ? Computed('Record', [key, type]) :
+    IsComputed(type) ? Computed('Record', [key, Computed(type.target, type.parameters)], options) :
+    IsComputed(key) ? Computed('Record', [Computed(type.target, type.parameters), type], options) :
+    IsRef(key) ? Computed('Record', [Ref(key.$ref), type]) :
     IsUnion(key) ? FromUnionKey(key.anyOf, type, options) :
     IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) :
     IsLiteral(key) ? FromLiteralKey(key.const, type, options) :
diff --git a/test/runtime/type/guard/kind/computed.ts b/test/runtime/type/guard/kind/computed.ts
new file mode 100644
index 000000000..64a69047f
--- /dev/null
+++ b/test/runtime/type/guard/kind/computed.ts
@@ -0,0 +1,28 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TComputed', () => {
+  // ----------------------------------------------------------------
+  // Record
+  // ----------------------------------------------------------------
+  it('Should guard for Record 1', () => {
+    const T = Type.Record(Type.String(), Type.String())
+    Assert.IsTrue(KindGuard.IsRecord(T))
+  })
+  // TRecord<TRecordKey, TRef<...>> is not computed.
+  it('Should guard for Record 3', () => {
+    const T = Type.Record(Type.String(), Type.Ref('A'))
+    Assert.IsTrue(KindGuard.IsRecord(T))
+  })
+  // TRecord<TRecordKey, TComputed<..., [TRef<...>]> is computed due to interior computed.
+  it('Should guard for Record 3', () => {
+    const T = Type.Record(Type.String(), Type.Partial(Type.Ref('A')))
+    Assert.IsTrue(KindGuard.IsComputed(T))
+  })
+  // TRecord<TRef<...>, TSchema> is computed as schematics may be transformed to TObject if finite
+  it('Should guard for Record 4', () => {
+    const T = Type.Record(Type.Ref('A'), Type.String())
+    Assert.IsTrue(KindGuard.IsComputed(T))
+  })
+})
diff --git a/test/runtime/type/guard/kind/import.ts b/test/runtime/type/guard/kind/import.ts
index 5feb06523..7474e26fd 100644
--- a/test/runtime/type/guard/kind/import.ts
+++ b/test/runtime/type/guard/kind/import.ts
@@ -13,6 +13,41 @@ describe('guard/kind/TImport', () => {
     Assert.IsTrue(KindGuard.IsString(N))
   })
   // ----------------------------------------------------------------
+  // Computed: Options
+  // ----------------------------------------------------------------
+  it('Should guard for TImport with Options 1', () => {
+    const Module = Type.Module({
+      A: Type.String(),
+    })
+    const A = Module.Import('A', { format: 'string' })
+    const N = A.$defs[A.$ref]
+    Assert.IsTrue(KindGuard.IsImport(A))
+    Assert.IsTrue(KindGuard.IsString(N))
+    Assert.IsTrue(N.format === 'string')
+  })
+  it('Should guard for TImport with Options 2', () => {
+    const Module = Type.Module({
+      R: Type.Object({ x: Type.Number() }),
+      A: Type.Ref('R'),
+    })
+    const A = Module.Import('A', { test: 'test' })
+    const N = A.$defs[A.$ref]
+    Assert.IsTrue(KindGuard.IsImport(A))
+    Assert.IsTrue(KindGuard.IsRef(N))
+    Assert.IsTrue(N.test === 'test')
+  })
+  it('Should guard for TImport with Options 3', () => {
+    const Module = Type.Module({
+      R: Type.Object({ x: Type.Number() }),
+      A: Type.Partial(Type.Ref('R')),
+    })
+    const A = Module.Import('A', { additionalProperties: false })
+    const N = A.$defs[A.$ref]
+    Assert.IsTrue(KindGuard.IsImport(A))
+    Assert.IsTrue(KindGuard.IsObject(N))
+    Assert.IsTrue(N.additionalProperties === false)
+  })
+  // ----------------------------------------------------------------
   // Computed: Awaited
   // ----------------------------------------------------------------
   it('Should compute for Awaited', () => {
@@ -110,8 +145,11 @@ describe('guard/kind/TImport', () => {
     })
     const T = Module.Import('R')
     Assert.IsTrue(KindGuard.IsRecord(T.$defs['R']))
-    Assert.IsTrue(KindGuard.IsNumber(T.$defs['R'].patternProperties['^(.*)$'].properties.x))
-    Assert.IsTrue(KindGuard.IsString(T.$defs['R'].patternProperties['^(.*)$'].properties.y))
+    // note: TRecord<TSchema, TRef<...>> are not computed. Only the Key is
+    // computed as TypeBox needs to make a deferred call to transform from
+    // TRecord to TObject for finite keys.
+    Assert.IsTrue(KindGuard.IsRef(T.$defs['R'].patternProperties['^(.*)$']))
+    Assert.IsTrue(T.$defs['R'].patternProperties['^(.*)$'].$ref === 'T')
   })
   it('Should compute for Record 2', () => {
     const Module = Type.Module({
diff --git a/test/runtime/type/guard/kind/index.ts b/test/runtime/type/guard/kind/index.ts
index ec0073daa..d3d241ded 100644
--- a/test/runtime/type/guard/kind/index.ts
+++ b/test/runtime/type/guard/kind/index.ts
@@ -6,6 +6,7 @@ import './bigint'
 import './boolean'
 import './capitalize'
 import './composite'
+import './computed'
 import './const'
 import './constructor'
 import './date'
diff --git a/test/runtime/type/guard/type/computed.ts b/test/runtime/type/guard/type/computed.ts
new file mode 100644
index 000000000..fc3724264
--- /dev/null
+++ b/test/runtime/type/guard/type/computed.ts
@@ -0,0 +1,28 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/type/TComputed', () => {
+  // ----------------------------------------------------------------
+  // Record
+  // ----------------------------------------------------------------
+  it('Should guard for Record 1', () => {
+    const T = Type.Record(Type.String(), Type.String())
+    Assert.IsTrue(KindGuard.IsRecord(T))
+  })
+  // TRecord<TRecordKey, TRef<...>> is not computed.
+  it('Should guard for Record 3', () => {
+    const T = Type.Record(Type.String(), Type.Ref('A'))
+    Assert.IsTrue(KindGuard.IsRecord(T))
+  })
+  // TRecord<TRecordKey, TComputed<..., [TRef<...>]> is computed due to interior computed.
+  it('Should guard for Record 3', () => {
+    const T = Type.Record(Type.String(), Type.Partial(Type.Ref('A')))
+    Assert.IsTrue(KindGuard.IsComputed(T))
+  })
+  // TRecord<TRef<...>, TSchema> is computed as schematics may be transformed to TObject if finite
+  it('Should guard for Record 4', () => {
+    const T = Type.Record(Type.Ref('A'), Type.String())
+    Assert.IsTrue(KindGuard.IsComputed(T))
+  })
+})
diff --git a/test/runtime/type/guard/type/import.ts b/test/runtime/type/guard/type/import.ts
index f38124320..05b56739c 100644
--- a/test/runtime/type/guard/type/import.ts
+++ b/test/runtime/type/guard/type/import.ts
@@ -13,6 +13,41 @@ describe('guard/type/TImport', () => {
     Assert.IsTrue(TypeGuard.IsString(N))
   })
   // ----------------------------------------------------------------
+  // Computed: Options
+  // ----------------------------------------------------------------
+  it('Should guard for TImport with Options 1', () => {
+    const Module = Type.Module({
+      A: Type.String(),
+    })
+    const A = Module.Import('A', { format: 'string' })
+    const N = A.$defs[A.$ref]
+    Assert.IsTrue(TypeGuard.IsImport(A))
+    Assert.IsTrue(TypeGuard.IsString(N))
+    Assert.IsTrue(N.format === 'string')
+  })
+  it('Should guard for TImport with Options 2', () => {
+    const Module = Type.Module({
+      R: Type.Object({ x: Type.Number() }),
+      A: Type.Ref('R'),
+    })
+    const A = Module.Import('A', { test: 'test' })
+    const N = A.$defs[A.$ref]
+    Assert.IsTrue(TypeGuard.IsImport(A))
+    Assert.IsTrue(TypeGuard.IsRef(N))
+    Assert.IsTrue(N.test === 'test')
+  })
+  it('Should guard for TImport with Options 3', () => {
+    const Module = Type.Module({
+      R: Type.Object({ x: Type.Number() }),
+      A: Type.Partial(Type.Ref('R')),
+    })
+    const A = Module.Import('A', { additionalProperties: false })
+    const N = A.$defs[A.$ref]
+    Assert.IsTrue(TypeGuard.IsImport(A))
+    Assert.IsTrue(TypeGuard.IsObject(N))
+    Assert.IsTrue(N.additionalProperties === false)
+  })
+  // ----------------------------------------------------------------
   // Computed: Awaited
   // ----------------------------------------------------------------
   it('Should compute for Awaited', () => {
@@ -109,9 +144,14 @@ describe('guard/type/TImport', () => {
       R: Type.Record(Type.String(), Type.Ref('T')),
     })
     const T = Module.Import('R')
+
+    console.dir(T, { depth: 100 })
     Assert.IsTrue(TypeGuard.IsRecord(T.$defs['R']))
-    Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R'].patternProperties['^(.*)$'].properties.x))
-    Assert.IsTrue(TypeGuard.IsString(T.$defs['R'].patternProperties['^(.*)$'].properties.y))
+    // note: TRecord<TSchema, TRef<...>> are not computed. Only the Key is
+    // computed as TypeBox needs to make a deferred call to transform from
+    // TRecord to TObject for finite keys.
+    Assert.IsTrue(TypeGuard.IsRef(T.$defs['R'].patternProperties['^(.*)$']))
+    Assert.IsTrue(T.$defs['R'].patternProperties['^(.*)$'].$ref === 'T')
   })
   it('Should compute for Record 2', () => {
     const Module = Type.Module({
diff --git a/test/runtime/type/guard/type/index.ts b/test/runtime/type/guard/type/index.ts
index ec0073daa..d3d241ded 100644
--- a/test/runtime/type/guard/type/index.ts
+++ b/test/runtime/type/guard/type/index.ts
@@ -6,6 +6,7 @@ import './bigint'
 import './boolean'
 import './capitalize'
 import './composite'
+import './computed'
 import './const'
 import './constructor'
 import './date'
diff --git a/test/static/import.ts b/test/static/import.ts
index bab132f11..0998817b0 100644
--- a/test/static/import.ts
+++ b/test/static/import.ts
@@ -1,5 +1,5 @@
 import { Expect } from './assert'
-import { Type } from '@sinclair/typebox'
+import { Type, Static } from '@sinclair/typebox'
 
 // ------------------------------------------------------------------
 // Enum 1
@@ -38,3 +38,66 @@ import { Type } from '@sinclair/typebox'
     value: 1 | 2
   }>()
 }
+// ------------------------------------------------------------------
+// Record 1
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const T = Type.Module({
+    R: Type.Object({ x: Type.Number(), y: Type.Number() }),
+    T: Type.Record(Type.String(), Type.Ref('R')),
+  }).Import('T')
+
+  type T = Static<typeof T>
+  Expect(T).ToStatic<{ 
+    [key: string]: { x: number, y: number } 
+  }>()
+}
+// ------------------------------------------------------------------
+// Record 2
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const T = Type.Module({
+    R: Type.Object({ x: Type.Number(), y: Type.Number() }),
+    T: Type.Record(Type.String(), Type.Partial(Type.Ref('R'))),
+  }).Import('T')
+
+  type T = Static<typeof T>
+  Expect(T).ToStatic<{ 
+    [key: string]: { x?: number, y?: number } 
+  }>()
+}
+// ------------------------------------------------------------------
+// Record 3
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const T = Type.Module({
+    R: Type.Object({ x: Type.Number(), y: Type.Number() }),
+    K: Type.Number(),
+    T: Type.Record(Type.Ref('K'), Type.Partial(Type.Ref('R'))),
+  }).Import('T')
+
+  type T = Static<typeof T>
+  Expect(T).ToStatic<{ 
+    [key: number]: { x?: number, y?: number } 
+  }>()
+}
+// ------------------------------------------------------------------
+// Record 4
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const T = Type.Module({
+    R: Type.Object({ x: Type.Number(), y: Type.Number() }),
+    K: Type.TemplateLiteral('${A|B|C}'),
+    T: Type.Record(Type.Ref('K'), Type.Partial(Type.Ref('R'))),
+  }).Import('T')
+  type T = Static<typeof T>
+  Expect(T).ToStatic<{ 
+    A: { x?: number, y?: number },
+    B: { x?: number, y?: number },
+    C: { x?: number, y?: number } 
+  }>()
+}

From 2c5dbab611afa5be38af1144e4b1134548a5daa7 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Thu, 21 Nov 2024 02:29:16 +0900
Subject: [PATCH 311/369] Revision 0.34.6 (#1090)

* Add Computed To Type and Kind Guards

* Version

* ChangeLog
---
 changelog/0.34.0.md                      |  2 ++
 package-lock.json                        |  4 ++--
 package.json                             |  2 +-
 src/type/guard/kind.ts                   |  1 +
 src/type/guard/type.ts                   |  9 ++++++++-
 src/type/module/compute.ts               |  4 ++--
 test/runtime/type/guard/kind/computed.ts |  8 ++++++++
 test/runtime/type/guard/type/computed.ts | 18 +++++++++++++-----
 8 files changed, 37 insertions(+), 11 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index a43929440..77f5d0146 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,4 +1,6 @@
 ### 0.34.0
+- [Revision 0.34.6](https://github.com/sinclairzx81/typebox/pull/1090)
+  - Add Computed To Type and Kind Guards (IsSchema)
 - [Revision 0.34.5](https://github.com/sinclairzx81/typebox/pull/1088)
   - Record Types no longer TCompute for TRef Value Type (Modules)
 - [Revision 0.34.4](https://github.com/sinclairzx81/typebox/pull/1085)
diff --git a/package-lock.json b/package-lock.json
index 61ab83569..4b4175ebb 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.5",
+  "version": "0.34.6",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.5",
+      "version": "0.34.6",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index f061e7736..7ccb40d08 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.5",
+  "version": "0.34.6",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/guard/kind.ts b/src/type/guard/kind.ts
index 95e14fc2f..ed3f68f2f 100644
--- a/src/type/guard/kind.ts
+++ b/src/type/guard/kind.ts
@@ -265,6 +265,7 @@ export function IsSchema(value: unknown): value is TSchema {
     IsBoolean(value) ||
     IsBigInt(value) ||
     IsAsyncIterator(value) ||
+    IsComputed(value) ||
     IsConstructor(value) ||
     IsDate(value) ||
     IsFunction(value) ||
diff --git a/src/type/guard/type.ts b/src/type/guard/type.ts
index b4564bed2..ebd4b8f8f 100644
--- a/src/type/guard/type.ts
+++ b/src/type/guard/type.ts
@@ -221,7 +221,13 @@ export function IsBoolean(value: unknown): value is TBoolean {
 }
 /** Returns true if the given value is TComputed */
 export function IsComputed(value: unknown): value is TComputed {
-  return IsKindOf(value, 'Computed') && IsString(value.target) && ValueGuard.IsArray(value.parameters) && value.parameters.every((schema) => IsSchema(schema))
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Computed') && 
+    ValueGuard.IsString(value.target) && 
+    ValueGuard.IsArray(value.parameters) && 
+    value.parameters.every((schema) => IsSchema(schema))
+  )
 }
 /** Returns true if the given value is TConstructor */
 export function IsConstructor(value: unknown): value is TConstructor {
@@ -606,6 +612,7 @@ export function IsSchema(value: unknown): value is TSchema {
       IsBoolean(value) ||
       IsBigInt(value) ||
       IsAsyncIterator(value) ||
+      IsComputed(value) ||
       IsConstructor(value) ||
       IsDate(value) ||
       IsFunction(value) ||
diff --git a/src/type/module/compute.ts b/src/type/module/compute.ts
index 1e9bca28d..94a134829 100644
--- a/src/type/module/compute.ts
+++ b/src/type/module/compute.ts
@@ -36,7 +36,7 @@ import { TComputed } from '../computed/index'
 import { Constructor, type TConstructor } from '../constructor/index'
 import { Index, type TIndex } from '../indexed/index'
 import { TEnum, TEnumRecord } from '../enum/index'
-import { Function, type TFunction } from '../function/index'
+import { Function as FunctionType, type TFunction } from '../function/index'
 import { Intersect, type TIntersect, type TIntersectEvaluated } from '../intersect/index'
 import { Iterator, type TIterator } from '../iterator/index'
 import { KeyOf, type TKeyOf } from '../keyof/index'
@@ -261,7 +261,7 @@ function FromFunction<ModuleProperties extends TProperties, Parameters extends T
   parameters: [...Parameters],
   returnType: ReturnType,
 ): TFromFunction<ModuleProperties, Parameters, ReturnType> {
-  return Function(FromRest(moduleProperties, parameters as never), FromType(moduleProperties, returnType) as never) as never
+  return FunctionType(FromRest(moduleProperties, parameters as never), FromType(moduleProperties, returnType) as never) as never
 }
 // ------------------------------------------------------------------
 // Tuple
diff --git a/test/runtime/type/guard/kind/computed.ts b/test/runtime/type/guard/kind/computed.ts
index 64a69047f..38262833e 100644
--- a/test/runtime/type/guard/kind/computed.ts
+++ b/test/runtime/type/guard/kind/computed.ts
@@ -3,6 +3,14 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../../assert/index'
 
 describe('guard/kind/TComputed', () => {
+  // ----------------------------------------------------------------
+  // Schema
+  // ----------------------------------------------------------------
+  it('Should guard for Schema', () => {
+    const T = Type.Partial(Type.Ref('A'))
+    Assert.IsTrue(KindGuard.IsComputed(T))
+    Assert.IsTrue(KindGuard.IsSchema(T))
+  })
   // ----------------------------------------------------------------
   // Record
   // ----------------------------------------------------------------
diff --git a/test/runtime/type/guard/type/computed.ts b/test/runtime/type/guard/type/computed.ts
index fc3724264..34de3be67 100644
--- a/test/runtime/type/guard/type/computed.ts
+++ b/test/runtime/type/guard/type/computed.ts
@@ -1,28 +1,36 @@
-import { KindGuard } from '@sinclair/typebox'
+import { TypeGuard } from '@sinclair/typebox'
 import { Type } from '@sinclair/typebox'
 import { Assert } from '../../../assert/index'
 
 describe('guard/type/TComputed', () => {
+  // ----------------------------------------------------------------
+  // Schema
+  // ----------------------------------------------------------------
+  it('Should guard for Schema', () => {
+    const T = Type.Partial(Type.Ref('A'))
+    Assert.IsTrue(TypeGuard.IsComputed(T))
+    Assert.IsTrue(TypeGuard.IsSchema(T))
+  })
   // ----------------------------------------------------------------
   // Record
   // ----------------------------------------------------------------
   it('Should guard for Record 1', () => {
     const T = Type.Record(Type.String(), Type.String())
-    Assert.IsTrue(KindGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsRecord(T))
   })
   // TRecord<TRecordKey, TRef<...>> is not computed.
   it('Should guard for Record 3', () => {
     const T = Type.Record(Type.String(), Type.Ref('A'))
-    Assert.IsTrue(KindGuard.IsRecord(T))
+    Assert.IsTrue(TypeGuard.IsRecord(T))
   })
   // TRecord<TRecordKey, TComputed<..., [TRef<...>]> is computed due to interior computed.
   it('Should guard for Record 3', () => {
     const T = Type.Record(Type.String(), Type.Partial(Type.Ref('A')))
-    Assert.IsTrue(KindGuard.IsComputed(T))
+    Assert.IsTrue(TypeGuard.IsComputed(T))
   })
   // TRecord<TRef<...>, TSchema> is computed as schematics may be transformed to TObject if finite
   it('Should guard for Record 4', () => {
     const T = Type.Record(Type.Ref('A'), Type.String())
-    Assert.IsTrue(KindGuard.IsComputed(T))
+    Assert.IsTrue(TypeGuard.IsComputed(T))
   })
 })

From b13b3c33fbf5ae70dd35fd0e775951ddb03dbfcf Mon Sep 17 00:00:00 2001
From: Nathan Smith <nathanrandal@gmail.com>
Date: Wed, 20 Nov 2024 23:50:00 -0500
Subject: [PATCH 312/369] Documentation (#1091)

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 8b1eeb35a..740e7c3e9 100644
--- a/readme.md
+++ b/readme.md
@@ -337,7 +337,7 @@ The following table lists the supported Json types. These types are fully compat
 │   }),                          │   y: number                 │     required: ['x'],           │
 │   Type.Object({                │ }                           │     properties: {              │
 │     y: Type.Number()           │                             │       x: {                     │
-│   ])                           │                             │         type: 'number'         │
+│   })                           │                             │         type: 'number'         │
 │ ])                             │                             │       }                        │
 │                                │                             │     }                          │
 │                                │                             │   }, {                         │

From b05c59c13bc95679a5ec1c202e7007e2aa127f1a Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Thu, 21 Nov 2024 13:53:20 +0900
Subject: [PATCH 313/369] Revision 0.34.7 (#1093)

* Revert Ref(Schema) Signature with Deprecation Notice

* ChangeLog

* Version
---
 changelog/0.34.0.md                 |  2 ++
 package-lock.json                   |  4 ++--
 package.json                        |  2 +-
 readme.md                           | 10 +---------
 src/type/ref/ref.ts                 | 28 +++++++++++++++++++++++++++-
 src/type/type/json.ts               | 27 +++++++++++++++++++++++----
 test/runtime/compiler-ajv/ref.ts    | 12 ++++++++++++
 test/runtime/compiler/ref.ts        | 12 ++++++++++++
 test/runtime/type/guard/kind/ref.ts | 21 +++++++++++++++++++++
 test/runtime/type/guard/type/ref.ts | 21 +++++++++++++++++++++
 test/runtime/value/check/ref.ts     | 12 ++++++++++++
 11 files changed, 134 insertions(+), 17 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 77f5d0146..6a2ea89e7 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,4 +1,6 @@
 ### 0.34.0
+- [Revision 0.34.7](https://github.com/sinclairzx81/typebox/pull/1093)
+  - Revert Ref(Schema) Signature with Deprecation Notice
 - [Revision 0.34.6](https://github.com/sinclairzx81/typebox/pull/1090)
   - Add Computed To Type and Kind Guards (IsSchema)
 - [Revision 0.34.5](https://github.com/sinclairzx81/typebox/pull/1088)
diff --git a/package-lock.json b/package-lock.json
index 4b4175ebb..a3eedbdaf 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.6",
+  "version": "0.34.7",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.6",
+      "version": "0.34.7",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 7ccb40d08..e630cd735 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.6",
+  "version": "0.34.7",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 740e7c3e9..c6438cb85 100644
--- a/readme.md
+++ b/readme.md
@@ -534,15 +534,7 @@ The following table lists the supported Json types. These types are fully compat
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Object({        │ type T = {                  │ const R = {                    │
-│    x: Type.Number(),           │   x: number,                │   $ref: 'T'                    │
-│    y: Type.Number()            │   y: number                 │ }                              │
-│ }, { $id: 'T' })               | }                           │                                │
-│                                │                             │                                │
-│ const R = Type.Ref(T)          │ type R = T                  │                                │
-│                                │                             │                                │
-│                                │                             │                                │
-│                                │                             │                                │
+│ const R = Type.Ref('T')        │ type R = unknown            │ const R = { $ref: 'T' }        │
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
diff --git a/src/type/ref/ref.ts b/src/type/ref/ref.ts
index f61f04fac..f50f6a7ed 100644
--- a/src/type/ref/ref.ts
+++ b/src/type/ref/ref.ts
@@ -27,8 +27,11 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import type { TSchema, SchemaOptions } from '../schema/index'
+import { TypeBoxError } from '../error/index'
 import { CreateType } from '../create/type'
 import { Kind } from '../symbols/index'
+import { TUnsafe } from '../unsafe/index'
+import { Static } from '../static/index'
 
 // ------------------------------------------------------------------
 // TRef
@@ -38,7 +41,30 @@ export interface TRef<Ref extends string = string> extends TSchema {
   static: unknown
   $ref: Ref
 }
+
+export type TRefUnsafe<Type extends TSchema> = TUnsafe<Static<Type>>
+
+/** `[Json]` Creates a Ref type.*/
+export function Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref>
+/**
+ * @deprecated `[Json]` Creates a Ref type. The referenced type MUST contain a $id. The Ref(TSchema) signature was
+ * deprecated on 0.34.0 in support of a new type referencing model (Module). Existing implementations using Ref(TSchema)
+ * can migrate using the following. The Ref(TSchema) validation behavior of Ref will be preserved how the construction
+ * of legacy Ref(TSchema) will require wrapping in TUnsafe (where TUnsafe is used for inference only)
+ *
+ * ```typescript
+ * const R = Type.Ref(T)
+ * ```
+ * to
+ *
+ * ```typescript
+ * const R = Type.Unsafe<Static<T>>(T.$id)
+ * ```
+ */
+export function Ref<Type extends TSchema>(type: Type, options?: SchemaOptions): TRefUnsafe<Type>
 /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
-export function Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref> {
+export function Ref(...args: any[]): unknown {
+  const [$ref, options] = typeof args[0] === 'string' ? [args[0], args[1]] : [args[0].$id, args[1]]
+  if (typeof $ref !== 'string') throw new TypeBoxError('Ref: $ref must be a string')
   return CreateType({ [Kind]: 'Ref', $ref }, options) as never
 }
diff --git a/src/type/type/json.ts b/src/type/type/json.ts
index acc91ce1f..f7efb99c4 100644
--- a/src/type/type/json.ts
+++ b/src/type/type/json.ts
@@ -57,7 +57,7 @@ import { Readonly, type TReadonlyWithFlag, type TReadonlyFromMappedResult } from
 import { ReadonlyOptional, type TReadonlyOptional } from '../readonly-optional/index'
 import { Record, type TRecordOrObject } from '../record/index'
 import { Recursive, type TRecursive, type TThis } from '../recursive/index'
-import { Ref, type TRef } from '../ref/index'
+import { Ref, type TRef, type TRefUnsafe } from '../ref/index'
 import { Required, type TRequired, type TRequiredFromMappedResult } from '../required/index'
 import { Rest, type TRest } from '../rest/index'
 import { type TSchema, type SchemaOptions } from '../schema/index'
@@ -259,9 +259,28 @@ export class JsonTypeBuilder {
   public Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T> {
     return Recursive(callback, options)
   }
-  /** `[Json]` Creates a Ref type. */
-  public Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref> {
-    return Ref($ref, options)
+
+  /** `[Json]` Creates a Ref type.*/
+  public Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref>
+  /**
+   * @deprecated `[Json]` Creates a Ref type. The referenced type MUST contain a $id. The Ref(TSchema) signature was
+   * deprecated on 0.34.0 in support of a new type referencing model (Module). Existing implementations using Ref(TSchema)
+   * can migrate using the following. The Ref(TSchema) validation behavior of Ref will be preserved how the construction
+   * of legacy Ref(TSchema) will require wrapping in TUnsafe (where TUnsafe is used for inference only)
+   *
+   * ```typescript
+   * const R = Type.Ref(T)
+   * ```
+   * to
+   *
+   * ```typescript
+   * const R = Type.Unsafe<Static<T>>(T.$id)
+   * ```
+   */
+  public Ref<Type extends TSchema>(type: Type, options?: SchemaOptions): TRefUnsafe<Type>
+  /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
+  public Ref(...args: any[]): unknown {
+    return Ref(args[0] as string, args[1])
   }
   /** `[Json]` Constructs a type where all properties are required */
   public Required<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>
diff --git a/test/runtime/compiler-ajv/ref.ts b/test/runtime/compiler-ajv/ref.ts
index 564dbc197..ac0815b13 100644
--- a/test/runtime/compiler-ajv/ref.ts
+++ b/test/runtime/compiler-ajv/ref.ts
@@ -2,6 +2,18 @@ import { Type } from '@sinclair/typebox'
 import { Ok, Fail } from './validate'
 
 describe('compiler-ajv/Ref', () => {
+  // ----------------------------------------------------------------
+  // Deprecated
+  // ----------------------------------------------------------------
+  it('Should validate for Ref(Schema)', () => {
+    const T = Type.Number({ $id: 'T' })
+    const R = Type.Ref(T)
+    Ok(R, 1234, [T])
+    Fail(R, 'hello', [T])
+  })
+  // ----------------------------------------------------------------
+  // Standard
+  // ----------------------------------------------------------------
   it('Should should validate when referencing a type', () => {
     const T = Type.Object(
       {
diff --git a/test/runtime/compiler/ref.ts b/test/runtime/compiler/ref.ts
index 1cd002f80..75470f8e5 100644
--- a/test/runtime/compiler/ref.ts
+++ b/test/runtime/compiler/ref.ts
@@ -3,6 +3,18 @@ import { Ok, Fail } from './validate'
 import { Assert } from '../assert/index'
 
 describe('compiler/Ref', () => {
+  // ----------------------------------------------------------------
+  // Deprecated
+  // ----------------------------------------------------------------
+  it('Should validate for Ref(Schema)', () => {
+    const T = Type.Number({ $id: 'T' })
+    const R = Type.Ref(T)
+    Ok(R, 1234, [T])
+    Fail(R, 'hello', [T])
+  })
+  // ----------------------------------------------------------------
+  // Standard
+  // ----------------------------------------------------------------
   it('Should should validate when referencing a type', () => {
     const T = Type.Object(
       {
diff --git a/test/runtime/type/guard/kind/ref.ts b/test/runtime/type/guard/kind/ref.ts
index 441d412cd..60d674634 100644
--- a/test/runtime/type/guard/kind/ref.ts
+++ b/test/runtime/type/guard/kind/ref.ts
@@ -3,6 +3,27 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../../assert/index'
 
 describe('guard/kind/TRef', () => {
+  // ----------------------------------------------------------------
+  // Deprecated
+  // ----------------------------------------------------------------
+  it('Should guard for Ref(Schema) 1', () => {
+    const T = Type.Number({ $id: 'T' })
+    const R = Type.Ref(T)
+    Assert.IsTrue(KindGuard.IsRef(R))
+    Assert.IsTrue(typeof R['$ref'] === 'string')
+  })
+  it('Should guard for Ref(Schema) 2', () => {
+    const T = Type.Number()
+    Assert.Throws(() => Type.Ref(T))
+  })
+  it('Should guard for Ref(Schema) 3', () => {
+    // @ts-ignore
+    const T = Type.Number({ $id: null })
+    Assert.Throws(() => Type.Ref(T))
+  })
+  // ----------------------------------------------------------------
+  // Standard
+  // ----------------------------------------------------------------
   it('Should guard for TRef', () => {
     const T = Type.Number({ $id: 'T' })
     const R = KindGuard.IsRef(Type.Ref(T))
diff --git a/test/runtime/type/guard/type/ref.ts b/test/runtime/type/guard/type/ref.ts
index c11b1a39c..0228f01af 100644
--- a/test/runtime/type/guard/type/ref.ts
+++ b/test/runtime/type/guard/type/ref.ts
@@ -3,6 +3,27 @@ import { Type, CloneType } from '@sinclair/typebox'
 import { Assert } from '../../../assert/index'
 
 describe('guard/type/TRef', () => {
+  // ----------------------------------------------------------------
+  // Deprecated
+  // ----------------------------------------------------------------
+  it('Should guard for Ref(Schema) 1', () => {
+    const T = Type.Number({ $id: 'T' })
+    const R = Type.Ref(T)
+    Assert.IsTrue(TypeGuard.IsRef(R))
+    Assert.IsTrue(typeof R['$ref'] === 'string')
+  })
+  it('Should guard for Ref(Schema) 2', () => {
+    const T = Type.Number()
+    Assert.Throws(() => Type.Ref(T))
+  })
+  it('Should guard for Ref(Schema) 3', () => {
+    // @ts-ignore
+    const T = Type.Number({ $id: null })
+    Assert.Throws(() => Type.Ref(T))
+  })
+  // ----------------------------------------------------------------
+  // Standard
+  // ----------------------------------------------------------------
   it('Should guard for TRef', () => {
     const T = Type.Number({ $id: 'T' })
     const R = TypeGuard.IsRef(Type.Ref('T'))
diff --git a/test/runtime/value/check/ref.ts b/test/runtime/value/check/ref.ts
index 20156eb8d..aa7d76f03 100644
--- a/test/runtime/value/check/ref.ts
+++ b/test/runtime/value/check/ref.ts
@@ -3,6 +3,18 @@ import { Type } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 describe('value/check/Ref', () => {
+  // ----------------------------------------------------------------
+  // Deprecated
+  // ----------------------------------------------------------------
+  it('Should validate for Ref(Schema)', () => {
+    const T = Type.Number({ $id: 'T' })
+    const R = Type.Ref(T)
+    Assert.IsTrue(Value.Check(T, [T], 1234))
+    Assert.IsFalse(Value.Check(T, [T], 'hello'))
+  })
+  // ----------------------------------------------------------------
+  // Standard
+  // ----------------------------------------------------------------
   it('Should should validate when referencing a type', () => {
     const T = Type.Object(
       {

From 81f0a28ad7aad4ba45693d47dc212fa81b9089b2 Mon Sep 17 00:00:00 2001
From: Michael Kaeser <87946992+michaelcollabai@users.noreply.github.com>
Date: Sat, 23 Nov 2024 08:50:25 +0100
Subject: [PATCH 314/369] Fix for Computed Readonly and Optional Properties
 (#1096)

* Fix importing optional properties

* Readonly and Optional Unwrap for Computed Type

* Comment for Modifier Reapply on Unwrap

---------

Co-authored-by: sinclair <haydn.developer@gmail.com>
---
 src/type/module/compute.ts             | 12 ++++
 test/runtime/compiler-ajv/module.ts    | 31 +++++++++
 test/runtime/compiler/module.ts        | 31 +++++++++
 test/runtime/type/guard/kind/import.ts | 87 +++++++++++++++++++++++++
 test/runtime/type/guard/type/import.ts | 89 +++++++++++++++++++++++++-
 test/runtime/value/check/module.ts     | 31 +++++++++
 test/static/import.ts                  | 62 ++++++++++++++++++
 7 files changed, 341 insertions(+), 2 deletions(-)

diff --git a/src/type/module/compute.ts b/src/type/module/compute.ts
index 94a134829..b2ee6e785 100644
--- a/src/type/module/compute.ts
+++ b/src/type/module/compute.ts
@@ -27,6 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { CreateType } from '../create/index'
+import { Discard } from '../discard/index'
 import { Ensure, Evaluate } from '../helpers/index'
 import { type TSchema } from '../schema/index'
 import { Array, type TArray } from '../array/index'
@@ -42,15 +43,18 @@ import { Iterator, type TIterator } from '../iterator/index'
 import { KeyOf, type TKeyOf } from '../keyof/index'
 import { Object, type TObject, type TProperties } from '../object/index'
 import { Omit, type TOmit } from '../omit/index'
+import { type TOptional } from '../optional/index'
 import { Pick, type TPick } from '../pick/index'
 import { Never, type TNever } from '../never/index'
 import { Partial, TPartial } from '../partial/index'
+import { type TReadonly } from '../readonly/index'
 import { Record, type TRecordOrObject } from '../record/index'
 import { type TRef } from '../ref/index'
 import { Required, TRequired } from '../required/index'
 import { Tuple, type TTuple } from '../tuple/index'
 import { Union, type TUnion, type TUnionEvaluated } from '../union/index'
 
+import { OptionalKind, ReadonlyKind } from '../symbols/index'
 // ------------------------------------------------------------------
 // KindGuard
 // ------------------------------------------------------------------
@@ -340,6 +344,10 @@ function FromRest<ModuleProperties extends TProperties, Types extends TSchema[]>
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (
+  // Modifier Unwrap
+  Type extends TOptional<infer Type extends TSchema> ? TOptional<TFromType<ModuleProperties, Type>> :
+  Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TFromType<ModuleProperties, Type>> :
+  // Traveral
   Type extends TArray<infer Type extends TSchema> ? TFromArray<ModuleProperties, Type> :
   Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<ModuleProperties, Type> :
   Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<ModuleProperties, Target, Parameters> :
@@ -356,6 +364,10 @@ export type TFromType<ModuleProperties extends TProperties, Type extends TSchema
 // prettier-ignore
 export function FromType<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromType<ModuleProperties, Type> {
   return (
+    // Modifier Unwrap - Reapplied via CreateType Options
+    KindGuard.IsOptional(type) ? CreateType(FromType(moduleProperties, Discard(type, [OptionalKind]) as TSchema) as never, type) :
+    KindGuard.IsReadonly(type) ? CreateType(FromType(moduleProperties, Discard(type, [ReadonlyKind]) as TSchema) as never, type) :
+    // Traveral
     KindGuard.IsArray(type) ? CreateType(FromArray(moduleProperties, type.items), type) :
     KindGuard.IsAsyncIterator(type) ? CreateType(FromAsyncIterator(moduleProperties, type.items), type) :
     // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
diff --git a/test/runtime/compiler-ajv/module.ts b/test/runtime/compiler-ajv/module.ts
index 9de6813b7..756c09f36 100644
--- a/test/runtime/compiler-ajv/module.ts
+++ b/test/runtime/compiler-ajv/module.ts
@@ -75,4 +75,35 @@ describe('compiler-ajv/Module', () => {
     Ok(T, 'hello')
     Fail(T, 'world')
   })
+  // ----------------------------------------------------------------
+  // Modifiers
+  // ----------------------------------------------------------------
+  it('Should validate objects with property modifiers 1', () => {
+    const Module = Type.Module({
+      T: Type.Object({
+        x: Type.ReadonlyOptional(Type.Null()),
+        y: Type.Readonly(Type.Null()),
+        z: Type.Optional(Type.Null()),
+        w: Type.Null(),
+      }),
+    })
+    const T = Module.Import('T')
+    Ok(T, { x: null, y: null, w: null })
+    Ok(T, { y: null, w: null })
+    Fail(T, { x: 1, y: null, w: null })
+  })
+  it('Should validate objects with property modifiers 2', () => {
+    const Module = Type.Module({
+      T: Type.Object({
+        x: Type.ReadonlyOptional(Type.Array(Type.Null())),
+        y: Type.Readonly(Type.Array(Type.Null())),
+        z: Type.Optional(Type.Array(Type.Null())),
+        w: Type.Array(Type.Null()),
+      }),
+    })
+    const T = Module.Import('T')
+    Ok(T, { x: [null], y: [null], w: [null] })
+    Ok(T, { y: [null], w: [null] })
+    Fail(T, { x: [1], y: [null], w: [null] })
+  })
 })
diff --git a/test/runtime/compiler/module.ts b/test/runtime/compiler/module.ts
index 02fcb4d45..32b455605 100644
--- a/test/runtime/compiler/module.ts
+++ b/test/runtime/compiler/module.ts
@@ -75,4 +75,35 @@ describe('compiler/Module', () => {
     Ok(T, 'hello')
     Fail(T, 'world')
   })
+  // ----------------------------------------------------------------
+  // Modifiers
+  // ----------------------------------------------------------------
+  it('Should validate objects with property modifiers 1', () => {
+    const Module = Type.Module({
+      T: Type.Object({
+        x: Type.ReadonlyOptional(Type.Null()),
+        y: Type.Readonly(Type.Null()),
+        z: Type.Optional(Type.Null()),
+        w: Type.Null(),
+      }),
+    })
+    const T = Module.Import('T')
+    Ok(T, { x: null, y: null, w: null })
+    Ok(T, { y: null, w: null })
+    Fail(T, { x: 1, y: null, w: null })
+  })
+  it('Should validate objects with property modifiers 2', () => {
+    const Module = Type.Module({
+      T: Type.Object({
+        x: Type.ReadonlyOptional(Type.Array(Type.Null())),
+        y: Type.Readonly(Type.Array(Type.Null())),
+        z: Type.Optional(Type.Array(Type.Null())),
+        w: Type.Array(Type.Null()),
+      }),
+    })
+    const T = Module.Import('T')
+    Ok(T, { x: [null], y: [null], w: [null] })
+    Ok(T, { y: [null], w: [null] })
+    Fail(T, { x: [1], y: [null], w: [null] })
+  })
 })
diff --git a/test/runtime/type/guard/kind/import.ts b/test/runtime/type/guard/kind/import.ts
index 7474e26fd..55bd572e7 100644
--- a/test/runtime/type/guard/kind/import.ts
+++ b/test/runtime/type/guard/kind/import.ts
@@ -190,4 +190,91 @@ describe('guard/kind/TImport', () => {
     Assert.IsTrue(T.$defs['R'].anyOf[0].const === 'x')
     Assert.IsTrue(T.$defs['R'].anyOf[1].const === 'y')
   })
+  // ----------------------------------------------------------------
+  // Modifiers: 1
+  // ----------------------------------------------------------------
+  it('Should compute for Modifiers 1', () => {
+    const Module = Type.Module({
+      T: Type.Object({
+        x: Type.ReadonlyOptional(Type.Null()),
+        y: Type.Readonly(Type.Null()),
+        z: Type.Optional(Type.Null()),
+        w: Type.Null(),
+      }),
+    })
+    const T = Module.Import('T')
+    const R = T.$defs[T.$ref]
+    Assert.IsTrue(KindGuard.IsObject(R))
+
+    Assert.IsTrue(KindGuard.IsNull(R.properties.x))
+    Assert.IsTrue(KindGuard.IsReadonly(R.properties.x))
+    Assert.IsTrue(KindGuard.IsOptional(R.properties.x))
+
+    Assert.IsTrue(KindGuard.IsNull(R.properties.y))
+    Assert.IsTrue(KindGuard.IsReadonly(R.properties.y))
+    Assert.IsFalse(KindGuard.IsOptional(R.properties.y))
+
+    Assert.IsTrue(KindGuard.IsNull(R.properties.z))
+    Assert.IsTrue(KindGuard.IsOptional(R.properties.z))
+    Assert.IsFalse(KindGuard.IsReadonly(R.properties.z))
+
+    Assert.IsTrue(KindGuard.IsNull(R.properties.w))
+    Assert.IsFalse(KindGuard.IsOptional(R.properties.w))
+    Assert.IsFalse(KindGuard.IsReadonly(R.properties.w))
+  })
+  // ----------------------------------------------------------------
+  // Modifiers: 2
+  // ----------------------------------------------------------------
+  it('Should compute for Modifiers 2', () => {
+    const Module = Type.Module({
+      T: Type.Object({
+        x: Type.ReadonlyOptional(Type.Array(Type.Null())),
+        y: Type.Readonly(Type.Array(Type.Null())),
+        z: Type.Optional(Type.Array(Type.Null())),
+        w: Type.Array(Type.Null()),
+      }),
+    })
+    const T = Module.Import('T')
+    const R = T.$defs[T.$ref]
+    Assert.IsTrue(KindGuard.IsObject(R))
+
+    Assert.IsTrue(KindGuard.IsArray(R.properties.x))
+    Assert.IsTrue(KindGuard.IsNull(R.properties.x.items))
+    Assert.IsTrue(KindGuard.IsReadonly(R.properties.x))
+    Assert.IsTrue(KindGuard.IsOptional(R.properties.x))
+
+    Assert.IsTrue(KindGuard.IsArray(R.properties.y))
+    Assert.IsTrue(KindGuard.IsNull(R.properties.y.items))
+    Assert.IsTrue(KindGuard.IsReadonly(R.properties.y))
+    Assert.IsFalse(KindGuard.IsOptional(R.properties.y))
+
+    Assert.IsTrue(KindGuard.IsArray(R.properties.z))
+    Assert.IsTrue(KindGuard.IsNull(R.properties.z.items))
+    Assert.IsTrue(KindGuard.IsOptional(R.properties.z))
+    Assert.IsFalse(KindGuard.IsReadonly(R.properties.z))
+
+    Assert.IsTrue(KindGuard.IsArray(R.properties.w))
+    Assert.IsTrue(KindGuard.IsNull(R.properties.w.items))
+    Assert.IsFalse(KindGuard.IsOptional(R.properties.w))
+    Assert.IsFalse(KindGuard.IsReadonly(R.properties.w))
+  })
+  // ----------------------------------------------------------------
+  // Modifiers: 3
+  // ----------------------------------------------------------------
+  it('Should compute for Modifiers 3', () => {
+    const Module = Type.Module({
+      T: Type.Object({
+        x: Type.Array(Type.Null()),
+      }),
+      // Computed Partial
+      U: Type.Partial(Type.Ref('T')),
+    })
+    const T = Module.Import('U')
+    const R = T.$defs[T.$ref]
+    Assert.IsTrue(KindGuard.IsObject(R))
+
+    Assert.IsTrue(KindGuard.IsArray(R.properties.x))
+    Assert.IsTrue(KindGuard.IsNull(R.properties.x.items))
+    Assert.IsTrue(KindGuard.IsOptional(R.properties.x))
+  })
 })
diff --git a/test/runtime/type/guard/type/import.ts b/test/runtime/type/guard/type/import.ts
index 05b56739c..5388e2f29 100644
--- a/test/runtime/type/guard/type/import.ts
+++ b/test/runtime/type/guard/type/import.ts
@@ -144,8 +144,6 @@ describe('guard/type/TImport', () => {
       R: Type.Record(Type.String(), Type.Ref('T')),
     })
     const T = Module.Import('R')
-
-    console.dir(T, { depth: 100 })
     Assert.IsTrue(TypeGuard.IsRecord(T.$defs['R']))
     // note: TRecord<TSchema, TRef<...>> are not computed. Only the Key is
     // computed as TypeBox needs to make a deferred call to transform from
@@ -192,4 +190,91 @@ describe('guard/type/TImport', () => {
     Assert.IsTrue(T.$defs['R'].anyOf[0].const === 'x')
     Assert.IsTrue(T.$defs['R'].anyOf[1].const === 'y')
   })
+  // ----------------------------------------------------------------
+  // Modifiers: 1
+  // ----------------------------------------------------------------
+  it('Should compute for Modifiers 1', () => {
+    const Module = Type.Module({
+      T: Type.Object({
+        x: Type.ReadonlyOptional(Type.Null()),
+        y: Type.Readonly(Type.Null()),
+        z: Type.Optional(Type.Null()),
+        w: Type.Null(),
+      }),
+    })
+    const T = Module.Import('T')
+    const R = T.$defs[T.$ref]
+    Assert.IsTrue(TypeGuard.IsObject(R))
+
+    Assert.IsTrue(TypeGuard.IsNull(R.properties.x))
+    Assert.IsTrue(TypeGuard.IsReadonly(R.properties.x))
+    Assert.IsTrue(TypeGuard.IsOptional(R.properties.x))
+
+    Assert.IsTrue(TypeGuard.IsNull(R.properties.y))
+    Assert.IsTrue(TypeGuard.IsReadonly(R.properties.y))
+    Assert.IsFalse(TypeGuard.IsOptional(R.properties.y))
+
+    Assert.IsTrue(TypeGuard.IsNull(R.properties.z))
+    Assert.IsTrue(TypeGuard.IsOptional(R.properties.z))
+    Assert.IsFalse(TypeGuard.IsReadonly(R.properties.z))
+
+    Assert.IsTrue(TypeGuard.IsNull(R.properties.w))
+    Assert.IsFalse(TypeGuard.IsOptional(R.properties.w))
+    Assert.IsFalse(TypeGuard.IsReadonly(R.properties.w))
+  })
+  // ----------------------------------------------------------------
+  // Modifiers: 2
+  // ----------------------------------------------------------------
+  it('Should compute for Modifiers 2', () => {
+    const Module = Type.Module({
+      T: Type.Object({
+        x: Type.ReadonlyOptional(Type.Array(Type.Null())),
+        y: Type.Readonly(Type.Array(Type.Null())),
+        z: Type.Optional(Type.Array(Type.Null())),
+        w: Type.Array(Type.Null()),
+      }),
+    })
+    const T = Module.Import('T')
+    const R = T.$defs[T.$ref]
+    Assert.IsTrue(TypeGuard.IsObject(R))
+
+    Assert.IsTrue(TypeGuard.IsArray(R.properties.x))
+    Assert.IsTrue(TypeGuard.IsNull(R.properties.x.items))
+    Assert.IsTrue(TypeGuard.IsReadonly(R.properties.x))
+    Assert.IsTrue(TypeGuard.IsOptional(R.properties.x))
+
+    Assert.IsTrue(TypeGuard.IsArray(R.properties.y))
+    Assert.IsTrue(TypeGuard.IsNull(R.properties.y.items))
+    Assert.IsTrue(TypeGuard.IsReadonly(R.properties.y))
+    Assert.IsFalse(TypeGuard.IsOptional(R.properties.y))
+
+    Assert.IsTrue(TypeGuard.IsArray(R.properties.z))
+    Assert.IsTrue(TypeGuard.IsNull(R.properties.z.items))
+    Assert.IsTrue(TypeGuard.IsOptional(R.properties.z))
+    Assert.IsFalse(TypeGuard.IsReadonly(R.properties.z))
+
+    Assert.IsTrue(TypeGuard.IsArray(R.properties.w))
+    Assert.IsTrue(TypeGuard.IsNull(R.properties.w.items))
+    Assert.IsFalse(TypeGuard.IsOptional(R.properties.w))
+    Assert.IsFalse(TypeGuard.IsReadonly(R.properties.w))
+  })
+  // ----------------------------------------------------------------
+  // Modifiers: 3
+  // ----------------------------------------------------------------
+  it('Should compute for Modifiers 3', () => {
+    const Module = Type.Module({
+      T: Type.Object({
+        x: Type.Array(Type.Null()),
+      }),
+      // Computed Partial
+      U: Type.Partial(Type.Ref('T')),
+    })
+    const T = Module.Import('U')
+    const R = T.$defs[T.$ref]
+    Assert.IsTrue(TypeGuard.IsObject(R))
+
+    Assert.IsTrue(TypeGuard.IsArray(R.properties.x))
+    Assert.IsTrue(TypeGuard.IsNull(R.properties.x.items))
+    Assert.IsTrue(TypeGuard.IsOptional(R.properties.x))
+  })
 })
diff --git a/test/runtime/value/check/module.ts b/test/runtime/value/check/module.ts
index 3a64267de..371b302d0 100644
--- a/test/runtime/value/check/module.ts
+++ b/test/runtime/value/check/module.ts
@@ -77,4 +77,35 @@ describe('value/check/Module', () => {
     Assert.IsTrue(Value.Check(T, 'hello'))
     Assert.IsFalse(Value.Check(T, 'world'))
   })
+  // ----------------------------------------------------------------
+  // Modifiers
+  // ----------------------------------------------------------------
+  it('Should validate objects with property modifiers 1', () => {
+    const Module = Type.Module({
+      T: Type.Object({
+        x: Type.ReadonlyOptional(Type.Null()),
+        y: Type.Readonly(Type.Null()),
+        z: Type.Optional(Type.Null()),
+        w: Type.Null(),
+      }),
+    })
+    const T = Module.Import('T')
+    Assert.IsTrue(Value.Check(T, { x: null, y: null, w: null }))
+    Assert.IsTrue(Value.Check(T, { y: null, w: null }))
+    Assert.IsFalse(Value.Check(T, { x: 1, y: null, w: null }))
+  })
+  it('Should validate objects with property modifiers 2', () => {
+    const Module = Type.Module({
+      T: Type.Object({
+        x: Type.ReadonlyOptional(Type.Array(Type.Null())),
+        y: Type.Readonly(Type.Array(Type.Null())),
+        z: Type.Optional(Type.Array(Type.Null())),
+        w: Type.Array(Type.Null()),
+      }),
+    })
+    const T = Module.Import('T')
+    Assert.IsTrue(Value.Check(T, { x: [null], y: [null], w: [null] }))
+    Assert.IsTrue(Value.Check(T, { y: [null], w: [null] }))
+    Assert.IsFalse(Value.Check(T, { x: [1], y: [null], w: [null] }))
+  })
 })
diff --git a/test/static/import.ts b/test/static/import.ts
index 0998817b0..ab546c453 100644
--- a/test/static/import.ts
+++ b/test/static/import.ts
@@ -101,3 +101,65 @@ import { Type, Static } from '@sinclair/typebox'
     C: { x?: number, y?: number } 
   }>()
 }
+// ------------------------------------------------------------------
+// Modifiers 1
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const Module = Type.Module({
+    T: Type.Object({
+      x: Type.ReadonlyOptional(Type.Null()), 
+      y: Type.Readonly(Type.Null()),
+      z: Type.Optional(Type.Null()),
+      w: Type.Null()
+    })
+  })
+  const T = Module.Import('T')
+  type T = Static<typeof T>
+  Expect(T).ToStatic<{ 
+    readonly x?: null,
+    readonly y: null,
+    z?: null,
+    w: null
+  }>()
+}
+// ------------------------------------------------------------------
+// Modifiers 2
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const Module = Type.Module({
+    T: Type.Object({
+      x: Type.ReadonlyOptional(Type.Array(Type.Null())), 
+      y: Type.Readonly(Type.Array(Type.Null())),
+      z: Type.Optional(Type.Array(Type.Null())),
+      w: Type.Array(Type.Null())
+    })
+  })
+  const T = Module.Import('T')
+  type T = Static<typeof T>
+  Expect(T).ToStatic<{ 
+    readonly x?: null[],
+    readonly y: null[],
+    z?:null[],
+    w: null[]
+  }>()
+}
+// ------------------------------------------------------------------
+// Modifiers 3
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const Module = Type.Module({
+    T: Type.Object({
+      x: Type.Array(Type.Null())
+    }),
+    // Computed Partial
+    U: Type.Partial(Type.Ref('T'))
+  })
+  const T = Module.Import('U')
+  type T = Static<typeof T>
+  Expect(T).ToStatic<{ 
+    x?: null[],
+  }>()
+}

From 10968abfed00577c7a71855ee09f46789502bcc9 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Sat, 23 Nov 2024 17:05:03 +0900
Subject: [PATCH 315/369] Revision 0.34.8 (#1098)

* Version

* ChangeLog
---
 changelog/0.34.0.md | 2 ++
 package-lock.json   | 4 ++--
 package.json        | 2 +-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 6a2ea89e7..755d04bf3 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,4 +1,6 @@
 ### 0.34.0
+- [Revision 0.34.8](https://github.com/sinclairzx81/typebox/pull/1098)
+  - Fix for Computed Readonly and Optional Properties
 - [Revision 0.34.7](https://github.com/sinclairzx81/typebox/pull/1093)
   - Revert Ref(Schema) Signature with Deprecation Notice
 - [Revision 0.34.6](https://github.com/sinclairzx81/typebox/pull/1090)
diff --git a/package-lock.json b/package-lock.json
index a3eedbdaf..0257ff706 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.7",
+  "version": "0.34.8",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.7",
+      "version": "0.34.8",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index e630cd735..b12b19f6b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.7",
+  "version": "0.34.8",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

From c4b84552a20bc9adf1f1336691ac0ba6b4afee4a Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Mon, 25 Nov 2024 15:59:55 +0900
Subject: [PATCH 316/369] TypeScript 5.7.2

---
 hammer.mjs        |  2 +-
 package-lock.json | 14 +++++++-------
 package.json      |  2 +-
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/hammer.mjs b/hammer.mjs
index 82755bffb..02dacedfc 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -32,7 +32,7 @@ export async function benchmark() {
 // Test
 // -------------------------------------------------------------------------------
 export async function test_typescript() {
-  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', '5.4.5', '5.5.2', '5.5.3', '5.5.4', '5.6.2', 'next', 'latest']) {
+  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', '5.4.5', '5.5.2', '5.5.3', '5.5.4', '5.6.2', '5.6.3', 'next', 'latest']) {
     await shell(`npm install typescript@${version} --no-save`)
     await test_static()
   }
diff --git a/package-lock.json b/package-lock.json
index 0257ff706..8d9666303 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -17,7 +17,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^10.4.0",
         "prettier": "^2.7.1",
-        "typescript": "^5.6.3"
+        "typescript": "^5.7.2"
       }
     },
     "node_modules/@andrewbranch/untar.js": {
@@ -1576,9 +1576,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.6.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.6.3.tgz",
-      "integrity": "sha512-hjcS1mhfuyi4WW8IWtjP7brDrG2cuDZukyrYrSauoXGNgx0S7zceP07adYkJycEr56BOUTNPzbInooiN3fn1qw==",
+      "version": "5.7.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.2.tgz",
+      "integrity": "sha512-i5t66RHxDvVN40HfDd1PsEThGNnlMCMT3jMUuoh9/0TaqWevNontacunWyN02LA9/fIbEWlcHZcgTKb9QoaLfg==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -2738,9 +2738,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.6.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.6.3.tgz",
-      "integrity": "sha512-hjcS1mhfuyi4WW8IWtjP7brDrG2cuDZukyrYrSauoXGNgx0S7zceP07adYkJycEr56BOUTNPzbInooiN3fn1qw==",
+      "version": "5.7.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.2.tgz",
+      "integrity": "sha512-i5t66RHxDvVN40HfDd1PsEThGNnlMCMT3jMUuoh9/0TaqWevNontacunWyN02LA9/fIbEWlcHZcgTKb9QoaLfg==",
       "dev": true
     },
     "undici-types": {
diff --git a/package.json b/package.json
index b12b19f6b..b841d7895 100644
--- a/package.json
+++ b/package.json
@@ -37,6 +37,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^10.4.0",
     "prettier": "^2.7.1",
-    "typescript": "^5.6.3"
+    "typescript": "^5.7.2"
   }
 }

From 428f906f304ef17bedbc41e062e0b576a241c8c2 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 26 Nov 2024 14:26:05 +0900
Subject: [PATCH 317/369] Documentation

---
 readme.md | 90 +++++++++++++++++--------------------------------------
 1 file changed, 27 insertions(+), 63 deletions(-)

diff --git a/readme.md b/readme.md
index c6438cb85..4004ece9f 100644
--- a/readme.md
+++ b/readme.md
@@ -78,9 +78,6 @@ License MIT
   - [Unsafe](#types-unsafe)
 - [Syntax](#syntax)
   - [Parse](#syntax-parse)
-  - [Compose](#syntax-compose)
-  - [Context](#syntax-context)
-  - [Module](#syntax-module)
   - [Static](#syntax-static)
   - [Limits](#syntax-limits)
 - [Values](#values)
@@ -1025,9 +1022,9 @@ if(TypeGuard.IsString(T)) {
 
 ## Syntax Types
 
-TypeBox provides support for parsing TypeScript syntax directly into TypeBox Json Schema schematics. Syntax Types offer a string based DSL frontend to TypeBox's Type Builder system and can be useful for converting existing TypeScript type definitions into Json Schema schematics without reimplementation via the Type Builder.
+Syntax Types is a feature that enables TypeBox to parse TypeScript type annotations directly into Json Schema. This feature works both at runtime and statically within the type system. Syntax Types use Json Schema as the Abstract Syntax Tree (AST) parse target for TypeScript types. Syntax Types are designed to offer a syntactical frontend to the standard Type Builder API.
 
-Syntax Types are provided via optional import.
+This feature is available via optional import.
 
 ```typescript
 import { Parse } from '@sinclair/typebox/syntax'
@@ -1037,7 +1034,7 @@ import { Parse } from '@sinclair/typebox/syntax'
 
 ### Parse
 
-Use the Parse function to convert a TypeScript string into a TypeBox type. TypeBox will infer the appropriate TSchema type or return undefined if there is a syntax error.
+Use the Parse function to transform a TypeScript type annotation into a TypeBox type. This function will return the parsed TypeBox type or undefined on error.
 
 ```typescript
 const A = Parse('string')                           // const A: TString
@@ -1054,45 +1051,46 @@ const C = Parse(`{ x: number, y: number }`)         // const C: TObject<{
                                                     // }>
 ```
 
-
-
-<a name='syntax-compose'></a>
-
-### Compose
-
-Syntax Types are designed to be interchangeable with standard Types.
+Syntax Types can be composed with Standard Types. 
 
 ```typescript
 const T = Type.Object({                             // const T: TObject<{
   x: Parse('number'),                               //   x: TNumber,
-  y: Parse('number'),                               //   y: TNumber,
-  z: Parse('number')                                //   z: TNumber
+  y: Parse('string'),                               //   y: TString,
+  z: Parse('boolean')                               //   z: TBoolean
 })                                                  // }>
 ```
 
-<a name='syntax-module'></a>
+It is also possible to pass Standard Types to Syntax Types in the following way.
 
-### Module
+```typescript
+const X = Type.Number()
+const Y = Type.String()
+const Z = Type.Boolean()
+
+const T = Parse({ X, Y, Z }, `{ 
+  x: X, 
+  y: Y, 
+  z: Z 
+}`)
+```
 
-Syntax Types also support Module parsing. This can provide a more terse syntax for creating Module definitions, but comes with an inference performance cost. Module parsing supports interface and type alias definitions. Generics types are currently unsupported. 
+Syntax Types can also be used to parse Module types.
 
 ```typescript
-const Module = Parse(`module {
-  
+const Foo = Parse(`module Foo {
+
+  export type PartialUser = Pick<User, 'id'> & Partial<Omit<User, 'id'>>
+
   export interface User {
     id: string
     name: string
     email: string
   }
- 
-  export type PartialUser = (
-    Pick<User, 'id'> &
-    Partial<Omit<User, 'id'>>
-  )
 
 }`)
 
-const PartialUser = Module.Import('PartialUser')    // TImport<{...}, 'PartialUser'>
+const PartialUser = Foo.Import('PartialUser')       // TImport<{...}, 'PartialUser'>
 
 type PartialUser = Static<typeof PartialUser>       // type PartialUser = {
                                                     //   id: string,
@@ -1102,45 +1100,11 @@ type PartialUser = Static<typeof PartialUser>       // type PartialUser = {
                                                     // }
 ```
 
-<a name='syntax-context'></a>
-
-### Context
-
-The Parse function takes an optional leading Context object that contains external types. This Context allows the syntax to reference these external types using the property identifiers provided by the Context. The following passes the external type `T` to Parse.
-
-```typescript
-const T = Type.Object({                             // const T: TObject<{
-  x: Type.Number(),                                 //   x: TNumber,
-  y: Type.Number(),                                 //   y: TNumber,
-  z: Type.Number()                                  //   z: TNumber
-})                                                  // }>
-
-const A = Parse({ T }, 'Partial<T>')                // const A: TObject<{
-                                                    //   x: TOptional<TNumber>,
-                                                    //   y: TOptional<TNumber>,
-                                                    //   z: TOptional<TNumber>
-                                                    // }>
-
-const B = Parse({ T }, 'keyof T')                   // const B: TUnion<[
-                                                    //   TLiteral<'x'>,
-                                                    //   TLiteral<'y'>,
-                                                    //   TLiteral<'z'>
-                                                    // ]>
-
-const C = Parse({ T }, 'T & { w: number }')         // const C: TIntersect<[TObject<{
-                                                    //    x: TNumber;
-                                                    //    y: TNumber;
-                                                    //    z: TNumber;
-                                                    // }>, TObject<{
-                                                    //    w: TNumber;
-                                                    // }>]>
-```
-
 <a name='syntax-static'></a>
 
 ### Static
 
-Syntax Types provide two Static types for inferring TypeScript types and TypeBox schematics from strings.
+Syntax Types provide two Static types specific to inferring TypeBox and TypeScript types from strings.
 
 ```typescript
 import { StaticParseAsSchema, StaticParseAsType } from '@sinclair/typebox/syntax' 
@@ -1154,8 +1118,8 @@ type S = StaticParseAsSchema<{}, '{ x: number }'>   // type S: TObject<{
 // Will infer as a type
 
 type T = StaticParseAsType<{}, '{ x: number }'>     // type T = {
-                                                    //  x: number
-                                                    //                       
+                                                    //   x: number
+                                                    // }                      
 ```
 
 

From cd9712c463a385ac3df8b2980b6adafaab249a66 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Tue, 26 Nov 2024 19:42:36 +0900
Subject: [PATCH 318/369] Revision 0.34.9 (#1101)

* Parse Pipeline and TypeCheck Schema and Reference Accessor Functions

* Documentation

* Version
---
 changelog/0.34.0.md                |   3 +
 package-lock.json                  |   4 +-
 package.json                       |   2 +-
 readme.md                          |  22 +++---
 src/compiler/compiler.ts           |   8 +++
 src/value/parse/parse.ts           | 106 ++++++++++++++++++++++-------
 test/runtime/compiler/__members.ts |  20 ++++++
 test/runtime/compiler/index.ts     |   1 +
 test/runtime/value/parse/parse.ts  |  39 ++++++++++-
 9 files changed, 167 insertions(+), 38 deletions(-)
 create mode 100644 test/runtime/compiler/__members.ts

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 755d04bf3..7e5e46939 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,4 +1,7 @@
 ### 0.34.0
+- [Revision 0.34.9](https://github.com/sinclairzx81/typebox/pull/1101)
+  - User Defined Parse Pipelines
+  - Access to Schema and References on TypeCheck
 - [Revision 0.34.8](https://github.com/sinclairzx81/typebox/pull/1098)
   - Fix for Computed Readonly and Optional Properties
 - [Revision 0.34.7](https://github.com/sinclairzx81/typebox/pull/1093)
diff --git a/package-lock.json b/package-lock.json
index 8d9666303..a962edf2f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.8",
+  "version": "0.34.9",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.8",
+      "version": "0.34.9",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index b841d7895..279b3dd59 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.8",
+  "version": "0.34.9",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 4004ece9f..6dc0ceb83 100644
--- a/readme.md
+++ b/readme.md
@@ -1325,26 +1325,28 @@ const B = Value.Encode(Type.String(), 42)             // throw
 
 ### Parse
 
-Use the Parse function to parse a value or throw if invalid. This function internally uses Default, Clean, Convert and Decode to make a best effort attempt to parse the value into the expected type. This function should not be used in performance critical code paths.
+Use the Parse function to parse a value. This function calls the `Clone` `Clean`, `Default`, `Convert`, `Assert` and `Decode` Value functions in this exact order to process a value.
 
 ```typescript
-const T = Type.Object({ x: Type.Number({ default: 0 }), y: Type.Number({ default: 0 }) })
+const R = Value.Parse(Type.String(), 'hello')      // const R: string = "hello"
 
-// Default
+const E = Value.Parse(Type.String(), undefined)    // throws AssertError 
+```
 
-const A = Value.Parse(T, { })                                 // const A = { x: 0, y: 0 }
+You can override the order in which functions are are run, or omit functions entirely in the following way.
 
-// Convert
+```typescript
+// Runs no functions.
 
-const B = Value.Parse(T, { x: '1', y: '2' })                  // const B = { x: 1, y: 2 }
+const R = Value.Parse([], Type.String(), 12345)
 
-// Clean
+// Runs the Assert() function.
 
-const C = Value.Parse(T, { x: 1, y: 2, z: 3 })                // const C = { x: 1, y: 2 }
+const E = Value.Parse(['Assert'], Type.String(), 12345)
 
-// Assert
+// Runs the Convert() function followed by the Assert() function.
 
-const D = Value.Parse(T, undefined)                           // throws AssertError
+const S = Value.Parse(['Convert', 'Assert'], Type.String(), 12345)
 ```
 
 <a name='values-equal'></a>
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 6e438702b..7450c8aab 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -97,6 +97,14 @@ export class TypeCheck<T extends TSchema> {
   public Code(): string {
     return this.code
   }
+  /** Returns the schema type used to validate */
+  public Schema(): T {
+    return this.schema
+  }
+  /** Returns reference types used to validate */
+  public References(): TSchema[] {
+    return this.references
+  }
   /** Returns an iterator for each error in this value. */
   public Errors(value: unknown): ValueErrorIterator {
     return Errors(this.schema, this.references, value)
diff --git a/src/value/parse/parse.ts b/src/value/parse/parse.ts
index 13477a4c9..be07f5b81 100644
--- a/src/value/parse/parse.ts
+++ b/src/value/parse/parse.ts
@@ -26,43 +26,103 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { TransformDecode, HasTransform } from '../transform/index'
+import { TypeBoxError } from '../../type/error/index'
+import { TransformDecode, TransformEncode, HasTransform } from '../transform/index'
 import { TSchema } from '../../type/schema/index'
 import { StaticDecode } from '../../type/static/index'
-import { Assert } from '../assert/assert'
-import { Default } from '../default/default'
-import { Convert } from '../convert/convert'
-import { Clean } from '../clean/clean'
+import { Assert } from '../assert/index'
+import { Default } from '../default/index'
+import { Convert } from '../convert/index'
+import { Clean } from '../clean/index'
 import { Clone } from '../clone/index'
 
 // ------------------------------------------------------------------
-// ParseReducer
+// Guards
 // ------------------------------------------------------------------
-type ReducerFunction = (schema: TSchema, references: TSchema[], value: unknown) => unknown
+import { IsArray, IsUndefined } from '../guard/index'
+
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export class ParseError extends TypeBoxError {
+  constructor(message: string) {
+    super(message)
+  }
+}
+
+// ------------------------------------------------------------------
+// ParseRegistry
+// ------------------------------------------------------------------
+export type TParseOperation = 'Clone' | 'Clean' | 'Default' | 'Convert' | 'Assert' | 'Decode' | ({} & string)
+export type TParseFunction = (type: TSchema, references: TSchema[], value: unknown) => unknown
 
 // prettier-ignore
-const ParseReducer: ReducerFunction[] = [
-  (_schema, _references, value) => Clone(value),
-  (schema, references, value) => Default(schema, references, value),
-  (schema, references, value) => Clean(schema, references, value),
-  (schema, references, value) => Convert(schema, references, value),
-  (schema, references, value) => { Assert(schema, references, value); return value },
-  (schema, references, value) => (HasTransform(schema, references) ? TransformDecode(schema, references, value) : value),
-]
+export namespace ParseRegistry {
+  const registry = new Map<string, TParseFunction>([
+    ['Clone', (_type, _references, value: unknown) => Clone(value)],
+    ['Clean', (type, references, value: unknown) => Clean(type, references, value)],
+    ['Default', (type, references, value: unknown) => Default(type, references, value)],
+    ['Convert', (type, references, value: unknown) => Convert(type, references, value)],
+    ['Assert', (type, references, value: unknown) => { Assert(type, references, value); return value }],
+    ['Decode', (type, references, value: unknown) => (HasTransform(type, references) ? TransformDecode(type, references, value) : value)],
+    ['Encode', (type, references, value: unknown) => (HasTransform(type, references) ? TransformEncode(type, references, value) : value)],
+  ])
+  // Deletes an entry from the registry
+  export function Delete(key: string): void {
+    registry.delete(key)
+  }
+  // Sets an entry in the registry
+  export function Set(key: string, callback: TParseFunction): void {
+    registry.set(key, callback)
+  }
+  // Gets an entry in the registry
+  export function Get(key: string): TParseFunction | undefined {
+    return registry.get(key)
+  }
+}
+// ------------------------------------------------------------------
+// Default Parse Sequence
+// ------------------------------------------------------------------
+// prettier-ignore
+export const ParseDefault = [
+  'Clone',
+  'Clean',
+  'Default',
+  'Convert',
+  'Assert',
+  'Decode'
+] as const
+
 // ------------------------------------------------------------------
 // ParseValue
 // ------------------------------------------------------------------
-function ParseValue<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R {
-  return ParseReducer.reduce((value, reducer) => reducer(schema, references, value), value) as R
+function ParseValue<Type extends TSchema, Result extends StaticDecode<Type> = StaticDecode<Type>>(operations: TParseOperation[], type: Type, references: TSchema[], value: unknown): Result {
+  return operations.reduce((value, operationKey) => {
+    const operation = ParseRegistry.Get(operationKey)
+    if (IsUndefined(operation)) throw new ParseError(`Unable to find Parse operation '${operationKey}'`)
+    return operation(type, references, value)
+  }, value) as Result
 }
+
 // ------------------------------------------------------------------
 // Parse
 // ------------------------------------------------------------------
-/** Parses a value or throws an `AssertError` if invalid. */
-export function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R
-/** Parses a value or throws an `AssertError` if invalid. */
-export function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R
-/** Parses a value or throws an `AssertError` if invalid. */
+/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
+export function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, references: TSchema[], value: unknown): Result
+/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
+export function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, value: unknown): Result
+/** Parses a value using the specified operations. */
+export function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, references: TSchema[], value: unknown): unknown
+/** Parses a value using the specified operations. */
+export function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, value: unknown): unknown
+/** Parses a value */
 export function Parse(...args: any[]): unknown {
-  return args.length === 3 ? ParseValue(args[0], args[1], args[2]) : ParseValue(args[0], [], args[1])
+  // prettier-ignore
+  const [operations, schema, references, value] = (
+    args.length === 4 ? [args[0], args[1], args[2], args[3]] :
+    args.length === 3 ? IsArray(args[0]) ? [args[0], args[1], [], args[2]] : [ParseDefault, args[0], args[1], args[2]] :
+    args.length === 2 ? [ParseDefault, args[0], [], args[1]] :
+    (() => { throw new ParseError('Invalid Arguments') })()
+  )
+  return ParseValue(operations, schema, references, value)
 }
diff --git a/test/runtime/compiler/__members.ts b/test/runtime/compiler/__members.ts
new file mode 100644
index 000000000..6ade7f40b
--- /dev/null
+++ b/test/runtime/compiler/__members.ts
@@ -0,0 +1,20 @@
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { Type, TypeGuard, ValueGuard } from '@sinclair/typebox'
+import { Assert } from '../assert/index'
+
+describe('compiler/TypeCheckMembers', () => {
+  it('Should return Schema', () => {
+    const A = TypeCompiler.Compile(Type.Number(), [Type.String(), Type.Boolean()])
+    Assert.IsTrue(TypeGuard.IsNumber(A.Schema()))
+  })
+  it('Should return References', () => {
+    const A = TypeCompiler.Compile(Type.Number(), [Type.String(), Type.Boolean()])
+    Assert.IsTrue(TypeGuard.IsNumber(A.Schema()))
+    Assert.IsTrue(TypeGuard.IsString(A.References()[0]))
+    Assert.IsTrue(TypeGuard.IsBoolean(A.References()[1]))
+  })
+  it('Should return Code', () => {
+    const A = TypeCompiler.Compile(Type.Number(), [Type.String(), Type.Boolean()])
+    Assert.IsTrue(ValueGuard.IsString(A.Code()))
+  })
+})
diff --git a/test/runtime/compiler/index.ts b/test/runtime/compiler/index.ts
index 21decd7fa..a39e51760 100644
--- a/test/runtime/compiler/index.ts
+++ b/test/runtime/compiler/index.ts
@@ -1,3 +1,4 @@
+import './__members'
 import './any'
 import './array'
 import './async-iterator'
diff --git a/test/runtime/value/parse/parse.ts b/test/runtime/value/parse/parse.ts
index 5c8be9dd7..2bf7106de 100644
--- a/test/runtime/value/parse/parse.ts
+++ b/test/runtime/value/parse/parse.ts
@@ -1,5 +1,5 @@
-import { Value, AssertError } from '@sinclair/typebox/value'
-import { Type } from '@sinclair/typebox'
+import { Value, AssertError, ParseRegistry } from '@sinclair/typebox/value'
+import { Type, TypeGuard } from '@sinclair/typebox'
 import { Assert } from '../../assert/index'
 
 // prettier-ignore
@@ -87,4 +87,39 @@ describe('value/Parse', () => {
     const X = Value.Parse(T, 'world')
     Assert.IsEqual(X, 'hello')
   })
+  // ----------------------------------------------------------------
+  // Operations
+  // ----------------------------------------------------------------
+  it('Should run operations 1', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const I = { x: 1 }
+    const O = Value.Parse([], A, I)
+    Assert.IsTrue(I === O)
+  })
+  it('Should run operations 2', () => {
+    const A = Type.Object({ x: Type.Number() })
+    const I = { x: 1 }
+    const O = Value.Parse(['Clone'], A, I)
+    Assert.IsTrue(I !== O)
+  })
+  it('Should run operations 3', () => {
+    ParseRegistry.Set('Intercept', ( schema, references, value) => { throw 1 })
+    const A = Type.Object({ x: Type.Number() })
+    Assert.Throws(() => Value.Parse(['Intercept'], A, null))
+    ParseRegistry.Delete('Intercept')
+    const F = ParseRegistry.Get('Intercept')
+    Assert.IsEqual(F, undefined)
+  })
+  it('Should run operations 4', () => {
+    ParseRegistry.Set('Intercept', ( schema, references, value) => { 
+      Assert.IsEqual(value, 12345)
+      Assert.IsTrue(TypeGuard.IsNumber(schema))
+      Assert.IsTrue(TypeGuard.IsString(references[0]))
+    })
+    Value.Parse(['Intercept'], Type.Number(), [Type.String()], 12345)
+    ParseRegistry.Delete('Intercept')
+  })
+  it('Should run operations 5', () => {
+    Assert.Throws(() => Value.Parse(['Intercept'], Type.String(), null))
+  })
 })

From 010d1818ba7c1ae7f3973ead35dfc6946eac6447 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 27 Nov 2024 02:40:09 +0900
Subject: [PATCH 319/369] Documentation

---
 readme.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/readme.md b/readme.md
index 6dc0ceb83..35d2c912e 100644
--- a/readme.md
+++ b/readme.md
@@ -1022,7 +1022,7 @@ if(TypeGuard.IsString(T)) {
 
 ## Syntax Types
 
-Syntax Types is a feature that enables TypeBox to parse TypeScript type annotations directly into Json Schema. This feature works both at runtime and statically within the type system. Syntax Types use Json Schema as the Abstract Syntax Tree (AST) parse target for TypeScript types. Syntax Types are designed to offer a syntactical frontend to the standard Type Builder API.
+TypeBox has support for parsing TypeScript type annotations directly into TypeBox types. This feature supports both runtime and static parsing, with TypeBox implementing TypeScript parsers within the TypeScript type system itself. Syntax Types use the TypeBox Json Schema representations as an AST target for TypeScript types, providing a direct mapping between TypeScript syntax and Json Schema. Syntax Types are offered as a syntactical frontend to the Standard Type Builder API.
 
 This feature is available via optional import.
 
@@ -1051,7 +1051,7 @@ const C = Parse(`{ x: number, y: number }`)         // const C: TObject<{
                                                     // }>
 ```
 
-Syntax Types can be composed with Standard Types. 
+Syntax Types can compose with Standard Types created via the Type Builder API
 
 ```typescript
 const T = Type.Object({                             // const T: TObject<{
@@ -1061,7 +1061,7 @@ const T = Type.Object({                             // const T: TObject<{
 })                                                  // }>
 ```
 
-It is also possible to pass Standard Types to Syntax Types in the following way.
+Standard Types can also be passed to and referenced within Syntax Types.
 
 ```typescript
 const X = Type.Number()
@@ -1075,7 +1075,7 @@ const T = Parse({ X, Y, Z }, `{
 }`)
 ```
 
-Syntax Types can also be used to parse Module types.
+Syntax Types also support Module parsing.
 
 ```typescript
 const Foo = Parse(`module Foo {
@@ -1127,7 +1127,7 @@ type T = StaticParseAsType<{}, '{ x: number }'>     // type T = {
 
 ### Limitations
 
-Syntax Types work by having TypeBox parse TypeScript syntax within the TypeScript type system. This approach can place some strain on the TypeScript compiler and language service, potentially affecting responsiveness. While TypeBox makes a best-effort attempt to optimize for Syntax Types, users should be mindful of the following structures:
+TypeBox parses TypeScript types directly within the TypeScript type system. This process does come with an inference cost, which scales with the size and complexity of the types being parsed. Although TypeBox strives to optimize Syntax Types, users should be aware of the following structures:
 
 ```typescript
 // Excessively wide structures will result in instantiation limits exceeding
@@ -1154,12 +1154,12 @@ const B = Parse(`{
 }`)
 ```
 
-In cases where Syntax Types exceed TypeScript's instantiation limits, TypeBox offers a fallback ParseOnly function, which will only parse but not infer. This function can also be used to parse types where the syntax is statically unknown to TypeScript (for example, when loading types from disk).
+If Syntax Types exceed TypeScript's instantiation limits, users are advised to fall back to the Standard Type Builder API. Alternatively, TypeBox offers a `ParseOnly` function that parses the TypeScript syntax at runtime without statically inferring the schema.
 
 ```typescript
 import { ParseOnly } from '@sinclair/typebox/syntax'
 
-// Where A is TSchema | undefined 
+// const A: TSchema | undefined 
 
 const A = ParseOnly(`{
   x: {
@@ -1172,7 +1172,7 @@ const A = ParseOnly(`{
 }`)
 ```
 
-For more information on TypeBox's parsing infrastructure, refer to the [ParseBox](https://github.com/sinclairzx81/parsebox) project.
+For more information on static parsing, refer to the [ParseBox](https://github.com/sinclairzx81/parsebox) project.
 
 <a name='values'></a>
 
@@ -1333,7 +1333,7 @@ const R = Value.Parse(Type.String(), 'hello')      // const R: string = "hello"
 const E = Value.Parse(Type.String(), undefined)    // throws AssertError 
 ```
 
-You can override the order in which functions are are run, or omit functions entirely in the following way.
+You can override the order in which functions are run, or omit functions entirely using the following.
 
 ```typescript
 // Runs no functions.

From 39765414b4316a1e9630f238173d5e36b865d843 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Wed, 4 Dec 2024 17:18:00 +0900
Subject: [PATCH 320/369] Revision 0.34.10 (#1107)

* Add Remote Build Task

* Use Overloads for Index Signature

* Tidy Record Module Inference

* Add Encode to Parse Operation Type

* Fix Record Key mapping when using Import

* Version

* ChangeLog
---
 changelog/0.34.0.md                           |   5 +
 hammer.mjs                                    |  25 ++
 package-lock.json                             |   4 +-
 package.json                                  |   3 +-
 src/type/indexed/indexed-from-mapped-key.ts   |  11 +-
 .../indexed/indexed-from-mapped-result.ts     |   3 +-
 src/type/indexed/indexed-property-keys.ts     |  26 +--
 src/type/indexed/indexed.ts                   | 218 ++++++++----------
 src/type/module/compute.ts                    |  18 +-
 src/type/module/infer.ts                      |   2 +-
 src/type/record/record.ts                     |   6 +-
 src/type/type/json.ts                         |  16 +-
 src/value/parse/parse.ts                      |   2 +-
 13 files changed, 176 insertions(+), 163 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 7e5e46939..0b821e451 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,4 +1,9 @@
 ### 0.34.0
+- [Revision 0.34.10](https://github.com/sinclairzx81/typebox/pull/1107)
+  - Fix Declaration Emit for Index and Mapped Types
+  - Fix Record Inference Presentation when Embedded in Modules
+  - Fix Record Mapping when using TImport as Key
+  - Add Encode to Parse Operation List
 - [Revision 0.34.9](https://github.com/sinclairzx81/typebox/pull/1101)
   - User Defined Parse Pipelines
   - Access to Schema and References on TypeCheck
diff --git a/hammer.mjs b/hammer.mjs
index 02dacedfc..26f758006 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -9,12 +9,14 @@ export async function clean() {
   await folder('node_modules/typebox').delete()
   await folder('target').delete()
 }
+
 // -------------------------------------------------------------------------------
 // Format
 // -------------------------------------------------------------------------------
 export async function format() {
   await shell('prettier --no-semi --single-quote --print-width 240 --trailing-comma all --write src test task example/index.ts')
 }
+
 // -------------------------------------------------------------------------------
 // Start
 // -------------------------------------------------------------------------------
@@ -28,6 +30,7 @@ export async function benchmark() {
   await Benchmark.compression()
   await Benchmark.measurement()
 }
+
 // -------------------------------------------------------------------------------
 // Test
 // -------------------------------------------------------------------------------
@@ -49,6 +52,7 @@ export async function test(filter = '') {
   await test_static()
   await test_runtime(filter)
 }
+
 // -------------------------------------------------------------------------------
 // Build
 // -------------------------------------------------------------------------------
@@ -69,6 +73,25 @@ export async function build(target = 'target/build') {
   await shell(`cd ${target} && npm pack`)
   await build_check(target)
 }
+
+// -------------------------------------------------------------------------------
+// Build To
+// -------------------------------------------------------------------------------
+export async function build_to(remote = 'target/remote', target = 'target/build') {
+  await clean()
+  await Promise.all([
+    Build.Package.build(target),
+    Build.Esm.build(target),
+    Build.Cjs.build(target),
+  ])
+  await folder(target).add('readme.md')
+  await folder(target).add('license')
+  await shell(`cd ${target} && npm pack`)
+  const { version } = JSON.parse(Fs.readFileSync('package.json', 'utf8'))
+  const filename = `${target}/sinclair-typebox-${version}.tgz`
+  await folder(remote).add(filename)
+}
+
 // -------------------------------------------------------------------------------
 // Install
 // -------------------------------------------------------------------------------
@@ -77,6 +100,7 @@ export async function install_local() {
   await build('target/typebox')
   await folder('node_modules').add('target/typebox')
 }
+
 // -------------------------------------------------------------
 // Publish
 // -------------------------------------------------------------
@@ -87,6 +111,7 @@ export async function publish(otp, target = 'target/build') {
   await shell(`git tag ${version}`)
   await shell(`git push origin ${version}`)
 }
+
 // -------------------------------------------------------------
 // Publish-Dev
 // -------------------------------------------------------------
diff --git a/package-lock.json b/package-lock.json
index a962edf2f..acfa45500 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.9",
+  "version": "0.34.10",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.9",
+      "version": "0.34.10",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 279b3dd59..8b857c362 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.9",
+  "version": "0.34.10",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -20,6 +20,7 @@
     "test:runtime": "hammer task test_runtime",
     "install:local": "hammer task install_local",
     "benchmark": "hammer task benchmark",
+    "build:to": "hammer task build_to",
     "build": "hammer task build",
     "test": "hammer task test",
     "clean": "hammer task clean",
diff --git a/src/type/indexed/indexed-from-mapped-key.ts b/src/type/indexed/indexed-from-mapped-key.ts
index b66cf5113..a523032f8 100644
--- a/src/type/indexed/indexed-from-mapped-key.ts
+++ b/src/type/indexed/indexed-from-mapped-key.ts
@@ -41,8 +41,7 @@ type TMappedIndexPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
   [_ in Key]: TIndex<Type, [Key]>
 }
 // prettier-ignore
-function MappedIndexPropertyKey<Type extends TSchema, Key extends PropertyKey
->(type: Type, key: Key, options?: SchemaOptions): TMappedIndexPropertyKey<Type, Key> {
+function MappedIndexPropertyKey<Type extends TSchema, Key extends PropertyKey>(type: Type, key: Key, options?: SchemaOptions): TMappedIndexPropertyKey<Type, Key> {
   return { [key]: Index(type, [key], Clone(options)) } as never
 }
 // ------------------------------------------------------------------
@@ -55,7 +54,10 @@ type TMappedIndexPropertyKeys<Type extends TSchema, PropertyKeys extends Propert
     : Result
 )
 // prettier-ignore
-function MappedIndexPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TMappedIndexPropertyKeys<Type, PropertyKeys> {
+function MappedIndexPropertyKeys<
+  Type extends TSchema, 
+  PropertyKeys extends PropertyKey[]
+>(type: Type, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TMappedIndexPropertyKeys<Type, PropertyKeys> {
   return propertyKeys.reduce((result, left) => {
     return { ...result, ...MappedIndexPropertyKey(type, left, options) }
   }, {} as TProperties) as never
@@ -68,7 +70,8 @@ type TMappedIndexProperties<Type extends TSchema, MappedKey extends TMappedKey>
   TMappedIndexPropertyKeys<Type, MappedKey['keys']>
 >
 // prettier-ignore
-function MappedIndexProperties<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedIndexProperties<Type, MappedKey> {
+function MappedIndexProperties<Type extends TSchema, MappedKey extends TMappedKey
+>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedIndexProperties<Type, MappedKey> {
   return MappedIndexPropertyKeys(type, mappedKey.keys, options) as never
 }
 // ------------------------------------------------------------------
diff --git a/src/type/indexed/indexed-from-mapped-result.ts b/src/type/indexed/indexed-from-mapped-result.ts
index e2b2b007c..200493649 100644
--- a/src/type/indexed/indexed-from-mapped-result.ts
+++ b/src/type/indexed/indexed-from-mapped-result.ts
@@ -43,8 +43,7 @@ type TFromProperties<Type extends TSchema, Properties extends TProperties> = (
 function FromProperties<Type extends TSchema, Properties extends TProperties>(type: Type, properties: Properties, options?: SchemaOptions): TFromProperties<Type, Properties> {
   const result = {} as Record<PropertyKey, TSchema>
   for(const K2 of Object.getOwnPropertyNames(properties)) {
-    const keys = IndexPropertyKeys(properties[K2])
-    result[K2] = Index(type, keys, options) as never
+    result[K2] = Index(type, IndexPropertyKeys(properties[K2]), options)
   }
   return result as never
 }
diff --git a/src/type/indexed/indexed-property-keys.ts b/src/type/indexed/indexed-property-keys.ts
index ad73541e4..d5f2e7315 100644
--- a/src/type/indexed/indexed-property-keys.ts
+++ b/src/type/indexed/indexed-property-keys.ts
@@ -41,13 +41,11 @@ import { IsTemplateLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../g
 // FromTemplateLiteral
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromTemplateLiteral<TemplateLiteral extends TTemplateLiteral, 
-  Result extends string[] = TTemplateLiteralGenerate<TemplateLiteral>
-> = Result
+type TFromTemplateLiteral<TemplateLiteral extends TTemplateLiteral, Keys extends string[] = TTemplateLiteralGenerate<TemplateLiteral>> = (Keys)
 // prettier-ignore
 function FromTemplateLiteral<TemplateLiteral extends TTemplateLiteral>(templateLiteral: TemplateLiteral): TFromTemplateLiteral<TemplateLiteral> {
-  const result = TemplateLiteralGenerate(templateLiteral) as string[]
-  return result.map(S => S.toString()) as never
+  const keys = TemplateLiteralGenerate(templateLiteral) as string[]
+  return keys.map(key => key.toString()) as never
 }
 // ------------------------------------------------------------------
 // FromUnion
@@ -59,9 +57,9 @@ type TFromUnion<Types extends TSchema[], Result extends string[] = []> = (
     : Result
 )
 // prettier-ignore
-function FromUnion<Type extends TSchema[]>(type: Type): TFromUnion<Type> {
+function FromUnion<Types extends TSchema[]>(types: Types): TFromUnion<Types> {
   const result = [] as string[]
-  for(const left of type) result.push(...IndexPropertyKeys(left))
+  for(const type of types) result.push(...IndexPropertyKeys(type))
   return result as never
 }
 // ------------------------------------------------------------------
@@ -74,23 +72,23 @@ type TFromLiteral<LiteralValue extends TLiteralValue> = (
     : []
 )
 // prettier-ignore
-function FromLiteral<LiteralValue extends TLiteralValue>(T: LiteralValue): TFromLiteral<LiteralValue> {
+function FromLiteral<LiteralValue extends TLiteralValue>(literalValue: LiteralValue): TFromLiteral<LiteralValue> {
   return (
-    [(T as string).toString()] // TS 5.4 observes TLiteralValue as not having a toString()
+    [(literalValue as string).toString()] // TS 5.4 observes TLiteralValue as not having a toString()
   ) as never
 }
 // ------------------------------------------------------------------
-// IndexedKeyResolve
+// IndexPropertyKeys
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TIndexPropertyKeys<Type extends TSchema, Result extends PropertyKey[] = (
-  Type extends TTemplateLiteral ? TFromTemplateLiteral<Type> :
+export type TIndexPropertyKeys<Type extends TSchema> = (
+  Type extends TTemplateLiteral  ? TFromTemplateLiteral<Type> :
   Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> :
-  Type extends TLiteral<infer LiteralValue extends TLiteralValue> ? TFromLiteral<LiteralValue> :
+  Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> :
   Type extends TNumber ? ['[number]'] :  
   Type extends TInteger ? ['[number]'] :
   []
-)> = Result
+)
 /** Returns a tuple of PropertyKeys derived from the given TSchema */
 // prettier-ignore
 export function IndexPropertyKeys<Type extends TSchema>(type: Type): TIndexPropertyKeys<Type> {
diff --git a/src/type/indexed/indexed.ts b/src/type/indexed/indexed.ts
index 5598b034c..541c6e734 100644
--- a/src/type/indexed/indexed.ts
+++ b/src/type/indexed/indexed.ts
@@ -27,70 +27,45 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { CreateType } from '../create/type'
+import { TypeBoxError } from '../error/index'
+
 import { type TSchema, SchemaOptions } from '../schema/index'
-import { Computed, type TComputed } from '../computed/index'
-import { Literal, type TLiteral, type TLiteralValue } from '../literal/index'
+import { type Assert } from '../helpers/index'
+import { type TComputed, Computed } from '../computed/index'
+import { type TNever, Never } from '../never/index'
+import { type TArray } from '../array/index'
+import { type TIntersect } from '../intersect/index'
+import { type TMappedResult, type TMappedKey } from '../mapped/index'
 import { type TObject, type TProperties } from '../object/index'
-import { type Ensure, type Assert } from '../helpers/index'
-import { Never, type TNever } from '../never/index'
+import { type TUnion } from '../union/index'
 import { type TRecursive } from '../recursive/index'
-import { type TIntersect } from '../intersect/index'
-import { TMappedResult, type TMappedKey } from '../mapped/index'
-import { Union, type TUnion } from '../union/index'
+import { type TRef } from '../ref/index'
 import { type TTuple } from '../tuple/index'
-import { type TArray } from '../array/index'
-import { Ref, type TRef } from '../ref/index'
+
 import { IntersectEvaluated, type TIntersectEvaluated } from '../intersect/index'
 import { UnionEvaluated, type TUnionEvaluated } from '../union/index'
 
-// ------------------------------------------------------------------
-// Infrastructure
-// ------------------------------------------------------------------
 import { IndexPropertyKeys, type TIndexPropertyKeys } from './indexed-property-keys'
 import { IndexFromMappedKey, type TIndexFromMappedKey } from './indexed-from-mapped-key'
 import { IndexFromMappedResult, type TIndexFromMappedResult } from './indexed-from-mapped-result'
 
 // ------------------------------------------------------------------
-// KindGuard
+// TypeGuard
 // ------------------------------------------------------------------
-import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion, IsLiteralValue, IsRef, IsComputed } from '../guard/kind'
-import { IsArray as IsArrayValue } from '../guard/value'
-
-// ------------------------------------------------------------------
-// FromComputed
-// ------------------------------------------------------------------
-// prettier-ignore
-// type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<
-//   TComputed<'Partial', [TComputed<Target, Parameters>]>
-// >
-// // prettier-ignore
-// function FromComputed<Target extends string, Parameters extends TSchema[]>(target: Target, parameters: Parameters): TFromComputed<Target, Parameters> {
-//   return Computed('Partial', [Computed(target, parameters)]) as never
-// }
-// // ------------------------------------------------------------------
-// // FromRef
-// // ------------------------------------------------------------------
-// // prettier-ignore
-// type TFromRef<Ref extends string> = Ensure<
-//   TComputed<'Partial', [TRef<Ref>]>
-// >
-// // prettier-ignore
-// function FromRef<Ref extends string>($ref: Ref): TFromRef<Ref> {
-//   return Computed('Partial', [Ref($ref)]) as never
-// }
+import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion, IsRef } from '../guard/kind'
 
 // ------------------------------------------------------------------
 // FromRest
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromRest<T extends TSchema[], K extends PropertyKey, Result extends TSchema[] = []> = (
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TFromRest<R, K, [...Result, Assert<TIndexFromPropertyKey<L, K>, TSchema>]>
+type TFromRest<Types extends TSchema[], Key extends PropertyKey, Result extends TSchema[] = []> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
+    ? TFromRest<Right, Key, [...Result, Assert<TIndexFromPropertyKey<Left, Key>, TSchema>]>
     : Result
 )
 // prettier-ignore
-function FromRest<Types extends TSchema[], K extends PropertyKey>(types: [...Types], key: K): TFromRest<Types, K> {
-  return types.map(left => IndexFromPropertyKey(left, key)) as never
+function FromRest<Types extends TSchema[], Key extends PropertyKey>(types: [...Types], key: Key): TFromRest<Types, Key> {
+  return types.map(type => IndexFromPropertyKey(type, key)) as never
 }
 // ------------------------------------------------------------------
 // FromIntersectRest
@@ -105,7 +80,7 @@ type TFromIntersectRest<Types extends TSchema[], Result extends TSchema[] = []>
 )
 // prettier-ignore
 function FromIntersectRest<Types extends TSchema[]>(types: [...Types]): TFromIntersectRest<Types> {
-  return types.filter(left => !IsNever(left)) as never
+  return types.filter(type => !IsNever(type)) as never
 }
 // prettier-ignore
 type TFromIntersect<Types extends TSchema[], Key extends PropertyKey> = (
@@ -171,21 +146,17 @@ function FromUnion<Types extends TSchema[], Key extends PropertyKey>(types: [...
 // ------------------------------------------------------------------
 // FromTuple
 // ------------------------------------------------------------------
-
 // prettier-ignore
-type TFromTuple<Types extends TSchema[], Key extends PropertyKey, Result extends TSchema = (
-  Key extends '[number]' ? TUnionEvaluated<Types> :
-  Key extends keyof Types
-    ? Types[Key] extends infer Type extends TSchema
-      ? Type
-      : TNever 
-    : TNever
-)> = Result
+type TFromTuple<Types extends TSchema[], Key extends PropertyKey> = (
+  Key extends keyof Types ? Types[Key] : 
+  Key extends '[number]' ? TUnionEvaluated<Types> : 
+  TNever
+)
 // prettier-ignore
 function FromTuple<Types extends TSchema[], Key extends PropertyKey>(types: [...Types], key: Key): TFromTuple<Types, Key>  {
   return (
-    key === '[number]' ? UnionEvaluated(types) : 
     key in types ? types[key as number] : 
+    key === '[number]' ? UnionEvaluated(types) : 
     Never()
   ) as never
 }
@@ -194,20 +165,25 @@ function FromTuple<Types extends TSchema[], Key extends PropertyKey>(types: [...
 // ------------------------------------------------------------------
 // prettier-ignore
 type TFromArray<Type extends TSchema, Key extends PropertyKey> = (
-  Key extends '[number]' ? Type : TNever
+  Key extends '[number]' 
+    ? Type 
+    : TNever
 )
 // prettier-ignore
-function FromArray<Type extends TSchema, Key extends PropertyKey>(type: Type, key: Key): TFromArray<Type, Key> {
-  // ... ?
-  return (key === '[number]' ? type : Never()) as never
+function FromArray<Type extends TSchema, Key extends PropertyKey>(type: Type, key: Key): TFromArray<Type, Key>  {
+  return (
+    key === '[number]' 
+      ? type 
+      : Never()
+  ) as never
 }
 // ------------------------------------------------------------------
 // FromProperty
 // ------------------------------------------------------------------
-type AssertPropertyKey<T extends unknown> = Assert<T, string | number>
+type AssertPropertyKey<T> = Assert<T, string | number>
 
 // prettier-ignore
-type TFromProperty<Properties extends TProperties, Key extends PropertyKey, Result extends TSchema = (
+type TFromProperty<Properties extends TProperties, Key extends PropertyKey> = (
   // evaluate for string keys
   Key extends keyof Properties 
     ? Properties[Key] 
@@ -215,32 +191,32 @@ type TFromProperty<Properties extends TProperties, Key extends PropertyKey, Resu
     : `${AssertPropertyKey<Key>}` extends `${AssertPropertyKey<keyof Properties>}` 
       ? Properties[AssertPropertyKey<Key>]
       : TNever
-)> = Result
+)
 // prettier-ignore
-function FromProperty<Properties extends TProperties, Key extends PropertyKey>(properties: Properties, key: Key): TFromProperty<Properties, Key> {
-  return (key in properties ? properties[key as string] : Never()) as never
+function FromProperty<Properties extends TProperties, Key extends PropertyKey>(properties: Properties, propertyKey: Key): TFromProperty<Properties, Key> {
+  return (propertyKey in properties ? properties[propertyKey as string] : Never()) as never
 }
 // ------------------------------------------------------------------
 // FromKey
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TIndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = (
-  Type extends TRecursive<infer S extends TSchema> ? TIndexFromPropertyKey<S, Key> :
-  Type extends TIntersect<infer S extends TSchema[]> ? TFromIntersect<S, Key> :
-  Type extends TUnion<infer S extends TSchema[]> ? TFromUnion<S, Key> :
-  Type extends TTuple<infer S extends TSchema[]> ? TFromTuple<S, Key> :
-  Type extends TArray<infer S extends TSchema> ? TFromArray<S, Key> :
-  Type extends TObject<infer S extends TProperties> ? TFromProperty<S, Key> :
+  Type extends TRecursive<infer Type extends TSchema> ? TIndexFromPropertyKey<Type, Key> :
+  Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types, Key> :
+  Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types, Key> :
+  Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types, Key> :
+  Type extends TArray<infer Type extends TSchema> ? TFromArray<Type, Key> :
+  Type extends TObject<infer Properties extends TProperties> ? TFromProperty<Properties, Key> :
   TNever
 )
 // prettier-ignore
-export function IndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey>(type: Type, key: Key): TIndexFromPropertyKey<Type, Key> {
+export function IndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey>(type: Type, propertyKey: Key): TIndexFromPropertyKey<Type, Key> {
   return (
-    IsIntersect(type) ? FromIntersect(type.allOf, key) :
-    IsUnion(type) ? FromUnion(type.anyOf, key) :
-    IsTuple(type) ? FromTuple(type.items ?? [], key) :
-    IsArray(type) ? FromArray(type.items, key) :
-    IsObject(type) ? FromProperty(type.properties, key) :
+    IsIntersect(type) ? FromIntersect(type.allOf, propertyKey) :
+    IsUnion(type) ? FromUnion(type.anyOf, propertyKey) :
+    IsTuple(type) ? FromTuple(type.items ?? [], propertyKey) :
+    IsArray(type) ? FromArray(type.items, propertyKey) :
+    IsObject(type) ? FromProperty(type.properties, propertyKey) :
     Never()
   ) as never
 }
@@ -255,76 +231,70 @@ export type TIndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends Pr
 )
 // prettier-ignore
 export function IndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): TIndexFromPropertyKeys<Type, PropertyKeys> {
-  return propertyKeys.map(left => IndexFromPropertyKey(type, left)) as never
+  return propertyKeys.map(propertyKey => IndexFromPropertyKey(type, propertyKey)) as never
 }
 // ------------------------------------------------------------------
 // FromSchema
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromType<Type extends TSchema, PropertyKeys extends PropertyKey[], 
-  Result extends TSchema[] = TIndexFromPropertyKeys<Type, PropertyKeys>,
-> = TUnionEvaluated<Result>
+type FromSchema<Type extends TSchema, PropertyKeys extends PropertyKey[]> = (
+  TUnionEvaluated<TIndexFromPropertyKeys<Type, PropertyKeys>>
+)
 // prettier-ignore
-function FromType<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): TFromType<Type, PropertyKeys> {
-  const result = IndexFromPropertyKeys(type, propertyKeys as PropertyKey[])
-  return UnionEvaluated(result) as never
+function FromSchema<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): FromSchema<Type, PropertyKeys> {
+  return (
+    UnionEvaluated(IndexFromPropertyKeys(type, propertyKeys as PropertyKey[]))
+  ) as never
 }
 // ------------------------------------------------------------------
-// UnionFromPropertyKeys
+// FromSchema
 // ------------------------------------------------------------------
 // prettier-ignore
-type TUnionFromPropertyKeys<PropertyKeys extends PropertyKey[], Result extends TLiteral[] = []> = (
-  PropertyKeys extends [infer Key extends PropertyKey, ...infer Rest extends PropertyKey[]]
-    ? Key extends TLiteralValue
-      ? TUnionFromPropertyKeys<Rest, [...Result, TLiteral<Key>]>
-      : TUnionFromPropertyKeys<Rest, [...Result]>
-    : TUnionEvaluated<Result>
+export type TIndexFromComputed<Type extends TSchema, Key extends TSchema> = (
+  TComputed<'Index', [Type, Key]>
 )
 // prettier-ignore
-function UnionFromPropertyKeys<PropertyKeys extends PropertyKey[]>(propertyKeys: PropertyKeys): TUnionFromPropertyKeys<PropertyKeys> {
-  const result = propertyKeys.reduce((result, key) => IsLiteralValue(key) ? [...result, Literal(key)]: result, [] as TLiteral[])
-  return UnionEvaluated(result) as never
+export function IndexFromComputed<Type extends TSchema, Key extends TSchema>(type: Type, key: Key): TIndexFromComputed<Type, Key> {
+  return Computed('Index', [type, key])
 }
 // ------------------------------------------------------------------
 // TIndex
 // ------------------------------------------------------------------
-// prettier-ignore (do not export this type)
-type TResolvePropertyKeys<Key extends TSchema | PropertyKey[]> = Key extends TSchema ? TIndexPropertyKeys<Key> : Key
-// prettier-ignore (do not export this type)
-type TResolveTypeKey<Key extends TSchema | PropertyKey[]> = Key extends PropertyKey[] ? TUnionFromPropertyKeys<Key> : Key
 // prettier-ignore
-export type TIndex<Type extends TSchema, Key extends TSchema | PropertyKey[],
-  IsTypeRef extends boolean = Type extends TRef ? true : false,
-  IsKeyRef extends boolean = Key extends TRef ? true : false,
-> = (
-  Key extends TMappedResult ? TIndexFromMappedResult<Type, Key> :
-  Key extends TMappedKey ? TIndexFromMappedKey<Type, Key> :
-  [IsTypeRef, IsKeyRef] extends [true, true] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> :
-  [IsTypeRef, IsKeyRef] extends [false, true] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> :
-  [IsTypeRef, IsKeyRef] extends [true, false] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> : 
-  TFromType<Type, TResolvePropertyKeys<Key>>
+export type TIndex<Type extends TSchema, PropertyKeys extends PropertyKey[]> = (
+  FromSchema<Type, PropertyKeys>
 )
 /** `[Json]` Returns an Indexed property type for the given keys */
-export function Index<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TIndex<Type, Key>
+export function Index<Type extends TRef, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>
 /** `[Json]` Returns an Indexed property type for the given keys */
-export function Index<Type extends TSchema, Key extends TMappedKey>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>
+export function Index<Type extends TSchema, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>
 /** `[Json]` Returns an Indexed property type for the given keys */
-export function Index<Type extends TSchema, Key extends TMappedResult>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>
+export function Index<Type extends TRef, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>
 /** `[Json]` Returns an Indexed property type for the given keys */
-export function Index<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>
+export function Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>
 /** `[Json]` Returns an Indexed property type for the given keys */
-// prettier-ignore
-export function Index(type: any, key: any, options?: SchemaOptions): any {
-  const typeKey: TSchema = IsArrayValue(key) ? UnionFromPropertyKeys(key as PropertyKey[]) : key 
-  const propertyKeys: PropertyKey[] = IsSchema(key) ? IndexPropertyKeys(key) : key
-  const isTypeRef: boolean = IsRef(type)
-  const isKeyRef: boolean = IsRef(key)
-  return (
-    IsMappedResult(key) ? IndexFromMappedResult(type, key, options) :
-    IsMappedKey(key) ? IndexFromMappedKey(type, key, options) :
-    (isTypeRef && isKeyRef) ? Computed('Index', [type, typeKey], options) :
-    (!isTypeRef && isKeyRef) ? Computed('Index', [type, typeKey], options) :
-    (isTypeRef && !isKeyRef) ? Computed('Index', [type, typeKey], options) :
-    CreateType(FromType(type, propertyKeys), options) 
-  ) as never
+export function Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>
+/** `[Json]` Returns an Indexed property type for the given keys */
+export function Index<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TIndexFromMappedKey<Type, MappedKey>
+/** `[Json]` Returns an Indexed property type for the given keys */
+export function Index<Type extends TSchema, Key extends TSchema, PropertyKeys extends PropertyKey[] = TIndexPropertyKeys<Key>>(T: Type, K: Key, options?: SchemaOptions): TIndex<Type, PropertyKeys>
+/** `[Json]` Returns an Indexed property type for the given keys */
+export function Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>
+/** `[Json]` Returns an Indexed property type for the given keys */
+export function Index(type: TSchema, key: any, options?: SchemaOptions): any {
+  // computed-type
+  if (IsRef(type) || IsRef(key)) {
+    const error = `Index types using Ref parameters require both Type and Key to be of TSchema`
+    if (!IsSchema(type) || !IsSchema(key)) throw new TypeBoxError(error)
+    return Computed('Index', [type, key])
+  }
+  // mapped-types
+  if (IsMappedResult(key)) return IndexFromMappedResult(type, key, options)
+  if (IsMappedKey(key)) return IndexFromMappedKey(type, key, options)
+  // prettier-ignore
+  return CreateType(
+    IsSchema(key) 
+      ? FromSchema(type, IndexPropertyKeys(key)) 
+      : FromSchema(type, key as string[])
+  , options) as never
 }
diff --git a/src/type/module/compute.ts b/src/type/module/compute.ts
index b2ee6e785..8527ab135 100644
--- a/src/type/module/compute.ts
+++ b/src/type/module/compute.ts
@@ -35,8 +35,8 @@ import { Awaited, type TAwaited } from '../awaited/index'
 import { AsyncIterator, type TAsyncIterator } from '../async-iterator/index'
 import { TComputed } from '../computed/index'
 import { Constructor, type TConstructor } from '../constructor/index'
-import { Index, type TIndex } from '../indexed/index'
-import { TEnum, TEnumRecord } from '../enum/index'
+import { Index, type TIndex, type TIndexPropertyKeys } from '../indexed/index'
+import { TEnum, type TEnumRecord } from '../enum/index'
 import { Function as FunctionType, type TFunction } from '../function/index'
 import { Intersect, type TIntersect, type TIntersectEvaluated } from '../intersect/index'
 import { Iterator, type TIterator } from '../iterator/index'
@@ -119,7 +119,14 @@ function FromAwaited<Parameters extends TSchema[]>(parameters: Parameters): TFro
 // ------------------------------------------------------------------
 // prettier-ignore
 type TFromIndex<Parameters extends TSchema[]> = (
-  Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TIndex<T0, T1> : never
+  Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] 
+    // Note: This inferred result check is required to mitgate a "as never" 
+    // assertion on FromComputed resolution. This should be removed when
+    // reimplementing TIndex to use TSchema as the primary key indexer.
+    ? TIndex<T0, TIndexPropertyKeys<T1>> extends infer Result extends TSchema 
+      ? Result
+      : never
+    : never
 )
 // prettier-ignore
 function FromIndex<Parameters extends TSchema[]>(parameters: Parameters): TFromIndex<Parameters> {
@@ -370,10 +377,7 @@ export function FromType<ModuleProperties extends TProperties, Type extends TSch
     // Traveral
     KindGuard.IsArray(type) ? CreateType(FromArray(moduleProperties, type.items), type) :
     KindGuard.IsAsyncIterator(type) ? CreateType(FromAsyncIterator(moduleProperties, type.items), type) :
-    // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
-    // all need re-implementation to remove the PropertyKey[] selector. Reimplementation of these types should
-    // be a priority as there is a potential for the current inference to break on TS compiler changes.
-    KindGuard.IsComputed(type) ? CreateType(FromComputed(moduleProperties, type.target, type.parameters) as never) :
+    KindGuard.IsComputed(type) ? CreateType(FromComputed(moduleProperties, type.target, type.parameters)) :
     KindGuard.IsConstructor(type) ? CreateType(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
     KindGuard.IsFunction(type) ? CreateType(FromFunction(moduleProperties, type.parameters, type.returns), type) :
     KindGuard.IsIntersect(type) ? CreateType(FromIntersect(moduleProperties, type.allOf), type) :
diff --git a/src/type/module/infer.ts b/src/type/module/infer.ts
index 65ca8fd13..2a663919f 100644
--- a/src/type/module/infer.ts
+++ b/src/type/module/infer.ts
@@ -126,7 +126,7 @@ type TInferTuple<ModuleProperties extends TProperties, Types extends TSchema[] ,
 type TInferRecord<ModuleProperties extends TProperties, Key extends TSchema, Type extends TSchema,
   InferredKey extends PropertyKey = TInfer<ModuleProperties, Key> extends infer Key extends PropertyKey ? Key : never,
   InferedType extends unknown = TInfer<ModuleProperties, Type>,
-> = Record<InferredKey, InferedType>
+> = Ensure<{ [_ in InferredKey]: InferedType }>
 // ------------------------------------------------------------------
 // Ref
 // ------------------------------------------------------------------
diff --git a/src/type/record/record.ts b/src/type/record/record.ts
index 782269644..8e7da8257 100644
--- a/src/type/record/record.ts
+++ b/src/type/record/record.ts
@@ -204,7 +204,9 @@ function FromNumberKey<Key extends TNumber, Type extends TSchema>(_: Key, type:
 // ------------------------------------------------------------------
 // prettier-ignore
 type RecordStatic<Key extends TSchema, Type extends TSchema, P extends unknown[]> = (
-  Evaluate<{ [_ in Assert<Static<Key>, PropertyKey>]: Static<Type, P>; }>
+  // Note: We would return a Record<K, T> here, but recursive Record<K, T> types will
+  // break when T is self recursive. We can mitigate this by using a Mapped instead.
+  Evaluate<{ [_ in Assert<Static<Key>, PropertyKey>]: Static<Type, P> }>
 )
 // prettier-ignore
 export interface TRecord<Key extends TSchema = TSchema, Type extends TSchema = TSchema> extends TSchema {
@@ -232,7 +234,7 @@ export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = (
   Key extends TString ? TFromStringKey<Key, Type> :
   Key extends TAny ? TFromAnyKey<Key, Type> :
   Key extends TNever ? TFromNeverKey<Key, Type> :
-  Key
+  TNever
 )
 // ------------------------------------------------------------------
 // TRecordOrObject
diff --git a/src/type/type/json.ts b/src/type/type/json.ts
index f7efb99c4..8cbb88ef2 100644
--- a/src/type/type/json.ts
+++ b/src/type/type/json.ts
@@ -35,7 +35,7 @@ import { Enum, type TEnum, type TEnumKey, type TEnumValue } from '../enum/index'
 import { Exclude, type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from '../exclude/index'
 import { Extends, type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index'
 import { Extract, type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from '../extract/index'
-import { Index, TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult } from '../indexed/index'
+import { Index, TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult, type TIndexFromComputed } from '../indexed/index'
 import { Integer, type IntegerOptions, type TInteger } from '../integer/index'
 import { Intersect, type IntersectOptions } from '../intersect/index'
 import { Capitalize, Uncapitalize, Lowercase, Uppercase, type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index'
@@ -164,13 +164,19 @@ export class JsonTypeBuilder {
     return Extract(type, union, options)
   }
   /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, key: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>
+  public Index<Type extends TRef, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>
   /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<Type extends TSchema, Key extends TMappedKey>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>
+  public Index<Type extends TSchema, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>
   /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<Type extends TSchema, Key extends TMappedResult>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>
+  public Index<Type extends TRef, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>
   /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>
+  public Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>
+  /** `[Json]` Returns an Indexed property type for the given keys */
+  public Index<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TIndexFromMappedKey<Type, MappedKey>
+  /** `[Json]` Returns an Indexed property type for the given keys */
+  public Index<Type extends TSchema, Key extends TSchema, PropertyKeys extends PropertyKey[] = TIndexPropertyKeys<Key>>(T: Type, K: Key, options?: SchemaOptions): TIndex<Type, PropertyKeys>
+  /** `[Json]` Returns an Indexed property type for the given keys */
+  public Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>
   /** `[Json]` Returns an Indexed property type for the given keys */
   public Index(type: TSchema, key: any, options?: SchemaOptions): any {
     return Index(type, key, options)
diff --git a/src/value/parse/parse.ts b/src/value/parse/parse.ts
index be07f5b81..e28d53de8 100644
--- a/src/value/parse/parse.ts
+++ b/src/value/parse/parse.ts
@@ -53,7 +53,7 @@ export class ParseError extends TypeBoxError {
 // ------------------------------------------------------------------
 // ParseRegistry
 // ------------------------------------------------------------------
-export type TParseOperation = 'Clone' | 'Clean' | 'Default' | 'Convert' | 'Assert' | 'Decode' | ({} & string)
+export type TParseOperation = 'Clone' | 'Clean' | 'Default' | 'Convert' | 'Assert' | 'Decode' | 'Encode' | ({} & string)
 export type TParseFunction = (type: TSchema, references: TSchema[], value: unknown) => unknown
 
 // prettier-ignore

From 88a48198c56021ffd8f74cb655f1220a3e68fba3 Mon Sep 17 00:00:00 2001
From: Haydn Paterson <haydn.developer@gmail.com>
Date: Thu, 5 Dec 2024 14:24:44 +0900
Subject: [PATCH 321/369] Revision 0.34.11 (#1110)

* Fix Compile For Deep Referential Module Types

* Version

* ChangeLog
---
 changelog/0.34.0.md                 |  2 ++
 package-lock.json                   |  4 ++--
 package.json                        |  2 +-
 src/compiler/compiler.ts            | 21 ++++++++---------
 test/runtime/compiler-ajv/module.ts | 35 +++++++++++++++++++++++++++++
 test/runtime/compiler/module.ts     | 35 +++++++++++++++++++++++++++++
 test/runtime/value/check/module.ts  | 35 +++++++++++++++++++++++++++++
 7 files changed, 121 insertions(+), 13 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 0b821e451..b7774bfec 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,4 +1,6 @@
 ### 0.34.0
+- [Revision 0.34.11](https://github.com/sinclairzx81/typebox/pull/1110)
+  - Fix Compiler Emit for Deeply Referential Module Types
 - [Revision 0.34.10](https://github.com/sinclairzx81/typebox/pull/1107)
   - Fix Declaration Emit for Index and Mapped Types
   - Fix Record Inference Presentation when Embedded in Modules
diff --git a/package-lock.json b/package-lock.json
index acfa45500..37145ec05 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.10",
+  "version": "0.34.11",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.10",
+      "version": "0.34.11",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 8b857c362..2734e73ea 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.10",
+  "version": "0.34.11",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 7450c8aab..5edf8fd7b 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -59,7 +59,7 @@ import type { TNumber } from '../type/number/index'
 import type { TObject } from '../type/object/index'
 import type { TPromise } from '../type/promise/index'
 import type { TRecord } from '../type/record/index'
-import type { TRef } from '../type/ref/index'
+import { Ref, type TRef } from '../type/ref/index'
 import type { TRegExp } from '../type/regexp/index'
 import type { TTemplateLiteral } from '../type/template-literal/index'
 import type { TThis } from '../type/recursive/index'
@@ -298,9 +298,10 @@ export namespace TypeCompiler {
     yield `(typeof ${value} === 'function')`
   }
   function* FromImport(schema: TImport, references: TSchema[], value: string): IterableIterator<string> {
-    const definitions = globalThis.Object.values(schema.$defs) as TSchema[]
-    const target = schema.$defs[schema.$ref] as TSchema
-    yield* Visit(target, [...references, ...definitions], value)
+    const members = globalThis.Object.getOwnPropertyNames(schema.$defs).reduce((result, key) => {
+      return [...result, schema.$defs[key as never] as TSchema]
+    }, [] as TSchema[])
+    yield* Visit(Ref(schema.$ref), [...references, ...members], value)
   }
   function* FromInteger(schema: TInteger, references: TSchema[], value: string): IterableIterator<string> {
     yield `Number.isInteger(${value})`
@@ -399,12 +400,8 @@ export namespace TypeCompiler {
   function* FromRef(schema: TRef, references: TSchema[], value: string): IterableIterator<string> {
     const target = Deref(schema, references)
     // Reference: If we have seen this reference before we can just yield and return the function call.
-    // If this isn't the case we defer to visit to generate and set the _recursion_end_for_ for subsequent
-    // passes. This operation is very awkward as we are using the functions state to store values to
-    // enable self referential types to terminate. This needs to be refactored.
-    const recursiveEnd = `_recursion_end_for_${schema.$ref}`
-    if (state.functions.has(recursiveEnd)) return yield `${CreateFunctionName(schema.$ref)}(${value})`
-    state.functions.set(recursiveEnd, '') // terminate recursion here by setting the name.
+    // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
+    if (state.functions.has(schema.$ref)) return yield `${CreateFunctionName(schema.$ref)}(${value})`
     yield* Visit(target, references, value)
   }
   function* FromRegExp(schema: TRegExp, references: TSchema[], value: string): IterableIterator<string> {
@@ -481,6 +478,10 @@ export namespace TypeCompiler {
       if (state.functions.has(functionName)) {
         return yield `${functionName}(${value})`
       } else {
+        // Note: In the case of cyclic types, we need to create a 'functions' record
+        // to prevent infinitely re-visiting the CreateFunction. Subsequent attempts
+        // to visit will be caught by the above condition.
+        state.functions.set(functionName, '<deferred>')
         const functionCode = CreateFunction(functionName, schema, references, 'value', false)
         state.functions.set(functionName, functionCode)
         return yield `${functionName}(${value})`
diff --git a/test/runtime/compiler-ajv/module.ts b/test/runtime/compiler-ajv/module.ts
index 756c09f36..0797dd451 100644
--- a/test/runtime/compiler-ajv/module.ts
+++ b/test/runtime/compiler-ajv/module.ts
@@ -106,4 +106,39 @@ describe('compiler-ajv/Module', () => {
     Ok(T, { y: [null], w: [null] })
     Fail(T, { x: [1], y: [null], w: [null] })
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/1109
+  // ----------------------------------------------------------------
+  it('Should validate deep referential 1', () => {
+    const Module = Type.Module({
+      A: Type.Union([Type.Literal('Foo'), Type.Literal('Bar')]),
+      B: Type.Ref('A'),
+      C: Type.Object({ ref: Type.Ref('B') }),
+      D: Type.Union([Type.Ref('B'), Type.Ref('C')]),
+    })
+    Ok(Module.Import('A') as never, 'Foo')
+    Ok(Module.Import('A') as never, 'Bar')
+    Ok(Module.Import('B') as never, 'Foo')
+    Ok(Module.Import('B') as never, 'Bar')
+    Ok(Module.Import('C') as never, { ref: 'Foo' })
+    Ok(Module.Import('C') as never, { ref: 'Bar' })
+    Ok(Module.Import('D') as never, 'Foo')
+    Ok(Module.Import('D') as never, 'Bar')
+    Ok(Module.Import('D') as never, { ref: 'Foo' })
+    Ok(Module.Import('D') as never, { ref: 'Bar' })
+  })
+  it('Should validate deep referential 2', () => {
+    const Module = Type.Module({
+      A: Type.Literal('Foo'),
+      B: Type.Ref('A'),
+      C: Type.Ref('B'),
+      D: Type.Ref('C'),
+      E: Type.Ref('D'),
+    })
+    Ok(Module.Import('A'), 'Foo')
+    Ok(Module.Import('B'), 'Foo')
+    Ok(Module.Import('C'), 'Foo')
+    Ok(Module.Import('D'), 'Foo')
+    Ok(Module.Import('E'), 'Foo')
+  })
 })
diff --git a/test/runtime/compiler/module.ts b/test/runtime/compiler/module.ts
index 32b455605..2121a9d5d 100644
--- a/test/runtime/compiler/module.ts
+++ b/test/runtime/compiler/module.ts
@@ -106,4 +106,39 @@ describe('compiler/Module', () => {
     Ok(T, { y: [null], w: [null] })
     Fail(T, { x: [1], y: [null], w: [null] })
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/1109
+  // ----------------------------------------------------------------
+  it('Should validate deep referential 1', () => {
+    const Module = Type.Module({
+      A: Type.Union([Type.Literal('Foo'), Type.Literal('Bar')]),
+      B: Type.Ref('A'),
+      C: Type.Object({ ref: Type.Ref('B') }),
+      D: Type.Union([Type.Ref('B'), Type.Ref('C')]),
+    })
+    Ok(Module.Import('A') as never, 'Foo')
+    Ok(Module.Import('A') as never, 'Bar')
+    Ok(Module.Import('B') as never, 'Foo')
+    Ok(Module.Import('B') as never, 'Bar')
+    Ok(Module.Import('C') as never, { ref: 'Foo' })
+    Ok(Module.Import('C') as never, { ref: 'Bar' })
+    Ok(Module.Import('D') as never, 'Foo')
+    Ok(Module.Import('D') as never, 'Bar')
+    Ok(Module.Import('D') as never, { ref: 'Foo' })
+    Ok(Module.Import('D') as never, { ref: 'Bar' })
+  })
+  it('Should validate deep referential 2', () => {
+    const Module = Type.Module({
+      A: Type.Literal('Foo'),
+      B: Type.Ref('A'),
+      C: Type.Ref('B'),
+      D: Type.Ref('C'),
+      E: Type.Ref('D'),
+    })
+    Ok(Module.Import('A'), 'Foo')
+    Ok(Module.Import('B'), 'Foo')
+    Ok(Module.Import('C'), 'Foo')
+    Ok(Module.Import('D'), 'Foo')
+    Ok(Module.Import('E'), 'Foo')
+  })
 })
diff --git a/test/runtime/value/check/module.ts b/test/runtime/value/check/module.ts
index 371b302d0..af80b0e68 100644
--- a/test/runtime/value/check/module.ts
+++ b/test/runtime/value/check/module.ts
@@ -108,4 +108,39 @@ describe('value/check/Module', () => {
     Assert.IsTrue(Value.Check(T, { y: [null], w: [null] }))
     Assert.IsFalse(Value.Check(T, { x: [1], y: [null], w: [null] }))
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/1109
+  // ----------------------------------------------------------------
+  it('Should validate deep referential 1', () => {
+    const Module = Type.Module({
+      A: Type.Union([Type.Literal('Foo'), Type.Literal('Bar')]),
+      B: Type.Ref('A'),
+      C: Type.Object({ ref: Type.Ref('B') }),
+      D: Type.Union([Type.Ref('B'), Type.Ref('C')]),
+    })
+    Assert.IsTrue(Value.Check(Module.Import('A') as never, 'Foo'))
+    Assert.IsTrue(Value.Check(Module.Import('A') as never, 'Bar'))
+    Assert.IsTrue(Value.Check(Module.Import('B') as never, 'Foo'))
+    Assert.IsTrue(Value.Check(Module.Import('B') as never, 'Bar'))
+    Assert.IsTrue(Value.Check(Module.Import('C') as never, { ref: 'Foo' }))
+    Assert.IsTrue(Value.Check(Module.Import('C') as never, { ref: 'Bar' }))
+    Assert.IsTrue(Value.Check(Module.Import('D') as never, 'Foo'))
+    Assert.IsTrue(Value.Check(Module.Import('D') as never, 'Bar'))
+    Assert.IsTrue(Value.Check(Module.Import('D') as never, { ref: 'Foo' }))
+    Assert.IsTrue(Value.Check(Module.Import('D') as never, { ref: 'Bar' }))
+  })
+  it('Should validate deep referential 2', () => {
+    const Module = Type.Module({
+      A: Type.Literal('Foo'),
+      B: Type.Ref('A'),
+      C: Type.Ref('B'),
+      D: Type.Ref('C'),
+      E: Type.Ref('D'),
+    })
+    Assert.IsTrue(Value.Check(Module.Import('A'), 'Foo'))
+    Assert.IsTrue(Value.Check(Module.Import('B'), 'Foo'))
+    Assert.IsTrue(Value.Check(Module.Import('C'), 'Foo'))
+    Assert.IsTrue(Value.Check(Module.Import('D'), 'Foo'))
+    Assert.IsTrue(Value.Check(Module.Import('E'), 'Foo'))
+  })
 })

From dd3fc5ff3200dfd76dc3b97252cf766409294181 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 11 Dec 2024 13:17:43 +0900
Subject: [PATCH 322/369] Prototype: Discriminated Union

---
 example/prototypes/discriminated-union.ts | 96 +++++++++++++++++++++++
 example/prototypes/index.ts               |  1 +
 2 files changed, 97 insertions(+)
 create mode 100644 example/prototypes/discriminated-union.ts

diff --git a/example/prototypes/discriminated-union.ts b/example/prototypes/discriminated-union.ts
new file mode 100644
index 000000000..22da0f486
--- /dev/null
+++ b/example/prototypes/discriminated-union.ts
@@ -0,0 +1,96 @@
+
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/prototypes
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Static, Kind, TSchema, TObject, SchemaOptions, CreateType, TLiteral, TypeRegistry, ValueGuard, KindGuard, TUnion } from '@sinclair/typebox'
+import { GetErrorFunction, SetErrorFunction } from 'src/errors/function'
+import { Value } from '@sinclair/typebox/value'
+
+// ------------------------------------------------------------------
+// DiscriminatedUnionError
+// ------------------------------------------------------------------
+const errorFunction = GetErrorFunction()
+
+// prettier-ignore
+SetErrorFunction((parameter) => {
+  if (parameter.schema[Kind] !== 'DiscriminatedUnion') {
+    return errorFunction(parameter)
+  }
+  const union = parameter.schema as TDiscriminatedUnion
+  // Try generate error when value matches known discriminator literal
+  if (ValueGuard.IsObject(parameter.value) && union.discriminator in parameter.value) {
+    const variant = parameter.schema.anyOf.find((variant: TSchema) => union.discriminator in variant.properties
+      && (variant.properties[union.discriminator] as TLiteral).const ===
+      (parameter.value as Record<PropertyKey, unknown>)[union.discriminator])
+    if (KindGuard.IsSchema(variant)) {
+      const literal = variant.properties[union.discriminator]
+      return `Invalid value for DiscriminatedUnion variant '${literal.const}'`
+    }
+  }
+  // Return generic error containing possible discriminator types.
+  const options = union.anyOf.map(object => object.properties[union.discriminator].const) as string[]
+  return `Expected value of ${options.map(option => `'${option}'`).join(', ')} for DiscriminatedUnion`
+})
+
+// ------------------------------------------------------------------
+// TDiscriminatedUnionObject
+//
+// Constructs a base TObject type requiring 1 discriminator property
+// ------------------------------------------------------------------
+// prettier-ignore
+type TDiscriminatedUnionProperties<Discriminator extends string> = {
+  [_ in Discriminator]: TLiteral
+}
+// prettier-ignore
+type TDiscriminatedUnionObject<Discriminator extends string> = TObject<TDiscriminatedUnionProperties<Discriminator>>
+
+// ------------------------------------------------------------------
+// DiscriminatedUnion
+// ------------------------------------------------------------------
+// prettier-ignore
+TypeRegistry.Set('DiscriminatedUnion', (schema: TDiscriminatedUnion, value) => {
+  return schema.anyOf.some(variant => Value.Check(variant, [], value))
+})
+// prettier-ignore
+export interface TDiscriminatedUnion<Discriminator extends string = string, Types extends TObject[] = TObject[]> extends TSchema {
+  [Kind]: 'DiscriminatedUnion'
+  static: Static<TUnion<Types>>
+  discriminator: Discriminator
+  anyOf: Types
+}
+
+/** Creates a DiscriminatedUnion. */
+// prettier-ignore
+export function DiscriminatedUnion<Discriminator extends string, Types extends TDiscriminatedUnionObject<Discriminator>[]>(
+  discriminator: Discriminator, types: [...Types], options?: SchemaOptions
+): TDiscriminatedUnion<Discriminator, Types> {
+  return CreateType({ [Kind]: 'DiscriminatedUnion', anyOf: types, discriminator }, options) as never
+}
+
+
+
diff --git a/example/prototypes/index.ts b/example/prototypes/index.ts
index 179da98fd..d5d9aeda4 100644
--- a/example/prototypes/index.ts
+++ b/example/prototypes/index.ts
@@ -26,6 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
+export * from './discriminated-union'
 export * from './from-schema'
 export * from './partial-deep'
 export * from './union-enum'

From cd61fa92c03c60d9bf38e50951a63409625796fa Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 18 Dec 2024 19:20:39 +0900
Subject: [PATCH 323/369] Revision 0.34.12 (#1120)

* Fix Mutate Object Check | Documentation

* ChangeLog
---
 changelog/0.34.0.md                 |  3 ++
 package-lock.json                   |  4 +--
 package.json                        |  2 +-
 readme.md                           | 52 +++++++++++++++++++++--------
 src/value/mutate/mutate.ts          | 14 +++++---
 test/runtime/value/mutate/mutate.ts | 28 ++++++++++++++++
 6 files changed, 83 insertions(+), 20 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index b7774bfec..4f7a9f483 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,4 +1,7 @@
 ### 0.34.0
+- [Revision 0.34.12](https://github.com/sinclairzx81/typebox/pull/1120)
+  - [1119](https://github.com/sinclairzx81/typebox/issues/1119) Fix for Mutate Object Comparison
+  - [1117](https://github.com/sinclairzx81/typebox/issues/1117) Re-Add Type.Recursive Documentation
 - [Revision 0.34.11](https://github.com/sinclairzx81/typebox/pull/1110)
   - Fix Compiler Emit for Deeply Referential Module Types
 - [Revision 0.34.10](https://github.com/sinclairzx81/typebox/pull/1107)
diff --git a/package-lock.json b/package-lock.json
index 37145ec05..42b48a004 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.11",
+  "version": "0.34.12",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.11",
+      "version": "0.34.12",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 2734e73ea..1bac1b697 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.11",
+  "version": "0.34.12",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 35d2c912e..1d44e671f 100644
--- a/readme.md
+++ b/readme.md
@@ -68,6 +68,7 @@ License MIT
   - [Options](#types-options)
   - [Properties](#types-properties)
   - [Generics](#types-generics)
+  - [Recursive](#types-recursive)
   - [Modules](#types-modules)
   - [Template Literal](#types-template-literal)
   - [Indexed](#types-indexed)
@@ -759,21 +760,51 @@ const T = Nullable(Type.String())                    // const T = {
 type T = Static<typeof T>                            // type T = string | null
 ```
 
-<a name='types-modules'></a>
+<a name='types-recursive'></a>
 
-### Module Types
+### Recursive Types
 
-TypeBox Modules are containers for related types. They provide a referential namespace, enabling types to reference one another via string identifiers. Modules support both singular and mutually recursive referencing within the context of a module, as well as referential computed types (such as Partial + Ref). All Module types must be imported before use. TypeBox represents an imported type with the `$defs` Json Schema keyword. 
+Use the Recursive function to create a singular recursive type.
 
-#### Usage
+```typescript
+const Node = Type.Recursive(Self => Type.Object({    // const Node = {
+  id: Type.String(),                                 //   $id: 'Node',
+  nodes: Type.Array(Self)                            //   type: 'object',
+}), { $id: 'Node' })                                 //   properties: {
+                                                     //     id: {
+                                                     //       type: 'string'
+                                                     //     },
+                                                     //     nodes: {
+                                                     //       type: 'array',
+                                                     //       items: {
+                                                     //         $ref: 'Node'
+                                                     //       }
+                                                     //     }
+                                                     //   },
+                                                     //   required: [
+                                                     //     'id',
+                                                     //     'nodes'
+                                                     //   ]
+                                                     // }
 
-The following creates a Module with User and PartialUser types. Note that the PartialUser type is specified as a Partial + Ref to the User type. It is not possible to perform a Partial operation directly on a reference, so TypeBox will return a TComputed type that defers the Partial operation until all types are resolved. The TComputed type is evaluated when calling Import on the Module.
+type Node = Static<typeof Node>                      // type Node = {
+                                                     //   id: string
+                                                     //   nodes: Node[]
+                                                     // }
 
-```typescript
-// Module with PartialUser and User types
+function test(node: Node) {
+  const id = node.nodes[0].nodes[0].id               // id is string
+}
+```
 
-const Module = Type.Module({
+<a name='types-modules'></a>
+
+### Module Types
 
+Module types are containers for a set of referential types. Modules act as namespaces, enabling types to reference one another via string identifiers. Modules support both singular and mutually recursive references, as well as deferred dereferencing for computed types such as Partial. Types imported from a module are expressed using the Json Schema `$defs` keyword. 
+
+```typescript
+const Module = Type.Module({
   PartialUser: Type.Partial(Type.Ref('User')),  // TComputed<'Partial', [TRef<'User'>]>
 
   User: Type.Object({                           // TObject<{
@@ -781,11 +812,7 @@ const Module = Type.Module({
     name: Type.String(),                        //   name: TString,
     email: Type.String()                        //   email: TString
   }),                                           // }>
-  
 })
-
-// Types must be imported before use.
-
 const User = Module.Import('User')               // const User: TImport<{...}, 'User'>
 
 type User = Static<typeof User>                  // type User = { 
@@ -803,7 +830,6 @@ type PartialUser = Static<typeof PartialUser>    // type PartialUser = {
                                                  // }
 ```
 
-
 <a name='types-template-literal'></a>
 
 ### Template Literal Types
diff --git a/src/value/mutate/mutate.ts b/src/value/mutate/mutate.ts
index ed35d9cfd..b5ad3472a 100644
--- a/src/value/mutate/mutate.ts
+++ b/src/value/mutate/mutate.ts
@@ -31,6 +31,12 @@ import { ValuePointer } from '../pointer/index'
 import { Clone } from '../clone/index'
 import { TypeBoxError } from '../../type/error/index'
 
+// ------------------------------------------------------------------
+// IsStandardObject
+// ------------------------------------------------------------------
+function IsStandardObject(value: unknown): value is Record<PropertyKey, unknown> {
+  return IsObject(value) && !IsArray(value)
+}
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -44,7 +50,7 @@ export class ValueMutateError extends TypeBoxError {
 // ------------------------------------------------------------------
 export type Mutable = { [key: string]: unknown } | unknown[]
 function ObjectType(root: Mutable, path: string, current: unknown, next: Record<string, unknown>) {
-  if (!IsObject(current)) {
+  if (!IsStandardObject(current)) {
     ValuePointer.Set(root, path, Clone(next))
   } else {
     const currentKeys = Object.getOwnPropertyNames(current)
@@ -90,7 +96,7 @@ function ValueType(root: Mutable, path: string, current: unknown, next: unknown)
 function Visit(root: Mutable, path: string, current: unknown, next: unknown) {
   if (IsArray(next)) return ArrayType(root, path, current, next)
   if (IsTypedArray(next)) return TypedArrayType(root, path, current, next)
-  if (IsObject(next)) return ObjectType(root, path, current, next)
+  if (IsStandardObject(next)) return ObjectType(root, path, current, next)
   if (IsValueType(next)) return ValueType(root, path, current, next)
 }
 // ------------------------------------------------------------------
@@ -102,8 +108,8 @@ function IsNonMutableValue(value: unknown): value is Mutable {
 function IsMismatchedValue(current: unknown, next: unknown) {
   // prettier-ignore
   return (
-    (IsObject(current) && IsArray(next)) || 
-    (IsArray(current) && IsObject(next))
+    (IsStandardObject(current) && IsArray(next)) || 
+    (IsArray(current) && IsStandardObject(next))
   )
 }
 // ------------------------------------------------------------------
diff --git a/test/runtime/value/mutate/mutate.ts b/test/runtime/value/mutate/mutate.ts
index f90fcd8f5..db4d65661 100644
--- a/test/runtime/value/mutate/mutate.ts
+++ b/test/runtime/value/mutate/mutate.ts
@@ -85,4 +85,32 @@ describe('value/mutate/Mutate', () => {
     Assert.NotEqual(A.x, X)
     Assert.IsEqual(A.x, [1, 2, 3])
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/1119
+  // ----------------------------------------------------------------
+  it('Should mutate array 1', () => {
+    const A: unknown[] = []
+    Value.Mutate(A, [])
+    Assert.IsEqual(A, [])
+  })
+  it('Should mutate array 2', () => {
+    const A: unknown[] = []
+    Value.Mutate(A, [1])
+    Assert.IsEqual(A, [1])
+  })
+  it('Should mutate array 3', () => {
+    const A: unknown[] = [1, 2, 3]
+    Value.Mutate(A, [1, 2])
+    Assert.IsEqual(A, [1, 2])
+  })
+  it('Should mutate array 4', () => {
+    const A: unknown[] = [1, 2, 3]
+    Value.Mutate(A, [1, 2, 3, 4])
+    Assert.IsEqual(A, [1, 2, 3, 4])
+  })
+  it('Should mutate array 5', () => {
+    const A: unknown[] = [1, 2, 3]
+    Value.Mutate(A, [{}, {}, {}, [1, 2, 3]])
+    Assert.IsEqual(A, [{}, {}, {}, [1, 2, 3]])
+  })
 })

From 598c1d3facc9f7f6f493428c9ed36d3479e5fda9 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 19 Dec 2024 17:27:54 +0900
Subject: [PATCH 324/369] Documentation (#1123)

- Ref Documentation Update
---
 src/type/ref/ref.ts   | 25 +++++++++++++++++++------
 src/type/type/json.ts | 25 +++++++++++++++++++------
 2 files changed, 38 insertions(+), 12 deletions(-)

diff --git a/src/type/ref/ref.ts b/src/type/ref/ref.ts
index f50f6a7ed..85e0e125c 100644
--- a/src/type/ref/ref.ts
+++ b/src/type/ref/ref.ts
@@ -47,18 +47,31 @@ export type TRefUnsafe<Type extends TSchema> = TUnsafe<Static<Type>>
 /** `[Json]` Creates a Ref type.*/
 export function Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref>
 /**
- * @deprecated `[Json]` Creates a Ref type. The referenced type MUST contain a $id. The Ref(TSchema) signature was
- * deprecated on 0.34.0 in support of a new type referencing model (Module). Existing implementations using Ref(TSchema)
- * can migrate using the following. The Ref(TSchema) validation behavior of Ref will be preserved how the construction
- * of legacy Ref(TSchema) will require wrapping in TUnsafe (where TUnsafe is used for inference only)
+ * @deprecated `[Json]` Creates a Ref type. This signature was deprecated in 0.34.0 where Ref requires callers to pass
+ * a `string` value for the reference (and not a schema).
+ *
+ * To adhere to the 0.34.0 signature, Ref implementations should be updated to the following.
  *
  * ```typescript
+ * // pre-0.34.0
+ *
+ * const T = Type.String({ $id: 'T' })
+ *
  * const R = Type.Ref(T)
  * ```
- * to
+ * should be changed to the following
+ *
+ * ```typescript
+ * // post-0.34.0
+ *
+ * const T = Type.String({ $id: 'T' })
+ *
+ * const R = Type.Unsafe<Static<typeof T>>(Type.Ref('T'))
+ * ```
+ * You can also create a generic function to replicate the pre-0.34.0 signature if required
  *
  * ```typescript
- * const R = Type.Unsafe<Static<T>>(T.$id)
+ * const LegacyRef = <T extends TSchema>(schema: T) => Type.Unsafe<Static<T>>(Type.Ref(schema.$id!))
  * ```
  */
 export function Ref<Type extends TSchema>(type: Type, options?: SchemaOptions): TRefUnsafe<Type>
diff --git a/src/type/type/json.ts b/src/type/type/json.ts
index 8cbb88ef2..afc3650de 100644
--- a/src/type/type/json.ts
+++ b/src/type/type/json.ts
@@ -269,18 +269,31 @@ export class JsonTypeBuilder {
   /** `[Json]` Creates a Ref type.*/
   public Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref>
   /**
-   * @deprecated `[Json]` Creates a Ref type. The referenced type MUST contain a $id. The Ref(TSchema) signature was
-   * deprecated on 0.34.0 in support of a new type referencing model (Module). Existing implementations using Ref(TSchema)
-   * can migrate using the following. The Ref(TSchema) validation behavior of Ref will be preserved how the construction
-   * of legacy Ref(TSchema) will require wrapping in TUnsafe (where TUnsafe is used for inference only)
+   * @deprecated `[Json]` Creates a Ref type. This signature was deprecated in 0.34.0 where Ref requires callers to pass
+   * a `string` value for the reference (and not a schema).
+   *
+   * To adhere to the 0.34.0 signature, Ref implementations should be updated to the following.
    *
    * ```typescript
+   * // pre-0.34.0
+   *
+   * const T = Type.String({ $id: 'T' })
+   *
    * const R = Type.Ref(T)
    * ```
-   * to
+   * should be changed to the following
+   *
+   * ```typescript
+   * // post-0.34.0
+   *
+   * const T = Type.String({ $id: 'T' })
+   *
+   * const R = Type.Unsafe<Static<typeof T>>(Type.Ref('T'))
+   * ```
+   * You can also create a generic function to replicate the pre-0.34.0 signature if required
    *
    * ```typescript
-   * const R = Type.Unsafe<Static<T>>(T.$id)
+   * const LegacyRef = <T extends TSchema>(schema: T) => Type.Unsafe<Static<T>>(Type.Ref(schema.$id!))
    * ```
    */
   public Ref<Type extends TSchema>(type: Type, options?: SchemaOptions): TRefUnsafe<Type>

From 6d54d12420ee8badaa4cb2a3492af4cba214eb95 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 21 Dec 2024 03:40:45 +0900
Subject: [PATCH 325/369] Revision 0.34.13 (#1124)

* Fix: Convert Symbol Check for TypeScript 5.8.0

* Version

* ChangeLog
---
 changelog/0.34.0.md          | 2 ++
 package-lock.json            | 4 ++--
 package.json                 | 2 +-
 src/value/convert/convert.ts | 7 +------
 4 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 4f7a9f483..3c68b589d 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,4 +1,6 @@
 ### 0.34.0
+- [Revision 0.34.13](https://github.com/sinclairzx81/typebox/pull/1124)
+  - Pre emptive fix for TypeScript 5.8.0-nightly to resolve symbol narrowing on Convert.
 - [Revision 0.34.12](https://github.com/sinclairzx81/typebox/pull/1120)
   - [1119](https://github.com/sinclairzx81/typebox/issues/1119) Fix for Mutate Object Comparison
   - [1117](https://github.com/sinclairzx81/typebox/issues/1117) Re-Add Type.Recursive Documentation
diff --git a/package-lock.json b/package-lock.json
index 42b48a004..82a40a27d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.12",
+  "version": "0.34.13",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.12",
+      "version": "0.34.13",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 1bac1b697..e40785943 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.12",
+  "version": "0.34.13",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index 1cfaa1081..9461bd7dd 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -57,11 +57,6 @@ import type { TUndefined } from '../../type/undefined/index'
 // ------------------------------------------------------------------
 import { IsArray, IsObject, IsDate, IsUndefined, IsString, IsNumber, IsBoolean, IsBigInt, IsSymbol, HasPropertyKey } from '../guard/index'
 
-// ------------------------------------------------------------------
-// TypeGuard
-// ------------------------------------------------------------------
-import { IsOptional } from '../../type/guard/kind'
-
 // ------------------------------------------------------------------
 // Conversions
 // ------------------------------------------------------------------
@@ -124,7 +119,7 @@ function TryConvertBigInt(value: unknown) {
   return IsStringNumeric(value) ? BigInt(truncateInteger(value)) : IsNumber(value) ? BigInt(Math.trunc(value)) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value
 }
 function TryConvertString(value: unknown) {
-  return IsValueToString(value) ? value.toString() : IsSymbol(value) && value.description !== undefined ? value.description.toString() : value
+  return IsSymbol(value) && value.description !== undefined ? value.description.toString() : IsValueToString(value) ? value.toString() : value
 }
 function TryConvertNumber(value: unknown) {
   return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value

From bcfee3d0b1a7253c50fd52ec32d28a197d77682e Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 14 Jan 2025 17:10:09 +0900
Subject: [PATCH 326/369] Prototype: Options and RecursiveMap (#1137)

---
 example/prototypes/index.ts         |   2 +
 example/prototypes/options.ts       |  40 +++++++
 example/prototypes/readme.md        |  50 +++++++++
 example/prototypes/recursive-map.ts | 156 ++++++++++++++++++++++++++++
 example/standard/readme.md          |  66 +++---------
 example/standard/standard.ts        |  63 +++++++----
 6 files changed, 304 insertions(+), 73 deletions(-)
 create mode 100644 example/prototypes/options.ts
 create mode 100644 example/prototypes/recursive-map.ts

diff --git a/example/prototypes/index.ts b/example/prototypes/index.ts
index d5d9aeda4..dd5f572ee 100644
--- a/example/prototypes/index.ts
+++ b/example/prototypes/index.ts
@@ -28,6 +28,8 @@ THE SOFTWARE.
 
 export * from './discriminated-union'
 export * from './from-schema'
+export * from './options'
 export * from './partial-deep'
 export * from './union-enum'
 export * from './union-oneof'
+export * from './recursive-map'
diff --git a/example/prototypes/options.ts b/example/prototypes/options.ts
new file mode 100644
index 000000000..0270acbb7
--- /dev/null
+++ b/example/prototypes/options.ts
@@ -0,0 +1,40 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/prototypes
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { TSchema, CloneType } from '@sinclair/typebox'
+
+// prettier-ignore
+export type TOptions<Type extends TSchema, Options extends Record<PropertyKey, unknown>> = (
+  Type & Options
+)
+
+/** `[Prototype]` Augments a schema with additional generics aware properties */
+// prettier-ignore
+export function Options<Type extends TSchema, Options extends Record<PropertyKey, unknown>>(type: Type, options: Options): TOptions<Type, Options> {
+  return CloneType(type, options) as never
+}
diff --git a/example/prototypes/readme.md b/example/prototypes/readme.md
index cd95b34fb..f3aea908b 100644
--- a/example/prototypes/readme.md
+++ b/example/prototypes/readme.md
@@ -69,4 +69,54 @@ const T = UnionOneOf([                              // const T = {
 
 type T = Static<typeof T>                           // type T = 'A' | 'B' | 'C'
 
+```
+
+## Options
+
+By default, TypeBox does not represent arbituary options as generics aware properties. However, there are cases where having options observable to the type system can be useful, for example conditionally mapping schematics based on custom metadata. The Options function makes user defined options generics aware.
+
+```typescript
+import { Options } from './prototypes'
+
+const A = Options(Type.String(), { foo: 1 })             // Options<TString, { foo: number }>
+
+type A = typeof A extends { foo: number } ? true : false // true: foo property is observable to the type system
+```
+
+## Recursive Map
+
+The Recursive Map type enables deep structural remapping of a type and it's internal constituents. This type accepts a TSchema type and a mapping type function (expressed via HKT). The HKT is applied when traversing the type and it's interior. The mapping HKT can apply conditional tests to each visited type to remap into a new form. The following augments a schematic via Options, and conditionally remaps any schema with an default annotation to make it optional. 
+
+```typescript
+import { Type, TOptional, Static, TSchema } from '@sinclair/typebox'
+
+import { TRecursiveMap, TMappingType, Options } from './prototypes'
+
+// ------------------------------------------------------------------
+// StaticDefault
+// ------------------------------------------------------------------
+export interface StaticDefaultMapping extends TMappingType { 
+  output: (
+    this['input'] extends TSchema                        // if input schematic contains an default 
+      ? this['input'] extends { default: unknown }       // annotation, remap it to be optional, 
+        ? TOptional<this['input']>                       // otherwise just return the schema as is.
+        : this['input']
+      : this['input']
+  )
+}
+export type StaticDefault<Type extends TSchema> = (
+  Static<TRecursiveMap<Type, StaticDefaultMapping>>
+)
+
+// ------------------------------------------------------------------
+// Usage
+// ------------------------------------------------------------------
+
+const T = Type.Object({
+  x: Options(Type.String(), { default: 'hello' }),
+  y: Type.String()
+})
+
+type T = StaticDefault<typeof T>   // { x?: string, y: string }
+type S = Static<typeof T>          // { x: string, y: string }
 ```
\ No newline at end of file
diff --git a/example/prototypes/recursive-map.ts b/example/prototypes/recursive-map.ts
new file mode 100644
index 000000000..0443bed91
--- /dev/null
+++ b/example/prototypes/recursive-map.ts
@@ -0,0 +1,156 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/prototypes
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '@sinclair/typebox'
+
+// ------------------------------------------------------------------
+// Mapping: Functions and Type 
+// ------------------------------------------------------------------
+export type TMappingFunction = (schema: Types.TSchema) => Types.TSchema
+
+export interface TMappingType {
+  input: unknown
+  output: unknown
+}
+// ------------------------------------------------------------------
+// Record Parameters
+// ------------------------------------------------------------------
+function GetRecordPattern(record: Types.TRecord): string {
+  return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0]
+}
+function GetRecordKey(record: Types.TRecord): Types.TSchema {
+  const pattern = GetRecordPattern(record)
+  return (
+    pattern === Types.PatternStringExact ? Types.String() :
+    pattern === Types.PatternNumberExact ? Types.Number() :
+    pattern === Types.PatternBooleanExact ? Types.Boolean() :
+    Types.String({ pattern })
+  )
+}
+function GetRecordValue(record: Types.TRecord): Types.TSchema {
+  return record.patternProperties[GetRecordPattern(record)]
+}
+// ------------------------------------------------------------------
+// Traversal
+// ------------------------------------------------------------------
+// prettier-ignore
+type TApply<Type extends Types.TSchema, Func extends TMappingType,
+  Mapped = (Func & { input: Type })['output'],
+  Result = Mapped extends Types.TSchema ? Mapped : never
+> = Result
+// prettier-ignore
+type TFromProperties<Properties extends Types.TProperties, Func extends TMappingType, Result extends Types.TProperties = {
+  [Key in keyof Properties]: TRecursiveMap<Properties[Key], Func>
+}> = Result
+function FromProperties(properties: Types.TProperties, func: TMappingFunction): Types.TProperties {
+  return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+    return {...result, [key]: RecursiveMap(properties[key], func) }
+  }, {})
+}
+// prettier-ignore
+type TFromRest<Types extends Types.TSchema[], Func extends TMappingType, Result extends Types.TSchema[] = []> = (
+  Types extends [infer Left extends Types.TSchema, ...infer Right extends Types.TSchema[]]
+    ? TFromRest<Right, Func, [...Result, TRecursiveMap<Left, Func>]>
+    : Result
+)
+function FromRest(types: Types.TSchema[], func: TMappingFunction): Types.TSchema[] {
+  return types.map(type => RecursiveMap(type, func))
+}
+// prettier-ignore
+type TFromType<Type extends Types.TSchema, Func extends TMappingType, Result extends Types.TSchema = (
+  TApply<Type, Func>
+)> = Result
+function FromType(type: Types.TSchema, func: TMappingFunction): Types.TSchema {
+  return func(type)
+}
+// ------------------------------------------------------------------
+// TRecursiveMap<Type, Mapping>
+// ------------------------------------------------------------------
+/** `[Prototype]` Applies a deep recursive map across the given type and sub types. */
+// prettier-ignore
+export type TRecursiveMap<Type extends Types.TSchema, Func extends TMappingType, 
+  // Maps the Exterior Type
+  Exterior extends Types.TSchema = TFromType<Type, Func>, 
+  // Maps the Interior Parameterized Types
+  Interior extends Types.TSchema = (
+    Exterior extends Types.TConstructor<infer Parameters extends Types.TSchema[], infer ReturnType extends Types.TSchema> ? Types.TConstructor<TFromRest<Parameters, Func>, TFromType<ReturnType, Func>> :
+    Exterior extends Types.TFunction<infer Parameters extends Types.TSchema[], infer ReturnType extends Types.TSchema> ? Types.TFunction<TFromRest<Parameters, Func>, TFromType<ReturnType, Func>> :
+    Exterior extends Types.TIntersect<infer Types extends Types.TSchema[]> ? Types.TIntersect<TFromRest<Types, Func>> :
+    Exterior extends Types.TUnion<infer Types extends Types.TSchema[]> ? Types.TUnion<TFromRest<Types, Func>> :
+    Exterior extends Types.TTuple<infer Types extends Types.TSchema[]> ? Types.TTuple<TFromRest<Types, Func>> :
+    Exterior extends Types.TArray<infer Type extends Types.TSchema> ? Types.TArray<TFromType<Type, Func>>:
+    Exterior extends Types.TAsyncIterator<infer Type extends Types.TSchema> ? Types.TAsyncIterator<TFromType<Type, Func>> :
+    Exterior extends Types.TIterator<infer Type extends Types.TSchema> ? Types.TIterator<TFromType<Type, Func>> :
+    Exterior extends Types.TPromise<infer Type extends Types.TSchema> ? Types.TPromise<TFromType<Type, Func>> :
+    Exterior extends Types.TObject<infer Properties extends Types.TProperties> ? Types.TObject<TFromProperties<Properties, Func>> :
+    Exterior extends Types.TRecord<infer Key extends Types.TSchema, infer Value extends Types.TSchema> ? Types.TRecordOrObject<TFromType<Key, Func>, TFromType<Value, Func>> :
+    Exterior
+  ),
+  // Modifiers Derived from Exterior Type Mapping
+  IsOptional extends number = Exterior extends Types.TOptional<Types.TSchema> ? 1 : 0,
+  IsReadonly extends number = Exterior extends Types.TReadonly<Types.TSchema> ? 1 : 0,
+  Result extends Types.TSchema = (
+    [IsReadonly, IsOptional]  extends [1, 1] ? Types.TReadonlyOptional<Interior> :
+    [IsReadonly, IsOptional]  extends [0, 1] ? Types.TOptional<Interior> :
+    [IsReadonly, IsOptional]  extends [1, 0] ? Types.TReadonly<Interior> :
+    Interior
+  ) 
+> = Result
+/** `[Prototype]` Applies a deep recursive map across the given type and sub types. */
+// prettier-ignore
+export function RecursiveMap(type: Types.TSchema, func: TMappingFunction): Types.TSchema {
+  // Maps the Exterior Type
+  const exterior = Types.CloneType(FromType(type, func), type)
+  // Maps the Interior Parameterized Types
+  const interior = (
+    Types.KindGuard.IsConstructor(type) ? Types.Constructor(FromRest(type.parameters, func), FromType(type.returns, func), exterior) :
+    Types.KindGuard.IsFunction(type) ? Types.Function(FromRest(type.parameters, func), FromType(type.returns, func), exterior) :
+    Types.KindGuard.IsIntersect(type) ? Types.Intersect(FromRest(type.allOf, func), exterior) :
+    Types.KindGuard.IsUnion(type) ? Types.Union(FromRest(type.anyOf, func), exterior) :
+    Types.KindGuard.IsTuple(type) ? Types.Tuple(FromRest(type.items || [], func), exterior) :
+    Types.KindGuard.IsArray(type) ? Types.Array(FromType(type.items, func), exterior) :
+    Types.KindGuard.IsAsyncIterator(type) ? Types.AsyncIterator(FromType(type.items, func), exterior) :
+    Types.KindGuard.IsIterator(type) ? Types.Iterator(FromType(type.items, func), exterior) :
+    Types.KindGuard.IsPromise(type) ? Types.Promise(FromType(type.items, func), exterior) :
+    Types.KindGuard.IsObject(type) ? Types.Object(FromProperties(type.properties, func), exterior) :
+    Types.KindGuard.IsRecord(type) ? Types.Record(FromType(GetRecordKey(type), func), FromType(GetRecordValue(type), func), exterior) :
+    Types.CloneType(exterior, exterior)
+  )
+  // Modifiers Derived from Exterior Type Mapping
+  const isOptional = Types.KindGuard.IsOptional(exterior)
+  const isReadonly = Types.KindGuard.IsOptional(exterior)
+  return (
+    isOptional && isReadonly ? Types.ReadonlyOptional(interior) :
+    isOptional ? Types.Optional(interior) :
+    isReadonly ? Types.Readonly(interior) :
+    interior
+  )
+}
+
+
+
diff --git a/example/standard/readme.md b/example/standard/readme.md
index 343d60616..6dc310269 100644
--- a/example/standard/readme.md
+++ b/example/standard/readme.md
@@ -1,60 +1,24 @@
 ### Standard Schema
 
-This example is a reference implementation of [Standard Schema](https://github.com/standard-schema/standard-schema) for TypeBox.
-
-### Overview
-
-This example provides a reference implementation for the Standard Schema specification. Despite the name, this specification is NOT focused on schematics. Rather, it defines a set of common TypeScript interfaces that libraries are expected to implement to be considered "Standard" for framework integration, as defined by the specification's authors.
-
-The TypeBox project has some concerns about the Standard Schema specification, particularly regarding its avoidance to separate concerns between schematics and the logic used to validate those schematics. TypeBox does respect such separation for direct interoperability with industry standard validators as well as to allow intermediate processing of types (Compile). Additionally, augmenting schematics in the way proposed by Standard Schema would render Json Schema invalidated (which is a general concern for interoperability with Json Schema validation infrastructure, such as Ajv).
-
-The Standard Schema specification is currently in its RFC stage. TypeBox advocates for renaming the specification to better reflect its purpose, such as "Common Interface for Type Integration." Additionally, the requirement for type libraries to adopt a common interface for integration warrants review. The reference project link provided below demonstrates an alternative approach that would enable integration of all type libraries (including those not immediately compatible with Standard Schema) to be integrated into frameworks (such as tRPC) without modification to a library's core structure.
-
-[Type Adapters](https://github.com/sinclairzx81/type-adapters)
+Reference implementation of [Standard Schema](https://github.com/standard-schema/standard-schema) for TypeBox.
 
 ### Example
 
-The Standard Schema function will augment TypeBox's Json Schema with runtime validation methods. These methods are assigned to the sub property `~standard`. Once a type is augmented, it should no longer be considered valid Json Schema.
+The following example augments a TypeBox schema with the required `~standard` interface. The `~standard` interface is applied via non-enumerable configuration enabling the schematics to continue to be used with strict compliant validators such as Ajv that would otherwise reject the non-standard `~standard` keyword.
 
 ```typescript
-import { Type } from '@sinclair/typebox'
 import { StandardSchema } from './standard'
+import { Type } from '@sinclair/typebox'
 
-// The Standard Schema function will augment a TypeBox type with runtime validation 
-// logic to validate / parse a value (as mandated by the Standard Schema interfaces). 
-// Calling this function will render the json-schema schematics invalidated, specifically
-// the non-standard keyword `~standard` which ideally should be expressed as a non
-// serializable symbol (Ajv strict)
-
-const A = StandardSchema(Type.Object({     // const A = {
-  x: Type.Number(),                        //   '~standard': { version: 1, vendor: 'TypeBox', validate: [Function: validate] },
-  y: Type.Number(),                        //   type: 'object',
-  z: Type.Number(),                        //   properties: {
-}))                                        //     x: { type: 'number', [Symbol(TypeBox.Kind)]: 'Number' },
-                                           //     y: { type: 'number', [Symbol(TypeBox.Kind)]: 'Number' },
-                                           //     z: { type: 'number', [Symbol(TypeBox.Kind)]: 'Number' }
+const T = StandardSchema(Type.Object({     // const A = {
+  x: Type.Number(),                        //   (non-enumerable) '~standard': { 
+  y: Type.Number(),                        //      version: 1, 
+  z: Type.Number(),                        //      vendor: 'TypeBox', 
+}))                                        //      validate: [Function: validate] 
                                            //   },
-                                           //   required: [ 'x', 'y', 'z' ],
-                                           //   [Symbol(TypeBox.Kind)]: 'Object'
-                                           // }
-
-const R = A['~standard'].validate({ x: 1, y: 2, z: 3 }) // const R = { value: { x: 1, y: 2, z: 3 }, issues: [] }
-```
-
-### Ajv Strict
-
-Applying Standard Schema to a TypeBox types renders them unusable in Ajv. The issue is due to the `~standard` property being un-assignable as a keyword (due to the leading `~`)
-
-```typescript
-import Ajv from 'ajv'
-
-const ajv = new Ajv().addKeyword('~standard') // cannot be defined as keyword.
-
-const A = StandardSchema(Type.Object({     // const A = {
-  x: Type.Number(),                        //   '~standard': { version: 1, vendor: 'TypeBox', validate: [Function: validate] },
-  y: Type.Number(),                        //   type: 'object',
-  z: Type.Number(),                        //   properties: {
-}))                                        //     x: { type: 'number', [Symbol(TypeBox.Kind)]: 'Number' },
+                                           //   type: 'object',
+                                           //   properties: {
+                                           //     x: { type: 'number', [Symbol(TypeBox.Kind)]: 'Number' },
                                            //     y: { type: 'number', [Symbol(TypeBox.Kind)]: 'Number' },
                                            //     z: { type: 'number', [Symbol(TypeBox.Kind)]: 'Number' }
                                            //   },
@@ -62,6 +26,8 @@ const A = StandardSchema(Type.Object({     // const A = {
                                            //   [Symbol(TypeBox.Kind)]: 'Object'
                                            // }
 
-
-ajv.validate(A, { x: 1, y: 2, z: 3 }) // Error: Keyword ~standard has invalid name
-```
+const R = T['~standard'].validate({ x: 1, y: 2, z: 3 }) // const R = { 
+                                                        //   value: { x: 1, y: 2, z: 3 }, 
+                                                        //   issues: [] 
+                                                        // }
+```
\ No newline at end of file
diff --git a/example/standard/standard.ts b/example/standard/standard.ts
index b61dcbba0..ef5ca384e 100644
--- a/example/standard/standard.ts
+++ b/example/standard/standard.ts
@@ -26,43 +26,60 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { AssertError, Value, ValueError } from '@sinclair/typebox/value'
+import { AssertError, Value, ValueError, ValueErrorType } from '@sinclair/typebox/value'
 import { TSchema, StaticDecode, CloneType } from '@sinclair/typebox'
 
 // ------------------------------------------------------------------
-// StandardSchema: Common
+// StandardSchema
 // ------------------------------------------------------------------
 interface StandardResult<Output> {
   value: Output
-  issues: [ValueError[]]
+  issues: ValueError[]
 }
 interface StandardSchema<Input = unknown, Output = Input> {
-  readonly "~standard": StandardSchemaProps<Input, Output>;
+  readonly "~standard": StandardSchemaProperties<Input, Output>
 }
-
-interface StandardSchemaProps<Input = unknown, Output = Input> {
-  readonly version: 1;
-  readonly vendor: 'TypeBox';
-  readonly validate: (value: unknown) => StandardResult<Output>;
-  readonly types?: undefined;
+interface StandardSchemaProperties<Input = unknown, Output = Input> {
+  readonly version: 1
+  readonly vendor: 'TypeBox'
+  readonly validate: (value: unknown) => StandardResult<Output>
+  readonly types?: undefined
 }
 // ------------------------------------------------------------------
-// StandardSchema: TypeBox
+// Issues
 // ------------------------------------------------------------------
-export type TStandardSchema<Input = unknown, Output = Input, Result = Input & StandardSchema<Input, Output>> = Result
-/** 
- * Augments a Json Schema with runtime validation logic required by StandardSchema. Wrapping a type in this way renders the type
- * incompatible with the Json Schema specification.
- */
-export function StandardSchema<Type extends TSchema>(schema: Type, references: TSchema[] = []): TStandardSchema<Type, StaticDecode<Type>> {
-  const validate = (value: unknown) => {
+// prettier-ignore
+function CreateIssues(schema: TSchema, value: unknown, error: unknown): ValueError[] {
+  const isAssertError = error instanceof AssertError ? error : undefined
+  return !isAssertError 
+    ? [{errors: [], message: 'Unknown error', path: '/', type: ValueErrorType.Kind, schema, value }]
+    : [...isAssertError.Errors()] 
+}
+// ------------------------------------------------------------------
+// Validate
+// ------------------------------------------------------------------
+// prettier-ignore
+function CreateValidator<Type extends TSchema>(schema: Type, references: TSchema[]): (value: unknown) => StandardResult<StaticDecode<Type>> {
+  return (value: unknown): StandardResult<StaticDecode<Type>> => {
     try {
-      return { value: Value.Parse(schema, references, value) }
+      return { value: Value.Parse(schema, references, value), issues: [] }
     } catch (error) {
-      const asserted = error instanceof AssertError ? error : undefined
-      return asserted ? { issues: [...asserted.Errors()] } : { issues: ['Unknown error']}
+      return { value: undefined, issues: CreateIssues(schema, value, error) }
     }
   }
-  const standard = { version: 1, vendor: 'TypeBox', validate }
-  return CloneType(schema, { ['~standard']: standard }) as never
+}
+// ------------------------------------------------------------------
+// StandardSchema
+// ------------------------------------------------------------------
+/** Augments a TypeBox type with the `~standard` validation interface. */
+export type TStandardSchema<Input = unknown, Output = Input> = (
+  Input & StandardSchema<Input, Output>
+)
+/** Augments a TypeBox type with the `~standard` validation interface. */
+export function StandardSchema<Type extends TSchema>(schema: Type, references: TSchema[] = []): TStandardSchema<Type, StaticDecode<Type>> {
+  const standard = { version: 1, vendor: 'TypeBox', validate: CreateValidator(schema, references) }
+  return Object.defineProperty(CloneType(schema), "~standard", { 
+    enumerable: false, 
+    value: standard 
+  }) as never
 }
\ No newline at end of file

From cc6471a0bc08baa02295c0c26a200efbde7c5fe3 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 16 Jan 2025 14:57:01 +0900
Subject: [PATCH 327/369] Annual License Update (#1138)

Updates the license year range to 2017-2025.
---
 example/annotation/annotation.ts                          | 2 +-
 example/collections/array.ts                              | 2 +-
 example/collections/index.ts                              | 2 +-
 example/collections/map.ts                                | 2 +-
 example/collections/set.ts                                | 2 +-
 example/formats/index.ts                                  | 2 +-
 example/prototypes/discriminated-union.ts                 | 2 +-
 example/prototypes/from-schema.ts                         | 2 +-
 example/prototypes/index.ts                               | 2 +-
 example/prototypes/options.ts                             | 2 +-
 example/prototypes/partial-deep.ts                        | 2 +-
 example/prototypes/recursive-map.ts                       | 2 +-
 example/prototypes/union-enum.ts                          | 2 +-
 example/prototypes/union-oneof.ts                         | 2 +-
 example/typedef/index.ts                                  | 2 +-
 example/typedef/typedef.ts                                | 2 +-
 license                                                   | 2 +-
 src/compiler/compiler.ts                                  | 2 +-
 src/compiler/index.ts                                     | 2 +-
 src/errors/errors.ts                                      | 2 +-
 src/errors/function.ts                                    | 2 +-
 src/errors/index.ts                                       | 2 +-
 src/index.ts                                              | 2 +-
 src/syntax/index.ts                                       | 2 +-
 src/syntax/parse.ts                                       | 2 +-
 src/syntax/runtime.ts                                     | 2 +-
 src/syntax/static.ts                                      | 2 +-
 src/system/index.ts                                       | 2 +-
 src/system/policy.ts                                      | 2 +-
 src/system/system.ts                                      | 2 +-
 src/type/any/any.ts                                       | 2 +-
 src/type/any/index.ts                                     | 2 +-
 src/type/array/array.ts                                   | 2 +-
 src/type/array/index.ts                                   | 2 +-
 src/type/async-iterator/async-iterator.ts                 | 2 +-
 src/type/async-iterator/index.ts                          | 2 +-
 src/type/awaited/awaited.ts                               | 2 +-
 src/type/awaited/index.ts                                 | 2 +-
 src/type/bigint/bigint.ts                                 | 2 +-
 src/type/bigint/index.ts                                  | 2 +-
 src/type/boolean/boolean.ts                               | 2 +-
 src/type/boolean/index.ts                                 | 2 +-
 src/type/clone/index.ts                                   | 2 +-
 src/type/clone/type.ts                                    | 2 +-
 src/type/clone/value.ts                                   | 2 +-
 src/type/composite/composite.ts                           | 2 +-
 src/type/composite/index.ts                               | 2 +-
 src/type/computed/computed.ts                             | 2 +-
 src/type/computed/index.ts                                | 2 +-
 src/type/const/const.ts                                   | 2 +-
 src/type/const/index.ts                                   | 2 +-
 src/type/constructor-parameters/constructor-parameters.ts | 2 +-
 src/type/constructor-parameters/index.ts                  | 2 +-
 src/type/constructor/constructor.ts                       | 2 +-
 src/type/constructor/index.ts                             | 2 +-
 src/type/create/immutable.ts                              | 2 +-
 src/type/create/index.ts                                  | 2 +-
 src/type/create/type.ts                                   | 2 +-
 src/type/date/date.ts                                     | 2 +-
 src/type/date/index.ts                                    | 2 +-
 src/type/discard/discard.ts                               | 2 +-
 src/type/discard/index.ts                                 | 2 +-
 src/type/enum/enum.ts                                     | 2 +-
 src/type/enum/index.ts                                    | 2 +-
 src/type/error/error.ts                                   | 2 +-
 src/type/error/index.ts                                   | 2 +-
 src/type/exclude/exclude-from-mapped-result.ts            | 2 +-
 src/type/exclude/exclude-from-template-literal.ts         | 2 +-
 src/type/exclude/exclude.ts                               | 2 +-
 src/type/exclude/index.ts                                 | 2 +-
 src/type/extends/extends-check.ts                         | 2 +-
 src/type/extends/extends-from-mapped-key.ts               | 2 +-
 src/type/extends/extends-from-mapped-result.ts            | 2 +-
 src/type/extends/extends-undefined.ts                     | 2 +-
 src/type/extends/extends.ts                               | 2 +-
 src/type/extends/index.ts                                 | 2 +-
 src/type/extract/extract-from-mapped-result.ts            | 2 +-
 src/type/extract/extract-from-template-literal.ts         | 2 +-
 src/type/extract/extract.ts                               | 2 +-
 src/type/extract/index.ts                                 | 2 +-
 src/type/function/function.ts                             | 2 +-
 src/type/function/index.ts                                | 2 +-
 src/type/guard/index.ts                                   | 2 +-
 src/type/guard/kind.ts                                    | 2 +-
 src/type/guard/type.ts                                    | 2 +-
 src/type/guard/value.ts                                   | 2 +-
 src/type/helpers/helpers.ts                               | 2 +-
 src/type/helpers/index.ts                                 | 2 +-
 src/type/index.ts                                         | 2 +-
 src/type/indexed/index.ts                                 | 2 +-
 src/type/indexed/indexed-from-mapped-key.ts               | 2 +-
 src/type/indexed/indexed-from-mapped-result.ts            | 2 +-
 src/type/indexed/indexed-property-keys.ts                 | 2 +-
 src/type/indexed/indexed.ts                               | 2 +-
 src/type/instance-type/index.ts                           | 2 +-
 src/type/instance-type/instance-type.ts                   | 2 +-
 src/type/integer/index.ts                                 | 2 +-
 src/type/integer/integer.ts                               | 2 +-
 src/type/intersect/index.ts                               | 2 +-
 src/type/intersect/intersect-create.ts                    | 2 +-
 src/type/intersect/intersect-evaluated.ts                 | 2 +-
 src/type/intersect/intersect-type.ts                      | 2 +-
 src/type/intersect/intersect.ts                           | 2 +-
 src/type/intrinsic/capitalize.ts                          | 2 +-
 src/type/intrinsic/index.ts                               | 2 +-
 src/type/intrinsic/intrinsic-from-mapped-key.ts           | 2 +-
 src/type/intrinsic/intrinsic.ts                           | 2 +-
 src/type/intrinsic/lowercase.ts                           | 2 +-
 src/type/intrinsic/uncapitalize.ts                        | 2 +-
 src/type/intrinsic/uppercase.ts                           | 2 +-
 src/type/iterator/index.ts                                | 2 +-
 src/type/iterator/iterator.ts                             | 2 +-
 src/type/keyof/index.ts                                   | 2 +-
 src/type/keyof/keyof-from-mapped-result.ts                | 2 +-
 src/type/keyof/keyof-property-entries.ts                  | 2 +-
 src/type/keyof/keyof-property-keys.ts                     | 2 +-
 src/type/keyof/keyof.ts                                   | 2 +-
 src/type/literal/index.ts                                 | 2 +-
 src/type/literal/literal.ts                               | 2 +-
 src/type/mapped/index.ts                                  | 2 +-
 src/type/mapped/mapped-key.ts                             | 2 +-
 src/type/mapped/mapped-result.ts                          | 2 +-
 src/type/mapped/mapped.ts                                 | 2 +-
 src/type/module/compute.ts                                | 2 +-
 src/type/module/index.ts                                  | 2 +-
 src/type/module/infer.ts                                  | 2 +-
 src/type/module/module.ts                                 | 2 +-
 src/type/never/index.ts                                   | 2 +-
 src/type/never/never.ts                                   | 2 +-
 src/type/not/index.ts                                     | 2 +-
 src/type/not/not.ts                                       | 2 +-
 src/type/null/index.ts                                    | 2 +-
 src/type/null/null.ts                                     | 2 +-
 src/type/number/index.ts                                  | 2 +-
 src/type/number/number.ts                                 | 2 +-
 src/type/object/index.ts                                  | 2 +-
 src/type/object/object.ts                                 | 2 +-
 src/type/omit/index.ts                                    | 2 +-
 src/type/omit/omit-from-mapped-key.ts                     | 2 +-
 src/type/omit/omit-from-mapped-result.ts                  | 2 +-
 src/type/omit/omit.ts                                     | 2 +-
 src/type/optional/index.ts                                | 2 +-
 src/type/optional/optional-from-mapped-result.ts          | 2 +-
 src/type/optional/optional.ts                             | 2 +-
 src/type/parameters/index.ts                              | 2 +-
 src/type/parameters/parameters.ts                         | 2 +-
 src/type/partial/index.ts                                 | 2 +-
 src/type/partial/partial-from-mapped-result.ts            | 2 +-
 src/type/partial/partial.ts                               | 2 +-
 src/type/patterns/index.ts                                | 2 +-
 src/type/patterns/patterns.ts                             | 2 +-
 src/type/pick/index.ts                                    | 2 +-
 src/type/pick/pick-from-mapped-key.ts                     | 2 +-
 src/type/pick/pick-from-mapped-result.ts                  | 2 +-
 src/type/pick/pick.ts                                     | 2 +-
 src/type/promise/index.ts                                 | 2 +-
 src/type/promise/promise.ts                               | 2 +-
 src/type/readonly-optional/index.ts                       | 2 +-
 src/type/readonly-optional/readonly-optional.ts           | 2 +-
 src/type/readonly/index.ts                                | 2 +-
 src/type/readonly/readonly-from-mapped-result.ts          | 2 +-
 src/type/readonly/readonly.ts                             | 2 +-
 src/type/record/index.ts                                  | 2 +-
 src/type/record/record.ts                                 | 2 +-
 src/type/recursive/index.ts                               | 2 +-
 src/type/recursive/recursive.ts                           | 2 +-
 src/type/ref/index.ts                                     | 2 +-
 src/type/ref/ref.ts                                       | 2 +-
 src/type/regexp/index.ts                                  | 2 +-
 src/type/regexp/regexp.ts                                 | 2 +-
 src/type/registry/format.ts                               | 2 +-
 src/type/registry/index.ts                                | 2 +-
 src/type/registry/type.ts                                 | 2 +-
 src/type/required/index.ts                                | 2 +-
 src/type/required/required-from-mapped-result.ts          | 2 +-
 src/type/required/required.ts                             | 2 +-
 src/type/rest/index.ts                                    | 2 +-
 src/type/rest/rest.ts                                     | 2 +-
 src/type/return-type/index.ts                             | 2 +-
 src/type/return-type/return-type.ts                       | 2 +-
 src/type/schema/anyschema.ts                              | 2 +-
 src/type/schema/index.ts                                  | 2 +-
 src/type/schema/schema.ts                                 | 2 +-
 src/type/sets/index.ts                                    | 2 +-
 src/type/sets/set.ts                                      | 2 +-
 src/type/static/index.ts                                  | 2 +-
 src/type/static/static.ts                                 | 2 +-
 src/type/string/index.ts                                  | 2 +-
 src/type/string/string.ts                                 | 2 +-
 src/type/symbol/index.ts                                  | 2 +-
 src/type/symbol/symbol.ts                                 | 2 +-
 src/type/symbols/index.ts                                 | 2 +-
 src/type/symbols/symbols.ts                               | 2 +-
 src/type/template-literal/finite.ts                       | 2 +-
 src/type/template-literal/generate.ts                     | 2 +-
 src/type/template-literal/index.ts                        | 2 +-
 src/type/template-literal/parse.ts                        | 2 +-
 src/type/template-literal/pattern.ts                      | 2 +-
 src/type/template-literal/syntax.ts                       | 2 +-
 src/type/template-literal/template-literal.ts             | 2 +-
 src/type/template-literal/union.ts                        | 2 +-
 src/type/transform/index.ts                               | 2 +-
 src/type/transform/transform.ts                           | 2 +-
 src/type/tuple/index.ts                                   | 2 +-
 src/type/tuple/tuple.ts                                   | 2 +-
 src/type/type/index.ts                                    | 2 +-
 src/type/type/javascript.ts                               | 2 +-
 src/type/type/json.ts                                     | 2 +-
 src/type/type/type.ts                                     | 2 +-
 src/type/uint8array/index.ts                              | 2 +-
 src/type/uint8array/uint8array.ts                         | 2 +-
 src/type/undefined/index.ts                               | 2 +-
 src/type/undefined/undefined.ts                           | 2 +-
 src/type/union/index.ts                                   | 2 +-
 src/type/union/union-create.ts                            | 2 +-
 src/type/union/union-evaluated.ts                         | 2 +-
 src/type/union/union-type.ts                              | 2 +-
 src/type/union/union.ts                                   | 2 +-
 src/type/unknown/index.ts                                 | 2 +-
 src/type/unknown/unknown.ts                               | 2 +-
 src/type/unsafe/index.ts                                  | 2 +-
 src/type/unsafe/unsafe.ts                                 | 2 +-
 src/type/void/index.ts                                    | 2 +-
 src/type/void/void.ts                                     | 2 +-
 src/value/assert/assert.ts                                | 2 +-
 src/value/assert/index.ts                                 | 2 +-
 src/value/cast/cast.ts                                    | 2 +-
 src/value/cast/index.ts                                   | 2 +-
 src/value/check/check.ts                                  | 2 +-
 src/value/check/index.ts                                  | 2 +-
 src/value/clean/clean.ts                                  | 2 +-
 src/value/clean/index.ts                                  | 2 +-
 src/value/clone/clone.ts                                  | 2 +-
 src/value/clone/index.ts                                  | 2 +-
 src/value/convert/convert.ts                              | 2 +-
 src/value/convert/index.ts                                | 2 +-
 src/value/create/create.ts                                | 2 +-
 src/value/create/index.ts                                 | 2 +-
 src/value/decode/decode.ts                                | 2 +-
 src/value/decode/index.ts                                 | 2 +-
 src/value/default/default.ts                              | 2 +-
 src/value/default/index.ts                                | 2 +-
 src/value/delta/delta.ts                                  | 2 +-
 src/value/delta/index.ts                                  | 2 +-
 src/value/deref/deref.ts                                  | 2 +-
 src/value/deref/index.ts                                  | 2 +-
 src/value/encode/encode.ts                                | 2 +-
 src/value/encode/index.ts                                 | 2 +-
 src/value/equal/equal.ts                                  | 2 +-
 src/value/equal/index.ts                                  | 2 +-
 src/value/guard/guard.ts                                  | 2 +-
 src/value/guard/index.ts                                  | 2 +-
 src/value/hash/hash.ts                                    | 2 +-
 src/value/hash/index.ts                                   | 2 +-
 src/value/index.ts                                        | 2 +-
 src/value/mutate/index.ts                                 | 2 +-
 src/value/mutate/mutate.ts                                | 2 +-
 src/value/parse/index.ts                                  | 2 +-
 src/value/parse/parse.ts                                  | 2 +-
 src/value/pointer/index.ts                                | 2 +-
 src/value/pointer/pointer.ts                              | 2 +-
 src/value/transform/decode.ts                             | 2 +-
 src/value/transform/encode.ts                             | 2 +-
 src/value/transform/has.ts                                | 2 +-
 src/value/transform/index.ts                              | 2 +-
 src/value/value/index.ts                                  | 2 +-
 src/value/value/value.ts                                  | 2 +-
 task/build/cjs/build.ts                                   | 2 +-
 task/build/cjs/compile.ts                                 | 2 +-
 task/build/esm/build.ts                                   | 2 +-
 task/build/esm/compile.ts                                 | 2 +-
 task/build/esm/convert-to-esm.ts                          | 2 +-
 task/build/index.ts                                       | 2 +-
 task/build/notices/remove-notices.ts                      | 2 +-
 task/build/package/build.ts                               | 2 +-
 task/build/package/create-package-json-redirect.ts        | 2 +-
 task/build/package/create-package-json.ts                 | 2 +-
 277 files changed, 277 insertions(+), 277 deletions(-)

diff --git a/example/annotation/annotation.ts b/example/annotation/annotation.ts
index 9e38f70b6..90b8f7a20 100644
--- a/example/annotation/annotation.ts
+++ b/example/annotation/annotation.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/collections/array.ts b/example/collections/array.ts
index be13f9284..0549cda89 100644
--- a/example/collections/array.ts
+++ b/example/collections/array.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/collections/index.ts b/example/collections/index.ts
index 6069c8c37..a5187f8b5 100644
--- a/example/collections/index.ts
+++ b/example/collections/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/collections/map.ts b/example/collections/map.ts
index 47957795b..ac5174f88 100644
--- a/example/collections/map.ts
+++ b/example/collections/map.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/collections/set.ts b/example/collections/set.ts
index 730583ae3..70f44bb91 100644
--- a/example/collections/set.ts
+++ b/example/collections/set.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/formats/index.ts b/example/formats/index.ts
index 2ac3f6f51..cd002284d 100644
--- a/example/formats/index.ts
+++ b/example/formats/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/prototypes/discriminated-union.ts b/example/prototypes/discriminated-union.ts
index 22da0f486..8aae1f3f2 100644
--- a/example/prototypes/discriminated-union.ts
+++ b/example/prototypes/discriminated-union.ts
@@ -5,7 +5,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/prototypes/from-schema.ts b/example/prototypes/from-schema.ts
index 94a4716b2..f44c36735 100644
--- a/example/prototypes/from-schema.ts
+++ b/example/prototypes/from-schema.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/prototypes/index.ts b/example/prototypes/index.ts
index dd5f572ee..e7119a8aa 100644
--- a/example/prototypes/index.ts
+++ b/example/prototypes/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/prototypes/options.ts b/example/prototypes/options.ts
index 0270acbb7..bf09281ad 100644
--- a/example/prototypes/options.ts
+++ b/example/prototypes/options.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/prototypes/partial-deep.ts b/example/prototypes/partial-deep.ts
index 5fc707f80..8637b52dc 100644
--- a/example/prototypes/partial-deep.ts
+++ b/example/prototypes/partial-deep.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/prototypes/recursive-map.ts b/example/prototypes/recursive-map.ts
index 0443bed91..dfa35b004 100644
--- a/example/prototypes/recursive-map.ts
+++ b/example/prototypes/recursive-map.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/prototypes/union-enum.ts b/example/prototypes/union-enum.ts
index 91c768c52..ee15f15a4 100644
--- a/example/prototypes/union-enum.ts
+++ b/example/prototypes/union-enum.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/prototypes/union-oneof.ts b/example/prototypes/union-oneof.ts
index 818d3e457..ec14fac94 100644
--- a/example/prototypes/union-oneof.ts
+++ b/example/prototypes/union-oneof.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/typedef/index.ts b/example/typedef/index.ts
index a23b035fe..daac6020a 100644
--- a/example/typedef/index.ts
+++ b/example/typedef/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/example/typedef/typedef.ts b/example/typedef/typedef.ts
index 6682e5e38..f0b74da5f 100644
--- a/example/typedef/typedef.ts
+++ b/example/typedef/typedef.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/license b/license
index 7c58af806..5737c52ed 100644
--- a/license
+++ b/license
@@ -4,7 +4,7 @@ Json Schema Type Builder with Static Type Resolution for TypeScript
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 5edf8fd7b..706667ee7 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/compiler/index.ts b/src/compiler/index.ts
index d1a93e868..4bdcefef7 100644
--- a/src/compiler/index.ts
+++ b/src/compiler/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 9bb1f6cd1..de62cd970 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/errors/function.ts b/src/errors/function.ts
index 536f3e682..39ac67220 100644
--- a/src/errors/function.ts
+++ b/src/errors/function.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/errors/index.ts b/src/errors/index.ts
index 288d17757..4c499cc76 100644
--- a/src/errors/index.ts
+++ b/src/errors/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/index.ts b/src/index.ts
index 90525bd71..f17cc7d15 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/syntax/index.ts b/src/syntax/index.ts
index ae2cee724..8a2445bfb 100644
--- a/src/syntax/index.ts
+++ b/src/syntax/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/syntax/parse.ts b/src/syntax/parse.ts
index 1ec0d41fd..d58922e7b 100644
--- a/src/syntax/parse.ts
+++ b/src/syntax/parse.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/syntax/runtime.ts b/src/syntax/runtime.ts
index 82db79005..2f5801f20 100644
--- a/src/syntax/runtime.ts
+++ b/src/syntax/runtime.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/syntax/static.ts b/src/syntax/static.ts
index ddd48ea76..9d8bb0a38 100644
--- a/src/syntax/static.ts
+++ b/src/syntax/static.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/system/index.ts b/src/system/index.ts
index 70c91ccf2..b9a805ba6 100644
--- a/src/system/index.ts
+++ b/src/system/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/system/policy.ts b/src/system/policy.ts
index 8501462c5..88eb012c8 100644
--- a/src/system/policy.ts
+++ b/src/system/policy.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/system/system.ts b/src/system/system.ts
index 98b3647c6..b11de693d 100644
--- a/src/system/system.ts
+++ b/src/system/system.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/any/any.ts b/src/type/any/any.ts
index f5d7d907c..8adc89cca 100644
--- a/src/type/any/any.ts
+++ b/src/type/any/any.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/any/index.ts b/src/type/any/index.ts
index fe7f59848..400a3ef5c 100644
--- a/src/type/any/index.ts
+++ b/src/type/any/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/array/array.ts b/src/type/array/array.ts
index dc29a1858..bab2d7704 100644
--- a/src/type/array/array.ts
+++ b/src/type/array/array.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/array/index.ts b/src/type/array/index.ts
index d19c2e2be..46e91d8a2 100644
--- a/src/type/array/index.ts
+++ b/src/type/array/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/async-iterator/async-iterator.ts b/src/type/async-iterator/async-iterator.ts
index 2a97d73a0..7a885fc77 100644
--- a/src/type/async-iterator/async-iterator.ts
+++ b/src/type/async-iterator/async-iterator.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/async-iterator/index.ts b/src/type/async-iterator/index.ts
index 9a61d47dc..6a0c51edf 100644
--- a/src/type/async-iterator/index.ts
+++ b/src/type/async-iterator/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/awaited/awaited.ts b/src/type/awaited/awaited.ts
index 1a849f14e..37a84cad5 100644
--- a/src/type/awaited/awaited.ts
+++ b/src/type/awaited/awaited.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/awaited/index.ts b/src/type/awaited/index.ts
index 186c08da5..6d753bb9c 100644
--- a/src/type/awaited/index.ts
+++ b/src/type/awaited/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/bigint/bigint.ts b/src/type/bigint/bigint.ts
index e98491b2a..ad0af34c9 100644
--- a/src/type/bigint/bigint.ts
+++ b/src/type/bigint/bigint.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/bigint/index.ts b/src/type/bigint/index.ts
index 8d4c4b5d6..fca1fe8e8 100644
--- a/src/type/bigint/index.ts
+++ b/src/type/bigint/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/boolean/boolean.ts b/src/type/boolean/boolean.ts
index acbf44207..2e582ef08 100644
--- a/src/type/boolean/boolean.ts
+++ b/src/type/boolean/boolean.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/boolean/index.ts b/src/type/boolean/index.ts
index 4de112e06..d8620d4d7 100644
--- a/src/type/boolean/index.ts
+++ b/src/type/boolean/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/clone/index.ts b/src/type/clone/index.ts
index ee3c7bfec..c4df1782d 100644
--- a/src/type/clone/index.ts
+++ b/src/type/clone/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/clone/type.ts b/src/type/clone/type.ts
index 18a10f3ec..8cb09431b 100644
--- a/src/type/clone/type.ts
+++ b/src/type/clone/type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/clone/value.ts b/src/type/clone/value.ts
index 0a062cb38..a20ff5f1e 100644
--- a/src/type/clone/value.ts
+++ b/src/type/clone/value.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/composite/composite.ts b/src/type/composite/composite.ts
index 26b4406b5..8b9833399 100644
--- a/src/type/composite/composite.ts
+++ b/src/type/composite/composite.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/composite/index.ts b/src/type/composite/index.ts
index 141f3e337..55de8e6ec 100644
--- a/src/type/composite/index.ts
+++ b/src/type/composite/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/computed/computed.ts b/src/type/computed/computed.ts
index 2524dc152..bc8cfcb79 100644
--- a/src/type/computed/computed.ts
+++ b/src/type/computed/computed.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/computed/index.ts b/src/type/computed/index.ts
index 4d20b1f87..6c75b7205 100644
--- a/src/type/computed/index.ts
+++ b/src/type/computed/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/const/const.ts b/src/type/const/const.ts
index fcaa788a3..91e3df4f1 100644
--- a/src/type/const/const.ts
+++ b/src/type/const/const.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/const/index.ts b/src/type/const/index.ts
index 90b0ba9ca..2d24ed90f 100644
--- a/src/type/const/index.ts
+++ b/src/type/const/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/constructor-parameters/constructor-parameters.ts b/src/type/constructor-parameters/constructor-parameters.ts
index 3ce3e0034..b15718f1d 100644
--- a/src/type/constructor-parameters/constructor-parameters.ts
+++ b/src/type/constructor-parameters/constructor-parameters.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/constructor-parameters/index.ts b/src/type/constructor-parameters/index.ts
index dbc9c6c0a..f5898f6b5 100644
--- a/src/type/constructor-parameters/index.ts
+++ b/src/type/constructor-parameters/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/constructor/constructor.ts b/src/type/constructor/constructor.ts
index 6904b8541..31539fbf0 100644
--- a/src/type/constructor/constructor.ts
+++ b/src/type/constructor/constructor.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/constructor/index.ts b/src/type/constructor/index.ts
index 3269a4e78..1f5b0684e 100644
--- a/src/type/constructor/index.ts
+++ b/src/type/constructor/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/create/immutable.ts b/src/type/create/immutable.ts
index d2069efe7..b4041b94c 100644
--- a/src/type/create/immutable.ts
+++ b/src/type/create/immutable.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/create/index.ts b/src/type/create/index.ts
index 53780a6ef..ea69721de 100644
--- a/src/type/create/index.ts
+++ b/src/type/create/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/create/type.ts b/src/type/create/type.ts
index cb8371abd..253231d35 100644
--- a/src/type/create/type.ts
+++ b/src/type/create/type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/date/date.ts b/src/type/date/date.ts
index 44b9d0d3d..040e64e8e 100644
--- a/src/type/date/date.ts
+++ b/src/type/date/date.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/date/index.ts b/src/type/date/index.ts
index d73b06d48..6aff28867 100644
--- a/src/type/date/index.ts
+++ b/src/type/date/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/discard/discard.ts b/src/type/discard/discard.ts
index cf1688ddd..821f9b40c 100644
--- a/src/type/discard/discard.ts
+++ b/src/type/discard/discard.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/discard/index.ts b/src/type/discard/index.ts
index 54c7051b2..0e9830749 100644
--- a/src/type/discard/index.ts
+++ b/src/type/discard/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/enum/enum.ts b/src/type/enum/enum.ts
index 1cd8a5867..87f88e22c 100644
--- a/src/type/enum/enum.ts
+++ b/src/type/enum/enum.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/enum/index.ts b/src/type/enum/index.ts
index a77209132..8ad69431d 100644
--- a/src/type/enum/index.ts
+++ b/src/type/enum/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/error/error.ts b/src/type/error/error.ts
index f72140b3d..443a56338 100644
--- a/src/type/error/error.ts
+++ b/src/type/error/error.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/error/index.ts b/src/type/error/index.ts
index 4cf885dad..2e03c77bd 100644
--- a/src/type/error/index.ts
+++ b/src/type/error/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/exclude/exclude-from-mapped-result.ts b/src/type/exclude/exclude-from-mapped-result.ts
index 8985e467e..ab8fef55a 100644
--- a/src/type/exclude/exclude-from-mapped-result.ts
+++ b/src/type/exclude/exclude-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/exclude/exclude-from-template-literal.ts b/src/type/exclude/exclude-from-template-literal.ts
index 707a6c254..a80f10a2f 100644
--- a/src/type/exclude/exclude-from-template-literal.ts
+++ b/src/type/exclude/exclude-from-template-literal.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/exclude/exclude.ts b/src/type/exclude/exclude.ts
index daee3ea1f..663cf73bc 100644
--- a/src/type/exclude/exclude.ts
+++ b/src/type/exclude/exclude.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/exclude/index.ts b/src/type/exclude/index.ts
index 610ff43a2..5e725fb54 100644
--- a/src/type/exclude/index.ts
+++ b/src/type/exclude/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extends/extends-check.ts b/src/type/extends/extends-check.ts
index dc461eff4..e78bbc318 100644
--- a/src/type/extends/extends-check.ts
+++ b/src/type/extends/extends-check.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extends/extends-from-mapped-key.ts b/src/type/extends/extends-from-mapped-key.ts
index 506ebc854..697a2d37f 100644
--- a/src/type/extends/extends-from-mapped-key.ts
+++ b/src/type/extends/extends-from-mapped-key.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extends/extends-from-mapped-result.ts b/src/type/extends/extends-from-mapped-result.ts
index 02a1dc84b..a7f4fb40b 100644
--- a/src/type/extends/extends-from-mapped-result.ts
+++ b/src/type/extends/extends-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extends/extends-undefined.ts b/src/type/extends/extends-undefined.ts
index 23c51776d..4d6f41cd9 100644
--- a/src/type/extends/extends-undefined.ts
+++ b/src/type/extends/extends-undefined.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extends/extends.ts b/src/type/extends/extends.ts
index 9048d1eab..ae9d264a7 100644
--- a/src/type/extends/extends.ts
+++ b/src/type/extends/extends.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extends/index.ts b/src/type/extends/index.ts
index aa0bc3d6c..1a8957763 100644
--- a/src/type/extends/index.ts
+++ b/src/type/extends/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extract/extract-from-mapped-result.ts b/src/type/extract/extract-from-mapped-result.ts
index b49720a37..640ee37dd 100644
--- a/src/type/extract/extract-from-mapped-result.ts
+++ b/src/type/extract/extract-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extract/extract-from-template-literal.ts b/src/type/extract/extract-from-template-literal.ts
index 82cc52dd9..e3e9f8024 100644
--- a/src/type/extract/extract-from-template-literal.ts
+++ b/src/type/extract/extract-from-template-literal.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extract/extract.ts b/src/type/extract/extract.ts
index 8c94045b2..aaed115ee 100644
--- a/src/type/extract/extract.ts
+++ b/src/type/extract/extract.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/extract/index.ts b/src/type/extract/index.ts
index 38bc0a813..c8f052d88 100644
--- a/src/type/extract/index.ts
+++ b/src/type/extract/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/function/function.ts b/src/type/function/function.ts
index 150fc7338..6feffaed4 100644
--- a/src/type/function/function.ts
+++ b/src/type/function/function.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/function/index.ts b/src/type/function/index.ts
index 21b4ad556..948381971 100644
--- a/src/type/function/index.ts
+++ b/src/type/function/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/guard/index.ts b/src/type/guard/index.ts
index feeaa6296..9745d55cd 100644
--- a/src/type/guard/index.ts
+++ b/src/type/guard/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/guard/kind.ts b/src/type/guard/kind.ts
index ed3f68f2f..9ca359fdb 100644
--- a/src/type/guard/kind.ts
+++ b/src/type/guard/kind.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/guard/type.ts b/src/type/guard/type.ts
index ebd4b8f8f..521522ffd 100644
--- a/src/type/guard/type.ts
+++ b/src/type/guard/type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/guard/value.ts b/src/type/guard/value.ts
index 4e4f9d1e2..93ae57fe8 100644
--- a/src/type/guard/value.ts
+++ b/src/type/guard/value.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/helpers/helpers.ts b/src/type/helpers/helpers.ts
index 1ab44dc30..a3cb86466 100644
--- a/src/type/helpers/helpers.ts
+++ b/src/type/helpers/helpers.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/helpers/index.ts b/src/type/helpers/index.ts
index 8e6b80464..31d3e5185 100644
--- a/src/type/helpers/index.ts
+++ b/src/type/helpers/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/index.ts b/src/type/index.ts
index d9d5d5076..661e36678 100644
--- a/src/type/index.ts
+++ b/src/type/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/indexed/index.ts b/src/type/indexed/index.ts
index ed02a2814..b13a8c9b5 100644
--- a/src/type/indexed/index.ts
+++ b/src/type/indexed/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/indexed/indexed-from-mapped-key.ts b/src/type/indexed/indexed-from-mapped-key.ts
index a523032f8..ae99317eb 100644
--- a/src/type/indexed/indexed-from-mapped-key.ts
+++ b/src/type/indexed/indexed-from-mapped-key.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/indexed/indexed-from-mapped-result.ts b/src/type/indexed/indexed-from-mapped-result.ts
index 200493649..b5b3d67ca 100644
--- a/src/type/indexed/indexed-from-mapped-result.ts
+++ b/src/type/indexed/indexed-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/indexed/indexed-property-keys.ts b/src/type/indexed/indexed-property-keys.ts
index d5f2e7315..e04866414 100644
--- a/src/type/indexed/indexed-property-keys.ts
+++ b/src/type/indexed/indexed-property-keys.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/indexed/indexed.ts b/src/type/indexed/indexed.ts
index 541c6e734..1e6603bf5 100644
--- a/src/type/indexed/indexed.ts
+++ b/src/type/indexed/indexed.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/instance-type/index.ts b/src/type/instance-type/index.ts
index a16ba2e50..35a3a954d 100644
--- a/src/type/instance-type/index.ts
+++ b/src/type/instance-type/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/instance-type/instance-type.ts b/src/type/instance-type/instance-type.ts
index 853c8da61..ece1382c9 100644
--- a/src/type/instance-type/instance-type.ts
+++ b/src/type/instance-type/instance-type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/integer/index.ts b/src/type/integer/index.ts
index 82c3e2cce..8c78b4721 100644
--- a/src/type/integer/index.ts
+++ b/src/type/integer/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/integer/integer.ts b/src/type/integer/integer.ts
index 8b15618d3..245037e1e 100644
--- a/src/type/integer/integer.ts
+++ b/src/type/integer/integer.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intersect/index.ts b/src/type/intersect/index.ts
index e9ec6eaea..67a0a8911 100644
--- a/src/type/intersect/index.ts
+++ b/src/type/intersect/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intersect/intersect-create.ts b/src/type/intersect/intersect-create.ts
index 6b38ce830..59f6cf64e 100644
--- a/src/type/intersect/intersect-create.ts
+++ b/src/type/intersect/intersect-create.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intersect/intersect-evaluated.ts b/src/type/intersect/intersect-evaluated.ts
index 637009345..2ac4a3c0d 100644
--- a/src/type/intersect/intersect-evaluated.ts
+++ b/src/type/intersect/intersect-evaluated.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intersect/intersect-type.ts b/src/type/intersect/intersect-type.ts
index 1b1f6a5de..80b2c25e5 100644
--- a/src/type/intersect/intersect-type.ts
+++ b/src/type/intersect/intersect-type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intersect/intersect.ts b/src/type/intersect/intersect.ts
index 999d3d2af..63dd76b09 100644
--- a/src/type/intersect/intersect.ts
+++ b/src/type/intersect/intersect.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intrinsic/capitalize.ts b/src/type/intrinsic/capitalize.ts
index 48acdc23d..51309eac6 100644
--- a/src/type/intrinsic/capitalize.ts
+++ b/src/type/intrinsic/capitalize.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intrinsic/index.ts b/src/type/intrinsic/index.ts
index 8a67cea42..c55fa12d6 100644
--- a/src/type/intrinsic/index.ts
+++ b/src/type/intrinsic/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intrinsic/intrinsic-from-mapped-key.ts b/src/type/intrinsic/intrinsic-from-mapped-key.ts
index 16afb241e..80c873451 100644
--- a/src/type/intrinsic/intrinsic-from-mapped-key.ts
+++ b/src/type/intrinsic/intrinsic-from-mapped-key.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intrinsic/intrinsic.ts b/src/type/intrinsic/intrinsic.ts
index bbb139be6..aca5d386c 100644
--- a/src/type/intrinsic/intrinsic.ts
+++ b/src/type/intrinsic/intrinsic.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intrinsic/lowercase.ts b/src/type/intrinsic/lowercase.ts
index 745c4ff22..6837496f8 100644
--- a/src/type/intrinsic/lowercase.ts
+++ b/src/type/intrinsic/lowercase.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intrinsic/uncapitalize.ts b/src/type/intrinsic/uncapitalize.ts
index 3024f9672..c9af91f12 100644
--- a/src/type/intrinsic/uncapitalize.ts
+++ b/src/type/intrinsic/uncapitalize.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/intrinsic/uppercase.ts b/src/type/intrinsic/uppercase.ts
index bde519cc6..34eb578bc 100644
--- a/src/type/intrinsic/uppercase.ts
+++ b/src/type/intrinsic/uppercase.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/iterator/index.ts b/src/type/iterator/index.ts
index 1a6c6fd01..03694ff57 100644
--- a/src/type/iterator/index.ts
+++ b/src/type/iterator/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/iterator/iterator.ts b/src/type/iterator/iterator.ts
index da528a8ae..f2d5fd99f 100644
--- a/src/type/iterator/iterator.ts
+++ b/src/type/iterator/iterator.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/keyof/index.ts b/src/type/keyof/index.ts
index 67512251b..8480f6853 100644
--- a/src/type/keyof/index.ts
+++ b/src/type/keyof/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/keyof/keyof-from-mapped-result.ts b/src/type/keyof/keyof-from-mapped-result.ts
index 0be659752..fb96a9ba7 100644
--- a/src/type/keyof/keyof-from-mapped-result.ts
+++ b/src/type/keyof/keyof-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/keyof/keyof-property-entries.ts b/src/type/keyof/keyof-property-entries.ts
index f8eb236f9..8e2361c1b 100644
--- a/src/type/keyof/keyof-property-entries.ts
+++ b/src/type/keyof/keyof-property-entries.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/keyof/keyof-property-keys.ts b/src/type/keyof/keyof-property-keys.ts
index 25cfd2df3..0130ff934 100644
--- a/src/type/keyof/keyof-property-keys.ts
+++ b/src/type/keyof/keyof-property-keys.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/keyof/keyof.ts b/src/type/keyof/keyof.ts
index fbd20df62..9a8b26d30 100644
--- a/src/type/keyof/keyof.ts
+++ b/src/type/keyof/keyof.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/literal/index.ts b/src/type/literal/index.ts
index a3102cc94..0892b18c8 100644
--- a/src/type/literal/index.ts
+++ b/src/type/literal/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/literal/literal.ts b/src/type/literal/literal.ts
index 5a17d8959..32e1eed20 100644
--- a/src/type/literal/literal.ts
+++ b/src/type/literal/literal.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/mapped/index.ts b/src/type/mapped/index.ts
index 9999cfd84..e5bf772b6 100644
--- a/src/type/mapped/index.ts
+++ b/src/type/mapped/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/mapped/mapped-key.ts b/src/type/mapped/mapped-key.ts
index 42a9a6926..e8dd24f3f 100644
--- a/src/type/mapped/mapped-key.ts
+++ b/src/type/mapped/mapped-key.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/mapped/mapped-result.ts b/src/type/mapped/mapped-result.ts
index 7faf21d75..29d5a3c82 100644
--- a/src/type/mapped/mapped-result.ts
+++ b/src/type/mapped/mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/mapped/mapped.ts b/src/type/mapped/mapped.ts
index 7efdd2139..5dfc725f9 100644
--- a/src/type/mapped/mapped.ts
+++ b/src/type/mapped/mapped.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/module/compute.ts b/src/type/module/compute.ts
index 8527ab135..9ca66adf0 100644
--- a/src/type/module/compute.ts
+++ b/src/type/module/compute.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/module/index.ts b/src/type/module/index.ts
index ce46d5a0c..ba33fc039 100644
--- a/src/type/module/index.ts
+++ b/src/type/module/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/module/infer.ts b/src/type/module/infer.ts
index 2a663919f..e0fff5e0f 100644
--- a/src/type/module/infer.ts
+++ b/src/type/module/infer.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/module/module.ts b/src/type/module/module.ts
index 276332c3f..afc34fbc1 100644
--- a/src/type/module/module.ts
+++ b/src/type/module/module.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/never/index.ts b/src/type/never/index.ts
index d8937194f..72210457c 100644
--- a/src/type/never/index.ts
+++ b/src/type/never/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/never/never.ts b/src/type/never/never.ts
index f2df6451e..fb75cda84 100644
--- a/src/type/never/never.ts
+++ b/src/type/never/never.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/not/index.ts b/src/type/not/index.ts
index 34f540ae0..49e085461 100644
--- a/src/type/not/index.ts
+++ b/src/type/not/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/not/not.ts b/src/type/not/not.ts
index eb283dfdf..4ee1ef139 100644
--- a/src/type/not/not.ts
+++ b/src/type/not/not.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/null/index.ts b/src/type/null/index.ts
index fe04d45b7..a57dac3de 100644
--- a/src/type/null/index.ts
+++ b/src/type/null/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/null/null.ts b/src/type/null/null.ts
index f953d04ec..f51fccfd7 100644
--- a/src/type/null/null.ts
+++ b/src/type/null/null.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/number/index.ts b/src/type/number/index.ts
index 2cb1382f0..3d335f9ba 100644
--- a/src/type/number/index.ts
+++ b/src/type/number/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/number/number.ts b/src/type/number/number.ts
index 0ef585560..8d92776cc 100644
--- a/src/type/number/number.ts
+++ b/src/type/number/number.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/object/index.ts b/src/type/object/index.ts
index ac0958f80..97eac7b24 100644
--- a/src/type/object/index.ts
+++ b/src/type/object/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/object/object.ts b/src/type/object/object.ts
index 965ab8295..a0745ee25 100644
--- a/src/type/object/object.ts
+++ b/src/type/object/object.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/omit/index.ts b/src/type/omit/index.ts
index fc10b7329..40be9e17a 100644
--- a/src/type/omit/index.ts
+++ b/src/type/omit/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/omit/omit-from-mapped-key.ts b/src/type/omit/omit-from-mapped-key.ts
index 2a2a4ae94..08df5f145 100644
--- a/src/type/omit/omit-from-mapped-key.ts
+++ b/src/type/omit/omit-from-mapped-key.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/omit/omit-from-mapped-result.ts b/src/type/omit/omit-from-mapped-result.ts
index 5abac5f60..4bc99f029 100644
--- a/src/type/omit/omit-from-mapped-result.ts
+++ b/src/type/omit/omit-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/omit/omit.ts b/src/type/omit/omit.ts
index d52a8b477..c7c866640 100644
--- a/src/type/omit/omit.ts
+++ b/src/type/omit/omit.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/optional/index.ts b/src/type/optional/index.ts
index ef2545c59..a9da96fea 100644
--- a/src/type/optional/index.ts
+++ b/src/type/optional/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/optional/optional-from-mapped-result.ts b/src/type/optional/optional-from-mapped-result.ts
index b5bb6966a..fe04a71fb 100644
--- a/src/type/optional/optional-from-mapped-result.ts
+++ b/src/type/optional/optional-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/optional/optional.ts b/src/type/optional/optional.ts
index a481135b7..09a8951d7 100644
--- a/src/type/optional/optional.ts
+++ b/src/type/optional/optional.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/parameters/index.ts b/src/type/parameters/index.ts
index fc04a3a98..60fa18ad5 100644
--- a/src/type/parameters/index.ts
+++ b/src/type/parameters/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/parameters/parameters.ts b/src/type/parameters/parameters.ts
index a7a0daa45..d36ed9a18 100644
--- a/src/type/parameters/parameters.ts
+++ b/src/type/parameters/parameters.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/partial/index.ts b/src/type/partial/index.ts
index 953dfdbbb..af260312a 100644
--- a/src/type/partial/index.ts
+++ b/src/type/partial/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/partial/partial-from-mapped-result.ts b/src/type/partial/partial-from-mapped-result.ts
index af60533b8..65f6ba978 100644
--- a/src/type/partial/partial-from-mapped-result.ts
+++ b/src/type/partial/partial-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/partial/partial.ts b/src/type/partial/partial.ts
index 3cfb48724..52af56364 100644
--- a/src/type/partial/partial.ts
+++ b/src/type/partial/partial.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/patterns/index.ts b/src/type/patterns/index.ts
index 240e6e9ca..619eb64e1 100644
--- a/src/type/patterns/index.ts
+++ b/src/type/patterns/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/patterns/patterns.ts b/src/type/patterns/patterns.ts
index 9c9e910a2..bb44c60fb 100644
--- a/src/type/patterns/patterns.ts
+++ b/src/type/patterns/patterns.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/pick/index.ts b/src/type/pick/index.ts
index ac52efa52..8e659b8f4 100644
--- a/src/type/pick/index.ts
+++ b/src/type/pick/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/pick/pick-from-mapped-key.ts b/src/type/pick/pick-from-mapped-key.ts
index 86933aa58..df17792e5 100644
--- a/src/type/pick/pick-from-mapped-key.ts
+++ b/src/type/pick/pick-from-mapped-key.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/pick/pick-from-mapped-result.ts b/src/type/pick/pick-from-mapped-result.ts
index 7fa74f9c4..75b9dbd04 100644
--- a/src/type/pick/pick-from-mapped-result.ts
+++ b/src/type/pick/pick-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/pick/pick.ts b/src/type/pick/pick.ts
index fc690845f..b7042fb69 100644
--- a/src/type/pick/pick.ts
+++ b/src/type/pick/pick.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/promise/index.ts b/src/type/promise/index.ts
index ee5555e88..1436cfa71 100644
--- a/src/type/promise/index.ts
+++ b/src/type/promise/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/promise/promise.ts b/src/type/promise/promise.ts
index 4a2488408..cb2311c61 100644
--- a/src/type/promise/promise.ts
+++ b/src/type/promise/promise.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/readonly-optional/index.ts b/src/type/readonly-optional/index.ts
index 594463f54..8e2481eff 100644
--- a/src/type/readonly-optional/index.ts
+++ b/src/type/readonly-optional/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/readonly-optional/readonly-optional.ts b/src/type/readonly-optional/readonly-optional.ts
index 5520539e8..d53f74b50 100644
--- a/src/type/readonly-optional/readonly-optional.ts
+++ b/src/type/readonly-optional/readonly-optional.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/readonly/index.ts b/src/type/readonly/index.ts
index c21de9d35..356f84b10 100644
--- a/src/type/readonly/index.ts
+++ b/src/type/readonly/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/readonly/readonly-from-mapped-result.ts b/src/type/readonly/readonly-from-mapped-result.ts
index cd0865aaa..62134e8e9 100644
--- a/src/type/readonly/readonly-from-mapped-result.ts
+++ b/src/type/readonly/readonly-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/readonly/readonly.ts b/src/type/readonly/readonly.ts
index 47d9ee0da..bf77263ed 100644
--- a/src/type/readonly/readonly.ts
+++ b/src/type/readonly/readonly.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/record/index.ts b/src/type/record/index.ts
index 6b0a78848..7ba836747 100644
--- a/src/type/record/index.ts
+++ b/src/type/record/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/record/record.ts b/src/type/record/record.ts
index 8e7da8257..265495a66 100644
--- a/src/type/record/record.ts
+++ b/src/type/record/record.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/recursive/index.ts b/src/type/recursive/index.ts
index f23634a44..b1e22c649 100644
--- a/src/type/recursive/index.ts
+++ b/src/type/recursive/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/recursive/recursive.ts b/src/type/recursive/recursive.ts
index 50df4f320..35f36253a 100644
--- a/src/type/recursive/recursive.ts
+++ b/src/type/recursive/recursive.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/ref/index.ts b/src/type/ref/index.ts
index 606ede084..6daaa62b3 100644
--- a/src/type/ref/index.ts
+++ b/src/type/ref/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/ref/ref.ts b/src/type/ref/ref.ts
index 85e0e125c..dd4f37b21 100644
--- a/src/type/ref/ref.ts
+++ b/src/type/ref/ref.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/regexp/index.ts b/src/type/regexp/index.ts
index 578ac9777..a2f473c62 100644
--- a/src/type/regexp/index.ts
+++ b/src/type/regexp/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/regexp/regexp.ts b/src/type/regexp/regexp.ts
index 6f005e696..7fc24ea27 100644
--- a/src/type/regexp/regexp.ts
+++ b/src/type/regexp/regexp.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/registry/format.ts b/src/type/registry/format.ts
index 99b893bbe..af818ae19 100644
--- a/src/type/registry/format.ts
+++ b/src/type/registry/format.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/registry/index.ts b/src/type/registry/index.ts
index f16716fd9..cdb2ac472 100644
--- a/src/type/registry/index.ts
+++ b/src/type/registry/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/registry/type.ts b/src/type/registry/type.ts
index 35078a856..955357a5b 100644
--- a/src/type/registry/type.ts
+++ b/src/type/registry/type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/required/index.ts b/src/type/required/index.ts
index e6d6901ff..4570618f2 100644
--- a/src/type/required/index.ts
+++ b/src/type/required/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/required/required-from-mapped-result.ts b/src/type/required/required-from-mapped-result.ts
index 147508846..c5c2c30e7 100644
--- a/src/type/required/required-from-mapped-result.ts
+++ b/src/type/required/required-from-mapped-result.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/required/required.ts b/src/type/required/required.ts
index 7ae6a234d..25d4c0491 100644
--- a/src/type/required/required.ts
+++ b/src/type/required/required.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/rest/index.ts b/src/type/rest/index.ts
index e62da1430..f4cfc39eb 100644
--- a/src/type/rest/index.ts
+++ b/src/type/rest/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/rest/rest.ts b/src/type/rest/rest.ts
index d437fa2da..e467ed0c7 100644
--- a/src/type/rest/rest.ts
+++ b/src/type/rest/rest.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/return-type/index.ts b/src/type/return-type/index.ts
index 799891a64..18d2290dd 100644
--- a/src/type/return-type/index.ts
+++ b/src/type/return-type/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/return-type/return-type.ts b/src/type/return-type/return-type.ts
index f868d2fcf..17dd44757 100644
--- a/src/type/return-type/return-type.ts
+++ b/src/type/return-type/return-type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/schema/anyschema.ts b/src/type/schema/anyschema.ts
index 908295fc1..5a1d45675 100644
--- a/src/type/schema/anyschema.ts
+++ b/src/type/schema/anyschema.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/schema/index.ts b/src/type/schema/index.ts
index d3ce4acee..8279e8b4c 100644
--- a/src/type/schema/index.ts
+++ b/src/type/schema/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/schema/schema.ts b/src/type/schema/schema.ts
index 6cba033d7..f4c967ed2 100644
--- a/src/type/schema/schema.ts
+++ b/src/type/schema/schema.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/sets/index.ts b/src/type/sets/index.ts
index c793d0851..df79d6aff 100644
--- a/src/type/sets/index.ts
+++ b/src/type/sets/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/sets/set.ts b/src/type/sets/set.ts
index 35b697975..186d3f1c9 100644
--- a/src/type/sets/set.ts
+++ b/src/type/sets/set.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/static/index.ts b/src/type/static/index.ts
index 94f485cd1..70c29b49d 100644
--- a/src/type/static/index.ts
+++ b/src/type/static/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/static/static.ts b/src/type/static/static.ts
index 2ba1f1bdc..84999f184 100644
--- a/src/type/static/static.ts
+++ b/src/type/static/static.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/string/index.ts b/src/type/string/index.ts
index a21b1efbe..48ecacda4 100644
--- a/src/type/string/index.ts
+++ b/src/type/string/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/string/string.ts b/src/type/string/string.ts
index c1d6061b9..52f2ae113 100644
--- a/src/type/string/string.ts
+++ b/src/type/string/string.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/symbol/index.ts b/src/type/symbol/index.ts
index 0ba6f5542..2e308a833 100644
--- a/src/type/symbol/index.ts
+++ b/src/type/symbol/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/symbol/symbol.ts b/src/type/symbol/symbol.ts
index 5a65b23b9..e60dae6e0 100644
--- a/src/type/symbol/symbol.ts
+++ b/src/type/symbol/symbol.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/symbols/index.ts b/src/type/symbols/index.ts
index 7ee40afb8..627854d7a 100644
--- a/src/type/symbols/index.ts
+++ b/src/type/symbols/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/symbols/symbols.ts b/src/type/symbols/symbols.ts
index 11530fedb..8b47d1be6 100644
--- a/src/type/symbols/symbols.ts
+++ b/src/type/symbols/symbols.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/template-literal/finite.ts b/src/type/template-literal/finite.ts
index 194e15f93..fa5f5ea27 100644
--- a/src/type/template-literal/finite.ts
+++ b/src/type/template-literal/finite.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/template-literal/generate.ts b/src/type/template-literal/generate.ts
index 22d87a99a..56a0a0c6a 100644
--- a/src/type/template-literal/generate.ts
+++ b/src/type/template-literal/generate.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/template-literal/index.ts b/src/type/template-literal/index.ts
index 8f6a05c3e..c06e4a639 100644
--- a/src/type/template-literal/index.ts
+++ b/src/type/template-literal/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/template-literal/parse.ts b/src/type/template-literal/parse.ts
index 6a36c013e..1a6620f5d 100644
--- a/src/type/template-literal/parse.ts
+++ b/src/type/template-literal/parse.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/template-literal/pattern.ts b/src/type/template-literal/pattern.ts
index 03ab3c76f..4898583f0 100644
--- a/src/type/template-literal/pattern.ts
+++ b/src/type/template-literal/pattern.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/template-literal/syntax.ts b/src/type/template-literal/syntax.ts
index 3352b10b6..7f4804602 100644
--- a/src/type/template-literal/syntax.ts
+++ b/src/type/template-literal/syntax.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/template-literal/template-literal.ts b/src/type/template-literal/template-literal.ts
index 7eadc534d..794009f88 100644
--- a/src/type/template-literal/template-literal.ts
+++ b/src/type/template-literal/template-literal.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/template-literal/union.ts b/src/type/template-literal/union.ts
index dba883805..44cae3781 100644
--- a/src/type/template-literal/union.ts
+++ b/src/type/template-literal/union.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/transform/index.ts b/src/type/transform/index.ts
index 949f78cfe..da318ecf7 100644
--- a/src/type/transform/index.ts
+++ b/src/type/transform/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/transform/transform.ts b/src/type/transform/transform.ts
index eb7c561cd..b89ac5f9b 100644
--- a/src/type/transform/transform.ts
+++ b/src/type/transform/transform.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/tuple/index.ts b/src/type/tuple/index.ts
index 54d2b14ab..ffe9c5a9e 100644
--- a/src/type/tuple/index.ts
+++ b/src/type/tuple/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/tuple/tuple.ts b/src/type/tuple/tuple.ts
index 80b092c79..59caac85f 100644
--- a/src/type/tuple/tuple.ts
+++ b/src/type/tuple/tuple.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/type/index.ts b/src/type/type/index.ts
index dbe0febc8..3c82b269a 100644
--- a/src/type/type/index.ts
+++ b/src/type/type/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/type/javascript.ts b/src/type/type/javascript.ts
index 101231eb2..a7d6573d4 100644
--- a/src/type/type/javascript.ts
+++ b/src/type/type/javascript.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/type/json.ts b/src/type/type/json.ts
index afc3650de..c29e046a0 100644
--- a/src/type/type/json.ts
+++ b/src/type/type/json.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/type/type.ts b/src/type/type/type.ts
index d00686cc6..85ed02710 100644
--- a/src/type/type/type.ts
+++ b/src/type/type/type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/uint8array/index.ts b/src/type/uint8array/index.ts
index fc3256037..b81391707 100644
--- a/src/type/uint8array/index.ts
+++ b/src/type/uint8array/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/uint8array/uint8array.ts b/src/type/uint8array/uint8array.ts
index 09c57ab01..8a8f31845 100644
--- a/src/type/uint8array/uint8array.ts
+++ b/src/type/uint8array/uint8array.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/undefined/index.ts b/src/type/undefined/index.ts
index 728a1232d..209e971cd 100644
--- a/src/type/undefined/index.ts
+++ b/src/type/undefined/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/undefined/undefined.ts b/src/type/undefined/undefined.ts
index efd2a7649..66919ebac 100644
--- a/src/type/undefined/undefined.ts
+++ b/src/type/undefined/undefined.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/union/index.ts b/src/type/union/index.ts
index b49ca2d45..bc694b24d 100644
--- a/src/type/union/index.ts
+++ b/src/type/union/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/union/union-create.ts b/src/type/union/union-create.ts
index 856f1ffc4..0989fd967 100644
--- a/src/type/union/union-create.ts
+++ b/src/type/union/union-create.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/union/union-evaluated.ts b/src/type/union/union-evaluated.ts
index 8ba1eb21b..b3441294b 100644
--- a/src/type/union/union-evaluated.ts
+++ b/src/type/union/union-evaluated.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/union/union-type.ts b/src/type/union/union-type.ts
index 68f0cb19e..245791fda 100644
--- a/src/type/union/union-type.ts
+++ b/src/type/union/union-type.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/union/union.ts b/src/type/union/union.ts
index bacffbd19..e91ba8c5a 100644
--- a/src/type/union/union.ts
+++ b/src/type/union/union.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/unknown/index.ts b/src/type/unknown/index.ts
index 80a7b68e7..6070bc428 100644
--- a/src/type/unknown/index.ts
+++ b/src/type/unknown/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/unknown/unknown.ts b/src/type/unknown/unknown.ts
index f91f9613d..4c2406996 100644
--- a/src/type/unknown/unknown.ts
+++ b/src/type/unknown/unknown.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/unsafe/index.ts b/src/type/unsafe/index.ts
index 395fd75bf..6f3db72a5 100644
--- a/src/type/unsafe/index.ts
+++ b/src/type/unsafe/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/unsafe/unsafe.ts b/src/type/unsafe/unsafe.ts
index 4a52650d8..133a1927d 100644
--- a/src/type/unsafe/unsafe.ts
+++ b/src/type/unsafe/unsafe.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/void/index.ts b/src/type/void/index.ts
index e6bc946ae..ee941af09 100644
--- a/src/type/void/index.ts
+++ b/src/type/void/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/type/void/void.ts b/src/type/void/void.ts
index 0672480b9..dec74a5e5 100644
--- a/src/type/void/void.ts
+++ b/src/type/void/void.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/assert/assert.ts b/src/value/assert/assert.ts
index 07a50db10..57c0eebba 100644
--- a/src/value/assert/assert.ts
+++ b/src/value/assert/assert.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/assert/index.ts b/src/value/assert/index.ts
index c2b2c88b3..c7adc3b1e 100644
--- a/src/value/assert/index.ts
+++ b/src/value/assert/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/cast/cast.ts b/src/value/cast/cast.ts
index a6f9d9891..671050421 100644
--- a/src/value/cast/cast.ts
+++ b/src/value/cast/cast.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/cast/index.ts b/src/value/cast/index.ts
index 575c46a49..9cdbd9556 100644
--- a/src/value/cast/index.ts
+++ b/src/value/cast/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/check/check.ts b/src/value/check/check.ts
index c5244e22a..f55475c64 100644
--- a/src/value/check/check.ts
+++ b/src/value/check/check.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/check/index.ts b/src/value/check/index.ts
index 04975a6ba..9fe61e89e 100644
--- a/src/value/check/index.ts
+++ b/src/value/check/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/clean/clean.ts b/src/value/clean/clean.ts
index 41e7f4edb..6a692e347 100644
--- a/src/value/clean/clean.ts
+++ b/src/value/clean/clean.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/clean/index.ts b/src/value/clean/index.ts
index 81d0b0910..89ecef46e 100644
--- a/src/value/clean/index.ts
+++ b/src/value/clean/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/clone/clone.ts b/src/value/clone/clone.ts
index 370fdac49..7ea2261b4 100644
--- a/src/value/clone/clone.ts
+++ b/src/value/clone/clone.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/clone/index.ts b/src/value/clone/index.ts
index 22d2dd12b..c6563b3cb 100644
--- a/src/value/clone/index.ts
+++ b/src/value/clone/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index 9461bd7dd..ca0a96c51 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/convert/index.ts b/src/value/convert/index.ts
index 3a88a32f7..9ff2227d1 100644
--- a/src/value/convert/index.ts
+++ b/src/value/convert/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/create/create.ts b/src/value/create/create.ts
index 478aab130..b56ab26fa 100644
--- a/src/value/create/create.ts
+++ b/src/value/create/create.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/create/index.ts b/src/value/create/index.ts
index 706ec0023..adeb52ec6 100644
--- a/src/value/create/index.ts
+++ b/src/value/create/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/decode/decode.ts b/src/value/decode/decode.ts
index c1cc8a248..0ff9a238a 100644
--- a/src/value/decode/decode.ts
+++ b/src/value/decode/decode.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/decode/index.ts b/src/value/decode/index.ts
index 4372c79ae..6c82cdbe7 100644
--- a/src/value/decode/index.ts
+++ b/src/value/decode/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/default/default.ts b/src/value/default/default.ts
index e77cd0188..5737c8d91 100644
--- a/src/value/default/default.ts
+++ b/src/value/default/default.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/default/index.ts b/src/value/default/index.ts
index 62ca5b16f..9619cd8c5 100644
--- a/src/value/default/index.ts
+++ b/src/value/default/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/delta/delta.ts b/src/value/delta/delta.ts
index fd65c57cc..dc9d41034 100644
--- a/src/value/delta/delta.ts
+++ b/src/value/delta/delta.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/delta/index.ts b/src/value/delta/index.ts
index 0ea44bee9..64b7dd1d7 100644
--- a/src/value/delta/index.ts
+++ b/src/value/delta/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/deref/deref.ts b/src/value/deref/deref.ts
index 2f7d594ad..df2d80881 100644
--- a/src/value/deref/deref.ts
+++ b/src/value/deref/deref.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/deref/index.ts b/src/value/deref/index.ts
index 99003df72..0603b9430 100644
--- a/src/value/deref/index.ts
+++ b/src/value/deref/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/encode/encode.ts b/src/value/encode/encode.ts
index 357effe66..be52b4a62 100644
--- a/src/value/encode/encode.ts
+++ b/src/value/encode/encode.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/encode/index.ts b/src/value/encode/index.ts
index 4b57d9b32..e4eb54b1c 100644
--- a/src/value/encode/index.ts
+++ b/src/value/encode/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/equal/equal.ts b/src/value/equal/equal.ts
index 8646fd739..2cceefd82 100644
--- a/src/value/equal/equal.ts
+++ b/src/value/equal/equal.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/equal/index.ts b/src/value/equal/index.ts
index 7a4ad2de7..17c146250 100644
--- a/src/value/equal/index.ts
+++ b/src/value/equal/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/guard/guard.ts b/src/value/guard/guard.ts
index 8d5fa25d0..7ad705a9b 100644
--- a/src/value/guard/guard.ts
+++ b/src/value/guard/guard.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/guard/index.ts b/src/value/guard/index.ts
index 439925ae1..d00b7dc7b 100644
--- a/src/value/guard/index.ts
+++ b/src/value/guard/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/hash/hash.ts b/src/value/hash/hash.ts
index eb86c7c72..b72c039ea 100644
--- a/src/value/hash/hash.ts
+++ b/src/value/hash/hash.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/hash/index.ts b/src/value/hash/index.ts
index 8f83cb1ac..c7122183b 100644
--- a/src/value/hash/index.ts
+++ b/src/value/hash/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/index.ts b/src/value/index.ts
index a1b4e46f5..0f91d6e9f 100644
--- a/src/value/index.ts
+++ b/src/value/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/mutate/index.ts b/src/value/mutate/index.ts
index ef0e67394..d999d10eb 100644
--- a/src/value/mutate/index.ts
+++ b/src/value/mutate/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/mutate/mutate.ts b/src/value/mutate/mutate.ts
index b5ad3472a..5b7128dc4 100644
--- a/src/value/mutate/mutate.ts
+++ b/src/value/mutate/mutate.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/parse/index.ts b/src/value/parse/index.ts
index 3d329f1ce..a5f6ba890 100644
--- a/src/value/parse/index.ts
+++ b/src/value/parse/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/parse/parse.ts b/src/value/parse/parse.ts
index e28d53de8..9654f1d4e 100644
--- a/src/value/parse/parse.ts
+++ b/src/value/parse/parse.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/pointer/index.ts b/src/value/pointer/index.ts
index c64016d47..f0828dcb6 100644
--- a/src/value/pointer/index.ts
+++ b/src/value/pointer/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/pointer/pointer.ts b/src/value/pointer/pointer.ts
index 6b8d7aa6f..aa1b7e39c 100644
--- a/src/value/pointer/pointer.ts
+++ b/src/value/pointer/pointer.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/transform/decode.ts b/src/value/transform/decode.ts
index 013b0abd1..f9a120ae4 100644
--- a/src/value/transform/decode.ts
+++ b/src/value/transform/decode.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/transform/encode.ts b/src/value/transform/encode.ts
index 3ac8c54c8..1852c5ffe 100644
--- a/src/value/transform/encode.ts
+++ b/src/value/transform/encode.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/transform/has.ts b/src/value/transform/has.ts
index 5a0d785c3..549a39e9e 100644
--- a/src/value/transform/has.ts
+++ b/src/value/transform/has.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/transform/index.ts b/src/value/transform/index.ts
index e3bd75d2a..1759d820d 100644
--- a/src/value/transform/index.ts
+++ b/src/value/transform/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/value/index.ts b/src/value/value/index.ts
index eabf61e7b..af4861374 100644
--- a/src/value/value/index.ts
+++ b/src/value/value/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/src/value/value/value.ts b/src/value/value/value.ts
index ab0e06b3d..d1d5f6319 100644
--- a/src/value/value/value.ts
+++ b/src/value/value/value.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/cjs/build.ts b/task/build/cjs/build.ts
index 65f1c8410..061043cea 100644
--- a/task/build/cjs/build.ts
+++ b/task/build/cjs/build.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/cjs/compile.ts b/task/build/cjs/compile.ts
index bd089ec21..c70aa0d6f 100644
--- a/task/build/cjs/compile.ts
+++ b/task/build/cjs/compile.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/esm/build.ts b/task/build/esm/build.ts
index 04a0eb450..ff1c5db63 100644
--- a/task/build/esm/build.ts
+++ b/task/build/esm/build.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/esm/compile.ts b/task/build/esm/compile.ts
index 08e0129e5..35a9d3722 100644
--- a/task/build/esm/compile.ts
+++ b/task/build/esm/compile.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/esm/convert-to-esm.ts b/task/build/esm/convert-to-esm.ts
index 9878a4fe6..21df0eac6 100644
--- a/task/build/esm/convert-to-esm.ts
+++ b/task/build/esm/convert-to-esm.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/index.ts b/task/build/index.ts
index e55ce6705..2d9d295d9 100644
--- a/task/build/index.ts
+++ b/task/build/index.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/notices/remove-notices.ts b/task/build/notices/remove-notices.ts
index 96b4dfb2d..3d101ae46 100644
--- a/task/build/notices/remove-notices.ts
+++ b/task/build/notices/remove-notices.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/package/build.ts b/task/build/package/build.ts
index 0e05ede91..305ebbd1a 100644
--- a/task/build/package/build.ts
+++ b/task/build/package/build.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/package/create-package-json-redirect.ts b/task/build/package/create-package-json-redirect.ts
index f586763f3..298477082 100644
--- a/task/build/package/create-package-json-redirect.ts
+++ b/task/build/package/create-package-json-redirect.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/task/build/package/create-package-json.ts b/task/build/package/create-package-json.ts
index 3fc0a186e..863e922c5 100644
--- a/task/build/package/create-package-json.ts
+++ b/task/build/package/create-package-json.ts
@@ -4,7 +4,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

From 870ab417fb69775e3b490d4457aa5963b6f16673 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 16 Jan 2025 17:20:57 +0900
Subject: [PATCH 328/369] Revision 0.34.14 (#1140)

* Fix Compiler Promise Check

* ChangeLog

* Version
---
 changelog/0.34.0.md      |  2 ++
 package-lock.json        |  4 ++--
 package.json             |  2 +-
 src/compiler/compiler.ts |  2 +-
 src/value/guard/guard.ts | 16 ++++++++--------
 5 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 3c68b589d..97f0a53fb 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,4 +1,6 @@
 ### 0.34.0
+- [Revision 0.34.14](https://github.com/sinclairzx81/typebox/pull/1140)
+  - [1139](https://github.com/sinclairzx81/typebox/issues/1139) Update TypeCompiler Check for Promise (use instanceof Promise over Thenable check)
 - [Revision 0.34.13](https://github.com/sinclairzx81/typebox/pull/1124)
   - Pre emptive fix for TypeScript 5.8.0-nightly to resolve symbol narrowing on Convert.
 - [Revision 0.34.12](https://github.com/sinclairzx81/typebox/pull/1120)
diff --git a/package-lock.json b/package-lock.json
index 82a40a27d..830c835ee 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.13",
+  "version": "0.34.14",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.13",
+      "version": "0.34.14",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index e40785943..1c2dafe03 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.13",
+  "version": "0.34.14",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index 706667ee7..eb5c67c40 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -384,7 +384,7 @@ export namespace TypeCompiler {
     }
   }
   function* FromPromise(schema: TPromise, references: TSchema[], value: string): IterableIterator<string> {
-    yield `(typeof value === 'object' && typeof ${value}.then === 'function')`
+    yield `${value} instanceof Promise`
   }
   function* FromRecord(schema: TRecord, references: TSchema[], value: string): IterableIterator<string> {
     yield Policy.IsRecordLike(value)
diff --git a/src/value/guard/guard.ts b/src/value/guard/guard.ts
index 7ad705a9b..56410e709 100644
--- a/src/value/guard/guard.ts
+++ b/src/value/guard/guard.ts
@@ -50,18 +50,18 @@ export type TypedArrayType =
 // --------------------------------------------------------------------------
 /** Returns true if this value is an async iterator */
 export function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<any> {
-  return IsObject(value) && Symbol.asyncIterator in value
+  return IsObject(value) && globalThis.Symbol.asyncIterator in value
 }
 /** Returns true if this value is an iterator */
 export function IsIterator(value: unknown): value is IterableIterator<any> {
-  return IsObject(value) && Symbol.iterator in value
+  return IsObject(value) && globalThis.Symbol.iterator in value
 }
 // --------------------------------------------------------------------------
 // Object Instances
 // --------------------------------------------------------------------------
 /** Returns true if this value is not an instance of a class */
 export function IsStandardObject(value: unknown): value is ObjectType {
-  return IsObject(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)
+  return IsObject(value) && (globalThis.Object.getPrototypeOf(value) === Object.prototype || globalThis.Object.getPrototypeOf(value) === null)
 }
 /** Returns true if this value is an instance of a class */
 export function IsInstanceObject(value: unknown): value is ObjectType {
@@ -72,11 +72,11 @@ export function IsInstanceObject(value: unknown): value is ObjectType {
 // --------------------------------------------------------------------------
 /** Returns true if this value is a Promise */
 export function IsPromise(value: unknown): value is Promise<unknown> {
-  return value instanceof Promise
+  return value instanceof globalThis.Promise
 }
 /** Returns true if this value is a Date */
 export function IsDate(value: unknown): value is Date {
-  return value instanceof Date && Number.isFinite(value.getTime())
+  return value instanceof Date && globalThis.Number.isFinite(value.getTime())
 }
 /** Returns true if this value is an instance of Map<K, T> */
 export function IsMap(value: unknown): value is Map<unknown, unknown> {
@@ -92,7 +92,7 @@ export function IsRegExp(value: unknown): value is RegExp {
 }
 /** Returns true if this value is a typed array */
 export function IsTypedArray(value: unknown): value is TypedArrayType {
-  return ArrayBuffer.isView(value)
+  return globalThis.ArrayBuffer.isView(value)
 }
 /** Returns true if the value is a Int8Array */
 export function IsInt8Array(value: unknown): value is Int8Array {
@@ -154,7 +154,7 @@ export function IsObject(value: unknown): value is ObjectType {
 }
 /** Returns true if this value is an array, but not a typed array */
 export function IsArray(value: unknown): value is ArrayType {
-  return Array.isArray(value) && !ArrayBuffer.isView(value)
+  return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value)
 }
 /** Returns true if this value is an undefined */
 export function IsUndefined(value: unknown): value is undefined {
@@ -174,7 +174,7 @@ export function IsNumber(value: unknown): value is number {
 }
 /** Returns true if this value is an integer */
 export function IsInteger(value: unknown): value is number {
-  return Number.isInteger(value)
+  return globalThis.Number.isInteger(value)
 }
 /** Returns true if this value is bigint */
 export function IsBigInt(value: unknown): value is bigint {

From 9ea7eb0493c1f483322d882d84b7f4e8950fc3a5 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 30 Jan 2025 13:55:26 +0900
Subject: [PATCH 329/369] Documentation

- Update Ecosystem
---
 readme.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/readme.md b/readme.md
index 1d44e671f..b33def232 100644
--- a/readme.md
+++ b/readme.md
@@ -1779,7 +1779,6 @@ The following is a list of community packages that offer general tooling, extend
 | [sveltekit-superforms](https://github.com/ciscoheat/sveltekit-superforms)  | A comprehensive SvelteKit form library for server and client validation |
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
 | [typebox-form-parser](https://github.com/jtlapp/typebox-form-parser) | Parses form and query data based on TypeBox schemas |
-| [typebox-validators](https://github.com/jtlapp/typebox-validators) | Advanced validators supporting discriminated and heterogeneous unions |
 
 <a name='benchmark'></a>
 

From e772a4f3c6958a6358f48617b49dd72d16a796ad Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 30 Jan 2025 14:25:13 +0900
Subject: [PATCH 330/369] Revision 0.34.15 (#1148)

* Use Math.Trunc to avoid 32-bit coersion for Integer

* Version

* ChangeLog
---
 changelog/0.34.0.md                   |  2 ++
 package-lock.json                     |  4 ++--
 package.json                          |  2 +-
 src/value/convert/convert.ts          |  2 +-
 test/runtime/value/convert/integer.ts | 23 +++++++++++++++++++++++
 5 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 97f0a53fb..703528ec2 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,4 +1,6 @@
 ### 0.34.0
+- [Revision 0.34.15](https://github.com/sinclairzx81/typebox/pull/1148)
+  - [1147](https://github.com/sinclairzx81/typebox/issues/1147) Fix incorrect truncation for integers that exceed 32-bit values in Value.Convert
 - [Revision 0.34.14](https://github.com/sinclairzx81/typebox/pull/1140)
   - [1139](https://github.com/sinclairzx81/typebox/issues/1139) Update TypeCompiler Check for Promise (use instanceof Promise over Thenable check)
 - [Revision 0.34.13](https://github.com/sinclairzx81/typebox/pull/1124)
diff --git a/package-lock.json b/package-lock.json
index 830c835ee..b2abe8da4 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.14",
+  "version": "0.34.15",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.14",
+      "version": "0.34.15",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 1c2dafe03..734199b76 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.14",
+  "version": "0.34.15",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index ca0a96c51..752ba37a4 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -125,7 +125,7 @@ function TryConvertNumber(value: unknown) {
   return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value
 }
 function TryConvertInteger(value: unknown) {
-  return IsStringNumeric(value) ? parseInt(value) : IsNumber(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value
+  return IsStringNumeric(value) ? parseInt(value) : IsNumber(value) ? Math.trunc(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value
 }
 function TryConvertNull(value: unknown) {
   return IsString(value) && value.toLowerCase() === 'null' ? null : value
diff --git a/test/runtime/value/convert/integer.ts b/test/runtime/value/convert/integer.ts
index 8f17ff4c1..abfc59792 100644
--- a/test/runtime/value/convert/integer.ts
+++ b/test/runtime/value/convert/integer.ts
@@ -76,4 +76,27 @@ describe('value/convert/Integer', () => {
     const result = Value.Convert(Type.Integer(), value)
     Assert.IsEqual(result, [])
   })
+  // ----------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/1147
+  // ----------------------------------------------------------
+  it('Should convert large Integer 1', () => {
+    const N = 1738213389080
+    const R = Value.Convert(Type.Integer(), N)
+    Assert.IsEqual(R, N)
+  })
+  it('Should convert large Integer 2', () => {
+    const N = 1738213389080.5555
+    const R = Value.Convert(Type.Integer(), N)
+    Assert.IsEqual(R, 1738213389080)
+  })
+  it('Should convert large Integer 3', () => {
+    const N = '1738213389080'
+    const R = Value.Convert(Type.Integer(), N)
+    Assert.IsEqual(R, 1738213389080)
+  })
+  it('Should convert large Integer 3', () => {
+    const N = '1738213389080.555'
+    const R = Value.Convert(Type.Integer(), N)
+    Assert.IsEqual(R, 1738213389080)
+  })
 })

From b5e1d146ed2547eaa79a2dac7ccd4e559773ef41 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 6 Feb 2025 18:48:30 +0900
Subject: [PATCH 331/369] Revision 0.34.16 (#1156)

* Export Parsing Infrastructure

* TypeScript 5.7.3

* ChangeLog

* Documentation
---
 changelog/0.34.0.md                           |   2 +
 example/index.ts                              |   4 +-
 hammer.mjs                                    |   2 +-
 package-lock.json                             |  18 +-
 package.json                                  |   4 +-
 readme.md                                     | 246 ++++--------
 src/{syntax/parsebox => parser}/index.ts      |   0
 .../parsebox => parser}/runtime/guard.ts      |   0
 .../parsebox => parser}/runtime/index.ts      |   0
 .../parsebox => parser}/runtime/module.ts     |   0
 .../parsebox => parser}/runtime/parse.ts      |   0
 .../parsebox => parser}/runtime/token.ts      |   0
 .../parsebox => parser}/runtime/types.ts      |   0
 .../parsebox => parser}/static/index.ts       |   0
 .../parsebox => parser}/static/parse.ts       |   0
 .../parsebox => parser}/static/token.ts       |   0
 .../parsebox => parser}/static/types.ts       |   0
 src/syntax/index.ts                           |   2 +-
 src/syntax/parse.ts                           |  60 ---
 src/syntax/runtime.ts                         | 374 ++++++------------
 src/syntax/static.ts                          | 353 +++++------------
 src/syntax/syntax.ts                          | 105 +++++
 src/tsconfig.json                             |   2 +-
 .../constructor-parameters.ts                 |  14 +-
 src/type/instance-type/instance-type.ts       |  19 +-
 src/type/parameters/parameters.ts             |  15 +-
 src/type/return-type/return-type.ts           |  19 +-
 src/type/type/javascript.ts                   |   8 +-
 task/build/package/build.ts                   |   2 +-
 test/runtime/syntax/syntax.ts                 | 235 ++++-------
 tsconfig.json                                 |   1 +
 31 files changed, 549 insertions(+), 936 deletions(-)
 rename src/{syntax/parsebox => parser}/index.ts (100%)
 rename src/{syntax/parsebox => parser}/runtime/guard.ts (100%)
 rename src/{syntax/parsebox => parser}/runtime/index.ts (100%)
 rename src/{syntax/parsebox => parser}/runtime/module.ts (100%)
 rename src/{syntax/parsebox => parser}/runtime/parse.ts (100%)
 rename src/{syntax/parsebox => parser}/runtime/token.ts (100%)
 rename src/{syntax/parsebox => parser}/runtime/types.ts (100%)
 rename src/{syntax/parsebox => parser}/static/index.ts (100%)
 rename src/{syntax/parsebox => parser}/static/parse.ts (100%)
 rename src/{syntax/parsebox => parser}/static/token.ts (100%)
 rename src/{syntax/parsebox => parser}/static/types.ts (100%)
 delete mode 100644 src/syntax/parse.ts
 create mode 100644 src/syntax/syntax.ts

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 703528ec2..b3645d6e9 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,4 +1,6 @@
 ### 0.34.0
+- [Revision 0.34.16](https://github.com/sinclairzx81/typebox/pull/1156)
+  - Export TypeBox String Parsing Infrastructure
 - [Revision 0.34.15](https://github.com/sinclairzx81/typebox/pull/1148)
   - [1147](https://github.com/sinclairzx81/typebox/issues/1147) Fix incorrect truncation for integers that exceed 32-bit values in Value.Convert
 - [Revision 0.34.14](https://github.com/sinclairzx81/typebox/pull/1140)
diff --git a/example/index.ts b/example/index.ts
index 9d228684a..ff155a02a 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -1,8 +1,8 @@
 import { TypeSystem } from '@sinclair/typebox/system'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 import { Value, ValuePointer } from '@sinclair/typebox/value'
-import { Parse, StaticParseAsType } from '@sinclair/typebox/syntax'
 import { Type, TypeGuard, Kind, Static, TSchema } from '@sinclair/typebox'
+import { Syntax } from '@sinclair/typebox/syntax'
 
 // -----------------------------------------------------------
 // Create: Type
@@ -22,7 +22,7 @@ console.log(T)
 // Parse: Type
 // -----------------------------------------------------------
 
-const S = Parse({ T }, `{ x: T, y: T, z: T }`)
+const S = Syntax({ T }, `{ x: T, y: T, z: T }`)
 
 type S = Static<typeof S>
 
diff --git a/hammer.mjs b/hammer.mjs
index 26f758006..cc8bd42f6 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -35,7 +35,7 @@ export async function benchmark() {
 // Test
 // -------------------------------------------------------------------------------
 export async function test_typescript() {
-  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', '5.4.5', '5.5.2', '5.5.3', '5.5.4', '5.6.2', '5.6.3', 'next', 'latest']) {
+  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', '5.4.5', '5.5.2', '5.5.3', '5.5.4', '5.6.2', '5.6.3', '5.7.2', 'next', 'latest']) {
     await shell(`npm install typescript@${version} --no-save`)
     await test_static()
   }
diff --git a/package-lock.json b/package-lock.json
index b2abe8da4..373aed4f7 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.15",
+  "version": "0.34.16",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.15",
+      "version": "0.34.16",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
@@ -17,7 +17,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^10.4.0",
         "prettier": "^2.7.1",
-        "typescript": "^5.7.2"
+        "typescript": "^5.7.3"
       }
     },
     "node_modules/@andrewbranch/untar.js": {
@@ -1576,9 +1576,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.7.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.2.tgz",
-      "integrity": "sha512-i5t66RHxDvVN40HfDd1PsEThGNnlMCMT3jMUuoh9/0TaqWevNontacunWyN02LA9/fIbEWlcHZcgTKb9QoaLfg==",
+      "version": "5.7.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.3.tgz",
+      "integrity": "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -2738,9 +2738,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.7.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.2.tgz",
-      "integrity": "sha512-i5t66RHxDvVN40HfDd1PsEThGNnlMCMT3jMUuoh9/0TaqWevNontacunWyN02LA9/fIbEWlcHZcgTKb9QoaLfg==",
+      "version": "5.7.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.3.tgz",
+      "integrity": "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==",
       "dev": true
     },
     "undici-types": {
diff --git a/package.json b/package.json
index 734199b76..1bf33bd7b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.15",
+  "version": "0.34.16",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -38,6 +38,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^10.4.0",
     "prettier": "^2.7.1",
-    "typescript": "^5.7.2"
+    "typescript": "^5.7.3"
   }
 }
diff --git a/readme.md b/readme.md
index b33def232..37fd0b36e 100644
--- a/readme.md
+++ b/readme.md
@@ -77,10 +77,6 @@ License MIT
   - [Transform](#types-transform)
   - [Guard](#types-guard)
   - [Unsafe](#types-unsafe)
-- [Syntax](#syntax)
-  - [Parse](#syntax-parse)
-  - [Static](#syntax-static)
-  - [Limits](#syntax-limits)
 - [Values](#values)
   - [Assert](#values-assert)
   - [Create](#values-create)
@@ -100,6 +96,11 @@ License MIT
   - [Errors](#values-errors)
   - [Mutate](#values-mutate)
   - [Pointer](#values-pointer)
+- [Syntax](#syntax)
+  - [Type](#syntax-type)
+  - [Options](#syntax-options)
+  - [Parameters](#syntax-parameters)
+  - [Generics](#syntax-generics)
 - [TypeRegistry](#typeregistry)
   - [Type](#typeregistry-type)
   - [Format](#typeregistry-format)
@@ -1044,162 +1045,6 @@ if(TypeGuard.IsString(T)) {
 }
 ```
 
-<a name='syntax'></a>
-
-## Syntax Types
-
-TypeBox has support for parsing TypeScript type annotations directly into TypeBox types. This feature supports both runtime and static parsing, with TypeBox implementing TypeScript parsers within the TypeScript type system itself. Syntax Types use the TypeBox Json Schema representations as an AST target for TypeScript types, providing a direct mapping between TypeScript syntax and Json Schema. Syntax Types are offered as a syntactical frontend to the Standard Type Builder API.
-
-This feature is available via optional import.
-
-```typescript
-import { Parse } from '@sinclair/typebox/syntax'
-```
-
-<a name='syntax-parse'></a>
-
-### Parse
-
-Use the Parse function to transform a TypeScript type annotation into a TypeBox type. This function will return the parsed TypeBox type or undefined on error.
-
-```typescript
-const A = Parse('string')                           // const A: TString
-
-const B = Parse('[1, 2, 3]')                        // const B: TTuple<[
-                                                    //   TLiteral<1>,
-                                                    //   TLiteral<2>,
-                                                    //   TLiteral<3>
-                                                    // ]>
-
-const C = Parse(`{ x: number, y: number }`)         // const C: TObject<{
-                                                    //   x: TNumber
-                                                    //   y: TNumber
-                                                    // }>
-```
-
-Syntax Types can compose with Standard Types created via the Type Builder API
-
-```typescript
-const T = Type.Object({                             // const T: TObject<{
-  x: Parse('number'),                               //   x: TNumber,
-  y: Parse('string'),                               //   y: TString,
-  z: Parse('boolean')                               //   z: TBoolean
-})                                                  // }>
-```
-
-Standard Types can also be passed to and referenced within Syntax Types.
-
-```typescript
-const X = Type.Number()
-const Y = Type.String()
-const Z = Type.Boolean()
-
-const T = Parse({ X, Y, Z }, `{ 
-  x: X, 
-  y: Y, 
-  z: Z 
-}`)
-```
-
-Syntax Types also support Module parsing.
-
-```typescript
-const Foo = Parse(`module Foo {
-
-  export type PartialUser = Pick<User, 'id'> & Partial<Omit<User, 'id'>>
-
-  export interface User {
-    id: string
-    name: string
-    email: string
-  }
-
-}`)
-
-const PartialUser = Foo.Import('PartialUser')       // TImport<{...}, 'PartialUser'>
-
-type PartialUser = Static<typeof PartialUser>       // type PartialUser = {
-                                                    //   id: string,
-                                                    // } & {
-                                                    //   name?: string,
-                                                    //   email?: string,
-                                                    // }
-```
-
-<a name='syntax-static'></a>
-
-### Static
-
-Syntax Types provide two Static types specific to inferring TypeBox and TypeScript types from strings.
-
-```typescript
-import { StaticParseAsSchema, StaticParseAsType } from '@sinclair/typebox/syntax' 
-
-// Will infer as a TSchema
-
-type S = StaticParseAsSchema<{}, '{ x: number }'>   // type S: TObject<{
-                                                    //   x: TNumber
-                                                    // }>
-
-// Will infer as a type
-
-type T = StaticParseAsType<{}, '{ x: number }'>     // type T = {
-                                                    //   x: number
-                                                    // }                      
-```
-
-
-<a name='syntax-limits'></a>
-
-### Limitations
-
-TypeBox parses TypeScript types directly within the TypeScript type system. This process does come with an inference cost, which scales with the size and complexity of the types being parsed. Although TypeBox strives to optimize Syntax Types, users should be aware of the following structures:
-
-```typescript
-// Excessively wide structures will result in instantiation limits exceeding
-const A = Parse(`[
-  0, 1, 2, 3, 4, 5, 6, 7,
-  0, 1, 2, 3, 4, 5, 6, 7,
-  0, 1, 2, 3, 4, 5, 6, 7,
-  0, 1, 2, 3, 4, 5, 6, 7,
-  0, 1, 2, 3, 4, 5, 6, 7,
-  0, 1, 2, 3, 4, 5, 6, 7,
-  0, 1, 2, 3, 4, 5, 6, 7,
-  0, 1, 2, 3, 4, 5, 6, 7,
-]`)
-
-// Excessively nested structures will result in instantiation limits exceeding
-const B = Parse(`{
-  x: {
-    y: {
-      z: {
-        w: 1 <-- Type instantiation is excessively deep and possibly infinite.
-      } 
-    }
-  }  
-}`)
-```
-
-If Syntax Types exceed TypeScript's instantiation limits, users are advised to fall back to the Standard Type Builder API. Alternatively, TypeBox offers a `ParseOnly` function that parses the TypeScript syntax at runtime without statically inferring the schema.
-
-```typescript
-import { ParseOnly } from '@sinclair/typebox/syntax'
-
-// const A: TSchema | undefined 
-
-const A = ParseOnly(`{
-  x: {
-    y: {
-      z: {
-        w: 1
-      } 
-    }
-  }  
-}`)
-```
-
-For more information on static parsing, refer to the [ParseBox](https://github.com/sinclairzx81/parsebox) project.
-
 <a name='values'></a>
 
 ## Values
@@ -1490,6 +1335,87 @@ ValuePointer.Set(A, '/y', 1)                         // A' = { x: 1, y: 1, z: 0
 ValuePointer.Set(A, '/z', 1)                         // A' = { x: 1, y: 1, z: 1 }
 ```
 
+
+
+<a name='syntax'></a>
+
+## Syntax Types
+
+TypeBox provides optional support for runtime and type level parsing from TypeScript syntax.
+
+```typescript
+import { Syntax } from '@sinclair/typebox/syntax'
+```
+
+<a name='syntax-type'></a>
+
+### Type
+
+Use the Syntax function to create TypeBox type from TypeScript syntax.
+
+```typescript
+const T = Syntax(`{ x: number, y: number }`)        // const T: TObject<{
+                                                    //   x: TNumber
+                                                    //   y: TNumber
+                                                    // }>
+```
+
+<a name='syntax-options'></a>
+
+### Options
+
+Options can be passed to types on the last parameter
+
+```typescript
+const T = Syntax(`number`, {                      // const T = {
+  minimum: 0,                                     //   type: 'number',
+  maximum: 10                                     //   minimum: 0,
+})                                                //   maximum: 10
+                                                  // }
+```
+
+<a name="syntax-parameters"></a>
+
+### Parameters
+
+Syntax types can be parameterized to accept exterior types.
+
+```typescript
+const T = Syntax('number')
+
+const S = Syntax({ T }, `{ x: T, y: T, z: T }`)     // const S: TObject<{
+                                                    //   x: TNumber,
+                                                    //   y: TNumber,
+                                                    //   z: TNumber
+                                                    // }>
+```
+
+<a name="syntax-generics"></a>
+
+### Generics
+
+Generic syntax types can be created using parameterized types.
+
+```typescript
+// Generic Syntax Type
+
+const Vector = <T extends string>(T: T) => Syntax({ T: Syntax(T) }, `{
+  x: T,
+  y: T,
+  z: T
+}`)
+
+
+// Instanced Generic Syntax Type
+
+const NumberVector = Vector('number')                 // const NumberVector: TObject<{
+                                                      //   x: TNumber,
+                                                      //   y: TNumber,
+                                                      //   z: TNumber
+                                                      // }>
+```
+
+
 <a name='typeregistry'></a>
 
 ## TypeRegistry
diff --git a/src/syntax/parsebox/index.ts b/src/parser/index.ts
similarity index 100%
rename from src/syntax/parsebox/index.ts
rename to src/parser/index.ts
diff --git a/src/syntax/parsebox/runtime/guard.ts b/src/parser/runtime/guard.ts
similarity index 100%
rename from src/syntax/parsebox/runtime/guard.ts
rename to src/parser/runtime/guard.ts
diff --git a/src/syntax/parsebox/runtime/index.ts b/src/parser/runtime/index.ts
similarity index 100%
rename from src/syntax/parsebox/runtime/index.ts
rename to src/parser/runtime/index.ts
diff --git a/src/syntax/parsebox/runtime/module.ts b/src/parser/runtime/module.ts
similarity index 100%
rename from src/syntax/parsebox/runtime/module.ts
rename to src/parser/runtime/module.ts
diff --git a/src/syntax/parsebox/runtime/parse.ts b/src/parser/runtime/parse.ts
similarity index 100%
rename from src/syntax/parsebox/runtime/parse.ts
rename to src/parser/runtime/parse.ts
diff --git a/src/syntax/parsebox/runtime/token.ts b/src/parser/runtime/token.ts
similarity index 100%
rename from src/syntax/parsebox/runtime/token.ts
rename to src/parser/runtime/token.ts
diff --git a/src/syntax/parsebox/runtime/types.ts b/src/parser/runtime/types.ts
similarity index 100%
rename from src/syntax/parsebox/runtime/types.ts
rename to src/parser/runtime/types.ts
diff --git a/src/syntax/parsebox/static/index.ts b/src/parser/static/index.ts
similarity index 100%
rename from src/syntax/parsebox/static/index.ts
rename to src/parser/static/index.ts
diff --git a/src/syntax/parsebox/static/parse.ts b/src/parser/static/parse.ts
similarity index 100%
rename from src/syntax/parsebox/static/parse.ts
rename to src/parser/static/parse.ts
diff --git a/src/syntax/parsebox/static/token.ts b/src/parser/static/token.ts
similarity index 100%
rename from src/syntax/parsebox/static/token.ts
rename to src/parser/static/token.ts
diff --git a/src/syntax/parsebox/static/types.ts b/src/parser/static/types.ts
similarity index 100%
rename from src/syntax/parsebox/static/types.ts
rename to src/parser/static/types.ts
diff --git a/src/syntax/index.ts b/src/syntax/index.ts
index 8a2445bfb..d7fc819f7 100644
--- a/src/syntax/index.ts
+++ b/src/syntax/index.ts
@@ -26,4 +26,4 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export * from './parse'
+export * from './syntax'
diff --git a/src/syntax/parse.ts b/src/syntax/parse.ts
deleted file mode 100644
index d58922e7b..000000000
--- a/src/syntax/parse.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/syntax
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import * as Types from '../type/index'
-import { Static } from './parsebox/index'
-import { Module } from './runtime'
-import { Main } from './static'
-
-/** `[Syntax]` Infers a TypeBox type from TypeScript syntax. */
-export type StaticParseAsSchema<Context extends Record<PropertyKey, Types.TSchema>, Code extends string> = Static.Parse<Main, Code, Context>[0]
-
-/** `[Syntax]` Infers a TypeScript type from TypeScript syntax. */
-export type StaticParseAsType<Context extends Record<PropertyKey, Types.TSchema>, Code extends string> = StaticParseAsSchema<Context, Code> extends infer Type extends Types.TSchema ? Types.StaticDecode<Type> : undefined
-
-/** `[Syntax]` Parses a TypeBox type from TypeScript syntax. */
-export function Parse<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): StaticParseAsSchema<Context, Code>
-/** `[Syntax]` Parses a TypeBox type from TypeScript syntax. */
-export function Parse<Code extends string>(code: Code, options?: Types.SchemaOptions): StaticParseAsSchema<{}, Code>
-/** `[Syntax]` Parses a TypeBox type from TypeScript syntax. */
-export function Parse(...args: any[]): never {
-  return ParseOnly.apply(null, args as never) as never
-}
-
-/** `[Syntax]` Parses a TypeBox TSchema from TypeScript syntax. This function does not infer the type. */
-export function ParseOnly<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined
-/** `[Syntax]` Parses a TypeBox TSchema from TypeScript syntax */
-export function ParseOnly<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined
-/** `[Syntax]` Parses a TypeBox TSchema from TypeScript syntax. This function does not infer the type. */
-export function ParseOnly(...args: any[]): Types.TSchema | undefined {
-  const withContext = typeof args[0] === 'string' ? false : true
-  const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}]
-  const type = Module.Parse('Main', code, context)[0] as Types.TSchema | undefined
-  // Note: Parsing may return either a ModuleInstance or Type. We only apply options on the Type.
-  return Types.KindGuard.IsSchema(type) ? Types.CloneType(type, options) : type
-}
diff --git a/src/syntax/runtime.ts b/src/syntax/runtime.ts
index 2f5801f20..8a62f2014 100644
--- a/src/syntax/runtime.ts
+++ b/src/syntax/runtime.ts
@@ -26,8 +26,8 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { Runtime } from './parsebox/index'
-import * as Types from '../type/index'
+import { Runtime } from '../parser/index'
+import * as t from '../type/index'
 
 // ------------------------------------------------------------------
 // Tokens
@@ -62,164 +62,40 @@ function DestructureRight<T>(values: T[]): [T[], T | undefined] {
 // ------------------------------------------------------------------
 // Deref
 // ------------------------------------------------------------------
-const Deref = (context: Types.TProperties, key: string): Types.TSchema => {
-  return key in context ? context[key] : Types.Ref(key)
+const Deref = (context: t.TProperties, key: string): t.TSchema => {
+  return key in context ? context[key] : t.Ref(key)
 }
 // ------------------------------------------------------------------
-// ExportModifier
-// ------------------------------------------------------------------
-// prettier-ignore
-const ExportModifierMapping = (values: unknown[]) => {
-  return values.length === 1
-}
-// prettier-ignore
-const ExportModifier = Runtime.Union([
-  Runtime.Tuple([Runtime.Const('export')]), Runtime.Tuple([])
-], ExportModifierMapping)
-
-// ------------------------------------------------------------------
-// TypeAliasDeclaration
-// ------------------------------------------------------------------
-// prettier-ignore
-const TypeAliasDeclarationMapping = (_Export: boolean, _Keyword: 'type', Ident: string, _Equals: typeof Equals, Type: Types.TSchema) => {
-  return { [Ident]: Type }
-}
-// prettier-ignore
-const TypeAliasDeclaration = Runtime.Tuple([
-  Runtime.Ref<boolean>('ExportModifier'), 
-  Runtime.Const('type'), 
-  Runtime.Ident(), 
-  Runtime.Const(Equals), 
-  Runtime.Ref<Types.TSchema>('Type')
-], value => TypeAliasDeclarationMapping(...value))
-
-// ------------------------------------------------------------------
-// HeritageList
-// ------------------------------------------------------------------
-// prettier-ignore (note, heritage list should disallow trailing comma)
-const HeritageListDelimiter = Runtime.Union([Runtime.Tuple([Runtime.Const(Comma), Runtime.Const(Newline)]), Runtime.Tuple([Runtime.Const(Comma)])])
-// prettier-ignore
-const HeritageListMapping = (values: string[], context: Types.TProperties): Types.TSchema[] => {
-  return (
-    values.length === 3 ? [Deref(context, values[0]), ...values[2] as never] :
-    values.length === 1 ? [Deref(context, values[0])] :
-    []
-  ) as never
-}
-// prettier-ignore
-const HeritageList = Runtime.Union([
-  Runtime.Tuple([Runtime.Ident(), HeritageListDelimiter, Runtime.Ref('HeritageList')]),
-  Runtime.Tuple([Runtime.Ident()]),
-  Runtime.Tuple([])
-], HeritageListMapping)
-// ------------------------------------------------------------------
-// Heritage
-// ------------------------------------------------------------------
-// prettier-ignore
-const HeritageMapping = (values: unknown[]): unknown[] => {
-  return (values.length === 2 ? values[1] : []) as never
-}
-// prettier-ignore
-const Heritage = Runtime.Union([
-  Runtime.Tuple([Runtime.Const('extends'), Runtime.Ref('HeritageList')]),
-  Runtime.Tuple([])
-], HeritageMapping)
-// ------------------------------------------------------------------
-// InterfaceDeclaration
-// ------------------------------------------------------------------
-// prettier-ignore
-const InterfaceDeclarationMapping = (_0: boolean, _1: 'interface', Ident: string, Heritage: Types.TRef[], _4: typeof LBrace, Properties: Types.TProperties, _6: typeof RBrace) => {
-  return { [Ident]: Types.Intersect([...Heritage, Types.Object(Properties)]) }
-}
-// prettier-ignore
-const InterfaceDeclaration = Runtime.Tuple([
-  Runtime.Ref<boolean>('ExportModifier'), 
-  Runtime.Const('interface'), 
-  Runtime.Ident(), 
-  Runtime.Ref<Types.TRef[]>('Heritage'), 
-  Runtime.Const(LBrace), 
-  Runtime.Ref<Types.TProperties>('Properties'), 
-  Runtime.Const(RBrace), 
-], values => InterfaceDeclarationMapping(...values))
-
-// ------------------------------------------------------------------
-// ModuleType
-// ------------------------------------------------------------------
-// prettier-ignore
-const ModuleType = Runtime.Union([
-  Runtime.Ref('InterfaceDeclaration'),
-  Runtime.Ref('TypeAliasDeclaration')
-])
-// ------------------------------------------------------------------
-// ModuleProperties
-// ------------------------------------------------------------------
-// prettier-ignore
-const ModulePropertiesDelimiter = Runtime.Union([
-  Runtime.Tuple([Runtime.Const(SemiColon), Runtime.Const(Newline)]),
-  Runtime.Tuple([Runtime.Const(SemiColon)]),
-  Runtime.Tuple([Runtime.Const(Newline)]),
-])
-// prettier-ignore
-const ModulePropertiesMapping = (values: unknown[]): Types.TProperties => {
-  return (
-    values.length === 3 ? { ...values[0] as Types.TProperties, ...values[2] as Types.TProperties }:
-    values.length === 1 ? values[0] as Types.TProperties :
-    {} as Types.TProperties
-  )
-}
-// prettier-ignore
-const ModuleProperties = Runtime.Union([
-  Runtime.Tuple([Runtime.Ref<Types.TProperties>('ModuleType'), ModulePropertiesDelimiter, Runtime.Ref<Types.TProperties>('ModuleProperties')]),
-  Runtime.Tuple([Runtime.Ref<Types.TProperties>('ModuleType')]),
-  Runtime.Tuple([]),
-], ModulePropertiesMapping)
-// ------------------------------------------------------------------
-// ModuleDeclaration
-// ------------------------------------------------------------------
-// prettier-ignore
-const ModuleIdentifier = Runtime.Union([
-  Runtime.Tuple([Runtime.Ident()]),
-  Runtime.Tuple([])
-])
-// prettier-ignore
-const ModuleDeclarationMapping = (_1: boolean, _2: 'module', _Ident: string[], _3: typeof LBrace, Properties: Types.TProperties, _5: typeof RBrace) => {
-  return Types.Module(Properties)
-}
-// prettier-ignore
-const ModuleDeclaration = Runtime.Tuple([
-  Runtime.Ref<boolean>('ExportModifier'), Runtime.Const('module'), ModuleIdentifier, Runtime.Const(LBrace), Runtime.Ref<Types.TProperties>('ModuleProperties'), Runtime.Const(RBrace)
-], values => ModuleDeclarationMapping(...values))
-// ------------------------------------------------------------------
 // Reference
 // ------------------------------------------------------------------
 // prettier-ignore
-const Reference = Runtime.Ident((value, context: Types.TProperties) => Deref(context, value))
+const Reference = Runtime.Ident((value, context: t.TProperties) => Deref(context, value))
 // ------------------------------------------------------------------
 // Literal
 // ------------------------------------------------------------------
 // prettier-ignore
 const Literal = Runtime.Union([
-  Runtime.Union([Runtime.Const('true'), Runtime.Const('false')], value => Types.Literal(value === 'true')),
-  Runtime.Number(value => Types.Literal(parseFloat(value))),
-  Runtime.String([SingleQuote, DoubleQuote, Tilde], value => Types.Literal(value))
+  Runtime.Union([Runtime.Const('true'), Runtime.Const('false')], value => t.Literal(value === 'true')),
+  Runtime.Number(value => t.Literal(parseFloat(value))),
+  Runtime.String([SingleQuote, DoubleQuote, Tilde], value => t.Literal(value))
 ])
 // ------------------------------------------------------------------
 // Keyword
 // ------------------------------------------------------------------
 // prettier-ignore
 const Keyword = Runtime.Union([
-  Runtime.Const('any', Runtime.As(Types.Any())),
-  Runtime.Const('bigint', Runtime.As(Types.BigInt())),
-  Runtime.Const('boolean', Runtime.As(Types.Boolean())),
-  Runtime.Const('integer', Runtime.As(Types.Integer())),
-  Runtime.Const('never', Runtime.As(Types.Never())),
-  Runtime.Const('null', Runtime.As(Types.Null())),
-  Runtime.Const('number', Runtime.As(Types.Number())),
-  Runtime.Const('string', Runtime.As(Types.String())),
-  Runtime.Const('symbol', Runtime.As(Types.Symbol())),
-  Runtime.Const('undefined', Runtime.As(Types.Undefined())),
-  Runtime.Const('unknown', Runtime.As(Types.Unknown())),
-  Runtime.Const('void', Runtime.As(Types.Void())),
+  Runtime.Const('any', Runtime.As(t.Any())),
+  Runtime.Const('bigint', Runtime.As(t.BigInt())),
+  Runtime.Const('boolean', Runtime.As(t.Boolean())),
+  Runtime.Const('integer', Runtime.As(t.Integer())),
+  Runtime.Const('never', Runtime.As(t.Never())),
+  Runtime.Const('null', Runtime.As(t.Null())),
+  Runtime.Const('number', Runtime.As(t.Number())),
+  Runtime.Const('string', Runtime.As(t.String())),
+  Runtime.Const('symbol', Runtime.As(t.Symbol())),
+  Runtime.Const('undefined', Runtime.As(t.Undefined())),
+  Runtime.Const('unknown', Runtime.As(t.Unknown())),
+  Runtime.Const('void', Runtime.As(t.Void())),
 ])
 // ------------------------------------------------------------------
 // KeyOf
@@ -314,54 +190,54 @@ const Base = Runtime.Union([
 // Factor
 // ------------------------------------------------------------------
 // prettier-ignore
-const FactorExtends = (Type: Types.TSchema, Extends: Types.TSchema[]) => {
+const FactorExtends = (Type: t.TSchema, Extends: t.TSchema[]) => {
   return Extends.length === 3
-    ? Types.Extends(Type, Extends[0], Extends[1], Extends[2])
+    ? t.Extends(Type, Extends[0], Extends[1], Extends[2])
     : Type
 }
 // prettier-ignore
-const FactorIndexArray = (Type: Types.TSchema, IndexArray: unknown[]): Types.TSchema => {
-  const [Left, Right] = DestructureRight(IndexArray) as [unknown[], Types.TSchema[]]
+const FactorIndexArray = (Type: t.TSchema, IndexArray: unknown[]): t.TSchema => {
+  const [Left, Right] = DestructureRight(IndexArray) as [unknown[], t.TSchema[]]
   return (
-    !Types.ValueGuard.IsUndefined(Right) ? (
+    !t.ValueGuard.IsUndefined(Right) ? (
       // note: Indexed types require reimplementation to replace `[number]` indexers
-      Right.length === 1 ? Types.Index(FactorIndexArray(Type, Left), Right[0]) as never :
-      Right.length === 0 ? Types.Array(FactorIndexArray(Type, Left)) :
-      Types.Never()
+      Right.length === 1 ? t.Index(FactorIndexArray(Type, Left), Right[0]) as never :
+      Right.length === 0 ? t.Array(FactorIndexArray(Type, Left)) :
+      t.Never()
     ) : Type
   ) 
 }
 // prettier-ignore
-const FactorMapping = (KeyOf: boolean, Type: Types.TSchema, IndexArray: unknown[], Extends: Types.TSchema[]) => {
+const FactorMapping = (KeyOf: boolean, Type: t.TSchema, IndexArray: unknown[], Extends: t.TSchema[]) => {
   return KeyOf
-    ? FactorExtends(Types.KeyOf(FactorIndexArray(Type, IndexArray)), Extends)
+    ? FactorExtends(t.KeyOf(FactorIndexArray(Type, IndexArray)), Extends)
     : FactorExtends(FactorIndexArray(Type, IndexArray), Extends)
 }
 // prettier-ignore
 const Factor = Runtime.Tuple([
   Runtime.Ref<boolean>('KeyOf'), 
-  Runtime.Ref<Types.TSchema>('Base'),
+  Runtime.Ref<t.TSchema>('Base'),
   Runtime.Ref<unknown[]>('IndexArray'),
-  Runtime.Ref<Types.TSchema[]>('Extends')
+  Runtime.Ref<t.TSchema[]>('Extends')
 ], values => FactorMapping(...values))
 // ------------------------------------------------------------------
 // Expr
 // ------------------------------------------------------------------
 // prettier-ignore
-function ExprBinaryMapping(Left: Types.TSchema, Rest: unknown[]): Types.TSchema {
+function ExprBinaryMapping(Left: t.TSchema, Rest: unknown[]): t.TSchema {
   return (
     Rest.length === 3 ? (() => {
-      const [Operator, Right, Next] = Rest as [string, Types.TSchema, unknown[]]
+      const [Operator, Right, Next] = Rest as [string, t.TSchema, unknown[]]
       const Schema = ExprBinaryMapping(Right, Next)
       if (Operator === '&') {
-        return Types.TypeGuard.IsIntersect(Schema)
-          ? Types.Intersect([Left, ...Schema.allOf])
-          : Types.Intersect([Left, Schema])
+        return t.TypeGuard.IsIntersect(Schema)
+          ? t.Intersect([Left, ...Schema.allOf])
+          : t.Intersect([Left, Schema])
       }
       if (Operator === '|') {
-        return Types.TypeGuard.IsUnion(Schema)
-          ? Types.Union([Left, ...Schema.anyOf])
-          : Types.Union([Left, Schema])
+        return t.TypeGuard.IsUnion(Schema)
+          ? t.Union([Left, ...Schema.anyOf])
+          : t.Union([Left, Schema])
       }
       throw 1
     })() : Left
@@ -374,7 +250,7 @@ const ExprTermTail = Runtime.Union([
 ])
 // prettier-ignore
 const ExprTerm = Runtime.Tuple([
-  Runtime.Ref<Types.TSchema>('Factor'), Runtime.Ref<unknown[]>('ExprTermTail')
+  Runtime.Ref<t.TSchema>('Factor'), Runtime.Ref<unknown[]>('ExprTermTail')
 ], value => ExprBinaryMapping(...value))
 // prettier-ignore
 const ExprTail = Runtime.Union([
@@ -383,7 +259,7 @@ const ExprTail = Runtime.Union([
 ])
 // prettier-ignore
 const Expr = Runtime.Tuple([
-  Runtime.Ref<Types.TSchema>('ExprTerm'), Runtime.Ref<unknown[]>('ExprTail')
+  Runtime.Ref<t.TSchema>('ExprTerm'), Runtime.Ref<unknown[]>('ExprTail')
 ], value => ExprBinaryMapping(...value))
 
 // ------------------------------------------------------------------
@@ -397,11 +273,11 @@ const PropertyKey = Runtime.Union([Runtime.Ident(), Runtime.String([SingleQuote,
 const Readonly = Runtime.Union([Runtime.Tuple([Runtime.Const('readonly')]), Runtime.Tuple([])], (value) => value.length > 0)
 const Optional = Runtime.Union([Runtime.Tuple([Runtime.Const(Question)]), Runtime.Tuple([])], (value) => value.length > 0)
 // prettier-ignore
-const PropertyMapping = (IsReadonly: boolean, Key: string, IsOptional: boolean, _: typeof Colon, Type: Types.TSchema) => ({
+const PropertyMapping = (IsReadonly: boolean, Key: string, IsOptional: boolean, _: typeof Colon, Type: t.TSchema) => ({
   [Key]: (
-    IsReadonly && IsOptional ? Types.ReadonlyOptional(Type) :
-    IsReadonly && !IsOptional ? Types.Readonly(Type) :
-    !IsReadonly && IsOptional ? Types.Optional(Type) :
+    IsReadonly && IsOptional ? t.ReadonlyOptional(Type) :
+    IsReadonly && !IsOptional ? t.Readonly(Type) :
+    !IsReadonly && IsOptional ? t.Optional(Type) :
     Type
   )
 })
@@ -411,7 +287,7 @@ const Property = Runtime.Tuple([
   Runtime.Ref<string>('PropertyKey'),
   Runtime.Ref<boolean>('Optional'),
   Runtime.Const(Colon),
-  Runtime.Ref<Types.TSchema>('Type'),
+  Runtime.Ref<t.TSchema>('Type'),
 ], value => PropertyMapping(...value))
 // prettier-ignore
 const PropertyDelimiter = Runtime.Union([
@@ -423,9 +299,9 @@ const PropertyDelimiter = Runtime.Union([
 ])
 // prettier-ignore
 const Properties = Runtime.Union([
-  Runtime.Tuple([Runtime.Ref<Types.TProperties>('Property'), Runtime.Ref('PropertyDelimiter'), Runtime.Ref<Types.TProperties>('Properties')]),
-  Runtime.Tuple([Runtime.Ref<Types.TProperties>('Property'), Runtime.Ref('PropertyDelimiter')]),
-  Runtime.Tuple([Runtime.Ref<Types.TProperties>('Property')]),
+  Runtime.Tuple([Runtime.Ref<t.TProperties>('Property'), Runtime.Ref('PropertyDelimiter'), Runtime.Ref<t.TProperties>('Properties')]),
+  Runtime.Tuple([Runtime.Ref<t.TProperties>('Property'), Runtime.Ref('PropertyDelimiter')]),
+  Runtime.Tuple([Runtime.Ref<t.TProperties>('Property')]),
   Runtime.Tuple([])
 ], values => (
   values.length === 3 ? { ...values[0], ...values[2] } :
@@ -437,11 +313,11 @@ const Properties = Runtime.Union([
 // Object
 // ------------------------------------------------------------------
 // prettier-ignore
-const ObjectMapping = (_0: typeof LBrace, Properties: Types.TProperties, _2: typeof RBrace) => Types.Object(Properties)
+const ObjectMapping = (_0: typeof LBrace, Properties: t.TProperties, _2: typeof RBrace) => t.Object(Properties)
 // prettier-ignore
 const _Object = Runtime.Tuple([
   Runtime.Const(LBrace),
-  Runtime.Ref<Types.TProperties>('Properties'),
+  Runtime.Ref<t.TProperties>('Properties'),
   Runtime.Const(RBrace)
 ], values => ObjectMapping(...values))
 
@@ -463,16 +339,16 @@ const Elements = Runtime.Union([
 // prettier-ignore
 const Tuple = Runtime.Tuple([
   Runtime.Const(LBracket),
-  Runtime.Ref<Types.TSchema[]>('Elements'),
+  Runtime.Ref<t.TSchema[]>('Elements'),
   Runtime.Const(RBracket)
-], value => Types.Tuple(value[1]))
+], value => t.Tuple(value[1]))
 
 // ------------------------------------------------------------------
 // Parameters
 // ------------------------------------------------------------------
 // prettier-ignore
 const Parameter = Runtime.Tuple([
-  Runtime.Ident(), Runtime.Const(Colon), Runtime.Ref<Types.TSchema>('Type')
+  Runtime.Ident(), Runtime.Const(Colon), Runtime.Ref<t.TSchema>('Type')
 ], value => value[2])
 // prettier-ignore
 const Parameters = Runtime.Union([
@@ -493,28 +369,28 @@ const Parameters = Runtime.Union([
 const Constructor = Runtime.Tuple([
   Runtime.Const('new'), 
   Runtime.Const(LParen), 
-  Runtime.Ref<Types.TSchema[]>('Parameters'), 
+  Runtime.Ref<t.TSchema[]>('Parameters'), 
   Runtime.Const(RParen), 
   Runtime.Const('=>'), 
-  Runtime.Ref<Types.TSchema>('Type')
-], value => Types.Constructor(value[2], value[5]))
+  Runtime.Ref<t.TSchema>('Type')
+], value => t.Constructor(value[2], value[5]))
 // ------------------------------------------------------------------
 // Function
 // ------------------------------------------------------------------
 // prettier-ignore
 const Function = Runtime.Tuple([
   Runtime.Const(LParen), 
-  Runtime.Ref<Types.TSchema[]>('Parameters'), 
+  Runtime.Ref<t.TSchema[]>('Parameters'), 
   Runtime.Const(RParen), 
   Runtime.Const('=>'), 
-  Runtime.Ref<Types.TSchema>('Type')
-], value => Types.Function(value[1], value[4]))
+  Runtime.Ref<t.TSchema>('Type')
+], value => t.Function(value[1], value[4]))
 // ------------------------------------------------------------------
 // Mapped (requires deferred types)
 // ------------------------------------------------------------------
 // prettier-ignore
 const MappedMapping = (values: unknown[]) => {
-  return Types.Literal('Mapped types not supported')
+  return t.Literal('Mapped types not supported')
 }
 // prettier-ignore
 const Mapped = Runtime.Tuple([
@@ -522,10 +398,10 @@ const Mapped = Runtime.Tuple([
   Runtime.Const(LBracket), 
   Runtime.Ident(), 
   Runtime.Const('in'), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RBracket), 
   Runtime.Const(Colon), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RBrace)
 ], MappedMapping)
 // ------------------------------------------------------------------
@@ -535,9 +411,9 @@ const Mapped = Runtime.Tuple([
 const AsyncIterator = Runtime.Tuple([
   Runtime.Const('AsyncIterator'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),
-], value => Types.AsyncIterator(value[2]))
+], value => t.AsyncIterator(value[2]))
 // ------------------------------------------------------------------
 // Iterator
 // ------------------------------------------------------------------
@@ -545,9 +421,9 @@ const AsyncIterator = Runtime.Tuple([
 const Iterator = Runtime.Tuple([
   Runtime.Const('Iterator'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),
-], value => Types.Iterator(value[2]))
+], value => t.Iterator(value[2]))
 // ------------------------------------------------------------------
 // ConstructorParameters
 // ------------------------------------------------------------------
@@ -555,9 +431,9 @@ const Iterator = Runtime.Tuple([
 const ConstructorParameters = Runtime.Tuple([
   Runtime.Const('ConstructorParameters'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TConstructor>('Type'), 
+  Runtime.Ref<t.TConstructor>('Type'), 
   Runtime.Const(RAngle),
-], value => Types.ConstructorParameters(value[2]))
+], value => t.ConstructorParameters(value[2]))
 // ------------------------------------------------------------------
 // Parameters
 // ------------------------------------------------------------------
@@ -565,9 +441,9 @@ const ConstructorParameters = Runtime.Tuple([
 const FunctionParameters = Runtime.Tuple([
   Runtime.Const('Parameters'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TFunction>('Type'), 
+  Runtime.Ref<t.TFunction>('Type'), 
   Runtime.Const(RAngle),
-], value => Types.Parameters(value[2]))
+], value => t.Parameters(value[2]))
 // ------------------------------------------------------------------
 // InstanceType
 // ------------------------------------------------------------------
@@ -575,9 +451,9 @@ const FunctionParameters = Runtime.Tuple([
 const InstanceType = Runtime.Tuple([
   Runtime.Const('InstanceType'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TConstructor>('Type'), 
+  Runtime.Ref<t.TConstructor>('Type'), 
   Runtime.Const(RAngle),
-], value => Types.InstanceType(value[2]))
+], value => t.InstanceType(value[2]))
 // ------------------------------------------------------------------
 // ReturnType
 // ------------------------------------------------------------------
@@ -585,9 +461,9 @@ const InstanceType = Runtime.Tuple([
 const ReturnType = Runtime.Tuple([
   Runtime.Const('ReturnType'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TFunction>('Type'), 
+  Runtime.Ref<t.TFunction>('Type'), 
   Runtime.Const(RAngle),
-], value => Types.ReturnType(value[2]))
+], value => t.ReturnType(value[2]))
 // ------------------------------------------------------------------
 // Awaited
 // ------------------------------------------------------------------
@@ -595,9 +471,9 @@ const ReturnType = Runtime.Tuple([
 const Awaited = Runtime.Tuple([
   Runtime.Const('Awaited'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),
-], value => Types.Awaited(value[2]))
+], value => t.Awaited(value[2]))
 // ------------------------------------------------------------------
 // Array
 // ------------------------------------------------------------------
@@ -605,9 +481,9 @@ const Awaited = Runtime.Tuple([
 const Array = Runtime.Tuple([
   Runtime.Const('Array'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),
-], value => Types.Array(value[2]))
+], value => t.Array(value[2]))
 // ------------------------------------------------------------------
 // Record
 // ------------------------------------------------------------------
@@ -615,11 +491,11 @@ const Array = Runtime.Tuple([
 const Record = Runtime.Tuple([
   Runtime.Const('Record'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TSchema>('Type'),
+  Runtime.Ref<t.TSchema>('Type'),
   Runtime.Const(Comma), 
-  Runtime.Ref<Types.TSchema>('Type'),
+  Runtime.Ref<t.TSchema>('Type'),
   Runtime.Const(RAngle),  
-], value => Types.Record(value[2], value[4]))
+], value => t.Record(value[2], value[4]))
 // ------------------------------------------------------------------
 // Promise
 // ------------------------------------------------------------------
@@ -627,9 +503,9 @@ const Record = Runtime.Tuple([
 const Promise = Runtime.Tuple([
   Runtime.Const('Promise'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => Types.Promise(value[2]))
+], value => t.Promise(value[2]))
 // ------------------------------------------------------------------
 // Partial
 // ------------------------------------------------------------------
@@ -637,9 +513,9 @@ const Promise = Runtime.Tuple([
 const Partial = Runtime.Tuple([
   Runtime.Const('Partial'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => Types.Partial(value[2]))
+], value => t.Partial(value[2]))
 // ------------------------------------------------------------------
 // Required
 // ------------------------------------------------------------------
@@ -647,9 +523,9 @@ const Partial = Runtime.Tuple([
 const Required = Runtime.Tuple([
   Runtime.Const('Required'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => Types.Required(value[2]))
+], value => t.Required(value[2]))
 // ------------------------------------------------------------------
 // Pick
 // ------------------------------------------------------------------
@@ -657,11 +533,11 @@ const Required = Runtime.Tuple([
 const Pick = Runtime.Tuple([
   Runtime.Const('Pick'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(Comma), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => Types.Pick(value[2], value[4]))
+], value => t.Pick(value[2], value[4]))
 // ------------------------------------------------------------------
 // Omit
 // ------------------------------------------------------------------
@@ -669,11 +545,11 @@ const Pick = Runtime.Tuple([
 const Omit = Runtime.Tuple([
   Runtime.Const('Omit'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(Comma), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => Types.Omit(value[2], value[4]))
+], value => t.Omit(value[2], value[4]))
 // ------------------------------------------------------------------
 // Exclude
 // ------------------------------------------------------------------
@@ -681,11 +557,11 @@ const Omit = Runtime.Tuple([
 const Exclude = Runtime.Tuple([
   Runtime.Const('Exclude'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(Comma), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => Types.Exclude(value[2], value[4]))
+], value => t.Exclude(value[2], value[4]))
 // ------------------------------------------------------------------
 // Extract
 // ------------------------------------------------------------------
@@ -693,11 +569,11 @@ const Exclude = Runtime.Tuple([
 const Extract = Runtime.Tuple([
   Runtime.Const('Extract'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(Comma), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => Types.Extract(value[2], value[4]))
+], value => t.Extract(value[2], value[4]))
 // ------------------------------------------------------------------
 // Uppercase
 // ------------------------------------------------------------------
@@ -705,9 +581,9 @@ const Extract = Runtime.Tuple([
 const Uppercase = Runtime.Tuple([
   Runtime.Const('Uppercase'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => Types.Uppercase(value[2]))
+], value => t.Uppercase(value[2]))
 // ------------------------------------------------------------------
 // Lowercase
 // ------------------------------------------------------------------
@@ -715,9 +591,9 @@ const Uppercase = Runtime.Tuple([
 const Lowercase = Runtime.Tuple([
   Runtime.Const('Lowercase'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => Types.Lowercase(value[2]))
+], value => t.Lowercase(value[2]))
 // ------------------------------------------------------------------
 // Capitalize
 // ------------------------------------------------------------------
@@ -725,9 +601,9 @@ const Lowercase = Runtime.Tuple([
 const Capitalize = Runtime.Tuple([
   Runtime.Const('Capitalize'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => Types.Capitalize(value[2]))
+], value => t.Capitalize(value[2]))
 // ------------------------------------------------------------------
 // Uncapitalize
 // ------------------------------------------------------------------
@@ -735,45 +611,22 @@ const Capitalize = Runtime.Tuple([
 const Uncapitalize = Runtime.Tuple([
   Runtime.Const('Uncapitalize'), 
   Runtime.Const(LAngle), 
-  Runtime.Ref<Types.TSchema>('Type'), 
+  Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => Types.Uncapitalize(value[2]))
+], value => t.Uncapitalize(value[2]))
 // ------------------------------------------------------------------
 // Date
 // ------------------------------------------------------------------
-const Date = Runtime.Const('Date', Runtime.As(Types.Date()))
+const Date = Runtime.Const('Date', Runtime.As(t.Date()))
 // ------------------------------------------------------------------
 // Uint8Array
 // ------------------------------------------------------------------
-const Uint8Array = Runtime.Const('Uint8Array', Runtime.As(Types.Uint8Array()))
-
-// ------------------------------------------------------------------
-// Main
-// ------------------------------------------------------------------
-// prettier-ignore
-const Main = Runtime.Union([
-  ModuleDeclaration,
-  TypeAliasDeclaration,
-  InterfaceDeclaration,
-  Type
-])
+const Uint8Array = Runtime.Const('Uint8Array', Runtime.As(t.Uint8Array()))
 // ------------------------------------------------------------------
 // Module
 // ------------------------------------------------------------------
 // prettier-ignore
 export const Module = new Runtime.Module({
-  // ----------------------------------------------------------------
-  // Modules, Interfaces and Type Aliases
-  // ----------------------------------------------------------------
-  ExportModifier,
-  HeritageList,
-  Heritage,
-  InterfaceDeclaration,
-  TypeAliasDeclaration,
-  ModuleType,
-  ModuleProperties,
-  ModuleDeclaration,
-
   // ----------------------------------------------------------------
   // Type Expressions
   // ----------------------------------------------------------------
@@ -826,9 +679,4 @@ export const Module = new Runtime.Module({
   Date,
   Uint8Array,
   Reference,
-
-  // ----------------------------------------------------------------
-  // Main
-  // ----------------------------------------------------------------
-  Main
 })
diff --git a/src/syntax/static.ts b/src/syntax/static.ts
index 9d8bb0a38..4cd125565 100644
--- a/src/syntax/static.ts
+++ b/src/syntax/static.ts
@@ -26,8 +26,8 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { Static } from './parsebox/index'
-import * as Types from '../type/index'
+import { Static } from '../parser/index'
+import * as t from '../type/index'
 
 // ------------------------------------------------------------------
 // Tokens
@@ -139,147 +139,15 @@ type Delimit<Parser extends Static.IParser, Delimiter extends Static.IParser> =
 // Deref
 // ------------------------------------------------------------------
 // prettier-ignore
-type Deref<Context extends Types.TProperties, Ref extends string> = (
-  Ref extends keyof Context ? Context[Ref] : Types.TRef<Ref>
+type Deref<Context extends t.TProperties, Ref extends string> = (
+  Ref extends keyof Context ? Context[Ref] : t.TRef<Ref>
 )
 // ------------------------------------------------------------------
-// ExportModifier
-// ------------------------------------------------------------------
-// prettier-ignore
-interface ExportModifierMapping extends Static.IMapping {
-  output: this['input'] extends [string] ? true : false
-}
-// prettier-ignore
-type ExportModifier = Static.Union<[
-  Static.Tuple<[Static.Const<'export'>]>,
-  Static.Tuple<[]>,
-], ExportModifierMapping>
-
-// ------------------------------------------------------------------
-// TypeAliasDeclaration
-// ------------------------------------------------------------------
-// prettier-ignore
-interface TypeAliasDeclarationMapping extends Static.IMapping {
-  output: this['input'] extends [infer _Export extends boolean, 'type', infer Ident extends string, Equals, infer Type extends Types.TSchema] 
-    ? { [_ in Ident]: Type } 
-    : never
-}
-// prettier-ignore
-type TypeAliasDeclaration = Static.Tuple<[
-  ExportModifier, Static.Const<'type'>, Static.Ident, Static.Const<Equals>, Type
-], TypeAliasDeclarationMapping>
-
-// ------------------------------------------------------------------
-// HeritageList
-// ------------------------------------------------------------------
-// prettier-ignore (note, heritage list should disallow trailing comma)
-type HeritageListDelimiter = Static.Union<[Static.Tuple<[Static.Const<Comma>, Static.Const<Newline>]>, Static.Tuple<[Static.Const<Comma>]>]>
-// prettier-ignore
-type HeritageListReduce<Values extends string[], Context extends Types.TProperties, Result extends Types.TSchema[] = []> = (
-  Values extends [infer Ref extends string, ...infer Rest extends string[]]
-    ? HeritageListReduce<Rest, Context, [...Result, Deref<Context, Ref>]>
-    : Result
-)
-// prettier-ignore
-interface HeritageListMapping extends Static.IMapping {
-  output: (
-    this['context'] extends Types.TProperties ?
-    this['input'] extends string[] 
-      ? HeritageListReduce<this['input'], this['context']> 
-      : []
-    : []
-  )
-}
-// prettier-ignore
-type HeritageList = Static.Union<[Delimit<Static.Ident, HeritageListDelimiter>], HeritageListMapping>
-// ------------------------------------------------------------------
-// Heritage
-// ------------------------------------------------------------------
-// prettier-ignore
-interface HeritageMapping extends Static.IMapping {
-  output: this['input'] extends ['extends', infer List extends Types.TSchema[]] ? List : []
-}
-// prettier-ignore
-type Heritage = Static.Union<[
-  Static.Tuple<[Static.Const<'extends'>, HeritageList]>,
-  Static.Tuple<[]>
-], HeritageMapping>
-// ------------------------------------------------------------------
-// InterfaceDeclaration
-// ------------------------------------------------------------------
-// prettier-ignore
-interface InterfaceDeclarationMapping extends Static.IMapping {
-  output: this['input'] extends [boolean, 'interface', infer Ident extends string, infer Heritage extends Types.TSchema[], LBrace, infer Properties extends Types.TProperties, RBrace]
-    ? { [_ in Ident]: Types.TIntersectEvaluated<[...Heritage, Types.TObject<Properties>]> }
-    : never
-}
-// prettier-ignore
-type InterfaceDeclaration = Static.Tuple<[
-  ExportModifier,
-  Static.Const<'interface'>, 
-  Static.Ident, 
-  Heritage,
-  Static.Const<LBrace>, 
-  Properties,
-  Static.Const<RBrace>, 
-], InterfaceDeclarationMapping>
-// ------------------------------------------------------------------
-// ModuleType
-// ------------------------------------------------------------------
-// prettier-ignore
-type ModuleType = Static.Union<[
-  InterfaceDeclaration,
-  TypeAliasDeclaration
-]>
-// ------------------------------------------------------------------
-// ModuleProperties
-// ------------------------------------------------------------------
-// prettier-ignore
-type ModulePropertiesDelimiter = Static.Union<[
-  Static.Tuple<[Static.Const<SemiColon>, Static.Const<Newline>]>,
-  Static.Tuple<[Static.Const<SemiColon>]>,
-  Static.Tuple<[Static.Const<Newline>]>,
-]>
-// prettier-ignore
-type ModulePropertiesReduce<Value extends unknown[], Result extends Types.TProperties = {}> = (
-  Value extends [infer ModuleType extends Types.TProperties, unknown[], ...infer Rest extends unknown[]] ? ModulePropertiesReduce<Rest, Result & ModuleType> :
-  Value extends [infer ModuleType extends Types.TProperties] ? ModulePropertiesReduce<[], Result & ModuleType> : 
-  Types.Evaluate<Result>
-)
-// prettier-ignore
-interface ModulePropertiesMapping extends Static.IMapping {
-  output: this['input'] extends unknown[] ? ModulePropertiesReduce<this['input']> : never
-}
-// prettier-ignore
-type ModuleProperties = Static.Union<[
-  Static.Tuple<[ModuleType, ModulePropertiesDelimiter, ModuleProperties]>,
-  Static.Tuple<[ModuleType]>,
-  Static.Tuple<[]>,
-], ModulePropertiesMapping>
-// ------------------------------------------------------------------
-// ModuleDeclaration
-// ------------------------------------------------------------------
-// prettier-ignore
-type ModuleIdentifier = Static.Union<[
-  Static.Tuple<[Static.Ident]>,
-  Static.Tuple<[]>
-]>
-// prettier-ignore
-interface ModuleDeclarationMapping extends Static.IMapping {
-  output: this['input'] extends [boolean, 'module', infer _Ident extends string[], LBrace, infer Properties extends Types.TProperties, RBrace] 
-    ? Types.TModule<Properties> 
-    : never
-}
-// prettier-ignore
-type ModuleDeclaration = Static.Tuple<[
-  ExportModifier, Static.Const<'module'>, ModuleIdentifier, Static.Const<LBrace>, ModuleProperties, Static.Const<RBrace>
-], ModuleDeclarationMapping>
-// ------------------------------------------------------------------
 // Reference
 // ------------------------------------------------------------------
 // prettier-ignore
 interface ReferenceMapping extends Static.IMapping {
-  output: this['context'] extends Types.TProperties
+  output: this['context'] extends t.TProperties
     ? this['input'] extends string
       ? Deref<this['context'], this['input']>
       : never
@@ -291,15 +159,15 @@ type Reference = Static.Ident<ReferenceMapping>
 // ------------------------------------------------------------------
 // prettier-ignore
 interface LiteralBooleanMapping extends Static.IMapping {
-  output: this['input'] extends `${infer S extends boolean}` ? Types.TLiteral<S> : never
+  output: this['input'] extends `${infer S extends boolean}` ? t.TLiteral<S> : never
 }
 // prettier-ignore
 interface LiteralNumberMapping extends Static.IMapping {
-  output: this['input'] extends `${infer S extends number}` ? Types.TLiteral<S> : never
+  output: this['input'] extends `${infer S extends number}` ? t.TLiteral<S> : never
 }
 // prettier-ignore
 interface LiteralStringMapping extends Static.IMapping {
-  output: this['input'] extends `${infer S extends string}` ? Types.TLiteral<S> : never
+  output: this['input'] extends `${infer S extends string}` ? t.TLiteral<S> : never
 }
 // prettier-ignore
 type Literal = Static.Union<[
@@ -312,18 +180,18 @@ type Literal = Static.Union<[
 // ------------------------------------------------------------------
 // prettier-ignore
 type Keyword = Static.Union<[
-  Static.Const<'any', Static.As<Types.TAny>>,
-  Static.Const<'bigint', Static.As<Types.TBigInt>>,
-  Static.Const<'boolean', Static.As<Types.TBoolean>>,
-  Static.Const<'integer', Static.As<Types.TInteger>>,
-  Static.Const<'never', Static.As<Types.TNever>>,
-  Static.Const<'null', Static.As<Types.TNull>>,
-  Static.Const<'number', Static.As<Types.TNumber>>,
-  Static.Const<'string', Static.As<Types.TString>>,
-  Static.Const<'symbol', Static.As<Types.TSymbol>>,
-  Static.Const<'undefined', Static.As<Types.TUndefined>>,
-  Static.Const<'unknown', Static.As<Types.TUnknown>>,
-  Static.Const<'void', Static.As<Types.TVoid>>,
+  Static.Const<'any', Static.As<t.TAny>>,
+  Static.Const<'bigint', Static.As<t.TBigInt>>,
+  Static.Const<'boolean', Static.As<t.TBoolean>>,
+  Static.Const<'integer', Static.As<t.TInteger>>,
+  Static.Const<'never', Static.As<t.TNever>>,
+  Static.Const<'null', Static.As<t.TNull>>,
+  Static.Const<'number', Static.As<t.TNumber>>,
+  Static.Const<'string', Static.As<t.TString>>,
+  Static.Const<'symbol', Static.As<t.TSymbol>>,
+  Static.Const<'undefined', Static.As<t.TUndefined>>,
+  Static.Const<'unknown', Static.As<t.TUnknown>>,
+  Static.Const<'void', Static.As<t.TVoid>>,
 ]>
 // ------------------------------------------------------------------
 // KeyOf
@@ -343,7 +211,7 @@ type KeyOf = Static.Union<[
 // prettier-ignore
 interface IndexArrayMapping extends Static.IMapping {
   output: (
-    this['input'] extends [LBracket, infer Type extends Types.TSchema, RBracket, infer Rest extends unknown[]] ? [[Type], ...Rest] :
+    this['input'] extends [LBracket, infer Type extends t.TSchema, RBracket, infer Rest extends unknown[]] ? [[Type], ...Rest] :
     this['input'] extends [LBracket, RBracket, infer Rest extends unknown[]] ? [[], ...Rest] :
     []
   )
@@ -360,7 +228,7 @@ type IndexArray = Static.Union<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface ExtendsMapping extends Static.IMapping {
-  output: this['input'] extends ['extends', infer Type extends Types.TSchema, Question, infer True extends Types.TSchema, Colon, infer False extends Types.TSchema]
+  output: this['input'] extends ['extends', infer Type extends t.TSchema, Question, infer True extends t.TSchema, Colon, infer False extends t.TSchema]
     ? [Type, True, False]
     : []
 }
@@ -375,8 +243,8 @@ type Extends = Static.Union<[
 // prettier-ignore
 interface BaseMapping extends Static.IMapping {
   output: (
-    this['input'] extends [LParen, infer Type extends Types.TSchema, RParen] ? Type :
-    this['input'] extends [infer Type extends Types.TSchema] ? Type :
+    this['input'] extends [LParen, infer Type extends t.TSchema, RParen] ? Type :
+    this['input'] extends [infer Type extends t.TSchema] ? Type :
     never
   )
 }
@@ -424,24 +292,24 @@ type Base = Static.Union<[
 // Factor
 // ------------------------------------------------------------------
 // prettier-ignore
-type FactorExtends<Type extends Types.TSchema, Extends extends unknown[]> = (
-  Extends extends [infer Right extends Types.TSchema, infer True extends Types.TSchema, infer False extends Types.TSchema] 
-    ? Types.TExtends<Type, Right, True, False>
+type FactorExtends<Type extends t.TSchema, Extends extends unknown[]> = (
+  Extends extends [infer Right extends t.TSchema, infer True extends t.TSchema, infer False extends t.TSchema] 
+    ? t.TExtends<Type, Right, True, False>
     : Type
 )
 // prettier-ignore
-type FactorIndexArray<Type extends Types.TSchema, IndexArray extends unknown[]> = (
-  IndexArray extends [...infer Left extends unknown[], infer Right extends Types.TSchema[]] ? (
-    Right extends [infer Indexer extends Types.TSchema] ? Types.TIndex<FactorIndexArray<Type, Left>, Types.TIndexPropertyKeys<Indexer>> : 
-    Right extends [] ? Types.TArray<FactorIndexArray<Type, Left>> :
-    Types.TNever
+type FactorIndexArray<Type extends t.TSchema, IndexArray extends unknown[]> = (
+  IndexArray extends [...infer Left extends unknown[], infer Right extends t.TSchema[]] ? (
+    Right extends [infer Indexer extends t.TSchema] ? t.TIndex<FactorIndexArray<Type, Left>, t.TIndexPropertyKeys<Indexer>> : 
+    Right extends [] ? t.TArray<FactorIndexArray<Type, Left>> :
+    t.TNever
   ) : Type
 )
 // prettier-ignore
 interface FactorMapping extends Static.IMapping {
-  output: this['input'] extends [infer KeyOf extends boolean, infer Type extends Types.TSchema, infer IndexArray extends unknown[], infer Extends extends unknown[]]
+  output: this['input'] extends [infer KeyOf extends boolean, infer Type extends t.TSchema, infer IndexArray extends unknown[], infer Extends extends unknown[]]
   ? KeyOf extends true
-    ? FactorExtends<Types.TKeyOf<FactorIndexArray<Type, IndexArray>>, Extends>
+    ? FactorExtends<t.TKeyOf<FactorIndexArray<Type, IndexArray>>, Extends>
     : FactorExtends<FactorIndexArray<Type, IndexArray>, Extends>
   : never
 }
@@ -453,18 +321,18 @@ type Factor = Static.Tuple<[
 // Expr
 // ------------------------------------------------------------------
 // prettier-ignore
-type ExprBinaryReduce<Left extends Types.TSchema, Rest extends unknown[]> = (
-  Rest extends [infer Operator extends unknown, infer Right extends Types.TSchema, infer Next extends unknown[]] ? (
-    ExprBinaryReduce<Right, Next> extends infer Schema extends Types.TSchema ? (
+type ExprBinaryReduce<Left extends t.TSchema, Rest extends unknown[]> = (
+  Rest extends [infer Operator extends unknown, infer Right extends t.TSchema, infer Next extends unknown[]] ? (
+    ExprBinaryReduce<Right, Next> extends infer Schema extends t.TSchema ? (
       Operator extends '&' ? (
-        Schema extends Types.TIntersect<infer Types extends Types.TSchema[]>
-        ? Types.TIntersect<[Left, ...Types]>
-        : Types.TIntersect<[Left, Schema]>
+        Schema extends t.TIntersect<infer Types extends t.TSchema[]>
+        ? t.TIntersect<[Left, ...Types]>
+        : t.TIntersect<[Left, Schema]>
       ) :
       Operator extends '|' ? (
-        Schema extends Types.TUnion<infer Types extends Types.TSchema[]>
-        ? Types.TUnion<[Left, ...Types]>
-        : Types.TUnion<[Left, Schema]>
+        Schema extends t.TUnion<infer Types extends t.TSchema[]>
+        ? t.TUnion<[Left, ...Types]>
+        : t.TUnion<[Left, Schema]>
       ) : never
     ) : never
   ) : Left
@@ -472,7 +340,7 @@ type ExprBinaryReduce<Left extends Types.TSchema, Rest extends unknown[]> = (
 // prettier-ignore
 interface ExprBinaryMapping extends Static.IMapping {
   output: (
-    this['input'] extends [infer Left extends Types.TSchema, infer Rest extends unknown[]]
+    this['input'] extends [infer Left extends t.TSchema, infer Rest extends unknown[]]
     ? ExprBinaryReduce<Left, Rest>
     : []
   )
@@ -498,7 +366,7 @@ type Expr = Static.Tuple<[
 // ------------------------------------------------------------------
 // Type
 // ------------------------------------------------------------------
-type Type = Expr
+export type Type = Expr
 // ------------------------------------------------------------------
 // Properties
 // ------------------------------------------------------------------
@@ -520,12 +388,12 @@ interface OptionalMapping extends Static.IMapping {
 type Optional = Static.Union<[Static.Tuple<[Static.Const<Question>]>, Static.Tuple<[]>], OptionalMapping>
 // prettier-ignore
 interface PropertyMapping extends Static.IMapping {
-  output: this['input'] extends [infer IsReadonly extends boolean, infer Key extends string, infer IsOptional extends boolean, string, infer Type extends Types.TSchema]
+  output: this['input'] extends [infer IsReadonly extends boolean, infer Key extends string, infer IsOptional extends boolean, string, infer Type extends t.TSchema]
   ? { 
     [_ in Key]: (
-      [IsReadonly, IsOptional] extends [true, true] ? Types.TReadonlyOptional<Type> :
-      [IsReadonly, IsOptional] extends [true, false] ? Types.TReadonly<Type> :
-      [IsReadonly, IsOptional] extends [false, true] ? Types.TOptional<Type> :
+      [IsReadonly, IsOptional] extends [true, true] ? t.TReadonlyOptional<Type> :
+      [IsReadonly, IsOptional] extends [true, false] ? t.TReadonly<Type> :
+      [IsReadonly, IsOptional] extends [false, true] ? t.TOptional<Type> :
       Type 
     ) 
   } : never
@@ -540,14 +408,14 @@ type PropertyDelimiter = Static.Union<[
   Static.Tuple<[Static.Const<Newline>]>,
 ]>
 // prettier-ignore
-type PropertiesReduce<PropertiesArray extends Types.TProperties[], Result extends Types.TProperties = {}> = (
-  PropertiesArray extends [infer Left extends Types.TProperties, ...infer Right extends Types.TProperties[]]
-  ? PropertiesReduce<Right, Types.Evaluate<Result & Left>>
+type PropertiesReduce<PropertiesArray extends t.TProperties[], Result extends t.TProperties = {}> = (
+  PropertiesArray extends [infer Left extends t.TProperties, ...infer Right extends t.TProperties[]]
+  ? PropertiesReduce<Right, t.Evaluate<Result & Left>>
   : Result
 )
 // prettier-ignore
 interface PropertiesMapping extends Static.IMapping {
-  output: this['input'] extends Types.TProperties[] ? PropertiesReduce<this['input']> : never
+  output: this['input'] extends t.TProperties[] ? PropertiesReduce<this['input']> : never
 }
 type Properties = Static.Union<[Delimit<Property, PropertyDelimiter>], PropertiesMapping>
 // ------------------------------------------------------------------
@@ -555,8 +423,8 @@ type Properties = Static.Union<[Delimit<Property, PropertyDelimiter>], Propertie
 // ------------------------------------------------------------------
 // prettier-ignore
 interface ObjectMapping extends Static.IMapping {
-  output: this['input'] extends [unknown, infer Properties extends Types.TProperties, unknown] 
-    ? Types.TObject<Properties> 
+  output: this['input'] extends [unknown, infer Properties extends t.TProperties, unknown] 
+    ? t.TObject<Properties> 
     : never
 }
 // prettier-ignore
@@ -569,7 +437,7 @@ type Object = Static.Tuple<[
 type Elements = Delimit<Type, Static.Const<Comma>>
 // prettier-ignore
 interface TupleMapping extends Static.IMapping {
-  output: this['input'] extends [unknown, infer Elements extends Types.TSchema[], unknown] ? Types.TTuple<Elements> : never
+  output: this['input'] extends [unknown, infer Elements extends t.TSchema[], unknown] ? t.TTuple<Elements> : never
 }
 // prettier-ignore
 type Tuple = Static.Tuple<[
@@ -579,7 +447,7 @@ type Tuple = Static.Tuple<[
 // Parameters
 // ------------------------------------------------------------------
 interface ParameterMapping extends Static.IMapping {
-  output: this['input'] extends [string, Colon, infer Type extends Types.TSchema] ? Type : never
+  output: this['input'] extends [string, Colon, infer Type extends t.TSchema] ? Type : never
 }
 // prettier-ignore
 type Parameter = Static.Tuple<[
@@ -592,8 +460,8 @@ type Parameters = Delimit<Parameter, Static.Const<Comma>>
 // ------------------------------------------------------------------
 // prettier-ignore
 interface FunctionMapping extends Static.IMapping {
-  output: this['input'] extends [LParen, infer Parameters extends Types.TSchema[], RParen, '=>', infer ReturnType extends Types.TSchema]
-    ? Types.TFunction<Parameters, ReturnType>
+  output: this['input'] extends [LParen, infer Parameters extends t.TSchema[], RParen, '=>', infer ReturnType extends t.TSchema]
+    ? t.TFunction<Parameters, ReturnType>
     : never
 }
 // prettier-ignore
@@ -605,8 +473,8 @@ type Function = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface ConstructorMapping extends Static.IMapping {
-  output: this['input'] extends ['new', LParen, infer Parameters extends Types.TSchema[], RParen, '=>', infer InstanceType extends Types.TSchema]
-    ? Types.TConstructor<Parameters, InstanceType>
+  output: this['input'] extends ['new', LParen, infer Parameters extends t.TSchema[], RParen, '=>', infer InstanceType extends t.TSchema]
+    ? t.TConstructor<Parameters, InstanceType>
     : never
 }
 // prettier-ignore
@@ -618,8 +486,8 @@ type Constructor = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface MappedMapping extends Static.IMapping {
-  output: this['input'] extends [LBrace, LBracket, infer _Key extends string, 'in', infer _Right extends Types.TSchema, RBracket, Colon, infer Type extends Types.TSchema, RBrace]
-    ? Types.TLiteral<'Mapped types not supported'>
+  output: this['input'] extends [LBrace, LBracket, infer _Key extends string, 'in', infer _Right extends t.TSchema, RBracket, Colon, infer Type extends t.TSchema, RBrace]
+    ? t.TLiteral<'Mapped types not supported'>
     : this['input']
 }
 // prettier-ignore
@@ -631,8 +499,8 @@ type Mapped = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface ArrayMapping extends Static.IMapping {
-  output: this['input'] extends ['Array', LAngle, infer Type extends Types.TSchema, RAngle]
-    ? Types.TArray<Type>
+  output: this['input'] extends ['Array', LAngle, infer Type extends t.TSchema, RAngle]
+    ? t.TArray<Type>
     : never
 }
 // prettier-ignore
@@ -644,8 +512,8 @@ type Array = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface AsyncIteratorMapping extends Static.IMapping {
-  output: this['input'] extends ['AsyncIterator', LAngle, infer Type extends Types.TSchema, RAngle]
-    ? Types.TAsyncIterator<Type>
+  output: this['input'] extends ['AsyncIterator', LAngle, infer Type extends t.TSchema, RAngle]
+    ? t.TAsyncIterator<Type>
     : never
 }
 // prettier-ignore
@@ -657,8 +525,8 @@ type AsyncIterator = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface IteratorMapping extends Static.IMapping {
-  output: this['input'] extends ['Iterator', LAngle, infer Type extends Types.TSchema, RAngle]
-    ? Types.TIterator<Type>
+  output: this['input'] extends ['Iterator', LAngle, infer Type extends t.TSchema, RAngle]
+    ? t.TIterator<Type>
     : never
 }
 // prettier-ignore
@@ -671,8 +539,8 @@ type Iterator = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface ConstructorParametersMapping extends Static.IMapping {
-  output: this['input'] extends ['ConstructorParameters', LAngle, infer Type extends Types.TConstructor, RAngle]
-    ? Types.TConstructorParameters<Type>
+  output: this['input'] extends ['ConstructorParameters', LAngle, infer Type extends t.TSchema, RAngle]
+    ? t.TConstructorParameters<Type>
     : never
 }
 // prettier-ignore
@@ -684,8 +552,8 @@ type ConstructorParameters = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface FunctionParametersMapping extends Static.IMapping {
-  output: this['input'] extends ['Parameters', LAngle, infer Type extends Types.TFunction, RAngle]
-    ? Types.TParameters<Type>
+  output: this['input'] extends ['Parameters', LAngle, infer Type extends t.TSchema, RAngle]
+    ? t.TParameters<Type>
     : never
 }
 // prettier-ignore
@@ -697,8 +565,8 @@ type FunctionParameters = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface InstanceTypeMapping extends Static.IMapping {
-  output: this['input'] extends ['InstanceType', LAngle, infer Type extends Types.TConstructor, RAngle]
-    ? Types.TInstanceType<Type>
+  output: this['input'] extends ['InstanceType', LAngle, infer Type extends t.TSchema, RAngle]
+    ? t.TInstanceType<Type>
     : never
 }
 // prettier-ignore
@@ -710,8 +578,8 @@ type InstanceType = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface ReturnTypeMapping extends Static.IMapping {
-  output: this['input'] extends ['ReturnType', LAngle, infer Type extends Types.TFunction, RAngle]
-    ? Types.TReturnType<Type>
+  output: this['input'] extends ['ReturnType', LAngle, infer Type extends t.TSchema, RAngle]
+    ? t.TReturnType<Type>
     : never
 }
 // prettier-ignore
@@ -723,8 +591,8 @@ type ReturnType = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface AwaitedMapping extends Static.IMapping {
-  output: this['input'] extends ['Awaited', LAngle, infer Type extends Types.TSchema, RAngle]
-    ? Types.TAwaited<Type>
+  output: this['input'] extends ['Awaited', LAngle, infer Type extends t.TSchema, RAngle]
+    ? t.TAwaited<Type>
     : never
 }
 // prettier-ignore
@@ -736,8 +604,8 @@ type Awaited = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface PromiseMapping extends Static.IMapping {
-  output: this['input'] extends ['Promise', LAngle, infer Type extends Types.TSchema, RAngle]
-    ? Types.TPromise<Type>
+  output: this['input'] extends ['Promise', LAngle, infer Type extends t.TSchema, RAngle]
+    ? t.TPromise<Type>
     : never
 }
 // prettier-ignore
@@ -749,8 +617,8 @@ type Promise = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface RecordMapping extends Static.IMapping {
-  output: this['input'] extends ['Record', LAngle, infer Key extends Types.TSchema, Comma, infer Type extends Types.TSchema,  RAngle]
-    ? Types.TRecord<Key, Type>
+  output: this['input'] extends ['Record', LAngle, infer Key extends t.TSchema, Comma, infer Type extends t.TSchema,  RAngle]
+    ? t.TRecord<Key, Type>
     : never
 }
 // prettier-ignore
@@ -762,8 +630,8 @@ type Record = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface PartialMapping extends Static.IMapping {
-  output: this['input'] extends ['Partial', LAngle, infer Type extends Types.TSchema, RAngle]
-    ? Types.TPartial<Type>
+  output: this['input'] extends ['Partial', LAngle, infer Type extends t.TSchema, RAngle]
+    ? t.TPartial<Type>
     : never
 }
 // prettier-ignore
@@ -775,8 +643,8 @@ type Partial = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface RequiredMapping extends Static.IMapping {
-  output: this['input'] extends ['Required', LAngle, infer Type extends Types.TSchema, RAngle]
-    ? Types.TRequired<Type>
+  output: this['input'] extends ['Required', LAngle, infer Type extends t.TSchema, RAngle]
+    ? t.TRequired<Type>
     : never
 }
 // prettier-ignore
@@ -788,8 +656,8 @@ type Required = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface PickMapping extends Static.IMapping {
-  output: this['input'] extends ['Pick', LAngle, infer Type extends Types.TSchema, Comma, infer Key extends Types.TSchema, RAngle]
-    ? Types.TPick<Type, Key>
+  output: this['input'] extends ['Pick', LAngle, infer Type extends t.TSchema, Comma, infer Key extends t.TSchema, RAngle]
+    ? t.TPick<Type, Key>
     : never
 }
 // prettier-ignore
@@ -801,8 +669,8 @@ type Pick = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface OmitMapping extends Static.IMapping {
-  output: this['input'] extends ['Omit', LAngle, infer Type extends Types.TSchema, Comma, infer Key extends Types.TSchema, RAngle]
-    ? Types.TOmit<Type, Key>
+  output: this['input'] extends ['Omit', LAngle, infer Type extends t.TSchema, Comma, infer Key extends t.TSchema, RAngle]
+    ? t.TOmit<Type, Key>
     : never
 }
 // prettier-ignore
@@ -814,8 +682,8 @@ type Omit = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface ExcludeMapping extends Static.IMapping {
-  output: this['input'] extends ['Exclude', LAngle, infer Type extends Types.TSchema, Comma, infer PropertyKey extends Types.TSchema, RAngle]
-    ? Types.TExclude<Type, PropertyKey>
+  output: this['input'] extends ['Exclude', LAngle, infer Type extends t.TSchema, Comma, infer PropertyKey extends t.TSchema, RAngle]
+    ? t.TExclude<Type, PropertyKey>
     : never
 }
 // prettier-ignore
@@ -827,8 +695,8 @@ type Exclude = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface ExtractMapping extends Static.IMapping {
-  output: this['input'] extends ['Extract', LAngle, infer Type extends Types.TSchema, Comma, infer PropertyKey extends Types.TSchema, RAngle]
-    ? Types.TExtract<Type, PropertyKey>
+  output: this['input'] extends ['Extract', LAngle, infer Type extends t.TSchema, Comma, infer PropertyKey extends t.TSchema, RAngle]
+    ? t.TExtract<Type, PropertyKey>
     : never
 }
 // prettier-ignore
@@ -840,8 +708,8 @@ type Extract = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface UppercaseMapping extends Static.IMapping {
-  output: this['input'] extends ['Uppercase', LAngle, infer Type extends Types.TSchema, RAngle]
-    ? Types.TUppercase<Type>
+  output: this['input'] extends ['Uppercase', LAngle, infer Type extends t.TSchema, RAngle]
+    ? t.TUppercase<Type>
     : never
 }
 // prettier-ignore
@@ -853,8 +721,8 @@ type Uppercase = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface LowercaseMapping extends Static.IMapping {
-  output: this['input'] extends ['Lowercase', LAngle, infer Type extends Types.TSchema, RAngle]
-    ? Types.TLowercase<Type>
+  output: this['input'] extends ['Lowercase', LAngle, infer Type extends t.TSchema, RAngle]
+    ? t.TLowercase<Type>
     : never
 }
 // prettier-ignore
@@ -866,8 +734,8 @@ type Lowercase = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface CapitalizeMapping extends Static.IMapping {
-  output: this['input'] extends ['Capitalize', LAngle, infer Type extends Types.TSchema, RAngle]
-    ? Types.TCapitalize<Type>
+  output: this['input'] extends ['Capitalize', LAngle, infer Type extends t.TSchema, RAngle]
+    ? t.TCapitalize<Type>
     : never
 }
 // prettier-ignore
@@ -879,8 +747,8 @@ type Capitalize = Static.Tuple<[
 // ------------------------------------------------------------------
 // prettier-ignore
 interface UncapitalizeMapping extends Static.IMapping {
-  output: this['input'] extends ['Uncapitalize', LAngle, infer Type extends Types.TSchema, RAngle]
-    ? Types.TUncapitalize<Type>
+  output: this['input'] extends ['Uncapitalize', LAngle, infer Type extends t.TSchema, RAngle]
+    ? t.TUncapitalize<Type>
     : never
 }
 // prettier-ignore
@@ -890,19 +758,8 @@ type Uncapitalize = Static.Tuple<[
 // ------------------------------------------------------------------
 // Date
 // ------------------------------------------------------------------
-type Date = Static.Const<'Date', Static.As<Types.TDate>>
+type Date = Static.Const<'Date', Static.As<t.TDate>>
 // ------------------------------------------------------------------
 // Uint8Array
 // ------------------------------------------------------------------
-type Uint8Array = Static.Const<'Uint8Array', Static.As<Types.TUint8Array>>
-
-// ------------------------------------------------------------------
-// Main
-// ------------------------------------------------------------------
-// prettier-ignore
-export type Main = Static.Union<[
-  ModuleDeclaration,
-  TypeAliasDeclaration,
-  InterfaceDeclaration,
-  Type
-]>
+type Uint8Array = Static.Const<'Uint8Array', Static.As<t.TUint8Array>>
diff --git a/src/syntax/syntax.ts b/src/syntax/syntax.ts
new file mode 100644
index 000000000..4d5550cb3
--- /dev/null
+++ b/src/syntax/syntax.ts
@@ -0,0 +1,105 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/syntax
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '../type/index'
+import { Static } from '../parser/index'
+import { Module } from './runtime'
+import { Type } from './static'
+
+// ------------------------------------------------------------------
+// NoInfer
+// ------------------------------------------------------------------
+/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
+export function NoInfer<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined
+/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
+export function NoInfer<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined
+/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
+// prettier-ignore
+export function NoInfer(...args: any[]): Types.TSchema | undefined {
+  const withContext = typeof args[0] === 'string' ? false : true
+  const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}]
+  const type = Module.Parse('Type', code, context)[0]
+  return Types.KindGuard.IsSchema(type) 
+    ? Types.CloneType(type, options) 
+    : Types.Never(options)
+}
+// ------------------------------------------------------------------
+// Syntax
+// ------------------------------------------------------------------
+/** Infers a TSchema type from TypeScript syntax. */
+// prettier-ignore
+export type TSyntax<Context extends Record<PropertyKey, Types.TSchema>, Code extends string> = (
+  Static.Parse<Type, Code, Context> extends [infer Type extends Types.TSchema, string] 
+    ? Type
+    : Types.TNever
+)
+/** Parses a TSchema type from TypeScript syntax */
+export function Syntax<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): TSyntax<Context, Code>
+/** Parses a TSchema type from TypeScript syntax */
+export function Syntax<Code extends string>(code: Code, options?: Types.SchemaOptions): TSyntax<{}, Code>
+/** Parses a TSchema type from TypeScript syntax */
+export function Syntax(...args: any[]): never {
+  return NoInfer.apply(null, args as never) as never
+}
+// ------------------------------------------------------------------
+// Deprecated
+// ------------------------------------------------------------------
+/**
+ * Parses a TSchema type from Syntax.
+ * @deprecated Use Syntax() function
+ */
+export function Parse<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): TSyntax<Context, Code>
+/**
+ * Parses a TSchema type from Syntax.
+ * @deprecated Use Syntax() function
+ */
+export function Parse<Code extends string>(code: Code, options?: Types.SchemaOptions): TSyntax<{}, Code>
+/**
+ * Parses a TSchema type from Syntax.
+ * @deprecated Use Syntax() function
+ */
+export function Parse(...args: any[]): never {
+  return NoInfer.apply(null, args as never) as never
+}
+/**
+ * Parses a TSchema from TypeScript Syntax
+ * @deprecated Use NoInfer() function
+ */
+export function ParseOnly<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined
+/**
+ * Parses a TSchema from TypeScript Syntax
+ * @deprecated Use NoInfer() function
+ */
+export function ParseOnly<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined
+/**
+ * Parses a TSchema from TypeScript Syntax
+ * @deprecated Use NoInfer() function
+ */
+export function ParseOnly(...args: any[]): Types.TSchema | undefined {
+  return NoInfer.apply(null, args as never) as never
+}
diff --git a/src/tsconfig.json b/src/tsconfig.json
index 89a62a897..e65c06406 100644
--- a/src/tsconfig.json
+++ b/src/tsconfig.json
@@ -1,4 +1,4 @@
 {
   "extends": "../tsconfig.json",
-  "files": ["compiler/index.ts", "errors/index.ts", "syntax/index.ts", "system/index.ts", "type/index.ts", "value/index.ts", "index.ts"]
+  "files": ["compiler/index.ts", "errors/index.ts", "parser/index.ts", "syntax/index.ts", "system/index.ts", "type/index.ts", "value/index.ts", "index.ts"]
 }
diff --git a/src/type/constructor-parameters/constructor-parameters.ts b/src/type/constructor-parameters/constructor-parameters.ts
index b15718f1d..3947c8539 100644
--- a/src/type/constructor-parameters/constructor-parameters.ts
+++ b/src/type/constructor-parameters/constructor-parameters.ts
@@ -27,19 +27,21 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import type { TSchema, SchemaOptions } from '../schema/index'
-import type { Ensure } from '../helpers/index'
 import type { TConstructor } from '../constructor/index'
 import { Tuple, type TTuple } from '../tuple/index'
+import { Never, type TNever } from '../never/index'
+import * as KindGuard from '../guard/kind'
 
 // ------------------------------------------------------------------
 // ConstructorParameters
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = (
-  Ensure<TTuple<T['parameters']>>
+export type TConstructorParameters<Type extends TSchema> = (
+  Type extends TConstructor<infer Parameters extends TSchema[], infer _InstanceType extends TSchema>
+    ? TTuple<Parameters>
+    : TNever
 )
-
 /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-export function ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TConstructorParameters<T> {
-  return Tuple(schema.parameters, options)
+export function ConstructorParameters<Type extends TSchema>(schema: Type, options?: SchemaOptions): TConstructorParameters<Type> {
+  return (KindGuard.IsConstructor(schema) ? Tuple(schema.parameters, options) : Never(options)) as never
 }
diff --git a/src/type/instance-type/instance-type.ts b/src/type/instance-type/instance-type.ts
index ece1382c9..7bba6663c 100644
--- a/src/type/instance-type/instance-type.ts
+++ b/src/type/instance-type/instance-type.ts
@@ -27,12 +27,19 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { CreateType } from '../create/type'
-import type { TSchema, SchemaOptions } from '../schema/index'
-import type { TConstructor } from '../constructor/index'
-
-export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns']
+import { type TSchema, SchemaOptions } from '../schema/index'
+import { type TConstructor } from '../constructor/index'
+import { type TNever, Never } from '../never/index'
+import * as KindGuard from '../guard/kind'
+
+// prettier-ignore
+export type TInstanceType<Type extends TSchema,
+  Result extends TSchema = Type extends TConstructor<infer _Parameters extends TSchema[], infer InstanceType extends TSchema>
+    ? InstanceType
+    : TNever
+> = Result
 
 /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-export function InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T> {
-  return CreateType(schema.returns, options)
+export function InstanceType<Type extends TSchema>(schema: Type, options?: SchemaOptions): TInstanceType<Type> {
+  return (KindGuard.IsConstructor(schema) ? CreateType(schema.returns, options) : Never(options)) as never
 }
diff --git a/src/type/parameters/parameters.ts b/src/type/parameters/parameters.ts
index d36ed9a18..02ec79500 100644
--- a/src/type/parameters/parameters.ts
+++ b/src/type/parameters/parameters.ts
@@ -28,15 +28,20 @@ THE SOFTWARE.
 
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { TFunction } from '../function/index'
-import type { Ensure } from '../helpers/index'
 import { Tuple, type TTuple } from '../tuple/index'
+import { Never, type TNever } from '../never/index'
+import * as KindGuard from '../guard/kind'
 
 // ------------------------------------------------------------------
 // Parameters
 // ------------------------------------------------------------------
-export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>
-
+// prettier-ignore
+export type TParameters<Type extends TSchema> = (
+  Type extends TFunction<infer Parameters extends TSchema[], infer _ReturnType extends TSchema>
+    ? TTuple<Parameters>
+    : TNever
+)
 /** `[JavaScript]` Extracts the Parameters from the given Function type */
-export function Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T> {
-  return Tuple(schema.parameters, options)
+export function Parameters<Type extends TSchema>(schema: Type, options?: SchemaOptions): TParameters<Type> {
+  return (KindGuard.IsFunction(schema) ? Tuple(schema.parameters, options) : Never()) as never
 }
diff --git a/src/type/return-type/return-type.ts b/src/type/return-type/return-type.ts
index 17dd44757..1b44968dd 100644
--- a/src/type/return-type/return-type.ts
+++ b/src/type/return-type/return-type.ts
@@ -27,12 +27,19 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { CreateType } from '../create/type'
-import type { SchemaOptions } from '../schema/index'
-import type { TFunction } from '../function/index'
-
-export type TReturnType<T extends TFunction> = T['returns']
+import { type TSchema, type SchemaOptions } from '../schema/index'
+import { type TFunction } from '../function/index'
+import { type TNever, Never } from '../never/index'
+import * as KindGuard from '../guard/kind'
+
+// prettier-ignore
+export type TReturnType<Type extends TSchema,
+  Result extends TSchema = Type extends TFunction<infer _Parameters extends TSchema[], infer ReturnType extends TSchema>
+    ? ReturnType
+    : TNever
+> = Result
 
 /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-export function ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T> {
-  return CreateType(schema.returns, options) as never
+export function ReturnType<Type extends TSchema>(schema: Type, options?: SchemaOptions): TReturnType<Type> {
+  return (KindGuard.IsFunction(schema) ? CreateType(schema.returns, options) : Never(options)) as never
 }
diff --git a/src/type/type/javascript.ts b/src/type/type/javascript.ts
index a7d6573d4..13705e5d7 100644
--- a/src/type/type/javascript.ts
+++ b/src/type/type/javascript.ts
@@ -61,7 +61,7 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     return BigInt(options)
   }
   /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-  public ConstructorParameters<Type extends TConstructor>(schema: Type, options?: SchemaOptions): TConstructorParameters<Type> {
+  public ConstructorParameters<Type extends TSchema>(schema: Type, options?: SchemaOptions): TConstructorParameters<Type> {
     return ConstructorParameters(schema, options)
   }
   /** `[JavaScript]` Creates a Constructor type */
@@ -77,7 +77,7 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     return FunctionType(parameters, returnType, options)
   }
   /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-  public InstanceType<Type extends TConstructor>(schema: Type, options?: SchemaOptions): TInstanceType<Type> {
+  public InstanceType<Type extends TSchema>(schema: Type, options?: SchemaOptions): TInstanceType<Type> {
     return InstanceType(schema, options)
   }
   /** `[JavaScript]` Creates an Iterator type */
@@ -85,7 +85,7 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     return Iterator(items, options)
   }
   /** `[JavaScript]` Extracts the Parameters from the given Function type */
-  public Parameters<Type extends TFunction>(schema: Type, options?: SchemaOptions): TParameters<Type> {
+  public Parameters<Type extends TSchema>(schema: Type, options?: SchemaOptions): TParameters<Type> {
     return Parameters(schema, options)
   }
   /** `[JavaScript]` Creates a Promise type */
@@ -101,7 +101,7 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     return RegExp(unresolved as any, options)
   }
   /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-  public ReturnType<Type extends TFunction>(type: Type, options?: SchemaOptions): TReturnType<Type> {
+  public ReturnType<Type extends TSchema>(type: Type, options?: SchemaOptions): TReturnType<Type> {
     return ReturnType(type, options)
   }
   /** `[JavaScript]` Creates a Symbol type */
diff --git a/task/build/package/build.ts b/task/build/package/build.ts
index 305ebbd1a..a4b3c5880 100644
--- a/task/build/package/build.ts
+++ b/task/build/package/build.ts
@@ -32,7 +32,7 @@ import { createPackageJson } from './create-package-json'
 /** Builds package.json and redirect directories */
 export async function build(target: string) {
   console.log('building...package.json')
-  const submodules = ['compiler', 'errors', 'syntax', 'system', 'type', 'value']
+  const submodules = ['compiler', 'errors', 'parser', 'syntax', 'system', 'type', 'value']
   await createPackageJsonRedirect(target, submodules)
   await createPackageJson(target, submodules)
 }
diff --git a/test/runtime/syntax/syntax.ts b/test/runtime/syntax/syntax.ts
index ae7056752..6f66c2ec1 100644
--- a/test/runtime/syntax/syntax.ts
+++ b/test/runtime/syntax/syntax.ts
@@ -1,156 +1,69 @@
 import { TypeGuard } from '@sinclair/typebox'
-import { Type, TModule } from '@sinclair/typebox'
-import { Parse } from '@sinclair/typebox/syntax'
+import { Type } from '@sinclair/typebox'
+import { Syntax } from '@sinclair/typebox/syntax'
 import { Assert } from '../assert/index'
 
 // prettier-ignore
-describe('syntax/Parse', () => {
-  // ----------------------------------------------------------------
-  // Type Alias
-  // ----------------------------------------------------------------
-  it('Should parse Type Alias 1', () => {
-    const T = Parse('type A = 1')
-    Assert.IsTrue(TypeGuard.IsLiteral(T.A))
-    Assert.IsTrue(T.A.const === 1)
-  })
-  it('Should parse Type Alias 2', () => {
-    const T = Parse('export type A = 1')
-    Assert.IsTrue(TypeGuard.IsLiteral(T.A))
-    Assert.IsTrue(T.A.const === 1)
-  })
-  // ----------------------------------------------------------------
-  // Interface
-  // ----------------------------------------------------------------
-  it('Should parse Interface 1', () => {
-    const T = Parse('interface A { x: 1 }')
-    Assert.IsTrue(TypeGuard.IsObject(T.A))
-    Assert.IsTrue(TypeGuard.IsLiteral(T.A.properties.x))
-    Assert.IsTrue(T.A.properties.x.const === 1)
-  })
-  it('Should parse Interface 2', () => {
-    const T = Parse('export interface A { x: 1 }')
-    Assert.IsTrue(TypeGuard.IsObject(T.A))
-    Assert.IsTrue(TypeGuard.IsLiteral(T.A.properties.x))
-    Assert.IsTrue(T.A.properties.x.const === 1)
-  })
-  // ----------------------------------------------------------------
-  // Module
-  // ----------------------------------------------------------------
-  it('Should parse Module 1', () => {
-    const T = Parse('module {}')
-    Assert.IsTrue(T instanceof TModule)
-  })
-  it('Should parse Module 2', () => {
-    const T = Parse('export module {}')
-    Assert.IsTrue(T instanceof TModule)
-  })
-  it('Should parse Module 3', () => {
-    const T = Parse('module A {}')
-    Assert.IsTrue(T instanceof TModule)
-  })
-  it('Should parse Module 4', () => {
-    const T = Parse('export module A {}')
-    Assert.IsTrue(T instanceof TModule)
-  })
-  it('Should parse Module 5', () => {
-    const T = Parse(`export module A {
-      export type A = number
-    }`)
-    const A = T.Import('A')
-    Assert.IsTrue(T instanceof TModule)
-    Assert.IsTrue(TypeGuard.IsImport(A))
-    const N = A.$defs[A.$ref]
-    Assert.IsTrue(TypeGuard.IsNumber(N))
-  })
-  it('Should parse Module 6', () => {
-    const T = Parse(`export module A {
-      export interface A { x: number }
-    }`)
-    const A = T.Import('A')
-    Assert.IsTrue(T instanceof TModule)
-    Assert.IsTrue(TypeGuard.IsImport(A))
-    const N = A.$defs[A.$ref]
-    Assert.IsTrue(TypeGuard.IsObject(N))
-    Assert.IsTrue(TypeGuard.IsNumber(N.properties.x))
-  })
-  it('Should parse Module 7', () => {
-    const T = Parse(`export module A {
-      export interface A { x: number }
-      export type B = number
-    }`)
-    // A
-    const A = T.Import('A')
-    Assert.IsTrue(T instanceof TModule)
-    Assert.IsTrue(TypeGuard.IsImport(A))
-    const N1 = A.$defs[A.$ref]
-    Assert.IsTrue(TypeGuard.IsObject(N1))
-    Assert.IsTrue(TypeGuard.IsNumber(N1.properties.x))
-    // B
-    const B = T.Import('B')
-    Assert.IsTrue(T instanceof TModule)
-    Assert.IsTrue(TypeGuard.IsImport(B))
-    const N2 = B.$defs[B.$ref]
-    Assert.IsTrue(TypeGuard.IsNumber(N2))
-  })
+describe('syntax/Syntax', () => {
   // ----------------------------------------------------------------
   // Type Expressions
   // ----------------------------------------------------------------
   it('Should parse Any', () => {
-    const T = Parse(`any`)
+    const T = Syntax(`any`)
     Assert.IsTrue(TypeGuard.IsAny(T))
   })
   it('Should parse Array 1', () => {
-    const T = Parse(`number[]`)
+    const T = Syntax(`number[]`)
     Assert.IsTrue(TypeGuard.IsArray(T))
     Assert.IsTrue(TypeGuard.IsNumber(T.items))
   })
   it('Should parse Array 2', () => {
-    const T = Parse(`Array<number>`)
+    const T = Syntax(`Array<number>`)
     Assert.IsTrue(TypeGuard.IsArray(T))
     Assert.IsTrue(TypeGuard.IsNumber(T.items))
   })
   it('Should parse AsyncIterator', () => {
-    const T = Parse(`AsyncIterator<number>`)
+    const T = Syntax(`AsyncIterator<number>`)
     Assert.IsTrue(TypeGuard.IsAsyncIterator(T))
     Assert.IsTrue(TypeGuard.IsNumber(T.items))
   })
   it('Should parse Awaited', () => {
-    const T = Parse(`Awaited<Promise<number>>`)
+    const T = Syntax(`Awaited<Promise<number>>`)
     Assert.IsTrue(TypeGuard.IsNumber(T))
   })
   it('Should parse BigInt', () => {
-    const T = Parse(`bigint`)
+    const T = Syntax(`bigint`)
     Assert.IsTrue(TypeGuard.IsBigInt(T))
   })
   it('Should parse Boolean', () => {
-    const T = Parse(`boolean`)
+    const T = Syntax(`boolean`)
     Assert.IsTrue(TypeGuard.IsBoolean(T))
   })
   it('Should parse ConstructorParameters', () => {
-    const T = Parse(`ConstructorParameters<new (a: number, b: string) => boolean>`)
+    const T = Syntax(`ConstructorParameters<new (a: number, b: string) => boolean>`)
     Assert.IsTrue(TypeGuard.IsTuple(T))
     Assert.IsTrue(TypeGuard.IsNumber(T.items![0]))
     Assert.IsTrue(TypeGuard.IsString(T.items![1]))
   })
   it('Should parse Constructor', () => {
-    const T = Parse(`new (a: number, b: string) => boolean`)
+    const T = Syntax(`new (a: number, b: string) => boolean`)
     Assert.IsTrue(TypeGuard.IsConstructor(T))
     Assert.IsTrue(TypeGuard.IsNumber(T.parameters[0]))
     Assert.IsTrue(TypeGuard.IsString(T.parameters[1]))
     Assert.IsTrue(TypeGuard.IsBoolean(T.returns))
   })
   it('Should parse Date', () => {
-    const T = Parse(`Date`)
+    const T = Syntax(`Date`)
     Assert.IsTrue(TypeGuard.IsDate(T))
   })
   it('Should parse Exclude', () => {
-    const T = Parse(`Exclude<1 | 2 | 3, 1>`)
+    const T = Syntax(`Exclude<1 | 2 | 3, 1>`)
     Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsTrue(T.anyOf[0].const === 2)
     Assert.IsTrue(T.anyOf[1].const === 3)
   })
   it('Should parse Extract', () => {
-    const T = Parse(`Extract<1 | 2 | 3, 1 | 2>`)
+    const T = Syntax(`Extract<1 | 2 | 3, 1 | 2>`)
     Assert.IsTrue(TypeGuard.IsUnion(T))
     // @ts-ignore fix: incorrect union order (result of UnionToTuple, replace with Tuple destructuring)
     Assert.IsTrue(T.anyOf[0].const === 1)
@@ -158,144 +71,144 @@ describe('syntax/Parse', () => {
     Assert.IsTrue(T.anyOf[1].const === 2)
   })
   it('Should parse Function', () => {
-    const T = Parse(`(a: number, b: string) => boolean`)
+    const T = Syntax(`(a: number, b: string) => boolean`)
     Assert.IsTrue(TypeGuard.IsFunction(T))
     Assert.IsTrue(TypeGuard.IsNumber(T.parameters[0]))
     Assert.IsTrue(TypeGuard.IsString(T.parameters[1]))
     Assert.IsTrue(TypeGuard.IsBoolean(T.returns))
   })
   it('Should parse Indexed 1', () => {
-    const T = Parse(`{ x: 1, y: 2, z: 3 }['x']`)
+    const T = Syntax(`{ x: 1, y: 2, z: 3 }['x']`)
     Assert.IsTrue(T.const === 1)
   })
   it('Should parse Indexed 2', () => {
-    const T = Parse(`{ x: 1, y: 2, z: 3 }['x' | 'y' | 'z']`)
+    const T = Syntax(`{ x: 1, y: 2, z: 3 }['x' | 'y' | 'z']`)
     Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsTrue(T.anyOf[0].const === 1)
     Assert.IsTrue(T.anyOf[1].const === 2)
     Assert.IsTrue(T.anyOf[2].const === 3)
   })
   it('Should parse Indexed 3', () => {
-    const T = Parse(`{ x: 1, y: 2, z: 3 }`)
-    const S = Parse({ T }, `T[keyof T]`)
+    const T = Syntax(`{ x: 1, y: 2, z: 3 }`)
+    const S = Syntax({ T }, `T[keyof T]`)
     Assert.IsTrue(TypeGuard.IsUnion(S))
     Assert.IsTrue(S.anyOf[0].const === 1)
     Assert.IsTrue(S.anyOf[1].const === 2)
     Assert.IsTrue(S.anyOf[2].const === 3)
   })
   it('Should parse Indexed 4', () => {
-    const T = Parse(`['A', 'B', 'C']`)
-    const S = Parse({ T }, `T[number]`)
+    const T = Syntax(`['A', 'B', 'C']`)
+    const S = Syntax({ T }, `T[number]`)
     Assert.IsTrue(TypeGuard.IsUnion(S))
     Assert.IsTrue(S.anyOf[0].const === 'A')
     Assert.IsTrue(S.anyOf[1].const === 'B')
     Assert.IsTrue(S.anyOf[2].const === 'C')
   })
   it('Should parse Integer', () => {
-    const T = Parse(`integer`)
+    const T = Syntax(`integer`)
     Assert.IsTrue(TypeGuard.IsInteger(T))
   })
   it('Should parse Intersect 1', () => {
-    const T = Parse(`1 & 2`)
+    const T = Syntax(`1 & 2`)
     Assert.IsTrue(TypeGuard.IsIntersect(T))
     Assert.IsTrue(T.allOf[0].const === 1)
     Assert.IsTrue(T.allOf[1].const === 2)
   })
   it('Should parse Intersect 2', () => {
-    const T = Parse(`1 & (2 & 3)`) // expect flatten
+    const T = Syntax(`1 & (2 & 3)`) // expect flatten
     Assert.IsTrue(TypeGuard.IsIntersect(T))
     Assert.IsTrue(T.allOf[0].const === 1)
     Assert.IsTrue(T.allOf[1].const === 2)
     Assert.IsTrue(T.allOf[2].const === 3)
   })
   it('Should parse Intersect 3', () => {
-    const T = Parse(`(1 | 2) & 3`) // operator precedence
+    const T = Syntax(`(1 | 2) & 3`) // operator precedence
     Assert.IsTrue(TypeGuard.IsIntersect(T))
     Assert.IsTrue(TypeGuard.IsUnion(T.allOf[0]))
     Assert.IsTrue(T.allOf[1].const === 3)
   })
   it('Should parse InstanceType 1', () => {
-    const T = Parse(`InstanceType<new () => { x: 1, y: 2 }>`)
+    const T = Syntax(`InstanceType<new () => { x: 1, y: 2 }>`)
     Assert.IsTrue(TypeGuard.IsObject(T))
     Assert.IsTrue(T.properties.x.const === 1)
     Assert.IsTrue(T.properties.y.const === 2)
   })
   it('Should parse InstanceType 2', () => {
-    const T = Parse(`InstanceType<number>`) // generalization issue
-    Assert.IsTrue(T === undefined)
+    const T = Syntax(`InstanceType<number>`) // generalization issue
+    Assert.IsTrue(TypeGuard.IsNever(T))
   })
   it('Should parse Iterator', () => {
-    const T = Parse(`Iterator<number>`)
+    const T = Syntax(`Iterator<number>`)
     Assert.IsTrue(TypeGuard.IsIterator(T))
     Assert.IsTrue(TypeGuard.IsNumber(T.items))
   })
   it('Should parse KeyOf 1', () => {
-    const T = Parse(`keyof { x: 1, y: 2 }`)
+    const T = Syntax(`keyof { x: 1, y: 2 }`)
     Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsTrue(T.anyOf[0].const === 'x')
     Assert.IsTrue(T.anyOf[1].const === 'y')
   })
   it('Should parse KeyOf 2', () => {
-    const T = Parse(`keyof [0, 1]`)
+    const T = Syntax(`keyof [0, 1]`)
     Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsTrue(T.anyOf[0].const === '0')
     Assert.IsTrue(T.anyOf[1].const === '1')
   })
   it('Should parse KeyOf 3', () => {
-    const T = Parse(`{ x: 1, y: 2 }`)
-    const S = Parse({ T }, `keyof T`)
+    const T = Syntax(`{ x: 1, y: 2 }`)
+    const S = Syntax({ T }, `keyof T`)
     Assert.IsTrue(TypeGuard.IsUnion(S))
     Assert.IsTrue(S.anyOf[0].const === 'x')
     Assert.IsTrue(S.anyOf[1].const === 'y')
   })
   it('Should parse Literal Boolean 1', () => {
-    const T = Parse(`true`)
+    const T = Syntax(`true`)
     Assert.IsTrue(T.const === true)
   })
   it('Should parse Literal Boolean 2', () => {
-    const T = Parse(`false`)
+    const T = Syntax(`false`)
     Assert.IsTrue(T.const === false)
   })
   it('Should parse Literal Number', () => {
-    const T = Parse(`1`)
+    const T = Syntax(`1`)
     Assert.IsTrue(T.const === 1)
   })
   it('Should parse Literal String', () => {
-    const T = Parse(`'1'`)
+    const T = Syntax(`'1'`)
     Assert.IsTrue(T.const === '1')
   })
   it('Should parse Mapped (Pending)', () => {
-    const T = Parse(`{ [K in 1 | 2 | 3]: K }`)
+    const T = Syntax(`{ [K in 1 | 2 | 3]: K }`)
     Assert.IsTrue(T.const === 'Mapped types not supported')
   })
   it('Should parse Never', () => {
-    const T = Parse(`never`)
+    const T = Syntax(`never`)
     Assert.IsTrue(TypeGuard.IsNever(T))
   })
   it('Should parse Null', () => {
-    const T = Parse(`null`)
+    const T = Syntax(`null`)
     Assert.IsTrue(TypeGuard.IsNull(T))
   })
   it('Should parse Number', () => {
-    const T = Parse(`number`)
+    const T = Syntax(`number`)
     Assert.IsTrue(TypeGuard.IsNumber(T))
   })
   it('Should parse Object 1', () => {
-    const T = Parse(`{x: boolean, y: number, z: string, }`)
+    const T = Syntax(`{x: boolean, y: number, z: string, }`)
     Assert.IsTrue(TypeGuard.IsObject(T))
     Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
     Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
     Assert.IsTrue(TypeGuard.IsString(T.properties.z))
   })
   it('Should parse Object 2', () => {
-    const T = Parse(`{x: boolean; y: number; z: string; }`)
+    const T = Syntax(`{x: boolean; y: number; z: string; }`)
     Assert.IsTrue(TypeGuard.IsObject(T))
     Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
     Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
     Assert.IsTrue(TypeGuard.IsString(T.properties.z))
   })
   it('Should parse Object 3', () => {
-    const T = Parse(`{
+    const T = Syntax(`{
       x: boolean 
       y: number
       z: string
@@ -306,7 +219,7 @@ describe('syntax/Parse', () => {
     Assert.IsTrue(TypeGuard.IsString(T.properties.z))
   })
   it('Should parse Object 4', () => {
-    const T = Parse(`{
+    const T = Syntax(`{
       x: boolean; 
       y: number; 
       z: string;
@@ -317,7 +230,7 @@ describe('syntax/Parse', () => {
     Assert.IsTrue(TypeGuard.IsString(T.properties.z))
   })
   it('Should parse Object 5', () => {
-    const T = Parse(`{
+    const T = Syntax(`{
       x: boolean, 
       y: number,
       z: string,
@@ -328,51 +241,51 @@ describe('syntax/Parse', () => {
     Assert.IsTrue(TypeGuard.IsString(T.properties.z))
   })
   it('Should parse Omit 1', () => {
-    const T = Parse(`Omit<{ x: boolean, y: number, z: string }, 'z'>`)
+    const T = Syntax(`Omit<{ x: boolean, y: number, z: string }, 'z'>`)
     Assert.IsTrue(TypeGuard.IsObject(T))
     Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
     Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
     Assert.IsTrue(('z' in T.properties) === false)
   })
   it('Should parse Omit 2', () => {
-    const T = Parse(`Omit<{ x: boolean, y: number, z: string }, 'z' | 'y'>`)
+    const T = Syntax(`Omit<{ x: boolean, y: number, z: string }, 'z' | 'y'>`)
     Assert.IsTrue(TypeGuard.IsObject(T))
     Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
     Assert.IsTrue(('y' in T.properties) === false)
     Assert.IsTrue(('z' in T.properties) === false)
   })
   it('Should parse Parameters', () => {
-    const T = Parse(`Parameters<(a: number, b: string) => boolean>`)
+    const T = Syntax(`Parameters<(a: number, b: string) => boolean>`)
     Assert.IsTrue(TypeGuard.IsTuple(T))
     Assert.IsTrue(TypeGuard.IsNumber(T.items![0]))
     Assert.IsTrue(TypeGuard.IsString(T.items![1]))
   })
   it('Should parse Partial', () => {
-    const T = Parse(`Partial<{ x: boolean, y: number, z: string }>`)
+    const T = Syntax(`Partial<{ x: boolean, y: number, z: string }>`)
     Assert.IsTrue(TypeGuard.IsObject(T))
     Assert.IsTrue(('required' in T) === false)
   })
   it('Should parse Pick 1', () => {
-    const T = Parse(`Pick<{ x: boolean, y: number, z: string }, 'x' | 'y'>`)
+    const T = Syntax(`Pick<{ x: boolean, y: number, z: string }, 'x' | 'y'>`)
     Assert.IsTrue(TypeGuard.IsObject(T))
     Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
     Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
     Assert.IsTrue(('z' in T.properties) === false)
   })
   it('Should parse Pick 2', () => {
-    const T = Parse(`Pick<{ x: boolean, y: number, z: string }, 'x'>`)
+    const T = Syntax(`Pick<{ x: boolean, y: number, z: string }, 'x'>`)
     Assert.IsTrue(TypeGuard.IsObject(T))
     Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
     Assert.IsTrue(('y' in T.properties) === false)
     Assert.IsTrue(('z' in T.properties) === false)
   })
   it('Should parse Promise', () => {
-    const T = Parse(`Promise<number>`)
+    const T = Syntax(`Promise<number>`)
     Assert.IsTrue(TypeGuard.IsPromise(T))
     Assert.IsTrue(TypeGuard.IsNumber(T.item))
   })
   it('Should parse ReadonlyOptional', () => {
-    const T = Parse(`{ readonly x?: boolean, readonly y?: number }`)
+    const T = Syntax(`{ readonly x?: boolean, readonly y?: number }`)
     Assert.IsTrue(TypeGuard.IsObject(T))
     Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
     Assert.IsTrue(TypeGuard.IsReadonly(T.properties.x))
@@ -382,7 +295,7 @@ describe('syntax/Parse', () => {
     Assert.IsTrue(TypeGuard.IsOptional(T.properties.y))
   })
   it('Should parse Readonly', () => {
-    const T = Parse(`{ readonly x: boolean, readonly y: number }`)
+    const T = Syntax(`{ readonly x: boolean, readonly y: number }`)
     Assert.IsTrue(TypeGuard.IsObject(T))
     Assert.IsTrue(TypeGuard.IsBoolean(T.properties.x))
     Assert.IsTrue(TypeGuard.IsReadonly(T.properties.x))
@@ -390,58 +303,58 @@ describe('syntax/Parse', () => {
     Assert.IsTrue(TypeGuard.IsReadonly(T.properties.y))
   })
   it('Should parse Record 1', () => {
-    const T = Parse(`Record<string, number>`)
+    const T = Syntax(`Record<string, number>`)
     Assert.IsTrue(TypeGuard.IsRecord(T))
     Assert.IsTrue(TypeGuard.IsNumber(T.patternProperties['^(.*)$']))
   })
   it('Should parse Record 2', () => {
-    const T = Parse(`Record<number, number>`)
+    const T = Syntax(`Record<number, number>`)
     Assert.IsTrue(TypeGuard.IsRecord(T))
     Assert.IsTrue(TypeGuard.IsNumber(T.patternProperties['^(0|[1-9][0-9]*)$']))
   })
   it('Should parse Record 3', () => {
-    const T = Parse(`Record<'x' | 'y', number>`)
+    const T = Syntax(`Record<'x' | 'y', number>`)
     Assert.IsTrue(TypeGuard.IsObject(T))
     Assert.IsTrue(TypeGuard.IsNumber(T.properties.x))
     Assert.IsTrue(TypeGuard.IsNumber(T.properties.y))
   })
   it('Should parse Recursive', () => {
-    const T = Type.Recursive(This => Parse({ This }, `{ id: string, nodes: This[] }`))
+    const T = Type.Recursive(This => Syntax({ This }, `{ id: string, nodes: This[] }`))
     Assert.IsTrue(TypeGuard.IsObject(T))
     Assert.IsTrue(TypeGuard.IsString(T.properties.id))
     Assert.IsTrue(TypeGuard.IsArray(T.properties.nodes))
     Assert.IsTrue(TypeGuard.IsThis(T.properties.nodes.items))
   })
   it('Should parse Ref', () => {
-    const T = Parse('foo')
+    const T = Syntax('foo')
     Assert.IsTrue(TypeGuard.IsRef(T))
     Assert.IsTrue(T.$ref === 'foo')
   })
   it('Should parse Required', () => {
-    const T = Parse(`Required<{ x?: boolean, y?: number, z?: string }>`)
+    const T = Syntax(`Required<{ x?: boolean, y?: number, z?: string }>`)
     Assert.IsTrue(TypeGuard.IsObject(T))
     Assert.IsEqual(T.required, ['x', 'y', 'z'])
   })
   it('Should parse ReturnType 1', () => {
-    const T = Parse(`ReturnType<() => { x: 1, y: 2 }>`)
+    const T = Syntax(`ReturnType<() => { x: 1, y: 2 }>`)
     Assert.IsTrue(TypeGuard.IsObject(T))
     Assert.IsTrue(T.properties.x.const === 1)
     Assert.IsTrue(T.properties.y.const === 2)
   })
   it('Should parse ReturnType 2', () => {
-    const T = Parse(`ReturnType<number>`) // generalization issue
-    Assert.IsTrue(T === undefined)
+    const T = Syntax(`ReturnType<number>`) // generalization issue
+    Assert.IsTrue(TypeGuard.IsNever(T))
   })
   it('Should parse String', () => {
-    const T = Parse(`string`)
+    const T = Syntax(`string`)
     Assert.IsTrue(TypeGuard.IsString(T))
   })
   it('Should parse Symbol', () => {
-    const T = Parse(`symbol`)
+    const T = Syntax(`symbol`)
     Assert.IsTrue(TypeGuard.IsSymbol(T))
   })
   it('Should parse Tuple', () => {
-    const T = Parse(`[0, 1, 2, 3]`)
+    const T = Syntax(`[0, 1, 2, 3]`)
     Assert.IsTrue(TypeGuard.IsTuple(T))
     Assert.IsTrue(T.items![0].const === 0)
     Assert.IsTrue(T.items![1].const === 1)
@@ -449,32 +362,32 @@ describe('syntax/Parse', () => {
     Assert.IsTrue(T.items![3].const === 3)
   })
   it('Should parse Uint8Array', () => {
-    const T = Parse(`Uint8Array`)
+    const T = Syntax(`Uint8Array`)
     Assert.IsTrue(TypeGuard.IsUint8Array(T))
   })
   it('Should parse Undefined', () => {
-    const T = Parse(`undefined`)
+    const T = Syntax(`undefined`)
     Assert.IsTrue(TypeGuard.IsUndefined(T))
   })
   it('Should parse Union 1', () => {
-    const T = Parse(`1 | 2`)
+    const T = Syntax(`1 | 2`)
     Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsTrue(T.anyOf[0].const === 1)
     Assert.IsTrue(T.anyOf[1].const === 2)
   })
   it('Should parse Union 2', () => {
-    const T = Parse(`1 | (2 | 3)`)
+    const T = Syntax(`1 | (2 | 3)`)
     Assert.IsTrue(TypeGuard.IsUnion(T))
     Assert.IsTrue(T.anyOf[0].const === 1)
     Assert.IsTrue(T.anyOf[1].const === 2)
     Assert.IsTrue(T.anyOf[2].const === 3)
   })
   it('Should parse Unknown', () => {
-    const T = Parse(`unknown`)
+    const T = Syntax(`unknown`)
     Assert.IsTrue(TypeGuard.IsUnknown(T))
   })
   it('Should parse Void', () => {
-    const T = Parse(`void`)
+    const T = Syntax(`void`)
     Assert.IsTrue(TypeGuard.IsVoid(T))
   })
 })
diff --git a/tsconfig.json b/tsconfig.json
index 34a4b8f21..786056048 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -8,6 +8,7 @@
     "paths": {
       "@sinclair/typebox/compiler": ["src/compiler/index.ts"],
       "@sinclair/typebox/errors": ["src/errors/index.ts"],
+      "@sinclair/typebox/parser": ["src/parser/index.ts"],
       "@sinclair/typebox/syntax": ["src/syntax/index.ts"],
       "@sinclair/typebox/system": ["src/system/index.ts"],
       "@sinclair/typebox/type": ["src/type/index.ts"],

From 6616988aa097e39eb5d1e5e42752365e673b5fea Mon Sep 17 00:00:00 2001
From: Garik Suess <garic.suess@gmail.com>
Date: Wed, 12 Feb 2025 05:18:28 +0100
Subject: [PATCH 332/369] Documentation (#1160)

- Ecosystem: Add typebox-cli
---
 readme.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/readme.md b/readme.md
index 37fd0b36e..1dd918493 100644
--- a/readme.md
+++ b/readme.md
@@ -1705,6 +1705,7 @@ The following is a list of community packages that offer general tooling, extend
 | [sveltekit-superforms](https://github.com/ciscoheat/sveltekit-superforms)  | A comprehensive SvelteKit form library for server and client validation |
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
 | [typebox-form-parser](https://github.com/jtlapp/typebox-form-parser) | Parses form and query data based on TypeBox schemas |
+| [typebox-cli](https://github.com/gsuess/typebox-cli) | Generate Schema with typebox from the CLI |
 
 <a name='benchmark'></a>
 

From 1caee147d894f68e187f75d0abe18bd58c94da3d Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 12 Feb 2025 13:20:12 +0900
Subject: [PATCH 333/369] Documentation

---
 readme.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 1dd918493..23e033c2b 100644
--- a/readme.md
+++ b/readme.md
@@ -1704,8 +1704,9 @@ The following is a list of community packages that offer general tooling, extend
 | [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from Json Schemas |
 | [sveltekit-superforms](https://github.com/ciscoheat/sveltekit-superforms)  | A comprehensive SvelteKit form library for server and client validation |
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
-| [typebox-form-parser](https://github.com/jtlapp/typebox-form-parser) | Parses form and query data based on TypeBox schemas |
 | [typebox-cli](https://github.com/gsuess/typebox-cli) | Generate Schema with typebox from the CLI |
+| [typebox-form-parser](https://github.com/jtlapp/typebox-form-parser) | Parses form and query data based on TypeBox schemas |
+
 
 <a name='benchmark'></a>
 

From 44e02afe636609b1b1dd28f696e70574dcce59c0 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 12 Feb 2025 21:24:40 +0900
Subject: [PATCH 334/369] Revision 0.34.17 (#1162)

* Add Argument and Instantiate Types

* ChangeLog

* Version
---
 changelog/0.34.0.md                      |   2 +
 example/prototypes/index.ts              |   1 -
 example/prototypes/readme.md             |  38 ------
 example/prototypes/recursive-map.ts      | 156 -----------------------
 package-lock.json                        |   4 +-
 package.json                             |   2 +-
 readme.md                                |  73 +++++------
 src/compiler/compiler.ts                 |   6 +
 src/errors/errors.ts                     |   3 +
 src/index.ts                             |   3 +
 src/syntax/runtime.ts                    |  36 +++++-
 src/syntax/static.ts                     |  41 +++++-
 src/type/argument/argument.ts            |  41 ++++++
 src/type/argument/index.ts               |  29 +++++
 src/type/guard/kind.ts                   |  19 ++-
 src/type/guard/type.ts                   |  24 +++-
 src/type/index.ts                        |   2 +
 src/type/instantiate/index.ts            |  29 +++++
 src/type/instantiate/instantiate.ts      |  96 ++++++++++++++
 src/type/record/record.ts                |  64 +++++++++-
 src/type/remap/index.ts                  |  29 +++++
 src/type/remap/remap.ts                  | 128 +++++++++++++++++++
 src/type/type/javascript.ts              |  10 ++
 src/type/type/type.ts                    |   3 +
 src/value/check/check.ts                 |   9 +-
 src/value/create/create.ts               |   5 +
 test/runtime/compiler/argument.ts        |  41 ++++++
 test/runtime/compiler/index.ts           |   1 +
 test/runtime/compiler/validate.ts        |   1 +
 test/runtime/syntax/syntax.ts            |  29 +++++
 test/runtime/type/guard/kind/argument.ts |  14 ++
 test/runtime/type/guard/kind/index.ts    |   1 +
 test/runtime/type/guard/type/argument.ts |  14 ++
 test/runtime/type/guard/type/index.ts    |   1 +
 test/runtime/type/guard/type/record.ts   |  42 +++++-
 test/runtime/value/check/argument.ts     |  47 +++++++
 test/runtime/value/check/index.ts        |   1 +
 test/runtime/value/create/argument.ts    |  10 ++
 test/runtime/value/create/index.ts       |   1 +
 test/static/argument.ts                  |  21 +++
 test/static/index.ts                     |   1 +
 41 files changed, 816 insertions(+), 262 deletions(-)
 delete mode 100644 example/prototypes/recursive-map.ts
 create mode 100644 src/type/argument/argument.ts
 create mode 100644 src/type/argument/index.ts
 create mode 100644 src/type/instantiate/index.ts
 create mode 100644 src/type/instantiate/instantiate.ts
 create mode 100644 src/type/remap/index.ts
 create mode 100644 src/type/remap/remap.ts
 create mode 100644 test/runtime/compiler/argument.ts
 create mode 100644 test/runtime/type/guard/kind/argument.ts
 create mode 100644 test/runtime/type/guard/type/argument.ts
 create mode 100644 test/runtime/value/check/argument.ts
 create mode 100644 test/runtime/value/create/argument.ts
 create mode 100644 test/static/argument.ts

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index b3645d6e9..a41e509af 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,4 +1,6 @@
 ### 0.34.0
+- [Revision 0.34.17](https://github.com/sinclairzx81/typebox/pull/1162)
+  - Add Argument() and Instantiate() Types and Instancing via Syntax support.
 - [Revision 0.34.16](https://github.com/sinclairzx81/typebox/pull/1156)
   - Export TypeBox String Parsing Infrastructure
 - [Revision 0.34.15](https://github.com/sinclairzx81/typebox/pull/1148)
diff --git a/example/prototypes/index.ts b/example/prototypes/index.ts
index e7119a8aa..0dfa2301b 100644
--- a/example/prototypes/index.ts
+++ b/example/prototypes/index.ts
@@ -32,4 +32,3 @@ export * from './options'
 export * from './partial-deep'
 export * from './union-enum'
 export * from './union-oneof'
-export * from './recursive-map'
diff --git a/example/prototypes/readme.md b/example/prototypes/readme.md
index f3aea908b..c514e3456 100644
--- a/example/prototypes/readme.md
+++ b/example/prototypes/readme.md
@@ -81,42 +81,4 @@ import { Options } from './prototypes'
 const A = Options(Type.String(), { foo: 1 })             // Options<TString, { foo: number }>
 
 type A = typeof A extends { foo: number } ? true : false // true: foo property is observable to the type system
-```
-
-## Recursive Map
-
-The Recursive Map type enables deep structural remapping of a type and it's internal constituents. This type accepts a TSchema type and a mapping type function (expressed via HKT). The HKT is applied when traversing the type and it's interior. The mapping HKT can apply conditional tests to each visited type to remap into a new form. The following augments a schematic via Options, and conditionally remaps any schema with an default annotation to make it optional. 
-
-```typescript
-import { Type, TOptional, Static, TSchema } from '@sinclair/typebox'
-
-import { TRecursiveMap, TMappingType, Options } from './prototypes'
-
-// ------------------------------------------------------------------
-// StaticDefault
-// ------------------------------------------------------------------
-export interface StaticDefaultMapping extends TMappingType { 
-  output: (
-    this['input'] extends TSchema                        // if input schematic contains an default 
-      ? this['input'] extends { default: unknown }       // annotation, remap it to be optional, 
-        ? TOptional<this['input']>                       // otherwise just return the schema as is.
-        : this['input']
-      : this['input']
-  )
-}
-export type StaticDefault<Type extends TSchema> = (
-  Static<TRecursiveMap<Type, StaticDefaultMapping>>
-)
-
-// ------------------------------------------------------------------
-// Usage
-// ------------------------------------------------------------------
-
-const T = Type.Object({
-  x: Options(Type.String(), { default: 'hello' }),
-  y: Type.String()
-})
-
-type T = StaticDefault<typeof T>   // { x?: string, y: string }
-type S = Static<typeof T>          // { x: string, y: string }
 ```
\ No newline at end of file
diff --git a/example/prototypes/recursive-map.ts b/example/prototypes/recursive-map.ts
deleted file mode 100644
index dfa35b004..000000000
--- a/example/prototypes/recursive-map.ts
+++ /dev/null
@@ -1,156 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/prototypes
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import * as Types from '@sinclair/typebox'
-
-// ------------------------------------------------------------------
-// Mapping: Functions and Type 
-// ------------------------------------------------------------------
-export type TMappingFunction = (schema: Types.TSchema) => Types.TSchema
-
-export interface TMappingType {
-  input: unknown
-  output: unknown
-}
-// ------------------------------------------------------------------
-// Record Parameters
-// ------------------------------------------------------------------
-function GetRecordPattern(record: Types.TRecord): string {
-  return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0]
-}
-function GetRecordKey(record: Types.TRecord): Types.TSchema {
-  const pattern = GetRecordPattern(record)
-  return (
-    pattern === Types.PatternStringExact ? Types.String() :
-    pattern === Types.PatternNumberExact ? Types.Number() :
-    pattern === Types.PatternBooleanExact ? Types.Boolean() :
-    Types.String({ pattern })
-  )
-}
-function GetRecordValue(record: Types.TRecord): Types.TSchema {
-  return record.patternProperties[GetRecordPattern(record)]
-}
-// ------------------------------------------------------------------
-// Traversal
-// ------------------------------------------------------------------
-// prettier-ignore
-type TApply<Type extends Types.TSchema, Func extends TMappingType,
-  Mapped = (Func & { input: Type })['output'],
-  Result = Mapped extends Types.TSchema ? Mapped : never
-> = Result
-// prettier-ignore
-type TFromProperties<Properties extends Types.TProperties, Func extends TMappingType, Result extends Types.TProperties = {
-  [Key in keyof Properties]: TRecursiveMap<Properties[Key], Func>
-}> = Result
-function FromProperties(properties: Types.TProperties, func: TMappingFunction): Types.TProperties {
-  return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
-    return {...result, [key]: RecursiveMap(properties[key], func) }
-  }, {})
-}
-// prettier-ignore
-type TFromRest<Types extends Types.TSchema[], Func extends TMappingType, Result extends Types.TSchema[] = []> = (
-  Types extends [infer Left extends Types.TSchema, ...infer Right extends Types.TSchema[]]
-    ? TFromRest<Right, Func, [...Result, TRecursiveMap<Left, Func>]>
-    : Result
-)
-function FromRest(types: Types.TSchema[], func: TMappingFunction): Types.TSchema[] {
-  return types.map(type => RecursiveMap(type, func))
-}
-// prettier-ignore
-type TFromType<Type extends Types.TSchema, Func extends TMappingType, Result extends Types.TSchema = (
-  TApply<Type, Func>
-)> = Result
-function FromType(type: Types.TSchema, func: TMappingFunction): Types.TSchema {
-  return func(type)
-}
-// ------------------------------------------------------------------
-// TRecursiveMap<Type, Mapping>
-// ------------------------------------------------------------------
-/** `[Prototype]` Applies a deep recursive map across the given type and sub types. */
-// prettier-ignore
-export type TRecursiveMap<Type extends Types.TSchema, Func extends TMappingType, 
-  // Maps the Exterior Type
-  Exterior extends Types.TSchema = TFromType<Type, Func>, 
-  // Maps the Interior Parameterized Types
-  Interior extends Types.TSchema = (
-    Exterior extends Types.TConstructor<infer Parameters extends Types.TSchema[], infer ReturnType extends Types.TSchema> ? Types.TConstructor<TFromRest<Parameters, Func>, TFromType<ReturnType, Func>> :
-    Exterior extends Types.TFunction<infer Parameters extends Types.TSchema[], infer ReturnType extends Types.TSchema> ? Types.TFunction<TFromRest<Parameters, Func>, TFromType<ReturnType, Func>> :
-    Exterior extends Types.TIntersect<infer Types extends Types.TSchema[]> ? Types.TIntersect<TFromRest<Types, Func>> :
-    Exterior extends Types.TUnion<infer Types extends Types.TSchema[]> ? Types.TUnion<TFromRest<Types, Func>> :
-    Exterior extends Types.TTuple<infer Types extends Types.TSchema[]> ? Types.TTuple<TFromRest<Types, Func>> :
-    Exterior extends Types.TArray<infer Type extends Types.TSchema> ? Types.TArray<TFromType<Type, Func>>:
-    Exterior extends Types.TAsyncIterator<infer Type extends Types.TSchema> ? Types.TAsyncIterator<TFromType<Type, Func>> :
-    Exterior extends Types.TIterator<infer Type extends Types.TSchema> ? Types.TIterator<TFromType<Type, Func>> :
-    Exterior extends Types.TPromise<infer Type extends Types.TSchema> ? Types.TPromise<TFromType<Type, Func>> :
-    Exterior extends Types.TObject<infer Properties extends Types.TProperties> ? Types.TObject<TFromProperties<Properties, Func>> :
-    Exterior extends Types.TRecord<infer Key extends Types.TSchema, infer Value extends Types.TSchema> ? Types.TRecordOrObject<TFromType<Key, Func>, TFromType<Value, Func>> :
-    Exterior
-  ),
-  // Modifiers Derived from Exterior Type Mapping
-  IsOptional extends number = Exterior extends Types.TOptional<Types.TSchema> ? 1 : 0,
-  IsReadonly extends number = Exterior extends Types.TReadonly<Types.TSchema> ? 1 : 0,
-  Result extends Types.TSchema = (
-    [IsReadonly, IsOptional]  extends [1, 1] ? Types.TReadonlyOptional<Interior> :
-    [IsReadonly, IsOptional]  extends [0, 1] ? Types.TOptional<Interior> :
-    [IsReadonly, IsOptional]  extends [1, 0] ? Types.TReadonly<Interior> :
-    Interior
-  ) 
-> = Result
-/** `[Prototype]` Applies a deep recursive map across the given type and sub types. */
-// prettier-ignore
-export function RecursiveMap(type: Types.TSchema, func: TMappingFunction): Types.TSchema {
-  // Maps the Exterior Type
-  const exterior = Types.CloneType(FromType(type, func), type)
-  // Maps the Interior Parameterized Types
-  const interior = (
-    Types.KindGuard.IsConstructor(type) ? Types.Constructor(FromRest(type.parameters, func), FromType(type.returns, func), exterior) :
-    Types.KindGuard.IsFunction(type) ? Types.Function(FromRest(type.parameters, func), FromType(type.returns, func), exterior) :
-    Types.KindGuard.IsIntersect(type) ? Types.Intersect(FromRest(type.allOf, func), exterior) :
-    Types.KindGuard.IsUnion(type) ? Types.Union(FromRest(type.anyOf, func), exterior) :
-    Types.KindGuard.IsTuple(type) ? Types.Tuple(FromRest(type.items || [], func), exterior) :
-    Types.KindGuard.IsArray(type) ? Types.Array(FromType(type.items, func), exterior) :
-    Types.KindGuard.IsAsyncIterator(type) ? Types.AsyncIterator(FromType(type.items, func), exterior) :
-    Types.KindGuard.IsIterator(type) ? Types.Iterator(FromType(type.items, func), exterior) :
-    Types.KindGuard.IsPromise(type) ? Types.Promise(FromType(type.items, func), exterior) :
-    Types.KindGuard.IsObject(type) ? Types.Object(FromProperties(type.properties, func), exterior) :
-    Types.KindGuard.IsRecord(type) ? Types.Record(FromType(GetRecordKey(type), func), FromType(GetRecordValue(type), func), exterior) :
-    Types.CloneType(exterior, exterior)
-  )
-  // Modifiers Derived from Exterior Type Mapping
-  const isOptional = Types.KindGuard.IsOptional(exterior)
-  const isReadonly = Types.KindGuard.IsOptional(exterior)
-  return (
-    isOptional && isReadonly ? Types.ReadonlyOptional(interior) :
-    isOptional ? Types.Optional(interior) :
-    isReadonly ? Types.Readonly(interior) :
-    interior
-  )
-}
-
-
-
diff --git a/package-lock.json b/package-lock.json
index 373aed4f7..eab2429fc 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.16",
+  "version": "0.34.17",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.16",
+      "version": "0.34.17",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 1bf33bd7b..217a3e6d6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.16",
+  "version": "0.34.17",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 23e033c2b..ba0ccc901 100644
--- a/readme.md
+++ b/readme.md
@@ -731,46 +731,42 @@ Object properties can be modified with Readonly and Optional. The following tabl
 
 ### Generic Types
 
-Generic types can be created with functions. TypeBox types extend the TSchema interface so you should constrain parameters to this type. The following creates a generic Vector type.
+Generic types can be created with generic functions
 
 ```typescript
-import { Type, type Static, type TSchema } from '@sinclair/typebox'
-
-const Vector = <T extends TSchema>(T: T) => 
-  Type.Object({                                      // type Vector<T> = {
-    x: T,                                            //   x: T,
-    y: T,                                            //   y: T,
-    z: T                                             //   z: T
-  })                                                 // }
+const Nullable = <T extends TSchema>(T: T) => {     // type Nullable<T> = T | null
+  return Type.Union([T, Type.Null())
+}
 
-const NumberVector = Vector(Type.Number())           // type NumberVector = Vector<number>
+const T = Nullable(Type.String())                  // type T = Nullable<string>
 ```
 
-Generic types are often used to create aliases for complex types. The following creates a Nullable generic type.
+Generic types can also be created with Argument types
 
 ```typescript
-const Nullable = <T extends TSchema>(schema: T) => Type.Union([schema, Type.Null()])
-
-const T = Nullable(Type.String())                    // const T = {
-                                                     //   anyOf: [
-                                                     //     { type: 'string' },
-                                                     //     { type: 'null' }
-                                                     //   ]
-                                                     // }
-
-type T = Static<typeof T>                            // type T = string | null
+const Vector = Type.Object({                        // type Vector<A_0, A_1, A_2> = {
+  x: Type.Argument(0),                              //   x: A_0,
+  y: Type.Argument(1),                              //   y: A_1,
+  z: Type.Argument(2),                              //   z: A_2
+})                                                  // }
+
+const T = Type.Instantiate(Vector, [                // type T = Vector<
+  Type.Boolean(),                                   //   boolean, 
+  Type.Number(),                                    //   number,
+  Type.String()                                     //   string
+])                                                  // >
 ```
 
 <a name='types-recursive'></a>
 
 ### Recursive Types
 
-Use the Recursive function to create a singular recursive type.
+Use the Recursive function to create recursive types
 
 ```typescript
-const Node = Type.Recursive(Self => Type.Object({    // const Node = {
+const Node = Type.Recursive(This => Type.Object({    // const Node = {
   id: Type.String(),                                 //   $id: 'Node',
-  nodes: Type.Array(Self)                            //   type: 'object',
+  nodes: Type.Array(This)                            //   type: 'object',
 }), { $id: 'Node' })                                 //   properties: {
                                                      //     id: {
                                                      //       type: 'string'
@@ -1394,28 +1390,27 @@ const S = Syntax({ T }, `{ x: T, y: T, z: T }`)     // const S: TObject<{
 
 ### Generics
 
-Generic syntax types can be created using parameterized types.
+Generic types can be created by passing Argument types as parameters.
 
 ```typescript
-// Generic Syntax Type
-
-const Vector = <T extends string>(T: T) => Syntax({ T: Syntax(T) }, `{
-  x: T,
-  y: T,
-  z: T
+// Generic Vector Type
+
+const Vector = Syntax({                             // type Vector<X, Y, Z> = {
+  X: Type.Argument(0),                              //   x: X
+  Y: Type.Argument(1),                              //   y: Y,
+  Z: Type.Argument(2)                               //   z: Z
+},                                                  // }
+`{                            
+  x: X,
+  y: Y,
+  z: Z
 }`)
 
+// Instanced Vector Type 
 
-// Instanced Generic Syntax Type
-
-const NumberVector = Vector('number')                 // const NumberVector: TObject<{
-                                                      //   x: TNumber,
-                                                      //   y: TNumber,
-                                                      //   z: TNumber
-                                                      // }>
+const Up = Syntax({ Vector }, `Vector<0, 1, 0>`)    // type Up = Vector<0, 1, 0>
 ```
 
-
 <a name='typeregistry'></a>
 
 ## TypeRegistry
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index eb5c67c40..05e2e905d 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -41,6 +41,7 @@ import { ExtendsUndefinedCheck } from '../type/extends/extends-undefined'
 import type { TSchema } from '../type/schema/index'
 import type { TAsyncIterator } from '../type/async-iterator/index'
 import type { TAny } from '../type/any/index'
+import type { TArgument } from '../type/argument/index'
 import type { TArray } from '../type/array/index'
 import type { TBigInt } from '../type/bigint/index'
 import type { TBoolean } from '../type/boolean/index'
@@ -247,6 +248,9 @@ export namespace TypeCompiler {
   function* FromAny(schema: TAny, references: TSchema[], value: string): IterableIterator<string> {
     yield 'true'
   }
+  function* FromArgument(schema: TArgument, references: TSchema[], value: string): IterableIterator<string> {
+    yield 'true'
+  }
   function* FromArray(schema: TArray, references: TSchema[], value: string): IterableIterator<string> {
     yield `Array.isArray(${value})`
     const [parameter, accumulator] = [CreateParameter('value', 'any'), CreateParameter('acc', 'number')]
@@ -490,6 +494,8 @@ export namespace TypeCompiler {
     switch (schema_[Kind]) {
       case 'Any':
         return yield* FromAny(schema_, references_, value)
+      case 'Argument':
+        return yield* FromArgument(schema_, references_, value)
       case 'Array':
         return yield* FromArray(schema_, references_, value)
       case 'AsyncIterator':
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index de62cd970..87ef5e904 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -222,6 +222,7 @@ function Create(errorType: ValueErrorType, schema: TSchema, path: string, value:
 // Types
 // --------------------------------------------------------------------------
 function* FromAny(schema: TAny, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {}
+function* FromArgument(schema: TAny, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {}
 function* FromArray(schema: TArray, references: TSchema[], path: string, value: any): IterableIterator<ValueError> {
   if (!IsArray(value)) {
     return yield Create(ValueErrorType.Array, schema, path, value)
@@ -558,6 +559,8 @@ function* Visit<T extends TSchema>(schema: T, references: TSchema[], path: strin
   switch (schema_[Kind]) {
     case 'Any':
       return yield* FromAny(schema_, references_, path, value)
+    case 'Argument':
+      return yield* FromArgument(schema_, references_, path, value)
     case 'Array':
       return yield* FromArray(schema_, references_, path, value)
     case 'AsyncIterator':
diff --git a/src/index.ts b/src/index.ts
index f17cc7d15..847758ecd 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -44,6 +44,7 @@ export * from './type/symbols/index'
 // ------------------------------------------------------------------
 export * from './type/any/index'
 export * from './type/array/index'
+export * from './type/argument/index'
 export * from './type/async-iterator/index'
 export * from './type/awaited/index'
 export * from './type/bigint/index'
@@ -60,6 +61,7 @@ export * from './type/extract/index'
 export * from './type/function/index'
 export * from './type/indexed/index'
 export * from './type/instance-type/index'
+export * from './type/instantiate/index'
 export * from './type/integer/index'
 export * from './type/intersect/index'
 export * from './type/iterator/index'
@@ -85,6 +87,7 @@ export * from './type/record/index'
 export * from './type/recursive/index'
 export * from './type/ref/index'
 export * from './type/regexp/index'
+export * from './type/remap/index'
 export * from './type/required/index'
 export * from './type/rest/index'
 export * from './type/return-type/index'
diff --git a/src/syntax/runtime.ts b/src/syntax/runtime.ts
index 8a62f2014..c5366d277 100644
--- a/src/syntax/runtime.ts
+++ b/src/syntax/runtime.ts
@@ -60,16 +60,28 @@ function DestructureRight<T>(values: T[]): [T[], T | undefined] {
     : [values, undefined]
 }
 // ------------------------------------------------------------------
-// Deref
+// Dereference
 // ------------------------------------------------------------------
-const Deref = (context: t.TProperties, key: string): t.TSchema => {
+const Dereference = (context: t.TProperties, key: string): t.TSchema => {
   return key in context ? context[key] : t.Ref(key)
 }
 // ------------------------------------------------------------------
+// GenericReference
+// ------------------------------------------------------------------
+function GenericReferenceMapping(results: unknown[], context: t.TProperties) {
+  const target = Dereference(context, results[0] as string)
+  return t.Instantiate(target, results[2] as t.TSchema[])
+}
+const GenericReference = Runtime.Tuple([Runtime.Ident(), Runtime.Const(LAngle), Runtime.Ref('Elements'), Runtime.Const(RAngle)], (results, context) => GenericReferenceMapping(results, context))
+// ------------------------------------------------------------------
 // Reference
 // ------------------------------------------------------------------
+function ReferenceMapping(result: string, context: t.TProperties) {
+  const target = Dereference(context, result)
+  return target
+}
 // prettier-ignore
-const Reference = Runtime.Ident((value, context: t.TProperties) => Deref(context, value))
+const Reference = Runtime.Ident((result, context) => ReferenceMapping(result, context))
 // ------------------------------------------------------------------
 // Literal
 // ------------------------------------------------------------------
@@ -166,6 +178,7 @@ const Base = Runtime.Union([
     Runtime.Ref('FunctionParameters'),
     Runtime.Ref('InstanceType'),
     Runtime.Ref('ReturnType'),
+    Runtime.Ref('Argument'),
     Runtime.Ref('Awaited'),
     Runtime.Ref('Array'),
     Runtime.Ref('Record'),
@@ -182,6 +195,7 @@ const Base = Runtime.Union([
     Runtime.Ref('Uncapitalize'),
     Runtime.Ref('Date'),
     Runtime.Ref('Uint8Array'),
+    Runtime.Ref('GenericReference'),
     Runtime.Ref('Reference')
   ])])
 ], BaseMapping)
@@ -465,6 +479,20 @@ const ReturnType = Runtime.Tuple([
   Runtime.Const(RAngle),
 ], value => t.ReturnType(value[2]))
 // ------------------------------------------------------------------
+// Argument
+// ------------------------------------------------------------------
+// prettier-ignore
+const Argument = Runtime.Tuple([
+  Runtime.Const('Argument'), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref<t.TSchema>('Type'), 
+  Runtime.Const(RAngle),
+], results => {
+  return t.KindGuard.IsLiteralNumber(results[2])
+    ? t.Argument(Math.trunc(results[2].const))
+    : t.Never()
+})
+// ------------------------------------------------------------------
 // Awaited
 // ------------------------------------------------------------------
 // prettier-ignore
@@ -658,6 +686,7 @@ export const Module = new Runtime.Module({
   Mapped,
   AsyncIterator,
   Iterator,
+  Argument,
   Awaited,
   Array,
   Record,
@@ -678,5 +707,6 @@ export const Module = new Runtime.Module({
   Uncapitalize,
   Date,
   Uint8Array,
+  GenericReference,
   Reference,
 })
diff --git a/src/syntax/static.ts b/src/syntax/static.ts
index 4cd125565..fd06a402e 100644
--- a/src/syntax/static.ts
+++ b/src/syntax/static.ts
@@ -136,20 +136,38 @@ type Delimit<Parser extends Static.IParser, Delimiter extends Static.IParser> =
   ], DelimitMapping>
 )
 // ------------------------------------------------------------------
-// Deref
+// Dereference
 // ------------------------------------------------------------------
 // prettier-ignore
-type Deref<Context extends t.TProperties, Ref extends string> = (
+type Dereference<Context extends t.TProperties, Ref extends string> = (
   Ref extends keyof Context ? Context[Ref] : t.TRef<Ref>
 )
 // ------------------------------------------------------------------
+// GenericReference
+// ------------------------------------------------------------------
+// prettier-ignore
+interface GenericReferenceMapping extends Static.IMapping {
+  output: this['context'] extends t.TProperties
+    ? this['input'] extends [infer Reference extends string, LAngle, infer Parameters extends t.TSchema[], RAngle]
+      ? t.TInstantiate<Dereference<this['context'], Reference>, [...Parameters]>
+      : never
+    : never  
+}
+// prettier-ignore
+type GenericReference = Static.Tuple<[
+  Static.Ident,
+  Static.Const<LAngle>,
+  Elements,
+  Static.Const<RAngle>,
+], GenericReferenceMapping>
+// ------------------------------------------------------------------
 // Reference
 // ------------------------------------------------------------------
 // prettier-ignore
 interface ReferenceMapping extends Static.IMapping {
   output: this['context'] extends t.TProperties
     ? this['input'] extends string
-      ? Deref<this['context'], this['input']>
+      ? Dereference<this['context'], this['input']>
       : never
     : never  
 }
@@ -267,6 +285,7 @@ type Base = Static.Union<[
     Iterator,
     ConstructorParameters,
     FunctionParameters,
+    Argument,
     InstanceType,
     ReturnType,
     Awaited,
@@ -285,6 +304,7 @@ type Base = Static.Union<[
     Uncapitalize,
     Date,
     Uint8Array,
+    GenericReference,
     Reference
   ]>]>
 ], BaseMapping>
@@ -587,6 +607,21 @@ type ReturnType = Static.Tuple<[
   Static.Const<'ReturnType'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
 ], ReturnTypeMapping>
 // ------------------------------------------------------------------
+// Argument
+// ------------------------------------------------------------------
+// prettier-ignore
+interface ArgumentMapping extends Static.IMapping {
+  output: this['input'] extends ['Argument', LAngle, infer Type extends t.TSchema, RAngle]
+    ? Type extends t.TLiteral<infer Index extends number>
+      ? t.TArgument<Index>
+      : t.TNever
+    : never
+}
+// prettier-ignore
+type Argument = Static.Tuple<[
+  Static.Const<'Argument'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
+], ArgumentMapping>
+// ------------------------------------------------------------------
 // Awaited
 // ------------------------------------------------------------------
 // prettier-ignore
diff --git a/src/type/argument/argument.ts b/src/type/argument/argument.ts
new file mode 100644
index 000000000..a6c63f286
--- /dev/null
+++ b/src/type/argument/argument.ts
@@ -0,0 +1,41 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { CreateType } from '../create/type'
+import type { TSchema } from '../schema/index'
+import { Kind } from '../symbols/index'
+
+export interface TArgument<Index extends number = number> extends TSchema {
+  [Kind]: 'Argument'
+  static: unknown
+  index: Index
+}
+/** `[JavaScript]` Creates an Argument Type. */
+export function Argument<Index extends number>(index: Index): TArgument<Index> {
+  return CreateType({ [Kind]: 'Argument', index }) as never
+}
diff --git a/src/type/argument/index.ts b/src/type/argument/index.ts
new file mode 100644
index 000000000..186ff4ee6
--- /dev/null
+++ b/src/type/argument/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './argument'
diff --git a/src/type/guard/kind.ts b/src/type/guard/kind.ts
index 9ca359fdb..6447412f4 100644
--- a/src/type/guard/kind.ts
+++ b/src/type/guard/kind.ts
@@ -29,15 +29,13 @@ THE SOFTWARE.
 import * as ValueGuard from './value'
 import { Kind, Hint, TransformKind, ReadonlyKind, OptionalKind } from '../symbols/index'
 import { TransformOptions } from '../transform/index'
-import type { TTemplateLiteral } from '../template-literal/index'
+
+import type { TAny } from '../any/index'
+import type { TArgument } from '../argument/index'
 import type { TArray } from '../array/index'
+import type { TAsyncIterator } from '../async-iterator/index'
 import type { TBoolean } from '../boolean/index'
 import type { TComputed } from '../computed/index'
-import type { TRecord } from '../record/index'
-import type { TString } from '../string/index'
-import type { TUnion } from '../union/index'
-import type { TAny } from '../any/index'
-import type { TAsyncIterator } from '../async-iterator/index'
 import type { TBigInt } from '../bigint/index'
 import type { TConstructor } from '../constructor/index'
 import type { TFunction } from '../function/index'
@@ -55,14 +53,18 @@ import type { TObject, TProperties } from '../object/index'
 import type { TOptional } from '../optional/index'
 import type { TPromise } from '../promise/index'
 import type { TReadonly } from '../readonly/index'
+import type { TRecord } from '../record/index'
 import type { TRef } from '../ref/index'
 import type { TRegExp } from '../regexp/index'
 import type { TSchema } from '../schema/index'
+import type { TString } from '../string/index'
 import type { TSymbol } from '../symbol/index'
+import type { TTemplateLiteral } from '../template-literal/index'
 import type { TTuple } from '../tuple/index'
 import type { TUint8Array } from '../uint8array/index'
 import type { TUndefined } from '../undefined/index'
 import type { TUnknown } from '../unknown/index'
+import type { TUnion } from '../union/index'
 import type { TUnsafe } from '../unsafe/index'
 import type { TVoid } from '../void/index'
 import type { TDate } from '../date/index'
@@ -80,6 +82,10 @@ export function IsOptional<T extends TSchema>(value: T): value is TOptional<T> {
 export function IsAny(value: unknown): value is TAny {
   return IsKindOf(value, 'Any')
 }
+/** `[Kind-Only]` Returns true if the given value is TArgument */
+export function IsArgument(value: unknown): value is TArgument {
+  return IsKindOf(value, 'Argument')
+}
 /** `[Kind-Only]` Returns true if the given value is TArray */
 export function IsArray(value: unknown): value is TArray {
   return IsKindOf(value, 'Array')
@@ -261,6 +267,7 @@ export function IsSchema(value: unknown): value is TSchema {
   // prettier-ignore
   return (
     IsAny(value) ||
+    IsArgument(value) ||
     IsArray(value) ||
     IsBoolean(value) ||
     IsBigInt(value) ||
diff --git a/src/type/guard/type.ts b/src/type/guard/type.ts
index 521522ffd..9df35670a 100644
--- a/src/type/guard/type.ts
+++ b/src/type/guard/type.ts
@@ -30,15 +30,13 @@ import * as ValueGuard from './value'
 import { Kind, Hint, TransformKind, ReadonlyKind, OptionalKind } from '../symbols/index'
 import { TypeBoxError } from '../error/index'
 import { TransformOptions } from '../transform/index'
-import type { TTemplateLiteral } from '../template-literal/index'
+
+import type { TAny } from '../any/index'
+import type { TArgument } from '../argument/index'
 import type { TArray } from '../array/index'
+import type { TAsyncIterator } from '../async-iterator/index'
 import type { TBoolean } from '../boolean/index'
 import type { TComputed } from '../computed/index'
-import type { TRecord } from '../record/index'
-import type { TString } from '../string/index'
-import type { TUnion } from '../union/index'
-import type { TAny } from '../any/index'
-import type { TAsyncIterator } from '../async-iterator/index'
 import type { TBigInt } from '../bigint/index'
 import type { TConstructor } from '../constructor/index'
 import type { TFunction } from '../function/index'
@@ -56,13 +54,17 @@ import type { TObject, TAdditionalProperties, TProperties } from '../object/inde
 import type { TOptional } from '../optional/index'
 import type { TPromise } from '../promise/index'
 import type { TReadonly } from '../readonly/index'
+import type { TRecord } from '../record/index'
 import type { TRef } from '../ref/index'
 import type { TRegExp } from '../regexp/index'
 import type { TSchema } from '../schema/index'
+import type { TString } from '../string/index'
 import type { TSymbol } from '../symbol/index'
+import type { TTemplateLiteral } from '../template-literal/index'
 import type { TTuple } from '../tuple/index'
 import type { TUint8Array } from '../uint8array/index'
 import type { TUndefined } from '../undefined/index'
+import type { TUnion } from '../union/index'
 import type { TUnknown } from '../unknown/index'
 import type { TUnsafe } from '../unsafe/index'
 import type { TVoid } from '../void/index'
@@ -72,6 +74,7 @@ import type { TThis } from '../recursive/index'
 export class TypeGuardUnknownTypeError extends TypeBoxError {}
 
 const KnownTypes = [
+  'Argument',
   'Any',
   'Array',
   'AsyncIterator',
@@ -171,6 +174,14 @@ export function IsAny(value: unknown): value is TAny {
     IsOptionalString(value.$id)
   )
 }
+/** Returns true if the given value is TArgument */
+export function IsArgument(value: unknown): value is TArgument {
+  // prettier-ignore
+  return (
+    IsKindOf(value, 'Argument') &&
+    ValueGuard.IsNumber(value.index)
+  )
+}
 /** Returns true if the given value is TArray */
 export function IsArray(value: unknown): value is TArray {
   return (
@@ -608,6 +619,7 @@ export function IsSchema(value: unknown): value is TSchema {
     ValueGuard.IsObject(value)
   ) && (
       IsAny(value) ||
+      IsArgument(value) ||
       IsArray(value) ||
       IsBoolean(value) ||
       IsBigInt(value) ||
diff --git a/src/type/index.ts b/src/type/index.ts
index 661e36678..cafc2a7f6 100644
--- a/src/type/index.ts
+++ b/src/type/index.ts
@@ -27,6 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 export * from './any/index'
+export * from './argument/index'
 export * from './array/index'
 export * from './async-iterator/index'
 export * from './awaited/index'
@@ -49,6 +50,7 @@ export * from './guard/index'
 export * from './helpers/index'
 export * from './indexed/index'
 export * from './instance-type/index'
+export * from './instantiate/index'
 export * from './integer/index'
 export * from './intersect/index'
 export * from './intrinsic/index'
diff --git a/src/type/instantiate/index.ts b/src/type/instantiate/index.ts
new file mode 100644
index 000000000..5f0a519b0
--- /dev/null
+++ b/src/type/instantiate/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './instantiate'
diff --git a/src/type/instantiate/instantiate.ts b/src/type/instantiate/instantiate.ts
new file mode 100644
index 000000000..b42628667
--- /dev/null
+++ b/src/type/instantiate/instantiate.ts
@@ -0,0 +1,96 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import type { TSchema } from '../schema/index'
+import type { TArgument } from '../argument/index'
+import { type TNever, Never } from '../never/index'
+import { type TReadonlyOptional, ReadonlyOptional } from '../readonly-optional/index'
+import { type TReadonly, Readonly } from '../readonly/index'
+import { type TOptional, Optional } from '../optional/index'
+
+import { Remap, type TRemap, type TMapping as TRemapMapping } from '../remap/index'
+import * as KindGuard from '../guard/kind'
+
+// ------------------------------------------------------------------
+// InstantiateArgument
+// ------------------------------------------------------------------
+// prettier-ignore
+type TInstantiateArgument<Argument extends TArgument, Type extends TSchema,
+  IsArgumentReadonly extends number = Argument extends TReadonly<TSchema> ? 1 : 0,
+  IsArgumentOptional extends number = Argument extends TOptional<TSchema> ? 1 : 0,
+  Result extends TSchema = (
+    [IsArgumentReadonly, IsArgumentOptional]  extends [1, 1] ? TReadonlyOptional<Type> :
+    [IsArgumentReadonly, IsArgumentOptional]  extends [0, 1] ? TOptional<Type> :
+    [IsArgumentReadonly, IsArgumentOptional]  extends [1, 0] ? TReadonly<Type> :
+    Type
+  ) 
+> = Result
+// prettier-ignore
+function InstantiateArgument<Argument extends TArgument, Type extends TSchema>(argument: Argument, type: Type): TInstantiateArgument<Argument, Type> {
+  const isReadonly = KindGuard.IsReadonly(argument)
+  const isOptional = KindGuard.IsOptional(argument)
+  return (
+    isReadonly && isOptional ? ReadonlyOptional(type) :
+    isReadonly && !isOptional ? Readonly(type) :
+    !isReadonly && isOptional ? Optional(type) :
+    type
+  ) as never
+}
+// ------------------------------------------------------------------
+// Instantiate
+// ------------------------------------------------------------------
+// prettier-ignore
+interface TInstantiateArguments<Arguments extends TSchema[]> extends TRemapMapping { 
+  output: (
+    this['input'] extends TArgument<infer Index extends number>
+      ? Index extends keyof Arguments 
+        ? Arguments[Index] extends TSchema
+          ? TInstantiateArgument<this['input'], Arguments[Index]>
+          : TNever
+        : TNever
+      : this['input']
+  )
+}
+/** `[JavaScript]` Instantiates a type with the given parameters */
+// prettier-ignore
+export type TInstantiate<Type extends TSchema, Arguments extends TSchema[]> = (
+  TRemap<Type, TInstantiateArguments<Arguments>>
+)
+/** `[JavaScript]` Instantiates a type with the given parameters */
+// prettier-ignore
+export function Instantiate<Type extends TSchema, Arguments extends TSchema[]>(type: Type, args: [...Arguments]): TInstantiate<Type, Arguments> {
+  return Remap(type, (type) => {
+    return KindGuard.IsArgument(type)
+      ? type.index in args
+        ? KindGuard.IsSchema(args[type.index])
+          ? InstantiateArgument(type, args[type.index]) 
+          : Never()
+        : Never()
+      : type
+  }) as never
+}
diff --git a/src/type/record/record.ts b/src/type/record/record.ts
index 265495a66..e22e180df 100644
--- a/src/type/record/record.ts
+++ b/src/type/record/record.ts
@@ -32,16 +32,17 @@ import type { TSchema } from '../schema/index'
 import type { Static } from '../static/index'
 import type { Evaluate, Ensure, Assert } from '../helpers/index'
 import { type TAny } from '../any/index'
+import { type TBoolean } from '../boolean/index'
 import { type TComputed, Computed } from '../computed/index'
 import { type TEnumRecord, type TEnum } from '../enum/index'
 import { type TInteger } from '../integer/index'
 import { type TLiteral, type TLiteralValue } from '../literal/index'
 import { type TNever, Never } from '../never/index'
-import { type TNumber } from '../number/index'
+import { type TNumber, Number } from '../number/index'
 import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions, Object } from '../object/index'
 import { type TRef, Ref } from '../ref/index'
 import { type TRegExp } from '../regexp/index'
-import { type TString } from '../string/index'
+import { type TString, String } from '../string/index'
 import { type TUnion, Union } from '../union/index'
 
 import { IsTemplateLiteralFinite, TIsTemplateLiteralFinite, type TTemplateLiteral } from '../template-literal/index'
@@ -55,7 +56,7 @@ import { IsUndefined } from '../guard/value'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsInteger, IsLiteral, IsAny, IsNever, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion, IsRef, IsComputed } from '../guard/kind'
+import { IsInteger, IsLiteral, IsAny, IsBoolean, IsNever, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion, IsRef, IsComputed } from '../guard/kind'
 
 // ------------------------------------------------------------------
 // RecordCreateFromPattern
@@ -178,6 +179,17 @@ function FromNeverKey<Key extends TNever, Type extends TSchema>(_key: Key, type:
   return RecordCreateFromPattern(PatternNeverExact, type, options) as never
 }
 // ------------------------------------------------------------------
+// TromBooleanKey
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromBooleanKey<_Key extends TBoolean, Type extends TSchema> = (
+  Ensure<TObject<{ true: Type, false: Type }>>
+)
+// prettier-ignore
+function FromBooleanKey<Key extends TBoolean, Type extends TSchema>(_key: Key, type: Type, options: ObjectOptions): TFromBooleanKey<Key, Type> {
+  return Object({ true: type, false: type }, options)
+}
+// ------------------------------------------------------------------
 // FromIntegerKey
 // ------------------------------------------------------------------
 // prettier-ignore
@@ -228,6 +240,7 @@ export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = (
   Key extends TEnum<infer Enum extends TEnumRecord> ? TFromEnumKey<Enum, Type> : // (Special: Ensure resolve Enum before Union)
   Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Type> :
   Key extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteralKey<Value, Type> :
+  Key extends TBoolean ? TFromBooleanKey<Key, Type> :
   Key extends TInteger ? TFromIntegerKey<Key, Type> :
   Key extends TNumber ? TFromNumberKey<Key, Type> :
   Key extends TRegExp ? TFromRegExpKey<Key, Type> :
@@ -249,6 +262,7 @@ export function Record<Key extends TSchema, Type extends TSchema>(key: Key, type
     IsUnion(key) ? FromUnionKey(key.anyOf, type, options) :
     IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) :
     IsLiteral(key) ? FromLiteralKey(key.const, type, options) :
+    IsBoolean(key) ?  FromBooleanKey(key, type, options) :
     IsInteger(key) ? FromIntegerKey(key, type, options) :
     IsNumber(key) ? FromNumberKey(key, type, options) :
     IsRegExp(key) ? FromRegExpKey(key, type, options) :
@@ -258,3 +272,47 @@ export function Record<Key extends TSchema, Type extends TSchema>(key: Key, type
     Never(options)
   ) as never
 }
+
+// ------------------------------------------------------------------
+// Record Utilities
+// ------------------------------------------------------------------
+/** Gets the Records Pattern */
+export function RecordPattern(record: TRecord): string {
+  return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0]
+}
+// ------------------------------------------------------------------
+// RecordKey
+// ------------------------------------------------------------------
+/** Gets the Records Key Type */
+// prettier-ignore
+export type TRecordKey<Type extends TRecord> = (
+  Type extends TRecord<infer Key extends TSchema, TSchema> 
+    ? (
+      Key extends TNumber ? TNumber :
+      Key extends TString ? TString :
+      TString
+    ) : TString
+)
+/** Gets the Records Key Type */
+// prettier-ignore
+export function RecordKey<Type extends TRecord>(type: Type): TRecordKey<Type> {
+  const pattern = RecordPattern(type)
+  return (
+    pattern === PatternStringExact ? String() :
+    pattern === PatternNumberExact ? Number() :
+    String({ pattern })
+  ) as never
+}
+// ------------------------------------------------------------------
+// RecordValue
+// ------------------------------------------------------------------
+/** Gets a Record Value Type */
+// prettier-ignore
+export type TRecordValue<Type extends TRecord> = (
+  Type extends TRecord<TSchema, infer Value extends TSchema> ? Value : TNever
+)
+/** Gets a Record Value Type */
+// prettier-ignore
+export function RecordValue<Type extends TRecord>(type: Type): TRecordValue<Type> {
+  return type.patternProperties[RecordPattern(type)] as never
+}
diff --git a/src/type/remap/index.ts b/src/type/remap/index.ts
new file mode 100644
index 000000000..f05c8c5db
--- /dev/null
+++ b/src/type/remap/index.ts
@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+export * from './remap'
diff --git a/src/type/remap/remap.ts b/src/type/remap/remap.ts
new file mode 100644
index 000000000..3354b87ca
--- /dev/null
+++ b/src/type/remap/remap.ts
@@ -0,0 +1,128 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/prototypes
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as t from '@sinclair/typebox'
+
+// ------------------------------------------------------------------
+// Callback
+// ------------------------------------------------------------------
+export type TCallback = (schema: t.TSchema) => t.TSchema
+// ------------------------------------------------------------------
+// Mapping
+// ------------------------------------------------------------------
+export interface TMapping {
+  input: unknown
+  output: unknown
+}
+// ------------------------------------------------------------------
+// Apply
+// ------------------------------------------------------------------
+// prettier-ignore
+type TApply<Type extends t.TSchema, Mapping extends TMapping,
+  Mapped = (Mapping & { input: Type })['output'],
+  Result = Mapped extends t.TSchema ? Mapped : never
+> = Result
+// ------------------------------------------------------------------
+// Properties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperties<Properties extends t.TProperties, Mapping extends TMapping, Result extends t.TProperties = {
+  [Key in keyof Properties]: TRemap<Properties[Key], Mapping>
+}> = Result
+function FromProperties(properties: t.TProperties, func: TCallback): t.TProperties {
+  return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+    return { ...result, [key]: Remap(properties[key], func) }
+  }, {})
+}
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromTypes<Types extends t.TSchema[], Mapping extends TMapping, Result extends t.TSchema[] = []> = (
+  Types extends [infer Left extends t.TSchema, ...infer Right extends t.TSchema[]]
+    ? TFromTypes<Right, Mapping, [...Result, TRemap<Left, Mapping>]>
+    : Result
+)
+function FromTypes(types: t.TSchema[], callback: TCallback): t.TSchema[] {
+  return types.map((type) => Remap(type, callback))
+}
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromType<Type extends t.TSchema, Mapping extends TMapping, Result extends t.TSchema = (
+  TApply<Type, Mapping>
+)> = Result
+function FromType(type: t.TSchema, callback: TCallback): t.TSchema {
+  return callback(type)
+}
+// ------------------------------------------------------------------
+// TRemap<Type, Function>
+// ------------------------------------------------------------------
+/** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
+// prettier-ignore
+export type TRemap<Type extends t.TSchema, Mapping extends TMapping, 
+  // Maps the Exterior Type
+  Mapped extends t.TSchema = TFromType<Type, Mapping>, 
+  // Maps the Interior Parameterized Types
+  Result extends t.TSchema = (
+    Mapped extends t.TConstructor<infer Parameters extends t.TSchema[], infer ReturnType extends t.TSchema> ? t.TConstructor<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> :
+    Mapped extends t.TFunction<infer Parameters extends t.TSchema[], infer ReturnType extends t.TSchema> ? t.TFunction<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> :
+    Mapped extends t.TIntersect<infer Types extends t.TSchema[]> ? t.TIntersect<TFromTypes<Types, Mapping>> :
+    Mapped extends t.TUnion<infer Types extends t.TSchema[]> ? t.TUnion<TFromTypes<Types, Mapping>> :
+    Mapped extends t.TTuple<infer Types extends t.TSchema[]> ? t.TTuple<TFromTypes<Types, Mapping>> :
+    Mapped extends t.TArray<infer Type extends t.TSchema> ? t.TArray<TFromType<Type, Mapping>>:
+    Mapped extends t.TAsyncIterator<infer Type extends t.TSchema> ? t.TAsyncIterator<TFromType<Type, Mapping>> :
+    Mapped extends t.TIterator<infer Type extends t.TSchema> ? t.TIterator<TFromType<Type, Mapping>> :
+    Mapped extends t.TPromise<infer Type extends t.TSchema> ? t.TPromise<TFromType<Type, Mapping>> :
+    Mapped extends t.TObject<infer Properties extends t.TProperties> ? t.TObject<TFromProperties<Properties, Mapping>> :
+    Mapped extends t.TRecord<infer Key extends t.TSchema, infer Value extends t.TSchema> ? t.TRecordOrObject<TFromType<Key, Mapping>, TFromType<Value, Mapping>> :
+    Mapped
+  )
+> = Result
+/** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
+// prettier-ignore
+export function Remap(type: t.TSchema, callback: TCallback): t.TSchema {
+  // Map incoming type
+  const mapped = t.CloneType(FromType(type, callback))
+  // Return remapped interior
+  return (
+    t.KindGuard.IsConstructor(type) ? t.Constructor(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
+    t.KindGuard.IsFunction(type) ? t.Function(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
+    t.KindGuard.IsIntersect(type) ? t.Intersect(FromTypes(type.allOf, callback), mapped) :
+    t.KindGuard.IsUnion(type) ? t.Union(FromTypes(type.anyOf, callback), mapped) :
+    t.KindGuard.IsTuple(type) ? t.Tuple(FromTypes(type.items || [], callback), mapped) :
+    t.KindGuard.IsArray(type) ? t.Array(FromType(type.items, callback), mapped) :
+    t.KindGuard.IsAsyncIterator(type) ? t.AsyncIterator(FromType(type.items, callback), mapped) :
+    t.KindGuard.IsIterator(type) ? t.Iterator(FromType(type.items, callback), mapped) :
+    t.KindGuard.IsPromise(type) ? t.Promise(FromType(type.items, callback), mapped) :
+    t.KindGuard.IsObject(type) ? t.Object(FromProperties(type.properties, callback), mapped) :
+    t.KindGuard.IsRecord(type) ? t.Record(FromType(t.RecordKey(type), callback), FromType(t.RecordValue(type), callback), mapped) :
+    t.CloneType(mapped)
+  )
+}
diff --git a/src/type/type/javascript.ts b/src/type/type/javascript.ts
index 13705e5d7..daba64887 100644
--- a/src/type/type/javascript.ts
+++ b/src/type/type/javascript.ts
@@ -27,6 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { JsonTypeBuilder } from './json'
+import { Argument, type TArgument } from '../argument/index'
 import { AsyncIterator, type TAsyncIterator } from '../async-iterator/index'
 import { Awaited, type TAwaited } from '../awaited/index'
 import { BigInt, type TBigInt, type BigIntOptions } from '../bigint/index'
@@ -35,6 +36,7 @@ import { ConstructorParameters, type TConstructorParameters } from '../construct
 import { Date, type TDate, type DateOptions } from '../date/index'
 import { Function as FunctionType, type TFunction } from '../function/index'
 import { InstanceType, type TInstanceType } from '../instance-type/index'
+import { Instantiate, type TInstantiate } from '../instantiate/index'
 import { Iterator, type TIterator } from '../iterator/index'
 import { Parameters, type TParameters } from '../parameters/index'
 import { Promise, type TPromise } from '../promise/index'
@@ -48,6 +50,10 @@ import { Void, type TVoid } from '../void/index'
 
 /** JavaScript Type Builder with Static Resolution for TypeScript */
 export class JavaScriptTypeBuilder extends JsonTypeBuilder {
+  /** `[JavaScript]` Creates a Generic Argument Type */
+  public Argument<Index extends number>(index: Index): TArgument<Index> {
+    return Argument(index)
+  }
   /** `[JavaScript]` Creates a AsyncIterator type */
   public AsyncIterator<Type extends TSchema>(items: Type, options?: SchemaOptions): TAsyncIterator<Type> {
     return AsyncIterator(items, options)
@@ -80,6 +86,10 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
   public InstanceType<Type extends TSchema>(schema: Type, options?: SchemaOptions): TInstanceType<Type> {
     return InstanceType(schema, options)
   }
+  /** `[JavaScript]` Instantiates a type with the given parameters */
+  public Instantiate<Type extends TSchema, Parameters extends TSchema[]>(schema: Type, parameters: [...Parameters]): TInstantiate<Type, Parameters> {
+    return Instantiate(schema, parameters)
+  }
   /** `[JavaScript]` Creates an Iterator type */
   public Iterator<Type extends TSchema>(items: Type, options?: SchemaOptions): TIterator<Type> {
     return Iterator(items, options)
diff --git a/src/type/type/type.ts b/src/type/type/type.ts
index 85ed02710..d384cfa33 100644
--- a/src/type/type/type.ts
+++ b/src/type/type/type.ts
@@ -30,6 +30,7 @@ THE SOFTWARE.
 // Type: Module
 // ------------------------------------------------------------------
 export { Any } from '../any/index'
+export { Argument } from '../argument/index'
 export { Array } from '../array/index'
 export { AsyncIterator } from '../async-iterator/index'
 export { Awaited } from '../awaited/index'
@@ -47,6 +48,7 @@ export { Extract } from '../extract/index'
 export { Function } from '../function/index'
 export { Index } from '../indexed/index'
 export { InstanceType } from '../instance-type/index'
+export { Instantiate } from '../instantiate/index'
 export { Integer } from '../integer/index'
 export { Intersect } from '../intersect/index'
 export { Capitalize, Uncapitalize, Lowercase, Uppercase } from '../intrinsic/index'
@@ -72,6 +74,7 @@ export { Record } from '../record/index'
 export { Recursive } from '../recursive/index'
 export { Ref } from '../ref/index'
 export { RegExp } from '../regexp/index'
+export { Remap } from '../remap/index'
 export { Required } from '../required/index'
 export { Rest } from '../rest/index'
 export { ReturnType } from '../return-type/index'
diff --git a/src/value/check/check.ts b/src/value/check/check.ts
index f55475c64..7a61d9ad1 100644
--- a/src/value/check/check.ts
+++ b/src/value/check/check.ts
@@ -36,9 +36,11 @@ import { TypeRegistry, FormatRegistry } from '../../type/registry/index'
 import { TypeBoxError } from '../../type/error/index'
 
 import type { TSchema } from '../../type/schema/index'
-import type { TAsyncIterator } from '../../type/async-iterator/index'
+
 import type { TAny } from '../../type/any/index'
+import type { TArgument } from '../../type/argument/index'
 import type { TArray } from '../../type/array/index'
+import type { TAsyncIterator } from '../../type/async-iterator/index'
 import type { TBigInt } from '../../type/bigint/index'
 import type { TBoolean } from '../../type/boolean/index'
 import type { TDate } from '../../type/date/index'
@@ -104,6 +106,9 @@ function IsDefined<T>(value: unknown): value is T {
 function FromAny(schema: TAny, references: TSchema[], value: any): boolean {
   return true
 }
+function FromArgument(schema: TArgument, references: TSchema[], value: any): boolean {
+  return true
+}
 function FromArray(schema: TArray, references: TSchema[], value: any): boolean {
   if (!IsArray(value)) return false
   if (IsDefined<number>(schema.minItems) && !(value.length >= schema.minItems)) {
@@ -426,6 +431,8 @@ function Visit<T extends TSchema>(schema: T, references: TSchema[], value: any):
   switch (schema_[Kind]) {
     case 'Any':
       return FromAny(schema_, references_, value)
+    case 'Argument':
+      return FromArgument(schema_, references_, value)
     case 'Array':
       return FromArray(schema_, references_, value)
     case 'AsyncIterator':
diff --git a/src/value/create/create.ts b/src/value/create/create.ts
index b56ab26fa..3af0245d9 100644
--- a/src/value/create/create.ts
+++ b/src/value/create/create.ts
@@ -97,6 +97,9 @@ function FromAny(schema: TAny, references: TSchema[]): any {
     return {}
   }
 }
+function FromArgument(schema: TAny, references: TSchema[]): any {
+  return {}
+}
 function FromArray(schema: TArray, references: TSchema[]): any {
   if (schema.uniqueItems === true && !HasPropertyKey(schema, 'default')) {
     throw new ValueCreateError(schema, 'Array with the uniqueItems constraint requires a default value')
@@ -403,6 +406,8 @@ function Visit(schema: TSchema, references: TSchema[]): unknown {
   switch (schema_[Kind]) {
     case 'Any':
       return FromAny(schema_, references_)
+    case 'Argument':
+      return FromArgument(schema_, references_)
     case 'Array':
       return FromArray(schema_, references_)
     case 'AsyncIterator':
diff --git a/test/runtime/compiler/argument.ts b/test/runtime/compiler/argument.ts
new file mode 100644
index 000000000..502df49c6
--- /dev/null
+++ b/test/runtime/compiler/argument.ts
@@ -0,0 +1,41 @@
+import { Type } from '@sinclair/typebox'
+import { Ok } from './validate'
+
+describe('compiler/Argument', () => {
+  it('Should validate number', () => {
+    const T = Type.Argument(0)
+    Ok(T, 1)
+  })
+  it('Should validate string', () => {
+    const T = Type.Argument(0)
+    Ok(T, 'hello')
+  })
+  it('Should validate boolean', () => {
+    const T = Type.Argument(0)
+    Ok(T, true)
+  })
+  it('Should validate array', () => {
+    const T = Type.Argument(0)
+    Ok(T, [1, 2, 3])
+  })
+  it('Should validate object', () => {
+    const T = Type.Argument(0)
+    Ok(T, { a: 1, b: 2 })
+  })
+  it('Should validate null', () => {
+    const T = Type.Argument(0)
+    Ok(T, null)
+  })
+  it('Should validate undefined', () => {
+    const T = Type.Argument(0)
+    Ok(T, undefined)
+  })
+  it('Should validate bigint', () => {
+    const T = Type.Argument(0)
+    Ok(T, BigInt(1))
+  })
+  it('Should validate symbol', () => {
+    const T = Type.Argument(0)
+    Ok(T, Symbol(1))
+  })
+})
diff --git a/test/runtime/compiler/index.ts b/test/runtime/compiler/index.ts
index a39e51760..4bb587c30 100644
--- a/test/runtime/compiler/index.ts
+++ b/test/runtime/compiler/index.ts
@@ -1,5 +1,6 @@
 import './__members'
 import './any'
+import './argument'
 import './array'
 import './async-iterator'
 import './bigint'
diff --git a/test/runtime/compiler/validate.ts b/test/runtime/compiler/validate.ts
index eb3ab6a0e..508d49738 100644
--- a/test/runtime/compiler/validate.ts
+++ b/test/runtime/compiler/validate.ts
@@ -59,6 +59,7 @@ FormatRegistry.Set('date-time', (value) => isDateTime(value, true))
 export function Ok<T extends TSchema>(schema: T, data: unknown, references: any[] = []) {
   const C = TypeCompiler.Compile(schema, references)
   const result = C.Check(data)
+
   if (result !== Value.Check(schema, references, data)) {
     throw Error('Compiler and Value Check disparity')
   }
diff --git a/test/runtime/syntax/syntax.ts b/test/runtime/syntax/syntax.ts
index 6f66c2ec1..62749598e 100644
--- a/test/runtime/syntax/syntax.ts
+++ b/test/runtime/syntax/syntax.ts
@@ -390,4 +390,33 @@ describe('syntax/Syntax', () => {
     const T = Syntax(`void`)
     Assert.IsTrue(TypeGuard.IsVoid(T))
   })
+  // ----------------------------------------------------------------
+  // Argument + Instantiation
+  // ----------------------------------------------------------------
+  it('Should parse Argument 0', () => {
+    const G = Syntax(`[Argument<0>]`)
+    const T = Syntax({ G }, `G`)
+    Assert.IsTrue(TypeGuard.IsTuple(T))
+    Assert.IsTrue(TypeGuard.IsArgument(T.items![0]))
+  })
+  it('Should parse Argument 1', () => {
+    const G = Syntax(`[Argument<0>]`)
+    const T = Syntax({ G }, `G<number>`)
+    Assert.IsTrue(TypeGuard.IsTuple(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.items![0]))
+  })
+  it('Should parse Argument 2', () => {
+    const G = Syntax(`[Argument<0>, Argument<1>]`)
+    const T = Syntax({ G }, `G<number, string>`)
+    Assert.IsTrue(TypeGuard.IsTuple(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.items![0]))
+    Assert.IsTrue(TypeGuard.IsString(T.items![1]))
+  })
+  it('Should parse Argument 3', () => {
+    const G = Syntax(`[Argument<0>, Argument<1>]`)
+    const T = Syntax({ G }, `G<number>`)
+    Assert.IsTrue(TypeGuard.IsTuple(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.items![0]))
+    Assert.IsTrue(TypeGuard.IsNever(T.items![1]))
+  })
 })
diff --git a/test/runtime/type/guard/kind/argument.ts b/test/runtime/type/guard/kind/argument.ts
new file mode 100644
index 000000000..5739e1eee
--- /dev/null
+++ b/test/runtime/type/guard/kind/argument.ts
@@ -0,0 +1,14 @@
+import { KindGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/kind/TArgument', () => {
+  it('Should guard for TArgument', () => {
+    const R = KindGuard.IsArgument(Type.Argument(0))
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TArgument', () => {
+    const R = KindGuard.IsArgument(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/kind/index.ts b/test/runtime/type/guard/kind/index.ts
index d3d241ded..d8e59fb7d 100644
--- a/test/runtime/type/guard/kind/index.ts
+++ b/test/runtime/type/guard/kind/index.ts
@@ -1,4 +1,5 @@
 import './any'
+import './argument'
 import './array'
 import './async-iterator'
 import './awaited'
diff --git a/test/runtime/type/guard/type/argument.ts b/test/runtime/type/guard/type/argument.ts
new file mode 100644
index 000000000..904cf8068
--- /dev/null
+++ b/test/runtime/type/guard/type/argument.ts
@@ -0,0 +1,14 @@
+import { TypeGuard } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../../assert/index'
+
+describe('guard/type/TArgument', () => {
+  it('Should guard for TArgument', () => {
+    const R = TypeGuard.IsArgument(Type.Argument(0))
+    Assert.IsTrue(R)
+  })
+  it('Should not guard for TArgument', () => {
+    const R = TypeGuard.IsArgument(null)
+    Assert.IsFalse(R)
+  })
+})
diff --git a/test/runtime/type/guard/type/index.ts b/test/runtime/type/guard/type/index.ts
index d3d241ded..d8e59fb7d 100644
--- a/test/runtime/type/guard/type/index.ts
+++ b/test/runtime/type/guard/type/index.ts
@@ -1,4 +1,5 @@
 import './any'
+import './argument'
 import './array'
 import './async-iterator'
 import './awaited'
diff --git a/test/runtime/type/guard/type/record.ts b/test/runtime/type/guard/type/record.ts
index 38c7d1bc4..0bf69119a 100644
--- a/test/runtime/type/guard/type/record.ts
+++ b/test/runtime/type/guard/type/record.ts
@@ -1,5 +1,5 @@
 import { TypeGuard, PatternNumberExact, PatternStringExact, PatternNeverExact, PatternString, PatternNumber } from '@sinclair/typebox'
-import { Type } from '@sinclair/typebox'
+import { Type, RecordKey, RecordValue, RecordPattern } from '@sinclair/typebox'
 import { Assert } from '../../../assert/index'
 
 describe('guard/type/TRecord', () => {
@@ -151,16 +151,52 @@ describe('guard/type/TRecord', () => {
     )
     Assert.IsFalse(R)
   })
-  it('Normalize: Should should normalize to TObject for single literal union value', () => {
+  it('Normalize: Should normalize to TObject for single literal union value', () => {
     const K = Type.Union([Type.Literal('ok')])
     const R = TypeGuard.IsObject(Type.Record(K, Type.Number()))
     Assert.IsTrue(R)
   })
-  it('Normalize: Should should normalize to TObject for multi literal union value', () => {
+  it('Normalize: Should normalize to TObject for multi literal union value', () => {
     const K = Type.Union([Type.Literal('A'), Type.Literal('B')])
     const R = TypeGuard.IsObject(Type.Record(K, Type.Number()))
     Assert.IsTrue(R)
   })
+  it('Normalize: Should normalize boolean key into true and false', () => {
+    const K = Type.Boolean()
+    const R = Type.Record(K, Type.Number())
+    Assert.IsTrue(TypeGuard.IsObject(R))
+    Assert.IsTrue(TypeGuard.IsNumber(R.properties.true))
+    Assert.IsTrue(TypeGuard.IsNumber(R.properties.false))
+  })
+  // ------------------------------------------------------------------
+  // Utility Types
+  // ------------------------------------------------------------------
+  it('Should return RecordPattern', () => {
+    const R = Type.Record(Type.Number(), Type.Number())
+    const K = RecordPattern(R)
+    Assert.IsTrue(typeof K === 'string')
+  })
+  it('Should return RecordKey (Number)', () => {
+    const R = Type.Record(Type.Number(), Type.Number())
+    const K = RecordKey(R)
+    Assert.IsTrue(TypeGuard.IsNumber(K))
+  })
+  it('Should return RecordKey (String)', () => {
+    const R = Type.Record(Type.String(), Type.Number())
+    const K = RecordKey(R)
+    Assert.IsTrue(TypeGuard.IsString(K))
+  })
+  it('Should return RecordKey (RegExp)', () => {
+    const R = Type.Record(Type.RegExp(/(a|b)/), Type.Number())
+    const K = RecordKey(R)
+    Assert.IsTrue(TypeGuard.IsString(K)) // facade
+  })
+  it('Should return RecordValue', () => {
+    const R = Type.Record(Type.String(), Type.Literal(12345))
+    const V = RecordValue(R)
+    Assert.IsTrue(TypeGuard.IsLiteral(V))
+    Assert.IsEqual(V.const, 12345)
+  })
   // ------------------------------------------------------------------
   // Evaluated: Dollar Sign Escape
   // https://github.com/sinclairzx81/typebox/issues/794
diff --git a/test/runtime/value/check/argument.ts b/test/runtime/value/check/argument.ts
new file mode 100644
index 000000000..7a49e8bbf
--- /dev/null
+++ b/test/runtime/value/check/argument.ts
@@ -0,0 +1,47 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/check/Argument', () => {
+  const T = Type.Argument(0)
+  it('Should pass string', () => {
+    const value = 'hello'
+    const result = Value.Check(T, value)
+    Assert.IsEqual(result, true)
+  })
+  it('Should pass number', () => {
+    const value = 1
+    const result = Value.Check(T, value)
+    Assert.IsEqual(result, true)
+  })
+  it('Should pass boolean', () => {
+    const value = true
+    const result = Value.Check(T, value)
+    Assert.IsEqual(result, true)
+  })
+  it('Should pass null', () => {
+    const value = null
+    const result = Value.Check(T, value)
+    Assert.IsEqual(result, true)
+  })
+  it('Should pass undefined', () => {
+    const value = undefined
+    const result = Value.Check(T, value)
+    Assert.IsEqual(result, true)
+  })
+  it('Should pass object', () => {
+    const value = { a: 1 }
+    const result = Value.Check(T, value)
+    Assert.IsEqual(result, true)
+  })
+  it('Should pass array', () => {
+    const value = [1, 2]
+    const result = Value.Check(T, value)
+    Assert.IsEqual(result, true)
+  })
+  it('Should pass Date', () => {
+    const value = new Date()
+    const result = Value.Check(T, value)
+    Assert.IsEqual(result, true)
+  })
+})
diff --git a/test/runtime/value/check/index.ts b/test/runtime/value/check/index.ts
index 27bda1e41..ae71b7d46 100644
--- a/test/runtime/value/check/index.ts
+++ b/test/runtime/value/check/index.ts
@@ -1,4 +1,5 @@
 import './any'
+import './argument'
 import './array'
 import './async-iterator'
 import './bigint'
diff --git a/test/runtime/value/create/argument.ts b/test/runtime/value/create/argument.ts
new file mode 100644
index 000000000..55bd0de07
--- /dev/null
+++ b/test/runtime/value/create/argument.ts
@@ -0,0 +1,10 @@
+import { Value } from '@sinclair/typebox/value'
+import { Type } from '@sinclair/typebox'
+import { Assert } from '../../assert/index'
+
+describe('value/create/Argument', () => {
+  it('Should create value', () => {
+    const T = Type.Argument(0)
+    Assert.IsEqual(Value.Create(T), {})
+  })
+})
diff --git a/test/runtime/value/create/index.ts b/test/runtime/value/create/index.ts
index 9962a44f0..78c340b5e 100644
--- a/test/runtime/value/create/index.ts
+++ b/test/runtime/value/create/index.ts
@@ -1,5 +1,6 @@
 import './_deferred'
 import './any'
+import './argument'
 import './array'
 import './async-iterator'
 import './bigint'
diff --git a/test/static/argument.ts b/test/static/argument.ts
new file mode 100644
index 000000000..588f80827
--- /dev/null
+++ b/test/static/argument.ts
@@ -0,0 +1,21 @@
+import { Expect } from './assert'
+import { Type } from '@sinclair/typebox'
+
+const T = Type.Object({
+  x: Type.Argument(0),
+  y: Type.Argument(1),
+  z: Type.Argument(2),
+})
+const I = Type.Instantiate(T, [Type.Literal(1), Type.Literal(2), Type.Literal(3)])
+// Infer as Broadest Type (Pending Generic Constraints)
+Expect(T).ToStatic<{
+  x: unknown
+  y: unknown
+  z: unknown
+}>()
+// Infer as Narrowed Type
+Expect(I).ToStatic<{
+  x: 1
+  y: 2
+  z: 3
+}>()
diff --git a/test/static/index.ts b/test/static/index.ts
index c6af9e754..40c2067b3 100644
--- a/test/static/index.ts
+++ b/test/static/index.ts
@@ -1,4 +1,5 @@
 import './any'
+import './argument'
 import './array'
 import './async-iterator'
 import './awaited'

From 6b76fb949b764f2c9f55fa9cf1a69586c0fce7db Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 12 Feb 2025 21:41:11 +0900
Subject: [PATCH 335/369] Revision 0.34.18 (#1164)

* Fix Remap Imports

* ChangeLog
---
 changelog/0.34.0.md     |  2 +
 package-lock.json       |  4 +-
 package.json            |  2 +-
 src/type/remap/remap.ts | 92 ++++++++++++++++++++++++-----------------
 4 files changed, 58 insertions(+), 42 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index a41e509af..1394faf14 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,4 +1,6 @@
 ### 0.34.0
+- [Revision 0.34.18](https://github.com/sinclairzx81/typebox/pull/1164)
+  - Hotfix: Internal Remap Imports
 - [Revision 0.34.17](https://github.com/sinclairzx81/typebox/pull/1162)
   - Add Argument() and Instantiate() Types and Instancing via Syntax support.
 - [Revision 0.34.16](https://github.com/sinclairzx81/typebox/pull/1156)
diff --git a/package-lock.json b/package-lock.json
index eab2429fc..36a3e8e75 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.17",
+  "version": "0.34.18",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.17",
+      "version": "0.34.18",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 217a3e6d6..ddefae7aa 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.17",
+  "version": "0.34.18",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/remap/remap.ts b/src/type/remap/remap.ts
index 3354b87ca..d0c707cfc 100644
--- a/src/type/remap/remap.ts
+++ b/src/type/remap/remap.ts
@@ -26,12 +26,26 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import * as t from '@sinclair/typebox'
+import { TSchema } from '../schema/index'
+import { Object, TObject, TProperties } from '../object/index'
+import { Constructor, TConstructor } from '../constructor/index'
+import { Function, TFunction } from '../function/index'
+import { Intersect, TIntersect } from '../intersect/index'
+import { Union, TUnion } from '../union/index'
+import { Tuple, TTuple } from '../tuple/index'
+import { Array, TArray } from '../array/index'
+import { AsyncIterator, TAsyncIterator } from '../async-iterator/index'
+import { Iterator, TIterator } from '../iterator/index'
+import { Promise, TPromise } from '../promise/index'
+import { Record, TRecord, TRecordOrObject, RecordKey, RecordValue } from '../record/index'
+
+import * as KindGuard from '../guard/kind'
+import { CloneType } from '../clone/type'
 
 // ------------------------------------------------------------------
 // Callback
 // ------------------------------------------------------------------
-export type TCallback = (schema: t.TSchema) => t.TSchema
+export type TCallback = (schema: TSchema) => TSchema
 // ------------------------------------------------------------------
 // Mapping
 // ------------------------------------------------------------------
@@ -43,18 +57,18 @@ export interface TMapping {
 // Apply
 // ------------------------------------------------------------------
 // prettier-ignore
-type TApply<Type extends t.TSchema, Mapping extends TMapping,
+type TApply<Type extends TSchema, Mapping extends TMapping,
   Mapped = (Mapping & { input: Type })['output'],
-  Result = Mapped extends t.TSchema ? Mapped : never
+  Result = Mapped extends TSchema ? Mapped : never
 > = Result
 // ------------------------------------------------------------------
 // Properties
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromProperties<Properties extends t.TProperties, Mapping extends TMapping, Result extends t.TProperties = {
+type TFromProperties<Properties extends TProperties, Mapping extends TMapping, Result extends TProperties = {
   [Key in keyof Properties]: TRemap<Properties[Key], Mapping>
 }> = Result
-function FromProperties(properties: t.TProperties, func: TCallback): t.TProperties {
+function FromProperties(properties: TProperties, func: TCallback): TProperties {
   return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
     return { ...result, [key]: Remap(properties[key], func) }
   }, {})
@@ -63,22 +77,22 @@ function FromProperties(properties: t.TProperties, func: TCallback): t.TProperti
 // Types
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromTypes<Types extends t.TSchema[], Mapping extends TMapping, Result extends t.TSchema[] = []> = (
-  Types extends [infer Left extends t.TSchema, ...infer Right extends t.TSchema[]]
+type TFromTypes<Types extends TSchema[], Mapping extends TMapping, Result extends TSchema[] = []> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
     ? TFromTypes<Right, Mapping, [...Result, TRemap<Left, Mapping>]>
     : Result
 )
-function FromTypes(types: t.TSchema[], callback: TCallback): t.TSchema[] {
+function FromTypes(types: TSchema[], callback: TCallback): TSchema[] {
   return types.map((type) => Remap(type, callback))
 }
 // ------------------------------------------------------------------
 // Type
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromType<Type extends t.TSchema, Mapping extends TMapping, Result extends t.TSchema = (
+type TFromType<Type extends TSchema, Mapping extends TMapping, Result extends TSchema = (
   TApply<Type, Mapping>
 )> = Result
-function FromType(type: t.TSchema, callback: TCallback): t.TSchema {
+function FromType(type: TSchema, callback: TCallback): TSchema {
   return callback(type)
 }
 // ------------------------------------------------------------------
@@ -86,43 +100,43 @@ function FromType(type: t.TSchema, callback: TCallback): t.TSchema {
 // ------------------------------------------------------------------
 /** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
 // prettier-ignore
-export type TRemap<Type extends t.TSchema, Mapping extends TMapping, 
+export type TRemap<Type extends TSchema, Mapping extends TMapping, 
   // Maps the Exterior Type
-  Mapped extends t.TSchema = TFromType<Type, Mapping>, 
+  Mapped extends TSchema = TFromType<Type, Mapping>, 
   // Maps the Interior Parameterized Types
-  Result extends t.TSchema = (
-    Mapped extends t.TConstructor<infer Parameters extends t.TSchema[], infer ReturnType extends t.TSchema> ? t.TConstructor<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> :
-    Mapped extends t.TFunction<infer Parameters extends t.TSchema[], infer ReturnType extends t.TSchema> ? t.TFunction<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> :
-    Mapped extends t.TIntersect<infer Types extends t.TSchema[]> ? t.TIntersect<TFromTypes<Types, Mapping>> :
-    Mapped extends t.TUnion<infer Types extends t.TSchema[]> ? t.TUnion<TFromTypes<Types, Mapping>> :
-    Mapped extends t.TTuple<infer Types extends t.TSchema[]> ? t.TTuple<TFromTypes<Types, Mapping>> :
-    Mapped extends t.TArray<infer Type extends t.TSchema> ? t.TArray<TFromType<Type, Mapping>>:
-    Mapped extends t.TAsyncIterator<infer Type extends t.TSchema> ? t.TAsyncIterator<TFromType<Type, Mapping>> :
-    Mapped extends t.TIterator<infer Type extends t.TSchema> ? t.TIterator<TFromType<Type, Mapping>> :
-    Mapped extends t.TPromise<infer Type extends t.TSchema> ? t.TPromise<TFromType<Type, Mapping>> :
-    Mapped extends t.TObject<infer Properties extends t.TProperties> ? t.TObject<TFromProperties<Properties, Mapping>> :
-    Mapped extends t.TRecord<infer Key extends t.TSchema, infer Value extends t.TSchema> ? t.TRecordOrObject<TFromType<Key, Mapping>, TFromType<Value, Mapping>> :
+  Result extends TSchema = (
+    Mapped extends TConstructor<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TConstructor<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> :
+    Mapped extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> :
+    Mapped extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Types, Mapping>> :
+    Mapped extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Types, Mapping>> :
+    Mapped extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Types, Mapping>> :
+    Mapped extends TArray<infer Type extends TSchema> ? TArray<TFromType<Type, Mapping>>:
+    Mapped extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TFromType<Type, Mapping>> :
+    Mapped extends TIterator<infer Type extends TSchema> ? TIterator<TFromType<Type, Mapping>> :
+    Mapped extends TPromise<infer Type extends TSchema> ? TPromise<TFromType<Type, Mapping>> :
+    Mapped extends TObject<infer Properties extends TProperties> ? TObject<TFromProperties<Properties, Mapping>> :
+    Mapped extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TRecordOrObject<TFromType<Key, Mapping>, TFromType<Value, Mapping>> :
     Mapped
   )
 > = Result
 /** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
 // prettier-ignore
-export function Remap(type: t.TSchema, callback: TCallback): t.TSchema {
+export function Remap(type: TSchema, callback: TCallback): TSchema {
   // Map incoming type
-  const mapped = t.CloneType(FromType(type, callback))
+  const mapped = CloneType(FromType(type, callback))
   // Return remapped interior
   return (
-    t.KindGuard.IsConstructor(type) ? t.Constructor(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
-    t.KindGuard.IsFunction(type) ? t.Function(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
-    t.KindGuard.IsIntersect(type) ? t.Intersect(FromTypes(type.allOf, callback), mapped) :
-    t.KindGuard.IsUnion(type) ? t.Union(FromTypes(type.anyOf, callback), mapped) :
-    t.KindGuard.IsTuple(type) ? t.Tuple(FromTypes(type.items || [], callback), mapped) :
-    t.KindGuard.IsArray(type) ? t.Array(FromType(type.items, callback), mapped) :
-    t.KindGuard.IsAsyncIterator(type) ? t.AsyncIterator(FromType(type.items, callback), mapped) :
-    t.KindGuard.IsIterator(type) ? t.Iterator(FromType(type.items, callback), mapped) :
-    t.KindGuard.IsPromise(type) ? t.Promise(FromType(type.items, callback), mapped) :
-    t.KindGuard.IsObject(type) ? t.Object(FromProperties(type.properties, callback), mapped) :
-    t.KindGuard.IsRecord(type) ? t.Record(FromType(t.RecordKey(type), callback), FromType(t.RecordValue(type), callback), mapped) :
-    t.CloneType(mapped)
+    KindGuard.IsConstructor(type) ? Constructor(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
+    KindGuard.IsFunction(type) ? Function(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
+    KindGuard.IsIntersect(type) ? Intersect(FromTypes(type.allOf, callback), mapped) :
+    KindGuard.IsUnion(type) ? Union(FromTypes(type.anyOf, callback), mapped) :
+    KindGuard.IsTuple(type) ? Tuple(FromTypes(type.items || [], callback), mapped) :
+    KindGuard.IsArray(type) ? Array(FromType(type.items, callback), mapped) :
+    KindGuard.IsAsyncIterator(type) ? AsyncIterator(FromType(type.items, callback), mapped) :
+    KindGuard.IsIterator(type) ? Iterator(FromType(type.items, callback), mapped) :
+    KindGuard.IsPromise(type) ? Promise(FromType(type.items, callback), mapped) :
+    KindGuard.IsObject(type) ? Object(FromProperties(type.properties, callback), mapped) :
+    KindGuard.IsRecord(type) ? Record(FromType(RecordKey(type), callback), FromType(RecordValue(type), callback), mapped) :
+    CloneType(mapped)
   )
 }

From de43700f4677571a42ce6d98a4fe182e8c5de536 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 12 Feb 2025 22:30:09 +0900
Subject: [PATCH 336/369] Revision 0.34.19 (#1166)

* Documentation

* Version
---
 package-lock.json |  4 ++--
 package.json      |  2 +-
 readme.md         | 29 +++++++++++++++--------------
 3 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 36a3e8e75..ce8e69fc7 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.18",
+  "version": "0.34.19",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.18",
+      "version": "0.34.19",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index ddefae7aa..93b83a4c5 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.18",
+  "version": "0.34.19",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index ba0ccc901..5ee6d1024 100644
--- a/readme.md
+++ b/readme.md
@@ -1390,25 +1390,26 @@ const S = Syntax({ T }, `{ x: T, y: T, z: T }`)     // const S: TObject<{
 
 ### Generics
 
-Generic types can be created by passing Argument types as parameters.
+Generic types can be created using Argument types.
 
 ```typescript
-// Generic Vector Type
-
-const Vector = Syntax({                             // type Vector<X, Y, Z> = {
-  X: Type.Argument(0),                              //   x: X
-  Y: Type.Argument(1),                              //   y: Y,
-  Z: Type.Argument(2)                               //   z: Z
-},                                                  // }
-`{                            
-  x: X,
-  y: Y,
-  z: Z
+const Vector = Syntax(`{
+  x: Argument<0>,
+  y: Argument<1>,
+  z: Argument<2>
 }`)
 
-// Instanced Vector Type 
+const Basis = Syntax({ Vector }, `{
+  x: Vector<1, 0, 0>,
+  y: Vector<0, 1, 0>,
+  z: Vector<0, 0, 1>,
+}`)
 
-const Up = Syntax({ Vector }, `Vector<0, 1, 0>`)    // type Up = Vector<0, 1, 0>
+type Basis = Static<typeof Basis>                   // type Basis = {
+                                                    //   x: { x: 1, y: 0, z: 0 },
+                                                    //   y: { x: 0, y: 1, z: 0 },
+                                                    //   z: { x: 0, y: 0, z: 1 }
+                                                    // } 
 ```
 
 <a name='typeregistry'></a>

From bf4391f0416a1b90d9b734fc05d4ced37e4c58bf Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 13 Feb 2025 01:56:28 +0900
Subject: [PATCH 337/369] Revision 0.34.20 (#1167)

* Disable Computed Types on Record

* Version

* ChangeLog
---
 changelog/0.34.0.md                      |  4 ++
 package-lock.json                        |  4 +-
 package.json                             |  2 +-
 src/type/record/record.ts                |  8 ----
 test/runtime/type/guard/kind/computed.ts |  7 +--
 test/runtime/type/guard/kind/import.ts   | 22 ++++-----
 test/runtime/type/guard/type/computed.ts |  7 +--
 test/runtime/type/guard/type/import.ts   | 22 ++++-----
 test/static/import.ts                    | 60 ++++++++++++------------
 9 files changed, 63 insertions(+), 73 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 1394faf14..b10199e25 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,4 +1,8 @@
 ### 0.34.0
+- [Revision 0.34.20](https://github.com/sinclairzx81/typebox/pull/1167)
+  - Hotfix: Disable Computed Types on Record
+- [Revision 0.34.19](https://github.com/sinclairzx81/typebox/pull/1166)
+  - Hotfix: Republished due to NPM error
 - [Revision 0.34.18](https://github.com/sinclairzx81/typebox/pull/1164)
   - Hotfix: Internal Remap Imports
 - [Revision 0.34.17](https://github.com/sinclairzx81/typebox/pull/1162)
diff --git a/package-lock.json b/package-lock.json
index ce8e69fc7..d77b8c158 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.19",
+  "version": "0.34.20",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.19",
+      "version": "0.34.20",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 93b83a4c5..7c918efa2 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.19",
+  "version": "0.34.20",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/record/record.ts b/src/type/record/record.ts
index e22e180df..53d5ead10 100644
--- a/src/type/record/record.ts
+++ b/src/type/record/record.ts
@@ -33,14 +33,12 @@ import type { Static } from '../static/index'
 import type { Evaluate, Ensure, Assert } from '../helpers/index'
 import { type TAny } from '../any/index'
 import { type TBoolean } from '../boolean/index'
-import { type TComputed, Computed } from '../computed/index'
 import { type TEnumRecord, type TEnum } from '../enum/index'
 import { type TInteger } from '../integer/index'
 import { type TLiteral, type TLiteralValue } from '../literal/index'
 import { type TNever, Never } from '../never/index'
 import { type TNumber, Number } from '../number/index'
 import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions, Object } from '../object/index'
-import { type TRef, Ref } from '../ref/index'
 import { type TRegExp } from '../regexp/index'
 import { type TString, String } from '../string/index'
 import { type TUnion, Union } from '../union/index'
@@ -233,9 +231,6 @@ export interface TRecord<Key extends TSchema = TSchema, Type extends TSchema = T
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = (
-  Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [Key, TComputed<Target, Parameters>]> :
-  Key extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [TComputed<Target, Parameters>, Type]> :
-  Key extends TRef<infer Ref extends string> ? TComputed<'Record', [TRef<Ref>, Type]> :
   Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> :  
   Key extends TEnum<infer Enum extends TEnumRecord> ? TFromEnumKey<Enum, Type> : // (Special: Ensure resolve Enum before Union)
   Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Type> :
@@ -256,9 +251,6 @@ export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = (
 export function Record<Key extends TSchema, Type extends TSchema>(key: Key, type: Type, options: ObjectOptions = {}): TRecordOrObject<Key, Type> {
   // prettier-ignore
   return (
-    IsComputed(type) ? Computed('Record', [key, Computed(type.target, type.parameters)], options) :
-    IsComputed(key) ? Computed('Record', [Computed(type.target, type.parameters), type], options) :
-    IsRef(key) ? Computed('Record', [Ref(key.$ref), type]) :
     IsUnion(key) ? FromUnionKey(key.anyOf, type, options) :
     IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) :
     IsLiteral(key) ? FromLiteralKey(key.const, type, options) :
diff --git a/test/runtime/type/guard/kind/computed.ts b/test/runtime/type/guard/kind/computed.ts
index 38262833e..5d7929af9 100644
--- a/test/runtime/type/guard/kind/computed.ts
+++ b/test/runtime/type/guard/kind/computed.ts
@@ -18,19 +18,16 @@ describe('guard/kind/TComputed', () => {
     const T = Type.Record(Type.String(), Type.String())
     Assert.IsTrue(KindGuard.IsRecord(T))
   })
-  // TRecord<TRecordKey, TRef<...>> is not computed.
   it('Should guard for Record 3', () => {
     const T = Type.Record(Type.String(), Type.Ref('A'))
     Assert.IsTrue(KindGuard.IsRecord(T))
   })
-  // TRecord<TRecordKey, TComputed<..., [TRef<...>]> is computed due to interior computed.
   it('Should guard for Record 3', () => {
     const T = Type.Record(Type.String(), Type.Partial(Type.Ref('A')))
-    Assert.IsTrue(KindGuard.IsComputed(T))
+    Assert.IsTrue(KindGuard.IsRecord(T))
   })
-  // TRecord<TRef<...>, TSchema> is computed as schematics may be transformed to TObject if finite
   it('Should guard for Record 4', () => {
     const T = Type.Record(Type.Ref('A'), Type.String())
-    Assert.IsTrue(KindGuard.IsComputed(T))
+    Assert.IsTrue(KindGuard.IsNever(T))
   })
 })
diff --git a/test/runtime/type/guard/kind/import.ts b/test/runtime/type/guard/kind/import.ts
index 55bd572e7..529cd5f6c 100644
--- a/test/runtime/type/guard/kind/import.ts
+++ b/test/runtime/type/guard/kind/import.ts
@@ -151,17 +151,17 @@ describe('guard/kind/TImport', () => {
     Assert.IsTrue(KindGuard.IsRef(T.$defs['R'].patternProperties['^(.*)$']))
     Assert.IsTrue(T.$defs['R'].patternProperties['^(.*)$'].$ref === 'T')
   })
-  it('Should compute for Record 2', () => {
-    const Module = Type.Module({
-      T: Type.Number(),
-      K: Type.Union([Type.Literal('x'), Type.Literal('y')]),
-      R: Type.Record(Type.Ref('K'), Type.Ref('T')),
-    })
-    const T = Module.Import('R')
-    Assert.IsTrue(KindGuard.IsObject(T.$defs['R']))
-    Assert.IsTrue(KindGuard.IsNumber(T.$defs['R'].properties.x))
-    Assert.IsTrue(KindGuard.IsNumber(T.$defs['R'].properties.x))
-  })
+  // it('Should compute for Record 2', () => {
+  //   const Module = Type.Module({
+  //     T: Type.Number(),
+  //     K: Type.Union([Type.Literal('x'), Type.Literal('y')]),
+  //     R: Type.Record(Type.Ref('K'), Type.Ref('T')),
+  //   })
+  //   const T = Module.Import('R')
+  //   Assert.IsTrue(KindGuard.IsObject(T.$defs['R']))
+  //   Assert.IsTrue(KindGuard.IsNumber(T.$defs['R'].properties.x))
+  //   Assert.IsTrue(KindGuard.IsNumber(T.$defs['R'].properties.x))
+  // })
   // ----------------------------------------------------------------
   // Computed: Required
   // ----------------------------------------------------------------
diff --git a/test/runtime/type/guard/type/computed.ts b/test/runtime/type/guard/type/computed.ts
index 34de3be67..d4dd6df24 100644
--- a/test/runtime/type/guard/type/computed.ts
+++ b/test/runtime/type/guard/type/computed.ts
@@ -18,19 +18,16 @@ describe('guard/type/TComputed', () => {
     const T = Type.Record(Type.String(), Type.String())
     Assert.IsTrue(TypeGuard.IsRecord(T))
   })
-  // TRecord<TRecordKey, TRef<...>> is not computed.
   it('Should guard for Record 3', () => {
     const T = Type.Record(Type.String(), Type.Ref('A'))
     Assert.IsTrue(TypeGuard.IsRecord(T))
   })
-  // TRecord<TRecordKey, TComputed<..., [TRef<...>]> is computed due to interior computed.
   it('Should guard for Record 3', () => {
     const T = Type.Record(Type.String(), Type.Partial(Type.Ref('A')))
-    Assert.IsTrue(TypeGuard.IsComputed(T))
+    Assert.IsTrue(TypeGuard.IsRecord(T))
   })
-  // TRecord<TRef<...>, TSchema> is computed as schematics may be transformed to TObject if finite
   it('Should guard for Record 4', () => {
     const T = Type.Record(Type.Ref('A'), Type.String())
-    Assert.IsTrue(TypeGuard.IsComputed(T))
+    Assert.IsTrue(TypeGuard.IsNever(T))
   })
 })
diff --git a/test/runtime/type/guard/type/import.ts b/test/runtime/type/guard/type/import.ts
index 5388e2f29..8b0f3b2dc 100644
--- a/test/runtime/type/guard/type/import.ts
+++ b/test/runtime/type/guard/type/import.ts
@@ -151,17 +151,17 @@ describe('guard/type/TImport', () => {
     Assert.IsTrue(TypeGuard.IsRef(T.$defs['R'].patternProperties['^(.*)$']))
     Assert.IsTrue(T.$defs['R'].patternProperties['^(.*)$'].$ref === 'T')
   })
-  it('Should compute for Record 2', () => {
-    const Module = Type.Module({
-      T: Type.Number(),
-      K: Type.Union([Type.Literal('x'), Type.Literal('y')]),
-      R: Type.Record(Type.Ref('K'), Type.Ref('T')),
-    })
-    const T = Module.Import('R')
-    Assert.IsTrue(TypeGuard.IsObject(T.$defs['R']))
-    Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R'].properties.x))
-    Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R'].properties.x))
-  })
+  // it('Should compute for Record 2', () => {
+  //   const Module = Type.Module({
+  //     T: Type.Number(),
+  //     K: Type.Union([Type.Literal('x'), Type.Literal('y')]),
+  //     R: Type.Record(Type.Ref('K'), Type.Ref('T')),
+  //   })
+  //   const T = Module.Import('R')
+  //   Assert.IsTrue(TypeGuard.IsObject(T.$defs['R']))
+  //   Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R'].properties.x))
+  //   Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R'].properties.x))
+  // })
   // ----------------------------------------------------------------
   // Computed: Required
   // ----------------------------------------------------------------
diff --git a/test/static/import.ts b/test/static/import.ts
index ab546c453..010c3d645 100644
--- a/test/static/import.ts
+++ b/test/static/import.ts
@@ -58,49 +58,49 @@ import { Type, Static } from '@sinclair/typebox'
 // ------------------------------------------------------------------
 // prettier-ignore
 {
-  const T = Type.Module({
-    R: Type.Object({ x: Type.Number(), y: Type.Number() }),
-    T: Type.Record(Type.String(), Type.Partial(Type.Ref('R'))),
-  }).Import('T')
+  // const T = Type.Module({
+  //   R: Type.Object({ x: Type.Number(), y: Type.Number() }),
+  //   T: Type.Record(Type.String(), Type.Partial(Type.Ref('R'))),
+  // }).Import('T')
 
-  type T = Static<typeof T>
-  Expect(T).ToStatic<{ 
-    [key: string]: { x?: number, y?: number } 
-  }>()
+  // type T = Static<typeof T>
+  // Expect(T).ToStatic<{ 
+  //   [key: string]: { x?: number, y?: number } 
+  // }>()
 }
 // ------------------------------------------------------------------
 // Record 3
 // ------------------------------------------------------------------
 // prettier-ignore
 {
-  const T = Type.Module({
-    R: Type.Object({ x: Type.Number(), y: Type.Number() }),
-    K: Type.Number(),
-    T: Type.Record(Type.Ref('K'), Type.Partial(Type.Ref('R'))),
-  }).Import('T')
+  // const T = Type.Module({
+  //   R: Type.Object({ x: Type.Number(), y: Type.Number() }),
+  //   K: Type.Number(),
+  //   T: Type.Record(Type.Ref('K'), Type.Partial(Type.Ref('R'))),
+  // }).Import('T')
 
-  type T = Static<typeof T>
-  Expect(T).ToStatic<{ 
-    [key: number]: { x?: number, y?: number } 
-  }>()
+  // type T = Static<typeof T>
+  // Expect(T).ToStatic<{ 
+  //   [key: number]: { x?: number, y?: number } 
+  // }>()
 }
 // ------------------------------------------------------------------
 // Record 4
 // ------------------------------------------------------------------
 // prettier-ignore
-{
-  const T = Type.Module({
-    R: Type.Object({ x: Type.Number(), y: Type.Number() }),
-    K: Type.TemplateLiteral('${A|B|C}'),
-    T: Type.Record(Type.Ref('K'), Type.Partial(Type.Ref('R'))),
-  }).Import('T')
-  type T = Static<typeof T>
-  Expect(T).ToStatic<{ 
-    A: { x?: number, y?: number },
-    B: { x?: number, y?: number },
-    C: { x?: number, y?: number } 
-  }>()
-}
+// {
+//   const T = Type.Module({
+//     R: Type.Object({ x: Type.Number(), y: Type.Number() }),
+//     K: Type.TemplateLiteral('${A|B|C}'),
+//     T: Type.Record(Type.Ref('K'), Type.Partial(Type.Ref('R'))),
+//   }).Import('T')
+//   type T = Static<typeof T>
+//   Expect(T).ToStatic<{
+//     A: { x?: number, y?: number },
+//     B: { x?: number, y?: number },
+//     C: { x?: number, y?: number }
+//   }>()
+// }
 // ------------------------------------------------------------------
 // Modifiers 1
 // ------------------------------------------------------------------

From 1bd8f7810a68658f2b610da9668acd508d991440 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 13 Feb 2025 16:01:34 +0900
Subject: [PATCH 338/369] Revision 0.34.21 (#1168)

* Reimplement Computed Record Type

* Version
---
 changelog/0.34.0.md                    |  4 ++-
 package-lock.json                      |  4 +--
 package.json                           |  2 +-
 src/type/module/compute.ts             | 37 +++++++++++--------
 src/type/record/record.ts              | 25 +++++++------
 test/runtime/type/guard/kind/import.ts | 33 +++++++++++------
 test/runtime/type/guard/type/import.ts | 33 +++++++++++------
 test/static/import.ts                  | 49 +++++---------------------
 8 files changed, 95 insertions(+), 92 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index b10199e25..f2d9ade16 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,6 +1,8 @@
 ### 0.34.0
+- [Revision 0.34.21](https://github.com/sinclairzx81/typebox/pull/1168)
+  - Reimplement Computed Record Types
 - [Revision 0.34.20](https://github.com/sinclairzx81/typebox/pull/1167)
-  - Hotfix: Disable Computed Types on Record
+  - Hotfix: Disable Computed Record Types
 - [Revision 0.34.19](https://github.com/sinclairzx81/typebox/pull/1166)
   - Hotfix: Republished due to NPM error
 - [Revision 0.34.18](https://github.com/sinclairzx81/typebox/pull/1164)
diff --git a/package-lock.json b/package-lock.json
index d77b8c158..27a2d1f92 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.20",
+  "version": "0.34.21",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.20",
+      "version": "0.34.21",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 7c918efa2..90ccd20e0 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.20",
+  "version": "0.34.21",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/module/compute.ts b/src/type/module/compute.ts
index 9ca66adf0..abd138af9 100644
--- a/src/type/module/compute.ts
+++ b/src/type/module/compute.ts
@@ -27,6 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { CreateType } from '../create/index'
+import { CloneType } from '../clone/index'
 import { Discard } from '../discard/index'
 import { Ensure, Evaluate } from '../helpers/index'
 import { type TSchema } from '../schema/index'
@@ -48,7 +49,7 @@ import { Pick, type TPick } from '../pick/index'
 import { Never, type TNever } from '../never/index'
 import { Partial, TPartial } from '../partial/index'
 import { type TReadonly } from '../readonly/index'
-import { Record, type TRecordOrObject } from '../record/index'
+import { RecordValue, RecordPattern, type TRecordOrObject, type TRecord } from '../record/index'
 import { type TRef } from '../ref/index'
 import { Required, TRequired } from '../required/index'
 import { Tuple, type TTuple } from '../tuple/index'
@@ -177,17 +178,6 @@ function FromPick<Parameters extends TSchema[]>(parameters: Parameters): TFromPi
   return Pick(parameters[0], parameters[1]) as never
 }
 // ------------------------------------------------------------------
-// Record
-// ------------------------------------------------------------------
-// prettier-ignore
-type TFromRecord<Parameters extends TSchema[]> = (
-  Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TRecordOrObject<T0, T1> : never
-)
-// prettier-ignore
-function FromRecord<Parameters extends TSchema[]>(parameters: Parameters): TFromPick<Parameters> {
-  return Record(parameters[0], parameters[1]) as never
-}
-// ------------------------------------------------------------------
 // Required
 // ------------------------------------------------------------------
 // prettier-ignore
@@ -211,7 +201,6 @@ type TFromComputed<ModuleProperties extends TProperties, Target extends string,
   Target extends 'Partial' ? TFromPartial<Dereferenced> :
   Target extends 'Omit' ? TFromOmit<Dereferenced> :
   Target extends 'Pick' ? TFromPick<Dereferenced> :
-  Target extends 'Record' ? TFromRecord<Dereferenced> :
   Target extends 'Required' ? TFromRequired<Dereferenced> :
   TNever
 )
@@ -225,7 +214,6 @@ function FromComputed<ModuleProperties extends TProperties, Target extends strin
     target === 'Partial' ? FromPartial(dereferenced) :
     target === 'Omit' ? FromOmit(dereferenced) :
     target === 'Pick' ? FromPick(dereferenced) :
-    target === 'Record' ? FromRecord(dereferenced) :
     target === 'Required' ? FromRequired(dereferenced) :
     Never()
   ) as never
@@ -245,6 +233,25 @@ function FromObject<ModuleProperties extends TProperties, Properties extends TPr
   ) as never
 }
 // ------------------------------------------------------------------
+// Record
+//
+// Note: Varying Runtime and Static path here as we need to retain
+// constraints on the Record. This requires remapping the entire
+// Record in the Runtime path but where the Static path is merely
+// a facade for the patternProperties regular expression.
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRecord<ModuleProperties extends TProperties, Key extends TSchema, Value extends TSchema,
+  Result extends TSchema = TRecordOrObject<Key, TFromType<ModuleProperties, Value>> 
+> = Result
+// prettier-ignore
+function FromRecord<ModuleProperties extends TProperties, Type extends TRecord>(moduleProperties: ModuleProperties, type: Type): never {
+  const [value, pattern] = [FromType(moduleProperties, RecordValue(type)), RecordPattern(type)]
+  const result = CloneType(type)
+  result.patternProperties[pattern] = value
+  return result as never
+}
+// ------------------------------------------------------------------
 // Constructor
 // ------------------------------------------------------------------
 // prettier-ignore
@@ -363,6 +370,7 @@ export type TFromType<ModuleProperties extends TProperties, Type extends TSchema
   Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<ModuleProperties, Types> :
   Type extends TIterator<infer Type extends TSchema> ? TFromIterator<ModuleProperties, Type> :
   Type extends TObject<infer Properties extends TProperties> ? TFromObject<ModuleProperties, Properties> :
+  Type extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TFromRecord<ModuleProperties, Key, Value> :
   Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<ModuleProperties, Types> :
   Type extends TEnum<infer _ extends TEnumRecord> ? Type : // intercept enum before union
   Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<ModuleProperties, Types> :
@@ -383,6 +391,7 @@ export function FromType<ModuleProperties extends TProperties, Type extends TSch
     KindGuard.IsIntersect(type) ? CreateType(FromIntersect(moduleProperties, type.allOf), type) :
     KindGuard.IsIterator(type) ? CreateType(FromIterator(moduleProperties, type.items), type) :
     KindGuard.IsObject(type) ? CreateType(FromObject(moduleProperties, type.properties), type) :
+    KindGuard.IsRecord(type) ? CreateType(FromRecord(moduleProperties, type)) :
     KindGuard.IsTuple(type)? CreateType(FromTuple(moduleProperties, type.items || []), type) :
     KindGuard.IsUnion(type) ? CreateType(FromUnion(moduleProperties, type.anyOf), type) :
     type
diff --git a/src/type/record/record.ts b/src/type/record/record.ts
index 53d5ead10..f9a4fe540 100644
--- a/src/type/record/record.ts
+++ b/src/type/record/record.ts
@@ -277,14 +277,13 @@ export function RecordPattern(record: TRecord): string {
 // ------------------------------------------------------------------
 /** Gets the Records Key Type */
 // prettier-ignore
-export type TRecordKey<Type extends TRecord> = (
-  Type extends TRecord<infer Key extends TSchema, TSchema> 
-    ? (
-      Key extends TNumber ? TNumber :
-      Key extends TString ? TString :
-      TString
-    ) : TString
-)
+export type TRecordKey<Type extends TRecord,
+  Result extends TSchema = Type extends TRecord<infer Key extends TSchema, TSchema> ? (
+    Key extends TNumber ? TNumber :
+    Key extends TString ? TString :
+    TString
+  ) : TString
+> = Result
 /** Gets the Records Key Type */
 // prettier-ignore
 export function RecordKey<Type extends TRecord>(type: Type): TRecordKey<Type> {
@@ -300,9 +299,13 @@ export function RecordKey<Type extends TRecord>(type: Type): TRecordKey<Type> {
 // ------------------------------------------------------------------
 /** Gets a Record Value Type */
 // prettier-ignore
-export type TRecordValue<Type extends TRecord> = (
-  Type extends TRecord<TSchema, infer Value extends TSchema> ? Value : TNever
-)
+export type TRecordValue<Type extends TRecord,
+  Result extends TSchema = (
+    Type extends TRecord<TSchema, infer Value extends TSchema> 
+      ? Value 
+      : TNever
+    )
+> = Result
 /** Gets a Record Value Type */
 // prettier-ignore
 export function RecordValue<Type extends TRecord>(type: Type): TRecordValue<Type> {
diff --git a/test/runtime/type/guard/kind/import.ts b/test/runtime/type/guard/kind/import.ts
index 529cd5f6c..03921fe9f 100644
--- a/test/runtime/type/guard/kind/import.ts
+++ b/test/runtime/type/guard/kind/import.ts
@@ -151,17 +151,28 @@ describe('guard/kind/TImport', () => {
     Assert.IsTrue(KindGuard.IsRef(T.$defs['R'].patternProperties['^(.*)$']))
     Assert.IsTrue(T.$defs['R'].patternProperties['^(.*)$'].$ref === 'T')
   })
-  // it('Should compute for Record 2', () => {
-  //   const Module = Type.Module({
-  //     T: Type.Number(),
-  //     K: Type.Union([Type.Literal('x'), Type.Literal('y')]),
-  //     R: Type.Record(Type.Ref('K'), Type.Ref('T')),
-  //   })
-  //   const T = Module.Import('R')
-  //   Assert.IsTrue(KindGuard.IsObject(T.$defs['R']))
-  //   Assert.IsTrue(KindGuard.IsNumber(T.$defs['R'].properties.x))
-  //   Assert.IsTrue(KindGuard.IsNumber(T.$defs['R'].properties.x))
-  // })
+  it('Should compute for Record 2', () => {
+    const Module = Type.Module({
+      T: Type.Number(),
+      R: Type.Record(Type.Union([Type.Literal('x'), Type.Literal('y')]), Type.Ref('T')),
+    })
+    // Retain reference if not computed
+    const T = Module.Import('R')
+    Assert.IsTrue(KindGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(KindGuard.IsRef(T.$defs['R'].properties.x))
+    Assert.IsTrue(KindGuard.IsRef(T.$defs['R'].properties.y))
+  })
+  it('Should compute for Record 3', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number() }),
+      R: Type.Record(Type.Union([Type.Literal('x'), Type.Literal('y')]), Type.Partial(Type.Ref('T'))),
+    })
+    // Dereference if computed
+    const T = Module.Import('R')
+    Assert.IsTrue(KindGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(KindGuard.IsObject(T.$defs['R'].properties.x))
+    Assert.IsTrue(KindGuard.IsObject(T.$defs['R'].properties.y))
+  })
   // ----------------------------------------------------------------
   // Computed: Required
   // ----------------------------------------------------------------
diff --git a/test/runtime/type/guard/type/import.ts b/test/runtime/type/guard/type/import.ts
index 8b0f3b2dc..91080764f 100644
--- a/test/runtime/type/guard/type/import.ts
+++ b/test/runtime/type/guard/type/import.ts
@@ -151,17 +151,28 @@ describe('guard/type/TImport', () => {
     Assert.IsTrue(TypeGuard.IsRef(T.$defs['R'].patternProperties['^(.*)$']))
     Assert.IsTrue(T.$defs['R'].patternProperties['^(.*)$'].$ref === 'T')
   })
-  // it('Should compute for Record 2', () => {
-  //   const Module = Type.Module({
-  //     T: Type.Number(),
-  //     K: Type.Union([Type.Literal('x'), Type.Literal('y')]),
-  //     R: Type.Record(Type.Ref('K'), Type.Ref('T')),
-  //   })
-  //   const T = Module.Import('R')
-  //   Assert.IsTrue(TypeGuard.IsObject(T.$defs['R']))
-  //   Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R'].properties.x))
-  //   Assert.IsTrue(TypeGuard.IsNumber(T.$defs['R'].properties.x))
-  // })
+  it('Should compute for Record 2', () => {
+    const Module = Type.Module({
+      T: Type.Number(),
+      R: Type.Record(Type.Union([Type.Literal('x'), Type.Literal('y')]), Type.Ref('T')),
+    })
+    // Retain reference if not computed
+    const T = Module.Import('R')
+    Assert.IsTrue(TypeGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(TypeGuard.IsRef(T.$defs['R'].properties.x))
+    Assert.IsTrue(TypeGuard.IsRef(T.$defs['R'].properties.y))
+  })
+  it('Should compute for Record 3', () => {
+    const Module = Type.Module({
+      T: Type.Object({ x: Type.Number() }),
+      R: Type.Record(Type.Union([Type.Literal('x'), Type.Literal('y')]), Type.Partial(Type.Ref('T'))),
+    })
+    // Dereference if computed
+    const T = Module.Import('R')
+    Assert.IsTrue(TypeGuard.IsObject(T.$defs['R']))
+    Assert.IsTrue(TypeGuard.IsObject(T.$defs['R'].properties.x))
+    Assert.IsTrue(TypeGuard.IsObject(T.$defs['R'].properties.y))
+  })
   // ----------------------------------------------------------------
   // Computed: Required
   // ----------------------------------------------------------------
diff --git a/test/static/import.ts b/test/static/import.ts
index 010c3d645..0f30704f2 100644
--- a/test/static/import.ts
+++ b/test/static/import.ts
@@ -58,50 +58,17 @@ import { Type, Static } from '@sinclair/typebox'
 // ------------------------------------------------------------------
 // prettier-ignore
 {
-  // const T = Type.Module({
-  //   R: Type.Object({ x: Type.Number(), y: Type.Number() }),
-  //   T: Type.Record(Type.String(), Type.Partial(Type.Ref('R'))),
-  // }).Import('T')
-
-  // type T = Static<typeof T>
-  // Expect(T).ToStatic<{ 
-  //   [key: string]: { x?: number, y?: number } 
-  // }>()
-}
-// ------------------------------------------------------------------
-// Record 3
-// ------------------------------------------------------------------
-// prettier-ignore
-{
-  // const T = Type.Module({
-  //   R: Type.Object({ x: Type.Number(), y: Type.Number() }),
-  //   K: Type.Number(),
-  //   T: Type.Record(Type.Ref('K'), Type.Partial(Type.Ref('R'))),
-  // }).Import('T')
+  const T = Type.Module({
+    R: Type.Object({ x: Type.Number(), y: Type.Number() }),
+    T: Type.Record(Type.String(), Type.Partial(Type.Ref('R'))),
+  }).Import('T')
 
-  // type T = Static<typeof T>
-  // Expect(T).ToStatic<{ 
-  //   [key: number]: { x?: number, y?: number } 
-  // }>()
+  type T = Static<typeof T>
+  Expect(T).ToStatic<{ 
+    [key: string]: { x?: number, y?: number } 
+  }>()
 }
 // ------------------------------------------------------------------
-// Record 4
-// ------------------------------------------------------------------
-// prettier-ignore
-// {
-//   const T = Type.Module({
-//     R: Type.Object({ x: Type.Number(), y: Type.Number() }),
-//     K: Type.TemplateLiteral('${A|B|C}'),
-//     T: Type.Record(Type.Ref('K'), Type.Partial(Type.Ref('R'))),
-//   }).Import('T')
-//   type T = Static<typeof T>
-//   Expect(T).ToStatic<{
-//     A: { x?: number, y?: number },
-//     B: { x?: number, y?: number },
-//     C: { x?: number, y?: number }
-//   }>()
-// }
-// ------------------------------------------------------------------
 // Modifiers 1
 // ------------------------------------------------------------------
 // prettier-ignore

From 4e97af20bb2263a03fccbdaed34ff066261710de Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 14 Feb 2025 16:36:39 +0900
Subject: [PATCH 339/369] Revision 0.34.22 (#1171)

* Intrinsics Passthrough on Required and Partial

* ChangeLog

* Version
---
 changelog/0.34.0.md                      |  2 +
 package-lock.json                        |  4 +-
 package.json                             |  2 +-
 src/type/partial/partial.ts              | 72 +++++++++++++++++-------
 src/type/required/required.ts            | 48 +++++++++++++---
 test/runtime/type/guard/kind/partial.ts  | 32 +++++++++++
 test/runtime/type/guard/kind/required.ts | 32 +++++++++++
 test/runtime/type/guard/type/partial.ts  | 32 +++++++++++
 test/runtime/type/guard/type/required.ts | 32 +++++++++++
 test/static/partial.ts                   | 18 ++++++
 test/static/required.ts                  | 18 ++++++
 11 files changed, 263 insertions(+), 29 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index f2d9ade16..72c5f68a9 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,4 +1,6 @@
 ### 0.34.0
+- [Revision 0.34.22](https://github.com/sinclairzx81/typebox/pull/1171)
+  - Intrinsic Types Number, String, Boolean, etc Passthrough on Required and Partial Mapping
 - [Revision 0.34.21](https://github.com/sinclairzx81/typebox/pull/1168)
   - Reimplement Computed Record Types
 - [Revision 0.34.20](https://github.com/sinclairzx81/typebox/pull/1167)
diff --git a/package-lock.json b/package-lock.json
index 27a2d1f92..fee15aeb9 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.21",
+  "version": "0.34.22",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.21",
+      "version": "0.34.22",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 90ccd20e0..0bad6e6e8 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.21",
+  "version": "0.34.22",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/partial/partial.ts b/src/type/partial/partial.ts
index 52af56364..1f1ac83ac 100644
--- a/src/type/partial/partial.ts
+++ b/src/type/partial/partial.ts
@@ -39,14 +39,24 @@ import { type TObject, type TProperties, Object } from '../object/index'
 import { type TIntersect, Intersect } from '../intersect/index'
 import { type TUnion, Union } from '../union/index'
 import { type TRef, Ref } from '../ref/index'
+import { type TBigInt } from '../bigint/index'
+import { type TBoolean } from '../boolean/index'
+import { type TInteger } from '../integer/index'
+import { type TLiteral } from '../literal/index'
+import { type TNull } from '../null/index'
+import { type TNumber } from '../number/index'
+import { type TString } from '../string/index'
+import { type TSymbol } from '../symbol/index'
+import { type TUndefined } from '../undefined/index'
+
 import { Discard } from '../discard/index'
 import { TransformKind } from '../symbols/index'
 import { PartialFromMappedResult, type TPartialFromMappedResult } from './partial-from-mapped-result'
 
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsIntersect, IsUnion, IsObject, IsRef, IsComputed } from '../guard/kind'
+import * as KindGuard from '../guard/kind'
 
 // ------------------------------------------------------------------
 // FromComputed
@@ -95,9 +105,9 @@ type TFromObject<Type extends TObject, Properties extends TProperties = Type['pr
   TFromProperties<Properties>
 )>>
 // prettier-ignore
-function FromObject<Type extends TObject>(T: Type): TFromObject<Type> {
-  const options = Discard(T, [TransformKind, '$id', 'required', 'properties'])
-  const properties = FromProperties(T['properties'])
+function FromObject<Type extends TObject>(type: Type): TFromObject<Type> {
+  const options = Discard(type, [TransformKind, '$id', 'required', 'properties'])
+  const properties = FromProperties(type['properties'])
   return Object(properties, options) as never
 }
 // ------------------------------------------------------------------
@@ -119,11 +129,23 @@ function FromRest<Types extends TSchema[]>(types: [...Types]): TFromRest<Types>
 // prettier-ignore
 function PartialResolve<Type extends TSchema>(type: Type): TPartial<Type> {
   return (
-    IsComputed(type) ? FromComputed(type.target, type.parameters) :
-    IsRef(type) ? FromRef(type.$ref) :
-    IsIntersect(type) ? Intersect(FromRest(type.allOf)) :
-    IsUnion(type) ? Union(FromRest(type.anyOf)) :
-    IsObject(type) ? FromObject(type) :
+    // Mappable
+    KindGuard.IsComputed(type) ? FromComputed(type.target, type.parameters) :
+    KindGuard.IsRef(type) ? FromRef(type.$ref) :
+    KindGuard.IsIntersect(type) ? Intersect(FromRest(type.allOf)) :
+    KindGuard.IsUnion(type) ? Union(FromRest(type.anyOf)) :
+    KindGuard.IsObject(type) ? FromObject(type) :
+    // Intrinsic
+    KindGuard.IsBigInt(type) ? type :
+    KindGuard.IsBoolean(type) ? type :
+    KindGuard.IsInteger(type) ? type :
+    KindGuard.IsLiteral(type) ? type :
+    KindGuard.IsNull(type) ? type :
+    KindGuard.IsNumber(type) ? type :
+    KindGuard.IsString(type) ? type :
+    KindGuard.IsSymbol(type) ? type :
+    KindGuard.IsUndefined(type) ? type :
+    // Passthrough
     Object({})
   ) as never
 }
@@ -131,13 +153,25 @@ function PartialResolve<Type extends TSchema>(type: Type): TPartial<Type> {
 // TPartial
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TPartial<T extends TSchema> = (
-  T extends TRecursive<infer Type extends TSchema> ? TRecursive<TPartial<Type>> :
-  T extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> :
-  T extends TRef<infer Ref extends string> ? TFromRef<Ref> :
-  T extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> :
-  T extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> :
-  T extends TObject<infer Properties extends TProperties> ? TFromObject<TObject<Properties>> :
+export type TPartial<Type extends TSchema> = (
+  // Mappable
+  Type extends TRecursive<infer Type extends TSchema> ? TRecursive<TPartial<Type>> :
+  Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> :
+  Type extends TRef<infer Ref extends string> ? TFromRef<Ref> :
+  Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> :
+  Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> :
+  Type extends TObject<infer Properties extends TProperties> ? TFromObject<TObject<Properties>> :
+  // Intrinsic
+  Type extends TBigInt ? Type :
+  Type extends TBoolean ? Type :
+  Type extends TInteger ? Type :
+  Type extends TLiteral ? Type :
+  Type extends TNull ? Type :
+  Type extends TNumber ? Type :
+  Type extends TString ? Type :
+  Type extends TSymbol ? Type :
+  Type extends TUndefined ? Type :
+  // Passthrough
   TObject<{}>
 )
 /** `[Json]` Constructs a type where all properties are optional */
@@ -145,8 +179,8 @@ export function Partial<MappedResult extends TMappedResult>(type: MappedResult,
 /** `[Json]` Constructs a type where all properties are optional */
 export function Partial<Type extends TSchema>(type: Type, options?: SchemaOptions): TPartial<Type>
 /** `[Json]` Constructs a type where all properties are optional */
-export function Partial(type: TSchema, options?: SchemaOptions): any {
-  if (IsMappedResult(type)) {
+export function Partial(type: TSchema, options?: SchemaOptions): unknown {
+  if (KindGuard.IsMappedResult(type)) {
     return PartialFromMappedResult(type, options)
   } else {
     // special: mapping types require overridable options
diff --git a/src/type/required/required.ts b/src/type/required/required.ts
index 25d4c0491..7ce1b8879 100644
--- a/src/type/required/required.ts
+++ b/src/type/required/required.ts
@@ -39,6 +39,16 @@ import { type TObject, type TProperties, Object } from '../object/index'
 import { type TIntersect, Intersect } from '../intersect/index'
 import { type TUnion, Union } from '../union/index'
 import { type TRef, Ref } from '../ref/index'
+import { type TBigInt } from '../bigint/index'
+import { type TBoolean } from '../boolean/index'
+import { type TInteger } from '../integer/index'
+import { type TLiteral } from '../literal/index'
+import { type TNull } from '../null/index'
+import { type TNumber } from '../number/index'
+import { type TString } from '../string/index'
+import { type TSymbol } from '../symbol/index'
+import { type TUndefined } from '../undefined/index'
+
 import { OptionalKind, TransformKind } from '../symbols/index'
 import { Discard } from '../discard/index'
 import { RequiredFromMappedResult, type TRequiredFromMappedResult } from './required-from-mapped-result'
@@ -46,7 +56,7 @@ import { RequiredFromMappedResult, type TRequiredFromMappedResult } from './requ
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsIntersect, IsUnion, IsObject, IsRef, IsComputed } from '../guard/kind'
+import * as KindGuard from '../guard/kind'
 
 // ------------------------------------------------------------------
 // FromComputed
@@ -119,11 +129,23 @@ function FromRest<Types extends TSchema[]>(types: [...Types]) : TFromRest<Types>
 // prettier-ignore
 function RequiredResolve<Type extends TSchema>(type: Type): TRequired<Type> {
   return (
-    IsComputed(type) ? FromComputed(type.target, type.parameters) :
-    IsRef(type) ? FromRef(type.$ref) :
-    IsIntersect(type) ? Intersect(FromRest(type.allOf)) :
-    IsUnion(type) ?  Union(FromRest(type.anyOf)) :
-    IsObject(type) ? FromObject(type) :
+    // Mappable
+    KindGuard.IsComputed(type) ? FromComputed(type.target, type.parameters) :
+    KindGuard.IsRef(type) ? FromRef(type.$ref) :
+    KindGuard.IsIntersect(type) ? Intersect(FromRest(type.allOf)) :
+    KindGuard.IsUnion(type) ?  Union(FromRest(type.anyOf)) :
+    KindGuard.IsObject(type) ? FromObject(type) :
+    // Intrinsic
+    KindGuard.IsBigInt(type) ? type :
+    KindGuard.IsBoolean(type) ? type :
+    KindGuard.IsInteger(type) ? type :
+    KindGuard.IsLiteral(type) ? type :
+    KindGuard.IsNull(type) ? type :
+    KindGuard.IsNumber(type) ? type :
+    KindGuard.IsString(type) ? type :
+    KindGuard.IsSymbol(type) ? type :
+    KindGuard.IsUndefined(type) ? type :
+    // Passthrough
     Object({})
   ) as never
 }
@@ -132,12 +154,24 @@ function RequiredResolve<Type extends TSchema>(type: Type): TRequired<Type> {
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TRequired<Type extends TSchema> = (
+  // Mappable
   Type extends TRecursive<infer Type extends TSchema> ? TRecursive<TRequired<Type>> :
   Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> :
   Type extends TRef<infer Ref extends string> ? TFromRef<Ref> :
   Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> :
   Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> :
   Type extends TObject<infer Properties extends TProperties> ? TFromObject<TObject<Properties>> :
+  // Intrinsic
+  Type extends TBigInt ? Type :
+  Type extends TBoolean ? Type :
+  Type extends TInteger ? Type :
+  Type extends TLiteral ? Type :
+  Type extends TNull ? Type :
+  Type extends TNumber ? Type :
+  Type extends TString ? Type :
+  Type extends TSymbol ? Type :
+  Type extends TUndefined ? Type :
+  // Passthrough
   TObject<{}>
 )
 /** `[Json]` Constructs a type where all properties are required */
@@ -146,7 +180,7 @@ export function Required<MappedResult extends TMappedResult>(type: MappedResult,
 export function Required<Type extends TSchema>(type: Type, options?: SchemaOptions): TRequired<Type>
 /** `[Json]` Constructs a type where all properties are required */
 export function Required<Type extends TSchema>(type: Type, options?: SchemaOptions): never {
-  if (IsMappedResult(type)) {
+  if (KindGuard.IsMappedResult(type)) {
     return RequiredFromMappedResult(type, options) as never
   } else {
     // special: mapping types require overridable options
diff --git a/test/runtime/type/guard/kind/partial.ts b/test/runtime/type/guard/kind/partial.ts
index 6520da9d8..f9f4615d4 100644
--- a/test/runtime/type/guard/kind/partial.ts
+++ b/test/runtime/type/guard/kind/partial.ts
@@ -64,4 +64,36 @@ describe('guard/kind/TPartial', () => {
     const R = Type.Partial(S)
     Assert.IsFalse(TransformKind in R)
   })
+  // ------------------------------------------------------------------
+  // Intrinsic Passthough
+  // https://github.com/sinclairzx81/typebox/issues/1169
+  // ------------------------------------------------------------------
+  it('Should pass through on intrinsic types on union 1', () => {
+    const T = Type.Partial(
+      Type.Union([
+        Type.Number(),
+        Type.Object({
+          x: Type.Number(),
+        }),
+      ]),
+    )
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsTrue(KindGuard.IsNumber(T.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsObject(T.anyOf[1]))
+    Assert.IsTrue(KindGuard.IsOptional(T.anyOf[1].properties.x))
+  })
+  it('Should pass through on intrinsic types on union 2', () => {
+    const T = Type.Partial(
+      Type.Union([
+        Type.Literal(1),
+        Type.Object({
+          x: Type.Number(),
+        }),
+      ]),
+    )
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsTrue(KindGuard.IsLiteral(T.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsObject(T.anyOf[1]))
+    Assert.IsTrue(KindGuard.IsOptional(T.anyOf[1].properties.x))
+  })
 })
diff --git a/test/runtime/type/guard/kind/required.ts b/test/runtime/type/guard/kind/required.ts
index e795a05e1..0bf29e49e 100644
--- a/test/runtime/type/guard/kind/required.ts
+++ b/test/runtime/type/guard/kind/required.ts
@@ -61,4 +61,36 @@ describe('guard/kind/TRequired', () => {
     const R = Type.Required(S)
     Assert.IsFalse(TransformKind in R)
   })
+  // ------------------------------------------------------------------
+  // Intrinsic Passthough
+  // https://github.com/sinclairzx81/typebox/issues/1169
+  // ------------------------------------------------------------------
+  it('Should pass through on intrinsic types on union 1', () => {
+    const T = Type.Required(
+      Type.Union([
+        Type.Number(),
+        Type.Object({
+          x: Type.Optional(Type.Number()),
+        }),
+      ]),
+    )
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsTrue(KindGuard.IsNumber(T.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsObject(T.anyOf[1]))
+    Assert.IsFalse(KindGuard.IsOptional(T.anyOf[1].properties.x))
+  })
+  it('Should pass through on intrinsic types on union 2', () => {
+    const T = Type.Required(
+      Type.Union([
+        Type.Literal(1),
+        Type.Object({
+          x: Type.Optional(Type.Number()),
+        }),
+      ]),
+    )
+    Assert.IsTrue(KindGuard.IsUnion(T))
+    Assert.IsTrue(KindGuard.IsLiteral(T.anyOf[0]))
+    Assert.IsTrue(KindGuard.IsObject(T.anyOf[1]))
+    Assert.IsFalse(KindGuard.IsOptional(T.anyOf[1].properties.x))
+  })
 })
diff --git a/test/runtime/type/guard/type/partial.ts b/test/runtime/type/guard/type/partial.ts
index 1fb138d82..c2cb21312 100644
--- a/test/runtime/type/guard/type/partial.ts
+++ b/test/runtime/type/guard/type/partial.ts
@@ -73,4 +73,36 @@ describe('guard/type/TPartial', () => {
     Assert.IsEqual(A.title, 'A')
     Assert.IsEqual(B.title, 'B')
   })
+  // ------------------------------------------------------------------
+  // Intrinsic Passthough
+  // https://github.com/sinclairzx81/typebox/issues/1169
+  // ------------------------------------------------------------------
+  it('Should pass through on intrinsic types on union 1', () => {
+    const T = Type.Partial(
+      Type.Union([
+        Type.Number(),
+        Type.Object({
+          x: Type.Number(),
+        }),
+      ]),
+    )
+    Assert.IsTrue(TypeGuard.IsUnion(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsObject(T.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsOptional(T.anyOf[1].properties.x))
+  })
+  it('Should pass through on intrinsic types on union 2', () => {
+    const T = Type.Partial(
+      Type.Union([
+        Type.Literal(1),
+        Type.Object({
+          x: Type.Number(),
+        }),
+      ]),
+    )
+    Assert.IsTrue(TypeGuard.IsUnion(T))
+    Assert.IsTrue(TypeGuard.IsLiteral(T.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsObject(T.anyOf[1]))
+    Assert.IsTrue(TypeGuard.IsOptional(T.anyOf[1].properties.x))
+  })
 })
diff --git a/test/runtime/type/guard/type/required.ts b/test/runtime/type/guard/type/required.ts
index b4baf6dd1..3c4869594 100644
--- a/test/runtime/type/guard/type/required.ts
+++ b/test/runtime/type/guard/type/required.ts
@@ -70,4 +70,36 @@ describe('guard/type/TRequired', () => {
     Assert.IsEqual(A.title, 'A')
     Assert.IsEqual(B.title, 'B')
   })
+  // ------------------------------------------------------------------
+  // Intrinsic Passthough
+  // https://github.com/sinclairzx81/typebox/issues/1169
+  // ------------------------------------------------------------------
+  it('Should pass through on intrinsic types on union 1', () => {
+    const T = Type.Required(
+      Type.Union([
+        Type.Number(),
+        Type.Object({
+          x: Type.Optional(Type.Number()),
+        }),
+      ]),
+    )
+    Assert.IsTrue(TypeGuard.IsUnion(T))
+    Assert.IsTrue(TypeGuard.IsNumber(T.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsObject(T.anyOf[1]))
+    Assert.IsFalse(TypeGuard.IsOptional(T.anyOf[1].properties.x))
+  })
+  it('Should pass through on intrinsic types on union 2', () => {
+    const T = Type.Required(
+      Type.Union([
+        Type.Literal(1),
+        Type.Object({
+          x: Type.Optional(Type.Number()),
+        }),
+      ]),
+    )
+    Assert.IsTrue(TypeGuard.IsUnion(T))
+    Assert.IsTrue(TypeGuard.IsLiteral(T.anyOf[0]))
+    Assert.IsTrue(TypeGuard.IsObject(T.anyOf[1]))
+    Assert.IsFalse(TypeGuard.IsOptional(T.anyOf[1].properties.x))
+  })
 })
diff --git a/test/static/partial.ts b/test/static/partial.ts
index f4f81b023..5feacceef 100644
--- a/test/static/partial.ts
+++ b/test/static/partial.ts
@@ -85,3 +85,21 @@ import * as Types from '@sinclair/typebox'
     d: Types.TOptional<Types.TNumber>
   }> = Type.Partial(T)
 }
+// ------------------------------------------------------------------
+// Intrinsic Passthough
+// https://github.com/sinclairzx81/typebox/issues/1169
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const T = Type.Partial(Type.Union([Type.Number(), Type.Object({
+    x: Type.Number()
+  })]))
+  Expect(T).ToStatic<number | { x?: number }>
+}
+// prettier-ignore
+{
+  const T = Type.Partial(Type.Union([Type.Literal(1), Type.Object({
+    x: Type.Number()
+  })]))
+  Expect(T).ToStatic<1 | { x?: number }>
+}
diff --git a/test/static/required.ts b/test/static/required.ts
index a35c61f22..47c7a3be7 100644
--- a/test/static/required.ts
+++ b/test/static/required.ts
@@ -87,3 +87,21 @@ import * as Types from '@sinclair/typebox'
     d: Types.TNumber
   }> = Type.Required(T)
 }
+// ------------------------------------------------------------------
+// Intrinsic Passthough
+// https://github.com/sinclairzx81/typebox/issues/1169
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const T = Type.Required(Type.Union([Type.Number(), Type.Object({
+    x: Type.Optional(Type.Number())
+  })]))
+  Expect(T).ToStatic<number | { x: number }>
+}
+// prettier-ignore
+{
+  const T = Type.Required(Type.Union([Type.Literal(1), Type.Object({
+    x: Type.Optional(Type.Number())
+  })]))
+  Expect(T).ToStatic<1 | { x: number }>
+}

From 929efd2652b1fea60e4a5fd78062d207f57c7293 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Fri, 14 Feb 2025 18:45:45 +0900
Subject: [PATCH 340/369] Documentation

---
 readme.md | 143 ++++++++++++++++++++++++++++++------------------------
 1 file changed, 79 insertions(+), 64 deletions(-)

diff --git a/readme.md b/readme.md
index 5ee6d1024..bd108c697 100644
--- a/readme.md
+++ b/readme.md
@@ -64,7 +64,6 @@ License MIT
 - [Types](#types)
   - [Json](#types-json)
   - [JavaScript](#types-javascript)
-  - [Import](#types-import)
   - [Options](#types-options)
   - [Properties](#types-properties)
   - [Generics](#types-generics)
@@ -97,9 +96,9 @@ License MIT
   - [Mutate](#values-mutate)
   - [Pointer](#values-pointer)
 - [Syntax](#syntax)
-  - [Type](#syntax-type)
-  - [Options](#syntax-options)
+  - [Create](#syntax-create)
   - [Parameters](#syntax-parameters)
+  - [Options](#syntax-options)
   - [Generics](#syntax-generics)
 - [TypeRegistry](#typeregistry)
   - [Type](#typeregistry-type)
@@ -107,6 +106,8 @@ License MIT
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
   - [TypeCompiler](#typecheck-typecompiler)
+- [TypeMap](#typemap)
+  - [Usage](#typemap-usage)
 - [TypeSystem](#typesystem)
   - [Policies](#typesystem-policies)
 - [Error Function](#error-function)
@@ -638,22 +639,6 @@ TypeBox provides an extended type set that can be used to create schematics for
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name='types-import'></a>
-
-### Import
-
-Import the Type namespace to bring in the full TypeBox type system. This is recommended for most users.
-
-```typescript
-import { Type, type Static } from '@sinclair/typebox'
-```
-
-You can also selectively import types. This enables modern bundlers to tree shake for unused types.
-
-```typescript
-import { Object, Number, String, Boolean, type Static } from '@sinclair/typebox'
-```
-
 <a name='types-options'></a>
 
 ### Options
@@ -741,22 +726,6 @@ const Nullable = <T extends TSchema>(T: T) => {     // type Nullable<T> = T | nu
 const T = Nullable(Type.String())                  // type T = Nullable<string>
 ```
 
-Generic types can also be created with Argument types
-
-```typescript
-const Vector = Type.Object({                        // type Vector<A_0, A_1, A_2> = {
-  x: Type.Argument(0),                              //   x: A_0,
-  y: Type.Argument(1),                              //   y: A_1,
-  z: Type.Argument(2),                              //   z: A_2
-})                                                  // }
-
-const T = Type.Instantiate(Vector, [                // type T = Vector<
-  Type.Boolean(),                                   //   boolean, 
-  Type.Number(),                                    //   number,
-  Type.String()                                     //   string
-])                                                  // >
-```
-
 <a name='types-recursive'></a>
 
 ### Recursive Types
@@ -1337,30 +1306,50 @@ ValuePointer.Set(A, '/z', 1)                         // A' = { x: 1, y: 1, z: 1
 
 ## Syntax Types
 
-TypeBox provides optional support for runtime and type level parsing from TypeScript syntax.
+TypeBox has support for parsing TypeScript syntax at runtime as well as statically in the type system. This feature offers a syntactical frontend to the TypeBox type builder.
+
+Syntax types are available via optional import.
 
 ```typescript
 import { Syntax } from '@sinclair/typebox/syntax'
 ```
 
-<a name='syntax-type'></a>
+<a name='syntax-create'></a>
+
+### Create
+
+Use the Syntax function to create TypeBox types from TypeScript syntax
 
-### Type
+```typescript
+const T = Syntax(`{ x: number, y: number }`)        // const T: TObject<{
+                                                    //   x: TNumber,
+                                                    //   y: TNumber
+                                                    // }>
+```
+
+<a name="syntax-parameters"></a>
+
+### Parameters
 
-Use the Syntax function to create TypeBox type from TypeScript syntax.
+Syntax types can be parameterized to receive exterior types.
 
 ```typescript
 const T = Syntax(`{ x: number, y: number }`)        // const T: TObject<{
-                                                    //   x: TNumber
+                                                    //   x: TNumber,
                                                     //   y: TNumber
                                                     // }>
+
+const S = Syntax({ T }, `Partial<T>`)               // const S: TObject<{
+                                                    //   x: TOptional<TNumber>,
+                                                    //   y: TOptional<TNumber>
+                                                    // }>
 ```
 
 <a name='syntax-options'></a>
 
 ### Options
 
-Options can be passed to types on the last parameter
+Options can be passed via the last parameter
 
 ```typescript
 const T = Syntax(`number`, {                      // const T = {
@@ -1370,42 +1359,30 @@ const T = Syntax(`number`, {                      // const T = {
                                                   // }
 ```
 
-<a name="syntax-parameters"></a>
-
-### Parameters
-
-Syntax types can be parameterized to accept exterior types.
-
-```typescript
-const T = Syntax('number')
-
-const S = Syntax({ T }, `{ x: T, y: T, z: T }`)     // const S: TObject<{
-                                                    //   x: TNumber,
-                                                    //   y: TNumber,
-                                                    //   z: TNumber
-                                                    // }>
-```
-
 <a name="syntax-generics"></a>
 
 ### Generics
 
-Generic types can be created using Argument types.
+Generic types can be created using positional argument types ([Example](https://www.typescriptlang.org/play/?moduleResolution=99&module=199&ts=5.8.0-beta#code/JYWwDg9gTgLgBAbzgZQJ4DsYEMAecC+cAZlBCHAOQACAzsOgMYA2WwUA9DKmAKYBGEHOxoZsOCgChQkWIhTYYwBgWKly1OoxZtO3foMkSGEdDXgAVAAxwAvClG4AFBQCCUAOYBXED0wAeSwA+CgBKIxMzOHMARlt7TCdXD29fGD9o4LDjUwsAJji0BJxnNy8ff1zMiXCcuAA1HgYYaAKHYqQrABoo6O7zfPxugAMECTg4HAAuKMtOsbhUaZi58YAvJdyJfCGwmsiAISw6Ggam6BpWosckU+aoAmHR8an6xrv07tm4IJWF6dvoAFur1voFfutXmcoEDvsCwVsdtUuLw4IdjgCoBc7MgFEo-MieBAiKijsATm9zoFxtT2Ow4ASSeiKZi4k9qeyOZyudyeTzadSXkgXiDFrC4BDrIN5ryZbK5ez+eNRULpl9RSCJQ9pfKdbqFXS1tMVWLRV8IbF8Nq9da5fzCEA))
 
 ```typescript
-const Vector = Syntax(`{
-  x: Argument<0>,
-  y: Argument<1>,
-  z: Argument<2>
+const T0 = Syntax('Argument<0>')
+const T1 = Syntax('Argument<1>')
+const T2 = Syntax('Argument<2>')
+
+const Vector = Syntax({ T0, T1, T2 }, `{
+  x: T0,
+  y: T1,
+  z: T2
 }`)
 
-const Basis = Syntax({ Vector }, `{
+const BasisVectors = Syntax({ Vector }, `{
   x: Vector<1, 0, 0>,
   y: Vector<0, 1, 0>,
   z: Vector<0, 0, 1>,
 }`)
 
-type Basis = Static<typeof Basis>                   // type Basis = {
+type BasisVectors = Static<typeof BasisVectors>     // type BasisVectors = {
                                                     //   x: { x: 1, y: 0, z: 0 },
                                                     //   y: { x: 0, y: 1, z: 0 },
                                                     //   z: { x: 0, y: 0, z: 1 }
@@ -1573,6 +1550,44 @@ const C = TypeCompiler.Code(Type.String())           // const C = `return functi
                                                      // }`
 ```
 
+<a name='typemap'></a>
+
+## TypeMap
+
+TypeBox offers an external package for bi-directional mapping between TypeBox, Valibot, and Zod type libraries. It also includes syntax parsing support for Valibot and Zod and supports the Standard Schema specification. For more details on TypeMap, refer to the project repository.
+
+[TypeMap Repository](https://github.com/sinclairzx81/typemap)
+
+<a name='typemap-usage'></a>
+
+### Usage
+
+TypeMap needs to be installed seperately
+
+```bash
+$ npm install @sinclair/typemap
+```
+
+Once installed it offers advanced structural remapping between various runtime type libraries ([Example](https://www.typescriptlang.org/play/?moduleResolution=99&module=199&ts=5.8.0-beta#code/JYWwDg9gTgLgBAbzgFQJ5gKYCEIA8A0cAyqgHYwCGBcAWhACZwC+cAZlBCHAOQACAzsFIBjADYVgUAPQx0GEBTDcAUMuERS-eMjgBeFHJy4AFAAMkuAFxxSAVxAAjDFEKprdx88IAvd-adQzKYAlHBwUlJw6pra1sgA8g4AVhjCMAA8CMphObl5+QWFRcW5ETlWKABy-s4A3NkljU3NBWVhblU1UPUtvX3FbXC+nZ7dDf0TE2VMAHyq0VrEesRklCbIoS1lC-BE1twWfqOuRwE+p87MKmoaiwBKy3T0xkTBAHRgFFD8GMZ2oqJNnltrd4HdrFlJltImEKh4Aj0oU1Bh14XVxkiBjChhcxpjGtMwkA))
+
+```typescript
+import { TypeBox, Syntax, Zod } from '@sinclair/typemap'
+
+const T = TypeBox(`{ x: number, y: number, z: number }`)  // const T: TObject<{
+                                                          //   x: TNumber;
+                                                          //   y: TNumber;
+                                                          //   z: TNumber;
+                                                          // }>
+
+const S = Syntax(T)                // const S: '{ x: number, y: number, z: number }'
+
+const R = Zod(S).parse(null)       // const R: {
+                                   //   x: number;
+                                   //   y: number;
+                                   //   z: number;
+                                   // }                    
+```
+
 <a name='typesystem'></a>
 
 ## TypeSystem

From 89603918259dcc95dac878d3ba758c1bd0414778 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 16 Feb 2025 00:41:38 +0900
Subject: [PATCH 341/369] Revision 0.34.23 (#1174)

* Inline Instantiate

* Update Mocha

* Version

* ChangeLog
---
 changelog/0.32.0.md                 |    4 +-
 changelog/0.33.0.md                 |    5 +
 changelog/0.34.0.md                 |    8 +
 example/prototypes/index.ts         |    1 +
 example/prototypes/readme.md        |   37 +-
 example/prototypes/recursive-map.ts |  153 ++++
 package-lock.json                   | 1000 +++++++++++++++++++++------
 package.json                        |    4 +-
 src/index.ts                        |    1 -
 src/syntax/runtime.ts               |   13 +-
 src/syntax/static.ts                |    4 +-
 src/type/instantiate/instantiate.ts |  296 ++++++--
 src/type/remap/index.ts             |   29 -
 src/type/remap/remap.ts             |  142 ----
 src/type/type/type.ts               |    1 -
 15 files changed, 1244 insertions(+), 454 deletions(-)
 create mode 100644 example/prototypes/recursive-map.ts
 delete mode 100644 src/type/remap/index.ts
 delete mode 100644 src/type/remap/remap.ts

diff --git a/changelog/0.32.0.md b/changelog/0.32.0.md
index e2609e3bd..d28eb5e2d 100644
--- a/changelog/0.32.0.md
+++ b/changelog/0.32.0.md
@@ -1,6 +1,8 @@
+### 0.32.0
 
+---
 
-### 0.32.0
+### Revision Updates
 
 - [Revision 0.32.35](https://github.com/sinclairzx81/typebox/pull/914) Support Any for Record keys, Revert error message on required property, Fix order dependency for Union Convert.
 - [Revision 0.32.34](https://github.com/sinclairzx81/typebox/pull/914) Fix template literal generation for template literals embedded within template literals.
diff --git a/changelog/0.33.0.md b/changelog/0.33.0.md
index 31140defd..c8c44a896 100644
--- a/changelog/0.33.0.md
+++ b/changelog/0.33.0.md
@@ -1,4 +1,9 @@
 ### 0.33.0
+
+---
+
+### Revision Updates
+
 - [Revision 0.33.22](https://github.com/sinclairzx81/typebox/pull/1065)
   - Rename TypeScript parsing infrastructure from `/parse` to `/syntax`. Remove Parse API from top level import.
 - [Revision 0.33.21](https://github.com/sinclairzx81/typebox/pull/1064)
diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 72c5f68a9..2550686c4 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -1,4 +1,12 @@
 ### 0.34.0
+
+---
+
+### Revision Updates
+
+
+- [Revision 0.34.23](https://github.com/sinclairzx81/typebox/pull/1174)
+  - Inline Instantiate Type Logic Local to Instantiate Module
 - [Revision 0.34.22](https://github.com/sinclairzx81/typebox/pull/1171)
   - Intrinsic Types Number, String, Boolean, etc Passthrough on Required and Partial Mapping
 - [Revision 0.34.21](https://github.com/sinclairzx81/typebox/pull/1168)
diff --git a/example/prototypes/index.ts b/example/prototypes/index.ts
index 0dfa2301b..979519c61 100644
--- a/example/prototypes/index.ts
+++ b/example/prototypes/index.ts
@@ -30,5 +30,6 @@ export * from './discriminated-union'
 export * from './from-schema'
 export * from './options'
 export * from './partial-deep'
+export * from './recursive-map'
 export * from './union-enum'
 export * from './union-oneof'
diff --git a/example/prototypes/readme.md b/example/prototypes/readme.md
index c514e3456..bf5ea9060 100644
--- a/example/prototypes/readme.md
+++ b/example/prototypes/readme.md
@@ -81,4 +81,39 @@ import { Options } from './prototypes'
 const A = Options(Type.String(), { foo: 1 })             // Options<TString, { foo: number }>
 
 type A = typeof A extends { foo: number } ? true : false // true: foo property is observable to the type system
-```
\ No newline at end of file
+```
+
+## Recursive Map
+The Recursive Map type enables deep structural remapping of a type and it's internal constituents. This type accepts a TSchema type and a mapping type function (expressed via HKT). The HKT is applied when traversing the type and it's interior. The mapping HKT can apply conditional tests to each visited type to remap into a new form. The following augments a schematic via Options, and conditionally remaps any schema with an default annotation to make it optional. 
+```typescript
+import { Type, TOptional, Static, TSchema } from '@sinclair/typebox'
+
+import { TRecursiveMap, TMappingType, Options } from './prototypes'
+
+// ------------------------------------------------------------------
+// StaticDefault
+// ------------------------------------------------------------------
+export interface StaticDefaultMapping extends TMappingType { 
+  output: (
+    this['input'] extends TSchema                        // if input schematic contains an default 
+      ? this['input'] extends { default: unknown }       // annotation, remap it to be optional, 
+        ? TOptional<this['input']>                       // otherwise just return the schema as is.
+        : this['input']
+      : this['input']
+  )
+}
+export type StaticDefault<Type extends TSchema> = (
+  Static<TRecursiveMap<Type, StaticDefaultMapping>>
+)
+
+// ------------------------------------------------------------------
+// Usage
+// ------------------------------------------------------------------
+
+const T = Type.Object({
+  x: Options(Type.String(), { default: 'hello' }),
+  y: Type.String()
+})
+
+type T = StaticDefault<typeof T>   // { x?: string, y: string }
+type S = Static<typeof T>          // { x: string, y: string }
\ No newline at end of file
diff --git a/example/prototypes/recursive-map.ts b/example/prototypes/recursive-map.ts
new file mode 100644
index 000000000..4ff008309
--- /dev/null
+++ b/example/prototypes/recursive-map.ts
@@ -0,0 +1,153 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/prototypes
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as Types from '@sinclair/typebox'
+
+// ------------------------------------------------------------------
+// Mapping: Functions and Type 
+// ------------------------------------------------------------------
+export type TMappingFunction = (schema: Types.TSchema) => Types.TSchema
+
+export interface TMappingType {
+  input: unknown
+  output: unknown
+}
+// ------------------------------------------------------------------
+// Record Parameters
+// ------------------------------------------------------------------
+function GetRecordPattern(record: Types.TRecord): string {
+  return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0]
+}
+function GetRecordKey(record: Types.TRecord): Types.TSchema {
+  const pattern = GetRecordPattern(record)
+  return (
+    pattern === Types.PatternStringExact ? Types.String() :
+    pattern === Types.PatternNumberExact ? Types.Number() :
+    pattern === Types.PatternBooleanExact ? Types.Boolean() :
+    Types.String({ pattern })
+  )
+}
+function GetRecordValue(record: Types.TRecord): Types.TSchema {
+  return record.patternProperties[GetRecordPattern(record)]
+}
+// ------------------------------------------------------------------
+// Traversal
+// ------------------------------------------------------------------
+// prettier-ignore
+type TApply<Type extends Types.TSchema, Func extends TMappingType,
+  Mapped = (Func & { input: Type })['output'],
+  Result = Mapped extends Types.TSchema ? Mapped : never
+> = Result
+// prettier-ignore
+type TFromProperties<Properties extends Types.TProperties, Func extends TMappingType, Result extends Types.TProperties = {
+  [Key in keyof Properties]: TRecursiveMap<Properties[Key], Func>
+}> = Result
+function FromProperties(properties: Types.TProperties, func: TMappingFunction): Types.TProperties {
+  return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+    return {...result, [key]: RecursiveMap(properties[key], func) }
+  }, {})
+}
+// prettier-ignore
+type TFromRest<Types extends Types.TSchema[], Func extends TMappingType, Result extends Types.TSchema[] = []> = (
+  Types extends [infer Left extends Types.TSchema, ...infer Right extends Types.TSchema[]]
+    ? TFromRest<Right, Func, [...Result, TRecursiveMap<Left, Func>]>
+    : Result
+)
+function FromRest(types: Types.TSchema[], func: TMappingFunction): Types.TSchema[] {
+  return types.map(type => RecursiveMap(type, func))
+}
+// prettier-ignore
+type TFromType<Type extends Types.TSchema, Func extends TMappingType, Result extends Types.TSchema = (
+  TApply<Type, Func>
+)> = Result
+function FromType(type: Types.TSchema, func: TMappingFunction): Types.TSchema {
+  return func(type)
+}
+// ------------------------------------------------------------------
+// TRecursiveMap<Type, Mapping>
+// ------------------------------------------------------------------
+/** `[Prototype]` Applies a deep recursive map across the given type and sub types. */
+// prettier-ignore
+export type TRecursiveMap<Type extends Types.TSchema, Func extends TMappingType, 
+  // Maps the Exterior Type
+  Exterior extends Types.TSchema = TFromType<Type, Func>, 
+  // Maps the Interior Parameterized Types
+  Interior extends Types.TSchema = (
+    Exterior extends Types.TConstructor<infer Parameters extends Types.TSchema[], infer ReturnType extends Types.TSchema> ? Types.TConstructor<TFromRest<Parameters, Func>, TFromType<ReturnType, Func>> :
+    Exterior extends Types.TFunction<infer Parameters extends Types.TSchema[], infer ReturnType extends Types.TSchema> ? Types.TFunction<TFromRest<Parameters, Func>, TFromType<ReturnType, Func>> :
+    Exterior extends Types.TIntersect<infer Types extends Types.TSchema[]> ? Types.TIntersect<TFromRest<Types, Func>> :
+    Exterior extends Types.TUnion<infer Types extends Types.TSchema[]> ? Types.TUnion<TFromRest<Types, Func>> :
+    Exterior extends Types.TTuple<infer Types extends Types.TSchema[]> ? Types.TTuple<TFromRest<Types, Func>> :
+    Exterior extends Types.TArray<infer Type extends Types.TSchema> ? Types.TArray<TFromType<Type, Func>>:
+    Exterior extends Types.TAsyncIterator<infer Type extends Types.TSchema> ? Types.TAsyncIterator<TFromType<Type, Func>> :
+    Exterior extends Types.TIterator<infer Type extends Types.TSchema> ? Types.TIterator<TFromType<Type, Func>> :
+    Exterior extends Types.TPromise<infer Type extends Types.TSchema> ? Types.TPromise<TFromType<Type, Func>> :
+    Exterior extends Types.TObject<infer Properties extends Types.TProperties> ? Types.TObject<TFromProperties<Properties, Func>> :
+    Exterior extends Types.TRecord<infer Key extends Types.TSchema, infer Value extends Types.TSchema> ? Types.TRecordOrObject<TFromType<Key, Func>, TFromType<Value, Func>> :
+    Exterior
+  ),
+  // Modifiers Derived from Exterior Type Mapping
+  IsOptional extends number = Exterior extends Types.TOptional<Types.TSchema> ? 1 : 0,
+  IsReadonly extends number = Exterior extends Types.TReadonly<Types.TSchema> ? 1 : 0,
+  Result extends Types.TSchema = (
+    [IsReadonly, IsOptional]  extends [1, 1] ? Types.TReadonlyOptional<Interior> :
+    [IsReadonly, IsOptional]  extends [0, 1] ? Types.TOptional<Interior> :
+    [IsReadonly, IsOptional]  extends [1, 0] ? Types.TReadonly<Interior> :
+    Interior
+  ) 
+> = Result
+/** `[Prototype]` Applies a deep recursive map across the given type and sub types. */
+// prettier-ignore
+export function RecursiveMap(type: Types.TSchema, func: TMappingFunction): Types.TSchema {
+  // Maps the Exterior Type
+  const exterior = Types.CloneType(FromType(type, func), type)
+  // Maps the Interior Parameterized Types
+  const interior = (
+    Types.KindGuard.IsConstructor(type) ? Types.Constructor(FromRest(type.parameters, func), FromType(type.returns, func), exterior) :
+    Types.KindGuard.IsFunction(type) ? Types.Function(FromRest(type.parameters, func), FromType(type.returns, func), exterior) :
+    Types.KindGuard.IsIntersect(type) ? Types.Intersect(FromRest(type.allOf, func), exterior) :
+    Types.KindGuard.IsUnion(type) ? Types.Union(FromRest(type.anyOf, func), exterior) :
+    Types.KindGuard.IsTuple(type) ? Types.Tuple(FromRest(type.items || [], func), exterior) :
+    Types.KindGuard.IsArray(type) ? Types.Array(FromType(type.items, func), exterior) :
+    Types.KindGuard.IsAsyncIterator(type) ? Types.AsyncIterator(FromType(type.items, func), exterior) :
+    Types.KindGuard.IsIterator(type) ? Types.Iterator(FromType(type.items, func), exterior) :
+    Types.KindGuard.IsPromise(type) ? Types.Promise(FromType(type.items, func), exterior) :
+    Types.KindGuard.IsObject(type) ? Types.Object(FromProperties(type.properties, func), exterior) :
+    Types.KindGuard.IsRecord(type) ? Types.Record(FromType(GetRecordKey(type), func), FromType(GetRecordValue(type), func), exterior) :
+    Types.CloneType(exterior, exterior)
+  )
+  // Modifiers Derived from Exterior Type Mapping
+  const isOptional = Types.KindGuard.IsOptional(exterior)
+  const isReadonly = Types.KindGuard.IsOptional(exterior)
+  return (
+    isOptional && isReadonly ? Types.ReadonlyOptional(interior) :
+    isOptional ? Types.Optional(interior) :
+    isReadonly ? Types.Readonly(interior) :
+    interior
+  )
+}
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index fee15aeb9..a7caf3c68 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.22",
+  "version": "0.34.23",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.22",
+      "version": "0.34.23",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
@@ -15,7 +15,7 @@
         "@types/node": "^20.10.1",
         "ajv": "^8.12.0",
         "ajv-formats": "^2.1.1",
-        "mocha": "^10.4.0",
+        "mocha": "^11.1.0",
         "prettier": "^2.7.1",
         "typescript": "^5.7.3"
       }
@@ -102,6 +102,83 @@
         "node": ">=12"
       }
     },
+    "node_modules/@isaacs/cliui": {
+      "version": "8.0.2",
+      "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
+      "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
+      "dev": true,
+      "dependencies": {
+        "string-width": "^5.1.2",
+        "string-width-cjs": "npm:string-width@^4.2.0",
+        "strip-ansi": "^7.0.1",
+        "strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
+        "wrap-ansi": "^8.1.0",
+        "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@isaacs/cliui/node_modules/ansi-regex": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
+      "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
+      "dev": true,
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
+      }
+    },
+    "node_modules/@isaacs/cliui/node_modules/emoji-regex": {
+      "version": "9.2.2",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
+      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
+      "dev": true
+    },
+    "node_modules/@isaacs/cliui/node_modules/string-width": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
+      "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
+      "dev": true,
+      "dependencies": {
+        "eastasianwidth": "^0.2.0",
+        "emoji-regex": "^9.2.2",
+        "strip-ansi": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@isaacs/cliui/node_modules/strip-ansi": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
+      "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
+      "dev": true,
+      "dependencies": {
+        "ansi-regex": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+      }
+    },
+    "node_modules/@pkgjs/parseargs": {
+      "version": "0.11.0",
+      "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
+      "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
+      "dev": true,
+      "optional": true,
+      "engines": {
+        "node": ">=14"
+      }
+    },
     "node_modules/@sinclair/hammer": {
       "version": "0.18.0",
       "resolved": "https://registry.npmjs.org/@sinclair/hammer/-/hammer-0.18.0.tgz",
@@ -175,9 +252,9 @@
       }
     },
     "node_modules/ansi-colors": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz",
-      "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==",
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz",
+      "integrity": "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==",
       "dev": true,
       "engines": {
         "node": ">=6"
@@ -403,14 +480,34 @@
       }
     },
     "node_modules/cliui": {
-      "version": "7.0.4",
-      "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz",
-      "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==",
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
       "dev": true,
       "dependencies": {
         "string-width": "^4.2.0",
-        "strip-ansi": "^6.0.0",
+        "strip-ansi": "^6.0.1",
         "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/cliui/node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dev": true,
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
       }
     },
     "node_modules/color-convert": {
@@ -440,13 +537,27 @@
         "node": ">=14"
       }
     },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
     "node_modules/debug": {
-      "version": "4.3.4",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
-      "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==",
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
+      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
       "dev": true,
       "dependencies": {
-        "ms": "2.1.2"
+        "ms": "^2.1.3"
       },
       "engines": {
         "node": ">=6.0"
@@ -457,12 +568,6 @@
         }
       }
     },
-    "node_modules/debug/node_modules/ms": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
-      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
-      "dev": true
-    },
     "node_modules/decamelize": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz",
@@ -476,14 +581,20 @@
       }
     },
     "node_modules/diff": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz",
-      "integrity": "sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==",
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/diff/-/diff-5.2.0.tgz",
+      "integrity": "sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==",
       "dev": true,
       "engines": {
         "node": ">=0.3.1"
       }
     },
+    "node_modules/eastasianwidth": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
+      "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
+      "dev": true
+    },
     "node_modules/emoji-regex": {
       "version": "8.0.0",
       "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
@@ -853,9 +964,9 @@
       }
     },
     "node_modules/escalade": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
-      "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
       "dev": true,
       "engines": {
         "node": ">=6"
@@ -935,11 +1046,21 @@
         "flat": "cli.js"
       }
     },
-    "node_modules/fs.realpath": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
-      "dev": true
+    "node_modules/foreground-child": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.0.tgz",
+      "integrity": "sha512-Ld2g8rrAyMYFXBhEqMz8ZAHBi4J4uS1i/CxGMDnjyFWddMXLVcDp051DZfu+t7+ab7Wv6SMqpWmyFIj5UbfFvg==",
+      "dev": true,
+      "dependencies": {
+        "cross-spawn": "^7.0.0",
+        "signal-exit": "^4.0.1"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
     },
     "node_modules/fsevents": {
       "version": "2.3.2",
@@ -965,20 +1086,20 @@
       }
     },
     "node_modules/glob": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz",
-      "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==",
-      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "version": "10.4.5",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
+      "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
       "dev": true,
       "dependencies": {
-        "fs.realpath": "^1.0.0",
-        "inflight": "^1.0.4",
-        "inherits": "2",
-        "minimatch": "^5.0.1",
-        "once": "^1.3.0"
+        "foreground-child": "^3.1.0",
+        "jackspeak": "^3.1.2",
+        "minimatch": "^9.0.4",
+        "minipass": "^7.1.2",
+        "package-json-from-dist": "^1.0.0",
+        "path-scurry": "^1.11.1"
       },
-      "engines": {
-        "node": ">=12"
+      "bin": {
+        "glob": "dist/esm/bin.mjs"
       },
       "funding": {
         "url": "https://github.com/sponsors/isaacs"
@@ -996,6 +1117,21 @@
         "node": ">= 6"
       }
     },
+    "node_modules/glob/node_modules/minimatch": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+      "dev": true,
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/has-flag": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
@@ -1014,23 +1150,6 @@
         "he": "bin/he"
       }
     },
-    "node_modules/inflight": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
-      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
-      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
-      "dev": true,
-      "dependencies": {
-        "once": "^1.3.0",
-        "wrappy": "1"
-      }
-    },
-    "node_modules/inherits": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
-      "dev": true
-    },
     "node_modules/is-binary-path": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
@@ -1103,6 +1222,27 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true
+    },
+    "node_modules/jackspeak": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz",
+      "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==",
+      "dev": true,
+      "dependencies": {
+        "@isaacs/cliui": "^8.0.2"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      },
+      "optionalDependencies": {
+        "@pkgjs/parseargs": "^0.11.0"
+      }
+    },
     "node_modules/js-yaml": {
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
@@ -1209,9 +1349,9 @@
       }
     },
     "node_modules/minimatch": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.0.1.tgz",
-      "integrity": "sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==",
+      "version": "5.1.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
+      "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
       "dev": true,
       "dependencies": {
         "brace-expansion": "^2.0.1"
@@ -1220,39 +1360,48 @@
         "node": ">=10"
       }
     },
+    "node_modules/minipass": {
+      "version": "7.1.2",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
+      "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+      "dev": true,
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
     "node_modules/mocha": {
-      "version": "10.4.0",
-      "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.4.0.tgz",
-      "integrity": "sha512-eqhGB8JKapEYcC4ytX/xrzKforgEc3j1pGlAXVy3eRwrtAy5/nIfT1SvgGzfN0XZZxeLq0aQWkOUAmqIJiv+bA==",
-      "dev": true,
-      "dependencies": {
-        "ansi-colors": "4.1.1",
-        "browser-stdout": "1.3.1",
-        "chokidar": "3.5.3",
-        "debug": "4.3.4",
-        "diff": "5.0.0",
-        "escape-string-regexp": "4.0.0",
-        "find-up": "5.0.0",
-        "glob": "8.1.0",
-        "he": "1.2.0",
-        "js-yaml": "4.1.0",
-        "log-symbols": "4.1.0",
-        "minimatch": "5.0.1",
-        "ms": "2.1.3",
-        "serialize-javascript": "6.0.0",
-        "strip-json-comments": "3.1.1",
-        "supports-color": "8.1.1",
-        "workerpool": "6.2.1",
-        "yargs": "16.2.0",
-        "yargs-parser": "20.2.4",
-        "yargs-unparser": "2.0.0"
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/mocha/-/mocha-11.1.0.tgz",
+      "integrity": "sha512-8uJR5RTC2NgpY3GrYcgpZrsEd9zKbPDpob1RezyR2upGHRQtHWofmzTMzTMSV6dru3tj5Ukt0+Vnq1qhFEEwAg==",
+      "dev": true,
+      "dependencies": {
+        "ansi-colors": "^4.1.3",
+        "browser-stdout": "^1.3.1",
+        "chokidar": "^3.5.3",
+        "debug": "^4.3.5",
+        "diff": "^5.2.0",
+        "escape-string-regexp": "^4.0.0",
+        "find-up": "^5.0.0",
+        "glob": "^10.4.5",
+        "he": "^1.2.0",
+        "js-yaml": "^4.1.0",
+        "log-symbols": "^4.1.0",
+        "minimatch": "^5.1.6",
+        "ms": "^2.1.3",
+        "serialize-javascript": "^6.0.2",
+        "strip-json-comments": "^3.1.1",
+        "supports-color": "^8.1.1",
+        "workerpool": "^6.5.1",
+        "yargs": "^17.7.2",
+        "yargs-parser": "^21.1.1",
+        "yargs-unparser": "^2.0.0"
       },
       "bin": {
         "_mocha": "bin/_mocha",
         "mocha": "bin/mocha.js"
       },
       "engines": {
-        "node": ">= 14.0.0"
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       }
     },
     "node_modules/ms": {
@@ -1285,15 +1434,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
-      "dev": true,
-      "dependencies": {
-        "wrappy": "1"
-      }
-    },
     "node_modules/p-limit": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
@@ -1324,6 +1464,12 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/package-json-from-dist": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
+      "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
+      "dev": true
+    },
     "node_modules/path-exists": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
@@ -1333,6 +1479,37 @@
         "node": ">=8"
       }
     },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-scurry": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz",
+      "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==",
+      "dev": true,
+      "dependencies": {
+        "lru-cache": "^10.2.0",
+        "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/path-scurry/node_modules/lru-cache": {
+      "version": "10.4.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+      "dev": true
+    },
     "node_modules/picomatch": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
@@ -1453,14 +1630,47 @@
       }
     },
     "node_modules/serialize-javascript": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz",
-      "integrity": "sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==",
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz",
+      "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==",
       "dev": true,
       "dependencies": {
         "randombytes": "^2.1.0"
       }
     },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "dev": true,
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/skin-tone": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/skin-tone/-/skin-tone-2.0.0.tgz",
@@ -1487,6 +1697,21 @@
         "node": ">=8"
       }
     },
+    "node_modules/string-width-cjs": {
+      "name": "string-width",
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/strip-ansi": {
       "version": "6.0.1",
       "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
@@ -1499,6 +1724,19 @@
         "node": ">=8"
       }
     },
+    "node_modules/strip-ansi-cjs": {
+      "name": "strip-ansi",
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/strip-json-comments": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
@@ -1624,13 +1862,46 @@
         "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
       }
     },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
     "node_modules/workerpool": {
-      "version": "6.2.1",
-      "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.2.1.tgz",
-      "integrity": "sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==",
+      "version": "6.5.1",
+      "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.5.1.tgz",
+      "integrity": "sha512-Fs4dNYcsdpYSAfVxhnl1L5zTksjvOJxtC5hzMNl+1t9B8hTJTdKDyZ5ju7ztgPy+ft9tBFXoOlDNiOT9WUXZlA==",
       "dev": true
     },
     "node_modules/wrap-ansi": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
+      "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
+      "dev": true,
+      "dependencies": {
+        "ansi-styles": "^6.1.0",
+        "string-width": "^5.0.1",
+        "strip-ansi": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi-cjs": {
+      "name": "wrap-ansi",
       "version": "7.0.0",
       "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
       "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
@@ -1647,12 +1918,68 @@
         "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
       }
     },
-    "node_modules/wrappy": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+    "node_modules/wrap-ansi/node_modules/ansi-regex": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
+      "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
+      "dev": true,
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi/node_modules/ansi-styles": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz",
+      "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==",
+      "dev": true,
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi/node_modules/emoji-regex": {
+      "version": "9.2.2",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
+      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
       "dev": true
     },
+    "node_modules/wrap-ansi/node_modules/string-width": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
+      "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
+      "dev": true,
+      "dependencies": {
+        "eastasianwidth": "^0.2.0",
+        "emoji-regex": "^9.2.2",
+        "strip-ansi": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/wrap-ansi/node_modules/strip-ansi": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
+      "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
+      "dev": true,
+      "dependencies": {
+        "ansi-regex": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+      }
+    },
     "node_modules/y18n": {
       "version": "5.0.8",
       "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
@@ -1669,30 +1996,30 @@
       "dev": true
     },
     "node_modules/yargs": {
-      "version": "16.2.0",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz",
-      "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==",
+      "version": "17.7.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
       "dev": true,
       "dependencies": {
-        "cliui": "^7.0.2",
+        "cliui": "^8.0.1",
         "escalade": "^3.1.1",
         "get-caller-file": "^2.0.5",
         "require-directory": "^2.1.1",
-        "string-width": "^4.2.0",
+        "string-width": "^4.2.3",
         "y18n": "^5.0.5",
-        "yargs-parser": "^20.2.2"
+        "yargs-parser": "^21.1.1"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">=12"
       }
     },
     "node_modules/yargs-parser": {
-      "version": "20.2.4",
-      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.4.tgz",
-      "integrity": "sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==",
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
       "dev": true,
       "engines": {
-        "node": ">=10"
+        "node": ">=12"
       }
     },
     "node_modules/yargs-unparser": {
@@ -1780,6 +2107,61 @@
       "dev": true,
       "optional": true
     },
+    "@isaacs/cliui": {
+      "version": "8.0.2",
+      "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
+      "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
+      "dev": true,
+      "requires": {
+        "string-width": "^5.1.2",
+        "string-width-cjs": "npm:string-width@^4.2.0",
+        "strip-ansi": "^7.0.1",
+        "strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
+        "wrap-ansi": "^8.1.0",
+        "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "6.1.0",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
+          "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
+          "dev": true
+        },
+        "emoji-regex": {
+          "version": "9.2.2",
+          "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
+          "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
+          "dev": true
+        },
+        "string-width": {
+          "version": "5.1.2",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
+          "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
+          "dev": true,
+          "requires": {
+            "eastasianwidth": "^0.2.0",
+            "emoji-regex": "^9.2.2",
+            "strip-ansi": "^7.0.1"
+          }
+        },
+        "strip-ansi": {
+          "version": "7.1.0",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
+          "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
+          "dev": true,
+          "requires": {
+            "ansi-regex": "^6.0.1"
+          }
+        }
+      }
+    },
+    "@pkgjs/parseargs": {
+      "version": "0.11.0",
+      "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
+      "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
+      "dev": true,
+      "optional": true
+    },
     "@sinclair/hammer": {
       "version": "0.18.0",
       "resolved": "https://registry.npmjs.org/@sinclair/hammer/-/hammer-0.18.0.tgz",
@@ -1832,9 +2214,9 @@
       }
     },
     "ansi-colors": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz",
-      "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==",
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz",
+      "integrity": "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==",
       "dev": true
     },
     "ansi-escapes": {
@@ -1998,14 +2380,27 @@
       }
     },
     "cliui": {
-      "version": "7.0.4",
-      "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz",
-      "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==",
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
       "dev": true,
       "requires": {
         "string-width": "^4.2.0",
-        "strip-ansi": "^6.0.0",
+        "strip-ansi": "^6.0.1",
         "wrap-ansi": "^7.0.0"
+      },
+      "dependencies": {
+        "wrap-ansi": {
+          "version": "7.0.0",
+          "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+          "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+          "dev": true,
+          "requires": {
+            "ansi-styles": "^4.0.0",
+            "string-width": "^4.1.0",
+            "strip-ansi": "^6.0.0"
+          }
+        }
       }
     },
     "color-convert": {
@@ -2029,21 +2424,24 @@
       "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==",
       "dev": true
     },
+    "cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
+      "requires": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      }
+    },
     "debug": {
-      "version": "4.3.4",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
-      "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==",
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
+      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
       "dev": true,
       "requires": {
-        "ms": "2.1.2"
-      },
-      "dependencies": {
-        "ms": {
-          "version": "2.1.2",
-          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
-          "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
-          "dev": true
-        }
+        "ms": "^2.1.3"
       }
     },
     "decamelize": {
@@ -2053,9 +2451,15 @@
       "dev": true
     },
     "diff": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz",
-      "integrity": "sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==",
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/diff/-/diff-5.2.0.tgz",
+      "integrity": "sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==",
+      "dev": true
+    },
+    "eastasianwidth": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
+      "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
       "dev": true
     },
     "emoji-regex": {
@@ -2240,9 +2644,9 @@
       "optional": true
     },
     "escalade": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
-      "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
       "dev": true
     },
     "escape-string-regexp": {
@@ -2294,11 +2698,15 @@
       "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==",
       "dev": true
     },
-    "fs.realpath": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
-      "dev": true
+    "foreground-child": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.0.tgz",
+      "integrity": "sha512-Ld2g8rrAyMYFXBhEqMz8ZAHBi4J4uS1i/CxGMDnjyFWddMXLVcDp051DZfu+t7+ab7Wv6SMqpWmyFIj5UbfFvg==",
+      "dev": true,
+      "requires": {
+        "cross-spawn": "^7.0.0",
+        "signal-exit": "^4.0.1"
+      }
     },
     "fsevents": {
       "version": "2.3.2",
@@ -2314,16 +2722,28 @@
       "dev": true
     },
     "glob": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz",
-      "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==",
+      "version": "10.4.5",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
+      "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
       "dev": true,
       "requires": {
-        "fs.realpath": "^1.0.0",
-        "inflight": "^1.0.4",
-        "inherits": "2",
-        "minimatch": "^5.0.1",
-        "once": "^1.3.0"
+        "foreground-child": "^3.1.0",
+        "jackspeak": "^3.1.2",
+        "minimatch": "^9.0.4",
+        "minipass": "^7.1.2",
+        "package-json-from-dist": "^1.0.0",
+        "path-scurry": "^1.11.1"
+      },
+      "dependencies": {
+        "minimatch": {
+          "version": "9.0.5",
+          "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+          "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+          "dev": true,
+          "requires": {
+            "brace-expansion": "^2.0.1"
+          }
+        }
       }
     },
     "glob-parent": {
@@ -2347,22 +2767,6 @@
       "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==",
       "dev": true
     },
-    "inflight": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
-      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
-      "dev": true,
-      "requires": {
-        "once": "^1.3.0",
-        "wrappy": "1"
-      }
-    },
-    "inherits": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
-      "dev": true
-    },
     "is-binary-path": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
@@ -2411,6 +2815,22 @@
       "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==",
       "dev": true
     },
+    "isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true
+    },
+    "jackspeak": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz",
+      "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==",
+      "dev": true,
+      "requires": {
+        "@isaacs/cliui": "^8.0.2",
+        "@pkgjs/parseargs": "^0.11.0"
+      }
+    },
     "js-yaml": {
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
@@ -2483,40 +2903,46 @@
       }
     },
     "minimatch": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.0.1.tgz",
-      "integrity": "sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==",
+      "version": "5.1.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
+      "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
       "dev": true,
       "requires": {
         "brace-expansion": "^2.0.1"
       }
     },
+    "minipass": {
+      "version": "7.1.2",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
+      "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+      "dev": true
+    },
     "mocha": {
-      "version": "10.4.0",
-      "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.4.0.tgz",
-      "integrity": "sha512-eqhGB8JKapEYcC4ytX/xrzKforgEc3j1pGlAXVy3eRwrtAy5/nIfT1SvgGzfN0XZZxeLq0aQWkOUAmqIJiv+bA==",
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/mocha/-/mocha-11.1.0.tgz",
+      "integrity": "sha512-8uJR5RTC2NgpY3GrYcgpZrsEd9zKbPDpob1RezyR2upGHRQtHWofmzTMzTMSV6dru3tj5Ukt0+Vnq1qhFEEwAg==",
       "dev": true,
       "requires": {
-        "ansi-colors": "4.1.1",
-        "browser-stdout": "1.3.1",
-        "chokidar": "3.5.3",
-        "debug": "4.3.4",
-        "diff": "5.0.0",
-        "escape-string-regexp": "4.0.0",
-        "find-up": "5.0.0",
-        "glob": "8.1.0",
-        "he": "1.2.0",
-        "js-yaml": "4.1.0",
-        "log-symbols": "4.1.0",
-        "minimatch": "5.0.1",
-        "ms": "2.1.3",
-        "serialize-javascript": "6.0.0",
-        "strip-json-comments": "3.1.1",
-        "supports-color": "8.1.1",
-        "workerpool": "6.2.1",
-        "yargs": "16.2.0",
-        "yargs-parser": "20.2.4",
-        "yargs-unparser": "2.0.0"
+        "ansi-colors": "^4.1.3",
+        "browser-stdout": "^1.3.1",
+        "chokidar": "^3.5.3",
+        "debug": "^4.3.5",
+        "diff": "^5.2.0",
+        "escape-string-regexp": "^4.0.0",
+        "find-up": "^5.0.0",
+        "glob": "^10.4.5",
+        "he": "^1.2.0",
+        "js-yaml": "^4.1.0",
+        "log-symbols": "^4.1.0",
+        "minimatch": "^5.1.6",
+        "ms": "^2.1.3",
+        "serialize-javascript": "^6.0.2",
+        "strip-json-comments": "^3.1.1",
+        "supports-color": "^8.1.1",
+        "workerpool": "^6.5.1",
+        "yargs": "^17.7.2",
+        "yargs-parser": "^21.1.1",
+        "yargs-unparser": "^2.0.0"
       }
     },
     "ms": {
@@ -2543,15 +2969,6 @@
       "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
       "dev": true
     },
-    "once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
-      "dev": true,
-      "requires": {
-        "wrappy": "1"
-      }
-    },
     "p-limit": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
@@ -2570,12 +2987,42 @@
         "p-limit": "^3.0.2"
       }
     },
+    "package-json-from-dist": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
+      "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
+      "dev": true
+    },
     "path-exists": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
       "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
       "dev": true
     },
+    "path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true
+    },
+    "path-scurry": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz",
+      "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==",
+      "dev": true,
+      "requires": {
+        "lru-cache": "^10.2.0",
+        "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0"
+      },
+      "dependencies": {
+        "lru-cache": {
+          "version": "10.4.3",
+          "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+          "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+          "dev": true
+        }
+      }
+    },
     "picomatch": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
@@ -2649,14 +3096,35 @@
       }
     },
     "serialize-javascript": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz",
-      "integrity": "sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==",
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz",
+      "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==",
       "dev": true,
       "requires": {
         "randombytes": "^2.1.0"
       }
     },
+    "shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
+      "requires": {
+        "shebang-regex": "^3.0.0"
+      }
+    },
+    "shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true
+    },
+    "signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "dev": true
+    },
     "skin-tone": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/skin-tone/-/skin-tone-2.0.0.tgz",
@@ -2677,6 +3145,17 @@
         "strip-ansi": "^6.0.1"
       }
     },
+    "string-width-cjs": {
+      "version": "npm:string-width@4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "requires": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      }
+    },
     "strip-ansi": {
       "version": "6.0.1",
       "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
@@ -2686,6 +3165,15 @@
         "ansi-regex": "^5.0.1"
       }
     },
+    "strip-ansi-cjs": {
+      "version": "npm:strip-ansi@6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "requires": {
+        "ansi-regex": "^5.0.1"
+      }
+    },
     "strip-json-comments": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
@@ -2773,14 +3261,74 @@
         "builtins": "^5.0.0"
       }
     },
+    "which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "requires": {
+        "isexe": "^2.0.0"
+      }
+    },
     "workerpool": {
-      "version": "6.2.1",
-      "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.2.1.tgz",
-      "integrity": "sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==",
+      "version": "6.5.1",
+      "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.5.1.tgz",
+      "integrity": "sha512-Fs4dNYcsdpYSAfVxhnl1L5zTksjvOJxtC5hzMNl+1t9B8hTJTdKDyZ5ju7ztgPy+ft9tBFXoOlDNiOT9WUXZlA==",
       "dev": true
     },
     "wrap-ansi": {
-      "version": "7.0.0",
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
+      "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
+      "dev": true,
+      "requires": {
+        "ansi-styles": "^6.1.0",
+        "string-width": "^5.0.1",
+        "strip-ansi": "^7.0.1"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "6.1.0",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
+          "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
+          "dev": true
+        },
+        "ansi-styles": {
+          "version": "6.2.1",
+          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz",
+          "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==",
+          "dev": true
+        },
+        "emoji-regex": {
+          "version": "9.2.2",
+          "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
+          "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
+          "dev": true
+        },
+        "string-width": {
+          "version": "5.1.2",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
+          "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
+          "dev": true,
+          "requires": {
+            "eastasianwidth": "^0.2.0",
+            "emoji-regex": "^9.2.2",
+            "strip-ansi": "^7.0.1"
+          }
+        },
+        "strip-ansi": {
+          "version": "7.1.0",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
+          "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
+          "dev": true,
+          "requires": {
+            "ansi-regex": "^6.0.1"
+          }
+        }
+      }
+    },
+    "wrap-ansi-cjs": {
+      "version": "npm:wrap-ansi@7.0.0",
       "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
       "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
       "dev": true,
@@ -2790,12 +3338,6 @@
         "strip-ansi": "^6.0.0"
       }
     },
-    "wrappy": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
-      "dev": true
-    },
     "y18n": {
       "version": "5.0.8",
       "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
@@ -2809,24 +3351,24 @@
       "dev": true
     },
     "yargs": {
-      "version": "16.2.0",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz",
-      "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==",
+      "version": "17.7.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
       "dev": true,
       "requires": {
-        "cliui": "^7.0.2",
+        "cliui": "^8.0.1",
         "escalade": "^3.1.1",
         "get-caller-file": "^2.0.5",
         "require-directory": "^2.1.1",
-        "string-width": "^4.2.0",
+        "string-width": "^4.2.3",
         "y18n": "^5.0.5",
-        "yargs-parser": "^20.2.2"
+        "yargs-parser": "^21.1.1"
       }
     },
     "yargs-parser": {
-      "version": "20.2.4",
-      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.4.tgz",
-      "integrity": "sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==",
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
       "dev": true
     },
     "yargs-unparser": {
diff --git a/package.json b/package.json
index 0bad6e6e8..db1c66b0e 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.22",
+  "version": "0.34.23",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -36,7 +36,7 @@
     "@types/node": "^20.10.1",
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "mocha": "^10.4.0",
+    "mocha": "^11.1.0",
     "prettier": "^2.7.1",
     "typescript": "^5.7.3"
   }
diff --git a/src/index.ts b/src/index.ts
index 847758ecd..54d6bbc8a 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -87,7 +87,6 @@ export * from './type/record/index'
 export * from './type/recursive/index'
 export * from './type/ref/index'
 export * from './type/regexp/index'
-export * from './type/remap/index'
 export * from './type/required/index'
 export * from './type/rest/index'
 export * from './type/return-type/index'
diff --git a/src/syntax/runtime.ts b/src/syntax/runtime.ts
index c5366d277..227393a1b 100644
--- a/src/syntax/runtime.ts
+++ b/src/syntax/runtime.ts
@@ -69,10 +69,17 @@ const Dereference = (context: t.TProperties, key: string): t.TSchema => {
 // GenericReference
 // ------------------------------------------------------------------
 function GenericReferenceMapping(results: unknown[], context: t.TProperties) {
-  const target = Dereference(context, results[0] as string)
-  return t.Instantiate(target, results[2] as t.TSchema[])
+  const type = Dereference(context, results[0] as string)
+  const args = results[2] as t.TSchema[]
+  return t.Instantiate(type, args)
 }
-const GenericReference = Runtime.Tuple([Runtime.Ident(), Runtime.Const(LAngle), Runtime.Ref('Elements'), Runtime.Const(RAngle)], (results, context) => GenericReferenceMapping(results, context))
+// prettier-ignore
+const GenericReference = Runtime.Tuple([
+  Runtime.Ident(), 
+  Runtime.Const(LAngle), 
+  Runtime.Ref('Elements'), 
+  Runtime.Const(RAngle)
+], (results, context) => GenericReferenceMapping(results, context))
 // ------------------------------------------------------------------
 // Reference
 // ------------------------------------------------------------------
diff --git a/src/syntax/static.ts b/src/syntax/static.ts
index fd06a402e..1ace9a445 100644
--- a/src/syntax/static.ts
+++ b/src/syntax/static.ts
@@ -148,8 +148,8 @@ type Dereference<Context extends t.TProperties, Ref extends string> = (
 // prettier-ignore
 interface GenericReferenceMapping extends Static.IMapping {
   output: this['context'] extends t.TProperties
-    ? this['input'] extends [infer Reference extends string, LAngle, infer Parameters extends t.TSchema[], RAngle]
-      ? t.TInstantiate<Dereference<this['context'], Reference>, [...Parameters]>
+    ? this['input'] extends [infer Reference extends string, LAngle, infer Args extends t.TSchema[], RAngle]
+      ? t.TInstantiate<Dereference<this['context'], Reference>, Args>
       : never
     : never  
 }
diff --git a/src/type/instantiate/instantiate.ts b/src/type/instantiate/instantiate.ts
index b42628667..210df5f66 100644
--- a/src/type/instantiate/instantiate.ts
+++ b/src/type/instantiate/instantiate.ts
@@ -26,71 +26,281 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import type { TSchema } from '../schema/index'
-import type { TArgument } from '../argument/index'
+import { CloneType } from '../clone/type'
+import { type TSchema } from '../schema/index'
+import { type TArgument } from '../argument/index'
 import { type TNever, Never } from '../never/index'
 import { type TReadonlyOptional, ReadonlyOptional } from '../readonly-optional/index'
 import { type TReadonly, Readonly } from '../readonly/index'
 import { type TOptional, Optional } from '../optional/index'
+import { type TConstructor } from '../constructor/index'
+import { type TFunction } from '../function/index'
+import { type TIntersect } from '../intersect/index'
+import { type TUnion } from '../union/index'
+import { type TTuple } from '../tuple/index'
+import { type TArray } from '../array/index'
+import { type TAsyncIterator } from '../async-iterator/index'
+import { type TIterator } from '../iterator/index'
+import { type TPromise } from '../promise/index'
+import { type TObject, type TProperties } from '../object/index'
+import { type TRecordOrObject, type TRecord, Record, RecordKey, RecordValue } from '../record/index'
 
-import { Remap, type TRemap, type TMapping as TRemapMapping } from '../remap/index'
+import * as ValueGuard from '../guard/value'
 import * as KindGuard from '../guard/kind'
 
 // ------------------------------------------------------------------
-// InstantiateArgument
+// Constructor
 // ------------------------------------------------------------------
 // prettier-ignore
-type TInstantiateArgument<Argument extends TArgument, Type extends TSchema,
-  IsArgumentReadonly extends number = Argument extends TReadonly<TSchema> ? 1 : 0,
-  IsArgumentOptional extends number = Argument extends TOptional<TSchema> ? 1 : 0,
+type TFromConstructor<Args extends TSchema[], Parameters extends TSchema[], InstanceType extends TSchema,
+  Result extends TConstructor = TConstructor<TFromTypes<Args, Parameters>, TFromType<Args, InstanceType>>
+> = Result
+// prettier-ignore
+function FromConstructor(args: TSchema[], type: TConstructor): TConstructor {
+  type.parameters = FromTypes(args, type.parameters)
+  type.returns = FromType(args, type.returns)
+  return type
+}
+// ------------------------------------------------------------------
+// Function
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromFunction<Args extends TSchema[], Parameters extends TSchema[], ReturnType extends TSchema,
+  Result extends TFunction = TFunction<TFromTypes<Args, Parameters>, TFromType<Args, ReturnType>>
+> = Result
+// prettier-ignore
+function FromFunction(args: TSchema[], type: TFunction): TFunction {
+  type.parameters = FromTypes(args, type.parameters)
+  type.returns = FromType(args, type.returns)
+  return type
+}
+// ------------------------------------------------------------------
+// Intersect
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromIntersect<Args extends TSchema[], Types extends TSchema[],
+  Result extends TIntersect = TIntersect<TFromTypes<Args, Types>>
+> = Result
+// prettier-ignore
+function FromIntersect(args: TSchema[], type: TIntersect): TIntersect {
+  type.allOf = FromTypes(args, type.allOf)
+  return type
+}
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromUnion<Args extends TSchema[], Types extends TSchema[],
+  Result extends TUnion = TUnion<TFromTypes<Args, Types>>
+> = Result
+// prettier-ignore
+function FromUnion(args: TSchema[], type: TUnion): TUnion {
+  type.anyOf = FromTypes(args, type.anyOf)
+  return type
+}
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromTuple<Args extends TSchema[], Types extends TSchema[],
+  Result extends TTuple = TTuple<TFromTypes<Args, Types>>
+> = Result
+// prettier-ignore
+function FromTuple(args: TSchema[], type: TTuple): TTuple {
+  if(ValueGuard.IsUndefined(type.items)) return type
+  type.items = FromTypes(args, type.items!)
+  return type
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromArray<Args extends TSchema[], Type extends TSchema,
+  Result extends TArray = TArray<TFromType<Args, Type>>
+> = Result
+// prettier-ignore
+function FromArray(args: TSchema[], type: TArray): TArray {
+  type.items = FromType(args, type.items)
+  return type
+}
+// ------------------------------------------------------------------
+// AsyncIterator
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromAsyncIterator<Args extends TSchema[], Type extends TSchema,
+  Result extends TAsyncIterator = TAsyncIterator<TFromType<Args, Type>>
+> = Result
+// prettier-ignore
+function FromAsyncIterator(args: TSchema[], type: TAsyncIterator): TAsyncIterator {
+  type.items = FromType(args, type.items)
+  return type
+}
+// ------------------------------------------------------------------
+// Iterator
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromIterator<Args extends TSchema[], Type extends TSchema,
+  Result extends TIterator = TIterator<TFromType<Args, Type>>
+> = Result
+// prettier-ignore
+function FromIterator(args: TSchema[], type: TIterator): TIterator {
+  type.items = FromType(args, type.items)
+  return type
+}
+// ------------------------------------------------------------------
+// Promise
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromPromise<Args extends TSchema[], Type extends TSchema,
+  Result extends TPromise = TPromise<TFromType<Args, Type>>
+> = Result
+// prettier-ignore
+function FromPromise(args: TSchema[], type: TPromise): TPromise {
+  type.item = FromType(args, type.item)
+  return type
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromObject<Args extends TSchema[], Properties extends TProperties,
+  Result extends TObject = TObject<TFromProperties<Args, Properties>>
+> = Result
+// prettier-ignore
+function FromObject(args: TSchema[], type: TObject): TObject {
+  type.properties = FromProperties(args, type.properties)
+  return type
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRecord<Args extends TSchema[], Key extends TSchema, Value extends TSchema,
+  MappedKey extends TSchema = TFromType<Args, Key>,
+  MappedValue extends TSchema = TFromType<Args, Value>,
+  Result extends TSchema = TRecordOrObject<MappedKey, MappedValue>
+> = Result
+// prettier-ignore
+function FromRecord(args: TSchema[], type: TRecord): TRecord {
+  const mappedKey = FromType(args, RecordKey(type))
+  const mappedValue = FromType(args, RecordValue(type))
+  const result = Record(mappedKey, mappedValue)
+  return { ...type, ... result } as never // retain options
+}
+// ------------------------------------------------------------------
+// Argument
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromArgument<Args extends TSchema[], Index extends number> = (
+  Index extends keyof Args ? Args[Index] : TNever
+)
+// prettier-ignore
+function FromArgument(args: TSchema[], argument: TArgument): TSchema {
+  return argument.index in args ? args[argument.index] : Never()
+}
+// ------------------------------------------------------------------
+// Property
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromProperty<Args extends TSchema[], Type extends TSchema,
+  IsReadonly extends boolean = Type extends TReadonly<Type> ? true : false,   
+  IsOptional extends boolean = Type extends TOptional<Type> ? true : false,
+  Mapped extends TSchema = TFromType<Args, Type>,
   Result extends TSchema = (
-    [IsArgumentReadonly, IsArgumentOptional]  extends [1, 1] ? TReadonlyOptional<Type> :
-    [IsArgumentReadonly, IsArgumentOptional]  extends [0, 1] ? TOptional<Type> :
-    [IsArgumentReadonly, IsArgumentOptional]  extends [1, 0] ? TReadonly<Type> :
-    Type
-  ) 
+    [IsReadonly, IsOptional] extends [true, true] ? TReadonlyOptional<Mapped> :
+    [IsReadonly, IsOptional] extends [true, false] ? TReadonly<Mapped> :
+    [IsReadonly, IsOptional] extends [false, true] ? TOptional<Mapped> :
+    Mapped
+  )
 > = Result
 // prettier-ignore
-function InstantiateArgument<Argument extends TArgument, Type extends TSchema>(argument: Argument, type: Type): TInstantiateArgument<Argument, Type> {
-  const isReadonly = KindGuard.IsReadonly(argument)
-  const isOptional = KindGuard.IsOptional(argument)
+function FromProperty<Args extends TSchema[], Type extends TSchema>(args: [...Args], type: Type): TFromProperty<Args, Type> {
+  const isReadonly = KindGuard.IsReadonly(type)
+  const isOptional = KindGuard.IsOptional(type)
+  const mapped = FromType(args, type)
   return (
-    isReadonly && isOptional ? ReadonlyOptional(type) :
-    isReadonly && !isOptional ? Readonly(type) :
-    !isReadonly && isOptional ? Optional(type) :
-    type
+    isReadonly && isOptional ? ReadonlyOptional(mapped) :
+    isReadonly && !isOptional ? Readonly(mapped) :
+    !isReadonly && isOptional ? Optional(mapped) :
+    mapped
   ) as never
 }
 // ------------------------------------------------------------------
-// Instantiate
+// Properties
 // ------------------------------------------------------------------
 // prettier-ignore
-interface TInstantiateArguments<Arguments extends TSchema[]> extends TRemapMapping { 
-  output: (
-    this['input'] extends TArgument<infer Index extends number>
-      ? Index extends keyof Arguments 
-        ? Arguments[Index] extends TSchema
-          ? TInstantiateArgument<this['input'], Arguments[Index]>
-          : TNever
-        : TNever
-      : this['input']
-  )
+type TFromProperties<Args extends TSchema[], Properties extends TProperties, 
+  Result extends TProperties = {
+    [Key in keyof Properties]: TFromProperty<Args, Properties[Key]>
+  }
+> = Result
+// prettier-ignore
+function FromProperties<Args extends TSchema[], Properties extends TProperties>(args: TSchema[], properties: TProperties): TFromProperties<Args, Properties> {
+  return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+    return { ...result, [key]: FromProperty(args, properties[key]) }
+  }, {}) as never
 }
-/** `[JavaScript]` Instantiates a type with the given parameters */
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TFromTypes<Args extends TSchema[], Types extends TSchema[], Result extends TSchema[] = []> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
+    ? TFromTypes<Args, Right, [...Result, TFromType<Args, Left>]>
+    : Result
+)
+// prettier-ignore
+export function FromTypes<Args extends TSchema[], Types extends TSchema[]>(args: [...Args], types: [...Types]): TFromTypes<Args, Types> {
+  return types.map(type => FromType(args, type)) as never
+}
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
 // prettier-ignore
-export type TInstantiate<Type extends TSchema, Arguments extends TSchema[]> = (
-  TRemap<Type, TInstantiateArguments<Arguments>>
+export type TFromType<Args extends TSchema[], Type extends TSchema> = (
+  Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<Args, Parameters, InstanceType> :
+  Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<Args, Parameters, ReturnType> :
+  Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Args, Types> :
+  Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Args, Types> :
+  Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Args, Types> :
+  Type extends TArray<infer Type extends TSchema> ? TFromArray<Args, Type>:
+  Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<Args, Type> :
+  Type extends TIterator<infer Type extends TSchema> ? TFromIterator<Args, Type> :
+  Type extends TPromise<infer Type extends TSchema> ? TFromPromise<Args, Type> :
+  Type extends TObject<infer Properties extends TProperties> ? TFromObject<Args, Properties> :
+  Type extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TFromRecord<Args, Key, Value> :
+  Type extends TArgument<infer Index extends number> ? TFromArgument<Args, Index> :
+  Type
 )
+// prettier-ignore
+function FromType<Args extends TSchema[], Type extends TSchema>(args: [...Args], type: TSchema): TFromType<Args, Type> {
+  return (
+    KindGuard.IsConstructor(type) ? FromConstructor(args, type) :
+    KindGuard.IsFunction(type) ? FromFunction(args, type) :
+    KindGuard.IsIntersect(type) ? FromIntersect(args, type) :
+    KindGuard.IsUnion(type) ? FromUnion(args, type) :
+    KindGuard.IsTuple(type) ? FromTuple(args, type) :
+    KindGuard.IsArray(type) ? FromArray(args, type) :
+    KindGuard.IsAsyncIterator(type) ? FromAsyncIterator(args, type) :
+    KindGuard.IsIterator(type) ? FromIterator(args, type) :
+    KindGuard.IsPromise(type) ? FromPromise(args, type) :
+    KindGuard.IsObject(type) ? FromObject(args, type):
+    KindGuard.IsRecord(type) ? FromRecord(args, type) :
+    KindGuard.IsArgument(type) ? FromArgument(args, type) :
+    type
+  ) as never
+}
+// ------------------------------------------------------------------
+// Instantiate
+// ------------------------------------------------------------------
+/** `[JavaScript]` Instantiates a type with the given parameters */
+// prettier-ignore
+export type TInstantiate<Type extends TSchema, Args extends TSchema[],
+  Result extends TSchema = TFromType<Args, Type>
+> = Result
+
 /** `[JavaScript]` Instantiates a type with the given parameters */
 // prettier-ignore
-export function Instantiate<Type extends TSchema, Arguments extends TSchema[]>(type: Type, args: [...Arguments]): TInstantiate<Type, Arguments> {
-  return Remap(type, (type) => {
-    return KindGuard.IsArgument(type)
-      ? type.index in args
-        ? KindGuard.IsSchema(args[type.index])
-          ? InstantiateArgument(type, args[type.index]) 
-          : Never()
-        : Never()
-      : type
-  }) as never
+export function Instantiate<Type extends TSchema, Args extends TSchema[]>(type: Type, args: [...Args]): TInstantiate<Type, Args> {
+  return FromType(args, CloneType(type))
 }
diff --git a/src/type/remap/index.ts b/src/type/remap/index.ts
deleted file mode 100644
index f05c8c5db..000000000
--- a/src/type/remap/index.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-export * from './remap'
diff --git a/src/type/remap/remap.ts b/src/type/remap/remap.ts
deleted file mode 100644
index d0c707cfc..000000000
--- a/src/type/remap/remap.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/prototypes
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { TSchema } from '../schema/index'
-import { Object, TObject, TProperties } from '../object/index'
-import { Constructor, TConstructor } from '../constructor/index'
-import { Function, TFunction } from '../function/index'
-import { Intersect, TIntersect } from '../intersect/index'
-import { Union, TUnion } from '../union/index'
-import { Tuple, TTuple } from '../tuple/index'
-import { Array, TArray } from '../array/index'
-import { AsyncIterator, TAsyncIterator } from '../async-iterator/index'
-import { Iterator, TIterator } from '../iterator/index'
-import { Promise, TPromise } from '../promise/index'
-import { Record, TRecord, TRecordOrObject, RecordKey, RecordValue } from '../record/index'
-
-import * as KindGuard from '../guard/kind'
-import { CloneType } from '../clone/type'
-
-// ------------------------------------------------------------------
-// Callback
-// ------------------------------------------------------------------
-export type TCallback = (schema: TSchema) => TSchema
-// ------------------------------------------------------------------
-// Mapping
-// ------------------------------------------------------------------
-export interface TMapping {
-  input: unknown
-  output: unknown
-}
-// ------------------------------------------------------------------
-// Apply
-// ------------------------------------------------------------------
-// prettier-ignore
-type TApply<Type extends TSchema, Mapping extends TMapping,
-  Mapped = (Mapping & { input: Type })['output'],
-  Result = Mapped extends TSchema ? Mapped : never
-> = Result
-// ------------------------------------------------------------------
-// Properties
-// ------------------------------------------------------------------
-// prettier-ignore
-type TFromProperties<Properties extends TProperties, Mapping extends TMapping, Result extends TProperties = {
-  [Key in keyof Properties]: TRemap<Properties[Key], Mapping>
-}> = Result
-function FromProperties(properties: TProperties, func: TCallback): TProperties {
-  return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
-    return { ...result, [key]: Remap(properties[key], func) }
-  }, {})
-}
-// ------------------------------------------------------------------
-// Types
-// ------------------------------------------------------------------
-// prettier-ignore
-type TFromTypes<Types extends TSchema[], Mapping extends TMapping, Result extends TSchema[] = []> = (
-  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
-    ? TFromTypes<Right, Mapping, [...Result, TRemap<Left, Mapping>]>
-    : Result
-)
-function FromTypes(types: TSchema[], callback: TCallback): TSchema[] {
-  return types.map((type) => Remap(type, callback))
-}
-// ------------------------------------------------------------------
-// Type
-// ------------------------------------------------------------------
-// prettier-ignore
-type TFromType<Type extends TSchema, Mapping extends TMapping, Result extends TSchema = (
-  TApply<Type, Mapping>
-)> = Result
-function FromType(type: TSchema, callback: TCallback): TSchema {
-  return callback(type)
-}
-// ------------------------------------------------------------------
-// TRemap<Type, Function>
-// ------------------------------------------------------------------
-/** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
-// prettier-ignore
-export type TRemap<Type extends TSchema, Mapping extends TMapping, 
-  // Maps the Exterior Type
-  Mapped extends TSchema = TFromType<Type, Mapping>, 
-  // Maps the Interior Parameterized Types
-  Result extends TSchema = (
-    Mapped extends TConstructor<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TConstructor<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> :
-    Mapped extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> :
-    Mapped extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Types, Mapping>> :
-    Mapped extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Types, Mapping>> :
-    Mapped extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Types, Mapping>> :
-    Mapped extends TArray<infer Type extends TSchema> ? TArray<TFromType<Type, Mapping>>:
-    Mapped extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TFromType<Type, Mapping>> :
-    Mapped extends TIterator<infer Type extends TSchema> ? TIterator<TFromType<Type, Mapping>> :
-    Mapped extends TPromise<infer Type extends TSchema> ? TPromise<TFromType<Type, Mapping>> :
-    Mapped extends TObject<infer Properties extends TProperties> ? TObject<TFromProperties<Properties, Mapping>> :
-    Mapped extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TRecordOrObject<TFromType<Key, Mapping>, TFromType<Value, Mapping>> :
-    Mapped
-  )
-> = Result
-/** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
-// prettier-ignore
-export function Remap(type: TSchema, callback: TCallback): TSchema {
-  // Map incoming type
-  const mapped = CloneType(FromType(type, callback))
-  // Return remapped interior
-  return (
-    KindGuard.IsConstructor(type) ? Constructor(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
-    KindGuard.IsFunction(type) ? Function(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
-    KindGuard.IsIntersect(type) ? Intersect(FromTypes(type.allOf, callback), mapped) :
-    KindGuard.IsUnion(type) ? Union(FromTypes(type.anyOf, callback), mapped) :
-    KindGuard.IsTuple(type) ? Tuple(FromTypes(type.items || [], callback), mapped) :
-    KindGuard.IsArray(type) ? Array(FromType(type.items, callback), mapped) :
-    KindGuard.IsAsyncIterator(type) ? AsyncIterator(FromType(type.items, callback), mapped) :
-    KindGuard.IsIterator(type) ? Iterator(FromType(type.items, callback), mapped) :
-    KindGuard.IsPromise(type) ? Promise(FromType(type.items, callback), mapped) :
-    KindGuard.IsObject(type) ? Object(FromProperties(type.properties, callback), mapped) :
-    KindGuard.IsRecord(type) ? Record(FromType(RecordKey(type), callback), FromType(RecordValue(type), callback), mapped) :
-    CloneType(mapped)
-  )
-}
diff --git a/src/type/type/type.ts b/src/type/type/type.ts
index d384cfa33..83fc32dc2 100644
--- a/src/type/type/type.ts
+++ b/src/type/type/type.ts
@@ -74,7 +74,6 @@ export { Record } from '../record/index'
 export { Recursive } from '../recursive/index'
 export { Ref } from '../ref/index'
 export { RegExp } from '../regexp/index'
-export { Remap } from '../remap/index'
 export { Required } from '../required/index'
 export { Rest } from '../rest/index'
 export { ReturnType } from '../return-type/index'

From f41dfe37abcb0ca622a2aa1be408e660ecf36e08 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 16 Feb 2025 04:15:52 +0900
Subject: [PATCH 342/369] Revision 0.34.24 (#1175)

* Support Generic Parameter Syntax

* Documentation

* Version

* ChangeLog
---
 changelog/0.34.0.md                 |  3 +-
 package-lock.json                   |  4 +-
 package.json                        |  2 +-
 readme.md                           | 56 ++++++++++----------
 src/syntax/runtime.ts               | 46 +++++++++++++++++
 src/syntax/static.ts                | 40 +++++++++++++++
 src/syntax/syntax.ts                | 80 ++++++++++++++++-------------
 src/type/instantiate/instantiate.ts | 20 ++++----
 test/runtime/syntax/syntax.ts       |  2 +-
 test/static/index.ts                |  1 +
 test/static/syntax.ts               | 35 +++++++++++++
 11 files changed, 211 insertions(+), 78 deletions(-)
 create mode 100644 test/static/syntax.ts

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 2550686c4..50b6a5ce4 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -4,7 +4,8 @@
 
 ### Revision Updates
 
-
+- [Revision 0.34.24](https://github.com/sinclairzx81/typebox/pull/1175)
+  - Add Support For Generic Parameter Syntax
 - [Revision 0.34.23](https://github.com/sinclairzx81/typebox/pull/1174)
   - Inline Instantiate Type Logic Local to Instantiate Module
 - [Revision 0.34.22](https://github.com/sinclairzx81/typebox/pull/1171)
diff --git a/package-lock.json b/package-lock.json
index a7caf3c68..5dffd1d6e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.23",
+  "version": "0.34.24",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.23",
+      "version": "0.34.24",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index db1c66b0e..7281eb530 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.23",
+  "version": "0.34.24",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index bd108c697..5ffedc827 100644
--- a/readme.md
+++ b/readme.md
@@ -98,8 +98,8 @@ License MIT
 - [Syntax](#syntax)
   - [Create](#syntax-create)
   - [Parameters](#syntax-parameters)
-  - [Options](#syntax-options)
   - [Generics](#syntax-generics)
+  - [Options](#syntax-options)
 - [TypeRegistry](#typeregistry)
   - [Type](#typeregistry-type)
   - [Format](#typeregistry-format)
@@ -1306,9 +1306,9 @@ ValuePointer.Set(A, '/z', 1)                         // A' = { x: 1, y: 1, z: 1
 
 ## Syntax Types
 
-TypeBox has support for parsing TypeScript syntax at runtime as well as statically in the type system. This feature offers a syntactical frontend to the TypeBox type builder.
+TypeBox includes support for parsing TypeScript annotation syntax into TypeBox schematics.
 
-Syntax types are available via optional import.
+This feature is provided via optional import.
 
 ```typescript
 import { Syntax } from '@sinclair/typebox/syntax'
@@ -1318,20 +1318,25 @@ import { Syntax } from '@sinclair/typebox/syntax'
 
 ### Create
 
-Use the Syntax function to create TypeBox types from TypeScript syntax
+Use the Syntax function to create TypeBox types from TypeScript syntax ([Example](https://www.typescriptlang.org/play/?moduleResolution=99&module=199&ts=5.8.0-beta#code/JYWwDg9gTgLgBAbzgZQJ4DsYEMAecC+cAZlBCHAOQACAzsOgMYA2WwUA9DKmAKYBGEHOxoZsOCgChQkWIhTYYwBgWKly1OoxZtO3foMkSGEdDXgAVOAF4Uo3AAoABkhwAuOOgCuIPjygAaOFR3Lx8-AkcASjgY2Jj2djhjUwt3cwB5PgArHgYYAB4ECTiS0rLyisrYhNi3OHMAOW9fAOKq9o7OuBqY4PqmsKg2rpHR+MT8AD4JCS5eeut5LEUGfLmeCCJ6ybHKmvWFmyLdk86euDrQlv9h07uy876rv1v7t-GCIA))
 
 ```typescript
 const T = Syntax(`{ x: number, y: number }`)        // const T: TObject<{
                                                     //   x: TNumber,
                                                     //   y: TNumber
                                                     // }>
+
+type T = Static<typeof T>                            // type T = {
+                                                     //   x: number,
+                                                     //   y: number
+                                                     // }
 ```
 
 <a name="syntax-parameters"></a>
 
 ### Parameters
 
-Syntax types can be parameterized to receive exterior types.
+Syntax types can be parameterized to receive exterior types ([Example](https://www.typescriptlang.org/play/?moduleResolution=99&module=199&ts=5.8.0-beta#code/JYWwDg9gTgLgBAbzgZQJ4DsYEMAecC+cAZlBCHAOQACAzsOgMYA2WwUA9DKmAKYBGEHOxoZsOCgCgJDCOhrwAKnAC8KUbgAUAAyQ4AXHHQBXEHx5QANHFQHjp8wS0BKOK7ev27ODLmKDCgHk+ACseBhgAHgQJd1i4+ITEpLdPN304BQA5EzNLGOSCwqK4VNcbDOz7KHzi2rqPL3wAPikfeRQVNUxNJCV8Ky0ABSxYYCwmCIUm52LUtvhkfyDQ8Kia+o2C0rh0wLAYYFlxycrcpot1zav47fK9g6OJrJzzFuv3m8amoA))
 
 ```typescript
 const T = Syntax(`{ x: number, y: number }`)        // const T: TObject<{
@@ -1345,35 +1350,19 @@ const S = Syntax({ T }, `Partial<T>`)               // const S: TObject<{
                                                     // }>
 ```
 
-<a name='syntax-options'></a>
-
-### Options
 
-Options can be passed via the last parameter
-
-```typescript
-const T = Syntax(`number`, {                      // const T = {
-  minimum: 0,                                     //   type: 'number',
-  maximum: 10                                     //   minimum: 0,
-})                                                //   maximum: 10
-                                                  // }
-```
 
 <a name="syntax-generics"></a>
 
 ### Generics
 
-Generic types can be created using positional argument types ([Example](https://www.typescriptlang.org/play/?moduleResolution=99&module=199&ts=5.8.0-beta#code/JYWwDg9gTgLgBAbzgZQJ4DsYEMAecC+cAZlBCHAOQACAzsOgMYA2WwUA9DKmAKYBGEHOxoZsOCgChQkWIhTYYwBgWKly1OoxZtO3foMkSGEdDXgAVAAxwAvClG4AFBQCCUAOYBXED0wAeSwA+CgBKIxMzOHMARlt7TCdXD29fGD9o4LDjUwsAJji0BJxnNy8ff1zMiXCcuAA1HgYYaAKHYqQrABoo6O7zfPxugAMECTg4HAAuKMtOsbhUaZi58YAvJdyJfCGwmsiAISw6Ggam6BpWosckU+aoAmHR8an6xrv07tm4IJWF6dvoAFur1voFfutXmcoEDvsCwVsdtUuLw4IdjgCoBc7MgFEo-MieBAiKijsATm9zoFxtT2Ow4ASSeiKZi4k9qeyOZyudyeTzadSXkgXiDFrC4BDrIN5ryZbK5ez+eNRULpl9RSCJQ9pfKdbqFXS1tMVWLRV8IbF8Nq9da5fzCEA))
+Syntax types support generic parameters in the following way ([Example](https://www.typescriptlang.org/play/?moduleResolution=99&module=199&ts=5.8.0-beta#code/JYWwDg9gTgLgBAbzgZQJ4DsYEMAecC+cAZlBCHAOQACAzsOgMYA2WwUA9DKmAKYBGEHOxoZsOCgChQkWIhTYYwBgWKly1OoxZtO3foMkSGEdDXgA1HgxjQ4AXhSjcACgAGAHgAaAGjgBNXwAtAD45CTg4HAAuOB84cLhUGID4iIAvGMD4-FcASgkjEzM4ACEsOhpLa2gae0dMFyQqmygCX1cEBOi4Zuh3AEZfAAZh4O8EpJ6rFvcRuEG4IbGEjKnqqFnh337lnPyJLl5S8uBK6Zq65AUld0OeCCJjit6oGlCIiPZ2ODun05fag5Oh8QaCweCIZCoV8Pt0kN0FpM5qshm0ElCMZisSCYRFJvCYnNJgsUWjseSKeDcXBVgTFr4kb5Vv0COjKezsTD8EA))
 
 ```typescript
-const T0 = Syntax('Argument<0>')
-const T1 = Syntax('Argument<1>')
-const T2 = Syntax('Argument<2>')
-
-const Vector = Syntax({ T0, T1, T2 }, `{
-  x: T0,
-  y: T1,
-  z: T2
+const Vector = Syntax(`<X, Y, Z> { 
+  x: X, 
+  y: Y, 
+  z: Z 
 }`)
 
 const BasisVectors = Syntax({ Vector }, `{
@@ -1386,7 +1375,20 @@ type BasisVectors = Static<typeof BasisVectors>     // type BasisVectors = {
                                                     //   x: { x: 1, y: 0, z: 0 },
                                                     //   y: { x: 0, y: 1, z: 0 },
                                                     //   z: { x: 0, y: 0, z: 1 }
-                                                    // } 
+                                                    // }
+```
+
+<a name='syntax-options'></a>
+
+### Options
+
+Options can be passed via the last parameter
+
+```typescript
+const T = Syntax(`number`, { minimum: 42 })       // const T = {
+                                                  //   type: 'number',
+                                                  //   minimum: 42
+                                                  // }
 ```
 
 <a name='typeregistry'></a>
diff --git a/src/syntax/runtime.ts b/src/syntax/runtime.ts
index 227393a1b..f13a09aea 100644
--- a/src/syntax/runtime.ts
+++ b/src/syntax/runtime.ts
@@ -66,6 +66,46 @@ const Dereference = (context: t.TProperties, key: string): t.TSchema => {
   return key in context ? context[key] : t.Ref(key)
 }
 // ------------------------------------------------------------------
+// GenericArgumentList
+// ------------------------------------------------------------------
+// prettier-ignore
+const GenericArgumentListMapping = (results: unknown[]) => {
+  return (
+    results.length === 3 ? [results[0], ...results[2] as unknown[]] :
+    results.length === 2 ? [results[0]] :
+    results.length === 1 ? [results[0]] :
+    []
+  )
+}
+// prettier-ignore
+const GenericArgumentList = Runtime.Union([
+  Runtime.Tuple([Runtime.Ident(), Runtime.Const(Comma), Runtime.Ref('GenericArgumentList')]),
+  Runtime.Tuple([Runtime.Ident(), Runtime.Const(Comma)]),
+  Runtime.Tuple([Runtime.Ident()]),
+  Runtime.Tuple([]),
+], (results) => GenericArgumentListMapping(results))
+// ------------------------------------------------------------------
+// GenericArguments
+// ------------------------------------------------------------------
+// prettier-ignore
+const GenericArgumentsContext = (args: string[]) => {
+  return args.reduce((result, arg, index) => {
+    return { ...result, [arg]: t.Argument(index) }
+  }, {})
+}
+// prettier-ignore
+const GenericArgumentsMapping = (results: unknown[]) => {
+  return results.length === 3
+    ? GenericArgumentsContext(results[1] as string[])
+    : {}
+}
+// prettier-ignore
+const GenericArguments = Runtime.Tuple([
+  Runtime.Const(LAngle),
+  Runtime.Ref('GenericArgumentList'),
+  Runtime.Const(RAngle),
+], results => GenericArgumentsMapping(results))
+// ------------------------------------------------------------------
 // GenericReference
 // ------------------------------------------------------------------
 function GenericReferenceMapping(results: unknown[], context: t.TProperties) {
@@ -657,11 +697,17 @@ const Date = Runtime.Const('Date', Runtime.As(t.Date()))
 // Uint8Array
 // ------------------------------------------------------------------
 const Uint8Array = Runtime.Const('Uint8Array', Runtime.As(t.Uint8Array()))
+
 // ------------------------------------------------------------------
 // Module
 // ------------------------------------------------------------------
 // prettier-ignore
 export const Module = new Runtime.Module({
+  // ----------------------------------------------------------------
+  // Generic Arguments
+  // ----------------------------------------------------------------
+  GenericArgumentList,
+  GenericArguments,
   // ----------------------------------------------------------------
   // Type Expressions
   // ----------------------------------------------------------------
diff --git a/src/syntax/static.ts b/src/syntax/static.ts
index 1ace9a445..0d06c5bff 100644
--- a/src/syntax/static.ts
+++ b/src/syntax/static.ts
@@ -143,6 +143,46 @@ type Dereference<Context extends t.TProperties, Ref extends string> = (
   Ref extends keyof Context ? Context[Ref] : t.TRef<Ref>
 )
 // ------------------------------------------------------------------
+// GenericArgumentList
+// ------------------------------------------------------------------
+// prettier-ignore
+interface GenericArgumentListMapping extends Static.IMapping {
+  output: (
+    this['input'] extends [infer Ident extends string, Comma, infer Rest extends unknown[]] ? [Ident, ...Rest] :
+    this['input'] extends [infer Ident extends string, Comma] ? [Ident] :
+    this['input'] extends [infer Ident extends string] ? [Ident] :
+    []
+  )
+}
+// prettier-ignore
+type GenericArgumentList = Static.Union<[
+  Static.Tuple<[Static.Ident, Static.Const<Comma>, GenericArgumentList]>,
+  Static.Tuple<[Static.Ident, Static.Const<Comma>]>,
+  Static.Tuple<[Static.Ident]>,
+  Static.Tuple<[]>,
+], GenericArgumentListMapping>
+// ------------------------------------------------------------------
+// GenericArguments
+// ------------------------------------------------------------------
+// prettier-ignore
+type GenericArgumentsContext<Args extends string[], Result extends t.TProperties = {}> = (
+  Args extends [...infer Left extends string[], infer Right extends string]
+    ? GenericArgumentsContext<Left, Result & { [_ in Right]: t.TArgument<Left['length']> }>
+    : t.Evaluate<Result>
+)
+// prettier-ignore
+interface GenericArgumentsMapping extends Static.IMapping {
+  output: this['input'] extends [LAngle, infer Args extends string[], RAngle]
+    ? GenericArgumentsContext<Args>
+    : never
+}
+// prettier-ignore
+export type GenericArguments = Static.Tuple<[
+  Static.Const<LAngle>,
+  GenericArgumentList,
+  Static.Const<RAngle>,
+], GenericArgumentsMapping>
+// ------------------------------------------------------------------
 // GenericReference
 // ------------------------------------------------------------------
 // prettier-ignore
diff --git a/src/syntax/syntax.ts b/src/syntax/syntax.ts
index 4d5550cb3..9f6e482ff 100644
--- a/src/syntax/syntax.ts
+++ b/src/syntax/syntax.ts
@@ -26,43 +26,57 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import * as Types from '../type/index'
+import * as t from '../type/index'
 import { Static } from '../parser/index'
 import { Module } from './runtime'
-import { Type } from './static'
+import { Type, GenericArguments } from './static'
 
+// ------------------------------------------------------------------
+// ParseSyntax: Two-Phase Parse
+// ------------------------------------------------------------------
+// prettier-ignore
+type TParseSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (
+  Static.Parse<GenericArguments, Code, {}> extends [infer Args extends t.TProperties, infer Rest extends string]
+    ? Static.Parse<Type, Rest, Context & Args>
+    : Static.Parse<Type, Code, Context>
+)
+// prettier-ignore
+function ParseSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string>(context: Context, code: Code): [] | [t.TSchema, string] {
+  const results = Module.Parse('GenericArguments', code, {}) // [ArgumentContext, Rest]
+  return (
+    results.length === 2
+      ? Module.Parse('Type', results[1], { ...context, ...results[0] })
+      : Module.Parse('Type', code, context)
+  ) as never
+}
 // ------------------------------------------------------------------
 // NoInfer
 // ------------------------------------------------------------------
-/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
-export function NoInfer<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined
-/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
-export function NoInfer<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined
-/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
+/** Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+export function NoInfer<Context extends Record<PropertyKey, t.TSchema>, Code extends string>(context: Context, code: Code, options?: t.SchemaOptions): t.TSchema
+/** Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+export function NoInfer<Code extends string>(code: Code, options?: t.SchemaOptions): t.TSchema
+/** Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
 // prettier-ignore
-export function NoInfer(...args: any[]): Types.TSchema | undefined {
+export function NoInfer(...args: any[]): t.TSchema {
   const withContext = typeof args[0] === 'string' ? false : true
   const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}]
-  const type = Module.Parse('Type', code, context)[0]
-  return Types.KindGuard.IsSchema(type) 
-    ? Types.CloneType(type, options) 
-    : Types.Never(options)
+  const result = ParseSyntax(context, code)[0]
+  return t.KindGuard.IsSchema(result) 
+    ? t.CloneType(result, options) 
+    : t.Never(options)
 }
-// ------------------------------------------------------------------
-// Syntax
-// ------------------------------------------------------------------
-/** Infers a TSchema type from TypeScript syntax. */
+
+/** Parses a TypeScript annotation into a TypeBox type */
 // prettier-ignore
-export type TSyntax<Context extends Record<PropertyKey, Types.TSchema>, Code extends string> = (
-  Static.Parse<Type, Code, Context> extends [infer Type extends Types.TSchema, string] 
-    ? Type
-    : Types.TNever
+export type TSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (
+  TParseSyntax<Context, Code> extends [infer Type extends t.TSchema, string] ? Type : t.TNever
 )
-/** Parses a TSchema type from TypeScript syntax */
-export function Syntax<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): TSyntax<Context, Code>
-/** Parses a TSchema type from TypeScript syntax */
-export function Syntax<Code extends string>(code: Code, options?: Types.SchemaOptions): TSyntax<{}, Code>
-/** Parses a TSchema type from TypeScript syntax */
+/** Parses a TypeScript annotation into a TypeBox type */
+export function Syntax<Context extends Record<PropertyKey, t.TSchema>, Annotation extends string>(context: Context, annotation: Annotation, options?: t.SchemaOptions): TSyntax<Context, Annotation>
+/** Parses a TypeScript annotation into a TypeBox type */
+export function Syntax<Annotation extends string>(annotation: Annotation, options?: t.SchemaOptions): TSyntax<{}, Annotation>
+/** Parses a TypeScript annotation into a TypeBox type */
 export function Syntax(...args: any[]): never {
   return NoInfer.apply(null, args as never) as never
 }
@@ -70,36 +84,30 @@ export function Syntax(...args: any[]): never {
 // Deprecated
 // ------------------------------------------------------------------
 /**
- * Parses a TSchema type from Syntax.
  * @deprecated Use Syntax() function
  */
-export function Parse<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): TSyntax<Context, Code>
+export function Parse<Context extends Record<PropertyKey, t.TSchema>, Annotation extends string>(context: Context, annotation: Annotation, options?: t.SchemaOptions): TSyntax<Context, Annotation>
 /**
- * Parses a TSchema type from Syntax.
  * @deprecated Use Syntax() function
  */
-export function Parse<Code extends string>(code: Code, options?: Types.SchemaOptions): TSyntax<{}, Code>
+export function Parse<Annotation extends string>(annotation: Annotation, options?: t.SchemaOptions): TSyntax<{}, Annotation>
 /**
- * Parses a TSchema type from Syntax.
  * @deprecated Use Syntax() function
  */
 export function Parse(...args: any[]): never {
   return NoInfer.apply(null, args as never) as never
 }
 /**
- * Parses a TSchema from TypeScript Syntax
  * @deprecated Use NoInfer() function
  */
-export function ParseOnly<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined
+export function ParseOnly<Context extends Record<PropertyKey, t.TSchema>, Code extends string>(context: Context, code: Code, options?: t.SchemaOptions): t.TSchema | undefined
 /**
- * Parses a TSchema from TypeScript Syntax
  * @deprecated Use NoInfer() function
  */
-export function ParseOnly<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined
+export function ParseOnly<Code extends string>(code: Code, options?: t.SchemaOptions): t.TSchema | undefined
 /**
- * Parses a TSchema from TypeScript Syntax
  * @deprecated Use NoInfer() function
  */
-export function ParseOnly(...args: any[]): Types.TSchema | undefined {
+export function ParseOnly(...args: any[]): t.TSchema | undefined {
   return NoInfer.apply(null, args as never) as never
 }
diff --git a/src/type/instantiate/instantiate.ts b/src/type/instantiate/instantiate.ts
index 210df5f66..e4fd67955 100644
--- a/src/type/instantiate/instantiate.ts
+++ b/src/type/instantiate/instantiate.ts
@@ -29,7 +29,7 @@ THE SOFTWARE.
 import { CloneType } from '../clone/type'
 import { type TSchema } from '../schema/index'
 import { type TArgument } from '../argument/index'
-import { type TNever, Never } from '../never/index'
+import { type TUnknown, Unknown } from '../unknown/index'
 import { type TReadonlyOptional, ReadonlyOptional } from '../readonly-optional/index'
 import { type TReadonly, Readonly } from '../readonly/index'
 import { type TOptional, Optional } from '../optional/index'
@@ -42,7 +42,7 @@ import { type TArray } from '../array/index'
 import { type TAsyncIterator } from '../async-iterator/index'
 import { type TIterator } from '../iterator/index'
 import { type TPromise } from '../promise/index'
-import { type TObject, type TProperties } from '../object/index'
+import { type TObject, type TProperties, Object } from '../object/index'
 import { type TRecordOrObject, type TRecord, Record, RecordKey, RecordValue } from '../record/index'
 
 import * as ValueGuard from '../guard/value'
@@ -164,12 +164,12 @@ function FromPromise(args: TSchema[], type: TPromise): TPromise {
 // ------------------------------------------------------------------
 // prettier-ignore
 type TFromObject<Args extends TSchema[], Properties extends TProperties,
-  Result extends TObject = TObject<TFromProperties<Args, Properties>>
-> = Result
+  Result extends TProperties = TFromProperties<Args, Properties>
+> = TObject<Result>
 // prettier-ignore
 function FromObject(args: TSchema[], type: TObject): TObject {
-  type.properties = FromProperties(args, type.properties)
-  return type
+  const properties = FromProperties(args, type.properties)
+  return { ...type, ...Object(properties) } // retain options
 }
 // ------------------------------------------------------------------
 // Object
@@ -191,12 +191,12 @@ function FromRecord(args: TSchema[], type: TRecord): TRecord {
 // Argument
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromArgument<Args extends TSchema[], Index extends number> = (
-  Index extends keyof Args ? Args[Index] : TNever
-)
+type TFromArgument<Args extends TSchema[], Index extends number,
+  Result extends TSchema = Index extends keyof Args[Index] ? Args[Index] : TUnknown
+> = Result
 // prettier-ignore
 function FromArgument(args: TSchema[], argument: TArgument): TSchema {
-  return argument.index in args ? args[argument.index] : Never()
+  return argument.index in args ? args[argument.index] : Unknown() 
 }
 // ------------------------------------------------------------------
 // Property
diff --git a/test/runtime/syntax/syntax.ts b/test/runtime/syntax/syntax.ts
index 62749598e..148119a7d 100644
--- a/test/runtime/syntax/syntax.ts
+++ b/test/runtime/syntax/syntax.ts
@@ -417,6 +417,6 @@ describe('syntax/Syntax', () => {
     const T = Syntax({ G }, `G<number>`)
     Assert.IsTrue(TypeGuard.IsTuple(T))
     Assert.IsTrue(TypeGuard.IsNumber(T.items![0]))
-    Assert.IsTrue(TypeGuard.IsNever(T.items![1]))
+    Assert.IsTrue(TypeGuard.IsUnknown(T.items![1]))
   })
 })
diff --git a/test/static/index.ts b/test/static/index.ts
index 40c2067b3..2a27fadee 100644
--- a/test/static/index.ts
+++ b/test/static/index.ts
@@ -48,6 +48,7 @@ import './rest'
 import './return-type'
 import './string'
 import './symbol'
+import './syntax'
 import './template-literal'
 import './transform'
 import './tuple'
diff --git a/test/static/syntax.ts b/test/static/syntax.ts
new file mode 100644
index 000000000..7b0a84601
--- /dev/null
+++ b/test/static/syntax.ts
@@ -0,0 +1,35 @@
+import { Expect } from './assert'
+import { Syntax } from '@sinclair/typebox/syntax'
+
+// prettier-ignore
+{
+  const Basis = Syntax(`{
+    x: 1,
+    y: 2,
+    z: 3  
+  }`)
+
+  Expect(Basis).ToStatic<{
+    x: 1,
+    y: 2,
+    z: 3,
+  }>()
+}
+// prettier-ignore
+{
+  const Vector = Syntax(`<X, Y, Z>{
+    x: X,
+    y: Y,
+    z: Z  
+  }`)
+  const Basis = Syntax({ Vector }, `{
+    x: Vector<1, 0, 0>,
+    y: Vector<0, 1, 0>,
+    z: Vector<0, 0, 1>,
+  }`)
+  Expect(Basis).ToStatic<{
+    x: { x: 1, y: 0, z: 0 },
+    y: { x: 0, y: 1, z: 0 },
+    z: { x: 0, y: 0, z: 1 },
+  }>()
+}

From b2eb0de540f9577e2dd3e4b74faab7f2480cdb61 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 16 Feb 2025 15:42:27 +0900
Subject: [PATCH 343/369] Revision 0.34.25 (#1176)

* Evaluate Object Type in Instantiate + Documentation

* Documentation

* Version

* ChangeLog
---
 changelog/0.34.0.md                 |  2 ++
 package-lock.json                   |  4 ++--
 package.json                        |  2 +-
 readme.md                           | 20 +++++++++++++++++++-
 src/syntax/syntax.ts                | 14 +++++++-------
 src/type/instantiate/instantiate.ts |  9 +++++----
 6 files changed, 36 insertions(+), 15 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 50b6a5ce4..b511b6f2f 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -4,6 +4,8 @@
 
 ### Revision Updates
 
+- [Revision 0.34.25](https://github.com/sinclairzx81/typebox/pull/1176)
+  - Evaluate Conditional Expression for Instatiated Object Types
 - [Revision 0.34.24](https://github.com/sinclairzx81/typebox/pull/1175)
   - Add Support For Generic Parameter Syntax
 - [Revision 0.34.23](https://github.com/sinclairzx81/typebox/pull/1174)
diff --git a/package-lock.json b/package-lock.json
index 5dffd1d6e..f34a66b9e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.24",
+  "version": "0.34.25",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.24",
+      "version": "0.34.25",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 7281eb530..3c6914331 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.24",
+  "version": "0.34.25",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index 5ffedc827..ce855410e 100644
--- a/readme.md
+++ b/readme.md
@@ -100,6 +100,7 @@ License MIT
   - [Parameters](#syntax-parameters)
   - [Generics](#syntax-generics)
   - [Options](#syntax-options)
+  - [NoInfer](#syntax-no-infer)
 - [TypeRegistry](#typeregistry)
   - [Type](#typeregistry-type)
   - [Format](#typeregistry-format)
@@ -1306,7 +1307,7 @@ ValuePointer.Set(A, '/z', 1)                         // A' = { x: 1, y: 1, z: 1
 
 ## Syntax Types
 
-TypeBox includes support for parsing TypeScript annotation syntax into TypeBox schematics.
+TypeBox provides experimental support for parsing TypeScript annotation syntax into TypeBox types.
 
 This feature is provided via optional import.
 
@@ -1391,6 +1392,23 @@ const T = Syntax(`number`, { minimum: 42 })       // const T = {
                                                   // }
 ```
 
+<a name='syntax-no-infer'></a>
+
+### NoInfer
+
+Syntax parsing is an expensive type level operation and can impact on language service performance. Use the NoInfer function parse syntax at runtime only.
+
+```typescript
+import { NoInfer } from '@sinclair/typebox/syntax'
+
+const T = NoInfer(`number | string`)                // const T: TSchema = {
+                                                    //   anyOf: [
+                                                    //     { type: 'number' },
+                                                    //     { type: 'string' }
+                                                    //   ]
+                                                    // }
+```
+
 <a name='typeregistry'></a>
 
 ## TypeRegistry
diff --git a/src/syntax/syntax.ts b/src/syntax/syntax.ts
index 9f6e482ff..3309ff155 100644
--- a/src/syntax/syntax.ts
+++ b/src/syntax/syntax.ts
@@ -52,11 +52,11 @@ function ParseSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extend
 // ------------------------------------------------------------------
 // NoInfer
 // ------------------------------------------------------------------
-/** Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
 export function NoInfer<Context extends Record<PropertyKey, t.TSchema>, Code extends string>(context: Context, code: Code, options?: t.SchemaOptions): t.TSchema
-/** Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
 export function NoInfer<Code extends string>(code: Code, options?: t.SchemaOptions): t.TSchema
-/** Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
 // prettier-ignore
 export function NoInfer(...args: any[]): t.TSchema {
   const withContext = typeof args[0] === 'string' ? false : true
@@ -67,16 +67,16 @@ export function NoInfer(...args: any[]): t.TSchema {
     : t.Never(options)
 }
 
-/** Parses a TypeScript annotation into a TypeBox type */
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
 // prettier-ignore
 export type TSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (
   TParseSyntax<Context, Code> extends [infer Type extends t.TSchema, string] ? Type : t.TNever
 )
-/** Parses a TypeScript annotation into a TypeBox type */
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
 export function Syntax<Context extends Record<PropertyKey, t.TSchema>, Annotation extends string>(context: Context, annotation: Annotation, options?: t.SchemaOptions): TSyntax<Context, Annotation>
-/** Parses a TypeScript annotation into a TypeBox type */
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
 export function Syntax<Annotation extends string>(annotation: Annotation, options?: t.SchemaOptions): TSyntax<{}, Annotation>
-/** Parses a TypeScript annotation into a TypeBox type */
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
 export function Syntax(...args: any[]): never {
   return NoInfer.apply(null, args as never) as never
 }
diff --git a/src/type/instantiate/instantiate.ts b/src/type/instantiate/instantiate.ts
index e4fd67955..3cb2b4857 100644
--- a/src/type/instantiate/instantiate.ts
+++ b/src/type/instantiate/instantiate.ts
@@ -164,12 +164,13 @@ function FromPromise(args: TSchema[], type: TPromise): TPromise {
 // ------------------------------------------------------------------
 // prettier-ignore
 type TFromObject<Args extends TSchema[], Properties extends TProperties,
-  Result extends TProperties = TFromProperties<Args, Properties>
-> = TObject<Result>
+  MappedProperties extends TProperties = TFromProperties<Args, Properties>,
+  Result extends TObject = TObject<MappedProperties>
+> = Result
 // prettier-ignore
 function FromObject(args: TSchema[], type: TObject): TObject {
-  const properties = FromProperties(args, type.properties)
-  return { ...type, ...Object(properties) } // retain options
+  const mappedProperties = FromProperties(args, type.properties)
+  return { ...type, ...Object(mappedProperties) } // retain options
 }
 // ------------------------------------------------------------------
 // Object

From 2f1b54aacdb3dce0c9f663a1e94697045f978a4e Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Wed, 19 Feb 2025 18:47:33 +0900
Subject: [PATCH 344/369] Prototype: FromSchema

---
 example/prototypes/from-schema.ts | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/example/prototypes/from-schema.ts b/example/prototypes/from-schema.ts
index f44c36735..31cc374da 100644
--- a/example/prototypes/from-schema.ts
+++ b/example/prototypes/from-schema.ts
@@ -41,6 +41,7 @@ const IsSTuple = (value: unknown): value is STuple => Type.ValueGuard.IsObject(v
 const IsSArray = (value: unknown): value is SArray => Type.ValueGuard.IsObject(value) && IsExact(value.type, 'array') && !Type.ValueGuard.IsArray(value.items) && Type.ValueGuard.IsObject(value.items)
 const IsSConst = (value: unknown): value is SConst => Type.ValueGuard.IsObject(value) && Type.ValueGuard.IsObject(value['const'])
 const IsSString = (value: unknown): value is SString => Type.ValueGuard.IsObject(value) && IsExact(value.type, 'string')
+const IsSRef = (value: unknown): value is SRef => Type.ValueGuard.IsObject(value) && Type.ValueGuard.IsString(value.$ref)
 const IsSNumber = (value: unknown): value is SNumber => Type.ValueGuard.IsObject(value) && IsExact(value.type, 'number')
 const IsSInteger = (value: unknown): value is SInteger => Type.ValueGuard.IsObject(value) && IsExact(value.type, 'integer')
 const IsSBoolean = (value: unknown): value is SBoolean => Type.ValueGuard.IsObject(value) && IsExact(value.type, 'boolean')
@@ -58,6 +59,7 @@ type SObject = Readonly<{ type: 'object'; properties: SProperties; required?: re
 type STuple = Readonly<{ type: 'array'; items: readonly unknown[] }>
 type SArray = Readonly<{ type: 'array'; items: unknown }>
 type SConst = Readonly<{ const: SValue }>
+type SRef = Readonly<{ $ref: string }>
 type SString = Readonly<{ type: 'string' }>
 type SNumber = Readonly<{ type: 'number' }>
 type SInteger = Readonly<{ type: 'integer' }>
@@ -174,6 +176,16 @@ function FromConst<T extends SConst>(T: T) {
   return Type.Literal(T.const, T)
 }
 // ------------------------------------------------------------------
+// Ref
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRef<T extends SRef> = (
+  Type.Ensure<Type.TRef<T['$ref']>>
+)
+function FromRef<T extends SRef>(T: T) {
+  return Type.Ref(T['$ref'])
+}
+// ------------------------------------------------------------------
 // Object
 // ------------------------------------------------------------------
 type TFromPropertiesIsOptional<K extends PropertyKey, R extends string | unknown> = unknown extends R ? true : K extends R ? false : true
@@ -208,6 +220,7 @@ export type TFromSchema<T> = (
   T extends STuple ? TFromTuple<T> :
   T extends SArray ? TFromArray<T> :
   T extends SConst ? TFromConst<T> :
+  T extends SRef ? TFromRef<T> :
   T extends SString ? Type.TString :
   T extends SNumber ? Type.TNumber :
   T extends SInteger ? Type.TInteger :
@@ -227,6 +240,7 @@ export function FromSchema<T>(T: T): TFromSchema<T> {
     IsSTuple(T) ? FromTuple(T) :
     IsSArray(T) ? FromArray(T) :
     IsSConst(T) ? FromConst(T) :
+    IsSRef(T) ? FromRef(T) :
     IsSString(T) ? Type.String(T) :
     IsSNumber(T) ? Type.Number(T) :
     IsSInteger(T) ? Type.Integer(T) :

From 9cd581a6b1b7245d1741bb4c95b85cadd23443be Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 19 Feb 2025 21:59:47 +0900
Subject: [PATCH 345/369] Revision 0.34.26 (#1181)

* Parse Context Threading

* Version

* ChangeLog
---
 changelog/0.34.0.md          |   2 +
 package-lock.json            |   4 +-
 package.json                 |   2 +-
 src/parser/runtime/guard.ts  |  54 +++++++-----
 src/parser/runtime/module.ts |  19 +++--
 src/parser/runtime/parse.ts  | 132 ++++++++++++++++++----------
 src/parser/runtime/types.ts  | 161 ++++++++++++++++++++++++++---------
 src/parser/static/parse.ts   |  70 +++++++++++----
 src/parser/static/types.ts   |  91 ++++++++++++++------
 src/syntax/runtime.ts        |  22 +++--
 src/syntax/static.ts         |  19 +++--
 src/syntax/syntax.ts         |  24 +-----
 12 files changed, 400 insertions(+), 200 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index b511b6f2f..45a967947 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -4,6 +4,8 @@
 
 ### Revision Updates
 
+- [Revision 0.34.26](https://github.com/sinclairzx81/typebox/pull/1181)
+  - Internal: Use Parser Context Threading for Generic Arguments.
 - [Revision 0.34.25](https://github.com/sinclairzx81/typebox/pull/1176)
   - Evaluate Conditional Expression for Instatiated Object Types
 - [Revision 0.34.24](https://github.com/sinclairzx81/typebox/pull/1175)
diff --git a/package-lock.json b/package-lock.json
index f34a66b9e..502f9362a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.25",
+  "version": "0.34.26",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.25",
+      "version": "0.34.26",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 3c6914331..f443150d6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.25",
+  "version": "0.34.26",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/parser/runtime/guard.ts b/src/parser/runtime/guard.ts
index fa002e473..a340b8e86 100644
--- a/src/parser/runtime/guard.ts
+++ b/src/parser/runtime/guard.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { IIdent, INumber, IRef, IString, IConst, ITuple, IUnion } from './types'
+import { IArray, IConst, IContext, IIdent, INumber, IOptional, IRef, IString, ITuple, IUnion } from './types'
 
 // ------------------------------------------------------------------
 // Value Guard
@@ -46,51 +46,59 @@ function IsArrayValue(value: unknown): value is unknown[] {
 // ------------------------------------------------------------------
 // Parser Guard
 // ------------------------------------------------------------------
-/** Returns true if the value is a Tuple Parser */
-// prettier-ignore
-export function IsTuple(value: unknown): value is ITuple {
-  return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Tuple' && HasPropertyKey(value, 'parsers') && IsArrayValue(value.parsers)
-}
-/** Returns true if the value is a Union Parser */
-// prettier-ignore
-export function IsUnion(value: unknown): value is IUnion {
-  return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Union' && HasPropertyKey(value, 'parsers') && IsArrayValue(value.parsers)
+/** Returns true if the value is a Array Parser */
+export function IsArray(value: unknown): value is IArray {
+  return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Array' && HasPropertyKey(value, 'parser') && IsObjectValue(value.parser)
 }
 /** Returns true if the value is a Const Parser */
-// prettier-ignore
 export function IsConst(value: unknown): value is IConst {
   return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Const' && HasPropertyKey(value, 'value') && typeof value.value === 'string'
 }
+/** Returns true if the value is a Context Parser */
+export function IsContext(value: unknown): value is IContext {
+  return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Context' && HasPropertyKey(value, 'left') && IsParser(value.left) && HasPropertyKey(value, 'right') && IsParser(value.right)
+}
 /** Returns true if the value is a Ident Parser */
-// prettier-ignore
 export function IsIdent(value: unknown): value is IIdent {
   return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Ident'
 }
 /** Returns true if the value is a Number Parser */
-// prettier-ignore
 export function IsNumber(value: unknown): value is INumber {
   return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Number'
 }
+/** Returns true if the value is a Optional Parser */
+export function IsOptional(value: unknown): value is IOptional {
+  return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Optional' && HasPropertyKey(value, 'parser') && IsObjectValue(value.parser)
+}
 /** Returns true if the value is a Ref Parser */
-// prettier-ignore
 export function IsRef(value: unknown): value is IRef {
   return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Ref' && HasPropertyKey(value, 'ref') && typeof value.ref === 'string'
 }
 /** Returns true if the value is a String Parser */
-// prettier-ignore
 export function IsString(value: unknown): value is IString {
   return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'String' && HasPropertyKey(value, 'options') && IsArrayValue(value.options)
 }
+/** Returns true if the value is a Tuple Parser */
+export function IsTuple(value: unknown): value is ITuple {
+  return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Tuple' && HasPropertyKey(value, 'parsers') && IsArrayValue(value.parsers)
+}
+/** Returns true if the value is a Union Parser */
+export function IsUnion(value: unknown): value is IUnion {
+  return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Union' && HasPropertyKey(value, 'parsers') && IsArrayValue(value.parsers)
+}
 /** Returns true if the value is a Parser */
-// prettier-ignore
 export function IsParser(value: unknown) {
+  // prettier-ignore
   return (
-    IsTuple(value) ||
-    IsUnion(value) ||
-    IsConst(value) ||
-    IsIdent(value) ||
-    IsNumber(value) ||
-    IsRef(value) ||
-    IsString(value)
+    IsArray(value) || 
+    IsConst(value) || 
+    IsContext(value) || 
+    IsIdent(value) || 
+    IsNumber(value) || 
+    IsOptional(value) || 
+    IsRef(value) || 
+    IsString(value) || 
+    IsTuple(value) || 
+    IsUnion(value)
   )
 }
diff --git a/src/parser/runtime/module.ts b/src/parser/runtime/module.ts
index 4384ce4f4..b00349b60 100644
--- a/src/parser/runtime/module.ts
+++ b/src/parser/runtime/module.ts
@@ -32,20 +32,21 @@ import { Parse } from './parse'
 // ------------------------------------------------------------------
 // Module
 // ------------------------------------------------------------------
-// prettier-ignore
 export class Module<Properties extends Types.IModuleProperties = Types.IModuleProperties> {
-  constructor(private readonly properties: Properties) { }
-  
+  constructor(private readonly properties: Properties) {}
+
   /** Parses using one of the parsers defined on this instance */
-  public Parse<Key extends keyof Properties>(key: Key, code: string, context: unknown): [] | [Types.StaticParser<Properties[Key]>, string]
+  public Parse<Key extends keyof Properties>(key: Key, content: string, context: unknown): [] | [Types.StaticParser<Properties[Key]>, string]
   /** Parses using one of the parsers defined on this instance */
-  public Parse<Key extends keyof Properties>(key: Key, code: string): [] | [Types.StaticParser<Properties[Key]>, string]
+  public Parse<Key extends keyof Properties>(key: Key, content: string): [] | [Types.StaticParser<Properties[Key]>, string]
   /** Parses using one of the parsers defined on this instance */
   public Parse(...args: any[]): never {
-    const [key, code, context] = 
-      args.length === 3 ? [args[0], args[1], args[2]] :
-      args.length === 2 ? [args[0], args[1], undefined] :
+    // prettier-ignore
+    const [key, content, context] = (
+      args.length === 3 ? [args[0], args[1], args[2]] : 
+      args.length === 2 ? [args[0], args[1], undefined] : 
       (() => { throw Error('Invalid parse arguments') })()
-    return Parse(this.properties[key], this.properties, code, context) as never
+    )
+    return Parse(this.properties, this.properties[key], content, context) as never
   }
 }
diff --git a/src/parser/runtime/parse.ts b/src/parser/runtime/parse.ts
index 73ecf2f75..e810789cd 100644
--- a/src/parser/runtime/parse.ts
+++ b/src/parser/runtime/parse.ts
@@ -31,48 +31,67 @@ import * as Token from './token'
 import * as Types from './types'
 
 // ------------------------------------------------------------------
-// Tuple
+// Context
 // ------------------------------------------------------------------
-// prettier-ignore
-function ParseTuple<Parsers extends Types.IParser[], Properties extends Types.IModuleProperties>(parsers: [...Parsers], properties: Properties, code: string, context: unknown): [] | [unknown[], string] {
+function ParseContext<ModuleProperties extends Types.IModuleProperties, Parser extends Types.IParser>(moduleProperties: ModuleProperties, left: Parser, right: Parser, code: string, context: unknown): unknown[] {
+  const result = ParseParser(moduleProperties, left, code, context)
+  return result.length === 2 ? ParseParser(moduleProperties, right, result[1], result[0]) : []
+}
+
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+function ParseArray<ModuleProperties extends Types.IModuleProperties, Parser extends Types.IParser>(moduleProperties: ModuleProperties, parser: Parser, code: string, context: unknown): unknown[] {
   const buffer = [] as unknown[]
   let rest = code
-  for(const parser of parsers) {
-    const result = ParseParser(parser, properties, rest, context)
-    if(result.length === 0) return []
+  while (rest.length > 0) {
+    const result = ParseParser(moduleProperties, parser, rest, context)
+    if (result.length === 0) return [buffer, rest]
     buffer.push(result[0])
     rest = result[1]
   }
   return [buffer, rest]
 }
+
 // ------------------------------------------------------------------
-// Union
+// Const
 // ------------------------------------------------------------------
-// prettier-ignore
-function ParseUnion<Parsers extends Types.IParser[], Properties extends Types.IModuleProperties>(parsers: [...Parsers], properties: Properties, code: string, context: unknown): [] | [unknown, string] {
-  for(const parser of parsers) {
-    const result = ParseParser(parser, properties, code, context)
-    if(result.length === 0) continue 
-    return result
-  }
-  return []
+function ParseConst<Value extends string>(value: Value, code: string, context: unknown): [] | [Value, string] {
+  return Token.Const(value, code) as never
 }
+
 // ------------------------------------------------------------------
-// Const
+// Ident
+// ------------------------------------------------------------------
+function ParseIdent(code: string, _context: unknown): [] | [string, string] {
+  return Token.Ident(code)
+}
+
+// ------------------------------------------------------------------
+// Number
 // ------------------------------------------------------------------
 // prettier-ignore
-function ParseConst<Value extends string>(value: Value, code: string, context: unknown): [] | [Value, string] {
-  return Token.Const(value, code) as never
+function ParseNumber(code: string, _context: unknown): [] | [string, string] {
+  return Token.Number(code)
 }
+
+// ------------------------------------------------------------------
+// Optional
+// ------------------------------------------------------------------
+function ParseOptional<ModuleProperties extends Types.IModuleProperties, Parser extends Types.IParser>(moduleProperties: ModuleProperties, parser: Parser, code: string, context: unknown): [] | [[unknown] | [], unknown] {
+  const result = ParseParser(moduleProperties, parser, code, context)
+  return (result.length === 2 ? [[result[0]], result[1]] : [[], code]) as never
+}
+
 // ------------------------------------------------------------------
 // Ref
 // ------------------------------------------------------------------
-// prettier-ignore
-function ParseRef<Ref extends string, Properties extends Types.IModuleProperties>(ref: Ref, properties: Properties, code: string, context: unknown): [] | [string, string] {
-  const parser = properties[ref]
-  if(!Guard.IsParser(parser))  throw Error(`Cannot dereference parser '${ref}'`)
-  return ParseParser(parser, properties, code, context) as never
+function ParseRef<ModuleProperties extends Types.IModuleProperties, Ref extends string>(moduleProperties: ModuleProperties, ref: Ref, code: string, context: unknown): [] | [string, string] {
+  const parser = moduleProperties[ref]
+  if (!Guard.IsParser(parser)) throw Error(`Cannot dereference Parser '${ref}'`)
+  return ParseParser(moduleProperties, parser, code, context) as never
 }
+
 // ------------------------------------------------------------------
 // String
 // ------------------------------------------------------------------
@@ -80,33 +99,51 @@ function ParseRef<Ref extends string, Properties extends Types.IModuleProperties
 function ParseString(options: string[], code: string, _context: unknown): [] | [string, string] {
   return Token.String(options, code)
 }
+
 // ------------------------------------------------------------------
-// Number
+// Tuple
 // ------------------------------------------------------------------
-// prettier-ignore
-function ParseNumber(code: string, _context: unknown): [] | [string, string] {
-  return Token.Number(code)
+function ParseTuple<ModuleProperties extends Types.IModuleProperties, Parsers extends Types.IParser[]>(moduleProperties: ModuleProperties, parsers: [...Parsers], code: string, context: unknown): [] | [unknown[], string] {
+  const buffer = [] as unknown[]
+  let rest = code
+  for (const parser of parsers) {
+    const result = ParseParser(moduleProperties, parser, rest, context)
+    if (result.length === 0) return []
+    buffer.push(result[0])
+    rest = result[1]
+  }
+  return [buffer, rest]
 }
+
 // ------------------------------------------------------------------
-// Ident
+// Union
 // ------------------------------------------------------------------
 // prettier-ignore
-function ParseIdent(code: string, _context: unknown): [] | [string, string] {
-  return Token.Ident(code)
+function ParseUnion<ModuleProperties extends Types.IModuleProperties, Parsers extends Types.IParser[]>(moduleProperties: ModuleProperties, parsers: [...Parsers], code: string, context: unknown): [] | [unknown, string] {
+  for(const parser of parsers) {
+    const result = ParseParser(moduleProperties, parser, code, context)
+    if(result.length === 0) continue 
+    return result
+  }
+  return []
 }
+
 // ------------------------------------------------------------------
 // Parser
 // ------------------------------------------------------------------
 // prettier-ignore
-function ParseParser<Parser extends Types.IParser>(parser: Parser, properties: Types.IModuleProperties, code: string, context: unknown): [] | [Types.StaticParser<Parser>, string] {
+function ParseParser<Parser extends Types.IParser>(moduleProperties: Types.IModuleProperties, parser: Parser, code: string, context: unknown): [] | [Types.StaticParser<Parser>, string] {
   const result = (
-    Guard.IsTuple(parser) ? ParseTuple(parser.parsers, properties, code, context) :
-    Guard.IsUnion(parser) ? ParseUnion(parser.parsers, properties, code, context) :
+    Guard.IsContext(parser) ? ParseContext(moduleProperties, parser.left, parser.right, code, context) :
+    Guard.IsArray(parser) ? ParseArray(moduleProperties, parser.parser, code, context) :
     Guard.IsConst(parser) ? ParseConst(parser.value, code, context) :
-    Guard.IsRef(parser) ? ParseRef(parser.ref, properties, code, context) :
-    Guard.IsString(parser) ? ParseString(parser.options, code, context) :
     Guard.IsIdent(parser) ? ParseIdent(code, context) :
     Guard.IsNumber(parser) ? ParseNumber(code, context) :
+    Guard.IsOptional(parser) ? ParseOptional(moduleProperties, parser.parser, code, context) :
+    Guard.IsRef(parser) ? ParseRef(moduleProperties, parser.ref, code, context) :
+    Guard.IsString(parser) ? ParseString(parser.options, code, context) :
+    Guard.IsTuple(parser) ? ParseTuple(moduleProperties, parser.parsers, code, context) :
+    Guard.IsUnion(parser) ? ParseUnion(moduleProperties, parser.parsers, code, context) :
     []
   )
   return (
@@ -115,27 +152,28 @@ function ParseParser<Parser extends Types.IParser>(parser: Parser, properties: T
     : result
   ) as never
 }
+
 // ------------------------------------------------------------------
 // Parse
 // ------------------------------------------------------------------
-/** Parses content using the given parser */
+/** Parses content using the given Parser */
 // prettier-ignore
-export function Parse<Parser extends Types.IParser>(parser: Parser, properties: Types.IModuleProperties, code: string, context: unknown): [] | [Types.StaticParser<Parser>, string]
-/** Parses content using the given parser */
+export function Parse<Parser extends Types.IParser>(moduleProperties: Types.IModuleProperties, parser: Parser, code: string, context: unknown): [] | [Types.StaticParser<Parser>, string]
+/** Parses content using the given Parser */
 // prettier-ignore
-export function Parse<Parser extends Types.IParser>(parser: Parser, properties: Types.IModuleProperties, code: string): [] | [Types.StaticParser<Parser>, string]
-/** Parses content using the given parser */
+export function Parse<Parser extends Types.IParser>(moduleProperties: Types.IModuleProperties, parser: Parser, code: string): [] | [Types.StaticParser<Parser>, string]
+/** Parses content using the given Parser */
 // prettier-ignore
-export function Parse<Parser extends Types.IParser>(parser: Parser, code: string, context: unknown): [] | [Types.StaticParser<Parser>, string]
-/** Parses content using the given parser */
+export function Parse<Parser extends Types.IParser>(parser: Parser, content: string, context: unknown): [] | [Types.StaticParser<Parser>, string]
+/** Parses content using the given Parser */
 // prettier-ignore
-export function Parse<Parser extends Types.IParser>(parser: Parser, code: string): [] | [Types.StaticParser<Parser>, string]
+export function Parse<Parser extends Types.IParser>(parser: Parser, content: string): [] | [Types.StaticParser<Parser>, string]
 /** Parses content using the given parser */
 // prettier-ignore
 export function Parse(...args: any[]): never {
-  const withProperties = typeof args[1] === 'string' ? false : true
-  const [parser, properties, code, context] = withProperties 
+  const withModuleProperties = typeof args[1] === 'string' ? false : true
+  const [moduleProperties, parser, content, context] = withModuleProperties 
     ? [args[0], args[1], args[2], args[3]]
-    : [args[0], {}, args[1], args[2]]
-  return ParseParser(parser, properties, code, context) as never
+    : [{}, args[0], args[1], args[2]]
+  return ParseParser(moduleProperties, parser, content, context) as never
 }
diff --git a/src/parser/runtime/types.ts b/src/parser/runtime/types.ts
index 53dd047d0..c013bf5fa 100644
--- a/src/parser/runtime/types.ts
+++ b/src/parser/runtime/types.ts
@@ -32,6 +32,9 @@ export type IModuleProperties = Record<PropertyKey, IParser>
 // Static
 // ------------------------------------------------------------------
 
+/** Force output static type evaluation for Arrays */
+export type StaticEnsure<T> = T extends infer R ? R : never
+
 /** Infers the Output Parameter for a Parser */
 export type StaticParser<Parser extends IParser> = Parser extends IParser<infer Output extends unknown> ? Output : unknown
 
@@ -44,10 +47,8 @@ export type IMapping<Input extends unknown = any, Output extends unknown = unkno
 export const Identity = (value: unknown) => value
 
 /** Maps the output as the given parameter T */
-export const As =
-  <T>(mapping: T): ((value: unknown) => T) =>
-  (_: unknown) =>
-    mapping
+// prettier-ignore
+export const As = <T>(mapping: T): ((value: unknown) => T) => (_: unknown) => mapping
 
 // ------------------------------------------------------------------
 // Parser
@@ -57,50 +58,59 @@ export interface IParser<Output extends unknown = unknown> {
   mapping: IMapping<any, Output>
 }
 // ------------------------------------------------------------------
-// Tuple
+// Context
 // ------------------------------------------------------------------
-export type TupleParameter<Parsers extends IParser[], Result extends unknown[] = []> = Parsers extends [infer L extends IParser, ...infer R extends IParser[]] ? TupleParameter<R, [...Result, StaticParser<L>]> : Result
-export interface ITuple<Output extends unknown = unknown> extends IParser<Output> {
-  type: 'Tuple'
-  parsers: IParser[]
+// prettier-ignore
+export type ContextParameter<_Left extends IParser, Right extends IParser> = (
+  StaticParser<Right>
+)
+export interface IContext<Output extends unknown = unknown> extends IParser<Output> {
+  type: 'Context'
+  left: IParser
+  right: IParser
 }
-/** Creates a Tuple parser */
-export function Tuple<Parsers extends IParser[], Mapping extends IMapping = IMapping<TupleParameter<Parsers>>>(parsers: [...Parsers], mapping: Mapping): ITuple<ReturnType<Mapping>>
-/** Creates a Tuple parser */
-export function Tuple<Parsers extends IParser[]>(parsers: [...Parsers]): ITuple<TupleParameter<Parsers>>
-export function Tuple(...args: unknown[]): never {
-  const [parsers, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
-  return { type: 'Tuple', parsers, mapping } as never
+/** `[Context]` Creates a Context Parser */
+export function Context<Left extends IParser, Right extends IParser, Mapping extends IMapping = IMapping<ContextParameter<Left, Right>>>(left: Left, right: Right, mapping: Mapping): IContext<ReturnType<Mapping>>
+/** `[Context]` Creates a Context Parser */
+export function Context<Left extends IParser, Right extends IParser>(left: Left, right: Right): IContext<ContextParameter<Left, Right>>
+/** `[Context]` Creates a Context Parser */
+export function Context(...args: unknown[]): never {
+  const [left, right, mapping] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], args[1], Identity]
+  return { type: 'Context', left, right, mapping } as never
 }
-
 // ------------------------------------------------------------------
-// Union
+// Array
 // ------------------------------------------------------------------
-export type UnionParameter<Parsers extends IParser[], Result extends unknown = never> = Parsers extends [infer L extends IParser, ...infer R extends IParser[]] ? UnionParameter<R, Result | StaticParser<L>> : Result
-export interface IUnion<Output extends unknown = unknown> extends IParser<Output> {
-  type: 'Union'
-  parsers: IParser[]
+// prettier-ignore
+export type ArrayParameter<Parser extends IParser> = StaticEnsure<
+  StaticParser<Parser>[]
+>
+export interface IArray<Output extends unknown = unknown> extends IParser<Output> {
+  type: 'Array'
+  parser: IParser
 }
-/** Creates a Union parser */
-export function Union<Parsers extends IParser[], Mapping extends IMapping = IMapping<UnionParameter<Parsers>>>(parsers: [...Parsers], mapping: Mapping): IUnion<ReturnType<Mapping>>
-/** Creates a Union parser */
-export function Union<Parsers extends IParser[]>(parsers: [...Parsers]): IUnion<UnionParameter<Parsers>>
-export function Union(...args: unknown[]): never {
-  const [parsers, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
-  return { type: 'Union', parsers, mapping } as never
+/** `[EBNF]` Creates an Array Parser */
+export function Array<Parser extends IParser, Mapping extends IMapping = IMapping<ArrayParameter<Parser>>>(parser: Parser, mapping: Mapping): IArray<ReturnType<Mapping>>
+/** `[EBNF]` Creates an Array Parser */
+export function Array<Parser extends IParser>(parser: Parser): IArray<ArrayParameter<Parser>>
+/** `[EBNF]` Creates an Array Parser */
+export function Array(...args: unknown[]): never {
+  const [parser, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
+  return { type: 'Array', parser, mapping } as never
 }
 
 // ------------------------------------------------------------------
-// Token
+// Const
 // ------------------------------------------------------------------
 export interface IConst<Output extends unknown = unknown> extends IParser<Output> {
   type: 'Const'
   value: string
 }
-/** Creates a Const parser */
+/** `[TERM]` Creates a Const Parser */
 export function Const<Value extends string, Mapping extends IMapping<Value>>(value: Value, mapping: Mapping): IConst<ReturnType<Mapping>>
-/** Creates a Const parser */
+/** `[TERM]` Creates a Const Parser */
 export function Const<Value extends string>(value: Value): IConst<Value>
+/** `[TERM]` Creates a Const Parser */
 export function Const(...args: unknown[]): never {
   const [value, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
   return { type: 'Const', value, mapping } as never
@@ -113,10 +123,11 @@ export interface IRef<Output extends unknown = unknown> extends IParser<Output>
   type: 'Ref'
   ref: string
 }
-/** Creates a Ref parser */
+/** `[BNF]` Creates a Ref Parser. This Parser can only be used in the context of a Module */
 export function Ref<Type extends unknown, Mapping extends IMapping<Type>>(ref: string, mapping: Mapping): IRef<ReturnType<Mapping>>
-/** Creates a Ref parser */
+/** `[BNF]` Creates a Ref Parser. This Parser can only be used in the context of a Module */
 export function Ref<Type extends unknown>(ref: string): IRef<Type>
+/** `[BNF]` Creates a Ref Parser. This Parser can only be used in the context of a Module */
 export function Ref(...args: unknown[]): never {
   const [ref, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
   return { type: 'Ref', ref, mapping } as never
@@ -129,10 +140,11 @@ export interface IString<Output extends unknown = unknown> extends IParser<Outpu
   type: 'String'
   options: string[]
 }
-/** Creates a String Parser. Options are an array of permissable quote characters */
+/** `[TERM]` Creates a String Parser. Options are an array of permissable quote characters */
 export function String<Mapping extends IMapping<string>>(options: string[], mapping: Mapping): IString<ReturnType<Mapping>>
-/** Creates a String Parser. Options are an array of permissable quote characters */
+/** `[TERM]` Creates a String Parser. Options are an array of permissable quote characters */
 export function String(options: string[]): IString<string>
+/** `[TERM]` Creates a String Parser. Options are an array of permissable quote characters */
 export function String(...params: unknown[]): never {
   const [options, mapping] = params.length === 2 ? [params[0], params[1]] : [params[0], Identity]
   return { type: 'String', options, mapping } as never
@@ -144,10 +156,11 @@ export function String(...params: unknown[]): never {
 export interface IIdent<Output extends unknown = unknown> extends IParser<Output> {
   type: 'Ident'
 }
-/** Creates an Ident parser */
+/** `[TERM]` Creates an Ident Parser where Ident matches any valid JavaScript identifier */
 export function Ident<Mapping extends IMapping<string>>(mapping: Mapping): IIdent<ReturnType<Mapping>>
-/** Creates an Ident parser */
+/** `[TERM]` Creates an Ident Parser where Ident matches any valid JavaScript identifier */
 export function Ident(): IIdent<string>
+/** `[TERM]` Creates an Ident Parser where Ident matches any valid JavaScript identifier */
 export function Ident(...params: unknown[]): never {
   const mapping = params.length === 1 ? params[0] : Identity
   return { type: 'Ident', mapping } as never
@@ -159,11 +172,79 @@ export function Ident(...params: unknown[]): never {
 export interface INumber<Output extends unknown = unknown> extends IParser<Output> {
   type: 'Number'
 }
-/** Creates a Number parser */
+/** `[TERM]` Creates an Number Parser */
 export function Number<Mapping extends IMapping<string>>(mapping: Mapping): INumber<ReturnType<Mapping>>
-/** Creates a Number parser */
+/** `[TERM]` Creates an Number Parser */
 export function Number(): INumber<string>
+/** `[TERM]` Creates an Number Parser */
 export function Number(...params: unknown[]): never {
   const mapping = params.length === 1 ? params[0] : Identity
   return { type: 'Number', mapping } as never
 }
+
+// ------------------------------------------------------------------
+// Optional
+// ------------------------------------------------------------------
+// prettier-ignore
+export type OptionalParameter<Parser extends IParser, Result extends unknown = [StaticParser<Parser>] | []> = (
+  Result
+)
+export interface IOptional<Output extends unknown = unknown> extends IParser<Output> {
+  type: 'Optional'
+  parser: IParser
+}
+/** `[EBNF]` Creates an Optional Parser */
+export function Optional<Parser extends IParser, Mapping extends IMapping = IMapping<OptionalParameter<Parser>>>(parser: Parser, mapping: Mapping): IOptional<ReturnType<Mapping>>
+/** `[EBNF]` Creates an Optional Parser */
+export function Optional<Parser extends IParser>(parser: Parser): IOptional<OptionalParameter<Parser>>
+/** `[EBNF]` Creates an Optional Parser */
+export function Optional(...args: unknown[]): never {
+  const [parser, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
+  return { type: 'Optional', parser, mapping } as never
+}
+
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TupleParameter<Parsers extends IParser[], Result extends unknown[] = []> = StaticEnsure<
+  Parsers extends [infer Left extends IParser, ...infer Right extends IParser[]] 
+    ? TupleParameter<Right, [...Result, StaticEnsure<StaticParser<Left>>]> 
+    : Result
+>
+export interface ITuple<Output extends unknown = unknown> extends IParser<Output> {
+  type: 'Tuple'
+  parsers: IParser[]
+}
+/** `[BNF]` Creates a Tuple Parser */
+export function Tuple<Parsers extends IParser[], Mapping extends IMapping = IMapping<TupleParameter<Parsers>>>(parsers: [...Parsers], mapping: Mapping): ITuple<ReturnType<Mapping>>
+/** `[BNF]` Creates a Tuple Parser */
+export function Tuple<Parsers extends IParser[]>(parsers: [...Parsers]): ITuple<TupleParameter<Parsers>>
+/** `[BNF]` Creates a Tuple Parser */
+export function Tuple(...args: unknown[]): never {
+  const [parsers, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
+  return { type: 'Tuple', parsers, mapping } as never
+}
+
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// prettier-ignore
+export type UnionParameter<Parsers extends IParser[], Result extends unknown = never> = StaticEnsure<
+  Parsers extends [infer Left extends IParser, ...infer Right extends IParser[]] 
+    ? UnionParameter<Right, Result | StaticParser<Left>> 
+    : Result
+>
+export interface IUnion<Output extends unknown = unknown> extends IParser<Output> {
+  type: 'Union'
+  parsers: IParser[]
+}
+/** `[BNF]` Creates a Union parser */
+export function Union<Parsers extends IParser[], Mapping extends IMapping = IMapping<UnionParameter<Parsers>>>(parsers: [...Parsers], mapping: Mapping): IUnion<ReturnType<Mapping>>
+/** `[BNF]` Creates a Union parser */
+export function Union<Parsers extends IParser[]>(parsers: [...Parsers]): IUnion<UnionParameter<Parsers>>
+/** `[BNF]` Creates a Union parser */
+export function Union(...args: unknown[]): never {
+  const [parsers, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity]
+  return { type: 'Union', parsers, mapping } as never
+}
diff --git a/src/parser/static/parse.ts b/src/parser/static/parse.ts
index f4fc12e1e..f19eaad9c 100644
--- a/src/parser/static/parse.ts
+++ b/src/parser/static/parse.ts
@@ -30,27 +30,23 @@ import * as Tokens from './token'
 import * as Types from './types'
 
 // ------------------------------------------------------------------
-// Tuple
+// Context
 // ------------------------------------------------------------------
 // prettier-ignore
-type TupleParser<Parsers extends Types.IParser[], Code extends string, Context extends unknown, Result extends unknown[] = []> = (
-  Parsers extends [infer Left extends Types.IParser, ...infer Right extends Types.IParser[]]
-    ? Parse<Left, Code, Context> extends [infer Value extends unknown, infer Rest extends string]
-      ? TupleParser<Right, Rest, Context, [...Result, Value]>
-      : []
-    : [Result, Code]
+type ContextParser<Left extends Types.IParser, Right extends Types.IParser, Code extends string, Context extends unknown> = (
+  Parse<Left, Code, Context> extends [infer Context extends unknown, infer Rest extends string]
+    ? Parse<Right, Rest, Context>
+    : []
 )
 
 // ------------------------------------------------------------------
-// Union
+// Array
 // ------------------------------------------------------------------
 // prettier-ignore
-type UnionParser<Parsers extends Types.IParser[], Code extends string, Context extends unknown> = (
-  Parsers extends [infer Left extends Types.IParser, ...infer Right extends Types.IParser[]]
-    ? Parse<Left, Code, Context> extends [infer Value extends unknown, infer Rest extends string]
-      ? [Value, Rest]
-      : UnionParser<Right, Code, Context>
-    : []
+type ArrayParser<Parser extends Types.IParser, Code extends string, Context extends unknown, Result extends unknown[] = []> = (
+  Parse<Parser, Code, Context> extends [infer Value1 extends unknown, infer Rest extends string]
+    ? ArrayParser<Parser, Rest, Context, [...Result, Value1]>
+    : [Result, Code]
 )
 
 // ------------------------------------------------------------------
@@ -83,6 +79,16 @@ type NumberParser<Code extends string, _Context extends unknown> = (
     : []
 )
 
+// ------------------------------------------------------------------
+// Optional
+// ------------------------------------------------------------------
+// prettier-ignore
+type OptionalParser<Parser extends Types.IParser, Code extends string, Context extends unknown> = (
+  Parse<Parser, Code, Context> extends [infer Value extends unknown, infer Rest extends string]
+    ? [[Value], Rest]
+    : [[], Code]
+)
+
 // ------------------------------------------------------------------
 // String
 // ------------------------------------------------------------------
@@ -93,23 +99,51 @@ type StringParser<Options extends string[], Code extends string, _Context extend
     : []
 )
 
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+type TupleParser<Parsers extends Types.IParser[], Code extends string, Context extends unknown, Result extends unknown[] = []> = (
+  Parsers extends [infer Left extends Types.IParser, ...infer Right extends Types.IParser[]]
+    ? Parse<Left, Code, Context> extends [infer Value extends unknown, infer Rest extends string]
+      ? TupleParser<Right, Rest, Context, [...Result, Value]>
+      : []
+    : [Result, Code]
+)
+
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// prettier-ignore
+type UnionParser<Parsers extends Types.IParser[], Code extends string, Context extends unknown> = (
+  Parsers extends [infer Left extends Types.IParser, ...infer Right extends Types.IParser[]]
+    ? Parse<Left, Code, Context> extends [infer Value extends unknown, infer Rest extends string]
+      ? [Value, Rest]
+      : UnionParser<Right, Code, Context>
+    : []
+)
+
 // ------------------------------------------------------------------
 // Parse
 // ------------------------------------------------------------------
 // prettier-ignore
 type ParseCode<Type extends Types.IParser, Code extends string, Context extends unknown = unknown> = (
-  Type extends Types.Union<infer S extends Types.IParser[]> ? UnionParser<S, Code, Context> :
-  Type extends Types.Tuple<infer S extends Types.IParser[]> ? TupleParser<S, Code, Context> :
-  Type extends Types.Const<infer S extends string> ? ConstParser<S, Code, Context> :
-  Type extends Types.String<infer S extends string[]> ? StringParser<S, Code, Context> :
+  Type extends Types.Context<infer Left extends Types.IParser, infer Right extends Types.IParser> ? ContextParser<Left, Right, Code, Context> :
+  Type extends Types.Array<infer Parser extends Types.IParser> ? ArrayParser<Parser, Code, Context> :
+  Type extends Types.Const<infer Value extends string> ? ConstParser<Value, Code, Context> :
   Type extends Types.Ident ? IdentParser<Code, Context> :
   Type extends Types.Number ? NumberParser<Code, Context> :
+  Type extends Types.Optional<infer Parser extends Types.IParser> ? OptionalParser<Parser, Code, Context> :
+  Type extends Types.String<infer Options extends string[]> ? StringParser<Options, Code, Context> :
+  Type extends Types.Tuple<infer Parsers extends Types.IParser[]> ? TupleParser<Parsers, Code, Context> :
+  Type extends Types.Union<infer Parsers extends Types.IParser[]> ? UnionParser<Parsers, Code, Context> :
   []
 )
 // prettier-ignore
 type ParseMapping<Parser extends Types.IParser, Result extends unknown, Context extends unknown = unknown> = (
   (Parser['mapping'] & { input: Result, context: Context })['output']
 )
+
 /** Parses code with the given parser */
 // prettier-ignore
 export type Parse<Type extends Types.IParser, Code extends string, Context extends unknown = unknown> = (
diff --git a/src/parser/static/types.ts b/src/parser/static/types.ts
index 534125505..5adbc306c 100644
--- a/src/parser/static/types.ts
+++ b/src/parser/static/types.ts
@@ -1,6 +1,6 @@
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox/parse
+@sinclair/parsebox
 
 The MIT License (MIT)
 
@@ -29,16 +29,25 @@ THE SOFTWARE.
 // ------------------------------------------------------------------
 // Mapping
 // ------------------------------------------------------------------
+/**
+ * `[ACTION]` Inference mapping base type. Used to specify semantic actions for
+ * Parser productions. This type is implemented as a higher-kinded type where
+ * productions are received on the `input` property with mapping assigned
+ * the `output` property. The parsing context is available on the `context`
+ * property.
+ */
 export interface IMapping {
   context: unknown
   input: unknown
   output: unknown
 }
-/** Maps input to output. This is the default Mapping */
+
+/** `[ACTION]` Default inference mapping. */
 export interface Identity extends IMapping {
   output: this['input']
 }
-/** Maps the output as the given parameter T */
+
+/** `[ACTION]` Maps the given argument `T` as the mapping output */
 export interface As<T> extends IMapping {
   output: T
 }
@@ -50,51 +59,85 @@ export interface IParser<Mapping extends IMapping = Identity> {
   type: string
   mapping: Mapping
 }
+
 // ------------------------------------------------------------------
-// Tuple
+// Context
 // ------------------------------------------------------------------
-/** Creates a Tuple Parser */
-export interface Tuple<Parsers extends IParser[] = [], Mapping extends IMapping = Identity> extends IParser<Mapping> {
-  type: 'Tuple'
-  parsers: [...Parsers]
+/** `[Context]` Creates a Context Parser */
+export interface Context<Left extends IParser = IParser, Right extends IParser = IParser, Mapping extends IMapping = Identity> extends IParser<Mapping> {
+  type: 'Context'
+  left: Left
+  right: Right
 }
+
 // ------------------------------------------------------------------
-// Union
+// Array
 // ------------------------------------------------------------------
-/** Creates a Union Parser */
-export interface Union<Parsers extends IParser[] = [], Mapping extends IMapping = Identity> extends IParser<Mapping> {
-  type: 'Union'
-  parsers: [...Parsers]
+/** `[EBNF]` Creates an Array Parser */
+export interface Array<Parser extends IParser = IParser, Mapping extends IMapping = Identity> extends IParser<Mapping> {
+  type: 'Array'
+  parser: Parser
 }
+
 // ------------------------------------------------------------------
 // Const
 // ------------------------------------------------------------------
-/** Creates a Const Parser */
+/** `[TERM]` Creates a Const Parser */
 export interface Const<Value extends string = string, Mapping extends IMapping = Identity> extends IParser<Mapping> {
   type: 'Const'
   value: Value
 }
-// ------------------------------------------------------------------
-// String
-// ------------------------------------------------------------------
-/** Creates a String Parser. Options are an array of permissable quote characters */
-export interface String<Options extends string[], Mapping extends IMapping = Identity> extends IParser<Mapping> {
-  type: 'String'
-  quote: Options
-}
+
 // ------------------------------------------------------------------
 // Ident
 // ------------------------------------------------------------------
-/** Creates an Ident Parser. */
+/** `[TERM]` Creates an Ident Parser. */
 // prettier-ignore
 export interface Ident<Mapping extends IMapping = Identity> extends IParser<Mapping> {
   type: 'Ident'
 }
+
 // ------------------------------------------------------------------
 // Number
 // ------------------------------------------------------------------
-/** Creates a Number Parser. */
+/** `[TERM]` Creates a Number Parser. */
 // prettier-ignore
 export interface Number<Mapping extends IMapping = Identity> extends IParser<Mapping> {
   type: 'Number'
 }
+
+// ------------------------------------------------------------------
+// Optional
+// ------------------------------------------------------------------
+/** `[EBNF]` Creates a Optional Parser */
+export interface Optional<Parser extends IParser = IParser, Mapping extends IMapping = Identity> extends IParser<Mapping> {
+  type: 'Optional'
+  parser: Parser
+}
+
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+/** `[TERM]` Creates a String Parser. Options are an array of permissable quote characters */
+export interface String<Options extends string[], Mapping extends IMapping = Identity> extends IParser<Mapping> {
+  type: 'String'
+  quote: Options
+}
+
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+/** `[BNF]` Creates a Tuple Parser */
+export interface Tuple<Parsers extends IParser[] = [], Mapping extends IMapping = Identity> extends IParser<Mapping> {
+  type: 'Tuple'
+  parsers: [...Parsers]
+}
+
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+/** `[BNF]` Creates a Union Parser */
+export interface Union<Parsers extends IParser[] = [], Mapping extends IMapping = Identity> extends IParser<Mapping> {
+  type: 'Union'
+  parsers: [...Parsers]
+}
diff --git a/src/syntax/runtime.ts b/src/syntax/runtime.ts
index f13a09aea..428ae8e7a 100644
--- a/src/syntax/runtime.ts
+++ b/src/syntax/runtime.ts
@@ -88,15 +88,15 @@ const GenericArgumentList = Runtime.Union([
 // GenericArguments
 // ------------------------------------------------------------------
 // prettier-ignore
-const GenericArgumentsContext = (args: string[]) => {
+const GenericArgumentsContext = (args: string[], context: t.TProperties) => {
   return args.reduce((result, arg, index) => {
     return { ...result, [arg]: t.Argument(index) }
-  }, {})
+  }, context)
 }
 // prettier-ignore
-const GenericArgumentsMapping = (results: unknown[]) => {
+const GenericArgumentsMapping = (results: unknown[], context: t.TProperties) => {
   return results.length === 3
-    ? GenericArgumentsContext(results[1] as string[])
+    ? GenericArgumentsContext(results[1] as string[], context)
     : {}
 }
 // prettier-ignore
@@ -104,7 +104,7 @@ const GenericArguments = Runtime.Tuple([
   Runtime.Const(LAngle),
   Runtime.Ref('GenericArgumentList'),
   Runtime.Const(RAngle),
-], results => GenericArgumentsMapping(results))
+], (results, context) => GenericArgumentsMapping(results, context))
 // ------------------------------------------------------------------
 // GenericReference
 // ------------------------------------------------------------------
@@ -326,7 +326,11 @@ const Expr = Runtime.Tuple([
 // ------------------------------------------------------------------
 // Type
 // ------------------------------------------------------------------
-const Type = Runtime.Ref('Expr')
+// prettier-ignore
+const Type = Runtime.Union([
+  Runtime.Context(Runtime.Ref('GenericArguments'), Runtime.Ref('Expr')), 
+  Runtime.Ref('Expr')
+])
 // ------------------------------------------------------------------
 // Properties
 // ------------------------------------------------------------------
@@ -704,12 +708,12 @@ const Uint8Array = Runtime.Const('Uint8Array', Runtime.As(t.Uint8Array()))
 // prettier-ignore
 export const Module = new Runtime.Module({
   // ----------------------------------------------------------------
-  // Generic Arguments
+  // Generics
   // ----------------------------------------------------------------
   GenericArgumentList,
   GenericArguments,
   // ----------------------------------------------------------------
-  // Type Expressions
+  // Type
   // ----------------------------------------------------------------
   Literal,
   Keyword,
@@ -722,7 +726,7 @@ export const Module = new Runtime.Module({
   ExprTerm,
   ExprTail,
   Expr,
-  Type, // Alias for Expr
+  Type,
   PropertyKey,
   Readonly,
   Optional,
diff --git a/src/syntax/static.ts b/src/syntax/static.ts
index 0d06c5bff..1e9712f52 100644
--- a/src/syntax/static.ts
+++ b/src/syntax/static.ts
@@ -165,23 +165,26 @@ type GenericArgumentList = Static.Union<[
 // GenericArguments
 // ------------------------------------------------------------------
 // prettier-ignore
-type GenericArgumentsContext<Args extends string[], Result extends t.TProperties = {}> = (
+type GenericArgumentsContext<Args extends string[], Context extends t.TProperties, Result extends t.TProperties = {}> = (
   Args extends [...infer Left extends string[], infer Right extends string]
-    ? GenericArgumentsContext<Left, Result & { [_ in Right]: t.TArgument<Left['length']> }>
-    : t.Evaluate<Result>
+    ? GenericArgumentsContext<Left, Context, Result & { [_ in Right]: t.TArgument<Left['length']> }>
+    : t.Evaluate<Result & Context>
 )
 // prettier-ignore
 interface GenericArgumentsMapping extends Static.IMapping {
   output: this['input'] extends [LAngle, infer Args extends string[], RAngle]
-    ? GenericArgumentsContext<Args>
+    ? this['context'] extends infer Context extends t.TProperties
+        ? GenericArgumentsContext<Args, Context>
+        : never
     : never
 }
 // prettier-ignore
-export type GenericArguments = Static.Tuple<[
+type GenericArguments = Static.Tuple<[
   Static.Const<LAngle>,
   GenericArgumentList,
   Static.Const<RAngle>,
 ], GenericArgumentsMapping>
+
 // ------------------------------------------------------------------
 // GenericReference
 // ------------------------------------------------------------------
@@ -426,7 +429,11 @@ type Expr = Static.Tuple<[
 // ------------------------------------------------------------------
 // Type
 // ------------------------------------------------------------------
-export type Type = Expr
+// prettier-ignore
+export type Type = Static.Union<[
+  Static.Context<GenericArguments, Expr>, 
+  Expr
+]>
 // ------------------------------------------------------------------
 // Properties
 // ------------------------------------------------------------------
diff --git a/src/syntax/syntax.ts b/src/syntax/syntax.ts
index 3309ff155..e467cd2ef 100644
--- a/src/syntax/syntax.ts
+++ b/src/syntax/syntax.ts
@@ -29,26 +29,8 @@ THE SOFTWARE.
 import * as t from '../type/index'
 import { Static } from '../parser/index'
 import { Module } from './runtime'
-import { Type, GenericArguments } from './static'
+import { Type } from './static'
 
-// ------------------------------------------------------------------
-// ParseSyntax: Two-Phase Parse
-// ------------------------------------------------------------------
-// prettier-ignore
-type TParseSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (
-  Static.Parse<GenericArguments, Code, {}> extends [infer Args extends t.TProperties, infer Rest extends string]
-    ? Static.Parse<Type, Rest, Context & Args>
-    : Static.Parse<Type, Code, Context>
-)
-// prettier-ignore
-function ParseSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string>(context: Context, code: Code): [] | [t.TSchema, string] {
-  const results = Module.Parse('GenericArguments', code, {}) // [ArgumentContext, Rest]
-  return (
-    results.length === 2
-      ? Module.Parse('Type', results[1], { ...context, ...results[0] })
-      : Module.Parse('Type', code, context)
-  ) as never
-}
 // ------------------------------------------------------------------
 // NoInfer
 // ------------------------------------------------------------------
@@ -61,7 +43,7 @@ export function NoInfer<Code extends string>(code: Code, options?: t.SchemaOptio
 export function NoInfer(...args: any[]): t.TSchema {
   const withContext = typeof args[0] === 'string' ? false : true
   const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}]
-  const result = ParseSyntax(context, code)[0]
+  const result = Module.Parse('Type', code, context)[0]
   return t.KindGuard.IsSchema(result) 
     ? t.CloneType(result, options) 
     : t.Never(options)
@@ -70,7 +52,7 @@ export function NoInfer(...args: any[]): t.TSchema {
 /** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
 // prettier-ignore
 export type TSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (
-  TParseSyntax<Context, Code> extends [infer Type extends t.TSchema, string] ? Type : t.TNever
+  Static.Parse<Type, Code, Context> extends [infer Type extends t.TSchema, string] ? Type : t.TNever
 )
 /** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
 export function Syntax<Context extends Record<PropertyKey, t.TSchema>, Annotation extends string>(context: Context, annotation: Annotation, options?: t.SchemaOptions): TSyntax<Context, Annotation>

From 5130ee57a721d58a43dfa180f8603a4530231302 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Thu, 20 Feb 2025 16:24:01 +0900
Subject: [PATCH 346/369] Revision 0.34.27 (#1182)

* Support Deep Referential Transform Inference Inside Modules

* Version

* ChangeLog
---
 changelog/0.34.0.md                    |   3 +-
 package-lock.json                      |   4 +-
 package.json                           |   2 +-
 src/type/module/compute.ts             | 208 +++++++++++++++----------
 src/type/static/static.ts              |  88 +++++++----
 src/value/transform/decode.ts          |   9 +-
 src/value/transform/encode.ts          |   8 +-
 src/value/transform/has.ts             |   9 ++
 test/runtime/value/transform/import.ts |  68 +++++++-
 test/static/transform.ts               |  54 +++++++
 10 files changed, 323 insertions(+), 130 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 45a967947..c0c59d339 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -3,7 +3,8 @@
 ---
 
 ### Revision Updates
-
+- [Revision 0.34.27](https://github.com/sinclairzx81/typebox/pull/1182)
+  - [1178](https://github.com/sinclairzx81/typebox/issues/1178) Support Deep Referential Transform Inference Inside Modules
 - [Revision 0.34.26](https://github.com/sinclairzx81/typebox/pull/1181)
   - Internal: Use Parser Context Threading for Generic Arguments.
 - [Revision 0.34.25](https://github.com/sinclairzx81/typebox/pull/1176)
diff --git a/package-lock.json b/package-lock.json
index 502f9362a..ac510958e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.26",
+  "version": "0.34.27",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.26",
+      "version": "0.34.27",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index f443150d6..e59f3ed4a 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.26",
+  "version": "0.34.27",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/module/compute.ts b/src/type/module/compute.ts
index abd138af9..286665597 100644
--- a/src/type/module/compute.ts
+++ b/src/type/module/compute.ts
@@ -51,18 +51,24 @@ import { Partial, TPartial } from '../partial/index'
 import { type TReadonly } from '../readonly/index'
 import { RecordValue, RecordPattern, type TRecordOrObject, type TRecord } from '../record/index'
 import { type TRef } from '../ref/index'
-import { Required, TRequired } from '../required/index'
+import { Required, type TRequired } from '../required/index'
+import { type TTransform } from '../transform/index'
 import { Tuple, type TTuple } from '../tuple/index'
 import { Union, type TUnion, type TUnionEvaluated } from '../union/index'
 
-import { OptionalKind, ReadonlyKind } from '../symbols/index'
+// ------------------------------------------------------------------
+// Symbols
+// ------------------------------------------------------------------
+import { TransformKind, OptionalKind, ReadonlyKind } from '../symbols/index'
+
 // ------------------------------------------------------------------
 // KindGuard
 // ------------------------------------------------------------------
 import * as KindGuard from '../guard/kind'
 
 // ------------------------------------------------------------------
-// DerefParameters
+//
+// DereferenceParameters
 //
 // Dereferences TComputed parameters. It is important to note that
 // dereferencing anything other than these parameters may result
@@ -71,39 +77,47 @@ import * as KindGuard from '../guard/kind'
 //
 // ------------------------------------------------------------------
 // prettier-ignore
-type TDerefParameters<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (
+type TDereferenceParameters<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (
   Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
     ? Left extends TRef<infer Key extends string>
-      ? TDerefParameters<ModuleProperties, Right, [...Result, TDeref<ModuleProperties, Key>]>
-      : TDerefParameters<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]>
+      ? TDereferenceParameters<ModuleProperties, Right, [...Result, TDereference<ModuleProperties, Key>]>
+      : TDereferenceParameters<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]>
     : Result
 )
 // prettier-ignore
-function DerefParameters<ModuleProperties extends TProperties, Types extends TSchema[]>(moduleProperties: ModuleProperties, types: [...Types]): TFromRest<ModuleProperties, Types> {
+function DereferenceParameters<ModuleProperties extends TProperties, Types extends TSchema[]>(moduleProperties: ModuleProperties, types: [...Types]): TSchema[] {
   return types.map((type) => {
     return KindGuard.IsRef(type)
-      ? Deref(moduleProperties, type.$ref)
+      ? Dereference(moduleProperties, type.$ref)
       : FromType(moduleProperties, type)
   }) as never
 }
 // prettier-ignore
-type TDeref<ModuleProperties extends TProperties, Ref extends string, Result extends TSchema = (
+type TDereference<ModuleProperties extends TProperties, Ref extends string, Result extends TSchema = (
   Ref extends keyof ModuleProperties
     ? ModuleProperties[Ref] extends TRef<infer Ref2 extends string> 
-      ? TDeref<ModuleProperties, Ref2>
+      ? TDereference<ModuleProperties, Ref2>
       : TFromType<ModuleProperties, ModuleProperties[Ref]>
     : TNever
 )> = Result
 // prettier-ignore
-function Deref<ModuleProperties extends TProperties, Ref extends string>(moduleProperties: ModuleProperties, ref: Ref): TDeref<ModuleProperties, Ref> {
+function Dereference<ModuleProperties extends TProperties, Ref extends string>(moduleProperties: ModuleProperties, ref: Ref): TSchema {
   return (
     ref in moduleProperties 
       ? KindGuard.IsRef(moduleProperties[ref])
-        ? Deref(moduleProperties, moduleProperties[ref].$ref)
+        ? Dereference(moduleProperties, moduleProperties[ref].$ref)
         : FromType(moduleProperties, moduleProperties[ref])
       : Never()
   ) as never
 }
+
+// ------------------------------------------------------------------
+//
+// TComputed
+//
+// The following types support deferred evaluation
+//
+// ------------------------------------------------------------------
 // ------------------------------------------------------------------
 // Awaited
 // ------------------------------------------------------------------
@@ -193,7 +207,7 @@ function FromRequired<Parameters extends TSchema[]>(parameters: Parameters): TFr
 // ------------------------------------------------------------------
 // prettier-ignore
 type TFromComputed<ModuleProperties extends TProperties, Target extends string, Parameters extends TSchema[],
-  Dereferenced extends TSchema[] = TDerefParameters<ModuleProperties, Parameters>
+  Dereferenced extends TSchema[] = TDereferenceParameters<ModuleProperties, Parameters>
 > = (
   Target extends 'Awaited' ? TFromAwaited<Dereferenced> :
   Target extends 'Index' ? TFromIndex<Dereferenced> :
@@ -206,7 +220,7 @@ type TFromComputed<ModuleProperties extends TProperties, Target extends string,
 )
 // prettier-ignore
 function FromComputed<ModuleProperties extends TProperties, Target extends string, Parameters extends TSchema[]>(moduleProperties: ModuleProperties, target: Target, parameters: Parameters): TFromComputed<ModuleProperties, Target, Parameters> {
-  const dereferenced = DerefParameters(moduleProperties, parameters)
+  const dereferenced = DereferenceParameters(moduleProperties, parameters)
   return (
     target === 'Awaited' ? FromAwaited(dereferenced) :
     target === 'Index' ? FromIndex(dereferenced) :
@@ -218,45 +232,41 @@ function FromComputed<ModuleProperties extends TProperties, Target extends strin
     Never()
   ) as never
 }
+
 // ------------------------------------------------------------------
-// Object
+//
+// Standard Types
+//
+// The following are the standard mappable types and structures
+//
+// ------------------------------------------------------------------
+
+// ------------------------------------------------------------------
+// Array
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromObject<ModuleProperties extends TProperties, Properties extends TProperties> = Ensure<TObject<Evaluate<{ 
-  [Key in keyof Properties]: TFromType<ModuleProperties, Properties[Key]>
-}>>>
-function FromObject<ModuleProperties extends TProperties, Properties extends TProperties>(moduleProperties: ModuleProperties, properties: Properties): TFromObject<ModuleProperties, Properties> {
-  return Object(
-    globalThis.Object.keys(properties).reduce((result, key) => {
-      return { ...result, [key]: FromType(moduleProperties, properties[key]) as never }
-    }, {} as TProperties),
-  ) as never
+type TFromArray<ModuleProperties extends TProperties, Type extends TSchema> = (
+  Ensure<TArray<TFromType<ModuleProperties, Type>>>
+)
+function FromArray<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromArray<ModuleProperties, Type> {
+  return Array(FromType(moduleProperties, type))
 }
 // ------------------------------------------------------------------
-// Record
-//
-// Note: Varying Runtime and Static path here as we need to retain
-// constraints on the Record. This requires remapping the entire
-// Record in the Runtime path but where the Static path is merely
-// a facade for the patternProperties regular expression.
+// AsyncIterator
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromRecord<ModuleProperties extends TProperties, Key extends TSchema, Value extends TSchema,
-  Result extends TSchema = TRecordOrObject<Key, TFromType<ModuleProperties, Value>> 
-> = Result
-// prettier-ignore
-function FromRecord<ModuleProperties extends TProperties, Type extends TRecord>(moduleProperties: ModuleProperties, type: Type): never {
-  const [value, pattern] = [FromType(moduleProperties, RecordValue(type)), RecordPattern(type)]
-  const result = CloneType(type)
-  result.patternProperties[pattern] = value
-  return result as never
+type TFromAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema> = (
+  TAsyncIterator<TFromType<ModuleProperties, Type>>
+)
+function FromAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromAsyncIterator<ModuleProperties, Type> {
+  return AsyncIterator(FromType(moduleProperties, type))
 }
 // ------------------------------------------------------------------
 // Constructor
 // ------------------------------------------------------------------
 // prettier-ignore
 type TFromConstructor<ModuleProperties extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema> = (
-  TConstructor<TFromRest<ModuleProperties, Parameters>, TFromType<ModuleProperties, InstanceType>>
+  TConstructor<TFromTypes<ModuleProperties, Parameters>, TFromType<ModuleProperties, InstanceType>>
 )
 // prettier-ignore
 function FromConstructor<ModuleProperties extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema>(
@@ -264,14 +274,14 @@ function FromConstructor<ModuleProperties extends TProperties, Parameters extend
   parameters: [...Parameters],
   instanceType: InstanceType,
 ): TFromConstructor<ModuleProperties, Parameters, InstanceType> {
-  return Constructor(FromRest(moduleProperties, parameters as never), FromType(moduleProperties, instanceType) as never) as never
+  return Constructor(FromTypes(moduleProperties, parameters as never), FromType(moduleProperties, instanceType) as never) as never
 }
 // ------------------------------------------------------------------
 // Function
 // ------------------------------------------------------------------
 // prettier-ignore
 type TFromFunction<ModuleProperties extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema> = Ensure<
-  Ensure<TFunction<TFromRest<ModuleProperties, Parameters>, TFromType<ModuleProperties, ReturnType>>>
+  Ensure<TFunction<TFromTypes<ModuleProperties, Parameters>, TFromType<ModuleProperties, ReturnType>>>
 >
 // prettier-ignore
 function FromFunction<ModuleProperties extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema>(
@@ -279,78 +289,106 @@ function FromFunction<ModuleProperties extends TProperties, Parameters extends T
   parameters: [...Parameters],
   returnType: ReturnType,
 ): TFromFunction<ModuleProperties, Parameters, ReturnType> {
-  return FunctionType(FromRest(moduleProperties, parameters as never), FromType(moduleProperties, returnType) as never) as never
+  return FunctionType(FromTypes(moduleProperties, parameters as never), FromType(moduleProperties, returnType) as never) as never
 }
 // ------------------------------------------------------------------
-// Tuple
+// Intersect
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromTuple<ModuleProperties extends TProperties, Types extends TSchema[]> = (
-  Ensure<TTuple<TFromRest<ModuleProperties, Types>>>
+type TFromIntersect<ModuleProperties extends TProperties, Types extends TSchema[]> = (
+  Ensure<TIntersectEvaluated<TFromTypes<ModuleProperties, Types>>>
 )
-function FromTuple<ModuleProperties extends TProperties, Types extends TSchema[]>(moduleProperties: ModuleProperties, types: [...Types]): TFromTuple<ModuleProperties, Types> {
-  return Tuple(FromRest(moduleProperties, types as never)) as never
+function FromIntersect<ModuleProperties extends TProperties, Types extends TSchema[]>(moduleProperties: ModuleProperties, types: [...Types]): TFromIntersect<ModuleProperties, Types> {
+  return Intersect(FromTypes(moduleProperties, types as never)) as never
 }
 // ------------------------------------------------------------------
-// Intersect
+// Iterator
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromIntersect<ModuleProperties extends TProperties, Types extends TSchema[]> = (
-  Ensure<TIntersectEvaluated<TFromRest<ModuleProperties, Types>>>
+type TFromIterator<ModuleProperties extends TProperties, Type extends TSchema> = (
+  TIterator<TFromType<ModuleProperties, Type>>
 )
-function FromIntersect<ModuleProperties extends TProperties, Types extends TSchema[]>(moduleProperties: ModuleProperties, types: [...Types]): TFromIntersect<ModuleProperties, Types> {
-  return Intersect(FromRest(moduleProperties, types as never)) as never
+function FromIterator<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromIterator<ModuleProperties, Type> {
+  return Iterator(FromType(moduleProperties, type))
 }
 // ------------------------------------------------------------------
-// Union
+// Object
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromUnion<ModuleProperties extends TProperties, Types extends TSchema[]> = (
-  Ensure<TUnionEvaluated<TFromRest<ModuleProperties, Types>>>
-)
-function FromUnion<ModuleProperties extends TProperties, Types extends TSchema[]>(moduleProperties: ModuleProperties, types: [...Types]): TFromUnion<ModuleProperties, Types> {
-  return Union(FromRest(moduleProperties, types as never)) as never
+type TFromObject<ModuleProperties extends TProperties, Properties extends TProperties> = Ensure<TObject<Evaluate<{ 
+  [Key in keyof Properties]: TFromType<ModuleProperties, Properties[Key]>
+}>>>
+function FromObject<ModuleProperties extends TProperties, Properties extends TProperties>(moduleProperties: ModuleProperties, properties: Properties): TFromObject<ModuleProperties, Properties> {
+  return Object(
+    globalThis.Object.keys(properties).reduce((result, key) => {
+      return { ...result, [key]: FromType(moduleProperties, properties[key]) as never }
+    }, {} as TProperties),
+  ) as never
 }
 // ------------------------------------------------------------------
-// Array
+// Record
+//
+// Note: Varying Runtime and Static path here as we need to retain
+// constraints on the Record. This requires remapping the entire
+// Record in the Runtime path but where the Static path is merely
+// a facade for the patternProperties regular expression.
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromArray<ModuleProperties extends TProperties, Type extends TSchema> = (
-  Ensure<TArray<TFromType<ModuleProperties, Type>>>
-)
-function FromArray<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromArray<ModuleProperties, Type> {
-  return Array(FromType(moduleProperties, type))
+type TFromRecord<ModuleProperties extends TProperties, Key extends TSchema, Value extends TSchema,
+  Result extends TSchema = TRecordOrObject<Key, TFromType<ModuleProperties, Value>> 
+> = Result
+// prettier-ignore
+function FromRecord<ModuleProperties extends TProperties, Type extends TRecord>(moduleProperties: ModuleProperties, type: Type): never {
+  const [value, pattern] = [FromType(moduleProperties, RecordValue(type)), RecordPattern(type)]
+  const result = CloneType(type)
+  result.patternProperties[pattern] = value
+  return result as never
 }
 // ------------------------------------------------------------------
-// AsyncIterator
+// Transform
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema> = (
-  TAsyncIterator<TFromType<ModuleProperties, Type>>
+type TFromTransform<ModuleProperties extends TProperties, Input extends TSchema, Output extends unknown,
+  Result extends TSchema = Input extends TRef<infer Key extends string> 
+    ? TTransform<TDereference<ModuleProperties, Key>, Output>
+    : TTransform<Input, Output> 
+> = Result
+// prettier-ignore
+function FromTransform<ModuleProperties extends TProperties, Transform extends TTransform>(moduleProperties: ModuleProperties, transform: Transform): TSchema {
+  return (KindGuard.IsRef(transform))
+    ? { ...Dereference(moduleProperties, transform.$ref), [TransformKind]: transform[TransformKind] }
+    : transform
+}
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromTuple<ModuleProperties extends TProperties, Types extends TSchema[]> = (
+  Ensure<TTuple<TFromTypes<ModuleProperties, Types>>>
 )
-function FromAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromAsyncIterator<ModuleProperties, Type> {
-  return AsyncIterator(FromType(moduleProperties, type))
+function FromTuple<ModuleProperties extends TProperties, Types extends TSchema[]>(moduleProperties: ModuleProperties, types: [...Types]): TFromTuple<ModuleProperties, Types> {
+  return Tuple(FromTypes(moduleProperties, types as never)) as never
 }
 // ------------------------------------------------------------------
-// Iterator
+// Union
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromIterator<ModuleProperties extends TProperties, Type extends TSchema> = (
-  TIterator<TFromType<ModuleProperties, Type>>
+type TFromUnion<ModuleProperties extends TProperties, Types extends TSchema[]> = (
+  Ensure<TUnionEvaluated<TFromTypes<ModuleProperties, Types>>>
 )
-function FromIterator<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromIterator<ModuleProperties, Type> {
-  return Iterator(FromType(moduleProperties, type))
+function FromUnion<ModuleProperties extends TProperties, Types extends TSchema[]>(moduleProperties: ModuleProperties, types: [...Types]): TFromUnion<ModuleProperties, Types> {
+  return Union(FromTypes(moduleProperties, types as never)) as never
 }
 // ------------------------------------------------------------------
-// Rest
+// Types
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromRest<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (
+type TFromTypes<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (
   Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
-    ? TFromRest<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]>
+    ? TFromTypes<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]>
     : Result
 )
-function FromRest<ModuleProperties extends TProperties, Types extends TSchema[]>(moduleProperties: ModuleProperties, types: [...Types]): TFromRest<ModuleProperties, Types> {
+function FromTypes<ModuleProperties extends TProperties, Types extends TSchema[]>(moduleProperties: ModuleProperties, types: [...Types]): TFromTypes<ModuleProperties, Types> {
   return types.map((type) => FromType(moduleProperties, type)) as never
 }
 // ------------------------------------------------------------------
@@ -358,10 +396,12 @@ function FromRest<ModuleProperties extends TProperties, Types extends TSchema[]>
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (
-  // Modifier Unwrap
+  // Modifier
   Type extends TOptional<infer Type extends TSchema> ? TOptional<TFromType<ModuleProperties, Type>> :
   Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TFromType<ModuleProperties, Type>> :
-  // Traveral
+  // Transform
+  Type extends TTransform<infer Input extends TSchema, infer Output extends unknown> ? TFromTransform<ModuleProperties, Input, Output> :
+  // Types
   Type extends TArray<infer Type extends TSchema> ? TFromArray<ModuleProperties, Type> :
   Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<ModuleProperties, Type> :
   Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<ModuleProperties, Target, Parameters> :
@@ -379,10 +419,12 @@ export type TFromType<ModuleProperties extends TProperties, Type extends TSchema
 // prettier-ignore
 export function FromType<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromType<ModuleProperties, Type> {
   return (
-    // Modifier Unwrap - Reapplied via CreateType Options
+    // Modifiers
     KindGuard.IsOptional(type) ? CreateType(FromType(moduleProperties, Discard(type, [OptionalKind]) as TSchema) as never, type) :
     KindGuard.IsReadonly(type) ? CreateType(FromType(moduleProperties, Discard(type, [ReadonlyKind]) as TSchema) as never, type) :
-    // Traveral
+    // Transform
+    KindGuard.IsTransform(type) ? CreateType(FromTransform(moduleProperties, type), type) :
+    // Types
     KindGuard.IsArray(type) ? CreateType(FromArray(moduleProperties, type.items), type) :
     KindGuard.IsAsyncIterator(type) ? CreateType(FromAsyncIterator(moduleProperties, type.items), type) :
     KindGuard.IsComputed(type) ? CreateType(FromComputed(moduleProperties, type.target, type.parameters)) :
diff --git a/src/type/static/static.ts b/src/type/static/static.ts
index 84999f184..b85250600 100644
--- a/src/type/static/static.ts
+++ b/src/type/static/static.ts
@@ -35,6 +35,7 @@ import type { TConstructor } from '../constructor/index'
 import type { TEnum } from '../enum/index'
 import type { TFunction } from '../function/index'
 import type { TIntersect } from '../intersect/index'
+import type { TImport } from '../module/index'
 import type { TIterator } from '../iterator/index'
 import type { TNot } from '../not/index'
 import type { TObject, TProperties } from '../object/index'
@@ -47,48 +48,73 @@ import type { TUnion } from '../union/index'
 import type { TUnsafe } from '../unsafe/index'
 import type { TSchema } from '../schema/index'
 import type { TTransform } from '../transform/index'
+import type { TNever } from '../never/index'
 
 // ------------------------------------------------------------------
-// DecodeType
+// Import
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TDecodeProperties<T extends TProperties> = {
-  [K in keyof T]: TDecodeType<T[K]>
+type TDecodeImport<ModuleProperties extends TProperties, Key extends PropertyKey> = (
+  Key extends keyof ModuleProperties 
+    ? TDecodeType<ModuleProperties[Key]> extends infer Type extends TSchema
+      ? Type extends TRef<infer Ref extends string>
+        ? TDecodeImport<ModuleProperties, Ref>
+        : Type 
+    : TNever
+  : TNever
+)
+// ------------------------------------------------------------------
+// Properties
+// ------------------------------------------------------------------
+// prettier-ignore
+type TDecodeProperties<Properties extends TProperties> = {
+  [Key in keyof Properties]: TDecodeType<Properties[Key]>
 }
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
 // prettier-ignore
-export type TDecodeRest<T extends TSchema[], Acc extends TSchema[] = []> = 
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TDecodeRest<R, [...Acc, TDecodeType<L>]>
-    : Acc
+type TDecodeTypes<Types extends TSchema[], Result extends TSchema[] = []> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
+    ? TDecodeTypes<Right, [...Result, TDecodeType<Left>]>
+    : Result
+)
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
 // prettier-ignore
-export type TDecodeType<T extends TSchema> = (
-  T extends TOptional<infer S extends TSchema> ? TOptional<TDecodeType<S>> :
-  T extends TReadonly<infer S extends TSchema> ? TReadonly<TDecodeType<S>> :
-  T extends TTransform<infer _, infer R> ? TUnsafe<R> :
-  T extends TArray<infer S extends TSchema> ? TArray<TDecodeType<S>> :
-  T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<TDecodeType<S>> :
-  T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<TDecodeRest<P>, TDecodeType<R>> :
-  T extends TEnum<infer S> ? TEnum<S> : // intercept for union. interior non decodable
-  T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<TDecodeRest<P>, TDecodeType<R>> :
-  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TDecodeRest<S>> :
-  T extends TIterator<infer S extends TSchema> ? TIterator<TDecodeType<S>> :
-  T extends TNot<infer S extends TSchema> ? TNot<TDecodeType<S>> :
-  T extends TObject<infer S> ? TObject<Evaluate<TDecodeProperties<S>>> :
-  T extends TPromise<infer S extends TSchema> ? TPromise<TDecodeType<S>> :
-  T extends TRecord<infer K, infer S> ? TRecord<K, TDecodeType<S>> :
-  T extends TRecursive<infer S extends TSchema> ? TRecursive<TDecodeType<S>> :
-  T extends TRef<infer S extends string> ? TRef<S> :
-  T extends TTuple<infer S extends TSchema[]> ? TTuple<TDecodeRest<S>> :
-  T extends TUnion<infer S extends TSchema[]> ? TUnion<TDecodeRest<S>> :
-  T
+export type TDecodeType<Type extends TSchema> = (
+  Type extends TOptional<infer Type extends TSchema> ? TOptional<TDecodeType<Type>> :
+  Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TDecodeType<Type>> :
+  Type extends TTransform<infer _Input extends TSchema, infer Output> ? TUnsafe<Output> :
+  Type extends TArray<infer Type extends TSchema> ? TArray<TDecodeType<Type>> :
+  Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TDecodeType<Type>> :
+  Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TDecodeTypes<Parameters>, TDecodeType<InstanceType>> :
+  Type extends TEnum<infer Values> ? TEnum<Values> : // intercept for union. interior non decodable
+  Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TDecodeTypes<Parameters>, TDecodeType<ReturnType>> :
+  Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TDecodeTypes<Types>> :
+  Type extends TImport<infer ModuleProperties extends TProperties, infer Key> ? TDecodeImport<ModuleProperties, Key> :
+  Type extends TIterator<infer Type extends TSchema> ? TIterator<TDecodeType<Type>> :
+  Type extends TNot<infer Type extends TSchema> ? TNot<TDecodeType<Type>> :
+  Type extends TObject<infer Properties extends TProperties> ? TObject<Evaluate<TDecodeProperties<Properties>>> :
+  Type extends TPromise<infer Type extends TSchema> ? TPromise<TDecodeType<Type>> :
+  Type extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TRecord<Key, TDecodeType<Value>> :
+  Type extends TRecursive<infer Type extends TSchema> ? TRecursive<TDecodeType<Type>> :
+  Type extends TRef<infer Ref extends string> ? TRef<Ref> :
+  Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TDecodeTypes<Types>> :
+  Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TDecodeTypes<Types>> :
+  Type
 )
 // ------------------------------------------------------------------
 // Static
 // ------------------------------------------------------------------
-export type StaticDecodeIsAny<T> = boolean extends (T extends TSchema ? true : false) ? true : false
+export type StaticDecodeIsAny<Type> = boolean extends (Type extends TSchema ? true : false) ? true : false
 /** Creates an decoded static type from a TypeBox type */
-export type StaticDecode<T extends TSchema, P extends unknown[] = []> = StaticDecodeIsAny<T> extends true ? unknown : Static<TDecodeType<T>, P>
+// prettier-ignore
+export type StaticDecode<Type extends TSchema, Params extends unknown[] = [],
+  Result = StaticDecodeIsAny<Type> extends true ? unknown : Static<TDecodeType<Type>, Params>
+> = Result
 /** Creates an encoded static type from a TypeBox type */
-export type StaticEncode<T extends TSchema, P extends unknown[] = []> = Static<T, P>
+export type StaticEncode<Type extends TSchema, Params extends unknown[] = [], Result = Static<Type, Params>> = Result
 /** Creates a static type from a TypeBox type */
-export type Static<T extends TSchema, P extends unknown[] = []> = (T & { params: P })['static']
+export type Static<Type extends TSchema, Params extends unknown[] = [], Result = (Type & { params: Params })['static']> = Result
diff --git a/src/value/transform/decode.ts b/src/value/transform/decode.ts
index f9a120ae4..c40752ec1 100644
--- a/src/value/transform/decode.ts
+++ b/src/value/transform/decode.ts
@@ -118,12 +118,10 @@ function FromIntersect(schema: TIntersect, references: TSchema[], path: string,
 }
 // prettier-ignore
 function FromImport(schema: TImport, references: TSchema[], path: string, value: unknown): unknown {
-  const definitions = globalThis.Object.values(schema.$defs) as TSchema[]
+  const additional = globalThis.Object.values(schema.$defs) as TSchema[]
   const target = schema.$defs[schema.$ref] as TSchema
-  const transform = schema[TransformKind as never]
-  // Note: we need to re-spec the target as TSchema + [TransformKind]
-  const transformTarget = { [TransformKind]: transform, ...target } as TSchema
-  return Visit(transformTarget as never, [...references, ...definitions], path, value)
+  const result = Visit(target, [...references, ...additional], path, value)
+  return Default(schema, path, result)
 }
 function FromNot(schema: TNot, references: TSchema[], path: string, value: any): unknown {
   return Default(schema, path, Visit(schema.not, references, path, value))
@@ -202,6 +200,7 @@ function FromUnion(schema: TUnion, references: TSchema[], path: string, value: a
   }
   return Default(schema, path, value)
 }
+
 // prettier-ignore
 function Visit(schema: TSchema, references: TSchema[], path: string, value: any): any {
   const references_ = Pushref(schema, references)
diff --git a/src/value/transform/encode.ts b/src/value/transform/encode.ts
index 1852c5ffe..ab8de080f 100644
--- a/src/value/transform/encode.ts
+++ b/src/value/transform/encode.ts
@@ -98,12 +98,10 @@ function FromArray(schema: TArray, references: TSchema[], path: string, value: a
 }
 // prettier-ignore
 function FromImport(schema: TImport, references: TSchema[], path: string, value: unknown): unknown {
-  const definitions = globalThis.Object.values(schema.$defs) as TSchema[]
+  const additional = globalThis.Object.values(schema.$defs) as TSchema[]
   const target = schema.$defs[schema.$ref] as TSchema
-  const transform = schema[TransformKind as never]
-  // Note: we need to re-spec the target as TSchema + [TransformKind]
-  const transformTarget = { [TransformKind]: transform, ...target } as TSchema
-  return Visit(transformTarget as never, [...references, ...definitions], path, value)
+  const result = Default(schema, path, value)
+  return Visit(target, [...references, ...additional], path, result)
 }
 // prettier-ignore
 function FromIntersect(schema: TIntersect, references: TSchema[], path: string, value: any) {
diff --git a/src/value/transform/has.ts b/src/value/transform/has.ts
index 549a39e9e..0acf959c1 100644
--- a/src/value/transform/has.ts
+++ b/src/value/transform/has.ts
@@ -36,6 +36,7 @@ import type { TConstructor } from '../../type/constructor/index'
 import type { TFunction } from '../../type/function/index'
 import type { TIntersect } from '../../type/intersect/index'
 import type { TIterator } from '../../type/iterator/index'
+import type { TImport } from '../../type/module/index'
 import type { TNot } from '../../type/not/index'
 import type { TObject } from '../../type/object/index'
 import type { TPromise } from '../../type/promise/index'
@@ -75,6 +76,12 @@ function FromIntersect(schema: TIntersect, references: TSchema[]) {
   return IsTransform(schema) || IsTransform(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references))
 }
 // prettier-ignore
+function FromImport(schema: TImport, references: TSchema[]) {
+  const additional = globalThis.Object.getOwnPropertyNames(schema.$defs).reduce((result, key) => [...result, schema.$defs[key as never]], [] as TSchema[])
+  const target = schema.$defs[schema.$ref]
+  return IsTransform(schema) || Visit(target, [...additional, ...references]) 
+}
+// prettier-ignore
 function FromIterator(schema: TIterator, references: TSchema[]) {
   return IsTransform(schema) || Visit(schema.items, references)
 }
@@ -135,6 +142,8 @@ function Visit(schema: TSchema, references: TSchema[]): boolean {
       return FromConstructor(schema_, references_)
     case 'Function':
       return FromFunction(schema_, references_)
+    case 'Import':
+      return FromImport(schema_, references_)
     case 'Intersect':
       return FromIntersect(schema_, references_)
     case 'Iterator':
diff --git a/test/runtime/value/transform/import.ts b/test/runtime/value/transform/import.ts
index a8646dcfc..456610f75 100644
--- a/test/runtime/value/transform/import.ts
+++ b/test/runtime/value/transform/import.ts
@@ -135,13 +135,13 @@ describe('value/transform/Import', () => {
   const T5 = Type.Transform(Type.Module({ A: Type.Object({ x: Type.String(), y: Type.String() })}).Import('A'))
     .Decode((value) => new Map(Object.entries(value)))
     .Encode((value) => Object.fromEntries(value.entries()) as any)
-  it('should decode map', () => {
+  it('Should decode map', () => {
     const R = Encoder.Decode(T5, { x: 'hello', y: 'world' })
     Assert.IsInstanceOf(R, Map)
     Assert.IsEqual(R.get('x'), 'hello')
     Assert.IsEqual(R.get('y'), 'world')
   })
-  it('should encode map', () => {
+  it('Should encode map', () => {
     const R = Encoder.Encode(
       T5,
       new Map([
@@ -154,4 +154,68 @@ describe('value/transform/Import', () => {
   it('Should throw on map decode', () => {
     Assert.Throws(() => Encoder.Decode(T5, {}))
   })
+
+  // -------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/1178
+  // -------------------------------------------------------------
+  // immediate
+  it('Should transform embedded module codec 1', () => {
+    const T = Type.Module({
+      A: Type.Transform(Type.String())
+        .Decode((value) => parseInt(value))
+        .Encode((value) => value.toString()),
+    }).Import('A')
+
+    const D = Value.Decode(T, '123')
+    const E = Value.Encode(T, 123)
+    Assert.IsEqual(D, 123)
+    Assert.IsEqual(E, '123')
+  })
+  // referential
+  it('Should transform embedded module codec 2', () => {
+    const T = Type.Module({
+      A: Type.Transform(Type.String())
+        .Decode((value) => parseInt(value))
+        .Encode((value) => value.toString()),
+      B: Type.Ref('A'),
+    }).Import('B')
+    const D = Value.Decode(T, '123')
+    const E = Value.Encode(T, 123)
+    Assert.IsEqual(D, 123)
+    Assert.IsEqual(E, '123')
+  })
+  // deep-referential
+  it('Should transform embedded module codec 3', () => {
+    const T = Type.Module({
+      A: Type.Transform(Type.String())
+        .Decode((value) => parseInt(value))
+        .Encode((value) => value.toString()),
+      B: Type.Ref('A'),
+      C: Type.Ref('B'),
+      D: Type.Ref('C'),
+      E: Type.Ref('D'),
+    }).Import('E')
+    const D = Value.Decode(T, '123')
+    const E = Value.Encode(T, 123)
+    Assert.IsEqual(D, 123)
+    Assert.IsEqual(E, '123')
+  })
+  // interior-transform referential
+  it('Should transform embedded module codec 4', () => {
+      const T = Type.Module({
+        A: Type.String(),
+        B: Type.Ref('A'),
+        C: Type.Ref('B'),
+        T: Type.Transform(Type.Ref('C'))
+          .Decode((value) => parseInt(value as string))
+          .Encode((value) => value.toString()),
+        X: Type.Ref('T'),
+        Y: Type.Ref('X'),
+        Z: Type.Ref('Y')
+      }).Import('Z')
+      const D = Value.Decode(T, '123')
+      const E = Value.Encode(T, 123)
+      Assert.IsEqual(D, 123)
+      Assert.IsEqual(E, '123')
+  })
 })
diff --git a/test/static/transform.ts b/test/static/transform.ts
index 2f5e2411f..e9dbc2177 100644
--- a/test/static/transform.ts
+++ b/test/static/transform.ts
@@ -320,3 +320,57 @@ import { Expect } from './assert'
   const x1 = c1.Decode({})
   const x2 = Value.Decode({} as any, {})
 }
+// -------------------------------------------------------------
+// https://github.com/sinclairzx81/typebox/issues/1178
+// -------------------------------------------------------------
+// immediate
+{
+  const T = Type.Module({
+    A: Type.Transform(Type.String())
+      .Decode((value) => parseInt(value))
+      .Encode((value) => value.toString()),
+  }).Import('A')
+  Expect(T).ToStaticDecode<number>()
+  Expect(T).ToStaticEncode<string>()
+}
+// referential
+{
+  const T = Type.Module({
+    A: Type.Transform(Type.String())
+      .Decode((value) => parseInt(value))
+      .Encode((value) => value.toString()),
+    B: Type.Ref('A'),
+  }).Import('B')
+  Expect(T).ToStaticDecode<number>()
+  Expect(T).ToStaticEncode<string>()
+}
+// deep-referential
+{
+  const T = Type.Module({
+    A: Type.Transform(Type.String())
+      .Decode((value) => parseInt(value))
+      .Encode((value) => value.toString()),
+    B: Type.Ref('A'),
+    C: Type.Ref('B'),
+    D: Type.Ref('C'),
+    E: Type.Ref('D'),
+  }).Import('E')
+  Expect(T).ToStaticDecode<number>()
+  Expect(T).ToStaticEncode<string>()
+}
+// interior-transform referential
+{
+  const T = Type.Module({
+    A: Type.String(),
+    B: Type.Ref('A'),
+    C: Type.Ref('B'),
+    T: Type.Transform(Type.Ref('C'))
+      .Decode((value) => parseInt(value as string))
+      .Encode((value) => value.toString()),
+    X: Type.Ref('T'),
+    Y: Type.Ref('X'),
+    Z: Type.Ref('Y'),
+  }).Import('Z')
+  Expect(T).ToStaticDecode<number>()
+  Expect(T).ToStaticEncode<string>()
+}

From 713fd483754f315531cc730317506544e6d23f66 Mon Sep 17 00:00:00 2001
From: rqphqel <5072757+rqphqel@users.noreply.github.com>
Date: Sun, 23 Feb 2025 05:01:39 +0000
Subject: [PATCH 347/369] Documentation (#1185)

- docs: fix typos in readme.md
---
 readme.md | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/readme.md b/readme.md
index ce855410e..fccb50e12 100644
--- a/readme.md
+++ b/readme.md
@@ -544,7 +544,7 @@ The following table lists the supported Json types. These types are fully compat
 
 ### JavaScript Types
 
-TypeBox provides an extended type set that can be used to create schematics for common JavaScript constructs. These types can not be used with any standard Json Schema validator; but can be used to frame schematics for interfaces that may receive Json validated data. JavaScript types are prefixed with the `[JavaScript]` jsdoc comment for convenience. The following table lists the supported types.
+TypeBox provides an extended type set that can be used to create schematics for common JavaScript constructs. These types can not be used with any standard Json Schema validator; but can be used to frame schematics for interfaces that may receive Json validated data. JavaScript types are prefixed with the `[JavaScript]` JSDoc comment for convenience. The following table lists the supported types.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
@@ -717,11 +717,11 @@ Object properties can be modified with Readonly and Optional. The following tabl
 
 ### Generic Types
 
-Generic types can be created with generic functions
+Generic types can be created with generic functions.
 
 ```typescript
 const Nullable = <T extends TSchema>(T: T) => {     // type Nullable<T> = T | null
-  return Type.Union([T, Type.Null())
+  return Type.Union([T, Type.Null()])
 }
 
 const T = Nullable(Type.String())                  // type T = Nullable<string>
@@ -731,7 +731,7 @@ const T = Nullable(Type.String())                  // type T = Nullable<string>
 
 ### Recursive Types
 
-Use the Recursive function to create recursive types
+Use the Recursive function to create recursive types.
 
 ```typescript
 const Node = Type.Recursive(This => Type.Object({    // const Node = {
@@ -875,7 +875,7 @@ const C = Type.Index(T, Type.KeyOf(T))               // type C = T[keyof T]
 
 ### Mapped Types
 
-TypeBox supports mapped types with the Mapped function. This function accepts two arguments, the first is a union type typically derived from KeyOf, the second is a mapping function that receives a mapping key `K` that can be used to index properties of a type. The following implements a mapped type that remaps each property to be `T | null`
+TypeBox supports mapped types with the Mapped function. This function accepts two arguments, the first is a union type typically derived from KeyOf, the second is a mapping function that receives a mapping key `K` that can be used to index properties of a type. The following implements a mapped type that remaps each property to be `T | null`.
 
 ```typescript
 const T = Type.Object({                              // type T = {
@@ -1123,7 +1123,7 @@ const Z = Value.Default(T, { x: 1 })                    // const 'Z = { x: 1, y:
 
 ### Cast
 
-Use the Cast function to upcast a value into a target type. This function will retain as much infomation as possible from the original value. The Cast function is intended to be used in data migration scenarios where existing values need to be upgraded to match a modified type.
+Use the Cast function to upcast a value into a target type. This function will retain as much information as possible from the original value. The Cast function is intended to be used in data migration scenarios where existing values need to be upgraded to match a modified type.
 
 ```typescript
 const T = Type.Object({ x: Type.Number(), y: Type.Number() }, { additionalProperties: false })
@@ -1203,7 +1203,7 @@ const R = Value.Equal(                               // const R = true
 
 ### Hash
 
-Use the Hash function to create a [FNV1A-64](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function) non cryptographic hash of a value.
+Use the Hash function to create a [FNV1A-64](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function) non-cryptographic hash of a value.
 
 ```typescript
 const A = Value.Hash({ x: 1, y: 2, z: 3 })           // const A = 2910466848807138541n
@@ -1383,7 +1383,7 @@ type BasisVectors = Static<typeof BasisVectors>     // type BasisVectors = {
 
 ### Options
 
-Options can be passed via the last parameter
+Options can be passed via the last parameter.
 
 ```typescript
 const T = Syntax(`number`, { minimum: 42 })       // const T = {
@@ -1455,7 +1455,7 @@ const B = Value.Check(T, 'bar')                      // const B = false
 
 ## TypeCheck
 
-TypeBox types target Json Schema Draft 7 and are compatible with any validator that supports this specification. TypeBox also provides a built in type checking compiler designed specifically for TypeBox types that offers high performance compilation and value checking.
+TypeBox types target Json Schema Draft 7 and are compatible with any validator that supports this specification. TypeBox also provides a built-in type checking compiler designed specifically for TypeBox types that offers high performance compilation and value checking.
 
 The following sections detail using Ajv and the TypeBox compiler infrastructure.
 
@@ -1574,7 +1574,7 @@ const C = TypeCompiler.Code(Type.String())           // const C = `return functi
 
 ## TypeMap
 
-TypeBox offers an external package for bi-directional mapping between TypeBox, Valibot, and Zod type libraries. It also includes syntax parsing support for Valibot and Zod and supports the Standard Schema specification. For more details on TypeMap, refer to the project repository.
+TypeBox offers an external package for bidirectional mapping between TypeBox, Valibot, and Zod type libraries. It also includes syntax parsing support for Valibot and Zod and supports the Standard Schema specification. For more details on TypeMap, refer to the project repository.
 
 [TypeMap Repository](https://github.com/sinclairzx81/typemap)
 
@@ -1582,7 +1582,7 @@ TypeBox offers an external package for bi-directional mapping between TypeBox, V
 
 ### Usage
 
-TypeMap needs to be installed seperately
+TypeMap needs to be installed separately
 
 ```bash
 $ npm install @sinclair/typemap
@@ -1731,11 +1731,11 @@ The following is a list of community packages that offer general tooling, extend
 | [json2typebox](https://github.com/hacxy/json2typebox) | Creating TypeBox code from Json Data |
 | [nominal-typebox](https://github.com/Coder-Spirit/nominal/tree/main/%40coderspirit/nominal-typebox) | Allows devs to integrate nominal types into TypeBox schemas |
 | [openapi-box](https://github.com/geut/openapi-box) | Generate TypeBox types from OpenApi IDL + Http client library |
-| [prismabox](https://github.com/m1212e/prismabox) | Converts a prisma.schema to typebox schema matching the database models |
+| [prismabox](https://github.com/m1212e/prismabox) | Converts a prisma.schema to TypeBox schema matching the database models |
 | [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from Json Schemas |
 | [sveltekit-superforms](https://github.com/ciscoheat/sveltekit-superforms)  | A comprehensive SvelteKit form library for server and client validation |
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
-| [typebox-cli](https://github.com/gsuess/typebox-cli) | Generate Schema with typebox from the CLI |
+| [typebox-cli](https://github.com/gsuess/typebox-cli) | Generate Schema with TypeBox from the CLI |
 | [typebox-form-parser](https://github.com/jtlapp/typebox-form-parser) | Parses form and query data based on TypeBox schemas |
 
 

From a67e380a73fd6185df40aa114277100f54f7d240 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 23 Feb 2025 14:27:57 +0900
Subject: [PATCH 348/369] Revision 0.34.28 (#1187)

* Add Cast to Parse Pipeline

* Version

* ChangeLog
---
 changelog/0.34.0.md      |  2 ++
 package-lock.json        |  4 ++--
 package.json             |  2 +-
 src/value/parse/parse.ts | 16 +++++++++-------
 4 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index c0c59d339..c43d2060b 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -3,6 +3,8 @@
 ---
 
 ### Revision Updates
+- [Revision 0.34.28](https://github.com/sinclairzx81/typebox/pull/1187)
+  - Add Cast to Configurable Parse Pipeline
 - [Revision 0.34.27](https://github.com/sinclairzx81/typebox/pull/1182)
   - [1178](https://github.com/sinclairzx81/typebox/issues/1178) Support Deep Referential Transform Inference Inside Modules
 - [Revision 0.34.26](https://github.com/sinclairzx81/typebox/pull/1181)
diff --git a/package-lock.json b/package-lock.json
index ac510958e..f8b32007b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.27",
+  "version": "0.34.28",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.27",
+      "version": "0.34.28",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index e59f3ed4a..418e5421f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.27",
+  "version": "0.34.28",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/parse/parse.ts b/src/value/parse/parse.ts
index 9654f1d4e..429b0084c 100644
--- a/src/value/parse/parse.ts
+++ b/src/value/parse/parse.ts
@@ -31,10 +31,11 @@ import { TransformDecode, TransformEncode, HasTransform } from '../transform/ind
 import { TSchema } from '../../type/schema/index'
 import { StaticDecode } from '../../type/static/index'
 import { Assert } from '../assert/index'
-import { Default } from '../default/index'
-import { Convert } from '../convert/index'
+import { Cast } from '../cast/index'
 import { Clean } from '../clean/index'
 import { Clone } from '../clone/index'
+import { Convert } from '../convert/index'
+import { Default } from '../default/index'
 
 // ------------------------------------------------------------------
 // Guards
@@ -53,18 +54,19 @@ export class ParseError extends TypeBoxError {
 // ------------------------------------------------------------------
 // ParseRegistry
 // ------------------------------------------------------------------
-export type TParseOperation = 'Clone' | 'Clean' | 'Default' | 'Convert' | 'Assert' | 'Decode' | 'Encode' | ({} & string)
+export type TParseOperation = 'Assert' | 'Cast' | 'Clean' | 'Clone' | 'Convert' | 'Decode' | 'Default' | 'Encode' | ({} & string)
 export type TParseFunction = (type: TSchema, references: TSchema[], value: unknown) => unknown
 
 // prettier-ignore
 export namespace ParseRegistry {
   const registry = new Map<string, TParseFunction>([
-    ['Clone', (_type, _references, value: unknown) => Clone(value)],
+    ['Assert', (type, references, value: unknown) => { Assert(type, references, value); return value }],
+    ['Cast', (type, references, value: unknown) => Cast(type, references, value)],
     ['Clean', (type, references, value: unknown) => Clean(type, references, value)],
-    ['Default', (type, references, value: unknown) => Default(type, references, value)],
+    ['Clone', (_type, _references, value: unknown) => Clone(value)],
     ['Convert', (type, references, value: unknown) => Convert(type, references, value)],
-    ['Assert', (type, references, value: unknown) => { Assert(type, references, value); return value }],
     ['Decode', (type, references, value: unknown) => (HasTransform(type, references) ? TransformDecode(type, references, value) : value)],
+    ['Default', (type, references, value: unknown) => Default(type, references, value)],
     ['Encode', (type, references, value: unknown) => (HasTransform(type, references) ? TransformEncode(type, references, value) : value)],
   ])
   // Deletes an entry from the registry
@@ -81,7 +83,7 @@ export namespace ParseRegistry {
   }
 }
 // ------------------------------------------------------------------
-// Default Parse Sequence
+// Default Parse Pipeline
 // ------------------------------------------------------------------
 // prettier-ignore
 export const ParseDefault = [

From 2f20aae454f39efab67606b71d825ecc1cd7c987 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Thu, 27 Feb 2025 14:45:52 +0900
Subject: [PATCH 349/369] Update Node Types to 22.13.5

---
 package-lock.json | 30 +++++++++++++++---------------
 package.json      |  2 +-
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index f8b32007b..b38185996 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -12,7 +12,7 @@
         "@arethetypeswrong/cli": "^0.13.2",
         "@sinclair/hammer": "^0.18.0",
         "@types/mocha": "^9.1.1",
-        "@types/node": "^20.10.1",
+        "@types/node": "^22.13.5",
         "ajv": "^8.12.0",
         "ajv-formats": "^2.1.1",
         "mocha": "^11.1.0",
@@ -210,12 +210,12 @@
       "dev": true
     },
     "node_modules/@types/node": {
-      "version": "20.10.1",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.10.1.tgz",
-      "integrity": "sha512-T2qwhjWwGH81vUEx4EXmBKsTJRXFXNZTL4v0gi01+zyBmCwzE6TyHszqX01m+QHTEq+EZNo13NeJIdEqf+Myrg==",
+      "version": "22.13.5",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.13.5.tgz",
+      "integrity": "sha512-+lTU0PxZXn0Dr1NBtC7Y8cR21AJr87dLLU953CWA6pMxxv/UDc7jYAY90upcrie1nRcD6XNG5HOYEDtgW5TxAg==",
       "dev": true,
       "dependencies": {
-        "undici-types": "~5.26.4"
+        "undici-types": "~6.20.0"
       }
     },
     "node_modules/ajv": {
@@ -1827,9 +1827,9 @@
       }
     },
     "node_modules/undici-types": {
-      "version": "5.26.5",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
-      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
+      "version": "6.20.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.20.0.tgz",
+      "integrity": "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==",
       "dev": true
     },
     "node_modules/unicode-emoji-modifier-base": {
@@ -2184,12 +2184,12 @@
       "dev": true
     },
     "@types/node": {
-      "version": "20.10.1",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.10.1.tgz",
-      "integrity": "sha512-T2qwhjWwGH81vUEx4EXmBKsTJRXFXNZTL4v0gi01+zyBmCwzE6TyHszqX01m+QHTEq+EZNo13NeJIdEqf+Myrg==",
+      "version": "22.13.5",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.13.5.tgz",
+      "integrity": "sha512-+lTU0PxZXn0Dr1NBtC7Y8cR21AJr87dLLU953CWA6pMxxv/UDc7jYAY90upcrie1nRcD6XNG5HOYEDtgW5TxAg==",
       "dev": true,
       "requires": {
-        "undici-types": "~5.26.4"
+        "undici-types": "~6.20.0"
       }
     },
     "ajv": {
@@ -3232,9 +3232,9 @@
       "dev": true
     },
     "undici-types": {
-      "version": "5.26.5",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
-      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
+      "version": "6.20.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.20.0.tgz",
+      "integrity": "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==",
       "dev": true
     },
     "unicode-emoji-modifier-base": {
diff --git a/package.json b/package.json
index 418e5421f..32ac42525 100644
--- a/package.json
+++ b/package.json
@@ -33,7 +33,7 @@
     "@arethetypeswrong/cli": "^0.13.2",
     "@sinclair/hammer": "^0.18.0",
     "@types/mocha": "^9.1.1",
-    "@types/node": "^20.10.1",
+    "@types/node": "^22.13.5",
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
     "mocha": "^11.1.0",

From 75c53ea2cf24610d5e15aa40edf3ce4eab953737 Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Sat, 1 Mar 2025 21:22:15 +0900
Subject: [PATCH 350/369] TypeScript 5.8.2

---
 hammer.mjs        |  2 +-
 package-lock.json | 14 +++++++-------
 package.json      |  2 +-
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/hammer.mjs b/hammer.mjs
index cc8bd42f6..477cc7599 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -35,7 +35,7 @@ export async function benchmark() {
 // Test
 // -------------------------------------------------------------------------------
 export async function test_typescript() {
-  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', '5.4.5', '5.5.2', '5.5.3', '5.5.4', '5.6.2', '5.6.3', '5.7.2', 'next', 'latest']) {
+  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', '5.4.5', '5.5.2', '5.5.3', '5.5.4', '5.6.2', '5.6.3', '5.7.2', '5.7.3', 'next', 'latest']) {
     await shell(`npm install typescript@${version} --no-save`)
     await test_static()
   }
diff --git a/package-lock.json b/package-lock.json
index b38185996..bf521a355 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -17,7 +17,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^11.1.0",
         "prettier": "^2.7.1",
-        "typescript": "^5.7.3"
+        "typescript": "^5.8.2"
       }
     },
     "node_modules/@andrewbranch/untar.js": {
@@ -1814,9 +1814,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.7.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.3.tgz",
-      "integrity": "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==",
+      "version": "5.8.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.2.tgz",
+      "integrity": "sha512-aJn6wq13/afZp/jT9QZmwEjDqqvSGp1VT5GVg+f/t6/oVyrgXM6BY1h9BRh/O5p3PlUPAe+WuiEZOmb/49RqoQ==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -3226,9 +3226,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.7.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.3.tgz",
-      "integrity": "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==",
+      "version": "5.8.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.2.tgz",
+      "integrity": "sha512-aJn6wq13/afZp/jT9QZmwEjDqqvSGp1VT5GVg+f/t6/oVyrgXM6BY1h9BRh/O5p3PlUPAe+WuiEZOmb/49RqoQ==",
       "dev": true
     },
     "undici-types": {
diff --git a/package.json b/package.json
index 32ac42525..621ca3f74 100644
--- a/package.json
+++ b/package.json
@@ -38,6 +38,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^11.1.0",
     "prettier": "^2.7.1",
-    "typescript": "^5.7.3"
+    "typescript": "^5.8.2"
   }
 }

From f709937ac2da2d181859e785eb882632257eb202 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 10 Mar 2025 22:11:51 +0900
Subject: [PATCH 351/369] Revision 0.34.29 (#1197)

* Scalable Delimit Parsing

* Version

* ChangeLog
---
 changelog/0.34.0.md  |   2 +
 package-lock.json    |   4 +-
 package.json         |   2 +-
 src/syntax/static.ts | 140 ++++++++++++-------------------------------
 4 files changed, 44 insertions(+), 104 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index c43d2060b..47f200f3f 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -3,6 +3,8 @@
 ---
 
 ### Revision Updates
+- [Revision 0.34.29](https://github.com/sinclairzx81/typebox/pull/1197)
+  - Scalable Delimited Sequence Parsing
 - [Revision 0.34.28](https://github.com/sinclairzx81/typebox/pull/1187)
   - Add Cast to Configurable Parse Pipeline
 - [Revision 0.34.27](https://github.com/sinclairzx81/typebox/pull/1182)
diff --git a/package-lock.json b/package-lock.json
index bf521a355..a8478796d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.28",
+  "version": "0.34.29",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.28",
+      "version": "0.34.29",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 621ca3f74..839902c14 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.28",
+  "version": "0.34.29",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/syntax/static.ts b/src/syntax/static.ts
index 1e9712f52..50729c558 100644
--- a/src/syntax/static.ts
+++ b/src/syntax/static.ts
@@ -52,89 +52,41 @@ type Equals = '='
 
 // ------------------------------------------------------------------
 // Delimit
-//
-// This type is used to perform a partial breadth match for repeated
-// elements in a sequence. It used to mitigate depth+1 traversal for
-// each element which helps prevent reaching instantiation limits. The
-// technique works by infering as wide as possible on the sequence
-// enabling TS to hoist interior matches, but does come at slight
-// inference performance cost. The current (infer=9) is configured
-// to match 64 terminal tuple elements.
-//
-// for the given sequence
-//
-// [a, b, c, d, e, f, g]
-//
-// ------------------------------------------------------------------
-//
-// without breadth mapping (infer=1, depth=6)
-//
-// [infer a,
-//   [infer b,
-//     [infer c,
-//       [infer d,
-//         [infer e,
-//           [infer f,
-//             [infer g,
-//               []]]]]]]]
-//
-// ------------------------------------------------------------------
-//
-// with breadth mapping (infer=4, depth=2)
-//
-// [infer a, infer b, infer c, infer d,
-//   [infer e, infer f, infer g,
-//     []]]
-//
-//
-// ------------------------------------------------------------------
-// prettier-ignore
-interface DelimitTailMapping<_ = unknown> extends Static.IMapping {
-  output: (
-    this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer F, _, infer G, _, infer H, _, infer I, _, infer Rest extends unknown[]] ? [A, B, C, D, E, F, G, H, I, ...Rest] :
-    this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer F, _, infer G, _, infer H, _, infer Rest extends unknown[]] ? [A, B, C, D, E, F, G, H, ...Rest] :
-    this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer F, _, infer G, _, infer Rest extends unknown[]] ? [A, B, C, D, E, F, G, ...Rest] :
-    this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer F, _, infer Rest extends unknown[]] ? [A, B, C, D, E, F, ...Rest] :
-    this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer Rest extends unknown[]] ? [A, B, C, D, E, ...Rest] :
-    this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _,  infer Rest extends unknown[]] ? [A, B, C, D, ...Rest] :
-    this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer Rest extends unknown[]] ? [A, B, C, ...Rest] :
-    this['input'] extends [_, infer A, _, infer B, _, infer Rest extends unknown[]] ? [A, B, ...Rest] :
-    this['input'] extends [_, infer A, _, infer Rest extends unknown[]] ? [A, ...Rest] :
-    this['input'] extends [_, infer Rest extends unknown[]] ? [...Rest] : 
-    this['input'] extends [_] ? [] :
-    []
-  )
+// ------------------------------------------------------------------
+// prettier-ignore
+type DelimitHeadReduce<Elements extends unknown[], Result extends unknown[] = []> = (
+  Elements extends [infer Left extends unknown, ...infer Right extends unknown[]]
+    ? Left extends [infer Element, infer _Delimiter]
+      ? DelimitHeadReduce<Right, [...Result, Element]>
+      : DelimitHeadReduce<Right, Result>
+    : Result
+)
+// prettier-ignore
+interface DelimitHeadMapping extends Static.IMapping {
+  output: this['input'] extends unknown[] 
+    ? DelimitHeadReduce<this['input']> 
+    : []
 }
 // prettier-ignore
-type DelimitTail<T extends Static.IParser, _ extends Static.IParser> = Static.Union<[
-  Static.Tuple<[_, T, _, T, _, T, _, T, _, T, _, T, _, T, _, T, _, T, _, Delimit<T, _>]>,
-  Static.Tuple<[_, T, _, T, _, T, _, T, _, T, _, T, _, T, _, T, _, Delimit<T, _>]>,
-  Static.Tuple<[_, T, _, T, _, T, _, T, _, T, _, T, _, T, _, Delimit<T, _>]>,
-  Static.Tuple<[_, T, _, T, _, T, _, T, _, T, _, T, _, Delimit<T, _>]>,
-  Static.Tuple<[_, T, _, T, _, T, _, T, _, T, _, Delimit<T, _>]>,
-  Static.Tuple<[_, T, _, T, _, T, _, T, _, Delimit<T, _>]>,
-  Static.Tuple<[_, T, _, T, _, T, _,Delimit<T, _>]>,
-  Static.Tuple<[_, T, _, T, _, Delimit<T, _>]>,
-  Static.Tuple<[_, T, _, Delimit<T, _>]>,
-  Static.Tuple<[_, Delimit<T, _>]>,
-  Static.Tuple<[_]>,
-  Static.Tuple<[]>
-], DelimitTailMapping>
+type DelimitHead<Element extends Static.IParser, Delimiter extends Static.IParser> = (
+  Static.Array<Static.Tuple<[Element, Delimiter]>, DelimitHeadMapping>
+)
+// prettier-ignore
+type DelimitTail<Element extends Static.IParser> = Static.Union<[
+  Static.Tuple<[Element]>,
+  Static.Tuple<[]>,
+]>
 // prettier-ignore
 interface DelimitMapping extends Static.IMapping {
-  output: (
-    this['input'] extends [infer Element extends unknown, infer Rest extends unknown[]] 
-      ? [Element, ...Rest]
-      : []
-  )
+  output: this['input'] extends [infer Left extends unknown[], infer Right extends unknown[]]
+    ? [...Left, ...Right]
+    : []
 }
 // prettier-ignore
-type Delimit<Parser extends Static.IParser, Delimiter extends Static.IParser> = (
-  Static.Union<[
-    Static.Tuple<[Parser, DelimitTail<Parser, Delimiter>]>,
-    Static.Tuple<[]>
-  ], DelimitMapping>
-)
+type Delimit<Element extends Static.IParser, Delimiter extends Static.IParser> = Static.Tuple<[
+  DelimitHead<Element, Delimiter>,
+  DelimitTail<Element>
+], DelimitMapping>
 // ------------------------------------------------------------------
 // Dereference
 // ------------------------------------------------------------------
@@ -143,25 +95,6 @@ type Dereference<Context extends t.TProperties, Ref extends string> = (
   Ref extends keyof Context ? Context[Ref] : t.TRef<Ref>
 )
 // ------------------------------------------------------------------
-// GenericArgumentList
-// ------------------------------------------------------------------
-// prettier-ignore
-interface GenericArgumentListMapping extends Static.IMapping {
-  output: (
-    this['input'] extends [infer Ident extends string, Comma, infer Rest extends unknown[]] ? [Ident, ...Rest] :
-    this['input'] extends [infer Ident extends string, Comma] ? [Ident] :
-    this['input'] extends [infer Ident extends string] ? [Ident] :
-    []
-  )
-}
-// prettier-ignore
-type GenericArgumentList = Static.Union<[
-  Static.Tuple<[Static.Ident, Static.Const<Comma>, GenericArgumentList]>,
-  Static.Tuple<[Static.Ident, Static.Const<Comma>]>,
-  Static.Tuple<[Static.Ident]>,
-  Static.Tuple<[]>,
-], GenericArgumentListMapping>
-// ------------------------------------------------------------------
 // GenericArguments
 // ------------------------------------------------------------------
 // prettier-ignore
@@ -181,7 +114,7 @@ interface GenericArgumentsMapping extends Static.IMapping {
 // prettier-ignore
 type GenericArguments = Static.Tuple<[
   Static.Const<LAngle>,
-  GenericArgumentList,
+  Delimit<Static.Ident, Static.Const<Comma>>,
   Static.Const<RAngle>,
 ], GenericArgumentsMapping>
 
@@ -477,8 +410,8 @@ type PropertyDelimiter = Static.Union<[
 // prettier-ignore
 type PropertiesReduce<PropertiesArray extends t.TProperties[], Result extends t.TProperties = {}> = (
   PropertiesArray extends [infer Left extends t.TProperties, ...infer Right extends t.TProperties[]]
-  ? PropertiesReduce<Right, t.Evaluate<Result & Left>>
-  : Result
+  ? PropertiesReduce<Right, Result & Left>
+  : t.Evaluate<Result>
 )
 // prettier-ignore
 interface PropertiesMapping extends Static.IMapping {
@@ -499,12 +432,17 @@ type Object = Static.Tuple<[
   Static.Const<LBrace>, Properties, Static.Const<RBrace>
 ], ObjectMapping>
 // ------------------------------------------------------------------
-// Tuple
+// Elements
 // ------------------------------------------------------------------
 type Elements = Delimit<Type, Static.Const<Comma>>
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
 // prettier-ignore
 interface TupleMapping extends Static.IMapping {
-  output: this['input'] extends [unknown, infer Elements extends t.TSchema[], unknown] ? t.TTuple<Elements> : never
+  output: this['input'] extends [unknown, infer Elements extends t.TSchema[], unknown] 
+    ? t.TTuple<Elements> 
+    : never
 }
 // prettier-ignore
 type Tuple = Static.Tuple<[

From 0aac4b83ed5e695bf62224bae85e36e364aedf7d Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Tue, 11 Mar 2025 15:25:01 +0900
Subject: [PATCH 352/369] Revision 0.34.30 (#1198)

---
 changelog/0.34.0.md   |   6 +-
 example/index.ts      |   2 +-
 package-lock.json     |   4 +-
 package.json          |   2 +-
 src/syntax/runtime.ts | 353 +++++++++++++++++++++++-------------------
 src/syntax/static.ts  | 231 ++++++++++++++++-----------
 6 files changed, 343 insertions(+), 255 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 47f200f3f..7b81c3920 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -2,9 +2,13 @@
 
 ---
 
+
+
 ### Revision Updates
+- [Revision 0.34.30](https://github.com/sinclairzx81/typebox/pull/1198)
+  - Additional Syntax Parsing Optimizations
 - [Revision 0.34.29](https://github.com/sinclairzx81/typebox/pull/1197)
-  - Scalable Delimited Sequence Parsing
+  - Syntax Parsing Optimizations
 - [Revision 0.34.28](https://github.com/sinclairzx81/typebox/pull/1187)
   - Add Cast to Configurable Parse Pipeline
 - [Revision 0.34.27](https://github.com/sinclairzx81/typebox/pull/1182)
diff --git a/example/index.ts b/example/index.ts
index ff155a02a..58b1d1370 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -19,7 +19,7 @@ type T = Static<typeof T>
 console.log(T)
 
 // -----------------------------------------------------------
-// Parse: Type
+// Syntax: Type
 // -----------------------------------------------------------
 
 const S = Syntax({ T }, `{ x: T, y: T, z: T }`)
diff --git a/package-lock.json b/package-lock.json
index a8478796d..abce9d2f1 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.29",
+  "version": "0.34.30",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.29",
+      "version": "0.34.30",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 839902c14..ca5b738b2 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.29",
+  "version": "0.34.30",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/syntax/runtime.ts b/src/syntax/runtime.ts
index 428ae8e7a..92703afcc 100644
--- a/src/syntax/runtime.ts
+++ b/src/syntax/runtime.ts
@@ -59,31 +59,47 @@ function DestructureRight<T>(values: T[]): [T[], T | undefined] {
     ? [values.slice(0, values.length - 1), values[values.length - 1]]
     : [values, undefined]
 }
+
+// ------------------------------------------------------------------
+// Delimit
+// ------------------------------------------------------------------
+// prettier-ignore
+const DelimitHeadMapping = (results: unknown[]) => results.reduce((result: unknown[], value) => {
+  const [element, _delimiter] = value as [unknown, unknown]
+  return [...result, element]
+}, [] as unknown[])
+// prettier-ignore
+const DelimitHead = <Element extends Runtime.IParser, Delimiter extends Runtime.IParser>(element: Element, delimiter: Delimiter) => (
+  Runtime.Array(Runtime.Tuple([element, delimiter]), DelimitHeadMapping)
+)
+// prettier-ignore
+const DelimitTail = <Element extends Runtime.IParser>(element: Element) => Runtime.Union([
+  Runtime.Tuple([element]),
+  Runtime.Tuple([]),
+])
+// prettier-ignore
+const DelimitMapping = (results: [unknown[], unknown[]]) => {
+  return [...results[0], ...results[1]]
+}
+// prettier-ignore
+const Delimit = <Element extends Runtime.IParser, Delimiter extends Runtime.IParser>(element: Element, delimiter: Delimiter) => Runtime.Tuple([
+  DelimitHead(element, delimiter),
+  DelimitTail(element),
+], DelimitMapping)
+
 // ------------------------------------------------------------------
 // Dereference
 // ------------------------------------------------------------------
 const Dereference = (context: t.TProperties, key: string): t.TSchema => {
   return key in context ? context[key] : t.Ref(key)
 }
+
 // ------------------------------------------------------------------
-// GenericArgumentList
+// GenericArgumentsList
 // ------------------------------------------------------------------
 // prettier-ignore
-const GenericArgumentListMapping = (results: unknown[]) => {
-  return (
-    results.length === 3 ? [results[0], ...results[2] as unknown[]] :
-    results.length === 2 ? [results[0]] :
-    results.length === 1 ? [results[0]] :
-    []
-  )
-}
-// prettier-ignore
-const GenericArgumentList = Runtime.Union([
-  Runtime.Tuple([Runtime.Ident(), Runtime.Const(Comma), Runtime.Ref('GenericArgumentList')]),
-  Runtime.Tuple([Runtime.Ident(), Runtime.Const(Comma)]),
-  Runtime.Tuple([Runtime.Ident()]),
-  Runtime.Tuple([]),
-], (results) => GenericArgumentListMapping(results))
+const GenericArgumentsList = Delimit(Runtime.Ident(), Runtime.Const(Comma))
+
 // ------------------------------------------------------------------
 // GenericArguments
 // ------------------------------------------------------------------
@@ -102,9 +118,10 @@ const GenericArgumentsMapping = (results: unknown[], context: t.TProperties) =>
 // prettier-ignore
 const GenericArguments = Runtime.Tuple([
   Runtime.Const(LAngle),
-  Runtime.Ref('GenericArgumentList'),
+  Runtime.Ref('GenericArgumentsList'),
   Runtime.Const(RAngle),
 ], (results, context) => GenericArgumentsMapping(results, context))
+
 // ------------------------------------------------------------------
 // GenericReference
 // ------------------------------------------------------------------
@@ -113,13 +130,15 @@ function GenericReferenceMapping(results: unknown[], context: t.TProperties) {
   const args = results[2] as t.TSchema[]
   return t.Instantiate(type, args)
 }
+const GenericReferenceParameters = Delimit(Runtime.Ref('Type'), Runtime.Const(Comma))
 // prettier-ignore
 const GenericReference = Runtime.Tuple([
   Runtime.Ident(), 
   Runtime.Const(LAngle), 
-  Runtime.Ref('Elements'), 
+  Runtime.Ref('GenericReferenceParameters'),
   Runtime.Const(RAngle)
 ], (results, context) => GenericReferenceMapping(results, context))
+
 // ------------------------------------------------------------------
 // Reference
 // ------------------------------------------------------------------
@@ -129,6 +148,7 @@ function ReferenceMapping(result: string, context: t.TProperties) {
 }
 // prettier-ignore
 const Reference = Runtime.Ident((result, context) => ReferenceMapping(result, context))
+
 // ------------------------------------------------------------------
 // Literal
 // ------------------------------------------------------------------
@@ -138,24 +158,26 @@ const Literal = Runtime.Union([
   Runtime.Number(value => t.Literal(parseFloat(value))),
   Runtime.String([SingleQuote, DoubleQuote, Tilde], value => t.Literal(value))
 ])
+
 // ------------------------------------------------------------------
 // Keyword
 // ------------------------------------------------------------------
 // prettier-ignore
 const Keyword = Runtime.Union([
-  Runtime.Const('any', Runtime.As(t.Any())),
-  Runtime.Const('bigint', Runtime.As(t.BigInt())),
+  Runtime.Const('string', Runtime.As(t.String())),
+  Runtime.Const('number', Runtime.As(t.Number())),
   Runtime.Const('boolean', Runtime.As(t.Boolean())),
+  Runtime.Const('undefined', Runtime.As(t.Undefined())),
+  Runtime.Const('null', Runtime.As(t.Null())),
   Runtime.Const('integer', Runtime.As(t.Integer())),
+  Runtime.Const('bigint', Runtime.As(t.BigInt())),
+  Runtime.Const('unknown', Runtime.As(t.Unknown())),
+  Runtime.Const('any', Runtime.As(t.Any())),
   Runtime.Const('never', Runtime.As(t.Never())),
-  Runtime.Const('null', Runtime.As(t.Null())),
-  Runtime.Const('number', Runtime.As(t.Number())),
-  Runtime.Const('string', Runtime.As(t.String())),
   Runtime.Const('symbol', Runtime.As(t.Symbol())),
-  Runtime.Const('undefined', Runtime.As(t.Undefined())),
-  Runtime.Const('unknown', Runtime.As(t.Unknown())),
   Runtime.Const('void', Runtime.As(t.Void())),
 ])
+
 // ------------------------------------------------------------------
 // KeyOf
 // ------------------------------------------------------------------
@@ -167,21 +189,23 @@ const KeyOfMapping = (values: unknown[]) => (
 const KeyOf = Runtime.Union([
   Runtime.Tuple([Runtime.Const('keyof')]), Runtime.Tuple([])
 ], KeyOfMapping)
+
 // ------------------------------------------------------------------
 // IndexArray
 // ------------------------------------------------------------------
 // prettier-ignore
-const IndexArrayMapping = (values: unknown[]) => (
-  values.length === 4 ? [[values[1]], ...values[3] as unknown[]] :
-  values.length === 3 ? [[], ...values[2] as unknown[]] :
-  []
-)
+const IndexArrayMapping = (results: ([unknown, unknown, unknown] | [unknown, unknown])[]) => {
+  return results.reduce((result: unknown[], current) => {
+    return current.length === 3 
+      ? [...result, [current[1]]] 
+      : [...result, []]
+  }, [] as unknown[])
+}
 // prettier-ignore
-const IndexArray = Runtime.Union([
-  Runtime.Tuple([Runtime.Const(LBracket), Runtime.Ref('Type'), Runtime.Const(RBracket), Runtime.Ref('IndexArray')]),
-  Runtime.Tuple([Runtime.Const(LBracket), Runtime.Const(RBracket), Runtime.Ref('IndexArray')]),
-  Runtime.Tuple([])
-], value => IndexArrayMapping(value))
+const IndexArray = Runtime.Array(Runtime.Union([
+  Runtime.Tuple([Runtime.Const(LBracket), Runtime.Ref('Type'), Runtime.Const(RBracket)]),
+  Runtime.Tuple([Runtime.Const(LBracket), Runtime.Const(RBracket)]),
+]), IndexArrayMapping)
 
 // ------------------------------------------------------------------
 // Extends
@@ -197,54 +221,51 @@ const Extends = Runtime.Union([
   Runtime.Tuple([Runtime.Const('extends'), Runtime.Ref('Type'), Runtime.Const(Question), Runtime.Ref('Type'), Runtime.Const(Colon), Runtime.Ref('Type')]),
   Runtime.Tuple([])
 ], ExtendsMapping)
+
 // ------------------------------------------------------------------
 // Base
 // ------------------------------------------------------------------
 // prettier-ignore
-const BaseMapping = (values: unknown[]) => {
-  return values.length === 3 ? values[1] : values[0]
+const BaseMapping = (value: unknown) => {
+  return t.ValueGuard.IsArray(value) && value.length === 3 
+    ? value[1] 
+    : value
 }
 // prettier-ignore
 const Base = Runtime.Union([
-  Runtime.Tuple([
-    Runtime.Const(LParen), 
-    Runtime.Ref('Type'), 
-    Runtime.Const(RParen)
-  ]),
-  Runtime.Tuple([Runtime.Union([
-    Runtime.Ref('Literal'),
-    Runtime.Ref('Keyword'),
-    Runtime.Ref('Object'),
-    Runtime.Ref('Tuple'),
-    Runtime.Ref('Constructor'),
-    Runtime.Ref('Function'),
-    Runtime.Ref('Mapped'),
-    Runtime.Ref('AsyncIterator'),
-    Runtime.Ref('Iterator'),
-    Runtime.Ref('ConstructorParameters'),
-    Runtime.Ref('FunctionParameters'),
-    Runtime.Ref('InstanceType'),
-    Runtime.Ref('ReturnType'),
-    Runtime.Ref('Argument'),
-    Runtime.Ref('Awaited'),
-    Runtime.Ref('Array'),
-    Runtime.Ref('Record'),
-    Runtime.Ref('Promise'),
-    Runtime.Ref('Partial'),
-    Runtime.Ref('Required'),
-    Runtime.Ref('Pick'),
-    Runtime.Ref('Omit'),
-    Runtime.Ref('Exclude'),
-    Runtime.Ref('Extract'),
-    Runtime.Ref('Uppercase'),
-    Runtime.Ref('Lowercase'),
-    Runtime.Ref('Capitalize'),
-    Runtime.Ref('Uncapitalize'),
-    Runtime.Ref('Date'),
-    Runtime.Ref('Uint8Array'),
-    Runtime.Ref('GenericReference'),
-    Runtime.Ref('Reference')
-  ])])
+  Runtime.Tuple([Runtime.Const(LParen), Runtime.Ref('Type'), Runtime.Const(RParen)]),
+  Runtime.Ref('Keyword'),
+  Runtime.Ref('Object'),
+  Runtime.Ref('Tuple'),
+  Runtime.Ref('Literal'),
+  Runtime.Ref('Constructor'),
+  Runtime.Ref('Function'),
+  Runtime.Ref('Mapped'),
+  Runtime.Ref('AsyncIterator'),
+  Runtime.Ref('Iterator'),
+  Runtime.Ref('ConstructorParameters'),
+  Runtime.Ref('FunctionParameters'),
+  Runtime.Ref('InstanceType'),
+  Runtime.Ref('ReturnType'),
+  Runtime.Ref('Argument'),
+  Runtime.Ref('Awaited'),
+  Runtime.Ref('Array'),
+  Runtime.Ref('Record'),
+  Runtime.Ref('Promise'),
+  Runtime.Ref('Partial'),
+  Runtime.Ref('Required'),
+  Runtime.Ref('Pick'),
+  Runtime.Ref('Omit'),
+  Runtime.Ref('Exclude'),
+  Runtime.Ref('Extract'),
+  Runtime.Ref('Uppercase'),
+  Runtime.Ref('Lowercase'),
+  Runtime.Ref('Capitalize'),
+  Runtime.Ref('Uncapitalize'),
+  Runtime.Ref('Date'),
+  Runtime.Ref('Uint8Array'),
+  Runtime.Ref('GenericReference'),
+  Runtime.Ref('Reference')
 ], BaseMapping)
 
 // ------------------------------------------------------------------
@@ -280,7 +301,8 @@ const Factor = Runtime.Tuple([
   Runtime.Ref<t.TSchema>('Base'),
   Runtime.Ref<unknown[]>('IndexArray'),
   Runtime.Ref<t.TSchema[]>('Extends')
-], values => FactorMapping(...values))
+], results => FactorMapping(...results))
+
 // ------------------------------------------------------------------
 // Expr
 // ------------------------------------------------------------------
@@ -312,7 +334,7 @@ const ExprTermTail = Runtime.Union([
 // prettier-ignore
 const ExprTerm = Runtime.Tuple([
   Runtime.Ref<t.TSchema>('Factor'), Runtime.Ref<unknown[]>('ExprTermTail')
-], value => ExprBinaryMapping(...value))
+], results => ExprBinaryMapping(...results))
 // prettier-ignore
 const ExprTail = Runtime.Union([
   Runtime.Tuple([Runtime.Const('|'), Runtime.Ref('ExprTerm'), Runtime.Ref('ExprTail')]),
@@ -321,7 +343,7 @@ const ExprTail = Runtime.Union([
 // prettier-ignore
 const Expr = Runtime.Tuple([
   Runtime.Ref<t.TSchema>('ExprTerm'), Runtime.Ref<unknown[]>('ExprTail')
-], value => ExprBinaryMapping(...value))
+], results => ExprBinaryMapping(...results))
 
 // ------------------------------------------------------------------
 // Type
@@ -331,8 +353,9 @@ const Type = Runtime.Union([
   Runtime.Context(Runtime.Ref('GenericArguments'), Runtime.Ref('Expr')), 
   Runtime.Ref('Expr')
 ])
+
 // ------------------------------------------------------------------
-// Properties
+// Property
 // ------------------------------------------------------------------
 const PropertyKey = Runtime.Union([Runtime.Ident(), Runtime.String([SingleQuote, DoubleQuote])])
 const Readonly = Runtime.Union([Runtime.Tuple([Runtime.Const('readonly')]), Runtime.Tuple([])], (value) => value.length > 0)
@@ -353,7 +376,11 @@ const Property = Runtime.Tuple([
   Runtime.Ref<boolean>('Optional'),
   Runtime.Const(Colon),
   Runtime.Ref<t.TSchema>('Type'),
-], value => PropertyMapping(...value))
+], results => PropertyMapping(...results))
+
+// ------------------------------------------------------------------
+// PropertyDelimiter
+// ------------------------------------------------------------------
 // prettier-ignore
 const PropertyDelimiter = Runtime.Union([
   Runtime.Tuple([Runtime.Const(Comma), Runtime.Const(Newline)]),
@@ -362,51 +389,43 @@ const PropertyDelimiter = Runtime.Union([
   Runtime.Tuple([Runtime.Const(SemiColon)]),
   Runtime.Tuple([Runtime.Const(Newline)]),
 ])
-// prettier-ignore
-const Properties = Runtime.Union([
-  Runtime.Tuple([Runtime.Ref<t.TProperties>('Property'), Runtime.Ref('PropertyDelimiter'), Runtime.Ref<t.TProperties>('Properties')]),
-  Runtime.Tuple([Runtime.Ref<t.TProperties>('Property'), Runtime.Ref('PropertyDelimiter')]),
-  Runtime.Tuple([Runtime.Ref<t.TProperties>('Property')]),
-  Runtime.Tuple([])
-], values => (
-  values.length === 3 ? { ...values[0], ...values[2] } :
-  values.length === 2 ? values[0] :
-  values.length === 1 ? values[0] :
-  {}
-))
+
+// ------------------------------------------------------------------
+// PropertyList
+// ------------------------------------------------------------------
+const PropertyList = Delimit(Runtime.Ref('Property'), Runtime.Ref('PropertyDelimiter'))
+
 // ------------------------------------------------------------------
 // Object
 // ------------------------------------------------------------------
 // prettier-ignore
-const ObjectMapping = (_0: typeof LBrace, Properties: t.TProperties, _2: typeof RBrace) => t.Object(Properties)
+const ObjectMapping = (results: unknown[]) => {
+  const propertyList = results[1] as t.TProperties[]
+  return t.Object(propertyList.reduce((result, property) => {
+    return { ...result, ...property }
+  }, {} as t.TProperties))
+}
 // prettier-ignore
 const _Object = Runtime.Tuple([
   Runtime.Const(LBrace),
-  Runtime.Ref<t.TProperties>('Properties'),
+  Runtime.Ref('PropertyList'),
   Runtime.Const(RBrace)
-], values => ObjectMapping(...values))
+], ObjectMapping)
+
+// ------------------------------------------------------------------
+// ElementList
+// ------------------------------------------------------------------
+const ElementList = Delimit(Runtime.Ref('Type'), Runtime.Const(Comma))
 
 // ------------------------------------------------------------------
 // Tuple
 // ------------------------------------------------------------------
 // prettier-ignore
-const Elements = Runtime.Union([
-  Runtime.Tuple([Runtime.Ref('Type'), Runtime.Const(Comma), Runtime.Ref<unknown[]>('Elements')]),
-  Runtime.Tuple([Runtime.Ref('Type'), Runtime.Const(Comma)]),
-  Runtime.Tuple([Runtime.Ref('Type')]),
-  Runtime.Tuple([]),
-], value => (
-  value.length === 3 ? [value[0], ...value[2]] :
-  value.length === 2 ? [value[0]] :
-  value.length === 1 ? [value[0]] :
-  []
-))
-// prettier-ignore
 const Tuple = Runtime.Tuple([
   Runtime.Const(LBracket),
-  Runtime.Ref<t.TSchema[]>('Elements'),
+  Runtime.Ref<t.TSchema[]>('ElementList'),
   Runtime.Const(RBracket)
-], value => t.Tuple(value[1]))
+], results => t.Tuple(results[1]))
 
 // ------------------------------------------------------------------
 // Parameters
@@ -414,19 +433,13 @@ const Tuple = Runtime.Tuple([
 // prettier-ignore
 const Parameter = Runtime.Tuple([
   Runtime.Ident(), Runtime.Const(Colon), Runtime.Ref<t.TSchema>('Type')
-], value => value[2])
-// prettier-ignore
-const Parameters = Runtime.Union([
-  Runtime.Tuple([Runtime.Ref('Parameter'), Runtime.Const(Comma), Runtime.Ref<unknown[]>('Parameters')]),
-  Runtime.Tuple([Runtime.Ref('Parameter'), Runtime.Const(Comma)]),
-  Runtime.Tuple([Runtime.Ref('Parameter')]),
-  Runtime.Tuple([]),
-], value => (
-  value.length === 3 ? [value[0], ...value[2]] :
-  value.length === 2 ? [value[0]] :
-  value.length === 1 ? [value[0]] :
-  []
-))
+], results => results[2])
+
+// ------------------------------------------------------------------
+// ParameterList
+// ------------------------------------------------------------------
+const ParameterList = Delimit(Runtime.Ref('Parameter'), Runtime.Const(Comma))
+
 // ------------------------------------------------------------------
 // Constructor
 // ------------------------------------------------------------------
@@ -434,27 +447,29 @@ const Parameters = Runtime.Union([
 const Constructor = Runtime.Tuple([
   Runtime.Const('new'), 
   Runtime.Const(LParen), 
-  Runtime.Ref<t.TSchema[]>('Parameters'), 
+  Runtime.Ref<t.TSchema[]>('ParameterList'), 
   Runtime.Const(RParen), 
   Runtime.Const('=>'), 
   Runtime.Ref<t.TSchema>('Type')
-], value => t.Constructor(value[2], value[5]))
+], results => t.Constructor(results[2], results[5]))
+
 // ------------------------------------------------------------------
 // Function
 // ------------------------------------------------------------------
 // prettier-ignore
 const Function = Runtime.Tuple([
   Runtime.Const(LParen), 
-  Runtime.Ref<t.TSchema[]>('Parameters'), 
+  Runtime.Ref<t.TSchema[]>('ParameterList'), 
   Runtime.Const(RParen), 
   Runtime.Const('=>'), 
   Runtime.Ref<t.TSchema>('Type')
-], value => t.Function(value[1], value[4]))
+], results => t.Function(results[1], results[4]))
+
 // ------------------------------------------------------------------
 // Mapped (requires deferred types)
 // ------------------------------------------------------------------
 // prettier-ignore
-const MappedMapping = (values: unknown[]) => {
+const MappedMapping = (results: unknown[]) => {
   return t.Literal('Mapped types not supported')
 }
 // prettier-ignore
@@ -463,12 +478,13 @@ const Mapped = Runtime.Tuple([
   Runtime.Const(LBracket), 
   Runtime.Ident(), 
   Runtime.Const('in'), 
-  Runtime.Ref<t.TSchema>('Type'), 
+  Runtime.Ref('Type'), 
   Runtime.Const(RBracket), 
   Runtime.Const(Colon), 
-  Runtime.Ref<t.TSchema>('Type'), 
+  Runtime.Ref('Type'), 
   Runtime.Const(RBrace)
 ], MappedMapping)
+
 // ------------------------------------------------------------------
 // AsyncIterator
 // ------------------------------------------------------------------
@@ -478,7 +494,8 @@ const AsyncIterator = Runtime.Tuple([
   Runtime.Const(LAngle), 
   Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),
-], value => t.AsyncIterator(value[2]))
+], results => t.AsyncIterator(results[2]))
+
 // ------------------------------------------------------------------
 // Iterator
 // ------------------------------------------------------------------
@@ -488,7 +505,8 @@ const Iterator = Runtime.Tuple([
   Runtime.Const(LAngle), 
   Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),
-], value => t.Iterator(value[2]))
+], results => t.Iterator(results[2]))
+
 // ------------------------------------------------------------------
 // ConstructorParameters
 // ------------------------------------------------------------------
@@ -498,7 +516,8 @@ const ConstructorParameters = Runtime.Tuple([
   Runtime.Const(LAngle), 
   Runtime.Ref<t.TConstructor>('Type'), 
   Runtime.Const(RAngle),
-], value => t.ConstructorParameters(value[2]))
+], results => t.ConstructorParameters(results[2]))
+
 // ------------------------------------------------------------------
 // Parameters
 // ------------------------------------------------------------------
@@ -508,7 +527,8 @@ const FunctionParameters = Runtime.Tuple([
   Runtime.Const(LAngle), 
   Runtime.Ref<t.TFunction>('Type'), 
   Runtime.Const(RAngle),
-], value => t.Parameters(value[2]))
+], results => t.Parameters(results[2]))
+
 // ------------------------------------------------------------------
 // InstanceType
 // ------------------------------------------------------------------
@@ -518,7 +538,8 @@ const InstanceType = Runtime.Tuple([
   Runtime.Const(LAngle), 
   Runtime.Ref<t.TConstructor>('Type'), 
   Runtime.Const(RAngle),
-], value => t.InstanceType(value[2]))
+], results => t.InstanceType(results[2]))
+
 // ------------------------------------------------------------------
 // ReturnType
 // ------------------------------------------------------------------
@@ -528,7 +549,8 @@ const ReturnType = Runtime.Tuple([
   Runtime.Const(LAngle), 
   Runtime.Ref<t.TFunction>('Type'), 
   Runtime.Const(RAngle),
-], value => t.ReturnType(value[2]))
+], results => t.ReturnType(results[2]))
+
 // ------------------------------------------------------------------
 // Argument
 // ------------------------------------------------------------------
@@ -543,6 +565,7 @@ const Argument = Runtime.Tuple([
     ? t.Argument(Math.trunc(results[2].const))
     : t.Never()
 })
+
 // ------------------------------------------------------------------
 // Awaited
 // ------------------------------------------------------------------
@@ -552,7 +575,8 @@ const Awaited = Runtime.Tuple([
   Runtime.Const(LAngle), 
   Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),
-], value => t.Awaited(value[2]))
+], results => t.Awaited(results[2]))
+
 // ------------------------------------------------------------------
 // Array
 // ------------------------------------------------------------------
@@ -562,7 +586,8 @@ const Array = Runtime.Tuple([
   Runtime.Const(LAngle), 
   Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),
-], value => t.Array(value[2]))
+], results => t.Array(results[2]))
+
 // ------------------------------------------------------------------
 // Record
 // ------------------------------------------------------------------
@@ -574,7 +599,8 @@ const Record = Runtime.Tuple([
   Runtime.Const(Comma), 
   Runtime.Ref<t.TSchema>('Type'),
   Runtime.Const(RAngle),  
-], value => t.Record(value[2], value[4]))
+], results => t.Record(results[2], results[4]))
+
 // ------------------------------------------------------------------
 // Promise
 // ------------------------------------------------------------------
@@ -584,7 +610,8 @@ const Promise = Runtime.Tuple([
   Runtime.Const(LAngle), 
   Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => t.Promise(value[2]))
+], results => t.Promise(results[2]))
+
 // ------------------------------------------------------------------
 // Partial
 // ------------------------------------------------------------------
@@ -594,7 +621,8 @@ const Partial = Runtime.Tuple([
   Runtime.Const(LAngle), 
   Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => t.Partial(value[2]))
+], results => t.Partial(results[2]))
+
 // ------------------------------------------------------------------
 // Required
 // ------------------------------------------------------------------
@@ -604,7 +632,8 @@ const Required = Runtime.Tuple([
   Runtime.Const(LAngle), 
   Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => t.Required(value[2]))
+], results => t.Required(results[2]))
+
 // ------------------------------------------------------------------
 // Pick
 // ------------------------------------------------------------------
@@ -616,7 +645,8 @@ const Pick = Runtime.Tuple([
   Runtime.Const(Comma), 
   Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => t.Pick(value[2], value[4]))
+], results => t.Pick(results[2], results[4]))
+
 // ------------------------------------------------------------------
 // Omit
 // ------------------------------------------------------------------
@@ -628,7 +658,8 @@ const Omit = Runtime.Tuple([
   Runtime.Const(Comma), 
   Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => t.Omit(value[2], value[4]))
+], results => t.Omit(results[2], results[4]))
+
 // ------------------------------------------------------------------
 // Exclude
 // ------------------------------------------------------------------
@@ -640,7 +671,8 @@ const Exclude = Runtime.Tuple([
   Runtime.Const(Comma), 
   Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => t.Exclude(value[2], value[4]))
+], results => t.Exclude(results[2], results[4]))
+
 // ------------------------------------------------------------------
 // Extract
 // ------------------------------------------------------------------
@@ -652,7 +684,8 @@ const Extract = Runtime.Tuple([
   Runtime.Const(Comma), 
   Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => t.Extract(value[2], value[4]))
+], results => t.Extract(results[2], results[4]))
+
 // ------------------------------------------------------------------
 // Uppercase
 // ------------------------------------------------------------------
@@ -662,7 +695,8 @@ const Uppercase = Runtime.Tuple([
   Runtime.Const(LAngle), 
   Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => t.Uppercase(value[2]))
+], results => t.Uppercase(results[2]))
+
 // ------------------------------------------------------------------
 // Lowercase
 // ------------------------------------------------------------------
@@ -672,7 +706,8 @@ const Lowercase = Runtime.Tuple([
   Runtime.Const(LAngle), 
   Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => t.Lowercase(value[2]))
+], results => t.Lowercase(results[2]))
+
 // ------------------------------------------------------------------
 // Capitalize
 // ------------------------------------------------------------------
@@ -682,7 +717,8 @@ const Capitalize = Runtime.Tuple([
   Runtime.Const(LAngle), 
   Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => t.Capitalize(value[2]))
+], results => t.Capitalize(results[2]))
+
 // ------------------------------------------------------------------
 // Uncapitalize
 // ------------------------------------------------------------------
@@ -692,11 +728,13 @@ const Uncapitalize = Runtime.Tuple([
   Runtime.Const(LAngle), 
   Runtime.Ref<t.TSchema>('Type'), 
   Runtime.Const(RAngle),  
-], value => t.Uncapitalize(value[2]))
+], results => t.Uncapitalize(results[2]))
+
 // ------------------------------------------------------------------
 // Date
 // ------------------------------------------------------------------
 const Date = Runtime.Const('Date', Runtime.As(t.Date()))
+
 // ------------------------------------------------------------------
 // Uint8Array
 // ------------------------------------------------------------------
@@ -707,14 +745,8 @@ const Uint8Array = Runtime.Const('Uint8Array', Runtime.As(t.Uint8Array()))
 // ------------------------------------------------------------------
 // prettier-ignore
 export const Module = new Runtime.Module({
-  // ----------------------------------------------------------------
-  // Generics
-  // ----------------------------------------------------------------
-  GenericArgumentList,
+  GenericArgumentsList,
   GenericArguments,
-  // ----------------------------------------------------------------
-  // Type
-  // ----------------------------------------------------------------
   Literal,
   Keyword,
   KeyOf,
@@ -732,13 +764,13 @@ export const Module = new Runtime.Module({
   Optional,
   Property,
   PropertyDelimiter,
-  Properties,
+  PropertyList,
   Object: _Object,
-  Elements,
+  ElementList,
   Tuple,
   Parameter,
+  ParameterList,
   Function,
-  Parameters,
   Constructor,
   Mapped,
   AsyncIterator,
@@ -764,6 +796,7 @@ export const Module = new Runtime.Module({
   Uncapitalize,
   Date,
   Uint8Array,
+  GenericReferenceParameters,
   GenericReference,
   Reference,
 })
diff --git a/src/syntax/static.ts b/src/syntax/static.ts
index 50729c558..609fc3d7b 100644
--- a/src/syntax/static.ts
+++ b/src/syntax/static.ts
@@ -87,6 +87,7 @@ type Delimit<Element extends Static.IParser, Delimiter extends Static.IParser> =
   DelimitHead<Element, Delimiter>,
   DelimitTail<Element>
 ], DelimitMapping>
+
 // ------------------------------------------------------------------
 // Dereference
 // ------------------------------------------------------------------
@@ -94,6 +95,7 @@ type Delimit<Element extends Static.IParser, Delimiter extends Static.IParser> =
 type Dereference<Context extends t.TProperties, Ref extends string> = (
   Ref extends keyof Context ? Context[Ref] : t.TRef<Ref>
 )
+
 // ------------------------------------------------------------------
 // GenericArguments
 // ------------------------------------------------------------------
@@ -111,10 +113,11 @@ interface GenericArgumentsMapping extends Static.IMapping {
         : never
     : never
 }
+type GenericArgumentsList = Delimit<Static.Ident, Static.Const<Comma>>
 // prettier-ignore
 type GenericArguments = Static.Tuple<[
   Static.Const<LAngle>,
-  Delimit<Static.Ident, Static.Const<Comma>>,
+  GenericArgumentsList,
   Static.Const<RAngle>,
 ], GenericArgumentsMapping>
 
@@ -129,13 +132,15 @@ interface GenericReferenceMapping extends Static.IMapping {
       : never
     : never  
 }
+type GenericReferenceParameters = Delimit<Type, Static.Const<Comma>>
 // prettier-ignore
 type GenericReference = Static.Tuple<[
   Static.Ident,
   Static.Const<LAngle>,
-  Elements,
+  GenericReferenceParameters,
   Static.Const<RAngle>,
 ], GenericReferenceMapping>
+
 // ------------------------------------------------------------------
 // Reference
 // ------------------------------------------------------------------
@@ -148,20 +153,21 @@ interface ReferenceMapping extends Static.IMapping {
     : never  
 }
 type Reference = Static.Ident<ReferenceMapping>
+
 // ------------------------------------------------------------------
 // Literal
 // ------------------------------------------------------------------
 // prettier-ignore
 interface LiteralBooleanMapping extends Static.IMapping {
-  output: this['input'] extends `${infer S extends boolean}` ? t.TLiteral<S> : never
+  output: this['input'] extends `${infer Value extends boolean}` ? t.TLiteral<Value> : never
 }
 // prettier-ignore
 interface LiteralNumberMapping extends Static.IMapping {
-  output: this['input'] extends `${infer S extends number}` ? t.TLiteral<S> : never
+  output: this['input'] extends `${infer Value extends number}` ? t.TLiteral<Value> : never
 }
 // prettier-ignore
 interface LiteralStringMapping extends Static.IMapping {
-  output: this['input'] extends `${infer S extends string}` ? t.TLiteral<S> : never
+  output: this['input'] extends `${infer Value extends string}` ? t.TLiteral<Value> : never
 }
 // prettier-ignore
 type Literal = Static.Union<[
@@ -169,24 +175,26 @@ type Literal = Static.Union<[
   Static.Number<LiteralNumberMapping>,
   Static.String<[DoubleQuote, SingleQuote, Tilde], LiteralStringMapping>,
 ]>
+
 // ------------------------------------------------------------------
 // Keyword
 // ------------------------------------------------------------------
 // prettier-ignore
 type Keyword = Static.Union<[
-  Static.Const<'any', Static.As<t.TAny>>,
-  Static.Const<'bigint', Static.As<t.TBigInt>>,
+  Static.Const<'string', Static.As<t.TString>>,
+  Static.Const<'number', Static.As<t.TNumber>>,
   Static.Const<'boolean', Static.As<t.TBoolean>>,
+  Static.Const<'undefined', Static.As<t.TUndefined>>,
+  Static.Const<'null', Static.As<t.TNull>>,
   Static.Const<'integer', Static.As<t.TInteger>>,
+  Static.Const<'bigint', Static.As<t.TBigInt>>,
+  Static.Const<'unknown', Static.As<t.TUnknown>>,
+  Static.Const<'any', Static.As<t.TAny>>,
   Static.Const<'never', Static.As<t.TNever>>,
-  Static.Const<'null', Static.As<t.TNull>>,
-  Static.Const<'number', Static.As<t.TNumber>>,
-  Static.Const<'string', Static.As<t.TString>>,
   Static.Const<'symbol', Static.As<t.TSymbol>>,
-  Static.Const<'undefined', Static.As<t.TUndefined>>,
-  Static.Const<'unknown', Static.As<t.TUnknown>>,
   Static.Const<'void', Static.As<t.TVoid>>,
 ]>
+
 // ------------------------------------------------------------------
 // KeyOf
 // ------------------------------------------------------------------
@@ -199,23 +207,29 @@ type KeyOf = Static.Union<[
   Static.Tuple<[Static.Const<'keyof'>]>,
   Static.Tuple<[]>
 ], KeyOfMapping>
+
 // ------------------------------------------------------------------
 // IndexArray
 // ------------------------------------------------------------------
 // prettier-ignore
+type IndexArrayReduce<Values extends unknown[], Result extends unknown[] = []> = (
+  Values extends [infer Left extends unknown, ...infer Right extends unknown[]]
+    ? Left extends [LBracket, infer Type extends t.TSchema, RBracket] 
+      ? IndexArrayReduce<Right, [...Result, [Type]]>
+      : IndexArrayReduce<Right, [...Result, []]>
+    : Result
+)
+// prettier-ignore
 interface IndexArrayMapping extends Static.IMapping {
-  output: (
-    this['input'] extends [LBracket, infer Type extends t.TSchema, RBracket, infer Rest extends unknown[]] ? [[Type], ...Rest] :
-    this['input'] extends [LBracket, RBracket, infer Rest extends unknown[]] ? [[], ...Rest] :
-    []
-  )
+  output: this['input'] extends unknown[] 
+    ? IndexArrayReduce<this['input']> 
+    : []
 }
 // prettier-ignore
-type IndexArray = Static.Union<[
-  Static.Tuple<[Static.Const<LBracket>, Type, Static.Const<RBracket>, IndexArray]>,
-  Static.Tuple<[Static.Const<LBracket>, Static.Const<RBracket>, IndexArray]>,
-  Static.Tuple<[]>
-], IndexArrayMapping>
+type IndexArray = Static.Array<Static.Union<[
+  Static.Tuple<[Static.Const<LBracket>, Type, Static.Const<RBracket>,]>,
+  Static.Tuple<[Static.Const<LBracket>, Static.Const<RBracket>]>,
+]>, IndexArrayMapping>
 
 // ------------------------------------------------------------------
 // Extends
@@ -231,6 +245,7 @@ type Extends = Static.Union<[
   Static.Tuple<[Static.Const<'extends'>, Type, Static.Const<Question>, Type, Static.Const<Colon>, Type]>,
   Static.Tuple<[]>
 ], ExtendsMapping>
+
 // ------------------------------------------------------------------
 // Base
 // ------------------------------------------------------------------
@@ -238,52 +253,47 @@ type Extends = Static.Union<[
 interface BaseMapping extends Static.IMapping {
   output: (
     this['input'] extends [LParen, infer Type extends t.TSchema, RParen] ? Type :
-    this['input'] extends [infer Type extends t.TSchema] ? Type :
+    this['input'] extends infer Type extends t.TSchema ? Type :
     never
   )
 }
 // prettier-ignore
 type Base = Static.Union<[
-  Static.Tuple<[
-    Static.Const<LParen>, 
-    Type,
-    Static.Const<RParen>
-  ]>,
-  Static.Tuple<[Static.Union<[
-    Literal,
-    Keyword,
-    Object, 
-    Tuple,
-    Function,
-    Constructor,
-    Mapped,
-    AsyncIterator,
-    Iterator,
-    ConstructorParameters,
-    FunctionParameters,
-    Argument,
-    InstanceType,
-    ReturnType,
-    Awaited,
-    Array,
-    Record,
-    Promise,
-    Partial,
-    Required,
-    Pick,
-    Omit,
-    Exclude,
-    Extract,
-    Lowercase,
-    Uppercase,
-    Capitalize,
-    Uncapitalize,
-    Date,
-    Uint8Array,
-    GenericReference,
-    Reference
-  ]>]>
+  Static.Tuple<[Static.Const<LParen>, Type, Static.Const<RParen>]>,
+  Keyword,
+  Object, 
+  Tuple,
+  Literal,
+  Function,
+  Constructor,
+  Mapped,
+  AsyncIterator,
+  Iterator,
+  ConstructorParameters,
+  FunctionParameters,
+  Argument,
+  InstanceType,
+  ReturnType,
+  Awaited,
+  Array,
+  Record,
+  Promise,
+  Partial,
+  Required,
+  Pick,
+  Omit,
+  Exclude,
+  Extract,
+  Lowercase,
+  Uppercase,
+  Capitalize,
+  Uncapitalize,
+  Date,
+  Uint8Array,
+  GenericReference,
+  Reference
 ], BaseMapping>
+
 // ------------------------------------------------------------------
 // Factor
 // ------------------------------------------------------------------
@@ -313,6 +323,7 @@ interface FactorMapping extends Static.IMapping {
 type Factor = Static.Tuple<[
   KeyOf, Base, IndexArray, Extends
 ], FactorMapping>
+
 // ------------------------------------------------------------------
 // Expr
 // ------------------------------------------------------------------
@@ -359,6 +370,7 @@ type ExprTail = Static.Union<[
 type Expr = Static.Tuple<[
   ExprTerm, ExprTail
 ], ExprBinaryMapping>
+
 // ------------------------------------------------------------------
 // Type
 // ------------------------------------------------------------------
@@ -367,8 +379,9 @@ export type Type = Static.Union<[
   Static.Context<GenericArguments, Expr>, 
   Expr
 ]>
+
 // ------------------------------------------------------------------
-// Properties
+// Property
 // ------------------------------------------------------------------
 // prettier-ignore
 interface PropertyKeyStringMapping extends Static.IMapping {
@@ -399,6 +412,10 @@ interface PropertyMapping extends Static.IMapping {
   } : never
 }
 type Property = Static.Tuple<[Readonly, PropertyKey, Optional, Static.Const<Colon>, Type], PropertyMapping>
+
+// ------------------------------------------------------------------
+// PropertyDelimiter
+// ------------------------------------------------------------------
 // prettier-ignore
 type PropertyDelimiter = Static.Union<[
   Static.Tuple<[Static.Const<Comma>, Static.Const<Newline>]>,
@@ -407,49 +424,55 @@ type PropertyDelimiter = Static.Union<[
   Static.Tuple<[Static.Const<SemiColon>]>,
   Static.Tuple<[Static.Const<Newline>]>,
 ]>
-// prettier-ignore
-type PropertiesReduce<PropertiesArray extends t.TProperties[], Result extends t.TProperties = {}> = (
-  PropertiesArray extends [infer Left extends t.TProperties, ...infer Right extends t.TProperties[]]
-  ? PropertiesReduce<Right, Result & Left>
-  : t.Evaluate<Result>
-)
-// prettier-ignore
-interface PropertiesMapping extends Static.IMapping {
-  output: this['input'] extends t.TProperties[] ? PropertiesReduce<this['input']> : never
-}
-type Properties = Static.Union<[Delimit<Property, PropertyDelimiter>], PropertiesMapping>
+
+// ------------------------------------------------------------------
+// PropertyList
+// ------------------------------------------------------------------
+type PropertyList = Delimit<Property, PropertyDelimiter>
+
 // ------------------------------------------------------------------
 // Object
 // ------------------------------------------------------------------
 // prettier-ignore
+type ObjectReduce<PropertiesList extends t.TProperties[], Result extends t.TProperties = {}> = (
+  PropertiesList extends [infer Left extends t.TProperties, ...infer Right extends t.TProperties[]]
+  ? ObjectReduce<Right, Result & Left>
+  : t.Evaluate<Result>
+)
+// prettier-ignore
 interface ObjectMapping extends Static.IMapping {
-  output: this['input'] extends [unknown, infer Properties extends t.TProperties, unknown] 
-    ? t.TObject<Properties> 
+  output: this['input'] extends [LBrace, infer PropertyList extends t.TProperties[], RBrace] 
+    ? t.TObject<ObjectReduce<PropertyList>> 
     : never
 }
 // prettier-ignore
 type Object = Static.Tuple<[
-  Static.Const<LBrace>, Properties, Static.Const<RBrace>
+  Static.Const<LBrace>,
+  PropertyList, 
+  Static.Const<RBrace>
 ], ObjectMapping>
+
 // ------------------------------------------------------------------
-// Elements
+// ElementList
 // ------------------------------------------------------------------
-type Elements = Delimit<Type, Static.Const<Comma>>
+type ElementList = Delimit<Type, Static.Const<Comma>>
+
 // ------------------------------------------------------------------
 // Tuple
 // ------------------------------------------------------------------
 // prettier-ignore
 interface TupleMapping extends Static.IMapping {
-  output: this['input'] extends [unknown, infer Elements extends t.TSchema[], unknown] 
-    ? t.TTuple<Elements> 
+  output: this['input'] extends [unknown, infer ElementList extends t.TSchema[], unknown] 
+    ? t.TTuple<ElementList> 
     : never
 }
 // prettier-ignore
 type Tuple = Static.Tuple<[
-  Static.Const<LBracket>, Elements, Static.Const<RBracket>
+  Static.Const<LBracket>, ElementList, Static.Const<RBracket>
 ], TupleMapping>
+
 // ------------------------------------------------------------------
-// Parameters
+// Parameter
 // ------------------------------------------------------------------
 interface ParameterMapping extends Static.IMapping {
   output: this['input'] extends [string, Colon, infer Type extends t.TSchema] ? Type : never
@@ -459,33 +482,39 @@ type Parameter = Static.Tuple<[
   Static.Ident, Static.Const<Colon>, Type
 ], ParameterMapping>
 
-type Parameters = Delimit<Parameter, Static.Const<Comma>>
+// ------------------------------------------------------------------
+// ParameterList
+// ------------------------------------------------------------------
+type ParameterList = Delimit<Parameter, Static.Const<Comma>>
+
 // ------------------------------------------------------------------
 // Function
 // ------------------------------------------------------------------
 // prettier-ignore
 interface FunctionMapping extends Static.IMapping {
-  output: this['input'] extends [LParen, infer Parameters extends t.TSchema[], RParen, '=>', infer ReturnType extends t.TSchema]
-    ? t.TFunction<Parameters, ReturnType>
+  output: this['input'] extends [LParen, infer ParameterList extends t.TSchema[], RParen, '=>', infer ReturnType extends t.TSchema]
+    ? t.TFunction<ParameterList, ReturnType>
     : never
 }
 // prettier-ignore
 type Function = Static.Tuple<[
-  Static.Const<LParen>, Parameters, Static.Const<RParen>, Static.Const<'=>'>, Type
+  Static.Const<LParen>, ParameterList, Static.Const<RParen>, Static.Const<'=>'>, Type
 ], FunctionMapping>
+
 // ------------------------------------------------------------------
 // Constructor
 // ------------------------------------------------------------------
 // prettier-ignore
 interface ConstructorMapping extends Static.IMapping {
-  output: this['input'] extends ['new', LParen, infer Parameters extends t.TSchema[], RParen, '=>', infer InstanceType extends t.TSchema]
-    ? t.TConstructor<Parameters, InstanceType>
+  output: this['input'] extends ['new', LParen, infer ParameterList extends t.TSchema[], RParen, '=>', infer InstanceType extends t.TSchema]
+    ? t.TConstructor<ParameterList, InstanceType>
     : never
 }
 // prettier-ignore
 type Constructor = Static.Tuple<[
-  Static.Const<'new'>, Static.Const<LParen>, Parameters, Static.Const<RParen>, Static.Const<'=>'>, Type
+  Static.Const<'new'>, Static.Const<LParen>, ParameterList, Static.Const<RParen>, Static.Const<'=>'>, Type
 ], ConstructorMapping>
+
 // ------------------------------------------------------------------
 // Mapped (requires deferred types)
 // ------------------------------------------------------------------
@@ -499,6 +528,7 @@ interface MappedMapping extends Static.IMapping {
 type Mapped = Static.Tuple<[
   Static.Const<LBrace>, Static.Const<LBracket>, Static.Ident, Static.Const<'in'>, Type, Static.Const<RBracket>, Static.Const<Colon>, Type, Static.Const<RBrace>
 ], MappedMapping>
+
 // ------------------------------------------------------------------
 // Array
 // ------------------------------------------------------------------
@@ -512,6 +542,7 @@ interface ArrayMapping extends Static.IMapping {
 type Array = Static.Tuple<[
   Static.Const<'Array'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
 ], ArrayMapping>
+
 // ------------------------------------------------------------------
 // AsyncIterator
 // ------------------------------------------------------------------
@@ -525,6 +556,7 @@ interface AsyncIteratorMapping extends Static.IMapping {
 type AsyncIterator = Static.Tuple<[
   Static.Const<'AsyncIterator'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
 ], AsyncIteratorMapping>
+
 // ------------------------------------------------------------------
 // Iterator
 // ------------------------------------------------------------------
@@ -552,6 +584,7 @@ interface ConstructorParametersMapping extends Static.IMapping {
 type ConstructorParameters = Static.Tuple<[
   Static.Const<'ConstructorParameters'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
 ], ConstructorParametersMapping>
+
 // ------------------------------------------------------------------
 // FunctionParameters
 // ------------------------------------------------------------------
@@ -565,6 +598,7 @@ interface FunctionParametersMapping extends Static.IMapping {
 type FunctionParameters = Static.Tuple<[
   Static.Const<'Parameters'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
 ], FunctionParametersMapping>
+
 // ------------------------------------------------------------------
 // InstanceType
 // ------------------------------------------------------------------
@@ -578,6 +612,7 @@ interface InstanceTypeMapping extends Static.IMapping {
 type InstanceType = Static.Tuple<[
   Static.Const<'InstanceType'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
 ], InstanceTypeMapping>
+
 // ------------------------------------------------------------------
 // ReturnType
 // ------------------------------------------------------------------
@@ -591,6 +626,7 @@ interface ReturnTypeMapping extends Static.IMapping {
 type ReturnType = Static.Tuple<[
   Static.Const<'ReturnType'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
 ], ReturnTypeMapping>
+
 // ------------------------------------------------------------------
 // Argument
 // ------------------------------------------------------------------
@@ -606,6 +642,7 @@ interface ArgumentMapping extends Static.IMapping {
 type Argument = Static.Tuple<[
   Static.Const<'Argument'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
 ], ArgumentMapping>
+
 // ------------------------------------------------------------------
 // Awaited
 // ------------------------------------------------------------------
@@ -619,6 +656,7 @@ interface AwaitedMapping extends Static.IMapping {
 type Awaited = Static.Tuple<[
   Static.Const<'Awaited'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
 ], AwaitedMapping>
+
 // ------------------------------------------------------------------
 // Promise
 // ------------------------------------------------------------------
@@ -632,6 +670,7 @@ interface PromiseMapping extends Static.IMapping {
 type Promise = Static.Tuple<[
   Static.Const<'Promise'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
 ], PromiseMapping>
+
 // ------------------------------------------------------------------
 // Record
 // ------------------------------------------------------------------
@@ -645,6 +684,7 @@ interface RecordMapping extends Static.IMapping {
 type Record = Static.Tuple<[
   Static.Const<'Record'>, Static.Const<LAngle>, Type, Static.Const<Comma>, Type, Static.Const<RAngle>,
 ], RecordMapping>
+
 // ------------------------------------------------------------------
 // Partial
 // ------------------------------------------------------------------
@@ -658,6 +698,7 @@ interface PartialMapping extends Static.IMapping {
 type Partial = Static.Tuple<[
   Static.Const<'Partial'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
 ], PartialMapping>
+
 // ------------------------------------------------------------------
 // Required
 // ------------------------------------------------------------------
@@ -671,6 +712,7 @@ interface RequiredMapping extends Static.IMapping {
 type Required = Static.Tuple<[
   Static.Const<'Required'>,  Static.Const<LAngle>, Type, Static.Const<RAngle>,
 ], RequiredMapping>
+
 // ------------------------------------------------------------------
 // Pick
 // ------------------------------------------------------------------
@@ -684,6 +726,7 @@ interface PickMapping extends Static.IMapping {
 type Pick = Static.Tuple<[
   Static.Const<'Pick'>, Static.Const<LAngle>, Type, Static.Const<Comma>, Type, Static.Const<RAngle>,
 ], PickMapping>
+
 // ------------------------------------------------------------------
 // Omit
 // ------------------------------------------------------------------
@@ -697,6 +740,7 @@ interface OmitMapping extends Static.IMapping {
 type Omit = Static.Tuple<[
   Static.Const<'Omit'>, Static.Const<LAngle>, Type, Static.Const<Comma>, Type, Static.Const<RAngle>
 ], OmitMapping>
+
 // ------------------------------------------------------------------
 // Exclude
 // ------------------------------------------------------------------
@@ -710,6 +754,7 @@ interface ExcludeMapping extends Static.IMapping {
 type Exclude = Static.Tuple<[
   Static.Const<'Exclude'>, Static.Const<LAngle>, Type, Static.Const<Comma>, Type, Static.Const<RAngle>
 ], ExcludeMapping>
+
 // ------------------------------------------------------------------
 // Extract
 // ------------------------------------------------------------------
@@ -723,6 +768,7 @@ interface ExtractMapping extends Static.IMapping {
 type Extract = Static.Tuple<[
   Static.Const<'Extract'>, Static.Const<LAngle>, Type, Static.Const<Comma>, Type, Static.Const<RAngle>
 ], ExtractMapping>
+
 // ------------------------------------------------------------------
 // Uppercase
 // ------------------------------------------------------------------
@@ -736,6 +782,7 @@ interface UppercaseMapping extends Static.IMapping {
 type Uppercase = Static.Tuple<[
   Static.Const<'Uppercase'>,  Static.Const<LAngle>, Type, Static.Const<RAngle>,
 ], UppercaseMapping>
+
 // ------------------------------------------------------------------
 // Lowercase
 // ------------------------------------------------------------------
@@ -749,6 +796,7 @@ interface LowercaseMapping extends Static.IMapping {
 type Lowercase = Static.Tuple<[
   Static.Const<'Lowercase'>,  Static.Const<LAngle>, Type, Static.Const<RAngle>,
 ], LowercaseMapping>
+
 // ------------------------------------------------------------------
 // Capitalize
 // ------------------------------------------------------------------
@@ -762,6 +810,7 @@ interface CapitalizeMapping extends Static.IMapping {
 type Capitalize = Static.Tuple<[
   Static.Const<'Capitalize'>,  Static.Const<LAngle>, Type, Static.Const<RAngle>,
 ], CapitalizeMapping>
+
 // ------------------------------------------------------------------
 // Uncapitalize
 // ------------------------------------------------------------------
@@ -775,10 +824,12 @@ interface UncapitalizeMapping extends Static.IMapping {
 type Uncapitalize = Static.Tuple<[
   Static.Const<'Uncapitalize'>,  Static.Const<LAngle>, Type, Static.Const<RAngle>,
 ], UncapitalizeMapping>
+
 // ------------------------------------------------------------------
 // Date
 // ------------------------------------------------------------------
 type Date = Static.Const<'Date', Static.As<t.TDate>>
+
 // ------------------------------------------------------------------
 // Uint8Array
 // ------------------------------------------------------------------

From 90979d8381716aec36d2cb600572f8b32fce35ee Mon Sep 17 00:00:00 2001
From: Lonli-Lokli <lonli.lokli@gmail.com>
Date: Mon, 17 Mar 2025 17:02:42 +0000
Subject: [PATCH 353/369] added @lonli-lokli/fetcher-typebox

---
 readme.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/readme.md b/readme.md
index fccb50e12..ed893e6b7 100644
--- a/readme.md
+++ b/readme.md
@@ -1737,6 +1737,7 @@ The following is a list of community packages that offer general tooling, extend
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
 | [typebox-cli](https://github.com/gsuess/typebox-cli) | Generate Schema with TypeBox from the CLI |
 | [typebox-form-parser](https://github.com/jtlapp/typebox-form-parser) | Parses form and query data based on TypeBox schemas |
+| [@lonli-lokli/fetcher-typebox](https://github.com/Lonli-Lokli/fetcher-ts/tree/master/packages/fetcher-typebox) | A strongly-typed fetch wrapper for TypeScript applications with optional runtime validation using TypeBox |
 
 
 <a name='benchmark'></a>

From 0d2c1f49d834e3bb2a5a51dd259d57e761785854 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Mon, 24 Mar 2025 13:37:15 +0900
Subject: [PATCH 354/369] Revision 0.34.31 (#1209)

* Use Tail Call Optimized Inference for Record Union Key

* Version

* ChangeLog

* Order Ecosystem List
---
 changelog/0.34.0.md       |  2 ++
 package-lock.json         |  4 +--
 package.json              |  2 +-
 readme.md                 |  2 +-
 src/type/record/record.ts | 14 +++++------
 test/static/record.ts     | 53 +++++++++++++++++++++++++++++++++++++++
 6 files changed, 66 insertions(+), 11 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 7b81c3920..425741b4c 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -5,6 +5,8 @@
 
 
 ### Revision Updates
+- [Revision 0.34.31](https://github.com/sinclairzx81/typebox/pull/1209)
+  - Use Tail Call Optimized Inference for Records with Large Union Keys
 - [Revision 0.34.30](https://github.com/sinclairzx81/typebox/pull/1198)
   - Additional Syntax Parsing Optimizations
 - [Revision 0.34.29](https://github.com/sinclairzx81/typebox/pull/1197)
diff --git a/package-lock.json b/package-lock.json
index abce9d2f1..17451589e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.30",
+  "version": "0.34.31",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.30",
+      "version": "0.34.31",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index ca5b738b2..013f0d344 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.30",
+  "version": "0.34.31",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/readme.md b/readme.md
index ed893e6b7..8bc45b3ca 100644
--- a/readme.md
+++ b/readme.md
@@ -1726,6 +1726,7 @@ The following is a list of community packages that offer general tooling, extend
 | [fastify-type-provider-typebox](https://github.com/fastify/fastify-type-provider-typebox) | Fastify TypeBox integration with the Fastify Type Provider |
 | [feathersjs](https://github.com/feathersjs/feathers) | The API and real-time application framework |
 | [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
+| [@lonli-lokli/fetcher-typebox](https://github.com/Lonli-Lokli/fetcher-ts/tree/master/packages/fetcher-typebox) | A strongly-typed fetch wrapper for TypeScript applications with optional runtime validation using TypeBox |
 | [h3-typebox](https://github.com/kevinmarrec/h3-typebox) | Schema validation utilities for h3 using TypeBox & Ajv |
 | [http-wizard](https://github.com/flodlc/http-wizard) | Type safe http client library for Fastify |
 | [json2typebox](https://github.com/hacxy/json2typebox) | Creating TypeBox code from Json Data |
@@ -1737,7 +1738,6 @@ The following is a list of community packages that offer general tooling, extend
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
 | [typebox-cli](https://github.com/gsuess/typebox-cli) | Generate Schema with TypeBox from the CLI |
 | [typebox-form-parser](https://github.com/jtlapp/typebox-form-parser) | Parses form and query data based on TypeBox schemas |
-| [@lonli-lokli/fetcher-typebox](https://github.com/Lonli-Lokli/fetcher-ts/tree/master/packages/fetcher-typebox) | A strongly-typed fetch wrapper for TypeScript applications with optional runtime validation using TypeBox |
 
 
 <a name='benchmark'></a>
diff --git a/src/type/record/record.ts b/src/type/record/record.ts
index f9a4fe540..c118c8ab7 100644
--- a/src/type/record/record.ts
+++ b/src/type/record/record.ts
@@ -106,15 +106,15 @@ type TFromUnionKeyLiteralString<Key extends TLiteral<string>, Type extends TSche
 // prettier-ignore
 type TFromUnionKeyLiteralNumber<Key extends TLiteral<number>, Type extends TSchema> = { [_ in Key['const']]: Type }
 // prettier-ignore
-type TFromUnionKeyRest<Keys extends TSchema[], Type extends TSchema> = 
+type TFromUnionKeyVariants<Keys extends TSchema[], Type extends TSchema, Result extends TProperties = {}> = 
   Keys extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? (
-    Left extends TUnion<infer Types extends TSchema[]> ? TFromUnionKeyRest<Types, Type> & TFromUnionKeyRest<Right, Type> :
-    Left extends TLiteral<string> ? TFromUnionKeyLiteralString<Left, Type> & TFromUnionKeyRest<Right, Type> :
-    Left extends TLiteral<number> ? TFromUnionKeyLiteralNumber<Left, Type> & TFromUnionKeyRest<Right, Type> :
-  {}) : {}
+    Left extends TUnion<infer Types extends TSchema[]> ? TFromUnionKeyVariants<Right, Type, Result & TFromUnionKeyVariants<Types, Type>> :
+    Left extends TLiteral<string> ? TFromUnionKeyVariants<Right, Type, Result & TFromUnionKeyLiteralString<Left, Type>> :
+    Left extends TLiteral<number> ? TFromUnionKeyVariants<Right, Type, Result & TFromUnionKeyLiteralNumber<Left, Type>> :
+  {}) : Result
 // prettier-ignore
-type TFromUnionKey<Key extends TSchema[], Type extends TSchema, P extends TProperties = TFromUnionKeyRest<Key, Type>> = (
-  Ensure<TObject<Evaluate<P>>>
+type TFromUnionKey<Key extends TSchema[], Type extends TSchema, Properties extends TProperties = TFromUnionKeyVariants<Key, Type>> = (
+  Ensure<TObject<Evaluate<Properties>>>
 )
 // prettier-ignore
 function FromUnionKey<Key extends TSchema[], Type extends TSchema>(key: Key, type: Type, options: ObjectOptions): TFromUnionKey<Key, Type> {
diff --git a/test/static/record.ts b/test/static/record.ts
index ab18b06b4..df66a813e 100644
--- a/test/static/record.ts
+++ b/test/static/record.ts
@@ -202,3 +202,56 @@ import { Type, Static } from '@sinclair/typebox'
   const T = Type.Record(K, Type.String())
   Expect(T).ToStatic<{}>()
 }
+// ------------------------------------------------------------------
+// Deep Union
+// https://github.com/sinclairzx81/typebox/issues/1208
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const A = Type.Record(Type.Union([
+    Type.Literal(0), Type.Literal(1), Type.Literal(2), Type.Literal(3), Type.Literal(4), Type.Literal(5), Type.Literal(6), Type.Literal(7),
+    Type.Literal(8), Type.Literal(9), Type.Literal(10), Type.Literal(11), Type.Literal(12), Type.Literal(13), Type.Literal(14), Type.Literal(15),
+    Type.Literal(16), Type.Literal(17), Type.Literal(18), Type.Literal(19), Type.Literal(20), Type.Literal(21), Type.Literal(22), Type.Literal(23),
+    Type.Literal(24), Type.Literal(25), Type.Literal(26), Type.Literal(27), Type.Literal(28), Type.Literal(29), Type.Literal(30), Type.Literal(31),
+    Type.Literal(32), Type.Literal(33), Type.Literal(34), Type.Literal(35), Type.Literal(36), Type.Literal(37), Type.Literal(38), Type.Literal(39),
+    Type.Literal(40), Type.Literal(41), Type.Literal(42), Type.Literal(43), Type.Literal(44), Type.Literal(45), Type.Literal(46), Type.Literal(47),
+    Type.Literal(48), Type.Literal(49), Type.Literal(50), Type.Literal(51), Type.Literal(52), Type.Literal(53), Type.Literal(54), Type.Literal(55),
+    Type.Literal(56), Type.Literal(57), Type.Literal(58), Type.Literal(59), Type.Literal(60), Type.Literal(61), Type.Literal(62), Type.Literal(63),  // <- x64
+    Type.Literal(64), Type.Literal(65), Type.Literal(66), Type.Literal(67), Type.Literal(68), Type.Literal(69), Type.Literal(70), Type.Literal(71),
+    Type.Literal(72), Type.Literal(73), Type.Literal(74), Type.Literal(75), Type.Literal(76), Type.Literal(77), Type.Literal(78), Type.Literal(79),
+    Type.Literal(80), Type.Literal(81), Type.Literal(82), Type.Literal(83), Type.Literal(84), Type.Literal(85), Type.Literal(86), Type.Literal(87),
+    Type.Literal(88), Type.Literal(89), Type.Literal(90), Type.Literal(91), Type.Literal(92), Type.Literal(93), Type.Literal(94), Type.Literal(95),
+    Type.Literal(96), Type.Literal(97), Type.Literal(98), Type.Literal(99), Type.Literal(100), Type.Literal(101), Type.Literal(102), Type.Literal(103),
+    Type.Literal(104), Type.Literal(105), Type.Literal(106), Type.Literal(107), Type.Literal(108), Type.Literal(109), Type.Literal(110), Type.Literal(111),
+    Type.Literal(112), Type.Literal(113), Type.Literal(114), Type.Literal(115), Type.Literal(116), Type.Literal(117), Type.Literal(118), Type.Literal(119),
+    Type.Literal(120), Type.Literal(121), Type.Literal(122), Type.Literal(123), Type.Literal(124), Type.Literal(125), Type.Literal(126), Type.Literal(127), // <- x128
+  ]), Type.String())
+  const B = Type.Record(Type.Union([
+    Type.Union([
+      Type.Literal(0), Type.Literal(1), Type.Literal(2), Type.Literal(3), Type.Literal(4), Type.Literal(5), Type.Literal(6), Type.Literal(7),
+      Type.Literal(8), Type.Literal(9), Type.Literal(10), Type.Literal(11), Type.Literal(12), Type.Literal(13), Type.Literal(14), Type.Literal(15),
+      Type.Literal(16), Type.Literal(17), Type.Literal(18), Type.Literal(19), Type.Literal(20), Type.Literal(21), Type.Literal(22), Type.Literal(23),
+      Type.Literal(24), Type.Literal(25), Type.Literal(26), Type.Literal(27), Type.Literal(28), Type.Literal(29), Type.Literal(30), Type.Literal(31),
+    ]),
+    Type.Union([
+      Type.Literal(32), Type.Literal(33), Type.Literal(34), Type.Literal(35), Type.Literal(36), Type.Literal(37), Type.Literal(38), Type.Literal(39),
+      Type.Literal(40), Type.Literal(41), Type.Literal(42), Type.Literal(43), Type.Literal(44), Type.Literal(45), Type.Literal(46), Type.Literal(47),
+      Type.Literal(48), Type.Literal(49), Type.Literal(50), Type.Literal(51), Type.Literal(52), Type.Literal(53), Type.Literal(54), Type.Literal(55),
+      Type.Literal(56), Type.Literal(57), Type.Literal(58), Type.Literal(59), Type.Literal(60), Type.Literal(61), Type.Literal(62), Type.Literal(63),  // <- x64
+    ]),
+    Type.Union([
+      Type.Literal(64), Type.Literal(65), Type.Literal(66), Type.Literal(67), Type.Literal(68), Type.Literal(69), Type.Literal(70), Type.Literal(71),
+      Type.Literal(72), Type.Literal(73), Type.Literal(74), Type.Literal(75), Type.Literal(76), Type.Literal(77), Type.Literal(78), Type.Literal(79),
+      Type.Literal(80), Type.Literal(81), Type.Literal(82), Type.Literal(83), Type.Literal(84), Type.Literal(85), Type.Literal(86), Type.Literal(87),
+      Type.Literal(88), Type.Literal(89), Type.Literal(90), Type.Literal(91), Type.Literal(92), Type.Literal(93), Type.Literal(94), Type.Literal(95),
+    ]),
+    Type.Union([
+      Type.Literal(96), Type.Literal(97), Type.Literal(98), Type.Literal(99), Type.Literal(100), Type.Literal(101), Type.Literal(102), Type.Literal(103),
+      Type.Literal(104), Type.Literal(105), Type.Literal(106), Type.Literal(107), Type.Literal(108), Type.Literal(109), Type.Literal(110), Type.Literal(111),
+      Type.Literal(112), Type.Literal(113), Type.Literal(114), Type.Literal(115), Type.Literal(116), Type.Literal(117), Type.Literal(118), Type.Literal(119),
+      Type.Literal(120), Type.Literal(121), Type.Literal(122), Type.Literal(123), Type.Literal(124), Type.Literal(125), Type.Literal(126), Type.Literal(127), // <- x128
+    ])
+  ]), Type.String())
+  type A = Static<typeof A>
+  Expect(B).ToStatic<A>()
+}

From f958156785350aa052c5f822bc2970d0945d887b Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 2 Apr 2025 17:11:45 +0900
Subject: [PATCH 355/369] Revision 0.34.32 (#1218)

* Accelerated Syntax Parser

* ChangeLog

* Version
---
 changelog/0.34.0.md   |    4 +-
 package-lock.json     |    4 +-
 package.json          |    2 +-
 src/syntax/mapping.ts | 1030 +++++++++++++++++++++++++
 src/syntax/parser.ts  | 1686 +++++++++++++++++++++++++++++++++++++++++
 src/syntax/runtime.ts |  802 --------------------
 src/syntax/static.ts  |  836 --------------------
 src/syntax/syntax.ts  |   63 +-
 8 files changed, 2736 insertions(+), 1691 deletions(-)
 create mode 100644 src/syntax/mapping.ts
 create mode 100644 src/syntax/parser.ts
 delete mode 100644 src/syntax/runtime.ts
 delete mode 100644 src/syntax/static.ts

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 425741b4c..5baecf130 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -2,9 +2,9 @@
 
 ---
 
-
-
 ### Revision Updates
+- [Revision 0.34.32](https://github.com/sinclairzx81/typebox/pull/1218)
+  - Accelerated | High Performance Syntax Parsing
 - [Revision 0.34.31](https://github.com/sinclairzx81/typebox/pull/1209)
   - Use Tail Call Optimized Inference for Records with Large Union Keys
 - [Revision 0.34.30](https://github.com/sinclairzx81/typebox/pull/1198)
diff --git a/package-lock.json b/package-lock.json
index 17451589e..c76f353fa 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.31",
+  "version": "0.34.32",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.31",
+      "version": "0.34.32",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 013f0d344..b0b1786e1 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.31",
+  "version": "0.34.32",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/syntax/mapping.ts b/src/syntax/mapping.ts
new file mode 100644
index 000000000..257435f27
--- /dev/null
+++ b/src/syntax/mapping.ts
@@ -0,0 +1,1030 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/syntax
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import * as T from '@sinclair/typebox'
+
+// ------------------------------------------------------------------
+//
+// Dereference
+//
+// Referential types pull from the Context or defer dereferencing
+// for later execution. This overlaps with module dereferencing,
+// where named identifiers in the syntax are deferred until
+// instantiation. This code should be revised as part of a
+// general-purpose Instantiate module (next revision)
+//
+// ------------------------------------------------------------------
+// prettier-ignore
+type TDereference<Context extends T.TProperties, Key extends string> = (
+  Key extends keyof Context ? Context[Key] : T.TRef<Key>
+)
+// prettier-ignore
+const Dereference = (context: T.TProperties, key: string): T.TSchema => {
+  return key in context ? context[key] : T.Ref(key)
+}
+
+// ------------------------------------------------------------------
+//
+// Delimited
+//
+// Delimited sequences use an accumulated buffer to parse sequence
+// tokens. This approach is more scalable than using a Union + Tuple
+// + Epsilon pattern, as TypeScript can instantiate deeper when
+// tail-call recursive accumulators are employed. However, this
+// comes with a latent processing cost due to the need to decode
+// the accumulated buffer.
+//
+// - Encoding: [[<Ident>, ','][], [<Ident>] | []]
+//
+// ------------------------------------------------------------------
+// prettier-ignore
+type TDelimitedDecode<Input extends ([unknown, unknown] | unknown)[], Result extends unknown[] = []> = (
+  Input extends [infer Left, ...infer Right]
+  ? Left extends [infer Item, infer _]
+  ? TDelimitedDecode<Right, [...Result, Item]>
+  : TDelimitedDecode<Right, [...Result, Left]>
+  : Result
+)
+// prettier-ignore
+type TDelimited<Input extends [unknown, unknown]> 
+  = Input extends [infer Left extends unknown[], infer Right extends unknown[]]
+  ? TDelimitedDecode<[...Left, ...Right]>
+  : []
+// prettier-ignore
+const DelimitedDecode = (input: ([unknown, unknown] | unknown)[], result: unknown[] = []) => {
+  return input.reduce<unknown[]>((result, left) => {
+    return T.ValueGuard.IsArray(left) && left.length === 2
+      ? [...result, left[0]]
+      : [...result, left]
+  }, [])
+}
+// prettier-ignore
+const Delimited = (input: [unknown, unknown]) => {
+  const [left, right] = input as [unknown[], unknown[]]
+  return DelimitedDecode([...left, ...right])
+}
+// -------------------------------------------------------------------
+// GenericReferenceParameterList: [[Type, ','][], [Type] | []]
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TGenericReferenceParameterListMapping<Input extends [unknown, unknown], Context extends T.TProperties>
+  = TDelimited<Input>
+// prettier-ignore
+export function GenericReferenceParameterListMapping(input: [unknown, unknown], context: unknown) {
+  return Delimited(input)
+}
+// -------------------------------------------------------------------
+// GenericReference: [<Ident>, '<', GenericReferenceParameterList, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TGenericReferenceMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties,
+  Result = Context extends T.TProperties
+  ? Input extends [infer Reference extends string, '<', infer Args extends T.TSchema[], '>']
+  ? T.TInstantiate<TDereference<Context, Reference>, Args>
+  : never
+  : never
+> = Result
+// prettier-ignore
+export function GenericReferenceMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const type = Dereference(context as T.TProperties, input[0] as string)
+  const args = input[2] as T.TSchema[]
+  return T.Instantiate(type, args)
+}
+// -------------------------------------------------------------------
+// GenericArgumentsList: [[<Ident>, ','][], [<Ident>] | []]
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TGenericArgumentsListMapping<Input extends [unknown, unknown], Context extends T.TProperties>
+  = TDelimited<Input>
+// prettier-ignore
+export function GenericArgumentsListMapping(input: [unknown, unknown], context: unknown) {
+  return Delimited(input)
+}
+// -------------------------------------------------------------------
+// GenericArguments: ['<', GenericArgumentsList, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+type GenericArgumentsContext<Arguments extends string[], Context extends T.TProperties, Result extends T.TProperties = {}> = (
+  Arguments extends [...infer Left extends string[], infer Right extends string]
+  ? GenericArgumentsContext<Left, Context, Result & { [_ in Right]: T.TArgument<Left['length']> }>
+  : T.Evaluate<Result & Context>
+)
+// prettier-ignore
+export type TGenericArgumentsMapping<Input extends [unknown, unknown, unknown], Context extends T.TProperties> =
+  Input extends ['<', infer Arguments extends string[], '>']
+  ? Context extends infer Context extends T.TProperties
+  ? GenericArgumentsContext<Arguments, Context>
+  : never
+  : never
+// ...
+// prettier-ignore
+const GenericArgumentsContext = (_arguments: string[], context: T.TProperties) => {
+  return _arguments.reduce((result, arg, index) => {
+    return { ...result, [arg]: T.Argument(index) }
+  }, context)
+}
+// prettier-ignore
+export function GenericArgumentsMapping(input: [unknown, unknown, unknown], context: unknown) {
+  return input.length === 3
+    ? GenericArgumentsContext(input[1] as string[], context as T.TProperties)
+    : {}
+}
+// -------------------------------------------------------------------
+// KeywordString: 'string'
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TKeywordStringMapping<Input extends 'string', Context extends T.TProperties>
+  = T.TString
+// prettier-ignore
+export function KeywordStringMapping(input: 'string', context: unknown) {
+  return T.String()
+}
+// -------------------------------------------------------------------
+// KeywordNumber: 'number'
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TKeywordNumberMapping<Input extends 'number', Context extends T.TProperties>
+  = T.TNumber
+// prettier-ignore
+export function KeywordNumberMapping(input: 'number', context: unknown) {
+  return T.Number()
+}
+// -------------------------------------------------------------------
+// KeywordBoolean: 'boolean'
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TKeywordBooleanMapping<Input extends 'boolean', Context extends T.TProperties>
+  = T.TBoolean
+// prettier-ignore
+export function KeywordBooleanMapping(input: 'boolean', context: unknown) {
+  return T.Boolean()
+}
+// -------------------------------------------------------------------
+// KeywordUndefined: 'undefined'
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TKeywordUndefinedMapping<Input extends 'undefined', Context extends T.TProperties>
+  = T.TUndefined
+// prettier-ignore
+export function KeywordUndefinedMapping(input: 'undefined', context: unknown) {
+  return T.Undefined()
+}
+// -------------------------------------------------------------------
+// KeywordNull: 'null'
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TKeywordNullMapping<Input extends 'null', Context extends T.TProperties>
+  = T.TNull
+// prettier-ignore
+export function KeywordNullMapping(input: 'null', context: unknown) {
+  return T.Null()
+}
+// -------------------------------------------------------------------
+// KeywordInteger: 'integer'
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TKeywordIntegerMapping<Input extends 'integer', Context extends T.TProperties>
+  = T.TInteger
+// prettier-ignore
+export function KeywordIntegerMapping(input: 'integer', context: unknown) {
+  return T.Integer()
+}
+// -------------------------------------------------------------------
+// KeywordBigInt: 'bigint'
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TKeywordBigIntMapping<Input extends 'bigint', Context extends T.TProperties>
+  = T.TBigInt
+// prettier-ignore
+export function KeywordBigIntMapping(input: 'bigint', context: unknown) {
+  return T.BigInt()
+}
+// -------------------------------------------------------------------
+// KeywordUnknown: 'unknown'
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TKeywordUnknownMapping<Input extends 'unknown', Context extends T.TProperties>
+  = T.TUnknown
+// prettier-ignore
+export function KeywordUnknownMapping(input: 'unknown', context: unknown) {
+  return T.Unknown()
+}
+// -------------------------------------------------------------------
+// KeywordAny: 'any'
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TKeywordAnyMapping<Input extends 'any', Context extends T.TProperties>
+  = T.TAny
+// prettier-ignore
+export function KeywordAnyMapping(input: 'any', context: unknown) {
+  return T.Any()
+}
+// -------------------------------------------------------------------
+// KeywordNever: 'never'
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TKeywordNeverMapping<Input extends 'never', Context extends T.TProperties>
+  = T.TNever
+// prettier-ignore
+export function KeywordNeverMapping(input: 'never', context: unknown) {
+  return T.Never()
+}
+// -------------------------------------------------------------------
+// KeywordSymbol: 'symbol'
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TKeywordSymbolMapping<Input extends 'symbol', Context extends T.TProperties>
+  = T.TSymbol
+// prettier-ignore
+export function KeywordSymbolMapping(input: 'symbol', context: unknown) {
+  return T.Symbol()
+}
+// -------------------------------------------------------------------
+// KeywordVoid: 'void'
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TKeywordVoidMapping<Input extends 'void', Context extends T.TProperties>
+  = T.TVoid
+// prettier-ignore
+export function KeywordVoidMapping(input: 'void', context: unknown) {
+  return T.Void()
+}
+// -------------------------------------------------------------------
+// Keyword: KeywordString | KeywordNumber | KeywordBoolean | KeywordUndefined | KeywordNull | KeywordInteger | KeywordBigInt | KeywordUnknown | KeywordAny | KeywordNever | KeywordSymbol | KeywordVoid
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TKeywordMapping<Input extends unknown, Context extends T.TProperties>
+  = Input
+// prettier-ignore
+export function KeywordMapping(input: unknown, context: unknown) {
+  return input
+}
+// -------------------------------------------------------------------
+// LiteralString: <String>
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TLiteralStringMapping<Input extends string, Context extends T.TProperties> = 
+  Input extends T.TLiteralValue ? T.TLiteral<Input> : never
+// prettier-ignore
+export function LiteralStringMapping(input: string, context: unknown) {
+  return T.Literal(input)
+}
+// -------------------------------------------------------------------
+// LiteralNumber: <Number>
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TLiteralNumberMapping<Input extends string, Context extends T.TProperties> =
+  Input extends `${infer Value extends number}` ? T.TLiteral<Value> : never
+// prettier-ignore
+export function LiteralNumberMapping(input: string, context: unknown) {
+  return T.Literal(parseFloat(input))
+}
+// -------------------------------------------------------------------
+// LiteralBoolean: 'true' | 'false'
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TLiteralBooleanMapping<Input extends 'true' | 'false', Context extends T.TProperties> 
+  = Input extends 'true' ? T.TLiteral<true> : T.TLiteral<false>
+// prettier-ignore
+export function LiteralBooleanMapping(input: 'true' | 'false', context: unknown) {
+  return T.Literal(input === 'true')
+}
+// -------------------------------------------------------------------
+// Literal: LiteralBoolean | LiteralNumber | LiteralString
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TLiteralMapping<Input extends unknown, Context extends T.TProperties>
+  = Input
+// prettier-ignore
+export function LiteralMapping(input: unknown, context: unknown) {
+  return input
+}
+// -------------------------------------------------------------------
+// KeyOf: ['keyof'] | []
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TKeyOfMapping<Input extends [unknown] | [], Context extends T.TProperties>
+  = Input extends [unknown] ? true : false
+// prettier-ignore
+export function KeyOfMapping(input: [unknown] | [], context: unknown) {
+  return input.length > 0
+}
+// -------------------------------------------------------------------
+// IndexArray: ['[', Type, ']'] | ['[', ']'][]
+// -------------------------------------------------------------------
+// prettier-ignore
+type TIndexArrayMappingReduce<Input extends unknown[], Result extends unknown[] = []> = (
+  Input extends [infer Left extends unknown, ...infer Right extends unknown[]]
+  ? Left extends ['[', infer Type extends T.TSchema, ']']
+  ? TIndexArrayMappingReduce<Right, [...Result, [Type]]>
+  : TIndexArrayMappingReduce<Right, [...Result, []]>
+  : Result
+)
+// prettier-ignore
+export type TIndexArrayMapping<Input extends ([unknown, unknown, unknown] | [unknown, unknown])[], Context extends T.TProperties>
+  = Input extends unknown[]
+  ? TIndexArrayMappingReduce<Input>
+  : []
+// prettier-ignore
+export function IndexArrayMapping(input: ([unknown, unknown, unknown] | [unknown, unknown])[], context: unknown) {
+  return input.reduce((result: unknown[], current) => {
+    return current.length === 3
+      ? [...result, [current[1]]]
+      : [...result, []]
+  }, [] as unknown[])
+}
+// -------------------------------------------------------------------
+// Extends: ['extends', Type, '?', Type, ':', Type] | []
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TExtendsMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown] | [], Context extends T.TProperties>
+  = Input extends ['extends', infer Type extends T.TSchema, '?', infer True extends T.TSchema, ':', infer False extends T.TSchema]
+  ? [Type, True, False]
+  : []
+// prettier-ignore
+export function ExtendsMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown] | [], context: unknown) {
+  return input.length === 6
+    ? [input[1], input[3], input[5]]
+    : []
+}
+// -------------------------------------------------------------------
+// Base: ['(', Type, ')'] | Keyword | Object | Tuple | Literal | Constructor | Function | Mapped | AsyncIterator | Iterator | ConstructorParameters | FunctionParameters | InstanceType | ReturnType | Argument | Awaited | Array | Record | Promise | Partial | Required | Pick | Omit | Exclude | Extract | Uppercase | Lowercase | Capitalize | Uncapitalize | Date | Uint8Array | GenericReference | Reference
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TBaseMapping<Input extends [unknown, unknown, unknown] | unknown, Context extends T.TProperties> = (
+  Input extends ['(', infer Type extends T.TSchema, ')'] ? Type :
+  Input extends infer Type extends T.TSchema ? Type :
+  never
+)
+// prettier-ignore
+export function BaseMapping(input: [unknown, unknown, unknown] | unknown, context: unknown) {
+  return T.ValueGuard.IsArray(input) && input.length === 3 ? input[1] : input
+}
+// -------------------------------------------------------------------
+// Factor: [KeyOf, Base, IndexArray, Extends]
+// -------------------------------------------------------------------
+// prettier-ignore
+type TFactorIndexArray<Type extends T.TSchema, IndexArray extends unknown[]> = (
+  IndexArray extends [...infer Left extends unknown[], infer Right extends T.TSchema[]] ? (
+    Right extends [infer Indexer extends T.TSchema] ? T.TIndex<TFactorIndexArray<Type, Left>, T.TIndexPropertyKeys<Indexer>> :
+    Right extends [] ? T.TArray<TFactorIndexArray<Type, Left>> :
+    T.TNever
+  ) : Type
+)
+// prettier-ignore
+type TFactorExtends<Type extends T.TSchema, Extends extends unknown[]> = (
+  Extends extends [infer Right extends T.TSchema, infer True extends T.TSchema, infer False extends T.TSchema]
+  ? T.TExtends<Type, Right, True, False>
+  : Type
+)
+// prettier-ignore
+export type TFactorMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> =
+  Input extends [infer KeyOf extends boolean, infer Type extends T.TSchema, infer IndexArray extends unknown[], infer Extends extends unknown[]]
+  ? KeyOf extends true
+  ? TFactorExtends<T.TKeyOf<TFactorIndexArray<Type, IndexArray>>, Extends>
+  : TFactorExtends<TFactorIndexArray<Type, IndexArray>, Extends>
+  : never
+
+// ...
+// prettier-ignore
+const FactorIndexArray = (Type: T.TSchema, indexArray: unknown[]): T.TSchema => {
+  return indexArray.reduceRight<T.TSchema>((result, right) => {
+    const _right = right as T.TSchema[]
+    return (
+      _right.length === 1 ? T.Index(result, _right[0]) :
+      _right.length === 0 ? T.Array(result, _right[0]) :
+      T.Never()
+    )
+  }, Type)
+}
+// prettier-ignore
+const FactorExtends = (Type: T.TSchema, Extends: T.TSchema[]) => {
+  return Extends.length === 3
+    ? T.Extends(Type, Extends[0], Extends[1], Extends[2])
+    : Type
+}
+// prettier-ignore
+export function FactorMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const [KeyOf, Type, IndexArray, Extends] = input as [boolean, T.TSchema, unknown[], T.TSchema[]]
+  return KeyOf
+    ? FactorExtends(T.KeyOf(FactorIndexArray(Type, IndexArray)), Extends)
+    : FactorExtends(FactorIndexArray(Type, IndexArray), Extends)
+}
+
+// ------------------------------------------------------------------
+//
+// ExprBinaryMapping
+//
+// TypeBox Union and Intersection types are flattened to prevent
+// excessive nesting of `anyOf` and `allOf`, ensuring a more
+// readable and presentable type for the user. This function
+// recursively reduces Union and Intersection types based on
+// binary expressions parsed from input.
+//
+// ------------------------------------------------------------------
+// prettier-ignore
+type TExprBinaryMapping<Left extends T.TSchema, Rest extends unknown[]> = (
+  Rest extends [infer Operator extends unknown, infer Right extends T.TSchema, infer Next extends unknown[]] ? (
+    TExprBinaryMapping<Right, Next> extends infer Schema extends T.TSchema ? (
+      Operator extends '&' ? (
+        Schema extends T.TIntersect<infer Types extends T.TSchema[]>
+        ? T.TIntersect<[Left, ...Types]>
+        : T.TIntersect<[Left, Schema]>
+      ) :
+      Operator extends '|' ? (
+        Schema extends T.TUnion<infer Types extends T.TSchema[]>
+        ? T.TUnion<[Left, ...Types]>
+        : T.TUnion<[Left, Schema]>
+      ) : never
+    ) : never
+  ) : Left
+)
+// prettier-ignore
+function ExprBinaryMapping(Left: T.TSchema, Rest: unknown[]): T.TSchema {
+  return (
+    Rest.length === 3 ? (() => {
+      const [Operator, Right, Next] = Rest as [string, T.TSchema, unknown[]]
+      const Schema = ExprBinaryMapping(Right, Next)
+      if (Operator === '&') {
+        return T.TypeGuard.IsIntersect(Schema)
+          ? T.Intersect([Left, ...Schema.allOf])
+          : T.Intersect([Left, Schema])
+      }
+      if (Operator === '|') {
+        return T.TypeGuard.IsUnion(Schema)
+          ? T.Union([Left, ...Schema.anyOf])
+          : T.Union([Left, Schema])
+      }
+      throw 1
+    })() : Left
+  )
+}
+// -------------------------------------------------------------------
+// ExprTermTail: ['&', Factor, ExprTermTail] | []
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TExprTermTailMapping<Input extends [unknown, unknown, unknown] | [], Context extends T.TProperties>
+  = Input
+// prettier-ignore
+export function ExprTermTailMapping(input: [unknown, unknown, unknown] | [], context: unknown) {
+  return input
+}
+// -------------------------------------------------------------------
+// ExprTerm: [Factor, ExprTermTail]
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TExprTermMapping<Input extends [unknown, unknown], Context extends T.TProperties> = (
+  Input extends [infer Left extends T.TSchema, infer Rest extends unknown[]]
+  ? TExprBinaryMapping<Left, Rest>
+  : []
+)
+// prettier-ignore
+export function ExprTermMapping(input: [unknown, unknown], context: unknown) {
+  const [left, rest] = input as [T.TSchema, unknown[]]
+  return ExprBinaryMapping(left, rest)
+}
+// -------------------------------------------------------------------
+// ExprTail: ['|', ExprTerm, ExprTail] | []
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TExprTailMapping<Input extends [unknown, unknown, unknown] | [], Context extends T.TProperties>
+  = Input
+// prettier-ignore
+export function ExprTailMapping(input: [unknown, unknown, unknown] | [], context: unknown) {
+  return input
+}
+// -------------------------------------------------------------------
+// Expr: [ExprTerm, ExprTail]
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TExprMapping<Input extends [unknown, unknown], Context extends T.TProperties>
+  = Input extends [infer Left extends T.TSchema, infer Rest extends unknown[]]
+  ? TExprBinaryMapping<Left, Rest>
+  : []
+// prettier-ignore
+export function ExprMapping(input: [unknown, unknown], context: unknown) {
+  const [left, rest] = input as [T.TSchema, unknown[]]
+  return ExprBinaryMapping(left, rest)
+}
+// -------------------------------------------------------------------
+// Type: GenericArguments -> Expr | Expr
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TTypeMapping<Input extends unknown, Context extends T.TProperties>
+  = Input
+// prettier-ignore
+export function TypeMapping(input: unknown, context: unknown) {
+  return input
+}
+// -------------------------------------------------------------------
+// PropertyKey: <Ident> | <String>
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TPropertyKeyMapping<Input extends string, Context extends T.TProperties>
+  = Input
+// prettier-ignore
+export function PropertyKeyMapping(input: string, context: unknown) {
+  return input
+}
+// -------------------------------------------------------------------
+// Readonly: ['readonly'] | []
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TReadonlyMapping<Input extends [unknown] | [], Context extends T.TProperties>
+  = Input extends [unknown] ? true : false
+// prettier-ignore
+export function ReadonlyMapping(input: [unknown] | [], context: unknown) {
+  return input.length > 0
+}
+// -------------------------------------------------------------------
+// Optional: ['?'] | []
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TOptionalMapping<Input extends [unknown] | [], Context extends T.TProperties>
+  = Input extends [unknown] ? true : false
+// prettier-ignore
+export function OptionalMapping(input: [unknown] | [], context: unknown) {
+  return input.length > 0
+}
+// -------------------------------------------------------------------
+// Property: [Readonly, PropertyKey, Optional, ':', Type]
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TPropertyMapping<Input extends [unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends [infer IsReadonly extends boolean, infer Key extends string, infer IsOptional extends boolean, string, infer Type extends T.TSchema] ? {
+    [_ in Key]: (
+      [IsReadonly, IsOptional] extends [true, true] ? T.TReadonlyOptional<Type> :
+      [IsReadonly, IsOptional] extends [true, false] ? T.TReadonly<Type> :
+      [IsReadonly, IsOptional] extends [false, true] ? T.TOptional<Type> :
+      Type
+    )
+  } : never
+// prettier-ignore
+export function PropertyMapping(input: [unknown, unknown, unknown, unknown, unknown], context: unknown) {
+  const [isReadonly, key, isOptional, _colon, type] = input as [boolean, string, boolean, ':', T.TSchema]
+  return {
+    [key]: (
+      isReadonly && isOptional ? T.ReadonlyOptional(type) :
+      isReadonly && !isOptional ? T.Readonly(type) :
+      !isReadonly && isOptional ? T.Optional(type) :
+      type
+    )
+  }
+}
+// -------------------------------------------------------------------
+// PropertyDelimiter: [',', '\n'] | [';', '\n'] | [','] | [';'] | ['\n']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TPropertyDelimiterMapping<Input extends [unknown, unknown] | [unknown], Context extends T.TProperties>
+  = Input
+// prettier-ignore
+export function PropertyDelimiterMapping(input: [unknown, unknown] | [unknown], context: unknown) {
+  return input
+}
+// -------------------------------------------------------------------
+// PropertyList: [[Property, PropertyDelimiter][], [Property] | []]
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TPropertyListMapping<Input extends [unknown, unknown], Context extends T.TProperties>
+  = TDelimited<Input>
+// prettier-ignore
+export function PropertyListMapping(input: [unknown, unknown], context: unknown) {
+  return Delimited(input)
+}
+// -------------------------------------------------------------------
+// Object: ['{', PropertyList, '}']
+// -------------------------------------------------------------------
+// prettier-ignore
+type TObjectMappingReduce<PropertiesList extends T.TProperties[], Result extends T.TProperties = {}> = (
+  PropertiesList extends [infer Left extends T.TProperties, ...infer Right extends T.TProperties[]]
+  ? TObjectMappingReduce<Right, Result & Left>
+  : { [Key in keyof Result]: Result[Key] }
+)
+// prettier-ignore
+export type TObjectMapping<Input extends [unknown, unknown, unknown], Context extends T.TProperties> =
+  Input extends ['{', infer PropertyList extends T.TProperties[], '}']
+  ? T.TObject<TObjectMappingReduce<PropertyList>>
+  : never
+// prettier-ignore
+export function ObjectMapping(input: [unknown, unknown, unknown], context: unknown) {
+  const propertyList = input[1] as T.TProperties[]
+  return T.Object(propertyList.reduce((result, property) => {
+    return { ...result, ...property }
+  }, {} as T.TProperties))
+}
+// -------------------------------------------------------------------
+// ElementList: [[Type, ','][], [Type] | []]
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TElementListMapping<Input extends [unknown, unknown], Context extends T.TProperties>
+  = TDelimited<Input>
+// prettier-ignore
+export function ElementListMapping(input: [unknown, unknown], context: unknown) {
+  return Delimited(input)
+}
+// -------------------------------------------------------------------
+// Tuple: ['[', ElementList, ']']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TTupleMapping<Input extends [unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['[', infer Types extends T.TSchema[], ']'] ? T.TTuple<Types> : never
+// prettier-ignore
+export function TupleMapping(input: [unknown, unknown, unknown], context: unknown) {
+  return T.Tuple(input[1] as T.TSchema[])
+}
+// -------------------------------------------------------------------
+// Parameter: [<Ident>, ':', Type]
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TParameterMapping<Input extends [unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends [string, ':', infer Type extends T.TSchema] ? Type : never
+// prettier-ignore
+export function ParameterMapping(input: [unknown, unknown, unknown], context: unknown) {
+  const [_ident, _colon, type] = input as [string, ':', T.TSchema]
+  return type
+}
+// -------------------------------------------------------------------
+// ParameterList: [[Parameter, ','][], [Parameter] | []]
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TParameterListMapping<Input extends [unknown, unknown], Context extends T.TProperties>
+  = TDelimited<Input>
+// prettier-ignore
+export function ParameterListMapping(input: [unknown, unknown], context: unknown) {
+  return Delimited(input)
+}
+// -------------------------------------------------------------------
+// Function: ['(', ParameterList, ')', '=>', Type]
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TFunctionMapping<Input extends [unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['(', infer ParameterList extends T.TSchema[], ')', '=>', infer ReturnType extends T.TSchema]
+  ? T.TFunction<ParameterList, ReturnType>
+  : never
+// prettier-ignore
+export function FunctionMapping(input: [unknown, unknown, unknown, unknown, unknown], context: unknown) {
+  const [_lparan, parameterList, _rparan, _arrow, returnType] = input as ['(', T.TSchema[], ')', '=>', T.TSchema]
+  return T.Function(parameterList, returnType)
+}
+// -------------------------------------------------------------------
+// Constructor: ['new', '(', ParameterList, ')', '=>', Type]
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TConstructorMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['new', '(', infer ParameterList extends T.TSchema[], ')', '=>', infer InstanceType extends T.TSchema]
+  ? T.TConstructor<ParameterList, InstanceType>
+  : never
+// prettier-ignore
+export function ConstructorMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown) {
+  const [_new, _lparan, parameterList, _rparan, _arrow, instanceType] = input as ['new', '(', T.TSchema[], ')', '=>', T.TSchema]
+  return T.Constructor(parameterList, instanceType)
+}
+// -------------------------------------------------------------------
+// Mapped: ['{', '[', <Ident>, 'in', Type, ']', ':', Type, '}']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TMappedMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['{', '[', infer _Key extends string, 'in', infer _Right extends T.TSchema, ']', ':', infer _Type extends T.TSchema, '}']
+  ? T.TLiteral<'Mapped types not supported'>
+  : never
+// prettier-ignore
+export function MappedMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown], context: unknown) {
+  const [_lbrace, _lbracket, _key, _in, _right, _rbracket, _colon, _type] = input as ['{', '[', string, 'in', T.TSchema, ']', ':', T.TSchema, '}']
+  return T.Literal('Mapped types not supported')
+}
+// -------------------------------------------------------------------
+// AsyncIterator: ['AsyncIterator', '<', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TAsyncIteratorMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['AsyncIterator', '<', infer Type extends T.TSchema, '>']
+  ? T.TAsyncIterator<Type>
+  : never
+// prettier-ignore
+export function AsyncIteratorMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, type, _rangle] = input as ['AsyncIterator', '<', T.TSchema, '>']
+  return T.AsyncIterator(type)
+}
+// -------------------------------------------------------------------
+// Iterator: ['Iterator', '<', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TIteratorMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Iterator', '<', infer Type extends T.TSchema, '>']
+  ? T.TIterator<Type>
+  : never
+// prettier-ignore
+export function IteratorMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, type, _rangle] = input as ['Iterator', '<', T.TSchema, '>']
+  return T.Iterator(type)
+}
+// -------------------------------------------------------------------
+// Argument: ['Argument', '<', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TArgumentMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Argument', '<', infer Type extends T.TSchema, '>']
+  ? Type extends T.TLiteral<infer Index extends number>
+  ? T.TArgument<Index>
+  : T.TNever
+  : never
+// prettier-ignore
+export function ArgumentMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  return T.KindGuard.IsLiteralNumber(input[2])
+    ? T.Argument(Math.trunc(input[2].const))
+    : T.Never()
+}
+// -------------------------------------------------------------------
+// Awaited: ['Awaited', '<', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TAwaitedMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Awaited', '<', infer Type extends T.TSchema, '>']
+  ? T.TAwaited<Type>
+  : never
+// prettier-ignore
+export function AwaitedMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, type, _rangle] = input as ['Awaited', '<', T.TSchema, '>']
+  return T.Awaited(type)
+}
+// -------------------------------------------------------------------
+// Array: ['Array', '<', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TArrayMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Array', '<', infer Type extends T.TSchema, '>']
+  ? T.TArray<Type>
+  : never
+// prettier-ignore
+export function ArrayMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, type, _rangle] = input as ['Array', '<', T.TSchema, '>']
+  return T.Array(type)
+}
+// -------------------------------------------------------------------
+// Record: ['Record', '<', Type, ',', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TRecordMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Record', '<', infer Key extends T.TSchema, ',', infer Type extends T.TSchema, '>']
+  ? T.TRecordOrObject<Key, Type>
+  : never
+// prettier-ignore
+export function RecordMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, key, _comma, type, _rangle] = input as ['Record', '<', T.TSchema, ',', T.TSchema, '>']
+  return T.Record(key, type)
+}
+// -------------------------------------------------------------------
+// Promise: ['Promise', '<', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TPromiseMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Promise', '<', infer Type extends T.TSchema, '>']
+  ? T.TPromise<Type>
+  : never
+// prettier-ignore
+export function PromiseMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, type, _rangle] = input as ['Promise', '<', T.TSchema, '>']
+  return T.Promise(type)
+}
+// -------------------------------------------------------------------
+// ConstructorParameters: ['ConstructorParameters', '<', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TConstructorParametersMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['ConstructorParameters', '<', infer Type extends T.TSchema, '>']
+  ? T.TConstructorParameters<Type>
+  : never
+// prettier-ignore
+export function ConstructorParametersMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, type, _rangle] = input as ['ConstructorParameters', '<', T.TSchema, '>']
+  return T.ConstructorParameters(type)
+}
+// -------------------------------------------------------------------
+// FunctionParameters: ['Parameters', '<', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TFunctionParametersMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Parameters', '<', infer Type extends T.TSchema, '>']
+  ? T.TParameters<Type>
+  : never
+// prettier-ignore
+export function FunctionParametersMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, type, _rangle] = input as ['Parameters', '<', T.TSchema, '>']
+  return T.Parameters(type)
+}
+// -------------------------------------------------------------------
+// InstanceType: ['InstanceType', '<', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TInstanceTypeMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['InstanceType', '<', infer Type extends T.TSchema, '>']
+  ? T.TInstanceType<Type>
+  : never
+// prettier-ignore
+export function InstanceTypeMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, type, _rangle] = input as ['InstanceType', '<', T.TSchema, '>']
+  return T.InstanceType(type)
+}
+// -------------------------------------------------------------------
+// ReturnType: ['ReturnType', '<', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TReturnTypeMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['ReturnType', '<', infer Type extends T.TSchema, '>']
+  ? T.TReturnType<Type>
+  : never
+// prettier-ignore
+export function ReturnTypeMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, type, _rangle] = input as ['ReturnType', '<', T.TSchema, '>']
+  return T.ReturnType(type)
+}
+// -------------------------------------------------------------------
+// Partial: ['Partial', '<', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TPartialMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Partial', '<', infer Type extends T.TSchema, '>']
+  ? T.TPartial<Type>
+  : never
+// prettier-ignore
+export function PartialMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, type, _rangle] = input as ['Partial', '<', T.TSchema, '>']
+  return T.Partial(type)
+}
+// -------------------------------------------------------------------
+// Required: ['Required', '<', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TRequiredMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Required', '<', infer Type extends T.TSchema, '>']
+  ? T.TRequired<Type>
+  : never
+// prettier-ignore
+export function RequiredMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, type, _rangle] = input as ['Required', '<', T.TSchema, '>']
+  return T.Required(type)
+}
+// -------------------------------------------------------------------
+// Pick: ['Pick', '<', Type, ',', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TPickMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Pick', '<', infer Type extends T.TSchema, ',', infer Key extends T.TSchema, '>']
+  ? T.TPick<Type, Key>
+  : never
+// prettier-ignore
+export function PickMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, key, _comma, type, _rangle] = input as ['Pick', '<', T.TSchema, ',', T.TSchema, '>']
+  return T.Pick(key, type)
+}
+// -------------------------------------------------------------------
+// Omit: ['Omit', '<', Type, ',', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TOmitMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Omit', '<', infer Type extends T.TSchema, ',', infer Key extends T.TSchema, '>']
+  ? T.TOmit<Type, Key>
+  : never
+// prettier-ignore
+export function OmitMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, key, _comma, type, _rangle] = input as ['Omit', '<', T.TSchema, ',', T.TSchema, '>']
+  return T.Omit(key, type)
+}
+// -------------------------------------------------------------------
+// Exclude: ['Exclude', '<', Type, ',', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TExcludeMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Exclude', '<', infer Type extends T.TSchema, ',', infer Key extends T.TSchema, '>']
+  ? T.TExclude<Type, Key>
+  : never
+// prettier-ignore
+export function ExcludeMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, key, _comma, type, _rangle] = input as ['Exclude', '<', T.TSchema, ',', T.TSchema, '>']
+  return T.Exclude(key, type)
+}
+// -------------------------------------------------------------------
+// Extract: ['Extract', '<', Type, ',', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TExtractMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Extract', '<', infer Type extends T.TSchema, ',', infer Key extends T.TSchema, '>']
+  ? T.TExtract<Type, Key>
+  : never
+// prettier-ignore
+export function ExtractMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, key, _comma, type, _rangle] = input as ['Extract', '<', T.TSchema, ',', T.TSchema, '>']
+  return T.Extract(key, type)
+}
+// -------------------------------------------------------------------
+// Uppercase: ['Uppercase', '<', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TUppercaseMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Uppercase', '<', infer Type extends T.TSchema, '>']
+  ? T.TUppercase<Type>
+  : never
+// prettier-ignore
+export function UppercaseMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, type, _rangle] = input as ['Uppercase', '<', T.TSchema, '>']
+  return T.Uppercase(type)
+}
+// -------------------------------------------------------------------
+// Lowercase: ['Lowercase', '<', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TLowercaseMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Lowercase', '<', infer Type extends T.TSchema, '>']
+  ? T.TLowercase<Type>
+  : never
+// prettier-ignore
+export function LowercaseMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, type, _rangle] = input as ['Lowercase', '<', T.TSchema, '>']
+  return T.Lowercase(type)
+}
+// -------------------------------------------------------------------
+// Capitalize: ['Capitalize', '<', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TCapitalizeMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Capitalize', '<', infer Type extends T.TSchema, '>']
+  ? T.TCapitalize<Type>
+  : never
+// prettier-ignore
+export function CapitalizeMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, type, _rangle] = input as ['Capitalize', '<', T.TSchema, '>']
+  return T.Capitalize(type)
+}
+// -------------------------------------------------------------------
+// Uncapitalize: ['Uncapitalize', '<', Type, '>']
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TUncapitalizeMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
+  = Input extends ['Uncapitalize', '<', infer Type extends T.TSchema, '>']
+  ? T.TUncapitalize<Type>
+  : never
+// prettier-ignore
+export function UncapitalizeMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
+  const [_name, _langle, type, _rangle] = input as ['Uncapitalize', '<', T.TSchema, '>']
+  return T.Uncapitalize(type)
+}
+// -------------------------------------------------------------------
+// Date: 'Date'
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TDateMapping<Input extends 'Date', Context extends T.TProperties>
+  = T.TDate
+// prettier-ignore
+export function DateMapping(input: 'Date', context: unknown) {
+  return T.Date()
+}
+// -------------------------------------------------------------------
+// Uint8Array: 'Uint8Array'
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TUint8ArrayMapping<Input extends 'Uint8Array', Context extends T.TProperties>
+  = T.TUint8Array
+// prettier-ignore
+export function Uint8ArrayMapping(input: 'Uint8Array', context: unknown) {
+  return T.Uint8Array()
+}
+// -------------------------------------------------------------------
+// Reference: <Ident>
+// -------------------------------------------------------------------
+// prettier-ignore
+export type TReferenceMapping<Input extends string, Context extends T.TProperties> 
+  = Context extends T.TProperties
+      ? Input extends string
+        ? TDereference<Context, Input>
+        : never
+      : never
+// prettier-ignore
+export function ReferenceMapping(input: string, context: unknown) {
+  const target = Dereference(context as T.TProperties, input)
+  return target
+}
diff --git a/src/syntax/parser.ts b/src/syntax/parser.ts
new file mode 100644
index 000000000..6787f8588
--- /dev/null
+++ b/src/syntax/parser.ts
@@ -0,0 +1,1686 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/syntax
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+import { Runtime, Static } from '../parser/index'
+import * as T from '../type/index'
+import * as S from './mapping'
+
+// ------------------------------------------------------------------
+// Parser
+//
+// The following code is optimized inline types generated by a remote
+// compiler process. It is readonly and should not be modified.
+// ------------------------------------------------------------------
+
+export type TGenericReferenceParameterList_0<Input extends string, Context extends T.TProperties, Result extends unknown[] = []> = (
+  TType<Input, Context> extends [infer _0, infer Input extends string] ? (Static.Token.Const<',', Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []
+) extends [infer _0, infer Input extends string]
+  ? TGenericReferenceParameterList_0<Input, Context, [...Result, _0]>
+  : [Result, Input]
+export type TGenericReferenceParameterList<Input extends string, Context extends T.TProperties = {}> = (
+  TGenericReferenceParameterList_0<Input, Context> extends [infer _0, infer Input extends string]
+    ? (
+        (TType<Input, Context> extends [infer _0, infer Input extends string] ? [[_0], Input] : []) extends [infer _0, infer Input extends string] ? [_0, Input] : [[], Input] extends [infer _0, infer Input extends string] ? [_0, Input] : []
+      ) extends [infer _1, infer Input extends string]
+      ? [[_0, _1], Input]
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown], infer Input extends string]
+  ? [S.TGenericReferenceParameterListMapping<_0, Context>, Input]
+  : []
+export type TGenericReference<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Ident<Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TGenericReferenceParameterList<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TGenericReferenceMapping<_0, Context>, Input]
+  : []
+export type TGenericArgumentsList_0<Input extends string, Context extends T.TProperties, Result extends unknown[] = []> = (
+  Static.Token.Ident<Input> extends [infer _0, infer Input extends string] ? (Static.Token.Const<',', Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []
+) extends [infer _0, infer Input extends string]
+  ? TGenericArgumentsList_0<Input, Context, [...Result, _0]>
+  : [Result, Input]
+export type TGenericArgumentsList<Input extends string, Context extends T.TProperties = {}> = (
+  TGenericArgumentsList_0<Input, Context> extends [infer _0, infer Input extends string]
+    ? (
+        (Static.Token.Ident<Input> extends [infer _0, infer Input extends string] ? [[_0], Input] : []) extends [infer _0, infer Input extends string]
+          ? [_0, Input]
+          : [[], Input] extends [infer _0, infer Input extends string]
+          ? [_0, Input]
+          : []
+      ) extends [infer _1, infer Input extends string]
+      ? [[_0, _1], Input]
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown], infer Input extends string]
+  ? [S.TGenericArgumentsListMapping<_0, Context>, Input]
+  : []
+export type TGenericArguments<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'<', Input> extends [infer _0, infer Input extends string]
+    ? TGenericArgumentsList<Input, Context> extends [infer _1, infer Input extends string]
+      ? Static.Token.Const<'>', Input> extends [infer _2, infer Input extends string]
+        ? [[_0, _1, _2], Input]
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown], infer Input extends string]
+  ? [S.TGenericArgumentsMapping<_0, Context>, Input]
+  : []
+export type TKeywordString<Input extends string, Context extends T.TProperties = {}> = Static.Token.Const<'string', Input> extends [infer _0 extends 'string', infer Input extends string] ? [S.TKeywordStringMapping<_0, Context>, Input] : []
+export type TKeywordNumber<Input extends string, Context extends T.TProperties = {}> = Static.Token.Const<'number', Input> extends [infer _0 extends 'number', infer Input extends string] ? [S.TKeywordNumberMapping<_0, Context>, Input] : []
+export type TKeywordBoolean<Input extends string, Context extends T.TProperties = {}> = Static.Token.Const<'boolean', Input> extends [infer _0 extends 'boolean', infer Input extends string]
+  ? [S.TKeywordBooleanMapping<_0, Context>, Input]
+  : []
+export type TKeywordUndefined<Input extends string, Context extends T.TProperties = {}> = Static.Token.Const<'undefined', Input> extends [infer _0 extends 'undefined', infer Input extends string]
+  ? [S.TKeywordUndefinedMapping<_0, Context>, Input]
+  : []
+export type TKeywordNull<Input extends string, Context extends T.TProperties = {}> = Static.Token.Const<'null', Input> extends [infer _0 extends 'null', infer Input extends string] ? [S.TKeywordNullMapping<_0, Context>, Input] : []
+export type TKeywordInteger<Input extends string, Context extends T.TProperties = {}> = Static.Token.Const<'integer', Input> extends [infer _0 extends 'integer', infer Input extends string]
+  ? [S.TKeywordIntegerMapping<_0, Context>, Input]
+  : []
+export type TKeywordBigInt<Input extends string, Context extends T.TProperties = {}> = Static.Token.Const<'bigint', Input> extends [infer _0 extends 'bigint', infer Input extends string] ? [S.TKeywordBigIntMapping<_0, Context>, Input] : []
+export type TKeywordUnknown<Input extends string, Context extends T.TProperties = {}> = Static.Token.Const<'unknown', Input> extends [infer _0 extends 'unknown', infer Input extends string]
+  ? [S.TKeywordUnknownMapping<_0, Context>, Input]
+  : []
+export type TKeywordAny<Input extends string, Context extends T.TProperties = {}> = Static.Token.Const<'any', Input> extends [infer _0 extends 'any', infer Input extends string] ? [S.TKeywordAnyMapping<_0, Context>, Input] : []
+export type TKeywordNever<Input extends string, Context extends T.TProperties = {}> = Static.Token.Const<'never', Input> extends [infer _0 extends 'never', infer Input extends string] ? [S.TKeywordNeverMapping<_0, Context>, Input] : []
+export type TKeywordSymbol<Input extends string, Context extends T.TProperties = {}> = Static.Token.Const<'symbol', Input> extends [infer _0 extends 'symbol', infer Input extends string] ? [S.TKeywordSymbolMapping<_0, Context>, Input] : []
+export type TKeywordVoid<Input extends string, Context extends T.TProperties = {}> = Static.Token.Const<'void', Input> extends [infer _0 extends 'void', infer Input extends string] ? [S.TKeywordVoidMapping<_0, Context>, Input] : []
+export type TKeyword<Input extends string, Context extends T.TProperties = {}> = (
+  TKeywordString<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TKeywordNumber<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TKeywordBoolean<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TKeywordUndefined<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TKeywordNull<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TKeywordInteger<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TKeywordBigInt<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TKeywordUnknown<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TKeywordAny<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TKeywordNever<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TKeywordSymbol<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TKeywordVoid<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : []
+) extends [infer _0 extends unknown, infer Input extends string]
+  ? [S.TKeywordMapping<_0, Context>, Input]
+  : []
+export type TLiteralString<Input extends string, Context extends T.TProperties = {}> = Static.Token.String<["'", '"', '`'], Input> extends [infer _0 extends string, infer Input extends string]
+  ? [S.TLiteralStringMapping<_0, Context>, Input]
+  : []
+export type TLiteralNumber<Input extends string, Context extends T.TProperties = {}> = Static.Token.Number<Input> extends [infer _0 extends string, infer Input extends string] ? [S.TLiteralNumberMapping<_0, Context>, Input] : []
+export type TLiteralBoolean<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'true', Input> extends [infer _0, infer Input extends string] ? [_0, Input] : Static.Token.Const<'false', Input> extends [infer _0, infer Input extends string] ? [_0, Input] : []
+) extends [infer _0 extends 'true' | 'false', infer Input extends string]
+  ? [S.TLiteralBooleanMapping<_0, Context>, Input]
+  : []
+export type TLiteral<Input extends string, Context extends T.TProperties = {}> = (
+  TLiteralBoolean<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TLiteralNumber<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TLiteralString<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : []
+) extends [infer _0 extends unknown, infer Input extends string]
+  ? [S.TLiteralMapping<_0, Context>, Input]
+  : []
+export type TKeyOf<Input extends string, Context extends T.TProperties = {}> = (
+  (Static.Token.Const<'keyof', Input> extends [infer _0, infer Input extends string] ? [[_0], Input] : []) extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : [[], Input] extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : []
+) extends [infer _0 extends [unknown] | [], infer Input extends string]
+  ? [S.TKeyOfMapping<_0, Context>, Input]
+  : []
+export type TIndexArray_0<Input extends string, Context extends T.TProperties, Result extends unknown[] = []> = (
+  (
+    Static.Token.Const<'[', Input> extends [infer _0, infer Input extends string]
+      ? TType<Input, Context> extends [infer _1, infer Input extends string]
+        ? Static.Token.Const<']', Input> extends [infer _2, infer Input extends string]
+          ? [[_0, _1, _2], Input]
+          : []
+        : []
+      : []
+  ) extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : (Static.Token.Const<'[', Input> extends [infer _0, infer Input extends string] ? (Static.Token.Const<']', Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [
+        infer _0,
+        infer Input extends string,
+      ]
+    ? [_0, Input]
+    : []
+) extends [infer _0, infer Input extends string]
+  ? TIndexArray_0<Input, Context, [...Result, _0]>
+  : [Result, Input]
+export type TIndexArray<Input extends string, Context extends T.TProperties = {}> = TIndexArray_0<Input, Context> extends [infer _0 extends ([unknown, unknown, unknown] | [unknown, unknown])[], infer Input extends string]
+  ? [S.TIndexArrayMapping<_0, Context>, Input]
+  : []
+export type TExtends<Input extends string, Context extends T.TProperties = {}> = (
+  (
+    Static.Token.Const<'extends', Input> extends [infer _0, infer Input extends string]
+      ? TType<Input, Context> extends [infer _1, infer Input extends string]
+        ? Static.Token.Const<'?', Input> extends [infer _2, infer Input extends string]
+          ? TType<Input, Context> extends [infer _3, infer Input extends string]
+            ? Static.Token.Const<':', Input> extends [infer _4, infer Input extends string]
+              ? TType<Input, Context> extends [infer _5, infer Input extends string]
+                ? [[_0, _1, _2, _3, _4, _5], Input]
+                : []
+              : []
+            : []
+          : []
+        : []
+      : []
+  ) extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : [[], Input] extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown, unknown] | [], infer Input extends string]
+  ? [S.TExtendsMapping<_0, Context>, Input]
+  : []
+export type TBase<Input extends string, Context extends T.TProperties = {}> = (
+  (
+    Static.Token.Const<'(', Input> extends [infer _0, infer Input extends string]
+      ? TType<Input, Context> extends [infer _1, infer Input extends string]
+        ? Static.Token.Const<')', Input> extends [infer _2, infer Input extends string]
+          ? [[_0, _1, _2], Input]
+          : []
+        : []
+      : []
+  ) extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TKeyword<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TObject<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TTuple<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TLiteral<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TConstructor<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TFunction<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TMapped<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TAsyncIterator<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TIterator<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TConstructorParameters<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TFunctionParameters<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TInstanceType<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TReturnType<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TArgument<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TAwaited<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TArray<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TRecord<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TPromise<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TPartial<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TRequired<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TPick<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TOmit<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TExclude<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TExtract<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TUppercase<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TLowercase<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TCapitalize<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TUncapitalize<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TDate<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TUint8Array<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TGenericReference<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TReference<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown] | unknown, infer Input extends string]
+  ? [S.TBaseMapping<_0, Context>, Input]
+  : []
+export type TFactor<Input extends string, Context extends T.TProperties = {}> = (
+  TKeyOf<Input, Context> extends [infer _0, infer Input extends string]
+    ? TBase<Input, Context> extends [infer _1, infer Input extends string]
+      ? TIndexArray<Input, Context> extends [infer _2, infer Input extends string]
+        ? TExtends<Input, Context> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TFactorMapping<_0, Context>, Input]
+  : []
+export type TExprTermTail<Input extends string, Context extends T.TProperties = {}> = (
+  (
+    Static.Token.Const<'&', Input> extends [infer _0, infer Input extends string]
+      ? TFactor<Input, Context> extends [infer _1, infer Input extends string]
+        ? TExprTermTail<Input, Context> extends [infer _2, infer Input extends string]
+          ? [[_0, _1, _2], Input]
+          : []
+        : []
+      : []
+  ) extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : [[], Input] extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown] | [], infer Input extends string]
+  ? [S.TExprTermTailMapping<_0, Context>, Input]
+  : []
+export type TExprTerm<Input extends string, Context extends T.TProperties = {}> = (
+  TFactor<Input, Context> extends [infer _0, infer Input extends string] ? (TExprTermTail<Input, Context> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []
+) extends [infer _0 extends [unknown, unknown], infer Input extends string]
+  ? [S.TExprTermMapping<_0, Context>, Input]
+  : []
+export type TExprTail<Input extends string, Context extends T.TProperties = {}> = (
+  (
+    Static.Token.Const<'|', Input> extends [infer _0, infer Input extends string]
+      ? TExprTerm<Input, Context> extends [infer _1, infer Input extends string]
+        ? TExprTail<Input, Context> extends [infer _2, infer Input extends string]
+          ? [[_0, _1, _2], Input]
+          : []
+        : []
+      : []
+  ) extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : [[], Input] extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown] | [], infer Input extends string]
+  ? [S.TExprTailMapping<_0, Context>, Input]
+  : []
+export type TExpr<Input extends string, Context extends T.TProperties = {}> = (
+  TExprTerm<Input, Context> extends [infer _0, infer Input extends string] ? (TExprTail<Input, Context> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []
+) extends [infer _0 extends [unknown, unknown], infer Input extends string]
+  ? [S.TExprMapping<_0, Context>, Input]
+  : []
+export type TType<Input extends string, Context extends T.TProperties = {}> = (
+  TGenericArguments<Input, Context> extends [infer _0 extends T.TProperties, infer Input extends string]
+    ? TExpr<Input, _0>
+    : [] extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : TExpr<Input, Context> extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : []
+) extends [infer _0 extends unknown, infer Input extends string]
+  ? [S.TTypeMapping<_0, Context>, Input]
+  : []
+export type TPropertyKey<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Ident<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : Static.Token.String<["'", '"'], Input> extends [infer _0, infer Input extends string] ? [_0, Input] : []
+) extends [infer _0 extends string, infer Input extends string]
+  ? [S.TPropertyKeyMapping<_0, Context>, Input]
+  : []
+export type TReadonly<Input extends string, Context extends T.TProperties = {}> = (
+  (Static.Token.Const<'readonly', Input> extends [infer _0, infer Input extends string] ? [[_0], Input] : []) extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : [[], Input] extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : []
+) extends [infer _0 extends [unknown] | [], infer Input extends string]
+  ? [S.TReadonlyMapping<_0, Context>, Input]
+  : []
+export type TOptional<Input extends string, Context extends T.TProperties = {}> = (
+  (Static.Token.Const<'?', Input> extends [infer _0, infer Input extends string] ? [[_0], Input] : []) extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : [[], Input] extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : []
+) extends [infer _0 extends [unknown] | [], infer Input extends string]
+  ? [S.TOptionalMapping<_0, Context>, Input]
+  : []
+export type TProperty<Input extends string, Context extends T.TProperties = {}> = (
+  TReadonly<Input, Context> extends [infer _0, infer Input extends string]
+    ? TPropertyKey<Input, Context> extends [infer _1, infer Input extends string]
+      ? TOptional<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<':', Input> extends [infer _3, infer Input extends string]
+          ? TType<Input, Context> extends [infer _4, infer Input extends string]
+            ? [[_0, _1, _2, _3, _4], Input]
+            : []
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TPropertyMapping<_0, Context>, Input]
+  : []
+export type TPropertyDelimiter<Input extends string, Context extends T.TProperties = {}> = (
+  (Static.Token.Const<',', Input> extends [infer _0, infer Input extends string] ? (Static.Token.Const<'\n', Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [
+    infer _0,
+    infer Input extends string,
+  ]
+    ? [_0, Input]
+    : (Static.Token.Const<';', Input> extends [infer _0, infer Input extends string] ? (Static.Token.Const<'\n', Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [
+        infer _0,
+        infer Input extends string,
+      ]
+    ? [_0, Input]
+    : (Static.Token.Const<',', Input> extends [infer _0, infer Input extends string] ? [[_0], Input] : []) extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : (Static.Token.Const<';', Input> extends [infer _0, infer Input extends string] ? [[_0], Input] : []) extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : (Static.Token.Const<'\n', Input> extends [infer _0, infer Input extends string] ? [[_0], Input] : []) extends [infer _0, infer Input extends string]
+    ? [_0, Input]
+    : []
+) extends [infer _0 extends [unknown, unknown] | [unknown], infer Input extends string]
+  ? [S.TPropertyDelimiterMapping<_0, Context>, Input]
+  : []
+export type TPropertyList_0<Input extends string, Context extends T.TProperties, Result extends unknown[] = []> = (
+  TProperty<Input, Context> extends [infer _0, infer Input extends string] ? (TPropertyDelimiter<Input, Context> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []
+) extends [infer _0, infer Input extends string]
+  ? TPropertyList_0<Input, Context, [...Result, _0]>
+  : [Result, Input]
+export type TPropertyList<Input extends string, Context extends T.TProperties = {}> = (
+  TPropertyList_0<Input, Context> extends [infer _0, infer Input extends string]
+    ? (
+        (TProperty<Input, Context> extends [infer _0, infer Input extends string] ? [[_0], Input] : []) extends [infer _0, infer Input extends string]
+          ? [_0, Input]
+          : [[], Input] extends [infer _0, infer Input extends string]
+          ? [_0, Input]
+          : []
+      ) extends [infer _1, infer Input extends string]
+      ? [[_0, _1], Input]
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown], infer Input extends string]
+  ? [S.TPropertyListMapping<_0, Context>, Input]
+  : []
+export type TObject<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'{', Input> extends [infer _0, infer Input extends string]
+    ? TPropertyList<Input, Context> extends [infer _1, infer Input extends string]
+      ? Static.Token.Const<'}', Input> extends [infer _2, infer Input extends string]
+        ? [[_0, _1, _2], Input]
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown], infer Input extends string]
+  ? [S.TObjectMapping<_0, Context>, Input]
+  : []
+export type TElementList_0<Input extends string, Context extends T.TProperties, Result extends unknown[] = []> = (
+  TType<Input, Context> extends [infer _0, infer Input extends string] ? (Static.Token.Const<',', Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []
+) extends [infer _0, infer Input extends string]
+  ? TElementList_0<Input, Context, [...Result, _0]>
+  : [Result, Input]
+export type TElementList<Input extends string, Context extends T.TProperties = {}> = (
+  TElementList_0<Input, Context> extends [infer _0, infer Input extends string]
+    ? (
+        (TType<Input, Context> extends [infer _0, infer Input extends string] ? [[_0], Input] : []) extends [infer _0, infer Input extends string] ? [_0, Input] : [[], Input] extends [infer _0, infer Input extends string] ? [_0, Input] : []
+      ) extends [infer _1, infer Input extends string]
+      ? [[_0, _1], Input]
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown], infer Input extends string]
+  ? [S.TElementListMapping<_0, Context>, Input]
+  : []
+export type TTuple<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'[', Input> extends [infer _0, infer Input extends string]
+    ? TElementList<Input, Context> extends [infer _1, infer Input extends string]
+      ? Static.Token.Const<']', Input> extends [infer _2, infer Input extends string]
+        ? [[_0, _1, _2], Input]
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown], infer Input extends string]
+  ? [S.TTupleMapping<_0, Context>, Input]
+  : []
+export type TParameter<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Ident<Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<':', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? [[_0, _1, _2], Input]
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown], infer Input extends string]
+  ? [S.TParameterMapping<_0, Context>, Input]
+  : []
+export type TParameterList_0<Input extends string, Context extends T.TProperties, Result extends unknown[] = []> = (
+  TParameter<Input, Context> extends [infer _0, infer Input extends string] ? (Static.Token.Const<',', Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []
+) extends [infer _0, infer Input extends string]
+  ? TParameterList_0<Input, Context, [...Result, _0]>
+  : [Result, Input]
+export type TParameterList<Input extends string, Context extends T.TProperties = {}> = (
+  TParameterList_0<Input, Context> extends [infer _0, infer Input extends string]
+    ? (
+        (TParameter<Input, Context> extends [infer _0, infer Input extends string] ? [[_0], Input] : []) extends [infer _0, infer Input extends string]
+          ? [_0, Input]
+          : [[], Input] extends [infer _0, infer Input extends string]
+          ? [_0, Input]
+          : []
+      ) extends [infer _1, infer Input extends string]
+      ? [[_0, _1], Input]
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown], infer Input extends string]
+  ? [S.TParameterListMapping<_0, Context>, Input]
+  : []
+export type TFunction<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'(', Input> extends [infer _0, infer Input extends string]
+    ? TParameterList<Input, Context> extends [infer _1, infer Input extends string]
+      ? Static.Token.Const<')', Input> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'=>', Input> extends [infer _3, infer Input extends string]
+          ? TType<Input, Context> extends [infer _4, infer Input extends string]
+            ? [[_0, _1, _2, _3, _4], Input]
+            : []
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TFunctionMapping<_0, Context>, Input]
+  : []
+export type TConstructor<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'new', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'(', Input> extends [infer _1, infer Input extends string]
+      ? TParameterList<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<')', Input> extends [infer _3, infer Input extends string]
+          ? Static.Token.Const<'=>', Input> extends [infer _4, infer Input extends string]
+            ? TType<Input, Context> extends [infer _5, infer Input extends string]
+              ? [[_0, _1, _2, _3, _4, _5], Input]
+              : []
+            : []
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TConstructorMapping<_0, Context>, Input]
+  : []
+export type TMapped<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'{', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'[', Input> extends [infer _1, infer Input extends string]
+      ? Static.Token.Ident<Input> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'in', Input> extends [infer _3, infer Input extends string]
+          ? TType<Input, Context> extends [infer _4, infer Input extends string]
+            ? Static.Token.Const<']', Input> extends [infer _5, infer Input extends string]
+              ? Static.Token.Const<':', Input> extends [infer _6, infer Input extends string]
+                ? TType<Input, Context> extends [infer _7, infer Input extends string]
+                  ? Static.Token.Const<'}', Input> extends [infer _8, infer Input extends string]
+                    ? [[_0, _1, _2, _3, _4, _5, _6, _7, _8], Input]
+                    : []
+                  : []
+                : []
+              : []
+            : []
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TMappedMapping<_0, Context>, Input]
+  : []
+export type TAsyncIterator<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'AsyncIterator', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TAsyncIteratorMapping<_0, Context>, Input]
+  : []
+export type TIterator<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Iterator', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TIteratorMapping<_0, Context>, Input]
+  : []
+export type TArgument<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Argument', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TArgumentMapping<_0, Context>, Input]
+  : []
+export type TAwaited<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Awaited', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TAwaitedMapping<_0, Context>, Input]
+  : []
+export type TArray<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Array', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TArrayMapping<_0, Context>, Input]
+  : []
+export type TRecord<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Record', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<',', Input> extends [infer _3, infer Input extends string]
+          ? TType<Input, Context> extends [infer _4, infer Input extends string]
+            ? Static.Token.Const<'>', Input> extends [infer _5, infer Input extends string]
+              ? [[_0, _1, _2, _3, _4, _5], Input]
+              : []
+            : []
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TRecordMapping<_0, Context>, Input]
+  : []
+export type TPromise<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Promise', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TPromiseMapping<_0, Context>, Input]
+  : []
+export type TConstructorParameters<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'ConstructorParameters', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TConstructorParametersMapping<_0, Context>, Input]
+  : []
+export type TFunctionParameters<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Parameters', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TFunctionParametersMapping<_0, Context>, Input]
+  : []
+export type TInstanceType<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'InstanceType', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TInstanceTypeMapping<_0, Context>, Input]
+  : []
+export type TReturnType<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'ReturnType', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TReturnTypeMapping<_0, Context>, Input]
+  : []
+export type TPartial<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Partial', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TPartialMapping<_0, Context>, Input]
+  : []
+export type TRequired<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Required', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TRequiredMapping<_0, Context>, Input]
+  : []
+export type TPick<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Pick', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<',', Input> extends [infer _3, infer Input extends string]
+          ? TType<Input, Context> extends [infer _4, infer Input extends string]
+            ? Static.Token.Const<'>', Input> extends [infer _5, infer Input extends string]
+              ? [[_0, _1, _2, _3, _4, _5], Input]
+              : []
+            : []
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TPickMapping<_0, Context>, Input]
+  : []
+export type TOmit<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Omit', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<',', Input> extends [infer _3, infer Input extends string]
+          ? TType<Input, Context> extends [infer _4, infer Input extends string]
+            ? Static.Token.Const<'>', Input> extends [infer _5, infer Input extends string]
+              ? [[_0, _1, _2, _3, _4, _5], Input]
+              : []
+            : []
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TOmitMapping<_0, Context>, Input]
+  : []
+export type TExclude<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Exclude', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<',', Input> extends [infer _3, infer Input extends string]
+          ? TType<Input, Context> extends [infer _4, infer Input extends string]
+            ? Static.Token.Const<'>', Input> extends [infer _5, infer Input extends string]
+              ? [[_0, _1, _2, _3, _4, _5], Input]
+              : []
+            : []
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TExcludeMapping<_0, Context>, Input]
+  : []
+export type TExtract<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Extract', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<',', Input> extends [infer _3, infer Input extends string]
+          ? TType<Input, Context> extends [infer _4, infer Input extends string]
+            ? Static.Token.Const<'>', Input> extends [infer _5, infer Input extends string]
+              ? [[_0, _1, _2, _3, _4, _5], Input]
+              : []
+            : []
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TExtractMapping<_0, Context>, Input]
+  : []
+export type TUppercase<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Uppercase', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TUppercaseMapping<_0, Context>, Input]
+  : []
+export type TLowercase<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Lowercase', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TLowercaseMapping<_0, Context>, Input]
+  : []
+export type TCapitalize<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Capitalize', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TCapitalizeMapping<_0, Context>, Input]
+  : []
+export type TUncapitalize<Input extends string, Context extends T.TProperties = {}> = (
+  Static.Token.Const<'Uncapitalize', Input> extends [infer _0, infer Input extends string]
+    ? Static.Token.Const<'<', Input> extends [infer _1, infer Input extends string]
+      ? TType<Input, Context> extends [infer _2, infer Input extends string]
+        ? Static.Token.Const<'>', Input> extends [infer _3, infer Input extends string]
+          ? [[_0, _1, _2, _3], Input]
+          : []
+        : []
+      : []
+    : []
+) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string]
+  ? [S.TUncapitalizeMapping<_0, Context>, Input]
+  : []
+export type TDate<Input extends string, Context extends T.TProperties = {}> = Static.Token.Const<'Date', Input> extends [infer _0 extends 'Date', infer Input extends string] ? [S.TDateMapping<_0, Context>, Input] : []
+export type TUint8Array<Input extends string, Context extends T.TProperties = {}> = Static.Token.Const<'Uint8Array', Input> extends [infer _0 extends 'Uint8Array', infer Input extends string]
+  ? [S.TUint8ArrayMapping<_0, Context>, Input]
+  : []
+export type TReference<Input extends string, Context extends T.TProperties = {}> = Static.Token.Ident<Input> extends [infer _0 extends string, infer Input extends string] ? [S.TReferenceMapping<_0, Context>, Input] : []
+const If = (result: [unknown, string] | [], left: (input: [unknown, string]) => [unknown, string] | [], right: () => [unknown, string] | [] = () => []): [unknown, string] | [] => (result.length === 2 ? left(result) : right())
+
+export const GenericReferenceParameterList_0 = (input: string, context: T.TProperties, result: unknown[] = []): [unknown[], string] =>
+  If(
+    If(Type(input, context), ([_0, input]) => If(Runtime.Token.Const(',', input), ([_1, input]) => [[_0, _1], input])),
+    ([_0, input]) => GenericReferenceParameterList_0(input, context, [...result, _0]),
+    () => [result, input],
+  ) as [unknown[], string]
+export const GenericReferenceParameterList = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(GenericReferenceParameterList_0(input, context), ([_0, input]) =>
+      If(
+        If(
+          If(Type(input, context), ([_0, input]) => [[_0], input]),
+          ([_0, input]) => [_0, input],
+          () =>
+            If(
+              [[], input],
+              ([_0, input]) => [_0, input],
+              () => [],
+            ),
+        ),
+        ([_1, input]) => [[_0, _1], input],
+      ),
+    ),
+    ([_0, input]) => [S.GenericReferenceParameterListMapping(_0 as [unknown, unknown], context), input],
+  )
+export const GenericReference = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Ident(input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) => If(GenericReferenceParameterList(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input]))),
+    ),
+    ([_0, input]) => [S.GenericReferenceMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const GenericArgumentsList_0 = (input: string, context: T.TProperties, result: unknown[] = []): [unknown[], string] =>
+  If(
+    If(Runtime.Token.Ident(input), ([_0, input]) => If(Runtime.Token.Const(',', input), ([_1, input]) => [[_0, _1], input])),
+    ([_0, input]) => GenericArgumentsList_0(input, context, [...result, _0]),
+    () => [result, input],
+  ) as [unknown[], string]
+export const GenericArgumentsList = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(GenericArgumentsList_0(input, context), ([_0, input]) =>
+      If(
+        If(
+          If(Runtime.Token.Ident(input), ([_0, input]) => [[_0], input]),
+          ([_0, input]) => [_0, input],
+          () =>
+            If(
+              [[], input],
+              ([_0, input]) => [_0, input],
+              () => [],
+            ),
+        ),
+        ([_1, input]) => [[_0, _1], input],
+      ),
+    ),
+    ([_0, input]) => [S.GenericArgumentsListMapping(_0 as [unknown, unknown], context), input],
+  )
+export const GenericArguments = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('<', input), ([_0, input]) => If(GenericArgumentsList(input, context), ([_1, input]) => If(Runtime.Token.Const('>', input), ([_2, input]) => [[_0, _1, _2], input]))),
+    ([_0, input]) => [S.GenericArgumentsMapping(_0 as [unknown, unknown, unknown], context), input],
+  )
+export const KeywordString = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.Const('string', input), ([_0, input]) => [S.KeywordStringMapping(_0 as 'string', context), input])
+export const KeywordNumber = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.Const('number', input), ([_0, input]) => [S.KeywordNumberMapping(_0 as 'number', context), input])
+export const KeywordBoolean = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.Const('boolean', input), ([_0, input]) => [S.KeywordBooleanMapping(_0 as 'boolean', context), input])
+export const KeywordUndefined = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.Const('undefined', input), ([_0, input]) => [S.KeywordUndefinedMapping(_0 as 'undefined', context), input])
+export const KeywordNull = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.Const('null', input), ([_0, input]) => [S.KeywordNullMapping(_0 as 'null', context), input])
+export const KeywordInteger = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.Const('integer', input), ([_0, input]) => [S.KeywordIntegerMapping(_0 as 'integer', context), input])
+export const KeywordBigInt = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.Const('bigint', input), ([_0, input]) => [S.KeywordBigIntMapping(_0 as 'bigint', context), input])
+export const KeywordUnknown = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.Const('unknown', input), ([_0, input]) => [S.KeywordUnknownMapping(_0 as 'unknown', context), input])
+export const KeywordAny = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.Const('any', input), ([_0, input]) => [S.KeywordAnyMapping(_0 as 'any', context), input])
+export const KeywordNever = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.Const('never', input), ([_0, input]) => [S.KeywordNeverMapping(_0 as 'never', context), input])
+export const KeywordSymbol = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.Const('symbol', input), ([_0, input]) => [S.KeywordSymbolMapping(_0 as 'symbol', context), input])
+export const KeywordVoid = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.Const('void', input), ([_0, input]) => [S.KeywordVoidMapping(_0 as 'void', context), input])
+export const Keyword = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(
+      KeywordString(input, context),
+      ([_0, input]) => [_0, input],
+      () =>
+        If(
+          KeywordNumber(input, context),
+          ([_0, input]) => [_0, input],
+          () =>
+            If(
+              KeywordBoolean(input, context),
+              ([_0, input]) => [_0, input],
+              () =>
+                If(
+                  KeywordUndefined(input, context),
+                  ([_0, input]) => [_0, input],
+                  () =>
+                    If(
+                      KeywordNull(input, context),
+                      ([_0, input]) => [_0, input],
+                      () =>
+                        If(
+                          KeywordInteger(input, context),
+                          ([_0, input]) => [_0, input],
+                          () =>
+                            If(
+                              KeywordBigInt(input, context),
+                              ([_0, input]) => [_0, input],
+                              () =>
+                                If(
+                                  KeywordUnknown(input, context),
+                                  ([_0, input]) => [_0, input],
+                                  () =>
+                                    If(
+                                      KeywordAny(input, context),
+                                      ([_0, input]) => [_0, input],
+                                      () =>
+                                        If(
+                                          KeywordNever(input, context),
+                                          ([_0, input]) => [_0, input],
+                                          () =>
+                                            If(
+                                              KeywordSymbol(input, context),
+                                              ([_0, input]) => [_0, input],
+                                              () =>
+                                                If(
+                                                  KeywordVoid(input, context),
+                                                  ([_0, input]) => [_0, input],
+                                                  () => [],
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        ),
+    ),
+    ([_0, input]) => [S.KeywordMapping(_0 as unknown, context), input],
+  )
+export const LiteralString = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.String(["'", '"', '`'], input), ([_0, input]) => [S.LiteralStringMapping(_0 as string, context), input])
+export const LiteralNumber = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.Number(input), ([_0, input]) => [S.LiteralNumberMapping(_0 as string, context), input])
+export const LiteralBoolean = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(
+      Runtime.Token.Const('true', input),
+      ([_0, input]) => [_0, input],
+      () =>
+        If(
+          Runtime.Token.Const('false', input),
+          ([_0, input]) => [_0, input],
+          () => [],
+        ),
+    ),
+    ([_0, input]) => [S.LiteralBooleanMapping(_0 as 'true' | 'false', context), input],
+  )
+export const Literal = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(
+      LiteralBoolean(input, context),
+      ([_0, input]) => [_0, input],
+      () =>
+        If(
+          LiteralNumber(input, context),
+          ([_0, input]) => [_0, input],
+          () =>
+            If(
+              LiteralString(input, context),
+              ([_0, input]) => [_0, input],
+              () => [],
+            ),
+        ),
+    ),
+    ([_0, input]) => [S.LiteralMapping(_0 as unknown, context), input],
+  )
+export const KeyOf = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(
+      If(Runtime.Token.Const('keyof', input), ([_0, input]) => [[_0], input]),
+      ([_0, input]) => [_0, input],
+      () =>
+        If(
+          [[], input],
+          ([_0, input]) => [_0, input],
+          () => [],
+        ),
+    ),
+    ([_0, input]) => [S.KeyOfMapping(_0 as [unknown] | [], context), input],
+  )
+export const IndexArray_0 = (input: string, context: T.TProperties, result: unknown[] = []): [unknown[], string] =>
+  If(
+    If(
+      If(Runtime.Token.Const('[', input), ([_0, input]) => If(Type(input, context), ([_1, input]) => If(Runtime.Token.Const(']', input), ([_2, input]) => [[_0, _1, _2], input]))),
+      ([_0, input]) => [_0, input],
+      () =>
+        If(
+          If(Runtime.Token.Const('[', input), ([_0, input]) => If(Runtime.Token.Const(']', input), ([_1, input]) => [[_0, _1], input])),
+          ([_0, input]) => [_0, input],
+          () => [],
+        ),
+    ),
+    ([_0, input]) => IndexArray_0(input, context, [...result, _0]),
+    () => [result, input],
+  ) as [unknown[], string]
+export const IndexArray = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(IndexArray_0(input, context), ([_0, input]) => [S.IndexArrayMapping(_0 as ([unknown, unknown, unknown] | [unknown, unknown])[], context), input])
+export const Extends = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(
+      If(Runtime.Token.Const('extends', input), ([_0, input]) =>
+        If(Type(input, context), ([_1, input]) =>
+          If(Runtime.Token.Const('?', input), ([_2, input]) => If(Type(input, context), ([_3, input]) => If(Runtime.Token.Const(':', input), ([_4, input]) => If(Type(input, context), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input])))),
+        ),
+      ),
+      ([_0, input]) => [_0, input],
+      () =>
+        If(
+          [[], input],
+          ([_0, input]) => [_0, input],
+          () => [],
+        ),
+    ),
+    ([_0, input]) => [S.ExtendsMapping(_0 as [unknown, unknown, unknown, unknown, unknown, unknown] | [], context), input],
+  )
+export const Base = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(
+      If(Runtime.Token.Const('(', input), ([_0, input]) => If(Type(input, context), ([_1, input]) => If(Runtime.Token.Const(')', input), ([_2, input]) => [[_0, _1, _2], input]))),
+      ([_0, input]) => [_0, input],
+      () =>
+        If(
+          Keyword(input, context),
+          ([_0, input]) => [_0, input],
+          () =>
+            If(
+              _Object(input, context),
+              ([_0, input]) => [_0, input],
+              () =>
+                If(
+                  Tuple(input, context),
+                  ([_0, input]) => [_0, input],
+                  () =>
+                    If(
+                      Literal(input, context),
+                      ([_0, input]) => [_0, input],
+                      () =>
+                        If(
+                          Constructor(input, context),
+                          ([_0, input]) => [_0, input],
+                          () =>
+                            If(
+                              Function(input, context),
+                              ([_0, input]) => [_0, input],
+                              () =>
+                                If(
+                                  Mapped(input, context),
+                                  ([_0, input]) => [_0, input],
+                                  () =>
+                                    If(
+                                      AsyncIterator(input, context),
+                                      ([_0, input]) => [_0, input],
+                                      () =>
+                                        If(
+                                          Iterator(input, context),
+                                          ([_0, input]) => [_0, input],
+                                          () =>
+                                            If(
+                                              ConstructorParameters(input, context),
+                                              ([_0, input]) => [_0, input],
+                                              () =>
+                                                If(
+                                                  FunctionParameters(input, context),
+                                                  ([_0, input]) => [_0, input],
+                                                  () =>
+                                                    If(
+                                                      InstanceType(input, context),
+                                                      ([_0, input]) => [_0, input],
+                                                      () =>
+                                                        If(
+                                                          ReturnType(input, context),
+                                                          ([_0, input]) => [_0, input],
+                                                          () =>
+                                                            If(
+                                                              Argument(input, context),
+                                                              ([_0, input]) => [_0, input],
+                                                              () =>
+                                                                If(
+                                                                  Awaited(input, context),
+                                                                  ([_0, input]) => [_0, input],
+                                                                  () =>
+                                                                    If(
+                                                                      Array(input, context),
+                                                                      ([_0, input]) => [_0, input],
+                                                                      () =>
+                                                                        If(
+                                                                          Record(input, context),
+                                                                          ([_0, input]) => [_0, input],
+                                                                          () =>
+                                                                            If(
+                                                                              Promise(input, context),
+                                                                              ([_0, input]) => [_0, input],
+                                                                              () =>
+                                                                                If(
+                                                                                  Partial(input, context),
+                                                                                  ([_0, input]) => [_0, input],
+                                                                                  () =>
+                                                                                    If(
+                                                                                      Required(input, context),
+                                                                                      ([_0, input]) => [_0, input],
+                                                                                      () =>
+                                                                                        If(
+                                                                                          Pick(input, context),
+                                                                                          ([_0, input]) => [_0, input],
+                                                                                          () =>
+                                                                                            If(
+                                                                                              Omit(input, context),
+                                                                                              ([_0, input]) => [_0, input],
+                                                                                              () =>
+                                                                                                If(
+                                                                                                  Exclude(input, context),
+                                                                                                  ([_0, input]) => [_0, input],
+                                                                                                  () =>
+                                                                                                    If(
+                                                                                                      Extract(input, context),
+                                                                                                      ([_0, input]) => [_0, input],
+                                                                                                      () =>
+                                                                                                        If(
+                                                                                                          Uppercase(input, context),
+                                                                                                          ([_0, input]) => [_0, input],
+                                                                                                          () =>
+                                                                                                            If(
+                                                                                                              Lowercase(input, context),
+                                                                                                              ([_0, input]) => [_0, input],
+                                                                                                              () =>
+                                                                                                                If(
+                                                                                                                  Capitalize(input, context),
+                                                                                                                  ([_0, input]) => [_0, input],
+                                                                                                                  () =>
+                                                                                                                    If(
+                                                                                                                      Uncapitalize(input, context),
+                                                                                                                      ([_0, input]) => [_0, input],
+                                                                                                                      () =>
+                                                                                                                        If(
+                                                                                                                          Date(input, context),
+                                                                                                                          ([_0, input]) => [_0, input],
+                                                                                                                          () =>
+                                                                                                                            If(
+                                                                                                                              Uint8Array(input, context),
+                                                                                                                              ([_0, input]) => [_0, input],
+                                                                                                                              () =>
+                                                                                                                                If(
+                                                                                                                                  GenericReference(input, context),
+                                                                                                                                  ([_0, input]) => [_0, input],
+                                                                                                                                  () =>
+                                                                                                                                    If(
+                                                                                                                                      Reference(input, context),
+                                                                                                                                      ([_0, input]) => [_0, input],
+                                                                                                                                      () => [],
+                                                                                                                                    ),
+                                                                                                                                ),
+                                                                                                                            ),
+                                                                                                                        ),
+                                                                                                                    ),
+                                                                                                                ),
+                                                                                                            ),
+                                                                                                        ),
+                                                                                                    ),
+                                                                                                ),
+                                                                                            ),
+                                                                                        ),
+                                                                                    ),
+                                                                                ),
+                                                                            ),
+                                                                        ),
+                                                                    ),
+                                                                ),
+                                                            ),
+                                                        ),
+                                                    ),
+                                                ),
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        ),
+    ),
+    ([_0, input]) => [S.BaseMapping(_0 as [unknown, unknown, unknown] | unknown, context), input],
+  )
+export const Factor = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(KeyOf(input, context), ([_0, input]) => If(Base(input, context), ([_1, input]) => If(IndexArray(input, context), ([_2, input]) => If(Extends(input, context), ([_3, input]) => [[_0, _1, _2, _3], input])))),
+    ([_0, input]) => [S.FactorMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const ExprTermTail = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(
+      If(Runtime.Token.Const('&', input), ([_0, input]) => If(Factor(input, context), ([_1, input]) => If(ExprTermTail(input, context), ([_2, input]) => [[_0, _1, _2], input]))),
+      ([_0, input]) => [_0, input],
+      () =>
+        If(
+          [[], input],
+          ([_0, input]) => [_0, input],
+          () => [],
+        ),
+    ),
+    ([_0, input]) => [S.ExprTermTailMapping(_0 as [unknown, unknown, unknown] | [], context), input],
+  )
+export const ExprTerm = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Factor(input, context), ([_0, input]) => If(ExprTermTail(input, context), ([_1, input]) => [[_0, _1], input])),
+    ([_0, input]) => [S.ExprTermMapping(_0 as [unknown, unknown], context), input],
+  )
+export const ExprTail = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(
+      If(Runtime.Token.Const('|', input), ([_0, input]) => If(ExprTerm(input, context), ([_1, input]) => If(ExprTail(input, context), ([_2, input]) => [[_0, _1, _2], input]))),
+      ([_0, input]) => [_0, input],
+      () =>
+        If(
+          [[], input],
+          ([_0, input]) => [_0, input],
+          () => [],
+        ),
+    ),
+    ([_0, input]) => [S.ExprTailMapping(_0 as [unknown, unknown, unknown] | [], context), input],
+  )
+export const Expr = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(ExprTerm(input, context), ([_0, input]) => If(ExprTail(input, context), ([_1, input]) => [[_0, _1], input])),
+    ([_0, input]) => [S.ExprMapping(_0 as [unknown, unknown], context), input],
+  )
+export const Type = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(
+      If(
+        GenericArguments(input, context),
+        ([_0, input]) => Expr(input, _0 as T.TProperties),
+        () => [],
+      ),
+      ([_0, input]) => [_0, input],
+      () =>
+        If(
+          Expr(input, context),
+          ([_0, input]) => [_0, input],
+          () => [],
+        ),
+    ),
+    ([_0, input]) => [S.TypeMapping(_0 as unknown, context), input],
+  )
+export const PropertyKey = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(
+      Runtime.Token.Ident(input),
+      ([_0, input]) => [_0, input],
+      () =>
+        If(
+          Runtime.Token.String(["'", '"'], input),
+          ([_0, input]) => [_0, input],
+          () => [],
+        ),
+    ),
+    ([_0, input]) => [S.PropertyKeyMapping(_0 as string, context), input],
+  )
+export const Readonly = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(
+      If(Runtime.Token.Const('readonly', input), ([_0, input]) => [[_0], input]),
+      ([_0, input]) => [_0, input],
+      () =>
+        If(
+          [[], input],
+          ([_0, input]) => [_0, input],
+          () => [],
+        ),
+    ),
+    ([_0, input]) => [S.ReadonlyMapping(_0 as [unknown] | [], context), input],
+  )
+export const Optional = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(
+      If(Runtime.Token.Const('?', input), ([_0, input]) => [[_0], input]),
+      ([_0, input]) => [_0, input],
+      () =>
+        If(
+          [[], input],
+          ([_0, input]) => [_0, input],
+          () => [],
+        ),
+    ),
+    ([_0, input]) => [S.OptionalMapping(_0 as [unknown] | [], context), input],
+  )
+export const Property = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Readonly(input, context), ([_0, input]) =>
+      If(PropertyKey(input, context), ([_1, input]) => If(Optional(input, context), ([_2, input]) => If(Runtime.Token.Const(':', input), ([_3, input]) => If(Type(input, context), ([_4, input]) => [[_0, _1, _2, _3, _4], input])))),
+    ),
+    ([_0, input]) => [S.PropertyMapping(_0 as [unknown, unknown, unknown, unknown, unknown], context), input],
+  )
+export const PropertyDelimiter = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(
+      If(Runtime.Token.Const(',', input), ([_0, input]) => If(Runtime.Token.Const('\n', input), ([_1, input]) => [[_0, _1], input])),
+      ([_0, input]) => [_0, input],
+      () =>
+        If(
+          If(Runtime.Token.Const(';', input), ([_0, input]) => If(Runtime.Token.Const('\n', input), ([_1, input]) => [[_0, _1], input])),
+          ([_0, input]) => [_0, input],
+          () =>
+            If(
+              If(Runtime.Token.Const(',', input), ([_0, input]) => [[_0], input]),
+              ([_0, input]) => [_0, input],
+              () =>
+                If(
+                  If(Runtime.Token.Const(';', input), ([_0, input]) => [[_0], input]),
+                  ([_0, input]) => [_0, input],
+                  () =>
+                    If(
+                      If(Runtime.Token.Const('\n', input), ([_0, input]) => [[_0], input]),
+                      ([_0, input]) => [_0, input],
+                      () => [],
+                    ),
+                ),
+            ),
+        ),
+    ),
+    ([_0, input]) => [S.PropertyDelimiterMapping(_0 as [unknown, unknown] | [unknown], context), input],
+  )
+export const PropertyList_0 = (input: string, context: T.TProperties, result: unknown[] = []): [unknown[], string] =>
+  If(
+    If(Property(input, context), ([_0, input]) => If(PropertyDelimiter(input, context), ([_1, input]) => [[_0, _1], input])),
+    ([_0, input]) => PropertyList_0(input, context, [...result, _0]),
+    () => [result, input],
+  ) as [unknown[], string]
+export const PropertyList = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(PropertyList_0(input, context), ([_0, input]) =>
+      If(
+        If(
+          If(Property(input, context), ([_0, input]) => [[_0], input]),
+          ([_0, input]) => [_0, input],
+          () =>
+            If(
+              [[], input],
+              ([_0, input]) => [_0, input],
+              () => [],
+            ),
+        ),
+        ([_1, input]) => [[_0, _1], input],
+      ),
+    ),
+    ([_0, input]) => [S.PropertyListMapping(_0 as [unknown, unknown], context), input],
+  )
+export const _Object = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('{', input), ([_0, input]) => If(PropertyList(input, context), ([_1, input]) => If(Runtime.Token.Const('}', input), ([_2, input]) => [[_0, _1, _2], input]))),
+    ([_0, input]) => [S.ObjectMapping(_0 as [unknown, unknown, unknown], context), input],
+  )
+export const ElementList_0 = (input: string, context: T.TProperties, result: unknown[] = []): [unknown[], string] =>
+  If(
+    If(Type(input, context), ([_0, input]) => If(Runtime.Token.Const(',', input), ([_1, input]) => [[_0, _1], input])),
+    ([_0, input]) => ElementList_0(input, context, [...result, _0]),
+    () => [result, input],
+  ) as [unknown[], string]
+export const ElementList = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(ElementList_0(input, context), ([_0, input]) =>
+      If(
+        If(
+          If(Type(input, context), ([_0, input]) => [[_0], input]),
+          ([_0, input]) => [_0, input],
+          () =>
+            If(
+              [[], input],
+              ([_0, input]) => [_0, input],
+              () => [],
+            ),
+        ),
+        ([_1, input]) => [[_0, _1], input],
+      ),
+    ),
+    ([_0, input]) => [S.ElementListMapping(_0 as [unknown, unknown], context), input],
+  )
+export const Tuple = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('[', input), ([_0, input]) => If(ElementList(input, context), ([_1, input]) => If(Runtime.Token.Const(']', input), ([_2, input]) => [[_0, _1, _2], input]))),
+    ([_0, input]) => [S.TupleMapping(_0 as [unknown, unknown, unknown], context), input],
+  )
+export const Parameter = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Ident(input), ([_0, input]) => If(Runtime.Token.Const(':', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => [[_0, _1, _2], input]))),
+    ([_0, input]) => [S.ParameterMapping(_0 as [unknown, unknown, unknown], context), input],
+  )
+export const ParameterList_0 = (input: string, context: T.TProperties, result: unknown[] = []): [unknown[], string] =>
+  If(
+    If(Parameter(input, context), ([_0, input]) => If(Runtime.Token.Const(',', input), ([_1, input]) => [[_0, _1], input])),
+    ([_0, input]) => ParameterList_0(input, context, [...result, _0]),
+    () => [result, input],
+  ) as [unknown[], string]
+export const ParameterList = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(ParameterList_0(input, context), ([_0, input]) =>
+      If(
+        If(
+          If(Parameter(input, context), ([_0, input]) => [[_0], input]),
+          ([_0, input]) => [_0, input],
+          () =>
+            If(
+              [[], input],
+              ([_0, input]) => [_0, input],
+              () => [],
+            ),
+        ),
+        ([_1, input]) => [[_0, _1], input],
+      ),
+    ),
+    ([_0, input]) => [S.ParameterListMapping(_0 as [unknown, unknown], context), input],
+  )
+export const Function = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('(', input), ([_0, input]) =>
+      If(ParameterList(input, context), ([_1, input]) => If(Runtime.Token.Const(')', input), ([_2, input]) => If(Runtime.Token.Const('=>', input), ([_3, input]) => If(Type(input, context), ([_4, input]) => [[_0, _1, _2, _3, _4], input])))),
+    ),
+    ([_0, input]) => [S.FunctionMapping(_0 as [unknown, unknown, unknown, unknown, unknown], context), input],
+  )
+export const Constructor = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('new', input), ([_0, input]) =>
+      If(Runtime.Token.Const('(', input), ([_1, input]) =>
+        If(ParameterList(input, context), ([_2, input]) =>
+          If(Runtime.Token.Const(')', input), ([_3, input]) => If(Runtime.Token.Const('=>', input), ([_4, input]) => If(Type(input, context), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input]))),
+        ),
+      ),
+    ),
+    ([_0, input]) => [S.ConstructorMapping(_0 as [unknown, unknown, unknown, unknown, unknown, unknown], context), input],
+  )
+export const Mapped = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('{', input), ([_0, input]) =>
+      If(Runtime.Token.Const('[', input), ([_1, input]) =>
+        If(Runtime.Token.Ident(input), ([_2, input]) =>
+          If(Runtime.Token.Const('in', input), ([_3, input]) =>
+            If(Type(input, context), ([_4, input]) =>
+              If(Runtime.Token.Const(']', input), ([_5, input]) =>
+                If(Runtime.Token.Const(':', input), ([_6, input]) => If(Type(input, context), ([_7, input]) => If(Runtime.Token.Const('}', input), ([_8, input]) => [[_0, _1, _2, _3, _4, _5, _6, _7, _8], input]))),
+              ),
+            ),
+          ),
+        ),
+      ),
+    ),
+    ([_0, input]) => [S.MappedMapping(_0 as [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown], context), input],
+  )
+export const AsyncIterator = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('AsyncIterator', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input]))),
+    ),
+    ([_0, input]) => [S.AsyncIteratorMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const Iterator = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Iterator', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input]))),
+    ),
+    ([_0, input]) => [S.IteratorMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const Argument = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Argument', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input]))),
+    ),
+    ([_0, input]) => [S.ArgumentMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const Awaited = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Awaited', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input]))),
+    ),
+    ([_0, input]) => [S.AwaitedMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const Array = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Array', input), ([_0, input]) => If(Runtime.Token.Const('<', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input])))),
+    ([_0, input]) => [S.ArrayMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const Record = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Record', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) =>
+        If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const(',', input), ([_3, input]) => If(Type(input, context), ([_4, input]) => If(Runtime.Token.Const('>', input), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input])))),
+      ),
+    ),
+    ([_0, input]) => [S.RecordMapping(_0 as [unknown, unknown, unknown, unknown, unknown, unknown], context), input],
+  )
+export const Promise = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Promise', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input]))),
+    ),
+    ([_0, input]) => [S.PromiseMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const ConstructorParameters = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('ConstructorParameters', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input]))),
+    ),
+    ([_0, input]) => [S.ConstructorParametersMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const FunctionParameters = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Parameters', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input]))),
+    ),
+    ([_0, input]) => [S.FunctionParametersMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const InstanceType = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('InstanceType', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input]))),
+    ),
+    ([_0, input]) => [S.InstanceTypeMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const ReturnType = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('ReturnType', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input]))),
+    ),
+    ([_0, input]) => [S.ReturnTypeMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const Partial = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Partial', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input]))),
+    ),
+    ([_0, input]) => [S.PartialMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const Required = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Required', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input]))),
+    ),
+    ([_0, input]) => [S.RequiredMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const Pick = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Pick', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) =>
+        If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const(',', input), ([_3, input]) => If(Type(input, context), ([_4, input]) => If(Runtime.Token.Const('>', input), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input])))),
+      ),
+    ),
+    ([_0, input]) => [S.PickMapping(_0 as [unknown, unknown, unknown, unknown, unknown, unknown], context), input],
+  )
+export const Omit = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Omit', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) =>
+        If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const(',', input), ([_3, input]) => If(Type(input, context), ([_4, input]) => If(Runtime.Token.Const('>', input), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input])))),
+      ),
+    ),
+    ([_0, input]) => [S.OmitMapping(_0 as [unknown, unknown, unknown, unknown, unknown, unknown], context), input],
+  )
+export const Exclude = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Exclude', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) =>
+        If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const(',', input), ([_3, input]) => If(Type(input, context), ([_4, input]) => If(Runtime.Token.Const('>', input), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input])))),
+      ),
+    ),
+    ([_0, input]) => [S.ExcludeMapping(_0 as [unknown, unknown, unknown, unknown, unknown, unknown], context), input],
+  )
+export const Extract = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Extract', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) =>
+        If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const(',', input), ([_3, input]) => If(Type(input, context), ([_4, input]) => If(Runtime.Token.Const('>', input), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input])))),
+      ),
+    ),
+    ([_0, input]) => [S.ExtractMapping(_0 as [unknown, unknown, unknown, unknown, unknown, unknown], context), input],
+  )
+export const Uppercase = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Uppercase', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input]))),
+    ),
+    ([_0, input]) => [S.UppercaseMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const Lowercase = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Lowercase', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input]))),
+    ),
+    ([_0, input]) => [S.LowercaseMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const Capitalize = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Capitalize', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input]))),
+    ),
+    ([_0, input]) => [S.CapitalizeMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const Uncapitalize = (input: string, context: T.TProperties = {}): [unknown, string] | [] =>
+  If(
+    If(Runtime.Token.Const('Uncapitalize', input), ([_0, input]) =>
+      If(Runtime.Token.Const('<', input), ([_1, input]) => If(Type(input, context), ([_2, input]) => If(Runtime.Token.Const('>', input), ([_3, input]) => [[_0, _1, _2, _3], input]))),
+    ),
+    ([_0, input]) => [S.UncapitalizeMapping(_0 as [unknown, unknown, unknown, unknown], context), input],
+  )
+export const Date = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.Const('Date', input), ([_0, input]) => [S.DateMapping(_0 as 'Date', context), input])
+export const Uint8Array = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.Const('Uint8Array', input), ([_0, input]) => [S.Uint8ArrayMapping(_0 as 'Uint8Array', context), input])
+export const Reference = (input: string, context: T.TProperties = {}): [unknown, string] | [] => If(Runtime.Token.Ident(input), ([_0, input]) => [S.ReferenceMapping(_0 as string, context), input])
diff --git a/src/syntax/runtime.ts b/src/syntax/runtime.ts
deleted file mode 100644
index 92703afcc..000000000
--- a/src/syntax/runtime.ts
+++ /dev/null
@@ -1,802 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/syntax
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { Runtime } from '../parser/index'
-import * as t from '../type/index'
-
-// ------------------------------------------------------------------
-// Tokens
-// ------------------------------------------------------------------
-const Newline = '\n'
-const LBracket = '['
-const RBracket = ']'
-const LParen = '('
-const RParen = ')'
-const LBrace = '{'
-const RBrace = '}'
-const LAngle = '<'
-const RAngle = '>'
-const Question = '?'
-const Colon = ':'
-const Comma = ','
-const SemiColon = ';'
-const SingleQuote = "'"
-const DoubleQuote = '"'
-const Tilde = '`'
-const Equals = '='
-
-// ------------------------------------------------------------------
-// DestructureRight
-// ------------------------------------------------------------------
-// prettier-ignore
-function DestructureRight<T>(values: T[]): [T[], T | undefined] {
-  return (values.length > 0)
-    ? [values.slice(0, values.length - 1), values[values.length - 1]]
-    : [values, undefined]
-}
-
-// ------------------------------------------------------------------
-// Delimit
-// ------------------------------------------------------------------
-// prettier-ignore
-const DelimitHeadMapping = (results: unknown[]) => results.reduce((result: unknown[], value) => {
-  const [element, _delimiter] = value as [unknown, unknown]
-  return [...result, element]
-}, [] as unknown[])
-// prettier-ignore
-const DelimitHead = <Element extends Runtime.IParser, Delimiter extends Runtime.IParser>(element: Element, delimiter: Delimiter) => (
-  Runtime.Array(Runtime.Tuple([element, delimiter]), DelimitHeadMapping)
-)
-// prettier-ignore
-const DelimitTail = <Element extends Runtime.IParser>(element: Element) => Runtime.Union([
-  Runtime.Tuple([element]),
-  Runtime.Tuple([]),
-])
-// prettier-ignore
-const DelimitMapping = (results: [unknown[], unknown[]]) => {
-  return [...results[0], ...results[1]]
-}
-// prettier-ignore
-const Delimit = <Element extends Runtime.IParser, Delimiter extends Runtime.IParser>(element: Element, delimiter: Delimiter) => Runtime.Tuple([
-  DelimitHead(element, delimiter),
-  DelimitTail(element),
-], DelimitMapping)
-
-// ------------------------------------------------------------------
-// Dereference
-// ------------------------------------------------------------------
-const Dereference = (context: t.TProperties, key: string): t.TSchema => {
-  return key in context ? context[key] : t.Ref(key)
-}
-
-// ------------------------------------------------------------------
-// GenericArgumentsList
-// ------------------------------------------------------------------
-// prettier-ignore
-const GenericArgumentsList = Delimit(Runtime.Ident(), Runtime.Const(Comma))
-
-// ------------------------------------------------------------------
-// GenericArguments
-// ------------------------------------------------------------------
-// prettier-ignore
-const GenericArgumentsContext = (args: string[], context: t.TProperties) => {
-  return args.reduce((result, arg, index) => {
-    return { ...result, [arg]: t.Argument(index) }
-  }, context)
-}
-// prettier-ignore
-const GenericArgumentsMapping = (results: unknown[], context: t.TProperties) => {
-  return results.length === 3
-    ? GenericArgumentsContext(results[1] as string[], context)
-    : {}
-}
-// prettier-ignore
-const GenericArguments = Runtime.Tuple([
-  Runtime.Const(LAngle),
-  Runtime.Ref('GenericArgumentsList'),
-  Runtime.Const(RAngle),
-], (results, context) => GenericArgumentsMapping(results, context))
-
-// ------------------------------------------------------------------
-// GenericReference
-// ------------------------------------------------------------------
-function GenericReferenceMapping(results: unknown[], context: t.TProperties) {
-  const type = Dereference(context, results[0] as string)
-  const args = results[2] as t.TSchema[]
-  return t.Instantiate(type, args)
-}
-const GenericReferenceParameters = Delimit(Runtime.Ref('Type'), Runtime.Const(Comma))
-// prettier-ignore
-const GenericReference = Runtime.Tuple([
-  Runtime.Ident(), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref('GenericReferenceParameters'),
-  Runtime.Const(RAngle)
-], (results, context) => GenericReferenceMapping(results, context))
-
-// ------------------------------------------------------------------
-// Reference
-// ------------------------------------------------------------------
-function ReferenceMapping(result: string, context: t.TProperties) {
-  const target = Dereference(context, result)
-  return target
-}
-// prettier-ignore
-const Reference = Runtime.Ident((result, context) => ReferenceMapping(result, context))
-
-// ------------------------------------------------------------------
-// Literal
-// ------------------------------------------------------------------
-// prettier-ignore
-const Literal = Runtime.Union([
-  Runtime.Union([Runtime.Const('true'), Runtime.Const('false')], value => t.Literal(value === 'true')),
-  Runtime.Number(value => t.Literal(parseFloat(value))),
-  Runtime.String([SingleQuote, DoubleQuote, Tilde], value => t.Literal(value))
-])
-
-// ------------------------------------------------------------------
-// Keyword
-// ------------------------------------------------------------------
-// prettier-ignore
-const Keyword = Runtime.Union([
-  Runtime.Const('string', Runtime.As(t.String())),
-  Runtime.Const('number', Runtime.As(t.Number())),
-  Runtime.Const('boolean', Runtime.As(t.Boolean())),
-  Runtime.Const('undefined', Runtime.As(t.Undefined())),
-  Runtime.Const('null', Runtime.As(t.Null())),
-  Runtime.Const('integer', Runtime.As(t.Integer())),
-  Runtime.Const('bigint', Runtime.As(t.BigInt())),
-  Runtime.Const('unknown', Runtime.As(t.Unknown())),
-  Runtime.Const('any', Runtime.As(t.Any())),
-  Runtime.Const('never', Runtime.As(t.Never())),
-  Runtime.Const('symbol', Runtime.As(t.Symbol())),
-  Runtime.Const('void', Runtime.As(t.Void())),
-])
-
-// ------------------------------------------------------------------
-// KeyOf
-// ------------------------------------------------------------------
-// prettier-ignore
-const KeyOfMapping = (values: unknown[]) => (
-  values.length > 0
-)
-// prettier-ignore
-const KeyOf = Runtime.Union([
-  Runtime.Tuple([Runtime.Const('keyof')]), Runtime.Tuple([])
-], KeyOfMapping)
-
-// ------------------------------------------------------------------
-// IndexArray
-// ------------------------------------------------------------------
-// prettier-ignore
-const IndexArrayMapping = (results: ([unknown, unknown, unknown] | [unknown, unknown])[]) => {
-  return results.reduce((result: unknown[], current) => {
-    return current.length === 3 
-      ? [...result, [current[1]]] 
-      : [...result, []]
-  }, [] as unknown[])
-}
-// prettier-ignore
-const IndexArray = Runtime.Array(Runtime.Union([
-  Runtime.Tuple([Runtime.Const(LBracket), Runtime.Ref('Type'), Runtime.Const(RBracket)]),
-  Runtime.Tuple([Runtime.Const(LBracket), Runtime.Const(RBracket)]),
-]), IndexArrayMapping)
-
-// ------------------------------------------------------------------
-// Extends
-// ------------------------------------------------------------------
-// prettier-ignore
-const ExtendsMapping = (values: unknown[]) => {
-  return values.length === 6
-    ? [values[1], values[3], values[5]]
-    : []
-}
-// prettier-ignore
-const Extends = Runtime.Union([
-  Runtime.Tuple([Runtime.Const('extends'), Runtime.Ref('Type'), Runtime.Const(Question), Runtime.Ref('Type'), Runtime.Const(Colon), Runtime.Ref('Type')]),
-  Runtime.Tuple([])
-], ExtendsMapping)
-
-// ------------------------------------------------------------------
-// Base
-// ------------------------------------------------------------------
-// prettier-ignore
-const BaseMapping = (value: unknown) => {
-  return t.ValueGuard.IsArray(value) && value.length === 3 
-    ? value[1] 
-    : value
-}
-// prettier-ignore
-const Base = Runtime.Union([
-  Runtime.Tuple([Runtime.Const(LParen), Runtime.Ref('Type'), Runtime.Const(RParen)]),
-  Runtime.Ref('Keyword'),
-  Runtime.Ref('Object'),
-  Runtime.Ref('Tuple'),
-  Runtime.Ref('Literal'),
-  Runtime.Ref('Constructor'),
-  Runtime.Ref('Function'),
-  Runtime.Ref('Mapped'),
-  Runtime.Ref('AsyncIterator'),
-  Runtime.Ref('Iterator'),
-  Runtime.Ref('ConstructorParameters'),
-  Runtime.Ref('FunctionParameters'),
-  Runtime.Ref('InstanceType'),
-  Runtime.Ref('ReturnType'),
-  Runtime.Ref('Argument'),
-  Runtime.Ref('Awaited'),
-  Runtime.Ref('Array'),
-  Runtime.Ref('Record'),
-  Runtime.Ref('Promise'),
-  Runtime.Ref('Partial'),
-  Runtime.Ref('Required'),
-  Runtime.Ref('Pick'),
-  Runtime.Ref('Omit'),
-  Runtime.Ref('Exclude'),
-  Runtime.Ref('Extract'),
-  Runtime.Ref('Uppercase'),
-  Runtime.Ref('Lowercase'),
-  Runtime.Ref('Capitalize'),
-  Runtime.Ref('Uncapitalize'),
-  Runtime.Ref('Date'),
-  Runtime.Ref('Uint8Array'),
-  Runtime.Ref('GenericReference'),
-  Runtime.Ref('Reference')
-], BaseMapping)
-
-// ------------------------------------------------------------------
-// Factor
-// ------------------------------------------------------------------
-// prettier-ignore
-const FactorExtends = (Type: t.TSchema, Extends: t.TSchema[]) => {
-  return Extends.length === 3
-    ? t.Extends(Type, Extends[0], Extends[1], Extends[2])
-    : Type
-}
-// prettier-ignore
-const FactorIndexArray = (Type: t.TSchema, IndexArray: unknown[]): t.TSchema => {
-  const [Left, Right] = DestructureRight(IndexArray) as [unknown[], t.TSchema[]]
-  return (
-    !t.ValueGuard.IsUndefined(Right) ? (
-      // note: Indexed types require reimplementation to replace `[number]` indexers
-      Right.length === 1 ? t.Index(FactorIndexArray(Type, Left), Right[0]) as never :
-      Right.length === 0 ? t.Array(FactorIndexArray(Type, Left)) :
-      t.Never()
-    ) : Type
-  ) 
-}
-// prettier-ignore
-const FactorMapping = (KeyOf: boolean, Type: t.TSchema, IndexArray: unknown[], Extends: t.TSchema[]) => {
-  return KeyOf
-    ? FactorExtends(t.KeyOf(FactorIndexArray(Type, IndexArray)), Extends)
-    : FactorExtends(FactorIndexArray(Type, IndexArray), Extends)
-}
-// prettier-ignore
-const Factor = Runtime.Tuple([
-  Runtime.Ref<boolean>('KeyOf'), 
-  Runtime.Ref<t.TSchema>('Base'),
-  Runtime.Ref<unknown[]>('IndexArray'),
-  Runtime.Ref<t.TSchema[]>('Extends')
-], results => FactorMapping(...results))
-
-// ------------------------------------------------------------------
-// Expr
-// ------------------------------------------------------------------
-// prettier-ignore
-function ExprBinaryMapping(Left: t.TSchema, Rest: unknown[]): t.TSchema {
-  return (
-    Rest.length === 3 ? (() => {
-      const [Operator, Right, Next] = Rest as [string, t.TSchema, unknown[]]
-      const Schema = ExprBinaryMapping(Right, Next)
-      if (Operator === '&') {
-        return t.TypeGuard.IsIntersect(Schema)
-          ? t.Intersect([Left, ...Schema.allOf])
-          : t.Intersect([Left, Schema])
-      }
-      if (Operator === '|') {
-        return t.TypeGuard.IsUnion(Schema)
-          ? t.Union([Left, ...Schema.anyOf])
-          : t.Union([Left, Schema])
-      }
-      throw 1
-    })() : Left
-  )
-}
-// prettier-ignore
-const ExprTermTail = Runtime.Union([
-  Runtime.Tuple([Runtime.Const('&'), Runtime.Ref('Factor'), Runtime.Ref('ExprTermTail')]),
-  Runtime.Tuple([])
-])
-// prettier-ignore
-const ExprTerm = Runtime.Tuple([
-  Runtime.Ref<t.TSchema>('Factor'), Runtime.Ref<unknown[]>('ExprTermTail')
-], results => ExprBinaryMapping(...results))
-// prettier-ignore
-const ExprTail = Runtime.Union([
-  Runtime.Tuple([Runtime.Const('|'), Runtime.Ref('ExprTerm'), Runtime.Ref('ExprTail')]),
-  Runtime.Tuple([])
-])
-// prettier-ignore
-const Expr = Runtime.Tuple([
-  Runtime.Ref<t.TSchema>('ExprTerm'), Runtime.Ref<unknown[]>('ExprTail')
-], results => ExprBinaryMapping(...results))
-
-// ------------------------------------------------------------------
-// Type
-// ------------------------------------------------------------------
-// prettier-ignore
-const Type = Runtime.Union([
-  Runtime.Context(Runtime.Ref('GenericArguments'), Runtime.Ref('Expr')), 
-  Runtime.Ref('Expr')
-])
-
-// ------------------------------------------------------------------
-// Property
-// ------------------------------------------------------------------
-const PropertyKey = Runtime.Union([Runtime.Ident(), Runtime.String([SingleQuote, DoubleQuote])])
-const Readonly = Runtime.Union([Runtime.Tuple([Runtime.Const('readonly')]), Runtime.Tuple([])], (value) => value.length > 0)
-const Optional = Runtime.Union([Runtime.Tuple([Runtime.Const(Question)]), Runtime.Tuple([])], (value) => value.length > 0)
-// prettier-ignore
-const PropertyMapping = (IsReadonly: boolean, Key: string, IsOptional: boolean, _: typeof Colon, Type: t.TSchema) => ({
-  [Key]: (
-    IsReadonly && IsOptional ? t.ReadonlyOptional(Type) :
-    IsReadonly && !IsOptional ? t.Readonly(Type) :
-    !IsReadonly && IsOptional ? t.Optional(Type) :
-    Type
-  )
-})
-// prettier-ignore
-const Property = Runtime.Tuple([
-  Runtime.Ref<boolean>('Readonly'),
-  Runtime.Ref<string>('PropertyKey'),
-  Runtime.Ref<boolean>('Optional'),
-  Runtime.Const(Colon),
-  Runtime.Ref<t.TSchema>('Type'),
-], results => PropertyMapping(...results))
-
-// ------------------------------------------------------------------
-// PropertyDelimiter
-// ------------------------------------------------------------------
-// prettier-ignore
-const PropertyDelimiter = Runtime.Union([
-  Runtime.Tuple([Runtime.Const(Comma), Runtime.Const(Newline)]),
-  Runtime.Tuple([Runtime.Const(SemiColon), Runtime.Const(Newline)]),
-  Runtime.Tuple([Runtime.Const(Comma)]),
-  Runtime.Tuple([Runtime.Const(SemiColon)]),
-  Runtime.Tuple([Runtime.Const(Newline)]),
-])
-
-// ------------------------------------------------------------------
-// PropertyList
-// ------------------------------------------------------------------
-const PropertyList = Delimit(Runtime.Ref('Property'), Runtime.Ref('PropertyDelimiter'))
-
-// ------------------------------------------------------------------
-// Object
-// ------------------------------------------------------------------
-// prettier-ignore
-const ObjectMapping = (results: unknown[]) => {
-  const propertyList = results[1] as t.TProperties[]
-  return t.Object(propertyList.reduce((result, property) => {
-    return { ...result, ...property }
-  }, {} as t.TProperties))
-}
-// prettier-ignore
-const _Object = Runtime.Tuple([
-  Runtime.Const(LBrace),
-  Runtime.Ref('PropertyList'),
-  Runtime.Const(RBrace)
-], ObjectMapping)
-
-// ------------------------------------------------------------------
-// ElementList
-// ------------------------------------------------------------------
-const ElementList = Delimit(Runtime.Ref('Type'), Runtime.Const(Comma))
-
-// ------------------------------------------------------------------
-// Tuple
-// ------------------------------------------------------------------
-// prettier-ignore
-const Tuple = Runtime.Tuple([
-  Runtime.Const(LBracket),
-  Runtime.Ref<t.TSchema[]>('ElementList'),
-  Runtime.Const(RBracket)
-], results => t.Tuple(results[1]))
-
-// ------------------------------------------------------------------
-// Parameters
-// ------------------------------------------------------------------
-// prettier-ignore
-const Parameter = Runtime.Tuple([
-  Runtime.Ident(), Runtime.Const(Colon), Runtime.Ref<t.TSchema>('Type')
-], results => results[2])
-
-// ------------------------------------------------------------------
-// ParameterList
-// ------------------------------------------------------------------
-const ParameterList = Delimit(Runtime.Ref('Parameter'), Runtime.Const(Comma))
-
-// ------------------------------------------------------------------
-// Constructor
-// ------------------------------------------------------------------
-// prettier-ignore
-const Constructor = Runtime.Tuple([
-  Runtime.Const('new'), 
-  Runtime.Const(LParen), 
-  Runtime.Ref<t.TSchema[]>('ParameterList'), 
-  Runtime.Const(RParen), 
-  Runtime.Const('=>'), 
-  Runtime.Ref<t.TSchema>('Type')
-], results => t.Constructor(results[2], results[5]))
-
-// ------------------------------------------------------------------
-// Function
-// ------------------------------------------------------------------
-// prettier-ignore
-const Function = Runtime.Tuple([
-  Runtime.Const(LParen), 
-  Runtime.Ref<t.TSchema[]>('ParameterList'), 
-  Runtime.Const(RParen), 
-  Runtime.Const('=>'), 
-  Runtime.Ref<t.TSchema>('Type')
-], results => t.Function(results[1], results[4]))
-
-// ------------------------------------------------------------------
-// Mapped (requires deferred types)
-// ------------------------------------------------------------------
-// prettier-ignore
-const MappedMapping = (results: unknown[]) => {
-  return t.Literal('Mapped types not supported')
-}
-// prettier-ignore
-const Mapped = Runtime.Tuple([
-  Runtime.Const(LBrace), 
-  Runtime.Const(LBracket), 
-  Runtime.Ident(), 
-  Runtime.Const('in'), 
-  Runtime.Ref('Type'), 
-  Runtime.Const(RBracket), 
-  Runtime.Const(Colon), 
-  Runtime.Ref('Type'), 
-  Runtime.Const(RBrace)
-], MappedMapping)
-
-// ------------------------------------------------------------------
-// AsyncIterator
-// ------------------------------------------------------------------
-// prettier-ignore
-const AsyncIterator = Runtime.Tuple([
-  Runtime.Const('AsyncIterator'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(RAngle),
-], results => t.AsyncIterator(results[2]))
-
-// ------------------------------------------------------------------
-// Iterator
-// ------------------------------------------------------------------
-// prettier-ignore
-const Iterator = Runtime.Tuple([
-  Runtime.Const('Iterator'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(RAngle),
-], results => t.Iterator(results[2]))
-
-// ------------------------------------------------------------------
-// ConstructorParameters
-// ------------------------------------------------------------------
-// prettier-ignore
-const ConstructorParameters = Runtime.Tuple([
-  Runtime.Const('ConstructorParameters'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TConstructor>('Type'), 
-  Runtime.Const(RAngle),
-], results => t.ConstructorParameters(results[2]))
-
-// ------------------------------------------------------------------
-// Parameters
-// ------------------------------------------------------------------
-// prettier-ignore
-const FunctionParameters = Runtime.Tuple([
-  Runtime.Const('Parameters'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TFunction>('Type'), 
-  Runtime.Const(RAngle),
-], results => t.Parameters(results[2]))
-
-// ------------------------------------------------------------------
-// InstanceType
-// ------------------------------------------------------------------
-// prettier-ignore
-const InstanceType = Runtime.Tuple([
-  Runtime.Const('InstanceType'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TConstructor>('Type'), 
-  Runtime.Const(RAngle),
-], results => t.InstanceType(results[2]))
-
-// ------------------------------------------------------------------
-// ReturnType
-// ------------------------------------------------------------------
-// prettier-ignore
-const ReturnType = Runtime.Tuple([
-  Runtime.Const('ReturnType'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TFunction>('Type'), 
-  Runtime.Const(RAngle),
-], results => t.ReturnType(results[2]))
-
-// ------------------------------------------------------------------
-// Argument
-// ------------------------------------------------------------------
-// prettier-ignore
-const Argument = Runtime.Tuple([
-  Runtime.Const('Argument'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(RAngle),
-], results => {
-  return t.KindGuard.IsLiteralNumber(results[2])
-    ? t.Argument(Math.trunc(results[2].const))
-    : t.Never()
-})
-
-// ------------------------------------------------------------------
-// Awaited
-// ------------------------------------------------------------------
-// prettier-ignore
-const Awaited = Runtime.Tuple([
-  Runtime.Const('Awaited'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(RAngle),
-], results => t.Awaited(results[2]))
-
-// ------------------------------------------------------------------
-// Array
-// ------------------------------------------------------------------
-// prettier-ignore
-const Array = Runtime.Tuple([
-  Runtime.Const('Array'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(RAngle),
-], results => t.Array(results[2]))
-
-// ------------------------------------------------------------------
-// Record
-// ------------------------------------------------------------------
-// prettier-ignore
-const Record = Runtime.Tuple([
-  Runtime.Const('Record'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'),
-  Runtime.Const(Comma), 
-  Runtime.Ref<t.TSchema>('Type'),
-  Runtime.Const(RAngle),  
-], results => t.Record(results[2], results[4]))
-
-// ------------------------------------------------------------------
-// Promise
-// ------------------------------------------------------------------
-// prettier-ignore
-const Promise = Runtime.Tuple([
-  Runtime.Const('Promise'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(RAngle),  
-], results => t.Promise(results[2]))
-
-// ------------------------------------------------------------------
-// Partial
-// ------------------------------------------------------------------
-// prettier-ignore
-const Partial = Runtime.Tuple([
-  Runtime.Const('Partial'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(RAngle),  
-], results => t.Partial(results[2]))
-
-// ------------------------------------------------------------------
-// Required
-// ------------------------------------------------------------------
-// prettier-ignore
-const Required = Runtime.Tuple([
-  Runtime.Const('Required'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(RAngle),  
-], results => t.Required(results[2]))
-
-// ------------------------------------------------------------------
-// Pick
-// ------------------------------------------------------------------
-// prettier-ignore
-const Pick = Runtime.Tuple([
-  Runtime.Const('Pick'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(Comma), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(RAngle),  
-], results => t.Pick(results[2], results[4]))
-
-// ------------------------------------------------------------------
-// Omit
-// ------------------------------------------------------------------
-// prettier-ignore
-const Omit = Runtime.Tuple([
-  Runtime.Const('Omit'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(Comma), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(RAngle),  
-], results => t.Omit(results[2], results[4]))
-
-// ------------------------------------------------------------------
-// Exclude
-// ------------------------------------------------------------------
-// prettier-ignore
-const Exclude = Runtime.Tuple([
-  Runtime.Const('Exclude'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(Comma), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(RAngle),  
-], results => t.Exclude(results[2], results[4]))
-
-// ------------------------------------------------------------------
-// Extract
-// ------------------------------------------------------------------
-// prettier-ignore
-const Extract = Runtime.Tuple([
-  Runtime.Const('Extract'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(Comma), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(RAngle),  
-], results => t.Extract(results[2], results[4]))
-
-// ------------------------------------------------------------------
-// Uppercase
-// ------------------------------------------------------------------
-// prettier-ignore
-const Uppercase = Runtime.Tuple([
-  Runtime.Const('Uppercase'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(RAngle),  
-], results => t.Uppercase(results[2]))
-
-// ------------------------------------------------------------------
-// Lowercase
-// ------------------------------------------------------------------
-// prettier-ignore
-const Lowercase = Runtime.Tuple([
-  Runtime.Const('Lowercase'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(RAngle),  
-], results => t.Lowercase(results[2]))
-
-// ------------------------------------------------------------------
-// Capitalize
-// ------------------------------------------------------------------
-// prettier-ignore
-const Capitalize = Runtime.Tuple([
-  Runtime.Const('Capitalize'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(RAngle),  
-], results => t.Capitalize(results[2]))
-
-// ------------------------------------------------------------------
-// Uncapitalize
-// ------------------------------------------------------------------
-// prettier-ignore
-const Uncapitalize = Runtime.Tuple([
-  Runtime.Const('Uncapitalize'), 
-  Runtime.Const(LAngle), 
-  Runtime.Ref<t.TSchema>('Type'), 
-  Runtime.Const(RAngle),  
-], results => t.Uncapitalize(results[2]))
-
-// ------------------------------------------------------------------
-// Date
-// ------------------------------------------------------------------
-const Date = Runtime.Const('Date', Runtime.As(t.Date()))
-
-// ------------------------------------------------------------------
-// Uint8Array
-// ------------------------------------------------------------------
-const Uint8Array = Runtime.Const('Uint8Array', Runtime.As(t.Uint8Array()))
-
-// ------------------------------------------------------------------
-// Module
-// ------------------------------------------------------------------
-// prettier-ignore
-export const Module = new Runtime.Module({
-  GenericArgumentsList,
-  GenericArguments,
-  Literal,
-  Keyword,
-  KeyOf,
-  IndexArray,
-  Extends,
-  Base,
-  Factor,
-  ExprTermTail,
-  ExprTerm,
-  ExprTail,
-  Expr,
-  Type,
-  PropertyKey,
-  Readonly,
-  Optional,
-  Property,
-  PropertyDelimiter,
-  PropertyList,
-  Object: _Object,
-  ElementList,
-  Tuple,
-  Parameter,
-  ParameterList,
-  Function,
-  Constructor,
-  Mapped,
-  AsyncIterator,
-  Iterator,
-  Argument,
-  Awaited,
-  Array,
-  Record,
-  Promise,
-  ConstructorParameters,
-  FunctionParameters,
-  InstanceType,
-  ReturnType,
-  Partial,
-  Required,
-  Pick,
-  Omit,
-  Exclude,
-  Extract,
-  Uppercase,
-  Lowercase,
-  Capitalize,
-  Uncapitalize,
-  Date,
-  Uint8Array,
-  GenericReferenceParameters,
-  GenericReference,
-  Reference,
-})
diff --git a/src/syntax/static.ts b/src/syntax/static.ts
deleted file mode 100644
index 609fc3d7b..000000000
--- a/src/syntax/static.ts
+++ /dev/null
@@ -1,836 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/syntax
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2025 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { Static } from '../parser/index'
-import * as t from '../type/index'
-
-// ------------------------------------------------------------------
-// Tokens
-// ------------------------------------------------------------------
-type Newline = '\n'
-type LBracket = '['
-type RBracket = ']'
-type LParen = '('
-type RParen = ')'
-type LBrace = '{'
-type RBrace = '}'
-type LAngle = '<'
-type RAngle = '>'
-type Question = '?'
-type Colon = ':'
-type Comma = ','
-type SemiColon = ';'
-type SingleQuote = "'"
-type DoubleQuote = '"'
-type Tilde = '`'
-type Equals = '='
-
-// ------------------------------------------------------------------
-// Delimit
-// ------------------------------------------------------------------
-// prettier-ignore
-type DelimitHeadReduce<Elements extends unknown[], Result extends unknown[] = []> = (
-  Elements extends [infer Left extends unknown, ...infer Right extends unknown[]]
-    ? Left extends [infer Element, infer _Delimiter]
-      ? DelimitHeadReduce<Right, [...Result, Element]>
-      : DelimitHeadReduce<Right, Result>
-    : Result
-)
-// prettier-ignore
-interface DelimitHeadMapping extends Static.IMapping {
-  output: this['input'] extends unknown[] 
-    ? DelimitHeadReduce<this['input']> 
-    : []
-}
-// prettier-ignore
-type DelimitHead<Element extends Static.IParser, Delimiter extends Static.IParser> = (
-  Static.Array<Static.Tuple<[Element, Delimiter]>, DelimitHeadMapping>
-)
-// prettier-ignore
-type DelimitTail<Element extends Static.IParser> = Static.Union<[
-  Static.Tuple<[Element]>,
-  Static.Tuple<[]>,
-]>
-// prettier-ignore
-interface DelimitMapping extends Static.IMapping {
-  output: this['input'] extends [infer Left extends unknown[], infer Right extends unknown[]]
-    ? [...Left, ...Right]
-    : []
-}
-// prettier-ignore
-type Delimit<Element extends Static.IParser, Delimiter extends Static.IParser> = Static.Tuple<[
-  DelimitHead<Element, Delimiter>,
-  DelimitTail<Element>
-], DelimitMapping>
-
-// ------------------------------------------------------------------
-// Dereference
-// ------------------------------------------------------------------
-// prettier-ignore
-type Dereference<Context extends t.TProperties, Ref extends string> = (
-  Ref extends keyof Context ? Context[Ref] : t.TRef<Ref>
-)
-
-// ------------------------------------------------------------------
-// GenericArguments
-// ------------------------------------------------------------------
-// prettier-ignore
-type GenericArgumentsContext<Args extends string[], Context extends t.TProperties, Result extends t.TProperties = {}> = (
-  Args extends [...infer Left extends string[], infer Right extends string]
-    ? GenericArgumentsContext<Left, Context, Result & { [_ in Right]: t.TArgument<Left['length']> }>
-    : t.Evaluate<Result & Context>
-)
-// prettier-ignore
-interface GenericArgumentsMapping extends Static.IMapping {
-  output: this['input'] extends [LAngle, infer Args extends string[], RAngle]
-    ? this['context'] extends infer Context extends t.TProperties
-        ? GenericArgumentsContext<Args, Context>
-        : never
-    : never
-}
-type GenericArgumentsList = Delimit<Static.Ident, Static.Const<Comma>>
-// prettier-ignore
-type GenericArguments = Static.Tuple<[
-  Static.Const<LAngle>,
-  GenericArgumentsList,
-  Static.Const<RAngle>,
-], GenericArgumentsMapping>
-
-// ------------------------------------------------------------------
-// GenericReference
-// ------------------------------------------------------------------
-// prettier-ignore
-interface GenericReferenceMapping extends Static.IMapping {
-  output: this['context'] extends t.TProperties
-    ? this['input'] extends [infer Reference extends string, LAngle, infer Args extends t.TSchema[], RAngle]
-      ? t.TInstantiate<Dereference<this['context'], Reference>, Args>
-      : never
-    : never  
-}
-type GenericReferenceParameters = Delimit<Type, Static.Const<Comma>>
-// prettier-ignore
-type GenericReference = Static.Tuple<[
-  Static.Ident,
-  Static.Const<LAngle>,
-  GenericReferenceParameters,
-  Static.Const<RAngle>,
-], GenericReferenceMapping>
-
-// ------------------------------------------------------------------
-// Reference
-// ------------------------------------------------------------------
-// prettier-ignore
-interface ReferenceMapping extends Static.IMapping {
-  output: this['context'] extends t.TProperties
-    ? this['input'] extends string
-      ? Dereference<this['context'], this['input']>
-      : never
-    : never  
-}
-type Reference = Static.Ident<ReferenceMapping>
-
-// ------------------------------------------------------------------
-// Literal
-// ------------------------------------------------------------------
-// prettier-ignore
-interface LiteralBooleanMapping extends Static.IMapping {
-  output: this['input'] extends `${infer Value extends boolean}` ? t.TLiteral<Value> : never
-}
-// prettier-ignore
-interface LiteralNumberMapping extends Static.IMapping {
-  output: this['input'] extends `${infer Value extends number}` ? t.TLiteral<Value> : never
-}
-// prettier-ignore
-interface LiteralStringMapping extends Static.IMapping {
-  output: this['input'] extends `${infer Value extends string}` ? t.TLiteral<Value> : never
-}
-// prettier-ignore
-type Literal = Static.Union<[
-  Static.Union<[Static.Const<'true'>, Static.Const<'false'>], LiteralBooleanMapping>,
-  Static.Number<LiteralNumberMapping>,
-  Static.String<[DoubleQuote, SingleQuote, Tilde], LiteralStringMapping>,
-]>
-
-// ------------------------------------------------------------------
-// Keyword
-// ------------------------------------------------------------------
-// prettier-ignore
-type Keyword = Static.Union<[
-  Static.Const<'string', Static.As<t.TString>>,
-  Static.Const<'number', Static.As<t.TNumber>>,
-  Static.Const<'boolean', Static.As<t.TBoolean>>,
-  Static.Const<'undefined', Static.As<t.TUndefined>>,
-  Static.Const<'null', Static.As<t.TNull>>,
-  Static.Const<'integer', Static.As<t.TInteger>>,
-  Static.Const<'bigint', Static.As<t.TBigInt>>,
-  Static.Const<'unknown', Static.As<t.TUnknown>>,
-  Static.Const<'any', Static.As<t.TAny>>,
-  Static.Const<'never', Static.As<t.TNever>>,
-  Static.Const<'symbol', Static.As<t.TSymbol>>,
-  Static.Const<'void', Static.As<t.TVoid>>,
-]>
-
-// ------------------------------------------------------------------
-// KeyOf
-// ------------------------------------------------------------------
-// prettier-ignore
-interface KeyOfMapping extends Static.IMapping {
-  output: this['input'] extends [] ? false : true
-}
-// prettier-ignore
-type KeyOf = Static.Union<[
-  Static.Tuple<[Static.Const<'keyof'>]>,
-  Static.Tuple<[]>
-], KeyOfMapping>
-
-// ------------------------------------------------------------------
-// IndexArray
-// ------------------------------------------------------------------
-// prettier-ignore
-type IndexArrayReduce<Values extends unknown[], Result extends unknown[] = []> = (
-  Values extends [infer Left extends unknown, ...infer Right extends unknown[]]
-    ? Left extends [LBracket, infer Type extends t.TSchema, RBracket] 
-      ? IndexArrayReduce<Right, [...Result, [Type]]>
-      : IndexArrayReduce<Right, [...Result, []]>
-    : Result
-)
-// prettier-ignore
-interface IndexArrayMapping extends Static.IMapping {
-  output: this['input'] extends unknown[] 
-    ? IndexArrayReduce<this['input']> 
-    : []
-}
-// prettier-ignore
-type IndexArray = Static.Array<Static.Union<[
-  Static.Tuple<[Static.Const<LBracket>, Type, Static.Const<RBracket>,]>,
-  Static.Tuple<[Static.Const<LBracket>, Static.Const<RBracket>]>,
-]>, IndexArrayMapping>
-
-// ------------------------------------------------------------------
-// Extends
-// ------------------------------------------------------------------
-// prettier-ignore
-interface ExtendsMapping extends Static.IMapping {
-  output: this['input'] extends ['extends', infer Type extends t.TSchema, Question, infer True extends t.TSchema, Colon, infer False extends t.TSchema]
-    ? [Type, True, False]
-    : []
-}
-// prettier-ignore
-type Extends = Static.Union<[
-  Static.Tuple<[Static.Const<'extends'>, Type, Static.Const<Question>, Type, Static.Const<Colon>, Type]>,
-  Static.Tuple<[]>
-], ExtendsMapping>
-
-// ------------------------------------------------------------------
-// Base
-// ------------------------------------------------------------------
-// prettier-ignore
-interface BaseMapping extends Static.IMapping {
-  output: (
-    this['input'] extends [LParen, infer Type extends t.TSchema, RParen] ? Type :
-    this['input'] extends infer Type extends t.TSchema ? Type :
-    never
-  )
-}
-// prettier-ignore
-type Base = Static.Union<[
-  Static.Tuple<[Static.Const<LParen>, Type, Static.Const<RParen>]>,
-  Keyword,
-  Object, 
-  Tuple,
-  Literal,
-  Function,
-  Constructor,
-  Mapped,
-  AsyncIterator,
-  Iterator,
-  ConstructorParameters,
-  FunctionParameters,
-  Argument,
-  InstanceType,
-  ReturnType,
-  Awaited,
-  Array,
-  Record,
-  Promise,
-  Partial,
-  Required,
-  Pick,
-  Omit,
-  Exclude,
-  Extract,
-  Lowercase,
-  Uppercase,
-  Capitalize,
-  Uncapitalize,
-  Date,
-  Uint8Array,
-  GenericReference,
-  Reference
-], BaseMapping>
-
-// ------------------------------------------------------------------
-// Factor
-// ------------------------------------------------------------------
-// prettier-ignore
-type FactorExtends<Type extends t.TSchema, Extends extends unknown[]> = (
-  Extends extends [infer Right extends t.TSchema, infer True extends t.TSchema, infer False extends t.TSchema] 
-    ? t.TExtends<Type, Right, True, False>
-    : Type
-)
-// prettier-ignore
-type FactorIndexArray<Type extends t.TSchema, IndexArray extends unknown[]> = (
-  IndexArray extends [...infer Left extends unknown[], infer Right extends t.TSchema[]] ? (
-    Right extends [infer Indexer extends t.TSchema] ? t.TIndex<FactorIndexArray<Type, Left>, t.TIndexPropertyKeys<Indexer>> : 
-    Right extends [] ? t.TArray<FactorIndexArray<Type, Left>> :
-    t.TNever
-  ) : Type
-)
-// prettier-ignore
-interface FactorMapping extends Static.IMapping {
-  output: this['input'] extends [infer KeyOf extends boolean, infer Type extends t.TSchema, infer IndexArray extends unknown[], infer Extends extends unknown[]]
-  ? KeyOf extends true
-    ? FactorExtends<t.TKeyOf<FactorIndexArray<Type, IndexArray>>, Extends>
-    : FactorExtends<FactorIndexArray<Type, IndexArray>, Extends>
-  : never
-}
-// prettier-ignore
-type Factor = Static.Tuple<[
-  KeyOf, Base, IndexArray, Extends
-], FactorMapping>
-
-// ------------------------------------------------------------------
-// Expr
-// ------------------------------------------------------------------
-// prettier-ignore
-type ExprBinaryReduce<Left extends t.TSchema, Rest extends unknown[]> = (
-  Rest extends [infer Operator extends unknown, infer Right extends t.TSchema, infer Next extends unknown[]] ? (
-    ExprBinaryReduce<Right, Next> extends infer Schema extends t.TSchema ? (
-      Operator extends '&' ? (
-        Schema extends t.TIntersect<infer Types extends t.TSchema[]>
-        ? t.TIntersect<[Left, ...Types]>
-        : t.TIntersect<[Left, Schema]>
-      ) :
-      Operator extends '|' ? (
-        Schema extends t.TUnion<infer Types extends t.TSchema[]>
-        ? t.TUnion<[Left, ...Types]>
-        : t.TUnion<[Left, Schema]>
-      ) : never
-    ) : never
-  ) : Left
-)
-// prettier-ignore
-interface ExprBinaryMapping extends Static.IMapping {
-  output: (
-    this['input'] extends [infer Left extends t.TSchema, infer Rest extends unknown[]]
-    ? ExprBinaryReduce<Left, Rest>
-    : []
-  )
-}
-// prettier-ignore
-type ExprTermTail = Static.Union<[
-  Static.Tuple<[Static.Const<'&'>, Factor, ExprTermTail]>,
-  Static.Tuple<[]>
-]>
-// prettier-ignore
-type ExprTerm = Static.Tuple<[
-  Factor, ExprTermTail
-], ExprBinaryMapping>
-// prettier-ignore
-type ExprTail = Static.Union<[
-  Static.Tuple<[Static.Const<'|'>, ExprTerm, ExprTail]>,
-  Static.Tuple<[]>
-]>
-// prettier-ignore
-type Expr = Static.Tuple<[
-  ExprTerm, ExprTail
-], ExprBinaryMapping>
-
-// ------------------------------------------------------------------
-// Type
-// ------------------------------------------------------------------
-// prettier-ignore
-export type Type = Static.Union<[
-  Static.Context<GenericArguments, Expr>, 
-  Expr
-]>
-
-// ------------------------------------------------------------------
-// Property
-// ------------------------------------------------------------------
-// prettier-ignore
-interface PropertyKeyStringMapping extends Static.IMapping {
-  output: this['input']
-}
-type PropertyKeyString = Static.String<[SingleQuote, DoubleQuote], PropertyKeyStringMapping>
-type PropertyKey = Static.Union<[Static.Ident, PropertyKeyString]>
-// prettier-ignore
-interface ReadonlyMapping extends Static.IMapping {
-  output: this['input'] extends ['readonly'] ? true : false
-}
-type Readonly = Static.Union<[Static.Tuple<[Static.Const<'readonly'>]>, Static.Tuple<[]>], ReadonlyMapping>
-// prettier-ignore
-interface OptionalMapping extends Static.IMapping {
-  output: this['input'] extends [Question] ? true : false
-}
-type Optional = Static.Union<[Static.Tuple<[Static.Const<Question>]>, Static.Tuple<[]>], OptionalMapping>
-// prettier-ignore
-interface PropertyMapping extends Static.IMapping {
-  output: this['input'] extends [infer IsReadonly extends boolean, infer Key extends string, infer IsOptional extends boolean, string, infer Type extends t.TSchema]
-  ? { 
-    [_ in Key]: (
-      [IsReadonly, IsOptional] extends [true, true] ? t.TReadonlyOptional<Type> :
-      [IsReadonly, IsOptional] extends [true, false] ? t.TReadonly<Type> :
-      [IsReadonly, IsOptional] extends [false, true] ? t.TOptional<Type> :
-      Type 
-    ) 
-  } : never
-}
-type Property = Static.Tuple<[Readonly, PropertyKey, Optional, Static.Const<Colon>, Type], PropertyMapping>
-
-// ------------------------------------------------------------------
-// PropertyDelimiter
-// ------------------------------------------------------------------
-// prettier-ignore
-type PropertyDelimiter = Static.Union<[
-  Static.Tuple<[Static.Const<Comma>, Static.Const<Newline>]>,
-  Static.Tuple<[Static.Const<SemiColon>, Static.Const<Newline>]>,
-  Static.Tuple<[Static.Const<Comma>]>,
-  Static.Tuple<[Static.Const<SemiColon>]>,
-  Static.Tuple<[Static.Const<Newline>]>,
-]>
-
-// ------------------------------------------------------------------
-// PropertyList
-// ------------------------------------------------------------------
-type PropertyList = Delimit<Property, PropertyDelimiter>
-
-// ------------------------------------------------------------------
-// Object
-// ------------------------------------------------------------------
-// prettier-ignore
-type ObjectReduce<PropertiesList extends t.TProperties[], Result extends t.TProperties = {}> = (
-  PropertiesList extends [infer Left extends t.TProperties, ...infer Right extends t.TProperties[]]
-  ? ObjectReduce<Right, Result & Left>
-  : t.Evaluate<Result>
-)
-// prettier-ignore
-interface ObjectMapping extends Static.IMapping {
-  output: this['input'] extends [LBrace, infer PropertyList extends t.TProperties[], RBrace] 
-    ? t.TObject<ObjectReduce<PropertyList>> 
-    : never
-}
-// prettier-ignore
-type Object = Static.Tuple<[
-  Static.Const<LBrace>,
-  PropertyList, 
-  Static.Const<RBrace>
-], ObjectMapping>
-
-// ------------------------------------------------------------------
-// ElementList
-// ------------------------------------------------------------------
-type ElementList = Delimit<Type, Static.Const<Comma>>
-
-// ------------------------------------------------------------------
-// Tuple
-// ------------------------------------------------------------------
-// prettier-ignore
-interface TupleMapping extends Static.IMapping {
-  output: this['input'] extends [unknown, infer ElementList extends t.TSchema[], unknown] 
-    ? t.TTuple<ElementList> 
-    : never
-}
-// prettier-ignore
-type Tuple = Static.Tuple<[
-  Static.Const<LBracket>, ElementList, Static.Const<RBracket>
-], TupleMapping>
-
-// ------------------------------------------------------------------
-// Parameter
-// ------------------------------------------------------------------
-interface ParameterMapping extends Static.IMapping {
-  output: this['input'] extends [string, Colon, infer Type extends t.TSchema] ? Type : never
-}
-// prettier-ignore
-type Parameter = Static.Tuple<[
-  Static.Ident, Static.Const<Colon>, Type
-], ParameterMapping>
-
-// ------------------------------------------------------------------
-// ParameterList
-// ------------------------------------------------------------------
-type ParameterList = Delimit<Parameter, Static.Const<Comma>>
-
-// ------------------------------------------------------------------
-// Function
-// ------------------------------------------------------------------
-// prettier-ignore
-interface FunctionMapping extends Static.IMapping {
-  output: this['input'] extends [LParen, infer ParameterList extends t.TSchema[], RParen, '=>', infer ReturnType extends t.TSchema]
-    ? t.TFunction<ParameterList, ReturnType>
-    : never
-}
-// prettier-ignore
-type Function = Static.Tuple<[
-  Static.Const<LParen>, ParameterList, Static.Const<RParen>, Static.Const<'=>'>, Type
-], FunctionMapping>
-
-// ------------------------------------------------------------------
-// Constructor
-// ------------------------------------------------------------------
-// prettier-ignore
-interface ConstructorMapping extends Static.IMapping {
-  output: this['input'] extends ['new', LParen, infer ParameterList extends t.TSchema[], RParen, '=>', infer InstanceType extends t.TSchema]
-    ? t.TConstructor<ParameterList, InstanceType>
-    : never
-}
-// prettier-ignore
-type Constructor = Static.Tuple<[
-  Static.Const<'new'>, Static.Const<LParen>, ParameterList, Static.Const<RParen>, Static.Const<'=>'>, Type
-], ConstructorMapping>
-
-// ------------------------------------------------------------------
-// Mapped (requires deferred types)
-// ------------------------------------------------------------------
-// prettier-ignore
-interface MappedMapping extends Static.IMapping {
-  output: this['input'] extends [LBrace, LBracket, infer _Key extends string, 'in', infer _Right extends t.TSchema, RBracket, Colon, infer Type extends t.TSchema, RBrace]
-    ? t.TLiteral<'Mapped types not supported'>
-    : this['input']
-}
-// prettier-ignore
-type Mapped = Static.Tuple<[
-  Static.Const<LBrace>, Static.Const<LBracket>, Static.Ident, Static.Const<'in'>, Type, Static.Const<RBracket>, Static.Const<Colon>, Type, Static.Const<RBrace>
-], MappedMapping>
-
-// ------------------------------------------------------------------
-// Array
-// ------------------------------------------------------------------
-// prettier-ignore
-interface ArrayMapping extends Static.IMapping {
-  output: this['input'] extends ['Array', LAngle, infer Type extends t.TSchema, RAngle]
-    ? t.TArray<Type>
-    : never
-}
-// prettier-ignore
-type Array = Static.Tuple<[
-  Static.Const<'Array'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
-], ArrayMapping>
-
-// ------------------------------------------------------------------
-// AsyncIterator
-// ------------------------------------------------------------------
-// prettier-ignore
-interface AsyncIteratorMapping extends Static.IMapping {
-  output: this['input'] extends ['AsyncIterator', LAngle, infer Type extends t.TSchema, RAngle]
-    ? t.TAsyncIterator<Type>
-    : never
-}
-// prettier-ignore
-type AsyncIterator = Static.Tuple<[
-  Static.Const<'AsyncIterator'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
-], AsyncIteratorMapping>
-
-// ------------------------------------------------------------------
-// Iterator
-// ------------------------------------------------------------------
-// prettier-ignore
-interface IteratorMapping extends Static.IMapping {
-  output: this['input'] extends ['Iterator', LAngle, infer Type extends t.TSchema, RAngle]
-    ? t.TIterator<Type>
-    : never
-}
-// prettier-ignore
-type Iterator = Static.Tuple<[
-  Static.Const<'Iterator'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
-], IteratorMapping>
-
-// ------------------------------------------------------------------
-// ConstructorParameters
-// ------------------------------------------------------------------
-// prettier-ignore
-interface ConstructorParametersMapping extends Static.IMapping {
-  output: this['input'] extends ['ConstructorParameters', LAngle, infer Type extends t.TSchema, RAngle]
-    ? t.TConstructorParameters<Type>
-    : never
-}
-// prettier-ignore
-type ConstructorParameters = Static.Tuple<[
-  Static.Const<'ConstructorParameters'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
-], ConstructorParametersMapping>
-
-// ------------------------------------------------------------------
-// FunctionParameters
-// ------------------------------------------------------------------
-// prettier-ignore
-interface FunctionParametersMapping extends Static.IMapping {
-  output: this['input'] extends ['Parameters', LAngle, infer Type extends t.TSchema, RAngle]
-    ? t.TParameters<Type>
-    : never
-}
-// prettier-ignore
-type FunctionParameters = Static.Tuple<[
-  Static.Const<'Parameters'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
-], FunctionParametersMapping>
-
-// ------------------------------------------------------------------
-// InstanceType
-// ------------------------------------------------------------------
-// prettier-ignore
-interface InstanceTypeMapping extends Static.IMapping {
-  output: this['input'] extends ['InstanceType', LAngle, infer Type extends t.TSchema, RAngle]
-    ? t.TInstanceType<Type>
-    : never
-}
-// prettier-ignore
-type InstanceType = Static.Tuple<[
-  Static.Const<'InstanceType'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
-], InstanceTypeMapping>
-
-// ------------------------------------------------------------------
-// ReturnType
-// ------------------------------------------------------------------
-// prettier-ignore
-interface ReturnTypeMapping extends Static.IMapping {
-  output: this['input'] extends ['ReturnType', LAngle, infer Type extends t.TSchema, RAngle]
-    ? t.TReturnType<Type>
-    : never
-}
-// prettier-ignore
-type ReturnType = Static.Tuple<[
-  Static.Const<'ReturnType'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
-], ReturnTypeMapping>
-
-// ------------------------------------------------------------------
-// Argument
-// ------------------------------------------------------------------
-// prettier-ignore
-interface ArgumentMapping extends Static.IMapping {
-  output: this['input'] extends ['Argument', LAngle, infer Type extends t.TSchema, RAngle]
-    ? Type extends t.TLiteral<infer Index extends number>
-      ? t.TArgument<Index>
-      : t.TNever
-    : never
-}
-// prettier-ignore
-type Argument = Static.Tuple<[
-  Static.Const<'Argument'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
-], ArgumentMapping>
-
-// ------------------------------------------------------------------
-// Awaited
-// ------------------------------------------------------------------
-// prettier-ignore
-interface AwaitedMapping extends Static.IMapping {
-  output: this['input'] extends ['Awaited', LAngle, infer Type extends t.TSchema, RAngle]
-    ? t.TAwaited<Type>
-    : never
-}
-// prettier-ignore
-type Awaited = Static.Tuple<[
-  Static.Const<'Awaited'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
-], AwaitedMapping>
-
-// ------------------------------------------------------------------
-// Promise
-// ------------------------------------------------------------------
-// prettier-ignore
-interface PromiseMapping extends Static.IMapping {
-  output: this['input'] extends ['Promise', LAngle, infer Type extends t.TSchema, RAngle]
-    ? t.TPromise<Type>
-    : never
-}
-// prettier-ignore
-type Promise = Static.Tuple<[
-  Static.Const<'Promise'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
-], PromiseMapping>
-
-// ------------------------------------------------------------------
-// Record
-// ------------------------------------------------------------------
-// prettier-ignore
-interface RecordMapping extends Static.IMapping {
-  output: this['input'] extends ['Record', LAngle, infer Key extends t.TSchema, Comma, infer Type extends t.TSchema,  RAngle]
-    ? t.TRecord<Key, Type>
-    : never
-}
-// prettier-ignore
-type Record = Static.Tuple<[
-  Static.Const<'Record'>, Static.Const<LAngle>, Type, Static.Const<Comma>, Type, Static.Const<RAngle>,
-], RecordMapping>
-
-// ------------------------------------------------------------------
-// Partial
-// ------------------------------------------------------------------
-// prettier-ignore
-interface PartialMapping extends Static.IMapping {
-  output: this['input'] extends ['Partial', LAngle, infer Type extends t.TSchema, RAngle]
-    ? t.TPartial<Type>
-    : never
-}
-// prettier-ignore
-type Partial = Static.Tuple<[
-  Static.Const<'Partial'>, Static.Const<LAngle>, Type, Static.Const<RAngle>,
-], PartialMapping>
-
-// ------------------------------------------------------------------
-// Required
-// ------------------------------------------------------------------
-// prettier-ignore
-interface RequiredMapping extends Static.IMapping {
-  output: this['input'] extends ['Required', LAngle, infer Type extends t.TSchema, RAngle]
-    ? t.TRequired<Type>
-    : never
-}
-// prettier-ignore
-type Required = Static.Tuple<[
-  Static.Const<'Required'>,  Static.Const<LAngle>, Type, Static.Const<RAngle>,
-], RequiredMapping>
-
-// ------------------------------------------------------------------
-// Pick
-// ------------------------------------------------------------------
-// prettier-ignore
-interface PickMapping extends Static.IMapping {
-  output: this['input'] extends ['Pick', LAngle, infer Type extends t.TSchema, Comma, infer Key extends t.TSchema, RAngle]
-    ? t.TPick<Type, Key>
-    : never
-}
-// prettier-ignore
-type Pick = Static.Tuple<[
-  Static.Const<'Pick'>, Static.Const<LAngle>, Type, Static.Const<Comma>, Type, Static.Const<RAngle>,
-], PickMapping>
-
-// ------------------------------------------------------------------
-// Omit
-// ------------------------------------------------------------------
-// prettier-ignore
-interface OmitMapping extends Static.IMapping {
-  output: this['input'] extends ['Omit', LAngle, infer Type extends t.TSchema, Comma, infer Key extends t.TSchema, RAngle]
-    ? t.TOmit<Type, Key>
-    : never
-}
-// prettier-ignore
-type Omit = Static.Tuple<[
-  Static.Const<'Omit'>, Static.Const<LAngle>, Type, Static.Const<Comma>, Type, Static.Const<RAngle>
-], OmitMapping>
-
-// ------------------------------------------------------------------
-// Exclude
-// ------------------------------------------------------------------
-// prettier-ignore
-interface ExcludeMapping extends Static.IMapping {
-  output: this['input'] extends ['Exclude', LAngle, infer Type extends t.TSchema, Comma, infer PropertyKey extends t.TSchema, RAngle]
-    ? t.TExclude<Type, PropertyKey>
-    : never
-}
-// prettier-ignore
-type Exclude = Static.Tuple<[
-  Static.Const<'Exclude'>, Static.Const<LAngle>, Type, Static.Const<Comma>, Type, Static.Const<RAngle>
-], ExcludeMapping>
-
-// ------------------------------------------------------------------
-// Extract
-// ------------------------------------------------------------------
-// prettier-ignore
-interface ExtractMapping extends Static.IMapping {
-  output: this['input'] extends ['Extract', LAngle, infer Type extends t.TSchema, Comma, infer PropertyKey extends t.TSchema, RAngle]
-    ? t.TExtract<Type, PropertyKey>
-    : never
-}
-// prettier-ignore
-type Extract = Static.Tuple<[
-  Static.Const<'Extract'>, Static.Const<LAngle>, Type, Static.Const<Comma>, Type, Static.Const<RAngle>
-], ExtractMapping>
-
-// ------------------------------------------------------------------
-// Uppercase
-// ------------------------------------------------------------------
-// prettier-ignore
-interface UppercaseMapping extends Static.IMapping {
-  output: this['input'] extends ['Uppercase', LAngle, infer Type extends t.TSchema, RAngle]
-    ? t.TUppercase<Type>
-    : never
-}
-// prettier-ignore
-type Uppercase = Static.Tuple<[
-  Static.Const<'Uppercase'>,  Static.Const<LAngle>, Type, Static.Const<RAngle>,
-], UppercaseMapping>
-
-// ------------------------------------------------------------------
-// Lowercase
-// ------------------------------------------------------------------
-// prettier-ignore
-interface LowercaseMapping extends Static.IMapping {
-  output: this['input'] extends ['Lowercase', LAngle, infer Type extends t.TSchema, RAngle]
-    ? t.TLowercase<Type>
-    : never
-}
-// prettier-ignore
-type Lowercase = Static.Tuple<[
-  Static.Const<'Lowercase'>,  Static.Const<LAngle>, Type, Static.Const<RAngle>,
-], LowercaseMapping>
-
-// ------------------------------------------------------------------
-// Capitalize
-// ------------------------------------------------------------------
-// prettier-ignore
-interface CapitalizeMapping extends Static.IMapping {
-  output: this['input'] extends ['Capitalize', LAngle, infer Type extends t.TSchema, RAngle]
-    ? t.TCapitalize<Type>
-    : never
-}
-// prettier-ignore
-type Capitalize = Static.Tuple<[
-  Static.Const<'Capitalize'>,  Static.Const<LAngle>, Type, Static.Const<RAngle>,
-], CapitalizeMapping>
-
-// ------------------------------------------------------------------
-// Uncapitalize
-// ------------------------------------------------------------------
-// prettier-ignore
-interface UncapitalizeMapping extends Static.IMapping {
-  output: this['input'] extends ['Uncapitalize', LAngle, infer Type extends t.TSchema, RAngle]
-    ? t.TUncapitalize<Type>
-    : never
-}
-// prettier-ignore
-type Uncapitalize = Static.Tuple<[
-  Static.Const<'Uncapitalize'>,  Static.Const<LAngle>, Type, Static.Const<RAngle>,
-], UncapitalizeMapping>
-
-// ------------------------------------------------------------------
-// Date
-// ------------------------------------------------------------------
-type Date = Static.Const<'Date', Static.As<t.TDate>>
-
-// ------------------------------------------------------------------
-// Uint8Array
-// ------------------------------------------------------------------
-type Uint8Array = Static.Const<'Uint8Array', Static.As<t.TUint8Array>>
diff --git a/src/syntax/syntax.ts b/src/syntax/syntax.ts
index e467cd2ef..82a6d9624 100644
--- a/src/syntax/syntax.ts
+++ b/src/syntax/syntax.ts
@@ -26,70 +26,37 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import * as t from '../type/index'
-import { Static } from '../parser/index'
-import { Module } from './runtime'
-import { Type } from './static'
+import * as t from '@sinclair/typebox'
+import { Type, TType } from './parser'
 
 // ------------------------------------------------------------------
 // NoInfer
 // ------------------------------------------------------------------
-/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
-export function NoInfer<Context extends Record<PropertyKey, t.TSchema>, Code extends string>(context: Context, code: Code, options?: t.SchemaOptions): t.TSchema
-/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
-export function NoInfer<Code extends string>(code: Code, options?: t.SchemaOptions): t.TSchema
-/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+/** `[Experimental]` Parses type expressions into TypeBox types but does not infer */
+export function NoInfer<Context extends Record<PropertyKey, t.TSchema>, Input extends string>(context: Context, input: Input, options?: t.SchemaOptions): t.TSchema
+/** `[Experimental]` Parses type expressions into TypeBox types but does not infer */
+export function NoInfer<Input extends string>(input: Input, options?: t.SchemaOptions): t.TSchema
+/** `[Experimental]` Parses type expressions into TypeBox types but does not infer */
 // prettier-ignore
 export function NoInfer(...args: any[]): t.TSchema {
   const withContext = typeof args[0] === 'string' ? false : true
   const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}]
-  const result = Module.Parse('Type', code, context)[0]
+  const result = Type(code, context)[0]
   return t.KindGuard.IsSchema(result) 
     ? t.CloneType(result, options) 
     : t.Never(options)
 }
 
-/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
+/** `[Experimental]` Parses type expressions into TypeBox types */
 // prettier-ignore
 export type TSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (
-  Static.Parse<Type, Code, Context> extends [infer Type extends t.TSchema, string] ? Type : t.TNever
+  TType<Code, Context> extends [infer Type extends t.TSchema, string] ? Type : t.TNever
 )
-/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
-export function Syntax<Context extends Record<PropertyKey, t.TSchema>, Annotation extends string>(context: Context, annotation: Annotation, options?: t.SchemaOptions): TSyntax<Context, Annotation>
-/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
-export function Syntax<Annotation extends string>(annotation: Annotation, options?: t.SchemaOptions): TSyntax<{}, Annotation>
-/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
+/** `[Experimental]` Parses type expressions into TypeBox types */
+export function Syntax<Context extends Record<PropertyKey, t.TSchema>, Input extends string>(context: Context, input: Input, options?: t.SchemaOptions): TSyntax<Context, Input>
+/** `[Experimental]` Parses type expressions into TypeBox types */
+export function Syntax<Input extends string>(annotation: Input, options?: t.SchemaOptions): TSyntax<{}, Input>
+/** `[Experimental]` Parses type expressions into TypeBox types */
 export function Syntax(...args: any[]): never {
   return NoInfer.apply(null, args as never) as never
 }
-// ------------------------------------------------------------------
-// Deprecated
-// ------------------------------------------------------------------
-/**
- * @deprecated Use Syntax() function
- */
-export function Parse<Context extends Record<PropertyKey, t.TSchema>, Annotation extends string>(context: Context, annotation: Annotation, options?: t.SchemaOptions): TSyntax<Context, Annotation>
-/**
- * @deprecated Use Syntax() function
- */
-export function Parse<Annotation extends string>(annotation: Annotation, options?: t.SchemaOptions): TSyntax<{}, Annotation>
-/**
- * @deprecated Use Syntax() function
- */
-export function Parse(...args: any[]): never {
-  return NoInfer.apply(null, args as never) as never
-}
-/**
- * @deprecated Use NoInfer() function
- */
-export function ParseOnly<Context extends Record<PropertyKey, t.TSchema>, Code extends string>(context: Context, code: Code, options?: t.SchemaOptions): t.TSchema | undefined
-/**
- * @deprecated Use NoInfer() function
- */
-export function ParseOnly<Code extends string>(code: Code, options?: t.SchemaOptions): t.TSchema | undefined
-/**
- * @deprecated Use NoInfer() function
- */
-export function ParseOnly(...args: any[]): t.TSchema | undefined {
-  return NoInfer.apply(null, args as never) as never
-}

From 5a5431439f7d5ca6b494d0d18fbfd7b1a356d67c Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 2 Apr 2025 21:18:30 +0900
Subject: [PATCH 356/369] Revision 0.34.33 (#1220)

* Fix Import Specifier

* ChangeLog

* Version
---
 changelog/0.34.0.md   | 2 ++
 package-lock.json     | 4 ++--
 package.json          | 2 +-
 src/syntax/mapping.ts | 2 +-
 src/syntax/syntax.ts  | 2 +-
 5 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 5baecf130..10428a8ad 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -3,6 +3,8 @@
 ---
 
 ### Revision Updates
+- [Revision 0.34.33](https://github.com/sinclairzx81/typebox/pull/1220)
+  - Hotfix: Correct Invalid Import Specifier
 - [Revision 0.34.32](https://github.com/sinclairzx81/typebox/pull/1218)
   - Accelerated | High Performance Syntax Parsing
 - [Revision 0.34.31](https://github.com/sinclairzx81/typebox/pull/1209)
diff --git a/package-lock.json b/package-lock.json
index c76f353fa..d293b7ecc 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.32",
+  "version": "0.34.33",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.32",
+      "version": "0.34.33",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index b0b1786e1..3b573eccc 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.32",
+  "version": "0.34.33",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/syntax/mapping.ts b/src/syntax/mapping.ts
index 257435f27..60061759d 100644
--- a/src/syntax/mapping.ts
+++ b/src/syntax/mapping.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import * as T from '@sinclair/typebox'
+import * as T from '../type/index'
 
 // ------------------------------------------------------------------
 //
diff --git a/src/syntax/syntax.ts b/src/syntax/syntax.ts
index 82a6d9624..82be0075c 100644
--- a/src/syntax/syntax.ts
+++ b/src/syntax/syntax.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import * as t from '@sinclair/typebox'
+import * as t from '../type/index'
 import { Type, TType } from './parser'
 
 // ------------------------------------------------------------------

From 7b45ec1c4706e41068b8b5d7529efb86499b1424 Mon Sep 17 00:00:00 2001
From: Antonio Silva <antoniopresto@gmail.com>
Date: Fri, 13 Jun 2025 00:13:32 -0300
Subject: [PATCH 357/369] Support Inference of Ref inside Recursive inside
 Module (#1263)

---
 src/type/module/infer.ts |  2 ++
 test/static/import.ts    | 23 +++++++++++++++++++++++
 2 files changed, 25 insertions(+)

diff --git a/src/type/module/infer.ts b/src/type/module/infer.ts
index e0fff5e0f..8c8708d20 100644
--- a/src/type/module/infer.ts
+++ b/src/type/module/infer.ts
@@ -43,6 +43,7 @@ import { TRef } from '../ref/index'
 import { TTuple } from '../tuple/index'
 import { TUnion } from '../union/index'
 import { Static } from '../static/index'
+import { TRecursive } from '../recursive/index'
 
 // ------------------------------------------------------------------
 // Array
@@ -160,6 +161,7 @@ type TInfer<ModuleProperties extends TProperties, Type extends TSchema> = (
   Type extends TTuple<infer Types extends TSchema[]> ? TInferTuple<ModuleProperties, Types> :
   Type extends TEnum<infer _ extends TEnumRecord> ? Static<Type> : // intercept enum before union
   Type extends TUnion<infer Types extends TSchema[]> ? TInferUnion<ModuleProperties, Types> :
+  Type extends TRecursive<infer Schema extends TSchema> ? TInfer<ModuleProperties, Schema> :
   Static<Type>
 )
 // ------------------------------------------------------------------
diff --git a/test/static/import.ts b/test/static/import.ts
index 0f30704f2..dec8e8ec2 100644
--- a/test/static/import.ts
+++ b/test/static/import.ts
@@ -130,3 +130,26 @@ import { Type, Static } from '@sinclair/typebox'
     x?: null[],
   }>()
 }
+// ------------------------------------------------------------------
+// Ref inside Recursive
+// ------------------------------------------------------------------
+// prettier-ignore
+{
+  const Module = Type.Module({
+    T: Type.Recursive((_) =>
+      Type.Object({
+        M: Type.Ref("U"),
+      })
+    ),
+    U: Type.Union([
+      Type.Literal("A"),
+      Type.Literal("B")
+    ]),
+  });
+
+  const T = Module.Import("T");
+  type T = Static<typeof T>;
+  Expect(T).ToStatic<{
+    M: 'A'|'B'
+  }>();
+}

From 394927d8ade58ca5214765a0d4bee13825f1235d Mon Sep 17 00:00:00 2001
From: sinclair <haydn.developer@gmail.com>
Date: Fri, 13 Jun 2025 12:17:40 +0900
Subject: [PATCH 358/369] Revision 0.34.34

---
 changelog/0.34.0.md | 2 ++
 package-lock.json   | 4 ++--
 package.json        | 2 +-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 10428a8ad..975953c6e 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -3,6 +3,8 @@
 ---
 
 ### Revision Updates
+- [Revision 0.34.34](https://github.com/sinclairzx81/typebox/pull/1263)
+  - Support Inference of Ref inside Recursive inside Module
 - [Revision 0.34.33](https://github.com/sinclairzx81/typebox/pull/1220)
   - Hotfix: Correct Invalid Import Specifier
 - [Revision 0.34.32](https://github.com/sinclairzx81/typebox/pull/1218)
diff --git a/package-lock.json b/package-lock.json
index d293b7ecc..cae1614e2 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.33",
+  "version": "0.34.34",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.33",
+      "version": "0.34.34",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 3b573eccc..a2d46f405 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.33",
+  "version": "0.34.34",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

From 2406c7462cd42d286a60e01f0940bf992a77cb45 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 13 Jun 2025 13:58:56 +0900
Subject: [PATCH 359/369] Revision 0.34.35 (#1265)

* Deep Assign on Intersect Cast

* ChangeLog

* Version
---
 changelog/0.34.0.md                  |  2 ++
 package-lock.json                    |  4 ++--
 package.json                         |  2 +-
 src/value/cast/cast.ts               | 20 +++++++++++++++++---
 test/runtime/value/cast/intersect.ts | 27 +++++++++++++++++++++++++++
 5 files changed, 49 insertions(+), 6 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 975953c6e..6df506b25 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -3,6 +3,8 @@
 ---
 
 ### Revision Updates
+- [Revision 0.34.35](https://github.com/sinclairzx81/typebox/pull/1265)
+  - Deep Assign on Intersect Cast
 - [Revision 0.34.34](https://github.com/sinclairzx81/typebox/pull/1263)
   - Support Inference of Ref inside Recursive inside Module
 - [Revision 0.34.33](https://github.com/sinclairzx81/typebox/pull/1220)
diff --git a/package-lock.json b/package-lock.json
index cae1614e2..426d2ced1 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.34",
+  "version": "0.34.35",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.34",
+      "version": "0.34.35",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index a2d46f405..7642679e8 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.34",
+  "version": "0.34.35",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/cast/cast.ts b/src/value/cast/cast.ts
index 671050421..728aded2b 100644
--- a/src/value/cast/cast.ts
+++ b/src/value/cast/cast.ts
@@ -139,10 +139,24 @@ function FromImport(schema: TImport, references: TSchema[], value: unknown): boo
   const target = schema.$defs[schema.$ref] as TSchema
   return Visit(target, [...references, ...definitions], value)
 }
+
+// ------------------------------------------------------------------
+// Intersect
+// ------------------------------------------------------------------
+function IntersectAssign(correct: unknown, value: unknown): unknown {
+  // trust correct on mismatch | value on non-object
+  if ((IsObject(correct) && !IsObject(value)) || (!IsObject(correct) && IsObject(value))) return correct
+  if (!IsObject(correct) || !IsObject(value)) return value
+  return globalThis.Object.getOwnPropertyNames(correct).reduce((result, key) => {
+    const property = key in value ? IntersectAssign(correct[key], value[key]) : correct[key]
+    return { ...result, [key]: property }
+  }, {})
+}
 function FromIntersect(schema: TIntersect, references: TSchema[], value: any): any {
-  const created = Create(schema, references)
-  const mapped = IsObject(created) && IsObject(value) ? { ...(created as any), ...value } : value
-  return Check(schema, references, mapped) ? mapped : Create(schema, references)
+  if (Check(schema, references, value)) return value
+  const correct = Create(schema, references)
+  const assigned = IntersectAssign(correct, value)
+  return Check(schema, references, assigned) ? assigned : correct
 }
 function FromNever(schema: TNever, references: TSchema[], value: any): any {
   throw new ValueCastError(schema, 'Never types cannot be cast')
diff --git a/test/runtime/value/cast/intersect.ts b/test/runtime/value/cast/intersect.ts
index 82044975f..ff5f5895b 100644
--- a/test/runtime/value/cast/intersect.ts
+++ b/test/runtime/value/cast/intersect.ts
@@ -73,4 +73,31 @@ describe('value/cast/Intersect', () => {
     const V = Value.Cast(T, 2000)
     Assert.IsEqual(V, 2000)
   })
+
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/1264
+  // ----------------------------------------------------------------
+  it('Should preserve intersected properties', () => {
+    const T = Type.Intersect([
+      Type.Object({}),
+      Type.Object({
+        name: Type.String(),
+        age: Type.Optional(Type.Number()),
+        location: Type.Object({
+          lat: Type.Number(),
+          long: Type.Number(),
+        }),
+        greeting: Type.String(),
+      }),
+    ])
+    const V0 = Value.Cast(T, { greeting: 'Hello' })
+    const V1 = Value.Cast(T, { location: null, greeting: 'Hello' })
+    const V2 = Value.Cast(T, { location: { lat: 1 }, greeting: 'Hello' })
+    const V3 = Value.Cast(T, { location: { lat: 1, long: 1 }, greeting: 'Hello' })
+
+    Assert.IsEqual(V0, { name: '', location: { lat: 0, long: 0 }, greeting: 'Hello' })
+    Assert.IsEqual(V1, { name: '', location: { lat: 0, long: 0 }, greeting: 'Hello' })
+    Assert.IsEqual(V2, { name: '', location: { lat: 1, long: 0 }, greeting: 'Hello' })
+    Assert.IsEqual(V3, { name: '', location: { lat: 1, long: 1 }, greeting: 'Hello' })
+  })
 })

From cb3f898093148c41f1140219d58d00b5f9512852 Mon Sep 17 00:00:00 2001
From: Ilya Medvedev <iam-medvedev@users.noreply.github.com>
Date: Sun, 22 Jun 2025 06:16:51 +0200
Subject: [PATCH 360/369] Ecosystem (#1274)

Added a link to a plugin that allows you to create fake data based on TypeBox schemas.

- docs: add `typebox-schema-faker` to the ecosystem (#1274)
---
 readme.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/readme.md b/readme.md
index 8bc45b3ca..18bbc55e7 100644
--- a/readme.md
+++ b/readme.md
@@ -1738,6 +1738,7 @@ The following is a list of community packages that offer general tooling, extend
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
 | [typebox-cli](https://github.com/gsuess/typebox-cli) | Generate Schema with TypeBox from the CLI |
 | [typebox-form-parser](https://github.com/jtlapp/typebox-form-parser) | Parses form and query data based on TypeBox schemas |
+| [typebox-schema-faker](https://github.com/iam-medvedev/typebox-schema-faker) | Generate fake data from TypeBox schemas for testing, prototyping and development |
 
 
 <a name='benchmark'></a>

From b40ba2c751cc3b16fb8060d266267600a993628a Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 22 Jun 2025 14:49:16 +0900
Subject: [PATCH 361/369] Revision 0.34.36 (#1276)

* Fix Record Intersect on Cast

* TypeScript 5.8.3

* Version

* ChangeLog
---
 changelog/0.34.0.md                  |  2 ++
 hammer.mjs                           |  8 +++++++-
 package-lock.json                    | 18 +++++++++---------
 package.json                         |  4 ++--
 src/value/create/create.ts           |  6 ------
 test/runtime/value/cast/intersect.ts |  9 +++++++++
 6 files changed, 29 insertions(+), 18 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 6df506b25..b769a4f0c 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -3,6 +3,8 @@
 ---
 
 ### Revision Updates
+- [Revision 0.34.36](https://github.com/sinclairzx81/typebox/pull/1276)
+  - Fix Record Intersect on Cast
 - [Revision 0.34.35](https://github.com/sinclairzx81/typebox/pull/1265)
   - Deep Assign on Intersect Cast
 - [Revision 0.34.34](https://github.com/sinclairzx81/typebox/pull/1263)
diff --git a/hammer.mjs b/hammer.mjs
index 477cc7599..5bde41f39 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -35,7 +35,13 @@ export async function benchmark() {
 // Test
 // -------------------------------------------------------------------------------
 export async function test_typescript() {
-  for (const version of ['4.9.5', '5.0.4', '5.1.3', '5.1.6', '5.2.2', '5.3.2', '5.3.3', '5.4.3', '5.4.5', '5.5.2', '5.5.3', '5.5.4', '5.6.2', '5.6.3', '5.7.2', '5.7.3', 'next', 'latest']) {
+  for (const version of [
+    '4.9.5', '5.0.4', '5.1.3', '5.1.6', 
+    '5.2.2', '5.3.2', '5.3.3', '5.4.3', 
+    '5.4.5', '5.5.2', '5.5.3', '5.5.4', 
+    '5.6.2', '5.6.3', '5.7.2', '5.7.3', 
+    '5.8.2', 'next', 'latest'
+  ]) {
     await shell(`npm install typescript@${version} --no-save`)
     await test_static()
   }
diff --git a/package-lock.json b/package-lock.json
index 426d2ced1..4b5499e44 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.35",
+  "version": "0.34.36",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.35",
+      "version": "0.34.36",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
@@ -17,7 +17,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^11.1.0",
         "prettier": "^2.7.1",
-        "typescript": "^5.8.2"
+        "typescript": "^5.8.3"
       }
     },
     "node_modules/@andrewbranch/untar.js": {
@@ -1814,9 +1814,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.8.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.2.tgz",
-      "integrity": "sha512-aJn6wq13/afZp/jT9QZmwEjDqqvSGp1VT5GVg+f/t6/oVyrgXM6BY1h9BRh/O5p3PlUPAe+WuiEZOmb/49RqoQ==",
+      "version": "5.8.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
+      "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -3226,9 +3226,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.8.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.2.tgz",
-      "integrity": "sha512-aJn6wq13/afZp/jT9QZmwEjDqqvSGp1VT5GVg+f/t6/oVyrgXM6BY1h9BRh/O5p3PlUPAe+WuiEZOmb/49RqoQ==",
+      "version": "5.8.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
+      "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
       "dev": true
     },
     "undici-types": {
diff --git a/package.json b/package.json
index 7642679e8..09380c4d0 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.35",
+  "version": "0.34.36",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -38,6 +38,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^11.1.0",
     "prettier": "^2.7.1",
-    "typescript": "^5.8.2"
+    "typescript": "^5.8.3"
   }
 }
diff --git a/src/value/create/create.ts b/src/value/create/create.ts
index 3af0245d9..9c75b0d50 100644
--- a/src/value/create/create.ts
+++ b/src/value/create/create.ts
@@ -269,14 +269,8 @@ function FromPromise(schema: TPromise, references: TSchema[]): any {
   }
 }
 function FromRecord(schema: TRecord, references: TSchema[]): any {
-  const [keyPattern, valueSchema] = Object.entries(schema.patternProperties)[0]
   if (HasPropertyKey(schema, 'default')) {
     return FromDefault(schema.default)
-  } else if (!(keyPattern === PatternStringExact || keyPattern === PatternNumberExact)) {
-    const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|')
-    const Acc = {} as Record<PropertyKey, unknown>
-    for (const key of propertyKeys) Acc[key] = Visit(valueSchema, references)
-    return Acc
   } else {
     return {}
   }
diff --git a/test/runtime/value/cast/intersect.ts b/test/runtime/value/cast/intersect.ts
index ff5f5895b..bed80df65 100644
--- a/test/runtime/value/cast/intersect.ts
+++ b/test/runtime/value/cast/intersect.ts
@@ -100,4 +100,13 @@ describe('value/cast/Intersect', () => {
     Assert.IsEqual(V2, { name: '', location: { lat: 1, long: 0 }, greeting: 'Hello' })
     Assert.IsEqual(V3, { name: '', location: { lat: 1, long: 1 }, greeting: 'Hello' })
   })
+
+  // --------------------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/1269#issuecomment-2993924180
+  // --------------------------------------------------------------------------
+  it('Should Cast with intersected Record', () => {
+    const T = Type.Intersect([Type.Record(Type.TemplateLiteral('x-${string}'), Type.Unknown()), Type.Object({ name: Type.String() })])
+    const R = Value.Cast(T, {})
+    Assert.IsEqual(R, { name: '' })
+  })
 })

From 978339122870fdd8300171e62994e8afcf1e9cda Mon Sep 17 00:00:00 2001
From: Redis Stasa <91160178+DemonHa@users.noreply.github.com>
Date: Tue, 24 Jun 2025 01:13:26 -0400
Subject: [PATCH 362/369] Fix: Correctly score nested unions (#1273)

---
 src/value/cast/cast.ts           |   7 +-
 test/runtime/value/cast/union.ts | 186 +++++++++++++++++++++++++++++++
 2 files changed, 192 insertions(+), 1 deletion(-)

diff --git a/src/value/cast/cast.ts b/src/value/cast/cast.ts
index 728aded2b..8b31f5771 100644
--- a/src/value/cast/cast.ts
+++ b/src/value/cast/cast.ts
@@ -76,6 +76,11 @@ function ScoreUnion(schema: TSchema, references: TSchema[], value: any): number
       const exists = keys.includes(key) ? point : 0
       return acc + (literal + checks + exists)
     }, 0)
+  } else if (schema[Kind] === "Union") {
+    const schemas = schema.anyOf.map((schema: TSchema) =>
+      Deref(schema, references)
+    )
+    return  Math.max(...schemas.map((schema: TSchema) => ScoreUnion(schema, references, value)))
   } else {
     return Check(schema, references, value) ? 1 : 0
   }
@@ -127,7 +132,7 @@ function FromArray(schema: TArray, references: TSchema[], value: any): any {
 function FromConstructor(schema: TConstructor, references: TSchema[], value: any): any {
   if (Check(schema, references, value)) return Create(schema, references)
   const required = new Set(schema.returns.required || [])
-  const result = function () {}
+  const result = function () { }
   for (const [key, property] of Object.entries(schema.returns.properties)) {
     if (!required.has(key) && value.prototype[key] === undefined) continue
     result.prototype[key] = Visit(property as TSchema, references, value.prototype[key])
diff --git a/test/runtime/value/cast/union.ts b/test/runtime/value/cast/union.ts
index 96b159cdc..ca73c089d 100644
--- a/test/runtime/value/cast/union.ts
+++ b/test/runtime/value/cast/union.ts
@@ -161,4 +161,190 @@ describe('value/cast/Union', () => {
     Assert.IsEqual(Value.Cast(RA, [A, B], { type: 'A' }), { type: 'A' })
     Assert.IsEqual(Value.Cast(RB, [A, B], { type: 'A' }), { type: 'A' })
   })
+
+  // ------------------------------------------------------------------------
+  // ref: https://github.com/sinclairzx81/typebox/issues/1268
+  // ------------------------------------------------------------------------
+  it('should correctly score nested union types #1', () => {
+    const A =
+      Type.Union([
+        Type.Union([
+          Type.Object({
+            type: Type.Literal('a'),
+            name: Type.String(),
+            in: Type.String(),
+          }),
+          Type.Object({
+            type: Type.Literal('b'),
+            description: Type.Optional(Type.String()),
+            nested: Type.Object({
+              a: Type.String(),
+              b: Type.Optional(Type.String()),
+            }),
+          }),
+        ]),
+        Type.Object({
+          $ref: Type.String(),
+          description: Type.Optional(Type.String()),
+        }),
+      ],
+
+      );
+
+    Assert.IsEqual(Value.Cast(A, {
+      type: 'b',
+      description: 'Hello World',
+      nested: {
+        b: 'hello',
+      },
+    }), {
+      type: 'b',
+      description: 'Hello World',
+      nested: { a: '', b: 'hello' },
+    });
+  });
+
+  it('should correctly score nested union types #2', () => {
+    const A = Type.Union([
+      Type.Union([
+        Type.Object({
+          prop1: Type.String(),
+          prop2: Type.String(),
+          prop3: Type.String(),
+        }),
+        Type.Object({
+          prop1: Type.String(),
+          prop4: Type.String(),
+          prop5: Type.String(),
+        })
+      ]),
+      Type.Union([
+        Type.Object({
+          prop6: Type.String(),
+          prop7: Type.String(),
+          prop8: Type.String(),
+        }),
+        Type.Object({
+          prop1: Type.String(),
+          prop9: Type.String(),
+          prop10: Type.String(),
+        }),
+      ]),
+    ])
+
+    // Picks the first union variant when the score is equal
+    Assert.IsEqual(Value.Cast(A, {
+      prop1: ''
+    }), {
+      prop1: '',
+      prop2: '',
+      prop3: '',
+    });
+
+    Assert.IsEqual(Value.Cast(A, {
+      prop1: '',
+      prop4: ''
+    }), {
+      prop1: '',
+      prop4: '',
+      prop5: '',
+    });
+
+    Assert.IsEqual(Value.Cast(A, {
+      prop6: '',
+    }), {
+      prop6: '',
+      prop7: '',
+      prop8: '',
+    });
+  });
+
+  it('should correctly score nested union types #3', () => {
+    const A = Type.Union([
+      Type.Object({
+        prop1: Type.String(),
+        prop2: Type.String(),
+        prop3: Type.String(),
+      }),
+      Type.Object({
+        prop4: Type.String(),
+        prop5: Type.String(),
+        prop6: Type.String(),
+      }),
+      Type.Union([
+        Type.Object({
+          prop4: Type.String(),
+          prop5: Type.String(),
+          prop6: Type.String(),
+        }),
+        Type.Object({
+          prop1: Type.String(),
+          prop2: Type.String(),
+          prop7: Type.String(),
+          prop8: Type.String(),
+        }),
+      ]),
+    ])
+
+    Assert.IsEqual(Value.Cast(A, {
+      prop1: '',
+      prop2: '',
+      prop7: ''
+    }), {
+      prop1: '',
+      prop2: '',
+      prop7: '',
+      prop8: '',
+    });
+  });
+
+  it('should correctly score nested union types #4', () => {
+    const A = Type.Union([
+      Type.Object({
+        prop1: Type.String(),
+        prop2: Type.String(),
+        prop3: Type.String(),
+      }),
+      Type.Union([
+        Type.Object({
+          prop4: Type.String(),
+          prop5: Type.String(),
+          prop6: Type.String(),
+        }),
+        Type.Union([
+          Type.Object({
+            prop1: Type.String(),
+            prop2: Type.String(),
+            prop7: Type.String(),
+            prop8: Type.String(),
+          }),
+          Type.Union([
+            Type.Object({
+              prop1: Type.String(),
+              prop2: Type.String(),
+              prop9: Type.String(),
+              prop10: Type.String(),
+            }),
+            Type.Object({
+              prop1: Type.String(),
+              prop2: Type.String(),
+              prop11: Type.String(),
+              prop12: Type.String(),
+            })
+          ])
+        ])
+      ]),
+    ])
+
+    Assert.IsEqual(Value.Cast(A, {
+      prop1: '',
+      prop2: '',
+      prop9: ''
+    }), {
+      prop1: '',
+      prop2: '',
+      prop9: '',
+      prop10: '',
+    });
+  })
 })

From 30cfe8904d8e7ea3da549783f66d32ae1f867b6a Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 24 Jun 2025 14:27:54 +0900
Subject: [PATCH 363/369] Revision 0.34.37 (#1278)

* Format

* Refactor

* Version

* ChangeLog
---
 changelog/0.34.0.md              |   2 +
 package-lock.json                |   4 +-
 package.json                     |   2 +-
 src/value/cast/cast.ts           |  11 +-
 test/runtime/value/cast/union.ts | 173 +++++++++++++++++--------------
 5 files changed, 104 insertions(+), 88 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index b769a4f0c..2d8a0fe58 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -3,6 +3,8 @@
 ---
 
 ### Revision Updates
+- [Revision 0.34.37](https://github.com/sinclairzx81/typebox/pull/1278)
+  - Fix Support nested Union selection when scoring for Cast
 - [Revision 0.34.36](https://github.com/sinclairzx81/typebox/pull/1276)
   - Fix Record Intersect on Cast
 - [Revision 0.34.35](https://github.com/sinclairzx81/typebox/pull/1265)
diff --git a/package-lock.json b/package-lock.json
index 4b5499e44..b4eac3353 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.36",
+  "version": "0.34.37",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.36",
+      "version": "0.34.37",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 09380c4d0..6ebc41259 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.36",
+  "version": "0.34.37",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/cast/cast.ts b/src/value/cast/cast.ts
index 8b31f5771..86149da79 100644
--- a/src/value/cast/cast.ts
+++ b/src/value/cast/cast.ts
@@ -76,11 +76,10 @@ function ScoreUnion(schema: TSchema, references: TSchema[], value: any): number
       const exists = keys.includes(key) ? point : 0
       return acc + (literal + checks + exists)
     }, 0)
-  } else if (schema[Kind] === "Union") {
-    const schemas = schema.anyOf.map((schema: TSchema) =>
-      Deref(schema, references)
-    )
-    return  Math.max(...schemas.map((schema: TSchema) => ScoreUnion(schema, references, value)))
+  } else if (schema[Kind] === 'Union') {
+    const schemas = schema.anyOf.map((schema: TSchema) => Deref(schema, references))
+    const scores = schemas.map((schema: TSchema) => ScoreUnion(schema, references, value))
+    return Math.max(...scores)
   } else {
     return Check(schema, references, value) ? 1 : 0
   }
@@ -132,7 +131,7 @@ function FromArray(schema: TArray, references: TSchema[], value: any): any {
 function FromConstructor(schema: TConstructor, references: TSchema[], value: any): any {
   if (Check(schema, references, value)) return Create(schema, references)
   const required = new Set(schema.returns.required || [])
-  const result = function () { }
+  const result = function () {}
   for (const [key, property] of Object.entries(schema.returns.properties)) {
     if (!required.has(key) && value.prototype[key] === undefined) continue
     result.prototype[key] = Visit(property as TSchema, references, value.prototype[key])
diff --git a/test/runtime/value/cast/union.ts b/test/runtime/value/cast/union.ts
index ca73c089d..fa86fb0ba 100644
--- a/test/runtime/value/cast/union.ts
+++ b/test/runtime/value/cast/union.ts
@@ -166,43 +166,43 @@ describe('value/cast/Union', () => {
   // ref: https://github.com/sinclairzx81/typebox/issues/1268
   // ------------------------------------------------------------------------
   it('should correctly score nested union types #1', () => {
-    const A =
+    const A = Type.Union([
       Type.Union([
-        Type.Union([
-          Type.Object({
-            type: Type.Literal('a'),
-            name: Type.String(),
-            in: Type.String(),
-          }),
-          Type.Object({
-            type: Type.Literal('b'),
-            description: Type.Optional(Type.String()),
-            nested: Type.Object({
-              a: Type.String(),
-              b: Type.Optional(Type.String()),
-            }),
-          }),
-        ]),
         Type.Object({
-          $ref: Type.String(),
+          type: Type.Literal('a'),
+          name: Type.String(),
+          in: Type.String(),
+        }),
+        Type.Object({
+          type: Type.Literal('b'),
           description: Type.Optional(Type.String()),
+          nested: Type.Object({
+            a: Type.String(),
+            b: Type.Optional(Type.String()),
+          }),
         }),
-      ],
-
-      );
+      ]),
+      Type.Object({
+        $ref: Type.String(),
+        description: Type.Optional(Type.String()),
+      }),
+    ])
 
-    Assert.IsEqual(Value.Cast(A, {
-      type: 'b',
-      description: 'Hello World',
-      nested: {
-        b: 'hello',
+    Assert.IsEqual(
+      Value.Cast(A, {
+        type: 'b',
+        description: 'Hello World',
+        nested: {
+          b: 'hello',
+        },
+      }),
+      {
+        type: 'b',
+        description: 'Hello World',
+        nested: { a: '', b: 'hello' },
       },
-    }), {
-      type: 'b',
-      description: 'Hello World',
-      nested: { a: '', b: 'hello' },
-    });
-  });
+    )
+  })
 
   it('should correctly score nested union types #2', () => {
     const A = Type.Union([
@@ -216,7 +216,7 @@ describe('value/cast/Union', () => {
           prop1: Type.String(),
           prop4: Type.String(),
           prop5: Type.String(),
-        })
+        }),
       ]),
       Type.Union([
         Type.Object({
@@ -233,31 +233,40 @@ describe('value/cast/Union', () => {
     ])
 
     // Picks the first union variant when the score is equal
-    Assert.IsEqual(Value.Cast(A, {
-      prop1: ''
-    }), {
-      prop1: '',
-      prop2: '',
-      prop3: '',
-    });
+    Assert.IsEqual(
+      Value.Cast(A, {
+        prop1: '',
+      }),
+      {
+        prop1: '',
+        prop2: '',
+        prop3: '',
+      },
+    )
 
-    Assert.IsEqual(Value.Cast(A, {
-      prop1: '',
-      prop4: ''
-    }), {
-      prop1: '',
-      prop4: '',
-      prop5: '',
-    });
+    Assert.IsEqual(
+      Value.Cast(A, {
+        prop1: '',
+        prop4: '',
+      }),
+      {
+        prop1: '',
+        prop4: '',
+        prop5: '',
+      },
+    )
 
-    Assert.IsEqual(Value.Cast(A, {
-      prop6: '',
-    }), {
-      prop6: '',
-      prop7: '',
-      prop8: '',
-    });
-  });
+    Assert.IsEqual(
+      Value.Cast(A, {
+        prop6: '',
+      }),
+      {
+        prop6: '',
+        prop7: '',
+        prop8: '',
+      },
+    )
+  })
 
   it('should correctly score nested union types #3', () => {
     const A = Type.Union([
@@ -286,17 +295,20 @@ describe('value/cast/Union', () => {
       ]),
     ])
 
-    Assert.IsEqual(Value.Cast(A, {
-      prop1: '',
-      prop2: '',
-      prop7: ''
-    }), {
-      prop1: '',
-      prop2: '',
-      prop7: '',
-      prop8: '',
-    });
-  });
+    Assert.IsEqual(
+      Value.Cast(A, {
+        prop1: '',
+        prop2: '',
+        prop7: '',
+      }),
+      {
+        prop1: '',
+        prop2: '',
+        prop7: '',
+        prop8: '',
+      },
+    )
+  })
 
   it('should correctly score nested union types #4', () => {
     const A = Type.Union([
@@ -330,21 +342,24 @@ describe('value/cast/Union', () => {
               prop2: Type.String(),
               prop11: Type.String(),
               prop12: Type.String(),
-            })
-          ])
-        ])
+            }),
+          ]),
+        ]),
       ]),
     ])
 
-    Assert.IsEqual(Value.Cast(A, {
-      prop1: '',
-      prop2: '',
-      prop9: ''
-    }), {
-      prop1: '',
-      prop2: '',
-      prop9: '',
-      prop10: '',
-    });
+    Assert.IsEqual(
+      Value.Cast(A, {
+        prop1: '',
+        prop2: '',
+        prop9: '',
+      }),
+      {
+        prop1: '',
+        prop2: '',
+        prop9: '',
+        prop10: '',
+      },
+    )
   })
 })

From 97e315439690ef84f85d75cc9179163b2cd0e55a Mon Sep 17 00:00:00 2001
From: Ramtin Mesgari <26694963+iamramtin@users.noreply.github.com>
Date: Wed, 16 Jul 2025 03:06:34 +0200
Subject: [PATCH 364/369] Preserve exact type matches in union conversion
 (#1282)

Modify Value.Convert to check for exact type matches before attempting
conversion in union types. This prevents unnecessary type coercion when
the input value already matches one of the union schema types.

Fixes #1281

Signed-off-by: Ramtin Mesgari <26694963+iamramtin@users.noreply.github.com>
---
 src/value/convert/convert.ts        |  8 +++++++
 test/runtime/value/convert/union.ts | 37 +++++++++++++++++++++++++++++
 2 files changed, 45 insertions(+)

diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index 752ba37a4..7b183e599 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -243,6 +243,14 @@ function FromUndefined(schema: TUndefined, references: TSchema[], value: any): u
   return TryConvertUndefined(value)
 }
 function FromUnion(schema: TUnion, references: TSchema[], value: any): unknown {
+  // Check if original value already matches one of the union variants
+  for (const subschema of schema.anyOf) {
+    if (Check(subschema, references, value)) {
+      return value
+    }
+  }
+
+  // Attempt conversion for each variant
   for (const subschema of schema.anyOf) {
     const converted = Visit(subschema, references, Clone(value))
     if (!Check(subschema, references, converted)) continue
diff --git a/test/runtime/value/convert/union.ts b/test/runtime/value/convert/union.ts
index ef020b69a..fbf207702 100644
--- a/test/runtime/value/convert/union.ts
+++ b/test/runtime/value/convert/union.ts
@@ -40,4 +40,41 @@ describe('value/convert/Union', () => {
     Assert.IsEqual(B, { b: 1, c: 2 })
     Assert.IsEqual(C, { a: 1, b: '2', c: 3 }) // note: matching on first
   })
+  it('Should preserve number type in string-first union when value already matches', () => {
+    const T = Type.Union([Type.String(), Type.Number()])
+    const numValue = 42
+    const strValue = 'hello'
+
+    const A = Value.Convert(T, numValue)
+    const B = Value.Convert(T, strValue)
+
+    Assert.IsEqual(typeof A, 'number')
+    Assert.IsEqual(typeof B, 'string')
+    Assert.IsEqual(A, 42)
+    Assert.IsEqual(B, 'hello')
+  })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/1281
+  // Union conversion should preserve original type if valid
+  // ----------------------------------------------------------------
+  it('Should preserve original type when value already matches union variant', () => {
+    const T1 = Type.Object({
+      data: Type.Array(Type.Record(Type.String(), Type.Union([Type.String(), Type.Number(), Type.Null()]))),
+    })
+    const T2 = Type.Object({
+      data: Type.Array(Type.Record(Type.String(), Type.Union([Type.Number(), Type.String(), Type.Null()]))),
+    })
+    const testData = {
+      data: [{ key1: 'hello', key2: 42, key3: null }],
+    }
+
+    const A = Value.Convert(T1, testData)
+    const B = Value.Convert(T2, testData)
+
+    // Both should preserve the original number type
+    Assert.IsEqual(typeof (A as any).data[0].key2, 'number')
+    Assert.IsEqual(typeof (B as any).data[0].key2, 'number')
+    Assert.IsEqual((A as any).data[0].key2, 42)
+    Assert.IsEqual((B as any).data[0].key2, 42)
+  })
 })

From 60fdafe857089ac908b5fe7741c15c62260b651f Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Wed, 16 Jul 2025 11:45:37 +0900
Subject: [PATCH 365/369] Revision 0.34.38 (#1285)

* ChangeLog

* Version
---
 changelog/0.34.0.md | 2 ++
 package-lock.json   | 4 ++--
 package.json        | 2 +-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 2d8a0fe58..9efa8bfd8 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -3,6 +3,8 @@
 ---
 
 ### Revision Updates
+- [Revision 0.34.38](https://github.com/sinclairzx81/typebox/pull/1282)
+  - Preserve exact type matches in Union conversion
 - [Revision 0.34.37](https://github.com/sinclairzx81/typebox/pull/1278)
   - Fix Support nested Union selection when scoring for Cast
 - [Revision 0.34.36](https://github.com/sinclairzx81/typebox/pull/1276)
diff --git a/package-lock.json b/package-lock.json
index b4eac3353..2e670f791 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.37",
+  "version": "0.34.38",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.37",
+      "version": "0.34.38",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 6ebc41259..2f8ae4f38 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.37",
+  "version": "0.34.38",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

From c54a0f8c20372fff6789054d1d82287a0a13e161 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Fri, 15 Aug 2025 12:12:11 +0900
Subject: [PATCH 366/369] Revision 0.34.39 (#1296)

* Guard Array in Object Conversion

* Guard Array in Record Conversion

* Version | Changelog

* TypeScript 5.9.2
---
 changelog/0.34.0.md                 |  2 ++
 hammer.mjs                          |  2 +-
 package-lock.json                   | 18 +++++++++---------
 package.json                        |  4 ++--
 src/value/convert/convert.ts        |  4 ++--
 test/runtime/value/convert/union.ts | 22 ++++++++++++++++++++++
 6 files changed, 38 insertions(+), 14 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 9efa8bfd8..ac7e893ca 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -3,6 +3,8 @@
 ---
 
 ### Revision Updates
+- [Revision 0.34.39](https://github.com/sinclairzx81/typebox/pull/1296)
+  - Guard for Array in Object and Record conversion
 - [Revision 0.34.38](https://github.com/sinclairzx81/typebox/pull/1282)
   - Preserve exact type matches in Union conversion
 - [Revision 0.34.37](https://github.com/sinclairzx81/typebox/pull/1278)
diff --git a/hammer.mjs b/hammer.mjs
index 5bde41f39..7ed360b62 100644
--- a/hammer.mjs
+++ b/hammer.mjs
@@ -40,7 +40,7 @@ export async function test_typescript() {
     '5.2.2', '5.3.2', '5.3.3', '5.4.3', 
     '5.4.5', '5.5.2', '5.5.3', '5.5.4', 
     '5.6.2', '5.6.3', '5.7.2', '5.7.3', 
-    '5.8.2', 'next', 'latest'
+    '5.8.2', '5.8.3', 'next', 'latest'
   ]) {
     await shell(`npm install typescript@${version} --no-save`)
     await test_static()
diff --git a/package-lock.json b/package-lock.json
index 2e670f791..42240284a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.38",
+  "version": "0.34.39",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.38",
+      "version": "0.34.39",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
@@ -17,7 +17,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^11.1.0",
         "prettier": "^2.7.1",
-        "typescript": "^5.8.3"
+        "typescript": "^5.9.2"
       }
     },
     "node_modules/@andrewbranch/untar.js": {
@@ -1814,9 +1814,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.8.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
-      "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
+      "version": "5.9.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.2.tgz",
+      "integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -3226,9 +3226,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "5.8.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
-      "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
+      "version": "5.9.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.2.tgz",
+      "integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==",
       "dev": true
     },
     "undici-types": {
diff --git a/package.json b/package.json
index 2f8ae4f38..8c57dd0f4 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.38",
+  "version": "0.34.39",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -38,6 +38,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^11.1.0",
     "prettier": "^2.7.1",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.2"
   }
 }
diff --git a/src/value/convert/convert.ts b/src/value/convert/convert.ts
index 7b183e599..b23c0bba8 100644
--- a/src/value/convert/convert.ts
+++ b/src/value/convert/convert.ts
@@ -200,7 +200,7 @@ function FromNumber(schema: TNumber, references: TSchema[], value: any): unknown
 }
 // prettier-ignore
 function FromObject(schema: TObject, references: TSchema[], value: any): unknown {
-  if(!IsObject(value)) return value
+  if(!IsObject(value) || IsArray(value)) return value
   for(const propertyKey of Object.getOwnPropertyNames(schema.properties)) {
     if(!HasPropertyKey(value, propertyKey)) continue
     value[propertyKey] = Visit(schema.properties[propertyKey], references, value[propertyKey])
@@ -208,7 +208,7 @@ function FromObject(schema: TObject, references: TSchema[], value: any): unknown
   return value
 }
 function FromRecord(schema: TRecord, references: TSchema[], value: any): unknown {
-  const isConvertable = IsObject(value)
+  const isConvertable = IsObject(value) && !IsArray(value)
   if (!isConvertable) return value
   const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0]
   const property = schema.patternProperties[propertyKey]
diff --git a/test/runtime/value/convert/union.ts b/test/runtime/value/convert/union.ts
index fbf207702..03483da86 100644
--- a/test/runtime/value/convert/union.ts
+++ b/test/runtime/value/convert/union.ts
@@ -77,4 +77,26 @@ describe('value/convert/Union', () => {
     Assert.IsEqual((A as any).data[0].key2, 42)
     Assert.IsEqual((B as any).data[0].key2, 42)
   })
+  // ----------------------------------------------------------------
+  // https://github.com/sinclairzx81/typebox/issues/1295
+  // ----------------------------------------------------------------
+  it('Should guard against Array conversion in Object', () => {
+    const T = Type.Union([
+      Type.Object({
+        type: Type.Literal('A'),
+        values: Type.Union([Type.String(), Type.Number()]),
+      }),
+      Type.Object({
+        type: Type.Literal('B'),
+        values: Type.String(),
+      }),
+    ])
+    const converted = Value.Convert(T, [{ type: 'A', values: 1 }])
+    Assert.IsEqual(converted, [{ type: 'A', values: 1 }])
+  })
+  it('Should guard against Array conversion in Record', () => {
+    const T = Type.Union([Type.Record(Type.String({ pattern: '^values$' }), Type.Union([Type.String(), Type.Number()])), Type.Record(Type.String({ pattern: '^type$' }), Type.Union([Type.String(), Type.Number()]))])
+    const converted = Value.Convert(T, [{ type: 'A', values: 1 }])
+    Assert.IsEqual(converted, [{ type: 'A', values: 1 }])
+  })
 })

From 16f1d0a1652e40513d08e20686df11bae5c77bd1 Mon Sep 17 00:00:00 2001
From: Redis Stasa <91160178+DemonHa@users.noreply.github.com>
Date: Sat, 16 Aug 2025 23:16:14 -0400
Subject: [PATCH 367/369] Cast: Use Uniform over Reciprocal weighting on Union
 Select (#1293)

* fix: correctly score nested unions

* chore: add reference to the test cases
---
 src/value/cast/cast.ts           | 18 ++++----
 test/runtime/value/cast/union.ts | 70 ++++++++++++++++++++++++++++++++
 2 files changed, 78 insertions(+), 10 deletions(-)

diff --git a/src/value/cast/cast.ts b/src/value/cast/cast.ts
index 86149da79..01123fb70 100644
--- a/src/value/cast/cast.ts
+++ b/src/value/cast/cast.ts
@@ -57,23 +57,21 @@ export class ValueCastError extends TypeBoxError {
   }
 }
 // ------------------------------------------------------------------
-// The following will score a schema against a value. For objects,
-// the score is the tally of points awarded for each property of
-// the value. Property points are (1.0 / propertyCount) to prevent
-// large property counts biasing results. Properties that match
-// literal values are maximally awarded as literals are typically
-// used as union discriminator fields.
+// The following logic assigns a score to a schema based on how well it matches a given value.
+// For object types, the score is calculated by evaluating each property of the value against
+// the schema's properties. To avoid bias towards objects with many properties, each property
+// contributes equally to the total score. Properties that exactly match literal values receive
+// the highest possible score, as literals are often used as discriminators in union types.
 // ------------------------------------------------------------------
 function ScoreUnion(schema: TSchema, references: TSchema[], value: any): number {
   if (schema[Kind] === 'Object' && typeof value === 'object' && !IsNull(value)) {
     const object = schema as TObject
     const keys = Object.getOwnPropertyNames(value)
     const entries = Object.entries(object.properties)
-    const [point, max] = [1 / entries.length, entries.length]
     return entries.reduce((acc, [key, schema]) => {
-      const literal = schema[Kind] === 'Literal' && schema.const === value[key] ? max : 0
-      const checks = Check(schema, references, value[key]) ? point : 0
-      const exists = keys.includes(key) ? point : 0
+      const literal = schema[Kind] === 'Literal' && schema.const === value[key] ? 100 : 0
+      const checks = Check(schema, references, value[key]) ? 10 : 0
+      const exists = keys.includes(key) ? 1 : 0
       return acc + (literal + checks + exists)
     }, 0)
   } else if (schema[Kind] === 'Union') {
diff --git a/test/runtime/value/cast/union.ts b/test/runtime/value/cast/union.ts
index fa86fb0ba..dcc16ceef 100644
--- a/test/runtime/value/cast/union.ts
+++ b/test/runtime/value/cast/union.ts
@@ -362,4 +362,74 @@ describe('value/cast/Union', () => {
       },
     )
   })
+
+  // ------------------------------------------------------------------------
+  // ref: https://github.com/sinclairzx81/typebox/issues/1292
+  // ------------------------------------------------------------------------
+  it('should correctly score object unions with shared properties #1', () => {
+    const schema = Type.Union([
+      Type.Object({
+        summary: Type.Optional(Type.String()),
+        description: Type.Optional(Type.String()),
+        parameters: Type.Optional(Type.Array(Type.Any())),
+        responses: Type.Optional(Type.Record(Type.String(), Type.Any())),
+        requestBody: Type.Optional(Type.Any()),
+      }),
+      Type.Object({
+        $ref: Type.String(),
+        summary: Type.Optional(Type.String()),
+      }),
+    ])
+
+    Assert.IsEqual(
+      Value.Cast(schema, {
+        summary: 'Test Summary',
+        parameters: {},
+      }),
+      {
+        summary: 'Test Summary',
+        parameters: [],
+      },
+    )
+  })
+
+  it('should correctly score object unions with shared properties #2', () => {
+    const A = Type.Union([
+      Type.Object({
+        prop1: Type.String(),
+        prop2: Type.String(),
+        prop3: Type.String(),
+      }),
+      Type.Object({
+        prop1: Type.String(),
+        prop2: Type.String(),
+        prop4: Type.String(),
+        prop5: Type.String(),
+        prop6: Type.String(),
+        prop7: Type.String(),
+        prop8: Type.String(),
+        prop9: Type.String(),
+        prop10: Type.String(),
+      }),
+    ])
+
+    Assert.IsEqual(
+      Value.Cast(A, {
+        prop1: '',
+        prop2: '',
+        prop7: '',
+      }),
+      {
+        prop1: '',
+        prop2: '',
+        prop4: '',
+        prop5: '',
+        prop6: '',
+        prop7: '',
+        prop8: '',
+        prop9: '',
+        prop10: '',
+      },
+    )
+  })
 })

From 81c3686da5379dbc9562354e86f41c4c472eca50 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 17 Aug 2025 12:29:20 +0900
Subject: [PATCH 368/369] Revision 0.34.40 (#1298)

* ChangeLog

* Version

* Formatting
---
 changelog/0.34.0.md    |  2 ++
 package-lock.json      |  4 ++--
 package.json           |  2 +-
 src/value/cast/cast.ts | 12 +++++++-----
 4 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index ac7e893ca..364ee9309 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -3,6 +3,8 @@
 ---
 
 ### Revision Updates
+- [Revision 0.34.40](https://github.com/sinclairzx81/typebox/pull/1293)
+  - Use Uniform over Reciprocal weighting on Cast Union Select
 - [Revision 0.34.39](https://github.com/sinclairzx81/typebox/pull/1296)
   - Guard for Array in Object and Record conversion
 - [Revision 0.34.38](https://github.com/sinclairzx81/typebox/pull/1282)
diff --git a/package-lock.json b/package-lock.json
index 42240284a..ef0388b1d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.39",
+  "version": "0.34.40",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.39",
+      "version": "0.34.40",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index 8c57dd0f4..c4f790fcc 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.39",
+  "version": "0.34.40",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/value/cast/cast.ts b/src/value/cast/cast.ts
index 01123fb70..28fe3028f 100644
--- a/src/value/cast/cast.ts
+++ b/src/value/cast/cast.ts
@@ -57,11 +57,13 @@ export class ValueCastError extends TypeBoxError {
   }
 }
 // ------------------------------------------------------------------
-// The following logic assigns a score to a schema based on how well it matches a given value.
-// For object types, the score is calculated by evaluating each property of the value against
-// the schema's properties. To avoid bias towards objects with many properties, each property
-// contributes equally to the total score. Properties that exactly match literal values receive
-// the highest possible score, as literals are often used as discriminators in union types.
+// The following logic assigns a score to a schema based on how well
+// it matches a given value. For object types, the score is calculated
+// by evaluating each property of the value against the schema's
+// properties. To avoid bias towards objects with many properties,
+// each property contributes equally to the total score. Properties
+// that exactly match literal values receive the highest possible
+// score, as literals are often used as discriminators in union types.
 // ------------------------------------------------------------------
 function ScoreUnion(schema: TSchema, references: TSchema[], value: any): number {
   if (schema[Kind] === 'Object' && typeof value === 'object' && !IsNull(value)) {

From e0ec98c9dbbf6f6b8777f121a2da38f2d09cf2ed Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sat, 30 Aug 2025 04:14:00 +0900
Subject: [PATCH 369/369] Revision 0.34.41 (#1310)

* Update Module Resolution for TS7 Node10 Deprecation

* Version

* ChangeLog
---
 changelog/0.34.0.md                                | 2 ++
 package-lock.json                                  | 4 ++--
 package.json                                       | 2 +-
 task/build/cjs/compile.ts                          | 3 ++-
 task/build/esm/compile.ts                          | 1 +
 task/build/package/create-package-json-redirect.ts | 2 +-
 tsconfig.json                                      | 4 ++--
 7 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
index 364ee9309..db216fb8e 100644
--- a/changelog/0.34.0.md
+++ b/changelog/0.34.0.md
@@ -3,6 +3,8 @@
 ---
 
 ### Revision Updates
+- [Revision 0.34.41](https://github.com/sinclairzx81/typebox/pull/1310)
+  - Disable Node10 Module Resolution | TS7 Deprecation Warning.
 - [Revision 0.34.40](https://github.com/sinclairzx81/typebox/pull/1293)
   - Use Uniform over Reciprocal weighting on Cast Union Select
 - [Revision 0.34.39](https://github.com/sinclairzx81/typebox/pull/1296)
diff --git a/package-lock.json b/package-lock.json
index ef0388b1d..ed66a3f84 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.40",
+  "version": "0.34.41",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.34.40",
+      "version": "0.34.41",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index c4f790fcc..fc3c42e3b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.40",
+  "version": "0.34.41",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/task/build/cjs/compile.ts b/task/build/cjs/compile.ts
index c70aa0d6f..75bd85f59 100644
--- a/task/build/cjs/compile.ts
+++ b/task/build/cjs/compile.ts
@@ -33,7 +33,8 @@ export async function compile(target: string) {
   const options = [
     `--outDir ${target}`,
     '--target ES2020',
-    '--module CommonJS',
+    '--module Node16',
+    '--moduleResolution Node16',
     '--declaration',
   ].join(' ')
   await shell(`tsc -p ./src/tsconfig.json ${options}`)
diff --git a/task/build/esm/compile.ts b/task/build/esm/compile.ts
index 35a9d3722..6d88cfa27 100644
--- a/task/build/esm/compile.ts
+++ b/task/build/esm/compile.ts
@@ -34,6 +34,7 @@ export async function compile(target: string) {
     `--outDir ${target}`,
     '--target ES2020',
     '--module ESNext',
+    '--moduleResolution Bundler',
     '--declaration',
   ].join(' ')
   await shell(`tsc -p ./src/tsconfig.json ${options}`)
diff --git a/task/build/package/create-package-json-redirect.ts b/task/build/package/create-package-json-redirect.ts
index 298477082..5b17ef98a 100644
--- a/task/build/package/create-package-json-redirect.ts
+++ b/task/build/package/create-package-json-redirect.ts
@@ -38,7 +38,7 @@ function writeRedirect(target: string, submodule: string) {
 }
 // --------------------------------------------------------------------------------------------------------------------------
 // Builds redirect directories for earlier versions of Node. Note that TypeScript will use these directories to
-// resolve types when tsconfig.json is configured for `moduleResolution: 'node'`. This approach is referred to as
+// resolve types when tsconfig.json is configured for `moduleResolution: 'Node16'`. This approach is referred to as
 // `package-json-redirect` and enables correct type resolution in lieu of a correct end user configuration.
 //
 // https://github.com/andrewbranch/example-subpath-exports-ts-compat/tree/main/examples/node_modules/package-json-redirects
diff --git a/tsconfig.json b/tsconfig.json
index 786056048..80620ddf5 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -2,8 +2,8 @@
   "compilerOptions": {
     "strict": true,
     "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "Node",
+    "module": "Node16",
+    "moduleResolution": "Node16",
     "baseUrl": ".",
     "paths": {
       "@sinclair/typebox/compiler": ["src/compiler/index.ts"],